[mirror_frr.git] / lib / yang.c

/*
 * Copyright (C) 2018  NetDEF, Inc.
 *                     Renato Westphal
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include <zebra.h>

#include "log.h"
#include "log_int.h"
#include "lib_errors.h"
#include "yang.h"
#include "yang_translator.h"
#include "northbound.h"

DEFINE_MTYPE(LIB, YANG_MODULE, "YANG module")
DEFINE_MTYPE(LIB, YANG_DATA, "YANG data structure")

/* libyang container. */
struct ly_ctx *ly_native_ctx;

static struct yang_module_embed *embeds, **embedupd = &embeds;

void yang_module_embed(struct yang_module_embed *embed)
{
	embed->next = NULL;
	*embedupd = embed;
	embedupd = &embed->next;
}

static const char *yang_module_imp_clb(const char *mod_name,
				       const char *mod_rev,
				       const char *submod_name,
				       const char *submod_rev,
				       void *user_data,
				       LYS_INFORMAT *format,
				       void (**free_module_data)
						(void *, void*))
{
	struct yang_module_embed *e;

	if (submod_name || submod_rev)
		return NULL;

	for (e = embeds; e; e = e->next) {
		if (strcmp(e->mod_name, mod_name))
			continue;
		if (mod_rev && strcmp(e->mod_rev, mod_rev))
			continue;

		*format = e->format;
		return e->data;
	}

	flog_warn(EC_LIB_YANG_MODULE_LOAD,
		  "YANG model \"%s@%s\" not embedded, trying external file",
		  mod_name, mod_rev ? mod_rev : "*");
	return NULL;
}

static const char *const frr_native_modules[] = {
	"frr-interface",
	"frr-ripd",
	"frr-ripngd",
	"frr-isisd",
};

/* Generate the yang_modules tree. */
static inline int yang_module_compare(const struct yang_module *a,
				      const struct yang_module *b)
{
	return strcmp(a->name, b->name);
}
RB_GENERATE(yang_modules, yang_module, entry, yang_module_compare)

struct yang_modules yang_modules = RB_INITIALIZER(&yang_modules);

struct yang_module *yang_module_load(const char *module_name)
{
	struct yang_module *module;
	const struct lys_module *module_info;

	module_info = ly_ctx_load_module(ly_native_ctx, module_name, NULL);
	if (!module_info) {
		flog_err(EC_LIB_YANG_MODULE_LOAD,
			 "%s: failed to load data model: %s", __func__,
			 module_name);
		exit(1);
	}

	module = XCALLOC(MTYPE_YANG_MODULE, sizeof(*module));
	module->name = module_name;
	module->info = module_info;

	if (RB_INSERT(yang_modules, &yang_modules, module) != NULL) {
		flog_err(EC_LIB_YANG_MODULE_LOADED_ALREADY,
			 "%s: YANG module is loaded already: %s", __func__,
			 module_name);
		exit(1);
	}

	return module;
}

void yang_module_load_all(void)
{
	for (size_t i = 0; i < array_size(frr_native_modules); i++)
		yang_module_load(frr_native_modules[i]);
}

struct yang_module *yang_module_find(const char *module_name)
{
	struct yang_module s;

	s.name = module_name;
	return RB_FIND(yang_modules, &yang_modules, &s);
}

int yang_snodes_iterate_subtree(const struct lys_node *snode,
				yang_iterate_cb cb, uint16_t flags, void *arg)
{
	struct lys_node *child;
	int ret = YANG_ITER_CONTINUE;

	if (CHECK_FLAG(flags, YANG_ITER_FILTER_IMPLICIT)) {
		switch (snode->nodetype) {
		case LYS_CASE:
		case LYS_INPUT:
		case LYS_OUTPUT:
			if (CHECK_FLAG(snode->flags, LYS_IMPLICIT))
				goto next;
			break;
		default:
			break;
		}
	}

	switch (snode->nodetype) {
	case LYS_CONTAINER:
		if (CHECK_FLAG(flags, YANG_ITER_FILTER_NPCONTAINERS)) {
			struct lys_node_container *scontainer;

			scontainer = (struct lys_node_container *)snode;
			if (!scontainer->presence)
				goto next;
		}
		break;
	case LYS_LEAF:
		if (CHECK_FLAG(flags, YANG_ITER_FILTER_LIST_KEYS)) {
			struct lys_node_leaf *sleaf;

			/* Ignore list keys. */
			sleaf = (struct lys_node_leaf *)snode;
			if (lys_is_key(sleaf, NULL))
				goto next;
		}
		break;
	case LYS_GROUPING:
		/* Return since we're not interested in the grouping subtree. */
		return YANG_ITER_CONTINUE;
	case LYS_USES:
	case LYS_AUGMENT:
		/* Always ignore nodes of these types. */
		goto next;
	case LYS_INPUT:
	case LYS_OUTPUT:
		if (CHECK_FLAG(flags, YANG_ITER_FILTER_INPUT_OUTPUT))
			goto next;
		break;
	default:
		break;
	}

	ret = (*cb)(snode, arg);
	if (ret == YANG_ITER_STOP)
		return ret;

next:
	/*
	 * YANG leafs and leaf-lists can't have child nodes, and trying to
	 * access snode->child is undefined behavior.
	 */
	if (CHECK_FLAG(snode->nodetype, LYS_LEAF | LYS_LEAFLIST))
		return YANG_ITER_CONTINUE;

	LY_TREE_FOR (snode->child, child) {
		if (!CHECK_FLAG(flags, YANG_ITER_ALLOW_AUGMENTATIONS)
		    && child->parent != snode)
			continue;

		ret = yang_snodes_iterate_subtree(child, cb, flags, arg);
		if (ret == YANG_ITER_STOP)
			return ret;
	}

	return ret;
}

