static int
setup_ctx(void **state, int format)
{
//ly_verb(LY_LLVRB);
if (format == LYS_IN_YANG){
(*state) = ly_ctx_new(SCHEMA_FOLDER_YANG);
} else {
(*state) = ly_ctx_new(SCHEMA_FOLDER_YIN);
}
if (!(*state)) {
return -1;
}
return 0;
}
int
cmd_clear(const char *UNUSED(arg))
{
ly_ctx_destroy(ctx);
ctx = ly_ctx_new(search_path);
return 0;
}
static int
setup_ctx(void **state)
{
struct state *st;
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(NULL, 0);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
goto error;
}
return 0;
error:
ly_ctx_destroy(st->ctx, NULL);
free(st);
(*state) = NULL;
return -1;
}
static void
test_mult_revisions(void **state)
{
struct ly_ctx *ctx = *state;
const char *sch_yang = "module main_mod {"
"namespace \"urn:cesnet:test:a\";"
"prefix \"a\";"
"include submod_r { revision-date \"2016-06-19\";}"
"include submod1;}";
const char *sch_correct_yang = "module main_mod {"
"namespace \"urn:cesnet:test:a\";"
"prefix \"a\";"
"include submod_r;"
"include submod1;}";
const char *sch_yin = "<module name=\"main_mod\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
"<namespace uri=\"urn:cesnet:test:a\"/><prefix value=\"a\"/>"
"<include module=\"submod_r\"><revision-date date=\"2016-06-19\"/></include>"
"<include module=\"submod1\"/></module>";
const char *sch_correct_yin = "<module name=\"main_mod\" xmlns=\"urn:ietf:params:xml:ns:yang:yin:1\">"
"<namespace uri=\"urn:cesnet:test:a\"/><prefix value=\"a\"/>"
"<include module=\"submod_r\"/>"
"<include module=\"submod1\"/></module>";
ly_ctx_set_searchdir(ctx, SCHEMA_FOLDER_YIN);
assert_ptr_equal(lys_parse_mem(ctx, sch_yin, LYS_IN_YIN), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, sch_correct_yin, LYS_IN_YIN), NULL);
ly_ctx_destroy(*state, NULL);
*state = ctx = ly_ctx_new(SCHEMA_FOLDER_YANG);
assert_ptr_equal(lys_parse_mem(ctx, sch_yang, LYS_IN_YANG), NULL);
assert_ptr_not_equal(lys_parse_mem(ctx, sch_correct_yang, LYS_IN_YANG), NULL);
}
static int
setup_f(void **state)
{
struct state *st;
const char *schemafile = TESTS_DIR"/data/files/defaults.yin";
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(NULL, 0);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
goto error;
}
/* schemas */
st->mod = lys_parse_path(st->ctx, schemafile, LYS_IN_YIN);
if (!st->mod) {
fprintf(stderr, "Failed to load data model \"%s\".\n", schemafile);
goto error;
}
return 0;
error:
ly_ctx_destroy(st->ctx, NULL);
free(st);
(*state) = NULL;
return -1;
}
static int
setup_f(void **state)
{
struct state *st;
const char *schemafile = TESTS_DIR"/data/files/instance.yin";
const char *datafile = TESTS_DIR"/data/files/instance.xml";
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(NULL);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
return -1;
}
/* schema */
if (!lys_parse_path(st->ctx, schemafile, LYS_IN_YIN)) {
fprintf(stderr, "Failed to load data model \"%s\".\n", schemafile);
return -1;
}
/* data */
st->data = lyd_parse_path(st->ctx, datafile, LYD_XML, 0);
if (!st->data) {
fprintf(stderr, "Failed to load initial data file.\n");
return -1;
}
return 0;
}
static int
setup_f(void **state)
{
struct state *st;
const char *augschema = "ietf-ip";
const char *typeschema = "iana-if-type";
const char *ietfdir = TESTS_DIR"/schema/yin/ietf/";
const struct lys_module *mod;
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error.\n");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(ietfdir);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
goto error;
}
/* schema */
mod = ly_ctx_load_module(st->ctx, augschema, NULL);
if (!mod) {
fprintf(stderr, "Failed to load data module \"%s\".\n", augschema);
goto error;
}
lys_features_enable(mod, "*");
mod = ly_ctx_get_module(st->ctx, "ietf-interfaces", NULL);
if (!mod) {
fprintf(stderr, "Failed to get data module \"ietf-interfaces\".\n");
goto error;
}
lys_features_enable(mod, "*");
mod = ly_ctx_load_module(st->ctx, typeschema, NULL);
if (!mod) {
fprintf(stderr, "Failed to load data module \"%s\".\n", typeschema);
goto error;
}
/* data */
st->dt = lyd_parse_mem(st->ctx, data, LYD_XML, LYD_OPT_CONFIG);
if (!st->dt) {
fprintf(stderr, "Failed to build the data tree.\n");
goto error;
}
return 0;
error:
ly_ctx_destroy(st->ctx, NULL);
free(st);
(*state) = NULL;
return -1;
}
static int
setup_ctx(void **state)
{
*state = ly_ctx_new(NULL);
if (!*state) {
return -1;
}
return 0;
}
static void
test_ctx_new_destroy(void **state)
{
(void) state; /* unused */
ctx = ly_ctx_new(NULL);
if (!ctx) {
fail();
}
ly_ctx_destroy(ctx);
}
static int
setup_ctx_yang(void **state)
{
struct ly_ctx *ctx;
ctx = ly_ctx_new(SCHEMA_FOLDER_YANG);
assert_non_null(ctx);
*state = ctx;
return 0;
}
static int
setup_f(void **state)
{
struct state *st;
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx1 = ly_ctx_new(NULL, 0);
st->ctx2 = ly_ctx_new(NULL, 0);
if (!st->ctx1 || !st->ctx2) {
fprintf(stderr, "Failed to create context.\n");
return -1;
}
return 0;
}
void
test_parse_print_yang(void **state)
{
struct state *st = (*state);
struct stat s;
int fd;
*state = st = calloc(1, sizeof *st);
assert_ptr_not_equal(st, NULL);
st->ctx = ly_ctx_new(TESTS_DIR"/data/files");
assert_ptr_not_equal(st->ctx, NULL);
st->mod = lys_parse_path(st->ctx, TESTS_DIR"/data/files/all.yang", LYS_IN_YANG);
assert_ptr_not_equal(st->mod, NULL);
st->mod = lys_parse_path(st->ctx, TESTS_DIR"/data/files/all-dev.yang", LYS_IN_YANG);
assert_ptr_not_equal(st->mod, NULL);
fd = open(TESTS_DIR"/data/files/all-dev.yang", O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
lys_print_mem(&(st->str2), st->mod, LYS_OUT_YANG, NULL);
assert_string_equal(st->str1, st->str2);
close(fd);
fd = -1;
free(st->str1);
st->str1 = NULL;
free(st->str2);
st->str2 = NULL;
st->mod = ly_ctx_get_module(st->ctx, "all", NULL);
assert_ptr_not_equal(st->mod, NULL);
fd = open(TESTS_DIR"/data/files/all.yang", O_RDONLY);
fstat(fd, &s);
st->str1 = malloc(s.st_size + 1);
assert_ptr_not_equal(st->str1, NULL);
assert_int_equal(read(fd, st->str1, s.st_size), s.st_size);
st->str1[s.st_size] = '\0';
lys_print_mem(&(st->str2), st->mod, LYS_OUT_YANG, NULL);
assert_string_equal(st->str1, st->str2);
}
void
createDataTreeLargeExampleModule(int list_count)
{
struct ly_ctx *ctx = NULL;
struct lyd_node *root = NULL, *node = 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 MAX_XP_LEN 100
const char *template = "/example-module:container/list[key1='k1%d'][key2='k2%d']/leaf";
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
new_nacm_config(test_nacm_cfg_t **nacm_config_p)
{
test_nacm_cfg_t *nacm_config = NULL;
nacm_config = calloc(1, sizeof *nacm_config);
assert_non_null(nacm_config);
nacm_config->ly_ctx = ly_ctx_new(TEST_SCHEMA_SEARCH_DIR);
assert_non_null(nacm_config->ly_ctx);
assert_non_null(ly_ctx_load_module(nacm_config->ly_ctx, "ietf-netconf-acm@2012-02-22", NULL));
*nacm_config_p = nacm_config;
}
static void
test_lys_parse_fd(void **state)
{
(void) state; /* unused */
const struct lys_module *module;
char *yang_folder = TESTS_DIR"/api/files";
char *yin_file = TESTS_DIR"/api/files/a.yin";
char *yang_file = TESTS_DIR"/api/files/b.yang";
int fd = -1;
ctx = ly_ctx_new(yang_folder, 0);
fd = open(yin_file, O_RDONLY);
if (fd == -1) {
fail();
}
module = lys_parse_fd(ctx, fd, LYS_IN_YIN);
if (!module) {
fail();
}
close(fd);
assert_string_equal("a", module->name);
fd = open(yang_file, O_RDONLY);
if (fd == -1) {
fail();
}
module = lys_parse_fd(ctx, fd, LYS_IN_YANG);
if (!module) {
fail();
}
close(fd);
assert_string_equal("b", module->name);
module = lys_parse_mem(ctx, lys_module_a, LYS_IN_YIN);
if (module) {
fail();
}
ly_ctx_destroy(ctx, NULL);
ctx = NULL;
}
int
generic_init(char *yang_file, char *yang_folder)
{
LYS_INFORMAT yang_format;
char *schema = NULL;
struct stat sb_schema;
int fd = -1;
if (!yang_file || !yang_folder) {
goto error;
}
yang_format = LYS_IN_YIN;
ctx = ly_ctx_new(yang_folder, 0);
if (!ctx) {
goto error;
}
fd = open(yang_file, O_RDONLY);
if (fd == -1 || fstat(fd, &sb_schema) == -1 || !S_ISREG(sb_schema.st_mode)) {
goto error;
}
schema = mmap(NULL, sb_schema.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd);
if (!lys_parse_mem(ctx, schema, yang_format)) {
goto error;
}
/* cleanup */
munmap(schema, sb_schema.st_size);
return 0;
error:
if (schema) {
munmap(schema, sb_schema.st_size);
}
if (fd != -1) {
close(fd);
}
return -1;
}
static int
setup_f(void **state)
{
struct state *st;
const char *schema = TESTS_DIR"/data/files/all.yin";
const char *schemadev = TESTS_DIR"/data/files/all-dev.yin";
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(TESTS_DIR"/data/files");
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
goto error;
}
/* schema */
st->mod = lys_parse_path(st->ctx, schema, LYS_IN_YIN);
if (!st->mod) {
fprintf(stderr, "Failed to load data model \"%s\".\n", schema);
goto error;
}
lys_features_enable(st->mod, "feat2");
lys_features_enable(st->mod, "*");
st->mod = lys_parse_path(st->ctx, schemadev, LYS_IN_YIN);
if (!st->mod) {
fprintf(stderr, "Failed to load data model \"%s\".\n", schemadev);
goto error;
}
return 0;
error:
ly_ctx_destroy(st->ctx, NULL);
free(st);
(*state) = NULL;
return -1;
}
static int
setup_f(void **state)
{
struct state *st;
(*state) = st = calloc(1, sizeof *st);
if (!st) {
fprintf(stderr, "Memory allocation error");
return -1;
}
/* libyang context */
st->ctx = ly_ctx_new(TESTS_DIR "/conformance/" TEST_DIR, 0);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
return -1;
}
st->s = 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 int
setup_write(void **state)
{
(void) state; /* unused */
int fd;
struct wr *w;
w = malloc(sizeof *w);
w->session = calloc(1, sizeof *w->session);
w->session->ctx = ly_ctx_new(TESTS_DIR"../schemas");
w->session->ti_lock = malloc(sizeof *w->session->ti_lock);
pthread_mutex_init(w->session->ti_lock, NULL);
/* ietf-netconf */
fd = open(TESTS_DIR"../schemas/ietf-netconf.yin", O_RDONLY);
if (fd == -1) {
free(w);
return -1;
}
lys_parse_fd(w->session->ctx, fd, LYS_IN_YIN);
close(fd);
w->session->status = NC_STATUS_RUNNING;
w->session->version = NC_VERSION_10;
w->session->msgid = 999;
w->session->ti_type = NC_TI_FD;
w->session->ti.fd.in = STDIN_FILENO;
w->session->ti.fd.out = STDOUT_FILENO;
/* get rpc to write */
w->rpc = nc_rpc_lock(NC_DATASTORE_RUNNING);
assert_non_null(w->rpc);
w->session->ti.fd.in = -1;
*state = w;
return 0;
}
static void
test_lys_parse_mem(void **state)
{
(void) state; /* unused */
const struct lys_module *module;
char *yang_folder = TESTS_DIR"/api/files";
LYS_INFORMAT yang_format = LYS_IN_YIN;
module = NULL;
ctx = NULL;
ctx = ly_ctx_new(yang_folder, 0);
module = lys_parse_mem(ctx, lys_module_a, yang_format);
if (!module) {
fail();
}
assert_string_equal("a", module->name);
module = NULL;
module = lys_parse_mem(ctx, lys_module_a_with_typo, yang_format);
if (module) {
fail();
}
module = NULL;
module = lys_parse_mem(ctx, lys_module_b, LYS_IN_YANG);
if (!module) {
fail();
}
assert_string_equal("b", module->name);
module = NULL;
ly_ctx_destroy(ctx, NULL);
ctx = NULL;
}
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);
}
static void
test_parse_noncharacters_xml(void **state)
{
struct state *st;
const char* mod = "module x {namespace urn:x; prefix x; leaf x { type string;}}";
const char* data = "<x xmlns=\"urn:x\">----------</x>";
assert_ptr_not_equal(((*state) = st = calloc(1, sizeof *st)), NULL);
assert_ptr_not_equal((st->ctx = ly_ctx_new(NULL)), NULL);
/* test detection of invalid characters according to RFC 7950, sec 9.4 */
assert_ptr_not_equal(lys_parse_mem(st->ctx, mod, LYS_IN_YANG), 0);
assert_ptr_not_equal((st->str1 = strdup(data)), NULL);
/* exclude surrogate blocks 0xD800-DFFF - trying 0xd800 */
st->str1[17] = 0xed;
st->str1[18] = 0xa0;
st->str1[19] = 0x80;
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INCHAR);
assert_string_equal(ly_errmsg(), "Invalid UTF-8 value 0x0000d800");
/* exclude noncharacters %xFDD0-FDEF - trying 0xfdd0 */
st->str1[17] = 0xef;
st->str1[18] = 0xb7;
st->str1[19] = 0x90;
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INCHAR);
assert_string_equal(ly_errmsg(), "Invalid UTF-8 value 0x0000fdd0");
/* exclude noncharacters %xFFFE-FFFF - trying 0xfffe */
st->str1[17] = 0xef;
st->str1[18] = 0xbf;
st->str1[19] = 0xbe;
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INCHAR);
assert_string_equal(ly_errmsg(), "Invalid UTF-8 value 0x0000fffe");
/* exclude c0 control characters except tab, carriage return and line feed */
st->str1[17] = 0x9; /* valid - horizontal tab */
st->str1[18] = 0xa; /* valid - new line */
st->str1[19] = 0xd; /* valid - carriage return */
st->str1[20] = 0x6; /* invalid - ack */
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INCHAR);
assert_string_equal(ly_errmsg(), "Invalid UTF-8 value 0x06");
/* exclude noncharacters %x?FFFE-?FFFF - trying 0x10ffff */
st->str1[17] = 0xf4;
st->str1[18] = 0x8f;
st->str1[19] = 0xbf;
st->str1[20] = 0xbf;
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INCHAR);
assert_string_equal(ly_errmsg(), "Invalid UTF-8 value 0x0010ffff");
/* 0x6 */
st->str1[17] = '&';
st->str1[18] = '#';
st->str1[19] = 'x';
st->str1[20] = '6';
st->str1[21] = ';';
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INVAL);
assert_string_equal(ly_errmsg(), "Invalid character reference value.");
/* 0xdfff */
st->str1[17] = '&';
st->str1[18] = '#';
st->str1[19] = 'x';
st->str1[20] = 'd';
st->str1[21] = 'f';
st->str1[22] = 'f';
st->str1[23] = 'f';
st->str1[24] = ';';
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INVAL);
assert_string_equal(ly_errmsg(), "Invalid character reference value.");
/* 0xfdef */
st->str1[17] = '&';
st->str1[18] = '#';
st->str1[19] = 'x';
st->str1[20] = 'f';
st->str1[21] = 'd';
st->str1[22] = 'e';
st->str1[23] = 'f';
st->str1[24] = ';';
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INVAL);
assert_string_equal(ly_errmsg(), "Invalid character reference value.");
/* 0xffff */
st->str1[17] = '&';
st->str1[18] = '#';
st->str1[19] = 'x';
st->str1[20] = 'f';
st->str1[21] = 'f';
st->str1[22] = 'f';
st->str1[23] = 'f';
st->str1[24] = ';';
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INVAL);
assert_string_equal(ly_errmsg(), "Invalid character reference value.");
/* the same using character reference */
/* 0x10ffff */
st->str1[17] = '&';
st->str1[18] = '#';
st->str1[19] = 'x';
st->str1[20] = '1';
st->str1[21] = '0';
st->str1[22] = 'f';
st->str1[23] = 'f';
st->str1[24] = 'f';
st->str1[25] = 'f';
st->str1[26] = ';';
assert_ptr_equal(lyd_parse_mem(st->ctx, st->str1, LYD_XML, LYD_OPT_CONFIG), NULL);
assert_int_equal(ly_errno, LY_EVALID);
assert_int_equal(ly_vecode, LYVE_XML_INVAL);
assert_string_equal(ly_errmsg(), "Invalid character reference value.");
}
int
generic_init(char *config_file, char *yang_file, char *yang_folder)
{
LYS_INFORMAT yang_format;
LYD_FORMAT in_format;
char *schema = NULL;
char *config = NULL;
struct stat sb_schema, sb_config;
int fd = -1;
if (!config_file || !yang_file || !yang_folder) {
goto error;
}
yang_format = LYS_IN_YIN;
in_format = LYD_XML;
ctx = ly_ctx_new(yang_folder);
if (!ctx) {
goto error;
}
fd = open(yang_file, O_RDONLY);
if (fd == -1 || fstat(fd, &sb_schema) == -1 || !S_ISREG(sb_schema.st_mode)) {
goto error;
}
schema = mmap(NULL, sb_schema.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd);
fd = open(config_file, O_RDONLY);
if (fd == -1 || fstat(fd, &sb_config) == -1 || !S_ISREG(sb_config.st_mode)) {
goto error;
}
config = mmap(NULL, sb_config.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
close(fd);
fd = -1;
if (!lys_parse_data(ctx, schema, yang_format)) {
goto error;
}
root = lyd_parse_data(ctx, config, in_format, LYD_OPT_STRICT);
if (!root) {
goto error;
}
/* cleanup */
munmap(config, sb_config.st_size);
munmap(schema, sb_schema.st_size);
return 0;
error:
if (schema) {
munmap(schema, sb_schema.st_size);
}
if (config) {
munmap(config, sb_config.st_size);
}
if (fd != -1) {
close(fd);
}
return -1;
}
static void
TEST_NOTIFICATION(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);
lys_features_enable(mod, "*");
}
}
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_NOTIF, NULL);
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;
ly_ctx_destroy(st->ctx, NULL);
st->ctx = ly_ctx_new(TESTS_DIR "/conformance/" TEST_DIR);
if (!st->ctx) {
fprintf(stderr, "Failed to create context.\n");
fail();
}
} 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 Initializes libyang ctx with all schemas installed for specified module in sysrepo.
*/
static int
srcfg_ly_init(struct ly_ctx **ly_ctx, const char *module_name)
{
DIR *dp = NULL;
struct dirent *ep = NULL;
char *delim = NULL;
char schema_filename[PATH_MAX] = { 0, };
const struct lys_module *module = NULL;
CHECK_NULL_ARG2(ly_ctx, module_name);
*ly_ctx = ly_ctx_new(srcfg_schema_search_dir);
if (NULL == *ly_ctx) {
SR_LOG_ERR("Unable to initialize libyang context: %s", ly_errmsg());
return SR_ERR_INTERNAL;
}
ly_set_log_clb(srcfg_ly_log_cb, 1);
/* iterate over all files in the directory with schemas */
dp = opendir(srcfg_schema_search_dir);
if (NULL == dp) {
SR_LOG_ERR("Failed to open the schema directory: %s.", sr_strerror_safe(errno));
return SR_ERR_INTERNAL;
}
while (NULL != (ep = readdir(dp))) {
/* test file extension */
LYS_INFORMAT fmt = LYS_IN_UNKNOWN;
if (sr_str_ends_with(ep->d_name, SR_SCHEMA_YIN_FILE_EXT)) {
fmt = LYS_IN_YIN;
} else if (sr_str_ends_with(ep->d_name, SR_SCHEMA_YANG_FILE_EXT)) {
fmt = LYS_IN_YANG;
}
if (fmt != LYS_IN_UNKNOWN) {
/* strip extension and revision */
strcpy(schema_filename, ep->d_name);
delim = strrchr(schema_filename, '.');
assert(delim);
*delim = '\0';
delim = strrchr(schema_filename, '@');
if (delim) {
*delim = '\0';
}
/* TODO install all revisions and dependencies of the specified module, but not more */
#if 0 /* XXX install all schemas until we can resolve all dependencies */
if (strcmp(schema_filename, module_name) == 0) {
#endif
/* construct full file path */
snprintf(schema_filename, PATH_MAX, "%s%s", srcfg_schema_search_dir, ep->d_name);
/* load the schema into the context */
SR_LOG_DBG("Loading module schema: '%s'.", schema_filename);
module = lys_parse_path(*ly_ctx, schema_filename, fmt);
if (NULL == module) {
continue;
}
for (uint8_t i = 0; i < module->features_size; i++) {
lys_features_enable(module, module->features[i].name);
}
#if 0
}
#endif
}
}
closedir(dp);
return SR_ERR_OK;
}
static int
setup_sessions(void **state)
{
(void)state;
struct ly_ctx *ctx;
const struct lys_module *module;
const struct lys_node *node;
int sock[2];
/* create ctx */
ctx = ly_ctx_new(TESTS_DIR"../schemas");
assert_non_null(ctx);
/* load modules */
module = ly_ctx_load_module(ctx, "ietf-netconf-acm", NULL);
assert_non_null(module);
module = ly_ctx_load_module(ctx, "ietf-netconf", NULL);
assert_non_null(module);
/* set RPC callbacks */
node = lys_get_node(module, "/get");
assert_non_null(node);
lys_set_private(node, my_get_rpc_clb);
node = lys_get_node(module, "/get-config");
assert_non_null(node);
lys_set_private(node, my_getconfig_rpc_clb);
/* create communication channel */
socketpair(AF_UNIX, SOCK_STREAM, 0, sock);
nc_server_init(ctx);
/* create server session */
server_session = calloc(1, sizeof *server_session);
server_session->status = NC_STATUS_RUNNING;
server_session->side = NC_SERVER;
server_session->id = 1;
server_session->ti_type = NC_TI_FD;
server_session->ti_lock = malloc(sizeof *server_session->ti_lock);
pthread_mutex_init(server_session->ti_lock, NULL);
server_session->ti.fd.in = sock[0];
server_session->ti.fd.out = sock[0];
server_session->ctx = ctx;
server_session->flags = NC_SESSION_SHAREDCTX;
/* create client session */
client_session = calloc(1, sizeof *server_session);
client_session->status = NC_STATUS_RUNNING;
client_session->side = NC_CLIENT;
client_session->id = 1;
client_session->ti_type = NC_TI_FD;
client_session->ti_lock = malloc(sizeof *client_session->ti_lock);
pthread_mutex_init(client_session->ti_lock, NULL);
client_session->ti.fd.in = sock[1];
client_session->ti.fd.out = sock[1];
client_session->ctx = ctx;
client_session->flags = NC_SESSION_SHAREDCTX;
client_session->msgid = 50;
return 0;
}
