mir/bind
2
0
Fork 0
mirror of https://gitlab.isc.org/isc-projects/bind9 synced 2025-08-23 02:28:55 +00:00
Code Issues Releases Wiki Activity
bind/lib/ns/hooks.c

361 lines
8.6 KiB
C
Raw Normal View History

set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
/*
* 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
update all copyright headers to eliminate the typo
2020-09-14 16:20:40 -07:00
* file, you can obtain one at https://mozilla.org/MPL/2.0/.
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
*
* See the COPYRIGHT file distributed with this work for additional
* information regarding copyright ownership.
*/
/*! \file */
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
#include <errno.h>
#include <stdio.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
#include <string.h>
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
#include <uv.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
#include <isc/errno.h>
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
#include <isc/list.h>
#include <isc/log.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
#include <isc/mem.h>
#include <isc/mutex.h>
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
#include <isc/print.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
#include <isc/result.h>
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
#include <isc/types.h>
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#include <isc/util.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
restore filter-aaaa syntax checking - added functionality to check hook parameters in named-checkconf, and restored the checkconf tests that were removed from the filter-aaaa test.
2018-11-02 23:28:25 -07:00
#include <dns/view.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
#include <ns/hooks.h>
#include <ns/log.h>
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
#include <ns/query.h>
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
#define CHECK(op) \
do { \
result = (op); \
if (result != ISC_R_SUCCESS) { \
goto cleanup; \
} \
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
} while (0)
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
struct ns_plugin {
apply the modified style
2020-02-13 14:44:37 -08:00
isc_mem_t *mctx;
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
uv_lib_t handle;
apply the modified style
2020-02-13 14:44:37 -08:00
void *inst;
char *modpath;
ns_plugin_check_t *check_func;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
ns_plugin_register_t *register_func;
apply the modified style
2020-02-13 14:44:37 -08:00
ns_plugin_destroy_t *destroy_func;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
LINK(ns_plugin_t) link;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
};
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
static ns_hooklist_t default_hooktable[NS_HOOKPOINTS_COUNT];
Remove LIB<*>_EXTERNAL_DATA defines After Windows has been removed, the LIB<*>_EXTERNAL_DATA defines were just dummy leftovers. Remove them.
2021-06-10 08:06:48 +02:00
ns_hooktable_t *ns__hook_table = &default_hooktable;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
isc_result_t
apply the modified style
2020-02-13 14:44:37 -08:00
ns_plugin_expandpath(const char *src, char *dst, size_t dstsize) {
Add ns_plugin_expandpath() Implement a helper function which, given an input string: - copies it verbatim if it contains at least one path separator, - prepends the named plugin installation directory to it otherwise. This function will allow configuration parsing code to conveniently determine the full path to a plugin module given either a path or a filename. While other, simpler ways exist for making sure filenames passed to dlopen() cause the latter to look for shared objects in a specific directory, they are very platform-specific. Using full paths is thus likely the most portable and reliable solution. Also added unit tests for ns_plugin_expandpath() to ensure it behaves as expected for absolute paths, relative paths, and filenames, for various target buffer sizes. (Note: plugins share a directory with named on Windows; there is no default plugin path. Therefore the source path is copied to the destination path with no modification.)
2019-02-12 15:59:54 +01:00
int result;
/*
* On Unix systems, differentiate between paths and filenames.
*/
if (strchr(src, '/') != NULL) {
/*
* 'src' is an absolute or relative path. Copy it verbatim.
*/
result = snprintf(dst, dstsize, "%s", src);
} else {
/*
* 'src' is a filename. Prepend default plugin directory path.
*/
result = snprintf(dst, dstsize, "%s/%s", NAMED_PLUGINDIR, src);
}
if (result < 0) {
return (isc_errno_toresult(errno));
} else if ((size_t)result >= dstsize) {
return (ISC_R_NOSPACE);
} else {
return (ISC_R_SUCCESS);
}
}
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
static isc_result_t
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
load_symbol(uv_lib_t *handle, const char *modpath, const char *symbol_name,
apply the modified style
2020-02-13 14:44:37 -08:00
void **symbolp) {
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
void *symbol = NULL;
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
int r;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
REQUIRE(handle != NULL);
REQUIRE(symbolp != NULL && *symbolp == NULL);
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
r = uv_dlsym(handle, symbol_name, &symbol);
if (r != 0) {
const char *errmsg = uv_dlerror(handle);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
if (errmsg == NULL) {
errmsg = "returned function pointer is NULL";
}
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL,
NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
"failed to look up symbol %s in "
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
"plugin '%s': %s",
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
symbol_name, modpath, errmsg);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
return (ISC_R_FAILURE);
}
*symbolp = symbol;
return (ISC_R_SUCCESS);
}
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
static void
unload_plugin(ns_plugin_t **pluginp);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
static isc_result_t
apply the modified style
2020-02-13 14:44:37 -08:00
load_plugin(isc_mem_t *mctx, const char *modpath, ns_plugin_t **pluginp) {
isc_result_t result;
ns_plugin_t *plugin = NULL;
ns_plugin_version_t *version_func = NULL;
Complete rewrite the BIND 9 build system The rewrite of BIND 9 build system is a large work and cannot be reasonable split into separate merge requests. Addition of the automake has a positive effect on the readability and maintainability of the build system as it is more declarative, it allows conditional and we are able to drop all of the custom make code that BIND 9 developed over the years to overcome the deficiencies of autoconf + custom Makefile.in files. This squashed commit contains following changes: - conversion (or rather fresh rewrite) of all Makefile.in files to Makefile.am by using automake - the libtool is now properly integrated with automake (the way we used it was rather hackish as the only official way how to use libtool is via automake - the dynamic module loading was rewritten from a custom patchwork to libtool's libltdl (which includes the patchwork to support module loading on different systems internally) - conversion of the unit test executor from kyua to automake parallel driver - conversion of the system test executor from custom make/shell to automake parallel driver - The GSSAPI has been refactored, the custom SPNEGO on the basis that all major KRB5/GSSAPI (mit-krb5, heimdal and Windows) implementations support SPNEGO mechanism. - The various defunct tests from bin/tests have been removed: bin/tests/optional and bin/tests/pkcs11 - The text files generated from the MD files have been removed, the MarkDown has been designed to be readable by both humans and computers - The xsl header is now generated by a simple sed command instead of perl helper - The <irs/platform.h> header has been removed - cleanups of configure.ac script to make it more simpler, addition of multiple macros (there's still work to be done though) - the tarball can now be prepared with `make dist` - the system tests are partially able to run in oot build Here's a list of unfinished work that needs to be completed in subsequent merge requests: - `make distcheck` doesn't yet work (because of system tests oot run is not yet finished) - documentation is not yet built, there's a different merge request with docbook to sphinx-build rst conversion that needs to be rebased and adapted on top of the automake - msvc build is non functional yet and we need to decide whether we will just cross-compile bind9 using mingw-w64 or fix the msvc build - contributed dlz modules are not included neither in the autoconf nor automake
2018-08-07 16:46:53 +02:00
int version;
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
int r;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
REQUIRE(pluginp != NULL && *pluginp == NULL);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
plugin = isc_mem_get(mctx, sizeof(*plugin));
memset(plugin, 0, sizeof(*plugin));
isc_mem_attach(mctx, &plugin->mctx);
plugin->modpath = isc_mem_strdup(plugin->mctx, modpath);
ISC_LINK_INIT(plugin, link);
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
r = uv_dlopen(modpath, &plugin->handle);
if (r != 0) {
const char *errmsg = uv_dlerror(&plugin->handle);
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
if (errmsg == NULL) {
errmsg = "unknown error";
}
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL,
NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
"failed to dlopen() plugin '%s': %s", modpath,
errmsg);
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
CHECK(ISC_R_FAILURE);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
}
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
CHECK(load_symbol(&plugin->handle, modpath, "plugin_version",
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
(void **)&version_func));
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
version = version_func();
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
if (version < (NS_PLUGIN_VERSION - NS_PLUGIN_AGE) ||
apply the modified style
2020-02-13 14:44:37 -08:00
version > NS_PLUGIN_VERSION)
{
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL,
NS_LOGMODULE_HOOKS, ISC_LOG_ERROR,
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
"plugin API version mismatch: %d/%d", version,
NS_PLUGIN_VERSION);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
CHECK(ISC_R_FAILURE);
}
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
CHECK(load_symbol(&plugin->handle, modpath, "plugin_check",
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
(void **)&plugin->check_func));
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
CHECK(load_symbol(&plugin->handle, modpath, "plugin_register",
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
(void **)&plugin->register_func));
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
CHECK(load_symbol(&plugin->handle, modpath, "plugin_destroy",
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
(void **)&plugin->destroy_func));
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
*pluginp = plugin;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
return (ISC_R_SUCCESS);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
cleanup:
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
ISC_LOG_ERROR,
"failed to dynamically load plugin '%s': %s", modpath,
isc_result_totext(result));
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
unload_plugin(&plugin);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
return (result);
}
static void
apply the modified style
2020-02-13 14:44:37 -08:00
unload_plugin(ns_plugin_t **pluginp) {
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
ns_plugin_t *plugin = NULL;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
REQUIRE(pluginp != NULL && *pluginp != NULL);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
plugin = *pluginp;
*pluginp = NULL;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
ISC_LOG_DEBUG(1), "unloading plugin '%s'",
plugin->modpath);
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
if (plugin->inst != NULL) {
plugin->destroy_func(&plugin->inst);
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
}
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
Use libuv's shared library handling capabilities While libltdl is a feature-rich library, BIND 9 code only uses its basic capabilities, which are also provided by libuv and which BIND 9 already uses for other purposes. As libuv's cross-platform shared library handling interface is modeled after the POSIX dlopen() interface, converting code using the latter to the former is simple. Replace libltdl function calls with their libuv counterparts, refactoring the code as necessary. Remove all use of libltdl from the BIND 9 source tree.
2020-10-20 23:51:08 +02:00
uv_dlclose(&plugin->handle);
Refactor the cleanup code in lt_dl code The cleanup code that would clean the object after plugin/dlz/dyndb loading has failed was duplicating the destructor for the object, so instead of the extra code, we just use the destructor instead.
2020-10-20 23:51:08 +02:00
isc_mem_free(plugin->mctx, plugin->modpath);
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
isc_mem_putanddetach(&plugin->mctx, plugin, sizeof(*plugin));
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
}
isc_result_t
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
ns_plugin_register(const char *modpath, const char *parameters, const void *cfg,
const char *cfg_file, unsigned long cfg_line,
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
isc_mem_t *mctx, isc_log_t *lctx, void *actx,
apply the modified style
2020-02-13 14:44:37 -08:00
dns_view_t *view) {
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
isc_result_t result;
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
ns_plugin_t *plugin = NULL;
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
eliminate ns_hookctx structure, pass mctx/lctx/view directly
2018-11-30 10:12:04 -08:00
REQUIRE(mctx != NULL);
REQUIRE(lctx != NULL);
REQUIRE(view != NULL);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
ISC_LOG_INFO, "loading plugin '%s'", modpath);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
CHECK(load_plugin(mctx, modpath, &plugin));
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_log_write(ns_lctx, NS_LOGCATEGORY_GENERAL, NS_LOGMODULE_HOOKS,
ISC_LOG_INFO, "registering plugin '%s'", modpath);
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
CHECK(plugin->register_func(parameters, cfg, cfg_file, cfg_line, mctx,
lctx, actx, view->hooktable,
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
&plugin->inst));
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
ISC_LIST_APPEND(*(ns_plugins_t *)view->plugins, plugin, link);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
cleanup:
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
if (result != ISC_R_SUCCESS && plugin != NULL) {
unload_plugin(&plugin);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
}
return (result);
}
initial implementation of filter-aaaa.so as a shared object - temporary kluge! in this version, for testing purposes, named always searches for a filter-aaaa module at /tmp/filter-aaaa.so. this enables the filter-aaaa system test to run even though the code to configure hooks in named.conf hasn't been written yet. - filter-aaaa-on-v4, filter-aaaa-on-v6 and the filter-aaaa ACL are still configured in the view as they were before, not in the hook.
2018-08-10 19:32:12 -07:00
isc_result_t
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
ns_plugin_check(const char *modpath, const char *parameters, const void *cfg,
const char *cfg_file, unsigned long cfg_line, isc_mem_t *mctx,
apply the modified style
2020-02-13 14:44:37 -08:00
isc_log_t *lctx, void *actx) {
restore filter-aaaa syntax checking - added functionality to check hook parameters in named-checkconf, and restored the checkconf tests that were removed from the filter-aaaa test.
2018-11-02 23:28:25 -07:00
isc_result_t result;
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
ns_plugin_t *plugin = NULL;
restore filter-aaaa syntax checking - added functionality to check hook parameters in named-checkconf, and restored the checkconf tests that were removed from the filter-aaaa test.
2018-11-02 23:28:25 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
CHECK(load_plugin(mctx, modpath, &plugin));
restore filter-aaaa syntax checking - added functionality to check hook parameters in named-checkconf, and restored the checkconf tests that were removed from the filter-aaaa test.
2018-11-02 23:28:25 -07:00
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
result = plugin->check_func(parameters, cfg, cfg_file, cfg_line, mctx,
lctx, actx);
restore filter-aaaa syntax checking - added functionality to check hook parameters in named-checkconf, and restored the checkconf tests that were removed from the filter-aaaa test.
2018-11-02 23:28:25 -07:00
cleanup:
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
if (plugin != NULL) {
unload_plugin(&plugin);
restore filter-aaaa syntax checking - added functionality to check hook parameters in named-checkconf, and restored the checkconf tests that were removed from the filter-aaaa test.
2018-11-02 23:28:25 -07:00
}
return (result);
}
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
void
apply the modified style
2020-02-13 14:44:37 -08:00
ns_hooktable_init(ns_hooktable_t *hooktable) {
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
int i;
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
for (i = 0; i < NS_HOOKPOINTS_COUNT; i++) {
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
ISC_LIST_INIT((*hooktable)[i]);
}
}
add hook statement to configuration parser - allow multiple "hook" statements at global or view level - add "optional bracketed text" type for optional parameter list - load hook module from specified path rather than hardcoded path - add a hooktable pointer (and a callback for freeing it) to the view structure - change the hooktable functions so they no longer update ns__hook_table by default, and modify PROCESS_HOOK so it uses the view hooktable, if set, rather than ns__hook_table. (ns__hook_table is retained for use by unit tests.) - update the filter-aaaa system test to load filter-aaaa.so - add a prereq script to check for dlopen support before running the filter-aaaa system test not yet done: - configuration parameters are not being passed to the filter-aaaa module; the filter-aaaa ACL and filter-aaaa-on-{v4,v6} settings are still stored in dns_view
2018-08-12 11:19:36 -07:00
isc_result_t
apply the modified style
2020-02-13 14:44:37 -08:00
ns_hooktable_create(isc_mem_t *mctx, ns_hooktable_t **tablep) {
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
ns_hooktable_t *hooktable = NULL;
add hook statement to configuration parser - allow multiple "hook" statements at global or view level - add "optional bracketed text" type for optional parameter list - load hook module from specified path rather than hardcoded path - add a hooktable pointer (and a callback for freeing it) to the view structure - change the hooktable functions so they no longer update ns__hook_table by default, and modify PROCESS_HOOK so it uses the view hooktable, if set, rather than ns__hook_table. (ns__hook_table is retained for use by unit tests.) - update the filter-aaaa system test to load filter-aaaa.so - add a prereq script to check for dlopen support before running the filter-aaaa system test not yet done: - configuration parameters are not being passed to the filter-aaaa module; the filter-aaaa ACL and filter-aaaa-on-{v4,v6} settings are still stored in dns_view
2018-08-12 11:19:36 -07:00
REQUIRE(tablep != NULL && *tablep == NULL);
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
hooktable = isc_mem_get(mctx, sizeof(*hooktable));
add hook statement to configuration parser - allow multiple "hook" statements at global or view level - add "optional bracketed text" type for optional parameter list - load hook module from specified path rather than hardcoded path - add a hooktable pointer (and a callback for freeing it) to the view structure - change the hooktable functions so they no longer update ns__hook_table by default, and modify PROCESS_HOOK so it uses the view hooktable, if set, rather than ns__hook_table. (ns__hook_table is retained for use by unit tests.) - update the filter-aaaa system test to load filter-aaaa.so - add a prereq script to check for dlopen support before running the filter-aaaa system test not yet done: - configuration parameters are not being passed to the filter-aaaa module; the filter-aaaa ACL and filter-aaaa-on-{v4,v6} settings are still stored in dns_view
2018-08-12 11:19:36 -07:00
ns_hooktable_init(hooktable);
*tablep = hooktable;
return (ISC_R_SUCCESS);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
}
void
apply the modified style
2020-02-13 14:44:37 -08:00
ns_hooktable_free(isc_mem_t *mctx, void **tablep) {
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
ns_hooktable_t *table = NULL;
apply the modified style
2020-02-13 14:44:37 -08:00
ns_hook_t *hook = NULL, *next = NULL;
int i = 0;
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
add hook statement to configuration parser - allow multiple "hook" statements at global or view level - add "optional bracketed text" type for optional parameter list - load hook module from specified path rather than hardcoded path - add a hooktable pointer (and a callback for freeing it) to the view structure - change the hooktable functions so they no longer update ns__hook_table by default, and modify PROCESS_HOOK so it uses the view hooktable, if set, rather than ns__hook_table. (ns__hook_table is retained for use by unit tests.) - update the filter-aaaa system test to load filter-aaaa.so - add a prereq script to check for dlopen support before running the filter-aaaa system test not yet done: - configuration parameters are not being passed to the filter-aaaa module; the filter-aaaa ACL and filter-aaaa-on-{v4,v6} settings are still stored in dns_view
2018-08-12 11:19:36 -07:00
REQUIRE(tablep != NULL && *tablep != NULL);
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
table = *tablep;
add hook statement to configuration parser - allow multiple "hook" statements at global or view level - add "optional bracketed text" type for optional parameter list - load hook module from specified path rather than hardcoded path - add a hooktable pointer (and a callback for freeing it) to the view structure - change the hooktable functions so they no longer update ns__hook_table by default, and modify PROCESS_HOOK so it uses the view hooktable, if set, rather than ns__hook_table. (ns__hook_table is retained for use by unit tests.) - update the filter-aaaa system test to load filter-aaaa.so - add a prereq script to check for dlopen support before running the filter-aaaa system test not yet done: - configuration parameters are not being passed to the filter-aaaa module; the filter-aaaa ACL and filter-aaaa-on-{v4,v6} settings are still stored in dns_view
2018-08-12 11:19:36 -07:00
*tablep = NULL;
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
for (i = 0; i < NS_HOOKPOINTS_COUNT; i++) {
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
for (hook = ISC_LIST_HEAD((*table)[i]); hook != NULL;
hook = next) {
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
next = ISC_LIST_NEXT(hook, link);
ISC_LIST_UNLINK((*table)[i], hook, link);
if (hook->mctx != NULL) {
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
isc_mem_putanddetach(&hook->mctx, hook,
sizeof(*hook));
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
}
}
}
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
isc_mem_put(mctx, table, sizeof(*table));
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
}
void
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
ns_hook_add(ns_hooktable_t *hooktable, isc_mem_t *mctx,
apply the modified style
2020-02-13 14:44:37 -08:00
ns_hookpoint_t hookpoint, const ns_hook_t *hook) {
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
ns_hook_t *copy = NULL;
REQUIRE(hooktable != NULL);
REQUIRE(mctx != NULL);
clear AD flag when altering response messages - the AD flag was not being cleared correctly when filtering - enabled dnssec valdiation in the filter-aaaa test to confirm this works correctly now
2018-09-14 12:32:36 -07:00
REQUIRE(hookpoint < NS_HOOKPOINTS_COUNT);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
REQUIRE(hook != NULL);
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
copy = isc_mem_get(mctx, sizeof(*copy));
memset(copy, 0, sizeof(*copy));
copy->action = hook->action;
copy->action_data = hook->action_data;
isc_mem_attach(mctx, &copy->mctx);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
copy ns_hook objects before adding them to a hook table - this is necessary because adding the same hook to multiple views causes the ISC_LIST link value to become inconsistent; it isn't noticeable when only one hook action is ever registered at a given hook point, but it will break things when there are two.
2018-09-19 23:38:23 -07:00
ISC_LINK_INIT(copy, link);
ISC_LIST_APPEND((*hooktable)[hookpoint], copy, link);
set up hooks.c to enable setting hook points and loading modules - move hooks.h to public include directory - ns_hooktable_init() initializes a hook table. if NULL is passed in, it initializes the global hook table - ns_hooktable_save() saves a pointer to the current global hook table. - ns_hooktable_reset() replaces the global hook table with different one - ns_hook_add() adds hooks at specified hook points in a hook table (or the global hook table if the specified table is NULL) - load and unload functions support dlopen() of hook modules (this is adapted from dyndb and not yet functional) - began adding new hook points to query.c
2018-08-03 14:16:41 -07:00
}
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
void
apply the modified style
2020-02-13 14:44:37 -08:00
ns_plugins_create(isc_mem_t *mctx, ns_plugins_t **listp) {
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
ns_plugins_t *plugins = NULL;
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
REQUIRE(listp != NULL && *listp == NULL);
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
plugins = isc_mem_get(mctx, sizeof(*plugins));
memset(plugins, 0, sizeof(*plugins));
ISC_LIST_INIT(*plugins);
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
*listp = plugins;
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
}
void
apply the modified style
2020-02-13 14:44:37 -08:00
ns_plugins_free(isc_mem_t *mctx, void **listp) {
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
ns_plugins_t *list = NULL;
apply the modified style
2020-02-13 14:44:37 -08:00
ns_plugin_t *plugin = NULL, *next = NULL;
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
REQUIRE(listp != NULL && *listp != NULL);
list = *listp;
*listp = NULL;
Use clang-format to reformat the source files
2020-02-12 13:59:18 +01:00
for (plugin = ISC_LIST_HEAD(*list); plugin != NULL; plugin = next) {
name change from "hook modules" to "plugins" - "hook" is now used only for hook points and hook actions - the "hook" statement in named.conf is now "plugin" - ns_module and ns_modlist are now ns_plugin and ns_plugins - ns_module_load is renamed ns_plugin_register - the mandatory functions in plugin modules (hook_register, hook_check, hook_version, hook_destroy) have been renamed
2018-11-30 15:32:03 -08:00
next = ISC_LIST_NEXT(plugin, link);
ISC_LIST_UNLINK(*list, plugin, link);
unload_plugin(&plugin);
refactor to support multiple module instances - use a per-view module list instead of global hook_modules - create an 'instance' pointer when registering modules, store it in the module structure, and use it as action_data when calling hook functions - this enables multiple module instances to be set up in parallel - also some nomenclature changes and cleanup
2018-10-31 19:02:29 -07:00
}
isc_mem_put(mctx, list, sizeof(*list));
}
Reference in New Issue Copy Permalink