wasm-micro-runtime/core/app-framework/app-native-shared/attr_container.c

/*
 * Copyright (C) 2019 Intel Corporation.  All rights reserved.
 * SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 */

#include "bi-inc/attr_container.h"

typedef union jvalue {
    bool z;
    int8_t i8;
    uint8_t u8;
    int16_t i16;
    uint16_t u16;
    int32_t i32;
    uint32_t u32;
    int64_t i64;
    uint64_t u64;
    float f;
    double d;
} jvalue;

static inline int16_t
get_int16(const char *buf)
{
    int16_t ret;
    bh_memcpy_s(&ret, sizeof(int16_t), buf, sizeof(int16_t));
    return ret;
}

static inline uint16_t
get_uint16(const char *buf)
{
    uint16_t ret;
    bh_memcpy_s(&ret, sizeof(uint16_t), buf, sizeof(uint16_t));
    return ret;
}

static inline int32_t
get_int32(const char *buf)
{
    int32_t ret;
    bh_memcpy_s(&ret, sizeof(int32_t), buf, sizeof(int32_t));
    return ret;
}

static inline uint32_t
get_uint32(const char *buf)
{
    uint32_t ret;
    bh_memcpy_s(&ret, sizeof(uint32_t), buf, sizeof(uint32_t));
    return ret;
}

static inline int64_t
get_int64(const char *buf)
{
    int64_t ret;
    bh_memcpy_s(&ret, sizeof(int64_t), buf, sizeof(int64_t));
    return ret;
}

static inline uint64_t
get_uint64(const char *buf)
{
    uint64_t ret;
    bh_memcpy_s(&ret, sizeof(uint64_t), buf, sizeof(uint64_t));
    return ret;
}

static inline void
set_int16(char *buf, int16_t v)
{
    bh_memcpy_s(buf, sizeof(int16_t), &v, sizeof(int16_t));
}

static inline void
set_uint16(char *buf, uint16_t v)
{
    bh_memcpy_s(buf, sizeof(uint16_t), &v, sizeof(uint16_t));
}

static inline void
set_int32(char *buf, int32_t v)
{
    bh_memcpy_s(buf, sizeof(int32_t), &v, sizeof(int32_t));
}

static inline void
set_uint32(char *buf, uint32_t v)
{
    bh_memcpy_s(buf, sizeof(uint32_t), &v, sizeof(uint32_t));
}

static inline void
set_int64(char *buf, int64_t v)
{
    bh_memcpy_s(buf, sizeof(int64_t), &v, sizeof(int64_t));
}

static inline void
set_uint64(char *buf, uint64_t v)
{
    bh_memcpy_s(buf, sizeof(uint64_t), &v, sizeof(uint64_t));
}

char *
attr_container_get_attr_begin(const attr_container_t *attr_cont,
                              uint32_t *p_total_length, uint16_t *p_attr_num)
{
    char *p = (char *)attr_cont->buf;
    uint16_t str_len, attr_num;
    uint32_t total_length;

    /* skip total length */
    total_length = get_uint32(p);
    p += sizeof(uint32_t);
    if (!total_length)
        return NULL;

    /* tag length */
    str_len = get_uint16(p);
    p += sizeof(uint16_t);
    if (!str_len)
        return NULL;

    /* tag content */
    p += str_len;
    if ((uint32_t)(p - attr_cont->buf) >= total_length)
        return NULL;

    /* attribute num */
    attr_num = get_uint16(p);
    p += sizeof(uint16_t);
    if ((uint32_t)(p - attr_cont->buf) >= total_length)
        return NULL;

    if (p_total_length)
        *p_total_length = total_length;

    if (p_attr_num)
        *p_attr_num = attr_num;

    /* first attribute */
    return p;
}