int yang_snodes_iterate_module(const struct lys_module *module,
			       yang_iterate_cb cb, uint16_t flags, void *arg)
{
	struct lys_node *snode;
	int ret = YANG_ITER_CONTINUE;

	LY_TREE_FOR (module->data, snode) {
		ret = yang_snodes_iterate_subtree(snode, cb, flags, arg);
		if (ret == YANG_ITER_STOP)
			return ret;
	}

	for (uint8_t i = 0; i < module->augment_size; i++) {
		ret = yang_snodes_iterate_subtree(
			(const struct lys_node *)&module->augment[i], cb, flags,
			arg);
		if (ret == YANG_ITER_STOP)
			return ret;
	}

	return ret;
}

int yang_snodes_iterate_all(yang_iterate_cb cb, uint16_t flags, void *arg)
{
	struct yang_module *module;
	int ret = YANG_ITER_CONTINUE;

	RB_FOREACH (module, yang_modules, &yang_modules) {
		ret = yang_snodes_iterate_module(module->info, cb, flags, arg);
		if (ret == YANG_ITER_STOP)
			return ret;
	}

	return ret;
}

void yang_snode_get_path(const struct lys_node *snode, enum yang_path_type type,
			 char *xpath, size_t xpath_len)
{
	char *xpath_ptr;

	switch (type) {
	case YANG_PATH_SCHEMA:
		xpath_ptr = lys_path(snode, 0);
		break;
	case YANG_PATH_DATA:
		xpath_ptr = lys_data_path(snode);
		break;
	default:
		flog_err(EC_LIB_DEVELOPMENT, "%s: unknown yang path type: %u",
			 __func__, type);
		exit(1);
	}
	strlcpy(xpath, xpath_ptr, xpath_len);
	free(xpath_ptr);
}

struct lys_node *yang_snode_real_parent(const struct lys_node *snode)
{
	struct lys_node *parent = snode->parent;

	while (parent) {
		struct lys_node_container *scontainer;

		switch (parent->nodetype) {
		case LYS_CONTAINER:
			scontainer = (struct lys_node_container *)parent;
			if (scontainer->presence)
				return parent;
			break;
		case LYS_LIST:
			return parent;
		default:
			break;
		}
		parent = parent->parent;
	}

	return NULL;
}

struct lys_node *yang_snode_parent_list(const struct lys_node *snode)
{
	struct lys_node *parent = snode->parent;

	while (parent) {
		switch (parent->nodetype) {
		case LYS_LIST:
			return parent;
		default:
			break;
		}
		parent = parent->parent;
	}

	return NULL;
}

bool yang_snode_is_typeless_data(const struct lys_node *snode)
{
	struct lys_node_leaf *sleaf;

	switch (snode->nodetype) {
	case LYS_LEAF:
		sleaf = (struct lys_node_leaf *)snode;
		if (sleaf->type.base == LY_TYPE_EMPTY)
			return true;
		return false;
	case LYS_LEAFLIST:
		return false;
	default:
		return true;
	}
}

const char *yang_snode_get_default(const struct lys_node *snode)
{
	struct lys_node_leaf *sleaf;

	switch (snode->nodetype) {
	case LYS_LEAF:
		sleaf = (struct lys_node_leaf *)snode;

		/* NOTE: this might be null. */
		return sleaf->dflt;
	case LYS_LEAFLIST:
		/* TODO: check leaf-list default values */
		return NULL;
	default:
		return NULL;
	}
}

const struct lys_type *yang_snode_get_type(const struct lys_node *snode)
{
	struct lys_node_leaf *sleaf = (struct lys_node_leaf *)snode;
	struct lys_type *type;

	if (!CHECK_FLAG(sleaf->nodetype, LYS_LEAF | LYS_LEAFLIST))
		return NULL;

	type = &sleaf->type;
	while (type->base == LY_TYPE_LEAFREF)
		type = &type->info.lref.target->type;

	return type;
}

void yang_dnode_get_path(const struct lyd_node *dnode, char *xpath,
			 size_t xpath_len)
{
	char *xpath_ptr;

	xpath_ptr = lyd_path(dnode);
	strlcpy(xpath, xpath_ptr, xpath_len);
	free(xpath_ptr);
}

const char *yang_dnode_get_schema_name(const struct lyd_node *dnode,
				       const char *xpath_fmt, ...)
{
	if (xpath_fmt) {
		va_list ap;
		char xpath[XPATH_MAXLEN];

		va_start(ap, xpath_fmt);
		vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
		va_end(ap);

		dnode = yang_dnode_get(dnode, xpath);
		if (!dnode) {
			flog_err(EC_LIB_YANG_DNODE_NOT_FOUND,
				 "%s: couldn't find %s", __func__, xpath);
			zlog_backtrace(LOG_ERR);
			abort();
		}
	}

	return dnode->schema->name;
}

struct lyd_node *yang_dnode_get(const struct lyd_node *dnode,
				const char *xpath_fmt, ...)
{
	va_list ap;
	char xpath[XPATH_MAXLEN];
	struct ly_set *set;
	struct lyd_node *dnode_ret = NULL;

	va_start(ap, xpath_fmt);
	vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
	va_end(ap);

	set = lyd_find_path(dnode, xpath);
	assert(set);
	if (set->number == 0)
		goto exit;

	if (set->number > 1) {
		flog_warn(EC_LIB_YANG_DNODE_NOT_FOUND,
			  "%s: found %u elements (expected 0 or 1) [xpath %s]",
			  __func__, set->number, xpath);
		goto exit;
	}

	dnode_ret = set->set.d[0];

exit:
	ly_set_free(set);

	return dnode_ret;
}

