static int
teardown_f(void **state)
{
struct state *st = (*state);
lyd_free_withsiblings(st->first);
lyd_free_withsiblings(st->second);
ly_ctx_destroy(st->ctx, NULL);
free(st->xml);
free(st);
(*state) = NULL;
return 0;
}
/**
* @brief Export content of the specified datastore for the given module into a file
* referenced by the descriptor 'fd_out'
*/
static int
srcfg_export_datastore(struct ly_ctx *ly_ctx, int fd_out, const char *module_name, LYD_FORMAT format)
{
int rc = SR_ERR_INTERNAL;
struct lyd_node *data_tree = NULL;
int ret = 0;
CHECK_NULL_ARG2(ly_ctx, module_name);
/* get data tree of currently stored configuration */
rc = srcfg_get_module_data(ly_ctx, module_name, &data_tree);
if (SR_ERR_OK != rc) {
goto cleanup;
}
/* dump data */
ret = lyd_print_fd(fd_out, data_tree, format, LYP_WITHSIBLINGS | LYP_FORMAT);
CHECK_ZERO_LOG_GOTO(ret, rc, SR_ERR_INTERNAL, cleanup, "Unable to print the data: %s", ly_errmsg());
rc = SR_ERR_OK;
cleanup:
if (NULL != data_tree) {
lyd_free_withsiblings(data_tree);
}
return rc;
}
void
delete_nacm_config(test_nacm_cfg_t *nacm_config)
{
if (NULL != nacm_config) {
lyd_free_withsiblings(nacm_config->root);
ly_ctx_destroy(nacm_config->ly_ctx, NULL);
free(nacm_config);
}
}
static int
teardown_f(void **state)
{
struct state *st = (*state);
lyd_free_withsiblings(st->dt);
lyd_free_withsiblings(st->rpc_act);
ly_ctx_destroy(st->ctx, NULL);
if (st->fd > 0) {
close(st->fd);
}
free(st->str1);
free(st->str2);
free(st);
(*state) = NULL;
return 0;
}
int main(int argc, char *argv[])
{
int fd, i;
struct ly_ctx *ctx = NULL;
char buf[30];
struct lyd_node *data = NULL, *next;
const struct lys_module *mod;
/* libyang context */
ctx = ly_ctx_new(NULL);
if (!ctx) {
fprintf(stderr, "Failed to create context.\n");
return 1;
}
/* schema */
if (!(mod = lys_parse_path(ctx, argv[1], LYS_IN_YIN))) {
fprintf(stderr, "Failed to load data model.\n");
goto cleanup;
}
/* data */
data = NULL;
fd = open("./addloop_result.xml", O_WRONLY | O_CREAT, 0666);
data = NULL;
for(i = 1; i <= 5000; i++) {
next = lyd_new(NULL, mod, "ptest1");
// if (i == 2091) {sprintf(buf, "%d", 1);} else {
sprintf(buf, "%d", i);//}
lyd_new_leaf(next, mod, "index", buf);
lyd_new_leaf(next, mod, "p1", buf);
if (!data) {
data = next;
} else {
lyd_insert_after(data->prev, next);
}
if (lyd_validate(&data, LYD_OPT_CONFIG, NULL)) {
goto cleanup;
}
//lyd_print_fd(fd, data, LYD_XML);
}
lyd_print_fd(fd, data, LYD_XML, LYP_WITHSIBLINGS | LYP_FORMAT);
close(fd);
cleanup:
lyd_free_withsiblings(data);
ly_ctx_destroy(ctx, NULL);
return 0;
}
void
createDataTreeExampleModule()
{
struct ly_ctx *ctx = NULL;
struct lyd_node *root = NULL;
ctx = ly_ctx_new(TEST_SCHEMA_SEARCH_DIR);
assert_non_null(ctx);
const struct lys_module *module = ly_ctx_load_module(ctx, "example-module", NULL);
assert_non_null(module);
#define XPATH "/example-module:container/list[key1='key1'][key2='key2']/leaf"
root = lyd_new_path(NULL, ctx, XPATH, "Leaf value", 0);
assert_int_equal(0, lyd_validate(&root, LYD_OPT_STRICT | LYD_OPT_CONFIG));
assert_int_equal(SR_ERR_OK, sr_save_data_tree_file(EXAMPLE_MODULE_DATA_FILE_NAME, root));
lyd_free_withsiblings(root);
ly_ctx_destroy(ctx, NULL);
}
static void
TEST_RPC_OUTPUT(void **state)
{
struct state *st = (*state);
const int schemas_fail[] = {TEST_SCHEMA_LOAD_FAIL};
const int data_files_fail[] = {TEST_DATA_FILE_LOAD_FAIL};
char buf[1024];
LYS_INFORMAT schema_format = LYS_IN_YANG;
const struct lys_module *mod;
int i, j, ret;
const int data_compare_fail[] = {TEST_DATA_COMPARE_FAIL};
const char *data_compare_string[] = {TEST_DATA_COMPARE};
const char *data_rpc_name[] = {TEST_RPC_NODE};
struct lyd_node *rpc;
for (i = 0; i < 2; ++i) {
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.%s", j + 1, (schema_format == LYS_IN_YANG ? "yang" : "yin"));
mod = lys_parse_path(st->ctx, buf, schema_format);
if (schemas_fail[j]) {
assert_ptr_equal(mod, NULL);
} else {
assert_ptr_not_equal(mod, NULL);
}
}
for (j = 0; j < TEST_DATA_FILE_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/data%d.xml", j + 1);
rpc = lyd_new(NULL, mod, data_rpc_name[j]);
st->node = lyd_parse_path(st->ctx, buf, LYD_XML, LYD_OPT_RPCREPLY, rpc, NULL);
lyd_free(rpc);
if (data_files_fail[j]) {
assert_ptr_equal(st->node, NULL);
} else {
assert_ptr_not_equal(st->node, NULL);
lyd_print_mem(&st->s, st->node, LYD_XML, LYP_WITHSIBLINGS | LYP_FORMAT | LYP_WD_ALL);
if (data_compare_fail[j]) {
assert_ptr_equal(strstr(st->s, data_compare_string[j]), NULL);
} else {
assert_ptr_not_equal(strstr(st->s, data_compare_string[j]), NULL);
}
free(st->s);
st->s = NULL;
}
lyd_free_withsiblings(st->node);
st->node = NULL;
}
if (schema_format == LYS_IN_YANG) {
/* convert the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, BUILD_DIR "/yang2yin "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yang "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1, j + 1);
ret = system(buf);
if (ret == -1) {
fprintf(stderr, "system() failed (%s).\n", strerror(errno));
fail();
} else if (WEXITSTATUS(ret) != 0) {
fprintf(stderr, "Executing command \"%s\" finished with %d.\n", buf, WEXITSTATUS(ret));
fail();
}
}
schema_format = LYS_IN_YIN;
} else {
/* remove the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1);
if (unlink(buf)) {
fprintf(stderr, "unlink() on \"%s\" failed (%s).\n", buf, strerror(errno));
}
}
}
}
}
static void
TEST_USES_REFINE(void **state)
{
struct state *st = (*state);
const int schemas_fail[] = {TEST_SCHEMA_LOAD_FAIL};
const int data_files_fail[] = {TEST_DATA_FILE_LOAD_FAIL};
char buf[1024];
LYS_INFORMAT schema_format = LYS_IN_YANG;
const struct lys_module *mod;
int i, j, ret;
for (i = 0; i < 2; ++i) {
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.%s", j + 1, (schema_format == LYS_IN_YANG ? "yang" : "yin"));
mod = lys_parse_path(st->ctx, buf, schema_format);
if (schemas_fail[j]) {
assert_ptr_equal(mod, NULL);
} else {
assert_ptr_not_equal(mod, NULL);
}
}
for (j = 0; j < TEST_DATA_FILE_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/data%d.xml", j + 1);
st->node = lyd_parse_path(st->ctx, buf, LYD_XML, LYD_OPT_CONFIG | LYD_OPT_NOAUTODEL);
if (data_files_fail[j]) {
assert_ptr_equal(st->node, NULL);
} else {
assert_ptr_not_equal(st->node, NULL);
}
lyd_free_withsiblings(st->node);
st->node = NULL;
}
if (schema_format == LYS_IN_YANG) {
/* convert the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, BUILD_DIR "/yang2yin "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yang "
TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1, j + 1);
ret = system(buf);
if (ret == -1) {
fprintf(stderr, "system() failed (%s).\n", strerror(errno));
fail();
} else if (WEXITSTATUS(ret) != 0) {
fprintf(stderr, "Executing command \"%s\" finished with %d.\n", buf, WEXITSTATUS(ret));
fail();
}
}
schema_format = LYS_IN_YIN;
} else {
/* remove the modules */
for (j = 0; j < TEST_SCHEMA_COUNT; ++j) {
sprintf(buf, TESTS_DIR "/conformance/" TEST_DIR "/mod%d.yin", j + 1);
if (unlink(buf)) {
fprintf(stderr, "unlink() on \"%s\" failed (%s).\n", buf, strerror(errno));
}
}
}
}
}
/**
* @brief Import content of the specified datastore for the given module from a file
* referenced by the descriptor 'fd_in'
*/
static int
srcfg_import_datastore(struct ly_ctx *ly_ctx, int fd_in, const char *module_name, srcfg_datastore_t datastore,
LYD_FORMAT format, bool permanent)
{
int rc = SR_ERR_INTERNAL;
unsigned i = 0;
struct lyd_node *new_data_tree = NULL;
struct lyd_node *current_data_tree = NULL;
struct lyd_difflist *diff = NULL;
char *first_xpath = NULL, *second_xpath = NULL;
char *input_data = NULL;
int ret = 0;
struct stat info;
CHECK_NULL_ARG2(ly_ctx, module_name);
/* parse input data */
ret = fstat(fd_in, &info);
CHECK_NOT_MINUS1_LOG_GOTO(ret, rc, SR_ERR_INTERNAL, cleanup,
"Unable to obtain input file info: %s.", sr_strerror_safe(errno));
ly_errno = LY_SUCCESS;
if (S_ISREG(info.st_mode)) {
/* load (using mmap) and parse the input data in one step */
new_data_tree = lyd_parse_fd(ly_ctx, fd_in, format, LYD_OPT_STRICT | LYD_OPT_CONFIG);
} else { /* most likely STDIN */
/* load input data into the memory first */
ret = srcfg_read_file_content(fd_in, &input_data);
CHECK_RC_MSG_GOTO(ret, cleanup, "Unable to read the input data.");
/* parse the input data stored inside memory buffer */
new_data_tree = lyd_parse_mem(ly_ctx, input_data, format, LYD_OPT_STRICT | LYD_OPT_CONFIG);
}
if (NULL == new_data_tree && LY_SUCCESS != ly_errno) {
SR_LOG_ERR("Unable to parse the input data: %s", ly_errmsg());
goto cleanup;
}
/* validate input data */
if (NULL != new_data_tree) {
ret = lyd_validate(&new_data_tree, LYD_OPT_STRICT | LYD_OPT_CONFIG | LYD_WD_IMPL_TAG);
CHECK_ZERO_LOG_GOTO(ret, rc, SR_ERR_INTERNAL, cleanup, "Input data are not valid: %s", ly_errmsg());
}
/* remove default nodes */
lyd_wd_cleanup(&new_data_tree, 0);
/* get data tree of currently stored configuration */
rc = srcfg_get_module_data(ly_ctx, module_name, ¤t_data_tree);
if (SR_ERR_OK != rc) {
goto cleanup;
}
/* get the list of changes made by the user */
diff = lyd_diff(current_data_tree, new_data_tree, 0);
if (NULL == diff) {
SR_LOG_ERR("Unable to get the list of changes: %s", ly_errmsg());
goto cleanup;
}
/* iterate over the list of differences and for each issue corresponding Sysrepo command(s) */
while (diff->type && LYD_DIFF_END != diff->type[i]) {
if (NULL != diff->first[i]) {
first_xpath = lyd_path(diff->first[i]);
if (NULL == first_xpath) {
SR_LOG_ERR("Error returned from lyd_path: %s.", ly_errmsg());
goto cleanup;
}
}
if (NULL != diff->second[i]) {
second_xpath = lyd_path(diff->second[i]);
if (NULL == second_xpath) {
free(first_xpath);
first_xpath = NULL;
SR_LOG_ERR("Error returned from lyd_path: %s.", ly_errmsg());
goto cleanup;
}
}
switch (diff->type[i]) {
case LYD_DIFF_DELETED:
SR_LOG_DBG("<LYD_DIFF_DELETED> node: %s", first_xpath);
rc = srcfg_convert_lydiff_deleted(first_xpath);
break;
case LYD_DIFF_CHANGED:
SR_LOG_DBG("<LYD_DIFF_CHANGED> orig: %s, new: %s", first_xpath, second_xpath);
rc = srcfg_convert_lydiff_changed(first_xpath, diff->second[i]);
break;
case LYD_DIFF_MOVEDAFTER1:
SR_LOG_DBG("<LYD_DIFF_MOVEDAFTER1> moved: %s, after: %s", first_xpath, second_xpath);
rc = srcfg_convert_lydiff_movedafter(first_xpath, second_xpath);
break;
case LYD_DIFF_CREATED:
SR_LOG_DBG("<LYD_DIFF_CREATED> parent: %s, new node: %s", first_xpath, second_xpath);
rc = srcfg_convert_lydiff_created(diff->second[i]);
break;
case LYD_DIFF_MOVEDAFTER2:
SR_LOG_DBG("<LYD_DIFF_MOVEDAFTER2> after: %s, this new node was inserted: %s", first_xpath, second_xpath);
rc = srcfg_convert_lydiff_movedafter(second_xpath, first_xpath);
break;
default:
assert(0 && "not reachable");
}
free(first_xpath);
free(second_xpath);
first_xpath = second_xpath = NULL;
if (SR_ERR_OK != rc) {
goto cleanup;
}
++i;
}
if (0 == i) {
SR_LOG_DBG_MSG("No changes were made.");
} else {
/* commit the changes */
rc = sr_commit(srcfg_session);
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error returned from sr_commit: %s.", sr_strerror(rc));
goto cleanup;
}
if (SRCFG_STORE_RUNNING == datastore && permanent) {
/* copy running datastore data into the startup datastore */
rc = sr_copy_config(srcfg_session, module_name, SR_DS_RUNNING, SR_DS_STARTUP);
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error returned from sr_copy_config: %s.", sr_strerror(rc));
goto cleanup;
}
}
}
rc = SR_ERR_OK;
cleanup:
if (NULL != diff) {
lyd_free_diff(diff);
}
if (NULL != current_data_tree) {
lyd_free_withsiblings(current_data_tree);
}
if (NULL != new_data_tree) {
lyd_free_withsiblings(new_data_tree);
}
if (input_data) {
free(input_data);
}
return rc;
}
/**
* @brief Get complete libyang data tree of a specified module from sysrepo.
*/
static int
srcfg_get_module_data(struct ly_ctx *ly_ctx, const char *module_name, struct lyd_node **data_tree)
{
int rc = SR_ERR_OK, ret = 0;
sr_val_t *value = NULL;
sr_val_iter_t *iter = NULL;
struct lyd_node *node = NULL;
const struct lys_node *schema = NULL;
char query[PATH_MAX] = { 0, };
char *string_val = NULL;
snprintf(query, PATH_MAX, "/%s:*//.", module_name);
rc = sr_get_items_iter(srcfg_session, query, &iter);
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error by sr_get_items_iter: %s", sr_strerror(rc));
goto cleanup;
}
*data_tree = NULL;
ly_errno = LY_SUCCESS;
ly_diminish_errors = true;
while (SR_ERR_OK == (rc = sr_get_item_next(srcfg_session, iter, &value))) {
ly_diminish_errors = false;
if (NULL == value) {
goto next;
}
/* get node schema */
schema = ly_ctx_get_node2(ly_ctx, NULL, value->xpath, 0);
if (!schema) {
SR_LOG_ERR("Error by ly_ctx_get_node2: %s", ly_errmsg());
goto fail;
}
/* skip default values */
if (schema->nodetype == LYS_LEAF && value->dflt) {
goto next;
}
/* skip non-presence containers */
if (value->type == SR_CONTAINER_T) {
goto next;
}
/* convert value to string */
rc = sr_val_to_str(value, schema, &string_val);
if (SR_ERR_OK != rc) {
SR_LOG_ERR("Error by sr_val_to_str: %s", sr_strerror(rc));
goto fail;
}
/* add node to data tree */
ly_errno = LY_SUCCESS;
node = lyd_new_path(*data_tree, ly_ctx, value->xpath, string_val, LYD_PATH_OPT_UPDATE);
if (!node && LY_SUCCESS != ly_errno) {
SR_LOG_ERR("Error by lyd_new_path: %s", ly_errmsg());
goto fail;
}
if (NULL == *data_tree) {
*data_tree = node;
}
next:
/* cleanup before next iteration */
if (NULL != string_val) {
free(string_val);
string_val = NULL;
}
if (NULL != value) {
sr_free_val(value);
value = NULL;
}
ly_diminish_errors = true;
}
ly_diminish_errors = false;
if (SR_ERR_NOT_FOUND == rc) {
rc = SR_ERR_OK;
}
if (SR_ERR_OK == rc) {
if (NULL != *data_tree) {
/* validate returned data, but most importantly resolve leafrefs */
ret = lyd_validate(data_tree, LYD_OPT_STRICT | LYD_OPT_CONFIG | LYD_WD_IMPL_TAG);
CHECK_ZERO_LOG_GOTO(ret, rc, SR_ERR_INTERNAL, fail, "Received data tree from sysrepo is not valid: %s", ly_errmsg());
/* remove default nodes added by validation */
lyd_wd_cleanup(data_tree, 0);
}
goto cleanup;
}
fail:
rc = SR_ERR_INTERNAL;
if (NULL != *data_tree) {
lyd_free_withsiblings(*data_tree);
*data_tree = NULL;
}
cleanup:
if (NULL != string_val) {
free(string_val);
}
if (NULL != value) {
sr_free_val(value);
}
if (NULL != iter) {
sr_free_val_iter(iter);
}
return rc;
}
void
createDataTreeTestModule()
{
struct ly_ctx *ctx = NULL;
struct lyd_node *node = NULL;
struct lyd_node *n = NULL;
struct lyd_node *r = NULL;
ctx = ly_ctx_new(TEST_SCHEMA_SEARCH_DIR);
assert_non_null(ctx);
const struct lys_module *module = ly_ctx_load_module(ctx, "test-module", NULL);
assert_non_null(module);
r = lyd_new(NULL, module, "main");
assert_non_null(r);
node = lyd_new_leaf(r, module, "enum", XP_TEST_MODULE_ENUM_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "raw", XP_TEST_MODULE_RAW_VALUE);
assert_non_null(node);
/*Strict = 1, Recursive = 1, Loggin = 0*/
node = lyd_new_leaf(r, module, "options", XP_TEST_MODULE_BITS_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "dec64", XP_TEST_MODULE_DEC64_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i8", XP_TEST_MODULE_INT8_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i16", XP_TEST_MODULE_INT16_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i32", XP_TEST_MODULE_INT32_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "i64", XP_TEST_MODULE_INT64_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui8", XP_TEST_MODULE_UINT8_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui16", XP_TEST_MODULE_UINT16_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui32", XP_TEST_MODULE_UINT32_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "ui64", XP_TEST_MODULE_INT64_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "empty", XP_TEST_MODULE_EMPTY_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "boolean", XP_TEST_MODULE_BOOL_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "string", XP_TEST_MODULE_STRING_VALUE);
assert_non_null(node);
node = lyd_new_leaf(r, module, "id_ref", XP_TEST_MODULE_IDREF_VALUE);
assert_non_null(node);
/* leaf -list*/
n = lyd_new_leaf(r, module, "numbers", "1");
assert_non_null(n);
n = lyd_new_leaf(r, module, "numbers", "2");
assert_non_null(n);
n = lyd_new_leaf(r, module, "numbers", "42");
assert_non_null(n);
/* list k1*/
node = lyd_new(NULL, module, "list");
assert_non_null(node);
assert_int_equal(0,lyd_insert_after(r, node));
n = lyd_new_leaf(node, module, "key", "k1");
assert_non_null(n);
n = lyd_new_leaf(node, module, "id_ref", "id_1");
assert_non_null(n);
n = lyd_new_leaf(node, module, "union", "42");
assert_non_null(n);
/* presence container*/
n = lyd_new(node, module, "wireless");
assert_non_null(n);
/* list k2*/
node = lyd_new(NULL, module, "list");
assert_non_null(node);
assert_int_equal(0, lyd_insert_after(r, node));
n = lyd_new_leaf(node, module, "key", "k2");
assert_non_null(n);
n = lyd_new_leaf(node, module, "id_ref", "id_2");
assert_non_null(n);
n = lyd_new_leaf(node, module, "union", "infinity");
assert_non_null(n);
assert_int_equal(0, lyd_validate(&r, LYD_OPT_STRICT | LYD_OPT_CONFIG));
assert_int_equal(SR_ERR_OK, sr_save_data_tree_file(TEST_MODULE_DATA_FILE_NAME, r));
lyd_free_withsiblings(r);
ly_ctx_destroy(ctx, NULL);
}
struct nc_server_reply *
op_validate(struct lyd_node *rpc, struct nc_session *ncs)
{
struct np2_sessions *sessions;
struct ly_set *nodeset;
struct nc_server_error *e = NULL;
int rc;
struct lyd_node *config = NULL;
struct lyd_node_anyxml *axml;
const char *dsname;
sr_datastore_t ds = SR_DS_CANDIDATE;
/* get sysrepo connections for this session */
sessions = (struct np2_sessions *)nc_session_get_data(ncs);
/* get know which datastore is being affected */
nodeset = lyd_get_node(rpc, "/ietf-netconf:validate/source/*");
dsname = nodeset->set.d[0]->schema->name;
axml = (struct lyd_node_anyxml *)nodeset->set.d[0];
ly_set_free(nodeset);
if (!strcmp(dsname, "running")) {
ds = SR_DS_RUNNING;
} else if (!strcmp(dsname, "startup")) {
ds = SR_DS_STARTUP;
} else if (!strcmp(dsname, "candidate")) {
ds = SR_DS_CANDIDATE;
} else if (!strcmp(dsname, "config")) {
/* get data tree to validate */
config = lyd_parse_xml(rpc->schema->module->ctx, &axml->value.xml, LYD_OPT_CONFIG | LYD_OPT_DESTRUCT);
if (ly_errno != LY_SUCCESS) {
ly_set_free(nodeset);
goto error;
}
rc = lyd_validate(&config, LYD_OPT_CONFIG, np2srv.ly_ctx);
/* cleanup */
lyd_free_withsiblings(config);
goto done;
}
/* TODO support URL */
if (ds != sessions->ds) {
/* update sysrepo session */
sr_session_switch_ds(sessions->srs, ds);
sessions->ds = ds;
}
if (ds != SR_DS_CANDIDATE) {
/* refresh datastore content */
if (sr_session_refresh(sessions->srs) != SR_ERR_OK) {
goto error;
}
}
/* validate sysrepo's datastore */
rc = sr_validate(sessions->srs);
if (rc != SR_ERR_OK) {
goto error;
}
done:
return nc_server_reply_ok();
error:
/* handle error */
if (!e) {
e = nc_err(NC_ERR_OP_FAILED, NC_ERR_TYPE_APP);
nc_err_set_msg(e, np2log_lasterr(), "en");
}
return nc_server_reply_err(e);
}
static void
test_multdfltvalues_yin(void **state)
{
struct ly_ctx *ctx = *state;
struct lyd_node *root;
const char *yin_cfg = "<module name=\"x\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
" <namespace uri=\"urn:x\"/>"
" <prefix value=\"x\"/>"
" <yang-version value=\"1.1\"/>"
" <container name=\"x\">"
" <leaf-list name=\"ll\">"
" <type name=\"string\"/>"
" <default value=\"a\"/>"
" <default value=\"a\"/>"
" </leaf-list>"
" </container>"
"</module>";
const char *yin_status_10 = "<module name=\"x\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
" <namespace uri=\"urn:x\"/>"
" <prefix value=\"x\"/>"
" <container name=\"x\">"
" <leaf-list name=\"ll\">"
" <config value=\"false\"/>"
" <type name=\"string\"/>"
" <default value=\"a\"/>"
" <default value=\"a\"/>"
" </leaf-list>"
" </container>"
"</module>";
const char *yin_status = "<module name=\"x\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
" <namespace uri=\"urn:x\"/>"
" <prefix value=\"x\"/>"
" <yang-version value=\"1.1\"/>"
" <container name=\"x\">"
" <leaf-list name=\"ll\">"
" <config value=\"false\"/>"
" <type name=\"string\"/>"
" <default value=\"a\"/>"
" <default value=\"a\"/>"
" </leaf-list>"
" </container>"
"</module>";
const char *xml = "<x xmlns=\"urn:x\"><ll>a</ll><ll>a</ll></x>";
char *printed;
/* only config leaflists must be unique, so in case of default data
* the same value can be specified as default multiple times */
assert_ptr_equal(lys_parse_mem(ctx, yin_cfg, LYS_IN_YIN), NULL);
assert_ptr_equal(lys_parse_mem(ctx, yin_status_10, LYS_IN_YIN), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, yin_status, LYS_IN_YIN), NULL);
/* for validating complete data tree, we need data from ietf-yang-library */
root = ly_ctx_info(ctx);
assert_int_equal(lyd_validate(&root, LYD_OPT_DATA, ctx), 0);
assert_ptr_not_equal(root, NULL); /* ietf-yang-library */
assert_ptr_not_equal(root->next, NULL); /* added default nodes from module x */
lyd_print_mem(&printed, root->prev, LYD_XML, LYP_WD_ALL); /* print only the default nodes from module x */
assert_string_equal(printed, xml);
free(printed);
lyd_free_withsiblings(root);
}
static void
test_multdfltvalues_yang(void **state)
{
struct ly_ctx *ctx = *state;
struct lyd_node *root;
const char *yang_cfg = "module x {"
" namespace urn:x;"
" prefix x;"
" yang-version 1.1;"
" container x {"
" leaf-list ll {"
" type string;"
" default a;"
" default a;"
" }"
" }"
"}";
const char *yang_status_10 = "module x {"
" namespace urn:x;"
" prefix x;"
" container x {"
" leaf-list ll {"
" config false;"
" type string;"
" default a;"
" default a;"
" }"
" }"
"}";
const char *yang_status = "module x {"
" namespace urn:x;"
" prefix x;"
" yang-version 1.1;"
" container x {"
" leaf-list ll {"
" config false;"
" type string;"
" default a;"
" default a;"
" }"
" }"
"}";
const char *xml = "<x xmlns=\"urn:x\"><ll>a</ll><ll>a</ll></x>";
char *printed;
/* only config leaflists must be unique, so in case of default data
* the same value can be specified as default multiple times */
assert_ptr_equal(lys_parse_mem(ctx, yang_cfg, LYS_IN_YANG), NULL);
assert_ptr_equal(lys_parse_mem(ctx, yang_status_10, LYS_IN_YANG), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, yang_status, LYS_IN_YANG), NULL);
/* for validating complete data tree, we need data from ietf-yang-library */
root = ly_ctx_info(ctx);
assert_int_equal(lyd_validate(&root, LYD_OPT_DATA, ctx), 0);
assert_ptr_not_equal(root, NULL); /* ietf-yang-library */
assert_ptr_not_equal(root->next, NULL); /* added default nodes from module x */
lyd_print_mem(&printed, root->prev, LYD_XML, LYP_WD_ALL); /* print only the default nodes from module x */
assert_string_equal(printed, xml);
free(printed);
lyd_free_withsiblings(root);
}
