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; }