Esempio n. 1
0
/**
 * Create query.
 *
 */
query_type*
query_create(void)
{
    allocator_type* allocator = NULL;
    query_type* q = NULL;
    allocator = allocator_create(malloc, free);
    if (!allocator) {
        return NULL;
    }
    q = (query_type*) allocator_alloc(allocator, sizeof(query_type));
    if (!q) {
        allocator_cleanup(allocator);
        return NULL;
    }
    q->allocator = allocator;
    q->buffer = NULL;
    q->tsig_rr = NULL;
    q->buffer = buffer_create(allocator, PACKET_BUFFER_SIZE);
    if (!q->buffer) {
        query_cleanup(q);
        return NULL;
    }
    q->tsig_rr = tsig_rr_create(allocator);
    if (!q->tsig_rr) {
        query_cleanup(q);
        return NULL;
    }
    q->edns_rr = edns_rr_create(allocator);
    if (!q->edns_rr) {
        query_cleanup(q);
        return NULL;
    }
    query_reset(q, UDP_MAX_MESSAGE_LEN, 0);
    return q;
}
/**
 * Create a new 'instant' duration.
 *
 */
duration_type*
duration_create(void)
{
    duration_type* duration;
    allocator_type* allocator = allocator_create(malloc, free);
    if (!allocator) {
        ods_log_error("[%s] cannot create: no allocator available",
            duration_str);
        return NULL;
    }

    duration = (duration_type*) allocator_alloc(allocator,
        sizeof(duration_type));
    if (!duration) {
        ods_log_error("[%s] cannot create: allocator failed", duration_str);
        allocator_cleanup(allocator);
        return NULL;
    }
    duration->allocator = allocator;
    duration->years = 0;
    duration->months = 0;
    duration->weeks = 0;
    duration->days = 0;
    duration->hours = 0;
    duration->minutes = 0;
    duration->seconds = 0;
    return duration;
}
Esempio n. 3
0
//*************************************************************************//
//* initialize the av heap.
//*************************************************************************//
int av_heap_init(int fd_ve)
{
    //* 1. allocate a heap context.
    if(heap_ctx != NULL)
    {
        loge("av heap context already initialized, return fail.");
        return -1;
    }

    heap_ctx = (heap_ctx_t*)malloc(sizeof(heap_ctx_t));
    if(heap_ctx == NULL)
    {
        loge("can not malloc memory for av heap context, return fail.");
        return -1;
    }

    memset(heap_ctx, 0, sizeof(heap_ctx_t));

    //* 2. initialize the mutex.
    if(pthread_mutex_init(&heap_ctx->mutex, NULL) != 0)
    {
        loge("can not initialize mutex for the av heap context, return fail.");

        free(heap_ctx);
        heap_ctx = NULL;

        return -1;
    }

    //* 3. open the driver.
    heap_ctx->fd = fd_ve;
    if(heap_ctx->fd == -1 || heap_ctx->fd == 0)
    {
        loge("file descriptor of driver '/dev/cedar_dev' is invalid, return fail.");

        pthread_mutex_destroy(&heap_ctx->mutex);
        free(heap_ctx);
        heap_ctx = NULL;

        return -1;
    }

    //* 4. get memory information.
    ioctl(heap_ctx->fd, IOCTL_GET_ENV_INFO, (unsigned int)&heap_ctx->env_info);

    //* 5. create a allocator.
    heap_ctx->allocator = allocator_create(heap_ctx->env_info.phymem_total_size);
    if(heap_ctx->allocator == NULL)
    {
        loge("can not create allocator for the heap context, return fail.");

        pthread_mutex_destroy(&heap_ctx->mutex);
        free(heap_ctx);
        heap_ctx = NULL;

        return -1;
    }

    return 0;
}
/*
 * Create an object allocator managing the root CNode's free slots
 */