bool yang_dnode_exists(const struct lyd_node *dnode, const char *xpath_fmt, ...)
{
	va_list ap;
	char xpath[XPATH_MAXLEN];
	struct ly_set *set;
	bool found;

	va_start(ap, xpath_fmt);
	vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
	va_end(ap);

	set = lyd_find_path(dnode, xpath);
	assert(set);
	found = (set->number > 0);
	ly_set_free(set);

	return found;
}

bool yang_dnode_is_default(const struct lyd_node *dnode, const char *xpath_fmt,
			   ...)
{
	struct lys_node *snode;
	struct lys_node_leaf *sleaf;
	struct lys_node_container *scontainer;

	if (xpath_fmt) {
		va_list ap;
		char xpath[XPATH_MAXLEN];

		va_start(ap, xpath_fmt);
		vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
		va_end(ap);

		dnode = yang_dnode_get(dnode, xpath);
	}

	assert(dnode);
	snode = dnode->schema;
	switch (snode->nodetype) {
	case LYS_LEAF:
		sleaf = (struct lys_node_leaf *)snode;
		if (sleaf->type.base == LY_TYPE_EMPTY)
			return false;
		return lyd_wd_default((struct lyd_node_leaf_list *)dnode);
	case LYS_LEAFLIST:
		/* TODO: check leaf-list default values */
		return false;
	case LYS_CONTAINER:
		scontainer = (struct lys_node_container *)snode;
		if (scontainer->presence)
			return false;
		return true;
	default:
		return false;
	}
}

bool yang_dnode_is_default_recursive(const struct lyd_node *dnode)
{
	struct lys_node *snode;
	struct lyd_node *root, *next, *dnode_iter;

	snode = dnode->schema;
	if (CHECK_FLAG(snode->nodetype, LYS_LEAF | LYS_LEAFLIST))
		return yang_dnode_is_default(dnode, NULL);

	if (!yang_dnode_is_default(dnode, NULL))
		return false;

	LY_TREE_FOR (dnode->child, root) {
		LY_TREE_DFS_BEGIN (root, next, dnode_iter) {
			if (!yang_dnode_is_default(dnode_iter, NULL))
				return false;

			LY_TREE_DFS_END(root, next, dnode_iter);
		}
	}

	return true;
}

void yang_dnode_change_leaf(struct lyd_node *dnode, const char *value)
{
	assert(dnode->schema->nodetype == LYS_LEAF);
	lyd_change_leaf((struct lyd_node_leaf_list *)dnode, value);
}

void yang_dnode_set_entry(const struct lyd_node *dnode, void *entry)
{
	assert(CHECK_FLAG(dnode->schema->nodetype, LYS_LIST | LYS_CONTAINER));
	lyd_set_private(dnode, entry);
}

void *yang_dnode_get_entry(const struct lyd_node *dnode,
			   bool abort_if_not_found)
{
	const struct lyd_node *orig_dnode = dnode;
	char xpath[XPATH_MAXLEN];

	while (dnode) {
		switch (dnode->schema->nodetype) {
		case LYS_CONTAINER:
		case LYS_LIST:
			if (dnode->priv)
				return dnode->priv;
			break;
		default:
			break;
		}

		dnode = dnode->parent;
	}

	if (!abort_if_not_found)
		return NULL;

	yang_dnode_get_path(orig_dnode, xpath, sizeof(xpath));
	flog_err(EC_LIB_YANG_DNODE_NOT_FOUND,
		 "%s: failed to find entry [xpath %s]", __func__, xpath);
	zlog_backtrace(LOG_ERR);
	abort();
}

struct lyd_node *yang_dnode_new(struct ly_ctx *ly_ctx, bool config_only)
{
	struct lyd_node *dnode;
	int options;

	if (config_only)
		options = LYD_OPT_CONFIG;
	else
		options = LYD_OPT_DATA | LYD_OPT_DATA_NO_YANGLIB;

	dnode = NULL;
	if (lyd_validate(&dnode, options, ly_ctx) != 0) {
		/* Should never happen. */
		flog_err(EC_LIB_LIBYANG, "%s: lyd_validate() failed", __func__);
		exit(1);
	}

	return dnode;
}

struct lyd_node *yang_dnode_dup(const struct lyd_node *dnode)
{
	return lyd_dup_withsiblings(dnode, 1);
}

void yang_dnode_free(struct lyd_node *dnode)
{
	while (dnode->parent)
		dnode = dnode->parent;
	lyd_free_withsiblings(dnode);
}

struct yang_data *yang_data_new(const char *xpath, const char *value)
{
	struct yang_data *data;

	data = XCALLOC(MTYPE_YANG_DATA, sizeof(*data));
	strlcpy(data->xpath, xpath, sizeof(data->xpath));
	if (value)
		data->value = strdup(value);

	return data;
}

void yang_data_free(struct yang_data *data)
{
	if (data->value)
		free(data->value);
	XFREE(MTYPE_YANG_DATA, data);
}

struct list *yang_data_list_new(void)
{
	struct list *list;

	list = list_new();
	list->del = (void (*)(void *))yang_data_free;

	return list;
}

static void *ly_dup_cb(const void *priv)
{
	/* Make a shallow copy of the priv pointer. */
	return (void *)priv;
}

/* Make libyang log its errors using FRR logging infrastructure. */
static void ly_log_cb(LY_LOG_LEVEL level, const char *msg, const char *path)
{
	int priority;

	switch (level) {
	case LY_LLERR:
		priority = LOG_ERR;
		break;
	case LY_LLWRN:
		priority = LOG_WARNING;
		break;
	case LY_LLVRB:
		priority = LOG_DEBUG;
		break;
	default:
		return;
	}

	if (path)
		zlog(priority, "libyang: %s (%s)", msg, path);
	else
		zlog(priority, "libyang: %s", msg);
}

