cborattr/include/cborattr/cborattr.h

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */


#ifndef CBORATTR_H
#define CBORATTR_H

#include <stdbool.h>
#include <stdint.h>
#include <ctype.h>
#include <stdio.h>
#include <sys/types.h>
#include "tinycbor/cbor.h"

#ifdef MYNEWT
#include <os/os_mbuf.h>
#endif

#ifdef __cplusplus
extern "C" {
#endif

/* This library wraps the tinycbor decoder with a attribute based decoder
 * suitable for decoding a binary version of json.  Specifically, the
 * contents of the cbor contains pairs of attributes.  where the attribute
 * is a key/value pair.  keys are always text strings, but values can be
 * many different things (enumerated below) */

typedef enum CborAttrType {
    CborAttrIntegerType = 1,
    CborAttrUnsignedIntegerType,
    CborAttrByteStringType,
    CborAttrTextStringType,
    CborAttrBooleanType,
    CborAttrHalfFloatType,
    CborAttrFloatType,
    CborAttrDoubleType,
    CborAttrArrayType,
    CborAttrObjectType,
    CborAttrStructObjectType,
    CborAttrNullType,
} CborAttrType;

struct cbor_attr_t;

struct cbor_enum_t {
    char *name;
    long long int value;
};

struct cbor_array_t {
    CborAttrType element_type;
    union {
        struct {
            const struct cbor_attr_t *subtype;
            char *base;
            size_t stride;
        } objects;
        struct {
            char **ptrs;
            char *store;
            int storelen;
        } strings;
        struct {
            long long int *store;
        } integers;
        struct {
            long long unsigned int *store;
        } uintegers;
        struct {
            double *store;
        } reals;
        struct{
            uint16_t *store;
        } halffloats;
        struct {
            bool *store;
        } booleans;
    } arr;
    int *count;
    int maxlen;
};

struct cbor_attr_t {
    char *attribute;
    CborAttrType type;
    union {
        long long int *integer;
        long long unsigned int *uinteger;
        uint16_t *halffloat;
        double *real;
        float *fval;
        char *string;
        bool *boolean;
        struct byte_string {
            uint8_t *data;
            size_t *len;
        } bytestring;
        struct cbor_array_t array;
        size_t offset;
        struct cbor_attr_t *obj;
    } addr;
    union {
        long long int integer;
        double real;
        bool boolean;
        float fval;
        uint16_t halffloat;
    } dflt;
    size_t len;
    bool nodefault;
};

#ifndef __ZEPHYR__
/** An array value to be encoded as CBOR. */
struct cbor_out_arr_val_t {
    struct cbor_out_val_t *elems;
    size_t len;
};

/** A single value to be encoded as CBOR. */
struct cbor_out_val_t {
    /** The type of data. */
    CborAttrType type;

    /** The data value. */
    union {
        long long int integer;
        long long unsigned int uinteger;
        double real;
        float fval;
        uint16_t halffloat;
        const char *string;
        bool boolean;
        struct {
            const uint8_t *data;
            size_t len;
        } bytestring;
        struct cbor_out_arr_val_t array;
        struct cbor_out_attr_t *obj; /* Terminated with a type=0 entry. */
    };
};

/** An object key-value pair to be encoded as CBOR. */
struct cbor_out_attr_t {
    const char *attribute;      /** The attribute name (key). */
    struct cbor_out_val_t val;  /** The attribute value. */
    bool omit;                  /** Attribute ignored if true. */
};
#endif

/*
 * Use the following macros to declare template initializers for
 * CborAttrStructObjectType arrays. Writing the equivalents out by hand is
 * error-prone.
 *
 * CBOR_STRUCT_OBJECT takes a structure name s, and a fieldname f in s.
 *
 * CBOR_STRUCT_ARRAY takes the name of a structure array, a pointer to a an
 * initializer defining the subobject type, and the address of an integer to
 * store the length in.
 */
#define CBORATTR_STRUCT_OBJECT(s, f)        .addr.offset = offsetof(s, f)
#define CBORATTR_STRUCT_ARRAY(a, e, n)                                  \
    .addr.array.element_type = CborAttrStructObjectType,                \
    .addr.array.arr.objects.subtype = e,                                \
    .addr.array.arr.objects.base = (char*)a,                            \
    .addr.array.arr.objects.stride = sizeof(a[0]),                      \
    .addr.array.count = n,                                              \
    .addr.array.maxlen = (int)(sizeof(a)/sizeof(a[0]))

#define CBORATTR_ATTR_UNNAMED (char *)(-1)

int cbor_read_object(struct CborValue *, const struct cbor_attr_t *);
int cbor_read_array(struct CborValue *, const struct cbor_array_t *);

int cbor_read_flat_attrs(const uint8_t *data, int len,
                         const struct cbor_attr_t *attrs);
#ifdef MYNEWT
int cbor_read_mbuf_attrs(struct os_mbuf *m, uint16_t off, uint16_t len,
                         const struct cbor_attr_t *attrs);

/**
 * @brief Encodes a CBOR representation of the specified key-value map.
 *
 * @param enc                   The CBOR encoder to write to.
 * @param attrs                 The key-value map to encode.
 *
 * @return                      0 on success; SYS_E[...] error on failure.
 */
int cbor_write_object(struct CborEncoder *enc,
                      const struct cbor_out_attr_t *attrs);

/**
 * @brief Encodes a CBOR representation of the specified key-value map into an
 * msys mbuf chain.
 *
 * @param attrs                 The key-value map to encode.
 * @param out_om                On success, points to the populate mbuf chain.
 *
 * @return                      0 on success; SYS_E[...] error on failure.
 */
int cbor_write_object_msys(const struct cbor_out_attr_t *attrs,
                           struct os_mbuf **out_om);
#endif
#ifdef __cplusplus
}
#endif

#endif /* CBORATTR_H */