blob: 9fa1b95e0ade6ae45bb314586a2bfa249c645ff4 [file] [log] [blame]
Radek Krejcie9f13b12020-11-09 17:42:04 +01001/**
2 * @file cmd_data.c
3 * @author Michal Vasko <mvasko@cesnet.cz>
4 * @author Radek Krejci <rkrejci@cesnet.cz>
aPieceka83b8e02023-06-07 15:25:16 +02005 * @author Adam Piecek <piecek@cesnet.cz>
Radek Krejcie9f13b12020-11-09 17:42:04 +01006 * @brief 'data' command of the libyang's yanglint tool.
7 *
aPieceka83b8e02023-06-07 15:25:16 +02008 * Copyright (c) 2015-2023 CESNET, z.s.p.o.
Radek Krejcie9f13b12020-11-09 17:42:04 +01009 *
10 * This source code is licensed under BSD 3-Clause License (the "License").
11 * You may not use this file except in compliance with the License.
12 * You may obtain a copy of the License at
13 *
14 * https://opensource.org/licenses/BSD-3-Clause
15 */
16
17#define _GNU_SOURCE
18
19#include "cmd.h"
20
aPieceka83b8e02023-06-07 15:25:16 +020021#include <assert.h>
Radek Krejcie9f13b12020-11-09 17:42:04 +010022#include <errno.h>
23#include <getopt.h>
24#include <stdint.h>
25#include <stdio.h>
26#include <string.h>
27#include <strings.h>
28
29#include "libyang.h"
30
31#include "common.h"
aPieceka83b8e02023-06-07 15:25:16 +020032#include "yl_opt.h"
Radek Krejcie9f13b12020-11-09 17:42:04 +010033
aPiecekb073f6a2023-04-28 15:23:25 +020034static void
35cmd_data_help_header(void)
Radek Krejcie9f13b12020-11-09 17:42:04 +010036{
Michal Vaskod3b10542021-02-03 11:31:16 +010037 printf("Usage: data [-emn] [-t TYPE]\n"
38 " [-F FORMAT] [-f FORMAT] [-d DEFAULTS] [-o OUTFILE] <data1> ...\n"
39 " data [-n] -t (rpc | notif | reply) [-O FILE]\n"
40 " [-F FORMAT] [-f FORMAT] [-d DEFAULTS] [-o OUTFILE] <data1> ...\n"
41 " data [-en] [-t TYPE] [-F FORMAT] -x XPATH [-o OUTFILE] <data1> ...\n"
aPiecekb073f6a2023-04-28 15:23:25 +020042 " Parse, validate and optionally print data instances\n");
43}
Radek Krejcie9f13b12020-11-09 17:42:04 +010044
aPiecekb073f6a2023-04-28 15:23:25 +020045static void
46cmd_data_help_type(void)
47{
48 printf(" -t TYPE, --type=TYPE\n"
Radek Krejcie9f13b12020-11-09 17:42:04 +010049 " Specify data tree type in the input data file(s):\n"
50 " data - Complete datastore with status data (default type).\n"
51 " config - Configuration datastore (without status data).\n"
52 " get - Result of the NETCONF <get> operation.\n"
53 " getconfig - Result of the NETCONF <get-config> operation.\n"
54 " edit - Content of the NETCONF <edit-config> operation.\n"
55 " rpc - Content of the NETCONF <rpc> message, defined as YANG's\n"
56 " RPC/Action input statement.\n"
aPiecek860e34f2023-04-28 10:01:32 +020057 " nc-rpc - Similar to 'rpc' but expect and check also the NETCONF\n"
58 " envelopes <rpc> or <action>.\n"
Radek Krejci6784a4e2020-12-09 14:23:05 +010059 " reply - Reply to the RPC/Action. Note that the reply data are\n"
60 " expected inside a container representing the original\n"
61 " RPC/Action. This is necessary to identify appropriate\n"
62 " data definitions in the schema module.\n"
aPiecek079bcde2023-05-05 11:48:25 +020063 " nc-reply - Similar to 'reply' but expect and check also the NETCONF\n"
64 " envelope <rpc-reply> with output data nodes as direct\n"
65 " descendants. The original RPC/action invocation is expected\n"
66 " in a separate parameter '-R' and is parsed as 'nc-rpc'.\n"
Radek Krejcie9f13b12020-11-09 17:42:04 +010067 " notif - Notification instance (content of the <notification>\n"
aPiecek6d2c1e72023-04-28 15:54:48 +020068 " element without <eventTime>).\n"
69 " nc-notif - Similar to 'notif' but expect and check also the NETCONF\n"
70 " envelope <notification> with element <eventTime> and its\n"
71 " sibling as the actual notification.\n");
aPiecekb073f6a2023-04-28 15:23:25 +020072}
Radek Krejcie9f13b12020-11-09 17:42:04 +010073
aPiecekb073f6a2023-04-28 15:23:25 +020074static void
75cmd_data_help_format(void)
76{
77 printf(" -f FORMAT, --format=FORMAT\n"
78 " Print the data in one of the following formats:\n"
79 " xml, json, lyb\n"
80 " Note that the LYB format requires the -o option specified.\n");
81}
82
83static void
84cmd_data_help_in_format(void)
85{
86 printf(" -F FORMAT, --in-format=FORMAT\n"
87 " Load the data in one of the following formats:\n"
88 " xml, json, lyb\n"
89 " If input format not specified, it is detected from the file extension.\n");
90}
91
92static void
93cmd_data_help_default(void)
94{
95 printf(" -d MODE, --default=MODE\n"
96 " Print data with default values, according to the MODE\n"
97 " (to print attributes, ietf-netconf-with-defaults model\n"
98 " must be loaded):\n"
99 " all - Add missing default nodes.\n"
100 " all-tagged - Add missing default nodes and mark all the default\n"
101 " nodes with the attribute.\n"
102 " trim - Remove all nodes with a default value.\n"
103 " implicit-tagged - Add missing nodes and mark them with the attribute.\n");
104}
105
106static void
107cmd_data_help_xpath(void)
108{
109 printf(" -x XPATH, --xpath=XPATH\n"
aPiecek41955272023-05-10 16:10:17 +0200110 " Evaluate XPATH expression and print the nodes satisfying the\n"
aPiecekb073f6a2023-04-28 15:23:25 +0200111 " expression. The output format is specific and the option cannot\n"
112 " be combined with the -f and -d options. Also all the data\n"
113 " inputs are merged into a single data tree where the expression\n"
114 " is evaluated, so the -m option is always set implicitly.\n");
115}
116
117void
118cmd_data_help(void)
119{
120 cmd_data_help_header();
121 printf("\n");
122 cmd_data_help_type();
123 printf(" -e, --present Validate only with the schema modules whose data actually\n"
Radek Krejcie9f13b12020-11-09 17:42:04 +0100124 " exist in the provided input data files. Takes effect only\n"
125 " with the 'data' or 'config' TYPEs. Used to avoid requiring\n"
126 " mandatory nodes from modules which data are not present in the\n"
127 " provided input data files.\n"
128 " -m, --merge Merge input data files into a single tree and validate at\n"
129 " once.The option has effect only for 'data' and 'config' TYPEs.\n"
130 " In case of using -x option, the data are always merged.\n"
Michal Vaskoc431a0a2021-01-25 14:31:58 +0100131 " -n, --not-strict\n"
132 " Do not require strict data parsing (silently skip unknown data),\n"
aPiecekb073f6a2023-04-28 15:23:25 +0200133 " has no effect for schemas.\n"
Radek Krejcie9f13b12020-11-09 17:42:04 +0100134 " -O FILE, --operational=FILE\n"
135 " Provide optional data to extend validation of the 'rpc',\n"
136 " 'reply' or 'notif' TYPEs. The FILE is supposed to contain\n"
aPieceka40764b2023-04-27 15:34:56 +0200137 " the operational datastore referenced from the operation.\n"
138 " In case of a nested notification or action, its parent\n"
aPiecek079bcde2023-05-05 11:48:25 +0200139 " existence is also checked in these operational data.\n"
140 " -R FILE, --reply-rpc=FILE\n"
141 " Provide source RPC for parsing of the 'nc-reply' TYPE. The FILE\n"
142 " is supposed to contain the source 'nc-rpc' operation of the reply.\n");
aPiecekb073f6a2023-04-28 15:23:25 +0200143 cmd_data_help_format();
144 cmd_data_help_in_format();
145 printf(" -o OUTFILE, --output=OUTFILE\n"
146 " Write the output to OUTFILE instead of stdout.\n");
147 cmd_data_help_xpath();
148 printf("\n");
Radek Krejcie9f13b12020-11-09 17:42:04 +0100149}
150
aPieceka83b8e02023-06-07 15:25:16 +0200151int
152cmd_data_opt(struct yl_opt *yo, const char *cmdline, char ***posv, int *posc)
Radek Krejcie9f13b12020-11-09 17:42:04 +0100153{
aPieceka83b8e02023-06-07 15:25:16 +0200154 int rc = 0, argc = 0;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100155 int opt, opt_index;
156 struct option options[] = {
Michal Vasko667ce6b2021-01-25 15:00:27 +0100157 {"defaults", required_argument, NULL, 'd'},
158 {"present", no_argument, NULL, 'e'},
159 {"format", required_argument, NULL, 'f'},
Michal Vaskod3b10542021-02-03 11:31:16 +0100160 {"in-format", required_argument, NULL, 'F'},
Michal Vasko667ce6b2021-01-25 15:00:27 +0100161 {"help", no_argument, NULL, 'h'},
162 {"merge", no_argument, NULL, 'm'},
163 {"output", required_argument, NULL, 'o'},
Radek Krejcie9f13b12020-11-09 17:42:04 +0100164 {"operational", required_argument, NULL, 'O'},
aPiecek079bcde2023-05-05 11:48:25 +0200165 {"reply-rpc", required_argument, NULL, 'R'},
Michal Vasko667ce6b2021-01-25 15:00:27 +0100166 {"not-strict", no_argument, NULL, 'n'},
167 {"type", required_argument, NULL, 't'},
168 {"xpath", required_argument, NULL, 'x'},
Radek Krejcie9f13b12020-11-09 17:42:04 +0100169 {NULL, 0, NULL, 0}
170 };
171
Radek Krejcie9f13b12020-11-09 17:42:04 +0100172 uint8_t data_type_set = 0;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100173
aPieceka83b8e02023-06-07 15:25:16 +0200174 yo->data_parse_options = YL_DEFAULT_DATA_PARSE_OPTIONS;
175 yo->data_validate_options = YL_DEFAULT_DATA_VALIDATE_OPTIONS;
176
177 if ((rc = parse_cmdline(cmdline, &argc, &yo->argv))) {
178 return rc;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100179 }
180
aPieceka83b8e02023-06-07 15:25:16 +0200181 while ((opt = getopt_long(argc, yo->argv, commands[CMD_DATA].optstring, options, &opt_index)) != -1) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100182 switch (opt) {
183 case 'd': /* --default */
aPiecek20cc2fe2023-06-09 09:32:28 +0200184 if (yo_opt_update_data_default(optarg, yo)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100185 YLMSG_E("Unknown default mode %s\n", optarg);
aPiecekb073f6a2023-04-28 15:23:25 +0200186 cmd_data_help_default();
aPieceka83b8e02023-06-07 15:25:16 +0200187 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100188 }
189 break;
190 case 'f': /* --format */
aPiecek113e0f02023-06-09 08:47:48 +0200191 if (yl_opt_update_data_out_format(optarg, yo)) {
aPiecekb073f6a2023-04-28 15:23:25 +0200192 cmd_data_help_format();
aPieceka83b8e02023-06-07 15:25:16 +0200193 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100194 }
195 break;
Michal Vaskod3b10542021-02-03 11:31:16 +0100196 case 'F': /* --in-format */
aPiecekb5dff492023-06-09 09:38:08 +0200197 if (yo_opt_update_data_in_format(optarg, yo)) {
Michal Vaskod3b10542021-02-03 11:31:16 +0100198 YLMSG_E("Unknown input format %s\n", optarg);
aPiecekb073f6a2023-04-28 15:23:25 +0200199 cmd_data_help_in_format();
aPieceka83b8e02023-06-07 15:25:16 +0200200 return 1;
Michal Vaskod3b10542021-02-03 11:31:16 +0100201 }
202 break;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100203 case 'o': /* --output */
aPieceka83b8e02023-06-07 15:25:16 +0200204 if (yo->out) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100205 YLMSG_E("Only a single output can be specified.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200206 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100207 } else {
aPieceka83b8e02023-06-07 15:25:16 +0200208 if (ly_out_new_filepath(optarg, &yo->out)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100209 YLMSG_E("Unable open output file %s (%s)\n", optarg, strerror(errno));
aPieceka83b8e02023-06-07 15:25:16 +0200210 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100211 }
212 }
213 break;
aPieceka83b8e02023-06-07 15:25:16 +0200214 case 'O': /* --operational */
215 if (yo->data_operational.path) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100216 YLMSG_E("The operational datastore (-O) cannot be set multiple times.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200217 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100218 }
aPieceka83b8e02023-06-07 15:25:16 +0200219 yo->data_operational.path = optarg;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100220 break;
aPieceka83b8e02023-06-07 15:25:16 +0200221 case 'R': /* --reply-rpc */
222 if (yo->reply_rpc.path) {
aPiecek079bcde2023-05-05 11:48:25 +0200223 YLMSG_E("The PRC of the reply (-R) cannot be set multiple times.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200224 return 1;
aPiecek079bcde2023-05-05 11:48:25 +0200225 }
aPieceka83b8e02023-06-07 15:25:16 +0200226 yo->reply_rpc.path = optarg;
aPiecek079bcde2023-05-05 11:48:25 +0200227 break;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100228 case 'e': /* --present */
aPieceka83b8e02023-06-07 15:25:16 +0200229 yo->data_validate_options |= LYD_VALIDATE_PRESENT;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100230 break;
231 case 'm': /* --merge */
aPieceka83b8e02023-06-07 15:25:16 +0200232 yo->data_merge = 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100233 break;
Michal Vasko667ce6b2021-01-25 15:00:27 +0100234 case 'n': /* --not-strict */
aPieceka83b8e02023-06-07 15:25:16 +0200235 yo->data_parse_options &= ~LYD_PARSE_STRICT;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100236 break;
237 case 't': /* --type */
238 if (data_type_set) {
239 YLMSG_E("The data type (-t) cannot be set multiple times.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200240 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100241 }
242
aPiecek3167f382023-06-09 09:23:10 +0200243 if (yl_opt_update_data_type(optarg, yo)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100244 YLMSG_E("Unknown data tree type %s.\n", optarg);
aPiecekb073f6a2023-04-28 15:23:25 +0200245 cmd_data_help_type();
aPieceka83b8e02023-06-07 15:25:16 +0200246 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100247 }
248
249 data_type_set = 1;
250 break;
251
252 case 'x': /* --xpath */
aPieceka83b8e02023-06-07 15:25:16 +0200253 if (ly_set_add(&yo->data_xpath, optarg, 0, NULL)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100254 YLMSG_E("Storing XPath \"%s\" failed.\n", optarg);
aPieceka83b8e02023-06-07 15:25:16 +0200255 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100256 }
257 break;
258
259 case 'h': /* --help */
260 cmd_data_help();
aPieceka83b8e02023-06-07 15:25:16 +0200261 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100262 default:
263 YLMSG_E("Unknown option.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200264 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100265 }
266 }
267
aPieceka83b8e02023-06-07 15:25:16 +0200268 *posv = &yo->argv[optind];
269 *posc = argc - optind;
270
271 return rc;
272}
273
274int
275cmd_data_dep(struct yl_opt *yo, int posc)
276{
277 if (yo->interactive && !posc) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100278 YLMSG_E("Missing the data file to process.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200279 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100280 }
281
aPieceka83b8e02023-06-07 15:25:16 +0200282 if (yo->data_merge) {
283 if (yo->data_type || (yo->data_parse_options & LYD_PARSE_ONLY)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100284 /* switch off the option, incompatible input data type */
aPiecek3d46fa92023-05-10 08:30:39 +0200285 YLMSG_W("The --merge option has effect only for 'data' and 'config' TYPEs\n");
aPieceka83b8e02023-06-07 15:25:16 +0200286 yo->data_merge = 0;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100287 } else {
288 /* postpone validation after the merge of all the input data */
aPieceka83b8e02023-06-07 15:25:16 +0200289 yo->data_parse_options |= LYD_PARSE_ONLY;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100290 }
aPieceka83b8e02023-06-07 15:25:16 +0200291 } else if (yo->data_xpath.count) {
292 yo->data_merge = 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100293 }
294
aPiecekbc39de12023-06-08 08:10:29 +0200295 if (yo->data_xpath.count && (yo->schema_out_format || yo->data_out_format)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100296 YLMSG_E("The --format option cannot be combined with --xpath option.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200297 if (yo->interactive) {
298 cmd_data_help_xpath();
299 }
300 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100301 }
aPieceka83b8e02023-06-07 15:25:16 +0200302 if (yo->data_xpath.count && (yo->data_print_options & LYD_PRINT_WD_MASK)) {
aPiecek72a24c92023-04-12 15:03:05 +0200303 YLMSG_E("The --default option cannot be combined with --xpath option.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200304 if (yo->interactive) {
305 cmd_data_help_xpath();
306 }
307 return 1;
aPiecek72a24c92023-04-12 15:03:05 +0200308 }
Radek Krejcie9f13b12020-11-09 17:42:04 +0100309
aPieceka83b8e02023-06-07 15:25:16 +0200310 if (yo->data_operational.path && !yo->data_type) {
aPiecekbc39de12023-06-08 08:10:29 +0200311 YLMSG_W("Operational datastore takes effect only with RPCs/Actions/Replies/Notification input data types.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200312 yo->data_operational.path = NULL;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100313 }
314
aPieceka83b8e02023-06-07 15:25:16 +0200315 if (yo->reply_rpc.path && (yo->data_type != LYD_TYPE_REPLY_NETCONF)) {
aPiecek079bcde2023-05-05 11:48:25 +0200316 YLMSG_W("Source RPC is needed only for NETCONF Reply input data type.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200317 yo->data_operational.path = NULL;
318 } else if (!yo->reply_rpc.path && (yo->data_type == LYD_TYPE_REPLY_NETCONF)) {
aPiecek079bcde2023-05-05 11:48:25 +0200319 YLMSG_E("Missing source RPC (-R) for NETCONF Reply input data type.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200320 return 1;
aPiecek079bcde2023-05-05 11:48:25 +0200321 }
322
aPieceka83b8e02023-06-07 15:25:16 +0200323 if (!yo->out && (yo->data_out_format == LYD_LYB)) {
aPieceka4723482023-05-11 14:31:02 +0200324 YLMSG_E("The LYB format requires the -o option specified.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200325 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100326 }
327
328 /* default output stream */
aPieceka83b8e02023-06-07 15:25:16 +0200329 if (!yo->out) {
330 if (ly_out_new_file(stdout, &yo->out)) {
Radek Krejcie9f13b12020-11-09 17:42:04 +0100331 YLMSG_E("Unable to set stdout as output.\n");
aPieceka83b8e02023-06-07 15:25:16 +0200332 return 1;
333 }
334 yo->out_stdout = 1;
335 }
336
337 /* process the operational and/or reply RPC content if any */
338 if (yo->data_operational.path) {
339 if (get_input(yo->data_operational.path, NULL, &yo->data_operational.format, &yo->data_operational.in)) {
340 return -1;
341 }
342 }
343 if (yo->reply_rpc.path) {
344 if (get_input(yo->reply_rpc.path, NULL, &yo->reply_rpc.format, &yo->reply_rpc.in)) {
345 return -1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100346 }
347 }
348
aPieceka83b8e02023-06-07 15:25:16 +0200349 return 0;
350}
351
352int
aPiecekcf9e7682023-06-19 14:03:50 +0200353cmd_data_store(struct ly_ctx **ctx, struct yl_opt *yo, const char *posv)
aPieceka83b8e02023-06-07 15:25:16 +0200354{
355 (void) ctx;
356 struct ly_in *in;
357 LYD_FORMAT format_data;
358
359 assert(posv);
360
361 format_data = yo->data_in_format;
362
363 /* process input data files provided as standalone command line arguments */
364 if (get_input(posv, NULL, &format_data, &in)) {
365 return 1;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100366 }
367
aPieceka83b8e02023-06-07 15:25:16 +0200368 if (!fill_cmdline_file(&yo->data_inputs, in, posv, format_data)) {
369 ly_in_free(in, 1);
370 return 1;
371 }
372
373 return 0;
374}
375
aPiecek618d1cc2023-06-15 08:31:27 +0200376/**
377 * @brief Evaluate xpath adn print result.
378 *
379 * @param[in] tree Data tree.
380 * @param[in] xpath Xpath to evaluate.
381 * @return 0 on success.
382 */
383static int
384evaluate_xpath(const struct lyd_node *tree, const char *xpath)
385{
386 struct ly_set *set = NULL;
387
388 if (lyd_find_xpath(tree, xpath, &set)) {
389 return -1;
390 }
391
392 /* print result */
393 printf("XPath \"%s\" evaluation result:\n", xpath);
394 if (!set->count) {
395 printf("\tEmpty\n");
396 } else {
397 for (uint32_t u = 0; u < set->count; ++u) {
398 struct lyd_node *node = (struct lyd_node *)set->objs[u];
399
400 printf(" %s \"%s\"", lys_nodetype2str(node->schema->nodetype), node->schema->name);
401 if (node->schema->nodetype & (LYS_LEAF | LYS_LEAFLIST)) {
402 printf(" (value: \"%s\")\n", lyd_get_value(node));
403 } else if (node->schema->nodetype == LYS_LIST) {
404 printf(" (");
405 for (struct lyd_node *key = ((struct lyd_node_inner *)node)->child; key && lysc_is_key(key->schema); key = key->next) {
406 printf("%s\"%s\": \"%s\";", (key != ((struct lyd_node_inner *)node)->child) ? " " : "",
407 key->schema->name, lyd_get_value(key));
408 }
409 printf(")\n");
410 } else {
411 printf("\n");
412 }
413 }
414 }
415
416 ly_set_free(set, NULL);
417 return 0;
418}
419
420/**
421 * @brief Checking that a parent data node exists in the datastore for the nested-notification and action.
422 *
423 * @param[in] op Operation to check.
424 * @param[in] oper_tree Data from datastore.
425 * @param[in] operational_f Operational datastore file information.
426 * @return LY_ERR value.
427 */
428static LY_ERR
429check_operation_parent(struct lyd_node *op, struct lyd_node *oper_tree, struct cmdline_file *operational_f)
430{
431 LY_ERR ret;
432 struct ly_set *set = NULL;
433 char *path = NULL;
434
435 if (!op || !lyd_parent(op)) {
436 /* The function is defined only for nested-notification and action. */
437 return LY_SUCCESS;
438 }
439
440 if (!operational_f || (operational_f && !operational_f->in)) {
441 YLMSG_E("The --operational parameter needed to validate operation \"%s\" is missing.\n", LYD_NAME(op));
442 ret = LY_EVALID;
443 goto cleanup;
444 }
445
446 path = lyd_path(lyd_parent(op), LYD_PATH_STD, NULL, 0);
447 if (!path) {
448 ret = LY_EMEM;
449 goto cleanup;
450 }
451
452 if (!oper_tree) {
453 YLMSG_W("Operational datastore is empty or contains unknown data.\n");
454 YLMSG_E("Operation \"%s\" parent \"%s\" not found in the operational data.\n", LYD_NAME(op), path);
455 ret = LY_EVALID;
456 goto cleanup;
457 }
458 if ((ret = lyd_find_xpath(oper_tree, path, &set))) {
459 goto cleanup;
460 }
461 if (!set->count) {
462 YLMSG_E("Operation \"%s\" parent \"%s\" not found in the operational data.\n", LYD_NAME(op), path);
463 ret = LY_EVALID;
464 goto cleanup;
465 }
466
467cleanup:
468 ly_set_free(set, NULL);
469 free(path);
470
471 return ret;
472}
473
474/**
475 * @brief Process the input data files - parse, validate and print according to provided options.
476 *
477 * @param[in] ctx libyang context with schema.
478 * @param[in] type The type of data in the input files.
479 * @param[in] merge Flag if the data should be merged before validation.
480 * @param[in] out_format Data format for printing.
481 * @param[in] out The output handler for printing.
482 * @param[in] parse_options Parser options.
483 * @param[in] validate_options Validation options.
484 * @param[in] print_options Printer options.
485 * @param[in] operational Optional operational datastore file information for the case of an extended validation of
486 * operation(s).
487 * @param[in] reply_rpc Source RPC operation file information for parsing NETCONF rpc-reply.
488 * @param[in] inputs Set of file informations of input data files.
489 * @param[in] xpaths The set of XPaths to be evaluated on the processed data tree, basic information about the resulting set
490 * is printed. Alternative to data printing.
491 * @return LY_ERR value.
492 */
493static LY_ERR
494process_data(struct ly_ctx *ctx, enum lyd_type type, uint8_t merge, LYD_FORMAT out_format,
495 struct ly_out *out, uint32_t parse_options, uint32_t validate_options, uint32_t print_options,
496 struct cmdline_file *operational, struct cmdline_file *reply_rpc, struct ly_set *inputs,
497 struct ly_set *xpaths)
498{
499 LY_ERR ret = LY_SUCCESS;
500 struct lyd_node *tree = NULL, *op = NULL, *envp = NULL, *merged_tree = NULL, *oper_tree = NULL;
501 const char *xpath;
502 struct ly_set *set = NULL;
503
504 /* additional operational datastore */
505 if (operational && operational->in) {
506 ret = lyd_parse_data(ctx, NULL, operational->in, operational->format, LYD_PARSE_ONLY, 0, &oper_tree);
507 if (ret) {
508 YLMSG_E("Failed to parse operational datastore file \"%s\".\n", operational->path);
509 goto cleanup;
510 }
511 }
512
513 for (uint32_t u = 0; u < inputs->count; ++u) {
514 struct cmdline_file *input_f = (struct cmdline_file *)inputs->objs[u];
515
516 switch (type) {
517 case LYD_TYPE_DATA_YANG:
518 ret = lyd_parse_data(ctx, NULL, input_f->in, input_f->format, parse_options, validate_options, &tree);
519 break;
520 case LYD_TYPE_RPC_YANG:
521 case LYD_TYPE_REPLY_YANG:
522 case LYD_TYPE_NOTIF_YANG:
523 ret = lyd_parse_op(ctx, NULL, input_f->in, input_f->format, type, &tree, &op);
524 break;
525 case LYD_TYPE_RPC_NETCONF:
526 case LYD_TYPE_NOTIF_NETCONF:
527 ret = lyd_parse_op(ctx, NULL, input_f->in, input_f->format, type, &envp, &op);
528
529 /* adjust pointers */
530 for (tree = op; lyd_parent(tree); tree = lyd_parent(tree)) {}
531 break;
532 case LYD_TYPE_REPLY_NETCONF:
533 /* parse source RPC operation */
534 assert(reply_rpc && reply_rpc->in);
535 ret = lyd_parse_op(ctx, NULL, reply_rpc->in, reply_rpc->format, LYD_TYPE_RPC_NETCONF, &envp, &op);
536 if (ret) {
537 YLMSG_E("Failed to parse source NETCONF RPC operation file \"%s\".\n", reply_rpc->path);
538 goto cleanup;
539 }
540
541 /* adjust pointers */
542 for (tree = op; lyd_parent(tree); tree = lyd_parent(tree)) {}
543
544 /* free input */
545 lyd_free_siblings(lyd_child(op));
546
547 /* we do not care */
548 lyd_free_all(envp);
549 envp = NULL;
550
551 ret = lyd_parse_op(ctx, op, input_f->in, input_f->format, type, &envp, NULL);
552 break;
553 default:
554 YLMSG_E("Internal error (%s:%d).\n", __FILE__, __LINE__);
555 goto cleanup;
556 }
557
558 if (ret) {
559 YLMSG_E("Failed to parse input data file \"%s\".\n", input_f->path);
560 goto cleanup;
561 }
562
563 if (merge) {
564 /* merge the data so far parsed for later validation and print */
565 if (!merged_tree) {
566 merged_tree = tree;
567 } else {
568 ret = lyd_merge_siblings(&merged_tree, tree, LYD_MERGE_DESTRUCT);
569 if (ret) {
570 YLMSG_E("Merging %s with previous data failed.\n", input_f->path);
571 goto cleanup;
572 }
573 }
574 tree = NULL;
575 } else if (out_format) {
576 /* print */
577 switch (type) {
578 case LYD_TYPE_DATA_YANG:
579 lyd_print_all(out, tree, out_format, print_options);
580 break;
581 case LYD_TYPE_RPC_YANG:
582 case LYD_TYPE_REPLY_YANG:
583 case LYD_TYPE_NOTIF_YANG:
584 case LYD_TYPE_RPC_NETCONF:
585 case LYD_TYPE_NOTIF_NETCONF:
586 lyd_print_tree(out, tree, out_format, print_options);
587 break;
588 case LYD_TYPE_REPLY_NETCONF:
589 /* just the output */
590 lyd_print_tree(out, lyd_child(tree), out_format, print_options);
591 break;
592 default:
593 assert(0);
594 }
595 } else {
596 /* validation of the RPC/Action/reply/Notification with the operational datastore, if any */
597 switch (type) {
598 case LYD_TYPE_DATA_YANG:
599 /* already validated */
600 break;
601 case LYD_TYPE_RPC_YANG:
602 case LYD_TYPE_RPC_NETCONF:
603 ret = lyd_validate_op(tree, oper_tree, LYD_TYPE_RPC_YANG, NULL);
604 break;
605 case LYD_TYPE_REPLY_YANG:
606 case LYD_TYPE_REPLY_NETCONF:
607 ret = lyd_validate_op(tree, oper_tree, LYD_TYPE_REPLY_YANG, NULL);
608 break;
609 case LYD_TYPE_NOTIF_YANG:
610 case LYD_TYPE_NOTIF_NETCONF:
611 ret = lyd_validate_op(tree, oper_tree, LYD_TYPE_NOTIF_YANG, NULL);
612 break;
613 default:
614 assert(0);
615 }
616 if (ret) {
617 if (operational->path) {
618 YLMSG_E("Failed to validate input data file \"%s\" with operational datastore \"%s\".\n",
619 input_f->path, operational->path);
620 } else {
621 YLMSG_E("Failed to validate input data file \"%s\".\n", input_f->path);
622 }
623 goto cleanup;
624 }
625
626 if ((ret = check_operation_parent(op, oper_tree, operational))) {
627 goto cleanup;
628 }
629 }
630
631 /* next iter */
632 lyd_free_all(tree);
633 tree = NULL;
634 lyd_free_all(envp);
635 envp = NULL;
636 }
637
638 if (merge) {
639 /* validate the merged result */
640 ret = lyd_validate_all(&merged_tree, ctx, validate_options, NULL);
641 if (ret) {
642 YLMSG_E("Merged data are not valid.\n");
643 goto cleanup;
644 }
645
646 if (out_format) {
647 /* and print it */
648 lyd_print_all(out, merged_tree, out_format, print_options);
649 }
650
651 for (uint32_t u = 0; xpaths && (u < xpaths->count); ++u) {
652 xpath = (const char *)xpaths->objs[u];
653 ly_set_free(set, NULL);
654 ret = lys_find_xpath(ctx, NULL, xpath, LYS_FIND_NO_MATCH_ERROR, &set);
655 if (ret || !set->count) {
656 ret = (ret == LY_SUCCESS) ? LY_EINVAL : ret;
657 YLMSG_E("The requested xpath failed.\n");
658 goto cleanup;
659 }
660 if (evaluate_xpath(merged_tree, xpath)) {
661 goto cleanup;
662 }
663 }
664 }
665
666cleanup:
667 lyd_free_all(tree);
668 lyd_free_all(envp);
669 lyd_free_all(merged_tree);
670 lyd_free_all(oper_tree);
671 ly_set_free(set, NULL);
672 return ret;
673}
674
aPieceka83b8e02023-06-07 15:25:16 +0200675int
aPiecekcf9e7682023-06-19 14:03:50 +0200676cmd_data_process(struct ly_ctx *ctx, struct yl_opt *yo)
aPieceka83b8e02023-06-07 15:25:16 +0200677{
678 /* parse, validate and print data */
679 if (process_data(ctx, yo->data_type, yo->data_merge, yo->data_out_format, yo->out, yo->data_parse_options,
680 yo->data_validate_options, yo->data_print_options, &yo->data_operational, &yo->reply_rpc,
681 &yo->data_inputs, &yo->data_xpath)) {
682 return 1;
683 }
684
685 return 0;
Radek Krejcie9f13b12020-11-09 17:42:04 +0100686}