"Fossies" - the Fresh Open Source Software Archive

Member "bind-9.11.23/lib/isc/app_api.c" (7 Sep 2020, 5151 Bytes) of package /linux/misc/dns/bind9/9.11.23/bind-9.11.23.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "app_api.c" see the Fossies "Dox" file reference documentation.

    1 /*
    2  * Copyright (C) Internet Systems Consortium, Inc. ("ISC")
    3  *
    4  * This Source Code Form is subject to the terms of the Mozilla Public
    5  * License, v. 2.0. If a copy of the MPL was not distributed with this
    6  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
    7  *
    8  * See the COPYRIGHT file distributed with this work for additional
    9  * information regarding copyright ownership.
   10  */
   11 
   12 
   13 #include <config.h>
   14 
   15 #include <stdbool.h>
   16 #include <unistd.h>
   17 
   18 #include <isc/app.h>
   19 #include <isc/magic.h>
   20 #include <isc/mutex.h>
   21 #include <isc/once.h>
   22 #include <isc/util.h>
   23 
   24 static isc_mutex_t createlock;
   25 static isc_once_t once = ISC_ONCE_INIT;
   26 static isc_appctxcreatefunc_t appctx_createfunc = NULL;
   27 static isc_mutex_t runninglock;
   28 static bool is_running = false;
   29 
   30 #define ISCAPI_APPMETHODS_VALID(m) ISC_MAGIC_VALID(m, ISCAPI_APPMETHODS_MAGIC)
   31 
   32 static void
   33 initialize(void) {
   34     RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
   35     RUNTIME_CHECK(isc_mutex_init(&runninglock) == ISC_R_SUCCESS);
   36 }
   37 
   38 isc_result_t
   39 isc_app_register(isc_appctxcreatefunc_t createfunc) {
   40     isc_result_t result = ISC_R_SUCCESS;
   41 
   42     RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
   43 
   44     LOCK(&createlock);
   45     if (appctx_createfunc == NULL)
   46         appctx_createfunc = createfunc;
   47     else
   48         result = ISC_R_EXISTS;
   49     UNLOCK(&createlock);
   50 
   51     return (result);
   52 }
   53 
   54 isc_result_t
   55 isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
   56     isc_result_t result;
   57 
   58     if (isc_bind9)
   59         return (isc__appctx_create(mctx, ctxp));
   60 
   61     LOCK(&createlock);
   62 
   63     REQUIRE(appctx_createfunc != NULL);
   64     result = (*appctx_createfunc)(mctx, ctxp);
   65 
   66     UNLOCK(&createlock);
   67 
   68     return (result);
   69 }
   70 
   71 void
   72 isc_appctx_destroy(isc_appctx_t **ctxp) {
   73     REQUIRE(ctxp != NULL && ISCAPI_APPCTX_VALID(*ctxp));
   74 
   75     if (isc_bind9)
   76         isc__appctx_destroy(ctxp);
   77     else
   78         (*ctxp)->methods->ctxdestroy(ctxp);
   79 
   80     ENSURE(*ctxp == NULL);
   81 }
   82 
   83 isc_result_t
   84 isc_app_ctxstart(isc_appctx_t *ctx) {
   85     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
   86 
   87     if (isc_bind9)
   88         return (isc__app_ctxstart(ctx));
   89 
   90     return (ctx->methods->ctxstart(ctx));
   91 }
   92 
   93 isc_result_t
   94 isc_app_ctxrun(isc_appctx_t *ctx) {
   95     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
   96 
   97     if (isc_bind9)
   98         return (isc__app_ctxrun(ctx));
   99 
  100     return (ctx->methods->ctxrun(ctx));
  101 }
  102 
  103 isc_result_t
  104 isc_app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx,
  105          isc_task_t *task, isc_taskaction_t action,
  106          void *arg)
  107 {
  108     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  109 
  110     if (isc_bind9)
  111         return (isc__app_ctxonrun(ctx, mctx, task, action, arg));
  112 
  113     return (ctx->methods->ctxonrun(ctx, mctx, task, action, arg));
  114 }
  115 
  116 isc_result_t
  117 isc_app_ctxsuspend(isc_appctx_t *ctx) {
  118     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  119 
  120     if (isc_bind9)
  121         return (isc__app_ctxsuspend(ctx));
  122 
  123     return (ctx->methods->ctxsuspend(ctx));
  124 }
  125 
  126 isc_result_t
  127 isc_app_ctxshutdown(isc_appctx_t *ctx) {
  128     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  129 
  130     if (isc_bind9)
  131         return (isc__app_ctxshutdown(ctx));
  132 
  133     return (ctx->methods->ctxshutdown(ctx));
  134 }
  135 
  136 void
  137 isc_app_ctxfinish(isc_appctx_t *ctx) {
  138     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  139 
  140     if (isc_bind9)
  141         isc__app_ctxfinish(ctx);
  142 
  143     ctx->methods->ctxfinish(ctx);
  144 }
  145 
  146 void
  147 isc_appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr) {
  148     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  149     REQUIRE(taskmgr != NULL);
  150 
  151     if (isc_bind9)
  152         isc__appctx_settaskmgr(ctx, taskmgr);
  153 
  154     ctx->methods->settaskmgr(ctx, taskmgr);
  155 }
  156 
  157 void
  158 isc_appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr) {
  159     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  160     REQUIRE(socketmgr != NULL);
  161 
  162     if (isc_bind9)
  163         isc__appctx_setsocketmgr(ctx, socketmgr);
  164 
  165     ctx->methods->setsocketmgr(ctx, socketmgr);
  166 }
  167 
  168 void
  169 isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr) {
  170     REQUIRE(ISCAPI_APPCTX_VALID(ctx));
  171     REQUIRE(timermgr != NULL);
  172 
  173     if (isc_bind9)
  174         isc__appctx_settimermgr(ctx, timermgr);
  175 
  176     ctx->methods->settimermgr(ctx, timermgr);
  177 }
  178 
  179 isc_result_t
  180 isc_app_start(void) {
  181     if (isc_bind9)
  182         return (isc__app_start());
  183 
  184     return (ISC_R_NOTIMPLEMENTED);
  185 }
  186 
  187 isc_result_t
  188 isc_app_onrun(isc_mem_t *mctx, isc_task_t *task,
  189            isc_taskaction_t action, void *arg)
  190 {
  191     if (isc_bind9)
  192         return (isc__app_onrun(mctx, task, action, arg));
  193 
  194     return (ISC_R_NOTIMPLEMENTED);
  195 }
  196 
  197 isc_result_t
  198 isc_app_run() {
  199     if (isc_bind9) {
  200         isc_result_t result;
  201 
  202         RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
  203 
  204         LOCK(&runninglock);
  205         is_running = true;
  206         UNLOCK(&runninglock);
  207         result = isc__app_run();
  208         LOCK(&runninglock);
  209         is_running = false;
  210         UNLOCK(&runninglock);
  211 
  212         return (result);
  213     }
  214 
  215     return (ISC_R_NOTIMPLEMENTED);
  216 }
  217 
  218 bool
  219 isc_app_isrunning() {
  220     bool running;
  221 
  222     RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
  223 
  224     LOCK(&runninglock);
  225     running = is_running;
  226     UNLOCK(&runninglock);
  227 
  228     return (running);
  229 }
  230 
  231 isc_result_t
  232 isc_app_shutdown(void) {
  233     if (isc_bind9)
  234         return (isc__app_shutdown());
  235 
  236     return (ISC_R_NOTIMPLEMENTED);
  237 }
  238 
  239 isc_result_t
  240 isc_app_reload(void) {
  241     if (isc_bind9)
  242         return (isc__app_reload());
  243 
  244     return (ISC_R_NOTIMPLEMENTED);
  245 }
  246 
  247 void
  248 isc_app_finish(void) {
  249     if (!isc_bind9)
  250         return;
  251 
  252     isc__app_finish();
  253 }
  254 
  255 void
  256 isc_app_block(void) {
  257     if (!isc_bind9)
  258         return;
  259 
  260     isc__app_block();
  261 }
  262 
  263 void
  264 isc_app_unblock(void) {
  265     if (!isc_bind9)
  266         return;
  267 
  268     isc__app_unblock();
  269 }