6768 lines
189 KiB
C++
6768 lines
189 KiB
C++
///////////////////////////////////////////////////////////////////////////////
|
|
// //
|
|
// Copyright Test Competence Center (TCC) ETH 2003 //
|
|
// //
|
|
// The copyright to the computer program(s) herein is the property of TCC. //
|
|
// The program(s) may be used and/or copied only with the written permission //
|
|
// of TCC or in accordance with the terms and conditions stipulated in the //
|
|
// agreement/contract under which the program(s) has been supplied. //
|
|
// //
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// File: ROHC_EncDec.cc
|
|
// Description: ROHC
|
|
// Rev: R3A01
|
|
// Prodnr: CNL 113 426
|
|
// Updated: 2007-02-07
|
|
// Contact: http://ttcn.ericsson.se
|
|
//
|
|
|
|
/* Based on RFC 3095, July 2001 */
|
|
|
|
#include "IP_Types.hh"
|
|
#include "UDP_Types.hh"
|
|
#include "RTP_Types.hh"
|
|
#include "ROHC_Types.hh"
|
|
|
|
/* ============ Constants ============ */
|
|
|
|
/* Encoding and decoding is performed using static buffers */
|
|
#define MAX_PACKET_SIZE 1500
|
|
#define HEXDUMP_BUFFER_SIZE 1500
|
|
|
|
/* ROHC mode constants */
|
|
#define ROHC_mode_C 0
|
|
#define ROHC_mode_U 1
|
|
#define ROHC_mode_O 2
|
|
#define ROHC_mode_R 3
|
|
|
|
/* Inner and outer IP level numbers */
|
|
#define Inner_IP 1
|
|
#define Outer_IP 0
|
|
|
|
/* ============ Utilities ============ */
|
|
|
|
#define isIR(val) (((val) & 0xFE) == 0xFC)
|
|
#define isIRDYN(val) ((val) == 0xF8)
|
|
#define isUOR2(val) (((val) & 0xE0) == 0xC0)
|
|
|
|
/* Shifts the passed bit value from the position 0 to position N. */
|
|
#define ShiftUpBit(val, position) ((val) << (position)) & (0x01 << (position))
|
|
|
|
/* Shifts the passed bit value from the position N to position 0. */
|
|
#define ShiftDownBit(val, position) (((val) >> (position)) & 0x01)
|
|
|
|
/* Logs an event, when the 'value' field in the type 'typename' is not
|
|
implemented. 'typename' must be provided in '"'s */
|
|
#define Log_not_implemented_union_field(typename, value) \
|
|
TTCN_error("Encoding of the selected union field (%u) in type " \
|
|
typename " is not implemented", (value));
|
|
|
|
/* Prints a hexdump of the buffer 'buf' in length 'length'. */
|
|
#define Log_hexdump(buf, length) \
|
|
TTCN_logger.log(TTCN_DEBUG, "Buffer (length = %d):\n%s", \
|
|
(length), debug_hexdump((buf), debug_buf, (length)));
|
|
|
|
/* Logs the name of the function on entering */
|
|
#define Log_function_name_on_enter() \
|
|
TTCN_logger.log(TTCN_DEBUG, "Entering %s", __FUNCTION__);
|
|
|
|
/* Logs the name of the function on leaving */
|
|
#define Log_function_name_on_leave() \
|
|
TTCN_logger.log(TTCN_DEBUG, "Leaving %s", __FUNCTION__);
|
|
|
|
/* Logs an object */
|
|
#define Log_object(o) \
|
|
TTCN_logger.begin_event(TTCN_DEBUG); \
|
|
(o).log(); \
|
|
TTCN_logger.end_event(); \
|
|
|
|
//**********************************************************
|
|
// NAMESPACE
|
|
//**********************************************************
|
|
|
|
namespace ROHC__Types {
|
|
|
|
using namespace General__Types;
|
|
using namespace IP__Types;
|
|
using namespace UDP__Types;
|
|
using namespace RTP__Types;
|
|
|
|
/* Umbrella type for parsing an incoming ROHC packet */
|
|
typedef struct
|
|
{
|
|
ROHC__context & context;
|
|
int cid;
|
|
int compressed_ah_data_len[2];
|
|
bool ipx_gre_cksum_present[2];
|
|
} t_dat;
|
|
|
|
/* TODO: this is not a thread-safe thing to do. For FT, it does not
|
|
matter, but the buffer should be allocated dynamically. */
|
|
static char debug_buf[HEXDUMP_BUFFER_SIZE];
|
|
|
|
static char *
|
|
debug_hexdump(const unsigned char *src_buf, char *dest_buf, unsigned int len)
|
|
{
|
|
unsigned int offset = 0;
|
|
char val;
|
|
|
|
memset(dest_buf, 0, HEXDUMP_BUFFER_SIZE);
|
|
|
|
if (src_buf == NULL || len == 0)
|
|
return dest_buf;
|
|
|
|
for (unsigned int i = 0; i < len; i++)
|
|
{
|
|
if ((i % 16) == 0 && i > 0)
|
|
{
|
|
dest_buf[offset] = 0x0A; /* newline after each line */
|
|
offset++;
|
|
}
|
|
if ((i % 8) == 0)
|
|
{
|
|
dest_buf[offset] = 0x20; /* space after 8 characters */
|
|
offset++;
|
|
}
|
|
val = (src_buf[i] >> 4) & 0x0F; /* First digit */
|
|
val = (val < 10) ? (val + 48) : (val + 65 - 10);
|
|
dest_buf[offset] = val;
|
|
offset++;
|
|
val = src_buf[i] & 0x0F; /* Second digit */
|
|
val = (val < 10) ? (val + 48) : (val + 65 - 10);
|
|
dest_buf[offset] += val;
|
|
offset++;
|
|
dest_buf[offset] = 0x20; /* space after the value */
|
|
offset++;
|
|
}
|
|
|
|
return dest_buf;
|
|
}
|
|
|
|
/* ============ Consistency check routines ============ */
|
|
void
|
|
Check_field_value(char *text, int urherenow, int wannabe)
|
|
{
|
|
if (wannabe != urherenow)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING, "Field '%s' must be %u, %u is given",
|
|
text, wannabe, urherenow);
|
|
}
|
|
}
|
|
|
|
void
|
|
Check_field_presence(char *text, bool flag, bool presence)
|
|
{
|
|
if (flag && !presence)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING, "Field '%s' must be present, when "
|
|
"its presence flag is set", text);
|
|
}
|
|
else if (!flag && presence)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING, "Field '%s' must not be present, when "
|
|
"its presence flag is unset", text);
|
|
}
|
|
}
|
|
|
|
void
|
|
Check_feedback_code__size(const INT3b & code, const OPTIONAL < LIN1 > &size)
|
|
{
|
|
if (size.ispresent() && code > 0)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"Code field must be 0, when size field is specified");
|
|
}
|
|
}
|
|
|
|
void
|
|
Check_feedback_optlen__optsize(const INT4b & len,
|
|
const OPTIONAL < OCTETSTRING > &data)
|
|
{
|
|
if (data.ispresent() && (data().lengthof() != len))
|
|
{
|
|
int flen = len;
|
|
int fdatalen = data().lengthof();
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"Feedback option length (%u) is different from "
|
|
"the length of feedback option data (%u)", flen, fdatalen);
|
|
}
|
|
else if (!data.ispresent() && len > 0)
|
|
{
|
|
int flen = len;
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"No feedback option data, but feedback option length "
|
|
"is not 0 (%u)", flen);
|
|
}
|
|
}
|
|
|
|
void
|
|
Check_ps_bit__xi_format(const BIT1 & psbit,
|
|
const OPTIONAL < XI__list > &xilist)
|
|
{
|
|
if (!xilist.ispresent())
|
|
return;
|
|
if (xilist().get_selection() == XI__list::ALT_xi__item8 && (*psbit) == 0)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING, "PS bit is 0, 4-bit indices must be used");
|
|
}
|
|
else if (xilist().get_selection() == XI__list::ALT_xi__item4 && (*psbit) == 1)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING, "PS bit is 1, 8-bit indices must be used");
|
|
}
|
|
}
|
|
|
|
INTEGER
|
|
ComputeCRC(const unsigned char *buf, int length, int crclen)
|
|
{
|
|
int crcval, poly, shiftmask;
|
|
|
|
Log_function_name_on_enter();
|
|
TTCN_logger.log(TTCN_DEBUG, "Calculating CRC-%d over:", crclen);
|
|
Log_hexdump(buf, length);
|
|
|
|
switch (crclen)
|
|
{
|
|
case 3:
|
|
poly = 0x06;
|
|
crcval = 0x07;
|
|
shiftmask = 0x03;
|
|
break;
|
|
|
|
case 7:
|
|
poly = 0x79;
|
|
crcval = 0x7F;
|
|
shiftmask = 0x3F;
|
|
break;
|
|
|
|
case 8:
|
|
poly = 0xE0;
|
|
crcval = 0xFF;
|
|
shiftmask = 0x7F;
|
|
break;
|
|
|
|
case 32:
|
|
poly = 0xEDB88320;
|
|
crcval = 0xFFFFFFFF;
|
|
shiftmask = 0x7FFFFFFF;
|
|
break;
|
|
|
|
default:
|
|
poly = 0;
|
|
TTCN_error("Unknown CRC length(%d)\n", crclen);
|
|
break;
|
|
}
|
|
|
|
if (poly == 0)
|
|
return 0;
|
|
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
for (int j = 0; j < 8; j++)
|
|
{
|
|
if ((crcval & 0x01) ^ (ShiftDownBit(buf[i], j)))
|
|
{
|
|
crcval = (crcval >> 1) & shiftmask;
|
|
crcval ^= poly;
|
|
}
|
|
else
|
|
{
|
|
crcval = (crcval >> 1) & shiftmask;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* CRC-32 in ROHC needs to be negated at the end */
|
|
if (crclen == 32)
|
|
{
|
|
crcval ^= 0xffffffff;
|
|
}
|
|
|
|
Log_function_name_on_leave();
|
|
|
|
unsigned int ui = (unsigned int)crcval;
|
|
char sbuf[16];
|
|
sprintf(sbuf, "%u", ui);
|
|
|
|
return INTEGER(sbuf);
|
|
}
|
|
|
|
/* ============ Encoding functions for base types ============ */
|
|
|
|
/** Returns the index of the innermost IP level, based on the number of
|
|
IP levels in the context. */
|
|
int
|
|
getInnermostIPidx(t_dat *dat)
|
|
{
|
|
// More than 1 levels: the innermost is always the index = 1
|
|
if (dat->context.ip__ctx().size_of() > 1)
|
|
return Inner_IP;
|
|
else
|
|
// The index is the one and only 0.
|
|
return Outer_IP;
|
|
}
|
|
|
|
/* Returns the index of the inner or outer IP level in the context, based on the
|
|
number of the IP levels in the context. If the return value is negative,
|
|
it indicates that the outer IP level does not exists. Negative value is
|
|
never returned, if the ip_level is the Inner IP level. */
|
|
int
|
|
getIPidx(t_dat *dat, int ip_level)
|
|
{
|
|
if (ip_level == Outer_IP)
|
|
{
|
|
if (dat->context.ip__ctx().size_of() > 1)
|
|
return Outer_IP;
|
|
else
|
|
return -1;
|
|
}
|
|
else if (ip_level == Inner_IP)
|
|
return getInnermostIPidx(dat);
|
|
else
|
|
return ip_level;
|
|
}
|
|
|
|
/** Initializes the context of the specified IP level. */
|
|
void
|
|
initIPcontext(t_dat *dat, int ip_level, int ip_version)
|
|
{
|
|
unsigned char ctemp = 0;
|
|
IP__context & field = dat->context.ip__ctx()[ip_level];
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
field.version() = INTEGER(ip_version);
|
|
if (! field.rnd__bit().is_bound()) field.rnd__bit() = BOOLEAN(ctemp);
|
|
if (! field.ah__present().is_bound()) field.ah__present() = BOOLEAN(ctemp);
|
|
if (! field.gre__present().is_bound()) field.gre__present() = BOOLEAN(ctemp);
|
|
if (! field.esp__present().is_bound()) field.esp__present() = BOOLEAN(ctemp);
|
|
if (! field.ah__data__len().is_bound())
|
|
field.ah__data__len() = INTEGER(ctemp);
|
|
if (! field.gre__cksum__present().is_bound())
|
|
field.gre__cksum__present() = BOOLEAN(ctemp);
|
|
|
|
Log_object(dat->context);
|
|
|
|
Log_function_name_on_leave();
|
|
}
|
|
|
|
/** Initializes the UDP context. */
|
|
void
|
|
initUDPcontext(t_dat *dat)
|
|
{
|
|
unsigned char ctemp = 1;
|
|
UDP__context & field = dat->context.udp__ctx();
|
|
|
|
if (! field.udp__cksum().is_bound()) field.udp__cksum() = BOOLEAN(ctemp);
|
|
}
|
|
|
|
/** Initializes the specified CID's context. */
|
|
void
|
|
initCIDcontext(t_dat *dat)
|
|
{
|
|
unsigned char ctemp = 0;
|
|
ROHC__context & field = dat->context;
|
|
|
|
if (! field.mode().is_bound()) field.mode() = INTEGER(cg__ROHC__mode__U);
|
|
if (! field.profile().is_bound()) field.profile() = INTEGER(ctemp);
|
|
if (! field.pkt().is_bound()) field.pkt() = Packet__type(Packet__type::IR);
|
|
if (! field.ip__ctx().is_bound()) initIPcontext(dat, 0, 4);
|
|
initUDPcontext(dat);
|
|
}
|
|
|
|
/** Initializes the umbrella type before the ROHC packet parsing starts. */
|
|
t_dat
|
|
initTDAT(ROHC__config & config, int cid)
|
|
{
|
|
t_dat dat = { config.context()[cid], cid, {0, 0}, {false, false} };
|
|
|
|
// Expect AH auth data and GRE checksum after the compressed header
|
|
// by default. If the uncompressed form is used, these values will be
|
|
// set to 0 or false during parsing.
|
|
dat.compressed_ah_data_len[0] =
|
|
config.context()[cid].ip__ctx()[0].ah__data__len();
|
|
dat.ipx_gre_cksum_present[0] =
|
|
config.context()[cid].ip__ctx()[0].gre__cksum__present();
|
|
if (config.context()[cid].ip__ctx().size_of() > 1)
|
|
{
|
|
dat.compressed_ah_data_len[1] =
|
|
config.context()[cid].ip__ctx()[1].ah__data__len();
|
|
dat.ipx_gre_cksum_present[1] =
|
|
config.context()[cid].ip__ctx()[1].gre__cksum__present();
|
|
}
|
|
return dat;
|
|
}
|
|
|
|
/** Returns, whether there is any compressed IPv4 level,
|
|
where the RND bit is 0. */
|
|
bool
|
|
isAnyIPv4RNDunset(t_dat *dat)
|
|
{
|
|
for (int i = 0; i < 2; i++)
|
|
{
|
|
int ip_idx = getIPidx(dat, i);
|
|
|
|
if (ip_idx >= 0) // IP level exists
|
|
{
|
|
if (! dat->context.ip__ctx()[ip_idx].rnd__bit())
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/* Encodes an OCTETSTING value */
|
|
int
|
|
Set_octetstring(unsigned char *buf, const OCTETSTRING & val)
|
|
{
|
|
memcpy(&(buf[0]), val, val.lengthof());
|
|
return val.lengthof();
|
|
}
|
|
|
|
/* Encodes a LIN2_BO_LAST value */
|
|
int
|
|
Set_LIN2_BO_LAST(unsigned char *buf, const LIN2__BO__LAST & val)
|
|
{
|
|
buf[0] = (val >> 8) & 0xFF;
|
|
buf[1] = val & 0xFF;
|
|
return 2;
|
|
}
|
|
|
|
/* Encodes a LIN4_BO_LAST value */
|
|
int
|
|
Set_LIN4_BO_LAST(unsigned char *buf, const LIN4__BO__LAST & val)
|
|
{
|
|
buf[0] = (val >> 24) & 0xFF;
|
|
buf[1] = (val >> 16) & 0xFF;
|
|
buf[2] = (val >> 8) & 0xFF;
|
|
buf[3] = val & 0xFF;
|
|
return 4;
|
|
}
|
|
|
|
/* Encodes a LIN1 value */
|
|
int
|
|
Set_LIN1(unsigned char *buf, const LIN1 & val)
|
|
{
|
|
buf[0] = val & 0xFF;
|
|
return 1;
|
|
}
|
|
|
|
/* Returns the length of the SDVL encoded CID value 'val'. If the value
|
|
is invalid, exits via the ttcn_error(). */
|
|
int
|
|
SDVL_encoded_CID_length(int val)
|
|
{
|
|
if (val <= 0x7F)
|
|
return 1;
|
|
else if (val <= 0x3FFF)
|
|
return 2;
|
|
else if (val <= 0x1FFFFF)
|
|
return 3;
|
|
else if (val <= 0x1FFFFFFF)
|
|
return 4;
|
|
else
|
|
TTCN_error("Value %u is too big for the SDVL encoder "
|
|
"(at most 29 bits can be used)", val);
|
|
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
Set_SDVL_field(unsigned char *buf, const INTEGER & val, int encoded_length)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if ((val <= 0x7F && encoded_length == 0) || encoded_length == 1)
|
|
{
|
|
buf[len] = val & 0x7F;
|
|
len += 1;
|
|
}
|
|
else if ((val <= 0x3FFF && encoded_length == 0) || encoded_length == 2)
|
|
{
|
|
buf[len] = 0x80 | ((val >> 8) & 0x7F);
|
|
len += 1;
|
|
buf[len] = val & 0xFF;
|
|
len += 1;
|
|
}
|
|
else if ((val <= 0x1FFFFF && encoded_length == 0) || encoded_length == 3)
|
|
{
|
|
buf[len] = 0xC0 | ((val >> 16) & 0x3F);
|
|
len += 1;
|
|
buf[len] = (val >> 8) & 0xFF;
|
|
len += 1;
|
|
buf[len] = val & 0xFF;
|
|
len += 1;
|
|
}
|
|
else if ((val <= 0x1FFFFFFF && encoded_length == 0) || encoded_length == 4)
|
|
{
|
|
buf[len] = 0xE0 | ((val >> 24) & 0x1F);
|
|
len += 1;
|
|
buf[len] = (val >> 16) & 0xFF;
|
|
len += 1;
|
|
buf[len] = (val >> 8) & 0xFF;
|
|
len += 1;
|
|
buf[len] = val & 0xFF;
|
|
len += 1;
|
|
}
|
|
else
|
|
{
|
|
int tmp = val;
|
|
TTCN_error("Value %u (specified length is %u) is too big for the "
|
|
"SDVL encoder (at most 29 bits can be used)",
|
|
tmp, encoded_length);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* ============ Encoding wrappers for optional base types ============ */
|
|
|
|
/* Encodes an optional OCTETSTING value */
|
|
int
|
|
Set_octetstring_opt(unsigned char *buf, const OPTIONAL < OCTETSTRING > &val)
|
|
{
|
|
if (!val.ispresent())
|
|
return 0;
|
|
return Set_octetstring(buf, val());
|
|
}
|
|
|
|
/* Encodes an optional LIN2_BO_LAST value */
|
|
int
|
|
Set_LIN2_BO_LAST_opt(unsigned char *buf,
|
|
const OPTIONAL < LIN2__BO__LAST > &val)
|
|
{
|
|
if (!val.ispresent())
|
|
return 0;
|
|
return Set_LIN2_BO_LAST(buf, val());
|
|
}
|
|
|
|
/* Encodes an optional LIN4_BO_LAST value */
|
|
int
|
|
Set_LIN4_BO_LAST_opt(unsigned char *buf,
|
|
const OPTIONAL < LIN4__BO__LAST > &val)
|
|
{
|
|
if (!val.ispresent())
|
|
return 0;
|
|
return Set_LIN4_BO_LAST(buf, val());
|
|
}
|
|
|
|
/* Encodes an optional LIN1 value */
|
|
int
|
|
Set_LIN1_opt(unsigned char *buf, const OPTIONAL < LIN1 > &val)
|
|
{
|
|
if (!val.ispresent())
|
|
return 0;
|
|
return Set_LIN1(buf, val());
|
|
}
|
|
|
|
int
|
|
Set_SDVL_field_opt(unsigned char *buf,
|
|
const OPTIONAL < INTEGER > &val, int length)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!val.ispresent())
|
|
return 0;
|
|
len += Set_SDVL_field(buf, val(), length);
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
|
|
/* ============ Encoding functions for common ROHC types ============ */
|
|
|
|
int
|
|
Set_CID(unsigned char *buf, const INTEGER & cid, BOOLEAN const &large_cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (large_cid == false)
|
|
{
|
|
if (cid > 0)
|
|
{
|
|
buf[len] = 0xE0 + (cid & 0x0F);
|
|
len += 1;
|
|
}
|
|
}
|
|
else
|
|
len += Set_SDVL_field(&buf[len], cid, 0);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* CSRC and IP extension header item list encoding */
|
|
int
|
|
Set_Item_list_opt(unsigned char *buf, const OPTIONAL < Item__list > &item_list)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!item_list.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
|
|
/* Item list is an IP extension header list */
|
|
if (item_list().get_selection() == Item__list::ALT_ip__item__list)
|
|
{
|
|
IP__Item__list ip_item_list = item_list().ip__item__list();
|
|
|
|
for (int num = 0; num < ip_item_list.size_of(); num++)
|
|
{
|
|
int start_pos = len;
|
|
|
|
switch (ip_item_list[num].get_selection())
|
|
{
|
|
case Item::ALT_ipv6__ext__item:
|
|
{
|
|
IPv6__ext__item & item = ip_item_list[num].ipv6__ext__item();
|
|
|
|
len += Set_LIN1(&buf[len], item.nexthead());
|
|
/* Length of the header in 8-octet units, not including
|
|
the first 8 octets. */
|
|
if (item.hdr__ext__len() == 0)
|
|
{
|
|
if ((item.data().lengthof() + 2) % 8 != 0)
|
|
{
|
|
TTCN_error("Invalid length (%u) of the IPv6 extension header",
|
|
item.data().lengthof());
|
|
}
|
|
buf[len] = (item.data().lengthof() + 2) / 8 - 1;
|
|
len += 1;
|
|
}
|
|
else
|
|
len += Set_LIN1(&buf[len], item.hdr__ext__len());
|
|
len += Set_octetstring(&buf[len], item.data());
|
|
break;
|
|
}
|
|
case Item::ALT_mine__item:
|
|
{
|
|
MINE__item & item = ip_item_list[num].mine__item();
|
|
|
|
Check_field_value("MINE protocol", item.protocol(), c__ip__proto__mine);
|
|
Check_field_value("MINE reserved", *item.reserved(), 0);
|
|
|
|
len += Set_LIN1(&buf[len], item.protocol());
|
|
buf[len] = (*item.s__bit()) << 7;
|
|
buf[len] += *item.reserved();
|
|
len += 1;
|
|
len += Set_LIN2_BO_LAST(&buf[len], item.cksum());
|
|
len += Set_octetstring(&buf[len], item.dstaddr());
|
|
len += Set_octetstring_opt(&buf[len], item.srcaddr());
|
|
break;
|
|
}
|
|
case Item::ALT_ah__item:
|
|
{
|
|
AH__item & item = ip_item_list[num].ah__item();
|
|
|
|
Check_field_value("AH nexthead", item.nexthead(), c__ip__proto__ah);
|
|
len += Set_LIN1(&buf[len], item.nexthead());
|
|
|
|
/* RFC 2402: This 8-bit field specifies the length of AH in
|
|
32-bit words (4-byte units), minus "2". */
|
|
if (item.payload__len() == 0)
|
|
{
|
|
if (item.auth__data().ispresent())
|
|
buf[len] = (item.auth__data()().lengthof() / 4) + 3 - 2;
|
|
else
|
|
buf[len] = 1;
|
|
len += 1;
|
|
}
|
|
else
|
|
len += Set_LIN1(&buf[len], item.payload__len());
|
|
|
|
Check_field_value("AH reserved", item.reserved(), 0);
|
|
len += Set_LIN2_BO_LAST(&buf[len], item.reserved());
|
|
len += Set_LIN4_BO_LAST(&buf[len], item.spi());
|
|
len += Set_LIN4_BO_LAST(&buf[len], item.sn());
|
|
len += Set_octetstring_opt(&buf[len], item.auth__data());
|
|
break;
|
|
}
|
|
case Item::ALT_esp__item:
|
|
{
|
|
ESP__item & item = ip_item_list[num].esp__item();
|
|
|
|
Check_field_value("ESP nexthead", item.nexthead(), c__ip__proto__esp);
|
|
len += Set_LIN1(&buf[len], item.nexthead());
|
|
len += Set_LIN4_BO_LAST(&buf[len], item.spi());
|
|
len += Set_LIN4_BO_LAST(&buf[len], item.sn());
|
|
break;
|
|
}
|
|
case Item::ALT_gre__item:
|
|
{
|
|
GRE__item & item = ip_item_list[num].gre__item();
|
|
|
|
Check_field_value("GRE nexthead", item.nexthead(), c__ip__proto__gre2);
|
|
len += Set_LIN1(&buf[len], item.nexthead());
|
|
buf[len] = (*item.C__bit()) << 7;
|
|
Check_field_value("GRE reserved1", (int) *item.reserved__1(), 0);
|
|
buf[len] += (*item.reserved__1()) << 6;
|
|
buf[len] += (*item.K__bit()) << 5;
|
|
buf[len] += (*item.S__bit()) << 4;
|
|
Check_field_value("GRE reserved2", (int) *item.reserved__2(), 0);
|
|
buf[len] += (*item.reserved__2()) << 3;
|
|
buf[len] += *item.version();
|
|
len += 1;
|
|
Check_field_presence("checksum", *item.C__bit() == 1,
|
|
item.cksum().ispresent());
|
|
Check_field_presence("key", *item.K__bit() == 1,
|
|
item.key().ispresent());
|
|
Check_field_presence("sn", *item.S__bit() == 1,
|
|
item.sn().ispresent());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], item.cksum());
|
|
len += Set_LIN4_BO_LAST_opt(&buf[len], item.key());
|
|
len += Set_LIN4_BO_LAST_opt(&buf[len], item.sn());
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
Log_not_implemented_union_field("Item",
|
|
ip_item_list[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
TTCN_logger.log(TTCN_DEBUG, "%uth item:", num);
|
|
Log_hexdump(&(buf[start_pos]), len - start_pos);
|
|
}
|
|
}
|
|
else if (item_list().get_selection() == Item__list::ALT_csrc__item__list)
|
|
{
|
|
/* Item list is CSRC item list */
|
|
for (int num = 0; num < item_list().csrc__item__list().size_of(); num++)
|
|
{
|
|
int start_pos = len;
|
|
|
|
len += Set_octetstring( &buf[len],
|
|
item_list().csrc__item__list()[num] );
|
|
TTCN_logger.log(TTCN_DEBUG, "%uth item:", num);
|
|
Log_hexdump(&(buf[start_pos]), len - start_pos);
|
|
}
|
|
}
|
|
else if (item_list().get_selection() == Item__list::ALT_raw__data)
|
|
{
|
|
/* Item list is a raw octetstring */
|
|
for (int num = 0; num < item_list().csrc__item__list().size_of(); num++)
|
|
{
|
|
int start_pos = len;
|
|
|
|
len += Set_octetstring(&buf[len], item_list().raw__data()[num] );
|
|
TTCN_logger.log(TTCN_DEBUG, "%uth item:", num);
|
|
Log_hexdump(&(buf[start_pos]), len - start_pos);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log_not_implemented_union_field("Item_list", item_list().get_selection());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_XI_list_opt(unsigned char *buf, const OPTIONAL < XI__list > &xilist,
|
|
const OPTIONAL < BITSTRING > &padding, int length)
|
|
{
|
|
int len = 0;
|
|
int halfbyte = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!xilist.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
|
|
switch (xilist().get_selection())
|
|
{
|
|
case XI__list::ALT_xi__item4:
|
|
{
|
|
if (length != xilist().xi__item4().size_of())
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"Number of indices != value of CC field");
|
|
for (int num = 0; num < xilist().xi__item4().size_of(); num++)
|
|
{
|
|
if (halfbyte)
|
|
{
|
|
buf[len] += ((*xilist().xi__item4()[num].x__ind()) << 3) & 0x08;
|
|
buf[len] += xilist().xi__item4()[num].index() & 0x07;
|
|
len += 1;
|
|
}
|
|
else
|
|
{
|
|
buf[len] = ((*xilist().xi__item4()[num].x__ind()) << 7) & 0x80;
|
|
buf[len] += (xilist().xi__item4()[num].index() << 4) & 0x70;
|
|
}
|
|
halfbyte = 1 - halfbyte; // Invert the value (0 -> 1 or 1 -> 0)
|
|
}
|
|
break;
|
|
}
|
|
|
|
case XI__list::ALT_xi__item8:
|
|
{
|
|
if (length != xilist().xi__item8().size_of())
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"Number of indices != value of CC field");
|
|
for (int num = 0; num < xilist().xi__item8().size_of(); num++)
|
|
{
|
|
buf[len] = ((*xilist().xi__item8()[num].x__ind()) << 7) & 0x80;
|
|
buf[len] += xilist().xi__item8()[num].index() & 0x7F;
|
|
len += 1;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Log_not_implemented_union_field("XI_list", xilist().get_selection());
|
|
break;
|
|
}
|
|
|
|
if (padding.ispresent() && halfbyte == 0)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING, "Specified padding is ignored");
|
|
}
|
|
else if (!padding.ispresent() && halfbyte)
|
|
{
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"Padding not specified, padding bits left uninitialized");
|
|
}
|
|
else if (padding.ispresent())
|
|
{
|
|
Check_field_value("Index padding", *padding(), 0);
|
|
buf[len] += (*padding()) & 0x0F;
|
|
len += 1;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Encoding_Type_0(unsigned char *buf, const Enc__Type__0 & enct0)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_presence("gen_id", *enct0.gp__bit() == 1,
|
|
enct0.gen__id().ispresent());
|
|
|
|
Check_field_value("Encoding type", *enct0.et(), 0);
|
|
buf[len] = ((*enct0.et()) << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*enct0.gp__bit(), 5);
|
|
buf[len] += ShiftUpBit(*enct0.ps__bit(), 4);
|
|
buf[len] += enct0.cc() & 0x0F;
|
|
len += 1;
|
|
len += Set_LIN1_opt(&buf[len], enct0.gen__id());
|
|
Check_ps_bit__xi_format(enct0.ps__bit(), enct0.xi__list());
|
|
len += Set_XI_list_opt(&buf[len], enct0.xi__list(), enct0.padding(),
|
|
enct0.cc());
|
|
len += Set_Item_list_opt(&buf[len], enct0.item__list());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int
|
|
Set_Encoding_Type_1(unsigned char *buf, const Enc__Type__1 & enct1)
|
|
{
|
|
int len = 0;
|
|
int n = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_presence("gen_id", *enct1.gp__bit() == 1,
|
|
enct1.gen__id().ispresent());
|
|
|
|
Check_field_value("Encoding type", *enct1.et(), 1);
|
|
buf[len] = ((*enct1.et()) << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*enct1.gp__bit(), 5);
|
|
buf[len] += ShiftUpBit(*enct1.ps__bit(), 4);
|
|
buf[len] += enct1.xi1() & 0x0F;
|
|
len += 1;
|
|
len += Set_LIN1_opt(&buf[len], enct1.gen__id());
|
|
len += Set_LIN1_opt(&buf[len], enct1.ref__id());
|
|
len += Set_octetstring(&buf[len], enct1.insbitmask());
|
|
|
|
// Count the number of 1's in the bitmask
|
|
for (int i = 0; i < enct1.insbitmask().lengthof(); ++i)
|
|
{
|
|
if (enct1.insbitmask() & int2oct(i + 1, enct1.insbitmask().lengthof()))
|
|
++n;
|
|
}
|
|
|
|
Check_ps_bit__xi_format(enct1.ps__bit(), enct1.xi__list());
|
|
len += Set_XI_list_opt(&buf[len], enct1.xi__list(), enct1.padding(), n);
|
|
len += Set_Item_list_opt(&buf[len], enct1.item__list());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int
|
|
Set_Encoding_Type_2(unsigned char *buf, const Enc__Type__2 & enct2)
|
|
{
|
|
int len = 0;
|
|
|
|
Check_field_presence("gen_id", *enct2.gp__bit() == 1,
|
|
enct2.gen__id().ispresent());
|
|
|
|
Check_field_value("Encoding type", *enct2.et(), 2);
|
|
buf[len] = ((*enct2.et()) << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*enct2.gp__bit(), 5);
|
|
buf[len] += ShiftUpBit(*enct2.res(), 4);
|
|
buf[len] += enct2.count() & 0x0F;
|
|
len += 1;
|
|
len += Set_LIN1_opt(&buf[len], enct2.gen__id());
|
|
len += Set_LIN1_opt(&buf[len], enct2.ref__id());
|
|
len += Set_octetstring(&buf[len], enct2.rembitmask());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int
|
|
Set_Encoding_Type_3(unsigned char *buf, const Enc__Type__3 & enct3)
|
|
{
|
|
int len = 0;
|
|
int n = 0;
|
|
|
|
Check_field_presence("gen_id", *enct3.gp__bit() == 1,
|
|
enct3.gen__id().ispresent());
|
|
|
|
Check_field_value("Encoding type", *enct3.et(), 3);
|
|
buf[len] = ((*enct3.et()) << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*enct3.gp__bit(), 5);
|
|
buf[len] += ShiftUpBit(*enct3.ps__bit(), 4);
|
|
buf[len] += enct3.xi1() & 0x0F;
|
|
len += 1;
|
|
len += Set_LIN1_opt(&buf[len], enct3.gen__id());
|
|
len += Set_LIN1_opt(&buf[len], enct3.ref__id());
|
|
len += Set_octetstring(&buf[len], enct3.rembitmask());
|
|
len += Set_octetstring(&buf[len], enct3.insbitmask());
|
|
|
|
// Count the number of 1's in the bitmask
|
|
for (int i = 0; i < enct3.insbitmask().lengthof(); ++i)
|
|
{
|
|
if (enct3.insbitmask() & int2oct(i + 1, enct3.insbitmask().lengthof()))
|
|
++n;
|
|
}
|
|
Check_ps_bit__xi_format(enct3.ps__bit(), enct3.xi__list());
|
|
len += Set_XI_list_opt(&buf[len], enct3.xi__list(), enct3.padding(), n);
|
|
len += Set_Item_list_opt(&buf[len], enct3.item__list());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Compr_head_list_opt(unsigned char *buf,
|
|
const OPTIONAL < Compr__head__list > &chl)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!chl.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
if (chl().get_selection() == Compr__head__list::ALT_enctype0)
|
|
len += Set_Encoding_Type_0(&buf[len], chl().enctype0());
|
|
else if (chl().get_selection() == Compr__head__list::ALT_enctype1)
|
|
len += Set_Encoding_Type_1(&buf[len], chl().enctype1());
|
|
else if (chl().get_selection() == Compr__head__list::ALT_enctype2)
|
|
len += Set_Encoding_Type_2(&buf[len], chl().enctype2());
|
|
else if (chl().get_selection() == Compr__head__list::ALT_enctype3)
|
|
len += Set_Encoding_Type_3(&buf[len], chl().enctype3());
|
|
else
|
|
{
|
|
Log_not_implemented_union_field("Compr_head_list", chl().get_selection());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_AEGSeqnum_opt(unsigned char *buf, const OPTIONAL < AEGSeqnum > &oseqn)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!oseqn.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
if (oseqn().get_selection() == AEGSeqnum::ALT_short__form)
|
|
{
|
|
Check_field_value("form-bit", (int) *oseqn().short__form().ind(), 0);
|
|
buf[len] = ShiftUpBit(*oseqn().short__form().ind(), 7);
|
|
buf[len] += oseqn().short__form().lsb__of__seqnum() & 0x7F;
|
|
len += 1;
|
|
}
|
|
else if (oseqn().get_selection() == AEGSeqnum::ALT_long__form)
|
|
{
|
|
Check_field_value("form-bit", (int) *oseqn().long__form().ind(), 1);
|
|
buf[len] = ShiftUpBit(*oseqn().long__form().ind(), 7);
|
|
buf[len] += (oseqn().long__form().lsb__of__seqnum() >> 24) & 0x7F;
|
|
len += 1;
|
|
|
|
buf[len] = (oseqn().long__form().lsb__of__seqnum() >> 16) & 0xFF;
|
|
len += 1;
|
|
|
|
buf[len] = (oseqn().long__form().lsb__of__seqnum() >> 8) & 0xFF;
|
|
len += 1;
|
|
|
|
buf[len] = oseqn().long__form().lsb__of__seqnum() & 0xFF;
|
|
len += 1;
|
|
}
|
|
else
|
|
Log_not_implemented_union_field("AEGSeqnum", oseqn().get_selection());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_IPv4_static_chain(unsigned char *buf, const IPv4__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("IPv4 version", chain.version(), 4);
|
|
buf[len] = (chain.version() << 4) & 0xF0;
|
|
Check_field_value("IPv4 reserved (static chain)", chain.reserved(), 0);
|
|
buf[len] += chain.reserved() & 0x0F;
|
|
len += 1;
|
|
len += Set_LIN1(&buf[len], chain.proto());
|
|
len += Set_octetstring(&buf[len], chain.srcaddr());
|
|
len += Set_octetstring(&buf[len], chain.dstaddr());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_IPv6_static_chain(unsigned char *buf, const IPv6__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("IPv6 version", chain.version(), 6);
|
|
buf[len] = (chain.version() << 4) & 0xF0;
|
|
buf[len] += (chain.flowlabel() >> 16) & 0x0F;
|
|
len += 1;
|
|
|
|
buf[len] = (chain.flowlabel() >> 8) & 0xFF;
|
|
len += 1;
|
|
buf[len] = chain.flowlabel() & 0xFF;
|
|
len += 1;
|
|
|
|
len += Set_LIN1(&buf[len], chain.nexthead());
|
|
len += Set_octetstring(&buf[len], chain.srcaddr());
|
|
len += Set_octetstring(&buf[len], chain.dstaddr());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_UDP_static_chain(unsigned char *buf, const UDP__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN2_BO_LAST(&buf[len], chain.srcport());
|
|
len += Set_LIN2_BO_LAST(&buf[len], chain.dstport());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_RTP_static_chain(unsigned char *buf, const RTP__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_octetstring(&buf[len], chain.ssrc());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_RTP_dynamic_chain(unsigned char *buf, const RTP__Dynamic & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("RTP version", chain.vfield(), 2);
|
|
buf[len] = (chain.vfield() << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*chain.pbit(), 5);
|
|
buf[len] += ShiftUpBit(*chain.rxbit(), 4);
|
|
buf[len] += chain.ccfield() & 0x0F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*chain.mbit(), 7);
|
|
buf[len] += chain.ptfield() & 0x7F;
|
|
len += 1;
|
|
len += Set_LIN2_BO_LAST(&buf[len], chain.rtpseqnum());
|
|
len += Set_LIN4_BO_LAST(&buf[len], chain.rtpts());
|
|
len += Set_Encoding_Type_0(&buf[len], chain.gencsrclist());
|
|
Check_field_presence("RTP rx", *chain.rxbit() == 1,
|
|
chain.rx__field().ispresent());
|
|
if (chain.rx__field().ispresent())
|
|
{
|
|
Check_field_value("RX reserved", (int) *chain.rx__field()().reserved(), 0);
|
|
buf[len] = ((*chain.rx__field()().reserved()) << 5) & 0xE0;
|
|
buf[len] += ShiftUpBit(*chain.rx__field()().xbit(), 4);
|
|
buf[len] += (chain.rx__field()().mode() << 2) & 0x0C;
|
|
buf[len] += ShiftUpBit(*chain.rx__field()().tisbit(), 1);
|
|
buf[len] += ShiftUpBit(*chain.rx__field()().tssbit(), 0);
|
|
len += 1;
|
|
}
|
|
Check_field_presence("TS Stride",
|
|
chain.rx__field().ispresent() &&
|
|
(*chain.rx__field()().tssbit()) == 1,
|
|
chain.ts__stride().ispresent());
|
|
Check_field_presence("TIME Stride",
|
|
chain.rx__field().ispresent() &&
|
|
(*chain.rx__field()().tisbit()) == 1,
|
|
chain.time__stride().ispresent());
|
|
len += Set_SDVL_field_opt(&buf[len], chain.ts__stride(), 0);
|
|
len += Set_SDVL_field_opt(&buf[len], chain.time__stride(), 0);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_RTP_flags_fields_opt(unsigned char *buf,
|
|
const OPTIONAL < RTP__flags__fields > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
buf[len] = (field().mode() << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*field().r__pt(), 5);
|
|
buf[len] += ShiftUpBit(*field().m__bit(), 4);
|
|
buf[len] += ShiftUpBit(*field().r__x(), 3);
|
|
buf[len] += ShiftUpBit(*field().csrc(), 2);
|
|
buf[len] += ShiftUpBit(*field().tss(), 1);
|
|
buf[len] += ShiftUpBit(*field().tis(), 0);
|
|
len += 1;
|
|
|
|
Check_field_presence("RTP flags",
|
|
*field().r__pt() == 1, field().flags().ispresent());
|
|
if (field().flags().ispresent())
|
|
{
|
|
buf[len] = (((*field().flags()().r__p()) << 7) & 0x80) +
|
|
(field().flags()().rtp__pt() & 0x7F);
|
|
len += 1;
|
|
}
|
|
Check_field_presence("Compressed CSRC list",
|
|
*field().csrc() == 1, field().csrc__list().ispresent());
|
|
len += Set_Compr_head_list_opt(&buf[len], field().csrc__list());
|
|
Check_field_presence("TS_STRIDE",
|
|
*field().tss() == 1, field().ts__stride().ispresent());
|
|
len += Set_SDVL_field_opt(&buf[len], field().ts__stride(), 0);
|
|
Check_field_presence("TIME_STRIDE",
|
|
*field().tis() == 1,
|
|
field().time__stride().ispresent());
|
|
len += Set_SDVL_field_opt(&buf[len], field().time__stride(), 0);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_IPv4_dynamic_chain(unsigned char *buf, const IPv4__Dynamic & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN1(&buf[len], chain.tos());
|
|
len += Set_LIN1(&buf[len], chain.ttl());
|
|
len += Set_LIN2_BO_LAST(&buf[len], chain.identification());
|
|
|
|
buf[len] = ShiftUpBit(*chain.df__bit(), 7);
|
|
buf[len] += ShiftUpBit(*chain.rnd__bit(), 6);
|
|
buf[len] += ShiftUpBit(*chain.nbo__bit(), 5);
|
|
Check_field_value("IPv4 reserved (dynamic chain)", *chain.reserved(), 0);
|
|
buf[len] += (*chain.reserved()) & 0x1F;
|
|
len += 1;
|
|
len += Set_Encoding_Type_0(&buf[len], chain.genextheadlist());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_IPv6_dynamic_chain(unsigned char *buf, const IPv6__Dynamic & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN1(&buf[len], chain.trafficclass());
|
|
len += Set_LIN1(&buf[len], chain.hoplimit());
|
|
len += Set_Encoding_Type_0(&buf[len], chain.genextheadlist());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* ============ Encoding functions for ROHC types ============ */
|
|
int
|
|
Set_feedback(unsigned char *buf, const Feedback__u & feedback,
|
|
BOOLEAN const &large_cid)
|
|
{
|
|
int len = 0, crcpos = 0, crcstart = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("feedback type", (int) *feedback.feedback__type(), 30);
|
|
Check_feedback_code__size(feedback.code(), feedback.size());
|
|
buf[len] = ((*feedback.feedback__type()) << 3) & 0xF8;
|
|
buf[len] += feedback.code() & 0x07;
|
|
len += 1;
|
|
|
|
len += Set_LIN1_opt(&buf[len], feedback.size());
|
|
|
|
crcstart = len;
|
|
|
|
len += Set_CID(&buf[len], feedback.feedback__data().cid(), large_cid);
|
|
|
|
switch (feedback.feedback__data().feedback__type().get_selection())
|
|
{
|
|
case Feedback__type::ALT_feedback1:
|
|
{
|
|
Feedback1 fback1 =
|
|
feedback.feedback__data().feedback__type().feedback1();
|
|
|
|
len += Set_octetstring(&buf[len], fback1);
|
|
break;
|
|
}
|
|
|
|
case Feedback__type::ALT_feedback2:
|
|
{
|
|
Feedback2 fback2 =
|
|
feedback.feedback__data().feedback__type().feedback2();
|
|
|
|
buf[len] = (fback2.acktype() << 6) & 0xC0;
|
|
buf[len] += (fback2.mode() << 4) & 0x30;
|
|
buf[len] += (fback2.sn() >> 8) & 0x0F;
|
|
len += 1;
|
|
|
|
buf[len] = fback2.sn() & 0xFF;
|
|
len += 1;
|
|
|
|
if (fback2.feedback__opts().ispresent())
|
|
{
|
|
Feedback__opts & fbopts = fback2.feedback__opts();
|
|
|
|
for (int num = 0; num < fbopts.size_of(); num++)
|
|
{
|
|
buf[len] = (fbopts[num].opt__type() << 4) & 0xF0;
|
|
Check_feedback_optlen__optsize(fbopts[num].opt__len(),
|
|
fbopts[num].opt__data());
|
|
buf[len] += fbopts[num].opt__len() & 0x0F;
|
|
len += 1;
|
|
|
|
len += Set_octetstring_opt(&buf[len], fbopts[num].opt__data());
|
|
if (fbopts[num].opt__data().ispresent())
|
|
{
|
|
if ((fbopts[num].opt__len() == 1)
|
|
&& (fbopts[num].opt__type() == 1) && (buf[len - 1] == 0))
|
|
crcpos = len - 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (feedback.size().ispresent() && feedback.size() == 0)
|
|
{
|
|
buf[1] = (len - 2) & 0xFF;
|
|
}
|
|
if ((!feedback.size().ispresent()) && feedback.code() == 0)
|
|
{
|
|
buf[0] = (buf[0] & 0xF8) + ((len - 1) & 0x07);
|
|
}
|
|
|
|
if ((crcpos > crcstart) && (buf[crcpos] == 0))
|
|
buf[crcpos] = ComputeCRC(&(buf[crcstart]), len - crcstart, 8);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_ROHC_Feedback_opt(unsigned char *buf,
|
|
const OPTIONAL < Feedback > &feedback,
|
|
BOOLEAN const &large_cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!feedback.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
for (int num = 0; num < feedback().size_of(); num++)
|
|
{
|
|
len += Set_feedback(&buf[len], feedback()[num], large_cid);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
|
|
/* Inserts CID infomation into the buffer by moving memory areas */
|
|
int
|
|
Set_CID_for_packets(unsigned char *buf, ROHC__config const &config,
|
|
int cid, int buflen)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (config.large__cid() == false)
|
|
{ /* Small CID: first octet is the CID */
|
|
if (cid > 0)
|
|
{
|
|
// Overlapping memory areas, use memmove
|
|
memmove(&(buf[1]), &(buf[0]), buflen);
|
|
buf[0] = 0xE0 + (cid & 0x0F);
|
|
len += 1;
|
|
}
|
|
}
|
|
else
|
|
{ /* Large CID: CID is placed after the first octet */
|
|
int cidlen = SDVL_encoded_CID_length(cid);
|
|
|
|
// Overlapping memory areas, use memmove
|
|
memmove(&(buf[1 + cidlen]), &(buf[1]), buflen - 1);
|
|
len += Set_SDVL_field(&(buf[1]), cid, 0);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_ROHC_Header_Profile0(unsigned char *buf,
|
|
const Profile0__headers & hdr,
|
|
ROHC__config const &config)
|
|
{
|
|
int len = 0, crcpos = 0, cidlen, cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
switch (hdr.get_selection())
|
|
{
|
|
case Profile0__headers::ALT_ir:
|
|
{
|
|
cid = hdr.ir().cid();
|
|
Check_field_value("packet type", (int) *hdr.ir().type__ind(), 126);
|
|
buf[len] = ((*hdr.ir().type__ind()) << 1) & 0xFE;
|
|
buf[len] += (*hdr.ir().d()) & 0x01;
|
|
len += 1;
|
|
Check_field_value("profile", hdr.ir().profile(), 0);
|
|
len += Set_LIN1(&buf[len], hdr.ir().profile());
|
|
crcpos = len;
|
|
len += Set_LIN1(&buf[len], hdr.ir().crc());
|
|
len += Set_octetstring(&buf[len], hdr.ir().orig__packet());
|
|
break;
|
|
}
|
|
|
|
case Profile0__headers::ALT_normal:
|
|
{
|
|
cid = hdr.normal().cid();
|
|
len += Set_octetstring(&buf[len], hdr.normal().orig__packet());
|
|
break;
|
|
}
|
|
|
|
default:
|
|
Log_not_implemented_union_field("Profile0_headers", hdr.get_selection());
|
|
break;
|
|
}
|
|
|
|
cidlen = Set_CID_for_packets(buf, config, cid, len);
|
|
crcpos += cidlen;
|
|
len += cidlen;
|
|
|
|
if (hdr.get_selection() == Profile0__headers::ALT_ir && hdr.ir().crc() == 0)
|
|
{
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), crcpos, 8);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Static_Chain_Profile1(unsigned char *buf, const Static__Chain & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (int num = 0; num < chain.size_of(); num++)
|
|
{
|
|
switch (chain[num].get_selection())
|
|
{
|
|
case Static__Chain__u::ALT_ipv4__stat:
|
|
len += Set_IPv4_static_chain(&buf[len], chain[num].ipv4__stat());
|
|
break;
|
|
case Static__Chain__u::ALT_ipv6__stat:
|
|
len += Set_IPv6_static_chain(&buf[len], chain[num].ipv6__stat());
|
|
break;
|
|
case Static__Chain__u::ALT_udp__stat:
|
|
len += Set_UDP_static_chain(&buf[len], chain[num].udp__stat());
|
|
break;
|
|
case Static__Chain__u::ALT_rtp__stat:
|
|
len += Set_RTP_static_chain(&buf[len], chain[num].rtp__stat());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Static_Chain_u", chain[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Dynamic_Chain_Profile1(unsigned char *buf, const Dynamic__Chain & dynch)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (int num = 0; num < dynch.size_of(); num++)
|
|
{
|
|
switch (dynch[num].get_selection())
|
|
{
|
|
case Dynamic__Chain__u::ALT_ipv4__dyn:
|
|
len += Set_IPv4_dynamic_chain(&buf[len], dynch[num].ipv4__dyn());
|
|
break;
|
|
case Dynamic__Chain__u::ALT_ipv6__dyn:
|
|
len += Set_IPv6_dynamic_chain(&buf[len], dynch[num].ipv6__dyn());
|
|
break;
|
|
case Dynamic__Chain__u::ALT_udp__dyn:
|
|
len += Set_LIN2_BO_LAST(&buf[len], dynch[num].udp__dyn().cksum());
|
|
break;
|
|
case Dynamic__Chain__u::ALT_rtp__dyn:
|
|
len += Set_RTP_dynamic_chain(&buf[len], dynch[num].rtp__dyn());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Dynamic_Chain_u", dynch[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_ir(unsigned char *buf,
|
|
const Profile1__IR__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 126);
|
|
buf[len] = ((*hdr.type__ind()) << 1) & 0xFE;
|
|
Check_field_presence("dynamic chain", *hdr.d() == 1,
|
|
hdr.dyn__chain().ispresent());
|
|
buf[len] += ShiftUpBit(*hdr.d(), 0);
|
|
len += 1;
|
|
Check_field_value("profile", hdr.profile(), 1);
|
|
len += Set_LIN1(&buf[len], hdr.profile());
|
|
len += Set_LIN1(&buf[len], hdr.crc());
|
|
len += Set_Static_Chain_Profile1(&buf[len], hdr.stat__chain());
|
|
if (hdr.dyn__chain().ispresent())
|
|
len += Set_Dynamic_Chain_Profile1(&buf[len], hdr.dyn__chain());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_irdyn(unsigned char *buf,
|
|
const Profile1__IR__DYN__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 248);
|
|
buf[len] = *hdr.type__ind();
|
|
len += 1;
|
|
Check_field_value("profile", hdr.profile(), 1);
|
|
len += Set_LIN1(&buf[len], hdr.profile());
|
|
len += Set_LIN1(&buf[len], hdr.crc());
|
|
len += Set_Dynamic_Chain_Profile1(&buf[len], hdr.dyn__chain());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_r0(unsigned char *buf,
|
|
const Profile1__R__0__header & hdr)
|
|
{
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 0);
|
|
buf[0] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[0] += hdr.sn() & 0x3F;
|
|
|
|
Log_hexdump(buf, 1);
|
|
Log_function_name_on_leave();
|
|
|
|
return 1;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_r0crc(unsigned char *buf,
|
|
const Profile1__R__0__CRC__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 1);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += (hdr.sn() >> 1) & 0x3F;
|
|
len += 1;
|
|
buf[len] = (hdr.sn() << 7) & 0x80;
|
|
buf[len] += hdr.crc() & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uo0(unsigned char *buf,
|
|
const Profile1__UO__0__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 0);
|
|
buf[len] = ((*hdr.type__ind()) << 7) & 0x80;
|
|
buf[len] += (hdr.sn() << 3) & 0x78;
|
|
buf[len] += hdr.crc() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_r1(unsigned char *buf,
|
|
const Profile1__R__1__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.m__bit(), 7);
|
|
buf[len] += ShiftUpBit(*hdr.x__bit(), 6);
|
|
buf[len] += hdr.ts() & 0x3F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_r1id(unsigned char *buf,
|
|
const Profile1__R__1__ID__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.m__bit(), 7);
|
|
buf[len] += ShiftUpBit(*hdr.x__bit(), 6);
|
|
Check_field_value("T-bit", (int) *hdr.t__bit(), 0);
|
|
buf[len] += ShiftUpBit(*hdr.t__bit(), 5);
|
|
buf[len] += hdr.ip__id() & 0x1F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_r1ts(unsigned char *buf,
|
|
const Profile1__R__1__TS__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.m__bit(), 7);
|
|
buf[len] += ShiftUpBit(*hdr.x__bit(), 6);
|
|
Check_field_value("T-bit", (int) *hdr.t__bit(), 1);
|
|
buf[len] += ShiftUpBit(*hdr.t__bit(), 5);
|
|
buf[len] += hdr.ts() & 0x1F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uo1(unsigned char *buf,
|
|
const Profile1__UO__1__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += hdr.ts() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.m__bit(), 7);
|
|
buf[len] += (hdr.sn() << 3) & 0x78;
|
|
buf[len] += hdr.crc() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uo1id(unsigned char *buf,
|
|
const Profile1__UO__1__ID__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
Check_field_value("T-bit", (int) *hdr.t__bit(), 0);
|
|
buf[len] += ShiftUpBit(*hdr.t__bit(), 5);
|
|
buf[len] += hdr.ip__id() & 0x1F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.x__bit(), 7);
|
|
buf[len] += (hdr.sn() << 3) & 0x78;
|
|
buf[len] += hdr.crc() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uo1ts(unsigned char *buf,
|
|
const Profile1__UO__1__TS__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
Check_field_value("T-bit", (int) *hdr.t__bit(), 1);
|
|
buf[len] += ShiftUpBit(*hdr.t__bit(), 5);
|
|
buf[len] += hdr.ts() & 0x1F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.m__bit(), 7);
|
|
buf[len] += (hdr.sn() << 3) & 0x78;
|
|
buf[len] += hdr.crc() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uor2(unsigned char *buf,
|
|
const Profile1__UOR__2__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 6);
|
|
buf[len] = ((*hdr.type__ind()) << 5) & 0xE0;
|
|
buf[len] += (hdr.ts() >> 1) & 0x1F;
|
|
len += 1;
|
|
buf[len] = (hdr.ts() << 7) & 0x80;
|
|
buf[len] += ShiftUpBit(*hdr.m__bit(), 6);
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.x__bit(), 7);
|
|
buf[len] += hdr.crc() & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uor2id(unsigned char *buf,
|
|
const Profile1__UOR__2__ID__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 6);
|
|
buf[len] = ((*hdr.type__ind()) << 5) & 0xE0;
|
|
buf[len] += hdr.ip__id() & 0x1F;
|
|
len += 1;
|
|
Check_field_value("T-bit", (int) *hdr.t__bit(), 0);
|
|
buf[len] = ShiftUpBit(*hdr.t__bit(), 7);
|
|
buf[len] += ShiftUpBit(*hdr.m__bit(), 6);
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.x__bit(), 7);
|
|
buf[len] += hdr.crc() & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_uor2ts(unsigned char *buf,
|
|
const Profile1__UOR__2__TS__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 6);
|
|
Log_hexdump(buf, len);
|
|
buf[len] = ((*hdr.type__ind()) << 5) & 0xE0;
|
|
buf[len] += hdr.ts() & 0x1F;
|
|
len += 1;
|
|
Check_field_value("T-bit", (int) *hdr.t__bit(), 1);
|
|
buf[len] = ShiftUpBit(*hdr.t__bit(), 7);
|
|
buf[len] += ShiftUpBit(*hdr.m__bit(), 6);
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.x__bit(), 7);
|
|
buf[len] += hdr.crc() & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_Inner_IP_flags_opt(unsigned char *buf,
|
|
const OPTIONAL < Inner__IP__flags > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
buf[len] = ShiftUpBit(*field().tos(), 7);
|
|
buf[len] += ShiftUpBit(*field().ttl(), 6);
|
|
buf[len] += ShiftUpBit(*field().df(), 5);
|
|
buf[len] += ShiftUpBit(*field().pr(), 4);
|
|
buf[len] += ShiftUpBit(*field().ipx(), 3);
|
|
buf[len] += ShiftUpBit(*field().nbo(), 2);
|
|
buf[len] += ShiftUpBit(*field().rnd__bit(), 1);
|
|
buf[len] += ShiftUpBit(*field().ip2__bit(), 0);
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_Outer_IP_flags_opt(unsigned char *buf,
|
|
const OPTIONAL < Outer__IP__flags > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
buf[len] = ShiftUpBit(*field().tos2(), 7);
|
|
buf[len] += ShiftUpBit(*field().ttl2(), 6);
|
|
buf[len] += ShiftUpBit(*field().df2(), 5);
|
|
buf[len] += ShiftUpBit(*field().pr2(), 4);
|
|
buf[len] += ShiftUpBit(*field().ipx2(), 3);
|
|
buf[len] += ShiftUpBit(*field().nbo2(), 2);
|
|
buf[len] += ShiftUpBit(*field().rnd2(), 1);
|
|
buf[len] += ShiftUpBit(*field().i2__bit(), 0);
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ipx_headers_opt(unsigned char *buf,
|
|
const OPTIONAL < IP__Ext__heads > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
buf[len] = ShiftUpBit(*field().cl(), 7);
|
|
buf[len] += ShiftUpBit(*field().aseq(), 6);
|
|
buf[len] += ShiftUpBit(*field().eseq(), 5);
|
|
buf[len] += ShiftUpBit(*field().gseq(), 4);
|
|
buf[len] += (*field().res()) & 0x0F;
|
|
len += 1;
|
|
|
|
Check_field_presence("AH SN", *field().aseq() == 1,
|
|
field().ah__seq().ispresent());
|
|
Check_field_presence("ESP SN", *field().eseq() == 1,
|
|
field().esp__seq().ispresent());
|
|
Check_field_presence("GRE SN", *field().gseq() == 1,
|
|
field().gre__seq().ispresent());
|
|
Check_field_presence("Compressed header list", *field().cl() == 1,
|
|
field().compr__head__list().ispresent());
|
|
len += Set_AEGSeqnum_opt(&buf[len], field().ah__seq());
|
|
len += Set_AEGSeqnum_opt(&buf[len], field().esp__seq());
|
|
len += Set_AEGSeqnum_opt(&buf[len], field().gre__seq());
|
|
len += Set_Compr_head_list_opt(&buf[len], field().compr__head__list());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_Inner_IP_fields_opt(unsigned char *buf,
|
|
const OPTIONAL < Inner__IP__flags > &flags,
|
|
const OPTIONAL < Inner__IP__fields > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
Check_field_presence("TOS (inner IP)",
|
|
flags.ispresent() && (*flags().tos() == 1),
|
|
field().tos().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().tos());
|
|
Check_field_presence("TTL (inner IP)",
|
|
flags.ispresent() && (*flags().ttl() == 1),
|
|
field().ttl().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().ttl());
|
|
Check_field_presence("PROTO (inner IP)",
|
|
flags.ispresent() && (*flags().pr() == 1),
|
|
field().proto().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().proto());
|
|
|
|
Check_field_presence("IP extension headers (inner IP)",
|
|
flags.ispresent() && (*flags().ipx() == 1),
|
|
field().ext__heads().ispresent());
|
|
len += Set_Profile1_ipx_headers_opt(&buf[len], field().ext__heads());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_Outer_IP_fields_opt(unsigned char *buf,
|
|
const OPTIONAL < Outer__IP__flags > &flags,
|
|
const OPTIONAL < Outer__IP__fields > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
Check_field_presence("TOS (outer IP)",
|
|
flags.ispresent() && (*flags().tos2() == 1),
|
|
field().tos().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().tos());
|
|
Check_field_presence("TTL (outer IP)",
|
|
flags.ispresent() && (*flags().ttl2() == 1),
|
|
field().ttl().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().ttl());
|
|
Check_field_presence("PROTO (outer IP)",
|
|
flags.ispresent() && (*flags().pr2() == 1),
|
|
field().proto().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().proto());
|
|
|
|
Check_field_presence("IP extension headers (outer IP)",
|
|
flags.ispresent() && (*flags().ipx2() == 1),
|
|
field().ext__heads().ispresent());
|
|
len += Set_Profile1_ipx_headers_opt(&buf[len], field().ext__heads());
|
|
Check_field_presence("IP-ID (outer IP)",
|
|
flags.ispresent() && (*flags().i2__bit() == 1),
|
|
field().ip__id().ispresent());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], field().ip__id());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_Extension0(unsigned char *buf, const Extension0 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 0);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += (ext.sn() << 3) & 0x38;
|
|
buf[len] += ext.plust() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_Extension1(unsigned char *buf, const Extension1 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 1);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += (ext.sn() << 3) & 0x38;
|
|
buf[len] += ext.plust() & 0x07;
|
|
len += 1;
|
|
len += Set_LIN1(&buf[len], ext.minust());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_Extension2(unsigned char *buf, const Extension2 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 2);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += (ext.sn() << 3) & 0x38;
|
|
buf[len] += (ext.plust() >> 8) & 0x07;
|
|
len += 1;
|
|
buf[len] = ext.plust() & 0xFF;
|
|
len += 1;
|
|
len += Set_LIN1(&buf[len], ext.minust());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_Extension3(unsigned char *buf, const Extension3 & ext)
|
|
{
|
|
int len = 0;
|
|
int ts_length = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 3);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*ext.s__bit(), 5);
|
|
buf[len] += ShiftUpBit(*ext.r__ts__bit(), 4);
|
|
buf[len] += ShiftUpBit(*ext.tsc__bit(), 3);
|
|
buf[len] += ShiftUpBit(*ext.i__bit(), 2);
|
|
buf[len] += ShiftUpBit(*ext.ip__bit(), 1);
|
|
buf[len] += ShiftUpBit(*ext.rtp__bit(), 0);
|
|
len += 1;
|
|
|
|
Check_field_presence("Inner IP flags",
|
|
*ext.ip__bit() == 1,
|
|
ext.inner__ip__flags().ispresent());
|
|
len += Set_Profile1_Inner_IP_flags_opt(&buf[len], ext.inner__ip__flags());
|
|
Check_field_presence("Outer IP flags",
|
|
ext.inner__ip__flags().ispresent() &&
|
|
(*ext.inner__ip__flags()().ip2__bit() == 1),
|
|
ext.outer__ip__flags().ispresent());
|
|
len += Set_Profile1_Outer_IP_flags_opt(&buf[len], ext.outer__ip__flags());
|
|
Check_field_presence("SN", *ext.s__bit() == 1, ext.sn().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], ext.sn());
|
|
Check_field_presence("RTP TS", *ext.r__ts__bit() == 1, ext.ts().ispresent());
|
|
if (ext.ts__length().ispresent()) ts_length = ext.ts__length()();
|
|
len += Set_SDVL_field_opt(&buf[len], ext.ts(), ts_length);
|
|
Check_field_presence("Inner IP fields",
|
|
*ext.ip__bit() == 1, ext.inner__ip__hdr().ispresent());
|
|
len += Set_Profile1_Inner_IP_fields_opt(&buf[len], ext.inner__ip__flags(),
|
|
ext.inner__ip__hdr());
|
|
Check_field_presence("Inner IP-ID",
|
|
*ext.i__bit() == 1, ext.ip__id().ispresent());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], ext.ip__id());
|
|
Check_field_presence("Outer IP fields",
|
|
ext.inner__ip__flags().ispresent() &&
|
|
(*ext.inner__ip__flags()().ip2__bit() == 1),
|
|
ext.outer__ip__hdr().ispresent());
|
|
len += Set_Profile1_Outer_IP_fields_opt(&buf[len], ext.outer__ip__flags(),
|
|
ext.outer__ip__hdr());
|
|
Check_field_presence("RTP flags and fields",
|
|
*ext.rtp__bit() == 1, ext.rtp__fl__fi().ispresent());
|
|
len += Set_RTP_flags_fields_opt(&buf[len], ext.rtp__fl__fi());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_Extension_opt(unsigned char *buf,
|
|
const OPTIONAL < Profile1__Extension >
|
|
&ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (ext.ispresent())
|
|
{
|
|
if (ext().get_selection() == Profile1__Extension::ALT_ext0)
|
|
{
|
|
len += Set_Profile1_ROHC_Header_Extension0(&buf[len], ext().ext0());
|
|
}
|
|
else if (ext().get_selection() == Profile1__Extension::ALT_ext1)
|
|
{
|
|
len += Set_Profile1_ROHC_Header_Extension1(&buf[len], ext().ext1());
|
|
}
|
|
else if (ext().get_selection() == Profile1__Extension::ALT_ext2)
|
|
{
|
|
len += Set_Profile1_ROHC_Header_Extension2(&buf[len], ext().ext2());
|
|
}
|
|
else if (ext().get_selection() == Profile1__Extension::ALT_ext3)
|
|
{
|
|
len += Set_Profile1_ROHC_Header_Extension3(&buf[len], ext().ext3());
|
|
}
|
|
else
|
|
{
|
|
Log_not_implemented_union_field("Profile1_Extension",
|
|
ext().get_selection());
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header_ipid_ah_gre(unsigned char *buf,
|
|
const Profile1__headers & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.ip__id__outer());
|
|
len += Set_octetstring_opt(&buf[len], hdr.ah__outer());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.gre__cksum1());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.ip__id__inner());
|
|
len += Set_octetstring_opt(&buf[len], hdr.ah__inner());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.gre__cksum2());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile1_ROHC_Header(unsigned char *buf,
|
|
const Profile1__headers & hdr,
|
|
ROHC__config const &config)
|
|
{
|
|
int len = 0, crcpos = 0, cidlen = 0, cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
switch (hdr.base__header().get_selection())
|
|
{
|
|
case Profile1__base__header::ALT_ir:
|
|
cid = hdr.base__header().ir().cid();
|
|
crcpos = len + 2;
|
|
len += Set_Profile1_ROHC_Header_ir(&buf[len], hdr.base__header().ir());
|
|
break;
|
|
case Profile1__base__header::ALT_ir__dyn:
|
|
cid = hdr.base__header().ir__dyn().cid();
|
|
crcpos = len + 2;
|
|
len += Set_Profile1_ROHC_Header_irdyn(&buf[len],
|
|
hdr.base__header().ir__dyn());
|
|
break;
|
|
case Profile1__base__header::ALT_r__0:
|
|
cid = hdr.base__header().r__0().cid();
|
|
len += Set_Profile1_ROHC_Header_r0(&buf[len], hdr.base__header().r__0());
|
|
break;
|
|
case Profile1__base__header::ALT_r__0__crc:
|
|
cid = hdr.base__header().r__0__crc().cid();
|
|
len += Set_Profile1_ROHC_Header_r0crc(&buf[len],
|
|
hdr.base__header().r__0__crc());
|
|
break;
|
|
case Profile1__base__header::ALT_uo__0:
|
|
cid = hdr.base__header().uo__0().cid();
|
|
len += Set_Profile1_ROHC_Header_uo0(&buf[len], hdr.base__header().uo__0());
|
|
break;
|
|
case Profile1__base__header::ALT_r__1:
|
|
cid = hdr.base__header().r__1().cid();
|
|
len += Set_Profile1_ROHC_Header_r1(&buf[len], hdr.base__header().r__1());
|
|
break;
|
|
case Profile1__base__header::ALT_r__1__id:
|
|
cid = hdr.base__header().r__1__id().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_r1id(&buf[len], hdr.base__header().r__1__id());
|
|
break;
|
|
case Profile1__base__header::ALT_r__1__ts:
|
|
cid = hdr.base__header().r__1__ts().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_r1ts(&buf[len], hdr.base__header().r__1__ts());
|
|
break;
|
|
case Profile1__base__header::ALT_uo__1:
|
|
cid = hdr.base__header().uo__1().cid();
|
|
len += Set_Profile1_ROHC_Header_uo1(&buf[len], hdr.base__header().uo__1());
|
|
break;
|
|
case Profile1__base__header::ALT_uo__1__id:
|
|
cid = hdr.base__header().uo__1__id().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_uo1id(&buf[len],
|
|
hdr.base__header().uo__1__id());
|
|
break;
|
|
case Profile1__base__header::ALT_uo__1__ts:
|
|
cid = hdr.base__header().uo__1__ts().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_uo1ts(&buf[len],
|
|
hdr.base__header().uo__1__ts());
|
|
break;
|
|
case Profile1__base__header::ALT_uor__2:
|
|
cid = hdr.base__header().uor__2().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_uor2(&buf[len], hdr.base__header().uor__2());
|
|
break;
|
|
case Profile1__base__header::ALT_uor__2__id:
|
|
cid = hdr.base__header().uor__2__id().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_uor2id(&buf[len],
|
|
hdr.base__header().uor__2__id());
|
|
break;
|
|
case Profile1__base__header::ALT_uor__2__ts:
|
|
cid = hdr.base__header().uor__2__ts().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_uor2ts(&buf[len],
|
|
hdr.base__header().uor__2__ts());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile1_base_header", hdr.base__header().get_selection());
|
|
break;
|
|
}
|
|
|
|
len += Set_Profile1_ROHC_Header_Extension_opt(&buf[len], hdr.ext());
|
|
len += Set_Profile1_ROHC_Header_ipid_ah_gre(&buf[len], hdr);
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.udp__cksum());
|
|
|
|
cidlen = Set_CID_for_packets(buf, config, cid, len);
|
|
crcpos += cidlen;
|
|
len += cidlen;
|
|
|
|
if (hdr.base__header().get_selection() == Profile1__base__header::ALT_ir
|
|
&& hdr.base__header().ir().crc() == 0)
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
else if (hdr.base__header().get_selection() ==
|
|
Profile1__base__header::ALT_ir__dyn
|
|
&& hdr.base__header().ir__dyn().crc() == 0)
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_Static_Chain(unsigned char
|
|
*buf, const Profile2__Static__Chain & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (int num = 0; num < chain.size_of(); num++)
|
|
{
|
|
switch (chain[num].get_selection())
|
|
{
|
|
case Static__Chain__u::ALT_ipv4__stat:
|
|
len += Set_IPv4_static_chain(&buf[len], chain[num].ipv4__stat());
|
|
break;
|
|
case Static__Chain__u::ALT_ipv6__stat:
|
|
len += Set_IPv6_static_chain(&buf[len], chain[num].ipv6__stat());
|
|
break;
|
|
case Static__Chain__u::ALT_udp__stat:
|
|
len += Set_UDP_static_chain(&buf[len], chain[num].udp__stat());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile2_Static_Chain", chain[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_Dynamic_Chain(unsigned char
|
|
*buf, const Profile2__Dynamic__Chain & dynch)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (int num = 0; num < dynch.size_of(); num++)
|
|
{
|
|
switch (dynch[num].get_selection())
|
|
{
|
|
case Profile2__Dynamic__Chain__u::ALT_ipv4__dyn:
|
|
len += Set_IPv4_dynamic_chain(&buf[len], dynch[num].ipv4__dyn());
|
|
break;
|
|
case Profile2__Dynamic__Chain__u::ALT_ipv6__dyn:
|
|
len += Set_IPv6_dynamic_chain(&buf[len], dynch[num].ipv6__dyn());
|
|
break;
|
|
case Profile2__Dynamic__Chain__u::ALT_udp__dyn:
|
|
len += Set_LIN2_BO_LAST(&buf[len], dynch[num].udp__dyn().cksum());
|
|
len += Set_LIN2_BO_LAST(&buf[len], dynch[num].udp__dyn().udp__sn());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile2_Dynamic_Chain", dynch[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_ir(unsigned char
|
|
*buf, const Profile2__IR__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 126);
|
|
buf[len] = ((*hdr.type__ind()) << 1) & 0xFE;
|
|
Check_field_presence("dynamic chain", *hdr.d() == 1,
|
|
hdr.dyn__chain().ispresent());
|
|
buf[len] += ShiftUpBit(*hdr.d(), 0);
|
|
len += 1;
|
|
Check_field_value("profile", hdr.profile(), 2);
|
|
len += Set_LIN1(&buf[len], hdr.profile());
|
|
len += Set_LIN1(&buf[len], hdr.crc());
|
|
len += Set_Profile2_Static_Chain(&buf[len], hdr.stat__chain());
|
|
if (hdr.dyn__chain().ispresent())
|
|
len += Set_Profile2_Dynamic_Chain(&buf[len], hdr.dyn__chain());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_irdyn(unsigned
|
|
char *buf,
|
|
const Profile2__IR__DYN__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 248);
|
|
buf[len] = *hdr.type__ind();
|
|
len += 1;
|
|
Check_field_value("profile", hdr.profile(), 2);
|
|
len += Set_LIN1(&buf[len], hdr.profile());
|
|
len += Set_LIN1(&buf[len], hdr.crc());
|
|
len += Set_Profile2_Dynamic_Chain(&buf[len], hdr.dyn__chain());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_r1(unsigned char
|
|
*buf, const Profile2__R__1__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += hdr.sn() & 0x3F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.x__bit(), 7);
|
|
buf[len] += hdr.ip__id() & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_uo1(unsigned char
|
|
*buf, const Profile2__UO__1__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 2);
|
|
buf[len] = ((*hdr.type__ind()) << 6) & 0xC0;
|
|
buf[len] += hdr.ip__id() & 0x3F;
|
|
len += 1;
|
|
buf[len] = (hdr.sn() << 3) & 0xF8;
|
|
buf[len] += hdr.crc() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_uor2(unsigned char *buf,
|
|
const Profile2__UOR__2__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 6);
|
|
buf[len] = ((*hdr.type__ind()) << 5) & 0xE0;
|
|
buf[len] += hdr.sn() & 0x1F;
|
|
len += 1;
|
|
buf[len] = ShiftUpBit(*hdr.x__bit(), 7);
|
|
buf[len] += hdr.crc() & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_Inner_IP_flags_opt(unsigned char *buf,
|
|
const OPTIONAL < Profile2__Inner__IP__flags >
|
|
&field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
buf[len] = ShiftUpBit(*field().tos(), 7);
|
|
buf[len] += ShiftUpBit(*field().ttl(), 6);
|
|
buf[len] += ShiftUpBit(*field().df(), 5);
|
|
buf[len] += ShiftUpBit(*field().pr(), 4);
|
|
buf[len] += ShiftUpBit(*field().ipx(), 3);
|
|
buf[len] += ShiftUpBit(*field().nbo(), 2);
|
|
buf[len] += ShiftUpBit(*field().rnd__bit(), 1);
|
|
Check_field_value("inner IP flags, reserved", (int) *field().reserved(), 0);
|
|
buf[len] += ShiftUpBit(*field().reserved(), 0);
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_Inner_IP_fields_opt(unsigned char *buf,
|
|
const OPTIONAL < Profile2__Inner__IP__flags >
|
|
&flags,
|
|
const OPTIONAL < Inner__IP__fields > &field)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!field.ispresent())
|
|
{
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
Check_field_presence("TOS (inner IP)",
|
|
flags.ispresent() && (*flags().tos() == 1),
|
|
field().tos().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().tos());
|
|
Check_field_presence("TTL (inner IP)",
|
|
flags.ispresent() && (*flags().ttl() == 1),
|
|
field().ttl().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().ttl());
|
|
Check_field_presence("PROTO (inner IP)",
|
|
flags.ispresent() && (*flags().pr() == 1),
|
|
field().proto().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], field().proto());
|
|
|
|
len += Set_Profile1_ipx_headers_opt(&buf[len], field().ext__heads());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_Extension0(unsigned char *buf,
|
|
const Profile2__Extension0 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 0);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += (ext.sn() << 3) & 0x38;
|
|
buf[len] += ext.ip__id() & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_Extension1(unsigned char *buf,
|
|
const Profile2__Extension1 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 1);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += (ext.sn() << 3) & 0x38;
|
|
buf[len] += (ext.ip__id() >> 8) & 0x07;
|
|
len += 1;
|
|
buf[len] = ext.ip__id() & 0xFF;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_Extension2(unsigned char *buf,
|
|
const Profile2__Extension2 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 2);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += (ext.sn() << 3) & 0x38;
|
|
buf[len] += (ext.ip__id2() >> 8) & 0x07;
|
|
len += 1;
|
|
buf[len] = ext.ip__id2() & 0xFF;
|
|
len += 1;
|
|
buf[len] = ext.ip__id() & 0xFF;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_Extension3(unsigned char *buf,
|
|
const Profile2__Extension3 & ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("extension type", (int) *ext.ext__type(), 3);
|
|
buf[len] = ((*ext.ext__type()) << 6) & 0xC0;
|
|
buf[len] += ShiftUpBit(*ext.s__bit(), 5);
|
|
buf[len] += ((ext.mode()) << 3) & 0x18;
|
|
buf[len] += ShiftUpBit(*ext.i__bit(), 2);
|
|
buf[len] += ShiftUpBit(*ext.ip__bit(), 1);
|
|
buf[len] += ShiftUpBit(*ext.ip2__bit(), 0);
|
|
len += 1;
|
|
|
|
Check_field_presence("Inner IP flags",
|
|
*ext.ip__bit() == 1,
|
|
ext.inner__ip__flags().ispresent());
|
|
len += Set_Profile2_Inner_IP_flags_opt(&buf[len], ext.inner__ip__flags());
|
|
Check_field_presence("Outer IP flags",
|
|
*ext.ip2__bit() == 1,
|
|
ext.outer__ip__flags().ispresent());
|
|
len += Set_Profile1_Outer_IP_flags_opt(&buf[len], ext.outer__ip__flags());
|
|
Check_field_presence("SN", *ext.s__bit() == 1, ext.sn().ispresent());
|
|
len += Set_LIN1_opt(&buf[len], ext.sn());
|
|
Check_field_presence("Inner IP fields",
|
|
*ext.ip__bit() == 1, ext.inner__ip__hdr().ispresent());
|
|
len += Set_Profile2_Inner_IP_fields_opt(&buf[len], ext.inner__ip__flags(),
|
|
ext.inner__ip__hdr());
|
|
Check_field_presence("Inner IP-ID",
|
|
*ext.i__bit() == 1, ext.ip__id().ispresent());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], ext.ip__id());
|
|
Check_field_presence("Outer IP fields",
|
|
*ext.ip2__bit() == 1, ext.outer__ip__hdr().ispresent());
|
|
len += Set_Profile1_Outer_IP_fields_opt(&buf[len], ext.outer__ip__flags(),
|
|
ext.outer__ip__hdr());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_Extension_opt(unsigned char *buf,
|
|
const OPTIONAL < Profile2__Extension >
|
|
&ext)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (ext.ispresent())
|
|
{
|
|
if (ext().get_selection() == Profile2__Extension::ALT_ext0)
|
|
{
|
|
len += Set_Profile2_ROHC_Header_Extension0(&buf[len], ext().ext0());
|
|
}
|
|
else if (ext().get_selection() == Profile2__Extension::ALT_ext1)
|
|
{
|
|
len += Set_Profile2_ROHC_Header_Extension1(&buf[len], ext().ext1());
|
|
}
|
|
else if (ext().get_selection() == Profile2__Extension::ALT_ext2)
|
|
{
|
|
len += Set_Profile2_ROHC_Header_Extension2(&buf[len], ext().ext2());
|
|
}
|
|
else if (ext().get_selection() == Profile2__Extension::ALT_ext3)
|
|
{
|
|
len += Set_Profile2_ROHC_Header_Extension3(&buf[len], ext().ext3());
|
|
}
|
|
else
|
|
{
|
|
Log_not_implemented_union_field("Profile2_Extension",
|
|
ext().get_selection());
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header_ipid_ah_gre(unsigned char *buf,
|
|
const Profile2__headers & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.ip__id__outer());
|
|
len += Set_octetstring_opt(&buf[len], hdr.ah__outer());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.gre__cksum1());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.ip__id__inner());
|
|
len += Set_octetstring_opt(&buf[len], hdr.ah__inner());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.gre__cksum2());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile2_ROHC_Header(unsigned char *buf,
|
|
const Profile2__headers & hdr,
|
|
ROHC__config const &config)
|
|
{
|
|
int len = 0, crcpos = 0, cidlen = 0, cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
switch (hdr.base__header().get_selection())
|
|
{
|
|
case Profile2__base__header::ALT_ir:
|
|
cid = hdr.base__header().ir().cid();
|
|
crcpos = len + 2;
|
|
len += Set_Profile2_ROHC_Header_ir(&buf[len], hdr.base__header().ir());
|
|
break;
|
|
case Profile2__base__header::ALT_ir__dyn:
|
|
cid = hdr.base__header().ir__dyn().cid();
|
|
crcpos = len + 2;
|
|
len +=
|
|
Set_Profile2_ROHC_Header_irdyn(&buf[len], hdr.base__header().ir__dyn());
|
|
break;
|
|
case Profile1__base__header::ALT_r__0:
|
|
cid = hdr.base__header().r__0().cid();
|
|
len += Set_Profile1_ROHC_Header_r0(&buf[len], hdr.base__header().r__0());
|
|
break;
|
|
case Profile1__base__header::ALT_r__0__crc:
|
|
cid = hdr.base__header().r__0__crc().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_r0crc(&buf[len],
|
|
hdr.base__header().r__0__crc());
|
|
break;
|
|
case Profile1__base__header::ALT_uo__0:
|
|
cid = hdr.base__header().uo__0().cid();
|
|
len += Set_Profile1_ROHC_Header_uo0(&buf[len], hdr.base__header().uo__0());
|
|
break;
|
|
case Profile2__base__header::ALT_r__1:
|
|
cid = hdr.base__header().r__1().cid();
|
|
len += Set_Profile2_ROHC_Header_r1(&buf[len], hdr.base__header().r__1());
|
|
break;
|
|
case Profile2__base__header::ALT_uo__1:
|
|
cid = hdr.base__header().uo__1().cid();
|
|
len += Set_Profile2_ROHC_Header_uo1(&buf[len], hdr.base__header().uo__1());
|
|
break;
|
|
case Profile2__base__header::ALT_uor__2:
|
|
cid = hdr.base__header().uor__2().cid();
|
|
len +=
|
|
Set_Profile2_ROHC_Header_uor2(&buf[len], hdr.base__header().uor__2());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile2_base_header", hdr.base__header().get_selection());
|
|
break;
|
|
}
|
|
|
|
len += Set_Profile2_ROHC_Header_Extension_opt(&buf[len], hdr.ext());
|
|
len += Set_Profile2_ROHC_Header_ipid_ah_gre(&buf[len], hdr);
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], hdr.udp__cksum());
|
|
|
|
cidlen = Set_CID_for_packets(buf, config, cid, len);
|
|
crcpos += cidlen;
|
|
len += cidlen;
|
|
|
|
if (hdr.base__header().get_selection() == Profile2__base__header::ALT_ir)
|
|
{
|
|
if (hdr.base__header().ir().crc() == 0)
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
}
|
|
else
|
|
if (hdr.base__header().
|
|
get_selection() == Profile2__base__header::ALT_ir__dyn)
|
|
{
|
|
if (hdr.base__header().ir__dyn().crc() == 0)
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
} /* Set_Profile2_ROHC_Header */
|
|
|
|
int
|
|
Set_Profile4_Static_Chain(unsigned char *buf,
|
|
const Profile4__Static__Chain & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (int num = 0; num < chain.size_of(); num++)
|
|
{
|
|
switch (chain[num].get_selection())
|
|
{
|
|
case Static__Chain__u::ALT_ipv4__stat:
|
|
len += Set_IPv4_static_chain(&buf[len], chain[num].ipv4__stat());
|
|
break;
|
|
case Static__Chain__u::ALT_ipv6__stat:
|
|
len += Set_IPv6_static_chain(&buf[len], chain[num].ipv6__stat());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile4_Static_Chain", chain[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile4_IPv4_dynamic(unsigned char *buf,
|
|
const Profile4__IPv4__Dynamic & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN1(&buf[len], chain.tos());
|
|
len += Set_LIN1(&buf[len], chain.ttl());
|
|
len += Set_LIN2_BO_LAST(&buf[len], chain.identification());
|
|
|
|
buf[len] = ShiftUpBit(*chain.df__bit(), 7);
|
|
buf[len] += ShiftUpBit(*chain.rnd__bit(), 6);
|
|
buf[len] += ShiftUpBit(*chain.nbo__bit(), 5);
|
|
buf[len] += ShiftUpBit(*chain.sid__bit(), 4);
|
|
Check_field_value("IPv4 reserved (dynamic chain)", *chain.reserved(), 0);
|
|
buf[len] += (*chain.reserved()) & 0x0F;
|
|
len += 1;
|
|
len += Set_Encoding_Type_0(&buf[len], chain.genextheadlist());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile4_Dynamic_Chain(unsigned char *buf,
|
|
const Profile4__Dynamic__Chain & dynch)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (int num = 0; num < dynch.size_of(); num++)
|
|
{
|
|
switch (dynch[num].get_selection())
|
|
{
|
|
case Profile4__Dynamic__Chain__u::ALT_ipv4__dyn:
|
|
len += Set_Profile4_IPv4_dynamic(&buf[len], dynch[num].ipv4__dyn());
|
|
break;
|
|
case Profile4__Dynamic__Chain__u::ALT_ipv6__dyn:
|
|
len += Set_IPv6_dynamic_chain(&buf[len], dynch[num].ipv6__dyn());
|
|
break;
|
|
case Profile4__Dynamic__Chain__u::ALT_sn:
|
|
len += Set_LIN2_BO_LAST(&buf[len], dynch[num].sn());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile4_Dynamic_Chain", dynch[num].get_selection());
|
|
break;
|
|
}
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile4_ROHC_Header_ir(unsigned char *buf,
|
|
const Profile4__IR__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 126);
|
|
buf[len] = ((*hdr.type__ind()) << 1) & 0xFE;
|
|
Check_field_presence("dynamic chain", *hdr.d() == 1,
|
|
hdr.dyn__chain().ispresent());
|
|
buf[len] += ShiftUpBit(*hdr.d(), 0);
|
|
len += 1;
|
|
Check_field_value("profile", hdr.profile(), 4);
|
|
len += Set_LIN1(&buf[len], hdr.profile());
|
|
len += Set_LIN1(&buf[len], hdr.crc());
|
|
len += Set_Profile4_Static_Chain(&buf[len], hdr.stat__chain());
|
|
if (hdr.dyn__chain().ispresent())
|
|
len += Set_Profile4_Dynamic_Chain(&buf[len], hdr.dyn__chain());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile4_ROHC_Header_irdyn(unsigned char *buf,
|
|
const Profile4__IR__DYN__header & hdr)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Check_field_value("packet type", (int) *hdr.type__ind(), 248);
|
|
buf[len] = *hdr.type__ind();
|
|
len += 1;
|
|
Check_field_value("profile", hdr.profile(), 4);
|
|
len += Set_LIN1(&buf[len], hdr.profile());
|
|
len += Set_LIN1(&buf[len], hdr.crc());
|
|
len += Set_Profile4_Dynamic_Chain(&buf[len], hdr.dyn__chain());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile4_ROHC_Header_ipid_ah_gre(unsigned char *buf,
|
|
const Profile4__headers & other_headers)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], other_headers.ip__id__outer());
|
|
len += Set_octetstring_opt(&buf[len], other_headers.ah__outer());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], other_headers.gre__cksum1());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], other_headers.ip__id__inner());
|
|
len += Set_octetstring_opt(&buf[len], other_headers.ah__inner());
|
|
len += Set_LIN2_BO_LAST_opt(&buf[len], other_headers.gre__cksum2());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Set_Profile4_ROHC_Header(unsigned char *buf,
|
|
const Profile4__headers & hdr,
|
|
ROHC__config const &config)
|
|
{
|
|
int len = 0, crcpos = 0, cidlen = 0, cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
switch (hdr.base__header().get_selection())
|
|
{
|
|
case Profile4__base__header::ALT_ir:
|
|
cid = hdr.base__header().ir().cid();
|
|
crcpos = len + 2;
|
|
len += Set_Profile4_ROHC_Header_ir(&buf[len], hdr.base__header().ir());
|
|
break;
|
|
case Profile4__base__header::ALT_ir__dyn:
|
|
cid = hdr.base__header().ir__dyn().cid();
|
|
crcpos = len + 2;
|
|
len +=
|
|
Set_Profile4_ROHC_Header_irdyn(&buf[len], hdr.base__header().ir__dyn());
|
|
break;
|
|
case Profile1__base__header::ALT_r__0:
|
|
cid = hdr.base__header().r__0().cid();
|
|
len += Set_Profile1_ROHC_Header_r0(&buf[len], hdr.base__header().r__0());
|
|
break;
|
|
case Profile1__base__header::ALT_r__0__crc:
|
|
cid = hdr.base__header().r__0__crc().cid();
|
|
len +=
|
|
Set_Profile1_ROHC_Header_r0crc(&buf[len],
|
|
hdr.base__header().r__0__crc());
|
|
break;
|
|
case Profile1__base__header::ALT_uo__0:
|
|
cid = hdr.base__header().uo__0().cid();
|
|
len += Set_Profile1_ROHC_Header_uo0(&buf[len], hdr.base__header().uo__0());
|
|
break;
|
|
case Profile2__base__header::ALT_r__1:
|
|
cid = hdr.base__header().r__1().cid();
|
|
len += Set_Profile2_ROHC_Header_r1(&buf[len], hdr.base__header().r__1());
|
|
break;
|
|
case Profile2__base__header::ALT_uo__1:
|
|
cid = hdr.base__header().uo__1().cid();
|
|
len += Set_Profile2_ROHC_Header_uo1(&buf[len], hdr.base__header().uo__1());
|
|
break;
|
|
case Profile2__base__header::ALT_uor__2:
|
|
cid = hdr.base__header().uor__2().cid();
|
|
len +=
|
|
Set_Profile2_ROHC_Header_uor2(&buf[len], hdr.base__header().uor__2());
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field
|
|
("Profile4_base_header", hdr.base__header().get_selection());
|
|
break;
|
|
}
|
|
|
|
len += Set_Profile2_ROHC_Header_Extension_opt(&buf[len], hdr.ext());
|
|
len += Set_Profile4_ROHC_Header_ipid_ah_gre(&buf[len], hdr);
|
|
if (hdr.additional__IP().ispresent())
|
|
{
|
|
len += Set_Profile4_Dynamic_Chain(&buf[len], hdr.additional__IP()());
|
|
}
|
|
|
|
cidlen = Set_CID_for_packets(buf, config, cid, len);
|
|
crcpos += cidlen;
|
|
len += cidlen;
|
|
|
|
if (hdr.base__header().get_selection() == Profile4__base__header::ALT_ir)
|
|
{
|
|
if (hdr.base__header().ir().crc() == 0)
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
}
|
|
else if (hdr.base__header().get_selection() ==
|
|
Profile4__base__header::ALT_ir__dyn)
|
|
{
|
|
if (hdr.base__header().ir__dyn().crc() == 0)
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
OCTETSTRING
|
|
f__ROHC__enc(ROHC__packet__u const &pdu, ROHC__config const &config)
|
|
{
|
|
unsigned char buf[MAX_PACKET_SIZE];
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.begin_event(TTCN_DEBUG);
|
|
config.log();
|
|
pdu.log();
|
|
TTCN_logger.end_event();
|
|
|
|
if (pdu.get_selection() == ROHC__packet__u::ALT_segment)
|
|
{
|
|
// Processing padding
|
|
len += Set_octetstring_opt(&buf[len], pdu.segment().padding());
|
|
// Processing feedback
|
|
len +=
|
|
Set_ROHC_Feedback_opt(&buf[len],
|
|
pdu.segment().feedback(), config.large__cid());
|
|
// Processing segment header
|
|
Check_field_value("segment header id",
|
|
pdu.segment().segment__header__id(), 127);
|
|
buf[len] = (pdu.segment().segment__header__id() << 1) & 0xFE;
|
|
if (pdu.segment().final())
|
|
buf[len] += 1;
|
|
len += 1;
|
|
// Processing payload
|
|
len += Set_octetstring_opt(&buf[len], pdu.segment().payload());
|
|
// Processing CRC
|
|
if (pdu.segment().crc().ispresent())
|
|
{
|
|
buf[len] = (pdu.segment().crc()() >> 24) & 0xFF;
|
|
len += 1;
|
|
buf[len] = (pdu.segment().crc()() >> 16) & 0xFF;
|
|
len += 1;
|
|
buf[len] = (pdu.segment().crc()() >> 8) & 0xFF;
|
|
len += 1;
|
|
buf[len] = pdu.segment().crc()() & 0xFF;
|
|
len += 1;
|
|
}
|
|
}
|
|
else if (pdu.get_selection() == ROHC__packet__u::ALT_rohc)
|
|
{
|
|
// Processing padding
|
|
len += Set_octetstring_opt(&buf[len], pdu.rohc().padding());
|
|
// Processing feedback
|
|
len += Set_ROHC_Feedback_opt(&buf[len],
|
|
pdu.rohc().feedback(), config.large__cid());
|
|
// Processing ROHC header
|
|
switch (pdu.rohc().header().get_selection())
|
|
{
|
|
case Header::ALT_prof0:
|
|
len += Set_ROHC_Header_Profile0(&buf[len], pdu.rohc().header().prof0(),
|
|
config);
|
|
break;
|
|
case Header::ALT_prof1:
|
|
len += Set_Profile1_ROHC_Header(&buf[len], pdu.rohc().header().prof1(),
|
|
config);
|
|
break;
|
|
case Header::ALT_prof2:
|
|
len += Set_Profile2_ROHC_Header(&buf[len], pdu.rohc().header().prof2(),
|
|
config);
|
|
break;
|
|
case Header::ALT_prof4:
|
|
len += Set_Profile4_ROHC_Header(&buf[len], pdu.rohc().header().prof4(),
|
|
config);
|
|
break;
|
|
default:
|
|
Log_not_implemented_union_field("Header",
|
|
pdu.rohc().header().get_selection());
|
|
break;
|
|
}
|
|
|
|
// Processing payload
|
|
len += Set_octetstring_opt(&buf[len], pdu.rohc().payload());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return OCTETSTRING(len, &(buf[0]));
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ============ Decoding functions for base types ============ */
|
|
|
|
/* Mirrors the bits of an octet and returns the same pointer. */
|
|
unsigned char *
|
|
Convert_bitstring(unsigned char *buf, int len)
|
|
{
|
|
unsigned char dst_buf = 0;
|
|
|
|
if (len > 8)
|
|
{
|
|
TTCN_error("Bitstring is too long, at most 8 bits can be converted");
|
|
}
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
dst_buf += ShiftUpBit(ShiftDownBit(buf[0], i), 7 - i);
|
|
}
|
|
buf[0] = dst_buf;
|
|
|
|
return buf;
|
|
}
|
|
|
|
/* Decodes an OCTETSTING value */
|
|
int
|
|
Get_octetstring(const unsigned char *buf, OCTETSTRING & octstr, int length)
|
|
{
|
|
octstr = OCTETSTRING(length, buf);
|
|
return length;
|
|
}
|
|
|
|
/* Decodes a LIN1 value */
|
|
int
|
|
Get_LIN1(const unsigned char *buf, LIN1 & var)
|
|
{
|
|
var = LIN1(buf[0]);
|
|
return 1;
|
|
}
|
|
|
|
/* Decodes a LIN2_BO_LAST value */
|
|
int
|
|
Get_LIN2_BO_LAST(const unsigned char *buf, LIN2__BO__LAST & var)
|
|
{
|
|
var = (buf[0] << 8) + buf[1];
|
|
return 2;
|
|
}
|
|
|
|
/* Decodes a LIN4_BO_LAST value */
|
|
int
|
|
Get_LIN4_BO_LAST(const unsigned char *buf, LIN4__BO__LAST & var)
|
|
{
|
|
var = (buf[0] << 24) + (buf[1] << 16) + (buf[2] << 8) + buf[3];
|
|
return 4;
|
|
}
|
|
|
|
int
|
|
Get_SDVL_field(const unsigned char *buf, INTEGER & dest)
|
|
{
|
|
int len = 0;
|
|
int decoded_value;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if ((buf[len] & 0x80) == 0)
|
|
{
|
|
dest = buf[len] & 0x7F;
|
|
len += 1;
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
dest = ((buf[len] << 8) & 0x3F00) + (buf[len + 1] & 0xFF);
|
|
len += 2;
|
|
}
|
|
else if ((buf[len] & 0xE0) == 0xC0)
|
|
{
|
|
dest =
|
|
((buf[len] << 16) & 0x1F0000) +
|
|
((buf[len + 1] << 8) & 0xFF00) + (buf[len + 2] & 0xFF);
|
|
len += 3;
|
|
}
|
|
else // if ((buf[len] & 0xE0) == 0xE0)
|
|
{
|
|
dest =
|
|
((buf[len] << 24) & 0x1F000000) +
|
|
((buf[len + 1] << 16) & 0xFF0000) +
|
|
((buf[len + 2] << 8) & 0xFF00) + (buf[len + 3] & 0xFF);
|
|
len += 4;
|
|
}
|
|
|
|
decoded_value = dest;
|
|
TTCN_logger.log(TTCN_DEBUG, "Decoded value is %u (encoded on %u octets)",
|
|
decoded_value, len);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* ============ Decoding wrappers for optional base types ============ */
|
|
|
|
/* Decodes a optional octetstring value */
|
|
int
|
|
Get_octetstring_opt(const unsigned char *buf, OPTIONAL < OCTETSTRING > &var,
|
|
bool hasvalue, int length)
|
|
{
|
|
if (hasvalue)
|
|
{
|
|
return Get_octetstring(buf, var(), length);
|
|
}
|
|
var = OMIT_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
/* Decodes a optional LIN1 value */
|
|
int
|
|
Get_LIN1_opt(const unsigned char *buf, OPTIONAL < LIN1 > &var, bool hasvalue)
|
|
{
|
|
if (hasvalue)
|
|
{
|
|
return Get_LIN1(buf, var());
|
|
}
|
|
var = OMIT_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
/* Decodes a optional LIN2_BO_LAST value */
|
|
int
|
|
Get_LIN2_BO_LAST_opt(const unsigned char *buf,
|
|
OPTIONAL < LIN2__BO__LAST > &var, bool hasvalue)
|
|
{
|
|
if (hasvalue)
|
|
{
|
|
return Get_LIN2_BO_LAST(buf, var());
|
|
}
|
|
var = OMIT_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
/* Decodes a optional LIN4_BO_LAST value */
|
|
int
|
|
Get_LIN4_BO_LAST_opt(const unsigned char *buf,
|
|
OPTIONAL < LIN4__BO__LAST > &var, bool hasvalue)
|
|
{
|
|
if (hasvalue)
|
|
{
|
|
return Get_LIN4_BO_LAST(buf, var());
|
|
}
|
|
var = OMIT_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
/* Decodes a optional SDVL value */
|
|
int
|
|
Get_SDVL_field_opt(const unsigned char *buf,
|
|
OPTIONAL < INTEGER > &var, bool hasvalue)
|
|
{
|
|
if (hasvalue)
|
|
{
|
|
return Get_SDVL_field(buf, var());
|
|
}
|
|
var = OMIT_VALUE;
|
|
return 0;
|
|
}
|
|
|
|
/* ============ Decoding functions for ROHC types ============ */
|
|
|
|
/* Returns the number of matching octets, that are the same as the passed
|
|
'octet'. */
|
|
int
|
|
Strip_leading_octet(const unsigned char *buf, int length, unsigned char octet)
|
|
{
|
|
int len = 0;
|
|
|
|
while ((buf[len] == octet) && (len < length))
|
|
len += 1;
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ROHC_Padding(const unsigned char *buf, int length,
|
|
OPTIONAL < Padding > &p_padding, ROHC__config & config)
|
|
{
|
|
int len = Strip_leading_octet(buf, length, 0xE0);
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (len > 0)
|
|
{
|
|
p_padding = OCTETSTRING(len, &(buf[0]));
|
|
Log_hexdump(buf, len);
|
|
}
|
|
else
|
|
p_padding = OMIT_VALUE;
|
|
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_CID(const unsigned char *buf, INT14b__BO__LAST & cid,
|
|
ROHC__config & config)
|
|
{
|
|
int len = 0;
|
|
int dec_cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (config.large__cid() == false)
|
|
{
|
|
if ((buf[len] & 0xF0) == 0xE0)
|
|
{
|
|
cid = buf[len] & 0x0F;
|
|
len += 1;
|
|
}
|
|
else
|
|
cid = 0;
|
|
}
|
|
else
|
|
{
|
|
len += Get_SDVL_field(&buf[len], cid);
|
|
}
|
|
|
|
dec_cid = cid;
|
|
TTCN_logger.log(TTCN_DEBUG, "Decoded CID = %u", dec_cid);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_feedback(const unsigned char *buf, Feedback__u & feedback,
|
|
ROHC__config & config)
|
|
{
|
|
int len = 0, fbsize = 0, cidlen;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 3) & 0x1F;
|
|
feedback.feedback__type() = BITSTRING(5, &ctemp);
|
|
feedback.code() = buf[len] & 0x07;
|
|
fbsize = feedback.code();
|
|
len += 1;
|
|
len += Get_LIN1_opt(&buf[len], feedback.size(), feedback.code() == 0);
|
|
if (feedback.size().ispresent())
|
|
{
|
|
fbsize = feedback.size()();
|
|
}
|
|
|
|
cidlen = Get_CID(&buf[len], feedback.feedback__data().cid(), config);
|
|
fbsize -= cidlen;
|
|
len += cidlen;
|
|
|
|
if (fbsize == 1) /* Feedback type 1 */
|
|
{
|
|
len += Get_octetstring(&buf[len],
|
|
feedback.feedback__data().feedback__type().
|
|
feedback1(), fbsize);
|
|
}
|
|
else /* Feedback type 2 */
|
|
{
|
|
int optnum = 0;
|
|
Feedback__opts fbopts;
|
|
Feedback2 feedback2;
|
|
|
|
feedback2.acktype() = (buf[len] >> 6) & 0x03;
|
|
feedback2.mode() = (buf[len] >> 4) & 0x03;
|
|
ctemp = buf[len] & 0x0F;
|
|
len += 1;
|
|
fbsize -= 1;
|
|
feedback2.sn() = ((ctemp << 8) & 0x0F00) + buf[len];
|
|
len += 1;
|
|
fbsize -= 1;
|
|
feedback2.feedback__opts() = OMIT_VALUE;
|
|
while (fbsize > 0)
|
|
{
|
|
fbopts[optnum].opt__type() = (buf[len] >> 4) & 0x0F;
|
|
fbopts[optnum].opt__len() = buf[len] & 0x0F;
|
|
len += 1;
|
|
fbsize -= 1;
|
|
if (fbopts[optnum].opt__len())
|
|
{
|
|
len += Get_octetstring(&buf[len], fbopts[optnum].opt__data(),
|
|
fbopts[optnum].opt__len());
|
|
fbsize -= fbopts[optnum].opt__len();
|
|
}
|
|
else
|
|
fbopts[optnum].opt__data() = OMIT_VALUE;
|
|
feedback2.feedback__opts() = fbopts;
|
|
optnum += 1;
|
|
}
|
|
|
|
feedback.feedback__data().feedback__type().feedback2() = feedback2;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ROHC_Feedback(const unsigned char *buf,
|
|
int length,
|
|
OPTIONAL < Feedback > &feedback, ROHC__config & config)
|
|
{
|
|
int len = 0, fbnum = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
feedback = OMIT_VALUE;
|
|
while (((buf[len] & 0xF8) == 0xF0) && (len < length))
|
|
{
|
|
len += Get_feedback(&buf[len], feedback()[fbnum], config);
|
|
fbnum++;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_XI_list(const unsigned char *buf,
|
|
OPTIONAL < XI__list > &xilist, int m,
|
|
const BITSTRING & ps_bit, int *itemnum,
|
|
OPTIONAL < BITSTRING > &padding)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (!m)
|
|
{
|
|
xilist = OMIT_VALUE;
|
|
padding = OMIT_VALUE;
|
|
return len;
|
|
}
|
|
|
|
if ((*ps_bit) == 1)
|
|
{
|
|
for (int num = 0; num < m; num++)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
xilist().xi__item8()[num].x__ind() = BITSTRING(1, &ctemp);
|
|
if (ctemp)
|
|
*itemnum += 1;
|
|
xilist().xi__item8()[num].index() = buf[len] & 0x7F;
|
|
len += 1;
|
|
}
|
|
padding = OMIT_VALUE;
|
|
}
|
|
else
|
|
{
|
|
int halfbyte = 0;
|
|
|
|
for (int num = 0; num < m; num++)
|
|
{
|
|
if (halfbyte)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
xilist().xi__item4()[num].x__ind() = BITSTRING(1, &ctemp);
|
|
if (ctemp)
|
|
*itemnum += 1;
|
|
xilist().xi__item4()[num].index() = buf[len] & 0x07;
|
|
len += 1;
|
|
}
|
|
else
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
xilist().xi__item4()[num].x__ind() = BITSTRING(1, &ctemp);
|
|
if (ctemp)
|
|
*itemnum += 1;
|
|
xilist().xi__item4()[num].index() = (buf[len] >> 4) & 0x07;
|
|
}
|
|
halfbyte = 1 - halfbyte; /* Invert the value */
|
|
}
|
|
/* Padding */
|
|
if (halfbyte == 1)
|
|
{
|
|
ctemp = buf[len] & 0x0F;
|
|
padding() = BITSTRING(4, &ctemp);
|
|
len += 1;
|
|
}
|
|
else
|
|
padding = OMIT_VALUE;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Item_list(const unsigned char *buf,
|
|
OPTIONAL < Item__list > &item_list, int n,
|
|
Item__list::union_selection_type selection,
|
|
t_dat *dat, int ip_idx)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (n == 0)
|
|
{
|
|
item_list = OMIT_VALUE;
|
|
Log_function_name_on_leave();
|
|
return len;
|
|
}
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "Expecting %u items", n);
|
|
|
|
/* Item list is an IP extension header list */
|
|
if (selection == Item__list::ALT_ip__item__list)
|
|
{
|
|
IP__Item__list & itlist = item_list().ip__item__list();
|
|
for (int num = 0; num < n; num++)
|
|
{
|
|
int headid = buf[len];
|
|
len += 1;
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "%uth item", num);
|
|
|
|
if (headid == c__ip__proto__ah)
|
|
{
|
|
AH__item & item = itlist[num].ah__item();
|
|
int payload_length, ah_data_len;
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "AH header found");
|
|
item.nexthead() = headid;
|
|
len += Get_LIN1(&buf[len], item.payload__len());
|
|
payload_length = item.payload__len();
|
|
ah_data_len = (item.payload__len() - 1) * 4;
|
|
len += Get_LIN2_BO_LAST(&buf[len], item.reserved());
|
|
len += Get_LIN4_BO_LAST(&buf[len], item.spi());
|
|
len += Get_LIN4_BO_LAST(&buf[len], item.sn());
|
|
len += Get_octetstring_opt(&buf[len], item.auth__data(),
|
|
item.payload__len() != 1, ah_data_len);
|
|
dat->context.ip__ctx()[ip_idx].ah__data__len() = ah_data_len;
|
|
dat->context.ip__ctx()[ip_idx].ah__present() = true;
|
|
// There is no compressed AH data after the base header
|
|
dat->compressed_ah_data_len[ip_idx] = 0;
|
|
TTCN_logger.log(TTCN_DEBUG,
|
|
"AH payload length is %d meaning %d octets",
|
|
payload_length, ah_data_len);
|
|
Log_hexdump(buf, len);
|
|
}
|
|
else if (headid == c__ip__proto__mine)
|
|
{
|
|
unsigned char ctemp;
|
|
MINE__item & item = itlist[num].mine__item();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "MINE header found");
|
|
item.protocol() = headid;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
item.s__bit() = BITSTRING(1, &ctemp);
|
|
item.reserved() = BITSTRING(7, &buf[len]);
|
|
len += 1;
|
|
len += Get_LIN2_BO_LAST(&buf[len], item.cksum());
|
|
len += Get_octetstring(&buf[len], item.dstaddr(), 4);
|
|
len += Get_octetstring_opt(&buf[len], item.srcaddr(),
|
|
*item.s__bit() == 1, 4);
|
|
Log_hexdump(buf, len);
|
|
}
|
|
else if (headid == c__ip__proto__esp)
|
|
{
|
|
ESP__item & item = itlist[num].esp__item();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "ESP header found");
|
|
item.nexthead() = headid;
|
|
len += Get_LIN4_BO_LAST(&buf[len], item.spi());
|
|
len += Get_LIN4_BO_LAST(&buf[len], item.sn());
|
|
|
|
dat->context.ip__ctx()[ip_idx].esp__present() = true;
|
|
Log_hexdump(buf, len);
|
|
}
|
|
else if (headid == c__ip__proto__gre2)
|
|
{
|
|
GRE__item & item = itlist[num].gre__item();
|
|
unsigned char ctemp;
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "GRE header found");
|
|
item.nexthead() = headid;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
item.C__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
item.reserved__1() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
item.K__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
item.S__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
item.reserved__2() = BITSTRING(1, &ctemp);
|
|
ctemp = buf[len] & 0x07;
|
|
item.version() = BITSTRING(3, &ctemp);
|
|
len += 1;
|
|
len += Get_LIN2_BO_LAST_opt(&buf[len], item.cksum(),
|
|
*item.C__bit() == 1);
|
|
len += Get_LIN4_BO_LAST_opt(&buf[len], item.key(),
|
|
*item.K__bit() == 1);
|
|
len += Get_LIN4_BO_LAST_opt(&buf[len], item.sn(), *item.S__bit() == 1);
|
|
|
|
dat->context.ip__ctx()[ip_idx].gre__cksum__present() = (*item.C__bit() == 1);
|
|
dat->context.ip__ctx()[ip_idx].gre__present() = true;
|
|
// There is no compressed GRE data after the base header
|
|
dat->ipx_gre_cksum_present[ip_idx] = false;
|
|
Log_hexdump(buf, len);
|
|
}
|
|
else /* Assuming IPv6 extension header */
|
|
/* TODO check: why only these were supported:
|
|
if (headid == 0 || headid == 43 || headid == 60) */
|
|
{
|
|
IPv6__ext__item & item = itlist[num].ipv6__ext__item();
|
|
int ext_len;
|
|
int ext_len_oct;
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "IPv6 header found (type %d)", headid);
|
|
item.nexthead() = headid;
|
|
len += Get_LIN1(&buf[len], item.hdr__ext__len());
|
|
ext_len_oct = item.hdr__ext__len();
|
|
ext_len = (item.hdr__ext__len() + 1) * 8;
|
|
TTCN_logger.log(TTCN_DEBUG,
|
|
"IPv6 extension length is %d meaning %d octets",
|
|
ext_len_oct, ext_len);
|
|
// 2 octets already been read
|
|
len += Get_octetstring(&buf[len], item.data(), ext_len - 2);
|
|
Log_hexdump(buf, len);
|
|
}
|
|
} /* for (num) */
|
|
}
|
|
else if (selection == Item__list::ALT_csrc__item__list)
|
|
{
|
|
for (int num = 0; num < n; num++)
|
|
{
|
|
TTCN_logger.log(TTCN_DEBUG, "%uth item", num);
|
|
|
|
len +=
|
|
Get_octetstring(&buf[len], item_list().csrc__item__list()[num], 4);
|
|
}
|
|
}
|
|
else if (selection == Item__list::ALT_raw__data)
|
|
{
|
|
/* TODO: RAW_data field is just a temporary hack for Profile4 tests */
|
|
RAW__data & itlist = item_list().raw__data();
|
|
|
|
for (int num = 0; num < n; num++)
|
|
{
|
|
int headid = char2int(buf[len]);
|
|
|
|
if (headid == 0 || headid == 43 || headid == 60)
|
|
{
|
|
int itemlimit = char2int(buf[len + 1]) + 1 * 8;
|
|
for (int itemlen = 0; itemlen < itemlimit; itemlen++)
|
|
{
|
|
if (itemlen == 0)
|
|
itlist[num] = OCTETSTRING(1, &buf[len]);
|
|
else
|
|
itlist[num] = itlist[num] + OCTETSTRING(1, &buf[len]);
|
|
len += 1;
|
|
}
|
|
}
|
|
else if (headid == 51)
|
|
{
|
|
int itemlimit = char2int(buf[len + 1]) + 1 * 8;
|
|
for (int itemlen = 0; itemlen < itemlimit; itemlen++)
|
|
{
|
|
if (itemlen == 0)
|
|
itlist[num] = OCTETSTRING(1, &buf[len]);
|
|
else
|
|
itlist[num] = itlist[num] + OCTETSTRING(1, &buf[len]);
|
|
len += 1;
|
|
}
|
|
}
|
|
else if (headid == 50)
|
|
{
|
|
for (int itemlen = 0; itemlen < 9; itemlen++)
|
|
{
|
|
if (itemlen == 0)
|
|
itlist[num] = OCTETSTRING(1, &buf[len]);
|
|
else
|
|
itlist[num] = itlist[num] + OCTETSTRING(1, &buf[len]);
|
|
len += 1;
|
|
}
|
|
}
|
|
else if (headid == 55 || headid == 47)
|
|
{
|
|
for (int itemlen = 0; itemlen < 13; itemlen++)
|
|
{
|
|
if (itemlen == 0)
|
|
itlist[num] = OCTETSTRING(1, &buf[len]);
|
|
else
|
|
itlist[num] = itlist[num] + OCTETSTRING(1, &buf[len]);
|
|
len += 1;
|
|
}
|
|
}
|
|
else
|
|
TTCN_logger.log(TTCN_WARNING,
|
|
"Unrecognized element in encoding type 0");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Log_not_implemented_union_field("Item_list", selection);
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Encoding_Type_0(Enc__Type__0 & enct0, const unsigned char *buf,
|
|
Item__list::union_selection_type selection,
|
|
t_dat *dat, int ip_idx)
|
|
{
|
|
unsigned char ctemp;
|
|
int itemnum = 0;
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
enct0.et() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
enct0.gp__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
enct0.ps__bit() = BITSTRING(1, &ctemp);
|
|
enct0.cc() = buf[len] & 0x0F;
|
|
len += 1;
|
|
len += Get_LIN1_opt(&buf[len], enct0.gen__id(), (*enct0.gp__bit()) == 1);
|
|
len += Get_XI_list(&buf[len], enct0.xi__list(),
|
|
enct0.cc(), enct0.ps__bit(), &itemnum, enct0.padding());
|
|
len += Get_Item_list(&buf[len], enct0.item__list(), itemnum, selection,
|
|
dat, ip_idx);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Encoding_Type_1(Enc__Type__1 & enct1, const unsigned char *buf,
|
|
Item__list::union_selection_type selection,
|
|
t_dat *dat, int ip_idx)
|
|
{
|
|
unsigned char ctemp;
|
|
int knum = 0, itemnum = 0, len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
enct1.et() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
enct1.gp__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
enct1.ps__bit() = BITSTRING(1, &ctemp);
|
|
enct1.xi1() = buf[len] & 0x0F;
|
|
len += 1;
|
|
len += Get_LIN1_opt(&buf[len], enct1.gen__id(), (*enct1.gp__bit()) == 1);
|
|
len += Get_LIN1(&buf[len], enct1.ref__id());
|
|
if ((buf[len] & 0x80) == 0) /* 1 octet insertion mask */
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
if (ShiftDownBit(buf[len], i) == 1)
|
|
knum++;
|
|
}
|
|
len += Get_octetstring(&buf[len], enct1.insbitmask(), 1);
|
|
}
|
|
else /* 2 octets insertion mask */
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
if (ShiftDownBit(buf[len], i) == 1)
|
|
knum++;
|
|
for (int i = 0; i < 8; i++)
|
|
if (ShiftDownBit(buf[len + 1], i) == 1)
|
|
knum++;
|
|
len += Get_octetstring(&buf[len], enct1.insbitmask(), 2);
|
|
}
|
|
|
|
/* Determine whether xi1 already contains the first index */
|
|
if ((*enct1.ps__bit()) == 0)
|
|
{
|
|
knum--;
|
|
}
|
|
len +=
|
|
Get_XI_list(&buf[len], enct1.xi__list(),
|
|
knum, enct1.ps__bit(), &itemnum, enct1.padding());
|
|
len += Get_Item_list(&buf[len], enct1.item__list(), itemnum, selection,
|
|
dat, ip_idx);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int
|
|
Get_Encoding_Type_2(Enc__Type__2 & enct2, const unsigned char *buf,
|
|
Item__list::union_selection_type selection)
|
|
{
|
|
unsigned char ctemp;
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
enct2.et() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
enct2.gp__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
enct2.res() = BITSTRING(1, &ctemp);
|
|
enct2.count() = buf[len] & 0x0F;
|
|
len += 1;
|
|
len += Get_LIN1_opt(&buf[len], enct2.gen__id(), (*enct2.gp__bit()) == 1);
|
|
len += Get_LIN1(&buf[len], enct2.ref__id());
|
|
if ((buf[len] & 0x80) == 0)
|
|
len += Get_octetstring(&buf[len], enct2.rembitmask(), 1);
|
|
else
|
|
len += Get_octetstring(&buf[len], enct2.rembitmask(), 2);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
|
|
int
|
|
Get_Encoding_Type_3(Enc__Type__3 & enct3, const unsigned char *buf,
|
|
Item__list::union_selection_type selection,
|
|
t_dat *dat, int ip_idx)
|
|
{
|
|
unsigned char ctemp;
|
|
int itemnum = 0;
|
|
int knum = 0;
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
enct3.et() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
enct3.gp__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
enct3.ps__bit() = BITSTRING(1, &ctemp);
|
|
enct3.xi1() = buf[len] & 0x0F;
|
|
len += 1;
|
|
len += Get_LIN1_opt(&buf[len], enct3.gen__id(), (*enct3.gp__bit()) == 1);
|
|
len += Get_LIN1(&buf[len], enct3.ref__id());
|
|
if ((buf[len] & 0x80) == 0)
|
|
len += Get_octetstring(&buf[len], enct3.rembitmask(), 1);
|
|
else
|
|
len += Get_octetstring(&buf[len], enct3.rembitmask(), 2);
|
|
|
|
if ((buf[len] & 0x80) == 0) /* 1 octet insertion mask */
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
{
|
|
if (ShiftDownBit(buf[len], i) == 1)
|
|
knum++;
|
|
}
|
|
len += Get_octetstring(&buf[len], enct3.insbitmask(), 1);
|
|
}
|
|
else /* 2 octets insertion mask */
|
|
{
|
|
for (int i = 0; i < 8; i++)
|
|
if (ShiftDownBit(buf[len], i) == 1)
|
|
knum++;
|
|
for (int i = 0; i < 8; i++)
|
|
if (ShiftDownBit(buf[len + 1], i) == 1)
|
|
knum++;
|
|
len += Get_octetstring(&buf[len], enct3.insbitmask(), 2);
|
|
}
|
|
|
|
/* Determine whether xi1 already contains the first index */
|
|
if ((*enct3.ps__bit()) == 0)
|
|
{
|
|
knum--;
|
|
}
|
|
len += Get_XI_list(&buf[len], enct3.xi__list(),
|
|
knum, enct3.ps__bit(), &itemnum, enct3.padding());
|
|
len += Get_Item_list(&buf[len], enct3.item__list(), itemnum, selection,
|
|
dat, ip_idx);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Compr_head_list(Compr__head__list & chl, const unsigned char *buf,
|
|
Item__list::union_selection_type selection,
|
|
t_dat *dat, int ip_idx)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if ((buf[len] & 0xC0) == 0)
|
|
len += Get_Encoding_Type_0(chl.enctype0(), &buf[len], selection,
|
|
dat, ip_idx);
|
|
else if ((buf[len] & 0xC0) == 0x40)
|
|
len += Get_Encoding_Type_1(chl.enctype1(), &buf[len], selection,
|
|
dat, ip_idx);
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
len += Get_Encoding_Type_2(chl.enctype2(), &buf[len], selection);
|
|
else
|
|
len += Get_Encoding_Type_3(chl.enctype3(), &buf[len], selection,
|
|
dat, ip_idx);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ipv4_dynamic(const unsigned char *buf, IPv4__Dynamic & chain,
|
|
t_dat *dat, int ip_level)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_LIN1(&buf[len], chain.tos());
|
|
len += Get_LIN1(&buf[len], chain.ttl());
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.identification());
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
chain.df__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
chain.rnd__bit() = BITSTRING(1, &ctemp);
|
|
dat->context.ip__ctx()[ip_level].rnd__bit() = BOOLEAN(ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
chain.nbo__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = buf[len] & 0x1F;
|
|
chain.reserved() = BITSTRING(5, &ctemp);
|
|
len += 1;
|
|
len += Get_Encoding_Type_0(chain.genextheadlist(),
|
|
&buf[len], Item__list::ALT_ip__item__list,
|
|
dat, ip_level);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ipv4_static(const unsigned char *buf, IPv4__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
chain.version() = (buf[len] >> 4) & 0x0F;
|
|
chain.reserved() = buf[len] & 0x0F;
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], chain.proto());
|
|
len += Get_octetstring(&buf[len], chain.srcaddr(), 4);
|
|
len += Get_octetstring(&buf[len], chain.dstaddr(), 4);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ipv6_static(const unsigned char *buf, IPv6__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
chain.version() = (buf[len] >> 4) & 0x0F;
|
|
chain.flowlabel() =
|
|
((buf[len] & 0x0F) << 16) + (buf[len + 1] << 8) + buf[len + 2];
|
|
len += 3;
|
|
len += Get_LIN1(&buf[len], chain.nexthead());
|
|
len += Get_octetstring(&buf[len], chain.srcaddr(), 16);
|
|
len += Get_octetstring(&buf[len], chain.dstaddr(), 16);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ipv6_dynamic(const unsigned char *buf, IPv6__Dynamic & chain,
|
|
t_dat *dat, int ip_level)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_LIN1(&buf[len], chain.trafficclass());
|
|
len += Get_LIN1(&buf[len], chain.hoplimit());
|
|
len += Get_Encoding_Type_0(chain.genextheadlist(), &buf[len],
|
|
Item__list::ALT_ip__item__list, dat, ip_level);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_udp_static(const unsigned char *buf, UDP__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.srcport());
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.dstport());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_udp_dynamic_wo_sn(const unsigned char *buf,
|
|
UDP__Dynamic & chain, t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.cksum());
|
|
if (chain.cksum() == 0)
|
|
{
|
|
/* Checksum value 0 means that no UDP checksum is present in the
|
|
forthcoming compressed packets. */
|
|
dat->context.udp__ctx().udp__cksum() = false;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_udp_dynamic_w_sn(const unsigned char *buf,
|
|
Profile2__UDP__Dynamic & chain, t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.cksum());
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.udp__sn());
|
|
if (chain.cksum() == 0)
|
|
{
|
|
/* Checksum value 0 means that no UDP checksum is present in the
|
|
forthcoming compressed packets. */
|
|
dat->context.udp__ctx().udp__cksum() = false;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_rtp_static(const unsigned char *buf, RTP__Static & chain)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_octetstring(&buf[len], chain.ssrc(), 4);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_rtp_dynamic(const unsigned char *buf, RTP__Dynamic & chain,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
chain.vfield() = (buf[len] >> 6) & 0x03;
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
chain.pbit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
chain.rxbit() = BITSTRING(1, &ctemp);
|
|
chain.ccfield() = buf[len] & 0x0F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
chain.mbit() = BITSTRING(1, &ctemp);
|
|
chain.ptfield() = buf[len] & 0x7F;
|
|
len += 1;
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.rtpseqnum());
|
|
len += Get_LIN4_BO_LAST(&buf[len], chain.rtpts());
|
|
len += Get_Encoding_Type_0(chain.gencsrclist(),
|
|
&buf[len], Item__list::ALT_csrc__item__list,
|
|
dat, 0);
|
|
if ((*chain.rxbit()) == 1)
|
|
{
|
|
Rx__Field & rxfield = chain.rx__field();
|
|
|
|
ctemp = (buf[len] >> 5) & 0x07;
|
|
rxfield.reserved() = BITSTRING(3, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
rxfield.xbit() = BITSTRING(1, &ctemp);
|
|
rxfield.mode() = (buf[len] >> 2) & 0x03;
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
rxfield.tisbit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
rxfield.tssbit() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
len += Get_SDVL_field_opt(&buf[len], chain.ts__stride(),
|
|
*rxfield.tssbit() == 1);
|
|
len += Get_SDVL_field_opt(&buf[len], chain.time__stride(),
|
|
*rxfield.tisbit() == 1);
|
|
}
|
|
else
|
|
{
|
|
chain.rx__field() = OMIT_VALUE;
|
|
chain.ts__stride() = OMIT_VALUE;
|
|
chain.time__stride() = OMIT_VALUE;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* Reads the compressed IP-ID field after the base header */
|
|
int
|
|
Get_IP_ID_compressed_opt(unsigned char *buf,
|
|
OPTIONAL < LIN2__BO__LAST > &field,
|
|
t_dat *dat, int ip_level)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (dat->context.pkt() != Packet__type::IR && dat->context.pkt() != Packet__type::IR__DYN)
|
|
{
|
|
int ip_idx = getIPidx(dat, ip_level);
|
|
TTCN_logger.log(TTCN_DEBUG, "iplevel = %d, ip_idx = %d", ip_level, ip_idx);
|
|
|
|
if (ip_idx >= 0)
|
|
{
|
|
if (dat->context.ip__ctx()[ip_idx].rnd__bit())
|
|
len += Get_LIN2_BO_LAST(&buf[len], field());
|
|
else
|
|
field = OMIT_VALUE;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* Reads the AH data field after the base header */
|
|
int
|
|
Get_AH_data_opt(unsigned char *buf,
|
|
OPTIONAL < OCTETSTRING > &field, t_dat *dat,
|
|
int ip_level)
|
|
{
|
|
int len = 0;
|
|
int ip_idx = getIPidx(dat, ip_level);
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "iplevel = %d, ip_idx = %d", ip_level, ip_idx);
|
|
|
|
/* AH present */
|
|
if (ip_idx >= 0)
|
|
{
|
|
int ah_len = dat->compressed_ah_data_len[ip_idx];
|
|
|
|
if (ah_len > 0)
|
|
len += Get_octetstring(&buf[len], field(), ah_len);
|
|
else
|
|
field = OMIT_VALUE;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* Reads the GRE checksum field after the base header */
|
|
int
|
|
Get_GRE_cksum_opt(unsigned char *buf,
|
|
OPTIONAL < LIN2__BO__LAST > &field, t_dat *dat,
|
|
int ip_level)
|
|
{
|
|
int len = 0;
|
|
int ip_idx = getIPidx(dat, ip_level);
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "iplevel = %d, ip_idx = %d", ip_level, ip_idx);
|
|
|
|
/* Compressed packet and GRE present */
|
|
if (ip_idx >= 0)
|
|
{
|
|
if (dat->ipx_gre_cksum_present[ip_idx])
|
|
len += Get_LIN2_BO_LAST(&buf[len], field());
|
|
else
|
|
field = OMIT_VALUE;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
/* Reads the UDP checksum field after the base header */
|
|
int
|
|
Get_UDP_cksum_opt(unsigned char *buf,
|
|
OPTIONAL < LIN2__BO__LAST > &field, t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (dat->context.pkt() != Packet__type::IR && dat->context.pkt() != Packet__type::IR__DYN &&
|
|
dat->context.udp__ctx().udp__cksum())
|
|
{
|
|
len += Get_LIN2_BO_LAST(&buf[len], field());
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_AEGSeqnum_opt(OPTIONAL < AEGSeqnum > &seqn, const unsigned char *buf,
|
|
bool hasvalue)
|
|
{
|
|
unsigned char ctemp;
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
if ((buf[len] & 0x80) == 0)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
seqn().short__form().ind() = BITSTRING(1, &ctemp);
|
|
seqn().short__form().lsb__of__seqnum() = buf[len] & 0x7F;
|
|
len += 1;
|
|
}
|
|
else
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
seqn().long__form().ind() = BITSTRING(1, &ctemp);
|
|
seqn().long__form().lsb__of__seqnum() =
|
|
((buf[len] & 0x7F) << 24) +
|
|
(buf[len + 1] << 16) + (buf[len + 2] << 8) + buf[len + 3];
|
|
len += 4;
|
|
}
|
|
}
|
|
else
|
|
seqn = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Inner_IP_flags_opt(unsigned char *buf,
|
|
OPTIONAL < Inner__IP__flags > &field,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
int ip_idx = getIPidx(dat, Inner_IP);
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "iplevel = %d, ip_idx = %d", Inner_IP, ip_idx);
|
|
|
|
if (hasvalue)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
field().tos() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
field().ttl() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
field().df() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
field().pr() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
field().ipx() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 2);
|
|
field().nbo() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
field().rnd__bit() = BITSTRING(1, &ctemp);
|
|
dat->context.ip__ctx()[ip_idx].rnd__bit() = BOOLEAN(ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
field().ip2__bit() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Outer_IP_flags_opt(unsigned char *buf,
|
|
OPTIONAL < Outer__IP__flags > &field,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
int ip_idx = getIPidx(dat, Outer_IP);
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "iplevel = %d, ip_idx = %d", Outer_IP, ip_idx);
|
|
|
|
if (hasvalue)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
field().tos2() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
field().ttl2() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
field().df2() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
field().pr2() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
field().ipx2() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 2);
|
|
field().nbo2() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
field().rnd2() = BITSTRING(1, &ctemp);
|
|
dat->context.ip__ctx()[ip_idx].rnd__bit() = BOOLEAN(ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
field().i2__bit() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_ipx_headers_opt(unsigned char *buf, OPTIONAL < IP__Ext__heads > &field,
|
|
t_dat *dat, bool hasvalue, int ip_idx)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "present = %d, ip_idx = %d", hasvalue, ip_idx);
|
|
|
|
if (hasvalue)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
field().cl() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
field().aseq() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
field().eseq() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
field().gseq() = BITSTRING(1, &ctemp);
|
|
ctemp = buf[len] & 0x0F;
|
|
field().res() = BITSTRING(4, &ctemp);
|
|
len += 1;
|
|
|
|
len +=
|
|
Get_AEGSeqnum_opt(field().ah__seq(), &buf[len], *field().aseq() == 1);
|
|
len +=
|
|
Get_AEGSeqnum_opt(field().esp__seq(), &buf[len], *field().eseq() == 1);
|
|
len +=
|
|
Get_AEGSeqnum_opt(field().gre__seq(), &buf[len], *field().gseq() == 1);
|
|
|
|
if (*field().cl() == 1)
|
|
{
|
|
len += Get_Compr_head_list(field().compr__head__list(), &buf[len],
|
|
Item__list::ALT_ip__item__list,
|
|
dat, ip_idx);
|
|
}
|
|
else
|
|
field().compr__head__list() = OMIT_VALUE;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Inner_IP_fields_opt(unsigned char *buf,
|
|
OPTIONAL < Inner__IP__fields > &field,
|
|
OPTIONAL < Inner__IP__flags > &flags,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
len += Get_LIN1_opt(&buf[len], field().tos(), (*flags().tos()) == 1);
|
|
len += Get_LIN1_opt(&buf[len], field().ttl(), (*flags().ttl()) == 1);
|
|
len += Get_LIN1_opt(&buf[len], field().proto(), (*flags().pr()) == 1);
|
|
len += Get_ipx_headers_opt(&buf[len], field().ext__heads(), dat,
|
|
(*flags().ipx()) == 1, getIPidx(dat, Inner_IP));
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Outer_IP_fields_opt(unsigned char *buf,
|
|
OPTIONAL < Outer__IP__fields > &field,
|
|
OPTIONAL < Outer__IP__flags > &flags,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
len += Get_LIN1_opt(&buf[len], field().tos(), (*flags().tos2()) == 1);
|
|
len += Get_LIN1_opt(&buf[len], field().ttl(), (*flags().ttl2()) == 1);
|
|
len += Get_LIN1_opt(&buf[len], field().proto(), (*flags().pr2()) == 1);
|
|
len += Get_ipx_headers_opt(&buf[len], field().ext__heads(), dat,
|
|
(*flags().ipx2()) == 1, getIPidx(dat, Outer_IP));
|
|
len += Get_LIN2_BO_LAST_opt(&buf[len], field().ip__id(),
|
|
(*flags().i2__bit()) == 1);
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_RTP_flags_fields_opt(unsigned char *buf,
|
|
OPTIONAL < RTP__flags__fields > &field,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
field().mode() = (buf[len] >> 6) & 0x03;
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
field().r__pt() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
field().m__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
field().r__x() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 2);
|
|
field().csrc() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
field().tss() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
field().tis() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
|
|
if (*field().r__pt() == 1)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
field().flags()().r__p() = BITSTRING(1, &ctemp);
|
|
field().flags()().rtp__pt() = buf[len] & 0x7F;
|
|
len += 1;
|
|
}
|
|
else
|
|
field().flags() = OMIT_VALUE;
|
|
|
|
if (*field().csrc() == 1)
|
|
{
|
|
len += Get_Compr_head_list(field().csrc__list(),
|
|
&buf[len], Item__list::ALT_csrc__item__list,
|
|
dat, 0);
|
|
}
|
|
else
|
|
field().csrc__list() = OMIT_VALUE;
|
|
|
|
len += Get_SDVL_field_opt(&buf[len], field().ts__stride(),
|
|
*field().tss() == 1);
|
|
len += Get_SDVL_field_opt(&buf[len], field().time__stride(),
|
|
*field().tis() == 1);
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile0_ROHC_Header(unsigned char *buf, t_dat *dat, int length,
|
|
Profile0__headers & p_header, int cid)
|
|
{
|
|
unsigned char ctemp;
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (isIR(buf[len]))
|
|
{
|
|
Profile0__IR__packet & bhead = p_header.ir();
|
|
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 1) & 0x7F;
|
|
bhead.type__ind() = BITSTRING(7, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
bhead.d() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
Get_octetstring(&buf[len], bhead.orig__packet(), length - len);
|
|
len = length;
|
|
}
|
|
else
|
|
{
|
|
Profile0__normal__packet & bhead = p_header.normal();
|
|
bhead.cid() = cid;
|
|
Get_octetstring(&buf[len], bhead.orig__packet(), length - len);
|
|
len = length;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_Dynamic_Chain(Dynamic__Chain & dynch,
|
|
const unsigned char *buf, t_dat *dat)
|
|
{
|
|
int len = 0, num;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (num = 0; num < dat->context.ip__ctx().size_of(); num++)
|
|
{
|
|
if (dat->context.ip__ctx()[num].version() == 4)
|
|
{
|
|
len += Get_ipv4_dynamic(&buf[len], dynch[num].ipv4__dyn(), dat, num);
|
|
}
|
|
else if (dat->context.ip__ctx()[num].version() == 6)
|
|
{
|
|
len += Get_ipv6_dynamic(&buf[len], dynch[num].ipv6__dyn(), dat, num);
|
|
}
|
|
else
|
|
{
|
|
int ipver = dat->context.ip__ctx()[num].version();
|
|
TTCN_error("Invalid IP version %u on level %d", ipver, num);
|
|
}
|
|
}
|
|
|
|
num = dynch.size_of();
|
|
len += Get_udp_dynamic_wo_sn(&buf[len], dynch[num].udp__dyn(), dat);
|
|
|
|
num = dynch.size_of();
|
|
len += Get_rtp_dynamic(&buf[len], dynch[num].rtp__dyn(), dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_Static_Chain(unsigned char *buf, Static__Chain & chain,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0, num = 0, nextheader = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
while (nextheader != c__ip__proto__udp)
|
|
{
|
|
if (((buf[len] >> 4) & 0x0F) == 4)
|
|
{
|
|
initIPcontext(dat, num, 4);
|
|
len += Get_ipv4_static(&buf[len], chain[num].ipv4__stat());
|
|
nextheader = chain[num].ipv4__stat().proto();
|
|
}
|
|
else if (((buf[len] >> 4) & 0x0F) == 6)
|
|
{
|
|
initIPcontext(dat, num, 6);
|
|
len += Get_ipv6_static(&buf[len], chain[num].ipv6__stat());
|
|
nextheader = chain[num].ipv6__stat().nexthead();
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Invalid IP version %u on level %u (nextheader = %d)",
|
|
buf[len], num, nextheader);
|
|
}
|
|
num += 1;
|
|
}
|
|
|
|
len += Get_udp_static(&buf[len], chain[num].udp__stat());
|
|
num += 1;
|
|
|
|
len += Get_rtp_static(&buf[len], chain[num].rtp__stat());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_extension0(unsigned char *buf, Extension0 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ext.sn() = (buf[len] >> 3) & 0x07;
|
|
ext.plust() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_extension1(unsigned char *buf, Extension1 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ext.sn() = (buf[len] >> 3) & 0x07;
|
|
ext.plust() = buf[len] & 0x07;
|
|
len += 1;
|
|
ext.minust() = buf[len];
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_extension2(unsigned char *buf, Extension2 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ext.sn() = (buf[len] >> 3) & 0x07;
|
|
ext.plust() = ((buf[len] & 0x07) << 8) + (buf[len + 1] & 0xFF);
|
|
len += 2;
|
|
ext.minust() = buf[len];
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_extension3(unsigned char *buf, Extension3 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
int ts_length = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
ext.s__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
ext.r__ts__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
ext.tsc__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 2);
|
|
ext.i__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
ext.ip__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
ext.rtp__bit() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
|
|
len += Get_Inner_IP_flags_opt(&buf[len], ext.inner__ip__flags(),
|
|
dat, *ext.ip__bit() == 1);
|
|
|
|
len += Get_Outer_IP_flags_opt(&buf[len], ext.outer__ip__flags(), dat,
|
|
(ext.inner__ip__flags().ispresent() &&
|
|
(*ext.inner__ip__flags()().ip2__bit()) == 1));
|
|
|
|
len += Get_LIN1_opt(&buf[len], ext.sn(), *ext.s__bit() == 1);
|
|
ts_length = Get_SDVL_field_opt(&buf[len], ext.ts(), *ext.r__ts__bit() == 1);
|
|
if (ts_length > 0)
|
|
{
|
|
ext.ts__length()() = ts_length;
|
|
}
|
|
else
|
|
{
|
|
ext.ts__length() = OMIT_VALUE;
|
|
}
|
|
len += ts_length;
|
|
len += Get_Inner_IP_fields_opt(&buf[len], ext.inner__ip__hdr(),
|
|
ext.inner__ip__flags(), dat,
|
|
*ext.ip__bit() == 1);
|
|
|
|
len += Get_LIN2_BO_LAST_opt(&buf[len], ext.ip__id(), *ext.i__bit() == 1);
|
|
len += Get_Outer_IP_fields_opt(&buf[len], ext.outer__ip__hdr(),
|
|
ext.outer__ip__flags(), dat,
|
|
(ext.inner__ip__flags().ispresent() &&
|
|
(*ext.inner__ip__flags()().ip2__bit()) == 1));
|
|
|
|
len += Get_RTP_flags_fields_opt(&buf[len], ext.rtp__fl__fi(), dat,
|
|
*ext.rtp__bit() == 1);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_extensions_opt(unsigned char *buf,
|
|
OPTIONAL < Profile1__Extension > &ext,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
if ((buf[len] & 0xC0) == 0)
|
|
{
|
|
len += Get_Profile1_extension0(&buf[len], ext().ext0(), dat);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x40)
|
|
{
|
|
len += Get_Profile1_extension1(&buf[len], ext().ext1(), dat);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
len += Get_Profile1_extension2(&buf[len], ext().ext2(), dat);
|
|
}
|
|
else /* if ((buf[len] & 0xC0) == 0xC0) */
|
|
{
|
|
len += Get_Profile1_extension3(&buf[len], ext().ext3(), dat);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ext = OMIT_VALUE;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_ir(unsigned char *buf, Profile1__IR__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::IR);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 1) & 0x7F;
|
|
bhead.type__ind() = BITSTRING(7, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
bhead.d() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
|
|
len += Get_Profile1_Static_Chain(&buf[len], bhead.stat__chain(), dat);
|
|
|
|
if (*bhead.d() == 1)
|
|
len += Get_Profile1_Dynamic_Chain(bhead.dyn__chain(), &buf[len], dat);
|
|
else
|
|
bhead.dyn__chain() = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_irdyn(unsigned char *buf,
|
|
Profile1__IR__DYN__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::IR__DYN);
|
|
bhead.cid() = cid;
|
|
bhead.type__ind() = BITSTRING(8, &buf[len]);
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
|
|
len += Get_Profile1_Dynamic_Chain(bhead.dyn__chain(), &buf[len], dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_r0(unsigned char *buf,
|
|
Profile1__R__0__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__0);
|
|
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_r0crc(unsigned char *buf,
|
|
Profile1__R__0__CRC__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__0__CRC);
|
|
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
ctemp = (buf[len] << 1) & 0x7E;
|
|
len += 1;
|
|
ctemp += ShiftDownBit(buf[len], 7);
|
|
bhead.sn() = ctemp;
|
|
bhead.crc() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uo0(unsigned char *buf,
|
|
Profile1__UO__0__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UO__0);
|
|
bhead.cid() = cid;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.type__ind() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = (buf[len] >> 3) & 0x0F;
|
|
bhead.crc() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_r1(unsigned char *buf,
|
|
Profile1__R__1__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__1);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ts() = buf[len] & 0x3F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext, dat,
|
|
*bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_r1_id(unsigned char *buf,
|
|
Profile1__R__1__ID__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__1__ID);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
bhead.t__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ip__id() = buf[len] & 0x1F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext, dat,
|
|
*bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_r1_ts(unsigned char *buf,
|
|
Profile1__R__1__TS__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__1__TS);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
bhead.t__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ts() = buf[len] & 0x1F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext, dat,
|
|
*bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uo1(unsigned char *buf,
|
|
Profile1__UO__1__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UO__1);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.ts() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = (buf[len] >> 3) & 0x0F;
|
|
bhead.crc() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uo1_id(unsigned char *buf,
|
|
Profile1__UO__1__ID__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UO__1__ID);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
bhead.t__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ip__id() = buf[len] & 0x1F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = (buf[len] >> 3) & 0x0F;
|
|
bhead.crc() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uo1_ts(unsigned char *buf,
|
|
Profile1__UO__1__TS__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UO__1__TS);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
bhead.t__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ts() = buf[len] & 0x1F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = (buf[len] >> 3) & 0x0F;
|
|
bhead.crc() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uor2(unsigned char *buf,
|
|
Profile1__UOR__2__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UOR__2);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 5) & 0x07;
|
|
bhead.type__ind() = BITSTRING(3, &ctemp);
|
|
ctemp = (buf[len] & 0x1F) << 1;
|
|
len += 1;
|
|
ctemp += ShiftDownBit(buf[len], 7);
|
|
bhead.ts() = ctemp;
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.crc() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uor2_id(unsigned char *buf,
|
|
Profile1__UOR__2__ID__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > & ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UOR__2__ID);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 5) & 0x07;
|
|
bhead.type__ind() = BITSTRING(3, &ctemp);
|
|
bhead.ip__id() = buf[len] & 0x1F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.t__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.crc() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header_uor2_ts(unsigned char *buf,
|
|
Profile1__UOR__2__TS__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile1__Extension > & ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UOR__2__TS);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 5) & 0x07;
|
|
bhead.type__ind() = BITSTRING(3, &ctemp);
|
|
bhead.ts() = buf[len] & 0x1F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.t__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
bhead.m__bit() = BITSTRING(1, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.crc() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile1_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile1_ROHC_Header(unsigned char *buf, t_dat *dat, int length,
|
|
Profile1__headers & hdr, int cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (isIR(buf[len]))
|
|
{
|
|
len += Get_Profile1_ROHC_Header_ir(&buf[len],
|
|
hdr.base__header().ir(), dat, cid);
|
|
}
|
|
else if (isIRDYN(buf[len]))
|
|
{
|
|
len += Get_Profile1_ROHC_Header_irdyn(&buf[len],
|
|
hdr.base__header().ir__dyn(),
|
|
dat, cid);
|
|
}
|
|
else if (isUOR2(buf[len]))
|
|
{
|
|
if (isAnyIPv4RNDunset(dat))
|
|
{
|
|
if (buf[len + 1] & 0x80) // T = 1
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uor2_ts(&buf[len],
|
|
hdr.base__header().
|
|
uor__2__ts(), dat, cid,
|
|
hdr.ext());
|
|
}
|
|
else // T = 0
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uor2_id(&buf[len],
|
|
hdr.base__header().
|
|
uor__2__id(), dat, cid,
|
|
hdr.ext());
|
|
}
|
|
}
|
|
else // at least one RND is unset
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uor2(&buf[len],
|
|
hdr.base__header().uor__2(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
}
|
|
else if (dat->context.mode() == ROHC_mode_R)
|
|
{
|
|
if ((buf[len] & 0xC0) == 0)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r0(&buf[len],
|
|
hdr.base__header().r__0(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x40)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r0crc(&buf[len],
|
|
hdr.base__header().r__0__crc(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80) // PT-1
|
|
{
|
|
if (isAnyIPv4RNDunset(dat))
|
|
{
|
|
if (buf[len + 1] & 0x20) // T = 1
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r1_ts(&buf[len],
|
|
hdr.base__header().r__1__ts(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
else // T = 0
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r1_id(&buf[len],
|
|
hdr.base__header().r__1__id(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
}
|
|
else // at least one RND is unset
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r1(&buf[len],
|
|
hdr.base__header().r__1(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
}
|
|
}
|
|
else if (dat->context.mode() != ROHC_mode_R) // U-O modes
|
|
{
|
|
if ((buf[len] & 0x80) == 0)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uo0(&buf[len],
|
|
hdr.base__header().uo__0(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80) // PT-1
|
|
{
|
|
if (isAnyIPv4RNDunset(dat))
|
|
{
|
|
if (buf[len] & 0x20) // T = 1
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uo1_ts(&buf[len],
|
|
hdr.base__header().uo__1__ts(),
|
|
dat, cid);
|
|
}
|
|
else // T = 0
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uo1_id(&buf[len],
|
|
hdr.base__header().uo__1__id(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
}
|
|
else // at least one RND is unset
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uo1(&buf[len],
|
|
hdr.base__header().uo__1(),
|
|
dat, cid);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!hdr.ext().is_bound())
|
|
hdr.ext() = OMIT_VALUE;
|
|
len += Get_IP_ID_compressed_opt(&buf[len], hdr.ip__id__outer(),
|
|
dat, Outer_IP);
|
|
len += Get_AH_data_opt(&buf[len], hdr.ah__outer(), dat, Outer_IP);
|
|
len += Get_GRE_cksum_opt(&buf[len], hdr.gre__cksum1(), dat, Outer_IP);
|
|
len += Get_IP_ID_compressed_opt(&buf[len], hdr.ip__id__inner(),
|
|
dat, Inner_IP);
|
|
len += Get_AH_data_opt(&buf[len], hdr.ah__inner(), dat, Inner_IP);
|
|
len += Get_GRE_cksum_opt(&buf[len], hdr.gre__cksum2(), dat, Inner_IP);
|
|
len += Get_UDP_cksum_opt(&buf[len], hdr.udp__cksum(), dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
} /* Get_Profile1_ROHC_Header */
|
|
|
|
int
|
|
Get_Profile2_Dynamic_Chain(Profile2__Dynamic__Chain & dynch,
|
|
const unsigned char *buf, t_dat *dat)
|
|
{
|
|
int len = 0, num;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (num = 0; num < dat->context.ip__ctx().size_of(); num++)
|
|
{
|
|
if (dat->context.ip__ctx()[num].version() == 4)
|
|
{
|
|
len += Get_ipv4_dynamic(&buf[len], dynch[num].ipv4__dyn(), dat, num);
|
|
}
|
|
else if (dat->context.ip__ctx()[num].version() == 6)
|
|
{
|
|
len += Get_ipv6_dynamic(&buf[len], dynch[num].ipv6__dyn(), dat, num);
|
|
}
|
|
else
|
|
{
|
|
int ipver = dat->context.ip__ctx()[num].version();
|
|
TTCN_error("Invalid IP version %u on level %d", ipver, num);
|
|
}
|
|
}
|
|
|
|
num = dynch.size_of();
|
|
len += Get_udp_dynamic_w_sn(&buf[len], dynch[num].udp__dyn(), dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_extension0(unsigned char *buf, Profile2__Extension0 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ext.sn() = (buf[len] >> 3) & 0x07;
|
|
ext.ip__id() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_extension1(unsigned char *buf, Profile2__Extension1 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ext.sn() = (buf[len] >> 3) & 0x07;
|
|
ext.ip__id() = ((buf[len] & 0x07) << 8) + (buf[len + 1] & 0xFF);
|
|
len += 2;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_extension2(unsigned char *buf, Profile2__Extension2 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ext.sn() = (buf[len] >> 3) & 0x07;
|
|
ext.ip__id2() = ((buf[len] & 0x07) << 8) + (buf[len + 1] & 0xFF);
|
|
len += 2;
|
|
ext.ip__id() = buf[len];
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_Inner_IP_flags_opt(unsigned char *buf,
|
|
OPTIONAL < Profile2__Inner__IP__flags > &field,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
field().tos() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
field().ttl() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
field().df() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
field().pr() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 3);
|
|
field().ipx() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 2);
|
|
field().nbo() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
field().rnd__bit() = BITSTRING(1, &ctemp);
|
|
dat->context.ip__ctx()[getIPidx(dat, Inner_IP)].rnd__bit() = BOOLEAN(ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
field().reserved() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_Inner_IP_fields_opt(unsigned char *buf,
|
|
OPTIONAL < Inner__IP__fields > &field,
|
|
OPTIONAL < Profile2__Inner__IP__flags >
|
|
&flags, t_dat *dat,
|
|
bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
len += Get_LIN1_opt(&buf[len], field().tos(), (*flags().tos()) == 1);
|
|
len += Get_LIN1_opt(&buf[len], field().ttl(), (*flags().ttl()) == 1);
|
|
len += Get_LIN1_opt(&buf[len], field().proto(), (*flags().pr()) == 1);
|
|
len += Get_ipx_headers_opt(&buf[len], field().ext__heads(), dat,
|
|
(*flags().ipx()) == 1, getIPidx(dat, Inner_IP));
|
|
}
|
|
else
|
|
field = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_extension3(unsigned char *buf, Profile2__Extension3 & ext,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Profile2__Inner__IP__flags inipflags;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
ext.ext__type() = BITSTRING(2, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
ext.s__bit() = BITSTRING(1, &ctemp);
|
|
ext.mode() = (buf[len] >> 3) & 0x03;
|
|
ctemp = ShiftDownBit(buf[len], 2);
|
|
ext.i__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 1);
|
|
ext.ip__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
ext.ip2__bit() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
|
|
len +=
|
|
Get_Profile2_Inner_IP_flags_opt(&buf[len], ext.inner__ip__flags(),
|
|
dat, *ext.ip__bit() == 1);
|
|
|
|
len += Get_Outer_IP_flags_opt(&buf[len], ext.outer__ip__flags(), dat,
|
|
*ext.ip2__bit() == 1);
|
|
|
|
len += Get_LIN1_opt(&buf[len], ext.sn(), *ext.s__bit() == 1);
|
|
|
|
len += Get_Profile2_Inner_IP_fields_opt(&buf[len], ext.inner__ip__hdr(),
|
|
ext.inner__ip__flags(), dat,
|
|
*ext.ip__bit() == 1);
|
|
|
|
len += Get_LIN2_BO_LAST_opt(&buf[len], ext.ip__id(), *ext.i__bit() == 1);
|
|
|
|
len += Get_Outer_IP_fields_opt(&buf[len], ext.outer__ip__hdr(),
|
|
ext.outer__ip__flags(), dat,
|
|
*ext.ip2__bit() == 1);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_extensions_opt(unsigned char *buf,
|
|
OPTIONAL < Profile2__Extension > &ext,
|
|
t_dat *dat, bool hasvalue)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (hasvalue)
|
|
{
|
|
if ((buf[len] & 0xC0) == 0)
|
|
{
|
|
len += Get_Profile2_extension0(&buf[len], ext().ext0(), dat);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x40)
|
|
{
|
|
len += Get_Profile2_extension1(&buf[len], ext().ext1(), dat);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
len += Get_Profile2_extension2(&buf[len], ext().ext2(), dat);
|
|
}
|
|
else /* if ((buf[len] & 0xC0) == 0xC0) */
|
|
{
|
|
len += Get_Profile2_extension3(&buf[len], ext().ext3(), dat);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
ext = OMIT_VALUE;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_Static_Chain(unsigned char *buf, Profile2__Static__Chain & chain,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0, num = 0, nextheader = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
while (nextheader != c__ip__proto__udp)
|
|
{
|
|
if (((buf[len] >> 4) & 0x0F) == 4)
|
|
{
|
|
initIPcontext(dat, num, 4);
|
|
len += Get_ipv4_static(&buf[len], chain[num].ipv4__stat());
|
|
nextheader = chain[num].ipv4__stat().proto();
|
|
}
|
|
else if (((buf[len] >> 4) & 0x0F) == 6)
|
|
{
|
|
initIPcontext(dat, num, 6);
|
|
len += Get_ipv6_static(&buf[len], chain[num].ipv6__stat());
|
|
nextheader = chain[num].ipv6__stat().nexthead();
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Invalid IP version %u on level %u", buf[len], num);
|
|
}
|
|
num += 1;
|
|
}
|
|
|
|
len += Get_udp_static(&buf[len], chain[num].udp__stat());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_ROHC_Header_ir(unsigned char *buf, Profile2__IR__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::IR);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 1) & 0x7F;
|
|
bhead.type__ind() = BITSTRING(7, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
bhead.d() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
|
|
len += Get_Profile2_Static_Chain(&buf[len], bhead.stat__chain(), dat);
|
|
|
|
if (*bhead.d() == 1)
|
|
len += Get_Profile2_Dynamic_Chain(bhead.dyn__chain(), &buf[len], dat);
|
|
else
|
|
bhead.dyn__chain() = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_ROHC_Header_irdyn(unsigned char *buf,
|
|
Profile2__IR__DYN__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::IR__DYN);
|
|
bhead.cid() = cid;
|
|
bhead.type__ind() = BITSTRING(8, &buf[len]);
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
|
|
len += Get_Profile2_Dynamic_Chain(bhead.dyn__chain(), &buf[len], dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_ROHC_Header_r1(unsigned char *buf,
|
|
Profile2__R__1__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile2__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__1);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ip__id() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile2_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_ROHC_Header_uo1(unsigned char *buf,
|
|
Profile2__UO__1__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UO__1);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.ip__id() = buf[len] & 0x3F;
|
|
len += 1;
|
|
bhead.sn() = (buf[len] >> 3) & 0x1F;
|
|
bhead.crc() = buf[len] & 0x07;
|
|
len += 1;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_ROHC_Header_uor2(unsigned char *buf,
|
|
Profile2__UOR__2__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile2__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UOR__2);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 5) & 0x07;
|
|
bhead.type__ind() = BITSTRING(3, &ctemp);
|
|
bhead.sn() = buf[len] & 0x1F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.crc() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile2_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile2_ROHC_Header(unsigned char *buf, int length,
|
|
Profile2__headers & hdr,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (isIR(buf[len]))
|
|
{
|
|
len += Get_Profile2_ROHC_Header_ir(&buf[len],
|
|
hdr.base__header().ir(), dat, cid);
|
|
}
|
|
else if (isIRDYN(buf[len]))
|
|
{
|
|
len += Get_Profile2_ROHC_Header_irdyn(&buf[len],
|
|
hdr.base__header().ir__dyn(),
|
|
dat, cid);
|
|
}
|
|
else if (isUOR2(buf[len]))
|
|
{
|
|
len += Get_Profile2_ROHC_Header_uor2(&buf[len],
|
|
hdr.base__header().uor__2(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
else if (dat->context.mode() == ROHC_mode_R)
|
|
{
|
|
if ((buf[len] & 0xC0) == 0)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r0(&buf[len],
|
|
hdr.base__header().r__0(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x40)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r0crc(&buf[len],
|
|
hdr.base__header().r__0__crc(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
len += Get_Profile2_ROHC_Header_r1(&buf[len],
|
|
hdr.base__header().r__1(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Unknown compressed packet (R mode) (0x%02x)", buf[len]);
|
|
}
|
|
}
|
|
else if (dat->context.mode() != ROHC_mode_R) // U-O modes
|
|
{
|
|
if ((buf[len] & 0x80) == 0)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uo0(&buf[len],
|
|
hdr.base__header().uo__0(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
len += Get_Profile2_ROHC_Header_uo1(&buf[len],
|
|
hdr.base__header().uo__1(),
|
|
dat, cid);
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Unknown compressed packet (U-O mode) (0x%02x)", buf[len]);
|
|
}
|
|
}
|
|
|
|
if (!hdr.ext().is_bound())
|
|
hdr.ext() = OMIT_VALUE;
|
|
len += Get_IP_ID_compressed_opt(&buf[len], hdr.ip__id__outer(),
|
|
dat, Outer_IP);
|
|
len += Get_AH_data_opt(&buf[len], hdr.ah__outer(), dat, Outer_IP);
|
|
len += Get_GRE_cksum_opt(&buf[len], hdr.gre__cksum1(), dat, Outer_IP);
|
|
len += Get_IP_ID_compressed_opt(&buf[len], hdr.ip__id__inner(),
|
|
dat, Inner_IP);
|
|
len += Get_AH_data_opt(&buf[len], hdr.ah__inner(), dat, Inner_IP);
|
|
len += Get_GRE_cksum_opt(&buf[len], hdr.gre__cksum2(), dat, Inner_IP);
|
|
len += Get_UDP_cksum_opt(&buf[len], hdr.udp__cksum(), dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
} /* Get_Profile2_ROHC_Header */
|
|
|
|
int
|
|
Get_Profile4_ipv4_dynamic(const unsigned char *buf,
|
|
Profile4__IPv4__Dynamic & chain,
|
|
t_dat *dat, int ip_level)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
len += Get_LIN1(&buf[len], chain.tos());
|
|
len += Get_LIN1(&buf[len], chain.ttl());
|
|
len += Get_LIN2_BO_LAST(&buf[len], chain.identification());
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
chain.df__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 6);
|
|
chain.rnd__bit() = BITSTRING(1, &ctemp);
|
|
dat->context.ip__ctx()[ip_level].rnd__bit() = BOOLEAN(ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 5);
|
|
chain.nbo__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 4);
|
|
chain.sid__bit() = BITSTRING(1, &ctemp);
|
|
ctemp = buf[len] & 0x0F;
|
|
chain.reserved() = BITSTRING(4, &ctemp);
|
|
len += 1;
|
|
len += Get_Encoding_Type_0(chain.genextheadlist(),
|
|
&buf[len], Item__list::ALT_ip__item__list,
|
|
dat, ip_level);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_Dynamic_Chain(Profile4__Dynamic__Chain & dynch,
|
|
const unsigned char *buf, t_dat *dat)
|
|
{
|
|
int len = 0, num;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
for (num = 0; num < dat->context.ip__ctx().size_of() && num < 2; num++)
|
|
{
|
|
if (dat->context.ip__ctx()[num].version() == 4)
|
|
{
|
|
len += Get_Profile4_ipv4_dynamic(&buf[len], dynch[num].ipv4__dyn(),
|
|
dat, num);
|
|
}
|
|
else if (dat->context.ip__ctx()[num].version() == 6)
|
|
{
|
|
len += Get_ipv6_dynamic(&buf[len], dynch[num].ipv6__dyn(), dat, num);
|
|
}
|
|
else
|
|
{
|
|
int ipver = dat->context.ip__ctx()[num].version();
|
|
TTCN_error("Invalid IP version %u on level %d", ipver, num);
|
|
}
|
|
}
|
|
|
|
num = dynch.size_of();
|
|
len += Get_LIN2_BO_LAST(&buf[len], dynch[num].sn());
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_Additional_Dynamic_Chain_opt(OPTIONAL < Profile4__Dynamic__Chain >
|
|
&dynch,
|
|
const unsigned char *buf,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (dat->context.ip__ctx().size_of() > 2)
|
|
{
|
|
for (int num = 2; num < dat->context.ip__ctx().size_of(); num++)
|
|
{
|
|
if (dat->context.ip__ctx()[num].version() == 4)
|
|
{
|
|
len += Get_Profile4_ipv4_dynamic(&buf[len],
|
|
dynch()[num - 2].ipv4__dyn(),
|
|
dat, num);
|
|
}
|
|
else if (dat->context.ip__ctx()[num].version() == 6)
|
|
{
|
|
len += Get_ipv6_dynamic(&buf[len], dynch()[num - 2].ipv6__dyn(),
|
|
dat, num);
|
|
}
|
|
else
|
|
{
|
|
int ipver = dat->context.ip__ctx()[num].version();
|
|
TTCN_error("Invalid IP version %u on level %d", ipver, num);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
dynch = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_Static_Chain(unsigned char *buf, Profile4__Static__Chain & chain,
|
|
t_dat *dat)
|
|
{
|
|
int len = 0, num = 0, nextheader = 0;
|
|
bool terminated = false;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
do
|
|
{
|
|
/* Version does not include the MSB bit of the version field */
|
|
int ver = (buf[len] >> 4) & 0x07;
|
|
|
|
terminated = (buf[len] & 0x80 > 0) ? true : false;
|
|
if (ver == c__ip__version__ipv4)
|
|
{
|
|
// version is stored with the MSB bit
|
|
initIPcontext(dat, num, (buf[len] >> 4) & 0x0F);
|
|
len += Get_ipv4_static(&buf[len], chain[num].ipv4__stat());
|
|
nextheader = chain[num].ipv4__stat().proto();
|
|
}
|
|
else if (ver == c__ip__version__ipv6)
|
|
{
|
|
// version is stored with the MSB bit
|
|
initIPcontext(dat, num, (buf[len] >> 4) & 0x0F);
|
|
len += Get_ipv6_static(&buf[len], chain[num].ipv6__stat());
|
|
nextheader = chain[num].ipv6__stat().nexthead();
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Invalid IP version %u on level %u", ver, num);
|
|
}
|
|
/* Explicit MSB termination */
|
|
if (terminated)
|
|
{
|
|
TTCN_logger.log(TTCN_DEBUG, "MSB static chain termination on level %u",
|
|
num);
|
|
}
|
|
num += 1;
|
|
}
|
|
while ((nextheader == c__ip__proto__ipv4 || nextheader == c__ip__proto__ipv6) &&
|
|
!terminated);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_ROHC_Header_ir(unsigned char *buf, Profile4__IR__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::IR);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 1) & 0x7F;
|
|
bhead.type__ind() = BITSTRING(7, &ctemp);
|
|
ctemp = ShiftDownBit(buf[len], 0);
|
|
bhead.d() = BITSTRING(1, &ctemp);
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
|
|
len += Get_Profile4_Static_Chain(&buf[len], bhead.stat__chain(), dat);
|
|
|
|
if (*bhead.d() == 1)
|
|
len += Get_Profile4_Dynamic_Chain(bhead.dyn__chain(), &buf[len], dat);
|
|
else
|
|
bhead.dyn__chain() = OMIT_VALUE;
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_ROHC_Header_irdyn(unsigned char *buf,
|
|
Profile4__IR__DYN__header & bhead,
|
|
t_dat *dat, int cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::IR__DYN);
|
|
bhead.cid() = cid;
|
|
bhead.type__ind() = BITSTRING(8, &buf[len]);
|
|
len += 1;
|
|
len += Get_LIN1(&buf[len], bhead.profile());
|
|
dat->context.profile() = bhead.profile();
|
|
len += Get_LIN1(&buf[len], bhead.crc());
|
|
|
|
len += Get_Profile4_Dynamic_Chain(bhead.dyn__chain(), &buf[len], dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_ROHC_Header_r1(unsigned char *buf,
|
|
Profile2__R__1__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile2__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::R__1);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 6) & 0x03;
|
|
bhead.type__ind() = BITSTRING(2, &ctemp);
|
|
bhead.sn() = buf[len] & 0x3F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.ip__id() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile2_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_ROHC_Header_uor2(unsigned char *buf,
|
|
Profile2__UOR__2__header & bhead,
|
|
t_dat *dat, int cid,
|
|
OPTIONAL < Profile2__Extension > &ext)
|
|
{
|
|
int len = 0;
|
|
unsigned char ctemp;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
dat->context.pkt() = Packet__type(Packet__type::UOR__2);
|
|
bhead.cid() = cid;
|
|
ctemp = (buf[len] >> 5) & 0x07;
|
|
bhead.type__ind() = BITSTRING(3, &ctemp);
|
|
bhead.sn() = buf[len] & 0x1F;
|
|
len += 1;
|
|
ctemp = ShiftDownBit(buf[len], 7);
|
|
bhead.x__bit() = BITSTRING(1, &ctemp);
|
|
bhead.crc() = buf[len] & 0x7F;
|
|
len += 1;
|
|
|
|
if (*bhead.x__bit())
|
|
{
|
|
len += Get_Profile2_extensions_opt(&buf[len], ext,
|
|
dat, *bhead.x__bit());
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
int
|
|
Get_Profile4_ROHC_Header(unsigned char *buf, int length,
|
|
Profile4__headers & hdr, t_dat *dat,
|
|
int cid)
|
|
{
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (isIR(buf[len]))
|
|
{
|
|
len += Get_Profile4_ROHC_Header_ir(&buf[len],
|
|
hdr.base__header().ir(), dat, cid);
|
|
}
|
|
else if (isIRDYN(buf[len]))
|
|
{
|
|
len += Get_Profile4_ROHC_Header_irdyn(&buf[len],
|
|
hdr.base__header().ir__dyn(),
|
|
dat, cid);
|
|
}
|
|
else if (isUOR2(buf[len]))
|
|
{
|
|
len += Get_Profile4_ROHC_Header_uor2(&buf[len],
|
|
hdr.base__header().uor__2(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
else if (dat->context.mode() == ROHC_mode_R)
|
|
{
|
|
if ((buf[len] & 0xC0) == 0)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r0(&buf[len],
|
|
hdr.base__header().r__0(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x40)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_r0crc(&buf[len],
|
|
hdr.base__header().r__0__crc(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
len += Get_Profile4_ROHC_Header_r1(&buf[len],
|
|
hdr.base__header().r__1(),
|
|
dat, cid, hdr.ext());
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Unknown compressed packet (R mode) (0x%02x)", buf[len]);
|
|
}
|
|
}
|
|
else if (dat->context.mode() != ROHC_mode_R) // U-O modes
|
|
{
|
|
if ((buf[len] & 0x80) == 0)
|
|
{
|
|
len += Get_Profile1_ROHC_Header_uo0(&buf[len],
|
|
hdr.base__header().uo__0(),
|
|
dat, cid);
|
|
}
|
|
else if ((buf[len] & 0xC0) == 0x80)
|
|
{
|
|
len += Get_Profile2_ROHC_Header_uo1(&buf[len],
|
|
hdr.base__header().uo__1(),
|
|
dat, cid);
|
|
}
|
|
else
|
|
{
|
|
TTCN_error("Unknown compressed packet (U-O modes) (0x%02x)", buf[len]);
|
|
}
|
|
}
|
|
|
|
if (!hdr.ext().is_bound())
|
|
hdr.ext() = OMIT_VALUE;
|
|
len += Get_IP_ID_compressed_opt(&buf[len], hdr.ip__id__outer(),
|
|
dat, Outer_IP);
|
|
len += Get_AH_data_opt(&buf[len], hdr.ah__outer(), dat, Outer_IP);
|
|
len += Get_GRE_cksum_opt(&buf[len], hdr.gre__cksum1(), dat, Outer_IP);
|
|
len += Get_IP_ID_compressed_opt(&buf[len], hdr.ip__id__inner(),
|
|
dat, Inner_IP);
|
|
len += Get_AH_data_opt(&buf[len], hdr.ah__inner(), dat, Inner_IP);
|
|
len += Get_GRE_cksum_opt(&buf[len], hdr.gre__cksum2(), dat, Inner_IP);
|
|
len += Get_Profile4_Additional_Dynamic_Chain_opt(hdr.additional__IP(),
|
|
&buf[len], dat);
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
} /* Get_Profile4_ROHC_Header */
|
|
|
|
int
|
|
Get_ROHC_Header(const unsigned char *p_buf,
|
|
int length, Header & p_header, ROHC__config & config)
|
|
{
|
|
unsigned char buf[MAX_PACKET_SIZE];
|
|
int len = 0, cidlen = 0;
|
|
INTEGER cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
memcpy(buf, p_buf, length);
|
|
|
|
if (config.large__cid())
|
|
{
|
|
/* Skip packet type octet */
|
|
cidlen = Get_CID(&p_buf[1], cid, config);
|
|
/* Move the packet type octet right after the CID */
|
|
buf[cidlen] = buf[0];
|
|
}
|
|
else
|
|
{
|
|
cidlen = Get_CID(&p_buf[0], cid, config);
|
|
}
|
|
len += cidlen;
|
|
|
|
if (isIR(buf[len]) || isIRDYN(buf[len]))
|
|
{
|
|
config.context()[cid].profile() = buf[len + 1];
|
|
}
|
|
|
|
t_dat dat = initTDAT(config, cid);
|
|
initCIDcontext(&dat);
|
|
|
|
switch (config.context()[cid].profile())
|
|
{
|
|
case 0:
|
|
len += Get_Profile0_ROHC_Header(&buf[len], &dat,
|
|
length - cidlen, p_header.prof0(),
|
|
(int) cid);
|
|
break;
|
|
case 1:
|
|
len += Get_Profile1_ROHC_Header(&buf[len], &dat, length - cidlen,
|
|
p_header.prof1(), (int) cid);
|
|
break;
|
|
case 2:
|
|
len += Get_Profile2_ROHC_Header(&buf[len], length - cidlen,
|
|
p_header.prof2(), &dat,
|
|
(int) cid);
|
|
break;
|
|
case 4:
|
|
len += Get_Profile4_ROHC_Header(&buf[len], length - cidlen,
|
|
p_header.prof4(), &dat,
|
|
(int) cid);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
Log_hexdump(buf, len);
|
|
Log_function_name_on_leave();
|
|
|
|
return len;
|
|
}
|
|
|
|
ROHC__packet__u
|
|
f__ROHC__dec(OCTETSTRING const &data, ROHC__config & p_config)
|
|
{
|
|
ROHC__packet__u packet;
|
|
OPTIONAL < Padding > padding;
|
|
OPTIONAL < Feedback > feedback;
|
|
const unsigned char *buf = (const unsigned char *) data;
|
|
int len = 0;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
Log_object(p_config);
|
|
|
|
// Processing padding
|
|
Log_hexdump(buf, data.lengthof() - len);
|
|
len += Get_ROHC_Padding(&buf[len], data.lengthof() - len, padding, p_config);
|
|
// Processing feedback
|
|
len += Get_ROHC_Feedback(&buf[len], data.lengthof() - len, feedback, p_config);
|
|
// Processing ROHC header
|
|
if ((buf[len] & 0xFE) == 0xFE)
|
|
{
|
|
packet.segment().padding() = padding;
|
|
packet.segment().feedback() = feedback;
|
|
packet.segment().segment__header__id() = 0x7F;
|
|
if (ShiftDownBit(buf[len], 0))
|
|
{
|
|
packet.segment().final() = BOOLEAN(true);
|
|
len += 1;
|
|
if (data.lengthof() - len < 4)
|
|
{
|
|
packet.segment().payload() =
|
|
OCTETSTRING(data.lengthof() - len, &buf[len]);
|
|
len = data.lengthof();
|
|
packet.segment().crc() = OMIT_VALUE;
|
|
}
|
|
else
|
|
{
|
|
packet.segment().payload() =
|
|
OCTETSTRING(data.lengthof() - len - 4, &buf[len]);
|
|
len = data.lengthof() - 4;
|
|
packet.segment().crc() =
|
|
((buf[len] << 24) & 0xFF000000) +
|
|
((buf[len + 1] << 16) & 0xFF0000) +
|
|
((buf[len + 2] << 8) & 0xFF00) + (buf[len + 3] & 0xFF);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
packet.segment().final() = BOOLEAN(false);
|
|
len += 1;
|
|
packet.segment().payload() =
|
|
OCTETSTRING(data.lengthof() - len, &buf[len]);
|
|
packet.segment().crc() = OMIT_VALUE;
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
packet.rohc().padding() = padding;
|
|
packet.rohc().feedback() = feedback;
|
|
len += Get_ROHC_Header(&buf[len],
|
|
data.lengthof() - len, packet.rohc().header(),
|
|
p_config);
|
|
if (data.lengthof() == len)
|
|
{
|
|
packet.rohc().payload() = OMIT_VALUE;
|
|
}
|
|
else
|
|
{
|
|
packet.rohc().payload() = OCTETSTRING(data.lengthof() - len, &buf[len]);
|
|
}
|
|
}
|
|
|
|
TTCN_logger.begin_event(TTCN_DEBUG);
|
|
p_config.log();
|
|
packet.log();
|
|
TTCN_logger.end_event();
|
|
|
|
Log_function_name_on_leave();
|
|
|
|
return packet;
|
|
}
|
|
|
|
INTEGER
|
|
f__ROHC__CRC(OCTETSTRING const &data, INTEGER const &crclen)
|
|
{
|
|
const unsigned char *buf = (const unsigned char *) data;
|
|
INTEGER crcval;
|
|
int crclength = crclen;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
TTCN_logger.log(TTCN_DEBUG, "Calculating CRC-%d over:", crclength);
|
|
Log_hexdump(buf, data.lengthof());
|
|
|
|
crcval = INTEGER(ComputeCRC(&(buf[0]), data.lengthof(), crclength));
|
|
Log_function_name_on_leave();
|
|
return crcval;
|
|
}
|
|
|
|
OCTETSTRING
|
|
f__FBCK__enc(Feedback__data const &feedback_data, ROHC__config const &config)
|
|
{
|
|
unsigned char buf[MAX_PACKET_SIZE];
|
|
int len = 0, crcpos = 0;
|
|
INTEGER cid;
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
cid = feedback_data.cid();
|
|
if (config.large__cid() == false)
|
|
{
|
|
if (cid > 0)
|
|
{
|
|
buf[len] = 0xE0 + (cid & 0x0F);
|
|
len += 1;
|
|
}
|
|
}
|
|
else
|
|
len += Set_SDVL_field(&buf[len], cid, 0);
|
|
switch (feedback_data.feedback__type().get_selection())
|
|
{
|
|
case Feedback__type::ALT_feedback1:
|
|
const unsigned char *tempbuf;
|
|
tempbuf =
|
|
(const unsigned char *) feedback_data.feedback__type().feedback1();
|
|
buf[len] = tempbuf[0];
|
|
len += 1;
|
|
break;
|
|
case Feedback__type::ALT_feedback2:
|
|
{
|
|
Feedback2 fback2;
|
|
fback2 = feedback_data.feedback__type().feedback2();
|
|
buf[len] = (fback2.acktype() << 6) & 0xC0;
|
|
buf[len] += (fback2.mode() << 4) & 0x30;
|
|
buf[len] += (fback2.sn() >> 8) & 0x0F;
|
|
len += 1;
|
|
buf[len] = fback2.sn() & 0xFF;
|
|
len += 1;
|
|
if (fback2.feedback__opts().ispresent())
|
|
{
|
|
Feedback__opts & fbopts = fback2.feedback__opts();
|
|
for (int num2 = 0; num2 < fbopts.size_of(); num2++)
|
|
{
|
|
buf[len] = (fbopts[num2].opt__type() << 4) & 0xF0;
|
|
buf[len] += fbopts[num2].opt__len() & 0x0F;
|
|
len += 1;
|
|
len += Set_octetstring_opt(&buf[len], fbopts[num2].opt__data());
|
|
if (fbopts[num2].opt__data().ispresent())
|
|
{
|
|
OCTETSTRING opt;
|
|
opt = fbopts[num2].opt__data();
|
|
if (fbopts[num2].opt__len() != opt.lengthof())
|
|
TTCN_logger.
|
|
log(TTCN_WARNING,
|
|
"Feedback option length mismatch: %d, %d",
|
|
(int) fbopts[num2].opt__len(), opt.lengthof());
|
|
else
|
|
if ((fbopts[num2].opt__len() == 1)
|
|
&& (fbopts[num2].opt__type() == 1) && (buf[len - 1] == 0))
|
|
crcpos = len - 1;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if ((crcpos > 0) && (buf[crcpos] == 0))
|
|
buf[crcpos] = ComputeCRC(&(buf[0]), len, 8);
|
|
|
|
Log_function_name_on_leave();
|
|
|
|
return OCTETSTRING(len, &(buf[0]));
|
|
}
|
|
|
|
Feedback__data
|
|
f__FBCK__dec(OCTETSTRING const &data, ROHC__config const &config)
|
|
{
|
|
Feedback__data feedback_data;
|
|
const unsigned char *buf;
|
|
unsigned char ctemp;
|
|
int len = 0, fbsize, cidlen = 0;
|
|
buf = (const unsigned char *) data;
|
|
fbsize = data.lengthof();
|
|
|
|
Log_function_name_on_enter();
|
|
|
|
if (config.large__cid() == false)
|
|
{
|
|
if ((buf[len] & 0xF0) == 0xE0)
|
|
{
|
|
feedback_data.cid() = buf[len] & 0x0F;
|
|
len += 1;
|
|
fbsize -= 1;
|
|
}
|
|
else
|
|
feedback_data.cid() = 0;
|
|
}
|
|
else
|
|
{
|
|
cidlen = Get_SDVL_field(&buf[len], feedback_data.cid());
|
|
len += cidlen;
|
|
fbsize -= cidlen;
|
|
}
|
|
|
|
if (fbsize == 1)
|
|
{
|
|
feedback_data.feedback__type().feedback1() = OCTETSTRING(1, &buf[len]);
|
|
len += 1;
|
|
}
|
|
else if (fbsize >= 1)
|
|
{
|
|
int optnum;
|
|
Feedback__opts fbopts;
|
|
Feedback2 feedback2;
|
|
feedback2.acktype() = (buf[len] >> 6) & 0x03;
|
|
feedback2.mode() = (buf[len] >> 4) & 0x03;
|
|
ctemp = buf[len] & 0x0F;
|
|
len += 1;
|
|
fbsize -= 1;
|
|
feedback2.sn() = ((ctemp << 8) & 0x0F00) + buf[len];
|
|
len += 1;
|
|
fbsize -= 1;
|
|
optnum = 0;
|
|
feedback2.feedback__opts() = OMIT_VALUE;
|
|
while (fbsize)
|
|
{
|
|
fbopts[optnum].opt__type() = (buf[len] >> 4) & 0x0F;
|
|
fbopts[optnum].opt__len() = buf[len] & 0x0F;
|
|
len += 1;
|
|
fbsize -= 1;
|
|
if (fbopts[optnum].opt__len())
|
|
{
|
|
len += Get_octetstring(&buf[len], fbopts[optnum].opt__data(),
|
|
fbopts[optnum].opt__len());
|
|
fbsize -= fbopts[optnum].opt__len();
|
|
}
|
|
else
|
|
fbopts[optnum].opt__data() = OMIT_VALUE;
|
|
feedback2.feedback__opts() = fbopts;
|
|
optnum += 1;
|
|
}
|
|
|
|
feedback_data.feedback__type().feedback2() = feedback2;
|
|
}
|
|
else
|
|
TTCN_logger.log(TTCN_WARNING, "Size mismatch in feedback(%d)", fbsize);
|
|
|
|
Log_function_name_on_leave();
|
|
|
|
return feedback_data;
|
|
}
|
|
|
|
}//namespace
|