isc_result_t
isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__appctx_create(mctx, ctxp));
-
- LOCK(&createlock);
-
- REQUIRE(appctx_createfunc != NULL);
- result = (*appctx_createfunc)(mctx, ctxp);
-
- UNLOCK(&createlock);
-
- return (result);
+ return (isc__appctx_create(mctx, ctxp));
}
void
isc_appctx_destroy(isc_appctx_t **ctxp) {
REQUIRE(ctxp != NULL && ISCAPI_APPCTX_VALID(*ctxp));
- if (isc_bind9)
- isc__appctx_destroy(ctxp);
- else
- (*ctxp)->methods->ctxdestroy(ctxp);
-
+ isc__appctx_destroy(ctxp);
ENSURE(*ctxp == NULL);
}
isc_app_ctxstart(isc_appctx_t *ctx) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- if (isc_bind9)
- return (isc__app_ctxstart(ctx));
-
- return (ctx->methods->ctxstart(ctx));
+ return (isc__app_ctxstart(ctx));
}
isc_result_t
isc_app_ctxrun(isc_appctx_t *ctx) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- if (isc_bind9)
- return (isc__app_ctxrun(ctx));
-
- return (ctx->methods->ctxrun(ctx));
+ return (isc__app_ctxrun(ctx));
}
isc_result_t
{
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- if (isc_bind9)
- return (isc__app_ctxonrun(ctx, mctx, task, action, arg));
-
- return (ctx->methods->ctxonrun(ctx, mctx, task, action, arg));
+ return (isc__app_ctxonrun(ctx, mctx, task, action, arg));
}
isc_result_t
isc_app_ctxsuspend(isc_appctx_t *ctx) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- if (isc_bind9)
- return (isc__app_ctxsuspend(ctx));
-
- return (ctx->methods->ctxsuspend(ctx));
+ return (isc__app_ctxsuspend(ctx));
}
isc_result_t
isc_app_ctxshutdown(isc_appctx_t *ctx) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- if (isc_bind9)
- return (isc__app_ctxshutdown(ctx));
-
- return (ctx->methods->ctxshutdown(ctx));
+ return (isc__app_ctxshutdown(ctx));
}
void
isc_app_ctxfinish(isc_appctx_t *ctx) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
- if (isc_bind9)
- isc__app_ctxfinish(ctx);
-
- ctx->methods->ctxfinish(ctx);
+ isc__app_ctxfinish(ctx);
}
void
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
REQUIRE(taskmgr != NULL);
- if (isc_bind9)
- isc__appctx_settaskmgr(ctx, taskmgr);
-
- ctx->methods->settaskmgr(ctx, taskmgr);
+ isc__appctx_settaskmgr(ctx, taskmgr);
}
void
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
REQUIRE(socketmgr != NULL);
- if (isc_bind9)
- isc__appctx_setsocketmgr(ctx, socketmgr);
-
- ctx->methods->setsocketmgr(ctx, socketmgr);
+ isc__appctx_setsocketmgr(ctx, socketmgr);
}
void
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
REQUIRE(timermgr != NULL);
- if (isc_bind9)
- isc__appctx_settimermgr(ctx, timermgr);
-
- ctx->methods->settimermgr(ctx, timermgr);
+ isc__appctx_settimermgr(ctx, timermgr);
}
isc_result_t
isc_app_start(void) {
- if (isc_bind9)
- return (isc__app_start());
-
- return (ISC_R_NOTIMPLEMENTED);
+ return (isc__app_start());
}
isc_result_t
isc_app_onrun(isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
- if (isc_bind9)
- return (isc__app_onrun(mctx, task, action, arg));
-
- return (ISC_R_NOTIMPLEMENTED);
+ return (isc__app_onrun(mctx, task, action, arg));
}
isc_result_t
isc_app_run() {
- if (isc_bind9) {
- isc_result_t result;
-
- is_running = true;
- result = isc__app_run();
- is_running = false;
+ isc_result_t result;
- return (result);
- }
+ is_running = ISC_TRUE;
+ result = isc__app_run();
+ is_running = ISC_FALSE;
- return (ISC_R_NOTIMPLEMENTED);
+ return (result);
}
bool
isc_result_t
isc_app_shutdown(void) {
- if (isc_bind9)
- return (isc__app_shutdown());
-
- return (ISC_R_NOTIMPLEMENTED);
+ return (isc__app_shutdown());
}
isc_result_t
isc_app_reload(void) {
- if (isc_bind9)
- return (isc__app_reload());
-
- return (ISC_R_NOTIMPLEMENTED);
+ return (isc__app_reload());
}
void
isc_app_finish(void) {
- if (!isc_bind9)
- return;
-
isc__app_finish();
}
void
isc_app_block(void) {
- if (!isc_bind9)
- return;
-
isc__app_block();
}
void
isc_app_unblock(void) {
- if (!isc_bind9)
- return;
-
isc__app_unblock();
}
#define ISC_APPEVENT_SHUTDOWN (ISC_EVENTCLASS_APP + 1)
#define ISC_APPEVENT_LASTEVENT (ISC_EVENTCLASS_APP + 65535)
-/*%
- * app module methods. Only app driver implementations use this structure.
- * Other clients should use the top-level interfaces (i.e., isc_app_xxx
- * functions). magic must be ISCAPI_APPMETHODS_MAGIC.
- */
-typedef struct isc_appmethods {
- void (*ctxdestroy)(isc_appctx_t **ctxp);
- isc_result_t (*ctxstart)(isc_appctx_t *ctx);
- isc_result_t (*ctxrun)(isc_appctx_t *ctx);
- isc_result_t (*ctxsuspend)(isc_appctx_t *ctx);
- isc_result_t (*ctxshutdown)(isc_appctx_t *ctx);
- void (*ctxfinish)(isc_appctx_t *ctx);
- void (*settaskmgr)(isc_appctx_t *ctx,
- isc_taskmgr_t *timermgr);
- void (*setsocketmgr)(isc_appctx_t *ctx,
- isc_socketmgr_t *timermgr);
- void (*settimermgr)(isc_appctx_t *ctx,
- isc_timermgr_t *timermgr);
- isc_result_t (*ctxonrun)(isc_appctx_t *ctx, isc_mem_t *mctx,
- isc_task_t *task, isc_taskaction_t action,
- void *arg);
-} isc_appmethods_t;
-
/*%
* This structure is actually just the common prefix of an application context
* implementation's version of an isc_appctx_t.
struct isc_appctx {
unsigned int impmagic;
unsigned int magic;
- isc_appmethods_t *methods;
};
#define ISCAPI_APPCTX_MAGIC ISC_MAGIC('A','a','p','c')
* \endcode
*/
-/*% memory and memory pool methods */
-typedef struct isc_memmethods {
- void (*attach)(isc_mem_t *source, isc_mem_t **targetp);
- void (*detach)(isc_mem_t **mctxp);
- void (*destroy)(isc_mem_t **mctxp);
- void *(*memget)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
- void (*memput)(isc_mem_t *mctx, void *ptr, size_t size _ISC_MEM_FLARG);
- void (*memputanddetach)(isc_mem_t **mctxp, void *ptr,
- size_t size _ISC_MEM_FLARG);
- void *(*memallocate)(isc_mem_t *mctx, size_t size _ISC_MEM_FLARG);
- void *(*memreallocate)(isc_mem_t *mctx, void *ptr,
- size_t size _ISC_MEM_FLARG);
- char *(*memstrdup)(isc_mem_t *mctx, const char *s _ISC_MEM_FLARG);
- void (*memfree)(isc_mem_t *mctx, void *ptr _ISC_MEM_FLARG);
- void (*setdestroycheck)(isc_mem_t *mctx, bool flag);
- void (*setwater)(isc_mem_t *ctx, isc_mem_water_t water,
- void *water_arg, size_t hiwater, size_t lowater);
- void (*waterack)(isc_mem_t *ctx, int flag);
- size_t (*inuse)(isc_mem_t *mctx);
- size_t (*maxinuse)(isc_mem_t *mctx);
- size_t (*total)(isc_mem_t *mctx);
- bool (*isovermem)(isc_mem_t *mctx);
- isc_result_t (*mpcreate)(isc_mem_t *mctx, size_t size,
- isc_mempool_t **mpctxp);
-} isc_memmethods_t;
-
-typedef struct isc_mempoolmethods {
- void (*destroy)(isc_mempool_t **mpctxp);
- void *(*get)(isc_mempool_t *mpctx _ISC_MEM_FLARG);
- void (*put)(isc_mempool_t *mpctx, void *mem _ISC_MEM_FLARG);
- unsigned int (*getallocated)(isc_mempool_t *mpctx);
- void (*setmaxalloc)(isc_mempool_t *mpctx, unsigned int limit);
- void (*setfreemax)(isc_mempool_t *mpctx, unsigned int limit);
- void (*setname)(isc_mempool_t *mpctx, const char *name);
- void (*associatelock)(isc_mempool_t *mpctx, isc_mutex_t *lock);
- void (*setfillcount)(isc_mempool_t *mpctx, unsigned int limit);
-} isc_mempoolmethods_t;
-
/*%
* This structure is actually just the common prefix of a memory context
* implementation's version of an isc_mem_t.
struct isc_mem {
unsigned int impmagic;
unsigned int magic;
- isc_memmethods_t *methods;
};
#define ISCAPI_MCTX_MAGIC ISC_MAGIC('A','m','c','x')
struct isc_mempool {
unsigned int impmagic;
unsigned int magic;
- isc_mempoolmethods_t *methods;
};
#define ISCAPI_MPOOL_MAGIC ISC_MAGIC('A','m','p','l')
#define ISC_SOCKFDWATCH_WRITE 0x00000002 /*%< watch for writable */
/*@}*/
-/*% Socket and socket manager methods */
-typedef struct isc_socketmgrmethods {
- void (*destroy)(isc_socketmgr_t **managerp);
- isc_result_t (*socketcreate)(isc_socketmgr_t *manager, int pf,
- isc_sockettype_t type,
- isc_socket_t **socketp);
- isc_result_t (*fdwatchcreate)(isc_socketmgr_t *manager, int fd,
- int flags,
- isc_sockfdwatch_t callback,
- void *cbarg, isc_task_t *task,
- isc_socket_t **socketp);
-} isc_socketmgrmethods_t;
-
-typedef struct isc_socketmethods {
- void (*attach)(isc_socket_t *socket,
- isc_socket_t **socketp);
- void (*detach)(isc_socket_t **socketp);
- isc_result_t (*bind)(isc_socket_t *sock,
- const isc_sockaddr_t *sockaddr,
- unsigned int options);
- isc_result_t (*sendto)(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task, isc_taskaction_t action,
- void *arg,
- const isc_sockaddr_t *address,
- struct in6_pktinfo *pktinfo);
- isc_result_t (*sendto2)(isc_socket_t *sock, isc_region_t *region,
- isc_task_t *task,
- const isc_sockaddr_t *address,
- struct in6_pktinfo *pktinfo,
- isc_socketevent_t *event,
- unsigned int flags);
- isc_result_t (*connect)(isc_socket_t *sock,
- const isc_sockaddr_t *addr,
- isc_task_t *task, isc_taskaction_t action,
- void *arg);
- isc_result_t (*recv)(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_taskaction_t action, void *arg);
- isc_result_t (*recv2)(isc_socket_t *sock, isc_region_t *region,
- unsigned int minimum, isc_task_t *task,
- isc_socketevent_t *event, unsigned int flags);
- void (*cancel)(isc_socket_t *sock, isc_task_t *task,
- unsigned int how);
- isc_result_t (*getsockname)(isc_socket_t *sock,
- isc_sockaddr_t *addressp);
- isc_sockettype_t (*gettype)(isc_socket_t *sock);
- void (*ipv6only)(isc_socket_t *sock, bool yes);
- isc_result_t (*fdwatchpoke)(isc_socket_t *sock, int flags);
- isc_result_t (*dup)(isc_socket_t *socket,
- isc_socket_t **socketp);
- int (*getfd)(isc_socket_t *socket);
- void (*dscp)(isc_socket_t *socket, isc_dscp_t dscp);
-} isc_socketmethods_t;
-
/*%
* This structure is actually just the common prefix of a socket manager
* object implementation's version of an isc_socketmgr_t.
struct isc_socketmgr {
unsigned int impmagic;
unsigned int magic;
- isc_socketmgrmethods_t *methods;
};
#endif
struct isc_socket {
unsigned int impmagic;
unsigned int magic;
- isc_socketmethods_t *methods;
};
#endif
}
}
-static isc_once_t register_once = ISC_ONCE_INIT;
-
-static void
-do_register(void) {
- isc_bind9 = false;
-
- RUNTIME_CHECK(isc__mem_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__app_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__task_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__socket_register() == ISC_R_SUCCESS);
- RUNTIME_CHECK(isc__timer_register() == ISC_R_SUCCESS);
-}
-
void
isc_lib_register(void) {
- RUNTIME_CHECK(isc_once_do(®ister_once, do_register)
- == ISC_R_SUCCESS);
+ printf("ISC_LIB_REGISTER\n");
}
unsigned int
isc__mem_references(isc_mem_t *ctx0);
-static struct isc__memmethods {
- isc_memmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *createx, *create, *create2, *stats,
- *setquota, *getquota, *setname, *getname, *gettag;
-} memmethods = {
- {
- isc__mem_attach,
- isc__mem_detach,
- isc__mem_destroy,
- isc___mem_get,
- isc___mem_put,
- isc___mem_putanddetach,
- isc___mem_allocate,
- isc___mem_reallocate,
- isc___mem_strdup,
- isc___mem_free,
- isc__mem_setdestroycheck,
- isc__mem_setwater,
- isc__mem_waterack,
- isc__mem_inuse,
- isc__mem_maxinuse,
- isc__mem_total,
- isc__mem_isovermem,
- isc__mempool_create
- },
- (void *)isc_mem_createx,
- (void *)isc_mem_create,
- (void *)isc_mem_create2,
- (void *)isc_mem_stats,
- (void *)isc_mem_setquota,
- (void *)isc_mem_getquota,
- (void *)isc_mem_setname,
- (void *)isc_mem_getname,
- (void *)isc_mem_gettag
-};
-
-static struct isc__mempoolmethods {
- isc_mempoolmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *getfreemax, *getfreecount, *getmaxalloc, *getfillcount;
-} mempoolmethods = {
- {
- isc__mempool_destroy,
- isc___mempool_get,
- isc___mempool_put,
- isc__mempool_getallocated,
- isc__mempool_setmaxalloc,
- isc__mempool_setfreemax,
- isc__mempool_setname,
- isc__mempool_associatelock,
- isc__mempool_setfillcount
- },
- (void *)isc_mempool_getfreemax,
- (void *)isc_mempool_getfreecount,
- (void *)isc_mempool_getmaxalloc,
- (void *)isc_mempool_getfillcount
-};
-
#if ISC_MEM_TRACKLINES
/*!
* mctx must be locked.
ctx->water_arg = NULL;
ctx->common.impmagic = MEM_MAGIC;
ctx->common.magic = ISCAPI_MCTX_MAGIC;
- ctx->common.methods = (isc_memmethods_t *)&memmethods;
ctx->memalloc = memalloc;
ctx->memfree = memfree;
ctx->arg = arg;
if (mpctx == NULL)
return (ISC_R_NOMEMORY);
- mpctx->common.methods = (isc_mempoolmethods_t *)&mempoolmethods;
mpctx->common.impmagic = MEMPOOL_MAGIC;
mpctx->common.magic = ISCAPI_MPOOL_MAGIC;
mpctx->lock = NULL;
isc_result_t
isc_mem_create(size_t init_max_size, size_t target_size, isc_mem_t **mctxp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc_mem_createx2(init_max_size, target_size,
- default_memalloc, default_memfree,
- NULL, mctxp, isc_mem_defaultflags));
- LOCK(&createlock);
-
- REQUIRE(mem_createfunc != NULL);
- result = (*mem_createfunc)(init_max_size, target_size, mctxp,
- isc_mem_defaultflags);
-
- UNLOCK(&createlock);
-
- return (result);
+ return (isc_mem_createx2(init_max_size, target_size,
+ default_memalloc, default_memfree,
+ NULL, mctxp, isc_mem_defaultflags));
}
isc_result_t
isc_mem_create2(size_t init_max_size, size_t target_size, isc_mem_t **mctxp,
unsigned int flags)
{
- if (isc_bind9)
- return (isc_mem_createx2(init_max_size, target_size,
- default_memalloc, default_memfree,
- NULL, mctxp, flags));
-
return (isc_mem_createx2(init_max_size, target_size,
default_memalloc, default_memfree,
NULL, mctxp, flags));
REQUIRE(ISCAPI_MCTX_VALID(source));
REQUIRE(targetp != NULL && *targetp == NULL);
- if (isc_bind9)
- isc__mem_attach(source, targetp);
- else
- source->methods->attach(source, targetp);
+ isc__mem_attach(source, targetp);
ENSURE(*targetp == source);
}
isc_mem_detach(isc_mem_t **mctxp) {
REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
- if (isc_bind9)
- isc__mem_detach(mctxp);
- else
- (*mctxp)->methods->detach(mctxp);
+ isc__mem_detach(mctxp);
ENSURE(*mctxp == NULL);
}
isc_mem_destroy(isc_mem_t **mctxp) {
REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
- if (isc_bind9)
- isc__mem_destroy(mctxp);
- else
- (*mctxp)->methods->destroy(mctxp);
+ isc__mem_destroy(mctxp);
ENSURE(*mctxp == NULL);
}
isc_mem_setdestroycheck(isc_mem_t *mctx, bool flag) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- mctx->methods->setdestroycheck(mctx, flag);
+ isc__mem_setdestroycheck(mctx, flag);
}
void
{
REQUIRE(ISCAPI_MCTX_VALID(ctx));
- if (isc_bind9)
- isc__mem_setwater(ctx, water, water_arg, hiwater, lowater);
- else
- ctx->methods->setwater(ctx, water, water_arg, hiwater, lowater);
+ isc__mem_setwater(ctx, water, water_arg, hiwater, lowater);
}
void
isc_mem_waterack(isc_mem_t *ctx, int flag) {
REQUIRE(ISCAPI_MCTX_VALID(ctx));
- if (isc_bind9)
- isc__mem_waterack(ctx, flag);
- else
- ctx->methods->waterack(ctx, flag);
+ isc__mem_waterack(ctx, flag);
}
size_t
isc_mem_inuse(isc_mem_t *mctx) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc__mem_inuse(mctx));
-
- return (mctx->methods->inuse(mctx));
+ return (isc__mem_inuse(mctx));
}
size_t
isc_mem_maxinuse(isc_mem_t *mctx) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc__mem_maxinuse(mctx));
-
- return (mctx->methods->maxinuse(mctx));
+ return (isc__mem_maxinuse(mctx));
}
size_t
isc_mem_total(isc_mem_t *mctx) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc__mem_total(mctx));
-
- return (mctx->methods->total(mctx));
+ return (isc__mem_total(mctx));
}
bool
isc_mem_isovermem(isc_mem_t *mctx) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc__mem_isovermem(mctx));
-
- return (mctx->methods->isovermem(mctx));
+ return (isc__mem_isovermem(mctx));
}
isc_mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- return (mctx->methods->mpcreate(mctx, size, mpctxp));
+ return (isc__mempool_create(mctx, size, mpctxp));
}
void
isc_mempool_destroy(isc_mempool_t **mpctxp) {
REQUIRE(mpctxp != NULL && ISCAPI_MPOOL_VALID(*mpctxp));
- if (isc_bind9)
- isc__mempool_destroy(mpctxp);
- else
- (*mpctxp)->methods->destroy(mpctxp);
+ isc__mempool_destroy(mpctxp);
ENSURE(*mpctxp == NULL);
}
isc_mempool_getallocated(isc_mempool_t *mpctx) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- return (isc__mempool_getallocated(mpctx));
-
- return (mpctx->methods->getallocated(mpctx));
+ return (isc__mempool_getallocated(mpctx));
}
void
isc_mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- isc__mempool_setmaxalloc(mpctx, limit);
- else
- mpctx->methods->setmaxalloc(mpctx, limit);
+ isc__mempool_setmaxalloc(mpctx, limit);
}
void
isc_mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- isc__mempool_setfreemax(mpctx, limit);
- else
- mpctx->methods->setfreemax(mpctx, limit);
+ isc__mempool_setfreemax(mpctx, limit);
}
void
isc_mempool_setname(isc_mempool_t *mpctx, const char *name) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- isc__mempool_setname(mpctx, name);
- else
- mpctx->methods->setname(mpctx, name);
+ isc__mempool_setname(mpctx, name);
}
void
isc_mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- isc__mempool_associatelock(mpctx, lock);
- else
- mpctx->methods->associatelock(mpctx, lock);
+ isc__mempool_associatelock(mpctx, lock);
}
void
isc_mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- isc__mempool_setfillcount(mpctx, limit);
- else
- mpctx->methods->setfillcount(mpctx, limit);
+ isc__mempool_setfillcount(mpctx, limit);
}
void *
isc__mem_get(isc_mem_t *mctx, size_t size FLARG) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc___mem_get(mctx, size FLARG_PASS));
-
- return (mctx->methods->memget(mctx, size FLARG_PASS));
+ return (isc___mem_get(mctx, size FLARG_PASS));
}
isc__mem_put(isc_mem_t *mctx, void *ptr, size_t size FLARG) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- isc___mem_put(mctx, ptr, size FLARG_PASS);
- else
- mctx->methods->memput(mctx, ptr, size FLARG_PASS);
+ isc___mem_put(mctx, ptr, size FLARG_PASS);
}
void
isc__mem_putanddetach(isc_mem_t **mctxp, void *ptr, size_t size FLARG) {
REQUIRE(mctxp != NULL && ISCAPI_MCTX_VALID(*mctxp));
- if (isc_bind9)
- isc___mem_putanddetach(mctxp, ptr, size FLARG_PASS);
- else
- (*mctxp)->methods->memputanddetach(mctxp, ptr, size FLARG_PASS);
+ isc___mem_putanddetach(mctxp, ptr, size FLARG_PASS);
/*
* XXX: We cannot always ensure *mctxp == NULL here
isc__mem_allocate(isc_mem_t *mctx, size_t size FLARG) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc___mem_allocate(mctx, size FLARG_PASS));
-
- return (mctx->methods->memallocate(mctx, size FLARG_PASS));
+ return (isc___mem_allocate(mctx, size FLARG_PASS));
}
void *
isc__mem_reallocate(isc_mem_t *mctx, void *ptr, size_t size FLARG) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc___mem_reallocate(mctx, ptr, size FLARG_PASS));
-
- return (mctx->methods->memreallocate(mctx, ptr, size FLARG_PASS));
+ return (isc___mem_reallocate(mctx, ptr, size FLARG_PASS));
}
char *
isc__mem_strdup(isc_mem_t *mctx, const char *s FLARG) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- return (isc___mem_strdup(mctx, s FLARG_PASS));
-
- return (mctx->methods->memstrdup(mctx, s FLARG_PASS));
+ return (isc___mem_strdup(mctx, s FLARG_PASS));
}
void
isc__mem_free(isc_mem_t *mctx, void *ptr FLARG) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
- if (isc_bind9)
- isc___mem_free(mctx, ptr FLARG_PASS);
- else
- mctx->methods->memfree(mctx, ptr FLARG_PASS);
+ isc___mem_free(mctx, ptr FLARG_PASS);
}
void *
isc__mempool_get(isc_mempool_t *mpctx FLARG) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- return (isc___mempool_get(mpctx FLARG_PASS));
-
- return (mpctx->methods->get(mpctx FLARG_PASS));
+ return (isc___mempool_get(mpctx FLARG_PASS));
}
void
isc__mempool_put(isc_mempool_t *mpctx, void *mem FLARG) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
- if (isc_bind9)
- isc___mempool_put(mpctx, mem FLARG_PASS);
- else
- mpctx->methods->put(mpctx, mem FLARG_PASS);
+ isc___mempool_put(mpctx, mem FLARG_PASS);
}
isc_result_t
isc_socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__socketmgr_create(mctx, managerp));
-
- LOCK(&createlock);
-
- REQUIRE(socketmgr_createfunc != NULL);
- result = (*socketmgr_createfunc)(mctx, managerp);
-
- UNLOCK(&createlock);
-
- return (result);
+ return (isc__socketmgr_create(mctx, managerp));
}
void
isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
REQUIRE(managerp != NULL && ISCAPI_SOCKETMGR_VALID(*managerp));
- if (isc_bind9)
- isc__socketmgr_destroy(managerp);
- else
- (*managerp)->methods->destroy(managerp);
+ isc__socketmgr_destroy(managerp);
ENSURE(*managerp == NULL);
}
{
REQUIRE(ISCAPI_SOCKETMGR_VALID(manager));
- if (isc_bind9)
- return (isc__socket_create(manager, pf, type, socketp));
-
- return (manager->methods->socketcreate(manager, pf, type, socketp));
+ return (isc__socket_create(manager, pf, type, socketp));
}
void
REQUIRE(ISCAPI_SOCKET_VALID(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
- if (isc_bind9)
- isc__socket_attach(sock, socketp);
- else
- sock->methods->attach(sock, socketp);
+ isc__socket_attach(sock, socketp);
ENSURE(*socketp == sock);
}
isc_socket_detach(isc_socket_t **socketp) {
REQUIRE(socketp != NULL && ISCAPI_SOCKET_VALID(*socketp));
- if (isc_bind9)
- isc__socket_detach(socketp);
- else
- (*socketp)->methods->detach(socketp);
+ isc__socket_detach(socketp);
ENSURE(*socketp == NULL);
}
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_bind(sock, sockaddr, options));
-
- return (sock->methods->bind(sock, sockaddr, options));
+ return (isc__socket_bind(sock, sockaddr, options));
}
isc_result_t
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_sendto(sock, region, task,
- action, arg, address, pktinfo));
-
- return (sock->methods->sendto(sock, region, task, action, arg, address,
- pktinfo));
+ return (isc__socket_sendto(sock, region, task,
+ action, arg, address, pktinfo));
}
isc_result_t
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_connect(sock, addr, task, action, arg));
-
- return (sock->methods->connect(sock, addr, task, action, arg));
+ return (isc__socket_connect(sock, addr, task, action, arg));
}
isc_result_t
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_recv(sock, region, minimum,
- task, action, arg));
-
- return (sock->methods->recv(sock, region, minimum, task, action, arg));
+ return (isc__socket_recv(sock, region, minimum,
+ task, action, arg));
}
void
isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- isc__socket_cancel(sock, task, how);
- else
- sock->methods->cancel(sock, task, how);
+ isc__socket_cancel(sock, task, how);
}
isc_result_t
isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_getsockname(sock, addressp));
-
- return (sock->methods->getsockname(sock, addressp));
+ return (isc__socket_getsockname(sock, addressp));
}
void
isc_socket_ipv6only(isc_socket_t *sock, bool yes) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- isc__socket_ipv6only(sock, yes);
- else
- sock->methods->ipv6only(sock, yes);
+ isc__socket_ipv6only(sock, yes);
}
void
isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- sock->methods->dscp(sock, dscp);
+ isc__socket_dscp(sock, dscp);
}
isc_sockettype_t
isc_socket_gettype(isc_socket_t *sock) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_gettype(sock));
-
- return (sock->methods->gettype(sock));
+ return (isc__socket_gettype(sock));
}
void
{
REQUIRE(ISCAPI_SOCKETMGR_VALID(manager));
- if (isc_bind9)
- return (isc__socket_fdwatchcreate(manager, fd, flags,
- callback, cbarg,
- task, socketp));
-
- return (manager->methods->fdwatchcreate(manager, fd, flags,
- callback, cbarg, task,
- socketp));
+ return (isc__socket_fdwatchcreate(manager, fd, flags,
+ callback, cbarg,
+ task, socketp));
}
isc_result_t
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_fdwatchpoke(sock, flags));
-
- return (sock->methods->fdwatchpoke(sock, flags));
+ return (isc__socket_fdwatchpoke(sock, flags));
}
isc_result_t
REQUIRE(ISCAPI_SOCKET_VALID(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
- if (isc_bind9)
- return (isc__socket_dup(sock, socketp));
-
- return (sock->methods->dup(sock, socketp));
+ return (isc__socket_dup(sock, socketp));
}
int
isc_socket_getfd(isc_socket_t *sock) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
- if (isc_bind9)
- return (isc__socket_getfd(sock));
-
- return (sock->methods->getfd(sock));
+ return (isc__socket_getfd(sock));
}
isc_result_t
unsigned int total_dispatch_count = 0;
isc__tasklist_t new_ready_tasks;
isc__tasklist_t new_priority_tasks;
- unsigned int tasks_ready = 0;
+
REQUIRE(VALID_MANAGER(manager));
isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_taskmgr_t **managerp)
{
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__taskmgr_create(mctx, workers,
- default_quantum, managerp));
- LOCK(&createlock);
-
- REQUIRE(taskmgr_createfunc != NULL);
- result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
- managerp);
-
- UNLOCK(&createlock);
-
- return (result);
+ return (isc__taskmgr_create(mctx, workers,
+ default_quantum, managerp));
}
void
isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
REQUIRE(managerp != NULL && ISCAPI_TASKMGR_VALID(*managerp));
- if (isc_bind9)
- isc__taskmgr_destroy(managerp);
- else
- (*managerp)->methods->destroy(managerp);
+ isc__taskmgr_destroy(managerp);
ENSURE(*managerp == NULL);
}
isc_taskmgr_setmode(isc_taskmgr_t *manager, isc_taskmgrmode_t mode) {
REQUIRE(ISCAPI_TASKMGR_VALID(manager));
- if (isc_bind9)
- isc__taskmgr_setmode(manager, mode);
- else
- manager->methods->setmode(manager, mode);
+ isc__taskmgr_setmode(manager, mode);
}
isc_taskmgrmode_t
isc_taskmgr_mode(isc_taskmgr_t *manager) {
REQUIRE(ISCAPI_TASKMGR_VALID(manager));
- if (isc_bind9)
- return (isc__taskmgr_mode(manager));
-
- return (manager->methods->mode(manager));
+ return (isc__taskmgr_mode(manager));
}
isc_result_t
REQUIRE(ISCAPI_TASKMGR_VALID(manager));
REQUIRE(taskp != NULL && *taskp == NULL);
- if (isc_bind9)
- return (isc__task_create(manager, quantum, taskp));
-
- return (manager->methods->taskcreate(manager, quantum, taskp));
+ return (isc__task_create(manager, quantum, taskp));
}
void
REQUIRE(ISCAPI_TASK_VALID(source));
REQUIRE(targetp != NULL && *targetp == NULL);
- if (isc_bind9)
- isc__task_attach(source, targetp);
- else
- source->methods->attach(source, targetp);
+ isc__task_attach(source, targetp);
ENSURE(*targetp == source);
}
isc_task_detach(isc_task_t **taskp) {
REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
- if (isc_bind9)
- isc__task_detach(taskp);
- else
- (*taskp)->methods->detach(taskp);
+ isc__task_detach(taskp);
ENSURE(*taskp == NULL);
}
REQUIRE(ISCAPI_TASK_VALID(task));
REQUIRE(eventp != NULL && *eventp != NULL);
- if (isc_bind9)
- isc__task_send(task, eventp);
- else {
- task->methods->send(task, eventp);
- ENSURE(*eventp == NULL);
- }
+ isc__task_send(task, eventp);
}
void
REQUIRE(taskp != NULL && ISCAPI_TASK_VALID(*taskp));
REQUIRE(eventp != NULL && *eventp != NULL);
- if (isc_bind9)
- isc__task_sendanddetach(taskp, eventp);
- else {
- (*taskp)->methods->sendanddetach(taskp, eventp);
- ENSURE(*eventp == NULL);
- }
+ isc__task_sendanddetach(taskp, eventp);
ENSURE(*taskp == NULL);
}
{
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- return (isc__task_unsend(task, sender, type, tag, events));
-
- return (task->methods->unsend(task, sender, type, tag, events));
+ return (isc__task_unsend(task, sender, type, tag, events));
}
isc_result_t
{
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- return (isc__task_onshutdown(task, action, arg));
-
- return (task->methods->onshutdown(task, action, arg));
+ return (isc__task_onshutdown(task, action, arg));
}
void
isc_task_shutdown(isc_task_t *task) {
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- isc__task_shutdown(task);
- else
- task->methods->shutdown(task);
+ isc__task_shutdown(task);
}
void
isc_task_destroy(isc_task_t **taskp) {
- if (!isc_bind9)
- return;
-
isc__task_destroy(taskp);
}
isc_task_setname(isc_task_t *task, const char *name, void *tag) {
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- isc__task_setname(task, name, tag);
- else
- task->methods->setname(task, name, tag);
+ isc__task_setname(task, name, tag);
}
unsigned int
{
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- return (isc__task_purge(task, sender, type, tag));
-
- return (task->methods->purgeevents(task, sender, type, tag));
+ return (isc__task_purge(task, sender, type, tag));
}
isc_result_t
isc_task_beginexclusive(isc_task_t *task) {
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- return (isc__task_beginexclusive(task));
-
- return (task->methods->beginexclusive(task));
+ return (isc__task_beginexclusive(task));
}
void
isc_task_endexclusive(isc_task_t *task) {
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- isc__task_endexclusive(task);
- else
- task->methods->endexclusive(task);
+ isc__task_endexclusive(task);
}
void
isc_task_setprivilege(isc_task_t *task, bool priv) {
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- isc__task_setprivilege(task, priv);
- else
- task->methods->setprivilege(task, priv);
+ isc__task_setprivilege(task, priv);
}
bool
isc_task_privilege(isc_task_t *task) {
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- return (isc__task_privilege(task));
-
- return (task->methods->privilege(task));
+ return (isc__task_privilege(task));
}
void
isc_task_getcurrenttime(isc_task_t *task, isc_stdtime_t *t) {
- if (!isc_bind9)
- return;
-
isc__task_getcurrenttime(task, t);
}
void
isc_task_getcurrenttimex(isc_task_t *task, isc_time_t *t) {
- if (!isc_bind9)
- return;
-
isc__task_getcurrenttimex(task, t);
}
{
REQUIRE(ISCAPI_TASK_VALID(task));
- if (isc_bind9)
- return (isc__task_purgerange(task, sender, first, last, tag));
-
- return (task->methods->purgerange(task, sender, first, last, tag));
+ return (isc__task_purgerange(task, sender, first, last, tag));
}
void
isc__timermgr_destroy(isc_timermgr_t **managerp);
-static struct isc__timermethods {
- isc_timermethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *gettype;
-} timermethods = {
- {
- isc__timer_attach,
- isc__timer_detach,
- isc__timer_reset,
- isc__timer_touch
- },
- (void *)isc_timer_gettype
-};
-
-static struct isc__timermgrmethods {
- isc_timermgrmethods_t methods;
- void *poke; /* see above */
-} timermgrmethods = {
- {
- isc__timermgr_destroy,
- isc__timer_create
- },
- (void *)isc_timermgr_poke
-};
-
static inline isc_result_t
schedule(isc__timer_t *timer, isc_time_t *now, bool signal_ok) {
isc_result_t result;
ISC_LINK_INIT(timer, link);
timer->common.impmagic = TIMER_MAGIC;
timer->common.magic = ISCAPI_TIMER_MAGIC;
- timer->common.methods = (isc_timermethods_t *)&timermethods;
LOCK(&manager->lock);
manager->common.impmagic = TIMER_MANAGER_MAGIC;
manager->common.magic = ISCAPI_TIMERMGR_MAGIC;
- manager->common.methods = (isc_timermgrmethods_t *)&timermgrmethods;
manager->mctx = NULL;
manager->done = false;
INIT_LIST(manager->timers);
isc_result_t
isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
- isc_result_t result;
-
- if (isc_bind9)
- return (isc__timermgr_create(mctx, managerp));
-
- LOCK(&createlock);
-
- REQUIRE(timermgr_createfunc != NULL);
- result = (*timermgr_createfunc)(mctx, managerp);
-
- UNLOCK(&createlock);
-
- return (result);
+ return (isc__timermgr_create(mctx, managerp));
}
void
isc_timermgr_destroy(isc_timermgr_t **managerp) {
REQUIRE(*managerp != NULL && ISCAPI_TIMERMGR_VALID(*managerp));
- if (isc_bind9)
- isc__timermgr_destroy(managerp);
- else
- (*managerp)->methods->destroy(managerp);
+ isc__timermgr_destroy(managerp);
ENSURE(*managerp == NULL);
}
{
REQUIRE(ISCAPI_TIMERMGR_VALID(manager));
- if (isc_bind9)
- return (isc__timer_create(manager, type, expires, interval,
- task, action, arg, timerp));
-
- return (manager->methods->timercreate(manager, type, expires,
- interval, task, action, arg,
- timerp));
+ return (isc__timer_create(manager, type, expires, interval,
+ task, action, arg, timerp));
}
void
REQUIRE(ISCAPI_TIMER_VALID(timer));
REQUIRE(timerp != NULL && *timerp == NULL);
- if (isc_bind9)
- isc__timer_attach(timer, timerp);
- else
- timer->methods->attach(timer, timerp);
+ isc__timer_attach(timer, timerp);
ENSURE(*timerp == timer);
}
isc_timer_detach(isc_timer_t **timerp) {
REQUIRE(timerp != NULL && ISCAPI_TIMER_VALID(*timerp));
- if (isc_bind9)
- isc__timer_detach(timerp);
- else
- (*timerp)->methods->detach(timerp);
+ isc__timer_detach(timerp);
ENSURE(*timerp == NULL);
}
{
REQUIRE(ISCAPI_TIMER_VALID(timer));
- if (isc_bind9)
- return (isc__timer_reset(timer, type, expires,
- interval, purge));
-
- return (timer->methods->reset(timer, type, expires, interval, purge));
+ return (isc__timer_reset(timer, type, expires,
+ interval, purge));
}
isc_result_t
isc_timer_touch(isc_timer_t *timer) {
REQUIRE(ISCAPI_TIMER_VALID(timer));
- if (isc_bind9)
- return (isc__timer_touch(timer));
-
- return (timer->methods->touch(timer));
+ return (isc__timer_touch(timer));
}
static isc__appctx_t isc_g_appctx;
-static struct {
- isc_appmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *run, *shutdown, *start, *reload, *finish, *block, *unblock;
-} appmethods = {
- {
- isc__appctx_destroy,
- isc__app_ctxstart,
- isc__app_ctxrun,
- isc__app_ctxsuspend,
- isc__app_ctxshutdown,
- isc__app_ctxfinish,
- isc__appctx_settaskmgr,
- isc__appctx_setsocketmgr,
- isc__appctx_settimermgr,
- isc__app_ctxonrun
- },
- (void *)isc__app_run,
- (void *)isc__app_shutdown,
- (void *)isc__app_start,
- (void *)isc__app_reload,
- (void *)isc__app_finish,
- (void *)isc__app_block,
- (void *)isc__app_unblock
-};
-
#ifdef HAVE_LINUXTHREADS
/*!
* Linux has sigwait(), but it appears to prevent signal handlers from
isc__app_start(void) {
isc_g_appctx.common.impmagic = APPCTX_MAGIC;
isc_g_appctx.common.magic = ISCAPI_APPCTX_MAGIC;
- isc_g_appctx.common.methods = &appmethods.methods;
isc_g_appctx.mctx = NULL;
/* The remaining members will be initialized in ctxstart() */
ctx->common.impmagic = APPCTX_MAGIC;
ctx->common.magic = ISCAPI_APPCTX_MAGIC;
- ctx->common.methods = &appmethods.methods;
ctx->mctx = NULL;
isc_mem_attach(mctx, &ctx->mctx);
isc__socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats);
#endif
-static struct {
- isc_socketmethods_t methods;
-
- /*%
- * The following are defined just for avoiding unused static functions.
- */
- void *recvv, *send, *sendv, *sendto2, *cleanunix, *permunix, *filter,
- *listen, *accept, *getpeername, *isbound;
-} socketmethods = {
- {
- isc__socket_attach,
- isc__socket_detach,
- isc__socket_bind,
- isc__socket_sendto,
- isc__socket_sendto2,
- isc__socket_connect,
- isc__socket_recv,
- isc__socket_recv2,
- isc__socket_cancel,
- isc__socket_getsockname,
- isc__socket_gettype,
- isc__socket_ipv6only,
- isc__socket_fdwatchpoke,
- isc__socket_dup,
- isc__socket_getfd,
- isc__socket_dscp
- },
- (void *)isc__socket_recvv, (void *)isc__socket_send,
- (void *)isc__socket_sendv, (void *)isc__socket_sendto2,
- (void *)isc__socket_cleanunix, (void *)isc__socket_permunix,
- (void *)isc__socket_filter, (void *)isc__socket_listen,
- (void *)isc__socket_accept, (void *)isc__socket_getpeername,
- (void *)isc__socket_isbound
-};
-
-static isc_socketmgrmethods_t socketmgrmethods = {
- isc__socketmgr_destroy,
- isc__socket_create,
- isc__socket_fdwatchcreate
-};
-
#define SELECT_POKE_SHUTDOWN (-1)
#define SELECT_POKE_NOTHING (-2)
#define SELECT_POKE_READ (-3)
return (result);
}
- sock->common.methods = (isc_socketmethods_t *)&socketmethods;
sock->references = 1;
*socketp = (isc_socket_t *)sock;
sock->fdwatchtask = task;
sock->statsindex = fdwatchstatsindex;
- sock->common.methods = (isc_socketmethods_t *)&socketmethods;
sock->references = 1;
*socketp = (isc_socket_t *)sock;
#endif
manager->stats = NULL;
- manager->common.methods = &socketmgrmethods;
manager->common.magic = ISCAPI_SOCKETMGR_MAGIC;
manager->common.impmagic = SOCKET_MANAGER_MAGIC;
manager->mctx = NULL;
projects / thirdparty / bind9.git / commitdiff