void yang_init(void)
{
	static char ly_plugin_dir[PATH_MAX];
	const char *const *ly_loaded_plugins;
	const char *ly_plugin;
	bool found_ly_frr_types = false;

	/* Tell libyang where to find its plugins. */
	snprintf(ly_plugin_dir, sizeof(ly_plugin_dir), "%s=%s",
		 "LIBYANG_USER_TYPES_PLUGINS_DIR", LIBYANG_PLUGINS_PATH);
	putenv(ly_plugin_dir);

	/* Initialize libyang global parameters that affect all containers. */
	ly_set_log_clb(ly_log_cb, 1);
	ly_log_options(LY_LOLOG | LY_LOSTORE);

	/* Initialize libyang container for native models. */
	ly_native_ctx =
		ly_ctx_new(YANG_MODELS_PATH, LY_CTX_DISABLE_SEARCHDIR_CWD);
	if (!ly_native_ctx) {
		flog_err(EC_LIB_LIBYANG, "%s: ly_ctx_new() failed", __func__);
		exit(1);
	}
	ly_ctx_set_module_imp_clb(ly_native_ctx, yang_module_imp_clb, NULL);
	ly_ctx_set_priv_dup_clb(ly_native_ctx, ly_dup_cb);

	/* Detect if the required libyang plugin(s) were loaded successfully. */
	ly_loaded_plugins = ly_get_loaded_plugins();
	for (size_t i = 0; (ly_plugin = ly_loaded_plugins[i]); i++) {
		if (strmatch(ly_plugin, "frr_user_types")) {
			found_ly_frr_types = true;
			break;
		}
	}
	if (!found_ly_frr_types) {
		flog_err(EC_LIB_LIBYANG_PLUGIN_LOAD,
			 "%s: failed to load frr_user_types.so", __func__);
		exit(1);
	}

	yang_translator_init();
}

void yang_terminate(void)
{
	struct yang_module *module;

	yang_translator_terminate();

	while (!RB_EMPTY(yang_modules, &yang_modules)) {
		module = RB_ROOT(yang_modules, &yang_modules);

		/*
		 * We shouldn't call ly_ctx_remove_module() here because this
		 * function also removes other modules that depend on it.
		 *
		 * ly_ctx_destroy() will release all memory for us.
		 */
		RB_REMOVE(yang_modules, &yang_modules, module);
		XFREE(MTYPE_YANG_MODULE, module);
	}

	ly_ctx_destroy(ly_native_ctx, NULL);
}
Commit	Line	Data
1c2facd1 RW	1	/*
	2	* Copyright (C) 2018 NetDEF, Inc.
	3	* Renato Westphal
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License as published by the Free
	7	* Software Foundation; either version 2 of the License, or (at your option)
	8	* any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful, but WITHOUT
	11	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	12	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
	13	* more details.
	14	*
	15	* You should have received a copy of the GNU General Public License along
	16	* with this program; see the file COPYING; if not, write to the Free Software
	17	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	18	*/
	19
	20	#include <zebra.h>
	21
	22	#include "log.h"
	23	#include "log_int.h"
	24	#include "lib_errors.h"
	25	#include "yang.h"
	26	#include "yang_translator.h"
	27	#include "northbound.h"
	28
	29	DEFINE_MTYPE(LIB, YANG_MODULE, "YANG module")
	30	DEFINE_MTYPE(LIB, YANG_DATA, "YANG data structure")
	31
	32	/* libyang container. */
	33	struct ly_ctx *ly_native_ctx;
	34
3a11599c DL	35	static struct yang_module_embed embeds, *embedupd = &embeds;
	36
	37	void yang_module_embed(struct yang_module_embed *embed)
	38	{
	39	embed->next = NULL;
	40	*embedupd = embed;
	41	embedupd = &embed->next;
	42	}
	43
	44	static const char yang_module_imp_clb(const char mod_name,
	45	const char *mod_rev,
	46	const char *submod_name,
	47	const char *submod_rev,
	48	void *user_data,
	49	LYS_INFORMAT *format,
	50	void (**free_module_data)
	51	(void , void))
	52	{
	53	struct yang_module_embed *e;
	54
	55	if (submod_name \|\| submod_rev)
	56	return NULL;
	57
	58	for (e = embeds; e; e = e->next) {
	59	if (strcmp(e->mod_name, mod_name))
	60	continue;
	61	if (mod_rev && strcmp(e->mod_rev, mod_rev))
	62	continue;
	63
	64	*format = e->format;
	65	return e->data;
	66	}
	67
	68	flog_warn(EC_LIB_YANG_MODULE_LOAD,
	69	"YANG model \"%s@%s\" not embedded, trying external file",
	70	mod_name, mod_rev ? mod_rev : "*");
	71	return NULL;
	72	}
	73
