cellular-infrastructure
/
osmo-pcu
mirror of https://gerrit.osmocom.org/osmo-pcu
9
0
Fork 1
Code Issues Releases Wiki Activity

csn1: get rid of C++ specific code, compile with GCC 

The implementation of CSN.1 codec was taken from Wireshark, where
it's implemented in pure C. For some reason it was mixed with C++
specific features, mostly using references in parameter
declaration. Not sure what are the benefits.

Change-Id: I56d8b7fbd2f9f4e0bdd6b09d0366fe7eb7aa327a
This commit is contained in:
Vadim Yanitskiy 2020-01-25 01:24:59 +07:00
parent 8a87f913bd
commit 39a65056da
6 changed files with 209 additions and 213 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile.am
View File

@ -40,7 +40,7 @@ noinst_LTLIBRARIES = libgprs.la
libgprs_la_SOURCES = \
gprs_debug.cpp \
csn1.cpp \
csn1.c \
gsm_rlcmac.cpp \
gprs_bssgp_pcu.cpp \
gprs_rlcmac.cpp \

237
src/csn1.cpp → src/csn1.c
View File

@ -28,8 +28,6 @@
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include <iostream>
#include <cstdlib>
#include <assert.h>
#include <string.h>
#define __STDC_FORMAT_MACROS
@ -37,10 +35,8 @@
#include "csn1.h"
#include <gprs_debug.h>
extern "C" {
#include <osmocom/core/logging.h>
#include <osmocom/core/utils.h>
}
#define pvDATA(_pv, _offset) ((void*) ((unsigned char*)_pv + _offset))
#define pui8DATA(_pv, _offset) ((guint8*) pvDATA(_pv, _offset))
@ -51,33 +47,32 @@ extern "C" {
#define STANDARD_TAG 1
#define REVERSED_TAG 0
using namespace std;
static const unsigned char ixBitsTab[] = {0, 1, 1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 5};
/* Returns no_of_bits (up to 8) masked with 0x2B */
static guint8
get_masked_bits8( bitvec *vector, unsigned& readIndex, gint bit_offset, const gint no_of_bits)
get_masked_bits8(struct bitvec *vector, unsigned *readIndex, gint bit_offset, const gint no_of_bits)
{
static const guint8 maskBits[] = {0x00, 0x01, 0x03, 0x07, 0x0F, 0x1F, 0x3F, 0x7F, 0xFF};
//gint byte_offset = bit_offset >> 3; /* divide by 8 */
gint relative_bit_offset = bit_offset & 0x07; /* modulo 8 */
guint8 result;
gint bit_shift = 8 - relative_bit_offset - (gint) no_of_bits;
readIndex -= relative_bit_offset;
*readIndex -= relative_bit_offset;
if (bit_shift >= 0)
{
result = (0x2B ^ ((guint8)bitvec_read_field(vector, &readIndex, 8))) >> bit_shift;
readIndex-= bit_shift;
result = (0x2B ^ ((guint8)bitvec_read_field(vector, readIndex, 8))) >> bit_shift;
*readIndex-= bit_shift;
result &= maskBits[no_of_bits];
}
else
{
guint8 hight_part = (0x2B ^ ((guint8)bitvec_read_field(vector, &readIndex, 8))) & maskBits[8 - relative_bit_offset];
guint8 hight_part = (0x2B ^ ((guint8)bitvec_read_field(vector, readIndex, 8))) & maskBits[8 - relative_bit_offset];
hight_part = (guint8) (hight_part << (-bit_shift));
result = (0x2B ^ ((guint8)bitvec_read_field(vector, &readIndex, 8))) >> (8 + bit_shift);
readIndex = readIndex - (8 - (-bit_shift));
result = (0x2B ^ ((guint8)bitvec_read_field(vector, readIndex, 8))) >> (8 + bit_shift);
*readIndex = *readIndex - (8 - (-bit_shift));
result |= hight_part;
}
return result;
@ -111,14 +106,14 @@ static const struct value_string csn1_error_names[] = {
};
static gint16 ProcessError_impl(const char *file, int line, unsigned readIndex,
static gint16 ProcessError_impl(const char *file, int line, unsigned *readIndex,
const char* sz, gint16 err, const CSN_DESCR* pDescr)
{
/* Don't add trailing newline, top caller is responsible for appending it */
if (err != CSN_OK)
LOGPSRC(DCSN1, LOGL_ERROR, file, line, "%s: error %s (%d) at %s (idx %d)",
sz, get_value_string(csn1_error_names, err), err,
pDescr ? pDescr->sz : "-", readIndex);
pDescr ? pDescr->sz : "-", *readIndex);
return err;
}
@ -135,9 +130,9 @@ static gint16 ProcessError_impl(const char *file, int line, unsigned readIndex,
*/
static gboolean
existNextElement(bitvec *vector, unsigned& readIndex, guint8 Tag)
existNextElement(struct bitvec *vector, unsigned *readIndex, guint8 Tag)
{
int res = bitvec_get_bit_pos(vector, readIndex++);
int res = bitvec_get_bit_pos(vector, (*readIndex)++);
if (Tag == STANDARD_TAG)
{
return (res > 0);
@ -147,7 +142,7 @@ existNextElement(bitvec *vector, unsigned& readIndex, guint8 Tag)
gint16
csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsigned& readIndex, void* data)
csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, struct bitvec *vector, unsigned *readIndex, void* data)
{
gint remaining_bits_len = ar->remaining_bits_len;
gint bit_offset = ar->bit_offset;
@ -156,6 +151,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
guint32* pui32;
guint64* pui64;
guint8 Tag = STANDARD_TAG;
unsigned ib;
if (remaining_bits_len <= 0)
{
@ -171,7 +167,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (remaining_bits_len > 0)
{
pui8 = pui8DATA(data, pDescr->offset);
*pui8 = bitvec_read_field(vector, &readIndex, 1);
*pui8 = bitvec_read_field(vector, readIndex, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
/* end add the bit value to protocol tree */
}
@ -207,21 +203,21 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
{
if (no_of_bits <= 8)
{
guint8 ui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint8 ui8 = bitvec_read_field(vector, readIndex, no_of_bits);
pui8 = pui8DATA(data, pDescr->offset);
*pui8 = ui8;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
else if (no_of_bits <= 16)
{
guint16 ui16 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint16 ui16 = bitvec_read_field(vector, readIndex, no_of_bits);
pui16 = pui16DATA(data, pDescr->offset);
*pui16 = ui16;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui16);
}
else if (no_of_bits <= 32)
{
guint32 ui32 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint32 ui32 = bitvec_read_field(vector, readIndex, no_of_bits);
pui32 = pui32DATA(data, pDescr->offset);
*pui32 = ui32;
LOGPC(DCSN1, LOGL_NOTICE, "%s = 0x%08x | ", pDescr->sz , *pui32);
@ -269,21 +265,21 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
{
if (no_of_bits <= 8)
{
guint8 ui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint8 ui8 = bitvec_read_field(vector, readIndex, no_of_bits);
pui8 = pui8DATA(data, pDescr->offset);
*pui8 = ui8 + (guint8)pDescr->descr.value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
else if (no_of_bits <= 16)
{
guint16 ui16 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint16 ui16 = bitvec_read_field(vector, readIndex, no_of_bits);
pui16 = pui16DATA(data, pDescr->offset);
*pui16 = ui16 + (guint16)pDescr->descr.value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui16);
}
else if (no_of_bits <= 32)
{
guint32 ui32 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint32 ui32 = bitvec_read_field(vector, readIndex, no_of_bits);
pui32 = pui32DATA(data, pDescr->offset);
*pui32 = ui32 + (guint16)pDescr->descr.value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui32);
@ -352,7 +348,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
pui8 = pui8DATA(data, pDescr->offset);
do
{
*pui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
*pui8 = bitvec_read_field(vector, readIndex, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
bit_offset += no_of_bits;
@ -433,9 +429,9 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (no_of_bits <= 32)
{
for(unsigned ib = 0; ib < 4; ib++)
for(ib = 0; ib < 4; ib++)
{
guint8 ui8 = bitvec_read_field(vector, &readIndex, 8);
guint8 ui8 = bitvec_read_field(vector, readIndex, 8);
pui8 = pui8DATA(data, pDescr->offset+ib);
*pui8 = ui8;
LOGPC(DCSN1, LOGL_NOTICE, "%s[%u] = %u | ", pDescr->sz , ib, (unsigned)*pui8);
@ -443,9 +439,9 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
}
else if (no_of_bits <= 64)
{
for(unsigned ib = 0; ib < 8; ib++)
for(ib = 0; ib < 8; ib++)
{
guint8 ui8 = bitvec_read_field(vector, &readIndex, 8);
guint8 ui8 = bitvec_read_field(vector, readIndex, 8);
pui8 = pui8DATA(data, pDescr->offset+ib);
*pui8 = ui8;
LOGPC(DCSN1, LOGL_NOTICE, "%s[%u] = %u | ", pDescr->sz , ib, (unsigned)*pui8);
@ -502,7 +498,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
while (count > 0)
{
guint8 no_of_bits = pChoice->bits;
guint8 value = bitvec_read_field(vector, &readIndex, no_of_bits);
guint8 value = bitvec_read_field(vector, readIndex, no_of_bits);
if (value == pChoice->value)
{
CSN_DESCR descr[2];
@ -535,7 +531,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
break;
}
readIndex -= no_of_bits;
*readIndex -= no_of_bits;
count--;
pChoice++;
i++;
@ -556,7 +552,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
guint8 length_len = pDescr->i;
gint16 Status = -1;
guint8 length = bitvec_read_field(vector, &readIndex, length_len);
guint8 length = bitvec_read_field(vector, readIndex, length_len);
LOGPC(DCSN1, LOGL_NOTICE, "%s length = %d | ", pDescr->sz , (int)length);
bit_offset += length_len;
@ -611,11 +607,11 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (CSN_UNION_LH == pDescr->type)
{
index |= get_masked_bits8(vector,readIndex, bit_offset, 1);
index |= get_masked_bits8(vector, readIndex, bit_offset, 1);
}
else
{
index |= bitvec_read_field(vector, &readIndex, 1);
index |= bitvec_read_field(vector, readIndex, 1);
}
remaining_bits_len--;
bit_offset++;
@ -638,7 +634,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
{
pui8 = pui8DATA(data, pDescr->offset);
*pui8 = 0x00;
if (bitvec_read_field(vector, &readIndex, 1) > 0)
if (bitvec_read_field(vector, readIndex, 1) > 0)
{
*pui8 = 0x01;
}
@ -665,21 +661,21 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (no_of_bits <= 8)
{
guint8 ui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint8 ui8 = bitvec_read_field(vector, readIndex, no_of_bits);
pui8 = pui8DATA(data, pDescr->offset);
*pui8 = ui8;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
else if (no_of_bits <= 16)
{
guint16 ui16 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint16 ui16 = bitvec_read_field(vector, readIndex, no_of_bits);
pui16 = pui16DATA(data, pDescr->offset);
*pui16 = ui16;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui16);
}
else if (no_of_bits <= 32)
{
guint32 ui32 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint32 ui32 = bitvec_read_field(vector, readIndex, no_of_bits);
pui32 = pui32DATA(data, pDescr->offset);
*pui32 = ui32;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui32);
@ -707,21 +703,21 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
{
if (no_of_bits <= 8)
{
guint8 ui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint8 ui8 = bitvec_read_field(vector, readIndex, no_of_bits);
pui8 = pui8DATA(data, pDescr->offset);
*pui8 = ui8 + (guint8)pDescr->descr.value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
else if (no_of_bits <= 16)
{
guint16 ui16 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint16 ui16 = bitvec_read_field(vector, readIndex, no_of_bits);
pui16 = pui16DATA(data, pDescr->offset);
*pui16 = ui16 + (guint16)pDescr->descr.value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui16);
}
else if (no_of_bits <= 32)
{
guint32 ui32 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint32 ui32 = bitvec_read_field(vector, readIndex, no_of_bits);
pui32 = pui32DATA(data, pDescr->offset);
*pui32 = ui32 + (guint16)pDescr->descr.value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui32);
@ -788,7 +784,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
while (nCount > 0)
{
*pui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
*pui8 = bitvec_read_field(vector, readIndex, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
bit_offset += no_of_bits;
@ -801,7 +797,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
while (nCount > 0)
{
*pui16 = bitvec_read_field(vector, &readIndex, no_of_bits);
*pui16 = bitvec_read_field(vector, readIndex, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , *pui16);
pui16++;
bit_offset += no_of_bits;
@ -877,13 +873,13 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (no_of_bits <= 32)
{
guint32 ui32 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint32 ui32 = bitvec_read_field(vector, readIndex, no_of_bits);
pui32 = pui32DATA(data, pDescr->offset);
*pui32 = ui32;
}
else if (no_of_bits <= 64)
{
guint64 ui64 = bitvec_read_field(vector, &readIndex, no_of_bits);
guint64 ui64 = bitvec_read_field(vector, readIndex, no_of_bits);
pui64 = pui64DATA(data, pDescr->offset);
*pui64 = ui64;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %lu | ", pDescr->sz , *pui64);
@ -948,7 +944,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
}
else
{
fExist = bitvec_read_field(vector, &readIndex, 1);
fExist = bitvec_read_field(vector, readIndex, 1);
}
*pui8 = fExist;
@ -987,7 +983,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
/* the "regular" M_NEXT_EXIST description element */
fExist = 0x00;
if (bitvec_read_field(vector, &readIndex, 1))
if (bitvec_read_field(vector, readIndex, 1))
{
fExist = 0x01;
}
@ -1030,7 +1026,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
}
/* the "regular" M_NEXT_EXIST_LH description element */
fExist = get_masked_bits8(vector,readIndex,bit_offset, 1);
fExist = get_masked_bits8(vector, readIndex, bit_offset, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)fExist);
*pui8++ = fExist;
remaining_bits_len -= 1;
@ -1080,7 +1076,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (nB1 > 0)
{ /* take care of the first byte - it will be right aligned */
*pui8 = bitvec_read_field(vector, &readIndex, nB1);
*pui8 = bitvec_read_field(vector, readIndex, nB1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= nB1;
@ -1090,7 +1086,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
/* remaining no_of_bits is a multiple of 8 or 0 */
while (no_of_bits > 0)
{
*pui8 = bitvec_read_field(vector, &readIndex, 8);
*pui8 = bitvec_read_field(vector, readIndex, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= 8;
@ -1134,14 +1130,14 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
while (no_of_bits >= 8)
{
*pui8 = bitvec_read_field(vector, &readIndex, 8);
*pui8 = bitvec_read_field(vector, readIndex, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= 8;
}
if (no_of_bits > 0)
{
*pui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
{
*pui8 = bitvec_read_field(vector, readIndex, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
bit_offset += no_of_bits;
@ -1212,7 +1208,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
while (count > 0)
{
readIndex -= 8;
*pui8 = bitvec_read_field(vector, &readIndex, 8);
*pui8 = bitvec_read_field(vector, readIndex, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
bit_offset += 8;
@ -1245,7 +1241,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
remaining_bits_len--;
/* extract and store no_of_bits long element from bitstream */
*pui8 = bitvec_read_field(vector, &readIndex, no_of_bits);
*pui8 = bitvec_read_field(vector, readIndex, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
remaining_bits_len -= no_of_bits;
@ -1394,7 +1390,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
if (no_of_bits <= 32)
{
ui32 = bitvec_read_field(vector, &readIndex, no_of_bits);
ui32 = bitvec_read_field(vector, readIndex, no_of_bits);
}
else
{
@ -1446,7 +1442,7 @@ csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsig
gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsigned& writeIndex, void* data)
gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, struct bitvec *vector, unsigned *writeIndex, void* data)
{
gint remaining_bits_len = ar->remaining_bits_len;
gint bit_offset = ar->bit_offset;
@ -1454,6 +1450,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
guint16* pui16;
guint32* pui32;
guint64* pui64;
unsigned ib;
guint8 Tag = STANDARD_TAG;
@ -1471,7 +1468,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (remaining_bits_len > 0)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8, 1);
bitvec_write_field(vector, writeIndex, *pui8, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
/* end add the bit value to protocol tree */
}
@ -1505,19 +1502,19 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 8)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
else if (no_of_bits <= 16)
{
pui16 = pui16DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui16, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui16, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui16);
}
else if (no_of_bits <= 32)
{
pui32 = pui32DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui32, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui32, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui32);
}
else
@ -1550,19 +1547,19 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 8)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8 - (guint8)pDescr->descr.value, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8 - (guint8)pDescr->descr.value, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)(*pui8 - (guint8)pDescr->descr.value));
}
else if (no_of_bits <= 16)
{
pui16 = pui16DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui16 - (guint16)pDescr->descr.value, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui16 - (guint16)pDescr->descr.value, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , (unsigned short)(*pui16 - (guint16)pDescr->descr.value));
}
else if (no_of_bits <= 32)
{
pui32 = pui32DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui32 - (guint16)pDescr->descr.value, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui32 - (guint16)pDescr->descr.value, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , (unsigned int)(*pui32 - (guint16)pDescr->descr.value));
}
else
@ -1590,12 +1587,12 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 8)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
// TODO : Change get_masked_bits8()
writeIndex -= no_of_bits;
*writeIndex -= no_of_bits;
guint8 ui8 = get_masked_bits8(vector, writeIndex, bit_offset, no_of_bits);
writeIndex -= no_of_bits;
bitvec_write_field(vector, &writeIndex, ui8, no_of_bits);
*writeIndex -= no_of_bits;
bitvec_write_field(vector, writeIndex, ui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
@ -1632,7 +1629,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
pui8 = pui8DATA(data, pDescr->offset);
do
{
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
remaining_bits_len -= no_of_bits;
@ -1715,19 +1712,19 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 32)
{
for(unsigned ib = 0; ib < 4; ib++)
for(ib = 0; ib < 4; ib++)
{
pui8 = pui8DATA(data, pDescr->offset+ib);
bitvec_write_field(vector, &writeIndex, *pui8, 8);
bitvec_write_field(vector, writeIndex, *pui8, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s[%u] = %u | ", pDescr->sz , ib, (unsigned)*pui8);
}
}
else if (no_of_bits <= 64)
{
for(unsigned ib = 0; ib < 8; ib++)
for(ib = 0; ib < 8; ib++)
{
pui8 = pui8DATA(data, pDescr->offset+ib);
bitvec_write_field(vector, &writeIndex, *pui8, 8);
bitvec_write_field(vector, writeIndex, *pui8, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s[%u] = %u | ", pDescr->sz , ib, (unsigned)*pui8);
}
}
@ -1782,7 +1779,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
guint8 no_of_bits = pChoice->bits;
guint8 value = pChoice->value;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pChoice->descr.sz , (unsigned)value);
bitvec_write_field(vector, &writeIndex, value, no_of_bits);
bitvec_write_field(vector, writeIndex, value, no_of_bits);
CSN_DESCR descr[2];
gint16 Status;
@ -1820,16 +1817,16 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
unsigned lengthIndex;
// store writeIndex for length value (7 bit)
lengthIndex = writeIndex;
writeIndex += length_len;
lengthIndex = *writeIndex;
*writeIndex += length_len;
bit_offset += length_len;
remaining_bits_len -= length_len;
arT.direction = 0;
csnStreamInit(&arT, bit_offset, remaining_bits_len);
Status = serialize(&arT, vector, writeIndex, pvDATA(data, pDescr->offset));
bitvec_write_field(vector, &lengthIndex, writeIndex-lengthIndex-length_len, length_len);
LOGPC(DCSN1, LOGL_NOTICE, "%s length = %u | ", pDescr->sz , (unsigned)(writeIndex-lengthIndex));
bitvec_write_field(vector, &lengthIndex, *writeIndex - lengthIndex - length_len, length_len);
LOGPC(DCSN1, LOGL_NOTICE, "%s length = %u | ", pDescr->sz , (unsigned)(*writeIndex - lengthIndex));
if (Status >= 0)
{
@ -1867,10 +1864,10 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
/* Assign UnionType */
pui8 = pui8DATA(data, pDescr->offset);
//read index from data and write to vector
bitvec_write_field(vector, &writeIndex, *pui8, Bits);
bitvec_write_field(vector, writeIndex, *pui8, Bits);
//decode index
writeIndex -= Bits;
*writeIndex -= Bits;
while (Bits > 0)
{
@ -1878,11 +1875,11 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (CSN_UNION_LH == pDescr->type)
{
index |= get_masked_bits8(vector,writeIndex, bit_offset, 1);
index |= get_masked_bits8(vector, writeIndex, bit_offset, 1);
}
else
{
index |= bitvec_read_field(vector, &writeIndex, 1);
index |= bitvec_read_field(vector, writeIndex, 1);
}
remaining_bits_len--;
@ -1890,8 +1887,8 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
Bits--;
}
writeIndex -= Bits;
bitvec_write_field(vector, &writeIndex, index, Bits);
*writeIndex -= Bits;
bitvec_write_field(vector, writeIndex, index, Bits);
/* script index to continue on, limited in case we do not have a power of 2 */
@ -1904,7 +1901,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
case CSN_BIT:
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8, 1);
bitvec_write_field(vector, writeIndex, *pui8, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
remaining_bits_len--;
bit_offset++;
@ -1926,19 +1923,19 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 8)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
else if (no_of_bits <= 16)
{
pui16 = pui16DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui16, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui16, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui16);
}
else if (no_of_bits <= 32)
{
pui32 = pui32DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui32, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui32, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui32);
}
else
@ -1966,19 +1963,19 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 8)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8 - (guint8)pDescr->descr.value, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8 - (guint8)pDescr->descr.value, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)(*pui8 - (guint8)pDescr->descr.value));
}
else if (no_of_bits <= 16)
{
pui16 = pui16DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui16 - (guint16)pDescr->descr.value, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui16 - (guint16)pDescr->descr.value, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , (unsigned short)(*pui16 - (guint16)pDescr->descr.value));
}
else if (no_of_bits <= 32)
{
pui32 = pui32DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui32 - (guint16)pDescr->descr.value, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui32 - (guint16)pDescr->descr.value, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , (unsigned int)(*pui32 - (guint16)pDescr->descr.value));
}
else
@ -2007,12 +2004,12 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 8)
{
pui8 = pui8DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
// TODO : Change get_masked_bits8()
writeIndex -= no_of_bits;
*writeIndex -= no_of_bits;
guint8 ui8 = get_masked_bits8(vector, writeIndex, bit_offset, no_of_bits);
writeIndex -= no_of_bits;
bitvec_write_field(vector, &writeIndex, ui8, no_of_bits);
*writeIndex -= no_of_bits;
bitvec_write_field(vector, writeIndex, ui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
}
@ -2049,7 +2046,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
pui8 = pui8DATA(data, pDescr->offset);
do
{
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
remaining_bits_len -= no_of_bits;
@ -2132,13 +2129,13 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (no_of_bits <= 32)
{
pui32 = pui32DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui32, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui32, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %d | ", pDescr->sz , *pui32);
}
else if (no_of_bits <= 64)
{
pui64 = pui64DATA(data, pDescr->offset);
bitvec_write_field(vector, &writeIndex, *pui64, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui64, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %lu | ", pDescr->sz , *pui64);
}
else
@ -2196,7 +2193,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
unsigned exist = 0;
pui8 = pui8DATA(data, pDescr->offset);
exist = *pui8;
bitvec_write_field(vector, &writeIndex, *pui8, 1);
bitvec_write_field(vector, writeIndex, *pui8, 1);
writeIndex--;
if (CSN_EXIST_LH == pDescr->type)
{
@ -2204,10 +2201,10 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
}
else
{
fExist = bitvec_read_field(vector, &writeIndex, 1);
fExist = bitvec_read_field(vector, writeIndex, 1);
}
writeIndex--;
bitvec_write_field(vector, &writeIndex, fExist, 1);
bitvec_write_field(vector, writeIndex, fExist, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz, (unsigned)fExist);
remaining_bits_len--;
bit_offset++;
@ -2238,7 +2235,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
break;
}
bitvec_write_field(vector, &writeIndex, *pui8, 1);
bitvec_write_field(vector, writeIndex, *pui8, 1);
fExist = *pui8;
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
@ -2272,11 +2269,11 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
}
/* the "regular" M_NEXT_EXIST_LH description element */
bitvec_write_field(vector, &writeIndex, *pui8, 1);
bitvec_write_field(vector, writeIndex, *pui8, 1);
writeIndex--;
fExist = get_masked_bits8(vector,writeIndex, bit_offset, 1);
fExist = get_masked_bits8(vector, writeIndex, bit_offset, 1);
writeIndex--;
bitvec_write_field(vector, &writeIndex, fExist, 1);
bitvec_write_field(vector, writeIndex, fExist, 1);
pui8++;
remaining_bits_len--;
@ -2324,7 +2321,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
if (nB1 > 0)
{ /* take care of the first byte - it will be right aligned */
bitvec_write_field(vector, &writeIndex, *pui8, nB1);
bitvec_write_field(vector, writeIndex, *pui8, nB1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= nB1;
@ -2335,7 +2332,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
/* remaining no_of_bits is a multiple of 8 or 0 */
while (no_of_bits > 0)
{
bitvec_write_field(vector, &writeIndex, *pui8, 8);
bitvec_write_field(vector, writeIndex, *pui8, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= 8;
@ -2382,14 +2379,14 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
while (no_of_bits > 0)
{
bitvec_write_field(vector, &writeIndex, *pui8, 8);
bitvec_write_field(vector, writeIndex, *pui8, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= 8;
}
if (nB1 > 0)
{
bitvec_write_field(vector, &writeIndex, *pui8, nB1);
bitvec_write_field(vector, writeIndex, *pui8, nB1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
no_of_bits -= nB1;
@ -2421,14 +2418,14 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
* < padding bits > ::= { null | 0 < spare padding > ! < Ignore : 1 bit** = < no string > > } ;
*/
guint8 fl = filler&(0xff>>(8-bits_to_handle + 1));
bitvec_write_field(vector, &writeIndex, fl, bits_to_handle);
bitvec_write_field(vector, writeIndex, fl, bits_to_handle);
LOGPC(DCSN1, LOGL_NOTICE, "%u|", fl);
remaining_bits_len -= bits_to_handle;
bit_offset += bits_to_handle;
}
else if (bits_to_handle == 0)
{
bitvec_write_field(vector, &writeIndex, filler, 8);
bitvec_write_field(vector, writeIndex, filler, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%u|", filler);
remaining_bits_len -= 8;
bit_offset += 8;
@ -2467,7 +2464,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
while (count > 0)
{
bitvec_write_field(vector, &writeIndex, *pui8, 8);
bitvec_write_field(vector, writeIndex, *pui8, 8);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
bit_offset += 8;
@ -2495,13 +2492,13 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
ElementCount = *pui8DATA(data, (gint16)pDescr->descr.value);
while (ElementCount > 0)
{ /* tag control shows existence of next list elements */
bitvec_write_field(vector, &writeIndex, Tag, 1);
bitvec_write_field(vector, writeIndex, Tag, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)Tag);
bit_offset++;
remaining_bits_len--;
/* extract and store no_of_bits long element from bitstream */
bitvec_write_field(vector, &writeIndex, *pui8, no_of_bits);
bitvec_write_field(vector, writeIndex, *pui8, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)*pui8);
pui8++;
ElementCount--;
@ -2515,7 +2512,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
remaining_bits_len -= no_of_bits;
}
bitvec_write_field(vector, &writeIndex, !Tag, 1);
bitvec_write_field(vector, writeIndex, !Tag, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)(!Tag));
bit_offset++;
remaining_bits_len--;
@ -2537,7 +2534,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
while (ElementCount > 0)
{ /* tag control shows existence of next list elements */
bitvec_write_field(vector, &writeIndex, Tag, 1);
bitvec_write_field(vector, writeIndex, Tag, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)Tag);
bit_offset++;
@ -2568,7 +2565,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
}
}
bitvec_write_field(vector, &writeIndex, !Tag, 1);
bitvec_write_field(vector, writeIndex, !Tag, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)(!Tag));
bit_offset++;
@ -2606,7 +2603,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
{ /* get data element */
if (ElementCount != ElementNum)
{
bitvec_write_field(vector, &writeIndex, Tag, 1);
bitvec_write_field(vector, writeIndex, Tag, 1);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)Tag);
bit_offset++;
remaining_bits_len--;
@ -2633,7 +2630,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
}
}
bitvec_write_field(vector, &writeIndex, !Tag, 1);
bitvec_write_field(vector, writeIndex, !Tag, 1);
bit_offset++;
remaining_bits_len--;
Tag = STANDARD_TAG; /* in case it was set to "reversed" */
@ -2644,7 +2641,7 @@ gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector
case CSN_FIXED:
{ /* Verify the fixed bits */
guint8 no_of_bits = (guint8) pDescr->i;
bitvec_write_field(vector, &writeIndex, pDescr->offset, no_of_bits);
bitvec_write_field(vector, writeIndex, pDescr->offset, no_of_bits);
LOGPC(DCSN1, LOGL_NOTICE, "%s = %u | ", pDescr->sz , (unsigned)pDescr->offset);
remaining_bits_len -= no_of_bits;
bit_offset += no_of_bits;

11
src/csn1.h
View File

@ -28,12 +28,7 @@
#ifndef _PACKET_CSN1_H_
#define _PACKET_CSN1_H_
extern "C" {
#include <osmocom/core/bitvec.h>
}
#include <iostream>
#include <cstdlib>
#define MIN(a,b) (((a)<(b))?(a):(b))
//#define max(a,b) (((a)>(b))?(a):(b))
@ -88,7 +83,7 @@ typedef struct
gint direction; /* 0 - decode; 1 - encode */
} csnStream_t;
typedef gint16 (*StreamSerializeFcn_t)(csnStream_t* ar, bitvec *vector, unsigned& readIndex, void* data);
typedef gint16 (*StreamSerializeFcn_t)(csnStream_t* ar, struct bitvec *vector, unsigned *readIndex, void* data);
typedef enum
{
CSN_END = 0,
@ -233,9 +228,9 @@ void csnStreamInit(csnStream_t* ar,gint BitOffset,gint BitCount);
* RETURNS: int Number of bits left to be unpacked. Negative Error code if failed to unpack all bits
******************************************************************************/
gint16 csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsigned& readIndex, void* data);
gint16 csnStreamDecoder(csnStream_t* ar, const CSN_DESCR* pDescr, struct bitvec *vector, unsigned *readIndex, void* data);
gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, bitvec *vector, unsigned& readIndex, void* data);
gint16 csnStreamEncoder(csnStream_t* ar, const CSN_DESCR* pDescr, struct bitvec *vector, unsigned *writeIndex, void* data);
/* CSN struct macro's */
#define CSN_DESCR_BEGIN(_STRUCT)\

166
src/gsm_rlcmac.cpp
View File

@ -184,7 +184,7 @@ CSN_DESCR_BEGIN (EGPRS_AckNack_Desc_t)
CSN_DESCR_END (EGPRS_AckNack_Desc_t)
/*< EGPRS Ack/Nack Description IE >*/
gint16 Egprs_Ack_Nack_Desc_w_len_Dissector(csnStream_t* ar, bitvec *vector, unsigned& readIndex, void* data)
gint16 Egprs_Ack_Nack_Desc_w_len_Dissector(csnStream_t* ar, bitvec *vector, unsigned *readIndex, void* data)
{
if (ar->direction == 0)
{
@ -745,7 +745,7 @@ CSN_DESCR_BEGIN(Receive_N_PDU_Number_t)
M_UINT (Receive_N_PDU_Number_t, value, 8),
CSN_DESCR_END (Receive_N_PDU_Number_t)
gint16 Receive_N_PDU_Number_list_Dissector(csnStream_t* ar, bitvec *vector, unsigned& readIndex, void* data)
gint16 Receive_N_PDU_Number_list_Dissector(csnStream_t* ar, bitvec *vector, unsigned *readIndex, void* data)
{
if (ar->direction == 0)
{
@ -856,7 +856,7 @@ CSN_DESCR_BEGIN (Content_t)
M_UINT_OR_NULL (Content_t, PS_HandoverCapability, 1),
CSN_DESCR_END (Content_t)
gint16 Content_Dissector(csnStream_t* ar, bitvec *vector, unsigned& readIndex, void* data)
gint16 Content_Dissector(csnStream_t* ar, bitvec *vector, unsigned *readIndex, void* data)
{
if (ar->direction == 0)
{
@ -880,7 +880,7 @@ CSN_DESCR_BEGIN (Additional_access_technologies_t)
M_REC_TARRAY (Additional_access_technologies_t, Additional_access_technologies[0], Additional_access_technologies_struct_t, Count_additional_access_technologies),
CSN_DESCR_END (Additional_access_technologies_t)
gint16 Additional_access_technologies_Dissector(csnStream_t* ar, bitvec* vector, unsigned& readIndex, void* data)
gint16 Additional_access_technologies_Dissector(csnStream_t* ar, bitvec* vector, unsigned *readIndex, void* data)
{
if (ar->direction == 0)
{
@ -4999,73 +4999,73 @@ int decode_gsm_rlcmac_uplink(bitvec * vector, RlcMacUplink_t * data)
* CSNDESCR is an array that holds the different element types
* ar is the csn context holding the bitcount, offset and output
*/
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Failure_t), vector, readIndex, &data->u.Packet_Cell_Change_Failure);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Failure_t), vector, &readIndex, &data->u.Packet_Cell_Change_Failure);
break;
}
case MT_PACKET_CONTROL_ACK:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Control_Acknowledgement_t), vector, readIndex, &data->u.Packet_Control_Acknowledgement);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Control_Acknowledgement_t), vector, &readIndex, &data->u.Packet_Control_Acknowledgement);
break;
}
case MT_PACKET_DOWNLINK_ACK_NACK:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Downlink_Ack_Nack_t), vector, readIndex, &data->u.Packet_Downlink_Ack_Nack);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Downlink_Ack_Nack_t), vector, &readIndex, &data->u.Packet_Downlink_Ack_Nack);
break;
}
case MT_PACKET_UPLINK_DUMMY_CONTROL_BLOCK:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Uplink_Dummy_Control_Block_t), vector, readIndex, &data->u.Packet_Uplink_Dummy_Control_Block);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Uplink_Dummy_Control_Block_t), vector, &readIndex, &data->u.Packet_Uplink_Dummy_Control_Block);
break;
}
case MT_PACKET_MEASUREMENT_REPORT:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Measurement_Report_t), vector, readIndex, &data->u.Packet_Measurement_Report);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Measurement_Report_t), vector, &readIndex, &data->u.Packet_Measurement_Report);
break;
}
case MT_PACKET_RESOURCE_REQUEST:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Resource_Request_t), vector, readIndex, &data->u.Packet_Resource_Request);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Resource_Request_t), vector, &readIndex, &data->u.Packet_Resource_Request);
break;
}
case MT_PACKET_MOBILE_TBF_STATUS:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Mobile_TBF_Status_t), vector, readIndex, &data->u.Packet_Mobile_TBF_Status);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Mobile_TBF_Status_t), vector, &readIndex, &data->u.Packet_Mobile_TBF_Status);
break;
}
case MT_PACKET_PSI_STATUS:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PSI_Status_t), vector, readIndex, &data->u.Packet_PSI_Status);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PSI_Status_t), vector, &readIndex, &data->u.Packet_PSI_Status);
break;
}
case MT_EGPRS_PACKET_DOWNLINK_ACK_NACK:
{
ret = csnStreamDecoder(&ar, CSNDESCR(EGPRS_PD_AckNack_t), vector, readIndex, &data->u.Egprs_Packet_Downlink_Ack_Nack);
ret = csnStreamDecoder(&ar, CSNDESCR(EGPRS_PD_AckNack_t), vector, &readIndex, &data->u.Egprs_Packet_Downlink_Ack_Nack);
break;
}
case MT_PACKET_PAUSE:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Pause_t), vector, readIndex, &data->u.Packet_Pause);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Pause_t), vector, &readIndex, &data->u.Packet_Pause);
break;
}
case MT_PACKET_ENHANCED_MEASUREMENT_REPORT:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Enh_Measurement_Report_t), vector, readIndex, &data->u.Packet_Enh_Measurement_Report);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Enh_Measurement_Report_t), vector, &readIndex, &data->u.Packet_Enh_Measurement_Report);
break;
}
case MT_ADDITIONAL_MS_RAC:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Additional_MS_Rad_Access_Cap_t), vector, readIndex, &data->u.Additional_MS_Rad_Access_Cap);
ret = csnStreamDecoder(&ar, CSNDESCR(Additional_MS_Rad_Access_Cap_t), vector, &readIndex, &data->u.Additional_MS_Rad_Access_Cap);
break;
}
case MT_PACKET_CELL_CHANGE_NOTIFICATION:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Notification_t), vector, readIndex, &data->u.Packet_Cell_Change_Notification);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Notification_t), vector, &readIndex, &data->u.Packet_Cell_Change_Notification);
break;
}
case MT_PACKET_SI_STATUS:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_SI_Status_t), vector, readIndex, &data->u.Packet_SI_Status);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_SI_Status_t), vector, &readIndex, &data->u.Packet_SI_Status);
break;
}
default:
@ -5154,127 +5154,127 @@ int decode_gsm_rlcmac_downlink(bitvec * vector, RlcMacDownlink_t * data)
{
case MT_PACKET_ACCESS_REJECT:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Access_Reject_t), vector, readIndex, &data->u.Packet_Access_Reject);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Access_Reject_t), vector, &readIndex, &data->u.Packet_Access_Reject);
break;
}
case MT_PACKET_CELL_CHANGE_ORDER:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Order_t), vector, readIndex, &data->u.Packet_Cell_Change_Order);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Order_t), vector, &readIndex, &data->u.Packet_Cell_Change_Order);
break;
}
case MT_PACKET_CELL_CHANGE_CONTINUE:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Continue_t), vector, readIndex, &data->u.Packet_Cell_Change_Continue);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Cell_Change_Continue_t), vector, &readIndex, &data->u.Packet_Cell_Change_Continue);
break;
}
case MT_PACKET_DOWNLINK_ASSIGNMENT:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Downlink_Assignment_t), vector, readIndex, &data->u.Packet_Downlink_Assignment);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Downlink_Assignment_t), vector, &readIndex, &data->u.Packet_Downlink_Assignment);
break;
}
case MT_PACKET_MEASUREMENT_ORDER:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Measurement_Order_t), vector, readIndex, &data->u.Packet_Measurement_Order);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Measurement_Order_t), vector, &readIndex, &data->u.Packet_Measurement_Order);
break;
}
case MT_PACKET_NEIGHBOUR_CELL_DATA:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Neighbour_Cell_Data_t), vector, readIndex, &data->u.Packet_Neighbour_Cell_Data);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Neighbour_Cell_Data_t), vector, &readIndex, &data->u.Packet_Neighbour_Cell_Data);
break;
}
case MT_PACKET_SERVING_CELL_DATA:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Serving_Cell_Data_t), vector, readIndex, &data->u.Packet_Serving_Cell_Data);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Serving_Cell_Data_t), vector, &readIndex, &data->u.Packet_Serving_Cell_Data);
break;
}
case MT_PACKET_PAGING_REQUEST:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Paging_Request_t), vector, readIndex, &data->u.Packet_Paging_Request);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Paging_Request_t), vector, &readIndex, &data->u.Packet_Paging_Request);
break;
}
case MT_PACKET_PDCH_RELEASE:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PDCH_Release_t), vector, readIndex, &data->u.Packet_PDCH_Release);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PDCH_Release_t), vector, &readIndex, &data->u.Packet_PDCH_Release);
break;
}
case MT_PACKET_POLLING_REQ:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Polling_Request_t), vector, readIndex, &data->u.Packet_Polling_Request);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Polling_Request_t), vector, &readIndex, &data->u.Packet_Polling_Request);
break;
}
case MT_PACKET_POWER_CONTROL_TIMING_ADVANCE:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Power_Control_Timing_Advance_t), vector, readIndex, &data->u.Packet_Power_Control_Timing_Advance);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Power_Control_Timing_Advance_t), vector, &readIndex, &data->u.Packet_Power_Control_Timing_Advance);
break;
}
case MT_PACKET_PRACH_PARAMETERS:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PRACH_Parameters_t), vector, readIndex, &data->u.Packet_PRACH_Parameters);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PRACH_Parameters_t), vector, &readIndex, &data->u.Packet_PRACH_Parameters);
break;
}
case MT_PACKET_QUEUEING_NOTIFICATION:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Queueing_Notification_t), vector, readIndex, &data->u.Packet_Queueing_Notification);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Queueing_Notification_t), vector, &readIndex, &data->u.Packet_Queueing_Notification);
break;
}
case MT_PACKET_TIMESLOT_RECONFIGURE:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Timeslot_Reconfigure_t), vector, readIndex, &data->u.Packet_Timeslot_Reconfigure);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Timeslot_Reconfigure_t), vector, &readIndex, &data->u.Packet_Timeslot_Reconfigure);
break;
}
case MT_PACKET_TBF_RELEASE:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_TBF_Release_t), vector, readIndex, &data->u.Packet_TBF_Release);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_TBF_Release_t), vector, &readIndex, &data->u.Packet_TBF_Release);
break;
}
case MT_PACKET_UPLINK_ACK_NACK:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Uplink_Ack_Nack_t), vector, readIndex, &data->u.Packet_Uplink_Ack_Nack);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Uplink_Ack_Nack_t), vector, &readIndex, &data->u.Packet_Uplink_Ack_Nack);
break;
}
case MT_PACKET_UPLINK_ASSIGNMENT:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Uplink_Assignment_t), vector, readIndex, &data->u.Packet_Uplink_Assignment);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Uplink_Assignment_t), vector, &readIndex, &data->u.Packet_Uplink_Assignment);
break;
}
case MT_PACKET_HANDOVER_COMMAND:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Handover_Command_t), vector, readIndex, &data->u.Packet_Handover_Command);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Handover_Command_t), vector, &readIndex, &data->u.Packet_Handover_Command);
break;
}
case MT_PACKET_PHYSICAL_INFORMATION:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PhysicalInformation_t), vector, readIndex, &data->u.Packet_Handover_Command);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_PhysicalInformation_t), vector, &readIndex, &data->u.Packet_Handover_Command);
break;
}
case MT_PACKET_DOWNLINK_DUMMY_CONTROL_BLOCK:
{
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Downlink_Dummy_Control_Block_t), vector, readIndex, &data->u.Packet_Downlink_Dummy_Control_Block);
ret = csnStreamDecoder(&ar, CSNDESCR(Packet_Downlink_Dummy_Control_Block_t), vector, &readIndex, &data->u.Packet_Downlink_Dummy_Control_Block);
break;
}
case MT_PACKET_SYSTEM_INFO_1:
{
ret = csnStreamDecoder(&ar, CSNDESCR(PSI1_t), vector, readIndex, &data->u.PSI1);
ret = csnStreamDecoder(&ar, CSNDESCR(PSI1_t), vector, &readIndex, &data->u.PSI1);
break;
}
case MT_PACKET_SYSTEM_INFO_2:
{
ret = csnStreamDecoder(&ar, CSNDESCR(PSI2_t), vector, readIndex, &data->u.PSI2);
ret = csnStreamDecoder(&ar, CSNDESCR(PSI2_t), vector, &readIndex, &data->u.PSI2);
break;
}
case MT_PACKET_SYSTEM_INFO_3:
{
ret = csnStreamDecoder(&ar, CSNDESCR(PSI3_t), vector, readIndex, &data->u.PSI3);
ret = csnStreamDecoder(&ar, CSNDESCR(PSI3_t), vector, &readIndex, &data->u.PSI3);
break;
}
case MT_PACKET_SYSTEM_INFO_5:
{
ret = csnStreamDecoder(&ar, CSNDESCR(PSI5_t), vector, readIndex, &data->u.PSI5);
ret = csnStreamDecoder(&ar, CSNDESCR(PSI5_t), vector, &readIndex, &data->u.PSI5);
break;
}
case MT_PACKET_SYSTEM_INFO_13:
{
ret = csnStreamDecoder(&ar, CSNDESCR(PSI13_t), vector, readIndex, &data->u.PSI13);
ret = csnStreamDecoder(&ar, CSNDESCR(PSI13_t), vector, &readIndex, &data->u.PSI13);
break;
}
default:
@ -5316,73 +5316,73 @@ int encode_gsm_rlcmac_uplink(bitvec * vector, RlcMacUplink_t * data)
* CSNDESCR is an array that holds the different element types
* ar is the csn context holding the bitcount, offset and output
*/
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Failure_t), vector, writeIndex, &data->u.Packet_Cell_Change_Failure);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Failure_t), vector, &writeIndex, &data->u.Packet_Cell_Change_Failure);
break;
}
case MT_PACKET_CONTROL_ACK:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Control_Acknowledgement_t), vector, writeIndex, &data->u.Packet_Control_Acknowledgement);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Control_Acknowledgement_t), vector, &writeIndex, &data->u.Packet_Control_Acknowledgement);
break;
}
case MT_PACKET_DOWNLINK_ACK_NACK:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Downlink_Ack_Nack_t), vector, writeIndex, &data->u.Packet_Downlink_Ack_Nack);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Downlink_Ack_Nack_t), vector, &writeIndex, &data->u.Packet_Downlink_Ack_Nack);
break;
}
case MT_PACKET_UPLINK_DUMMY_CONTROL_BLOCK:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Uplink_Dummy_Control_Block_t), vector, writeIndex, &data->u.Packet_Uplink_Dummy_Control_Block);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Uplink_Dummy_Control_Block_t), vector, &writeIndex, &data->u.Packet_Uplink_Dummy_Control_Block);
break;
}
case MT_PACKET_MEASUREMENT_REPORT:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Measurement_Report_t), vector, writeIndex, &data->u.Packet_Measurement_Report);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Measurement_Report_t), vector, &writeIndex, &data->u.Packet_Measurement_Report);
break;
}
case MT_PACKET_RESOURCE_REQUEST:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Resource_Request_t), vector, writeIndex, &data->u.Packet_Resource_Request);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Resource_Request_t), vector, &writeIndex, &data->u.Packet_Resource_Request);
break;
}
case MT_PACKET_MOBILE_TBF_STATUS:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Mobile_TBF_Status_t), vector, writeIndex, &data->u.Packet_Mobile_TBF_Status);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Mobile_TBF_Status_t), vector, &writeIndex, &data->u.Packet_Mobile_TBF_Status);
break;
}
case MT_PACKET_PSI_STATUS:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PSI_Status_t), vector, writeIndex, &data->u.Packet_PSI_Status);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PSI_Status_t), vector, &writeIndex, &data->u.Packet_PSI_Status);
break;
}
case MT_EGPRS_PACKET_DOWNLINK_ACK_NACK:
{
ret = csnStreamEncoder(&ar, CSNDESCR(EGPRS_PD_AckNack_t), vector, writeIndex, &data->u.Egprs_Packet_Downlink_Ack_Nack);
ret = csnStreamEncoder(&ar, CSNDESCR(EGPRS_PD_AckNack_t), vector, &writeIndex, &data->u.Egprs_Packet_Downlink_Ack_Nack);
break;
}
case MT_PACKET_PAUSE:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Pause_t), vector, writeIndex, &data->u.Packet_Pause);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Pause_t), vector, &writeIndex, &data->u.Packet_Pause);
break;
}
case MT_PACKET_ENHANCED_MEASUREMENT_REPORT:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Enh_Measurement_Report_t), vector, writeIndex, &data->u.Packet_Enh_Measurement_Report);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Enh_Measurement_Report_t), vector, &writeIndex, &data->u.Packet_Enh_Measurement_Report);
break;
}
case MT_ADDITIONAL_MS_RAC:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Additional_MS_Rad_Access_Cap_t), vector, writeIndex, &data->u.Additional_MS_Rad_Access_Cap);
ret = csnStreamEncoder(&ar, CSNDESCR(Additional_MS_Rad_Access_Cap_t), vector, &writeIndex, &data->u.Additional_MS_Rad_Access_Cap);
break;
}
case MT_PACKET_CELL_CHANGE_NOTIFICATION:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Notification_t), vector, writeIndex, &data->u.Packet_Cell_Change_Notification);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Notification_t), vector, &writeIndex, &data->u.Packet_Cell_Change_Notification);
break;
}
case MT_PACKET_SI_STATUS:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_SI_Status_t), vector, writeIndex, &data->u.Packet_SI_Status);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_SI_Status_t), vector, &writeIndex, &data->u.Packet_SI_Status);
break;
}
default:
@ -5468,127 +5468,127 @@ int encode_gsm_rlcmac_downlink(bitvec * vector, RlcMacDownlink_t * data)
{
case MT_PACKET_ACCESS_REJECT:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Access_Reject_t), vector, writeIndex, &data->u.Packet_Access_Reject);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Access_Reject_t), vector, &writeIndex, &data->u.Packet_Access_Reject);
break;
}
case MT_PACKET_CELL_CHANGE_ORDER:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Order_t), vector, writeIndex, &data->u.Packet_Cell_Change_Order);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Order_t), vector, &writeIndex, &data->u.Packet_Cell_Change_Order);
break;
}
case MT_PACKET_CELL_CHANGE_CONTINUE:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Continue_t), vector, writeIndex, &data->u.Packet_Cell_Change_Continue);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Cell_Change_Continue_t), vector, &writeIndex, &data->u.Packet_Cell_Change_Continue);
break;
}
case MT_PACKET_DOWNLINK_ASSIGNMENT:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Downlink_Assignment_t), vector, writeIndex, &data->u.Packet_Downlink_Assignment);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Downlink_Assignment_t), vector, &writeIndex, &data->u.Packet_Downlink_Assignment);
break;
}
case MT_PACKET_MEASUREMENT_ORDER:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Measurement_Order_t), vector, writeIndex, &data->u.Packet_Measurement_Order);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Measurement_Order_t), vector, &writeIndex, &data->u.Packet_Measurement_Order);
break;
}
case MT_PACKET_NEIGHBOUR_CELL_DATA:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Neighbour_Cell_Data_t), vector, writeIndex, &data->u.Packet_Neighbour_Cell_Data);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Neighbour_Cell_Data_t), vector, &writeIndex, &data->u.Packet_Neighbour_Cell_Data);
break;
}
case MT_PACKET_SERVING_CELL_DATA:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Serving_Cell_Data_t), vector, writeIndex, &data->u.Packet_Serving_Cell_Data);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Serving_Cell_Data_t), vector, &writeIndex, &data->u.Packet_Serving_Cell_Data);
break;
}
case MT_PACKET_PAGING_REQUEST:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Paging_Request_t), vector, writeIndex, &data->u.Packet_Paging_Request);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Paging_Request_t), vector, &writeIndex, &data->u.Packet_Paging_Request);
break;
}
case MT_PACKET_PDCH_RELEASE:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PDCH_Release_t), vector, writeIndex, &data->u.Packet_PDCH_Release);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PDCH_Release_t), vector, &writeIndex, &data->u.Packet_PDCH_Release);
break;
}
case MT_PACKET_POLLING_REQ:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Polling_Request_t), vector, writeIndex, &data->u.Packet_Polling_Request);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Polling_Request_t), vector, &writeIndex, &data->u.Packet_Polling_Request);
break;
}
case MT_PACKET_POWER_CONTROL_TIMING_ADVANCE:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Power_Control_Timing_Advance_t), vector, writeIndex, &data->u.Packet_Power_Control_Timing_Advance);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Power_Control_Timing_Advance_t), vector, &writeIndex, &data->u.Packet_Power_Control_Timing_Advance);
break;
}
case MT_PACKET_PRACH_PARAMETERS:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PRACH_Parameters_t), vector, writeIndex, &data->u.Packet_PRACH_Parameters);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PRACH_Parameters_t), vector, &writeIndex, &data->u.Packet_PRACH_Parameters);
break;
}
case MT_PACKET_QUEUEING_NOTIFICATION:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Queueing_Notification_t), vector, writeIndex, &data->u.Packet_Queueing_Notification);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Queueing_Notification_t), vector, &writeIndex, &data->u.Packet_Queueing_Notification);
break;
}
case MT_PACKET_TIMESLOT_RECONFIGURE:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Timeslot_Reconfigure_t), vector, writeIndex, &data->u.Packet_Timeslot_Reconfigure);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Timeslot_Reconfigure_t), vector, &writeIndex, &data->u.Packet_Timeslot_Reconfigure);
break;
}
case MT_PACKET_TBF_RELEASE:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_TBF_Release_t), vector, writeIndex, &data->u.Packet_TBF_Release);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_TBF_Release_t), vector, &writeIndex, &data->u.Packet_TBF_Release);
break;
}
case MT_PACKET_UPLINK_ACK_NACK:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Uplink_Ack_Nack_t), vector, writeIndex, &data->u.Packet_Uplink_Ack_Nack);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Uplink_Ack_Nack_t), vector, &writeIndex, &data->u.Packet_Uplink_Ack_Nack);
break;
}
case MT_PACKET_UPLINK_ASSIGNMENT:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Uplink_Assignment_t), vector, writeIndex, &data->u.Packet_Uplink_Assignment);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Uplink_Assignment_t), vector, &writeIndex, &data->u.Packet_Uplink_Assignment);
break;
}
case MT_PACKET_HANDOVER_COMMAND:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Handover_Command_t), vector, writeIndex, &data->u.Packet_Handover_Command);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Handover_Command_t), vector, &writeIndex, &data->u.Packet_Handover_Command);
break;
}
case MT_PACKET_PHYSICAL_INFORMATION:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PhysicalInformation_t), vector, writeIndex, &data->u.Packet_Handover_Command);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_PhysicalInformation_t), vector, &writeIndex, &data->u.Packet_Handover_Command);
break;
}
case MT_PACKET_DOWNLINK_DUMMY_CONTROL_BLOCK:
{
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Downlink_Dummy_Control_Block_t), vector, writeIndex, &data->u.Packet_Downlink_Dummy_Control_Block);
ret = csnStreamEncoder(&ar, CSNDESCR(Packet_Downlink_Dummy_Control_Block_t), vector, &writeIndex, &data->u.Packet_Downlink_Dummy_Control_Block);
break;
}
case MT_PACKET_SYSTEM_INFO_1:
{
ret = csnStreamEncoder(&ar, CSNDESCR(PSI1_t), vector, writeIndex, &data->u.PSI1);
ret = csnStreamEncoder(&ar, CSNDESCR(PSI1_t), vector, &writeIndex, &data->u.PSI1);
break;
}
case MT_PACKET_SYSTEM_INFO_2:
{
ret = csnStreamEncoder(&ar, CSNDESCR(PSI2_t), vector, writeIndex, &data->u.PSI2);
ret = csnStreamEncoder(&ar, CSNDESCR(PSI2_t), vector, &writeIndex, &data->u.PSI2);
break;
}
case MT_PACKET_SYSTEM_INFO_3:
{
ret = csnStreamEncoder(&ar, CSNDESCR(PSI3_t), vector, writeIndex, &data->u.PSI3);
ret = csnStreamEncoder(&ar, CSNDESCR(PSI3_t), vector, &writeIndex, &data->u.PSI3);
break;
}
case MT_PACKET_SYSTEM_INFO_5:
{
ret = csnStreamEncoder(&ar, CSNDESCR(PSI5_t), vector, writeIndex, &data->u.PSI5);
ret = csnStreamEncoder(&ar, CSNDESCR(PSI5_t), vector, &writeIndex, &data->u.PSI5);
break;
}
case MT_PACKET_SYSTEM_INFO_13:
{
ret = csnStreamEncoder(&ar, CSNDESCR(PSI13_t), vector, writeIndex, &data->u.PSI13);
ret = csnStreamEncoder(&ar, CSNDESCR(PSI13_t), vector, &writeIndex, &data->u.PSI13);
break;
}
default:
@ -5754,7 +5754,7 @@ int decode_gsm_ra_cap(bitvec * vector, MS_Radio_Access_capability_t *data)
/* recursive csnStreamEncoder call uses LOGPC everywhere, so we need to start the log somewhere... */
LOGP(DCSN1, LOGL_INFO, "csnStreamEncoder (RAcap): ");
ret = csnStreamDecoder(&ar, CSNDESCR(MS_Radio_Access_capability_t), vector, readIndex, data);
ret = csnStreamDecoder(&ar, CSNDESCR(MS_Radio_Access_capability_t), vector, &readIndex, data);
/* recursive csnStreamDecoder call uses LOGPC everywhere without trailing
newline, so as a caller we are responisble for submitting it */

3
src/gsm_rlcmac.h
View File

@ -32,7 +32,10 @@
#ifndef __PACKET_GSM_RLCMAC_H__
#define __PACKET_GSM_RLCMAC_H__
extern "C" {
#include "csn1.h"
}
#include <iostream>
#include <cstdlib>

3
tests/rlcmac/RLCMACTest.cpp
View File

@ -24,7 +24,6 @@
#include <cstdlib>
#include <cstring>
#include <assert.h>
#include "csn1.h"
#include "gsm_rlcmac.h"
#include "gprs_rlcmac.h"
#include "decoding.h"
@ -37,6 +36,8 @@ extern const struct log_info gprs_log_info;
#include <osmocom/core/utils.h>
#include <osmocom/core/msgb.h>
#include <osmocom/core/application.h>
#include "csn1.h"
}
using namespace std;