msgb.h

Go to the documentation of this file.

#pragma once
 
/* (C) 2008 by Harald Welte <laforge@gnumonks.org>
 * All Rights Reserved
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */
 
#include <stdint.h>
#include <osmocom/core/linuxlist.h>
#include <osmocom/core/utils.h>
#include <osmocom/core/bits.h>
#include <osmocom/core/defs.h>
 
#define MSGB_DEBUG
 
struct msgb {
        struct llist_head list; 
        /* Part of which TRX logical channel we were received / transmitted */
        /* FIXME: move them into the control buffer */
        union {
                void *dst; 
                struct gsm_bts_trx *trx;
        };
        struct gsm_lchan *lchan; 
        unsigned char *l1h; 
        unsigned char *l2h; 
        unsigned char *l3h; 
        unsigned char *l4h; 
        unsigned long cb[5]; 
        uint16_t data_len;   
        uint16_t len;        
        unsigned char *head;    
        unsigned char *tail;    
        unsigned char *data;    
        unsigned char _data[0]; 
};
 
extern struct msgb *msgb_alloc_c(const void *ctx, uint16_t size, const char *name);
extern struct msgb *msgb_alloc(uint16_t size, const char *name);
extern void msgb_free(struct msgb *m);
extern void msgb_enqueue(struct llist_head *queue, struct msgb *msg);
extern struct msgb *msgb_dequeue(struct llist_head *queue);
extern void msgb_reset(struct msgb *m);
uint16_t msgb_length(const struct msgb *msg);
extern const char *msgb_hexdump(const struct msgb *msg);
char *msgb_hexdump_buf(char *buf, size_t buf_len, const struct msgb *msg);
char *msgb_hexdump_c(const void *ctx, const struct msgb *msg);
extern int msgb_resize_area(struct msgb *msg, uint8_t *area,
        int old_size, int new_size);
extern struct msgb *msgb_copy(const struct msgb *msg, const char *name);
extern struct msgb *msgb_copy_c(const void *ctx, const struct msgb *msg, const char *name);
extern struct msgb *msgb_copy_resize(const struct msgb *msg, uint16_t new_len, const char *name);
extern struct msgb *msgb_copy_resize_c(const void *ctx, const struct msgb *msg, uint16_t new_len, const char *name);
static int msgb_test_invariant(const struct msgb *msg) __attribute__((pure));
 
static inline void msgb_queue_free(struct llist_head *queue)
{
        struct msgb *msg;
        while ((msg = msgb_dequeue(queue))) msgb_free(msg);
}
 
static inline void msgb_enqueue_count(struct llist_head *queue, struct msgb *msg,
                                        unsigned int *count)
{
        msgb_enqueue(queue, msg);
        (*count)++;
}
 
static inline struct msgb *msgb_dequeue_count(struct llist_head *queue,
                                                unsigned int *count)
{
        struct msgb *msg = msgb_dequeue(queue);
        if (msg)
                (*count)--;
        return msg;
}
 
#ifdef MSGB_DEBUG
#include <osmocom/core/panic.h>
#define MSGB_ABORT(msg, fmt, args ...) do {             \
        osmo_panic("msgb(%p): " fmt, msg, ## args);     \
        } while(0)
#else
#define MSGB_ABORT(msg, fmt, args ...)
#endif
 
#define msgb_l1(m)      ((void *)((m)->l1h))
#define msgb_l2(m)      ((void *)((m)->l2h))
#define msgb_l3(m)      ((void *)((m)->l3h))
#define msgb_l4(m)      ((void *)((m)->l4h))
#define msgb_sms(m)     msgb_l4(m)
 
static inline unsigned int msgb_l1len(const struct msgb *msgb)
{
        OSMO_ASSERT(msgb->l1h);
        return msgb->tail - (uint8_t *)msgb_l1(msgb);
}
 
static inline unsigned int msgb_l2len(const struct msgb *msgb)
{
        OSMO_ASSERT(msgb->l2h);
        return msgb->tail - (uint8_t *)msgb_l2(msgb);
}
 
