union.c

Go to the documentation of this file.

 
#define _GNU_SOURCE /* strdup */
 
#include "plugins_types.h"
 
#include <assert.h>
#include <inttypes.h>
#include <stdlib.h>
#include <string.h>
 
#include "compat.h"
#include "dict.h"
#include "ly_array.h"
#include "ly_common.h"
#include "lyb.h"
#include "plugins_internal.h"
 
static void lyplg_type_free_union(const struct ly_ctx *ctx, struct lyd_value *value);
 
#define LYPLG_UNION_TYPE_IDX_SIZE 1
 
static LY_ERR
union_validate_value_lyb(const void *lyb_data, uint64_t lyb_data_size_bits, const struct lysc_type_union *type_u,
        struct ly_err_item **err)
{
    uint32_t type_idx = 0;
 
    /* basic validation */
    if (lyb_data_size_bits < LYPLG_UNION_TYPE_IDX_SIZE * 8) {
        return ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL, "Invalid LYB union value size %" PRIu64
                " b (expected at least %" PRIu8 " b).", lyb_data_size_bits, LYPLG_UNION_TYPE_IDX_SIZE * 8);
    }
 
    /* get index in correct byte order */
    memcpy(&type_idx, lyb_data, LYPLG_UNION_TYPE_IDX_SIZE);
    type_idx = le32toh(type_idx);
    if (type_idx >= LYA_COUNT(type_u->types)) {
        return ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, NULL,
                "Invalid LYB union type index %" PRIu32 " (type count %" LYA_PRI_COUNT_T ").",
                type_idx, LYA_COUNT(type_u->types));
    }
 
    return LY_SUCCESS;
}
 
static void
union_parse_value_lyb(const void *lyb_data, uint64_t lyb_data_size_bits, uint32_t *type_idx, const void **lyb_value,
        uint64_t *lyb_value_size_bits)
{
    uint32_t num = 0;
 
    assert(lyb_data);
 
    if (type_idx) {
        memcpy(&num, lyb_data, LYPLG_UNION_TYPE_IDX_SIZE);
        num = le32toh(num);
 
        *type_idx = num;
    }
 
    if (lyb_value && lyb_value_size_bits && lyb_data_size_bits) {
        /* get lyb_value and its size */
        if (lyb_data_size_bits == LYPLG_UNION_TYPE_IDX_SIZE * 8) {
            *lyb_value_size_bits = 0;
            *lyb_value = "";
        } else {
            *lyb_value_size_bits = lyb_data_size_bits - LYPLG_UNION_TYPE_IDX_SIZE * 8;
            *lyb_value = (char *)lyb_data + LYPLG_UNION_TYPE_IDX_SIZE;
        }
    }
}
 
static LY_ERR
union_create_value_lyb(const struct ly_ctx *ctx, uint32_t type_idx, const struct lyd_value *value, void **lyb_value,
        uint64_t *lyb_size_bits, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS;
    void *lyb = NULL;
    const void *pval = NULL;
    uint64_t pval_size_bits, lyb_bits = 0;
    uint32_t num;
    ly_bool dynamic = 0;
 
    *err = NULL;
 
    /* print the value in LYB format */
    pval = LYSC_GET_TYPE_PLG(value->realtype->plugin_ref)->print(ctx, value, LY_VALUE_LYB, NULL, &dynamic, &pval_size_bits);
    if (!pval) {
        rc = ly_err_new_no_mem(err);
        goto cleanup;
    }
 
    /* create the binary data of the pinned member type index followed by its binary value
     * (the size may not be an exact number of bytes, e.g. for integers) */
    lyb_bits = LYPLG_UNION_TYPE_IDX_SIZE * 8 + pval_size_bits;
    lyb = malloc(LYPLG_BITS2BYTES(lyb_bits));
    if (!lyb) {
        lyb_bits = 0;
        rc = ly_err_new_no_mem(err);
        goto cleanup;
    }
 
    num = htole32(type_idx);
    memcpy(lyb, &num, LYPLG_UNION_TYPE_IDX_SIZE);
    memcpy((char *)lyb + LYPLG_UNION_TYPE_IDX_SIZE, pval, LYPLG_BITS2BYTES(pval_size_bits));
 
cleanup:
    if (dynamic) {
        free((void *)pval);
    }
    *lyb_value = lyb;
    if (lyb_size_bits) {
        *lyb_size_bits = lyb_bits;
    }
    return rc;
}
 