static char *
attr_container_get_attr_next(const char *curr_attr)
{
    char *p = (char *)curr_attr;
    uint8_t type;

    /* key length and key */
    p += sizeof(uint16_t) + get_uint16(p);
    type = *p++;

    /* Byte type to Boolean type */
    if (type >= ATTR_TYPE_BYTE && type <= ATTR_TYPE_BOOLEAN) {
        p += 1 << (type & 3);
        return p;
    }
    /* String type */
    else if (type == ATTR_TYPE_STRING) {
        p += sizeof(uint16_t) + get_uint16(p);
        return p;
    }
    /* ByteArray type */
    else if (type == ATTR_TYPE_BYTEARRAY) {
        p += sizeof(uint32_t) + get_uint32(p);
        return p;
    }

    return NULL;
}

static const char *
attr_container_find_attr(const attr_container_t *attr_cont, const char *key)
{
    uint32_t total_length;
    uint16_t str_len, attr_num, i;
    const char *p = attr_cont->buf;

    if (!key)
        return NULL;

    if (!(p = attr_container_get_attr_begin(attr_cont, &total_length,
                                            &attr_num)))
        return NULL;

    for (i = 0; i < attr_num; i++) {
        /* key length */
        if (!(str_len = get_uint16(p)))
            return NULL;

        if (str_len == strlen(key) + 1
            && memcmp(p + sizeof(uint16_t), key, str_len) == 0) {
            if ((uint32_t)(p + sizeof(uint16_t) + str_len - attr_cont->buf)
                >= total_length)
                return NULL;
            return p;
        }

        if (!(p = attr_container_get_attr_next(p)))
            return NULL;
    }

    return NULL;
}

char *
attr_container_get_attr_end(const attr_container_t *attr_cont)
{
    uint32_t total_length;
    uint16_t attr_num, i;
    char *p;

    if (!(p = attr_container_get_attr_begin(attr_cont, &total_length,
                                            &attr_num)))
        return NULL;

    for (i = 0; i < attr_num; i++)
        if (!(p = attr_container_get_attr_next(p)))
            return NULL;

    return p;
}

static char *
attr_container_get_msg_end(attr_container_t *attr_cont)
{
    char *p = attr_cont->buf;
    return p + get_uint32(p);
}

uint16_t
attr_container_get_attr_num(const attr_container_t *attr_cont)
{
    uint16_t str_len;
    /* skip total length */
    const char *p = attr_cont->buf + sizeof(uint32_t);

    str_len = get_uint16(p);
    /* skip tag length and tag */
    p += sizeof(uint16_t) + str_len;

    /* attribute num */
    return get_uint16(p);
}

static void
attr_container_inc_attr_num(attr_container_t *attr_cont)
{
    uint16_t str_len, attr_num;
    /* skip total length */
    char *p = attr_cont->buf + sizeof(uint32_t);

    str_len = get_uint16(p);
    /* skip tag length and tag */
    p += sizeof(uint16_t) + str_len;

    /* attribute num */
    attr_num = get_uint16(p) + 1;
    set_uint16(p, attr_num);
}

attr_container_t *
attr_container_create(const char *tag)
{
    attr_container_t *attr_cont;
    int length, tag_length;
    char *p;

    tag_length = tag ? strlen(tag) + 1 : 1;
    length = offsetof(attr_container_t, buf) +
             /* total length + tag length + tag + reserved 100 bytes */
             sizeof(uint32_t) + sizeof(uint16_t) + tag_length + 100;

    if (!(attr_cont = attr_container_malloc(length))) {
        attr_container_printf(
            "Create attr_container failed: allocate memory failed.\r\n");
        return NULL;
    }

    memset(attr_cont, 0, length);
    p = attr_cont->buf;

    /* total length */
    set_uint32(p, length - offsetof(attr_container_t, buf));
    p += 4;

    /* tag length, tag */
    set_uint16(p, tag_length);
    p += 2;
    if (tag)
        bh_memcpy_s(p, tag_length, tag, tag_length);

    return attr_cont;
}

void
attr_container_destroy(const attr_container_t *attr_cont)
{
    if (attr_cont)
        attr_container_free((char *)attr_cont);
}

static bool
check_set_attr(attr_container_t **p_attr_cont, const char *key)
{
    uint32_t flags;

    if (!p_attr_cont || !*p_attr_cont || !key || strlen(key) == 0) {
        attr_container_printf(
            "Set attribute failed: invalid input arguments.\r\n");
        return false;
    }

    flags = get_uint32((char *)*p_attr_cont);
    if (flags & ATTR_CONT_READONLY_SHIFT) {
        attr_container_printf(
            "Set attribute failed: attribute container is readonly.\r\n");
        return false;
    }

    return true;
}