96f2c009	74	static const char *const frr_native_modules[] = {
a1b5f469 RW	75	"frr-interface",
a1b5f469 RW	76	"frr-ripd",
e9ce224b	77	"frr-ripngd",
96f2c009	78	"frr-isisd",
a1b5f469 RW	79	};
a1b5f469 RW	80
1c2facd1 RW	81	/* Generate the yang_modules tree. */
	82	static inline int yang_module_compare(const struct yang_module *a,
	83	const struct yang_module *b)
	84	{
	85	return strcmp(a->name, b->name);
	86	}
	87	RB_GENERATE(yang_modules, yang_module, entry, yang_module_compare)
	88
	89	struct yang_modules yang_modules = RB_INITIALIZER(&yang_modules);
	90
	91	struct yang_module yang_module_load(const char module_name)
	92	{
	93	struct yang_module *module;
	94	const struct lys_module *module_info;
	95
	96	module_info = ly_ctx_load_module(ly_native_ctx, module_name, NULL);
	97	if (!module_info) {
	98	flog_err(EC_LIB_YANG_MODULE_LOAD,
	99	"%s: failed to load data model: %s", __func__,
	100	module_name);
	101	exit(1);
	102	}
	103
	104	module = XCALLOC(MTYPE_YANG_MODULE, sizeof(*module));
	105	module->name = module_name;
	106	module->info = module_info;
	107
	108	if (RB_INSERT(yang_modules, &yang_modules, module) != NULL) {
	109	flog_err(EC_LIB_YANG_MODULE_LOADED_ALREADY,
	110	"%s: YANG module is loaded already: %s", __func__,
	111	module_name);
	112	exit(1);
	113	}
	114
	115	return module;
	116	}
	117
a1b5f469 RW	118	void yang_module_load_all(void)
	119	{
	120	for (size_t i = 0; i < array_size(frr_native_modules); i++)
	121	yang_module_load(frr_native_modules[i]);
	122	}
	123
1c2facd1 RW	124	struct yang_module yang_module_find(const char module_name)
	125	{
	126	struct yang_module s;
	127
	128	s.name = module_name;
	129	return RB_FIND(yang_modules, &yang_modules, &s);
	130	}
	131
e0ccfad2 RW	132	int yang_snodes_iterate_subtree(const struct lys_node *snode,
e0ccfad2 RW	133	yang_iterate_cb cb, uint16_t flags, void *arg)
1c2facd1 RW	134	{
1c2facd1 RW	135	struct lys_node *child;
e0ccfad2	136	int ret = YANG_ITER_CONTINUE;
1c2facd1 RW	137
	138	if (CHECK_FLAG(flags, YANG_ITER_FILTER_IMPLICIT)) {
	139	switch (snode->nodetype) {
	140	case LYS_CASE:
	141	case LYS_INPUT:
	142	case LYS_OUTPUT:
db452508	143	if (CHECK_FLAG(snode->flags, LYS_IMPLICIT))
1c2facd1 RW	144	goto next;
	145	break;
	146	default:
	147	break;
	148	}
	149	}
	150
	151	switch (snode->nodetype) {
	152	case LYS_CONTAINER:
	153	if (CHECK_FLAG(flags, YANG_ITER_FILTER_NPCONTAINERS)) {
	154	struct lys_node_container *scontainer;
	155
	156	scontainer = (struct lys_node_container *)snode;
	157	if (!scontainer->presence)
	158	goto next;
	159	}
	160	break;
	161	case LYS_LEAF:
	162	if (CHECK_FLAG(flags, YANG_ITER_FILTER_LIST_KEYS)) {
	163	struct lys_node_leaf *sleaf;
	164
	165	/* Ignore list keys. */
	166	sleaf = (struct lys_node_leaf *)snode;
	167	if (lys_is_key(sleaf, NULL))
	168	goto next;
	169	}
	170	break;
	171	case LYS_GROUPING:
	172	/* Return since we're not interested in the grouping subtree. */
e0ccfad2	173	return YANG_ITER_CONTINUE;
1c2facd1 RW	174	case LYS_USES:
	175	case LYS_AUGMENT:
	176	/* Always ignore nodes of these types. */
	177	goto next;
	178	case LYS_INPUT:
	179	case LYS_OUTPUT:
	180	if (CHECK_FLAG(flags, YANG_ITER_FILTER_INPUT_OUTPUT))
	181	goto next;
	182	break;
	183	default:
	184	break;
	185	}
	186
e0ccfad2 RW	187	ret = (*cb)(snode, arg);
	188	if (ret == YANG_ITER_STOP)
	189	return ret;
1c2facd1 RW	190
	191	next:
	192	/*
	193	* YANG leafs and leaf-lists can't have child nodes, and trying to
	194	* access snode->child is undefined behavior.
	195	*/
db452508	196	if (CHECK_FLAG(snode->nodetype, LYS_LEAF \| LYS_LEAFLIST))
e0ccfad2	197	return YANG_ITER_CONTINUE;
1c2facd1 RW	198
1c2facd1 RW	199	LY_TREE_FOR (snode->child, child) {
544ca69a RW	200	if (!CHECK_FLAG(flags, YANG_ITER_ALLOW_AUGMENTATIONS)
544ca69a RW	201	&& child->parent != snode)
1c2facd1	202	continue;
e0ccfad2 RW	203
	204	ret = yang_snodes_iterate_subtree(child, cb, flags, arg);
	205	if (ret == YANG_ITER_STOP)
	206	return ret;
1c2facd1	207	}
e0ccfad2 RW	208
e0ccfad2 RW	209	return ret;
1c2facd1 RW	210	}
1c2facd1 RW	211
e0ccfad2 RW	212	int yang_snodes_iterate_module(const struct lys_module *module,
e0ccfad2 RW	213	yang_iterate_cb cb, uint16_t flags, void *arg)
1c2facd1 RW	214	{
1c2facd1 RW	215	struct lys_node *snode;
e0ccfad2	216	int ret = YANG_ITER_CONTINUE;
1c2facd1 RW	217
1c2facd1 RW	218	LY_TREE_FOR (module->data, snode) {
e0ccfad2 RW	219	ret = yang_snodes_iterate_subtree(snode, cb, flags, arg);
	220	if (ret == YANG_ITER_STOP)
	221	return ret;
1c2facd1 RW	222	}
	223
	224	for (uint8_t i = 0; i < module->augment_size; i++) {
e0ccfad2 RW	225	ret = yang_snodes_iterate_subtree(
	226	(const struct lys_node *)&module->augment[i], cb, flags,
	227	arg);
	228	if (ret == YANG_ITER_STOP)
	229	return ret;
1c2facd1	230	}
e0ccfad2 RW	231
e0ccfad2 RW	232	return ret;
1c2facd1 RW	233	}
1c2facd1 RW	234
e0ccfad2	235	int yang_snodes_iterate_all(yang_iterate_cb cb, uint16_t flags, void *arg)
1c2facd1 RW	236	{
1c2facd1 RW	237	struct yang_module *module;
e0ccfad2 RW	238	int ret = YANG_ITER_CONTINUE;
	239
	240	RB_FOREACH (module, yang_modules, &yang_modules) {
	241	ret = yang_snodes_iterate_module(module->info, cb, flags, arg);
	242	if (ret == YANG_ITER_STOP)
	243	return ret;
	244	}
1c2facd1	245
e0ccfad2	246	return ret;
1c2facd1 RW	247	}
	248
	249	void yang_snode_get_path(const struct lys_node *snode, enum yang_path_type type,
	250	char *xpath, size_t xpath_len)
	251	{
	252	char *xpath_ptr;
	253
	254	switch (type) {
	255	case YANG_PATH_SCHEMA:
	256	xpath_ptr = lys_path(snode, 0);
	257	break;
	258	case YANG_PATH_DATA:
	259	xpath_ptr = lys_data_path(snode);
	260	break;
	261	default:
	262	flog_err(EC_LIB_DEVELOPMENT, "%s: unknown yang path type: %u",
	263	__func__, type);
	264	exit(1);
	265	}
	266	strlcpy(xpath, xpath_ptr, xpath_len);
	267	free(xpath_ptr);
	268	}
	269
	270	struct lys_node yang_snode_real_parent(const struct lys_node snode)
	271	{
	272	struct lys_node *parent = snode->parent;
	273
	274	while (parent) {
	275	struct lys_node_container *scontainer;
	276
	277	switch (parent->nodetype) {
	278	case LYS_CONTAINER:
	279	scontainer = (struct lys_node_container *)parent;
	280	if (scontainer->presence)
	281	return parent;
	282	break;
	283	case LYS_LIST:
	284	return parent;
	285	default:
	286	break;
	287	}
	288	parent = parent->parent;
	289	}
	290
	291	return NULL;
	292	}
	293
	294	struct lys_node yang_snode_parent_list(const struct lys_node snode)
	295	{
	296	struct lys_node *parent = snode->parent;
	297
	298	while (parent) {
	299	switch (parent->nodetype) {
	300	case LYS_LIST:
	301	return parent;
	302	default:
	303	break;
	304	}
	305	parent = parent->parent;
	306	}
	307
	308	return NULL;
	309	}
	310