static LY_ERR
union_update_lref_err(struct ly_err_item *err, const struct lysc_type *type, const void *value, uint64_t value_size_bits)
{
    const struct lysc_type_leafref *lref;
    char *valstr = NULL;
    int r;
 
    if (!err || (type->basetype != LY_TYPE_LEAFREF)) {
        /* nothing to do */
        return LY_SUCCESS;
    }
 
    lref = (const struct lysc_type_leafref *)type;
 
    /* update error-app-tag */
    free(err->apptag);
    err->apptag = strdup("instance-required");
    LY_CHECK_ERR_RET(!err->apptag, LOGMEM(NULL), LY_EMEM);
 
    valstr = strndup((const char *)value, value_size_bits / 8);
    LY_CHECK_ERR_RET(!valstr, LOGMEM(NULL), LY_EMEM);
 
    /* update error-message */
    free(err->msg);
    r = asprintf(&err->msg, LY_ERRMSG_NOLREF_VAL, valstr, lyxp_get_expr(lref->path));
    free(valstr);
    LY_CHECK_ERR_RET(r == -1, LOGMEM(NULL), LY_EMEM);
 
    return LY_SUCCESS;
}
 
static LY_ERR
union_subvalue_get_input_value(const struct ly_ctx *ctx, const struct lysc_type_union *type_u, uint32_t type_idx,
        const struct lyd_value_union *subvalue, const void **value, uint64_t *value_size_bits, ly_bool *dynamic,
        LY_VALUE_FORMAT *format, void **prefix_data, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS;
    struct lyd_value storage = {0};
    uint32_t ti;
    struct lyplg_type *type_plg;
 
    *value = NULL;
    *value_size_bits = 0;
    *dynamic = 0;
    *format = 0;
    *prefix_data = NULL;
    *err = NULL;
 
    if (subvalue->format == LY_VALUE_LYB) {
        union_parse_value_lyb(subvalue->original, subvalue->orig_size_bits, &ti, value, value_size_bits);
        if (ti != type_idx) {
            /* value of another type, store the value */
            type_plg = LYSC_GET_TYPE_PLG(type_u->types[ti]->plugin_ref);
            rc = type_plg->store(ctx, type_u->types[ti], *value, *value_size_bits, LYPLG_TYPE_STORE_ONLY,
                    subvalue->format, subvalue->prefix_data, subvalue->hints, subvalue->ctx_node, &storage, NULL, err);
            if (rc && (rc != LY_EINCOMPLETE)) {
                /* if this is a leafref, lets make sure we propagate the appropriate error, and not a type validation failure */
                union_update_lref_err(*err, type_u->types[ti], *value, *value_size_bits);
                goto cleanup;
            }
 
            /* print the value in canonical format */
            assert(storage.realtype);
            *value = LYSC_GET_TYPE_PLG(storage.realtype->plugin_ref)->print(ctx, &storage, LY_VALUE_CANON, NULL, dynamic,
                    value_size_bits);
            assert(!(*value_size_bits % 8));
 
            /* free storage, but we need the value, which may be stored there */
            if (!*dynamic) {
                *value = strndup(*value, *value_size_bits / 8);
                *dynamic = 1;
            }
            type_plg->free(ctx, &storage);
 
            *format = LY_VALUE_CANON;
            *prefix_data = NULL;
        } else {
            *format = subvalue->format;
            *prefix_data = subvalue->prefix_data;
        }
    } else {
        *value = subvalue->original;
        *value_size_bits = subvalue->orig_size_bits;
        *format = subvalue->format;
        *prefix_data = subvalue->prefix_data;
    }
 
cleanup:
    return rc;
}
 