bool
attr_container_set_attr(attr_container_t **p_attr_cont, const char *key,
                        int type, const void *value, int value_length)
{
    attr_container_t *attr_cont, *attr_cont1;
    uint16_t str_len;
    uint32_t total_length, attr_len;
    char *p, *p1, *attr_end, *msg_end, *attr_buf;

    if (!check_set_attr(p_attr_cont, key)) {
        return false;
    }

    attr_cont = *p_attr_cont;
    p = attr_cont->buf;
    total_length = get_uint32(p);

    if (!(attr_end = attr_container_get_attr_end(attr_cont))) {
        attr_container_printf("Set attr failed: get attr end failed.\r\n");
        return false;
    }

    msg_end = attr_container_get_msg_end(attr_cont);

    /* key len + key + '\0' + type */
    attr_len = sizeof(uint16_t) + strlen(key) + 1 + 1;
    if (type >= ATTR_TYPE_BYTE && type <= ATTR_TYPE_BOOLEAN)
        attr_len += 1 << (type & 3);
    else if (type == ATTR_TYPE_STRING)
        attr_len += sizeof(uint16_t) + value_length;
    else if (type == ATTR_TYPE_BYTEARRAY)
        attr_len += sizeof(uint32_t) + value_length;

    if (!(p = attr_buf = attr_container_malloc(attr_len))) {
        attr_container_printf("Set attr failed: allocate memory failed.\r\n");
        return false;
    }

    /* Set the attr buf */
    str_len = (uint16_t)(strlen(key) + 1);
    set_uint16(p, str_len);
    p += sizeof(uint16_t);
    bh_memcpy_s(p, str_len, key, str_len);
    p += str_len;

    *p++ = type;
    if (type >= ATTR_TYPE_BYTE && type <= ATTR_TYPE_BOOLEAN)
        bh_memcpy_s(p, 1 << (type & 3), value, 1 << (type & 3));
    else if (type == ATTR_TYPE_STRING) {
        set_uint16(p, value_length);
        p += sizeof(uint16_t);
        bh_memcpy_s(p, value_length, value, value_length);
    }
    else if (type == ATTR_TYPE_BYTEARRAY) {
        set_uint32(p, value_length);
        p += sizeof(uint32_t);
        bh_memcpy_s(p, value_length, value, value_length);
    }

    if ((p = (char *)attr_container_find_attr(attr_cont, key))) {
        /* key found */
        p1 = attr_container_get_attr_next(p);

        if (p1 - p == attr_len) {
            bh_memcpy_s(p, attr_len, attr_buf, attr_len);
            attr_container_free(attr_buf);
            return true;
        }

        if ((uint32_t)(p1 - p + msg_end - attr_end) >= attr_len) {
            memmove(p, p1, attr_end - p1);
            bh_memcpy_s(p + (attr_end - p1), attr_len, attr_buf, attr_len);
            attr_container_free(attr_buf);
            return true;
        }

        total_length += attr_len + 100;
        if (!(attr_cont1 = attr_container_malloc(offsetof(attr_container_t, buf)
                                                 + total_length))) {
            attr_container_printf(
                "Set attr failed: allocate memory failed.\r\n");
            attr_container_free(attr_buf);
            return false;
        }

        bh_memcpy_s(attr_cont1, p - (char *)attr_cont, attr_cont,
                    p - (char *)attr_cont);
        bh_memcpy_s((char *)attr_cont1 + (unsigned)(p - (char *)attr_cont),
                    attr_end - p1, p1, attr_end - p1);
        bh_memcpy_s((char *)attr_cont1 + (unsigned)(p - (char *)attr_cont)
                        + (unsigned)(attr_end - p1),
                    attr_len, attr_buf, attr_len);
        p = attr_cont1->buf;
        set_uint32(p, total_length);
        *p_attr_cont = attr_cont1;
        /* Free original buffer */
        attr_container_free(attr_cont);
        attr_container_free(attr_buf);
        return true;
    }
    else {
        /* key not found */
        if ((uint32_t)(msg_end - attr_end) >= attr_len) {
            bh_memcpy_s(attr_end, msg_end - attr_end, attr_buf, attr_len);
            attr_container_inc_attr_num(attr_cont);
            attr_container_free(attr_buf);
            return true;
        }

        total_length += attr_len + 100;
        if (!(attr_cont1 = attr_container_malloc(offsetof(attr_container_t, buf)
                                                 + total_length))) {
            attr_container_printf(
                "Set attr failed: allocate memory failed.\r\n");
            attr_container_free(attr_buf);
            return false;
        }

        bh_memcpy_s(attr_cont1, attr_end - (char *)attr_cont, attr_cont,
                    attr_end - (char *)attr_cont);
        bh_memcpy_s((char *)attr_cont1
                        + (unsigned)(attr_end - (char *)attr_cont),
                    attr_len, attr_buf, attr_len);
        attr_container_inc_attr_num(attr_cont1);
        p = attr_cont1->buf;
        set_uint32(p, total_length);
        *p_attr_cont = attr_cont1;
        /* Free original buffer */
        attr_container_free(attr_cont);
        attr_container_free(attr_buf);
        return true;
    }

    return false;
}