311	bool yang_snode_is_typeless_data(const struct lys_node *snode)
312	{
313	struct lys_node_leaf *sleaf;
314
315	switch (snode->nodetype) {
316	case LYS_LEAF:
317	sleaf = (struct lys_node_leaf *)snode;
318	if (sleaf->type.base == LY_TYPE_EMPTY)
319	return true;
320	return false;
321	case LYS_LEAFLIST:
322	return false;
323	default:
324	return true;
325	}
326	}
327
328	const char yang_snode_get_default(const struct lys_node snode)
329	{
330	struct lys_node_leaf *sleaf;
331
332	switch (snode->nodetype) {
333	case LYS_LEAF:
334	sleaf = (struct lys_node_leaf *)snode;
335
336	/* NOTE: this might be null. */
337	return sleaf->dflt;
338	case LYS_LEAFLIST:
339	/* TODO: check leaf-list default values */
340	return NULL;
341	default:
342	return NULL;
343	}
344	}
345
346	const struct lys_type yang_snode_get_type(const struct lys_node snode)
347	{
348	struct lys_node_leaf sleaf = (struct lys_node_leaf )snode;
349	struct lys_type *type;
350
db452508	351	if (!CHECK_FLAG(sleaf->nodetype, LYS_LEAF \| LYS_LEAFLIST))
1c2facd1 RW	352	return NULL;
	353
	354	type = &sleaf->type;
	355	while (type->base == LY_TYPE_LEAFREF)
	356	type = &type->info.lref.target->type;
	357
	358	return type;
	359	}
	360
	361	void yang_dnode_get_path(const struct lyd_node dnode, char xpath,
	362	size_t xpath_len)
	363	{
	364	char *xpath_ptr;
	365
	366	xpath_ptr = lyd_path(dnode);
	367	strlcpy(xpath, xpath_ptr, xpath_len);
	368	free(xpath_ptr);
	369	}
	370
3f662078 RW	371	const char yang_dnode_get_schema_name(const struct lyd_node dnode,
	372	const char *xpath_fmt, ...)
	373	{
	374	if (xpath_fmt) {
	375	va_list ap;
	376	char xpath[XPATH_MAXLEN];
	377
	378	va_start(ap, xpath_fmt);
	379	vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
	380	va_end(ap);
	381
	382	dnode = yang_dnode_get(dnode, xpath);
	383	if (!dnode) {
	384	flog_err(EC_LIB_YANG_DNODE_NOT_FOUND,
	385	"%s: couldn't find %s", __func__, xpath);
	386	zlog_backtrace(LOG_ERR);
	387	abort();
	388	}
	389	}
	390
	391	return dnode->schema->name;
	392	}
	393