static void
create_bootstrap_allocator(struct allocator *allocator)
{
    /* Fetch seL4 bootinfo. */
    seL4_BootInfo *bootinfo = seL4_GetBootInfo();

    /* Create the allocator. */
    allocator_create(
        allocator,
        seL4_CapInitThreadCNode,
        seL4_WordBits,
        0,
        bootinfo->empty.start,
        bootinfo->empty.end - bootinfo->empty.start,
        NULL,
        0
    );

    /* Give the allocator all of our free memory. */
    fill_allocator_with_resources(allocator, bootinfo);

#ifdef CONFIG_DEBUG_BUILD
    /* Test out everything. */
    allocator_self_test(allocator);
#endif
}
Esempio n. 5
0
int cpeer_create_out(int fd,struct net_client_t *nc)
{
	allocator_t *allocator;
	if(allocator_create(&allocator) < 0)
		return -1;

	struct cpeer *p = (struct cpeer *)mmalloc(nc->allocator,sizeof(struct cpeer));
	memset(p,0,sizeof(struct cpeer));
	p->sd = fd;
	p->id = 0;
	p->refcount = 0;
	p->status = CPEER_CONNECTED;
	p->nc = nc;
	p->allocator = allocator;
	thread_mutex_create(&(p->mpool_mutex),0);

	allocator_mutex_set(allocator,p->mpool_mutex);

	p->sendbuf = iobuf_init(p->allocator,512);
	p->recvbuf = iobuf_init(p->allocator,512);

	thread_mutex_create(&(p->sq_mutex),0);
	BTPDQ_INIT(&p->send_queue);

	nc->peer = p;

	fdev_new(nc->epfd,&p->ioev,fd,EV_READ,net_io_cb,p);
	return 0;
}
Esempio n. 6
0
/**
 * Create a new task.
 *
 */
task_type*
task_create(task_id what, time_t when, void* zone)
{
    allocator_type* allocator = NULL;
    task_type* task = NULL;

    if (!zone) {
        return NULL;
    }
    allocator = allocator_create(malloc, free);
    if (!allocator) {
        ods_log_error("[%s] unable to create task: allocator_create() failed",
            task_str);
        return NULL;
    }
    task = (task_type*) allocator_alloc(allocator, sizeof(task_type));
    if (!task) {
        ods_log_error("[%s] unable to create task: allocator_alloc() failed",
            task_str);
        allocator_cleanup(allocator);
        return NULL;
    }
    task->allocator = allocator;
    task->what = what;
    task->interrupt = TASK_NONE;
    task->halted = TASK_NONE;
    task->when = when;
    task->halted_when = 0;
    task->backoff = 0;
    task->flush = 0;
    task->zone = zone;
    return task;
}
Esempio n. 7
0
int display_matrix_init(void)
{
  if (!matrixdef_allocator) {
    matrixdef_allocator = allocator_create(256, sizeof(lua_matrix_def_t),
					   "mat_def");
  }
  if (!matrixref_allocator) {
    matrixref_allocator = allocator_create(256, sizeof(lua_matrix_t),
					   "mat_ref");
  }

  if (!matrixdef_allocator || !matrixref_allocator) {
    display_matrix_shutdown();
    return -1;
  }
  return 0;
}
Esempio n. 8
0
allocator_t* allocator_get_global() {
	static allocator_t* allocator = NULL;
	if (!allocator) {
		allocator = allocator_create();
		assert(allocator);
	}
	return allocator;
}
Esempio n. 9
0
int nc_connect(net_client_t **nc,const nc_arg_t *nc_arg)
{
	//忽略SIGPIPE 信号 
	struct sigaction sa;
	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;        
	sa.sa_handler = SIG_IGN;
	sigaction(SIGPIPE,&sa,NULL); 

	int rv,sd;
	rv = nc_nbconnect(&sd,nc_arg);
	if(rv < 0)
	    return -1;

	int on=1;
	setsockopt(sd, IPPROTO_TCP, TCP_NODELAY,(void *)&on,(socklen_t)sizeof(on));

	allocator_t *allocator;
	if(allocator_create(&allocator) < 0)
	{
	    close(sd);
	    return -1;
	}

	(*nc) = (net_client_t *)malloc(sizeof(net_client_t));
	memset((*nc),0,sizeof(net_client_t));

	thread_mutex_create(&((*nc)->mpool_mutex),0);
	allocator_mutex_set(allocator,(*nc)->mpool_mutex);

        (*nc)->allocator = allocator;

	queue_create(&((*nc)->recv_queue),C_MAX_QUEUE_CAPACITY);
//	BTPDQ_INIT(&(*nc)->recv_queue);
//	thread_mutex_create(&((*nc)->recv_mutex),0);

	thread_mutex_create(&((*nc)->peer_mutex),0);
	
	if(nc_arg->data_func)
		(*nc)->data_func = nc_arg->data_func;
	else
		(*nc)->data_func = default_process_func;

	if(nc_arg->msg_func)
		(*nc)->msg_func = nc_arg->msg_func;

	int epfd = evloop_init();
	(*nc)->epfd = epfd;
	cpeer_create_out(sd,*nc);

	pthread_t td;
	pthread_create(&td,NULL,&start_threads,(*nc));
	(*nc)->td_start = td;
	return 0;
}
Esempio n. 10
0
/**
 * Update zone list.
 *
 */