static LY_ERR
union_store_type(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, uint64_t value_size_bits,
        uint32_t options, LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lysc_node *ctx_snode,
        struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS;
    struct lyplg_type *type_plg;
    ly_bool dynamic = 0;
 
    *err = NULL;
 
    type_plg = LYSC_GET_TYPE_PLG(type->plugin_ref);
 
    /* do not free the value (yet) */
    if (options & LYPLG_TYPE_STORE_DYNAMIC) {
        options &= ~LYPLG_TYPE_STORE_DYNAMIC;
        dynamic = 1;
    }
 
    rc = type_plg->store(ctx, type, value, value_size_bits, options, format, prefix_data, hints, ctx_snode, storage,
            unres, err);
 
    if (rc && (rc != LY_EINCOMPLETE)) {
        /* if this is a leafref, lets make sure we propagate the appropriate error, and not a type validation failure */
        union_update_lref_err(*err, type, value, value_size_bits);
 
        /* clear any leftover/freed garbage */
        memset(storage, 0, sizeof *storage);
    }
    if (dynamic) {
        free((void *)value);
    }
    return rc;
}
 
static LY_ERR
union_read_store_type(const struct ly_ctx *ctx, const struct lysc_type_union *type_u, uint32_t type_idx,
        struct lyd_value_union *subvalue, uint32_t options, const struct lyd_node *ctx_node,
        const struct lyd_node *tree, const struct ly_ht *unres_ht, struct lys_glob_unres *unres, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS, r;
    const void *value;
    uint64_t value_size_bits;
    ly_bool dynamic;
    LY_VALUE_FORMAT format;
    void *prefix_data;
    struct lyplg_type *type_plg;
 
    /* get the input value in a suitable format from the original value */
    r = union_subvalue_get_input_value(ctx, type_u, type_idx, subvalue, &value, &value_size_bits, &dynamic, &format,
            &prefix_data, err);
    if (r && (r != LY_EINCOMPLETE)) {
        rc = r;
        goto cleanup;
    }
 
    if (dynamic) {
        options |= LYPLG_TYPE_STORE_DYNAMIC;
    } else {
        options &= ~LYPLG_TYPE_STORE_DYNAMIC;
    }
 
    /* store the value as the specific type */
    rc = union_store_type(ctx, type_u->types[type_idx], value, value_size_bits, options, format, prefix_data,
            subvalue->hints, subvalue->ctx_node, &subvalue->value, unres, err);
    if (rc && (rc != LY_EINCOMPLETE)) {
        goto cleanup;
    }
 
    /* validate the value */
    type_plg = LYSC_GET_TYPE_PLG(type_u->types[type_idx]->plugin_ref);
    if (tree && type_plg->validate_tree) {
        rc = type_plg->validate_tree(ctx, type_u->types[type_idx], ctx_node, tree, unres_ht, &subvalue->value, err);
        if (rc) {
            /* validate failed, we need to free the stored value */
            type_plg->free(ctx, &subvalue->value);
            memset(&subvalue->value, 0, sizeof subvalue->value);
            goto cleanup;
        }
    }
 
cleanup:
    return rc;
}
 
