tlv.h

Go to the documentation of this file.

#pragma once
 
#include <stdint.h>
#include <string.h>
 
#include <osmocom/core/msgb.h>
#include <osmocom/core/byteswap.h>
#include <osmocom/core/bit16gen.h>
#include <osmocom/core/bit32gen.h>
 
/* Terminology / wording
                tag     length          value   (in bits)
 
            V   -       -               8
           LV   -       8               N * 8
          TLV   8       8               N * 8
        TL16V   8       16              N * 8
        TLV16   8       8               N * 16
         TvLV   8       8/16            N * 8
        vTvLV   8/16    8/16            N * 8
        T16LV   16      8               N * 8
*/
 
#define LV_GROSS_LEN(x)         (x+1)
#define TLV_GROSS_LEN(x)        (x+2)
#define TLV16_GROSS_LEN(x)      ((2*x)+2)
#define TL16V_GROSS_LEN(x)      (x+3)
#define L16TV_GROSS_LEN(x)      (x+3)
#define T16LV_GROSS_LEN(x)      (x+3)
 
#define TVLV_MAX_ONEBYTE        0x7f
 
enum osmo_tlv_parser_error {
        OSMO_TLVP_ERR_OFS_BEYOND_BUFFER         = -1,
        OSMO_TLVP_ERR_OFS_LEN_BEYOND_BUFFER     = -2,
        OSMO_TLVP_ERR_UNKNOWN_TLV_TYPE          = -3,
 
        OSMO_TLVP_ERR_MAND_IE_MISSING           = -50,
        OSMO_TLVP_ERR_IE_TOO_SHORT              = -51,
};
 
static inline uint16_t TVLV_GROSS_LEN(uint16_t len)
{
        if (len <= TVLV_MAX_ONEBYTE)
                return TLV_GROSS_LEN(len);
        else
                return TL16V_GROSS_LEN(len);
}
 
static inline uint16_t VTVL_GAN_GROSS_LEN(uint16_t tag, uint16_t len)
{
        uint16_t ret = 2;
 
        if (tag > TVLV_MAX_ONEBYTE)
                ret++;
 
        if (len > TVLV_MAX_ONEBYTE)
                ret++;
 
        return ret;
}
 
static inline uint16_t VTVLV_GAN_GROSS_LEN(uint16_t tag, uint16_t len)
{
        uint16_t ret;
 
        if (len <= TVLV_MAX_ONEBYTE)
                ret = TLV_GROSS_LEN(len);
        else
                ret = TL16V_GROSS_LEN(len);
 
        if (tag > TVLV_MAX_ONEBYTE)
                ret += 1;
 
        return ret;
}
 
/* TLV generation */
 
static inline uint8_t *lv_put(uint8_t *buf, uint8_t len,
                                const uint8_t *val)
{
        *buf++ = len;
        memcpy(buf, val, len);
        return buf + len;
}
 
static inline uint8_t *tlv_put(uint8_t *buf, uint8_t tag, uint8_t len,
                                const uint8_t *val)
{
        *buf++ = tag;
        *buf++ = len;
        if (len) {
                if (val)
                        memcpy(buf, val, len);
                else
                        memset(buf, 0, len);
        }
        return buf + len;
}
 
static inline uint8_t *tl_put(uint8_t *buf, uint8_t tag, uint8_t len)
{
        *buf++ = tag;
        *buf++ = len;
        return buf;
}
 
static inline uint8_t *tlv16_put(uint8_t *buf, uint8_t tag, uint8_t len,
                                const uint16_t *val)
{
        *buf++ = tag;
        *buf++ = len;
        memcpy(buf, val, len*2);
        return buf + len*2;
}
 
static inline uint8_t *tl16v_put(uint8_t *buf, uint8_t tag, uint16_t len,
                                const uint8_t *val)
{
        *buf++ = tag;
        *buf++ = len >> 8;
        *buf++ = len & 0xff;
        memcpy(buf, val, len);
        return buf + len;
}
 
