upstream/bind9
1
0
Fork 0
mirror of https://github.com/isc-projects/bind9.git synced 2026-03-27 21:04:17 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge branch '479-remove-isc_bind9' into 'master'

Browse source 
Remove isc_bind9 from (almost) everywhere

Closes #479

See merge request isc-projects/bind9!656
This commit is contained in:
Witold Krecicki 2018-10-18 06:39:42 -04:00
commit aaa66d2560
29 changed files with 490 additions and 2784 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
bin/named/main.c
View file

@ -831,7 +831,7 @@ create_managers(void) {
isc_result_totext(result));
return (ISC_R_UNEXPECTED);
}
isc__socketmgr_maxudp(named_g_socketmgr, maxudp);
isc_socketmgr_maxudp(named_g_socketmgr, maxudp);
result = isc_socketmgr_getmaxsockets(named_g_socketmgr, &socks);
if (result == ISC_R_SUCCESS) {
isc_log_write(named_g_lctx, NAMED_LOGCATEGORY_GENERAL,

2
bin/named/server.c
View file

@ -8120,7 +8120,7 @@ load_configuration(const char *filename, named_server_t *server,
"less than 128 UDP sockets available after "
"applying 'reserved-sockets' and 'maxsockets'");
}
isc__socketmgr_setreserved(named_g_socketmgr, reserved);
isc_socketmgr_setreserved(named_g_socketmgr, reserved);
#ifdef HAVE_GEOIP
/*

2
lib/dns/dnstap.c
View file

@ -167,7 +167,7 @@ dt_init(void) {
int ret;
if (dt_mctx == NULL)
result = isc_mem_create2(0, 0, &dt_mctx, 0);
result = isc_mem_create(0, 0, &dt_mctx);
if (result != ISC_R_SUCCESS)
goto unlock;
isc_mem_setname(dt_mctx, "dt", NULL);

4
lib/dns/dst_api.c
View file

@ -159,8 +159,8 @@ dst_lib_init(isc_mem_t *mctx, const char *engine) {
* ISC_MEMFLAG_INTERNAL as it will free up memory still being used
* by libcrypto.
*/
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &dst__memory_pool, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &dst__memory_pool, 0);
if (result != ISC_R_SUCCESS)
return (result);
isc_mem_setname(dst__memory_pool, "dst", NULL);

2
lib/dns/geoip.c
View file

@ -114,7 +114,7 @@ state_key_init(void) {
int ret;
if (state_mctx == NULL)
result = isc_mem_create2(0, 0, &state_mctx, 0);
result = isc_mem_create(0, 0, &state_mctx);
if (result != ISC_R_SUCCESS)
goto unlock;
isc_mem_setname(state_mctx, "geoip_state", NULL);

2
lib/dns/name.c
View file

@ -1301,7 +1301,7 @@ totext_filter_proc_key_init(void) {
if (!thread_key_initialized) {
LOCK(&thread_key_mutex);
if (thread_key_mctx == NULL)
result = isc_mem_create2(0, 0, &thread_key_mctx, 0);
result = isc_mem_create(0, 0, &thread_key_mctx);
if (result != ISC_R_SUCCESS)
goto unlock;
isc_mem_setname(thread_key_mctx, "threadkey", NULL);

24
lib/dns/view.c
View file

@ -121,16 +121,15 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
goto cleanup_name;
view->zonetable = NULL;
if (isc_bind9) {
result = dns_zt_create(mctx, rdclass, &view->zonetable);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"dns_zt_create() failed: %s",
isc_result_totext(result));
result = ISC_R_UNEXPECTED;
goto cleanup_mutex;
}
result = dns_zt_create(mctx, rdclass, &view->zonetable);
if (result != ISC_R_SUCCESS) {
UNEXPECTED_ERROR(__FILE__, __LINE__,
"dns_zt_create() failed: %s",
isc_result_totext(result));
result = ISC_R_UNEXPECTED;
goto cleanup_mutex;
}
view->secroots_priv = NULL;
view->ntatable_priv = NULL;
view->fwdtable = NULL;
@ -264,10 +263,9 @@ dns_view_create(isc_mem_t *mctx, dns_rdataclass_t rdclass,
if (result != ISC_R_SUCCESS)
goto cleanup_dynkeys;
if (isc_bind9) {
result = dns_order_create(view->mctx, &view->order);
if (result != ISC_R_SUCCESS)
goto cleanup_new_zone_lock;
result = dns_order_create(view->mctx, &view->order);
if (result != ISC_R_SUCCESS) {
goto cleanup_new_zone_lock;
}
result = dns_peerlist_new(view->mctx, &view->peers);

253
lib/isc/app_api.c
View file

@ -1,253 +0,0 @@
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <config.h>
#include <stdbool.h>
#include <unistd.h>
#include <isc/app.h>
#include <isc/magic.h>
#include <isc/mutex.h>
#include <isc/once.h>
#include <isc/util.h>
static isc_mutex_t createlock;
static isc_once_t once = ISC_ONCE_INIT;
static isc_appctxcreatefunc_t appctx_createfunc = NULL;
static bool is_running = false;
#define ISCAPI_APPMETHODS_VALID(m) ISC_MAGIC_VALID(m, ISCAPI_APPMETHODS_MAGIC)
static void
initialize(void) {
RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
}
isc_result_t
isc_app_register(isc_appctxcreatefunc_t createfunc) {
isc_result_t result = ISC_R_SUCCESS;
RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
LOCK(&createlock);
if (appctx_createfunc == NULL)
appctx_createfunc = createfunc;
else
result = ISC_R_EXISTS;
UNLOCK(&createlock);
return (result);
}
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);
}
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);
ENSURE(*ctxp == NULL);
}
isc_result_t
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));
}
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));
}
isc_result_t
isc_app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx,
isc_task_t *task, isc_taskaction_t action,
void *arg)
{
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));
}
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));
}
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));
}
void
isc_app_ctxfinish(isc_appctx_t *ctx) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
if (isc_bind9)
isc__app_ctxfinish(ctx);
ctx->methods->ctxfinish(ctx);
}
void
isc_appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
REQUIRE(taskmgr != NULL);
if (isc_bind9)
isc__appctx_settaskmgr(ctx, taskmgr);
ctx->methods->settaskmgr(ctx, taskmgr);
}
void
isc_appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
REQUIRE(socketmgr != NULL);
if (isc_bind9)
isc__appctx_setsocketmgr(ctx, socketmgr);
ctx->methods->setsocketmgr(ctx, socketmgr);
}
void
isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr) {
REQUIRE(ISCAPI_APPCTX_VALID(ctx));
REQUIRE(timermgr != NULL);
if (isc_bind9)
isc__appctx_settimermgr(ctx, timermgr);
ctx->methods->settimermgr(ctx, timermgr);
}
isc_result_t
isc_app_start(void) {
if (isc_bind9)
return (isc__app_start());
return (ISC_R_NOTIMPLEMENTED);
}
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);
}
isc_result_t
isc_app_run() {
if (isc_bind9) {
isc_result_t result;
is_running = true;
result = isc__app_run();
is_running = false;
return (result);
}
return (ISC_R_NOTIMPLEMENTED);
}
bool
isc_app_isrunning() {
return (is_running);
}
isc_result_t
isc_app_shutdown(void) {
if (isc_bind9)
return (isc__app_shutdown());
return (ISC_R_NOTIMPLEMENTED);
}
isc_result_t
isc_app_reload(void) {
if (isc_bind9)
return (isc__app_reload());
return (ISC_R_NOTIMPLEMENTED);
}
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();
}

47
lib/isc/include/isc/app.h
View file

@ -94,29 +94,6 @@ typedef isc_event_t isc_appevent_t;
#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.
@ -129,7 +106,6 @@ typedef struct isc_appmethods {
struct isc_appctx {
unsigned int impmagic;
unsigned int magic;
isc_appmethods_t *methods;
};
#define ISCAPI_APPCTX_MAGIC ISC_MAGIC('A','a','p','c')
@ -357,29 +333,6 @@ isc_appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr);
*\li 'timermgr' is a valid timer manager.
*/
/*%<
* See isc_appctx_create() above.
*/
typedef isc_result_t
(*isc_appctxcreatefunc_t)(isc_mem_t *mctx, isc_appctx_t **ctxp);
isc_result_t
isc_app_register(isc_appctxcreatefunc_t createfunc);
/*%<
* Register a new application implementation and add it to the list of
* supported implementations. This function must be called when a different
* event library is used than the one contained in the ISC library.
*/
isc_result_t
isc__app_register(void);
/*%<
* A short cut function that specifies the application module in the ISC
* library for isc_app_register(). An application that uses the ISC library
* usually do not have to care about this function: it would call
* isc_lib_register(), which internally calls this function.
*/
ISC_LANG_ENDDECLS
#endif /* ISC_APP_H */

107
lib/isc/include/isc/mem.h
View file

@ -125,7 +125,7 @@ LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_defaultflags;
#endif
/*
* Flags for isc_mem_create2()calls.
* Flags for isc_mem_createx() calls.
*/
#define ISC_MEMFLAG_NOLOCK 0x00000001 /* no lock is necessary */
#define ISC_MEMFLAG_INTERNAL 0x00000002 /* use internal malloc */
@ -137,21 +137,6 @@ LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_defaultflags;
#define ISC_MEMFLAG_DEFAULT ISC_MEMFLAG_INTERNAL|ISC_MEMFLAG_FILL
#endif
/*%<
* We use either isc___mem (three underscores) or isc__mem (two) depending on
* whether it's for BIND9's internal purpose (with -DBIND9) or generic export
* library.
*/
#define ISCMEMFUNC(sfx) isc__mem_ ## sfx
#define ISCMEMPOOLFUNC(sfx) isc__mempool_ ## sfx
#define isc_mem_get(c, s) ISCMEMFUNC(get)((c), (s) _ISC_MEM_FILELINE)
#define isc_mem_allocate(c, s) ISCMEMFUNC(allocate)((c), (s) _ISC_MEM_FILELINE)
#define isc_mem_reallocate(c, p, s) ISCMEMFUNC(reallocate)((c), (p), (s) _ISC_MEM_FILELINE)
#define isc_mem_strdup(c, p) ISCMEMFUNC(strdup)((c), (p) _ISC_MEM_FILELINE)
#define isc_mempool_get(c) ISCMEMPOOLFUNC(get)((c) _ISC_MEM_FILELINE)
/*%
* isc_mem_putanddetach() is a convenience function for use where you
* have a structure with an attached memory context.
@ -183,9 +168,6 @@ LIBISC_EXTERNAL_DATA extern unsigned int isc_mem_defaultflags;
/*% 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,
@ -195,30 +177,8 @@ typedef struct isc_memmethods {
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.
@ -245,13 +205,33 @@ struct isc_mem {
struct isc_mempool {
unsigned int impmagic;
unsigned int magic;
isc_mempoolmethods_t *methods;
};
#define ISCAPI_MPOOL_MAGIC ISC_MAGIC('A','m','p','l')
#define ISCAPI_MPOOL_VALID(mp) ((mp) != NULL && \
(mp)->magic == ISCAPI_MPOOL_MAGIC)
/*%
* These functions are actually implemented in isc__mem_<function>
* (two underscores). The single-underscore macros are used to pass
* __FILE__ and __LINE__, and in the case of the put functions, to
* set the pointer being freed to NULL in the calling function.
*
* Many of these functions have a further isc___mem_<function>
* (three underscores) implementation, which is called indirectly
* via the isc_memmethods structure in the mctx so that dynamically
* loaded modules can use them even if named is statically linked.
*/
#define ISCMEMFUNC(sfx) isc__mem_ ## sfx
#define ISCMEMPOOLFUNC(sfx) isc__mempool_ ## sfx
#define isc_mem_get(c, s) ISCMEMFUNC(get)((c), (s) _ISC_MEM_FILELINE)
#define isc_mem_allocate(c, s) ISCMEMFUNC(allocate)((c), (s) _ISC_MEM_FILELINE)
#define isc_mem_reallocate(c, p, s) ISCMEMFUNC(reallocate)((c), (p), (s) _ISC_MEM_FILELINE)
#define isc_mem_strdup(c, p) ISCMEMFUNC(strdup)((c), (p) _ISC_MEM_FILELINE)
#define isc_mempool_get(c) ISCMEMPOOLFUNC(get)((c) _ISC_MEM_FILELINE)
#define isc_mem_put(c, p, s) \
do { \
ISCMEMFUNC(put)((c), (p), (s) _ISC_MEM_FILELINE); \
@ -278,19 +258,10 @@ isc_result_t
isc_mem_create(size_t max_size, size_t target_size,
isc_mem_t **mctxp);
isc_result_t
isc_mem_create2(size_t max_size, size_t target_size,
isc_mem_t **mctxp, unsigned int flags);
isc_result_t
isc_mem_createx(size_t max_size, size_t target_size,
isc_memalloc_t memalloc, isc_memfree_t memfree,
void *arg, isc_mem_t **mctxp);
isc_result_t
isc_mem_createx2(size_t max_size, size_t target_size,
isc_memalloc_t memalloc, isc_memfree_t memfree,
void *arg, isc_mem_t **mctxp, unsigned int flags);
void *arg, isc_mem_t **mctxp, unsigned int flags);
/*!<
* \brief Create a memory context.
@ -702,38 +673,6 @@ ISCMEMPOOLFUNC(get)(isc_mempool_t * _ISC_MEM_FLARG);
void
ISCMEMPOOLFUNC(put)(isc_mempool_t *, void * _ISC_MEM_FLARG);
/*%<
* See isc_mem_create2() above.
*/
typedef isc_result_t
(*isc_memcreatefunc_t)(size_t init_max_size, size_t target_size,
isc_mem_t **ctxp, unsigned int flags);
isc_result_t
isc_mem_register(isc_memcreatefunc_t createfunc);
/*%<
* Register a new memory management implementation and add it to the list of
* supported implementations. This function must be called when a different
* memory management library is used than the one contained in the ISC library.
*/
isc_result_t
isc__mem_register(void);
/*%<
* A short cut function that specifies the memory management module in the ISC
* library for isc_mem_register(). An application that uses the ISC library
* usually do not have to care about this function: it would call
* isc_lib_register(), which internally calls this function.
*/
void
isc__mem_printactive(isc_mem_t *mctx, FILE *file);
/*%<
* For internal use by the isc module and its unit tests, these functions
* print lists of active memory blocks for a single memory context or for
* all contexts.
*/
ISC_LANG_ENDDECLS
#endif /* ISC_MEM_H */

128
lib/isc/include/isc/socket.h
View file

