blob: a0d997ff144a17d7e4d92e889fd211e9c333142c [file] [log] [blame]
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001/**
2 * @file log.c
3 * @author Radek Krejci <rkrejci@cesnet.cz>
Michal Vasko193dacd2022-10-13 08:43:05 +02004 * @author Michal Vasko <mvasko@cesnet.cz>
Radek Krejci5aeea3a2018-09-05 13:29:36 +02005 * @brief Logger routines implementations
6 *
Michal Vaskob5b883c2023-07-10 10:36:18 +02007 * Copyright (c) 2015 - 2023 CESNET, z.s.p.o.
Radek Krejci5aeea3a2018-09-05 13:29:36 +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
Christian Hopps32874e12021-05-01 09:43:54 -040016#define _GNU_SOURCE /* asprintf, strdup */
Radek Krejci535ea9f2020-05-29 16:01:05 +020017
18#include "log.h"
Radek Krejcib7db73a2018-10-24 14:18:40 +020019
Radek Krejci5aeea3a2018-09-05 13:29:36 +020020#include <assert.h>
Radek Krejcic04f0a22018-09-21 15:49:45 +020021#include <inttypes.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020022#include <pthread.h>
Radek Krejci5aeea3a2018-09-05 13:29:36 +020023#include <stdarg.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020024#include <stdint.h>
Radek Krejci5aeea3a2018-09-05 13:29:36 +020025#include <stdio.h>
Radek Krejcie7b95092019-05-15 11:03:07 +020026#include <stdlib.h>
27#include <string.h>
Radek Krejci5aeea3a2018-09-05 13:29:36 +020028
Radek Krejci535ea9f2020-05-29 16:01:05 +020029#include "common.h"
Radek Krejciaa45bda2020-07-20 07:43:38 +020030#include "compat.h"
Radek Krejciaddfc9a2020-12-17 20:46:35 +010031#include "in_internal.h"
Radek Krejci0935f412019-08-20 16:15:18 +020032#include "plugins_exts.h"
Radek Krejci77114102021-03-10 15:21:57 +010033#include "set.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020034#include "tree_data.h"
Michal Vaskodbf3e652022-10-21 08:46:25 +020035#include "tree_data_internal.h"
Radek Krejci535ea9f2020-05-29 16:01:05 +020036#include "tree_schema.h"
Michal Vasko193dacd2022-10-13 08:43:05 +020037#include "tree_schema_internal.h"
Radek Krejci5aeea3a2018-09-05 13:29:36 +020038
Václav Kubernátd367ad92021-11-29 09:28:56 +010039ATOMIC_T ly_ll = (uint_fast32_t)LY_LLWRN;
40ATOMIC_T ly_log_opts = (uint_fast32_t)(LY_LOLOG | LY_LOSTORE_LAST);
Michal Vaskod4a6d042022-12-08 08:34:29 +010041THREAD_LOCAL uint32_t *temp_ly_log_opts;
Michal Vaskod8085612020-08-21 12:55:23 +020042static ly_log_clb log_clb;
Václav Kubernátd367ad92021-11-29 09:28:56 +010043static ATOMIC_T path_flag = 1;
Michal Vasko236cbac2023-02-10 15:45:37 +010044THREAD_LOCAL char last_msg[LY_LAST_MSG_SIZE];
Radek Krejci5aeea3a2018-09-05 13:29:36 +020045#ifndef NDEBUG
Václav Kubernátd367ad92021-11-29 09:28:56 +010046ATOMIC_T ly_ldbg_groups = 0;
Radek Krejci5aeea3a2018-09-05 13:29:36 +020047#endif
48
Radek Krejciddace2c2021-01-08 11:30:56 +010049THREAD_LOCAL struct ly_log_location_s log_location = {0};
50
Jan Kundrátc53a7ec2021-12-09 16:01:19 +010051LIBYANG_API_DEF LY_ERR
Radek Krejcid33273d2018-10-25 14:55:52 +020052ly_errcode(const struct ly_ctx *ctx)
53{
54 struct ly_err_item *i;
55
Radek Krejci572ee602020-09-16 14:35:08 +020056 i = ly_err_last(ctx);
Radek Krejcid33273d2018-10-25 14:55:52 +020057 if (i) {
Radek Krejci572ee602020-09-16 14:35:08 +020058 return i->no;
Radek Krejcid33273d2018-10-25 14:55:52 +020059 }
60
61 return LY_SUCCESS;
62}
63
Michal Vaskob5b883c2023-07-10 10:36:18 +020064LIBYANG_API_DEF const char *
65ly_strerrcode(LY_ERR err)
66{
67 /* ignore plugin flag */
68 err &= ~LY_EPLUGIN;
69
70 switch (err) {
71 case LY_SUCCESS:
Michal Vaskoe4207652023-07-10 14:57:32 +020072 return "Success";
Michal Vaskob5b883c2023-07-10 10:36:18 +020073 case LY_EMEM:
74 return "Out of memory";
75 case LY_ESYS:
76 return "System call failed";
77 case LY_EINVAL:
78 return "Invalid value";
79 case LY_EEXIST:
80 return "Already exists";
81 case LY_ENOTFOUND:
82 return "Not found";
83 case LY_EINT:
84 return "Internal error";
85 case LY_EVALID:
86 return "Validation failed";
87 case LY_EDENIED:
88 return "Operation denied";
89 case LY_EINCOMPLETE:
90 return "Operation incomplete";
91 case LY_ERECOMPILE:
92 return "Recompilation required";
93 case LY_ENOT:
94 return "Negative result";
95 case LY_EOTHER:
96 return "Another failure reason";
97 case LY_EPLUGIN:
98 break;
99 }
100
101 /* unreachable */
Michal Vaskob87e9a12023-07-10 15:10:58 +0200102 return "Unknown";
Michal Vaskob5b883c2023-07-10 10:36:18 +0200103}
104
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100105LIBYANG_API_DEF LY_VECODE
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200106ly_vecode(const struct ly_ctx *ctx)
107{
108 struct ly_err_item *i;
109
Radek Krejci572ee602020-09-16 14:35:08 +0200110 i = ly_err_last(ctx);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200111 if (i) {
Radek Krejci572ee602020-09-16 14:35:08 +0200112 return i->vecode;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200113 }
114
115 return LYVE_SUCCESS;
116}
117
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100118LIBYANG_API_DEF const char *
Michal Vaskob5b883c2023-07-10 10:36:18 +0200119ly_strvecode(LY_VECODE vecode)
120{
121 switch (vecode) {
122 case LYVE_SUCCESS:
Michal Vaskoe4207652023-07-10 14:57:32 +0200123 return "Success";
Michal Vaskob5b883c2023-07-10 10:36:18 +0200124 case LYVE_SYNTAX:
125 return "General syntax error";
126 case LYVE_SYNTAX_YANG:
127 return "YANG syntax error";
128 case LYVE_SYNTAX_YIN:
129 return "YIN syntax error";
130 case LYVE_REFERENCE:
131 return "Reference error";
132 case LYVE_XPATH:
133 return "XPath error";
134 case LYVE_SEMANTICS:
135 return "Semantic error";
136 case LYVE_SYNTAX_XML:
137 return "XML syntax error";
138 case LYVE_SYNTAX_JSON:
139 return "JSON syntax error";
140 case LYVE_DATA:
141 return "YANG data error";
142 case LYVE_OTHER:
143 return "Another error";
144 }
145
146 /* unreachable */
Michal Vaskob87e9a12023-07-10 15:10:58 +0200147 return "Unknown";
Michal Vaskob5b883c2023-07-10 10:36:18 +0200148}
149
150LIBYANG_API_DEF const char *
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200151ly_errmsg(const struct ly_ctx *ctx)
152{
153 struct ly_err_item *i;
154
Michal Vaskob3d0d6b2018-09-07 10:17:33 +0200155 LY_CHECK_ARG_RET(NULL, ctx, NULL);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200156
Radek Krejci572ee602020-09-16 14:35:08 +0200157 i = ly_err_last(ctx);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200158 if (i) {
Radek Krejci572ee602020-09-16 14:35:08 +0200159 return i->msg;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200160 }
161
162 return NULL;
163}
164
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100165LIBYANG_API_DEF const char *
Michal Vaskob5b883c2023-07-10 10:36:18 +0200166ly_last_errmsg(void)
167{
168 return last_msg;
169}
170
171LIBYANG_API_DEF const char *
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200172ly_errpath(const struct ly_ctx *ctx)
173{
174 struct ly_err_item *i;
175
Michal Vaskob3d0d6b2018-09-07 10:17:33 +0200176 LY_CHECK_ARG_RET(NULL, ctx, NULL);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200177
Radek Krejci572ee602020-09-16 14:35:08 +0200178 i = ly_err_last(ctx);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200179 if (i) {
Radek Krejci572ee602020-09-16 14:35:08 +0200180 return i->path;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200181 }
182
183 return NULL;
184}
185
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100186LIBYANG_API_DEF const char *
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200187ly_errapptag(const struct ly_ctx *ctx)
188{
189 struct ly_err_item *i;
190
Michal Vaskob3d0d6b2018-09-07 10:17:33 +0200191 LY_CHECK_ARG_RET(NULL, ctx, NULL);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200192
Radek Krejci572ee602020-09-16 14:35:08 +0200193 i = ly_err_last(ctx);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200194 if (i) {
Radek Krejci572ee602020-09-16 14:35:08 +0200195 return i->apptag;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200196 }
197
198 return NULL;
199}
200
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100201LIBYANG_API_DEF LY_ERR
aPiecek6d618552021-06-18 10:02:59 +0200202ly_err_new(struct ly_err_item **err, LY_ERR ecode, LY_VECODE vecode, char *path, char *apptag, const char *err_format, ...)
Radek Krejcie7b95092019-05-15 11:03:07 +0200203{
Radek Krejcidb0ee022021-03-15 16:53:44 +0100204 char *msg = NULL;
205 struct ly_err_item *e;
Radek Krejcie7b95092019-05-15 11:03:07 +0200206
Radek Krejcid43298b2021-03-25 16:17:15 +0100207 if (!err || (ecode == LY_SUCCESS)) {
Radek Krejcidb0ee022021-03-15 16:53:44 +0100208 /* nothing to do */
209 return ecode;
210 }
211
212 e = malloc(sizeof *e);
213 LY_CHECK_ERR_RET(!e, LOGMEM(NULL), LY_EMEM);
214 e->prev = (*err) ? (*err)->prev : e;
215 e->next = NULL;
216 if (*err) {
217 (*err)->prev->next = e;
218 }
Radek Krejcie7b95092019-05-15 11:03:07 +0200219
220 /* fill in the information */
Radek Krejcidb0ee022021-03-15 16:53:44 +0100221 e->level = LY_LLERR;
222 e->no = ecode;
223 e->vecode = vecode;
224 e->path = path;
225 e->apptag = apptag;
Radek Krejcie7b95092019-05-15 11:03:07 +0200226
aPiecek6d618552021-06-18 10:02:59 +0200227 if (err_format) {
Radek Krejcidb0ee022021-03-15 16:53:44 +0100228 va_list print_args;
229
aPiecek6d618552021-06-18 10:02:59 +0200230 va_start(print_args, err_format);
Radek Krejcidb0ee022021-03-15 16:53:44 +0100231
aPiecek6d618552021-06-18 10:02:59 +0200232 if (vasprintf(&msg, err_format, print_args) == -1) {
233 /* we don't have anything more to do, just set msg to NULL to avoid undefined content,
Radek Krejcidb0ee022021-03-15 16:53:44 +0100234 * still keep the information about the original error instead of LY_EMEM or other printf's error */
235 msg = NULL;
236 }
237
238 va_end(print_args);
239 }
240 e->msg = msg;
241
242 if (!(*err)) {
243 *err = e;
244 }
245
246 return e->no;
Radek Krejcie7b95092019-05-15 11:03:07 +0200247}
248
Michal Vasko88ccd582023-03-30 11:50:57 +0200249/**
250 * @brief Get error record from error hash table of a context for the current thread.
251 *
252 * @param[in] ctx Context to use.
253 * @return Thread error record, if any.
254 */
255static struct ly_ctx_err_rec *
256ly_err_get_rec(const struct ly_ctx *ctx)
257{
Michal Vasko4cca0092023-03-30 13:20:53 +0200258 struct ly_ctx_err_rec rec, *match;
Michal Vasko88ccd582023-03-30 11:50:57 +0200259
260 /* prepare record */
261 rec.tid = pthread_self();
262
263 /* get the pointer to the matching record */
Michal Vaskoae130f52023-04-20 14:25:16 +0200264 if (lyht_find(ctx->err_ht, &rec, lyht_hash((void *)&rec.tid, sizeof rec.tid), (void **)&match)) {
Michal Vasko4cca0092023-03-30 13:20:53 +0200265 return NULL;
266 }
Michal Vasko88ccd582023-03-30 11:50:57 +0200267
268 return match;
269}
270
Michal Vaskoe0be7452023-03-30 13:35:35 +0200271/**
272 * @brief Insert new error record to error hash table of a context for the current thread.
273 *
274 * @param[in] ctx Context to use.
275 * @return Thread error record.
276 */
277static struct ly_ctx_err_rec *
278ly_err_new_rec(const struct ly_ctx *ctx)
279{
280 struct ly_ctx_err_rec new, *rec;
281 LY_ERR r;
282
283 /* insert a new record */
284 new.err = NULL;
285 new.tid = pthread_self();
286
287 /* reuse lock */
288 /* LOCK */
289 pthread_mutex_lock((pthread_mutex_t *)&ctx->lyb_hash_lock);
290
Michal Vaskoae130f52023-04-20 14:25:16 +0200291 r = lyht_insert(ctx->err_ht, &new, lyht_hash((void *)&new.tid, sizeof new.tid), (void **)&rec);
Michal Vaskoe0be7452023-03-30 13:35:35 +0200292
293 /* UNLOCK */
294 pthread_mutex_unlock((pthread_mutex_t *)&ctx->lyb_hash_lock);
295
296 return r ? NULL : rec;
297}
298
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100299LIBYANG_API_DEF struct ly_err_item *
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200300ly_err_first(const struct ly_ctx *ctx)
301{
Michal Vasko88ccd582023-03-30 11:50:57 +0200302 struct ly_ctx_err_rec *rec;
303
Michal Vaskob3d0d6b2018-09-07 10:17:33 +0200304 LY_CHECK_ARG_RET(NULL, ctx, NULL);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200305
Michal Vasko88ccd582023-03-30 11:50:57 +0200306 /* get the pointer to the matching record */
307 rec = ly_err_get_rec(ctx);
308
309 return rec ? rec->err : NULL;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200310}
311
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100312LIBYANG_API_DEF struct ly_err_item *
Radek Krejci572ee602020-09-16 14:35:08 +0200313ly_err_last(const struct ly_ctx *ctx)
314{
Michal Vasko88ccd582023-03-30 11:50:57 +0200315 struct ly_ctx_err_rec *rec;
Radek Krejci572ee602020-09-16 14:35:08 +0200316
317 LY_CHECK_ARG_RET(NULL, ctx, NULL);
318
Michal Vasko88ccd582023-03-30 11:50:57 +0200319 /* get the pointer to the matching record */
320 if (!(rec = ly_err_get_rec(ctx))) {
321 return NULL;
322 }
323
324 return rec->err ? rec->err->prev : NULL;
Radek Krejci572ee602020-09-16 14:35:08 +0200325}
326
Michal Vasko9dbb91d2023-01-30 13:59:22 +0100327void
328ly_err_move(struct ly_ctx *src_ctx, struct ly_ctx *trg_ctx)
329{
Michal Vasko88ccd582023-03-30 11:50:57 +0200330 struct ly_ctx_err_rec *rec;
331 struct ly_err_item *err = NULL;
Michal Vasko9dbb91d2023-01-30 13:59:22 +0100332
Michal Vasko88ccd582023-03-30 11:50:57 +0200333 /* get and remove the errors from src */
334 rec = ly_err_get_rec(src_ctx);
335 if (rec) {
336 err = rec->err;
337 rec->err = NULL;
338 }
Michal Vasko9dbb91d2023-01-30 13:59:22 +0100339
340 /* set them for trg */
Michal Vaskoe0be7452023-03-30 13:35:35 +0200341 if (!(rec = ly_err_get_rec(trg_ctx))) {
342 if (!(rec = ly_err_new_rec(trg_ctx))) {
343 LOGINT(NULL);
344 ly_err_free(err);
345 return;
346 }
347 }
Michal Vasko88ccd582023-03-30 11:50:57 +0200348 ly_err_free(rec->err);
349 rec->err = err;
Michal Vasko9dbb91d2023-01-30 13:59:22 +0100350}
351
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100352LIBYANG_API_DEF void
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200353ly_err_free(void *ptr)
354{
Michal Vasko88ccd582023-03-30 11:50:57 +0200355 struct ly_err_item *e, *next;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200356
357 /* clean the error list */
Michal Vasko88ccd582023-03-30 11:50:57 +0200358 LY_LIST_FOR_SAFE(ptr, next, e) {
359 free(e->msg);
360 free(e->path);
361 free(e->apptag);
362 free(e);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200363 }
364}
365
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100366LIBYANG_API_DEF void
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200367ly_err_clean(struct ly_ctx *ctx, struct ly_err_item *eitem)
368{
Michal Vasko88ccd582023-03-30 11:50:57 +0200369 struct ly_ctx_err_rec *rec;
370 struct ly_err_item *e;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200371
Michal Vasko88ccd582023-03-30 11:50:57 +0200372 if (!(rec = ly_err_get_rec(ctx))) {
373 return;
374 }
375 if (rec->err == eitem) {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200376 eitem = NULL;
377 }
Michal Vasko88ccd582023-03-30 11:50:57 +0200378
379 if (!eitem) {
380 /* free all err */
381 ly_err_free(rec->err);
382 rec->err = NULL;
383 } else {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200384 /* disconnect the error */
Michal Vasko88ccd582023-03-30 11:50:57 +0200385 for (e = rec->err; e && (e->next != eitem); e = e->next) {}
386 assert(e);
387 e->next = NULL;
388 rec->err->prev = e;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200389 /* free this err and newer */
390 ly_err_free(eitem);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200391 }
392}
393
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100394LIBYANG_API_DEF LY_LOG_LEVEL
Radek Krejci52b6d512020-10-12 12:33:17 +0200395ly_log_level(LY_LOG_LEVEL level)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200396{
Václav Kubernátd367ad92021-11-29 09:28:56 +0100397 LY_LOG_LEVEL prev = ATOMIC_LOAD_RELAXED(ly_ll);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200398
Václav Kubernátd367ad92021-11-29 09:28:56 +0100399 ATOMIC_STORE_RELAXED(ly_ll, level);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200400 return prev;
401}
402
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100403LIBYANG_API_DEF uint32_t
Radek Krejci1deb5be2020-08-26 16:43:36 +0200404ly_log_options(uint32_t opts)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200405{
Václav Kubernátd367ad92021-11-29 09:28:56 +0100406 uint32_t prev = ATOMIC_LOAD_RELAXED(ly_log_opts);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200407
Václav Kubernátd367ad92021-11-29 09:28:56 +0100408 ATOMIC_STORE_RELAXED(ly_log_opts, opts);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200409 return prev;
410}
411
Michal Vaskod4a6d042022-12-08 08:34:29 +0100412LIBYANG_API_DEF void
413ly_temp_log_options(uint32_t *opts)
414{
415 temp_ly_log_opts = opts;
416}
417
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100418LIBYANG_API_DEF uint32_t
Radek Krejci68433c92020-10-12 17:03:55 +0200419ly_log_dbg_groups(uint32_t dbg_groups)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200420{
421#ifndef NDEBUG
Václav Kubernátd367ad92021-11-29 09:28:56 +0100422 uint32_t prev = ATOMIC_LOAD_RELAXED(ly_ldbg_groups);
Radek Krejciebdaed02020-11-09 13:05:06 +0100423
Václav Kubernátd367ad92021-11-29 09:28:56 +0100424 ATOMIC_STORE_RELAXED(ly_ldbg_groups, dbg_groups);
Radek Krejciebdaed02020-11-09 13:05:06 +0100425 return prev;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200426#else
427 (void)dbg_groups;
Radek Krejciebdaed02020-11-09 13:05:06 +0100428 return 0;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200429#endif
430}
431
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100432LIBYANG_API_DEF void
Radek Krejci857189e2020-09-01 13:26:36 +0200433ly_set_log_clb(ly_log_clb clb, ly_bool path)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200434{
Michal Vaskod8085612020-08-21 12:55:23 +0200435 log_clb = clb;
Václav Kubernátd367ad92021-11-29 09:28:56 +0100436 ATOMIC_STORE_RELAXED(path_flag, path);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200437}
438
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100439LIBYANG_API_DEF ly_log_clb
Michal Vaskod8085612020-08-21 12:55:23 +0200440ly_get_log_clb(void)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200441{
Michal Vaskod8085612020-08-21 12:55:23 +0200442 return log_clb;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200443}
444
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100445void
Michal Vasko59e69e72022-02-18 09:18:21 +0100446ly_log_location(const struct lysc_node *scnode, const struct lyd_node *dnode, const char *path, const struct ly_in *in,
Michal Vaskof8ebf132022-11-21 14:06:48 +0100447 uint64_t line)
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100448{
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100449 if (scnode) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100450 ly_set_add(&log_location.scnodes, (void *)scnode, 1, NULL);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100451 }
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100452 if (dnode) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100453 ly_set_add(&log_location.dnodes, (void *)dnode, 1, NULL);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100454 }
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100455 if (path) {
456 char *s = strdup(path);
Michal Vasko26bbb272022-08-02 14:54:33 +0200457
Radek Krejciddace2c2021-01-08 11:30:56 +0100458 LY_CHECK_ERR_RET(!s, LOGMEM(NULL), );
459 ly_set_add(&log_location.paths, s, 1, NULL);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100460 }
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100461 if (in) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100462 ly_set_add(&log_location.inputs, (void *)in, 1, NULL);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100463 }
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100464 if (line) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100465 log_location.line = line;
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100466 }
467}
468
469void
Michal Vasko59e69e72022-02-18 09:18:21 +0100470ly_log_location_revert(uint32_t scnode_steps, uint32_t dnode_steps, uint32_t path_steps, uint32_t in_steps)
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100471{
Radek Krejciddace2c2021-01-08 11:30:56 +0100472 for (uint32_t i = scnode_steps; i && log_location.scnodes.count; i--) {
473 log_location.scnodes.count--;
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100474 }
475
Radek Krejciddace2c2021-01-08 11:30:56 +0100476 for (uint32_t i = dnode_steps; i && log_location.dnodes.count; i--) {
477 log_location.dnodes.count--;
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100478 }
479
Radek Krejciddace2c2021-01-08 11:30:56 +0100480 for (uint32_t i = path_steps; i && log_location.paths.count; i--) {
481 ly_set_rm_index(&log_location.paths, log_location.paths.count - 1, free);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100482 }
483
Radek Krejciddace2c2021-01-08 11:30:56 +0100484 for (uint32_t i = in_steps; i && log_location.inputs.count; i--) {
485 log_location.inputs.count--;
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100486 }
487
Radek Krejciddace2c2021-01-08 11:30:56 +0100488 /* deallocate the empty sets */
489 if (scnode_steps && !log_location.scnodes.count) {
490 ly_set_erase(&log_location.scnodes, NULL);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100491 }
Radek Krejciddace2c2021-01-08 11:30:56 +0100492 if (dnode_steps && !log_location.dnodes.count) {
493 ly_set_erase(&log_location.dnodes, NULL);
494 }
495 if (path_steps && !log_location.paths.count) {
496 ly_set_erase(&log_location.paths, free);
497 }
498 if (in_steps && !log_location.inputs.count) {
499 ly_set_erase(&log_location.inputs, NULL);
Radek Krejciaddfc9a2020-12-17 20:46:35 +0100500 }
501}
502
Michal Vaskoa878a892023-08-18 12:22:07 +0200503const struct lyd_node *
504ly_log_location_dnode(uint32_t idx)
505{
506 if (idx < log_location.dnodes.count) {
507 return log_location.dnodes.dnodes[idx];
508 }
509
510 return NULL;
511}
512
513uint32_t
514ly_log_location_dnode_count(void)
515{
516 return log_location.dnodes.count;
517}
518
Michal Vasko88ccd582023-03-30 11:50:57 +0200519/**
520 * @brief Store generated error in a context.
521 *
522 * @param[in] ctx Context to use.
523 * @param[in] level Message log level.
524 * @param[in] no Error number.
525 * @param[in] vecode Error validation error code.
526 * @param[in] msg Error message, always spent.
527 * @param[in] path Error path, always spent.
528 * @param[in] apptag Error app tag, always spent.
529 * @return LY_ERR value.
530 */
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200531static LY_ERR
532log_store(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR no, LY_VECODE vecode, char *msg, char *path, char *apptag)
533{
Michal Vaskoe0be7452023-03-30 13:35:35 +0200534 struct ly_ctx_err_rec *rec;
Michal Vasko88ccd582023-03-30 11:50:57 +0200535 struct ly_err_item *e, *last;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200536
537 assert(ctx && (level < LY_LLVRB));
538
Michal Vasko88ccd582023-03-30 11:50:57 +0200539 if (!(rec = ly_err_get_rec(ctx))) {
Michal Vaskoe0be7452023-03-30 13:35:35 +0200540 if (!(rec = ly_err_new_rec(ctx))) {
541 goto mem_fail;
Michal Vasko88ccd582023-03-30 11:50:57 +0200542 }
543 }
544
545 e = rec->err;
546 if (!e) {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200547 /* if we are only to fill in path, there must have been an error stored */
548 assert(msg);
Michal Vasko88ccd582023-03-30 11:50:57 +0200549 e = malloc(sizeof *e);
550 LY_CHECK_GOTO(!e, mem_fail);
551 e->prev = e;
552 e->next = NULL;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200553
Michal Vasko88ccd582023-03-30 11:50:57 +0200554 rec->err = e;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200555 } else if (!msg) {
556 /* only filling the path */
557 assert(path);
558
559 /* find last error */
Michal Vasko88ccd582023-03-30 11:50:57 +0200560 e = e->prev;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200561 do {
Michal Vasko88ccd582023-03-30 11:50:57 +0200562 if (e->level == LY_LLERR) {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200563 /* fill the path */
Michal Vasko88ccd582023-03-30 11:50:57 +0200564 free(e->path);
565 e->path = path;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200566 return LY_SUCCESS;
567 }
Michal Vasko88ccd582023-03-30 11:50:57 +0200568 e = e->prev;
569 } while (e->prev->next);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200570 /* last error was not found */
571 assert(0);
Michal Vaskod4a6d042022-12-08 08:34:29 +0100572 } else if ((temp_ly_log_opts && ((*temp_ly_log_opts & LY_LOSTORE_LAST) == LY_LOSTORE_LAST)) ||
573 (!temp_ly_log_opts && ((ATOMIC_LOAD_RELAXED(ly_log_opts) & LY_LOSTORE_LAST) == LY_LOSTORE_LAST))) {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200574 /* overwrite last message */
Michal Vasko88ccd582023-03-30 11:50:57 +0200575 free(e->msg);
576 free(e->path);
577 free(e->apptag);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200578 } else {
579 /* store new message */
Michal Vasko88ccd582023-03-30 11:50:57 +0200580 last = e->prev;
581 e->prev = malloc(sizeof *e);
582 LY_CHECK_GOTO(!e->prev, mem_fail);
583 e = e->prev;
584 e->prev = last;
585 e->next = NULL;
586 last->next = e;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200587 }
588
589 /* fill in the information */
Michal Vasko88ccd582023-03-30 11:50:57 +0200590 e->level = level;
591 e->no = no;
592 e->vecode = vecode;
593 e->msg = msg;
594 e->path = path;
595 e->apptag = apptag;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200596 return LY_SUCCESS;
597
598mem_fail:
599 LOGMEM(NULL);
600 free(msg);
601 free(path);
602 free(apptag);
603 return LY_EMEM;
604}
605
606static void
Michal Vaskoe9391c72021-10-05 10:04:56 +0200607log_vprintf(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR no, LY_VECODE vecode, char *path, const char *apptag,
Radek Krejci0f969882020-08-21 16:56:47 +0200608 const char *format, va_list args)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200609{
610 char *msg = NULL;
Michal Vaskod4a6d042022-12-08 08:34:29 +0100611 ly_bool free_strs, lolog, lostore;
612
613 /* learn effective logger options */
614 if (temp_ly_log_opts) {
615 lolog = *temp_ly_log_opts & LY_LOLOG;
616 lostore = *temp_ly_log_opts & LY_LOSTORE;
617 } else {
618 lolog = ATOMIC_LOAD_RELAXED(ly_log_opts) & LY_LOLOG;
619 lostore = ATOMIC_LOAD_RELAXED(ly_log_opts) & LY_LOSTORE;
620 }
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200621
Václav Kubernátd367ad92021-11-29 09:28:56 +0100622 if (level > ATOMIC_LOAD_RELAXED(ly_ll)) {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200623 /* do not print or store the message */
624 free(path);
625 return;
626 }
627
Michal Vasko5a016922021-05-07 08:19:15 +0200628 if (no == LY_EMEM) {
629 /* just print it, anything else would most likely fail anyway */
Michal Vaskod4a6d042022-12-08 08:34:29 +0100630 if (lolog) {
Michal Vasko5a016922021-05-07 08:19:15 +0200631 if (log_clb) {
632 log_clb(level, LY_EMEM_MSG, path);
633 } else {
634 fprintf(stderr, "libyang[%d]: ", level);
635 vfprintf(stderr, format, args);
636 if (path) {
637 fprintf(stderr, " (path: %s)\n", path);
638 } else {
639 fprintf(stderr, "\n");
640 }
641 }
642 }
643 free(path);
644 return;
645 }
646
Michal Vasko236cbac2023-02-10 15:45:37 +0100647 /* print into a single message */
648 if (vasprintf(&msg, format, args) == -1) {
649 LOGMEM(ctx);
650 free(path);
651 return;
652 }
653
654 /* store as the last message */
655 strncpy(last_msg, msg, LY_LAST_MSG_SIZE - 1);
656
657 /* store the error/warning in the context (if we need to store errors internally, it does not matter what are
658 * the user log options) */
Michal Vaskod4a6d042022-12-08 08:34:29 +0100659 if ((level < LY_LLVRB) && ctx && lostore) {
Radek Krejcic9e64a62020-09-18 20:08:12 +0200660 if (((no & ~LY_EPLUGIN) == LY_EVALID) && (vecode == LYVE_SUCCESS)) {
661 /* assume we are inheriting the error, so inherit vecode as well */
662 vecode = ly_vecode(ctx);
663 }
Michal Vaskoe9391c72021-10-05 10:04:56 +0200664 if (log_store(ctx, level, no, vecode, msg, path, apptag ? strdup(apptag) : NULL)) {
Michal Vasko004d3152020-06-11 19:59:22 +0200665 return;
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200666 }
667 free_strs = 0;
668 } else {
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200669 free_strs = 1;
670 }
671
672 /* if we are only storing errors internally, never print the message (yet) */
Michal Vaskod4a6d042022-12-08 08:34:29 +0100673 if (lolog) {
Michal Vaskod8085612020-08-21 12:55:23 +0200674 if (log_clb) {
675 log_clb(level, msg, path);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200676 } else {
677 fprintf(stderr, "libyang[%d]: %s%s", level, msg, path ? " " : "\n");
678 if (path) {
679 fprintf(stderr, "(path: %s)\n", path);
680 }
681 }
682 }
683
684 if (free_strs) {
685 free(path);
686 free(msg);
687 }
688}
689
Radek Krejci4ab61562018-09-05 15:00:37 +0200690#ifndef NDEBUG
691
692void
Radek Krejci1deb5be2020-08-26 16:43:36 +0200693ly_log_dbg(uint32_t group, const char *format, ...)
Radek Krejci4ab61562018-09-05 15:00:37 +0200694{
695 char *dbg_format;
696 const char *str_group;
697 va_list ap;
698
Václav Kubernátd367ad92021-11-29 09:28:56 +0100699 if (!(ATOMIC_LOAD_RELAXED(ly_ldbg_groups) & group)) {
Radek Krejci4ab61562018-09-05 15:00:37 +0200700 return;
701 }
702
703 switch (group) {
704 case LY_LDGDICT:
705 str_group = "DICT";
706 break;
Radek Krejci4ab61562018-09-05 15:00:37 +0200707 case LY_LDGXPATH:
708 str_group = "XPATH";
709 break;
Michal Vaskoe558f792021-07-28 08:20:15 +0200710 case LY_LDGDEPSETS:
711 str_group = "DEPSETS";
712 break;
Radek Krejci4ab61562018-09-05 15:00:37 +0200713 default:
714 LOGINT(NULL);
715 return;
716 }
717
718 if (asprintf(&dbg_format, "%s: %s", str_group, format) == -1) {
719 LOGMEM(NULL);
720 return;
721 }
722
723 va_start(ap, format);
Michal Vaskoe9391c72021-10-05 10:04:56 +0200724 log_vprintf(NULL, LY_LLDBG, 0, 0, NULL, NULL, dbg_format, ap);
Radek Krejci4ab61562018-09-05 15:00:37 +0200725 va_end(ap);
aPiecekd6d2c042023-06-02 08:31:43 +0200726
727 free(dbg_format);
Radek Krejci4ab61562018-09-05 15:00:37 +0200728}
729
730#endif
731
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200732void
733ly_log(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR no, const char *format, ...)
734{
735 va_list ap;
736
737 va_start(ap, format);
Michal Vaskoe9391c72021-10-05 10:04:56 +0200738 log_vprintf(ctx, level, no, 0, NULL, NULL, format, ap);
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200739 va_end(ap);
740}
741
Michal Vaskodbf3e652022-10-21 08:46:25 +0200742/**
743 * @brief Append a schema node name to a generated data path, only if it fits.
744 *
745 * @param[in,out] str Generated path to update.
746 * @param[in] snode Schema node to append.
747 * @param[in] parent Last printed data node.
748 * @return LY_ERR value.
749 */
750static LY_ERR
751ly_vlog_build_path_append(char **str, const struct lysc_node *snode, const struct lyd_node *parent)
752{
753 const struct lys_module *mod, *prev_mod;
754 uint32_t len, new_len;
755 void *mem;
756
757 if (snode->nodetype & (LYS_CHOICE | LYS_CASE)) {
758 /* schema-only node */
759 return LY_SUCCESS;
Michal Vaskoccd1fa62023-08-17 09:15:46 +0200760 } else if (lysc_data_parent(snode) != lyd_node_schema(parent)) {
Michal Vaskodbf3e652022-10-21 08:46:25 +0200761 /* not a direct descendant node */
762 return LY_SUCCESS;
763 }
764
765 /* get module to print, if any */
766 mod = snode->module;
767 prev_mod = (parent->schema) ? parent->schema->module : lyd_owner_module(parent);
768 if (prev_mod == mod) {
769 mod = NULL;
770 }
771
772 /* realloc string */
773 len = strlen(*str);
774 new_len = len + 1 + (mod ? strlen(mod->name) + 1 : 0) + strlen(snode->name);
775 mem = realloc(*str, new_len + 1);
776 LY_CHECK_ERR_RET(!mem, LOGMEM(LYD_CTX(parent)), LY_EMEM);
777 *str = mem;
778
779 /* print the last schema node */
780 sprintf(*str + len, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", snode->name);
781 return LY_SUCCESS;
782}
783
784/**
785 * @brief Build log path from the stored log location information.
786 *
787 * @param[in] ctx Context to use.
788 * @param[out] path Generated log path.
789 * @return LY_ERR value.
790 */
Radek Krejci94aa9942018-09-07 17:12:17 +0200791static LY_ERR
Radek Krejciddace2c2021-01-08 11:30:56 +0100792ly_vlog_build_path(const struct ly_ctx *ctx, char **path)
Radek Krejci94aa9942018-09-07 17:12:17 +0200793{
Michal Vaskodbf3e652022-10-21 08:46:25 +0200794 int r;
Radek Krejci2efc45b2020-12-22 16:25:44 +0100795 char *str = NULL, *prev = NULL;
Michal Vaskodbf3e652022-10-21 08:46:25 +0200796 const struct lyd_node *dnode;
Radek Krejcicb3e6472021-01-06 08:19:01 +0100797
Radek Krejci2efc45b2020-12-22 16:25:44 +0100798 *path = NULL;
Radek Krejci94aa9942018-09-07 17:12:17 +0200799
Radek Krejciddace2c2021-01-08 11:30:56 +0100800 if (log_location.paths.count && ((const char *)(log_location.paths.objs[log_location.paths.count - 1]))[0]) {
Radek Krejci2efc45b2020-12-22 16:25:44 +0100801 /* simply get what is in the provided path string */
Michal Vasko6727c682023-02-17 10:40:26 +0100802 r = asprintf(path, "Path \"%s\".", (const char *)log_location.paths.objs[log_location.paths.count - 1]);
803 LY_CHECK_ERR_RET(r == -1, LOGMEM(ctx), LY_EMEM);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100804 } else {
Michal Vaskodbf3e652022-10-21 08:46:25 +0200805 /* data/schema node */
806 if (log_location.dnodes.count) {
807 dnode = log_location.dnodes.objs[log_location.dnodes.count - 1];
Michal Vaskoa4dfb3c2022-10-25 14:59:31 +0200808 if (dnode->parent || !lysc_data_parent(dnode->schema)) {
809 /* data node with all of its parents */
810 str = lyd_path(log_location.dnodes.objs[log_location.dnodes.count - 1], LYD_PATH_STD, NULL, 0);
811 LY_CHECK_ERR_RET(!str, LOGMEM(ctx), LY_EMEM);
812 } else {
Michal Vaskodbf3e652022-10-21 08:46:25 +0200813 /* data parsers put all the parent nodes in the set, but they are not connected */
814 str = lyd_path_set(&log_location.dnodes, LYD_PATH_STD);
Michal Vasko3e65ee32022-10-21 10:09:51 +0200815 LY_CHECK_ERR_RET(!str, LOGMEM(ctx), LY_EMEM);
Michal Vaskoa4dfb3c2022-10-25 14:59:31 +0200816 }
Michal Vaskodbf3e652022-10-21 08:46:25 +0200817
Michal Vaskoa4dfb3c2022-10-25 14:59:31 +0200818 /* sometimes the last node is not created yet and we only have the schema node */
819 if (log_location.scnodes.count) {
820 ly_vlog_build_path_append(&str, log_location.scnodes.objs[log_location.scnodes.count - 1], dnode);
Michal Vaskodbf3e652022-10-21 08:46:25 +0200821 }
Michal Vaskodbf3e652022-10-21 08:46:25 +0200822
823 r = asprintf(path, "Data location \"%s\"", str);
824 free(str);
825 LY_CHECK_ERR_RET(r == -1, LOGMEM(ctx), LY_EMEM);
826 } else if (log_location.scnodes.count) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100827 str = lysc_path(log_location.scnodes.objs[log_location.scnodes.count - 1], LYSC_PATH_LOG, NULL, 0);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100828 LY_CHECK_ERR_RET(!str, LOGMEM(ctx), LY_EMEM);
829
Michal Vaskodbf3e652022-10-21 08:46:25 +0200830 r = asprintf(path, "Schema location \"%s\"", str);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100831 free(str);
Michal Vaskodbf3e652022-10-21 08:46:25 +0200832 LY_CHECK_ERR_RET(r == -1, LOGMEM(ctx), LY_EMEM);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100833 }
Radek Krejci2efc45b2020-12-22 16:25:44 +0100834
Michal Vaskodbf3e652022-10-21 08:46:25 +0200835 /* line */
836 prev = *path;
Radek Krejciddace2c2021-01-08 11:30:56 +0100837 if (log_location.line) {
Michal Vaskodbf3e652022-10-21 08:46:25 +0200838 r = asprintf(path, "%s%sine number %" PRIu64, prev ? prev : "", prev ? ", l" : "L", log_location.line);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100839 free(prev);
Michal Vaskodbf3e652022-10-21 08:46:25 +0200840 LY_CHECK_ERR_RET(r == -1, LOGMEM(ctx), LY_EMEM);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100841
Radek Krejciddace2c2021-01-08 11:30:56 +0100842 log_location.line = 0;
843 } else if (log_location.inputs.count) {
Michal Vaskodbf3e652022-10-21 08:46:25 +0200844 r = asprintf(path, "%s%sine number %" PRIu64, prev ? prev : "", prev ? ", l" : "L",
Radek Krejciddace2c2021-01-08 11:30:56 +0100845 ((struct ly_in *)log_location.inputs.objs[log_location.inputs.count - 1])->line);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100846 free(prev);
Michal Vaskodbf3e652022-10-21 08:46:25 +0200847 LY_CHECK_ERR_RET(r == -1, LOGMEM(ctx), LY_EMEM);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100848 }
849
850 if (*path) {
851 prev = *path;
Michal Vaskodbf3e652022-10-21 08:46:25 +0200852 r = asprintf(path, "%s.", prev);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100853 free(prev);
Michal Vaskodbf3e652022-10-21 08:46:25 +0200854 LY_CHECK_ERR_RET(r == -1, LOGMEM(ctx), LY_EMEM);
Radek Krejci2efc45b2020-12-22 16:25:44 +0100855 }
Radek Krejci94aa9942018-09-07 17:12:17 +0200856 }
857
Radek Krejci94aa9942018-09-07 17:12:17 +0200858 return LY_SUCCESS;
859}
860
861void
Michal Vaskoe9391c72021-10-05 10:04:56 +0200862ly_vlog(const struct ly_ctx *ctx, const char *apptag, LY_VECODE code, const char *format, ...)
Radek Krejci94aa9942018-09-07 17:12:17 +0200863{
864 va_list ap;
Michal Vasko22df3f02020-08-24 13:29:22 +0200865 char *path = NULL;
Radek Krejci94aa9942018-09-07 17:12:17 +0200866
Václav Kubernátd367ad92021-11-29 09:28:56 +0100867 if (ATOMIC_LOAD_RELAXED(path_flag) && ctx) {
Radek Krejciddace2c2021-01-08 11:30:56 +0100868 ly_vlog_build_path(ctx, &path);
Radek Krejci94aa9942018-09-07 17:12:17 +0200869 }
870
871 va_start(ap, format);
Michal Vaskoe9391c72021-10-05 10:04:56 +0200872 log_vprintf(ctx, LY_LLERR, LY_EVALID, code, path, apptag, format, ap);
Radek Krejci94aa9942018-09-07 17:12:17 +0200873 /* path is spent and should not be freed! */
874 va_end(ap);
875}
876
Michal Vasko193dacd2022-10-13 08:43:05 +0200877/**
878 * @brief Print a log message from an extension plugin callback.
879 *
880 * @param[in] ctx libyang context to store the error record. If not provided, the error is just printed.
881 * @param[in] plugin_name Name of the plugin generating the message.
882 * @param[in] level Log message level (error, warning, etc.)
883 * @param[in] err_no Error type code.
Michal Vasko6727c682023-02-17 10:40:26 +0100884 * @param[in] path Optional path of the error, used if set.
Michal Vasko193dacd2022-10-13 08:43:05 +0200885 * @param[in] format Format string to print.
886 * @param[in] ap Var arg list for @p format.
887 */
888static void
Michal Vasko6727c682023-02-17 10:40:26 +0100889ly_ext_log(const struct ly_ctx *ctx, const char *plugin_name, LY_LOG_LEVEL level, LY_ERR err_no, char *path,
Michal Vasko193dacd2022-10-13 08:43:05 +0200890 const char *format, va_list ap)
Radek Krejci0935f412019-08-20 16:15:18 +0200891{
Radek Krejci0935f412019-08-20 16:15:18 +0200892 char *plugin_msg;
Radek Krejci0935f412019-08-20 16:15:18 +0200893
Václav Kubernátd367ad92021-11-29 09:28:56 +0100894 if (ATOMIC_LOAD_RELAXED(ly_ll) < level) {
Radek Krejci0935f412019-08-20 16:15:18 +0200895 return;
896 }
Michal Vasko193dacd2022-10-13 08:43:05 +0200897 if (asprintf(&plugin_msg, "Ext plugin \"%s\": %s", plugin_name, format) == -1) {
898 LOGMEM(ctx);
Radek Krejci0935f412019-08-20 16:15:18 +0200899 return;
900 }
901
Michal Vasko6727c682023-02-17 10:40:26 +0100902 log_vprintf(ctx, level, (level == LY_LLERR ? LY_EPLUGIN : 0) | err_no, LYVE_OTHER, path, NULL, plugin_msg, ap);
Michal Vasko193dacd2022-10-13 08:43:05 +0200903 free(plugin_msg);
904}
905
906LIBYANG_API_DEF void
907lyplg_ext_parse_log(const struct lysp_ctx *pctx, const struct lysp_ext_instance *ext, LY_LOG_LEVEL level, LY_ERR err_no,
908 const char *format, ...)
909{
910 va_list ap;
911 char *path = NULL;
912
913 if (ATOMIC_LOAD_RELAXED(path_flag)) {
914 ly_vlog_build_path(PARSER_CTX(pctx), &path);
915 }
916
Radek Krejci0935f412019-08-20 16:15:18 +0200917 va_start(ap, format);
Michal Vasko193dacd2022-10-13 08:43:05 +0200918 ly_ext_log(PARSER_CTX(pctx), ext->record->plugin.id, level, err_no, path, format, ap);
Radek Krejci0935f412019-08-20 16:15:18 +0200919 va_end(ap);
Michal Vasko193dacd2022-10-13 08:43:05 +0200920}
921
922LIBYANG_API_DEF void
923lyplg_ext_compile_log(const struct lysc_ctx *cctx, const struct lysc_ext_instance *ext, LY_LOG_LEVEL level, LY_ERR err_no,
924 const char *format, ...)
925{
926 va_list ap;
Michal Vasko6727c682023-02-17 10:40:26 +0100927 char *path = NULL;
928
929 if (cctx && (asprintf(&path, "Path \"%s\".", cctx->path) == -1)) {
930 LOGMEM(cctx->ctx);
931 return;
932 }
Michal Vasko193dacd2022-10-13 08:43:05 +0200933
934 va_start(ap, format);
Michal Vasko6727c682023-02-17 10:40:26 +0100935 ly_ext_log(ext->module->ctx, ext->def->plugin->id, level, err_no, path, format, ap);
Michal Vasko193dacd2022-10-13 08:43:05 +0200936 va_end(ap);
937}
938
939LIBYANG_API_DEF void
940lyplg_ext_compile_log_path(const char *path, const struct lysc_ext_instance *ext, LY_LOG_LEVEL level, LY_ERR err_no,
941 const char *format, ...)
942{
943 va_list ap;
Michal Vasko6727c682023-02-17 10:40:26 +0100944 char *log_path = NULL;
945
946 if (path && (asprintf(&log_path, "Path \"%s\".", path) == -1)) {
947 LOGMEM(ext->module->ctx);
948 return;
949 }
Michal Vasko193dacd2022-10-13 08:43:05 +0200950
951 va_start(ap, format);
Michal Vasko6727c682023-02-17 10:40:26 +0100952 ly_ext_log(ext->module->ctx, ext->def->plugin->id, level, err_no, log_path, format, ap);
Michal Vasko193dacd2022-10-13 08:43:05 +0200953 va_end(ap);
Radek Krejci0935f412019-08-20 16:15:18 +0200954}
955
Michal Vasko177d0ed2020-11-23 16:43:03 +0100956/**
Michal Vasko6727c682023-02-17 10:40:26 +0100957 * @brief Serves only for creating ap.
958 */
959static void
960_lyplg_ext_compile_log_err(const struct ly_err_item *err, const struct lysc_ext_instance *ext, ...)
961{
962 va_list ap;
963
964 va_start(ap, ext);
965 ly_ext_log(ext->module->ctx, ext->def->plugin->id, err->level, err->no, err->path ? strdup(err->path) : NULL, "%s", ap);
966 va_end(ap);
967}
968
969LIBYANG_API_DEF void
970lyplg_ext_compile_log_err(const struct ly_err_item *err, const struct lysc_ext_instance *ext)
971{
972 _lyplg_ext_compile_log_err(err, ext, err->msg);
973}
974
975/**
Michal Vaskoc78a6092021-05-07 15:27:35 +0200976 * @brief Exact same functionality as ::ly_err_print() but has variable arguments so log_vprintf() can be called.
Michal Vasko177d0ed2020-11-23 16:43:03 +0100977 */
978static void
Michal Vaskoc78a6092021-05-07 15:27:35 +0200979_ly_err_print(const struct ly_ctx *ctx, struct ly_err_item *eitem, const char *format, ...)
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200980{
Michal Vasko177d0ed2020-11-23 16:43:03 +0100981 va_list ap;
982 char *path_dup = NULL;
983
984 LY_CHECK_ARG_RET(ctx, eitem, );
985
986 if (eitem->path) {
987 /* duplicate path because it will be freed */
988 path_dup = strdup(eitem->path);
989 LY_CHECK_ERR_RET(!path_dup, LOGMEM(ctx), );
Radek Krejci5aeea3a2018-09-05 13:29:36 +0200990 }
Michal Vasko177d0ed2020-11-23 16:43:03 +0100991
Michal Vaskoc78a6092021-05-07 15:27:35 +0200992 va_start(ap, format);
Michal Vaskoe9391c72021-10-05 10:04:56 +0200993 log_vprintf(ctx, eitem->level, eitem->no, eitem->vecode, path_dup, eitem->apptag, format, ap);
Michal Vasko177d0ed2020-11-23 16:43:03 +0100994 va_end(ap);
Michal Vasko177d0ed2020-11-23 16:43:03 +0100995}
996
Jan Kundrátc53a7ec2021-12-09 16:01:19 +0100997LIBYANG_API_DEF void
Michal Vasko177d0ed2020-11-23 16:43:03 +0100998ly_err_print(const struct ly_ctx *ctx, struct ly_err_item *eitem)
999{
Michal Vaskoc78a6092021-05-07 15:27:35 +02001000 /* String ::ly_err_item.msg cannot be used directly because it may contain the % character */
1001 _ly_err_print(ctx, eitem, "%s", eitem->msg);
Radek Krejci5aeea3a2018-09-05 13:29:36 +02001002}