ods_status
zonelist_update(zonelist_type* zl, const char* zlfile)
{
    zonelist_type* new_zlist = NULL;
    allocator_type* tmp_alloc = NULL;
    time_t st_mtime = 0;
    ods_status status = ODS_STATUS_OK;
    char* datestamp = NULL;

    ods_log_debug("[%s] update zone list", zl_str);
    if (!zl|| !zl->zones || !zlfile) {
        return ODS_STATUS_ASSERT_ERR;
    }
    /* is the file updated? */
    st_mtime = ods_file_lastmodified(zlfile);
    if (st_mtime <= zl->last_modified) {
        (void)time_datestamp(zl->last_modified, "%Y-%m-%d %T", &datestamp);
        ods_log_debug("[%s] zonelist file %s is unchanged since %s",
                      zl_str, zlfile, datestamp?datestamp:"Unknown");
        free((void*)datestamp);
        return ODS_STATUS_UNCHANGED;
    }
    /* create new zonelist */
    tmp_alloc = allocator_create(malloc, free);
    if (!tmp_alloc) {
        return ODS_STATUS_MALLOC_ERR;
    }
    new_zlist = zonelist_create(tmp_alloc);
    if (!new_zlist) {
        ods_log_error("[%s] unable to update zonelist: zonelist_create() "
                      "failed", zl_str);
        allocator_cleanup(tmp_alloc);
        return ODS_STATUS_ERR;
    }
    /* read zonelist */
    status = zonelist_read(new_zlist, zlfile);
    if (status == ODS_STATUS_OK) {
        zl->just_removed = 0;
        zl->just_added = 0;
        zl->just_updated = 0;
        new_zlist->last_modified = st_mtime;
        zonelist_merge(zl, new_zlist);
        (void)time_datestamp(zl->last_modified, "%Y-%m-%d %T", &datestamp);
        ods_log_debug("[%s] file %s is modified since %s", zl_str, zlfile,
                      datestamp?datestamp:"Unknown");
        free((void*)datestamp);
    } else {
        ods_log_error("[%s] unable to update zonelist: read file %s failed "
                      "(%s)", zl_str, zlfile, ods_status2str(status));
    }
    zonelist_free(new_zlist);
    allocator_cleanup(tmp_alloc);
    return status;
}
Esempio n. 11
0
/**
 * Create engine.
 *
 */
static engine_type*
engine_create(void)
{
    engine_type* engine;
    allocator_type* allocator = allocator_create(malloc, free);
    if (!allocator) {
        ods_log_error("[%s] unable to create engine: allocator_create() "
            "failed", engine_str);
        return NULL;
    }
    engine = (engine_type*) allocator_alloc(allocator, sizeof(engine_type));
    if (!engine) {
        ods_log_error("[%s] unable to create engine: allocator_alloc() "
            "failed", engine_str);
        allocator_cleanup(allocator);
        return NULL;
    }
    engine->allocator = allocator;
    engine->config = NULL;
    engine->workers = NULL;
    engine->drudgers = NULL;
    engine->cmdhandler = NULL;
    engine->cmdhandler_done = 0;
    engine->dnshandler = NULL;
    engine->xfrhandler = NULL;
    engine->pid = -1;
    engine->uid = -1;
    engine->gid = -1;
    engine->daemonize = 0;
    engine->need_to_exit = 0;
    engine->need_to_reload = 0;
    lock_basic_init(&engine->signal_lock);
    lock_basic_set(&engine->signal_cond);
    lock_basic_lock(&engine->signal_lock);
    engine->signal = SIGNAL_INIT;
    lock_basic_unlock(&engine->signal_lock);
    engine->zonelist = zonelist_create(engine->allocator);
    if (!engine->zonelist) {
        engine_cleanup(engine);
        return NULL;
    }
    engine->taskq = schedule_create(engine->allocator);
    if (!engine->taskq) {
        engine_cleanup(engine);
        return NULL;
    }
    engine->signq = fifoq_create(engine->allocator);
    if (!engine->signq) {
        engine_cleanup(engine);
        return NULL;
    }
    return engine;
}
Esempio n. 12
0
/**
 * Create notify structure.
 *
 */
