blob: d2109b2e4cc576e437dc68897313061065c43cfa [file] [log] [blame]
Radek Krejcied5acc52019-04-25 15:57:04 +02001/**
2 * @file main_ni.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
4 * @brief libyang's yanglint tool - noninteractive code
5 *
6 * Copyright (c) 2015-2018 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
Radek Krejcied5acc52019-04-25 15:57:04 +020016
17#include <stdio.h>
18#include <stdlib.h>
19#include <getopt.h>
20#include <errno.h>
21#include <libgen.h>
22#include <sys/stat.h>
23#include <sys/times.h>
24#include <sys/types.h>
25#include <string.h>
26#include <unistd.h>
27
Radek Krejcied5acc52019-04-25 15:57:04 +020028#include "libyang.h"
29
Radek Krejci535ea9f2020-05-29 16:01:05 +020030#include "tools/config.h"
31
32#include "commands.h"
33
34
Radek Krejcied5acc52019-04-25 15:57:04 +020035volatile uint8_t verbose = 0;
36
37#if 0
38/* from commands.c */
39int print_list(FILE *out, struct ly_ctx *ctx, LYD_FORMAT outformat);
40#endif
41
42void
43help(int shortout)
44{
45 fprintf(stdout, "Usage:\n");
Radek Krejcid8c0f5e2019-11-17 12:18:34 +080046 fprintf(stdout, " yanglint [options] [-f { yang | yin | tree | tree-rfc | info}] <file>...\n");
Radek Krejcied5acc52019-04-25 15:57:04 +020047 fprintf(stdout, " Validates the YANG module in <file>, and all its dependencies.\n\n");
48 fprintf(stdout, " yanglint [options] [-f { xml | json }] <schema>... <file>...\n");
49 fprintf(stdout, " Validates the YANG modeled data in <file> according to the <schema>.\n\n");
50 fprintf(stdout, " yanglint\n");
51 fprintf(stdout, " Starts interactive mode with more features.\n\n");
52
53 if (shortout) {
54 return;
55 }
56 fprintf(stdout, "Options:\n"
57 " -h, --help Show this help message and exit.\n"
58 " -v, --version Show version number and exit.\n"
59 " -V, --verbose Show verbose messages, can be used multiple times to\n"
60 " increase verbosity.\n"
61#ifndef NDEBUG
62 " -G GROUPS, --debug=GROUPS\n"
63 " Enable printing of specific debugging message group\n"
64 " (nothing will be printed unless verbosity is set to debug):\n"
65 " <group>[,<group>]* (dict, yang, yin, xpath, diff)\n\n"
66#endif
67 " -p PATH, --path=PATH Search path for schema (YANG/YIN) modules. The option can be used multiple times.\n"
68 " Current working directory and path of the module being added is used implicitly.\n\n"
69 " -D, --disable-searchdir\n"
70 " Do not implicitly search in CWD for schema modules. If specified a second time,\n"
71 " do not even search the module directory (all modules must be explicitly specified).\n\n"
72 " -s, --strict Strict data parsing (do not skip unknown data),\n"
73 " has no effect for schemas.\n\n"
74 " -m, --merge Merge input data files into a single tree and validate at once,\n"
75 " has no effect for the auto, rpc, rpcreply and notif TYPEs.\n\n"
76 " -f FORMAT, --format=FORMAT\n"
77 " Convert to FORMAT. Supported formats: \n"
Radek Krejcid8c0f5e2019-11-17 12:18:34 +080078 " yang, yin, tree and info for schemas,\n"
Radek Krejcied5acc52019-04-25 15:57:04 +020079 " xml, json for data.\n"
80 " -a, --auto Modify the xml output by adding envelopes for autodetection.\n\n"
81 " -i, --allimplemented Make all the imported modules implemented.\n\n"
82 " -l, --list Print info about the loaded schemas in ietf-yang-library format,\n"
83 " the -f option applies here to specify data encoding.\n"
84 " (i - imported module, I - implemented module)\n\n"
85 " -o OUTFILE, --output=OUTFILE\n"
86 " Write the output to OUTFILE instead of stdout.\n\n"
87 " -F FEATURES, --features=FEATURES\n"
88 " Features to support, default all.\n"
89 " <modname>:[<feature>,]*\n\n"
90 " -d MODE, --default=MODE\n"
91 " Print data with default values, according to the MODE\n"
92 " (to print attributes, ietf-netconf-with-defaults model\n"
93 " must be loaded):\n"
94 " all - Add missing default nodes.\n"
95 " all-tagged - Add missing default nodes and mark all the default\n"
96 " nodes with the attribute.\n"
97 " trim - Remove all nodes with a default value.\n"
98 " implicit-tagged - Add missing nodes and mark them with the attribute.\n\n"
99 " -t TYPE, --type=TYPE\n"
100 " Specify data tree type in the input data file:\n"
101 " auto - Resolve data type (one of the following) automatically\n"
102 " (as pyang does) - applicable only on XML input data.\n"
103 " data - Complete datastore with status data (default type).\n"
104 " config - Configuration datastore (without status data).\n"
105 " get - Result of the NETCONF <get> operation.\n"
106 " getconfig - Result of the NETCONF <get-config> operation.\n"
107 " edit - Content of the NETCONF <edit-config> operation.\n"
108 " rpc - Content of the NETCONF <rpc> message, defined as YANG's rpc input statement.\n"
109 " rpcreply - Reply to the RPC. The input data <file>s are expected in pairs - each RPC reply\n"
110 " input data <file> must be followed by the origin RPC input data <file> for the reply.\n"
111 " The same rule of pairing applies also in case of 'auto' TYPE and input data file\n"
112 " containing RPC reply.\n"
113 " notif - Notification instance (content of the <notification> element without <eventTime>.\n\n"
114 " -O FILE, --operational=FILE\n"
115 " - Optional parameter for 'rpc', 'rpcreply' and 'notif' TYPEs, the FILE contains running\n"
116 " configuration datastore and state data (operational datastore) referenced from\n"
117 " the RPC/Notification. The same data apply to all input data <file>s. Note that\n"
118 " the file is validated as 'data' TYPE. Special value '!' can be used as FILE argument\n"
119 " to ignore the external references.\n\n"
120 " -y YANGLIB_PATH - Path to a yang-library data describing the initial context.\n\n"
121 "Tree output specific options:\n"
122 " --tree-help - Print help on tree symbols and exit.\n"
123 " --tree-print-groupings\n"
124 " Print top-level groupings in a separate section.\n"
125 " --tree-print-uses - Print uses nodes instead the resolved grouping nodes.\n"
126 " --tree-no-leafref-target\n"
127 " Do not print target nodes of leafrefs.\n"
128 " --tree-path=SCHEMA_PATH\n"
129 " Print only the specified subtree.\n"
130 " --tree-line-length=LINE_LENGTH\n"
131 " Wrap lines if longer than the specified length (it is not a strict limit, longer lines\n"
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800132 " can often appear).\n\n"
133 "Info output specific options:\n"
134 " -P INFOPATH, --info-path=INFOPATH\n"
135 " - Schema path with full module names used as node's prefixes, the path identify the root\n"
136 " node of the subtree to print information about.\n"
137 " --single-node - Print information about a single node instead of a subtree."
Radek Krejcied5acc52019-04-25 15:57:04 +0200138 "\n");
139}
140
141void
142tree_help(void)
143{
144 fprintf(stdout, "Each node is printed as:\n\n");
145 fprintf(stdout, "<status> <flags> <name> <opts> <type> <if-features>\n\n"
146 " <status> is one of:\n"
147 " + for current\n"
148 " x for deprecated\n"
149 " o for obsolete\n\n"
150 " <flags> is one of:\n"
151 " rw for configuration data\n"
152 " ro for status data\n"
153 " -x for RPCs\n"
154 " -n for Notification\n\n"
155 " <name> is the name of the node\n"
156 " (<name>) means that the node is a choice node\n"
157 " :(<name>) means that the node is a case node\n\n"
158 " if the node is augmented into the tree from another module,\n"
159 " it is printed with the module name as <module-name>:<name>.\n\n"
160 " <opts> is one of:\n"
161 " ? for an optional leaf or choice\n"
162 " ! for a presence container\n"
163 " * for a leaf-list or list\n"
164 " [<keys>] for a list's keys\n\n"
165 " <type> is the name of the type for leafs and leaf-lists\n"
166 " If there is a default value defined, it is printed within\n"
167 " angle brackets <default-value>.\n"
168 " If the type is a leafref, the type is printed as -> TARGET`\n\n"
169 " <if-features> is the list of features this node depends on,\n"
170 " printed within curly brackets and a question mark {...}?\n\n");
171}
172
173void
174version(void)
175{
176 fprintf(stdout, "yanglint %s\n", PROJECT_VERSION);
177}
178
179void
180libyang_verbclb(LY_LOG_LEVEL level, const char *msg, const char *path)
181{
182 char *levstr;
183
184 if (level <= verbose) {
185 switch(level) {
186 case LY_LLERR:
187 levstr = "err :";
188 break;
189 case LY_LLWRN:
190 levstr = "warn:";
191 break;
192 case LY_LLVRB:
193 levstr = "verb:";
194 break;
195 default:
196 levstr = "dbg :";
197 break;
198 }
199 if (path) {
200 fprintf(stderr, "%s %s (%s)\n", levstr, msg, path);
201 } else {
202 fprintf(stderr, "%s %s\n", levstr, msg);
203 }
204 }
205}
206
207/*
208 * return:
209 * 0 - error
210 * 1 - schema format
211 * 2 - data format
212 */
213static int
Radek Krejcie7b95092019-05-15 11:03:07 +0200214get_fileformat(const char *filename, LYS_INFORMAT *schema, LYD_FORMAT *data)
Radek Krejcied5acc52019-04-25 15:57:04 +0200215{
216 char *ptr;
217 LYS_INFORMAT informat_s;
Radek Krejcied5acc52019-04-25 15:57:04 +0200218 LYD_FORMAT informat_d;
Radek Krejcie7b95092019-05-15 11:03:07 +0200219
Radek Krejcied5acc52019-04-25 15:57:04 +0200220 /* get the file format */
221 if ((ptr = strrchr(filename, '.')) != NULL) {
222 ++ptr;
223 if (!strcmp(ptr, "yang")) {
224 informat_s = LYS_IN_YANG;
Radek Krejcied5acc52019-04-25 15:57:04 +0200225 informat_d = 0;
226 } else if (!strcmp(ptr, "yin")) {
227 informat_s = LYS_IN_YIN;
228 informat_d = 0;
229 } else if (!strcmp(ptr, "xml")) {
230 informat_s = 0;
231 informat_d = LYD_XML;
Radek Krejcie7b95092019-05-15 11:03:07 +0200232#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200233 } else if (!strcmp(ptr, "json")) {
234 informat_s = 0;
235 informat_d = LYD_JSON;
236#endif
237 } else {
238 fprintf(stderr, "yanglint error: input file in an unknown format \"%s\".\n", ptr);
239 return 0;
240 }
241 } else {
242 fprintf(stderr, "yanglint error: input file \"%s\" without file extension - unknown format.\n", filename);
243 return 0;
244 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200245
Radek Krejcied5acc52019-04-25 15:57:04 +0200246 if (data) {
247 (*data) = informat_d;
248 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200249
Radek Krejcied5acc52019-04-25 15:57:04 +0200250 if (schema) {
251 (*schema) = informat_s;
252 }
253
254 if (informat_s) {
255 return 1;
256 } else {
257 return 2;
258 }
259}
260
261int
262main_ni(int argc, char* argv[])
263{
264 int ret = EXIT_FAILURE;
Radek Krejcid8c0f5e2019-11-17 12:18:34 +0800265 int opt, opt_index = 0, i, featsize = 0;
Radek Krejcied5acc52019-04-25 15:57:04 +0200266 struct option options[] = {
267#if 0
268 {"auto", no_argument, NULL, 'a'},
269 {"default", required_argument, NULL, 'd'},
270#endif
271 {"format", required_argument, NULL, 'f'},
272 {"features", required_argument, NULL, 'F'},
273#if 0
274 {"tree-print-groupings", no_argument, NULL, 'g'},
275 {"tree-print-uses", no_argument, NULL, 'u'},
276 {"tree-no-leafref-target", no_argument, NULL, 'n'},
277 {"tree-path", required_argument, NULL, 'P'},
278 {"tree-line-length", required_argument, NULL, 'L'},
279#endif
280 {"help", no_argument, NULL, 'h'},
281#if 0
282 {"tree-help", no_argument, NULL, 'H'},
283#endif
284 {"allimplemented", no_argument, NULL, 'i'},
285 {"disable-cwd-search", no_argument, NULL, 'D'},
286 {"list", no_argument, NULL, 'l'},
287#if 0
288 {"merge", no_argument, NULL, 'm'},
289#endif
290 {"output", required_argument, NULL, 'o'},
291 {"path", required_argument, NULL, 'p'},
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800292 {"info-path", required_argument, NULL, 'P'},
Radek Krejcied5acc52019-04-25 15:57:04 +0200293#if 0
294 {"running", required_argument, NULL, 'r'},
295 {"operational", required_argument, NULL, 'O'},
Radek Krejcie7b95092019-05-15 11:03:07 +0200296#endif
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800297 {"single-node", no_argument, NULL, 'q'},
Radek Krejcied5acc52019-04-25 15:57:04 +0200298 {"strict", no_argument, NULL, 's'},
299 {"type", required_argument, NULL, 't'},
Radek Krejcied5acc52019-04-25 15:57:04 +0200300 {"version", no_argument, NULL, 'v'},
301 {"verbose", no_argument, NULL, 'V'},
302#ifndef NDEBUG
303 {"debug", required_argument, NULL, 'G'},
304#endif
305 {NULL, required_argument, NULL, 'y'},
306 {NULL, 0, NULL, 0}
307 };
Radek Krejci241f6b52020-05-21 18:13:49 +0200308 struct ly_out *out = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200309 struct ly_ctx *ctx = NULL;
310 const struct lys_module *mod;
311 LYS_OUTFORMAT outformat_s = 0;
312 LYS_INFORMAT informat_s;
Radek Krejcie7b95092019-05-15 11:03:07 +0200313 LYD_FORMAT informat_d, outformat_d = 0;
Radek Krejcied5acc52019-04-25 15:57:04 +0200314#if 0
Radek Krejcie7b95092019-05-15 11:03:07 +0200315 LYD_FORMAT ylformat = 0;
Radek Krejcied5acc52019-04-25 15:57:04 +0200316#endif
317 struct ly_set *searchpaths = NULL;
318 const char *outtarget_s = NULL;
319 char **feat = NULL, *ptr, *featlist, *dir;
320 struct stat st;
321 uint32_t u;
322 int options_ctx = LY_CTX_NOYANGLIBRARY, list = 0, outoptions_s = 0, outline_length_s = 0;
Radek Krejcie7b95092019-05-15 11:03:07 +0200323 int autodetection = 0, options_parser = 0, merge = 0;
324 const char *oper_file = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200325#if 0
Radek Krejcie7b95092019-05-15 11:03:07 +0200326 const char *envelope_s = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200327 char *ylpath = NULL;
Radek Krejcie7b95092019-05-15 11:03:07 +0200328 int options_dflt = 0, envelope = 0;
329 struct lyxml_elem *iter, *elem;
330 struct *subroot, *next, *node;
331#endif
Michal Vaskof03ed032020-03-04 13:31:44 +0100332 struct lyd_node *tree = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200333 struct dataitem {
334 const char *filename;
Radek Krejcied5acc52019-04-25 15:57:04 +0200335 struct lyd_node *tree;
336 struct dataitem *next;
337 LYD_FORMAT format;
Michal Vaskoa3881362020-01-21 15:57:35 +0100338 int flags;
Radek Krejcied5acc52019-04-25 15:57:04 +0200339 } *data = NULL, *data_item, *data_prev = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200340 struct ly_set *mods = NULL;
341 void *p;
342 int index = 0;
343
344 opterr = 0;
345#ifndef NDEBUG
Radek Krejci693262f2019-04-29 15:23:20 +0200346 while ((opt = getopt_long(argc, argv, "acd:f:F:gunP:L:hHiDlmo:p:r:O:st:vVG:y:", options, &opt_index)) != -1)
Radek Krejcied5acc52019-04-25 15:57:04 +0200347#else
Radek Krejci693262f2019-04-29 15:23:20 +0200348 while ((opt = getopt_long(argc, argv, "acd:f:F:gunP:L:hHiDlmo:p:r:O:st:vVy:", options, &opt_index)) != -1)
Radek Krejcied5acc52019-04-25 15:57:04 +0200349#endif
350 {
351 switch (opt) {
352#if 0
353 case 'a':
354 envelope = 1;
355 break;
356 case 'd':
357 if (!strcmp(optarg, "all")) {
358 options_dflt = (options_dflt & ~LYP_WD_MASK) | LYP_WD_ALL;
359 } else if (!strcmp(optarg, "all-tagged")) {
360 options_dflt = (options_dflt & ~LYP_WD_MASK) | LYP_WD_ALL_TAG;
361 } else if (!strcmp(optarg, "trim")) {
362 options_dflt = (options_dflt & ~LYP_WD_MASK) | LYP_WD_TRIM;
363 } else if (!strcmp(optarg, "implicit-tagged")) {
364 options_dflt = (options_dflt & ~LYP_WD_MASK) | LYP_WD_IMPL_TAG;
365 } else {
366 fprintf(stderr, "yanglint error: unknown default mode %s\n", optarg);
367 help(1);
368 goto cleanup;
369 }
370 break;
371#endif
372 case 'f':
373 if (!strcasecmp(optarg, "yang")) {
374 outformat_s = LYS_OUT_YANG;
Radek Krejcied5acc52019-04-25 15:57:04 +0200375 outformat_d = 0;
Radek Krejcie7b95092019-05-15 11:03:07 +0200376#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200377 } else if (!strcasecmp(optarg, "tree")) {
378 outformat_s = LYS_OUT_TREE;
379 outformat_d = 0;
380 } else if (!strcasecmp(optarg, "tree-rfc")) {
381 outformat_s = LYS_OUT_TREE;
382 outoptions_s |= LYS_OUTOPT_TREE_RFC;
383 outformat_d = 0;
FredGand944bdc2019-11-05 21:57:07 +0800384#endif
Radek Krejcied5acc52019-04-25 15:57:04 +0200385 } else if (!strcasecmp(optarg, "yin")) {
386 outformat_s = LYS_OUT_YIN;
387 outformat_d = 0;
Radek Krejcid8c0f5e2019-11-17 12:18:34 +0800388 } else if (!strcasecmp(optarg, "info")) {
389 outformat_s = LYS_OUT_YANG_COMPILED;
Radek Krejcied5acc52019-04-25 15:57:04 +0200390 outformat_d = 0;
391 } else if (!strcasecmp(optarg, "xml")) {
392 outformat_s = 0;
393 outformat_d = LYD_XML;
Radek Krejcie7b95092019-05-15 11:03:07 +0200394#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200395 } else if (!strcasecmp(optarg, "json")) {
396 outformat_s = 0;
397 outformat_d = LYD_JSON;
398#endif
399 } else {
400 fprintf(stderr, "yanglint error: unknown output format %s\n", optarg);
401 help(1);
402 goto cleanup;
403 }
404 break;
405 case 'F':
406 featsize++;
407 if (!feat) {
408 p = malloc(sizeof *feat);
409 } else {
410 p = realloc(feat, featsize * sizeof *feat);
411 }
412 if (!p) {
413 fprintf(stderr, "yanglint error: Memory allocation failed (%s:%d, %s)", __FILE__, __LINE__, strerror(errno));
414 goto cleanup;
415 }
416 feat = p;
417 feat[featsize - 1] = strdup(optarg);
418 ptr = strchr(feat[featsize - 1], ':');
419 if (!ptr) {
420 fprintf(stderr, "yanglint error: Invalid format of the features specification (%s)", optarg);
421 goto cleanup;
422 }
423 *ptr = '\0';
424
425 break;
426#if 0
427 case 'g':
428 outoptions_s |= LYS_OUTOPT_TREE_GROUPING;
429 break;
430 case 'u':
431 outoptions_s |= LYS_OUTOPT_TREE_USES;
432 break;
433 case 'n':
434 outoptions_s |= LYS_OUTOPT_TREE_NO_LEAFREF;
435 break;
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800436#endif
Radek Krejcied5acc52019-04-25 15:57:04 +0200437 case 'P':
438 outtarget_s = optarg;
439 break;
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800440#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200441 case 'L':
442 outline_length_s = atoi(optarg);
443 break;
444#endif
445 case 'h':
446 help(0);
447 ret = EXIT_SUCCESS;
448 goto cleanup;
449#if 0
450 case 'H':
451 tree_help();
452 ret = EXIT_SUCCESS;
453 goto cleanup;
454#endif
455 case 'i':
456 options_ctx |= LY_CTX_ALLIMPLEMENTED;
457 break;
458 case 'D':
459 if (options_ctx & LY_CTX_DISABLE_SEARCHDIRS) {
460 fprintf(stderr, "yanglint error: -D specified too many times.\n");
461 goto cleanup;
462 } else if (options_ctx & LY_CTX_DISABLE_SEARCHDIR_CWD) {
463 options_ctx &= ~LY_CTX_DISABLE_SEARCHDIR_CWD;
464 options_ctx |= LY_CTX_DISABLE_SEARCHDIRS;
465 } else {
466 options_ctx |= LY_CTX_DISABLE_SEARCHDIR_CWD;
467 }
468 break;
469 case 'l':
470 list = 1;
471 break;
472#if 0
473 case 'm':
474 merge = 1;
475 break;
476#endif
477 case 'o':
Radek Krejcia5bba312020-01-09 15:41:20 +0100478 if (out) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200479 if (ly_out_filepath(out, optarg) != NULL) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100480 fprintf(stderr, "yanglint error: unable open output file %s (%s)\n", optarg, strerror(errno));
481 goto cleanup;
482 }
483 } else {
Radek Krejci84ce7b12020-06-11 17:28:25 +0200484 if (ly_out_new_filepath(optarg, &out)) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100485 fprintf(stderr, "yanglint error: unable open output file %s (%s)\n", optarg, strerror(errno));
486 goto cleanup;
487 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200488 }
489 break;
490 case 'p':
491 if (stat(optarg, &st) == -1) {
492 fprintf(stderr, "yanglint error: Unable to use search path (%s) - %s.\n", optarg, strerror(errno));
493 goto cleanup;
494 }
495 if (!S_ISDIR(st.st_mode)) {
496 fprintf(stderr, "yanglint error: Provided search path is not a directory.\n");
497 goto cleanup;
498 }
499 if (!searchpaths) {
500 searchpaths = ly_set_new();
501 }
502 ly_set_add(searchpaths, optarg, 0);
503 break;
504#if 0
505 case 'r':
506 case 'O':
507 if (oper_file || (options_parser & LYD_OPT_NOEXTDEPS)) {
508 fprintf(stderr, "yanglint error: The operational datastore (-O) cannot be set multiple times.\n");
509 goto cleanup;
510 }
511 if (optarg[0] == '!') {
512 /* ignore extenral dependencies to the operational datastore */
513 options_parser |= LYD_OPT_NOEXTDEPS;
514 } else {
515 /* external file with the operational datastore */
516 oper_file = optarg;
517 }
518 break;
Radek Krejcie7b95092019-05-15 11:03:07 +0200519#endif
Radek Krejcied5acc52019-04-25 15:57:04 +0200520 case 's':
521 options_parser |= LYD_OPT_STRICT;
522 break;
523 case 't':
524 if (!strcmp(optarg, "auto")) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200525 autodetection = 1;
Michal Vaskob36053d2020-03-26 15:49:30 +0100526 /*} else if (!strcmp(optarg, "config")) {
Michal Vaskoa3881362020-01-21 15:57:35 +0100527 options_parser |= LYD_OPT_CONFIG;
Radek Krejcied5acc52019-04-25 15:57:04 +0200528 } else if (!strcmp(optarg, "get")) {
Michal Vaskoa3881362020-01-21 15:57:35 +0100529 options_parser |= LYD_OPT_GET;
Radek Krejcied5acc52019-04-25 15:57:04 +0200530 } else if (!strcmp(optarg, "getconfig")) {
Michal Vaskoa3881362020-01-21 15:57:35 +0100531 options_parser |= LYD_OPT_GETCONFIG;
Michal Vaskob36053d2020-03-26 15:49:30 +0100532 } else if (!strcmp(optarg, "edit")) {
Michal Vasko9f96a052020-03-10 09:41:45 +0100533 options_parser |= LYD_OPT_EDIT;*/
Radek Krejcied5acc52019-04-25 15:57:04 +0200534 } else if (!strcmp(optarg, "data")) {
Michal Vaskoa3881362020-01-21 15:57:35 +0100535 /* no options */
Radek Krejcied5acc52019-04-25 15:57:04 +0200536 } else {
537 fprintf(stderr, "yanglint error: unknown data tree type %s\n", optarg);
538 help(1);
539 goto cleanup;
540 }
541 break;
Radek Krejcied5acc52019-04-25 15:57:04 +0200542 case 'v':
543 version();
544 ret = EXIT_SUCCESS;
545 goto cleanup;
546 case 'V':
547 verbose++;
548 break;
549#ifndef NDEBUG
550 case 'G':
551 u = 0;
552 ptr = optarg;
553 while (ptr[0]) {
554 if (!strncmp(ptr, "dict", 4)) {
555 u |= LY_LDGDICT;
556 ptr += 4;
557 } else if (!strncmp(ptr, "yang", 4)) {
558 u |= LY_LDGYANG;
559 ptr += 4;
560 } else if (!strncmp(ptr, "yin", 3)) {
561 u |= LY_LDGYIN;
562 ptr += 3;
563 } else if (!strncmp(ptr, "xpath", 5)) {
564 u |= LY_LDGXPATH;
565 ptr += 5;
566 } else if (!strncmp(ptr, "diff", 4)) {
567 u |= LY_LDGDIFF;
568 ptr += 4;
569 }
570
571 if (ptr[0]) {
572 if (ptr[0] != ',') {
573 fprintf(stderr, "yanglint error: unknown debug group string \"%s\"\n", optarg);
574 goto cleanup;
575 }
576 ++ptr;
577 }
578 }
579 ly_verb_dbg(u);
580 break;
581#endif
582#if 0
583 case 'y':
584 ptr = strrchr(optarg, '.');
585 if (ptr) {
586 ptr++;
587 if (!strcmp(ptr, "xml")) {
588 ylformat = LYD_XML;
589 } else if (!strcmp(ptr, "json")) {
590 ylformat = LYD_JSON;
591 } else {
592 fprintf(stderr, "yanglint error: yang-library file in an unknown format \"%s\".\n", ptr);
593 goto cleanup;
594 }
595 } else {
596 fprintf(stderr, "yanglint error: yang-library file in an unknown format.\n");
597 goto cleanup;
598 }
599 ylpath = optarg;
600 break;
601#endif
602 default:
603 help(1);
604 if (optopt) {
605 fprintf(stderr, "yanglint error: invalid option: -%c\n", optopt);
606 } else {
607 fprintf(stderr, "yanglint error: invalid option: %s\n", argv[optind - 1]);
608 }
609 goto cleanup;
610 }
611 }
612
613 /* check options compatibility */
614 if (!list && optind >= argc) {
615 help(1);
616 fprintf(stderr, "yanglint error: missing <file> to process\n");
617 goto cleanup;
618 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200619 if (outformat_s && outformat_s != LYS_OUT_TREE && (optind + 1) < argc) {
620 /* we have multiple schemas to be printed as YIN or YANG */
621 fprintf(stderr, "yanglint error: too many schemas to convert and store.\n");
622 goto cleanup;
623 }
624 if (outoptions_s || outtarget_s || outline_length_s) {
625#if 0
626 if (outformat_d || (outformat_s && outformat_s != LYS_OUT_TREE)) {
627 /* we have --tree-print-grouping with other output format than tree */
628 fprintf(stderr,
629 "yanglint warning: --tree options take effect only in case of the tree output format.\n");
630 }
631 }
632 if (merge) {
633 if (autodetection || (options_parser & (LYD_OPT_RPC | LYD_OPT_RPCREPLY | LYD_OPT_NOTIF))) {
634 fprintf(stderr, "yanglint warning: merging not allowed, ignoring option -m.\n");
635 merge = 0;
636 } else {
637 /* first, files will be parsed as trusted to allow missing data, then the data trees will be merged
638 * and the result will be validated */
639 options_parser |= LYD_OPT_TRUSTED;
640 }
641#endif
642 }
643#if 0
644 if (!outformat_d && options_dflt) {
645 /* we have options for printing default nodes, but data output not specified */
646 fprintf(stderr, "yanglint warning: default mode is ignored when not printing data.\n");
647 }
648 if (outformat_s && (options_parser || autodetection)) {
649 /* we have options for printing data tree, but output is schema */
650 fprintf(stderr, "yanglint warning: data parser options are ignored when printing schema.\n");
651 }
652 if (oper_file && (!autodetection && !(options_parser & (LYD_OPT_RPC | LYD_OPT_RPCREPLY | LYD_OPT_NOTIF)))) {
653 fprintf(stderr, "yanglint warning: operational datastore applies only to RPCs or Notifications.\n");
654 /* ignore operational datastore file */
655 oper_file = NULL;
656 }
657 if ((options_parser & LYD_OPT_TYPEMASK) == LYD_OPT_DATA) {
658 /* add option to ignore ietf-yang-library data for implicit data type */
659 options_parser |= LYD_OPT_DATA_NO_YANGLIB;
660 }
Michal Vaskoa3881362020-01-21 15:57:35 +0100661#endif
Radek Krejcied5acc52019-04-25 15:57:04 +0200662
663 /* set callback for printing libyang messages */
664 ly_set_log_clb(libyang_verbclb, 1);
665#if 0
666 /* create libyang context */
667 if (ylpath) {
668 ctx = ly_ctx_new_ylpath(searchpaths ? (const char*)searchpaths->set.g[0] : NULL, ylpath, ylformat, options_ctx);
669 } else {
670#else
671 {
672#endif
673 ly_ctx_new(NULL, options_ctx, &ctx);
674 }
675 if (!ctx) {
676 goto cleanup;
677 }
678
679 /* set searchpaths */
680 if (searchpaths) {
681 for (u = 0; u < searchpaths->count; u++) {
682 ly_ctx_set_searchdir(ctx, (const char*)searchpaths->objs[u]);
683 }
684 index = u + 1;
685 }
686
687 /* derefered setting of verbosity in libyang after context initiation */
688 ly_verb(verbose);
689
690 mods = ly_set_new();
691
692
693 /* divide input files */
694 for (i = 0; i < argc - optind; i++) {
695 /* get the file format */
Radek Krejcie7b95092019-05-15 11:03:07 +0200696 if (!get_fileformat(argv[optind + i], &informat_s, &informat_d)) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200697 goto cleanup;
698 }
699
700 if (informat_s) {
701 /* load/validate schema */
702 if (verbose >= 2) {
703 fprintf(stdout, "Validating %s schema file.\n", argv[optind + i]);
704 }
705 dir = strdup(argv[optind + i]);
706 ly_ctx_set_searchdir(ctx, ptr = dirname(dir));
707 mod = lys_parse_path(ctx, argv[optind + i], informat_s);
708 ly_ctx_unset_searchdir(ctx, index);
709 free(dir);
710 if (!mod) {
711 goto cleanup;
712 }
713 ly_set_add(mods, (void *)mod, 0);
Radek Krejcied5acc52019-04-25 15:57:04 +0200714 } else {
715 if (autodetection && informat_d != LYD_XML) {
716 /* data file content autodetection is possible only for XML input */
717 fprintf(stderr, "yanglint error: data type autodetection is applicable only to XML files.\n");
718 goto cleanup;
719 }
720
721 /* remember data filename and its format */
722 if (!data) {
723 data = data_item = malloc(sizeof *data);
724 } else {
725 for (data_item = data; data_item->next; data_item = data_item->next);
726 data_item->next = malloc(sizeof *data_item);
727 data_item = data_item->next;
728 }
729 data_item->filename = argv[optind + i];
730 data_item->format = informat_d;
Michal Vaskoa3881362020-01-21 15:57:35 +0100731 data_item->flags = options_parser;
Radek Krejcied5acc52019-04-25 15:57:04 +0200732 data_item->tree = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200733 data_item->next = NULL;
Radek Krejcied5acc52019-04-25 15:57:04 +0200734 }
735 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200736 if (outformat_d && !data && !list) {
737 fprintf(stderr, "yanglint error: no input data file for the specified data output format.\n");
738 goto cleanup;
739 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200740
741 /* enable specified features, if not specified, all the module's features are enabled */
742 u = 4; /* skip internal libyang modules */
743 while ((mod = ly_ctx_get_module_iter(ctx, &u))) {
744 for (i = 0; i < featsize; i++) {
745 if (!strcmp(feat[i], mod->name)) {
746 /* parse features spec */
747 featlist = strdup(feat[i] + strlen(feat[i]) + 1);
748 ptr = NULL;
749 while((ptr = strtok(ptr ? NULL : featlist, ","))) {
750 if (verbose >= 2) {
751 fprintf(stdout, "Enabling feature %s in module %s.\n", ptr, mod->name);
752 }
753 if (lys_feature_enable(mod, ptr)) {
754 fprintf(stderr, "Feature %s not defined in module %s.\n", ptr, mod->name);
755 }
756 }
757 free(featlist);
758 break;
759 }
760 }
761 if (i == featsize) {
762 if (verbose >= 2) {
763 fprintf(stdout, "Enabling all features in module %s.\n", mod->name);
764 }
765 lys_feature_enable(mod, "*");
766 }
767 }
768
769 /* convert (print) to FORMAT */
770 if (outformat_s) {
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800771 if (outtarget_s) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100772 const struct lysc_node *node = lys_find_node(ctx, NULL, outtarget_s);
773 if (node) {
774 lys_print_node(out, node, outformat_s, outline_length_s, outoptions_s);
775 } else {
776 fprintf(stderr, "yanglint error: The requested schema node \"%s\" does not exists.\n", outtarget_s);
777 }
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800778 } else {
779 for (u = 0; u < mods->count; u++) {
780 if (u) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200781 ly_print(out, "\n");
Radek Krejcie1f6d5a2019-11-17 14:03:04 +0800782 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100783 lys_print(out, (struct lys_module *)mods->objs[u], outformat_s, outline_length_s, outoptions_s);
Radek Krejcied5acc52019-04-25 15:57:04 +0200784 }
785 }
Radek Krejcied5acc52019-04-25 15:57:04 +0200786 } else if (data) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200787
788 /* prepare operational datastore when specified for RPC/Notification */
789 if (oper_file) {
790 /* get the file format */
791 if (!get_fileformat(oper_file, NULL, &informat_d)) {
792 goto cleanup;
793 } else if (!informat_d) {
794 fprintf(stderr, "yanglint error: The operational data are expected in XML or JSON format.\n");
795 goto cleanup;
796 }
Michal Vaskof03ed032020-03-04 13:31:44 +0100797 tree = lyd_parse_path(ctx, oper_file, informat_d, LYD_OPT_PARSE_ONLY);
798 if (!tree) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200799 fprintf(stderr, "yanglint error: Failed to parse the operational datastore file for RPC/Notification validation.\n");
800 goto cleanup;
801 }
802 }
803
804 for (data_item = data, data_prev = NULL; data_item; data_prev = data_item, data_item = data_item->next) {
805 /* parse data file - via LYD_OPT_TRUSTED postpone validation when all data are loaded and merged */
Radek Krejcie7b95092019-05-15 11:03:07 +0200806#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200807 if (autodetection) {
808 /* erase option not covered by LYD_OPT_TYPEMASK, but used according to the type */
809 options_parser &= ~LYD_OPT_DATA_NO_YANGLIB;
810 /* automatically detect data type from the data top level */
811 data_item->xml = lyxml_parse_path(ctx, data_item->filename, 0);
812 if (!data_item->xml) {
813 fprintf(stderr, "yanglint error: parsing XML data for data type autodetection failed.\n");
814 goto cleanup;
815 }
816
817 /* NOTE: namespace is ignored to simplify usage of this feature */
818 if (!strcmp(data_item->xml->name, "data")) {
819 if (verbose >= 2) {
820 fprintf(stdout, "Parsing %s as complete datastore.\n", data_item->filename);
821 }
822 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_DATA_NO_YANGLIB;
823 data_item->type = LYD_OPT_DATA;
824 } else if (!strcmp(data_item->xml->name, "config")) {
825 if (verbose >= 2) {
826 fprintf(stdout, "Parsing %s as config data.\n", data_item->filename);
827 }
828 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_CONFIG;
829 data_item->type = LYD_OPT_CONFIG;
830 } else if (!strcmp(data_item->xml->name, "get-reply")) {
831 if (verbose >= 2) {
832 fprintf(stdout, "Parsing %s as <get> reply data.\n", data_item->filename);
833 }
834 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_GET;
835 data_item->type = LYD_OPT_GET;
836 } else if (!strcmp(data_item->xml->name, "get-config-reply")) {
837 if (verbose >= 2) {
838 fprintf(stdout, "Parsing %s as <get-config> reply data.\n", data_item->filename);
839 }
840 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_GETCONFIG;
841 data_item->type = LYD_OPT_GETCONFIG;
842 } else if (!strcmp(data_item->xml->name, "edit-config")) {
843 if (verbose >= 2) {
844 fprintf(stdout, "Parsing %s as <edit-config> data.\n", data_item->filename);
845 }
846 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_EDIT;
847 data_item->type = LYD_OPT_EDIT;
848 } else if (!strcmp(data_item->xml->name, "rpc")) {
849 if (verbose >= 2) {
850 fprintf(stdout, "Parsing %s as <rpc> data.\n", data_item->filename);
851 }
852 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_RPC;
853 data_item->type = LYD_OPT_RPC;
854 } else if (!strcmp(data_item->xml->name, "rpc-reply")) {
855 if (verbose >= 2) {
856 fprintf(stdout, "Parsing %s as <rpc-reply> data.\n", data_item->filename);
857 }
858
859 data_item->type = LYD_OPT_RPCREPLY;
860 if (!data_item->next || (data_prev && !data_prev->tree)) {
861 fprintf(stderr, "RPC reply (%s) must be paired with the original RPC, see help.\n", data_item->filename);
862 goto cleanup;
863 }
864
865 continue;
866 } else if (!strcmp(data_item->xml->name, "notification")) {
867 if (verbose >= 2) {
868 fprintf(stdout, "Parsing %s as <notification> data.\n", data_item->filename);
869 }
870 options_parser = (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_NOTIF;
871 data_item->type = LYD_OPT_NOTIF;
872
873 /* ignore eventTime element if present */
874 while (data_item->xml->child && !strcmp(data_item->xml->child->name, "eventTime")) {
875 lyxml_free(ctx, data_item->xml->child);
876 }
877 } else {
878 fprintf(stderr, "yanglint error: invalid top-level element \"%s\" for data type autodetection.\n",
879 data_item->xml->name);
880 goto cleanup;
881 }
882
883 data_item->tree = lyd_parse_xml(ctx, &data_item->xml->child, options_parser, oper);
884 if (data_prev && data_prev->type == LYD_OPT_RPCREPLY) {
885parse_reply:
886 /* check result of the RPC parsing, we are going to do another parsing in this step */
887 if (ly_errno) {
888 goto cleanup;
889 }
890
891 /* check that we really have RPC for the reply */
892 if (data_item->type != LYD_OPT_RPC) {
893 fprintf(stderr, "yanglint error: RPC reply (%s) must be paired with the original RPC, see help.\n", data_prev->filename);
894 goto cleanup;
895 }
896
897 if (data_prev->format == LYD_XML) {
898 /* ignore <ok> and <rpc-error> elements if present */
899 u = 0;
900 LY_TREE_FOR_SAFE(data_prev->xml->child, iter, elem) {
901 if (!strcmp(data_prev->xml->child->name, "ok")) {
902 if (u) {
903 /* rpc-error or ok already present */
904 u = 0x8; /* error flag */
905 } else {
906 u = 0x1 | 0x4; /* <ok> flag with lyxml_free() flag */
907 }
908 } else if (!strcmp(data_prev->xml->child->name, "rpc-error")) {
909 if (u && (u & 0x1)) {
910 /* ok already present, rpc-error can be present multiple times */
911 u = 0x8; /* error flag */
912 } else {
913 u = 0x2 | 0x4; /* <rpc-error> flag with lyxml_free() flag */
914 }
915 }
916
917 if (u == 0x8) {
918 fprintf(stderr, "yanglint error: Invalid RPC reply (%s) content.\n", data_prev->filename);
919 goto cleanup;
920 } else if (u & 0x4) {
921 lyxml_free(ctx, data_prev->xml->child);
922 u &= ~0x4; /* unset lyxml_free() flag */
923 }
924 }
925
926 /* finally, parse RPC reply from the previous step */
927 data_prev->tree = lyd_parse_xml(ctx, &data_prev->xml->child,
928 (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_RPCREPLY, data_item->tree, oper);
929 } else { /* LYD_JSON */
930 data_prev->tree = lyd_parse_path(ctx, data_prev->filename, data_item->format,
931 (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_RPCREPLY, data_item->tree, oper);
932 }
933 }
934 } else if ((options_parser & LYD_OPT_TYPEMASK) == LYD_OPT_RPCREPLY) {
935 if (data_prev && !data_prev->tree) {
936 /* now we should have RPC for the preceding RPC reply */
937 data_item->tree = lyd_parse_path(ctx, data_item->filename, data_item->format,
938 (options_parser & ~LYD_OPT_TYPEMASK) | LYD_OPT_RPC, oper);
939 data_item->type = LYD_OPT_RPC;
940 goto parse_reply;
941 } else {
942 /* now we have RPC reply which will be parsed in next step together with its RPC */
943 if (!data_item->next) {
944 fprintf(stderr, "yanglint error: RPC reply (%s) must be paired with the original RPC, see help.\n", data_item->filename);
945 goto cleanup;
946 }
947 if (data_item->format == LYD_XML) {
948 /* create rpc-reply container to unify handling with autodetection */
949 data_item->xml = calloc(1, sizeof *data_item->xml);
950 if (!data_item->xml) {
951 fprintf(stderr, "yanglint error: Memory allocation failed failed.\n");
952 goto cleanup;
953 }
954 data_item->xml->name = lydict_insert(ctx, "rpc-reply", 9);
955 data_item->xml->prev = data_item->xml;
956 data_item->xml->child = lyxml_parse_path(ctx, data_item->filename, LYXML_PARSE_MULTIROOT | LYXML_PARSE_NOMIXEDCONTENT);
957 if (data_item->xml->child) {
958 data_item->xml->child->parent = data_item->xml;
959 }
960 }
961 continue;
962 }
963 } else {
Radek Krejcie7b95092019-05-15 11:03:07 +0200964#else
965 {
966#endif
Michal Vaskoa3881362020-01-21 15:57:35 +0100967 data_item->tree = lyd_parse_path(ctx, data_item->filename, data_item->format, options_parser);
Radek Krejcied5acc52019-04-25 15:57:04 +0200968 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200969 if (ly_err_first(ctx)) {
Radek Krejcied5acc52019-04-25 15:57:04 +0200970 goto cleanup;
971 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200972#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200973 if (merge && data != data_item) {
974 if (!data->tree) {
975 data->tree = data_item->tree;
976 } else if (data_item->tree) {
977 /* merge results */
978 if (lyd_merge(data->tree, data_item->tree, LYD_OPT_DESTRUCT | LYD_OPT_EXPLICIT)) {
979 fprintf(stderr, "yanglint error: merging multiple data trees failed.\n");
980 goto cleanup;
981 }
982 }
983 data_item->tree = NULL;
984 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200985#endif
Radek Krejcied5acc52019-04-25 15:57:04 +0200986 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200987#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +0200988 if (merge) {
989 /* validate the merged data tree, do not trust the input, invalidate all the data first */
990 LY_TREE_FOR(data->tree, subroot) {
991 LY_TREE_DFS_BEGIN(subroot, next, node) {
992 node->validity = LYD_VAL_OK;
993 switch (node->schema->nodetype) {
994 case LYS_LEAFLIST:
995 case LYS_LEAF:
996 if (((struct lys_node_leaf *)node->schema)->type.base == LY_TYPE_LEAFREF) {
997 node->validity |= LYD_VAL_LEAFREF;
998 }
999 break;
1000 case LYS_LIST:
1001 node->validity |= LYD_VAL_UNIQUE;
1002 /* falls through */
1003 case LYS_CONTAINER:
1004 case LYS_NOTIF:
1005 case LYS_RPC:
1006 case LYS_ACTION:
1007 node->validity |= LYD_VAL_MAND;
1008 break;
1009 default:
1010 break;
1011 }
1012 LY_TREE_DFS_END(subroot, next, node)
1013 }
1014 }
1015 if (lyd_validate(&data->tree, options_parser & ~LYD_OPT_TRUSTED, ctx)) {
1016 goto cleanup;
1017 }
1018 }
Radek Krejcie7b95092019-05-15 11:03:07 +02001019#endif
Radek Krejcied5acc52019-04-25 15:57:04 +02001020 /* print only if data output format specified */
1021 if (outformat_d) {
1022 for (data_item = data; data_item; data_item = data_item->next) {
1023 if (!merge && verbose >= 2) {
1024 fprintf(stdout, "File %s:\n", data_item->filename);
1025 }
Radek Krejcie7b95092019-05-15 11:03:07 +02001026#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +02001027 if (outformat_d == LYD_XML && envelope) {
1028 switch (data_item->type) {
1029 case LYD_OPT_DATA:
1030 envelope_s = "data";
1031 break;
1032 case LYD_OPT_CONFIG:
1033 envelope_s = "config";
1034 break;
1035 case LYD_OPT_GET:
1036 envelope_s = "get-reply";
1037 break;
1038 case LYD_OPT_GETCONFIG:
1039 envelope_s = "get-config-reply";
1040 break;
1041 case LYD_OPT_EDIT:
1042 envelope_s = "edit-config";
1043 break;
1044 case LYD_OPT_RPC:
1045 envelope_s = "rpc";
1046 break;
1047 case LYD_OPT_RPCREPLY:
1048 envelope_s = "rpc-reply";
1049 break;
1050 case LYD_OPT_NOTIF:
1051 envelope_s = "notification";
1052 break;
1053 }
1054 fprintf(out, "<%s>\n", envelope_s);
1055 if (data_item->type == LYD_OPT_RPC && data_item->tree->schema->nodetype != LYS_RPC) {
1056 /* action */
1057 fprintf(out, "<action xmlns=\"urn:ietf:params:xml:ns:yang:1\">\n");
1058 }
1059 }
Radek Krejcie7b95092019-05-15 11:03:07 +02001060#endif
Radek Krejcia5bba312020-01-09 15:41:20 +01001061 lyd_print(out, data_item->tree, outformat_d, LYDP_WITHSIBLINGS | LYDP_FORMAT /* TODO defaults | options_dflt */);
Radek Krejcie7b95092019-05-15 11:03:07 +02001062#if 0
Radek Krejcied5acc52019-04-25 15:57:04 +02001063 if (envelope_s) {
1064 if (data_item->type == LYD_OPT_RPC && data_item->tree->schema->nodetype != LYS_RPC) {
1065 fprintf(out, "</action>\n");
1066 }
1067 fprintf(out, "</%s>\n", envelope_s);
1068 }
1069 if (merge) {
1070 /* stop after first item */
1071 break;
1072 }
Radek Krejcie7b95092019-05-15 11:03:07 +02001073#endif
Radek Krejcied5acc52019-04-25 15:57:04 +02001074 }
1075 }
Radek Krejcied5acc52019-04-25 15:57:04 +02001076 }
1077#if 0
1078 if (list) {
1079 print_list(out, ctx, outformat_d);
1080 }
1081#endif
1082
1083 ret = EXIT_SUCCESS;
1084
1085cleanup:
Radek Krejcied5acc52019-04-25 15:57:04 +02001086 ly_set_free(mods, NULL);
1087 ly_set_free(searchpaths, NULL);
1088 for (i = 0; i < featsize; i++) {
1089 free(feat[i]);
1090 }
1091 free(feat);
Radek Krejcied5acc52019-04-25 15:57:04 +02001092 for (; data; data = data_item) {
1093 data_item = data->next;
Radek Krejcie7b95092019-05-15 11:03:07 +02001094 lyd_free_all(data->tree);
Radek Krejcied5acc52019-04-25 15:57:04 +02001095 free(data);
1096 }
Radek Krejcied5acc52019-04-25 15:57:04 +02001097 ly_ctx_destroy(ctx, NULL);
1098
Radek Krejci241f6b52020-05-21 18:13:49 +02001099 ly_out_free(out, NULL, 1);
Radek Krejcied5acc52019-04-25 15:57:04 +02001100 return ret;
1101}