FreeCalypso > hg > freecalypso-citrine
view ccd/cdc_com.c @ 0:75a11d740a02
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Thu, 09 Jun 2016 00:02:41 +0000 |
| parents | |
| children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : cdc_com.c +----------------------------------------------------------------------------- | Copyright 2002 Texas Instruments Berlin, AG | All rights reserved. | | This file is confidential and a trade secret of Texas | Instruments Berlin, AG | The receipt of or possession of this file does not convey | any rights to reproduce or disclose its contents or to | manufacture, use, or sell anything it may describe, in | whole, or in part, without the specific written consent of | Texas Instruments Berlin, AG. +----------------------------------------------------------------------------- | Purpose : Condat Conder Decoder | Definitions of common functions for encoding and decoding of | GSM, GPRS or UMTS air interface messages +----------------------------------------------------------------------------- */ #ifdef _MSDOS #include <dos.h> #include <conio.h> #endif /* * standard definitions like UCHAR, ERROR etc. */ #include "typedefs.h" #include "header.h" #include <string.h> #include <stdlib.h> /* * Prototypes of ccd (USE_DRIVER EQ undef) for prototypes only * look at ccdapi.h */ #undef USE_DRIVER #include "ccdapi.h" /* * Types and functions for bit access and manipulation */ #include "ccd_globs.h" #include "bitfun.h" /* * Declaration of coder/decoder-tables */ #include "ccdtable.h" #include "ccddata.h" /* * Prototypes and constants in the common part of ccd */ #include "ccd.h" #include "ccd_codingtypes.h" /* * Need memory allocation functions for dynamic arrays (pointers) */ #ifdef DYNAMIC_ARRAYS #include "vsi.h" #endif #ifndef RUN_FLASH const UBYTE padding_bits[8] = {0, 0, 1, 0, 1, 0, 1, 1}; const UBYTE padding_bits_prev[8] = {1, 0, 0, 1, 0, 1, 0, 1}; #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* Attention for RUN_...: static data (used in cdc_skipElem) */ static UBYTE dummy[256]; #endif /* !RUN_FLASH */ typedef struct unknownTag { U8 errCode; U8 tag; U16 bitpos; struct unknownTag *next; }T_UNKNOWN_TAG; #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_init_ctx_table | +--------------------------------------------------------------------+ PURPOSE : init the iei_ctx table. This must be done before decoding a message. */ static void cdc_init_ctx_table (T_CCD_Globs *globs) { int i; #ifdef DEBUG_CCD TRACE_CCD (globs, "CONTEXT table init"); #endif for (i=0; i<MAX_RECURSIONS_PER_MSG; i++) { globs->iei_ctx[i].valid = FALSE; } globs->numEOCPending = 0; } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CCD | | STATE : code ROUTINE : cdc_BCD_decode | +--------------------------------------------------------------------+ PURPOSE : Decoding of an bitstream containing a BCD string with k digits. If the first digit in the bitstream is DIGIT_2, the digits are ordered in the Bitstream as follow: MSBit LSBit 8 7 6 5 4 3 2 1 DIGIT_2 DIGIT_1 Octett n DIGIT_4 DIGIT_3 Octett n+1 : : : : : : : : DIGIT_Z DIGIT_X Octett n+m if the number of the digits is odd, the last Octett contains the bit pattern 1111 in the most significant nibble. : : : : : : : : 1 1 1 1 DIGIT_X Octett n+m NOTE: If the first digit in the bitstream is DIGIT_1, the digits are ordered in a different way: MSBit LSBit 8 7 6 5 4 3 2 1 DIGIT_1 XXXXXXX Octett n DIGIT_3 DIGIT_2 Octett n+1 DIGIT_5 DIGIT_4 Octett n+2 : : : : : : : : DIGIT_Z DIGIT_X Octett n+m In this case, if the number of the digits is even, the last octett contains the bit pattern 1111 in the most significant nibble. : : : : : : : : 1 1 1 1 DIGIT_X Octett n+m The amount of digits may be constant or variable. NOTE: A special case (type BCD_NOFILL) is the encoding and decoding of a BCD string starting with DIGIT_2 but without setting/checking the most significant nibble of Octet n+m. This nibble belongs to the next IE (usual coded by type BCD_MNC). Type BCD_NOFILL is coded by startDigit EQ 2. */ void cdc_BCD_decode (const ULONG e_ref, UBYTE startDigit, T_CCD_Globs *globs) { BOOL is_variable; UBYTE *digits; UBYTE *addr_c_xxx; ULONG i, max_rep, nibbles_to_read, repeat; ULONG cix_ref, num_prolog_steps, prolog_step_ref; int k; #ifdef DEBUG_CCD #ifndef CCD_SYMBOLS TRACE_CCD (globs, "cdc_BCD_decode()"); #else TRACE_CCD (globs, "cdc_BCD_decode() %s", ccddata_get_alias((USHORT) e_ref, 1)); #endif #endif cix_ref = melem[e_ref].calcIdxRef; num_prolog_steps = calcidx[cix_ref].numPrologSteps; prolog_step_ref = calcidx[cix_ref].prologStepRef; /* * if this element is conditional, check the condition */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return; /* * if this element have a defined Prolog * we have to process it before decoding the bitstream */ if (num_prolog_steps) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } /* * if this element is repeatable, and the number of * repeats depends on another element, calculate the repeater */ if (melem[e_ref].repType NEQ ' ') { is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs); } else { repeat = 1; is_variable = FALSE; } /* * setup the offset into the C-structure for this element */ globs->pstructOffs = melem[e_ref].structOffs; if (melem[e_ref].optional) { /* * for optional elements set the valid-flag */ globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE; } if (is_variable) { /* * for variable sized elements store the min-value * as counter into the C-Structure (c_xxx). */ addr_c_xxx = (UBYTE *) (globs->pstruct + globs->pstructOffs++); if (max_rep > 255) globs->pstructOffs++; } else addr_c_xxx = NULL; digits = (UBYTE *) (globs->pstruct + globs->pstructOffs); if (startDigit EQ 1) { /* * read the BCD digits out of the bitstream. * The read order is 1,X,3,2,5,4 ... */ /* * if the first digit is digit_1 read it and skip * the next 4 bits, because they do not belong to * the BCD stream. */ digits[0] = bf_decodeByteNumber (4, globs); bf_incBitpos (4, globs); /* * make a correction on the repeatvalue */ if (melem[e_ref].repType NEQ ' ') { is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs); } k = 2; for (i=0; i<repeat; i++) { digits[k] = bf_decodeByteNumber (4, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "BCD digit (%X) read", (USHORT) digits[k]); #endif k = ((k&1) EQ 0) ? (k-1) : (k+3); } } else { /* * read the BCD digits out of the bitstream. * The read order is 2,1,4,3,6,5 ... */ k = 1; nibbles_to_read = repeat; if (repeat & 1) nibbles_to_read++; for (i=0; i<nibbles_to_read; i++) { digits[k] = bf_decodeByteNumber (4, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "BCD digit (%X) read", (USHORT) digits[k]); #endif k = ((k&1) EQ 1) ? (k-1) : (k+3); } } /* * check the 1111 pattern and the even odd criteria */ if (startDigit EQ 1) { if ((repeat & 1) EQ 0) { /* even number of digits */ if (digits[repeat] NEQ 0xf) repeat++; } } else { if ((repeat & 1) EQ 1) { /* odd number of digits */ if (digits[repeat] NEQ 0xf AND startDigit EQ 0) { /* * if there is no 1111 pattern generate an error */ ccd_setError (globs, ERR_PATTERN_MISMATCH, CONTINUE, (USHORT) (globs->bitpos-8), (USHORT) -1); } } else { /* even number of digits - the last may be 0xf */ if (digits[repeat-1] EQ 0xf) repeat--; /* 0x0f dosn't belong to the coded digit string */ } } if (addr_c_xxx NEQ NULL) { /* * store the number of digits into the * c_xxx variable if there is one. */ if (max_rep > 65535) { ULONG *addr_c_xxx_u32; addr_c_xxx_u32 = (ULONG *)addr_c_xxx; *addr_c_xxx_u32 = repeat; } else if (max_rep > 255) { USHORT *addr_c_xxx_u16; addr_c_xxx_u16 = (USHORT *)addr_c_xxx; *addr_c_xxx_u16 = (USHORT) repeat; } else *addr_c_xxx = (UBYTE) repeat; } } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CCD | | STATE : code ROUTINE : cdc_BCD_encode | +--------------------------------------------------------------------+ PURPOSE : encoding a Bytearray, that contain a BCD Number, into bitstream. The digits coded in the following order into the Bitstream: MSBit LSBit 7 8 6 5 4 3 2 1 DIGIT_2 DIGIT_1 Octett n DIGIT_4 DIGIT_3 Octett n+1 : : : : : : : : DIGIT_Z DIGIT_X Octett n+m if the number of the digits are odd, the bit pattern 1111 will be coded in the most significant nibble of the last Octett. : : : : : : : : 1 1 1 1 DIGIT_X Octett n+m The amount of digits may be constant or variable. */ void cdc_BCD_encode (const ULONG e_ref, UBYTE startDigit, T_CCD_Globs *globs) { ULONG repeat; int k; register UBYTE *digits; BOOL fullBitsNeeded=FALSE; ULONG cix_ref, num_prolog_steps, prolog_step_ref; #ifdef DEBUG_CCD #ifndef CCD_SYMBOLS TRACE_CCD (globs, "cdc_BCD_encode()"); #else TRACE_CCD (globs, "cdc_BCD_encode() %s", ccddata_get_alias((USHORT) e_ref, 1)); #endif #endif cix_ref = melem[e_ref].calcIdxRef; num_prolog_steps = calcidx[cix_ref].numPrologSteps; prolog_step_ref = calcidx[cix_ref].prologStepRef; /* * if this element is conditional, check the condition */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return; /* * if this element have a defined Prolog * we have to process it before decoding the bitstream */ if (num_prolog_steps) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } /* * setup the offset into the C-structure for this element */ globs->pstructOffs = melem[e_ref].structOffs; if (melem[e_ref].optional) { /* * for optional elements check the valid-flag */ if (globs->pstruct[globs->pstructOffs++] == FALSE) return; #ifdef DEBUG_CCD else if (globs->pstruct [melem[e_ref].structOffs] != TRUE) { TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d", e_ref); } #endif } /* * if this element is repeatable, and the number of * repeats depends on another element, calculate the repeater */ if (melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i') { /* * for variable sized elements read the amount * of repeats out of the C-Structure (c_xxx). * If the number of repeats given by the C-Structure * exceeds the allowed value (maxRepeat) CCD gives a warning! */ if (melem[e_ref].maxRepeat > 255) { ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++)); repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat); if (repeat < count) ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, e_ref, globs->pstruct + globs->pstructOffs); } else { repeat = (ULONG)MINIMUM (globs->pstruct[globs->pstructOffs], melem[e_ref].maxRepeat); if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) ) ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } globs->pstructOffs++; } else if (melem[e_ref].repType EQ 'c') repeat = (ULONG) melem[e_ref].maxRepeat; else repeat = 1; /* There seems to exist cases where address contains no digits. */ if (repeat EQ 0) return; /* * setup the read pointer to the byte array that contain * the BCD number. */ digits = (UBYTE *) (globs->pstruct + globs->pstructOffs); if (startDigit EQ 1) { /* * write the BCD digits into the bitstream. * The write order is 1,X,3,2,5,4 ... */ if ((repeat & 1) EQ 0) { /* * for even digits store the 1111 pattern at last digit */ fullBitsNeeded = TRUE; } /* * if the first digit is digit_1 write it and skip * the next 4 bits, because they does not belong to * the BCD stream. */ bf_codeByteNumber (4, digits[0], globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "BCD digit (%X) written", (USHORT) digits[0]); TRACE_CCD (globs, "skipping 4 bits"); #endif bf_incBitpos (4, globs); k = 2; while (--repeat>1) { bf_codeByteNumber (4, digits[k], globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "BCD digit (%X) written", (USHORT) digits[k]); #endif k = ((k&1) EQ 0) ? (k-1) : (k+3); } if (repeat) { if (fullBitsNeeded) { bf_codeByteNumber (4, 0xf, globs); k = ((k&1) EQ 0) ? (k-1) : (k+3); } bf_codeByteNumber (4, digits[k], globs); } } else { /* * store the BCD digits into the bitstream. * The write order is 2,1,4,3,6,5 ... */ if (repeat & 1) { /* * for odd digits store the 1111 pattern at last digit * in case of type BCD_NOFILL use 0 instead */ fullBitsNeeded = TRUE; } k = 1; while ( repeat-- > 1) { bf_codeByteNumber (4, digits[k], globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "BCD digit (%X) written", (USHORT) digits[k]); #endif k = ((k&1) EQ 1) ? (k-1) : (k+3); } if (fullBitsNeeded) { bf_codeByteNumber (4, (UBYTE)((startDigit NEQ 2) ? 0xf : 0), globs); k = ((k&1) EQ 1) ? (k-1) : (k+3); } bf_codeByteNumber (4, digits[k], globs); } } #endif /* !RUN_INT_RAM */ #ifndef RUN_FLASH /* Attention for RUN_...: static function */ /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_init_table | +--------------------------------------------------------------------+ PURPOSE : init the iei_table for each new msg that is to be decoded. The c_ref references a composition (msg). The function initialises the table entrys only for the used iei for this message. */ static void cdc_init_table (const ULONG c_ref, T_CCD_Globs *globs) { ULONG look_up; ULONG num_elems; ULONG ie_table_idx; ULONG rlevel = globs->ccd_recurs_level; if (globs->iei_ctx[rlevel].valid AND rlevel < (ULONG) globs->last_level) { int i; /* * this iei context has been initialized before, so * no action for this. All deeper levels must be set * to invalid; */ for (i=globs->last_level; i<MAX_RECURSIONS_PER_MSG; i++) globs->iei_ctx[i].valid = FALSE; #ifdef DEBUG_CCD TRACE_CCD (globs, "TAG table init for old level %d", rlevel); #endif } else { /* * this iei context has not been initialized before, so * initialize the iei_table for this. */ #ifdef DEBUG_CCD TRACE_CCD (globs, "TAG table init for new level %d", rlevel); #endif look_up = (ULONG) mcomp[c_ref].componentRef; num_elems = (ULONG) mcomp[c_ref].numOfComponents; /* * store the startposition of the corresponding melem table and * the number of elements in the IEtable */ globs->iei_ctx[rlevel].melemStart = (USHORT) look_up; globs->iei_ctx[rlevel].ieTableLen = (USHORT) num_elems; globs->iei_ctx[rlevel].EOCPending = FALSE; globs->iei_ctx[rlevel].countSkipped = 0; /* * for each element with an iei (ident) setup the * the iei_table-entry. */ ie_table_idx = 0; /* * if the number of IE in this message is greater than * the allocated IEItable, generate an error. */ if (num_elems > MAX_IE_PER_MSG) ccd_setError (globs, ERR_INTERNAL_ERROR, BREAK, (USHORT) -1); while (num_elems--) { if (melem[look_up].ident NEQ 0xffff) { globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident = (UBYTE) melem[look_up].ident; /* * GSM1TV elements have only a 4 bit Tag (T). For this * elements we have to shift the ident into the upper nibble * and set the lower nibble to zero. For GSM2T elements and * GSM1TV elements set the MSBit (Bit7). */ if (melem[look_up].codingType EQ CCDTYPE_GSM1_TV) { /* * shift into the upper nibble, clear the lower nibble * and set the MSBit. */ globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident <<= 4; globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident |= 0x80; globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident &= 0xf0; } else { if (melem[look_up].codingType EQ CCDTYPE_GSM2_T) { /* * Set the MSBit. */ globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident |= 0x80; } } globs->iei_ctx[rlevel].iei_table[ie_table_idx].act_amount = 0; globs->iei_ctx[rlevel].iei_table[ie_table_idx].exhausted = FALSE; switch (melem[look_up].codingType) { case CCDTYPE_GSM1_TV: case CCDTYPE_GSM2_T: case CCDTYPE_GSM3_TV: case CCDTYPE_GSM4_TLV: case CCDTYPE_GSM5_TV: case CCDTYPE_GSM5_TLV: case CCDTYPE_GSM1_ASN: case CCDTYPE_GSM6_TLV: globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid = TRUE; break; default: globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid = FALSE; break; } } else globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid = FALSE; #ifdef DEBUG_CCD TRACE_CCD (globs, "iei_table[%d] v=%d ident=%x level=%d", ie_table_idx, globs->iei_ctx[rlevel].iei_table[ie_table_idx].valid, globs->iei_ctx[rlevel].iei_table[ie_table_idx].ident, rlevel); #endif look_up++; ie_table_idx++; } globs->iei_ctx[rlevel].valid = TRUE; } } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* Attention for RUN_...: static function */ /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_search_table | +--------------------------------------------------------------------+ PURPOSE : search on the iei_table for the given TAG (T). if the TAG can be found (and - in case of CCDTYPE_GSM1_ASN - if the information element isn't exhausted), the table index was returned as a difference between the found index and the aktIndex, -127 otherwise. */ static int cdc_search_table ( int akt_index, ULONG t, BOOL limited, BOOL *nonTaggedFound, T_CCD_Globs *globs ) { int tab_idx; ULONG iei; int ret = -127; ULONG rec_level = globs->ccd_recurs_level; /* * search from the akt position to the end of the table. * This is faster, because in correct messages the found Tag * is at a later position in the table. */ tab_idx = akt_index; *nonTaggedFound = FALSE; while (tab_idx < (int) globs->iei_ctx[rec_level].ieTableLen) { #ifdef DEBUG_CCD TRACE_CCD (globs, "looking for Tag(%x) iei_table[%d] v=%d ident=%x level=%d", t, tab_idx, globs->iei_ctx[rec_level].iei_table[tab_idx].valid, globs->iei_ctx[rec_level].iei_table[tab_idx].ident, rec_level); #endif if (globs->iei_ctx[rec_level].iei_table[tab_idx].valid) { if (limited) { iei= (ULONG)(globs->iei_ctx[rec_level].iei_table[tab_idx].ident & 0x7f); } else { iei= (ULONG)(globs->iei_ctx[rec_level].iei_table[tab_idx].ident); } if ( iei EQ t ) { if ( globs->iei_ctx[rec_level].iei_table[tab_idx].exhausted EQ FALSE ) { return (tab_idx-akt_index); } else if ( (globs->iei_ctx[rec_level].melemStart + akt_index) EQ (int) globs->iei_ctx[rec_level].melemLast) { /* * allows multiple appearance of the repeated element is coded as * TLV0 TLV1 TLV2 .... */ return (tab_idx-akt_index); } else { ret = (tab_idx-akt_index); } } } else *nonTaggedFound = TRUE; tab_idx++; } tab_idx = 0; while (tab_idx < akt_index) { #ifdef DEBUG_CCD TRACE_CCD (globs, "looking for Tag(%x) iei_table[%d] v=%d ident=%x level=%d", t, tab_idx, globs->iei_ctx[rec_level].iei_table[tab_idx].valid, globs->iei_ctx[rec_level].iei_table[tab_idx].ident, rec_level); #endif if (limited) { iei= (ULONG)(globs->iei_ctx[rec_level].iei_table[tab_idx].ident & 0x7f); } else { iei= (ULONG) globs->iei_ctx[rec_level].iei_table[tab_idx].ident; } if (globs->iei_ctx[rec_level].iei_table[tab_idx].valid AND (iei EQ t) ) { if ( globs->iei_ctx[rec_level].iei_table[tab_idx].exhausted EQ FALSE ) { return (tab_idx-akt_index); } else { ret = (tab_idx-akt_index); } } tab_idx++; } if (ret != -127) { globs->SequenceError = TRUE; } return ret; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* Attention for RUN_...: static function */ /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_decode_L | +--------------------------------------------------------------------+ PURPOSE : Decode the length element of TLV and LV values */ static ULONG cdc_decode_L (const ULONG e_ref, const ULONG len_l, T_CCD_Globs *globs) { ULONG l; switch (melem[e_ref].codingType) { case CCDTYPE_GSM1_ASN: l = (ULONG) bf_decodeByteNumber (8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "decoding 8 bits, l = (%x)", l); #endif if (l EQ 0x80) l = 0xFFFF; else if (l EQ 0x81) { l = (ULONG) bf_decodeByteNumber (8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "decoding 8 bits after 0x81, l = (%x)", l); #endif } else if (l EQ 0x82) { l = bf_decodeShortNumber (16, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "decoding 16 bits after 0x82, l = (%x)", l); #endif } break; case CCDTYPE_GSM5_TLV: l = (ULONG) bf_decodeByteNumber (8, globs); if (l EQ 0x81) { l = (ULONG) bf_decodeByteNumber (8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "decoding 8 bits after 0x81, l = (%x)", l); } else { TRACE_CCD (globs, "decoding 8 bits, l = (%x)", l); #endif } break; case CCDTYPE_GSM6_TLV: l = bf_decodeShortNumber (16, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "decoding 16 bits, l = (%x)", l); #endif break; default: l = (ULONG) bf_decodeByteNumber (len_l, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "decoding %d bits, l = (%x)", len_l, l); #endif break; } /* * Write the value of l at the end of UPN Stack. * this could be read by an IE of the coding type NO_CODE. */ globs->KeepReg[0] = l ; return l; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* Attention for RUN_...: static function */ /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_tagged_LV_decode| +--------------------------------------------------------------------+ PURPOSE : If the parameter lenL is set to a positive value, this function decodes the L-component. After this it decodes the element referenced by eRef out of the bitstream into the C-Structure (globs->pstruct) at position globs->pstructOffs. If a repeat value is defined for this element, this function decodes only one appeareance of the element because it is a tagged element. In this case the decoded element is stored in an array wich is indexed by eIndex; */ static BOOL cdc_tagged_LV_decode (const ULONG e_ref, ULONG e_index, const ULONG len_l, T_CCD_Globs *globs) { ULONG amount, l; USHORT act_maxBP, tmp_maxBP; BOOL endOfComposition = FALSE; BOOL asn1=FALSE; U32 offset=0; #ifdef DYNAMIC_ARRAYS U8 *old_pstruct = NULL; #endif if (melem[e_ref].codingType EQ CCDTYPE_GSM1_ASN) asn1 = TRUE; if (melem[e_ref].elemType NEQ 'S') { /* * set the offset into the C-structure for this element. */ if (melem[e_ref].optional) { globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE; } if (melem[e_ref].repType EQ 'i') { /* * The number of appearance of all repeatable IEs may * differ in a message. So we have to store the number * in a c_xxx counter into the C-Structure. */ if (melem[e_ref].maxRepeat > 65535) *(ULONG *) (globs->pstruct + globs->pstructOffs++) = e_index; else if (melem[e_ref].maxRepeat > 255) *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) e_index; else globs->pstruct[globs->pstructOffs] = (UBYTE) e_index; globs->pstructOffs++; /* * Recalculate the struct offset for repeatable IEs. * New pointer types 'R' and 'F' are equivalent to 'V'. */ #ifdef DYNAMIC_ARRAYS offset = (e_index-1) * ((melem[e_ref].elemType EQ 'V' OR melem[e_ref].elemType EQ 'R' OR melem[e_ref].elemType EQ 'F' ) ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ); #else offset = (e_index-1) * ((melem[e_ref].elemType EQ 'V') ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ); #endif } } /* * If len_l > 0 read the l-Component out of the bistream. */ if (len_l) { if( len_l <= (ULONG) (globs->maxBitpos - globs->bitpos) ) { act_maxBP = globs->maxBitpos; l = cdc_decode_L (e_ref, len_l, globs); if (l EQ 0xFFFF) { /* * For ASN1-BER encoding we must look for the special * length 0x80 because it indicates the indefinite * length. This needs a special handling with later EOC tags. * */ globs->iei_ctx[globs->ccd_recurs_level].EOCPending = TRUE; globs->numEOCPending++; #ifdef DEBUG_CCD TRACE_CCD (globs, "implicit ASN1 length - EOC is pending"); #endif } else { /* * Calculate the max bitpos for this element */ tmp_maxBP = (USHORT) (globs->bitpos + (l*8)); if (globs->buflen < tmp_maxBP) { ccd_recordFault (globs, ERR_MSG_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } else if (globs->maxBitpos < tmp_maxBP) { ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } globs->maxBitpos = (USHORT)MINIMUM (globs->buflen, tmp_maxBP); tmp_maxBP = globs->maxBitpos; } } else { ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } } #ifdef DYNAMIC_ARRAYS /* * Check for pointer types; allocate memory if necessary. */ if ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')) { U32 cSize; U8 *addr; /* * Find size to allocate; * - Read from mcomp or mvar according to type */ cSize = (ULONG)((melem[e_ref].elemType EQ 'V' OR melem[e_ref].elemType EQ 'R') ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ); /* * Allocate additional memory */ addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS); /* If no memory, log error and return immediately */ if (addr EQ NULL) { ccd_setError (globs, ERR_NO_MEM, BREAK, (USHORT) -1); return endOfComposition; } else memset (addr, 0, (size_t)(cSize)); /* * Memory allocated; * 1. Save old "globs->pstruct" variables * 2. Store pointer to freshly allocated memory area in structure * 3. Initialize pstruct to point to the freshly allocated memory area. * 4. Initialize pstructOffs to 0 to start decoding at offset 0 * in the new memory area. */ old_pstruct = globs->pstruct; *(U8 **)(globs->pstruct + globs->pstructOffs) = addr; globs->pstruct = addr; globs->pstructOffs = 0; } else { globs->pstructOffs += offset; } #else /* DYNAMIC_ARRAYS */ globs->pstructOffs += offset; #endif /* DYNAMIC_ARRAYS */ /* * Decode the value. Keep caution with BER encoding of ASN1 integers. * All other types can be decoded by a generic function. */ if (asn1 AND melem[e_ref].elemType EQ 'V' AND melem[e_ref].repType EQ ' ' AND l NEQ 0xFFFF ) { #ifdef DEBUG_CCD #ifdef CCD_SYMBOLS TRACE_CCD (globs, "BER decoding of ASN.1 integer %s", ccddata_get_alias((USHORT) e_ref, 1)); #else TRACE_CCD (globs, "BER decoding of ASN.1 integer; e_ref = %d", melem[e_ref].elemRef); #endif #endif if (mvar[melem[e_ref].elemRef].cType EQ 'X') bf_readBitChunk (l*8, globs); else bf_readBits (l*8, globs); } else { amount = 1; if (len_l) { if (l > 0) { cdc_decodeElemvalue (e_ref, &amount, globs); } else { amount = 0; } } else { if (melem[e_ref].codingType != CCDTYPE_GSM2_T) cdc_decodeElemvalue (e_ref, &amount, globs); } } #ifdef DYNAMIC_ARRAYS /* * Restore globs->pstruct for possible use below */ if (old_pstruct NEQ NULL) globs->pstruct = old_pstruct; #endif if (asn1 AND globs->numEOCPending AND !bf_endOfBitstream(globs)) { UBYTE T = bf_decodeByteNumber (8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "looking for EOC decoding 8 bits T = (%x)", T); #endif if (T EQ 0) { #ifdef DEBUG_CCD TRACE_CCD (globs, "First EOC octet found"); #endif if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) { #ifdef DEBUG_CCD TRACE_CCD (globs, "End of ASN1 TLV"); #endif /* * Skip the second EOC octet. */ bf_incBitpos (8, globs); globs->iei_ctx[globs->ccd_recurs_level].EOCPending = FALSE; globs->numEOCPending--; } else { /* * The read first EOC octet belongs to an ASN1 TLV of a * higher recursion level. Let it be read and evalauted later * again for that IE. */ bf_setBitpos (globs->bitpos-8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "End of higer level ASN1 TLV"); TRACE_CCD (globs, "Decrementing bitpos by 8 to %d", globs->bitpos); #endif endOfComposition = TRUE; } } else { if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) { /* * EOC element is pending but not found. */ ccd_setError (globs, ERR_EOC_TAG_MISSING, BREAK, (USHORT) T, globs->bitpos-8, (USHORT) -1); bf_setBitpos (globs->bitpos-8, globs); } else { /* * normal TAG leave it in the bitstream */ #ifdef DEBUG_CCD TRACE_CCD (globs, "Normal TAG - Decrementing bitpos by 8 to %d", globs->bitpos); #endif bf_setBitpos (globs->bitpos-8, globs); } } } if (len_l) { if (!asn1) { if (globs->bitpos > tmp_maxBP) { ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } else { /* * set the bitpos to the end of the LV or TLV element */ bf_setBitpos (tmp_maxBP, globs); } } /* * set the maxBitpos to the next octet boundary if the * last non-spare IE does not end at an octet boundary. * This is necessary for avoiding an early end of decoding. */ /* globs->maxBitpos = globs->buflen; */ globs->maxBitpos = act_maxBP; } return endOfComposition; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* Attention for RUN_...: static function */ /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_normal_LV_decode| +--------------------------------------------------------------------+ PURPOSE : If the parameter lenL is set, this function decodes the L-component. After this it decodes the element referenced by eRef from the bitstream into the C-Structure (globs->pstruct) at position globs->pstructOffs. If a repeat value is defined for this element this function decodes the V-component multiple and stores the values into an array. */ static BOOL cdc_normal_LV_decode (const ULONG e_ref, const ULONG len_l, T_CCD_Globs *globs) { ULONG l, repeat, amount, max_rep; USHORT act_maxBP, tmp_maxBP; BOOL is_variable; BOOL endOfComposition = FALSE; BOOL asn1; BOOL length_in_bits; #ifdef DYNAMIC_ARRAYS U8 *old_pstruct = NULL; #endif switch (melem[e_ref].codingType) { case CCDTYPE_GSM1_ASN: asn1 = TRUE; length_in_bits = FALSE; break; case CCDTYPE_GSM7_LV: asn1 = FALSE; length_in_bits = TRUE; break; default: asn1 = FALSE; length_in_bits = FALSE; break; } /* * if this element is repeatable, and the number of * repeats depends on another element, calculate the repeater */ if (melem[e_ref].repType NEQ ' ') { is_variable = ccd_calculateRep (e_ref, &repeat, &max_rep, globs); } else { repeat = 1; is_variable = FALSE; } if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE. * Setup the offset into the C-structure for this element */ if (melem[e_ref].optional) { globs->pstruct[globs->pstructOffs++] = (UBYTE) TRUE; } if (is_variable) { /* * for variable sized elements store the min-value * as counter into the C-Structure (c_xxx). */ if (max_rep > 65535) *(ULONG *) (globs->pstruct + globs->pstructOffs++) = repeat; else if (max_rep > 255) *(USHORT *) (globs->pstruct + globs->pstructOffs++) = (USHORT) repeat; else globs->pstruct[globs->pstructOffs] = (UBYTE) repeat; globs->pstructOffs++; } } /* * if len_l > 0 read the l-Component out of the bistream. */ if (len_l) { if( len_l <= (ULONG)(globs->maxBitpos - globs->bitpos) ) { act_maxBP = globs->maxBitpos; l = cdc_decode_L (e_ref, len_l, globs); if (l EQ 0xFFFF) { /* * for ASN1 element coding we must look for the special * length 0x80 because it indicates the indefinite * length. This needs a special handling with later EOC tags. */ globs->iei_ctx[globs->ccd_recurs_level].EOCPending = TRUE; globs->numEOCPending++; #ifdef DEBUG_CCD TRACE_CCD (globs, "implicit ASN1 length - EOC is pending"); #endif } else { /* * calculate the max bitpos for this element */ if (!length_in_bits) l *= 8; tmp_maxBP = (USHORT) (globs->bitpos + l); if (globs->buflen < tmp_maxBP) { ccd_recordFault (globs, ERR_MSG_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } else if (globs->maxBitpos < tmp_maxBP) { ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } globs->maxBitpos = (USHORT)MINIMUM (globs->buflen, tmp_maxBP); tmp_maxBP = globs->maxBitpos; /* * for bitfields which appear in TLV or LV elements * we must calculate the length (repeat) from the l values */ if (melem[e_ref].repType EQ 'b') repeat = l; } } else { ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } } #ifdef DYNAMIC_ARRAYS /* * MVJ: Dynamic array addition. * Check for pointer types; allocate memory if necessary. */ if ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')) { ULONG cSize, rep; U8 *addr; /* * Find size to allocate; * - Read from mcomp or mvar according to type * - Unbounded (0-terminated) ASN1-types are allocated with MAX repeat */ if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) { rep = (ULONG) melem[e_ref].maxRepeat; } else { rep = repeat; } cSize = (ULONG)((melem[e_ref].elemType EQ 'V' OR melem[e_ref].elemType EQ 'R') ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ) * rep; /* * Allocate additional memory */ addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS); /* If no memory, log error and return immediately */ if (addr EQ NULL) { ccd_setError (globs, ERR_NO_MEM, BREAK, (USHORT) -1); return endOfComposition; } else memset (addr, 0, (size_t)cSize); /* * Memory allocated; * 1. Save old "globs->pstruct" variables * 2. Store pointer to freshly allocated memory area in structure * 3. Initialize pstruct to point to the freshly allocated memory area. * 4. Initialize pstructOffs to 0 to start decoding at offset 0 * in the new memory area. */ old_pstruct = globs->pstruct; *(U8 **)(globs->pstruct + globs->pstructOffs) = addr; globs->pstruct = addr; globs->pstructOffs = 0; } #endif /* * Decode the value. Keep caution with BER encoding of ASN1 integers. * All other types can be decoded by a generic function. */ if (asn1 AND melem[e_ref].elemType EQ 'V' AND melem[e_ref].repType EQ ' ' AND l NEQ 0xFFFF ) { #ifdef DEBUG_CCD #ifdef CCD_SYMBOLS TRACE_CCD (globs, "BER decoding of ASN.1 integer %s", ccddata_get_alias((USHORT) e_ref, 1)); #else TRACE_CCD (globs, "BER decoding of ASN.1 integer; e_ref = %d", melem[e_ref].elemRef); #endif #endif amount = l; if (mvar[melem[e_ref].elemRef].cType EQ 'X') bf_readBitChunk (l, globs); else bf_readBits (l, globs); } else { amount = repeat; if (len_l) { if (l > 0) { cdc_decodeElemvalue (e_ref, &amount, globs); } else { amount = 0; } } else { if (melem[e_ref].codingType != CCDTYPE_GSM2_T) cdc_decodeElemvalue (e_ref, &amount, globs); } } #ifdef DYNAMIC_ARRAYS /* * Restore globs->pstruct for possible use below */ if (old_pstruct NEQ NULL) { globs->pstruct = old_pstruct; } #endif if (amount NEQ repeat AND is_variable) { /* * If the number of decoded elements is not equal to the given * repeat value, because the bitstream or the IE ended, * store the new c_xxx value. */ globs->pstructOffs = melem[e_ref].structOffs; if (melem[e_ref].optional) globs->pstructOffs++; globs->pstruct[globs->pstructOffs] = (UBYTE) amount; if (melem[e_ref].repType NEQ 'i') { /* * if this element is not of the repeat style 'interval' * ([X..Y] where X and Y are constants) we have to generate * an ccd error because some outstanding repeats are missing. */ ccd_setError (globs, ERR_MAND_ELEM_MISS, CONTINUE, (USHORT) -1); } } if (asn1 AND globs->numEOCPending AND !bf_endOfBitstream(globs)) { UBYTE T = bf_decodeByteNumber (8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "looking for EOC decoding 8 bits T = (%x)", T); #endif if (T EQ 0) { #ifdef DEBUG_CCD TRACE_CCD (globs, "First EOC octet found"); #endif if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) { #ifdef DEBUG_CCD TRACE_CCD (globs, "End of ASN1 TLV"); #endif /* * Skip the second EOC octet. */ bf_incBitpos (8, globs); globs->iei_ctx[globs->ccd_recurs_level].EOCPending = FALSE; globs->numEOCPending--; } else { /* * The read first EOC octet belongs to an ASN1 TLV of a * higher recursion level. Let it be read and evalauted later * again for that IE. */ bf_setBitpos (globs->bitpos-8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "End of higer level ASN1 TLV"); TRACE_CCD (globs, "Decrementing bitpos by 8 to %d", globs->bitpos); #endif endOfComposition = TRUE; } } else { if (globs->iei_ctx[globs->ccd_recurs_level].EOCPending) { /* * EOC element is pending but not found. */ ccd_setError (globs, ERR_EOC_TAG_MISSING, BREAK, (USHORT) T, globs->bitpos-8, (USHORT) -1); bf_setBitpos (globs->bitpos-8, globs); } else { /* * normal TAG leave it in the bitstream */ #ifdef DEBUG_CCD TRACE_CCD (globs, "Normal TAG - Decrementing bitpos by 8 to %d", globs->bitpos); #endif bf_setBitpos (globs->bitpos-8, globs); } } } if (len_l) { if (!asn1) { if (globs->bitpos > tmp_maxBP) { ccd_recordFault (globs, ERR_ELEM_LEN, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } else { /* * set the bitpos to the end of the LV or TLV element */ bf_setBitpos (tmp_maxBP, globs); } } /* * set the maxBitpos to the next octet boundary if the * last non-spare IE does not end at an octet boundary. * This is necessary for avoiding an early end of decoding. */ /* globs->maxBitpos = globs->buflen; */ globs->maxBitpos = act_maxBP; } return endOfComposition; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* Attention for RUN_...: static function */ /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_skipElem | +--------------------------------------------------------------------+ PURPOSE : Skip an element referenced by eRef. This function perform a decoding of this element, but not into the target C-Structure. A dummy C-Structure is used instead. The complete decoding is necesary, because there is no information about the length of this element. B.t.w. for mandatory elements with fixed length, we can calculate the length, for optional elements or for variable sized arrays or bitbuffers it is impossible without decoding the entire element. */ static void cdc_skipElem (const ULONG e_ref, const ULONG len_l, T_CCD_Globs *globs) { UBYTE *ActStructAddr; U32 ActStructOffs; #ifdef DEBUG_CCD TRACE_CCD (globs, "skipping element %d", melem[e_ref].elemRef); #endif ActStructAddr = globs->pstruct; ActStructOffs = globs->pstructOffs; globs->pstruct = dummy; globs->pstructOffs = 0; cdc_tagged_LV_decode (e_ref, 1, len_l, globs); globs->pstruct = ActStructAddr; globs->pstructOffs = ActStructOffs; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_tlv_decode | +--------------------------------------------------------------------+ PURPOSE : Decoding of the T-components of T TV and TLV typed information elements. The len determines the length of the T component. This function returns the index (reference) of the rigth element. If the iei is not known in this composition (msg or submsg) an error handling is done and NO_REF is returned. */ SHORT cdc_tlv_decode (const ULONG c_ref, const ULONG e_ref, const T_TLV_SORT *tlv_inf, T_CCD_Globs *globs) { ULONG repeat, max_rep; ULONG ie_amount, l, len_l, len_t, t; BOOL is_variable, nonTagged, limitSearch=FALSE; UBYTE CR=FALSE; SHORT IdxOffset = 0; int ieTableIdx; BOOL asn1, non_std_tag; SHORT ret; ULONG cix_ref, num_prolog_steps, prolog_step_ref; /* .../src/linux/include/asm/current.h defines a macro 'current' */ T_UNKNOWN_TAG *first, *currentTag; /* * Set the flag for the type of extension which is to expect * at the end of the message. */ globs->SeekTLVExt = TRUE; /* Set ref number for calcidx table. */ cix_ref = melem[e_ref].calcIdxRef; num_prolog_steps = calcidx[cix_ref].numPrologSteps; prolog_step_ref = calcidx[cix_ref].prologStepRef; /* * if this element is conditional, check the condition */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return 1; len_t = 8; switch (melem[e_ref].codingType) { case CCDTYPE_GSM1_ASN: asn1 = TRUE; non_std_tag = FALSE; len_l = 8; break; case CCDTYPE_GSM5_TV: case CCDTYPE_GSM5_TLV: non_std_tag = TRUE; asn1 = FALSE; len_l = 8; break; case CCDTYPE_GSM6_TLV: non_std_tag = FALSE; asn1 = FALSE; len_l = 16; break; case CCDTYPE_GSM7_LV: non_std_tag = FALSE; asn1 = FALSE; len_l = 7; break; default: asn1 = FALSE; non_std_tag = FALSE; len_l = 8; break; } /* * if this element have a defined Prolog * we have to process it before decoding the bitstream */ if (num_prolog_steps) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } if (tlv_inf->gotTag) { /* * tagged element */ len_t = 8; /* * initialize the iei_table for each new message */ if (globs->ccd_recurs_level NEQ globs->last_level) { cdc_init_table (c_ref, globs); globs->TagPending = FALSE; globs->SequenceError = FALSE; globs->last_level = globs->ccd_recurs_level; } /* * calculate the index into the ieTable for this element */ ieTableIdx = (int)(e_ref - globs->iei_ctx[globs->ccd_recurs_level].melemStart); if (globs->TagPending) { /* * if we previously read a t value and does not processed it * get this pending tag. */ t = (ULONG) globs->PendingTag; globs->TagPending = FALSE; } else { /* * read the information element identifier out of the bitstream. * If the first bit (MSBit) of the t-component is set, it is * a Tag of a TYPE1 or TYPE2 element. */ t = (ULONG) bf_decodeByteNumber (8, globs); if (!asn1 AND !non_std_tag AND (t & 0x80) EQ 0x80 AND (t & 0xA0) NEQ 0xA0) { ULONG Tag4 = t & 0xf0; /* * MSBit is set. We have to check if the Tag value can * be found as a 4 bit or 8 bit value in the IEI-table. */ if (cdc_search_table (ieTableIdx, Tag4, limitSearch, &nonTagged, globs) NEQ -127) { /* * Tag found as a 4 bit value. Decrement the readpointer * of the bitstream by 4, because we have read out 4 bits * to much. */ bf_setBitpos (globs->bitpos-4, globs); t = Tag4; len_t =4; #ifdef DEBUG_CCD TRACE_CCD (globs, "4 bit Tag decrementing bitpos by 4 to %d", globs->bitpos); #endif } } } #ifdef DEBUG_CCD TRACE_CCD (globs, "reading t = 0x%X", t); #endif if (melem[e_ref].codingType EQ CCDTYPE_GSM5_TLV) { limitSearch = TRUE; CR = (UBYTE) (((t & 0x80) EQ 0x80) ? TRUE : FALSE); t &= 0x7f; } if (asn1 AND t EQ 0x00) { /* * This is for ASN1 element coding the special * End Of Component Tag (EOC). The following length must be zero. */ bf_setBitpos (globs->bitpos-8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "ASN1 End of Component found belongs to higher TLV"); TRACE_CCD (globs, "leaving this level and decrementing bitpos by 8 to %d", globs->bitpos); #endif return END_OF_COMPOSITION; /* skip the remaining elements in this level */ } /* asn1 and EOC */ else { if ((IdxOffset = (SHORT) cdc_search_table (ieTableIdx, t, limitSearch, &nonTagged, globs)) == -127) { /* * t (iei) not defined in this composition (msg or submsg) */ if (asn1) { if (melem[mcomp[c_ref].componentRef + mcomp[c_ref].numOfComponents -1].codingType == CCDTYPE_GSM5_V) { /* Restore the old bitposition (before the 'TAG') and return * IdxOffset to jump to last element of the composition. * The coding type of this elements is CCDTYPE_GSM5_V */ bf_setBitpos (globs->bitpos-8, globs); IdxOffset = (SHORT)(mcomp[c_ref].numOfComponents - ieTableIdx - 1); return (IdxOffset); } /* * for recursive ASN.1 structs it is possible that the foreign * tag belongs to a upper level composition of element. * * * Restore the old bitposition (before the TAG) and return * END_OF_COMPOSITION to leave this composition level */ bf_setBitpos (globs->bitpos-8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "Unknown Tag. It may belong to upper ASN.1 comp -> dec. bitpos by 8 to %d", globs->bitpos); #endif return END_OF_COMPOSITION; /* skip the remaining elements in this level */ } else if (nonTagged) { U16 actBitpos; actBitpos = globs->bitpos-8; if (melem[mcomp[c_ref].componentRef + mcomp[c_ref].numOfComponents -1].codingType == CCDTYPE_GSM5_V && melem[e_ref].codingType EQ CCDTYPE_GSM5_TLV) { #if defined (CCD_TEST) currentTag = (T_UNKNOWN_TAG *) malloc(sizeof(T_UNKNOWN_TAG)); #else currentTag = (T_UNKNOWN_TAG *) D_ALLOC(sizeof(T_UNKNOWN_TAG)); #endif first = currentTag; currentTag->bitpos = globs->bitpos-8; currentTag->errCode = ERR_NO_MORE_ERROR; currentTag->next = NULL; /* unknown GSM Type TLV -> skip 'l' bytes */ /* at least 8 bits must remain for following expeceted tagged element */ while (globs->maxBitpos - 8 - globs->bitpos >= 8) { currentTag->bitpos = globs->bitpos-8; currentTag->tag = (UBYTE) t; /* * Expecting a CCDTYPE_GSM5_TLV type we get an unknown tag with MSB set. * Store bitpos and t for the application (SAT) for the handling of * comprehension required elements. */ if (CR) { // save (ERR_COMPREH_REQUIRED; globs->bitpos-len_t) currentTag->errCode = ERR_COMPREH_REQUIRED; } else { // save (ERR_IE_NOT_EXPECTED; globs->bitpos-len_t) currentTag->errCode = ERR_IE_NOT_EXPECTED; } l = (ULONG) bf_decodeByteNumber (8, globs); bf_incBitpos ((l << 3) , globs); t = (ULONG) bf_decodeByteNumber (8, globs); limitSearch = TRUE; CR = (UBYTE) (((t & 0x80) EQ 0x80) ? TRUE : FALSE); t &= 0x7f; if (cdc_search_table (ieTableIdx, t, limitSearch, &nonTagged, globs) != -127) { bf_setBitpos (globs->bitpos-8, globs); // set all ccd Errors do { currentTag = first; ccd_setError (globs, currentTag->errCode, CONTINUE, (USHORT) currentTag->tag, currentTag->bitpos, (USHORT) -1); first = currentTag->next; #if defined (CCD_TEST) free(currentTag); #else D_FREE(currentTag); #endif } while (first != NULL ); return 0; } else { #if defined (CCD_TEST) currentTag->next = (T_UNKNOWN_TAG *) malloc(sizeof(T_UNKNOWN_TAG)); #else currentTag->next = (T_UNKNOWN_TAG *) D_ALLOC(sizeof(T_UNKNOWN_TAG)); #endif currentTag = currentTag->next; currentTag->next = NULL; } } do { currentTag = first; first = currentTag->next; #if defined (CCD_TEST) free(currentTag); #else D_FREE(currentTag); #endif } while (first != NULL ); } /* * a non tagged element is possible in the message. If the tag * can not be found, the tag may be the beginning of the non tagged * element. E.g. rest octetts in sysinfo 4 * * Restore the old bitposition (before the TAG) and return 1 to * go to the next element. */ bf_setBitpos (actBitpos, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "Unknown Tag but mand. IE possible -> dec. bitpos by 8 to %d", globs->bitpos); #endif return 1; } /* * Otherwise look if it is a type 1,2 or 4 Element */ if ((t & 0x80) EQ 0x80) { /* MSBit set -> GSM Type 1 or Type2 -> skip 1 byte */ /* position already incremented by decoding the TAG value */ } /* Just another reason for getting IdxOffset equal to 0. */ else if (globs->ccd_recurs_level >= MAX_RECURSIONS_PER_MSG) { ccd_setError (globs, ERR_INTERNAL_ERROR, BREAK, (USHORT) -1); } else { /* * Expecting a CCDTYPE_GSM5_TLV type we get an unknown tag with MSB set. * Store bitpos and t for the application (SAT) for the handling of * comprehension required elements. */ if (CR) { ccd_setError (globs, ERR_COMPREH_REQUIRED, CONTINUE, (USHORT) t, (USHORT) globs->bitpos-len_t, (USHORT) -1); } /* * Expecting other types than CCDTYPE_GSM5_TLV we get an unknown tag with * comprehension required bits (5, 6, 7 and 8 of IEI according to GSM0407) * are set to zero. * Store bitpos and t for the application for the handling of comprehension * required elements. */ else if ((t & 0x70) EQ 0 AND melem[e_ref].codingType NEQ CCDTYPE_GSM5_TLV) { ccd_setError (globs, ERR_COMPREH_REQUIRED, CONTINUE, (USHORT) t, (USHORT) globs->bitpos-len_t, (USHORT) -1); } /* * We get an unknown tag and any sort of comprehension required flag is set. * Store bitpos and t for the application */ else { ccd_setError (globs, ERR_IE_NOT_EXPECTED, CONTINUE, (USHORT) t, (USHORT) globs->bitpos-len_t, (USHORT) -1); } /* MSBit cleared -> GSM Type TLV -> skip 'l' bytes */ if (globs->maxBitpos - globs->bitpos >= 8) { l = (ULONG) bf_decodeByteNumber (8, globs); bf_incBitpos ((l << 3) , globs); } else { ccd_recordFault (globs, ERR_ELEM_LEN, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } } /* * return 0 -> that means try it again with this actual element * referenced by e_ref */ return 0; } /* tag not found */ else { T_IEI_TABLE *iei_tbl = &globs->iei_ctx[globs->ccd_recurs_level].iei_table[ieTableIdx]; /* * element definition for this iei found */ if (IdxOffset NEQ 0) { /* * found index differs from the actual index */ globs->TagPending = TRUE; globs->PendingTag = (UBYTE) t; if (!asn1 AND IdxOffset < 0) { /* * found an element in wrong sequence * (for ASN1 elements the sequence order is not relevant) */ ccd_setError (globs, ERR_IE_SEQUENCE, (UBYTE) ((asn1) ? BREAK : CONTINUE), (USHORT) t, (USHORT) globs->bitpos-len_t, (USHORT) -1); globs->SequenceError = TRUE; } if (globs->SequenceError) { globs->RefBeforeError = (USHORT) e_ref; } if (asn1) { globs->iei_ctx[globs->ccd_recurs_level].countSkipped += IdxOffset; } /* * skip to the found element */ return (IdxOffset); } else { globs->iei_ctx[globs->ccd_recurs_level].melemLast = (USHORT) e_ref; if (iei_tbl->act_amount == 0) { /* * first apearance of this iei * calculate the upper and lower boundaries and the * facility of multiple appearance of this tagged element * in the bitstream. */ /* * The element is repeatable. There are three kinds of * repeat definitions valid for standard elements: * [5] - The element is repeated 5 times. * [0..5] - The element is repeated 0 to 5 times. * [a..5] - The element is repeated "the value of a" times. * * For tagged elements the following processing is defined: * * [5] - The t-Component is decoded * (maybe the l-Component too (if defined one). * After this the V-component of the element * is decoded 5 times. * * [0..5] - The t- and maybe the l-Component are decoded. * After this one V-Component is decoded and it * is stored as an array entry into * the target C-Structure. In this case the * parameter ieIndex gives the index into * this array, where the element has to * be written into. * * [a..5] - The t- and maybe the l-Component are decoded. * After this one V-Component is decoded * "a" times and is stored into the C-Structure * as an array. * */ switch (melem[e_ref+IdxOffset].repType) { case 'i': /* * multiapearance of this element. The V-component is * repeated once */ is_variable = ccd_calculateRep (e_ref+IdxOffset, &repeat, &max_rep, globs); iei_tbl->max_amount = (UBYTE) max_rep; iei_tbl->multiple = TRUE; break; case 'v': case 'b': default: /* * if this element is repeatable, and the number of * repeats depends on another element, the valid amount * of this element is 1 and the V-component will be * repeated. */ iei_tbl->max_amount = 1; iei_tbl->multiple = FALSE; break; } iei_tbl->act_amount = 1; } if (iei_tbl->act_amount <= iei_tbl->max_amount) { /* * process only the max_amount appearances of each element. * All additional IEs are ignored. */ ie_amount = (ULONG)(iei_tbl->act_amount)++; } else { if (asn1) { /* For ASN1 elements the sequence order is not relevant. * It is possible that the tag belongs to an upper level * composition of elements. * Restore the old bitposition (before the TAG) and return * END_OF_COMPOSITION to leave this composition level */ bf_setBitpos (globs->bitpos-8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "Tag may belong to upper ASN.1 comp -> dec. bitpos by 8 to %d", globs->bitpos); #endif return END_OF_COMPOSITION; /* skip the remaining elements in this level */ } else { ie_amount = 0; ccd_setError (globs, ERR_MAX_IE_EXCEED, CONTINUE, (USHORT) t, (USHORT) globs->bitpos-len_t, (USHORT) -1); } } /* * The t-component matches with the defined identifier for * the actual element definition (e_ref). */ if (globs->SequenceError) { globs->SequenceError = FALSE; if (asn1) { /* For ASN1 elements the sequence order is not relevant. * It is possible that the tag belongs to an upper level * composition of elements. * Restore the old bitposition (before the TAG) and return * END_OF_COMPOSITION to leave this composition level */ bf_setBitpos (globs->bitpos-8, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "Tag may belong to upper ASN.1 comp -> dec. bitpos by 8 to %d", globs->bitpos); #endif return END_OF_COMPOSITION; /* skip the remaining elements in this level */ } else { /* found an element in wrong sequence */ cdc_skipElem (e_ref, (tlv_inf->gotLen ? len_l:0), globs); return (SHORT)(globs->RefBeforeError - e_ref); } } /* * if this element is conditional, check the condition */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) { /* * if the condition for this element is not valid * but this element appears in the message, generate * an error and skip the element */ ccd_setError (globs, ERR_IE_NOT_EXPECTED, CONTINUE, (USHORT) t, (USHORT) globs->bitpos-len_t, (USHORT) -1); cdc_skipElem (e_ref, (tlv_inf->gotLen ? len_l:0), globs); return 0; } /* * check for a valid index */ if (ie_amount EQ 0) { /* * The max number of repeats are reached * In this case we must skip this element. */ cdc_skipElem (e_ref, (tlv_inf->gotLen ? len_l:0), globs); return 0; } if (iei_tbl->multiple) { if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE * Setup the offset into the C-structure for this element */ globs->pstructOffs = melem[e_ref].structOffs; } ret = cdc_tagged_LV_decode (e_ref, ie_amount, (tlv_inf->gotLen ? len_l:0), globs); } else { if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE * Setup the offset into the C-structure for this element */ globs->pstructOffs = melem[e_ref].structOffs; } ret = cdc_normal_LV_decode (e_ref, (tlv_inf->gotLen ? len_l:0), globs); } globs->SeekTLVExt = TRUE; iei_tbl->exhausted = TRUE; if (ret) return END_OF_COMPOSITION; /* * if more then one IE of this type are allowed, a ret of 0 * indicates the calling function (ccd_decodeComposition()) * to leave the pointer to the actual element definition on * this element. If the value of ret is greater then 0 the * calling function will increment the pointer by the value * of ret. * cdc_T_decode() has found the expected element definition. * Go to the next definition or stay at this definition, * if the occurance of this element is more than one. */ if (iei_tbl->act_amount > iei_tbl->max_amount) { iei_tbl->act_amount = 0; } if (iei_tbl->max_amount > 1) { return (0); } else { if (globs->iei_ctx[globs->ccd_recurs_level].countSkipped) { ret = (-1) * (globs->iei_ctx[globs->ccd_recurs_level].countSkipped); (globs->iei_ctx[globs->ccd_recurs_level].countSkipped) = 0; return (ret); } else { return (1); } } } /* IdxOffset == 0 */ } /* tag found */ } /* no asn1, no EOC */ } /* got tag */ else { /* * element has no t-component, process the l- and V-components */ if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE * Setup the offset into the C-structure for this element */ globs->pstructOffs = melem[e_ref].structOffs; } ret = cdc_normal_LV_decode (e_ref, len_l, globs) ? END_OF_COMPOSITION : 1; globs->SeekTLVExt = TRUE; return ret; } } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_tlv_encode | +--------------------------------------------------------------------+ PURPOSE : if T_len > 0 this function encodes the T-Component of this element. If L_len > 0 it encodes the number of bytes uses for this element. After all the function encodes the V-component referenced by eRef from the C-Structure (globs->pstruct) at position globs->pstructOffs into the bitstream. */ void cdc_tlv_encode (const ULONG e_ref, UBYTE lenT, UBYTE lenL, T_CCD_Globs *globs) { ULONG posL=0, t_repeat, v_repeat, repeat; ULONG cSize, startOffset=0; BOOL multAppear; U8 *old_pstruct = NULL; ULONG i; ULONG cix_ref, num_prolog_steps, prolog_step_ref; cix_ref = melem[e_ref].calcIdxRef; num_prolog_steps = calcidx[cix_ref].numPrologSteps; prolog_step_ref = calcidx[cix_ref].prologStepRef; /* * If this element is conditional, check the condition. */ if (calcidx[cix_ref].numCondCalcs NEQ 0 AND ! ccd_conditionOK (e_ref, globs)) return; /* * If this element have a defined Prolog, * we have to process it before decoding the bit stream. */ if (num_prolog_steps) { ccd_performOperations (num_prolog_steps, prolog_step_ref, globs); } if (melem[e_ref].elemType NEQ 'S') { /* * Element is not a SPARE. * Setup the offset into the C-structure for this element. * In case of pointer types, the pstructOffs must be * the offset into the memory area pointed to. CCDGEN must * ensure this holds true. */ globs->pstructOffs = melem[e_ref].structOffs; if ( ! cdc_isPresent(e_ref, globs) ) return; if (melem[e_ref].repType EQ 'v' OR melem[e_ref].repType EQ 'i') { /* * for variable sized elements read the amount * of repeats out of the C-Structure (c_xxx). * If the number of repeats given by the C-Structure * exceeds the allowed value (maxRepeat) CCD gives a warning! */ if (melem[e_ref].maxRepeat > 255) { ULONG count = (ULONG) (* (USHORT *)(globs->pstruct + globs->pstructOffs++)); repeat = MINIMUM (count, (ULONG) melem[e_ref].maxRepeat); if (repeat < count) ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } else { repeat = (ULONG) MINIMUM (globs->pstruct[globs->pstructOffs], melem[e_ref].maxRepeat); if ( repeat < (ULONG) (globs->pstruct[globs->pstructOffs]) ) ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } globs->pstructOffs++; multAppear = (melem[e_ref].repType EQ 'i'); } else { /* * Field of constant length: repType EQ 'c' * or bit-field allocated with * given maximum length: repType EQ 'b' (often cType='X') */ repeat = (ULONG)((melem[e_ref].repType EQ 'c' OR melem[e_ref].repType EQ 'b') ? melem[e_ref].maxRepeat : 1 ); multAppear = FALSE; } /* * Perform pointer dereference for pointer types. * Also, check optionality for these types. */ #ifdef DYNAMIC_ARRAYS if ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')) { U8 *deref_pstruct; /* Get pointer value */ deref_pstruct = *(U8 **)(globs->pstruct + globs->pstructOffs); /* * Strictly speaking the 'D' to 'F' types should not need this * check (should have returned after the optionality check above), * but it will catch stray NULL pointers (or uninitialized * valid flags) */ if (ccd_check_pointer(deref_pstruct) != ccdOK) { ccd_recordFault (globs, ERR_INVALID_PTR, BREAK, (USHORT) e_ref, &globs->pstruct[globs->pstructOffs]); return; } /* * Pointer not NULL; * 1. Save old globs->pstruct and assign pointer to globs->pstruct * as new base. * 2. Set pstructOffs to 0 (zero) as the next offset will start * in the new memory area. */ old_pstruct = globs->pstruct; globs->pstruct = deref_pstruct; globs->pstructOffs = 0; } #endif /* * 20010621 MVJ: Dynamic array addition. * Types 'R' and 'F' point to base types (just as type 'V') and * read sizes from the same table. */ cSize = (ULONG)((melem[e_ref].elemType EQ 'V' #ifdef DYNAMIC_ARRAYS OR melem[e_ref].elemType EQ 'R' OR melem[e_ref].elemType EQ 'F' #endif ) ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ); startOffset = globs->pstructOffs; } else { repeat = (ULONG)((melem[e_ref].repType EQ 'c') ? melem[e_ref].maxRepeat : 1); multAppear = FALSE; cSize = 0; } if (multAppear AND lenT) { /* * multiple appearance of the repeated element is coded as * TLV0 TLV1 TLV2 .... */ t_repeat = repeat; v_repeat = 1; } else { t_repeat = 1; v_repeat = repeat; } /* * single appearance of the repeated element is coded as * TLV0V1V2V3 .... */ for (i=0; i < t_repeat; i++) { if (lenT) { /* * encode the T-component */ bf_codeByteNumber (lenT, (UBYTE) melem[e_ref].ident, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "encoding %d bits T-value (%x)", lenT, melem[e_ref].ident); #endif } /* * if lenL > 0 remember the position of the L-component, because * we know it after encoding the entire element. for GSM5TLV elements * it could be necessary to use 2 bytes for the length information. */ if (lenL) { posL = (ULONG) globs->bitpos; bf_incBitpos (lenL, globs); #ifdef DEBUG_CCD TRACE_CCD (globs, "skipping %d bits for L-value at byte %d.%d", lenL, globs->bytepos, globs->byteoffs); #endif } if (cSize) { /* * calculate the offset if it is not a spare */ globs->pstructOffs = (ULONG)(startOffset + (i * cSize)); } /* * Encode the value. Keep caution with BER encoding of ASN1 integers. * All other types can be encoded by a generic function. */ if (melem[e_ref].codingType EQ CCDTYPE_GSM1_ASN AND melem[e_ref].elemType EQ 'V' AND melem[e_ref].repType EQ ' ' ) { #ifdef DEBUG_CCD #ifdef CCD_SYMBOLS TRACE_CCD (globs, "BER encoding of ASN.1 integer %s", ccddata_get_alias((USHORT) e_ref, 1)); #else TRACE_CCD (globs, "BER encoding of ASN.1 integer; e_ref= %d", melem[e_ref].elemRef); #endif #endif switch (mvar[melem[e_ref].elemRef].cType) { case 'B': bf_writeBits (8, globs); break; case 'S': { if (*(U16 *) (globs->pstruct+globs->pstructOffs) <= (U16)0xFF) bf_writeBits (8, globs); else bf_writeBits (16, globs); } break; case 'L': { U32 tmpVal= *(U32 *) (globs->pstruct+globs->pstructOffs); if ( tmpVal <= (U32)0xFF) bf_writeBits (8, globs); else if ( tmpVal <= (U32)0xFFFF) bf_writeBits (16, globs); else if ( tmpVal <= (U32)0xFFFFFF) bf_writeBits (24, globs); else bf_writeBits (32, globs); } break; case 'X': { U16 ValLen= *(U16 *) (globs->pstruct+globs->pstructOffs); if ( mvar[melem[e_ref].elemRef].bSize >= ValLen) bf_writeBitChunk (ValLen, globs); else { #ifdef DEBUG_CCD TRACE_CCD (globs, "value length (%d) exceeds defined bSize!", ValLen); #endif } } break; } } else { cdc_encodeElemvalue (e_ref, v_repeat, globs); } /* * calculate the bitlen if it is an TLV element and write the * L-value. */ if (lenL) { switch (melem[e_ref].codingType) { case CCDTYPE_GSM5_TLV: { USHORT L = (((USHORT)((globs->bitpos - posL)-lenL)+7) >> 3); #ifdef DEBUG_CCD TRACE_CCD (globs, "recoding the 8 bit L-value (%d)", L); #endif if (L > 127) { /* * if the length is > 127 we code the first byte to * 0x81, shift the whole stuff rightwise by 8 and * encode the length in the next byte (16 bits for L) */ bf_rShift8Bit ((USHORT) (posL+8), (USHORT) (L<<3), globs); bf_incBitpos (8, globs); bf_recodeByteNumber ((USHORT) posL, lenL, (UBYTE) 0x81, globs); bf_recodeByteNumber ((USHORT) (posL+8), lenL, (UBYTE) L, globs); /* * set the bitpos to a 8 bit aligned position * corresponding the L value */ bf_setBitpos (posL+(L*8)+16, globs); } else { bf_recodeByteNumber ((USHORT) posL, lenL, (UBYTE) L, globs); /* * set the bitpos to a 8 bit aligned position * corresponding the L value */ bf_setBitpos (posL+(L*8)+8, globs); } break; } case CCDTYPE_GSM6_TLV: { USHORT L = ((USHORT)(((globs->bitpos - posL)-lenL)+7) >> 3); #ifdef DEBUG_CCD TRACE_CCD (globs, "recoding the 16 bit L-value (%d)", L); #endif bf_recodeShortNumber ((USHORT)posL, lenL, L, globs); /* * set the bitpos to a 8 bit aligned position * corresponding the L value */ bf_setBitpos (posL+(L*8)+16, globs); break; } case CCDTYPE_GSM7_LV: { USHORT L = (USHORT) ((globs->bitpos - posL)-lenL); #ifdef DEBUG_CCD TRACE_CCD (globs, "recoding the 7 bit L-value (bitlength) (%d)", L); #endif bf_recodeShortNumber ((USHORT)posL, lenL, L, globs); bf_setBitpos (posL+L+7, globs); break; } default: { USHORT L = ((USHORT)(((globs->bitpos - posL)-lenL)+7) >> 3); #ifdef DEBUG_CCD TRACE_CCD (globs, "recoding the 8 bit L-value (%d)", L); #endif bf_recodeByteNumber ((USHORT)posL, lenL, (UBYTE) L, globs); /* * Set the bitpos to a 8 bit aligned position * corresponding the L value */ bf_setBitpos (posL+(L*8)+8, globs); break; } } } } /* * Restore globs->pstruct if overwritten by pointer dereference. */ if (old_pstruct) globs->pstruct = old_pstruct; } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_GSM_start | +--------------------------------------------------------------------+ PURPOSE : Initialize the GSM specific codec part for each msg. */ void cdc_GSM_start (T_CCD_Globs *globs) { globs->Swap1V_inProgress = FALSE; globs->last_level = 255; cdc_init_ctx_table (globs); } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : cdc_isPresent | +--------------------------------------------------------------------+ PURPOSE : For optional elements check the valid-flag in the C-struct. Spare elements in PER do not have a corresponding valid flag. In case of Dynamic Arrays: Postpone optional check for non-code transparent pointer types ('P', 'Q', 'R'). For these types, the optional flag is the pointer itself. These types cannot be checked yet, as the pointer may be preceeded by a counter octet, a union tag id octet etc. */ U16 cdc_isPresent (const ULONG e_ref, T_CCD_Globs *globs) { if (melem[e_ref].optional) { #ifdef DYNAMIC_ARRAYS if (melem[e_ref].elemType < 'P' OR melem[e_ref].elemType > 'R') { if(globs->pstruct[globs->pstructOffs++] == FALSE) return FALSE; #ifdef DEBUG_CCD else if (globs->pstruct [melem[e_ref].structOffs] != TRUE) { TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d", e_ref); } #endif } else { /*If elemType is P, Q or R - check the pointer value*/ if(*(void**) &globs->pstruct[globs->pstructOffs] == NULL) return FALSE; } #else if (globs->pstruct[globs->pstructOffs++] == FALSE) return FALSE; #ifdef DEBUG_CCD else if (globs->pstruct [melem[e_ref].structOffs] != TRUE) { TRACE_CCD (globs, "Ambiguous value for valid flag!\n...assumed 1 for ccdID=%d", e_ref); } #endif #endif } return TRUE; } #endif /* !RUN_INT_RAM */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : is_pointer_type | +--------------------------------------------------------------------+ PURPOSE : Return TRUE for pointer elements. */ BOOL is_pointer_type (const ULONG e_ref) { return ((melem[e_ref].elemType >= 'P' AND melem[e_ref].elemType <= 'R') OR (melem[e_ref].elemType >= 'D' AND melem[e_ref].elemType <= 'F')); } #endif /* !RUN_FLASH */ #ifndef RUN_FLASH /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : is_variable_type | +--------------------------------------------------------------------+ PURPOSE : Return TRUE for elements with variable character. */ BOOL is_variable_type (const ULONG e_ref) { return ((melem[e_ref].elemType == 'F') || ( melem[e_ref].elemType == 'R') || (melem[e_ref].elemType == 'V')); } #endif /* !RUN_FLASH */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : PER_CommonBegin | +--------------------------------------------------------------------+ PURPOSE : Common settings done by most of the encoding or decoding functions for UNALIGNED PER (UMTS). It handles position of pointer to the C-structure, valid flag for optional elements and length determinant for array of elements. */ SHORT PER_CommonBegin (const ULONG e_ref, ULONG *max_rep, T_CCD_Globs *globs) { /* * Set the offset in the C-structure on the value for this element */ globs->pstructOffs = melem[e_ref].structOffs; /* For optional elements we have already set the valid flag in the * C-structure while processing ASN1_SEQ. */ if ( ! cdc_isPresent(e_ref, globs) ) return (SHORT)ccdError; switch (melem[e_ref].repType) { case ' ': /* * Element is not an array. */ *max_rep = 1; break; case 'c': case 'C': /* * Read the size for an array of fixed length. */ *max_rep = (ULONG) melem[e_ref].maxRepeat; break; case 'j': case 'J': { /* * Read the size for an array of variable length. * Read the value of the last encoded element. It is the length * indicator. * Hint 1: globs->pstruct[melem[e_ref-1].structOffs is 0, since * fields of variable length are projected on a COMP made of an * ASN1_INTEGER for the lenght indicator and the field elements * (sequences, integers, octets or bits). * Hint 2: The current version of UMTS does not use length * indicators larger than 64K. Hence the use of USHORT for repeat. */ switch (mvar[melem[e_ref-1].elemRef].cType) { case 'B': *max_rep = (ULONG) globs->pstruct[melem[e_ref-1].structOffs]; break; case 'S': *max_rep = (ULONG) *(USHORT *) (globs->pstruct+melem[e_ref-1].structOffs); break; default: *max_rep = 0; break; } break; } default: ccd_recordFault (globs, ERR_DEFECT_CCDDATA, BREAK, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); break; } /* * There is nothing to be encoded. */ if (*max_rep EQ 0) { return (SHORT)ccdError; } /* * Check the validity of the lenght information. */ else if (melem[e_ref].maxRepeat AND *max_rep > melem[e_ref].maxRepeat) { ccd_recordFault (globs, ERR_MAX_REPEAT, CONTINUE, (USHORT) e_ref, globs->pstruct + globs->pstructOffs); } return (SHORT)ccdOK; } #endif /* !RUN_INT_RAM */ #ifdef DYNAMIC_ARRAYS #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : PER_allocmem | +--------------------------------------------------------------------+ PURPOSE : Allocate memory for pointer types (dynamic array addition) Returns address of freshly allocated memory or ccdError in case no memory is available. */ U8 *PER_allocmem(const ULONG e_ref, ULONG repeat, T_CCD_Globs *globs) { /* * Check for pointer types; allocate memory if necessary. */ if ( is_pointer_type(e_ref) ) { ULONG cSize; U8 *addr; /* * Find size to allocate. * Read from mcomp or mvar according to type. */ cSize = (ULONG)((melem[e_ref].elemType EQ 'V' OR melem[e_ref].elemType EQ 'R' OR melem[e_ref].elemType EQ 'F') ? mvar[melem[e_ref].elemRef].cSize : mcomp[melem[e_ref].elemRef].cSize ); #ifdef DEBUG_CCD TRACE_CCD (globs, "PER_allocmem(): alloc%5d x%5d bytes (type '%c'); " "elem%5d ('%s')", repeat, cSize, melem[e_ref].elemType, e_ref, #ifdef CCD_SYMBOLS mcomp[melem[e_ref].elemRef].name #else "" #endif ); #endif /* * Allocate additional memory - append to existing mem chain */ cSize *= repeat; addr = (U8 *)DP_ALLOC( cSize, globs->alloc_head, DP_NO_FRAME_GUESS); /* If no memory, log error and return immediately */ if (addr EQ NULL) { ccd_setError (globs, ERR_NO_MEM, BREAK, (USHORT) -1); return (U8 *)ccdError; } else memset (addr, 0, (size_t)cSize); return addr; } return (U8 *)ccdError; } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : PER_allocmem_and_update| +--------------------------------------------------------------------+ PURPOSE : Allocate memory for pointer types (dynamic array addition) Updates global variables after allocation (globs->pstruct and globs->pstructOffs). Assumes that these global variables are saved by the calling function. Returns ccdOK or ccdError in case no memory is available. */ USHORT PER_allocmem_and_update(const ULONG e_ref, ULONG repeat, T_CCD_Globs *globs) { U8 *addr; /* Allocate memory */ addr = PER_allocmem(e_ref, repeat, globs); /* No memory ? */ if ( addr != (U8 *)ccdError ) { /* * Memory allocated; * 1. Store pointer to freshly allocated memory area in structure * 2. Initialize pstruct to point to the freshly allocated memory area. * 3. Initialize pstructOffs to 0 to start decoding at offset 0 * in the new memory area. * Assumes that globs->pstruct is saved in the calling function. */ *(U8 **)(globs->pstruct + globs->pstructOffs) = addr; globs->pstruct = addr; globs->pstructOffs = 0; return ccdOK; } else { /* No memory - Return error */ return ccdError; } } #endif /* !RUN_INT_RAM */ #endif #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : Read_NormallySmallNonNegativeWholeNr| +--------------------------------------------------------------------+ PURPOSE : Read a normally small non-negative whole number as defined by ASN.1 PER. Function is used to read elements such as: a) bit-map field of SEQUENCE extensions, b) index of CHOICE extension or c) extension value of extensible INTEGER or ENUMERATED. */ U32 Read_NormallySmallNonNegativeWholeNr (T_CCD_Globs *globs) { U32 value_length=0; /* Read the first bit. If set to 0 it means the value is encoded * in the following five bits. Else read a normally small ...nr. */ if (bf_readBit (globs) EQ 0) { return ((U32) bf_getBits (6, globs)); } else { /* * Do not handle the theoretical case that value length * needs more than 63 bits. */ bf_incBitpos (1, globs); /* * Read the value length first. * Then use the length to read the value. */ value_length = (U32) bf_getBits (6, globs); return ((U32) bf_getBits (value_length, globs)); } } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : Write_NormallySmallNonNegativeWholeNr| +--------------------------------------------------------------------+ PURPOSE : Write a normally small non-negative whole number as defined by ASN.1 PER. Function is used to encode elements such as: a) bit-map field of SEQUENCE extensions, b) index of CHOICE extension or c) extension value of extensible INTEGER or ENUMERATED. */ void Write_NormallySmallNonNegativeWholeNr (U32 Value, T_CCD_Globs *globs) { /* For small numbers write 0 in the first bit. * Then encode that number in the succeeding five bits. */ if (Value < 64) { bf_writeBit (0, globs); bf_writeVal (Value, 6, globs); } /* * Encode the number under the assumption that its length is * given by less than 63 bits. Hence encode also the length as a * normally small... */ else { /* Set flag bits: * 1 means "length determinant encoded before the value itself" * 0 means "length determinant encoded only in five bits" */ bf_writeVal (2, 2, globs); bf_writeVal (bitSize[Value], 5, globs); /* Encode the number itself */ bf_writeVal (Value, bitSize[Value], globs); } return; } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : Read_OpenTpye_Length | +--------------------------------------------------------------------+ PURPOSE : Read length of an ASN.1 open type. Open types are normally found in encoding of parametrized information objects and extension types. */ U32 Read_OpenTpye_Length (T_CCD_Globs *globs) { U32 Value; /* * Flag bit is 0 for "Value < 128" which means * "encoding fits in the current octet" */ if (bf_readBit (globs) EQ 0) { Value = bf_getBits (7, globs); } /* * Flag bits are 10 for 128 "< Value < 16K". * 1 means "encoding does not fit in the current octet". * 0 means "encoding needs only one further octet". */ else if (bf_readBit (globs) EQ 0) { Value = bf_getBits (14, globs); } /* Currently no support for bigger values is required. */ else { /* force error detection */ Value = 0; } return Value; } #endif /* !RUN_INT_RAM */ #ifndef RUN_INT_RAM /* +--------------------------------------------------------------------+ | PROJECT : CCD (6144) MODULE : CDC_COM | | STATE : code ROUTINE : Write_OpenTpye_Length | +--------------------------------------------------------------------+ PURPOSE : Write length of an ASN.1 open type. Open types are normally found in encoding of parametrized information objects and extension types. */ void Write_OpenTpye_Length (U32 Value, T_CCD_Globs *globs) { if (Value < 128) { bf_writeVal (Value, 8, globs); } else if (Value < 0x8000) { /* Set flag bits: * 1 means "encoding does not fit in the current octet" * 0 means "encoding needs only one further octet" */ bf_writeVal (2, 2, globs); bf_writeVal (Value, 14, globs); } /* Currently no support for bigger values is required. */ else {} return; } #endif /* !RUN_INT_RAM */