FreeCalypso > hg > fc-magnetite
diff src/aci2/aci/cmh_satf.c @ 3:93999a60b835
src/aci2, src/condat2: import of g23m/condat source pieces from TCS211
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Mon, 26 Sep 2016 00:29:36 +0000 |
| parents | |
| children |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/src/aci2/aci/cmh_satf.c Mon Sep 26 00:29:36 2016 +0000 @@ -0,0 +1,6691 @@ +/* ++----------------------------------------------------------------------------- +| Project : GSM-PS (6147) +| Modul : CMH_SATF ++----------------------------------------------------------------------------- +| 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 global functions of the command +| handler. ++----------------------------------------------------------------------------- +*/ + +#ifdef SIM_TOOLKIT + +#ifndef CMH_SATF_C +#define CMH_SATF_C +#endif + +#define _PACK_DEF_ALPHA /* apply packing for GSM Default Alphabet */ + +#include "aci_all.h" +/*==== INCLUDES ===================================================*/ +#ifdef DTI +#include "dti.h" +#endif /* DTI */ + +#include "pcm.h" + +#include "aci.h" +#include "aci_cmh.h" +#include "ati_cmd.h" +#include "aci_mem.h" + +#include "ati_src_sat.h" + +#ifdef FAX_AND_DATA +#include "aci_fd.h" +#endif /* FAX_AND_DATA */ + +#include "phb.h" +#include "ksd.h" +#include "aoc.h" + +#include "psa.h" +#include "psa_cc.h" +#include "psa_sat.h" +#include "psa_sim.h" +#include "psa_sms.h" +#include "psa_ss.h" +#include "psa_util.h" +#include "psa_mm.h" + +#include "cmh.h" +#include "cmh_ss.h" +#include "cmh_cc.h" +#include "cmh_phb.h" + +#ifdef DTI +#include "dti_conn_mng.h" +#include "dti_cntrl_mng.h" +#endif /* DTI */ + +#include "cmh_sim.h" +#include "cmh_sat.h" +#include "cmh_sms.h" + +/* #include "cmh_sat.h" */ + +#if defined (GPRS) AND defined (DTI) +#include "gaci.h" +#include "gaci_cmh.h" +#include "gaci_srcc.h" +#include "psa_gmm.h" +#include "psa_sm.h" +#include "cmh_sm.h" +#endif + + +#if defined (FAX_AND_DATA) AND defined (DTI) +#include "psa_ra.h" +#include "cmh_ra.h" +#include "psa_l2r.h" +#include "cmh_l2r.h" +#endif /* FAX_AND_DATA */ + +#ifdef CO_UDP_IP +#include "wap_aci.h" +#include "psa_tcpip.h" +#endif /* CO_UDP_IP */ +#include "rtcdrv.h" + +/*==== CONSTANTS ==================================================*/ +#define MAX_CBM_REMEMBERED 9 + +/*==== TYPES ======================================================*/ +typedef struct +{ + U16 msgIdent; + U16 msgCode; + U8 updtNum; + U8 pageNum; +} T_SAT_CBM_SEND; + + +/*==== EXPORT =====================================================*/ +LOCAL void cmhSAT_CBMInitList(); + +/*==== VARIABLES ==================================================*/ +T_SAT_CBM_SEND *CBMsend = NULL; + +EXTERN T_ACI_CUSCFG_PARAMS cuscfgParams; + + +/*==== FUNCTIONS ==================================================*/ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_GetCmdPrfLocation | ++-------------------------------------------------------------------+ + + PURPOSE : This function will return TRUE if the Command has been found and + FALSE if the Command or the Qualifier is unknown. + The byte location and Mask for the given Stk Cmd are returned in the passed paramters, + a return value of TRUE with Byte Number of 0xFF and Mask of 0xFF indicates an + END_OF_SESSION, which isn't in the Profile +*/ + +LOCAL BOOL cmhSAT_GetCmdPrfLocation (U8 cmd_typ, U8 cmd_qual, U8 *prf_byte_no, U8 *byte_mask) +{ + /* + ** Initialise the byte and Mask settings to 0xFF + */ + *prf_byte_no = 0xFF; + *byte_mask = 0xFF; + + switch (cmd_typ) + { + case SAT_CMD_REFRESH: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_REFRESH; + break; + + case SAT_CMD_MORE_TIME: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_MORE_TIME; + break; + + case SAT_CMD_POLL_INTERVAL: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_POLL_ITV; + break; + + case SAT_CMD_POLL_OFF: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_POLL_OFF; + break; + + case SAT_CMD_EVENT_LIST: + *prf_byte_no = 4; + *byte_mask = SAT_TP5_EVENT_LIST; + break; + + case SAT_CMD_SETUP_CALL: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_SETUP_CALL; + break; + + case SAT_CMD_SEND_SS: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_SEND_SS; + break; + + case SAT_CMD_SEND_USSD: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_SEND_USSD; + break; + + case SAT_CMD_SEND_SMS: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_SEND_SMS; + break; + + case SAT_CMD_SEND_DTMF: + *prf_byte_no = 8; + *byte_mask = SAT_TP9_DTMF_CMD; + break; + + case SAT_CMD_LAUNCH_BROWSER: + *prf_byte_no = 8; + *byte_mask = SAT_TP9_LAUNCH_BROWSER; + break; + + case SAT_CMD_PLAY_TONE: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_PLAY_TONE; + break; + + case SAT_CMD_DISPLAY_TEXT: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_DSPL_TXT; + break; + + case SAT_CMD_GET_INKEY: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_GET_INKEY; + break; + + case SAT_CMD_GET_INPUT: + *prf_byte_no = 2; + *byte_mask = SAT_TP3_GET_INPUT; + break; + + case SAT_CMD_SEL_ITEM: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_SEL_ITEM; + break; + + case SAT_CMD_SETUP_MENU: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_SETUP_MENU; + break; + + case SAT_CMD_PROV_LOC_INFO: + /* + ** Depends on which type of Local Info is requested + */ + switch (cmd_qual) + { + case 0: + case 1: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_PLI_PLMN_IMEI; + break; + + case 2: + *prf_byte_no = 3; + *byte_mask = SAT_TP4_PLI_NMR; + break; + + case 3: + *prf_byte_no = 7; + *byte_mask = SAT_TP8_PLI_DTT; + break; + + case 4: + *prf_byte_no = 8; + *byte_mask = SAT_TP9_PLI_LANG; + break; + + case 5: + *prf_byte_no = 8; + *byte_mask = SAT_TP9_PLI_TIMING_ADV; + break; + + default: + return (FALSE); /* Command Not recognised */ + } + break; + + case SAT_CMD_TIMER_MNG: + *prf_byte_no = 7; + *byte_mask = SAT_TP8_TMNG_ST | SAT_TP8_TMNG_VAL; + break; + + case SAT_CMD_IDLE_TEXT: + *prf_byte_no = 7; + *byte_mask = SAT_TP8_IDLE_TXT; + break; + + case SAT_CMD_RUN_AT: + *prf_byte_no = 7; + *byte_mask = SAT_TP8_AT_CMD; + break; + + case SAT_CMD_OPEN_CHANNEL: + *prf_byte_no = 11; + *byte_mask = SAT_TP12_OPEN_CHANNEL; + break; + + case SAT_CMD_CLOSE_CHANNEL: + *prf_byte_no = 11; + *byte_mask = SAT_TP12_CLOSE_CHANNEL; + break; + + case SAT_CMD_RECEIVE_DATA: + *prf_byte_no = 11; + *byte_mask = SAT_TP12_RECEIVE_DATA; + break; + + case SAT_CMD_SEND_DATA: + *prf_byte_no = 11; + *byte_mask = SAT_TP12_SEND_DATA; + break; + + case SAT_CMD_GET_CHANNEL_STATUS: + *prf_byte_no = 11; + *byte_mask = SAT_TP12_GET_CHANNEL_STAT; + break; + + case SAT_CMD_END_SESSION: + /* + ** Do nothing - The command should be handled by the MMI, + ** but there is no entry in the terminal profile + */ + break; + + default: + return (FALSE); /* Command Not recognised */ + } + + return (TRUE); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_IsStkCmdForMmi | ++-------------------------------------------------------------------+ + + PURPOSE : This function will check whether the command should be set to the MMI + and if so will trigger a SATI indication + +*/ + +GLOBAL BOOL cmhSAT_IsStkCmdForMmi (U8 cmd_typ, U8 cmd_qual) +{ + BOOL is_handled = FALSE; + U8 prf_byte_no; + U8 byte_mask; + int idx; + + /* + ** End of Session is handled by the + */ + if (cmd_typ EQ SAT_CMD_END_SESSION) + { + is_handled = TRUE; + } + else + { + /* + ** Convert the command type into a Stk Profile Byte Number and Offset + */ + if (cmhSAT_GetCmdPrfLocation(cmd_typ, cmd_qual, &prf_byte_no, &byte_mask)) + { + /* + ** For each Attached Service + */ + for (idx = 0; idx < CMD_SRC_MAX AND (is_handled EQ FALSE); idx++) + { + /* + ** if the Command is handled + */ + if (simShrdPrm.setPrm[idx].STKprof[prf_byte_no] & byte_mask) + { + /* + ** Set a handled flag to TRUE + */ + is_handled = TRUE; + } + } + } + } + + /* + ** if the Command is handled + */ + if (is_handled) + { + /* + ** Send the SATI indication + */ + cmhSAT_STKCmdInd(); + } + + /* + ** return the value of the handled flag + */ + return (is_handled); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CalCntrlBySIM | ++-------------------------------------------------------------------+ + + PURPOSE : If call control by SIM is activated and allocated, the + parameters for the call found in the call table are + packed into a SIM envelope command and send to the SIM + for checking. + +*/ + +GLOBAL T_ACI_RETURN cmhSAT_CalCntrlBySIM ( SHORT cId ) +{ + T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId]; + + TRACE_FUNCTION("cmhSAT_CalCntrlBySIM()"); + +/* + *------------------------------------------------------------------- + * check if Call Control is disabled (Cust1 Customisation) + *------------------------------------------------------------------- + */ + if(simShrdPrm.setPrm[ctb->calOwn].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_INACTIVE) + { + simShrdPrm.setPrm[ctb->calOwn].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; + return( AT_CMPL ); + } + +/* + *------------------------------------------------------------------- + * check if service is activated and allocated + *------------------------------------------------------------------- + */ + if( ! psaSIM_ChkSIMSrvSup( SRV_CalCntrl )) return( AT_CMPL ); + +/* + *------------------------------------------------------------------- + * check if Call Control customization is enabled... if yes return AT_CMPL + *------------------------------------------------------------------- + */ + + if(cuscfgParams.MO_Call_Control_SIM EQ CUSCFG_STAT_Enabled) + { + return( AT_CMPL ); + } + +/* + *------------------------------------------------------------------- + * check if a call control request is in progress + *------------------------------------------------------------------- + */ + if( satShrdPrm.SIMCCParm.busy EQ TRUE ) return( AT_BUSY ); + +/* + *------------------------------------------------------------------- + * get bearer capability parameter for data calls + *------------------------------------------------------------------- + */ + /* capability configuration parameters */ + if( ctb->BC[0].bearer_serv NEQ BEARER_SERV_NOT_PRES AND + ctb->BC[0].bearer_serv NEQ BEARER_SERV_SPEECH AND + ctb->BC[0].bearer_serv NEQ BEARER_SERV_AUX_SPEECH ) + { + /* CCP not supported yet */ + /* satShrdPrm.capParm.cId = cId; */ + /* psaCC_BCapCode( BCRI_SAT, cId, 0 ); */ + } + + if( ctb->BC[1].bearer_serv NEQ BEARER_SERV_NOT_PRES AND + ctb->BC[1].bearer_serv NEQ BEARER_SERV_SPEECH AND + ctb->BC[1].bearer_serv NEQ BEARER_SERV_AUX_SPEECH ) + { + /* CCP not supported yet */ + /* satShrdPrm.capParm.cId = cId; */ + /* psaCC_BCapCode( BCRI_SAT, cId, 1 ); */ + } + +/* + *------------------------------------------------------------------- + * build envelope call control command + *------------------------------------------------------------------- + */ + CCD_START; + psaSAT_BuildEnvCC ( cId, NULL, NULL, NULL ); + + satShrdPrm.SIMCCParm.cId = cId; + satShrdPrm.SIMCCParm.ccAct = CC_ACT_CAL; + satShrdPrm.SIMCCParm.owner = ctb->calOwn; + satShrdPrm.SIMCCParm.busy = TRUE; + + satShrdPrm.owner = /*ctb->calOwn;*/ NO_VLD_OWN; + + if( psaSAT_STKEnvelope (NULL) < 0 ) /* envelope STK command */ + { + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + CCD_END; + return( AT_FAIL ); + } + + CCD_END; + return (AT_EXCT); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_SSCntrlBySIM | ++-------------------------------------------------------------------+ + + PURPOSE : If call control by SIM is activated and allocated, the + the passed supplementary service control string is + packed into a SIM envelope command and send to the SIM + for checking. + +*/ + +GLOBAL T_ACI_RETURN cmhSAT_SSCntrlBySIM ( T_CLPTY_PRM *cldPty, UBYTE own ) +{ + TRACE_FUNCTION("cmhSAT_SSCntrlBySIM()"); + +/* + *------------------------------------------------------------------- + * check if Call Control is disabled (Cust1 Customisation) + *------------------------------------------------------------------- + */ + if(simShrdPrm.setPrm[own].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_INACTIVE) + { + simShrdPrm.setPrm[own].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; + return( AT_CMPL ); + } + +/* + *------------------------------------------------------------------- + * check if service is activated and allocated + *------------------------------------------------------------------- + */ + if( ! psaSIM_ChkSIMSrvSup( SRV_CalCntrl )) return( AT_CMPL ); + +/* + *------------------------------------------------------------------- + * check if Call Control customization is enabled... if yes return AT_CMPL + *------------------------------------------------------------------- + */ + + if(cuscfgParams.MO_SS_Control_SIM EQ CUSCFG_STAT_Enabled) + { + return( AT_CMPL ); + } + +/* + *------------------------------------------------------------------- + * check if a call control request is in progress + *------------------------------------------------------------------- + */ + if( satShrdPrm.SIMCCParm.busy EQ TRUE ) return( AT_BUSY ); + +/* + *------------------------------------------------------------------- + * build envelope call control command + *------------------------------------------------------------------- + */ + CCD_START; + psaSAT_BuildEnvCC ( NO_ENTRY, cldPty, NULL, NULL ); + + if( cldPty NEQ NULL ) + satShrdPrm.SIMCCParm.ccAct = CC_ACT_SS; + + satShrdPrm.SIMCCParm.owner = own; + satShrdPrm.SIMCCParm.busy = TRUE; + + satShrdPrm.owner = NO_VLD_OWN; + + if( psaSAT_STKEnvelope (NULL) < 0 ) /* envelope STK command */ + { + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + CCD_END; + return( AT_FAIL ); + } + + CCD_END; + +/* + *------------------------------------------------------------------- + * save SS string + *------------------------------------------------------------------- + */ + + if( cldPty NEQ NULL ) + memcpy(&satPndSetup.clpty, cldPty, sizeof(T_CLPTY_PRM)); + + return (AT_EXCT); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_USSDCntrlBySIM | ++-------------------------------------------------------------------+ + + PURPOSE : If call control by SIM is activated and allocated, the + the passed supplementary service control string is + packed into a SIM envelope command and send to the SIM + for checking. + +*/ + +GLOBAL T_ACI_RETURN cmhSAT_USSDCntrlBySIM ( T_sat_ussd *ussd, UBYTE own ) +{ + TRACE_FUNCTION("cmhSAT_USSDCntrlBySIM()"); + +/* + *------------------------------------------------------------------- + * check if Call Control is disabled (Cust1 Customisation) + *------------------------------------------------------------------- + */ + if(simShrdPrm.setPrm[own].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_INACTIVE) + { + simShrdPrm.setPrm[own].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; + return( AT_CMPL ); + } + +/* + *------------------------------------------------------------------- + * check if service is activated and allocated + *------------------------------------------------------------------- + */ + if( ! psaSIM_ChkSIMSrvSup( SRV_CalCntrl )) return( AT_CMPL ); + +/* + *------------------------------------------------------------------- + * check if Call Control customization is enabled... if yes return AT_CMPL + *------------------------------------------------------------------- + */ + + if(cuscfgParams.MO_USSD_Control_SIM EQ CUSCFG_STAT_Enabled) + { + return( AT_CMPL ); + } + +/* + *------------------------------------------------------------------- + * check if a call control request is in progress + *------------------------------------------------------------------- + */ + if( satShrdPrm.SIMCCParm.busy EQ TRUE ) return( AT_BUSY ); + +/* + *------------------------------------------------------------------- + * save SS string + *------------------------------------------------------------------- + */ + if( ussd ) + { + satPndSetup.ussd_str.dcs = ussd->dcs; + satPndSetup.ussd_str.c_ussd_str = ussd->c_ussd_str; + memcpy( satPndSetup.ussd_str.ussd_str, ussd->ussd_str, satPndSetup.ussd_str.c_ussd_str); + /* we have to move the ussd_str pointer since it still points to _decodedMsg + and would be overwritten by the first memset in psaSAT_BuildEnvCC */ + ussd->ussd_str = satPndSetup.ussd_str.ussd_str; + } + +/* + *------------------------------------------------------------------- + * build envelope call control command + *------------------------------------------------------------------- + */ + CCD_START; + psaSAT_BuildEnvCC ( NO_ENTRY, NULL, ussd, NULL ); + + if( ussd ) + satShrdPrm.SIMCCParm.ccAct = CC_ACT_USSD; + + satShrdPrm.SIMCCParm.owner = own; + satShrdPrm.SIMCCParm.busy = TRUE; + + satShrdPrm.owner = NO_VLD_OWN; + + if( psaSAT_STKEnvelope (NULL) < 0 ) /* envelope STK command */ + { + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + CCD_END; + return( AT_FAIL ); + } + + CCD_END; + + + return (AT_EXCT); + +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CBMInitList | ++-------------------------------------------------------------------+ + + PURPOSE : Allocates and initializes CBM list. +*/ + +LOCAL void cmhSAT_CBMInitList() +{ + TRACE_FUNCTION("cmhSAT_CBMInitList()"); + + if ( CBMsend EQ NULL ) + { + ACI_MALLOC(CBMsend, sizeof(T_SAT_CBM_SEND) * MAX_CBM_REMEMBERED); + } + memset( CBMsend, NOT_PRESENT_8BIT, + sizeof(T_SAT_CBM_SEND) * MAX_CBM_REMEMBERED ); +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CBMDestroyList | ++-------------------------------------------------------------------+ + + PURPOSE : Frees memory of CBM list and sets list pointer to NULL. +*/ + +GLOBAL void cmhSAT_CBMDestroyList() +{ + TRACE_FUNCTION("cmhSAT_CBMDestroyList()"); + + if ( CBMsend NEQ NULL ) + { + ACI_MFREE( CBMsend ); + CBMsend = NULL; + } +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CBMAddToList | ++-------------------------------------------------------------------+ + + PURPOSE : Adds new CBM Identifiers to end of CBM list +*/ + +LOCAL void cmhSAT_CBMAddToList( UBYTE pos, + U16 msgIdent, + U16 msgCode, + UBYTE updtNum, + UBYTE pageNum ) +{ + TRACE_FUNCTION("cmhSAT_CBMAddToList()"); + + if ( pos >= MAX_CBM_REMEMBERED ) + { + /* remove oldest: + move all entries one entry to the beginning of the list */ + memcpy( CBMsend, CBMsend + 1, + (MAX_CBM_REMEMBERED - 1) * sizeof(T_SAT_CBM_SEND)); + pos = MAX_CBM_REMEMBERED - 1; + } + + CBMsend[pos].msgIdent = msgIdent; + CBMsend[pos].msgCode = msgCode; + CBMsend[pos].updtNum = updtNum; + CBMsend[pos].pageNum = pageNum; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CBMUpdateList | ++-------------------------------------------------------------------+ + + PURPOSE : Moves last updated CBM to end of the CBM list +*/ + +LOCAL void cmhSAT_CBMUpdateList( UBYTE pos ) +{ + T_SAT_CBM_SEND curCBM; + + TRACE_FUNCTION("cmhSAT_CBMUpdateList()"); + + /* save data of current CBM */ + memcpy( &curCBM, CBMsend + pos, sizeof(T_SAT_CBM_SEND) ); + + /* move all entries, starting after the current entry, one entry to + the beginning of the list */ + memcpy( CBMsend + pos, CBMsend + pos+1, + ( MAX_CBM_REMEMBERED - (pos+1)) * sizeof(T_SAT_CBM_SEND) ); + + /* copy current CBM at last used position */ + while ( (pos < MAX_CBM_REMEMBERED-1) AND + (CBMsend[pos].msgIdent NEQ NOT_PRESENT_16BIT) ) + { + pos++; + } + memcpy( CBMsend + pos, &curCBM, sizeof(T_SAT_CBM_SEND) ); + +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CBMExtractData | ++-------------------------------------------------------------------+ + + PURPOSE : Extracts MessageCode, Messag Identifier, Update number, + Page number and total numbers of pages from the CBM. +*/ + +LOCAL void cmhSAT_CBMExtractData( UBYTE* cbMsg, + U16* msgIdent, + U16* msgCode, + UBYTE* updtNum, + UBYTE* pageNum, + UBYTE* pageTotal ) +{ + UBYTE cnvrt[2]; + + TRACE_FUNCTION("cmhSAT_CBMExtractData()"); + + /* extract message identifiers: + cbMsg is not yet enveloped for SAT, so that Bytes 3 - 4 includes + the message identifiers. + */ + memcpy(cnvrt+1, &cbMsg[2], 1); + memcpy(cnvrt, &cbMsg[3], 1); + memcpy(msgIdent, cnvrt, 2); + + /* decode serial number: + cbMsg is not yet enveloped for SAT, so that cbMsg starts + with the serial number. + update number: + The serial number includes the message code in bits 0 - 5 of the + first Byte and in bits 4 -7 in the second Byte. + */ + memcpy(cnvrt+1, &cbMsg[0], 1); + memcpy(cnvrt, &cbMsg[1], 1); + memcpy(msgCode, cnvrt, 2); + *msgCode = ( *msgCode >> 4 ) & 1023; + + /* + update number: + The second Byte of the serial number includes the + update number in bits 0 - 3. + the bitwise AND operation with 15 will set bits 4 - 7 to zero. + */ + *updtNum = cbMsg[1] & 15; + + /* extract page parameter: + cbMsg is not yet enveloped for SAT, so that the sixth Byte is + the page parameter. + It includes the total number of pages in bits 0 - 3. + The bitwise AND operation with 15 will set bits 4 - 7 to zero. + The current page number is in bits 4 - 7. + To get the current page number the bits have to be shifted + 4 positions to the right. + */ + *pageTotal = cbMsg[5] & 15; + *pageNum = cbMsg[5] >> 4; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CBMIsNewMsg | ++-------------------------------------------------------------------+ + + PURPOSE : Checks if CBM is a new CBM or if it already has been + send to SIM. The Identifiers of already received CBMs + are stored in a list. + RETURNS: TRUE, if it is new and shall be send to SIM now. + FALSE, if it already has been send to SIM. +*/ + +LOCAL BOOL cmhSAT_CBMIsNewMsg( UBYTE* cbMsg ) +{ + + U16 msgIdent; + U16 msgCode; + U8 updtNum; + U8 pageTotal; + U8 pageNum; + UBYTE i; + + + TRACE_FUNCTION("cmhSAT_CBMIsNewMsg()"); + + if ( CBMsend EQ NULL ) + { + cmhSAT_CBMInitList(); + } + + /*---------------------------------------------------------------- + * extract CBM identifiers + *----------------------------------------------------------------*/ + + cmhSAT_CBMExtractData( cbMsg, &msgIdent, &msgCode, &updtNum, + &pageNum, &pageTotal ); + + /*---------------------------------------------------------------- + * check if message has already been send to SIM + *----------------------------------------------------------------*/ + + /* search for message identifiers in CB Messages already send to SIM */ + for ( i = 0; + (i < MAX_CBM_REMEMBERED) AND (CBMsend[i].msgCode NEQ NOT_PRESENT_16BIT); + i++ ) + { + if ( (msgIdent EQ CBMsend[i].msgIdent) AND + (msgCode EQ CBMsend[i].msgCode) ) + { + + /* if update number has changed, CBM shall be send to SIM */ + /* 23.041 9.4.1.2.1: + Any Update Number eight or less higher (modulo 16) + than the last received Update Number will be considered more recent, + and shall be treated as a new CBS message, + provided the mobile has not been switched off. */ + + U8 delta; + + delta = (updtNum - CBMsend[i].updtNum) % 16; /* force explicit negative carry! */ + if (delta > 0 AND delta <= 8) + { + /* for the next check: set update number to new update number + and reset page number for new update */ + CBMsend[i].updtNum = updtNum; + CBMsend[i].pageNum = 0; + cmhSAT_CBMUpdateList( i ); + + return TRUE; + } + + + /* check if message contains more than one page */ + if ( pageTotal > 1 ) + { + /* check if page is send to SIM */ + if ( pageNum > CBMsend[i].pageNum ) + { + /* mark page now as send for next CBM */ + CBMsend[i].pageNum = pageNum; + cmhSAT_CBMUpdateList( i ); + + /* page is not yet send to SIM */ + return TRUE; + } + } + + /* CBM is not new */ + return FALSE; + } + } + + /*---------------------------------------------------------------- + * mark CBM as send to SIM: insert into list + *---------------------------------------------------------------*/ + + cmhSAT_CBMAddToList( i, msgIdent, msgCode, updtNum, pageNum ); + + return TRUE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_verifyNewLocInfo | ++-------------------------------------------------------------------+ + + PURPOSE : This function verifies the current MM PLMN information + with the one already stored by SAT and indicates TRUE if + the information has changed + +*/ +LOCAL BOOL cmhSAT_verifyNewLocInfo () +{ + if (satShrdPrm.locInfo.regStatus EQ mmShrdPrm.regStat) + { + /* If registration status is full service, check to proceed + if the location information has changed*/ + if (satShrdPrm.locInfo.regStatus EQ RS_FULL_SRV) + { + if( memcmp (mmShrdPrm.usedPLMN.mcc, satShrdPrm.locInfo.currPLMN.mcc, SIZE_MCC) EQ 0 + AND memcmp (mmShrdPrm.usedPLMN.mnc, satShrdPrm.locInfo.currPLMN.mnc, SIZE_MNC) EQ 0 + AND mmShrdPrm.lac EQ satShrdPrm.locInfo.lac AND mmShrdPrm.cid EQ satShrdPrm.locInfo.cid) + { + return FALSE; + } + } + } + + satShrdPrm.locInfo.regStatus = mmShrdPrm.regStat; + + /* The other information is updated only if ME is in full service mode */ + if (satShrdPrm.locInfo.regStatus EQ RS_FULL_SRV) + { + satShrdPrm.locInfo.cid = mmShrdPrm.cid; + satShrdPrm.locInfo.lac = mmShrdPrm.lac; + satShrdPrm.locInfo.currPLMN.v_plmn = mmShrdPrm.usedPLMN.v_plmn; + memcpy(satShrdPrm.locInfo.currPLMN.mcc, mmShrdPrm.usedPLMN.mcc, SIZE_MCC); + memcpy(satShrdPrm.locInfo.currPLMN.mnc, mmShrdPrm.usedPLMN.mnc, SIZE_MNC); + } + + return TRUE; +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_DatDwnLdCB | ++-------------------------------------------------------------------+ + + PURPOSE : This function supports the data download to SIM via cell + broadcast messages. + +*/ + +GLOBAL T_ACI_RETURN cmhSAT_DatDwnLdCB ( UBYTE* cbMsg, SHORT cbLen ) +{ + + TRACE_FUNCTION("cmhSAT_DatDwnLdCB()"); + +/* + *------------------------------------------------------------------- + * build envelope + *------------------------------------------------------------------- + */ + CCD_START; + psaSAT_BuildEnvCB ( cbMsg, cbLen ); + + satShrdPrm.owner = NO_VLD_OWN; + + /* only if CBM is not yet send to SIM, CBM shall be send to SIM */ + if ( cmhSAT_CBMIsNewMsg( cbMsg ) ) + { + if( psaSAT_STKEnvelope (NULL) < 0 ) /* envelope STK command */ + { + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + CCD_END; + return( AT_FAIL ); + } + } + + CCD_END; + + return( AT_CMPL ); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_MoSmCntr | ++-------------------------------------------------------------------+ + + PURPOSE : This function supports the MO SM control. + +*/ + +GLOBAL T_ACI_RETURN cmhSAT_MoSmCntr ( T_rp_addr sc_addr, + T_tp_da dest_addr, + UBYTE own) +{ + + TRACE_FUNCTION("cmhSAT_MoSmCntr()"); + +/* + *------------------------------------------------------------------- + * check if Call Control customization is enabled... if yes return AT_CMPL + *------------------------------------------------------------------- + */ + + if(cuscfgParams.MO_SM_Control_SIM EQ CUSCFG_STAT_Enabled) + { + return( AT_CMPL ); + } + + +/* + *------------------------------------------------------------------- + * check if a call control request is in progress + *------------------------------------------------------------------- + */ + if( satShrdPrm.SIMCCParm.busy EQ TRUE ) return( AT_BUSY ); + + +/* + *------------------------------------------------------------------- + * build envelope + *------------------------------------------------------------------- + */ + CCD_START; + psaSAT_BuildEnvMoSmCntr ( sc_addr, dest_addr ); + + satShrdPrm.SIMCCParm.ccAct = SMC_ACT_MO; + satShrdPrm.SIMCCParm.owner = own; + satShrdPrm.SIMCCParm.busy = TRUE; + + satShrdPrm.owner = NO_VLD_OWN; + + if( psaSAT_STKEnvelope (NULL) < 0 ) /* envelope STK command */ + { + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + CCD_END; + return( AT_FAIL ); + } + + CCD_END; + return( AT_EXCT ); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_EventDwn | ++-------------------------------------------------------------------+ + + PURPOSE : This function supports Event download. + +*/ + +GLOBAL T_ACI_RETURN cmhSAT_EventDwn ( UBYTE event, SHORT callId , T_CC_INITIATER actionSrc ) +{ + + TRACE_FUNCTION("cmhSAT_EventDwn()"); + + /* If the event is Location info download, event download is sent only + if the location information has changed or has been updated */ + if (event EQ EVENT_LOC_STATUS AND !cmhSAT_verifyNewLocInfo ()) + { + TRACE_EVENT("No update for SIM app"); + return AT_CMPL; + } + + +/* + *------------------------------------------------------------------- + * build envelope + *------------------------------------------------------------------- + */ + CCD_START; + + /* if events were queued, send them */ + if (satShrdPrm.event.c_queued) + { + do + { + T_SAT_QUEUE *p_queue; + + satShrdPrm.event.c_queued--; + p_queue = &satShrdPrm.event.queued[satShrdPrm.event.c_queued]; + + satShrdPrm.owner = p_queue->owner; + if (psaSAT_STKEnvelope(p_queue->stk_cmd) < 0) /* envelope STK command */ + { + /* ignore event if error */ + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + } + p_queue->stk_cmd = NULL; + } + while (satShrdPrm.event.c_queued); + } + else + { + if (!psaSAT_BuildEnvEventDwn ( event , callId, actionSrc )) + { + CCD_END; + return AT_BUSY; + } + + /*satShrdPrm.SIMCCParm.busy = TRUE;*/ + + satShrdPrm.owner = NO_VLD_OWN; + + if( psaSAT_STKEnvelope (NULL) < 0 ) /* envelope STK command */ + { + TRACE_EVENT( "FATAL RETURN SAT in send env" ); + CCD_END; + return( AT_FAIL ); + } + } + + CCD_END; + return( AT_CMPL ); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : MODULE : SAT | +| ROUTINE : cmhSAT_LaunchBrowser | ++-------------------------------------------------------------------+ + + PURPOSE : + +*/ +GLOBAL BOOL cmhSAT_launchBrowser (T_LAUNCH_BROWSER* launchBrowser) +{ + T_ACI_SAT_TERM_RESP resp_data; + + /* check for busy SS condition */ + if (psaSS_stbFindActSrv (NO_ENTRY) NEQ NO_ENTRY) + { + /* respond with "error, ME currently unable to process command" */ + resp_data.add_content = ADD_ME_SS_BUSY; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); /* unused */ + } + +#if defined(MFW) AND defined(FF_WAP) + rAT_PercentSATBROW (launchBrowser); /* Info 718: Symbol undeclared, assumed to return int */ + return( TRUE ); /* unused */ +#else + cmhSAT_STKCmdInd(); + return( FALSE ); /* unused */ +#endif + +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_provLocalInfo | ++-------------------------------------------------------------------+ + + PURPOSE : This function supports Provide Local Information for + Date, time and time zone. + +*/ +GLOBAL BOOL cmhSAT_provLocalInfo () +{ + T_ACI_SAT_TERM_RESP resp_data; + rtc_time_type rtc_time; + + CHAR* ef = EF_CLNG_ID; + pcm_FileInfo_Type fileInfo; + EF_CLNG lng; + + char *auptr="au"; + + TRACE_FUNCTION("cmhSAT_provLocalInfo()"); + + psaSAT_InitTrmResp( &resp_data ); + +#ifndef _SIMULATION_ + /* if no service is currently available */ + if ((mmShrdPrm.regStat EQ RS_NO_SRV) OR (mmShrdPrm.regStat EQ NO_VLD_RS)) + { + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return(FALSE); + } +#endif + + if (satShrdPrm.cmdDet.cmdQlf NEQ QLF_PLOI_DTT AND (satShrdPrm.cmdDet.cmdQlf NEQ QLF_PLOI_LANG_SET)) + { + return (FALSE); + } + + if (satShrdPrm.cmdDet.cmdQlf EQ QLF_PLOI_DTT) + { + if ( rtc_read_time ( &rtc_time ) EQ TRUE ) + { + int i = 0; + UBYTE hex2bcd; + + resp_data.dtt_buf[0] = rtc_time.year; + resp_data.dtt_buf[1] = rtc_time.month; + resp_data.dtt_buf[2] = rtc_time.day; + resp_data.dtt_buf[3] = rtc_time.hour; + resp_data.dtt_buf[4] = rtc_time.minute; + resp_data.dtt_buf[5] = rtc_time.second; + while(i<TIME_STAMP_LENGTH) + { + hex2bcd = 0; + hex2bcd = hex2bcd + resp_data.dtt_buf[i] / 0x0A; + hex2bcd = hex2bcd << 4; + hex2bcd = hex2bcd + resp_data.dtt_buf[i] % 0x0A; + resp_data.dtt_buf[i] = ((hex2bcd & 0x0F) << 4) + ((hex2bcd & 0xF0) >> 4); + i++; + } +#ifdef _SIMULATION_ + memset(resp_data.dtt_buf, 0xA0, 6); +#endif /* _SIMULATION_ */ + + resp_data.dtt_buf[6] = mmShrdPrm.tz; + + if (mmShrdPrm.regStat EQ RS_LMTD_SRV) + { + psaSAT_SendTrmResp( RSLT_PERF_LIM_SRV, &resp_data ); + } + else + { + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + } + } + else + { + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return (FALSE); + } + } + else /* Expecting LS Qualifier */ + { + if (pcm_GetFileInfo ( ( UBYTE* ) ef, &fileInfo) NEQ PCM_OK) + { + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return (FALSE); + } + else + { + if (pcm_ReadFile( (UBYTE*)ef, + fileInfo.FileSize, + (UBYTE*) &lng, + &fileInfo.Version) EQ PCM_OK ) + { + + /*------------------------------------------------------------------- + * Read EF ELP or LP from the sim if Automatic language is selected + *------------------------------------------------------------------- + */ + + if (!memcmp(lng.data, auptr, CLAN_CODE_LEN)) + { + if (cmhSIM_ReqLanguagePrf() EQ FALSE) + { + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return (FALSE); + } + } + else + { + memcpy(&resp_data.lang, &lng.data[0], CLAN_CODE_LEN); + +#ifdef _SIMULATION_ + memset(resp_data.lang, 0xA0, 2); +#endif + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + } + + } + else + { + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return (FALSE); + } + } + } + return(TRUE); +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_setupCall | ++-------------------------------------------------------------------+ + + PURPOSE : + +*/ + +GLOBAL BOOL cmhSAT_setupCall ( T_SETUP_CALL * cal ) +{ + T_CC_CALL_TBL *ctb; /* pointer to call table associated with cId */ + T_ACI_RETURN retVal; /* holds return value */ + SHORT cId; /* holds call id */ + UBYTE idx; /* holds index */ + T_ACI_SAT_TERM_RESP resp_data; +#ifdef FF_SAT_E + T_ACI_SATA_ADD addPrm; +#endif /* FF_SAT_E */ + + psaSAT_InitTrmResp( &resp_data ); + + TRACE_FUNCTION("cmhSAT_setupCall()"); + +/* + *------------------------------------------------------------------- + * get call table entry + *------------------------------------------------------------------- + */ + cId = psaCC_ctbNewEntry(); + + if( cId EQ NO_ENTRY ) + { + /* send SAT response */ + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); /* primitive not needed anymore */ + } + + ctb = ccShrdPrm.ctb[cId]; + +/* + *------------------------------------------------------------------- + * build setup parameters + *------------------------------------------------------------------- + */ + /* check dial number */ + if( !cal->v_addr ) + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + cmhSAT_fillSetupPrm ( cId, /* cId is valid */ + ((cal->v_addr)?&cal->addr:NULL), + ((cal->v_subaddr)?&cal->subaddr:NULL)); + + /* check aoc condition */ + if ((ctb->prio EQ PRIO_NORM_CALL) AND + (aoc_check_moc() EQ FALSE)) + /* + * check ACM exceeds ACMmax + * for non-emergency calls + */ + { + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + /* declare the owner and status of the call */ + ctb->calOwn = OWN_SAT; + ctb->calStat = CS_SAT_REQ; + ctb->curCmd = AT_CMD_D; + ctb->SATinv = TRUE; + + /* bearer capabilities */ + if ( cal->v_cap_cnf_parms EQ 0 ) + { + /* + * no bearer capabilities => set to speech + * this function was called for a SIM_TOOLKIT_IND + */ + cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES ); + } + else + { + /* future to consider the bearer capabilities */ + cmhSAT_fillSetupBC ( cId, BEARER_SERV_SPEECH, BEARER_SERV_NOT_PRES ); + + /* CCP not supported yet */ +/* + cmhSAT_ChckRedial(cId, cal->v_dur, &cal->dur); + + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + satShrdPrm.capParm.cId = cId; + satShrdPrm.capParm.cntxt = CTX_SAT_SETUP; + + if( psaCC_BCapDecode( BCRI_SAT, cal->cap_cnf_parms.l_cap_cnf_parms>>3, + cal->cap_cnf_parms.b_cap_cnf_parms ) < 0 ) + { + psaSAT_SendTrmResp( RSLT_ME_CAP, 0, NULL, NULL, NULL ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + else + { + return( TRUE ); + } +*/ + } + +/* + *------------------------------------------------------------------- + * check for emergency call + *------------------------------------------------------------------- + */ + if( ctb->prio EQ PRIO_EMERG_CALL ) + { + if (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) + { + /* + * Clear the call table entry as it will be re-created when the MMI + * requests the emergency call setup + */ + psaCC_FreeCtbNtry (cId); + + /* + ** Send the original Setup Call Request to the MMI in a %SATI indication + */ + cmhSAT_Cust1StkCmdInd(); + } + else + { + /* alert user */ + for( idx = 0; idx < CMD_SRC_MAX; idx++ ) + { + +#ifdef FF_SAT_E + addPrm.chnType = SATA_CT_VOICE; + addPrm.chnEst = SATA_EST_IM; + + R_AT( RAT_SATA, idx )( cId+1, + cmhSAT_ChckRedial(cId, cal->v_dur, &cal->dur), + &addPrm); +#else /* FF_SAT_E */ + R_AT( RAT_SATA, idx )( cId+1, + cmhSAT_ChckRedial(cId, cal->v_dur, &cal->dur)); +#endif /* FF_SAT_E */ + } + } + + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + return( TRUE ); + } + +/* + *------------------------------------------------------------------- + * check for call control by SIM + *------------------------------------------------------------------- + */ + + retVal = cmhSAT_CalCntrlBySIM( cId ); + + + switch( retVal ) + { + case( AT_EXCT ): + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + return( TRUE ); + + case( AT_BUSY ): + /* respond with "Interaction with call control by SIM, temporary" */ + psaSAT_SendTrmResp( RSLT_CC_SIM_TMP, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + + case( AT_FAIL ): + /* respond with "Interaction with call control by SIM, permanent" */ + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + + case( AT_CMPL): + TRACE_EVENT_P1("Restoring the Cid = %d",cId); + satShrdPrm.SIMCCParm.cId = cId; + break; + } + +/* + *------------------------------------------------------------------- + * alert user if command details are supported + *------------------------------------------------------------------- + */ + if (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) + { + /* + * Clear the call table entry as it will be re-created when the MMI + * requests the emergency call setup + */ + psaCC_FreeCtbNtry (cId); + + /* + ** Send the original Setup Call Request to the MMI in a %SATI indication + */ + cmhSAT_Cust1StkCmdInd(); + + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + return( TRUE ); + } + else if( cmhSAT_ChckCmdDet() ) + { + for( idx = 0; idx < CMD_SRC_MAX; idx++ ) + { + + /* + ** If cust_mode is not NORMAL_BEHAVIOUR, then don't do anything yet, because the + ** %SATI indication will be sent later in the process + */ + if (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_NORMAL_BEHAVIOUR) + { +#ifdef FF_SAT_E + addPrm.chnType = SATA_CT_VOICE; + addPrm.chnEst = SATA_EST_IM; + + R_AT( RAT_SATA, idx )( cId+1, + cmhSAT_ChckRedial(cId, cal->v_dur, &cal->dur), + &addPrm); +#else /* FF_SAT_E */ + R_AT( RAT_SATA, idx )( cId+1, + cmhSAT_ChckRedial(cId, cal->v_dur, &cal->dur)); +#endif /* FF_SAT_E */ + + } + } + + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + return( TRUE ); + } + + psaCC_FreeCtbNtry (cId); + return( FALSE ); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_sendSS | ++-------------------------------------------------------------------+ + + PURPOSE : This function starts a SS transaction initiated by SAT. + If the request is going to be processed, the function + returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_sendSS ( T_SEND_SS * ss ) +{ + T_ACI_RETURN retVal; /* holds return value */ + T_ACI_D_CLIR_OVRD dummy2; /* dummy value */ + T_ACI_D_TOC dummy1; /* dummy value */ + T_ACI_SAT_TERM_RESP resp_data; + + psaSAT_InitTrmResp( &resp_data ); + + TRACE_FUNCTION("cmhSAT_sendSS()"); + +/* + *------------------------------------------------------------------- + * build SS string + *------------------------------------------------------------------- + */ + if( !ss->v_ss_string ) + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_UNKN_DATA, &resp_data ); + return( FALSE ); + } + + if ( !ss->ss_string.c_ss_ctrl_string ) + { + psaSAT_SendTrmResp(RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + + cmhCC_init_cldPty( &satPndSetup.clpty ); + + utl_BCD2DialStr( ss->ss_string.ss_ctrl_string, satPndSetup.clpty.num, + (UBYTE)MINIMUM(ss->ss_string.c_ss_ctrl_string, + MAX_DIAL_LEN-1)); + + satPndSetup.clpty.ton = ss->ss_string.noa; + satPndSetup.clpty.npi = ss->ss_string.npi; + +/* + *------------------------------------------------------------------- + * check for call control by SIM + *------------------------------------------------------------------- + */ + retVal = cmhSAT_SSCntrlBySIM( &satPndSetup.clpty, OWN_SAT ); + + switch( retVal ) + { + case( AT_EXCT ): + satShrdPrm.ntfy = USR_NTF_SEND_SS; + return( TRUE ); + + case( AT_BUSY ): + /* respond with "Interaction with call control by SIM, temporary" */ + psaSAT_SendTrmResp( RSLT_CC_SIM_TMP, &resp_data ); + return( FALSE ); + + case( AT_FAIL ): + /* respond with "Interaction with call control by SIM, permanent" */ + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); + return( FALSE ); + } + +/* + *------------------------------------------------------------------- + * check for busy SS condition + *------------------------------------------------------------------- + */ + if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) + { + /* respond with "error, ME currently unable to process command" */ + resp_data.add_content = ADD_ME_SS_BUSY; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + } + + if (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) + { + /* + ** Send the original SendSS Request to the MMI in a %SATI indication + */ + cmhSAT_Cust1StkCmdInd(); + + satShrdPrm.ntfy = USR_NTF_SEND_SS; + return( TRUE ); + } + +/* + *------------------------------------------------------------------- + * decode and send SS string + *------------------------------------------------------------------- + */ + retVal = cmhCC_chkKeySeq ( OWN_SAT, + &satPndSetup.clpty, + &dummy1, + &dummy2, + CC_SIM_NO ); + if( retVal NEQ AT_EXCT ) + { + /* respond with "error, beyond ME capabilities" */ + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); + } + + satShrdPrm.ntfy = USR_NTF_SEND_SS; + return( TRUE ); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_sendUSSD | ++-------------------------------------------------------------------+ + + PURPOSE : This function starts a USSD transaction initiated by SAT. + If the request is going to be processed, the function + returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_sendUSSD ( T_SEND_USSD * ussd ) +{ + T_ACI_RETURN retVal; /* holds return value */ + SHORT sId; /* holds service id */ + T_ACI_SAT_TERM_RESP resp_data; + T_sat_ussd SATCC_ussd; /* to hold USSD string in case of SAT Control */ + + psaSAT_InitTrmResp( &resp_data ); + + TRACE_FUNCTION("cmhSAT_sendUSSD()"); + +/* + *------------------------------------------------------------------- + * build SS string + *------------------------------------------------------------------- + */ + if( !ussd->v_ussd_string ) + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + +/* + *------------------------------------------------------------------- + * check for call control by SIM + *------------------------------------------------------------------- + */ + if ( psaSIM_ChkSIMSrvSup(SRV_USSDsupportInCC) ) + { + SATCC_ussd.dcs = ussd->ussd_string.dcs; + SATCC_ussd.c_ussd_str = ussd->ussd_string.c_ussd_str; + SATCC_ussd.ussd_str = ussd->ussd_string.ussd_str; + + retVal = cmhSAT_USSDCntrlBySIM( &SATCC_ussd, OWN_SAT ); + + switch( retVal ) + { + case( AT_EXCT ): + satShrdPrm.ntfy = USR_NTF_SEND_USSD; + return( TRUE ); + + case( AT_BUSY ): + /* respond with "Interaction with call control by SIM, temporary" */ + psaSAT_SendTrmResp( RSLT_CC_SIM_TMP, &resp_data ); + return( FALSE ); + + case( AT_FAIL ): + /* respond with "Interaction with call control by SIM, permanent" */ + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); + return( FALSE ); + } + } + + /*********************************************************** + check if a SS or a USSD transaction is already in process + ***********************************************************/ + + sId = psaSS_stbFindActSrv( NO_ENTRY ); + + if( sId NEQ NO_ENTRY ) + { + if (ssShrdPrm.stb[sId].curCmd EQ KSD_CMD_USSD + OR ssShrdPrm.stb[sId].curCmd EQ AT_CMD_CUSD) + resp_data.add_content = ADD_ME_USSD_BUSY; + else + resp_data.add_content = ADD_ME_SS_BUSY; + + resp_data.addLen = 1; + + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + } + + if (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) + { + /* + ** Send the original SendSS Request to the MMI in a %SATI indication + */ + cmhSAT_Cust1StkCmdInd(); + + satShrdPrm.ntfy = USR_NTF_SEND_USSD; + return( TRUE ); + } + + + /* get new service table entry */ + sId = psaSS_stbNewEntry(); + if( sId EQ NO_ENTRY ) + { + resp_data.add_content = ADD_ME_USSD_BUSY; + resp_data.addLen = 1; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + } + + CCD_START; + + /* TLU: save DCS for USSD v1 */ + ssShrdPrm.ussdDcs = ussd->ussd_string.dcs; + + /* set data coding scheme */ + /* patch !!!!! CLB 11/12/01 */ + if( (UBYTE)ussd->ussd_string.dcs EQ 0x40 ) + { + /* 0x40 means basically default alphabet... + yet some asian networks dont seem to accept it (although using it + in their own STK !!!) */ + ussd->ussd_string.dcs = 0x0F; + } + /*********************************/ + + psaSS_asmProcUSSDReq( (UBYTE)ussd->ussd_string.dcs, + ussd->ussd_string.ussd_str, + ussd->ussd_string.c_ussd_str ); + + /* start new transaction */ + ssShrdPrm.stb[sId].ntryUsdFlg = TRUE; + ssShrdPrm.stb[sId].curCmd = AT_CMD_NONE; + ssShrdPrm.stb[sId].srvOwn = OWN_SAT; + + /* save ussd string for possible version 1 retry */ + /* if( cmhSMS_getAlphabetCb( (UBYTE)dcs ) EQ 0 ) NOT SURE ABOUT THAT !!!! clb */ + { + if( ussd->ussd_string.c_ussd_str <= MAX_USSD_STRING ) + { + ssShrdPrm.ussdLen = ussd->ussd_string.c_ussd_str; + memcpy( ssShrdPrm.ussdBuf, + ussd->ussd_string.ussd_str, + ussd->ussd_string.c_ussd_str ); + } + } + + satShrdPrm.SentUSSDid = sId; /* save for response message */ + + psaSS_NewTrns(sId); + + CCD_END; + + return( TRUE ); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_sendDTMF | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a DTMF sequence to the network. + +*/ + +LOCAL BOOL cmhSAT_initDTMF ( T_SEND_DTMF *dtmf ) +{ + SHORT cId; /* holds call id */ + T_ACI_SAT_TERM_RESP resp_data; + CHAR num[MAX_CC_CALLED_NUMBER]; + UBYTE i; + USHORT length; + + + TRACE_FUNCTION("cmhSAT_initDTMF()"); + + psaSAT_InitTrmResp( &resp_data ); + + cId = cmhCC_find_call_for_DTMF( ); + if (cId EQ NO_ENTRY) + { + /* respond with "error, no speech call in process" */ + resp_data.add_content = ADD_ME_NO_SPCH_CALL; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + } + + /* check arguments */ + if( dtmf AND !dtmf->v_dtmf_string ) + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + else + { + length = MINIMUM((dtmf ? dtmf->dtmf_string.c_bcdDigit : 0), MAX_CC_CALLED_NUMBER); + if (dtmf NEQ NULL) + { + for(i=0; i<length; i++) + { + num[i] = cmhPHB_convertBCD2char(dtmf->dtmf_string.bcdDigit[i]); + } + } + else + num[0] = '\0'; + + cmhCC_chkDTMFDig( num, + cId, + length, + FALSE ); + + ccShrdPrm.dtmf.cId = cId; /* Update the global parameter with cId */ + psaCC_ctb(cId)->dtmfCmd = AT_CMD_NONE ; + psaCC_ctb(cId)->dtmfSrc = OWN_SAT; /* wait for confirmation */ + return TRUE; + } +} + + +GLOBAL BOOL cmhSAT_sendDTMF ( T_SEND_DTMF *dtmf ) +{ + SHORT cId; /* holds call id */ + T_ACI_SAT_TERM_RESP resp_data; + BOOL param_ok; + + TRACE_FUNCTION("cmhSAT_sendDTMF()"); + + psaSAT_InitTrmResp( &resp_data ); + + /* if no proceeding yet, check for a voice call */ + if( ccShrdPrm.dtmf.cId NEQ NO_ENTRY ) + { + cId = ccShrdPrm.dtmf.cId; + if (ccShrdPrm.ctb[cId] EQ NULL OR + psaCC_ctb(cId)->dtmfSrc NEQ OWN_SAT ) + { + /* respond with "error, busy on DTMF" */ + /* resp_data.add_content = ADD_ME_DTMF_BUSY; */ + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + } + } + else + { + /* initialize DTMF related parameters */ + if (!cmhSAT_initDTMF( dtmf )) + return (FALSE); + cId = ccShrdPrm.dtmf.cId; + } + + /* send DTMF */ + param_ok = cmhCC_SendDTMFdig ( AT_CMD_NONE, cId, + ccShrdPrm.dtmf.dig[ccShrdPrm.dtmf.cur], + DTMF_MOD_AUTO); + ccShrdPrm.dtmf.cur++; + + if( !param_ok ) + { + /* respond with "value not recognized" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + return( TRUE ); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_runAt | ++-------------------------------------------------------------------+ + + PURPOSE : This function performs run at command for SAT. +*/ + +GLOBAL BOOL cmhSAT_runAt ( T_RUN_AT *run_at) +{ + T_ACI_SAT_TERM_RESP resp_data; + + psaSAT_InitTrmResp( &resp_data ); + + TRACE_FUNCTION("cmhSAT_runAt()"); + + if(!run_at->v_at_string) + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return(FALSE); + } + +#ifdef FF_ATI + if( sat_src_proc_chars (run_at->at_string) EQ FALSE ) + { + return(FALSE); + } +#endif /* FF_ATI */ + + return(TRUE); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_setupEvent_Test | ++-------------------------------------------------------------------+ + + PURPOSE : This function updates the event list to be whatched for SAT. +*/ + +GLOBAL BOOL cmhSAT_setupEvent_Test ( T_SETUP_EVENT *set_event, + BOOL *aci_events_only ) +{ + SHORT i; + BOOL mt_done = FALSE; + BOOL conn_done = FALSE; + BOOL disc_done = FALSE; + BOOL loc_done = FALSE; +#ifdef FF_SAT_E + BOOL dat_avail = FALSE; + BOOL chn_stat = FALSE; +#endif /* FF_SAT_E */ + BOOL list_in_process; + + /* ACI-SPR-18200: temporary event list, not processed by ACI */ + UBYTE tmpEventList[MAX_EVENT_LIST_LEN]; + UBYTE tmpEventListLen = 0; + + TRACE_FUNCTION("cmhSAT_setupEvent_Test()"); + + if (set_event -> v_ev_list EQ TRUE) + { + + + /* erase previous list if received list is empty */ + if (set_event -> ev_list.c_event EQ 0L) + { + satShrdPrm.event.list = 0L; + return TRUE; + } + + /* test events whether they are supported by ACI or not... + Moreover, every event shall take place only once in the list */ + /* supported by ACI: + EVENT_MT_CALL + EVENT_CALL_CONN + EVENT_CALL_DISC + EVENT_LOC_STATUS + EVENT_DATA_AVAIL (SAT E) + EVENT_CHAN_STAT (SAT E) */ + + list_in_process = ( satShrdPrm.event.temp_list & 0x8000 ) > 0; + + if ( list_in_process ) + { + /*means a setup_event_list is already currently in process */ + return FALSE; /* TR(30) is sent by calling function */ + } + + for (i=0;i<set_event -> ev_list.c_event;i++) + { + switch( set_event -> ev_list.event[i] ) + { + case( EVENT_MT_CALL ): + if (! mt_done ) + { + mt_done = TRUE; + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + break; + + case( EVENT_CALL_CONN ): + if (! conn_done ) + { + conn_done = TRUE; + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + break; + + case( EVENT_CALL_DISC ): + if (! disc_done ) + { + disc_done = TRUE; + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + break; + + case( EVENT_LOC_STATUS ): + if (! loc_done ) + { + loc_done = TRUE; + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + break; + +#ifdef FF_SAT_E + case( EVENT_DATA_AVAIL ): + if (! dat_avail ) + { + dat_avail = TRUE; + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + break; + + case( EVENT_CHAN_STAT ): + if (! chn_stat ) + { + chn_stat = TRUE; + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + break; +#endif /* FF_SAT_E */ + + default: + satShrdPrm.event.temp_list |= (0x01 << set_event->ev_list.event[i]); + /* so that the corresponding bit won't actually be set in temp_list */ + /* ACI-SPR-18200: add to local temp event list */ + tmpEventList[tmpEventListLen] = set_event->ev_list.event[i]; + tmpEventListLen++; + break; + } + satShrdPrm.event.temp_list |= (0x01 << set_event->ev_list.event[i]); + } + } + else + { + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + + satShrdPrm.event.temp_list |= 0x8000; /* to flag that a list is in process */ + + /* ACI-SPR-18200: Modify the SAT cmd send to MMI */ + if ( cmhSAT_copyUnprocEvents ( tmpEventList, + tmpEventListLen, + set_event->ev_list.c_event ) ) + { + *aci_events_only = FALSE; + } + else + { + *aci_events_only = TRUE; + } + + return TRUE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_copyUnprocEvents | ++-------------------------------------------------------------------+ + + PURPOSE : Modify the event list that will be send to MMI. + Insert the events that could not be processed by ACI. + Returning TRUE means: Forward the current SAT command + to MMI for further analysis. +*/ + +GLOBAL BOOL cmhSAT_copyUnprocEvents ( UBYTE* eventList, + UBYTE eventListLen, + UBYTE oldEventListLen) +{ + USHORT totalLen; + UBYTE lenDiff; + UBYTE i; + UBYTE j; + UBYTE shift = 0; /* Holds the shift value */ + + TRACE_FUNCTION("cmhSAT_copyUnprocEvents()"); + + /* No modification needed, all events processed in ACI */ + if ( (eventListLen EQ 0) AND (oldEventListLen NEQ 0) ) + { + return FALSE; + } + /* No modifiction necessary, all events are forwarded */ + else if ( eventListLen EQ oldEventListLen ) + { + return TRUE; + } + else + { + /* modify SAT event list string */ + /* calculate difference between new and old length of event list */ + lenDiff = oldEventListLen - eventListLen; + + /* modify the total length, always second (and third) byte + Note: This is the only length that is critical, if the length + decrement changes the total len from 2 to 1 byte representation + the whole array has to be shifted one position at the end of + modification. */ + if ( satShrdPrm.stkCmd[1] EQ 0x81 ) + { + if ( (satShrdPrm.stkCmd[2] > 0x7F) AND + ((satShrdPrm.stkCmd[2] - lenDiff) <= 0x7F )) /* mod changes repres.*/ + { + /* forces a shift at the end of modification */ + shift = 1; + } + satShrdPrm.stkCmd[2] = satShrdPrm.stkCmd[2] - lenDiff; + i = 3; + } + else + { + satShrdPrm.stkCmd[1] = satShrdPrm.stkCmd[1] - lenDiff; + i = 2; + } + + /* go to index of SET UP EVENT LIST TAG */ + while( i < satShrdPrm.stkCmdLen ) + { + /* Is tag set up event list TAG */ + if ( satShrdPrm.stkCmd[i] NEQ 0x99 ) + { + /* go LENGTH steps ahead */ + /* jump over the VALUE field to the next TAG */ + if ( satShrdPrm.stkCmd[i+1] EQ 0x81 ) /* 2 byte length representation */ + { + i = i + ( satShrdPrm.stkCmd[i+2] + 3 ); + } + else + { + i = i + ( satShrdPrm.stkCmd[i+1] + 2 ); + } + } + else + { + /* found index */ + break; + } + } + + /* insert new events and decrease length */ + if ( (i < satShrdPrm.stkCmdLen) AND + (satShrdPrm.stkCmd[i] EQ 0x99) ) + { + /* set index to LENGTH */ + i++; + /* decrease length */ + if ( satShrdPrm.stkCmd[i] EQ 0x81 ) /* 2 byte length representation */ + { + if ( satShrdPrm.stkCmd[i+1] - lenDiff <= 0x7F ) /*repres. changes to 1*/ + { + satShrdPrm.stkCmd[i] = satShrdPrm.stkCmd[i+1] - lenDiff; + /* set index just one byte ahead to overwrite second length byte */ + i++; + } + else + { + satShrdPrm.stkCmd[i+1] = satShrdPrm.stkCmd[i+1] - lenDiff; + /* set index to value */ + i+=2; + } + } + else /* just change the length */ + { + satShrdPrm.stkCmd[i] = satShrdPrm.stkCmd[i] - lenDiff; + /* set index to VALUE */ + i++; + } + /* write out events that have to be forwarded to MMI */ + for( j = 0; j < eventListLen; j++) + { + satShrdPrm.stkCmd[i+j] = eventList[j]; + } + + /* set index to end */ + i = i + j; + /* clear rest of array */ + if ( i < satShrdPrm.stkCmdLen ) + { + while ( i < satShrdPrm.stkCmdLen ) + { + satShrdPrm.stkCmd[i] = 0xFF; + i++; + } + } + + } + else + { + TRACE_EVENT("ERROR: Could not find SET UP EVENT LIST TAG"); + /* reset temp list to force error response */ + satShrdPrm.event.temp_list = 0L; + return FALSE; + } + + /* if shift is needed */ + /* set index to first byte of total length */ + i = 2; + if ( shift ) + { + for ( i = 2; i < (satShrdPrm.stkCmdLen - 1); i++ ) + { + satShrdPrm.stkCmd[i] = satShrdPrm.stkCmd[i+1]; + } + } + + /* decrease the total length */ + totalLen = satShrdPrm.stkCmdLen - (lenDiff*8); + satShrdPrm.stkCmdLen = totalLen; + + return TRUE; + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_setupEvent_Perform| ++-------------------------------------------------------------------+ + + PURPOSE : This function updates the event list to be whatched for SAT. +*/ + +GLOBAL void cmhSAT_setupEvent_Perform ( void ) +{ + TRACE_FUNCTION("cmhSAT_setupEvent_Perform()"); + + /* update list */ + satShrdPrm.event.list = satShrdPrm.event.temp_list; + + satShrdPrm.event.temp_list = 0L; /* reinitialize for next setup list */ + +#if defined (FF_SAT_E) AND defined (DTI) + /* inform SIM about a possible DATA AVAIL event */ + psaSIM_EvDatAvail(psaSAT_ChkEventList( EVENT_DATA_AVAIL )); +#endif /* FF_SAT_E */ + + /*psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, 0, NULL, NULL ); + not needed... what comes from MMI is sent to SAT */ +} +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_UserRejCall | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a terminal response, indicating that + the user has not accept the SAT call. + +*/ + +GLOBAL void cmhSAT_UserRejCall ( UBYTE calStat ) +{ + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_UserRejCall()"); + + psaSAT_InitTrmResp( &resp_data ); + +#ifdef FF_SAT_E + if( calStat EQ CS_SAT_CSD_REQ ) + + resp_data.chnStat = TRUE; +#endif /* FF_SAT_E */ + + psaSAT_SendTrmResp( RSLT_USR_REJ, &resp_data ); + +#ifdef FF_SAT_E + if( calStat EQ CS_SAT_CSD_REQ ) + { + cmhSAT_cleanupOpChnPrms(); + } +#endif /* FF_SAT_E */ +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_UserRejCntxt | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a terminal response, indicating that + the user has not accepted the SAT GPRS context. + +*/ + +#if defined (GPRS) && defined (FF_SAT_E) +GLOBAL void cmhSAT_UserRejCntxt( void ) +{ + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_UserRejCntxt()"); + + psaSAT_InitTrmResp( &resp_data ); + resp_data.chnStat = TRUE; + + psaSAT_SendTrmResp( RSLT_USR_REJ, &resp_data ); + + cmhSAT_cleanupOpChnPrms(); + +} +#endif /* GPRS && SAT E */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CallCncted | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a terminal response, indicating that + the SAT call was connected. + +*/ + +GLOBAL void cmhSAT_CallCncted ( void ) +{ + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_CallCncted()"); + + psaSAT_InitTrmResp( &resp_data ); + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_NtwErr | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a terminal response, indicating that + the SAT call was not connected due to a network problem. + The function will return TRUE if it is OK to send a AT + result code. If a result code should be suppressed, the + function will return FALSE. + +*/ + +GLOBAL UBYTE cmhSAT_NtwErr ( UBYTE cs ) +{ + + T_ACI_SAT_TERM_RESP resp_data; +#if defined (FF_SAT_E) AND defined (DTI) + T_SIM_SAT_CHN chnInf; +#endif + UBYTE ret = TRUE; + + TRACE_FUNCTION("cmhSAT_NtwErr()"); + + psaSAT_InitTrmResp( &resp_data ); + + resp_data.add_content = cs; + +#if defined (FF_SAT_E) AND defined (DTI) + /* in case of a SEND DATA command, close the channel. Terminal response + will be sent by SIM entity */ + if( satShrdPrm.chnTb.chnUsdFlg AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_SEND_DATA) + { + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_NTW_UNAB_PROC; + chnInf.addRes = cs; + + psaSIM_SATBIPChn( chnInf, cmhSAT_OpChnClose ); + ret = FALSE; + } + /* otherwise send a terminal response */ + else + { + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.opchType EQ B_CSD ) + { + resp_data.chnStat = TRUE; + } +#endif /* FF_SAT_E */ + + psaSAT_SendTrmResp( RSLT_NTW_UNAB_PROC, &resp_data ); + +#if defined (FF_SAT_E) AND defined (DTI) + } + + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.opchType EQ B_CSD ) + { + satShrdPrm.chnTb.chnUsdFlg = FALSE; + cmhSAT_cleanupOpChnPrms(); + } +#endif /* FF_SAT_E */ + + return ret; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_UserClear | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a terminal response, indicating that + the SAT call was not connected due to a user clearance. + +*/ + +GLOBAL void cmhSAT_UserClear ( void ) +{ + T_ACI_SAT_TERM_RESP resp_data; +#if defined (FF_SAT_E) AND defined (DTI) + T_SIM_SAT_CHN chnInf; +#endif /* FF_SAT_E */ + + TRACE_FUNCTION("cmhSAT_UserClear()"); + + psaSAT_InitTrmResp( &resp_data ); + +#if defined (FF_SAT_E) AND defined (DTI) + /* in case of a SEND DATA command, close the channel. Terminal response + will be sent by SIM entity */ + if( satShrdPrm.chnTb.chnUsdFlg AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_SEND_DATA) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_USR_CLR_DWN; + chnInf.addRes = ADD_NO_CAUSE; + + psaSIM_SATBIPChn( chnInf, cmhSAT_OpChnClose ); + } + /* otherwise send a terminal response */ + else + { + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.opchType EQ B_CSD ) + { + resp_data.chnStat = TRUE; + } +#endif /* FF_SAT_E */ + psaSAT_SendTrmResp( RSLT_USR_CLR_DWN, &resp_data ); + +#if defined (FF_SAT_E) AND defined (DTI) + } + + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.opchType EQ B_CSD ) + { + satShrdPrm.chnTb.chnUsdFlg = FALSE; + cmhSAT_cleanupOpChnPrms(); + } +#endif /* FF_SAT_E */ +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_UserAcptCall | ++-------------------------------------------------------------------+ + + PURPOSE : This function performs the user acceptance of the pending + SAT call. If command details do not allow the operation, + the function returns FALSE. + +*/ + +GLOBAL BOOL cmhSAT_UserAcptCall ( SHORT acptId, UBYTE srcId ) +{ + T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */ + SHORT actId; /* holds id of active call */ + UBYTE ctbIdx; /* holds call table index */ + BOOL found_call=FALSE; + +#if defined (FAX_AND_DATA) AND defined (FF_SAT_E) + T_SIM_SAT_CHN chnInf; +#endif + + TRACE_FUNCTION("cmhSAT_UserAcptCall()"); + + pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm; + + pCCCmdPrm -> mltyCncFlg = 0; + pCCCmdPrm -> mltyDscFlg = 0; + + psaCC_ctb(acptId)->curCmd = AT_CMD_A; + psaCC_ctb(acptId)->curSrc = srcId; + +/* + *------------------------------------------------------------------- + * perform according to command details for SETUP CALL command + *------------------------------------------------------------------- + */ + if (psaCC_ctb(acptId)->calStat EQ CS_SAT_REQ) + { + if( !cmhSAT_ChckCmdDet() ) + { + psaCC_FreeCtbNtry (acptId); + return( FALSE ); + } + + switch( satShrdPrm.cmdDet.cmdQlf ) + { + case( QLF_CALL_HOLD ): + case( QLF_CALL_HOLD_RDL ): + + actId = psaCC_ctbFindCall( NO_VLD_OWN, CS_ACT, NO_VLD_CT ); + + if( actId NEQ NO_ENTRY ) + { + psaCC_ctb(actId)->SATinv = TRUE; + + cmhCC_HoldCall(actId, psaCC_ctb(acptId)->curSrc, AT_CMD_A); + + if( psaCC_ctb(actId)->mptyStat NEQ CS_ACT ) + { + /* do not start building sat call, has to wait for answer for holding */ + return( TRUE ); + } + } + break; + + case( QLF_CALL_DISC ): + case( QLF_CALL_DISC_RDL ): + + for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ ) + { + T_CC_CALL_TBL *ctbx = ccShrdPrm.ctb[ctbIdx]; + + if (ctbx NEQ NULL AND + ctbIdx NEQ acptId ) + { + cmhCC_flagCall( ctbIdx, &(pCCCmdPrm -> mltyDscFlg)); + ctbx->nrmCs = MNCC_CAUSE_CALL_CLEAR; + ctbx->curCmd = AT_CMD_H; + ctbx->curSrc = psaCC_ctb(acptId)->curSrc; + ctbx->SATinv = TRUE; + psaCC_ClearCall (ctbIdx); + found_call = TRUE; + } + } + + if (found_call) + { + /* do not start building sat call, has to wait for answer for clearing */ + return( TRUE ); + } + break; + } + } + +/* + *------------------------------------------------------------------- + * perform according to command details for OPEN CHANNEL command + *------------------------------------------------------------------- + */ +#if defined (FAX_AND_DATA) AND defined (FF_SAT_E) AND defined (DTI) + + if( psaCC_ctb(acptId)->calStat EQ CS_SAT_CSD_REQ ) + { + + /* reset own to SAT */ + psaCC_ctb(acptId)->calOwn = OWN_SAT; + + /* store current command source */ + satShrdPrm.opchAcptSrc = srcId; + + if( satShrdPrm.opchPrm AND + ((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->v_itl AND + ((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->itl.trans_prot_type EQ UDP ) + { + satShrdPrm.chnTb.chnTPL = ((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->itl.trans_prot_type; + } + else + { + satShrdPrm.chnTb.chnTPL = TPL_NONE; + } + + /* check for on-demand channel establishment */ + if(!(satShrdPrm.cmdDet.cmdQlf & QLF_OPCH_IMMDT_LINK_EST)) + { + /* CASE: ON DEMAND */ + /* set open channel status */ + satShrdPrm.opchStat = OPCH_ON_DMND; + } + else /* immediately channel establishment */ + { + /* CASE: IMMEDIATELY */ + /* check temporary problems */ + if( cmhSAT_OpChnChkTmpProblem() ) + { + psaCC_FreeCtbNtry (acptId); + satShrdPrm.chnTb.chnUsdFlg = FALSE; + + return( FALSE ); + } + + /* set open channel status */ + satShrdPrm.opchStat = OPCH_EST_REQ; + +#ifdef DTI +#ifdef CO_UDP_IP + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + /* enable establishment of UDP data chain */ + sAT_PercentWAP ( psaCC_ctb(acptId)->curSrc , 1 ); + + /* setup PPP parameters */ + cmhSAT_OpChnSetPPP( B_CSD ); + } +#endif /* CO_UDP_IP */ +#endif /* DTI */ + } + + /* Establish BIP channel for immediate and on demand */ + chnInf.bipConn = SIM_BIP_OPEN_CHANNEL; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_PERF_SUCCESS; + chnInf.addRes = ADD_NO_CAUSE; + + /* SAT_E_PATCH: send SIM_BIP_REQ to open BIP channel */ + psaSIM_SATBIPChn( chnInf, cmhSAT_OpBIPChnOpen); + + return (TRUE); + } +#endif /* FAX_AND_DATA AND FF_SAT_E */ + + /* finally set up call */ + cmhCC_flagCall( acptId, &(pCCCmdPrm->mltyCncFlg)); + cmhCC_NewCall(acptId, srcId, AT_CMD_A); + return( TRUE ); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_UserAcptCntxt | ++-------------------------------------------------------------------+ + + PURPOSE : This function performs the user acceptance of the pending + SAT GPRS context. If conditions occur, which prevent the + establishment of the context, the function returns FALSE. + +*/ + +#if defined (GPRS) AND defined (FF_SAT_E) AND defined (DTI) +GLOBAL BOOL cmhSAT_UserAcptCntxt( UBYTE srcId ) +{ + T_SIM_SAT_CHN chnInf; /* holds channel information */ + SHORT cid_array[2] = { 0,INVALID_CID }; + + TRACE_FUNCTION("cmhSAT_UserAcptCntxt()"); + + /* store current command source */ + satShrdPrm.opchAcptSrc = srcId; + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + if( satShrdPrm.opchPrm AND + ((T_SAT_GPRS_PRM*)satShrdPrm.opchPrm)->v_itl AND + ((T_SAT_GPRS_PRM*)satShrdPrm.opchPrm)->itl.trans_prot_type EQ UDP ) + { + satShrdPrm.chnTb.chnTPL = ((T_SAT_GPRS_PRM*)satShrdPrm.opchPrm)->itl.trans_prot_type; + } + else + { + satShrdPrm.chnTb.chnTPL = TPL_NONE; + } + + + /* check for on-demand channel establishment */ + if(!(satShrdPrm.cmdDet.cmdQlf & QLF_OPCH_IMMDT_LINK_EST)) + { + /* CASE: ON DEMAND */ + + /* set open channel status */ + satShrdPrm.opchStat = OPCH_ON_DMND; + } + else + { + /* CASE: IMMEDIATELY */ + + /* check temporary problems */ + if( cmhSAT_OpChnChkTmpProblem() ) + { + /* any reset of cid parameters should be placed here, if necessary */ + return( FALSE ); + } + + /* set open channel status */ + satShrdPrm.opchStat = OPCH_EST_REQ; + } +/* + * The activation of the GPRS context is triggered by cmhSAT_OpBIPChnOpen(), + * a function processing the SIM_BIP_CNF. In the new design the BIP channel + * has to be established before the bearer is started (see also + * cmhSAT_UserAcptCall() for CSD case) + */ + + /* Establish BIP channel for immediate and on demand */ + chnInf.bipConn = SIM_BIP_OPEN_CHANNEL; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_PERF_SUCCESS; + chnInf.addRes = ADD_NO_CAUSE; + + /* SAT_E_PATCH: send SIM_BIP_REQ to open BIP channel */ + psaSIM_SATBIPChn( chnInf, cmhSAT_OpBIPChnOpen); + + return ( TRUE ); +} +#endif /* GPRS AND FF_SAT_E */ +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_ChckRedial | ++-------------------------------------------------------------------+ + + PURPOSE : This function checks the redialling conditions and setup + the appropriate parameters. + +*/ + +GLOBAL LONG cmhSAT_ChckRedial ( SHORT cId, UBYTE v_dur, T_dur * dur ) +{ + TRACE_FUNCTION("cmhSAT_ChckRedial()"); + + satShrdPrm.dur = -1; + +/* + *------------------------------------------------------------------- + * check command qualifier for redialling + *------------------------------------------------------------------- + */ +#ifdef FF_SAT_E + /* in case of SETUP CALL command */ + if( satShrdPrm.cmdDet.cmdType EQ SAT_CMD_SETUP_CALL ) +#endif /* FF_SAT_E */ + { + switch( satShrdPrm.cmdDet.cmdQlf ) + { + case( QLF_CALL_IDLE_RDL ): + case( QLF_CALL_HOLD_RDL ): + case( QLF_CALL_DISC_RDL ): + + break; + + default: + + return( ACI_NumParmNotPresent ); + } + } + +#ifdef FF_SAT_E + /* in case of OPEN CHANNEL command */ + if( satShrdPrm.cmdDet.cmdType EQ SAT_CMD_OPEN_CHANNEL ) + { + if(!(satShrdPrm.cmdDet.cmdQlf & QLF_OPCH_AUTO_RECONNECT)) + + return( ACI_NumParmNotPresent ); + } +#endif /* FF_SAT_E */ + + /* calculate redial timeout */ + psaCC_ctb(cId)->SATinv |= SAT_REDIAL; + + if( v_dur ) + { + switch( dur->time_unit ) + { + /* scale to ms */ + case( TU_MIN ): + satShrdPrm.dur = dur->time_ivl*60000; + break; + case( TU_SEC ): + satShrdPrm.dur = dur->time_ivl*1000; + break; + case( TU_100_MSEC ): + satShrdPrm.dur = dur->time_ivl*100; + break; + default: + satShrdPrm.dur = -1; + } + } + + + return((satShrdPrm.dur EQ -1)?ACI_NumParmNotPresent:satShrdPrm.dur); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_StartPendingCall | ++-------------------------------------------------------------------+ + + PURPOSE : This function performs the actual start of the pending + SAT call. +*/ + +GLOBAL BOOL cmhSAT_StartPendingCall ( void ) +{ + T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */ + SHORT satId; /* id of sat pending call */ +#if defined SMI OR defined MFW OR defined FF_MMI_RIV + T_ACI_CLOG cmdLog; /* holds logging info */ +#endif + + TRACE_FUNCTION("cmhSAT_StartPendingCall()"); + + satId = psaCC_ctbFindCall( NO_VLD_OWN, CS_SAT_REQ, NO_VLD_CT ); + + if (satId EQ NO_ENTRY) + return FALSE; + + pCCCmdPrm = &cmhPrm[psaCC_ctb(satId)->curSrc].ccCmdPrm; + TRACE_EVENT_P1("psaCC_ctb(cId)->curCmd: %d", psaCC_ctb(satId)->curCmd); + + cmhCC_flagCall( satId, &(pCCCmdPrm -> mltyCncFlg)); + psaCC_NewCall(satId); + +#if defined SMI OR defined MFW OR defined FF_MMI_RIV + cmdLog.atCmd = AT_CMD_A; + cmdLog.cmdType = CLOG_TYPE_Set; + cmdLog.retCode = AT_EXCT; + cmdLog.sId = ACI_NumParmNotPresent; + cmdLog.cmdPrm.sA.srcId = psaCC_ctb(satId)->curSrc; + cmdLog.cId = satId+1; + rAT_PercentCLOG( &cmdLog ); +#endif + + return TRUE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_ChckCmdDet | ++-------------------------------------------------------------------+ + + PURPOSE : This function checks the command details against the + current ME status. If the mobile status does not interfere + with the command details, the function returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_ChckCmdDet ( void ) +{ + SHORT ctbIdx; /* holds call table index */ + SHORT actId = NO_ENTRY; /* identifier for active call */ + SHORT hldId = NO_ENTRY; /* identifier for held call */ + SHORT cId = satShrdPrm.SIMCCParm.cId; /* holds setup call id */ + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_ChckCmdDet()"); + + if (!psaCC_ctbIsValid (cId)) + { + TRACE_ERROR ("Call table entry disappeared"); + return FALSE; + } + + /* + * From here it is guaranteed that cId describes an existing (non-NULL) + * call table entry. + */ + + psaSAT_InitTrmResp( &resp_data ); +/* + *------------------------------------------------------------------- + * scan call table + *------------------------------------------------------------------- + */ + for( ctbIdx = 0; ctbIdx < MAX_CALL_NR; ctbIdx++ ) + { + if (ccShrdPrm.ctb[ctbIdx] NEQ NULL) + { + switch( psaCC_ctb(ctbIdx)->calStat ) + { + case( CS_ACT ): + case( CS_ACT_REQ ): + case( CS_MDF_REQ ): + + actId = ctbIdx; + break; + + case( CS_HLD ): + case( CS_HLD_REQ ): + + hldId = ctbIdx; + break; + } + } + } + +/* + *------------------------------------------------------------------- + * check command qualifier against ME status + *------------------------------------------------------------------- + */ + switch( satShrdPrm.cmdDet.cmdQlf ) + { + case( QLF_CALL_IDLE ): + case( QLF_CALL_IDLE_RDL ): + + if( actId NEQ NO_ENTRY OR hldId NEQ NO_ENTRY ) + { + resp_data.add_content = ADD_ME_CALL_BUSY; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + /* clear call ID */ + psaCC_retMOCTi(psaCC_ctb(cId)->ti); + psaCC_chngCalTypCnt(cId, -1); + psaCC_FreeCtbNtry (cId); + + TRACE_EVENT("cmhSAT_ChckCmdDet(): CALL_BUSY, RSLT_ME_UNAB_PROC"); + return( FALSE ); + } + break; + + case( QLF_CALL_HOLD ): + case( QLF_CALL_HOLD_RDL ): + + if( ( hldId NEQ NO_ENTRY AND actId NEQ NO_ENTRY ) OR + ( actId NEQ NO_ENTRY AND + psaCC_ctb(actId)->prio EQ PRIO_NORM_CALL AND + cmhCC_getcalltype(actId) NEQ VOICE_CALL ) ) + { + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + TRACE_EVENT("cmhSAT_ChckCmdDet(): RSLT_ME_CAP"); + return( FALSE ); + } + break; + + case( QLF_CALL_DISC ): + case( QLF_CALL_DISC_RDL ): + + break; + } + + return( TRUE ); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_fillSetupBC | ++-------------------------------------------------------------------+ + + PURPOSE : This function fills the call table bentry with the + necessary bearer service setup parameters. + +*/ + +GLOBAL void cmhSAT_fillSetupBC ( SHORT cId, + UBYTE bearer_serv_1, + UBYTE bearer_serv_2 ) +{ + T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId]; + + TRACE_FUNCTION ("cmhSAT_fillSetupBC()"); + + /* + *----------------------------------------------------------------- + * bearer service + *----------------------------------------------------------------- + */ + if ( bearer_serv_1 EQ BEARER_SERV_NOT_PRES ) + { + ctb->BC[0].rate = UR_NOT_PRES; + ctb->BC[0].bearer_serv = BEARER_SERV_SPEECH; + ctb->BC[0].conn_elem = CONN_ELEM_NOT_PRES; + } + else + { + ctb->BC[0].rate = UR_NOT_PRES; + ctb->BC[0].bearer_serv = (bearer_serv_1 EQ BEARER_SERV_SPEECH) ? + cmhCC_set_speech_serv (&cmhPrm[CMD_SRC_LCL].ccCmdPrm) : bearer_serv_1; + ctb->BC[0].conn_elem = CONN_ELEM_NOT_PRES; + } + if ( bearer_serv_2 EQ BEARER_SERV_NOT_PRES ) + { + ctb->BC[1].rate = UR_NOT_PRES; + ctb->BC[1].bearer_serv = BEARER_SERV_NOT_PRES; + ctb->BC[1].conn_elem = CONN_ELEM_NOT_PRES; + } + else + { + ctb->BC[1].rate = UR_NOT_PRES; + ctb->BC[1].bearer_serv = (bearer_serv_2 EQ BEARER_SERV_SPEECH) ? + cmhCC_set_speech_serv (&cmhPrm[CMD_SRC_LCL].ccCmdPrm) : bearer_serv_2; + ctb->BC[1].conn_elem = CONN_ELEM_NOT_PRES; + } +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_convertBCDNum | ++-------------------------------------------------------------------+ + + PURPOSE : This function converts the BCD number to an ascii char + string + +*/ +LOCAL void cmhSAT_convertBCDNum(U8 *bcdNum, U16 len, CHAR *bcdChar) +{ + int i; + + TRACE_FUNCTION("cmhSAT_convertBCDNum"); + + memset(bcdChar, 0, MAX_PARTY_NUM_SAT); + + for ( i=0; i < len; i++) + { + bcdChar[i] = bcdNum[i] + '0'; + } + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_fillSetupPrm | ++-------------------------------------------------------------------+ + + PURPOSE : This function fills the call table entry with the + necessary SAT setup parameters. + +*/ + +GLOBAL void cmhSAT_fillSetupPrm ( SHORT cId, + T_addr *adr, + T_subaddr *sub ) +{ + T_CC_CALL_TBL *ctb = ccShrdPrm.ctb[cId]; + UBYTE i; + USHORT dummy=0, length; + CHAR *buf_4_dtmf; + BOOL end_of_dial_string = FALSE; + CHAR *number_buffer; + + TRACE_FUNCTION ("cmhSAT_fillSetupPrm()"); + + ACI_MALLOC(number_buffer, MAX_PARTY_NUM_SAT); + ACI_MALLOC(buf_4_dtmf, MAX_CC_CALLED_NUMBER+1); + + /* called address */ + if( adr NEQ NULL ) + { + /* check for emergency call code 112 */ + if( adr -> c_bcdDigit > 0 AND + adr -> bcdDigit[adr -> c_bcdDigit-1] EQ 0x0f ) + { + adr -> c_bcdDigit -= 1; + } + + cmhSAT_convertBCDNum(adr->bcdDigit, adr->c_bcdDigit, number_buffer); + + /* Only use 112 as an Emmergency Call on STK */ + if (!strcmp(number_buffer,"112")) + { + ctb->prio = PRIO_EMERG_CALL; + TRACE_EVENT("EMERGENCY CALL"); + } + else + ctb->prio = PRIO_NORM_CALL; + + /* Check for DTMF tones within dial string */ + length = MINIMUM(adr->c_bcdDigit, MAX_CC_CALLED_NUMBER); + for(i=0; i<length; i++) + { + /* convert address: PHB compliant */ + buf_4_dtmf[i] = cmhPHB_convertBCD2char( adr->bcdDigit[i] ); + if(buf_4_dtmf[i] EQ PHB_DTMF_SEP) + { + /* DTMF separator */ + if(!end_of_dial_string) + { + adr-> c_bcdDigit = i; /* split number from DTMF tones */ + end_of_dial_string = TRUE; + } + } + } + + buf_4_dtmf[length] = '\0'; + cmhCC_chkDTMFDig ( buf_4_dtmf, cId, dummy, TRUE ); + + /* set address */ + ctb->cldPty.ton = adr -> noa; + ctb->cldPty.npi = adr -> npi; + + ctb->cldPty.c_called_num = MINIMUM( MAX_SMS_ADDR_DIG, adr -> c_bcdDigit ); /* why MAX_SMS_ADDR_DIG ??? */ + if (ctb->cldPty.called_num NEQ NULL) + { + ACI_MFREE (ctb->cldPty.called_num); + ctb->cldPty.called_num = NULL; + } + if (ctb->cldPty.c_called_num NEQ 0) + { + ACI_MALLOC (ctb->cldPty.called_num, ctb->cldPty.c_called_num); + memcpy( ctb->cldPty.called_num, + adr -> bcdDigit, + ctb->cldPty.c_called_num ); + } + + psaCC_phbSrchNum( cId, CT_MOC ); /* get alpha identifier */ + + } + +/* + *----------------------------------------------------------------- + * called subaddress + *----------------------------------------------------------------- + */ + if( sub NEQ NULL ) + { + if( sub -> c_bcdDigit > 0 AND + sub -> bcdDigit[sub -> c_bcdDigit-1] EQ 0x0f ) + + sub -> c_bcdDigit -= 1; + + ctb->cldPtySub.c_subaddr = + MINIMUM( SUB_LENGTH, sub -> c_bcdDigit ); + + memcpy( ctb->cldPtySub.subaddr, sub -> bcdDigit, + ctb->cldPtySub.c_subaddr ); + + ctb->cldPtySub.tos = sub -> tos; + + ctb->cldPtySub.odd_even = sub -> oei; + } + else /* subaddress not found */ + { + ctb->cldPtySub.tos = TOS_NOT_PRES; + ctb->cldPtySub.odd_even = OE_EVEN; + ctb->cldPtySub.c_subaddr = 0; + } + + /* + *----------------------------------------------------------------- + * clir + *----------------------------------------------------------------- + */ + ctb->CLIRsup = NOT_PRESENT_8BIT; + ctb->rptInd = RI_NOT_PRES; + + ACI_MFREE(number_buffer); + ACI_MFREE(buf_4_dtmf); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_chkDTMF | ++-------------------------------------------------------------------+ + + PURPOSE : This function extracs DTMF digit from the dial string and + store them in a buffer. +*/ +#if 0 +GLOBAL void cmhSAT_chkDTMF ( SHORT cId, T_addr* adr ) +{ + UBYTE cnt = 0; + UBYTE dtmf = 0; + USHORT len = adr->c_bcdDigit; + + /* reset dtmf parameters */ + satDtmfBuf.cId = -1; + satDtmfBuf.cnt = 0; + satDtmfBuf.cur = 0; + + /* search first occurrence of dtmf digit */ + while( adr->bcdDigit[cnt] NEQ 0x0C AND cnt < len ) cnt++; + + /* if none return */ + if( cnt EQ adr->c_bcdDigit ) return; + + /* adjust num digit count */ + adr->c_bcdDigit = cnt; + + /* convert to IA5 */ + while( cnt < len AND dtmf < MAX_DTMF_DIG ) + { + satDtmfBuf.dig[dtmf] = cmhPHB_convertBCD2char( adr->bcdDigit[cnt] ); + + cnt++; + if( satDtmfBuf.dig[dtmf] NEQ '\0' ) + { + dtmf++; /* else erase it: that was an invalid parameter */ + } + } + + /* update dtmf parameter */ + satDtmfBuf.cnt = dtmf+1; + satDtmfBuf.cur = 0; + satDtmfBuf.cId = cId; +} +#endif /* 0 */ +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_ResCapCode | ++-------------------------------------------------------------------+ + + PURPOSE : This function proceeds after the reception of a capability + configuration parameter coding. +*/ + +GLOBAL void cmhSAT_ResCapCode ( USHORT cause, T_bcconf* bc ) +{ + SHORT cId; /* holds call id */ + UBYTE cmdBuf; /* buffers command */ + UBYTE srcBuf; /* buffers command source */ + + cId = satShrdPrm.capParm.cId; + + if (!psaCC_ctbIsValid (cId)) + { + TRACE_ERROR ("Call table entry disappeared"); + return; + } + + switch( cause ) + { + case( MNCC_CAUSE_SUCCESS ): + + /* + *------------------------------------------------------------------- + * build envelope call control command + *------------------------------------------------------------------- + */ + CCD_START; + psaSAT_BuildEnvCC ( cId, NULL, NULL, bc ); + + satShrdPrm.SIMCCParm.cId = cId; + satShrdPrm.SIMCCParm.ccAct = CC_ACT_CAL; + satShrdPrm.SIMCCParm.owner = psaCC_ctb(cId)->calOwn; + satShrdPrm.SIMCCParm.busy = TRUE; + + satShrdPrm.owner = NO_VLD_OWN; + + psaSAT_STKEnvelope (NULL); + + CCD_END; + break; + + case( MNCC_CAUSE_MS_INCOMPAT_DEST ): + default: + + /* + *------------------------------------------------------------------- + * inform MMI about unsuccessful call setup + *------------------------------------------------------------------- + */ + /* at the moment only user caps need to be coded */ + cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf); + psaCC_FreeCtbNtry (cId); + + R_AT( RAT_CME, srcBuf ) ( cmdBuf, CME_ERR_NotPresent ); + + /* log result */ + cmh_logRslt ( srcBuf, RAT_CME, cmdBuf, + -1, -1, CME_ERR_NotPresent ); + break; + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_ResCapDecode | ++-------------------------------------------------------------------+ + + PURPOSE : This function proceeds after the reception of a capability + configuration parameter decoding. +*/ + +GLOBAL void cmhSAT_ResCapDecode ( USHORT cause, T_bcpara* bc ) +{ + T_CC_CALL_TBL *ctb; /* Pointer to call table */ + unsigned bci; /* Bearer capability index */ + SHORT cId; /* holds call id */ + UBYTE ownNotSAT; /* flags that the owner is not SAT */ + UBYTE cmdBuf; /* buffers command */ + UBYTE srcBuf; /* buffers command */ + UBYTE idx; /* holds index */ + T_ACI_RETURN retVal; /* holds return value */ + T_ACI_SAT_TERM_RESP resp_data; +#ifdef FF_SAT_E + T_ACI_SATA_ADD addPrm; +#endif /* FF_SAT_E */ + + cId = satShrdPrm.capParm.cId; + + if (!psaCC_ctbIsValid (cId)) + { + TRACE_ERROR ("Call table entry disappeared"); + return; + } + + ctb = ccShrdPrm.ctb[cId]; + + psaSAT_InitTrmResp( &resp_data ); + + ownNotSAT = ctb->calOwn NEQ OWN_SAT; + + switch( cause ) + { + case( MNCC_CAUSE_SUCCESS ): + + if( ownNotSAT ) + { + for (bci = 0; bci < 2; bci++) + { + if (ctb->BC[bci].bearer_serv NEQ BEARER_SERV_NOT_PRES AND + ctb->BC[bci].bearer_serv NEQ BEARER_SERV_SPEECH AND + ctb->BC[bci].bearer_serv NEQ BEARER_SERV_AUX_SPEECH ) + { + ctb->BC[bci] = *bc; + } + } + } + else + { + ctb->BC[0] = *bc; + } + + /* check capability context */ + switch( satShrdPrm.capParm.cntxt ) + { + case( CTX_SAT_SETUP ): + + /* check for call control by SIM */ + retVal = cmhSAT_CalCntrlBySIM( cId ); + + switch( retVal ) + { + case( AT_EXCT ): + break; + + case( AT_BUSY ): + /* respond with "Interaction with call control by SIM, temporary" */ + psaSAT_SendTrmResp( RSLT_CC_SIM_TMP, &resp_data ); + psaCC_FreeCtbNtry (cId); + break; + + case( AT_FAIL ): + /* respond with "Interaction with call control by SIM, permanent" */ + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); + psaCC_FreeCtbNtry (cId); + break; + } + + /* alert user if command details are supported */ + if( cmhSAT_ChckCmdDet() ) + { + for( idx = 0; idx < CMD_SRC_MAX; idx++ ) + { +#ifdef FF_SAT_E + addPrm.chnType = SATA_CT_VOICE; + addPrm.chnEst = SATA_EST_IM; + + R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur, &addPrm ); +#else /* FF_SAT_E */ + R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur); +#endif /* FF_SAT_E */ + } + } + else + + psaCC_FreeCtbNtry (cId); + + break; + + case( CTX_CC_RESULT ): + + cmhSAT_SetupCalAfterCCRes ( ownNotSAT, cId, satShrdPrm.capParm.CCres ); + break; + } + break; + + case( MNCC_CAUSE_MS_INCOMPAT_DEST ): + default: + + /* + *------------------------------------------------------------------- + * inform about unsuccessful call setup + *------------------------------------------------------------------- + */ + /* setup initiated by user */ + if( ownNotSAT ) + { + cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf); + psaCC_FreeCtbNtry (cId); + + R_AT( RAT_CME, srcBuf ) ( cmdBuf, CME_ERR_NotPresent ); + + /* log result */ + cmh_logRslt ( srcBuf, RAT_CME, cmdBuf, + -1, -1, CME_ERR_NotPresent ); + } + /* setup initiated by SAT */ + else + { + /* send SAT response */ + resp_data.resCC = (satShrdPrm.capParm.cntxt EQ CTX_CC_RESULT)? + &satShrdPrm.capParm.CCres: NULL; + + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + } + break; + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_SetupCalAfterCCRes| ++-------------------------------------------------------------------+ + + PURPOSE : This function proceeds with call setup after call control + by SIM result. +*/ + +GLOBAL BOOL cmhSAT_SetupCalAfterCCRes ( UBYTE ownNotSAT, SHORT cId, + UBYTE CCres) +{ + SHORT actId; /* holds active call id */ + UBYTE cmdBuf; /* buffers command */ + UBYTE srcBuf; /* buffers command source */ + UBYTE idx; /* holds list index */ + T_ACI_SAT_TERM_RESP resp_data; +#ifdef FF_SAT_E + T_ACI_SATA_ADD addPrm; +#endif /* FF_SAT_E */ + + psaSAT_InitTrmResp( &resp_data ); + + /* + *------------------------------------------------------------ + * perform call setup initiated by user + *------------------------------------------------------------ + */ + if( ownNotSAT ) + { + /* check for an active call */ + actId = psaCC_ctbFindCall( NO_VLD_OWN, CS_ACT, NO_VLD_CT ); + + if( actId NEQ NO_ENTRY ) + { + /* put active on hold if possible */ + if( psaCC_ctb(actId)->prio EQ PRIO_NORM_CALL AND + cmhCC_getcalltype(cId) EQ VOICE_CALL ) + { + cmhCC_HoldCall(actId, psaCC_ctb(cId)->curSrc, AT_CMD_D); + } + /* reject call setup */ + else + { + cmhCC_PrepareCmdEnd (cId, &cmdBuf, &srcBuf);; + psaCC_FreeCtbNtry (cId); + + R_AT( RAT_CME, srcBuf ) ( cmdBuf, CME_ERR_NotPresent ); + + /* log result */ + cmh_logRslt ( srcBuf, RAT_CME, cmdBuf, + -1, -1, CME_ERR_NotPresent ); + return( FALSE ); + } + } + + /* finally set up call */ + cmhCC_flagCall( cId, + &(cmhPrm[psaCC_ctb(cId)->calOwn].ccCmdPrm.mltyCncFlg)); + + psaCC_NewCall(cId); + + return( FALSE ); + } + + /* + *------------------------------------------------------------ + * perform call setup initiated by SAT + *------------------------------------------------------------ + */ + else + { + /* alert user if command details are supported */ + if( cmhSAT_ChckCmdDet() ) + { + /* check aoc condition */ + if ((psaCC_ctb(cId)->prio EQ PRIO_NORM_CALL) AND + (aoc_check_moc() EQ FALSE)) + /* + * check ACM exceeds ACMmax + * for non-emergency calls + */ + { + resp_data.add_content = ADD_NO_CAUSE; + resp_data.resCC = (CCres EQ CCR_ALLW_WITH_MDFY)? &CCres: NULL; + + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + for( idx = 0; idx < CMD_SRC_MAX; idx++ ) + { +#ifdef FF_SAT_E + addPrm.chnType = SATA_CT_VOICE; + addPrm.chnEst = SATA_EST_IM; + + R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur, &addPrm ); +#else /* FF_SAT_E */ + R_AT( RAT_SATA, idx )( cId+1, satShrdPrm.dur ); +#endif /* FF_SAT_E */ + } + + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + + return( TRUE ); + } + return( FALSE); + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_sendSM | ++-------------------------------------------------------------------+ + + PURPOSE : This function sends a Short Message requested by SAT. + If the request is going to be processed, the function + returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_sendSM ( T_SEND_SM * sm ) +{ + T_ACI_RETURN retVal; /* holds return value */ + UBYTE fo, mn; + USHORT oct_nr; + + USHORT sca_addr_len; /* length of service center address */ + T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ + T_ACI_SM_DATA pdu; + + UBYTE packed_data[MAX_SM_LEN]; + UBYTE header_len; + UBYTE dcs, *p_dcs; + UBYTE udl, *p_udl; + UBYTE oct_udl; + + UBYTE *sm_cont; /* pointer to the current position in the pdu */ + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_sendSM()"); + + psaSAT_InitTrmResp( &resp_data ); + pdu.len = 0; + + pSMSSetPrm = smsShrdPrm.pSetPrm[OWN_SAT]; + +/* + *------------------------------------------------------------------- + * check presence of SMS TPDU + *------------------------------------------------------------------- + */ + if (!sm->v_smpdu) + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } +/* + *------------------------------------------------------------------- + * get SCA + *------------------------------------------------------------------- + */ + if (sm->v_addr AND sm->addr.c_bcdDigit > 0) + { + if (sm->addr.c_bcdDigit >= MAX_SMS_NUM_LEN) + { + TRACE_EVENT("cmhSAT_sendSM: ERROR SMSC address to long"); + /* SCA number too long */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* copy the sca into the pdu */ + sca_addr_len = CodeRPAddress(pdu.data, + (UBYTE)sm->addr.c_bcdDigit, + sm->addr.noa, + sm->addr.npi, + sm->addr.bcdDigit); + + } + else + { + /* ACI-SPR-16431: changes */ + if ( psaSIM_ChkSIMSrvSup( SRV_SMS_Parms ) ) /* verify that SMSP is provided */ + { + if ( pSMSSetPrm -> sca.c_num > 0 ) /* verify that SMSP contains address */ + { + /* ready to copy the sca into the pdu */ + sca_addr_len = CodeRPAddress(pdu.data, + pSMSSetPrm -> sca.c_num, + pSMSSetPrm -> sca.ton, + pSMSSetPrm -> sca.npi, + pSMSSetPrm -> sca.num); + } + else + { + /* ERROR: SMSP address EMPTY */ + TRACE_EVENT("cmhSAT_sendSM: ERROR: SMSP address EMPTY"); + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); /* TR(20) */ + return( FALSE ); + } + } + else + { + /* ERROR: SMSP NOT available */ + TRACE_EVENT("cmhSAT_sendSM: ERROR: SMSP NOT available"); + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); /* TR(20) */ + return( FALSE ); + } + } + +/* + *------------------------------------------------------------------- + * check and evaluate SMS TPDU + *------------------------------------------------------------------- + */ + if (sm->smpdu.c_tpdu_data > 0) + { + fo = sm->smpdu.tpdu_data[0]; /* first octet with Message Type */ + switch (fo & TP_MTI_MASK) + { + case TP_MTI_SMS_SUBMIT: + if (sm->smpdu.c_tpdu_data < 7) + { + /* not the minimum length for TP-SUBMIT */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + if (sm->smpdu.tpdu_data[2] >= MAX_SMS_NUM_LEN) + { + /* destination number too long */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* oct_nr is the number of bytes in address value */ + oct_nr = (USHORT)((sm->smpdu.tpdu_data[2] + 1) / 2); + if ((oct_nr + 7) > (USHORT)sm->smpdu.c_tpdu_data) + { + /* number length inconsistent with overall length for TP-SUBMIT */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* sm_cont points now to TP-DCS */ + sm_cont = &sm->smpdu.tpdu_data[4 + oct_nr + 1]; + p_dcs = &pdu.data[sca_addr_len+4 + oct_nr + 1]; + + /* sm_cont points now to TP-VP */ + dcs = *sm_cont++; + + + switch (fo & TP_VPF_MASK) + { + case TP_VPF_NOT_PRESENT: + default: + /* oct_nr is length of TP-UD */ + oct_nr = (USHORT)sm->smpdu.c_tpdu_data - oct_nr - 7; + break; + + case TP_VPF_RELATIVE: + if ((oct_nr + 8) > (USHORT)sm->smpdu.c_tpdu_data) + { + /* not the required length for TP-SUBMIT with VP-RELATIVE */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + /* sm_cont points now to TP-UDL */ + sm_cont++; + + /* oct_nr is length of TP-UD */ + oct_nr = (USHORT)sm->smpdu.c_tpdu_data - oct_nr - 8; + break; + + case TP_VPF_ABSOLUTE: + case TP_VPF_ENHANCED: /* treat as VP-ABSOLUTE */ + if ((oct_nr + 14) > (USHORT)sm->smpdu.c_tpdu_data) + { + /* not the required length for TP-SUBMIT with VP-ABSOLUTE */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* sm_cont points now to TP-UDL */ + sm_cont += 7; + + /* oct_nr is length of TP-UD */ + oct_nr = (USHORT)sm->smpdu.c_tpdu_data - oct_nr - 14; + break; + } + + + header_len = sm->smpdu.c_tpdu_data - oct_nr; + p_udl = &pdu.data[sca_addr_len + header_len - 1]; + + + switch (cmhSMS_getAlphabetPp (dcs)) + { + default: /* 7 bit default aphabet */ + if (*sm_cont > 160) + { + /* SM length inconsistent */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } +#ifdef _PACK_DEF_ALPHA + /* packing required */ + if (satShrdPrm.cmdDet.cmdQlf EQ QLF_SMS_PACK AND + (USHORT)*sm_cont EQ oct_nr) /* check if packing is valid at all + (so *sm_cont must be equal of remaining bytes) + otherwise do not repack the data since it seems that + data has already been packed. + This is CQ18268/MOBil57469 */ + { + /* length in septets, sm_cont points now to TP-UD */ + udl = *sm_cont++; + + /* oct_udl is the length of packed data in octets */ + oct_udl = utl_cvt8To7 (sm_cont, udl, packed_data, 0); + + /* copy the header into the pdu */ + memcpy(&pdu.data[sca_addr_len], sm->smpdu.tpdu_data, + header_len); + + /* copy the packed user data into the pdu */ + memcpy (&pdu.data[sca_addr_len+header_len], packed_data, oct_udl); + + pdu.len = sca_addr_len+header_len+oct_udl; + + retVal = sAT_PlusCMGSPdu (OWN_SAT, &pdu); + switch (retVal) + { + case AT_CMPL: + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + return TRUE; + + case AT_BUSY: + mn = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + + case AT_FAIL: + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + return TRUE; + } /* if (satShrdPrm.cmdDet.cmdQlf EQ QLF_SMS_PACK) */ + else +#endif /* _PACK_DEF_ALPHA: ignore PACKING REQUIRED for GSM default + alphabet, when not set */ + { + /* packing not required */ + udl = *sm_cont; + oct_udl = ((*sm_cont + 1)*7)/8; + } + break; + + + case 1: /* 8 bit data */ + if (satShrdPrm.cmdDet.cmdQlf EQ QLF_SMS_PACK + AND ((dcs & 0xE0) NEQ 0x20)) + { /* packing only, when text is uncompressed */ + if ((USHORT)*sm_cont > oct_nr OR *sm_cont > 160) + { + /* SM length inconsistent */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + if ((dcs & 0xC0) EQ 0) + dcs &= 0xF3; /* adjust coding group 00xx */ + else if ((dcs & 0xF0) EQ 0xF0) + dcs &= 0xFB; /* adjust coding group 1111 */ + + /* length in septets, sm_cont points now to TP-UD */ + udl = *sm_cont++; + + /* oct_udl is the length of packed data in octets */ + oct_udl = utl_cvt8To7 (sm_cont, udl, packed_data, 0); + + /* copy the header into the pdu */ + memcpy(&pdu.data[sca_addr_len], sm->smpdu.tpdu_data, + header_len); + + /* copy the dcs into the pdu */ + *p_dcs = dcs; + + /* copy the packed user data into the pdu */ + memcpy (&pdu.data[sca_addr_len+header_len], packed_data, oct_udl); + + pdu.len = sca_addr_len+header_len+oct_udl; + + retVal = sAT_PlusCMGSPdu (OWN_SAT, &pdu); + switch (retVal) + { + case AT_CMPL: + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + return TRUE; + + case AT_BUSY: + mn = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + + case AT_FAIL: + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + return TRUE; + } + /* sandip CQ - 18269 + * To take care of a case where Command qualifier == 0x00( packing not required ) + * DCS == 0x04( 8 -bit packing ) + * TPDU length >140 + */ + + /* + else if((satShrdPrm.cmdDet.cmdQlf EQ QLF_SMS_NO_PACK) && (oct_nr > 140)) + { + psaSAT_SendTrmResp(RSLT_UNKN_DATA,&resp_data); + return(FALSE); + }*/ + else + { + if(oct_nr > 140) + { + psaSAT_SendTrmResp(RSLT_UNKN_DATA,&resp_data); + return(FALSE); + } + /* packing not required */ + udl = *sm_cont; + oct_udl = *sm_cont; + } + break; + + case 2: /* UCS2 */ + /* + * Special consideration: are octets (incorrect) or UCS2 + * characters (correct) counted by SAT? + */ + if ((USHORT)*sm_cont EQ oct_nr) + oct_udl = *sm_cont++; /* assume octet count */ + else + oct_udl= *sm_cont++ * 2; /* assume character count */ + udl = oct_udl; + break; + } /* switch (cmhSMS_getAlphabetPp (dcs)) */ + + + if ((USHORT)oct_udl > oct_nr OR oct_udl > MAX_SM_LEN) + { + /* SM length inconsistent */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* copy the tpdu data into the pdu */ + memcpy(&pdu.data[sca_addr_len], sm->smpdu.tpdu_data, sm->smpdu.c_tpdu_data); + + /* copy the udl into the pdu */ + *p_udl = udl; + + pdu.len = sca_addr_len + sm->smpdu.c_tpdu_data; + + retVal = sAT_PlusCMGSPdu (OWN_SAT, &pdu); + switch (retVal) + { + case AT_CMPL: + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + return TRUE; + + case AT_BUSY: + mn = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + + case AT_FAIL: + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } /* end switch (retVal) */ + return TRUE; + + + case TP_MTI_SMS_COMMAND: + if (sm->smpdu.c_tpdu_data < 8) + { + /* not the minimum length for TP-COMMAND */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + if (sm->smpdu.tpdu_data[5] >= MAX_SMS_NUM_LEN) + { + /* destination number too long */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + oct_nr = (USHORT)((sm->smpdu.tpdu_data[5] + 1) / 2); + if ((oct_nr + 8) > (USHORT)sm->smpdu.c_tpdu_data) + { + /* number length inconsistent with overall length for TP-SUBMIT */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* + ** If the MMI is a Cust1 Application + */ + if (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1) + { + /* + ** Having performed some checks, + ** don't send the primitve, but pass the entire command to the MMI for processing. + ** NOTE: An SMS Command is not passed to the SIM for MO SMS Control By SIM + ** + ** Ensure that the SMS parameters are reset, so that the SMS Entity is freed to + ** process the command later. + */ + smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; + smsShrdPrm.smsEntStat.entOwn = smsShrdPrm.owner = CMD_SRC_NONE; + + cmhSAT_Cust1StkCmdInd(); + return TRUE; + } + + memcpy(&pdu.data[sca_addr_len], sm->smpdu.tpdu_data, sm->smpdu.c_tpdu_data); + retVal = sAT_PlusCMGCPdu (OWN_SAT, &pdu); + switch (retVal) + { + case AT_CMPL: + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + return TRUE; + + case AT_BUSY: + mn = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + + case AT_FAIL: + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + return TRUE; + + default: + /* invalid message type */ + psaSAT_SendTrmResp( RSLT_UNKN_DATA, &resp_data ); + return( FALSE ); + } /* end switch (fo & TP_MTI_MASK) */ + } + else /* if (sm->smpdu.c_tpdu_data > 0) */ + { + /* respond with "error, required values are missing" */ + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : CMH | +| ROUTINE : cmhSAT_CheckSetEventResp| ++-------------------------------------------------------------------+ + + PURPOSE : check for an answer to a setup event list. function + returns TRUE if caller has to forward the checked + SAT response +*/ + +GLOBAL BOOL cmhSAT_CheckSetEventResp ( void ) +{ + BOOL list_in_process; + const UBYTE TermRespSetEventOk [12] = + { + 0x81, /* command details tag */ + 0x03, /* command details length */ + 0x13, /* command number */ + 0x05, /* command SETUP EVENT LIST */ + 0x00, /* not used */ + 0x82, /* device details tag */ + 0x02, /* device details length */ + 0x82, /* source ME */ + 0x81, /* destination SIM */ + 0x83, /* result tag */ + 0x01, /* result length */ + 0x00 /* result OK */ + }; + const UBYTE TermRespSetEvent [4] = + { + 0x81, /* command details tag */ + 0x03, /* command details length */ + 0x13, /* command number */ + 0x05, /* command SETUP EVENT LIST */ + }; + UBYTE *p; + + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_CheckSetEventResp"); + + psaSAT_InitTrmResp( &resp_data ); + + list_in_process = ( satShrdPrm.event.temp_list & 0x8000 ) > 0L; + + if ( list_in_process ) + { + + p = (satShrdPrm.setPrm[satShrdPrm.owner].stkCmd); + + if ((!memcmp((const UBYTE*) p, TermRespSetEvent,2)) AND (p[3] EQ TermRespSetEvent[3])) /* TRUE means: answer to a SETUP EVENT Command */ + { + if (!memcmp((const UBYTE*) p+3, TermRespSetEventOk+3, 9)) /* TRUE means: answer ok */ + { + cmhSAT_setupEvent_Perform(); /* accept list */ + TRACE_EVENT("New Download Event List accepted "); + return TRUE; /* caller has to send/forward TR */ + } + else + { + /* MMI couldn't perform the list: ACI doesn't perform it and returns + Beyond Mobile Capabilities */ + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + TRACE_EVENT("New Download Event List refused by MMI"); + satShrdPrm.event.temp_list = 0L; /* reinitialize for next setup list */ + return FALSE; /* caller hasn't to send TR, already sent! */ + } + } + else + { + return TRUE; /* caller has to send/forward TR */ + } + } + return TRUE; /* caller has to send/forward TR */ +} + +/* SAT CLASS E FUNCTIONS START */ +#ifdef FF_SAT_E + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_CloseChannel | ++-------------------------------------------------------------------+ + + PURPOSE : This function handles the request by SAT to close a + desired channel. If the request is going to be processed, + the function returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_CloseChannel ( void ) +{ + T_SIM_SAT_CHN chnInf; + + TRACE_FUNCTION("cmhSAT_CloseChannel()"); + +/* + *------------------------------------------------------------------- + * notify about SAT command + *------------------------------------------------------------------- + */ + cmhSAT_STKUsrNtfy(); + +/* + *------------------------------------------------------------------- + * check channel status + *------------------------------------------------------------------- + */ + if( satShrdPrm.chnTb.chnUsdFlg ) + { + chnInf.bipConn = SIM_BIP_UNKNOWN; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN ) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + + } + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_CNCT ) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.dtiConn = SIM_DTI_DISCONNECT; + } + + satShrdPrm.opchStat = OPCH_CLS_REQ; + + if( chnInf.bipConn ) + { +#ifdef DTI + + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_PERF_SUCCESS; + chnInf.addRes = ADD_NO_CAUSE; + + psaSIM_SATBIPChn( chnInf, NULL /*cmhSAT_OpChnClose*/); +#endif /* DTI */ + } + else + { + cmhSAT_OpChnClose( SIM_BIP_CLOSE_CHANNEL, 1 ); + } + } + + return TRUE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_SendData | ++-------------------------------------------------------------------+ + + PURPOSE : This function handles the request by SAT to open a + desired channel immediately. If the request is going to + be processed, the function returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_SendData ( void ) +{ + TRACE_FUNCTION("cmhSAT_SendData()"); + +/* + *------------------------------------------------------------------- + * notify about SAT command + *------------------------------------------------------------------- + */ + cmhSAT_STKUsrNtfy(); + +/* + *------------------------------------------------------------------- + * check if on demand channel activation has to be performed + *------------------------------------------------------------------- + */ + if( satShrdPrm.opchStat EQ OPCH_ON_DMND AND + satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN AND + satShrdPrm.cmdDet.cmdQlf & QLF_OPCH_IMMDT_LINK_EST ) + { + satShrdPrm.opchStat = OPCH_EST_REQ; + + /* + *------------------------------------------------------------------- + * for a CSD channel + *------------------------------------------------------------------- + */ + if( satShrdPrm.opchType EQ B_CSD ) + { + if (!psaCC_ctbIsValid (satShrdPrm.chnTb.chnRefId)) + { + TRACE_ERROR ("Call table entry disappeared"); + satShrdPrm.chnTb.chnUsdFlg = FALSE; + + return ( FALSE ); + } + + /* check temporary problems */ + if( cmhSAT_OpChnChkTmpProblem() ) + { + /* remove call table entry */ + psaCC_FreeCtbNtry (satShrdPrm.chnTb.chnRefId); + satShrdPrm.chnTb.chnUsdFlg = FALSE; + + return( FALSE ); + } +#ifdef DTI +#ifdef CO_UDP_IP + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + /* enable establishment of UDP data chain */ + sAT_PercentWAP ( psaCC_ctb(satShrdPrm.chnTb.chnRefId)->curSrc , 1 ); + + /* setup PPP parameters */ + cmhSAT_OpChnSetPPP( satShrdPrm.opchType ); + } +#endif /* CO_UDP_IP */ +#endif /* DTI */ + + /* set up call */ + cmhPrm[satShrdPrm.opchAcptSrc].ccCmdPrm.mltyCncFlg = 0; + + cmhCC_flagCall( satShrdPrm.chnTb.chnRefId, &cmhPrm[satShrdPrm.opchAcptSrc]. + ccCmdPrm.mltyCncFlg); + /* ccShrdPrm.ctb[satShrdPrm.chnTb.chnRefId].curCmd = AT_CMD_A; */ + /* ccShrdPrm.ctb[satShrdPrm.chnTb.chnRefId].curSrc = satShrdPrm.opchAcptSrc; */ + /* psaCC_NewCall ( satShrdPrm.chnTb.chnRefId ); */ + cmhCC_NewCall( satShrdPrm.chnTb.chnRefId, + satShrdPrm.opchAcptSrc, + AT_CMD_A); + return( TRUE ); + } + /* + *------------------------------------------------------------------- + * for a GPRS channel + *------------------------------------------------------------------- + */ +#if defined (GPRS) AND defined (DTI) + else if( satShrdPrm.opchType EQ B_GPRS ) + { + SHORT cid_array[2] = { 0,INVALID_CID }; + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + /* check temporary problems */ + if( cmhSAT_OpChnChkTmpProblem() ) + { + /* any reset of cid parameters should be placed here, + * if necessary + */ + return( FALSE ); + } + +#ifdef DTI +#ifdef CO_UDP_IP + /* activate the context with UDP */ + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + /* enable establishment of UDP data chain */ + sAT_PercentWAP ( satShrdPrm.opchAcptSrc , 1 ); + + /* setup PPP parameters */ + cmhSAT_OpChnSetPPP( B_GPRS ); + + /* activate context with UDP */ + cmhSAT_OpChnUDPActivateGprs(); + } + else +#endif /* CO_UDP_IP */ +#endif /* DTI */ + + /* activate context with no transport layer */ + if( sAT_PlusCGACT( satShrdPrm.opchAcptSrc, CGACT_STATE_ACTIVATED, cid_array ) + NEQ AT_EXCT ) + + return( FALSE ); + + satShrdPrm.opchStat = OPCH_EST_REQ; + + return( TRUE ); + } +#endif /* GPRS */ + /* + *------------------------------------------------------------------- + * invalid channel + *------------------------------------------------------------------- + */ + else + { + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_ERROR("invalid channel found, on demand est. failed"); + + psaSAT_InitTrmResp( &resp_data ); + resp_data.add_content = ADD_NO_CAUSE; + + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + cmhSAT_cleanupOpChnPrms(); + + } + } + + return FALSE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_GetChannelStatus | ++-------------------------------------------------------------------+ + + PURPOSE : This function handles the request by SAT to return the + current status of all channels. If the request is going + to be processed, the function returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_GetChannelStatus ( void ) +{ + T_ACI_SAT_TERM_RESP resp_data; + + psaSAT_InitTrmResp( &resp_data ); + + + TRACE_FUNCTION("cmhSAT_GetChannelStatus()"); + +/* + *------------------------------------------------------------------- + * notify about SAT command + *------------------------------------------------------------------- + */ + cmhSAT_STKUsrNtfy(); + +/* + *------------------------------------------------------------------- + * return channel status + *------------------------------------------------------------------- + */ + resp_data.chnStat = TRUE; + + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + + return FALSE; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpenChannelReq | ++-------------------------------------------------------------------+ + + PURPOSE : This function handles the request by SAT to open a channel. + If the request is going to be processed, the function + returns TRUE. + +*/ + +GLOBAL BOOL cmhSAT_OpenChannelReq ( T_OPEN_CHANNEL *opchCmd ) +{ +#ifdef FAX_AND_DATA + T_ACI_RETURN retVal; /* holds return value */ +#endif /* FAX_AND_DATA */ + SHORT cId; /* holds call id / context id */ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + + psaSAT_InitTrmResp( &resp_data ); + + + TRACE_FUNCTION("cmhSAT_OpenChannelReq()"); + +/* + *------------------------------------------------------------------- + * check for basic reasons to reject the command + *------------------------------------------------------------------- + */ + resp_data.chnStat = TRUE; + + /* ME is busy with another open channel command */ + if( satShrdPrm.opchStat NEQ OPCH_IDLE ) + { + TRACE_EVENT("SAT OPCH FAIL, busy with other command"); + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); + } + + /* is there a IPv6 address given ?*/ + if((opchCmd->v_other_addr AND opchCmd->other_addr.v_ipv6_addr) OR + (opchCmd->v_data_dest_addr AND opchCmd->data_dest_addr.v_ipv6_addr)) + { + TRACE_EVENT("SAT OPCH FAIL, IPv6 not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); + } + + /* is TCP requested */ + if( opchCmd->v_if_transp_lev AND + opchCmd->if_transp_lev.trans_prot_type EQ TCP ) + { + TRACE_EVENT("SAT OPCH FAIL, TCP not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); + } + + /* check UDP restrictions, WAP is a synonym for UDP */ + if( opchCmd->v_if_transp_lev AND + opchCmd->if_transp_lev.trans_prot_type EQ UDP ) + { +#if !defined (CO_UDP_IP) + /* is UDP requested, but WAP not set ?*/ + TRACE_EVENT("SAT OPCH FAIL, UDP not supported"); + resp_data.add_content = ADD_BIP_SIME_ITL_NAVAIL; + psaSAT_SendTrmResp( RSLT_BEARIND_PERR, &resp_data ); + return( FALSE ); +#endif /* WAP */ + + /* no destination address given */ + if( !opchCmd->v_data_dest_addr ) + { + TRACE_EVENT("SAT OPCH FAIL, no destination address given"); + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + } + + /* requested buffer size not available */ + if( opchCmd->v_buffer_size AND + opchCmd->buffer_size > SIM_CLASS_E_BUFFER_SIZE ) + { + TRACE_EVENT("SAT OPCH FAIL, buffer size not available"); + resp_data.add_content = ADD_BIP_BUF_SIZ_NAVAIL; + psaSAT_SendTrmResp( RSLT_BEARIND_PERR, &resp_data ); + return( FALSE ); + } + + /**** is CSD channel requested, but not supported ? ****/ +#ifndef FAX_AND_DATA + if( opchCmd->v_addr ) + { + /* CSD call not supported by ME */ + TRACE_EVENT("SAT OPCH FAIL, CSD not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); + } +#endif /* FAX_AND_DATA */ + + /**** is GPRS channel requested, but not supported ? ****/ +#ifndef GPRS + if( !opchCmd->v_addr AND opchCmd->v_bear_desc ) + { + /* GPRS call not supported by ME */ + TRACE_EVENT("SAT OPCH FAIL, GPRS not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); + } +#endif /* GPRS */ + + +/* + *------------------------------------------------------------------- + * store channel parameters + *------------------------------------------------------------------- + */ + + /* + *------------------------------------------------------------------- + * for a CSD channel use the call table + *------------------------------------------------------------------- + */ +#ifdef FAX_AND_DATA + + if( opchCmd->v_addr ) + { + T_CC_CALL_TBL *ctb; + + /* get call table entry */ + cId = psaCC_ctbNewEntry(); + + if( cId EQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, call table full"); + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); /* primitive not needed anymore */ + } + + ctb = ccShrdPrm.ctb[cId]; + + /* build setup parameters */ + cmhSAT_fillSetupPrm ( cId, + &opchCmd->addr, + ((opchCmd->v_subaddr)?&opchCmd->subaddr:NULL)); + + /* check aoc condition */ + if ((ctb->prio EQ PRIO_NORM_CALL) AND + (aoc_check_moc() EQ FALSE)) + /* + * check ACM exceeds ACMmax + * for non-emergency calls + */ + { + TRACE_EVENT("SAT OPCH FAIL, ACM exceeds"); + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + /* bearer capabilities */ + ctb->rptInd = RI_NOT_PRES; + + if( opchCmd->bear_desc.v_csd_bear_prm ) + { + UBYTE selVal; + + /* check and set speed parameter */ + selVal = cmhCC_SelRate(opchCmd->bear_desc.csd_bear_prm.csd_speed); + + if( selVal EQ UR_NOT_PRES ) + { + TRACE_EVENT("SAT OPCH FAIL, user rate not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + ctb->BC[0].rate = selVal; + + /* check and set name parameter */ + selVal = cmhCC_SelServ(opchCmd->bear_desc.csd_bear_prm.csd_name); + + if( selVal EQ BEARER_SERV_NOT_PRES ) + { + TRACE_EVENT("SAT OPCH FAIL, user service not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + ctb->BC[0].bearer_serv = selVal; + + /* check and set ce parameter */ + selVal = cmhCC_SelCE(opchCmd->bear_desc.csd_bear_prm.csd_ce); + + if( selVal EQ CONN_ELEM_NOT_PRES ) + { + TRACE_EVENT("SAT OPCH FAIL, ce not supported"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + ctb->BC[0].conn_elem = selVal; + + ctb->BC[0].modem_type = cmhCC_SelMT(opchCmd->bear_desc. + csd_bear_prm.csd_speed); + } + + else if ( opchCmd->bear_desc.bear_type EQ BT_DEFAULT ) + { + /* default settings for CSD channel */ + ctb->BC[0].rate = UR_9_6_KBIT; + ctb->BC[0].bearer_serv = BEARER_SERV_ASYNC; + ctb->BC[0].conn_elem = CONN_ELEM_NON_TRANS; + ctb->BC[0].modem_type = MT_V32; + + /* store default settings in opchCmd, will be used for term response later on */ + opchCmd->bear_desc.csd_bear_prm.csd_speed = BS_SPEED_9600_V32; + opchCmd->bear_desc.csd_bear_prm.csd_name = CBST_NAM_Asynch; + opchCmd->bear_desc.csd_bear_prm.csd_ce = CBST_CE_NonTransparent; + } + + else /* invalid bearer setting for CSD */ + { + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + } + + ctb->BC[0].stop_bits = STOP_1_BIT; + ctb->BC[0].data_bits = DATA_8_BIT; + ctb->BC[0].parity = PARITY_NONE; + + ctb->BC[1].rate = UR_NOT_PRES; + ctb->BC[1].bearer_serv = BEARER_SERV_NOT_PRES; + ctb->BC[1].conn_elem = CONN_ELEM_NOT_PRES; + + /* declare the owner and status of the call */ + ctb->calOwn = OWN_SAT; + ctb->calStat = CS_SAT_CSD_REQ; + ctb->curCmd = AT_CMD_D; + ctb->SATinv = TRUE; + + /* fill in channel table */ + satShrdPrm.chnTb.chnUsdFlg = TRUE; + satShrdPrm.chnTb.chnRefId = cId; + satShrdPrm.chnTb.chnType = B_CSD; + satShrdPrm.chnTb.lnkStat = SIM_NO_LINK; + + /* store bearer parameters for later use */ + cmhSAT_storeCSDPrms (opchCmd); + + /* check for call control by SIM */ + retVal = cmhSAT_CalCntrlBySIM( cId ); + + switch( retVal ) + { + case( AT_BUSY ): + /* respond with "Interaction with call control by SIM, temporary" */ + TRACE_EVENT("SAT OPCH FAIL, CC by SIM busy"); + psaSAT_SendTrmResp( RSLT_CC_SIM_TMP, &resp_data ); + cmhSAT_cleanupOpChnPrms(); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + + case( AT_FAIL ): + /* respond with "Interaction with call control by SIM, permanent" */ + TRACE_EVENT("SAT OPCH FAIL, CC by SIM failure"); + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_CC_SIM_PRM, &resp_data ); + cmhSAT_cleanupOpChnPrms(); + psaCC_FreeCtbNtry (cId); + return( FALSE ); + + case( AT_EXCT ): + /* wait for SIM result */ + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + satShrdPrm.opchStat = OPCH_CCSIM_REQ; + break; + } + + + /* if call control check is performed, return here */ + if( satShrdPrm.opchStat EQ OPCH_CCSIM_REQ ) return( TRUE ); + } + else +#endif /* FAX_AND_DATA */ + + /* + *------------------------------------------------------------------- + * for a GPRS channel use a context id in GACI + *------------------------------------------------------------------- + */ +#if defined (GPRS) AND defined (DTI) + + if( opchCmd->v_bear_desc ) + { + T_GPRS_CONT_REC cntxt; + + /* get context id */ + cId = psaSAT_gprsFindFreeCntxt(); + + if( cId EQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, no free context"); + resp_data.add_content = ADD_NO_CAUSE; + psaSAT_SendTrmResp( RSLT_ME_UNAB_PROC, &resp_data ); + return( FALSE ); /* primitive not needed anymore */ + } + + /* bearer capabilities */ + if( opchCmd->bear_desc.v_gprs_bear_prm ) + { + /* only PDP type IP is supported */ + if( opchCmd->bear_desc.gprs_bear_prm.gprs_pdp_type NEQ PDP_TYPE_IP ) + { + TRACE_EVENT("SAT OPCH FAIL, PDP type diff from IP"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); + } + + cntxt.qos.preced = opchCmd->bear_desc.gprs_bear_prm.gprs_prec; + cntxt.qos.delay = opchCmd->bear_desc.gprs_bear_prm.gprs_delay; + cntxt.qos.relclass = opchCmd->bear_desc.gprs_bear_prm.gprs_rely; + cntxt.qos.peak = opchCmd->bear_desc.gprs_bear_prm.gprs_peak; + cntxt.qos.mean = opchCmd->bear_desc.gprs_bear_prm.gprs_mean; + } + + else if ( opchCmd->bear_desc.bear_type EQ BT_DEFAULT ) + { + /* default settings for GPRS channel = as subscribed */ + cntxt.qos.preced = 0; + cntxt.qos.delay = 0; + cntxt.qos.relclass = 0; + cntxt.qos.peak = 0; + cntxt.qos.mean = 0; + + /* store default settings in opchCmd, will be used for term response later on */ + opchCmd->bear_desc.gprs_bear_prm.gprs_prec = 0; + opchCmd->bear_desc.gprs_bear_prm.gprs_delay = 0; + opchCmd->bear_desc.gprs_bear_prm.gprs_rely = 0; + opchCmd->bear_desc.gprs_bear_prm.gprs_peak = 0; + opchCmd->bear_desc.gprs_bear_prm.gprs_mean = 0; + opchCmd->bear_desc.gprs_bear_prm.gprs_pdp_type = PDP_TYPE_IP; + } + else /* invalid bearer setting for GPRS */ + { + TRACE_EVENT("SAT OPCH FAIL, invalid GPRS bearer settings"); + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + /* if an APN is given */ + if( opchCmd->v_nan_buf AND opchCmd->nan_buf.c_n_acc_name ) + { + cmhSAT_cnvrtAPN2NetworkAdr((UBYTE *)opchCmd->nan_buf.n_acc_name, + (UBYTE) opchCmd->nan_buf.c_n_acc_name, + (UBYTE *)cntxt.apn ); + } + else /* use default */ + { + cntxt.apn[0] = 0; + } + + /* if a local address is given */ + if( opchCmd->v_other_addr AND opchCmd->other_addr.v_ipv4_addr ) + { + cmhSM_ip_to_pdp_address( opchCmd->other_addr.ipv4_addr, + cntxt.pdp_addr ); + } + else /* use default, dynamic address */ + { + cntxt.pdp_addr[0] = 0; + } + + cntxt.d_comp = CGDCONT_D_COMP_OMITTED; + cntxt.h_comp = CGDCONT_H_COMP_OMITTED; + strncpy( cntxt.pdp_type, "IP", sizeof( T_PDP_TYPE )); + + + if( sAT_PlusCGDCONT ( CMD_SRC_NONE, cId, &cntxt) NEQ AT_CMPL ) + { + TRACE_EVENT("SAT OPCH FAIL, invalid CGDCONT parms"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); /* primitive not needed anymore */ + } + + if( sAT_PlusCGQREQ( CMD_SRC_NONE, cId, &cntxt.qos) NEQ AT_CMPL ) + { + TRACE_EVENT("SAT OPCH FAIL, invalid CGQREQ parms"); + psaSAT_SendTrmResp( RSLT_ME_CAP, &resp_data ); + return( FALSE ); /* primitive not needed anymore */ + } + + /* fill in channel table */ + satShrdPrm.chnTb.chnUsdFlg = TRUE; + satShrdPrm.chnTb.chnRefId = cId; + satShrdPrm.chnTb.chnType = B_GPRS; + satShrdPrm.chnTb.lnkStat = SIM_NO_LINK; + + /* store bearer parameters for later use */ + cmhSAT_storeGPRSPrms (opchCmd); + } + else + +#endif /* GPRS */ + + /* + *------------------------------------------------------------------- + * undefined channel + *------------------------------------------------------------------- + */ + { + /* respond with "error, required values are missing" */ + TRACE_EVENT("SAT OPCH FAIL, requires values missing"); + psaSAT_SendTrmResp( RSLT_ERR_REQ_VAL, &resp_data ); + return( FALSE ); + } + + +/* + *------------------------------------------------------------------- + * request for user confirmation + *------------------------------------------------------------------- + */ + cmhSAT_OpChnAlert( cId ); + + return( TRUE ); + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_storeCSDPrms | ++-------------------------------------------------------------------+ + + PURPOSE : This function stores the CSD open channel parameters for + later use. + +*/ + +GLOBAL void cmhSAT_storeCSDPrms ( T_OPEN_CHANNEL * opchCmd ) +{ + T_SAT_CSD_PRM *p; + + TRACE_FUNCTION("cmhSAT_storeCSDPrms()"); + + ACI_MALLOC(satShrdPrm.opchPrm, sizeof(T_SAT_CSD_PRM)); + TRACE_EVENT("ALLOC opchPrm"); + memset(satShrdPrm.opchPrm, 0, sizeof(T_SAT_CSD_PRM)); + + p = (T_SAT_CSD_PRM*)satShrdPrm.opchPrm; + + if(opchCmd->bear_desc.bear_type EQ BT_DEFAULT) + p->def_bear_prm = TRUE; + + p->csd_bear_prm = opchCmd->bear_desc.csd_bear_prm; + + if(opchCmd->v_dur) + { + p->v_dur = TRUE; + p->dur = opchCmd->dur; + } + + if(opchCmd->v_dur2) + { + p->v_dur2 = TRUE; + p->dur2 = opchCmd->dur2; + } + + if(opchCmd->v_other_addr) + { + p->v_other_addr = TRUE; + p->other_addr = opchCmd->other_addr; + } + + if(opchCmd->v_text) + { + p->v_log = TRUE; + p->log = opchCmd->text; + } + + if(opchCmd->v_text2) + { + p->v_pwd = TRUE; + p->pwd = opchCmd->text2; + } + + if(opchCmd->v_if_transp_lev) + { + p->v_itl = TRUE; + p->itl = opchCmd->if_transp_lev; + } + + if(opchCmd->v_data_dest_addr) + { + p->v_dda = TRUE; + p->dda = opchCmd->data_dest_addr; + } + + satShrdPrm.opchType = B_CSD; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_storeGPRSPrms | ++-------------------------------------------------------------------+ + + PURPOSE : This function stores the CSD open channel parameters for + later use. + +*/ + +GLOBAL void cmhSAT_storeGPRSPrms ( T_OPEN_CHANNEL * opchCmd ) +{ + T_SAT_GPRS_PRM *p; + + TRACE_FUNCTION("cmhSAT_storeGPRSPrms()"); + + ACI_MALLOC(satShrdPrm.opchPrm, sizeof(T_SAT_GPRS_PRM)); + TRACE_EVENT("ALLOC opchPrm"); + memset(satShrdPrm.opchPrm, 0, sizeof(T_SAT_GPRS_PRM)); + + p = (T_SAT_GPRS_PRM*)satShrdPrm.opchPrm; + + if(opchCmd->bear_desc.bear_type EQ BT_DEFAULT) + p->def_bear_prm = TRUE; + + p->gprs_bear_prm = opchCmd->bear_desc.gprs_bear_prm; + + if(opchCmd->v_nan_buf) + { + p->v_apn = TRUE; + p->c_apn = opchCmd->nan_buf.c_n_acc_name; + memcpy(p->apn, opchCmd->nan_buf.n_acc_name, opchCmd->nan_buf.c_n_acc_name); + } + + if(opchCmd->v_other_addr) + { + p->v_other_addr = TRUE; + p->other_addr = opchCmd->other_addr; + } + + if(opchCmd->v_if_transp_lev) + { + p->v_itl = TRUE; + p->itl = opchCmd->if_transp_lev; + } + + if(opchCmd->v_data_dest_addr) + { + p->v_dda = TRUE; + p->dda = opchCmd->data_dest_addr; + } + + satShrdPrm.opchType = B_GPRS; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_cleanupOpChnPrms | ++-------------------------------------------------------------------+ + + PURPOSE : This function cleans the Op channel parameters + +*/ + +GLOBAL void cmhSAT_cleanupOpChnPrms ( void ) +{ + TRACE_FUNCTION("cmhSAT_cleanupOpChnPrms()"); + + if( satShrdPrm.opchPrm ) + { + ACI_MFREE(satShrdPrm.opchPrm); + satShrdPrm.opchPrm = NULL; + TRACE_EVENT("FREE opchPrm"); + } + + satShrdPrm.opchPrmMdf = FALSE; + satShrdPrm.opchCCMdfy = FALSE; + satShrdPrm.opchStat = OPCH_IDLE; + satShrdPrm.opchType = 0; + satShrdPrm.gprsNtwCs = 0; + +} + +/* ++--------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnResetCnctFalg| ++--------------------------------------------------------------------+ + + PURPOSE : This function cleans the Op channel parameters + +*/ + +GLOBAL void cmhSAT_OpChnResetCnctFlag ( void ) +{ + TRACE_FUNCTION("cmhSAT_cleanupOpChnWAP()"); +#ifdef CO_UDP_IP + /* If transport layer is UDP, reset wap_call flag */ + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + sAT_PercentWAP ( CMD_SRC_NONE, 0 ); + } +#endif /* CO_UDP_IP */ +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnFailed | ++-------------------------------------------------------------------+ + + PURPOSE : Indication that an open channel command has failed due to + a reason indicated by cause and add_cause. If the failure + occured in context with the OPEN CHANNEL command, a terminal + response will be sent and parameters will be cleaned up. + If the failure was in context with a SEND DATA command, the + SIM BIP channel will be closed and parameters will be cleared + up. If the failure was unexpected, a channel status event + message will be sent, if enabled. + +*/ + +GLOBAL void cmhSAT_OpChnFailed( UBYTE cause, T_ACI_SAT_TERM_RESP *resp_data ) +{ + T_SIM_SAT_CHN chnInf; + + TRACE_FUNCTION("cmhSAT_OpChnFailed()"); + + /* command context is OPEN CHANNEL */ + if((satShrdPrm.opchStat EQ OPCH_EST_REQ OR + satShrdPrm.opchStat EQ OPCH_CCSIM_REQ OR + satShrdPrm.opchStat EQ OPCH_WAIT_CNF) AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_OPEN_CHANNEL ) + { + resp_data->chnStat = TRUE; + psaSAT_SendTrmResp( cause, resp_data ); + + if(!(satShrdPrm.opchStat EQ OPCH_WAIT_CNF)) + { + R_AT( RAT_CME, satShrdPrm.opchAcptSrc ) ( AT_CMD_A, CME_ERR_NotPresent ); + + /* log result */ + cmh_logRslt ( satShrdPrm.opchAcptSrc, RAT_CME, AT_CMD_A, + -1, -1, CME_ERR_NotPresent ); + } + cmhSAT_cleanupOpChnPrms(); + } + + /* command context is SEND DATA */ + else if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_SEND_DATA ) + { + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN ) + { + /* check if user has cleared down the call */ + if( satShrdPrm.chnTb.chnType EQ B_CSD AND + (!psaCC_ctbIsValid (satShrdPrm.chnTb.chnRefId) OR + psaCC_ctb(satShrdPrm.chnTb.chnRefId)->curCmd EQ AT_CMD_H OR + psaCC_ctb(satShrdPrm.chnTb.chnRefId)->curCmd EQ AT_CMD_CHUP)) + { + cause = RSLT_USR_CLR_DWN; + } +#ifdef DTI + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = cause; + chnInf.addRes = resp_data->add_content; + + psaSIM_SATBIPChn( chnInf, cmhSAT_OpChnClose ); +#endif /* DTI */ + } + } + /* unsolicited problem */ + else if( satShrdPrm.opchStat EQ OPCH_IDLE ) + { + chnInf.bipConn = SIM_BIP_UNKNOWN; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN ) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + } + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_CNCT ) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.dtiConn = SIM_DTI_DISCONNECT; + } +#ifdef DTI + if( chnInf.bipConn ) + { + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_BEARIND_PERR; + chnInf.addRes = ADD_BIP_CHAN_CLOSD; + + psaSIM_SATBIPChn( chnInf, cmhSAT_OpChnClose ); + + cmhSAT_OpChnStatEvnt(); + } +#endif /* DTI */ + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnAlert | ++-------------------------------------------------------------------+ + + PURPOSE : This function alerts the user about a pending SAT open + channel command, which is ready for execution. + +*/ + +GLOBAL void cmhSAT_OpChnAlert( SHORT cId ) + +{ + UBYTE idx; + ULONG rdl = ACI_NumParmNotPresent; + T_ACI_SATA_ADD addPrm; + + if( satShrdPrm.opchType EQ B_CSD ) + { + rdl = cmhSAT_ChckRedial(cId, ((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->v_dur, + &(((T_SAT_CSD_PRM*)satShrdPrm.opchPrm)->dur)); + + addPrm.chnType = SATA_CT_CSD; + cId += 1; + } + else if ( satShrdPrm.opchType EQ B_GPRS ) + + addPrm.chnType = SATA_CT_GPRS; + + addPrm.chnEst = ( satShrdPrm.cmdDet.cmdQlf & QLF_OPCH_IMMDT_LINK_EST )? + SATA_EST_IM:SATA_EST_OD; + + for( idx = 0; idx < CMD_SRC_MAX; idx++ ) + { + R_AT( RAT_SATA, idx )( cId, rdl, &addPrm ); + } + + satShrdPrm.ntfy = USR_NTF_SETUP_CAL; + satShrdPrm.opchStat = OPCH_WAIT_CNF; +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnChkTmpProblem| ++-------------------------------------------------------------------+ + + PURPOSE : This function checks for a temporary situation, which + prevents the open channel command to be completed. If such + a condition exists, the open channel command will be aborted + with a suitable terminal response and the function returns + TRUE + +*/ + +GLOBAL BOOL cmhSAT_OpChnChkTmpProblem( void ) + +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + SHORT actId = NO_ENTRY; + BOOL cleanup = FALSE; + + psaSAT_InitTrmResp( &resp_data ); + + + TRACE_FUNCTION("cmhSAT_OpChnChkTmpProblem()"); + + /* + *------------------------------------------------------------------- + * check channel type independent conditions + *------------------------------------------------------------------- + */ +#ifdef CO_UDP_IP + /* check for a busy UDP situation, WAP is a synonym for UDP */ + if( satShrdPrm.chnTb.chnTPL EQ UDP AND + Wap_Call ) + { + TRACE_EVENT("SAT OPCH FAIL, UDP is busy"); + resp_data.add_content = ADD_NO_CAUSE; + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + cleanup = TRUE; + } + /* + *------------------------------------------------------------------- + * check CSD channel conditions + *------------------------------------------------------------------- + */ + else +#endif /* CO_UDP_IP */ + + if( satShrdPrm.opchType EQ B_CSD ) + { + /* check for busy SS condition */ + if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, SS busy"); + resp_data.add_content = ADD_ME_SS_BUSY; + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + cleanup = TRUE; + } + + /* check for busy call condition */ + else if( psaSAT_ctbFindActCall() NEQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, busy on call"); + resp_data.add_content = ADD_ME_CALL_BUSY; + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + cleanup = TRUE; + } +#if defined (GPRS) AND defined (DTI) + /* CSD channel, but class CG */ + else if( gmmShrdPrm.mobile_class EQ GMMREG_CLASS_CG ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, no channel avail"); + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + cmhSAT_OpChnFailed( RSLT_BEARIND_PERR, &resp_data ); + + cleanup = TRUE; + } +#endif /* GPRS */ + + } + + /* + *------------------------------------------------------------------- + * check GPRS channel conditions + *------------------------------------------------------------------- + */ +#if defined (GPRS) AND defined (DTI) + else if( satShrdPrm.opchType EQ B_GPRS ) + { + /* GPRS channel, class B */ + if( gmmShrdPrm.mobile_class EQ GMMREG_CLASS_BC OR + gmmShrdPrm.mobile_class EQ GMMREG_CLASS_BG ) + { + if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, SS busy"); + resp_data.add_content = ADD_ME_SS_BUSY; + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + cleanup = TRUE; + } + + /* check for busy call condition */ + else if( psaSAT_ctbFindActCall() NEQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, busy on call"); + resp_data.add_content = ADD_ME_CALL_BUSY; + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + cleanup = TRUE; + } + } + + /* GPRS channel, but class CC */ + else if( gmmShrdPrm.mobile_class EQ GMMREG_CLASS_CC ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, no channel avail"); + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + cmhSAT_OpChnFailed( RSLT_BEARIND_PERR, &resp_data ); + + cleanup = TRUE; + } + + /* no channel left for GPRS */ + else if( psaSAT_gprsFindFreeCntxt() EQ NO_ENTRY ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, no channel avail"); + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + cmhSAT_OpChnFailed( RSLT_BEARIND_PERR, &resp_data ); + + cleanup = TRUE; + } + + /* check SM entity status */ + else if( smEntStat.entOwn NEQ OWN_NONE OR + smEntStat.curCmd NEQ AT_CMD_NONE ) + { + /* send SAT response */ + TRACE_EVENT("SAT OPCH FAIL, SM entity busy"); + resp_data.add_content = ADD_NO_CAUSE; + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + cleanup = TRUE; + } + } +#endif /* GPRS */ + + /* + *------------------------------------------------------------------- + * cleanup if necessary + *------------------------------------------------------------------- + */ + if( cleanup ) + { + if( satShrdPrm.opchType EQ B_CSD ) + { + /* free ctb entry */ + psaCC_FreeCtbNtry (satShrdPrm.chnTb.chnRefId); + } + + cmhSAT_cleanupOpChnPrms(); + + return ( TRUE ); + } + + return( FALSE ); +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnUDPActiveCsd| ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the UDP stack + is active + +*/ + +GLOBAL void cmhSAT_OpChnUDPActiveCsd(T_ACI_RETURN result) +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + + TRACE_FUNCTION("cmhSAT_OpChnUDPActiveCsd()"); + + /* Ensure we never dereference NULL in the CC call table */ + if (!psaCC_ctbIsValid (tcpipShrdPrm.wap_call_id)) + { + TRACE_ERROR ("Call table entry disappeared"); + ccShrdPrm.datStat = DS_IDL ; + psaSAT_InitTrmResp( &resp_data ); + resp_data.add_content = ADD_NO_CAUSE; + + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + return; + } + + /* + * activate RA connection: in case of failure clear call ! + */ + ccShrdPrm.datStat = DS_ACT_REQ; + + if(cmhRA_Activate(psaCC_ctb(tcpipShrdPrm.wap_call_id)->curSrc, + psaCC_ctb(tcpipShrdPrm.wap_call_id)->curCmd, + tcpipShrdPrm.wap_call_id) + NEQ AT_EXCT) + { + TRACE_EVENT("RA ACTIVATION FAILURE -> DISC CALL"); + ccShrdPrm.datStat = DS_IDL ; + psaCC_ctb(tcpipShrdPrm.wap_call_id)->nrmCs = MNCC_CAUSE_CALL_CLEAR; + psaCC_ClearCall (tcpipShrdPrm.wap_call_id); + + + psaSAT_InitTrmResp( &resp_data ); + resp_data.add_content = ADD_NO_CAUSE; + + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + } +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnUDPConfCsd | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the UDP stack + is configured + +*/ +GLOBAL void cmhSAT_OpChnUDPConfCsd(T_ACI_RETURN result) +{ + + TRACE_FUNCTION("cmhSAT_OpChnUDPConfCsd()"); + /* + * send the SIM_BIP_CONFIG_REQ primitive providing details of the connection + * to SIM + */ + psaSIM_Bip_Config_Req(); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnUDPDeactCsd | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the UDP stack + is deactive + +*/ + +GLOBAL void cmhSAT_OpChnUDPDeactCsd(T_ACI_RETURN result) +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + + TRACE_FUNCTION("cmhSAT_OpChnUDPDeactCsd()"); + + psaSAT_InitTrmResp( &resp_data ); + + /* + *------------------------------------------------------------------- + * check if deactivation was intended + *------------------------------------------------------------------- + */ + if( satShrdPrm.opchStat EQ OPCH_CLS_REQ ) + { + /* nothing to do here anymore */ + } + + /* + *------------------------------------------------------------------- + * deactivation during an establish request + *------------------------------------------------------------------- + */ + else if( satShrdPrm.opchStat EQ OPCH_EST_REQ ) + { + if (cmhL2R_Deactivate() NEQ AT_EXCT) + { + TRACE_EVENT("L2R DEACTIVATION FAILURE "); + if (psaCC_ctbIsValid (tcpipShrdPrm.wap_call_id)) + { + psaCC_ctb(tcpipShrdPrm.wap_call_id)->nrmCs = MNCC_CAUSE_CALL_CLEAR; + psaCC_ClearCall(tcpipShrdPrm.wap_call_id); + } + } + + resp_data.add_content = ADD_NO_CAUSE; + + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + + } +} +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpBIPChnOpen | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the SIM entity + has tried to open a BIP channel + +*/ + +GLOBAL void cmhSAT_OpBIPChnOpen( UBYTE bipConn, UBYTE chnId ) +{ + T_CC_CMD_PRM * pCCCmdPrm; /* points to CC command parameters */ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + UBYTE srcId; /* holds source ID */ + UBYTE cause; + SHORT cId; /* holds caller ID for pending CSD call (case immediately) */ +#ifdef GPRS + SHORT cid_array[2] = { 0,INVALID_CID }; /* holds cids for GPRS context */ +#endif /* GPRS */ + + TRACE_FUNCTION("cmhSAT_OpBIPChnOpen()"); + + /* get source id */ + srcId = satShrdPrm.opchAcptSrc; + + psaSAT_InitTrmResp( &resp_data ); + + /* send TR in the case of on demand establishment */ + if( satShrdPrm.opchStat EQ OPCH_ON_DMND ) + { + /* CASE: ON DEMAND */ + + /* check if opening has been successful */ + if( bipConn & SIM_BIP_OPEN_CHANNEL ) + { + /* BEARER: GPRS OR CSD */ + + /* set link state to OPEN */ + satShrdPrm.chnTb.lnkStat = SIM_LINK_OPEN; + + resp_data.chnStat = TRUE; + resp_data.bearDesc = TRUE; + resp_data.bufSize = TRUE; + cause = (satShrdPrm.opchCCMdfy)?RSLT_PERF_MDFY_SIM:RSLT_PERF_SUCCESS; + + psaSAT_SendTrmResp( cause, &resp_data ); + + R_AT( RAT_OK, satShrdPrm.opchAcptSrc ) ( AT_CMD_A ); + + /* log result */ + cmh_logRslt ( satShrdPrm.opchAcptSrc, RAT_OK, AT_CMD_A, -1, -1, -1 ); + } + /* unsuccessful channel opening */ + else + { + /* BEARER: GPRS OR CSD */ + + TRACE_ERROR("cmhSAT_OpChnOpen: ERROR: OPEN BIP CHANNEL unsuccessful"); + + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + cause = RSLT_BEARIND_PERR; + + cmhSAT_cleanupOpChnPrms(); + + psaSAT_SendTrmResp( cause, &resp_data ); + + R_AT( RAT_CME, satShrdPrm.opchAcptSrc ) ( AT_CMD_A, CME_ERR_NotPresent ); + + /* log result */ + cmh_logRslt ( satShrdPrm.opchAcptSrc, RAT_CME, AT_CMD_A, + -1, -1, CME_ERR_NotPresent ); + } + + } + else if ( satShrdPrm.opchStat EQ OPCH_EST_REQ ) + { + /* CASE: IMMEDIATELY */ + /* Check whether OPEN BIP CHANNEL successful */ + if( bipConn & SIM_BIP_OPEN_CHANNEL ) + { + + /* set link state to OPEN, since the BIP and DTI establishment has split + * this state is alse used for "immediately" OPEN CHANNEL command */ + satShrdPrm.chnTb.lnkStat = SIM_LINK_OPEN; + + /* check for BEARER */ + if (satShrdPrm.opchType EQ B_CSD) + { + /* BEARER: CSD */ + /* proceed to set up bearer for CSD */ + + /* get SAT call cId */ + cId = psaCC_ctbFindCall( OWN_SAT, CS_SAT_CSD_REQ, NO_VLD_CT ); + + /* check if a call has been found */ + if ( cId NEQ (-1)) + { + pCCCmdPrm = &cmhPrm[srcId].ccCmdPrm; + + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + /* TRANSPORT LAYER: UDP */ + + /* enable establishment of UDP data chain */ + sAT_PercentWAP ( psaCC_ctb(cId)->curSrc , 1 ); + + /* setup PPP parameters */ + cmhSAT_OpChnSetPPP( B_CSD ); + } + /* finally set up call */ + cmhCC_flagCall( cId, &(pCCCmdPrm->mltyCncFlg)); + cmhCC_NewCall(cId, srcId, AT_CMD_A); + } + else + { + TRACE_FUNCTION("cmhSAT_OpChnOpen: No CSD call pending"); + } + } +#if defined (GPRS) AND defined (DTI) + else if (satShrdPrm.opchType EQ B_GPRS) + { + /* BEARER: GPRS */ + + /* copy channel reference ID */ + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + /* TRANSPORT LAYER: UDP */ + + /* enable establishment of UDP data chain */ + sAT_PercentWAP ( srcId , 1 ); + + /* setup PPP parameters */ + cmhSAT_OpChnSetPPP( B_GPRS ); + + /* activate context with UDP */ + cmhSAT_OpChnUDPActivateGprs(); + } + else + { + /* NO TRANSPORT LAYER: SNDCP only */ + + /* activate context with no transport layer */ + if( sAT_PlusCGACT( srcId, CGACT_STATE_ACTIVATED, cid_array ) NEQ AT_EXCT ) + { + /* activate context command could not proccessed */ + /* throw error */ + TRACE_ERROR("cmhSAT_OpChnOpen: ERROR: activate context with no TRL failed"); + R_AT( RAT_CME, satShrdPrm.opchAcptSrc ) ( AT_CMD_A, CME_ERR_NoConnect ); + } + } + } /* end bearer B_GPRS */ +#endif /* GPRS AND DTI */ + } + else /* OPEN BIP CHANNEL unsuccessful */ + { + /* CASE: ON DEMAND and IMMEDIATELY */ + /* BEARER: CSD and GPRS */ + + TRACE_ERROR("cmhSAT_OpChnOpen: ERROR: OPEN BIP CHANNEL unsuccessful"); + + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + cause = RSLT_BEARIND_PERR; + + /* store current status of BIP channel */ + simShrdPrm.sim_dti_chPrm->sat_chn_prm.bipConn = SIM_BIP_CLOSE_CHANNEL; + + cmhSAT_cleanupOpChnPrms(); + + psaSAT_SendTrmResp( cause, &resp_data ); + + R_AT( RAT_CME, satShrdPrm.opchAcptSrc ) ( AT_CMD_A, CME_ERR_NotPresent ); + + /* log result */ + cmh_logRslt ( satShrdPrm.opchAcptSrc, RAT_CME, AT_CMD_A, + -1, -1, CME_ERR_NotPresent ); + } + } /* end if ( satShrdPrm.opchStat EQ OPCH_EST_REQ ) */ +} + + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnCnct | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the SIM entity + has tried to connect a DTI channel + +*/ + +GLOBAL void cmhSAT_OpChnCnct( UBYTE dtiConn, UBYTE chnId ) +{ +#ifdef DTI + T_SIM_SAT_CHN chnInf; + + TRACE_FUNCTION("cmhSAT_OpChnCnct()"); + + /* connection was successful */ + if( dtiConn & SIM_DTI_CONNECT ) + { + satShrdPrm.chnTb.lnkStat = SIM_LINK_CNCT; + TRACE_EVENT("cmhSAT_OpChnCnct: SIM-DTI connection successful"); + } + else + { + /* unsuccessful connection */ + TRACE_EVENT("cmhSAT_OpChnCnct: ERROR: SIM-DTI connection unsuccessful!"); + + /* if the channel is still open */ + + /* SAT E patch: Since this information isn't available from incoming + * SIM_DTI_CNF look into the shrd parameters whether there has been a + * already BIP channel established within this channel connection */ + /* former checked: dtiConn & SIM_BIP_OPEN_CHANNEL*/ + if( (satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN) ) + { + /* check for SEND DATA/OPEN CHANNEL command context */ + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + (satShrdPrm.cmdDet.cmdType EQ SAT_CMD_OPEN_CHANNEL OR + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_SEND_DATA)) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_BEARIND_PERR; + chnInf.addRes = ADD_BIP_NO_CHAN_AVAIL; + + psaSIM_SATBIPChn( chnInf, cmhSAT_OpChnClose ); + } + + satShrdPrm.chnTb.lnkStat = SIM_LINK_OPEN; + } + /* if bearer is still in use */ + else if ( satShrdPrm.chnTb.chnUsdFlg ) + { + /* if a CSD is still in progress */ + if( satShrdPrm.chnTb.chnType EQ B_CSD ) + { + SHORT dummy; + + cmhCC_ClearCall( satShrdPrm.chnTb.chnRefId, + MNCC_CAUSE_CALL_CLEAR, + satShrdPrm.opchAcptSrc, + AT_CMD_NONE, + &dummy); + } + +#ifdef GPRS + /* if a GPRS context is still in progress */ + if( satShrdPrm.chnTb.chnType EQ B_GPRS ) + { + SHORT cid_array[2] = { 0,INVALID_CID }; + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + sAT_PlusCGACT( satShrdPrm.opchAcptSrc, + CGACT_STATE_DEACTIVATED, cid_array ); + } +#endif /* GPRS */ + } + } +#endif /* DTI */ +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnClose | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the SIM entity + has tried to close a channel + +*/ + +GLOBAL void cmhSAT_OpChnClose( UBYTE bipConn, UBYTE chnId ) +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + + TRACE_FUNCTION("cmhSAT_OpChnClose()"); + + + /* channel closed */ + if( bipConn & SIM_BIP_CLOSE_CHANNEL ) + { + satShrdPrm.chnTb.lnkStat = SIM_NO_LINK; + + psaSAT_InitTrmResp( &resp_data ); + + /* check for OPEN CHANNEL command context, immediate channel */ + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_OPEN_CHANNEL ) + { + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + resp_data.chnStat = TRUE; + + cmhSAT_OpChnFailed(RSLT_BEARIND_PERR, &resp_data); + cmhSAT_cleanupOpChnPrms(); + + } + + /* check for SEND DATA command context, on-demand channel */ + else if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_SEND_DATA ) + { + cmhSAT_cleanupOpChnPrms(); + } + + /* check for intented channel closing */ + else if( satShrdPrm.opchStat EQ OPCH_CLS_REQ AND + satShrdPrm.cmdDet.cmdType EQ SAT_CMD_CLOSE_CHANNEL) + { + resp_data.chnStat = TRUE; + psaSAT_SendTrmResp( RSLT_PERF_SUCCESS, &resp_data ); + if ( dti_cntrl_is_dti_channel_connected (DTI_ENTITY_UDP, simShrdPrm.sat_class_e_dti_id) +#ifdef GPRS + OR dti_cntrl_is_dti_channel_connected (DTI_ENTITY_SNDCP, simShrdPrm.sat_class_e_dti_id) +#endif /* GPRS */ + ) + { + cmhSAT_cleanupOpChnPrms(); + } + else /* L2R or TRA - dti channel has to be closed explicitly */ + { + /* close existing DTI channel first */ + dti_cntrl_close_dpath_from_dti_id(simShrdPrm.sat_class_e_dti_id); + cmhSAT_cleanupOpChnPrms(); + } + } + + + /* if bearer is still in use */ + if( satShrdPrm.chnTb.chnUsdFlg ) + { + /* if a CSD is still in progress */ + if( satShrdPrm.chnTb.chnType EQ B_CSD ) + { + SHORT dummy; + + cmhCC_ClearCall( satShrdPrm.chnTb.chnRefId, + MNCC_CAUSE_CALL_CLEAR, + satShrdPrm.opchAcptSrc, + AT_CMD_NONE, + &dummy); + } +#if defined (GPRS) AND defined (DTI) + /* if a GPRS context is still in progress */ + if( satShrdPrm.chnTb.chnType EQ B_GPRS ) + { + SHORT cid_array[2] = { 0,INVALID_CID }; + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + sAT_PlusCGACT( satShrdPrm.opchAcptSrc, + CGACT_STATE_DEACTIVATED, cid_array ); + } +#endif /* GPRS */ + } + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnCSDDown | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to indictate that the CSD data + connection is down. + +*/ + +GLOBAL void cmhSAT_OpChnCSDDown( SHORT cId, UBYTE tpl ) +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + + TRACE_FUNCTION("cmhSAT_OpChnCSDDown()"); + + psaSAT_InitTrmResp( &resp_data ); + resp_data.add_content = ADD_NO_CAUSE; + + if( satShrdPrm.chnTb.chnUsdFlg AND + satShrdPrm.chnTb.chnType EQ B_CSD AND + (satShrdPrm.chnTb.chnTPL EQ tpl OR tpl EQ TPL_DONT_CARE) AND + satShrdPrm.chnTb.chnRefId EQ cId ) + { + + /* If transport layer is UDP, reset wap_call flag */ + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + sAT_PercentWAP ( CMD_SRC_NONE, 0 ); + + /* clear parameters of dti connection */ + } + + if(simShrdPrm.sat_class_e_dti_id NEQ DTI_DTI_ID_NOTPRESENT) + { + dti_cntrl_erase_entry(simShrdPrm.sat_class_e_dti_id); + dti_cntrl_clear_conn_parms(simShrdPrm.sat_class_e_dti_id); + simShrdPrm.sat_class_e_dti_id = DTI_DTI_ID_NOTPRESENT; + TRACE_EVENT("sat_class_e_dti_id reset"); + } + + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + } +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnGPRSDeact | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to indictate that the CSD data + connection is down. + +*/ +#ifdef GPRS +GLOBAL void cmhSAT_OpChnGPRSDeact( void ) +{ + + SHORT cid; + TRACE_FUNCTION("cmhSAT_OpChnGPRSDeact()"); + + cid = gaci_get_cid_over_dti_id(wap_dti_id); + + /* If transport layer is UDP, reset wap_call flag */ + if( satShrdPrm.chnTb.chnTPL EQ UDP ) + { + cmhSM_disconnect_cid(cid, GC_TYPE_WAP ); + sAT_PercentWAP ( CMD_SRC_NONE, 0 ); + if(work_cids[cid_pointer] EQ cid) + { + smEntStat.curCmd = AT_CMD_NONE; + *work_cids = 0; + cid_pointer = 0; + } + } + + /* clear parameters of dti connection */ + if(simShrdPrm.sat_class_e_dti_id NEQ DTI_DTI_ID_NOTPRESENT) + { + dti_cntrl_erase_entry(simShrdPrm.sat_class_e_dti_id); + dti_cntrl_clear_conn_parms(simShrdPrm.sat_class_e_dti_id); + simShrdPrm.sat_class_e_dti_id = DTI_DTI_ID_NOTPRESENT; + TRACE_EVENT("sat_class_e_dti_id reset"); + } + +} +#endif /* GPRS */ +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnSIMFail | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the SIM entity + has reported a failure + +*/ + +GLOBAL void cmhSAT_OpChnSIMFail( UBYTE dtiConn, UBYTE bipConn, UBYTE chnId ) +{ +#ifdef DTI + T_SIM_SAT_CHN chnInf; + + TRACE_FUNCTION("cmhSAT_OpChnSIMFail()"); + + /* if the channel is still open */ + if( bipConn & SIM_BIP_OPEN_CHANNEL ) + { + chnInf.bipConn = SIM_BIP_CLOSE_CHANNEL; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_BEARIND_PERR; + chnInf.addRes = ADD_BIP_NO_CHAN_AVAIL; + + psaSIM_SATBIPChn( chnInf, cmhSAT_OpChnClose ); + + satShrdPrm.chnTb.lnkStat = SIM_LINK_OPEN; + } + /* if bearer is still in use */ + else if ( satShrdPrm.chnTb.chnUsdFlg ) + { + /* if a CSD is still in progress */ + if( satShrdPrm.chnTb.chnType EQ B_CSD ) + { + SHORT dummy; + + cmhCC_ClearCall( satShrdPrm.chnTb.chnRefId, + MNCC_CAUSE_CALL_CLEAR, + satShrdPrm.opchAcptSrc, + AT_CMD_NONE, + &dummy); + } + +#ifdef GPRS + /* if a GPRS context is still in progress */ + if( satShrdPrm.chnTb.chnType EQ B_GPRS ) + { + SHORT cid_array[2] = { 0,INVALID_CID }; + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + sAT_PlusCGACT( satShrdPrm.opchAcptSrc, + CGACT_STATE_DEACTIVATED, cid_array ); + } +#endif /* GPRS */ + } +#endif /* DTI */ +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnChckCSD | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to check if an open channel command + for CSD with the given TPL is pending + +*/ + +GLOBAL BOOL cmhSAT_OpChnChckCSD( UBYTE tpl ) +{ + + /* in case of a SAT channel establishment */ + if( satShrdPrm.opchStat EQ OPCH_EST_REQ AND + satShrdPrm.chnTb.chnTPL EQ tpl AND + satShrdPrm.opchType EQ B_CSD ) + { + return( TRUE ); + } + + return( FALSE ); +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnSIMCnctReq | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to request a connection between SIM + and the specified unit +*/ + +GLOBAL void cmhSAT_OpChnSIMCnctReq(UBYTE unit) +{ +#ifdef DTI + T_SIM_SAT_CHN chnInf; + + TRACE_FUNCTION("cmhSAT_OpChnSIMCnctReq()"); + + if( satShrdPrm.opchStat EQ OPCH_EST_REQ ) + { + /* DTI CHANNEL ESTABLISHMENT requested */ + + /* check for modification of bearer parameters */ + cmhSAT_OpChnChckBear(); + + /* setup channel info for PSA */ + chnInf.dtiUnit = unit; + chnInf.chnId = CHANNEL_ID_1; + chnInf.dtiConn = 0; + chnInf.dtiConn = SIM_DTI_CONNECT; + + if ( unit NEQ DTI_ENTITY_UDP ) + { + /* init DTI channel for SIM -> SNDCP, L2R and TRA */ + psaSIM_SATChn( chnInf, cmhSAT_OpChnCnct ); + } + else + { + /* prepare parameters for SIM -> UDP connection */ + /* copy settings into shrd prms */ + memcpy(&simShrdPrm.sim_dti_chPrm->sat_chn_prm,&chnInf,sizeof(T_SIM_SAT_CHN)); + /* callback for results of DTI connection has to be cmhSAT_OpChnCnct */ + simShrdPrm.sim_dti_chPrm->dti_cb = cmhSAT_OpChnCnct; + } + } +#endif /* DTI */ +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnChckBear | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to check whether the bearer parameters + differ from the orignal settings by the SAT command. + If so, the new parameters will overwrite the settings in + opchPrm and the opchPrmMdf will be set to TRUE. + +*/ + +GLOBAL void cmhSAT_OpChnChckBear(void) +{ + UBYTE mt; + + TRACE_FUNCTION("cmhSAT_OpChnChckBear()"); + + satShrdPrm.opchPrmMdf = FALSE; + + /* + *------------------------------------------------------------------- + * for CSD bearer parameters + *------------------------------------------------------------------- + */ + if( satShrdPrm.chnTb.chnType EQ B_CSD ) + { + T_CC_CALL_TBL * pCtbNtry; + UBYTE cmdSpeed; + UBYTE cmdName; + UBYTE cmdCE; + T_SAT_CSD_PRM *p = (T_SAT_CSD_PRM*)satShrdPrm.opchPrm; + + if (!psaCC_ctbIsValid (satShrdPrm.chnTb.chnRefId)) + { + /* Avoid to dereference NULL */ + TRACE_ERROR ("Call table entry disappeared"); + return; + } + + pCtbNtry = ccShrdPrm.ctb[satShrdPrm.chnTb.chnRefId]; + + if( !p->def_bear_prm ) + { + cmdSpeed = cmhCC_SelRate(p->csd_bear_prm.csd_speed); + cmdName = cmhCC_SelServ(p->csd_bear_prm.csd_name); + cmdCE = cmhCC_SelCE (p->csd_bear_prm.csd_ce); + + if((cmdSpeed NEQ pCtbNtry->BC[0].rate) OR + (cmdName NEQ pCtbNtry->BC[0].bearer_serv) OR + (cmdCE NEQ pCtbNtry->BC[0].conn_elem )) + { + satShrdPrm.opchPrmMdf = TRUE; + } + } + + /* update bearer parms with current values */ + p->csd_bear_prm.csd_speed = (UBYTE)cmhCC_GetDataRate(&pCtbNtry->BC[0]); + mt = pCtbNtry->BC[0].modem_type; + + switch( pCtbNtry->BC[0].rate ) + { + case( UR_0_3_KBIT ): + if( mt EQ MT_V21 ) p->csd_bear_prm.csd_speed = BS_SPEED_300_V21; + break; + case( UR_1_2_KBIT ): + if ( mt EQ MT_V22 ) p->csd_bear_prm.csd_speed = BS_SPEED_1200_V22; + else if ( mt EQ MT_V23 ) p->csd_bear_prm.csd_speed = BS_SPEED_1200_75_V23; + else if ( mt EQ MT_NONE ) p->csd_bear_prm.csd_speed = BS_SPEED_1200_V110; + break; + case( UR_2_4_KBIT ): + if ( mt EQ MT_V22_BIS ) p->csd_bear_prm.csd_speed = BS_SPEED_2400_V22bis; + else if ( mt EQ MT_V26_TER ) p->csd_bear_prm.csd_speed = BS_SPEED_2400_V26ter; + else if ( mt EQ MT_NONE ) p->csd_bear_prm.csd_speed = BS_SPEED_2400_V110; + break; + case( UR_4_8_KBIT ): + if ( mt EQ MT_V32 ) p->csd_bear_prm.csd_speed = BS_SPEED_4800_V32; + else if ( mt EQ MT_NONE ) p->csd_bear_prm.csd_speed = BS_SPEED_4800_V110; + break; + case( UR_9_6_KBIT ): + if ( mt EQ MT_V32 ) p->csd_bear_prm.csd_speed = BS_SPEED_9600_V32; + else if ( mt EQ MT_V34 ) p->csd_bear_prm.csd_speed = BS_SPEED_9600_V34; + else if ( mt EQ MT_NONE ) p->csd_bear_prm.csd_speed = BS_SPEED_9600_V110; + break; + case( UR_14_4_KBIT ): + if ( mt EQ MT_V34 ) p->csd_bear_prm.csd_speed = BS_SPEED_14400_V34; + else if ( mt EQ MT_NONE ) p->csd_bear_prm.csd_speed = BS_SPEED_14400_V110; + break; + default: + break; /* leave it the way it is */ + } + + switch( pCtbNtry->BC[0].bearer_serv ) + { + case( BEARER_SERV_ASYNC ): + p->csd_bear_prm.csd_name = CBST_NAM_Asynch; break; + + case( BEARER_SERV_SYNC ): + p->csd_bear_prm.csd_name = CBST_NAM_Synch; break; + + default: break; /* leave it the way it is */ + } + + switch( pCtbNtry->BC[0].conn_elem ) + { + case( CONN_ELEM_TRANS ): + p->csd_bear_prm.csd_ce = CBST_CE_Transparent; break; + + case( CONN_ELEM_NON_TRANS ): + p->csd_bear_prm.csd_ce = CBST_CE_NonTransparent; break; + + default: break; /* leave it the way it is */ + } + } + /* + *------------------------------------------------------------------- + * for GPRS bearer parameters + *------------------------------------------------------------------- + */ +#ifdef GPRS + if( satShrdPrm.chnTb.chnType EQ B_GPRS ) + { + T_QOS* curQOS; + T_SAT_GPRS_PRM *p = (T_SAT_GPRS_PRM*)satShrdPrm.opchPrm; + + curQOS = cmhSM_getCurQOS( satShrdPrm.chnTb.chnRefId ); + + if( !p->def_bear_prm ) + { + if((curQOS->preced NEQ p->gprs_bear_prm.gprs_prec) OR + (curQOS->delay NEQ p->gprs_bear_prm.gprs_delay) OR + (curQOS->relclass NEQ p->gprs_bear_prm.gprs_rely ) OR + (curQOS->peak NEQ p->gprs_bear_prm.gprs_peak ) OR + (curQOS->mean NEQ p->gprs_bear_prm.gprs_mean ) ) + { + satShrdPrm.opchPrmMdf = TRUE; + } + } + /* update bearer parms with current values */ + p->gprs_bear_prm.gprs_prec = curQOS->preced; + p->gprs_bear_prm.gprs_delay = curQOS->delay; + p->gprs_bear_prm.gprs_rely = curQOS->relclass; + p->gprs_bear_prm.gprs_peak = curQOS->peak; + p->gprs_bear_prm.gprs_mean = curQOS->mean; + } +#endif /* GPRS */ +} +#ifdef DTI +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnSetPPP | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to set up PPP parameters. + +*/ + +GLOBAL void cmhSAT_OpChnSetPPP(UBYTE chnType) +{ + + CHAR log[PPP_LOGIN_NAME_LENGTH+1]; /* holds login name */ + CHAR pwd[PPP_LOGIN_NAME_LENGTH+1]; /* holds password */ + + T_SAT_CSD_PRM *p = (T_SAT_CSD_PRM*)satShrdPrm.opchPrm; + + TRACE_FUNCTION("cmhSAT_OpChnSetPPP()"); + + log[0] = 0; /* empty login name */ + pwd[0] = 0; /* empty user name */ + + if( chnType EQ B_CSD ) + { + /* set login name and password, if available */ + if(p->v_log AND p->log.c_text_str) + { + strncpy(pwd,(const CHAR *)p->log.text_str,MINIMUM(p->log.c_text_str, PPP_LOGIN_NAME_LENGTH)); + log[MINIMUM(p->log.c_text_str, PPP_LOGIN_NAME_LENGTH)] ='\0'; + } + + if(p->v_pwd AND p->pwd.c_text_str) + { + strncpy(pwd,(const CHAR *)p->pwd.text_str,MINIMUM(p->pwd.c_text_str, PPP_LOGIN_NAME_LENGTH)); + pwd[MINIMUM(p->pwd.c_text_str, PPP_LOGIN_NAME_LENGTH)] ='\0'; + } + } + + sAT_PercentPPP( satShrdPrm.opchAcptSrc, A_PAP, log, pwd, USE_NO_PPP_FOR_AAA ); +} +#endif /* DTI */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnStatEvnt | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to send a channel status event if + enabled by SAT + +*/ + +GLOBAL void cmhSAT_OpChnStatEvnt( void ) +{ + + TRACE_FUNCTION("cmhSAT_OpChnStatEvnt()"); + + if( psaSAT_ChkEventList( EVENT_CHAN_STAT ) ) + { + cmhSAT_EventDwn( EVENT_CHAN_STAT, -1, NEAR_END ); + } + +} + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnGPRSPend | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to check for a pending GPRS open + channel command. + +*/ +#ifdef GPRS +GLOBAL BOOL cmhSAT_OpChnGPRSPend( SHORT cid, UBYTE opchStat ) +{ + if( satShrdPrm.chnTb.chnUsdFlg AND + satShrdPrm.chnTb.chnType EQ B_GPRS AND + (opchStat EQ OPCH_NONE OR opchStat EQ satShrdPrm.opchStat)AND + (cid EQ INVALID_CID OR cid EQ satShrdPrm.chnTb.chnRefId)) + + return( TRUE ); + + else + + return( FALSE ); +} +#endif /* GPRS */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnUDPActivateGprs | ++-------------------------------------------------------------------+ + + PURPOSE : This function is used to activate the UDP data chain and + GPRS context. + +*/ +#if defined (GPRS) AND defined (DTI) +GLOBAL void cmhSAT_OpChnUDPActivateGprs( void ) +{ + SHORT cid_array[2] = { 0,INVALID_CID }; + T_ACI_SAT_TERM_RESP resp_data; + + TRACE_FUNCTION("cmhSAT_OpChnUDPActivateGprs()"); + + cid_array[0] = satShrdPrm.chnTb.chnRefId; + + /* final check of context id and link status */ + if(!cmhSM_define_cid_list((T_ACI_CMD_SRC)satShrdPrm.opchAcptSrc, cid_array ) OR + !srcc_reserve_sources( SRCC_IP_SNDCP_LINK, satShrdPrm.chnTb.chnRefId)) + { + psaSAT_InitTrmResp( &resp_data ); + resp_data.add_content = ADD_BIP_NO_CHAN_AVAIL; + cmhSAT_OpChnFailed( RSLT_BEARIND_PERR, &resp_data ); + } + + srcc_new_count(SRCC_IP_SNDCP_LINK); + + /* create a SAT class E DTI ID if not present */ + 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); + } + + /* get dti id for SNDCP/IP link */ + pdp_context[satShrdPrm.chnTb.chnRefId-1].link_id_new = + dti_conn_compose_link_id (0,0, simShrdPrm.sat_class_e_dti_id, DTI_TUPLE_NO_NOTPRESENT); + + /* send request to ACI WAP to activate WAP */ + smEntStat.entOwn = smShrdPrm.owner = satShrdPrm.opchAcptSrc; + smEntStat.curCmd = AT_CMD_CGACT; + + psaTCPIP_Activate( satShrdPrm.opchAcptSrc, + simShrdPrm.sat_class_e_dti_id, + 0, TCPIP_ACT_OPTION_V4 | TCPIP_ACT_OPTION_UDP, + TCPIP_CONNECTION_TYPE_GPRS_WAP, + cmhSM_IP_activate_cb); + +} +#endif /* GPRS */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnUDPConfGprs | ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the UDP stack + is configured + +*/ + +#if defined(GPRS) +GLOBAL void cmhSAT_OpChnUDPConfGprs(void) +{ + + TRACE_FUNCTION("cmhSAT_OpChnUDPConfGprs()"); + /* + * send the SIM_BIP_CONFIG_REQ primitive providing details of the connection + * to SIM + */ + psaSIM_Bip_Config_Req(); + +} +#endif /* GPRS */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GSM-PS (6147) MODULE : SAT | +| ROUTINE : cmhSAT_OpChnUDPDeactGprs| ++-------------------------------------------------------------------+ + + PURPOSE : This callback function will be called when the UDP stack + is deactive + +*/ + +#if defined(GPRS) +GLOBAL void cmhSAT_OpChnUDPDeactGprs(void) +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + UBYTE cause; + + TRACE_FUNCTION("cmhSAT_OpChnUDPDeactGprs()"); + + psaSAT_InitTrmResp( &resp_data ); + + /* + *------------------------------------------------------------------- + * check if deactivation was intended + *------------------------------------------------------------------- + */ + if( satShrdPrm.opchStat EQ OPCH_CLS_REQ ) + { + /* nothing to do here anymore */ + } + + /* + *------------------------------------------------------------------- + * deactivation during an establish request + *------------------------------------------------------------------- + */ + else if( satShrdPrm.opchStat EQ OPCH_EST_REQ ) + { + if( satShrdPrm.gprsNtwCs ) + { + resp_data.add_content = satShrdPrm.gprsNtwCs | 0x80; + + cause = RSLT_NTW_UNAB_PROC; + } + else + { + resp_data.add_content = ADD_NO_CAUSE; + cause = RSLT_ME_UNAB_PROC; + } + + cmhSAT_OpChnFailed( cause, &resp_data ); + } +} +#endif /* GPRS */ + +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSAT_OpChnGPRSStat | ++-------------------------------------------------------------------+ + + PURPOSE : This function will be called if the status of the requested + GPRS context has changed. + +*/ +#if defined (GPRS) AND defined (DTI) +GLOBAL void cmhSAT_OpChnGPRSStat(T_SAT_GPRS_CB_STAT stat, UBYTE cause) +{ + T_ACI_SAT_TERM_RESP resp_data; /* holds terminal response parms */ + T_SIM_SAT_CHN chnInf; + + TRACE_FUNCTION ("cmhSAT_OpChnGPRSStat()"); + + if( cause ) satShrdPrm.gprsNtwCs = cause; + + /* in case of UDP, we will wait for the UDP status */ + if( satShrdPrm.chnTb.chnTPL EQ UDP AND + stat NEQ SAT_GPRS_SUSPEND AND + stat NEQ SAT_GPRS_RESUME) + + return; + + psaSAT_InitTrmResp( &resp_data ); + + /* + *------------------------------------------------------------------- + * during a close channel request + *------------------------------------------------------------------- + */ + if( satShrdPrm.opchStat EQ OPCH_CLS_REQ ) + { + /* nothing to do here anymore */ + } + + /* + *------------------------------------------------------------------- + * during an open channel establish request + *------------------------------------------------------------------- + */ + else if( satShrdPrm.opchStat EQ OPCH_EST_REQ ) + { + switch ( stat ) + { + case( SAT_GPRS_DEACT ): + case( SAT_GPRS_ATT_FAILED ): + case( SAT_GPRS_ACT_FAILED ): + + if( satShrdPrm.gprsNtwCs ) + { + resp_data.add_content = satShrdPrm.gprsNtwCs | 0x80; + + cause = RSLT_NTW_UNAB_PROC; + } + else + { + resp_data.add_content = ADD_NO_CAUSE; + cause = RSLT_ME_UNAB_PROC; + } + + cmhSAT_OpChnFailed( cause, &resp_data ); + break; + + case( SAT_GPRS_SUSPEND ): + + if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) + { + TRACE_EVENT("SAT GPRS channel suspend, SS busy"); + resp_data.add_content = ADD_ME_SS_BUSY; + } + + /* check for busy call condition */ + else if( psaSAT_ctbFindActCall() NEQ NO_ENTRY ) + { + TRACE_EVENT("SAT GPRS channel suspend, busy on call"); + resp_data.add_content = ADD_ME_CALL_BUSY; + } + + cmhSAT_OpChnFailed( RSLT_ME_UNAB_PROC, &resp_data ); + break; + + case( SAT_GPRS_ACT ): + + cmhSAT_OpChnSIMCnctReq( DTI_ENTITY_SNDCP ); + break; + + default: + + break; + } + } + /* + *------------------------------------------------------------------- + * expected status change + *------------------------------------------------------------------- + */ + else + { + switch ( stat ) + { + case( SAT_GPRS_DEACT ): + case( SAT_GPRS_ATT_FAILED ): + case( SAT_GPRS_ACT_FAILED ): + + resp_data.add_content = ADD_BIP_CHAN_CLOSD; + cmhSAT_OpChnFailed( RSLT_BEARIND_PERR, &resp_data ); + break; + + case( SAT_GPRS_SUSPEND ): + + chnInf.addRes = ADD_NO_CAUSE; + + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN OR + satShrdPrm.chnTb.lnkStat EQ SIM_LINK_CNCT ) + { + if( psaSS_stbFindActSrv( NO_ENTRY ) NEQ NO_ENTRY ) + { + TRACE_EVENT("SAT GPRS channel suspend, SS busy"); + chnInf.addRes = ADD_ME_SS_BUSY; + } + + /* check for busy call condition */ + else if( psaSAT_ctbFindActCall() NEQ NO_ENTRY ) + { + TRACE_EVENT("SAT GPRS channel suspend, busy on call"); + chnInf.addRes = ADD_ME_CALL_BUSY; + } + + /* setup channel info for PSA */ + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_ME_UNAB_PROC; + chnInf.bipConn = SIM_BIP_CHANNEL_SUSPENDED; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + + psaSIM_SATBIPChn( chnInf, NULL ); + } + break; + + case( SAT_GPRS_RESUME ): + + if( satShrdPrm.chnTb.lnkStat EQ SIM_LINK_OPEN OR + satShrdPrm.chnTb.lnkStat EQ SIM_LINK_CNCT ) + { + /* setup channel info for PSA */ + chnInf.chnId = CHANNEL_ID_1; + chnInf.genRes = RSLT_PERF_SUCCESS; + chnInf.addRes = ADD_NO_CAUSE; + chnInf.bipConn = SIM_BIP_CHANNEL_RESUMED; + chnInf.dtiConn = SIM_DTI_UNKNOWN; + + psaSIM_SATBIPChn( chnInf, NULL ); + } + break; + + case( SAT_GPRS_ACT ): + default: + + break; + } + } + +} +#endif /* GPRS */ +/* ++-------------------------------------------------------------------+ +| PROJECT : GPRS (8441) MODULE : CMH_SMF | +| STATE : finished ROUTINE : cmhSAT_cnvrtAPN2NetworkAdr| ++-------------------------------------------------------------------+ + + PURPOSE : converts a APN with a given length into a null terminated + domain name + +*/ + +#ifdef GPRS +GLOBAL void cmhSAT_cnvrtAPN2NetworkAdr( UBYTE *apn, UBYTE c_apn, UBYTE *dom_name ) +{ + UBYTE lblLen; + UBYTE apnIdx = 0; + UBYTE dnIdx = 0; + + TRACE_FUNCTION ("cmhSAT_cnvrtAPN2NetworkAdr()"); + + while( apnIdx < c_apn ) + { + lblLen = apn[apnIdx++]; + + memcpy( &dom_name[dnIdx], &apn[apnIdx], lblLen ); + + dnIdx += lblLen; + apnIdx += lblLen; + + dom_name[dnIdx++] = '.'; + } + + dom_name[dnIdx-1] = 0; +} +#endif /* GPRS */ + +#endif /* FF_SAT_E */ + +#endif /* SIM_TOOLKIT */ +/*==== EOF ========================================================*/