struct ub_ctx*
ub_ctx_create(void)
{
struct ub_ctx* ctx = ub_ctx_create_nopipe();
if(!ctx)
return NULL;
if((ctx->qq_pipe = tube_create()) == NULL) {
int e = errno;
ub_randfree(ctx->seed_rnd);
config_delete(ctx->env->cfg);
modstack_desetup(&ctx->mods, ctx->env);
free(ctx->env);
free(ctx);
errno = e;
return NULL;
}
if((ctx->rr_pipe = tube_create()) == NULL) {
int e = errno;
tube_delete(ctx->qq_pipe);
ub_randfree(ctx->seed_rnd);
config_delete(ctx->env->cfg);
modstack_desetup(&ctx->mods, ctx->env);
free(ctx->env);
free(ctx);
errno = e;
return NULL;
}
return ctx;
}
CTEST2(tube, utilities)
{
tube *t;
spud_tube_id *id;
int local_data = 1337;
int *out;
char buf[24];
char buf2[24];
ASSERT_TRUE(tube_manager_running(data->mgr));
ASSERT_EQUAL(tube_manager_size(data->mgr), 0);
ASSERT_TRUE( tube_create(&t, &data->err));
tube_set_data(t, &local_data);
out = tube_get_data(t);
ASSERT_EQUAL(*out, 1337);
ASSERT_EQUAL(tube_get_state(t), TS_UNKNOWN);
tube_get_id(t, &id);
spud_id_to_string(buf, sizeof(buf), id);
ASSERT_TRUE( tube_id_to_string(t, buf2, sizeof(buf2)) == buf2);
ASSERT_STR(buf, buf2);
ASSERT_TRUE(tube_manager_stop(data->mgr, &data->err));
ASSERT_FALSE(tube_manager_running(data->mgr));
}
CTEST2(tube, print)
{
tube *t;
ASSERT_TRUE( tube_create(&t, &data->err));
ASSERT_TRUE( tube_print(t, &data->err));
tube_destroy(t);
}
static bool _oom_test(ls_err *err)
{
tube *t;
if (!tube_create(&t, err)) {
return false;
}
tube_destroy(t);
return true;
}
CTEST2(tube, print_tubes)
{
tube *t;
spud_tube_id id;
ASSERT_TRUE( tube_create(&t, &data->err) );
tube_set_info(t, -1, NULL, NULL);
ASSERT_TRUE(spud_create_id(&id, &data->err));
tube_set_info(t, -1, NULL, &id);
ASSERT_TRUE(tube_manager_add(data->mgr, t, &data->err));
tube_manager_print_tubes(data->mgr);
}
CTEST2(tube, manager_foreach)
{
tube * tubes[TMGR_FOREACH_NUMTUBES];
spud_tube_id ids[TMGR_FOREACH_NUMTUBES];
for (int i = 0; i < TMGR_FOREACH_NUMTUBES; ++i) {
ASSERT_TRUE(tube_create(&tubes[i], &data->err));
ASSERT_TRUE(spud_create_id(&ids[i], &data->err));
tube_set_info(tubes[i], -1, NULL, &ids[i]);
ASSERT_TRUE(tube_manager_add(data->mgr, tubes[i], &data->err));
}
int num_tubes = 0;
tube_manager_foreach(data->mgr, _mock_tube_walker, (void *) &num_tubes);
ASSERT_TRUE(num_tubes == TMGR_FOREACH_NUMTUBES);
}
CTEST2(tube_stream, bind)
{
tube_stream *s;
tube *t;
bool retval;
tube_create(&t, &data->err);
tube_stream_create(&s, &data->err);
retval = tube_stream_bind(s, t, &data->err);
ASSERT_FALSE( retval );
ASSERT_EQUAL( data->err.code, LS_ERR_NO_IMPL );
tube_stream_destroy(s);
tube_destroy(t);
}
struct ub_ctx*
ub_ctx_create(void)
{
struct ub_ctx* ctx;
unsigned int seed;
#ifdef USE_WINSOCK
int r;
WSADATA wsa_data;
#endif
log_init(NULL, 0, NULL); /* logs to stderr */
log_ident_set("libunbound");
#ifdef USE_WINSOCK
if((r = WSAStartup(MAKEWORD(2,2), &wsa_data)) != 0) {
log_err("could not init winsock. WSAStartup: %s",
wsa_strerror(r));
return NULL;
}
#endif
verbosity = 0; /* errors only */
checklock_start();
ctx = (struct ub_ctx*)calloc(1, sizeof(*ctx));
if(!ctx) {
errno = ENOMEM;
return NULL;
}
alloc_init(&ctx->superalloc, NULL, 0);
seed = (unsigned int)time(NULL) ^ (unsigned int)getpid();
if(!(ctx->seed_rnd = ub_initstate(seed, NULL))) {
seed = 0;
ub_randfree(ctx->seed_rnd);
free(ctx);
errno = ENOMEM;
return NULL;
}
seed = 0;
if((ctx->qq_pipe = tube_create()) == NULL) {
int e = errno;
ub_randfree(ctx->seed_rnd);
free(ctx);
errno = e;
return NULL;
}
if((ctx->rr_pipe = tube_create()) == NULL) {
int e = errno;
tube_delete(ctx->qq_pipe);
ub_randfree(ctx->seed_rnd);
free(ctx);
errno = e;
return NULL;
}
lock_basic_init(&ctx->qqpipe_lock);
lock_basic_init(&ctx->rrpipe_lock);
lock_basic_init(&ctx->cfglock);
ctx->env = (struct module_env*)calloc(1, sizeof(*ctx->env));
if(!ctx->env) {
tube_delete(ctx->qq_pipe);
tube_delete(ctx->rr_pipe);
ub_randfree(ctx->seed_rnd);
free(ctx);
errno = ENOMEM;
return NULL;
}
ctx->env->cfg = config_create_forlib();
if(!ctx->env->cfg) {
tube_delete(ctx->qq_pipe);
tube_delete(ctx->rr_pipe);
free(ctx->env);
ub_randfree(ctx->seed_rnd);
free(ctx);
errno = ENOMEM;
return NULL;
}
ctx->env->alloc = &ctx->superalloc;
ctx->env->worker = NULL;
ctx->env->need_to_validate = 0;
modstack_init(&ctx->mods);
rbtree_init(&ctx->queries, &context_query_cmp);
return ctx;
}
CTEST2(tube, create)
{
tube *t;
ASSERT_TRUE( tube_create(&t, &data->err) );
tube_destroy(t);
}
static int
markov()
{
struct timespec timer;
struct timespec remaining;
tube* t;
ls_err err;
int i;
int* iptr;
timer.tv_sec = 0;
while ( tube_manager_running(mgr) )
{
timer.tv_nsec = gauss(50000000, 10000000);
nanosleep(&timer, &remaining);
i = random() % NUM_TUBES;
t = tubes[i];
if (!t)
{
if ( !tube_create(&t, &err) )
{
LS_LOG_ERR(err, "tube_create");
return 1;
}
tubes[i] = t;
iptr = malloc( sizeof(*iptr) );
*iptr = i;
tube_set_data(t, iptr);
}
switch ( tube_get_state(t) )
{
case TS_START:
ls_log(LS_LOG_ERROR, "invalid tube state");
return 1;
case TS_UNKNOWN:
if ( !tube_manager_open_tube(mgr,
(const struct sockaddr*)&remoteAddr,
&t,
&err) )
{
LS_LOG_ERR(err, "tube_manager_open_tube");
return 1;
}
break;
case TS_OPENING:
/* keep waiting by the mailbox, Charlie Brown */
break;
case TS_RUNNING:
/* .1% chance of close */
if ( (random() % 10000) < 10 )
{
if ( !tube_close(t, &err) )
{
LS_LOG_ERR(err, "tube_close");
return 1;
}
}
else
{
/* TODO: put something intersting in the buffer */
if ( !tube_data(t, data, random() % sizeof(data), &err) )
{
LS_LOG_ERR(err, "tube_data");
return 1;
}
}
case TS_RESUMING:
/* can't get here yet */
break;
}
}
return 0;
}