static inline uint8_t *tl16_put(uint8_t *buf, uint8_t tag, uint16_t len)
{
        *buf++ = tag;
        *buf++ = len >> 8;
        *buf++ = len & 0xff;
        return buf;
}
 
static inline uint8_t *t16lv_put(uint8_t *buf, uint16_t tag, uint8_t len,
                                const uint8_t *val)
{
        *buf++ = tag >> 8;
        *buf++ = tag & 0xff;
        *buf++ = len;
        memcpy(buf, val, len);
        return buf + len;
}
 
static inline uint8_t *tvlv_put(uint8_t *buf, uint8_t tag, uint16_t len,
                                 const uint8_t *val)
{
        uint8_t *ret;
 
        if (len <= TVLV_MAX_ONEBYTE) {
                ret = tlv_put(buf, tag, len, val);
                buf[1] |= 0x80;
        } else
                ret = tl16v_put(buf, tag, len, val);
 
        return ret;
}
 
static inline uint8_t *tvl_put(uint8_t *buf, uint8_t tag, uint16_t len)
{
        uint8_t *ret;
 
        if (len <= TVLV_MAX_ONEBYTE) {
                ret = tl_put(buf, tag, len);
                buf[1] |= 0x80;
        } else
                ret = tl16_put(buf, tag, len);
 
        return ret;
}
 
static inline uint8_t *vt_gan_put(uint8_t *buf, uint16_t tag)
{
        if (tag > TVLV_MAX_ONEBYTE) {
                /* two-byte TAG */
                *buf++ = 0x80 | (tag >> 8);
                *buf++ = (tag & 0xff);
        } else
                *buf++ = tag;
 
        return buf;
}
 
/* put (append) vTvL (GAN) field (tag + length)*/
static inline uint8_t *vtvl_gan_put(uint8_t *buf, uint16_t tag, uint16_t len)
{
        uint8_t *ret;
 
        ret = vt_gan_put(buf, tag);
        return vt_gan_put(ret, len);
}
 
/* put (append) vTvLV (GAN) field (tag + length + val) */
static inline uint8_t *vtvlv_gan_put(uint8_t *buf, uint16_t tag, uint16_t len,
                                      const uint8_t *val)
{
        uint8_t *ret;
 
        ret = vtvl_gan_put(buf, tag, len );
 
        memcpy(ret, val, len);
        ret = buf + len;
 
        return ret;
}
 
static inline uint8_t *msgb_tlv16_put(struct msgb *msg, uint8_t tag, uint8_t len, const uint16_t *val)
{
        uint8_t *buf = msgb_put(msg, TLV16_GROSS_LEN(len));
        return tlv16_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_tl16v_put(struct msgb *msg, uint8_t tag, uint16_t len,
                                        const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, TL16V_GROSS_LEN(len));
        return tl16v_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_t16lv_put(struct msgb *msg, uint16_t tag, uint8_t len, const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, T16LV_GROSS_LEN(len));
        return t16lv_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_tvl_put(struct msgb *msg, uint8_t tag, uint16_t len)
{
        uint8_t *buf = msgb_put(msg, TVLV_GROSS_LEN(len));
        return tvl_put(buf, tag, len);
}
 
static inline uint8_t *msgb_tvlv_put(struct msgb *msg, uint8_t tag, uint16_t len,
                                      const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, TVLV_GROSS_LEN(len));
        return tvlv_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_tvlv_put_16be(struct msgb *msg, uint8_t tag, uint16_t val)
{
        uint16_t val_be = osmo_htons(val);
        return msgb_tvlv_put(msg, tag, 2, (const uint8_t *)&val_be);
}
 
static inline uint8_t *msgb_tvlv_put_32be(struct msgb *msg, uint8_t tag, uint32_t val)
{
        uint32_t val_be = osmo_htonl(val);
        return msgb_tvlv_put(msg, tag, 4, (const uint8_t *)&val_be);
}
 
static inline uint8_t *msgb_vtvlv_gan_put(struct msgb *msg, uint16_t tag,
                                          uint16_t len, const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, VTVLV_GAN_GROSS_LEN(tag, len));
        return vtvlv_gan_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_l16tv_put(struct msgb *msg, uint16_t len, uint8_t tag,
                                       const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, L16TV_GROSS_LEN(len));
 
        *buf++ = len >> 8;
        *buf++ = len & 0xff;
        *buf++ = tag;
        memcpy(buf, val, len);
        return buf + len;
}
 
