Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1 | /** |
| 2 | * @file main_ni.c |
| 3 | * @author Radek Krejci <rkrejci@cesnet.cz> |
Michal Vasko | 193dacd | 2022-10-13 08:43:05 +0200 | [diff] [blame] | 4 | * @author Michal Vasko <mvasko@cesnet.cz> |
| 5 | * @brief libyang's yanglint tool - non-interactive code |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 6 | * |
Michal Vasko | 193dacd | 2022-10-13 08:43:05 +0200 | [diff] [blame] | 7 | * Copyright (c) 2020 - 2022 CESNET, z.s.p.o. |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 8 | * |
| 9 | * This source code is licensed under BSD 3-Clause License (the "License"). |
| 10 | * You may not use this file except in compliance with the License. |
| 11 | * You may obtain a copy of the License at |
| 12 | * |
| 13 | * https://opensource.org/licenses/BSD-3-Clause |
| 14 | */ |
| 15 | |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 16 | #define _GNU_SOURCE |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 17 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 18 | #include <errno.h> |
| 19 | #include <getopt.h> |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 20 | #include <stdint.h> |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 21 | #include <stdio.h> |
| 22 | #include <stdlib.h> |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 23 | #include <string.h> |
Radek Krejci | 47fab89 | 2020-11-05 17:02:41 +0100 | [diff] [blame] | 24 | #include <strings.h> |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 25 | #include <sys/stat.h> |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 26 | |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 27 | #include "libyang.h" |
Michal Vasko | 193dacd | 2022-10-13 08:43:05 +0200 | [diff] [blame] | 28 | #include "plugins_exts.h" |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 29 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 30 | #include "common.h" |
aPiecek | 8f0b788 | 2021-05-21 10:18:36 +0200 | [diff] [blame] | 31 | #include "out.h" |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 32 | #include "tools/config.h" |
| 33 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 34 | /** |
| 35 | * @brief Context structure to hold and pass variables in a structured form. |
| 36 | */ |
| 37 | struct context { |
| 38 | /* libyang context for the run */ |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 39 | const char *yang_lib_file; |
| 40 | uint16_t ctx_options; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 41 | struct ly_ctx *ctx; |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 42 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 43 | /* prepared output (--output option or stdout by default) */ |
| 44 | struct ly_out *out; |
Radek Krejci | 535ea9f | 2020-05-29 16:01:05 +0200 | [diff] [blame] | 45 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 46 | char *searchpaths; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 47 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 48 | /* options flags */ |
| 49 | uint8_t list; /* -l option to print list of schemas */ |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 50 | |
aPiecek | 2cfeeae | 2021-04-21 13:17:34 +0200 | [diff] [blame] | 51 | /* line length for 'tree' format */ |
| 52 | size_t line_length; /* --tree-line-length */ |
| 53 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 54 | /* |
| 55 | * schema |
| 56 | */ |
Michal Vasko | a9a9861 | 2021-11-22 10:00:27 +0100 | [diff] [blame] | 57 | /* set schema modules' features via --features option (struct schema_features *) */ |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 58 | struct ly_set schema_features; |
| 59 | |
| 60 | /* set of loaded schema modules (struct lys_module *) */ |
| 61 | struct ly_set schema_modules; |
| 62 | |
| 63 | /* options to parse and print schema modules */ |
| 64 | uint32_t schema_parse_options; |
| 65 | uint32_t schema_print_options; |
| 66 | |
| 67 | /* specification of printing schema node subtree, option --schema-node */ |
| 68 | const char *schema_node_path; |
| 69 | const struct lysc_node *schema_node; |
Michal Vasko | fe74d1e | 2021-09-30 13:17:36 +0200 | [diff] [blame] | 70 | const char *submodule; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 71 | |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 72 | /* name of file containing explicit context passed to callback |
| 73 | * for schema-mount extension. This also causes a callback to |
| 74 | * be registered. |
| 75 | */ |
| 76 | char *schema_context_filename; |
| 77 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 78 | /* value of --format in case of schema format */ |
| 79 | LYS_OUTFORMAT schema_out_format; |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 80 | ly_bool feature_param_format; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 81 | |
| 82 | /* |
| 83 | * data |
| 84 | */ |
| 85 | /* various options based on --type option */ |
Michal Vasko | e066574 | 2021-02-11 11:08:44 +0100 | [diff] [blame] | 86 | enum lyd_type data_type; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 87 | uint32_t data_parse_options; |
| 88 | uint32_t data_validate_options; |
| 89 | uint32_t data_print_options; |
| 90 | |
| 91 | /* flag for --merge option */ |
| 92 | uint8_t data_merge; |
| 93 | |
| 94 | /* value of --format in case of data format */ |
| 95 | LYD_FORMAT data_out_format; |
| 96 | |
| 97 | /* input data files (struct cmdline_file *) */ |
| 98 | struct ly_set data_inputs; |
| 99 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 100 | /* storage for --operational */ |
| 101 | struct cmdline_file data_operational; |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 102 | |
| 103 | /* storage for --reply-rpc */ |
| 104 | struct cmdline_file reply_rpc; |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 105 | |
| 106 | /* storage for --data-xpath */ |
| 107 | struct ly_set data_xpath; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 108 | }; |
| 109 | |
| 110 | static void |
| 111 | erase_context(struct context *c) |
| 112 | { |
| 113 | /* data */ |
| 114 | ly_set_erase(&c->data_inputs, free_cmdline_file); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 115 | ly_in_free(c->data_operational.in, 1); |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 116 | ly_set_erase(&c->data_xpath, NULL); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 117 | |
| 118 | /* schema */ |
| 119 | ly_set_erase(&c->schema_features, free_features); |
| 120 | ly_set_erase(&c->schema_modules, NULL); |
| 121 | |
| 122 | /* context */ |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 123 | free(c->searchpaths); |
| 124 | c->searchpaths = NULL; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 125 | |
aPiecek | adb01c4 | 2023-06-02 08:28:52 +0200 | [diff] [blame] | 126 | /* --reply-rpc */ |
| 127 | ly_in_free(c->reply_rpc.in, 1); |
| 128 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 129 | ly_out_free(c->out, NULL, 0); |
Radek Krejci | 90ed21e | 2021-04-12 14:47:46 +0200 | [diff] [blame] | 130 | ly_ctx_destroy(c->ctx); |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 131 | |
| 132 | if (c->schema_context_filename) { |
| 133 | free(c->schema_context_filename); |
| 134 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 135 | } |
| 136 | |
| 137 | static void |
| 138 | version(void) |
| 139 | { |
| 140 | printf("yanglint %s\n", PROJECT_VERSION); |
| 141 | } |
| 142 | |
| 143 | static void |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 144 | help(int shortout) |
| 145 | { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 146 | |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 147 | printf("Example usage:\n" |
| 148 | " yanglint [-f { yang | yin | info}] <schema>...\n" |
| 149 | " Validates the YANG module <schema>(s) and all its dependencies, optionally printing\n" |
| 150 | " them in the specified format.\n\n" |
| 151 | " yanglint [-f { xml | json }] <schema>... <file>...\n" |
| 152 | " Validates the YANG modeled data <file>(s) according to the <schema>(s) optionally\n" |
| 153 | " printing them in the specified format.\n\n" |
| 154 | " yanglint -t (nc-)rpc/notif [-O <operational-file>] <schema>... <file>\n" |
| 155 | " Validates the YANG/NETCONF RPC/notification <file> according to the <schema>(s) using\n" |
aPiecek | a40764b | 2023-04-27 15:34:56 +0200 | [diff] [blame^] | 156 | " <operational-file> with possible references to the operational datastore data.\n" |
| 157 | " To validate nested-notification or action, the <operational-file> is required.\n\n" |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 158 | " yanglint -t nc-reply -R <rpc-file> [-O <operational-file>] <schema>... <file>\n" |
| 159 | " Validates the NETCONF rpc-reply <file> of RPC <rpc-file> according to the <schema>(s)\n" |
| 160 | " using <operational-file> with possible references to the operational datastore data.\n\n" |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 161 | " yanglint\n" |
| 162 | " Starts interactive mode with more features.\n\n"); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 163 | |
| 164 | if (shortout) { |
| 165 | return; |
| 166 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 167 | printf("Options:\n" |
| 168 | " -h, --help Show this help message and exit.\n" |
| 169 | " -v, --version Show version number and exit.\n" |
Michal Vasko | b0d307b | 2021-11-25 11:15:16 +0100 | [diff] [blame] | 170 | " -V, --verbose Increase libyang verbosity and show verbose messages. If specified\n" |
| 171 | " a second time, show even debug messages.\n" |
| 172 | " -Q, --quiet Decrease libyang verbosity and hide warnings. If specified a second\n" |
| 173 | " time, hide errors so no libyang messages are printed.\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 174 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 175 | printf(" -f FORMAT, --format=FORMAT\n" |
| 176 | " Convert input into FORMAT. Supported formats: \n" |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 177 | " yang, yin, tree, info and feature-param for schemas,\n" |
Michal Vasko | d8b0e77 | 2022-03-18 13:36:04 +0100 | [diff] [blame] | 178 | " xml, json, and lyb for data.\n\n"); |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 179 | |
| 180 | printf(" -p PATH, --path=PATH\n" |
| 181 | " Search path for schema (YANG/YIN) modules. The option can be\n" |
| 182 | " used multiple times. The current working directory and the\n" |
aPiecek | 4f306da | 2023-03-27 09:06:07 +0200 | [diff] [blame] | 183 | " path of the module being added is used implicitly. Subdirectories\n" |
| 184 | " are also searched\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 185 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 186 | printf(" -D, --disable-searchdir\n" |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 187 | " Do not implicitly search in current working directory for\n" |
| 188 | " schema modules. If specified a second time, do not even\n" |
| 189 | " search in the module directory (all modules must be \n" |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 190 | " explicitly specified).\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 191 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 192 | printf(" -F FEATURES, --features=FEATURES\n" |
Michal Vasko | 5974087 | 2021-11-22 10:01:34 +0100 | [diff] [blame] | 193 | " Specific module features to support in the form <module-name>:(<feature>,)*\n" |
| 194 | " Use <feature> '*' to enable all features of a module. This option can be\n" |
| 195 | " specified multiple times, to enable features in multiple modules. If this\n" |
| 196 | " option is not specified, all the features in all the implemented modules\n" |
| 197 | " are enabled.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 198 | |
Michal Vasko | 8d6d0ad | 2021-10-19 12:32:27 +0200 | [diff] [blame] | 199 | printf(" -i, --make-implemented\n" |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 200 | " Make the imported modules \"referenced\" from any loaded\n" |
| 201 | " module also implemented. If specified a second time, all the\n" |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 202 | " modules are set implemented.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 203 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 204 | printf(" -P PATH, --schema-node=PATH\n" |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 205 | " Print only the specified subtree of the schema.\n" |
| 206 | " The PATH is the XPath subset mentioned in documentation as\n" |
| 207 | " the Path format. The option can be combined with --single-node\n" |
| 208 | " option to print information only about the specified node.\n" |
| 209 | " -q, --single-node\n" |
| 210 | " Supplement to the --schema-node option to print information\n" |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 211 | " only about a single node specified as PATH argument.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 212 | |
Michal Vasko | fe74d1e | 2021-09-30 13:17:36 +0200 | [diff] [blame] | 213 | printf(" -s SUBMODULE, --submodule=SUBMODULE\n" |
| 214 | " Print the specific submodule instead of the main module.\n\n"); |
| 215 | |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 216 | printf(" -x FILE, --ext-data=FILE\n" |
| 217 | " File containing the specific data required by an extension. Required by\n" |
Michal Vasko | 1466280 | 2022-11-08 08:45:46 +0100 | [diff] [blame] | 218 | " the schema-mount extension, for example, when the operational data are\n" |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 219 | " expected in the file. File format is guessed.\n\n"); |
| 220 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 221 | printf(" -n, --not-strict\n" |
Michal Vasko | 667ce6b | 2021-01-25 15:00:27 +0100 | [diff] [blame] | 222 | " Do not require strict data parsing (silently skip unknown data),\n" |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 223 | " has no effect for schemas.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 224 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 225 | printf(" -e, --present Validate only with the schema modules whose data actually\n" |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 226 | " exist in the provided input data files. Takes effect only\n" |
| 227 | " with the 'data' or 'config' TYPEs. Used to avoid requiring\n" |
| 228 | " mandatory nodes from modules which data are not present in the\n" |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 229 | " provided input data files.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 230 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 231 | printf(" -t TYPE, --type=TYPE\n" |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 232 | " Specify data tree type in the input data file(s):\n" |
| 233 | " data - Complete datastore with status data (default type).\n" |
| 234 | " config - Configuration datastore (without status data).\n" |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 235 | " get - Data returned by the NETCONF <get> operation.\n" |
| 236 | " getconfig - Data returned by the NETCONF <get-config> operation.\n" |
| 237 | " edit - Config content of the NETCONF <edit-config> operation.\n" |
| 238 | " rpc - Invocation of a YANG RPC/action, defined as input.\n" |
| 239 | " nc-rpc - Similar to 'rpc' but expect and check also the NETCONF\n" |
| 240 | " envelopes <rpc> or <action>.\n" |
| 241 | " reply - Reply to a YANG RPC/action, defined as output. Note that\n" |
| 242 | " the reply data are expected inside a container representing\n" |
| 243 | " the original RPC/action invocation.\n" |
| 244 | " nc-reply - Similar to 'reply' but expect and check also the NETCONF\n" |
| 245 | " envelope <rpc-reply> with output data nodes as direct\n" |
| 246 | " descendants. The original RPC/action invocation is expected\n" |
| 247 | " in a separate parameter '-R' and is parsed as 'nc-rpc'.\n" |
| 248 | " notif - Notification instance of a YANG notification.\n" |
| 249 | " nc-notif - Similar to 'notif' but expect and check also the NETCONF\n" |
| 250 | " envelope <notification> with element <eventTime> and its\n" |
| 251 | " sibling as the actual notification.\n\n"); |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 252 | |
| 253 | printf(" -d MODE, --default=MODE\n" |
| 254 | " Print data with default values, according to the MODE\n" |
| 255 | " (to print attributes, ietf-netconf-with-defaults model\n" |
| 256 | " must be loaded):\n" |
| 257 | " all - Add missing default nodes.\n" |
| 258 | " all-tagged - Add missing default nodes and mark all the default\n" |
| 259 | " nodes with the attribute.\n" |
| 260 | " trim - Remove all nodes with a default value.\n" |
| 261 | " implicit-tagged - Add missing nodes and mark them with the attribute.\n\n"); |
| 262 | |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 263 | printf(" -E XPATH, --data-xpath=XPATH\n" |
| 264 | " Evaluate XPATH expression over the data and print the nodes satysfying\n" |
| 265 | " the expression. The output format is specific and the option cannot\n" |
| 266 | " be combined with the -f and -d options. Also all the data\n" |
| 267 | " inputs are merged into a single data tree where the expression\n" |
| 268 | " is evaluated, so the -m option is always set implicitly.\n\n"); |
| 269 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 270 | printf(" -l, --list Print info about the loaded schemas.\n" |
| 271 | " (i - imported module, I - implemented module)\n" |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 272 | " In case the '-f' option with data encoding is specified,\n" |
| 273 | " the list is printed as \"ietf-yang-library\" data.\n\n"); |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 274 | |
| 275 | printf(" -L LINE_LENGTH, --tree-line-length=LINE_LENGTH\n" |
| 276 | " The limit of the maximum line length on which the 'tree'\n" |
| 277 | " format will try to be printed.\n\n"); |
| 278 | |
| 279 | printf(" -o OUTFILE, --output=OUTFILE\n" |
| 280 | " Write the output to OUTFILE instead of stdout.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 281 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 282 | printf(" -O FILE, --operational=FILE\n" |
Michal Vasko | 9e81ce5 | 2022-04-29 10:16:21 +0200 | [diff] [blame] | 283 | " Provide optional data to extend validation of the '(nc-)rpc',\n" |
| 284 | " '(nc-)reply' or '(nc-)notif' TYPEs. The FILE is supposed to contain\n" |
| 285 | " the operational datastore referenced from the operation.\n" |
aPiecek | a40764b | 2023-04-27 15:34:56 +0200 | [diff] [blame^] | 286 | " In case of a nested notification or action, its parent existence\n" |
| 287 | " is also checked in these operational data.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 288 | |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 289 | printf(" -R FILE, --reply-rpc=FILE\n" |
| 290 | " Provide source RPC for parsing of the 'nc-reply' TYPE. The FILE\n" |
| 291 | " is supposed to contain the source 'nc-rpc' operation of the reply.\n\n"); |
| 292 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 293 | printf(" -m, --merge Merge input data files into a single tree and validate at\n" |
Michal Vasko | 06158fb | 2022-03-29 12:13:16 +0200 | [diff] [blame] | 294 | " once. The option has effect only for 'data' and 'config' TYPEs.\n\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 295 | |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 296 | printf(" -y, --yang-library\n" |
Michal Vasko | c431a0a | 2021-01-25 14:31:58 +0100 | [diff] [blame] | 297 | " Load and implement internal \"ietf-yang-library\" YANG module.\n" |
| 298 | " Note that this module includes definitions of mandatory state\n" |
Michal Vasko | 22e0f3a | 2021-09-22 12:19:23 +0200 | [diff] [blame] | 299 | " data that can result in unexpected data validation errors.\n\n"); |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 300 | |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 301 | printf(" -Y FILE, --yang-library-file=FILE\n" |
| 302 | " Parse FILE with \"ietf-yang-library\" data and use them to\n" |
| 303 | " create an exact YANG schema context. If specified, the '-F'\n" |
| 304 | " parameter (enabled features) is ignored.\n\n"); |
| 305 | |
steweg | d8e2fc9 | 2023-05-31 09:52:56 +0200 | [diff] [blame] | 306 | printf(" -X, --extended-leafref\n" |
| 307 | " Allow usage of deref() XPath function within leafref\n\n"); |
| 308 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 309 | #ifndef NDEBUG |
| 310 | printf(" -G GROUPS, --debug=GROUPS\n" |
| 311 | " Enable printing of specific debugging message group\n" |
| 312 | " (nothing will be printed unless verbosity is set to debug):\n" |
Michal Vasko | 27a4acb | 2021-11-22 10:03:46 +0100 | [diff] [blame] | 313 | " <group>[,<group>]* (dict, xpath, dep-sets)\n\n"); |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 314 | #endif |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 315 | } |
| 316 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 317 | static void |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 318 | libyang_verbclb(LY_LOG_LEVEL level, const char *msg, const char *path) |
| 319 | { |
| 320 | char *levstr; |
| 321 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 322 | switch (level) { |
| 323 | case LY_LLERR: |
| 324 | levstr = "err :"; |
| 325 | break; |
| 326 | case LY_LLWRN: |
| 327 | levstr = "warn:"; |
| 328 | break; |
| 329 | case LY_LLVRB: |
| 330 | levstr = "verb:"; |
| 331 | break; |
| 332 | default: |
| 333 | levstr = "dbg :"; |
| 334 | break; |
| 335 | } |
| 336 | if (path) { |
| 337 | fprintf(stderr, "libyang %s %s (%s)\n", levstr, msg, path); |
| 338 | } else { |
| 339 | fprintf(stderr, "libyang %s %s\n", levstr, msg); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 340 | } |
| 341 | } |
| 342 | |
Michal Vasko | 686d8fc | 2021-11-22 10:03:23 +0100 | [diff] [blame] | 343 | static struct schema_features * |
| 344 | get_features_not_applied(const struct ly_set *fset) |
| 345 | { |
| 346 | for (uint32_t u = 0; u < fset->count; ++u) { |
| 347 | struct schema_features *sf = fset->objs[u]; |
Michal Vasko | 26bbb27 | 2022-08-02 14:54:33 +0200 | [diff] [blame] | 348 | |
Michal Vasko | 686d8fc | 2021-11-22 10:03:23 +0100 | [diff] [blame] | 349 | if (!sf->applied) { |
| 350 | return sf; |
| 351 | } |
| 352 | } |
| 353 | |
| 354 | return NULL; |
| 355 | } |
| 356 | |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 357 | static LY_ERR |
| 358 | ext_data_clb(const struct lysc_ext_instance *ext, void *user_data, void **ext_data, ly_bool *ext_data_free) |
| 359 | { |
| 360 | struct ly_ctx *ctx; |
| 361 | struct lyd_node *data = NULL; |
| 362 | |
| 363 | ctx = ext->module->ctx; |
| 364 | if (user_data) { |
| 365 | lyd_parse_data_path(ctx, user_data, LYD_XML, LYD_PARSE_STRICT, LYD_VALIDATE_PRESENT, &data); |
| 366 | } |
| 367 | |
| 368 | *ext_data = data; |
| 369 | *ext_data_free = 1; |
| 370 | return LY_SUCCESS; |
| 371 | } |
| 372 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 373 | static LY_ERR |
| 374 | searchpath_strcat(char **searchpaths, const char *path) |
| 375 | { |
| 376 | uint64_t len; |
| 377 | char *new; |
| 378 | |
| 379 | if (!(*searchpaths)) { |
| 380 | *searchpaths = strdup(path); |
| 381 | return LY_SUCCESS; |
| 382 | } |
| 383 | |
| 384 | len = strlen(*searchpaths) + strlen(path) + strlen(PATH_SEPARATOR); |
| 385 | new = realloc(*searchpaths, sizeof(char) * len + 1); |
| 386 | if (!new) { |
| 387 | return LY_EMEM; |
| 388 | } |
| 389 | strcat(new, PATH_SEPARATOR); |
| 390 | strcat(new, path); |
| 391 | *searchpaths = new; |
| 392 | |
| 393 | return LY_SUCCESS; |
| 394 | } |
| 395 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 396 | static int |
| 397 | fill_context_inputs(int argc, char *argv[], struct context *c) |
| 398 | { |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 399 | struct ly_in *in = NULL; |
Michal Vasko | 686d8fc | 2021-11-22 10:03:23 +0100 | [diff] [blame] | 400 | struct schema_features *sf; |
Michal Vasko | c91fb12 | 2021-11-23 09:00:17 +0100 | [diff] [blame] | 401 | struct lys_module *mod; |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 402 | const char *all_features[] = {"*", NULL}; |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 403 | char *dir = NULL, *module = NULL; |
| 404 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 405 | /* Create libyang context. */ |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 406 | if (c->yang_lib_file) { |
| 407 | /* ignore features */ |
| 408 | ly_set_erase(&c->schema_features, free_features); |
| 409 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 410 | if (ly_ctx_new_ylpath(c->searchpaths, c->yang_lib_file, LYD_UNKNOWN, c->ctx_options, &c->ctx)) { |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 411 | YLMSG_E("Unable to modify libyang context with yang-library data.\n"); |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 412 | return -1; |
| 413 | } |
| 414 | } else { |
| 415 | /* set imp feature flag if all should be enabled */ |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 416 | c->ctx_options |= !c->schema_features.count ? LY_CTX_ENABLE_IMP_FEATURES : 0; |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 417 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 418 | if (ly_ctx_new(c->searchpaths, c->ctx_options, &c->ctx)) { |
| 419 | YLMSG_E("Unable to create libyang context\n"); |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 420 | return -1; |
| 421 | } |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 422 | } |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 423 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 424 | /* set callback providing run-time extension instance data */ |
| 425 | if (c->schema_context_filename) { |
| 426 | ly_ctx_set_ext_data_clb(c->ctx, ext_data_clb, c->schema_context_filename); |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 427 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 428 | |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 429 | /* process the operational and/or reply RPC content if any */ |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 430 | if (c->data_operational.path) { |
| 431 | if (get_input(c->data_operational.path, NULL, &c->data_operational.format, &c->data_operational.in)) { |
| 432 | return -1; |
| 433 | } |
| 434 | } |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 435 | if (c->reply_rpc.path) { |
| 436 | if (get_input(c->reply_rpc.path, NULL, &c->reply_rpc.format, &c->reply_rpc.in)) { |
| 437 | return -1; |
| 438 | } |
| 439 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 440 | |
| 441 | for (int i = 0; i < argc - optind; i++) { |
| 442 | LYS_INFORMAT format_schema = LYS_IN_UNKNOWN; |
| 443 | LYD_FORMAT format_data = LYD_UNKNOWN; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 444 | |
| 445 | if (get_input(argv[optind + i], &format_schema, &format_data, &in)) { |
Radek Krejci | f2afd67 | 2020-11-26 12:29:23 +0100 | [diff] [blame] | 446 | goto error; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 447 | } |
| 448 | |
| 449 | if (format_schema) { |
| 450 | LY_ERR ret; |
| 451 | uint8_t path_unset = 1; /* flag to unset the path from the searchpaths list (if not already present) */ |
Michal Vasko | 5974087 | 2021-11-22 10:01:34 +0100 | [diff] [blame] | 452 | const char **features; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 453 | |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 454 | /* parse the input */ |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 455 | if (parse_schema_path(argv[optind + i], &dir, &module)) { |
Radek Krejci | f2afd67 | 2020-11-26 12:29:23 +0100 | [diff] [blame] | 456 | goto error; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 457 | } |
| 458 | |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 459 | if (c->yang_lib_file) { |
| 460 | /* just get the module, it should already be parsed */ |
| 461 | mod = ly_ctx_get_module_implemented(c->ctx, module); |
| 462 | if (!mod) { |
| 463 | YLMSG_E("Schema module \"%s\" not implemented in yang-library data.\n", module); |
| 464 | goto error; |
| 465 | } |
Michal Vasko | 5974087 | 2021-11-22 10:01:34 +0100 | [diff] [blame] | 466 | } else { |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 467 | /* add temporarily also the path of the module itself */ |
| 468 | if (ly_ctx_set_searchdir(c->ctx, dir) == LY_EEXIST) { |
| 469 | path_unset = 0; |
| 470 | } |
| 471 | |
| 472 | /* get features list for this module */ |
| 473 | if (!c->schema_features.count) { |
| 474 | features = all_features; |
| 475 | } else { |
| 476 | get_features(&c->schema_features, module, &features); |
| 477 | } |
| 478 | |
| 479 | /* parse module */ |
| 480 | ret = lys_parse(c->ctx, in, format_schema, features, &mod); |
| 481 | ly_ctx_unset_searchdir_last(c->ctx, path_unset); |
| 482 | if (ret) { |
| 483 | YLMSG_E("Parsing schema module \"%s\" failed.\n", argv[optind + i]); |
| 484 | goto error; |
| 485 | } |
Michal Vasko | 703370c | 2021-10-19 14:07:16 +0200 | [diff] [blame] | 486 | } |
| 487 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 488 | /* temporary cleanup */ |
| 489 | free(dir); |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 490 | dir = NULL; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 491 | free(module); |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 492 | module = NULL; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 493 | |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 494 | if (c->schema_out_format || c->feature_param_format) { |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 495 | /* module will be printed */ |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 496 | if (ly_set_add(&c->schema_modules, (void *)mod, 1, NULL)) { |
| 497 | YLMSG_E("Storing parsed schema module (%s) for print failed.\n", argv[optind + i]); |
Radek Krejci | f2afd67 | 2020-11-26 12:29:23 +0100 | [diff] [blame] | 498 | goto error; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 499 | } |
| 500 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 501 | } else if (format_data) { |
Radek Krejci | 6784a4e | 2020-12-09 14:23:05 +0100 | [diff] [blame] | 502 | if (!fill_cmdline_file(&c->data_inputs, in, argv[optind + i], format_data)) { |
Radek Krejci | f2afd67 | 2020-11-26 12:29:23 +0100 | [diff] [blame] | 503 | goto error; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 504 | } |
Radek Krejci | f53b0d5 | 2020-12-03 11:29:24 +0100 | [diff] [blame] | 505 | in = NULL; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 506 | } |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 507 | |
| 508 | ly_in_free(in, 1); |
| 509 | in = NULL; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 510 | } |
| 511 | |
Michal Vasko | c91fb12 | 2021-11-23 09:00:17 +0100 | [diff] [blame] | 512 | /* check that all specified features were applied, apply now if possible */ |
| 513 | while ((sf = get_features_not_applied(&c->schema_features))) { |
| 514 | /* try to find implemented or the latest revision of this module */ |
| 515 | mod = ly_ctx_get_module_implemented(c->ctx, sf->mod_name); |
| 516 | if (!mod) { |
| 517 | mod = ly_ctx_get_module_latest(c->ctx, sf->mod_name); |
Michal Vasko | 686d8fc | 2021-11-22 10:03:23 +0100 | [diff] [blame] | 518 | } |
Michal Vasko | c91fb12 | 2021-11-23 09:00:17 +0100 | [diff] [blame] | 519 | if (!mod) { |
| 520 | YLMSG_E("Specified features not applied, module \"%s\" not loaded.\n", sf->mod_name); |
| 521 | goto error; |
| 522 | } |
| 523 | |
| 524 | /* we have the module, implement it if needed and enable the specific features */ |
| 525 | if (lys_set_implemented(mod, (const char **)sf->features)) { |
| 526 | YLMSG_E("Implementing module \"%s\" failed.\n", mod->name); |
| 527 | goto error; |
| 528 | } |
| 529 | sf->applied = 1; |
Michal Vasko | 686d8fc | 2021-11-22 10:03:23 +0100 | [diff] [blame] | 530 | } |
| 531 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 532 | return 0; |
Radek Krejci | f2afd67 | 2020-11-26 12:29:23 +0100 | [diff] [blame] | 533 | |
| 534 | error: |
| 535 | ly_in_free(in, 1); |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 536 | free(dir); |
| 537 | free(module); |
Radek Krejci | f2afd67 | 2020-11-26 12:29:23 +0100 | [diff] [blame] | 538 | return -1; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 539 | } |
| 540 | |
| 541 | /** |
| 542 | * @brief Process command line options and store the settings into the context. |
| 543 | * |
| 544 | * return -1 in case of error; |
| 545 | * return 0 in case of success and ready to process |
| 546 | * return 1 in case of success, but expect to exit. |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 547 | */ |
| 548 | static int |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 549 | fill_context(int argc, char *argv[], struct context *c) |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 550 | { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 551 | int ret; |
Radek Krejci | e7b9509 | 2019-05-15 11:03:07 +0200 | [diff] [blame] | 552 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 553 | int opt, opt_index; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 554 | struct option options[] = { |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 555 | {"help", no_argument, NULL, 'h'}, |
| 556 | {"version", no_argument, NULL, 'v'}, |
| 557 | {"verbose", no_argument, NULL, 'V'}, |
| 558 | {"quiet", no_argument, NULL, 'Q'}, |
| 559 | {"format", required_argument, NULL, 'f'}, |
| 560 | {"path", required_argument, NULL, 'p'}, |
Michal Vasko | d8b0e77 | 2022-03-18 13:36:04 +0100 | [diff] [blame] | 561 | {"disable-searchdir", no_argument, NULL, 'D'}, |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 562 | {"features", required_argument, NULL, 'F'}, |
| 563 | {"make-implemented", no_argument, NULL, 'i'}, |
| 564 | {"schema-node", required_argument, NULL, 'P'}, |
| 565 | {"single-node", no_argument, NULL, 'q'}, |
| 566 | {"submodule", required_argument, NULL, 's'}, |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 567 | {"ext-data", required_argument, NULL, 'x'}, |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 568 | {"not-strict", no_argument, NULL, 'n'}, |
| 569 | {"present", no_argument, NULL, 'e'}, |
| 570 | {"type", required_argument, NULL, 't'}, |
| 571 | {"default", required_argument, NULL, 'd'}, |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 572 | {"data-xpath", required_argument, NULL, 'E'}, |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 573 | {"list", no_argument, NULL, 'l'}, |
| 574 | {"tree-line-length", required_argument, NULL, 'L'}, |
| 575 | {"output", required_argument, NULL, 'o'}, |
| 576 | {"operational", required_argument, NULL, 'O'}, |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 577 | {"reply-rpc", required_argument, NULL, 'R'}, |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 578 | {"merge", no_argument, NULL, 'm'}, |
| 579 | {"yang-library", no_argument, NULL, 'y'}, |
| 580 | {"yang-library-file", required_argument, NULL, 'Y'}, |
steweg | d8e2fc9 | 2023-05-31 09:52:56 +0200 | [diff] [blame] | 581 | {"extended-leafref", no_argument, NULL, 'X'}, |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 582 | #ifndef NDEBUG |
| 583 | {"debug", required_argument, NULL, 'G'}, |
| 584 | #endif |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 585 | {NULL, 0, NULL, 0} |
| 586 | }; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 587 | uint8_t data_type_set = 0; |
| 588 | |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 589 | c->ctx_options = YL_DEFAULT_CTX_OPTIONS; |
Michal Vasko | 667ce6b | 2021-01-25 15:00:27 +0100 | [diff] [blame] | 590 | c->data_parse_options = YL_DEFAULT_DATA_PARSE_OPTIONS; |
Michal Vasko | 05eaf83 | 2023-02-10 09:21:46 +0100 | [diff] [blame] | 591 | c->data_validate_options = YL_DEFAULT_DATA_VALIDATE_OPTIONS; |
aPiecek | 2cfeeae | 2021-04-21 13:17:34 +0200 | [diff] [blame] | 592 | c->line_length = 0; |
Michal Vasko | 667ce6b | 2021-01-25 15:00:27 +0100 | [diff] [blame] | 593 | |
Michal Vasko | 27a4acb | 2021-11-22 10:03:46 +0100 | [diff] [blame] | 594 | opterr = 0; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 595 | #ifndef NDEBUG |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 596 | while ((opt = getopt_long(argc, argv, "hvVQf:p:DF:iP:qs:neE:t:d:lL:o:O:R:myY:Xx:G:", options, &opt_index)) != -1) |
Michal Vasko | 27a4acb | 2021-11-22 10:03:46 +0100 | [diff] [blame] | 597 | #else |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 598 | while ((opt = getopt_long(argc, argv, "hvVQf:p:DF:iP:qs:neE:t:d:lL:o:O:R:myY:Xx:", options, &opt_index)) != -1) |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 599 | #endif |
Michal Vasko | 03fe620 | 2022-07-22 16:23:13 +0200 | [diff] [blame] | 600 | { |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 601 | switch (opt) { |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 602 | case 'h': /* --help */ |
| 603 | help(0); |
| 604 | return 1; |
| 605 | |
| 606 | case 'v': /* --version */ |
| 607 | version(); |
| 608 | return 1; |
| 609 | |
| 610 | case 'V': { /* --verbose */ |
| 611 | LY_LOG_LEVEL verbosity = ly_log_level(LY_LLERR); |
Michal Vasko | 2bf4af4 | 2023-01-04 12:08:38 +0100 | [diff] [blame] | 612 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 613 | if (verbosity < LY_LLDBG) { |
Michal Vasko | b0d307b | 2021-11-25 11:15:16 +0100 | [diff] [blame] | 614 | ++verbosity; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 615 | } |
Michal Vasko | b0d307b | 2021-11-25 11:15:16 +0100 | [diff] [blame] | 616 | ly_log_level(verbosity); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 617 | break; |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 618 | } /* case 'V' */ |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 619 | |
Michal Vasko | b0d307b | 2021-11-25 11:15:16 +0100 | [diff] [blame] | 620 | case 'Q': { /* --quiet */ |
| 621 | LY_LOG_LEVEL verbosity = ly_log_level(LY_LLERR); |
Michal Vasko | 2bf4af4 | 2023-01-04 12:08:38 +0100 | [diff] [blame] | 622 | |
Michal Vasko | b0d307b | 2021-11-25 11:15:16 +0100 | [diff] [blame] | 623 | if (verbosity == LY_LLERR) { |
| 624 | /* turn logging off */ |
| 625 | ly_log_options(LY_LOSTORE_LAST); |
| 626 | } else if (verbosity > LY_LLERR) { |
| 627 | --verbosity; |
| 628 | } |
| 629 | ly_log_level(verbosity); |
| 630 | break; |
| 631 | } /* case 'Q' */ |
| 632 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 633 | case 'f': /* --format */ |
| 634 | if (!strcasecmp(optarg, "yang")) { |
| 635 | c->schema_out_format = LYS_OUT_YANG; |
| 636 | c->data_out_format = 0; |
| 637 | } else if (!strcasecmp(optarg, "yin")) { |
| 638 | c->schema_out_format = LYS_OUT_YIN; |
| 639 | c->data_out_format = 0; |
| 640 | } else if (!strcasecmp(optarg, "info")) { |
| 641 | c->schema_out_format = LYS_OUT_YANG_COMPILED; |
| 642 | c->data_out_format = 0; |
| 643 | } else if (!strcasecmp(optarg, "tree")) { |
| 644 | c->schema_out_format = LYS_OUT_TREE; |
| 645 | c->data_out_format = 0; |
| 646 | } else if (!strcasecmp(optarg, "xml")) { |
| 647 | c->schema_out_format = 0; |
| 648 | c->data_out_format = LYD_XML; |
| 649 | } else if (!strcasecmp(optarg, "json")) { |
| 650 | c->schema_out_format = 0; |
| 651 | c->data_out_format = LYD_JSON; |
Michal Vasko | d8b0e77 | 2022-03-18 13:36:04 +0100 | [diff] [blame] | 652 | } else if (!strcasecmp(optarg, "lyb")) { |
| 653 | c->schema_out_format = 0; |
| 654 | c->data_out_format = LYD_LYB; |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 655 | } else if (!strcasecmp(optarg, "feature-param")) { |
| 656 | c->feature_param_format = 1; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 657 | } else { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 658 | YLMSG_E("Unknown output format %s\n", optarg); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 659 | help(1); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 660 | return -1; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 661 | } |
| 662 | break; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 663 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 664 | case 'p': { /* --path */ |
| 665 | struct stat st; |
| 666 | |
| 667 | if (stat(optarg, &st) == -1) { |
| 668 | YLMSG_E("Unable to use search path (%s) - %s.\n", optarg, strerror(errno)); |
| 669 | return -1; |
| 670 | } |
| 671 | if (!S_ISDIR(st.st_mode)) { |
| 672 | YLMSG_E("Provided search path is not a directory.\n"); |
| 673 | return -1; |
| 674 | } |
| 675 | |
aPiecek | 912f3d5 | 2022-10-12 10:02:33 +0200 | [diff] [blame] | 676 | if (searchpath_strcat(&c->searchpaths, optarg)) { |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 677 | YLMSG_E("Storing searchpath failed.\n"); |
| 678 | return -1; |
| 679 | } |
| 680 | |
| 681 | break; |
| 682 | } /* case 'p' */ |
| 683 | |
| 684 | case 'D': /* --disable-search */ |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 685 | if (c->ctx_options & LY_CTX_DISABLE_SEARCHDIRS) { |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 686 | YLMSG_W("The -D option specified too many times.\n"); |
| 687 | } |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 688 | if (c->ctx_options & LY_CTX_DISABLE_SEARCHDIR_CWD) { |
| 689 | c->ctx_options &= ~LY_CTX_DISABLE_SEARCHDIR_CWD; |
| 690 | c->ctx_options |= LY_CTX_DISABLE_SEARCHDIRS; |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 691 | } else { |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 692 | c->ctx_options |= LY_CTX_DISABLE_SEARCHDIR_CWD; |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 693 | } |
| 694 | break; |
| 695 | |
| 696 | case 'F': /* --features */ |
| 697 | if (parse_features(optarg, &c->schema_features)) { |
| 698 | return -1; |
| 699 | } |
| 700 | break; |
| 701 | |
Michal Vasko | 8d6d0ad | 2021-10-19 12:32:27 +0200 | [diff] [blame] | 702 | case 'i': /* --make-implemented */ |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 703 | if (c->ctx_options & LY_CTX_REF_IMPLEMENTED) { |
| 704 | c->ctx_options &= ~LY_CTX_REF_IMPLEMENTED; |
| 705 | c->ctx_options |= LY_CTX_ALL_IMPLEMENTED; |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 706 | } else { |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 707 | c->ctx_options |= LY_CTX_REF_IMPLEMENTED; |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 708 | } |
| 709 | break; |
| 710 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 711 | case 'P': /* --schema-node */ |
| 712 | c->schema_node_path = optarg; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 713 | break; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 714 | |
| 715 | case 'q': /* --single-node */ |
| 716 | c->schema_print_options |= LYS_PRINT_NO_SUBSTMT; |
| 717 | break; |
| 718 | |
Michal Vasko | fe74d1e | 2021-09-30 13:17:36 +0200 | [diff] [blame] | 719 | case 's': /* --submodule */ |
| 720 | c->submodule = optarg; |
| 721 | break; |
| 722 | |
ekinzie | 0ab8b30 | 2022-10-10 03:03:57 -0400 | [diff] [blame] | 723 | case 'x': /* --ext-data */ |
| 724 | c->schema_context_filename = strdup(optarg); |
| 725 | break; |
| 726 | |
Michal Vasko | 667ce6b | 2021-01-25 15:00:27 +0100 | [diff] [blame] | 727 | case 'n': /* --not-strict */ |
| 728 | c->data_parse_options &= ~LYD_PARSE_STRICT; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 729 | break; |
| 730 | |
| 731 | case 'e': /* --present */ |
| 732 | c->data_validate_options |= LYD_VALIDATE_PRESENT; |
| 733 | break; |
| 734 | |
| 735 | case 't': /* --type */ |
| 736 | if (data_type_set) { |
| 737 | YLMSG_E("The data type (-t) cannot be set multiple times.\n"); |
| 738 | return -1; |
| 739 | } |
| 740 | |
| 741 | if (!strcasecmp(optarg, "config")) { |
| 742 | c->data_parse_options |= LYD_PARSE_NO_STATE; |
Michal Vasko | f6bda33 | 2021-02-01 08:59:03 +0100 | [diff] [blame] | 743 | c->data_validate_options |= LYD_VALIDATE_NO_STATE; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 744 | } else if (!strcasecmp(optarg, "get")) { |
| 745 | c->data_parse_options |= LYD_PARSE_ONLY; |
aPiecek | be6c060 | 2023-04-18 11:29:09 +0200 | [diff] [blame] | 746 | } else if (!strcasecmp(optarg, "getconfig") || !strcasecmp(optarg, "get-config") || !strcasecmp(optarg, "edit")) { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 747 | c->data_parse_options |= LYD_PARSE_ONLY | LYD_PARSE_NO_STATE; |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 748 | } else if (!strcasecmp(optarg, "rpc")) { |
Michal Vasko | 1e4c68e | 2021-02-18 15:03:01 +0100 | [diff] [blame] | 749 | c->data_type = LYD_TYPE_RPC_YANG; |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 750 | } else if (!strcasecmp(optarg, "nc-rpc")) { |
| 751 | c->data_type = LYD_TYPE_RPC_NETCONF; |
| 752 | } else if (!strcasecmp(optarg, "reply")) { |
Michal Vasko | 1e4c68e | 2021-02-18 15:03:01 +0100 | [diff] [blame] | 753 | c->data_type = LYD_TYPE_REPLY_YANG; |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 754 | } else if (!strcasecmp(optarg, "nc-reply")) { |
| 755 | c->data_type = LYD_TYPE_REPLY_NETCONF; |
| 756 | } else if (!strcasecmp(optarg, "notif")) { |
Michal Vasko | 1e4c68e | 2021-02-18 15:03:01 +0100 | [diff] [blame] | 757 | c->data_type = LYD_TYPE_NOTIF_YANG; |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 758 | } else if (!strcasecmp(optarg, "nc-notif")) { |
| 759 | c->data_type = LYD_TYPE_NOTIF_NETCONF; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 760 | } else if (!strcasecmp(optarg, "data")) { |
| 761 | /* default option */ |
| 762 | } else { |
| 763 | YLMSG_E("Unknown data tree type %s\n", optarg); |
| 764 | help(1); |
| 765 | return -1; |
| 766 | } |
| 767 | |
| 768 | data_type_set = 1; |
| 769 | break; |
| 770 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 771 | case 'd': /* --default */ |
| 772 | if (!strcasecmp(optarg, "all")) { |
| 773 | c->data_print_options = (c->data_print_options & ~LYD_PRINT_WD_MASK) | LYD_PRINT_WD_ALL; |
| 774 | } else if (!strcasecmp(optarg, "all-tagged")) { |
| 775 | c->data_print_options = (c->data_print_options & ~LYD_PRINT_WD_MASK) | LYD_PRINT_WD_ALL_TAG; |
| 776 | } else if (!strcasecmp(optarg, "trim")) { |
| 777 | c->data_print_options = (c->data_print_options & ~LYD_PRINT_WD_MASK) | LYD_PRINT_WD_TRIM; |
| 778 | } else if (!strcasecmp(optarg, "implicit-tagged")) { |
| 779 | c->data_print_options = (c->data_print_options & ~LYD_PRINT_WD_MASK) | LYD_PRINT_WD_IMPL_TAG; |
| 780 | } else { |
| 781 | YLMSG_E("Unknown default mode %s\n", optarg); |
| 782 | help(1); |
| 783 | return -1; |
| 784 | } |
| 785 | break; |
| 786 | |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 787 | case 'E': /* --data-xpath */ |
| 788 | if (ly_set_add(&c->data_xpath, optarg, 0, NULL)) { |
| 789 | YLMSG_E("Storing XPath \"%s\" failed.\n", optarg); |
| 790 | return -1; |
| 791 | } |
| 792 | break; |
| 793 | |
Michal Vasko | c40548b | 2021-09-30 13:05:47 +0200 | [diff] [blame] | 794 | case 'l': /* --list */ |
| 795 | c->list = 1; |
| 796 | break; |
| 797 | |
| 798 | case 'L': /* --tree-line-length */ |
| 799 | c->line_length = atoi(optarg); |
| 800 | break; |
| 801 | |
| 802 | case 'o': /* --output */ |
| 803 | if (c->out) { |
| 804 | YLMSG_E("Only a single output can be specified.\n"); |
| 805 | return -1; |
| 806 | } else { |
| 807 | if (ly_out_new_filepath(optarg, &c->out)) { |
| 808 | YLMSG_E("Unable open output file %s (%s)\n", optarg, strerror(errno)); |
| 809 | return -1; |
| 810 | } |
| 811 | } |
| 812 | break; |
| 813 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 814 | case 'O': /* --operational */ |
| 815 | if (c->data_operational.path) { |
| 816 | YLMSG_E("The operational datastore (-O) cannot be set multiple times.\n"); |
| 817 | return -1; |
| 818 | } |
| 819 | c->data_operational.path = optarg; |
| 820 | break; |
| 821 | |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 822 | case 'R': /* --reply-rpc */ |
| 823 | if (c->reply_rpc.path) { |
| 824 | YLMSG_E("The PRC of the reply (-R) cannot be set multiple times.\n"); |
| 825 | return -1; |
| 826 | } |
| 827 | c->reply_rpc.path = optarg; |
| 828 | break; |
| 829 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 830 | case 'm': /* --merge */ |
| 831 | c->data_merge = 1; |
| 832 | break; |
| 833 | |
Michal Vasko | c431a0a | 2021-01-25 14:31:58 +0100 | [diff] [blame] | 834 | case 'y': /* --yang-library */ |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 835 | c->ctx_options &= ~LY_CTX_NO_YANGLIBRARY; |
| 836 | break; |
| 837 | |
| 838 | case 'Y': /* --yang-library-file */ |
| 839 | c->ctx_options &= ~LY_CTX_NO_YANGLIBRARY; |
| 840 | c->yang_lib_file = optarg; |
Michal Vasko | c431a0a | 2021-01-25 14:31:58 +0100 | [diff] [blame] | 841 | break; |
| 842 | |
steweg | d8e2fc9 | 2023-05-31 09:52:56 +0200 | [diff] [blame] | 843 | case 'X': /* --extended-leafref */ |
| 844 | c->ctx_options |= LY_CTX_LEAFREF_EXTENDED; |
| 845 | break; |
| 846 | |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 847 | #ifndef NDEBUG |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 848 | case 'G': { /* --debug */ |
| 849 | uint32_t dbg_groups = 0; |
| 850 | const char *ptr = optarg; |
| 851 | |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 852 | while (ptr[0]) { |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 853 | if (!strncasecmp(ptr, "dict", sizeof "dict" - 1)) { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 854 | dbg_groups |= LY_LDGDICT; |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 855 | ptr += sizeof "dict" - 1; |
| 856 | } else if (!strncasecmp(ptr, "xpath", sizeof "xpath" - 1)) { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 857 | dbg_groups |= LY_LDGXPATH; |
Radek Krejci | f13b87b | 2020-12-01 22:02:17 +0100 | [diff] [blame] | 858 | ptr += sizeof "xpath" - 1; |
Michal Vasko | 27a4acb | 2021-11-22 10:03:46 +0100 | [diff] [blame] | 859 | } else if (!strncasecmp(ptr, "dep-sets", sizeof "dep-sets" - 1)) { |
| 860 | dbg_groups |= LY_LDGDEPSETS; |
| 861 | ptr += sizeof "dep-sets" - 1; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 862 | } |
| 863 | |
| 864 | if (ptr[0]) { |
| 865 | if (ptr[0] != ',') { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 866 | YLMSG_E("Unknown debug group string \"%s\"\n", optarg); |
| 867 | return -1; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 868 | } |
| 869 | ++ptr; |
| 870 | } |
| 871 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 872 | ly_log_dbg_groups(dbg_groups); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 873 | break; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 874 | } /* case 'G' */ |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 875 | #endif |
Michal Vasko | 27a4acb | 2021-11-22 10:03:46 +0100 | [diff] [blame] | 876 | default: |
| 877 | YLMSG_E("Invalid option or missing argument: -%c\n", optopt); |
| 878 | return -1; |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 879 | } /* switch */ |
| 880 | } |
| 881 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 882 | /* additional checks for the options combinations */ |
| 883 | if (!c->list && (optind >= argc)) { |
| 884 | help(1); |
| 885 | YLMSG_E("Missing <schema> to process.\n"); |
| 886 | return 1; |
| 887 | } |
| 888 | |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 889 | if (c->data_xpath.count) { |
| 890 | c->data_merge = 1; |
| 891 | } |
| 892 | if (c->data_xpath.count && (c->schema_out_format || c->data_out_format)) { |
| 893 | YLMSG_E("The --format option cannot be combined with --data-xpath option.\n"); |
| 894 | return -1; |
| 895 | } |
| 896 | if (c->data_xpath.count && (c->data_print_options & LYD_PRINT_WD_MASK)) { |
| 897 | YLMSG_E("The --default option cannot be combined with --data-xpath option.\n"); |
| 898 | return -1; |
| 899 | } |
| 900 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 901 | if (c->data_merge) { |
| 902 | if (c->data_type || (c->data_parse_options & LYD_PARSE_ONLY)) { |
| 903 | /* switch off the option, incompatible input data type */ |
| 904 | c->data_merge = 0; |
| 905 | } else { |
| 906 | /* postpone validation after the merge of all the input data */ |
| 907 | c->data_parse_options |= LYD_PARSE_ONLY; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 908 | } |
| 909 | } |
| 910 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 911 | if (c->data_operational.path && !c->data_type) { |
aPiecek | ce48158 | 2023-04-26 15:44:59 +0200 | [diff] [blame] | 912 | YLMSG_W("Operational datastore takes effect only with RPCs/Actions/Replies/Notification input data types.\n"); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 913 | c->data_operational.path = NULL; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 914 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 915 | |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 916 | if (c->reply_rpc.path && (c->data_type != LYD_TYPE_REPLY_NETCONF)) { |
aPiecek | ce48158 | 2023-04-26 15:44:59 +0200 | [diff] [blame] | 917 | YLMSG_W("Source RPC is needed only for NETCONF Reply input data type.\n"); |
Michal Vasko | 3f08fb9 | 2022-04-21 09:52:35 +0200 | [diff] [blame] | 918 | c->data_operational.path = NULL; |
| 919 | } else if (!c->reply_rpc.path && (c->data_type == LYD_TYPE_REPLY_NETCONF)) { |
| 920 | YLMSG_E("Missing source RPC (-R) for NETCONF Reply input data type.\n"); |
| 921 | return -1; |
| 922 | } |
| 923 | |
aPiecek | 2cfeeae | 2021-04-21 13:17:34 +0200 | [diff] [blame] | 924 | if ((c->schema_out_format != LYS_OUT_TREE) && c->line_length) { |
aPiecek | ce48158 | 2023-04-26 15:44:59 +0200 | [diff] [blame] | 925 | YLMSG_W("--tree-line-length take effect only in case of the tree output format.\n"); |
aPiecek | 2cfeeae | 2021-04-21 13:17:34 +0200 | [diff] [blame] | 926 | } |
| 927 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 928 | /* default output stream */ |
| 929 | if (!c->out) { |
| 930 | if (ly_out_new_file(stdout, &c->out)) { |
| 931 | YLMSG_E("Unable to set stdout as output.\n"); |
| 932 | return -1; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 933 | } |
| 934 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 935 | |
aPiecek | 7ac66d5 | 2021-05-20 07:54:07 +0200 | [diff] [blame] | 936 | if (c->schema_out_format == LYS_OUT_TREE) { |
| 937 | /* print tree from lysc_nodes */ |
Michal Vasko | 24aaf8e | 2022-02-04 11:15:26 +0100 | [diff] [blame] | 938 | c->ctx_options |= LY_CTX_SET_PRIV_PARSED; |
aPiecek | 7ac66d5 | 2021-05-20 07:54:07 +0200 | [diff] [blame] | 939 | } |
| 940 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 941 | /* process input files provided as standalone command line arguments, |
| 942 | * schema modules are parsed and inserted into the context, |
| 943 | * data files are just checked and prepared into internal structures for further processing */ |
| 944 | ret = fill_context_inputs(argc, argv, c); |
| 945 | if (ret) { |
| 946 | return ret; |
| 947 | } |
| 948 | |
| 949 | /* the second batch of checks */ |
| 950 | if (c->schema_print_options && !c->schema_out_format) { |
| 951 | YLMSG_W("Schema printer options specified, but the schema output format is missing.\n"); |
| 952 | } |
| 953 | if (c->schema_parse_options && !c->schema_modules.count) { |
| 954 | YLMSG_W("Schema parser options specified, but no schema input file provided.\n"); |
| 955 | } |
| 956 | if (c->data_print_options && !c->data_out_format) { |
| 957 | YLMSG_W("data printer options specified, but the data output format is missing.\n"); |
| 958 | } |
Michal Vasko | 667ce6b | 2021-01-25 15:00:27 +0100 | [diff] [blame] | 959 | if (((c->data_parse_options != YL_DEFAULT_DATA_PARSE_OPTIONS) || c->data_type) && !c->data_inputs.count) { |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 960 | YLMSG_W("Data parser options specified, but no data input file provided.\n"); |
| 961 | } |
| 962 | |
| 963 | if (c->schema_node_path) { |
| 964 | c->schema_node = lys_find_path(c->ctx, NULL, c->schema_node_path, 0); |
| 965 | if (!c->schema_node) { |
| 966 | c->schema_node = lys_find_path(c->ctx, NULL, c->schema_node_path, 1); |
| 967 | |
| 968 | if (!c->schema_node) { |
| 969 | YLMSG_E("Invalid schema path.\n"); |
| 970 | return -1; |
| 971 | } |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 972 | } |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 973 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 974 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 975 | return 0; |
| 976 | } |
| 977 | |
| 978 | int |
| 979 | main_ni(int argc, char *argv[]) |
| 980 | { |
| 981 | int ret = EXIT_SUCCESS, r; |
| 982 | struct context c = {0}; |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 983 | char *features_output = NULL; |
| 984 | struct ly_set set = {0}; |
| 985 | uint32_t u; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 986 | |
| 987 | /* set callback for printing libyang messages */ |
| 988 | ly_set_log_clb(libyang_verbclb, 1); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 989 | |
| 990 | r = fill_context(argc, argv, &c); |
| 991 | if (r < 0) { |
| 992 | ret = EXIT_FAILURE; |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 993 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 994 | if (r) { |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 995 | goto cleanup; |
| 996 | } |
| 997 | |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 998 | /* do the required job - parse, validate, print */ |
| 999 | |
| 1000 | if (c.list) { |
| 1001 | /* print the list of schemas */ |
aPiecek | 3426262 | 2023-03-27 08:28:25 +0200 | [diff] [blame] | 1002 | ret = print_list(c.out, c.ctx, c.data_out_format); |
| 1003 | goto cleanup; |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1004 | } else { |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 1005 | if (c.feature_param_format) { |
| 1006 | for (u = 0; u < c.schema_modules.count; u++) { |
| 1007 | if (collect_features(c.schema_modules.objs[u], &set)) { |
| 1008 | YLMSG_E("Unable to read features from a module.\n"); |
| 1009 | goto cleanup; |
| 1010 | } |
| 1011 | if (generate_features_output(c.schema_modules.objs[u], &set, &features_output)) { |
| 1012 | YLMSG_E("Unable to generate feature command output.\n"); |
| 1013 | goto cleanup; |
| 1014 | } |
| 1015 | ly_set_erase(&set, NULL); |
| 1016 | } |
| 1017 | ly_print(c.out, "%s\n", features_output); |
| 1018 | } else if (c.schema_out_format) { |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1019 | if (c.schema_node) { |
aPiecek | 146fd19 | 2023-03-30 11:22:16 +0200 | [diff] [blame] | 1020 | ret = lys_print_node(c.out, c.schema_node, c.schema_out_format, c.line_length, c.schema_print_options); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 1021 | if (ret) { |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1022 | YLMSG_E("Unable to print schema node %s.\n", c.schema_node_path); |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 1023 | goto cleanup; |
| 1024 | } |
Michal Vasko | fe74d1e | 2021-09-30 13:17:36 +0200 | [diff] [blame] | 1025 | } else if (c.submodule) { |
| 1026 | const struct lysp_submodule *submod = ly_ctx_get_submodule_latest(c.ctx, c.submodule); |
Michal Vasko | 26bbb27 | 2022-08-02 14:54:33 +0200 | [diff] [blame] | 1027 | |
Michal Vasko | fe74d1e | 2021-09-30 13:17:36 +0200 | [diff] [blame] | 1028 | if (!submod) { |
| 1029 | YLMSG_E("Unable to find submodule %s.\n", c.submodule); |
| 1030 | goto cleanup; |
| 1031 | } |
| 1032 | |
| 1033 | ret = lys_print_submodule(c.out, submod, c.schema_out_format, c.line_length, c.schema_print_options); |
| 1034 | if (ret) { |
| 1035 | YLMSG_E("Unable to print submodule %s.\n", submod->name); |
| 1036 | goto cleanup; |
| 1037 | } |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1038 | } else { |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 1039 | for (u = 0; u < c.schema_modules.count; ++u) { |
aPiecek | 2cfeeae | 2021-04-21 13:17:34 +0200 | [diff] [blame] | 1040 | ret = lys_print_module(c.out, (struct lys_module *)c.schema_modules.objs[u], c.schema_out_format, |
| 1041 | c.line_length, c.schema_print_options); |
aPiecek | 8f0b788 | 2021-05-21 10:18:36 +0200 | [diff] [blame] | 1042 | /* for YANG Tree Diagrams printing it's more readable to print a blank line between modules. */ |
| 1043 | if ((c.schema_out_format == LYS_OUT_TREE) && (u + 1 < c.schema_modules.count)) { |
| 1044 | ly_print(c.out, "\n"); |
| 1045 | } |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1046 | if (ret) { |
| 1047 | YLMSG_E("Unable to print module %s.\n", ((struct lys_module *)c.schema_modules.objs[u])->name); |
| 1048 | goto cleanup; |
| 1049 | } |
| 1050 | } |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 1051 | } |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1052 | } |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1053 | |
| 1054 | /* do the data validation despite the schema was printed */ |
| 1055 | if (c.data_inputs.size) { |
Michal Vasko | 0f1e456 | 2022-03-29 11:57:57 +0200 | [diff] [blame] | 1056 | ret = process_data(c.ctx, c.data_type, c.data_merge, c.data_out_format, c.out, c.data_parse_options, |
aPiecek | 1b62976 | 2023-04-12 13:52:30 +0200 | [diff] [blame] | 1057 | c.data_validate_options, c.data_print_options, &c.data_operational, &c.reply_rpc, &c.data_inputs, |
| 1058 | &c.data_xpath); |
Michal Vasko | 0f1e456 | 2022-03-29 11:57:57 +0200 | [diff] [blame] | 1059 | if (ret) { |
Radek Krejci | 047d64e | 2020-12-03 12:57:10 +0100 | [diff] [blame] | 1060 | goto cleanup; |
| 1061 | } |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1062 | } |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1063 | } |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1064 | |
| 1065 | cleanup: |
Radek Krejci | e9f13b1 | 2020-11-09 17:42:04 +0100 | [diff] [blame] | 1066 | /* cleanup */ |
| 1067 | erase_context(&c); |
roman | 300b878 | 2022-08-11 12:49:21 +0200 | [diff] [blame] | 1068 | free(features_output); |
| 1069 | ly_set_erase(&set, NULL); |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1070 | |
Radek Krejci | ed5acc5 | 2019-04-25 15:57:04 +0200 | [diff] [blame] | 1071 | return ret; |
| 1072 | } |