FreeCalypso > hg > freecalypso-sw
diff gsm-fw/g23m-aci/aci/cmh_smf.c @ 775:eedbf248bac0
gsm-fw/g23m-aci subtree: initial import from LoCosto source
| author | Michael Spacefalcon <msokolov@ivan.Harhan.ORG> |
|---|---|
| date | Sun, 12 Oct 2014 01:45:14 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gsm-fw/g23m-aci/aci/cmh_smf.c Sun Oct 12 01:45:14 2014 +0000 @@ -0,0 +1,3686 @@ +/* ++----------------------------------------------------------------------------- +| Project : +| Modul : ++----------------------------------------------------------------------------- +| Copyright 2002 Texas Instruments Berlin, AG +| All rights reserved. +| +| This file is confidential and a trade secret of Texas +| Instruments Berlin, AG +| The receipt of or possession of this file does not convey +| any rights to reproduce or disclose its contents or to +| manufacture, use, or sell anything it may describe, in +| whole, or in part, without the specific written consent of +| Texas Instruments Berlin, AG. ++----------------------------------------------------------------------------- +| Purpose : This module defines the functions used by the command +| handler for GPRS session management ( SM ). ++----------------------------------------------------------------------------- +*/ + +#if defined (GPRS) && defined (DTI) + +#ifndef CMH_SMF_C +#define CMH_SMF_C +#endif + +#include "aci_all.h" +/*==== INCLUDES ===================================================*/ +#include "gprs.h" + +#include "dti.h" /* functionality of the dti library */ +#include "aci_cmh.h" +#include "ati_cmd.h" +#include "aci_cmd.h" +#include "aci_lst.h" +#include "aci_mem.h" +#include "aci.h" + +#include "dti_conn_mng.h" +#include "dti_cntrl_mng.h" + +#include "gaci.h" +#include "gaci_cmh.h" +#include "psa.h" +#include "psa_gmm.h" +#include "psa_sm.h" +#include "psa_gppp.h" + +#include "phb.h" +#include "cmh.h" +#include "cmh_gmm.h" + +#include "cmh_sm.h" +#include "cmh_gppp.h" +#include "gaci_srcc.h" +#include "psa_cc.h" + +#if defined (CO_UDP_IP) OR defined (FF_GPF_TCPIP) +#include "wap_aci.h" +#include "psa_tcpip.h" +#include "cmh_ipa.h" +#endif /* WAP OR FF_GPF_TCPIP OR SAT E */ + +#ifdef SIM_TOOLKIT +#include "psa_sat.h" +#include "cmh_sat.h" +#endif + +#include "psa_sim.h" +#include "cmh_sim.h" + +#include "cmh_sm.h" +/* temp needed because of use of ATI functions here: should eventually disappear */ +#include "ati_int.h" + +#ifdef FF_GPF_TCPIP +#include "dcm_utils.h" +#include "dcm_state.h" +#include "dcm_env.h" +#endif +#include "dcm_f.h" +#include "psa_uart.h" + + +/*==== CONSTANTS ==================================================*/ + +/*==== TYPES ======================================================*/ +typedef struct +{ + T_CGEREP_EVENT event; + T_CGEREP_EVENT_REP_PARAM parm; + +} T_CGERP_EVENT_BUFFER; + +typedef enum +{ + T_CDS_IDLE, + T_CDS_RUNNING + +} T_CONTEXTS_DEACTIVATION_STATUS; + +typedef struct +{ + T_CONTEXTS_DEACTIVATION_STATUS state; + USHORT nsapi_set; + T_ACI_CMD_SRC srcId; + U8 cid_set; + +} T_CONTEXTS_DEACTIVATION_INFORMATION; + +/*==== EXPORT =====================================================*/ + +/*==== VARIABLES ==================================================*/ +static T_CGSMS_SERVICE m_service; +static T_CGERP_EVENT_BUFFER gprs_event_buffer[GPRS_EVENT_REPORTING_BUFFER_SIZE]; +static SHORT gprs_eb_current_p, gprs_eb_oldest_p; +static BOOL m_mt_te_link; +static BOOL call_waits_in_table; +static T_CONTEXTS_DEACTIVATION_INFORMATION working_cgact_actions; +EXTERN T_PDP_CONTEXT_INTERNAL *p_pdp_context_list; +/*==== FUNCTIONS ==================================================*/ + +/* + * functions for ATA and ATH + */ +static BOOL cmhSM_sAT_A_H_intern( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret, SHORT mode ); + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Init | ++--------------------------------------------------------------------+ + + PURPOSE : Fill variables for the own use with default values. +*/ +GLOBAL void cmhSM_Init (void) +{ + + UBYTE default_pco[] = { + 0x80,0x80,0x21,0x10,0x01,0x01,0x00,0x10,0x81,0x06, + 0x00,0x00,0x00,0x00,0x83,0x06,0x00,0x00,0x00,0x00 + }; + + T_PDP_CONTEXT default_pdp_context = { "", + "", + NAS_is_ip_not_present,0, + PDP_CONTEXT_D_COMP_OMITTED, + PDP_CONTEXT_H_COMP_OMITTED, + PDP_CONTEXT_CID_OMITTED }; + + + /* SM CMH global parameter */ + smEntStat.curCmd = AT_CMD_NONE; + smEntStat.entOwn = CMD_SRC_NONE; + + memset( &pdp_context_default, 0, sizeof(T_PDP_CONTEXT_INTERNAL) ); + + memset( work_cids, PDP_CONTEXT_CID_INVALID, sizeof(work_cids) ); + + pdp_context_default.ctrl_qos = PS_is_R97; + pdp_context_default.ctrl_min_qos = PS_is_min_qos_not_present; + + + //set default context values initial ! + memcpy( &pdp_context_default.attributes, &default_pdp_context , sizeof(T_PDP_CONTEXT) ); + strcpy( pdp_context_default.attributes.pdp_type, "IP" ); + + memcpy( &pdp_context_default.internal_data.user_pco.pco, &default_pco, sizeof( default_pco ) ); + pdp_context_default.internal_data.user_pco.len = sizeof( default_pco ); + + /* GPRS event reporting */ + memset( gprs_event_buffer, 0, sizeof(T_CGERP_EVENT_BUFFER) * GPRS_EVENT_REPORTING_BUFFER_SIZE ); + + gprs_eb_current_p = 0; + gprs_eb_oldest_p = 0; + + cmhSM_empty_call_table(); + + /* used for network requested context reactivation */ + call_waits_in_table = FALSE; + + working_cgact_actions.state = T_CDS_IDLE; + working_cgact_actions.nsapi_set = 0; + working_cgact_actions.srcId = CMD_SRC_NONE; + working_cgact_actions.cid_set = 0; + + m_mt_te_link = FALSE; +} + +/* ++-------------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_ResetNonWorkingContexts | ++-------------------------------------------------------------------------+ + + PURPOSE : +*/ +GLOBAL void cmhSM_ResetNonWorkingContexts( void ) +{ + + UBYTE cid = 0; + T_PDP_CONTEXT_STATE pdp_context_state; + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + UBYTE k = 0; + + UBYTE gprs_default_pco[] = { + 0x80,0x80,0x21,0x10,0x01,0x01,0x00,0x10,0x81,0x06, + 0x00,0x00,0x00,0x00,0x83,0x06,0x00,0x00,0x00,0x00 + }; + + T_PDP_CONTEXT default_pdp_context = { "", + "", + NAS_is_ip_not_present,0, + PDP_CONTEXT_D_COMP_OMITTED, + PDP_CONTEXT_H_COMP_OMITTED, + PDP_CONTEXT_CID_OMITTED }; + + TRACE_FUNCTION("cmhSM_ResetNonWorkingContexts()"); + + + /**************************************************************************** + The reset of PDP contexts to factory setting of causes: + - Any defined context to be deactivated. + - The default context and QoS is set to initial values. + ***************************************************************************/ + + p_pdp_context_node = p_pdp_context_list; + + while( p_pdp_context_node AND k < PDP_CONTEXT_CID_MAX ) + { + cid = p_pdp_context_node->cid; + pdp_context_state = pdp_context_get_state_for_cid( cid ); + + if( pdp_context_state EQ PDP_CONTEXT_STATE_DEFINED ) + { + if( !pdp_context_cid_used_by_other( cid ) ) + { + pdp_context_remove_node( cid ); + TRACE_EVENT("ATZ: UDEFINED the defined PDP Context"); + } + else + { + TRACE_ERROR("PDP Context Not Found"); + } + } + k++; + p_pdp_context_node = p_pdp_context_node->p_next; + + } + + TRACE_EVENT("ATZ: Command Initiated Restting all the Factory Defined Values"); + + /* set default context parameter */ + memset( &pdp_context_default, 0, sizeof(T_PDP_CONTEXT_INTERNAL) ); + + memset( work_cids, PDP_CONTEXT_CID_INVALID, sizeof(work_cids) ); + cid_pointer = 0; + + //set default context values initial ! + memcpy( &pdp_context_default.attributes, &default_pdp_context , sizeof(T_PDP_CONTEXT) ); + strcpy( pdp_context_default.attributes.pdp_type, "IP" ); + + pdp_context_default.ctrl_qos = PS_is_R97; + pdp_context_default.ctrl_min_qos = (T_PS_ctrl_min_qos)PS_is_R97; + + memcpy( &pdp_context_default.internal_data.user_pco.pco, &gprs_default_pco, sizeof( gprs_default_pco ) ); + pdp_context_default.internal_data.user_pco.len = sizeof( gprs_default_pco ); + + /* mode of CGAUTO*/ + automatic_response_mode = 3; + + m_service = CGSMS_SERVICE_CS_PREFERRED; + + /* GPRS event reporting */ + sm_cgerep_mode = CGEREP_MODE_BUFFER; + sm_cgerep_bfr = CGEREP_BFR_CLEAR; + sm_cgsms_service = CGSMS_SERVICE_CS_PREFERRED; +} + +GLOBAL void cmhSM_Reset( void ) +{ + + + /* SMF CMH local parameter */ + + memset( work_cids, PDP_CONTEXT_CID_INVALID, sizeof(work_cids) ); + + cid_pointer = 0; + + /* set default context parameter */ + + /* mode of CGAUTO*/ + automatic_response_mode = 3; + + m_service = CGSMS_SERVICE_CS_PREFERRED; + + /* GPRS event reporting */ + sm_cgerep_mode = CGEREP_MODE_BUFFER; + sm_cgerep_bfr = CGEREP_BFR_CLEAR; + sm_cgsms_service = CGSMS_SERVICE_CS_PREFERRED; + sm_cgerep_srcId = (T_ACI_CMD_SRC)CMD_SRC_ATI; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_empty_call_table | ++--------------------------------------------------------------------+ + + PURPOSE : Fill variables for the own use with default values. +*/ +GLOBAL void cmhSM_empty_call_table (void) +{ + memset( gprs_call_table, 0, sizeof(T_GPRS_CALL_TABLE) *MAX_GPRS_CALL_TABLE_ENTRIES ); + current_gprs_ct_index = 0; + gprs_ct_index = 0; + gprs_call_table[0].sm_ind.ti = UNDEFINED_TI; +} + + +/* ++-------------------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : code ROUTINE : cmhSM_getSrcIdOfRunningCGACTDeactivation | ++-------------------------------------------------------------------------------+ + + PURPOSE : Returns a source ID if the given cid is requested to deactivate + by +CGACT. The source ID indicates where the +CGACT was started. +*/ +GLOBAL T_ACI_CMD_SRC cmhSM_getSrcIdOfRunningCGACTDeactivation(U8 cid) +{ + if( ( 1 << cid ) & working_cgact_actions.cid_set ) + { + return working_cgact_actions.srcId; + } + return CMD_SRC_NONE; +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : code ROUTINE : cmhSM_connection_down | ++----------------------------------------------------------------------+ + + PURPOSE : Control the answer of context deactivations + started by an AT command. +*/ +GLOBAL void cmhSM_connection_down( UBYTE dti_id ) +{ + SHORT cid = gaci_get_cid_over_dti_id( dti_id ); + + TRACE_FUNCTION("cmhSM_connection_down"); + + switch( working_cgact_actions.state ) + { + case T_CDS_RUNNING: + TRACE_EVENT_P1("T_CDS_RUNNING, nsapi:%d", CID_TO_NSAPI(cid)); + if ( ( 1 << CID_TO_NSAPI(cid) ) & working_cgact_actions.nsapi_set ) + { /* nsapi deactivation is requested */ + + working_cgact_actions.nsapi_set &= (USHORT) ~(1U << CID_TO_NSAPI(cid)); + if ( ! working_cgact_actions.nsapi_set ) + { + R_AT( RAT_OK, working_cgact_actions.srcId ) ( AT_CMD_CGACT ); + working_cgact_actions.state = T_CDS_IDLE; + } + else + { + TRACE_EVENT_P1("NO OK: nsapi_set:%d",working_cgact_actions.nsapi_set); + } + } + else + { + TRACE_EVENT_P1("meets not the nsapi_set: %d",working_cgact_actions.nsapi_set); + } + break; + case T_CDS_IDLE: + TRACE_EVENT("T_CDS_IDLE"); + break; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_contextDeactivated | ++--------------------------------------------------------------------+ + + PURPOSE : Detach mobile if necessary? Only possible if all context are disconnected. + cmhSM_automatic_detach is called after SM is deactivated (either MS initiated or + network initiated) +*/ +GLOBAL void cmhSM_contextDeactivated ( void ) +{ + + if( ! cmhSM_isContextActive() ) + { + cmhGMM_allContextsDeactivated(); + } +} + +/* ++-------------------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : code ROUTINE : isContextDeactivationRequestedByCGACT | ++-------------------------------------------------------------------------------+ + + PURPOSE : Returns TRUE if +CGACT is running on the given cid -> NO_CARRIER + FALSE if no CGACT was running on this cid -> CME_ERROR +*/ +GLOBAL BOOL isContextDeactivationRequestedByCGACT(SHORT cid) +{ + TRACE_FUNCTION("***isContextDeactivationRequestedByCGACT"); + + switch( working_cgact_actions.state ) + { + case T_CDS_RUNNING: + if ( (1 << (cid - 1)) & working_cgact_actions.cid_set ) + { + return TRUE; + } + } + return FALSE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Get_pdp_type | ++--------------------------------------------------------------------+ + + PURPOSE : Give the PDP type of the current PDP context that will build. +*/ +GLOBAL UBYTE cmhSM_Get_pdp_type( void ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + + if( p_pdp_context_node ) + { + if( !strcmp( p_pdp_context_node->attributes.pdp_type, "PPP" ) ) + return SMREG_PDP_PPP; + if( !strcmp( p_pdp_context_node->attributes.pdp_type, "IP") ) + return SMREG_PDP_IPV4; + if( !strcmp( p_pdp_context_node->attributes.pdp_type, "IPV6") ) + return SMREG_PDP_IPV6; + + /* Otherwise return an empty pdp_type. */ + return SMREG_PDP_EMPTY; + } + + return 0; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Get_pdp_address | ++--------------------------------------------------------------------+ + + PURPOSE : Give the PDP address of the current PDP context that will build. +*/ +GLOBAL void cmhSM_Get_pdp_address ( T_NAS_ip_address *pdp_address, T_NAS_ctrl_ip_address * ctrl_ip_address ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + * ctrl_ip_address = p_pdp_context_node->attributes.pdp_addr.ctrl_ip_address; + if (p_pdp_context_node->attributes.pdp_addr.ctrl_ip_address EQ NAS_is_ipv4) + { + memcpy( &(pdp_address->ipv4_addr.a4), &p_pdp_context_node->attributes.pdp_addr.ip_address.ipv4_addr.a4, NAS_SIZE_IPv4_ADDR); + } + else if(p_pdp_context_node->attributes.pdp_addr.ctrl_ip_address EQ NAS_is_ipv6) + { + memcpy( &(pdp_address->ipv6_addr.a6), &p_pdp_context_node->attributes.pdp_addr.ip_address.ipv6_addr.a6, NAS_SIZE_IPv6_ADDR); + } + else + { + TRACE_EVENT("Dynamic IP Address"); + } + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_Get_pdp_address" ); + } + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_pdp_address_to_ip | ++--------------------------------------------------------------------+ + + PURPOSE : Transform a PDP address to 4 BYTE IP form. +*/ +GLOBAL UBYTE cmhSM_pdp_address_to_ip( T_PDP_TYPE pdp_type, T_NAS_ip *pdp_addr_str, U8 *pdp_addr ) +{ + + UBYTE addr_len = 0; + + switch( cmhSM_transform_pdp_type(pdp_type)) + { + case PDP_T_IP: + addr_len = 4; + break; + case PDP_T_IPV6: + addr_len = 16; + break; + default: + addr_len = 0; + break; + } + if (addr_len) + { + memcpy(pdp_addr, pdp_addr_str, addr_len); + } + else + { + *pdp_addr = 0; + } + + return addr_len; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : convert_netaddr_to_apn | ++-------------------------------------------------------------------+ + + PURPOSE : converts a domain name into an APN + + Technical Information: + + The APN contains out of labels separated by dots. + (e.g. xxx.yyy.zzz) + + This string representation must be translated to a network + representation. + + The APN network representation contains out of a sequence of + a length field (not ASCII) followed by a ASCII string. + + xxx.yyy.zzz => 3xxx3yyy3zzz +*/ + +LOCAL void convert_netaddr_to_apn ( T_SMREG_apn *apn) +{ + UBYTE counter = 0, + buffer = apn->apn_buf[0], + *pdest = apn->apn_buf + apn->c_apn_buf, + *psource = pdest - 1; + + if(apn->c_apn_buf EQ 0) + { + return; + } + + if(apn->c_apn_buf >= sizeof apn->apn_buf) + { + apn->c_apn_buf = 0; + TRACE_EVENT_P2 ("convert_netaddr_to_apn: array out of bounds exeption (%d >= %d)", apn->c_apn_buf, sizeof apn->apn_buf); + return; + } + + /* The network representation is 1 byte longer. */ + apn->c_apn_buf++; + + /* A sentinel */ + apn->apn_buf[0] = '.'; + + /* Algorithm: copy from back to front! */ + while(pdest > apn->apn_buf ) + { + counter = 0; + while(*psource NEQ '.') + { + *(pdest--) = *(psource--); + counter++; + } + *(pdest--) = counter; + psource--; + } + + /* Correction according to the sentinel */ + + apn->apn_buf[1] = buffer; + apn->apn_buf[0] = ++counter; + + /* Modify special empty APN to the need of SMREG_SAP */ + if ((apn->c_apn_buf EQ 2) AND (apn->apn_buf[0] EQ 1) AND (apn->apn_buf[1] EQ 255)) + { + apn->c_apn_buf = 1; /* Special SMREG_SAP indicating that there is an APN present but empty */ + apn->apn_buf[0]= 0; + } +} +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Get_smreg_apn | ++--------------------------------------------------------------------+ + + PURPOSE : Give the APN of the current PDP context that will build. +*/ +GLOBAL void cmhSM_Get_smreg_apn( T_SMREG_apn *smreg_apn ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + smreg_apn->c_apn_buf = strlen(p_pdp_context_node->attributes.pdp_apn); + strncpy((char *)smreg_apn->apn_buf, (const char *)p_pdp_context_node->attributes.pdp_apn, smreg_apn->c_apn_buf); + convert_netaddr_to_apn(smreg_apn); + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_Get_smreg_apn" ); + } + +#ifdef _SIMULATION_ + memset( smreg_apn->apn_buf + smreg_apn->c_apn_buf, 0, sizeof(smreg_apn->apn_buf) - smreg_apn->c_apn_buf ); +#endif +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Get_h_comp | ++--------------------------------------------------------------------+ + + PURPOSE : Give the h_comp of the current PDP context that will build. +*/ +GLOBAL UBYTE cmhSM_Get_h_comp ( void ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + return (UBYTE) p_pdp_context_node->attributes.h_comp; + } + + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_Get_h_comp" ); + return 0; + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Get_d_comp | ++--------------------------------------------------------------------+ + + PURPOSE : Give the d_comp of the current PDP context that will build. +*/ +GLOBAL UBYTE cmhSM_Get_d_comp( void ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + return (UBYTE) p_pdp_context_node->attributes.d_comp; + } + + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_Get_d_comp" ); + return 0; + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_change_def_QOS | ++--------------------------------------------------------------------+ + + PURPOSE : Set the quality of service (requested) of default context. + +*/ +GLOBAL void cmhSM_change_def_QOS( T_PS_qos *qos, T_PS_ctrl_qos ctrl_qos ) +{ + + pdp_context_default.ctrl_qos = ctrl_qos; + + if(ctrl_qos EQ PS_is_R97) { + memcpy( &pdp_context_default.qos.qos_r97, &(qos->qos_r97), sizeof(T_PS_qos_r97) ); + } + else { + memcpy( &pdp_context_default.qos.qos_r99, &(qos->qos_r99), sizeof(T_PS_qos_r99) ); + } + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_change_def_QOS_min | ++--------------------------------------------------------------------+ + + PURPOSE : Set the quality of service (min.) of default context. + +*/ +GLOBAL void cmhSM_change_def_QOS_min( T_PS_min_qos *qos, T_PS_ctrl_min_qos ctrl_min_qos ) +{ + + pdp_context_default.ctrl_min_qos = ctrl_min_qos; + + if(ctrl_min_qos EQ PS_is_min_R97) { + memcpy( &pdp_context_default.min_qos.qos_r97, &(qos->qos_r97), sizeof(T_PS_qos_r97) ); + } + else { + memcpy( &pdp_context_default.min_qos.qos_r99, &(qos->qos_r99), sizeof(T_PS_qos_r99) ); + } + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Set_default_QOS | ++--------------------------------------------------------------------+ + + PURPOSE : Set the quality of service of the spezified PDP context + to default. +*/ +GLOBAL void cmhSM_Set_default_QOS( U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + p_pdp_context_node->ctrl_qos = pdp_context_default.ctrl_qos; + memcpy( &p_pdp_context_node->qos, &pdp_context_default.qos, sizeof(T_PS_qos) ); + } + else + { + TRACE_ERROR(" ERROR: PDP context not found, in function cmhSM_Set_default_QOS "); + } + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_Set_default_QOS | ++--------------------------------------------------------------------+ + + PURPOSE : Set the quality of service of the spezified PDP context + to default. +*/ +GLOBAL void cmhSM_Set_default_QOS_min ( U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + p_pdp_context_node->ctrl_min_qos = pdp_context_default.ctrl_min_qos; + memcpy( &p_pdp_context_node->min_qos, &pdp_context_default.min_qos, sizeof(T_PS_min_qos) ); + } + else + { + TRACE_ERROR(" ERROR: PDP context not found, in function cmhSM_Set_default_QOS_min"); + } + +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : changed, smn ROUTINE : cmhSM_Get_QOS | ++--------------------------------------------------------------------+ + + PURPOSE : Give the requested quality of service of the current + PDP context that will build. +*/ +GLOBAL void cmhSM_Get_QOS( T_PS_qos *dest_qos ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + memcpy( dest_qos, &p_pdp_context_node->qos, sizeof(T_PS_qos) ); + else + TRACE_ERROR( "ERROR: PDP context not found, in funciton cmhSM_Get_QOS" ); + +} /* End: cmhSM_Get_QOS */ + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : changed, smn ROUTINE : cmhSM_Get_QOS_min | ++--------------------------------------------------------------------+ + + PURPOSE : Give the minimum acceptable quality of service of the + current PDP context that will build. +*/ +GLOBAL void cmhSM_Get_QOS_min ( T_PS_min_qos *dest_qos_min ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + memcpy( dest_qos_min, &p_pdp_context_node->min_qos, sizeof(T_PS_min_qos) ); + else + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_Get_QOS_min" ); + +} /* End: cmhSM_Get_QOS_min */ + + + +GLOBAL USHORT cmhSM_pdp_typ_to_string ( UBYTE pdp_typ_no, char* string ) +{ + switch ( pdp_typ_no ) + { + case 0: + strcpy (string, "X_121"); + return 5; + case 33: + strcpy (string, "IP_V_4"); + return 6; + case 87: + strcpy (string, "IP_V_6"); + return 6; + default: + strcpy (string, ""); + return 0; + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_pdp_type_to_string | ++--------------------------------------------------------------------+ + + PURPOSE : +*/ +GLOBAL SHORT cmhSM_pdp_type_to_string ( UBYTE pdp_type_no, char* string ) +{ + SHORT i; + + switch ( pdp_type_no ) + { + case 0: + strcpy (string, "X_121"); + i = 5; + break; + case 33: + strcpy (string, "IP_V_4"); + i = 6; + break; + case 87: + strcpy (string, "IP_V_6"); + i = 6; + break; + default: + strcpy (string, ""); + i = 0; + } + + return i; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_ring_gprs_par | ++--------------------------------------------------------------------+ + + PURPOSE : Return the information for CRING. +*/ +GLOBAL char* cmhSM_ring_gprs_par ( void ) +{ + static char string[MAX_CRING_INFORMATION_LENGTH] = "\""; + unsigned int i = 1; + + i += cmhSM_pdp_typ_to_string(gprs_call_table[current_gprs_ct_index].sm_ind.pdp_type, string + i); + string[i++] = '\"'; + + string[i++] = ','; + + string[i++] = '\"'; + if (gprs_call_table[current_gprs_ct_index].sm_ind.ctrl_ip_address EQ NAS_is_ipv4) + { + memcpy (string + i, gprs_call_table[current_gprs_ct_index].sm_ind.ip_address.ipv4_addr.a4, NAS_SIZE_IPv4_ADDR); + i += NAS_SIZE_IPv4_ADDR + 1; + } + else + { + memcpy (string + i, gprs_call_table[current_gprs_ct_index].sm_ind.ip_address.ipv6_addr.a6, NAS_SIZE_IPv6_ADDR); + i += NAS_SIZE_IPv6_ADDR + 1; + } + + + string[i++] = '\"'; + + if ( *gprs_call_table[current_gprs_ct_index].L2P ) + { + string[i++] = ','; + + string[i++] = '\"'; + strcpy (string + i, gprs_call_table[current_gprs_ct_index].L2P); + i += strlen (gprs_call_table[current_gprs_ct_index].L2P); + string[i++] = '\"'; + } + + string[i] = 0; + + return string; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_call_answer | ++--------------------------------------------------------------------+ + + PURPOSE : Return TRUE in this case, if an auto answer is needed. +*/ +GLOBAL BOOL cmhSM_call_answer ( UBYTE ring_counter, T_ACI_CRING_MOD mode ) +{ + + switch(automatic_response_mode) + { + case 0: /* GPRS off, GSM controlled by S0 */ + if( mode NEQ CRING_MOD_Gprs AND + at.S[0] AND + at.S[0] <= ring_counter ) + return TRUE; + break; + + case 1: /* GPRS on, GSM controlled by S0 */ + if( mode EQ CRING_MOD_Gprs ) + return TRUE; + + if( at.S[0] AND + at.S[0] <= ring_counter ) + return TRUE; + break; + + case 2: /* modem copatibility mode, GPRS on, GSM off */ + if ( mode NEQ CRING_MOD_Gprs ) + break; + + /*lint -fallthrough*/ + /*lint -fallthrough*/ + case 3: /* modem copatibility mode, GPRS on, GSM on */ + if (at.S[0] AND ring_counter >= at.S[0]) + return TRUE; + } + + return FALSE; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_call_reject | ++--------------------------------------------------------------------+ + + PURPOSE : Return TRUE in this case, if an auto reject is needed. +*/ +GLOBAL BOOL cmhSM_call_reject ( UBYTE ring_counter, T_ACI_CRING_MOD mode ) +{ + switch(automatic_response_mode) + { + case 0: /* GPRS off, GSM controlled by S0 */ + return FALSE; + case 1: /* GPRS on, GSM controlled by S0 */ + if (at.S99 AND mode EQ CRING_MOD_Gprs ) + return TRUE; + break; + case 2: /* modem copatibility mode, GPRS on, GSM off */ + case 3: /* modem copatibility mode, GPRS on, GSM on */ + if ( mode NEQ CRING_MOD_Gprs ) + break; + if (at.S99 AND ring_counter >= at.S99) + return TRUE; + } + + return FALSE; +} + + + + +/* ++--------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : is_GSM_call_active | ++--------------------------------------------------------------------+ + + PURPOSE : +*/ + +LOCAL BOOL is_GSM_call_active (void) +{ + SHORT ctbIdx; /* holds call table index */ + + for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ ) + { + if (ccShrdPrm.ctb[ctbIdx] NEQ NULL) + { + return (TRUE); + } + } + + return (FALSE); +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_sAT_H | ++--------------------------------------------------------------------+ + + PURPOSE : handle GPRS calls and return FALSE if a circuit switched + call need a handle. +*/ +GLOBAL BOOL cmhSM_sAT_H( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret ) +{ + + SHORT cid_array[1] = { PDP_CONTEXT_CID_INVALID }; + T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, (UBYTE)srcId, search_ati_src_id); + + if ( ( at.rngPrms.isRng EQ TRUE ) AND ( at.rngPrms.mode EQ CRING_MOD_Gprs) ) + { + /* + * brz patch: In the case of context reactivation over SMREG_PDP_ACTIVATE_IND with an used ti + * the GPRS ATH command doesn't do anything! + * + * Why? Because the Windows Dial-Up Networking client send every time an ATH after termination + * of the connection and with this a context reactivation was impossible. + */ + if ( gprs_call_table[current_gprs_ct_index].reactivation EQ GCTT_NORMAL ) + { + return cmhSM_sAT_A_H_intern(srcId, aci_ret, 0); + } + return TRUE; + } + else + { + if (is_GSM_call_active()) + { + return (FALSE); + } + /* if AT_H has been called and no RING is active, then disconnect the active + context */ +#ifdef FF_GPF_TCPIP + if(is_gpf_tcpip_call()) + { + T_DCM_STATUS_IND_MSG err_ind_msg; + err_ind_msg.hdr.msg_id = DCM_ERROR_IND_MSG; + err_ind_msg.result = DCM_PS_CONN_BROKEN; + dcm_send_message(err_ind_msg, DCM_SUB_NO_ACTION); + } +#endif + *aci_ret = sAT_PlusCGACT ( srcId, CGACT_STATE_DEACTIVATED, cid_array ); + + switch (*aci_ret) + { + case (AT_CMPL): /*operation completed*/ + return FALSE; /* return false, so that GSM calls will be canceled */ + + case (AT_EXCT): + src_params->curAtCmd = AT_CMD_CGACT; + return TRUE; + + default: + cmdCmeError(CME_ERR_Unknown); /*Command failed*/ + return FALSE; + } + } +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_sAT_A | ++--------------------------------------------------------------------+ + + PURPOSE : handle GPRS calls and return FALSE if a circuit switched + call need a handle. +*/ +GLOBAL BOOL cmhSM_sAT_A( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret ) +{ + BOOL b; + + b = cmhSM_sAT_A_H_intern(srcId, aci_ret, 1); + + if ( *aci_ret EQ AT_EXCT ) + cmdErrStr = NULL; + + return b; +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_sAT_A_H_intern | ++--------------------------------------------------------------------+ + + PURPOSE : handle sAT_A and cAT_H for GPRS +*/ +static BOOL cmhSM_sAT_A_H_intern ( T_ACI_CMD_SRC srcId, T_ACI_RETURN *aci_ret, SHORT mode) +{ + if ( at.rngPrms.isRng EQ TRUE ) + { + if ( at.rngPrms.mode EQ CRING_MOD_Gprs) + { + *aci_ret = automatic_response_mode > 1 ? /* modem copatibility mode possible */ + sAT_PlusCGANS(srcId, mode, NULL, PDP_CONTEXT_CID_OMITTED): AT_FAIL; + } + else /* circuit switched call */ + { + return FALSE; + } + } + else + { + return FALSE; + } + return TRUE; +} + + + +/* ++----------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_type_omitted | ++----------------------------------------------------------------------+ + + PURPOSE : check if the pdp context type is omitted. +*/ +GLOBAL BOOL pdp_context_type_omitted( char *p_type ) +{ + BOOL omitted = TRUE; + char i; + + for( i = 0; i < MAX_PDP_CONTEXT_TYPE_LEN; i++ ) + { + if( *(p_type + i) NEQ 0 ) + omitted = FALSE; + } + + return omitted; +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_addr_omitted | ++----------------------------------------------------------------------+ + + PURPOSE : check if the pdp context apn is omitted. +*/ +GLOBAL BOOL pdp_context_apn_omitted( char *p_apn ) +{ + BOOL omitted = TRUE; + int i; + + for( i = 0; i < MAX_PDP_CONTEXT_APN_LEN; i++ ) + { + if( *(p_apn + i) NEQ 0 ) + omitted = FALSE; + } + + return omitted; +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_addr_omitted | ++----------------------------------------------------------------------+ + + PURPOSE : check if the pdp context addr is omitted. +*/ +GLOBAL BOOL pdp_context_addr_omitted( T_NAS_ip *p_addr ) +{ + return (p_addr->ctrl_ip_address EQ NAS_is_ip_not_present); +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_type_valid | ++----------------------------------------------------------------------+ + + PURPOSE : check pdp context type, return false if not valid. +*/ +GLOBAL BOOL pdp_context_type_valid( char *p_type ) +{ + BOOL valid = FALSE; + + if( !strcmp( p_type, "IP") ) + valid = TRUE; + + if( !strcmp( p_type, "IPV6") ) + valid = TRUE; + + if( !strcmp( p_type, "PPP") ) + { + /* For EDGE we are not supporting PDP_TYPE "PPP" */ + valid = FALSE; + } + + return valid; +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : pdp_context_apn_vaild | ++----------------------------------------------------------------------+ + + PURPOSE : check APN of well formed +*/ +GLOBAL BOOL pdp_context_apn_valid( char *p_apn ) +{ + SHORT i = 0; + SHORT length = strlen( p_apn ); + char *no_start_labels[] = {"rac","lac","sgsn"}, *start, *end, *mark; + T_PDP_CONTEXT_APN apn; + + strcpy( apn, p_apn ); + start = apn; + + /* change charcter of string to lower cases */ + for( i = 0; i < length; i++ ) + apn[i] = tolower( apn[i] ); + + /* The Network Identifier shall not start with this labels */ + for( i = 0; i < 3; i++ ) + { + if( apn EQ strstr(apn, no_start_labels[i]) ) + return FALSE; + } + + /* the Wild Card APN */ + if ( length EQ 1 AND *start EQ '*' ) + return TRUE; + + /* the APN with no name */ + if ( length EQ 1 AND *start EQ /*lint -e(743)*/ '\x0ff' ) + return TRUE; + + /* Oporater Identifer is optional and the Network Identifer */ + mark = strrchr( apn, '.' ); + if( mark ) + if( strstr(mark + 1, "gprs") ) + { + /* APN Operator Identifier contained (optional) */ + if( length < 18 ) + return FALSE; + + mark = start + length - 18; /* start of the APN Operator Identifier */ + /* check APN Operator Identifier: "mncXXX.mccXXX.gprs" */ + if( mark NEQ strstr(mark, "mnc") ) + return FALSE; + + if ( mark + 6 NEQ strstr(mark, ".mcc") ) + return FALSE; + strtol(mark + 3, &end, 10); + + if ( end NEQ mark + 6 ) + return FALSE; + strtol(mark + 10, &end, 10); + + if ( end NEQ mark + 13 ) + return FALSE; + /* check character between APN Network Identifier and the Operator Identifer */ + mark--; + + if ( *mark NEQ '.' ) + return FALSE; + /* set stop mark */ + *mark = 0; + } + else + mark = 0; + + /* check APN Network Identifier */ + + /* shall not end in ".gprs" */ + end = strrchr(apn, '.'); + if ( end ) + if ( strstr(end + 1, "gprs") ) + return FALSE; + + /* parse all labels */ + while ( *start ) + { + /* in first at least one Label */ + while ( (*start >= 'a' AND *start <= 'z') OR (*start >= '0' AND *start <= '9') OR *start EQ '-' ) + start ++; + + /* next Label or nothing */ + if ( *start EQ '.' ) + start ++; + else + if ( *start NEQ 0) + return FALSE; + } + + /* The APN Network Identifier shall have a maximum length of 63 octets. */ + if ( start - apn > 63 ) + return FALSE; + + /* clear stop mark */ + if ( mark ) + *mark = '.'; + + return TRUE; +} + + + +/* ++----------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_addr_valid | ++----------------------------------------------------------------------+ + + PURPOSE : check pdp context address, return false if not valid. +*/ +GLOBAL BOOL pdp_context_addr_valid( T_NAS_ip * p_addr ) +{ + BOOL valid = TRUE; + int i = 0; + + if (p_addr->ctrl_ip_address EQ NAS_is_ip_not_present) + return FALSE; + + if (p_addr->ctrl_ip_address EQ NAS_is_ipv4) + { + if (( p_addr->ip_address.ipv4_addr.a4[0] EQ 0 ) OR //According to RFC3330 first digit must not be ZERO + ( p_addr->ip_address.ipv4_addr.a4[0] EQ 127 ) OR //According to RFC3330 first digit 127 means LOOPBACK + ((p_addr->ip_address.ipv4_addr.a4[0] >= 224 ) AND (p_addr->ip_address.ipv4_addr.a4[0] < 240)) ) //According to RFC3330 224.0.0.0/4 is reserved for multicast + { + valid = FALSE; + } + } + else + { + switch( p_addr->ip_address.ipv6_addr.a6[0] ) + { + case 0: + if( p_addr->ip_address.ipv6_addr.a6[11] EQ 0 AND p_addr->ip_address.ipv6_addr.a6[12] NEQ 0 + AND p_addr->ip_address.ipv6_addr.a6[12] NEQ 127 AND p_addr->ip_address.ipv6_addr.a6[12] NEQ 255 ) + { + /* this could be an ip v4 address embedded in ip v6 */ + break; + } + + for(i = 1; i < PDP_CONTEXT_ADDR_LEN_MAX; i++) + { + if( p_addr->ip_address.ipv6_addr.a6[i] EQ 0 ) + valid = FALSE; + } + break; + + case 127: /* local host address */ + valid = FALSE; + break; + + case 254: /* invalid for an ip v6 address, the rest of the address must be '0' */ + for(i = 4; i < PDP_CONTEXT_ADDR_LEN_MAX; i++) + { + if( p_addr->ip_address.ipv6_addr.a6[i] NEQ 0 ) + valid = FALSE; + } + break; + +// case 255: /* omitted 255.255...255.255 */ +// for( i = 1; i < PDP_CONTEXT_ADDR_LEN_MAX; i++ ) +// { +// if( p_addr->ip_address.ipv6_addr.a6[i] NEQ 255 ) +// { +// valid = FALSE; +// } +// } +// break; + + default: + /* the address is valid */ + break; + + } + } + return valid; +} + + +/* ++--------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_transform_pdp_type | ++--------------------------------------------------------------------+ + + PURPOSE : transform pdp_type +*/ +GLOBAL USHORT cmhSM_transform_pdp_type( char *pdp_type_str ) +{ + T_GACI_PDP_TYPE pdp_type = PDP_T_NONE; + + if( !strcmp(pdp_type_str, "IP") ) + pdp_type = PDP_T_IP; + + if( !strcmp(pdp_type_str, "IPV6") ) + pdp_type = PDP_T_IPV6; + + if( !strcmp(pdp_type_str, "PPP") ) + pdp_type = PDP_T_PPP; + + return pdp_type; +} + + +/* ++-------------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_get_state_for_cid | ++-------------------------------------------------------------------------+ + + PURPOSE : return the PDP context state for the given <cid>. +*/ +GLOBAL T_PDP_CONTEXT_STATE pdp_context_get_state_for_cid( U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + T_PDP_CONTEXT_STATE pdp_context_state = PDP_CONTEXT_STATE_INVALID; + + TRACE_FUNCTION("pdp_context_get_state_from_cid()"); + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + pdp_context_state = p_pdp_context_node->internal_data.state; + + return pdp_context_state; +} + + +/* ++-------------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMF | +| STATE : ROUTINE : pdp_context_cid_used_by_other | ++-------------------------------------------------------------------------+ + + PURPOSE : return true if the context id is used +*/ +GLOBAL BOOL pdp_context_cid_used_by_other( U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("pdp_context_cid_used_by_other()"); + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + + while( p_pdp_context_node ) + { + if( p_pdp_context_node->attributes.p_cid < PDP_CONTEXT_CID_MIN AND + p_pdp_context_node->attributes.p_cid > PDP_CONTEXT_CID_MAX ) + { + return TRUE; + } + p_pdp_context_node = p_pdp_context_node->p_next; + } + + return FALSE; +} + +GLOBAL void set_state_over_cid ( U8 cid, T_PDP_CONTEXT_STATE state ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.state = state; + } +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : get_state_over_cid | ++---------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL T_PDP_CONTEXT_STATE get_state_over_cid( U8 cid ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("get_state_over_cid()"); + + if ( (cid >= 1) AND (cid <= PDP_CONTEXT_CID_MAX) ) + { + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + return p_pdp_context_node->internal_data.state; + } + } + + TRACE_EVENT("invalid cid detected!"); + return PDP_CONTEXT_STATE_INVALID; + +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : get_state_working_cid | ++---------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL T_PDP_CONTEXT_STATE get_state_working_cid( void ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + return p_pdp_context_node->internal_data.state; + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function get_state_working_cid" ); + return PDP_CONTEXT_STATE_INVALID; + } + +} + + +/* ++------------------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : set_conn_param_on_working_cids | ++------------------------------------------------------------------------------+ + + PURPOSE : +*/ +GLOBAL void set_conn_param_on_working_cid ( UBYTE owner, T_DTI_ENTITY_ID entity_id ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + TRACE_FUNCTION("set_conn_param_on_working_cid()"); + + p_pdp_context_node = pdp_context_find_node_from_cid(work_cids[cid_pointer]); + + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.owner = (T_ACI_CMD_SRC)owner; + p_pdp_context_node->internal_data.entity_id = entity_id; + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function set_conn_param_on_working_cid " ); + return; + } +} + + + +/* ++------------------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : set_conn_param_on_all_working_cids | ++------------------------------------------------------------------------------+ + + PURPOSE : +*/ +GLOBAL void set_conn_param_on_all_working_cids ( UBYTE owner, T_DTI_ENTITY_ID entity_id ) +{ + U8 *pcid = &(work_cids[cid_pointer]); + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("set_conn_param_on_all_working_cids()"); + + while(INVALID_CID NEQ *pcid) { + + p_pdp_context_node = pdp_context_find_node_from_cid((U8)*pcid); + + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.owner = (T_ACI_CMD_SRC)owner; + p_pdp_context_node->internal_data.entity_id = entity_id; + } + pcid ++; + } +} + +/* ++---------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : set_state_working_cid | ++---------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL void set_state_working_cid( T_PDP_CONTEXT_STATE c_state ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("set_state_working_cid()"); + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.state = c_state; + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, invalid cid, in function set_state_working_cid" ); + } +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : get_state_over_nsapi_set | ++---------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL T_PDP_CONTEXT_STATE get_state_over_nsapi_set ( USHORT *nsapi_set, U8 *cid ) +{ + USHORT nsapi = 0; + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("get_state_over_nsapi_set()"); + while( nsapi < SMH_LAST_FREE_NSAPIS AND !((*nsapi_set >> nsapi) & 1) ) + nsapi++; + + if( !(*nsapi_set & ( 1 << nsapi )) ) + { + return PDP_CONTEXT_STATE_INVALID; + } + + TRACE_EVENT_P1("NSAPI: %d", nsapi); + + TRACE_EVENT_P1("NSAPI: %4d", nsapi); + + *nsapi_set &= ~( 1U << nsapi ); + + p_pdp_context_node = pdp_context_find_node_from_cid( NSAPI_TO_CID( nsapi ) ); + if( !p_pdp_context_node ) + { + TRACE_ERROR( "ERROR: PDP context not found, invalid cid, in function get_state_over_nsapi_set" ); + return PDP_CONTEXT_STATE_INVALID; + } + + *cid = p_pdp_context_node->cid; + + return get_state_over_cid( *cid ); + +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_Give_nsapi_set | ++---------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL USHORT cmhSM_Give_nsapi_set ( U8 cid ) +{ + return (1 << CID_TO_NSAPI(cid) ); +} + + +/* ++---------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : get_owner_over_cid | ++---------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL T_ACI_CAL_OWN get_owner_over_cid( U8 cid ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + return (T_ACI_CAL_OWN)p_pdp_context_node->internal_data.owner; + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function get_owner_over_cid" ); + return CAL_OWN_NONE; + } +} + + +/* ++--------------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhGPPP_send_establish_request | ++--------------------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL void cmhGPPP_send_establish_request ( UBYTE peer, UBYTE prot ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; +// T_PPP_ESTABLISH_REQ est_req; + + PALLOC (ppp_establish_req, PPP_ESTABLISH_REQ); + + TRACE_FUNCTION( "cmhGPPP_send_establish_request" ); + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { + + if(!strcmp(p_pdp_context_node->attributes.pdp_type, "PPP")) + ppp_establish_req->mode = PPP_TRANSPARENT; + else + ppp_establish_req->mode = PPP_SERVER; + + ppp_establish_req->mru = PPP_MRU_DEFAULT; + ppp_establish_req->ap = gpppShrdPrm.ppp_authentication_protocol; + ppp_establish_req->accm = gpppShrdPrm.accm; + ppp_establish_req->rt = gpppShrdPrm.restart_timer; + ppp_establish_req->mc = gpppShrdPrm.max_configure; + ppp_establish_req->mt = gpppShrdPrm.max_terminate; + ppp_establish_req->mf = gpppShrdPrm.max_failure; + ppp_establish_req->ip = p_pdp_context_node->attributes.pdp_addr.ip_address.ipv4_addr.a4[0] << 24; + ppp_establish_req->ip += p_pdp_context_node->attributes.pdp_addr.ip_address.ipv4_addr.a4[1] << 16; + ppp_establish_req->ip += p_pdp_context_node->attributes.pdp_addr.ip_address.ipv4_addr.a4[2] << 8; + ppp_establish_req->ip += p_pdp_context_node->attributes.pdp_addr.ip_address.ipv4_addr.a4[3]; + + ppp_establish_req->peer_direction = DTI_CHANNEL_TO_LOWER_LAYER; + ppp_establish_req->prot_direction = DTI_CHANNEL_TO_HIGHER_LAYER; + + ppp_establish_req->peer_link_id = p_pdp_context_node->internal_data.link_id_uart; + ppp_establish_req->prot_link_id = p_pdp_context_node->internal_data.link_id; + + +#ifdef _SIMULATION_ + memset (ppp_establish_req->peer_channel.peer_entity, 0, CHANNEL_NAME_LENGTH); + memset (ppp_establish_req->protocol_channel.protocol_entity, 0, CHANNEL_NAME_LENGTH); +#endif /* _SIMULATION_ */ + + strcpy ( (char *) ppp_establish_req->protocol_channel.protocol_entity, SNDCP_NAME); + + switch (peer) + { +#ifdef BT_ADAPTER + case DTI_ENTITY_BLUETOOTH: + strcpy ( (char *)(&(ppp_establish_req->peer_channel)), BTI_NAME); + break; +#endif + case DTI_ENTITY_UART: + strcpy ( (char *)(&(ppp_establish_req->peer_channel)), UART_NAME); + break; + +#ifdef FF_PSI + case DTI_ENTITY_PSI: + strcpy ( (char *)(&(ppp_establish_req->peer_channel)), PSI_NAME); + break; +#endif /*FF_PSI*/ + + case DTI_ENTITY_AAA: + strcpy ( (char *)(&(ppp_establish_req->peer_channel)), RIV_NAME); + break; + + default: + TRACE_ERROR ("[cmhGPPP_send_establish_request()] Unexpected peer!"); + return; + } + + psaGPPP_Establish ( ppp_establish_req ); + + switch (get_state_working_cid()) + { + case PDP_CONTEXT_STATE_ACTIVATED: + set_state_working_cid( PDP_CONTEXT_STATE_ACTIVATED_ESTABLISH_1 ); + break; + default: + set_state_working_cid( PDP_CONTEXT_STATE_ESTABLISH_1 ); + break; + } + + } + else + { + TRACE_ERROR( "PDP context not found, in function cmhGPPP_send_establish_request" ); + } +} + + +/* ++-----------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_cgerep_buffer | ++-----------------------------------------------------------------+ + PURPOSE : +*/ + +GLOBAL void cmhSM_cgerep_buffer ( void ) +{ + + switch (sm_cgerep_bfr) + { + case CGEREP_BFR_CLEAR: + memset(gprs_event_buffer, 0, sizeof(T_CGERP_EVENT_BUFFER) * GPRS_EVENT_REPORTING_BUFFER_SIZE); + break; + case CGEREP_BFR_FLUSH: + if ( uart_is_mt_te_link EQ FALSE) + { + while ( gprs_eb_oldest_p NEQ gprs_eb_current_p ) + { + R_AT( RAT_CGEREP, (T_ACI_CMD_SRC)sm_cgerep_srcId ) + ( gprs_event_buffer[gprs_eb_oldest_p].event, gprs_event_buffer[gprs_eb_oldest_p].parm ); + + gprs_eb_oldest_p++; + } + } + break; + case CGEREP_BFR_OMITTED: + case CGEREP_BFR_INVALID: + default: + break; + } +} + + +/* ++-----------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_save_event | ++-----------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL void cmhSM_save_event( T_CGEREP_EVENT event, T_CGEREP_EVENT_REP_PARAM *param ) +{ + + /* save event */ + gprs_event_buffer[gprs_eb_current_p].event = event; + if (param) + memcpy (&gprs_event_buffer[gprs_eb_current_p].parm, param, sizeof(T_CGEREP_EVENT_REP_PARAM)); + + /* is buffer full */ + if ( gprs_eb_oldest_p EQ gprs_eb_current_p ) + gprs_eb_oldest_p = -1; + + /* new current pointer */ + gprs_eb_current_p++; + if ( gprs_eb_current_p EQ GPRS_EVENT_REPORTING_BUFFER_SIZE ) + gprs_eb_current_p = 0; + + /* if buffer full correct pointer to oldest event */ + if ( gprs_eb_oldest_p EQ -1 ) + gprs_eb_oldest_p = gprs_eb_current_p; + +} + + +/* ++-----------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_set_sms_service | ++-----------------------------------------------------------------+ + + PURPOSE : +*/ + +GLOBAL void cmhSM_set_sms_service( T_CGSMS_SERVICE service ) +{ + + { + PALLOC (mnsms_mo_serv_req, MNSMS_MO_SERV_REQ); + + /* fill in primitive parameter: command request */ + mnsms_mo_serv_req -> mo_sms_serv = (UBYTE) service; + + PSENDX (SMS, mnsms_mo_serv_req); + } + + m_service = service; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_sms_service_changed | ++-------------------------------------------------------------------+ + + PURPOSE : indicates a network initiated PDP context modification + +*/ +GLOBAL void cmhSM_sms_service_changed ( UBYTE service ) +{ + + TRACE_FUNCTION ("cmhSM_sms_service_changed()"); + +/* + *------------------------------------------------------------------- + * check for command context + *------------------------------------------------------------------- + */ + if ( smEntStat.curCmd EQ AT_CMD_CGSMS ) + { + if ( m_service EQ service ) + { + sm_cgsms_service = m_service; + R_AT( RAT_OK, smEntStat.entOwn ) ( smEntStat.curCmd ); + } + else + { + R_AT( RAT_CME, smEntStat.entOwn ) ( smEntStat.curCmd, CME_ERR_Unknown ); + /* log result */ + cmh_logRslt ( smEntStat.entOwn, RAT_CME, smEntStat.curCmd, + -1, BS_SPEED_NotPresent, CME_ERR_Unknown ); + } + + smEntStat.curCmd = AT_CMD_NONE; + } +} + + +/* ++-----------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_GprsAttached | ++-----------------------------------------------------------------+ + + PURPOSE : Handling of changed GMM attach state. + PARAMETERS : state - TRUE is GPRS attached. + FALSE is GPRS detached. +*/ + +GLOBAL void cmhSM_GprsAttached( T_GPRS_ATTACH_STATE state ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + TRACE_FUNCTION ("cmhSM_GprsAttached()"); + + /* + * Do nothing if no context action is in progress (no cmd is running). + */ + if (work_cids[cid_pointer] EQ PDP_CONTEXT_CID_INVALID) + return; + + + if ( state EQ GPRS_ATTACH ) + { /* mobile is attached */ + switch ( get_state_working_cid( ) ) + { + case PDP_CONTEXT_STATE_ATTACHING: + /* The first cid in work_cids should continue activation after the attach */ + if (gpppEntStat.curCmd EQ AT_CMD_CGDATA) + { + /* Continue establishing the data link context */ + cmhSM_data_link_context(); + break; + } + else if (smEntStat.curCmd EQ AT_CMD_CGACT) + { + /* Continue activating the context */ + cmhSM_activate_context(); + break; + } + default: + /* Do nothing since no context is forcing the attach. */ + break; + } + } + else + { + /* attach failed or the network has indicated detach. */ + + p_pdp_context_node = pdp_context_find_node_from_cid((U8)(work_cids[cid_pointer])); + if( p_pdp_context_node NEQ NULL ) + { + switch ( get_state_working_cid() ) + { + case PDP_CONTEXT_STATE_ATTACHING: + /* The attach was rejected. Set state back to defined and return no carrier */ + + if (smEntStat.curCmd EQ AT_CMD_CGACT) + { + p_pdp_context_node->internal_data.owner = smEntStat.entOwn; + } + else + { + p_pdp_context_node->internal_data.owner = gpppEntStat.entOwn; + } + + if (gpppEntStat.curCmd EQ AT_CMD_CGDATA) + { + gaci_RAT_caller ( RAT_NO_CARRIER, work_cids[cid_pointer], AT_CMD_DATA, 0 ); + } + else if (smEntStat.curCmd EQ AT_CMD_CGACT) + { + gaci_RAT_caller ( RAT_CME, work_cids[cid_pointer], AT_CMD_CGACT, CME_ERR_GPRSUnspec ); + } + + set_state_working_cid( PDP_CONTEXT_STATE_DEFINED ); + + gpppEntStat.curCmd = AT_CMD_NONE; + smEntStat.curCmd = AT_CMD_NONE; + work_cids[0] = PDP_CONTEXT_CID_INVALID; + cid_pointer = 0; + + break; + case PDP_CONTEXT_STATE_ESTABLISH_1: + /* + * Context not activated towards SM, but PPP has to be terminated. + */ + cmhSM_deactivateAContext( smEntStat.entOwn, work_cids[cid_pointer] ); + + gpppEntStat.curCmd = AT_CMD_NONE; + gpppEntStat.entOwn = CMD_SRC_NONE; + break; + default: + /* Do nothing. Context is deactivated from SM */ + break; + } + } + } +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_activate_context | ++-------------------------------------------------------------------+ + + PURPOSE : Activates a context without user plane. +*/ + +GLOBAL void cmhSM_activate_context(void) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + U8 hcomp; + U8 dcomp; + + TRACE_FUNCTION ("cmhSM_activate_context()"); + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( !p_pdp_context_node ) + { + TRACE_ERROR( "PDP context not found, in function cmhSM_activate_context" ); + return; + } + + + /* hcomp value being changed according to spec 27.007 */ + hcomp = cmhSM_Get_h_comp() ; + dcomp = cmhSM_Get_d_comp() ; + + /* + * Activate the primary or secondary context + */ + if( p_pdp_context_node->type EQ PDP_CONTEXT_TYPE_PRIMARY ) + { + psaSM_smreg_pdp_activate_req( work_cids[cid_pointer], + hcomp, + dcomp); + } +#ifdef REL99 + else if( p_pdp_context_node->type EQ PDP_CONTEXT_TYPE_SECONDARY ) + { + psaSM_smreg_pdp_activate_sec_req( work_cids[cid_pointer] ); + } +#endif + + set_state_working_cid( PDP_CONTEXT_STATE_ACTIVATING ); +} + + +#if defined (CO_UDP_IP) OR defined (FF_GPF_TCPIP) +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : cmh_smf | +| STATE : initial ROUTINE : cmhSM_IP_activate_cb | ++----------------------------------------------------------------------+ + + PURPOSE : callback function for WAP over GPRS. + While handling the command ATD*98# in function atGD() + the function psaTCPIP_Activate() is called for WAP handling. + psaTCPIP_Activate() has this function as parameter for + call backs. +*/ +void cmhSM_IP_activate_cb(T_ACI_RETURN result) +{ + U8 cid = gaci_get_cid_over_dti_id(wap_dti_id); + TRACE_FUNCTION("cmhSM_IP_activate_cb"); + TRACE_EVENT_P1("wap_state: %s",wap_state_to_string(wap_state)); +#ifndef FF_SAT_E + ACI_ASSERT(DTI_DTI_ID_NOTPRESENT NEQ wap_dti_id); + ACI_ASSERT(cid >= GPRS_CID_1 AND cid < GPRS_CID_INVALID); + ACI_ASSERT(result NEQ AT_FAIL); +#endif /* not FF_SAT_E */ + + if ( result EQ AT_FAIL ) + { + /* IP activation failed. */ + TRACE_EVENT("UDP/TCP/IP activation/configuration returned AT_FAIL"); + + if (DTI_DTI_ID_NOTPRESENT NEQ wap_dti_id) + { + dti_cntrl_close_dpath_from_dti_id (wap_dti_id); + cmhSM_disconnect_cid(cid, GC_TYPE_WAP ); + } + + /* reset work_cids */ + set_state_over_cid(cid, PDP_CONTEXT_STATE_DEFINED); + + sAT_PercentWAP((T_ACI_CMD_SRC)smShrdPrm.owner, 0); + smEntStat.curCmd = AT_CMD_NONE; + + dti_cntrl_erase_entry(wap_dti_id); + cmdCmeError(CME_ERR_Unknown); + +#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E) + if( cmhSAT_OpChnGPRSPend( PDP_CONTEXT_CID_INVALID, OPCH_EST_REQ )) + { + cmhSAT_OpChnUDPDeactGprs(); + } +#endif /* SIM_TOOLKIT */ + return; + } + + switch(wap_state) + { + // in case CO_UDP_IP and FF_GPF_TCPIP is defined this is a fall through case + UDPIP_STATEMENT(case IPA_Activated:) + GPF_TCPIP_STATEMENT(case TCPIP_Activation:) + + if(is_gpf_tcpip_call()) { + GPF_TCPIP_STATEMENT(set_conn_param_on_working_cid( + (UBYTE)smEntStat.entOwn, DTI_ENTITY_TCPIP)); + } + else { + UDPIP_STATEMENT(set_conn_param_on_working_cid( + (UBYTE)smEntStat.entOwn, DTI_ENTITY_IP)); + } + cmhSM_activate_context_For_WAP(); + return; + + UDPIP_STATEMENT(case UDPA_Configurated:) + GPF_TCPIP_STATEMENT(case TCPIP_Configurated:) + + //smEntStat.curCmd = AT_CMD_NONE; +#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E) + if( cmhSAT_OpChnGPRSPend( PDP_CONTEXT_CID_INVALID, OPCH_EST_REQ )) + { + cmhSAT_OpChnUDPConfGprs(); + } + else +#endif /* SIM_TOOLKIT */ + { + R_AT ( RAT_CONNECT, smEntStat.entOwn )( AT_CMD_CGACT, -1, wapId, FALSE ); + } + smEntStat.curCmd = AT_CMD_NONE; + smEntStat.entOwn = CMD_SRC_NONE; +#ifdef FF_GPF_TCPIP + if(is_gpf_tcpip_call()) + { + T_DCM_STATUS_IND_MSG msg; + msg.hdr.msg_id = DCM_NEXT_CMD_READY_MSG; + dcm_send_message(msg, DCM_SUB_WAIT_CGACT_CNF); + } +#endif + break; + + UDPIP_STATEMENT(case IPA_Deactivated:) + GPF_TCPIP_STATEMENT(case TCPIP_Deactivated:) + + TRACE_EVENT_P1("cmhSM_IP_activate_cb, no connection, dti_id = %d", wap_dti_id); + +#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E) + if( cmhSAT_OpChnGPRSPend( PDP_CONTEXT_CID_INVALID, OPCH_NONE )) + { + cmhSAT_OpChnUDPDeactGprs(); + } + else +#endif /* SIM_TOOLKIT */ + { +#ifdef FF_GPF_TCPIP + /* Don't send NO CARRIER if it is TCPIP call */ + if (!is_gpf_tcpip_call()) +#endif + + /* TC GACIWAP232 */ + gaci_RAT_caller ( RAT_NO_CARRIER, cid, AT_CMD_CGACT, 0 ); + } + dti_cntrl_close_dpath_from_dti_id (wap_dti_id); + cmhSM_connection_down(wap_dti_id); + /*Decrease the count for the corresponding link if it is a TCPIP call */ +#ifdef FF_GPF_TCPIP + if (is_gpf_tcpip_call()) + { + GPF_TCPIP_STATEMENT(srcc_delete_count(SRCC_TCPIP_SNDCP_LINK )); + } + else +#endif + { + + cmhSM_disconnect_cid(cid, GC_TYPE_WAP ); + } + sAT_PercentWAP((T_ACI_CMD_SRC)smShrdPrm.owner, 0); + if(work_cids[cid_pointer] EQ cid) + { + smEntStat.curCmd = AT_CMD_NONE; + *work_cids = 0; + cid_pointer = 0; + } +#ifdef FF_GPF_TCPIP + if(is_gpf_tcpip_call()) + { + T_DCM_STATUS_IND_MSG msg; + msg.hdr.msg_id = DCM_NEXT_CMD_READY_MSG; + dcm_send_message(msg, DCM_SUB_WAIT_CGDEACT_CNF); + } +#endif + break; + + default: + TRACE_EVENT("Unexpected wap state in cmhSM_IP_activate_cb()"); + if(is_gpf_tcpip_call()) { + GPF_TCPIP_STATEMENT(srcc_delete_count(SRCC_TCPIP_SNDCP_LINK )); + } + else { + UDPIP_STATEMENT(srcc_delete_count(SRCC_IP_SNDCP_LINK )); + } + dti_cntrl_erase_entry(wap_dti_id); + sAT_PercentWAP((T_ACI_CMD_SRC)smShrdPrm.owner, 0); + smEntStat.curCmd = AT_CMD_NONE; + +#if defined (SIM_TOOLKIT) AND defined (FF_SAT_E) + if( cmhSAT_OpChnGPRSPend( PDP_CONTEXT_CID_INVALID, OPCH_NONE )) + { + cmhSAT_OpChnUDPDeactGprs(); + } + else +#endif /* SIM_TOOLKIT */ + { + cmdCmeError(CME_ERR_Unknown); + } + break; + } + return; +} + +GLOBAL T_ACI_RETURN cmhSM_activate_context_For_WAP(void) +{ + TRACE_FUNCTION ("cmhSM_activate_context_For_WAP()"); + + if( AT_CMPL EQ cmhGMM_attach_if_necessary( smEntStat.entOwn, AT_CMD_CGDATA ) ) + { + cmhSM_connect_working_cid(); + } + else /* AT_EXCT -> class BX class change requested (NOMIII) */ + { + /* For TC ACTSAT 510 + Activating the context for WAP + */ + gpppEntStat.curCmd = AT_CMD_CGDATA; + set_state_working_cid( PDP_CONTEXT_STATE_ATTACHING ); + } + return (AT_EXCT); +} +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : cmh_smf | +| STATE : initial ROUTINE : cmhSM_IP_Enable | ++----------------------------------------------------------------------+ + + PURPOSE : enables IP dti connection. +*/ +GLOBAL void cmhSM_IP_Enable ( T_DTI_CONN_LINK_ID link_id) +{ + TRACE_FUNCTION("cmhSM_IP_Enable"); + +#ifdef _SIMULATION_ + cmhSM_connect_context ( gaci_get_cid_over_link_id( link_id ), + DTI_ENTITY_IP ); +#else /* _SIMULATION_ */ + cmhSM_connect_context ( gaci_get_cid_over_link_id( link_id ), + DTI_ENTITY_IP ); +#endif /* _SIMULATION_ */ +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : cmh_smf | +| STATE : initial ROUTINE : cmhSM_IP_Disable | ++----------------------------------------------------------------------+ + + PURPOSE : disables IP dti connection. +*/ +GLOBAL void cmhSM_IP_Disable () +{ + TRACE_FUNCTION("cmhSM_IP_Disable"); +} + +#endif /* WAP OR FF_GPF_TCPIP OR SAT E */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_data_link_context | ++-------------------------------------------------------------------+ +*/ + +GLOBAL void cmhSM_data_link_context(void) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION ("cmhSM_data_link_context()"); + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + if( p_pdp_context_node ) + { +#if defined FF_WAP + if(!Wap_Call) + { + R_AT( RAT_CONNECT, p_pdp_context_node->internal_data.owner ) + ( AT_CMD_CGDATA, 0, 0, FALSE ); + } +#else + R_AT( RAT_CONNECT, p_pdp_context_node->internal_data.owner ) + ( AT_CMD_CGDATA, 0, 0, FALSE ); +#endif /* WAP OR SAT E */ + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_data_link_context" ); + } + + + + /* log result */ + if( p_pdp_context_node ) + cmh_logRslt ( p_pdp_context_node->internal_data.owner, + RAT_CONNECT, AT_CMD_CGDATA, -1, BS_SPEED_NotPresent,CME_ERR_NotPresent ); + + cmhSM_connect_working_cid(); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_next_work_cid | ++-------------------------------------------------------------------+ + + PURPOSE : start the next context activation if requested + +*/ +GLOBAL BOOL cmhSM_next_work_cid ( T_ACI_AT_CMD curCmd ) +{ + + TRACE_EVENT_P1("cmhSM_next_work_cid, cid_pointer: %d", cid_pointer); + + cid_pointer ++; + + if ( work_cids[cid_pointer] EQ PDP_CONTEXT_CID_INVALID ) + { + smEntStat.curCmd = AT_CMD_NONE; + gpppEntStat.curCmd = AT_CMD_NONE; + + cid_pointer = 0; + memset( work_cids, PDP_CONTEXT_CID_INVALID, sizeof(work_cids) ); // *work_cids = 0; + + return FALSE; + } + + switch ( curCmd ) + { + case AT_CMD_CGDATA: + cmhSM_data_link_context(); + break; + case AT_CMD_CGACT: + cmhSM_activate_context(); + break; + default: + cid_pointer = 0; + *work_cids = 0; + return FALSE; + } + return TRUE; +} + + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_make_active_cid_list | ++-------------------------------------------------------------------+ + + PURPOSE : moves cids into work_cids list, verifies cid range, + checks for duplicated cids and checks that the context + is active. If no cids are specified, all active cids are + put into the work_cids list. + Used by the sAT_PlusCGCMOD command. + RETURN : Number of cids in work_cids list. + +*/ +GLOBAL SHORT cmhSM_make_active_cid_list ( T_ACI_CMD_SRC srcId, U8 *cids ) +{ + U8 i, j; + + cid_pointer = 0; + if( cids[0] NEQ PDP_CONTEXT_CID_INVALID ) + { + /* A number of cids are listed in *cids */ + i = 0; + while( (i<PDP_CONTEXT_CID_MAX) AND (cids[i] NEQ PDP_CONTEXT_CID_INVALID) ) + { + /* Check for duplicated cids (no check the first time). */ + for (j=0; j<i; j++) + if (work_cids[j] EQ cids[i]) return 0; + + /* Check for valid cid range */ + if( (cids[i] < PDP_CONTEXT_CID_MIN) OR (cids[i] > PDP_CONTEXT_CID_MAX) ) + return 0; + + /* Check that context state for cid is Active */ + if( (get_state_over_cid( (U8)(i+1) ) NEQ PDP_CONTEXT_STATE_ACTIVATED) AND + (get_state_over_cid( (U8)(i+1) ) NEQ PDP_CONTEXT_STATE_DATA_LINK) ) + return 0; + + /* This cid is OK: store in works_cids list */ + work_cids[i] = cids[i]; + i++; + } + work_cids[i] = PDP_CONTEXT_CID_INVALID; + /* Success!!! */ + return i; + } + else + { + /* No cids are listed in *cids. Apply cids for all Active context (check not necessary). */ + j = 0; + i = 1; + while (i<=PDP_CONTEXT_CID_MAX) + { + if( (get_state_over_cid(i) EQ PDP_CONTEXT_STATE_ACTIVATED) OR + (get_state_over_cid(i) EQ PDP_CONTEXT_STATE_DATA_LINK) ) + { + work_cids[j] = i; + j++; + } + i++; + } + work_cids[j] = PDP_CONTEXT_CID_INVALID; + return j; + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : UMTS MODULE : CMH_SMR | +| STATE : finnished ROUTINE : cmhSM_Set_pdp_type | ++-------------------------------------------------------------------+ + + PURPOSE : Set the pdp_type for a given cid. + RETURN : - +*/ +GLOBAL void cmhSM_Set_pdp_type( U8 cid, char *pdp_type ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + + if( p_pdp_context_node ) + { + memcpy( p_pdp_context_node->attributes.pdp_type, pdp_type, sizeof(T_PDP_TYPE) ); + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_Set_pdp_type"); + } + +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_get_pdp_addr_for_CGPADDR | ++----------------------------------------------------------------------+ + + PURPOSE : return the PDP_address to one cid for the GPRS CGPADDR AT command + +*/ +GLOBAL U8 cmhSM_get_pdp_addr_for_CGPADDR( U8 cid, T_NAS_ip * pdp_adress ) +{ + T_PDP_CONTEXT_STATE c_state; /* state of context */ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + + if( p_pdp_context_node ) + { + + c_state = get_state_over_cid( cid ); + + if ( c_state EQ PDP_CONTEXT_STATE_INVALID ) + { + //*pdp_adress = 0; + pdp_adress->ctrl_ip_address = NAS_is_ip_not_present; + return PDP_CONTEXT_CID_INVALID; + } + + if ( c_state EQ PDP_CONTEXT_STATE_ACTIVATED OR c_state EQ PDP_CONTEXT_STATE_DATA_LINK ) + { + memcpy(pdp_adress, &(p_pdp_context_node->internal_data.pdp_address_allocated), sizeof(T_NAS_ip)); + } + else + { + memcpy(pdp_adress, &(p_pdp_context_node->attributes.pdp_addr), sizeof(T_NAS_ip)); + } + + return cid; + } + else + { + pdp_adress->ctrl_ip_address = NAS_is_ip_not_present; + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_get_pdp_addr_for_CGPADDR" ); + return PDP_CONTEXT_CID_INVALID; + } + +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_is_smreg_ti_used | ++----------------------------------------------------------------------+ + + PURPOSE : handle for used ti + +*/ +GLOBAL BOOL cmhSM_is_smreg_ti_used ( U8 ti, U8 *cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_smreg_ti( ti ); + if( p_pdp_context_node ) + { + psaSM_PDP_Deactivate( (USHORT) (1 << CID_TO_NSAPI(p_pdp_context_node->cid) ), PS_REL_IND_YES ); + psaGPPP_Terminate( PPP_LOWER_LAYER_UP ); + + call_waits_in_table = TRUE; + set_state_over_cid( p_pdp_context_node->cid, PDP_CONTEXT_STATE_REACTIVATION_1 ); + *cid = p_pdp_context_node->cid; + return TRUE; + } + + return FALSE; +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_context_reactivation | ++----------------------------------------------------------------------+ + + PURPOSE : + +*/ +GLOBAL void cmhSM_context_reactivation ( void ) +{ + T_CGEREP_EVENT_REP_PARAM event; + T_SMREG_PDP_ACTIVATE_IND *sm_ind; + SHORT i = 0; + + if ( call_waits_in_table EQ TRUE ) + { + call_waits_in_table = FALSE; + /* + * GPRS event reporting + */ + sm_ind = &gprs_call_table[current_gprs_ct_index].sm_ind; + + cmhSM_pdp_typ_to_string(sm_ind->pdp_type, (char*) &event.act.pdp_type); + memcpy(&event.act.pdp_addr, &sm_ind->ip_address.ipv4_addr.a4, NAS_SIZE_IPv4_ADDR); + event.act.cid = gprs_call_table[current_gprs_ct_index].cid; + for( i = 0 ; i < CMD_SRC_MAX; i++ ) + { + R_AT( RAT_CRING,(T_ACI_CMD_SRC)i ) ( CRING_MOD_Gprs, CRING_SERV_TYP_GPRS, CRING_SERV_TYP_NotPresent ); + R_AT( RAT_CGEREP, (T_ACI_CMD_SRC)i ) ( CGEREP_EVENT_NW_REACT, &event ); + R_AT( RAT_P_CGEV, (T_ACI_CMD_SRC)i ) ( CGEREP_EVENT_NW_REACT, &event ); + } + } + else + { + cmhSM_next_call_table_entry(); + } +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_stop_context_reactivation | ++----------------------------------------------------------------------+ + + PURPOSE : + +*/ +GLOBAL void cmhSM_stop_context_reactivation ( void ) +{ + + call_waits_in_table = FALSE; +} + +GLOBAL void cmhSM_next_call_table_entry( void ) +{ + current_gprs_ct_index++; + + if ( current_gprs_ct_index >= gprs_ct_index ) + { + cmhSM_empty_call_table(); + } + else + { + cmhSM_context_reactivation(); + } +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_init_GPRS_DTI_list | ++----------------------------------------------------------------------+ + + PURPOSE : Init all DTI identifier for GPRS. +*/ +GLOBAL SHORT cmhSM_connect_working_cid ( void ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + UBYTE dti_id; + + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[cid_pointer] ); + + if( p_pdp_context_node ) + { + switch ( p_pdp_context_node->internal_data.entity_id ) + { + case DTI_ENTITY_PPPS: + { + + srcc_new_count( SRCC_PPPS_SNDCP_LINK ); + + if( IS_SRC_BT(p_pdp_context_node->internal_data.owner) ) + { + #if defined TI_GPRS OR TI_DUAL_MODE + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_BLUETOOTH, DTI_ENTITY_PPPS, DTI_ENTITY_UPM, DTI_ENTITY_SNDCP}; + #else /* TI_GPRS OR TI_DUAL_MODE */ + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_BLUETOOTH, DTI_ENTITY_PPPS, DTI_ENTITY_SNDCP}; + #endif /* TI_GPRS OR TI_DUAL_MODE */ + + + dti_id = dti_cntrl_new_dti( DTI_DTI_ID_NOTPRESENT ); + dti_cntrl_est_dpath ( dti_id, + entity_list, + GET_NUM_OF_DTI_ENTITIES(entity_list), + SPLIT, + PPP_UART_connect_dti_cb); + } + else + { + #if defined TI_GPRS OR TI_DUAL_MODE + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_PPPS, DTI_ENTITY_UPM, DTI_ENTITY_SNDCP}; + #else /* TI_GPRS OR TI_DUAL_MODE */ + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_PPPS, DTI_ENTITY_SNDCP}; + #endif /* TI_GPRS OR TI_DUAL_MODE */ + + dti_cntrl_est_dpath_indirect( (UBYTE)p_pdp_context_node->internal_data.owner, + entity_list, + GET_NUM_OF_DTI_ENTITIES(entity_list), + SPLIT, + PPP_UART_connect_dti_cb, + DTI_CPBLTY_SER, + (UBYTE)work_cids[cid_pointer] ); + + } + + m_mt_te_link = TRUE; + break; + } + + case DTI_ENTITY_IP: +#if defined CO_UDP_IP + { + #if defined TI_GPRS OR TI_DUAL_MODE + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_IP, DTI_ENTITY_UPM, DTI_ENTITY_SNDCP}; + #else /* TI_GPRS OR TI_DUAL_MODE */ + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_IP, DTI_ENTITY_SNDCP}; + #endif /* TI_GPRS OR TI_DUAL_MODE */ +#ifdef FF_SAT_E + if ( satShrdPrm.opchStat EQ OPCH_EST_REQ ) + dti_id = simShrdPrm.sat_class_e_dti_id; + else +#endif /* FF_SAT_E */ + dti_id = wap_dti_id; + + /* link_id should be created in atGD already, so just connect: */ + if( !dti_cntrl_est_dpath( dti_id, + entity_list, + GET_NUM_OF_DTI_ENTITIES(entity_list), + APPEND, + IP_UDP_connect_dti_cb) ) + { + TRACE_EVENT("cmhSM_connect_working_cid: dti_cntrl_est_dpath returned FALSE"); + return 0; + } + } +#endif /* CO_UDP_IP */ + break; +#ifdef FF_SAT_E + case DTI_ENTITY_SIM: + { + #if defined TI_GPRS OR TI_DUAL_MODE + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SIM, DTI_ENTITY_UPM, DTI_ENTITY_SNDCP}; + #else /* TI_GPRS OR TI_DUAL_MODE */ + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SIM, DTI_ENTITY_SNDCP}; + #endif /* TI_GPRS OR TI_DUAL_MODE */ + + if ( simShrdPrm.sat_class_e_dti_id EQ DTI_DTI_ID_NOTPRESENT ) + { + simShrdPrm.sat_class_e_dti_id = dti_cntrl_new_dti(DTI_DTI_ID_NOTPRESENT); + TRACE_EVENT_P1("sat_class_e_dti_id = %d", simShrdPrm.sat_class_e_dti_id); + } + + srcc_new_count( SRCC_SIM_SNDCP_LINK ); + + p_pdp_context_node->internal_data.link_id = dti_conn_compose_link_id( 0, 0, simShrdPrm.sat_class_e_dti_id, DTI_TUPLE_NO_NOTPRESENT ); + dti_cntrl_est_dpath( simShrdPrm.sat_class_e_dti_id, + entity_list, + GET_NUM_OF_DTI_ENTITIES(entity_list), + SPLIT, + SIM_SNDCP_connect_dti_cb ); + + break; + } +#endif /* FF_SAT_E */ + +#if defined (FF_GPF_TCPIP) + case DTI_ENTITY_TCPIP: + { + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_TCPIP, DTI_ENTITY_SNDCP}; + UBYTE dti_id; + dti_id = wap_dti_id; + /* link_id should be created in atGD already, so just connect: */ + if (!dti_cntrl_est_dpath( dti_id, + entity_list, + 2, + SPLIT, + TCPIP_connect_dti_cb)) + { + TRACE_EVENT("cmhSM_connect_working_cid: dti_cntrl_est_dpath returned FALSE"); + return 0; + } + } + break; +#endif // FF_GPF_TCPIP + + +#if defined(FF_PKTIO) OR defined(FF_TCP_IP) OR defined (FF_PSI) + case DTI_ENTITY_INVALID: + { + #if defined TI_GPRS OR TI_DUAL_MODE + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_UPM, DTI_ENTITY_SNDCP}; + #else /* TI_GPRS OR TI_DUAL_MODE */ + T_DTI_ENTITY_ID entity_list[] = {DTI_ENTITY_SNDCP}; + #endif /* TI_GPRS OR TI_DUAL_MODE */ + + srcc_new_count( SRCC_PKTIO_SNDCP_LINK ); + + dti_cntrl_est_dpath_indirect( (UBYTE)p_pdp_context_node->internal_data.owner, + entity_list, + GET_NUM_OF_DTI_ENTITIES(entity_list), + SPLIT, + PKTIO_SNDCP_connect_dti_cb, + DTI_CPBLTY_PKT, + (UBYTE)work_cids[cid_pointer] ); + + /* + Issue 31781 - If the PDP context is not activated then activate the context. + */ + switch ( get_state_working_cid( ) ) + { + case PDP_CONTEXT_STATE_DEFINED: + case PDP_CONTEXT_STATE_ATTACHING: + { + cmhSM_activate_context(); + } + break; + } + break; + } +#else /* FF_PKTIO OR FF_TCP_IP OR FF_PSI */ + case DTI_ENTITY_INVALID: + { + TRACE_ERROR("cmhSM_connect_working_cid(): DTI_ENTITY_INVALID is illegal for this product!!!"); + break; + } +#endif /* FF_PKTIO OR FF_TCP_IP */ + + default: + return 0; + + } + } + + return 1; +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : cmhSM_disconnect_cid | ++----------------------------------------------------------------------+ + + PURPOSE : +*/ +GLOBAL void cmhSM_disconnect_cid ( SHORT cid, T_GPRS_CONNECT_TYPE type ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("cmhSM_disconnect_cid"); + + p_pdp_context_node = pdp_context_find_node_from_cid((U8) cid ); + + if( p_pdp_context_node ) + { + + if ( DTI_LINK_ID_NOTPRESENT NEQ p_pdp_context_node->internal_data.link_id) + { + switch ( type ) + { + case GC_TYPE_DATA_LINK: + srcc_delete_count( SRCC_PPPS_SNDCP_LINK ); + p_pdp_context_node->internal_data.link_id = DTI_LINK_ID_NOTPRESENT; + p_pdp_context_node->internal_data.link_id_uart = DTI_LINK_ID_NOTPRESENT; + m_mt_te_link = FALSE; + break; + +#if defined (FF_WAP) OR defined (FF_SAT_E) + case GC_TYPE_WAP: + srcc_delete_count( SRCC_IP_SNDCP_LINK ); + p_pdp_context_node->internal_data.link_id = DTI_LINK_ID_NOTPRESENT; + break; +#endif /* FF_WAP OR SAT E */ + + case GC_TYPE_NULL: + case GC_TYPE_EMAIL: + switch ( p_pdp_context_node->internal_data.entity_id ) + { + case DTI_ENTITY_IP: + srcc_delete_count( SRCC_IP_SNDCP_LINK); + p_pdp_context_node->internal_data.link_id = DTI_LINK_ID_NOTPRESENT; + break; +#if defined(FF_PKTIO) OR defined(FF_TCP_IP) OR defined(FF_GPF_TCPIP) OR defined (FF_PSI) + case DTI_ENTITY_PKTIO: + case DTI_ENTITY_PSI: + case DTI_ENTITY_AAA: + srcc_delete_count( SRCC_PKTIO_SNDCP_LINK ); + p_pdp_context_node->internal_data.link_id = DTI_LINK_ID_NOTPRESENT; + break; +#endif /* FF_PKTIO OR FF_TCP_IP OR FF_GPF_TCPIP OR FF_PSI */ + } + break; + } + } + } + else + { + TRACE_ERROR( "PDP context not found" ); + } +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : MODULE : CMH_SMF | +| STATE : ROUTINE : uart_is_mt_te_link | ++----------------------------------------------------------------------+ + + PURPOSE : +*/ +GLOBAL BOOL uart_is_mt_te_link( void ) +{ + + return m_mt_te_link; +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_connect_context | ++----------------------------------------------------------------------+ + + PURPOSE : Activate the context or if the context is already activated + then activate the user plane. + (PPP_ACTIVATE_IND is just received). +*/ +GLOBAL SHORT cmhSM_connect_context ( U8 cid, T_DTI_ENTITY_ID peer ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + U8 hcomp; + U8 dcomp; + + TRACE_FUNCTION( "cmhSM_connect_context()" ); + + /* hcomp value being changed according to spec 27.007 */ + hcomp = cmhSM_Get_h_comp() ; + dcomp = cmhSM_Get_d_comp() ; + + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + /* + * Activate the context if not already activated. + */ + if (p_pdp_context_node) + { + switch (get_state_over_cid(cid)) + { + case PDP_CONTEXT_STATE_ESTABLISH_1: + if( p_pdp_context_node->type EQ PDP_CONTEXT_TYPE_PRIMARY ) + { + psaSM_smreg_pdp_activate_req( cid, + hcomp, + dcomp); + /*, + PS_RAT_UMTS_FDD);*/ + } +#ifdef REL99 + else if( p_pdp_context_node->type EQ PDP_CONTEXT_TYPE_SECONDARY ) + { + psaSM_smreg_pdp_activate_sec_req( cid ); + } +#endif + return 1; + default: + TRACE_ERROR("cmhSM_connect_context: Wrong state!!!"); + return 0; + } + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, in function cmhSM_connect_context" ); + return 0; + } +} + + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_set_PCO | ++----------------------------------------------------------------------+ + + PURPOSE : Set a PCO in the context of the cid. +*/ +GLOBAL void cmhSM_set_PCO( U8 cid, T_PCO_TYPE pco_type, UBYTE* buf_addr, UBYTE length ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + switch( pco_type ) + { + case PCO_USER: + { + /*lint -e(644) */ /* all possible types defined */ + memcpy( &p_pdp_context_node->internal_data.user_pco.pco, buf_addr, length ); + p_pdp_context_node->internal_data.user_pco.len = length; + break; + } + + case PCO_NETWORK: + { + memcpy( &p_pdp_context_node->internal_data.network_pco.pco, buf_addr, length ); + p_pdp_context_node->internal_data.network_pco.len = length; + break; + } + + } + + } + else + { + TRACE_ERROR( "ERROR: PDP context not found, invalid cid" ); + } + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSM_CGPCO_HEX | ++--------------------------------------------------------------------+ + +PURPOSE : This is the functional counterpart to the %CGPCO= AT + command to set protocol configuration options for the + PDP context activation. +*/ + +GLOBAL T_ACI_RETURN cmhSM_CGPCO_HEX (U8 cid, + UBYTE *pco_array, + UBYTE pco_len ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + T_ACI_RETURN ret = AT_CMPL; + U8 i; + + TRACE_FUNCTION("cmhSM_CGPCO_HEX"); + + if (pco_len EQ 0) + { + if( cid EQ PDP_CONTEXT_CID_OMITTED ) + { + /* For later contexts */ + pdp_context_default.internal_data.user_pco.len = 0; + memset( &pdp_context_default.internal_data.user_pco, 0, sizeof(T_PDP_CONTEXT_PCO) ); + + /* For defined contexts */ + for( i = PDP_CONTEXT_CID_MIN; i <= PDP_CONTEXT_CID_MAX; i++) + { + p_pdp_context_node = pdp_context_find_node_from_cid( i ); + + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.user_pco.len = 0; + memset( &p_pdp_context_node->internal_data.user_pco, 0, sizeof(T_PDP_CONTEXT_PCO) ); + } + } + } + else + { + /* For specified context */ + p_pdp_context_node = pdp_context_find_node_from_cid( (U8)cid ); + + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.user_pco.len = 0; + memset( &p_pdp_context_node->internal_data.user_pco, 0, sizeof(T_PDP_CONTEXT_PCO) ); + } + else + { + TRACE_EVENT_P1("PDP context for cid = %d not found.", cid ); + ret = AT_FAIL; + } + } + } + else + { + if( cid EQ PDP_CONTEXT_CID_OMITTED ) + { + /* For later contexts */ + pdp_context_default.internal_data.user_pco.len = pco_len; + memcpy( &pdp_context_default.internal_data.user_pco, pco_array, pco_len ); + + /* For defined contexts */ + for( i = PDP_CONTEXT_CID_MIN; i <= PDP_CONTEXT_CID_MAX; i++) + { + p_pdp_context_node = pdp_context_find_node_from_cid( i ); + + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.user_pco.len = pco_len; + memcpy( &p_pdp_context_node->internal_data.user_pco.pco, pco_array, pco_len ); + } + } + } + else + { + /* For specified context */ + p_pdp_context_node = pdp_context_find_node_from_cid( (U8)cid ); + + if( p_pdp_context_node ) + { + p_pdp_context_node->internal_data.user_pco.len = pco_len; + memcpy( &p_pdp_context_node->internal_data.user_pco.pco, pco_array, pco_len ); + } + else + { + TRACE_EVENT_P1("PDP context for cid = %d not found.", cid ); + ret = AT_FAIL; + } + } + } + return (ret); +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_get_dti_UPM_peer | ++----------------------------------------------------------------------+ + + PURPOSE : Give back the link_id for the UPM peer. +*/ +GLOBAL ULONG cmhSM_get_link_id_UPM_peer( U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( p_pdp_context_node ) + { + return p_pdp_context_node->internal_data.link_id; + } + + return DTI_LINK_ID_NOTPRESENT; +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : code ROUTINE : cmhSM_context_deactivated | ++----------------------------------------------------------------------+ + + PURPOSE : Control the answer of context deactivations + started by an AT command. +*/ +GLOBAL void cmhSM_context_deactivated( USHORT nsapi_set ) +{ + + switch( working_cgact_actions.state ) + { + case T_CDS_RUNNING: + /* For TC ACISAT531 + We do not need OK for SAT invoked context ! + */ +#if defined (FF_SAT_E) + if( ( satShrdPrm.chnTb.chnUsdFlg ) AND + ( satShrdPrm.chnTb.chnType EQ B_GPRS ) ) + { + if( nsapi_set EQ (1U << CID_TO_NSAPI(satShrdPrm.chnTb.chnRefId) ) ) + { + working_cgact_actions.nsapi_set &= ~nsapi_set; + if ( ! working_cgact_actions.nsapi_set ) + { + working_cgact_actions.state = T_CDS_IDLE; + return; + } + } + } +#endif /* SAT Class E */ + + if ( nsapi_set & working_cgact_actions.nsapi_set ) + { /* nsapi deactivation is requested */ + working_cgact_actions.nsapi_set &= ~nsapi_set; + if ( ! working_cgact_actions.nsapi_set ) + { + R_AT( RAT_OK, working_cgact_actions.srcId ) ( AT_CMD_CGACT ); + working_cgact_actions.state = T_CDS_IDLE; + } + } + break; + case T_CDS_IDLE: + break; + } +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GSM-PS (8441) MODULE : CMH_SMS | +| STATE : finnished ROUTINE : deactivateAContextForCGACT | ++----------------------------------------------------------------------+ + +PURPOSE : deactivate a context for CGACT + +RETURN VALUE : TRUE - AT_EXCT have to be returned for this context + FALSE - AT_CMPL have to be reported for this context + +*/ +T_ACI_RETURN deactivateAContextForCGACT(U8 cid) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("deactivateAContextForCGACT()"); + + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if( !p_pdp_context_node ) + { + TRACE_EVENT("ERROR: PDP context not defined"); + return( AT_FAIL ); + } + +#if defined (CO_UDP_IP) OR defined (FF_GPF_TCPIP) + /* + * additinal behaviour for WAP + * abort ATD*98# before context activation requested + * 2003.05.06 brz + */ + if( TRUE NEQ srcc_reserve_sources( SRCC_IP_SNDCP_LINK, 1 ) AND + DTI_LINK_ID_NOTPRESENT NEQ p_pdp_context_node->internal_data.link_id_new AND + cid EQ work_cids[cid_pointer] OR + p_pdp_context_node->internal_data.entity_id EQ DTI_ENTITY_IP ) + { + /* tell WAP ACI that contextactivation was rejected */ + TRACE_EVENT("Tell WAP ACI that contextactivation was rejected"); + psaTCPIP_Deactivate(cmhSM_IP_activate_cb); + + if ( PDP_CONTEXT_STATE_DEFINED EQ p_pdp_context_node->internal_data.state ) + { + if(is_gpf_tcpip_call()) { + GPF_TCPIP_STATEMENT(wap_state = TCPIP_Deactivation); + } + else { + wap_state = UDPA_Deactivation; + } + dti_cntrl_close_dpath_from_dti_id( + EXTRACT_DTI_ID(p_pdp_context_node->internal_data.link_id)); + } + + /* srcc_delete_count(SRCC_IP_SNDCP_LINK); */ + return cmhSM_deactivateAContext(CMD_SRC_NONE, cid); + } + else +#endif /* CO_UDP_IP OR FF_GPF_TCPIP */ + if( PDP_CONTEXT_STATE_DEFINED NEQ p_pdp_context_node->internal_data.state AND + PDP_CONTEXT_STATE_INVALID NEQ p_pdp_context_node->internal_data.state ) + { + return cmhSM_deactivateAContext(CMD_SRC_NONE, cid); + } + return AT_CMPL; +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_deactivateAContext | ++----------------------------------------------------------------------+ + + PURPOSE : deactivate some contexts (able for serial multiplexer mode). +*/ +GLOBAL T_ACI_RETURN cmhSM_deactivateContexts( T_ACI_CMD_SRC srcId, SHORT *cids) +{ + T_ACI_RETURN ret_value = AT_CMPL; + USHORT nsapi_set = 0; + U8 cid_set = 0; + SHORT i = 0; + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("cmhSM_deactivateContexts"); + + if( T_CDS_RUNNING EQ working_cgact_actions.state) { + TRACE_EVENT("cgact_ation is running: bussy returned"); + return AT_FAIL; /* AT_BUSY */ + } + + cid_pointer = 0; + if( *cids EQ PDP_CONTEXT_CID_INVALID ) + { /* all available contexts */ + + p_pdp_context_node = p_pdp_context_list; + while( p_pdp_context_node ) + { + work_cids[i] = p_pdp_context_node->cid; + i++; + p_pdp_context_node = p_pdp_context_node->p_next; + } + + work_cids[i] = PDP_CONTEXT_CID_INVALID; + + if( work_cids[0] EQ PDP_CONTEXT_CID_INVALID ) + { + return AT_CMPL; + } + } + else + { /* copy cid list */ + + for( i = 0; cids[i] NEQ PDP_CONTEXT_CID_INVALID; i++ ) + { + work_cids[i] = (U8)cids[i]; + } + } + + for(i = 0; work_cids[i] NEQ PDP_CONTEXT_CID_INVALID; i++) + { + p_pdp_context_node = pdp_context_find_node_from_cid( work_cids[i] ); + + if( !p_pdp_context_node ) + continue; + + if(AT_EXCT EQ deactivateAContextForCGACT( work_cids[i] )) + { + ret_value = AT_EXCT; + nsapi_set |= ( 1 << CID_TO_NSAPI (work_cids[i]) ); + cid_set |= ( 1 << work_cids[i] ); + } + } + + if( nsapi_set ) { + working_cgact_actions.state = T_CDS_RUNNING; + working_cgact_actions.nsapi_set = nsapi_set; + working_cgact_actions.srcId = srcId; + working_cgact_actions.cid_set = cid_set; + } + + cmhSM_stop_context_reactivation(); + + return ret_value; +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_CGACT_start | ++----------------------------------------------------------------------+ + + PURPOSE : Set specific +CGACT command parameter. +*/ +GLOBAL void cmhSM_CGACT_start( T_CGACT_STATE state, USHORT nsapi_set ) +{ + + working_cgact_actions.state = (T_CONTEXTS_DEACTIVATION_STATUS)state; + working_cgact_actions.nsapi_set = nsapi_set; + +} + + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_getCurQOS | ++----------------------------------------------------------------------+ + + PURPOSE : This function returns the current QOS settings. +*/ +#ifdef FF_SAT_E +GLOBAL T_PS_qos* cmhSM_getCurQOS( U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + if (p_pdp_context_node) + return &p_pdp_context_node->qos; + return NULL; +} +#endif /* FF_SAT_E */ + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_deactivateAContext | ++----------------------------------------------------------------------+ + + PURPOSE : deactivate a contexts (able for serial multiplexer mode). +*/ +GLOBAL T_ACI_RETURN cmhSM_deactivateAContext( T_ACI_CMD_SRC srcId, U8 cid ) +{ + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + TRACE_FUNCTION("cmhSM_deactivateAContext()") ; + + switch( get_state_over_cid( cid ) ) + { + case PDP_CONTEXT_STATE_INVALID: + case PDP_CONTEXT_STATE_DEFINED: + /* + * context ís deactivated -> not action necessary + */ + break; + + case PDP_CONTEXT_STATE_ATTACHING: + /* + * +CGDATA or +CGACT has started the attach procedure and which is stopped. + */ + set_state_over_cid( cid, PDP_CONTEXT_STATE_DEFINED ); + psaGMM_Detach( GMMREG_DT_GPRS ); + gpppEntStat.curCmd = AT_CMD_NONE; + smEntStat.curCmd = AT_CMD_NONE; + work_cids[0] = PDP_CONTEXT_CID_INVALID; + cid_pointer = 0; + if( CMD_SRC_NONE EQ srcId ) + { + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + p_pdp_context_node->internal_data.owner = gpppEntStat.entOwn; + gaci_RAT_caller ( RAT_NO_CARRIER, cid, AT_CMD_CGDATA, 0 ); + } + return AT_CMPL; + + case PDP_CONTEXT_STATE_ESTABLISH_1: + /* + * context not activated, but PPP has to be terminated + */ + set_state_over_cid( cid, PDP_CONTEXT_STATE_ABORT_ESTABLISH ); + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + dti_cntrl_entity_disconnected( p_pdp_context_node->internal_data.link_id_new, DTI_ENTITY_SNDCP ); + if (uartShrdPrm.escape_seq EQ UART_DETECT_ESC) + { + psaGPPP_Terminate( PPP_LOWER_LAYER_DOWN ); + } + else + { + psaGPPP_Terminate( PPP_LOWER_LAYER_UP ); + } + uartShrdPrm.escape_seq = UART_DETECT_DTR; + /* The user plane will be closed when the PPP_TERMINATE_IND is received */ + return AT_EXCT; + + case PDP_CONTEXT_STATE_DATA_LINK: + case PDP_CONTEXT_STATE_ESTABLISH_2: + case PDP_CONTEXT_STATE_ESTABLISH_3: + case PDP_CONTEXT_STATE_ACTIVATED_ESTABLISH_1: + /* + * context has to be deactivated and PPP has to be terminated + */ + set_state_over_cid( cid, PDP_CONTEXT_STATE_REACTIVATION_1 ); + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + psaSM_PDP_Deactivate( (USHORT) (1 << CID_TO_NSAPI( cid )), PS_REL_IND_NO); + /* The terminate request to PPP entitiy will be done in DTI for the + disconnection when PSI is enabled */ +#ifndef FF_PSI + psaGPPP_Terminate( PPP_LOWER_LAYER_UP ); +#endif /* FF_PSI */ + return AT_EXCT; + + case PDP_CONTEXT_STATE_ACTIVATED: + case PDP_CONTEXT_STATE_ACTIVATING: + /* + * +CGACT aborted + */ + set_state_over_cid( cid, PDP_CONTEXT_STATE_DEACTIVATE_NORMAL ); + p_pdp_context_node = pdp_context_find_node_from_cid( cid ); + psaSM_PDP_Deactivate( (USHORT) (1 << CID_TO_NSAPI( cid )), PS_REL_IND_NO); + + if( p_pdp_context_node->internal_data.entity_id EQ DTI_ENTITY_PKTIO ) + { + /* For PKTIO we are not maintaining any other states other than + PDP_CONTEXT_STATE_ACTIVATED and PDP_CONTEXT_STATE_ACTIVATING + and in this case after entering data mode if we deactivate the + PDP context, we are not taking care of freeing the DTI links + between PKTIO and other Neighboring entity + This is done if the entity is PKTIO. + As for PPP the DTI link free is taken care by PPP + primitives between ACI and PPP + */ + TRACE_EVENT("cmhSM_deactivateAContext: Free the DTI Links fpr PKTIO Entity after CGACT=0,1"); + TRACE_EVENT("States: PDP_CONTEXT_STATE_ACTIVATED OR PDP_CONTEXT_STATE_ACTIVATING"); + dti_cntrl_close_dpath_from_dti_id (EXTRACT_DTI_ID(p_pdp_context_node->internal_data.link_id)); + } + return AT_EXCT; + + case PDP_CONTEXT_STATE_ABORT_ESTABLISH: + case PDP_CONTEXT_STATE_DEACTIVATE_NORMAL: + case PDP_CONTEXT_STATE_BREAKDOWN_LINK_NORMAL: + /* + * context is during deactivation procedure -> not action necessary + */ + return AT_EXCT; + + case PDP_CONTEXT_STATE_REACTIVATION_1: + case PDP_CONTEXT_STATE_REACTIVATION_2: + /* + * context is during deactivation procedure + * -> not action for context deactivation or PPP termination necessary + */ + return AT_EXCT; + } + + return AT_FAIL; +} + + +GLOBAL BOOL cmhSM_isContextActive( void ) +{ + + T_PDP_CONTEXT_INTERNAL *p_pdp_context_node = NULL; + + p_pdp_context_node = p_pdp_context_list; + + while( p_pdp_context_node ) + { + if( p_pdp_context_node->internal_data.state EQ PDP_CONTEXT_STATE_ACTIVATED OR + p_pdp_context_node->internal_data.state EQ PDP_CONTEXT_STATE_ACTIVATED_ESTABLISH_1 OR + p_pdp_context_node->internal_data.state EQ PDP_CONTEXT_STATE_ACTIVATED_MODIFYING OR + p_pdp_context_node->internal_data.state EQ PDP_CONTEXT_STATE_DATA_LINK OR + p_pdp_context_node->internal_data.state EQ PDP_CONTEXT_STATE_DATA_LINK_MODIFYING ) + + return TRUE; + else + p_pdp_context_node = p_pdp_context_node->p_next; + } + + return FALSE; + +} + + +LOCAL void cmhSM_free_pdpcontext_tft(T_TFT_INTERNAL * pdp_tft) +{ + TRACE_FUNCTION("cmhSM_free_pdpcontext_tft"); + if(pdp_tft->p_next) + { + cmhSM_free_pdpcontext_tft(pdp_tft->p_next); + } + ACI_MFREE(pdp_tft); + +} + + +LOCAL void cmhSM_free_pdpcontext( T_PDP_CONTEXT_INTERNAL * p_pdp_context) +{ + //recursive call so that the contexts will be deallocated from last to first. + //when p_next pointer is null, it will proceed to deallocate the PDP context itself + TRACE_FUNCTION("cmhSM_free_pdpcontext"); + if (p_pdp_context->p_next) + { + cmhSM_free_pdpcontext(p_pdp_context->p_next); + } + //If one exist, it shall be deallocated together with the PDP context + if (p_pdp_context->internal_data.p_pdp_activate_cnf) + { + ACI_MFREE(p_pdp_context->internal_data.p_pdp_activate_cnf); + } + + if (p_pdp_context->p_tft_pf) + { + cmhSM_free_pdpcontext_tft(p_pdp_context->p_tft_pf); + } + + ACI_MFREE(p_pdp_context); +} + + +GLOBAL void cmhSM_free_pdpcontext_list(void) +{ + TRACE_FUNCTION("cmhSM_free_pdpcontext_list"); + if (p_pdp_context_list) + cmhSM_free_pdpcontext(p_pdp_context_list); +} + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_mapSM2ACI_Cause() | ++----------------------------------------------------------------------+ + + PURPOSE : The below function is used to MAP the SMREG cause values + sent by N/W to the ACI specific ERROR's. Refer 27.007 + Section 9.2. +*/ + +GLOBAL UBYTE cmhSM_mapSM2ACI_Cause(U16 cause_value) +{ + TRACE_FUNCTION("cmhSM_mapSM2ACI_Cause"); + + switch(cause_value) + { + case CAUSE_NWSM_USER_AUTH_FAILED : + return CME_ERR_GPRSPdpAuth; + + case CAUSE_NWSM_SERVICE_NOT_SUPPORTED : + return CME_ERR_GPRSSerOptNsup; + + case CAUSE_NWSM_SERVICE_NOT_SUBSCRIBED : + return CME_ERR_GPRSSerOptNsub; + + case CAUSE_NWSM_SERVICE_TEMP_OUT_OF_ORDER : + return CME_ERR_GPRSSerOptOOO; + + default: + return CME_ERR_GPRSUnspec; + } +} + + +/* ++----------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finnished ROUTINE : cmhSM_clear_work_cids | ++----------------------------------------------------------------------+ + + PURPOSE : The below function will decide whether to clear work_cids + and cid_pointer variables. +*/ + +GLOBAL void cmhSM_clear_work_cids(U8 cid) +{ + U8 index = 0; + + TRACE_FUNCTION("cmhSM_clear_work_cids()"); + + while( index < PDP_CONTEXT_CID_MAX ) + { + if(cid NEQ work_cids[index]) + { + index++; + } + else if( pdp_context_get_state_for_cid(cid) EQ PDP_CONTEXT_STATE_DEFINED ) + { + /* + If the state of the cid is other than PDP_CONTEXT_STATE_DEFINED then + don't clear the work_cids[]. + */ + TRACE_EVENT_P2("cmhSM_clear_work_cids(): Clear the work_cid value for the cid and for the location work_cids[index]= %d, %d", cid, index); + work_cids[index++] = PDP_CONTEXT_CID_INVALID; + } + else + { + index++; + } + } + + /* + Check whether the work_cids[] contains any valid cids which are in the + state, other than PDP_CONTEXT_CID_INVALID. + */ + while ( ( index < PDP_CONTEXT_CID_MAX ) AND ( work_cids[index] EQ PDP_CONTEXT_CID_INVALID ) ) + { + index++; + } + + /* + After scnaing whole work_cids[] if we didn't find any valid cids in the + work_cids[] list, then clear the work_cids[]. + */ + if (index >= PDP_CONTEXT_CID_MAX) + { + TRACE_EVENT("cmhSM_clear_work_cids(): Clear the whole work_cid[] list and cid_pointer"); + *work_cids = PDP_CONTEXT_CID_INVALID; + cid_pointer = 0; + smEntStat.curCmd = AT_CMD_NONE; + } +} + +#endif /* GPRS */ +/*==== EOF ========================================================*/