blob: dea32d37b08de9aa7d3a3607ed08167b7fccdc9a [file] [log] [blame]
Radek Krejci13a57b62019-07-19 13:04:09 +02001/**
Michal Vasko90932a92020-02-12 14:33:03 +01002 * @file printer_json.c
Radek Krejci13a57b62019-07-19 13:04:09 +02003 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko90932a92020-02-12 14:33:03 +01004 * @brief JSON printer for libyang data structure
Radek Krejci13a57b62019-07-19 13:04:09 +02005 *
Radek Krejci5536d282020-08-04 23:27:44 +02006 * Copyright (c) 2015 - 2020 CESNET, z.s.p.o.
Radek Krejci13a57b62019-07-19 13:04:09 +02007 *
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 Krejci5536d282020-08-04 23:27:44 +020015#include <assert.h>
Radek Krejci47fab892020-11-05 17:02:41 +010016#include <stdint.h>
Radek Krejci5536d282020-08-04 23:27:44 +020017#include <stdlib.h>
Radek Krejci5536d282020-08-04 23:27:44 +020018
Radek Krejci13a57b62019-07-19 13:04:09 +020019#include "common.h"
Radek Krejci47fab892020-11-05 17:02:41 +010020#include "context.h"
Radek Krejci5536d282020-08-04 23:27:44 +020021#include "log.h"
Radek Krejci47fab892020-11-05 17:02:41 +010022#include "out.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020023#include "out_internal.h"
Radek Krejci5536d282020-08-04 23:27:44 +020024#include "parser_data.h"
25#include "plugins_types.h"
26#include "printer_data.h"
27#include "printer_internal.h"
28#include "set.h"
29#include "tree.h"
30#include "tree_data.h"
Radek Krejci13a57b62019-07-19 13:04:09 +020031#include "tree_schema.h"
32
33/**
Radek Krejci5536d282020-08-04 23:27:44 +020034 * @brief JSON printer context.
35 */
36struct jsonpr_ctx {
Radek Krejci1deb5be2020-08-26 16:43:36 +020037 struct ly_out *out; /**< output specification */
38 uint16_t level; /**< current indentation level: 0 - no formatting, >= 1 indentation levels */
39 uint32_t options; /**< [Data printer flags](@ref dataprinterflags) */
40 const struct ly_ctx *ctx; /**< libyang context */
Radek Krejci5536d282020-08-04 23:27:44 +020041
Radek Krejci1deb5be2020-08-26 16:43:36 +020042 uint16_t level_printed; /* level where some data were already printed */
Radek Krejci5536d282020-08-04 23:27:44 +020043 struct ly_set open; /* currently open array(s) */
44 const struct lyd_node *print_sibling_metadata;
45};
46
47/**
48 * @brief Mark that something was already written in the current level,
49 * used to decide if a comma is expected between the items
50 */
51#define LEVEL_PRINTED ctx->level_printed = ctx->level
52
53#define PRINT_COMMA \
54 if (ctx->level_printed >= ctx->level) {\
Michal Vasko5233e962020-08-14 14:26:20 +020055 ly_print_(ctx->out, ",%s", (DO_FORMAT ? "\n" : ""));\
Radek Krejci5536d282020-08-04 23:27:44 +020056 }
57
58static LY_ERR json_print_node(struct jsonpr_ctx *ctx, const struct lyd_node *node);
59
60/**
Radek Krejci5536d282020-08-04 23:27:44 +020061 * Compare 2 nodes, despite it is regular data node or an opaq node, and
62 * decide if they corresponds to the same schema node.
63 *
64 * TODO: rewrite lyd_compare_single and use it instead of this
65 *
66 * @return 1 - matching nodes, 0 - non-matching nodes
67 */
68static int
69matching_node(const struct lyd_node *node1, const struct lyd_node *node2)
70{
71 assert(node1 || node2);
72
73 if (!node1 || !node2) {
74 return 0;
75 } else if (node1->schema != node2->schema) {
76 return 0;
77 }
78 if (!node1->schema) {
79 /* compare node names */
Michal Vasko22df3f02020-08-24 13:29:22 +020080 struct lyd_node_opaq *onode1 = (struct lyd_node_opaq *)node1;
81 struct lyd_node_opaq *onode2 = (struct lyd_node_opaq *)node2;
Michal Vaskoad92b672020-11-12 13:11:31 +010082 if ((onode1->name.name != onode2->name.name) || (onode1->name.prefix != onode2->name.prefix)) {
Radek Krejci5536d282020-08-04 23:27:44 +020083 return 0;
84 }
85 }
86
87 return 1;
88}
89
90/**
91 * @brief Open the JSON array ('[') for the specified @p node
92 *
93 * @param[in] ctx JSON printer context.
94 * @param[in] node First node of the array.
Michal Vaskob0099a92020-08-31 14:55:23 +020095 * @return LY_ERR value.
Radek Krejci5536d282020-08-04 23:27:44 +020096 */
Michal Vaskob0099a92020-08-31 14:55:23 +020097static LY_ERR
Radek Krejci5536d282020-08-04 23:27:44 +020098json_print_array_open(struct jsonpr_ctx *ctx, const struct lyd_node *node)
99{
Christian Hoppsbe51c942021-04-02 16:29:51 -0400100 ly_print_(ctx->out, "[%s", DO_FORMAT ? "\n" : "");
Michal Vaskob0099a92020-08-31 14:55:23 +0200101 LY_CHECK_RET(ly_set_add(&ctx->open, (void *)node, 0, NULL));
Radek Krejci5536d282020-08-04 23:27:44 +0200102 LEVEL_INC;
Michal Vaskob0099a92020-08-31 14:55:23 +0200103
104 return LY_SUCCESS;
Radek Krejci5536d282020-08-04 23:27:44 +0200105}
106
107/**
108 * @brief Get know if the array for the provided @p node is currently open.
109 *
110 * @param[in] ctx JSON printer context.
111 * @param[in] node Data node to check.
112 * @return 1 in case the printer is currently in the array belonging to the provided @p node.
113 * @return 0 in case the provided @p node is not connected with the currently open array (or there is no open array).
114 */
115static int
116is_open_array(struct jsonpr_ctx *ctx, const struct lyd_node *node)
117{
Michal Vasko22df3f02020-08-24 13:29:22 +0200118 if (ctx->open.count && matching_node(node, (const struct lyd_node *)ctx->open.objs[ctx->open.count - 1])) {
Radek Krejci5536d282020-08-04 23:27:44 +0200119 return 1;
120 } else {
121 return 0;
122 }
123}
124
125/**
126 * @brief Close the most inner JSON array.
127 *
128 * @param[in] ctx JSON printer context.
129 */
130static void
131json_print_array_close(struct jsonpr_ctx *ctx)
132{
Radek Krejci5536d282020-08-04 23:27:44 +0200133 LEVEL_DEC;
134 ly_set_rm_index(&ctx->open, ctx->open.count - 1, NULL);
Christian Hoppsbe51c942021-04-02 16:29:51 -0400135 ly_print_(ctx->out, "%s%*s]", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200136}
137
138/**
139 * @brief Get the node's module name to use as the @p node prefix in JSON.
Radek Krejci31bc3f52021-04-26 11:09:58 +0200140 *
Radek Krejci5536d282020-08-04 23:27:44 +0200141 * @param[in] node Node to process.
142 * @return The name of the module where the @p node belongs, it can be NULL in case the module name
143 * cannot be determined (source format is XML and the refered namespace is unknown/not implemented in the current context).
144 */
145static const char *
146node_prefix(const struct lyd_node *node)
147{
148 if (node->schema) {
149 return node->schema->module->name;
150 } else {
Michal Vasko22df3f02020-08-24 13:29:22 +0200151 struct lyd_node_opaq *onode = (struct lyd_node_opaq *)node;
Radek Krejci5536d282020-08-04 23:27:44 +0200152 const struct lys_module *mod;
153
154 switch (onode->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200155 case LY_VALUE_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +0100156 return onode->name.module_name;
Radek Krejci8df109d2021-04-23 12:19:08 +0200157 case LY_VALUE_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +0100158 mod = ly_ctx_get_module_implemented_ns(onode->ctx, onode->name.module_ns);
Radek Krejci5536d282020-08-04 23:27:44 +0200159 if (!mod) {
160 return NULL;
161 }
162 return mod->name;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100163 default:
Radek Krejci5536d282020-08-04 23:27:44 +0200164 /* cannot be created */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200165 LOGINT(LYD_CTX(node));
Radek Krejci5536d282020-08-04 23:27:44 +0200166 }
167 }
168
169 return NULL;
170}
171
172/**
173 * @brief Compare 2 nodes if the belongs to the same module (if they come from the same namespace)
174 *
175 * Accepts both regulard a well as opaq nodes.
176 *
177 * @param[in] node1 The first node to compare.
178 * @param[in] node2 The second node to compare.
179 * @return 0 in case the nodes' modules are the same
180 * @return 1 in case the nodes belongs to different modules
181 */
182int
183json_nscmp(const struct lyd_node *node1, const struct lyd_node *node2)
184{
185 assert(node1 || node2);
186
187 if (!node1 || !node2) {
188 return 1;
189 } else if (node1->schema && node2->schema) {
190 if (node1->schema->module == node2->schema->module) {
191 /* belongs to the same module */
192 return 0;
193 } else {
194 /* different modules */
195 return 1;
196 }
197 } else {
198 const char *pref1 = node_prefix(node1);
199 const char *pref2 = node_prefix(node2);
Michal Vasko69730152020-10-09 16:30:07 +0200200 if ((pref1 && pref2) && (pref1 == pref2)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200201 return 0;
202 } else {
203 return 1;
204 }
205 }
206}
207
208/**
209 * @brief Print the @p text as JSON string - encode special characters and add quotation around the string.
210 *
211 * @param[in] out The output handler.
212 * @param[in] text The string to print.
Michal Vasko5233e962020-08-14 14:26:20 +0200213 * @return LY_ERR value.
Radek Krejci5536d282020-08-04 23:27:44 +0200214 */
Michal Vasko5233e962020-08-14 14:26:20 +0200215static LY_ERR
Radek Krejci5536d282020-08-04 23:27:44 +0200216json_print_string(struct ly_out *out, const char *text)
217{
Radek Krejci1deb5be2020-08-26 16:43:36 +0200218 uint64_t i, n;
Radek Krejci5536d282020-08-04 23:27:44 +0200219
220 if (!text) {
Michal Vasko5233e962020-08-14 14:26:20 +0200221 return LY_SUCCESS;
Radek Krejci5536d282020-08-04 23:27:44 +0200222 }
223
Michal Vasko5233e962020-08-14 14:26:20 +0200224 ly_write_(out, "\"", 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200225 for (i = n = 0; text[i]; i++) {
226 const unsigned char ascii = text[i];
227 if (ascii < 0x20) {
228 /* control character */
Michal Vasko5233e962020-08-14 14:26:20 +0200229 ly_print_(out, "\\u%.4X", ascii);
Radek Krejci5536d282020-08-04 23:27:44 +0200230 } else {
231 switch (ascii) {
232 case '"':
Michal Vasko5233e962020-08-14 14:26:20 +0200233 ly_print_(out, "\\\"");
Radek Krejci5536d282020-08-04 23:27:44 +0200234 break;
235 case '\\':
Michal Vasko5233e962020-08-14 14:26:20 +0200236 ly_print_(out, "\\\\");
Radek Krejci5536d282020-08-04 23:27:44 +0200237 break;
238 default:
Michal Vasko5233e962020-08-14 14:26:20 +0200239 ly_write_(out, &text[i], 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200240 n++;
241 }
242 }
243 }
Michal Vasko5233e962020-08-14 14:26:20 +0200244 ly_write_(out, "\"", 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200245
Michal Vasko5233e962020-08-14 14:26:20 +0200246 return LY_SUCCESS;
Radek Krejci5536d282020-08-04 23:27:44 +0200247}
248
249/**
250 * @brief Print JSON object's member name, ending by ':'. It resolves if the prefix is supposed to be printed.
251 *
252 * @param[in] ctx JSON printer context.
253 * @param[in] node The data node being printed.
254 * @param[in] is_attr Flag if the metadata sign (@) is supposed to be added before the identifier.
255 * @return LY_ERR value.
256 */
257static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200258json_print_member(struct jsonpr_ctx *ctx, const struct lyd_node *node, ly_bool is_attr)
Radek Krejci5536d282020-08-04 23:27:44 +0200259{
260 PRINT_COMMA;
Michal Vasko69730152020-10-09 16:30:07 +0200261 if ((LEVEL == 1) || json_nscmp(node, (const struct lyd_node *)node->parent)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200262 /* print "namespace" */
Michal Vasko5233e962020-08-14 14:26:20 +0200263 ly_print_(ctx->out, "%*s\"%s%s:%s\":%s", INDENT, is_attr ? "@" : "",
Michal Vasko69730152020-10-09 16:30:07 +0200264 node_prefix(node), node->schema->name, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200265 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200266 ly_print_(ctx->out, "%*s\"%s%s\":%s", INDENT, is_attr ? "@" : "",
Michal Vasko69730152020-10-09 16:30:07 +0200267 node->schema->name, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200268 }
269
270 return LY_SUCCESS;
271}
272
273/**
274 * @brief More generic alternative to json_print_member() to print some special cases of the member names.
275 *
276 * @param[in] ctx JSON printer context.
277 * @param[in] parent Parent node to compare modules deciding if the prefix is printed.
278 * @param[in] format Format to decide how to process the @p prefix.
Michal Vaskoad92b672020-11-12 13:11:31 +0100279 * @param[in] name Name structure to provide name and prefix to print. If NULL, only "" name is printed.
Radek Krejci5536d282020-08-04 23:27:44 +0200280 * @param[in] is_attr Flag if the metadata sign (@) is supposed to be added before the identifier.
281 * @return LY_ERR value.
282 */
283static LY_ERR
Radek Krejci8df109d2021-04-23 12:19:08 +0200284json_print_member2(struct jsonpr_ctx *ctx, const struct lyd_node *parent, LY_VALUE_FORMAT format,
Michal Vaskoad92b672020-11-12 13:11:31 +0100285 const struct ly_opaq_name *name, ly_bool is_attr)
Radek Krejci5536d282020-08-04 23:27:44 +0200286{
Michal Vaskoad92b672020-11-12 13:11:31 +0100287 const char *module_name = NULL, *name_str;
Radek Krejci5536d282020-08-04 23:27:44 +0200288
289 PRINT_COMMA;
290
291 /* determine prefix string */
Michal Vaskoad92b672020-11-12 13:11:31 +0100292 if (name) {
Radek Krejci5536d282020-08-04 23:27:44 +0200293 const struct lys_module *mod;
294
295 switch (format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200296 case LY_VALUE_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +0100297 module_name = name->module_name;
Radek Krejci5536d282020-08-04 23:27:44 +0200298 break;
Radek Krejci8df109d2021-04-23 12:19:08 +0200299 case LY_VALUE_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +0100300 mod = ly_ctx_get_module_implemented_ns(ctx->ctx, name->module_ns);
Radek Krejci5536d282020-08-04 23:27:44 +0200301 if (mod) {
302 module_name = mod->name;
303 }
304 break;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100305 default:
Radek Krejci5536d282020-08-04 23:27:44 +0200306 /* cannot be created */
307 LOGINT_RET(ctx->ctx);
308 }
Michal Vaskoad92b672020-11-12 13:11:31 +0100309
310 name_str = name->name;
311 } else {
312 name_str = "";
Radek Krejci5536d282020-08-04 23:27:44 +0200313 }
314
315 /* print the member */
Michal Vasko69730152020-10-09 16:30:07 +0200316 if (module_name && (!parent || (node_prefix(parent) != module_name))) {
Michal Vaskoad92b672020-11-12 13:11:31 +0100317 ly_print_(ctx->out, "%*s\"%s%s:%s\":%s", INDENT, is_attr ? "@" : "", module_name, name_str, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200318 } else {
Michal Vaskoad92b672020-11-12 13:11:31 +0100319 ly_print_(ctx->out, "%*s\"%s%s\":%s", INDENT, is_attr ? "@" : "", name_str, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200320 }
321
322 return LY_SUCCESS;
323}
324
325/**
326 * @brief Print data value.
327 *
328 * @param[in] ctx JSON printer context.
329 * @param[in] val Data value to be printed.
330 * @return LY_ERR value.
331 */
332static LY_ERR
333json_print_value(struct jsonpr_ctx *ctx, const struct lyd_value *val)
334{
aPiecek0f6bf3e2021-08-25 15:47:49 +0200335 ly_bool dynamic;
Radek Krejci224d4b42021-04-23 13:54:59 +0200336 const char *value = val->realtype->plugin->print(ctx->ctx, val, LY_VALUE_JSON, NULL, &dynamic, NULL);
Radek Krejci5536d282020-08-04 23:27:44 +0200337
338 /* leafref is not supported */
339 switch (val->realtype->basetype) {
340 case LY_TYPE_BINARY:
341 case LY_TYPE_STRING:
342 case LY_TYPE_BITS:
343 case LY_TYPE_ENUM:
344 case LY_TYPE_INST:
345 case LY_TYPE_INT64:
346 case LY_TYPE_UINT64:
347 case LY_TYPE_DEC64:
348 case LY_TYPE_IDENT:
Michal Vaskoc5b59af2020-11-03 17:13:41 +0100349 case LY_TYPE_UNION:
Radek Krejci5536d282020-08-04 23:27:44 +0200350 json_print_string(ctx->out, value);
351 break;
352
353 case LY_TYPE_INT8:
354 case LY_TYPE_INT16:
355 case LY_TYPE_INT32:
356 case LY_TYPE_UINT8:
357 case LY_TYPE_UINT16:
358 case LY_TYPE_UINT32:
359 case LY_TYPE_BOOL:
Michal Vasko5233e962020-08-14 14:26:20 +0200360 ly_print_(ctx->out, "%s", value[0] ? value : "null");
Radek Krejci5536d282020-08-04 23:27:44 +0200361 break;
362
363 case LY_TYPE_EMPTY:
Michal Vasko5233e962020-08-14 14:26:20 +0200364 ly_print_(ctx->out, "[null]");
Radek Krejci5536d282020-08-04 23:27:44 +0200365 break;
366
367 default:
368 /* error */
369 LOGINT_RET(ctx->ctx);
370 }
371
372 if (dynamic) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200373 free((char *)value);
Radek Krejci5536d282020-08-04 23:27:44 +0200374 }
375
376 return LY_SUCCESS;
377}
378
379/**
380 * @brief Print all the attributes of the opaq node.
381 *
382 * @param[in] ctx JSON printer context.
383 * @param[in] node Opaq node where the attributes are placed.
384 * @param[in] wdmod With-defaults module to mark that default attribute is supposed to be printed.
385 * @return LY_ERR value.
386 */
387static LY_ERR
388json_print_attribute(struct jsonpr_ctx *ctx, const struct lyd_node_opaq *node, const struct lys_module *wdmod)
389{
390 struct lyd_attr *attr;
391
392 if (wdmod) {
Michal Vasko5233e962020-08-14 14:26:20 +0200393 ly_print_(ctx->out, "%*s\"%s:default\":\"true\"", INDENT, wdmod->name);
Radek Krejci5536d282020-08-04 23:27:44 +0200394 LEVEL_PRINTED;
395 }
396
397 for (attr = node->attr; attr; attr = attr->next) {
398 PRINT_COMMA;
Michal Vasko9e685082021-01-29 14:49:09 +0100399 json_print_member2(ctx, &node->node, attr->format, &attr->name, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200400
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200401 if (attr->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) {
Michal Vasko5233e962020-08-14 14:26:20 +0200402 ly_print_(ctx->out, "%s", attr->value[0] ? attr->value : "null");
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200403 } else if (attr->hints & LYD_VALHINT_EMPTY) {
Michal Vasko5233e962020-08-14 14:26:20 +0200404 ly_print_(ctx->out, "[null]");
Radek Krejci5536d282020-08-04 23:27:44 +0200405 } else {
406 json_print_string(ctx->out, attr->value);
407 }
408 LEVEL_PRINTED;
409 }
410
411 return LY_SUCCESS;
412}
413
414/**
415 * @brief Print all the metadata of the node.
416 *
417 * @param[in] ctx JSON printer context.
418 * @param[in] node Node where the metadata are placed.
419 * @param[in] wdmod With-defaults module to mark that default attribute is supposed to be printed.
420 * @return LY_ERR value.
421 */
422static LY_ERR
423json_print_metadata(struct jsonpr_ctx *ctx, const struct lyd_node *node, const struct lys_module *wdmod)
424{
425 struct lyd_meta *meta;
426
427 if (wdmod) {
Michal Vasko5233e962020-08-14 14:26:20 +0200428 ly_print_(ctx->out, "%*s\"%s:default\":\"true\"", INDENT, wdmod->name);
Radek Krejci5536d282020-08-04 23:27:44 +0200429 LEVEL_PRINTED;
430 }
431
432 for (meta = node->meta; meta; meta = meta->next) {
433 PRINT_COMMA;
Michal Vasko5233e962020-08-14 14:26:20 +0200434 ly_print_(ctx->out, "%*s\"%s:%s\":%s", INDENT, meta->annotation->module->name, meta->name, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200435 LY_CHECK_RET(json_print_value(ctx, &meta->value));
436 LEVEL_PRINTED;
437 }
438
439 return LY_SUCCESS;
440}
441
442/**
443 * @brief Print attributes/metadata of the given @p node. Accepts both regular as well as opaq nodes.
444 *
445 * @param[in] ctx JSON printer context.
446 * @param[in] node Data node where the attributes/metadata are placed.
Radek Krejci857189e2020-09-01 13:26:36 +0200447 * @param[in] inner Flag if the @p node is an inner node in the tree.
Radek Krejci5536d282020-08-04 23:27:44 +0200448 * @return LY_ERR value.
449 */
450static LY_ERR
Radek Krejci857189e2020-09-01 13:26:36 +0200451json_print_attributes(struct jsonpr_ctx *ctx, const struct lyd_node *node, ly_bool inner)
Radek Krejci5536d282020-08-04 23:27:44 +0200452{
453 const struct lys_module *wdmod = NULL;
454
455 if ((node->flags & LYD_DEFAULT) && (ctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG))) {
456 /* we have implicit OR explicit default node */
457 /* get with-defaults module */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200458 wdmod = ly_ctx_get_module_implemented(LYD_CTX(node), "ietf-netconf-with-defaults");
Radek Krejci5536d282020-08-04 23:27:44 +0200459 }
460
461 if (node->schema && node->meta) {
462 if (inner) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200463 LY_CHECK_RET(json_print_member2(ctx, NULL, LY_VALUE_JSON, NULL, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200464 } else {
465 LY_CHECK_RET(json_print_member(ctx, node, 1));
466 }
Michal Vasko5233e962020-08-14 14:26:20 +0200467 ly_print_(ctx->out, "{%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200468 LEVEL_INC;
469 LY_CHECK_RET(json_print_metadata(ctx, node, wdmod));
470 LEVEL_DEC;
Michal Vasko5233e962020-08-14 14:26:20 +0200471 ly_print_(ctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200472 LEVEL_PRINTED;
Michal Vasko22df3f02020-08-24 13:29:22 +0200473 } else if (!node->schema && ((struct lyd_node_opaq *)node)->attr) {
Radek Krejci5536d282020-08-04 23:27:44 +0200474 if (inner) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200475 LY_CHECK_RET(json_print_member2(ctx, NULL, LY_VALUE_JSON, NULL, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200476 } else {
Michal Vasko22df3f02020-08-24 13:29:22 +0200477 LY_CHECK_RET(json_print_member2(ctx, node, ((struct lyd_node_opaq *)node)->format,
Michal Vaskoad92b672020-11-12 13:11:31 +0100478 &((struct lyd_node_opaq *)node)->name, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200479 }
Michal Vasko5233e962020-08-14 14:26:20 +0200480 ly_print_(ctx->out, "{%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200481 LEVEL_INC;
Michal Vasko22df3f02020-08-24 13:29:22 +0200482 LY_CHECK_RET(json_print_attribute(ctx, (struct lyd_node_opaq *)node, wdmod));
Radek Krejci5536d282020-08-04 23:27:44 +0200483 LEVEL_DEC;
Michal Vasko5233e962020-08-14 14:26:20 +0200484 ly_print_(ctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200485 LEVEL_PRINTED;
486 }
487
488 return LY_SUCCESS;
489}
490
491/**
492 * @brief Print leaf data node including its metadata.
493 *
494 * @param[in] ctx JSON printer context.
495 * @param[in] node Data node to print.
496 * @return LY_ERR value.
497 */
498static LY_ERR
499json_print_leaf(struct jsonpr_ctx *ctx, const struct lyd_node *node)
500{
501 LY_CHECK_RET(json_print_member(ctx, node, 0));
Michal Vasko22df3f02020-08-24 13:29:22 +0200502 LY_CHECK_RET(json_print_value(ctx, &((const struct lyd_node_term *)node)->value));
Radek Krejci5536d282020-08-04 23:27:44 +0200503 LEVEL_PRINTED;
504
505 /* print attributes as sibling */
506 json_print_attributes(ctx, node, 0);
507
508 return LY_SUCCESS;
509}
510
511/**
512 * @brief Print anydata data node including its metadata.
513 *
514 * @param[in] ctx JSON printer context.
515 * @param[in] any Anydata node to print.
516 * @return LY_ERR value.
517 */
518static LY_ERR
519json_print_anydata(struct jsonpr_ctx *ctx, struct lyd_node_any *any)
520{
521 LY_ERR ret = LY_SUCCESS;
522 struct lyd_node *iter;
Radek Krejci1deb5be2020-08-26 16:43:36 +0200523 uint32_t prev_opts, prev_lo;
Radek Krejci5536d282020-08-04 23:27:44 +0200524
525 if (!any->value.tree) {
526 /* no content */
527 return LY_SUCCESS;
528 }
529
530 if (any->value_type == LYD_ANYDATA_LYB) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200531 uint32_t parser_options = LYD_PARSE_ONLY | LYD_PARSE_OPAQ | LYD_PARSE_STRICT;
Radek Krejci5536d282020-08-04 23:27:44 +0200532
533 /* turn logging off */
534 prev_lo = ly_log_options(0);
535
536 /* try to parse it into a data tree */
537 if (lyd_parse_data_mem(ctx->ctx, any->value.mem, LYD_LYB, parser_options, 0, &iter) == LY_SUCCESS) {
538 /* successfully parsed */
539 free(any->value.mem);
540 any->value.tree = iter;
541 any->value_type = LYD_ANYDATA_DATATREE;
542 }
543
544 /* turn loggin on again */
545 ly_log_options(prev_lo);
546 }
547
548 switch (any->value_type) {
549 case LYD_ANYDATA_DATATREE:
550 /* close opening tag and print data */
551 prev_opts = ctx->options;
552 ctx->options &= ~LYD_PRINT_WITHSIBLINGS;
553
554 LY_LIST_FOR(any->value.tree, iter) {
555 ret = json_print_node(ctx, iter);
556 LY_CHECK_ERR_RET(ret, LEVEL_DEC, ret);
557 }
558
559 ctx->options = prev_opts;
560 break;
561 case LYD_ANYDATA_JSON:
562 /* print without escaping special characters */
563 if (!any->value.str[0]) {
564 return LY_SUCCESS;
565 }
Michal Vasko5233e962020-08-14 14:26:20 +0200566 ly_print_(ctx->out, "%*s%s", INDENT, any->value.str);
Radek Krejci5536d282020-08-04 23:27:44 +0200567 break;
568 case LYD_ANYDATA_STRING:
569 case LYD_ANYDATA_XML:
570 case LYD_ANYDATA_LYB:
571 /* JSON and LYB format is not supported */
572 LOGWRN(ctx->ctx, "Unable to print anydata content (type %d) as XML.", any->value_type);
573 return LY_SUCCESS;
574 }
575
576 return LY_SUCCESS;
577}
578
579/**
580 * @brief Print content of a single container/list data node including its metadata.
581 * The envelope specific to container and list are expected to be printed by the caller.
582 *
583 * @param[in] ctx JSON printer context.
584 * @param[in] node Data node to print.
585 * @return LY_ERR value.
586 */
587static LY_ERR
588json_print_inner(struct jsonpr_ctx *ctx, const struct lyd_node *node)
589{
590 struct lyd_node *child;
Radek Krejci857189e2020-09-01 13:26:36 +0200591 ly_bool has_content = 0;
Radek Krejci5536d282020-08-04 23:27:44 +0200592
Michal Vasko630d9892020-12-08 17:11:08 +0100593 LY_LIST_FOR(lyd_child(node), child) {
594 if (ly_should_print(child, ctx->options)) {
595 break;
596 }
597 }
598 if (node->meta || child) {
Radek Krejci5536d282020-08-04 23:27:44 +0200599 has_content = 1;
Michal Vasko22df3f02020-08-24 13:29:22 +0200600 } else if (node->schema && (node->schema->nodetype & LYD_NODE_ANY) && ((struct lyd_node_any *)node)->value.tree) {
Radek Krejci5536d282020-08-04 23:27:44 +0200601 has_content = 1;
602 }
603
Michal Vasko69730152020-10-09 16:30:07 +0200604 if (!node->schema || (node->schema->nodetype != LYS_LIST)) {
Michal Vasko5233e962020-08-14 14:26:20 +0200605 ly_print_(ctx->out, "%s{%s", (is_open_array(ctx, node) && ctx->level_printed >= ctx->level) ? "," : "",
Radek Krejci0f969882020-08-21 16:56:47 +0200606 (DO_FORMAT && has_content) ? "\n" : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200607 } else {
Christian Hoppsbe51c942021-04-02 16:29:51 -0400608 ly_print_(ctx->out, "%s%*s{%s", (is_open_array(ctx, node) && ctx->level_printed >= ctx->level) ? (DO_FORMAT ? ",\n" : ",") : "",
Michal Vasko69730152020-10-09 16:30:07 +0200609 INDENT, (DO_FORMAT && has_content) ? "\n" : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200610 }
611 LEVEL_INC;
612
613 json_print_attributes(ctx, node, 1);
614
615 if (!node->schema || !(node->schema->nodetype & LYS_ANYDATA)) {
616 /* print children */
Michal Vasko630d9892020-12-08 17:11:08 +0100617 LY_LIST_FOR(lyd_child(node), child) {
Radek Krejci5536d282020-08-04 23:27:44 +0200618 LY_CHECK_RET(json_print_node(ctx, child));
619 }
620 } else {
621 /* anydata */
622 json_print_anydata(ctx, (struct lyd_node_any *)node);
623 }
624
Radek Krejci5536d282020-08-04 23:27:44 +0200625 LEVEL_DEC;
626 if (DO_FORMAT && has_content) {
Michal Vasko5233e962020-08-14 14:26:20 +0200627 ly_print_(ctx->out, "\n%*s}", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200628 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200629 ly_print_(ctx->out, "}");
Radek Krejci5536d282020-08-04 23:27:44 +0200630 }
631 LEVEL_PRINTED;
632
633 return LY_SUCCESS;
634}
635
636/**
637 * @brief Print container data node including its metadata.
638 *
639 * @param[in] ctx JSON printer context.
640 * @param[in] node Data node to print.
641 * @return LY_ERR value.
642 */
643static int
644json_print_container(struct jsonpr_ctx *ctx, const struct lyd_node *node)
645{
646 LY_CHECK_RET(json_print_member(ctx, node, 0));
647 LY_CHECK_RET(json_print_inner(ctx, node));
648
649 return LY_SUCCESS;
650}
651
652/**
653 * @brief Print single leaf-list or list instance.
654 *
655 * In case of list, metadata are printed inside the list object. For the leaf-list,
656 * metadata are marked in the context for later printing after closing the array next to it using
657 * json_print_metadata_leaflist().
658 *
659 * @param[in] ctx JSON printer context.
660 * @param[in] node Data node to print.
661 * @return LY_ERR value.
662 */
663static LY_ERR
664json_print_leaf_list(struct jsonpr_ctx *ctx, const struct lyd_node *node)
665{
666 if (!is_open_array(ctx, node)) {
667 LY_CHECK_RET(json_print_member(ctx, node, 0));
Michal Vaskob0099a92020-08-31 14:55:23 +0200668 LY_CHECK_RET(json_print_array_open(ctx, node));
Radek Krejciee74a192021-04-09 09:55:34 +0200669 if (node->schema->nodetype == LYS_LEAFLIST) {
Christian Hoppsbe51c942021-04-02 16:29:51 -0400670 ly_print_(ctx->out, "%*s", INDENT);
Radek Krejciee74a192021-04-09 09:55:34 +0200671 }
Radek Krejci5536d282020-08-04 23:27:44 +0200672 } else if (node->schema->nodetype == LYS_LEAFLIST) {
Christian Hoppsbe51c942021-04-02 16:29:51 -0400673 ly_print_(ctx->out, ",%s%*s", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200674 }
675
676 if (node->schema->nodetype == LYS_LIST) {
Radek Krejcia1c1e542020-09-29 16:06:52 +0200677 if (!lyd_child(node)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200678 /* empty, e.g. in case of filter */
Michal Vasko5233e962020-08-14 14:26:20 +0200679 ly_print_(ctx->out, "%s%snull", (ctx->level_printed >= ctx->level) ? "," : "", DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200680 LEVEL_PRINTED;
681 } else {
682 /* print list's content */
683 LY_CHECK_RET(json_print_inner(ctx, node));
684 }
685 } else {
686 assert(node->schema->nodetype == LYS_LEAFLIST);
Michal Vasko22df3f02020-08-24 13:29:22 +0200687 LY_CHECK_RET(json_print_value(ctx, &((const struct lyd_node_term *)node)->value));
Radek Krejci5536d282020-08-04 23:27:44 +0200688
689 if (node->meta && !ctx->print_sibling_metadata) {
690 ctx->print_sibling_metadata = node;
691 }
692 }
693
Michal Vasko69730152020-10-09 16:30:07 +0200694 if (is_open_array(ctx, node) && (!node->next || (node->next->schema != node->schema))) {
Radek Krejci5536d282020-08-04 23:27:44 +0200695 json_print_array_close(ctx);
696 }
697
698 return LY_SUCCESS;
699}
700
701/**
702 * @brief Print leaf-list's metadata in case they were marked in the last call to json_print_leaf_list().
703 * This function is supposed to be called when the leaf-list array is closed.
704 *
705 * @param[in] ctx JSON printer context.
706 * @return LY_ERR value.
707 */
708static LY_ERR
709json_print_metadata_leaflist(struct jsonpr_ctx *ctx)
710{
711 const struct lyd_node *prev, *node, *iter;
712
713 if (!ctx->print_sibling_metadata) {
714 return LY_SUCCESS;
715 }
716
717 for (node = ctx->print_sibling_metadata, prev = ctx->print_sibling_metadata->prev;
718 prev->next && matching_node(node, prev);
719 node = prev, prev = node->prev) {}
720
721 /* node is the first instance of the leaf-list */
722
723 LY_CHECK_RET(json_print_member(ctx, node, 1));
Michal Vasko5233e962020-08-14 14:26:20 +0200724 ly_print_(ctx->out, "[%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200725 LEVEL_INC;
726 LY_LIST_FOR(node, iter) {
727 PRINT_COMMA;
728 if (iter->meta) {
Michal Vasko5233e962020-08-14 14:26:20 +0200729 ly_print_(ctx->out, "%*s%s", INDENT, DO_FORMAT ? "{\n" : "{");
Radek Krejci5536d282020-08-04 23:27:44 +0200730 LEVEL_INC;
731 LY_CHECK_RET(json_print_metadata(ctx, iter, NULL));
732 LEVEL_DEC;
Michal Vasko5233e962020-08-14 14:26:20 +0200733 ly_print_(ctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200734 } else {
Michal Vasko5233e962020-08-14 14:26:20 +0200735 ly_print_(ctx->out, "null");
Radek Krejci5536d282020-08-04 23:27:44 +0200736 }
737 LEVEL_PRINTED;
738 if (!matching_node(iter, iter->next)) {
739 break;
740 }
741 }
742 LEVEL_DEC;
Michal Vasko5233e962020-08-14 14:26:20 +0200743 ly_print_(ctx->out, "%s%*s]", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200744 LEVEL_PRINTED;
745
746 return LY_SUCCESS;
747}
748
749/**
750 * @brief Print opaq data node including its attributes.
751 *
752 * @param[in] ctx JSON printer context.
753 * @param[in] node Opaq node to print.
754 * @return LY_ERR value.
755 */
756static LY_ERR
757json_print_opaq(struct jsonpr_ctx *ctx, const struct lyd_node_opaq *node)
758{
Radek Krejci857189e2020-09-01 13:26:36 +0200759 ly_bool first = 1, last = 1;
Radek Krejci5536d282020-08-04 23:27:44 +0200760
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200761 if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100762 if (node->prev->next && matching_node(node->prev, &node->node)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200763 first = 0;
764 }
Michal Vasko9e685082021-01-29 14:49:09 +0100765 if (node->next && matching_node(&node->node, node->next)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200766 last = 0;
767 }
768 }
769
770 if (first) {
Michal Vasko9e685082021-01-29 14:49:09 +0100771 LY_CHECK_RET(json_print_member2(ctx, lyd_parent(&node->node), node->format, &node->name, 0));
Radek Krejci5536d282020-08-04 23:27:44 +0200772
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200773 if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100774 LY_CHECK_RET(json_print_array_open(ctx, &node->node));
Radek Krejci5536d282020-08-04 23:27:44 +0200775 LEVEL_INC;
776 }
777 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200778 if (node->child || (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST))) {
Michal Vasko9e685082021-01-29 14:49:09 +0100779 LY_CHECK_RET(json_print_inner(ctx, &node->node));
Radek Krejci5536d282020-08-04 23:27:44 +0200780 LEVEL_PRINTED;
781 } else {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200782 if (node->hints & LYD_VALHINT_EMPTY) {
Michal Vasko5233e962020-08-14 14:26:20 +0200783 ly_print_(ctx->out, "[null]");
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200784 } else if (node->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) {
Michal Vasko5233e962020-08-14 14:26:20 +0200785 ly_print_(ctx->out, "%s", node->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200786 } else {
787 /* string */
Michal Vasko5233e962020-08-14 14:26:20 +0200788 ly_print_(ctx->out, "\"%s\"", node->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200789 }
790 LEVEL_PRINTED;
791
792 /* attributes */
Michal Vasko22df3f02020-08-24 13:29:22 +0200793 json_print_attributes(ctx, (const struct lyd_node *)node, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200794
795 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200796 if (last && (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST))) {
Radek Krejci5536d282020-08-04 23:27:44 +0200797 json_print_array_close(ctx);
798 LEVEL_DEC;
799 LEVEL_PRINTED;
800 }
801
802 return LY_SUCCESS;
803}
804
805/**
806 * @brief Print all the types of data node including its metadata.
807 *
808 * @param[in] ctx JSON printer context.
809 * @param[in] node Data node to print.
810 * @return LY_ERR value.
811 */
812static LY_ERR
813json_print_node(struct jsonpr_ctx *ctx, const struct lyd_node *node)
814{
815 if (!ly_should_print(node, ctx->options)) {
Michal Vasko69730152020-10-09 16:30:07 +0200816 if (is_open_array(ctx, node) && (!node->next || (node->next->schema != node->schema))) {
Radek Krejci5536d282020-08-04 23:27:44 +0200817 json_print_array_close(ctx);
818 }
819 return LY_SUCCESS;
820 }
821
822 if (!node->schema) {
823 LY_CHECK_RET(json_print_opaq(ctx, (const struct lyd_node_opaq *)node));
824 } else {
825 switch (node->schema->nodetype) {
826 case LYS_RPC:
827 case LYS_ACTION:
828 case LYS_NOTIF:
829 case LYS_CONTAINER:
830 LY_CHECK_RET(json_print_container(ctx, node));
831 break;
832 case LYS_LEAF:
833 LY_CHECK_RET(json_print_leaf(ctx, node));
834 break;
835 case LYS_LEAFLIST:
836 case LYS_LIST:
837 LY_CHECK_RET(json_print_leaf_list(ctx, node));
838 break;
839 case LYS_ANYXML:
840 case LYS_ANYDATA:
841 LY_CHECK_RET(json_print_container(ctx, node));
842 break;
843 default:
844 LOGINT(node->schema->module->ctx);
845 return EXIT_FAILURE;
846 }
847 }
848
849 ctx->level_printed = ctx->level;
850
851 if (ctx->print_sibling_metadata && !matching_node(node->next, ctx->print_sibling_metadata)) {
852 json_print_metadata_leaflist(ctx);
853 ctx->print_sibling_metadata = NULL;
854 }
855
856 return LY_SUCCESS;
857}
858
859LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200860json_print_data(struct ly_out *out, const struct lyd_node *root, uint32_t options)
Radek Krejci5536d282020-08-04 23:27:44 +0200861{
862 const struct lyd_node *node;
863 struct jsonpr_ctx ctx = {0};
Radek Krejci52f65552020-09-01 17:03:35 +0200864 const char *delimiter = (options & LYD_PRINT_SHRINK) ? "" : "\n";
Radek Krejci5536d282020-08-04 23:27:44 +0200865
Radek Krejci2e874772020-08-28 16:36:33 +0200866 if (!root) {
867 ly_print_(out, "{}%s", delimiter);
868 ly_print_flush(out);
869 return LY_SUCCESS;
870 }
871
Radek Krejci5536d282020-08-04 23:27:44 +0200872 ctx.out = out;
873 ctx.level = 1;
874 ctx.level_printed = 0;
875 ctx.options = options;
Michal Vaskob7be7a82020-08-20 09:09:04 +0200876 ctx.ctx = LYD_CTX(root);
Radek Krejci5536d282020-08-04 23:27:44 +0200877
878 /* start */
Michal Vasko5233e962020-08-14 14:26:20 +0200879 ly_print_(ctx.out, "{%s", delimiter);
Radek Krejci5536d282020-08-04 23:27:44 +0200880
881 /* content */
882 LY_LIST_FOR(root, node) {
883 LY_CHECK_RET(json_print_node(&ctx, node));
884 if (!(options & LYD_PRINT_WITHSIBLINGS)) {
885 break;
886 }
887 }
888
889 /* end */
Michal Vasko5233e962020-08-14 14:26:20 +0200890 ly_print_(out, "%s}%s", delimiter, delimiter);
Radek Krejci5536d282020-08-04 23:27:44 +0200891
892 assert(!ctx.open.count);
893 ly_set_erase(&ctx.open, NULL);
894
895 ly_print_flush(out);
896 return LY_SUCCESS;
897}