static inline unsigned int msgb_l3len(const struct msgb *msgb)
{
        OSMO_ASSERT(msgb->l3h);
        return msgb->tail - (uint8_t *)msgb_l3(msgb);
}
 
static inline unsigned int msgb_l4len(const struct msgb *msgb)
{
        OSMO_ASSERT(msgb->l4h);
        return msgb->tail - (uint8_t *)msgb_l4(msgb);
}
 
static inline unsigned int msgb_headlen(const struct msgb *msgb)
{
        return msgb->len - msgb->data_len;
}
 
static inline int msgb_tailroom(const struct msgb *msgb)
{
        return (msgb->head + msgb->data_len) - msgb->tail;
}
 
static inline int msgb_headroom(const struct msgb *msgb)
{
        return (msgb->data - msgb->head);
}
 
static inline unsigned char *msgb_put(struct msgb *msgb, unsigned int len)
{
        unsigned char *tmp = msgb->tail;
        if (OSMO_UNLIKELY(msgb_tailroom(msgb) < (int) len))
                MSGB_ABORT(msgb, "Not enough tailroom msgb_put"
                           " (allocated %u, head at %u, len %u, tailroom %u < want tailroom %u)\n",
                           msgb->data_len - sizeof(struct msgb),
                           msgb->head - msgb->_data,
                           msgb->len,
                           msgb_tailroom(msgb), len);
        msgb->tail += len;
        msgb->len += len;
        return tmp;
}
 
static inline void msgb_put_u8(struct msgb *msgb, uint8_t word)
{
        uint8_t *space = msgb_put(msgb, 1);
        space[0] = word & 0xFF;
}
 
static inline void msgb_put_u16(struct msgb *msgb, uint16_t word)
{
        uint8_t *space = msgb_put(msgb, 2);
        osmo_store16be(word, space);
}
 
static inline void msgb_put_u32(struct msgb *msgb, uint32_t word)
{
        uint8_t *space = msgb_put(msgb, 4);
        osmo_store32be(word, space);
}
 
static inline unsigned char *msgb_get(struct msgb *msgb, unsigned int len)
{
        if (OSMO_UNLIKELY(msgb_length(msgb) < len))
                MSGB_ABORT(msgb, "msgb too small to get %u (len %u)\n",
                           len, msgb_length(msgb));
        msgb->tail -= len;
        msgb->len -= len;
        return msgb->tail;
}
 
static inline uint8_t msgb_get_u8(struct msgb *msgb)
{
        uint8_t *space = msgb_get(msgb, 1);
        return space[0];
}
 
static inline uint16_t msgb_get_u16(struct msgb *msgb)
{
        uint8_t *space = msgb_get(msgb, 2);
        return osmo_load16be(space);
}
 
static inline uint32_t msgb_get_u32(struct msgb *msgb)
{
        uint8_t *space = msgb_get(msgb, 4);
        return osmo_load32be(space);
}
 
static inline unsigned char *msgb_push(struct msgb *msgb, unsigned int len)
{
        if (OSMO_UNLIKELY(msgb_headroom(msgb) < (int) len))
                MSGB_ABORT(msgb, "Not enough headroom msgb_push"
                           " (allocated %u, head at %u < want headroom %u, len %u, tailroom %u)\n",
                           msgb->data_len - sizeof(struct msgb),
                           msgb->head - msgb->_data,
                           len,
                           msgb->len,
                           msgb_tailroom(msgb));
        msgb->data -= len;
        msgb->len += len;
        return msgb->data;
}
 
static inline void msgb_push_u8(struct msgb *msg, uint8_t word)
{
        uint8_t *space = msgb_push(msg, 1);
        space[0] = word;
}
 
static inline void msgb_push_u16(struct msgb *msg, uint16_t word)
{
        uint16_t *space = (uint16_t *) msgb_push(msg, 2);
        osmo_store16be(word, space);
}
 
static inline void msgb_push_u32(struct msgb *msg, uint32_t word)
{
        uint32_t *space = (uint32_t *) msgb_push(msg, 4);
        osmo_store32be(word, space);
}
 