1c2facd1 RW	394	struct lyd_node yang_dnode_get(const struct lyd_node dnode,
	395	const char *xpath_fmt, ...)
	396	{
	397	va_list ap;
	398	char xpath[XPATH_MAXLEN];
	399	struct ly_set *set;
	400	struct lyd_node *dnode_ret = NULL;
	401
	402	va_start(ap, xpath_fmt);
	403	vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
	404	va_end(ap);
	405
	406	set = lyd_find_path(dnode, xpath);
	407	assert(set);
	408	if (set->number == 0)
	409	goto exit;
	410
	411	if (set->number > 1) {
	412	flog_warn(EC_LIB_YANG_DNODE_NOT_FOUND,
	413	"%s: found %u elements (expected 0 or 1) [xpath %s]",
	414	__func__, set->number, xpath);
	415	goto exit;
	416	}
	417
	418	dnode_ret = set->set.d[0];
	419
	420	exit:
	421	ly_set_free(set);
	422
	423	return dnode_ret;
	424	}
	425
	426	bool yang_dnode_exists(const struct lyd_node dnode, const char xpath_fmt, ...)
	427	{
	428	va_list ap;
	429	char xpath[XPATH_MAXLEN];
	430	struct ly_set *set;
	431	bool found;
	432
	433	va_start(ap, xpath_fmt);
	434	vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
	435	va_end(ap);
	436
	437	set = lyd_find_path(dnode, xpath);
	438	assert(set);
	439	found = (set->number > 0);
	440	ly_set_free(set);
	441
	442	return found;
	443	}
	444
	445	bool yang_dnode_is_default(const struct lyd_node dnode, const char xpath_fmt,
	446	...)
	447	{
	448	struct lys_node *snode;
	449	struct lys_node_leaf *sleaf;
	450	struct lys_node_container *scontainer;
	451
	452	if (xpath_fmt) {
	453	va_list ap;
	454	char xpath[XPATH_MAXLEN];
	455
	456	va_start(ap, xpath_fmt);
	457	vsnprintf(xpath, sizeof(xpath), xpath_fmt, ap);
458	va_end(ap);
459
460	dnode = yang_dnode_get(dnode, xpath);
461	}
462
463	assert(dnode);
464	snode = dnode->schema;
465	switch (snode->nodetype) {
466	case LYS_LEAF:
467	sleaf = (struct lys_node_leaf *)snode;
468	if (sleaf->type.base == LY_TYPE_EMPTY)
469	return false;
470	return lyd_wd_default((struct lyd_node_leaf_list *)dnode);
471	case LYS_LEAFLIST:
472	/* TODO: check leaf-list default values */
473	return false;
474	case LYS_CONTAINER:
475	scontainer = (struct lys_node_container *)snode;
476	if (scontainer->presence)
477	return false;
478	return true;
479	default:
480	return false;
481	}
482	}
483
484	bool yang_dnode_is_default_recursive(const struct lyd_node *dnode)
485	{
486	struct lys_node *snode;
487	struct lyd_node root, next, *dnode_iter;
488
489	snode = dnode->schema;
db452508	490	if (CHECK_FLAG(snode->nodetype, LYS_LEAF \| LYS_LEAFLIST))
1c2facd1 RW	491	return yang_dnode_is_default(dnode, NULL);
	492
	493	if (!yang_dnode_is_default(dnode, NULL))
	494	return false;
	495
	496	LY_TREE_FOR (dnode->child, root) {
	497	LY_TREE_DFS_BEGIN (root, next, dnode_iter) {
	498	if (!yang_dnode_is_default(dnode_iter, NULL))
	499	return false;
	500
	501	LY_TREE_DFS_END(root, next, dnode_iter);
	502	}
	503	}
	504
	505	return true;
	506	}
	507
	508	void yang_dnode_change_leaf(struct lyd_node dnode, const char value)
	509	{
	510	assert(dnode->schema->nodetype == LYS_LEAF);
	511	lyd_change_leaf((struct lyd_node_leaf_list *)dnode, value);
	512	}
	513
	514	void yang_dnode_set_entry(const struct lyd_node dnode, void entry)
	515	{
db452508	516	assert(CHECK_FLAG(dnode->schema->nodetype, LYS_LIST \| LYS_CONTAINER));
1c2facd1 RW	517	lyd_set_private(dnode, entry);
	518	}
	519
25c780a3 RW	520	void yang_dnode_get_entry(const struct lyd_node dnode,
25c780a3 RW	521	bool abort_if_not_found)
1c2facd1 RW	522	{
	523	const struct lyd_node *orig_dnode = dnode;
	524	char xpath[XPATH_MAXLEN];
	525
	526	while (dnode) {
	527	switch (dnode->schema->nodetype) {
	528	case LYS_CONTAINER:
	529	case LYS_LIST:
	530	if (dnode->priv)
	531	return dnode->priv;
	532	break;
	533	default:
	534	break;
	535	}
	536
	537	dnode = dnode->parent;
	538	}
	539
25c780a3 RW	540	if (!abort_if_not_found)
	541	return NULL;
	542
1c2facd1 RW	543	yang_dnode_get_path(orig_dnode, xpath, sizeof(xpath));
	544	flog_err(EC_LIB_YANG_DNODE_NOT_FOUND,
	545	"%s: failed to find entry [xpath %s]", __func__, xpath);
	546	zlog_backtrace(LOG_ERR);
	547	abort();
	548	}
	549