static inline uint8_t *v_put(uint8_t *buf, uint8_t val)
{
        *buf++ = val;
        return buf;
}
 
static inline uint8_t *tv_put(uint8_t *buf, uint8_t tag,
                                uint8_t val)
{
        *buf++ = tag;
        *buf++ = val;
        return buf;
}
 
static inline uint8_t *tv_fixed_put(uint8_t *buf, uint8_t tag,
                                    unsigned int len, const uint8_t *val)
{
        *buf++ = tag;
        memcpy(buf, val, len);
        return buf + len;
}
 
static inline uint8_t *tv16_put(uint8_t *buf, uint8_t tag,
                                 uint16_t val)
{
        *buf++ = tag;
        *buf++ = val >> 8;
        *buf++ = val & 0xff;
        return buf;
}
 
static inline uint8_t *msgb_lv_put(struct msgb *msg, uint8_t len, const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, LV_GROSS_LEN(len));
        return lv_put(buf, len, val);
}
 
static inline uint8_t *msgb_tlv_put(struct msgb *msg, uint8_t tag, uint8_t len, const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, TLV_GROSS_LEN(len));
        return tlv_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_tv_put(struct msgb *msg, uint8_t tag, uint8_t val)
{
        uint8_t *buf = msgb_put(msg, 2);
        return tv_put(buf, tag, val);
}
 
static inline uint8_t *msgb_tv_fixed_put(struct msgb *msg, uint8_t tag,
                                        unsigned int len, const uint8_t *val)
{
        uint8_t *buf = msgb_put(msg, 1+len);
        return tv_fixed_put(buf, tag, len, val);
}
 
static inline uint8_t *msgb_v_put(struct msgb *msg, uint8_t val)
{
        uint8_t *buf = msgb_put(msg, 1);
        return v_put(buf, val);
}
 
static inline uint8_t *msgb_tl_put(struct msgb *msg, uint8_t tag)
{
        uint8_t *len = msgb_v_put(msg, tag);
 
        /* reserve space for length, len points to this reserved space already */
        msgb_v_put(msg, 0);
 
        return len;
}
 
static inline uint8_t *msgb_tv16_put(struct msgb *msg, uint8_t tag, uint16_t val)
{
        uint8_t *buf = msgb_put(msg, 3);
        return tv16_put(buf, tag, val);
}
 
static inline uint8_t *msgb_tv32_put(struct msgb *msg, uint8_t tag, uint32_t val)
{
        uint8_t *buf = msgb_put(msg, 1 + 4);
        *buf++ = tag;
        osmo_store32be(val, buf);
        return msg->tail;
}
 
static inline uint8_t *msgb_tlv_push(struct msgb *msg, uint8_t tag, uint8_t len, const uint8_t *val)
{
        uint8_t *buf = msgb_push(msg, TLV_GROSS_LEN(len));
        tlv_put(buf, tag, len, val);
        return buf;
}
 
static inline uint8_t *msgb_tlv1_push(struct msgb *msg, uint8_t tag, uint8_t val)
{
        return msgb_tlv_push(msg, tag, 1, &val);
}
 
static inline uint8_t *msgb_tv_push(struct msgb *msg, uint8_t tag, uint8_t val)
{
        uint8_t *buf = msgb_push(msg, 2);
        tv_put(buf, tag, val);
        return buf;
}
 
static inline uint8_t *msgb_tv16_push(struct msgb *msg, uint8_t tag, uint16_t val)
{
        uint8_t *buf = msgb_push(msg, 3);
        tv16_put(buf, tag, val);
        return buf;
}
 