bool
attr_container_set_short(attr_container_t **p_attr_cont, const char *key,
                         short value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_SHORT, &value,
                                   2);
}

bool
attr_container_set_int16(attr_container_t **p_attr_cont, const char *key,
                         int16_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_INT16, &value,
                                   2);
}

bool
attr_container_set_int(attr_container_t **p_attr_cont, const char *key,
                       int value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_INT, &value, 4);
}

bool
attr_container_set_int32(attr_container_t **p_attr_cont, const char *key,
                         int32_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_INT32, &value,
                                   4);
}

bool
attr_container_set_uint32(attr_container_t **p_attr_cont, const char *key,
                          uint32_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_UINT32, &value,
                                   4);
}

bool
attr_container_set_int64(attr_container_t **p_attr_cont, const char *key,
                         int64_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_INT64, &value,
                                   8);
}

bool
attr_container_set_uint64(attr_container_t **p_attr_cont, const char *key,
                          uint64_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_UINT64, &value,
                                   8);
}

bool
attr_container_set_byte(attr_container_t **p_attr_cont, const char *key,
                        int8_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_BYTE, &value, 1);
}

bool
attr_container_set_int8(attr_container_t **p_attr_cont, const char *key,
                        int8_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_INT8, &value, 1);
}

bool
attr_container_set_uint8(attr_container_t **p_attr_cont, const char *key,
                         uint8_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_UINT8, &value,
                                   1);
}

bool
attr_container_set_uint16(attr_container_t **p_attr_cont, const char *key,
                          uint16_t value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_UINT16, &value,
                                   2);
}

bool
attr_container_set_float(attr_container_t **p_attr_cont, const char *key,
                         float value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_FLOAT, &value,
                                   4);
}

bool
attr_container_set_double(attr_container_t **p_attr_cont, const char *key,
                          double value)
{
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_DOUBLE, &value,
                                   8);
}

bool
attr_container_set_bool(attr_container_t **p_attr_cont, const char *key,
                        bool value)
{
    int8_t value1 = value ? 1 : 0;
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_BOOLEAN, &value1,
                                   1);
}

bool
attr_container_set_string(attr_container_t **p_attr_cont, const char *key,
                          const char *value)
{
    if (!value) {
        attr_container_printf("Set attr failed: invald input arguments.\r\n");
        return false;
    }
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_STRING, value,
                                   strlen(value) + 1);
}

bool
attr_container_set_bytearray(attr_container_t **p_attr_cont, const char *key,
                             const int8_t *value, unsigned length)
{
    if (!value) {
        attr_container_printf("Set attr failed: invald input arguments.\r\n");
        return false;
    }
    return attr_container_set_attr(p_attr_cont, key, ATTR_TYPE_BYTEARRAY, value,
                                   length);
}

