// SPDX-License-Identifier: GPL-2.0-or-later /* * Copyright (C) 2018 NetDEF, Inc. * Renato Westphal */ #include #include "log.h" #include "lib_errors.h" #include "hash.h" #include "yang.h" #include "yang_translator.h" #include "frrstr.h" DEFINE_MTYPE_STATIC(LIB, YANG_TRANSLATOR, "YANG Translator"); DEFINE_MTYPE_STATIC(LIB, YANG_TRANSLATOR_MODULE, "YANG Translator Module"); DEFINE_MTYPE_STATIC(LIB, YANG_TRANSLATOR_MAPPING, "YANG Translator Mapping"); /* Generate the yang_translators tree. */ static inline int yang_translator_compare(const struct yang_translator *a, const struct yang_translator *b) { return strcmp(a->family, b->family); } RB_GENERATE(yang_translators, yang_translator, entry, yang_translator_compare) struct yang_translators yang_translators = RB_INITIALIZER(&yang_translators); /* Separate libyang context for the translator module. */ static struct ly_ctx *ly_translator_ctx; static unsigned int yang_translator_validate(struct yang_translator *translator); static unsigned int yang_module_nodes_count(const struct lys_module *module); struct yang_mapping_node { char xpath_from_canonical[XPATH_MAXLEN]; char xpath_from_fmt[XPATH_MAXLEN]; char xpath_to_fmt[XPATH_MAXLEN]; }; static bool yang_mapping_hash_cmp(const void *value1, const void *value2) { const struct yang_mapping_node *c1 = value1; const struct yang_mapping_node *c2 = value2; return strmatch(c1->xpath_from_canonical, c2->xpath_from_canonical); } static unsigned int yang_mapping_hash_key(const void *value) { return string_hash_make(value); } static void *yang_mapping_hash_alloc(void *p) { struct yang_mapping_node *new, *key = p; new = XCALLOC(MTYPE_YANG_TRANSLATOR_MAPPING, sizeof(*new)); strlcpy(new->xpath_from_canonical, key->xpath_from_canonical, sizeof(new->xpath_from_canonical)); return new; } static void yang_mapping_hash_free(void *arg) { XFREE(MTYPE_YANG_TRANSLATOR_MAPPING, arg); } static struct yang_mapping_node * yang_mapping_lookup(const struct yang_translator *translator, int dir, const char *xpath) { struct yang_mapping_node s; strlcpy(s.xpath_from_canonical, xpath, sizeof(s.xpath_from_canonical)); return hash_lookup(translator->mappings[dir], &s); } static void yang_mapping_add(struct yang_translator *translator, int dir, const struct lysc_node *snode, const char *xpath_from_fmt, const char *xpath_to_fmt) { struct yang_mapping_node *mapping, s; yang_snode_get_path(snode, YANG_PATH_DATA, s.xpath_from_canonical, sizeof(s.xpath_from_canonical)); mapping = hash_get(translator->mappings[dir], &s, yang_mapping_hash_alloc); strlcpy(mapping->xpath_from_fmt, xpath_from_fmt, sizeof(mapping->xpath_from_fmt)); strlcpy(mapping->xpath_to_fmt, xpath_to_fmt, sizeof(mapping->xpath_to_fmt)); const char *keys[] = {"KEY1", "KEY2", "KEY3", "KEY4"}; char *xpfmt; for (unsigned int i = 0; i < array_size(keys); i++) { xpfmt = frrstr_replace(mapping->xpath_from_fmt, keys[i], "%[^']"); strlcpy(mapping->xpath_from_fmt, xpfmt, sizeof(mapping->xpath_from_fmt)); XFREE(MTYPE_TMP, xpfmt); } for (unsigned int i = 0; i < array_size(keys); i++) { xpfmt = frrstr_replace(mapping->xpath_to_fmt, keys[i], "%s"); strlcpy(mapping->xpath_to_fmt, xpfmt, sizeof(mapping->xpath_to_fmt)); XFREE(MTYPE_TMP, xpfmt); } } static void yang_tmodule_delete(struct yang_tmodule *tmodule) { XFREE(MTYPE_YANG_TRANSLATOR_MODULE, tmodule); } struct yang_translator *yang_translator_load(const char *path) { struct yang_translator *translator; struct yang_tmodule *tmodule = NULL; const char *family; struct lyd_node *dnode; struct ly_set *set; struct listnode *ln; LY_ERR err; /* Load module translator (JSON file). */ err = lyd_parse_data_path(ly_translator_ctx, path, LYD_JSON, LYD_PARSE_NO_STATE, LYD_VALIDATE_NO_STATE, &dnode); if (err) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: lyd_parse_path() failed: %d", __func__, err); return NULL; } dnode = yang_dnode_get(dnode, "/frr-module-translator:frr-module-translator"); /* * libyang guarantees the "frr-module-translator" top-level container is * always present since it contains mandatory child nodes. */ assert(dnode); family = yang_dnode_get_string(dnode, "./family"); translator = yang_translator_find(family); if (translator != NULL) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: module translator \"%s\" is loaded already", __func__, family); yang_dnode_free(dnode); return NULL; } translator = XCALLOC(MTYPE_YANG_TRANSLATOR, sizeof(*translator)); strlcpy(translator->family, family, sizeof(translator->family)); translator->modules = list_new(); for (size_t i = 0; i < YANG_TRANSLATE_MAX; i++) translator->mappings[i] = hash_create(yang_mapping_hash_key, yang_mapping_hash_cmp, "YANG translation table"); RB_INSERT(yang_translators, &yang_translators, translator); /* Initialize the translator libyang context. */ translator->ly_ctx = yang_ctx_new_setup(false, false); if (!translator->ly_ctx) { flog_warn(EC_LIB_LIBYANG, "%s: ly_ctx_new() failed", __func__); goto error; } /* Load modules */ if (lyd_find_xpath(dnode, "./module", &set) != LY_SUCCESS) assert(0); /* XXX libyang2: old ly1 code asserted success */ for (size_t i = 0; i < set->count; i++) { const char *module_name; tmodule = XCALLOC(MTYPE_YANG_TRANSLATOR_MODULE, sizeof(*tmodule)); module_name = yang_dnode_get_string(set->dnodes[i], "./name"); tmodule->module = ly_ctx_load_module(translator->ly_ctx, module_name, NULL, NULL); if (!tmodule->module) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: failed to load module: %s", __func__, module_name); ly_set_free(set, NULL); goto error; } } /* Count nodes in modules. */ for (ALL_LIST_ELEMENTS_RO(translator->modules, ln, tmodule)) { tmodule->nodes_before_deviations = yang_module_nodes_count(tmodule->module); } /* Load the deviations and count nodes again */ for (ALL_LIST_ELEMENTS_RO(translator->modules, ln, tmodule)) { const char *module_name = tmodule->module->name; tmodule->deviations = ly_ctx_load_module( translator->ly_ctx, module_name, NULL, NULL); if (!tmodule->deviations) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: failed to load module: %s", __func__, module_name); ly_set_free(set, NULL); goto error; } tmodule->nodes_after_deviations = yang_module_nodes_count(tmodule->module); } ly_set_free(set, NULL); /* Calculate the coverage. */ for (ALL_LIST_ELEMENTS_RO(translator->modules, ln, tmodule)) { tmodule->coverage = ((double)tmodule->nodes_after_deviations / (double)tmodule->nodes_before_deviations) * 100; } /* Load mappings. */ if (lyd_find_xpath(dnode, "./module/mappings", &set) != LY_SUCCESS) assert(0); /* XXX libyang2: old ly1 code asserted success */ for (size_t i = 0; i < set->count; i++) { const char *xpath_custom, *xpath_native; const struct lysc_node *snode_custom, *snode_native; xpath_custom = yang_dnode_get_string(set->dnodes[i], "./custom"); snode_custom = lys_find_path(translator->ly_ctx, NULL, xpath_custom, 0); if (!snode_custom) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: unknown data path: %s", __func__, xpath_custom); ly_set_free(set, NULL); goto error; } xpath_native = yang_dnode_get_string(set->dnodes[i], "./native"); snode_native = lys_find_path(ly_native_ctx, NULL, xpath_native, 0); if (!snode_native) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: unknown data path: %s", __func__, xpath_native); ly_set_free(set, NULL); goto error; } yang_mapping_add(translator, YANG_TRANSLATE_TO_NATIVE, snode_custom, xpath_custom, xpath_native); yang_mapping_add(translator, YANG_TRANSLATE_FROM_NATIVE, snode_native, xpath_native, xpath_custom); } ly_set_free(set, NULL); /* Validate mappings. */ if (yang_translator_validate(translator) != 0) goto error; yang_dnode_free(dnode); return translator; error: yang_dnode_free(dnode); yang_translator_unload(translator); yang_tmodule_delete(tmodule); return NULL; } void yang_translator_unload(struct yang_translator *translator) { for (size_t i = 0; i < YANG_TRANSLATE_MAX; i++) hash_clean(translator->mappings[i], yang_mapping_hash_free); translator->modules->del = (void (*)(void *))yang_tmodule_delete; list_delete(&translator->modules); ly_ctx_destroy(translator->ly_ctx); RB_REMOVE(yang_translators, &yang_translators, translator); XFREE(MTYPE_YANG_TRANSLATOR, translator); } struct yang_translator *yang_translator_find(const char *family) { struct yang_translator s; strlcpy(s.family, family, sizeof(s.family)); return RB_FIND(yang_translators, &yang_translators, &s); } enum yang_translate_result yang_translate_xpath(const struct yang_translator *translator, int dir, char *xpath, size_t xpath_len) { struct ly_ctx *ly_ctx; const struct lysc_node *snode; struct yang_mapping_node *mapping; char xpath_canonical[XPATH_MAXLEN]; char keys[4][LIST_MAXKEYLEN]; int n; if (dir == YANG_TRANSLATE_TO_NATIVE) ly_ctx = translator->ly_ctx; else ly_ctx = ly_native_ctx; snode = lys_find_path(ly_ctx, NULL, xpath, 0); if (!snode) { flog_warn(EC_LIB_YANG_TRANSLATION_ERROR, "%s: unknown data path: %s", __func__, xpath); return YANG_TRANSLATE_FAILURE; } yang_snode_get_path(snode, YANG_PATH_DATA, xpath_canonical, sizeof(xpath_canonical)); mapping = yang_mapping_lookup(translator, dir, xpath_canonical); if (!mapping) return YANG_TRANSLATE_NOTFOUND; #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wformat-nonliteral" /* processing format strings from mapping node... */ n = sscanf(xpath, mapping->xpath_from_fmt, keys[0], keys[1], keys[2], keys[3]); #pragma GCC diagnostic pop if (n < 0) { flog_warn(EC_LIB_YANG_TRANSLATION_ERROR, "%s: sscanf() failed: %s", __func__, safe_strerror(errno)); return YANG_TRANSLATE_FAILURE; } #pragma GCC diagnostic push #pragma GCC diagnostic ignored "-Wformat-nonliteral" /* processing format strings from mapping node... */ snprintf(xpath, xpath_len, mapping->xpath_to_fmt, keys[0], keys[1], keys[2], keys[3]); #pragma GCC diagnostic pop return YANG_TRANSLATE_SUCCESS; } int yang_translate_dnode(const struct yang_translator *translator, int dir, struct lyd_node **dnode) { struct ly_ctx *ly_ctx; struct lyd_node *new; struct lyd_node *root, *dnode_iter; /* Create new libyang data node to hold the translated data. */ if (dir == YANG_TRANSLATE_TO_NATIVE) ly_ctx = ly_native_ctx; else ly_ctx = translator->ly_ctx; new = yang_dnode_new(ly_ctx, false); /* Iterate over all nodes from the data tree. */ LY_LIST_FOR (*dnode, root) { LYD_TREE_DFS_BEGIN (root, dnode_iter) { char xpath[XPATH_MAXLEN]; enum yang_translate_result ret; yang_dnode_get_path(dnode_iter, xpath, sizeof(xpath)); ret = yang_translate_xpath(translator, dir, xpath, sizeof(xpath)); switch (ret) { case YANG_TRANSLATE_SUCCESS: break; case YANG_TRANSLATE_NOTFOUND: goto next; case YANG_TRANSLATE_FAILURE: goto error; } /* Create new node in the tree of translated data. */ if (lyd_new_path(new, ly_ctx, xpath, (void *)yang_dnode_get_string( dnode_iter, NULL), LYD_NEW_PATH_UPDATE, NULL)) { flog_err(EC_LIB_LIBYANG, "%s: lyd_new_path() failed", __func__); goto error; } next: LYD_TREE_DFS_END(root, dnode_iter); } } /* Replace dnode by the new translated dnode. */ yang_dnode_free(*dnode); *dnode = new; return YANG_TRANSLATE_SUCCESS; error: yang_dnode_free(new); return YANG_TRANSLATE_FAILURE; } struct translator_validate_args { struct yang_translator *translator; unsigned int errors; }; static int yang_translator_validate_cb(const struct lysc_node *snode_custom, void *arg) { struct translator_validate_args *args = arg; struct yang_mapping_node *mapping; const struct lysc_node *snode_native; const struct lysc_type *stype_custom, *stype_native; char xpath[XPATH_MAXLEN]; yang_snode_get_path(snode_custom, YANG_PATH_DATA, xpath, sizeof(xpath)); mapping = yang_mapping_lookup(args->translator, YANG_TRANSLATE_TO_NATIVE, xpath); if (!mapping) { flog_warn(EC_LIB_YANG_TRANSLATOR_LOAD, "%s: missing mapping for \"%s\"", __func__, xpath); args->errors += 1; return YANG_ITER_CONTINUE; } snode_native = lys_find_path(ly_native_ctx, NULL, mapping->xpath_to_fmt, 0); assert(snode_native); /* Check if the YANG types are compatible. */ stype_custom = yang_snode_get_type(snode_custom); stype_native = yang_snode_get_type(snode_native); if (stype_custom && stype_native) { if (stype_custom->basetype != stype_native->basetype) { flog_warn( EC_LIB_YANG_TRANSLATOR_LOAD, "%s: YANG types are incompatible (xpath: \"%s\")", __func__, xpath); args->errors += 1; return YANG_ITER_CONTINUE; } /* TODO: check if the value spaces are identical. */ } return YANG_ITER_CONTINUE; } /* * Check if the modules from the translator have a mapping for all of their * schema nodes (after loading the deviations). */ static unsigned int yang_translator_validate(struct yang_translator *translator) { struct yang_tmodule *tmodule; struct listnode *ln; struct translator_validate_args args; args.translator = translator; args.errors = 0; for (ALL_LIST_ELEMENTS_RO(translator->modules, ln, tmodule)) { yang_snodes_iterate(tmodule->module, yang_translator_validate_cb, YANG_ITER_FILTER_NPCONTAINERS | YANG_ITER_FILTER_LIST_KEYS | YANG_ITER_FILTER_INPUT_OUTPUT, &args); } if (args.errors) flog_warn( EC_LIB_YANG_TRANSLATOR_LOAD, "%s: failed to validate \"%s\" module translator: %u error(s)", __func__, translator->family, args.errors); return args.errors; } static int yang_module_nodes_count_cb(const struct lysc_node *snode, void *arg) { unsigned int *total = arg; *total += 1; return YANG_ITER_CONTINUE; } /* Calculate the number of nodes for the given module. */ static unsigned int yang_module_nodes_count(const struct lys_module *module) { unsigned int total = 0; yang_snodes_iterate(module, yang_module_nodes_count_cb, YANG_ITER_FILTER_NPCONTAINERS | YANG_ITER_FILTER_LIST_KEYS | YANG_ITER_FILTER_INPUT_OUTPUT, &total); return total; } void yang_translator_init(void) { ly_translator_ctx = yang_ctx_new_setup(true, false); if (!ly_translator_ctx) { flog_err(EC_LIB_LIBYANG, "%s: ly_ctx_new() failed", __func__); exit(1); } if (!ly_ctx_load_module(ly_translator_ctx, "frr-module-translator", NULL, NULL)) { flog_err( EC_LIB_YANG_MODULE_LOAD, "%s: failed to load the \"frr-module-translator\" module", __func__); exit(1); } } void yang_translator_terminate(void) { while (!RB_EMPTY(yang_translators, &yang_translators)) { struct yang_translator *translator; translator = RB_ROOT(yang_translators, &yang_translators); yang_translator_unload(translator); } ly_ctx_destroy(ly_translator_ctx); }