static LY_ERR
union_find_type(const struct ly_ctx *ctx, struct lysc_type_union *type_u, struct lyd_value_union *subvalue,
        uint32_t options, const struct lyd_node *ctx_node, const struct lyd_node *tree, const struct ly_ht *unres_ht,
        uint32_t *type_idx, struct lys_glob_unres *unres, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS, r;
    LYA_COUNT_T u;
    struct ly_err_item **errs = NULL, *e;
    uint32_t *prev_lo, temp_lo = 0;
    char *msg = NULL, *err_app_tag = NULL;
    uint32_t msg_size = 0, msg_len = 0;
    ly_bool use_err_app_tag = 0;
    struct lyplg_type *type_plg;
 
    *err = NULL;
 
    /* alloc errors */
    errs = calloc(LYA_COUNT(type_u->types), sizeof *errs);
    LY_CHECK_RET(!errs, LY_EMEM);
 
    /* turn logging temporarily off */
    prev_lo = ly_temp_log_options(&temp_lo);
 
    /* use the first usable subtype to store the value */
    LYA_FOR(type_u->types, u) {
        rc = union_read_store_type(ctx, type_u, u, subvalue, options, ctx_node, tree, unres_ht, unres, &e);
        if (!rc || (rc == LY_EINCOMPLETE)) {
            /* success */
            break;
        }
 
        errs[u] = e;
    }
 
    if (u == LYA_COUNT(type_u->types)) {
        /* create the full error */
        if (subvalue->format == LY_VALUE_LYB) {
            r = ly_append_str(&msg, &msg_size, &msg_len, "Invalid LYB union value - no matching subtype found:\n");
        } else {
            r = ly_append_str(&msg, &msg_size, &msg_len, "Invalid union value \"%.*s\" - no matching subtype found:\n",
                    (int)subvalue->orig_size_bits / 8, (char *)subvalue->original);
        }
        LY_CHECK_ERR_GOTO(r, rc = LY_EMEM, cleanup);
        LYA_FOR(type_u->types, u) {
            if (!errs[u]) {
                /* no error for some reason */
                continue;
            }
 
            /* use an app-tag if all the types set it or set none */
            if (errs[u]->apptag) {
                if (!err_app_tag) {
                    err_app_tag = strdup(errs[u]->apptag);
                    LY_CHECK_ERR_GOTO(!err_app_tag, rc = LY_EMEM, cleanup);
                    use_err_app_tag = 1;
                } else if (strcmp(errs[u]->apptag, err_app_tag)) {
                    use_err_app_tag = 0;
                }
            }
 
            type_plg = LYSC_GET_TYPE_PLG(type_u->types[u]->plugin_ref);
 
            r = ly_append_str(&msg, &msg_size, &msg_len, "    %s: %s\n", type_plg->id, errs[u]->msg);
            LY_CHECK_ERR_GOTO(r, rc = LY_EMEM, cleanup);
        }
 
        if (!use_err_app_tag) {
            free(err_app_tag);
            err_app_tag = NULL;
        }
        rc = ly_err_new(err, LY_EVALID, LYVE_DATA, NULL, err_app_tag, "%s", msg);
        err_app_tag = NULL;
    } else if (type_idx) {
        *type_idx = u;
    }
 
cleanup:
    LYA_FOR(type_u->types, u) {
        ly_err_free(errs[u]);
    }
    free(errs);
    free(msg);
    free(err_app_tag);
    ly_temp_log_options(prev_lo);
    return rc;
}
 
static LY_ERR
union_prepare_subvalue(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, uint64_t value_size_bits,
        uint32_t *options, LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
        struct lyd_value *storage, struct lyd_value_union **subvalue, struct ly_err_item **err)
{
    *err = NULL;
 
    /* init storage */
    memset(storage, 0, sizeof *storage);
    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, *subvalue);
    LY_CHECK_RET(!*subvalue, ly_err_new_no_mem(err));
 
    storage->realtype = type;
    (*subvalue)->hints = hints;
    (*subvalue)->ctx_node = ctx_node;
 
    /* store the caller value as the subvalue original, it is needed for the member type store */
    if (*options & LYPLG_TYPE_STORE_DYNAMIC) {
        (*subvalue)->original = (void *)value;
        *options &= ~LYPLG_TYPE_STORE_DYNAMIC;
    } else if (value_size_bits) {
        (*subvalue)->original = calloc(1, LYPLG_BITS2BYTES(value_size_bits));
        LY_CHECK_RET(!(*subvalue)->original, ly_err_new_no_mem(err));
        memcpy((*subvalue)->original, value, LYPLG_BITS2BYTES(value_size_bits));
    } else {
        (*subvalue)->original = strdup("");
        LY_CHECK_RET(!(*subvalue)->original, ly_err_new_no_mem(err));
    }
    (*subvalue)->orig_size_bits = value_size_bits;
 
    /* derive format-specific data of the value, needed for the member type store;
     * the values in the LYB format must have no prefix data stored (see ly_dup_prefix_data()) */
    return lyplg_type_prefix_data_new(ctx, value, LYPLG_BITS2BYTES(value_size_bits), format,
            (format == LY_VALUE_LYB) ? NULL : prefix_data, &(*subvalue)->format, &(*subvalue)->prefix_data);
}
 
