FreeCalypso > hg > fc-selenite
view src/g23m-gprs/llc/llc_rxf.c @ 112:fdecfb3bd860
.../drv_app/r2d/r2d_*.c: LCD include case fixes from Magnetite
R2D is not used in Selenite, but we strive to keep the two source trees
in sync as much as possible to reduce the diffs.
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sat, 13 Oct 2018 16:56:22 +0000 |
parents | d393cd9bb723 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | Project : | Modul : +----------------------------------------------------------------------------- | 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 : This modul is part of the entity LLC and implements all | procedures and functions as described in the | SDL-documentation (RX-statemachine) +----------------------------------------------------------------------------- */ #ifndef LLC_RXF_C #define LLC_RXF_C #endif #define ENTITY_LLC /*==== INCLUDES =============================================================*/ #include <string.h> /* to get memcpy() */ #include "typedefs.h" /* to get Condat data types */ #include "vsi.h" /* to get a lot of macros */ #include "macdef.h" #include "gprs.h" #include "gsm.h" /* to get a lot of macros */ #include "cnf_llc.h" /* to get cnf-definitions */ #include "mon_llc.h" /* to get mon-definitions */ #include "prim.h" /* to get the definitions of used SAP and directions */ #include "llc.h" /* to get the global entity definitions */ #include "llc_rxf.h" /* to get local defines */ #include "llc_rxp.h" /* to get the function rx_cci_decipher_cnf */ #include "llc_f.h" /* to get global functions, e.g. llc_generate_input */ #ifndef TI_PS_OP_CIPH_DRIVER #include "cci_fbsf.h" /* to get functional interface */ #endif /*==== CONST ================================================================*/ /*==== LOCAL VARS ===========================================================*/ /*==== PRIVATE FUNCTIONS ====================================================*/ #ifndef CF_FAST_EXEC GLOBAL UBYTE rx_get_desc_octet (T_desc_list *desc_list, USHORT offset, UBYTE *data_ptr); #endif /* CF_FAST_EXEC */ /*==== PUBLIC FUNCTIONS =====================================================*/ /* +------------------------------------------------------------------------------ | Function : rx_init +------------------------------------------------------------------------------ | Description : This procedure initialises all necessary variables of | receive_pdu. | | Parameters : | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL void rx_init (void) { TRACE_FUNCTION( "rx_init" ); /* * Initialise service RX with state TLLI_UNASSIGNED. */ INIT_STATE (RX, RX_TLLI_UNASSIGNED); return; } /* rx_init() */ #endif /* CF_FAST_EXEC */ /* +------------------------------------------------------------------------------ | Function : rx_analyse_ctrl_field +------------------------------------------------------------------------------ | Description : This procedure analyses the received LLC frame control field | and sets frame_type according to the frame type (U, UI, I/S). | protected_mode is set according to the protected mode of the | frame (U and I/S always protected, UI depends on setting of | PM bit). The type of protected_mode is the same as in | CCI_DECIPHER_REQ. ns is set to N(S) for I frames, N(U) for | UI frames, or an undefined value for S and U frames. ciphering | is set to TRUE if the frame is ciphered (U never, I/S always, | UI depends on setting of E bit), otherwise to FALSE. frame_ok | indicates if the frame contains enough octets to contain a | known control field (i.e. all necessary information is | accessible, not the control field is complete!). | | Parameters : grlc_unitdata_ind - a valid pointer to a GRLC_UNITDATA_IND | primitive | frame_type - a valid pointer to a T_PDU_TYPE variable | protected_mode - a valid pointer to a UBYTE variable | sapi - a valid pointer to a UBYTE variable | ns - a valid pointer to a T_FRAME_NUM variable | ciphering - a valid pointer to a BOOL variable | header_size - a valid pointer to a USHORT variable | frame_ok - a valid pointer to a BOOL variable | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL void rx_analyse_ctrl_field (T_GRLC_UNITDATA_IND *grlc_unitdata_ind, T_PDU_TYPE *frame_type, UBYTE *protected_mode, UBYTE *sapi, T_FRAME_NUM *ns, BOOL *ciphering, USHORT *header_size, BOOL *frame_ok) { UBYTE first_octet; UBYTE sec_octet; UBYTE command_octet; UBYTE sack_k_octet; TRACE_FUNCTION( "rx_analyse_ctrl_field" ); /* * Check if the frame contains enough octets to access the first octet of * the control field to find out the type of the frame. */ if (grlc_unitdata_ind->desc_list.list_len < CTRL_MIN_OCTETS) { *frame_ok = FALSE; return; } /* * Assume initially that the frame is ok. */ *frame_ok = TRUE; /* * Set first_octet to the value of the first frame octet (offset 0), which * is the address field. */ rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 0, &first_octet); *sapi = first_octet & 0x0F; /* * Set sec_octet to the value of the second frame octet (offset 1), which * is the first octet of the control field. */ rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 1, &sec_octet); /* * Determine frame_type, along with ns, protected_mode, and ciphering, * depending on the frame type. */ if ((sec_octet & I_FRAME_MASK) EQ I_FRAME_ID) { /* * I frame, protected, ciphered, at least 4 octets required to access all * requested information (1 Address, 3 Control). */ *frame_type = I_FRAME; *protected_mode = CCI_PM_PROTECTED; *ciphering = TRUE; /* * Check if the frame contains enough octets to access the complete * I frame control field. */ if (grlc_unitdata_ind->desc_list.list_len < I_CTRL_MIN_OCTETS) { *frame_ok = FALSE; return; } /* * Determine the header_size */ *header_size = I_CTRL_MIN_OCTETS; /* * Add bytes in case of SACK-Bitmap (add K+1). Therefore get at first * the command octet (offset 3). In case of an SACK, get next the k * octet (offset 4) and add the additional size. */ rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 3, &command_octet); if ( (command_octet & 0x03) == I_FRAME_SACK ) { *header_size += 1; /* k octet */ if (grlc_unitdata_ind->desc_list.list_len < *header_size) { *frame_ok = FALSE; return; } rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 4, &sack_k_octet); *header_size += (sack_k_octet & 0x1F); /* bitmap size */ if (grlc_unitdata_ind->desc_list.list_len < *header_size) { *frame_ok = FALSE; return; } } /* * Extract N(S) and store it in ns. */ *ns = (((T_FRAME_NUM) rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 1, NULL)) & 0x1F) << 4; *ns |= (((T_FRAME_NUM) rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 2, NULL)) >> 4); } else if ((sec_octet & S_FRAME_MASK) EQ S_FRAME_ID) { /* * S frame, protected, not ciphered. No N(S) present, only N(R). */ *frame_type = S_FRAME; *protected_mode = CCI_PM_PROTECTED; *ciphering = FALSE; *header_size = S_CTRL_MIN_OCTETS; /* not necessary to add bytes in case of SACK - value is not used */ } else if ((sec_octet & UI_FRAME_MASK) EQ UI_FRAME_ID) { /* * UI frame, at least 3 octets required to access all requested * information (1 Address, 2 Control). */ *frame_type = UI_FRAME; /* * Check if the frame contains enough octets to access the complete * UI frame control field. */ if (grlc_unitdata_ind->desc_list.list_len < UI_CTRL_MIN_OCTETS) { *frame_ok = FALSE; return; } /* * Extract protected mode setting of frame (PM bit). */ if (rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 2, NULL) & 0x01) { *protected_mode = CCI_PM_PROTECTED; } else { *protected_mode = CCI_PM_UNPROTECTED; } /* * Extract ciphering setting of frame (E bit). */ if (rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 2, NULL) & 0x02) { *ciphering = TRUE; } else { *ciphering = FALSE; } *header_size = UI_CTRL_MIN_OCTETS; /* * Extract N(U) and store it in ns. */ *ns = (((T_FRAME_NUM) rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 1, NULL)) & 0x07) << 6; *ns |= (((T_FRAME_NUM) rx_get_desc_octet (&grlc_unitdata_ind->desc_list, 2, NULL)) >> 2); } else if ((sec_octet & U_FRAME_MASK) EQ U_FRAME_ID) { /* * U frame, protected, not ciphered. No N(S) present. */ *frame_type = U_FRAME; *protected_mode = CCI_PM_PROTECTED; *ciphering = FALSE; *header_size = U_CTRL_MIN_OCTETS; } return; } /* rx_analyse_ctrl_field() */ #endif /* CF_FAST_EXEC */ /* +------------------------------------------------------------------------------ | Function : rx_decipher_req +------------------------------------------------------------------------------ | Description : Handles the function rx_decipher_req. This functions sets the | ciphering parameters and calls the deciphering driver function. | | Parameters : | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL void rx_decipher_req (T_CCI_DECIPHER_REQ *decipher_req) { T_CIPH_init_cipher_req_parms init_cipher_req_parms; T_CIPH_cipher_req_parms cipher_req_parms; T_CIPH_in_data_list in_data_list; T_CIPH_out_data out_data; T_CIPH_ck ck; U16 i; U8 status; U16 cnt = 0; TRACE_FUNCTION( "rx_decipher_req" ); #ifdef LLC_TRACE_CIPHERING TRACE_EVENT("DOWNLINK CIPHERED DATA"); llc_trace_desc_list(&decipher_req->desc_list); #endif /* * Copy pointer to desc's from CIPHER_REQ to the in_data_list * The in_data array in allocated dynamically in this func. */ llc_copy_dl_data_to_list(decipher_req, &in_data_list); /* * Set ciphering parameters */ cipher_req_parms.gprs_parameters.pm = decipher_req->pm; cipher_req_parms.gprs_parameters.header_size = decipher_req->header_size; cipher_req_parms.gprs_parameters.ciphering_input = decipher_req->ciphering_input; cipher_req_parms.gprs_parameters.threshold = 0; init_cipher_req_parms.direction = CIPH_DOWNLINK_DIR; init_cipher_req_parms.algo = decipher_req->ciphering_algorithm; init_cipher_req_parms.ptr_ck = & ck; /* * Copy ciphering key */ for (i = 0; i < 8;i++) { init_cipher_req_parms.ptr_ck->ck_element[i] = decipher_req->kc.key[i]; } { /* Use GRLC_DATA_REQ instead of CCI_CIPHER_CNF to avoid PPASS in LLC*/ PALLOC_SDU (ll_unitdata_ind, LL_UNITDATA_IND, (USHORT)((decipher_req->desc_list.list_len*8) - FCS_SIZE_BITS)); ll_unitdata_ind->sdu.o_buf = 0; ll_unitdata_ind->sdu.l_buf = 0; out_data.buf = (U32)(&ll_unitdata_ind->sdu.buf[ll_unitdata_ind->sdu.o_buf >> 3]); /* * Initialize ciphering driver and decipher data */ #ifdef TI_PS_OP_CIPH_DRIVER ciph_init_cipher_req (&init_cipher_req_parms, NULL); ciph_cipher_req (&cipher_req_parms, &in_data_list, &out_data, &status); #else ciph_init_cipher_req_sim (&init_cipher_req_parms, NULL); ciph_cipher_req_sim (&cipher_req_parms, &in_data_list, &out_data, &status); #endif /* * "Send" DECIPHER_CNF to LLC */ ll_unitdata_ind->sdu.l_buf = out_data.len * 8; ll_unitdata_ind->tlli = decipher_req->reference1; ll_unitdata_ind->cipher = (UBYTE)decipher_req->reference2; if (status == CIPH_CIPH_PASS){ ll_unitdata_ind->sapi = CCI_FCS_PASSED; } else { ll_unitdata_ind->sapi = CCI_FCS_FAILED; } #ifdef LLC_TRACE_CIPHERING TRACE_EVENT("DOWNLINK DECIPHERED DATA"); llc_trace_sdu(&ll_unitdata_ind->sdu); #endif rx_cci_decipher_cnf(ll_unitdata_ind); } /* * Free in_data array from in_data_list allocated in llc_copy_dl_data_to_list */ if(in_data_list.ptr_in_data != NULL){ MFREE(in_data_list.ptr_in_data); in_data_list.ptr_in_data = NULL; } /* * Free descriptors from the deipher_req->desc_list */ if (decipher_req != NULL) { T_desc *desc = (T_desc *)decipher_req->desc_list.first; T_desc *next_desc; while (desc NEQ NULL){ next_desc = (T_desc *)desc->next; MFREE (desc); desc = next_desc; /* increase freed partitions counter */ cnt++; } MFREE(decipher_req); decipher_req = NULL; } llc_data->fbs.cci_freed_partition +=cnt; /* trace number of freed partitions */ if(llc_data->fbs.cci_info_trace){ TRACE_EVENT_P2("INFO CCI: freed partitions %ld, total=%ld", cnt,llc_data->fbs.cci_freed_partition); } } /* rx_decipher_req */ #endif /* +------------------------------------------------------------------------------ | Function : rx_send_decipher_req +------------------------------------------------------------------------------ | Description : This procedure allocates the CCI_DECIPHER_REQ primitive, fills | in all necessary parameters and sends the primitive to CCI. | | Parameters : grlc_unitdata_ind - a valid pointer to a GRLC_UNITDATA_IND | primitive | frame_type - indicates (un)acknowledged operation mode | protected_mode - pm setting for CCI_DECIPHER_REQ | ns - N(S)/N(U) for deciphering, otherwise | undefined value | header_size - size of header bytes (not ciphered bytes) | ciphering - indicates deciphering (TRUE/FALSE) | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL void rx_send_decipher_req (T_GRLC_UNITDATA_IND *grlc_unitdata_ind, T_PDU_TYPE frame_type, UBYTE protected_mode, T_FRAME_NUM ns, USHORT header_size, BOOL ciphering) { ULONG oc; TRACE_FUNCTION ("rx_send_decipher_req"); { /* * No need to PPASS GRLC_xDATA_IND, because desc_list contains a pointer * which can be simply copied. */ T_CCI_DECIPHER_REQ *cci_decipher_req; MALLOC(cci_decipher_req, sizeof(T_CCI_DECIPHER_REQ)); /* * Requires rx_analyse_ctrl_field() to set a correct CCI value. */ cci_decipher_req->pm = protected_mode; if (ciphering EQ TRUE) { cci_decipher_req->reference2 = LL_CIPHER_ON; /* re-use of reference is ok */ cci_decipher_req->ciphering_algorithm = llc_data->ciphering_algorithm; memcpy (&cci_decipher_req->kc, &llc_data->kc, sizeof(T_kc)); /* * Calculate the OC which is valid for this ns. This could be the * current OC or OC + 1 in case of an modulo overflow of ns */ switch (frame_type) { case I_FRAME: case S_FRAME: if (ns >= llc_data->sapi->vr) oc = llc_data->sapi->oc_i_rx; else oc = llc_data->sapi->oc_i_rx + (MAX_SEQUENCE_NUMBER+1); break; default: if (ns >= llc_data->sapi->vur) oc = llc_data->sapi->oc_ui_rx; else oc = llc_data->sapi->oc_ui_rx + (MAX_SEQUENCE_NUMBER+1); break; } llc_generate_input (llc_data->current_sapi, frame_type, ns, &cci_decipher_req->ciphering_input, oc); cci_decipher_req->direction = CCI_DIRECTION_DOWNLINK; } else /* ciphering EQ FALSE */ { cci_decipher_req->reference2 = LL_CIPHER_OFF; cci_decipher_req->ciphering_algorithm = CCI_CIPHER_NO_ALGORITHM; } cci_decipher_req->header_size = header_size; /* * TLLI must be stored somewhere */ cci_decipher_req->reference1 = grlc_unitdata_ind->tlli; cci_decipher_req->desc_list = grlc_unitdata_ind->desc_list; /* TRACE_EVENT ("CCI thread not available, using functional interface"); */ rx_decipher_req(cci_decipher_req); } return; } /* rx_send_decipher_req() */ #endif /* CF_FAST_EXEC */ /* +------------------------------------------------------------------------------ | Function : rx_interpret_frame +------------------------------------------------------------------------------ | Description : This procedure analyses the LLC header and checksum of the | given frame (U, UI, or I) and sets sapi, pdu_type, command, | cr_bit, pf_bit, nr, and ns accordingly. The FCS field is not | included in frame, it has already been stripped off. frame_ok | is set to TRUE if the frame fulfils the following requirements: | known PDU type, valid length, valid PD bit, valid SAPI. | frame_rej indicates a frame rejection condition if any bit of | W4-W1 is set. If a frame is rejected, frame_rej_ctrl_length | indicates the length of the control field. If this length | could not be determined, frame_rej_ctrl_length is set to the | number of control field octets of the frame. | | Parameters : frame - contains the frame to be analysed, must be | a valid pointer | sapi - will be set to the SAPI of the frame, must be | a valid pointer | pdu_type - will be set to the PDU type of the frame, must be | a valid pointer | command - will be set to the command (I/S, U) of the frame | (if available), must be a valid pointer | cr_bit - will be set to the C/R bit of the frame, must be | a valid pointer | pf_bit - will be set to the P/F bit of the frame (if | available), must be a valid pointer | nr - will be set to N(R) / N(U) of the frame (if | available), must be a valid pointer | ns - will be set to N(S) of the frame (if available), | must be a valid pointer | frame_ok - TRUE if the frame is ok, else FALSE, must be | a valid pointer | frame_rej - indicates a frame rejection condition, must be | a valid pointer | frame_rej_ctrl_length - number of octets in the rejected | control field, must be a valid pointer | +------------------------------------------------------------------------------ */ /*#if defined(CF_FAST_EXEC) || defined(_SIMULATION_) || \ !defined(REL99) || defined(LL_2to1) */ GLOBAL void rx_interpret_frame (T_sdu *frame, UBYTE *sapi, T_PDU_TYPE *pdu_type, T_COMMAND *command, T_BIT *cr_bit, T_BIT *pf_bit, T_FRAME_NUM *nr, T_FRAME_NUM *ns, BOOL *frame_ok, UBYTE *frame_rej, USHORT *frame_rej_ctrl_length, UBYTE cipher) { USHORT min_length = 0; /* minimum required frame length */ BOOL check_length; /* check/ignore length at the end */ TRACE_FUNCTION( "rx_interpret_frame" ); /* * Preset variables with suspected success, control field length is not * yet known, so assume complete frame length. */ *frame_ok = TRUE; *frame_rej = FRAME_NOT_REJ; *frame_rej_ctrl_length = frame->l_buf/8 - 1; /* * Frame length is selectively activated, depending on frame type, command, * etc. Ignore frame length per default. */ check_length = FALSE; /* * Check if the frame contains enough octets to access the first octet of * the control field to find out the type of the frame. */ if (frame->l_buf/8 < CTRL_MIN_OCTETS) { *frame_ok = FALSE; return; } /* * Check if PD bit is set to 0. If it is not, the frame is invalid. * <R.LLC.XCEPTION.A.001> */ if ((frame->buf[frame->o_buf/8] & 0x80) != 0x00) { *frame_ok = FALSE; return; } /* * Extract C/R bit. */ *cr_bit = (frame->buf[frame->o_buf/8] & 0x40) >> 6; /* * Extract SAPI and check if the frame contains a reserved SAPI. * <R.LLC.XCEPTION.A.001> */ *sapi = frame->buf[frame->o_buf/8] & 0x0F; switch (*sapi) /* !!!!! constants or function/macro to determine invalid sapis */ { case 0: case 2: case 4: case 6: case 8: case 10: case 12: case 13: case 14: case 15: { *frame_ok = FALSE; return; } } /* * Determine the PDU type of the frame, along with the minimum length * required for this PDU type to constitute a complete frame. * Additionally, extract available variables for each PDU type. */ if ((frame->buf[(frame->o_buf/8)+1] & I_FRAME_MASK) EQ I_FRAME_ID) { /* * I frame, at least 5 octets (1 Address, 3 Control, 1(++) * Information, no FCS) */ *pdu_type = I_FRAME; min_length = I_FRAME_MIN_OCTETS_WITHOUT_FCS; *frame_rej_ctrl_length = I_CTRL_OCTETS; /* * Extract A bit (stored in P/F bit) */ *pf_bit = (frame->buf[(frame->o_buf/8)+1] & 0x40) >> 6; /* * Check if the frame contains enough octets to access the complete * I frame control field. */ if (frame->l_buf/8 < I_CTRL_MIN_OCTETS) { *frame_ok = FALSE; return; } /* * Extract N(S), N(R) */ *ns = (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+1] & 0x1F) << 4; *ns |= (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+2] >> 4); *nr = (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+2] & 0x07) << 6; *nr |= (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+3] >> 2); /* * Determine the command of the I frame (S1 & S2 bits) */ switch (frame->buf[(frame->o_buf/8)+3] & 0x03) { case I_FRAME_RR: TRACE_4_PARA("I-RR s:%d len:%d nr:%d ns:%d", *sapi, BYTELEN(frame->l_buf), *nr, *ns); *command = I_RR; break; case I_FRAME_ACK: TRACE_4_PARA("I-ACK s:%d len:%d nr:%d ns:%d", *sapi, BYTELEN(frame->l_buf), *nr, *ns); *command = I_ACK; break; case I_FRAME_RNR: TRACE_4_PARA("I-RNR s:%d len:%d nr:%d ns:%d", *sapi, BYTELEN(frame->l_buf), *nr, *ns); *command = I_RNR; break; case I_FRAME_SACK: TRACE_4_PARA("I-SACK s:%d len:%d nr:%d ns:%d", *sapi, BYTELEN(frame->l_buf), *nr, *ns); *command = I_SACK; /* * Check if the frame contains enough octets to access the complete * I frame SACK control field. K is at octet I_CTRL_MIN_OCTETS + 1 * and there must be at least K+1 octets within the bitmap. Therefore * the frame must contain a minimum of I_CTRL_MIN_OCTETS+2. */ if (frame->l_buf/8 < I_CTRL_MIN_OCTETS+2) { *frame_ok = FALSE; return; } /* * min_length is being modified to be more accurate for SACK frames, * according to the Bitmap Length Indicator K in * frame->buf[(frame->o_buf/8)+4]. */ min_length += (frame->buf[(frame->o_buf/8)+4] & 0x1F) + 1; check_length = TRUE; break; default: /* * Frame rejection condition due to receipt of a command or * response field that is undefined or not implemented (set * W3 bit to 1). * <R.LLC.XCEPTION.A.002> */ *frame_ok = FALSE; *frame_rej = FRAME_REJ_W3; return; } } else if ((frame->buf[(frame->o_buf/8)+1] & S_FRAME_MASK) EQ S_FRAME_ID) { /* * S frame, fixed 3 octets (1 Address, 2 Control, 0 Information, no FCS) */ *pdu_type = S_FRAME; min_length = S_FRAME_MIN_OCTETS_WITHOUT_FCS; *frame_rej_ctrl_length = S_CTRL_OCTETS; /* * Extract A bit (stored in P/F bit) */ *pf_bit = (frame->buf[(frame->o_buf/8)+1] & 0x20) >> 5; /* * Check if the frame contains enough octets to access the complete * S frame control field. */ if (frame->l_buf/8 < S_CTRL_MIN_OCTETS) { *frame_ok = FALSE; *frame_rej = FRAME_REJ_W1; *frame_rej_ctrl_length = frame->l_buf/8 - 1; return; } /* * Extract N(R) */ *nr = (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+1] & 0x07) << 6; *nr |= (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+2] >> 2); /* * Determine the command of the S frame (S1 & S2 bits) */ switch (frame->buf[(frame->o_buf/8)+2] & 0x03) { case I_FRAME_RR: TRACE_2_PARA("S-RR s:%d nr:%d", *sapi, *nr); *command = I_RR; check_length = TRUE; break; case I_FRAME_ACK: TRACE_2_PARA("S-ACK s:%d nr:%d", *sapi, *nr); *command = I_ACK; check_length = TRUE; break; case I_FRAME_RNR: TRACE_2_PARA("S-RNR s:%d nr:%d", *sapi, *nr); *command = I_RNR; check_length = TRUE; break; case I_FRAME_SACK: TRACE_2_PARA("S-SACK s:%d nr:%d", *sapi, *nr); *command = I_SACK; /* * min_length is being modified to be more accurate for SACK frames. * The S frame SACK format adds a number of up to 32 octets to the * control field. */ min_length += S_FRAME_SACK_MIN_CTRL_OCTETS; check_length = FALSE; break; default: /* * Frame rejection condition due to receipt of a command or * response field that is undefined or not implemented (set * W3 bit to 1). * <R.LLC.XCEPTION.A.002> */ *frame_ok = FALSE; *frame_rej = FRAME_REJ_W3; return; } } else if ((frame->buf[(frame->o_buf/8)+1] & UI_FRAME_MASK) EQ UI_FRAME_ID) { /* * UI frame, at least 3 octets (1 Address, 2 Control, 0(++) * Information, no FCS) */ *pdu_type = UI_FRAME; min_length = UI_FRAME_MIN_OCTETS_WITHOUT_FCS; *frame_rej_ctrl_length = UI_CTRL_OCTETS; /* * Check if the frame contains enough octets to access the complete * UI frame control field. */ if (frame->l_buf/8 < UI_CTRL_MIN_OCTETS) { *frame_ok = FALSE; return; } /* * Extract N(U) (is stored in N(R)) */ *nr = (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+1] & 0x07) << 6; *nr |= (T_FRAME_NUM)(frame->buf[(frame->o_buf/8)+2] >> 2); TRACE_4_PARA("UI s:%d len:%d nr:%d c:%d", *sapi, BYTELEN(frame->l_buf), *nr, cipher); } else if ((frame->buf[(frame->o_buf/8)+1] & U_FRAME_MASK) EQ U_FRAME_ID) { /* * U frame, at least 2 octets (1 Address, 1 Control, 0(++) * Information, no FCS) */ *pdu_type = U_FRAME; min_length = U_FRAME_MIN_OCTETS_WITHOUT_FCS; *frame_rej_ctrl_length = U_CTRL_OCTETS; /* * Extract P/F bit */ *pf_bit = (frame->buf[(frame->o_buf/8)+1] & 0x10) >> 4; /* * Check if the frame contains enough octets to access the complete * U frame control field. * NOTE: * This check could be omitted, because the U frame control field size * is only one octet. */ if (frame->l_buf/8 < U_CTRL_MIN_OCTETS) { *frame_ok = FALSE; *frame_rej = FRAME_REJ_W1; return; } /* * Determine the command of the U frame (M4, M3, M2, M1). * Adjust the minimum length of the frame, if possible. */ switch (frame->buf[(frame->o_buf/8)+1] & 0x0F) { case U_FRAME_DM: TRACE_1_PARA("DM s:%d", *sapi); *command = U_DM; /* * No information field is permitted. */ check_length = TRUE; break; case U_FRAME_DISC: TRACE_1_PARA("DISC s:%d", *sapi); *command = U_DISC; /* * No information field is permitted. */ check_length = TRUE; break; case U_FRAME_UA: TRACE_2_PARA("UA s:%d len:%d", *sapi, BYTELEN(frame->l_buf)); *command = U_UA; /* * No knowledge if an information field is permitted, because * this is only the case when UA is the response to SABM. */ break; case U_FRAME_SABM: TRACE_2_PARA("SABM s:%d len:%d", *sapi, BYTELEN(frame->l_buf)); *command = U_SABM; /* * An information field is permitted, containing XID * parameters. Therefore the size of the information field * is not (yet) known. */ break; case U_FRAME_FRMR: TRACE_1_PARA("FRMR s:%d", *sapi); *command = U_FRMR; /* * FRMR response contains an information field of 10 octets. * <R.LLC.XCEPTION.A.008> */ min_length += U_FRAME_FRMR_INFO_OCTETS; check_length = TRUE; break; case U_FRAME_XID: if( *cr_bit == SGSN_COMMAND ) { TRACE_2_PARA("XID REQ s:%d len:%d", *sapi, BYTELEN(frame->l_buf)); } else { TRACE_2_PARA("XID RSP s:%d len:%d", *sapi, BYTELEN(frame->l_buf)); } *command = U_XID; /* * An information field is required, containing XID * parameters. Therefore the size of the information field * is not (yet) known. */ break; default: TRACE_0_INFO("Not supported U frame received"); /* * Frame rejection condition due to receipt of a command or * response field that is undefined or not implemented (set * W3 bit to 1). * <R.LLC.XCEPTION.A.002> */ *frame_ok = FALSE; *frame_rej = FRAME_REJ_W3; return; } } /* * Determine if it is requested to check the frame length exactly * (check_length EQ TRUE), or just to check the minimum frame length * (check_length EQ FALSE). */ if (check_length AND (frame->l_buf/8 NEQ min_length)) { /* * Actual length of frame doesn't correspond with computed length. */ *frame_ok = FALSE; /* * Check if frame rejection condition occured: S or U frame with * incorrect length (= W1 + W3 bits). frame_rej_ctrl_length has already * been set above to the correct control field length. * <R.LLC.XCEPTION.A.002>, <R.LLC.XCEPTION.A.010> */ if ((*pdu_type EQ S_FRAME) OR (*pdu_type EQ U_FRAME)) { *frame_rej = FRAME_REJ_W1 | FRAME_REJ_W3; } return; } else if (frame->l_buf/8 < min_length) { /* * Frame doesn't contain enough octets to include the address field, * control field, information field, and FCS field necessary to constitute * a complete frame according to the PDU type. * <R.LLC.XCEPTION.A.001> */ *frame_ok = FALSE; return; } return; } /* rx_interpret_frame() */ /* #endif */ /* CF_FAST_EXEC || _SIMULATION_ */ /* +------------------------------------------------------------------------------ | Function : rx_strip_llc_header +------------------------------------------------------------------------------ | Description : This procedure strips the LLC header field off of the sdu | so that the sdu contains only the remaining L3-PDU. | | Parameters : sdu - contains the SDU (frame), must be a valid pointer | pdu_type - contains the PDU type of the frame, must be | a valid PDU type | command - contains the command (I/S, U) of the frame, must be | a valid command for the given PDU type | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL void rx_strip_llc_header (T_sdu *sdu, T_PDU_TYPE pdu_type, T_COMMAND command) { UBYTE header_len = 0; TRACE_FUNCTION ("rx_strip_llc_header"); switch (pdu_type) { case I_FRAME: /* * I frame 4 octets. Leave SACK Bitmap in PDU, will be stripped later! * (1 Address, 3Control). */ header_len = I_CTRL_MIN_OCTETS; break; case S_FRAME: /* * S frame 3 octets. Leave SACK Bitmap in PDU, will be stripped later! * (1 Address, 2(+32 max) Control). */ header_len = S_CTRL_MIN_OCTETS; break; case UI_FRAME: /* * UI frame, 3 octets (1 Address, 2 Control). */ header_len = UI_CTRL_MIN_OCTETS; break; case U_FRAME: /* * U frame, 2 octets (1 Address, 1 Control). */ header_len = U_CTRL_MIN_OCTETS; break; default: TRACE_ERROR ("Unknown PDU type"); break; } /* * Adjust the beginning of the PDU using the determined header_len. */ sdu->o_buf += header_len * 8; /* * Adjust the length of the PDU by the size of the header field. */ sdu->l_buf -= header_len * 8; return; } /* rx_strip_llc_header() */ #endif /* CF_FAST_EXEC */ /* +------------------------------------------------------------------------------ | Function : rx_get_desc_octet +------------------------------------------------------------------------------ | Description : This procedure maps the given linear offset to a descriptor | list and returns the value of the octet at this offset. If | offset is too large for descriptor list, 0x00 is returned. | Each descriptor in descriptor list is evaluated until the | requested offset is reached. The resulting octet value is | written to the referenced parameter data_ptr (if not set to | NULL), and is additionally returned. | | Parameters : desc_list - a valid pointer to a valid descriptor list | offset - linear octet offset, beginning with 0 | data_ptr - a valid pointer to be set to the resulting octet | value, or NULL | +------------------------------------------------------------------------------ */ #ifndef CF_FAST_EXEC GLOBAL UBYTE rx_get_desc_octet (T_desc_list *desc_list, USHORT offset, UBYTE *data_ptr) { T_desc *desc; UBYTE *desc_data; /* local pointer to data octet */ /* * Check if offset is contained in descriptor list. Return 0x00 if not. */ if (offset >= desc_list->list_len) { TRACE_ERROR ("offset too large for descriptor list"); return 0x00; } /* * Search requested data with given linear offset in descriptor list. * Empty descriptors are skipped. Check for each descriptor if requested * offset is in descriptor, until it is found. */ desc = (T_desc *)desc_list->first; desc_data = NULL; do { if (offset < desc->len) { /* * Requested data is in current descriptor. Set desc_data to point to * requested octet with remaining offset (has been decremented by * already passed descriptor payload). */ /*lint -e662 Possible creation of out-of-bounds pointer */ desc_data = &(desc->buffer[offset]); } else { /* * Requested data is not in current descriptor. Remember data payload * of current descriptor as already passed. */ offset -= desc->len; } desc = (T_desc *)desc->next; } while ((desc NEQ NULL) AND (desc_data EQ NULL)); if (desc_data EQ NULL) { TRACE_ERROR ("descriptor list ended before offset found"); if (data_ptr NEQ NULL) { *data_ptr = 0; } return 0; } else { /* * Store value of found octet in data_ptr, if pointer is valid. */ if (data_ptr NEQ NULL) { /*lint -e661 Possible access of out-of-bounds pointer */ *data_ptr = *desc_data; } return *desc_data; } } /* rx_get_desc_octet() */ #endif /* CF_FAST_EXEC */