blob: 0e8950020a45940e16ebbbad245355edf2c13576 [file] [log] [blame]
Radek Krejcid3ca0632019-04-16 16:54:54 +02001/**
2 * @file printer.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Radek Krejcie7b95092019-05-15 11:03:07 +02004 * @brief Generic libyang printers functions.
Radek Krejcid3ca0632019-04-16 16:54:54 +02005 *
6 * Copyright (c) 2015 - 2019 CESNET, z.s.p.o.
7 *
8 * This source code is licensed under BSD 3-Clause License (the "License").
9 * You may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * https://opensource.org/licenses/BSD-3-Clause
13 */
14
Radek Krejci535ea9f2020-05-29 16:01:05 +020015#define _GNU_SOURCE
Radek Krejcid3ca0632019-04-16 16:54:54 +020016
Radek Krejci535ea9f2020-05-29 16:01:05 +020017#include "printer.h"
18
19#include <assert.h>
Radek Krejcid3ca0632019-04-16 16:54:54 +020020#include <errno.h>
21#include <stdarg.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <stdio.h>
23#include <stdlib.h>
Radek Krejcid3ca0632019-04-16 16:54:54 +020024#include <string.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020025#include <unistd.h>
Radek Krejcid3ca0632019-04-16 16:54:54 +020026
Radek Krejci535ea9f2020-05-29 16:01:05 +020027#include "common.h"
Michal Vasko5aa44c02020-06-29 11:47:02 +020028#include "compat.h"
Radek Krejcie7b95092019-05-15 11:03:07 +020029#include "log.h"
Michal Vasko9b368d32020-02-14 13:53:31 +010030#include "plugins_types.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020031#include "printer_data.h"
32#include "printer_internal.h"
33#include "tree.h"
34#include "tree_schema.h"
Radek Krejcid3ca0632019-04-16 16:54:54 +020035
36/**
37 * @brief informational structure shared by printers
38 */
39struct ext_substmt_info_s ext_substmt_info[] = {
40 {NULL, NULL, 0}, /**< LYEXT_SUBSTMT_SELF */
41 {"argument", "name", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_ARGUMENT */
42 {"base", "name", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_BASE */
43 {"belongs-to", "module", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_BELONGSTO */
44 {"contact", "text", SUBST_FLAG_YIN}, /**< LYEXT_SUBSTMT_CONTACT */
45 {"default", "value", 0}, /**< LYEXT_SUBSTMT_DEFAULT */
46 {"description", "text", SUBST_FLAG_YIN}, /**< LYEXT_SUBSTMT_DESCRIPTION */
47 {"error-app-tag", "value", 0}, /**< LYEXT_SUBSTMT_ERRTAG */
48 {"error-message", "value", SUBST_FLAG_YIN}, /**< LYEXT_SUBSTMT_ERRMSG */
49 {"key", "value", 0}, /**< LYEXT_SUBSTMT_KEY */
50 {"namespace", "uri", 0}, /**< LYEXT_SUBSTMT_NAMESPACE */
51 {"organization", "text", SUBST_FLAG_YIN}, /**< LYEXT_SUBSTMT_ORGANIZATION */
52 {"path", "value", 0}, /**< LYEXT_SUBSTMT_PATH */
53 {"prefix", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_PREFIX */
54 {"presence", "value", 0}, /**< LYEXT_SUBSTMT_PRESENCE */
55 {"reference", "text", SUBST_FLAG_YIN}, /**< LYEXT_SUBSTMT_REFERENCE */
56 {"revision-date", "date", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_REVISIONDATE */
57 {"units", "name", 0}, /**< LYEXT_SUBSTMT_UNITS */
58 {"value", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_VALUE */
59 {"yang-version", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_VERSION */
60 {"modifier", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_MODIFIER */
61 {"require-instance", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_REQINST */
62 {"yin-element", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_YINELEM */
63 {"config", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_CONFIG */
64 {"mandatory", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_MANDATORY */
65 {"ordered-by", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_ORDEREDBY */
66 {"status", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_STATUS */
67 {"fraction-digits", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_DIGITS */
68 {"max-elements", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_MAX */
69 {"min-elements", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_MIN */
70 {"position", "value", SUBST_FLAG_ID}, /**< LYEXT_SUBSTMT_POSITION */
71 {"unique", "tag", 0}, /**< LYEXT_SUBSTMT_UNIQUE */
72};
73
Michal Vasko6f4cbb62020-02-28 11:15:47 +010074int
Michal Vasko9b368d32020-02-14 13:53:31 +010075ly_is_default(const struct lyd_node *node)
76{
77 const struct lysc_node_leaf *leaf;
78 const struct lysc_node_leaflist *llist;
79 const struct lyd_node_term *term;
Michal Vaskofd69e1d2020-07-03 11:57:17 +020080 LY_ARRAY_COUNT_TYPE u;
Michal Vasko9b368d32020-02-14 13:53:31 +010081
82 assert(node->schema->nodetype & LYD_NODE_TERM);
83 term = (const struct lyd_node_term *)node;
84
85 if (node->schema->nodetype == LYS_LEAF) {
86 leaf = (const struct lysc_node_leaf *)node->schema;
87 if (!leaf->dflt) {
88 return 0;
89 }
90
91 /* compare with the default value */
92 if (leaf->type->plugin->compare(&term->value, leaf->dflt)) {
93 return 0;
94 }
95 } else {
96 llist = (const struct lysc_node_leaflist *)node->schema;
97 if (!llist->dflts) {
98 return 0;
99 }
100
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200101 LY_ARRAY_FOR(llist->dflts, u) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100102 /* compare with each possible default value */
Radek Krejci7eb54ba2020-05-18 16:30:04 +0200103 if (llist->type->plugin->compare(&term->value, llist->dflts[u])) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100104 return 0;
105 }
106 }
107 }
108
109 return 1;
110}
111
112int
113ly_should_print(const struct lyd_node *node, int options)
114{
115 const struct lyd_node *next, *elem;
116
Radek Krejci7931b192020-06-25 17:05:03 +0200117 if (options & LYD_PRINT_WD_TRIM) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100118 /* do not print default nodes */
119 if (node->flags & LYD_DEFAULT) {
120 /* implicit default node/NP container with only default nodes */
121 return 0;
122 } else if (node->schema->nodetype & LYD_NODE_TERM) {
123 if (ly_is_default(node)) {
124 /* explicit default node */
125 return 0;
126 }
127 }
Radek Krejci7931b192020-06-25 17:05:03 +0200128 } else if ((node->flags & LYD_DEFAULT) && !(options & LYD_PRINT_WD_MASK) && !(node->schema->flags & LYS_CONFIG_R)) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200129 /* LYDP_WD_EXPLICIT
Michal Vasko9b368d32020-02-14 13:53:31 +0100130 * - print only if it contains status data in its subtree */
131 LYD_TREE_DFS_BEGIN(node, next, elem) {
Michal Vaskodb4f9e42020-06-01 17:29:56 +0200132 if ((elem->schema->nodetype != LYS_CONTAINER) || (elem->schema->flags & LYS_PRESENCE)) {
133 if (elem->schema->flags & LYS_CONFIG_R) {
134 return 1;
135 }
Michal Vasko9b368d32020-02-14 13:53:31 +0100136 }
137 LYD_TREE_DFS_END(node, next, elem)
138 }
139 return 0;
Radek Krejci7931b192020-06-25 17:05:03 +0200140 } else if ((node->flags & LYD_DEFAULT) && (node->schema->nodetype == LYS_CONTAINER) && !(options & LYD_PRINT_KEEPEMPTYCONT)) {
Michal Vasko9b368d32020-02-14 13:53:31 +0100141 /* avoid empty default containers */
142 LYD_TREE_DFS_BEGIN(node, next, elem) {
143 if (elem->schema->nodetype != LYS_CONTAINER) {
144 return 1;
145 }
146 assert(elem->flags & LYD_DEFAULT);
147 LYD_TREE_DFS_END(node, next, elem)
148 }
149 return 0;
150 }
151
152 return 1;
153}
154
Radek Krejci241f6b52020-05-21 18:13:49 +0200155API LY_OUT_TYPE
156ly_out_type(const struct ly_out *out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100157{
Radek Krejci241f6b52020-05-21 18:13:49 +0200158 LY_CHECK_ARG_RET(NULL, out, LY_OUT_ERROR);
Radek Krejcia5bba312020-01-09 15:41:20 +0100159 return out->type;
160}
161
Radek Krejci84ce7b12020-06-11 17:28:25 +0200162API LY_ERR
163ly_out_new_clb(ssize_t (*writeclb)(void *arg, const void *buf, size_t count), void *arg, struct ly_out **out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100164{
Radek Krejci84ce7b12020-06-11 17:28:25 +0200165 LY_CHECK_ARG_RET(NULL, out, writeclb, LY_EINVAL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100166
Radek Krejci84ce7b12020-06-11 17:28:25 +0200167 *out = calloc(1, sizeof **out);
168 LY_CHECK_ERR_RET(!*out, LOGMEM(NULL), LY_EMEM);
Radek Krejcia5bba312020-01-09 15:41:20 +0100169
Radek Krejci84ce7b12020-06-11 17:28:25 +0200170 (*out)->type = LY_OUT_CALLBACK;
171 (*out)->method.clb.func = writeclb;
172 (*out)->method.clb.arg = arg;
Radek Krejcia5bba312020-01-09 15:41:20 +0100173
Radek Krejci84ce7b12020-06-11 17:28:25 +0200174 return LY_SUCCESS;
Radek Krejcia5bba312020-01-09 15:41:20 +0100175}
176
Radek Krejci241f6b52020-05-21 18:13:49 +0200177API ssize_t (*ly_out_clb(struct ly_out *out, ssize_t (*writeclb)(void *arg, const void *buf, size_t count)))(void *arg, const void *buf, size_t count)
Radek Krejcia5bba312020-01-09 15:41:20 +0100178{
179 void *prev_clb;
180
Radek Krejci241f6b52020-05-21 18:13:49 +0200181 LY_CHECK_ARG_RET(NULL, out, out->type == LY_OUT_CALLBACK, NULL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100182
183 prev_clb = out->method.clb.func;
184
185 if (writeclb) {
186 out->method.clb.func = writeclb;
187 }
188
189 return prev_clb;
190}
191
192API void *
Radek Krejci241f6b52020-05-21 18:13:49 +0200193ly_out_clb_arg(struct ly_out *out, void *arg)
Radek Krejcia5bba312020-01-09 15:41:20 +0100194{
195 void *prev_arg;
196
Radek Krejci241f6b52020-05-21 18:13:49 +0200197 LY_CHECK_ARG_RET(NULL, out, out->type == LY_OUT_CALLBACK, NULL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100198
199 prev_arg = out->method.clb.arg;
200
201 if (arg) {
202 out->method.clb.arg = arg;
203 }
204
205 return prev_arg;
206}
207
Radek Krejci84ce7b12020-06-11 17:28:25 +0200208API LY_ERR
209ly_out_new_fd(int fd, struct ly_out **out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100210{
Radek Krejci84ce7b12020-06-11 17:28:25 +0200211 LY_CHECK_ARG_RET(NULL, out, fd != -1, LY_EINVAL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100212
Radek Krejci84ce7b12020-06-11 17:28:25 +0200213 *out = calloc(1, sizeof **out);
214 LY_CHECK_ERR_RET(!*out, LOGMEM(NULL), LY_EMEM);
Radek Krejci84ce7b12020-06-11 17:28:25 +0200215 (*out)->type = LY_OUT_FD;
216 (*out)->method.fd = fd;
Radek Krejcia5bba312020-01-09 15:41:20 +0100217
Radek Krejci84ce7b12020-06-11 17:28:25 +0200218 return LY_SUCCESS;
Radek Krejcia5bba312020-01-09 15:41:20 +0100219}
220
221API int
Radek Krejci241f6b52020-05-21 18:13:49 +0200222ly_out_fd(struct ly_out *out, int fd)
Radek Krejcia5bba312020-01-09 15:41:20 +0100223{
224 int prev_fd;
225
Radek Krejci241f6b52020-05-21 18:13:49 +0200226 LY_CHECK_ARG_RET(NULL, out, out->type <= LY_OUT_FDSTREAM, -1);
Radek Krejcia5bba312020-01-09 15:41:20 +0100227
Radek Krejci241f6b52020-05-21 18:13:49 +0200228 if (out->type == LY_OUT_FDSTREAM) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100229 prev_fd = out->method.fdstream.fd;
Radek Krejci241f6b52020-05-21 18:13:49 +0200230 } else { /* LY_OUT_FD */
Radek Krejcia5bba312020-01-09 15:41:20 +0100231 prev_fd = out->method.fd;
232 }
233
234 if (fd != -1) {
235 /* replace output stream */
Radek Krejci241f6b52020-05-21 18:13:49 +0200236 if (out->type == LY_OUT_FDSTREAM) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100237 int streamfd;
238 FILE *stream;
239
240 streamfd = dup(fd);
241 if (streamfd < 0) {
242 LOGERR(NULL, LY_ESYS, "Unable to duplicate provided file descriptor (%d) for printing the output (%s).", fd, strerror(errno));
243 return -1;
244 }
245 stream = fdopen(streamfd, "a");
246 if (!stream) {
247 LOGERR(NULL, LY_ESYS, "Unable to open provided file descriptor (%d) for printing the output (%s).", fd, strerror(errno));
248 close(streamfd);
249 return -1;
250 }
251 /* close only the internally created stream, file descriptor is returned and supposed to be closed by the caller */
252 fclose(out->method.fdstream.f);
253 out->method.fdstream.f = stream;
254 out->method.fdstream.fd = streamfd;
Radek Krejci241f6b52020-05-21 18:13:49 +0200255 } else { /* LY_OUT_FD */
Radek Krejcia5bba312020-01-09 15:41:20 +0100256 out->method.fd = fd;
257 }
258 }
259
260 return prev_fd;
261}
262
Radek Krejci84ce7b12020-06-11 17:28:25 +0200263API LY_ERR
264ly_out_new_file(FILE *f, struct ly_out **out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100265{
Radek Krejci84ce7b12020-06-11 17:28:25 +0200266 LY_CHECK_ARG_RET(NULL, out, f, LY_EINVAL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100267
Radek Krejci84ce7b12020-06-11 17:28:25 +0200268 *out = calloc(1, sizeof **out);
269 LY_CHECK_ERR_RET(!*out, LOGMEM(NULL), LY_EMEM);
Radek Krejcia5bba312020-01-09 15:41:20 +0100270
Radek Krejci84ce7b12020-06-11 17:28:25 +0200271 (*out)->type = LY_OUT_FILE;
272 (*out)->method.f = f;
Radek Krejcia5bba312020-01-09 15:41:20 +0100273
Radek Krejci84ce7b12020-06-11 17:28:25 +0200274 return LY_SUCCESS;
Radek Krejcia5bba312020-01-09 15:41:20 +0100275}
276
277API FILE *
Radek Krejci241f6b52020-05-21 18:13:49 +0200278ly_out_file(struct ly_out *out, FILE *f)
Radek Krejcia5bba312020-01-09 15:41:20 +0100279{
280 FILE *prev_f;
281
Radek Krejci241f6b52020-05-21 18:13:49 +0200282 LY_CHECK_ARG_RET(NULL, out, out->type == LY_OUT_FILE, NULL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100283
284 prev_f = out->method.f;
285
286 if (f) {
287 out->method.f = f;
288 }
289
290 return prev_f;
291}
292
Radek Krejci84ce7b12020-06-11 17:28:25 +0200293API LY_ERR
294ly_out_new_memory(char **strp, size_t size, struct ly_out **out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100295{
Radek Krejci84ce7b12020-06-11 17:28:25 +0200296 LY_CHECK_ARG_RET(NULL, out, strp, LY_EINVAL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100297
Radek Krejci84ce7b12020-06-11 17:28:25 +0200298 *out = calloc(1, sizeof **out);
299 LY_CHECK_ERR_RET(!*out, LOGMEM(NULL), LY_EMEM);
Radek Krejcia5bba312020-01-09 15:41:20 +0100300
Radek Krejci84ce7b12020-06-11 17:28:25 +0200301 (*out)->type = LY_OUT_MEMORY;
302 (*out)->method.mem.buf = strp;
Radek Krejcia5bba312020-01-09 15:41:20 +0100303 if (!size) {
304 /* buffer is supposed to be allocated */
305 *strp = NULL;
306 } else if (*strp) {
307 /* there is already buffer to use */
Radek Krejci84ce7b12020-06-11 17:28:25 +0200308 (*out)->method.mem.size = size;
Radek Krejcia5bba312020-01-09 15:41:20 +0100309 }
310
Radek Krejci84ce7b12020-06-11 17:28:25 +0200311 return LY_SUCCESS;
Radek Krejcia5bba312020-01-09 15:41:20 +0100312}
313
314char *
Radek Krejci241f6b52020-05-21 18:13:49 +0200315ly_out_memory(struct ly_out *out, char **strp, size_t size)
Radek Krejcia5bba312020-01-09 15:41:20 +0100316{
317 char *data;
318
Radek Krejci241f6b52020-05-21 18:13:49 +0200319 LY_CHECK_ARG_RET(NULL, out, out->type == LY_OUT_MEMORY, NULL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100320
321 data = *out->method.mem.buf;
322
323 if (strp) {
324 out->method.mem.buf = strp;
325 out->method.mem.len = out->method.mem.size = 0;
326 out->printed = 0;
327 if (!size) {
328 /* buffer is supposed to be allocated */
329 *strp = NULL;
330 } else if (*strp) {
331 /* there is already buffer to use */
332 out->method.mem.size = size;
333 }
334 }
335
336 return data;
337}
338
339API LY_ERR
Radek Krejci241f6b52020-05-21 18:13:49 +0200340ly_out_reset(struct ly_out *out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100341{
342 LY_CHECK_ARG_RET(NULL, out, LY_EINVAL);
343
344 switch(out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200345 case LY_OUT_ERROR:
Radek Krejcia5bba312020-01-09 15:41:20 +0100346 LOGINT(NULL);
347 return LY_EINT;
Radek Krejci241f6b52020-05-21 18:13:49 +0200348 case LY_OUT_FD:
Radek Krejcia5bba312020-01-09 15:41:20 +0100349 if ((lseek(out->method.fd, 0, SEEK_SET) == -1) && errno != ESPIPE) {
350 LOGERR(NULL, LY_ESYS, "Seeking output file descriptor failed (%s).", strerror(errno));
351 return LY_ESYS;
352 }
Radek Krejcic5a12e12020-05-27 17:09:59 +0200353 if (errno != ESPIPE && ftruncate(out->method.fd, 0) == -1) {
354 LOGERR(NULL, LY_ESYS, "Truncating output file failed (%s).", strerror(errno));
355 return LY_ESYS;
356 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100357 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200358 case LY_OUT_FDSTREAM:
359 case LY_OUT_FILE:
360 case LY_OUT_FILEPATH:
Radek Krejcia5bba312020-01-09 15:41:20 +0100361 if ((fseek(out->method.f, 0, SEEK_SET) == -1) && errno != ESPIPE) {
362 LOGERR(NULL, LY_ESYS, "Seeking output file stream failed (%s).", strerror(errno));
363 return LY_ESYS;
364 }
Radek Krejcic5a12e12020-05-27 17:09:59 +0200365 if (errno != ESPIPE && ftruncate(fileno(out->method.f), 0) == -1) {
366 LOGERR(NULL, LY_ESYS, "Truncating output file failed (%s).", strerror(errno));
367 return LY_ESYS;
368 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100369 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200370 case LY_OUT_MEMORY:
Radek Krejcic5a12e12020-05-27 17:09:59 +0200371 if (out->method.mem.buf && *out->method.mem.buf) {
372 memset(*out->method.mem.buf, 0, out->method.mem.len);
373 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100374 out->printed = 0;
375 out->method.mem.len = 0;
376 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200377 case LY_OUT_CALLBACK:
Radek Krejcia5bba312020-01-09 15:41:20 +0100378 /* nothing to do (not seekable) */
379 break;
380 }
381
382 return LY_SUCCESS;
383}
384
Radek Krejci84ce7b12020-06-11 17:28:25 +0200385API LY_ERR
386ly_out_new_filepath(const char *filepath, struct ly_out **out)
Radek Krejcia5bba312020-01-09 15:41:20 +0100387{
Radek Krejci84ce7b12020-06-11 17:28:25 +0200388 LY_CHECK_ARG_RET(NULL, out, filepath, LY_EINVAL);
Radek Krejcia5bba312020-01-09 15:41:20 +0100389
Radek Krejci84ce7b12020-06-11 17:28:25 +0200390 *out = calloc(1, sizeof **out);
391 LY_CHECK_ERR_RET(!*out, LOGMEM(NULL), LY_EMEM);
Radek Krejcia5bba312020-01-09 15:41:20 +0100392
Radek Krejci84ce7b12020-06-11 17:28:25 +0200393 (*out)->type = LY_OUT_FILEPATH;
394 (*out)->method.fpath.f = fopen(filepath, "w");
395 if (!(*out)->method.fpath.f) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100396 LOGERR(NULL, LY_ESYS, "Failed to open file \"%s\" (%s).", filepath, strerror(errno));
Radek Krejcif6923e82020-07-02 16:36:53 +0200397 free(*out);
398 *out = NULL;
Radek Krejci84ce7b12020-06-11 17:28:25 +0200399 return LY_ESYS;
Radek Krejcia5bba312020-01-09 15:41:20 +0100400 }
Radek Krejci84ce7b12020-06-11 17:28:25 +0200401 (*out)->method.fpath.filepath = strdup(filepath);
402 return LY_SUCCESS;
Radek Krejcia5bba312020-01-09 15:41:20 +0100403}
404
405API const char *
Radek Krejci241f6b52020-05-21 18:13:49 +0200406ly_out_filepath(struct ly_out *out, const char *filepath)
Radek Krejcia5bba312020-01-09 15:41:20 +0100407{
408 FILE *f;
409
Radek Krejci241f6b52020-05-21 18:13:49 +0200410 LY_CHECK_ARG_RET(NULL, out, out->type == LY_OUT_FILEPATH, filepath ? NULL : ((void *)-1));
Radek Krejcia5bba312020-01-09 15:41:20 +0100411
412 if (!filepath) {
413 return out->method.fpath.filepath;
414 }
415
416 /* replace filepath */
417 f = out->method.fpath.f;
418 out->method.fpath.f = fopen(filepath, "w");
419 if (!out->method.fpath.f) {
420 LOGERR(NULL, LY_ESYS, "Failed to open file \"%s\" (%s).", filepath, strerror(errno));
421 out->method.fpath.f = f;
422 return ((void *)-1);
423 }
424 fclose(f);
425 free(out->method.fpath.filepath);
426 out->method.fpath.filepath = strdup(filepath);
427
428 return NULL;
429}
430
431API void
Radek Krejci241f6b52020-05-21 18:13:49 +0200432ly_out_free(struct ly_out *out, void (*clb_arg_destructor)(void *arg), int destroy)
Radek Krejcia5bba312020-01-09 15:41:20 +0100433{
434 if (!out) {
435 return;
436 }
437
438 switch (out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200439 case LY_OUT_CALLBACK:
Radek Krejcia5bba312020-01-09 15:41:20 +0100440 if (clb_arg_destructor) {
441 clb_arg_destructor(out->method.clb.arg);
442 }
443 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200444 case LY_OUT_FDSTREAM:
Radek Krejcia5bba312020-01-09 15:41:20 +0100445 fclose(out->method.fdstream.f);
446 if (destroy) {
447 close(out->method.fdstream.fd);
448 }
449 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200450 case LY_OUT_FD:
Radek Krejcia5bba312020-01-09 15:41:20 +0100451 if (destroy) {
452 close(out->method.fd);
453 }
454 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200455 case LY_OUT_FILE:
Radek Krejcia5bba312020-01-09 15:41:20 +0100456 if (destroy) {
457 fclose(out->method.f);
458 }
459 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200460 case LY_OUT_MEMORY:
Radek Krejcia5bba312020-01-09 15:41:20 +0100461 if (destroy) {
462 free(*out->method.mem.buf);
463 }
464 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200465 case LY_OUT_FILEPATH:
Radek Krejcia5bba312020-01-09 15:41:20 +0100466 free(out->method.fpath.filepath);
Radek Krejci2aae3752020-05-27 18:16:30 +0200467 fclose(out->method.fpath.f);
Radek Krejcia5bba312020-01-09 15:41:20 +0100468 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200469 case LY_OUT_ERROR:
Radek Krejcia5bba312020-01-09 15:41:20 +0100470 LOGINT(NULL);
471 }
472 free(out);
473}
474
Radek Krejcibaeb8382020-05-27 16:44:53 +0200475API ssize_t
Radek Krejci241f6b52020-05-21 18:13:49 +0200476ly_print(struct ly_out *out, const char *format, ...)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200477{
478 int count = 0;
479 char *msg = NULL, *aux;
480 va_list ap;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200481
Radek Krejcibaeb8382020-05-27 16:44:53 +0200482 LYOUT_CHECK(out, -1 * out->status);
Radek Krejci56cc0872019-04-30 09:22:27 +0200483
Radek Krejcid3ca0632019-04-16 16:54:54 +0200484 va_start(ap, format);
485
486 switch (out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200487 case LY_OUT_FD:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200488 count = vdprintf(out->method.fd, format, ap);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200489 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200490 case LY_OUT_FDSTREAM:
491 case LY_OUT_FILEPATH:
492 case LY_OUT_FILE:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200493 count = vfprintf(out->method.f, format, ap);
494 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200495 case LY_OUT_MEMORY:
Radek Krejci897ad2e2019-04-29 16:43:07 +0200496 if ((count = vasprintf(&msg, format, ap)) < 0) {
497 break;
498 }
Radek Krejcid3ca0632019-04-16 16:54:54 +0200499 if (out->method.mem.len + count + 1 > out->method.mem.size) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100500 aux = ly_realloc(*out->method.mem.buf, out->method.mem.len + count + 1);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200501 if (!aux) {
502 out->method.mem.buf = NULL;
503 out->method.mem.len = 0;
504 out->method.mem.size = 0;
505 LOGMEM(NULL);
506 va_end(ap);
Radek Krejcibaeb8382020-05-27 16:44:53 +0200507 return -LY_EMEM;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200508 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100509 *out->method.mem.buf = aux;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200510 out->method.mem.size = out->method.mem.len + count + 1;
511 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100512 memcpy(&(*out->method.mem.buf)[out->method.mem.len], msg, count);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200513 out->method.mem.len += count;
Radek Krejcia5bba312020-01-09 15:41:20 +0100514 (*out->method.mem.buf)[out->method.mem.len] = '\0';
Radek Krejcid3ca0632019-04-16 16:54:54 +0200515 free(msg);
516 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200517 case LY_OUT_CALLBACK:
Radek Krejci897ad2e2019-04-29 16:43:07 +0200518 if ((count = vasprintf(&msg, format, ap)) < 0) {
519 break;
520 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100521 count = out->method.clb.func(out->method.clb.arg, msg, count);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200522 free(msg);
523 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200524 case LY_OUT_ERROR:
Radek Krejcia5bba312020-01-09 15:41:20 +0100525 LOGINT(NULL);
Radek Krejcibaeb8382020-05-27 16:44:53 +0200526 va_end(ap);
527 return -LY_EINT;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200528 }
529
530 va_end(ap);
531
532 if (count < 0) {
Radek Krejci897ad2e2019-04-29 16:43:07 +0200533 LOGERR(out->ctx, LY_ESYS, "%s: writing data failed (%s).", __func__, strerror(errno));
Radek Krejci56cc0872019-04-30 09:22:27 +0200534 out->status = LY_ESYS;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200535 return -LY_ESYS;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200536 } else {
Radek Krejci241f6b52020-05-21 18:13:49 +0200537 if (out->type == LY_OUT_FDSTREAM) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100538 /* move the original file descriptor to the end of the output file */
539 lseek(out->method.fdstream.fd, 0, SEEK_END);
540 }
Radek Krejci897ad2e2019-04-29 16:43:07 +0200541 out->printed += count;
Michal Vasko63f3d842020-07-08 10:10:14 +0200542 out->func_printed += count;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200543 return count;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200544 }
545}
546
Radek Krejci2aae3752020-05-27 18:16:30 +0200547API void
Radek Krejci241f6b52020-05-21 18:13:49 +0200548ly_print_flush(struct ly_out *out)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200549{
550 switch (out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200551 case LY_OUT_FDSTREAM:
Radek Krejcia5bba312020-01-09 15:41:20 +0100552 /* move the original file descriptor to the end of the output file */
553 lseek(out->method.fdstream.fd, 0, SEEK_END);
554 fflush(out->method.fdstream.f);
555 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200556 case LY_OUT_FILEPATH:
557 case LY_OUT_FILE:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200558 fflush(out->method.f);
559 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200560 case LY_OUT_FD:
Radek Krejcie7b95092019-05-15 11:03:07 +0200561 fsync(out->method.fd);
562 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200563 case LY_OUT_MEMORY:
564 case LY_OUT_CALLBACK:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200565 /* nothing to do */
566 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200567 case LY_OUT_ERROR:
Radek Krejcia5bba312020-01-09 15:41:20 +0100568 LOGINT(NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200569 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200570
571 free(out->buffered);
572 out->buf_size = out->buf_len = 0;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200573}
574
Radek Krejcibaeb8382020-05-27 16:44:53 +0200575API ssize_t
Radek Krejci241f6b52020-05-21 18:13:49 +0200576ly_write(struct ly_out *out, const char *buf, size_t len)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200577{
578 int written = 0;
579
Radek Krejcibaeb8382020-05-27 16:44:53 +0200580 LYOUT_CHECK(out, -1 * out->status);
Radek Krejci56cc0872019-04-30 09:22:27 +0200581
Radek Krejcid3ca0632019-04-16 16:54:54 +0200582 if (out->hole_count) {
583 /* we are buffering data after a hole */
Radek Krejcie7b95092019-05-15 11:03:07 +0200584 if (out->buf_len + len > out->buf_size) {
585 out->buffered = ly_realloc(out->buffered, out->buf_len + len);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200586 if (!out->buffered) {
587 out->buf_len = 0;
588 out->buf_size = 0;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200589 LOGMEM(NULL);
590 return -LY_EMEM;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200591 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200592 out->buf_size = out->buf_len + len;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200593 }
594
Radek Krejcie7b95092019-05-15 11:03:07 +0200595 memcpy(&out->buffered[out->buf_len], buf, len);
596 out->buf_len += len;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200597 return len;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200598 }
599
Radek Krejci897ad2e2019-04-29 16:43:07 +0200600repeat:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200601 switch (out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200602 case LY_OUT_MEMORY:
Radek Krejcie7b95092019-05-15 11:03:07 +0200603 if (out->method.mem.len + len + 1 > out->method.mem.size) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100604 *out->method.mem.buf = ly_realloc(*out->method.mem.buf, out->method.mem.len + len + 1);
605 if (!*out->method.mem.buf) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200606 out->method.mem.len = 0;
607 out->method.mem.size = 0;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200608 LOGMEM(NULL);
609 return -LY_EMEM;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200610 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200611 out->method.mem.size = out->method.mem.len + len + 1;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200612 }
Radek Krejcia5bba312020-01-09 15:41:20 +0100613 memcpy(&(*out->method.mem.buf)[out->method.mem.len], buf, len);
Radek Krejcie7b95092019-05-15 11:03:07 +0200614 out->method.mem.len += len;
Radek Krejcia5bba312020-01-09 15:41:20 +0100615 (*out->method.mem.buf)[out->method.mem.len] = '\0';
Radek Krejci897ad2e2019-04-29 16:43:07 +0200616
Radek Krejcie7b95092019-05-15 11:03:07 +0200617 out->printed += len;
Michal Vasko63f3d842020-07-08 10:10:14 +0200618 out->func_printed += len;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200619 return len;
Radek Krejci241f6b52020-05-21 18:13:49 +0200620 case LY_OUT_FD:
Radek Krejcie7b95092019-05-15 11:03:07 +0200621 written = write(out->method.fd, buf, len);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200622 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200623 case LY_OUT_FDSTREAM:
624 case LY_OUT_FILEPATH:
625 case LY_OUT_FILE:
Michal Vasko63f3d842020-07-08 10:10:14 +0200626 written = fwrite(buf, sizeof *buf, len, out->method.f);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200627 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200628 case LY_OUT_CALLBACK:
Radek Krejcia5bba312020-01-09 15:41:20 +0100629 written = out->method.clb.func(out->method.clb.arg, buf, len);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200630 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200631 case LY_OUT_ERROR:
Radek Krejcia5bba312020-01-09 15:41:20 +0100632 LOGINT(NULL);
Radek Krejcibaeb8382020-05-27 16:44:53 +0200633 return -LY_EINT;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200634 }
635
636 if (written < 0) {
Radek Krejci897ad2e2019-04-29 16:43:07 +0200637 if (errno == EAGAIN || errno == EWOULDBLOCK) {
638 goto repeat;
639 }
640 LOGERR(out->ctx, LY_ESYS, "%s: writing data failed (%s).", __func__, strerror(errno));
Radek Krejci56cc0872019-04-30 09:22:27 +0200641 out->status = LY_ESYS;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200642 return -LY_ESYS;
Radek Krejcie7b95092019-05-15 11:03:07 +0200643 } else if ((size_t)written != len) {
Michal Vasko63f3d842020-07-08 10:10:14 +0200644 LOGERR(out->ctx, LY_ESYS, "%s: writing data failed (unable to write %u from %u data).", __func__,
645 len - (size_t)written, len);
Radek Krejci56cc0872019-04-30 09:22:27 +0200646 out->status = LY_ESYS;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200647 return -LY_ESYS;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200648 } else {
Radek Krejci241f6b52020-05-21 18:13:49 +0200649 if (out->type == LY_OUT_FDSTREAM) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100650 /* move the original file descriptor to the end of the output file */
651 lseek(out->method.fdstream.fd, 0, SEEK_END);
652 }
Radek Krejci897ad2e2019-04-29 16:43:07 +0200653 out->printed += written;
Michal Vasko63f3d842020-07-08 10:10:14 +0200654 out->func_printed += written;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200655 return written;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200656 }
657}
658
Michal Vasko63f3d842020-07-08 10:10:14 +0200659API size_t
660ly_out_printed(const struct ly_out *out)
661{
662 return out->func_printed;
663}
664
Radek Krejcibaeb8382020-05-27 16:44:53 +0200665ssize_t
Radek Krejci241f6b52020-05-21 18:13:49 +0200666ly_write_skip(struct ly_out *out, size_t count, size_t *position)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200667{
Radek Krejcibaeb8382020-05-27 16:44:53 +0200668 LYOUT_CHECK(out, -1 * out->status);
Radek Krejci56cc0872019-04-30 09:22:27 +0200669
Radek Krejcid3ca0632019-04-16 16:54:54 +0200670 switch (out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200671 case LY_OUT_MEMORY:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200672 if (out->method.mem.len + count > out->method.mem.size) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100673 *out->method.mem.buf = ly_realloc(*out->method.mem.buf, out->method.mem.len + count);
674 if (!(*out->method.mem.buf)) {
Radek Krejcid3ca0632019-04-16 16:54:54 +0200675 out->method.mem.len = 0;
676 out->method.mem.size = 0;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200677 out->status = LY_EMEM;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200678 LOGMEM_RET(NULL);
679 }
680 out->method.mem.size = out->method.mem.len + count;
681 }
682
683 /* save the current position */
684 *position = out->method.mem.len;
685
686 /* skip the memory */
687 out->method.mem.len += count;
Radek Krejci897ad2e2019-04-29 16:43:07 +0200688
689 /* update printed bytes counter despite we actually printed just a hole */
690 out->printed += count;
Michal Vasko63f3d842020-07-08 10:10:14 +0200691 out->func_printed += count;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200692 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200693 case LY_OUT_FD:
694 case LY_OUT_FDSTREAM:
695 case LY_OUT_FILEPATH:
696 case LY_OUT_FILE:
697 case LY_OUT_CALLBACK:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200698 /* buffer the hole */
699 if (out->buf_len + count > out->buf_size) {
700 out->buffered = ly_realloc(out->buffered, out->buf_len + count);
701 if (!out->buffered) {
702 out->buf_len = 0;
703 out->buf_size = 0;
Radek Krejcibaeb8382020-05-27 16:44:53 +0200704 out->status = LY_EMEM;
705 LOGMEM(NULL);
706 return -LY_EMEM;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200707 }
708 out->buf_size = out->buf_len + count;
709 }
710
711 /* save the current position */
712 *position = out->buf_len;
713
714 /* skip the memory */
715 out->buf_len += count;
716
717 /* increase hole counter */
718 ++out->hole_count;
Radek Krejcia5bba312020-01-09 15:41:20 +0100719
720 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200721 case LY_OUT_ERROR:
Radek Krejcia5bba312020-01-09 15:41:20 +0100722 LOGINT(NULL);
Radek Krejcibaeb8382020-05-27 16:44:53 +0200723 return -LY_EINT;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200724 }
725
Radek Krejcibaeb8382020-05-27 16:44:53 +0200726 return count;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200727}
728
Michal Vasko66d99972020-06-29 13:37:42 +0200729LY_ERR
Radek Krejci241f6b52020-05-21 18:13:49 +0200730ly_write_skipped(struct ly_out *out, size_t position, const char *buf, size_t count)
Radek Krejcid3ca0632019-04-16 16:54:54 +0200731{
Michal Vasko66d99972020-06-29 13:37:42 +0200732 LY_ERR ret = LY_SUCCESS;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200733
Michal Vasko66d99972020-06-29 13:37:42 +0200734 LYOUT_CHECK(out, out->status);
Radek Krejci56cc0872019-04-30 09:22:27 +0200735
Radek Krejcid3ca0632019-04-16 16:54:54 +0200736 switch (out->type) {
Radek Krejci241f6b52020-05-21 18:13:49 +0200737 case LY_OUT_MEMORY:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200738 /* write */
Radek Krejcia5bba312020-01-09 15:41:20 +0100739 memcpy(&(*out->method.mem.buf)[position], buf, count);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200740 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200741 case LY_OUT_FD:
742 case LY_OUT_FDSTREAM:
743 case LY_OUT_FILEPATH:
744 case LY_OUT_FILE:
745 case LY_OUT_CALLBACK:
Radek Krejcid3ca0632019-04-16 16:54:54 +0200746 if (out->buf_len < position + count) {
Radek Krejcibaeb8382020-05-27 16:44:53 +0200747 out->status = LY_EMEM;
Michal Vasko66d99972020-06-29 13:37:42 +0200748 LOGMEM_RET(NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200749 }
750
751 /* write into the hole */
752 memcpy(&out->buffered[position], buf, count);
753
754 /* decrease hole counter */
755 --out->hole_count;
756
757 if (!out->hole_count) {
Radek Krejci897ad2e2019-04-29 16:43:07 +0200758 /* all holes filled, we can write the buffer,
759 * printed bytes counter is updated by ly_write() */
Radek Krejci241f6b52020-05-21 18:13:49 +0200760 ret = ly_write(out, out->buffered, out->buf_len);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200761 out->buf_len = 0;
762 }
763 break;
Radek Krejci241f6b52020-05-21 18:13:49 +0200764 case LY_OUT_ERROR:
Michal Vasko66d99972020-06-29 13:37:42 +0200765 LOGINT_RET(NULL);
Radek Krejcid3ca0632019-04-16 16:54:54 +0200766 }
767
Radek Krejci241f6b52020-05-21 18:13:49 +0200768 if (out->type == LY_OUT_FILEPATH) {
Radek Krejcia5bba312020-01-09 15:41:20 +0100769 /* move the original file descriptor to the end of the output file */
770 lseek(out->method.fdstream.fd, 0, SEEK_END);
771 }
Michal Vasko66d99972020-06-29 13:37:42 +0200772 return ret;
Radek Krejcid3ca0632019-04-16 16:54:54 +0200773}