FreeCalypso > hg > fc-magnetite
view src/g23m-gprs/sndcp/sndcp_mgf.c @ 518:4b7e0dba42f6
src/g23m-gsm defenestration: include case fixes
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Sun, 22 Jul 2018 06:21:01 +0000 |
parents | 219afcfc6250 |
children |
line wrap: on
line source
/* +----------------------------------------------------------------------------- | 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*/