@ -62,55 +62,6 @@
#include <isc/types.h>
#include <isc/xml.h>
#ifdef WIN32
/* from the old namespace.h */
#define isc_socket_create isc__socket_create
#define isc_socket_dup isc__socket_dup
#define isc_socket_attach isc__socket_attach
#define isc_socket_detach isc__socket_detach
#define isc_socketmgr_create isc__socketmgr_create
#define isc_socketmgr_create2 isc__socketmgr_create2
#define isc_socketmgr_destroy isc__socketmgr_destroy
#define isc_socket_open isc__socket_open
#define isc_socket_close isc__socket_close
#define isc_socket_recvv isc__socket_recvv
#define isc_socket_recv isc__socket_recv
#define isc_socket_recv2 isc__socket_recv2
#define isc_socket_send isc__socket_send
#define isc_socket_sendto isc__socket_sendto
#define isc_socket_sendv isc__socket_sendv
#define isc_socket_sendtov isc__socket_sendtov
#define isc_socket_sendtov2 isc__socket_sendtov2
#define isc_socket_sendto2 isc__socket_sendto2
#define isc_socket_cleanunix isc__socket_cleanunix
#define isc_socket_permunix isc__socket_permunix
#define isc_socket_bind isc__socket_bind
#define isc_socket_filter isc__socket_filter
#define isc_socket_listen isc__socket_listen
#define isc_socket_accept isc__socket_accept
#define isc_socket_connect isc__socket_connect
#define isc_socket_getfd isc__socket_getfd
#define isc_socket_getname isc__socket_getname
#define isc_socket_gettag isc__socket_gettag
#define isc_socket_getpeername isc__socket_getpeername
#define isc_socket_getsockname isc__socket_getsockname
#define isc_socket_cancel isc__socket_cancel
#define isc_socket_gettype isc__socket_gettype
#define isc_socket_isbound isc__socket_isbound
#define isc_socket_ipv6only isc__socket_ipv6only
#define isc_socket_setname isc__socket_setname
#define isc_socketmgr_getmaxsockets isc__socketmgr_getmaxsockets
#define isc_socketmgr_setstats isc__socketmgr_setstats
#define isc_socketmgr_setreserved isc__socketmgr_setreserved
#define isc__socketmgr_maxudp isc___socketmgr_maxudp
#define isc_socket_fdwatchcreate isc__socket_fdwatchcreate
#define isc_socket_fdwatchpoke isc__socket_fdwatchpoke
#define isc_socket_dscp isc__socket_dscp
#endif
ISC_LANG_BEGINDECLS
/***
@ -333,60 +284,6 @@ typedef enum {
#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,
isc_socket_options_t 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.
@ -404,7 +301,6 @@ typedef struct isc_socketmethods {
struct isc_socketmgr {
unsigned int impmagic;
unsigned int magic;
isc_socketmgrmethods_t *methods;
};
#endif
@ -420,7 +316,6 @@ struct isc_socketmgr {
struct isc_socket {
unsigned int impmagic;
unsigned int magic;
isc_socketmethods_t *methods;
};
#endif
@ -1138,7 +1033,7 @@ isc_socket_gettype(isc_socket_t *sock);
/*@{*/
bool
isc__socket_isbound(isc_socket_t *sock);
isc_socket_isbound(isc_socket_t *sock);
/*%
* Intended for internal use in BIND9 only
*/
@ -1231,13 +1126,13 @@ int isc_socket_getfd(isc_socket_t *socket);
*/
void
isc__socketmgr_setreserved(isc_socketmgr_t *mgr, uint32_t);
isc_socketmgr_setreserved(isc_socketmgr_t *mgr, uint32_t);
/*%<
* Temporary. For use by named only.
*/
void
isc__socketmgr_maxudp(isc_socketmgr_t *mgr, int maxudp);
isc_socketmgr_maxudp(isc_socketmgr_t *mgr, int maxudp);
/*%<
* Test interface. Drop UDP packet > 'maxudp'.
*/
@ -1264,23 +1159,6 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr, json_object *stats);
typedef isc_result_t
(*isc_socketmgrcreatefunc_t)(isc_mem_t *mctx, isc_socketmgr_t **managerp);
isc_result_t
isc_socket_register(isc_socketmgrcreatefunc_t createfunc);
/*%<
* Register a new socket I/O implementation and add it to the list of
* supported implementations. This function must be called when a different
* event library is used than the one contained in the ISC library.
*/
isc_result_t
isc__socket_register(void);
/*%<
* A short cut function that specifies the socket I/O module in the ISC
* library for isc_socket_register(). An application that uses the ISC library
* usually do not have to care about this function: it would call
* isc_lib_register(), which internally calls this function.
*/
ISC_LANG_ENDDECLS
#endif /* ISC_SOCKET_H */

73
lib/isc/include/isc/task.h
View file

@ -102,42 +102,6 @@ typedef enum {
isc_taskmgrmode_privileged
} isc_taskmgrmode_t;
/*% Task and task manager methods */
typedef struct isc_taskmgrmethods {
void (*destroy)(isc_taskmgr_t **managerp);
void (*setmode)(isc_taskmgr_t *manager,
isc_taskmgrmode_t mode);
isc_taskmgrmode_t (*mode)(isc_taskmgr_t *manager);
isc_result_t (*taskcreate)(isc_taskmgr_t *manager,
unsigned int quantum,
isc_task_t **taskp);
void (*setexcltask)(isc_taskmgr_t *mgr, isc_task_t *task);
isc_result_t (*excltask)(isc_taskmgr_t *mgr, isc_task_t **taskp);
} isc_taskmgrmethods_t;
typedef struct isc_taskmethods {
void (*attach)(isc_task_t *source, isc_task_t **targetp);
void (*detach)(isc_task_t **taskp);
void (*destroy)(isc_task_t **taskp);
void (*send)(isc_task_t *task, isc_event_t **eventp);
void (*sendanddetach)(isc_task_t **taskp, isc_event_t **eventp);
unsigned int (*unsend)(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag, isc_eventlist_t *events);
isc_result_t (*onshutdown)(isc_task_t *task, isc_taskaction_t action,
void *arg);
void (*shutdown)(isc_task_t *task);
void (*setname)(isc_task_t *task, const char *name, void *tag);
unsigned int (*purgeevents)(isc_task_t *task, void *sender,
isc_eventtype_t type, void *tag);
unsigned int (*purgerange)(isc_task_t *task, void *sender,
isc_eventtype_t first, isc_eventtype_t last,
void *tag);
isc_result_t (*beginexclusive)(isc_task_t *task);
void (*endexclusive)(isc_task_t *task);
void (*setprivilege)(isc_task_t *task, bool priv);
bool (*privilege)(isc_task_t *task);
} isc_taskmethods_t;
/*%
* This structure is actually just the common prefix of a task manager
* object implementation's version of an isc_taskmgr_t.
@ -150,7 +114,6 @@ typedef struct isc_taskmethods {
struct isc_taskmgr {
unsigned int impmagic;
unsigned int magic;
isc_taskmgrmethods_t *methods;
};
#define ISCAPI_TASKMGR_MAGIC ISC_MAGIC('A','t','m','g')
@ -164,7 +127,6 @@ struct isc_taskmgr {
struct isc_task {
unsigned int impmagic;
unsigned int magic;
isc_taskmethods_t *methods;
};
#define ISCAPI_TASK_MAGIC ISC_MAGIC('A','t','s','t')
@ -797,41 +759,6 @@ isc_result_t
isc_taskmgr_renderjson(isc_taskmgr_t *mgr, json_object *tasksobj);
#endif
/*%<
* See isc_taskmgr_create() above.
*/
typedef isc_result_t
(*isc_taskmgrcreatefunc_t)(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum,
isc_taskmgr_t **managerp);
isc_result_t
isc_task_register(isc_taskmgrcreatefunc_t createfunc);
/*%<
* Register a new task management implementation and add it to the list of
* supported implementations. This function must be called when a different
* event library is used than the one contained in the ISC library.
*/
isc_result_t
isc__task_register(void);
/*%<
* A short cut function that specifies the task management module in the ISC
* library for isc_task_register(). An application that uses the ISC library
* usually do not have to care about this function: it would call
* isc_lib_register(), which internally calls this function.
*/
/*%<
* These functions allow unit tests to manipulate the processing
* of the task queue. They are not intended as part of the public API.
*/
void
isc__taskmgr_pause(isc_taskmgr_t *taskmgr);
void
isc__taskmgr_resume(isc_taskmgr_t *taskmgr);
ISC_LANG_ENDDECLS
#endif /* ISC_TASK_H */

48
lib/isc/include/isc/timer.h
View file

@ -99,29 +99,6 @@ typedef struct isc_timerevent {
#define ISC_TIMEREVENT_LIFE (ISC_EVENTCLASS_TIMER + 3)
#define ISC_TIMEREVENT_LASTEVENT (ISC_EVENTCLASS_TIMER + 65535)
/*% Timer and timer manager methods */
typedef struct {
void (*destroy)(isc_timermgr_t **managerp);
isc_result_t (*timercreate)(isc_timermgr_t *manager,
isc_timertype_t type,
const isc_time_t *expires,
const isc_interval_t *interval,
isc_task_t *task,
isc_taskaction_t action,
void *arg,
isc_timer_t **timerp);
} isc_timermgrmethods_t;
typedef struct {
void (*attach)(isc_timer_t *timer, isc_timer_t **timerp);
void (*detach)(isc_timer_t **timerp);
isc_result_t (*reset)(isc_timer_t *timer, isc_timertype_t type,
const isc_time_t *expires,
const isc_interval_t *interval,
bool purge);
isc_result_t (*touch)(isc_timer_t *timer);
} isc_timermethods_t;
/*%
* This structure is actually just the common prefix of a timer manager
* object implementation's version of an isc_timermgr_t.
@ -134,7 +111,6 @@ typedef struct {
struct isc_timermgr {
unsigned int impmagic;
unsigned int magic;
isc_timermgrmethods_t *methods;
};
#define ISCAPI_TIMERMGR_MAGIC ISC_MAGIC('A','t','m','g')
@ -148,7 +124,6 @@ struct isc_timermgr {
struct isc_timer {
unsigned int impmagic;
unsigned int magic;
isc_timermethods_t *methods;
};
#define ISCAPI_TIMER_MAGIC ISC_MAGIC('A','t','m','r')
@ -398,29 +373,6 @@ isc_timermgr_destroy(isc_timermgr_t **managerp);
void isc_timermgr_poke(isc_timermgr_t *m);
/*%<
* See isc_timermgr_create() above.
*/
typedef isc_result_t
(*isc_timermgrcreatefunc_t)(isc_mem_t *mctx, isc_timermgr_t **managerp);
isc_result_t
isc__timer_register(void);
/*%<
* Register a new timer management implementation and add it to the list of
* supported implementations. This function must be called when a different
* event library is used than the one contained in the ISC library.
*/
isc_result_t
isc_timer_register(isc_timermgrcreatefunc_t createfunc);
/*%<
* A short cut function that specifies the timer management module in the ISC
* library for isc_timer_register(). An application that uses the ISC library
* usually do not have to care about this function: it would call
* isc_lib_register(), which internally calls this function.
*/
ISC_LANG_ENDDECLS
#endif /* ISC_TIMER_H */

16
lib/isc/lib.c
View file

@ -77,21 +77,7 @@ isc_lib_initmsgcat(void) {
}
}
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(&register_once, do_register)
== ISC_R_SUCCESS);
isc_bind9 = false;
}

563
lib/isc/mem.c
View file

