diff g23m/condat/ms/src/aci/cmh_satf.c @ 0:509db1a7b7b8

initial import: leo2moko-r1
author Space Falcon <falcon@ivan.Harhan.ORG>
date Mon, 01 Jun 2015 03:24:05 +0000
parents
children
line wrap: on
line diff
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/g23m/condat/ms/src/aci/cmh_satf.c	Mon Jun 01 03:24:05 2015 +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 ========================================================*/