notify_type*
notify_create(void* xfrhandler, void* zone)
{
    notify_type* notify = NULL;
    allocator_type* allocator = NULL;
    if (!xfrhandler || !zone) {
        return NULL;
    }
    allocator = allocator_create(malloc, free);
    if (!allocator) {
        ods_log_error("[%s] unable to create notify structure: "
            "allocator_create() failed", notify_str);
        return NULL;
    }
    notify = (notify_type*) allocator_alloc(allocator, sizeof(notify_type));
    if (!notify) {
        ods_log_error("[%s] unable to create notify structure: "
            " allocator_alloc() failed", notify_str);
        allocator_cleanup(allocator);
        return NULL;
    }
    notify->allocator = allocator;
    notify->zone = zone;
    notify->xfrhandler = xfrhandler;
    notify->waiting_next = NULL;
    notify->secondary = NULL;
    notify->soa = NULL;
    notify->tsig_rr = tsig_rr_create(allocator);
    if (!notify->tsig_rr) {
        notify_cleanup(notify);
        return NULL;
    }
    notify->retry = 0;
    notify->query_id = 0;
    notify->is_waiting = 0;
    notify->handler.fd = -1;
    notify->timeout.tv_sec = 0;
    notify->timeout.tv_nsec = 0;
    notify->handler.timeout = NULL;
    notify->handler.user_data = notify;
    notify->handler.event_types =
        NETIO_EVENT_READ|NETIO_EVENT_TIMEOUT;
    notify->handler.event_handler = notify_handle_zone;
    return notify;
}
Esempio n. 13
0
/**
 * Main. start interface tool.
 *
 */
int
main(int argc, char* argv[])
{
    char* cmd = NULL;
    int ret = 0;
    allocator_type* clialloc = allocator_create(malloc, free);
    if (!clialloc) {
        fprintf(stderr,"error, malloc failed for client\n");
        exit(1);
    }

	/*	argv[0] is always the executable name so 
		argc is always 1 or higher */
	ods_log_assert(argc >= 1);
	
	/*	concat arguments an add 1 extra char for 
		adding '\n' char later on, but only when argc > 1 */
    cmd = ods_str_join(clialloc,argc-1,&argv[1],' ');

    if (argc > 1 && !cmd) {
        fprintf(stderr, "memory allocation failed\n");
        exit(1);
    }

    /* main stuff */
    if (!cmd) {
        ret = interface_start(cmd);
    } else {
        if (ods_strcmp(cmd, "-h") == 0 || ods_strcmp(cmd, "--help") == 0) {
            usage(stdout);
            ret = 1;
        } else {
            strcat(cmd,"\n");
            ret = interface_start(cmd);
        }
    }

    /* done */
    allocator_deallocate(clialloc, (void*) cmd);
    allocator_cleanup(clialloc);
    return ret;
}
Esempio n. 14
0
/**
 * Create engine.
 *
 */
static engine_type*
engine_create(void)
{
    engine_type* engine;
    allocator_type* allocator = allocator_create(malloc, free);
    if (!allocator) {
        return NULL;
    }
    engine = (engine_type*) allocator_alloc(allocator, sizeof(engine_type));
    if (!engine) {
        allocator_cleanup(allocator);
        return NULL;
    }
    engine->allocator = allocator;
    engine->config = NULL;
    engine->workers = NULL;
    engine->drudgers = NULL;
    engine->cmdhandler = NULL;
    engine->cmdhandler_done = 0;
    engine->pid = -1;
    engine->uid = -1;
    engine->gid = -1;
    engine->daemonize = 0;
    engine->need_to_exit = 0;
    engine->need_to_reload = 0;

    engine->signal = SIGNAL_INIT;
    lock_basic_init(&engine->signal_lock);
    lock_basic_set(&engine->signal_cond);

    engine->taskq = schedule_create(engine->allocator);
    if (!engine->taskq) {
        engine_cleanup(engine);
        return NULL;
    }
    engine->signq = fifoq_create(engine->allocator);
    if (!engine->signq) {
        engine_cleanup(engine);
        return NULL;
    }
    return engine;
}
Esempio n. 15
0
/**
 * Create DNS output adapter.
 *
 */