@ -34,6 +34,8 @@
#include <isc/util.h>
#include <isc/xml.h>
#include "mem_p.h"
#define MCTXLOCK(m, l) if (((m)->flags & ISC_MEMFLAG_NOLOCK) == 0) LOCK(l)
#define MCTXUNLOCK(m, l) if (((m)->flags & ISC_MEMFLAG_NOLOCK) == 0) UNLOCK(l)
@ -111,7 +113,6 @@ static ISC_LIST(isc__mem_t) contexts;
static isc_once_t once = ISC_ONCE_INIT;
static isc_mutex_t contextslock;
static isc_mutex_t createlock;
/*%
* Total size of lost memory due to a bug of external library.
@ -220,158 +221,29 @@ print_active(isc__mem_t *ctx, FILE *out);
#endif /* ISC_MEM_TRACKLINES */
/*%
* The following are intended for internal use (indicated by "isc__"
* prefix) but are not declared as static, allowing direct access
* from unit tests, etc.
*/
isc_result_t
isc__mem_create2(size_t init_max_size, size_t target_size,
isc_mem_t **ctxp, unsigned int flags);
void
isc__mem_attach(isc_mem_t *source, isc_mem_t **targetp);
void
isc__mem_detach(isc_mem_t **ctxp);
void
isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG);
void
isc__mem_destroy(isc_mem_t **ctxp);
void *
static void *
isc___mem_get(isc_mem_t *ctx, size_t size FLARG);
void
static void
isc___mem_put(isc_mem_t *ctx, void *ptr, size_t size FLARG);
void
isc__mem_stats(isc_mem_t *ctx, FILE *out);
void *
static void
isc___mem_putanddetach(isc_mem_t **ctxp, void *ptr, size_t size FLARG);
static void *
isc___mem_allocate(isc_mem_t *ctx, size_t size FLARG);
void *
static void *
isc___mem_reallocate(isc_mem_t *ctx, void *ptr, size_t size FLARG);
void
isc___mem_free(isc_mem_t *ctx, void *ptr FLARG);
char *
static char *
isc___mem_strdup(isc_mem_t *mctx, const char *s FLARG);
void
isc__mem_setdestroycheck(isc_mem_t *ctx, bool flag);
void
isc__mem_setquota(isc_mem_t *ctx, size_t quota);
size_t
isc__mem_getquota(isc_mem_t *ctx);
size_t
isc__mem_inuse(isc_mem_t *ctx);
size_t
isc__mem_maxinuse(isc_mem_t *ctx);
size_t
isc__mem_total(isc_mem_t *ctx);
bool
isc__mem_isovermem(isc_mem_t *ctx);
void
isc__mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
size_t hiwater, size_t lowater);
void
isc__mem_waterack(isc_mem_t *ctx0, int flag);
void
isc__mem_setname(isc_mem_t *ctx, const char *name, void *tag);
const char *
isc__mem_getname(isc_mem_t *ctx);
void *
isc__mem_gettag(isc_mem_t *ctx);
isc_result_t
isc__mempool_create(isc_mem_t *mctx, size_t size, isc_mempool_t **mpctxp);
void
isc__mempool_setname(isc_mempool_t *mpctx, const char *name);
void
isc__mempool_destroy(isc_mempool_t **mpctxp);
void
isc__mempool_associatelock(isc_mempool_t *mpctx, isc_mutex_t *lock);
void *
isc___mempool_get(isc_mempool_t *mpctx FLARG);
void
isc___mempool_put(isc_mempool_t *mpctx, void *mem FLARG);
void
isc__mempool_setfreemax(isc_mempool_t *mpctx, unsigned int limit);
unsigned int
isc__mempool_getfreemax(isc_mempool_t *mpctx);
unsigned int
isc__mempool_getfreecount(isc_mempool_t *mpctx);
void
isc__mempool_setmaxalloc(isc_mempool_t *mpctx, unsigned int limit);
unsigned int
isc__mempool_getmaxalloc(isc_mempool_t *mpctx);
unsigned int
isc__mempool_getallocated(isc_mempool_t *mpctx);
void
isc__mempool_setfillcount(isc_mempool_t *mpctx, unsigned int limit);
unsigned int
isc__mempool_getfillcount(isc_mempool_t *mpctx);
void
isc__mem_printactive(isc_mem_t *ctx0, FILE *file);
unsigned int
isc__mem_references(isc_mem_t *ctx0);
static void
isc___mem_free(isc_mem_t *ctx, void *ptr FLARG);
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
static isc_memmethods_t memmethods = {
isc___mem_get,
isc___mem_put,
isc___mem_putanddetach,
isc___mem_allocate,
isc___mem_reallocate,
isc___mem_strdup,
isc___mem_free,
};
#if ISC_MEM_TRACKLINES
@ -853,7 +725,6 @@ default_memfree(void *arg, void *ptr) {
static void
initialize_action(void) {
RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
RUNTIME_CHECK(isc_mutex_init(&contextslock) == ISC_R_SUCCESS);
ISC_LIST_INIT(contexts);
totallost = 0;
@ -865,18 +736,8 @@ initialize_action(void) {
isc_result_t
isc_mem_createx(size_t init_max_size, size_t target_size,
isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
isc_mem_t **ctxp)
{
return (isc_mem_createx2(init_max_size, target_size, memalloc, memfree,
arg, ctxp, isc_mem_defaultflags));
}
isc_result_t
isc_mem_createx2(size_t init_max_size, size_t target_size,
isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
isc_mem_t **ctxp, unsigned int flags)
isc_memalloc_t memalloc, isc_memfree_t memfree, void *arg,
isc_mem_t **ctxp, unsigned int flags)
{
isc__mem_t *ctx;
isc_result_t result;
@ -890,8 +751,9 @@ isc_mem_createx2(size_t init_max_size, size_t target_size,
RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
ctx = (memalloc)(arg, sizeof(*ctx));
if (ctx == NULL)
if (ctx == NULL) {
return (ISC_R_NOMEMORY);
}
if ((flags & ISC_MEMFLAG_NOLOCK) == 0) {
result = isc_mutex_init(&ctx->lock);
@ -994,6 +856,7 @@ isc_mem_createx2(size_t init_max_size, size_t target_size,
UNLOCK(&contextslock);
*ctxp = (isc_mem_t *)ctx;
return (ISC_R_SUCCESS);
error:
@ -1092,7 +955,7 @@ destroy(isc__mem_t *ctx) {
}
void
isc__mem_attach(isc_mem_t *source0, isc_mem_t **targetp) {
isc_mem_attach(isc_mem_t *source0, isc_mem_t **targetp) {
isc__mem_t *source = (isc__mem_t *)source0;
REQUIRE(VALID_CONTEXT(source));
@ -1104,7 +967,7 @@ isc__mem_attach(isc_mem_t *source0, isc_mem_t **targetp) {
}
void
isc__mem_detach(isc_mem_t **ctxp) {
isc_mem_detach(isc_mem_t **ctxp) {
REQUIRE(ctxp != NULL && VALID_CONTEXT(*ctxp));
isc__mem_t *ctx = (isc__mem_t *)*ctxp;
*ctxp = NULL;
@ -1167,7 +1030,7 @@ destroy:
}
void
isc__mem_destroy(isc_mem_t **ctxp) {
isc_mem_destroy(isc_mem_t **ctxp) {
isc__mem_t *ctx;
/*
@ -1289,7 +1152,7 @@ isc___mem_put(isc_mem_t *ctx0, void *ptr, size_t size FLARG) {
}
void
isc__mem_waterack(isc_mem_t *ctx0, int flag) {
isc_mem_waterack(isc_mem_t *ctx0, int flag) {
isc__mem_t *ctx = (isc__mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
@ -1609,7 +1472,7 @@ isc___mem_strdup(isc_mem_t *mctx0, const char *s FLARG) {
}
void
isc__mem_setdestroycheck(isc_mem_t *ctx0, bool flag) {
isc_mem_setdestroycheck(isc_mem_t *ctx0, bool flag) {
isc__mem_t *ctx = (isc__mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
@ -1652,7 +1515,7 @@ isc_mem_getquota(isc_mem_t *ctx0) {
}
size_t
isc__mem_inuse(isc_mem_t *ctx0) {
isc_mem_inuse(isc_mem_t *ctx0) {
isc__mem_t *ctx = (isc__mem_t *)ctx0;
size_t inuse;
@ -1667,7 +1530,7 @@ isc__mem_inuse(isc_mem_t *ctx0) {
}
size_t
isc__mem_maxinuse(isc_mem_t *ctx0) {
isc_mem_maxinuse(isc_mem_t *ctx0) {
isc__mem_t *ctx = (isc__mem_t *)ctx0;
size_t maxinuse;
@ -1682,7 +1545,7 @@ isc__mem_maxinuse(isc_mem_t *ctx0) {
}
size_t
isc__mem_total(isc_mem_t *ctx0) {
isc_mem_total(isc_mem_t *ctx0) {
isc__mem_t *ctx = (isc__mem_t *)ctx0;
size_t total;
@ -1697,8 +1560,8 @@ isc__mem_total(isc_mem_t *ctx0) {
}
void
isc__mem_setwater(isc_mem_t *ctx0, isc_mem_water_t water, void *water_arg,
size_t hiwater, size_t lowater)
isc_mem_setwater(isc_mem_t *ctx0, isc_mem_water_t water, void *water_arg,
size_t hiwater, size_t lowater)
{
isc__mem_t *ctx = (isc__mem_t *)ctx0;
bool callwater = false;
@ -1734,7 +1597,7 @@ isc__mem_setwater(isc_mem_t *ctx0, isc_mem_water_t water, void *water_arg,
}
bool
isc__mem_isovermem(isc_mem_t *ctx0) {
isc_mem_isovermem(isc_mem_t *ctx0) {
isc__mem_t *ctx = (isc__mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
@ -1785,7 +1648,7 @@ isc_mem_gettag(isc_mem_t *ctx0) {
*/
isc_result_t
isc__mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) {
isc_mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) {
isc__mem_t *mctx = (isc__mem_t *)mctx0;
isc__mempool_t *mpctx;
@ -1801,7 +1664,6 @@ isc__mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) {
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;
@ -1835,7 +1697,7 @@ isc__mempool_create(isc_mem_t *mctx0, size_t size, isc_mempool_t **mpctxp) {
}
void
isc__mempool_setname(isc_mempool_t *mpctx0, const char *name) {
isc_mempool_setname(isc_mempool_t *mpctx0, const char *name) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
REQUIRE(name != NULL);
@ -1856,7 +1718,7 @@ isc__mempool_setname(isc_mempool_t *mpctx0, const char *name) {
}
void
isc__mempool_destroy(isc_mempool_t **mpctxp) {
isc_mempool_destroy(isc_mempool_t **mpctxp) {
isc__mempool_t *mpctx;
isc__mem_t *mctx;
isc_mutex_t *lock;
@ -1868,7 +1730,7 @@ isc__mempool_destroy(isc_mempool_t **mpctxp) {
#if ISC_MEMPOOL_NAMES
if (mpctx->allocated > 0)
UNEXPECTED_ERROR(__FILE__, __LINE__,
"isc__mempool_destroy(): mempool %s "
"isc_mempool_destroy(): mempool %s "
"leaked memory",
mpctx->name);
#endif
@ -1920,7 +1782,7 @@ isc__mempool_destroy(isc_mempool_t **mpctxp) {
}
void
isc__mempool_associatelock(isc_mempool_t *mpctx0, isc_mutex_t *lock) {
isc_mempool_associatelock(isc_mempool_t *mpctx0, isc_mutex_t *lock) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
REQUIRE(VALID_MEMPOOL(mpctx));
@ -1931,7 +1793,7 @@ isc__mempool_associatelock(isc_mempool_t *mpctx0, isc_mutex_t *lock) {
}
void *
isc___mempool_get(isc_mempool_t *mpctx0 FLARG) {
isc__mempool_get(isc_mempool_t *mpctx0 FLARG) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
element *item;
isc__mem_t *mctx;
@ -2007,7 +1869,7 @@ isc___mempool_get(isc_mempool_t *mpctx0 FLARG) {
/* coverity[+free : arg-1] */
void
isc___mempool_put(isc_mempool_t *mpctx0, void *mem FLARG) {
isc__mempool_put(isc_mempool_t *mpctx0, void *mem FLARG) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
isc__mem_t *mctx;
element *item;
@ -2065,7 +1927,7 @@ isc___mempool_put(isc_mempool_t *mpctx0, void *mem FLARG) {
*/
void
isc__mempool_setfreemax(isc_mempool_t *mpctx0, unsigned int limit) {
isc_mempool_setfreemax(isc_mempool_t *mpctx0, unsigned int limit) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
REQUIRE(VALID_MEMPOOL(mpctx));
@ -2116,7 +1978,7 @@ isc_mempool_getfreecount(isc_mempool_t *mpctx0) {
}
void
isc__mempool_setmaxalloc(isc_mempool_t *mpctx0, unsigned int limit) {
isc_mempool_setmaxalloc(isc_mempool_t *mpctx0, unsigned int limit) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
REQUIRE(limit > 0);
@ -2151,7 +2013,7 @@ isc_mempool_getmaxalloc(isc_mempool_t *mpctx0) {
}
unsigned int
isc__mempool_getallocated(isc_mempool_t *mpctx0) {
isc_mempool_getallocated(isc_mempool_t *mpctx0) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
unsigned int allocated;
@ -2169,7 +2031,7 @@ isc__mempool_getallocated(isc_mempool_t *mpctx0) {
}
void
isc__mempool_setfillcount(isc_mempool_t *mpctx0, unsigned int limit) {
isc_mempool_setfillcount(isc_mempool_t *mpctx0, unsigned int limit) {
isc__mempool_t *mpctx = (isc__mempool_t *)mpctx0;
REQUIRE(limit > 0);
@ -2203,27 +2065,6 @@ isc_mempool_getfillcount(isc_mempool_t *mpctx0) {
return (fillcount);
}
isc_result_t
isc__mem_register(void) {
return (isc_mem_register(isc_mem_create2));
}
void
isc__mem_printactive(isc_mem_t *ctx0, FILE *file) {
#if ISC_MEM_TRACKLINES
isc__mem_t *ctx = (isc__mem_t *)ctx0;
REQUIRE(VALID_CONTEXT(ctx));
REQUIRE(file != NULL);
print_active(ctx, file);
#else
UNUSED(ctx0);
UNUSED(file);
#endif
}
/*
* Requires contextslock to be held by caller.
*/
@ -2647,267 +2488,17 @@ isc_mem_renderjson(json_object *memobj) {
}
#endif /* HAVE_JSON */
static isc_memcreatefunc_t mem_createfunc = NULL;
isc_result_t
isc_mem_register(isc_memcreatefunc_t createfunc) {
isc_result_t result = ISC_R_SUCCESS;
RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
LOCK(&createlock);
if (mem_createfunc == NULL)
mem_createfunc = createfunc;
else
result = ISC_R_EXISTS;
UNLOCK(&createlock);
return (result);
}
isc_result_t
isc__mem_create2(size_t init_max_size, size_t target_size, isc_mem_t **mctxp,
unsigned int flags)
{
isc_result_t result;
LOCK(&createlock);
REQUIRE(mem_createfunc != NULL);
result = (*mem_createfunc)(init_max_size, target_size, mctxp, flags);
UNLOCK(&createlock);
return (result);
}
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);
}
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));
}
void
isc_mem_attach(isc_mem_t *source, isc_mem_t **targetp) {
REQUIRE(ISCAPI_MCTX_VALID(source));
REQUIRE(targetp != NULL && *targetp == NULL);
if (isc_bind9)
isc__mem_attach(source, targetp);
else
source->methods->attach(source, targetp);
ENSURE(*targetp == source);
}
void
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);
ENSURE(*mctxp == NULL);
}
void
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);
ENSURE(*mctxp == NULL);
}
void
isc_mem_setdestroycheck(isc_mem_t *mctx, bool flag) {
REQUIRE(ISCAPI_MCTX_VALID(mctx));
mctx->methods->setdestroycheck(mctx, flag);
}
void
isc_mem_setwater(isc_mem_t *ctx, isc_mem_water_t water, void *water_arg,
size_t hiwater, size_t lowater)
{
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);
}
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);
}
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));
}
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));
}
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));
}
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));
}
isc_result_t
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));
}
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);
ENSURE(*mpctxp == NULL);
}
unsigned int
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));
}
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);
}
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);
}
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);
}
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);
}
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);
return (isc_mem_createx(init_max_size, target_size,
default_memalloc, default_memfree,
NULL, mctxp, isc_mem_defaultflags));
}
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));
}
@ -2916,34 +2507,20 @@ void
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);
mctx->methods->memput(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);
/*
* XXX: We cannot always ensure *mctxp == NULL here
* (see lib/isc/mem.c).
*/
(*mctxp)->methods->memputanddetach(mctxp, ptr, size FLARG_PASS);
}
void *
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));
}
@ -2951,9 +2528,6 @@ 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));
}
@ -2961,9 +2535,6 @@ 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));
}
@ -2971,28 +2542,20 @@ 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);
}
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));
mctx->methods->memfree(mctx, ptr FLARG_PASS);
}
void
isc__mempool_put(isc_mempool_t *mpctx, void *mem FLARG) {
REQUIRE(ISCAPI_MPOOL_VALID(mpctx));
isc__mem_printactive(isc_mem_t *ctx0, FILE *file) {
#if ISC_MEM_TRACKLINES
isc__mem_t *ctx = (isc__mem_t *)ctx0;
if (isc_bind9)
isc___mempool_put(mpctx, mem FLARG_PASS);
else
mpctx->methods->put(mpctx, mem FLARG_PASS);
REQUIRE(VALID_CONTEXT(ctx));
REQUIRE(file != NULL);
print_active(ctx, file);
#else
UNUSED(ctx0);
UNUSED(file);
#endif
}

24
lib/isc/mem_p.h Normal file
View file

@ -0,0 +1,24 @@
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#ifndef ISC_MEM_P_H
#define ISC_MEM_P_H
/*! \file */
void
isc__mem_printactive(isc_mem_t *mctx, FILE *file);
/*%<
* For use by unit tests, prints active memory blocks for
* a single memory context.
*/
#endif /* ISC_MEM_P_H */

400
lib/isc/socket_api.c
View file

@ -1,400 +0,0 @@
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#include <config.h>
#include <inttypes.h>
#include <stdbool.h>
#include <isc/app.h>
#include <isc/magic.h>
#include <isc/mutex.h>
#include <isc/once.h>
#include <isc/socket.h>
#include <isc/util.h>
static isc_mutex_t createlock;
static isc_once_t once = ISC_ONCE_INIT;
static isc_socketmgrcreatefunc_t socketmgr_createfunc = NULL;
static void
initialize(void) {
RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
}
isc_result_t
isc_socket_register(isc_socketmgrcreatefunc_t createfunc) {
isc_result_t result = ISC_R_SUCCESS;
RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
LOCK(&createlock);
if (socketmgr_createfunc == NULL)
socketmgr_createfunc = createfunc;
else
result = ISC_R_EXISTS;
UNLOCK(&createlock);
return (result);
}
isc_result_t
isc_socketmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
isc_socketmgr_t **managerp)
{
isc_result_t result;
LOCK(&createlock);
REQUIRE(socketmgr_createfunc != NULL);
result = (*socketmgr_createfunc)(mctx, managerp);
UNLOCK(&createlock);
if (result == ISC_R_SUCCESS)
isc_appctx_setsocketmgr(actx, *managerp);
return (result);
}
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);
}
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);
ENSURE(*managerp == NULL);
}
isc_result_t
isc_socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp)
{
REQUIRE(ISCAPI_SOCKETMGR_VALID(manager));
if (isc_bind9)
return (isc__socket_create(manager, pf, type, socketp));
return (manager->methods->socketcreate(manager, pf, type, socketp));
}
void
isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
if (isc_bind9)
isc__socket_attach(sock, socketp);
else
sock->methods->attach(sock, socketp);
ENSURE(*socketp == sock);
}
void
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);
ENSURE(*socketp == NULL);
}
isc_result_t
isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options)
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
if (isc_bind9)
return (isc__socket_bind(sock, sockaddr, options));
return (sock->methods->bind(sock, sockaddr, options));
}
isc_result_t
isc_socket_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)
{
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));
}
isc_result_t
isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
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));
}
isc_result_t
isc_socket_recv(isc_socket_t *sock, isc_region_t *region, unsigned int minimum,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
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));
}
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_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));
}
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);
}
void
isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
sock->methods->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));
}
void
isc_socket_setname(isc_socket_t *sock, const char *name, void *tag) {
REQUIRE(ISCAPI_SOCKET_VALID(sock));
UNUSED(sock); /* in case REQUIRE() is empty */
UNUSED(name);
UNUSED(tag);
}
isc_result_t
isc_socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
isc_sockfdwatch_t callback, void *cbarg,
isc_task_t *task, isc_socket_t **socketp)
{
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));
}
isc_result_t
isc_socket_fdwatchpoke(isc_socket_t *sock, int flags)
{
REQUIRE(ISCAPI_SOCKET_VALID(sock));
if (isc_bind9)
return (isc__socket_fdwatchpoke(sock, flags));
return (sock->methods->fdwatchpoke(sock, flags));
}
isc_result_t
isc_socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
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));
}
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));
}
isc_result_t
isc_socket_open(isc_socket_t *sock) {
return (isc__socket_open(sock));
}
isc_result_t
isc_socket_close(isc_socket_t *sock) {
return (isc__socket_close(sock));
}
isc_result_t
isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
unsigned int maxsocks)
{
return (isc__socketmgr_create2(mctx, managerp, maxsocks));
}
isc_result_t
isc_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
return (isc__socket_recvv(sock, buflist, minimum, task, action, arg));
}
isc_result_t
isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_socketevent_t *event, unsigned int flags)
{
return (isc__socket_recv2(sock, region, minimum, task, event, flags));
}
isc_result_t
isc_socket_send(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
return (isc__socket_send(sock, region, task, action, arg));
}
isc_result_t
isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
return (isc__socket_sendv(sock, buflist, task, action, arg));
}
isc_result_t
isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
return (isc__socket_sendtov(sock, buflist, task, action, arg,
address, pktinfo));
}
isc_result_t
isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
{
return (isc__socket_sendtov2(sock, buflist, task, action, arg,
address, pktinfo, flags));
}
isc_result_t
isc_socket_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)
{
return (isc__socket_sendto2(sock, region, task, address, pktinfo,
event, flags));
}
void
isc_socket_cleanunix(const isc_sockaddr_t *sockaddr, bool active) {
isc__socket_cleanunix(sockaddr, active);
}
isc_result_t
isc_socket_permunix(const isc_sockaddr_t *sockaddr, uint32_t perm,
uint32_t owner, uint32_t group)
{
return (isc__socket_permunix(sockaddr, perm, owner, group));
}
isc_result_t
isc_socket_filter(isc_socket_t *sock, const char *filter) {
return (isc__socket_filter(sock, filter));
}
isc_result_t
isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
return (isc__socket_listen(sock, backlog));
}
isc_result_t
isc_socket_accept(isc_socket_t *sock, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
return (isc__socket_accept(sock, task, action, arg));
}
isc_result_t
isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
return (isc__socket_getpeername(sock, addressp));
}