static inline uint8_t *msgb_tv32_push(struct msgb *msg, uint8_t tag, uint32_t val)
{
        uint8_t *buf = msgb_push(msg, 5);
        *buf++ = tag;
        osmo_store32be(val, buf);
        return buf;
}
 
static inline uint8_t *msgb_tvlv_push(struct msgb *msg, uint8_t tag, uint16_t len,
                                      const uint8_t *val)
{
        uint8_t *buf = msgb_push(msg, TVLV_GROSS_LEN(len));
        tvlv_put(buf, tag, len, val);
        return buf;
}
 
/* push (prepend) a vTvL header to a \ref msgb
 */
static inline uint8_t *msgb_vtvl_gan_push(struct msgb *msg, uint16_t tag,
                                           uint16_t len)
{
        uint8_t *buf = msgb_push(msg, VTVL_GAN_GROSS_LEN(tag, len));
        vtvl_gan_put(buf, tag, len);
        return buf;
}
 
 
static inline uint8_t *msgb_vtvlv_gan_push(struct msgb *msg, uint16_t tag,
                                           uint16_t len, const uint8_t *val)
{
        uint8_t *buf = msgb_push(msg, VTVLV_GAN_GROSS_LEN(tag, len));
        vtvlv_gan_put(buf, tag, len, val);
        return buf;
}
 
/* TLV parsing */
 
struct tlv_p_entry {
        uint16_t len;           
        const uint8_t *val;     
};
 
enum tlv_type {
        TLV_TYPE_NONE,          
        TLV_TYPE_FIXED,         
        TLV_TYPE_T,             
        TLV_TYPE_TV,            
        TLV_TYPE_TLV,           
        TLV_TYPE_TL16V,         
        TLV_TYPE_TvLV,          
        TLV_TYPE_SINGLE_TV,     
        TLV_TYPE_vTvLV_GAN,     
};
 
struct tlv_def {
        enum tlv_type type;     
        uint8_t fixed_len;      
};
 
struct tlv_definition {
        struct tlv_def def[256];
};
 
struct tlv_parsed {
        struct tlv_p_entry lv[256];
};
 
extern struct tlv_definition tvlv_att_def;
extern struct tlv_definition vtvlv_gan_att_def;
 
int tlv_parse_one(uint8_t *o_tag, uint16_t *o_len, const uint8_t **o_val,
                  const struct tlv_definition *def,
                  const uint8_t *buf, int buf_len);
int tlv_parse(struct tlv_parsed *dec, const struct tlv_definition *def,
              const uint8_t *buf, int buf_len, uint8_t lv_tag, uint8_t lv_tag2);
int tlv_parse2(struct tlv_parsed *dec, int dec_multiples,
               const struct tlv_definition *def, const uint8_t *buf, int buf_len,
               uint8_t lv_tag, uint8_t lv_tag2);
/* take a master (src) tlv def and fill up all empty slots in 'dst' */
void tlv_def_patch(struct tlv_definition *dst, const struct tlv_definition *src);
 
int tlv_encode_one(struct msgb *msg, enum tlv_type type, uint8_t tag,
                   unsigned int len, const uint8_t *val);
int tlv_encode(struct msgb *msg, const struct tlv_definition *def, const struct tlv_parsed *tp);
int tlv_encode_ordered(struct msgb *msg, const struct tlv_definition *def, const struct tlv_parsed *tp,
                        const uint8_t *tag_order, unsigned int tag_order_len);
 
#define TLVP_PRESENT(x, y)      (!!((x)->lv[y].val))
#define TLVP_LEN(x, y)          (x)->lv[y].len
#define TLVP_VAL(x, y)          (x)->lv[y].val
 
#define TLVP_PRES_LEN(tp, tag, min_len) \
        (TLVP_PRESENT(tp, tag) && TLVP_LEN(tp, tag) >= min_len)
 
#define TLVP_GET(_tp, tag)      (TLVP_PRESENT(_tp, tag)? &(_tp)->lv[tag] : NULL)
 