static inline unsigned char *msgb_push_tl(struct msgb *msgb, uint8_t tag)
{
        uint8_t *data = msgb_push(msgb, 2);
 
        data[0] = tag;
        data[1] = msgb->len - 2;
        return data;
}
 
static inline unsigned char *msgb_pull(struct msgb *msgb, unsigned int len)
{
        if (OSMO_UNLIKELY(msgb_length(msgb) < len))
                MSGB_ABORT(msgb, "msgb too small to pull %u (len %u)\n",
                           len, msgb_length(msgb));
        msgb->len -= len;
        return msgb->data += len;
}
 
static inline unsigned char *msgb_pull_to_l3(struct msgb *msg)
{
        unsigned char *ret = msgb_pull(msg, msg->l3h - msg->data);
        msg->l1h = msg->l2h = NULL;
        return ret;
}
 
static inline unsigned char *msgb_pull_to_l2(struct msgb *msg)
{
        unsigned char *ret = msgb_pull(msg, msg->l2h - msg->data);
        msg->l1h = NULL;
        return ret;
}
 
static inline uint8_t msgb_pull_u8(struct msgb *msgb)
{
        uint8_t *space = msgb_pull(msgb, 1) - 1;
        return space[0];
}
 
static inline uint16_t msgb_pull_u16(struct msgb *msgb)
{
        uint8_t *space = msgb_pull(msgb, 2) - 2;
        return osmo_load16be(space);
}
 
static inline uint32_t msgb_pull_u32(struct msgb *msgb)
{
        uint8_t *space = msgb_pull(msgb, 4) - 4;
        return osmo_load32be(space);
}
 
static inline void msgb_reserve(struct msgb *msg, int len)
{
        msg->data += len;
        msg->tail += len;
}
 
static inline int msgb_trim(struct msgb *msg, int len)
{
        if (OSMO_UNLIKELY(len < 0))
                MSGB_ABORT(msg, "Negative length is not allowed\n");
        if (OSMO_UNLIKELY(len > msg->data_len))
                return -1;
 
        msg->len = len;
        msg->tail = msg->data + len;
 
        return 0;
}
 
static inline int msgb_l3trim(struct msgb *msg, int l3len)
{
        return msgb_trim(msg, (msg->l3h - msg->data) + l3len);
}
 
static inline struct msgb *msgb_alloc_headroom_c(const void *ctx, uint16_t size, uint16_t headroom,
                                                 const char *name)
{
        OSMO_ASSERT(size >= headroom);
 
        struct msgb *msg = msgb_alloc_c(ctx, size, name);
        if (OSMO_LIKELY(msg))
                msgb_reserve(msg, headroom);
        return msg;
}
 
 
static inline struct msgb *msgb_alloc_headroom(uint16_t size, uint16_t headroom,
                                                const char *name)
{
        OSMO_ASSERT(size >= headroom);
 
        struct msgb *msg = msgb_alloc(size, name);
        if (OSMO_LIKELY(msg))
                msgb_reserve(msg, headroom);
        return msg;
}
 
static inline int msgb_test_invariant(const struct msgb *msg)
{
        const unsigned char *lbound;
        if (!msg || !msg->data || !msg->tail ||
            (msg->data + msg->len != msg->tail) ||
            (msg->data < msg->head) ||
            (msg->tail > msg->head + msg->data_len))
                return 0;
 
        lbound = msg->head;
 
        if (msg->l1h) {
                if (msg->l1h < lbound)
                        return 0;
                lbound = msg->l1h;
        }
        if (msg->l2h) {
                if (msg->l2h < lbound)
                        return 0;
                lbound = msg->l2h;
        }
        if (msg->l3h) {
                if (msg->l3h < lbound)
                        return 0;
                lbound = msg->l3h;
        }
        if (msg->l4h) {
                if (msg->l4h < lbound)
                        return 0;
                lbound = msg->l4h;
        }
 
        return lbound <= msg->head +  msg->data_len;
}
 
 
/* msgb data comparison helpers */
 
#define msgb_eq_data(msg, data, len)                            \
        _msgb_eq(__FILE__, __LINE__, __func__, 0, msg, data, len, false)
 