468
lib/isc/task.c
View file

@ -152,6 +152,12 @@ struct isc__taskmgr {
isc__task_t *excl;
};
void
isc__taskmgr_pause(isc_taskmgr_t *manager0);
void
isc__taskmgr_resume(isc_taskmgr_t *manager0);
#define DEFAULT_TASKMGR_QUANTUM 10
#define DEFAULT_DEFAULT_QUANTUM 5
#define FINISHED(m) ((m)->exiting && EMPTY((m)->tasks))
@ -162,71 +168,12 @@ struct isc__taskmgr {
* unit tests etc.
*/
isc_result_t
isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp);
void
isc__task_attach(isc_task_t *source0, isc_task_t **targetp);
void
isc__task_detach(isc_task_t **taskp);
void
isc__task_send(isc_task_t *task0, isc_event_t **eventp);
void
isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp);
unsigned int
isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag);
unsigned int
isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag);
bool
isc_task_purgeevent(isc_task_t *task0, isc_event_t *event);
unsigned int
isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag,
isc_eventlist_t *events);
unsigned int
isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag, isc_eventlist_t *events);
isc_result_t
isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
void *arg);
void
isc__task_shutdown(isc_task_t *task0);
void
isc__task_destroy(isc_task_t **taskp);
void
isc__task_setname(isc_task_t *task0, const char *name, void *tag);
const char *
isc__task_getname(isc_task_t *task0);
void *
isc__task_gettag(isc_task_t *task0);
void
isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t);
void
isc__task_getcurrenttimex(isc_task_t *task0, isc_time_t *t);
isc_result_t
isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_taskmgr_t **managerp);
void
isc__taskmgr_destroy(isc_taskmgr_t **managerp);
void
isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0);
isc_result_t
isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp);
isc_result_t
isc__task_beginexclusive(isc_task_t *task);
void
isc__task_endexclusive(isc_task_t *task0);
void
isc__task_setprivilege(isc_task_t *task0, bool priv);
bool
isc__task_privilege(isc_task_t *task0);
void
isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode);
isc_taskmgrmode_t
isc__taskmgr_mode(isc_taskmgr_t *manager0);
static inline bool
empty_readyq(isc__taskmgr_t *manager);
@ -236,49 +183,6 @@ pop_readyq(isc__taskmgr_t *manager);
static inline void
push_readyq(isc__taskmgr_t *manager, isc__task_t *task);
static struct isc__taskmethods {
isc_taskmethods_t methods;
/*%
* The following are defined just for avoiding unused static functions.
*/
void *purgeevent, *unsendrange, *getname, *gettag,
*getcurrenttime, *getcurrenttimex;
} taskmethods = {
{
isc__task_attach,
isc__task_detach,
isc__task_destroy,
isc__task_send,
isc__task_sendanddetach,
isc__task_unsend,
isc__task_onshutdown,
isc__task_shutdown,
isc__task_setname,
isc__task_purge,
isc__task_purgerange,
isc__task_beginexclusive,
isc__task_endexclusive,
isc__task_setprivilege,
isc__task_privilege
},
(void *)isc_task_purgeevent,
(void *)isc__task_unsendrange,
(void *)isc__task_getname,
(void *)isc__task_gettag,
(void *)isc__task_getcurrenttime,
(void *)isc__task_getcurrenttimex
};
static isc_taskmgrmethods_t taskmgrmethods = {
isc__taskmgr_destroy,
isc__taskmgr_setmode,
isc__taskmgr_mode,
isc__task_create,
isc_taskmgr_setexcltask,
isc_taskmgr_excltask
};
/***
*** Tasks.
***/
@ -315,7 +219,7 @@ task_finished(isc__task_t *task) {
}
isc_result_t
isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_create(isc_taskmgr_t *manager0, unsigned int quantum,
isc_task_t **taskp)
{
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
@ -367,7 +271,6 @@ isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
return (ISC_R_SHUTTINGDOWN);
}
task->common.methods = (isc_taskmethods_t *)&taskmethods;
task->common.magic = ISCAPI_TASK_MAGIC;
task->common.impmagic = TASK_MAGIC;
*taskp = (isc_task_t *)task;
@ -376,7 +279,7 @@ isc__task_create(isc_taskmgr_t *manager0, unsigned int quantum,
}
void
isc__task_attach(isc_task_t *source0, isc_task_t **targetp) {
isc_task_attach(isc_task_t *source0, isc_task_t **targetp) {
isc__task_t *source = (isc__task_t *)source0;
/*
@ -442,7 +345,7 @@ task_shutdown(isc__task_t *task) {
static inline void
task_ready(isc__task_t *task) {
isc__taskmgr_t *manager = task->manager;
bool has_privilege = isc__task_privilege((isc_task_t *) task);
bool has_privilege = isc_task_privilege((isc_task_t *) task);
REQUIRE(VALID_MANAGER(manager));
REQUIRE(task->state == task_state_ready);
@ -486,7 +389,7 @@ task_detach(isc__task_t *task) {
}
void
isc__task_detach(isc_task_t **taskp) {
isc_task_detach(isc_task_t **taskp) {
isc__task_t *task;
bool was_idle;
@ -543,7 +446,7 @@ task_send(isc__task_t *task, isc_event_t **eventp) {
}
void
isc__task_send(isc_task_t *task0, isc_event_t **eventp) {
isc_task_send(isc_task_t *task0, isc_event_t **eventp) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle;
@ -585,7 +488,7 @@ isc__task_send(isc_task_t *task0, isc_event_t **eventp) {
}
void
isc__task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
bool idle1, idle2;
isc__task_t *task;
@ -662,13 +565,14 @@ dequeue_events(isc__task_t *task, void *sender, isc_eventtype_t first,
}
unsigned int
isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
isc_task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag)
{
isc__task_t *task = (isc__task_t *)task0;
unsigned int count;
isc_eventlist_t events;
isc_event_t *event, *next_event;
REQUIRE(VALID_TASK(task));
/*
* Purge events from a task's event queue.
@ -695,16 +599,17 @@ isc__task_purgerange(isc_task_t *task0, void *sender, isc_eventtype_t first,
}
unsigned int
isc__task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag)
{
/*
* Purge events from a task's event queue.
*/
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_purge");
return (isc__task_purgerange(task, sender, type, type, tag));
return (isc_task_purgerange(task, sender, type, type, tag));
}
bool
@ -752,13 +657,14 @@ isc_task_purgeevent(isc_task_t *task0, isc_event_t *event) {
}
unsigned int
isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag,
isc_eventlist_t *events)
{
/*
* Remove events from a task's event queue.
*/
REQUIRE(VALID_TASK(task));
XTRACE("isc_task_unsendrange");
@ -767,7 +673,7 @@ isc__task_unsendrange(isc_task_t *task, void *sender, isc_eventtype_t first,
}
unsigned int
isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag, isc_eventlist_t *events)
{
/*
@ -781,7 +687,7 @@ isc__task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
}
isc_result_t
isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
isc_task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
void *arg)
{
isc__task_t *task = (isc__task_t *)task0;
@ -821,7 +727,7 @@ isc__task_onshutdown(isc_task_t *task0, isc_taskaction_t action,
}
void
isc__task_shutdown(isc_task_t *task0) {
isc_task_shutdown(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
bool was_idle;
@ -840,7 +746,7 @@ isc__task_shutdown(isc_task_t *task0) {
}
void
isc__task_destroy(isc_task_t **taskp) {
isc_task_destroy(isc_task_t **taskp) {
/*
* Destroy '*taskp'.
@ -853,7 +759,7 @@ isc__task_destroy(isc_task_t **taskp) {
}
void
isc__task_setname(isc_task_t *task0, const char *name, void *tag) {
isc_task_setname(isc_task_t *task0, const char *name, void *tag) {
isc__task_t *task = (isc__task_t *)task0;
/*
@ -868,8 +774,9 @@ isc__task_setname(isc_task_t *task0, const char *name, void *tag) {
UNLOCK(&task->lock);
}
const char *
isc__task_getname(isc_task_t *task0) {
isc_task_getname(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
@ -878,7 +785,7 @@ isc__task_getname(isc_task_t *task0) {
}
void *
isc__task_gettag(isc_task_t *task0) {
isc_task_gettag(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
@ -887,7 +794,7 @@ isc__task_gettag(isc_task_t *task0) {
}
void
isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
isc_task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
@ -899,7 +806,7 @@ isc__task_getcurrenttime(isc_task_t *task0, isc_stdtime_t *t) {
}
void
isc__task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
isc_task_getcurrenttimex(isc_task_t *task0, isc_time_t *t) {
isc__task_t *task = (isc__task_t *)task0;
REQUIRE(VALID_TASK(task));
@ -1276,7 +1183,7 @@ manager_free(isc__taskmgr_t *manager) {
}
isc_result_t
isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
isc_taskmgr_create(isc_mem_t *mctx, unsigned int workers,
unsigned int default_quantum, isc_taskmgr_t **managerp)
{
isc_result_t result;
@ -1293,7 +1200,6 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
manager = isc_mem_get(mctx, sizeof(*manager));
if (manager == NULL)
return (ISC_R_NOMEMORY);
manager->common.methods = &taskmgrmethods;
manager->common.impmagic = TASK_MANAGER_MAGIC;
manager->common.magic = ISCAPI_TASKMGR_MAGIC;
manager->mode = isc_taskmgrmode_normal;
@ -1395,7 +1301,7 @@ isc__taskmgr_create(isc_mem_t *mctx, unsigned int workers,
}
void
isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
isc_taskmgr_destroy(isc_taskmgr_t **managerp) {
isc__taskmgr_t *manager;
isc__task_t *task;
unsigned int i;
@ -1422,7 +1328,7 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
*/
LOCK(&manager->excl_lock);
if (manager->excl != NULL)
isc__task_detach((isc_task_t **) &manager->excl);
isc_task_detach((isc_task_t **) &manager->excl);
UNLOCK(&manager->excl_lock);
/*
@ -1479,7 +1385,7 @@ isc__taskmgr_destroy(isc_taskmgr_t **managerp) {
}
void
isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
isc_taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
LOCK(&manager->lock);
@ -1488,7 +1394,7 @@ isc__taskmgr_setmode(isc_taskmgr_t *manager0, isc_taskmgrmode_t mode) {
}
isc_taskmgrmode_t
isc__taskmgr_mode(isc_taskmgr_t *manager0) {
isc_taskmgr_mode(isc_taskmgr_t *manager0) {
isc__taskmgr_t *manager = (isc__taskmgr_t *)manager0;
isc_taskmgrmode_t mode;
LOCK(&manager->lock);
@ -1529,8 +1435,8 @@ isc_taskmgr_setexcltask(isc_taskmgr_t *mgr0, isc_task_t *task0) {
REQUIRE(VALID_TASK(task));
LOCK(&mgr->excl_lock);
if (mgr->excl != NULL)
isc__task_detach((isc_task_t **) &mgr->excl);
isc__task_attach(task0, (isc_task_t **) &mgr->excl);
isc_task_detach((isc_task_t **) &mgr->excl);
isc_task_attach(task0, (isc_task_t **) &mgr->excl);
UNLOCK(&mgr->excl_lock);
}
@ -1544,7 +1450,7 @@ isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
LOCK(&mgr->excl_lock);
if (mgr->excl != NULL)
isc__task_attach((isc_task_t *) mgr->excl, taskp);
isc_task_attach((isc_task_t *) mgr->excl, taskp);
else
result = ISC_R_NOTFOUND;
UNLOCK(&mgr->excl_lock);
@ -1553,9 +1459,10 @@ isc_taskmgr_excltask(isc_taskmgr_t *mgr0, isc_task_t **taskp) {
}
isc_result_t
isc__task_beginexclusive(isc_task_t *task0) {
isc_task_beginexclusive(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
REQUIRE(VALID_TASK(task));
REQUIRE(task->state == task_state_running);
/*
@ -1577,10 +1484,11 @@ isc__task_beginexclusive(isc_task_t *task0) {
}
void
isc__task_endexclusive(isc_task_t *task0) {
isc_task_endexclusive(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
REQUIRE(VALID_TASK(task));
REQUIRE(task->state == task_state_running);
LOCK(&manager->lock);
REQUIRE(manager->exclusive_requested);
@ -1590,7 +1498,8 @@ isc__task_endexclusive(isc_task_t *task0) {
}
void
isc__task_setprivilege(isc_task_t *task0, bool priv) {
isc_task_setprivilege(isc_task_t *task0, bool priv) {
REQUIRE(ISCAPI_TASK_VALID(task0));
isc__task_t *task = (isc__task_t *)task0;
isc__taskmgr_t *manager = task->manager;
bool oldpriv;
@ -1617,9 +1526,10 @@ isc__task_setprivilege(isc_task_t *task0, bool priv) {
}
bool
isc__task_privilege(isc_task_t *task0) {
isc_task_privilege(isc_task_t *task0) {
isc__task_t *task = (isc__task_t *)task0;
bool priv;
REQUIRE(VALID_TASK(task));
LOCK(&task->lock);
priv = (task->flags & TASK_F_PRIVILEGED);
@ -1627,11 +1537,6 @@ isc__task_privilege(isc_task_t *task0) {
return (priv);
}
isc_result_t
isc__task_register(void) {
return (isc_task_register(isc__taskmgr_create));
}
bool
isc_task_exiting(isc_task_t *t) {
isc__task_t *task = (isc__task_t *)t;
@ -1837,31 +1742,6 @@ isc_taskmgr_renderjson(isc_taskmgr_t *mgr0, json_object *tasks) {
#endif
static isc_mutex_t createlock;
static isc_once_t once = ISC_ONCE_INIT;
static isc_taskmgrcreatefunc_t taskmgr_createfunc = NULL;
static void
initialize(void) {
RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
}
isc_result_t
isc_task_register(isc_taskmgrcreatefunc_t createfunc) {
isc_result_t result = ISC_R_SUCCESS;
RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
LOCK(&createlock);
if (taskmgr_createfunc == NULL)
taskmgr_createfunc = createfunc;
else
result = ISC_R_EXISTS;
UNLOCK(&createlock);
return (result);
}
isc_result_t
isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
unsigned int workers, unsigned int default_quantum,
@ -1869,268 +1749,12 @@ isc_taskmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
{
isc_result_t result;
LOCK(&createlock);
REQUIRE(taskmgr_createfunc != NULL);
result = (*taskmgr_createfunc)(mctx, workers, default_quantum,
result = isc_taskmgr_create(mctx, workers, default_quantum,
managerp);
UNLOCK(&createlock);
if (result == ISC_R_SUCCESS)
isc_appctx_settaskmgr(actx, *managerp);
return (result);
}
isc_result_t
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);
}
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);
ENSURE(*managerp == NULL);
}
void
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_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));
}
isc_result_t
isc_task_create(isc_taskmgr_t *manager, unsigned int quantum,
isc_task_t **taskp)
{
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));
}
void
isc_task_attach(isc_task_t *source, isc_task_t **targetp) {
REQUIRE(ISCAPI_TASK_VALID(source));
REQUIRE(targetp != NULL && *targetp == NULL);
if (isc_bind9)
isc__task_attach(source, targetp);
else
source->methods->attach(source, targetp);
ENSURE(*targetp == source);
}
void
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);
ENSURE(*taskp == NULL);
}
void
isc_task_send(isc_task_t *task, isc_event_t **eventp) {
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);
}
}
void
isc_task_sendanddetach(isc_task_t **taskp, isc_event_t **eventp) {
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);
}
ENSURE(*taskp == NULL);
}
unsigned int
isc_task_unsend(isc_task_t *task, void *sender, isc_eventtype_t type,
void *tag, isc_eventlist_t *events)
{
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));
}
isc_result_t
isc_task_onshutdown(isc_task_t *task, isc_taskaction_t action, void *arg)
{
REQUIRE(ISCAPI_TASK_VALID(task));
if (isc_bind9)
return (isc__task_onshutdown(task, action, arg));
return (task->methods->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);
}
void
isc_task_destroy(isc_task_t **taskp) {
if (!isc_bind9)
return;
isc__task_destroy(taskp);
}
void
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);
}
unsigned int
isc_task_purge(isc_task_t *task, void *sender, isc_eventtype_t type, void *tag)
{
REQUIRE(ISCAPI_TASK_VALID(task));
if (isc_bind9)
return (isc__task_purge(task, sender, type, tag));
return (task->methods->purgeevents(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));
}
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);
}
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);
}
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));
}
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);
}
/*%
* This is necessary for libisc's internal timer implementation. Other
* implementation might skip implementing this.
*/
unsigned int
isc_task_purgerange(isc_task_t *task, void *sender, isc_eventtype_t first,
isc_eventtype_t last, void *tag)
{
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));
}