static LY_ERR
lyplg_type_store_union(const struct ly_ctx *ctx, const struct lysc_type *type, const void *value, uint64_t value_size_bits,
        uint32_t options, LY_VALUE_FORMAT format, void *prefix_data, uint32_t hints, const struct lysc_node *ctx_node,
        struct lyd_value *storage, struct lys_glob_unres *unres, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS, r;
    struct lysc_type_union *type_u;
    struct lyd_value_union *subvalue;
    uint32_t type_idx = 0;
 
    *err = NULL;
 
    type_u = (struct lysc_type_union *)type;
 
    /* initialize the storage and assign the caller value to the subvalue */
    rc = union_prepare_subvalue(ctx, type, value, value_size_bits, &options, format, prefix_data, hints,
            ctx_node, storage, &subvalue, err);
    LY_CHECK_GOTO(rc, cleanup);
 
    if (format == LY_VALUE_LYB) {
        /* the binary value pins the member type to use, validate it and learn its index */
        rc = union_validate_value_lyb(value, value_size_bits, type_u, err);
        LY_CHECK_GOTO(rc, cleanup);
        union_parse_value_lyb(value, 0, &type_idx, NULL, NULL);
 
        /* use the pinned member type to store the value, its acceptance errors are propagated */
        rc = union_read_store_type(ctx, type_u, type_idx, subvalue, options, NULL, NULL, NULL, unres, err);
        LY_CHECK_GOTO(rc && (rc != LY_EINCOMPLETE), cleanup);
    } else {
        /* use the first usable and valid subtype to store the value */
        rc = union_find_type(ctx, type_u, subvalue, options & ~LYPLG_TYPE_STORE_ONLY, NULL, NULL, NULL, NULL, unres, err);
        if (rc && (rc != LY_EINCOMPLETE) && (options & LYPLG_TYPE_STORE_ONLY)) {
            /* we tried to find the actual type by validating the value but no type matched, so try to find any type */
            ly_err_free(*err);
            rc = union_find_type(ctx, type_u, subvalue, options, NULL, NULL, NULL, NULL, unres, err);
        }
        LY_CHECK_GOTO(rc && (rc != LY_EINCOMPLETE), cleanup);
    }
 
    /* store canonical value, if any (use the specific type value) */
    r = lydict_dup(ctx, subvalue->value._canonical, &storage->_canonical);
    LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
 
cleanup:
    if (options & LYPLG_TYPE_STORE_DYNAMIC) {
        free((void *)value);
    }
 
    if (rc && (rc != LY_EINCOMPLETE)) {
        lyplg_type_free_union(ctx, storage);
    }
    return rc;
}
 
LIBYANG_API_DEF LY_ERR
lyplg_type_store_union_idx(const struct ly_ctx *ctx, const struct lysc_type *type, uint32_t type_idx,
        const void *value, uint64_t value_size_bits, uint32_t options, LY_VALUE_FORMAT format, void *prefix_data,
        uint32_t hints, const struct lysc_node *ctx_node, struct lyd_value *storage, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS, r;
    struct lysc_type_union *type_u = (struct lysc_type_union *)type;
    struct lyd_value_union *subvalue;
    void *lyb;
    uint64_t lyb_size_bits;
 
    LY_CHECK_ARG_RET(ctx, ctx, type, type->basetype == LY_TYPE_UNION, type_idx < LYA_COUNT(type_u->types),
            !(options & LYPLG_TYPE_STORE_IMPLEMENT), storage, err, LY_EINVAL);
 
    memset(storage, 0, sizeof *storage);
    *err = NULL;
 
    LYPLG_TYPE_VAL_INLINE_PREPARE(storage, subvalue);
    LY_CHECK_ERR_GOTO(!subvalue, rc = LY_EMEM, cleanup);
 
    /* store the value of the specific type */
    rc = union_store_type(ctx, type_u->types[type_idx], value, value_size_bits, options & ~LYPLG_TYPE_STORE_DYNAMIC,
            format, prefix_data, hints, ctx_node, &subvalue->value, NULL, err);
    LY_CHECK_GOTO(rc && (rc != LY_EINCOMPLETE), cleanup);
 
    /* create the union LYB value with the resolved type index */
    r = union_create_value_lyb(ctx, type_idx, &subvalue->value, &lyb, &lyb_size_bits, err);
    LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
 
    /* store it as the original value (hints, while not relevant for the LYB format, may be used by other formats) */
    subvalue->original = lyb;
    subvalue->orig_size_bits = lyb_size_bits;
    subvalue->hints = hints;
    subvalue->format = LY_VALUE_LYB;
    subvalue->ctx_node = ctx_node;
 
    /* store canonical value (use the specific type value) and realtype */
    r = lydict_dup(ctx, subvalue->value._canonical, &storage->_canonical);
    LY_CHECK_ERR_GOTO(r, rc = r, cleanup);
    storage->realtype = type;
 
cleanup:
    if (options & LYPLG_TYPE_STORE_DYNAMIC) {
        free((void *)value);
    }
 
    if (rc && (rc != LY_EINCOMPLETE)) {
        lyplg_type_free_union(ctx, storage);
        memset(storage, 0, sizeof *storage);
    }
    return rc;
}
 
