FreeCalypso > hg > fc-selenite
diff src/g23m-gprs/sndcp/sndcp_mgf.c @ 1:d393cd9bb723
src/g23m-*: initial import from Magnetite
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 15 Jul 2018 04:40:46 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/g23m-gprs/sndcp/sndcp_mgf.c Sun Jul 15 04:40:46 2018 +0000 @@ -0,0 +1,6120 @@ +/* ++----------------------------------------------------------------------------- +| Project : GPRS (8441) +| Modul : sndcp_mgf.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 : This modul is part of the entity SNDCP and implements all +| procedures and functions as described in the +| SDL-documentation (MG-statemachine) ++----------------------------------------------------------------------------- +*/ + + +#define ENTITY_SNDCP + +/*==== INCLUDES =============================================================*/ + +#include "typedefs.h" /* to get Condat data types */ +#include "vsi.h" /* to get a lot of macros */ +#include "macdef.h" +#include "gsm.h" /* to get a lot of macros */ +#include "prim.h" /* to get the definitions of used SAP and directions */ + +#include "dti.h" + +#include "sndcp.h" /* to get the global entity definitions */ +#include "sndcp_f.h" /* to get the functions to access the global arrays*/ + +#include "sndcp_cias.h" /* to get the signals to service cia */ +#include "sndcp_nds.h" /* to get the signals to service nd */ +#include "sndcp_nus.h" /* to get the signals to service nu */ +#include "sndcp_nuf.h" +#include "sndcp_sus.h" /* to get the signals to service su */ +#include "sndcp_suas.h" /* to get the signals to service su */ +#include "sndcp_sds.h" /* to get the signals to service sd */ +#include "sndcp_sdas.h" /* to get the signals to service sda */ + +#include "sndcp_mgf.h" /* to get ths file */ +#include "sndcp_nup.h" /* nu_sn_[unit]data_req is called from + sig_callback().*/ + +#include <string.h> + +/*==== CONST ================================================================*/ + +/*==== LOCAL VARS ===========================================================*/ + +/*==== PRIVATE FUNCTIONS ====================================================*/ + +LOCAL void mg_get_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE* dntt); + +LOCAL void mg_get_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL* used); + +LOCAL void mg_get_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE* state); + +LOCAL void mg_get_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE* stat); + +LOCAL void mg_get_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE* stat); + +LOCAL void mg_get_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE* state); + +LOCAL void mg_set_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL used); + +LOCAL void mg_set_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE stat); + +LOCAL void mg_set_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE dntt); + +LOCAL void mg_set_sapi_dntt_rej (UBYTE sapi, UBYTE dntt, BOOL rej); + +LOCAL void mg_set_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE state); + +LOCAL void mg_set_sapi_pntt_nsapi (UBYTE sapi, UBYTE pntt, UBYTE nsapi, BOOL used); + +LOCAL void mg_set_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE stat); + +LOCAL void mg_set_sapi_pcomp_pntt (UBYTE sapi, UBYTE pcomp, UBYTE pntt); + +LOCAL void mg_set_sapi_pntt_rej (UBYTE sapi, UBYTE pntt, BOOL rej); + +LOCAL void mg_set_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE state); + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_dcomp_dntt ++------------------------------------------------------------------------------ +| Description : The procedures indicates the dntt assigned to a given dcomp +| for a given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dcomp UBYTE, +| IN/OUT dntt UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_get_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE* dntt) +{ + TRACE_FUNCTION( "mg_get_sapi_dcomp_dntt" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *dntt = sndcp_data->mg.sapi_dcomp_dntt_ra[sapi_index][dcomp]; + } +} /* mg_get_sapi_dcomp_dntt() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_dntt_nsapi ++------------------------------------------------------------------------------ +| Description : The procedure informs if a given nsapi uses a given dntt on a +| given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dntt UBYTE, +| IN nsapi UBYTE, +| IN/OUT used BOOL +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_get_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL* used) +{ + TRACE_FUNCTION( "mg_get_sapi_dntt_nsapi" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *used = sndcp_data->mg.sapi_dntt_nsapi_set_ra[sapi_index][dntt][nsapi]; + } +} /* mg_get_sapi_dntt_nsapi() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_dcomp_state ++------------------------------------------------------------------------------ +| Description : The procedures informs about the state of a given dcomp on a +| given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dcomp UBYTE, +| IN/OUT stat UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_get_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE* stat) +{ + TRACE_FUNCTION( "mg_get_sapi_dcomp_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *stat = sndcp_data->mg.sapi_dcomp_state_ra[sapi_index][dcomp]; + } +} /* mg_get_sapi_dcomp_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_dntt_state ++------------------------------------------------------------------------------ +| Description : The procedures informs about the state of a given data +| compression entity on a given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dntt UBYTE, +| IN/OUT state UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_get_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE* state) +{ + TRACE_FUNCTION( "mg_get_sapi_dntt_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *state = sndcp_data->mg.sapi_dntt_state_ra[sapi_index][dntt]; + } + + + +} /* mg_get_sapi_dntt_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_pcomp_state ++------------------------------------------------------------------------------ +| Description : The procedures informs about the state of a given pcomp on a +| given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pcomp UBYTE, +| IN/OUT stat UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_get_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE* stat) +{ + TRACE_FUNCTION( "mg_get_sapi_pcomp_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *stat = sndcp_data->mg.sapi_pcomp_state_ra[sapi_index][pcomp]; + } +} /* mg_get_sapi_pcomp_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_pntt_state ++------------------------------------------------------------------------------ +| Description : The procedures informs about the state of a given header +| compression entity on a given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pntt UBYTE, +| IN/OUT state UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_get_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE* state) +{ + TRACE_FUNCTION( "mg_get_sapi_pntt_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *state = sndcp_data->mg.sapi_pntt_state_ra[sapi_index][pntt]; + } +} /* mg_get_sapi_pntt_state() */ + + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_check_sense_bitwise ++------------------------------------------------------------------------------ +| Description : Checks, if "small" is bitwise smaller than or equal to "big" +| +| Parameters : USHORT small, big, BOOL wrong is set to TRUE, if small > big +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_ushort_sense_bitwise (USHORT small, + USHORT big, + BOOL* wrong) { + UBYTE bit = 0; + TRACE_FUNCTION( "mg_check_sense_bitwise" ); + *wrong = TRUE; + for (bit = 0; bit < 8 * sizeof(USHORT); bit++) { + if ((small & (1 << bit)) > (big & (1 << bit))) { + return; + } + } + *wrong = FALSE; +} /* mg_check_sense_bitwise() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_check_sense_bitwise ++------------------------------------------------------------------------------ +| Description : Checks, if "small" is bitwise smaller than "big" +| +| Parameters : UBYTE small, big, BOOL wrong is set to TRUE, if small > big +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_ubyte_sense_bitwise (UBYTE small, + UBYTE big, + BOOL* wrong) { + UBYTE bit = 0; + TRACE_FUNCTION( "mg_check_sense_bitwise" ); + *wrong = TRUE; + for (bit = 0; bit < 8 * sizeof(UBYTE); bit++) { + if ((small & (1 << bit)) > (big & (1 << bit))) { + return; + } + } + *wrong = FALSE; +} /* mg_check_sense_bitwise() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_decode_v42 ++------------------------------------------------------------------------------ +| Description : decodes the v42 part of given sdu to given xid block +| +| Parameters : source sdu, +| index in sdu, +| field index in sdu (sub index in compression fields, +| destination xid block, +| success ok +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_decode_v42 (T_sdu* sdu, + USHORT* index, + USHORT* field_index, + T_XID_BLOCK* xid_block, + BOOL* ok, + UBYTE p_bit) { +#define CHECK_XID_BUFFER_LEN2 if (*index + *field_index >= ((sdu->l_buf) >> 3)) return + + USHORT field_length = 0; + TRACE_FUNCTION( "mg_decode_v42" ); + *ok = FALSE; + + /* + * Set field_index to length of field octet. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + field_length = sdu->buf[*index + *field_index]; + /* + * NSAPIS parameter and followers omitted? + */ + if (p_bit == SNDCP_P_BIT_1) { + if (field_length == MG_DATA_P_1_NSAPIS_OM) { + *ok = TRUE; + return; + } + } else { + if (field_length == MG_DATA_P_0_NSAPIS_OM) { + *ok = TRUE; + return; + } + } + /* + * If p bit set to 1, set field_index to dcomp field. + */ + if (p_bit == SNDCP_P_BIT_1) { + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.dcomp = + ((USHORT)sdu->buf[*index + *field_index]) >> 4; + } + /* + * Set field_index to MSB of applicable nsapis short. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.nsapis = + ((USHORT)sdu->buf[*index + *field_index]) << 8; + xid_block->v42.nsapis_set = TRUE; + /* + * Set field_index to LSB of applicable nsapis short. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.nsapis += + ((USHORT)sdu->buf[*index + *field_index]); + /* + * P0 parameter and followers omitted? + */ + if (p_bit == SNDCP_P_BIT_1) { + if (field_length == MG_DATA_P_1_P0_OM) { + *ok = TRUE; + return; + } + } else { + if (field_length == MG_DATA_P_0_P0_OM) { + *ok = TRUE; + return; + } + } + /* + * Set field_index to p0. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.p0 = + sdu->buf[*index + *field_index]; + xid_block->v42.p0_set = TRUE; + /* + * P1 parameter and followers omitted? + */ + if (p_bit == SNDCP_P_BIT_1) { + if (field_length == MG_DATA_P_1_P1_OM) { + *ok =TRUE; + return; + } + } else { + if (field_length == MG_DATA_P_0_P1_OM) { + *ok =TRUE; + return; + } + } + /* + * Set field_index to MSB of p1. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.p1 = + ((USHORT)sdu->buf[*index + *field_index]) << 8; + xid_block->v42.p1_set = TRUE; + /* + * Set field_index to LSB of p1. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.p1 += + ((USHORT)sdu->buf[*index + *field_index]); + /* + * P2 parameter and followers omitted? + */ + if (p_bit == SNDCP_P_BIT_1) { + if (field_length == MG_DATA_P_1_P2_OM) { + *ok = TRUE; + return; + } + } else { + if (field_length == MG_DATA_P_0_P2_OM) { + *ok = TRUE; + return; + } + } + /* + * Set field_index to p2. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN2; + xid_block->v42.p2 = + sdu->buf[*index + *field_index]; + xid_block->v42.p2_set = TRUE; + + /* + * If length of v42 field is longer than specified, ignore the rest. + */ + while (*field_index < field_length) { + CHECK_XID_BUFFER_LEN2; + (*field_index)++; + } + + *ok = TRUE; + +} /* mg_decode_v42() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_decode_vj ++------------------------------------------------------------------------------ +| Description : decodes the vj part of given sdu to given xid block +| +| Parameters : source sdu, +| index in sdu, +| field index in sdu (sub index in compression fields, +| destination xid block, +| success ok +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_decode_vj (T_sdu* sdu, + USHORT* index, + USHORT* field_index, + T_XID_BLOCK* xid_block, + BOOL* ok, + UBYTE p_bit) { +#define CHECK_XID_BUFFER_LEN3 if (*index + *field_index >= ((sdu->l_buf) >> 3)) return + + USHORT field_length = 0; + TRACE_FUNCTION( "mg_decode_vj" ); + + /* + * Set field_index to length of field octet. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN3; + field_length = sdu->buf[*index + *field_index]; + /* + * NSAPIS parameter and followers omitted? + */ + if (p_bit == SNDCP_P_BIT_1) { + if (field_length == MG_HEADER_P_1_NSAPIS_OM) { + *ok = TRUE; + return; + } + } else { + if (field_length == MG_HEADER_P_0_NSAPIS_OM) { + *ok = TRUE; + return; + } + } + /* + * If p bit set to 1, set field_index to dcomp field. + */ + if (p_bit == SNDCP_P_BIT_1) { + (*field_index)++; + CHECK_XID_BUFFER_LEN3; + xid_block->vj.pcomp1 = + ((USHORT)sdu->buf[*index + *field_index]) >> 4; + xid_block->vj.pcomp2 = + ((USHORT)sdu->buf[*index + *field_index]) & 0xf; + } + + /* + * Set field_index to MSB of applicable nsapis short. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN3; + xid_block->vj.nsapis = + ((USHORT)sdu->buf[*index + *field_index]) << 8; + xid_block->vj.nsapis_set = TRUE; + /* + * Set field_index to LSB of applicable nsapis short. + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN3; + xid_block->vj.nsapis += + ((USHORT)sdu->buf[*index + *field_index]); + /* + * S0_M_1 parameter omitted? + */ + if (p_bit == SNDCP_P_BIT_1) { + if (field_length == MG_HEADER_P_1_S0_M_1_OM) { + *ok = TRUE; + return; + } + } else { + if (field_length == MG_HEADER_P_0_S0_M_1_OM) { + *ok = TRUE; + return; + } + } + /* + * Set field_index to "s0 - 1" Parameter + */ + (*field_index)++; + CHECK_XID_BUFFER_LEN3; + xid_block->vj.s0_m_1 = sdu->buf[*index + *field_index]; + xid_block->vj.s0_m_1_set = TRUE; + + /* + * If length of vj field is longer than specified, ignore the rest. + */ + while (*field_index < field_length) { + CHECK_XID_BUFFER_LEN3; + (*field_index)++; + } + + + *ok = TRUE; + +} /* mg_decode_vj() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_detect_mode_clash ++------------------------------------------------------------------------------ +| Description : Unacknowledged and acknowledged contexts may not share the same +| compressor entity. This procdure detects possible violations of that rule. +| +| Parameters : the set of nsapis given as USHORT bit mask, +| violation detected, TRUE if at least 1 acknowledged and 1 +| unacknowledged context share the same compressor. +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_detect_mode_clash (USHORT nsapis, BOOL* vio) +{ + UBYTE nsapi = 0; + BOOL unack_found = FALSE; + BOOL ack_found = FALSE; + BOOL ack = FALSE; + TRACE_FUNCTION( "mg_detect_mode_clash" ); + /* + * Find affected nsapis. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if ((nsapis & (1 << nsapi)) > 0) { + sndcp_get_nsapi_ack(nsapi, &ack); + if (ack) { + ack_found = TRUE; + } else { + unack_found = TRUE; + } + } + } + *vio = unack_found && ack_found; + + +} /* mg_detect_mode_clash() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_respond_if_nec ++------------------------------------------------------------------------------ +| Description : All nsapis connected to the given sapi +| that are in state MG_ACT are sent an +| SNSM_ACTIVATE_RES. +| +| Parameters : sapi +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_respond_if_nec (UBYTE sapi) { + UBYTE nsapi = 0; + UBYTE sapi_index = 0; +#ifdef SNDCP_UPM_INCLUDED + BOOL ack = FALSE; +#endif /* SNDCP_UPM_INCLUDED */ + + TRACE_FUNCTION( "mg_respond_if_nec" ); + + sndcp_get_sapi_index(sapi, &sapi_index); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + USHORT nsapi_state = MG_IDLE; + USHORT sapi_state = MG_IDLE; + UBYTE local_sapi = 0; + sndcp_get_nsapi_state(nsapi, &nsapi_state); + sndcp_get_nsapi_sapi(nsapi, &local_sapi); + sndcp_get_sapi_state(local_sapi, &sapi_state); + if (((nsapi_state & MG_ACT) > 0) + && + ((sapi_state & MG_XID) == 0) + && + ((sapi_state & MG_EST) == 0) + && + (local_sapi == sapi)) { + + /* + * Open DTI connection. + */ +#ifndef SNDCP_UPM_INCLUDED + mg_dti_open(nsapi); +#else + sndcp_get_nsapi_ack(nsapi, &ack); + if (ack) { + nu_ready_ind_if_nec(nsapi); + } else { + nu_unitready_ind_if_nec(nsapi); + } +#endif + + mg_send_snsm_activate_res(nsapi); + /* + * Set nsapi state to MG_IDLE. + */ + sndcp_unset_nsapi_state (nsapi, MG_ACT); + } + + if (((nsapi_state & MG_DEACT) > 0) + && + ((sapi_state & MG_XID) == 0) + && + ((sapi_state & MG_REL) == 0) + && + (local_sapi == sapi)) { + +#ifdef SNDCP_UPM_INCLUDED + PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF); +#else + PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + /* + * Now the NSAPI is not in use anymore: + */ + sndcp_set_nsapi_used(nsapi, FALSE); + sndcp_set_nsapi_ack(nsapi, FALSE); + + snsm_deactivate_res->nsapi = nsapi; + sndcp_unset_nsapi_state(nsapi, MG_DEACT); +#ifdef SNDCP_UPM_INCLUDED + PSEND(hCommUPM, snsm_deactivate_res); +#else + PSEND(hCommSM, snsm_deactivate_res); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + } + + } + +} /* mg_respond_if_nec */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_ntt_comp ++------------------------------------------------------------------------------ +| Description : Sets ntt and comp values acc. to req_xid_block. +| +| Parameters : UBYTE sapi, BOOL is this a renegotiation? +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_ntt_comp (UBYTE sapi) { + UBYTE sapi_index = 0; + UBYTE nsapi = 0; + TRACE_FUNCTION( "mg_set_ntt_comp" ); + sndcp_get_sapi_index(sapi, &sapi_index); + + if (sndcp_data->mg.req_xid_block[sapi_index].v42.is_set) { + mg_set_sapi_dntt_state(sapi, + sndcp_data->mg.req_xid_block[sapi_index].v42.ntt, + MG_SELECTED); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if ((sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis & (1 << nsapi)) + > 0) { + mg_set_sapi_dntt_nsapi(sapi, + sndcp_data->mg.req_xid_block[sapi_index].v42.ntt, + nsapi, + TRUE); + } + } + mg_set_sapi_dcomp_state(sapi, + sndcp_data->mg.req_xid_block[sapi_index].v42.dcomp, + MG_SELECTED); + mg_set_sapi_dcomp_dntt(sapi, + sndcp_data->mg.req_xid_block[sapi_index].v42.dcomp, + sndcp_data->mg.req_xid_block[sapi_index].v42.ntt); + } + if (sndcp_data->mg.req_xid_block[sapi_index].vj.is_set) { + mg_set_sapi_pntt_state(sapi, + sndcp_data->mg.req_xid_block[sapi_index].vj.ntt, + MG_SELECTED); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if ((sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis & (1 << nsapi)) + > 0) { + mg_set_sapi_pntt_nsapi(sapi, + sndcp_data->mg.req_xid_block[sapi_index].vj.ntt, + nsapi, + TRUE); + } + } + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp1, + MG_SELECTED); + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp2, + MG_SELECTED); + mg_set_sapi_pcomp_pntt(sapi, + sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp1, + sndcp_data->mg.req_xid_block[sapi_index].vj.ntt); + mg_set_sapi_pcomp_pntt(sapi, + sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp2, + sndcp_data->mg.req_xid_block[sapi_index].vj.ntt); + } + + +} /* mg_set_ntt_comp() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_dntt_nsapi ++------------------------------------------------------------------------------ +| Description : The procedure stores the info that a given nsapi uses a given +| dntt on a given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dntt UBYTE, +| IN nsapi UBYTE, +| IN used BOOL +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_dntt_nsapi (UBYTE sapi, UBYTE dntt, UBYTE nsapi, BOOL used) +{ + TRACE_FUNCTION( "mg_set_sapi_dntt_nsapi" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_dntt_nsapi_set_ra[sapi_index][dntt][nsapi] = used; + } +} /* mg_set_sapi_dntt_nsapi() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_dcomp_state ++------------------------------------------------------------------------------ +| Description : The procedures sets the state of a given dcomp on a given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dcomp UBYTE, +| IN stat UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_dcomp_state (UBYTE sapi, UBYTE dcomp, UBYTE stat) +{ + TRACE_FUNCTION( "mg_set_sapi_dcomp_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_dcomp_state_ra[sapi_index][dcomp] = stat; + } +} /* mg_set_sapi_dcomp_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_dcomp_dntt ++------------------------------------------------------------------------------ +| Description : The procedures sets the dntt assigned to a given dcomp +| for a given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dcomp UBYTE, +| IN dntt UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_dcomp_dntt (UBYTE sapi, UBYTE dcomp, UBYTE dntt) +{ + TRACE_FUNCTION( "mg_set_sapi_dcomp_dntt" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_dcomp_dntt_ra[sapi_index][dcomp] = dntt; + } +} /* mg_set_sapi_dcomp_dntt() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_dntt_rej ++------------------------------------------------------------------------------ +| Description : The procedures stores if a given data +| compression entity on a given SAPI is to be rejected in +| LL_XID_REQ because it cannot be set up. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dntt UBYTE, +| IN rej BOOL +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_dntt_rej (UBYTE sapi, UBYTE dntt, BOOL rej) +{ + TRACE_FUNCTION( "mg_set_sapi_dntt_rej" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][dntt] = rej; + } +} /* mg_set_sapi_dntt_rej() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_dntt_state ++------------------------------------------------------------------------------ +| Description : The procedures sets the state of a given data +| compression entity on a given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dntt UBYTE, +| IN state UBYTE +| Note : sapi dntt rej will be set ti FALSE if state is UNASSIGNED +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_dntt_state (UBYTE sapi, UBYTE dntt, UBYTE state) +{ + TRACE_FUNCTION( "mg_set_sapi_dntt_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_dntt_state_ra[sapi_index][dntt] = state; + + if (state == MG_UNASSIGNED) { + mg_set_sapi_dntt_rej(sapi, dntt, FALSE); + } + } +} /* mg_set_sapi_dntt_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_pntt_nsapi ++------------------------------------------------------------------------------ +| Description : The procedure stores the info that a given nsapi uses a given +| pntt on a given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pntt UBYTE, +| IN nsapi UBYTE, +| IN used BOOL +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_pntt_nsapi (UBYTE sapi, UBYTE pntt, UBYTE nsapi, BOOL used) +{ + TRACE_FUNCTION( "mg_set_sapi_pntt_nsapi" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_pntt_nsapi_set_ra[sapi_index][pntt][nsapi] = used; + } +} /* mg_set_sapi_pntt_nsapi() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_pcomp_state ++------------------------------------------------------------------------------ +| Description : The procedures sets the state of a given pcomp on a given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pcomp UBYTE, +| IN stat UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_pcomp_state (UBYTE sapi, UBYTE pcomp, UBYTE stat) +{ + TRACE_FUNCTION( "mg_set_sapi_pcomp_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_pcomp_state_ra[sapi_index][pcomp] = stat; + } +} /* mg_set_sapi_pcomp_state() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_pcomp_pntt ++------------------------------------------------------------------------------ +| Description : The procedures sets the pntt assigned to a given pcomp +| for a given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pcomp UBYTE, +| IN pntt UBYTE +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_pcomp_pntt (UBYTE sapi, UBYTE pcomp, UBYTE pntt) +{ + TRACE_FUNCTION( "mg_set_sapi_pcomp_pntt" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_pcomp_pntt_ra[sapi_index][pcomp] = pntt; + } +} /* mg_get_sapi_pcomp_pntt() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_pntt_rej ++------------------------------------------------------------------------------ +| Description : The procedures stores if a given data +| compression entity on a given SAPI is to be rejected in +| LL_XID_REQ because it cannot be set up. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pntt UBYTE, +| IN rej BOOL +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_pntt_rej (UBYTE sapi, UBYTE pntt, BOOL rej) +{ + TRACE_FUNCTION( "mg_set_sapi_pntt_rej" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][pntt] = rej; + } +} /* mg_set_sapi_pntt_rej() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_sapi_pntt_state ++------------------------------------------------------------------------------ +| Description : The procedures sets the state of a given header +| compression entity on a given SAPI. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pntt UBYTE, +| IN state UBYTE +| Note : sapi pntt rej will be set ti FALSE if state is UNASSIGNED +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_sapi_pntt_state (UBYTE sapi, UBYTE pntt, UBYTE state) +{ + TRACE_FUNCTION( "mg_set_sapi_pntt_state" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_data->mg.sapi_pntt_state_ra[sapi_index][pntt] = state; + + if (state == MG_UNASSIGNED) { + mg_set_sapi_pntt_rej(sapi, pntt, FALSE); + } + } +} /* mg_set_sapi_pntt_state() */ + +#ifndef NCONFIG +/* ++------------------------------------------------------------------------------ +| Function : mg_config_delay ++------------------------------------------------------------------------------ +| Description : after config prim DELAY each new context activation will be +| computed with a delay. +| +| Parameters : delay in milliseconds +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_config_delay (USHORT millis) +{ + + TRACE_FUNCTION("mg_config_delay"); + + sndcp_data->millis = millis; + +} /* mg_config_delay() */ +#endif + + +/* ++------------------------------------------------------------------------------ +| Function : mg_reset_compressors ++------------------------------------------------------------------------------ +| Description : All compressors used by this nsapi are reset. +| +| Parameters : nsapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_reset_compressors (UBYTE nsapi) +{ + BOOL compressed = FALSE; + TRACE_FUNCTION( "mg_reset_compressors" ); + + sndcp_is_nsapi_data_compressed(nsapi, &compressed); + if (compressed) { + /* + * Must be added when data compression is added. + */ + } + + sndcp_is_nsapi_header_compressed(nsapi, &compressed); + if (compressed) { + UBYTE sapi = 0; + UBYTE sapi_index = 0; + /* + * This is implementation dependent and only works as long as only 1 + * header compressor is used in cia service. + */ + sndcp_get_nsapi_sapi(nsapi, &sapi); + sndcp_get_sapi_index(sapi, &sapi_index); + sig_mg_cia_new_xid(&sndcp_data->mg.cur_xid_block[sapi_index]); + } + +} /* mg_reset_compressors() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_reset_comp_ack ++------------------------------------------------------------------------------ +| Description : all compression entities using +| acknowledged peer-to-peer LLC operation on this SAPI are reset. +| +| Parameters : sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_reset_comp_ack (UBYTE sapi) { + UBYTE nsapi = 0; + TRACE_FUNCTION( "mg_reset_comp_ack" ); + /* + * All nsapis at this sapi that use ack mode reset their compressors. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { + UBYTE s = 0; + BOOL ack = FALSE; + BOOL used = FALSE; + sndcp_is_nsapi_used(nsapi, &used); + if (!used) { + continue; + } + sndcp_get_nsapi_sapi(nsapi, &s); + sndcp_get_nsapi_ack(nsapi, &ack); + if (ack && s == sapi) { + mg_reset_compressors(nsapi); + } + } /* for all nsapis */ + +} /* mg_reset_comp_ack() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_reset_states_n_rej ++------------------------------------------------------------------------------ +| Description : Resets all states for ntts and p/dcomp to "unassigned". +| Resets the arrays with information on rejcted entities. +| +| Parameters : index of the affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_reset_states_n_rej (UBYTE sapi_index) +{ + + UBYTE ntt = 0; + UBYTE nsapi = 0; + UBYTE dcomp = 0; + UBYTE pcomp = 0; + TRACE_FUNCTION( "mg_reset_states_n_rej" ); + + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + sndcp_data->mg.sapi_dntt_state_ra[sapi_index][ntt] = MG_UNASSIGNED; + sndcp_data->mg.sapi_pntt_state_ra[sapi_index][ntt] = MG_UNASSIGNED; + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + sndcp_data->mg.sapi_dntt_nsapi_set_ra[sapi_index][ntt][nsapi] = FALSE; + sndcp_data->mg.sapi_pntt_nsapi_set_ra[sapi_index][ntt][nsapi] = FALSE; + } + sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][ntt] = FALSE; + sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][ntt] = FALSE; + } + for (dcomp = 0; dcomp < MG_MAX_DCOMP; dcomp++) { + sndcp_data->mg.sapi_dcomp_state_ra[sapi_index][dcomp] = MG_UNASSIGNED; + } + for (pcomp = 0; pcomp < MG_MAX_PCOMP; pcomp++) { + sndcp_data->mg.sapi_pcomp_state_ra[sapi_index][pcomp] = MG_UNASSIGNED; + } + /* + * sapi_dcomp_dntt_ra, sapi_pcomp_pntt_ra not initialized. + */ + +} /* mg_reset_states_n_rej() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_xid_nsapis ++------------------------------------------------------------------------------ +| Description : AN LL_XID_IND has delivered a desired set of nsapis for +| a V42.bis or VJ compressor entity. Now this is compared to a possibly +| already existing set of nsapis connected to the given entity. +| Also the rules in GSM 4.65, 6.8.x are checked. +| +| Parameters : a flag telling if we work on V42 or VanJacobson 'nsapis': +| MG_XID_V42_NSAPIS or MG_XID_VJ_NSAPIS. +| affected sapi, +| ++------------------------------------------------------------------------------ +*/ +LOCAL void mg_set_xid_nsapis (UBYTE sapi, UBYTE p_type) +{ + USHORT* cur_nsapis = 0; + USHORT* ind_nsapis = 0; + USHORT* res_nsapis = 0; + BOOL* ind_nsapis_set = NULL; + UBYTE sapi_index = 0; + UBYTE* p_bit = NULL; + UBYTE ntt_state = MG_UNASSIGNED; + U8 nsapi = 0; + U8 s0_m_1_min = 0; + + + TRACE_FUNCTION( "mg_set_xid_nsapis" ); + + sndcp_get_sapi_index(sapi, &sapi_index); + + /* + * V42.bis or VanJacobson? + */ + if (p_type == MG_XID_V42_NSAPIS) { + cur_nsapis = &(sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis); + ind_nsapis = &(sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis); + res_nsapis = &(sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis); + ind_nsapis_set = + &(sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis_set); + p_bit = &(sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit); + + *res_nsapis = 0; + /* + * Only those nsapis will be set in the response for which the user + * requested compression. + * Note: te other params are not yet set, must be implemented later. + */ + sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis_set = FALSE; + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if ((((1 << nsapi) & sndcp_data->mg.user_xid_block[nsapi].v42.nsapis) > + 0) && + (((1 << nsapi) & + sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0)) { + + *res_nsapis |= (1 << nsapi); + sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis_set = TRUE; + + } + } /* for nsapi */ + + } else { + cur_nsapis = &(sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis); + ind_nsapis = &(sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis); + res_nsapis = &(sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis); + ind_nsapis_set = + &(sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis_set); + p_bit = &(sndcp_data->mg.ind_xid_block[sapi_index].vj.p_bit); + + *res_nsapis = 0; + /* + * Only those nsapis will be set in the response for which the user + * requested compression. + * In the same loop we set the s0_m_1 to the minimum of + * the indicated value and the values requested by the user. + * Also the direction is set to the minimum of all requested + * directions. + */ + if (sndcp_data->mg.ind_xid_block[sapi_index].vj.s0_m_1 > 0) { + s0_m_1_min = sndcp_data->mg.ind_xid_block[sapi_index].vj.s0_m_1; + } else if (sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 > 0) { + s0_m_1_min = sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1; + } else { + s0_m_1_min = SNDCP_VJ_DEFAULT_S0_M_1; + } + #ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.res_xid_block[sapi_index].vj.direction = + NAS_HCOMP_BOTH_DIRECT; +#else + sndcp_data->mg.res_xid_block[sapi_index].vj.direction = + SNSM_COMP_BOTH_DIRECT; +#endif + + sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis_set = FALSE; + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & sndcp_data->mg.user_xid_block[nsapi].vj.nsapis) > + 0 && + (((1 << nsapi) & + sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis) > 0)) { + + *res_nsapis |= (1 << nsapi); + sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis_set = TRUE; + if (sndcp_data->mg.user_xid_block[nsapi].vj.s0_m_1 < s0_m_1_min) { + s0_m_1_min = sndcp_data->mg.user_xid_block[nsapi].vj.s0_m_1; + } + sndcp_data->mg.res_xid_block[sapi_index].vj.direction &= + sndcp_data->mg.user_xid_block[nsapi].vj.direction; + } + } /* for nsapi */ + sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1 = s0_m_1_min; + if (s0_m_1_min > 0) { + sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1_set = TRUE; + } else { + sndcp_data->mg.res_xid_block[sapi_index].vj.direction = 0; + } + } + + + + /* + * Rules in GSM 4.65, 6.8.1: acknowledged and unacknowlegded contexts may not + * share the same compressor. If that is demanded by the indication, reset + * nsapis parameter to the ones currently used. + */ + if (*ind_nsapis_set && + *ind_nsapis > 0) { + BOOL vio = FALSE; + mg_detect_mode_clash(*ind_nsapis, &vio); + if (!vio) { + /* + * Modes are the same, set cur to res. + */ + *cur_nsapis = *res_nsapis; + } else { + *res_nsapis = *cur_nsapis; + } + } + + /* + * Also from 6.8.3: If an unassigned entity number is included with the + * p bit set to 0, then the Applicable NSAPIs field shall be set to 0. + */ + if (p_type == MG_XID_V42_NSAPIS) { + mg_get_sapi_dntt_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, &ntt_state); + } else { + mg_get_sapi_pntt_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, &ntt_state); + } + if (ntt_state == MG_UNASSIGNED && *p_bit == 0) { + *cur_nsapis = 0; + *res_nsapis = 0; + } + +} /* mg_set_xid_nsapis() */ + + +/*==== PUBLIC FUNCTIONS =====================================================*/ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_check_cnf_xid ++------------------------------------------------------------------------------ +| Description : The confirmation of a requested XID negotiation has been +| received. The answer is now checked. +| A main issue is the comparison with the service variable +| req_xid_block which holds the requested xid block sent to the +| network. +| Detected errors: +| - SNDCP version number not correct +| - incorrect entity number (must be proposed one) +| - incorrect sense of negotiation for each parameter (down mainly, +| NSAPI down bitwise) +| - an entity is included in the cnf that was not requested, does not exist +| Not checked: +| - out of range value of parameters (must be in range if sense ofnegotiation was right. +| - parameters with duplicated instances. +| If one of these errors occurs ret is set to MG_XID_BAD_CONTENT, else +| MG_XID_OK. +| +| Parameters : ret, affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_check_cnf_xid (UBYTE* ret, UBYTE sapi) +{ + UBYTE sapi_index = 0; + BOOL wrong = FALSE; + TRACE_FUNCTION( "mg_check_cnf_xid" ); + sndcp_get_sapi_index(sapi, &sapi_index); + *ret = MG_XID_BAD_CONTENT; + /* + * Check SNDCP version. + */ + if (sndcp_data->mg.cnf_xid_block[sapi_index].version_set) { + if (sndcp_data->mg.cnf_xid_block[sapi_index].version != + SNDCP_XID_VERSION) { + return; + } + } + /* + * If an entity is included that has not been requested / does not exist: + * bad content! + */ + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.is_set && + ! sndcp_data->mg.req_xid_block[sapi_index].v42.is_set && + ! sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set) { + + return; + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.is_set && + ! sndcp_data->mg.req_xid_block[sapi_index].vj.is_set && + ! sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) { + + return; + } + + /* + * Check V42 parameters, if they are set. + */ + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.is_set) { + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p_bit == 1) { + return; + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.ntt != + sndcp_data->mg.req_xid_block[sapi_index].v42.ntt) { + return; + } + /* + * Sense of negotiation. If cnf value has been set, but req has not been + * set then cnf value will be compared with cur value. This + * is not applied to "applicable nsapis". + */ + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.nsapis_set) { + if (sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis_set) { + mg_ushort_sense_bitwise + (sndcp_data->mg.cnf_xid_block[sapi_index].v42.nsapis, + sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis, + &wrong); + } + if (wrong) { + return; + } + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p0_set) { + if (sndcp_data->mg.req_xid_block[sapi_index].v42.p0_set) { + mg_ubyte_sense_bitwise(sndcp_data->mg.cnf_xid_block[sapi_index].v42.p0, + sndcp_data->mg.req_xid_block[sapi_index].v42.p0, + &wrong); + } else { + mg_ubyte_sense_bitwise(sndcp_data->mg.cnf_xid_block[sapi_index].v42.p0, + sndcp_data->mg.cur_xid_block[sapi_index].v42.p0, + &wrong); + } + if (wrong) { + return; + } + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p1_set) { + if (sndcp_data->mg.req_xid_block[sapi_index].v42.p1_set) { + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p1 > + sndcp_data->mg.req_xid_block[sapi_index].v42.p1) { + return; + } + } else { + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p1 > + sndcp_data->mg.cur_xid_block[sapi_index].v42.p1) { + return; + } + } + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p2_set) { + if (sndcp_data->mg.req_xid_block[sapi_index].v42.p2_set) { + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p2 > + sndcp_data->mg.req_xid_block[sapi_index].v42.p2) { + return; + } + } else { + if (sndcp_data->mg.cnf_xid_block[sapi_index].v42.p2 > + sndcp_data->mg.cur_xid_block[sapi_index].v42.p2) { + return; + } + } + } + } + /* + * Check VJ parameters, if they are set. + */ + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.is_set) { + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.p_bit == 1) { + return; + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.ntt != + sndcp_data->mg.req_xid_block[sapi_index].vj.ntt) { + return; + } + /* + * Sense of negotiation. + */ + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.nsapis_set) { + if (sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis_set) { + mg_ushort_sense_bitwise(sndcp_data->mg.cnf_xid_block[sapi_index].vj.nsapis, + sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis, + &wrong); + } + if (wrong) { + return; + } + } + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.s0_m_1_set) { + if (sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1_set) { + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.s0_m_1 > + sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1) { + return; + } + } else { + if (sndcp_data->mg.cnf_xid_block[sapi_index].vj.s0_m_1 > + sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1) { + return; + } + } + } + } + *ret = MG_XID_OK; + +} /* mg_check_cnf_xid() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_check_ind_xid ++------------------------------------------------------------------------------ +| Description : Service variable ind_xid_block holds the xid block indicated +| by the peer. The ind_xid_block is now checked: (from 4.65 6.8.2). +| Criterium 1: +| If the indicated ntt is already used and pcomp or dcomp values are different, +| ret is set to MG_XID_BAD_CONTENT. +| Criterium 2: +| If the indicated algorithm type is already used and pcomp or dcomp values +| are different, ret is set to MG_XID_BAD_CONTENT. +| +| Note: implementation dependent: if data compression is proposed, it will +| be rejected. +| +| Otherwise ret is set to MG_XID_OK. +| Parameters : ret, affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_check_ind_xid (UBYTE* ret, UBYTE sapi) +{ + UBYTE sapi_index = 0; + UBYTE status = MG_UNASSIGNED; + TRACE_FUNCTION( "mg_check_ind_xid" ); + sndcp_get_sapi_index(sapi, &sapi_index); + *ret = MG_XID_OK; + + /* + * Check criterium 1. + */ + if (sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set && + sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit == SNDCP_P_BIT_1) { + mg_get_sapi_dntt_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, &status); + if (status == MG_ASSIGNED) { + /* + * Entity already used. DCOMP values differ? + */ + mg_get_sapi_dcomp_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp, &status); + if (status != MG_ASSIGNED) { + /* + * The indicated dcomp is not assigned. Error. + */ + mg_set_sapi_dntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } else { + UBYTE dntt = 0; + mg_get_sapi_dcomp_dntt + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp, &dntt); + if (dntt != sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt) { + /* + * Dcomp values differ, Error. + */ + mg_set_sapi_dntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } + } + } + } + if (sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set && + sndcp_data->mg.ind_xid_block[sapi_index].vj.p_bit == SNDCP_P_BIT_1) { + mg_get_sapi_pntt_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, &status); + if (status == MG_ASSIGNED) { + /* + * Entity already used. PCOMP values differ? + */ + /* + * PCOMP 1. + */ + mg_get_sapi_pcomp_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &status); + if (status != MG_ASSIGNED) { + /* + * The indicated pcomp is not assigned. Error. + */ + mg_set_sapi_pntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } else { + UBYTE pntt = 0; + mg_get_sapi_pcomp_pntt + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &pntt); + if (pntt != sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt) { + /* + * Pcomp values differ, Error. + */ + mg_set_sapi_pntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } + } + /* + * PCOMP 2. + */ + mg_get_sapi_pcomp_state + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &status); + if (status != MG_ASSIGNED) { + /* + * The indicated pcomp is not assigned. Error. + */ + mg_set_sapi_pntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } else { + UBYTE pntt = 0; + mg_get_sapi_pcomp_pntt + (sapi, sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1, &pntt); + if (pntt != sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt) { + /* + * Dcomp values differ, Error. + */ + mg_set_sapi_pntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } + } + } + } + + /* + * Check criterium 2. + * Since in the current implementation there is only SNDCP_XID_VJ and + * SNDCP_XID_V42, and only 1 instance of each, + * it will be sufficient to compare the proposed values for pcomp/dcomp + * with the ones in cur_xid_block. + * An error may only occur if cur and ind are set. + */ + if (sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set && + sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set && + sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit == SNDCP_P_BIT_1) { + if (sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp != + sndcp_data->mg.cur_xid_block[sapi_index].v42.dcomp) { + mg_set_sapi_dntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } + } + if (sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set && + sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set && + sndcp_data->mg.ind_xid_block[sapi_index].v42.p_bit == SNDCP_P_BIT_1) { + if (sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1 != + sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp1) { + mg_set_sapi_pntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } + if (sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp2 != + sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp2) { + mg_set_sapi_pntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + *ret = MG_XID_BAD_CONTENT; + } + } + +#ifndef TI_PS_FF_V42BIS + /* + * Implementation dependent: If data compression is proposed, reject it! + */ + if (sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set) { + mg_set_sapi_dntt_rej(sapi, + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, + TRUE); + } +#endif /* !TI_PS_FF_V42BIS */ +} /* mg_check_ind_xid() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_clean_xid ++------------------------------------------------------------------------------ +| Description : Cleans up the XID organizing arrays for nsapis and ntts +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_clean_xid (UBYTE sapi) { + UBYTE nsapi = 0; + UBYTE sapi_index = 0; + UBYTE stat = MG_UNASSIGNED; + TRACE_FUNCTION( "mg_clean_xid" ); + sndcp_get_sapi_index(sapi, &sapi_index); + + + /* + * NSAPIs that were assigned to a compressor unit but are not any more. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + BOOL connected = + ((1 << nsapi) & (sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis)) > 0; + mg_set_sapi_dntt_nsapi(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt, + nsapi, + connected); + connected = + ((1 << nsapi) & (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis)) > 0; + mg_set_sapi_pntt_nsapi(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt, + nsapi, + connected); + + + } + + /* + * Formerly assigned ntts that are now unassigned are cleaned. + * Implemented here: the one dntt and the one pntt in cur_xid_block are now + * checked. If they are in state MG_ASSIGNED but the affected 'nsapis' + * element is set to all '0' then the entities enter state MG_UNASSIGNED, + * all nsapis re set to FALSE in the sapi_?ntt_nsapi_ra, all + * affected pcomp/dcomp values are set to MG_UNASSIGNED. + */ + mg_get_sapi_dntt_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt, + &stat); + if (stat == MG_ASSIGNED && + sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis == 0) { + /* + * Reset dntt state. + */ + mg_set_sapi_dntt_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt, + MG_UNASSIGNED); + + /* + * reset nsapi connections. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + mg_set_sapi_dntt_nsapi(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].v42.ntt, + nsapi, + FALSE); + } + /* + * Reset dcomp. + */ + mg_set_sapi_dcomp_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].v42.dcomp, + MG_UNASSIGNED); + } + + + /* + * The same for header compresion. + */ + mg_get_sapi_pntt_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt, + &stat); + if (stat == MG_ASSIGNED && + sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis == 0) { + /* + * Reset pntt state. + */ + mg_set_sapi_pntt_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt, + MG_UNASSIGNED); + /* + * reset nsapi connections. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + mg_set_sapi_pntt_nsapi(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt, + nsapi, + FALSE); + } + /* + * Reset pcomps. + */ + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp1, + MG_UNASSIGNED); + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp2, + MG_UNASSIGNED); + } + + + +} /* mg_clean_xid() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_col_no_re ++------------------------------------------------------------------------------ +| Description : The function mg_col_no_re represents the SDL label +| COL_NO_RE: an LL_ESTABLISH_IND has been received, we do +| have a collision situation like given in [GSM 4.65, 6.2.1.4], +| we do not have a re-establishment situation. +| +| Parameters : the received LL_ESTABLISH_IND +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_col_no_re (T_LL_ESTABLISH_IND* ll_establish_ind) +{ + TRACE_FUNCTION( "mg_col_no_re" ); + + /* + * Resume data transfer suspended due to pending establishment; + */ + sig_mg_su_resume(ll_establish_ind->sapi); + sig_mg_sua_resume(ll_establish_ind->sapi); + mg_resume_affected_nus(ll_establish_ind->sapi); + + /* + * Now proceed like without collision. + */ + mg_no_col_no_re(ll_establish_ind); + + +} /* mg_col_no_re() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_col_re ++------------------------------------------------------------------------------ +| Description : The function mg_col_re represents the SDL label +| COL_RE: an LL_ESTABLISH_IND has been received, we do +| have a collision situation like given in [GSM 4.65, 6.2.1.4], +| we do have a re-establishment situation. +| +| Parameters : the received LL_ESTABLISH_IND +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_col_re (T_LL_ESTABLISH_IND* ll_establish_ind) +{ + TRACE_FUNCTION( "mg_col_re" ); + /* + * Resume data transfer suspended due to pending establishment; + */ + sig_mg_su_resume(ll_establish_ind->sapi); + sig_mg_sua_resume(ll_establish_ind->sapi); + mg_resume_affected_nus(ll_establish_ind->sapi); + /* + * Now proceed like without collision. + */ + mg_no_col_re(ll_establish_ind); +} /* mg_col_re() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_decode_xid ++------------------------------------------------------------------------------ +| Description : Implementation dependent. +| The entity number +| Works only for algorithm types 0 +| (V42 for data and VanJacobson for header). +| This procedure reads the given xid block (in form of an sdu) +| and writes the fields to the given xid_block variable, if +| compression fields for algorithms 0 (V42 or VanJacobson) are +| given. +| If the parsed sdu starts a negotiation then the p bit will be +| set to 1 and the "algorithm type" field will be included. If +| the parsed sdu ends a negotiation then the p bit will be set +| to 0 and the "algorithm type" field will not be included. +| In this case it will be checked if the "entity number" field +| corresponds with the entity number set in req_xid_block. +| +| Note: This procedure only re-formats the xid_block. The content +| of the xid_block are not checked. This will be done in a later +| procedure on the basis of the xid_block filled in here. +| The only error possibly detected is returned, if the byte format +| of the given xid block sdu is not correct: MG_XID_BAD_FORMAT. +| Then parameter type 1 list is read. If a data comp field has +| an algorithm of type 0 (V42bis) then its values are written +| to the given xid_block. If the algorithm is not 0 (V42bis) then +| the entity is rejected. +| The same for parameter type 2, here only algorithm type 0 +| (VanJacobson) is written to the xid_block. +| Note: it is assumed here that the parameters come in line 0, 1, 2. +| If that will no be the case, the parsing will have to modified +| slightly. +| If an unknown parameter type (not 0, 1, 2) is detected, an +| MG_XID_BAD_FORMAT is returned. +| +| Parameters : the sdu to be parsed, is negotiation started here?, the +| destination T_XID_BLOCK, a return value that should be MG_XID_OK +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_decode_xid (T_sdu* sdu, + T_XID_BLOCK* xid_block, + UBYTE* ret, + UBYTE sapi) +{ + +#define CHECK_XID_BUFFER_LEN if (index + field_index >= ((sdu->l_buf) >> 3)) return + UBYTE sapi_index = 0; + /* + * Index for the whole sdu. + */ + USHORT index = sdu->o_buf / 8; + /* + * Sub index used in compression fields. + */ + USHORT field_index = 0; + /* + * This is the index where the parameter 2 for header compression begins. + */ + USHORT beginning_of_header_comp = 0; + /* + * Length of complete parameter blocks of type 1 or 2. + */ + USHORT length = 0; + /* + * Was decoding successful? + */ + BOOL ok = FALSE; + + TRACE_FUNCTION( "mg_decode_xid" ); + + /* + * Reset xid_block. + */ + sndcp_reset_xid_block(xid_block); + + sndcp_get_sapi_index(sapi, &sapi_index); + *ret = MG_XID_BAD_FORMAT; + + /* + * If end is reached, return with ok. + */ + if (sdu->l_buf == 0) { + *ret = MG_XID_OK; + return; + } + /* + * If parameter type 0 is included, store it. + */ + CHECK_XID_BUFFER_LEN; + if (sdu->buf[index] == SNDCP_XID_PARAM_TYPE_0) { + index++; + xid_block->version_set = TRUE; + /* + * Length should be SNDCP_XID_0_LEN, but is not checked. + */ + CHECK_XID_BUFFER_LEN; + length = sdu->buf[index]; + + index++; + /* + * Set the version in xid_block. + */ + CHECK_XID_BUFFER_LEN; + xid_block->version = sdu->buf[index]; + index+= length; + } + + /* + * If end is reached, return with ok. + */ + if (index == ((sdu->l_buf) >> 3)) { + *ret = MG_XID_OK; + return; + } + + /* + * If parameter type 1 is included, store it. + */ + if (sdu->buf[index] == SNDCP_XID_PARAM_TYPE_1) { + /* + * Length of all data compression parameters. + */ + index++; + CHECK_XID_BUFFER_LEN; + length = sdu->buf[index]; + /* + * This is the index where the parameter 2 infos for header compression + * begin. + */ + beginning_of_header_comp = index + length + 1; + + /* + * Search data compression parameters for algorithm type 1. + */ + while (length > 0) { + /* + * Index is now on p-bit-entity-octet for one field. + * If the p bit is set to 1 then we read the algorithm + * type and drop the field if it is not SNDCP_XID_V42. + * If the p bit is not set to 1 then we read the + * entity number and drop the field if it is not the entity number + * proposed in req_xid_block. + */ + + /* + * Set field_index to beginning of next data compression field. + */ + field_index++; + + CHECK_XID_BUFFER_LEN; + if ((sdu->buf[index + field_index] & 0x80) > 0) { + /* + * P bit set to 1. Check algorithm type and drop field if + * type is not known. + * Set ntt. + */ + xid_block->v42.ntt = sdu->buf[index + field_index] & 0x1F; + /* + * Set field_index to algorithm type. + */ + field_index ++; + CHECK_XID_BUFFER_LEN; + if ((sdu->buf[index + field_index] & 0xf) != SNDCP_XID_V42) { + /* + * Wrong algorithm type. Add the ntt to list of rejected ones. + */ + mg_set_sapi_dntt_rej(sapi, xid_block->v42.ntt, TRUE); + /* + * Set index to length octet. + */ + field_index ++; + /* + * Set index to next field. Check field length. + */ + CHECK_XID_BUFFER_LEN; + field_index += sdu->buf[index + field_index]; + if (field_index > length) { + /* + * Field is too long, bad format. + */ + return; + } + if (field_index == length) { + /* + * Field is completed but entity number has not been found because in + * that case the loop would have been left with break; + */ + xid_block->v42.is_set = FALSE; + break; + } + continue; + } else { + /* + * Correct algorithm type. + */ + if (xid_block->v42.is_set == FALSE) { + /* + * This is the first occurrence. + */ + xid_block->v42.is_set = TRUE; + xid_block->v42.p_bit = 1; + + + mg_decode_v42(sdu, + &index, + &field_index, + xid_block, + &ok, + SNDCP_P_BIT_1); + if (!ok) { + /* + * Decoding was not successful. + */ + return; + } + } else { + /* + * There has been an occurrence of this algorithm. + */ + /* + * Set index to length octet. + */ + field_index ++; + /* + * Set index to next field. Check field length. + */ + CHECK_XID_BUFFER_LEN; + field_index += sdu->buf[index + field_index]; + if (field_index > length) { + /* + * Field is too long, bad format. + */ + return; + } + if (field_index == length) { + /* + * Field is completed. + */ + break; + } + + } + /* + * If all data parameters are read, go ahead for header ones. + */ + if (field_index == length) { + break; + } + } + } else { + /* + * P bit set to 0. + * Check entity number and drop field if it is not the proposed one or + * V42 has not been proposed yet. + * field_index is already on p-bit-entity-octet. + */ + CHECK_XID_BUFFER_LEN; + if (((sdu->buf[index + field_index] & 0x1f) != + xid_block->v42.ntt) && xid_block->v42.is_set) { + /* + * Wrong entity number. + */ + /* + * Set field_index to length octet. + */ + field_index ++; + /* + * Set index to next field. Check field length. + */ + CHECK_XID_BUFFER_LEN; + field_index += sdu->buf[index + field_index]; + if (field_index > length) { + /* + * Field is too long, bad format. + */ + return; + } + if (field_index == length) { + /* + * Field is completed but entity number has not been found because in + * that case the loop would have been left with break; + */ + xid_block->v42.is_set = FALSE; + break; + } + continue; + } else { + /* + * The entity number of this field equals the entity number in + * ththat is already in the xid block or there is no entity in + * the xid block yet. + */ + xid_block->v42.is_set = TRUE; + xid_block->v42.p_bit = 0; + xid_block->v42.ntt = + (sdu->buf[index + field_index] & 0x1f); + + mg_decode_v42(sdu, + &index, + &field_index, + xid_block, + &ok, + SNDCP_P_BIT_0); + if (!ok) { + /* + * Decoding was not successful. + */ + return; + } + + /* + * If all data parameters are read, go ahead for header ones. + */ + if (field_index == length) { + break; + } + } + } /* p bit set to 0 */ + } /* while */ + field_index = 0; + index = beginning_of_header_comp; + } + + /* + * Now comes the header compression parameter type 2. + * Is it omitted? + */ + if (index == ((sdu->l_buf) >> 3)) { + *ret = MG_XID_OK; + return; + } + + /* + * Parameter type should be SNDCP_XID_PARAM_TYPE_2. + */ + CHECK_XID_BUFFER_LEN; + if (sdu->buf[index] != SNDCP_XID_PARAM_TYPE_2) { + return; + } + /* + * Length of all header compression parameters. + */ + index++; + CHECK_XID_BUFFER_LEN; + length = sdu->buf[index]; + + + /* + * Search header compression parameters for algorithm type 2. + */ + while (length > 0) { + /* + * Index is now on p-bit-entity-octet for one field. + * If the p bit is set to 1 then we read the algorithm + * type and drop the field if it is not SNDCP_XID_VJ. + * If the p bit is not set to 1 then we read the + * entity number and drop the field if it is not the entity number + * proposed in req_xid_block. + */ + /* + * Set field_index to beginning of next header compression field. + */ + field_index++; + CHECK_XID_BUFFER_LEN; + if ((sdu->buf[index + field_index] & 0x80) > 0) { + UBYTE ntt = 0; + /* + * P bit set to 1. Check algorithm type and drop field if + * type is not known. + * Set ntt. + */ + ntt = sdu->buf[index + field_index] & 0x1F; + + /* + * Set index to algorithm type. + */ + field_index ++; + CHECK_XID_BUFFER_LEN; + if (((sdu->buf[index + field_index] & 0xf) != SNDCP_XID_VJ) + || + ((sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) && + (xid_block->vj.is_set == FALSE) && + (ntt != sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt) + ) + ) { + /* + * Wrong algorithm type or + * vj comp is currently used and proposed ntt is not equal to currently + * used one. + * Add ntt to list of rejected ones. + */ + mg_set_sapi_pntt_rej(sapi, ntt, TRUE); + /* + * Set index to length octet. + */ + field_index ++; + /* + * Set index to next field. Check field length. + */ + CHECK_XID_BUFFER_LEN; + field_index += sdu->buf[index + field_index]; + if (field_index > length) { + /* + * Field is too long, bad format. + */ + return; + } + if (field_index == length) { + /* + * Field is completed but entity number has not been found because in + * that case the loop would have been left with break; + */ + xid_block->vj.is_set = FALSE; + break; + } + continue; + } + /* + * Correct algorithm type and vj requested. + */ + /* + * If no vj comp is currently used and xid_block.vj is not set yet, take + * the proposed one. + * Also if vj comp is currently used and xid block is not yet set and + * proposed ntt is equal to currently used one. + */ + if (((! sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) && + (xid_block->vj.is_set == FALSE)) + || + ((sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) && + (xid_block->vj.is_set == FALSE) && + (ntt == sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt))) { + + xid_block->vj.is_set = TRUE; + xid_block->vj.p_bit = 1; + xid_block->vj.ntt = ntt; + + mg_decode_vj (sdu, + &index, + &field_index, + xid_block, + &ok, + SNDCP_P_BIT_1); + if (!ok) { + /* + * Decoding was not successful. + */ + return; + } + /* + * If all header parameters are read, go ahead for header ones. + */ + if (field_index == length) { + break; + } + continue; + } + /* + * This is not the first occurrence. Ignore. + */ + /* + * Set index to length octet. + */ + field_index ++; + /* + * Set index to next field. Check field length. + */ + CHECK_XID_BUFFER_LEN; + field_index += sdu->buf[index + field_index]; + if (field_index > length) { + /* + * Field is too long, bad format. + */ + return; + } + if (field_index == length) { + /* + * Field is completed. + */ + break; + } + + } else { + /* + * P bit set to 0. + * Check entity number and drop field if it is not the proposed one or + * VJ has not been proposed yet. + * Index is already on p-bit-entity-octet. + */ + CHECK_XID_BUFFER_LEN; + if (((sdu->buf[index + field_index] & 0x1f) != + xid_block->vj.ntt) && xid_block->vj.is_set) { + /* + * Wrong entity number. + * Set index to length octet. + */ + field_index ++; + /* + * Set index to next field. Check field length. + */ + CHECK_XID_BUFFER_LEN; + field_index += sdu->buf[index + field_index]; + if (field_index > length) { + /* + * Field is too long, bad format. + */ + return; + } + if (field_index == length) { + /* + * Field is completed but entity number has not been found because in + * that case the loop would have been left with break; + */ + break; + } + continue; + } else { + /* + * The entity number of this field equals the entity number in + * that is already in the xid_block or there is no entity number + * in the block yet. + */ + xid_block->vj.is_set = TRUE; + xid_block->vj.p_bit = 0; + xid_block->vj.ntt = + (sdu->buf[index + field_index] & 0x1f); + + mg_decode_vj (sdu, + &index, + &field_index, + xid_block, + &ok, + SNDCP_P_BIT_0); + if (!ok) { + /* + * Decoding was not successful. + */ + return; + } + /* + * The one field with same entity number as in req_xid_block has been + * found and loop of data compression field may be left. + * If errors in not used fields are to be detected then we must continue here! + */ + /* + * If all header parameters are read, leave. + */ + if (field_index == length) { + break; + } + } + } + } /* while */ + /* + * It is not checked here whether the sdu is completely read. + */ + *ret = MG_XID_OK; + +} /* mg_decode_xid() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_dti_close ++------------------------------------------------------------------------------ +| Description : Closes DTI connection +| Parameters : nsapi ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_dti_close (UBYTE nsapi) +{ + +#ifdef _SNDCP_DTI_2_ + UBYTE interfac = SNDCP_INTERFACE_UNACK; +#ifndef SNDCP_UPM_INCLUDED + sndcp_get_nsapi_interface(nsapi, &interfac); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + dti_close(sndcp_data->hDTI, /* DTI_HANDLE *hDTI, */ + 0, /* U8 instance, */ + interfac, /* U8 interface, */ + nsapi, + NULL/* U8 channel); */ + ); +#else /*_SNDCP_DTI_2_*/ + UBYTE interfac = SNDCP_INTERFACE_UNACK; + + sndcp_get_nsapi_interface(nsapi, &interfac); + dti_close(sndcp_data->hDTI, /* DTI_HANDLE *hDTI, */ + 0, /* U8 instance, */ + interfac, /* U8 interface, */ + nsapi /* U8 channel); */ + + ); +#endif /*_SNDCP_DTI_2_*/ + + /* + * The following is done in any case since the callback will not be called. + */ + nu_connection_state(nsapi, FALSE); + + /*FIXME ! Added newly. To be verified.*/ +#ifdef SNDCP_UPM_INCLUDED + { + U32 linkid = 0; + PALLOC (sn_dti_cnf, SN_DTI_CNF); + sndcp_get_nsapi_linkid(nsapi, &linkid); + sn_dti_cnf->dti_linkid = linkid; + sn_dti_cnf->dti_conn = NAS_DISCONNECT_DTI; + PSEND(hCommMMI, sn_dti_cnf); + } +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ +} /* mg_dti_close() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_dti_open ++------------------------------------------------------------------------------ +| Description : Opens DTI connection +| Parameters : nsapi ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_dti_open (UBYTE nsapi) +{ +#ifdef _SNDCP_DTI_2_ + UBYTE* neighbor = NULL; + ULONG linkid = 0; +#ifndef SNDCP_UPM_INCLUDED + BOOL ack = FALSE; +#endif + U8 direction = DTI_CHANNEL_TO_LOWER_LAYER; + UBYTE interfac = SNDCP_INTERFACE_UNACK; + + sndcp_get_nsapi_linkid(nsapi, &linkid); + sndcp_get_nsapi_neighbor(nsapi, &neighbor); +#ifndef SNDCP_UPM_INCLUDED + sndcp_get_nsapi_ack(nsapi, &ack); +#endif + sndcp_get_nsapi_direction(nsapi, &direction); +#ifndef SNDCP_UPM_INCLUDED + if (ack) { + interfac = SNDCP_INTERFACE_ACK; + sndcp_set_nsapi_interface(nsapi, interfac); + } +#endif + + dti_open(sndcp_data->hDTI, /* DTI_HANDLE hDTI */ + 0, /* U8 instance */ + interfac, /* U8 interface */ + nsapi, /* U8 channel */ + 0, /* U8 queue_size */ + direction, /* U8 direction */ + DTI_QUEUE_WATERMARK, /* U8 link options */ + DTI_VERSION_10, /* U32 version */ + neighbor, /* U8 *neighbor_entity */ + linkid/* U32 link_id */ + ); +#else /*_SNDCP_DTI_2_*/ + UBYTE* neighbor = NULL; + ULONG linkid = 0; + BOOL ack = FALSE; + BOOL direction = HOME; + UBYTE interfac = SNDCP_INTERFACE_UNACK; + + sndcp_get_nsapi_linkid(nsapi, &linkid); + sndcp_get_nsapi_neighbor(nsapi, &neighbor); + sndcp_get_nsapi_ack(nsapi, &ack); + sndcp_get_nsapi_direction(nsapi, &direction); +#ifndef SNDCP_UPM_INCLUDED + if (ack) { + interfac = SNDCP_INTERFACE_ACK; + sndcp_set_nsapi_interface(nsapi, interfac); + } +#endif + + dti_open(sndcp_data->hDTI, /* DTI_HANDLE *hDTI */ + 0, /* U8 instance */ + interfac, /* U8 interface */ + nsapi, /* U8 channel */ + 0, /* U8 queue_size */ + direction, /* BOOL direction */ + FLOW_CNTRL_ENABLED, /* U8 comm_type */ + DTI_VERSION_10, /* U32 version */ + neighbor, /* U8 *neighbor_entity */ + linkid/* U32 link_id */ + ); + +#endif /*_SNDCP_DTI_2_*/ +} /* mg_dti_open() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_init ++------------------------------------------------------------------------------ +| Description : The function mg_init() .... +| +| Parameters : +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_init (void) +{ + + UBYTE sapi_index = 0; + UBYTE nsapi = 0; + TRACE_FUNCTION( "mg_init" ); + INIT_STATE(MG, MG_DEFAULT); + /* + * req_xid_block, cnf_xid_block, cur_xid_block not initialized. + */ + for (sapi_index = 0; sapi_index < SNDCP_NUMBER_OF_SAPIS; sapi_index++) { + + mg_reset_states_n_rej(sapi_index); + /* + * Init renegotiation counter and cur_xid_block with default values. + */ + sndcp_data->mg.renego[sapi_index] = 0; + + sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.cnf_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.ind_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.res_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.new_xid_block[sapi_index]); + + } + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + sndcp_reset_xid_block(&sndcp_data->mg.user_xid_block[nsapi]); + sndcp_data->mg.user_xid_block[nsapi].vj.s0_m_1 = 0; + sndcp_data->cur_pcomp[nsapi] = 0; + sndcp_data->cur_dcomp[nsapi] = 0; + sndcp_data->cur_seg_pos[nsapi] = 0; + sndcp_data->cur_pdu_ref[nsapi].ref_nsapi = 0; + sndcp_data->cur_pdu_ref[nsapi].ref_npdu_num = 0; + sndcp_data->cur_pdu_ref[nsapi].ref_seg_num = 0; + sndcp_data->big_head[nsapi] = FALSE; + } + + + sndcp_data->mg.mod_expects = MG_MOD_X_NONE; + sndcp_data->mg.waiting_nsapis = 0; + sndcp_data->mg.suspended_nsapis = 0; + +} /* mg_init() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_is_ack ++------------------------------------------------------------------------------ +| Description : This procedure takes the snsm_qos!rely +| information: +| +| 0 SNSM_RELCLASS_SUB Subscribed reliability class +| 1 SNSM_GTP_LLC_RLC_PROT Acknowledged GTP, LLC, and RLC; Protected data +| 2 SNSM_LLC_RLC_PROT Unacknowledged GTP; Acknowledged LLC and RLC, Protected data +| 3 SNSM_RLC_PROT Unacknowledged GTP and LLC; Acknowledged RLC, Protected data +| 4 SNSM_PROT Unacknowledged GTP, LLC, and RLC, Protected data +| 5 SNSM_NO_REL Unacknowledged GTP, LLC, and RLC, Unprotected data +| +| and sets "spec" to TRUE, "b" to TRUE in case of SNSM_GTP_LLC_RLC_PROT or +| SNSM_LLC_RLC_PROT, +| [should be, is not:["spec" to FALSE in case of SNSM_RELCLASS_SUB]] and "spec" +| to TRUE, "b" to FALSE else. +| +| Important note: in case of SNSM_RELCLASS_SUB "spec" will actually be set to +| to TRUE, "b" to FALSE, to be robust in case of downlink protocol error! +| +| Parameters : snsm_qos +| BOOL* spec (FALSE for REL_CLASS_SUB), +| BOOL* b) +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_is_ack (T_snsm_qos snsm_qos, + BOOL* spec, + BOOL* b) +{ + TRACE_FUNCTION( "mg_is_ack" ); + + +#ifdef SNDCP_UPM_INCLUDED + if (snsm_qos.relclass == PS_GTP_LLC_RLC_PROT || + snsm_qos.relclass == PS_LLC_RLC_PROT) { +#else + if (snsm_qos.relclass == SNSM_GTP_LLC_RLC_PROT || + snsm_qos.relclass == SNSM_LLC_RLC_PROT) { +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + *spec = TRUE; + *b = TRUE; + /* } else if (snsm_qos.relclass == SNSM_RELCLASS_SUB) { + *spec = FALSE; + */ + } else { + *spec = TRUE; + *b = FALSE; + } + + +} /* mg_is_ack() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_no_col_no_re ++------------------------------------------------------------------------------ +| Description : The function mg_no_col_no_re represents the SDL label +| NO_COL_NO_RE: an LL_ESTABLISH_IND has been received, we do not +| have a collision situation like given in [GSM 4.65, 6.2.1.4], +| we do not have a re-establishment situation. +| +| Parameters : the received LL_ESTABLISH_IND +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_no_col_no_re (T_LL_ESTABLISH_IND* ll_establish_ind) +{ + UBYTE dec_ret = 0; + UBYTE check_ret = 0; + UBYTE sapi_index = 0; + U8 nsapi = 0; + TRACE_FUNCTION( "mg_no_col_no_re" ); + sndcp_get_sapi_index(ll_establish_ind->sapi, &sapi_index); + + TRACE_EVENT_P3("l3_valid?: %d, N201_I: %d, N201_U: %d", + ll_establish_ind->xid_valid, ll_establish_ind->n201_i, + ll_establish_ind->n201_u); + /* + * Set N201 values in uplink services. + */ + sig_mg_su_n201(ll_establish_ind->sapi, ll_establish_ind->n201_u); + sig_mg_sua_n201(ll_establish_ind->sapi, ll_establish_ind->n201_i); + /* + * If SNDCP XID block is not valid, we are ready. + */ + if (ll_establish_ind->xid_valid == LL_XID_INVALID) { + + PALLOC_SDU (ll_establish_res, LL_ESTABLISH_RES, 0); + /* + * Set sapi in ll_establish_res. + */ + ll_establish_res->sapi = ll_establish_ind->sapi; + ll_establish_res->xid_valid = ll_establish_ind->xid_valid; + ll_establish_res->sdu.l_buf = 0; + + /* + * Mark the affected sapi as MG_XID_IDLE. + */ + sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST); + + sig_mg_sda_end_est(ll_establish_res->sapi, TRUE); + + sndcp_set_sapi_ack(ll_establish_res->sapi, TRUE); + + PSEND(hCommLLC, ll_establish_res); + + /* + * All nsapis at this sapi that use ack mode, enter recovery state. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { + UBYTE sapi = 0; + BOOL ack = FALSE; + + sndcp_get_nsapi_sapi(nsapi, &sapi); + sndcp_get_nsapi_ack(nsapi, &ack); + if (ack && (sapi == ll_establish_ind->sapi)) { + sig_mg_cia_delete_npdus(nsapi); + sig_mg_sua_delete_pdus(nsapi, sapi, FALSE); + sig_mg_nu_recover(nsapi); + sig_mg_nd_recover(nsapi); + } + } /* for all nsapis */ + + return; + } + /* + * SNDCP XID block is valid and checked now. + */ + mg_decode_xid(&(ll_establish_ind->sdu), + &(sndcp_data->mg.ind_xid_block[sapi_index]), + &dec_ret, + ll_establish_ind->sapi); + if (dec_ret == MG_XID_OK) { + mg_check_ind_xid(&check_ret, ll_establish_ind->sapi); + if (check_ret == MG_XID_OK) { + /* + * Label MG_IND_OK_EST + */ + USHORT res_sdu_bit_len = 0; + UBYTE ntt = 0; + BOOL v42_rej = FALSE; + BOOL vj_rej = FALSE; + + mg_set_res_cur_xid_block(ll_establish_ind->sapi, &res_sdu_bit_len); + /* + * Add the extra space for ntts with nsapis == 0. + */ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_dntt_rej(ll_establish_ind->sapi, ntt, &rej); + if (rej) { + /* + * length of ntt octet and nsapis. + */ + res_sdu_bit_len += 32; + v42_rej = TRUE; + } + mg_get_sapi_pntt_rej(ll_establish_ind->sapi, ntt, &rej); + if (rej) { + /* + * length of ntt octet and nsapis. + */ + res_sdu_bit_len += 32; + vj_rej = TRUE; + } + } + if (! sndcp_data->mg.res_xid_block[sapi_index].v42.is_set && + v42_rej) { + /* + * Add length of parameter type and length. + */ + res_sdu_bit_len += 16; + } + if (! sndcp_data->mg.res_xid_block[sapi_index].vj.is_set && + vj_rej) { + /* + * Add length of parameter type and length. + */ + res_sdu_bit_len += 16; + } + + /* + * SDL Label MG_CNF_OK_ACK + */ + + { + + USHORT sapi_state = MG_IDLE; + + PALLOC_SDU (ll_establish_res, LL_ESTABLISH_RES, res_sdu_bit_len); + /* + * Set sapi in ll_establish_res. + */ + ll_establish_res->sapi = ll_establish_ind->sapi; + ll_establish_res->xid_valid = ll_establish_ind->xid_valid; + /* + * Write res_xid_block struct to sdu byte buffer. Implementation dep.. + */ + mg_set_res_xid_params(&ll_establish_res->sdu, ll_establish_res->sapi); + + /* + * Mark the affected nsapis and sapi as MG_XID_IDLE. + */ + sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_XID); + sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST); + + sig_mg_sda_end_est(ll_establish_res->sapi, TRUE); + + sndcp_set_sapi_ack(ll_establish_res->sapi, TRUE); + + PSEND(hCommLLC, ll_establish_res); + + /* + * All nsapis at this sapi that use ack mode, enter recovery state. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { + UBYTE sapi = 0; + BOOL ack = FALSE; + + sndcp_get_nsapi_sapi(nsapi, &sapi); + sndcp_get_nsapi_ack(nsapi, &ack); + if (ack && (sapi == ll_establish_ind->sapi)) { + sig_mg_cia_delete_npdus(nsapi); + sig_mg_sua_delete_pdus(nsapi, sapi, FALSE); + sig_mg_nu_recover(nsapi); + sig_mg_nd_recover(nsapi); + } + } /* for all nsapis */ + + /* + * Reset nsapis or ntts that were assigned, but are not any more. + */ + mg_clean_xid(ll_establish_ind->sapi); + /* + * If there was a collision and xid has not been negotiated + * sufficiently. + */ + mg_resend_xid_if_nec(ll_establish_ind->sapi); + + /* + * If nsapi has been in state xid_pending or est_pending then + * an snsm_activate_res will be sent now.!!! + */ + mg_respond_if_nec(ll_establish_ind->sapi); + sndcp_get_sapi_state(ll_establish_ind->sapi, &sapi_state); + if ((sapi_state & MG_XID) == 0) { + mg_xid_cnf_ok_res(ll_establish_ind->sapi); + } + + + } + + } else { + /* + * not (check_ret == MG_IND_XID_OK) + */ + /* + * Label MG_CHECK_FAIL_EST + */ + USHORT res_sdu_bit_len = 0; + UBYTE ntt = 0; + BOOL v42_rej = FALSE; + BOOL vj_rej = FALSE; + /* + * Add the extra space for ntts with nsapis == 0. + */ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_dntt_rej(ll_establish_ind->sapi, ntt, &rej); + if (rej) { + /* + * length of ntt octet and nsapis. + */ + res_sdu_bit_len += 32; + v42_rej = TRUE; + } + mg_get_sapi_pntt_rej(ll_establish_ind->sapi, ntt, &rej); + if (rej) { + /* + * length of ntt octet and nsapis. + */ + res_sdu_bit_len += 32; + vj_rej = TRUE; + } + } + if (v42_rej) { + /* + * Add length of parameter type and length. + */ + res_sdu_bit_len += 16; + } + if (vj_rej) { + /* + * Add length of parameter type and length. + */ + res_sdu_bit_len += 16; + } + /* + * Allocate response and send it. + */ + { + + PALLOC_SDU (ll_establish_res, LL_ESTABLISH_RES, res_sdu_bit_len); + /* + * Reset res_xid_block, ind_xid_block. + */ + sndcp_reset_xid_block(&sndcp_data->mg.res_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.ind_xid_block[sapi_index]); + /* + * Set sapi in ll_establish_res. + */ + ll_establish_res->sapi = ll_establish_ind->sapi; + ll_establish_res->xid_valid = ll_establish_ind->xid_valid; + /* + * Write res_xid_block struct to sdu byte buffer. Implementation dep.. + */ + mg_set_res_xid_params(&ll_establish_res->sdu, ll_establish_ind->sapi); + /* + * Modify the affected sapi state. + */ + sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_XID); + sndcp_unset_sapi_state(ll_establish_ind->sapi, MG_EST); + + sndcp_set_sapi_ack(ll_establish_res->sapi, TRUE); + /* + * Send the XID block to LLC. + */ + PSEND(hCommLLC, ll_establish_res); + /* + * All nsapis at this sapi that use ack mode, enter recovery state. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi ++) { + UBYTE sapi = 0; + BOOL ack = FALSE; + + sndcp_get_nsapi_sapi(nsapi, &sapi); + sndcp_get_nsapi_ack(nsapi, &ack); + if (ack && (sapi == ll_establish_ind->sapi)) { + sig_mg_cia_delete_npdus(nsapi); + sig_mg_sua_delete_pdus(nsapi, sapi, FALSE); + sig_mg_nu_recover(nsapi); + sig_mg_nd_recover(nsapi); + } + } /* for all nsapis */ + + } + + /* + * Reset nsapis or ntts that were assigned before + * but are not anymore. + */ + sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); + mg_clean_xid(ll_establish_ind->sapi); + /* + * Allocate status req and send it (label MG_SEND_STATUS_REQ_EST). + */ + { +#ifdef SNDCP_UPM_INCLUDED + PALLOC (snsm_status_req, SN_STATUS_IND); +#else + PALLOC (snsm_status_req, SNSM_STATUS_REQ); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + snsm_status_req->sapi = ll_establish_ind->sapi; +#ifdef SNDCP_UPM_INCLUDED + snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp; + snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID; + PSEND (hCommUPM, snsm_status_req); +#else + snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID; + PSEND (hCommSM, snsm_status_req); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + } + } + } else { /* not if (dec_ret == MG_XID_OK_EST) */ + /* + * Reset nsapis or ntts that were assigned before + * but are not anymore. + */ + sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); + mg_clean_xid(ll_establish_ind->sapi); + /* + * Decoding of ll_establish_ind failed (label MG_SEND_STATUS_REQ). + * Allocate status req and send it. + */ + + { +#ifdef SNDCP_UPM_INCLUDED + PALLOC (snsm_status_req, SN_STATUS_IND); + snsm_status_req->sapi = ll_establish_ind->sapi; + snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp; + snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID; + PSEND (hCommUPM, snsm_status_req); +#else + PALLOC (snsm_status_req, SNSM_STATUS_REQ); + snsm_status_req->sapi = ll_establish_ind->sapi; + snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID; + PSEND (hCommSM, snsm_status_req); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + } + + } + +} /* mg_no_col_no_re() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_no_col_re ++------------------------------------------------------------------------------ +| Description : The function mg_no_col_no_re represents the SDL label +| NO_COL_RE: an LL_ESTABLISH_IND has been received, we do not +| have a collision situation like given in [GSM 4.65, 6.2.1.4], +| we do have a re-establishment situation. +| +| Parameters : the received LL_ESTABLISH_IND +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_no_col_re (T_LL_ESTABLISH_IND* ll_establish_ind) +{ + + TRACE_FUNCTION( "mg_no_col_re" ); + /* + * Do the same things as without collision. + */ + mg_no_col_no_re (ll_establish_ind); + +} /* mg_no_col_re() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_re_negotiate ++------------------------------------------------------------------------------ +| Description : The answer to the sent LL_XID_REQ has been invalid +| (bad format or content). If service var renego < MG_MAX_RENEGO then +| same LL_XID_REQ is resent, else SNSM_STATUS_REQ is sent. +| This function represents the SDl label MG_RE_NEGOTIATE. +| +| Parameters : the affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_re_negotiate (UBYTE sapi) { + UBYTE sapi_index = 0; + + TRACE_FUNCTION( "mg_re_negotiate" ); + sndcp_get_sapi_index(sapi, &sapi_index); + + /* + * If number of re-negotiations is reached, deactivate all pdp contexts for + * the affected sapi. + */ + if (sndcp_data->mg.renego[sapi_index] < MG_MAX_RENEGO) { + PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN); + /* + * Set sapi in ll_xid_req. + */ + ll_xid_req->sapi = sapi; + + /* + * Fill the XID block. Implementation dependent. + */ + mg_set_xid_params(ll_xid_req->sapi, + &ll_xid_req->sdu, + sndcp_data->mg.req_xid_block[sapi_index]); + /* + * Send the XID block to LLC. + */ + + sndcp_unset_sapi_state(sapi, MG_XID_NEC); + sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID); + PSEND(hCommLLC, ll_xid_req); + /* + * Increment renegotiation counter. + */ + sndcp_data->mg.renego[sapi_index]++; + } else { + +#ifdef SNDCP_UPM_INCLUDED + PALLOC (snsm_status_req, SN_STATUS_IND); +#else + PALLOC (snsm_status_req, SNSM_STATUS_REQ); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + /* + * Set all ntts and dcomp/pcomp states to "unassigned". + */ + mg_reset_states_n_rej(sapi_index); + /* + * Set prim parameters. + */ +#ifdef SNDCP_UPM_INCLUDED + snsm_status_req->sapi = sapi; + snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp; + snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_INVALID_XID; +#else + snsm_status_req->sapi = sapi; + snsm_status_req->status_cause = SNSM_RELCS_INVALID_XID; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + + sndcp_data->mg.renego[sapi_index] = 0; + /* + * Reset cur_xid_block. + */ + sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); + /* + * Reset all compression entities for the affected sapi. + */ + mg_clean_xid(sapi); + +#ifdef SNDCP_UPM_INCLUDED + PSEND (hCommUPM, snsm_status_req); +#else + PSEND (hCommSM, snsm_status_req); +#endif + } + + +} /* mg_re_negotiate() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_re_negotiate_ack ++------------------------------------------------------------------------------ +| Description : The answer to the sent LL_ESTABLISH_REQ has been invalid +| (bad format or content). If service var renego < MG_MAX_RENEGO then +| same LL_ESTABLISH_REQ is resent, else SNSM_STATUS_REQ is sent. +| This function represents the SDl label MG_RE_NEGOTIATE_ACK. +| +| Parameters : the affected sapi, cause +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_re_negotiate_ack (UBYTE sapi, U16 cause) { + UBYTE sapi_index = 0; + + TRACE_FUNCTION( "mg_re_negotiate_ack" ); + sndcp_get_sapi_index(sapi, &sapi_index); + + /* + * If number of re-negotiations is reached, deactivate all pdp contexts for + * the affected sapi. + */ + if (sndcp_data->mg.renego[sapi_index] < MG_MAX_RENEGO) { + PALLOC_SDU(ll_establish_req, + LL_ESTABLISH_REQ, + SNDCP_XID_BLOCK_BIT_LEN); + /* + * Set sapi in ll_establish_req. + */ + ll_establish_req->sapi = sapi; + + /* + * Fill the XID block. Implementation dependent. + */ + mg_set_xid_params(ll_establish_req->sapi, + &ll_establish_req->sdu, + sndcp_data->mg.req_xid_block[sapi_index]); + /* + * Send the XID block to LLC, with establish request. + */ + sig_mg_sda_start_est(sapi); + + PSEND(hCommLLC, ll_establish_req); + /* + * Increment renegotiation counter. + */ + sndcp_data->mg.renego[sapi_index]++; + } else { + +#ifdef SNDCP_UPM_INCLUDED + PALLOC (snsm_status_req, SN_STATUS_IND); +#else + PALLOC (snsm_status_req, SNSM_STATUS_REQ); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + /* + * Service sda may now leave state SDA_ESTABLISH_REQUESTED. + */ + sig_mg_sda_end_est(sapi, FALSE); + /* + * Set all ntts and dcomp/pcomp states to "unassigned". + */ + mg_reset_states_n_rej(sapi_index); + /* + * Set prim parameters. + */ +#ifdef SNDCP_UPM_INCLUDED + snsm_status_req->sapi = sapi; + snsm_status_req->ps_cause.ctrl_value = CAUSE_is_from_sndcp; +#else + snsm_status_req->sapi = sapi; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + + sndcp_data->mg.renego[sapi_index] = 0; + /* + * Reset cur_xid_block. + */ + sndcp_reset_xid_block(&sndcp_data->mg.cur_xid_block[sapi_index]); + sndcp_reset_xid_block(&sndcp_data->mg.req_xid_block[sapi_index]); + /* + * Reset all compression entities for the affected sapi. + */ + mg_clean_xid(sapi); + /* + * The renegotiation is failed. If the cause is NO_PEER_RESPONSE + * or DM_RECEIVED, set it to RELCS_NORMAL to make SM deactivate + * PDP context. Otherwise the cause is forwarded to SM and the SM + * will deactivate PDP context depending on cause. + */ +#ifdef SNDCP_UPM_INCLUDED + if((cause == CAUSE_SN_NO_PEER_RESPONSE) || + (cause == CAUSE_SN_DM_RECEIVED) ){ + snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_NORMAL_RELEASE; +#else /* SNDCP_UPM_INCLUDED */ +#ifdef _SNDCP_DTI_2_ + if((cause == LL_RELCS_NO_PEER_RES) || + (cause == LL_RELCS_DM_RECEIVED) ){ + snsm_status_req->ps_cause.value.sn_cause = LL_RELCS_NORMAL; +#else + if((cause == CAUSE_SN_NO_PEER_RESPONSE) || + (cause == CAUSE_SN_DM_RECEIVED) ){ + snsm_status_req->ps_cause.value.sn_cause = CAUSE_SN_NORMAL_RELEASE; +#endif +#endif /* SNDCP_UPM_INCLUDED */ + sig_mg_su_resume(sapi); + sig_mg_sua_resume(sapi); + mg_resume_affected_nus(sapi); + sndcp_unset_sapi_state (sapi, MG_EST); + } else { +#ifdef SNDCP_UPM_INCLUDED + snsm_status_req->ps_cause.value.sn_cause = cause; +#else + snsm_status_req->status_cause = cause; +#endif + } + +#ifdef SNDCP_UPM_INCLUDED + PSEND (hCommUPM, snsm_status_req); +#else + PSEND (hCommSM, snsm_status_req); +#endif + + } + +} /* mg_re_negotiate_ack() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_resend_xid_if_nec ++------------------------------------------------------------------------------ +| Description : This procedure will be called after reception and computation +| of an LL_XID_IND or LL_ESTABLISH_IND in case of a collision +| or after receiving LL_XID_CNF or LL_ESTABLISH_CNF and does the +| following: +| (GSM 04.65 version 6.5.1 Release 1997), 6.2.1.4: +| If the +| LL-ESTABLISH.request or LL-XID.request contains one or more XID parameters, +| or one or more compression fields +| in an XID parameter, or one or more parameters in a compression field, +| that are not negotiated as part of the collision +| resolution, then negotiation of these XID parameters shall be performed at +| the earliest opportunity after conclusion of +| the collision resolution. +| +| Parameters : Affected sapi, out: was LL_XID_REQ sent? +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_resend_xid_if_nec (UBYTE sapi) { + UBYTE sapi_index = 0; + BOOL resend_necessary = FALSE; + USHORT sapi_state = MG_IDLE; + T_XID_BLOCK* req_xid_block = NULL; + T_XID_BLOCK* cur_xid_block = NULL; + T_XID_BLOCK* new_xid_block = NULL; + + TRACE_FUNCTION( "mg_resend_xid_if_nec" ); + + sndcp_get_sapi_index(sapi, &sapi_index); + req_xid_block = &sndcp_data->mg.req_xid_block[sapi_index]; + cur_xid_block = &sndcp_data->mg.cur_xid_block[sapi_index]; + new_xid_block = &sndcp_data->mg.new_xid_block[sapi_index]; + + /* + * Data compression. + */ + /* + * If a context is deactivated, maybe compressors must be switched off. + */ + if (cur_xid_block->v42.is_set) { + USHORT nsapis = cur_xid_block->v42.nsapis; + UBYTE nsapi = 0; + + /* + * XID renegotiation will only be necessary if one of the nsapis + * that are requested to use the data compression is in state + * MG_DEACT. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & nsapis) > 0) { + USHORT state = MG_IDLE; + sndcp_get_nsapi_state(nsapi, &state); + if ((state & MG_DEACT) > 0) { + UBYTE dntt = cur_xid_block->v42.ntt; + resend_necessary = TRUE; + mg_set_sapi_dntt_rej(sapi, dntt, TRUE); + } + } + } + } + + if (req_xid_block->v42.is_set && ! cur_xid_block->v42.is_set) { + UBYTE sapi_index_local = 0; + BOOL used = FALSE; + /* + * If one instance of v42 is used at a different sapi, + * we may not use another one here. + */ + for (sapi_index_local = 0; + sapi_index_local < SNDCP_NUMBER_OF_SAPIS; + sapi_index_local++) { + + if (sndcp_data->mg.cur_xid_block[sapi_index_local].v42.is_set) { + used = TRUE; + } + } + if (! used) { + USHORT nsapis = req_xid_block->v42.nsapis; + UBYTE nsapi = 0; + + /* + * XID renegotiation will only be necessary if one of the nsapis + * that are requested to use the data compression are not all in state + * MG_DEACT. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & nsapis) > 0) { + USHORT state = MG_IDLE; + sndcp_get_nsapi_state(nsapi, &state); + if ((state & MG_DEACT) == 0) { + resend_necessary = TRUE; + } + } + } + + } + } + /* + * Header compression. + */ + /* + * If a context is deactivated, maybe compressors must be switched off. + */ + if (cur_xid_block->vj.is_set) { + USHORT nsapis = cur_xid_block->vj.nsapis; + UBYTE nsapi = 0; + + /* + * XID renegotiation will only be necessary if one of the nsapis + * that are requested to use the header compression is in state + * MG_DEACT. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & nsapis) > 0) { + USHORT state = MG_IDLE; + sndcp_get_nsapi_state(nsapi, &state); + if ((state & MG_DEACT) > 0) { + UBYTE pntt = cur_xid_block->vj.ntt; + resend_necessary = TRUE; + mg_set_sapi_pntt_rej(sapi, pntt, TRUE); + } + } + } + + } + /* + * If a compressor is requested and not yet negotiated it must be requested + * now. + */ + if (req_xid_block->vj.is_set && !cur_xid_block->vj.is_set) { + USHORT nsapis = req_xid_block->vj.nsapis; + UBYTE nsapi = 0; + + req_xid_block->vj.p_bit = 1; + + /* + * XID renegotiation will only be necessary if the affected nsapis + * is not currently being deactivated. + */ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & nsapis) > 0) { + USHORT state = MG_IDLE; + sndcp_get_nsapi_state(nsapi, &state); + if ((state & MG_DEACT) == 0) { + resend_necessary = TRUE; + } + } + } + + } + + /* + * If in the meantime more compression has been requested, + * or compressors must be deactivated, + * re-negotiate. + */ + if (new_xid_block->v42.is_set) { + if ((! req_xid_block->v42.is_set) || + (req_xid_block->v42.is_set && + (new_xid_block->v42.nsapis != req_xid_block->v42.nsapis))) { + + *req_xid_block = *new_xid_block; + resend_necessary = TRUE; + } + } + + /* + * If in the meantime more compression has been requested, + * or compressors must be deactivated, + * re-negotiate. + */ + if (new_xid_block->vj.is_set) { + if ((! req_xid_block->vj.is_set) || + (req_xid_block->vj.is_set && + (new_xid_block->vj.nsapis != req_xid_block->vj.nsapis))) { + + *req_xid_block = *new_xid_block; + resend_necessary = TRUE; + } + } + + + sndcp_get_sapi_state(sapi, &sapi_state); + /* + * If re-negotiation is necessary but not possible because MG_REL or + * MG_XID, set MG_XID_NEC. + */ + if (resend_necessary + && + ((sapi_state & (MG_REL + MG_XID)) > 0)) + { + sndcp_set_sapi_state(sapi, MG_XID_NEC); + mg_set_cur_xid_block(sapi); + return; + } + + + /* + * If renegotiation of XID is necessary, send LL_XID_REQ. + */ + if (! resend_necessary) { +// mg_set_cur_xid_block(sapi); + return; + } + + + /* + * Now req_xid_block is in good shape. Send it. + */ + { + PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN); + /* + * Set sapi in ll_xid_req. + */ + ll_xid_req->sapi = sapi; + /* + * Write data from snsm_activate_ind to service variable req_xid_block. + */ + mg_set_ntt_comp(sapi); + /* + * Fill the XID block. Implementation dependent. + */ + mg_set_xid_params(ll_xid_req->sapi, + &ll_xid_req->sdu, + sndcp_data->mg.req_xid_block[sapi_index]); + /* + * Mark the affected sapi as MG_XID. + */ + sndcp_set_sapi_state(sapi, MG_XID); + sndcp_unset_sapi_state(sapi, MG_XID_NEC); + + /* + * Uplink data transfer on SAPI is completely suspended. + */ + sig_mg_su_suspend(sapi); + sig_mg_sua_suspend(sapi); + mg_suspend_affected_nus(sapi); + /* + * Send the XID block to LLC. + */ + + sndcp_unset_sapi_state(sapi, MG_XID_NEC); + sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID); + PSEND(hCommLLC, ll_xid_req); + } + +} /* mg_resend_xid_if_nec() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_resume_affected_nus ++------------------------------------------------------------------------------ +| Description : Resumes all nu service instances affected by +| If nsapi is waiting for SNSM_SEQUENCE_IND, fct. returns. +| +| Parameters : sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_resume_affected_nus (UBYTE sapi) { + UBYTE nsapi = 0; + TRACE_FUNCTION( "mg_resume_affected_nus" ); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + UBYTE local_sapi = 0; + sndcp_get_nsapi_sapi(nsapi, &local_sapi); + if (local_sapi == sapi) { + USHORT nsapi_state = 0; + sndcp_get_nsapi_state(nsapi, &nsapi_state); + if ((nsapi_state & MG_SEQ) > 0) { + return; + } + if (((1 << nsapi) & sndcp_data->mg.suspended_nsapis) > 0) { + sig_mg_nu_resume(nsapi); + sndcp_data->mg.suspended_nsapis &= (~ (ULONG)(1 << nsapi)); + } + } + } +} /* mg_resume_affected_nus() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_is_rel_comp_nec ++------------------------------------------------------------------------------ +| Description : This function will be called in course of the deactivation of +| the given nsapi. If the nsapi used a certain compressor, +| but has been the only one to do this, then with the +| compressor entity will also have to +| be deactivated and all affected +| arrays will be modified. +| Parameters : UBYTE nsapi -- the given nsapi +| BOOL* nec, a compressor +| Post : An "mg_set_sapi_[p/d]ntt_rej(sapi, pntt, TRUE);" will be called +| for +| each entity to be released. Later this information may be used +| to build up the right xid negotiation. +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_is_rel_comp_nec (UBYTE nsapi, BOOL* nec) +{ + UBYTE dntt = 0; + UBYTE pntt = 0; + UBYTE sapi = 0; + UBYTE nsp = 0; + + TRACE_FUNCTION( "mg_is_rel_comp_nec" ); + + sndcp_get_nsapi_sapi(nsapi, &sapi); + + + /* + * Which pntt is used? + */ + for (pntt = 0; pntt < MG_MAX_ENTITIES; pntt++) { + UBYTE state = MG_UNASSIGNED; + BOOL used = FALSE; + BOOL another = FALSE; + BOOL rej_known = FALSE; + /* + * Is pntt already known to be deactivated? + */ + mg_get_sapi_pntt_rej(sapi, pntt, &rej_known); + if (rej_known) { + *nec = TRUE; + continue; + } + /* + * Is ntt used? + */ + mg_get_sapi_pntt_state(sapi, pntt, &state); + if (state == MG_UNASSIGNED) { + continue; + } + /* + * Does the given nsapi use it? + */ + mg_get_sapi_pntt_nsapi(sapi, pntt, nsapi, &used); + if (! used) { + continue; + } + /* + * Is the given nsapi the only user? + */ + for (nsp = 0; nsp < SNDCP_NUMBER_OF_NSAPIS; nsp++) { + mg_get_sapi_pntt_nsapi(sapi, pntt, nsp, &used); + if (used && nsapi != nsp) { + another = TRUE; + } + } + if (another) { + continue; + } + mg_set_sapi_pntt_rej(sapi, pntt, TRUE); + *nec = TRUE; + } + + /* + * Which dntt is used? + */ + for (dntt = 0; dntt < MG_MAX_ENTITIES; dntt++) { + UBYTE state = MG_UNASSIGNED; + BOOL used = FALSE; + BOOL another = FALSE; + BOOL rej_known = FALSE; + /* + * Is pntt already known to be deactivated? + */ + mg_get_sapi_dntt_rej(sapi, dntt, &rej_known); + if (rej_known) { + *nec = TRUE; + continue; + } + /* + * Is ntt used? + */ + mg_get_sapi_dntt_state(sapi, dntt, &state); + if (state == MG_UNASSIGNED) { + continue; + } + /* + * Does the given nsapi use it? + */ + mg_get_sapi_dntt_nsapi(sapi, dntt, nsapi, &used); + if (! used) { + continue; + } + /* + * Is the given nsapi the only user? + */ + for (nsp = 0; nsp < SNDCP_NUMBER_OF_NSAPIS; nsp++) { + mg_get_sapi_dntt_nsapi(sapi, dntt, nsp, &used); + if (used && nsapi != nsp) { + another = TRUE; + } + } + if (another) { + continue; + } + + mg_set_sapi_dntt_rej(sapi, dntt, TRUE); + *nec = TRUE; + } + +} /* mg_is_rel_comp_nec() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_rel_nsapi_nec ++------------------------------------------------------------------------------ +| Description : The SAPI connected to this NSAPI shall release acknowledged LLC +| operation mode if the indicated NSAPI is the last one using +| acknowledged mode on this SAPI. If an LL_RELEASE_REQ is sent +| then the given NSAPI (the one in parameter!) shall enter state +| MG_REL and wait for an LL_RELEASE_CNF. If the affected +| NSAPI doesn't use ack mode then the procedure just returns. +| If the affected sapi does not use acknowledged LLC operation +| mode then the procedure just returns. +| If an LL_ESTABLISH_REQ or LL_XID_REQ for the affected sapi is +| pending, no LL_RELEASE_REQ primitive will be sent, but the +| flag MG_REL_NEC_LOC will be set. +| Pre : This procedure is called after receipt of an +| SNSM_DEACTIVATE_IND, so the "local" parameter in an +| LL_RELEASE_REQ will be set to LL_REL_LOCAL. +| The procedure will only be called if the given nsapi is +| currently using acknowledged LLC operation mode, so this +| does not have to be checked. +| Parameters : UBYTE nsapi -- the given nsapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_rel_nsapi_nec (UBYTE nsapi) +{ + UBYTE sapi = 0; + UBYTE npi = 0; + UBYTE spi = 0; + USHORT sapi_state = MG_IDLE; + /* + * Are there other contexts using acknowledged mode on the same SAPI? + */ + BOOL another_ack = FALSE; + BOOL sack = FALSE; + TRACE_FUNCTION( "mg_rel_nsapi_nec" ); + /* + * Which SAPI is connected to the given NSAPI? + */ + sndcp_get_nsapi_sapi(nsapi, &sapi); + sndcp_get_sapi_ack(sapi, &sack); + sndcp_get_sapi_state(sapi, &sapi_state); + + if(!sack){ + if ((sapi_state & MG_EST) != 0) { + sndcp_set_sapi_state(sapi, MG_REL_NEC_LOC); + } + return; + } + /* + * If release is pending, no need to send an other release. + */ + if ((sapi_state & MG_REL) > 0) { + return; + } + /* + * Are there other contexts using acknowledged mode on the same SAPI? + */ + for (npi = 0; npi < SNDCP_NUMBER_OF_NSAPIS; npi++) { + BOOL used = FALSE; + sndcp_is_nsapi_used(npi, &used); + if (!used) { + continue; + } + sndcp_get_nsapi_sapi(npi, &spi); + if (spi == sapi && npi != nsapi) { + BOOL is_ack = FALSE; + sndcp_get_nsapi_ack(npi, &is_ack); + if (is_ack) { + another_ack = TRUE; + } + break; + } + } + if (!another_ack) { + + if (((sapi_state & MG_EST) == 0) + && + ((sapi_state & MG_XID) == 0)) + { + /* + * No LL_ESTABLISH_REQ or LL_XID_REQ pending. + * LL_RELEASE_REQ may be sent. + */ + + PALLOC(ll_release_req, LL_RELEASE_REQ); + ll_release_req->sapi = sapi; + /* + * Note: this is always set to TRUE because the preconditions include that + * this procedure has been called after an SNSM_DEACTIVATE_IND. + * If this precondition changes the local flag will have to be a parameter. + * (GSM 4.65, 6.2.2.2). + */ + ll_release_req->local = TRUE; + /* + * Set the "state" for the affected sapi to MG_REL. + */ + sndcp_set_sapi_state(sapi, MG_REL); + sndcp_unset_sapi_state(sapi, MG_EST); + + PSEND(hCommLLC, ll_release_req); + + } else { + /* + * LL_ESTABLISH_REQ or LL_XID_REQ pending. + * LL_RELEASE_REQ may not be sent. + */ + sndcp_set_sapi_state(sapi, MG_REL_NEC_LOC); + + } + } /* if (!another_ack) */ + + +} /* mg_rel_nsapi_nec() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_send_empty_xid_req ++------------------------------------------------------------------------------ +| Description : This procedure sets the pending-states of the affected sapi +| and nsapi to MG_XID_PENDING and sends an LL_XID_REQ with +| the sapi from the given snsm_activate_ind and an empty XID +| block. +| +| Parameters : the SNSM_ACTIVATE_IND +| ++------------------------------------------------------------------------------ +*/ +#ifdef SNDCP_UPM_INCLUDED +GLOBAL void mg_send_empty_xid_req (T_SN_ACTIVATE_REQ* snsm_activate_ind) +#else +GLOBAL void mg_send_empty_xid_req (T_SNSM_ACTIVATE_IND* snsm_activate_ind) +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ +{ + TRACE_FUNCTION( "mg_send_empty_xid_req" ); + { + PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN); + /* + * Set sapi in ll_xid_req. + */ + ll_xid_req->sapi = snsm_activate_ind->sapi; + ll_xid_req->sdu.l_buf = 0; + + /* + * Mark sapi as pending. + */ + sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_XID); + /* + * Send the XID block to LLC. + */ + + sndcp_unset_sapi_state(ll_xid_req->sapi, MG_XID_NEC); + sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID); + PSEND(hCommLLC, ll_xid_req); + } +} /* mg_send_xid_req() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_send_snsm_activate_res ++------------------------------------------------------------------------------ +| Description : Allocates prim, sets parameters and sends prim +| +| Parameters : the affected nsapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_send_snsm_activate_res (UBYTE nsapi) +{ + + TRACE_FUNCTION( "mg_send_snsm_activate_res" ); + { + UBYTE sapi_index = 0; + UBYTE sapi = 0; + +#ifdef SNDCP_UPM_INCLUDED + PALLOC(snsm_activate_res, SN_ACTIVATE_CNF); +#else + PALLOC(snsm_activate_res, SNSM_ACTIVATE_RES); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + + sndcp_get_nsapi_sapi(nsapi, &sapi); + sndcp_get_sapi_index(sapi, &sapi_index); + + snsm_activate_res->nsapi = nsapi; + + /* + * If nsapi uses data compressor, set dcomp parameter + * in snsm_activate_res. + */ + if (sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set && + ((sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis & + (1 << nsapi)) > 0)) { + +#ifdef SNDCP_UPM_INCLUDED + snsm_activate_res->comp_params.dcomp = + sndcp_data->mg.cur_xid_block[sapi_index].v42.p0; +#else + snsm_activate_res->dcomp = + sndcp_data->mg.cur_xid_block[sapi_index].v42.p0; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + } else + { +#ifdef SNDCP_UPM_INCLUDED + snsm_activate_res->comp_params.dcomp = 0; +#else + snsm_activate_res->dcomp = 0; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + } + + /* + * If nsapi uses header compressor, set hcomp parameter + * and msid field in snsm_activate_res. + */ + +#ifdef SNDCP_UPM_INCLUDED + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set && + ((sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis & + (1 << nsapi)) > 0)) { + snsm_activate_res->comp_params.msid = + sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 + 1; + /* + * How is that one negotiated? + * Missing in VJ XID block. + */ + snsm_activate_res->comp_params.hcomp = + sndcp_data->mg.cur_xid_block[sapi_index].vj.direction; + } else { + snsm_activate_res->comp_params.hcomp = 0; + snsm_activate_res->comp_params.msid = 0; + } + + PSEND(hCommUPM, snsm_activate_res); +#else /*#ifdef SNDCP_UPM_INCLUDED*/ + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set && + ((sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis & + (1 << nsapi)) > 0)) { + snsm_activate_res->msid = + sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 + 1; + /* + * How is that one negotiated? + * Missing in VJ XID block. + */ + snsm_activate_res->hcomp = + sndcp_data->mg.cur_xid_block[sapi_index].vj.direction; + } else { + snsm_activate_res->hcomp = 0; + snsm_activate_res->msid = 0; + } + PSEND(hCommSM, snsm_activate_res); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ +} + } /* mg_send_snsm_activate_res() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_send_xid_req ++------------------------------------------------------------------------------ +| Description : This procedure sets the pending-states of the affected sapi +| and nsapi to MG_XID_PENDING and sends an LL_XID_REQ with +| parameters set according to the compression informations in +| the given snsm_activate_ind and according to constants that +| determine the capabilities of the data compression entity. +| The part of this procedure that deals with the constant +| compressor capabilities is implementation dependent. +| +| Parameters : the SNSM_ACTIVATE_IND +| ++------------------------------------------------------------------------------ +*/ +#ifdef SNDCP_UPM_INCLUDED +GLOBAL void mg_send_xid_req (T_SN_ACTIVATE_REQ* snsm_activate_ind) +#else +GLOBAL void mg_send_xid_req (T_SNSM_ACTIVATE_IND* snsm_activate_ind) +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ +{ + UBYTE sapi_index = 0; + TRACE_FUNCTION( "mg_send_xid_req" ); + sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index); + { + PALLOC_SDU(ll_xid_req, LL_XID_REQ, SNDCP_XID_BLOCK_BIT_LEN); + /* + * Set sapi in ll_xid_req. + */ + ll_xid_req->sapi = snsm_activate_ind->sapi; + /* + * Write data from snsm_activate_ind to service variable req_xid_block. + */ + + mg_set_req_xid_block(snsm_activate_ind); + /* + * Fill the XID block. Implementation dependent. + */ + mg_set_xid_params(ll_xid_req->sapi, + &ll_xid_req->sdu, + sndcp_data->mg.req_xid_block[sapi_index]); + /* + * Mark the affected sapi as xid pending + */ + + sndcp_set_sapi_state(snsm_activate_ind->sapi, MG_XID); + + /* + * Trace xid block. + */ +#ifdef SNDCP_TRACE_ALL + TRACE_EVENT("outcoming xid block:"); + sndcp_trace_sdu(&ll_xid_req->sdu); +#endif + /* + * Send the XID block to LLC. + */ + + sndcp_unset_sapi_state(ll_xid_req->sapi, MG_XID_NEC); + sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID); + PSEND(hCommLLC, ll_xid_req); + } +} /* mg_send_xid_req() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_send_xid_req_del ++------------------------------------------------------------------------------ +| Description : If mg_get_sapi_pntt_rej() or mg_get_sapi_dntt_rej() indicate +| that compressors must be removed, this function will +| send an LL_XID_REQ which does this, or if an XID is pending, +| the information about the rejected compressors will be stored +| to new_xid_block and the MG_XID_NEC will be set. +| +| Parameters : the SNSM_ACTIVATE_IND +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_send_xid_req_del (UBYTE sapi) +{ + UBYTE sapi_index = 0; + UBYTE ntt = 0; + T_XID_BLOCK mt_xid_block; + /* + * Only length of parameter type 0. + */ + USHORT res_sdu_bit_len = 24; + BOOL v42_rej = FALSE; + BOOL vj_rej = FALSE; + + TRACE_FUNCTION( "mg_send_xid_req_del" ); + + sndcp_reset_xid_block(&mt_xid_block); + + sndcp_get_sapi_index(sapi, &sapi_index); + /* + * How long will xid_block be? + */ + /* + * Add the extra space for ntts with nsapis == 0. + */ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_dntt_rej(sapi, ntt, &rej); + if (rej) { + /* + * length of ntt octet and nsapis. + */ + res_sdu_bit_len += 32; + v42_rej = TRUE; + /* + * Change new_xid_block. + */ + sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis = 0; + sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis_set = TRUE; + sndcp_data->mg.new_xid_block[sapi_index].v42.is_set = TRUE; + } + + mg_get_sapi_pntt_rej(sapi, ntt, &rej); + if (rej) { + /* + * length of ntt octet and nsapis. + */ + res_sdu_bit_len += 32; + vj_rej = TRUE; + /* + * Change req_xid_block. + */ + sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis = 0; + sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis_set = TRUE; + sndcp_data->mg.new_xid_block[sapi_index].vj.is_set = TRUE; + + } + } + if (v42_rej) { + /* + * Add length of parameter type and length. + */ + res_sdu_bit_len += 16; + } + if (vj_rej) { + /* + * Add length of parameter type and length. + */ + res_sdu_bit_len += 16; + } + + if (v42_rej || vj_rej) { + + USHORT state = MG_IDLE; + + sndcp_get_sapi_state(sapi, &state); + if ((state & MG_XID) == 0) { + + PALLOC_SDU(ll_xid_req, LL_XID_REQ, res_sdu_bit_len); + + sndcp_data->mg.req_xid_block[sapi_index] = + sndcp_data->mg.new_xid_block[sapi_index]; + /* + * Set sapi in ll_xid_req. + */ + ll_xid_req->sapi = sapi; + /* + * Write data from snsm_activate_ind to service variable req_xid_block. + */ + sndcp_reset_xid_block(&mt_xid_block); + sndcp_reset_xid_block(&sndcp_data->mg.new_xid_block[sapi_index]); + /* + * Fill the XID block. Implementation dependent. + */ + mg_set_xid_params(ll_xid_req->sapi, + &ll_xid_req->sdu, + mt_xid_block); + /* + * Mark the affected sapi as MG_DEL_XID_PENDING. + */ + sndcp_set_sapi_state(sapi, MG_XID); + /* + * Send the XID block to LLC. + */ + + sndcp_unset_sapi_state(sapi, MG_XID_NEC); + sndcp_set_sapi_state(ll_xid_req->sapi, MG_XID); + PSEND(hCommLLC, ll_xid_req); + } else { + sndcp_set_sapi_state(sapi, MG_XID_NEC); + } + } +} /* mg_send_xid_req_del() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_cur_xid_block ++------------------------------------------------------------------------------ +| Description : This procedure sets the cur_xid_block service variable +| according to the values given in req_xid_block and cnf_xid_block. +| It also sets the unassigned, selected, assigned states of the affected +| dcomp, pcomp, ntt. +| The p bit in the req_xid_block is unset, if affected. +| See GSM 4.65, 6.8.2. +| +| Parameters : the affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_set_cur_xid_block (UBYTE sapi) { + UBYTE sapi_index = 0; + T_XID_BLOCK* cur_xid_block; + T_XID_BLOCK* req_xid_block; + T_XID_BLOCK* cnf_xid_block; + TRACE_FUNCTION( "mg_set_cur_xid_block" ); + sndcp_get_sapi_index(sapi, &sapi_index); + cur_xid_block = &sndcp_data->mg.cur_xid_block[sapi_index]; + req_xid_block = &sndcp_data->mg.req_xid_block[sapi_index]; + cnf_xid_block = &sndcp_data->mg.cnf_xid_block[sapi_index]; + /* + * SNDCP version has been tested to be SNDCP_XID_VERSION. + */ + cur_xid_block->version = SNDCP_XID_VERSION; + + /* + * V42bis parameters. + */ + if (req_xid_block->v42.is_set) { + cur_xid_block->v42.is_set = TRUE; + cur_xid_block->v42.ntt = req_xid_block->v42.ntt; + mg_set_sapi_dntt_state(sapi, + req_xid_block->v42.ntt, + MG_ASSIGNED); + req_xid_block->v42.p_bit = SNDCP_P_BIT_0; + + /* + * Algorithm type and DCOMP are only set in req. + */ + cur_xid_block->v42.algo_type = req_xid_block->v42.algo_type; + cur_xid_block->v42.dcomp = req_xid_block->v42.dcomp; + mg_set_sapi_dcomp_state(sapi, + req_xid_block->v42.dcomp, + MG_ASSIGNED); + + if (cnf_xid_block->v42.is_set) { + + if (cnf_xid_block->v42.nsapis_set) { + cur_xid_block->v42.nsapis = cnf_xid_block->v42.nsapis; + cur_xid_block->v42.nsapis_set = TRUE; + } else if (req_xid_block->v42.nsapis_set) { + cur_xid_block->v42.nsapis = req_xid_block->v42.nsapis; + cur_xid_block->v42.nsapis_set = TRUE; + } + if (cnf_xid_block->v42.p0_set) { + cur_xid_block->v42.p0 = cnf_xid_block->v42.p0; + cur_xid_block->v42.p0_set = TRUE; + } else if (req_xid_block->v42.p0_set) { + cur_xid_block->v42.p0 = req_xid_block->v42.p0; + cur_xid_block->v42.p0_set = TRUE; + } + if (cnf_xid_block->v42.p1_set) { + cur_xid_block->v42.p1 = cnf_xid_block->v42.p1; + cur_xid_block->v42.p1_set = TRUE; + } else if (req_xid_block->v42.p1_set) { + cur_xid_block->v42.p1 = req_xid_block->v42.p1; + cur_xid_block->v42.p1_set = TRUE; + } + if (cnf_xid_block->v42.p2_set) { + cur_xid_block->v42.p2 = cnf_xid_block->v42.p2; + cur_xid_block->v42.p2_set = TRUE; + } else if (req_xid_block->v42.p2_set) { + cur_xid_block->v42.p2 = req_xid_block->v42.p2; + cur_xid_block->v42.p2_set = TRUE; + } + + } else { + /* + * NOT cnf_xid_block->v42.is_set. + */ + + if (req_xid_block->v42.nsapis_set) { + cur_xid_block->v42.nsapis = req_xid_block->v42.nsapis; + cur_xid_block->v42.nsapis_set = TRUE; + } + if (req_xid_block->v42.p0_set) { + cur_xid_block->v42.p0 = req_xid_block->v42.p0; + cur_xid_block->v42.p0_set = TRUE; + } + if (req_xid_block->v42.p1_set) { + cur_xid_block->v42.p1 = req_xid_block->v42.p1; + cur_xid_block->v42.p1_set = TRUE; + } + if (req_xid_block->v42.p2_set) { + cur_xid_block->v42.p2 = req_xid_block->v42.p2; + cur_xid_block->v42.p2_set = TRUE; + } + + } + } else { + /* + * NOT req_xid_block->v42.is_set. + */ + if (cnf_xid_block->v42.is_set) { + + cur_xid_block->v42.is_set = TRUE; + if (cnf_xid_block->v42.nsapis_set) { + cur_xid_block->v42.nsapis = cnf_xid_block->v42.nsapis; + cur_xid_block->v42.nsapis_set = TRUE; + } + if (cnf_xid_block->v42.p0_set) { + cur_xid_block->v42.p0 = cnf_xid_block->v42.p0; + cur_xid_block->v42.p0_set = TRUE; + } + if (cnf_xid_block->v42.p1_set) { + cur_xid_block->v42.p1 = cnf_xid_block->v42.p1; + cur_xid_block->v42.p1_set = TRUE; + } + if (cnf_xid_block->v42.p2_set) { + cur_xid_block->v42.p2 = cnf_xid_block->v42.p2; + cur_xid_block->v42.p2_set = TRUE; + } + + } else { + /* + * Req and cnf are not set, cur_xid_block keeps its values. + */ + } + } + + + /* + * VJ parameters. + */ + if (req_xid_block->vj.is_set) { + cur_xid_block->vj.is_set = TRUE; + cur_xid_block->vj.ntt = req_xid_block->vj.ntt; + mg_set_sapi_pntt_state(sapi, + req_xid_block->vj.ntt, + MG_ASSIGNED); + req_xid_block->vj.p_bit = SNDCP_P_BIT_0; + /* + * Algorithm type and PCOMPs are only set in req. + * The direction is only set in req. + */ + cur_xid_block->vj.algo_type = req_xid_block->vj.algo_type; + cur_xid_block->vj.pcomp1 = req_xid_block->vj.pcomp1; + mg_set_sapi_pcomp_state(sapi, + req_xid_block->vj.pcomp1, + MG_ASSIGNED); + cur_xid_block->vj.pcomp2 = req_xid_block->vj.pcomp2; + mg_set_sapi_pcomp_state(sapi, + req_xid_block->vj.pcomp2, + MG_ASSIGNED); + cur_xid_block->vj.direction = req_xid_block->vj.direction; + if (cnf_xid_block->vj.is_set) { + if (cnf_xid_block->vj.nsapis_set) { + cur_xid_block->vj.nsapis = cnf_xid_block->vj.nsapis; + cur_xid_block->vj.nsapis_set = TRUE; + } else { + cur_xid_block->vj.nsapis = req_xid_block->vj.nsapis; + cur_xid_block->vj.nsapis_set = TRUE; + } + if (cnf_xid_block->vj.s0_m_1_set) { + cur_xid_block->vj.s0_m_1 = cnf_xid_block->vj.s0_m_1; + cur_xid_block->vj.s0_m_1_set = TRUE; + } else { + cur_xid_block->vj.s0_m_1 = req_xid_block->vj.s0_m_1; + cur_xid_block->vj.s0_m_1_set = TRUE; + } + } else { + if (req_xid_block->vj.nsapis_set) { + cur_xid_block->vj.nsapis = req_xid_block->vj.nsapis; + cur_xid_block->vj.nsapis_set = TRUE; + } + if (req_xid_block->vj.s0_m_1_set) { + cur_xid_block->vj.s0_m_1 = req_xid_block->vj.s0_m_1; + cur_xid_block->vj.s0_m_1_set = TRUE; + } + } + } else { + /* + * NOT req_xid_block->vj.es_set. + */ + if (cnf_xid_block->vj.is_set) { + cur_xid_block->vj.is_set = TRUE; + if (cnf_xid_block->vj.nsapis_set) { + cur_xid_block->vj.nsapis = cnf_xid_block->vj.nsapis; + cur_xid_block->vj.nsapis_set = TRUE; + } + if (cnf_xid_block->vj.s0_m_1_set) { + cur_xid_block->vj.s0_m_1 = cnf_xid_block->vj.s0_m_1; + cur_xid_block->vj.s0_m_1_set = TRUE; + } + } else { + /* + * Req and cnf are not set, cur_xid_block keeps it's values. + */ + } + } + + /* + * If nsapis are 0, deactivate compressor. + */ + if (cur_xid_block->v42.nsapis == 0 || + cur_xid_block->v42.nsapis_set == FALSE) { + + /* + * Find the affected compressor entity. + */ + UBYTE dntt = 0; + mg_get_sapi_dcomp_dntt(sapi, req_xid_block->v42.dcomp, &dntt); + + cur_xid_block->v42.is_set = FALSE; + mg_set_sapi_dcomp_state(sapi, + req_xid_block->v42.dcomp, + MG_UNASSIGNED); + mg_set_sapi_dntt_state(sapi, + dntt, + MG_UNASSIGNED); + /* + * One compressor less, something like sndcp_data->v42_count--; + * should come here! + */ + + } + if (cur_xid_block->vj.nsapis == 0 || + cur_xid_block->vj.nsapis_set == FALSE) { + + /* + * Find the affected compressor entity. + */ + UBYTE pntt = 0; + mg_get_sapi_pcomp_pntt(sapi, req_xid_block->vj.pcomp1, &pntt); + mg_get_sapi_pcomp_pntt(sapi, req_xid_block->vj.pcomp2, &pntt); + cur_xid_block->vj.is_set = FALSE; + mg_set_sapi_pcomp_state(sapi, + req_xid_block->vj.pcomp1, + MG_UNASSIGNED); + mg_set_sapi_pcomp_state(sapi, + req_xid_block->vj.pcomp2, + MG_UNASSIGNED); + mg_set_sapi_pntt_state(sapi, + pntt, + MG_UNASSIGNED); + /* + * One compressor less. + */ + if (sndcp_data->vj_count > 0) { + sndcp_data->vj_count--; + } + } + + + /* + * Send new block to service cia. + */ + sig_mg_cia_new_xid(cur_xid_block); + +} /* mg_set_cur_xid_block() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_new_xid_block ++------------------------------------------------------------------------------ +| Description : This procedure reads data from the given snsm_activate_ind and +| from the already requested xid block and +| writes them to the service variable new_xid_block. +| When the pending establishment or xid negotiation is finished +| this new_xid_block will be newly evaluated. +| +| Parameters : +| the new SNSM_ACTIVATE_IND +| ++------------------------------------------------------------------------------ +*/ +#ifdef SNDCP_UPM_INCLUDED +GLOBAL void mg_set_new_xid_block (T_SN_ACTIVATE_REQ* snsm_activate_ind) +#else +GLOBAL void mg_set_new_xid_block (T_SNSM_ACTIVATE_IND* snsm_activate_ind) +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ +{ + UBYTE sapi_index = 0; + TRACE_FUNCTION( "mg_set_new_xid_block" ); + sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index); + /* + * Set the version number. + */ + sndcp_data->mg.new_xid_block[sapi_index].version = SNDCP_XID_VERSION; + /* + * Set the V42.bis parameters, + */ +#ifdef TI_PS_FF_V42BIS + sndcp_data->mg.new_xid_block[sapi_index].v42.is_set = +#ifdef SNDCP_UPM_INCLUDED + (snsm_activate_ind->comp_params.dcomp != NAS_DCOMP_NEITHER_DIRECT); +#else + (snsm_activate_ind->dcomp != SNSM_COMP_NEITHER_DIRECT); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.new_xid_block[sapi_index].v42.p_bit = SNDCP_P_BIT_1; + sndcp_data->mg.new_xid_block[sapi_index].v42.ntt = SNDCP_NTT_0; + sndcp_data->mg.new_xid_block[sapi_index].v42.algo_type = SNDCP_XID_V42; + sndcp_data->mg.new_xid_block[sapi_index].v42.dcomp = SNDCP_DCOMP1; + sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis = + 1 << (snsm_activate_ind->nsapi); + sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis_set = TRUE; +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.new_xid_block[sapi_index].v42.p0 = snsm_activate_ind->comp_params.dcomp; +#else + sndcp_data->mg.new_xid_block[sapi_index].v42.p0 = snsm_activate_ind->dcomp; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.new_xid_block[sapi_index].v42.p0_set = TRUE; + + /* + * Set p1 and p2 to default values. + */ + sndcp_data->mg.new_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1; + sndcp_data->mg.new_xid_block[sapi_index].v42.p1_set = TRUE; + sndcp_data->mg.new_xid_block[sapi_index].v42.p2 = + SNDCP_V42_DEFAULT_P2; + sndcp_data->mg.new_xid_block[sapi_index].v42.p2_set = TRUE; + + /* + * Set affected entities and dcomp/pcomp values. + */ + mg_set_ntt_comp(snsm_activate_ind->sapi); + +#else /* !TI_PS_FF_V42BIS */ + + + sndcp_data->mg.new_xid_block[sapi_index].v42.is_set = FALSE; + + sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis = 0; + + sndcp_data->mg.new_xid_block[sapi_index].v42.nsapis_set = FALSE; + sndcp_data->mg.new_xid_block[sapi_index].v42.p0_set = FALSE; + + /* + * Set p1 and p2 to default values. + */ + sndcp_data->mg.new_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1; + sndcp_data->mg.new_xid_block[sapi_index].v42.p1_set = TRUE; + sndcp_data->mg.new_xid_block[sapi_index].v42.p2 = + SNDCP_V42_DEFAULT_P2; + sndcp_data->mg.new_xid_block[sapi_index].v42.p2_set = TRUE; + +#endif /* TI_PS_FF_V42BIS */ + + /* + * Set the Van Jacobson parameters, + */ + sndcp_data->mg.new_xid_block[sapi_index].vj.is_set = +#ifdef SNDCP_UPM_INCLUDED + (snsm_activate_ind->comp_params.hcomp != NAS_HCOMP_OFF) || +#else + (snsm_activate_ind->hcomp != SNSM_COMP_NEITHER_DIRECT) || +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.new_xid_block[sapi_index].vj.is_set || + sndcp_data->mg.req_xid_block[sapi_index].vj.is_set; + + if (! sndcp_data->mg.req_xid_block[sapi_index].vj.is_set) { + sndcp_data->mg.new_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_1; + } else { + sndcp_data->mg.new_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_0; + } + + sndcp_data->mg.new_xid_block[sapi_index].vj.ntt = SNDCP_NTT_0; + sndcp_data->mg.new_xid_block[sapi_index].vj.algo_type = SNDCP_XID_VJ; + sndcp_data->mg.new_xid_block[sapi_index].vj.pcomp1 = SNDCP_PCOMP1; + sndcp_data->mg.new_xid_block[sapi_index].vj.pcomp2 = SNDCP_PCOMP2; + + sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis |= + (sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis | + 1 << (snsm_activate_ind->nsapi)); + sndcp_data->mg.new_xid_block[sapi_index].vj.nsapis_set = TRUE; + +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.new_xid_block[sapi_index].vj.s0_m_1 = + snsm_activate_ind->comp_params.msid - 1; +#else + sndcp_data->mg.new_xid_block[sapi_index].vj.s0_m_1 = + snsm_activate_ind->msid - 1; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.new_xid_block[sapi_index].vj.s0_m_1_set = TRUE; + /* + * Only used internally, not in XID block. + * Not: it is assumed that the indicated values match the existing ones! + */ +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.new_xid_block[sapi_index].vj.direction = + snsm_activate_ind->comp_params.hcomp; +#else + sndcp_data->mg.new_xid_block[sapi_index].vj.direction = + snsm_activate_ind->hcomp; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + +} /* mg_set_new_xid_block() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_req_xid_block ++------------------------------------------------------------------------------ +| Description : This procedure reads data from the given snsm_activate_ind and +| writes it to the service variable req_xid_block. +| +| Parameters : +| the SNSM_ACTIVATE_IND that caused the negotiation. +| ++------------------------------------------------------------------------------ +*/ +#ifdef SNDCP_UPM_INCLUDED +GLOBAL void mg_set_req_xid_block (T_SN_ACTIVATE_REQ* snsm_activate_ind) +#else +GLOBAL void mg_set_req_xid_block (T_SNSM_ACTIVATE_IND* snsm_activate_ind) +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ +{ + UBYTE sapi_index = 0; + BOOL vio; + TRACE_FUNCTION( "mg_set_req_xid_block" ); + sndcp_get_sapi_index(snsm_activate_ind->sapi, &sapi_index); + /* + * Set the version number. + */ + sndcp_data->mg.req_xid_block[sapi_index].version = SNDCP_XID_VERSION; + /* + * Set the V42.bis parameters, + */ +#ifdef TI_PS_FF_V42BIS + +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.req_xid_block[sapi_index].v42.is_set = + (snsm_activate_ind->comp_params.dcomp != NAS_DCOMP_NEITHER_DIRECT); +#else + sndcp_data->mg.req_xid_block[sapi_index].v42.is_set = + (snsm_activate_ind->dcomp != SNSM_COMP_NEITHER_DIRECT); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.req_xid_block[sapi_index].v42.p_bit = SNDCP_P_BIT_1; + sndcp_data->mg.req_xid_block[sapi_index].v42.ntt = SNDCP_NTT_0; + sndcp_data->mg.req_xid_block[sapi_index].v42.algo_type = SNDCP_XID_V42; + sndcp_data->mg.req_xid_block[sapi_index].v42.dcomp = SNDCP_DCOMP1; + + sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis = + 1 << (snsm_activate_ind->nsapi); + sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis_set = TRUE; +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.req_xid_block[sapi_index].v42.p0 = snsm_activate_ind->comp_params.dcomp; +#else + sndcp_data->mg.req_xid_block[sapi_index].v42.p0 = snsm_activate_ind->dcomp; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.req_xid_block[sapi_index].v42.p0_set = TRUE; + + /* + * Set p1 and p2 to default values. + */ + sndcp_data->mg.req_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1; + sndcp_data->mg.req_xid_block[sapi_index].v42.p1_set = TRUE; + sndcp_data->mg.req_xid_block[sapi_index].v42.p2 = + SNDCP_V42_DEFAULT_P2; + sndcp_data->mg.req_xid_block[sapi_index].v42.p2_set = TRUE; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.is_set = + #ifdef SNDCP_UPM_INCLUDED + (snsm_activate_ind->comp_params.dcomp != NAS_DCOMP_NEITHER_DIRECT); + #else + (snsm_activate_ind->dcomp != SNSM_COMP_NEITHER_DIRECT); + #endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p_bit = SNDCP_P_BIT_1; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.ntt = SNDCP_NTT_0; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.algo_type = SNDCP_XID_V42; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.dcomp = SNDCP_DCOMP1; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.nsapis = + 1 << (snsm_activate_ind->nsapi); + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.nsapis_set = TRUE; + #ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p0 = snsm_activate_ind->comp_params.dcomp; + #else + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p0 = snsm_activate_ind->dcomp; + #endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p0_set = TRUE; + + /* + * Set p1 and p2 to default values. + */ + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p1 = SNDCP_V42_DEFAULT_P1; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p1_set = TRUE; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p2 = + SNDCP_V42_DEFAULT_P2; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].v42.p2_set = TRUE; + + /* + * Set affected entities and dcomp/pcomp values. + */ + mg_set_ntt_comp(snsm_activate_ind->sapi); + + +#else /* !TI_PS_FF_V42BIS */ + + sndcp_data->mg.req_xid_block[sapi_index].v42.is_set = FALSE; + + sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis = 0; + + sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis_set = FALSE; + sndcp_data->mg.req_xid_block[sapi_index].v42.p0_set = FALSE; + + /* + * Set p1 and p2 to default values. + */ + sndcp_data->mg.req_xid_block[sapi_index].v42.p1 = SNDCP_V42_DEFAULT_P1; + sndcp_data->mg.req_xid_block[sapi_index].v42.p1_set = TRUE; + sndcp_data->mg.req_xid_block[sapi_index].v42.p2 = + SNDCP_V42_DEFAULT_P2; + sndcp_data->mg.req_xid_block[sapi_index].v42.p2_set = TRUE; + +#endif /* TI_PS_FF_V42BIS */ + + /* + * Set the Van Jacobson parameters. + * Note: + * If number of state slots is set to 0, do not request VJ in XID request. + */ +#ifdef SNDCP_UPM_INCLUDED + if (snsm_activate_ind->comp_params.msid == 0) { +#else + if (snsm_activate_ind->msid == 0) { +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.req_xid_block[sapi_index].vj.is_set = FALSE; + return; + } + + sndcp_data->mg.req_xid_block[sapi_index].vj.is_set = + #ifdef SNDCP_UPM_INCLUDED + (snsm_activate_ind->comp_params.hcomp != NAS_HCOMP_OFF); + #else + (snsm_activate_ind->hcomp != SNSM_COMP_NEITHER_DIRECT); + #endif /*#ifdef SNDCP_UPM_INCLUDED*/ + if (!sndcp_data->mg.req_xid_block[sapi_index].vj.is_set) { + return; + } + /* + * This function will only be called after snsm_activate_ind. So the + * user_xid_block will be set for the affected nsapi. + */ + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) { + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.p_bit = + SNDCP_P_BIT_0; + } else { + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.p_bit = + SNDCP_P_BIT_1; + } + + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.ntt = + SNDCP_NTT_0; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.algo_type = + SNDCP_XID_VJ; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.pcomp1 = + SNDCP_PCOMP1; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.pcomp2 = + SNDCP_PCOMP2; + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.nsapis += + 1 << (snsm_activate_ind->nsapi); + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.nsapis_set = TRUE; +#ifdef SNDCP_UPM_INCLUDED + if (snsm_activate_ind->comp_params.msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) { + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 = + SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1; + } else { + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 = + snsm_activate_ind->comp_params.msid - 1; + } +#else + if (snsm_activate_ind->msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) { + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 = + SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1; + } else { + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1 = + snsm_activate_ind->msid - 1; + } +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.s0_m_1_set = TRUE; + /* + * Only used internally, not in XID block. + */ +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.direction = + snsm_activate_ind->comp_params.hcomp; +#else + sndcp_data->mg.user_xid_block[snsm_activate_ind->nsapi].vj.direction = + snsm_activate_ind->hcomp; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + + /* + * Set affected entities and dcomp/pcomp values. + */ + mg_set_ntt_comp(snsm_activate_ind->sapi); + + mg_detect_mode_clash ((USHORT) + (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis + + (1 << (snsm_activate_ind->nsapi))), + &vio); + if (vio) { + return; + } + + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) { + sndcp_data->mg.req_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_0; + } else { + sndcp_data->mg.req_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_1; + } + sndcp_data->mg.req_xid_block[sapi_index].vj.ntt = SNDCP_NTT_0; + sndcp_data->mg.req_xid_block[sapi_index].vj.algo_type = SNDCP_XID_VJ; + sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp1 = SNDCP_PCOMP1; + sndcp_data->mg.req_xid_block[sapi_index].vj.pcomp2 = SNDCP_PCOMP2; + + /* + * All the nsapis that currently use the compressor and the new one + * shall be set in the nsapis field of the XID block. + */ + sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis = + (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis | + (1 << (snsm_activate_ind->nsapi))); + + sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis_set = TRUE; +#ifdef SNDCP_UPM_INCLUDED + if (snsm_activate_ind->comp_params.msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) { + sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 = + SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1; + } else { + sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 = + snsm_activate_ind->comp_params.msid - 1; + } +#else + if (snsm_activate_ind->msid > SNDCP_MAX_NUMBER_OF_VJ_SLOTS) { + sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 = + SNDCP_MAX_NUMBER_OF_VJ_SLOTS - 1; + } else { + sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1 = + snsm_activate_ind->msid - 1; + } +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + sndcp_data->mg.req_xid_block[sapi_index].vj.s0_m_1_set = TRUE; + /* + * Only used internally, not in XID block. + */ +#ifdef SNDCP_UPM_INCLUDED + sndcp_data->mg.req_xid_block[sapi_index].vj.direction = + snsm_activate_ind->comp_params.hcomp; +#else + sndcp_data->mg.req_xid_block[sapi_index].vj.direction = + snsm_activate_ind->hcomp; +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + /* + * Set affected entities and dcomp/pcomp values. + */ + mg_set_ntt_comp(snsm_activate_ind->sapi); + +} /* mg_set_req_xid_block() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_res_cur_xid_block ++------------------------------------------------------------------------------ +| Description : This procedure sets the service variables res_xid_block and +| cur_xid_block. The needed data comes from the service variable ind_xid_block, +| and from default settings. +| Note: if the indicated compressors do not match with compressors requested +| or currently used then they will be unset by adding them to the list of +| rejected compressors. +| +| +| Parameters : +| the affected sapi, +| the necessary bit length of an sdu that will later store the +| xid block derived from res_xid_block. +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_set_res_cur_xid_block (UBYTE sapi, USHORT* res_sdu_bit_len) +{ + UBYTE sapi_index = 0; + UBYTE nsapi = 0; + /* + * Which compressors are indicated? + */ + BOOL v42_ind, vj_ind; + /* + * Which compressors are possible? + * (The indicated set of nsapis must overlap with the + * currently used one.) + */ + BOOL v42_possible, vj_possible; + /* + * Is compressor going to rejected? In this case the compressor should not + * be requested. + */ + BOOL v42_rejected, vj_rejected; + + TRACE_FUNCTION( "mg_set_res_cur_xid_block" ); + + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_reset_xid_block(&(sndcp_data->mg.res_xid_block[sapi_index])); + + /* + * Set bit length to "only version", 3 bytes. + */ + *res_sdu_bit_len = 24; + /* + * Set the version number. + */ + sndcp_data->mg.res_xid_block[sapi_index].version = SNDCP_XID_VERSION; + + v42_ind = sndcp_data->mg.ind_xid_block[sapi_index].v42.is_set; + v42_possible = FALSE; + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if ((sndcp_data->mg.user_xid_block[nsapi].v42.nsapis & + sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) { + + U8 local_sapi = 0; + sndcp_get_nsapi_sapi(nsapi, &local_sapi); + if (local_sapi == sapi) { + v42_possible = TRUE; + } + } + } + + + if (v42_ind && ! v42_possible) { + sndcp_data->mg.res_xid_block[sapi_index].v42.is_set = FALSE; + mg_set_sapi_dntt_rej (sapi, + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, + TRUE); + } + + mg_get_sapi_dntt_rej (sapi, + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt, + &v42_rejected); + + + if (v42_ind && ! v42_rejected) { + /* + * Data compression will be included, increment bit len (+ 10 bytes). + */ + *res_sdu_bit_len += 80; + + /* + * Set the V42.bis parameters, + */ + sndcp_data->mg.res_xid_block[sapi_index].v42.is_set = TRUE; + + sndcp_data->mg.res_xid_block[sapi_index].v42.p_bit = SNDCP_P_BIT_0; + + sndcp_data->mg.res_xid_block[sapi_index].v42.ntt = + sndcp_data->mg.ind_xid_block[sapi_index].v42.ntt; + + + sndcp_data->mg.res_xid_block[sapi_index].v42.algo_type = SNDCP_XID_V42; + + sndcp_data->mg.res_xid_block[sapi_index].v42.dcomp = + sndcp_data->mg.ind_xid_block[sapi_index].v42.dcomp; + + /* + * Set the 'nsapis' parameter in res_xid_block: + * Check rules in 4.65, subclause 6.8.1, compare with cur_xid_block. + */ + mg_set_xid_nsapis(sapi, MG_XID_V42_NSAPIS); + + /* + * It is assumed that the values desired by the user / the + * values possible with the current implementation are written in + * req_xid_block, the responded values are then the minimum of + * req and ind values: + */ + /* + * For the direction parameter p0 take the logical AND: + */ + sndcp_data->mg.res_xid_block[sapi_index].v42.p0 = + (sndcp_data->mg.req_xid_block[sapi_index].v42.p0 & + sndcp_data->mg.ind_xid_block[sapi_index].v42.p0); + sndcp_data->mg.res_xid_block[sapi_index].v42.p0_set = TRUE; + + /* + * For p1 and p2 take minimum. + */ + sndcp_data->mg.res_xid_block[sapi_index].v42.p1 = + (sndcp_data->mg.req_xid_block[sapi_index].v42.p1 < + sndcp_data->mg.ind_xid_block[sapi_index].v42.p1)? + sndcp_data->mg.req_xid_block[sapi_index].v42.p1 : + sndcp_data->mg.ind_xid_block[sapi_index].v42.p1; + sndcp_data->mg.res_xid_block[sapi_index].v42.p1_set = TRUE; + + sndcp_data->mg.res_xid_block[sapi_index].v42.p2 = + (sndcp_data->mg.req_xid_block[sapi_index].v42.p2 < + sndcp_data->mg.ind_xid_block[sapi_index].v42.p2)? + sndcp_data->mg.req_xid_block[sapi_index].v42.p2 : + sndcp_data->mg.ind_xid_block[sapi_index].v42.p2; + sndcp_data->mg.res_xid_block[sapi_index].v42.p2_set = TRUE; + + } /* v42.is_set */ + + + /* + * Header compression, + */ + + + vj_ind = sndcp_data->mg.ind_xid_block[sapi_index].vj.is_set; + vj_possible = FALSE; + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if ((sndcp_data->mg.user_xid_block[nsapi].vj.nsapis & + sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis) > 0) { + + U8 local_sapi = 0; + sndcp_get_nsapi_sapi(nsapi, &local_sapi); + if (local_sapi == sapi) { + vj_possible = TRUE; + } + } + } + + if (vj_ind && ! vj_possible) { + sndcp_data->mg.res_xid_block[sapi_index].vj.is_set = FALSE; + mg_set_sapi_pntt_rej (sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + TRUE); + } + + mg_get_sapi_pntt_rej (sapi, + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt, + &vj_rejected); + + if (vj_ind && ! vj_rejected) { + /* + * Header compression will be included, increment bit len (+ 7 bytes). + */ + *res_sdu_bit_len += 56; + + /* + * Set the VJ parameters, + */ + sndcp_data->mg.res_xid_block[sapi_index].vj.is_set = TRUE; + + sndcp_data->mg.res_xid_block[sapi_index].vj.p_bit = SNDCP_P_BIT_0; + + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt = + sndcp_data->mg.ind_xid_block[sapi_index].vj.ntt; + + sndcp_data->mg.res_xid_block[sapi_index].vj.algo_type = SNDCP_XID_VJ; + + if (sndcp_data->mg.ind_xid_block[sapi_index].vj.p_bit == SNDCP_P_BIT_1) { + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1 = + sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp1; + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2 = + sndcp_data->mg.ind_xid_block[sapi_index].vj.pcomp2; + } else { + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1 = + sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp1; + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2 = + sndcp_data->mg.cur_xid_block[sapi_index].vj.pcomp2; + } + + /* + * Set the 'nsapis' parameter in res_xid_block: + * Check rules in 4.65, subclause 6.8.1, compare with cur_xid_block. + * State slots and direction are also set here. + */ + mg_set_xid_nsapis(sapi, MG_XID_VJ_NSAPIS); + + + } /* vj.is_set */ + + + /* + * Set affected entities and dcomp/pcomp values. + */ + if (v42_ind && v42_possible) { + mg_set_sapi_dntt_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].v42.ntt, + MG_ASSIGNED); + + mg_set_sapi_dcomp_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].v42.dcomp, + MG_ASSIGNED); + mg_set_sapi_dcomp_dntt(sapi, + sndcp_data->mg.res_xid_block[sapi_index].v42.dcomp, + sndcp_data->mg.res_xid_block[sapi_index].v42.ntt); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) { + mg_set_sapi_dntt_nsapi(sapi, + sndcp_data->mg.res_xid_block[sapi_index].v42.ntt, + nsapi, + TRUE); + } /* if nsapi is selected */ + } /* for loop over all nsapis */ + + } + /* + * If VJ is indicated and possible, switch on compressor. + */ + if (vj_ind && vj_possible) { + mg_set_sapi_pntt_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt, + MG_ASSIGNED); + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1, + MG_ASSIGNED); + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2, + MG_ASSIGNED); + mg_set_sapi_pcomp_pntt(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt); + mg_set_sapi_pcomp_pntt(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) { + mg_set_sapi_pntt_nsapi(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt, + nsapi, + TRUE); + } /* if nsapi is selected */ + } /* for loop over all nsapis */ + } + + /* + * If VJ has been switched on and is now indicated to be switched off: + * switch off compressor. + */ + if (vj_ind + && + sndcp_data->mg.ind_xid_block[sapi_index].vj.nsapis == 0 + && + sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis > 0) + { + mg_set_sapi_pntt_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt, + MG_UNASSIGNED); + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1, + MG_UNASSIGNED); + mg_set_sapi_pcomp_state(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2, + MG_UNASSIGNED); +/* mg_set_sapi_pcomp_pntt(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp1, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt); + mg_set_sapi_pcomp_pntt(sapi, + sndcp_data->mg.res_xid_block[sapi_index].vj.pcomp2, + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt); +*/ + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (((1 << nsapi) & sndcp_data->mg.ind_xid_block[sapi_index].v42.nsapis) > 0) { + mg_set_sapi_pntt_nsapi(sapi, + sndcp_data->mg.cur_xid_block[sapi_index].vj.ntt, + nsapi, + FALSE); + } /* if nsapi is selected */ + } /* for loop over all nsapis */ + } + + + /* + * Add same values for cur_xid_block. + */ + + if (sndcp_data->mg.res_xid_block[sapi_index].v42.is_set) { + if (sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set) { + sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis = + sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis; + if (sndcp_data->mg.cur_xid_block[sapi_index].v42.p0_set) { + sndcp_data->mg.cur_xid_block[sapi_index].v42.p0 = + sndcp_data->mg.res_xid_block[sapi_index].v42.p0; + } + if (sndcp_data->mg.cur_xid_block[sapi_index].v42.p1_set) { + sndcp_data->mg.cur_xid_block[sapi_index].v42.p1 = + sndcp_data->mg.res_xid_block[sapi_index].v42.p1; + } + if (sndcp_data->mg.cur_xid_block[sapi_index].v42.p2_set) { + sndcp_data->mg.cur_xid_block[sapi_index].v42.p2 = + sndcp_data->mg.res_xid_block[sapi_index].v42.p2; + } + } else { + sndcp_data->mg.cur_xid_block[sapi_index].v42 = + sndcp_data->mg.res_xid_block[sapi_index].v42; + } + } + + if (sndcp_data->mg.res_xid_block[sapi_index].vj.is_set) { + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set) { + sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis = + sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis; + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1_set) { + sndcp_data->mg.cur_xid_block[sapi_index].vj.s0_m_1 = + sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1; + } + } else { + sndcp_data->mg.cur_xid_block[sapi_index].vj = + sndcp_data->mg.res_xid_block[sapi_index].vj; + } + } + + + if (vj_rejected) { + sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis = 0; + } + if (sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis == 0) { + sndcp_data->mg.cur_xid_block[sapi_index].vj.is_set = FALSE; + } + + if (v42_rejected) { + sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis = 0; + } + if (sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis == 0) { + sndcp_data->mg.cur_xid_block[sapi_index].v42.is_set = FALSE; + } + + sig_mg_cia_new_xid(& sndcp_data->mg.cur_xid_block[sapi_index]); + + +} /* mg_set_res_cur_xid_block */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_res_xid_params ++------------------------------------------------------------------------------ +| Description : This procedure fills the XID block. It is implementation +| dependent. In the current version V42bis and VanJacobson +| header compression are applied. +| +| Parameters : +| the sdu that will be filled, +| Post : Reset arrays with reject information to all FALSE. +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_set_res_xid_params (T_sdu* sdu, UBYTE sapi) +{ + /* + * Byte index in destination sdu. + */ + UBYTE index = 3; + UBYTE type_2_header_index = 0; + UBYTE sapi_index = 0; + UBYTE ntt = 0; + BOOL type_1_header_set = FALSE; + BOOL type_2_header_set = FALSE; + TRACE_FUNCTION( "mg_set_res_xid_params" ); + sndcp_get_sapi_index(sapi, &sapi_index); + /* + * Set the values for parameter type 0 (version number). + */ + sdu->buf[0] = SNDCP_XID_PARAM_TYPE_0; + /*lint -e{415} (Warning -- access of out-of-bounds pointer)*/ + sdu->buf[1] = SNDCP_XID_0_LEN; + /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/ + sdu->buf[2] = + sndcp_data->mg.res_xid_block[sapi_index].version; + + sdu->l_buf = 3 * 8; + sdu->o_buf = 0; + /* + * Set the values for data compression, if necessary. + */ + /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/ + if (sndcp_data->mg.res_xid_block[sapi_index].v42.is_set) { + sdu->buf[3] = SNDCP_XID_PARAM_TYPE_1; + sdu->buf[4] = SNDCP_XID_1_LEN_RES; + sdu->buf[5] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.p_bit << 7) + + sndcp_data->mg.res_xid_block[sapi_index].v42.ntt; + sdu->buf[6] = SNDCP_XID_V42_LEN_RES; + sdu->buf[7] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis >> 8); + sdu->buf[8] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.nsapis & 0xff); + sdu->buf[9] = sndcp_data->mg.res_xid_block[sapi_index].v42.p0; + sdu->buf[10] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.p1 >> 8); + sdu->buf[11] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].v42.p1 & 0xff); + sdu->buf[12] = sndcp_data->mg.res_xid_block[sapi_index].v42.p2; + + index = 13; + sdu->l_buf = 13 * 8; + + type_1_header_set = TRUE; + } + /* + * Add rejected data compression entities. + */ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_dntt_rej(sapi, ntt, &rej); + /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/ + if (rej) { + if (! type_1_header_set) { + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_1; + index++; + sdu->buf[index] = 0; + index++; + type_1_header_set = TRUE; + sdu->l_buf += 16; + } + + sdu->buf[index] = ntt; + index++; + /* + * Length of field. + */ + sdu->buf[index] = 2; + index++; + /* + * Set 2 'nsapis' octets to 0. + */ + sdu->buf[index] = 0; + index++; + sdu->buf[index] = 0; + index++; + /* + * Increment sdu length. + */ + sdu->l_buf = sdu->l_buf + 32; + /* + * Increment parameter type 1 length octet. + */ + /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/ + sdu->buf[4] += 4; + } + } + type_2_header_index = index; + + /* + * Set the values for header compression, if requested. + */ + /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/ + if (sndcp_data->mg.res_xid_block[sapi_index].vj.is_set) { + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2; + index++; + sdu->buf[index] = SNDCP_XID_2_LEN_RES; + index++; + sdu->buf[index] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].vj.p_bit << 7) + + sndcp_data->mg.res_xid_block[sapi_index].vj.ntt; + index++; + sdu->buf[index] = SNDCP_XID_VJ_LEN_RES; + index++; + sdu->buf[index] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis >> 8); + index++; + sdu->buf[index] = + (UBYTE)(sndcp_data->mg.res_xid_block[sapi_index].vj.nsapis & 0xff); + index++; + sdu->buf[index] = + sndcp_data->mg.res_xid_block[sapi_index].vj.s0_m_1; + index++; + + sdu->l_buf = sdu->l_buf + 7 * 8; + + type_2_header_set = TRUE; + } + /* + * Add rejected header compression entities. + */ + /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_pntt_rej(sapi, ntt, &rej); + if (rej) { + if (! type_2_header_set) { + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2; + index++; + sdu->buf[index] = 0; + index++; + type_2_header_set = TRUE; + sdu->l_buf += 16; + } + sdu->buf[index] = ntt; + index++; + /* + * Length of field. + */ + sdu->buf[index] = 2; + index++; + /* + * Set 2 'nsapis' octets to 0. + */ + sdu->buf[index] = 0; + index++; + sdu->buf[index] = 0; + index++; + /* + * Increment sdu length. + */ + sdu->l_buf = sdu->l_buf + 32; + /* + * Increment parameter type 2 length octet. + */ + sdu->buf[type_2_header_index + 1] += 4; + } + } + /* + * Set sdu offset to 0. + */ + sdu->o_buf = 0; + /* + * Reset the arrays with rejected params to all FALSE. + */ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][ntt] = FALSE; + sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][ntt] = FALSE; + } + +} /* mg_set_res_xid_params() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_set_xid_params ++------------------------------------------------------------------------------ +| Description : This procedure fills the XID block. It is implementation +| dependent. In the current version V42bis and VanJacobson +| header compression are applied. +| +| Parameters : +| sapi and sdu from the LL_XID_REQ that will be filled and +| xid_block that defines the desired compressors +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_set_xid_params (UBYTE sapi, T_sdu* sdu, T_XID_BLOCK xid_block) +{ + /* + * Byte index in destination sdu. + */ + UBYTE index = 3; + UBYTE sapi_index = 0; + UBYTE ntt = 0; + BOOL type_1_header_set = FALSE; + BOOL type_2_header_set = FALSE; + UBYTE type_2_header_index = 0; + UBYTE type_1_header_index = 3; + USHORT p1 = SNDCP_V42_DEFAULT_P1; + TRACE_FUNCTION( "mg_set_xid_params" ); + sndcp_get_sapi_index(sapi, &sapi_index); + /* + * Set the values for parameter type 0 (version number). + */ + sdu->buf[0] = SNDCP_XID_PARAM_TYPE_0; + /*lint -e{415} (Warning -- access of out-of-bounds pointer)*/ + sdu->buf[1] = SNDCP_XID_0_LEN; + /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/ + sdu->buf[2] = SNDCP_XID_VERSION; + + sdu->l_buf = 24; /* 3 * 8 */ + sdu->o_buf = 0; + /* + * Set the values for data compression, if necessary. + */ + /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/ + if (xid_block.v42.is_set && + #ifdef SNDCP_UPM_INCLUDED + xid_block.v42.p0 != NAS_DCOMP_OFF && + #else + xid_block.v42.p0 != SNSM_COMP_NEITHER_DIRECT && + #endif /*#ifdef SNDCP_UPM_INCLUDED*/ + xid_block.v42.nsapis_set && + xid_block.v42.nsapis > 0) { + + if (xid_block.v42.p_bit > 0) { + sdu->buf[3] = SNDCP_XID_PARAM_TYPE_1; + sdu->buf[4] = SNDCP_XID_1_LEN; + sdu->buf[5] = (UBYTE)(xid_block.v42.p_bit << 7) + xid_block.v42.ntt; + sdu->buf[6] = xid_block.v42.algo_type; + sdu->buf[7] = SNDCP_XID_V42_LEN; + sdu->buf[8] = (UBYTE)(xid_block.v42.dcomp << 4); + sdu->buf[9] = (UBYTE)(xid_block.v42.nsapis >> 8); + sdu->buf[10] = (UBYTE)(xid_block.v42.nsapis & 0xff); + sdu->buf[11] = xid_block.v42.p0; + /* + * P1, P2 + */ + sdu->buf[12] = (p1 & 0xff00) >> 8; + sdu->buf[13] = p1 & 0x00ff; + sdu->buf[14] = SNDCP_V42_DEFAULT_P2; + + index = 15; + sdu->l_buf = 15 * 8; + } else { + sdu->buf[3] = SNDCP_XID_PARAM_TYPE_1; + sdu->buf[4] = SNDCP_XID_1_LEN_RES; + sdu->buf[5] = xid_block.v42.ntt; + sdu->buf[6] = SNDCP_XID_V42_LEN_RES; + sdu->buf[7] = (UBYTE)(xid_block.v42.nsapis >> 8); + sdu->buf[8] = (UBYTE)(xid_block.v42.nsapis & 0xff); + sdu->buf[9] = xid_block.v42.p0; + /* + * P1, P2 + */ + sdu->buf[10] = (p1 & 0xff00) >> 8; + sdu->buf[11] = p1 & 0x00ff; + sdu->buf[12] = SNDCP_V42_DEFAULT_P2; + + index = 13; + sdu->l_buf = 13 * 8; + + } + } + type_2_header_index = index; + /* + * Set the values for header compression, if requested. + */ + /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/ + if (xid_block.vj.is_set && + #ifdef SNDCP_UPM_INCLUDED + xid_block.vj.direction != NAS_HCOMP_OFF && + #else + xid_block.vj.direction != SNSM_COMP_NEITHER_DIRECT && + #endif /*#ifdef SNDCP_UPM_INCLUDED*/ + xid_block.vj.nsapis_set && + xid_block.vj.nsapis > 0) { + + if (xid_block.vj.p_bit > 0) { + + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2; + sdu->buf[index + 1] = SNDCP_XID_2_LEN; + sdu->buf[index + 2] = + (UBYTE)(xid_block.vj.p_bit << 7) + xid_block.vj.ntt; + sdu->buf[index + 3] = SNDCP_XID_VJ; + sdu->buf[index + 4] = SNDCP_XID_VJ_LEN; + sdu->buf[index + 5] = + (UBYTE)(xid_block.vj.pcomp1 << 4) + xid_block.vj.pcomp2; + sdu->buf[index + 6] = + (UBYTE)(xid_block.vj.nsapis >> 8); + sdu->buf[index + 7] = + (UBYTE)(xid_block.vj.nsapis & 0xff); + sdu->buf[index + 8] = xid_block.vj.s0_m_1; + + sdu->l_buf = sdu->l_buf + 9 * 8; + + type_2_header_set = TRUE; + } else { + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2; + sdu->buf[index + 1] = SNDCP_XID_2_LEN_RES; + sdu->buf[index + 2] = xid_block.vj.ntt; + + sdu->buf[index + 3] = SNDCP_XID_VJ_LEN_RES; + + sdu->buf[index + 4] = + (UBYTE)(xid_block.vj.nsapis >> 8); + sdu->buf[index + 5] = + (UBYTE)(xid_block.vj.nsapis & 0xff); + sdu->buf[index + 6] = xid_block.vj.s0_m_1; + + sdu->l_buf = sdu->l_buf + 7 * 8; + + type_2_header_set = TRUE; + } + } + /* + * Add rejected data compression entities. + */ + /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_dntt_rej(sapi, ntt, &rej); + if (rej) { + if (! type_1_header_set) { + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_1; + index++; + sdu->buf[index] = 0; + index++; + type_1_header_set = TRUE; + sdu->l_buf += 16; + } + sdu->buf[index] = ntt; + index++; + /* + * Length of field. + */ + sdu->buf[index] = 2; + index++; + /* + * Set 2 'nsapis' octets to 0. + */ + sdu->buf[index] = 0; + index++; + sdu->buf[index] = 0; + index++; + /* + * Increment sdu length. + */ + sdu->l_buf = sdu->l_buf + 32; + /* + * Increment parameter type 2 length octet. + */ + /*lint -e{415, 416} (Warning -- access/creation of out-of-bounds pointer)*/ + sdu->buf[type_1_header_index + 1] += 4; + } + } /* for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) */ + /* + * Add rejected header compression entities. + */ + /*lint -e{661, 662} (Warning -- Possible access/creation of out-of-bounds pointer)*/ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + BOOL rej = FALSE; + mg_get_sapi_pntt_rej(sapi, ntt, &rej); + if (rej) { + if (! type_2_header_set) { + sdu->buf[index] = SNDCP_XID_PARAM_TYPE_2; + index++; + sdu->buf[index] = 0; + index++; + type_2_header_set = TRUE; + sdu->l_buf += 16; + } + sdu->buf[index] = ntt; + index++; + /* + * Length of field. + */ + sdu->buf[index] = 2; + index++; + /* + * Set 2 'nsapis' octets to 0. + */ + sdu->buf[index] = 0; + index++; + sdu->buf[index] = 0; + index++; + /* + * Increment sdu length. + */ + sdu->l_buf = sdu->l_buf + 32; + /* + * Increment parameter type 2 length octet. + */ + sdu->buf[type_2_header_index + 1] += 4; + } + } /* for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) */ + /* + * Set sdu offset to 0. + */ + sdu->o_buf = 0; + /* + * Reset the arrays with rejected params to all FALSE. + */ + for (ntt = 0; ntt < MG_MAX_ENTITIES; ntt++) { + sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][ntt] = FALSE; + sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][ntt] = FALSE; + } + +} /* mg_set_xid_params() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_del_comp_pdus_ack ++------------------------------------------------------------------------------ +| Description : The function mg_del_comp_pdus_ack() +| GSM 4.65, 5.1.2.7: +| "compressed N-PDUs queuing to be forwarded to the affected +| SAPI are deleted from the SNDCP layer." +| Assumption: It is assumed here that acknowledged and +| unacknowledged npdus are deleted the same. +| +| Parameters : UBYTE sapi: the affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_del_comp_pdus_ack (UBYTE sapi) +{ + UBYTE nsapi = 0; + + TRACE_FUNCTION( "mg_del_comp_pdus_ack" ); + + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + UBYTE sp = 0; + sndcp_get_nsapi_sapi(nsapi, &sp); + if (sp == sapi) { + sig_mg_cia_delete_npdus(nsapi); + sig_mg_su_delete_pdus(nsapi, sapi); + sig_mg_sua_delete_pdus(nsapi, sapi, TRUE); + sig_mg_sd_delete_npdus(nsapi, sapi); + sig_mg_sda_delete_npdus(nsapi, sapi); + } + } +} /* mg_del_comp_pdus_ack() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_delete_npdus ++------------------------------------------------------------------------------ +| Description : The function mg_delete_npdus() sends signals to all affected +| services to delete the buffered npdus. +| +| Parameters : UBYTE nsapi: the affected nsapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_delete_npdus (UBYTE nsapi) +{ + UBYTE sapi = 0; + TRACE_FUNCTION( "mg_delete_npdus" ); + sndcp_get_nsapi_sapi(nsapi, &sapi); + + sig_mg_cia_delete_npdus(nsapi); + sig_mg_su_delete_pdus(nsapi, sapi); + sig_mg_sua_delete_pdus(nsapi, sapi, TRUE); + sig_mg_sd_delete_npdus(nsapi, sapi); + sig_mg_sda_delete_npdus(nsapi, sapi); + + sig_mg_nu_delete_npdus(nsapi); + +} /* mg_delete_npdus() */ + + +/* ++------------------------------------------------------------------------------ +| Function : mg_suspend_affected_nus ++------------------------------------------------------------------------------ +| Description : Suspends all nu service instances affected by XID negotiation +| Sets service variable 'suspended_nsapis'. +| +| Parameters : sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_suspend_affected_nus (UBYTE sapi) { + UBYTE nsapi = 0; + UBYTE sapi_index = 0; + TRACE_FUNCTION( "mg_resume_affected_nus" ); + sndcp_get_sapi_index(sapi, &sapi_index); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + if (1 << nsapi & sndcp_data->mg.req_xid_block[sapi_index].vj.nsapis || + 1 << nsapi & sndcp_data->mg.cur_xid_block[sapi_index].vj.nsapis || + 1 << nsapi & sndcp_data->mg.req_xid_block[sapi_index].v42.nsapis || + 1 << nsapi & sndcp_data->mg.cur_xid_block[sapi_index].v42.nsapis) { + + sndcp_data->mg.suspended_nsapis |= (1 << nsapi); + sig_mg_nu_suspend(nsapi); + } + } +} /* mg_suspend_affected_nus() */ + + + + + + +/* + * Getters and setters for the organizing arrays. + */ +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_dntt_rej ++------------------------------------------------------------------------------ +| Description : The procedures informs about if a given data +| compression entity on a given SAPI is to be rejected in +| LL_XID_REQ because it cannot be set up. +| +| Parameters : FPAR IN sapi UBYTE, +| IN dntt UBYTE, +| IN/OUT rej BOOL +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_get_sapi_dntt_rej (UBYTE sapi, UBYTE dntt, BOOL* rej) +{ + TRACE_FUNCTION( "mg_get_sapi_dntt_rej" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *rej = sndcp_data->mg.sapi_dntt_rej_ra[sapi_index][dntt]; + } +} /* mg_get_sapi_dntt_rej() */ + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_pntt_rej ++------------------------------------------------------------------------------ +| Description : The procedures informs about if a given header +| compression entity on a given SAPI is to be rejected in +| LL_XID_REQ because it cannot be set up. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pntt UBYTE, +| IN/OUT rej BOOL +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_get_sapi_pntt_rej (UBYTE sapi, UBYTE pntt, BOOL* rej) +{ + TRACE_FUNCTION( "mg_get_sapi_pntt_rej" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *rej = sndcp_data->mg.sapi_pntt_rej_ra[sapi_index][pntt]; + } +} /* mg_get_sapi_pntt_rej() */ + + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_pntt_nsapi ++------------------------------------------------------------------------------ +| Description : The procedure informs if a given nsapi uses a given pntt on a +| given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pntt UBYTE, +| IN nsapi UBYTE, +| IN/OUT used BOOL +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_get_sapi_pntt_nsapi (UBYTE sapi, UBYTE pntt, UBYTE nsapi, BOOL* used) +{ + TRACE_FUNCTION( "mg_get_sapi_pntt_nsapi" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *used = sndcp_data->mg.sapi_pntt_nsapi_set_ra[sapi_index][pntt][nsapi]; + } +} /* mg_get_sapi_pntt_nsapi() */ + + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_get_sapi_pcomp_pntt ++------------------------------------------------------------------------------ +| Description : The procedures indicates the pntt assigned to a given pcomp +| for a given sapi. +| +| Parameters : FPAR IN sapi UBYTE, +| IN pcomp UBYTE, +| IN/OUT dntt UBYTE +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_get_sapi_pcomp_pntt (UBYTE sapi, UBYTE pcomp, UBYTE* pntt) +{ + TRACE_FUNCTION( "mg_get_sapi_pcomp_pntt" ); + { + UBYTE sapi_index = 0; + sndcp_get_sapi_index(sapi, &sapi_index); + *pntt = sndcp_data->mg.sapi_pcomp_pntt_ra[sapi_index][pcomp]; + } +} /* mg_get_sapi_pcomp_pntt() */ + + + +/* ++------------------------------------------------------------------------------ +| Function : mg_xid_cnf_ok_res ++------------------------------------------------------------------------------ +| Description : +| After an LL_XID_REQ has been sent there are contexts in state MG_XID. +| These are now reset after reception of the LL_XID_CNF. +| The "applicable nsapis" in req_xid_block.v42 and req_xid_block.vj, each one +| only once. +| SIG_MG_NU_RESET(nsapi, discard_ready) is used. +| In every nu instance: N-PDU number is set to 0 for this instance and an +| SN_UNITREADY_IND is sent. State is set to NU_UNACK_SU_RECEPTIVE +| Then the SNSM_ACTIVATE_RES is sent for each one of these. +| +| Parameters : affected sapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_xid_cnf_ok_res (UBYTE sapi) +{ + UBYTE nsapi = 0; + + TRACE_FUNCTION( "mg_xid_cnf_ok_res" ); + for (nsapi = 0; nsapi < SNDCP_NUMBER_OF_NSAPIS; nsapi++) { + USHORT nsapi_state = MG_IDLE; + USHORT sapi_state = MG_IDLE; + UBYTE sapi_index = 0; + UBYTE func_sapi = 0; + sndcp_get_nsapi_sapi(nsapi, &func_sapi); + if (func_sapi != sapi) { + continue; + } + sndcp_get_sapi_index(sapi, &sapi_index); + sndcp_get_nsapi_state(nsapi, &nsapi_state); + sndcp_get_sapi_state(func_sapi, &sapi_state); + + + if (((sapi_state & MG_XID_NEC) > 0) + && + ((sapi_state & MG_REL) == 0)) { + mg_resend_xid_if_nec(sapi); + + sndcp_get_sapi_state(func_sapi, &sapi_state); + /* + * If now XID is sent, no further actions for this nsapi. + */ + if ((sapi_state & MG_XID) > 0) { + continue; + } + + } else if ((nsapi_state & MG_ACT) > 0 && + (sapi_state & MG_EST) == 0) { + + BOOL ack = FALSE; + + sndcp_get_nsapi_ack(nsapi, &ack); + /* + * Open DTI connection. + */ +#ifndef SNDCP_UPM_INCLUDED + mg_dti_open(nsapi); +#endif + if (ack) { + sig_mg_nu_reset_ack(nsapi, 0, 0, FALSE); + sig_mg_sda_getdata(sapi, nsapi); + } else { + sig_mg_nu_reset(nsapi, FALSE); + sig_mg_sd_getunitdata(sapi, nsapi); + } + + if ((sapi_state & MG_XID) == 0) { + mg_send_snsm_activate_res(nsapi); + /* + * Set nsapi state to MG_IDLE. + */ + sndcp_unset_nsapi_state(nsapi, MG_ACT); + } + } /* if state is MG_ACT and not MG_EST */ + + if ((nsapi_state & MG_DEACT) > 0) { + + USHORT local_sapi_state = MG_IDLE; + + sndcp_get_sapi_state(sapi, &local_sapi_state); + + if ((local_sapi_state & + (MG_REL_NEC_LOC + MG_REL_NEC_PEER + MG_XID_NEC + MG_XID)) + == 0) + { + /* + * No LL_RELEASE_REQ necessary. Notify sndcp. + */ +#ifdef SNDCP_UPM_INCLUDED + PALLOC(snsm_deactivate_res, SN_DEACTIVATE_CNF); +#else + PALLOC(snsm_deactivate_res, SNSM_DEACTIVATE_RES); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + /* + * Now the NSAPI is not in use anymore: + */ + sndcp_set_nsapi_used(nsapi, FALSE); + sndcp_set_nsapi_ack(nsapi, FALSE); + + snsm_deactivate_res->nsapi = nsapi; + sndcp_unset_nsapi_state(nsapi, MG_DEACT); +#ifdef SNDCP_UPM_INCLUDED + PSEND(hCommUPM, snsm_deactivate_res); +#else + PSEND(hCommSM, snsm_deactivate_res); +#endif /*#ifdef SNDCP_UPM_INCLUDED*/ + /* + * Resume nsapi. + */ + mg_resume_affected_nus(sapi); + + } else if ((local_sapi_state & (MG_REL_NEC_LOC + MG_REL_NEC_PEER)) > 0) { + /* + * LL_RELEASE_REQ must be sent. + */ + + PALLOC(ll_release_req, LL_RELEASE_REQ); + + sndcp_unset_sapi_state(sapi, MG_REL_NEC_LOC); + ll_release_req->sapi = sapi; + ll_release_req->local = TRUE; + /* + * Set the "state" for the affected and sapi to MG_REL_PENDING. + */ + sndcp_set_sapi_state(sapi, MG_REL); + + PSEND(hCommLLC, ll_release_req); + } else { + + UBYTE local_sapi = 0; + UBYTE local_nsapi = 0; + BOOL local_nec = FALSE; + for (local_nsapi = 0; + local_nsapi < SNDCP_NUMBER_OF_NSAPIS; + local_nsapi++) { + + sndcp_get_nsapi_sapi(local_nsapi, &local_sapi); + if (sapi == local_sapi) { + /* + * is compressor deactivation necessary? + */ + sndcp_get_nsapi_state(local_nsapi, &nsapi_state); + if ((nsapi_state & MG_DEACT) > 0) { + mg_is_rel_comp_nec(local_nsapi, &local_nec); + } + } + } + + /* + * Negotiate possible deactivation of compressors. + */ + if (local_nec) { + mg_send_xid_req_del(sapi); + } + } + + } + + } + +} /* mg_xid_cnf_ok_res */ + + +#ifdef TI_DUAL_MODE +/* ++------------------------------------------------------------------------------ +| Function : mg_get_unsent_unconfirmed_npdus ++------------------------------------------------------------------------------ +| Description : This procedure retrieves any unsent or unconfirmed acknowledged +| NPDU from SNDCP's internal buffers. ANY retrieved NPDU is packed +| the primitive SN_GET_PENDING_PDU_CNF data. +| +| Parameters : nsapi, pointer to the primitive. +| ++------------------------------------------------------------------------------ +*/ +GLOBAL T_SN_GET_PENDING_PDU_CNF* mg_get_unsent_unconfirmed_npdus + (U8 nsapi, + T_SN_GET_PENDING_PDU_CNF* sn_get_pending_pdu_cnf) +{ + + int count = 0; + U8 used_sapi=0, sapi_index=0; + T_NPDU_BUFFER* help = NULL; + + TRACE_FUNCTION( "mg_get_unsent_unconfirmed_npdus" ); + + /* + * set service instance according to nsapi in primitive + */ + sndcp_data->nu = & sndcp_data->nu_base[nsapi]; + + /* + * Find number of unconfirmed NPDUs + */ + help = sndcp_data->nu->first_buffered_npdu; + while(help != NULL) + { + count++; + help = help->next; + } + + sn_get_pending_pdu_cnf->ul_pdus[nsapi].ptr_desc_list2 = + (T_SN_desc_list2*)DRP_ALLOC( count * sizeof( T_SN_desc_list2 ), 0 ); + + sn_get_pending_pdu_cnf->ul_pdus[nsapi].nsapi = nsapi; + sn_get_pending_pdu_cnf->ul_pdus[nsapi].dl_sequence_number = + sndcp_data->nu->rec_npdu_number_ack; + sn_get_pending_pdu_cnf->ul_pdus[nsapi].c_desc_list2 = count; + + count = 0; + + /* + * Check if there are buffered any acknowledged type NPDUs. + */ + help = sndcp_data->nu->first_buffered_npdu; + while(help != NULL) + { + + sn_get_pending_pdu_cnf->ul_pdus[nsapi].ptr_desc_list2[count].first = + help->sn_data_req->desc_list2.first; + sn_get_pending_pdu_cnf->ul_pdus[nsapi].ptr_desc_list2[count].list_len = + help->sn_data_req->desc_list2.list_len; + count++; + help = help->next; + } + return sn_get_pending_pdu_cnf; +} + +/* ++------------------------------------------------------------------------------ +| Function : mg_clean_ack_npdu_queues_leave_data ++------------------------------------------------------------------------------ +| Description : This procedure deletes SNDCP's internal buffers containing +| unconfirmed acknowledged type NPDU's. +| The data stored in the queues are not deleted. +| +| Parameters : nsapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_clean_ack_npdu_queues_leave_data(U8 nsapi) +{ + + U8 used_sapi=0, sapi_index=0; + T_NPDU_BUFFER* help = NULL; + T_SN_DATA_REQ* sn_data_req = NULL; + + TRACE_FUNCTION( "mg_clean_ack_npdu_queues_leave_data" ); + + /* + * set service instance according to sapi + */ + sndcp_get_nsapi_sapi(nsapi, &used_sapi); + sndcp_get_sapi_index(used_sapi, &sapi_index); + sndcp_data->sua = & sndcp_data->sua_base[sapi_index]; + + if (sndcp_data->sua->sn_data_q_write != sndcp_data->sua->sn_data_q_read) + { + /* + * remove unhandled sn_data_req from queue. + */ + sn_data_req = sndcp_data->sua->sn_data_q[sndcp_data->sua->sn_data_q_read]; + FREE(sn_data_req); + } + + /* + * set service instance according to nsapi + */ + + sndcp_data->nu = & sndcp_data->nu_base[nsapi]; + + /* + * clean buffer with unconfirmed NPDUs + */ + + while(sndcp_data->nu->first_buffered_npdu != NULL) + { + help = sndcp_data->nu->first_buffered_npdu; + sndcp_data->nu->first_buffered_npdu = help->next; + MFREE(help->sn_data_req); + MFREE(help); + } +} + + +/* ++------------------------------------------------------------------------------ +| Function : mg_clean_unack_npdu_queues_including_data ++------------------------------------------------------------------------------ +| Description : This procedure deletes SNDCP's internal buffers containing +| unacknowledged type NPDU's. +| The data stored in the queues are also deleted. +| +| Parameters : nsapi +| ++------------------------------------------------------------------------------ +*/ +GLOBAL void mg_clean_unack_npdu_queues_including_data(U8 nsapi) +{ + /* + * Delete affected N-PDUS from sn_unitdata_q. + */ + BOOL still = TRUE; + U8 index = sndcp_data->su->sn_unitdata_q_read; + + while (still) + { + if (index == sndcp_data->su->sn_unitdata_q_write) { + break; + } + if (sndcp_data->su->sn_unitdata_q[index]->nsapi == nsapi) { + /* + * The index for the prims to be shifted when 1 entry is deleted. + */ + U8 i = 0; + + if (sndcp_data->su->sn_unitdata_q[index] != NULL) { + PFREE_DESC2(sndcp_data->su->sn_unitdata_q[index]); + sndcp_data->su->sn_unitdata_q[index] = NULL; + } + + for (i = index; + i != sndcp_data->su->sn_unitdata_q_write; + i = (i + 1) % SN_UNITDATA_Q_LEN) + { + sndcp_data->su->sn_unitdata_q[i] = + sndcp_data->su->sn_unitdata_q[(i + 1) % SN_UNITDATA_Q_LEN]; + + sndcp_data->su->sn_unitdata_q[(i + 1) % SN_UNITDATA_Q_LEN]=NULL; + } + sndcp_data->su->sn_unitdata_q_write = + (sndcp_data->su->sn_unitdata_q_write - 1 + + SN_UNITDATA_Q_LEN) % SN_UNITDATA_Q_LEN; + } + else + { + index = (index + 1) % SN_UNITDATA_Q_LEN; + } /* else (sndcp_data->su->sn_unitdata_q[index]->nsapi == nsapi) */ + } +} + +/* ++------------------------------------------------------------------------------ +| Function : sm_make_test_pending_pdu_cnf ++------------------------------------------------------------------------------ +| Description : Initialize SN_TEST_GET_PENDING_PDU_CNF primitive +| Parameters : sn_get_pending_pdu_cnf - primitive +| sn_test_get_pending_pdu_cnf - primitive +| ++------------------------------------------------------------------------------ +*/ + +GLOBAL void sm_make_test_pending_pdu_cnf + (T_SN_GET_PENDING_PDU_CNF* sn_get_pending_pdu_cnf, + T_SN_TEST_GET_PENDING_PDU_CNF* sn_test_get_pending_pdu_cnf) +{ + int i,j; + + for (i = 0; i < SN_SIZE_NSAPI; i++) { + sn_test_get_pending_pdu_cnf->c_test_ul_pdus = + sn_get_pending_pdu_cnf->c_ul_pdus; + sn_test_get_pending_pdu_cnf->test_ul_pdus[i].nsapi = + sn_get_pending_pdu_cnf->ul_pdus[i].nsapi; + sn_test_get_pending_pdu_cnf->test_ul_pdus[i].test_dl_sequence_number = + sn_get_pending_pdu_cnf->ul_pdus[i].dl_sequence_number; + sn_test_get_pending_pdu_cnf->test_ul_pdus[i].c_test_desc_list2 = + sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2; + + if (sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2) { + for(j = 0; j < sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2; j++) { + sn_test_get_pending_pdu_cnf->test_ul_pdus[i].c_test_desc_list2 = + sn_get_pending_pdu_cnf->ul_pdus[i].c_desc_list2; + sn_test_get_pending_pdu_cnf->test_ul_pdus[i].test_desc_list2[j].c_test_pending_pdu = + (U8)sn_get_pending_pdu_cnf->ul_pdus[i].ptr_desc_list2[j].list_len; + memcpy( + sn_test_get_pending_pdu_cnf->test_ul_pdus[i].test_desc_list2[j].test_pending_pdu, + ((T_desc2 *)sn_get_pending_pdu_cnf->ul_pdus[i].ptr_desc_list2[j].first)->buffer, + sn_get_pending_pdu_cnf->ul_pdus[i].ptr_desc_list2[j].list_len); + } + } + } +} + +#endif /*#ifdef TI_DUAL_MODE*/