#define msgb_eq_l1_data(msg, data, len)                         \
        _msgb_eq(__FILE__, __LINE__, __func__, 1, msg, data, len, false)
 
#define msgb_eq_l2_data(msg, data, len)                         \
        _msgb_eq(__FILE__, __LINE__, __func__, 2, msg, data, len, false)
 
#define msgb_eq_l3_data(msg, data, len)                         \
        _msgb_eq(__FILE__, __LINE__, __func__, 3, msg, data, len, false)
 
#define msgb_eq_l4_data(msg, data, len)                         \
        _msgb_eq(__FILE__, __LINE__, __func__, 4, msg, data, len, false)
 
 
/* msgb test/debug helpers */
 
#define msgb_eq_data_print(msg, data, len)                              \
        _msgb_eq(__FILE__, __LINE__, __func__, 0, msg, data, len, true)
 
#define msgb_eq_l1_data_print(msg, data, len)                           \
        _msgb_eq(__FILE__, __LINE__, __func__, 1, msg, data, len, true)
 
#define msgb_eq_l2_data_print(msg, data, len)                           \
        _msgb_eq(__FILE__, __LINE__, __func__, 2, msg, data, len, true)
 
#define msgb_eq_l3_data_print(msg, data, len)                           \
        _msgb_eq(__FILE__, __LINE__, __func__, 3, msg, data, len, true)
 
 
#define msgb_eq_l4_data_print(msg, data, len)                           \
        _msgb_eq(__FILE__, __LINE__, __func__, 4, msg, data, len, true)
 
bool _msgb_eq(const char *file, size_t line, const char *func, uint8_t level,
              const struct msgb *msg, const uint8_t *data, size_t len, bool print);
 
 
/* msgb data comparison */
 
#define msgb_eq(msg1, msg2) msgb_eq_data(msg1, msgb_data(msg2), msgb_length(msg2))
 
#define msgb_eq_l1(msg1, msg2) msgb_eq_l1_data(msg1, msgb_l1(msg2), msgb_l1len(msg2))
 
#define msgb_eq_l2(msg1, msg2) msgb_eq_l2_data(msg1, msgb_l2(msg2), msgb_l2len(msg2))
 
#define msgb_eq_l3(msg1, msg2) msgb_eq_l3_data(msg1, msgb_l3(msg2), msgb_l3len(msg2))
 
#define msgb_eq_l4(msg1, msg2) msgb_eq_l4_data(msg1, msgb_l4(msg2), msgb_l4len(msg2))
 
 
/* non inline functions to ease binding */
 
uint8_t *msgb_data(const struct msgb *msg);
 
void *msgb_talloc_ctx_init(void *root_ctx, unsigned int pool_size);
void msgb_set_talloc_ctx(void *ctx) OSMO_DEPRECATED("Use msgb_talloc_ctx_init() instead");
int msgb_printf(struct msgb *msgb, const char *format, ...);
 
static inline const char *msgb_hexdump_l1(const struct msgb *msg)
{
        if (!msgb_l1(msg) || !(msgb_l1len(msg)))
                return "[]";
        return osmo_hexdump((const unsigned char *) msgb_l1(msg), msgb_l1len(msg));
}
 
static inline const char *msgb_hexdump_l2(const struct msgb *msg)
{
        if (!msgb_l2(msg) || !(msgb_l2len(msg)))
                return "[]";
        return osmo_hexdump((const unsigned char *) msgb_l2(msg), msgb_l2len(msg));
}
 
static inline const char *msgb_hexdump_l3(const struct msgb *msg)
{
        if (!msgb_l3(msg) || !(msgb_l3len(msg)))
                return "[]";
        return osmo_hexdump((const unsigned char*) msgb_l3(msg), msgb_l3len(msg));
}
 
static inline const char *msgb_hexdump_l4(const struct msgb *msg)
{
        if (!msgb_l4(msg) || !(msgb_l4len(msg)))
                return "[]";
        return osmo_hexdump((const unsigned char*) msgb_l4(msg), msgb_l4len(msg));
}