#include #include #include "RLCMAC_Types.hh" #include "RLCMAC_Templates.hh" #include "GSM_Types.hh" /* Decoding of TS 44.060 GPRS RLC/MAC blocks, portions requiring manual functions * beyond what TITAN RAW coder can handle internally. * * (C) 2017 by Harald Welte * All rights reserved. * * Released under the terms of GNU General Public License, Version 2 or * (at your option) any later version. * * SPDX-License-Identifier: GPL-2.0-or-later */ namespace RLCMAC__Types { ///////////////////// // INTENRAL HELPERS ///////////////////// /* TS 04.60 10.3a.4.1.1 */ struct gprs_rlc_ul_header_egprs_1 { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t r:1, si:1, cv:4, tfi_hi:2; uint8_t tfi_lo:3, bsn1_hi:5; uint8_t bsn1_lo:6, bsn2_hi:2; uint8_t bsn2_lo:8; uint8_t cps:5, rsb:1, pi:1, spare_hi:1; uint8_t spare_lo:6, dummy:2; #else /* auto-generated from the little endian part above (libosmocore/contrib/struct_endianess.py) */ uint8_t tfi_hi:2, cv:4, si:1, r:1; uint8_t bsn1_hi:5, tfi_lo:3; uint8_t bsn2_hi:2, bsn1_lo:6; uint8_t bsn2_lo:8; uint8_t spare_hi:1, pi:1, rsb:1, cps:5; uint8_t dummy:2, spare_lo:6; #endif } __attribute__ ((packed)); /* TS 04.60 10.3a.4.2.1 */ struct gprs_rlc_ul_header_egprs_2 { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t r:1, si:1, cv:4, tfi_hi:2; uint8_t tfi_lo:3, bsn1_hi:5; uint8_t bsn1_lo:6, cps_hi:2; uint8_t cps_lo:1, rsb:1, pi:1, spare_hi:5; uint8_t spare_lo:5, dummy:3; #else /* auto-generated from the little endian part above (libosmocore/contrib/struct_endianess.py) */ uint8_t tfi_hi:2, cv:4, si:1, r:1; uint8_t bsn1_hi:5, tfi_lo:3; uint8_t cps_hi:2, bsn1_lo:6; uint8_t spare_hi:5, pi:1, rsb:1, cps_lo:1; uint8_t dummy:3, spare_lo:5; #endif } __attribute__ ((packed)); /* TS 04.60 10.3a.4.3.1 */ struct gprs_rlc_ul_header_egprs_3 { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t r:1, si:1, cv:4, tfi_hi:2; uint8_t tfi_lo:3, bsn1_hi:5; uint8_t bsn1_lo:6, cps_hi:2; uint8_t cps_lo:2, spb:2, rsb:1, pi:1, spare:1, dummy:1; #else /* auto-generated from the little endian part above (libosmocore/contrib/struct_endianess.py) */ uint8_t tfi_hi:2, cv:4, si:1, r:1; uint8_t bsn1_hi:5, tfi_lo:3; uint8_t cps_hi:2, bsn1_lo:6; uint8_t dummy:1, spare:1, pi:1, rsb:1, spb:2, cps_lo:2; #endif } __attribute__ ((packed)); struct gprs_rlc_dl_header_egprs_1 { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t usf:3, es_p:2, rrbp:2, tfi_hi:1; uint8_t tfi_lo:4, pr:2, bsn1_hi:2; uint8_t bsn1_mid:8; uint8_t bsn1_lo:1, bsn2_hi:7; uint8_t bsn2_lo:3, cps:5; #else /* auto-generated from the little endian part above (libosmocore/contrib/struct_endianess.py) */ uint8_t tfi_hi:1, rrbp:2, es_p:2, usf:3; uint8_t bsn1_hi:2, pr:2, tfi_lo:4; uint8_t bsn1_mid:8; uint8_t bsn2_hi:7, bsn1_lo:1; uint8_t cps:5, bsn2_lo:3; #endif } __attribute__ ((packed)); struct gprs_rlc_dl_header_egprs_2 { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t usf:3, es_p:2, rrbp:2, tfi_hi:1; uint8_t tfi_lo:4, pr:2, bsn1_hi:2; uint8_t bsn1_mid:8; uint8_t bsn1_lo:1, cps:3, dummy:4; #else /* auto-generated from the little endian part above (libosmocore/contrib/struct_endianess.py) */ uint8_t tfi_hi:1, rrbp:2, es_p:2, usf:3; uint8_t bsn1_hi:2, pr:2, tfi_lo:4; uint8_t bsn1_mid:8; uint8_t dummy:4, cps:3, bsn1_lo:1; #endif } __attribute__ ((packed)); struct gprs_rlc_dl_header_egprs_3 { #if __BYTE_ORDER == __LITTLE_ENDIAN uint8_t usf:3, es_p:2, rrbp:2, tfi_hi:1; uint8_t tfi_lo:4, pr:2, bsn1_hi:2; uint8_t bsn1_mid:8; uint8_t bsn1_lo:1, cps:4, spb:2, dummy:1; #else /* auto-generated from the little endian part above (libosmocore/contrib/struct_endianess.py) */ uint8_t tfi_hi:1, rrbp:2, es_p:2, usf:3; uint8_t bsn1_hi:2, pr:2, tfi_lo:4; uint8_t bsn1_mid:8; uint8_t dummy:1, spb:2, cps:4, bsn1_lo:1; #endif } __attribute__ ((packed)); /* static const char hex_chars[] = "0123456789abcdef"; void printbuffer(const char* ptr, TTCN_Buffer& buf) { int len = buf.get_len(); const unsigned char* cbuf = buf.get_data(); fprintf(stderr, "printbuffer %s (len=%d): [", ptr, len); for (int i = 0; i < len; i++) { fprintf(stderr, " %c%c", hex_chars[cbuf[i] >> 4], hex_chars[cbuf[i] & 0xf]); } fprintf(stderr, " ]\n"); } */ static CodingScheme::enum_type payload_len_2_coding_scheme(size_t payload_len) { switch (payload_len) { case 23: return CodingScheme::CS__1; case 34: return CodingScheme::CS__2; case 40: return CodingScheme::CS__3; case 54: return CodingScheme::CS__4; case 27: return CodingScheme::MCS__1; case 33: return CodingScheme::MCS__2; case 42: return CodingScheme::MCS__3; case 49: return CodingScheme::MCS__4; case 60: /* fall through */ case 61: return CodingScheme::MCS__5; case 78: /* fall through */ case 79: return CodingScheme::MCS__6; case 118: /* fall through */ case 119: return CodingScheme::MCS__7; case 142: /* fall through */ case 143: return CodingScheme::MCS__8; case 154: /* fall through */ case 155: return CodingScheme::MCS__9; default: fprintf(stderr, "ERROR: Unknown CodingSCheme for payload_len=%zu\n", payload_len); return CodingScheme::CS__1; } } static unsigned int coding_scheme_2_data_block_len(CodingScheme::enum_type mcs) { switch (mcs) { case CodingScheme::MCS__0: return 0; case CodingScheme::MCS__1: return 22; case CodingScheme::MCS__2: return 28; case CodingScheme::MCS__3: return 37; case CodingScheme::MCS__4: return 44; case CodingScheme::MCS__5: return 56; case CodingScheme::MCS__6: return 74; case CodingScheme::MCS__7: return 56; case CodingScheme::MCS__8: return 68; case CodingScheme::MCS__9: return 74; default: return 22; /* MCS1*/ } } static uint8_t bs2uint8(const BITSTRING& bs) { int len = bs.lengthof(); int i; uint8_t res = 0; for (i = 0; i < len; i++) { res = res << 1; res |= (bs[i].get_bit() ? 1 : 0); } return res; } /* determine the number of rlc data blocks and their size / offsets */ static void setup_rlc_mac_priv(CodingScheme::enum_type mcs, EgprsHeaderType::enum_type hdrtype, boolean is_uplink, unsigned int *n_calls, unsigned int *data_block_bits, unsigned int *data_block_offsets) { unsigned int nc, dbl = 0, dbo[2] = {0,0}; dbl = coding_scheme_2_data_block_len(mcs); switch (hdrtype) { case EgprsHeaderType::RLCMAC__HDR__TYPE__1: nc = 3; dbo[0] = is_uplink ? 5*8 + 6 : 5*8 + 0; dbo[1] = dbo[0] + dbl * 8 + 2; break; case EgprsHeaderType::RLCMAC__HDR__TYPE__2: nc = 2; dbo[0] = is_uplink ? 4*8 + 5 : 3*8 + 4; break; case EgprsHeaderType::RLCMAC__HDR__TYPE__3: nc = 2; dbo[0] = 3*8 + 7; break; default: nc = 1; break; } *n_calls = nc; *data_block_bits = dbl * 8 + 2; data_block_offsets[0] = dbo[0]; data_block_offsets[1] = dbo[1]; } /* bit-shift the entire 'src' of length 'length_bytes' by 'offset_bits' * and store the result to caller-allocated 'buffer'. The shifting is * done lsb-first. */ static void clone_aligned_buffer_lsbf(unsigned int offset_bits, unsigned int length_bytes, const uint8_t *src, uint8_t *buffer) { unsigned int hdr_bytes; unsigned int extra_bits; unsigned int i; uint8_t c, last_c; uint8_t *dst; hdr_bytes = offset_bits / 8; extra_bits = offset_bits % 8; //fprintf(stderr, "RLMAC: clone: hdr_bytes=%u extra_bits=%u (length_bytes=%u)\n", hdr_bytes, extra_bits, length_bytes); if (extra_bits == 0) { /* It is aligned already */ memcpy(buffer, src + hdr_bytes, length_bytes); return; } dst = buffer; src = src + hdr_bytes; last_c = *(src++); for (i = 0; i < length_bytes; i++) { c = src[i]; *(dst++) = (last_c >> extra_bits) | (c << (8 - extra_bits)); last_c = c; } } /* obtain an (aligned) EGPRS data block with given bit-offset and * bit-length from the parent buffer */ static void get_egprs_data_block(const TTCN_Buffer& orig_ttcn_buffer, unsigned int offset_bits, unsigned int length_bits, TTCN_Buffer& dst_ttcn_buffer) { const unsigned int initial_spare_bits = 6; unsigned char *aligned_buf = NULL; size_t min_src_length_bytes = (offset_bits + length_bits + 7) / 8; size_t length_bytes = (initial_spare_bits + length_bits + 7) / 8; size_t accepted_len = length_bytes; //fprintf(stderr, "RLMAC: trying to allocate %u bytes (orig is %zu bytes long with read pos %zu)\n", length_bytes, orig_ttcn_buffer.get_len(), orig_ttcn_buffer.get_pos()); dst_ttcn_buffer.get_end(aligned_buf, accepted_len); if (accepted_len < length_bytes) { fprintf(stderr, "RLMAC: ERROR! asked for %zu bytes but got %zu\n", length_bytes, accepted_len); } /* Copy the data out of the tvb to an aligned buffer */ clone_aligned_buffer_lsbf( offset_bits - initial_spare_bits, length_bytes, orig_ttcn_buffer.get_data(), aligned_buf); /* clear spare bits and move block header bits to the right */ aligned_buf[0] = aligned_buf[0] >> initial_spare_bits; dst_ttcn_buffer.increase_length(length_bytes); } /* bit-shift the entire 'src' of length 'length_bytes' * and store the result to caller-allocated 'buffer' by 'offset_bits'. The shifting is * done lsb-first. */ static void clone_unaligned_buffer_lsbf(unsigned int offset_bits, unsigned int length_bytes, const uint8_t *src, uint8_t *buffer) { unsigned int hdr_bytes; unsigned int extra_bits; unsigned int i; uint8_t c, last_hdr_c, last_c; uint8_t *dst; hdr_bytes = offset_bits / 8; extra_bits = offset_bits % 8; //fprintf(stderr, "RLMAC: clone: hdr_bytes=%u extra_bits=%u (length_bytes=%u)\n", hdr_bytes, extra_bits, length_bytes); if (extra_bits == 0) { /* It is aligned already */ memcpy(buffer, src + hdr_bytes, length_bytes); return; } /* Copy first header+data byte, it's not handled correctly by loop */ dst = buffer + hdr_bytes; last_hdr_c = *dst; last_c = *dst << (8 - extra_bits); for (i = 0; i < length_bytes; i++) { c = src[i]; *(dst++) = (last_c >> (8 - extra_bits)) | (c << extra_bits); last_c = c; } /* overwrite the lower extra_bits */ *dst = (*dst & (0xff << extra_bits)) | (last_c >> (8 - extra_bits)); /* Copy back first header+data byte */ dst = buffer + hdr_bytes; *(dst++) = last_hdr_c | (src[0] << (8 - extra_bits)); *dst |= (src[0] >> (extra_bits)) & (0xff >> (8 - extra_bits)); } /* put an (aligned) EGPRS data block with given bit-offset and * bit-length into parent buffer */ static void put_egprs_data_block(const TTCN_Buffer& aligned_data_block_buffer, unsigned int offset_bits, unsigned int length_bits, TTCN_Buffer& dst_ttcn_buffer) { const unsigned int initial_spare_bits = 6; unsigned char *unaligned_buf = NULL; char tmpbuf[120]; int tmplen = dst_ttcn_buffer.get_len(); //size_t max_length_bytes = (initial_spare_bits + length_bits + 7) / 8; size_t length_bytes = tmplen + aligned_data_block_buffer.get_len(); size_t accepted_len = length_bytes; //fprintf(stderr, "RLMAC: trying to allocate %u bytes\n", length_bytes); /* API .get_end() is the only one I could find to access writeable memory in the buffer. It points to the end. Hence, we first copy (readonly) data to tmpbuf and later clear() so that .get_end() provides us with a pointer to the start of the buffer. */ memcpy(tmpbuf, dst_ttcn_buffer.get_data(), tmplen); dst_ttcn_buffer.clear(); dst_ttcn_buffer.get_end(unaligned_buf, accepted_len); if (accepted_len < tmplen) { fprintf(stderr, "RLMAC: ERROR! asked for %zu bytes but got %zu\n", length_bytes, accepted_len); } memcpy(unaligned_buf, tmpbuf, tmplen); /* Copy the data out of the tvb to an aligned buffer */ clone_unaligned_buffer_lsbf( offset_bits - initial_spare_bits, length_bytes, aligned_data_block_buffer.get_data(), unaligned_buf); dst_ttcn_buffer.increase_length(length_bytes); } /* Append padding bytes and spare bits at the end of ttcn_buffer, based on requested CS */ static void encode_trailing_padding_spb(TTCN_Buffer& ttcn_buffer, CodingScheme cs) { uint8_t buf[256]; /* enough to fit any RLCMAC buffer*/ uint32_t blk_len = RLCMAC__Templates::f__rlcmac__cs__mcs2block__len(cs); uint32_t blk_len_no_spb = RLCMAC__Templates::f__rlcmac__cs__mcs2block__len__no__spare__bits(cs); uint32_t data_len = ttcn_buffer.get_len(); if (data_len > blk_len_no_spb) { fprintf(stderr, "Buffer too large for requested CS! %s (%s:%u)\n", __func__, __FILE__, __LINE__); // TODO: throw exception? } for (int i = 0; i < blk_len_no_spb - data_len; i++) buf[i] = 0x2b; /* Padding bits if needed */ for (int i = blk_len_no_spb - data_len; i < blk_len - data_len; i++) buf[i] = 0x00; /* Spare bits if needed */ const OCTETSTRING& pad_octstr = OCTETSTRING(blk_len - data_len, buf); ttcn_buffer.put_string(pad_octstr); } ///////////////////// // DECODE ///////////////////// /* DECODE DOWNLINK */ RlcmacDlDataBlock dec__RlcmacDlDataBlock(const OCTETSTRING& stream) { RlcmacDlDataBlock ret_val; TTCN_Buffer ttcn_buffer(stream); int num_llc_blocks = 0; ret_val.cs() = payload_len_2_coding_scheme(stream.lengthof()); /* use automatic/generated decoder for header */ ret_val.mac__hdr().decode(DlMacDataHeader_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); /* optional extension octets, containing LI+M+E of Llc blocks */ if (ret_val.mac__hdr().hdr__ext().e() == false) { /* extension octet follows, i.e. optional Llc length octets */ while (1) { /* decode one more extension octet with LlcBlocHdr inside */ LlcBlock lb; lb.hdr()().decode(LlcBlockHdr_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); ret_val.blocks()[num_llc_blocks++] = lb; /* if E == '1'B, we can proceed further */ if (lb.hdr()().e() == true) break; } } /* RLC blocks at end */ if (ret_val.mac__hdr().hdr__ext().e() == true) { LlcBlock lb; unsigned int length = ttcn_buffer.get_read_len(); /* LI not present: The Upper Layer PDU that starts with the current RLC data block either * fills the current RLC data block precisely or continues in the following in-sequence RLC * data block */ lb.hdr() = OMIT_VALUE; lb.payload() = OCTETSTRING(length, ttcn_buffer.get_read_data()); ttcn_buffer.increase_pos(length); ret_val.blocks()[0] = lb; } else { if (ret_val.blocks().is_bound()) { for (int i = 0; i < ret_val.blocks().size_of(); i++) { unsigned int length = ret_val.blocks()[i].hdr()().length__ind(); if (length > ttcn_buffer.get_read_len()) length = ttcn_buffer.get_read_len(); ret_val.blocks()[i].payload() = OCTETSTRING(length, ttcn_buffer.get_read_data()); ttcn_buffer.increase_pos(length); } } } return ret_val; } static EgprsDlMacDataHeader dec__EgprsDlMacDataHeader_type1(const OCTETSTRING& stream) { TTCN_Buffer ttcn_buffer(stream); EgprsDlMacDataHeader ret_val; const struct gprs_rlc_dl_header_egprs_1 *egprs1; uint8_t tmp; egprs1 = static_cast ((const void *)ttcn_buffer.get_data()); ret_val.header__type() = EgprsHeaderType::RLCMAC__HDR__TYPE__1; ret_val.tfi() = egprs1->tfi_lo << 1 | egprs1->tfi_hi << 0; ret_val.rrbp() = egprs1->rrbp; tmp = egprs1->es_p; ret_val.esp() = BITSTRING(2, &tmp); ret_val.usf() = egprs1->usf; ret_val.bsn1() = egprs1->bsn1_lo << 10 | egprs1->bsn1_mid << 2 | egprs1->bsn1_hi; ret_val.bsn2__offset() = egprs1->bsn2_lo << 7 | egprs1->bsn2_hi; ret_val.pr() = egprs1->pr; ret_val.cps() = egprs1->cps; ret_val.spb() = OMIT_VALUE; ttcn_buffer.increase_pos(sizeof(*egprs1)); return ret_val; } static EgprsDlMacDataHeader dec__EgprsDlMacDataHeader_type2(const OCTETSTRING& stream) { TTCN_Buffer ttcn_buffer(stream); EgprsDlMacDataHeader ret_val; const struct gprs_rlc_dl_header_egprs_2 *egprs2; uint8_t tmp; egprs2 = static_cast ((const void *)ttcn_buffer.get_data()); ret_val.header__type() = EgprsHeaderType::RLCMAC__HDR__TYPE__2; ret_val.tfi() = egprs2->tfi_lo << 1 | egprs2->tfi_hi << 0; ret_val.rrbp() = egprs2->rrbp; tmp = egprs2->es_p; ret_val.esp() = BITSTRING(2, &tmp); ret_val.usf() = egprs2->usf; ret_val.bsn1() = egprs2->bsn1_lo << 10 | egprs2->bsn1_mid << 2 | egprs2->bsn1_hi; ret_val.bsn2__offset() = 0; /*TODO: mark optional and not set ? */ ret_val.pr() = egprs2->pr; ret_val.cps() = egprs2->cps; ret_val.spb() = OMIT_VALUE; ttcn_buffer.increase_pos(sizeof(*egprs2)); return ret_val; } static EgprsDlMacDataHeader dec__EgprsDlMacDataHeader_type3(const OCTETSTRING& stream) { TTCN_Buffer ttcn_buffer(stream); EgprsDlMacDataHeader ret_val; const struct gprs_rlc_dl_header_egprs_3 *egprs3; uint8_t tmp; egprs3 = static_cast ((const void *)ttcn_buffer.get_data()); ret_val.header__type() = EgprsHeaderType::RLCMAC__HDR__TYPE__3; ret_val.tfi() = egprs3->tfi_lo << 1 | egprs3->tfi_hi << 0; ret_val.rrbp() = egprs3->rrbp; tmp = egprs3->es_p; ret_val.esp() = BITSTRING(2, &tmp); ret_val.usf() = egprs3->usf; ret_val.bsn1() = egprs3->bsn1_lo << 10 | egprs3->bsn1_mid << 2 | egprs3->bsn1_hi; ret_val.bsn2__offset() = 0; /*TODO: mark optional and not set ? */ ret_val.pr() = egprs3->pr; ret_val.spb() = egprs3->spb; ret_val.cps() = egprs3->cps; ttcn_buffer.increase_pos(sizeof(*egprs3)); return ret_val; } static RlcmacDlEgprsDataBlock dec__RlcmacDlEgprsDataBlock(const OCTETSTRING& stream) { RlcmacDlEgprsDataBlock ret_val; TTCN_Buffer ttcn_buffer(stream); TTCN_Buffer aligned_buffer; int num_llc_blocks = 0; unsigned int data_block_bits, data_block_offsets[2]; unsigned int num_calls; const uint8_t *ti_e; ret_val.mcs() = payload_len_2_coding_scheme(stream.lengthof()); switch (ret_val.mcs()) { case CodingScheme::MCS__0: case CodingScheme::MCS__1: case CodingScheme::MCS__2: case CodingScheme::MCS__3: case CodingScheme::MCS__4: ret_val.mac__hdr() = dec__EgprsDlMacDataHeader_type3(stream); break; case CodingScheme::MCS__5: case CodingScheme::MCS__6: ret_val.mac__hdr() = dec__EgprsDlMacDataHeader_type2(stream); break; case CodingScheme::MCS__7: case CodingScheme::MCS__8: case CodingScheme::MCS__9: ret_val.mac__hdr() = dec__EgprsDlMacDataHeader_type1(stream); break; } setup_rlc_mac_priv(ret_val.mcs(), ret_val.mac__hdr().header__type(), false, &num_calls, &data_block_bits, data_block_offsets); get_egprs_data_block(ttcn_buffer, data_block_offsets[0], data_block_bits, aligned_buffer); ti_e = aligned_buffer.get_read_data(); ret_val.fbi() = *ti_e & 0x02 ? true : false; ret_val.e() = *ti_e & 0x01 ? true : false; aligned_buffer.increase_pos(1); /* optional extension octets, containing LI+E of Llc blocks */ if (ret_val.e() == false) { /* extension octet follows, i.e. optional Llc length octets */ while (1) { /* decode one more extension octet with LlcBlocHdr inside */ EgprsLlcBlock lb; lb.hdr()().decode(EgprsLlcBlockHdr_descr_, aligned_buffer, TTCN_EncDec::CT_RAW); ret_val.blocks()[num_llc_blocks++] = lb; /* if E == '1'B, we can proceed further */ if (lb.hdr()().e() == true) break; } } /* RLC blocks at end */ if (ret_val.e() == true) { EgprsLlcBlock lb; unsigned int length = aligned_buffer.get_read_len(); /* LI not present: The Upper Layer PDU that starts with the current RLC data block either * fills the current RLC data block precisely or continues in the following in-sequence RLC * data block */ lb.hdr() = OMIT_VALUE; lb.payload() = OCTETSTRING(length, ttcn_buffer.get_read_data()); aligned_buffer.increase_pos(length); ret_val.blocks()[0] = lb; } else { /* RLC blocks at end */ if (ret_val.blocks().is_bound()) { for (int i = 0; i < ret_val.blocks().size_of(); i++) { unsigned int length = ret_val.blocks()[i].hdr()().length__ind(); if (length > aligned_buffer.get_read_len()) length = aligned_buffer.get_read_len(); ret_val.blocks()[i].payload() = OCTETSTRING(length, aligned_buffer.get_read_data()); aligned_buffer.increase_pos(length); } } } return ret_val; } RlcmacDlBlock dec__RlcmacDlBlock(const OCTETSTRING& stream) { RlcmacDlBlock ret_val; size_t stream_len = stream.lengthof(); CodingScheme::enum_type cs_mcs = payload_len_2_coding_scheme(stream_len); unsigned char pt; switch (cs_mcs) { case CodingScheme::CS__1: case CodingScheme::CS__2: case CodingScheme::CS__3: case CodingScheme::CS__4: pt = stream[0].get_octet() >> 6; if (pt == MacPayloadType::MAC__PT__RLC__DATA) ret_val.data() = dec__RlcmacDlDataBlock(stream); else ret_val.ctrl() = dec__RlcmacDlCtrlBlock(stream); break; case CodingScheme::MCS__0: case CodingScheme::MCS__1: case CodingScheme::MCS__2: case CodingScheme::MCS__3: case CodingScheme::MCS__4: case CodingScheme::MCS__5: case CodingScheme::MCS__6: case CodingScheme::MCS__7: case CodingScheme::MCS__8: case CodingScheme::MCS__9: ret_val.data__egprs() = dec__RlcmacDlEgprsDataBlock(stream); break; } return ret_val; } /* DECODE UPLINK */ RlcmacUlDataBlock dec__RlcmacUlDataBlock(const OCTETSTRING& stream) { RlcmacUlDataBlock ret_val; TTCN_Buffer ttcn_buffer(stream); int num_llc_blocks = 0; TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("==================================\n" "dec_RlcmacUlDataBlock(): Stream before decoding: "); stream.log(); TTCN_Logger::end_event(); ret_val.cs() = payload_len_2_coding_scheme(stream.lengthof()); /* use automatic/generated decoder for header */ ret_val.mac__hdr().decode(UlMacDataHeader_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("dec_RlcmacUlDataBlock(): Stream after decoding hdr: "); ttcn_buffer.log(); TTCN_Logger::end_event(); TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("dec_RlcmacUlDataBlock(): ret_val after decoding hdr: "); ret_val.log(); TTCN_Logger::end_event(); /* Manually decoder remainder of ttcn_buffer, containing optional header octets, * optional tlli, optional pfi and LLC Blocks */ /* optional extension octets, containing LI+M+E of Llc blocks */ if (ret_val.mac__hdr().e() == false) { /* extension octet follows, i.e. optional Llc length octets */ while (1) { /* decode one more extension octet with LlcBlocHdr inside */ LlcBlock lb; lb.hdr()().decode(LlcBlockHdr_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); ret_val.blocks()[num_llc_blocks++] = lb; TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("dec_RlcmacUlDataBlock(): Stream after decoding ExtOct: "); ttcn_buffer.log(); TTCN_Logger::end_event(); TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("dec_RlcmacUlDataBlock(): ret_val after decoding ExtOct: "); ret_val.log(); TTCN_Logger::end_event(); /* if E == '1'B, we can proceed further */ if (lb.hdr()().e() == true) break; } } /* parse optional TLLI */ if (ret_val.mac__hdr().tlli__ind()) { ret_val.tlli() = OCTETSTRING(4, ttcn_buffer.get_read_data()); ttcn_buffer.increase_pos(4); } else { ret_val.tlli() = OMIT_VALUE; } /* parse optional PFI */ if (ret_val.mac__hdr().pfi__ind()) { ret_val.pfi().decode(RlcmacUlDataBlock_pfi_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); } else { ret_val.pfi() = OMIT_VALUE; } /* RLC blocks at end */ if (ret_val.mac__hdr().e() == true) { LlcBlock lb; unsigned int length = ttcn_buffer.get_read_len(); /* LI not present: The Upper Layer PDU that starts with the current RLC data block either * fills the current RLC data block precisely or continues in the following in-sequence RLC * data block */ lb.hdr() = OMIT_VALUE; lb.payload() = OCTETSTRING(length, ttcn_buffer.get_read_data()); ttcn_buffer.increase_pos(length); ret_val.blocks()[0] = lb; } else { if (ret_val.blocks().is_bound()) { for (int i = 0; i < ret_val.blocks().size_of(); i++) { unsigned int length = ret_val.blocks()[i].hdr()().length__ind(); if (length > ttcn_buffer.get_read_len()) length = ttcn_buffer.get_read_len(); ret_val.blocks()[i].payload() = OCTETSTRING(length, ttcn_buffer.get_read_data()); ttcn_buffer.increase_pos(length); } } } TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("dec_RlcmacUlDataBlock(): Stream before return: "); ttcn_buffer.log(); TTCN_Logger::end_event(); TTCN_Logger::begin_event(TTCN_Logger::DEBUG_ENCDEC); TTCN_Logger::log_event_str("dec_RlcmacUlDataBlock(): ret_val before return: "); ret_val.log(); TTCN_Logger::end_event(); return ret_val; } static EgprsUlMacDataHeader dec__EgprsUlMacDataHeader_type1(const OCTETSTRING& stream) { EgprsUlMacDataHeader ret_val; fprintf(stderr, "FIXME: Not implemented! %s (%s:%u)\n", __func__, __FILE__, __LINE__); return ret_val; } static EgprsUlMacDataHeader dec__EgprsUlMacDataHeader_type2(const OCTETSTRING& stream) { EgprsUlMacDataHeader ret_val; fprintf(stderr, "FIXME: Not implemented! %s (%s:%u)\n", __func__, __FILE__, __LINE__); return ret_val; } static EgprsUlMacDataHeader dec__EgprsUlMacDataHeader_type3(const OCTETSTRING& stream) { TTCN_Buffer ttcn_buffer(stream); EgprsUlMacDataHeader ret_val; const struct gprs_rlc_ul_header_egprs_3 *egprs3; uint8_t tmp; egprs3 = static_cast ((const void *)ttcn_buffer.get_data()); ret_val.header__type() = EgprsHeaderType::RLCMAC__HDR__TYPE__3; ret_val.tfi() = egprs3->tfi_lo << 2 | egprs3->tfi_hi << 0; ret_val.countdown() = egprs3->cv; tmp = egprs3->si; ret_val.foi__si() = BITSTRING(1, &tmp); tmp = egprs3->r; ret_val.r__ri() = BITSTRING(1, &tmp); ret_val.bsn1() = egprs3->bsn1_lo << 5 | egprs3->bsn1_hi << 0; ret_val.cps() = egprs3->cps_lo << 2 | egprs3->cps_hi << 0; ret_val.pfi__ind() = egprs3->pi; tmp = egprs3->rsb; ret_val.rsb() = BITSTRING(1, &tmp); tmp = egprs3->spb; ret_val.spb() = BITSTRING(2, &tmp); ttcn_buffer.increase_pos(sizeof(*egprs3)); return ret_val; } RlcmacUlEgprsDataBlock dec__RlcmacUlEgprsDataBlock(const OCTETSTRING& stream) { RlcmacUlEgprsDataBlock ret_val; TTCN_Buffer ttcn_buffer(stream); TTCN_Buffer aligned_buffer; int num_llc_blocks = 0; unsigned int data_block_bits, data_block_offsets[2]; unsigned int num_calls; const uint8_t *ti_e; ret_val.mcs() = payload_len_2_coding_scheme(stream.lengthof()); switch (ret_val.mcs()) { case CodingScheme::MCS__1: case CodingScheme::MCS__2: case CodingScheme::MCS__3: case CodingScheme::MCS__4: ret_val.mac__hdr() = dec__EgprsUlMacDataHeader_type3(stream); break; case CodingScheme::MCS__5: case CodingScheme::MCS__6: ret_val.mac__hdr() = dec__EgprsUlMacDataHeader_type2(stream); break; case CodingScheme::MCS__7: case CodingScheme::MCS__8: case CodingScheme::MCS__9: ret_val.mac__hdr() = dec__EgprsUlMacDataHeader_type1(stream); break; } setup_rlc_mac_priv(ret_val.mcs(), ret_val.mac__hdr().header__type(), true, &num_calls, &data_block_bits, data_block_offsets); get_egprs_data_block(ttcn_buffer, data_block_offsets[0], data_block_bits, aligned_buffer); ti_e = aligned_buffer.get_read_data(); ret_val.tlli__ind() = *ti_e & 0x02 ? true : false; ret_val.e() = *ti_e & 0x01 ? true : false; aligned_buffer.increase_pos(1); /* Manually decoder remainder of aligned_buffer, containing optional header octets, * optional tlli, optional pfi and LLC Blocks */ /* optional extension octets, containing LI+M+E of Llc blocks */ if (ret_val.e() == false) { /* extension octet follows, i.e. optional Llc length octets */ while (1) { /* decode one more extension octet with LlcBlocHdr inside */ EgprsLlcBlock lb; lb.hdr()().decode(EgprsLlcBlockHdr_descr_, aligned_buffer, TTCN_EncDec::CT_RAW); ret_val.blocks()[num_llc_blocks++] = lb; /* if E == '1'B, we can proceed further */ if (lb.hdr()().e() == true) break; } } /* parse optional TLLI */ if (ret_val.tlli__ind()) { ret_val.tlli() = OCTETSTRING(4, aligned_buffer.get_read_data()); aligned_buffer.increase_pos(4); } else { ret_val.tlli() = OMIT_VALUE; } /* parse optional PFI */ if (ret_val.mac__hdr().pfi__ind()) { ret_val.pfi().decode(RlcmacUlEgprsDataBlock_pfi_descr_, aligned_buffer, TTCN_EncDec::CT_RAW); } else { ret_val.pfi() = OMIT_VALUE; } /* RLC blocks at end */ if (ret_val.e() == true) { EgprsLlcBlock lb; unsigned int length = aligned_buffer.get_read_len(); /* LI not present: The Upper Layer PDU that starts with the current RLC data block either * fills the current RLC data block precisely or continues in the following in-sequence RLC * data block */ lb.hdr() = OMIT_VALUE; lb.payload() = OCTETSTRING(length, aligned_buffer.get_read_data()); aligned_buffer.increase_pos(length); ret_val.blocks()[0] = lb; } else { if (ret_val.blocks().is_bound()) { for (int i = 0; i < ret_val.blocks().size_of(); i++) { unsigned int length = ret_val.blocks()[i].hdr()().length__ind(); if (length > aligned_buffer.get_read_len()) length = aligned_buffer.get_read_len(); ret_val.blocks()[i].payload() = OCTETSTRING(length, aligned_buffer.get_read_data()); aligned_buffer.increase_pos(length); } } } return ret_val; } RlcmacUlBlock dec__RlcmacUlBlock(const OCTETSTRING& stream) { RlcmacUlBlock ret_val; size_t stream_len = stream.lengthof(); CodingScheme::enum_type cs_mcs = payload_len_2_coding_scheme(stream_len); unsigned char pt; switch (cs_mcs) { case CodingScheme::CS__1: case CodingScheme::CS__2: case CodingScheme::CS__3: case CodingScheme::CS__4: pt = stream[0].get_octet() >> 6; if (pt == MacPayloadType::MAC__PT__RLC__DATA) ret_val.data() = dec__RlcmacUlDataBlock(stream); else ret_val.ctrl() = dec__RlcmacUlCtrlBlock(stream); break; case CodingScheme::MCS__1: case CodingScheme::MCS__2: case CodingScheme::MCS__3: case CodingScheme::MCS__4: case CodingScheme::MCS__5: case CodingScheme::MCS__6: case CodingScheme::MCS__7: case CodingScheme::MCS__8: case CodingScheme::MCS__9: ret_val.data__egprs() = dec__RlcmacUlEgprsDataBlock(stream); break; } return ret_val; } ///////////////////// // ENCODE ///////////////////// /* ENCODE DOWNLINK */ OCTETSTRING enc__RlcmacDlDataBlock(const RlcmacDlDataBlock& si) { RlcmacDlDataBlock in = si; OCTETSTRING ret_val; TTCN_Buffer ttcn_buffer; int i; /* Fix 'e' bit of initial header based on following blocks */ if (!in.blocks().is_bound() || (in.blocks().size_of() == 1 && !in.blocks()[0].hdr().is_bound())) in.mac__hdr().hdr__ext().e() = true; else in.mac__hdr().hdr__ext().e() = false; /* use automatic/generated decoder for header */ in.mac__hdr().encode(DlMacDataHeader_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); /* Add LI octets, if any */ if (in.blocks().is_bound() && (in.blocks().size_of() != 1 || in.blocks()[0].hdr().is_bound())) { /* first write LI octets */ for (i = 0; i < in.blocks().size_of(); i++) { /* fix the 'E' bit in case it is not clear */ if (i < in.blocks().size_of()-1) in.blocks()[i].hdr()().e() = false; else in.blocks()[i].hdr()().e() = true; in.blocks()[i].hdr()().encode(LlcBlockHdr_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); } } if (in.blocks().is_bound()) { for (i = 0; i < in.blocks().size_of(); i++) { if (!in.blocks()[i].is_bound()) continue; ttcn_buffer.put_string(in.blocks()[i].payload()); } } encode_trailing_padding_spb(ttcn_buffer, in.cs()); ttcn_buffer.get_string(ret_val); return ret_val; } static void enc__RlcmacDlEgprsDataHeader_type1(const EgprsDlMacDataHeader& si, TTCN_Buffer& ttcn_buffer) { fprintf(stderr, "FIXME: Not implemented! %s (%s:%u)\n", __func__, __FILE__, __LINE__); } static void enc__RlcmacDlEgprsDataHeader_type2(const EgprsDlMacDataHeader& si, TTCN_Buffer& ttcn_buffer) { fprintf(stderr, "FIXME: Not implemented! %s (%s:%u)\n", __func__, __FILE__, __LINE__); } static void enc__RlcmacDlEgprsDataHeader_type3(const EgprsDlMacDataHeader& si, TTCN_Buffer& ttcn_buffer) { fprintf(stderr, "FIXME: Not implemented! %s (%s:%u)\n", __func__, __FILE__, __LINE__); } OCTETSTRING enc__RlcmacDlEgprsDataBlock(const RlcmacDlEgprsDataBlock& si) { RlcmacDlEgprsDataBlock in = si; OCTETSTRING ret_val; TTCN_Buffer ttcn_buffer; int i; /* Fix 'e' bit of initial header based on following blocks */ if (!in.blocks().is_bound() || (in.blocks().size_of() == 1 && !in.blocks()[0].hdr().is_bound())) in.e() = true; else in.e() = false; switch (in.mac__hdr().header__type()) { case EgprsHeaderType::RLCMAC__HDR__TYPE__1: enc__RlcmacDlEgprsDataHeader_type1(si.mac__hdr(), ttcn_buffer); break; case EgprsHeaderType::RLCMAC__HDR__TYPE__2: enc__RlcmacDlEgprsDataHeader_type2(si.mac__hdr(), ttcn_buffer); break; case EgprsHeaderType::RLCMAC__HDR__TYPE__3: enc__RlcmacDlEgprsDataHeader_type3(si.mac__hdr(), ttcn_buffer); default: break; /* TODO: error */ } /* Add LI octets, if any */ if (in.blocks().is_bound() && (in.blocks().size_of() != 1 || in.blocks()[0].hdr().is_bound())) { /* first write LI octets */ for (i = 0; i < in.blocks().size_of(); i++) { /* fix the 'E' bit in case it is not clear */ if (i < in.blocks().size_of()-1) in.blocks()[i].hdr()().e() = false; else in.blocks()[i].hdr()().e() = true; in.blocks()[i].hdr()().encode(EgprsLlcBlockHdr_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); } } if (in.blocks().is_bound()) { for (i = 0; i < in.blocks().size_of(); i++) { if (!in.blocks()[i].is_bound()) continue; ttcn_buffer.put_string(in.blocks()[i].payload()); } } encode_trailing_padding_spb(ttcn_buffer, in.mcs()); ttcn_buffer.get_string(ret_val); return ret_val; } OCTETSTRING enc__RlcmacDlBlock(const RlcmacDlBlock& si) { if (si.ischosen(RlcmacDlBlock::ALT_data__egprs)) return enc__RlcmacDlEgprsDataBlock(si.data__egprs()); else if (si.ischosen(RlcmacDlBlock::ALT_data)) return enc__RlcmacDlDataBlock(si.data()); else return enc__RlcmacDlCtrlBlock(si.ctrl()); } /* ENCODE UPLINK */ OCTETSTRING enc__RlcmacUlDataBlock(const RlcmacUlDataBlock& si) { RlcmacUlDataBlock in = si; OCTETSTRING ret_val; TTCN_Buffer ttcn_buffer; int i; if (!in.blocks().is_bound()) { /* we don't have any blocks: Add length value (zero) */ in.mac__hdr().e() = false; /* E=0: extension octet follows */ } else if (in.blocks().size_of() == 1 && in.blocks()[0].hdr() == OMIT_VALUE) { /* If there's only a single block, and that block has no HDR value defined, */ in.mac__hdr().e() = true; /* E=0: extension octet follows */ } else { /* Length value */ in.mac__hdr().e() = false; } /* Fix other presence indications */ in.mac__hdr().tlli__ind() = in.tlli().is_bound() && in.tlli() != OMIT_VALUE; in.mac__hdr().pfi__ind() = in.pfi().is_bound() && in.pfi() != OMIT_VALUE; /* use automatic/generated encoder for header */ in.mac__hdr().encode(UlMacDataHeader_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); if (in.mac__hdr().e() == false) { /* Add LI octets, if any */ if (!in.blocks().is_bound()) { ttcn_buffer.put_c(0x01); /* M=0, E=1 LEN=0 */ } else { for (i = 0; i < in.blocks().size_of(); i++) { #if 0 /* check for penultimate block */ if (i == in.blocks().size_of()-2) { /* if last block has no header, no more LI */ if (in.blocks()[i+1].hdr() == OMIT_VALUE) { in.blocks()[i].hdr()().more() = true; } else { /* header present, we have to encode LI */ in.blocks()[i].hdr()().more() = false; in.blocks()[i].hdr()().length__ind() = in.blocks()[i+1].payload().lengthof(); } } else if (i < in.blocks().size_of()-2) { /* one of the first blocks, before the penultimate or last */ in.blocks()[i].hdr()().e() = false; /* LI present */ /* re-compute length */ in.blocks()[i].hdr()().length__ind() = in.blocks()[i+1].payload().lengthof(); } /* Encode LI octet if E=0 */ } #endif if (in.blocks()[i].hdr() != OMIT_VALUE) { in.blocks()[i].hdr()().encode(LlcBlockHdr_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); } } } } if (in.mac__hdr().tlli__ind()) { ttcn_buffer.put_string(in.tlli()); } if (in.mac__hdr().pfi__ind()) { in.pfi().encode(RlcmacUlDataBlock_pfi_descr_, ttcn_buffer, TTCN_EncDec::CT_RAW); } if (in.blocks().is_bound()) { for (i = 0; i < in.blocks().size_of(); i++) { if (!in.blocks()[i].is_bound()) continue; ttcn_buffer.put_string(in.blocks()[i].payload()); } } encode_trailing_padding_spb(ttcn_buffer, in.cs()); ttcn_buffer.get_string(ret_val); return ret_val; } static void enc__RlcmacUlEgprsDataHeader_type1(const EgprsUlMacDataHeader& si, TTCN_Buffer& ttcn_buffer) { struct gprs_rlc_ul_header_egprs_1 egprs1; egprs1.r = bs2uint8(si.r__ri()); egprs1.si = bs2uint8(si.foi__si()); egprs1.cv = si.countdown(); egprs1.tfi_hi = si.tfi() >> 0; egprs1.tfi_lo = si.tfi() >> 2; egprs1.bsn1_hi = si.bsn1() >> 0; egprs1.bsn1_lo = si.bsn1() >> 5; egprs1.bsn2_hi = si.bsn2__offset() >> 0; egprs1.bsn2_lo = si.bsn2__offset() >> 2; egprs1.cps = si.cps(); egprs1.rsb = bs2uint8(si.rsb()); egprs1.pi = si.pfi__ind(); egprs1.spare_hi = 0; egprs1.spare_lo = 0; egprs1.dummy = 0; ttcn_buffer.put_s(sizeof(egprs1), (const unsigned char *)&egprs1); } static void enc__RlcmacUlEgprsDataHeader_type2(const EgprsUlMacDataHeader& si, TTCN_Buffer& ttcn_buffer) { struct gprs_rlc_ul_header_egprs_2 egprs2; egprs2.r = bs2uint8(si.r__ri()); egprs2.si = bs2uint8(si.foi__si()); egprs2.cv = si.countdown(); egprs2.tfi_hi = si.tfi() >> 0; egprs2.tfi_lo = si.tfi() >> 2; egprs2.bsn1_hi = si.bsn1() >> 0; egprs2.bsn1_lo = si.bsn1() >> 5; egprs2.cps_hi = si.cps() >> 0; egprs2.cps_lo = si.cps() >> 2; egprs2.rsb = bs2uint8(si.rsb()); egprs2.pi = si.pfi__ind(); egprs2.spare_hi = 0; egprs2.spare_lo = 0; egprs2.dummy = 0; ttcn_buffer.put_s(sizeof(egprs2), (const unsigned char *)&egprs2); } static void enc__RlcmacUlEgprsDataHeader_type3(const EgprsUlMacDataHeader& si, TTCN_Buffer& ttcn_buffer) { struct gprs_rlc_ul_header_egprs_3 egprs3; egprs3.r = bs2uint8(si.r__ri()); egprs3.si = bs2uint8(si.foi__si()); egprs3.cv = si.countdown(); egprs3.tfi_hi = si.tfi() >> 0; egprs3.tfi_lo = si.tfi() >> 2; egprs3.bsn1_hi = si.bsn1() >> 0; egprs3.bsn1_lo = si.bsn1() >> 5; egprs3.cps_hi = si.cps() >> 0; egprs3.cps_lo = si.cps() >> 2; egprs3.spb = bs2uint8(si.spb()); egprs3.rsb = bs2uint8(si.rsb()); egprs3.pi = si.pfi__ind(); egprs3.spare = 0; egprs3.dummy = 0; ttcn_buffer.put_s(sizeof(egprs3), (const unsigned char *)&egprs3); } OCTETSTRING enc__RlcmacUlEgprsDataBlock(const RlcmacUlEgprsDataBlock& si) { RlcmacUlEgprsDataBlock in = si; OCTETSTRING ret_val; TTCN_Buffer ttcn_buffer, aligned_buffer; int i; unsigned int data_block_bits, data_block_offsets[2]; unsigned int num_calls; CodingScheme mcs; mcs = RLCMAC__Templates::f__rlcmac__cps__htype__to__mcs(in.mac__hdr().cps(), in.mac__hdr().header__type()); //fprintf(stderr, "RLCMAC: infered MCS %s (%d)\n", mcs.enum_to_str(static_cast(mcs.as_int())), mcs.as_int()); if (!in.blocks().is_bound()) { /* we don't have nay blocks: Add length value (zero) */ in.e() = false; /* E=0: extension octet follows */ } else if (in.blocks().size_of() == 1 && in.blocks()[0].hdr() == OMIT_VALUE) { /* If there's only a single block, and that block has no HDR value defined, */ in.e() = true; /* E=0: extension octet follows */ } else { /* Length value */ in.e() = false; } /* Fix other presence indications */ in.tlli__ind() = in.tlli().is_bound() && in.tlli() != OMIT_VALUE; in.mac__hdr().pfi__ind() = in.pfi().is_bound() && in.pfi() != OMIT_VALUE; switch (in.mac__hdr().header__type()) { case EgprsHeaderType::RLCMAC__HDR__TYPE__1: enc__RlcmacUlEgprsDataHeader_type1(in.mac__hdr(), ttcn_buffer); break; case EgprsHeaderType::RLCMAC__HDR__TYPE__2: enc__RlcmacUlEgprsDataHeader_type2(in.mac__hdr(), ttcn_buffer); break; case EgprsHeaderType::RLCMAC__HDR__TYPE__3: enc__RlcmacUlEgprsDataHeader_type3(in.mac__hdr(), ttcn_buffer); default: break; /* TODO: error */ } /* Put first TI + E byte */ aligned_buffer.put_c((in.tlli__ind() & 0x01) << 1 | (in.e() & 0x01) << 0); //printbuffer("After encoding first byte", aligned_buffer); if (in.e() == false) { /* Add LI octets, if any */ if (!in.blocks().is_bound()) { aligned_buffer.put_c(0x01); /* M=0, E=1 LEN=0 */ } else { for (i = 0; i < in.blocks().size_of(); i++) { #if 0 /* check for penultimate block */ if (i == in.blocks().size_of()-2) { /* if last block has no header, no more LI */ if (in.blocks()[i+1].hdr() == OMIT_VALUE) { in.blocks()[i].hdr()().more() = true; } else { /* header present, we have to encode LI */ in.blocks()[i].hdr()().more() = false; in.blocks()[i].hdr()().length__ind() = in.blocks()[i+1].payload().lengthof(); } } else if (i < in.blocks().size_of()-2) { /* one of the first blocks, before the penultimate or last */ in.blocks()[i].hdr()().e() = false; /* LI present */ /* re-compute length */ in.blocks()[i].hdr()().length__ind() = in.blocks()[i+1].payload().lengthof(); } /* Encode LI octet if E=0 */ } #endif if (in.blocks()[i].hdr() != OMIT_VALUE) { in.blocks()[i].hdr()().encode(EgprsLlcBlockHdr_descr_, aligned_buffer, TTCN_EncDec::CT_RAW); } } } } if (in.tlli__ind()) { /* The TLLI is encoded in little endian for EGPRS (see * TS 44.060, figure 10.3a.2.1, note 2) */ OCTETSTRING tlli = in.tlli(); aligned_buffer.put_c(tlli[3].get_octet()); aligned_buffer.put_c(tlli[2].get_octet()); aligned_buffer.put_c(tlli[1].get_octet()); aligned_buffer.put_c(tlli[0].get_octet()); } if (in.mac__hdr().pfi__ind()) { in.pfi().encode(RlcmacUlEgprsDataBlock_pfi_descr_, aligned_buffer, TTCN_EncDec::CT_RAW); } //printbuffer("Before encoding EgprsLlc payload", aligned_buffer); if (in.blocks().is_bound()) { for (i = 0; i < in.blocks().size_of(); i++) { if (!in.blocks()[i].is_bound()) continue; aligned_buffer.put_string(in.blocks()[i].payload()); } } //printbuffer("After encoding EgprsLlc payload", aligned_buffer); setup_rlc_mac_priv(mcs, in.mac__hdr().header__type(), true, &num_calls, &data_block_bits, data_block_offsets); //printbuffer("before merging data block", ttcn_buffer); put_egprs_data_block(aligned_buffer, data_block_offsets[0], data_block_bits, ttcn_buffer); //printbuffer("after merging data block", ttcn_buffer); encode_trailing_padding_spb(ttcn_buffer, in.mcs()); ttcn_buffer.get_string(ret_val); return ret_val; } OCTETSTRING enc__RlcmacUlBlock(const RlcmacUlBlock& si) { if (si.ischosen(RlcmacUlBlock::ALT_data__egprs)) return enc__RlcmacUlEgprsDataBlock(si.data__egprs()); else if (si.ischosen(RlcmacUlBlock::ALT_data)) return enc__RlcmacUlDataBlock(si.data()); else return enc__RlcmacUlCtrlBlock(si.ctrl()); } } // namespace