mirror of https://gerrit.osmocom.org/simtrace2
import libosmocore msgb handling (and dependencies)
This is supposed to be replaced with upstream libosmocore, as soon as that has a proper maintained embedded build (again).
This commit is contained in:
parent
0380d74405
commit
eb81d23a56
|
@ -1,61 +0,0 @@
|
|||
#pragma once
|
||||
|
||||
#define RCTX_SIZE_LARGE 960
|
||||
#define RCTX_SIZE_SMALL 320
|
||||
#define MAX_HDRSIZE sizeof(struct openpcd_hdr)
|
||||
|
||||
#include <stdint.h>
|
||||
#include "osmocom/core/linuxlist.h"
|
||||
|
||||
#define __ramfunc
|
||||
|
||||
enum req_ctx_state {
|
||||
/* free to be allocated */
|
||||
RCTX_S_FREE,
|
||||
|
||||
/* USB -> UART */
|
||||
/* In USB driver, waiting for data from host */
|
||||
RCTX_S_USB_RX_BUSY,
|
||||
/* somewhere in the main loop */
|
||||
RCTX_S_MAIN_PROCESSING,
|
||||
/* pending (in queue) for transmission on UART */
|
||||
RCTX_S_UART_TX_PENDING,
|
||||
/* currently in active transmission on UART */
|
||||
RCTX_S_UART_TX_BUSY,
|
||||
|
||||
/* UART -> USB */
|
||||
/* currently in active reception on UART */
|
||||
RCTX_S_UART_RX_BUSY,
|
||||
/* pending (in queue) for transmission over USB to host */
|
||||
RCTX_S_USB_TX_PENDING,
|
||||
/* currently in transmission over USB to host */
|
||||
RCTX_S_USB_TX_BUSY,
|
||||
|
||||
/* number of states */
|
||||
RCTX_STATE_COUNT
|
||||
};
|
||||
|
||||
struct req_ctx {
|
||||
/* if this req_ctx is on a queue... */
|
||||
struct llist_head list;
|
||||
uint32_t ep;
|
||||
|
||||
/* enum req_ctx_state */
|
||||
volatile uint32_t state;
|
||||
/* size of th 'data' buffer */
|
||||
uint16_t size;
|
||||
/* total number of used bytes in buffer */
|
||||
uint16_t tot_len;
|
||||
/* index into the buffer, user specific */
|
||||
uint16_t idx;
|
||||
/* actual data buffer */
|
||||
uint8_t *data;
|
||||
};
|
||||
|
||||
extern void req_ctx_init(void);
|
||||
extern struct req_ctx __ramfunc *req_ctx_find_get(int large, uint32_t old_state, uint32_t new_state);
|
||||
extern struct req_ctx *req_ctx_find_busy(void);
|
||||
extern void req_ctx_set_state(struct req_ctx *ctx, uint32_t new_state);
|
||||
extern void req_ctx_put(struct req_ctx *ctx);
|
||||
extern uint8_t req_ctx_num(struct req_ctx *ctx);
|
||||
unsigned int req_ctx_count(uint32_t state);
|
|
@ -0,0 +1,4 @@
|
|||
#pragma once
|
||||
|
||||
void osmo_generate_backtrace(void);
|
||||
void osmo_log_backtrace(int subsys, int level);
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
* bit16gen.h
|
||||
*
|
||||
* Copyright (C) 2014 Max <max.suraev@fairwaves.co>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/*! \brief load unaligned n-byte integer (little-endian encoding) into uint16_t
|
||||
* \param[in] p Buffer where integer is stored
|
||||
* \param[in] n Number of bytes stored in p
|
||||
* \returns 16 bit unsigned integer
|
||||
*/
|
||||
static inline uint16_t osmo_load16le_ext(const void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint16_t r = 0;
|
||||
const uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; r |= ((uint16_t)q[i] << (8 * i)), i++);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*! \brief load unaligned n-byte integer (big-endian encoding) into uint16_t
|
||||
* \param[in] p Buffer where integer is stored
|
||||
* \param[in] n Number of bytes stored in p
|
||||
* \returns 16 bit unsigned integer
|
||||
*/
|
||||
static inline uint16_t osmo_load16be_ext(const void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint16_t r = 0;
|
||||
const uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; r |= ((uint16_t)q[i] << (16 - 8* (1 + i))), i++);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/*! \brief store unaligned n-byte integer (little-endian encoding) from uint16_t
|
||||
* \param[in] x unsigned 16 bit integer
|
||||
* \param[out] p Buffer to store integer
|
||||
* \param[in] n Number of bytes to store
|
||||
*/
|
||||
static inline void osmo_store16le_ext(uint16_t x, void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; q[i] = (x >> i * 8) & 0xFF, i++);
|
||||
}
|
||||
|
||||
/*! \brief store unaligned n-byte integer (big-endian encoding) from uint16_t
|
||||
* \param[in] x unsigned 16 bit integer
|
||||
* \param[out] p Buffer to store integer
|
||||
* \param[in] n Number of bytes to store
|
||||
*/
|
||||
static inline void osmo_store16be_ext(uint16_t x, void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; q[i] = (x >> ((n - 1 - i) * 8)) & 0xFF, i++);
|
||||
}
|
||||
|
||||
|
||||
/* Convenience function for most-used cases */
|
||||
|
||||
|
||||
/*! \brief load unaligned 16-bit integer (little-endian encoding) */
|
||||
static inline uint16_t osmo_load16le(const void *p)
|
||||
{
|
||||
return osmo_load16le_ext(p, 16 / 8);
|
||||
}
|
||||
|
||||
/*! \brief load unaligned 16-bit integer (big-endian encoding) */
|
||||
static inline uint16_t osmo_load16be(const void *p)
|
||||
{
|
||||
return osmo_load16be_ext(p, 16 / 8);
|
||||
}
|
||||
|
||||
|
||||
/*! \brief store unaligned 16-bit integer (little-endian encoding) */
|
||||
static inline void osmo_store16le(uint16_t x, void *p)
|
||||
{
|
||||
osmo_store16le_ext(x, p, 16 / 8);
|
||||
}
|
||||
|
||||
/*! \brief store unaligned 16-bit integer (big-endian encoding) */
|
||||
static inline void osmo_store16be(uint16_t x, void *p)
|
||||
{
|
||||
osmo_store16be_ext(x, p, 16 / 8);
|
||||
}
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
* bit32gen.h
|
||||
*
|
||||
* Copyright (C) 2014 Max <max.suraev@fairwaves.co>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/*! \brief load unaligned n-byte integer (little-endian encoding) into uint32_t
|
||||
* \param[in] p Buffer where integer is stored
|
||||
* \param[in] n Number of bytes stored in p
|
||||
* \returns 32 bit unsigned integer
|
||||
*/
|
||||
static inline uint32_t osmo_load32le_ext(const void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint32_t r = 0;
|
||||
const uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; r |= ((uint32_t)q[i] << (8 * i)), i++);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*! \brief load unaligned n-byte integer (big-endian encoding) into uint32_t
|
||||
* \param[in] p Buffer where integer is stored
|
||||
* \param[in] n Number of bytes stored in p
|
||||
* \returns 32 bit unsigned integer
|
||||
*/
|
||||
static inline uint32_t osmo_load32be_ext(const void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint32_t r = 0;
|
||||
const uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; r |= ((uint32_t)q[i] << (32 - 8* (1 + i))), i++);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/*! \brief store unaligned n-byte integer (little-endian encoding) from uint32_t
|
||||
* \param[in] x unsigned 32 bit integer
|
||||
* \param[out] p Buffer to store integer
|
||||
* \param[in] n Number of bytes to store
|
||||
*/
|
||||
static inline void osmo_store32le_ext(uint32_t x, void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; q[i] = (x >> i * 8) & 0xFF, i++);
|
||||
}
|
||||
|
||||
/*! \brief store unaligned n-byte integer (big-endian encoding) from uint32_t
|
||||
* \param[in] x unsigned 32 bit integer
|
||||
* \param[out] p Buffer to store integer
|
||||
* \param[in] n Number of bytes to store
|
||||
*/
|
||||
static inline void osmo_store32be_ext(uint32_t x, void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; q[i] = (x >> ((n - 1 - i) * 8)) & 0xFF, i++);
|
||||
}
|
||||
|
||||
|
||||
/* Convenience function for most-used cases */
|
||||
|
||||
|
||||
/*! \brief load unaligned 32-bit integer (little-endian encoding) */
|
||||
static inline uint32_t osmo_load32le(const void *p)
|
||||
{
|
||||
return osmo_load32le_ext(p, 32 / 8);
|
||||
}
|
||||
|
||||
/*! \brief load unaligned 32-bit integer (big-endian encoding) */
|
||||
static inline uint32_t osmo_load32be(const void *p)
|
||||
{
|
||||
return osmo_load32be_ext(p, 32 / 8);
|
||||
}
|
||||
|
||||
|
||||
/*! \brief store unaligned 32-bit integer (little-endian encoding) */
|
||||
static inline void osmo_store32le(uint32_t x, void *p)
|
||||
{
|
||||
osmo_store32le_ext(x, p, 32 / 8);
|
||||
}
|
||||
|
||||
/*! \brief store unaligned 32-bit integer (big-endian encoding) */
|
||||
static inline void osmo_store32be(uint32_t x, void *p)
|
||||
{
|
||||
osmo_store32be_ext(x, p, 32 / 8);
|
||||
}
|
|
@ -0,0 +1,105 @@
|
|||
/*
|
||||
* bit64gen.h
|
||||
*
|
||||
* Copyright (C) 2014 Max <max.suraev@fairwaves.co>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
/*! \brief load unaligned n-byte integer (little-endian encoding) into uint64_t
|
||||
* \param[in] p Buffer where integer is stored
|
||||
* \param[in] n Number of bytes stored in p
|
||||
* \returns 64 bit unsigned integer
|
||||
*/
|
||||
static inline uint64_t osmo_load64le_ext(const void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint64_t r = 0;
|
||||
const uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; r |= ((uint64_t)q[i] << (8 * i)), i++);
|
||||
return r;
|
||||
}
|
||||
|
||||
/*! \brief load unaligned n-byte integer (big-endian encoding) into uint64_t
|
||||
* \param[in] p Buffer where integer is stored
|
||||
* \param[in] n Number of bytes stored in p
|
||||
* \returns 64 bit unsigned integer
|
||||
*/
|
||||
static inline uint64_t osmo_load64be_ext(const void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint64_t r = 0;
|
||||
const uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; r |= ((uint64_t)q[i] << (64 - 8* (1 + i))), i++);
|
||||
return r;
|
||||
}
|
||||
|
||||
|
||||
/*! \brief store unaligned n-byte integer (little-endian encoding) from uint64_t
|
||||
* \param[in] x unsigned 64 bit integer
|
||||
* \param[out] p Buffer to store integer
|
||||
* \param[in] n Number of bytes to store
|
||||
*/
|
||||
static inline void osmo_store64le_ext(uint64_t x, void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; q[i] = (x >> i * 8) & 0xFF, i++);
|
||||
}
|
||||
|
||||
/*! \brief store unaligned n-byte integer (big-endian encoding) from uint64_t
|
||||
* \param[in] x unsigned 64 bit integer
|
||||
* \param[out] p Buffer to store integer
|
||||
* \param[in] n Number of bytes to store
|
||||
*/
|
||||
static inline void osmo_store64be_ext(uint64_t x, void *p, uint8_t n)
|
||||
{
|
||||
uint8_t i;
|
||||
uint8_t *q = (uint8_t *)p;
|
||||
for(i = 0; i < n; q[i] = (x >> ((n - 1 - i) * 8)) & 0xFF, i++);
|
||||
}
|
||||
|
||||
|
||||
/* Convenience function for most-used cases */
|
||||
|
||||
|
||||
/*! \brief load unaligned 64-bit integer (little-endian encoding) */
|
||||
static inline uint64_t osmo_load64le(const void *p)
|
||||
{
|
||||
return osmo_load64le_ext(p, 64 / 8);
|
||||
}
|
||||
|
||||
/*! \brief load unaligned 64-bit integer (big-endian encoding) */
|
||||
static inline uint64_t osmo_load64be(const void *p)
|
||||
{
|
||||
return osmo_load64be_ext(p, 64 / 8);
|
||||
}
|
||||
|
||||
|
||||
/*! \brief store unaligned 64-bit integer (little-endian encoding) */
|
||||
static inline void osmo_store64le(uint64_t x, void *p)
|
||||
{
|
||||
osmo_store64le_ext(x, p, 64 / 8);
|
||||
}
|
||||
|
||||
/*! \brief store unaligned 64-bit integer (big-endian encoding) */
|
||||
static inline void osmo_store64be(uint64_t x, void *p)
|
||||
{
|
||||
osmo_store64be_ext(x, p, 64 / 8);
|
||||
}
|
|
@ -0,0 +1,118 @@
|
|||
#pragma once
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
|
||||
#include <osmocom/core/bit16gen.h>
|
||||
#include <osmocom/core/bit32gen.h>
|
||||
#include <osmocom/core/bit64gen.h>
|
||||
|
||||
/*! \defgroup bits soft, unpacked and packed bits
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file bits.h
|
||||
* \brief Osmocom bit level support code
|
||||
*
|
||||
* NOTE on the endianess of pbit_t:
|
||||
* Bits in a pbit_t are ordered MSB first, i.e. 0x80 is the first bit.
|
||||
* Bit i in a pbit_t array is array[i/8] & (1<<(7-i%8))
|
||||
*/
|
||||
|
||||
typedef int8_t sbit_t; /*!< \brief soft bit (-127...127) */
|
||||
typedef uint8_t ubit_t; /*!< \brief unpacked bit (0 or 1) */
|
||||
typedef uint8_t pbit_t; /*!< \brief packed bis (8 bits in a byte) */
|
||||
|
||||
/*! \brief determine how many bytes we would need for \a num_bits packed bits
|
||||
* \param[in] num_bits Number of packed bits
|
||||
* \returns number of bytes needed for \a num_bits packed bits
|
||||
*/
|
||||
static inline unsigned int osmo_pbit_bytesize(unsigned int num_bits)
|
||||
{
|
||||
unsigned int pbit_bytesize = num_bits / 8;
|
||||
|
||||
if (num_bits % 8)
|
||||
pbit_bytesize++;
|
||||
|
||||
return pbit_bytesize;
|
||||
}
|
||||
|
||||
int osmo_ubit2pbit(pbit_t *out, const ubit_t *in, unsigned int num_bits);
|
||||
|
||||
int osmo_pbit2ubit(ubit_t *out, const pbit_t *in, unsigned int num_bits);
|
||||
|
||||
void osmo_nibble_shift_right(uint8_t *out, const uint8_t *in,
|
||||
unsigned int num_nibbles);
|
||||
void osmo_nibble_shift_left_unal(uint8_t *out, const uint8_t *in,
|
||||
unsigned int num_nibbles);
|
||||
|
||||
void osmo_ubit2sbit(sbit_t *out, const ubit_t *in, unsigned int num_bits);
|
||||
void osmo_sbit2ubit(ubit_t *out, const sbit_t *in, unsigned int num_bits);
|
||||
|
||||
int osmo_ubit2pbit_ext(pbit_t *out, unsigned int out_ofs,
|
||||
const ubit_t *in, unsigned int in_ofs,
|
||||
unsigned int num_bits, int lsb_mode);
|
||||
|
||||
int osmo_pbit2ubit_ext(ubit_t *out, unsigned int out_ofs,
|
||||
const pbit_t *in, unsigned int in_ofs,
|
||||
unsigned int num_bits, int lsb_mode);
|
||||
|
||||
#define OSMO_BIN_SPEC "%d%d%d%d%d%d%d%d"
|
||||
#define OSMO_BIN_PRINT(byte) \
|
||||
(byte & 0x80 ? 1 : 0), \
|
||||
(byte & 0x40 ? 1 : 0), \
|
||||
(byte & 0x20 ? 1 : 0), \
|
||||
(byte & 0x10 ? 1 : 0), \
|
||||
(byte & 0x08 ? 1 : 0), \
|
||||
(byte & 0x04 ? 1 : 0), \
|
||||
(byte & 0x02 ? 1 : 0), \
|
||||
(byte & 0x01 ? 1 : 0)
|
||||
|
||||
#define OSMO_BIT_SPEC "%c%c%c%c%c%c%c%c"
|
||||
#define OSMO_BIT_PRINT(byte) \
|
||||
(byte & 0x80 ? '1' : '.'), \
|
||||
(byte & 0x40 ? '1' : '.'), \
|
||||
(byte & 0x20 ? '1' : '.'), \
|
||||
(byte & 0x10 ? '1' : '.'), \
|
||||
(byte & 0x08 ? '1' : '.'), \
|
||||
(byte & 0x04 ? '1' : '.'), \
|
||||
(byte & 0x02 ? '1' : '.'), \
|
||||
(byte & 0x01 ? '1' : '.')
|
||||
|
||||
/* BIT REVERSAL */
|
||||
|
||||
/*! \brief bit-reversal mode for osmo_bit_reversal() */
|
||||
enum osmo_br_mode {
|
||||
/*! \brief reverse all bits in a 32bit dword */
|
||||
OSMO_BR_BITS_IN_DWORD = 31,
|
||||
/*! \brief reverse byte order in a 32bit dword */
|
||||
OSMO_BR_BYTES_IN_DWORD = 24,
|
||||
/*! \brief reverse bits of each byte in a 32bit dword */
|
||||
OSMO_BR_BITS_IN_BYTE = 7,
|
||||
/*! \brief swap the two 16bit words in a 32bit dword */
|
||||
OSMO_BR_WORD_SWAP = 16,
|
||||
};
|
||||
|
||||
/*! \brief generic bit reversal function */
|
||||
uint32_t osmo_bit_reversal(uint32_t x, enum osmo_br_mode k);
|
||||
|
||||
/* \brief reverse the bits within each byte of a 32bit word */
|
||||
uint32_t osmo_revbytebits_32(uint32_t x);
|
||||
|
||||
/* \brief reverse the bits within a byte */
|
||||
uint32_t osmo_revbytebits_8(uint8_t x);
|
||||
|
||||
/* \brief reverse the bits of each byte in a given buffer */
|
||||
void osmo_revbytebits_buf(uint8_t *buf, int len);
|
||||
|
||||
/*! \brief left circular shift
|
||||
* \param[in] in The 16 bit unsigned integer to be rotated
|
||||
* \param[in] shift Number of bits to shift \a in to, [0;16] bits
|
||||
* \returns shifted value
|
||||
*/
|
||||
static inline uint16_t osmo_rol16(uint16_t in, unsigned shift)
|
||||
{
|
||||
return (in << shift) | (in >> (16 - shift));
|
||||
}
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,47 @@
|
|||
#pragma once
|
||||
|
||||
/*! \defgroup utils General-purpose utility functions
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file defs.h
|
||||
* \brief General definitions that are meant to be included from header files.
|
||||
*/
|
||||
|
||||
/*! \brief Check for gcc and version.
|
||||
*
|
||||
* \note Albeit glibc provides a features.h file that contains a similar
|
||||
* definition (__GNUC_PREREQ), this definition has been copied from there
|
||||
* to have it available with other libraries, too.
|
||||
*
|
||||
* \return != 0 iff gcc is used and it's version is at least maj.min.
|
||||
*/
|
||||
#if defined __GNUC__ && defined __GNUC_MINOR__
|
||||
# define OSMO_GNUC_PREREQ(maj, min) \
|
||||
((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min))
|
||||
#else
|
||||
# define OSMO_GNUC_PREREQ(maj, min) 0
|
||||
#endif
|
||||
|
||||
/*! \brief Set the deprecated attribute with a message.
|
||||
*/
|
||||
#if defined(__clang__)
|
||||
# define _OSMO_HAS_ATTRIBUTE_DEPRECATED __has_attribute(deprecated)
|
||||
# define _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE __has_extension(attribute_deprecated_with_message)
|
||||
#elif defined(__GNUC__)
|
||||
# define _OSMO_HAS_ATTRIBUTE_DEPRECATED 1
|
||||
# define _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE OSMO_GNUC_PREREQ(4,5)
|
||||
#endif
|
||||
|
||||
#if _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE
|
||||
# define OSMO_DEPRECATED(text) __attribute__((__deprecated__(text)))
|
||||
#elif _OSMO_HAS_ATTRIBUTE_DEPRECATED
|
||||
# define OSMO_DEPRECATED(text) __attribute__((__deprecated__))
|
||||
#else
|
||||
# define OSMO_DEPRECATED(text)
|
||||
#endif
|
||||
|
||||
#undef _OSMO_HAS_ATTRIBUTE_DEPRECATED_WITH_MESSAGE
|
||||
#undef _OSMO_HAS_ATTRIBUTE_DEPRECATED
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,510 @@
|
|||
#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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <osmocom/core/linuxlist.h>
|
||||
#include <osmocom/core/utils.h>
|
||||
#include <osmocom/core/bits.h>
|
||||
#include <osmocom/core/defs.h>
|
||||
|
||||
/*! \defgroup msgb Message buffers
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file msgb.h
|
||||
* \brief Osmocom message buffers
|
||||
* The Osmocom message buffers are modelled after the 'struct skb'
|
||||
* inside the Linux kernel network stack. As they exist in userspace,
|
||||
* they are much simplified. However, terminology such as headroom,
|
||||
* tailroom, push/pull/put etc. remains the same.
|
||||
*/
|
||||
|
||||
#define MSGB_DEBUG
|
||||
|
||||
/*! \brief Osmocom message buffer */
|
||||
struct msgb {
|
||||
struct llist_head list; /*!< \brief linked list header */
|
||||
|
||||
|
||||
/* Part of which TRX logical channel we were received / transmitted */
|
||||
/* FIXME: move them into the control buffer */
|
||||
union {
|
||||
void *dst; /*!< \brief reference of origin/destination */
|
||||
struct gsm_bts_trx *trx;
|
||||
};
|
||||
struct gsm_lchan *lchan; /*!< \brief logical channel */
|
||||
|
||||
unsigned char *l1h; /*!< \brief pointer to Layer1 header (if any) */
|
||||
unsigned char *l2h; /*!< \brief pointer to A-bis layer 2 header: OML, RSL(RLL), NS */
|
||||
unsigned char *l3h; /*!< \brief pointer to Layer 3 header. For OML: FOM; RSL: 04.08; GPRS: BSSGP */
|
||||
unsigned char *l4h; /*!< \brief pointer to layer 4 header */
|
||||
|
||||
unsigned long cb[5]; /*!< \brief control buffer */
|
||||
|
||||
uint16_t data_len; /*!< \brief length of underlying data array */
|
||||
uint16_t len; /*!< \brief length of bytes used in msgb */
|
||||
|
||||
unsigned char *head; /*!< \brief start of underlying memory buffer */
|
||||
unsigned char *tail; /*!< \brief end of message in buffer */
|
||||
unsigned char *data; /*!< \brief start of message in buffer */
|
||||
unsigned char _data[0]; /*!< \brief optional immediate data array */
|
||||
};
|
||||
|
||||
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);
|
||||
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);
|
||||
static int msgb_test_invariant(const struct msgb *msg) __attribute__((pure));
|
||||
|
||||
#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
|
||||
|
||||
/*! \brief obtain L1 header of msgb */
|
||||
#define msgb_l1(m) ((void *)(m->l1h))
|
||||
/*! \brief obtain L2 header of msgb */
|
||||
#define msgb_l2(m) ((void *)(m->l2h))
|
||||
/*! \brief obtain L3 header of msgb */
|
||||
#define msgb_l3(m) ((void *)(m->l3h))
|
||||
/*! \brief obtain SMS header of msgb */
|
||||
#define msgb_sms(m) ((void *)(m->l4h))
|
||||
|
||||
/*! \brief determine length of L1 message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns size of L1 message in bytes
|
||||
*
|
||||
* This function computes the number of bytes between the tail of the
|
||||
* message and the layer 1 header.
|
||||
*/
|
||||
static inline unsigned int msgb_l1len(const struct msgb *msgb)
|
||||
{
|
||||
return msgb->tail - (uint8_t *)msgb_l1(msgb);
|
||||
}
|
||||
|
||||
/*! \brief determine length of L2 message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns size of L2 message in bytes
|
||||
*
|
||||
* This function computes the number of bytes between the tail of the
|
||||
* message and the layer 2 header.
|
||||
*/
|
||||
static inline unsigned int msgb_l2len(const struct msgb *msgb)
|
||||
{
|
||||
return msgb->tail - (uint8_t *)msgb_l2(msgb);
|
||||
}
|
||||
|
||||
/*! \brief determine length of L3 message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns size of L3 message in bytes
|
||||
*
|
||||
* This function computes the number of bytes between the tail of the
|
||||
* message and the layer 3 header.
|
||||
*/
|
||||
static inline unsigned int msgb_l3len(const struct msgb *msgb)
|
||||
{
|
||||
return msgb->tail - (uint8_t *)msgb_l3(msgb);
|
||||
}
|
||||
|
||||
/*! \brief determine the length of the header
|
||||
* \param[in] msgb message buffer
|
||||
* \returns number of bytes between start of buffer and start of msg
|
||||
*
|
||||
* This function computes the length difference between the underlying
|
||||
* data buffer and the used section of the \a msgb.
|
||||
*/
|
||||
static inline unsigned int msgb_headlen(const struct msgb *msgb)
|
||||
{
|
||||
return msgb->len - msgb->data_len;
|
||||
}
|
||||
|
||||
/*! \brief determine how much tail room is left in msgb
|
||||
* \param[in] msgb message buffer
|
||||
* \returns number of bytes remaining at end of msgb
|
||||
*
|
||||
* This function computes the amount of octets left in the underlying
|
||||
* data buffer after the end of the message.
|
||||
*/
|
||||
static inline int msgb_tailroom(const struct msgb *msgb)
|
||||
{
|
||||
return (msgb->head + msgb->data_len) - msgb->tail;
|
||||
}
|
||||
|
||||
/*! \brief determine the amount of headroom in msgb
|
||||
* \param[in] msgb message buffer
|
||||
* \returns number of bytes left ahead of message start in msgb
|
||||
*
|
||||
* This function computes the amount of bytes left in the underlying
|
||||
* data buffer before the start of the actual message.
|
||||
*/
|
||||
static inline int msgb_headroom(const struct msgb *msgb)
|
||||
{
|
||||
return (msgb->data - msgb->head);
|
||||
}
|
||||
|
||||
/*! \brief append data to end of message buffer
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] len number of bytes to append to message
|
||||
* \returns pointer to start of newly-appended data
|
||||
*
|
||||
* This function will move the \a tail pointer of the message buffer \a
|
||||
* len bytes further, thus enlarging the message by \a len bytes.
|
||||
*
|
||||
* The return value is a pointer to start of the newly added section at
|
||||
* the end of the message and can be used for actually filling/copying
|
||||
* data into it.
|
||||
*/
|
||||
static inline unsigned char *msgb_put(struct msgb *msgb, unsigned int len)
|
||||
{
|
||||
unsigned char *tmp = msgb->tail;
|
||||
if (msgb_tailroom(msgb) < (int) len)
|
||||
MSGB_ABORT(msgb, "Not enough tailroom msgb_put (%u < %u)\n",
|
||||
msgb_tailroom(msgb), len);
|
||||
msgb->tail += len;
|
||||
msgb->len += len;
|
||||
return tmp;
|
||||
}
|
||||
|
||||
/*! \brief append a uint8 value to the end of the message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] word unsigned 8bit byte to be appended
|
||||
*/
|
||||
static inline void msgb_put_u8(struct msgb *msgb, uint8_t word)
|
||||
{
|
||||
uint8_t *space = msgb_put(msgb, 1);
|
||||
space[0] = word & 0xFF;
|
||||
}
|
||||
|
||||
/*! \brief append a uint16 value to the end of the message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] word unsigned 16bit byte to be appended
|
||||
*/
|
||||
static inline void msgb_put_u16(struct msgb *msgb, uint16_t word)
|
||||
{
|
||||
uint8_t *space = msgb_put(msgb, 2);
|
||||
osmo_store16be(word, space);
|
||||
}
|
||||
|
||||
/*! \brief append a uint32 value to the end of the message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] word unsigned 32bit byte to be appended
|
||||
*/
|
||||
static inline void msgb_put_u32(struct msgb *msgb, uint32_t word)
|
||||
{
|
||||
uint8_t *space = msgb_put(msgb, 4);
|
||||
osmo_store32be(word, space);
|
||||
}
|
||||
|
||||
/*! \brief remove data from end of message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] len number of bytes to remove from end
|
||||
*/
|
||||
static inline unsigned char *msgb_get(struct msgb *msgb, unsigned int len)
|
||||
{
|
||||
unsigned char *tmp = msgb->tail - len;
|
||||
if (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 tmp;
|
||||
}
|
||||
|
||||
/*! \brief remove uint8 from end of message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns 8bit value taken from end of msgb
|
||||
*/
|
||||
static inline uint8_t msgb_get_u8(struct msgb *msgb)
|
||||
{
|
||||
uint8_t *space = msgb_get(msgb, 1);
|
||||
return space[0];
|
||||
}
|
||||
|
||||
/*! \brief remove uint16 from end of message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns 16bit value taken from end of msgb
|
||||
*/
|
||||
static inline uint16_t msgb_get_u16(struct msgb *msgb)
|
||||
{
|
||||
uint8_t *space = msgb_get(msgb, 2);
|
||||
return osmo_load16be(space);
|
||||
}
|
||||
|
||||
/*! \brief remove uint32 from end of message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns 32bit value taken from end of msgb
|
||||
*/
|
||||
static inline uint32_t msgb_get_u32(struct msgb *msgb)
|
||||
{
|
||||
uint8_t *space = msgb_get(msgb, 4);
|
||||
return osmo_load32be(space);
|
||||
}
|
||||
|
||||
/*! \brief prepend (push) some data to start of message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] len number of bytes to pre-pend
|
||||
* \returns pointer to newly added portion at start of \a msgb
|
||||
*
|
||||
* This function moves the \a data pointer of the \ref msgb further
|
||||
* to the front (by \a len bytes), thereby enlarging the message by \a
|
||||
* len bytes.
|
||||
*
|
||||
* The return value is a pointer to the newly added section in the
|
||||
* beginning of the message. It can be used to fill/copy data into it.
|
||||
*/
|
||||
static inline unsigned char *msgb_push(struct msgb *msgb, unsigned int len)
|
||||
{
|
||||
if (msgb_headroom(msgb) < (int) len)
|
||||
MSGB_ABORT(msgb, "Not enough headroom msgb_push (%u < %u)\n",
|
||||
msgb_headroom(msgb), len);
|
||||
msgb->data -= len;
|
||||
msgb->len += len;
|
||||
return msgb->data;
|
||||
}
|
||||
|
||||
/*! \brief prepend a uint8 value to the head of the message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] word unsigned 8bit byte to be prepended
|
||||
*/
|
||||
static inline void msgb_push_u8(struct msgb *msg, uint8_t word)
|
||||
{
|
||||
uint8_t *space = msgb_push(msg, 1);
|
||||
space[0] = word;
|
||||
}
|
||||
|
||||
/*! \brief prepend a uint16 value to the head of the message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] word unsigned 16bit byte to be prepended
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/*! \brief prepend a uint32 value to the head of the message
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] word unsigned 32bit byte to be prepended
|
||||
*/
|
||||
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);
|
||||
}
|
||||
|
||||
/*! \brief remove (pull) a header from the front of the message buffer
|
||||
* \param[in] msgb message buffer
|
||||
* \param[in] len number of octets to be pulled
|
||||
* \returns pointer to new start of msgb
|
||||
*
|
||||
* This function moves the \a data pointer of the \ref msgb further back
|
||||
* in the message, thereby shrinking the size of the message by \a len
|
||||
* bytes.
|
||||
*/
|
||||
static inline unsigned char *msgb_pull(struct msgb *msgb, unsigned int len)
|
||||
{
|
||||
msgb->len -= len;
|
||||
return msgb->data += len;
|
||||
}
|
||||
|
||||
/*! \brief remove (pull) all headers in front of l3h from the message buffer.
|
||||
* \param[in] msgb message buffer with a valid l3h
|
||||
* \returns pointer to new start of msgb (l3h)
|
||||
*
|
||||
* This function moves the \a data pointer of the \ref msgb further back
|
||||
* in the message, thereby shrinking the size of the message.
|
||||
* l1h and l2h will be cleared.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/*! \brief remove (pull) all headers in front of l2h from the message buffer.
|
||||
* \param[in] msgb message buffer with a valid l2h
|
||||
* \returns pointer to new start of msgb (l2h)
|
||||
*
|
||||
* This function moves the \a data pointer of the \ref msgb further back
|
||||
* in the message, thereby shrinking the size of the message.
|
||||
* l1h will be cleared.
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/*! \brief remove uint8 from front of message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns 8bit value taken from end of msgb
|
||||
*/
|
||||
static inline uint8_t msgb_pull_u8(struct msgb *msgb)
|
||||
{
|
||||
uint8_t *space = msgb_pull(msgb, 1) - 1;
|
||||
return space[0];
|
||||
}
|
||||
|
||||
/*! \brief remove uint16 from front of message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns 16bit value taken from end of msgb
|
||||
*/
|
||||
static inline uint16_t msgb_pull_u16(struct msgb *msgb)
|
||||
{
|
||||
uint8_t *space = msgb_pull(msgb, 2) - 2;
|
||||
return osmo_load16be(space);
|
||||
}
|
||||
|
||||
/*! \brief remove uint32 from front of message
|
||||
* \param[in] msgb message buffer
|
||||
* \returns 32bit value taken from end of msgb
|
||||
*/
|
||||
static inline uint32_t msgb_pull_u32(struct msgb *msgb)
|
||||
{
|
||||
uint8_t *space = msgb_pull(msgb, 4) - 4;
|
||||
return osmo_load32be(space);
|
||||
}
|
||||
|
||||
/*! \brief Increase headroom of empty msgb, reducing the tailroom
|
||||
* \param[in] msg message buffer
|
||||
* \param[in] len amount of extra octets to be reserved as headroom
|
||||
*
|
||||
* This function reserves some memory at the beginning of the underlying
|
||||
* data buffer. The idea is to reserve space in case further headers
|
||||
* have to be pushed to the \ref msgb during further processing.
|
||||
*
|
||||
* Calling this function leads to undefined reusults if it is called on
|
||||
* a non-empty \ref msgb.
|
||||
*/
|
||||
static inline void msgb_reserve(struct msgb *msg, int len)
|
||||
{
|
||||
msg->data += len;
|
||||
msg->tail += len;
|
||||
}
|
||||
|
||||
/*! \brief Trim the msgb to a given absolute length
|
||||
* \param[in] msg message buffer
|
||||
* \param[in] len new total length of buffer
|
||||
* \returns 0 in case of success, negative in case of error
|
||||
*/
|
||||
static inline int msgb_trim(struct msgb *msg, int len)
|
||||
{
|
||||
if (len < 0)
|
||||
MSGB_ABORT(msg, "Negative length is not allowed\n");
|
||||
if (len > msg->data_len)
|
||||
return -1;
|
||||
|
||||
msg->len = len;
|
||||
msg->tail = msg->data + len;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*! \brief Trim the msgb to a given layer3 length
|
||||
* \param[in] msg message buffer
|
||||
* \param[in] l3len new layer3 length
|
||||
* \returns 0 in case of success, negative in case of error
|
||||
*/
|
||||
static inline int msgb_l3trim(struct msgb *msg, int l3len)
|
||||
{
|
||||
return msgb_trim(msg, (msg->l3h - msg->data) + l3len);
|
||||
}
|
||||
|
||||
/*! \brief Allocate message buffer with specified headroom
|
||||
* \param[in] size size in bytes, including headroom
|
||||
* \param[in] headroom headroom in bytes
|
||||
* \param[in] name human-readable name
|
||||
* \returns allocated message buffer with specified headroom
|
||||
*
|
||||
* This function is a convenience wrapper around \ref msgb_alloc
|
||||
* followed by \ref msgb_reserve in order to create a new \ref msgb with
|
||||
* user-specified amount of headroom.
|
||||
*/
|
||||
static inline struct msgb *msgb_alloc_headroom(int size, int headroom,
|
||||
const char *name)
|
||||
{
|
||||
osmo_static_assert(size > headroom, headroom_bigger);
|
||||
|
||||
struct msgb *msg = msgb_alloc(size, name);
|
||||
if (msg)
|
||||
msgb_reserve(msg, headroom);
|
||||
return msg;
|
||||
}
|
||||
|
||||
/*! \brief Check a message buffer for consistency
|
||||
* \param[in] msg message buffer
|
||||
* \returns 0 (false) if inconsistent, != 0 (true) otherwise
|
||||
*/
|
||||
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;
|
||||
}
|
||||
|
||||
/* 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");
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,17 @@
|
|||
#pragma once
|
||||
|
||||
/*! \addtogroup utils
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file panic.h */
|
||||
|
||||
#include <stdarg.h>
|
||||
|
||||
/*! \brief panic handler callback function type */
|
||||
typedef void (*osmo_panic_handler_t)(const char *fmt, va_list args);
|
||||
|
||||
extern void osmo_panic(const char *fmt, ...);
|
||||
extern void osmo_set_panic_handler(osmo_panic_handler_t h);
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,4 @@
|
|||
/* Convenience wrapper. libosmocore used to ship its own internal copy of
|
||||
* talloc, before libtalloc became a standard component on most systems */
|
||||
#pragma once
|
||||
#include <talloc.h>
|
|
@ -0,0 +1,92 @@
|
|||
#pragma once
|
||||
|
||||
#include <osmocom/core/backtrace.h>
|
||||
#include <osmocom/core/talloc.h>
|
||||
|
||||
/*! \defgroup utils General-purpose utility functions
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file utils.h */
|
||||
|
||||
/*! \brief Determine number of elements in an array of static size */
|
||||
#define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
|
||||
/*! \brief Return the maximum of two specified values */
|
||||
#define OSMO_MAX(a, b) ((a) >= (b) ? (a) : (b))
|
||||
/*! \brief Return the minimum of two specified values */
|
||||
#define OSMO_MIN(a, b) ((a) >= (b) ? (b) : (a))
|
||||
/*! \brief Stringify the contents of a macro, e.g. a port number */
|
||||
#define OSMO_STRINGIFY(x) #x
|
||||
/*! \brief Make a value_string entry from an enum value name */
|
||||
#define OSMO_VALUE_STRING(x) { x, #x }
|
||||
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
|
||||
/*! \brief A mapping between human-readable string and numeric value */
|
||||
struct value_string {
|
||||
unsigned int value; /*!< \brief numeric value */
|
||||
const char *str; /*!< \brief human-readable string */
|
||||
};
|
||||
|
||||
const char *get_value_string(const struct value_string *vs, uint32_t val);
|
||||
const char *get_value_string_or_null(const struct value_string *vs,
|
||||
uint32_t val);
|
||||
|
||||
int get_string_value(const struct value_string *vs, const char *str);
|
||||
|
||||
char osmo_bcd2char(uint8_t bcd);
|
||||
/* only works for numbers in ascci */
|
||||
uint8_t osmo_char2bcd(char c);
|
||||
|
||||
int osmo_hexparse(const char *str, uint8_t *b, int max_len);
|
||||
|
||||
char *osmo_ubit_dump(const uint8_t *bits, unsigned int len);
|
||||
char *osmo_hexdump(const unsigned char *buf, int len);
|
||||
char *osmo_hexdump_nospc(const unsigned char *buf, int len);
|
||||
char *osmo_osmo_hexdump_nospc(const unsigned char *buf, int len) __attribute__((__deprecated__));
|
||||
|
||||
#define osmo_static_assert(exp, name) typedef int dummy##name [(exp) ? 1 : -1] __attribute__((__unused__));
|
||||
|
||||
void osmo_str2lower(char *out, const char *in);
|
||||
void osmo_str2upper(char *out, const char *in);
|
||||
|
||||
#define OSMO_SNPRINTF_RET(ret, rem, offset, len) \
|
||||
do { \
|
||||
len += ret; \
|
||||
if (ret > rem) \
|
||||
ret = rem; \
|
||||
offset += ret; \
|
||||
rem -= ret; \
|
||||
} while (0)
|
||||
|
||||
/*! Helper macro to terminate when an assertion failes
|
||||
* \param[in] exp Predicate to verify
|
||||
* This function will generate a backtrace and terminate the program if
|
||||
* the predicate evaluates to false (0).
|
||||
*/
|
||||
#define OSMO_ASSERT(exp) \
|
||||
if (!(exp)) { \
|
||||
fprintf(stderr, "Assert failed %s %s:%d\n", #exp, __BASE_FILE__, __LINE__); \
|
||||
osmo_generate_backtrace(); \
|
||||
abort(); \
|
||||
}
|
||||
|
||||
/*! duplicate a string using talloc and release its prior content (if any)
|
||||
* \param[in] ctx Talloc context to use for allocation
|
||||
* \param[out] dst pointer to string, will be updated with ptr to new string
|
||||
* \param[in] newstr String that will be copieed to newly allocated string */
|
||||
static inline void osmo_talloc_replace_string(void *ctx, char **dst, const char *newstr)
|
||||
{
|
||||
if (*dst)
|
||||
talloc_free(*dst);
|
||||
*dst = talloc_strdup(ctx, newstr);
|
||||
}
|
||||
|
||||
int osmo_constant_time_cmp(const uint8_t *exp, const uint8_t *rel, const int count);
|
||||
uint64_t osmo_decode_big_endian(const uint8_t *data, size_t data_len);
|
||||
uint8_t *osmo_encode_big_endian(uint64_t value, size_t data_len);
|
||||
|
||||
size_t osmo_strlcpy(char *dst, const char *src, size_t siz);
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,92 @@
|
|||
/*
|
||||
* (C) 2009 by Holger Hans Peter Freyther <zecke@selfish.org>
|
||||
* (C) 2012 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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
*/
|
||||
|
||||
/*! \file backtrace.c
|
||||
* \brief Routines realted to generating call back traces
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <osmocom/core/utils.h>
|
||||
//#include <osmocom/core/logging.h>
|
||||
//#include "config.h"
|
||||
|
||||
#ifdef HAVE_EXECINFO_H
|
||||
#include <execinfo.h>
|
||||
|
||||
static void _osmo_backtrace(int use_printf, int subsys, int level)
|
||||
{
|
||||
int i, nptrs;
|
||||
void *buffer[100];
|
||||
char **strings;
|
||||
|
||||
nptrs = backtrace(buffer, ARRAY_SIZE(buffer));
|
||||
if (use_printf)
|
||||
printf("backtrace() returned %d addresses\n", nptrs);
|
||||
else
|
||||
LOGP(subsys, level, "backtrace() returned %d addresses\n",
|
||||
nptrs);
|
||||
|
||||
strings = backtrace_symbols(buffer, nptrs);
|
||||
if (!strings)
|
||||
return;
|
||||
|
||||
for (i = 1; i < nptrs; i++) {
|
||||
if (use_printf)
|
||||
printf("%s\n", strings[i]);
|
||||
else
|
||||
LOGP(subsys, level, "\t%s\n", strings[i]);
|
||||
}
|
||||
|
||||
free(strings);
|
||||
}
|
||||
|
||||
/*! \brief Generate and print a call back-trace
|
||||
*
|
||||
* This function will generate a function call back-trace of the
|
||||
* current process and print it to stdout. */
|
||||
void osmo_generate_backtrace(void)
|
||||
{
|
||||
_osmo_backtrace(1, 0, 0);
|
||||
}
|
||||
|
||||
/*! \brief Generate and log a call back-trace
|
||||
* \param[in] subsys Logging sub-system
|
||||
* \param[in] level Logging level
|
||||
*
|
||||
* This function will generate a function call back-trace of the
|
||||
* current process and log it to the specified subsystem and
|
||||
* level using the libosmocore logging subsystem */
|
||||
void osmo_log_backtrace(int subsys, int level)
|
||||
{
|
||||
_osmo_backtrace(0, subsys, level);
|
||||
}
|
||||
#else
|
||||
void osmo_generate_backtrace(void)
|
||||
{
|
||||
printf("This platform has no backtrace function\n");
|
||||
}
|
||||
void osmo_log_backtrace(int subsys, int level)
|
||||
{
|
||||
//LOGP(subsys, level, "This platform has no backtrace function\n");
|
||||
}
|
||||
#endif
|
|
@ -0,0 +1,307 @@
|
|||
/*
|
||||
* (C) 2011 by Harald Welte <laforge@gnumonks.org>
|
||||
* (C) 2011 by Sylvain Munaut <tnt@246tNt.com>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
#include <osmocom/core/bits.h>
|
||||
|
||||
/*! \addtogroup bits
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file bits.c
|
||||
* \brief Osmocom bit level support code
|
||||
*/
|
||||
|
||||
|
||||
/*! \brief convert unpacked bits to packed bits, return length in bytes
|
||||
* \param[out] out output buffer of packed bits
|
||||
* \param[in] in input buffer of unpacked bits
|
||||
* \param[in] num_bits number of bits
|
||||
*/
|
||||
int osmo_ubit2pbit(pbit_t *out, const ubit_t *in, unsigned int num_bits)
|
||||
{
|
||||
unsigned int i;
|
||||
uint8_t curbyte = 0;
|
||||
pbit_t *outptr = out;
|
||||
|
||||
for (i = 0; i < num_bits; i++) {
|
||||
uint8_t bitnum = 7 - (i % 8);
|
||||
|
||||
curbyte |= (in[i] << bitnum);
|
||||
|
||||
if(i % 8 == 7){
|
||||
*outptr++ = curbyte;
|
||||
curbyte = 0;
|
||||
}
|
||||
}
|
||||
/* we have a non-modulo-8 bitcount */
|
||||
if (i % 8)
|
||||
*outptr++ = curbyte;
|
||||
|
||||
return outptr - out;
|
||||
}
|
||||
|
||||
/*! \brief Shift unaligned input to octet-aligned output
|
||||
* \param[out] out output buffer, unaligned
|
||||
* \param[in] in input buffer, octet-aligned
|
||||
* \param[in] num_nibbles number of nibbles
|
||||
*/
|
||||
void osmo_nibble_shift_right(uint8_t *out, const uint8_t *in,
|
||||
unsigned int num_nibbles)
|
||||
{
|
||||
unsigned int i, num_whole_bytes = num_nibbles / 2;
|
||||
if (!num_whole_bytes)
|
||||
return;
|
||||
|
||||
/* first byte: upper nibble empty, lower nibble from src */
|
||||
out[0] = (in[0] >> 4);
|
||||
|
||||
/* bytes 1.. */
|
||||
for (i = 1; i < num_whole_bytes; i++)
|
||||
out[i] = ((in[i - 1] & 0xF) << 4) | (in[i] >> 4);
|
||||
|
||||
/* shift the last nibble, in case there's an odd count */
|
||||
i = num_whole_bytes;
|
||||
if (num_nibbles & 1)
|
||||
out[i] = ((in[i - 1] & 0xF) << 4) | (in[i] >> 4);
|
||||
else
|
||||
out[i] = (in[i - 1] & 0xF) << 4;
|
||||
}
|
||||
|
||||
/*! \brief Shift unaligned input to octet-aligned output
|
||||
* \param[out] out output buffer, octet-aligned
|
||||
* \param[in] in input buffer, unaligned
|
||||
* \param[in] num_nibbles number of nibbles
|
||||
*/
|
||||
void osmo_nibble_shift_left_unal(uint8_t *out, const uint8_t *in,
|
||||
unsigned int num_nibbles)
|
||||
{
|
||||
unsigned int i, num_whole_bytes = num_nibbles / 2;
|
||||
if (!num_whole_bytes)
|
||||
return;
|
||||
|
||||
for (i = 0; i < num_whole_bytes; i++)
|
||||
out[i] = ((in[i] & 0xF) << 4) | (in[i + 1] >> 4);
|
||||
|
||||
/* shift the last nibble, in case there's an odd count */
|
||||
i = num_whole_bytes;
|
||||
if (num_nibbles & 1)
|
||||
out[i] = (in[i] & 0xF) << 4;
|
||||
}
|
||||
|
||||
/*! \brief convert unpacked bits to soft bits
|
||||
* \param[out] out output buffer of soft bits
|
||||
* \param[in] in input buffer of unpacked bits
|
||||
* \param[in] num_bits number of bits
|
||||
*/
|
||||
void osmo_ubit2sbit(sbit_t *out, const ubit_t *in, unsigned int num_bits)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; i < num_bits; i++)
|
||||
out[i] = in[i] ? -127 : 127;
|
||||
}
|
||||
|
||||
/*! \brief convert soft bits to unpacked bits
|
||||
* \param[out] out output buffer of unpacked bits
|
||||
* \param[in] in input buffer of soft bits
|
||||
* \param[in] num_bits number of bits
|
||||
*/
|
||||
void osmo_sbit2ubit(ubit_t *out, const sbit_t *in, unsigned int num_bits)
|
||||
{
|
||||
unsigned int i;
|
||||
for (i = 0; i < num_bits; i++)
|
||||
out[i] = in[i] < 0;
|
||||
}
|
||||
|
||||
/*! \brief convert packed bits to unpacked bits, return length in bytes
|
||||
* \param[out] out output buffer of unpacked bits
|
||||
* \param[in] in input buffer of packed bits
|
||||
* \param[in] num_bits number of bits
|
||||
* \return number of bytes used in \ref out
|
||||
*/
|
||||
int osmo_pbit2ubit(ubit_t *out, const pbit_t *in, unsigned int num_bits)
|
||||
{
|
||||
unsigned int i;
|
||||
ubit_t *cur = out;
|
||||
ubit_t *limit = out + num_bits;
|
||||
|
||||
for (i = 0; i < (num_bits/8)+1; i++) {
|
||||
pbit_t byte = in[i];
|
||||
*cur++ = (byte >> 7) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 6) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 5) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 4) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 3) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 2) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 1) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
*cur++ = (byte >> 0) & 1;
|
||||
if (cur >= limit)
|
||||
break;
|
||||
}
|
||||
return cur - out;
|
||||
}
|
||||
|
||||
/*! \brief convert unpacked bits to packed bits (extended options)
|
||||
* \param[out] out output buffer of packed bits
|
||||
* \param[in] out_ofs offset into output buffer
|
||||
* \param[in] in input buffer of unpacked bits
|
||||
* \param[in] in_ofs offset into input buffer
|
||||
* \param[in] num_bits number of bits
|
||||
* \param[in] lsb_mode Encode bits in LSB orde instead of MSB
|
||||
* \returns length in bytes (max written offset of output buffer + 1)
|
||||
*/
|
||||
int osmo_ubit2pbit_ext(pbit_t *out, unsigned int out_ofs,
|
||||
const ubit_t *in, unsigned int in_ofs,
|
||||
unsigned int num_bits, int lsb_mode)
|
||||
{
|
||||
int i, op, bn;
|
||||
for (i=0; i<num_bits; i++) {
|
||||
op = out_ofs + i;
|
||||
bn = lsb_mode ? (op&7) : (7-(op&7));
|
||||
if (in[in_ofs+i])
|
||||
out[op>>3] |= 1 << bn;
|
||||
else
|
||||
out[op>>3] &= ~(1 << bn);
|
||||
}
|
||||
return ((out_ofs + num_bits - 1) >> 3) + 1;
|
||||
}
|
||||
|
||||
/*! \brief convert packed bits to unpacked bits (extended options)
|
||||
* \param[out] out output buffer of unpacked bits
|
||||
* \param[in] out_ofs offset into output buffer
|
||||
* \param[in] in input buffer of packed bits
|
||||
* \param[in] in_ofs offset into input buffer
|
||||
* \param[in] num_bits number of bits
|
||||
* \param[in] lsb_mode Encode bits in LSB orde instead of MSB
|
||||
* \returns length in bytes (max written offset of output buffer + 1)
|
||||
*/
|
||||
int osmo_pbit2ubit_ext(ubit_t *out, unsigned int out_ofs,
|
||||
const pbit_t *in, unsigned int in_ofs,
|
||||
unsigned int num_bits, int lsb_mode)
|
||||
{
|
||||
int i, ip, bn;
|
||||
for (i=0; i<num_bits; i++) {
|
||||
ip = in_ofs + i;
|
||||
bn = lsb_mode ? (ip&7) : (7-(ip&7));
|
||||
out[out_ofs+i] = !!(in[ip>>3] & (1<<bn));
|
||||
}
|
||||
return out_ofs + num_bits;
|
||||
}
|
||||
|
||||
/*! \brief generalized bit reversal function
|
||||
* \param[in] x the 32bit value to be reversed
|
||||
* \param[in] k the type of reversal requested
|
||||
* \returns the reversed 32bit dword
|
||||
*
|
||||
* This function reverses the bit order within a 32bit word. Depending
|
||||
* on "k", it either reverses all bits in a 32bit dword, or the bytes in
|
||||
* the dword, or the bits in each byte of a dword, or simply swaps the
|
||||
* two 16bit words in a dword. See Chapter 7 "Hackers Delight"
|
||||
*/
|
||||
uint32_t osmo_bit_reversal(uint32_t x, enum osmo_br_mode k)
|
||||
{
|
||||
if (k & 1) x = (x & 0x55555555) << 1 | (x & 0xAAAAAAAA) >> 1;
|
||||
if (k & 2) x = (x & 0x33333333) << 2 | (x & 0xCCCCCCCC) >> 2;
|
||||
if (k & 4) x = (x & 0x0F0F0F0F) << 4 | (x & 0xF0F0F0F0) >> 4;
|
||||
if (k & 8) x = (x & 0x00FF00FF) << 8 | (x & 0xFF00FF00) >> 8;
|
||||
if (k & 16) x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16;
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
/*! \brief reverse the bit-order in each byte of a dword
|
||||
* \param[in] x 32bit input value
|
||||
* \returns 32bit value where bits of each byte have been reversed
|
||||
*
|
||||
* See Chapter 7 "Hackers Delight"
|
||||
*/
|
||||
uint32_t osmo_revbytebits_32(uint32_t x)
|
||||
{
|
||||
x = (x & 0x55555555) << 1 | (x & 0xAAAAAAAA) >> 1;
|
||||
x = (x & 0x33333333) << 2 | (x & 0xCCCCCCCC) >> 2;
|
||||
x = (x & 0x0F0F0F0F) << 4 | (x & 0xF0F0F0F0) >> 4;
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
/*! \brief reverse the bit order in a byte
|
||||
* \param[in] x 8bit input value
|
||||
* \returns 8bit value where bits order has been reversed
|
||||
*
|
||||
* See Chapter 7 "Hackers Delight"
|
||||
*/
|
||||
uint32_t osmo_revbytebits_8(uint8_t x)
|
||||
{
|
||||
x = (x & 0x55) << 1 | (x & 0xAA) >> 1;
|
||||
x = (x & 0x33) << 2 | (x & 0xCC) >> 2;
|
||||
x = (x & 0x0F) << 4 | (x & 0xF0) >> 4;
|
||||
|
||||
return x;
|
||||
}
|
||||
|
||||
/*! \brief reverse bit-order of each byte in a buffer
|
||||
* \param[in] buf buffer containing bytes to be bit-reversed
|
||||
* \param[in] len length of buffer in bytes
|
||||
*
|
||||
* This function reverses the bits in each byte of the buffer
|
||||
*/
|
||||
void osmo_revbytebits_buf(uint8_t *buf, int len)
|
||||
{
|
||||
unsigned int i;
|
||||
unsigned int unaligned_cnt;
|
||||
int len_remain = len;
|
||||
|
||||
unaligned_cnt = ((unsigned long)buf & 3);
|
||||
for (i = 0; i < unaligned_cnt; i++) {
|
||||
buf[i] = osmo_revbytebits_8(buf[i]);
|
||||
len_remain--;
|
||||
if (len_remain <= 0)
|
||||
return;
|
||||
}
|
||||
|
||||
for (i = unaligned_cnt; i + 3 < len; i += 4) {
|
||||
osmo_store32be(osmo_revbytebits_32(osmo_load32be(buf + i)), buf + i);
|
||||
len_remain -= 4;
|
||||
}
|
||||
|
||||
for (i = len - len_remain; i < len; i++) {
|
||||
buf[i] = osmo_revbytebits_8(buf[i]);
|
||||
len_remain--;
|
||||
}
|
||||
}
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,353 @@
|
|||
/* (C) 2008 by Harald Welte <laforge@gnumonks.org>
|
||||
* (C) 2010 by Holger Hans Peter Freyther <zecke@selfish.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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
*/
|
||||
|
||||
/*! \addtogroup msgb
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file msgb.c
|
||||
*/
|
||||
|
||||
#include <unistd.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <inttypes.h>
|
||||
|
||||
#include <osmocom/core/msgb.h>
|
||||
//#include <openbsc/gsm_data.h>
|
||||
#include <osmocom/core/talloc.h>
|
||||
//#include <openbsc/debug.h>
|
||||
|
||||
void *tall_msgb_ctx = NULL;
|
||||
|
||||
/*! \brief Allocate a new message buffer
|
||||
* \param[in] size Length in octets, including headroom
|
||||
* \param[in] name Human-readable name to be associated with msgb
|
||||
* \returns dynamically-allocated \ref msgb
|
||||
*
|
||||
* This function allocates a 'struct msgb' as well as the underlying
|
||||
* memory buffer for the actual message data (size specified by \a size)
|
||||
* using the talloc memory context previously set by \ref msgb_set_talloc_ctx
|
||||
*/
|
||||
struct msgb *msgb_alloc(uint16_t size, const char *name)
|
||||
{
|
||||
struct msgb *msg;
|
||||
|
||||
msg = _talloc_zero(tall_msgb_ctx, sizeof(*msg) + size, name);
|
||||
|
||||
if (!msg) {
|
||||
//LOGP(DRSL, LOGL_FATAL, "unable to allocate msgb\n");
|
||||
return NULL;
|
||||
}
|
||||
|
||||
msg->data_len = size;
|
||||
msg->len = 0;
|
||||
msg->data = msg->_data;
|
||||
msg->head = msg->_data;
|
||||
msg->tail = msg->_data;
|
||||
|
||||
return msg;
|
||||
}
|
||||
|
||||
/*! \brief Release given message buffer
|
||||
* \param[in] m Message buffer to be free'd
|
||||
*/
|
||||
void msgb_free(struct msgb *m)
|
||||
{
|
||||
talloc_free(m);
|
||||
}
|
||||
|
||||
/*! \brief Enqueue message buffer to tail of a queue
|
||||
* \param[in] queue linked list header of queue
|
||||
* \param[in] msg message buffer to be added to the queue
|
||||
*
|
||||
* The function will append the specified message buffer \a msg to the
|
||||
* queue implemented by \ref llist_head \a queue
|
||||
*/
|
||||
void msgb_enqueue(struct llist_head *queue, struct msgb *msg)
|
||||
{
|
||||
llist_add_tail(&msg->list, queue);
|
||||
}
|
||||
|
||||
/*! \brief Dequeue message buffer from head of queue
|
||||
* \param[in] queue linked list header of queue
|
||||
* \returns message buffer (if any) or NULL if queue empty
|
||||
*
|
||||
* The function will remove the first message buffer from the queue
|
||||
* implemented by \ref llist_head \a queue.
|
||||
*/
|
||||
struct msgb *msgb_dequeue(struct llist_head *queue)
|
||||
{
|
||||
struct llist_head *lh;
|
||||
|
||||
if (llist_empty(queue))
|
||||
return NULL;
|
||||
|
||||
lh = queue->next;
|
||||
|
||||
if (lh) {
|
||||
llist_del(lh);
|
||||
return llist_entry(lh, struct msgb, list);
|
||||
} else
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/*! \brief Re-set all message buffer pointers
|
||||
* \param[in] msg message buffer that is to be resetted
|
||||
*
|
||||
* This will re-set the various internal pointers into the underlying
|
||||
* message buffer, i.e. remvoe all headroom and treat the msgb as
|
||||
* completely empty. It also initializes the control buffer to zero.
|
||||
*/
|
||||
void msgb_reset(struct msgb *msg)
|
||||
{
|
||||
msg->len = 0;
|
||||
msg->data = msg->_data;
|
||||
msg->head = msg->_data;
|
||||
msg->tail = msg->_data;
|
||||
|
||||
msg->trx = NULL;
|
||||
msg->lchan = NULL;
|
||||
msg->l2h = NULL;
|
||||
msg->l3h = NULL;
|
||||
msg->l4h = NULL;
|
||||
|
||||
memset(&msg->cb, 0, sizeof(msg->cb));
|
||||
}
|
||||
|
||||
/*! \brief get pointer to data section of message buffer
|
||||
* \param[in] msg message buffer
|
||||
* \returns pointer to data section of message buffer
|
||||
*/
|
||||
uint8_t *msgb_data(const struct msgb *msg)
|
||||
{
|
||||
return msg->data;
|
||||
}
|
||||
|
||||
/*! \brief get length of message buffer
|
||||
* \param[in] msg message buffer
|
||||
* \returns length of data section in message buffer
|
||||
*/
|
||||
uint16_t msgb_length(const struct msgb *msg)
|
||||
{
|
||||
return msg->len;
|
||||
}
|
||||
|
||||
/*! \brief Set the talloc context for \ref msgb_alloc
|
||||
* Deprecated, use msgb_talloc_ctx_init() instead.
|
||||
* \param[in] ctx talloc context to be used as root for msgb allocations
|
||||
*/
|
||||
void msgb_set_talloc_ctx(void *ctx)
|
||||
{
|
||||
tall_msgb_ctx = ctx;
|
||||
}
|
||||
|
||||
/*! \brief Initialize a msgb talloc context for \ref msgb_alloc.
|
||||
* Create a talloc context called "msgb". If \a pool_size is 0, create a named
|
||||
* const as msgb talloc context. If \a pool_size is nonzero, create a talloc
|
||||
* pool, possibly for faster msgb allocations (see talloc_pool()).
|
||||
* \param[in] root_ctx talloc context used as parent for the new "msgb" ctx.
|
||||
* \param[in] pool_size if nonzero, create a talloc pool of this size.
|
||||
* \returns the new msgb talloc context, e.g. for reporting
|
||||
*/
|
||||
void *msgb_talloc_ctx_init(void *root_ctx, unsigned int pool_size)
|
||||
{
|
||||
if (!pool_size)
|
||||
tall_msgb_ctx = talloc_size(root_ctx, 0);
|
||||
else
|
||||
tall_msgb_ctx = talloc_pool(root_ctx, pool_size);
|
||||
talloc_set_name_const(tall_msgb_ctx, "msgb");
|
||||
return tall_msgb_ctx;
|
||||
}
|
||||
|
||||
/*! \brief Copy an msgb.
|
||||
*
|
||||
* This function allocates a new msgb, copies the data buffer of msg,
|
||||
* and adjusts the pointers (incl l1h-l4h) accordingly. The cb part
|
||||
* is not copied.
|
||||
* \param[in] msg The old msgb object
|
||||
* \param[in] name Human-readable name to be associated with msgb
|
||||
*/
|
||||
struct msgb *msgb_copy(const struct msgb *msg, const char *name)
|
||||
{
|
||||
struct msgb *new_msg;
|
||||
|
||||
new_msg = msgb_alloc(msg->data_len, name);
|
||||
if (!new_msg)
|
||||
return NULL;
|
||||
|
||||
/* copy data */
|
||||
memcpy(new_msg->_data, msg->_data, new_msg->data_len);
|
||||
|
||||
/* copy header */
|
||||
new_msg->len = msg->len;
|
||||
new_msg->data += msg->data - msg->_data;
|
||||
new_msg->head += msg->head - msg->_data;
|
||||
new_msg->tail += msg->tail - msg->_data;
|
||||
|
||||
if (msg->l1h)
|
||||
new_msg->l1h = new_msg->_data + (msg->l1h - msg->_data);
|
||||
if (msg->l2h)
|
||||
new_msg->l2h = new_msg->_data + (msg->l2h - msg->_data);
|
||||
if (msg->l3h)
|
||||
new_msg->l3h = new_msg->_data + (msg->l3h - msg->_data);
|
||||
if (msg->l4h)
|
||||
new_msg->l4h = new_msg->_data + (msg->l4h - msg->_data);
|
||||
|
||||
return new_msg;
|
||||
}
|
||||
|
||||
/*! \brief Resize an area within an msgb
|
||||
*
|
||||
* This resizes a sub area of the msgb data and adjusts the pointers (incl
|
||||
* l1h-l4h) accordingly. The cb part is not updated. If the area is extended,
|
||||
* the contents of the extension is undefined. The complete sub area must be a
|
||||
* part of [data,tail].
|
||||
*
|
||||
* \param[inout] msg The msgb object
|
||||
* \param[in] area A pointer to the sub-area
|
||||
* \param[in] old_size The old size of the sub-area
|
||||
* \param[in] new_size The new size of the sub-area
|
||||
* \returns 0 on success, -1 if there is not enough space to extend the area
|
||||
*/
|
||||
int msgb_resize_area(struct msgb *msg, uint8_t *area,
|
||||
int old_size, int new_size)
|
||||
{
|
||||
int rc;
|
||||
uint8_t *post_start = area + old_size;
|
||||
int pre_len = area - msg->data;
|
||||
int post_len = msg->len - old_size - pre_len;
|
||||
int delta_size = new_size - old_size;
|
||||
|
||||
if (old_size < 0 || new_size < 0)
|
||||
MSGB_ABORT(msg, "Negative sizes are not allowed\n");
|
||||
if (area < msg->data || post_start > msg->tail)
|
||||
MSGB_ABORT(msg, "Sub area is not fully contained in the msg data\n");
|
||||
|
||||
if (delta_size == 0)
|
||||
return 0;
|
||||
|
||||
if (delta_size > 0) {
|
||||
rc = msgb_trim(msg, msg->len + delta_size);
|
||||
if (rc < 0)
|
||||
return rc;
|
||||
}
|
||||
|
||||
memmove(area + new_size, area + old_size, post_len);
|
||||
|
||||
if (msg->l1h >= post_start)
|
||||
msg->l1h += delta_size;
|
||||
if (msg->l2h >= post_start)
|
||||
msg->l2h += delta_size;
|
||||
if (msg->l3h >= post_start)
|
||||
msg->l3h += delta_size;
|
||||
if (msg->l4h >= post_start)
|
||||
msg->l4h += delta_size;
|
||||
|
||||
if (delta_size < 0)
|
||||
msgb_trim(msg, msg->len + delta_size);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*! \brief Return a (static) buffer containing a hexdump of the msg
|
||||
* \param[in] msg message buffer
|
||||
* \returns a pointer to a static char array
|
||||
*/
|
||||
const char *msgb_hexdump(const struct msgb *msg)
|
||||
{
|
||||
static char buf[4100];
|
||||
int buf_offs = 0;
|
||||
int nchars;
|
||||
const unsigned char *start = msg->data;
|
||||
const unsigned char *lxhs[4];
|
||||
int i;
|
||||
|
||||
lxhs[0] = msg->l1h;
|
||||
lxhs[1] = msg->l2h;
|
||||
lxhs[2] = msg->l3h;
|
||||
lxhs[3] = msg->l4h;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(lxhs); i++) {
|
||||
if (!lxhs[i])
|
||||
continue;
|
||||
|
||||
if (lxhs[i] < msg->head)
|
||||
continue;
|
||||
if (lxhs[i] > msg->head + msg->data_len)
|
||||
continue;
|
||||
if (lxhs[i] > msg->tail)
|
||||
continue;
|
||||
if (lxhs[i] < msg->data || lxhs[i] > msg->tail) {
|
||||
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
|
||||
"(L%d=data%+" PRIdPTR ") ",
|
||||
i+1, lxhs[i] - msg->data);
|
||||
buf_offs += nchars;
|
||||
continue;
|
||||
}
|
||||
if (lxhs[i] < start) {
|
||||
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
|
||||
"(L%d%+" PRIdPTR ") ", i+1,
|
||||
start - lxhs[i]);
|
||||
buf_offs += nchars;
|
||||
continue;
|
||||
}
|
||||
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
|
||||
"%s[L%d]> ",
|
||||
osmo_hexdump(start, lxhs[i] - start),
|
||||
i+1);
|
||||
if (nchars < 0 || nchars + buf_offs >= sizeof(buf))
|
||||
return "ERROR";
|
||||
|
||||
buf_offs += nchars;
|
||||
start = lxhs[i];
|
||||
}
|
||||
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
|
||||
"%s", osmo_hexdump(start, msg->tail - start));
|
||||
if (nchars < 0 || nchars + buf_offs >= sizeof(buf))
|
||||
return "ERROR";
|
||||
|
||||
buf_offs += nchars;
|
||||
|
||||
for (i = 0; i < ARRAY_SIZE(lxhs); i++) {
|
||||
if (!lxhs[i])
|
||||
continue;
|
||||
|
||||
if (lxhs[i] < msg->head || lxhs[i] > msg->head + msg->data_len) {
|
||||
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
|
||||
"(L%d out of range) ", i+1);
|
||||
} else if (lxhs[i] <= msg->data + msg->data_len &&
|
||||
lxhs[i] > msg->tail) {
|
||||
nchars = snprintf(buf + buf_offs, sizeof(buf) - buf_offs,
|
||||
"(L%d=tail%+" PRIdPTR ") ",
|
||||
i+1, lxhs[i] - msg->tail);
|
||||
} else
|
||||
continue;
|
||||
|
||||
if (nchars < 0 || nchars + buf_offs >= sizeof(buf))
|
||||
return "ERROR";
|
||||
buf_offs += nchars;
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
/*! @} */
|
|
@ -0,0 +1,102 @@
|
|||
/* Panic handling */
|
||||
/*
|
||||
* (C) 2010 by Sylvain Munaut <tnt@246tNt.com>
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License along
|
||||
* with this program; if not, write to the Free Software Foundation, Inc.,
|
||||
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
||||
*
|
||||
*/
|
||||
|
||||
/*! \addtogroup utils
|
||||
* @{
|
||||
*/
|
||||
|
||||
/*! \file panic.c
|
||||
* \brief Routines for panic handling
|
||||
*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <osmocom/core/panic.h>
|
||||
#include <osmocom/core/backtrace.h>
|
||||
|
||||
//#include "../config.h"
|
||||
|
||||
|
||||
static osmo_panic_handler_t osmo_panic_handler = (void*)0;
|
||||
|
||||
|
||||
#ifndef PANIC_INFLOOP
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static void osmo_panic_default(const char *fmt, va_list args)
|
||||
{
|
||||
vfprintf(stderr, fmt, args);
|
||||
osmo_generate_backtrace();
|
||||
assert(0);
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
static void osmo_panic_default(const char *fmt, va_list args)
|
||||
{
|
||||
while (1);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*! \brief Terminate the current program with a panic
|
||||
*
|
||||
* You can call this function in case some severely unexpected situation
|
||||
* is detected and the program is supposed to terminate in a way that
|
||||
* reports the fact that it terminates.
|
||||
*
|
||||
* The application can register a panic handler function using \ref
|
||||
* osmo_set_panic_handler. If it doesn't, a default panic handler
|
||||
* function is called automatically.
|
||||
*
|
||||
* The default function on most systems will generate a backtrace and
|
||||
* then abort() the process.
|
||||
*/
|
||||
void osmo_panic(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
|
||||
if (osmo_panic_handler)
|
||||
osmo_panic_handler(fmt, args);
|
||||
else
|
||||
osmo_panic_default(fmt, args);
|
||||
|
||||
va_end(args);
|
||||
}
|
||||
|
||||
|
||||
/*! \brief Set the panic handler
|
||||
* \param[in] h New panic handler function
|
||||
*
|
||||
* This changes the panic handling function from the currently active
|
||||
* function to a new call-back function supplied by the caller.
|
||||
*/
|
||||
void osmo_set_panic_handler(osmo_panic_handler_t h)
|
||||
{
|
||||
osmo_panic_handler = h;
|
||||
}
|
||||
|
||||
/*! @} */
|
Loading…
Reference in New Issue