static const char *
attr_container_get_attr(const attr_container_t *attr_cont, const char *key)
{
    const char *attr_addr;

    if (!attr_cont || !key) {
        attr_container_printf(
            "Get attribute failed: invalid input arguments.\r\n");
        return NULL;
    }

    if (!(attr_addr = attr_container_find_attr(attr_cont, key))) {
        attr_container_printf("Get attribute failed: lookup key failed.\r\n");
        return NULL;
    }

    /* key len + key + '\0' */
    return attr_addr + 2 + strlen(key) + 1;
}

#define TEMPLATE_ATTR_BUF_TO_VALUE(attr, key, var_name)                      \
    do {                                                                     \
        jvalue val;                                                          \
        const char *addr = attr_container_get_attr(attr, key);               \
        uint8_t type;                                                        \
        if (!addr)                                                           \
            return 0;                                                        \
        val.i64 = 0;                                                         \
        type = *(uint8_t *)addr++;                                           \
        switch (type) {                                                      \
            case ATTR_TYPE_BYTE:  /* = ATTR_TYPE_INT8 */                     \
            case ATTR_TYPE_SHORT: /* = ATTR_TYPE_INT16 */                    \
            case ATTR_TYPE_INT:   /* = ATTR_TYPE_INT32 */                    \
            case ATTR_TYPE_INT64:                                            \
            case ATTR_TYPE_UINT8:                                            \
            case ATTR_TYPE_UINT16:                                           \
            case ATTR_TYPE_UINT32:                                           \
            case ATTR_TYPE_UINT64:                                           \
            case ATTR_TYPE_FLOAT:                                            \
            case ATTR_TYPE_DOUBLE:                                           \
            case ATTR_TYPE_BOOLEAN:                                          \
                bh_memcpy_s(&val, sizeof(val.var_name), addr,                \
                            1 << (type & 3));                                \
                break;                                                       \
            case ATTR_TYPE_STRING:                                           \
            {                                                                \
                unsigned len = get_uint16(addr);                             \
                addr += 2;                                                   \
                if (len > sizeof(val.var_name))                              \
                    len = sizeof(val.var_name);                              \
                bh_memcpy_s(&val.var_name, sizeof(val.var_name), addr, len); \
                break;                                                       \
            }                                                                \
            case ATTR_TYPE_BYTEARRAY:                                        \
            {                                                                \
                unsigned len = get_uint32(addr);                             \
                addr += 4;                                                   \
                if (len > sizeof(val.var_name))                              \
                    len = sizeof(val.var_name);                              \
                bh_memcpy_s(&val.var_name, sizeof(val.var_name), addr, len); \
                break;                                                       \
            }                                                                \
            default:                                                         \
                bh_assert(0);                                                \
                break;                                                       \
        }                                                                    \
        return val.var_name;                                                 \
    } while (0)

short
attr_container_get_as_short(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, i16);
}

int16_t
attr_container_get_as_int16(const attr_container_t *attr_cont, const char *key)
{
    return (int16_t)attr_container_get_as_short(attr_cont, key);
}

int
attr_container_get_as_int(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, i32);
}

int32_t
attr_container_get_as_int32(const attr_container_t *attr_cont, const char *key)
{
    return (int32_t)attr_container_get_as_int(attr_cont, key);
}

uint32_t
attr_container_get_as_uint32(const attr_container_t *attr_cont, const char *key)
{
    return (uint32_t)attr_container_get_as_int(attr_cont, key);
}

int64_t
attr_container_get_as_int64(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, i64);
}

uint64_t
attr_container_get_as_uint64(const attr_container_t *attr_cont, const char *key)
{
    return (uint64_t)attr_container_get_as_int64(attr_cont, key);
}

int8_t
attr_container_get_as_byte(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, i8);
}

int8_t
attr_container_get_as_int8(const attr_container_t *attr_cont, const char *key)
{
    return attr_container_get_as_byte(attr_cont, key);
}

uint8_t
attr_container_get_as_uint8(const attr_container_t *attr_cont, const char *key)
{
    return (uint8_t)attr_container_get_as_byte(attr_cont, key);
}

