maki/openairinterface5g
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
d8d8426bb37047a2e2ef972eee2fa23fce22e1de
openairinterface5g/openair2/RRC/CELLULAR/rrc_bch_per_basic.c
T
Lionel Gauthier 059a0a3fdc astyle --recursive --indent=spaces=2 --style=kr --indent-col1-comments --break-blocks --convert-tabs --max-code-length=200 
This is done for better merging branch/LG_PRE_RELEASE_0.3 into trunk (same process is applied on this branch)

git-svn-id: http://svn.eurecom.fr/openair4G/trunk@7073 818b1a75-f10b-46b9-bf7c-635c3b92a50f
2015-04-09 09:29:12 +00:00

494 lines
15 KiB
C
Executable File
Raw Blame History

/***************************************************************************
rrc_bch_per_basic.c - description
-------------------
copyright : (C) 2002, 2010 by Eurecom
email : Michelle.Wetterwald@eurecom.fr
**************************************************************************
Procedures to perform PER encoding/decoding of basic entities
Currently, following entities are supported:
- constrained integer
- bit string
- constrained unsigned integer
***************************************************************************/
/********************
//OpenAir definitions
********************/
#include "LAYER2/MAC/extern.h"
//#include "UTIL/MEM/mem_block.h"
#ifdef NODE_RG
#include "rrc_rg_vars_extern.h"
#endif
#ifdef NODE_MT
#include "rrc_ue_vars_extern.h"
#endif
/********************
// RRC definitions
********************/
//#include "rrc_constant.h"
//#include "rrc_bch_mib.h"
//-----------------------------------------------------------------------------
//#include "rrc_proto_int.h"
void rrc_print_buffer (char *buffer, int length);
//-----------------------------------------------------------------------------
void rrc_new_per_parms (PERParms * pParms, ENCODEDBLOCK * pBuffer)
{
//-----------------------------------------------------------------------------
pParms->buffer = pBuffer;
pParms->buff_index = 1; //start +1 = placeholder for buffer total length
pParms->buff_size = 1; // idem
pParms->bitoffset = 0;
pParms->errInfo = P_SUCCESS;
}
//-----------------------------------------------------------------------------
void rrc_set_per_length (PERParms * pParms)
{
//-----------------------------------------------------------------------------
char *pwrite;
pwrite = ((char *) pParms->buffer);
*pwrite = pParms->buff_size;
}
//-----------------------------------------------------------------------------
int rrc_get_per_length (ENCODEDBLOCK * pBlock)
{
//-----------------------------------------------------------------------------
u8 length;
length = *((char *) pBlock);
return length;
}
//-----------------------------------------------------------------------------
void rrc_print_per_parms (PERParms * pParms)
{
//-----------------------------------------------------------------------------
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] PER Control block values \t- index : %d\t- size : %d\t- error info : %d", pParms->buff_index, pParms->buff_size, pParms->errInfo);
rrc_print_buffer ((char *) pParms->buffer, pParms->buff_size);
#endif
}
//-----------------------------------------------------------------------------
int rrc_PEREnc_padding (PERParms * pParms, int length)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
char *pwrite;
int i;
pwrite = ((char *) pParms->buffer) + pParms->buff_index;
for (i = 0; i < length; i++) {
*pwrite = 0;
pwrite++;
}
pParms->buff_index += length;
pParms->buff_size += length;
return status;
}
/**************************************************************/
/* Constrained Integer */
/**************************************************************/
//-----------------------------------------------------------------------------
int rrc_PEREnc_ConstrInteger (PERParms * pParms, int pvalue, int lower, int upper)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
unsigned char *pwrite = NULL;
unsigned short int *pshort = NULL;
pwrite = ((unsigned char *) pParms->buffer) + pParms->buff_index;
if (pvalue >= lower && pvalue <= upper) {
if ((lower >= -128) && (upper <= 127)) {
// *pwrite = (unsigned char)pvalue;
*pwrite = (char) pvalue;
pParms->buff_index += 1;
pParms->buff_size += 1;
} else {
if ((lower >= -32768) && (upper <= 32767)) {
// pshort = (unsigned short int *)pwrite;
// *pshort = (unsigned short int)pvalue;
pshort = (unsigned short int *) pwrite;
*pshort = (short int) pvalue;
pParms->buff_index += 2;
pParms->buff_size += 2;
} else {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] Error, Value larger than 2 bytes, Code to be written : %d\n", pvalue);
#endif
status = P_MISCLERROR;
}
}
} else {
status = P_OUTOFBOUNDS;
}
return status;
}
//-----------------------------------------------------------------------------
int rrc_PERDec_ConstrInteger (PERParms * pParms, int *pvalue, int lower, int upper)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
// unsigned char * pRead;
// unsigned short int * pshort;
char *pRead = NULL;
short int *pshort = NULL;
char value_read_1 = 0;
short int value_read_2 = 0;
pRead = ((char *) pParms->buffer) + pParms->buff_index;
if ((lower >= -128) && (upper <= 127)) {
value_read_1 = *(pRead);
if (value_read_1 >= lower && value_read_1 <= upper) {
*pvalue = value_read_1;
pParms->buff_index += 1;
pParms->buff_size -= 1;
} else {
status = P_OUTOFBOUNDS;
}
} else {
if ((lower >= -32768) && (upper <= 32767)) {
pshort = (short int *) pRead;
// pshort = (unsigned short int *)pRead;
value_read_2 = *(pshort);
if (value_read_2 >= lower && value_read_2 <= upper) {
*pvalue = value_read_2;
pParms->buff_index += 2;
pParms->buff_size -= 2;
} else {
status = P_OUTOFBOUNDS;
}
} else {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] Error, Value>65535, Code to be written : %d\n", *pRead);
#endif
status = P_MISCLERROR;
}
#ifdef DEBUG_RRC_BROADCAST
// msg("[RRC_BCH] Value read : %d\n", *pvalue);
#endif
}
return status;
}
/**************************************************************/
/* Constrained Unsigned Integer */
/**************************************************************/
//-----------------------------------------------------------------------------
int rrc_PEREnc_ConsUnsigned (PERParms * pParms, unsigned int pvalue, unsigned int lower, unsigned int upper)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
unsigned char *pwrite;
unsigned short int *pshort;
pwrite = ((unsigned char *) pParms->buffer) + pParms->buff_index;
if (pvalue >= lower && pvalue <= upper) {
if (upper <= 255) {
*pwrite = (unsigned char) pvalue;
pParms->buff_index += 1;
pParms->buff_size += 1;
} else {
if (upper <= 65535) {
pshort = (unsigned short int *) pwrite;
*pshort = (unsigned short int) pvalue;
pParms->buff_index += 2;
pParms->buff_size += 2;
} else {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] Error, Value>65535, Code to be written : %d\n", pvalue);
#endif
status = P_MISCLERROR;
}
}
} else {
status = P_OUTOFBOUNDS;
}
return status;
}
//-----------------------------------------------------------------------------
int rrc_PERDec_ConsUnsigned (PERParms * pParms, unsigned int *pvalue, unsigned int lower, unsigned int upper)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
unsigned char *pRead;
unsigned short int *pshort;
unsigned char value_read_1 = 0;
short int value_read_2 = 0;
pRead = ((unsigned char *) pParms->buffer) + pParms->buff_index;
if (upper <= 255) {
value_read_1 = *(pRead);
if (value_read_1 >= lower && value_read_1 <= upper) {
*pvalue = value_read_1;
pParms->buff_index += 1;
pParms->buff_size -= 1;
} else {
status = P_OUTOFBOUNDS;
}
} else {
if (upper <= 65535) {
pshort = (unsigned short int *) pRead;
value_read_2 = *(pshort);
if (value_read_2 >= lower && value_read_2 <= upper) {
*pvalue = value_read_2;
pParms->buff_index += 2;
pParms->buff_size -= 2;
} else {
status = P_OUTOFBOUNDS;
}
} else {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] Error, Value>65535, Code to be written : %d\n", *pRead);
#endif
status = P_MISCLERROR;
}
}
return status;
}
/**************************************************************/
/* Bit String */
/**************************************************************/
// working on octets in 1st step - 3rd parameter not used , FFS
//-----------------------------------------------------------------------------
int rrc_PEREnc_BitString (PERParms * pParms, unsigned int numbits, unsigned char *data)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
unsigned int length;
int i;
char *pwrite;
char *psource;
if (numbits == 0) { //data buffer empty. Get encoded values from pParms
length = rrc_get_per_length (pParms->data);
pwrite = ((char *) pParms->buffer) + pParms->buff_index;
psource = (char *) pParms->data;
for (i = 0; i < length; i++) {
*pwrite = *psource;
pwrite++;
psource++;
}
pParms->buff_index += length;
pParms->buff_size += length;
} else {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] Error, numbits>0, Code to be written \n");
#endif
status = P_MISCLERROR;
pParms->errInfo = P_MISCLERROR;
}
return status;
}
//-----------------------------------------------------------------------------
int rrc_PERDec_BitString (PERParms * pParms, unsigned int *numbits_p, char *buffer, unsigned int bufsiz)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
return status;
}
/**************************************************************/
/* Octet string */
/**************************************************************/
//-----------------------------------------------------------------------------
int rrc_PEREnc_OctetString (PERParms * pParms, unsigned int numocts, char *data)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
char *pwrite;
pwrite = ((char *) pParms->buffer) + pParms->buff_index;
memcpy (pwrite, data, numocts);
pParms->buff_index += numocts;
pParms->buff_size += numocts;
return status;
}
//-----------------------------------------------------------------------------
int rrc_PERDec_OctetString (PERParms * pParms, unsigned int *numocts_p, char *data, unsigned int bufsize)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
//int i;
char *pwrite;
char *psource;
unsigned int numocts;
psource = ((char *) pParms->buffer) + pParms->buff_index;
pwrite = data;
numocts = *psource;
*numocts_p = bufsize;
memcpy (data, psource, bufsize);
pParms->buff_index += numocts + 1;
pParms->buff_size -= (numocts + 1);
return status;
}
/**************************************************************/
/* Var Octet String - same as string, but with length */
/**************************************************************/
//-----------------------------------------------------------------------------
int rrc_PEREnc_VarOctetString (PERParms * pParms, unsigned int numocts, unsigned char *data)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
char *pwrite;
pwrite = ((char *) pParms->buffer) + pParms->buff_index;
*pwrite = numocts;
pwrite += 1;
memcpy (pwrite, data, numocts);
pParms->buff_index += numocts + 1;
pParms->buff_size += numocts + 1;
return status;
}
//-----------------------------------------------------------------------------
int rrc_PERDec_VarOctetString (PERParms * pParms, unsigned int *numocts_p, unsigned char *data)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
char *psource;
unsigned int numocts;
u8 read_value;
psource = ((char *) pParms->buffer) + pParms->buff_index;
read_value = *psource;
numocts = (unsigned int)read_value;
// (u8) numocts = *((u8 *)psource);
*numocts_p = numocts;
psource += 1;
memcpy (data, psource, numocts);
pParms->buff_index += numocts + 1;
pParms->buff_size -= (numocts + 1);
return status;
}
/**************************************************************/
/* Digit */
/**************************************************************/
//-----------------------------------------------------------------------------
int rrc_PEREnc_Digit (PERParms * pParms, Digit value)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
// status = rrc_PEREnc_ConstrInteger (pParms, value, 0, 9);
char *pwrite;
if (value >= 0 && value <= 9) {
pwrite = ((char *) pParms->buffer) + pParms->buff_index;
*pwrite = (char) value;
pParms->buff_index += 1;
pParms->buff_size += 1;
} else {
status = P_INVDIGIT;
}
return (status);
}
//-----------------------------------------------------------------------------
int rrc_PERDec_Digit (PERParms * pParms, Digit * pvalue)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
//status = rrc_PERDec_ConstrInteger (pParms, pvalue, 0, 9);
char *pRead;
unsigned char value_read;
pRead = ((char *) pParms->buffer) + pParms->buff_index;
value_read = *(pRead);
// if (value_read>=0 && value_read<=9){
*pvalue = value_read;
pParms->buff_index += 1;
pParms->buff_size -= 1;
// }else{
// status = P_INVDIGIT;
// }
return (status);
}
/**************************************************************/
/* Length */
/**************************************************************/
//-----------------------------------------------------------------------------
int rrc_PEREnc_Length (PERParms * pParms, unsigned int value)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
char *pwrite;
if (value <= 255) {
pwrite = ((char *) pParms->buffer) + pParms->buff_index;
*pwrite = (char) value;
pParms->buff_index += 1;
pParms->buff_size += 1;
} else {
#ifdef DEBUG_RRC_BROADCAST
msg ("[RRC_BCH] Error, length>255, value : %d\n", value);
#endif
status = P_OUTOFBOUNDS;
}
return status;
}
//-----------------------------------------------------------------------------
int rrc_PERDec_Length (PERParms * pParms, unsigned int *pvalue)
{
//-----------------------------------------------------------------------------
int status = P_SUCCESS;
char *pRead;
pRead = ((char *) pParms->buffer) + pParms->buff_index;
*pvalue = *pRead;
pParms->buff_index += 1;
pParms->buff_size -= 1;
return status;
}
Reference in New Issue View Git Blame Copy Permalink