5e02643a	550	struct lyd_node yang_dnode_new(struct ly_ctx ly_ctx, bool config_only)
1c2facd1 RW	551	{
1c2facd1 RW	552	struct lyd_node *dnode;
5e02643a RW	553	int options;
	554
	555	if (config_only)
	556	options = LYD_OPT_CONFIG;
	557	else
	558	options = LYD_OPT_DATA \| LYD_OPT_DATA_NO_YANGLIB;
1c2facd1 RW	559
1c2facd1 RW	560	dnode = NULL;
5e02643a	561	if (lyd_validate(&dnode, options, ly_ctx) != 0) {
1c2facd1 RW	562	/* Should never happen. */
	563	flog_err(EC_LIB_LIBYANG, "%s: lyd_validate() failed", __func__);
	564	exit(1);
	565	}
	566
	567	return dnode;
	568	}
	569
	570	struct lyd_node yang_dnode_dup(const struct lyd_node dnode)
	571	{
	572	return lyd_dup_withsiblings(dnode, 1);
	573	}
	574
	575	void yang_dnode_free(struct lyd_node *dnode)
	576	{
e5dc8a44 RW	577	while (dnode->parent)
e5dc8a44 RW	578	dnode = dnode->parent;
1c2facd1 RW	579	lyd_free_withsiblings(dnode);
	580	}
	581
	582	struct yang_data yang_data_new(const char xpath, const char *value)
	583	{
1c2facd1 RW	584	struct yang_data *data;
1c2facd1 RW	585
1c2facd1 RW	586	data = XCALLOC(MTYPE_YANG_DATA, sizeof(*data));
1c2facd1 RW	587	strlcpy(data->xpath, xpath, sizeof(data->xpath));
1c2facd1 RW	588	if (value)
	589	data->value = strdup(value);
	590
	591	return data;
	592	}
	593
	594	void yang_data_free(struct yang_data *data)
	595	{
	596	if (data->value)
	597	free(data->value);
	598	XFREE(MTYPE_YANG_DATA, data);
	599	}
	600
	601	struct list *yang_data_list_new(void)
	602	{
	603	struct list *list;
	604
	605	list = list_new();
	606	list->del = (void ()(void ))yang_data_free;
	607
	608	return list;
	609	}
	610
	611	static void ly_dup_cb(const void priv)
	612	{
	613	/* Make a shallow copy of the priv pointer. */
	614	return (void *)priv;
	615	}
	616
	617	/* Make libyang log its errors using FRR logging infrastructure. */
	618	static void ly_log_cb(LY_LOG_LEVEL level, const char msg, const char path)
	619	{
	620	int priority;
	621
	622	switch (level) {
	623	case LY_LLERR:
	624	priority = LOG_ERR;
	625	break;
	626	case LY_LLWRN:
	627	priority = LOG_WARNING;
	628	break;
	629	case LY_LLVRB:
	630	priority = LOG_DEBUG;
	631	break;
	632	default:
	633	return;
	634	}
	635
	636	if (path)
	637	zlog(priority, "libyang: %s (%s)", msg, path);
	638	else
	639	zlog(priority, "libyang: %s", msg);
	640	}
	641
	642	void yang_init(void)
	643	{
	644	static char ly_plugin_dir[PATH_MAX];
	645	const char const ly_loaded_plugins;
	646	const char *ly_plugin;
	647	bool found_ly_frr_types = false;
	648
	649	/* Tell libyang where to find its plugins. */
	650	snprintf(ly_plugin_dir, sizeof(ly_plugin_dir), "%s=%s",
	651	"LIBYANG_USER_TYPES_PLUGINS_DIR", LIBYANG_PLUGINS_PATH);
652	putenv(ly_plugin_dir);
653
654	/* Initialize libyang global parameters that affect all containers. */
655	ly_set_log_clb(ly_log_cb, 1);
656	ly_log_options(LY_LOLOG \| LY_LOSTORE);
657
658	/* Initialize libyang container for native models. */
f3e5b71c RW	659	ly_native_ctx =
f3e5b71c RW	660	ly_ctx_new(YANG_MODELS_PATH, LY_CTX_DISABLE_SEARCHDIR_CWD);
1c2facd1 RW	661	if (!ly_native_ctx) {
	662	flog_err(EC_LIB_LIBYANG, "%s: ly_ctx_new() failed", __func__);
	663	exit(1);
	664	}
3a11599c	665	ly_ctx_set_module_imp_clb(ly_native_ctx, yang_module_imp_clb, NULL);
1c2facd1 RW	666	ly_ctx_set_priv_dup_clb(ly_native_ctx, ly_dup_cb);
	667
	668	/* Detect if the required libyang plugin(s) were loaded successfully. */
	669	ly_loaded_plugins = ly_get_loaded_plugins();
	670	for (size_t i = 0; (ly_plugin = ly_loaded_plugins[i]); i++) {
	671	if (strmatch(ly_plugin, "frr_user_types")) {
	672	found_ly_frr_types = true;
	673	break;
	674	}
	675	}
	676	if (!found_ly_frr_types) {
	677	flog_err(EC_LIB_LIBYANG_PLUGIN_LOAD,
	678	"%s: failed to load frr_user_types.so", __func__);
	679	exit(1);
	680	}
	681
	682	yang_translator_init();
	683	}
	684
	685	void yang_terminate(void)
	686	{
	687	struct yang_module *module;
	688
	689	yang_translator_terminate();
	690
	691	while (!RB_EMPTY(yang_modules, &yang_modules)) {
	692	module = RB_ROOT(yang_modules, &yang_modules);
	693
	694	/*
	695	* We shouldn't call ly_ctx_remove_module() here because this
	696	* function also removes other modules that depend on it.
	697	*
	698	* ly_ctx_destroy() will release all memory for us.
	699	*/
	700	RB_REMOVE(yang_modules, &yang_modules, module);
	701	XFREE(MTYPE_YANG_MODULE, module);
	702	}
	703
	704	ly_ctx_destroy(ly_native_ctx, NULL);
	705	}