static LY_ERR
lyplg_type_validate_tree_union(const struct ly_ctx *ctx, const struct lysc_type *type, const struct lyd_node *ctx_node,
        const struct lyd_node *tree, const struct ly_ht *unres_ht, struct lyd_value *storage, struct ly_err_item **err)
{
    LY_ERR rc = LY_SUCCESS;
    struct lysc_type_union *type_u = (struct lysc_type_union *)type;
    struct lyd_value_union *subvalue = storage->subvalue;
    struct lyd_value orig = {0};
    uint32_t type_idx;
    ly_bool validated = 0;
    struct lyplg_type *realtype_plg;
 
    *err = NULL;
 
    /* because of types that do not store their own type as realtype (leafref), we are not able to call their
     * validate callback (there is no way to get the type) but even if possible, the value may be invalid
     * for the type, so we may have to perform union value storing again from scratch, but keep a value backup */
    realtype_plg = LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref);
    LY_CHECK_RET(realtype_plg->duplicate(ctx, &subvalue->value, &orig));
    realtype_plg->free(ctx, &subvalue->value);
 
    if (subvalue->format == LY_VALUE_LYB) {
        /* use the specific type to store and validate the value */
        union_parse_value_lyb(subvalue->original, 0, &type_idx, NULL, NULL);
 
        if (union_read_store_type(ctx, type_u, type_idx, subvalue, 0, ctx_node, tree, unres_ht, NULL, err)) {
            /* validation failed, we need to try storing the value again */
            ly_err_free(*err);
            *err = NULL;
        } else {
            validated = 1;
        }
    }
 
    if (!validated) {
        /* use the first usable subtype to store and validate the value */
        rc = union_find_type(ctx, type_u, subvalue, 0, ctx_node, tree, unres_ht, NULL, NULL, err);
        LY_CHECK_GOTO(rc, cleanup);
    }
 
    /* update the canonical value, if any generated */
    lydict_remove(ctx, storage->_canonical);
    storage->_canonical = NULL;
    LY_CHECK_GOTO(rc = lydict_dup(ctx, subvalue->value._canonical, &storage->_canonical), cleanup);
 
cleanup:
    if (rc) {
        /* restore the previous value */
        subvalue->value = orig;
    } else {
        /* free the backup value */
        LYSC_GET_TYPE_PLG(orig.realtype->plugin_ref)->free(ctx, &orig);
    }
    return rc;
}
 
static LY_ERR
lyplg_type_compare_union(const struct ly_ctx *ctx, const struct lyd_value *val1, const struct lyd_value *val2)
{
    if (val1->subvalue->value.realtype != val2->subvalue->value.realtype) {
        return LY_ENOT;
    }
    return LYSC_GET_TYPE_PLG(val1->subvalue->value.realtype->plugin_ref)->compare(ctx,
            &val1->subvalue->value, &val2->subvalue->value);
}
 