dnsout_type*
dnsout_create(void)
{
    dnsout_type* addns = NULL;
    allocator_type* allocator = allocator_create(malloc, free);
    if (!allocator) {
        ods_log_error("[%s] unable to create dnsout: allocator_create() "
                      " failed", adapter_str);
        return NULL;
    }
    addns = (dnsout_type*) allocator_alloc(allocator, sizeof(dnsout_type));
    if (!addns) {
        ods_log_error("[%s] unable to create dnsout: allocator_alloc() "
                      " failed", adapter_str);
        allocator_cleanup(allocator);
        return NULL;
    }
    addns->allocator = allocator;
    addns->provide_xfr = NULL;
    addns->do_notify = NULL;
    addns->tsig = NULL;
    return addns;
}
Esempio n. 16
0
int peer_create_in(int fd,struct sockaddr_in addr,struct net_server_t *ns)
{
	allocator_t *allocator;
	if(allocator_create(&allocator) < 0)
		return -1;

	struct peer *p = (struct peer *)mmalloc(ns->allocator,sizeof(struct peer));
	memset(p,0,sizeof(struct peer));
	p->sd = fd;
	gen_peerid(ns,&p->id);
	p->refcount = 0;
	p->status = PEER_CONNECTED;
	p->ns = ns;
	p->addr = addr;
	p->allocator = allocator;
	thread_mutex_create(&(p->mpool_mutex),0);

	allocator_mutex_set(allocator,p->mpool_mutex);

	p->sendbuf = iobuf_init(p->allocator,512);
	p->recvbuf = iobuf_init(p->allocator,512);

	thread_mutex_create(&(p->sq_mutex),0);
	BTPDQ_INIT(&p->send_queue);

	thread_mutex_lock(ns->ptbl_mutex);
	ptbl_insert(ns->ptbl,p);
	ns->npeers++;
	thread_mutex_unlock(ns->ptbl_mutex);

	fdev_new(ns->epfd,&p->ioev,fd,EV_READ,net_io_cb,p);

    char *peer_ip = inet_ntoa(p->addr.sin_addr);
    log_error(ns->log,"ns accept new connection from:%s.",peer_ip);
	return 0;
}
Esempio n. 17
0
/**
 * Create a new zone.
 *
 */
zone_type*
zone_create(char* name, ldns_rr_class klass)
{
    allocator_type* allocator = NULL;
    zone_type* zone = NULL;

    if (!name || !klass) {
        return NULL;
    }
    allocator = allocator_create(malloc, free);
    if (!allocator) {
        ods_log_error("[%s] unable to create zone %s: allocator_create() "
            "failed", zone_str, name);
        return NULL;
    }
    zone = (zone_type*) allocator_alloc(allocator, sizeof(zone_type));
    if (!zone) {
        ods_log_error("[%s] unable to create zone %s: allocator_alloc()",
            "failed", zone_str, name);
        allocator_cleanup(allocator);
        return NULL;
    }
    zone->allocator = allocator;
    /* [start] PS 9218653: Drop trailing dot in domain name */
    if (strlen(name) > 1 && name[strlen(name)-1] == '.') {
        name[strlen(name)-1] = '\0';
    }
    /* [end] PS 9218653 */
    zone->name = allocator_strdup(allocator, name);
    if (!zone->name) {
        ods_log_error("[%s] unable to create zone %s: allocator_strdup() "
            "failed", zone_str, name);
        zone_cleanup(zone);
        return NULL;
    }
    zone->klass = klass;
    zone->default_ttl = 3600; /* TODO: configure --default-ttl option? */
    zone->apex = ldns_dname_new_frm_str(name);
    /* check zone->apex? */
    zone->notify_command = NULL;
    zone->notify_ns = NULL;
    zone->notify_args = NULL;
    zone->policy_name = NULL;
    zone->signconf_filename = NULL;
    zone->adinbound = NULL;
    zone->adoutbound = NULL;
    zone->zl_status = ZONE_ZL_OK;
    zone->task = NULL;
    zone->xfrd = NULL;
    zone->notify = NULL;
    zone->db = namedb_create((void*)zone);
    if (!zone->db) {
        ods_log_error("[%s] unable to create zone %s: namedb_create() "
            "failed", zone_str, name);
        zone_cleanup(zone);
        return NULL;
    }
    zone->ixfr = ixfr_create((void*)zone);
    if (!zone->ixfr) {
        ods_log_error("[%s] unable to create zone %s: ixfr_create() "
            "failed", zone_str, name);
        zone_cleanup(zone);
        return NULL;
    }
    zone->signconf = signconf_create();
    if (!zone->signconf) {
        ods_log_error("[%s] unable to create zone %s: signconf_create() "
            "failed", zone_str, name);
        zone_cleanup(zone);
        return NULL;
    }
    zone->stats = stats_create();
    lock_basic_init(&zone->zone_lock);
    lock_basic_init(&zone->xfr_lock);
    return zone;
}