Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 1 | /** |
| 2 | * @file tree_schema_helpers.c |
| 3 | * @author Radek Krejci <rkrejci@cesnet.cz> |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 4 | * @brief Parsing and validation helper functions for schema trees |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 5 | * |
| 6 | * Copyright (c) 2015 - 2018 CESNET, z.s.p.o. |
| 7 | * |
| 8 | * This source code is licensed under BSD 3-Clause License (the "License"). |
| 9 | * You may not use this file except in compliance with the License. |
| 10 | * You may obtain a copy of the License at |
| 11 | * |
| 12 | * https://opensource.org/licenses/BSD-3-Clause |
| 13 | */ |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 14 | #include "common.h" |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 15 | |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 16 | #include <assert.h> |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 17 | #include <ctype.h> |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 18 | #include <errno.h> |
| 19 | #include <fcntl.h> |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 20 | #include <limits.h> |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 21 | #include <stdint.h> |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 22 | #include <stdlib.h> |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 23 | #include <string.h> |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 24 | #include <unistd.h> |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 25 | #include <time.h> |
| 26 | |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 27 | #include "context.h" |
| 28 | #include "dict.h" |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 29 | #include "hash_table.h" |
| 30 | #include "log.h" |
Radek Krejci | 0935f41 | 2019-08-20 16:15:18 +0200 | [diff] [blame] | 31 | #include "plugins_exts.h" |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 32 | #include "set.h" |
| 33 | #include "tree.h" |
| 34 | #include "tree_schema.h" |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 35 | #include "tree_schema_internal.h" |
| 36 | |
Radek Krejci | 8574795 | 2019-06-07 16:43:43 +0200 | [diff] [blame] | 37 | LY_ERR |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 38 | lys_resolve_schema_nodeid(struct lysc_ctx *ctx, const char *nodeid, size_t nodeid_len, const struct lysc_node *context_node, |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 39 | const struct lys_module *context_module, int nodetype, int implement, |
| 40 | const struct lysc_node **target, uint16_t *result_flag) |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 41 | { |
| 42 | LY_ERR ret = LY_EVALID; |
| 43 | const char *name, *prefix, *id; |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 44 | size_t name_len, prefix_len; |
Radek Krejci | 7af6424 | 2019-02-18 13:07:53 +0100 | [diff] [blame] | 45 | const struct lys_module *mod; |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 46 | const char *nodeid_type; |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 47 | int getnext_extra_flag = 0; |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 48 | int current_nodetype = 0; |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 49 | |
| 50 | assert(nodeid); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 51 | assert(target); |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 52 | assert(result_flag); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 53 | *target = NULL; |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 54 | *result_flag = 0; |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 55 | |
| 56 | id = nodeid; |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 57 | |
| 58 | if (context_node) { |
| 59 | /* descendant-schema-nodeid */ |
| 60 | nodeid_type = "descendant"; |
Radek Krejci | 3641f56 | 2019-02-13 15:38:40 +0100 | [diff] [blame] | 61 | |
| 62 | if (*id == '/') { |
| 63 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
| 64 | "Invalid descendant-schema-nodeid value \"%.*s\" - absolute-schema-nodeid used.", |
| 65 | nodeid_len ? nodeid_len : strlen(nodeid), nodeid); |
| 66 | return LY_EVALID; |
| 67 | } |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 68 | } else { |
| 69 | /* absolute-schema-nodeid */ |
| 70 | nodeid_type = "absolute"; |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 71 | |
| 72 | if (*id != '/') { |
| 73 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
| 74 | "Invalid absolute-schema-nodeid value \"%.*s\" - missing starting \"/\".", |
Radek Krejci | 3641f56 | 2019-02-13 15:38:40 +0100 | [diff] [blame] | 75 | nodeid_len ? nodeid_len : strlen(nodeid), nodeid); |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 76 | return LY_EVALID; |
| 77 | } |
| 78 | ++id; |
| 79 | } |
| 80 | |
Radek Krejci | b4a4a27 | 2019-06-10 12:44:52 +0200 | [diff] [blame] | 81 | while (*id && (ret = ly_parse_nodeid(&id, &prefix, &prefix_len, &name, &name_len)) == LY_SUCCESS) { |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 82 | if (prefix) { |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 83 | mod = lys_module_find_prefix(context_module, prefix, prefix_len); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 84 | if (!mod) { |
| 85 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 86 | "Invalid %s-schema-nodeid value \"%.*s\" - prefix \"%.*s\" not defined in module \"%s\".", |
| 87 | nodeid_type, id - nodeid, nodeid, prefix_len, prefix, context_module->name); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 88 | return LY_ENOTFOUND; |
| 89 | } |
| 90 | } else { |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 91 | mod = context_module; |
| 92 | } |
| 93 | if (implement && !mod->implemented) { |
| 94 | /* make the module implemented */ |
Michal Vasko | 294b76d | 2019-12-16 10:37:54 +0100 | [diff] [blame] | 95 | ret = lys_set_implemented_internal((struct lys_module*)mod, 2); |
| 96 | LY_CHECK_RET(ret); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 97 | } |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 98 | if (context_node && context_node->nodetype == LYS_ACTION) { |
| 99 | /* move through input/output manually */ |
Radek Krejci | 7f9b651 | 2019-09-18 13:11:09 +0200 | [diff] [blame] | 100 | if (!ly_strncmp("input", name, name_len)) { |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 101 | (*result_flag) |= LYSC_OPT_RPC_INPUT; |
Radek Krejci | 7f9b651 | 2019-09-18 13:11:09 +0200 | [diff] [blame] | 102 | } else if (!ly_strncmp("output", name, name_len)) { |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 103 | (*result_flag) |= LYSC_OPT_RPC_OUTPUT; |
| 104 | getnext_extra_flag = LYS_GETNEXT_OUTPUT; |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 105 | } else { |
| 106 | goto getnext; |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 107 | } |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 108 | current_nodetype = LYS_INOUT; |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 109 | } else { |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 110 | getnext: |
Michal Vasko | e444f75 | 2020-02-10 12:20:06 +0100 | [diff] [blame] | 111 | context_node = lys_find_child(context_node, mod, name, name_len, 0, |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 112 | getnext_extra_flag | LYS_GETNEXT_NOSTATECHECK | LYS_GETNEXT_WITHCHOICE | LYS_GETNEXT_WITHCASE); |
| 113 | if (!context_node) { |
| 114 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
| 115 | "Invalid %s-schema-nodeid value \"%.*s\" - target node not found.", nodeid_type, id - nodeid, nodeid); |
| 116 | return LY_ENOTFOUND; |
| 117 | } |
| 118 | getnext_extra_flag = 0; |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 119 | current_nodetype = context_node->nodetype; |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 120 | |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 121 | if (current_nodetype == LYS_NOTIF) { |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 122 | (*result_flag) |= LYSC_OPT_NOTIFICATION; |
| 123 | } |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 124 | } |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 125 | if (!*id || (nodeid_len && ((size_t)(id - nodeid) >= nodeid_len))) { |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 126 | break; |
| 127 | } |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 128 | if (*id != '/') { |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 129 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 130 | "Invalid %s-schema-nodeid value \"%.*s\" - missing \"/\" as node-identifier separator.", |
| 131 | nodeid_type, id - nodeid + 1, nodeid); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 132 | return LY_EVALID; |
| 133 | } |
| 134 | ++id; |
| 135 | } |
| 136 | |
| 137 | if (ret == LY_SUCCESS) { |
Radek Krejci | 7af6424 | 2019-02-18 13:07:53 +0100 | [diff] [blame] | 138 | *target = context_node; |
Radek Krejci | 05b774b | 2019-02-25 13:26:18 +0100 | [diff] [blame] | 139 | if (nodetype & LYS_INOUT) { |
| 140 | /* instead of input/output nodes, the RPC/action node is actually returned */ |
| 141 | } |
| 142 | if (nodetype && !(current_nodetype & nodetype)) { |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 143 | return LY_EDENIED; |
| 144 | } |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 145 | } else { |
| 146 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
| 147 | "Invalid %s-schema-nodeid value \"%.*s\" - unexpected end of expression.", |
Radek Krejci | 3641f56 | 2019-02-13 15:38:40 +0100 | [diff] [blame] | 148 | nodeid_type, nodeid_len ? nodeid_len : strlen(nodeid), nodeid); |
Radek Krejci | 9bb94eb | 2018-12-04 16:48:35 +0100 | [diff] [blame] | 149 | } |
| 150 | |
| 151 | return ret; |
| 152 | } |
| 153 | |
| 154 | LY_ERR |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 155 | lysp_check_prefix(struct lys_parser_ctx *ctx, struct lysp_import *imports, const char *module_prefix, const char **value) |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 156 | { |
| 157 | struct lysp_import *i; |
| 158 | |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 159 | if (module_prefix && &module_prefix != value && !strcmp(module_prefix, *value)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 160 | LOGVAL_PARSER(ctx, LYVE_REFERENCE, "Prefix \"%s\" already used as module prefix.", *value); |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 161 | return LY_EEXIST; |
| 162 | } |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 163 | LY_ARRAY_FOR(imports, struct lysp_import, i) { |
| 164 | if (i->prefix && &i->prefix != value && !strcmp(i->prefix, *value)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 165 | LOGVAL_PARSER(ctx, LYVE_REFERENCE, "Prefix \"%s\" already used to import \"%s\" module.", *value, i->name); |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 166 | return LY_EEXIST; |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 167 | } |
| 168 | } |
| 169 | return LY_SUCCESS; |
| 170 | } |
| 171 | |
| 172 | LY_ERR |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 173 | lysc_check_status(struct lysc_ctx *ctx, |
| 174 | uint16_t flags1, void *mod1, const char *name1, |
| 175 | uint16_t flags2, void *mod2, const char *name2) |
| 176 | { |
| 177 | uint16_t flg1, flg2; |
| 178 | |
| 179 | flg1 = (flags1 & LYS_STATUS_MASK) ? (flags1 & LYS_STATUS_MASK) : LYS_STATUS_CURR; |
| 180 | flg2 = (flags2 & LYS_STATUS_MASK) ? (flags2 & LYS_STATUS_MASK) : LYS_STATUS_CURR; |
| 181 | |
| 182 | if ((flg1 < flg2) && (mod1 == mod2)) { |
| 183 | if (ctx) { |
| 184 | LOGVAL(ctx->ctx, LY_VLOG_STR, ctx->path, LYVE_REFERENCE, |
| 185 | "A %s definition \"%s\" is not allowed to reference %s definition \"%s\".", |
| 186 | flg1 == LYS_STATUS_CURR ? "current" : "deprecated", name1, |
| 187 | flg2 == LYS_STATUS_OBSLT ? "obsolete" : "deprecated", name2); |
| 188 | } |
| 189 | return LY_EVALID; |
| 190 | } |
| 191 | |
| 192 | return LY_SUCCESS; |
| 193 | } |
| 194 | |
| 195 | LY_ERR |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 196 | lysp_check_date(struct lys_parser_ctx *ctx, const char *date, int date_len, const char *stmt) |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 197 | { |
| 198 | int i; |
| 199 | struct tm tm, tm_; |
| 200 | char *r; |
| 201 | |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 202 | LY_CHECK_ARG_RET(ctx ? PARSER_CTX(ctx) : NULL, date, LY_EINVAL); |
| 203 | LY_CHECK_ERR_RET(date_len != LY_REV_SIZE - 1, LOGARG(ctx ? PARSER_CTX(ctx) : NULL, date_len), LY_EINVAL); |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 204 | |
| 205 | /* check format */ |
| 206 | for (i = 0; i < date_len; i++) { |
| 207 | if (i == 4 || i == 7) { |
| 208 | if (date[i] != '-') { |
| 209 | goto error; |
| 210 | } |
| 211 | } else if (!isdigit(date[i])) { |
| 212 | goto error; |
| 213 | } |
| 214 | } |
| 215 | |
| 216 | /* check content, e.g. 2018-02-31 */ |
| 217 | memset(&tm, 0, sizeof tm); |
| 218 | r = strptime(date, "%Y-%m-%d", &tm); |
| 219 | if (!r || r != &date[LY_REV_SIZE - 1]) { |
| 220 | goto error; |
| 221 | } |
| 222 | memcpy(&tm_, &tm, sizeof tm); |
| 223 | mktime(&tm_); /* mktime modifies tm_ if it refers invalid date */ |
| 224 | if (tm.tm_mday != tm_.tm_mday) { /* e.g 2018-02-29 -> 2018-03-01 */ |
| 225 | /* checking days is enough, since other errors |
| 226 | * have been checked by strptime() */ |
| 227 | goto error; |
| 228 | } |
| 229 | |
| 230 | return LY_SUCCESS; |
| 231 | |
| 232 | error: |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 233 | if (stmt) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 234 | if (ctx) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 235 | LOGVAL_PARSER(ctx, LY_VCODE_INVAL, date_len, date, stmt); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 236 | } else { |
| 237 | LOGVAL(NULL, LY_VLOG_NONE, NULL, LY_VCODE_INVAL, date_len, date, stmt); |
| 238 | } |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 239 | } |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 240 | return LY_EINVAL; |
| 241 | } |
| 242 | |
| 243 | void |
| 244 | lysp_sort_revisions(struct lysp_revision *revs) |
| 245 | { |
| 246 | uint8_t i, r; |
| 247 | struct lysp_revision rev; |
| 248 | |
| 249 | for (i = 1, r = 0; revs && i < LY_ARRAY_SIZE(revs); i++) { |
Radek Krejci | b7db73a | 2018-10-24 14:18:40 +0200 | [diff] [blame] | 250 | if (strcmp(revs[i].date, revs[r].date) > 0) { |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 251 | r = i; |
| 252 | } |
| 253 | } |
| 254 | |
| 255 | if (r) { |
| 256 | /* the newest revision is not on position 0, switch them */ |
Radek Krejci | 2c4e717 | 2018-10-19 15:56:26 +0200 | [diff] [blame] | 257 | memcpy(&rev, &revs[0], sizeof rev); |
| 258 | memcpy(&revs[0], &revs[r], sizeof rev); |
| 259 | memcpy(&revs[r], &rev, sizeof rev); |
Radek Krejci | 86d106e | 2018-10-18 09:53:19 +0200 | [diff] [blame] | 260 | } |
| 261 | } |
Radek Krejci | 151a5b7 | 2018-10-19 14:21:44 +0200 | [diff] [blame] | 262 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 263 | static const struct lysp_tpdf * |
| 264 | lysp_type_match(const char *name, struct lysp_node *node) |
| 265 | { |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 266 | const struct lysp_tpdf *typedefs; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 267 | unsigned int u; |
| 268 | |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 269 | typedefs = lysp_node_typedefs(node); |
| 270 | LY_ARRAY_FOR(typedefs, u) { |
| 271 | if (!strcmp(name, typedefs[u].name)) { |
| 272 | /* match */ |
| 273 | return &typedefs[u]; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 274 | } |
| 275 | } |
| 276 | |
| 277 | return NULL; |
| 278 | } |
| 279 | |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 280 | static LY_DATA_TYPE |
| 281 | lysp_type_str2builtin(const char *name, size_t len) |
| 282 | { |
| 283 | if (len >= 4) { /* otherwise it does not match any built-in type */ |
| 284 | if (name[0] == 'b') { |
| 285 | if (name[1] == 'i') { |
| 286 | if (len == 6 && !strncmp(&name[2], "nary", 4)) { |
| 287 | return LY_TYPE_BINARY; |
| 288 | } else if (len == 4 && !strncmp(&name[2], "ts", 2)) { |
| 289 | return LY_TYPE_BITS; |
| 290 | } |
| 291 | } else if (len == 7 && !strncmp(&name[1], "oolean", 6)) { |
| 292 | return LY_TYPE_BOOL; |
| 293 | } |
| 294 | } else if (name[0] == 'd') { |
| 295 | if (len == 9 && !strncmp(&name[1], "ecimal64", 8)) { |
| 296 | return LY_TYPE_DEC64; |
| 297 | } |
| 298 | } else if (name[0] == 'e') { |
| 299 | if (len == 5 && !strncmp(&name[1], "mpty", 4)) { |
| 300 | return LY_TYPE_EMPTY; |
| 301 | } else if (len == 11 && !strncmp(&name[1], "numeration", 10)) { |
| 302 | return LY_TYPE_ENUM; |
| 303 | } |
| 304 | } else if (name[0] == 'i') { |
| 305 | if (name[1] == 'n') { |
| 306 | if (len == 4 && !strncmp(&name[2], "t8", 2)) { |
| 307 | return LY_TYPE_INT8; |
| 308 | } else if (len == 5) { |
| 309 | if (!strncmp(&name[2], "t16", 3)) { |
| 310 | return LY_TYPE_INT16; |
| 311 | } else if (!strncmp(&name[2], "t32", 3)) { |
| 312 | return LY_TYPE_INT32; |
| 313 | } else if (!strncmp(&name[2], "t64", 3)) { |
| 314 | return LY_TYPE_INT64; |
| 315 | } |
| 316 | } else if (len == 19 && !strncmp(&name[2], "stance-identifier", 17)) { |
| 317 | return LY_TYPE_INST; |
| 318 | } |
| 319 | } else if (len == 11 && !strncmp(&name[1], "dentityref", 10)) { |
| 320 | return LY_TYPE_IDENT; |
| 321 | } |
| 322 | } else if (name[0] == 'l') { |
| 323 | if (len == 7 && !strncmp(&name[1], "eafref", 6)) { |
| 324 | return LY_TYPE_LEAFREF; |
| 325 | } |
| 326 | } else if (name[0] == 's') { |
| 327 | if (len == 6 && !strncmp(&name[1], "tring", 5)) { |
| 328 | return LY_TYPE_STRING; |
| 329 | } |
| 330 | } else if (name[0] == 'u') { |
| 331 | if (name[1] == 'n') { |
| 332 | if (len == 5 && !strncmp(&name[2], "ion", 3)) { |
| 333 | return LY_TYPE_UNION; |
| 334 | } |
| 335 | } else if (name[1] == 'i' && name[2] == 'n' && name[3] == 't') { |
| 336 | if (len == 5 && name[4] == '8') { |
| 337 | return LY_TYPE_UINT8; |
| 338 | } else if (len == 6) { |
| 339 | if (!strncmp(&name[4], "16", 2)) { |
| 340 | return LY_TYPE_UINT16; |
| 341 | } else if (!strncmp(&name[4], "32", 2)) { |
| 342 | return LY_TYPE_UINT32; |
| 343 | } else if (!strncmp(&name[4], "64", 2)) { |
| 344 | return LY_TYPE_UINT64; |
| 345 | } |
| 346 | } |
| 347 | } |
| 348 | } |
| 349 | } |
| 350 | |
| 351 | return LY_TYPE_UNKNOWN; |
| 352 | } |
| 353 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 354 | LY_ERR |
| 355 | lysp_type_find(const char *id, struct lysp_node *start_node, struct lysp_module *start_module, |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 356 | LY_DATA_TYPE *type, const struct lysp_tpdf **tpdf, struct lysp_node **node, struct lysp_module **module) |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 357 | { |
| 358 | const char *str, *name; |
| 359 | struct lysp_tpdf *typedefs; |
| 360 | unsigned int u, v; |
| 361 | |
| 362 | assert(id); |
| 363 | assert(start_module); |
| 364 | assert(tpdf); |
| 365 | assert(node); |
| 366 | assert(module); |
| 367 | |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 368 | *node = NULL; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 369 | str = strchr(id, ':'); |
| 370 | if (str) { |
| 371 | *module = lysp_module_find_prefix(start_module, id, str - id); |
| 372 | name = str + 1; |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 373 | *type = LY_TYPE_UNKNOWN; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 374 | } else { |
| 375 | *module = start_module; |
| 376 | name = id; |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 377 | |
| 378 | /* check for built-in types */ |
| 379 | *type = lysp_type_str2builtin(name, strlen(name)); |
| 380 | if (*type) { |
| 381 | *tpdf = NULL; |
| 382 | return LY_SUCCESS; |
| 383 | } |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 384 | } |
| 385 | LY_CHECK_RET(!(*module), LY_ENOTFOUND); |
| 386 | |
| 387 | if (start_node && *module == start_module) { |
| 388 | /* search typedefs in parent's nodes */ |
| 389 | *node = start_node; |
| 390 | while (*node) { |
| 391 | *tpdf = lysp_type_match(name, *node); |
| 392 | if (*tpdf) { |
| 393 | /* match */ |
| 394 | return LY_SUCCESS; |
| 395 | } |
| 396 | *node = (*node)->parent; |
| 397 | } |
| 398 | } |
| 399 | |
| 400 | /* search in top-level typedefs */ |
| 401 | if ((*module)->typedefs) { |
| 402 | LY_ARRAY_FOR((*module)->typedefs, u) { |
| 403 | if (!strcmp(name, (*module)->typedefs[u].name)) { |
| 404 | /* match */ |
| 405 | *tpdf = &(*module)->typedefs[u]; |
| 406 | return LY_SUCCESS; |
| 407 | } |
| 408 | } |
| 409 | } |
| 410 | |
| 411 | /* search in submodules' typedefs */ |
| 412 | LY_ARRAY_FOR((*module)->includes, u) { |
| 413 | typedefs = (*module)->includes[u].submodule->typedefs; |
Radek Krejci | 76b3e96 | 2018-12-14 17:01:25 +0100 | [diff] [blame] | 414 | LY_ARRAY_FOR(typedefs, v) { |
| 415 | if (!strcmp(name, typedefs[v].name)) { |
| 416 | /* match */ |
| 417 | *tpdf = &typedefs[v]; |
| 418 | return LY_SUCCESS; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 419 | } |
| 420 | } |
| 421 | } |
| 422 | |
| 423 | return LY_ENOTFOUND; |
| 424 | } |
| 425 | |
David Sedlák | 6544c18 | 2019-07-12 13:17:33 +0200 | [diff] [blame] | 426 | LY_ERR |
David Sedlák | 07869a5 | 2019-07-12 14:28:19 +0200 | [diff] [blame] | 427 | lysp_check_enum_name(struct lys_parser_ctx *ctx, const char *name, size_t name_len) |
David Sedlák | 6544c18 | 2019-07-12 13:17:33 +0200 | [diff] [blame] | 428 | { |
| 429 | if (!name_len) { |
| 430 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not be zero-length."); |
| 431 | return LY_EVALID; |
| 432 | } else if (isspace(name[0]) || isspace(name[name_len - 1])) { |
| 433 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Enum name must not have any leading or trailing whitespaces (\"%.*s\").", |
| 434 | name_len, name); |
| 435 | return LY_EVALID; |
| 436 | } else { |
| 437 | for (size_t u = 0; u < name_len; ++u) { |
| 438 | if (iscntrl(name[u])) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 439 | LOGWRN(PARSER_CTX(ctx), "Control characters in enum name should be avoided (\"%.*s\", character number %d).", |
David Sedlák | 6544c18 | 2019-07-12 13:17:33 +0200 | [diff] [blame] | 440 | name_len, name, u + 1); |
| 441 | break; |
| 442 | } |
| 443 | } |
| 444 | } |
| 445 | |
| 446 | return LY_SUCCESS; |
| 447 | } |
| 448 | |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 449 | /** |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 450 | * @brief Check name of a new type to avoid name collisions. |
| 451 | * |
| 452 | * @param[in] ctx Parser context, module where the type is being defined is taken from here. |
| 453 | * @param[in] node Schema node where the type is being defined, NULL in case of a top-level typedef. |
| 454 | * @param[in] tpdf Typedef definition to check. |
| 455 | * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's |
| 456 | * typedefs are checked, caller is supposed to free the table. |
| 457 | * @param[in,out] tpdfs_global Initialized hash table to store temporary data between calls. When the module's |
| 458 | * typedefs are checked, caller is supposed to free the table. |
| 459 | * @return LY_EEXIST in case of collision, LY_SUCCESS otherwise. |
| 460 | */ |
| 461 | static LY_ERR |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 462 | lysp_check_typedef(struct lys_parser_ctx *ctx, struct lysp_node *node, const struct lysp_tpdf *tpdf, |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 463 | struct hash_table *tpdfs_global, struct hash_table *tpdfs_scoped) |
| 464 | { |
| 465 | struct lysp_node *parent; |
| 466 | uint32_t hash; |
| 467 | size_t name_len; |
| 468 | const char *name; |
| 469 | unsigned int u; |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 470 | const struct lysp_tpdf *typedefs; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 471 | |
| 472 | assert(ctx); |
| 473 | assert(tpdf); |
| 474 | |
| 475 | name = tpdf->name; |
| 476 | name_len = strlen(name); |
| 477 | |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 478 | if (lysp_type_str2builtin(name, name_len)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 479 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with a built-in type.", name); |
Radek Krejci | 4f28eda | 2018-11-12 11:46:16 +0100 | [diff] [blame] | 480 | return LY_EEXIST; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 481 | } |
| 482 | |
| 483 | /* check locally scoped typedefs (avoid name shadowing) */ |
| 484 | if (node) { |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 485 | typedefs = lysp_node_typedefs(node); |
| 486 | LY_ARRAY_FOR(typedefs, u) { |
| 487 | if (&typedefs[u] == tpdf) { |
| 488 | break; |
| 489 | } |
| 490 | if (!strcmp(name, typedefs[u].name)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 491 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with sibling type.", name); |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 492 | return LY_EEXIST; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 493 | } |
| 494 | } |
| 495 | /* search typedefs in parent's nodes */ |
Radek Krejci | 87e78ca | 2019-05-02 09:51:29 +0200 | [diff] [blame] | 496 | for (parent = node->parent; parent; parent = parent->parent) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 497 | if (lysp_type_match(name, parent)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 498 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with another scoped type.", name); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 499 | return LY_EEXIST; |
| 500 | } |
| 501 | } |
| 502 | } |
| 503 | |
| 504 | /* check collision with the top-level typedefs */ |
| 505 | hash = dict_hash(name, name_len); |
| 506 | if (node) { |
| 507 | lyht_insert(tpdfs_scoped, &name, hash, NULL); |
| 508 | if (!lyht_find(tpdfs_global, &name, hash, NULL)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 509 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - scoped type collide with a top-level type.", name); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 510 | return LY_EEXIST; |
| 511 | } |
| 512 | } else { |
| 513 | if (lyht_insert(tpdfs_global, &name, hash, NULL)) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 514 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid name \"%s\" of typedef - name collision with another top-level type.", name); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 515 | return LY_EEXIST; |
| 516 | } |
Radek Krejci | 3b1f929 | 2018-11-08 10:58:35 +0100 | [diff] [blame] | 517 | /* it is not necessary to test collision with the scoped types - in lysp_check_typedefs, all the |
| 518 | * top-level typedefs are inserted into the tables before the scoped typedefs, so the collision |
| 519 | * is detected in the first branch few lines above */ |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 520 | } |
| 521 | |
| 522 | return LY_SUCCESS; |
| 523 | } |
| 524 | |
| 525 | static int |
| 526 | lysp_id_cmp(void *val1, void *val2, int UNUSED(mod), void *UNUSED(cb_data)) |
| 527 | { |
| 528 | return !strcmp(val1, val2); |
| 529 | } |
| 530 | |
| 531 | LY_ERR |
David Sedlák | d2ebe57 | 2019-07-22 12:53:14 +0200 | [diff] [blame] | 532 | lysp_parse_finalize_reallocated(struct lys_parser_ctx *ctx, struct lysp_grp *groupings, struct lysp_augment *augments, |
| 533 | struct lysp_action *actions, struct lysp_notif *notifs) |
| 534 | { |
| 535 | unsigned int u, v; |
| 536 | struct lysp_node *child; |
| 537 | |
| 538 | /* finalize parent pointers to the reallocated items */ |
| 539 | |
| 540 | /* gropings */ |
| 541 | LY_ARRAY_FOR(groupings, u) { |
| 542 | LY_LIST_FOR(groupings[u].data, child) { |
| 543 | child->parent = (struct lysp_node*)&groupings[u]; |
| 544 | } |
| 545 | LY_ARRAY_FOR(groupings[u].actions, v) { |
| 546 | groupings[u].actions[v].parent = (struct lysp_node*)&groupings[u]; |
| 547 | } |
| 548 | LY_ARRAY_FOR(groupings[u].notifs, v) { |
| 549 | groupings[u].notifs[v].parent = (struct lysp_node*)&groupings[u]; |
| 550 | } |
| 551 | LY_ARRAY_FOR(groupings[u].groupings, v) { |
| 552 | groupings[u].groupings[v].parent = (struct lysp_node*)&groupings[u]; |
| 553 | } |
| 554 | if (groupings[u].typedefs) { |
| 555 | ly_set_add(&ctx->tpdfs_nodes, &groupings[u], 0); |
| 556 | } |
| 557 | } |
| 558 | |
| 559 | /* augments */ |
| 560 | LY_ARRAY_FOR(augments, u) { |
| 561 | LY_LIST_FOR(augments[u].child, child) { |
| 562 | child->parent = (struct lysp_node*)&augments[u]; |
| 563 | } |
| 564 | LY_ARRAY_FOR(augments[u].actions, v) { |
| 565 | augments[u].actions[v].parent = (struct lysp_node*)&augments[u]; |
| 566 | } |
| 567 | LY_ARRAY_FOR(augments[u].notifs, v) { |
| 568 | augments[u].notifs[v].parent = (struct lysp_node*)&augments[u]; |
| 569 | } |
| 570 | } |
| 571 | |
| 572 | /* actions */ |
| 573 | LY_ARRAY_FOR(actions, u) { |
| 574 | if (actions[u].input.parent) { |
| 575 | actions[u].input.parent = (struct lysp_node*)&actions[u]; |
| 576 | LY_LIST_FOR(actions[u].input.data, child) { |
| 577 | child->parent = (struct lysp_node*)&actions[u].input; |
| 578 | } |
| 579 | LY_ARRAY_FOR(actions[u].input.groupings, v) { |
| 580 | actions[u].input.groupings[v].parent = (struct lysp_node*)&actions[u].input; |
| 581 | } |
| 582 | if (actions[u].input.typedefs) { |
| 583 | ly_set_add(&ctx->tpdfs_nodes, &actions[u].input, 0); |
| 584 | } |
| 585 | } |
| 586 | if (actions[u].output.parent) { |
| 587 | actions[u].output.parent = (struct lysp_node*)&actions[u]; |
| 588 | LY_LIST_FOR(actions[u].output.data, child) { |
| 589 | child->parent = (struct lysp_node*)&actions[u].output; |
| 590 | } |
| 591 | LY_ARRAY_FOR(actions[u].output.groupings, v) { |
| 592 | actions[u].output.groupings[v].parent = (struct lysp_node*)&actions[u].output; |
| 593 | } |
| 594 | if (actions[u].output.typedefs) { |
| 595 | ly_set_add(&ctx->tpdfs_nodes, &actions[u].output, 0); |
| 596 | } |
| 597 | } |
| 598 | LY_ARRAY_FOR(actions[u].groupings, v) { |
| 599 | actions[u].groupings[v].parent = (struct lysp_node*)&actions[u]; |
| 600 | } |
| 601 | if (actions[u].typedefs) { |
| 602 | ly_set_add(&ctx->tpdfs_nodes, &actions[u], 0); |
| 603 | } |
| 604 | } |
| 605 | |
| 606 | /* notifications */ |
| 607 | LY_ARRAY_FOR(notifs, u) { |
| 608 | LY_LIST_FOR(notifs[u].data, child) { |
| 609 | child->parent = (struct lysp_node*)¬ifs[u]; |
| 610 | } |
| 611 | LY_ARRAY_FOR(notifs[u].groupings, v) { |
| 612 | notifs[u].groupings[v].parent = (struct lysp_node*)¬ifs[u]; |
| 613 | } |
| 614 | if (notifs[u].typedefs) { |
| 615 | ly_set_add(&ctx->tpdfs_nodes, ¬ifs[u], 0); |
| 616 | } |
| 617 | } |
| 618 | |
| 619 | return LY_SUCCESS; |
| 620 | } |
| 621 | |
| 622 | LY_ERR |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 623 | lysp_check_typedefs(struct lys_parser_ctx *ctx, struct lysp_module *mod) |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 624 | { |
| 625 | struct hash_table *ids_global; |
| 626 | struct hash_table *ids_scoped; |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 627 | const struct lysp_tpdf *typedefs; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 628 | unsigned int i, u; |
| 629 | LY_ERR ret = LY_EVALID; |
| 630 | |
| 631 | /* check name collisions - typedefs and groupings */ |
| 632 | ids_global = lyht_new(8, sizeof(char*), lysp_id_cmp, NULL, 1); |
| 633 | ids_scoped = lyht_new(8, sizeof(char*), lysp_id_cmp, NULL, 1); |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 634 | LY_ARRAY_FOR(mod->typedefs, i) { |
| 635 | if (lysp_check_typedef(ctx, NULL, &mod->typedefs[i], ids_global, ids_scoped)) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 636 | goto cleanup; |
| 637 | } |
| 638 | } |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 639 | LY_ARRAY_FOR(mod->includes, i) { |
| 640 | LY_ARRAY_FOR(mod->includes[i].submodule->typedefs, u) { |
| 641 | if (lysp_check_typedef(ctx, NULL, &mod->includes[i].submodule->typedefs[u], ids_global, ids_scoped)) { |
Radek Krejci | 3b1f929 | 2018-11-08 10:58:35 +0100 | [diff] [blame] | 642 | goto cleanup; |
| 643 | } |
| 644 | } |
| 645 | } |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 646 | for (u = 0; u < ctx->tpdfs_nodes.count; ++u) { |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 647 | typedefs = lysp_node_typedefs((struct lysp_node *)ctx->tpdfs_nodes.objs[u]); |
| 648 | LY_ARRAY_FOR(typedefs, i) { |
| 649 | if (lysp_check_typedef(ctx, (struct lysp_node *)ctx->tpdfs_nodes.objs[u], &typedefs[i], ids_global, ids_scoped)) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 650 | goto cleanup; |
| 651 | } |
| 652 | } |
| 653 | } |
| 654 | ret = LY_SUCCESS; |
| 655 | cleanup: |
| 656 | lyht_free(ids_global); |
| 657 | lyht_free(ids_scoped); |
| 658 | ly_set_erase(&ctx->tpdfs_nodes, NULL); |
| 659 | |
| 660 | return ret; |
| 661 | } |
| 662 | |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 663 | struct lysp_load_module_check_data { |
| 664 | const char *name; |
| 665 | const char *revision; |
| 666 | const char *path; |
| 667 | const char* submoduleof; |
| 668 | }; |
| 669 | |
| 670 | static LY_ERR |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 671 | lysp_load_module_check(const struct ly_ctx *ctx, struct lysp_module *mod, struct lysp_submodule *submod, void *data) |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 672 | { |
| 673 | struct lysp_load_module_check_data *info = data; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 674 | const char *filename, *dot, *rev, *name; |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 675 | uint8_t latest_revision; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 676 | size_t len; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 677 | struct lysp_revision *revs; |
| 678 | |
| 679 | name = mod ? mod->mod->name : submod->name; |
| 680 | revs = mod ? mod->revs : submod->revs; |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 681 | latest_revision = mod ? mod->mod->latest_revision : submod->latest_revision; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 682 | |
| 683 | if (info->name) { |
| 684 | /* check name of the parsed model */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 685 | if (strcmp(info->name, name)) { |
| 686 | LOGERR(ctx, LY_EINVAL, "Unexpected module \"%s\" parsed instead of \"%s\").", name, info->name); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 687 | return LY_EINVAL; |
| 688 | } |
| 689 | } |
| 690 | if (info->revision) { |
| 691 | /* check revision of the parsed model */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 692 | if (!revs || strcmp(info->revision, revs[0].date)) { |
| 693 | LOGERR(ctx, LY_EINVAL, "Module \"%s\" parsed with the wrong revision (\"%s\" instead \"%s\").", name, |
Radek Krejci | b07b5c9 | 2019-04-08 10:56:37 +0200 | [diff] [blame] | 694 | revs ? revs[0].date : "none", info->revision); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 695 | return LY_EINVAL; |
| 696 | } |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 697 | } else if (!latest_revision) { |
| 698 | /* do not log, we just need to drop the schema and use the latest revision from the context */ |
| 699 | return LY_EEXIST; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 700 | } |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 701 | if (submod) { |
| 702 | assert(info->submoduleof); |
| 703 | |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 704 | /* check that the submodule belongs-to our module */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 705 | if (strcmp(info->submoduleof, submod->belongsto)) { |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 706 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Included \"%s\" submodule from \"%s\" belongs-to a different module \"%s\".", |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 707 | submod->name, info->submoduleof, submod->belongsto); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 708 | return LY_EVALID; |
| 709 | } |
| 710 | /* check circular dependency */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 711 | if (submod->parsing) { |
| 712 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "A circular dependency (include) for module \"%s\".", submod->name); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 713 | return LY_EVALID; |
| 714 | } |
| 715 | } |
| 716 | if (info->path) { |
| 717 | /* check that name and revision match filename */ |
| 718 | filename = strrchr(info->path, '/'); |
| 719 | if (!filename) { |
| 720 | filename = info->path; |
| 721 | } else { |
| 722 | filename++; |
| 723 | } |
| 724 | /* name */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 725 | len = strlen(name); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 726 | rev = strchr(filename, '@'); |
| 727 | dot = strrchr(info->path, '.'); |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 728 | if (strncmp(filename, name, len) || |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 729 | ((rev && rev != &filename[len]) || (!rev && dot != &filename[len]))) { |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 730 | LOGWRN(ctx, "File name \"%s\" does not match module name \"%s\".", filename, name); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 731 | } |
| 732 | /* revision */ |
| 733 | if (rev) { |
| 734 | len = dot - ++rev; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 735 | if (!revs || len != 10 || strncmp(revs[0].date, rev, len)) { |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 736 | LOGWRN(ctx, "File name \"%s\" does not match module revision \"%s\".", filename, |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 737 | revs ? revs[0].date : "none"); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 738 | } |
| 739 | } |
| 740 | } |
| 741 | return LY_SUCCESS; |
| 742 | } |
| 743 | |
| 744 | LY_ERR |
fredgan | cd485b8 | 2019-10-18 15:00:17 +0800 | [diff] [blame] | 745 | lys_module_localfile(struct ly_ctx *ctx, const char *name, const char *revision, int implement, |
Radek Krejci | 78f0682 | 2019-10-30 12:54:05 +0100 | [diff] [blame] | 746 | struct lys_parser_ctx *main_ctx, const char *main_name, int required, void **result) |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 747 | { |
| 748 | int fd; |
| 749 | char *filepath = NULL; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 750 | const char **fp; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 751 | LYS_INFORMAT format; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 752 | void *mod = NULL; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 753 | LY_ERR ret = LY_SUCCESS; |
| 754 | struct lysp_load_module_check_data check_data = {0}; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 755 | char rpath[PATH_MAX]; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 756 | |
| 757 | LY_CHECK_RET(lys_search_localfile(ly_ctx_get_searchdirs(ctx), !(ctx->flags & LY_CTX_DISABLE_SEARCHDIR_CWD), name, revision, |
| 758 | &filepath, &format)); |
Radek Krejci | 78f0682 | 2019-10-30 12:54:05 +0100 | [diff] [blame] | 759 | LY_CHECK_ERR_RET(!filepath, if (required) {LOGERR(ctx, LY_ENOTFOUND, "Data model \"%s%s%s\" not found in local searchdirs.", |
| 760 | name, revision ? "@" : "", revision ? revision : "");}, LY_ENOTFOUND); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 761 | |
| 762 | LOGVRB("Loading schema from \"%s\" file.", filepath); |
| 763 | |
| 764 | /* open the file */ |
| 765 | fd = open(filepath, O_RDONLY); |
| 766 | LY_CHECK_ERR_GOTO(fd < 0, LOGERR(ctx, LY_ESYS, "Unable to open data model file \"%s\" (%s).", |
| 767 | filepath, strerror(errno)); ret = LY_ESYS, cleanup); |
| 768 | |
| 769 | check_data.name = name; |
| 770 | check_data.revision = revision; |
| 771 | check_data.path = filepath; |
fredgan | cd485b8 | 2019-10-18 15:00:17 +0800 | [diff] [blame] | 772 | check_data.submoduleof = main_name; |
Radek Krejci | 3b1f929 | 2018-11-08 10:58:35 +0100 | [diff] [blame] | 773 | mod = lys_parse_fd_(ctx, fd, format, implement, main_ctx, |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 774 | lysp_load_module_check, &check_data); |
| 775 | close(fd); |
| 776 | LY_CHECK_ERR_GOTO(!mod, ly_errcode(ctx), cleanup); |
| 777 | |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 778 | if (main_ctx) { |
| 779 | fp = &((struct lysp_submodule*)mod)->filepath; |
| 780 | } else { |
| 781 | fp = &((struct lys_module*)mod)->filepath; |
| 782 | } |
| 783 | if (!(*fp)) { |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 784 | if (realpath(filepath, rpath) != NULL) { |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 785 | (*fp) = lydict_insert(ctx, rpath, 0); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 786 | } else { |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 787 | (*fp) = lydict_insert(ctx, filepath, 0); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 788 | } |
| 789 | } |
| 790 | |
| 791 | *result = mod; |
| 792 | |
| 793 | /* success */ |
| 794 | cleanup: |
| 795 | free(filepath); |
| 796 | return ret; |
| 797 | } |
| 798 | |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 799 | LY_ERR |
Radek Krejci | 6d6e4e4 | 2018-10-29 13:28:19 +0100 | [diff] [blame] | 800 | lysp_load_module(struct ly_ctx *ctx, const char *name, const char *revision, int implement, int require_parsed, struct lys_module **mod) |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 801 | { |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 802 | const char *module_data = NULL; |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 803 | LYS_INFORMAT format = LYS_IN_UNKNOWN; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 804 | void (*module_data_free)(void *module_data, void *user_data) = NULL; |
| 805 | struct lysp_load_module_check_data check_data = {0}; |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 806 | struct lys_module *m = NULL; |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 807 | |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 808 | assert(mod); |
| 809 | |
| 810 | if (!*mod) { |
| 811 | /* try to get the module from the context */ |
| 812 | if (revision) { |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 813 | /* get the specific revision */ |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 814 | *mod = (struct lys_module*)ly_ctx_get_module(ctx, name, revision); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 815 | } else if (implement) { |
| 816 | /* prefer the implemented module instead of the latest one */ |
| 817 | *mod = (struct lys_module*)ly_ctx_get_module_implemented(ctx, name); |
| 818 | if (!*mod) { |
| 819 | /* there is no implemented module in the context, try to get the latest revision module */ |
| 820 | goto latest_in_the_context; |
| 821 | } |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 822 | } else { |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 823 | /* get the requested module of the latest revision in the context */ |
| 824 | latest_in_the_context: |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 825 | *mod = (struct lys_module*)ly_ctx_get_module_latest(ctx, name); |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 826 | if (*mod && (*mod)->latest_revision == 1) { |
| 827 | /* let us now search with callback and searchpaths to check if there is newer revision outside the context */ |
| 828 | m = *mod; |
| 829 | *mod = NULL; |
| 830 | } |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 831 | } |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 832 | } |
| 833 | |
Radek Krejci | 6d6e4e4 | 2018-10-29 13:28:19 +0100 | [diff] [blame] | 834 | if (!(*mod) || (require_parsed && !(*mod)->parsed)) { |
| 835 | (*mod) = NULL; |
| 836 | |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 837 | /* check collision with other implemented revision */ |
| 838 | if (implement && ly_ctx_get_module_implemented(ctx, name)) { |
| 839 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, |
| 840 | "Module \"%s\" is already present in other implemented revision.", name); |
| 841 | return LY_EDENIED; |
| 842 | } |
| 843 | |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 844 | /* module not present in the context, get the input data and parse it */ |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 845 | if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) { |
| 846 | search_clb: |
| 847 | if (ctx->imp_clb) { |
| 848 | if (ctx->imp_clb(name, revision, NULL, NULL, ctx->imp_clb_data, |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 849 | &format, &module_data, &module_data_free) == LY_SUCCESS) { |
| 850 | check_data.name = name; |
| 851 | check_data.revision = revision; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 852 | *mod = lys_parse_mem_module(ctx, module_data, format, implement, |
| 853 | lysp_load_module_check, &check_data); |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 854 | if (module_data_free) { |
| 855 | module_data_free((void*)module_data, ctx->imp_clb_data); |
| 856 | } |
Radek Krejci | 096235c | 2019-01-11 11:12:19 +0100 | [diff] [blame] | 857 | if (*mod && implement && lys_compile(*mod, 0)) { |
| 858 | ly_set_rm(&ctx->list, *mod, NULL); |
| 859 | lys_module_free(*mod, NULL); |
| 860 | *mod = NULL; |
| 861 | } |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 862 | } |
| 863 | } |
| 864 | if (!(*mod) && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) { |
| 865 | goto search_file; |
| 866 | } |
| 867 | } else { |
| 868 | search_file: |
| 869 | if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) { |
| 870 | /* module was not received from the callback or there is no callback set */ |
Radek Krejci | 78f0682 | 2019-10-30 12:54:05 +0100 | [diff] [blame] | 871 | lys_module_localfile(ctx, name, revision, implement, NULL, NULL, m ? 0 : 1, (void **)mod); |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 872 | } |
| 873 | if (!(*mod) && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) { |
| 874 | goto search_clb; |
| 875 | } |
| 876 | } |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 877 | |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 878 | /* update the latest_revision flag - here we have selected the latest available schema, |
| 879 | * consider that even the callback provides correct latest revision */ |
| 880 | if (!(*mod) && m) { |
Radek Krejci | 78f0682 | 2019-10-30 12:54:05 +0100 | [diff] [blame] | 881 | LOGVRB("Newer revision than %s-%s not found, using this as the latest revision.", m->name, m->revision); |
Radek Krejci | b3289d6 | 2019-09-18 12:21:39 +0200 | [diff] [blame] | 882 | m->latest_revision = 2; |
| 883 | *mod = m; |
| 884 | } else if ((*mod) && !revision && ((*mod)->latest_revision == 1)) { |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 885 | (*mod)->latest_revision = 2; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 886 | } |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 887 | } else { |
| 888 | /* we have module from the current context */ |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 889 | if (implement) { |
| 890 | m = ly_ctx_get_module_implemented(ctx, name); |
| 891 | if (m && m != *mod) { |
| 892 | /* check collision with other implemented revision */ |
| 893 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, |
| 894 | "Module \"%s\" is already present in other implemented revision.", name); |
| 895 | *mod = NULL; |
| 896 | return LY_EDENIED; |
| 897 | } |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 898 | } |
| 899 | |
| 900 | /* circular check */ |
Radek Krejci | f8f882a | 2018-10-31 14:51:15 +0100 | [diff] [blame] | 901 | if ((*mod)->parsed && (*mod)->parsed->parsing) { |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 902 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "A circular dependency (import) for module \"%s\".", name); |
| 903 | *mod = NULL; |
| 904 | return LY_EVALID; |
| 905 | } |
| 906 | } |
| 907 | if (!(*mod)) { |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 908 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "%s \"%s\" module failed.", implement ? "Loading" : "Importing", name); |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 909 | return LY_EVALID; |
| 910 | } |
| 911 | |
| 912 | if (implement) { |
| 913 | /* mark the module implemented, check for collision was already done */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 914 | (*mod)->implemented = 1; |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 915 | } |
Radek Krejci | 086c713 | 2018-10-26 15:29:04 +0200 | [diff] [blame] | 916 | |
| 917 | return LY_SUCCESS; |
| 918 | } |
| 919 | |
| 920 | LY_ERR |
David Sedlák | 4a65053 | 2019-07-10 11:55:18 +0200 | [diff] [blame] | 921 | lysp_check_stringchar(struct lys_parser_ctx *ctx, unsigned int c) |
| 922 | { |
| 923 | if (!is_yangutf8char(c)) { |
| 924 | LOGVAL_PARSER(ctx, LY_VCODE_INCHAR, c); |
| 925 | return LY_EVALID; |
| 926 | } |
| 927 | return LY_SUCCESS; |
| 928 | } |
| 929 | |
| 930 | LY_ERR |
| 931 | lysp_check_identifierchar(struct lys_parser_ctx *ctx, unsigned int c, int first, int *prefix) |
| 932 | { |
| 933 | if (first || (prefix && (*prefix) == 1)) { |
| 934 | if (!is_yangidentstartchar(c)) { |
| 935 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier first character '%c'.", c); |
| 936 | return LY_EVALID; |
| 937 | } |
| 938 | if (prefix) { |
| 939 | if (first) { |
| 940 | (*prefix) = 0; |
| 941 | } else { |
| 942 | (*prefix) = 2; |
| 943 | } |
| 944 | } |
| 945 | } else if (c == ':' && prefix && (*prefix) == 0) { |
| 946 | (*prefix) = 1; |
| 947 | } else if (!is_yangidentchar(c)) { |
| 948 | LOGVAL_PARSER(ctx, LYVE_SYNTAX_YANG, "Invalid identifier character '%c'.", c); |
| 949 | return LY_EVALID; |
| 950 | } |
| 951 | |
| 952 | return LY_SUCCESS; |
| 953 | } |
| 954 | |
| 955 | LY_ERR |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 956 | lysp_load_submodule(struct lys_parser_ctx *pctx, struct lysp_module *mod, struct lysp_include *inc) |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 957 | { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 958 | struct ly_ctx *ctx = (struct ly_ctx *)(PARSER_CTX(pctx)); |
Radek Krejci | 3eb299d | 2019-04-08 15:07:44 +0200 | [diff] [blame] | 959 | struct lysp_submodule *submod = NULL; |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 960 | const char *submodule_data = NULL; |
| 961 | LYS_INFORMAT format = LYS_IN_UNKNOWN; |
| 962 | void (*submodule_data_free)(void *module_data, void *user_data) = NULL; |
Radek Krejci | 9ed7a19 | 2018-10-31 16:23:51 +0100 | [diff] [blame] | 963 | struct lysp_load_module_check_data check_data = {0}; |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 964 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 965 | /* submodule not present in the context, get the input data and parse it */ |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 966 | if (!(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) { |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 967 | search_clb: |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 968 | if (ctx->imp_clb) { |
| 969 | if (ctx->imp_clb(mod->mod->name, NULL, inc->name, inc->rev[0] ? inc->rev : NULL, ctx->imp_clb_data, |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 970 | &format, &submodule_data, &submodule_data_free) == LY_SUCCESS) { |
| 971 | check_data.name = inc->name; |
| 972 | check_data.revision = inc->rev[0] ? inc->rev : NULL; |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 973 | check_data.submoduleof = mod->mod->name; |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 974 | submod = lys_parse_mem_submodule(ctx, submodule_data, format, pctx, |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 975 | lysp_load_module_check, &check_data); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 976 | if (submodule_data_free) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 977 | submodule_data_free((void*)submodule_data, ctx->imp_clb_data); |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 978 | } |
| 979 | } |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 980 | } |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 981 | if (!submod && !(ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 982 | goto search_file; |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 983 | } |
Radek Krejci | 2d31ea7 | 2018-10-25 15:46:42 +0200 | [diff] [blame] | 984 | } else { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 985 | search_file: |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 986 | if (!(ctx->flags & LY_CTX_DISABLE_SEARCHDIRS)) { |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 987 | /* submodule was not received from the callback or there is no callback set */ |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 988 | lys_module_localfile(ctx, inc->name, inc->rev[0] ? inc->rev : NULL, 0, pctx, mod->mod->name, 1, (void**)&submod); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 989 | } |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 990 | if (!submod && (ctx->flags & LY_CTX_PREFER_SEARCHDIRS)) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 991 | goto search_clb; |
| 992 | } |
| 993 | } |
| 994 | if (submod) { |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 995 | if (!inc->rev[0] && (submod->latest_revision == 1)) { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 996 | /* update the latest_revision flag - here we have selected the latest available schema, |
| 997 | * consider that even the callback provides correct latest revision */ |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 998 | submod->latest_revision = 2; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 999 | } |
| 1000 | |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 1001 | inc->submodule = submod; |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 1002 | } |
| 1003 | if (!inc->submodule) { |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 1004 | LOGVAL(ctx, LY_VLOG_NONE, NULL, LYVE_REFERENCE, "Including \"%s\" submodule into \"%s\" failed.", |
Radek Krejci | 0bcdaed | 2019-01-10 10:21:34 +0100 | [diff] [blame] | 1005 | inc->name, mod->mod->name); |
Radek Krejci | d33273d | 2018-10-25 14:55:52 +0200 | [diff] [blame] | 1006 | return LY_EVALID; |
| 1007 | } |
| 1008 | |
| 1009 | return LY_SUCCESS; |
| 1010 | } |
| 1011 | |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 1012 | #define FIND_MODULE(TYPE, MOD) \ |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1013 | TYPE *imp; \ |
Radek Krejci | 7f9b651 | 2019-09-18 13:11:09 +0200 | [diff] [blame] | 1014 | if (!ly_strncmp((MOD)->mod->prefix, prefix, len)) { \ |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1015 | /* it is the prefix of the module itself */ \ |
Radek Krejci | 0af4629 | 2019-01-11 16:02:31 +0100 | [diff] [blame] | 1016 | m = ly_ctx_get_module((MOD)->mod->ctx, (MOD)->mod->name, (MOD)->mod->revision); \ |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1017 | } \ |
| 1018 | /* search in imports */ \ |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1019 | if (!m) { \ |
| 1020 | LY_ARRAY_FOR((MOD)->imports, TYPE, imp) { \ |
Radek Krejci | 7f9b651 | 2019-09-18 13:11:09 +0200 | [diff] [blame] | 1021 | if (!ly_strncmp(imp->prefix, prefix, len)) { \ |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1022 | m = imp->module; \ |
| 1023 | break; \ |
| 1024 | } \ |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1025 | } \ |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1026 | } |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1027 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1028 | struct lysc_module * |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1029 | lysc_module_find_prefix(const struct lysc_module *mod, const char *prefix, size_t len) |
Radek Krejci | 151a5b7 | 2018-10-19 14:21:44 +0200 | [diff] [blame] | 1030 | { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1031 | const struct lys_module *m = NULL; |
| 1032 | |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 1033 | FIND_MODULE(struct lysc_import, mod); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1034 | return m ? m->compiled : NULL; |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1035 | } |
Radek Krejci | 151a5b7 | 2018-10-19 14:21:44 +0200 | [diff] [blame] | 1036 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1037 | struct lysp_module * |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1038 | lysp_module_find_prefix(const struct lysp_module *mod, const char *prefix, size_t len) |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1039 | { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1040 | const struct lys_module *m = NULL; |
| 1041 | |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 1042 | FIND_MODULE(struct lysp_import, mod); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1043 | return m ? m->parsed : NULL; |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1044 | } |
Radek Krejci | 151a5b7 | 2018-10-19 14:21:44 +0200 | [diff] [blame] | 1045 | |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1046 | struct lys_module * |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1047 | lys_module_find_prefix(const struct lys_module *mod, const char *prefix, size_t len) |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1048 | { |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1049 | const struct lys_module *m = NULL; |
| 1050 | |
Michal Vasko | 88a163b | 2019-12-18 12:11:44 +0100 | [diff] [blame] | 1051 | if (!prefix || (!strncmp(prefix, mod->prefix, len) && !mod->prefix[len])) { |
| 1052 | return (struct lys_module *)mod; |
Radek Krejci | 73dead2 | 2019-07-11 16:46:16 +0200 | [diff] [blame] | 1053 | } |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1054 | if (mod->compiled) { |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 1055 | FIND_MODULE(struct lysc_import, mod->compiled); |
Radek Krejci | ce8c159 | 2018-10-29 15:35:51 +0100 | [diff] [blame] | 1056 | } else { |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 1057 | FIND_MODULE(struct lysp_import, mod->parsed); |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1058 | } |
| 1059 | return (struct lys_module*)m; |
| 1060 | } |
| 1061 | |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1062 | const char * |
Radek Krejci | 693262f | 2019-04-29 15:23:20 +0200 | [diff] [blame] | 1063 | lys_prefix_find_module(const struct lys_module *mod, const struct lys_module *import) |
| 1064 | { |
| 1065 | unsigned int u; |
| 1066 | |
| 1067 | if (import == mod) { |
| 1068 | return mod->prefix; |
| 1069 | } |
| 1070 | |
| 1071 | if (mod->parsed) { |
| 1072 | LY_ARRAY_FOR(mod->parsed->imports, u) { |
| 1073 | if (mod->parsed->imports[u].module == import) { |
| 1074 | return mod->parsed->imports[u].prefix; |
| 1075 | } |
| 1076 | } |
| 1077 | } else { |
| 1078 | /* we don't have original information about the import's prefix, |
| 1079 | * so the prefix of the import module itself is returned instead */ |
| 1080 | return import->prefix; |
| 1081 | } |
| 1082 | |
| 1083 | return NULL; |
| 1084 | } |
| 1085 | |
Radek Krejci | 0935f41 | 2019-08-20 16:15:18 +0200 | [diff] [blame] | 1086 | API const char * |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1087 | lys_nodetype2str(uint16_t nodetype) |
| 1088 | { |
| 1089 | switch(nodetype) { |
| 1090 | case LYS_CONTAINER: |
| 1091 | return "container"; |
| 1092 | case LYS_CHOICE: |
| 1093 | return "choice"; |
| 1094 | case LYS_LEAF: |
| 1095 | return "leaf"; |
| 1096 | case LYS_LEAFLIST: |
| 1097 | return "leaf-list"; |
| 1098 | case LYS_LIST: |
| 1099 | return "list"; |
| 1100 | case LYS_ANYXML: |
| 1101 | return "anyxml"; |
| 1102 | case LYS_ANYDATA: |
| 1103 | return "anydata"; |
Radek Krejci | f12a1f0 | 2019-02-11 16:42:08 +0100 | [diff] [blame] | 1104 | case LYS_CASE: |
| 1105 | return "case"; |
Radek Krejci | f538ce5 | 2019-03-05 10:46:14 +0100 | [diff] [blame] | 1106 | case LYS_ACTION: |
| 1107 | return "RPC/action"; |
| 1108 | case LYS_NOTIF: |
Michal Vasko | a388136 | 2020-01-21 15:57:35 +0100 | [diff] [blame] | 1109 | return "notification"; |
Radek Krejci | fc81ea8 | 2019-04-18 13:27:22 +0200 | [diff] [blame] | 1110 | case LYS_USES: |
| 1111 | return "uses"; |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1112 | default: |
| 1113 | return "unknown"; |
| 1114 | } |
| 1115 | } |
| 1116 | |
Radek Krejci | 693262f | 2019-04-29 15:23:20 +0200 | [diff] [blame] | 1117 | const char * |
| 1118 | lys_datatype2str(LY_DATA_TYPE basetype) |
| 1119 | { |
| 1120 | switch(basetype) { |
| 1121 | case LY_TYPE_BINARY: |
| 1122 | return "binary"; |
| 1123 | case LY_TYPE_UINT8: |
| 1124 | return "uint8"; |
| 1125 | case LY_TYPE_UINT16: |
| 1126 | return "uint16"; |
| 1127 | case LY_TYPE_UINT32: |
| 1128 | return "uint32"; |
| 1129 | case LY_TYPE_UINT64: |
| 1130 | return "uint64"; |
| 1131 | case LY_TYPE_STRING: |
| 1132 | return "string"; |
| 1133 | case LY_TYPE_BITS: |
| 1134 | return "bits"; |
| 1135 | case LY_TYPE_BOOL: |
| 1136 | return "boolean"; |
| 1137 | case LY_TYPE_DEC64: |
| 1138 | return "decimal64"; |
| 1139 | case LY_TYPE_EMPTY: |
| 1140 | return "empty"; |
| 1141 | case LY_TYPE_ENUM: |
| 1142 | return "enumeration"; |
| 1143 | case LY_TYPE_IDENT: |
| 1144 | return "identityref"; |
| 1145 | case LY_TYPE_INST: |
| 1146 | return "instance-identifier"; |
| 1147 | case LY_TYPE_LEAFREF: |
| 1148 | return "leafref"; |
| 1149 | case LY_TYPE_UNION: |
| 1150 | return "union"; |
| 1151 | case LY_TYPE_INT8: |
| 1152 | return "int8"; |
| 1153 | case LY_TYPE_INT16: |
| 1154 | return "int16"; |
| 1155 | case LY_TYPE_INT32: |
| 1156 | return "int32"; |
| 1157 | case LY_TYPE_INT64: |
| 1158 | return "int64"; |
| 1159 | default: |
| 1160 | return "unknown"; |
| 1161 | } |
| 1162 | } |
| 1163 | |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1164 | API const struct lysp_tpdf * |
| 1165 | lysp_node_typedefs(const struct lysp_node *node) |
| 1166 | { |
Radek Krejci | 0fb2856 | 2018-12-13 15:17:37 +0100 | [diff] [blame] | 1167 | switch (node->nodetype) { |
| 1168 | case LYS_CONTAINER: |
| 1169 | return ((struct lysp_node_container*)node)->typedefs; |
| 1170 | case LYS_LIST: |
| 1171 | return ((struct lysp_node_list*)node)->typedefs; |
| 1172 | case LYS_GROUPING: |
| 1173 | return ((struct lysp_grp*)node)->typedefs; |
| 1174 | case LYS_ACTION: |
| 1175 | return ((struct lysp_action*)node)->typedefs; |
| 1176 | case LYS_INOUT: |
| 1177 | return ((struct lysp_action_inout*)node)->typedefs; |
| 1178 | case LYS_NOTIF: |
| 1179 | return ((struct lysp_notif*)node)->typedefs; |
| 1180 | default: |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1181 | return NULL; |
| 1182 | } |
| 1183 | } |
| 1184 | |
Radek Krejci | 53ea615 | 2018-12-13 15:21:15 +0100 | [diff] [blame] | 1185 | API const struct lysp_grp * |
| 1186 | lysp_node_groupings(const struct lysp_node *node) |
| 1187 | { |
| 1188 | switch (node->nodetype) { |
| 1189 | case LYS_CONTAINER: |
| 1190 | return ((struct lysp_node_container*)node)->groupings; |
| 1191 | case LYS_LIST: |
| 1192 | return ((struct lysp_node_list*)node)->groupings; |
| 1193 | case LYS_GROUPING: |
| 1194 | return ((struct lysp_grp*)node)->groupings; |
| 1195 | case LYS_ACTION: |
| 1196 | return ((struct lysp_action*)node)->groupings; |
| 1197 | case LYS_INOUT: |
| 1198 | return ((struct lysp_action_inout*)node)->groupings; |
| 1199 | case LYS_NOTIF: |
| 1200 | return ((struct lysp_notif*)node)->groupings; |
| 1201 | default: |
| 1202 | return NULL; |
| 1203 | } |
| 1204 | } |
| 1205 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1206 | struct lysp_action ** |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1207 | lysp_node_actions_p(struct lysp_node *node) |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1208 | { |
| 1209 | assert(node); |
| 1210 | switch (node->nodetype) { |
| 1211 | case LYS_CONTAINER: |
| 1212 | return &((struct lysp_node_container*)node)->actions; |
| 1213 | case LYS_LIST: |
| 1214 | return &((struct lysp_node_list*)node)->actions; |
| 1215 | case LYS_GROUPING: |
| 1216 | return &((struct lysp_grp*)node)->actions; |
| 1217 | case LYS_AUGMENT: |
| 1218 | return &((struct lysp_augment*)node)->actions; |
| 1219 | default: |
| 1220 | return NULL; |
| 1221 | } |
| 1222 | } |
| 1223 | |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1224 | API const struct lysp_action * |
| 1225 | lysp_node_actions(const struct lysp_node *node) |
| 1226 | { |
| 1227 | struct lysp_action **actions; |
| 1228 | actions = lysp_node_actions_p((struct lysp_node*)node); |
| 1229 | if (actions) { |
| 1230 | return *actions; |
| 1231 | } else { |
| 1232 | return NULL; |
| 1233 | } |
| 1234 | } |
| 1235 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1236 | struct lysp_notif ** |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1237 | lysp_node_notifs_p(struct lysp_node *node) |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1238 | { |
| 1239 | assert(node); |
| 1240 | switch (node->nodetype) { |
| 1241 | case LYS_CONTAINER: |
| 1242 | return &((struct lysp_node_container*)node)->notifs; |
| 1243 | case LYS_LIST: |
| 1244 | return &((struct lysp_node_list*)node)->notifs; |
| 1245 | case LYS_GROUPING: |
| 1246 | return &((struct lysp_grp*)node)->notifs; |
| 1247 | case LYS_AUGMENT: |
| 1248 | return &((struct lysp_augment*)node)->notifs; |
| 1249 | default: |
| 1250 | return NULL; |
| 1251 | } |
| 1252 | } |
| 1253 | |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1254 | API const struct lysp_notif * |
| 1255 | lysp_node_notifs(const struct lysp_node *node) |
| 1256 | { |
| 1257 | struct lysp_notif **notifs; |
| 1258 | notifs = lysp_node_notifs_p((struct lysp_node*)node); |
| 1259 | if (notifs) { |
| 1260 | return *notifs; |
| 1261 | } else { |
| 1262 | return NULL; |
| 1263 | } |
| 1264 | } |
| 1265 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1266 | struct lysp_node ** |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1267 | lysp_node_children_p(struct lysp_node *node) |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1268 | { |
| 1269 | assert(node); |
| 1270 | switch (node->nodetype) { |
| 1271 | case LYS_CONTAINER: |
| 1272 | return &((struct lysp_node_container*)node)->child; |
| 1273 | case LYS_CHOICE: |
| 1274 | return &((struct lysp_node_choice*)node)->child; |
| 1275 | case LYS_LIST: |
| 1276 | return &((struct lysp_node_list*)node)->child; |
| 1277 | case LYS_CASE: |
| 1278 | return &((struct lysp_node_case*)node)->child; |
| 1279 | case LYS_GROUPING: |
| 1280 | return &((struct lysp_grp*)node)->data; |
| 1281 | case LYS_AUGMENT: |
| 1282 | return &((struct lysp_augment*)node)->child; |
| 1283 | case LYS_INOUT: |
| 1284 | return &((struct lysp_action_inout*)node)->data; |
| 1285 | case LYS_NOTIF: |
| 1286 | return &((struct lysp_notif*)node)->data; |
| 1287 | default: |
| 1288 | return NULL; |
| 1289 | } |
| 1290 | } |
| 1291 | |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1292 | API const struct lysp_node * |
| 1293 | lysp_node_children(const struct lysp_node *node) |
| 1294 | { |
| 1295 | struct lysp_node **children; |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 1296 | |
| 1297 | if (!node) { |
| 1298 | return NULL; |
| 1299 | } |
| 1300 | |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1301 | children = lysp_node_children_p((struct lysp_node*)node); |
| 1302 | if (children) { |
| 1303 | return *children; |
| 1304 | } else { |
| 1305 | return NULL; |
| 1306 | } |
| 1307 | } |
| 1308 | |
| 1309 | struct lysc_action ** |
| 1310 | lysc_node_actions_p(struct lysc_node *node) |
| 1311 | { |
| 1312 | assert(node); |
| 1313 | switch (node->nodetype) { |
| 1314 | case LYS_CONTAINER: |
| 1315 | return &((struct lysc_node_container*)node)->actions; |
| 1316 | case LYS_LIST: |
| 1317 | return &((struct lysc_node_list*)node)->actions; |
| 1318 | default: |
| 1319 | return NULL; |
| 1320 | } |
| 1321 | } |
| 1322 | |
| 1323 | API const struct lysc_action * |
| 1324 | lysc_node_actions(const struct lysc_node *node) |
| 1325 | { |
| 1326 | struct lysc_action **actions; |
| 1327 | actions = lysc_node_actions_p((struct lysc_node*)node); |
| 1328 | if (actions) { |
| 1329 | return *actions; |
| 1330 | } else { |
| 1331 | return NULL; |
| 1332 | } |
| 1333 | } |
| 1334 | |
| 1335 | struct lysc_notif ** |
| 1336 | lysc_node_notifs_p(struct lysc_node *node) |
| 1337 | { |
| 1338 | assert(node); |
| 1339 | switch (node->nodetype) { |
| 1340 | case LYS_CONTAINER: |
| 1341 | return &((struct lysc_node_container*)node)->notifs; |
| 1342 | case LYS_LIST: |
| 1343 | return &((struct lysc_node_list*)node)->notifs; |
| 1344 | default: |
| 1345 | return NULL; |
| 1346 | } |
| 1347 | } |
| 1348 | |
| 1349 | API const struct lysc_notif * |
| 1350 | lysc_node_notifs(const struct lysc_node *node) |
| 1351 | { |
| 1352 | struct lysc_notif **notifs; |
| 1353 | notifs = lysc_node_notifs_p((struct lysc_node*)node); |
| 1354 | if (notifs) { |
| 1355 | return *notifs; |
| 1356 | } else { |
| 1357 | return NULL; |
| 1358 | } |
| 1359 | } |
| 1360 | |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1361 | struct lysc_node ** |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 1362 | lysc_node_children_p(const struct lysc_node *node, uint16_t flags) |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1363 | { |
| 1364 | assert(node); |
| 1365 | switch (node->nodetype) { |
| 1366 | case LYS_CONTAINER: |
| 1367 | return &((struct lysc_node_container*)node)->child; |
| 1368 | case LYS_CHOICE: |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1369 | if (((struct lysc_node_choice*)node)->cases) { |
Radek Krejci | 95710c9 | 2019-02-11 15:49:55 +0100 | [diff] [blame] | 1370 | return &((struct lysc_node_choice*)node)->cases->child; |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1371 | } else { |
| 1372 | return NULL; |
| 1373 | } |
Radek Krejci | 01342af | 2019-01-03 15:18:08 +0100 | [diff] [blame] | 1374 | case LYS_CASE: |
| 1375 | return &((struct lysc_node_case*)node)->child; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1376 | case LYS_LIST: |
| 1377 | return &((struct lysc_node_list*)node)->child; |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 1378 | case LYS_ACTION: |
| 1379 | if (flags & LYS_CONFIG_R) { |
| 1380 | return &((struct lysc_action*)node)->output.data; |
| 1381 | } else { |
| 1382 | /* LYS_CONFIG_W, but also the default case */ |
| 1383 | return &((struct lysc_action*)node)->input.data; |
| 1384 | } |
Radek Krejci | fc11bd7 | 2019-04-11 16:00:05 +0200 | [diff] [blame] | 1385 | case LYS_NOTIF: |
| 1386 | return &((struct lysc_notif*)node)->data; |
Radek Krejci | bbe09a9 | 2018-11-08 09:36:54 +0100 | [diff] [blame] | 1387 | default: |
| 1388 | return NULL; |
| 1389 | } |
| 1390 | } |
| 1391 | |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1392 | API const struct lysc_node * |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 1393 | lysc_node_children(const struct lysc_node *node, uint16_t flags) |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1394 | { |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1395 | struct lysc_node **children; |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 1396 | |
| 1397 | if (!node) { |
| 1398 | return NULL; |
| 1399 | } |
| 1400 | |
Radek Krejci | 6eeb58f | 2019-02-22 16:29:37 +0100 | [diff] [blame] | 1401 | children = lysc_node_children_p((struct lysc_node*)node, flags); |
Radek Krejci | 056d0a8 | 2018-12-06 16:57:25 +0100 | [diff] [blame] | 1402 | if (children) { |
| 1403 | return *children; |
| 1404 | } else { |
Radek Krejci | a304538 | 2018-11-22 14:30:31 +0100 | [diff] [blame] | 1405 | return NULL; |
| 1406 | } |
| 1407 | } |
| 1408 | |
Radek Krejci | 96a0bfd | 2018-11-22 15:25:06 +0100 | [diff] [blame] | 1409 | struct lys_module * |
| 1410 | lysp_find_module(struct ly_ctx *ctx, const struct lysp_module *mod) |
| 1411 | { |
| 1412 | unsigned int u; |
| 1413 | |
| 1414 | for (u = 0; u < ctx->list.count; ++u) { |
| 1415 | if (((struct lys_module*)ctx->list.objs[u])->parsed == mod) { |
| 1416 | return ((struct lys_module*)ctx->list.objs[u]); |
| 1417 | } |
| 1418 | } |
| 1419 | return NULL; |
| 1420 | } |
| 1421 | |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1422 | enum ly_stmt |
Michal Vasko | b36053d | 2020-03-26 15:49:30 +0100 | [diff] [blame^] | 1423 | lysp_match_kw(struct lys_yang_parser_ctx *ctx, const char **data) |
David Sedlák | c10e790 | 2018-12-17 02:17:59 +0100 | [diff] [blame] | 1424 | { |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1425 | /** |
| 1426 | * @brief Move the DATA pointer by COUNT items. Also updates the indent value in yang parser context |
| 1427 | * @param[in] CTX yang parser context to update its indent value. |
| 1428 | * @param[in,out] DATA pointer to move |
| 1429 | * @param[in] COUNT number of items for which the DATA pointer is supposed to move on. |
| 1430 | */ |
| 1431 | #define MOVE_IN(CTX, DATA, COUNT) (*(DATA))+=COUNT;if(CTX){(CTX)->indent+=COUNT;} |
| 1432 | #define IF_KW(STR, LEN, STMT) if (!strncmp(*(data), STR, LEN)) {MOVE_IN(ctx, data, LEN);*kw=STMT;} |
| 1433 | #define IF_KW_PREFIX(STR, LEN) if (!strncmp(*(data), STR, LEN)) {MOVE_IN(ctx, data, LEN); |
| 1434 | #define IF_KW_PREFIX_END } |
David Sedlák | 572e7ab | 2019-06-04 16:01:58 +0200 | [diff] [blame] | 1435 | |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1436 | enum ly_stmt result = LY_STMT_NONE; |
| 1437 | enum ly_stmt *kw = &result; |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1438 | /* read the keyword itself */ |
| 1439 | switch (**data) { |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1440 | case 'a': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1441 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1442 | IF_KW("rgument", 7, LY_STMT_ARGUMENT) |
| 1443 | else IF_KW("ugment", 6, LY_STMT_AUGMENT) |
| 1444 | else IF_KW("ction", 5, LY_STMT_ACTION) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1445 | else IF_KW_PREFIX("ny", 2) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1446 | IF_KW("data", 4, LY_STMT_ANYDATA) |
| 1447 | else IF_KW("xml", 3, LY_STMT_ANYXML) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1448 | IF_KW_PREFIX_END |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1449 | break; |
| 1450 | case 'b': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1451 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1452 | IF_KW("ase", 3, LY_STMT_BASE) |
| 1453 | else IF_KW("elongs-to", 9, LY_STMT_BELONGS_TO) |
| 1454 | else IF_KW("it", 2, LY_STMT_BIT) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1455 | break; |
| 1456 | case 'c': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1457 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1458 | IF_KW("ase", 3, LY_STMT_CASE) |
| 1459 | else IF_KW("hoice", 5, LY_STMT_CHOICE) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1460 | else IF_KW_PREFIX("on", 2) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1461 | IF_KW("fig", 3, LY_STMT_CONFIG) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1462 | else IF_KW_PREFIX("ta", 2) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1463 | IF_KW("ct", 2, LY_STMT_CONTACT) |
| 1464 | else IF_KW("iner", 4, LY_STMT_CONTAINER) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1465 | IF_KW_PREFIX_END |
| 1466 | IF_KW_PREFIX_END |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1467 | break; |
| 1468 | case 'd': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1469 | MOVE_IN(ctx, data, 1); |
| 1470 | IF_KW_PREFIX("e", 1) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1471 | IF_KW("fault", 5, LY_STMT_DEFAULT) |
| 1472 | else IF_KW("scription", 9, LY_STMT_DESCRIPTION) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1473 | else IF_KW_PREFIX("viat", 4) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1474 | IF_KW("e", 1, LY_STMT_DEVIATE) |
| 1475 | else IF_KW("ion", 3, LY_STMT_DEVIATION) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1476 | IF_KW_PREFIX_END |
| 1477 | IF_KW_PREFIX_END |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1478 | break; |
| 1479 | case 'e': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1480 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1481 | IF_KW("num", 3, LY_STMT_ENUM) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1482 | else IF_KW_PREFIX("rror-", 5) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1483 | IF_KW("app-tag", 7, LY_STMT_ERROR_APP_TAG) |
| 1484 | else IF_KW("message", 7, LY_STMT_ERROR_MESSAGE) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1485 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1486 | else IF_KW("xtension", 8, LY_STMT_EXTENSION) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1487 | break; |
| 1488 | case 'f': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1489 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1490 | IF_KW("eature", 6, LY_STMT_FEATURE) |
| 1491 | else IF_KW("raction-digits", 14, LY_STMT_FRACTION_DIGITS) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1492 | break; |
| 1493 | case 'g': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1494 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1495 | IF_KW("rouping", 7, LY_STMT_GROUPING) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1496 | break; |
| 1497 | case 'i': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1498 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1499 | IF_KW("dentity", 7, LY_STMT_IDENTITY) |
| 1500 | else IF_KW("f-feature", 9, LY_STMT_IF_FEATURE) |
| 1501 | else IF_KW("mport", 5, LY_STMT_IMPORT) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1502 | else IF_KW_PREFIX("n", 1) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1503 | IF_KW("clude", 5, LY_STMT_INCLUDE) |
| 1504 | else IF_KW("put", 3, LY_STMT_INPUT) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1505 | IF_KW_PREFIX_END |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1506 | break; |
| 1507 | case 'k': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1508 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1509 | IF_KW("ey", 2, LY_STMT_KEY) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1510 | break; |
| 1511 | case 'l': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1512 | MOVE_IN(ctx, data, 1); |
| 1513 | IF_KW_PREFIX("e", 1) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1514 | IF_KW("af-list", 7, LY_STMT_LEAF_LIST) |
| 1515 | else IF_KW("af", 2, LY_STMT_LEAF) |
| 1516 | else IF_KW("ngth", 4, LY_STMT_LENGTH) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1517 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1518 | else IF_KW("ist", 3, LY_STMT_LIST) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1519 | break; |
| 1520 | case 'm': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1521 | MOVE_IN(ctx, data, 1); |
| 1522 | IF_KW_PREFIX("a", 1) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1523 | IF_KW("ndatory", 7, LY_STMT_MANDATORY) |
| 1524 | else IF_KW("x-elements", 10, LY_STMT_MAX_ELEMENTS) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1525 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1526 | else IF_KW("in-elements", 11, LY_STMT_MIN_ELEMENTS) |
| 1527 | else IF_KW("ust", 3, LY_STMT_MUST) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1528 | else IF_KW_PREFIX("od", 2) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1529 | IF_KW("ule", 3, LY_STMT_MODULE) |
| 1530 | else IF_KW("ifier", 5, LY_STMT_MODIFIER) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1531 | IF_KW_PREFIX_END |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1532 | break; |
| 1533 | case 'n': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1534 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1535 | IF_KW("amespace", 8, LY_STMT_NAMESPACE) |
| 1536 | else IF_KW("otification", 11, LY_STMT_NOTIFICATION) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1537 | break; |
| 1538 | case 'o': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1539 | MOVE_IN(ctx, data, 1); |
| 1540 | IF_KW_PREFIX("r", 1) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1541 | IF_KW("dered-by", 8, LY_STMT_ORDERED_BY) |
| 1542 | else IF_KW("ganization", 10, LY_STMT_ORGANIZATION) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1543 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1544 | else IF_KW("utput", 5, LY_STMT_OUTPUT) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1545 | break; |
| 1546 | case 'p': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1547 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1548 | IF_KW("ath", 3, LY_STMT_PATH) |
| 1549 | else IF_KW("attern", 6, LY_STMT_PATTERN) |
| 1550 | else IF_KW("osition", 7, LY_STMT_POSITION) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1551 | else IF_KW_PREFIX("re", 2) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1552 | IF_KW("fix", 3, LY_STMT_PREFIX) |
| 1553 | else IF_KW("sence", 5, LY_STMT_PRESENCE) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1554 | IF_KW_PREFIX_END |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1555 | break; |
| 1556 | case 'r': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1557 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1558 | IF_KW("ange", 4, LY_STMT_RANGE) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1559 | else IF_KW_PREFIX("e", 1) |
| 1560 | IF_KW_PREFIX("f", 1) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1561 | IF_KW("erence", 6, LY_STMT_REFERENCE) |
| 1562 | else IF_KW("ine", 3, LY_STMT_REFINE) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1563 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1564 | else IF_KW("quire-instance", 14, LY_STMT_REQUIRE_INSTANCE) |
| 1565 | else IF_KW("vision-date", 11, LY_STMT_REVISION_DATE) |
| 1566 | else IF_KW("vision", 6, LY_STMT_REVISION) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1567 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1568 | else IF_KW("pc", 2, LY_STMT_RPC) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1569 | break; |
| 1570 | case 's': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1571 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1572 | IF_KW("tatus", 5, LY_STMT_STATUS) |
| 1573 | else IF_KW("ubmodule", 8, LY_STMT_SUBMODULE) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1574 | break; |
| 1575 | case 't': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1576 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1577 | IF_KW("ypedef", 6, LY_STMT_TYPEDEF) |
| 1578 | else IF_KW("ype", 3, LY_STMT_TYPE) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1579 | break; |
| 1580 | case 'u': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1581 | MOVE_IN(ctx, data, 1); |
| 1582 | IF_KW_PREFIX("ni", 2) |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1583 | IF_KW("que", 3, LY_STMT_UNIQUE) |
| 1584 | else IF_KW("ts", 2, LY_STMT_UNITS) |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1585 | IF_KW_PREFIX_END |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1586 | else IF_KW("ses", 3, LY_STMT_USES) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1587 | break; |
| 1588 | case 'v': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1589 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1590 | IF_KW("alue", 4, LY_STMT_VALUE) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1591 | break; |
| 1592 | case 'w': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1593 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1594 | IF_KW("hen", 3, LY_STMT_WHEN) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1595 | break; |
| 1596 | case 'y': |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1597 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1598 | IF_KW("ang-version", 11, LY_STMT_YANG_VERSION) |
| 1599 | else IF_KW("in-element", 10, LY_STMT_YIN_ELEMENT) |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1600 | break; |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1601 | default: |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1602 | /* if context is not NULL we are matching keyword from YANG data*/ |
| 1603 | if (ctx) { |
| 1604 | if (**data == ';') { |
| 1605 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1606 | *kw = LY_STMT_SYNTAX_SEMICOLON; |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1607 | } else if (**data == '{') { |
| 1608 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1609 | *kw = LY_STMT_SYNTAX_LEFT_BRACE; |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1610 | } else if (**data == '}') { |
| 1611 | MOVE_IN(ctx, data, 1); |
Radek Krejci | d6b7645 | 2019-09-03 17:03:03 +0200 | [diff] [blame] | 1612 | *kw = LY_STMT_SYNTAX_RIGHT_BRACE; |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1613 | } |
| 1614 | } |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1615 | break; |
| 1616 | } |
| 1617 | |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1618 | #undef IF_KW |
| 1619 | #undef IF_KW_PREFIX |
| 1620 | #undef IF_KW_PREFIX_END |
David Sedlák | 1873013 | 2019-03-15 15:51:34 +0100 | [diff] [blame] | 1621 | #undef MOVE_IN |
David Sedlák | 1873013 | 2019-03-15 15:51:34 +0100 | [diff] [blame] | 1622 | |
David Sedlák | 1bccdfa | 2019-06-17 15:55:27 +0200 | [diff] [blame] | 1623 | return result; |
David Sedlák | 23a59a6 | 2018-10-26 13:08:02 +0200 | [diff] [blame] | 1624 | } |
David Sedlák | ecf5eb8 | 2019-06-03 14:12:44 +0200 | [diff] [blame] | 1625 | |
Radek Krejci | d3ca063 | 2019-04-16 16:54:54 +0200 | [diff] [blame] | 1626 | unsigned int |
| 1627 | lysp_ext_instance_iter(struct lysp_ext_instance *ext, unsigned int index, LYEXT_SUBSTMT substmt) |
| 1628 | { |
| 1629 | LY_CHECK_ARG_RET(NULL, ext, LY_EINVAL); |
| 1630 | |
| 1631 | for (; index < LY_ARRAY_SIZE(ext); index++) { |
| 1632 | if (ext[index].insubstmt == substmt) { |
| 1633 | return index; |
| 1634 | } |
| 1635 | } |
| 1636 | |
| 1637 | return LY_ARRAY_SIZE(ext); |
| 1638 | } |
| 1639 | |
Radek Krejci | a191122 | 2019-07-22 17:24:50 +0200 | [diff] [blame] | 1640 | /** |
| 1641 | * @brief Schema mapping of YANG modules to prefixes in values. |
| 1642 | * |
| 1643 | * Implementation of ly_clb_get_prefix. Inverse function to lys_resolve_prefix. |
| 1644 | * |
| 1645 | * In this case the @p mod is searched in the list of imports and the import's prefix |
| 1646 | * (not the module's itself) prefix is returned. |
| 1647 | */ |
| 1648 | const char * |
| 1649 | lys_get_prefix(const struct lys_module *mod, void *private) |
| 1650 | { |
| 1651 | struct lys_module *context_mod = (struct lys_module*)private; |
| 1652 | unsigned int u; |
Radek Krejci | d3ca063 | 2019-04-16 16:54:54 +0200 | [diff] [blame] | 1653 | |
Radek Krejci | 474f9b8 | 2019-07-24 11:36:37 +0200 | [diff] [blame] | 1654 | if (context_mod == mod) { |
| 1655 | return context_mod->prefix; |
| 1656 | } |
Radek Krejci | a191122 | 2019-07-22 17:24:50 +0200 | [diff] [blame] | 1657 | LY_ARRAY_FOR(context_mod->compiled->imports, u) { |
| 1658 | if (context_mod->compiled->imports[u].module == mod) { |
| 1659 | /* match */ |
Radek Krejci | d0ef1af | 2019-07-23 12:22:05 +0200 | [diff] [blame] | 1660 | return context_mod->compiled->imports[u].prefix; |
Radek Krejci | a191122 | 2019-07-22 17:24:50 +0200 | [diff] [blame] | 1661 | } |
| 1662 | } |
| 1663 | |
| 1664 | return NULL; |
| 1665 | } |
| 1666 | |
| 1667 | /** |
| 1668 | * @brief Schema mapping of prefix in values to YANG modules (imports). |
| 1669 | * |
| 1670 | * Implementation of ly_clb_resolve_prefix. Inverse function to lys_get_prefix(). |
| 1671 | * |
| 1672 | * In this case the @p prefix is searched in the list of imports' prefixes (not the prefixes of the imported modules themselves). |
| 1673 | */ |
| 1674 | const struct lys_module * |
Michal Vasko | 52927e2 | 2020-03-16 17:26:14 +0100 | [diff] [blame] | 1675 | lys_resolve_prefix(const struct ly_ctx *UNUSED(ctx), const char *prefix, size_t prefix_len, void *private) |
Radek Krejci | a191122 | 2019-07-22 17:24:50 +0200 | [diff] [blame] | 1676 | { |
| 1677 | return lys_module_find_prefix((const struct lys_module*)private, prefix, prefix_len); |
| 1678 | } |