/** print one line with udb RR */
static void
print_udb_rr(uint8_t* name, udb_ptr* urr)
{
buffer_type buffer;
region_type* region = region_create(xalloc, free);
region_type* tmpregion = region_create(xalloc, free);
buffer_type* tmpbuffer = buffer_create(region, MAX_RDLENGTH);
rr_type rr;
ssize_t c;
domain_table_type* owners;
owners = domain_table_create(region);
rr.owner = domain_table_insert(owners, dname_make(region, name, 0));
/* to RR */
rr.type = RR(urr)->type;
rr.klass = RR(urr)->klass;
rr.ttl = RR(urr)->ttl;
buffer_create_from(&buffer, RR(urr)->wire, RR(urr)->len);
c = rdata_wireformat_to_rdata_atoms(region, owners, RR(urr)->type,
RR(urr)->len, &buffer, &rr.rdatas);
if(c == -1) {
printf("cannot parse wireformat\n");
region_destroy(region);
return;
}
rr.rdata_count = c;
print_rr(stdout, NULL, &rr, tmpregion, tmpbuffer);
region_destroy(region);
region_destroy(tmpregion);
}
static int
print_rrs(FILE* out, struct zone* zone)
{
rrset_type *rrset;
domain_type *domain = zone->apex;
region_type* region = region_create(xalloc, free);
region_type* rr_region = region_create(xalloc, free);
buffer_type* rr_buffer = buffer_create(region, MAX_RDLENGTH);
struct state_pretty_rr* state = create_pretty_rr(region);
/* first print the SOA record for the zone */
if(zone->soa_rrset) {
size_t i;
for(i=0; i < zone->soa_rrset->rr_count; i++) {
if(!print_rr(out, state, &zone->soa_rrset->rrs[i],
rr_region, rr_buffer)){
log_msg(LOG_ERR, "There was an error "
"printing SOARR to zone %s",
zone->opts->name);
region_destroy(region);
region_destroy(rr_region);
return 0;
}
}
}
/* go through entire tree below the zone apex (incl subzones) */
while(domain && domain_is_subdomain(domain, zone->apex))
{
for(rrset = domain->rrsets; rrset; rrset=rrset->next)
{
size_t i;
if(rrset->zone != zone || rrset == zone->soa_rrset)
continue;
for(i=0; i < rrset->rr_count; i++) {
if(!print_rr(out, state, &rrset->rrs[i],
rr_region, rr_buffer)){
log_msg(LOG_ERR, "There was an error "
"printing RR to zone %s",
zone->opts->name);
region_destroy(region);
region_destroy(rr_region);
return 0;
}
}
}
domain = domain_next(domain);
}
region_destroy(region);
region_destroy(rr_region);
return 1;
}
void ui_create_adv()
{
void* p_disp;
s32 ret;
rect_size_t rect_size = {0};
OS_PRINTF("ADV ui_create_adv \n");
p_disp = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_DISPLAY);
MT_ASSERT(NULL != p_disp);
rect_size.w = AD_SCREEN_WIDTH;
rect_size.h = AD_SCREEN_HEIGHT;
p_sub_rgn = region_create(&rect_size,PIX_FMT_ARGB8888);
MT_ASSERT(NULL != p_sub_rgn);
g_sub_pos.x = 0;
g_sub_pos.y = 0;
ret = disp_layer_add_region(p_disp, DISP_LAYER_ID_SUBTITL, p_sub_rgn, &g_sub_pos, NULL);
MT_ASSERT(SUCCESS == ret);
region_show(p_sub_rgn, TRUE);
disp_layer_alpha_onoff(p_disp, DISP_LAYER_ID_SUBTITL, TRUE);
region_alpha_onoff(p_sub_rgn, FALSE);
disp_layer_show(p_disp, DISP_LAYER_ID_SUBTITL, TRUE);
OS_PRINTF("ADV ui_create_adv end\n");
}
/** go ahead and read config, contact server and perform command and display */
static int
go(const char* cfgfile, char* svr, int argc, char* argv[])
{
struct nsd_options* opt;
int fd, ret;
SSL_CTX* ctx;
SSL* ssl;
/* read config */
if(!(opt = nsd_options_create(region_create(xalloc, free)))) {
fprintf(stderr, "out of memory\n");
exit(1);
}
tsig_init(opt->region);
if(!parse_options_file(opt, cfgfile, NULL, NULL)) {
fprintf(stderr, "could not read config file\n");
exit(1);
}
if(!opt->control_enable)
fprintf(stderr, "warning: control-enable is 'no' in the config file.\n");
ctx = setup_ctx(opt);
/* contact server */
fd = contact_server(svr, opt, argc>0&&strcmp(argv[0],"status")==0);
ssl = setup_ssl(ctx, fd);
/* send command */
ret = go_cmd(ssl, fd, argc, argv);
if(ssl) SSL_free(ssl);
close(fd);
if(ctx) SSL_CTX_free(ctx);
region_destroy(opt->region);
return ret;
}
/*
* The main server simply waits for signals and child processes to
* terminate. Child processes are restarted as necessary.
*/
void
server_main(struct nsd *nsd)
{
region_type *server_region = region_create(xalloc, free);
netio_handler_type xfrd_listener;
/* Ensure we are the main process */
assert(nsd->server_kind == NSD_SERVER_MAIN);
xfrd_listener.user_data = (struct ipc_handler_conn_data*)region_alloc(
server_region, sizeof(struct ipc_handler_conn_data));
xfrd_listener.fd = -1;
((struct ipc_handler_conn_data*)xfrd_listener.user_data)->nsd = nsd;
((struct ipc_handler_conn_data*)xfrd_listener.user_data)->conn =
xfrd_tcp_create(server_region);
nsd->pid = 0;
nsd->child_count = 0;
nsd->server_kind = NSD_SERVER_UDP;
nsd->this_child = &nsd->children[0];
/* remove signal flags inherited from parent
the parent will handle them. */
nsd->signal_hint_reload = 0;
nsd->signal_hint_child = 0;
nsd->signal_hint_quit = 0;
nsd->signal_hint_shutdown = 0;
nsd->signal_hint_stats = 0;
nsd->signal_hint_statsusr = 0;
close(nsd->this_child->child_fd);
nsd->this_child->child_fd = -1;
server_child(nsd);
abort();
}
void
region_test_truncate()
{
header();
struct region region;
region_create(®ion, &cache);
void *ptr = region_alloc(®ion, 10);
fail_unless(ptr);
size_t used = region_used(®ion);
region_alloc(®ion, 10000);
region_alloc(®ion, 10000000);
region_truncate(®ion, used);
fail_unless(region_used(®ion) == used);
region_free(®ion);
footer();
}
int main(int argc, char **argv)
{
region_t r;
int pc = 0, ret;
region_addr_t start, end, len;
while (1) {
switch (bcode_program[pc++]) {
case BCODE_END:
exit(0);
case BCODE_CREATE:
start = bcode_program[pc++];
end = bcode_program[pc++];
printf("Creating region with args(%d, %d)\n",
start, end);
r = region_create(start, end);
if (!r) {
fprintf(stderr, "Couldn't create region.\n");
exit(1);
}
break;
case BCODE_ALLOCATE:
start = bcode_program[pc++];
end = bcode_program[pc++];
ret = region_allocate(r, start, end);
printf("Region_allocate(%d, %d) returns %d\n",
start, end, ret);
break;
case BCODE_PRINT:
region_print(r, stdout);
break;
}
}
}
//static void *p_rgn_buf = NULL;
//static void * p_log_buf = NULL;
RET_CODE display_init(void)
{
RET_CODE ret;
rect_size_t rect_size;
point_t pos;
pos.x = 0;
pos.y = 0;
rect_size.h = REGION_HEIGHT;
rect_size.w = REGION_WIGHT;
p_disp = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_DISPLAY);
MT_ASSERT(NULL != p_disp);
p_gpe = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_GPE_VSB);
MT_ASSERT(NULL != p_gpe);
region = region_create(&rect_size, PIX_FMT_ARGB1555);
ret = disp_layer_add_region(p_disp, DISP_LAYER_ID_SUBTITL, region, &pos, NULL);
ret = region_show(region, TRUE);
KVDB_GRAPHIC_DEBUG("[%s][%d]ret:%d\n",__FUNCTION__, __LINE__, ret);
ret = disp_layer_show(p_disp, DISP_LAYER_ID_SUBTITL, TRUE);
KVDB_GRAPHIC_DEBUG("[%s][%d]ret:%d\n",__FUNCTION__, __LINE__, ret);
buf_logo= mtos_align_malloc(640*520*2, 8);
MT_ASSERT(buf_logo != NULL);
return 0;
}
static int
rdata_ipsecgateway_to_string(buffer_type *output, rdata_atom_type rdata, rr_type* rr)
{
int gateway_type = rdata_atom_data(rr->rdatas[1])[0];
switch(gateway_type) {
case IPSECKEY_NOGATEWAY:
buffer_printf(output, ".");
break;
case IPSECKEY_IP4:
rdata_a_to_string(output, rdata, rr);
break;
case IPSECKEY_IP6:
rdata_aaaa_to_string(output, rdata, rr);
break;
case IPSECKEY_DNAME:
{
region_type* temp = region_create(xalloc, free);
const dname_type* d = dname_make(temp,
rdata_atom_data(rdata), 0);
if(!d) {
region_destroy(temp);
return 0;
}
buffer_printf(output, "%s", dname_to_string(d, NULL));
region_destroy(temp);
}
break;
default:
return 0;
}
return 1;
}
void
sql_parser_create(struct Parse *parser, sql *db)
{
memset(parser, 0, sizeof(struct Parse));
parser->db = db;
rlist_create(&parser->record_list);
region_create(&parser->region, &cord()->slabc);
}
void
xfrd_handle_passed_packet(buffer_type* packet, int acl_num)
{
uint8_t qnamebuf[MAXDOMAINLEN];
uint16_t qtype, qclass;
const dname_type* dname;
region_type* tempregion = region_create(xalloc, free);
xfrd_zone_t* zone;
buffer_skip(packet, QHEADERSZ);
if(!packet_read_query_section(packet, qnamebuf, &qtype, &qclass)) {
region_destroy(tempregion);
return; /* drop bad packet */
}
dname = dname_make(tempregion, qnamebuf, 1);
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: got passed packet for %s, acl "
"%d", dname_to_string(dname,0), acl_num));
/* find the zone */
zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, dname);
if(!zone) {
log_msg(LOG_INFO, "xfrd: incoming packet for unknown zone %s",
dname_to_string(dname,0));
region_destroy(tempregion);
return; /* drop packet for unknown zone */
}
region_destroy(tempregion);
/* handle */
if(OPCODE(packet) == OPCODE_NOTIFY) {
xfrd_soa_t soa;
int have_soa = 0;
int next;
/* get serial from a SOA */
if(ANCOUNT(packet) == 1 && packet_skip_dname(packet) &&
xfrd_parse_soa_info(packet, &soa)) {
have_soa = 1;
}
if(xfrd_handle_incoming_notify(zone, have_soa?&soa:NULL)) {
if(zone->zone_handler.fd == -1
&& zone->tcp_conn == -1 &&
!zone->tcp_waiting && !zone->udp_waiting) {
xfrd_set_refresh_now(zone);
}
}
next = find_same_master_notify(zone, acl_num);
if(next != -1) {
zone->next_master = next;
DEBUG(DEBUG_XFRD,1, (LOG_INFO,
"xfrd: notify set next master to query %d",
next));
}
}
else {
/* TODO handle incoming IXFR udp reply via port 53 */
}
}
/* init rbtree tests */
static int init_rbtree(void)
{
/* is leaked */
reg = region_create(malloc, free);
if(reg == 0) return 1;
tree = rbtree_create(reg, testcompare);
if(tree == 0) return 1;
return 0;
}
/*ADV Region create */
static RET_CODE ui_adv_pic_region_init(const rect_t *rect)
{
rect_size_t rect_size = {0};
point_t pos;
RET_CODE ret = ERR_FAILURE;
void *p_region_buffer = NULL;
u32 region_block_size = 0;
u32 align = 0;
u32 region_size = 0;
void *p_disp_dev;
p_disp_dev = dev_find_identifier(NULL, DEV_IDT_TYPE, SYS_DEV_TYPE_DISPLAY);
//set coordinate
pos.x = rect->left;
pos.y = rect->top;
rect_size.w = ((u16)((rect->right - rect->left) + 7) >> 3) << 3; //must be multiple of 8
rect_size.h = (u16)(rect->bottom - rect->top);
if(pos.x+rect_size.w > SCREEN_WIDTH)
{
pos.x = SCREEN_WIDTH-rect_size.w;
}
if(pos.y+rect_size.h > SCREEN_HEIGHT)
{
pos.y = SCREEN_HEIGHT-rect_size.h;
}
DEBUG(ADS,INFO,"@@@region x=%d, y = %d, w = %d, h = %d \n",pos.x,pos.y,rect_size.w,rect_size.h);
region_block_size = SUB_BUFFER_SIZE;
MT_ASSERT(region_block_size != 0);
pic_adv_region = region_create(&rect_size, PIX_FMT_ARGB8888);
MT_ASSERT(NULL != pic_adv_region);
ret = disp_calc_region_size(p_disp_dev, DISP_LAYER_ID_SUBTITL, pic_adv_region, &align, ®ion_size);
DEBUG(ADS,INFO,"region_size=0x%x,region_block_size=0x%x\n",region_size,region_block_size);
if (ret != SUCCESS)
{
DEBUG(ADS,INFO,"disp_calc_region_size Failure!\n");
pic_adv_region = NULL;
return ERR_FAILURE;
}
MT_ASSERT(region_block_size >= region_size);
ret = disp_layer_add_region(p_disp_dev, DISP_LAYER_ID_SUBTITL,
pic_adv_region, &pos, p_region_buffer);
if(ret != SUCCESS)
{
DEBUG(ADS,INFO,"ui_adv_pic_region_init add region fail, LINE : %d!!!\n",__LINE__);
return ERR_FAILURE;
}
region_show(pic_adv_region, TRUE);
disp_layer_show(p_disp_dev, DISP_LAYER_ID_SUBTITL, TRUE);
return SUCCESS;
}
struct state_pretty_rr*
create_pretty_rr(struct region* region)
{
struct state_pretty_rr* state = (struct state_pretty_rr*)
region_alloc(region, sizeof(struct state_pretty_rr));
state->previous_owner_region = region_create(xalloc, free);
state->previous_owner = NULL;
state->previous_owner_origin = NULL;
region_add_cleanup(region, cleanup_region,
state->previous_owner_region);
return state;
}
/*
* setup parse
*/
void
zonec_setup_parser(namedb_type* db)
{
region_type* rr_region = region_create(xalloc, free);
parser = zparser_create(db->region, rr_region, db);
assert(parser);
/* Unique pointers used to mark errors. */
error_dname = (dname_type *) region_alloc(db->region, 1);
error_domain = (domain_type *) region_alloc(db->region, 1);
/* Open the network database */
setprotoent(1);
setservent(1);
}
void window_set_buffer(struct window *window, struct buffer* buffer) {
if (window->buffer) {
list_remove(window->buffer->marks, window->cursor);
free(window->cursor);
}
window->buffer = buffer;
window->top = 0;
window->left = 0;
window->cursor = region_create(0, 1);
window->incsearch_match = NULL;
list_append(buffer->marks, window->cursor);
}
/*
* Sprit region for the specified address/size.
*/
static struct region *
region_split(struct region *head, struct region *reg, void *addr,
size_t size)
{
struct region *prev, *next;
size_t diff;
/*
* Check previous region to split region.
*/
prev = NULL;
if (reg->addr != addr) {
prev = reg;
diff = (size_t)((char *)addr - (char *)reg->addr);
reg = region_create(prev, addr, prev->size - diff);
if (reg == NULL)
return NULL;
prev->size = diff;
}
/*
* Check next region to split region.
*/
if (reg->size != size) {
next = region_create(reg, (char *)reg->addr + size,
reg->size - size);
if (next == NULL) {
if (prev) {
/* Undo previous region_create() */
region_free(head, reg);
}
return NULL;
}
reg->size = size;
}
reg->flags = 0;
return reg;
}
static int
ts_init(void)
{
int rc = ts_reftable_init(&tss.rt);
if (rc == -1)
return -1;
ts_options_init(&tss.opts);
memset(&tss.s, 0, sizeof(tss.s));
tss.last_snap_lsn = 0;
tss.last_xlog_lsn = 0;
slab_cache_create(&tss.sc);
region_create(&tss.ra, &tss.sc);
return 0;
}
static struct diff_read_data*
diff_read_data_create()
{
region_type* region = region_create(xalloc, free);
struct diff_read_data* data = (struct diff_read_data*)
region_alloc(region, sizeof(struct diff_read_data));
if(!data) {
log_msg(LOG_ERR, "out of memory, %s:%d", __FILE__, __LINE__);
exit(1);
}
data->region = region;
data->zones = rbtree_create(region,
(int (*)(const void *, const void *)) dname_compare);
return data;
}
static int
do_map(vm_map_t map, void *addr, size_t size, void **alloc)
{
vm_map_t curmap;
task_t self;
char *start, *end;
struct region *reg, *tgt;
void *tmp;
if (size == 0)
return EINVAL;
/* check fault */
tmp = NULL;
if (umem_copyout(&tmp, alloc, sizeof(tmp)))
return EFAULT;
start = (char *)PAGE_TRUNC(addr);
end = (char *)PAGE_ALIGN((char *)addr + size);
size = (size_t)(end - start);
/*
* Find the region that includes target address
*/
reg = region_find(&map->head, start, size);
if (reg == NULL || (reg->flags & REG_FREE))
return EINVAL; /* not allocated */
tgt = reg;
/*
* Create new region to map
*/
self = cur_task();
curmap = self->map;
reg = region_create(&curmap->head, start, size);
if (reg == NULL)
return ENOMEM;
reg->flags = tgt->flags | REG_MAPPED;
umem_copyout(&addr, alloc, sizeof(addr));
return 0;
}
/*
* Reserve specific area for boot tasks.
*/
static int
do_reserve(vm_map_t map, void **addr, size_t size)
{
struct region *reg;
char *start, *end;
if (size == 0)
return EINVAL;
start = (char *)PAGE_TRUNC(*addr);
end = (char *)PAGE_ALIGN(start + size);
size = (size_t)(end - start);
reg = region_create(&map->head, start, size);
if (reg == NULL)
return ENOMEM;
reg->flags = REG_READ | REG_WRITE;
*addr = reg->addr;
return 0;
}
void
region_basic()
{
header();
struct region region;
region_create(®ion, &cache);
fail_unless(region_used(®ion) == 0);
void *ptr = region_alloc(®ion, 10);
fail_unless(ptr);
fail_unless(region_used(®ion) == 10);
ptr = region_alloc(®ion, 10000000);
fail_unless(ptr);
fail_unless(region_used(®ion) == 10000010);
region_free(®ion);
fail_unless(region_used(®ion) == 0);
printf("name of a new region: %s.\n", region_name(®ion));
region_set_name(®ion, "region");
printf("set new region name: %s.\n", region_name(®ion));
region_set_name(®ion, "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa");
printf("region name is truncated: %s.\n", region_name(®ion));
footer();
}
/*
* Allocate free region for specified size.
*/
static struct region *
region_alloc(struct region *head, size_t size)
{
struct region *reg;
reg = head;
do {
if ((reg->flags & REG_FREE) && reg->size >= size) {
if (reg->size != size) {
/* Split this region and return its head */
if (region_create(reg,
(char *)reg->addr + size,
reg->size - size) == NULL)
return NULL;
}
reg->size = size;
return reg;
}
reg = reg->next;
} while (reg != head);
return NULL;
}
/**
* Convert a duration to a time.
*
*/
time_t
duration2time(duration_type* duration)
{
time_t period = 0;
if (duration) {
period += (duration->seconds);
period += (duration->minutes)*60;
period += (duration->hours)*3600;
period += (duration->days)*86400;
period += (duration->weeks)*86400*7;
period += (duration->months)*86400*31;
period += (duration->years)*86400*365;
if (duration->months || duration->years) {
/* [TODO] calculate correct number of days in this month/year */
region_type* tmpregion = region_create();
char* dstr = duration2str(tmpregion, duration);
ods_log_warning("[%s] converting duration %s to approximate value",
logstr, dstr?dstr:"(null)");
region_cleanup(tmpregion);
}
}
return period;
}
static int
check_for_bad_serial(namedb_type* db, const char* zone_str, uint32_t old_serial)
{
/* see if serial OK with in-memory serial */
domain_type* domain;
region_type* region = region_create(xalloc, free);
const dname_type* zone_name = dname_parse(region, zone_str);
zone_type* zone = 0;
domain = domain_table_find(db->domains, zone_name);
if(domain)
zone = domain_find_zone(domain);
if(zone && zone->apex == domain && zone->soa_rrset && old_serial)
{
uint32_t memserial;
memcpy(&memserial, rdata_atom_data(zone->soa_rrset->rrs[0].rdatas[2]),
sizeof(uint32_t));
if(old_serial != ntohl(memserial)) {
region_destroy(region);
return 1;
}
}
region_destroy(region);
return 0;
}
static int
do_allocate(vm_map_t map, void **addr, size_t size, int anywhere)
{
struct region *reg;
char *start, *end;
if (size == 0)
return EINVAL;
/*
* Allocate region, and reserve pages for it.
*/
if (anywhere) {
size = (size_t)PAGE_ALIGN(size);
if ((start = page_alloc(size)) == 0)
return ENOMEM;
} else {
start = (char *)PAGE_TRUNC(*addr);
end = (char *)PAGE_ALIGN(start + size);
size = (size_t)(end - start);
if (page_reserve(start, size))
return EINVAL;
}
reg = region_create(&map->head, start, size);
if (reg == NULL) {
page_free(start, size);
return ENOMEM;
}
reg->flags = REG_READ | REG_WRITE;
/* Zero fill */
memset(start, 0, size);
*addr = reg->addr;
return 0;
}
int
main(int argc, char *argv[])
{
/* Scratch variables... */
int c;
pid_t oldpid;
size_t i;
struct sigaction action;
#ifdef HAVE_GETPWNAM
struct passwd *pwd = NULL;
#endif /* HAVE_GETPWNAM */
struct addrinfo hints[2];
int hints_in_use = 1;
char** nodes = NULL; /* array of address strings, size nsd.ifs */
const char *udp_port = 0;
const char *tcp_port = 0;
const char *configfile = CONFIGFILE;
char* argv0 = (argv0 = strrchr(argv[0], '/')) ? argv0 + 1 : argv[0];
log_init(argv0);
/* Initialize the server handler... */
memset(&nsd, 0, sizeof(struct nsd));
nsd.region = region_create(xalloc, free);
nsd.dbfile = 0;
nsd.pidfile = 0;
nsd.server_kind = NSD_SERVER_MAIN;
memset(&hints, 0, sizeof(*hints)*2);
hints[0].ai_family = DEFAULT_AI_FAMILY;
hints[0].ai_flags = AI_PASSIVE;
hints[1].ai_family = DEFAULT_AI_FAMILY;
hints[1].ai_flags = AI_PASSIVE;
nsd.identity = 0;
nsd.version = VERSION;
nsd.username = 0;
nsd.chrootdir = 0;
nsd.nsid = NULL;
nsd.nsid_len = 0;
nsd.child_count = 0;
nsd.maximum_tcp_count = 0;
nsd.current_tcp_count = 0;
nsd.grab_ip6_optional = 0;
nsd.file_rotation_ok = 0;
/* Set up our default identity to gethostname(2) */
if (gethostname(hostname, MAXHOSTNAMELEN) == 0) {
nsd.identity = hostname;
} else {
log_msg(LOG_ERR,
"failed to get the host name: %s - using default identity",
strerror(errno));
nsd.identity = IDENTITY;
}
/* Parse the command line... */
while ((c = getopt(argc, argv, "46a:c:df:hi:I:l:N:n:P:p:s:u:t:X:V:v"
#ifndef NDEBUG /* <mattthijs> only when configured with --enable-checking */
"F:L:"
#endif /* NDEBUG */
)) != -1) {
switch (c) {
case '4':
hints[0].ai_family = AF_INET;
break;
case '6':
#ifdef INET6
hints[0].ai_family = AF_INET6;
#else /* !INET6 */
error("IPv6 support not enabled.");
#endif /* INET6 */
break;
case 'a':
add_interface(&nodes, &nsd, optarg);
break;
case 'c':
configfile = optarg;
break;
case 'd':
nsd.debug = 1;
break;
case 'f':
nsd.dbfile = optarg;
break;
case 'h':
usage();
exit(0);
case 'i':
nsd.identity = optarg;
break;
case 'I':
if (nsd.nsid_len != 0) {
/* can only be given once */
break;
}
if (strncasecmp(optarg, "ascii_", 6) == 0) {
nsd.nsid = xalloc(strlen(optarg+6));
nsd.nsid_len = strlen(optarg+6);
memmove(nsd.nsid, optarg+6, nsd.nsid_len);
} else {
if (strlen(optarg) % 2 != 0) {
error("the NSID must be a hex string of an even length.");
}
nsd.nsid = xalloc(strlen(optarg) / 2);
nsd.nsid_len = strlen(optarg) / 2;
if (hex_pton(optarg, nsd.nsid, nsd.nsid_len) == -1) {
error("hex string cannot be parsed '%s' in NSID.", optarg);
}
}
break;
case 'l':
nsd.log_filename = optarg;
break;
case 'N':
i = atoi(optarg);
if (i <= 0) {
error("number of child servers must be greater than zero.");
} else {
nsd.child_count = i;
}
break;
case 'n':
i = atoi(optarg);
if (i <= 0) {
error("number of concurrent TCP connections must greater than zero.");
} else {
nsd.maximum_tcp_count = i;
}
break;
case 'P':
nsd.pidfile = optarg;
break;
case 'p':
if (atoi(optarg) == 0) {
error("port argument must be numeric.");
}
tcp_port = optarg;
udp_port = optarg;
break;
case 's':
#ifdef BIND8_STATS
nsd.st.period = atoi(optarg);
#else /* !BIND8_STATS */
error("BIND 8 statistics not enabled.");
#endif /* BIND8_STATS */
break;
case 't':
#ifdef HAVE_CHROOT
nsd.chrootdir = optarg;
#else /* !HAVE_CHROOT */
error("chroot not supported on this platform.");
#endif /* HAVE_CHROOT */
break;
case 'u':
nsd.username = optarg;
break;
case 'V':
verbosity = atoi(optarg);
break;
case 'v':
version();
/* version exits */
break;
#ifndef NDEBUG
case 'F':
sscanf(optarg, "%x", &nsd_debug_facilities);
break;
case 'L':
sscanf(optarg, "%d", &nsd_debug_level);
break;
#endif /* NDEBUG */
case '?':
default:
usage();
exit(1);
}
}
argc -= optind;
/* argv += optind; */
/* Commandline parse error */
if (argc != 0) {
usage();
exit(1);
}
if (strlen(nsd.identity) > UCHAR_MAX) {
error("server identity too long (%u characters)",
(unsigned) strlen(nsd.identity));
}
if(!tsig_init(nsd.region))
error("init tsig failed");
/* Read options */
nsd.options = nsd_options_create(region_create_custom(xalloc, free,
DEFAULT_CHUNK_SIZE, DEFAULT_LARGE_OBJECT_SIZE,
DEFAULT_INITIAL_CLEANUP_SIZE, 1));
if(!parse_options_file(nsd.options, configfile, NULL, NULL)) {
error("could not read config: %s\n", configfile);
}
if(!parse_zone_list_file(nsd.options)) {
error("could not read zonelist file %s\n",
nsd.options->zonelistfile);
}
if(nsd.options->do_ip4 && !nsd.options->do_ip6) {
hints[0].ai_family = AF_INET;
}
#ifdef INET6
if(nsd.options->do_ip6 && !nsd.options->do_ip4) {
hints[0].ai_family = AF_INET6;
}
#endif /* INET6 */
if(nsd.options->ip_addresses)
{
ip_address_option_type* ip = nsd.options->ip_addresses;
while(ip) {
add_interface(&nodes, &nsd, ip->address);
ip = ip->next;
}
}
if (verbosity == 0)
verbosity = nsd.options->verbosity;
#ifndef NDEBUG
if (nsd_debug_level > 0 && verbosity == 0)
verbosity = nsd_debug_level;
#endif /* NDEBUG */
if(nsd.options->debug_mode) nsd.debug=1;
if(!nsd.dbfile)
{
if(nsd.options->database)
nsd.dbfile = nsd.options->database;
else
nsd.dbfile = DBFILE;
}
if(!nsd.pidfile)
{
if(nsd.options->pidfile)
nsd.pidfile = nsd.options->pidfile;
else
nsd.pidfile = PIDFILE;
}
if(strcmp(nsd.identity, hostname)==0 || strcmp(nsd.identity,IDENTITY)==0)
{
if(nsd.options->identity)
nsd.identity = nsd.options->identity;
}
if(nsd.options->version) {
nsd.version = nsd.options->version;
}
if (nsd.options->logfile && !nsd.log_filename) {
nsd.log_filename = nsd.options->logfile;
}
if(nsd.child_count == 0) {
nsd.child_count = nsd.options->server_count;
}
#ifdef SO_REUSEPORT
if(nsd.options->reuseport && nsd.child_count > 1) {
nsd.reuseport = nsd.child_count;
}
#endif /* SO_REUSEPORT */
if(nsd.maximum_tcp_count == 0) {
nsd.maximum_tcp_count = nsd.options->tcp_count;
}
nsd.tcp_timeout = nsd.options->tcp_timeout;
nsd.tcp_query_count = nsd.options->tcp_query_count;
nsd.tcp_mss = nsd.options->tcp_mss;
nsd.outgoing_tcp_mss = nsd.options->outgoing_tcp_mss;
nsd.ipv4_edns_size = nsd.options->ipv4_edns_size;
nsd.ipv6_edns_size = nsd.options->ipv6_edns_size;
if(udp_port == 0)
{
if(nsd.options->port != 0) {
udp_port = nsd.options->port;
tcp_port = nsd.options->port;
} else {
udp_port = UDP_PORT;
tcp_port = TCP_PORT;
}
}
#ifdef BIND8_STATS
if(nsd.st.period == 0) {
nsd.st.period = nsd.options->statistics;
}
#endif /* BIND8_STATS */
#ifdef HAVE_CHROOT
if(nsd.chrootdir == 0) nsd.chrootdir = nsd.options->chroot;
#ifdef CHROOTDIR
/* if still no chrootdir, fallback to default */
if(nsd.chrootdir == 0) nsd.chrootdir = CHROOTDIR;
#endif /* CHROOTDIR */
#endif /* HAVE_CHROOT */
if(nsd.username == 0) {
if(nsd.options->username) nsd.username = nsd.options->username;
else nsd.username = USER;
}
if(nsd.options->zonesdir && nsd.options->zonesdir[0]) {
if(chdir(nsd.options->zonesdir)) {
error("cannot chdir to '%s': %s",
nsd.options->zonesdir, strerror(errno));
}
DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed directory to %s",
nsd.options->zonesdir));
}
/* EDNS0 */
edns_init_data(&nsd.edns_ipv4, nsd.options->ipv4_edns_size);
#if defined(INET6)
#if defined(IPV6_USE_MIN_MTU) || defined(IPV6_MTU)
edns_init_data(&nsd.edns_ipv6, nsd.options->ipv6_edns_size);
#else /* no way to set IPV6 MTU, send no bigger than that. */
if (nsd.options->ipv6_edns_size < IPV6_MIN_MTU)
edns_init_data(&nsd.edns_ipv6, nsd.options->ipv6_edns_size);
else
edns_init_data(&nsd.edns_ipv6, IPV6_MIN_MTU);
#endif /* IPV6 MTU) */
#endif /* defined(INET6) */
if (nsd.nsid_len == 0 && nsd.options->nsid) {
if (strlen(nsd.options->nsid) % 2 != 0) {
error("the NSID must be a hex string of an even length.");
}
nsd.nsid = xalloc(strlen(nsd.options->nsid) / 2);
nsd.nsid_len = strlen(nsd.options->nsid) / 2;
if (hex_pton(nsd.options->nsid, nsd.nsid, nsd.nsid_len) == -1) {
error("hex string cannot be parsed '%s' in NSID.", nsd.options->nsid);
}
}
edns_init_nsid(&nsd.edns_ipv4, nsd.nsid_len);
#if defined(INET6)
edns_init_nsid(&nsd.edns_ipv6, nsd.nsid_len);
#endif /* defined(INET6) */
/* Number of child servers to fork. */
nsd.children = (struct nsd_child *) region_alloc_array(
nsd.region, nsd.child_count, sizeof(struct nsd_child));
for (i = 0; i < nsd.child_count; ++i) {
nsd.children[i].kind = NSD_SERVER_BOTH;
nsd.children[i].pid = -1;
nsd.children[i].child_fd = -1;
nsd.children[i].parent_fd = -1;
nsd.children[i].handler = NULL;
nsd.children[i].need_to_send_STATS = 0;
nsd.children[i].need_to_send_QUIT = 0;
nsd.children[i].need_to_exit = 0;
nsd.children[i].has_exited = 0;
#ifdef BIND8_STATS
nsd.children[i].query_count = 0;
#endif
}
nsd.this_child = NULL;
/* We need at least one active interface */
if (nsd.ifs == 0) {
add_interface(&nodes, &nsd, NULL);
/*
* With IPv6 we'd like to open two separate sockets,
* one for IPv4 and one for IPv6, both listening to
* the wildcard address (unless the -4 or -6 flags are
* specified).
*
* However, this is only supported on platforms where
* we can turn the socket option IPV6_V6ONLY _on_.
* Otherwise we just listen to a single IPv6 socket
* and any incoming IPv4 connections will be
* automatically mapped to our IPv6 socket.
*/
#ifdef INET6
if (hints[0].ai_family == AF_UNSPEC) {
#ifdef IPV6_V6ONLY
add_interface(&nodes, &nsd, NULL);
hints[0].ai_family = AF_INET6;
hints[1].ai_family = AF_INET;
hints_in_use = 2;
nsd.grab_ip6_optional = 1;
#else /* !IPV6_V6ONLY */
hints[0].ai_family = AF_INET6;
#endif /* IPV6_V6ONLY */
}
#endif /* INET6 */
}
/* Set up the address info structures with real interface/port data */
assert(nodes);
for (i = 0; i < nsd.ifs; ++i) {
int r;
const char* node = NULL;
const char* service = NULL;
int h = ((hints_in_use == 1)?0:i%hints_in_use);
/* We don't perform name-lookups */
if (nodes[i] != NULL)
hints[h].ai_flags |= AI_NUMERICHOST;
get_ip_port_frm_str(nodes[i], &node, &service);
hints[h].ai_socktype = SOCK_DGRAM;
if ((r=getaddrinfo(node, (service?service:udp_port), &hints[h], &nsd.udp[i].addr)) != 0) {
#ifdef INET6
if(nsd.grab_ip6_optional && hints[0].ai_family == AF_INET6) {
log_msg(LOG_WARNING, "No IPv6, fallback to IPv4. getaddrinfo: %s",
r==EAI_SYSTEM?strerror(errno):gai_strerror(r));
continue;
}
#endif
error("cannot parse address '%s': getaddrinfo: %s %s",
nodes[i]?nodes[i]:"(null)",
gai_strerror(r),
r==EAI_SYSTEM?strerror(errno):"");
}
hints[h].ai_socktype = SOCK_STREAM;
if ((r=getaddrinfo(node, (service?service:tcp_port), &hints[h], &nsd.tcp[i].addr)) != 0) {
error("cannot parse address '%s': getaddrinfo: %s %s",
nodes[i]?nodes[i]:"(null)",
gai_strerror(r),
r==EAI_SYSTEM?strerror(errno):"");
}
}
/* Parse the username into uid and gid */
nsd.gid = getgid();
nsd.uid = getuid();
#ifdef HAVE_GETPWNAM
/* Parse the username into uid and gid */
if (*nsd.username) {
if (isdigit((unsigned char)*nsd.username)) {
char *t;
nsd.uid = strtol(nsd.username, &t, 10);
if (*t != 0) {
if (*t != '.' || !isdigit((unsigned char)*++t)) {
error("-u user or -u uid or -u uid.gid");
}
nsd.gid = strtol(t, &t, 10);
} else {
/* Lookup the group id in /etc/passwd */
if ((pwd = getpwuid(nsd.uid)) == NULL) {
error("user id %u does not exist.", (unsigned) nsd.uid);
} else {
nsd.gid = pwd->pw_gid;
}
}
} else {
/* Lookup the user id in /etc/passwd */
if ((pwd = getpwnam(nsd.username)) == NULL) {
error("user '%s' does not exist.", nsd.username);
} else {
nsd.uid = pwd->pw_uid;
nsd.gid = pwd->pw_gid;
}
}
}
/* endpwent(); */
#endif /* HAVE_GETPWNAM */
#if defined(HAVE_SSL)
key_options_tsig_add(nsd.options);
#endif
append_trailing_slash(&nsd.options->xfrdir, nsd.options->region);
/* Check relativity of pathnames to chroot */
if (nsd.chrootdir && nsd.chrootdir[0]) {
/* existing chrootdir: append trailing slash for strncmp checking */
append_trailing_slash(&nsd.chrootdir, nsd.region);
append_trailing_slash(&nsd.options->zonesdir, nsd.options->region);
/* zonesdir must be absolute and within chroot,
* all other pathnames may be relative to zonesdir */
if (strncmp(nsd.options->zonesdir, nsd.chrootdir, strlen(nsd.chrootdir)) != 0) {
error("zonesdir %s has to be an absolute path that starts with the chroot path %s",
nsd.options->zonesdir, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.pidfile, nsd.chrootdir)) {
error("pidfile %s is not relative to %s: chroot not possible",
nsd.pidfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.dbfile, nsd.chrootdir)) {
error("database %s is not relative to %s: chroot not possible",
nsd.dbfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.options->xfrdfile, nsd.chrootdir)) {
error("xfrdfile %s is not relative to %s: chroot not possible",
nsd.options->xfrdfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.options->zonelistfile, nsd.chrootdir)) {
error("zonelistfile %s is not relative to %s: chroot not possible",
nsd.options->zonelistfile, nsd.chrootdir);
} else if (!file_inside_chroot(nsd.options->xfrdir, nsd.chrootdir)) {
error("xfrdir %s is not relative to %s: chroot not possible",
nsd.options->xfrdir, nsd.chrootdir);
}
}
/* Set up the logging */
log_open(LOG_PID, FACILITY, nsd.log_filename);
if (!nsd.log_filename)
log_set_log_function(log_syslog);
else if (nsd.uid && nsd.gid) {
if(chown(nsd.log_filename, nsd.uid, nsd.gid) != 0)
VERBOSITY(2, (LOG_WARNING, "chown %s failed: %s",
nsd.log_filename, strerror(errno)));
}
log_msg(LOG_NOTICE, "%s starting (%s)", argv0, PACKAGE_STRING);
/* Do we have a running nsd? */
if ((oldpid = readpid(nsd.pidfile)) == -1) {
if (errno != ENOENT) {
log_msg(LOG_ERR, "can't read pidfile %s: %s",
nsd.pidfile, strerror(errno));
}
} else {
if (kill(oldpid, 0) == 0 || errno == EPERM) {
log_msg(LOG_WARNING,
"%s is already running as %u, continuing",
argv0, (unsigned) oldpid);
} else {
log_msg(LOG_ERR,
"...stale pid file from process %u",
(unsigned) oldpid);
}
}
/* Setup the signal handling... */
action.sa_handler = sig_handler;
sigfillset(&action.sa_mask);
action.sa_flags = 0;
sigaction(SIGTERM, &action, NULL);
sigaction(SIGHUP, &action, NULL);
sigaction(SIGINT, &action, NULL);
sigaction(SIGILL, &action, NULL);
sigaction(SIGUSR1, &action, NULL);
sigaction(SIGALRM, &action, NULL);
sigaction(SIGCHLD, &action, NULL);
action.sa_handler = SIG_IGN;
sigaction(SIGPIPE, &action, NULL);
/* Initialize... */
nsd.mode = NSD_RUN;
nsd.signal_hint_child = 0;
nsd.signal_hint_reload = 0;
nsd.signal_hint_reload_hup = 0;
nsd.signal_hint_quit = 0;
nsd.signal_hint_shutdown = 0;
nsd.signal_hint_stats = 0;
nsd.signal_hint_statsusr = 0;
nsd.quit_sync_done = 0;
/* Initialize the server... */
if (server_init(&nsd) != 0) {
error("server initialization failed, %s could "
"not be started", argv0);
}
#if defined(HAVE_SSL)
if(nsd.options->control_enable) {
/* read ssl keys while superuser and outside chroot */
if(!(nsd.rc = daemon_remote_create(nsd.options)))
error("could not perform remote control setup");
}
#endif /* HAVE_SSL */
/* Unless we're debugging, fork... */
if (!nsd.debug) {
int fd;
/* Take off... */
switch ((nsd.pid = fork())) {
case 0:
/* Child */
break;
case -1:
error("fork() failed: %s", strerror(errno));
break;
default:
/* Parent is done */
server_close_all_sockets(nsd.udp, nsd.ifs);
server_close_all_sockets(nsd.tcp, nsd.ifs);
exit(0);
}
/* Detach ourselves... */
if (setsid() == -1) {
error("setsid() failed: %s", strerror(errno));
}
if ((fd = open("/dev/null", O_RDWR, 0)) != -1) {
(void)dup2(fd, STDIN_FILENO);
(void)dup2(fd, STDOUT_FILENO);
(void)dup2(fd, STDERR_FILENO);
if (fd > 2)
(void)close(fd);
}
}
/* Get our process id */
nsd.pid = getpid();
/* Set user context */
#ifdef HAVE_GETPWNAM
if (*nsd.username) {
#ifdef HAVE_SETUSERCONTEXT
/* setusercontext does initgroups, setuid, setgid, and
* also resource limits from login config, but we
* still call setresuid, setresgid to be sure to set all uid */
if (setusercontext(NULL, pwd, nsd.uid,
LOGIN_SETALL & ~LOGIN_SETUSER & ~LOGIN_SETGROUP) != 0)
log_msg(LOG_WARNING, "unable to setusercontext %s: %s",
nsd.username, strerror(errno));
#endif /* HAVE_SETUSERCONTEXT */
}
#endif /* HAVE_GETPWNAM */
/* Chroot */
#ifdef HAVE_CHROOT
if (nsd.chrootdir && nsd.chrootdir[0]) {
int l = strlen(nsd.chrootdir)-1; /* ends in trailing slash */
if (file_inside_chroot(nsd.log_filename, nsd.chrootdir))
nsd.file_rotation_ok = 1;
/* strip chroot from pathnames if they're absolute */
nsd.options->zonesdir += l;
if (nsd.log_filename){
if (nsd.log_filename[0] == '/')
nsd.log_filename += l;
}
if (nsd.pidfile[0] == '/')
nsd.pidfile += l;
if (nsd.dbfile[0] == '/')
nsd.dbfile += l;
if (nsd.options->xfrdfile[0] == '/')
nsd.options->xfrdfile += l;
if (nsd.options->zonelistfile[0] == '/')
nsd.options->zonelistfile += l;
if (nsd.options->xfrdir[0] == '/')
nsd.options->xfrdir += l;
/* strip chroot from pathnames of "include:" statements
* on subsequent repattern commands */
cfg_parser->chroot = nsd.chrootdir;
#ifdef HAVE_TZSET
/* set timezone whilst not yet in chroot */
tzset();
#endif
if (chroot(nsd.chrootdir)) {
error("unable to chroot: %s", strerror(errno));
}
if (chdir("/")) {
error("unable to chdir to chroot: %s", strerror(errno));
}
DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed root directory to %s",
nsd.chrootdir));
/* chdir to zonesdir again after chroot */
if(nsd.options->zonesdir && nsd.options->zonesdir[0]) {
if(chdir(nsd.options->zonesdir)) {
error("unable to chdir to '%s': %s",
nsd.options->zonesdir, strerror(errno));
}
DEBUG(DEBUG_IPC,1, (LOG_INFO, "changed directory to %s",
nsd.options->zonesdir));
}
}
else
#endif /* HAVE_CHROOT */
nsd.file_rotation_ok = 1;
DEBUG(DEBUG_IPC,1, (LOG_INFO, "file rotation on %s %sabled",
nsd.log_filename, nsd.file_rotation_ok?"en":"dis"));
/* Write pidfile */
if (writepid(&nsd) == -1) {
log_msg(LOG_ERR, "cannot overwrite the pidfile %s: %s",
nsd.pidfile, strerror(errno));
}
/* Drop the permissions */
#ifdef HAVE_GETPWNAM
if (*nsd.username) {
#ifdef HAVE_INITGROUPS
if(initgroups(nsd.username, nsd.gid) != 0)
log_msg(LOG_WARNING, "unable to initgroups %s: %s",
nsd.username, strerror(errno));
#endif /* HAVE_INITGROUPS */
endpwent();
#ifdef HAVE_SETRESGID
if(setresgid(nsd.gid,nsd.gid,nsd.gid) != 0)
#elif defined(HAVE_SETREGID) && !defined(DARWIN_BROKEN_SETREUID)
if(setregid(nsd.gid,nsd.gid) != 0)
#else /* use setgid */
if(setgid(nsd.gid) != 0)
#endif /* HAVE_SETRESGID */
error("unable to set group id of %s: %s",
nsd.username, strerror(errno));
#ifdef HAVE_SETRESUID
if(setresuid(nsd.uid,nsd.uid,nsd.uid) != 0)
#elif defined(HAVE_SETREUID) && !defined(DARWIN_BROKEN_SETREUID)
if(setreuid(nsd.uid,nsd.uid) != 0)
#else /* use setuid */
if(setuid(nsd.uid) != 0)
#endif /* HAVE_SETRESUID */
error("unable to set user id of %s: %s",
nsd.username, strerror(errno));
DEBUG(DEBUG_IPC,1, (LOG_INFO, "dropped user privileges, run as %s",
nsd.username));
}
#endif /* HAVE_GETPWNAM */
xfrd_make_tempdir(&nsd);
#ifdef USE_ZONE_STATS
options_zonestatnames_create(nsd.options);
server_zonestat_alloc(&nsd);
#endif /* USE_ZONE_STATS */
#ifdef USE_DNSTAP
if(nsd.options->dnstap_enable) {
nsd.dt_collector = dt_collector_create(&nsd);
dt_collector_start(nsd.dt_collector, &nsd);
}
#endif /* USE_DNSTAP */
if(nsd.server_kind == NSD_SERVER_MAIN) {
server_prepare_xfrd(&nsd);
/* xfrd forks this before reading database, so it does not get
* the memory size of the database */
server_start_xfrd(&nsd, 0, 0);
/* close zonelistfile in non-xfrd processes */
zone_list_close(nsd.options);
}
if (server_prepare(&nsd) != 0) {
unlinkpid(nsd.pidfile);
error("server preparation failed, %s could "
"not be started", argv0);
}
if(nsd.server_kind == NSD_SERVER_MAIN) {
server_send_soa_xfrd(&nsd, 0);
}
/* Really take off */
log_msg(LOG_NOTICE, "%s started (%s), pid %d",
argv0, PACKAGE_STRING, (int) nsd.pid);
if (nsd.server_kind == NSD_SERVER_MAIN) {
server_main(&nsd);
} else {
server_child(&nsd);
}
/* NOTREACH */
exit(0);
}
ssize_t
rdata_wireformat_to_rdata_atoms(region_type *region,
domain_table_type *owners,
uint16_t rrtype,
uint16_t data_size,
buffer_type *packet,
rdata_atom_type **rdatas)
{
size_t end = buffer_position(packet) + data_size;
size_t i;
rdata_atom_type temp_rdatas[MAXRDATALEN];
rrtype_descriptor_type *descriptor = rrtype_descriptor_by_type(rrtype);
region_type *temp_region;
assert(descriptor->maximum <= MAXRDATALEN);
if (!buffer_available(packet, data_size)) {
return -1;
}
temp_region = region_create(xalloc, free);
for (i = 0; i < descriptor->maximum; ++i) {
int is_domain = 0;
int is_normalized = 0;
int is_wirestore = 0;
size_t length = 0;
int required = i < descriptor->minimum;
switch (rdata_atom_wireformat_type(rrtype, i)) {
case RDATA_WF_COMPRESSED_DNAME:
case RDATA_WF_UNCOMPRESSED_DNAME:
is_domain = 1;
is_normalized = 1;
break;
case RDATA_WF_LITERAL_DNAME:
is_domain = 1;
is_wirestore = 1;
break;
case RDATA_WF_BYTE:
length = sizeof(uint8_t);
break;
case RDATA_WF_SHORT:
length = sizeof(uint16_t);
break;
case RDATA_WF_LONG:
length = sizeof(uint32_t);
break;
case RDATA_WF_TEXTS:
case RDATA_WF_LONG_TEXT:
length = end - buffer_position(packet);
break;
case RDATA_WF_TEXT:
case RDATA_WF_BINARYWITHLENGTH:
/* Length is stored in the first byte. */
length = 1;
if (buffer_position(packet) + length <= end) {
length += buffer_current(packet)[length - 1];
}
break;
case RDATA_WF_A:
length = sizeof(in_addr_t);
break;
case RDATA_WF_AAAA:
length = IP6ADDRLEN;
break;
case RDATA_WF_ILNP64:
length = IP6ADDRLEN/2;
break;
case RDATA_WF_EUI48:
length = EUI48ADDRLEN;
break;
case RDATA_WF_EUI64:
length = EUI64ADDRLEN;
break;
case RDATA_WF_BINARY:
/* Remaining RDATA is binary. */
length = end - buffer_position(packet);
break;
case RDATA_WF_APL:
length = (sizeof(uint16_t) /* address family */
+ sizeof(uint8_t) /* prefix */
+ sizeof(uint8_t)); /* length */
if (buffer_position(packet) + length <= end) {
/* Mask out negation bit. */
length += (buffer_current(packet)[length - 1]
& APL_LENGTH_MASK);
}
break;
case RDATA_WF_IPSECGATEWAY:
switch(rdata_atom_data(temp_rdatas[1])[0]) /* gateway type */ {
default:
case IPSECKEY_NOGATEWAY:
length = 0;
break;
case IPSECKEY_IP4:
length = IP4ADDRLEN;
break;
case IPSECKEY_IP6:
length = IP6ADDRLEN;
break;
case IPSECKEY_DNAME:
is_domain = 1;
is_normalized = 1;
is_wirestore = 1;
break;
}
break;
}
if (is_domain) {
const dname_type *dname;
if (!required && buffer_position(packet) == end) {
break;
}
dname = dname_make_from_packet(
temp_region, packet, 1, is_normalized);
if (!dname || buffer_position(packet) > end) {
/* Error in domain name. */
region_destroy(temp_region);
return -1;
}
if(is_wirestore) {
temp_rdatas[i].data = (uint16_t *) region_alloc(
region, sizeof(uint16_t) + ((size_t)dname->name_size));
temp_rdatas[i].data[0] = dname->name_size;
memcpy(temp_rdatas[i].data+1, dname_name(dname),
dname->name_size);
} else {
temp_rdatas[i].domain
= domain_table_insert(owners, dname);
temp_rdatas[i].domain->usage ++;
}
} else {
if (buffer_position(packet) + length > end) {
if (required) {
/* Truncated RDATA. */
region_destroy(temp_region);
return -1;
} else {
break;
}
}
if (!required && buffer_position(packet) == end) {
break;
}
temp_rdatas[i].data = (uint16_t *) region_alloc(
region, sizeof(uint16_t) + length);
temp_rdatas[i].data[0] = length;
buffer_read(packet, temp_rdatas[i].data + 1, length);
}
}
if (buffer_position(packet) < end) {
/* Trailing garbage. */
region_destroy(temp_region);
return -1;
}
*rdatas = (rdata_atom_type *) region_alloc_array_init(
region, temp_rdatas, i, sizeof(rdata_atom_type));
region_destroy(temp_region);
return (ssize_t)i;
}
void
xfrd_read_state(struct xfrd_state* xfrd)
{
const char* statefile = xfrd->nsd->options->xfrdfile;
FILE *in;
uint32_t filetime = 0;
uint32_t numzones, i;
region_type *tempregion;
tempregion = region_create(xalloc, free);
if(!tempregion)
return;
in = fopen(statefile, "r");
if(!in) {
if(errno != ENOENT) {
log_msg(LOG_ERR, "xfrd: Could not open file %s for reading: %s",
statefile, strerror(errno));
} else {
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: no file %s. refreshing all zones.",
statefile));
}
region_destroy(tempregion);
return;
}
if(!xfrd_read_check_str(in, XFRD_FILE_MAGIC) ||
!xfrd_read_check_str(in, "filetime:") ||
!xfrd_read_i32(in, &filetime) ||
(time_t)filetime > xfrd_time()+15 ||
!xfrd_read_check_str(in, "numzones:") ||
!xfrd_read_i32(in, &numzones))
{
log_msg(LOG_ERR, "xfrd: corrupt state file %s dated %d (now=%lld)",
statefile, (int)filetime, (long long)xfrd_time());
fclose(in);
region_destroy(tempregion);
return;
}
for(i=0; i<numzones; i++) {
char *p;
xfrd_zone_t* zone;
const dname_type* dname;
uint32_t state, masnum, nextmas, round_num, timeout;
xfrd_soa_t soa_nsd_read, soa_disk_read, soa_notified_read;
time_t soa_nsd_acquired_read,
soa_disk_acquired_read, soa_notified_acquired_read;
xfrd_soa_t incoming_soa;
time_t incoming_acquired;
memset(&soa_nsd_read, 0, sizeof(soa_nsd_read));
memset(&soa_disk_read, 0, sizeof(soa_disk_read));
memset(&soa_notified_read, 0, sizeof(soa_notified_read));
if(!xfrd_read_check_str(in, "zone:") ||
!xfrd_read_check_str(in, "name:") ||
!(p=xfrd_read_token(in)) ||
!(dname = dname_parse(tempregion, p)) ||
!xfrd_read_check_str(in, "state:") ||
!xfrd_read_i32(in, &state) || (state>2) ||
!xfrd_read_check_str(in, "master:") ||
!xfrd_read_i32(in, &masnum) ||
!xfrd_read_check_str(in, "next_master:") ||
!xfrd_read_i32(in, &nextmas) ||
!xfrd_read_check_str(in, "round_num:") ||
!xfrd_read_i32(in, &round_num) ||
!xfrd_read_check_str(in, "next_timeout:") ||
!xfrd_read_i32(in, &timeout) ||
!xfrd_read_state_soa(in, "soa_nsd_acquired:", "soa_nsd:",
&soa_nsd_read, &soa_nsd_acquired_read) ||
!xfrd_read_state_soa(in, "soa_disk_acquired:", "soa_disk:",
&soa_disk_read, &soa_disk_acquired_read) ||
!xfrd_read_state_soa(in, "soa_notify_acquired:", "soa_notify:",
&soa_notified_read, &soa_notified_acquired_read))
{
log_msg(LOG_ERR, "xfrd: corrupt state file %s dated %d (now=%lld)",
statefile, (int)filetime, (long long)xfrd_time());
fclose(in);
region_destroy(tempregion);
return;
}
zone = (xfrd_zone_t*)rbtree_search(xfrd->zones, dname);
if(!zone) {
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: state file has info for not configured zone %s", p));
continue;
}
if(soa_nsd_acquired_read>xfrd_time()+15 ||
soa_disk_acquired_read>xfrd_time()+15 ||
soa_notified_acquired_read>xfrd_time()+15)
{
log_msg(LOG_ERR, "xfrd: statefile %s contains"
" times in the future for zone %s. Ignoring.",
statefile, zone->apex_str);
continue;
}
zone->state = state;
zone->master_num = masnum;
zone->next_master = nextmas;
zone->round_num = round_num;
zone->timeout.tv_sec = timeout;
zone->timeout.tv_usec = 0;
/* read the zone OK, now set the master properly */
zone->master = acl_find_num(zone->zone_options->pattern->
request_xfr, zone->master_num);
if(!zone->master) {
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: masters changed for zone %s",
zone->apex_str));
zone->master = zone->zone_options->pattern->request_xfr;
zone->master_num = 0;
zone->round_num = 0;
}
/*
* There is no timeout,
* or there is a notification,
* or there is a soa && current time is past refresh point
*/
if(timeout == 0 || soa_notified_acquired_read != 0 ||
(soa_disk_acquired_read != 0 &&
(uint32_t)xfrd_time() - soa_disk_acquired_read
> ntohl(soa_disk_read.refresh)))
{
zone->state = xfrd_zone_refreshing;
xfrd_set_refresh_now(zone);
}
/* There is a soa && current time is past expiry point */
if(soa_disk_acquired_read!=0 &&
(uint32_t)xfrd_time() - soa_disk_acquired_read
> ntohl(soa_disk_read.expire))
{
zone->state = xfrd_zone_expired;
xfrd_set_refresh_now(zone);
}
/* handle as an incoming SOA. */
incoming_soa = zone->soa_nsd;
incoming_acquired = zone->soa_nsd_acquired;
zone->soa_nsd = soa_nsd_read;
zone->soa_disk = soa_disk_read;
zone->soa_notified = soa_notified_read;
zone->soa_nsd_acquired = soa_nsd_acquired_read;
/* we had better use what we got from starting NSD, not
* what we store in this file, because the actual zone
* contents trumps the contents of this cache */
/* zone->soa_disk_acquired = soa_disk_acquired_read; */
zone->soa_notified_acquired = soa_notified_acquired_read;
xfrd_handle_incoming_soa(zone, &incoming_soa, incoming_acquired);
}
if(!xfrd_read_check_str(in, XFRD_FILE_MAGIC)) {
log_msg(LOG_ERR, "xfrd: corrupt state file %s dated %d (now=%lld)",
statefile, (int)filetime, (long long)xfrd_time());
region_destroy(tempregion);
fclose(in);
return;
}
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd: read %d zones from state file", (int)numzones));
fclose(in);
region_destroy(tempregion);
}
void
xfrd_init(int socket, struct nsd* nsd)
{
region_type* region;
assert(xfrd == 0);
/* to setup signalhandling */
nsd->server_kind = NSD_SERVER_BOTH;
region = region_create(xalloc, free);
xfrd = (xfrd_state_t*)region_alloc(region, sizeof(xfrd_state_t));
memset(xfrd, 0, sizeof(xfrd_state_t));
xfrd->region = region;
xfrd->xfrd_start_time = time(0);
xfrd->netio = netio_create(xfrd->region);
xfrd->nsd = nsd;
xfrd->packet = buffer_create(xfrd->region, QIOBUFSZ);
xfrd->udp_waiting_first = NULL;
xfrd->udp_waiting_last = NULL;
xfrd->udp_use_num = 0;
xfrd->ipc_pass = buffer_create(xfrd->region, QIOBUFSZ);
xfrd->parent_soa_info_pass = 0;
/* add the handlers already, because this involves allocs */
xfrd->reload_handler.fd = -1;
xfrd->reload_handler.timeout = NULL;
xfrd->reload_handler.user_data = xfrd;
xfrd->reload_handler.event_types = NETIO_EVENT_TIMEOUT;
xfrd->reload_handler.event_handler = xfrd_handle_reload;
xfrd->reload_timeout.tv_sec = 0;
xfrd->reload_cmd_last_sent = xfrd->xfrd_start_time;
xfrd->can_send_reload = 1;
xfrd->ipc_send_blocked = 0;
xfrd->ipc_handler.fd = socket;
xfrd->ipc_handler.timeout = NULL;
xfrd->ipc_handler.user_data = xfrd;
xfrd->ipc_handler.event_types = NETIO_EVENT_READ;
xfrd->ipc_handler.event_handler = xfrd_handle_ipc;
xfrd->ipc_conn = xfrd_tcp_create(xfrd->region);
/* not reading using ipc_conn yet */
xfrd->ipc_conn->is_reading = 0;
xfrd->ipc_conn->fd = xfrd->ipc_handler.fd;
xfrd->ipc_conn_write = xfrd_tcp_create(xfrd->region);
xfrd->ipc_conn_write->fd = xfrd->ipc_handler.fd;
xfrd->need_to_send_reload = 0;
xfrd->sending_zone_state = 0;
xfrd->dirty_zones = stack_create(xfrd->region,
nsd_options_num_zones(nsd->options));
xfrd->notify_waiting_first = NULL;
xfrd->notify_waiting_last = NULL;
xfrd->notify_udp_num = 0;
xfrd->tcp_set = xfrd_tcp_set_create(xfrd->region);
xfrd->tcp_set->tcp_timeout = nsd->tcp_timeout;
srandom((unsigned long) getpid() * (unsigned long) time(NULL));
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd pre-startup"));
diff_snip_garbage(nsd->db, nsd->options);
xfrd_init_zones();
xfrd_free_namedb();
xfrd_read_state(xfrd);
xfrd_send_expy_all_zones();
/* add handlers after zone handlers so they are before them in list */
netio_add_handler(xfrd->netio, &xfrd->reload_handler);
netio_add_handler(xfrd->netio, &xfrd->ipc_handler);
DEBUG(DEBUG_XFRD,1, (LOG_INFO, "xfrd startup"));
xfrd_main();
}
