Adding upstream version 3.1.0.upstream/3.1.0

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 985 insertions, 0 deletions

diff --git a/src/log.c b/src/log.c
new file mode 100644
index 0000000..9bb4b19
--- /dev/null
+++ b/src/log.c
@@ -0,0 +1,985 @@
+/**
+ * @file log.c
+ * @author Radek Krejci <rkrejci@cesnet.cz>
+ * @author Michal Vasko <mvasko@cesnet.cz>
+ * @brief Logger routines implementations
+ *
+ * Copyright (c) 2015 - 2023 CESNET, z.s.p.o.
+ *
+ * This source code is licensed under BSD 3-Clause License (the "License").
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     https://opensource.org/licenses/BSD-3-Clause
+ */
+
+#define _GNU_SOURCE /* asprintf, strdup */
+
+#include "log.h"
+
+#include <assert.h>
+#include <inttypes.h>
+#include <pthread.h>
+#include <stdarg.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "compat.h"
+#include "in_internal.h"
+#include "ly_common.h"
+#include "plugins_exts.h"
+#include "set.h"
+#include "tree_data.h"
+#include "tree_data_internal.h"
+#include "tree_schema.h"
+#include "tree_schema_internal.h"
+
+ATOMIC_T ly_ll = (uint_fast32_t)LY_LLWRN;
+ATOMIC_T ly_log_opts = (uint_fast32_t)(LY_LOLOG | LY_LOSTORE_LAST);
+THREAD_LOCAL uint32_t *temp_ly_log_opts;
+static ly_log_clb log_clb;
+THREAD_LOCAL char last_msg[LY_LAST_MSG_SIZE];
+#ifndef NDEBUG
+ATOMIC_T ly_ldbg_groups = 0;
+#endif
+
+THREAD_LOCAL struct ly_log_location_s log_location = {0};
+
+LIBYANG_API_DEF const char *
+ly_strerr(LY_ERR err)
+{
+    /* ignore plugin flag */
+    err &= ~LY_EPLUGIN;
+
+    switch (err) {
+    case LY_SUCCESS:
+        return "Success";
+    case LY_EMEM:
+        return "Out of memory";
+    case LY_ESYS:
+        return "System call failed";
+    case LY_EINVAL:
+        return "Invalid value";
+    case LY_EEXIST:
+        return "Already exists";
+    case LY_ENOTFOUND:
+        return "Not found";
+    case LY_EINT:
+        return "Internal error";
+    case LY_EVALID:
+        return "Validation failed";
+    case LY_EDENIED:
+        return "Operation denied";
+    case LY_EINCOMPLETE:
+        return "Operation incomplete";
+    case LY_ERECOMPILE:
+        return "Recompilation required";
+    case LY_ENOT:
+        return "Negative result";
+    case LY_EOTHER:
+        return "Another failure reason";
+    case LY_EPLUGIN:
+        break;
+    }
+
+    /* unreachable */
+    return "Unknown";
+}
+
+LIBYANG_API_DEF const char *
+ly_strvecode(LY_VECODE vecode)
+{
+    switch (vecode) {
+    case LYVE_SUCCESS:
+        return "Success";
+    case LYVE_SYNTAX:
+        return "General syntax error";
+    case LYVE_SYNTAX_YANG:
+        return "YANG syntax error";
+    case LYVE_SYNTAX_YIN:
+        return "YIN syntax error";
+    case LYVE_REFERENCE:
+        return "Reference error";
+    case LYVE_XPATH:
+        return "XPath error";
+    case LYVE_SEMANTICS:
+        return "Semantic error";
+    case LYVE_SYNTAX_XML:
+        return "XML syntax error";
+    case LYVE_SYNTAX_JSON:
+        return "JSON syntax error";
+    case LYVE_DATA:
+        return "YANG data error";
+    case LYVE_OTHER:
+        return "Another error";
+    }
+
+    /* unreachable */
+    return "Unknown";
+}
+
+LIBYANG_API_DEF const char *
+ly_last_logmsg(void)
+{
+    return last_msg;
+}
+
+LIBYANG_API_DEF LY_ERR
+ly_err_new(struct ly_err_item **err, LY_ERR ecode, LY_VECODE vecode, char *data_path, char *apptag,
+        const char *err_format, ...)
+{
+    char *msg = NULL;
+    struct ly_err_item *e;
+
+    if (!err || (ecode == LY_SUCCESS)) {
+        /* nothing to do */
+        return ecode;
+    }
+
+    e = calloc(1, sizeof *e);
+    LY_CHECK_ERR_RET(!e, LOGMEM(NULL), LY_EMEM);
+
+    e->prev = (*err) ? (*err)->prev : e;
+    if (*err) {
+        (*err)->prev->next = e;
+    }
+
+    /* fill in the information */
+    e->level = LY_LLERR;
+    e->err = ecode;
+    e->vecode = vecode;
+    e->data_path = data_path;
+    e->apptag = apptag;
+
+    if (err_format) {
+        va_list print_args;
+
+        va_start(print_args, err_format);
+
+        if (vasprintf(&msg, err_format, print_args) == -1) {
+            /* we don't have anything more to do, just set msg to NULL to avoid undefined content,
+             * still keep the information about the original error instead of LY_EMEM or other printf's error */
+            msg = NULL;
+        }
+
+        va_end(print_args);
+    }
+    e->msg = msg;
+
+    if (!(*err)) {
+        *err = e;
+    }
+
+    return e->err;
+}
+
+/**
+ * @brief Get error record from error hash table of a context for the current thread.
+ *
+ * @param[in] ctx Context to use.
+ * @return Thread error record, if any.
+ */
+static struct ly_ctx_err_rec *
+ly_err_get_rec(const struct ly_ctx *ctx)
+{
+    struct ly_ctx_err_rec rec, *match;
+
+    /* prepare record */
+    rec.tid = pthread_self();
+
+    /* get the pointer to the matching record */
+    if (lyht_find(ctx->err_ht, &rec, lyht_hash((void *)&rec.tid, sizeof rec.tid), (void **)&match)) {
+        return NULL;
+    }
+
+    return match;
+}
+
+/**
+ * @brief Insert new error record to error hash table of a context for the current thread.
+ *
+ * @param[in] ctx Context to use.
+ * @return Thread error record.
+ */
+static struct ly_ctx_err_rec *
+ly_err_new_rec(const struct ly_ctx *ctx)
+{
+    struct ly_ctx_err_rec new, *rec;
+    LY_ERR r;
+
+    /* insert a new record */
+    new.err = NULL;
+    new.tid = pthread_self();
+
+    /* reuse lock */
+    /* LOCK */
+    pthread_mutex_lock((pthread_mutex_t *)&ctx->lyb_hash_lock);
+
+    r = lyht_insert(ctx->err_ht, &new, lyht_hash((void *)&new.tid, sizeof new.tid), (void **)&rec);
+
+    /* UNLOCK */
+    pthread_mutex_unlock((pthread_mutex_t *)&ctx->lyb_hash_lock);
+
+    return r ? NULL : rec;
+}
+
+LIBYANG_API_DEF const struct ly_err_item *
+ly_err_first(const struct ly_ctx *ctx)
+{
+    struct ly_ctx_err_rec *rec;
+
+    LY_CHECK_ARG_RET(NULL, ctx, NULL);
+
+    /* get the pointer to the matching record */
+    rec = ly_err_get_rec(ctx);
+
+    return rec ? rec->err : NULL;
+}
+
+LIBYANG_API_DEF const struct ly_err_item *
+ly_err_last(const struct ly_ctx *ctx)
+{
+    struct ly_ctx_err_rec *rec;
+
+    LY_CHECK_ARG_RET(NULL, ctx, NULL);
+
+    /* get the pointer to the matching record */
+    if (!(rec = ly_err_get_rec(ctx))) {
+        return NULL;
+    }
+
+    return rec->err ? rec->err->prev : NULL;
+}
+
+void
+ly_err_move(struct ly_ctx *src_ctx, struct ly_ctx *trg_ctx)
+{
+    struct ly_ctx_err_rec *rec;
+    struct ly_err_item *err = NULL;
+
+    /* get and remove the errors from src */
+    rec = ly_err_get_rec(src_ctx);
+    if (rec) {
+        err = rec->err;
+        rec->err = NULL;
+    }
+
+    /* set them for trg */
+    if (!(rec = ly_err_get_rec(trg_ctx))) {
+        if (!(rec = ly_err_new_rec(trg_ctx))) {
+            LOGINT(NULL);
+            ly_err_free(err);
+            return;
+        }
+    }
+    ly_err_free(rec->err);
+    rec->err = err;
+}
+
+LIBYANG_API_DEF void
+ly_err_free(void *ptr)
+{
+    struct ly_err_item *e, *next;
+
+    /* clean the error list */
+    LY_LIST_FOR_SAFE(ptr, next, e) {
+        free(e->msg);
+        free(e->data_path);
+        free(e->schema_path);
+        free(e->apptag);
+        free(e);
+    }
+}
+
+LIBYANG_API_DEF void
+ly_err_clean(struct ly_ctx *ctx, struct ly_err_item *eitem)
+{
+    struct ly_ctx_err_rec *rec;
+    struct ly_err_item *e;
+
+    if (!(rec = ly_err_get_rec(ctx))) {
+        return;
+    }
+    if (rec->err == eitem) {
+        eitem = NULL;
+    }
+
+    if (!eitem) {
+        /* free all err */
+        ly_err_free(rec->err);
+        rec->err = NULL;
+    } else {
+        /* disconnect the error */
+        for (e = rec->err; e && (e->next != eitem); e = e->next) {}
+        assert(e);
+        e->next = NULL;
+        rec->err->prev = e;
+        /* free this err and newer */
+        ly_err_free(eitem);
+    }
+}
+
+LIBYANG_API_DEF LY_LOG_LEVEL
+ly_log_level(LY_LOG_LEVEL level)
+{
+    LY_LOG_LEVEL prev = ATOMIC_LOAD_RELAXED(ly_ll);
+
+    ATOMIC_STORE_RELAXED(ly_ll, level);
+    return prev;
+}
+
+LIBYANG_API_DEF uint32_t
+ly_log_options(uint32_t opts)
+{
+    uint32_t prev = ATOMIC_LOAD_RELAXED(ly_log_opts);
+
+    ATOMIC_STORE_RELAXED(ly_log_opts, opts);
+    return prev;
+}
+
+LIBYANG_API_DEF uint32_t *
+ly_temp_log_options(uint32_t *opts)
+{
+    uint32_t *prev_lo = temp_ly_log_opts;
+
+    temp_ly_log_opts = opts;
+
+    return prev_lo;
+}
+
+LIBYANG_API_DEF uint32_t
+ly_log_dbg_groups(uint32_t dbg_groups)
+{
+#ifndef NDEBUG
+    uint32_t prev = ATOMIC_LOAD_RELAXED(ly_ldbg_groups);
+
+    ATOMIC_STORE_RELAXED(ly_ldbg_groups, dbg_groups);
+    return prev;
+#else
+    (void)dbg_groups;
+    return 0;
+#endif
+}
+
+LIBYANG_API_DEF void
+ly_set_log_clb(ly_log_clb clb)
+{
+    log_clb = clb;
+}
+
+LIBYANG_API_DEF ly_log_clb
+ly_get_log_clb(void)
+{
+    return log_clb;
+}
+
+void
+ly_log_location(const struct lysc_node *scnode, const struct lyd_node *dnode, const char *spath, const struct ly_in *in)
+{
+    if (scnode) {
+        ly_set_add(&log_location.scnodes, (void *)scnode, 1, NULL);
+    }
+    if (dnode || (!scnode && !spath && !in)) {
+        ly_set_add(&log_location.dnodes, (void *)dnode, 1, NULL);
+    }
+    if (spath) {
+        char *s = strdup(spath);
+
+        LY_CHECK_ERR_RET(!s, LOGMEM(NULL), );
+        ly_set_add(&log_location.spaths, s, 1, NULL);
+    }
+    if (in) {
+        ly_set_add(&log_location.inputs, (void *)in, 1, NULL);
+    }
+}
+
+void
+ly_log_location_revert(uint32_t scnode_steps, uint32_t dnode_steps, uint32_t spath_steps, uint32_t in_steps)
+{
+    for (uint32_t i = scnode_steps; i && log_location.scnodes.count; i--) {
+        log_location.scnodes.count--;
+    }
+
+    for (uint32_t i = dnode_steps; i && log_location.dnodes.count; i--) {
+        log_location.dnodes.count--;
+    }
+
+    for (uint32_t i = spath_steps; i && log_location.spaths.count; i--) {
+        ly_set_rm_index(&log_location.spaths, log_location.spaths.count - 1, free);
+    }
+
+    for (uint32_t i = in_steps; i && log_location.inputs.count; i--) {
+        log_location.inputs.count--;
+    }
+
+    /* deallocate the empty sets */
+    if (scnode_steps && !log_location.scnodes.count) {
+        ly_set_erase(&log_location.scnodes, NULL);
+    }
+    if (dnode_steps && !log_location.dnodes.count) {
+        ly_set_erase(&log_location.dnodes, NULL);
+    }
+    if (spath_steps && !log_location.spaths.count) {
+        ly_set_erase(&log_location.spaths, free);
+    }
+    if (in_steps && !log_location.inputs.count) {
+        ly_set_erase(&log_location.inputs, NULL);
+    }
+}
+
+const struct lyd_node *
+ly_log_location_dnode(uint32_t idx)
+{
+    if (idx < log_location.dnodes.count) {
+        return log_location.dnodes.dnodes[idx];
+    }
+
+    return NULL;
+}
+
+uint32_t
+ly_log_location_dnode_count(void)
+{
+    return log_location.dnodes.count;
+}
+
+/**
+ * @brief Store generated error in a context.
+ *
+ * @param[in] ctx Context to use.
+ * @param[in] level Message log level.
+ * @param[in] err Error number.
+ * @param[in] vecode Error validation error code.
+ * @param[in] msg Error message, always spent.
+ * @param[in] data_path Error data path, always spent.
+ * @param[in] schema_path Error schema path, always spent.
+ * @param[in] line Error input line, if any.
+ * @param[in] apptag Error app tag, always spent.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+log_store(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR err, LY_VECODE vecode, char *msg, char *data_path,
+        char *schema_path, uint64_t line, char *apptag)
+{
+    struct ly_ctx_err_rec *rec;
+    struct ly_err_item *e, *last;
+
+    assert(ctx && (level < LY_LLVRB));
+
+    if (!(rec = ly_err_get_rec(ctx))) {
+        if (!(rec = ly_err_new_rec(ctx))) {
+            goto mem_fail;
+        }
+    }
+
+    e = rec->err;
+    if (!e) {
+        /* if we are only to fill in path, there must have been an error stored */
+        assert(msg);
+        e = calloc(1, sizeof *e);
+        LY_CHECK_GOTO(!e, mem_fail);
+        e->prev = e;
+        e->next = NULL;
+
+        rec->err = e;
+    } else if (!msg) {
+        /* only filling the path */
+        assert(data_path || schema_path);
+
+        /* find last error */
+        e = e->prev;
+        do {
+            if (e->level == LY_LLERR) {
+                /* fill the path */
+                if (data_path) {
+                    free(e->data_path);
+                    e->data_path = data_path;
+                } else {
+                    free(e->schema_path);
+                    e->schema_path = schema_path;
+                }
+                return LY_SUCCESS;
+            }
+            e = e->prev;
+        } while (e->prev->next);
+        /* last error was not found */
+        assert(0);
+    } else if ((temp_ly_log_opts && ((*temp_ly_log_opts & LY_LOSTORE_LAST) == LY_LOSTORE_LAST)) ||
+            (!temp_ly_log_opts && ((ATOMIC_LOAD_RELAXED(ly_log_opts) & LY_LOSTORE_LAST) == LY_LOSTORE_LAST))) {
+        /* overwrite last message */
+        free(e->msg);
+        free(e->data_path);
+        free(e->schema_path);
+        free(e->apptag);
+    } else {
+        /* store new message */
+        last = e->prev;
+        e->prev = calloc(1, sizeof *e);
+        LY_CHECK_GOTO(!e->prev, mem_fail);
+        e = e->prev;
+        e->prev = last;
+        e->next = NULL;
+        last->next = e;
+    }
+
+    /* fill in the information */
+    e->level = level;
+    e->err = err;
+    e->vecode = vecode;
+    e->msg = msg;
+    e->data_path = data_path;
+    e->schema_path = schema_path;
+    e->line = line;
+    e->apptag = apptag;
+    return LY_SUCCESS;
+
+mem_fail:
+    LOGMEM(NULL);
+    free(msg);
+    free(data_path);
+    free(schema_path);
+    free(apptag);
+    return LY_EMEM;
+}
+
+/**
+ * @brief Log data path/schema path/line to stderr after the message has been printed.
+ *
+ * @param[in] data_path Error data path.
+ * @param[in] schema_path Error schema path.
+ * @param[in] line Error input line.
+ */
+static void
+log_stderr_path_line(const char *data_path, const char *schema_path, uint64_t line)
+{
+    ly_bool par = 0;
+
+    if (data_path) {
+        fprintf(stderr, "%sdata path: %s", " (", data_path);
+        par = 1;
+    }
+
+    if (schema_path) {
+        fprintf(stderr, "%sschemadata path: %s", par ? ", " : " (", schema_path);
+        par = 1;
+    }
+
+    if (line) {
+        fprintf(stderr, "%sline: %" PRIu64, par ? ", " : " (", line);
+        par = 1;
+    }
+
+    fprintf(stderr, par ? ")\n" : "\n");
+}
+
+/**
+ * @brief Log a message.
+ *
+ * @param[in] ctx Context to use.
+ * @param[in] level Message log level.
+ * @param[in] err Error number.
+ * @param[in] vecode Error validation error code.
+ * @param[in] data_path Error data path, always spent.
+ * @param[in] schema_path Error schema path, always spent.
+ * @param[in] line Error input line, if any.
+ * @param[in] apptag Error app tag.
+ * @param[in] format Error message format.
+ * @param[in] args Error message format arguments.
+ */
+static void
+log_vprintf(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR err, LY_VECODE vecode, char *data_path,
+        char *schema_path, uint64_t line, const char *apptag, const char *format, va_list args)
+{
+    char *dyn_msg = NULL;
+    const char *msg;
+    ly_bool free_strs = 1, lolog, lostore;
+
+    /* learn effective logger options */
+    if (temp_ly_log_opts) {
+        lolog = *temp_ly_log_opts & LY_LOLOG;
+        lostore = *temp_ly_log_opts & LY_LOSTORE;
+    } else {
+        lolog = ATOMIC_LOAD_RELAXED(ly_log_opts) & LY_LOLOG;
+        lostore = ATOMIC_LOAD_RELAXED(ly_log_opts) & LY_LOSTORE;
+    }
+
+    if (level > ATOMIC_LOAD_RELAXED(ly_ll)) {
+        /* do not print or store the message */
+        goto cleanup;
+    }
+
+    if (err == LY_EMEM) {
+        /* no not use more dynamic memory */
+        vsnprintf(last_msg, LY_LAST_MSG_SIZE, format, args);
+        msg = last_msg;
+    } else {
+        /* print into a single message */
+        if (vasprintf(&dyn_msg, format, args) == -1) {
+            LOGMEM(ctx);
+            goto cleanup;
+        }
+        msg = dyn_msg;
+
+        /* store as the last message */
+        strncpy(last_msg, msg, LY_LAST_MSG_SIZE - 1);
+    }
+
+    /* store the error/warning in the context (if we need to store errors internally, it does not matter what are
+     * the user log options), if the message is not dynamic, it would most likely fail to store (no memory) */
+    if ((level < LY_LLVRB) && ctx && lostore && dyn_msg) {
+        free_strs = 0;
+        if (log_store(ctx, level, err, vecode, dyn_msg, data_path, schema_path, line, apptag ? strdup(apptag) : NULL)) {
+            goto cleanup;
+        }
+    }
+
+    /* if we are only storing errors internally, never print the message (yet) */
+    if (lolog) {
+        if (log_clb) {
+            log_clb(level, msg, data_path, schema_path, line);
+        } else {
+            fprintf(stderr, "libyang[%d]: ", level);
+            fprintf(stderr, "%s", msg);
+            log_stderr_path_line(data_path, schema_path, line);
+        }
+    }
+
+cleanup:
+    if (free_strs) {
+        free(data_path);
+        free(schema_path);
+        free(dyn_msg);
+    }
+}
+
+#ifndef NDEBUG
+
+void
+ly_log_dbg(uint32_t group, const char *format, ...)
+{
+    char *dbg_format;
+    const char *str_group;
+    va_list ap;
+
+    if (!(ATOMIC_LOAD_RELAXED(ly_ldbg_groups) & group)) {
+        return;
+    }
+
+    switch (group) {
+    case LY_LDGDICT:
+        str_group = "DICT";
+        break;
+    case LY_LDGXPATH:
+        str_group = "XPATH";
+        break;
+    case LY_LDGDEPSETS:
+        str_group = "DEPSETS";
+        break;
+    default:
+        LOGINT(NULL);
+        return;
+    }
+
+    if (asprintf(&dbg_format, "%s: %s", str_group, format) == -1) {
+        LOGMEM(NULL);
+        return;
+    }
+
+    va_start(ap, format);
+    log_vprintf(NULL, LY_LLDBG, 0, 0, NULL, NULL, 0, NULL, dbg_format, ap);
+    va_end(ap);
+
+    free(dbg_format);
+}
+
+#endif
+
+void
+ly_log(const struct ly_ctx *ctx, LY_LOG_LEVEL level, LY_ERR err, const char *format, ...)
+{
+    va_list ap;
+
+    va_start(ap, format);
+    log_vprintf(ctx, level, err, 0, NULL, NULL, 0, NULL, format, ap);
+    va_end(ap);
+}
+
+/**
+ * @brief Append a schema node name to a generated data path, only if it fits.
+ *
+ * @param[in,out] str Generated path to update.
+ * @param[in] snode Schema node to append.
+ * @param[in] parent Last printed data node.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+ly_vlog_build_path_append(char **str, const struct lysc_node *snode, const struct lyd_node *parent)
+{
+    const struct lys_module *mod, *prev_mod;
+    uint32_t len, new_len;
+    void *mem;
+
+    if (snode->nodetype & (LYS_CHOICE | LYS_CASE)) {
+        /* schema-only node */
+        return LY_SUCCESS;
+    } else if (lysc_data_parent(snode) != lyd_node_schema(parent)) {
+        /* not a direct descendant node */
+        return LY_SUCCESS;
+    }
+
+    /* get module to print, if any */
+    mod = snode->module;
+    prev_mod = lyd_node_module(parent);
+    if (prev_mod == mod) {
+        mod = NULL;
+    }
+
+    /* realloc string */
+    len = *str ? strlen(*str) : 0;
+    new_len = len + 1 + (mod ? strlen(mod->name) + 1 : 0) + strlen(snode->name);
+    mem = realloc(*str, new_len + 1);
+    LY_CHECK_ERR_RET(!mem, LOGMEM(LYD_CTX(parent)), LY_EMEM);
+    *str = mem;
+
+    /* print the last schema node */
+    sprintf(*str + len, "/%s%s%s", mod ? mod->name : "", mod ? ":" : "", snode->name);
+    return LY_SUCCESS;
+}
+
+LY_ERR
+ly_vlog_build_data_path(const struct ly_ctx *ctx, char **path)
+{
+    LY_ERR rc = LY_SUCCESS;
+    const struct lyd_node *dnode = NULL;
+
+    *path = NULL;
+
+    if (log_location.dnodes.count) {
+        dnode = log_location.dnodes.objs[log_location.dnodes.count - 1];
+        if (!dnode) {
+            /* special root node */
+            assert(log_location.dnodes.count == 1);
+            *path = strdup("/");
+            LY_CHECK_ERR_GOTO(!*path, LOGMEM(ctx); rc = LY_EMEM, cleanup);
+            goto cleanup;
+        }
+
+        if (dnode->parent || !lysc_data_parent(dnode->schema)) {
+            /* data node with all of its parents */
+            *path = lyd_path(log_location.dnodes.objs[log_location.dnodes.count - 1], LYD_PATH_STD, NULL, 0);
+            LY_CHECK_ERR_GOTO(!*path, LOGMEM(ctx); rc = LY_EMEM, cleanup);
+        } else {
+            /* data parsers put all the parent nodes in the set, but they are not connected */
+            *path = lyd_path_set(&log_location.dnodes, LYD_PATH_STD);
+            LY_CHECK_ERR_GOTO(!*path, LOGMEM(ctx); rc = LY_EMEM, cleanup);
+        }
+    }
+
+    /* sometimes the last node is not created yet and we only have the schema node */
+    if (log_location.scnodes.count) {
+        rc = ly_vlog_build_path_append(path, log_location.scnodes.objs[log_location.scnodes.count - 1], dnode);
+        LY_CHECK_GOTO(rc, cleanup);
+    }
+
+cleanup:
+    if (rc) {
+        free(*path);
+        *path = NULL;
+    }
+    return rc;
+}
+
+/**
+ * @brief Build log path/input line from the stored log location information.
+ *
+ * @param[in] ctx Context to use.
+ * @param[out] data_path Generated data path.
+ * @param[out] schema_path Generated data path.
+ * @param[out] line Input line.
+ * @return LY_ERR value.
+ */
+static LY_ERR
+ly_vlog_build_path_line(const struct ly_ctx *ctx, char **data_path, char **schema_path, uint64_t *line)
+{
+    *data_path = NULL;
+    *schema_path = NULL;
+    *line = 0;
+
+    if (log_location.spaths.count && ((const char *)(log_location.spaths.objs[log_location.spaths.count - 1]))[0]) {
+        /* simply get what is in the provided path string */
+        *schema_path = strdup(log_location.spaths.objs[log_location.spaths.count - 1]);
+        LY_CHECK_ERR_RET(!*schema_path, LOGMEM(ctx), LY_EMEM);
+    } else {
+        /* data/schema node */
+        if (log_location.dnodes.count) {
+            LY_CHECK_RET(ly_vlog_build_data_path(ctx, data_path));
+        } else if (log_location.scnodes.count) {
+            *schema_path = lysc_path(log_location.scnodes.objs[log_location.scnodes.count - 1], LYSC_PATH_LOG, NULL, 0);
+            LY_CHECK_ERR_RET(!*schema_path, LOGMEM(ctx), LY_EMEM);
+        }
+    }
+
+    /* line */
+    if (log_location.inputs.count) {
+        *line = ((struct ly_in *)log_location.inputs.objs[log_location.inputs.count - 1])->line;
+    }
+
+    return LY_SUCCESS;
+}
+
+void
+ly_vlog(const struct ly_ctx *ctx, const char *apptag, LY_VECODE code, const char *format, ...)
+{
+    va_list ap;
+    char *data_path = NULL, *schema_path = NULL;
+    uint64_t line = 0;
+
+    if (ctx) {
+        ly_vlog_build_path_line(ctx, &data_path, &schema_path, &line);
+    }
+
+    va_start(ap, format);
+    log_vprintf(ctx, LY_LLERR, LY_EVALID, code, data_path, schema_path, line, apptag, format, ap);
+    /* path is spent and should not be freed! */
+    va_end(ap);
+}
+
+/**
+ * @brief Print a log message from an extension plugin callback.
+ *
+ * @param[in] ctx libyang context to store the error record. If not provided, the error is just printed.
+ * @param[in] plugin_name Name of the plugin generating the message.
+ * @param[in] level Log message level (error, warning, etc.)
+ * @param[in] err Error type code.
+ * @param[in] data_path Error data path, always spent.
+ * @param[in] schema_path Error schema path, always spent.
+ * @param[in] line Error input line, if any.
+ * @param[in] format Format string to print.
+ * @param[in] ap Var arg list for @p format.
+ */
+static void
+ly_ext_log(const struct ly_ctx *ctx, const char *plugin_name, LY_LOG_LEVEL level, LY_ERR err, char *data_path,
+        char *schema_path, uint64_t line, const char *format, va_list ap)
+{
+    char *plugin_msg;
+
+    if (ATOMIC_LOAD_RELAXED(ly_ll) < level) {
+        return;
+    }
+    if (asprintf(&plugin_msg, "Ext plugin \"%s\": %s", plugin_name, format) == -1) {
+        LOGMEM(ctx);
+        return;
+    }
+
+    log_vprintf(ctx, level, (level == LY_LLERR ? LY_EPLUGIN : 0) | err, LYVE_OTHER, data_path, schema_path, line, NULL,
+            plugin_msg, ap);
+    free(plugin_msg);
+}
+
+LIBYANG_API_DEF void
+lyplg_ext_parse_log(const struct lysp_ctx *pctx, const struct lysp_ext_instance *ext, LY_LOG_LEVEL level, LY_ERR err,
+        const char *format, ...)
+{
+    va_list ap;
+    char *data_path, *schema_path;
+    uint64_t line;
+
+    ly_vlog_build_path_line(PARSER_CTX(pctx), &data_path, &schema_path, &line);
+
+    va_start(ap, format);
+    ly_ext_log(PARSER_CTX(pctx), ext->record->plugin.id, level, err, data_path, schema_path, line, format, ap);
+    va_end(ap);
+}
+
+LIBYANG_API_DEF void
+lyplg_ext_compile_log(const struct lysc_ctx *cctx, const struct lysc_ext_instance *ext, LY_LOG_LEVEL level, LY_ERR err,
+        const char *format, ...)
+{
+    va_list ap;
+    char *schema_path = NULL;
+
+    if (cctx && !(schema_path = strdup(cctx->path))) {
+        LOGMEM(cctx->ctx);
+        return;
+    }
+
+    va_start(ap, format);
+    ly_ext_log(ext->module->ctx, ext->def->plugin->id, level, err, NULL, schema_path, 0, format, ap);
+    va_end(ap);
+}
+
+LIBYANG_API_DEF void
+lyplg_ext_compile_log_path(const char *path, const struct lysc_ext_instance *ext, LY_LOG_LEVEL level, LY_ERR err,
+        const char *format, ...)
+{
+    va_list ap;
+    char *schema_path = NULL;
+
+    if (path && !(schema_path = strdup(path))) {
+        LOGMEM(ext->module->ctx);
+        return;
+    }
+
+    va_start(ap, format);
+    ly_ext_log(ext->module->ctx, ext->def->plugin->id, level, err, NULL, schema_path, 0, format, ap);
+    va_end(ap);
+}
+
+/**
+ * @brief Serves only for creating ap.
+ */
+static void
+_lyplg_ext_compile_log_err(const struct ly_err_item *eitem, const struct lysc_ext_instance *ext, ...)
+{
+    va_list ap;
+    char *data_path = NULL, *schema_path = NULL;
+
+    if (eitem->data_path) {
+        data_path = strdup(eitem->data_path);
+    }
+    if (eitem->schema_path) {
+        schema_path = strdup(eitem->schema_path);
+    }
+
+    va_start(ap, ext);
+    ly_ext_log(ext->module->ctx, ext->def->plugin->id, eitem->level, eitem->err, data_path, schema_path, eitem->line, "%s", ap);
+    va_end(ap);
+}
+
+LIBYANG_API_DEF void
+lyplg_ext_compile_log_err(const struct ly_err_item *eitem, const struct lysc_ext_instance *ext)
+{
+    _lyplg_ext_compile_log_err(eitem, ext, eitem->msg);
+}
+
+/**
+ * @brief Exact same functionality as ::ly_err_print() but has variable arguments so log_vprintf() can be called.
+ */
+static void
+_ly_err_print(const struct ly_ctx *ctx, const struct ly_err_item *eitem, const char *format, ...)
+{
+    va_list ap;
+    char *data_path = NULL, *schema_path = NULL;
+
+    LY_CHECK_ARG_RET(ctx, eitem, );
+
+    if (eitem->data_path) {
+        data_path = strdup(eitem->data_path);
+    }
+    if (eitem->schema_path) {
+        schema_path = strdup(eitem->schema_path);
+    }
+
+    va_start(ap, format);
+    log_vprintf(ctx, eitem->level, eitem->err, eitem->vecode, data_path, schema_path, eitem->line, eitem->apptag, format, ap);
+    va_end(ap);
+}
+
+LIBYANG_API_DEF void
+ly_err_print(const struct ly_ctx *ctx, const struct ly_err_item *eitem)
+{
+    /* String ::ly_err_item.msg cannot be used directly because it may contain the % character */
+    _ly_err_print(ctx, eitem, "%s", eitem->msg);
+}