Lines Matching defs:ctx
92 struct ub_ctx* ctx;
111 ctx = (struct ub_ctx*)calloc(1, sizeof(*ctx));
112 if(!ctx) {
116 alloc_init(&ctx->superalloc, NULL, 0);
117 if(!(ctx->seed_rnd = ub_initstate(NULL))) {
118 ub_randfree(ctx->seed_rnd);
119 free(ctx);
123 lock_basic_init(&ctx->qqpipe_lock);
124 lock_basic_init(&ctx->rrpipe_lock);
125 lock_basic_init(&ctx->cfglock);
126 ctx->env = (struct module_env*)calloc(1, sizeof(*ctx->env));
127 if(!ctx->env) {
128 ub_randfree(ctx->seed_rnd);
129 free(ctx);
133 ctx->env->cfg = config_create_forlib();
134 if(!ctx->env->cfg) {
135 free(ctx->env);
136 ub_randfree(ctx->seed_rnd);
137 free(ctx);
142 if(!edns_known_options_init(ctx->env)) {
143 config_delete(ctx->env->cfg);
144 free(ctx->env);
145 ub_randfree(ctx->seed_rnd);
146 free(ctx);
150 ctx->env->auth_zones = auth_zones_create();
151 if(!ctx->env->auth_zones) {
152 edns_known_options_delete(ctx->env);
153 config_delete(ctx->env->cfg);
154 free(ctx->env);
155 ub_randfree(ctx->seed_rnd);
156 free(ctx);
160 ctx->env->edns_strings = edns_strings_create();
161 if(!ctx->env->edns_strings) {
162 auth_zones_delete(ctx->env->auth_zones);
163 edns_known_options_delete(ctx->env);
164 config_delete(ctx->env->cfg);
165 free(ctx->env);
166 ub_randfree(ctx->seed_rnd);
167 free(ctx);
172 ctx->env->alloc = &ctx->superalloc;
173 ctx->env->worker = NULL;
174 ctx->env->need_to_validate = 0;
175 modstack_init(&ctx->mods);
176 ctx->env->modstack = &ctx->mods;
177 rbtree_init(&ctx->queries, &context_query_cmp);
178 return ctx;
184 struct ub_ctx* ctx = ub_ctx_create_nopipe();
185 if(!ctx)
187 if((ctx->qq_pipe = tube_create()) == NULL) {
189 ub_randfree(ctx->seed_rnd);
190 config_delete(ctx->env->cfg);
191 modstack_call_deinit(&ctx->mods, ctx->env);
192 modstack_call_destartup(&ctx->mods, ctx->env);
193 modstack_free(&ctx->mods);
195 edns_known_options_delete(ctx->env);
196 edns_strings_delete(ctx->env->edns_strings);
197 free(ctx->env);
198 free(ctx);
202 if((ctx->rr_pipe = tube_create()) == NULL) {
204 tube_delete(ctx->qq_pipe);
205 ub_randfree(ctx->seed_rnd);
206 config_delete(ctx->env->cfg);
207 modstack_call_deinit(&ctx->mods, ctx->env);
208 modstack_call_destartup(&ctx->mods, ctx->env);
209 modstack_free(&ctx->mods);
211 edns_known_options_delete(ctx->env);
212 edns_strings_delete(ctx->env->edns_strings);
213 free(ctx->env);
214 free(ctx);
218 return ctx;
224 struct ub_ctx* ctx = ub_ctx_create_nopipe();
225 if(!ctx)
228 ctx->created_bg = 0;
229 ctx->dothread = 1; /* the processing is in the same process,
231 ctx->event_base = ueb;
232 return ctx;
238 struct ub_ctx* ctx = ub_ctx_create_nopipe();
239 if(!ctx)
242 ctx->created_bg = 0;
243 ctx->dothread = 1; /* the processing is in the same process,
245 ctx->event_base = ub_libevent_event_base(eb);
246 if (!ctx->event_base) {
247 ub_ctx_delete(ctx);
250 ctx->event_base_malloced = 1;
251 return ctx;
263 static void ub_stop_bg(struct ub_ctx* ctx)
266 lock_basic_lock(&ctx->cfglock);
267 if(ctx->created_bg) {
271 lock_basic_unlock(&ctx->cfglock);
272 lock_basic_lock(&ctx->qqpipe_lock);
273 (void)tube_write_msg(ctx->qq_pipe, (uint8_t*)&cmd,
275 lock_basic_unlock(&ctx->qqpipe_lock);
276 lock_basic_lock(&ctx->rrpipe_lock);
277 while(tube_read_msg(ctx->rr_pipe, &msg, &len, 0)) {
285 lock_basic_unlock(&ctx->rrpipe_lock);
289 lock_basic_lock(&ctx->cfglock);
290 if(ctx->dothread) {
291 lock_basic_unlock(&ctx->cfglock);
292 ub_thread_join(ctx->bg_tid);
294 lock_basic_unlock(&ctx->cfglock);
296 if(waitpid(ctx->bg_pid, NULL, 0) == -1) {
304 lock_basic_unlock(&ctx->cfglock);
309 ub_ctx_delete(struct ub_ctx* ctx)
313 if(!ctx) return;
319 if(ctx->created_bg && ctx->pipe_pid != getpid()) {
325 if(ctx->qq_pipe->listen_com)
326 ctx->qq_pipe->listen_com->event_added = 0;
327 if(ctx->qq_pipe->res_com)
328 ctx->qq_pipe->res_com->event_added = 0;
329 if(ctx->rr_pipe->listen_com)
330 ctx->rr_pipe->listen_com->event_added = 0;
331 if(ctx->rr_pipe->res_com)
332 ctx->rr_pipe->res_com->event_added = 0;
339 if(ctx->created_bg && ctx->dothread && do_stop) {
340 if(pthread_kill(ctx->bg_tid, 0) == ESRCH) {
347 ub_stop_bg(ctx);
348 if(ctx->created_bg && ctx->pipe_pid != getpid() && ctx->thread_worker) {
353 ctx->thread_worker->base);
354 libworker_delete_event(ctx->thread_worker);
355 ctx->thread_worker = NULL;
365 libworker_delete_event(ctx->event_worker);
367 modstack_call_deinit(&ctx->mods, ctx->env);
368 modstack_call_destartup(&ctx->mods, ctx->env);
369 modstack_free(&ctx->mods);
370 a = ctx->alloc_list;
373 a->super = &ctx->superalloc;
378 local_zones_delete(ctx->local_zones);
379 lock_basic_destroy(&ctx->qqpipe_lock);
380 lock_basic_destroy(&ctx->rrpipe_lock);
381 lock_basic_destroy(&ctx->cfglock);
382 tube_delete(ctx->qq_pipe);
383 tube_delete(ctx->rr_pipe);
384 if(ctx->env) {
385 slabhash_delete(ctx->env->msg_cache);
386 rrset_cache_delete(ctx->env->rrset_cache);
387 infra_delete(ctx->env->infra_cache);
388 config_delete(ctx->env->cfg);
389 edns_known_options_delete(ctx->env);
390 edns_strings_delete(ctx->env->edns_strings);
391 forwards_delete(ctx->env->fwds);
392 hints_delete(ctx->env->hints);
393 auth_zones_delete(ctx->env->auth_zones);
394 free(ctx->env);
396 ub_randfree(ctx->seed_rnd);
397 alloc_clear(&ctx->superalloc);
399 traverse_postorder(&ctx->queries, delq, NULL);
404 if(ctx->event_base_malloced)
405 free(ctx->event_base);
406 free(ctx);
413 ub_ctx_set_option(struct ub_ctx* ctx, const char* opt, const char* val)
415 lock_basic_lock(&ctx->cfglock);
416 if(ctx->finalized) {
417 lock_basic_unlock(&ctx->cfglock);
420 if(!config_set_option(ctx->env->cfg, opt, val)) {
421 lock_basic_unlock(&ctx->cfglock);
424 lock_basic_unlock(&ctx->cfglock);
429 ub_ctx_get_option(struct ub_ctx* ctx, const char* opt, char** str)
432 lock_basic_lock(&ctx->cfglock);
433 r = config_get_option_collate(ctx->env->cfg, opt, str);
434 lock_basic_unlock(&ctx->cfglock);
442 ub_ctx_config(struct ub_ctx* ctx, const char* fname)
444 lock_basic_lock(&ctx->cfglock);
445 if(ctx->finalized) {
446 lock_basic_unlock(&ctx->cfglock);
449 if(!config_read(ctx->env->cfg, fname, NULL)) {
450 lock_basic_unlock(&ctx->cfglock);
453 lock_basic_unlock(&ctx->cfglock);
458 ub_ctx_add_ta(struct ub_ctx* ctx, const char* ta)
462 lock_basic_lock(&ctx->cfglock);
463 if(ctx->finalized) {
464 lock_basic_unlock(&ctx->cfglock);
468 if(!cfg_strlist_insert(&ctx->env->cfg->trust_anchor_list, dup)) {
469 lock_basic_unlock(&ctx->cfglock);
472 lock_basic_unlock(&ctx->cfglock);
477 ub_ctx_add_ta_file(struct ub_ctx* ctx, const char* fname)
481 lock_basic_lock(&ctx->cfglock);
482 if(ctx->finalized) {
483 lock_basic_unlock(&ctx->cfglock);
487 if(!cfg_strlist_insert(&ctx->env->cfg->trust_anchor_file_list, dup)) {
488 lock_basic_unlock(&ctx->cfglock);
491 lock_basic_unlock(&ctx->cfglock);
495 int ub_ctx_add_ta_autr(struct ub_ctx* ctx, const char* fname)
499 lock_basic_lock(&ctx->cfglock);
500 if(ctx->finalized) {
501 lock_basic_unlock(&ctx->cfglock);
505 if(!cfg_strlist_insert(&ctx->env->cfg->auto_trust_anchor_file_list,
507 lock_basic_unlock(&ctx->cfglock);
510 lock_basic_unlock(&ctx->cfglock);
515 ub_ctx_trustedkeys(struct ub_ctx* ctx, const char* fname)
519 lock_basic_lock(&ctx->cfglock);
520 if(ctx->finalized) {
521 lock_basic_unlock(&ctx->cfglock);
525 if(!cfg_strlist_insert(&ctx->env->cfg->trusted_keys_file_list, dup)) {
526 lock_basic_unlock(&ctx->cfglock);
529 lock_basic_unlock(&ctx->cfglock);
534 ub_ctx_debuglevel(struct ub_ctx* ctx, int d)
536 lock_basic_lock(&ctx->cfglock);
538 ctx->env->cfg->verbosity = d;
539 lock_basic_unlock(&ctx->cfglock);
543 int ub_ctx_debugout(struct ub_ctx* ctx, void* out)
545 lock_basic_lock(&ctx->cfglock);
548 ctx->logfile_override = 1;
549 ctx->log_out = out;
550 lock_basic_unlock(&ctx->cfglock);
555 ub_ctx_async(struct ub_ctx* ctx, int dothread)
561 lock_basic_lock(&ctx->cfglock);
562 if(ctx->finalized) {
563 lock_basic_unlock(&ctx->cfglock);
566 ctx->dothread = dothread;
567 lock_basic_unlock(&ctx->cfglock);
572 ub_poll(struct ub_ctx* ctx)
575 return tube_poll(ctx->rr_pipe);
579 ub_fd(struct ub_ctx* ctx)
581 return tube_read_fd(ctx->rr_pipe);
586 process_answer_detail(struct ub_ctx* ctx, uint8_t* msg, uint32_t len,
597 lock_basic_lock(&ctx->cfglock);
598 q = context_deserialize_answer(ctx, msg, len, err);
600 lock_basic_unlock(&ctx->cfglock);
639 (void)rbtree_delete(&ctx->queries, q->node.key);
640 ctx->num_async--;
642 lock_basic_unlock(&ctx->cfglock);
651 process_answer(struct ub_ctx* ctx, uint8_t* msg, uint32_t len)
659 r = process_answer_detail(ctx, msg, len, &cb, &cbarg, &err, &res);
670 ub_process(struct ub_ctx* ctx)
677 lock_basic_lock(&ctx->rrpipe_lock);
678 r = tube_read_msg(ctx->rr_pipe, &msg, &len, 1);
679 lock_basic_unlock(&ctx->rrpipe_lock);
684 if(!process_answer(ctx, msg, len)) {
694 ub_wait(struct ub_ctx* ctx)
706 lock_basic_lock(&ctx->rrpipe_lock);
707 lock_basic_lock(&ctx->cfglock);
708 if(ctx->num_async == 0) {
709 lock_basic_unlock(&ctx->cfglock);
710 lock_basic_unlock(&ctx->rrpipe_lock);
713 lock_basic_unlock(&ctx->cfglock);
721 r = tube_wait(ctx->rr_pipe);
723 r = tube_read_msg(ctx->rr_pipe, &msg, &len, 1);
725 lock_basic_unlock(&ctx->rrpipe_lock);
729 lock_basic_unlock(&ctx->rrpipe_lock);
732 r = process_answer_detail(ctx, msg, len,
734 lock_basic_unlock(&ctx->rrpipe_lock);
741 lock_basic_unlock(&ctx->rrpipe_lock);
748 ub_resolve(struct ub_ctx* ctx, const char* name, int rrtype,
755 lock_basic_lock(&ctx->cfglock);
756 if(!ctx->finalized) {
757 r = context_finalize(ctx);
759 lock_basic_unlock(&ctx->cfglock);
764 lock_basic_unlock(&ctx->cfglock);
765 q = context_new(ctx, name, rrtype, rrclass, NULL, NULL, NULL);
770 r = libworker_fg(ctx, q);
772 lock_basic_lock(&ctx->cfglock);
773 (void)rbtree_delete(&ctx->queries, q->node.key);
775 lock_basic_unlock(&ctx->cfglock);
784 lock_basic_lock(&ctx->cfglock);
785 (void)rbtree_delete(&ctx->queries, q->node.key);
787 lock_basic_unlock(&ctx->cfglock);
792 ub_resolve_event(struct ub_ctx* ctx, const char* name, int rrtype,
801 lock_basic_lock(&ctx->cfglock);
802 if(!ctx->finalized) {
803 r = context_finalize(ctx);
805 lock_basic_unlock(&ctx->cfglock);
809 lock_basic_unlock(&ctx->cfglock);
810 if(!ctx->event_worker) {
811 ctx->event_worker = libworker_create_event(ctx,
812 ctx->event_base);
813 if(!ctx->event_worker) {
819 ub_comm_base_now(ctx->event_worker->base);
822 q = context_new(ctx, name, rrtype, rrclass, NULL, callback, mydata);
827 if((r=libworker_attach_mesh(ctx, q, async_id)) != 0)
834 ub_resolve_async(struct ub_ctx* ctx, const char* name, int rrtype,
843 lock_basic_lock(&ctx->cfglock);
844 if(!ctx->finalized) {
845 int r = context_finalize(ctx);
847 lock_basic_unlock(&ctx->cfglock);
851 if(!ctx->created_bg) {
853 ctx->created_bg = 1;
854 lock_basic_unlock(&ctx->cfglock);
855 r = libworker_bg(ctx);
857 lock_basic_lock(&ctx->cfglock);
858 ctx->created_bg = 0;
859 lock_basic_unlock(&ctx->cfglock);
863 lock_basic_unlock(&ctx->cfglock);
867 q = context_new(ctx, name, rrtype, rrclass, callback, NULL, mydata);
872 lock_basic_lock(&ctx->cfglock);
875 (void)rbtree_delete(&ctx->queries, q->node.key);
876 ctx->num_async--;
878 lock_basic_unlock(&ctx->cfglock);
883 lock_basic_unlock(&ctx->cfglock);
885 lock_basic_lock(&ctx->qqpipe_lock);
886 if(!tube_write_msg(ctx->qq_pipe, msg, len, 0)) {
887 lock_basic_unlock(&ctx->qqpipe_lock);
891 lock_basic_unlock(&ctx->qqpipe_lock);
897 ub_cancel(struct ub_ctx* ctx, int async_id)
902 lock_basic_lock(&ctx->cfglock);
903 q = (struct ctx_query*)rbtree_search(&ctx->queries, &async_id);
906 lock_basic_unlock(&ctx->cfglock);
913 if(!ctx->dothread) { /* if forked */
914 (void)rbtree_delete(&ctx->queries, q->node.key);
915 ctx->num_async--;
918 lock_basic_unlock(&ctx->cfglock);
923 lock_basic_lock(&ctx->qqpipe_lock);
924 if(!tube_write_msg(ctx->qq_pipe, msg, len, 0)) {
925 lock_basic_unlock(&ctx->qqpipe_lock);
929 lock_basic_unlock(&ctx->qqpipe_lock);
932 lock_basic_unlock(&ctx->cfglock);
975 ub_ctx_set_fwd(struct ub_ctx* ctx, const char* addr)
981 lock_basic_lock(&ctx->cfglock);
982 if(ctx->finalized) {
983 lock_basic_unlock(&ctx->cfglock);
989 if(ctx->env->cfg->forwards &&
990 (ctx->env->cfg->forwards->name &&
991 strcmp(ctx->env->cfg->forwards->name, ".") == 0)) {
992 s = ctx->env->cfg->forwards;
993 ctx->env->cfg->forwards = s->next;
997 lock_basic_unlock(&ctx->cfglock);
1000 lock_basic_unlock(&ctx->cfglock);
1009 lock_basic_lock(&ctx->cfglock);
1010 if(!ctx->env->cfg->forwards ||
1011 (ctx->env->cfg->forwards->name &&
1012 strcmp(ctx->env->cfg->forwards->name, ".") != 0)) {
1015 lock_basic_unlock(&ctx->cfglock);
1022 lock_basic_unlock(&ctx->cfglock);
1026 s->next = ctx->env->cfg->forwards;
1027 ctx->env->cfg->forwards = s;
1029 log_assert(ctx->env->cfg->forwards);
1030 log_assert(ctx->env->cfg->forwards->name);
1031 s = ctx->env->cfg->forwards;
1035 lock_basic_unlock(&ctx->cfglock);
1040 lock_basic_unlock(&ctx->cfglock);
1044 lock_basic_unlock(&ctx->cfglock);
1048 int ub_ctx_set_tls(struct ub_ctx* ctx, int tls)
1050 lock_basic_lock(&ctx->cfglock);
1051 if(ctx->finalized) {
1052 lock_basic_unlock(&ctx->cfglock);
1056 ctx->env->cfg->ssl_upstream = tls;
1057 lock_basic_unlock(&ctx->cfglock);
1061 int ub_ctx_set_stub(struct ub_ctx* ctx, const char* zone, const char* addr,
1091 lock_basic_lock(&ctx->cfglock);
1092 if(ctx->finalized) {
1093 lock_basic_unlock(&ctx->cfglock);
1099 prev = &ctx->env->cfg->stubs;
1103 lock_basic_unlock(&ctx->cfglock);
1109 lock_basic_unlock(&ctx->cfglock);
1117 lock_basic_unlock(&ctx->cfglock);
1121 elem->next = ctx->env->cfg->stubs;
1122 ctx->env->cfg->stubs = elem;
1129 lock_basic_unlock(&ctx->cfglock);
1134 lock_basic_unlock(&ctx->cfglock);
1138 lock_basic_unlock(&ctx->cfglock);
1143 ub_ctx_resolvconf(struct ub_ctx* ctx, const char* fname)
1175 if((retval=ub_ctx_set_fwd(ctx,
1214 if((r = ub_ctx_set_fwd(ctx, addr)) != UB_NOERROR) {
1223 return ub_ctx_set_fwd(ctx, "127.0.0.1");
1229 ub_ctx_hosts(struct ub_ctx* ctx, const char* fname)
1234 lock_basic_lock(&ctx->cfglock);
1235 if(ctx->finalized) {
1236 lock_basic_unlock(&ctx->cfglock);
1240 lock_basic_unlock(&ctx->cfglock);
1253 if((retval=ub_ctx_hosts(ctx, buf)) !=0 ) {
1256 retval=ub_ctx_hosts(ctx, buf);
1317 lock_basic_lock(&ctx->cfglock);
1318 if(!cfg_strlist_insert(&ctx->env->cfg->local_data,
1320 lock_basic_unlock(&ctx->cfglock);
1325 lock_basic_unlock(&ctx->cfglock);
1333 static int ub_ctx_finalize(struct ub_ctx* ctx)
1336 lock_basic_lock(&ctx->cfglock);
1337 if (!ctx->finalized) {
1338 res = context_finalize(ctx);
1340 lock_basic_unlock(&ctx->cfglock);
1345 int ub_ctx_print_local_zones(struct ub_ctx* ctx)
1347 int res = ub_ctx_finalize(ctx);
1350 local_zones_print(ctx->local_zones);
1356 int ub_ctx_zone_add(struct ub_ctx* ctx, const char *zone_name,
1365 int res = ub_ctx_finalize(ctx);
1376 lock_rw_wrlock(&ctx->local_zones->lock);
1377 if((z=local_zones_find(ctx->local_zones, nm, nmlen, nmlabs,
1383 lock_rw_unlock(&ctx->local_zones->lock);
1387 if(!local_zones_add_zone(ctx->local_zones, nm, nmlen, nmlabs,
1389 lock_rw_unlock(&ctx->local_zones->lock);
1392 lock_rw_unlock(&ctx->local_zones->lock);
1397 int ub_ctx_zone_remove(struct ub_ctx* ctx, const char *zone_name)
1404 int res = ub_ctx_finalize(ctx);
1411 lock_rw_wrlock(&ctx->local_zones->lock);
1412 if((z=local_zones_find(ctx->local_zones, nm, nmlen, nmlabs,
1415 local_zones_del_zone(ctx->local_zones, z);
1417 lock_rw_unlock(&ctx->local_zones->lock);
1423 int ub_ctx_data_add(struct ub_ctx* ctx, const char *data)
1425 int res = ub_ctx_finalize(ctx);
1428 res = local_zones_add_RR(ctx->local_zones, data);
1433 int ub_ctx_data_remove(struct ub_ctx* ctx, const char *data)
1438 int res = ub_ctx_finalize(ctx);
1444 local_zones_del_data(ctx->local_zones, nm, nmlen, nmlabs,
1457 ub_ctx_set_event(struct ub_ctx* ctx, struct event_base* base) {
1460 if (!ctx || !ctx->event_base || !base) {
1463 if (ub_libevent_get_event_base(ctx->event_base) == base) {
1468 lock_basic_lock(&ctx->cfglock);
1470 libworker_delete_event(ctx->event_worker);
1471 ctx->event_worker = NULL;
1474 ctx->event_base = new_base;
1475 ctx->created_bg = 0;
1476 ctx->dothread = 1;
1477 lock_basic_unlock(&ctx->cfglock);