blob: 97347e1dcbbf9ed9b3e2ff476f55550605fbc27f [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 Vasko57c8d432022-11-30 15:35:56 +01004 * @author Michal Vasko <mvasko@cesnet.cz>
Michal Vasko90932a92020-02-12 14:33:03 +01005 * @brief JSON printer for libyang data structure
Radek Krejci13a57b62019-07-19 13:04:09 +02006 *
Michal Vasko57c8d432022-11-30 15:35:56 +01007 * Copyright (c) 2015 - 2022 CESNET, z.s.p.o.
Radek Krejci13a57b62019-07-19 13:04:09 +02008 *
9 * This source code is licensed under BSD 3-Clause License (the "License").
10 * You may not use this file except in compliance with the License.
11 * You may obtain a copy of the License at
12 *
13 * https://opensource.org/licenses/BSD-3-Clause
14 */
15
Radek Krejci5536d282020-08-04 23:27:44 +020016#include <assert.h>
Michal Vasko7730e302023-05-25 10:01:19 +020017#include <ctype.h>
Radek Krejci47fab892020-11-05 17:02:41 +010018#include <stdint.h>
Radek Krejci5536d282020-08-04 23:27:44 +020019#include <stdlib.h>
Radek Krejci5536d282020-08-04 23:27:44 +020020
Radek Krejci13a57b62019-07-19 13:04:09 +020021#include "common.h"
Radek Krejci47fab892020-11-05 17:02:41 +010022#include "context.h"
Radek Krejci5536d282020-08-04 23:27:44 +020023#include "log.h"
Radek Krejci47fab892020-11-05 17:02:41 +010024#include "out.h"
Michal Vaskoafac7822020-10-20 14:22:26 +020025#include "out_internal.h"
Radek Krejci5536d282020-08-04 23:27:44 +020026#include "parser_data.h"
Michal Vaskob4750962022-10-06 15:33:35 +020027#include "plugins_exts/metadata.h"
Radek Krejci5536d282020-08-04 23:27:44 +020028#include "plugins_types.h"
29#include "printer_data.h"
30#include "printer_internal.h"
31#include "set.h"
32#include "tree.h"
33#include "tree_data.h"
Radek Krejci13a57b62019-07-19 13:04:09 +020034#include "tree_schema.h"
35
36/**
Radek Krejci5536d282020-08-04 23:27:44 +020037 * @brief JSON printer context.
38 */
39struct jsonpr_ctx {
Radek Krejci1deb5be2020-08-26 16:43:36 +020040 struct ly_out *out; /**< output specification */
Michal Vaskoaa22f422021-12-02 10:48:32 +010041 const struct lyd_node *root; /**< root node of the subtree being printed */
Michal Vasko26743a22022-03-29 14:48:10 +020042 const struct lyd_node *parent; /**< parent of the node being printed */
Radek Krejci1deb5be2020-08-26 16:43:36 +020043 uint16_t level; /**< current indentation level: 0 - no formatting, >= 1 indentation levels */
44 uint32_t options; /**< [Data printer flags](@ref dataprinterflags) */
45 const struct ly_ctx *ctx; /**< libyang context */
Radek Krejci5536d282020-08-04 23:27:44 +020046
Radek Krejci1deb5be2020-08-26 16:43:36 +020047 uint16_t level_printed; /* level where some data were already printed */
Michal Vaskoaa22f422021-12-02 10:48:32 +010048 struct ly_set open; /* currently open array(s) */
Radek Krejci5536d282020-08-04 23:27:44 +020049 const struct lyd_node *print_sibling_metadata;
50};
51
52/**
53 * @brief Mark that something was already written in the current level,
54 * used to decide if a comma is expected between the items
55 */
Michal Vasko61ad1ff2022-02-10 15:48:39 +010056#define LEVEL_PRINTED pctx->level_printed = pctx->level
Radek Krejci5536d282020-08-04 23:27:44 +020057
58#define PRINT_COMMA \
Michal Vasko61ad1ff2022-02-10 15:48:39 +010059 if (pctx->level_printed >= pctx->level) { \
60 ly_print_(pctx->out, ",%s", (DO_FORMAT ? "\n" : "")); \
Radek Krejci5536d282020-08-04 23:27:44 +020061 }
62
Michal Vasko61ad1ff2022-02-10 15:48:39 +010063static LY_ERR json_print_node(struct jsonpr_ctx *pctx, const struct lyd_node *node);
Radek Krejci5536d282020-08-04 23:27:44 +020064
65/**
Michal Vaskob2c61572022-05-20 10:35:33 +020066 * @brief Compare 2 nodes, despite it is regular data node or an opaq node, and
Radek Krejci5536d282020-08-04 23:27:44 +020067 * decide if they corresponds to the same schema node.
68 *
Radek Krejci5536d282020-08-04 23:27:44 +020069 * @return 1 - matching nodes, 0 - non-matching nodes
70 */
71static int
72matching_node(const struct lyd_node *node1, const struct lyd_node *node2)
73{
74 assert(node1 || node2);
75
76 if (!node1 || !node2) {
77 return 0;
78 } else if (node1->schema != node2->schema) {
79 return 0;
80 }
81 if (!node1->schema) {
82 /* compare node names */
Michal Vasko22df3f02020-08-24 13:29:22 +020083 struct lyd_node_opaq *onode1 = (struct lyd_node_opaq *)node1;
84 struct lyd_node_opaq *onode2 = (struct lyd_node_opaq *)node2;
Michal Vasko26bbb272022-08-02 14:54:33 +020085
Michal Vaskoad92b672020-11-12 13:11:31 +010086 if ((onode1->name.name != onode2->name.name) || (onode1->name.prefix != onode2->name.prefix)) {
Radek Krejci5536d282020-08-04 23:27:44 +020087 return 0;
88 }
89 }
90
91 return 1;
92}
93
94/**
95 * @brief Open the JSON array ('[') for the specified @p node
96 *
97 * @param[in] ctx JSON printer context.
98 * @param[in] node First node of the array.
Michal Vaskob0099a92020-08-31 14:55:23 +020099 * @return LY_ERR value.
Radek Krejci5536d282020-08-04 23:27:44 +0200100 */
Michal Vaskob0099a92020-08-31 14:55:23 +0200101static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100102json_print_array_open(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200103{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100104 ly_print_(pctx->out, "[%s", DO_FORMAT ? "\n" : "");
105 LY_CHECK_RET(ly_set_add(&pctx->open, (void *)node, 0, NULL));
Radek Krejci5536d282020-08-04 23:27:44 +0200106 LEVEL_INC;
Michal Vaskob0099a92020-08-31 14:55:23 +0200107
108 return LY_SUCCESS;
Radek Krejci5536d282020-08-04 23:27:44 +0200109}
110
111/**
112 * @brief Get know if the array for the provided @p node is currently open.
113 *
114 * @param[in] ctx JSON printer context.
115 * @param[in] node Data node to check.
116 * @return 1 in case the printer is currently in the array belonging to the provided @p node.
117 * @return 0 in case the provided @p node is not connected with the currently open array (or there is no open array).
118 */
119static int
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100120is_open_array(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200121{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100122 if (pctx->open.count && matching_node(node, pctx->open.dnodes[pctx->open.count - 1])) {
Radek Krejci5536d282020-08-04 23:27:44 +0200123 return 1;
124 } else {
125 return 0;
126 }
127}
128
129/**
130 * @brief Close the most inner JSON array.
131 *
132 * @param[in] ctx JSON printer context.
133 */
134static void
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100135json_print_array_close(struct jsonpr_ctx *pctx)
Radek Krejci5536d282020-08-04 23:27:44 +0200136{
Radek Krejci5536d282020-08-04 23:27:44 +0200137 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100138 ly_set_rm_index(&pctx->open, pctx->open.count - 1, NULL);
139 ly_print_(pctx->out, "%s%*s]", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200140}
141
142/**
143 * @brief Get the node's module name to use as the @p node prefix in JSON.
Radek Krejci31bc3f52021-04-26 11:09:58 +0200144 *
Radek Krejci5536d282020-08-04 23:27:44 +0200145 * @param[in] node Node to process.
146 * @return The name of the module where the @p node belongs, it can be NULL in case the module name
147 * cannot be determined (source format is XML and the refered namespace is unknown/not implemented in the current context).
148 */
149static const char *
150node_prefix(const struct lyd_node *node)
151{
152 if (node->schema) {
153 return node->schema->module->name;
154 } else {
Michal Vasko22df3f02020-08-24 13:29:22 +0200155 struct lyd_node_opaq *onode = (struct lyd_node_opaq *)node;
Radek Krejci5536d282020-08-04 23:27:44 +0200156 const struct lys_module *mod;
157
158 switch (onode->format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200159 case LY_VALUE_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +0100160 return onode->name.module_name;
Radek Krejci8df109d2021-04-23 12:19:08 +0200161 case LY_VALUE_XML:
Michal Vaskoad92b672020-11-12 13:11:31 +0100162 mod = ly_ctx_get_module_implemented_ns(onode->ctx, onode->name.module_ns);
Radek Krejci5536d282020-08-04 23:27:44 +0200163 if (!mod) {
164 return NULL;
165 }
166 return mod->name;
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100167 default:
Radek Krejci5536d282020-08-04 23:27:44 +0200168 /* cannot be created */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200169 LOGINT(LYD_CTX(node));
Radek Krejci5536d282020-08-04 23:27:44 +0200170 }
171 }
172
173 return NULL;
174}
175
176/**
177 * @brief Compare 2 nodes if the belongs to the same module (if they come from the same namespace)
178 *
179 * Accepts both regulard a well as opaq nodes.
180 *
181 * @param[in] node1 The first node to compare.
182 * @param[in] node2 The second node to compare.
183 * @return 0 in case the nodes' modules are the same
184 * @return 1 in case the nodes belongs to different modules
185 */
186int
187json_nscmp(const struct lyd_node *node1, const struct lyd_node *node2)
188{
189 assert(node1 || node2);
190
191 if (!node1 || !node2) {
192 return 1;
193 } else if (node1->schema && node2->schema) {
194 if (node1->schema->module == node2->schema->module) {
195 /* belongs to the same module */
196 return 0;
197 } else {
198 /* different modules */
199 return 1;
200 }
201 } else {
202 const char *pref1 = node_prefix(node1);
203 const char *pref2 = node_prefix(node2);
Michal Vasko26bbb272022-08-02 14:54:33 +0200204
Michal Vasko69730152020-10-09 16:30:07 +0200205 if ((pref1 && pref2) && (pref1 == pref2)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200206 return 0;
207 } else {
208 return 1;
209 }
210 }
211}
212
213/**
214 * @brief Print the @p text as JSON string - encode special characters and add quotation around the string.
215 *
216 * @param[in] out The output handler.
217 * @param[in] text The string to print.
Michal Vasko5233e962020-08-14 14:26:20 +0200218 * @return LY_ERR value.
Radek Krejci5536d282020-08-04 23:27:44 +0200219 */
Michal Vasko5233e962020-08-14 14:26:20 +0200220static LY_ERR
Radek Krejci5536d282020-08-04 23:27:44 +0200221json_print_string(struct ly_out *out, const char *text)
222{
Michal Vasko7730e302023-05-25 10:01:19 +0200223 uint64_t i;
Radek Krejci5536d282020-08-04 23:27:44 +0200224
225 if (!text) {
Michal Vasko5233e962020-08-14 14:26:20 +0200226 return LY_SUCCESS;
Radek Krejci5536d282020-08-04 23:27:44 +0200227 }
228
Michal Vasko5233e962020-08-14 14:26:20 +0200229 ly_write_(out, "\"", 1);
Michal Vasko7730e302023-05-25 10:01:19 +0200230 for (i = 0; text[i]; i++) {
231 const unsigned char byte = text[i];
Michal Vasko26bbb272022-08-02 14:54:33 +0200232
Michal Vasko7730e302023-05-25 10:01:19 +0200233 switch (byte) {
234 case '"':
235 ly_print_(out, "\\\"");
236 break;
237 case '\\':
238 ly_print_(out, "\\\\");
239 break;
240 case '\r':
241 ly_print_(out, "\\r");
242 break;
243 case '\t':
244 ly_print_(out, "\\t");
245 break;
246 default:
247 if (iscntrl(byte)) {
248 /* control character */
249 ly_print_(out, "\\u%.4X", byte);
250 } else {
251 /* printable character (even non-ASCII UTF8) */
Michal Vasko5233e962020-08-14 14:26:20 +0200252 ly_write_(out, &text[i], 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200253 }
Michal Vasko7730e302023-05-25 10:01:19 +0200254 break;
Radek Krejci5536d282020-08-04 23:27:44 +0200255 }
256 }
Michal Vasko5233e962020-08-14 14:26:20 +0200257 ly_write_(out, "\"", 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200258
Michal Vasko5233e962020-08-14 14:26:20 +0200259 return LY_SUCCESS;
Radek Krejci5536d282020-08-04 23:27:44 +0200260}
261
262/**
263 * @brief Print JSON object's member name, ending by ':'. It resolves if the prefix is supposed to be printed.
264 *
265 * @param[in] ctx JSON printer context.
266 * @param[in] node The data node being printed.
267 * @param[in] is_attr Flag if the metadata sign (@) is supposed to be added before the identifier.
268 * @return LY_ERR value.
269 */
270static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100271json_print_member(struct jsonpr_ctx *pctx, const struct lyd_node *node, ly_bool is_attr)
Radek Krejci5536d282020-08-04 23:27:44 +0200272{
273 PRINT_COMMA;
Michal Vasko26743a22022-03-29 14:48:10 +0200274 if ((LEVEL == 1) || json_nscmp(node, pctx->parent)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200275 /* print "namespace" */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100276 ly_print_(pctx->out, "%*s\"%s%s:%s\":%s", INDENT, is_attr ? "@" : "",
Michal Vasko69730152020-10-09 16:30:07 +0200277 node_prefix(node), node->schema->name, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200278 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100279 ly_print_(pctx->out, "%*s\"%s%s\":%s", INDENT, is_attr ? "@" : "", node->schema->name, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200280 }
281
282 return LY_SUCCESS;
283}
284
285/**
286 * @brief More generic alternative to json_print_member() to print some special cases of the member names.
287 *
288 * @param[in] ctx JSON printer context.
289 * @param[in] parent Parent node to compare modules deciding if the prefix is printed.
290 * @param[in] format Format to decide how to process the @p prefix.
Michal Vaskoad92b672020-11-12 13:11:31 +0100291 * @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 +0200292 * @param[in] is_attr Flag if the metadata sign (@) is supposed to be added before the identifier.
293 * @return LY_ERR value.
294 */
295static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100296json_print_member2(struct jsonpr_ctx *pctx, const struct lyd_node *parent, LY_VALUE_FORMAT format,
Michal Vaskoad92b672020-11-12 13:11:31 +0100297 const struct ly_opaq_name *name, ly_bool is_attr)
Radek Krejci5536d282020-08-04 23:27:44 +0200298{
Michal Vaskoad92b672020-11-12 13:11:31 +0100299 const char *module_name = NULL, *name_str;
Radek Krejci5536d282020-08-04 23:27:44 +0200300
301 PRINT_COMMA;
302
303 /* determine prefix string */
Michal Vaskoad92b672020-11-12 13:11:31 +0100304 if (name) {
Radek Krejci5536d282020-08-04 23:27:44 +0200305 switch (format) {
Radek Krejci8df109d2021-04-23 12:19:08 +0200306 case LY_VALUE_JSON:
Michal Vaskoad92b672020-11-12 13:11:31 +0100307 module_name = name->module_name;
Radek Krejci5536d282020-08-04 23:27:44 +0200308 break;
Michal Vasko89762652023-02-09 13:58:37 +0100309 case LY_VALUE_XML: {
310 const struct lys_module *mod = NULL;
311
312 if (name->module_ns) {
313 mod = ly_ctx_get_module_implemented_ns(pctx->ctx, name->module_ns);
314 }
Radek Krejci5536d282020-08-04 23:27:44 +0200315 if (mod) {
316 module_name = mod->name;
317 }
318 break;
Michal Vasko89762652023-02-09 13:58:37 +0100319 }
Michal Vasko6b5cb2a2020-11-11 19:11:21 +0100320 default:
Radek Krejci5536d282020-08-04 23:27:44 +0200321 /* cannot be created */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100322 LOGINT_RET(pctx->ctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200323 }
Michal Vaskoad92b672020-11-12 13:11:31 +0100324
325 name_str = name->name;
326 } else {
327 name_str = "";
Radek Krejci5536d282020-08-04 23:27:44 +0200328 }
329
330 /* print the member */
Michal Vasko69730152020-10-09 16:30:07 +0200331 if (module_name && (!parent || (node_prefix(parent) != module_name))) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100332 ly_print_(pctx->out, "%*s\"%s%s:%s\":%s", INDENT, is_attr ? "@" : "", module_name, name_str, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200333 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100334 ly_print_(pctx->out, "%*s\"%s%s\":%s", INDENT, is_attr ? "@" : "", name_str, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200335 }
336
337 return LY_SUCCESS;
338}
339
340/**
341 * @brief Print data value.
342 *
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100343 * @param[in] pctx JSON printer context.
344 * @param[in] ctx Context used to print the value.
Radek Krejci5536d282020-08-04 23:27:44 +0200345 * @param[in] val Data value to be printed.
Michal Vasko32f067f2023-06-01 12:31:14 +0200346 * @param[in] local_mod Module of the current node.
Radek Krejci5536d282020-08-04 23:27:44 +0200347 * @return LY_ERR value.
348 */
349static LY_ERR
Michal Vasko32f067f2023-06-01 12:31:14 +0200350json_print_value(struct jsonpr_ctx *pctx, const struct ly_ctx *ctx, const struct lyd_value *val,
351 const struct lys_module *local_mod)
Radek Krejci5536d282020-08-04 23:27:44 +0200352{
aPiecek0f6bf3e2021-08-25 15:47:49 +0200353 ly_bool dynamic;
Michal Vasko183b9112021-11-04 16:02:24 +0100354 LY_DATA_TYPE basetype;
Michal Vasko32f067f2023-06-01 12:31:14 +0200355 const char *value;
Radek Krejci5536d282020-08-04 23:27:44 +0200356
Michal Vasko32f067f2023-06-01 12:31:14 +0200357 value = val->realtype->plugin->print(ctx, val, LY_VALUE_JSON, (void *)local_mod, &dynamic, NULL);
358 LY_CHECK_RET(!value, LY_EINVAL);
Michal Vasko183b9112021-11-04 16:02:24 +0100359 basetype = val->realtype->basetype;
360
361print_val:
Radek Krejci5536d282020-08-04 23:27:44 +0200362 /* leafref is not supported */
Michal Vasko183b9112021-11-04 16:02:24 +0100363 switch (basetype) {
364 case LY_TYPE_UNION:
365 /* use the resolved type */
366 basetype = val->subvalue->value.realtype->basetype;
367 goto print_val;
368
Radek Krejci5536d282020-08-04 23:27:44 +0200369 case LY_TYPE_BINARY:
370 case LY_TYPE_STRING:
371 case LY_TYPE_BITS:
372 case LY_TYPE_ENUM:
373 case LY_TYPE_INST:
374 case LY_TYPE_INT64:
375 case LY_TYPE_UINT64:
376 case LY_TYPE_DEC64:
377 case LY_TYPE_IDENT:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100378 json_print_string(pctx->out, value);
Radek Krejci5536d282020-08-04 23:27:44 +0200379 break;
380
381 case LY_TYPE_INT8:
382 case LY_TYPE_INT16:
383 case LY_TYPE_INT32:
384 case LY_TYPE_UINT8:
385 case LY_TYPE_UINT16:
386 case LY_TYPE_UINT32:
387 case LY_TYPE_BOOL:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100388 ly_print_(pctx->out, "%s", value[0] ? value : "null");
Radek Krejci5536d282020-08-04 23:27:44 +0200389 break;
390
391 case LY_TYPE_EMPTY:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100392 ly_print_(pctx->out, "[null]");
Radek Krejci5536d282020-08-04 23:27:44 +0200393 break;
394
395 default:
396 /* error */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100397 LOGINT_RET(pctx->ctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200398 }
399
400 if (dynamic) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200401 free((char *)value);
Radek Krejci5536d282020-08-04 23:27:44 +0200402 }
403
404 return LY_SUCCESS;
405}
406
407/**
408 * @brief Print all the attributes of the opaq node.
409 *
410 * @param[in] ctx JSON printer context.
411 * @param[in] node Opaq node where the attributes are placed.
412 * @param[in] wdmod With-defaults module to mark that default attribute is supposed to be printed.
413 * @return LY_ERR value.
414 */
415static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100416json_print_attribute(struct jsonpr_ctx *pctx, const struct lyd_node_opaq *node, const struct lys_module *wdmod)
Radek Krejci5536d282020-08-04 23:27:44 +0200417{
418 struct lyd_attr *attr;
419
420 if (wdmod) {
Michal Vaskob68c3b42022-05-20 10:36:40 +0200421 ly_print_(pctx->out, "%*s\"%s:default\":true", INDENT, wdmod->name);
Radek Krejci5536d282020-08-04 23:27:44 +0200422 LEVEL_PRINTED;
423 }
424
425 for (attr = node->attr; attr; attr = attr->next) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100426 json_print_member2(pctx, &node->node, attr->format, &attr->name, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200427
Michal Vasko69bb5fe2022-12-01 13:52:21 +0100428 if (attr->hints & (LYD_VALHINT_STRING | LYD_VALHINT_OCTNUM | LYD_VALHINT_HEXNUM | LYD_VALHINT_NUM64)) {
429 json_print_string(pctx->out, attr->value);
430 } else if (attr->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100431 ly_print_(pctx->out, "%s", attr->value[0] ? attr->value : "null");
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200432 } else if (attr->hints & LYD_VALHINT_EMPTY) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100433 ly_print_(pctx->out, "[null]");
Radek Krejci5536d282020-08-04 23:27:44 +0200434 } else {
Michal Vasko69bb5fe2022-12-01 13:52:21 +0100435 /* unknown value format with no hints, use universal string */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100436 json_print_string(pctx->out, attr->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200437 }
438 LEVEL_PRINTED;
439 }
440
441 return LY_SUCCESS;
442}
443
444/**
445 * @brief Print all the metadata of the node.
446 *
447 * @param[in] ctx JSON printer context.
448 * @param[in] node Node where the metadata are placed.
449 * @param[in] wdmod With-defaults module to mark that default attribute is supposed to be printed.
450 * @return LY_ERR value.
451 */
452static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100453json_print_metadata(struct jsonpr_ctx *pctx, const struct lyd_node *node, const struct lys_module *wdmod)
Radek Krejci5536d282020-08-04 23:27:44 +0200454{
455 struct lyd_meta *meta;
456
457 if (wdmod) {
Michal Vaskob68c3b42022-05-20 10:36:40 +0200458 ly_print_(pctx->out, "%*s\"%s:default\":true", INDENT, wdmod->name);
Radek Krejci5536d282020-08-04 23:27:44 +0200459 LEVEL_PRINTED;
460 }
461
462 for (meta = node->meta; meta; meta = meta->next) {
463 PRINT_COMMA;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100464 ly_print_(pctx->out, "%*s\"%s:%s\":%s", INDENT, meta->annotation->module->name, meta->name, DO_FORMAT ? " " : "");
Michal Vasko32f067f2023-06-01 12:31:14 +0200465 LY_CHECK_RET(json_print_value(pctx, LYD_CTX(node), &meta->value, NULL));
Radek Krejci5536d282020-08-04 23:27:44 +0200466 LEVEL_PRINTED;
467 }
468
469 return LY_SUCCESS;
470}
471
472/**
473 * @brief Print attributes/metadata of the given @p node. Accepts both regular as well as opaq nodes.
474 *
475 * @param[in] ctx JSON printer context.
476 * @param[in] node Data node where the attributes/metadata are placed.
Radek Krejci857189e2020-09-01 13:26:36 +0200477 * @param[in] inner Flag if the @p node is an inner node in the tree.
Radek Krejci5536d282020-08-04 23:27:44 +0200478 * @return LY_ERR value.
479 */
480static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100481json_print_attributes(struct jsonpr_ctx *pctx, const struct lyd_node *node, ly_bool inner)
Radek Krejci5536d282020-08-04 23:27:44 +0200482{
483 const struct lys_module *wdmod = NULL;
484
Michal Vasko6f39c822022-12-01 10:12:14 +0100485 if (node->schema && (node->schema->nodetype != LYS_CONTAINER) && (node->flags & LYD_DEFAULT) &&
486 (pctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG))) {
Radek Krejci5536d282020-08-04 23:27:44 +0200487 /* we have implicit OR explicit default node */
488 /* get with-defaults module */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200489 wdmod = ly_ctx_get_module_implemented(LYD_CTX(node), "ietf-netconf-with-defaults");
Radek Krejci5536d282020-08-04 23:27:44 +0200490 }
491
Michal Vaskob68c3b42022-05-20 10:36:40 +0200492 if (node->schema && (node->meta || wdmod)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200493 if (inner) {
Michal Vaskof2b0a042022-12-01 13:52:51 +0100494 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), LY_VALUE_JSON, NULL, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200495 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100496 LY_CHECK_RET(json_print_member(pctx, node, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200497 }
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100498 ly_print_(pctx->out, "{%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200499 LEVEL_INC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100500 LY_CHECK_RET(json_print_metadata(pctx, node, wdmod));
Radek Krejci5536d282020-08-04 23:27:44 +0200501 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100502 ly_print_(pctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200503 LEVEL_PRINTED;
Michal Vasko22df3f02020-08-24 13:29:22 +0200504 } else if (!node->schema && ((struct lyd_node_opaq *)node)->attr) {
Radek Krejci5536d282020-08-04 23:27:44 +0200505 if (inner) {
Michal Vaskof2b0a042022-12-01 13:52:51 +0100506 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), LY_VALUE_JSON, NULL, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200507 } else {
Michal Vaskof2b0a042022-12-01 13:52:51 +0100508 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), ((struct lyd_node_opaq *)node)->format,
Michal Vaskoad92b672020-11-12 13:11:31 +0100509 &((struct lyd_node_opaq *)node)->name, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200510 }
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100511 ly_print_(pctx->out, "{%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200512 LEVEL_INC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100513 LY_CHECK_RET(json_print_attribute(pctx, (struct lyd_node_opaq *)node, wdmod));
Radek Krejci5536d282020-08-04 23:27:44 +0200514 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100515 ly_print_(pctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200516 LEVEL_PRINTED;
517 }
518
519 return LY_SUCCESS;
520}
521
522/**
523 * @brief Print leaf data node including its metadata.
524 *
525 * @param[in] ctx JSON printer context.
526 * @param[in] node Data node to print.
527 * @return LY_ERR value.
528 */
529static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100530json_print_leaf(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200531{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100532 LY_CHECK_RET(json_print_member(pctx, node, 0));
Michal Vasko32f067f2023-06-01 12:31:14 +0200533 LY_CHECK_RET(json_print_value(pctx, LYD_CTX(node), &((const struct lyd_node_term *)node)->value, node->schema->module));
Radek Krejci5536d282020-08-04 23:27:44 +0200534 LEVEL_PRINTED;
535
536 /* print attributes as sibling */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100537 json_print_attributes(pctx, node, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200538
539 return LY_SUCCESS;
540}
541
542/**
Michal Vaskobbdadda2022-01-06 11:40:10 +0100543 * @brief Print anydata/anyxml content.
Radek Krejci5536d282020-08-04 23:27:44 +0200544 *
545 * @param[in] ctx JSON printer context.
546 * @param[in] any Anydata node to print.
547 * @return LY_ERR value.
548 */
549static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100550json_print_any_content(struct jsonpr_ctx *pctx, struct lyd_node_any *any)
Radek Krejci5536d282020-08-04 23:27:44 +0200551{
552 LY_ERR ret = LY_SUCCESS;
553 struct lyd_node *iter;
Michal Vasko26743a22022-03-29 14:48:10 +0200554 const struct lyd_node *prev_parent;
Michal Vaskod4a6d042022-12-08 08:34:29 +0100555 uint32_t prev_opts, temp_lo = 0;
Radek Krejci5536d282020-08-04 23:27:44 +0200556
Michal Vasko76096ec2022-02-24 16:06:16 +0100557 assert(any->schema->nodetype & LYD_NODE_ANY);
Radek Krejci5536d282020-08-04 23:27:44 +0200558
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100559 if ((any->schema->nodetype == LYS_ANYDATA) && (any->value_type != LYD_ANYDATA_DATATREE)) {
560 LOGINT_RET(pctx->ctx);
561 }
562
Radek Krejci5536d282020-08-04 23:27:44 +0200563 if (any->value_type == LYD_ANYDATA_LYB) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200564 uint32_t parser_options = LYD_PARSE_ONLY | LYD_PARSE_OPAQ | LYD_PARSE_STRICT;
Radek Krejci5536d282020-08-04 23:27:44 +0200565
566 /* turn logging off */
Michal Vaskod4a6d042022-12-08 08:34:29 +0100567 ly_temp_log_options(&temp_lo);
Radek Krejci5536d282020-08-04 23:27:44 +0200568
569 /* try to parse it into a data tree */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100570 if (lyd_parse_data_mem(pctx->ctx, any->value.mem, LYD_LYB, parser_options, 0, &iter) == LY_SUCCESS) {
Radek Krejci5536d282020-08-04 23:27:44 +0200571 /* successfully parsed */
572 free(any->value.mem);
573 any->value.tree = iter;
574 any->value_type = LYD_ANYDATA_DATATREE;
575 }
576
Michal Vaskod4a6d042022-12-08 08:34:29 +0100577 /* turn logging on again */
578 ly_temp_log_options(NULL);
Radek Krejci5536d282020-08-04 23:27:44 +0200579 }
580
581 switch (any->value_type) {
582 case LYD_ANYDATA_DATATREE:
Michal Vasko76096ec2022-02-24 16:06:16 +0100583 /* print as an object */
584 ly_print_(pctx->out, "{%s", DO_FORMAT ? "\n" : "");
585 LEVEL_INC;
Michal Vaskobbdadda2022-01-06 11:40:10 +0100586
Radek Krejci5536d282020-08-04 23:27:44 +0200587 /* close opening tag and print data */
Michal Vasko26743a22022-03-29 14:48:10 +0200588 prev_parent = pctx->parent;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100589 prev_opts = pctx->options;
Michal Vasko26743a22022-03-29 14:48:10 +0200590 pctx->parent = &any->node;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100591 pctx->options &= ~LYD_PRINT_WITHSIBLINGS;
Radek Krejci5536d282020-08-04 23:27:44 +0200592 LY_LIST_FOR(any->value.tree, iter) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100593 ret = json_print_node(pctx, iter);
Radek Krejci5536d282020-08-04 23:27:44 +0200594 LY_CHECK_ERR_RET(ret, LEVEL_DEC, ret);
595 }
Michal Vasko26743a22022-03-29 14:48:10 +0200596 pctx->parent = prev_parent;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100597 pctx->options = prev_opts;
Michal Vaskobbdadda2022-01-06 11:40:10 +0100598
Michal Vasko76096ec2022-02-24 16:06:16 +0100599 /* terminate the object */
Michal Vasko23b51a82022-03-29 14:22:34 +0200600 LEVEL_DEC;
Michal Vasko76096ec2022-02-24 16:06:16 +0100601 if (DO_FORMAT) {
602 ly_print_(pctx->out, "\n%*s}", INDENT);
603 } else {
604 ly_print_(pctx->out, "}");
Michal Vaskobbdadda2022-01-06 11:40:10 +0100605 }
Radek Krejci5536d282020-08-04 23:27:44 +0200606 break;
607 case LYD_ANYDATA_JSON:
Michal Vasko76096ec2022-02-24 16:06:16 +0100608 if (!any->value.json) {
609 /* no content */
610 if (any->schema->nodetype == LYS_ANYXML) {
611 ly_print_(pctx->out, "null");
612 } else {
613 ly_print_(pctx->out, "{}");
614 }
615 } else {
616 /* print without escaping special characters */
617 ly_print_(pctx->out, "%s", any->value.json);
Radek Krejci5536d282020-08-04 23:27:44 +0200618 }
Radek Krejci5536d282020-08-04 23:27:44 +0200619 break;
620 case LYD_ANYDATA_STRING:
621 case LYD_ANYDATA_XML:
Michal Vasko76096ec2022-02-24 16:06:16 +0100622 if (!any->value.str) {
623 /* no content */
624 if (any->schema->nodetype == LYS_ANYXML) {
625 ly_print_(pctx->out, "null");
626 } else {
627 ly_print_(pctx->out, "{}");
628 }
629 } else {
Michal Vaskobbdadda2022-01-06 11:40:10 +0100630 /* print as a string */
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100631 json_print_string(pctx->out, any->value.str);
Michal Vaskobbdadda2022-01-06 11:40:10 +0100632 }
Michal Vasko76096ec2022-02-24 16:06:16 +0100633 break;
Radek Krejci5536d282020-08-04 23:27:44 +0200634 case LYD_ANYDATA_LYB:
Michal Vasko76096ec2022-02-24 16:06:16 +0100635 /* LYB format is not supported */
636 LOGWRN(pctx->ctx, "Unable to print anydata content (type %d) as JSON.", any->value_type);
Michal Vaskobbdadda2022-01-06 11:40:10 +0100637 break;
Radek Krejci5536d282020-08-04 23:27:44 +0200638 }
639
640 return LY_SUCCESS;
641}
642
643/**
Michal Vasko76096ec2022-02-24 16:06:16 +0100644 * @brief Print content of a single container/list data node including its metadata.
Michal Vaskobbdadda2022-01-06 11:40:10 +0100645 * The envelope specific to nodes are expected to be printed by the caller.
Radek Krejci5536d282020-08-04 23:27:44 +0200646 *
647 * @param[in] ctx JSON printer context.
648 * @param[in] node Data node to print.
649 * @return LY_ERR value.
650 */
651static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100652json_print_inner(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200653{
654 struct lyd_node *child;
Michal Vasko26743a22022-03-29 14:48:10 +0200655 const struct lyd_node *prev_parent;
Michal Vasko23b51a82022-03-29 14:22:34 +0200656 struct lyd_node_opaq *opaq = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200657 ly_bool has_content = 0;
Radek Krejci5536d282020-08-04 23:27:44 +0200658
Michal Vasko630d9892020-12-08 17:11:08 +0100659 LY_LIST_FOR(lyd_child(node), child) {
Michal Vasko8db584d2022-03-30 13:42:48 +0200660 if (lyd_node_should_print(child, pctx->options)) {
Michal Vasko630d9892020-12-08 17:11:08 +0100661 break;
662 }
663 }
664 if (node->meta || child) {
Radek Krejci5536d282020-08-04 23:27:44 +0200665 has_content = 1;
Radek Krejci5536d282020-08-04 23:27:44 +0200666 }
Michal Vasko23b51a82022-03-29 14:22:34 +0200667 if (!node->schema) {
668 opaq = (struct lyd_node_opaq *)node;
669 }
Radek Krejci5536d282020-08-04 23:27:44 +0200670
Michal Vasko1a85d332021-08-27 10:35:28 +0200671 if ((node->schema && (node->schema->nodetype == LYS_LIST)) ||
Michal Vasko23b51a82022-03-29 14:22:34 +0200672 (opaq && (opaq->hints != LYD_HINT_DATA) && (opaq->hints & LYD_NODEHINT_LIST))) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100673 ly_print_(pctx->out, "%s%*s{%s", (is_open_array(pctx, node) && (pctx->level_printed >= pctx->level)) ?
Michal Vasko1a85d332021-08-27 10:35:28 +0200674 (DO_FORMAT ? ",\n" : ",") : "", INDENT, (DO_FORMAT && has_content) ? "\n" : "");
675 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100676 ly_print_(pctx->out, "%s{%s", (is_open_array(pctx, node) && (pctx->level_printed >= pctx->level)) ? "," : "",
Radek Krejci0f969882020-08-21 16:56:47 +0200677 (DO_FORMAT && has_content) ? "\n" : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200678 }
679 LEVEL_INC;
680
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100681 json_print_attributes(pctx, node, 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200682
Michal Vasko76096ec2022-02-24 16:06:16 +0100683 /* print children */
Michal Vasko26743a22022-03-29 14:48:10 +0200684 prev_parent = pctx->parent;
685 pctx->parent = node;
Michal Vasko76096ec2022-02-24 16:06:16 +0100686 LY_LIST_FOR(lyd_child(node), child) {
687 LY_CHECK_RET(json_print_node(pctx, child));
Radek Krejci5536d282020-08-04 23:27:44 +0200688 }
Michal Vasko26743a22022-03-29 14:48:10 +0200689 pctx->parent = prev_parent;
Radek Krejci5536d282020-08-04 23:27:44 +0200690
Radek Krejci5536d282020-08-04 23:27:44 +0200691 LEVEL_DEC;
692 if (DO_FORMAT && has_content) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100693 ly_print_(pctx->out, "\n%*s}", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200694 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100695 ly_print_(pctx->out, "}");
Radek Krejci5536d282020-08-04 23:27:44 +0200696 }
697 LEVEL_PRINTED;
698
699 return LY_SUCCESS;
700}
701
702/**
703 * @brief Print container data node including its metadata.
704 *
705 * @param[in] ctx JSON printer context.
706 * @param[in] node Data node to print.
707 * @return LY_ERR value.
708 */
709static int
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100710json_print_container(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200711{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100712 LY_CHECK_RET(json_print_member(pctx, node, 0));
713 LY_CHECK_RET(json_print_inner(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200714
715 return LY_SUCCESS;
716}
717
718/**
Michal Vasko76096ec2022-02-24 16:06:16 +0100719 * @brief Print anydata/anyxml data node including its metadata.
Michal Vaskobbdadda2022-01-06 11:40:10 +0100720 *
721 * @param[in] ctx JSON printer context.
722 * @param[in] node Data node to print.
723 * @return LY_ERR value.
724 */
725static int
Michal Vasko76096ec2022-02-24 16:06:16 +0100726json_print_any(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Michal Vaskobbdadda2022-01-06 11:40:10 +0100727{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100728 LY_CHECK_RET(json_print_member(pctx, node, 0));
729 LY_CHECK_RET(json_print_any_content(pctx, (struct lyd_node_any *)node));
Michal Vaskobbdadda2022-01-06 11:40:10 +0100730 LEVEL_PRINTED;
731
732 /* print attributes as sibling */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100733 json_print_attributes(pctx, node, 0);
Michal Vaskobbdadda2022-01-06 11:40:10 +0100734
735 return LY_SUCCESS;
736}
737
738/**
Michal Vaskoaa22f422021-12-02 10:48:32 +0100739 * @brief Check whether a node is the last printed instance of a (leaf-)list.
740 *
741 * @param[in] ctx JSON printer context.
742 * @param[in] node Last printed node.
743 * @return Whether it is the last printed instance or not.
744 */
745static ly_bool
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100746json_print_array_is_last_inst(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Michal Vaskoaa22f422021-12-02 10:48:32 +0100747{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100748 if (!is_open_array(pctx, node)) {
Michal Vasko06217f32021-12-09 09:25:50 +0100749 /* no array open */
750 return 0;
751 }
752
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100753 if ((pctx->root == node) && !(pctx->options & LYD_PRINT_WITHSIBLINGS)) {
Michal Vaskoaa22f422021-12-02 10:48:32 +0100754 /* the only printed instance */
755 return 1;
756 }
757
Michal Vasko06217f32021-12-09 09:25:50 +0100758 if (!node->next || (node->next->schema != node->schema)) {
Michal Vaskoaa22f422021-12-02 10:48:32 +0100759 /* last instance */
760 return 1;
761 }
762
763 return 0;
764}
765
766/**
Radek Krejci5536d282020-08-04 23:27:44 +0200767 * @brief Print single leaf-list or list instance.
768 *
769 * In case of list, metadata are printed inside the list object. For the leaf-list,
770 * metadata are marked in the context for later printing after closing the array next to it using
771 * json_print_metadata_leaflist().
772 *
773 * @param[in] ctx JSON printer context.
774 * @param[in] node Data node to print.
775 * @return LY_ERR value.
776 */
777static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100778json_print_leaf_list(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200779{
Michal Vasko57c8d432022-11-30 15:35:56 +0100780 const struct lys_module *wdmod = NULL;
781
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100782 if (!is_open_array(pctx, node)) {
783 LY_CHECK_RET(json_print_member(pctx, node, 0));
784 LY_CHECK_RET(json_print_array_open(pctx, node));
Radek Krejciee74a192021-04-09 09:55:34 +0200785 if (node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100786 ly_print_(pctx->out, "%*s", INDENT);
Radek Krejciee74a192021-04-09 09:55:34 +0200787 }
Radek Krejci5536d282020-08-04 23:27:44 +0200788 } else if (node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100789 ly_print_(pctx->out, ",%s%*s", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200790 }
791
792 if (node->schema->nodetype == LYS_LIST) {
Michal Vasko2fe10342022-12-01 11:54:02 +0100793 /* print list's content */
794 LY_CHECK_RET(json_print_inner(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200795 } else {
796 assert(node->schema->nodetype == LYS_LEAFLIST);
Michal Vasko57c8d432022-11-30 15:35:56 +0100797
Michal Vasko32f067f2023-06-01 12:31:14 +0200798 LY_CHECK_RET(json_print_value(pctx, LYD_CTX(node), &((const struct lyd_node_term *)node)->value, node->schema->module));
Radek Krejci5536d282020-08-04 23:27:44 +0200799
Michal Vasko57c8d432022-11-30 15:35:56 +0100800 if (!pctx->print_sibling_metadata) {
801 if ((node->flags & LYD_DEFAULT) && (pctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG))) {
802 /* we have implicit OR explicit default node, get with-defaults module */
803 wdmod = ly_ctx_get_module_implemented(LYD_CTX(node), "ietf-netconf-with-defaults");
804 }
805 if (node->meta || wdmod) {
806 /* we will be printing metadata for these siblings */
807 pctx->print_sibling_metadata = node;
808 }
Radek Krejci5536d282020-08-04 23:27:44 +0200809 }
810 }
811
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100812 if (json_print_array_is_last_inst(pctx, node)) {
813 json_print_array_close(pctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200814 }
815
816 return LY_SUCCESS;
817}
818
819/**
820 * @brief Print leaf-list's metadata in case they were marked in the last call to json_print_leaf_list().
821 * This function is supposed to be called when the leaf-list array is closed.
822 *
823 * @param[in] ctx JSON printer context.
824 * @return LY_ERR value.
825 */
826static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100827json_print_metadata_leaflist(struct jsonpr_ctx *pctx)
Radek Krejci5536d282020-08-04 23:27:44 +0200828{
829 const struct lyd_node *prev, *node, *iter;
Michal Vasko57c8d432022-11-30 15:35:56 +0100830 const struct lys_module *wdmod = NULL;
Radek Krejci5536d282020-08-04 23:27:44 +0200831
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100832 if (!pctx->print_sibling_metadata) {
Radek Krejci5536d282020-08-04 23:27:44 +0200833 return LY_SUCCESS;
834 }
835
Michal Vasko57c8d432022-11-30 15:35:56 +0100836 if (pctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG)) {
837 /* get with-defaults module */
838 wdmod = ly_ctx_get_module_implemented(pctx->ctx, "ietf-netconf-with-defaults");
839 }
840
841 /* node is the first instance of the leaf-list */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100842 for (node = pctx->print_sibling_metadata, prev = pctx->print_sibling_metadata->prev;
Radek Krejci5536d282020-08-04 23:27:44 +0200843 prev->next && matching_node(node, prev);
844 node = prev, prev = node->prev) {}
845
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100846 LY_CHECK_RET(json_print_member(pctx, node, 1));
847 ly_print_(pctx->out, "[%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200848 LEVEL_INC;
849 LY_LIST_FOR(node, iter) {
850 PRINT_COMMA;
Michal Vasko57c8d432022-11-30 15:35:56 +0100851 if (iter->meta || (iter->flags & LYD_DEFAULT)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100852 ly_print_(pctx->out, "%*s%s", INDENT, DO_FORMAT ? "{\n" : "{");
Radek Krejci5536d282020-08-04 23:27:44 +0200853 LEVEL_INC;
Michal Vasko57c8d432022-11-30 15:35:56 +0100854 LY_CHECK_RET(json_print_metadata(pctx, iter, (iter->flags & LYD_DEFAULT) ? wdmod : NULL));
Radek Krejci5536d282020-08-04 23:27:44 +0200855 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100856 ly_print_(pctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200857 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100858 ly_print_(pctx->out, "null");
Radek Krejci5536d282020-08-04 23:27:44 +0200859 }
860 LEVEL_PRINTED;
861 if (!matching_node(iter, iter->next)) {
862 break;
863 }
864 }
865 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100866 ly_print_(pctx->out, "%s%*s]", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200867 LEVEL_PRINTED;
868
869 return LY_SUCCESS;
870}
871
872/**
873 * @brief Print opaq data node including its attributes.
874 *
875 * @param[in] ctx JSON printer context.
876 * @param[in] node Opaq node to print.
877 * @return LY_ERR value.
878 */
879static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100880json_print_opaq(struct jsonpr_ctx *pctx, const struct lyd_node_opaq *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200881{
Radek Krejci857189e2020-09-01 13:26:36 +0200882 ly_bool first = 1, last = 1;
Radek Krejci5536d282020-08-04 23:27:44 +0200883
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200884 if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100885 if (node->prev->next && matching_node(node->prev, &node->node)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200886 first = 0;
887 }
Michal Vasko9e685082021-01-29 14:49:09 +0100888 if (node->next && matching_node(&node->node, node->next)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200889 last = 0;
890 }
891 }
892
893 if (first) {
Michal Vasko26743a22022-03-29 14:48:10 +0200894 LY_CHECK_RET(json_print_member2(pctx, pctx->parent, node->format, &node->name, 0));
Radek Krejci5536d282020-08-04 23:27:44 +0200895
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200896 if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100897 LY_CHECK_RET(json_print_array_open(pctx, &node->node));
Radek Krejci5536d282020-08-04 23:27:44 +0200898 }
Michal Vasko1a85d332021-08-27 10:35:28 +0200899 if (node->hints & LYD_NODEHINT_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100900 ly_print_(pctx->out, "%*s", INDENT);
Michal Vasko1a85d332021-08-27 10:35:28 +0200901 }
902 } else if (node->hints & LYD_NODEHINT_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100903 ly_print_(pctx->out, ",%s%*s", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200904 }
Michal Vasko1a85d332021-08-27 10:35:28 +0200905 if (node->child || (node->hints & LYD_NODEHINT_LIST)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100906 LY_CHECK_RET(json_print_inner(pctx, &node->node));
Radek Krejci5536d282020-08-04 23:27:44 +0200907 LEVEL_PRINTED;
908 } else {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200909 if (node->hints & LYD_VALHINT_EMPTY) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100910 ly_print_(pctx->out, "[null]");
Michal Vaskocea58712022-04-01 14:37:08 +0200911 } else if ((node->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) && !(node->hints & LYD_VALHINT_NUM64)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100912 ly_print_(pctx->out, "%s", node->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200913 } else {
Michal Vaskocea58712022-04-01 14:37:08 +0200914 /* string or a large number */
Michal Vasko5e2742d2023-05-25 10:01:42 +0200915 json_print_string(pctx->out, node->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200916 }
917 LEVEL_PRINTED;
918
919 /* attributes */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100920 json_print_attributes(pctx, (const struct lyd_node *)node, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200921
922 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200923 if (last && (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST))) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100924 json_print_array_close(pctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200925 LEVEL_PRINTED;
926 }
927
928 return LY_SUCCESS;
929}
930
931/**
932 * @brief Print all the types of data node including its metadata.
933 *
934 * @param[in] ctx JSON printer context.
935 * @param[in] node Data node to print.
936 * @return LY_ERR value.
937 */
938static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100939json_print_node(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200940{
Michal Vasko8db584d2022-03-30 13:42:48 +0200941 if (!lyd_node_should_print(node, pctx->options)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100942 if (json_print_array_is_last_inst(pctx, node)) {
943 json_print_array_close(pctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200944 }
945 return LY_SUCCESS;
946 }
947
948 if (!node->schema) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100949 LY_CHECK_RET(json_print_opaq(pctx, (const struct lyd_node_opaq *)node));
Radek Krejci5536d282020-08-04 23:27:44 +0200950 } else {
951 switch (node->schema->nodetype) {
952 case LYS_RPC:
953 case LYS_ACTION:
954 case LYS_NOTIF:
955 case LYS_CONTAINER:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100956 LY_CHECK_RET(json_print_container(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200957 break;
958 case LYS_LEAF:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100959 LY_CHECK_RET(json_print_leaf(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200960 break;
961 case LYS_LEAFLIST:
962 case LYS_LIST:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100963 LY_CHECK_RET(json_print_leaf_list(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200964 break;
Michal Vasko76096ec2022-02-24 16:06:16 +0100965 case LYS_ANYDATA:
Radek Krejci5536d282020-08-04 23:27:44 +0200966 case LYS_ANYXML:
Michal Vasko76096ec2022-02-24 16:06:16 +0100967 LY_CHECK_RET(json_print_any(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200968 break;
969 default:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100970 LOGINT(pctx->ctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200971 return EXIT_FAILURE;
972 }
973 }
974
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100975 pctx->level_printed = pctx->level;
Radek Krejci5536d282020-08-04 23:27:44 +0200976
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100977 if (pctx->print_sibling_metadata && !matching_node(node->next, pctx->print_sibling_metadata)) {
978 json_print_metadata_leaflist(pctx);
979 pctx->print_sibling_metadata = NULL;
Radek Krejci5536d282020-08-04 23:27:44 +0200980 }
981
982 return LY_SUCCESS;
983}
984
985LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200986json_print_data(struct ly_out *out, const struct lyd_node *root, uint32_t options)
Radek Krejci5536d282020-08-04 23:27:44 +0200987{
988 const struct lyd_node *node;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100989 struct jsonpr_ctx pctx = {0};
Radek Krejci52f65552020-09-01 17:03:35 +0200990 const char *delimiter = (options & LYD_PRINT_SHRINK) ? "" : "\n";
Radek Krejci5536d282020-08-04 23:27:44 +0200991
Radek Krejci2e874772020-08-28 16:36:33 +0200992 if (!root) {
993 ly_print_(out, "{}%s", delimiter);
994 ly_print_flush(out);
995 return LY_SUCCESS;
996 }
997
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100998 pctx.out = out;
Michal Vasko26743a22022-03-29 14:48:10 +0200999 pctx.parent = NULL;
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001000 pctx.level = 1;
1001 pctx.level_printed = 0;
1002 pctx.options = options;
1003 pctx.ctx = LYD_CTX(root);
Radek Krejci5536d282020-08-04 23:27:44 +02001004
1005 /* start */
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001006 ly_print_(pctx.out, "{%s", delimiter);
Radek Krejci5536d282020-08-04 23:27:44 +02001007
1008 /* content */
1009 LY_LIST_FOR(root, node) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001010 pctx.root = node;
1011 LY_CHECK_RET(json_print_node(&pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +02001012 if (!(options & LYD_PRINT_WITHSIBLINGS)) {
1013 break;
1014 }
1015 }
1016
1017 /* end */
Michal Vasko5233e962020-08-14 14:26:20 +02001018 ly_print_(out, "%s}%s", delimiter, delimiter);
Radek Krejci5536d282020-08-04 23:27:44 +02001019
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001020 assert(!pctx.open.count);
1021 ly_set_erase(&pctx.open, NULL);
Radek Krejci5536d282020-08-04 23:27:44 +02001022
1023 ly_print_flush(out);
1024 return LY_SUCCESS;
1025}