static int
lyplg_type_sort_union(const struct ly_ctx *ctx, const struct lyd_value *val1, const struct lyd_value *val2)
{
    int rc;
    LYA_COUNT_T u;
    struct lysc_type **types, *type;
 
    if (val1->subvalue->value.realtype == val2->subvalue->value.realtype) {
        return LYSC_GET_TYPE_PLG(val1->subvalue->value.realtype->plugin_ref)->sort(ctx,
                &val1->subvalue->value, &val2->subvalue->value);
    }
 
    /* compare according to the order of types */
    rc = 0;
    types = ((struct lysc_type_union *)val1->realtype)->types;
    LYA_FOR(types, u) {
        if (types[u]->basetype == LY_TYPE_LEAFREF) {
            type = ((struct lysc_type_leafref *)types[u])->realtype;
        } else {
            type = types[u];
        }
 
        if (type == val1->subvalue->value.realtype) {
            rc = 1;
            break;
        } else if (type == val2->subvalue->value.realtype) {
            rc = -1;
            break;
        }
    }
    assert(rc);
 
    return rc;
}
 
static const void *
union_print_value_lyb(const struct ly_ctx *ctx, struct lysc_type_union *type_u, struct lyd_value_union *subvalue,
        uint64_t *value_size_bits)
{
    void *ret = NULL;
    LY_ERR r;
    struct ly_err_item *err;
    uint32_t type_idx = 0;
    struct lyd_value orig = {0};
    struct lyplg_type *realtype_plg;
 
    if (!ctx) {
        assert(subvalue->ctx_node);
        ctx = subvalue->ctx_node->module->ctx;
    }
 
    /* because of types that do not store their own type as realtype (leafref), we are not able to call their
     * validate callback (there is no way to get the type) but even if possible, the value may be invalid
     * for the type, so we may have to perform union value storing again from scratch, but keep a value backup */
    realtype_plg = LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref);
    LY_CHECK_RET(realtype_plg->duplicate(ctx, &subvalue->value, &orig), NULL);
    realtype_plg->free(ctx, &subvalue->value);
 
    /* learn the type index, may fail if LYPLG_TYPE_STORE_ONLY has been used before */
    r = union_find_type(ctx, type_u, subvalue, 0, NULL, NULL, NULL, &type_idx, NULL, &err);
    ly_err_free(err);
    if (r && (r != LY_EINCOMPLETE)) {
        /* use LYPLG_TYPE_STORE_ONLY to manage to print the value */
        r = union_find_type(ctx, type_u, subvalue, LYPLG_TYPE_STORE_ONLY, NULL, NULL, NULL, &type_idx, NULL, &err);
        ly_err_free(err);
    }
    LY_CHECK_ERR_RET(r && (r != LY_EINCOMPLETE), subvalue->value = orig, NULL);
 
    /* create the LYB data of the resolved member type value */
    r = union_create_value_lyb(NULL, type_idx, &subvalue->value, &ret, value_size_bits, &err);
    ly_err_free(err);
    LY_CHECK_ERR_RET(r, subvalue->value = orig, NULL);
 
    /* restore backup (original) value */
    realtype_plg = LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref);
    realtype_plg->free(ctx, &subvalue->value);
    subvalue->value = orig;
    return ret;
}
 
static const void *
lyplg_type_print_union(const struct ly_ctx *ctx, const struct lyd_value *value, LY_VALUE_FORMAT format,
        void *prefix_data, ly_bool *dynamic, uint64_t *value_size_bits)
{
    const void *ret;
    struct lyd_value_union *subvalue = value->subvalue;
    struct lysc_type_union *type_u = (struct lysc_type_union *)value->realtype;
    uint64_t lyb_data_size_bits = 0;
 
    if ((format == LY_VALUE_LYB) && (subvalue->format == LY_VALUE_LYB)) {
        /* return value is ready */
        *dynamic = 0;
        if (value_size_bits) {
            *value_size_bits = subvalue->orig_size_bits;
        }
        return subvalue->original;
    } else if ((format == LY_VALUE_LYB) && (subvalue->format != LY_VALUE_LYB)) {
        /* return LYB data value must be created */
        *dynamic = 1;
        ret = union_print_value_lyb(ctx, type_u, subvalue, &lyb_data_size_bits);
        if (value_size_bits) {
            *value_size_bits = lyb_data_size_bits;
        }
        return ret;
    }
 
    assert(format != LY_VALUE_LYB);
    ret = (void *)LYSC_GET_TYPE_PLG(subvalue->value.realtype->plugin_ref)->print(ctx, &subvalue->value,
            format, prefix_data, dynamic, value_size_bits);
    if (!value->_canonical && (format == LY_VALUE_CANON)) {
        /* the canonical value is supposed to be stored now */
        lydict_dup(ctx, subvalue->value._canonical, (const char **)&value->_canonical);
    }
 
    return ret;
}
 