#define TLVP_GET_MINLEN(_tp, tag, min_len) \
        (TLVP_PRES_LEN(_tp, tag, min_len)? &(_tp)->lv[tag] : NULL)
 
#define TLVP_VAL_MINLEN(_tp, tag, min_len) \
        (TLVP_PRES_LEN(_tp, tag, min_len)? (_tp)->lv[tag].val : NULL)
 
 
static inline uint8_t tlvp_val8(const struct tlv_parsed *tp, uint8_t tag, uint8_t default_val)
{
        const uint8_t *res = TLVP_VAL_MINLEN(tp, tag, 1);
 
        if (res)
                return res[0];
 
        return default_val;
}
 
static inline uint16_t tlvp_val16_unal(const struct tlv_parsed *tp, int pos)
{
        uint16_t res;
        memcpy(&res, TLVP_VAL(tp, pos), sizeof(res));
        return res;
}
 
static inline uint32_t tlvp_val32_unal(const struct tlv_parsed *tp, int pos)
{
        uint32_t res;
        memcpy(&res, TLVP_VAL(tp, pos), sizeof(res));
        return res;
}
 
static inline uint16_t tlvp_val16be(const struct tlv_parsed *tp, int pos)
{
        return osmo_load16be(TLVP_VAL(tp, pos));
}
 
static inline uint32_t tlvp_val32be(const struct tlv_parsed *tp, int pos)
{
        return osmo_load32be(TLVP_VAL(tp, pos));
}
 
 
struct tlv_parsed *osmo_tlvp_copy(const struct tlv_parsed *tp_orig, void *ctx);
int osmo_tlvp_merge(struct tlv_parsed *dst, const struct tlv_parsed *src);
int osmo_shift_v_fixed(uint8_t **data, size_t *data_len,
                       size_t len, uint8_t **value);
int osmo_match_shift_tv_fixed(uint8_t **data, size_t *data_len,
                              uint8_t tag, size_t len, uint8_t **value);
int osmo_shift_tlv(uint8_t **data, size_t *data_len,
                   uint8_t *tag, uint8_t **value, size_t *value_len);
int osmo_match_shift_tlv(uint8_t **data, size_t *data_len,
                   uint8_t tag, uint8_t **value, size_t *value_len);
int osmo_shift_lv(uint8_t **data, size_t *data_len,
                  uint8_t **value, size_t *value_len);
 
#define MSG_DEF(name, mand_ies, flags) { name, mand_ies, ARRAY_SIZE(mand_ies), flags }
 
struct osmo_tlv_prot_msg_def {
        const char *name;
        const uint8_t *mand_ies;
        uint8_t mand_count;
        uint32_t flags;
};
struct osmo_tlv_prot_ie_def {
        uint16_t min_len;
        const char *name;
};
 
struct osmo_tlv_prot_def {
        const char *name;
        const struct tlv_definition *tlv_def;
        struct osmo_tlv_prot_msg_def msg_def[256];
        struct osmo_tlv_prot_ie_def ie_def[256];
        const struct value_string *msgt_names;
};
 
const char *osmo_tlv_prot_msg_name(const struct osmo_tlv_prot_def *pdef, uint8_t msg_type);
const char *osmo_tlv_prot_ie_name(const struct osmo_tlv_prot_def *pdef, uint8_t iei);
 
int osmo_tlv_prot_validate_tp(const struct osmo_tlv_prot_def *pdef, uint8_t msg_type,
                              const struct tlv_parsed *tp, int log_subsys, const char *log_pfx);
 
int osmo_tlv_prot_parse(const struct osmo_tlv_prot_def *pdef,
                        struct tlv_parsed *dec, unsigned int dec_multiples, uint8_t msg_type,
                        const uint8_t *buf, unsigned int buf_len, uint8_t lv_tag, uint8_t lv_tag2,
                        int log_subsys, const char *log_pfx);
 
static inline uint32_t osmo_tlv_prot_msgt_flags(const struct osmo_tlv_prot_def *pdef, uint8_t msg_type)
{
        return pdef->msg_def[msg_type].flags;
}