From 1ae7a3c4d2f018b251838ffdbd926c758cc2329c Mon Sep 17 00:00:00 2001 From: Martin Nagy Date: Tue, 21 Apr 2009 09:31:11 +0200 Subject: Pass all necessary pointers in a packed structure. Access to the dns_dyndb_arguments_t structure is done through a set of dns_dyndb_set_* and dns_dyndb_get_* functions. This will make it unnecessary to break the ABI if someone designing a plug-in will have a need for something more than there currently is. All that will be needed in that case will be an addition of set/get functions. --- bin/named/server.c | 31 ++++++++--- lib/dns/dynamic_db.c | 117 +++++++++++++++++++++++++++++++++++++-- lib/dns/include/dns/dynamic_db.h | 21 ++++++- lib/dns/include/dns/types.h | 1 + 4 files changed, 156 insertions(+), 14 deletions(-) diff --git a/bin/named/server.c b/bin/named/server.c index b76f3ce..5d4077d 100644 --- a/bin/named/server.c +++ b/bin/named/server.c @@ -851,7 +851,7 @@ configure_peer(const cfg_obj_t *cpeer, isc_mem_t *mctx, dns_peer_t **peerp) { static isc_result_t configure_dynamic_db(const cfg_obj_t *dynamic_db, isc_mem_t *mctx, - dns_view_t *view, dns_zonemgr_t *zmgr) + const dns_dyndb_arguments_t *dyndb_args) { isc_result_t result; const cfg_obj_t *obj; @@ -905,7 +905,7 @@ configure_dynamic_db(const cfg_obj_t *dynamic_db, isc_mem_t *mctx, REQUIRE(i < len); argv[i] = NULL; - CHECK(dns_dynamic_db_load(libname, name, mctx, argv, view, zmgr)); + CHECK(dns_dynamic_db_load(libname, name, mctx, argv, dyndb_args)); cleanup: if (argv != NULL) @@ -1246,12 +1246,27 @@ configure_view(dns_view_t *view, const cfg_obj_t *config, (void)cfg_map_get(voptions, "dynamic-db", &dynamic_db_list); else (void)cfg_map_get(config, "dynamic-db", &dynamic_db_list); - for (element = cfg_list_first(dynamic_db_list); - element != NULL; - element = cfg_list_next(element)) - { - obj = cfg_listelt_value(element); - CHECK(configure_dynamic_db(obj, mctx, view, ns_g_server->zonemgr)); + element = cfg_list_first(dynamic_db_list); + if (element != NULL) { + dns_dyndb_arguments_t *args; + + args = dns_dyndb_arguments_create(mctx); + if (args == NULL) { + result = ISC_R_NOMEMORY; + goto cleanup; + } + dns_dyndb_set_view(args, view); + dns_dyndb_set_zonemgr(args, ns_g_server->zonemgr); + dns_dyndb_set_task(args, ns_g_server->task); + dns_dyndb_set_timermgr(args, ns_g_timermgr); + while (element != NULL) { + obj = cfg_listelt_value(element); + CHECK(configure_dynamic_db(obj, mctx, args)); + + element = cfg_list_next(element); + } + + dns_dyndb_arguments_destroy(mctx, args); } /* diff --git a/lib/dns/dynamic_db.c b/lib/dns/dynamic_db.c index 662fc06..f11584d 100644 --- a/lib/dns/dynamic_db.c +++ b/lib/dns/dynamic_db.c @@ -21,13 +21,17 @@ #include #include #include +#include #include #include #include #include #include +#include +#include +#include #if HAVE_DLFCN_H #include @@ -40,8 +44,7 @@ typedef isc_result_t (*register_func_t)(isc_mem_t *mctx, const char *name, - const char * const *argv, dns_view_t *view, - dns_zonemgr_t *zmgr); + const char * const *argv, dns_dyndb_arguments_t *dyndb_args); typedef void (*destroy_func_t)(void); typedef struct dyndb_implementation dyndb_implementation_t; @@ -54,6 +57,13 @@ struct dyndb_implementation { LINK(dyndb_implementation_t) link; }; +struct dns_dyndb_arguments { + dns_view_t *view; + dns_zonemgr_t *zmgr; + isc_task_t *task; + isc_timermgr_t *timermgr; +}; + /* List of implementations. Locked by dyndb_lock. */ static LIST(dyndb_implementation_t) dyndb_implementations; /* Locks dyndb_implementations. */ @@ -192,8 +202,7 @@ unload_library(dyndb_implementation_t **impp) isc_result_t dns_dynamic_db_load(const char *libname, const char *name, isc_mem_t *mctx, - const char * const *argv, dns_view_t *view, - dns_zonemgr_t *zmgr) + const char * const *argv, dns_dyndb_arguments_t *dyndb_args) { isc_result_t result; dyndb_implementation_t *implementation = NULL; @@ -201,7 +210,7 @@ dns_dynamic_db_load(const char *libname, const char *name, isc_mem_t *mctx, RUNTIME_CHECK(isc_once_do(&once, dyndb_initialize) == ISC_R_SUCCESS); CHECK(load_library(mctx, libname, &implementation)); - CHECK(implementation->register_function(mctx, name, argv, view, zmgr)); + CHECK(implementation->register_function(mctx, name, argv, dyndb_args)); LOCK(&dyndb_lock); APPEND(dyndb_implementations, implementation, link); @@ -237,3 +246,101 @@ dns_dynamic_db_cleanup(void) isc_mutex_destroy(&dyndb_lock); } + +dns_dyndb_arguments_t * +dns_dyndb_arguments_create(isc_mem_t *mctx) +{ + dns_dyndb_arguments_t *args; + + args = isc_mem_get(mctx, sizeof(*args)); + if (args != NULL) + memset(args, 0, sizeof(*args)); + + return args; +} + +void +dns_dyndb_arguments_destroy(isc_mem_t *mctx, dns_dyndb_arguments_t *args) +{ + REQUIRE(args != NULL); + + dns_dyndb_set_view(args, NULL); + dns_dyndb_set_zonemgr(args, NULL); + dns_dyndb_set_task(args, NULL); + dns_dyndb_set_timermgr(args, NULL); + + isc_mem_put(mctx, args, sizeof(*args)); +} + +void +dns_dyndb_set_view(dns_dyndb_arguments_t *args, dns_view_t *view) +{ + REQUIRE(args != NULL); + + if (args->view != NULL) + dns_view_detach(&args->view); + if (view != NULL) + dns_view_attach(view, &args->view); +} + +dns_view_t * +dns_dyndb_get_view(dns_dyndb_arguments_t *args) +{ + REQUIRE(args != NULL); + + return args->view; +} + +void +dns_dyndb_set_zonemgr(dns_dyndb_arguments_t *args, dns_zonemgr_t *zmgr) +{ + REQUIRE(args != NULL); + + if (args->zmgr != NULL) + dns_zonemgr_detach(&args->zmgr); + if (zmgr != NULL) + dns_zonemgr_attach(zmgr, &args->zmgr); +} + +dns_zonemgr_t * +dns_dyndb_get_zonemgr(dns_dyndb_arguments_t *args) +{ + REQUIRE(args != NULL); + + return args->zmgr; +} + +void +dns_dyndb_set_task(dns_dyndb_arguments_t *args, isc_task_t *task) +{ + REQUIRE(args != NULL); + + if (args->task != NULL) + isc_task_detach(&args->task); + if (task != NULL) + isc_task_attach(task, &args->task); +} + +isc_task_t * +dns_dyndb_get_task(dns_dyndb_arguments_t *args) +{ + REQUIRE(args != NULL); + + return args->task; +} + +void +dns_dyndb_set_timermgr(dns_dyndb_arguments_t *args, isc_timermgr_t *timermgr) +{ + REQUIRE(args != NULL); + + args->timermgr = timermgr; +} + +isc_timermgr_t * +dns_dyndb_get_timermgr(dns_dyndb_arguments_t *args) +{ + REQUIRE(args != NULL); + + return args->timermgr; +} diff --git a/lib/dns/include/dns/dynamic_db.h b/lib/dns/include/dns/dynamic_db.h index 24147ea..12f7a06 100644 --- a/lib/dns/include/dns/dynamic_db.h +++ b/lib/dns/include/dns/dynamic_db.h @@ -22,10 +22,29 @@ #include +/* + * TODO: + * Reformat the prototypes. + * Add annotated comments. + */ + isc_result_t dns_dynamic_db_load(const char *libname, const char *name, isc_mem_t *mctx, const char * const *argv, - dns_view_t *view, dns_zonemgr_t *zmgr); + dns_dyndb_arguments_t *dyndb_args); void dns_dynamic_db_cleanup(void); +dns_dyndb_arguments_t *dns_dyndb_arguments_create(isc_mem_t *mctx); +void dns_dyndb_arguments_destroy(isc_mem_t *mctx, dns_dyndb_arguments_t *args); + +void dns_dyndb_set_view(dns_dyndb_arguments_t *args, dns_view_t *view); +dns_view_t *dns_dyndb_get_view(dns_dyndb_arguments_t *args); +void dns_dyndb_set_zonemgr(dns_dyndb_arguments_t *args, dns_zonemgr_t *zmgr); +dns_zonemgr_t *dns_dyndb_get_zonemgr(dns_dyndb_arguments_t *args); +void dns_dyndb_set_task(dns_dyndb_arguments_t *args, isc_task_t *task); +isc_task_t *dns_dyndb_get_task(dns_dyndb_arguments_t *args); +void dns_dyndb_set_timermgr(dns_dyndb_arguments_t *args, + isc_timermgr_t *timermgr); +isc_timermgr_t *dns_dyndb_get_timermgr(dns_dyndb_arguments_t *args); + #endif diff --git a/lib/dns/include/dns/types.h b/lib/dns/include/dns/types.h index 5223397..f434188 100644 --- a/lib/dns/include/dns/types.h +++ b/lib/dns/include/dns/types.h @@ -56,6 +56,7 @@ typedef struct dns_dbtable dns_dbtable_t; typedef void dns_dbversion_t; typedef struct dns_dlzimplementation dns_dlzimplementation_t; typedef struct dns_dlzdb dns_dlzdb_t; +typedef struct dns_dyndb_arguments dns_dyndb_arguments_t; typedef struct dns_sdlzimplementation dns_sdlzimplementation_t; typedef struct dns_decompress dns_decompress_t; typedef struct dns_dispatch dns_dispatch_t; -- cgit