diff options
Diffstat (limited to '')
| -rw-r--r-- | src/plugins.c | 653 |
1 files changed, 653 insertions, 0 deletions
diff --git a/src/plugins.c b/src/plugins.c new file mode 100644 index 0000000..5ff6616 --- /dev/null +++ b/src/plugins.c @@ -0,0 +1,653 @@ +/** + * @file plugins.c + * @author Radek Krejci <rkrejci@cesnet.cz> + * @brief Manipulate with the type and extension plugins. + * + * Copyright (c) 2021 CESNET, z.s.p.o. + * + * This source code is licensed under BSD 3-Clause License (the "License"). + * You may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * https://opensource.org/licenses/BSD-3-Clause + */ + +#define _GNU_SOURCE + +#include "plugins.h" +#include "plugins_internal.h" + +#include <assert.h> +#include <dirent.h> +#ifndef STATIC +# include <dlfcn.h> +#endif +#include <errno.h> +#include <limits.h> +#include <pthread.h> +#include <stddef.h> +#include <stdint.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +#include "ly_common.h" +#include "ly_config.h" +#include "plugins_exts.h" +#include "plugins_types.h" +#include "set.h" + +/* + * internal type plugins records + */ +extern const struct lyplg_type_record plugins_binary[]; +extern const struct lyplg_type_record plugins_bits[]; +extern const struct lyplg_type_record plugins_boolean[]; +extern const struct lyplg_type_record plugins_decimal64[]; +extern const struct lyplg_type_record plugins_empty[]; +extern const struct lyplg_type_record plugins_enumeration[]; +extern const struct lyplg_type_record plugins_identityref[]; +extern const struct lyplg_type_record plugins_instanceid[]; +extern const struct lyplg_type_record plugins_integer[]; +extern const struct lyplg_type_record plugins_leafref[]; +extern const struct lyplg_type_record plugins_string[]; +extern const struct lyplg_type_record plugins_union[]; + +/* + * yang + */ +extern const struct lyplg_type_record plugins_instanceid_keys[]; + +/* + * ietf-inet-types + */ +extern const struct lyplg_type_record plugins_ipv4_address[]; +extern const struct lyplg_type_record plugins_ipv4_address_no_zone[]; +extern const struct lyplg_type_record plugins_ipv6_address[]; +extern const struct lyplg_type_record plugins_ipv6_address_no_zone[]; +extern const struct lyplg_type_record plugins_ipv4_prefix[]; +extern const struct lyplg_type_record plugins_ipv6_prefix[]; + +/* + * ietf-yang-types + */ +extern const struct lyplg_type_record plugins_date_and_time[]; +extern const struct lyplg_type_record plugins_hex_string[]; +extern const struct lyplg_type_record plugins_xpath10[]; + +/* + * ietf-netconf-acm + */ +extern const struct lyplg_type_record plugins_node_instanceid[]; + +/* + * lyds_tree + */ +extern const struct lyplg_type_record plugins_lyds_tree[]; + +/* + * internal extension plugins records + */ +extern struct lyplg_ext_record plugins_metadata[]; +extern struct lyplg_ext_record plugins_nacm[]; +extern struct lyplg_ext_record plugins_yangdata[]; +extern struct lyplg_ext_record plugins_schema_mount[]; +extern struct lyplg_ext_record plugins_structure[]; + +static pthread_mutex_t plugins_guard = PTHREAD_MUTEX_INITIALIZER; + +/** + * @brief Counter for currently present contexts able to refer to the loaded plugins. + * + * Plugins are shared among all the created contexts. They are loaded with the creation of the very first context and + * unloaded with the destroy of the last context. Therefore, to reload the list of plugins, all the contexts must be + * destroyed and with the creation of a first new context after that, the plugins will be reloaded. + */ +static uint32_t context_refcount = 0; + +/** + * @brief Record describing an implemented extension. + * + * Matches ::lyplg_ext_record and ::lyplg_type_record + */ +struct lyplg_record { + const char *module; /**< name of the module where the extension/type is defined */ + const char *revision; /**< optional module revision - if not specified, the plugin applies to any revision, + which is not an optimal approach due to a possible future revisions of the module. + Instead, there should be defined multiple items in the plugins list, each with the + different revision, but all with the same pointer to the plugin functions. The + only valid use case for the NULL revision is the case the module has no revision. */ + const char *name; /**< name of the extension/typedef */ + int8_t plugin[]; /**< specific plugin type's data - ::lyplg_ext or ::lyplg_type */ +}; + +#ifndef STATIC +static struct ly_set plugins_handlers = {0}; +#endif +static struct ly_set plugins_types = {0}; +static struct ly_set plugins_extensions = {0}; + +/** + * @brief Iterate over list of loaded plugins of the given @p type. + * + * @param[in] ctx The context for which the plugin is searched for + * @param[in] type Type of the plugins to iterate. + * @param[in,out] index The iterator - set to 0 for the first call. + * @return The plugin records, NULL if no more record is available. + */ +static struct lyplg_record * +plugins_iter(const struct ly_ctx *ctx, enum LYPLG type, uint32_t *index) +{ + const struct ly_set *plugins; + + assert(index); + + if (type == LYPLG_EXTENSION) { + plugins = ctx ? &ctx->plugins_extensions : &plugins_extensions; + } else { + plugins = ctx ? &ctx->plugins_types : &plugins_types; + } + + if (*index == plugins->count) { + return NULL; + } + + *index += 1; + return plugins->objs[*index - 1]; +} + +static void * +lyplg_record_find(const struct ly_ctx *ctx, enum LYPLG type, const char *module, const char *revision, const char *name) +{ + uint32_t i = 0; + struct lyplg_record *item; + + assert(module); + assert(name); + + while ((item = plugins_iter(ctx, type, &i)) != NULL) { + if (!strcmp(item->module, module) && !strcmp(item->name, name)) { + if (item->revision && revision && strcmp(item->revision, revision)) { + continue; + } else if (!revision && item->revision) { + continue; + } + + return item; + } + } + + return NULL; +} + +struct lyplg_type * +lyplg_type_plugin_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name) +{ + struct lyplg_record *record = NULL; + + if (ctx) { + /* try to find context specific plugin */ + record = lyplg_record_find(ctx, LYPLG_TYPE, module, revision, name); + } + + if (!record) { + /* try to find shared plugin */ + record = lyplg_record_find(NULL, LYPLG_TYPE, module, revision, name); + } + + return record ? &((struct lyplg_type_record *)record)->plugin : NULL; +} + +struct lyplg_ext_record * +lyplg_ext_record_find(const struct ly_ctx *ctx, const char *module, const char *revision, const char *name) +{ + struct lyplg_ext_record *record = NULL; + + if (ctx) { + /* try to find context specific plugin */ + record = lyplg_record_find(ctx, LYPLG_EXTENSION, module, revision, name); + } + + if (!record) { + /* try to find shared plugin */ + record = lyplg_record_find(NULL, LYPLG_EXTENSION, module, revision, name); + } + + return record; +} + +/** + * @brief Insert the provided extension plugin records into the internal set of extension plugins for use by libyang. + * + * @param[in] ctx The context to which the plugin should be associated with. If NULL, the plugin is considered to be shared + * between all existing contexts. + * @param[in] type The type of plugins records + * @param[in] recs An array of plugin records provided by the plugin implementation. The array must be terminated by a zeroed + * record. + * @return LY_SUCCESS in case of success + * @return LY_EINVAL for invalid information in @p recs. + * @return LY_EMEM in case of memory allocation failure. + */ +static LY_ERR +plugins_insert(struct ly_ctx *ctx, enum LYPLG type, const void *recs) +{ + struct ly_set *plugins; + + if (!recs) { + return LY_SUCCESS; + } + + if (type == LYPLG_EXTENSION) { + const struct lyplg_ext_record *rec = (const struct lyplg_ext_record *)recs; + + plugins = ctx ? &ctx->plugins_extensions : &plugins_extensions; + + for (uint32_t i = 0; rec[i].name; i++) { + LY_CHECK_RET(ly_set_add(plugins, (void *)&rec[i], 0, NULL)); + } + } else { /* LYPLG_TYPE */ + const struct lyplg_type_record *rec = (const struct lyplg_type_record *)recs; + + plugins = ctx ? &ctx->plugins_types : &plugins_types; + + for (uint32_t i = 0; rec[i].name; i++) { + LY_CHECK_RET(ly_set_add(plugins, (void *)&rec[i], 0, NULL)); + } + } + + return LY_SUCCESS; +} + +#ifndef STATIC + +static void +lyplg_close_cb(void *handle) +{ + dlclose(handle); +} + +static void +lyplg_clean_(void) +{ + if (--context_refcount) { + /* there is still some other context, do not remove the plugins */ + return; + } + + ly_set_erase(&plugins_types, NULL); + ly_set_erase(&plugins_extensions, NULL); + ly_set_erase(&plugins_handlers, lyplg_close_cb); +} + +#endif + +void +lyplg_clean(void) +{ +#ifndef STATIC + pthread_mutex_lock(&plugins_guard); + lyplg_clean_(); + pthread_mutex_unlock(&plugins_guard); +#endif +} + +#ifndef STATIC + +/** + * @brief Just a variadic data to cover extension and type plugins by a single ::plugins_load() function. + * + * The values are taken from ::LY_PLUGINS_EXTENSIONS and ::LYPLG_TYPES macros. + */ +static const struct { + const char *id; /**< string identifier: type/extension */ + const char *apiver_var; /**< expected variable name holding API version value */ + const char *plugins_var; /**< expected variable name holding plugin records */ + const char *envdir; /**< environment variable containing directory with the plugins */ + const char *dir; /**< default directory with the plugins (has less priority than envdir) */ + uint32_t apiver; /**< expected API version */ +} plugins_load_info[] = { + { /* LYPLG_TYPE */ + .id = "type", + .apiver_var = "plugins_types_apiver__", + .plugins_var = "plugins_types__", + .envdir = "LIBYANG_TYPES_PLUGINS_DIR", + .dir = LYPLG_TYPE_DIR, + .apiver = LYPLG_TYPE_API_VERSION + }, {/* LYPLG_EXTENSION */ + .id = "extension", + .apiver_var = "plugins_extensions_apiver__", + .plugins_var = "plugins_extensions__", + .envdir = "LIBYANG_EXTENSIONS_PLUGINS_DIR", + .dir = LYPLG_EXT_DIR, + .apiver = LYPLG_EXT_API_VERSION + } +}; + +/** + * @brief Get the expected plugin objects from the loaded dynamic object and add the defined plugins into the lists of + * available extensions/types plugins. + * + * @param[in] dlhandler Loaded dynamic library handler. + * @param[in] pathname Path of the loaded library for logging. + * @param[in] type Type of the plugins to get from the dynamic library. Note that a single library can hold both types + * and extensions plugins implementations, so this function should be called twice (once for each plugin type) with + * different @p type values + * @return LY_ERR values. + */ +static LY_ERR +plugins_load(void *dlhandler, const char *pathname, enum LYPLG type) +{ + const void *plugins; + uint32_t *version; + + /* type plugin */ + version = dlsym(dlhandler, plugins_load_info[type].apiver_var); + if (version) { + /* check version ... */ + if (*version != plugins_load_info[type].apiver) { + LOGERR(NULL, LY_EINVAL, "Processing user %s plugin \"%s\" failed, wrong API version - %d expected, %d found.", + plugins_load_info[type].id, pathname, plugins_load_info[type].apiver, *version); + return LY_EINVAL; + } + + /* ... get types plugins information ... */ + if (!(plugins = dlsym(dlhandler, plugins_load_info[type].plugins_var))) { + char *errstr = dlerror(); + + LOGERR(NULL, LY_EINVAL, "Processing user %s plugin \"%s\" failed, missing %s plugins information (%s).", + plugins_load_info[type].id, pathname, plugins_load_info[type].id, errstr); + return LY_EINVAL; + } + + /* ... and load all the types plugins */ + LY_CHECK_RET(plugins_insert(NULL, type, plugins)); + } + + return LY_SUCCESS; +} + +static LY_ERR +plugins_load_module(const char *pathname) +{ + LY_ERR ret = LY_SUCCESS; + void *dlhandler; + uint32_t types_count = 0, extensions_count = 0; + + dlerror(); /* Clear any existing error */ + + dlhandler = dlopen(pathname, RTLD_NOW); + if (!dlhandler) { + LOGERR(NULL, LY_ESYS, "Loading \"%s\" as a plugin failed (%s).", pathname, dlerror()); + return LY_ESYS; + } + + if (ly_set_contains(&plugins_handlers, dlhandler, NULL)) { + /* the plugin is already loaded */ + LOGVRB("Plugin \"%s\" already loaded.", pathname); + + /* keep the correct refcount */ + dlclose(dlhandler); + return LY_SUCCESS; + } + + /* remember the current plugins lists for recovery */ + types_count = plugins_types.count; + extensions_count = plugins_extensions.count; + + /* type plugin */ + ret = plugins_load(dlhandler, pathname, LYPLG_TYPE); + LY_CHECK_GOTO(ret, error); + + /* extension plugin */ + ret = plugins_load(dlhandler, pathname, LYPLG_EXTENSION); + LY_CHECK_GOTO(ret, error); + + /* remember the dynamic plugin */ + ret = ly_set_add(&plugins_handlers, dlhandler, 1, NULL); + LY_CHECK_GOTO(ret, error); + + return LY_SUCCESS; + +error: + dlclose(dlhandler); + + /* revert changes in the lists */ + while (plugins_types.count > types_count) { + ly_set_rm_index(&plugins_types, plugins_types.count - 1, NULL); + } + while (plugins_extensions.count > extensions_count) { + ly_set_rm_index(&plugins_extensions, plugins_extensions.count - 1, NULL); + } + + return ret; +} + +static LY_ERR +plugins_insert_dir(enum LYPLG type) +{ + LY_ERR ret = LY_SUCCESS; + const char *pluginsdir; + DIR *dir; + ly_bool default_dir = 0; + + /* try to get the plugins directory from environment variable */ + pluginsdir = getenv(plugins_load_info[type].envdir); + if (!pluginsdir) { + /* remember that we are going to a default dir and do not print warning if the directory doesn't exist */ + default_dir = 1; + pluginsdir = plugins_load_info[type].dir; + } + + dir = opendir(pluginsdir); + if (!dir) { + /* no directory (or no access to it), no extension plugins */ + if (!default_dir || (errno != ENOENT)) { + LOGWRN(NULL, "Failed to open libyang %s plugins directory \"%s\" (%s).", plugins_load_info[type].id, + pluginsdir, strerror(errno)); + } + } else { + struct dirent *file; + + while ((file = readdir(dir))) { + size_t len; + char pathname[PATH_MAX]; + + /* required format of the filename is *LYPLG_SUFFIX */ + len = strlen(file->d_name); + if ((len < LYPLG_SUFFIX_LEN + 1) || strcmp(&file->d_name[len - LYPLG_SUFFIX_LEN], LYPLG_SUFFIX)) { + continue; + } + + /* and construct the filepath */ + snprintf(pathname, PATH_MAX, "%s/%s", pluginsdir, file->d_name); + + ret = plugins_load_module(pathname); + if (ret) { + break; + } + } + closedir(dir); + } + + return ret; +} + +#endif + +LY_ERR +lyplg_init(ly_bool builtin_type_plugins_only) +{ + LY_ERR ret; + + pthread_mutex_lock(&plugins_guard); + /* let only the first context to initiate plugins, but let others wait for finishing the initiation */ + if (context_refcount++) { + /* already initiated */ + pthread_mutex_unlock(&plugins_guard); + return LY_SUCCESS; + } + + /* internal types */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_binary), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_bits), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_boolean), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_decimal64), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_empty), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_enumeration), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_identityref), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_instanceid), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_integer), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_leafref), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_string), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_union), error); + + /* metadata and lyds_tree, which requires them */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_metadata), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_lyds_tree), error); + + if (!builtin_type_plugins_only) { + /* yang */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_instanceid_keys), error); + + /* ietf-inet-types */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_ipv4_address), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_ipv4_address_no_zone), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_ipv6_address), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_ipv6_address_no_zone), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_ipv4_prefix), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_ipv6_prefix), error); + + /* ietf-yang-types */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_date_and_time), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_hex_string), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_xpath10), error); + + /* ietf-netconf-acm */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_TYPE, plugins_node_instanceid), error); + + /* internal extensions */ + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_nacm), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_yangdata), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_schema_mount), error); + LY_CHECK_GOTO(ret = plugins_insert(NULL, LYPLG_EXTENSION, plugins_structure), error); + } + +#ifndef STATIC + /* external types */ + LY_CHECK_GOTO(ret = plugins_insert_dir(LYPLG_TYPE), error); + + /* external extensions */ + LY_CHECK_GOTO(ret = plugins_insert_dir(LYPLG_EXTENSION), error); +#endif + + /* initiation done, wake-up possibly waiting threads creating another contexts */ + pthread_mutex_unlock(&plugins_guard); + + return LY_SUCCESS; + +error: + /* initiation was not successful - cleanup (and let others to try) */ +#ifndef STATIC + lyplg_clean_(); +#endif + pthread_mutex_unlock(&plugins_guard); + + if (ret == LY_EINVAL) { + /* all the plugins here are internal, invalid record actually means an internal libyang error */ + ret = LY_EINT; + } + return ret; +} + +LIBYANG_API_DEF LY_ERR +lyplg_add(const char *pathname) +{ +#ifdef STATIC + (void)pathname; + + LOGERR(NULL, LY_EINVAL, "Plugins are not supported in statically built library."); + return LY_EINVAL; +#elif defined (_WIN32) + (void)pathname; + + LOGERR(NULL, LY_EINVAL, "Plugins are not (yet) supported on Windows."); + return LY_EINVAL; +#else + LY_ERR ret = LY_SUCCESS; + + LY_CHECK_ARG_RET(NULL, pathname, LY_EINVAL); + + /* works only in case a context exists */ + pthread_mutex_lock(&plugins_guard); + if (!context_refcount) { + /* no context */ + pthread_mutex_unlock(&plugins_guard); + LOGERR(NULL, LY_EDENIED, "To add a plugin, at least one context must exists."); + return LY_EDENIED; + } + + ret = plugins_load_module(pathname); + + pthread_mutex_unlock(&plugins_guard); + + return ret; +#endif +} + +/** + * @brief Manually load an extension plugins from memory + * + * Note, that a plugin can be loaded only if there is at least one context. The loaded plugins are connected with the + * existence of a context. When all the contexts are destroyed, all the plugins are unloaded. + * + * @param[in] ctx The context to which the plugin should be associated with. If NULL, the plugin is considered to be shared + * between all existing contexts. + * @param[in] version The version of plugin records. + * @param[in] type The type of plugins records. + * @param[in] recs An array of plugin records provided by the plugin implementation. The array must be terminated by a zeroed + * record. + * + * @return LY_SUCCESS if the plugins with compatible version were successfully loaded. + * @return LY_EDENIED in case there is no context and the plugin cannot be loaded. + * @return LY_EINVAL when recs is NULL or the plugin contains invalid content for this libyang version. + */ +static LY_ERR +lyplg_add_plugin(struct ly_ctx *ctx, uint32_t version, enum LYPLG type, const void *recs) +{ + LY_ERR ret = LY_SUCCESS; + uint32_t cur_ver = (type == LYPLG_TYPE) ? LYPLG_TYPE_API_VERSION : LYPLG_EXT_API_VERSION; + + LY_CHECK_ARG_RET(NULL, recs, LY_EINVAL); + + if (version != cur_ver) { + LOGERR(ctx, LY_EINVAL, "Adding user %s plugin failed, wrong API version - %" PRIu32 " expected, %" PRIu32 " found.", + (type == LYPLG_TYPE) ? "type" : "extension", cur_ver, version); + return LY_EINVAL; + } + + /* works only in case a context exists */ + pthread_mutex_lock(&plugins_guard); + if (!context_refcount) { + /* no context */ + pthread_mutex_unlock(&plugins_guard); + LOGERR(NULL, LY_EDENIED, "To add a plugin, at least one context must exists."); + return LY_EDENIED; + } + + ret = plugins_insert(ctx, type, recs); + pthread_mutex_unlock(&plugins_guard); + + return ret; +} + +LIBYANG_API_DEF LY_ERR +lyplg_add_extension_plugin(struct ly_ctx *ctx, uint32_t version, const struct lyplg_ext_record *recs) +{ + return lyplg_add_plugin(ctx, version, LYPLG_EXTENSION, recs); +} + +LIBYANG_API_DEF LY_ERR +lyplg_add_type_plugin(struct ly_ctx *ctx, uint32_t version, const struct lyplg_type_record *recs) +{ + return lyplg_add_plugin(ctx, version, LYPLG_TYPE, recs); +} |