static LY_ERR
lyplg_type_dup_union(const struct ly_ctx *ctx, const struct lyd_value *original, struct lyd_value *dup)
{
    LY_ERR ret = LY_SUCCESS;
    struct lyd_value_union *orig_val = original->subvalue, *dup_val;
 
    /* init dup value */
    memset(dup, 0, sizeof *dup);
    dup->realtype = original->realtype;
 
    ret = lydict_insert(ctx, original->_canonical, 0, &dup->_canonical);
    LY_CHECK_GOTO(ret, cleanup);
 
    dup_val = calloc(1, sizeof *dup_val);
    LY_CHECK_ERR_GOTO(!dup_val, LOGMEM(ctx); ret = LY_EMEM, cleanup);
    dup->subvalue = dup_val;
 
    ret = LYSC_GET_TYPE_PLG(orig_val->value.realtype->plugin_ref)->duplicate(ctx, &orig_val->value, &dup_val->value);
    LY_CHECK_GOTO(ret, cleanup);
 
    if (orig_val->orig_size_bits) {
        dup_val->original = calloc(1, LYPLG_BITS2BYTES(orig_val->orig_size_bits));
        LY_CHECK_ERR_GOTO(!dup_val->original, LOGMEM(ctx); ret = LY_EMEM, cleanup);
        memcpy(dup_val->original, orig_val->original, LYPLG_BITS2BYTES(orig_val->orig_size_bits));
    } else {
        dup_val->original = strdup("");
        LY_CHECK_ERR_GOTO(!dup_val->original, LOGMEM(ctx); ret = LY_EMEM, cleanup);
    }
    dup_val->orig_size_bits = orig_val->orig_size_bits;
 
    dup_val->format = orig_val->format;
    dup_val->ctx_node = orig_val->ctx_node;
    dup_val->hints = orig_val->hints;
    ret = lyplg_type_prefix_data_dup(ctx, orig_val->format, orig_val->prefix_data, &dup_val->prefix_data);
    LY_CHECK_GOTO(ret, cleanup);
 
cleanup:
    if (ret) {
        lyplg_type_free_union(ctx, dup);
    }
    return ret;
}
 
static void
lyplg_type_free_union(const struct ly_ctx *ctx, struct lyd_value *value)
{
    struct lyd_value_union *val;
 
    lydict_remove(ctx, value->_canonical);
    value->_canonical = NULL;
    LYD_VALUE_GET(value, val);
    if (val) {
        if (val->value.realtype) {
            LYSC_GET_TYPE_PLG(val->value.realtype->plugin_ref)->free(ctx, &val->value);
        }
        lyplg_type_prefix_data_free(val->format, val->prefix_data);
        free(val->original);
 
        LYPLG_TYPE_VAL_INLINE_DESTROY(val);
    }
}
 
const struct lyplg_type_record plugins_union[] = {
    {
        .module = "",
        .revision = NULL,
        .name = LY_TYPE_UNION_STR,
 
        .plugin.id = "ly2 union",
        .plugin.lyb_size = lyplg_type_lyb_size_variable_bits,
        .plugin.store = lyplg_type_store_union,
        .plugin.validate_value = NULL,
        .plugin.validate_tree = lyplg_type_validate_tree_union,
        .plugin.compare = lyplg_type_compare_union,
        .plugin.sort = lyplg_type_sort_union,
        .plugin.print = lyplg_type_print_union,
        .plugin.duplicate = lyplg_type_dup_union,
        .plugin.free = lyplg_type_free_union,
    },
    {0}
};