27
lib/isc/task_p.h Normal file
View file

@ -0,0 +1,27 @@
/*
* Copyright (C) Internet Systems Consortium, Inc. ("ISC")
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
#ifndef ISC_TASK_P_H
#define ISC_TASK_P_H
/*! \file */
/*%
* These functions allow unit tests to manipulate the processing
* of the task queue. They are not intended as part of the public API.
*/
void
isc__taskmgr_pause(isc_taskmgr_t *taskmgr);
void
isc__taskmgr_resume(isc_taskmgr_t *taskmgr);
#endif /* ISC_TASK_P_H */

8
lib/isc/tests/ht_test.c
View file

@ -47,8 +47,8 @@ static void test_ht_full(int bits, uintptr_t count) {
isc_mem_t *mctx = NULL;
uintptr_t i;
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_ht_init(&ht, mctx, bits);
@ -200,8 +200,8 @@ static void test_ht_iterator() {
unsigned char *tkey;
size_t tksize;
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_ht_init(&ht, mctx, 16);

32
lib/isc/tests/mem_test.c
View file

@ -16,14 +16,16 @@
#include <atf-c.h>
#include "isctest.h"
#include <isc/file.h>
#include <isc/mem.h>
#include <isc/print.h>
#include <isc/result.h>
#include <isc/stdio.h>
#include "../mem_p.h"
#include "isctest.h"
static void *
default_memalloc(void *arg, size_t size) {
UNUSED(arg);
@ -137,9 +139,9 @@ ATF_TC_BODY(isc_mem, tc) {
isc_mem_destroy(&localmctx);
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &localmctx,
ISC_MEMFLAG_FILL | ISC_MEMFLAG_INTERNAL);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &localmctx,
ISC_MEMFLAG_FILL | ISC_MEMFLAG_INTERNAL);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_mempool_create(localmctx, 2, &mp1);
@ -172,8 +174,8 @@ ATF_TC_BODY(isc_mem_total, tc) {
/* Local alloc, free */
mctx2 = NULL;
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
if (result != ISC_R_SUCCESS)
goto out;
@ -238,8 +240,8 @@ ATF_TC_BODY(isc_mem_inuse, tc) {
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
mctx2 = NULL;
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
if (result != ISC_R_SUCCESS)
goto out;
@ -282,8 +284,8 @@ ATF_TC_BODY(isc_mem_noflags, tc) {
result = isc_test_begin(NULL, true, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
isc_mem_debugging = 0;
ptr = isc_mem_get(mctx2, 2048);
@ -334,8 +336,8 @@ ATF_TC_BODY(isc_mem_recordflag, tc) {
result = isc_test_begin(NULL, false, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
ptr = isc_mem_get(mctx2, 2048);
ATF_CHECK(ptr != NULL);
@ -384,8 +386,8 @@ ATF_TC_BODY(isc_mem_traceflag, tc) {
result = isc_test_begin(NULL, true, 0);
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
result = isc_mem_createx2(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
result = isc_mem_createx(0, 0, default_memalloc, default_memfree,
NULL, &mctx2, 0);
isc_mem_debugging = ISC_MEM_DEBUGTRACE;
ATF_REQUIRE_EQ(result, ISC_R_SUCCESS);
ptr = isc_mem_get(mctx2, 2048);

2
lib/isc/tests/task_test.c
View file

@ -31,6 +31,8 @@
#include "isctest.h"
#include "../task_p.h"
/*
* Helper functions
*/

209
lib/isc/timer.c
View file

@ -97,63 +97,8 @@ struct isc__timermgr {
isc_heap_t * heap;
};
/*%
* The following are intended for internal use (indicated by "isc__"
* prefix) but are not declared as static, allowing direct access from
* unit tests etc.
*/
isc_result_t
isc__timer_create(isc_timermgr_t *manager, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_timer_t **timerp);
isc_result_t
isc__timer_reset(isc_timer_t *timer, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
bool purge);
isc_timertype_t
isc_timer_gettype(isc_timer_t *timer);
isc_result_t
isc__timer_touch(isc_timer_t *timer);
void
isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp);
void
isc__timer_detach(isc_timer_t **timerp);
isc_result_t
isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp);
void
isc_timermgr_poke(isc_timermgr_t *manager0);
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) {
@ -296,10 +241,10 @@ destroy(isc__timer_t *timer) {
}
isc_result_t
isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_timer_t **timerp)
isc_timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_timer_t **timerp)
{
isc__timermgr_t *manager = (isc__timermgr_t *)manager0;
isc__timer_t *timer;
@ -385,7 +330,6 @@ isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
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);
@ -418,7 +362,7 @@ isc__timer_create(isc_timermgr_t *manager0, isc_timertype_t type,
}
isc_result_t
isc__timer_reset(isc_timer_t *timer0, isc_timertype_t type,
isc_timer_reset(isc_timer_t *timer0, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
bool purge)
{
@ -508,7 +452,7 @@ isc_timer_gettype(isc_timer_t *timer0) {
}
isc_result_t
isc__timer_touch(isc_timer_t *timer0) {
isc_timer_touch(isc_timer_t *timer0) {
isc__timer_t *timer = (isc__timer_t *)timer0;
isc_result_t result;
isc_time_t now;
@ -539,7 +483,7 @@ isc__timer_touch(isc_timer_t *timer0) {
}
void
isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
isc_timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
isc__timer_t *timer = (isc__timer_t *)timer0;
/*
@ -557,7 +501,7 @@ isc__timer_attach(isc_timer_t *timer0, isc_timer_t **timerp) {
}
void
isc__timer_detach(isc_timer_t **timerp) {
isc_timer_detach(isc_timer_t **timerp) {
isc__timer_t *timer;
bool free_timer = false;
@ -771,7 +715,7 @@ set_index(void *what, unsigned int index) {
}
isc_result_t
isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
isc_timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
isc__timermgr_t *manager;
isc_result_t result;
@ -787,7 +731,6 @@ isc__timermgr_create(isc_mem_t *mctx, isc_timermgr_t **managerp) {
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);
@ -848,7 +791,7 @@ isc_timermgr_poke(isc_timermgr_t *manager0) {
}
void
isc__timermgr_destroy(isc_timermgr_t **managerp) {
isc_timermgr_destroy(isc_timermgr_t **managerp) {
isc__timermgr_t *manager;
isc_mem_t *mctx;
@ -896,146 +839,16 @@ isc__timermgr_destroy(isc_timermgr_t **managerp) {
}
isc_result_t
isc__timer_register(void) {
return (isc_timer_register(isc__timermgr_create));
}
static isc_mutex_t createlock;
static isc_once_t once = ISC_ONCE_INIT;
static isc_timermgrcreatefunc_t timermgr_createfunc = NULL;
static void
initialize(void) {
RUNTIME_CHECK(isc_mutex_init(&createlock) == ISC_R_SUCCESS);
}
isc_result_t
isc_timer_register(isc_timermgrcreatefunc_t createfunc) {
isc_result_t result = ISC_R_SUCCESS;
RUNTIME_CHECK(isc_once_do(&once, initialize) == ISC_R_SUCCESS);
LOCK(&createlock);
if (timermgr_createfunc == NULL)
timermgr_createfunc = createfunc;
else
result = ISC_R_EXISTS;
UNLOCK(&createlock);
return (result);
}
isc_result_t
isc_timermgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
isc_timermgr_t **managerp)
{
isc_result_t result;
LOCK(&createlock);
REQUIRE(timermgr_createfunc != NULL);
result = (*timermgr_createfunc)(mctx, managerp);
UNLOCK(&createlock);
result = isc_timermgr_create(mctx, managerp);
if (result == ISC_R_SUCCESS)
isc_appctx_settimermgr(actx, *managerp);
return (result);
}
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);
}
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);
ENSURE(*managerp == NULL);
}
isc_result_t
isc_timer_create(isc_timermgr_t *manager, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_timer_t **timerp)
{
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));
}
void
isc_timer_attach(isc_timer_t *timer, isc_timer_t **timerp) {
REQUIRE(ISCAPI_TIMER_VALID(timer));
REQUIRE(timerp != NULL && *timerp == NULL);
if (isc_bind9)
isc__timer_attach(timer, timerp);
else
timer->methods->attach(timer, timerp);
ENSURE(*timerp == timer);
}
void
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);
ENSURE(*timerp == NULL);
}
isc_result_t
isc_timer_reset(isc_timer_t *timer, isc_timertype_t type,
const isc_time_t *expires, const isc_interval_t *interval,
bool purge)
{
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));
}
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));
}

126
lib/isc/unix/app.c
View file

@ -51,34 +51,7 @@
* as an event loop dispatching various events.
*/
static pthread_t blockedthread;
/*%
* The following are intended for internal use (indicated by "isc__"
* prefix) but are not declared as static, allowing direct access from
* unit tests etc.
*/
isc_result_t isc__app_start(void);
isc_result_t isc__app_ctxstart(isc_appctx_t *ctx);
isc_result_t isc__app_onrun(isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg);
isc_result_t isc__app_ctxrun(isc_appctx_t *ctx);
isc_result_t isc__app_run(void);
isc_result_t isc__app_ctxshutdown(isc_appctx_t *ctx);
isc_result_t isc__app_shutdown(void);
isc_result_t isc__app_reload(void);
isc_result_t isc__app_ctxsuspend(isc_appctx_t *ctx);
void isc__app_ctxfinish(isc_appctx_t *ctx);
void isc__app_finish(void);
void isc__app_block(void);
void isc__app_unblock(void);
isc_result_t isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp);
void isc__appctx_destroy(isc_appctx_t **ctxp);
void isc__appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr);
void isc__appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr);
void isc__appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr);
isc_result_t isc__app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx,
isc_task_t *task, isc_taskaction_t action,
void *arg);
static bool is_running;
/*
* The application context of this module. This implementation actually
@ -115,35 +88,6 @@ typedef struct isc__appctx {
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
};
#ifndef HAVE_SIGWAIT
static void
exit_action(int arg) {
@ -181,7 +125,7 @@ handle_signal(int sig, void (*handler)(int)) {
}
isc_result_t
isc__app_ctxstart(isc_appctx_t *ctx0) {
isc_app_ctxstart(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_result_t result;
int presult;
@ -299,26 +243,25 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_start(void) {
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() */
return (isc__app_ctxstart((isc_appctx_t *)&isc_g_appctx));
return (isc_app_ctxstart((isc_appctx_t *)&isc_g_appctx));
}
isc_result_t
isc__app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
void *arg)
{
return (isc__app_ctxonrun((isc_appctx_t *)&isc_g_appctx, mctx,
return (isc_app_ctxonrun((isc_appctx_t *)&isc_g_appctx, mctx,
task, action, arg));
}
isc_result_t
isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
isc_app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
@ -357,7 +300,7 @@ isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
}
isc_result_t
isc__app_ctxrun(isc_appctx_t *ctx0) {
isc_app_ctxrun(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
int result;
isc_event_t *event, *next_event;
@ -504,12 +447,21 @@ isc__app_ctxrun(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_run(void) {
return (isc__app_ctxrun((isc_appctx_t *)&isc_g_appctx));
isc_app_run(void) {
isc_result_t result;
is_running = true;
result = isc_app_ctxrun((isc_appctx_t *)&isc_g_appctx);
is_running = false;
return result;
}
bool
isc_app_isrunning() {
return (is_running);
}
isc_result_t
isc__app_ctxshutdown(isc_appctx_t *ctx0) {
isc_app_ctxshutdown(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
char strbuf[ISC_STRERRORSIZE];
@ -557,12 +509,12 @@ isc__app_ctxshutdown(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_shutdown(void) {
return (isc__app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
isc_app_shutdown(void) {
return (isc_app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
}
isc_result_t
isc__app_ctxsuspend(isc_appctx_t *ctx0) {
isc_app_ctxsuspend(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
char strbuf[ISC_STRERRORSIZE];
@ -612,12 +564,12 @@ isc__app_ctxsuspend(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_reload(void) {
return (isc__app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
isc_app_reload(void) {
return (isc_app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
}
void
isc__app_ctxfinish(isc_appctx_t *ctx0) {
isc_app_ctxfinish(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -626,12 +578,12 @@ isc__app_ctxfinish(isc_appctx_t *ctx0) {
}
void
isc__app_finish(void) {
isc__app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
isc_app_finish(void) {
isc_app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
}
void
isc__app_block(void) {
isc_app_block(void) {
sigset_t sset;
REQUIRE(isc_g_appctx.running);
REQUIRE(!isc_g_appctx.blocked);
@ -645,7 +597,7 @@ isc__app_block(void) {
}
void
isc__app_unblock(void) {
isc_app_unblock(void) {
sigset_t sset;
REQUIRE(isc_g_appctx.running);
@ -662,7 +614,7 @@ isc__app_unblock(void) {
}
isc_result_t
isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(mctx != NULL);
@ -674,7 +626,6 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
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);
@ -689,7 +640,7 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
}
void
isc__appctx_destroy(isc_appctx_t **ctxp) {
isc_appctx_destroy(isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(ctxp != NULL);
@ -702,7 +653,7 @@ isc__appctx_destroy(isc_appctx_t **ctxp) {
}
void
isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
isc_appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -711,7 +662,7 @@ isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
}
void
isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
isc_appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -720,17 +671,10 @@ isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
}
void
isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
isc_appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
ctx->timermgr = timermgr;
}
isc_result_t
isc__app_register(void) {
return (isc_app_register(isc__appctx_create));
}
#include "../app_api.c"

295
lib/isc/unix/socket.c
View file

@ -37,6 +37,7 @@
#include <stdlib.h>
#include <unistd.h>
#include <isc/app.h>
#include <isc/buffer.h>
#include <isc/bufferlist.h>
#include <isc/condition.h>
@ -477,176 +478,6 @@ static void build_msghdr_recv(isc__socket_t *, char *, isc_socketevent_t *,
static bool process_ctlfd(isc__socketmgr_t *manager);
static void setdscp(isc__socket_t *sock, isc_dscp_t dscp);
/*%
* The following are intended for internal use (indicated by "isc__"
* prefix) but are not declared as static, allowing direct access from
* unit tests etc.
*/
isc_result_t
isc__socket_open(isc_socket_t *sock0);
isc_result_t
isc__socket_close(isc_socket_t *sock0);
isc_result_t
isc__socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp);
void
isc__socket_attach(isc_socket_t *sock, isc_socket_t **socketp);
void
isc__socket_detach(isc_socket_t **socketp);
isc_result_t
isc__socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg);
isc_result_t
isc__socket_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
isc__socket_recv2(isc_socket_t *sock, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_socketevent_t *event, unsigned int flags);
isc_result_t
isc__socket_send(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg);
isc_result_t
isc__socket_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
isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg);
isc_result_t
isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo);
isc_result_t
isc__socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags);
isc_result_t
isc__socket_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_socketevent_t *
isc_socket_socketevent(isc_mem_t *mctx, void *sender,
isc_eventtype_t eventtype, isc_taskaction_t action,
void *arg);
void
isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, bool active);
isc_result_t
isc__socket_permunix(const isc_sockaddr_t *sockaddr, uint32_t perm,
uint32_t owner, uint32_t group);
isc_result_t
isc__socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options);
isc_result_t
isc__socket_filter(isc_socket_t *sock, const char *filter);
isc_result_t
isc__socket_listen(isc_socket_t *sock, unsigned int backlog);
isc_result_t
isc__socket_accept(isc_socket_t *sock,
isc_task_t *task, isc_taskaction_t action, void *arg);
isc_result_t
isc__socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action,
void *arg);
isc_result_t
isc__socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp);
isc_result_t
isc__socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp);
void
isc__socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how);
isc_sockettype_t
isc__socket_gettype(isc_socket_t *sock);
bool
isc__socket_isbound(isc_socket_t *sock);
void
isc__socket_ipv6only(isc_socket_t *sock, bool yes);
void
isc__socket_dscp(isc_socket_t *sock, isc_dscp_t dscp);
isc_result_t
isc__socket_fdwatchcreate(isc_socketmgr_t *manager, int fd, int flags,
isc_sockfdwatch_t callback, void *cbarg,
isc_task_t *task, isc_socket_t **socketp);
isc_result_t
isc__socket_fdwatchpoke(isc_socket_t *sock, int flags);
isc_result_t
isc__socket_dup(isc_socket_t *sock, isc_socket_t **socketp);
int
isc__socket_getfd(isc_socket_t *sock);
isc_result_t
isc__socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp);
isc_result_t
isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
unsigned int maxsocks);
isc_result_t
isc_socketmgr_getmaxsockets(isc_socketmgr_t *manager0, unsigned int *nsockp);
void
isc_socketmgr_setstats(isc_socketmgr_t *manager0, isc_stats_t *stats);
void
isc__socketmgr_destroy(isc_socketmgr_t **managerp);
void
isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag);
const char *
isc__socket_getname(isc_socket_t *socket0);
void *
isc__socket_gettag(isc_socket_t *socket0);
#ifdef HAVE_LIBXML2
void
isc__socketmgr_renderxml(isc_socketmgr_t *mgr0, xmlTextWriterPtr writer);
#endif
#ifdef HAVE_JSON
isc_result_t
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)
@ -2892,7 +2723,6 @@ socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
return (result);
}
sock->common.methods = (isc_socketmethods_t *)&socketmethods;
sock->references = 1;
*socketp = (isc_socket_t *)sock;
@ -2935,7 +2765,7 @@ socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
* in 'socketp'.
*/
isc_result_t
isc__socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
isc_socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
isc_socket_t **socketp)
{
return (socket_create(manager0, pf, type, socketp, NULL));
@ -2946,7 +2776,7 @@ isc__socket_create(isc_socketmgr_t *manager0, int pf, isc_sockettype_t type,
* in 'socketp'.
*/
isc_result_t
isc__socket_dup(isc_socket_t *sock0, isc_socket_t **socketp) {
isc_socket_dup(isc_socket_t *sock0, isc_socket_t **socketp) {
isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
@ -2958,7 +2788,7 @@ isc__socket_dup(isc_socket_t *sock0, isc_socket_t **socketp) {
}
isc_result_t
isc__socket_open(isc_socket_t *sock0) {
isc_socket_open(isc_socket_t *sock0) {
isc_result_t result;
isc__socket_t *sock = (isc__socket_t *)sock0;
@ -3011,7 +2841,7 @@ isc__socket_open(isc_socket_t *sock0) {
* in 'socketp'.
*/
isc_result_t
isc__socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags,
isc_socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags,
isc_sockfdwatch_t callback, void *cbarg,
isc_task_t *task, isc_socket_t **socketp)
{
@ -3037,7 +2867,6 @@ isc__socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags,
sock->fdwatchtask = task;
sock->statsindex = fdwatchstatsindex;
sock->common.methods = (isc_socketmethods_t *)&socketmethods;
sock->references = 1;
*socketp = (isc_socket_t *)sock;
@ -3082,7 +2911,7 @@ isc__socket_fdwatchcreate(isc_socketmgr_t *manager0, int fd, int flags,
*/
isc_result_t
isc__socket_fdwatchpoke(isc_socket_t *sock0, int flags)
isc_socket_fdwatchpoke(isc_socket_t *sock0, int flags)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
@ -3116,7 +2945,7 @@ isc__socket_fdwatchpoke(isc_socket_t *sock0, int flags)
* Attach to a socket. Caller must explicitly detach when it is done.
*/
void
isc__socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) {
isc_socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) {
isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
@ -3134,7 +2963,7 @@ isc__socket_attach(isc_socket_t *sock0, isc_socket_t **socketp) {
* up by destroying the socket.
*/
void
isc__socket_detach(isc_socket_t **socketp) {
isc_socket_detach(isc_socket_t **socketp) {
isc__socket_t *sock;
bool kill_socket = false;
@ -3156,7 +2985,7 @@ isc__socket_detach(isc_socket_t **socketp) {
}
isc_result_t
isc__socket_close(isc_socket_t *sock0) {
isc_socket_close(isc_socket_t *sock0) {
isc__socket_t *sock = (isc__socket_t *)sock0;
int fd;
isc__socketmgr_t *manager;
@ -4267,7 +4096,7 @@ watcher(void *uap) {
}
void
isc__socketmgr_setreserved(isc_socketmgr_t *manager0, uint32_t reserved) {
isc_socketmgr_setreserved(isc_socketmgr_t *manager0, uint32_t reserved) {
isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
REQUIRE(VALID_MANAGER(manager));
@ -4276,7 +4105,7 @@ isc__socketmgr_setreserved(isc_socketmgr_t *manager0, uint32_t reserved) {
}
void
isc__socketmgr_maxudp(isc_socketmgr_t *manager0, int maxudp) {
isc_socketmgr_maxudp(isc_socketmgr_t *manager0, int maxudp) {
isc__socketmgr_t *manager = (isc__socketmgr_t *)manager0;
REQUIRE(VALID_MANAGER(manager));
@ -4488,12 +4317,12 @@ cleanup_watcher(isc_mem_t *mctx, isc__socketmgr_t *manager) {
}
isc_result_t
isc__socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
return (isc__socketmgr_create2(mctx, managerp, 0));
isc_socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
return (isc_socketmgr_create2(mctx, managerp, 0));
}
isc_result_t
isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
unsigned int maxsocks)
{
int i;
@ -4537,7 +4366,6 @@ isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
#endif
manager->stats = NULL;
manager->common.methods = &socketmgrmethods;
manager->common.magic = ISCAPI_SOCKETMGR_MAGIC;
manager->common.impmagic = SOCKET_MANAGER_MAGIC;
manager->mctx = NULL;
@ -4681,7 +4509,7 @@ isc_socketmgr_setstats(isc_socketmgr_t *manager0, isc_stats_t *stats) {
}
void
isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
isc__socketmgr_t *manager;
int i;
isc_mem_t *mctx;
@ -4841,7 +4669,7 @@ socket_recv(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
}
isc_result_t
isc__socket_recvv(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_socket_recvv(isc_socket_t *sock0, isc_bufferlist_t *buflist,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
@ -4896,7 +4724,7 @@ isc__socket_recvv(isc_socket_t *sock0, isc_bufferlist_t *buflist,
}
isc_result_t
isc__socket_recv(isc_socket_t *sock0, isc_region_t *region,
isc_socket_recv(isc_socket_t *sock0, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
@ -4917,11 +4745,11 @@ isc__socket_recv(isc_socket_t *sock0, isc_region_t *region,
if (dev == NULL)
return (ISC_R_NOMEMORY);
return (isc__socket_recv2(sock0, region, minimum, task, dev, 0));
return (isc_socket_recv2(sock0, region, minimum, task, dev, 0));
}
isc_result_t
isc__socket_recv2(isc_socket_t *sock0, isc_region_t *region,
isc_socket_recv2(isc_socket_t *sock0, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_socketevent_t *event, unsigned int flags)
{
@ -5045,18 +4873,18 @@ socket_send(isc__socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
}
isc_result_t
isc__socket_send(isc_socket_t *sock, isc_region_t *region,
isc_socket_send(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
/*
* REQUIRE() checking is performed in isc_socket_sendto().
*/
return (isc__socket_sendto(sock, region, task, action, arg, NULL,
return (isc_socket_sendto(sock, region, task, action, arg, NULL,
NULL));
}
isc_result_t
isc__socket_sendto(isc_socket_t *sock0, isc_region_t *region,
isc_socket_sendto(isc_socket_t *sock0, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
@ -5085,24 +4913,24 @@ isc__socket_sendto(isc_socket_t *sock0, isc_region_t *region,
}
isc_result_t
isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
return (isc__socket_sendtov2(sock, buflist, task, action, arg, NULL,
return (isc_socket_sendtov2(sock, buflist, task, action, arg, NULL,
NULL, 0));
}
isc_result_t
isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
return (isc__socket_sendtov2(sock, buflist, task, action, arg, address,
return (isc_socket_sendtov2(sock, buflist, task, action, arg, address,
pktinfo, 0));
}
isc_result_t
isc__socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
@ -5144,7 +4972,7 @@ isc__socket_sendtov2(isc_socket_t *sock0, isc_bufferlist_t *buflist,
}
isc_result_t
isc__socket_sendto2(isc_socket_t *sock0, isc_region_t *region,
isc_socket_sendto2(isc_socket_t *sock0, isc_region_t *region,
isc_task_t *task,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
isc_socketevent_t *event, unsigned int flags)
@ -5167,7 +4995,7 @@ isc__socket_sendto2(isc_socket_t *sock0, isc_region_t *region,
}
void
isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, bool active) {
isc_socket_cleanunix(const isc_sockaddr_t *sockaddr, bool active) {
#ifdef ISC_PLATFORM_HAVESYSUNH
int s;
struct stat sb;
@ -5297,7 +5125,7 @@ isc__socket_cleanunix(const isc_sockaddr_t *sockaddr, bool active) {
}
isc_result_t
isc__socket_permunix(const isc_sockaddr_t *sockaddr, uint32_t perm,
isc_socket_permunix(const isc_sockaddr_t *sockaddr, uint32_t perm,
uint32_t owner, uint32_t group)
{
#ifdef ISC_PLATFORM_HAVESYSUNH
@ -5353,7 +5181,7 @@ isc__socket_permunix(const isc_sockaddr_t *sockaddr, uint32_t perm,
}
isc_result_t
isc__socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
isc_socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
@ -5430,7 +5258,7 @@ isc__socket_bind(isc_socket_t *sock0, const isc_sockaddr_t *sockaddr,
#undef ENABLE_ACCEPTFILTER
isc_result_t
isc__socket_filter(isc_socket_t *sock0, const char *filter) {
isc_socket_filter(isc_socket_t *sock0, const char *filter) {
isc__socket_t *sock = (isc__socket_t *)sock0;
#if defined(SO_ACCEPTFILTER) && defined(ENABLE_ACCEPTFILTER)
char strbuf[ISC_STRERRORSIZE];
@ -5533,7 +5361,7 @@ set_tcp_fastopen(isc__socket_t *sock, unsigned int backlog) {
* as well keep things simple rather than having to track them.
*/
isc_result_t
isc__socket_listen(isc_socket_t *sock0, unsigned int backlog) {
isc_socket_listen(isc_socket_t *sock0, unsigned int backlog) {
isc__socket_t *sock = (isc__socket_t *)sock0;
char strbuf[ISC_STRERRORSIZE];
@ -5570,7 +5398,7 @@ isc__socket_listen(isc_socket_t *sock0, unsigned int backlog) {
* This should try to do aggressive accept() XXXMLG
*/
isc_result_t
isc__socket_accept(isc_socket_t *sock0,
isc_socket_accept(isc_socket_t *sock0,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
@ -5645,7 +5473,7 @@ isc__socket_accept(isc_socket_t *sock0,
}
isc_result_t
isc__socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
isc_socket_connect(isc_socket_t *sock0, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
isc__socket_t *sock = (isc__socket_t *)sock0;
@ -5924,7 +5752,7 @@ internal_connect(isc_task_t *me, isc_event_t *ev) {
}
isc_result_t
isc__socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
isc_socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
isc__socket_t *sock = (isc__socket_t *)sock0;
isc_result_t result;
@ -5946,7 +5774,7 @@ isc__socket_getpeername(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
}
isc_result_t
isc__socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
isc_socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
isc__socket_t *sock = (isc__socket_t *)sock0;
socklen_t len;
isc_result_t result;
@ -5985,7 +5813,7 @@ isc__socket_getsockname(isc_socket_t *sock0, isc_sockaddr_t *addressp) {
* queued for task "task" of type "how". "how" is a bitmask.
*/
void
isc__socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
isc_socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
@ -6105,7 +5933,7 @@ isc__socket_cancel(isc_socket_t *sock0, isc_task_t *task, unsigned int how) {
}
isc_sockettype_t
isc__socket_gettype(isc_socket_t *sock0) {
isc_socket_gettype(isc_socket_t *sock0) {
isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
@ -6113,22 +5941,8 @@ isc__socket_gettype(isc_socket_t *sock0) {
return (sock->type);
}
bool
isc__socket_isbound(isc_socket_t *sock0) {
isc__socket_t *sock = (isc__socket_t *)sock0;
bool val;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
val = ((sock->bound) ? true : false);
UNLOCK(&sock->lock);
return (val);
}
void
isc__socket_ipv6only(isc_socket_t *sock0, bool yes) {
isc_socket_ipv6only(isc_socket_t *sock0, bool yes) {
isc__socket_t *sock = (isc__socket_t *)sock0;
#if defined(IPV6_V6ONLY)
int onoff = yes ? 1 : 0;
@ -6204,7 +6018,7 @@ setdscp(isc__socket_t *sock, isc_dscp_t dscp) {
}
void
isc__socket_dscp(isc_socket_t *sock0, isc_dscp_t dscp) {
isc_socket_dscp(isc_socket_t *sock0, isc_dscp_t dscp) {
isc__socket_t *sock = (isc__socket_t *)sock0;
REQUIRE(VALID_SOCKET(sock));
@ -6238,7 +6052,7 @@ isc_socket_socketevent(isc_mem_t *mctx, void *sender,
}
void
isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
isc_socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
isc__socket_t *sock = (isc__socket_t *)socket0;
/*
@ -6254,26 +6068,21 @@ isc__socket_setname(isc_socket_t *socket0, const char *name, void *tag) {
}
const char *
isc__socket_getname(isc_socket_t *socket0) {
isc_socket_getname(isc_socket_t *socket0) {
isc__socket_t *sock = (isc__socket_t *)socket0;
return (sock->name);
}
void *
isc__socket_gettag(isc_socket_t *socket0) {
isc_socket_gettag(isc_socket_t *socket0) {
isc__socket_t *sock = (isc__socket_t *)socket0;
return (sock->tag);
}
isc_result_t
isc__socket_register(void) {
return (isc_socket_register(isc__socketmgr_create));
}
int
isc__socket_getfd(isc_socket_t *socket0) {
isc_socket_getfd(isc_socket_t *socket0) {
isc__socket_t *sock = (isc__socket_t *)socket0;
return ((short) sock->fd);
@ -6535,4 +6344,16 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr0, json_object *stats) {
}
#endif /* HAVE_JSON */
#include "../socket_api.c"
isc_result_t
isc_socketmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
isc_socketmgr_t **managerp)
{
isc_result_t result;
result = isc_socketmgr_create(mctx, managerp);
if (result == ISC_R_SUCCESS)
isc_appctx_setsocketmgr(actx, *managerp);
return (result);
}

126
lib/isc/win32/app.c
View file

@ -40,39 +40,8 @@
*/
static isc_thread_t blockedthread;
static bool is_running;
/*%
* The following are intended for internal use (indicated by "isc__"
* prefix) but are not declared as static, allowing direct access from
* unit tests etc.
*/
isc_result_t isc__app_start(void);
isc_result_t isc__app_ctxstart(isc_appctx_t *ctx);
isc_result_t isc__app_onrun(isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg);
isc_result_t isc__app_ctxrun(isc_appctx_t *ctx);
isc_result_t isc__app_run(void);
isc_result_t isc__app_ctxshutdown(isc_appctx_t *ctx);
isc_result_t isc__app_shutdown(void);
isc_result_t isc__app_reload(void);
isc_result_t isc__app_ctxsuspend(isc_appctx_t *ctx);
void isc__app_ctxfinish(isc_appctx_t *ctx);
void isc__app_finish(void);
void isc__app_block(void);
void isc__app_unblock(void);
isc_result_t isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp);
void isc__appctx_destroy(isc_appctx_t **ctxp);
void isc__appctx_settaskmgr(isc_appctx_t *ctx, isc_taskmgr_t *taskmgr);
void isc__appctx_setsocketmgr(isc_appctx_t *ctx, isc_socketmgr_t *socketmgr);
void isc__appctx_settimermgr(isc_appctx_t *ctx, isc_timermgr_t *timermgr);
isc_result_t isc__app_ctxonrun(isc_appctx_t *ctx, isc_mem_t *mctx,
isc_task_t *task, isc_taskaction_t action,
void *arg);
/*
* The application context of this module. This implementation actually
* doesn't use it. (This may change in the future).
*/
#define APPCTX_MAGIC ISC_MAGIC('A', 'p', 'c', 'x')
#define VALID_APPCTX(c) ISC_MAGIC_VALID(c, APPCTX_MAGIC)
@ -112,42 +81,13 @@ typedef struct isc__appctx {
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
};
/*
* We need to remember which thread is the main thread...
*/
static isc_thread_t main_thread;
isc_result_t
isc__app_ctxstart(isc_appctx_t *ctx0) {
isc_app_ctxstart(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_result_t result;
@ -180,26 +120,26 @@ isc__app_ctxstart(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_start(void) {
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() */
return (isc__app_ctxstart((isc_appctx_t *)&isc_g_appctx));
return (isc_app_ctxstart((isc_appctx_t *)&isc_g_appctx));
}
isc_result_t
isc__app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
isc_app_onrun(isc_mem_t *mctx, isc_task_t *task, isc_taskaction_t action,
void *arg)
{
return (isc__app_ctxonrun((isc_appctx_t *)&isc_g_appctx, mctx,
return (isc_app_ctxonrun((isc_appctx_t *)&isc_g_appctx, mctx,
task, action, arg));
}
isc_result_t
isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
isc_app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
@ -238,7 +178,7 @@ isc__app_ctxonrun(isc_appctx_t *ctx0, isc_mem_t *mctx, isc_task_t *task,
}
isc_result_t
isc__app_ctxrun(isc_appctx_t *ctx0) {
isc_app_ctxrun(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
isc_event_t *event, *next_event;
isc_task_t *task;
@ -311,12 +251,21 @@ isc__app_ctxrun(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_run(void) {
return (isc__app_ctxrun((isc_appctx_t *)&isc_g_appctx));
isc_app_run(void) {
isc_result_t result;
is_running = ISC_TRUE;
result = isc_app_ctxrun((isc_appctx_t *)&isc_g_appctx);
is_running = ISC_FALSE;
return result;
}
bool
isc_app_isrunning() {
return (is_running);
}
isc_result_t
isc__app_ctxshutdown(isc_appctx_t *ctx0) {
isc_app_ctxshutdown(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
@ -340,12 +289,12 @@ isc__app_ctxshutdown(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_shutdown(void) {
return (isc__app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
isc_app_shutdown(void) {
return (isc_app_ctxshutdown((isc_appctx_t *)&isc_g_appctx));
}
isc_result_t
isc__app_ctxsuspend(isc_appctx_t *ctx0) {
isc_app_ctxsuspend(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
bool want_kill = true;
@ -370,12 +319,12 @@ isc__app_ctxsuspend(isc_appctx_t *ctx0) {
}
isc_result_t
isc__app_reload(void) {
return (isc__app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
isc_app_reload(void) {
return (isc_app_ctxsuspend((isc_appctx_t *)&isc_g_appctx));
}
void
isc__app_ctxfinish(isc_appctx_t *ctx0) {
isc_app_ctxfinish(isc_appctx_t *ctx0) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -384,12 +333,12 @@ isc__app_ctxfinish(isc_appctx_t *ctx0) {
}
void
isc__app_finish(void) {
isc__app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
isc_app_finish(void) {
isc_app_ctxfinish((isc_appctx_t *)&isc_g_appctx);
}
void
isc__app_block(void) {
isc_app_block(void) {
REQUIRE(isc_g_appctx.running);
REQUIRE(!isc_g_appctx.blocked);
@ -398,7 +347,7 @@ isc__app_block(void) {
}
void
isc__app_unblock(void) {
isc_app_unblock(void) {
REQUIRE(isc_g_appctx.running);
REQUIRE(isc_g_appctx.blocked);
@ -407,7 +356,7 @@ isc__app_unblock(void) {
}
isc_result_t
isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
isc_appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(mctx != NULL);
@ -434,7 +383,7 @@ isc__appctx_create(isc_mem_t *mctx, isc_appctx_t **ctxp) {
}
void
isc__appctx_destroy(isc_appctx_t **ctxp) {
isc_appctx_destroy(isc_appctx_t **ctxp) {
isc__appctx_t *ctx;
REQUIRE(ctxp != NULL);
@ -447,7 +396,7 @@ isc__appctx_destroy(isc_appctx_t **ctxp) {
}
void
isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
isc_appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -456,7 +405,7 @@ isc__appctx_settaskmgr(isc_appctx_t *ctx0, isc_taskmgr_t *taskmgr) {
}
void
isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
isc_appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -465,7 +414,7 @@ isc__appctx_setsocketmgr(isc_appctx_t *ctx0, isc_socketmgr_t *socketmgr) {
}
void
isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
isc_appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
isc__appctx_t *ctx = (isc__appctx_t *)ctx0;
REQUIRE(VALID_APPCTX(ctx));
@ -473,9 +422,4 @@ isc__appctx_settimermgr(isc_appctx_t *ctx0, isc_timermgr_t *timermgr) {
ctx->timermgr = timermgr;
}
isc_result_t
isc__app_register(void) {
return (isc_app_register(isc__appctx_create));
}
#include "../app_api.c"

147
lib/isc/win32/libisc.def.in
View file

@ -9,25 +9,25 @@ closelog
getpassphrase
@END PKCS11
isc___socketmgr_maxudp
isc__app_block
isc__app_ctxfinish
isc__app_ctxonrun
isc__app_ctxrun
isc__app_ctxshutdown
isc__app_ctxstart
isc__app_ctxsuspend
isc__app_finish
isc__app_onrun
isc__app_reload
isc__app_run
isc__app_shutdown
isc__app_start
isc__app_unblock
isc__appctx_create
isc__appctx_destroy
isc__appctx_setsocketmgr
isc__appctx_settaskmgr
isc__appctx_settimermgr
isc_app_block
isc_app_ctxfinish
isc_app_ctxonrun
isc_app_ctxrun
isc_app_ctxshutdown
isc_app_ctxstart
isc_app_ctxsuspend
isc_app_finish
isc_app_onrun
isc_app_reload
isc_app_run
isc_app_shutdown
isc_app_start
isc_app_unblock
isc_appctx_create
isc_appctx_destroy
isc_appctx_setsocketmgr
isc_appctx_settaskmgr
isc_appctx_settimermgr
isc__buffer_activeregion
isc__buffer_add
isc__buffer_availableregion
@ -51,60 +51,61 @@ isc__buffer_remainingregion
isc__buffer_setactive
isc__buffer_subtract
isc__buffer_usedregion
isc__mem_allocate
isc__mem_free
isc__mem_get
isc__mem_printactive
isc__mem_put
isc__mem_putanddetach
isc__mem_reallocate
isc__mem_strdup
isc__mempool_get
isc__mempool_put
isc__socket_accept
isc__socket_attach
isc__socket_bind
isc__socket_cancel
isc__socket_cleanunix
isc__socket_close
isc__socket_connect
isc__socket_create
isc__socket_detach
isc__socket_dscp
isc__socket_dup
isc__socket_filter
isc__socket_getfd
isc__socket_getname
isc__socket_getpeername
isc__socket_getsockname
isc__socket_gettag
isc__socket_gettype
isc__socket_ipv6only
isc__socket_isbound
isc__socket_listen
isc__socket_open
isc__socket_permunix
isc__socket_recv
isc__socket_recv2
isc__socket_recvv
isc__socket_register
isc__socket_send
isc__socket_sendto
isc__socket_sendto2
isc__socket_sendtov
isc__socket_sendtov2
isc__socket_sendv
isc__socket_setname
isc__socketmgr_create
isc__socketmgr_create2
isc__socketmgr_destroy
isc__socketmgr_getmaxsockets
isc__socketmgr_setreserved
isc__socketmgr_setstats
isc__task_getname
isc__task_gettag
isc__task_unsendrange
isc__taskmgr_mode
isc_mem_allocate
isc_mem_free
isc_mem_get
isc_mem_printactive
isc_mem_put
isc_mem_putanddetach
isc_mem_reallocate
isc_mem_strdup
isc_mempool_get
isc_mempool_put
isc_socket_accept
isc_socket_attach
isc_socket_bind
isc_socket_cancel
isc_socket_cleanunix
isc_socket_close
isc_socket_connect
isc_socket_create
isc_socket_detach
isc_socket_dscp
isc_socket_dup
isc_socket_filter
isc_socket_getfd
isc_socket_getname
isc_socket_getpeername
isc_socket_getsockname
isc_socket_gettag
isc_socket_gettype
isc_socket_ipv6only
isc_socket_isbound
isc_socket_listen
isc_socket_open
isc_socket_permunix
isc_socket_recv
isc_socket_recv2
isc_socket_recvv
isc_socket_register
isc_socket_send
isc_socket_sendto
isc_socket_sendto2
isc_socket_sendtov
isc_socket_sendtov2
isc_socket_sendv
isc_socket_setname
isc_socketmgr_create
isc_socketmgr_create2
isc_socketmgr_destroy
isc_socketmgr_getmaxsockets
isc_socketmgr_setreserved
isc_socketmgr_setstats
isc__strerror
isc_task_getname
isc_task_gettag
isc_task_unsendrange
isc_taskmgr_mode
isc__taskmgr_pause
isc__taskmgr_resume
isc_aes128_crypt

133
lib/isc/win32/socket.c
View file

@ -1799,19 +1799,19 @@ socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
if (dup_socket) {
#ifndef ISC_ALLOW_MAPPED
isc__socket_ipv6only(sock, true);
isc_socket_ipv6only(sock, true);
#endif
if (dup_socket->bound) {
isc_sockaddr_t local;
result = isc__socket_getsockname(dup_socket, &local);
result = isc_socket_getsockname(dup_socket, &local);
if (result != ISC_R_SUCCESS) {
isc_socket_close(sock);
return (result);
}
result = isc__socket_bind(sock, &local,
ISC_SOCKET_REUSEADDRESS);
result = isc_socket_bind(sock, &local,
ISC_SOCKET_REUSEADDRESS);
if (result != ISC_R_SUCCESS) {
isc_socket_close(sock);
return (result);
@ -1837,14 +1837,14 @@ socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
}
isc_result_t
isc__socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_create(isc_socketmgr_t *manager, int pf, isc_sockettype_t type,
isc_socket_t **socketp)
{
return (socket_create(manager, pf, type, socketp, NULL));
}
isc_result_t
isc__socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
isc_socket_dup(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
@ -1864,7 +1864,7 @@ isc_socket_open(isc_socket_t *sock) {
* Attach to a socket. Caller must explicitly detach when it is done.
*/
void
isc__socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
isc_socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
REQUIRE(VALID_SOCKET(sock));
REQUIRE(socketp != NULL && *socketp == NULL);
@ -1881,7 +1881,7 @@ isc__socket_attach(isc_socket_t *sock, isc_socket_t **socketp) {
* up by destroying the socket.
*/
void
isc__socket_detach(isc_socket_t **socketp) {
isc_socket_detach(isc_socket_t **socketp) {
isc_socket_t *sock;
REQUIRE(socketp != NULL);
@ -2639,12 +2639,12 @@ SocketIoThread(LPVOID ThreadContext) {
* Create a new socket manager.
*/
isc_result_t
isc__socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
isc_socketmgr_create(isc_mem_t *mctx, isc_socketmgr_t **managerp) {
return (isc_socketmgr_create2(mctx, managerp, 0));
}
isc_result_t
isc__socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
isc_socketmgr_create2(isc_mem_t *mctx, isc_socketmgr_t **managerp,
unsigned int maxsocks)
{
isc_socketmgr_t *manager;
@ -2712,7 +2712,7 @@ isc_socketmgr_setstats(isc_socketmgr_t *manager, isc_stats_t *stats) {
}
void
isc__socketmgr_destroy(isc_socketmgr_t **managerp) {
isc_socketmgr_destroy(isc_socketmgr_t **managerp) {
isc_socketmgr_t *manager;
int i;
isc_mem_t *mctx;
@ -2837,7 +2837,7 @@ socket_recv(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
}
isc_result_t
isc__socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc;_socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
@ -2908,7 +2908,7 @@ isc__socket_recvv(isc_socket_t *sock, isc_bufferlist_t *buflist,
}
isc_result_t
isc__socket_recv(isc_socket_t *sock, isc_region_t *region,
isc_socket_recv(isc_socket_t *sock, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_taskaction_t action, void *arg)
{
@ -2947,7 +2947,7 @@ isc__socket_recv(isc_socket_t *sock, isc_region_t *region,
}
isc_result_t
isc__socket_recv2(isc_socket_t *sock, isc_region_t *region,
isc_socket_recv2(isc_socket_t *sock, isc_region_t *region,
unsigned int minimum, isc_task_t *task,
isc_socketevent_t *event, unsigned int flags)
{
@ -3058,7 +3058,7 @@ socket_send(isc_socket_t *sock, isc_socketevent_t *dev, isc_task_t *task,
}
isc_result_t
isc__socket_send(isc_socket_t *sock, isc_region_t *region,
isc_socket_send(isc_socket_t *sock, isc_region_t *region,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
/*
@ -3069,7 +3069,7 @@ isc__socket_send(isc_socket_t *sock, isc_region_t *region,
}
isc_result_t
isc__socket_sendto(isc_socket_t *sock, isc_region_t *region,
isc_socket_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)
{
@ -3113,7 +3113,7 @@ isc__socket_sendto(isc_socket_t *sock, isc_region_t *region,
}
isc_result_t
isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
return (isc_socket_sendtov2(sock, buflist, task, action, arg, NULL,
@ -3121,8 +3121,8 @@ isc__socket_sendv(isc_socket_t *sock, isc_bufferlist_t *buflist,
}
isc_result_t
isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo)
{
return (isc_socket_sendtov2(sock, buflist, task, action, arg, address,
@ -3130,10 +3130,10 @@ isc__socket_sendtov(isc_socket_t *sock, isc_bufferlist_t *buflist,
}
isc_result_t
isc__socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
isc_socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
isc_task_t *task, isc_taskaction_t action, void *arg,
const isc_sockaddr_t *address, struct in6_pktinfo *pktinfo,
unsigned int flags)
unsigned int flags)
{
isc_socketevent_t *dev;
isc_socketmgr_t *manager;
@ -3187,9 +3187,9 @@ isc__socket_sendtov2(isc_socket_t *sock, isc_bufferlist_t *buflist,
}
isc_result_t
isc__socket_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_socket_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 ret;
@ -3221,8 +3221,8 @@ isc__socket_sendto2(isc_socket_t *sock, isc_region_t *region, isc_task_t *task,
}
isc_result_t
isc__socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options)
isc_socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
isc_socket_options_t options)
{
int bind_errno;
char strbuf[ISC_STRERRORSIZE];
@ -3289,7 +3289,7 @@ isc__socket_bind(isc_socket_t *sock, const isc_sockaddr_t *sockaddr,
}
isc_result_t
isc__socket_filter(isc_socket_t *sock, const char *filter) {
isc_socket_filter(isc_socket_t *sock, const char *filter) {
UNUSED(sock);
UNUSED(filter);
@ -3308,7 +3308,7 @@ isc__socket_filter(isc_socket_t *sock, const char *filter) {
* as well keep things simple rather than having to track them.
*/
isc_result_t
isc__socket_listen(isc_socket_t *sock, unsigned int backlog) {
isc_socket_listen(isc_socket_t *sock, unsigned int backlog) {
char strbuf[ISC_STRERRORSIZE];
#if defined(ENABLE_TCP_FASTOPEN) && defined(TCP_FASTOPEN)
char on = 1;
@ -3367,8 +3367,8 @@ isc__socket_listen(isc_socket_t *sock, unsigned int backlog) {
* This should try to do aggressive accept() XXXMLG
*/
isc_result_t
isc__socket_accept(isc_socket_t *sock,
isc_task_t *task, isc_taskaction_t action, void *arg)
isc_socket_accept(isc_socket_t *sock,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
isc_socket_newconnev_t *adev;
isc_socketmgr_t *manager;
@ -3485,8 +3485,8 @@ isc__socket_accept(isc_socket_t *sock,
}
isc_result_t
isc__socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
isc_socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
isc_task_t *task, isc_taskaction_t action, void *arg)
{
char strbuf[ISC_STRERRORSIZE];
isc_socket_connev_t *cdev;
@ -3616,7 +3616,7 @@ isc__socket_connect(isc_socket_t *sock, const isc_sockaddr_t *addr,
}
isc_result_t
isc__socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
isc_socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
isc_result_t result;
REQUIRE(VALID_SOCKET(sock));
@ -3646,7 +3646,7 @@ isc__socket_getpeername(isc_socket_t *sock, isc_sockaddr_t *addressp) {
}
isc_result_t
isc__socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
isc_socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
socklen_t len;
isc_result_t result;
char strbuf[ISC_STRERRORSIZE];
@ -3693,7 +3693,7 @@ isc__socket_getsockname(isc_socket_t *sock, isc_sockaddr_t *addressp) {
* queued for task "task" of type "how". "how" is a bitmask.
*/
void
isc__socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
isc_socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
REQUIRE(VALID_SOCKET(sock));
@ -3819,7 +3819,7 @@ isc__socket_cancel(isc_socket_t *sock, isc_task_t *task, unsigned int how) {
}
isc_sockettype_t
isc__socket_gettype(isc_socket_t *sock) {
isc_socket_gettype(isc_socket_t *sock) {
isc_sockettype_t type;
REQUIRE(VALID_SOCKET(sock));
@ -3839,31 +3839,8 @@ isc__socket_gettype(isc_socket_t *sock) {
return (type);
}
bool
isc__socket_isbound(isc_socket_t *sock) {
bool val;
REQUIRE(VALID_SOCKET(sock));
LOCK(&sock->lock);
CONSISTENT(sock);
/*
* make sure that the socket's not closed
*/
if (sock->fd == INVALID_SOCKET) {
UNLOCK(&sock->lock);
return (false);
}
val = ((sock->bound) ? true : false);
UNLOCK(&sock->lock);
return (val);
}
void
isc__socket_ipv6only(isc_socket_t *sock, bool yes) {
isc_socket_ipv6only(isc_socket_t *sock, bool yes) {
#if defined(IPV6_V6ONLY)
int onoff = yes ? 1 : 0;
#else
@ -3881,7 +3858,7 @@ isc__socket_ipv6only(isc_socket_t *sock, bool yes) {
}
void
isc__socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
isc_socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
#if !defined(IP_TOS) && !defined(IPV6_TCLASS)
UNUSED(dscp);
#else
@ -3909,14 +3886,14 @@ isc__socket_dscp(isc_socket_t *sock, isc_dscp_t dscp) {
}
void
isc__socket_cleanunix(const isc_sockaddr_t *addr, bool active) {
isc_socket_cleanunix(const isc_sockaddr_t *addr, bool active) {
UNUSED(addr);
UNUSED(active);
}
isc_result_t
isc__socket_permunix(const isc_sockaddr_t *addr, uint32_t perm,
uint32_t owner, uint32_t group)
isc_socket_permunix(const isc_sockaddr_t *addr, uint32_t perm,
uint32_t owner, uint32_t group)
{
UNUSED(addr);
UNUSED(perm);
@ -3926,7 +3903,7 @@ isc__socket_permunix(const isc_sockaddr_t *addr, uint32_t perm,
}
void
isc__socket_setname(isc_socket_t *socket, const char *name, void *tag) {
isc_socket_setname(isc_socket_t *socket, const char *name, void *tag) {
/*
* Name 'socket'.
@ -3941,33 +3918,26 @@ isc__socket_setname(isc_socket_t *socket, const char *name, void *tag) {
}
const char *
isc__socket_getname(isc_socket_t *socket) {
isc_socket_getname(isc_socket_t *socket) {
return (socket->name);
}
void *
isc__socket_gettag(isc_socket_t *socket) {
isc_socket_gettag(isc_socket_t *socket) {
return (socket->tag);
}
int
isc__socket_getfd(isc_socket_t *socket) {
isc_socket_getfd(isc_socket_t *socket) {
return ((short) socket->fd);
}
void
isc__socketmgr_setreserved(isc_socketmgr_t *manager, uint32_t reserved) {
isc_socketmgr_setreserved(isc_socketmgr_t *manager, uint32_t reserved) {
UNUSED(manager);
UNUSED(reserved);
}
void
isc___socketmgr_maxudp(isc_socketmgr_t *manager, int maxudp) {
UNUSED(manager);
UNUSED(maxudp);
}
isc_socketevent_t *
isc_socket_socketevent(isc_mem_t *mctx, void *sender,
isc_eventtype_t eventtype, isc_taskaction_t action,
@ -4235,15 +4205,6 @@ isc_socketmgr_renderjson(isc_socketmgr_t *mgr, json_object *stats) {
}
#endif /* HAVE_JSON */
/*
* Replace ../socket_api.c
*/
isc_result_t
isc__socket_register(void) {
return (ISC_R_SUCCESS);
}
isc_result_t
isc_socketmgr_createinctx(isc_mem_t *mctx, isc_appctx_t *actx,
isc_socketmgr_t **managerp)

4
util/copyrights
View file

@ -3325,7 +3325,6 @@
./lib/isc/Kyuafile X 2017,2018
./lib/isc/aes.c C 2014,2016,2017,2018
./lib/isc/api X 1999,2000,2001,2006,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018
./lib/isc/app_api.c C 2009,2013,2014,2015,2016,2018
./lib/isc/assertions.c C 1997,1998,1999,2000,2001,2004,2005,2007,2008,2009,2015,2016,2018
./lib/isc/backtrace-emptytbl.c C 2009,2016,2018
./lib/isc/backtrace.c C 2009,2013,2014,2015,2016,2018
@ -3454,6 +3453,7 @@
./lib/isc/log.c C 1999,2000,2001,2002,2003,2004,2005,2006,2007,2009,2011,2012,2013,2014,2016,2017,2018
./lib/isc/md5.c C 2000,2001,2004,2005,2007,2009,2014,2015,2016,2017,2018
./lib/isc/mem.c C 1997,1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2012,2013,2014,2015,2016,2017,2018
./lib/isc/mem_p.h C 2018
./lib/isc/mutexblock.c C 1999,2000,2001,2004,2005,2007,2011,2012,2016,2018
./lib/isc/netaddr.c C 1999,2000,2001,2002,2004,2005,2007,2010,2011,2012,2014,2015,2016,2017,2018
./lib/isc/netscope.c C 2002,2004,2005,2006,2007,2016,2018
@ -3486,11 +3486,11 @@
./lib/isc/sha1.c C 2000,2001,2003,2004,2005,2007,2009,2011,2012,2014,2016,2017,2018
./lib/isc/sha2.c C 2005,2006,2007,2009,2011,2012,2014,2016,2017,2018
./lib/isc/sockaddr.c C 1999,2000,2001,2002,2003,2004,2005,2006,2007,2010,2011,2012,2014,2015,2016,2017,2018
./lib/isc/socket_api.c C 2009,2011,2012,2013,2014,2015,2016,2018
./lib/isc/stats.c C 2009,2012,2013,2014,2015,2016,2017,2018
./lib/isc/string.c C 1999,2000,2001,2003,2004,2005,2006,2007,2011,2012,2014,2015,2016,2018
./lib/isc/symtab.c C 1996,1997,1998,1999,2000,2001,2004,2005,2007,2011,2012,2013,2016,2018
./lib/isc/task.c C 1998,1999,2000,2001,2002,2003,2004,2005,2006,2007,2008,2009,2010,2011,2012,2013,2014,2015,2016,2017,2018
./lib/isc/task_p.h C 2018
./lib/isc/taskpool.c C 1999,2000,2001,2004,2005,2007,2011,2012,2013,2016,2018
./lib/isc/tests/Atffile X 2011,2017,2018
./lib/isc/tests/Kyuafile X 2017,2018