blob: 66ae1548e38b2679b19aa7b7b92ec53486855b99 [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 Vaskoa4e5eb42023-09-18 08:44:21 +02007 * Copyright (c) 2015 - 2023 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) */
Michal Vaskoa4e5eb42023-09-18 08:44:21 +020049 const struct lyd_node *first_leaflist; /**< first printed leaf-list instance, used when printing its metadata/attributes */
Radek Krejci5536d282020-08-04 23:27:44 +020050};
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 */
Ilyes Ben Hamouda0ee30a82023-09-07 08:46:33 +0200366 val = &val->subvalue->value;
367 basetype = val->realtype->basetype;
Michal Vasko183b9112021-11-04 16:02:24 +0100368 goto print_val;
369
Radek Krejci5536d282020-08-04 23:27:44 +0200370 case LY_TYPE_BINARY:
371 case LY_TYPE_STRING:
372 case LY_TYPE_BITS:
373 case LY_TYPE_ENUM:
374 case LY_TYPE_INST:
375 case LY_TYPE_INT64:
376 case LY_TYPE_UINT64:
377 case LY_TYPE_DEC64:
378 case LY_TYPE_IDENT:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100379 json_print_string(pctx->out, value);
Radek Krejci5536d282020-08-04 23:27:44 +0200380 break;
381
382 case LY_TYPE_INT8:
383 case LY_TYPE_INT16:
384 case LY_TYPE_INT32:
385 case LY_TYPE_UINT8:
386 case LY_TYPE_UINT16:
387 case LY_TYPE_UINT32:
388 case LY_TYPE_BOOL:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100389 ly_print_(pctx->out, "%s", value[0] ? value : "null");
Radek Krejci5536d282020-08-04 23:27:44 +0200390 break;
391
392 case LY_TYPE_EMPTY:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100393 ly_print_(pctx->out, "[null]");
Radek Krejci5536d282020-08-04 23:27:44 +0200394 break;
395
396 default:
397 /* error */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100398 LOGINT_RET(pctx->ctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200399 }
400
401 if (dynamic) {
Michal Vasko22df3f02020-08-24 13:29:22 +0200402 free((char *)value);
Radek Krejci5536d282020-08-04 23:27:44 +0200403 }
404
405 return LY_SUCCESS;
406}
407
408/**
409 * @brief Print all the attributes of the opaq node.
410 *
411 * @param[in] ctx JSON printer context.
412 * @param[in] node Opaq node where the attributes are placed.
Radek Krejci5536d282020-08-04 23:27:44 +0200413 * @return LY_ERR value.
414 */
415static LY_ERR
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200416json_print_attribute(struct jsonpr_ctx *pctx, const struct lyd_node_opaq *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200417{
418 struct lyd_attr *attr;
419
Radek Krejci5536d282020-08-04 23:27:44 +0200420 for (attr = node->attr; attr; attr = attr->next) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100421 json_print_member2(pctx, &node->node, attr->format, &attr->name, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200422
Michal Vasko69bb5fe2022-12-01 13:52:21 +0100423 if (attr->hints & (LYD_VALHINT_STRING | LYD_VALHINT_OCTNUM | LYD_VALHINT_HEXNUM | LYD_VALHINT_NUM64)) {
424 json_print_string(pctx->out, attr->value);
425 } else if (attr->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100426 ly_print_(pctx->out, "%s", attr->value[0] ? attr->value : "null");
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200427 } else if (attr->hints & LYD_VALHINT_EMPTY) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100428 ly_print_(pctx->out, "[null]");
Radek Krejci5536d282020-08-04 23:27:44 +0200429 } else {
Michal Vasko69bb5fe2022-12-01 13:52:21 +0100430 /* unknown value format with no hints, use universal string */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100431 json_print_string(pctx->out, attr->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200432 }
433 LEVEL_PRINTED;
434 }
435
436 return LY_SUCCESS;
437}
438
439/**
440 * @brief Print all the metadata of the node.
441 *
442 * @param[in] ctx JSON printer context.
443 * @param[in] node Node where the metadata are placed.
444 * @param[in] wdmod With-defaults module to mark that default attribute is supposed to be printed.
445 * @return LY_ERR value.
446 */
447static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100448json_print_metadata(struct jsonpr_ctx *pctx, const struct lyd_node *node, const struct lys_module *wdmod)
Radek Krejci5536d282020-08-04 23:27:44 +0200449{
450 struct lyd_meta *meta;
451
452 if (wdmod) {
aPiecekf312c8e2023-05-11 09:09:39 +0200453 ly_print_(pctx->out, "%*s\"%s:default\":%strue", INDENT, wdmod->name, DO_FORMAT ? " " : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200454 LEVEL_PRINTED;
455 }
456
457 for (meta = node->meta; meta; meta = meta->next) {
458 PRINT_COMMA;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100459 ly_print_(pctx->out, "%*s\"%s:%s\":%s", INDENT, meta->annotation->module->name, meta->name, DO_FORMAT ? " " : "");
Michal Vasko32f067f2023-06-01 12:31:14 +0200460 LY_CHECK_RET(json_print_value(pctx, LYD_CTX(node), &meta->value, NULL));
Radek Krejci5536d282020-08-04 23:27:44 +0200461 LEVEL_PRINTED;
462 }
463
464 return LY_SUCCESS;
465}
466
467/**
468 * @brief Print attributes/metadata of the given @p node. Accepts both regular as well as opaq nodes.
469 *
470 * @param[in] ctx JSON printer context.
471 * @param[in] node Data node where the attributes/metadata are placed.
Radek Krejci857189e2020-09-01 13:26:36 +0200472 * @param[in] inner Flag if the @p node is an inner node in the tree.
Radek Krejci5536d282020-08-04 23:27:44 +0200473 * @return LY_ERR value.
474 */
475static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100476json_print_attributes(struct jsonpr_ctx *pctx, const struct lyd_node *node, ly_bool inner)
Radek Krejci5536d282020-08-04 23:27:44 +0200477{
478 const struct lys_module *wdmod = NULL;
479
Michal Vasko6f39c822022-12-01 10:12:14 +0100480 if (node->schema && (node->schema->nodetype != LYS_CONTAINER) && (node->flags & LYD_DEFAULT) &&
481 (pctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG))) {
Radek Krejci5536d282020-08-04 23:27:44 +0200482 /* we have implicit OR explicit default node */
483 /* get with-defaults module */
Michal Vaskob7be7a82020-08-20 09:09:04 +0200484 wdmod = ly_ctx_get_module_implemented(LYD_CTX(node), "ietf-netconf-with-defaults");
Radek Krejci5536d282020-08-04 23:27:44 +0200485 }
486
Michal Vaskob68c3b42022-05-20 10:36:40 +0200487 if (node->schema && (node->meta || wdmod)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200488 if (inner) {
Michal Vaskof2b0a042022-12-01 13:52:51 +0100489 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), LY_VALUE_JSON, NULL, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200490 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100491 LY_CHECK_RET(json_print_member(pctx, node, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200492 }
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100493 ly_print_(pctx->out, "{%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200494 LEVEL_INC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100495 LY_CHECK_RET(json_print_metadata(pctx, node, wdmod));
Radek Krejci5536d282020-08-04 23:27:44 +0200496 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100497 ly_print_(pctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200498 LEVEL_PRINTED;
Michal Vasko22df3f02020-08-24 13:29:22 +0200499 } else if (!node->schema && ((struct lyd_node_opaq *)node)->attr) {
Radek Krejci5536d282020-08-04 23:27:44 +0200500 if (inner) {
Michal Vaskof2b0a042022-12-01 13:52:51 +0100501 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), LY_VALUE_JSON, NULL, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200502 } else {
Michal Vaskof2b0a042022-12-01 13:52:51 +0100503 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), ((struct lyd_node_opaq *)node)->format,
Michal Vaskoad92b672020-11-12 13:11:31 +0100504 &((struct lyd_node_opaq *)node)->name, 1));
Radek Krejci5536d282020-08-04 23:27:44 +0200505 }
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100506 ly_print_(pctx->out, "{%s", (DO_FORMAT ? "\n" : ""));
Radek Krejci5536d282020-08-04 23:27:44 +0200507 LEVEL_INC;
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200508 LY_CHECK_RET(json_print_attribute(pctx, (struct lyd_node_opaq *)node));
Radek Krejci5536d282020-08-04 23:27:44 +0200509 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100510 ly_print_(pctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200511 LEVEL_PRINTED;
512 }
513
514 return LY_SUCCESS;
515}
516
517/**
518 * @brief Print leaf data node including its metadata.
519 *
520 * @param[in] ctx JSON printer context.
521 * @param[in] node Data node to print.
522 * @return LY_ERR value.
523 */
524static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100525json_print_leaf(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200526{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100527 LY_CHECK_RET(json_print_member(pctx, node, 0));
Michal Vasko32f067f2023-06-01 12:31:14 +0200528 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 +0200529 LEVEL_PRINTED;
530
531 /* print attributes as sibling */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100532 json_print_attributes(pctx, node, 0);
Radek Krejci5536d282020-08-04 23:27:44 +0200533
534 return LY_SUCCESS;
535}
536
537/**
Michal Vaskobbdadda2022-01-06 11:40:10 +0100538 * @brief Print anydata/anyxml content.
Radek Krejci5536d282020-08-04 23:27:44 +0200539 *
540 * @param[in] ctx JSON printer context.
541 * @param[in] any Anydata node to print.
542 * @return LY_ERR value.
543 */
544static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100545json_print_any_content(struct jsonpr_ctx *pctx, struct lyd_node_any *any)
Radek Krejci5536d282020-08-04 23:27:44 +0200546{
547 LY_ERR ret = LY_SUCCESS;
548 struct lyd_node *iter;
Michal Vasko26743a22022-03-29 14:48:10 +0200549 const struct lyd_node *prev_parent;
Michal Vaskod4a6d042022-12-08 08:34:29 +0100550 uint32_t prev_opts, temp_lo = 0;
Radek Krejci5536d282020-08-04 23:27:44 +0200551
Michal Vasko76096ec2022-02-24 16:06:16 +0100552 assert(any->schema->nodetype & LYD_NODE_ANY);
Radek Krejci5536d282020-08-04 23:27:44 +0200553
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100554 if ((any->schema->nodetype == LYS_ANYDATA) && (any->value_type != LYD_ANYDATA_DATATREE)) {
555 LOGINT_RET(pctx->ctx);
556 }
557
Radek Krejci5536d282020-08-04 23:27:44 +0200558 if (any->value_type == LYD_ANYDATA_LYB) {
Radek Krejci1deb5be2020-08-26 16:43:36 +0200559 uint32_t parser_options = LYD_PARSE_ONLY | LYD_PARSE_OPAQ | LYD_PARSE_STRICT;
Radek Krejci5536d282020-08-04 23:27:44 +0200560
561 /* turn logging off */
Michal Vaskod4a6d042022-12-08 08:34:29 +0100562 ly_temp_log_options(&temp_lo);
Radek Krejci5536d282020-08-04 23:27:44 +0200563
564 /* try to parse it into a data tree */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100565 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 +0200566 /* successfully parsed */
567 free(any->value.mem);
568 any->value.tree = iter;
569 any->value_type = LYD_ANYDATA_DATATREE;
570 }
571
Michal Vaskod4a6d042022-12-08 08:34:29 +0100572 /* turn logging on again */
573 ly_temp_log_options(NULL);
Radek Krejci5536d282020-08-04 23:27:44 +0200574 }
575
576 switch (any->value_type) {
577 case LYD_ANYDATA_DATATREE:
Michal Vasko76096ec2022-02-24 16:06:16 +0100578 /* print as an object */
579 ly_print_(pctx->out, "{%s", DO_FORMAT ? "\n" : "");
580 LEVEL_INC;
Michal Vaskobbdadda2022-01-06 11:40:10 +0100581
Radek Krejci5536d282020-08-04 23:27:44 +0200582 /* close opening tag and print data */
Michal Vasko26743a22022-03-29 14:48:10 +0200583 prev_parent = pctx->parent;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100584 prev_opts = pctx->options;
Michal Vasko26743a22022-03-29 14:48:10 +0200585 pctx->parent = &any->node;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100586 pctx->options &= ~LYD_PRINT_WITHSIBLINGS;
Radek Krejci5536d282020-08-04 23:27:44 +0200587 LY_LIST_FOR(any->value.tree, iter) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100588 ret = json_print_node(pctx, iter);
Radek Krejci5536d282020-08-04 23:27:44 +0200589 LY_CHECK_ERR_RET(ret, LEVEL_DEC, ret);
590 }
Michal Vasko26743a22022-03-29 14:48:10 +0200591 pctx->parent = prev_parent;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100592 pctx->options = prev_opts;
Michal Vaskobbdadda2022-01-06 11:40:10 +0100593
Michal Vasko76096ec2022-02-24 16:06:16 +0100594 /* terminate the object */
Michal Vasko23b51a82022-03-29 14:22:34 +0200595 LEVEL_DEC;
Michal Vasko76096ec2022-02-24 16:06:16 +0100596 if (DO_FORMAT) {
597 ly_print_(pctx->out, "\n%*s}", INDENT);
598 } else {
599 ly_print_(pctx->out, "}");
Michal Vaskobbdadda2022-01-06 11:40:10 +0100600 }
Radek Krejci5536d282020-08-04 23:27:44 +0200601 break;
602 case LYD_ANYDATA_JSON:
Michal Vasko76096ec2022-02-24 16:06:16 +0100603 if (!any->value.json) {
604 /* no content */
605 if (any->schema->nodetype == LYS_ANYXML) {
606 ly_print_(pctx->out, "null");
607 } else {
608 ly_print_(pctx->out, "{}");
609 }
610 } else {
611 /* print without escaping special characters */
612 ly_print_(pctx->out, "%s", any->value.json);
Radek Krejci5536d282020-08-04 23:27:44 +0200613 }
Radek Krejci5536d282020-08-04 23:27:44 +0200614 break;
615 case LYD_ANYDATA_STRING:
616 case LYD_ANYDATA_XML:
Michal Vasko76096ec2022-02-24 16:06:16 +0100617 if (!any->value.str) {
618 /* no content */
619 if (any->schema->nodetype == LYS_ANYXML) {
620 ly_print_(pctx->out, "null");
621 } else {
622 ly_print_(pctx->out, "{}");
623 }
624 } else {
Michal Vaskobbdadda2022-01-06 11:40:10 +0100625 /* print as a string */
Michal Vaskoe3ed7dc2022-11-30 11:39:44 +0100626 json_print_string(pctx->out, any->value.str);
Michal Vaskobbdadda2022-01-06 11:40:10 +0100627 }
Michal Vasko76096ec2022-02-24 16:06:16 +0100628 break;
Radek Krejci5536d282020-08-04 23:27:44 +0200629 case LYD_ANYDATA_LYB:
Michal Vasko76096ec2022-02-24 16:06:16 +0100630 /* LYB format is not supported */
631 LOGWRN(pctx->ctx, "Unable to print anydata content (type %d) as JSON.", any->value_type);
Michal Vaskobbdadda2022-01-06 11:40:10 +0100632 break;
Radek Krejci5536d282020-08-04 23:27:44 +0200633 }
634
635 return LY_SUCCESS;
636}
637
638/**
Michal Vasko76096ec2022-02-24 16:06:16 +0100639 * @brief Print content of a single container/list data node including its metadata.
Michal Vaskobbdadda2022-01-06 11:40:10 +0100640 * The envelope specific to nodes are expected to be printed by the caller.
Radek Krejci5536d282020-08-04 23:27:44 +0200641 *
642 * @param[in] ctx JSON printer context.
643 * @param[in] node Data node to print.
644 * @return LY_ERR value.
645 */
646static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100647json_print_inner(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200648{
649 struct lyd_node *child;
Michal Vasko26743a22022-03-29 14:48:10 +0200650 const struct lyd_node *prev_parent;
Michal Vasko23b51a82022-03-29 14:22:34 +0200651 struct lyd_node_opaq *opaq = NULL;
Radek Krejci857189e2020-09-01 13:26:36 +0200652 ly_bool has_content = 0;
Radek Krejci5536d282020-08-04 23:27:44 +0200653
Michal Vasko630d9892020-12-08 17:11:08 +0100654 LY_LIST_FOR(lyd_child(node), child) {
Michal Vasko8db584d2022-03-30 13:42:48 +0200655 if (lyd_node_should_print(child, pctx->options)) {
Michal Vasko630d9892020-12-08 17:11:08 +0100656 break;
657 }
658 }
659 if (node->meta || child) {
Radek Krejci5536d282020-08-04 23:27:44 +0200660 has_content = 1;
Radek Krejci5536d282020-08-04 23:27:44 +0200661 }
Michal Vasko23b51a82022-03-29 14:22:34 +0200662 if (!node->schema) {
663 opaq = (struct lyd_node_opaq *)node;
664 }
Radek Krejci5536d282020-08-04 23:27:44 +0200665
Michal Vasko1a85d332021-08-27 10:35:28 +0200666 if ((node->schema && (node->schema->nodetype == LYS_LIST)) ||
Michal Vasko23b51a82022-03-29 14:22:34 +0200667 (opaq && (opaq->hints != LYD_HINT_DATA) && (opaq->hints & LYD_NODEHINT_LIST))) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100668 ly_print_(pctx->out, "%s%*s{%s", (is_open_array(pctx, node) && (pctx->level_printed >= pctx->level)) ?
Michal Vasko1a85d332021-08-27 10:35:28 +0200669 (DO_FORMAT ? ",\n" : ",") : "", INDENT, (DO_FORMAT && has_content) ? "\n" : "");
670 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100671 ly_print_(pctx->out, "%s{%s", (is_open_array(pctx, node) && (pctx->level_printed >= pctx->level)) ? "," : "",
Radek Krejci0f969882020-08-21 16:56:47 +0200672 (DO_FORMAT && has_content) ? "\n" : "");
Radek Krejci5536d282020-08-04 23:27:44 +0200673 }
674 LEVEL_INC;
675
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100676 json_print_attributes(pctx, node, 1);
Radek Krejci5536d282020-08-04 23:27:44 +0200677
Michal Vasko76096ec2022-02-24 16:06:16 +0100678 /* print children */
Michal Vasko26743a22022-03-29 14:48:10 +0200679 prev_parent = pctx->parent;
680 pctx->parent = node;
Michal Vasko76096ec2022-02-24 16:06:16 +0100681 LY_LIST_FOR(lyd_child(node), child) {
682 LY_CHECK_RET(json_print_node(pctx, child));
Radek Krejci5536d282020-08-04 23:27:44 +0200683 }
Michal Vasko26743a22022-03-29 14:48:10 +0200684 pctx->parent = prev_parent;
Radek Krejci5536d282020-08-04 23:27:44 +0200685
Radek Krejci5536d282020-08-04 23:27:44 +0200686 LEVEL_DEC;
687 if (DO_FORMAT && has_content) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100688 ly_print_(pctx->out, "\n%*s}", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200689 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100690 ly_print_(pctx->out, "}");
Radek Krejci5536d282020-08-04 23:27:44 +0200691 }
692 LEVEL_PRINTED;
693
694 return LY_SUCCESS;
695}
696
697/**
698 * @brief Print container data node including its metadata.
699 *
700 * @param[in] ctx JSON printer context.
701 * @param[in] node Data node to print.
702 * @return LY_ERR value.
703 */
704static int
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100705json_print_container(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200706{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100707 LY_CHECK_RET(json_print_member(pctx, node, 0));
708 LY_CHECK_RET(json_print_inner(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200709
710 return LY_SUCCESS;
711}
712
713/**
Michal Vasko76096ec2022-02-24 16:06:16 +0100714 * @brief Print anydata/anyxml data node including its metadata.
Michal Vaskobbdadda2022-01-06 11:40:10 +0100715 *
716 * @param[in] ctx JSON printer context.
717 * @param[in] node Data node to print.
718 * @return LY_ERR value.
719 */
720static int
Michal Vasko76096ec2022-02-24 16:06:16 +0100721json_print_any(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Michal Vaskobbdadda2022-01-06 11:40:10 +0100722{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100723 LY_CHECK_RET(json_print_member(pctx, node, 0));
724 LY_CHECK_RET(json_print_any_content(pctx, (struct lyd_node_any *)node));
Michal Vaskobbdadda2022-01-06 11:40:10 +0100725 LEVEL_PRINTED;
726
727 /* print attributes as sibling */
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100728 json_print_attributes(pctx, node, 0);
Michal Vaskobbdadda2022-01-06 11:40:10 +0100729
730 return LY_SUCCESS;
731}
732
733/**
Michal Vaskoaa22f422021-12-02 10:48:32 +0100734 * @brief Check whether a node is the last printed instance of a (leaf-)list.
735 *
736 * @param[in] ctx JSON printer context.
737 * @param[in] node Last printed node.
738 * @return Whether it is the last printed instance or not.
739 */
740static ly_bool
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100741json_print_array_is_last_inst(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Michal Vaskoaa22f422021-12-02 10:48:32 +0100742{
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100743 if (!is_open_array(pctx, node)) {
Michal Vasko06217f32021-12-09 09:25:50 +0100744 /* no array open */
745 return 0;
746 }
747
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100748 if ((pctx->root == node) && !(pctx->options & LYD_PRINT_WITHSIBLINGS)) {
Michal Vaskoaa22f422021-12-02 10:48:32 +0100749 /* the only printed instance */
750 return 1;
751 }
752
Michal Vasko06217f32021-12-09 09:25:50 +0100753 if (!node->next || (node->next->schema != node->schema)) {
Michal Vaskoaa22f422021-12-02 10:48:32 +0100754 /* last instance */
755 return 1;
756 }
757
758 return 0;
759}
760
761/**
Radek Krejci5536d282020-08-04 23:27:44 +0200762 * @brief Print single leaf-list or list instance.
763 *
764 * In case of list, metadata are printed inside the list object. For the leaf-list,
765 * metadata are marked in the context for later printing after closing the array next to it using
766 * json_print_metadata_leaflist().
767 *
768 * @param[in] ctx JSON printer context.
769 * @param[in] node Data node to print.
770 * @return LY_ERR value.
771 */
772static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100773json_print_leaf_list(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200774{
Michal Vasko57c8d432022-11-30 15:35:56 +0100775 const struct lys_module *wdmod = NULL;
776
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100777 if (!is_open_array(pctx, node)) {
778 LY_CHECK_RET(json_print_member(pctx, node, 0));
779 LY_CHECK_RET(json_print_array_open(pctx, node));
Radek Krejciee74a192021-04-09 09:55:34 +0200780 if (node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100781 ly_print_(pctx->out, "%*s", INDENT);
Radek Krejciee74a192021-04-09 09:55:34 +0200782 }
Radek Krejci5536d282020-08-04 23:27:44 +0200783 } else if (node->schema->nodetype == LYS_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100784 ly_print_(pctx->out, ",%s%*s", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200785 }
786
787 if (node->schema->nodetype == LYS_LIST) {
Michal Vasko2fe10342022-12-01 11:54:02 +0100788 /* print list's content */
789 LY_CHECK_RET(json_print_inner(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200790 } else {
791 assert(node->schema->nodetype == LYS_LEAFLIST);
Michal Vasko57c8d432022-11-30 15:35:56 +0100792
Michal Vasko32f067f2023-06-01 12:31:14 +0200793 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 +0200794
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200795 if (!pctx->first_leaflist) {
Michal Vasko57c8d432022-11-30 15:35:56 +0100796 if ((node->flags & LYD_DEFAULT) && (pctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG))) {
797 /* we have implicit OR explicit default node, get with-defaults module */
798 wdmod = ly_ctx_get_module_implemented(LYD_CTX(node), "ietf-netconf-with-defaults");
799 }
800 if (node->meta || wdmod) {
801 /* we will be printing metadata for these siblings */
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200802 pctx->first_leaflist = node;
Michal Vasko57c8d432022-11-30 15:35:56 +0100803 }
Radek Krejci5536d282020-08-04 23:27:44 +0200804 }
805 }
806
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100807 if (json_print_array_is_last_inst(pctx, node)) {
808 json_print_array_close(pctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200809 }
810
811 return LY_SUCCESS;
812}
813
814/**
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200815 * @brief Print leaf-list's metadata or opaque nodes attributes.
Radek Krejci5536d282020-08-04 23:27:44 +0200816 * This function is supposed to be called when the leaf-list array is closed.
817 *
818 * @param[in] ctx JSON printer context.
819 * @return LY_ERR value.
820 */
821static LY_ERR
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200822json_print_meta_attr_leaflist(struct jsonpr_ctx *pctx)
Radek Krejci5536d282020-08-04 23:27:44 +0200823{
824 const struct lyd_node *prev, *node, *iter;
Michal Vasko57c8d432022-11-30 15:35:56 +0100825 const struct lys_module *wdmod = NULL;
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200826 const struct lyd_node_opaq *opaq = NULL;
Radek Krejci5536d282020-08-04 23:27:44 +0200827
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200828 assert(pctx->first_leaflist);
Radek Krejci5536d282020-08-04 23:27:44 +0200829
Michal Vasko57c8d432022-11-30 15:35:56 +0100830 if (pctx->options & (LYD_PRINT_WD_ALL_TAG | LYD_PRINT_WD_IMPL_TAG)) {
831 /* get with-defaults module */
832 wdmod = ly_ctx_get_module_implemented(pctx->ctx, "ietf-netconf-with-defaults");
833 }
834
835 /* node is the first instance of the leaf-list */
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200836 for (node = pctx->first_leaflist, prev = pctx->first_leaflist->prev;
Radek Krejci5536d282020-08-04 23:27:44 +0200837 prev->next && matching_node(node, prev);
838 node = prev, prev = node->prev) {}
839
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200840 if (node->schema) {
841 LY_CHECK_RET(json_print_member(pctx, node, 1));
842 } else {
843 opaq = (struct lyd_node_opaq *)node;
844 LY_CHECK_RET(json_print_member2(pctx, lyd_parent(node), opaq->format, &opaq->name, 1));
845 }
846
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100847 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 Vaskoa4e5eb42023-09-18 08:44:21 +0200851 if ((iter->schema && (iter->meta || (iter->flags & LYD_DEFAULT))) || (opaq && opaq->attr)) {
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 Vaskoa4e5eb42023-09-18 08:44:21 +0200854
855 if (iter->schema) {
856 LY_CHECK_RET(json_print_metadata(pctx, iter, (iter->flags & LYD_DEFAULT) ? wdmod : NULL));
857 } else {
858 LY_CHECK_RET(json_print_attribute(pctx, (struct lyd_node_opaq *)iter));
859 }
860
Radek Krejci5536d282020-08-04 23:27:44 +0200861 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100862 ly_print_(pctx->out, "%s%*s}", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200863 } else {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100864 ly_print_(pctx->out, "null");
Radek Krejci5536d282020-08-04 23:27:44 +0200865 }
866 LEVEL_PRINTED;
867 if (!matching_node(iter, iter->next)) {
868 break;
869 }
870 }
871 LEVEL_DEC;
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100872 ly_print_(pctx->out, "%s%*s]", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200873 LEVEL_PRINTED;
874
875 return LY_SUCCESS;
876}
877
878/**
879 * @brief Print opaq data node including its attributes.
880 *
881 * @param[in] ctx JSON printer context.
882 * @param[in] node Opaq node to print.
883 * @return LY_ERR value.
884 */
885static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100886json_print_opaq(struct jsonpr_ctx *pctx, const struct lyd_node_opaq *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200887{
Radek Krejci857189e2020-09-01 13:26:36 +0200888 ly_bool first = 1, last = 1;
Radek Krejci5536d282020-08-04 23:27:44 +0200889
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200890 if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
Michal Vasko9e685082021-01-29 14:49:09 +0100891 if (node->prev->next && matching_node(node->prev, &node->node)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200892 first = 0;
893 }
Michal Vasko9e685082021-01-29 14:49:09 +0100894 if (node->next && matching_node(&node->node, node->next)) {
Radek Krejci5536d282020-08-04 23:27:44 +0200895 last = 0;
896 }
897 }
898
899 if (first) {
Michal Vasko26743a22022-03-29 14:48:10 +0200900 LY_CHECK_RET(json_print_member2(pctx, pctx->parent, node->format, &node->name, 0));
Radek Krejci5536d282020-08-04 23:27:44 +0200901
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200902 if (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100903 LY_CHECK_RET(json_print_array_open(pctx, &node->node));
Radek Krejci5536d282020-08-04 23:27:44 +0200904 }
Michal Vasko1a85d332021-08-27 10:35:28 +0200905 if (node->hints & LYD_NODEHINT_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100906 ly_print_(pctx->out, "%*s", INDENT);
Michal Vasko1a85d332021-08-27 10:35:28 +0200907 }
908 } else if (node->hints & LYD_NODEHINT_LEAFLIST) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100909 ly_print_(pctx->out, ",%s%*s", DO_FORMAT ? "\n" : "", INDENT);
Radek Krejci5536d282020-08-04 23:27:44 +0200910 }
Michal Vasko1a85d332021-08-27 10:35:28 +0200911 if (node->child || (node->hints & LYD_NODEHINT_LIST)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100912 LY_CHECK_RET(json_print_inner(pctx, &node->node));
Radek Krejci5536d282020-08-04 23:27:44 +0200913 LEVEL_PRINTED;
914 } else {
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200915 if (node->hints & LYD_VALHINT_EMPTY) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100916 ly_print_(pctx->out, "[null]");
Michal Vaskocea58712022-04-01 14:37:08 +0200917 } else if ((node->hints & (LYD_VALHINT_BOOLEAN | LYD_VALHINT_DECNUM)) && !(node->hints & LYD_VALHINT_NUM64)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100918 ly_print_(pctx->out, "%s", node->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200919 } else {
Michal Vaskocea58712022-04-01 14:37:08 +0200920 /* string or a large number */
Michal Vasko5e2742d2023-05-25 10:01:42 +0200921 json_print_string(pctx->out, node->value);
Radek Krejci5536d282020-08-04 23:27:44 +0200922 }
923 LEVEL_PRINTED;
924
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200925 if (!(node->hints & LYD_NODEHINT_LEAFLIST)) {
926 /* attributes */
927 json_print_attributes(pctx, (const struct lyd_node *)node, 0);
928 } else if (!pctx->first_leaflist && node->attr) {
929 /* attributes printed later */
930 pctx->first_leaflist = &node->node;
931 }
Radek Krejci5536d282020-08-04 23:27:44 +0200932
933 }
Michal Vaskofeca4fb2020-10-05 08:58:40 +0200934 if (last && (node->hints & (LYD_NODEHINT_LIST | LYD_NODEHINT_LEAFLIST))) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100935 json_print_array_close(pctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200936 LEVEL_PRINTED;
937 }
938
939 return LY_SUCCESS;
940}
941
942/**
943 * @brief Print all the types of data node including its metadata.
944 *
945 * @param[in] ctx JSON printer context.
946 * @param[in] node Data node to print.
947 * @return LY_ERR value.
948 */
949static LY_ERR
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100950json_print_node(struct jsonpr_ctx *pctx, const struct lyd_node *node)
Radek Krejci5536d282020-08-04 23:27:44 +0200951{
Michal Vasko8db584d2022-03-30 13:42:48 +0200952 if (!lyd_node_should_print(node, pctx->options)) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100953 if (json_print_array_is_last_inst(pctx, node)) {
954 json_print_array_close(pctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200955 }
956 return LY_SUCCESS;
957 }
958
959 if (!node->schema) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100960 LY_CHECK_RET(json_print_opaq(pctx, (const struct lyd_node_opaq *)node));
Radek Krejci5536d282020-08-04 23:27:44 +0200961 } else {
962 switch (node->schema->nodetype) {
963 case LYS_RPC:
964 case LYS_ACTION:
965 case LYS_NOTIF:
966 case LYS_CONTAINER:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100967 LY_CHECK_RET(json_print_container(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200968 break;
969 case LYS_LEAF:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100970 LY_CHECK_RET(json_print_leaf(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200971 break;
972 case LYS_LEAFLIST:
973 case LYS_LIST:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100974 LY_CHECK_RET(json_print_leaf_list(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200975 break;
Michal Vasko76096ec2022-02-24 16:06:16 +0100976 case LYS_ANYDATA:
Radek Krejci5536d282020-08-04 23:27:44 +0200977 case LYS_ANYXML:
Michal Vasko76096ec2022-02-24 16:06:16 +0100978 LY_CHECK_RET(json_print_any(pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +0200979 break;
980 default:
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100981 LOGINT(pctx->ctx);
Radek Krejci5536d282020-08-04 23:27:44 +0200982 return EXIT_FAILURE;
983 }
984 }
985
Michal Vasko61ad1ff2022-02-10 15:48:39 +0100986 pctx->level_printed = pctx->level;
Radek Krejci5536d282020-08-04 23:27:44 +0200987
Michal Vaskoa4e5eb42023-09-18 08:44:21 +0200988 if (pctx->first_leaflist && !matching_node(node->next, pctx->first_leaflist)) {
989 json_print_meta_attr_leaflist(pctx);
990 pctx->first_leaflist = NULL;
Radek Krejci5536d282020-08-04 23:27:44 +0200991 }
992
993 return LY_SUCCESS;
994}
995
996LY_ERR
Radek Krejci1deb5be2020-08-26 16:43:36 +0200997json_print_data(struct ly_out *out, const struct lyd_node *root, uint32_t options)
Radek Krejci5536d282020-08-04 23:27:44 +0200998{
999 const struct lyd_node *node;
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001000 struct jsonpr_ctx pctx = {0};
Radek Krejci52f65552020-09-01 17:03:35 +02001001 const char *delimiter = (options & LYD_PRINT_SHRINK) ? "" : "\n";
Radek Krejci5536d282020-08-04 23:27:44 +02001002
Radek Krejci2e874772020-08-28 16:36:33 +02001003 if (!root) {
1004 ly_print_(out, "{}%s", delimiter);
1005 ly_print_flush(out);
1006 return LY_SUCCESS;
1007 }
1008
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001009 pctx.out = out;
Michal Vasko26743a22022-03-29 14:48:10 +02001010 pctx.parent = NULL;
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001011 pctx.level = 1;
1012 pctx.level_printed = 0;
1013 pctx.options = options;
1014 pctx.ctx = LYD_CTX(root);
Radek Krejci5536d282020-08-04 23:27:44 +02001015
1016 /* start */
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001017 ly_print_(pctx.out, "{%s", delimiter);
Radek Krejci5536d282020-08-04 23:27:44 +02001018
1019 /* content */
1020 LY_LIST_FOR(root, node) {
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001021 pctx.root = node;
1022 LY_CHECK_RET(json_print_node(&pctx, node));
Radek Krejci5536d282020-08-04 23:27:44 +02001023 if (!(options & LYD_PRINT_WITHSIBLINGS)) {
1024 break;
1025 }
1026 }
1027
1028 /* end */
Michal Vasko5233e962020-08-14 14:26:20 +02001029 ly_print_(out, "%s}%s", delimiter, delimiter);
Radek Krejci5536d282020-08-04 23:27:44 +02001030
Michal Vasko61ad1ff2022-02-10 15:48:39 +01001031 assert(!pctx.open.count);
1032 ly_set_erase(&pctx.open, NULL);
Radek Krejci5536d282020-08-04 23:27:44 +02001033
1034 ly_print_flush(out);
1035 return LY_SUCCESS;
1036}