uint16_t
attr_container_get_as_uint16(const attr_container_t *attr_cont, const char *key)
{
    return (uint16_t)attr_container_get_as_short(attr_cont, key);
}

float
attr_container_get_as_float(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, f);
}

double
attr_container_get_as_double(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, d);
}

bool
attr_container_get_as_bool(const attr_container_t *attr_cont, const char *key)
{
    TEMPLATE_ATTR_BUF_TO_VALUE(attr_cont, key, z);
}

const int8_t *
attr_container_get_as_bytearray(const attr_container_t *attr_cont,
                                const char *key, unsigned *array_length)
{
    const char *addr = attr_container_get_attr(attr_cont, key);
    uint8_t type;
    uint32_t length;

    if (!addr)
        return NULL;

    if (!array_length) {
        attr_container_printf("Get attribute failed: invalid input arguments.");
        return NULL;
    }

    type = *(uint8_t *)addr++;
    switch (type) {
        case ATTR_TYPE_BYTE:  /* = ATTR_TYPE_INT8 */
        case ATTR_TYPE_SHORT: /* = ATTR_TYPE_INT16 */
        case ATTR_TYPE_INT:   /* = ATTR_TYPE_INT32 */
        case ATTR_TYPE_INT64:
        case ATTR_TYPE_UINT8:
        case ATTR_TYPE_UINT16:
        case ATTR_TYPE_UINT32:
        case ATTR_TYPE_UINT64:
        case ATTR_TYPE_FLOAT:
        case ATTR_TYPE_DOUBLE:
        case ATTR_TYPE_BOOLEAN:
            length = 1 << (type & 3);
            break;
        case ATTR_TYPE_STRING:
            length = get_uint16(addr);
            addr += 2;
            break;
        case ATTR_TYPE_BYTEARRAY:
            length = get_uint32(addr);
            addr += 4;
            break;
        default:
            return NULL;
    }

    *array_length = length;
    return (const int8_t *)addr;
}

char *
attr_container_get_as_string(const attr_container_t *attr_cont, const char *key)
{
    unsigned array_length;
    return (char *)attr_container_get_as_bytearray(attr_cont, key,
                                                   &array_length);
}

const char *
attr_container_get_tag(const attr_container_t *attr_cont)
{
    return attr_cont ? attr_cont->buf + sizeof(uint32_t) + sizeof(uint16_t)
                     : NULL;
}

bool
attr_container_contain_key(const attr_container_t *attr_cont, const char *key)
{
    if (!attr_cont || !key || !strlen(key)) {
        attr_container_printf(
            "Check contain key failed: invalid input arguments.\r\n");
        return false;
    }
    return attr_container_find_attr(attr_cont, key) ? true : false;
}

unsigned int
attr_container_get_serialize_length(const attr_container_t *attr_cont)
{
    const char *p;

    if (!attr_cont) {
        attr_container_printf("Get container serialize length failed: invalid "
                              "input arguments.\r\n");
        return 0;
    }

    p = attr_cont->buf;
    return sizeof(uint16_t) + get_uint32(p);
}

bool
attr_container_serialize(char *buf, const attr_container_t *attr_cont)
{
    const char *p;
    uint16_t flags;
    uint32_t length;

    if (!buf || !attr_cont) {
        attr_container_printf(
            "Container serialize failed: invalid input arguments.\r\n");
        return false;
    }

    p = attr_cont->buf;
    length = sizeof(uint16_t) + get_uint32(p);
    bh_memcpy_s(buf, length, attr_cont, length);
    /* Set readonly */
    flags = get_uint16((const char *)attr_cont);
    set_uint16(buf, flags | (1 << ATTR_CONT_READONLY_SHIFT));

    return true;
}

bool
attr_container_is_constant(const attr_container_t *attr_cont)
{
    uint16_t flags;

    if (!attr_cont) {
        attr_container_printf(
            "Container check const: invalid input arguments.\r\n");
        return false;
    }

    flags = get_uint16((const char *)attr_cont);
    return (flags & (1 << ATTR_CONT_READONLY_SHIFT)) ? true : false;
}

