/**
* @file parser.c
* @author Radek Krejci <rkrejci@cesnet.cz>
* @brief common libyang parsers routines implementations
*
* Copyright (c) 2015-2017 CESNET, z.s.p.o.
*
* This source code is licensed under BSD 3-Clause License (the "License").
* You may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://opensource.org/licenses/BSD-3-Clause
*/
#define _GNU_SOURCE
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <inttypes.h>
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <pcre.h>
#include <time.h>
#include "common.h"
#include "context.h"
#include "libyang.h"
#include "parser.h"
#include "resolve.h"
#include "tree_internal.h"
#include "parser_yang.h"
#include "xpath.h"
#define LYP_URANGE_LEN 19
static char *lyp_ublock2urange[][2] = {
{"BasicLatin", "[\\x{0000}-\\x{007F}]"},
{"Latin-1Supplement", "[\\x{0080}-\\x{00FF}]"},
{"LatinExtended-A", "[\\x{0100}-\\x{017F}]"},
{"LatinExtended-B", "[\\x{0180}-\\x{024F}]"},
{"IPAExtensions", "[\\x{0250}-\\x{02AF}]"},
{"SpacingModifierLetters", "[\\x{02B0}-\\x{02FF}]"},
{"CombiningDiacriticalMarks", "[\\x{0300}-\\x{036F}]"},
{"Greek", "[\\x{0370}-\\x{03FF}]"},
{"Cyrillic", "[\\x{0400}-\\x{04FF}]"},
{"Armenian", "[\\x{0530}-\\x{058F}]"},
{"Hebrew", "[\\x{0590}-\\x{05FF}]"},
{"Arabic", "[\\x{0600}-\\x{06FF}]"},
{"Syriac", "[\\x{0700}-\\x{074F}]"},
{"Thaana", "[\\x{0780}-\\x{07BF}]"},
{"Devanagari", "[\\x{0900}-\\x{097F}]"},
{"Bengali", "[\\x{0980}-\\x{09FF}]"},
{"Gurmukhi", "[\\x{0A00}-\\x{0A7F}]"},
{"Gujarati", "[\\x{0A80}-\\x{0AFF}]"},
{"Oriya", "[\\x{0B00}-\\x{0B7F}]"},
{"Tamil", "[\\x{0B80}-\\x{0BFF}]"},
{"Telugu", "[\\x{0C00}-\\x{0C7F}]"},
{"Kannada", "[\\x{0C80}-\\x{0CFF}]"},
{"Malayalam", "[\\x{0D00}-\\x{0D7F}]"},
{"Sinhala", "[\\x{0D80}-\\x{0DFF}]"},
{"Thai", "[\\x{0E00}-\\x{0E7F}]"},
{"Lao", "[\\x{0E80}-\\x{0EFF}]"},
{"Tibetan", "[\\x{0F00}-\\x{0FFF}]"},
{"Myanmar", "[\\x{1000}-\\x{109F}]"},
{"Georgian", "[\\x{10A0}-\\x{10FF}]"},
{"HangulJamo", "[\\x{1100}-\\x{11FF}]"},
{"Ethiopic", "[\\x{1200}-\\x{137F}]"},
{"Cherokee", "[\\x{13A0}-\\x{13FF}]"},
{"UnifiedCanadianAboriginalSyllabics", "[\\x{1400}-\\x{167F}]"},
{"Ogham", "[\\x{1680}-\\x{169F}]"},
{"Runic", "[\\x{16A0}-\\x{16FF}]"},
{"Khmer", "[\\x{1780}-\\x{17FF}]"},
{"Mongolian", "[\\x{1800}-\\x{18AF}]"},
{"LatinExtendedAdditional", "[\\x{1E00}-\\x{1EFF}]"},
{"GreekExtended", "[\\x{1F00}-\\x{1FFF}]"},
{"GeneralPunctuation", "[\\x{2000}-\\x{206F}]"},
{"SuperscriptsandSubscripts", "[\\x{2070}-\\x{209F}]"},
{"CurrencySymbols", "[\\x{20A0}-\\x{20CF}]"},
{"CombiningMarksforSymbols", "[\\x{20D0}-\\x{20FF}]"},
{"LetterlikeSymbols", "[\\x{2100}-\\x{214F}]"},
{"NumberForms", "[\\x{2150}-\\x{218F}]"},
{"Arrows", "[\\x{2190}-\\x{21FF}]"},
{"MathematicalOperators", "[\\x{2200}-\\x{22FF}]"},
{"MiscellaneousTechnical", "[\\x{2300}-\\x{23FF}]"},
{"ControlPictures", "[\\x{2400}-\\x{243F}]"},
{"OpticalCharacterRecognition", "[\\x{2440}-\\x{245F}]"},
{"EnclosedAlphanumerics", "[\\x{2460}-\\x{24FF}]"},
{"BoxDrawing", "[\\x{2500}-\\x{257F}]"},
{"BlockElements", "[\\x{2580}-\\x{259F}]"},
{"GeometricShapes", "[\\x{25A0}-\\x{25FF}]"},
{"MiscellaneousSymbols", "[\\x{2600}-\\x{26FF}]"},
{"Dingbats", "[\\x{2700}-\\x{27BF}]"},
{"BraillePatterns", "[\\x{2800}-\\x{28FF}]"},
{"CJKRadicalsSupplement", "[\\x{2E80}-\\x{2EFF}]"},
{"KangxiRadicals", "[\\x{2F00}-\\x{2FDF}]"},
{"IdeographicDescriptionCharacters", "[\\x{2FF0}-\\x{2FFF}]"},
{"CJKSymbolsandPunctuation", "[\\x{3000}-\\x{303F}]"},
{"Hiragana", "[\\x{3040}-\\x{309F}]"},
{"Katakana", "[\\x{30A0}-\\x{30FF}]"},
{"Bopomofo", "[\\x{3100}-\\x{312F}]"},
{"HangulCompatibilityJamo", "[\\x{3130}-\\x{318F}]"},
{"Kanbun", "[\\x{3190}-\\x{319F}]"},
{"BopomofoExtended", "[\\x{31A0}-\\x{31BF}]"},
{"EnclosedCJKLettersandMonths", "[\\x{3200}-\\x{32FF}]"},
{"CJKCompatibility", "[\\x{3300}-\\x{33FF}]"},
{"CJKUnifiedIdeographsExtensionA", "[\\x{3400}-\\x{4DB5}]"},
{"CJKUnifiedIdeographs", "[\\x{4E00}-\\x{9FFF}]"},
{"YiSyllables", "[\\x{A000}-\\x{A48F}]"},
{"YiRadicals", "[\\x{A490}-\\x{A4CF}]"},
{"HangulSyllables", "[\\x{AC00}-\\x{D7A3}]"},
{"PrivateUse", "[\\x{E000}-\\x{F8FF}]"},
{"CJKCompatibilityIdeographs", "[\\x{F900}-\\x{FAFF}]"},
{"AlphabeticPresentationForms", "[\\x{FB00}-\\x{FB4F}]"},
{"ArabicPresentationForms-A", "[\\x{FB50}-\\x{FDFF}]"},
{"CombiningHalfMarks", "[\\x{FE20}-\\x{FE2F}]"},
{"CJKCompatibilityForms", "[\\x{FE30}-\\x{FE4F}]"},
{"SmallFormVariants", "[\\x{FE50}-\\x{FE6F}]"},
{"ArabicPresentationForms-B", "[\\x{FE70}-\\x{FEFE}]"},
{"HalfwidthandFullwidthForms", "[\\x{FF00}-\\x{FFEF}]"},
{NULL, NULL}
};
const char *ly_stmt_str[] = {
[LY_STMT_UNKNOWN] = "",
[LY_STMT_ARGUMENT] = "argument",
[LY_STMT_BASE] = "base",
[LY_STMT_BELONGSTO] = "belongs-to",
[LY_STMT_CONTACT] = "contact",
[LY_STMT_DEFAULT] = "default",
[LY_STMT_DESCRIPTION] = "description",
[LY_STMT_ERRTAG] = "error-app-tag",
[LY_STMT_ERRMSG] = "error-message",
[LY_STMT_KEY] = "key",
[LY_STMT_NAMESPACE] = "namespace",
[LY_STMT_ORGANIZATION] = "organization",
[LY_STMT_PATH] = "path",
[LY_STMT_PREFIX] = "prefix",
[LY_STMT_PRESENCE] = "presence",
[LY_STMT_REFERENCE] = "reference",
[LY_STMT_REVISIONDATE] = "revision-date",
[LY_STMT_UNITS] = "units",
[LY_STMT_VALUE] = "value",
[LY_STMT_VERSION] = "yang-version",
[LY_STMT_MODIFIER] = "modifier",
[LY_STMT_REQINSTANCE] = "require-instance",
[LY_STMT_YINELEM] = "yin-element",
[LY_STMT_CONFIG] = "config",
[LY_STMT_MANDATORY] = "mandatory",
[LY_STMT_ORDEREDBY] = "ordered-by",
[LY_STMT_STATUS] = "status",
[LY_STMT_DIGITS] = "fraction-digits",
[LY_STMT_MAX] = "max-elements",
[LY_STMT_MIN] = "min-elements",
[LY_STMT_POSITION] = "position",
[LY_STMT_UNIQUE] = "unique",
[LY_STMT_MODULE] = "module",
[LY_STMT_SUBMODULE] = "submodule",
[LY_STMT_ACTION] = "action",
[LY_STMT_ANYDATA] = "anydata",
[LY_STMT_ANYXML] = "anyxml",
[LY_STMT_CASE] = "case",
[LY_STMT_CHOICE] = "choice",
[LY_STMT_CONTAINER] = "container",
[LY_STMT_GROUPING] = "grouping",
[LY_STMT_INPUT] = "input",
[LY_STMT_LEAF] = "leaf",
[LY_STMT_LEAFLIST] = "leaf-list",
[LY_STMT_LIST] = "list",
[LY_STMT_NOTIFICATION] = "notification",
[LY_STMT_OUTPUT] = "output",
[LY_STMT_RPC] = "rpc",
[LY_STMT_USES] = "uses",
[LY_STMT_TYPEDEF] = "typedef",
[LY_STMT_TYPE] = "type",
[LY_STMT_BIT] = "bit",
[LY_STMT_ENUM] = "enum",
[LY_STMT_REFINE] = "refine",
[LY_STMT_AUGMENT] = "augment",
[LY_STMT_DEVIATE] = "deviate",
[LY_STMT_DEVIATION] = "deviation",
[LY_STMT_EXTENSION] = "extension",
[LY_STMT_FEATURE] = "feature",
[LY_STMT_IDENTITY] = "identity",
[LY_STMT_IFFEATURE] = "if-feature",
[LY_STMT_IMPORT] = "import",
[LY_STMT_INCLUDE] = "include",
[LY_STMT_LENGTH] = "length",
[LY_STMT_MUST] = "must",
[LY_STMT_PATTERN] = "pattern",
[LY_STMT_RANGE] = "range",
[LY_STMT_WHEN] = "when",
[LY_STMT_REVISION] = "revision"
};
int
lyp_is_rpc_action(struct lys_node *node)
{
assert(node);
while (lys_parent(node)) {
node = lys_parent(node);
if (node->nodetype == LYS_ACTION) {
break;
}
}
if (node->nodetype & (LYS_RPC | LYS_ACTION)) {
return 1;
} else {
return 0;
}
}
int
lyp_data_check_options(struct ly_ctx *ctx, int options, const char *func)
{
int x = options & LYD_OPT_TYPEMASK;
/* LYD_OPT_WHENAUTODEL can be used only with LYD_OPT_DATA or LYD_OPT_CONFIG */
if (options & LYD_OPT_WHENAUTODEL) {
if ((x == LYD_OPT_EDIT) || (x == LYD_OPT_NOTIF_FILTER)) {
LOGERR(ctx, LY_EINVAL, "%s: Invalid options 0x%x (LYD_OPT_DATA_WHENAUTODEL can be used only with LYD_OPT_DATA or LYD_OPT_CONFIG)",
func, options);
return 1;
}
}
if (options & (LYD_OPT_DATA_ADD_YANGLIB | LYD_OPT_DATA_NO_YANGLIB)) {
if (x != LYD_OPT_DATA) {
LOGERR(ctx, LY_EINVAL, "%s: Invalid options 0x%x (LYD_OPT_DATA_*_YANGLIB can be used only with LYD_OPT_DATA)",
func, options);
return 1;
}
}
/* "is power of 2" algorithm, with 0 exception */
if (x && !(x && !(x & (x - 1)))) {
LOGERR(ctx, LY_EINVAL, "%s: Invalid options 0x%x (multiple data type flags set).", func, options);
return 1;
}
return 0;
}
int
lyp_mmap(struct ly_ctx *ctx, int fd, size_t addsize, size_t *length, void **addr)
{
struct stat sb;
long pagesize;
size_t m;
assert(fd >= 0);
if (fstat(fd, &sb) == -1) {
LOGERR(ctx, LY_ESYS, "Failed to stat the file descriptor (%s) for the mmap().", strerror(errno));
return 1;
}
if (!S_ISREG(sb.st_mode)) {
LOGERR(ctx, LY_EINVAL, "File to mmap() is not a regular file.");
return 1;
}
if (!sb.st_size) {
*addr = NULL;
return 0;
}
pagesize = sysconf(_SC_PAGESIZE);
++addsize; /* at least one additional byte for terminating NULL byte */
m = sb.st_size % pagesize;
if (m && pagesize - m >= addsize) {
/* there will be enough space after the file content mapping to provide zeroed additional bytes */
*length = sb.st_size + addsize;
*addr = mmap(NULL, *length, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
} else {
/* there will not be enough bytes after the file content mapping for the additional bytes and some of them
* would overflow into another page that would not be zerroed and any access into it would generate SIGBUS.
* Therefore we have to do the following hack with double mapping. First, the required number of bytes
* (including the additinal bytes) is required as anonymous and thus they will be really provided (actually more
* because of using whole pages) and also initialized by zeros. Then, the file is mapped to the same address
* where the anonymous mapping starts. */
*length = sb.st_size + pagesize;
*addr = mmap(NULL, *length, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
*addr = mmap(*addr, sb.st_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_FIXED, fd, 0);
}
if (*addr == MAP_FAILED) {
LOGERR(ctx, LY_ESYS, "mmap() failed (%s).", strerror(errno));
return 1;
}
return 0;
}
int
lyp_munmap(void *addr, size_t length)
{
return munmap(addr, length);
}
int
lyp_add_ietf_netconf_annotations_config(struct lys_module *mod)
{
void *reallocated;
struct lys_ext_instance_complex *op;
struct lys_type **type;
struct lys_node_anydata *anyxml;
int i;
struct ly_ctx *ctx = mod->ctx; /* shortcut */
reallocated = realloc(mod->ext, (mod->ext_size + 3) * sizeof *mod->ext);
LY_CHECK_ERR_RETURN(!reallocated, LOGMEM(ctx), EXIT_FAILURE);
mod->ext = reallocated;
/* 1) edit-config's operation */
op = calloc(1, (sizeof(struct lys_ext_instance_complex) - 1) + 5 * sizeof(void*) + sizeof(uint16_t));
LY_CHECK_ERR_RETURN(!op, LOGMEM(ctx), EXIT_FAILURE);
mod->ext[mod->ext_size] = (struct lys_ext_instance *)op;
op->arg_value = lydict_insert(ctx, "operation", 9);
op->def = &ctx->models.list[0]->extensions[0];
op->ext_type = LYEXT_COMPLEX;
op->module = op->parent = mod;
op->parent_type = LYEXT_PAR_MODULE;
op->substmt = ((struct lyext_plugin_complex *)op->def->plugin)->substmt;
op->nodetype = LYS_EXT;
type = (struct lys_type**)&op->content; /* type is stored at offset 0 */
*type = calloc(1, sizeof(struct lys_type));
LY_CHECK_ERR_RETURN(!*type, LOGMEM(ctx), EXIT_FAILURE);
(*type)->base = LY_TYPE_ENUM;
(*type)->der = ly_types[LY_TYPE_ENUM];
(*type)->parent = (struct lys_tpdf *)op;
(*type)->info.enums.count = 5;
(*type)->info.enums.enm = calloc(5, sizeof *(*type)->info.enums.enm);
LY_CHECK_ERR_RETURN(!(*type)->info.enums.enm, LOGMEM(ctx), EXIT_FAILURE);
(*type)->info.enums.enm[0].value = 0;
(*type)->info.enums.enm[0].name = lydict_insert(ctx, "merge", 5);
(*type)->info.enums.enm[1].value = 1;
(*type)->info.enums.enm[1].name = lydict_insert(ctx, "replace", 7);
(*type)->info.enums.enm[2].value = 2;
(*type)->info.enums.enm[2].name = lydict_insert(ctx, "create", 6);
(*type)->info.enums.enm[3].value = 3;
(*type)->info.enums.enm[3].name = lydict_insert(ctx, "delete", 6);
(*type)->info.enums.enm[4].value = 4;
(*type)->info.enums.enm[4].name = lydict_insert(ctx, "remove", 6);
mod->ext_size++;
/* 2) filter's type */
op = calloc(1, (sizeof(struct lys_ext_instance_complex) - 1) + 5 * sizeof(void*) + sizeof(uint16_t));
LY_CHECK_ERR_RETURN(!op, LOGMEM(ctx), EXIT_FAILURE);
mod->ext[mod->ext_size] = (struct lys_ext_instance *)op;
op->arg_value = lydict_insert(ctx, "type", 4);
op->def = &ctx->models.list[0]->extensions[0];
op->ext_type = LYEXT_COMPLEX;
op->module = op->parent = mod;
op->parent_type = LYEXT_PAR_MODULE;
op->substmt = ((struct lyext_plugin_complex *)op->def->plugin)->substmt;
op->nodetype = LYS_EXT;
type = (struct lys_type**)&op->content; /* type is stored at offset 0 */
*type = calloc(1, sizeof(struct lys_type));
LY_CHECK_ERR_RETURN(!*type, LOGMEM(ctx), EXIT_FAILURE);
(*type)->base = LY_TYPE_ENUM;
(*type)->der = ly_types[LY_TYPE_ENUM];
(*type)->parent = (struct lys_tpdf *)op;
(*type)->info.enums.count = 2;
(*type)->info.enums.enm = calloc(2, sizeof *(*type)->info.enums.enm);
LY_CHECK_ERR_RETURN(!(*type)->info.enums.enm, LOGMEM(ctx), EXIT_FAILURE);
(*type)->info.enums.enm[0].value = 0;
(*type)->info.enums.enm[0].name = lydict_insert(ctx, "subtree", 7);
(*type)->info.enums.enm[1].value = 1;
(*type)->info.enums.enm[1].name = lydict_insert(ctx, "xpath", 5);
for (i = mod->features_size; i > 0; i--) {
if (!strcmp(mod->features[i - 1].name, "xpath")) {
(*type)->info.enums.enm[1].iffeature_size = 1;
(*type)->info.enums.enm[1].iffeature = calloc(1, sizeof(struct lys_feature));
LY_CHECK_ERR_RETURN(!(*type)->info.enums.enm[1].iffeature, LOGMEM(ctx), EXIT_FAILURE);
(*type)->info.enums.enm[1].iffeature[0].expr = malloc(sizeof(uint8_t));
LY_CHECK_ERR_RETURN(!(*type)->info.enums.enm[1].iffeature[0].expr, LOGMEM(ctx), EXIT_FAILURE);
*(*type)->info.enums.enm[1].iffeature[0].expr = 3; /* LYS_IFF_F */
(*type)->info.enums.enm[1].iffeature[0].features = malloc(sizeof(struct lys_feature*));
LY_CHECK_ERR_RETURN(!(*type)->info.enums.enm[1].iffeature[0].features, LOGMEM(ctx), EXIT_FAILURE);
(*type)->info.enums.enm[1].iffeature[0].features[0] = &mod->features[i - 1];
break;
}
}
mod->ext_size++;
/* 3) filter's select */
op = calloc(1, (sizeof(struct lys_ext_instance_complex) - 1) + 5 * sizeof(void*) + sizeof(uint16_t));
LY_CHECK_ERR_RETURN(!op, LOGMEM(ctx), EXIT_FAILURE);
mod->ext[mod->ext_size] = (struct lys_ext_instance *)op;
op->arg_value = lydict_insert(ctx, "select", 6);
op->def = &ctx->models.list[0]->extensions[0];
op->ext_type = LYEXT_COMPLEX;
op->module = op->parent = mod;
op->parent_type = LYEXT_PAR_MODULE;
op->substmt = ((struct lyext_plugin_complex *)op->def->plugin)->substmt;
op->nodetype = LYS_EXT;
type = (struct lys_type**)&op->content; /* type is stored at offset 0 */
*type = calloc(1, sizeof(struct lys_type));
LY_CHECK_ERR_RETURN(!*type, LOGMEM(ctx), EXIT_FAILURE);
(*type)->base = LY_TYPE_STRING;
(*type)->der = ly_types[LY_TYPE_STRING];
(*type)->parent = (struct lys_tpdf *)op;
mod->ext_size++;
/* 4) URL config */
anyxml = calloc(1, sizeof *anyxml);
LY_CHECK_ERR_RETURN(!anyxml, LOGMEM(ctx), EXIT_FAILURE);
anyxml->nodetype = LYS_ANYXML;
anyxml->prev = (struct lys_node *)anyxml;
anyxml->name = lydict_insert(ctx, "config", 0);
anyxml->module = mod;
anyxml->flags = LYS_CONFIG_W;
if (lys_node_addchild(NULL, mod, (struct lys_node *)anyxml, 0)) {
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/* logs directly
* base: 0 - to accept decimal, octal, hexadecimal (in default value)
* 10 - to accept only decimal (instance value)
*/
static int
parse_int(const char *val_str, int64_t min, int64_t max, int base, int64_t *ret, struct lyd_node *node)
{
char *strptr;
assert(node);
if (!val_str || !val_str[0]) {
goto error;
}
/* convert to 64-bit integer, all the redundant characters are handled */
errno = 0;
strptr = NULL;
/* parse the value */
*ret = strtoll(val_str, &strptr, base);
if (errno || (*ret < min) || (*ret > max)) {
goto error;
} else if (strptr && *strptr) {
while (isspace(*strptr)) {
++strptr;
}
if (*strptr) {
goto error;
}
}
return EXIT_SUCCESS;
error:
LOGVAL(node->schema->module->ctx, LYE_INVAL, LY_VLOG_LYD, node, val_str ? val_str : "", node->schema->name);
return EXIT_FAILURE;
}
/* logs directly
* base: 0 - to accept decimal, octal, hexadecimal (in default value)
* 10 - to accept only decimal (instance value)
*/
static int
parse_uint(const char *val_str, uint64_t max, int base, uint64_t *ret, struct lyd_node *node)
{
char *strptr;
uint64_t u;
assert(node);
if (!val_str || !val_str[0]) {
goto error;
}
errno = 0;
strptr = NULL;
u = strtoull(val_str, &strptr, base);
if (errno || (u > max)) {
goto error;
} else if (strptr && *strptr) {
while (isspace(*strptr)) {
++strptr;
}
if (*strptr) {
goto error;
}
} else if (u != 0 && val_str[0] == '-') {
goto error;
}
*ret = u;
return EXIT_SUCCESS;
error:
LOGVAL(node->schema->module->ctx, LYE_INVAL, LY_VLOG_LYD, node, val_str ? val_str : "", node->schema->name);
return EXIT_FAILURE;
}
/* logs directly
*
* kind == 0 - unsigned (unum used), 1 - signed (snum used), 2 - floating point (fnum used)
*/
static int
validate_length_range(uint8_t kind, uint64_t unum, int64_t snum, int64_t fnum, uint8_t fnum_dig, struct lys_type *type,
const char *val_str, struct lyd_node *node)
{
struct lys_restr *restr = NULL;
struct len_ran_intv *intv = NULL, *tmp_intv;
struct lys_type *cur_type;
struct ly_ctx *ctx = type->parent->module->ctx;
int match;
if (resolve_len_ran_interval(ctx, NULL, type, &intv)) {
/* already done during schema parsing */
LOGINT(ctx);
return EXIT_FAILURE;
}
if (!intv) {
return EXIT_SUCCESS;
}
/* I know that all intervals belonging to a single restriction share one type pointer */
tmp_intv = intv;
cur_type = intv->type;
do {
match = 0;
for (; tmp_intv && (tmp_intv->type == cur_type); tmp_intv = tmp_intv->next) {
if (match) {
/* just iterate through the rest of this restriction intervals */
continue;
}
if (((kind == 0) && (unum < tmp_intv->value.uval.min))
|| ((kind == 1) && (snum < tmp_intv->value.sval.min))
|| ((kind == 2) && (dec64cmp(fnum, fnum_dig, tmp_intv->value.fval.min, cur_type->info.dec64.dig) < 0))) {
break;
}
if (((kind == 0) && (unum >= tmp_intv->value.uval.min) && (unum <= tmp_intv->value.uval.max))
|| ((kind == 1) && (snum >= tmp_intv->value.sval.min) && (snum <= tmp_intv->value.sval.max))
|| ((kind == 2) && (dec64cmp(fnum, fnum_dig, tmp_intv->value.fval.min, cur_type->info.dec64.dig) > -1)
&& (dec64cmp(fnum, fnum_dig, tmp_intv->value.fval.max, cur_type->info.dec64.dig) < 1))) {
match = 1;
}
}
if (!match) {
break;
} else if (tmp_intv) {
cur_type = tmp_intv->type;
}
} while (tmp_intv);
while (intv) {
tmp_intv = intv->next;
free(intv);
intv = tmp_intv;
}
if (!match) {
switch (cur_type->base) {
case LY_TYPE_BINARY:
restr = cur_type->info.binary.length;
break;
case LY_TYPE_DEC64:
restr = cur_type->info.dec64.range;
break;
case LY_TYPE_INT8:
case LY_TYPE_INT16:
case LY_TYPE_INT32:
case LY_TYPE_INT64:
case LY_TYPE_UINT8:
case LY_TYPE_UINT16:
case LY_TYPE_UINT32:
case LY_TYPE_UINT64:
restr = cur_type->info.num.range;
break;
case LY_TYPE_STRING:
restr = cur_type->info.str.length;
break;
default:
LOGINT(ctx);
return EXIT_FAILURE;
}
LOGVAL(ctx, LYE_NOCONSTR, LY_VLOG_LYD, node, (val_str ? val_str : ""), restr ? restr->expr : "");
if (restr && restr->emsg) {
ly_vlog_str(ctx, LY_VLOG_PREV, restr->emsg);
}
if (restr && restr->eapptag) {
ly_err_last_set_apptag(ctx, restr->eapptag);
}
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/* logs directly */
static int
validate_pattern(struct ly_ctx *ctx, const char *val_str, struct lys_type *type, struct lyd_node *node)
{
int rc;
unsigned int i;
#ifndef LY_ENABLED_CACHE
pcre *precomp;
#endif
assert(ctx && (type->base == LY_TYPE_STRING));
if (!val_str) {
val_str = "";
}
if (type->der && validate_pattern(ctx, val_str, &type->der->type, node)) {
return EXIT_FAILURE;
}
#ifdef LY_ENABLED_CACHE
/* there is no cache, build it */
if (!type->info.str.patterns_pcre && type->info.str.pat_count) {
type->info.str.patterns_pcre = malloc(2 * type->info.str.pat_count * sizeof *type->info.str.patterns_pcre);
LY_CHECK_ERR_RETURN(!type->info.str.patterns_pcre, LOGMEM(ctx), -1);
for (i = 0; i < type->info.str.pat_count; ++i) {
if (lyp_precompile_pattern(ctx, &type->info.str.patterns[i].expr[1],
(pcre**)&type->info.str.patterns_pcre[i * 2],
(pcre_extra**)&type->info.str.patterns_pcre[i * 2 + 1])) {
return EXIT_FAILURE;
}
}
}
#endif
for (i = 0; i < type->info.str.pat_count; ++i) {
#ifdef LY_ENABLED_CACHE
rc = pcre_exec((pcre *)type->info.str.patterns_pcre[2 * i], (pcre_extra *)type->info.str.patterns_pcre[2 * i + 1],
val_str, strlen(val_str), 0, 0, NULL, 0);
#else
if (lyp_check_pattern(ctx, &type->info.str.patterns[i].expr[1], &precomp)) {
return EXIT_FAILURE;
}
rc = pcre_exec(precomp, NULL, val_str, strlen(val_str), 0, 0, NULL, 0);
free(precomp);
#endif
if ((rc && type->info.str.patterns[i].expr[0] == 0x06) || (!rc && type->info.str.patterns[i].expr[0] == 0x15)) {
LOGVAL(ctx, LYE_NOCONSTR, LY_VLOG_LYD, node, val_str, &type->info.str.patterns[i].expr[1]);
if (type->info.str.patterns[i].emsg) {
ly_vlog_str(ctx, LY_VLOG_PREV, type->info.str.patterns[i].emsg);
}
if (type->info.str.patterns[i].eapptag) {
ly_err_last_set_apptag(ctx, type->info.str.patterns[i].eapptag);
}
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
static void
check_number(const char *str_num, const char **num_end, LY_DATA_TYPE base)
{
if (!isdigit(str_num[0]) && (str_num[0] != '-') && (str_num[0] != '+')) {
*num_end = str_num;
return;
}
if ((str_num[0] == '-') || (str_num[0] == '+')) {
++str_num;
}
while (isdigit(str_num[0])) {
++str_num;
}
if ((base != LY_TYPE_DEC64) || (str_num[0] != '.') || !isdigit(str_num[1])) {
*num_end = str_num;
return;
}
++str_num;
while (isdigit(str_num[0])) {
++str_num;
}
*num_end = str_num;
}
/**
* @brief Checks the syntax of length or range statement,
* on success checks the semantics as well. Does not log.
*
* @param[in] expr Length or range expression.
* @param[in] type Type with the restriction.
*
* @return EXIT_SUCCESS on success, EXIT_FAILURE otherwise.
*/
int
lyp_check_length_range(struct ly_ctx *ctx, const char *expr, struct lys_type *type)
{
struct len_ran_intv *intv = NULL, *tmp_intv;
const char *c = expr, *tail;
int ret = EXIT_FAILURE, flg = 1; /* first run flag */
assert(expr);
lengthpart:
while (isspace(*c)) {
c++;
}
/* lower boundary or explicit number */
if (!strncmp(c, "max", 3)) {
max:
c += 3;
while (isspace(*c)) {
c++;
}
if (*c != '\0') {
goto error;
}
goto syntax_ok;
} else if (!strncmp(c, "min", 3)) {
if (!flg) {
/* min cannot be used elsewhere than in the first length-part */
goto error;
} else {
flg = 0;
}
c += 3;
while (isspace(*c)) {
c++;
}
if (*c == '|') {
c++;
/* process next length-parth */
goto lengthpart;
} else if (*c == '\0') {
goto syntax_ok;
} else if (!strncmp(c, "..", 2)) {
upper:
c += 2;
while (isspace(*c)) {
c++;
}
if (*c == '\0') {
goto error;
}
/* upper boundary */
if (!strncmp(c, "max", 3)) {
goto max;
}
check_number(c, &tail, type->base);
if (c == tail) {
goto error;
}
c = tail;
while (isspace(*c)) {
c++;
}
if (*c == '\0') {
goto syntax_ok;
} else if (*c == '|') {
c++;
/* process next length-parth */
goto lengthpart;
} else {
goto error;
}
} else {
goto error;
}
} else if (isdigit(*c) || (*c == '-') || (*c == '+')) {
/* number */
check_number(c, &tail, type->base);
if (c == tail) {
goto error;
}
c = tail;
while (isspace(*c)) {
c++;
}
if (*c == '|') {
c++;
/* process next length-part */
goto lengthpart;
} else if (*c == '\0') {
goto syntax_ok;
} else if (!strncmp(c, "..", 2)) {
goto upper;
}
} else {
goto error;
}
syntax_ok:
if (resolve_len_ran_interval(ctx, expr, type, &intv)) {
goto error;
}
ret = EXIT_SUCCESS;
error:
while (intv) {
tmp_intv = intv->next;
free(intv);
intv = tmp_intv;
}
return ret;
}
/**
* @brief Checks pattern syntax. Logs directly.
*
* @param[in] pattern Pattern to check.
* @param[out] pcre_precomp Precompiled PCRE pattern. Can be NULL.
* @return EXIT_SUCCESS on success, EXIT_FAILURE otherwise.
*/
int
lyp_check_pattern(struct ly_ctx *ctx, const char *pattern, pcre **pcre_precomp)
{
int idx, idx2, start, end, err_offset, count;
char *perl_regex, *ptr;
const char *err_msg, *orig_ptr;
pcre *precomp;
/*
* adjust the expression to a Perl equivalent
*
* http://www.w3.org/TR/2004/REC-xmlschema-2-20041028/#regexs
*/
/* we need to replace all "$" with "\$", count them now */
for (count = 0, ptr = strchr(pattern, '$'); ptr; ++count, ptr = strchr(ptr + 1, '$'));
perl_regex = malloc((strlen(pattern) + 4 + count) * sizeof(char));
LY_CHECK_ERR_RETURN(!perl_regex, LOGMEM(ctx), EXIT_FAILURE);
perl_regex[0] = '\0';
ptr = perl_regex;
if (strncmp(pattern + strlen(pattern) - 2, ".*", 2)) {
/* we wil add line-end anchoring */
ptr[0] = '(';
++ptr;
}
for (orig_ptr = pattern; orig_ptr[0]; ++orig_ptr) {
if (orig_ptr[0] == '$') {
ptr += sprintf(ptr, "\\$");
} else {
ptr[0] = orig_ptr[0];
++ptr;
}
}
if (strncmp(pattern + strlen(pattern) - 2, ".*", 2)) {
ptr += sprintf(ptr, ")$");
} else {
ptr[0] = '\0';
++ptr;
}
/* substitute Unicode Character Blocks with exact Character Ranges */
while ((ptr = strstr(perl_regex, "\\p{Is"))) {
start = ptr - perl_regex;
ptr = strchr(ptr, '}');
if (!ptr) {
LOGVAL(ctx, LYE_INREGEX, LY_VLOG_NONE, NULL, pattern, perl_regex + start + 2, "unterminated character property");
free(perl_regex);
return EXIT_FAILURE;
}
end = (ptr - perl_regex) + 1;
/* need more space */
if (end - start < LYP_URANGE_LEN) {
perl_regex = ly_realloc(perl_regex, strlen(perl_regex) + (LYP_URANGE_LEN - (end - start)) + 1);
LY_CHECK_ERR_RETURN(!perl_regex, LOGMEM(ctx); free(perl_regex), EXIT_FAILURE);
}
/* find our range */
for (idx = 0; lyp_ublock2urange[idx][0]; ++idx) {
if (!strncmp(perl_regex + start + 5, lyp_ublock2urange[idx][0], strlen(lyp_ublock2urange[idx][0]))) {
break;
}
}
if (!lyp_ublock2urange[idx][0]) {
LOGVAL(ctx, LYE_INREGEX, LY_VLOG_NONE, NULL, pattern, perl_regex + start + 5, "unknown block name");
free(perl_regex);
return EXIT_FAILURE;
}
/* make the space in the string and replace the block (but we cannot include brackets if it was already enclosed in them) */
for (idx2 = 0, count = 0; idx2 < start; ++idx2) {
if ((perl_regex[idx2] == '[') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
++count;
}
if ((perl_regex[idx2] == ']') && (!idx2 || (perl_regex[idx2 - 1] != '\\'))) {
--count;
}
}
if (count) {
/* skip brackets */
memmove(perl_regex + start + (LYP_URANGE_LEN - 2), perl_regex + end, strlen(perl_regex + end) + 1);
memcpy(perl_regex + start, lyp_ublock2urange[idx][1] + 1, LYP_URANGE_LEN - 2);
} else {
memmove(perl_regex + start + LYP_URANGE_LEN, perl_regex + end, strlen(perl_regex + end) + 1);
memcpy(perl_regex + start, lyp_ublock2urange[idx][1], LYP_URANGE_LEN);
}
}
/* must return 0, already checked during parsing */
precomp = pcre_compile(perl_regex, PCRE_ANCHORED | PCRE_DOLLAR_ENDONLY | PCRE_NO_AUTO_CAPTURE,
&err_msg, &err_offset, NULL);
if (!precomp) {
LOGVAL(ctx, LYE_INREGEX, LY_VLOG_NONE, NULL, pattern, perl_regex + err_offset, err_msg);
free(perl_regex);
return EXIT_FAILURE;
}
free(perl_regex);
if (pcre_precomp) {
*pcre_precomp = precomp;
} else {
free(precomp);
}
return EXIT_SUCCESS;
}
int
lyp_precompile_pattern(struct ly_ctx *ctx, const char *pattern, pcre** pcre_cmp, pcre_extra **pcre_std)
{
const char *err_msg = NULL;
if (lyp_check_pattern(ctx, pattern, pcre_cmp)) {
return EXIT_FAILURE;
}
if (pcre_std && pcre_cmp) {
(*pcre_std) = pcre_study(*pcre_cmp, 0, &err_msg);
if (err_msg) {
LOGWRN(ctx, "Studying pattern \"%s\" failed (%s).", pattern, err_msg);
}
}
return EXIT_SUCCESS;
}
/**
* @brief Change the value into its canonical form. In libyang, additionally to the RFC,
* all identities have their module as a prefix in their canonical form.
*
* @param[in] ctx
* @param[in] type Type of the value.
* @param[in,out] value Original and then canonical value.
* @param[in] data1 If \p type is #LY_TYPE_BITS: (struct lys_type_bit **) type bit field,
* #LY_TYPE_DEC64: (int64_t *) parsed digits of the number itself without floating point,
* #LY_TYPE_IDENT: (const char *) local module name (identityref node module),
* #LY_TYPE_INT*: (int64_t *) parsed int number itself,
* #LY_TYPE_UINT*: (uint64_t *) parsed uint number itself,
* otherwise ignored.
* @param[in] data2 If \p type is #LY_TYPE_BITS: (int *) type bit field length,
* #LY_TYPE_DEC64: (uint8_t *) number of fraction digits (position of the floating point),
* otherwise ignored.
* @return 1 if a conversion took place, 0 if the value was kept the same, -1 on error.
*/
static int
make_canonical(struct ly_ctx *ctx, int type, const char **value, void *data1, void *data2)
{
const uint16_t buf_len = 511;
char buf[buf_len + 1];
struct lys_type_bit **bits = NULL;
struct lyxp_expr *exp;
const char *module_name, *cur_expr, *end;
int i, j, count;
int64_t num;
uint64_t unum;
uint8_t c;
#define LOGBUF(str) LOGERR(ctx, LY_EINVAL, "Value \"%s\" is too long.", str)
switch (type) {
case LY_TYPE_BITS:
bits = (struct lys_type_bit **)data1;
count = *((int *)data2);
/* in canonical form, the bits are ordered by their position */
buf[0] = '\0';
for (i = 0; i < count; i++) {
if (!bits[i]) {
/* bit not set */
continue;
}
if (buf[0]) {
LY_CHECK_ERR_RETURN(strlen(buf) + 1 + strlen(bits[i]->name) > buf_len, LOGBUF(bits[i]->name), -1);
sprintf(buf + strlen(buf), " %s", bits[i]->name);
} else {
LY_CHECK_ERR_RETURN(strlen(bits[i]->name) > buf_len, LOGBUF(bits[i]->name), -1);
strcpy(buf, bits[i]->name);
}
}
break;
case LY_TYPE_IDENT:
module_name = (const char *)data1;
/* identity must always have a prefix */
if (!strchr(*value, ':')) {
sprintf(buf, "%s:%s", module_name, *value);
} else {
strcpy(buf, *value);
}
break;
case LY_TYPE_INST:
exp = lyxp_parse_expr(ctx, *value);
LY_CHECK_ERR_RETURN(!exp, LOGINT(ctx), -1);
module_name = NULL;
count = 0;
for (i = 0; (unsigned)i < exp->used; ++i) {
cur_expr = &exp->expr[exp->expr_pos[i]];
/* copy WS */
if (i && ((end = exp->expr + exp->expr_pos[i - 1] + exp->tok_len[i - 1]) != cur_expr)) {
if (count + (cur_expr - end) > buf_len) {
lyxp_expr_free(exp);
LOGBUF(end);
return -1;
}
strncpy(&buf[count], end, cur_expr - end);
count += cur_expr - end;
}
if ((exp->tokens[i] == LYXP_TOKEN_NAMETEST) && (end = strnchr(cur_expr, ':', exp->tok_len[i]))) {
/* get the module name with ":" */
++end;
j = end - cur_expr;
if (!module_name || strncmp(cur_expr, module_name, j)) {
/* print module name with colon, it does not equal to the parent one */
if (count + j > buf_len) {
lyxp_expr_free(exp);
LOGBUF(cur_expr);
return -1;
}
strncpy(&buf[count], cur_expr, j);
count += j;
}
module_name = cur_expr;
/* copy the rest */
if (count + (exp->tok_len[i] - j) > buf_len) {
lyxp_expr_free(exp);
LOGBUF(end);
return -1;
}
strncpy(&buf[count], end, exp->tok_len[i] - j);
count += exp->tok_len[i] - j;
} else {
if (count + exp->tok_len[i] > buf_len) {
LOGBUF(&exp->expr[exp->expr_pos[i]]);
lyxp_expr_free(exp);
return -1;
}
strncpy(&buf[count], &exp->expr[exp->expr_pos[i]], exp->tok_len[i]);
count += exp->tok_len[i];
}
}
if (count > buf_len) {
LOGINT(ctx);
lyxp_expr_free(exp);
return -1;
}
buf[count] = '\0';
lyxp_expr_free(exp);
break;
case LY_TYPE_DEC64:
num = *((int64_t *)data1);
c = *((uint8_t *)data2);
if (num) {
count = sprintf(buf, "%"PRId64" ", num);
if ( (num > 0 && (count - 1) <= c)
|| (count - 2) <= c ) {
/* we have 0. value, print the value with the leading zeros
* (one for 0. and also keep the correct with of num according
* to fraction-digits value)
* for (num<0) - extra character for '-' sign */
count = sprintf(buf, "%0*"PRId64" ", (num > 0) ? (c + 1) : (c + 2), num);
}
for (i = c, j = 1; i > 0 ; i--) {
if (j && i > 1 && buf[count - 2] == '0') {
/* we have trailing zero to skip */
buf[count - 1] = '\0';
} else {
j = 0;
buf[count - 1] = buf[count - 2];
}
count--;
}
buf[count - 1] = '.';
} else {
/* zero */
sprintf(buf, "0.0");
}
break;
case LY_TYPE_INT8:
case LY_TYPE_INT16:
case LY_TYPE_INT32:
case LY_TYPE_INT64:
num = *((int64_t *)data1);
sprintf(buf, "%"PRId64, num);
break;
case LY_TYPE_UINT8:
case LY_TYPE_UINT16:
case LY_TYPE_UINT32:
case LY_TYPE_UINT64:
unum = *((uint64_t *)data1);
sprintf(buf, "%"PRIu64, unum);
break;
default:
/* should not be even called - just do nothing */
return 0;
}
if (strcmp(buf, *value)) {
lydict_remove(ctx, *value);
*value = lydict_insert(ctx, buf, 0);
return 1;
}
return 0;
#undef LOGBUF
}
static const char *
ident_val_add_module_prefix(const char *value, const struct lyxml_elem *xml, struct ly_ctx *ctx)
{
const struct lyxml_ns *ns;
const struct lys_module *mod;
char *str;
do {
LY_TREE_FOR((struct lyxml_ns *)xml->attr, ns) {
if ((ns->type == LYXML_ATTR_NS) && !ns->prefix) {
/* match */
break;
}
}
if (!ns) {
xml = xml->parent;
}
} while (!ns && xml);
if (!ns) {
/* no default namespace */
LOGINT(ctx);
return NULL;
}
/* find module */
mod = ly_ctx_get_module_by_ns(ctx, ns->value, NULL, 1);
if (!mod) {
LOGINT(ctx);
return NULL;
}
if (asprintf(&str, "%s:%s", mod->name, value) == -1) {
LOGMEM(ctx);
return NULL;
}
lydict_remove(ctx, value);
return lydict_insert_zc(ctx, str);
}
/*
* xml - optional for converting instance-identifier and identityref into JSON format
* leaf - mandatory to know the context (necessary e.g. for prefixes in idenitytref values)
* attr - alternative to leaf in case of parsing value in annotations (attributes)
* local_mod - optional if the local module dos not match the module of leaf/attr
* store - flag for union resolution - we do not want to store the result, we are just learning the type
* dflt - whether the value is a default value from the schema
* trusted - whether the value is trusted to be valid (but may not be canonical, so it is canonized)
*/
struct lys_type *
lyp_parse_value(struct lys_type *type, const char **value_, struct lyxml_elem *xml,
struct lyd_node_leaf_list *leaf, struct lyd_attr *attr, struct lys_module *local_mod,
int store, int dflt, int trusted)
{
struct lys_type *ret = NULL, *t;
struct lys_tpdf *tpdf;
enum int_log_opts prev_ilo;
int c, len, found = 0;
unsigned int i, j;
int64_t num;
uint64_t unum, uind, u = 0;
const char *ptr, *value = *value_, *itemname;
struct lys_type_bit **bits = NULL;
struct lys_ident *ident;
lyd_val *val, old_val;
LY_DATA_TYPE *val_type, old_val_type;
uint8_t *val_flags, old_val_flags;
struct lyd_node *contextnode;
struct ly_ctx *ctx = type->parent->module->ctx;
assert(leaf || attr);
if (leaf) {
assert(!attr);
if (!local_mod) {
local_mod = leaf->schema->module;
}
val = &leaf->value;
val_type = &leaf->value_type;
val_flags = &leaf->value_flags;
contextnode = (struct lyd_node *)leaf;
itemname = leaf->schema->name;
} else {
assert(!leaf);
if (!local_mod) {
local_mod = attr->annotation->module;
}
val = &attr->value;
val_type = &attr->value_type;
val_flags = &attr->value_flags;
contextnode = attr->parent;
itemname = attr->name;
}
/* fully clear the value */
if (store) {
lyd_free_value(*val, *val_type, *val_flags, type, &old_val, &old_val_type, &old_val_flags);
*val_flags &= ~LY_VALUE_UNRES;
}
switch (type->base) {
case LY_TYPE_BINARY:
/* get number of octets for length validation */
unum = 0;
ptr = NULL;
if (value) {
/* silently skip leading/trailing whitespaces */
for (uind = 0; isspace(value[uind]); ++uind);
ptr = &value[uind];
u = strlen(ptr);
while (u && isspace(ptr[u - 1])) {
--u;
}
unum = u;
for (uind = 0; uind < u; ++uind) {
if (ptr[uind] == '\n') {
unum--;
} else if ((ptr[uind] < '/' && ptr[uind] != '+') ||
(ptr[uind] > '9' && ptr[uind] < 'A') ||
(ptr[uind] > 'Z' && ptr[uind] < 'a') || ptr[uind] > 'z') {
if (ptr[uind] == '=') {
/* padding */
if (uind == u - 2 && ptr[uind + 1] == '=') {
found = 2;
uind++;
} else if (uind == u - 1) {
found = 1;
}
}
if (!found) {
/* error */
LOGVAL(ctx, LYE_INCHAR, LY_VLOG_LYD, contextnode, ptr[uind], &ptr[uind]);
LOGVAL(ctx, LYE_SPEC, LY_VLOG_PREV, NULL, "Invalid Base64 character.");
goto error;
}
}
}
}
if (unum & 3) {
/* base64 length must be multiple of 4 chars */
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
LOGVAL(ctx, LYE_SPEC, LY_VLOG_PREV, NULL, "Base64 encoded value length must be divisible by 4.");
goto error;
}
/* length of the encoded string */
len = ((unum / 4) * 3) - found;
if (!trusted && validate_length_range(0, len, 0, 0, 0, type, value, contextnode)) {
goto error;
}
if (value && (ptr != value || ptr[u] != '\0')) {
/* update the changed value */
ptr = lydict_insert(ctx, ptr, u);
lydict_remove(ctx, *value_);
*value_ = ptr;
}
if (store) {
/* store the result */
val->binary = value;
*val_type = LY_TYPE_BINARY;
}
break;
case LY_TYPE_BITS:
/* locate bits structure with the bits definitions
* since YANG 1.1 allows restricted bits, it is the first
* bits type with some explicit bit specification */
for (; !type->info.bits.count; type = &type->der->type);
if (value || store) {
/* allocate the array of pointers to bits definition */
bits = calloc(type->info.bits.count, sizeof *bits);
LY_CHECK_ERR_GOTO(!bits, LOGMEM(ctx), error);
}
if (!value) {
/* no bits set */
if (store) {
/* store empty array */
val->bit = bits;
*val_type = LY_TYPE_BITS;
}
break;
}
c = 0;
i = 0;
while (value[c]) {
/* skip leading whitespaces */
while (isspace(value[c])) {
c++;
}
if (!value[c]) {
/* trailing white spaces */
break;
}
/* get the length of the bit identifier */
for (len = 0; value[c] && !isspace(value[c]); c++, len++);
/* go back to the beginning of the identifier */
c = c - len;
/* find bit definition, identifiers appear ordered by their posititon */
for (found = i = 0; i < type->info.bits.count; i++) {
if (!strncmp(type->info.bits.bit[i].name, &value[c], len) && !type->info.bits.bit[i].name[len]) {
/* we have match, check if the value is enabled ... */
for (j = 0; !trusted && (j < type->info.bits.bit[i].iffeature_size); j++) {
if (!resolve_iffeature(&type->info.bits.bit[i].iffeature[j])) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
LOGVAL(ctx, LYE_SPEC, LY_VLOG_PREV, NULL,
"Bit \"%s\" is disabled by its %d. if-feature condition.",
type->info.bits.bit[i].name, j + 1);
free(bits);
goto error;
}
}
/* check that the value was not already set */
if (bits[i]) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
LOGVAL(ctx, LYE_SPEC, LY_VLOG_PREV, NULL, "Bit \"%s\" used multiple times.",
type->info.bits.bit[i].name);
free(bits);
goto error;
}
/* ... and then store the pointer */
bits[i] = &type->info.bits.bit[i];
/* stop searching */
found = 1;
break;
}
}
if (!found) {
/* referenced bit value does not exist */
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
free(bits);
goto error;
}
c = c + len;
}
if (make_canonical(ctx, LY_TYPE_BITS, value_, bits, &type->info.bits.count) == -1) {
free(bits);
goto error;
}
if (store) {
/* store the result */
val->bit = bits;
*val_type = LY_TYPE_BITS;
} else {
free(bits);
}
break;
case LY_TYPE_BOOL:
if (value && !strcmp(value, "true")) {
if (store) {
val->bln = 1;
}
} else if (!value || strcmp(value, "false")) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value ? value : "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value ? value : "");
}
goto error;
} else {
if (store) {
val->bln = 0;
}
}
if (store) {
*val_type = LY_TYPE_BOOL;
}
break;
case LY_TYPE_DEC64:
if (!value || !value[0]) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, "");
}
goto error;
}
ptr = value;
if (parse_range_dec64(&ptr, type->info.dec64.dig, &num) || ptr[0]) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
goto error;
}
if (!trusted && validate_length_range(2, 0, 0, num, type->info.dec64.dig, type, value, contextnode)) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_DEC64, value_, &num, &type->info.dec64.dig) == -1) {
goto error;
}
if (store) {
/* store the result */
val->dec64 = num;
*val_type = LY_TYPE_DEC64;
}
break;
case LY_TYPE_EMPTY:
if (value && value[0]) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
goto error;
}
if (store) {
*val_type = LY_TYPE_EMPTY;
}
break;
case LY_TYPE_ENUM:
/* locate enums structure with the enumeration definitions,
* since YANG 1.1 allows restricted enums, it is the first
* enum type with some explicit enum specification */
for (; !type->info.enums.count; type = &type->der->type);
/* find matching enumeration value */
for (i = found = 0; i < type->info.enums.count; i++) {
if (value && !strcmp(value, type->info.enums.enm[i].name)) {
/* we have match, check if the value is enabled ... */
for (j = 0; !trusted && (j < type->info.enums.enm[i].iffeature_size); j++) {
if (!resolve_iffeature(&type->info.enums.enm[i].iffeature[j])) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
LOGVAL(ctx, LYE_SPEC, LY_VLOG_PREV, NULL, "Enum \"%s\" is disabled by its %d. if-feature condition.",
value, j + 1);
goto error;
}
}
/* ... and store pointer to the definition */
if (store) {
val->enm = &type->info.enums.enm[i];
*val_type = LY_TYPE_ENUM;
}
found = 1;
break;
}
}
if (!found) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value ? value : "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value ? value : "");
}
goto error;
}
break;
case LY_TYPE_IDENT:
if (!value) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, "");
}
goto error;
}
if (xml) {
ly_ilo_change(NULL, ILO_IGNORE, &prev_ilo, NULL);
/* first, convert value into the json format, silently */
value = transform_xml2json(ctx, value, xml, 0, 0);
ly_ilo_restore(NULL, prev_ilo, NULL, 0);
if (!value) {
/* invalid identityref format */
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, *value_, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, *value_);
}
goto error;
}
/* the value has no prefix (default namespace), but the element's namespace has a prefix, find default namespace */
if (!strchr(value, ':') && xml->ns->prefix) {
value = ident_val_add_module_prefix(value, xml, ctx);
if (!value) {
goto error;
}
}
} else if (dflt) {
ly_ilo_change(NULL, ILO_IGNORE, &prev_ilo, NULL);
/* the value actually uses module's prefixes instead of the module names as in JSON format,
* we have to convert it */
value = transform_schema2json(local_mod, value);
ly_ilo_restore(NULL, prev_ilo, NULL, 0);
if (!value) {
/* invalid identityref format or it was already transformed, so ignore the error here */
value = lydict_insert(ctx, *value_, 0);
}
} else {
value = lydict_insert(ctx, *value_, 0);
}
/* value is now in the dictionary, whether it differs from *value_ or not */
ident = resolve_identref(type, value, contextnode, local_mod, dflt);
if (!ident) {
lydict_remove(ctx, value);
goto error;
} else if (store) {
/* store the result */
val->ident = ident;
*val_type = LY_TYPE_IDENT;
}
/* the value is always changed and includes prefix */
if (dflt) {
type->parent->flags |= LYS_DFLTJSON;
}
if (make_canonical(ctx, LY_TYPE_IDENT, &value, (void*)lys_main_module(local_mod)->name, NULL) == -1) {
lydict_remove(ctx, value);
goto error;
}
/* replace the old value with the new one (even if they may be the same) */
lydict_remove(ctx, *value_);
*value_ = value;
break;
case LY_TYPE_INST:
if (!value) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, "");
}
goto error;
}
if (xml) {
ly_ilo_change(NULL, ILO_IGNORE, &prev_ilo, NULL);
/* first, convert value into the json format, silently */
value = transform_xml2json(ctx, value, xml, 1, 1);
ly_ilo_restore(NULL, prev_ilo, NULL, 0);
if (!value) {
/* invalid instance-identifier format */
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, *value_, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, *value_);
}
goto error;
} else if (ly_strequal(value, *value_, 1)) {
/* we have actually created the same expression (prefixes are the same as the module names)
* so we have just increased dictionary's refcount - fix it */
lydict_remove(ctx, value);
}
} else if (dflt) {
/* turn logging off */
ly_ilo_change(NULL, ILO_IGNORE, &prev_ilo, NULL);
/* the value actually uses module's prefixes instead of the module names as in JSON format,
* we have to convert it */
value = transform_schema2json(local_mod, value);
if (!value) {
/* invalid identityref format or it was already transformed, so ignore the error here */
value = *value_;
} else if (ly_strequal(value, *value_, 1)) {
/* we have actually created the same expression (prefixes are the same as the module names)
* so we have just increased dictionary's refcount - fix it */
lydict_remove(ctx, value);
}
/* turn logging back on */
ly_ilo_restore(NULL, prev_ilo, NULL, 0);
} else {
if ((c = make_canonical(ctx, LY_TYPE_INST, &value, NULL, NULL))) {
if (c == -1) {
goto error;
}
/* if a change occured, value was removed from the dicionary so fix the pointers */
*value_ = value;
}
}
if (store) {
/* note that the data node is an unresolved instance-identifier */
val->instance = NULL;
*val_type = LY_TYPE_INST;
*val_flags |= LY_VALUE_UNRES;
}
if (!ly_strequal(value, *value_, 1)) {
/* update the changed value */
lydict_remove(ctx, *value_);
*value_ = value;
/* we have to remember the conversion into JSON format to be able to print it in correct form */
if (dflt) {
type->parent->flags |= LYS_DFLTJSON;
}
}
break;
case LY_TYPE_LEAFREF:
if (!value) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, "");
}
goto error;
}
/* it is called not only to get the final type, but mainly to update value to canonical or JSON form
* if needed */
t = lyp_parse_value(&type->info.lref.target->type, value_, xml, leaf, attr, NULL, store, dflt, trusted);
value = *value_; /* refresh possibly changed value */
if (!t) {
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, value, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, value);
}
goto error;
}
if (store) {
/* make the note that the data node is an unresolved leafref (value union was already filled) */
*val_flags |= LY_VALUE_UNRES;
}
type = t;
break;
case LY_TYPE_STRING:
if (!trusted && validate_length_range(0, (value ? strlen(value) : 0), 0, 0, 0, type, value, contextnode)) {
goto error;
}
if (!trusted && validate_pattern(ctx, value, type, contextnode)) {
goto error;
}
/* special handling of ietf-yang-types xpath1.0 */
for (tpdf = type->der;
tpdf->module && (strcmp(tpdf->name, "xpath1.0") || strcmp(tpdf->module->name, "ietf-yang-types"));
tpdf = tpdf->type.der);
if (tpdf->module && xml) {
/* convert value into the json format */
value = transform_xml2json(ctx, value, xml, 1, 1);
if (!value) {
/* invalid instance-identifier format */
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, *value_, itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, *value_);
}
goto error;
}
if (!ly_strequal(value, *value_, 1)) {
/* update the changed value */
lydict_remove(ctx, *value_);
*value_ = value;
}
}
if (store) {
/* store the result */
val->string = value;
*val_type = LY_TYPE_STRING;
}
break;
case LY_TYPE_INT8:
if (parse_int(value, __INT64_C(-128), __INT64_C(127), dflt ? 0 : 10, &num, contextnode)
|| (!trusted && validate_length_range(1, 0, num, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_INT8, value_, &num, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->int8 = (int8_t)num;
*val_type = LY_TYPE_INT8;
}
break;
case LY_TYPE_INT16:
if (parse_int(value, __INT64_C(-32768), __INT64_C(32767), dflt ? 0 : 10, &num, contextnode)
|| (!trusted && validate_length_range(1, 0, num, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_INT16, value_, &num, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->int16 = (int16_t)num;
*val_type = LY_TYPE_INT16;
}
break;
case LY_TYPE_INT32:
if (parse_int(value, __INT64_C(-2147483648), __INT64_C(2147483647), dflt ? 0 : 10, &num, contextnode)
|| (!trusted && validate_length_range(1, 0, num, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_INT32, value_, &num, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->int32 = (int32_t)num;
*val_type = LY_TYPE_INT32;
}
break;
case LY_TYPE_INT64:
if (parse_int(value, __INT64_C(-9223372036854775807) - __INT64_C(1), __INT64_C(9223372036854775807),
dflt ? 0 : 10, &num, contextnode)
|| (!trusted && validate_length_range(1, 0, num, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_INT64, value_, &num, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->int64 = num;
*val_type = LY_TYPE_INT64;
}
break;
case LY_TYPE_UINT8:
if (parse_uint(value, __UINT64_C(255), dflt ? 0 : 10, &unum, contextnode)
|| (!trusted && validate_length_range(0, unum, 0, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_UINT8, value_, &unum, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->uint8 = (uint8_t)unum;
*val_type = LY_TYPE_UINT8;
}
break;
case LY_TYPE_UINT16:
if (parse_uint(value, __UINT64_C(65535), dflt ? 0 : 10, &unum, contextnode)
|| (!trusted && validate_length_range(0, unum, 0, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_UINT16, value_, &unum, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->uint16 = (uint16_t)unum;
*val_type = LY_TYPE_UINT16;
}
break;
case LY_TYPE_UINT32:
if (parse_uint(value, __UINT64_C(4294967295), dflt ? 0 : 10, &unum, contextnode)
|| (!trusted && validate_length_range(0, unum, 0, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_UINT32, value_, &unum, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->uint32 = (uint32_t)unum;
*val_type = LY_TYPE_UINT32;
}
break;
case LY_TYPE_UINT64:
if (parse_uint(value, __UINT64_C(18446744073709551615), dflt ? 0 : 10, &unum, contextnode)
|| (!trusted && validate_length_range(0, unum, 0, 0, 0, type, value, contextnode))) {
goto error;
}
if (make_canonical(ctx, LY_TYPE_UINT64, value_, &unum, NULL) == -1) {
goto error;
}
if (store) {
/* store the result */
val->uint64 = unum;
*val_type = LY_TYPE_UINT64;
}
break;
case LY_TYPE_UNION:
if (store) {
/* unresolved union type */
memset(val, 0, sizeof(lyd_val));
*val_type = LY_TYPE_UNION;
}
if (type->info.uni.has_ptr_type) {
/* we are not resolving anything here, only parsing, and in this case we cannot decide
* the type without resolving it -> we return the union type (resolve it with resolve_union()) */
if (xml) {
/* in case it should resolve into a instance-identifier, we can only do the JSON conversion here */
ly_ilo_change(NULL, ILO_IGNORE, &prev_ilo, NULL);
val->string = transform_xml2json(ctx, value, xml, 1, 1);
ly_ilo_restore(NULL, prev_ilo, NULL, 0);
if (!val->string) {
/* invalid instance-identifier format, likely some other type */
val->string = lydict_insert(ctx, value, 0);
}
}
break;
}
t = NULL;
found = 0;
/* turn logging off, we are going to try to validate the value with all the types in order */
ly_ilo_change(NULL, ILO_IGNORE, &prev_ilo, NULL);
while ((t = lyp_get_next_union_type(type, t, &found))) {
found = 0;
ret = lyp_parse_value(t, value_, xml, leaf, attr, NULL, store, dflt, 0);
if (ret) {
/* we have the result */
type = ret;
break;
}
if (store) {
/* erase possible present and invalid value data */
lyd_free_value(*val, *val_type, *val_flags, t, NULL, NULL, NULL);
memset(val, 0, sizeof(lyd_val));
}
}
/* turn logging back on */
ly_ilo_restore(NULL, prev_ilo, NULL, 0);
if (!t) {
/* not found */
if (store) {
*val_type = 0;
}
if (leaf) {
LOGVAL(ctx, LYE_INVAL, LY_VLOG_LYD, contextnode, *value_ ? *value_ : "", itemname);
} else {
LOGVAL(ctx, LYE_INMETA, LY_VLOG_LYD, contextnode, "<none>", itemname, *value_);
}
goto error;
}
break;
default:
LOGINT(ctx);
goto error;
}
/* search user types in case this value is supposed to be stored in a custom way */
if (store && type->der && type->der->module) {
c = lytype_store(type->der->module, type->der->name, *value_, val);
if (c == -1) {
goto error;
} else if (!c) {
*val_flags |= LY_VALUE_USER;
}
}
/* free backup */
if (store) {
lyd_free_value(old_val, old_val_type, old_val_flags, type, NULL, NULL, NULL);
}
return type;
error:
/* restore the backup */
if (store) {
*val = old_val;
*val_type = old_val_type;
*val_flags = old_val_flags;
}
return NULL;
}
/* does not log, cannot fail */
struct lys_type *
lyp_get_next_union_type(struct lys_type *type, struct lys_type *prev_type, int *found)
{
unsigned int i;
struct lys_type *ret = NULL;
while (!type->info.uni.count) {
assert(type->der); /* at least the direct union type has to have type specified */
type = &type->der->type;
}
for (i = 0; i < type->info.uni.count; ++i) {
if (type->info.uni.types[i].base == LY_TYPE_UNION) {
ret = lyp_get_next_union_type(&type->info.uni.types[i], prev_type, found);
if (ret) {
break;
}
continue;
}
if (!prev_type || *found) {
ret = &type->info.uni.types[i];
break;
}
if (&type->info.uni.types[i] == prev_type) {
*found = 1;
}
}
return ret;
}
/* ret 0 - ret set, ret 1 - ret not set, no log, ret -1 - ret not set, fatal error */
int
lyp_fill_attr(struct ly_ctx *ctx, struct lyd_node *parent, const char *module_ns, const char *module_name,
const char *attr_name, const char *attr_value, struct lyxml_elem *xml, int options, struct lyd_attr **ret)
{
const struct lys_module *mod = NULL;
const struct lys_submodule *submod = NULL;
struct lys_type **type;
struct lyd_attr *dattr;
int pos, i, j, k;
/* first, get module where the annotation should be defined */
if (module_ns) {
mod = (struct lys_module *)ly_ctx_get_module_by_ns(ctx, module_ns, NULL, 0);
} else if (module_name) {
mod = (struct lys_module *)ly_ctx_get_module(ctx, module_name, NULL, 0);
} else {
LOGINT(ctx);
return -1;
}
if (!mod) {
return 1;
}
/* then, find the appropriate annotation definition */
pos = -1;
for (i = 0, j = 0; i < mod->ext_size; i = i + j + 1) {
j = lys_ext_instance_presence(&ctx->models.list[0]->extensions[0], &mod->ext[i], mod->ext_size - i);
if (j == -1) {
break;
}
if (ly_strequal(mod->ext[i + j]->arg_value, attr_name, 0)) {
pos = i + j;
break;
}
}
/* try submodules */
if (pos == -1) {
for (k = 0; k < mod->inc_size; ++k) {
submod = mod->inc[k].submodule;
for (i = 0, j = 0; i < submod->ext_size; i = i + j + 1) {
j = lys_ext_instance_presence(&ctx->models.list[0]->extensions[0], &submod->ext[i], submod->ext_size - i);
if (j == -1) {
break;
}
if (ly_strequal(submod->ext[i + j]->arg_value, attr_name, 0)) {
pos = i + j;
break;
}
}
}
}
if (pos == -1) {
return 1;
}
/* allocate and fill the data attribute structure */
dattr = calloc(1, sizeof *dattr);
LY_CHECK_ERR_RETURN(!dattr, LOGMEM(ctx), -1);
dattr->parent = parent;
dattr->next = NULL;
dattr->annotation = submod ? (struct lys_ext_instance_complex *)submod->ext[pos] :
(struct lys_ext_instance_complex *)mod->ext[pos];
dattr->name = lydict_insert(ctx, attr_name, 0);
dattr->value_str = lydict_insert(ctx, attr_value, 0);
/* the value is here converted to a JSON format if needed in case of LY_TYPE_IDENT and LY_TYPE_INST or to a
* canonical form of the value */
type = lys_ext_complex_get_substmt(LY_STMT_TYPE, dattr->annotation, NULL);
if (!type || !lyp_parse_value(*type, &dattr->value_str, xml, NULL, dattr, NULL, 1, 0, options & LYD_OPT_TRUSTED)) {
lydict_remove(ctx, dattr->name);
lydict_remove(ctx, dattr->value_str);
free(dattr);
return -1;
}
*ret = dattr;
return 0;
}
int
lyp_check_edit_attr(struct ly_ctx *ctx, struct lyd_attr *attr, struct lyd_node *parent, int *editbits)
{
struct lyd_attr *last = NULL;
int bits = 0;
/* 0x01 - insert attribute present
* 0x02 - insert is relative (before or after)
* 0x04 - value attribute present
* 0x08 - key attribute present
* 0x10 - operation attribute present
* 0x20 - operation not allowing insert attribute (delete or remove)
*/
LY_TREE_FOR(attr, attr) {
last = NULL;
if (!strcmp(attr->annotation->arg_value, "operation") &&
!strcmp(attr->annotation->module->name, "ietf-netconf")) {
if (bits & 0x10) {
LOGVAL(ctx, LYE_TOOMANY, LY_VLOG_LYD, parent, "operation attributes", parent->schema->name);
return -1;
}
bits |= 0x10;
if (attr->value.enm->value >= 3) {
/* delete or remove */
bits |= 0x20;
}
} else if (attr->annotation->module == ctx->models.list[1] && /* internal YANG schema */
!strcmp(attr->annotation->arg_value, "insert")) {
/* 'insert' attribute present */
if (!(parent->schema->flags & LYS_USERORDERED)) {
/* ... but it is not expected */
LOGVAL(ctx, LYE_INATTR, LY_VLOG_LYD, parent, "insert");
return -1;
}
if (bits & 0x01) {
LOGVAL(ctx, LYE_TOOMANY, LY_VLOG_LYD, parent, "insert attributes", parent->schema->name);
return -1;
}
bits |= 0x01;
if (attr->value.enm->value >= 2) {
/* before or after */
bits |= 0x02;
}
last = attr;
} else if (attr->annotation->module == ctx->models.list[1] && /* internal YANG schema */
!strcmp(attr->annotation->arg_value, "value")) {
if (bits & 0x04) {
LOGVAL(ctx, LYE_TOOMANY, LY_VLOG_LYD, parent, "value attributes", parent->schema->name);
return -1;
} else if (parent->schema->nodetype & LYS_LIST) {
LOGVAL(ctx, LYE_INATTR, LY_VLOG_LYD, parent, attr->name);
return -1;
}
bits |= 0x04;
last = attr;
} else if (attr->annotation->module == ctx->models.list[1] && /* internal YANG schema */
!strcmp(attr->annotation->arg_value, "key")) {
if (bits & 0x08) {
LOGVAL(ctx, LYE_TOOMANY, LY_VLOG_LYD, parent, "key attributes", parent->schema->name);
return -1;
} else if (parent->schema->nodetype & LYS_LEAFLIST) {
LOGVAL(ctx, LYE_INATTR, LY_VLOG_LYD, parent, attr->name);
return -1;
}
bits |= 0x08;
last = attr;
}
}
/* report errors */
if (last && (!(parent->schema->nodetype & (LYS_LEAFLIST | LYS_LIST)) || !(parent->schema->flags & LYS_USERORDERED))) {
/* moving attributes in wrong elements (not an user ordered list or not a list at all) */
LOGVAL(ctx, LYE_INATTR, LY_VLOG_LYD, parent, last->name);
return -1;
} else if (bits == 3) {
/* 0x01 | 0x02 - relative position, but value/key is missing */
if (parent->schema->nodetype & LYS_LIST) {
LOGVAL(ctx, LYE_MISSATTR, LY_VLOG_LYD, parent, "key", parent->schema->name);
} else { /* LYS_LEAFLIST */
LOGVAL(ctx, LYE_MISSATTR, LY_VLOG_LYD, parent, "value", parent->schema->name);
}
return -1;
} else if ((bits & (0x04 | 0x08)) && !(bits & 0x02)) {
/* key/value without relative position */
LOGVAL(ctx, LYE_INATTR, LY_VLOG_LYD, parent, (bits & 0x04) ? "value" : "key");
return -1;
} else if ((bits & 0x21) == 0x21) {
/* insert in delete/remove */
LOGVAL(ctx, LYE_INATTR, LY_VLOG_LYD, parent, "insert");
return -1;
}
if (editbits) {
*editbits = bits;
}
return 0;
}
/* does not log */
static int
dup_identity_check(const char *id, struct lys_ident *ident, uint32_t size)
{
uint32_t i;
for (i = 0; i < size; i++) {
if (ly_strequal(id, ident[i].name, 1)) {
/* name collision */
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
int
dup_identities_check(const char *id, struct lys_module *module)
{
struct lys_module *mainmod;
int i;
if (dup_identity_check(id, module->ident, module->ident_size)) {
LOGVAL(module->ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "identity", id);
return EXIT_FAILURE;
}
/* check identity in submodules */
mainmod = lys_main_module(module);
for (i = 0; i < mainmod->inc_size && mainmod->inc[i].submodule; ++i) {
if (dup_identity_check(id, mainmod->inc[i].submodule->ident, mainmod->inc[i].submodule->ident_size)) {
LOGVAL(module->ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "identity", id);
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
/* does not log */
int
dup_typedef_check(const char *type, struct lys_tpdf *tpdf, int size)
{
int i;
for (i = 0; i < size; i++) {
if (!strcmp(type, tpdf[i].name)) {
/* name collision */
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
/* does not log */
static int
dup_feature_check(const char *id, struct lys_module *module)
{
int i;
for (i = 0; i < module->features_size; i++) {
if (!strcmp(id, module->features[i].name)) {
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
/* does not log */
static int
dup_prefix_check(const char *prefix, struct lys_module *module)
{
int i;
if (module->prefix && !strcmp(module->prefix, prefix)) {
return EXIT_FAILURE;
}
for (i = 0; i < module->imp_size; i++) {
if (!strcmp(module->imp[i].prefix, prefix)) {
return EXIT_FAILURE;
}
}
return EXIT_SUCCESS;
}
/* logs directly */
int
lyp_check_identifier(struct ly_ctx *ctx, const char *id, enum LY_IDENT type, struct lys_module *module,
struct lys_node *parent)
{
int i, j;
int size;
struct lys_tpdf *tpdf;
struct lys_node *node;
struct lys_module *mainmod;
struct lys_submodule *submod;
assert(ctx && id);
/* check id syntax */
if (!(id[0] >= 'A' && id[0] <= 'Z') && !(id[0] >= 'a' && id[0] <= 'z') && id[0] != '_') {
LOGVAL(ctx, LYE_INID, LY_VLOG_NONE, NULL, id, "invalid start character");
return EXIT_FAILURE;
}
for (i = 1; id[i]; i++) {
if (!(id[i] >= 'A' && id[i] <= 'Z') && !(id[i] >= 'a' && id[i] <= 'z')
&& !(id[i] >= '0' && id[i] <= '9') && id[i] != '_' && id[i] != '-' && id[i] != '.') {
LOGVAL(ctx, LYE_INID, LY_VLOG_NONE, NULL, id, "invalid character");
return EXIT_FAILURE;
}
}
if (i > 64) {
LOGWRN(ctx, "Identifier \"%s\" is long, you should use something shorter.", id);
}
switch (type) {
case LY_IDENT_NAME:
/* check uniqueness of the node within its siblings */
if (!parent) {
break;
}
LY_TREE_FOR(parent->child, node) {
if (ly_strequal(node->name, id, 1)) {
LOGVAL(ctx, LYE_INID, LY_VLOG_NONE, NULL, id, "name duplication");
return EXIT_FAILURE;
}
}
break;
case LY_IDENT_TYPE:
assert(module);
mainmod = lys_main_module(module);
/* check collision with the built-in types */
if (!strcmp(id, "binary") || !strcmp(id, "bits") ||
!strcmp(id, "boolean") || !strcmp(id, "decimal64") ||
!strcmp(id, "empty") || !strcmp(id, "enumeration") ||
!strcmp(id, "identityref") || !strcmp(id, "instance-identifier") ||
!strcmp(id, "int8") || !strcmp(id, "int16") ||
!strcmp(id, "int32") || !strcmp(id, "int64") ||
!strcmp(id, "leafref") || !strcmp(id, "string") ||
!strcmp(id, "uint8") || !strcmp(id, "uint16") ||
!strcmp(id, "uint32") || !strcmp(id, "uint64") || !strcmp(id, "union")) {
LOGVAL(ctx, LYE_INARG, LY_VLOG_NONE, NULL, id, "typedef");
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Typedef name duplicates a built-in type.");
return EXIT_FAILURE;
}
/* check locally scoped typedefs (avoid name shadowing) */
for (; parent; parent = lys_parent(parent)) {
switch (parent->nodetype) {
case LYS_CONTAINER:
size = ((struct lys_node_container *)parent)->tpdf_size;
tpdf = ((struct lys_node_container *)parent)->tpdf;
break;
case LYS_LIST:
size = ((struct lys_node_list *)parent)->tpdf_size;
tpdf = ((struct lys_node_list *)parent)->tpdf;
break;
case LYS_GROUPING:
size = ((struct lys_node_grp *)parent)->tpdf_size;
tpdf = ((struct lys_node_grp *)parent)->tpdf;
break;
default:
continue;
}
if (dup_typedef_check(id, tpdf, size)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "typedef", id);
return EXIT_FAILURE;
}
}
/* check top-level names */
if (dup_typedef_check(id, module->tpdf, module->tpdf_size)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "typedef", id);
return EXIT_FAILURE;
}
/* check submodule's top-level names */
for (i = 0; i < mainmod->inc_size && mainmod->inc[i].submodule; i++) {
if (dup_typedef_check(id, mainmod->inc[i].submodule->tpdf, mainmod->inc[i].submodule->tpdf_size)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "typedef", id);
return EXIT_FAILURE;
}
}
break;
case LY_IDENT_PREFIX:
assert(module);
/* check the module itself */
if (dup_prefix_check(id, module)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "prefix", id);
return EXIT_FAILURE;
}
break;
case LY_IDENT_FEATURE:
assert(module);
mainmod = lys_main_module(module);
/* check feature name uniqueness*/
/* check features in the current module */
if (dup_feature_check(id, module)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "feature", id);
return EXIT_FAILURE;
}
/* and all its submodules */
for (i = 0; i < mainmod->inc_size && mainmod->inc[i].submodule; i++) {
if (dup_feature_check(id, (struct lys_module *)mainmod->inc[i].submodule)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "feature", id);
return EXIT_FAILURE;
}
}
break;
case LY_IDENT_EXTENSION:
assert(module);
mainmod = lys_main_module(module);
/* check extension name uniqueness in the main module ... */
for (i = 0; i < mainmod->extensions_size; i++) {
if (ly_strequal(id, mainmod->extensions[i].name, 1)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "extension", id);
return EXIT_FAILURE;
}
}
/* ... and all its submodules */
for (j = 0; j < mainmod->inc_size && mainmod->inc[j].submodule; j++) {
submod = mainmod->inc[j].submodule; /* shortcut */
for (i = 0; i < submod->extensions_size; i++) {
if (ly_strequal(id, submod->extensions[i].name, 1)) {
LOGVAL(ctx, LYE_DUPID, LY_VLOG_NONE, NULL, "extension", id);
return EXIT_FAILURE;
}
}
}
break;
default:
/* no check required */
break;
}
return EXIT_SUCCESS;
}
/* logs directly */
int
lyp_check_date(struct ly_ctx *ctx, const char *date)
{
int i;
struct tm tm, tm_;
char *r;
assert(date);
/* check format */
for (i = 0; i < LY_REV_SIZE - 1; i++) {
if (i == 4 || i == 7) {
if (date[i] != '-') {
goto error;
}
} else if (!isdigit(date[i])) {
goto error;
}
}
/* check content, e.g. 2018-02-31 */
memset(&tm, 0, sizeof tm);
r = strptime(date, "%Y-%m-%d", &tm);
if (!r || r != &date[LY_REV_SIZE - 1]) {
goto error;
}
/* set some arbitrary non-0 value in case DST changes, it could move the day otherwise */
tm.tm_hour = 12;
memcpy(&tm_, &tm, sizeof tm);
mktime(&tm_); /* mktime modifies tm_ if it refers invalid date */
if (tm.tm_mday != tm_.tm_mday) { /* e.g 2018-02-29 -> 2018-03-01 */
/* checking days is enough, since other errors
* have been checked by strptime() */
goto error;
}
return EXIT_SUCCESS;
error:
LOGVAL(ctx, LYE_INDATE, LY_VLOG_NONE, NULL, date);
return EXIT_FAILURE;
}
/**
* @return
* NULL - success
* root - not yet resolvable
* other node - mandatory node under the root
*/
static const struct lys_node *
lyp_check_mandatory_(const struct lys_node *root)
{
int mand_flag = 0;
const struct lys_node *iter = NULL;
while ((iter = lys_getnext(iter, root, NULL, LYS_GETNEXT_WITHCHOICE | LYS_GETNEXT_WITHUSES | LYS_GETNEXT_INTOUSES
| LYS_GETNEXT_INTONPCONT | LYS_GETNEXT_NOSTATECHECK))) {
if (iter->nodetype == LYS_USES) {
if (!((struct lys_node_uses *)iter)->grp) {
/* not yet resolved uses */
return root;
} else {
/* go into uses */
continue;
}
}
if (iter->nodetype == LYS_CHOICE) {
/* skip it, it was already checked for direct mandatory node in default */
continue;
}
if (iter->nodetype == LYS_LIST) {
if (((struct lys_node_list *)iter)->min) {
mand_flag = 1;
}
} else if (iter->nodetype == LYS_LEAFLIST) {
if (((struct lys_node_leaflist *)iter)->min) {
mand_flag = 1;
}
} else if (iter->flags & LYS_MAND_TRUE) {
mand_flag = 1;
}
if (mand_flag) {
return iter;
}
}
return NULL;
}
/* logs directly */
int
lyp_check_mandatory_augment(struct lys_node_augment *aug, const struct lys_node *target)
{
const struct lys_node *node;
if (aug->when || target->nodetype == LYS_CHOICE) {
/* - mandatory nodes in new cases are ok;
* clarification from YANG 1.1 - augmentation can add mandatory nodes when it is
* conditional with a when statement */
return EXIT_SUCCESS;
}
if ((node = lyp_check_mandatory_((struct lys_node *)aug))) {
if (node != (struct lys_node *)aug) {
LOGVAL(target->module->ctx, LYE_INSTMT, LY_VLOG_NONE, NULL, "mandatory");
LOGVAL(target->module->ctx, LYE_SPEC, LY_VLOG_NONE, NULL,
"Mandatory node \"%s\" appears in augment of \"%s\" without when condition.",
node->name, aug->target_name);
return -1;
}
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/**
* @brief check that a mandatory node is not directly under the default case.
* @param[in] node choice with default node
* @return EXIT_SUCCESS if the constraint is fulfilled, EXIT_FAILURE otherwise
*/
int
lyp_check_mandatory_choice(struct lys_node *node)
{
const struct lys_node *mand, *dflt = ((struct lys_node_choice *)node)->dflt;
if ((mand = lyp_check_mandatory_(dflt))) {
if (mand != dflt) {
LOGVAL(node->module->ctx, LYE_INSTMT, LY_VLOG_NONE, NULL, "mandatory");
LOGVAL(node->module->ctx, LYE_SPEC, LY_VLOG_NONE, NULL,
"Mandatory node \"%s\" is directly under the default case \"%s\" of the \"%s\" choice.",
mand->name, dflt->name, node->name);
return -1;
}
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/**
* @brief Check status for invalid combination.
*
* @param[in] flags1 Flags of the referencing node.
* @param[in] mod1 Module of the referencing node,
* @param[in] name1 Schema node name of the referencing node.
* @param[in] flags2 Flags of the referenced node.
* @param[in] mod2 Module of the referenced node,
* @param[in] name2 Schema node name of the referenced node.
* @return EXIT_SUCCES on success, EXIT_FAILURE on invalid reference.
*/
int
lyp_check_status(uint16_t flags1, struct lys_module *mod1, const char *name1,
uint16_t flags2, struct lys_module *mod2, const char *name2,
const struct lys_node *node)
{
uint16_t flg1, flg2;
flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR;
if ((flg1 < flg2) && (lys_main_module(mod1) == lys_main_module(mod2))) {
LOGVAL(mod1->ctx, LYE_INSTATUS, node ? LY_VLOG_LYS : LY_VLOG_NONE, node,
flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1, "references",
flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
void
lyp_del_includedup(struct lys_module *mod, int free_subs)
{
struct ly_modules_list *models = &mod->ctx->models;
uint8_t i;
assert(mod && !mod->type);
if (models->parsed_submodules_count) {
for (i = models->parsed_submodules_count - 1; models->parsed_submodules[i]->type; --i);
if (models->parsed_submodules[i] == mod) {
if (free_subs) {
for (i = models->parsed_submodules_count - 1; models->parsed_submodules[i]->type; --i) {
lys_sub_module_remove_devs_augs((struct lys_module *)models->parsed_submodules[i]);
lys_submodule_module_data_free((struct lys_submodule *)models->parsed_submodules[i]);
lys_submodule_free((struct lys_submodule *)models->parsed_submodules[i], NULL);
}
}
models->parsed_submodules_count = i;
if (!models->parsed_submodules_count) {
free(models->parsed_submodules);
models->parsed_submodules = NULL;
}
}
}
}
static void
lyp_add_includedup(struct lys_module *sub_mod, struct lys_submodule *parsed_submod)
{
struct ly_modules_list *models = &sub_mod->ctx->models;
int16_t i;
/* store main module if first include */
if (models->parsed_submodules_count) {
for (i = models->parsed_submodules_count - 1; models->parsed_submodules[i]->type; --i);
} else {
i = -1;
}
if ((i == -1) || (models->parsed_submodules[i] != lys_main_module(sub_mod))) {
++models->parsed_submodules_count;
models->parsed_submodules = ly_realloc(models->parsed_submodules,
models->parsed_submodules_count * sizeof *models->parsed_submodules);
LY_CHECK_ERR_RETURN(!models->parsed_submodules, LOGMEM(sub_mod->ctx), );
models->parsed_submodules[models->parsed_submodules_count - 1] = lys_main_module(sub_mod);
}
/* store parsed submodule */
++models->parsed_submodules_count;
models->parsed_submodules = ly_realloc(models->parsed_submodules,
models->parsed_submodules_count * sizeof *models->parsed_submodules);
LY_CHECK_ERR_RETURN(!models->parsed_submodules, LOGMEM(sub_mod->ctx), );
models->parsed_submodules[models->parsed_submodules_count - 1] = (struct lys_module *)parsed_submod;
}
/*
* types: 0 - include, 1 - import
*/
static int
lyp_check_circmod(struct lys_module *module, const char *value, int type)
{
LY_ECODE code = type ? LYE_CIRC_IMPORTS : LYE_CIRC_INCLUDES;
struct ly_modules_list *models = &module->ctx->models;
uint8_t i;
/* include/import itself */
if (ly_strequal(module->name, value, 1)) {
LOGVAL(module->ctx, code, LY_VLOG_NONE, NULL, value);
return -1;
}
/* currently parsed modules */
for (i = 0; i < models->parsing_sub_modules_count; i++) {
if (ly_strequal(models->parsing_sub_modules[i]->name, value, 1)) {
LOGVAL(module->ctx, code, LY_VLOG_NONE, NULL, value);
return -1;
}
}
return 0;
}
int
lyp_check_circmod_add(struct lys_module *module)
{
struct ly_modules_list *models = &module->ctx->models;
/* storing - enlarge the list of modules being currently parsed */
++models->parsing_sub_modules_count;
models->parsing_sub_modules = ly_realloc(models->parsing_sub_modules,
models->parsing_sub_modules_count * sizeof *models->parsing_sub_modules);
LY_CHECK_ERR_RETURN(!models->parsing_sub_modules, LOGMEM(module->ctx), -1);
models->parsing_sub_modules[models->parsing_sub_modules_count - 1] = module;
return 0;
}
void
lyp_check_circmod_pop(struct ly_ctx *ctx)
{
if (!ctx->models.parsing_sub_modules_count) {
LOGINT(ctx);
return;
}
/* update the list of currently being parsed modules */
ctx->models.parsing_sub_modules_count--;
if (!ctx->models.parsing_sub_modules_count) {
free(ctx->models.parsing_sub_modules);
ctx->models.parsing_sub_modules = NULL;
}
}
/*
* -1 - error - invalid duplicities)
* 0 - success, no duplicity
* 1 - success, valid duplicity found and stored in *sub
*/
static int
lyp_check_includedup(struct lys_module *mod, const char *name, struct lys_include *inc, struct lys_submodule **sub)
{
struct lys_module **parsed_sub = mod->ctx->models.parsed_submodules;
uint8_t i, parsed_sub_count = mod->ctx->models.parsed_submodules_count;
assert(sub);
for (i = 0; i < mod->inc_size; ++i) {
if (ly_strequal(mod->inc[i].submodule->name, name, 1)) {
/* the same module is already included in the same module - error */
LOGVAL(mod->ctx, LYE_INARG, LY_VLOG_NONE, NULL, name, "include");
LOGVAL(mod->ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Submodule \"%s\" included twice in the same module \"%s\".",
name, mod->name);
return -1;
}
}
if (parsed_sub_count) {
assert(!parsed_sub[0]->type);
for (i = parsed_sub_count - 1; parsed_sub[i]->type; --i) {
if (ly_strequal(parsed_sub[i]->name, name, 1)) {
/* check revisions, including multiple revisions of a single module is error */
if (inc->rev[0] && (!parsed_sub[i]->rev_size || strcmp(parsed_sub[i]->rev[0].date, inc->rev))) {
/* the already included submodule has
* - no revision, but here we require some
* - different revision than the one required here */
LOGVAL(mod->ctx, LYE_INARG, LY_VLOG_NONE, NULL, name, "include");
LOGVAL(mod->ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Including multiple revisions of submodule \"%s\".", name);
return -1;
}
/* the same module is already included in some other submodule, return it */
(*sub) = (struct lys_submodule *)parsed_sub[i];
return 1;
}
}
}
/* no duplicity found */
return 0;
}
/* returns:
* 0 - inc successfully filled
* -1 - error
*/
int
lyp_check_include(struct lys_module *module, const char *value, struct lys_include *inc, struct unres_schema *unres)
{
int i;
/* check that the submodule was not included yet */
i = lyp_check_includedup(module, value, inc, &inc->submodule);
if (i == -1) {
return -1;
} else if (i == 1) {
return 0;
}
/* submodule is not yet loaded */
/* circular include check */
if (lyp_check_circmod(module, value, 0)) {
return -1;
}
/* try to load the submodule */
inc->submodule = (struct lys_submodule *)ly_ctx_load_sub_module(module->ctx, module, value,
inc->rev[0] ? inc->rev : NULL, 1, unres);
/* check the result */
if (!inc->submodule) {
if (ly_errno != LY_EVALID) {
LOGVAL(module->ctx, LYE_INARG, LY_VLOG_NONE, NULL, value, "include");
}
LOGERR(module->ctx, LY_EVALID, "Including \"%s\" module into \"%s\" failed.", value, module->name);
return -1;
}
/* check the revision */
if (inc->rev[0] && inc->submodule->rev_size && strcmp(inc->rev, inc->submodule->rev[0].date)) {
LOGERR(module->ctx, LY_EVALID, "\"%s\" include of submodule \"%s\" in revision \"%s\" not found.",
module->name, value, inc->rev);
unres_schema_free((struct lys_module *)inc->submodule, &unres, 0);
lys_sub_module_remove_devs_augs((struct lys_module *)inc->submodule);
lys_submodule_module_data_free((struct lys_submodule *)inc->submodule);
lys_submodule_free(inc->submodule, NULL);
inc->submodule = NULL;
return -1;
}
/* store the submodule as successfully parsed */
lyp_add_includedup(module, inc->submodule);
return 0;
}
static int
lyp_check_include_missing_recursive(struct lys_module *main_module, struct lys_submodule *sub)
{
uint8_t i, j;
void *reallocated;
int ret = 0, tmp;
struct ly_ctx *ctx = main_module->ctx;
for (i = 0; i < sub->inc_size; i++) {
/* check that the include is also present in the main module */
for (j = 0; j < main_module->inc_size; j++) {
if (main_module->inc[j].submodule == sub->inc[i].submodule) {
break;
}
}
if (j == main_module->inc_size) {
/* match not found */
if (main_module->version >= LYS_VERSION_1_1) {
LOGVAL(ctx, LYE_MISSSTMT, LY_VLOG_NONE, NULL, "include");
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL,
"The main module \"%s\" misses include of the \"%s\" submodule used in another submodule \"%s\".",
main_module->name, sub->inc[i].submodule->name, sub->name);
/* now we should return error, but due to the issues with freeing the module, we actually have
* to go through the all includes and, as in case of 1.0, add them into the main module and fail
* at the end when all the includes are in the main module and we can free them */
ret = 1;
} else {
/* not strictly an error in YANG 1.0 */
LOGWRN(ctx, "The main module \"%s\" misses include of the \"%s\" submodule used in another submodule \"%s\".",
main_module->name, sub->inc[i].submodule->name, sub->name);
LOGWRN(ctx, "To avoid further issues, adding submodule \"%s\" into the main module \"%s\".",
sub->inc[i].submodule->name, main_module->name);
/* but since it is a good practise and because we expect all the includes in the main module
* when searching it and also when freeing the module, put it into it */
}
main_module->inc_size++;
reallocated = realloc(main_module->inc, main_module->inc_size * sizeof *main_module->inc);
LY_CHECK_ERR_RETURN(!reallocated, LOGMEM(ctx), 1);
main_module->inc = reallocated;
memset(&main_module->inc[main_module->inc_size - 1], 0, sizeof *main_module->inc);
/* to avoid unexpected consequences, copy just a link to the submodule and the revision,
* all other substatements of the include are ignored */
memcpy(&main_module->inc[main_module->inc_size - 1].rev, sub->inc[i].rev, LY_REV_SIZE - 1);
main_module->inc[main_module->inc_size - 1].submodule = sub->inc[i].submodule;
}
/* recursion */
tmp = lyp_check_include_missing_recursive(main_module, sub->inc[i].submodule);
if (!ret && tmp) {
ret = 1;
}
}
return ret;
}
int
lyp_check_include_missing(struct lys_module *main_module)
{
int ret = 0;
uint8_t i;
/* in YANG 1.1, all the submodules must be in the main module, check it even for
* 1.0 where it will be printed as warning and the include will be added into the main module */
for (i = 0; i < main_module->inc_size; i++) {
if (lyp_check_include_missing_recursive(main_module, main_module->inc[i].submodule)) {
ret = 1;
}
}
return ret;
}
/* returns:
* 0 - imp successfully filled
* -1 - error, imp not cleaned
*/
int
lyp_check_import(struct lys_module *module, const char *value, struct lys_import *imp)
{
int i;
struct lys_module *dup = NULL;
struct ly_ctx *ctx = module->ctx;
/* check for importing a single module in multiple revisions */
for (i = 0; i < module->imp_size; i++) {
if (!module->imp[i].module) {
/* skip the not yet filled records */
continue;
}
if (ly_strequal(module->imp[i].module->name, value, 1)) {
/* check revisions, including multiple revisions of a single module is error */
if (imp->rev[0] && (!module->imp[i].module->rev_size || strcmp(module->imp[i].module->rev[0].date, imp->rev))) {
/* the already imported module has
* - no revision, but here we require some
* - different revision than the one required here */
LOGVAL(ctx, LYE_INARG, LY_VLOG_NONE, NULL, value, "import");
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Importing multiple revisions of module \"%s\".", value);
return -1;
} else if (!imp->rev[0]) {
/* no revision, remember the duplication, but check revisions after loading the module
* because the current revision can be the same (then it is ok) or it can differ (then it
* is error */
dup = module->imp[i].module;
break;
}
/* there is duplication, but since prefixes differs (checked in caller of this function),
* it is ok */
imp->module = module->imp[i].module;
return 0;
}
}
/* circular import check */
if (lyp_check_circmod(module, value, 1)) {
return -1;
}
/* load module - in specific situations it tries to get the module from the context */
imp->module = (struct lys_module *)ly_ctx_load_sub_module(module->ctx, NULL, value, imp->rev[0] ? imp->rev : NULL,
module->ctx->models.flags & LY_CTX_ALLIMPLEMENTED ? 1 : 0,
NULL);
/* check the result */
if (!imp->module) {
LOGERR(ctx, LY_EVALID, "Importing \"%s\" module into \"%s\" failed.", value, module->name);
return -1;
}
if (imp->rev[0] && imp->module->rev_size && strcmp(imp->rev, imp->module->rev[0].date)) {
LOGERR(ctx, LY_EVALID, "\"%s\" import of module \"%s\" in revision \"%s\" not found.",
module->name, value, imp->rev);
return -1;
}
if (dup) {
/* check the revisions */
if ((dup != imp->module) ||
(dup->rev_size != imp->module->rev_size && (!dup->rev_size || imp->module->rev_size)) ||
(dup->rev_size && strcmp(dup->rev[0].date, imp->module->rev[0].date))) {
/* - modules are not the same
* - one of modules has no revision (except they both has no revision)
* - revisions of the modules are not the same */
LOGVAL(ctx, LYE_INARG, LY_VLOG_NONE, NULL, value, "import");
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Importing multiple revisions of module \"%s\".", value);
return -1;
} else {
LOGWRN(ctx, "Module \"%s\" is imported by \"%s\" multiple times with different prefixes.", dup->name, module->name);
}
}
return 0;
}
/*
* put the newest revision to the first position
*/
void
lyp_sort_revisions(struct lys_module *module)
{
uint8_t i, r;
struct lys_revision rev;
for (i = 1, r = 0; i < module->rev_size; i++) {
if (strcmp(module->rev[i].date, module->rev[r].date) > 0) {
r = i;
}
}
if (r) {
/* the newest revision is not on position 0, switch them */
memcpy(&rev, &module->rev[0], sizeof rev);
memcpy(&module->rev[0], &module->rev[r], sizeof rev);
memcpy(&module->rev[r], &rev, sizeof rev);
}
}
void
lyp_ext_instance_rm(struct ly_ctx *ctx, struct lys_ext_instance ***ext, uint8_t *size, uint8_t index)
{
uint8_t i;
lys_extension_instances_free(ctx, (*ext)[index]->ext, (*ext)[index]->ext_size, NULL);
lydict_remove(ctx, (*ext)[index]->arg_value);
free((*ext)[index]);
/* move the rest of the array */
for (i = index + 1; i < (*size); i++) {
(*ext)[i - 1] = (*ext)[i];
}
/* clean the last cell in the array structure */
(*ext)[(*size) - 1] = NULL;
/* the array is not reallocated here, just change its size */
(*size) = (*size) - 1;
if (!(*size)) {
/* ext array is empty */
free((*ext));
ext = NULL;
}
}
static int
lyp_rfn_apply_ext_(struct lys_refine *rfn, struct lys_node *target, LYEXT_SUBSTMT substmt, struct lys_ext *extdef)
{
struct ly_ctx *ctx;
int m, n;
struct lys_ext_instance *new;
void *reallocated;
ctx = target->module->ctx; /* shortcut */
m = n = -1;
while ((m = lys_ext_iter(rfn->ext, rfn->ext_size, m + 1, substmt)) != -1) {
/* refine's substatement includes extensions, copy them to the target, replacing the previous
* substatement's extensions if any. In case of refining the extension itself, we are going to
* replace only the same extension (pointing to the same definition) */
if (substmt == LYEXT_SUBSTMT_SELF && rfn->ext[m]->def != extdef) {
continue;
}
/* get the index of the extension to replace in the target node */
do {
n = lys_ext_iter(target->ext, target->ext_size, n + 1, substmt);
} while (n != -1 && substmt == LYEXT_SUBSTMT_SELF && target->ext[n]->def != extdef);
/* TODO cover complex extension instances */
if (n == -1) {
/* nothing to replace, we are going to add it - reallocate */
new = malloc(sizeof **target->ext);
LY_CHECK_ERR_RETURN(!new, LOGMEM(ctx), EXIT_FAILURE);
reallocated = realloc(target->ext, (target->ext_size + 1) * sizeof *target->ext);
LY_CHECK_ERR_RETURN(!reallocated, LOGMEM(ctx); free(new), EXIT_FAILURE);
target->ext = reallocated;
target->ext_size++;
/* init */
n = target->ext_size - 1;
target->ext[n] = new;
target->ext[n]->parent = target;
target->ext[n]->parent_type = LYEXT_PAR_NODE;
target->ext[n]->flags = 0;
target->ext[n]->insubstmt = substmt;
target->ext[n]->priv = NULL;
target->ext[n]->nodetype = LYS_EXT;
target->ext[n]->module = target->module;
} else {
/* replacing - first remove the allocated data from target */
lys_extension_instances_free(ctx, target->ext[n]->ext, target->ext[n]->ext_size, NULL);
lydict_remove(ctx, target->ext[n]->arg_value);
}
/* common part for adding and replacing */
target->ext[n]->def = rfn->ext[m]->def;
/* parent and parent_type do not change */
target->ext[n]->arg_value = lydict_insert(ctx, rfn->ext[m]->arg_value, 0);
/* flags do not change */
target->ext[n]->ext_size = rfn->ext[m]->ext_size;
lys_ext_dup(ctx, target->module, rfn->ext[m]->ext, rfn->ext[m]->ext_size, target, LYEXT_PAR_NODE,
&target->ext[n]->ext, 0, NULL);
/* substmt does not change, but the index must be taken from the refine */
target->ext[n]->insubstmt_index = rfn->ext[m]->insubstmt_index;
}
/* remove the rest of extensions belonging to the original substatement in the target node */
while ((n = lys_ext_iter(target->ext, target->ext_size, n + 1, substmt)) != -1) {
if (substmt == LYEXT_SUBSTMT_SELF && target->ext[n]->def != extdef) {
/* keep this extension */
continue;
}
/* remove the item */
lyp_ext_instance_rm(ctx, &target->ext, &target->ext_size, n);
--n;
}
return EXIT_SUCCESS;
}
/*
* apply extension instances defined under refine's substatements.
* It cannot be done immediately when applying the refine because there can be
* still unresolved data (e.g. type) and mainly the targeted extension instances.
*/
int
lyp_rfn_apply_ext(struct lys_module *module)
{
int i, k, a = 0;
struct lys_node *root, *nextroot, *next, *node;
struct lys_node *target;
struct lys_node_uses *uses;
struct lys_refine *rfn;
struct ly_set *extset;
/* refines in uses */
LY_TREE_FOR_SAFE(module->data, nextroot, root) {
/* go through the data tree of the module and all the defined augments */
LY_TREE_DFS_BEGIN(root, next, node) {
if (node->nodetype == LYS_USES) {
uses = (struct lys_node_uses *)node;
for (i = 0; i < uses->refine_size; i++) {
if (!uses->refine[i].ext_size) {
/* no extensions in refine */
continue;
}
rfn = &uses->refine[i]; /* shortcut */
/* get the target node */
target = NULL;
resolve_descendant_schema_nodeid(rfn->target_name, uses->child,
LYS_NO_RPC_NOTIF_NODE | LYS_ACTION | LYS_NOTIF,
0, (const struct lys_node **)&target);
if (!target) {
/* it should always succeed since the target_name was already resolved at least
* once when the refine itself was being resolved */
LOGINT(module->ctx);;
return EXIT_FAILURE;
}
/* extensions */
extset = ly_set_new();
k = -1;
while ((k = lys_ext_iter(rfn->ext, rfn->ext_size, k + 1, LYEXT_SUBSTMT_SELF)) != -1) {
ly_set_add(extset, rfn->ext[k]->def, 0);
}
for (k = 0; (unsigned int)k < extset->number; k++) {
if (lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_SELF, (struct lys_ext *)extset->set.g[k])) {
ly_set_free(extset);
return EXIT_FAILURE;
}
}
ly_set_free(extset);
/* description */
if (rfn->dsc && lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_DESCRIPTION, NULL)) {
return EXIT_FAILURE;
}
/* reference */
if (rfn->ref && lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_REFERENCE, NULL)) {
return EXIT_FAILURE;
}
/* config, in case of notification or rpc/action{notif, the config is not applicable
* (there is no config status) */
if ((rfn->flags & LYS_CONFIG_MASK) && (target->flags & LYS_CONFIG_MASK)) {
if (lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_CONFIG, NULL)) {
return EXIT_FAILURE;
}
}
/* default value */
if (rfn->dflt_size && lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_DEFAULT, NULL)) {
return EXIT_FAILURE;
}
/* mandatory */
if (rfn->flags & LYS_MAND_MASK) {
if (lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_MANDATORY, NULL)) {
return EXIT_FAILURE;
}
}
/* presence */
if ((target->nodetype & LYS_CONTAINER) && rfn->mod.presence) {
if (lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_PRESENCE, NULL)) {
return EXIT_FAILURE;
}
}
/* min/max */
if (rfn->flags & LYS_RFN_MINSET) {
if (lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_MIN, NULL)) {
return EXIT_FAILURE;
}
}
if (rfn->flags & LYS_RFN_MAXSET) {
if (lyp_rfn_apply_ext_(rfn, target, LYEXT_SUBSTMT_MAX, NULL)) {
return EXIT_FAILURE;
}
}
/* must and if-feature contain extensions on their own, not needed to be solved here */
if (target->ext_size) {
/* the allocated target's extension array can be now longer than needed in case
* there is less refine substatement's extensions than in original. Since we are
* going to reduce or keep the same memory, it is not necessary to test realloc's result */
target->ext = realloc(target->ext, target->ext_size * sizeof *target->ext);
}
}
}
LY_TREE_DFS_END(root, next, node)
}
if (!nextroot && a < module->augment_size) {
nextroot = module->augment[a].child;
a++;
}
}
return EXIT_SUCCESS;
}
/*
* check mandatory substatements defined under extension instances.
*/
int
lyp_mand_check_ext(struct lys_ext_instance_complex *ext, const char *ext_name)
{
void *p;
int i;
struct ly_ctx *ctx = ext->module->ctx;
/* check for mandatory substatements */
for (i = 0; ext->substmt[i].stmt; i++) {
if (ext->substmt[i].cardinality == LY_STMT_CARD_OPT || ext->substmt[i].cardinality == LY_STMT_CARD_ANY) {
/* not a mandatory */
continue;
} else if (ext->substmt[i].cardinality == LY_STMT_CARD_SOME) {
goto array;
}
/*
* LY_STMT_ORDEREDBY - not checked, has a default value which is the same as explicit system order
* LY_STMT_MODIFIER, LY_STMT_STATUS, LY_STMT_MANDATORY, LY_STMT_CONFIG - checked, but mandatory requirement
* does not make sense since there is also a default value specified
*/
switch(ext->substmt[i].stmt) {
case LY_STMT_ORDEREDBY:
/* always ok */
break;
case LY_STMT_REQINSTANCE:
case LY_STMT_DIGITS:
case LY_STMT_MODIFIER:
p = lys_ext_complex_get_substmt(ext->substmt[i].stmt, ext, NULL);
if (!*(uint8_t*)p) {
LOGVAL(ctx, LYE_MISSCHILDSTMT, LY_VLOG_NONE, NULL, ly_stmt_str[ext->substmt[i].stmt], ext_name);
goto error;
}
break;
case LY_STMT_STATUS:
p = lys_ext_complex_get_substmt(ext->substmt[i].stmt, ext, NULL);
if (!(*(uint16_t*)p & LYS_STATUS_MASK)) {
LOGVAL(ctx, LYE_MISSCHILDSTMT, LY_VLOG_NONE, NULL, ly_stmt_str[ext->substmt[i].stmt], ext_name);
goto error;
}
break;
case LY_STMT_MANDATORY:
p = lys_ext_complex_get_substmt(ext->substmt[i].stmt, ext, NULL);
if (!(*(uint16_t*)p & LYS_MAND_MASK)) {
LOGVAL(ctx, LYE_MISSCHILDSTMT, LY_VLOG_NONE, NULL, ly_stmt_str[ext->substmt[i].stmt], ext_name);
goto error;
}
break;
case LY_STMT_CONFIG:
p = lys_ext_complex_get_substmt(ext->substmt[i].stmt, ext, NULL);
if (!(*(uint16_t*)p & LYS_CONFIG_MASK)) {
LOGVAL(ctx, LYE_MISSCHILDSTMT, LY_VLOG_NONE, NULL, ly_stmt_str[ext->substmt[i].stmt], ext_name);
goto error;
}
break;
default:
array:
/* stored as a pointer */
p = lys_ext_complex_get_substmt(ext->substmt[i].stmt, ext, NULL);
if (!(*(void**)p)) {
LOGVAL(ctx, LYE_MISSCHILDSTMT, LY_VLOG_NONE, NULL, ly_stmt_str[ext->substmt[i].stmt], ext_name);
goto error;
}
break;
}
}
return EXIT_SUCCESS;
error:
return EXIT_FAILURE;
}
static int
lyp_deviate_del_ext(struct lys_node *target, struct lys_ext_instance *ext)
{
int n = -1, found = 0;
char *path;
while ((n = lys_ext_iter(target->ext, target->ext_size, n + 1, ext->insubstmt)) != -1) {
if (target->ext[n]->def != ext->def) {
continue;
}
if (ext->def->argument) {
/* check matching arguments */
if (!ly_strequal(target->ext[n]->arg_value, ext->arg_value, 1)) {
continue;
}
}
/* we have the matching extension - remove it */
++found;
lyp_ext_instance_rm(target->module->ctx, &target->ext, &target->ext_size, n);
--n;
}
if (!found) {
path = lys_path(target, LYS_PATH_FIRST_PREFIX);
LOGERR(target->module->ctx, LY_EVALID, "Extension deviation: extension \"%s\" to delete not found in \"%s\".",
ext->def->name, path)
free(path);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
static int
lyp_deviate_apply_ext(struct lys_deviate *dev, struct lys_node *target, LYEXT_SUBSTMT substmt, struct lys_ext *extdef)
{
struct ly_ctx *ctx;
int m, n;
struct lys_ext_instance *new;
void *reallocated;
/* LY_DEVIATE_ADD and LY_DEVIATE_RPL are very similar so they are implement the same way - in replacing,
* there can be some extension instances in the target, in case of adding, there should not be any so we
* will be just adding. */
ctx = target->module->ctx; /* shortcut */
m = n = -1;
while ((m = lys_ext_iter(dev->ext, dev->ext_size, m + 1, substmt)) != -1) {
/* deviate and its substatements include extensions, copy them to the target, replacing the previous
* extensions if any. In case of deviating extension itself, we have to deviate only the same type
* of the extension as specified in the deviation */
if (substmt == LYEXT_SUBSTMT_SELF && dev->ext[m]->def != extdef) {
continue;
}
if (substmt == LYEXT_SUBSTMT_SELF && dev->mod == LY_DEVIATE_ADD) {
/* in case of adding extension, we will be replacing only the inherited extensions */
do {
n = lys_ext_iter(target->ext, target->ext_size, n + 1, substmt);
} while (n != -1 && (target->ext[n]->def != extdef || !(target->ext[n]->flags & LYEXT_OPT_INHERIT)));
} else {
/* get the index of the extension to replace in the target node */
do {
n = lys_ext_iter(target->ext, target->ext_size, n + 1, substmt);
/* if we are applying extension deviation, we have to deviate only the same type of the extension */
} while (n != -1 && substmt == LYEXT_SUBSTMT_SELF && target->ext[n]->def != extdef);
}
if (n == -1) {
/* nothing to replace, we are going to add it - reallocate */
new = malloc(sizeof **target->ext);
LY_CHECK_ERR_RETURN(!new, LOGMEM(ctx), EXIT_FAILURE);
reallocated = realloc(target->ext, (target->ext_size + 1) * sizeof *target->ext);
LY_CHECK_ERR_RETURN(!reallocated, LOGMEM(ctx); free(new), EXIT_FAILURE);
target->ext = reallocated;
target->ext_size++;
n = target->ext_size - 1;
} else {
/* replacing - the original set of extensions is actually backuped together with the
* node itself, so we are supposed only to free the allocated data here ... */
lys_extension_instances_free(ctx, target->ext[n]->ext, target->ext[n]->ext_size, NULL);
lydict_remove(ctx, target->ext[n]->arg_value);
free(target->ext[n]);
/* and prepare the new structure */
new = malloc(sizeof **target->ext);
LY_CHECK_ERR_RETURN(!new, LOGMEM(ctx), EXIT_FAILURE);
}
/* common part for adding and replacing - fill the newly created / replaced cell */
target->ext[n] = new;
target->ext[n]->def = dev->ext[m]->def;
target->ext[n]->arg_value = lydict_insert(ctx, dev->ext[m]->arg_value, 0);
target->ext[n]->flags = 0;
target->ext[n]->parent = target;
target->ext[n]->parent_type = LYEXT_PAR_NODE;
target->ext[n]->insubstmt = substmt;
target->ext[n]->insubstmt_index = dev->ext[m]->insubstmt_index;
target->ext[n]->ext_size = dev->ext[m]->ext_size;
lys_ext_dup(ctx, target->module, dev->ext[m]->ext, dev->ext[m]->ext_size, target, LYEXT_PAR_NODE,
&target->ext[n]->ext, 1, NULL);
target->ext[n]->nodetype = LYS_EXT;
target->ext[n]->module = target->module;
target->ext[n]->priv = NULL;
/* TODO cover complex extension instances */
}
/* remove the rest of extensions belonging to the original substatement in the target node,
* due to possible reverting of the deviation effect, they are actually not removed, just moved
* to the backup of the original node when the original node is backuped, here we just have to
* free the replaced / deleted originals */
while ((n = lys_ext_iter(target->ext, target->ext_size, n + 1, substmt)) != -1) {
if (substmt == LYEXT_SUBSTMT_SELF) {
/* if we are applying extension deviation, we are going to remove only
* - the same type of the extension in case of replacing
* - the same type of the extension which was inherited in case of adding
* note - delete deviation is covered in lyp_deviate_del_ext */
if (target->ext[n]->def != extdef ||
(dev->mod == LY_DEVIATE_ADD && !(target->ext[n]->flags & LYEXT_OPT_INHERIT))) {
/* keep this extension */
continue;
}
}
/* remove the item */
lyp_ext_instance_rm(ctx, &target->ext, &target->ext_size, n);
--n;
}
return EXIT_SUCCESS;
}
/*
* not-supported deviations are not processed since they affect the complete node, not just their substatements
*/
int
lyp_deviation_apply_ext(struct lys_module *module)
{
int i, j, k;
struct lys_deviate *dev;
struct lys_node *target;
struct ly_set *extset;
for (i = 0; i < module->deviation_size; i++) {
target = NULL;
extset = NULL;
j = resolve_schema_nodeid(module->deviation[i].target_name, NULL, module, &extset, 0, 0);
if (j == -1) {
return EXIT_FAILURE;
} else if (!extset) {
/* LY_DEVIATE_NO */
ly_set_free(extset);
continue;
}
target = extset->set.s[0];
ly_set_free(extset);
for (j = 0; j < module->deviation[i].deviate_size; j++) {
dev = &module->deviation[i].deviate[j];
if (!dev->ext_size) {
/* no extensions in deviate and its substatement, nothing to do here */
continue;
}
/* extensions */
if (dev->mod == LY_DEVIATE_DEL) {
k = -1;
while ((k = lys_ext_iter(dev->ext, dev->ext_size, k + 1, LYEXT_SUBSTMT_SELF)) != -1) {
if (lyp_deviate_del_ext(target, dev->ext[k])) {
return EXIT_FAILURE;
}
}
/* In case of LY_DEVIATE_DEL, we are applying only extension deviation, removing
* of the substatement's extensions was already done when the substatement was applied.
* Extension deviation could not be applied by the parser since the extension could be unresolved,
* which is not the issue of the other substatements. */
continue;
} else {
extset = ly_set_new();
k = -1;
while ((k = lys_ext_iter(dev->ext, dev->ext_size, k + 1, LYEXT_SUBSTMT_SELF)) != -1) {
ly_set_add(extset, dev->ext[k]->def, 0);
}
for (k = 0; (unsigned int)k < extset->number; k++) {
if (lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_SELF, (struct lys_ext *)extset->set.g[k])) {
ly_set_free(extset);
return EXIT_FAILURE;
}
}
ly_set_free(extset);
}
/* unique */
if (dev->unique_size && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_UNIQUE, NULL)) {
return EXIT_FAILURE;
}
/* units */
if (dev->units && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_UNITS, NULL)) {
return EXIT_FAILURE;
}
/* default */
if (dev->dflt_size && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_DEFAULT, NULL)) {
return EXIT_FAILURE;
}
/* config */
if ((dev->flags & LYS_CONFIG_MASK) && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_CONFIG, NULL)) {
return EXIT_FAILURE;
}
/* mandatory */
if ((dev->flags & LYS_MAND_MASK) && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_MANDATORY, NULL)) {
return EXIT_FAILURE;
}
/* min/max */
if (dev->min_set && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_MIN, NULL)) {
return EXIT_FAILURE;
}
if (dev->min_set && lyp_deviate_apply_ext(dev, target, LYEXT_SUBSTMT_MAX, NULL)) {
return EXIT_FAILURE;
}
/* type and must contain extension instances in their structures */
}
}
return EXIT_SUCCESS;
}
int
lyp_ctx_check_module(struct lys_module *module)
{
struct ly_ctx *ctx;
int i, match_i = -1, to_implement;
const char *last_rev = NULL;
assert(module);
to_implement = 0;
ctx = module->ctx;
/* find latest revision */
for (i = 0; i < module->rev_size; ++i) {
if (!last_rev || (strcmp(last_rev, module->rev[i].date) < 0)) {
last_rev = module->rev[i].date;
}
}
for (i = 0; i < ctx->models.used; i++) {
/* check name (name/revision) and namespace uniqueness */
if (!strcmp(ctx->models.list[i]->name, module->name)) {
if (to_implement) {
if (i == match_i) {
continue;
}
LOGERR(ctx, LY_EINVAL, "Module \"%s@%s\" in another revision \"%s\" already implemented.",
module->name, last_rev ? last_rev : "<latest>", ctx->models.list[i]->rev[0].date);
return -1;
} else if (!ctx->models.list[i]->rev_size && module->rev_size) {
LOGERR(ctx, LY_EINVAL, "Module \"%s\" without revision already in context.", module->name);
return -1;
} else if (ctx->models.list[i]->rev_size && !module->rev_size) {
LOGERR(ctx, LY_EINVAL, "Module \"%s\" with revision \"%s\" already in context.",
module->name, ctx->models.list[i]->rev[0].date);
return -1;
} else if ((!module->rev_size && !ctx->models.list[i]->rev_size)
|| !strcmp(ctx->models.list[i]->rev[0].date, last_rev)) {
LOGVRB("Module \"%s@%s\" already in context.", module->name, last_rev ? last_rev : "<latest>");
/* if disabled, enable first */
if (ctx->models.list[i]->disabled) {
lys_set_enabled(ctx->models.list[i]);
}
to_implement = module->implemented;
match_i = i;
if (to_implement && !ctx->models.list[i]->implemented) {
/* check first that it is okay to change it to implemented */
i = -1;
continue;
}
return 1;
} else if (module->implemented && ctx->models.list[i]->implemented) {
LOGERR(ctx, LY_EINVAL, "Module \"%s@%s\" in another revision \"%s\" already implemented.",
module->name, last_rev ? last_rev : "<latest>", ctx->models.list[i]->rev[0].date);
return -1;
}
/* else keep searching, for now the caller is just adding
* another revision of an already present schema
*/
} else if (!strcmp(ctx->models.list[i]->ns, module->ns)) {
LOGERR(ctx, LY_EINVAL, "Two different modules (\"%s\" and \"%s\") have the same namespace \"%s\".",
ctx->models.list[i]->name, module->name, module->ns);
return -1;
}
}
if (to_implement) {
if (lys_set_implemented(ctx->models.list[match_i])) {
return -1;
}
return 1;
}
return 0;
}
int
lyp_ctx_add_module(struct lys_module *module)
{
struct lys_module **newlist = NULL;
int i;
assert(!lyp_ctx_check_module(module));
#ifndef NDEBUG
int j;
/* check that all augments are resolved */
for (i = 0; i < module->augment_size; ++i) {
assert(module->augment[i].target);
}
for (i = 0; i < module->inc_size; ++i) {
for (j = 0; j < module->inc[i].submodule->augment_size; ++j) {
assert(module->inc[i].submodule->augment[j].target);
}
}
#endif
/* add to the context's list of modules */
if (module->ctx->models.used == module->ctx->models.size) {
newlist = realloc(module->ctx->models.list, (2 * module->ctx->models.size) * sizeof *newlist);
LY_CHECK_ERR_RETURN(!newlist, LOGMEM(module->ctx), -1);
for (i = module->ctx->models.size; i < module->ctx->models.size * 2; i++) {
newlist[i] = NULL;
}
module->ctx->models.size *= 2;
module->ctx->models.list = newlist;
}
module->ctx->models.list[module->ctx->models.used++] = module;
module->ctx->models.module_set_id++;
return 0;
}
/**
* Store UTF-8 character specified as 4byte integer into the dst buffer.
* Returns number of written bytes (4 max), expects that dst has enough space.
*
* UTF-8 mapping:
* 00000000 -- 0000007F: 0xxxxxxx
* 00000080 -- 000007FF: 110xxxxx 10xxxxxx
* 00000800 -- 0000FFFF: 1110xxxx 10xxxxxx 10xxxxxx
* 00010000 -- 001FFFFF: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
*
* Includes checking for valid characters (following RFC 7950, sec 9.4)
*/
unsigned int
pututf8(struct ly_ctx *ctx, char *dst, int32_t value)
{
if (value < 0x80) {
/* one byte character */
if (value < 0x20 &&
value != 0x09 &&
value != 0x0a &&
value != 0x0d) {
goto error;
}
dst[0] = value;
return 1;
} else if (value < 0x800) {
/* two bytes character */
dst[0] = 0xc0 | (value >> 6);
dst[1] = 0x80 | (value & 0x3f);
return 2;
} else if (value < 0xfffe) {
/* three bytes character */
if (((value & 0xf800) == 0xd800) ||
(value >= 0xfdd0 && value <= 0xfdef)) {
/* exclude surrogate blocks %xD800-DFFF */
/* exclude noncharacters %xFDD0-FDEF */
goto error;
}
dst[0] = 0xe0 | (value >> 12);
dst[1] = 0x80 | ((value >> 6) & 0x3f);
dst[2] = 0x80 | (value & 0x3f);
return 3;
} else if (value < 0x10fffe) {
if ((value & 0xffe) == 0xffe) {
/* exclude noncharacters %xFFFE-FFFF, %x1FFFE-1FFFF, %x2FFFE-2FFFF, %x3FFFE-3FFFF, %x4FFFE-4FFFF,
* %x5FFFE-5FFFF, %x6FFFE-6FFFF, %x7FFFE-7FFFF, %x8FFFE-8FFFF, %x9FFFE-9FFFF, %xAFFFE-AFFFF,
* %xBFFFE-BFFFF, %xCFFFE-CFFFF, %xDFFFE-DFFFF, %xEFFFE-EFFFF, %xFFFFE-FFFFF, %x10FFFE-10FFFF */
goto error;
}
/* four bytes character */
dst[0] = 0xf0 | (value >> 18);
dst[1] = 0x80 | ((value >> 12) & 0x3f);
dst[2] = 0x80 | ((value >> 6) & 0x3f);
dst[3] = 0x80 | (value & 0x3f);
return 4;
}
error:
/* out of range */
LOGVAL(ctx, LYE_XML_INCHAR, LY_VLOG_NONE, NULL, NULL);
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Invalid UTF-8 value 0x%08x", value);
return 0;
}
unsigned int
copyutf8(struct ly_ctx *ctx, char *dst, const char *src)
{
uint32_t value;
/* unicode characters */
if (!(src[0] & 0x80)) {
/* one byte character */
if (src[0] < 0x20 &&
src[0] != 0x09 &&
src[0] != 0x0a &&
src[0] != 0x0d) {
LOGVAL(ctx, LYE_XML_INCHAR, LY_VLOG_NONE, NULL, src);
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Invalid UTF-8 value 0x%02x", src[0]);
return 0;
}
dst[0] = src[0];
return 1;
} else if (!(src[0] & 0x20)) {
/* two bytes character */
dst[0] = src[0];
dst[1] = src[1];
return 2;
} else if (!(src[0] & 0x10)) {
/* three bytes character */
value = ((uint32_t)(src[0] & 0xf) << 12) | ((uint32_t)(src[1] & 0x3f) << 6) | (src[2] & 0x3f);
if (((value & 0xf800) == 0xd800) ||
(value >= 0xfdd0 && value <= 0xfdef) ||
(value & 0xffe) == 0xffe) {
/* exclude surrogate blocks %xD800-DFFF */
/* exclude noncharacters %xFDD0-FDEF */
/* exclude noncharacters %xFFFE-FFFF */
LOGVAL(ctx, LYE_XML_INCHAR, LY_VLOG_NONE, NULL, src);
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Invalid UTF-8 value 0x%08x", value);
return 0;
}
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
return 3;
} else if (!(src[0] & 0x08)) {
/* four bytes character */
value = ((uint32_t)(src[0] & 0x7) << 18) | ((uint32_t)(src[1] & 0x3f) << 12) | ((uint32_t)(src[2] & 0x3f) << 6) | (src[3] & 0x3f);
if ((value & 0xffe) == 0xffe) {
/* exclude noncharacters %x1FFFE-1FFFF, %x2FFFE-2FFFF, %x3FFFE-3FFFF, %x4FFFE-4FFFF,
* %x5FFFE-5FFFF, %x6FFFE-6FFFF, %x7FFFE-7FFFF, %x8FFFE-8FFFF, %x9FFFE-9FFFF, %xAFFFE-AFFFF,
* %xBFFFE-BFFFF, %xCFFFE-CFFFF, %xDFFFE-DFFFF, %xEFFFE-EFFFF, %xFFFFE-FFFFF, %x10FFFE-10FFFF */
LOGVAL(ctx, LYE_XML_INCHAR, LY_VLOG_NONE, NULL, src);
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Invalid UTF-8 value 0x%08x", value);
return 0;
}
dst[0] = src[0];
dst[1] = src[1];
dst[2] = src[2];
dst[3] = src[3];
return 4;
} else {
LOGVAL(ctx, LYE_XML_INCHAR, LY_VLOG_NONE, NULL, src);
LOGVAL(ctx, LYE_SPEC, LY_VLOG_NONE, NULL, "Invalid UTF-8 leading byte 0x%02x", src[0]);
return 0;
}
}
const struct lys_module *
lyp_get_module(const struct lys_module *module, const char *prefix, int pref_len, const char *name, int name_len, int in_data)
{
const struct lys_module *main_module;
char *str;
int i;
assert(!prefix || !name);
if (prefix && !pref_len) {
pref_len = strlen(prefix);
}
if (name && !name_len) {
name_len = strlen(name);
}
main_module = lys_main_module(module);
/* module own prefix, submodule own prefix, (sub)module own name */
if ((!prefix || (!module->type && !strncmp(main_module->prefix, prefix, pref_len) && !main_module->prefix[pref_len])
|| (module->type && !strncmp(module->prefix, prefix, pref_len) && !module->prefix[pref_len]))
&& (!name || (!strncmp(main_module->name, name, name_len) && !main_module->name[name_len]))) {
return main_module;
}
/* standard import */
for (i = 0; i < module->imp_size; ++i) {
if ((!prefix || (!strncmp(module->imp[i].prefix, prefix, pref_len) && !module->imp[i].prefix[pref_len]))
&& (!name || (!strncmp(module->imp[i].module->name, name, name_len) && !module->imp[i].module->name[name_len]))) {
return module->imp[i].module;
}
}
/* module required by a foreign grouping, deviation, or submodule */
if (name) {
str = strndup(name, name_len);
if (!str) {
LOGMEM(module->ctx);
return NULL;
}
main_module = ly_ctx_get_module(module->ctx, str, NULL, 0);
/* try data callback */
if (!main_module && in_data && module->ctx->data_clb) {
main_module = module->ctx->data_clb(module->ctx, str, NULL, 0, module->ctx->data_clb_data);
}
free(str);
return main_module;
}
return NULL;
}
const struct lys_module *
lyp_get_import_module_ns(const struct lys_module *module, const char *ns)
{
int i;
const struct lys_module *mod = NULL;
assert(module && ns);
if (module->type) {
/* the module is actually submodule and to get the namespace, we need the main module */
if (ly_strequal(((struct lys_submodule *)module)->belongsto->ns, ns, 0)) {
return ((struct lys_submodule *)module)->belongsto;
}
} else {
/* module's own namespace */
if (ly_strequal(module->ns, ns, 0)) {
return module;
}
}
/* imported modules */
for (i = 0; i < module->imp_size; ++i) {
if (ly_strequal(module->imp[i].module->ns, ns, 0)) {
return module->imp[i].module;
}
}
return mod;
}
const char *
lyp_get_yang_data_template_name(const struct lyd_node *node)
{
struct lys_node *snode;
snode = lys_parent(node->schema);
while (snode && snode->nodetype & (LYS_USES | LYS_CASE | LYS_CHOICE)) {
snode = lys_parent(snode);
}
if (snode && snode->nodetype == LYS_EXT && strcmp(((struct lys_ext_instance_complex *)snode)->def->name, "yang-data") == 0) {
return ((struct lys_ext_instance_complex *)snode)->arg_value;
} else {
return NULL;
}
}
const struct lys_node *
lyp_get_yang_data_template(const struct lys_module *module, const char *yang_data_name, int yang_data_name_len)
{
int i, j;
const struct lys_node *ret = NULL;
const struct lys_submodule *submodule;
for(i = 0; i < module->ext_size; ++i) {
if (!strcmp(module->ext[i]->def->name, "yang-data") && !strncmp(module->ext[i]->arg_value, yang_data_name, yang_data_name_len)
&& !module->ext[i]->arg_value[yang_data_name_len]) {
ret = (struct lys_node *)module->ext[i];
break;
}
}
for(j = 0; !ret && j < module->inc_size; ++j) {
submodule = module->inc[j].submodule;
for(i = 0; i < submodule->ext_size; ++i) {
if (!strcmp(submodule->ext[i]->def->name, "yang-data") && !strncmp(submodule->ext[i]->arg_value, yang_data_name, yang_data_name_len)
&& !submodule->ext[i]->arg_value[yang_data_name_len]) {
ret = (struct lys_node *)submodule->ext[i];
break;
}
}
}
return ret;
}