void
attr_container_dump(const attr_container_t *attr_cont)
{
    uint32_t total_length;
    uint16_t attr_num, i, type;
    const char *p, *tag, *key;
    jvalue value;

    if (!attr_cont)
        return;

    tag = attr_container_get_tag(attr_cont);
    if (!tag)
        return;

    attr_container_printf("Attribute container dump:\n");
    attr_container_printf("Tag: %s\n", tag);

    p = attr_container_get_attr_begin(attr_cont, &total_length, &attr_num);
    if (!p)
        return;

    attr_container_printf("Attribute list:\n");
    for (i = 0; i < attr_num; i++) {
        key = p + 2;
        /* Skip key len and key */
        p += 2 + get_uint16(p);
        type = *p++;
        attr_container_printf("  key: %s", key);

        switch (type) {
            case ATTR_TYPE_BYTE: /* = ATTR_TYPE_INT8 */
                bh_memcpy_s(&value.i8, 1, p, 1);
                attr_container_printf(", type: byte, value: 0x%x\n",
                                      value.i8 & 0xFF);
                p++;
                break;
            case ATTR_TYPE_SHORT: /* = ATTR_TYPE_INT16 */
                bh_memcpy_s(&value.i16, sizeof(int16_t), p, sizeof(int16_t));
                attr_container_printf(", type: short, value: 0x%x\n",
                                      value.i16 & 0xFFFF);
                p += 2;
                break;
            case ATTR_TYPE_INT: /* = ATTR_TYPE_INT32 */
                bh_memcpy_s(&value.i32, sizeof(int32_t), p, sizeof(int32_t));
                attr_container_printf(", type: int, value: 0x%x\n", value.i32);
                p += 4;
                break;
            case ATTR_TYPE_INT64:
                bh_memcpy_s(&value.i64, sizeof(int64_t), p, sizeof(int64_t));
                attr_container_printf(", type: int64, value: 0x%llx\n",
                                      (long long unsigned int)(value.i64));
                p += 8;
                break;
            case ATTR_TYPE_UINT8:
                bh_memcpy_s(&value.u8, 1, p, 1);
                attr_container_printf(", type: uint8, value: 0x%x\n", value.u8);
                p++;
                break;
            case ATTR_TYPE_UINT16:
                bh_memcpy_s(&value.u16, sizeof(uint16_t), p, sizeof(uint16_t));
                attr_container_printf(", type: uint16, value: 0x%x\n",
                                      value.u16);
                p += 2;
                break;
            case ATTR_TYPE_UINT32:
                bh_memcpy_s(&value.u32, sizeof(uint32_t), p, sizeof(uint32_t));
                attr_container_printf(", type: uint32, value: 0x%x\n",
                                      value.u32);
                p += 4;
                break;
            case ATTR_TYPE_UINT64:
                bh_memcpy_s(&value.u64, sizeof(uint64_t), p, sizeof(uint64_t));
                attr_container_printf(", type: int64, value: 0x%llx\n",
                                      (long long unsigned int)(value.u64));
                p += 8;
                break;
            case ATTR_TYPE_FLOAT:
                bh_memcpy_s(&value.f, sizeof(float), p, sizeof(float));
                attr_container_printf(", type: float, value: %f\n", value.f);
                p += 4;
                break;
            case ATTR_TYPE_DOUBLE:
                bh_memcpy_s(&value.d, sizeof(double), p, sizeof(double));
                attr_container_printf(", type: double, value: %f\n", value.d);
                p += 8;
                break;
            case ATTR_TYPE_BOOLEAN:
                bh_memcpy_s(&value.z, 1, p, 1);
                attr_container_printf(", type: bool, value: 0x%x\n", value.z);
                p++;
                break;
            case ATTR_TYPE_STRING:
                attr_container_printf(", type: string, value: %s\n",
                                      p + sizeof(uint16_t));
                p += sizeof(uint16_t) + get_uint16(p);
                break;
            case ATTR_TYPE_BYTEARRAY:
                attr_container_printf(", type: byte array, length: %d\n",
                                      get_uint32(p));
                p += sizeof(uint32_t) + get_uint32(p);
                break;
            default:
                bh_assert(0);
                break;
        }
    }

    attr_container_printf("\n");
}