--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/g23m-gsm/sim/sim_stk.c	Tue Oct 04 18:24:05 2016 +0000
@@ -0,0 +1,5169 @@
+/*
++-----------------------------------------------------------------------------
+|  Project :  GSM-F&D (8411)
+|  Modul   :  SIM_STK
++-----------------------------------------------------------------------------
+|  Copyright 2002 Texas Instruments Berlin, AG
+|                 All rights reserved.
+|
+|                 This file is confidential and a trade secret of Texas
+|                 Instruments Berlin, AG
+|                 The receipt of or possession of this file does not convey
+|                 any rights to reproduce or disclose its contents or to
+|                 manufacture, use, or sell anything it may describe, in
+|                 whole, or in part, without the specific written consent of
+|                 Texas Instruments Berlin, AG.
++-----------------------------------------------------------------------------
+|  Purpose :  This modul defines the SIM Toolkit Upgrade.
++-----------------------------------------------------------------------------
+*/
+
+#ifndef SIM_STK_C
+#define SIM_STK_C
+
+#define ENTITY_SIM
+
+/*==== INCLUDES ===================================================*/
+
+#include <string.h>
+#include "typedefs.h"
+#include "pcm.h"
+#include "pconst.cdg"
+#include "message.h"
+#include "ccdapi.h"
+#include "vsi.h"
+#include "custom.h"
+#include "gsm.h"
+#include "cnf_sim.h"
+#include "mon_sim.h"
+#include "prim.h"
+#include "pei.h"
+#include "tok.h"
+#include "sim.h"
+#include "sim_em.h"
+#include "cl_imei.h"  /* IMEI common library */
+#include "cl_shrd.h"
+
+#ifdef TI_PS_UICC_CHIPSET_15
+#include "8010_136_SIMDRV_SAP_inline.h"
+#endif
+
+EXTERN  USHORT   stk_l_cmd;
+/*==== EXPORT =====================================================*/
+
+/*
+*  These Functions are only temporary valid and should be replaced as soon as possible
+*/
+EXTERN UBYTE get_network_meas   (UBYTE * chan_list);
+EXTERN UBYTE get_bcch_chan_list (stk_data_type * out_stk_data);
+
+
+/*==== PRIVAT =====================================================*/
+
+#ifdef FF_SAT_E
+LOCAL void stk_handle_ccd_error(UBYTE notOK,
+                                UBYTE* status,
+                                UBYTE* general_result,
+                                UBYTE* add_info_result);
+LOCAL void stk_bip_decode_stk_command(T_sdu*          message,
+                                      T_cmd_details*  cmd_details,
+                                      UBYTE*          status,
+                                      UBYTE*          general_result,
+                                      UBYTE*          add_info_result);
+LOCAL void stk_close_dti_connection(UBYTE open);
+LOCAL void stk_close_bip_channel(UBYTE general_result,
+                                 UBYTE add_info_result);
+/* LOCAL void stk_dti_inform_mmi_old (UBYTE dti_conn_req); */
+LOCAL void stk_dti_inform_mmi(UBYTE dti_conn_req, UBYTE bip_conn_req );
+
+LOCAL void stk_dti_send_data();
+LOCAL void stk_bip_send_data_terminal_response(UBYTE general_result,
+                                               UBYTE add_info_result);
+#endif /* FF_SAT_E */
+
+/*==== TYPES ======================================================*/
+
+typedef struct
+{
+    UBYTE tag;
+    UBYTE min_len;
+    UBYTE mand;
+    UBYTE min_req;
+} T_SAT_TAG_DESC;
+
+typedef struct
+{
+    UBYTE cmd_type;
+    UBYTE tp_i;
+    UBYTE tp_flag;
+    UBYTE max_tag;
+    const T_SAT_TAG_DESC *tag_desc;
+} T_SAT_CMD_DESC;
+
+/*==== CONSTANTS ==================================================*/
+
+const T_SAT_TAG_DESC sat_def_cmd[2] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE }
+};                   // valid tags for any command
+
+const T_SAT_TAG_DESC sat_cmd_poll_itv[3] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE },
+  { STK_DURATION_TAG,
+    STK_DURATION_LEN,
+    TRUE, TRUE }
+};                   // valid tags for POLL INTERVALL
+
+const T_SAT_TAG_DESC sat_cmd_refresh[3] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE },
+  { STK_FILE_LIST_TAG,
+    STK_FILE_LIST_LEN,
+    FALSE, TRUE }
+};                  // valid tags for REFRESH
+
+const T_SAT_TAG_DESC sat_cmd_event_list[3] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE },
+  { STK_EVENT_LIST_TAG,
+    STK_EVENT_LIST_LEN,
+    TRUE, TRUE }
+};                  // valid tags for SETUP EVENT LIST
+
+const T_SAT_TAG_DESC sat_cmd_timer[4] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE },
+  { STK_TIMER_ID_TAG,
+    STK_TIMER_ID_LEN,
+    TRUE, TRUE },
+  { STK_TIMER_VALUE_TAG,
+    STK_TIMER_VALUE_LEN,
+    FALSE, FALSE }
+};                  // valid tags for TIMER MANAGEMENT
+
+const T_SAT_TAG_DESC sat_cmd_receive_data[5] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE },
+  { STK_ALPHA_IDENTITY_TAG,
+    STK_ALPHA_IDENTITY_LEN,
+    FALSE, FALSE },
+  { STK_ICON_IDENTITY_TAG,
+    STK_ICON_IDENTITY_LEN,
+    FALSE, FALSE },
+  { STK_CHANNEL_DATA_LGTH_TAG,
+    STK_CHANNEL_DATA_LGTH_LEN,
+    TRUE, TRUE }
+};                  // valid tags for RECEIVE DATA
+
+const T_SAT_TAG_DESC sat_cmd_send_data[5] = {
+  { STK_COMMAND_DETAILS_TAG,
+    STK_COMMAND_DETAILS_LEN,
+    TRUE, TRUE },
+  { STK_DEVICE_IDENTITY_TAG,
+    STK_DEVICE_IDENTITY_LEN,
+    TRUE, TRUE },
+  { STK_ALPHA_IDENTITY_TAG,
+    STK_ALPHA_IDENTITY_LEN,
+    FALSE, FALSE },
+  { STK_ICON_IDENTITY_TAG,
+    STK_ICON_IDENTITY_LEN,
+    FALSE, FALSE },
+  { STK_CHANNEL_DATA_TAG,
+    STK_CHANNEL_DATA_LEN,
+    TRUE, TRUE }
+};                  // valid tags for SEND DATA
+
+const T_SAT_CMD_DESC sat_cmd_list[] = {
+  { 0, 0, 0xFF,
+    item_of(sat_def_cmd), sat_def_cmd },    // command not yet known
+  { STK_REFRESH, 2, SAT_TP3_REFRESH,
+    item_of(sat_cmd_refresh), sat_cmd_refresh },
+  { STK_MORE_TIME, 2, SAT_TP3_MORE_TIME,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_POLL_INTERVALL, 2, SAT_TP3_POLL_ITV,
+    item_of(sat_cmd_poll_itv), sat_cmd_poll_itv },
+  { STK_POLLING_OFF, 2, SAT_TP3_POLL_OFF,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SET_UP_CALL, 3, SAT_TP4_SETUP_CALL,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SEND_SS, 3, SAT_TP4_SEND_SS,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SEND_SMS, 3, SAT_TP4_SEND_SMS,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_PLAY_TONE, 2, SAT_TP3_PLAY_TONE,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_DISPLAY_TEXT, 2, SAT_TP3_DSPL_TXT,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_GET_INKEY, 2, SAT_TP3_GET_INKEY,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_GET_INPUT, 2, SAT_TP3_GET_INPUT,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SELECT_ITEM, 3, SAT_TP4_SEL_ITEM,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SET_UP_MENU, 3, SAT_TP4_SETUP_MENU,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_PROVIDE_LOCAL_INFO, 3, SAT_TP4_PLI_PLMN_IMEI,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_TIMER_MANAGEMENT, 7, SAT_TP8_TMNG_ST,
+    item_of(sat_cmd_timer), sat_cmd_timer },
+  { STK_SETUP_EVENT_LIST, 4, SAT_TP5_EVENT_LIST,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SEND_USSD, 3, SAT_TP4_SEND_USSD,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SEND_DTMF, 8, SAT_TP9_DTMF_CMD,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_SETUP_IDLE_TEXT, 7, SAT_TP8_IDLE_TXT,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_RUN_AT_CMD, 7, SAT_TP8_AT_CMD,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_LANGUAGE_NOTIFICATION, 8, SAT_TP9_LANG_NOTIFY,
+    item_of(sat_def_cmd), sat_def_cmd }
+#ifdef FF_SAT_C
+  ,
+  { STK_LAUNCH_BROWSER, 8, SAT_TP9_LAUNCH_BROWSER,
+    item_of(sat_def_cmd), sat_def_cmd }
+#endif /* FF_SAT_C */
+#ifdef FF_SAT_E
+  ,
+  { STK_OPEN_CHANNEL, 11, SAT_TP12_OPEN_CHANNEL,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_CLOSE_CHANNEL, 11, SAT_TP12_CLOSE_CHANNEL,
+    item_of(sat_def_cmd), sat_def_cmd },
+  { STK_RECEIVE_DATA, 11, SAT_TP12_RECEIVE_DATA,
+    item_of(sat_cmd_receive_data), sat_cmd_receive_data },
+  { STK_SEND_DATA, 11, SAT_TP12_SEND_DATA,
+    item_of(sat_cmd_send_data), sat_cmd_send_data },
+  { STK_GET_CHANNEL_STAT, 11, SAT_TP12_GET_CHANNEL_STAT,
+    item_of(sat_def_cmd), sat_def_cmd }
+#endif /* FF_SAT_E */
+};
+
+/* Terminal Profile bits for which SIM is exclusively responsible.
+   They are discarded from the profile provided by MMI */
+
+static const UBYTE sat_tp_sim_exclusive[MAX_STK_PRF] = {
+      /* SAT_TP1_PRF_DNL |*/ SAT_TP1_TIMER_EXP | SAT_TP1_CC_ON_REDIAL,
+      0x0,
+      SAT_TP3_MORE_TIME | SAT_TP3_POLL_ITV | SAT_TP3_POLL_OFF,
+      SAT_TP4_PLI_PLMN_IMEI | SAT_TP4_PLI_NMR,
+      0x0 /*SAT_TP5_LOC_STATUS*/,
+      0x0, 0xFF,
+      SAT_TP8_TMNG_ST | SAT_TP8_TMNG_VAL,
+      SAT_TP9_BCCH_COD | SAT_TP9_PLI_TIMING_ADV,    /* Timing Advance is to be supported */
+      0x0, 0x0,
+      SAT_TP12_RECEIVE_DATA | SAT_TP12_SEND_DATA,
+      0x0, 0x0, 0x0, 0x0, 0x0, 0xFF, 0x0, 0xFF};
+
+/* Terminal Profile bits which have to be supported by SIM to be
+   valid with the profile provided by MMI */
+
+static const UBYTE sat_tp_sim_ability[MAX_STK_PRF] = {
+      SAT_TP1_PRF_DNL,
+      SAT_TP2_CMD_RES,
+      SAT_TP3_DSPL_TXT | SAT_TP3_GET_INKEY | SAT_TP3_GET_INPUT
+       | SAT_TP3_PLAY_TONE | SAT_TP3_REFRESH,
+      SAT_TP4_SEL_ITEM | SAT_TP4_SEND_SMS | SAT_TP4_SEND_SS
+       | SAT_TP4_SEND_USSD | SAT_TP4_SETUP_CALL | SAT_TP4_SETUP_MENU,
+      SAT_TP5_EVENT_LIST, 0x0, 0x0,
+      SAT_TP8_IDLE_TXT | SAT_TP8_AT_CMD | SAT_TP8_PLI_DTT,
+      SAT_TP9_DTMF_CMD | SAT_TP9_LANG_NOTIFY | SAT_TP9_LAUNCH_BROWSER,
+      0x0, 0x0,
+      SAT_TP12_OPEN_CHANNEL | SAT_TP12_CLOSE_CHANNEL | SAT_TP12_GET_CHANNEL_STAT,
+      0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+
+/* Currently supported Terminal Profile bits by SIM */
+
+static const UBYTE sat_tp_sim_enabled[MAX_STK_PRF] = {
+      SAT_TP1_PRF_DNL | SAT_TP1_SMS_DNL | SAT_TP1_9E_XX | SAT_TP1_TIMER_EXP,
+      SAT_TP2_CMD_RES,
+      SAT_TP3_MORE_TIME | SAT_TP3_POLL_ITV | SAT_TP3_POLL_OFF | SAT_TP3_REFRESH,
+      SAT_TP4_PLI_PLMN_IMEI | SAT_TP4_PLI_NMR,
+      0x0, 0x0, 0x0,
+      SAT_TP8_TMNG_ST | SAT_TP8_TMNG_VAL | SAT_TP8_PLI_DTT
+       | SAT_TP8_IDLE_TXT | SAT_TP8_AT_CMD,
+      SAT_TP9_BCCH_COD | SAT_TP9_PLI_TIMING_ADV,       /* Timing Advance is to be supported */
+      0x0, 0x0,
+#ifdef FF_SAT_E
+      SAT_TP12_OPEN_CHANNEL | SAT_TP12_CLOSE_CHANNEL | SAT_TP12_GET_CHANNEL_STAT
+       | SAT_TP12_RECEIVE_DATA | SAT_TP12_SEND_DATA,
+#else
+      0x0,
+#endif
+      0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0};
+
+static const UBYTE tbl_device_src_id[] =
+{
+  DEV_SRC_KBD,
+  DEV_SRC_DSP,
+  DEV_SRC_EAR,
+  DEV_SRC_CDR0,
+  DEV_SRC_CDR1,
+  DEV_SRC_CDR2,
+  DEV_SRC_CDR3,
+  DEV_SRC_CDR4,
+  DEV_SRC_CDR5,
+  DEV_SRC_CDR6,
+  DEV_SRC_CDR7,
+  DEV_SRC_CH1,
+  DEV_SRC_CH2,
+  DEV_SRC_CH3,
+  DEV_SRC_CH4,
+  DEV_SRC_CH5,
+  DEV_SRC_CH6,
+  DEV_SRC_CH7,
+  DEV_SRC_SIM,
+  DEV_SRC_ME,
+  DEV_SRC_NTW,
+  0
+};
+
+/*==== VARIABLES ==================================================*/
+BOOL startTimerPollOff = FALSE; 
+
+USHORT cusSatMinPollItv = 50;     // 5 seconds
+
+/*==== FUNCTIONS ==================================================*/
+
+LOCAL UBYTE stk_dti_bip_receive_data (T_sdu* message, UBYTE result_code);
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_init_sim_data          |
++--------------------------------------------------------------------+
+
+  PURPOSE : Initialize the SIM data for the module SIM TOOLKIT.
+
+*/
+
+GLOBAL void stk_init_sim_data (void)
+{
+  TRACE_FUNCTION ("stk_init_sim_data()");
+
+  /*
+   * initialize SAT variables
+   */
+  sim_data.sat_session    = FALSE;
+  sim_data.ext_sat_cmd    = FALSE;
+  sim_data.term_resp_sent = FALSE;
+  sim_data.chk_sat_avail  = FALSE;
+  sim_data.context_switch_ptr         = NULL; 
+  sim_data.cust_mode                  = FALSE;
+  sim_data.user_confirmation_expected = FALSE;
+
+#ifdef FF_SAT_E
+  /*
+   * initialize DTI variables
+   */
+  sim_data.dti_connection_state       = SIM_DTI_CONNECTION_CLOSED;
+  sim_data.dti_rx_state               = SIM_DTI_RX_IDLE;
+  sim_data.dti_tx_state               = SIM_DTI_TX_IDLE;
+  sim_data.event_data_avail           = SIM_EVENT_DISABLE;
+  sim_data.bip_state                  = SIM_BIP_CLOSED;
+  sim_data.bip_suspend                = FALSE;
+#ifdef _SIMULATION_
+  TRACE_EVENT("bip_rx_state = IDLE");
+#endif
+  sim_data.bip_rx_state               = SIM_BIP_RX_IDLE;
+#ifdef _SIMULATION_
+  TRACE_EVENT("bip_tx_state = IDLE");
+#endif
+  sim_data.bip_tx_state               = SIM_BIP_TX_IDLE;
+  sim_data.bip_timer_state            = SIM_BIP_TIMER_DISCONNECTED;
+  sim_data.bip_release_time           = SIM_NO_AUTO_RELEASE;
+  sim_data.bip_general_result         = RSLT_PERF_SUCCESS;
+  sim_data.bip_add_info_result        = ADD_NO_CAUSE;
+  sim_data.con_type                   = SIM_CON_TYPE_UDP;
+  sim_data.data_to_send.first         = (ULONG)NULL;
+  sim_data.data_to_send.list_len      = 0;
+  sim_data.prev_data_to_send.first    = (ULONG)NULL;
+  sim_data.prev_data_to_send.list_len = 0;
+  sim_data.received_data.first        = (ULONG)NULL;
+  sim_data.received_data.list_len     = 0;
+  sim_data.received_data_pos          = 0;
+  sim_data.sim_dti_req                = NULL;
+  sim_data.sim_bip_req                = NULL;
+  sim_data.sim_bip_config_req         = NULL;
+  memset(&sim_data.udp_parameters, 0, sizeof(T_SRC_DES));
+#endif /* FF_SAT_E */
+} /* stk_init_sim_data() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)     MODULE  : SIM_STK                      |
+| STATE   : code              ROUTINE : stk_check_tp                 |
++--------------------------------------------------------------------+
+
+  PURPOSE : Evaluates the received Terminal Profile against the
+            capability of the SIM Entity.
+
+*/
+
+GLOBAL void stk_check_tp (UBYTE *out_prf, UBYTE *in_prf, USHORT len)
+{
+  int i;
+  UBYTE tp_tmp;
+
+/* TRACE_FUNCTION ("stk_check_tp()"); */
+
+  len = MINIMUM(len, MAX_STK_PRF);
+  for (i = 0; i < len; i++)                 // check TP from MMI
+  {
+#ifndef __OLD
+    tp_tmp = sat_tp_sim_enabled[i] & ~sat_tp_sim_ability[i];
+    out_prf[i] = ((in_prf[i] & ~sat_tp_sim_exclusive[i]) &
+                 ~tp_tmp) | tp_tmp;
+#else
+    out_prf[i] = ((in_prf[i] & ~sat_tp_sim_exclusive[i]) &
+                  (sat_tp_sim_enabled[i] | ~sat_tp_sim_ability[i]))
+                  | sat_tp_sim_enabled[i];
+#endif
+  }
+  if (!(out_prf[0] & SAT_TP1_SMS_DNL))      // check SMS download
+    out_prf[0] &= ~SAT_TP1_9E_XX;           // only valid with SMS download
+
+  if (len >= 6 AND
+      !(out_prf[4] & SAT_TP5_EVENT_LIST))   // check event list consistency
+    out_prf[5] = out_prf[4] = 0;            // discard event list
+
+  if (len >= 12 AND
+      (out_prf[11] & STK_TP12_CLASS_E) NEQ STK_TP12_CLASS_E)
+  {
+    out_prf[11] &= ~STK_TP12_CLASS_E;
+
+    if (len >= 13)
+      out_prf[12] &= ~(SAT_TP13_CSD_SUPP_BY_ME | SAT_TP13_GPRS_SUPP_BY_ME);
+
+    if (len >= 17)
+      out_prf[16] &= ~(SAT_TP17_BEARER_IND_SUPP_TCP | SAT_TP17_BEARER_IND_SUPP_UDP);
+  }
+  TRACE_EVENT_P5("TP: %02X %02X %02X %02X ... (%d bytes)",
+                 out_prf[0], out_prf[1], out_prf[2], out_prf[3], len);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)     MODULE  : SIM_STK                      |
+| STATE   : code              ROUTINE : stk_perform_profile_download |
++--------------------------------------------------------------------+
+
+  PURPOSE : Initialize the SIM data for the module application.
+
+*/
+
+GLOBAL void stk_perform_profile_download (void)
+{
+  USHORT result;
+  USHORT used_tp = (USHORT)sizeof (sim_data.stk_profile);
+
+  TRACE_FUNCTION ("stk_perform_profile_download()");
+
+  do
+  {
+    if (sim_data.stk_profile[--used_tp] NEQ 0)
+      break;
+  } while (used_tp >= 3);
+  used_tp++;
+
+  if ((result = FKT_TerminalProfile (sim_data.stk_profile,
+                                     used_tp)) NEQ SIM_NO_ERROR)
+  {
+    TRACE_EVENT_P1("TP dnl error: %04X", result);
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)     MODULE  : SIM_STK                      |
+| STATE   : code              ROUTINE : stk_proactive_polling        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Polling of an proactive SIM card.
+
+*/
+
+static const UBYTE tag_dur [] =
+{
+    STK_DURATION_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* duration tag                 */
+    STK_DURATION_LEN,               /* duration length              */
+    0,                              /* unit                         */
+    0                               /* number of units              */
+};
+
+static const UBYTE terminal_response_loci [21]  =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    STK_PROVIDE_LOCAL_INFO,         /* command PROVIDE LOCATION INFO*/
+    0,                              /* location information         */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* result tag                   */
+    1,                              /* result length                */
+    0,                              /* result OK                    */
+    0x13,                           /* location information tag     */
+    7,                              /* location information length  */
+    0,0,0,                          /* MCC & MNC                    */
+    0,0,                            /* Location area code           */
+    0,0                             /* cell identity                */
+};
+
+static const UBYTE terminal_response_imei [22]  =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    STK_PROVIDE_LOCAL_INFO,         /* command PROVIDE LOCATION INFO*/
+    1,                              /* imei                         */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* result tag                   */
+    1,                              /* result length                */
+    0,                              /* result OK                    */
+    0x14,                           /* imei tag                     */
+    8,                              /* imei length                  */
+    0,0,0,0,0,0,0,0                 /* imei digits                  */
+};
+
+static const UBYTE terminal_response_nmr [14]  =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    STK_PROVIDE_LOCAL_INFO,         /* command PROVIDE LOCATION INFO*/
+    2,                              /* network measurement results  */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* result tag                   */
+    1,                              /* result length                */
+    0,                              /* result OK                    */
+    0x16,                           /* nmr tag                      */
+    16                              /* nmr length                   */
+};
+
+/*
+ * Terminal-Response for timing advance
+ */
+static const UBYTE terminal_response_timingadv [16]  =
+{
+    /* ---- cmd details ----- */
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,   /*  command details tag  */
+    STK_COMMAND_DETAILS_LEN,      /*  command details length  */
+    0,                            /*  command number  */
+    STK_PROVIDE_LOCAL_INFO,       /*  command PROVIDE LOCAL INFO  */
+    5,                            /*  timing advance  */
+
+    /* ---- device ids ------ */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /*  device details tag  */
+    STK_DEVICE_IDENTITY_LEN,        /*  device details length  */
+    0x82,                           /*  source ME  */
+    0x81,                           /*  destination SIM  */
+    
+    /* ------result --------- */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /*  result tag  */
+    1,                              /*  result length  */
+    0,                              /*  result OK  */
+    
+    /* --- timing advance --- */
+    0x2E,                           /*  timing advance tag  */
+    2,                              /*  timing advance len  */
+    0,                              /*  ME Status  */
+    0                               /*  Timing Advance  */
+};
+
+static const T_SIM_TRSP_SIMPLE terminal_response_def =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    0,                              /* command type place holder    */
+    0,                              /* command qualifier            */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* result tag                   */
+    1,                              /* result length place holder   */
+    0xFF,                           /* result place holder          */
+    0,                              /* result additional info       */
+};
+
+#ifdef __INVALID
+static const UBYTE terminal_response_ok [12]  =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    2,                              /* command MORE TIME            */
+    0,                              /* not used                     */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* result tag                   */
+    1,                              /* result length                */
+    0                               /* result OK                    */
+};
+
+static const UBYTE terminal_response_loci_neg [13]  =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    STK_PROVIDE_LOCAL_INFO,         /* command PROVIDE LOCATION INFO*/
+    0,                              /* location information         */
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* result tag                   */
+    2,                              /* result length                */
+    0x20,                           /* result ME unable to process  */
+    4                               /* result add. info no service  */
+};
+
+static const UBYTE terminal_response_no_cap [12]  =
+{
+    STK_COMMAND_DETAILS_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* command details tag          */
+    STK_COMMAND_DETAILS_LEN,        /* command details length       */
+    0,                              /* command number               */
+    0x26,                           /* command PROVIDE LOCATION INFO*/
+    0,                              /* location information         */
+    2,                              /* device details tag           */
+    2,                              /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    3,                              /* result tag                   */
+    1,                              /* result length                */
+    0x30                            /* result beyond ME capability  */
+};
+#endif
+
+LOCAL UBYTE stk_process_tl (UBYTE **pp_stk,
+                            SHORT *p_ber_len,
+                            SHORT *p_tlv_len)
+{
+/* get tag and length and adjust pointer to get parameter values */
+
+  UBYTE tag = STK_COMPREHENSION_REQUIRED;
+  SHORT tlv_len;
+
+  if (*p_ber_len >= 2)
+  {
+    tag = *((*pp_stk)++);           // get tag and adjust pointer
+    if ((tlv_len = (SHORT)*((*pp_stk)++)) <= 0x7F)
+    {                               // one byte length
+      *p_tlv_len = tlv_len;         // get length
+      *p_ber_len -= 2;
+    }
+    else if (tlv_len EQ 0x81 AND *p_ber_len >= 3)
+    {                               // two bytes length
+      *p_tlv_len = (SHORT)*((*pp_stk)++);
+      *p_ber_len -= 3;              // get length and adjust pointer
+    }
+    else
+    {                               // erroneous length coding
+      *p_tlv_len = 0;
+      *p_ber_len = 0;
+      return STK_COMPREHENSION_REQUIRED;
+    }
+  }
+  return tag;
+}
+
+LOCAL SHORT stk_build_response (UBYTE *p_response,
+                                UBYTE *p_cmd, int cmd_len,
+                                UBYTE *p_res, int res_len,
+                                UBYTE *p_prm, int prm_len)
+{
+  /*
+   * builds a TERMINAL RESPONSE
+   */
+static const UBYTE dev_resp[5] =
+  {
+    STK_DEVICE_IDENTITY_TAG |
+    STK_COMPREHENSION_REQUIRED,     /* device details tag           */
+    STK_DEVICE_IDENTITY_LEN,        /* device details length        */
+    0x82,                           /* source ME                    */
+    0x81,                           /* destination SIM              */
+    STK_RESULT_TAG |
+    STK_COMPREHENSION_REQUIRED      /* result tag                   */
+  };
+  int tr_len = 6;
+
+#ifdef _SIMULATION_
+  TRACE_FUNCTION ("stk_build_response()");
+#endif
+  TRACE_FUNCTION_P1 ("TERMINAL_RESPONSE: result=0x%02X", (int)*p_res);
+
+  memcpy (p_response, p_cmd, cmd_len);
+  memcpy (p_response + cmd_len, dev_resp, 5);
+  p_response[cmd_len + 5] = (UBYTE)res_len;
+  memcpy (p_response + cmd_len + 6, p_res, res_len);
+  tr_len += cmd_len + res_len;
+
+  if (p_prm NEQ NULL AND prm_len > 0)
+  {
+    memcpy (p_response + tr_len, p_prm, prm_len);
+    tr_len += prm_len;
+  }
+  return (SHORT)tr_len;
+}
+
+
+GLOBAL int process_sim_refresh( T_CONTEXT_SWITCH    *cmd_ptr )
+{
+  int i;
+  SHORT resp_len = 0;
+  #ifdef TI_PS_UICC_CHIPSET_15
+  U8 readerId = SIMDRV_VAL_READER_ID__RANGE_MIN;
+  U8 voltageSelect = SIMDRV_REQ_VOLTAGE_SEL;
+  #endif
+  
+  T_STK_POLL_DATA *p;
+  MALLOC (p, sizeof (T_STK_POLL_DATA));
+  memset (p, 0, sizeof (T_STK_POLL_DATA));
+
+
+  TRACE_FUNCTION ("process_sim_refresh()");
+
+
+  /* process as before */
+  switch (cmd_ptr->p_cmd[4])
+  {
+  case 1:
+    /*check file list is empty */
+    if( ( 0 == cmd_ptr->fl_len ) OR ( 1 == cmd_ptr->fl_len ) )
+    {
+      cmd_ptr->res_code[0] = STK_RES_ERR_MISS_VALUE;
+      resp_len = stk_build_response (p->response,
+                                     cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                                     cmd_ptr->res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+      TRACE_EVENT("FCN: File List is empty");
+#endif
+      FKT_TerminalResponse (p->response, (USHORT)resp_len);
+      break;
+    }
+    if (cmd_ptr->tag2 NEQ NULL AND cmd_ptr->fl_len >= 5)
+    {
+      BOOL sim_init = FALSE;
+      PALLOC (file_update_sms, SIM_FILE_UPDATE_IND);
+      memset (file_update_sms, 0, sizeof(T_SIM_FILE_UPDATE_IND));
+
+      file_update_sms->val_nr = *(cmd_ptr->tag2++);
+      cmd_ptr->fl_len -= 3;    /* align file id count */
+      for (i = 0; cmd_ptr->fl_len > 0 AND i < (int)file_update_sms->val_nr; i++)
+      {
+        do
+        {
+          cmd_ptr->tag2 += 2;
+          /* Check if entry is a first level directory */
+          if(cmd_ptr->tag2[0] EQ 0x7F)
+          {
+            if(file_update_sms->file_info[i].v_path_info EQ FALSE)
+            {
+              file_update_sms->file_info[i].v_path_info = TRUE;
+              file_update_sms->file_info[i].path_info.df_level1 = 
+                ((USHORT)cmd_ptr->tag2[0] << 8) | (USHORT)cmd_ptr->tag2[1];
+            }
+            else
+            {
+              /* This has already been filled. There cannot be another 
+              first level directory. Since i is reduced, i will not 
+              equal to file_update_sms->val_nr and error will be sent to SIM */
+              i--;
+              break;
+            }
+          }
+          /* Check if entry is a second level directory and first level 
+           * directory is also filled*/
+          else if(cmd_ptr->tag2[0] EQ 0x5F)
+          { 
+            if(file_update_sms->file_info[i].v_path_info EQ TRUE AND
+               file_update_sms->file_info[i].path_info.v_df_level2 EQ FALSE)
+            {
+              file_update_sms->file_info[i].path_info.v_df_level2 = TRUE;
+              file_update_sms->file_info[i].path_info.df_level2 = 
+                ((USHORT)cmd_ptr->tag2[0] << 8) | (USHORT)cmd_ptr->tag2[1];
+            }
+            else
+            {
+              /* This has already been filled. There cannot be another 
+              second level directory */
+              i--;
+              break;
+            }
+          }
+          cmd_ptr->fl_len -= 2;
+        }
+        while (cmd_ptr->fl_len > 0 AND cmd_ptr->tag2[2] NEQ 0x3F);
+
+        if (cmd_ptr->tag2[0] NEQ 0x2F AND cmd_ptr->tag2[0] NEQ 0x6F
+                AND cmd_ptr->tag2[0] NEQ 0x4F)
+          break;      /* no EF code -> loop exit leads to error response */
+
+        file_update_sms->file_info[i].datafield = ((USHORT)cmd_ptr->tag2[0] << 8)
+                                                   | (USHORT)cmd_ptr->tag2[1];
+        if ((file_update_sms->file_info[i].datafield EQ SIM_PHASE) OR
+            (file_update_sms->file_info[i].datafield EQ SIM_SST))
+
+        {             /* SIM initialisation is needed! */
+           sim_init = TRUE;
+           TRACE_FUNCTION ("FCN converted to INIT");
+           /* break;      exit for loop */
+        }
+      }
+      if (cmd_ptr->fl_len > 0 OR i NEQ (int)file_update_sms->val_nr)
+      {               /* inconsistent TLV content */
+        PFREE(file_update_sms);
+        cmd_ptr->res_code[0] = STK_RES_ERR_CMD_DATA;
+        resp_len = stk_build_response (p->response,
+                            cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                            cmd_ptr->res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+        TRACE_EVENT("FCN: inconsistent TLV content");
+#endif
+        FKT_TerminalResponse (p->response, (USHORT)resp_len);
+        break;        /* exit switch 'cmd_qual' */
+      }
+      if (!sim_init)
+      {
+        {
+          PALLOC (file_update_mmi, SIM_FILE_UPDATE_IND);
+          memcpy (file_update_mmi, file_update_sms,
+                         sizeof(T_SIM_FILE_UPDATE_IND));
+          PSENDX (MMI, file_update_mmi);
+        }
+        {
+          PALLOC (file_update_mm, SIM_FILE_UPDATE_IND);
+          memcpy (file_update_mm, file_update_sms,
+                         sizeof(T_SIM_FILE_UPDATE_IND));
+          PSENDX (MM, file_update_mm);
+        }
+        PSENDX (SMS, file_update_sms);
+
+        sim_data.file_change_resp = 0x7;  /* check response */
+        /* Force file selection */
+        sim_data.act_directory = NOT_PRESENT_16BIT;
+        sim_data.act_field     = NOT_PRESENT_16BIT;
+
+        if ((USHORT)(cmd_ptr->cmd_len + 7) <= sizeof (sim_data.stk_response))
+        {
+          sim_data.stk_resp_len = stk_build_response (sim_data.stk_response,
+                                      cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                                      cmd_ptr->res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+          TRACE_EVENT("FCN: prepare TR");
+#endif
+        }
+        else
+          sim_data.stk_resp_len = 0;
+        break;
+      }
+      else
+      {
+        PFREE (file_update_sms);
+      }
+    }
+    else
+    {
+      cmd_ptr->res_code[0] = STK_RES_ERR_MISS_VALUE;
+      resp_len = stk_build_response (p->response,
+                                     cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                                     cmd_ptr->res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+      TRACE_EVENT("FCN: cmd incomplete");
+#endif
+      FKT_TerminalResponse (p->response, (USHORT)resp_len);
+      break;
+    }           // no break for sim_init EQ TRUE !
+
+  case 3:
+  case 2:
+    if (cmd_ptr->res_code[0] EQ STK_RES_SUCCESS)
+      // do not overwrite special result codes
+      // these commands read more EFs than indicated
+      cmd_ptr->res_code[0] = STK_RES_SUCC_ADD_EF_READ;
+  case 0:
+    if ( (SIM_IS_FLAG_SET (CALL_ACTIVE)) AND (sim_data.cust_mode EQ 0) )
+    {
+      cmd_ptr->res_code[0] = STK_RES_BUSY_ME;
+      cmd_ptr->res_code[1] = STK_RES_EXT_BUSY_CALL;
+      resp_len = stk_build_response (p->response,
+                                     cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                                     cmd_ptr->res_code, 2, NULL, 0);
+#ifdef _SIMULATION_
+      TRACE_EVENT("INIT: call active");
+#endif
+      FKT_TerminalResponse (p->response, (USHORT)resp_len);
+    }
+    else
+    {
+      /* Force file selection */
+      sim_data.act_directory = NOT_PRESENT_16BIT;
+      sim_data.act_field     = NOT_PRESENT_16BIT;
+      sim_data.status_time   = THIRTY_SECONDS;
+      app_sim_read_parameters ();
+      /* The terminal response to be sent is created and stored in context.
+         Once ACI and MM indicates the completion of the reading of the EFs
+         through SIM_SYNC_REQ, the response will be sent. */
+      sim_data.stk_resp_len = stk_build_response (sim_data.stk_response,
+                                     cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                                     cmd_ptr->res_code, 1, NULL, 0);
+      sim_data.sync_awaited = SIM_SYNC_AWAIT_MM_READ | SIM_SYNC_AWAIT_MMI_READ;
+
+#ifdef _SIMULATION_
+      TRACE_EVENT("INIT: success");
+#endif
+    }
+    break;
+  case 4:
+    if ( (SIM_IS_FLAG_SET (CALL_ACTIVE)) AND (sim_data.cust_mode EQ 0) )
+    {
+      cmd_ptr->res_code[0] = STK_RES_BUSY_ME;
+      cmd_ptr->res_code[1] = STK_RES_EXT_BUSY_CALL;
+      resp_len = stk_build_response (p->response,
+                                     cmd_ptr->p_cmd, (int)cmd_ptr->cmd_len,
+                                     cmd_ptr->res_code, 2, NULL, 0);
+#ifdef _SIMULATION_
+      TRACE_EVENT("RESET: call active");
+#endif
+      FKT_TerminalResponse (p->response, (USHORT)resp_len);
+    }
+    else
+    {
+      #ifndef TI_PS_UICC_CHIPSET_15
+	  T_SIM_CARD sim_info;
+      #endif   /*  TI_PS_UICC_CHIPSET_15 */
+      USHORT retcode;
+
+      TRACE_ASSERT (cmd_ptr->sig_ptr);
+      PFREE (cmd_ptr->sig_ptr);
+      TRACE_ASSERT (p);
+      MFREE (p);
+      sim_data.remove_error = SIM_NO_ERROR;
+      app_sim_remove ();
+      sim_data.remove_error = SIM_CAUSE_CARD_REMOVED;
+
+      #ifndef TI_PS_UICC_CHIPSET_15
+         SIM_PowerOff ();
+      #else
+         simdrv_poweroff(readerId);
+      #endif
+      /* Force file selection */
+      sim_data.act_directory = NOT_PRESENT_16BIT;
+      sim_data.act_field     = NOT_PRESENT_16BIT;
+
+      /*retcode = SIM_Restart (&sim_info); Driver does not call 'insert()'! */
+      #ifndef TI_PS_UICC_CHIPSET_15
+         retcode = SIM_Reset (&sim_info);
+      #else
+         retcode = simdrv_reset (readerId,voltageSelect);
+      #endif
+      TRACE_EVENT_P1 ("Result SIM Restart = %d", (int)retcode);
+      TRACE_FUNCTION ("process_sim_refresh() exited(1)");
+      return(1); //return and exit stk_proactive_polling(), if that is where called from
+    }
+    break;
+
+  default:
+    /*
+     * not supported information request
+     */
+     TRACE_FUNCTION ("process_sim_refresh() default:");
+     cmd_ptr->res_code[0] = STK_RES_ERR_CMD_TYPE;
+     resp_len = stk_build_response (p->response, cmd_ptr->p_cmd, cmd_ptr->cmd_len,
+                                    cmd_ptr->res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+     TRACE_EVENT("RFR: unknown qualifier");
+#endif
+     FKT_TerminalResponse (p->response, (USHORT)resp_len);
+     break;
+   }
+
+   TRACE_ASSERT (cmd_ptr->sig_ptr);
+   PFREE (cmd_ptr->sig_ptr);
+   TRACE_ASSERT (p);
+   MFREE (p);
+   TRACE_FUNCTION ("process_sim_refresh() exited(0)");
+   return(0);
+          
+}
+
+
+
+
+GLOBAL void stk_proactive_polling (void)
+{
+  UBYTE *stk, *p_tag, *p_cmd = NULL;
+  UBYTE *found_tag[STK_MAX_EXP_TAG];
+  UBYTE compreh = 0, cmd_nr = 0, cmd_type, cmd_qual = 0;
+  SHORT ber_len, tag_len, cmd_len, fl_len = 0, resp_len = 0;
+  SHORT i, tag_i, cmd_i, tlv_len;
+  const T_SAT_TAG_DESC *p_tag_desc;
+  int offset;
+  T_LOC_INFO loc_info;
+  T_TIM_ADV tim_adv;
+
+  TRACE_FUNCTION ("stk_proactive_polling()");
+
+  if (SIM_IS_FLAG_SET (PRO_ACTIVE_SIM))
+  {
+    while (sim_data.proactive_sim_data_len > 0)
+    {
+      UINT   in_queue, out_queue;
+      UBYTE  result = FALSE;
+      UBYTE  res_code[2] = {STK_RES_SUCCESS, 0};
+      T_TIME tm_val;
+      T_STK_POLL_DATA *p;
+
+      PALLOC (sim_toolkit_ind, SIM_TOOLKIT_IND);
+      MALLOC (p, sizeof (T_STK_POLL_DATA));
+      /*
+       * clear indication primitive
+       */
+      memset (sim_toolkit_ind, 0, sizeof (T_SIM_TOOLKIT_IND));
+      sim_toolkit_ind->stk_cmd.l_cmd = ((USHORT)sim_data.proactive_sim_data_len) << 3;
+      ber_len = (SHORT)sim_data.proactive_sim_data_len;
+      sim_data.proactive_sim_data_len = 0;
+      sim_data.term_resp_sent         = FALSE;
+
+      if (FKT_Fetch(sim_toolkit_ind->stk_cmd.cmd, ber_len) EQ SIM_NO_ERROR)
+      {
+        UBYTE tag;
+        BOOL tag_not_found = TRUE;
+
+#ifdef _SIMULATION_
+        TRACE_EVENT("FKT_Fetch_EQ_SIM_NO_ERROR"); /* for debug purpose only */
+#endif
+        sim_data.ext_sat_cmd = FALSE;             /* internal command by default */
+
+        stk = sim_toolkit_ind->stk_cmd.cmd;
+        memset (found_tag, 0, sizeof(found_tag));
+        tag_i = cmd_i = 0;
+        cmd_len = 0;
+        cmd_type = 0;
+
+        tag = stk_process_tl(&stk, &ber_len, &tlv_len); /* BER tag */
+        if (tag NEQ STK_PROACTIVE_SIM_COMMAND_TAG)
+        {
+          res_code[0] = STK_RES_ERR_MISS_VALUE;
+        }
+        else if (ber_len >= tlv_len)
+        {
+          ber_len = tlv_len;        // omit data after BER-TLV
+          result = TRUE;
+        }
+        else /* ber_len < tlv_len */
+        {
+          if (tlv_len > 2)
+          {
+            res_code[0] = STK_RES_ERR_MISS_VALUE;
+            result = TRUE;
+          }
+          else
+          {
+            res_code[0] = STK_RES_ERR_CMD_DATA;
+          }
+        }
+
+        while (result AND ber_len > 0) // tag and length needed
+        {
+          UBYTE tag_simple;
+
+          p_tag = stk;              // begin of TLV
+          tag_len = ber_len;
+          tag_simple = stk_process_tl(&stk, &ber_len, &tlv_len);
+
+          if (ber_len < tlv_len)    // inconsistent length
+          {
+            if (res_code[0] NEQ STK_RES_ERR_MISS_VALUE)
+            {
+              TRACE_EVENT("ber_len < tlv_len -> STK_RES_ERR_CMD_DATA");
+              res_code[0] = STK_RES_ERR_CMD_DATA;
+            }
+            result = FALSE;
+            break;
+          }
+          else
+            ber_len -= tlv_len;     // remaining BER-TLV
+
+          tag_len -= ber_len;       // length of TLV
+
+          if (tag EQ (tag_simple & ~STK_COMPREHENSION_REQUIRED))
+          {
+#ifdef _SIMULATION_
+            TRACE_EVENT("TC_505A, TC_505B, TC_505C");
+#endif
+            stk += tlv_len;
+            continue;
+          }
+          else
+          {
+            tag = tag_simple;
+            tag_not_found = FALSE;
+          }
+
+          compreh = tag & STK_COMPREHENSION_REQUIRED;
+          tag &= ~STK_COMPREHENSION_REQUIRED;
+
+          do
+          {
+            p_tag_desc = &sat_cmd_list[cmd_i].tag_desc[tag_i];
+            if (tag EQ p_tag_desc->tag)
+            {
+              break; /* tag found !!! */
+            }
+            else if (!p_tag_desc->mand)
+            {
+              tag_i++; /* skip non-mandatory tags */
+            }
+            else /* mandatory tag missed */
+            {
+              i = tag_i;
+              res_code[0] = STK_RES_ERR_MISS_VALUE;
+              while (i < (int)sat_cmd_list[cmd_i].max_tag)
+              {
+                p_tag_desc = &sat_cmd_list[cmd_i].tag_desc[i++];
+                if (tag EQ p_tag_desc->tag AND !p_tag_desc->mand)
+                {
+#ifdef _SIMULATION_
+                  TRACE_EVENT("TC_506");
+#endif
+                  res_code[0] = STK_RES_ERR_CMD_DATA;
+                  break;
+                }
+              }
+              if (!compreh AND i EQ (int)sat_cmd_list[cmd_i].max_tag)
+              {
+#ifdef _SIMULATION_
+                TRACE_EVENT("TC_507");
+#endif
+                res_code[0] = STK_RES_SUCC_PART_COMPR;
+                tag_not_found = TRUE;
+              }
+              break;
+            }
+          } while (tag_i < (int)sat_cmd_list[cmd_i].max_tag OR res_code[0]);
+
+          if (tag_i >= (int)sat_cmd_list[cmd_i].max_tag)
+          {
+            i = (int)sat_cmd_list[cmd_i].tp_i;
+
+            if ((~sat_tp_sim_ability[i] & sat_cmd_list[cmd_i].tp_flag) EQ 0)
+            {
+              break; /* the commmand is being handled outside the SIM */
+            }
+
+            if (compreh)
+            {
+#ifdef _SIMULATION_
+              TRACE_EVENT("TC_502C, TC_504");
+#endif
+              res_code[0] = STK_RES_ERR_CMD_DATA;
+              result = FALSE;
+              break;
+            }
+          }
+          else
+          {
+            p_tag_desc = &sat_cmd_list[cmd_i].tag_desc[tag_i];
+            if (tag NEQ p_tag_desc->tag OR tlv_len < p_tag_desc->min_len)
+            {
+              if (compreh)
+              {
+#ifdef _SIMULATION_
+                TRACE_EVENT("TC_503, TC_506");
+#endif
+                result = FALSE;
+                break;
+              }
+            }
+            else
+              found_tag[tag_i] = stk;   // points to parameters of tag
+          }
+
+          if (tag_not_found)
+          {
+            stk += tlv_len;
+            continue;
+          }
+
+          switch (tag)
+          {
+          case STK_COMMAND_DETAILS_TAG:
+            p_cmd = p_tag;              // for TERMINAL RESPONSE
+            cmd_len = tag_len;
+            cmd_nr = stk[0];
+            cmd_type = stk[1];
+            cmd_qual = stk[2];
+
+            TRACE_FUNCTION_P2("COMMAND_DETAILS: type=0x%02X, qlf=0x%02X",
+                              (int)cmd_type, (int) cmd_qual);
+
+            SIM_EM_PROACTIVE_COMMAND;
+
+            for (i = 1; i < (SHORT)item_of(sat_cmd_list); i++) /* find out if known command */
+            {
+              if (cmd_type EQ sat_cmd_list[i].cmd_type)
+              {
+                cmd_i = i;
+                break;
+              }
+            }
+            if (i EQ item_of(sat_cmd_list))
+            {
+              TRACE_EVENT_P1("UNKNOWN COMMAND TYPE:0x%02X", cmd_type);
+            }
+            break;
+
+          case STK_DEVICE_IDENTITY_TAG:
+#ifdef _SIMULATION_
+            TRACE_EVENT("found SIMPLE_TAG: STK_DEVICE_IDENTITY_TAG");
+#endif
+            break;
+
+          case STK_CHANNEL_DATA_TAG:
+#ifdef _SIMULATION_
+            TRACE_EVENT("found SIMPLE_TAG: STK_CHANNEL_DATA_TAG");
+#endif
+            break;
+
+          case STK_CHANNEL_DATA_LGTH_TAG:
+#ifdef _SIMULATION_
+            TRACE_EVENT("found SIMPLE_TAG: STK_CHANNEL_DATA_LGTH_TAG");
+#endif
+            break;
+
+          case STK_FILE_LIST_TAG:
+            fl_len = tlv_len;
+            break;
+
+          default:
+#ifdef _SIMULATION_
+            TRACE_EVENT_P1("other tag=0x%02X", tag);
+#endif
+            break;
+          }
+          if (++tag_i >= STK_MAX_EXP_TAG) /* incremented index points to next tag_desc entry */
+            break;
+
+          stk += tlv_len;
+        }
+
+        if (!result)
+        {
+          if (found_tag[0] EQ 0)
+          {
+            switch (res_code[0])
+            {
+            case STK_RES_ERR_MISS_VALUE:
+#ifdef _SIMULATION_
+              TRACE_EVENT("TC_501, TC_508");
+#endif
+              memcpy (p->response, &terminal_response_def, SAT_TRSP_MIN_RES);
+              ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_nr = cmd_nr;
+              ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_type = cmd_type;
+              ((T_SIM_TRSP_SIMPLE *)p->response)->res_gnrl = res_code[0];
+              FKT_TerminalResponse (p->response, SAT_TRSP_MIN_RES);
+              break;
+
+            default:
+              break;
+            }
+          }
+          else if (found_tag[0] AND cmd_i NEQ 0)
+          {
+            switch (res_code[0])
+            {
+            case STK_RES_ERR_CMD_DATA:
+#ifdef _SIMULATION_
+              TRACE_EVENT("TC_502A, TC_502B, TC_502C, TC_506");
+#endif
+              memcpy (p->response, &terminal_response_def, SAT_TRSP_MIN_RES);
+              ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_nr = cmd_nr;
+              ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_type = cmd_type;
+              ((T_SIM_TRSP_SIMPLE *)p->response)->res_gnrl = res_code[0];
+              FKT_TerminalResponse (p->response, SAT_TRSP_MIN_RES);
+              break;
+
+            case STK_RES_ERR_MISS_VALUE:
+#ifdef _SIMULATION_
+              TRACE_EVENT("TC_503, TC_509A");
+#endif
+              memcpy (p->response, &terminal_response_def, SAT_TRSP_MIN_RES);
+              ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_nr = cmd_nr;
+              ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_type = cmd_type;
+              ((T_SIM_TRSP_SIMPLE *)p->response)->res_gnrl = res_code[0];
+              FKT_TerminalResponse (p->response, SAT_TRSP_MIN_RES);
+              break;
+
+            default:
+              break;
+            }
+          }
+          else if (cmd_i EQ 0)
+          {
+#ifdef _SIMULATION_
+            TRACE_EVENT("TC_504");
+#endif
+            res_code[0] = STK_RES_ERR_CMD_TYPE;
+            memcpy (p->response, &terminal_response_def, SAT_TRSP_MIN_RES);
+            ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_nr = cmd_nr;
+            ((T_SIM_TRSP_SIMPLE *)p->response)->cmd_type = cmd_type;
+            ((T_SIM_TRSP_SIMPLE *)p->response)->res_gnrl = res_code[0];
+            FKT_TerminalResponse (p->response, SAT_TRSP_MIN_RES);
+          }
+          else
+          {
+            resp_len = stk_build_response (p->response, p_cmd, cmd_len, res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+            TRACE_EVENT("SAT: other error");
+#endif
+            FKT_TerminalResponse (p->response, (USHORT)resp_len);
+          }
+          PFREE (sim_toolkit_ind);
+        }
+        else switch (cmd_type)
+        {
+          case STK_DISPLAY_TEXT:
+          case STK_GET_INKEY:
+          case STK_GET_INPUT:
+          case STK_PLAY_TONE:
+          case STK_SET_UP_MENU:
+          case STK_SELECT_ITEM:
+          case STK_SEND_SMS:
+          case STK_SEND_SS:
+          case STK_SET_UP_CALL:
+
+          case STK_SETUP_EVENT_LIST:
+          case STK_SEND_USSD:
+          case STK_SEND_DTMF:
+          case STK_SETUP_IDLE_TEXT:
+          case STK_LAUNCH_BROWSER:
+          case STK_RUN_AT_CMD:
+          case STK_LANGUAGE_NOTIFICATION:
+#ifdef FF_SAT_E
+          case STK_OPEN_CHANNEL:
+          case STK_CLOSE_CHANNEL:
+          case STK_GET_CHANNEL_STAT:
+#endif /* FF_SAT_E */
+            /*
+             * Operations processed by MMI / MFW
+             */
+            sim_data.sat_session = TRUE;
+            sim_data.ext_sat_cmd = TRUE;
+            PSENDX (MMI, sim_toolkit_ind);
+            break;
+
+          case STK_POLL_INTERVALL:
+            /*
+             * SIM toolkit defines an idle poll interval. The timer in
+             * SIM application is stopped and started with the
+             * new value. A terminal response with the used time
+             * is sent to SIM toolkit.
+             */
+            if (found_tag[2] NEQ NULL)
+            {
+              BOOL org_val;
+              TRACE_EVENT("Idle Polling switched on");
+
+              if (found_tag[2][1] NEQ 0) /* value not "reserved" */
+              {
+                switch (found_tag[2][0])
+                {
+                case 0: /* minutes */
+                  if ((ULONG)found_tag[2][1] * 600L >= (ULONG)cusSatMinPollItv)
+                  {
+                    sim_data.status_time = ((T_TIME)found_tag[2][1]) * 60L * 1000
+                                            - TIMER_LATENCY;
+                    org_val = TRUE;
+                  }
+                  else
+                    org_val = FALSE;
+                  break;
+                case 1: /* seconds */
+                  if ((USHORT)found_tag[2][1] * 10 >= cusSatMinPollItv)
+                  {
+                    sim_data.status_time = ((T_TIME)found_tag[2][1]) * 1000L
+                                            - TIMER_LATENCY;
+                    org_val = TRUE;
+                  }
+                  else
+                    org_val = FALSE;
+                  break;
+                case 2: /* tenth seconds */
+                  if ((USHORT)found_tag[2][1] >= cusSatMinPollItv)
+                  {
+                    sim_data.status_time = ((T_TIME)found_tag[2][1]) * 100L
+                                            - TIMER_LATENCY;
+                    org_val = TRUE;
+                  }
+                  else
+                    org_val = FALSE;
+                  break;
+                default: /* command data not understood */
+                  res_code[0] = STK_RES_ERR_CMD_DATA;
+                  org_val = TRUE;
+                  break; /* return original values */
+                }
+              }
+              else /* return original values */
+              {
+                res_code[0] = STK_RES_ERR_CMD_DATA;
+                org_val = TRUE;
+              }
+
+              resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                             res_code, 1, (UBYTE *)tag_dur, sizeof(tag_dur));
+#ifdef _SIMULATION_
+              TRACE_EVENT("POLL_ITV data not understood");
+#endif
+              if (org_val)
+              {
+                p->response[cmd_len+ 9] = found_tag[2][0];  /* copy unit            */
+                /* copy number of units (1 to 255) or 0 !!! */
+                p->response[cmd_len+10] = found_tag[2][1];
+              }
+              else
+              {
+                sim_data.status_time = ((T_TIME)cusSatMinPollItv) * 100L
+                                        - TIMER_LATENCY;
+                if (cusSatMinPollItv < 0x100)
+                {
+                  p->response[cmd_len+ 9] = 2;     // fits to tenth of seconds
+                  p->response[cmd_len+10] = (UBYTE)cusSatMinPollItv;
+                }
+                else if (cusSatMinPollItv < (0x100*10))
+                {
+                  p->response[cmd_len+ 9] = 1;     // fits to seconds
+                  p->response[cmd_len+10] = (UBYTE)((cusSatMinPollItv / 5 + 1) / 2);
+                }
+                else
+                {
+                  p->response[cmd_len+ 9] = 0;     // fits to minutes
+                  p->response[cmd_len+10] = (UBYTE)((cusSatMinPollItv / 300 + 1) / 2);
+                }
+              }
+            sim_data.idle_polling = TRUE;
+            }
+            else
+            {
+              res_code[0] = STK_RES_ERR_MISS_VALUE;
+              resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                             res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+              TRACE_EVENT("POLL_ITV missing value");
+#endif
+            }
+            FKT_TerminalResponse (p->response, (USHORT)resp_len);
+            PFREE (sim_toolkit_ind);
+
+            if (SIM_IS_FLAG_CLEARED (CALL_ACTIVE) OR
+                sim_data.status_time < THIRTY_SECONDS)
+              TIMER_PSTART( sim_handle,
+                            SIM_TIMER,
+                            sim_data.status_time,
+                            sim_data.status_time);
+            break;
+
+          case STK_PROVIDE_LOCAL_INFO:
+            /*
+             * SIM toolkit request local information from the
+             * SIM application. These informations are:
+             * MCC, MNC, LAC, Cell Identity or IMEI.
+             * SIM application sends this information with
+             * a terminal response to the SIM toolkit.
+             */
+            if(p_cmd EQ NULL) 
+            {
+               TRACE_EVENT("p_cmd is NULL");
+               return;
+            }
+            switch (cmd_qual)
+            {
+              case QLF_PLOI_LOC_INFO:
+                /*
+                 * request location information
+                 */
+#ifdef _SIMULATION_
+                if (sim_data.location_info.c_loc NEQ 0)
+                {
+                  memcpy (p->response, p_cmd, cmd_len);
+                  /* location information available */
+                  memcpy (&p->response[cmd_len], &terminal_response_loci[5], 9);
+                  /* copy MCC, MNC & LAC */
+                  memcpy (&p->response[cmd_len+ 9], &sim_data.location_info.loc[4], 5);
+                  /* copy cell identity */
+                  p->response[cmd_len+14] = sim_data.cell_identity >> 8;
+                  p->response[cmd_len+15] = sim_data.cell_identity & 0xFF;
+                  p->response[cmd_len+ 6] = res_code[0];
+                  resp_len = cmd_len + 16;
+#else
+                if((cl_shrd_get_loc (&loc_info) EQ TRUE) AND
+                   (loc_info.service_mode NEQ NO_SERVICE))
+                {
+                  memcpy (p->response, p_cmd, cmd_len);
+                  /* location information available */
+                  memcpy (&p->response[cmd_len], &terminal_response_loci[5], 9);
+                  /* copy from loc_info to response */
+                  p->response[cmd_len+9]   = loc_info.mcc[1] << 4;
+                  p->response[cmd_len+9]  += loc_info.mcc[0];
+                  p->response[cmd_len+10]  = loc_info.mnc[2] << 4;
+                  p->response[cmd_len+10] += loc_info.mcc[2];
+                  p->response[cmd_len+11]  = loc_info.mnc[1] << 4;
+                  p->response[cmd_len+11] += loc_info.mnc[0];
+                  p->response[cmd_len+12]  = loc_info.lac >> 8;
+                  p->response[cmd_len+13]  = loc_info.lac & 0xff;
+                  p->response[cmd_len+14]  = loc_info.cell_id >> 8;
+                  p->response[cmd_len+15]  = loc_info.cell_id & 0xFF;
+                  
+                  if ( loc_info.service_mode EQ LIMITED_SERVICE )
+                  {
+                    p->response[cmd_len+ 6] = STK_RES_SUCC_LIMITED_SERVICE;
+                  }
+                  else
+                  {
+                    p->response[cmd_len+ 6] = res_code[0];
+                  }
+                  resp_len = cmd_len + 16;
+#endif  /* _SIMULATION_ */
+                }
+                else
+                {
+                  /* location information not available */
+                  res_code[0] = STK_RES_BUSY_ME;
+                  res_code[1] = STK_RES_EXT_NO_SERVICE;
+                  resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                 res_code, 2, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("PLI: local info not available");
+#endif
+                }
+                sim_data.ext_sat_cmd = FALSE;
+                break;
+              case QLF_PLOI_IMEI:
+                /*
+                 * request IMEI
+                 */
+                memcpy (p->response, p_cmd, cmd_len);
+                memcpy (&p->response[cmd_len], &terminal_response_imei[5], 17);
+
+                cl_get_imeisv(CL_IMEI_SIZE,
+                              &p->response[cmd_len + 9],
+                              CL_IMEI_GET_STORED_IMEI);
+                for (i = (int)cmd_len + 8 + CL_IMEI_SIZE;
+                     i > (int)cmd_len + 9; i--)
+                {     /* place nibbles according to 4.08 */
+                  p->response[i] = (p->response[i] & 0xf0) |
+                                   (p->response[i - 1] &  0x0f);
+                }
+                /* i points to first IMEI octet, set 'type of identity' */
+                p->response[i] = (p->response[i] & 0xf0) | 0xA;
+                p->response[cmd_len+8+CL_IMEI_SIZE] &= 0xF;
+                p->response[cmd_len+ 6] = res_code[0];
+                resp_len = cmd_len + 17;
+                sim_data.ext_sat_cmd = FALSE;
+                break;
+              case QLF_PLOI_NTW_MSR:
+                /*
+                 * request network measurement results and BCCH list
+                 */
+                if ((sat_tp_sim_enabled[3] & SAT_TP4_PLI_NMR) EQ 0)
+                {
+                  /* if not effective */
+                  res_code[0] = STK_RES_ERR_NO_SUPPORT;
+                  resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                 res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("PLI: NMR not supported");
+#endif
+                  break;
+                }
+                memcpy (p->response, p_cmd, cmd_len);
+                /* location information available */
+                memcpy (&p->response[cmd_len], &terminal_response_nmr[5], 9);
+                if (get_network_meas (&p->response[cmd_len+9]))
+                {
+                  /*
+                   * set result code
+                   */
+#ifdef _SIMULATION_
+                  p->response[cmd_len+ 6] = res_code[0];
+                  resp_len = cmd_len + 25;
+#else
+                  if ((cl_shrd_get_loc (&loc_info) EQ TRUE) AND
+                      (loc_info.service_mode NEQ NO_SERVICE))
+                  {
+                    if ( loc_info.service_mode EQ LIMITED_SERVICE )
+                    {
+                      p->response[cmd_len+ 6] = STK_RES_SUCC_LIMITED_SERVICE;
+                    }
+                    else
+                    {
+                      p->response[cmd_len+ 6] = res_code[0];
+                    }
+                    resp_len = cmd_len + 25;
+                  }
+                  else
+                  {
+                    res_code[0] = STK_RES_BUSY_ME;
+                    res_code[1] = STK_RES_EXT_NO_SERVICE;
+                    resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                  res_code, 2, NULL, 0);
+#ifdef _SIMULATION_
+                   TRACE_EVENT("PLI: service mode not available");
+#endif /* _SIMULATION_ */
+                  }
+#endif /* _SIMULATION_ */
+                  /*
+                   * Add BCCH list
+                   */
+                  if (get_bcch_chan_list (&p->stk_data))
+                  {
+                    /*
+                     * copy BCCH data list for answer
+                     */
+                    p->response[resp_len] = 0x1D;  /* BCCH channel flag */
+                    p->response[resp_len + 1] = p->stk_data.stk_length;
+                    memcpy (&p->response[resp_len + 2], p->stk_data.stk_parameter,
+                            p->stk_data.stk_length);
+                    resp_len += (2+p->stk_data.stk_length);
+                  }
+                  else
+                  {
+                    /* location information not available */
+                    res_code[0] = STK_RES_BUSY_ME;
+                    res_code[1] = STK_RES_EXT_NO_SERVICE;
+                    resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                   res_code, 2, NULL, 0);
+#ifdef _SIMULATION_
+                    TRACE_EVENT("PLI: BCCH list not available");
+#endif
+                  }
+                }
+                else
+                {
+                  /* location information not available */
+                  res_code[0] = STK_RES_BUSY_ME;
+                  res_code[1] = STK_RES_EXT_NO_SERVICE;
+                  resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                 res_code, 2, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("PLI: measurement not available");
+#endif
+                }
+                sim_data.ext_sat_cmd = FALSE;
+                break;
+              case QLF_PLOI_DTT:
+                /*
+                 * Date, Time and Timezone
+                 */
+                if ((sim_data.stk_profile[7] & SAT_TP8_PLI_DTT) EQ 0)
+                {
+                  /* if not effective */
+                  res_code[0] = STK_RES_ERR_NO_SUPPORT;
+                  resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                 res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("PLI: not supported in TP");
+#endif
+                  break;
+                }
+                /*
+                 * Operations processed by MMI / MFW
+                 */
+                sim_data.ext_sat_cmd = TRUE;
+                PSENDX (MMI, sim_toolkit_ind);
+                break;
+              case QLF_PLOI_LANG_SET:
+               /*
+                * Language Setting to be supported (to be processed by ACI)
+                */
+                if ((sim_data.stk_profile[8] & SAT_TP9_PLI_LANG) EQ 0)
+                {
+                  /* if not effective */
+                  res_code[0] = STK_RES_ERR_NO_SUPPORT;
+                  resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                                 res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("language setting not supported");
+#endif
+                  break;
+                }
+                /*
+                 * To be processed by ACI
+                 */
+                sim_data.sat_session = TRUE;
+                sim_data.ext_sat_cmd = TRUE;
+                PSENDX (MMI, sim_toolkit_ind);
+                break;
+
+              case QLF_PLOI_TIM_ADV:
+                
+                if ((sat_tp_sim_enabled[8] & SAT_TP9_PLI_TIMING_ADV) EQ 0)
+                {
+                  res_code[0] = STK_RES_ERR_NO_SUPPORT;
+                  resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("PLI: timing advance not supported");
+#endif
+                }
+                else
+                {
+                  memset (&tim_adv, 0, sizeof(T_TIM_ADV));
+                  memcpy (p->response, p_cmd, cmd_len);
+                  memcpy (&p->response[cmd_len], &terminal_response_timingadv[5], 11);
+#ifdef _SIMULATION_
+                  p->response[cmd_len+ 6] = res_code[0];
+                  resp_len = cmd_len + 11;
+#else
+                 if(cl_shrd_get_tim_adv (&tim_adv) EQ TRUE)
+                 {
+
+
+                   p->response[cmd_len+9] = tim_adv.me_status;
+                   p->response[cmd_len+10] = tim_adv.tm_adv;
+                   /*
+                   * Set result code.
+                   */
+                   p->response[cmd_len+ 6] = res_code[0];
+                   resp_len = cmd_len + 11;
+                 }
+                 else
+                 {
+                    res_code[0] = STK_RES_BUSY_ME;
+                    resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                  TRACE_EVENT("PLI: Timing Advance not available");
+#endif
+                 }
+#endif /* _SIMULATION_ */
+                }
+
+                sim_data.ext_sat_cmd = FALSE;
+                break;
+              default:
+                /*
+                 * no valid command qualifier
+                 */
+                res_code[0] = STK_RES_ERR_CMD_TYPE;
+                resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                TRACE_EVENT("PLI: type not understood");
+#endif
+                sim_data.ext_sat_cmd = FALSE;
+                break;
+            }
+            if (!sim_data.ext_sat_cmd)   /* may depend on Command Qualifier */
+            {
+              FKT_TerminalResponse (p->response, (USHORT)resp_len);
+              PFREE (sim_toolkit_ind);
+            }
+            break;
+
+          case STK_REFRESH:
+            /*
+             * process SIM REFRESH according to command qualifier
+             */
+            TRACE_EVENT("process SIM REFRESH according to command qualifier");
+
+            /* MALLOC area for CONTEXT SWITCH */
+            if ( sim_data.context_switch_ptr != NULL )
+            {
+              TRACE_EVENT("ERROR!! context_switch_ptr should be NULL - freeing");
+              MFREE ( sim_data.context_switch_ptr );
+              sim_data.context_switch_ptr = NULL;
+            }
+            MALLOC (sim_data.context_switch_ptr, sizeof (T_CONTEXT_SWITCH));
+            memset ( sim_data.context_switch_ptr,0, sizeof (T_CONTEXT_SWITCH));
+
+            /* Set sig_ptr to handle required signal */
+#ifdef TI_PS_FF_AT_P_CMD_CUST
+            if (sim_data.cust_mode EQ 1)
+            {
+              /* Cust_Mode 1 operation setup*/
+              PALLOC(copy_sim_toolkit_ind,SIM_TOOLKIT_IND);
+              memcpy(copy_sim_toolkit_ind,sim_toolkit_ind,sizeof(T_SIM_TOOLKIT_IND));
+              sim_data.context_switch_ptr->sig_ptr = copy_sim_toolkit_ind;
+            }
+            else
+            {
+              /*default operation setup*/
+              sim_data.context_switch_ptr->sig_ptr = sim_toolkit_ind;
+            }
+#else
+            /*default operation setup*/
+            sim_data.context_switch_ptr->sig_ptr = sim_toolkit_ind;
+#endif /* TI_PS_FF_AT_P_CMD_CUST */
+
+            /* Save decoding of original sim_toolkit_ind  signal processed by stk_proactive_polling */
+            offset = (long)found_tag[2] - (long)sim_toolkit_ind;
+            sim_data.context_switch_ptr->tag2 = (UBYTE *)(sim_data.context_switch_ptr->sig_ptr) + offset;
+            sim_data.context_switch_ptr->fl_len = fl_len;
+            offset = (long)p_cmd - (long)sim_toolkit_ind;
+            sim_data.context_switch_ptr->p_cmd = (UBYTE *)(sim_data.context_switch_ptr->sig_ptr) + offset;
+            sim_data.context_switch_ptr->cmd_len = cmd_len;
+            sim_data.context_switch_ptr->res_code[0]=res_code[0];
+            sim_data.context_switch_ptr->res_code[1]=res_code[1];
+
+#ifdef TI_PS_FF_AT_P_CMD_CUST
+            /* functionality is depended on cust_mode */
+            if (sim_data.cust_mode EQ 1)
+            {
+              /* Cust_Mode 1 operation */
+              sim_data.user_confirmation_expected = TRUE;
+
+              /*send Refresh command to MMI*/
+              PSENDX (MMI, sim_toolkit_ind);
+
+              /*REFRESH COMMAND NOW PROCESSED IN stk_sim_refresh_user_res()      */
+              /*note: stk_sim_refresh_user_res() will call process_sim_refresh() */
+              /*      This routine will free sig_ptr, user must free the         */
+              /*      context_switch.                                            */
+
+              /*Terminate Command */
+              break; 
+            }
+
+            else 
+            {
+              /* sim_data.cust_mode EQ 0 */
+              /* process default operation */
+              if ( process_sim_refresh(sim_data.context_switch_ptr) )
+              {
+                /* processed a SIM_RESET. Special case - exit stk_proactive_polling()*/
+                MFREE(p);
+                /* this thread has finished with the context switch so free it.      */
+                MFREE (sim_data.context_switch_ptr);
+                sim_data.context_switch_ptr = NULL;
+                return;   /* exit from stk_proactive_polling() */
+              }
+              else
+              {
+                /* process_sim_refresh() frees signal  sim_data.context_switch_ptr->sig_ptr */
+                /* this thread has finished with the context switch so free it.             */
+                MFREE (sim_data.context_switch_ptr); 
+                sim_data.context_switch_ptr = NULL;
+              }
+            }
+#else
+            /* sim_data.cust_mode EQ 0 */
+            /* process default operation */
+            if ( process_sim_refresh(sim_data.context_switch_ptr) )
+            {
+              /* processed a SIM_RESET. Special case - exit stk_proactive_polling()*/
+              MFREE(p);
+              /* this thread has finished with the context switch so free it.      */
+              MFREE (sim_data.context_switch_ptr);
+              sim_data.context_switch_ptr = NULL;
+              return;   /* exit from stk_proactive_polling() */
+            }
+            else
+            {
+              /* process_sim_refresh() frees signal  sim_data.context_switch_ptr->sig_ptr */
+              /* this thread has finished with the context switch so free it.             */
+              MFREE (sim_data.context_switch_ptr); 
+              sim_data.context_switch_ptr = NULL;
+            }
+#endif /* TI_PS_FF_AT_P_CMD_CUST */
+            break; //end of case STK_REFRESH
+
+#ifdef FF_SAT_E
+          case STK_RECEIVE_DATA:
+            if (stk_dti_bip_receive_data((T_sdu*)&sim_toolkit_ind->stk_cmd, res_code[0]))
+            {
+              /*
+               * message contains TLV elements to display
+               * so forward it to MMI
+               */
+              sim_data.sat_session = TRUE;
+
+              TRACE_EVENT("SEND receive data indication to MMI");
+              PSENDX (MMI, sim_toolkit_ind);
+              TRACE_EVENT("receive data indication to MMI sent");
+            }
+            else
+            {
+              PFREE (sim_toolkit_ind);
+            }
+            break;
+
+          case STK_SEND_DATA:
+            if (stk_dti_bip_send_data((T_sdu*)&sim_toolkit_ind->stk_cmd))
+            {
+              /*
+               * message contains TLV elements to display
+               * so forward it to MMI
+               */
+              sim_data.sat_session = TRUE;
+              PSENDX (MMI, sim_toolkit_ind);
+            }
+            else
+            {
+              PFREE (sim_toolkit_ind);
+            }
+          break;
+#endif /* FF_SAT_E */
+
+          case STK_TIMER_MANAGEMENT:
+          {
+            UBYTE tag_tv[8] = {STK_TIMER_ID_TAG|STK_COMPREHENSION_REQUIRED, STK_TIMER_ID_LEN, 0,
+                               STK_TIMER_VALUE_TAG, STK_TIMER_VALUE_LEN,
+                               0, 0 ,0};
+            tag_tv[2] = found_tag[2][0];
+
+            if ((unsigned)(i = (int)found_tag[2][0] - 1) >= MAX_SAT_TIMER)
+            {               /* invalid Timer identifier */
+              res_code[0] = STK_RES_ERR_CMD_DATA;
+              resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                             res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+              TRACE_EVENT("stk_build_response No 17");
+#endif
+            }
+            /*
+             * Process TIMER MANAGEMENT according to command qualifier
+             */
+            else switch (cmd_qual)
+            {
+            case 0:
+              if (found_tag[3] EQ NULL)
+              {
+                res_code[0] = STK_RES_ERR_MISS_VALUE;
+                resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                TRACE_EVENT("TM: missing parameters");
+#endif
+                break;
+              }
+              /* translate timer value into unit of seconds */
+              tm_val = ((T_TIME)BCD2INT(found_tag[3][0])  * 60 + // hours
+                        (T_TIME)BCD2INT(found_tag[3][1])) * 60 + // minutes
+                        (T_TIME)BCD2INT(found_tag[3][2]);        // seconds
+//TISH, patch for OMAPS00115011, 2007-02-12
+//start
+		if (tm_val==0)
+		{
+                res_code[0] = STK_RES_ERR_CMD_DATA;
+                resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, NULL, 0);
+		  TRACE_ERROR("TR wrong tm value");
+                break;
+		}
+//end
+              sim_data.timer[i].hour = found_tag[3][0];
+              sim_data.timer[i].minute = found_tag[3][1];
+              sim_data.timer[i].second = found_tag[3][2];
+
+              TIMER_START (sim_handle, (USHORT)(i+1), (tm_val * 1000 - TIMER_LATENCY));
+              sim_data.timer[i].active = TRUE;
+              resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                             res_code, 1, tag_tv, 3);
+#ifdef _SIMULATION_
+              TRACE_EVENT("TM: set timer");
+#endif
+              break;
+            case 1:
+            case 2:
+              if (sim_data.timer[i].active)
+              {
+                TIMER_STATUS (sim_handle, (USHORT)(i + 1), &tm_val);
+                tm_val /= 1000;
+                tag_tv[7] = INT2BCD((UBYTE)(tm_val % 60));
+                tm_val /= 60;
+                tag_tv[6] = INT2BCD((UBYTE)(tm_val % 60));
+                tm_val /= 60;
+                if (tm_val < 24)
+                  tag_tv[5] = INT2BCD((UBYTE)tm_val);
+                else
+                {             // set maximum value
+                  tag_tv[7] = tag_tv[6] = 0x59;
+                  tag_tv[5] = 0x23;
+                }
+                if (cmd_qual EQ 1)  /* timer to be stopped */
+                {
+                  TIMER_STOP (sim_handle, (USHORT)(i + 1));
+                  sim_data.timer[i].active = FALSE;
+                }
+                resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, tag_tv, 8);
+#ifdef _SIMULATION_
+                TRACE_EVENT("TM: stop/query timer");
+#endif
+              }
+              else
+              {
+                res_code[0] = STK_RES_BUSY_TIMER_STATE;
+                resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                               res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+                TRACE_EVENT("TM: timer not running");
+#endif
+              }
+              break;
+            default:
+              /*
+               * not supported information request
+               */
+              res_code[0] = STK_RES_ERR_CMD_TYPE;
+              resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                             res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+              TRACE_EVENT("TM: unknown qualifier");
+#endif
+              break;
+            }
+            FKT_TerminalResponse (p->response, (USHORT)resp_len);
+            PFREE (sim_toolkit_ind);
+            break;
+          }
+          default:
+            result = FALSE;
+            res_code[0] = STK_RES_ERR_CMD_TYPE; /* command type not understood */
+            /*
+             * fall through
+            */
+          case STK_POLLING_OFF:
+            /*
+             * SIM toolkit cancels the effect of a previous
+             * POLL INTERVAL command. Polling of the SIM
+             * toolkit is done now all thirty seconds with the
+             * STATUS command, when in a call.
+             */
+            if (result AND SIM_IS_FLAG_SET (PRO_ACTIVE_SIM))
+            {
+              TRACE_EVENT("Idle Polling switched off");
+              sim_data.idle_polling = FALSE;
+             /* there will not be a status command after this .so just force one status command to enable sleep */  
+			  startTimerPollOff = TRUE; 
+              if(SIM_IS_FLAG_SET(CALL_ACTIVE))
+              {
+               /* SIM_TIMER will be restarted, during a call, for
+                * presence detection
+                */
+                sim_data.status_time  = THIRTY_SECONDS;
+              }
+              else
+              {
+                /* timer value set to max, for with a '0', the timer would
+                   run for about one tick
+                 */
+                sim_data.status_time  = 0xFFFFFFFF;
+                TIMER_STOP (sim_handle, SIM_TIMER);
+              }
+
+            }
+          case STK_MORE_TIME:
+            /*
+             * SIM toolkit needs more time.
+             * SIM application sends terminal response with OK.
+             */
+            resp_len = stk_build_response (p->response, p_cmd, cmd_len,
+                                           res_code, 1, NULL, 0);
+#ifdef _SIMULATION_
+            TRACE_EVENT("MORE_TIME");
+#endif
+            FKT_TerminalResponse (p->response, (USHORT)resp_len);
+            PFREE (sim_toolkit_ind);
+            break;
+        }
+      }
+      else
+      {
+#ifdef _SIMULATION_
+        TRACE_EVENT("FKT_Fetch_NEQ_SIM_NO_ERROR");
+#endif
+        PFREE (sim_toolkit_ind);
+      }
+      MFREE (p);
+
+      if (vsi_c_status (VSI_CALLER &in_queue, &out_queue) EQ VSI_OK)
+      {
+        if (in_queue > 0) break; /* break while */
+      }      
+    } /* END while */
+    /*
+     * send end of SAT session indicator
+     */
+    TRACE_FUNCTION ("stk_proactive_polling() send end of SAT session indicator");
+    if ((sim_data.term_resp_sent) AND (sim_data.sat_session))
+    {
+      PALLOC (sim_toolkit_ind, SIM_TOOLKIT_IND);
+      memset (sim_toolkit_ind, 0, sizeof (T_SIM_TOOLKIT_IND));
+#ifdef _SIMULATION_
+      TRACE_EVENT("SAT session ended");
+#endif
+      sim_data.sat_session    = FALSE;
+      sim_data.term_resp_sent = FALSE;
+      PSENDX (MMI, sim_toolkit_ind);
+    }
+  }
+  TRACE_FUNCTION ("stk_proactive_polling() exited");
+}
+
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_stop_all_sat_timers    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Stop all timers started by TIMER MANAGEMENT, if running.
+            Required when card is deactivated or reset.
+
+*/
+
+GLOBAL void stk_stop_all_sat_timers (void)
+{
+  int i;
+
+  for (i = 0; i < MAX_SAT_TIMER; i++)
+  {
+    if (sim_data.timer[i].active)
+    {
+      TIMER_STOP (sim_handle, (USHORT)(i + 1));
+      sim_data.timer[i].active = FALSE;
+    }
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_start_timer_and_poll   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Start STATUS timer and control SIM Toolkit Polling
+
+*/
+
+LOCAL void stk_start_timer_and_poll (void)
+{
+  T_TIME t_val;
+  /*
+   * start status timer if SIM is inserted
+   * for periodic status polling of SIM Toolkit
+   */
+  if ((SIM_IS_FLAG_SET (PRO_ACTIVE_SIM) AND
+       sim_data.idle_polling AND
+       SIM_IS_FLAG_CLEARED (TEST_MODE_POLLING)) OR
+       SIM_IS_FLAG_SET (CALL_ACTIVE))
+  {
+  /*
+   * Start Status Polling
+   */
+    t_val = (SIM_IS_FLAG_SET (CALL_ACTIVE) AND
+             sim_data.status_time > THIRTY_SECONDS)?
+            THIRTY_SECONDS: sim_data.status_time;
+
+    TIMER_PSTART (sim_handle, SIM_TIMER, t_val, t_val);
+  }
+  sim_data.chk_sat_avail = TRUE;
+//  stk_proactive_polling();
+}
+
+#ifdef FF_SAT_E
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_handle_ccd_error       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle CCD error causes.
+
+*/
+
+LOCAL void stk_handle_ccd_error(UBYTE notOK,
+                                UBYTE* status,
+                                UBYTE* general_result,
+                                UBYTE* add_info_result)
+{
+  UBYTE  ccd_error;
+  USHORT parameter_list[MAX_ERR_PAR];
+  TRACE_EVENT_P1("stk_handle_ccd_error(): %d", notOK);
+  /*
+   * handle errors in list
+   */
+  memset (parameter_list, 0, sizeof(parameter_list));
+  ccd_error = ccd_getFirstError(CCDENT_SAT, parameter_list);
+
+  if (notOK EQ ccdWarning)
+  {
+    while (ccd_error NEQ ERR_NO_MORE_ERROR)
+    {
+      switch (ccd_error)
+      {
+      case ERR_COMPREH_REQUIRED:
+        /*
+         * comprehension required
+         */
+        TRACE_ERROR("CCD_WARNING=ERR_COMPREH_REQUIRED");
+        if (*status EQ SIM_CCD_OK)
+        {
+          *general_result  = RSLT_UNKN_DATA;
+          *add_info_result = ADD_NO_CAUSE;
+          *status          = SIM_CCD_RETURN;
+        }
+        break;
+
+      case ERR_IE_NOT_EXPECTED:
+        /*
+         * unexpected element
+         */
+        TRACE_ERROR("CCD_WARNING=ERR_IE_NOT_EXPECTED");
+        if (*status EQ SIM_CCD_OK)
+        {
+          *general_result  = RSLT_PERF_PART_CMPR;
+          *add_info_result = ADD_NO_CAUSE;
+        }
+        break;
+
+      case ERR_MAND_ELEM_MISS:
+        /*
+         * mandatory elements missing
+         */
+        TRACE_ERROR("CCD_WARNING=ERR_MAND_ELEM_MISS");
+        *general_result  = RSLT_ERR_REQ_VAL;
+        *add_info_result = ADD_NO_CAUSE;
+        *status          = SIM_CCD_RETURN;
+        break;
+
+      case ERR_MSG_LEN:
+        TRACE_ERROR("CCD_WARNING=ERR_MSG_LEN (TC_509B)");
+        *general_result  = RSLT_PERF_SUCCESS;
+        *add_info_result = ADD_NO_CAUSE;
+        *status          = SIM_CCD_OK;
+        break;
+
+      default:
+        TRACE_ERROR("CCD_WARNING ignored");
+        TRACE_EVENT_P1("ccd_error=0x%02X", ccd_error);
+        break;
+      }
+      memset (parameter_list,0, sizeof(parameter_list));
+      ccd_error = ccd_getNextError (CCDENT_SAT, parameter_list);
+    }
+  }
+  else /* ccdError */
+  {
+    while (ccd_error NEQ ERR_NO_MORE_ERROR)
+    {
+      switch (ccd_error)
+      {
+      case ERR_COMPREH_REQUIRED:
+        /*
+         * comprehension required
+         */
+        TRACE_ERROR("CCD_ERROR=ERR_COMPREH_REQUIRED");
+        if (*status EQ SIM_CCD_OK)
+        {
+          *general_result  = RSLT_UNKN_DATA;
+          *add_info_result = ADD_NO_CAUSE;
+          *status          = SIM_CCD_RETURN;
+        }
+        break;
+
+      case ERR_IE_NOT_EXPECTED:
+        /*
+         * unexpected element
+         */
+        TRACE_ERROR("CCD_ERROR=ERR_IE_NOT_EXPECTED");
+        if (*status EQ SIM_CCD_OK)
+        {
+          *general_result  = RSLT_PERF_PART_CMPR;
+          *add_info_result = ADD_NO_CAUSE;
+        }
+        break;
+
+      case ERR_MAND_ELEM_MISS:
+        /*
+         * mandatory elements missing
+         */
+        TRACE_ERROR("CCD_ERROR=ERR_MAND_ELEM_MISS");
+        *general_result  = RSLT_ERR_REQ_VAL;
+        *add_info_result = ADD_NO_CAUSE;
+        *status          = SIM_CCD_RETURN;
+        break;
+
+      case ERR_MSG_LEN:
+        TRACE_ERROR("CCD_ERROR=ERR_MSG_LEN");
+        *general_result  = RSLT_UNKN_DATA;
+        *add_info_result = ADD_NO_CAUSE;
+        *status          = SIM_CCD_DISCARD;
+        break;
+
+      default:
+        TRACE_ERROR("CCD_ERROR ignored");
+        TRACE_EVENT_P1("ccd_error=0x%02X", ccd_error);
+        break;
+      }
+      memset (parameter_list,0, sizeof(parameter_list));
+      ccd_error = ccd_getNextError (CCDENT_SAT, parameter_list);
+    }
+  }
+}
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_bip_decode_stk_command |
++--------------------------------------------------------------------+
+
+  PURPOSE : First step of decoding SEND DATA and RECEIVE DATA message.
+
+*/
+
+LOCAL void stk_bip_decode_stk_command(T_sdu*          message,
+                                      T_cmd_details*  cmd_details,
+                                      UBYTE*          status,
+                                      UBYTE*          general_result,
+                                      UBYTE*          add_info_result)
+{
+  UBYTE ccdRet;
+  MCAST(stk_cmd, STK_CMD);
+  memset(stk_cmd, 0, sizeof(T_STK_CMD));
+  /*
+   * decode toolkit command
+   */   
+  ccdRet = ccd_decodeMsg (CCDENT_SAT,
+                          DOWNLINK,
+                          (T_MSGBUF *) message,
+                          (UBYTE    *) _decodedMsg,
+                          STK_CMD);
+
+#ifdef _SIMULATION_
+  TRACE_EVENT_P1("ccdRet@bip_decode_stk_command: %d", ccdRet);
+#endif 
+
+  if ((stk_cmd->v_pas_cmd) AND (stk_cmd->pas_cmd.v_cmd_details))
+  {
+    /*
+     * store command details
+     */
+    *cmd_details = stk_cmd->pas_cmd.cmd_details;
+
+    if (ccdRet NEQ ccdOK)
+    {
+      /*
+       * handle errors in list
+       */
+      stk_handle_ccd_error(ccdRet, status, general_result, add_info_result);
+    }
+    if ((stk_cmd->pas_cmd.v_cmd_prms EQ FALSE) OR
+       (stk_cmd->pas_cmd.v_dev_ids EQ FALSE))
+    {
+      /*
+       * no Channel Data (Length) element present or
+       * no Device Identities element present
+       * Error, required values are missing
+       */
+      *general_result  = RSLT_ERR_REQ_VAL;
+      *add_info_result = ADD_NO_CAUSE;
+      *status          = SIM_CCD_RETURN;
+    }
+    if (*status EQ SIM_CCD_OK)
+    {
+      int i = 0;
+      while (tbl_device_src_id[i])
+      {
+        if (stk_cmd->pas_cmd.dev_ids.dest_dev EQ tbl_device_src_id[i])
+         break;
+
+        i++;
+      }
+      if (tbl_device_src_id[i] EQ 0)
+      {
+        /*
+         * device id not valid
+         */
+        *general_result  = RSLT_UNKN_DATA;
+        *add_info_result = ADD_NO_CAUSE;
+        *status          = SIM_CCD_RETURN;
+      }
+      else if /* norm sim_data.bip_ch_id for 11.14/12.7 conform */
+          ((sim_data.bip_state EQ SIM_BIP_CLOSED) OR
+         (stk_cmd->pas_cmd.dev_ids.dest_dev NEQ (sim_data.bip_ch_id | 0x020)))
+      {
+        /*
+         * BIP error, Channel identifier not valid
+         */
+        *general_result  = RSLT_BEARIND_PERR;
+        *add_info_result = ADD_BIP_CHANID_NT_VLD;
+        *status          = SIM_CCD_RETURN;
+      }
+      else
+      {
+        /*
+         * store command parameters
+         */
+        sim_data.bip_cmd_prms = stk_cmd->pas_cmd.cmd_prms;
+      }
+    }
+  }
+  else
+  {
+    /*
+     * incomplete message
+     */
+    *general_result  = RSLT_ERR_REQ_VAL;
+    *add_info_result = ADD_NO_CAUSE;
+    *status          = SIM_CCD_RETURN;
+    /*
+     * set Command Details object values to 0x00
+     */
+    cmd_details->cmd_nr  = 0;
+    cmd_details->cmd_typ = 0;
+    cmd_details->cmd_qlf = 0;
+  }
+} /* stk_bip_decode_stk_command */
+
+/*
++-----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                             |
+| STATE   : code                ROUTINE : stk_dti_send_data                   |
++-----------------------------------------------------------------------------+
+
+  PURPOSE : Create and send a DTI Data primitive.
+
+*/
+
+LOCAL void stk_dti_send_data()
+{
+  T_desc2* temp_desc1;
+  /*
+   * send DTI data primitive
+   */
+  PALLOC_DESC2 (dti_data_ind, DTI2_DATA_IND);
+
+#ifdef _SIMULATION_
+  dti_data_ind->parameters.p_id       = DTI_PID_UOS;
+  dti_data_ind->parameters.st_lines.st_flow      = DTI_FLOW_ON;
+  dti_data_ind->parameters.st_lines.st_line_sa   = DTI_SA_ON;
+  dti_data_ind->parameters.st_lines.st_line_sb   = DTI_SB_ON;
+  dti_data_ind->parameters.st_lines.st_break_len = DTI_BREAK_OFF;
+#endif /* _SIMULATION_ */
+  switch(sim_data.con_type)
+  {
+
+    case SIM_CON_TYPE_UDP:
+      MALLOC(temp_desc1, (USHORT)(sizeof(T_desc2) - 1 +
+                                  sizeof(T_SRC_DES)));
+      memcpy(temp_desc1->buffer,
+             &sim_data.udp_parameters,
+             sizeof(T_SRC_DES));/*lint !e419  Apparent data overrun for function*/
+      temp_desc1->len                = sizeof(T_SRC_DES);
+      temp_desc1->next               = sim_data.data_to_send.first;
+      sim_data.data_to_send.first    = (ULONG)temp_desc1;
+      sim_data.data_to_send.list_len+= temp_desc1->len;
+      break;
+
+    case SIM_CON_TYPE_IP:
+      dti_data_ind->parameters.p_id = DTI_PID_IP;
+      break;
+
+    case SIM_CON_TYPE_SERIAL:
+      dti_data_ind->parameters.st_lines.st_flow      = DTI_FLOW_ON;
+      dti_data_ind->parameters.st_lines.st_line_sa   = DTI_SA_ON;
+      dti_data_ind->parameters.st_lines.st_line_sb   = DTI_SB_ON;
+      dti_data_ind->parameters.st_lines.st_break_len = DTI_BREAK_OFF;
+      break;
+  }
+  dti_data_ind->desc_list2       = sim_data.data_to_send;
+  sim_data.data_to_send.first    = (ULONG)NULL;
+  sim_data.data_to_send.list_len = 0;
+  dti_send_data(sim_data.hDTI, 0, 0, 0, dti_data_ind);
+} /* stk_dti_send_data() */
+
+/*
++-----------------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                             |
+| STATE   : code                ROUTINE : stk_bip_send_data_terminal_response |
++-----------------------------------------------------------------------------+
+
+  PURPOSE : Send a Terminal Response message for a SEND DATA message.
+
+*/
+
+LOCAL void stk_bip_send_data_terminal_response(UBYTE general_result,
+                                               UBYTE add_info_result)
+{
+  T_sdu*  temp_sdu;
+  UBYTE   ccdRet;
+
+  /*
+   * memory for encoded message
+   */
+  MALLOC(temp_sdu, (USHORT)(sizeof(T_sdu) - 1 + MAX_STK_CMD));
+  temp_sdu->l_buf = MAX_STK_CMD << 3;
+  temp_sdu->o_buf = 0;
+
+  CCD_START;
+  {
+    MCAST(term_resp, TERM_RESP);
+    memset(term_resp, 0, sizeof(T_TERM_RESP));
+
+    /*
+     * set Command details
+     */
+    term_resp->v_cmd_details = TRUE;
+    term_resp->cmd_details   = sim_data.bip_tx_cmd_details;
+    /*
+     * set set Device identities
+     */
+    term_resp->v_dev_ids        = TRUE;
+    term_resp->dev_ids.src_dev  = DEV_SRC_ME;
+    term_resp->dev_ids.dest_dev = DEV_DST_SIM;
+    /*
+     * set Result
+     */
+    term_resp->v_res   = TRUE;
+    term_resp->res.gen = general_result;
+    switch(general_result)
+    {
+      case RSLT_ME_UNAB_PROC:
+      case RSLT_NTW_UNAB_PROC:
+      case RSLT_LABRWS_GENERIC:
+      case RSLT_SS_ERR:
+      case RSLT_SMS_ERR:
+      case RSLT_USSD_ERR:
+      case RSLT_CC_SIM_PRM:
+      case RSLT_BEARIND_PERR:
+        /*
+         * one byte for additional information
+         */
+        term_resp->res.v_add        = TRUE;
+        term_resp->res.add.l_add    = 1 << 3;
+        term_resp->res.add.o_add    = 0;
+        term_resp->res.add.b_add[0] = add_info_result;
+        break;
+    }
+    /*
+     * set Channel Data Length
+     */
+    term_resp->v_chan_dat_lth = TRUE;
+    if ((SIM_CLASS_E_BUFFER_SIZE - sim_data.data_to_send.list_len) > 255)
+    {
+      /*
+       * more than 255 bytes are available in TX buffer
+       */
+      term_resp->chan_dat_lth = 0xff;
+    }
+    else
+    {
+      term_resp->chan_dat_lth = SIM_CLASS_E_BUFFER_SIZE -
+                                sim_data.data_to_send.list_len;
+    }
+    /*
+     * encode message
+     */
+    ccdRet = ccd_codeMsg (CCDENT_SAT,
+                          UPLINK,
+                          (T_MSGBUF *) temp_sdu,
+                          (UBYTE    *) _decodedMsg,
+                          TERM_RESP);
+  }
+  CCD_END;
+  /*
+   * send Terminal Response
+   */
+  if (ccdRet NEQ ccdOK)
+  {
+    TRACE_EVENT_P1("SEND DATA: CCD Coding Error: %d",ccdRet );
+  }
+  else
+  {
+    FKT_TerminalResponse (temp_sdu->buf, (USHORT)(temp_sdu->l_buf >> 3));
+  }
+  MFREE(temp_sdu);
+} /* stk_bip_send_data_terminal_response() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_close_dti_connection   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Close DTI connection.
+
+  PARAMETER: The open parameter indicates if the DTI connection is
+             still open or already closed.
+
+*/
+
+LOCAL void stk_close_dti_connection(UBYTE close)
+{
+#ifdef _SIMULATION_
+  TRACE_FUNCTION ("stk_close_dti_connection()");
+#endif
+#ifdef _SIMULATION_
+  TRACE_EVENT_P1(" |___-->: sim_data.dti_connection_state=0x%02X", sim_data.dti_connection_state);
+#endif
+  if (sim_data.dti_connection_state NEQ SIM_DTI_CONNECTION_CLOSED)
+  {
+     /*
+     * close UDP connection
+     */
+    if (sim_data.con_type EQ SIM_CON_TYPE_UDP)
+    {
+      /*
+       * close currently used port
+       */
+      if ((sim_data.dti_connection_state NEQ SIM_DTI_CONNECTION_BIND) AND
+         (hCommUDP >= VSI_OK))
+      {
+        PALLOC(udp_closeport_req, UDP_CLOSEPORT_REQ);
+        udp_closeport_req->port = sim_data.udp_parameters.src_port[0];
+        udp_closeport_req->port = (udp_closeport_req->port << 8);
+        udp_closeport_req->port+= sim_data.udp_parameters.src_port[1];
+        PSEND(hCommUDP, udp_closeport_req);
+      }
+      /*
+       * release VSI channel
+       */
+      if (hCommUDP >= VSI_OK)
+      {
+        vsi_c_close (VSI_CALLER hCommUDP);
+      }
+      hCommUDP = VSI_ERROR;
+    }
+    /*
+     * disconnect BIP channel
+     */
+    if (sim_data.bip_state EQ SIM_BIP_CONNECTED)
+    {
+      sim_data.bip_state = SIM_BIP_OPEN;
+      /*
+       * stop release timer
+       */
+      if (sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED)
+      {
+        if (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+        {
+#ifdef _SIMULATION_
+          TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif
+          TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+        }
+        sim_data.bip_timer_state = SIM_BIP_TIMER_DISCONNECTED;
+      }
+    }
+    /*
+     * close DTI connection
+     */
+    sim_data.dti_connection_state = SIM_DTI_CONNECTION_CLOSED;
+    if (close)
+    {
+      dti_close(sim_data.hDTI, 0, 0, 0, FALSE);
+    }
+#ifdef _SIMULATION_
+TRACE_EVENT_P1("stk_close_dti_connection: sim_data.dti_connection_state=0x%02X", sim_data.dti_connection_state);
+#endif
+  }
+} /* stk_close_dti_connection() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_close_bip_channel      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Close Bearer Independent Protocol Channel.
+
+*/
+
+LOCAL void stk_close_bip_channel(UBYTE general_result,
+                                 UBYTE add_info_result)
+{
+  T_desc2* temp_desc1;
+  T_desc2* temp_desc2;
+
+  if (sim_data.bip_state NEQ SIM_BIP_CLOSED)
+  {
+    /*
+     * set BIP to close
+     */
+    sim_data.bip_state = SIM_BIP_CLOSED;
+    /*
+     * stop release timer if used
+     */
+    if (sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED)
+    {
+      if (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+      {
+#ifdef _SIMULATION_
+        TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif
+        TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+      }
+      sim_data.bip_timer_state = SIM_BIP_TIMER_DISCONNECTED;
+    }
+    /*
+     * send Terminal Response
+     */
+    if (sim_data.bip_tx_state EQ SIM_BIP_TX_SEND)
+    {
+      stk_bip_send_data_terminal_response(general_result, add_info_result);
+      /*
+       * close channel is not triggered from a proactive_polling function call
+       * so adjust timer and start polling
+       */
+      stk_start_timer_and_poll();
+    }
+    /*
+     * release suspension
+     */
+    sim_data.bip_suspend = FALSE;
+    /*
+     * release RX and TX buffer
+     */
+    temp_desc1 = (T_desc2*)sim_data.data_to_send.first;
+    while(temp_desc1)
+    {
+      temp_desc2 = temp_desc1;
+      temp_desc1 = (T_desc2*)temp_desc1->next;
+      MFREE(temp_desc2);
+    }
+    sim_data.data_to_send.first         = (ULONG)NULL;
+    sim_data.data_to_send.list_len      = 0;
+    sim_data.prev_data_to_send.first    = (ULONG)NULL;
+    sim_data.prev_data_to_send.list_len = 0;
+#ifdef _SIMULATION_
+    TRACE_EVENT("bip_tx_state = IDLE");
+#endif
+    sim_data.bip_tx_state               = SIM_BIP_TX_IDLE;
+    temp_desc1 = (T_desc2*)sim_data.received_data.first;
+    while(temp_desc1)
+    {
+      temp_desc2 = temp_desc1;
+      temp_desc1 = (T_desc2*)temp_desc1->next;
+      MFREE(temp_desc2);
+    }
+    sim_data.received_data.first    = (ULONG)NULL;
+    sim_data.received_data.list_len = 0;
+    sim_data.received_data_pos      = 0;
+#ifdef _SIMULATION_
+    TRACE_EVENT("bip_rx_state = IDLE");
+#endif
+    sim_data.bip_rx_state           = SIM_BIP_RX_IDLE;
+  }
+} /* stk_close_bip_channel() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_inform_mmi         |
++--------------------------------------------------------------------+
+
+  PURPOSE : Informs MMI if the requested actions have been done.
+
+*/
+
+LOCAL void stk_dti_inform_mmi (UBYTE dti_conn_req, UBYTE bip_conn_req )
+{
+  UBYTE dti_conn_done;
+  UBYTE bip_conn_done;
+#if _SIMULATION_
+  TRACE_FUNCTION ("stk_dti_inform_mmi()");
+#endif
+  /*
+   * set stutus
+   */
+  dti_conn_done = 0;
+  bip_conn_done = 0;
+
+  if (sim_data.bip_state EQ SIM_BIP_CLOSED)
+  {
+    bip_conn_done |= SIM_BIP_CLOSE_CHANNEL;
+  }
+  else
+  {
+    bip_conn_done |= SIM_BIP_OPEN_CHANNEL;
+    /*
+     * Only if BIP channel not closed, deal with its suspension state
+     */   
+    if (sim_data.bip_suspend)
+    {
+      bip_conn_done |= SIM_BIP_CHANNEL_SUSPENDED;
+    }
+    else
+    {
+      bip_conn_done |= SIM_BIP_CHANNEL_RESUMED;
+    }
+  }
+  
+  if (sim_data.dti_connection_state  EQ SIM_DTI_CONNECTION_OPEN)
+  {
+    dti_conn_done = SIM_DTI_CONNECT;
+  }
+
+  if (sim_data.dti_connection_state  EQ SIM_DTI_CONNECTION_CLOSED)
+  {
+    dti_conn_done = SIM_DTI_DISCONNECT;
+  }
+
+  /*
+   * inform MMI
+   */
+  if (  /* reguirements REALLY fullfilled in code, then confirm or indicate */
+        /* else no reaction at all !! */
+       (((bip_conn_req & bip_conn_done) EQ bip_conn_req) OR (bip_conn_req EQ SIM_BIP_UNKNOWN)) AND
+        ((dti_conn_req EQ dti_conn_done)OR (dti_conn_req EQ SIM_DTI_UNKNOWN)) AND
+       (~(UCHAR)((dti_conn_req EQ SIM_DTI_UNKNOWN) AND (bip_conn_req EQ SIM_BIP_UNKNOWN)))
+     ) 
+  {
+     if (sim_data.sim_dti_req)
+     {
+        /*
+         * send DTI confirm primitive
+         */
+        PALLOC(sim_dti_cnf, SIM_DTI_CNF);
+        sim_dti_cnf->link_id   = sim_data.sim_dti_req->link_id;
+        sim_dti_cnf->dti_conn  = dti_conn_done;
+        PSEND(hCommMMI, sim_dti_cnf);
+        /*
+         * free request primitive
+         */
+        PFREE(sim_data.sim_dti_req);
+        sim_data.sim_dti_req = NULL;
+      }
+      else if (sim_data.sim_bip_req)
+      {
+        /*
+         * send BIP confirm primitive
+         */
+        PALLOC(sim_bip_cnf, SIM_BIP_CNF);
+        sim_bip_cnf->bip_ch_id = sim_data.sim_bip_req->bip_ch_id;
+        sim_bip_cnf->bip_conn  = bip_conn_done;
+        PSEND(hCommMMI, sim_bip_cnf);
+        /*
+         * free request primitive
+         */
+        PFREE(sim_data.sim_bip_req);
+        sim_data.sim_bip_req = NULL;
+      }
+      else
+      {
+        /*
+         * send indication primitive
+         */
+        PALLOC(sim_dti_bip_ind, SIM_DTI_BIP_IND);
+        sim_dti_bip_ind->link_id   = sim_data.link_id;
+        sim_dti_bip_ind->dti_conn  = dti_conn_done;        
+        sim_dti_bip_ind->bip_ch_id = sim_data.bip_ch_id;
+        sim_dti_bip_ind->bip_conn  = bip_conn_done;
+        PSEND(hCommMMI, sim_dti_bip_ind);
+      }
+  } /* and if (requirements fullfilled) */
+} /* stk_dti_inform_mmi() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_connection_opened  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle CONNECTION OPENED signal from DTILIB.
+
+*/
+
+GLOBAL void stk_dti_connection_opened (void)
+{
+  TRACE_FUNCTION ("stk_dti_connection_opened()");
+
+  switch(sim_data.dti_connection_state)
+  {
+    case SIM_DTI_CONNECTION_SETUP:
+      sim_data.dti_connection_state = SIM_DTI_CONNECTION_OPEN;
+      /*
+       * send confirm primitive
+       */
+      stk_dti_inform_mmi(sim_data.sim_dti_req->dti_conn, (UBYTE) SIM_BIP_UNKNOWN);
+      /* fall through */
+    case SIM_DTI_CONNECTION_OPEN:
+      /*
+       * connect BIP with DTI
+       */
+      if (sim_data.bip_state EQ SIM_BIP_OPEN)
+      {
+        sim_data.bip_state = SIM_BIP_CONNECTED;
+        if (sim_data.bip_release_time EQ SIM_NO_AUTO_RELEASE)
+        {
+          sim_data.bip_timer_state = SIM_BIP_TIMER_NOT_USED;
+        }
+        else if (sim_data.bip_suspend)
+        {
+          sim_data.bip_timer_state = SIM_BIP_TIMER_SUSPENDED;
+        }
+        else
+        {
+          sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+        }
+      }
+      break;
+
+    default:
+      /*
+       * wrong state
+       * so close DTI connection
+       * and inform MMI
+       */
+      TRACE_ERROR("DTI_CONNECTION_OPENED in wrong state");
+      stk_close_dti_connection(TRUE);
+      stk_dti_inform_mmi(SIM_DTI_DISCONNECT, (UBYTE) SIM_BIP_UNKNOWN);
+      break;
+  }
+  /*
+   * reset RX, TX and timer
+   */
+  sim_data.dti_rx_state = SIM_DTI_RX_IDLE;
+  sim_data.dti_tx_state = SIM_DTI_TX_IDLE;
+#if 0 /*###jk:OK?*/
+  if (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+  {
+    sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_
+    TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif
+    TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+  }
+  /*
+   * update timer and DTI states
+   */
+  if ((sim_data.bip_state EQ SIM_BIP_CONNECTED) AND
+     (sim_data.bip_rx_state EQ SIM_BIP_RX_IDLE))
+  {
+    /*
+     * start reception
+     */
+    sim_data.dti_rx_state = SIM_DTI_RX_READY;
+    dti_start(sim_data.hDTI, 0, 0, 0);
+    /*
+     * start timer
+     */
+    if ((sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED) AND
+        (sim_data.bip_tx_state EQ SIM_BIP_TX_IDLE)
+       )
+    {
+      /*
+       * no data trafic on the BIP channel,
+       * so use the timer
+       */
+      sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_
+      TRACE_EVENT("SIM_BIP_TIMER: start in stk_dti_connection_opened()");
+#endif
+      TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+    }
+  }
+ #endif /*###jk:OK?*/
+} /* stk_dti_connection_opened() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_connection_closed  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle CONNECTION CLOSED signal from DTILIB.
+
+*/
+
+GLOBAL void stk_dti_connection_closed (void)
+{
+  TRACE_FUNCTION ("stk_dti_connection_closed()");
+
+  /*
+   * close DTI connection
+   */
+  stk_close_dti_connection(FALSE);
+  /*
+   * inform MMI about disconnection
+   */
+  stk_dti_inform_mmi(SIM_DTI_DISCONNECT, (UBYTE) SIM_BIP_UNKNOWN);
+} /* stk_dti_connection_closed() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_data_received      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Deal with incomming DTI data primitives.
+
+*/
+
+GLOBAL void stk_dti_data_received (T_DTI2_DATA_IND* dti_data_ind)
+{
+  UBYTE   ccdRet;
+  UBYTE   dummy[4];
+  T_sdu*  temp_sdu;
+  T_desc2* temp_desc1;
+  T_desc2* temp_desc2;
+
+ TRACE_FUNCTION ("stk_dti_data_received()");
+
+#ifdef _SIMULATION_
+  /*
+   * copy bytes of T_SRC_DES struct in extra descriptor
+   * this is a requirement of the DTI communication with UDP, but it should
+   * not have any side affects in case of communication with other entities
+   */
+  if ((dti_data_ind->desc_list2.first NEQ (ULONG)NULL) AND
+     (dti_data_ind->desc_list2.list_len >= sizeof(T_SRC_DES)))
+  {
+    T_desc2 *old_desc, *addr_desc, *test_desc, *next_desc;
+    USHORT  i, j;
+
+    old_desc = (T_desc2 *)dti_data_ind->desc_list2.first;
+
+    /*
+     * build the T_SRC_DES for IP-addresses and ports
+     */
+    MALLOC(addr_desc, (USHORT)(sizeof(T_desc2) - 1 + sizeof(T_SRC_DES)));
+    addr_desc->len = sizeof(T_SRC_DES);
+    j = 0;
+    for(i=0; i < addr_desc->len; i++)
+    {
+      while(j >= old_desc->len)
+      {
+        next_desc = (T_desc2*)old_desc->next;
+        MFREE(old_desc);
+        old_desc = next_desc;
+        j = 0;
+      }
+      addr_desc->buffer[i] = old_desc->buffer[j];
+      j++;
+    }
+
+    /*
+     *  Build the desc for the data
+     */
+    if (j < old_desc->len)
+    {
+      MALLOC(test_desc, (USHORT)(sizeof(T_desc2) - 1 + old_desc->len - j));
+      test_desc->len  = old_desc->len - j;
+      test_desc->next = old_desc->next;
+      for(i=0; i < test_desc->len; i++)
+      {
+        test_desc->buffer[i] = old_desc->buffer[j];
+        j++;
+      }
+    }
+    else
+    {
+      test_desc = (T_desc2*)old_desc->next;
+    }
+    MFREE(old_desc);
+
+    dti_data_ind->desc_list2.first = (ULONG)addr_desc;
+    addr_desc->next = (ULONG)test_desc;
+
+  }
+#endif /* _SIMULATION_ */
+  /*
+   * take data
+   */
+  temp_desc1 = (T_desc2*)dti_data_ind->desc_list2.first;
+  /*
+   * free primitive
+   */
+  PFREE(dti_data_ind);
+  /*
+   *
+   */
+  switch(sim_data.con_type)
+  {
+/* --67 asd; ###jk test error for image*/
+    case SIM_CON_TYPE_UDP:
+      /*
+       * free first descriptor
+       */
+      temp_desc2 = temp_desc1;
+      if (temp_desc1)
+      {
+        temp_desc1 = (T_desc2*)temp_desc1->next;
+      }
+      MFREE(temp_desc2);
+      /* fall through */
+    case SIM_CON_TYPE_IP:
+      /*
+       * store data
+       */
+      if (sim_data.received_data.first EQ (ULONG)NULL)
+      {
+        sim_data.received_data.first = (ULONG)temp_desc1;
+      }
+      else
+      {
+        /*
+         * error
+         * free received data
+         */
+        TRACE_ERROR("DTI data received, but still data in RX buffer");
+        while(temp_desc1)
+        {
+          temp_desc2 = temp_desc1;
+          temp_desc1 = (T_desc2*)temp_desc1->next;
+          MFREE(temp_desc2);
+        }
+        temp_desc1 = NULL;
+      }
+      break;
+
+    case SIM_CON_TYPE_SERIAL:
+      /*
+       * store data
+       */
+      if (sim_data.received_data.first EQ (ULONG)NULL)
+      {
+        sim_data.received_data.first = (ULONG)temp_desc1;
+      }
+      else
+      {
+        /*
+         * error, but concatinate data
+         */
+        TRACE_ERROR("DTI data received, but still data in RX buffer");
+        /*
+         * find last descriptor
+         */
+        temp_desc2 = (T_desc2*)sim_data.received_data.first;
+        while(temp_desc2->next NEQ (ULONG)NULL)
+        {
+          temp_desc2 = (T_desc2*)temp_desc2->next;
+        }
+        temp_desc2->next = (ULONG)temp_desc1;
+      }
+      break;
+  }
+  /*
+   * update list length
+   */
+  while(temp_desc1)
+  {
+    sim_data.received_data.list_len+= temp_desc1->len;
+    temp_desc1                      = (T_desc2*)temp_desc1->next;
+  }
+
+  if (sim_data.received_data.list_len)
+  {
+    /*
+     * change state of BIP RX and stop timer
+     */
+#ifdef _SIMULATION_
+    TRACE_EVENT("bip_rx_state = DATA");
+#endif
+    sim_data.bip_rx_state = SIM_BIP_RX_DATA;
+    if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+        (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+       )
+    {
+      sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_
+      TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif
+      TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+    }
+    /*
+     * stop reception
+     */
+    sim_data.dti_rx_state = SIM_DTI_RX_IDLE;
+    dti_stop(sim_data.hDTI, 0, 0, 0);
+    /*
+     * inform SIM card
+     */
+    if (sim_data.event_data_avail EQ SIM_EVENT_ENABLE)
+    {
+      CCD_START;
+      {
+        MCAST(env_cmd, ENV_CMD);
+        memset(env_cmd, 0, sizeof(T_ENV_CMD));
+
+        /*
+         * Event Download Command
+         */
+        env_cmd->v_evd_cmd = TRUE;
+        /*
+         * Event List
+         */
+        env_cmd->evd_cmd.v_ev_list        = TRUE;
+        env_cmd->evd_cmd.ev_list.c_event  = 1;
+        env_cmd->evd_cmd.ev_list.event[0] = EVENT_DATA_AVAIL;
+        /*
+         * Device Identities
+         */
+        env_cmd->evd_cmd.v_dev_ids        = TRUE;
+        env_cmd->evd_cmd.dev_ids.src_dev  = DEV_SRC_ME;
+        env_cmd->evd_cmd.dev_ids.dest_dev = DEV_DST_SIM;
+        /*
+         * Channel Satus
+         */
+        env_cmd->evd_cmd.v_chan_stat              = TRUE;
+        env_cmd->evd_cmd.chan_stat.chan_id        = sim_data.bip_ch_id & 0x07;
+        env_cmd->evd_cmd.chan_stat.chan_stat_inf1 = 0;
+        env_cmd->evd_cmd.chan_stat.chan_stat_link = LINK_ESTABL;
+        env_cmd->evd_cmd.chan_stat.chan_stat_inf2 = NO_FURTH_INFO;
+        /*
+         * Channel Data Length
+         */
+        env_cmd->evd_cmd.v_chan_dat_lth = TRUE;
+        if (sim_data.received_data.list_len > 255)
+        {
+          /*
+           * more than 255 bytes are available in RX buffer
+           */
+          env_cmd->evd_cmd.chan_dat_lth = 0xff;
+        }
+        else
+        {
+          env_cmd->evd_cmd.chan_dat_lth = (UBYTE)sim_data.received_data.list_len;
+        }
+        /*
+         * encode message
+         */
+        MALLOC(temp_sdu, (USHORT)(sizeof(T_sdu) - 1 + MAX_STK_CMD));
+        temp_sdu->l_buf = MAX_STK_CMD << 3;
+        temp_sdu->o_buf = 0;
+
+        ccdRet = ccd_codeMsg (CCDENT_SAT,
+                              UPLINK,
+                              (T_MSGBUF *) temp_sdu,
+                              (UBYTE    *) _decodedMsg,
+                              ENV_CMD);
+      }
+      CCD_END;
+
+      if ( ccdRet NEQ ccdOK )
+      {
+        TRACE_EVENT_P1("Data Available: CCD Coding Error: %d",ccdRet );
+      }
+      else
+      {
+          FKT_Envelope (dummy, temp_sdu->buf, (USHORT)(temp_sdu->l_buf >> 3), 0);
+        /*
+         * data received is not triggered from a proactive_polling
+         * function call, so adjust timer and start polling
+         */
+        stk_start_timer_and_poll();
+      }
+      MFREE(temp_sdu);
+    }
+  }
+} /* stk_dti_data_received() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_tx_buffer_full     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle TX BUFFER FULL signal from DTILIB.
+
+*/
+
+GLOBAL void stk_dti_tx_buffer_full (void)
+{
+  TRACE_FUNCTION ("stk_dti_tx_buffer_full()");
+
+  /*
+   * set new DTI state
+   */
+  sim_data.dti_tx_state = SIM_DTI_TX_IDLE;
+} /* stk_dti_tx_buffer_full() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_tx_buffer_ready    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle TX BUFFER READY signal from DTILIB.
+
+*/
+
+GLOBAL void stk_dti_tx_buffer_ready (void)
+{
+  TRACE_FUNCTION ("stk_dti_tx_buffer_ready()");
+
+  /*
+   * set new DTI state
+   */
+  sim_data.dti_tx_state = SIM_DTI_TX_READY;
+
+  /*
+   * send confirm primitive to MMI: out of here; actually as the response for 
+   * SIM_BIP_CONFIG_REQ
+   */
+  if ((sim_data.sim_bip_config_req) AND (sim_data.dti_connection_state EQ SIM_DTI_CONNECTION_SETUP))
+    {
+      PALLOC(sim_bip_config_cnf, SIM_BIP_CONFIG_CNF);
+      PSEND(hCommMMI, sim_bip_config_cnf);
+      /* primitive no longer needed.. */
+      /* and so avoid the second confirm in stk_udp_bind_cnf() */
+      PFREE(sim_data.sim_bip_config_req);
+      sim_data.sim_bip_config_req = NULL;
+      /*
+       * set the open state: the connection is now truly opened
+       */
+      sim_data.dti_connection_state = SIM_DTI_CONNECTION_OPEN;      
+    } 
+  /*
+   * send data
+   */
+  if (sim_data.bip_tx_state EQ SIM_BIP_TX_SEND)
+  {
+    /*
+     * set new BIP state
+     */
+#ifdef _SIMULATION_ 
+    TRACE_EVENT("bip_tx_state = IDLE");
+#endif 
+    sim_data.bip_tx_state = SIM_BIP_TX_IDLE;
+    /*
+     * send DTI data primitive
+     */
+    stk_dti_send_data();
+    /*
+     * send Terminal Response
+     */
+    stk_bip_send_data_terminal_response(sim_data.bip_general_result,
+                                        sim_data.bip_add_info_result);
+    /*
+     * buffer ready is not triggered from a proactive_polling function call
+     * so adjust timer and start polling
+     */
+    stk_start_timer_and_poll();
+    /*
+     * (re)start release timer
+     */
+    if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+        (sim_data.bip_rx_state EQ SIM_BIP_RX_IDLE) AND
+        ((sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED) OR
+        (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)))
+    {
+      sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_
+      TRACE_EVENT("SIM_BIP_TIMER: start in stk_dti_tx_buffer_ready()");
+#endif
+      TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+    }
+  }
+} /* stk_dti_tx_buffer_ready() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_bip_send_data      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle SEND DATA message from SIM card.
+
+*/
+
+GLOBAL UBYTE stk_dti_bip_send_data (T_sdu* message)
+{
+  UBYTE   ccdRet;
+  UBYTE   func_ret;
+  UBYTE   general_result;
+  UBYTE   add_info_result;
+  UBYTE   status;
+  T_desc2* temp_desc1;
+  T_desc2* temp_desc2;
+  USHORT  temp_pos;
+  USHORT  temp_len;
+
+  TRACE_FUNCTION ("stk_dti_bip_send_data()");
+
+  /*
+   * initialize value;
+   */
+  ccdRet          = ccdOK;
+  func_ret        = FALSE;
+  general_result  = RSLT_PERF_SUCCESS;
+  add_info_result = ADD_NO_CAUSE;
+  status          = SIM_CCD_OK;
+
+  CCD_START;
+  /*
+   * decode SIM Toolkit Command
+   */
+  stk_bip_decode_stk_command(message,
+                             &sim_data.bip_tx_cmd_details,
+                             &status,
+                             &general_result,
+                             &add_info_result);  
+  /*
+   * decode SEND DATA message
+   */
+  if (status EQ SIM_CCD_OK)
+  {
+    MCAST(send_data, SEND_DATA);
+    memset(send_data, 0, sizeof(T_SEND_DATA));
+    /*
+     * decode SEND DATA message
+     */
+    ccdRet = ccd_decodeMsg (CCDENT_SAT,
+                            DOWNLINK,
+                            (T_MSGBUF *) &sim_data.bip_cmd_prms,
+                            (UBYTE    *) _decodedMsg,
+                            SEND_DATA);
+
+    if (ccdRet NEQ ccdOK)
+    {
+      /*
+       * handle errors in list
+       */
+      stk_handle_ccd_error(ccdRet, &status, &general_result, &add_info_result);      
+    }
+    if (send_data->v_chan_data EQ FALSE)
+    {
+      /*
+       * no Channel Data element present
+       * Error, required values are missing
+       */
+      general_result  = RSLT_ERR_REQ_VAL;
+      add_info_result = ADD_NO_CAUSE;
+      status          = SIM_CCD_RETURN;
+    }
+    if (status EQ SIM_CCD_OK)
+    {
+      if (sim_data.bip_suspend)
+      {
+        /*
+         * channel suspended
+         * ME currently unable to process command
+         */
+        general_result  = sim_data.bip_general_result;
+        add_info_result = sim_data.bip_add_info_result;
+        status          = SIM_CCD_RETURN;
+      }
+      else if ((SIM_CLASS_E_BUFFER_SIZE - sim_data.data_to_send.list_len) <
+              send_data->chan_data.c_ch_dat_str)
+      {
+        /*
+         * not enough space in tx buffer
+         * BIP error
+         */
+        general_result  = RSLT_BEARIND_PERR;
+        add_info_result = ADD_BIP_BUF_SIZ_NAVAIL;
+        status          = SIM_CCD_RETURN;
+      }
+      else
+      {
+        /*
+         * concatenate Channel data
+         */
+        sim_data.prev_data_to_send = sim_data.data_to_send;
+        if (sim_data.data_to_send.first NEQ (ULONG)NULL)
+        {
+          /*
+           * find last descriptor
+           */
+          temp_desc1 = (T_desc2*)sim_data.data_to_send.first;
+          while(temp_desc1->next NEQ (ULONG)NULL)
+          {
+            temp_desc1 = (T_desc2*)temp_desc1->next;
+          }
+        }
+        else if (send_data->chan_data.c_ch_dat_str)
+        {
+          /*
+           * allocate a new descriptor
+           */
+          MALLOC(temp_desc1, (USHORT)(sizeof(T_desc2) - 1 +
+                             SIM_BIP_TX_DESC_SIZE));
+          temp_desc1->next = (ULONG)NULL;
+          temp_desc1->offset= 0; /*###jk:OK*/
+          temp_desc1->len  = 0;
+          temp_desc1->size= 0; /*###jk:OK*/
+          sim_data.data_to_send.first    = (ULONG)temp_desc1;
+          sim_data.data_to_send.list_len = 0;
+        }
+        temp_pos = 0;
+        while(temp_pos < send_data->chan_data.c_ch_dat_str)
+        {
+          if (temp_desc1->len >= SIM_BIP_TX_DESC_SIZE) /*lint !e644 temp_desc1 may not have been initialized*/
+          {
+            /*
+             * allocate new desriptor
+             */
+            temp_desc2 = temp_desc1;
+            MALLOC(temp_desc1, (USHORT)(sizeof(T_desc2) - 1 +
+                               SIM_BIP_TX_DESC_SIZE));
+            temp_desc1->next = (ULONG)NULL;
+            temp_desc1->offset = 0; /*###jk:OK*/
+            temp_desc1->len  = 0;
+            temp_desc1->size = 0; /*###jk:OK*/
+            temp_desc2->next = (ULONG)temp_desc1;
+          }
+          /*
+           * calculate length
+           */
+          temp_len = send_data->chan_data.c_ch_dat_str - temp_pos;
+          if (temp_len > (SIM_BIP_TX_DESC_SIZE - temp_desc1->len))
+          {
+            temp_len = SIM_BIP_TX_DESC_SIZE - temp_desc1->len;
+            TRACE_EVENT("sdbsd_5: if (temp_desc1->len >= SIM_BIP_TX_DESC_SIZE)"); /*###jk:tbd*/      
+            TRACE_EVENT_P1("sdbsd_5: temp_len = %d", temp_len); /*###jk:tbd*/      
+          }
+          /*
+           * copy data
+           */
+          memcpy(&temp_desc1->buffer[temp_desc1->len],
+                 &send_data->chan_data.ch_dat_str[temp_pos],
+                 temp_len);
+          temp_pos                      += temp_len;
+          temp_desc1->len               += temp_len;
+          temp_desc1->size              += temp_len; /*###jk:OK?*/
+          sim_data.data_to_send.list_len+= temp_len;
+        }
+      }
+      /*
+       * process SEND DATA message
+       */
+      if (status EQ SIM_CCD_OK)
+      {
+        /*
+         * if alpha identifier or icon identifier is present then
+         * forward message to MMI
+         */
+        if ((send_data->v_alpha_id) OR
+           (send_data->v_icon))
+        {
+          func_ret = TRUE;
+        }
+        /*
+         * check for immediate/store bit
+         */
+        if (sim_data.bip_tx_cmd_details.cmd_qlf & SIM_QLF_SEND_DATA_1)
+        {
+          /*
+           * send data immediately
+           */
+          if (sim_data.bip_state EQ SIM_BIP_CONNECTED)
+          {
+            /*
+             * DTI connected
+             */
+            if (sim_data.dti_tx_state EQ SIM_DTI_TX_READY)
+            {
+              /*
+               * send DTI data primitive
+               */
+#ifdef _SIMULATION_ 
+              TRACE_EVENT("bip_tx_state = IDLE");
+#endif 
+              sim_data.bip_tx_state = SIM_BIP_TX_IDLE;
+              status                = SIM_CCD_RETURN;
+              stk_dti_send_data();
+            }
+            else
+            {
+              TRACE_EVENT("stbsd_8: else (sim_data.dti_tx_state EQ SIM_DTI_TX_READY)"); /*###jk:tbd*/     
+              /*
+               * start release timer
+               */
+#ifdef _SIMULATION_ 
+              TRACE_EVENT("bip_tx_state = SEND");
+#endif 
+              sim_data.bip_tx_state = SIM_BIP_TX_SEND;
+              status                = SIM_CCD_DISCARD;
+              if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+                  (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+                 )
+              {
+                sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_  
+                TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif  
+                TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+              }
+            }
+            /*
+             * (re)start release timer
+             */
+            if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+                (sim_data.bip_rx_state EQ SIM_BIP_RX_IDLE) AND
+                (sim_data.bip_tx_state EQ SIM_BIP_TX_IDLE) AND
+                ((sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED) OR
+                 (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)))
+            {
+              sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_  
+              TRACE_EVENT("SIM_BIP_TIMER: start in stk_dti_bip_send_data(..)");
+#endif 
+              TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+            }
+          }
+          else
+          {
+            TRACE_EVENT("stbsd_7: else (sim_data.bip_state EQ SIM_BIP_CONNECTED)"); /*###jk:tbd*/
+            /*
+             * wait for DTI connection
+             */
+#ifdef _SIMULATION_ 
+            TRACE_EVENT("bip_tx_state = SEND");
+#endif  
+            sim_data.bip_tx_state = SIM_BIP_TX_SEND;
+            status                = SIM_CCD_DISCARD;
+            if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+                (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+               )
+            {
+              sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_ 
+              TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif  
+              TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+            }
+            if (sim_data.dti_connection_state EQ SIM_DTI_CONNECTION_CLOSED)
+            {
+              /*
+               * on demand link establishment
+               * so forward message to MMI
+               */
+              func_ret              = TRUE;
+            }
+          }
+        }
+        else
+        {
+          /*
+           * store data
+           */
+          TRACE_EVENT("bip_tx_state = STORE");
+          sim_data.bip_tx_state = SIM_BIP_TX_STORE;
+          status                = SIM_CCD_RETURN;
+          /*
+           * stop release timer if used 
+           */
+          if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+              (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+             )
+          {
+            sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+            TRACE_EVENT("SIM_BIP_TIMER: stopped");
+            TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+          }
+        }
+      }
+    }
+  } /* if (status EQ SIM_CCD_OK) */
+
+  CCD_END;
+
+  /*
+   * send TERMINAL RESPONSE message
+   */
+  if (status EQ SIM_CCD_RETURN)
+  {
+    stk_bip_send_data_terminal_response(general_result, add_info_result);
+  }
+  else
+  {
+    /*
+     * store result codes
+     */
+    sim_data.bip_general_result  = general_result;
+    sim_data.bip_add_info_result = add_info_result;
+  }
+  /*
+   * send return value
+   */
+  return func_ret;
+} /* stk_dti_bip_send_data() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (6302)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_dti_bip_receive_data   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Handle RECEIVE DATA message from SIM card.
+
+*/
+
+LOCAL UBYTE stk_dti_bip_receive_data (T_sdu* message, UBYTE result_code)
+{
+  UBYTE   ccdRet;
+  UBYTE   func_ret;
+  UBYTE   general_result;
+  UBYTE   add_info_result;
+  UBYTE   status;
+  UBYTE   chan_dat_lth;
+  T_desc2* temp_desc1;
+  T_desc2* temp_desc2;
+  T_sdu*  temp_sdu;
+  USHORT  temp_pos;
+  USHORT  temp_len;
+
+  /*
+   * initialize value;
+   */
+  ccdRet          = ccdOK;
+  func_ret        = FALSE;
+  general_result  = RSLT_PERF_SUCCESS;
+  add_info_result = ADD_NO_CAUSE;
+  status          = SIM_CCD_OK;
+  chan_dat_lth    = 0; /* jk: initialized because of LINT error */
+
+  CCD_START;
+  /*
+   * decode SIM Toolkit Command
+   */
+  stk_bip_decode_stk_command(message,
+                             &sim_data.bip_rx_cmd_details,
+                             &status,
+                             &general_result,
+                             &add_info_result);
+
+  /*
+   * decode RECEIVE DATA message
+   */
+  if (status EQ SIM_CCD_OK)
+  {
+    MCAST(receive_data, RECEIVE_DATA);
+    memset(receive_data, 0, sizeof(T_RECEIVE_DATA));
+
+    ccdRet = ccd_decodeMsg (CCDENT_SAT,
+                            DOWNLINK,
+                            (T_MSGBUF *) &sim_data.bip_cmd_prms,
+                            (UBYTE    *) _decodedMsg,
+                            RECEIVE_DATA);
+
+#ifdef _SIMULATION_
+  TRACE_EVENT_P1("ccdRet@dti_bip_receive_data: %d", ccdRet);
+#endif
+
+    if (ccdRet NEQ ccdOK)
+    {
+      /*
+       * handle errors in list
+       */
+      stk_handle_ccd_error(ccdRet, &status, &general_result, &add_info_result);
+    }
+    if (receive_data->v_chan_dat_lth EQ FALSE)
+    {
+      /*
+       * no Channel Data Length element present
+       * Error, required values are missing
+       */
+      general_result  = RSLT_ERR_REQ_VAL;
+      add_info_result = ADD_NO_CAUSE;
+      status          = SIM_CCD_RETURN;
+    }
+    /*
+     * process RECEIVE DATA message
+     */
+    if (status EQ SIM_CCD_OK)
+    {
+      /*
+       * if alpha identifier or icon identifier is present then
+       * forward message to MMI
+       */
+      if ((receive_data->v_alpha_id) OR
+         (receive_data->v_icon))
+      {
+        func_ret = TRUE;
+      }
+      if (sim_data.received_data.list_len < receive_data->chan_dat_lth)
+      {
+        /*
+         * can not fill the complete buffer
+         */
+        general_result  = RSLT_PERF_MISS_INFO;
+        add_info_result = ADD_NO_CAUSE;
+      }
+      status = SIM_CCD_RETURN;
+      /*
+       * store Channel Data Length
+       */
+      chan_dat_lth = receive_data->chan_dat_lth;
+    }
+  }
+  CCD_END;
+  /*
+   * send TERMINAL RESPONSE message
+   */
+  if (status EQ SIM_CCD_RETURN)
+  {
+    CCD_START;
+    {
+      MCAST(term_resp, TERM_RESP);
+      memset(term_resp, 0, sizeof(T_TERM_RESP));
+
+      /*
+       * set Command details
+       */
+      term_resp->v_cmd_details = TRUE;
+      term_resp->cmd_details   = sim_data.bip_rx_cmd_details;
+      /*
+       * set set Device identities
+       */
+      term_resp->v_dev_ids        = TRUE;
+      term_resp->dev_ids.src_dev  = DEV_SRC_ME;
+      term_resp->dev_ids.dest_dev = DEV_DST_SIM;
+      /*
+       * set Result
+       */
+      term_resp->v_res   = TRUE;
+      term_resp->res.gen = general_result;
+      switch (general_result)
+      {
+        case RSLT_ME_UNAB_PROC:
+        case RSLT_NTW_UNAB_PROC:
+        case RSLT_LABRWS_GENERIC:
+        case RSLT_SS_ERR:
+        case RSLT_SMS_ERR:
+        case RSLT_USSD_ERR:
+        case RSLT_CC_SIM_PRM:
+          /*
+           * one byte for additional information
+           */
+          term_resp->res.v_add        = TRUE;
+          term_resp->res.add.l_add    = 1 << 3;
+          term_resp->res.add.o_add    = 0;
+          term_resp->res.add.b_add[0] = add_info_result;
+          break;
+
+        case RSLT_BEARIND_PERR:
+          /*
+           * one byte for additional information
+           */
+          term_resp->res.v_add        = TRUE;
+          term_resp->res.add.l_add    = 1 << 3;
+          term_resp->res.add.o_add    = 0;
+          term_resp->res.add.b_add[0] = add_info_result-1;
+          break;
+
+        default:
+          if (result_code)
+            term_resp->res.gen = RSLT_PERF_PART_CMPR;
+          break;
+      }
+      /*
+       * set Channel Data
+       */
+      term_resp->v_chan_data = TRUE;
+      switch (general_result)
+      {
+      case RSLT_PERF_SUCCESS:
+      case RSLT_PERF_PART_CMPR:
+      case RSLT_PERF_MISS_INFO:
+      case RSLT_PERF_MDFY_SIM:
+      case RSLT_PERF_MDFIED:
+        /*
+         * calculate Channel Data String length
+         */
+        term_resp->chan_data.c_ch_dat_str = SIM_TERM_RESP_MAX_CHANNEL_DATA;
+        if (sim_data.received_data.list_len < term_resp->chan_data.c_ch_dat_str)
+        {
+          term_resp->chan_data.c_ch_dat_str = (UBYTE)sim_data.received_data.list_len;
+        }
+        if (chan_dat_lth < term_resp->chan_data.c_ch_dat_str)
+        {
+          term_resp->chan_data.c_ch_dat_str = chan_dat_lth;
+        }
+        /*
+         * copy data
+         */
+        temp_desc1 = (T_desc2*)sim_data.received_data.first;
+        temp_pos = 0;
+        while (temp_pos < term_resp->chan_data.c_ch_dat_str)
+        {
+          /*
+           * calculate length
+           */
+          temp_len = term_resp->chan_data.c_ch_dat_str - temp_pos;
+          if (temp_len > (temp_desc1->len - sim_data.received_data_pos))
+          {
+            temp_len = temp_desc1->len - sim_data.received_data_pos;
+          }
+          /*
+           * copy data
+           */
+          memcpy(&term_resp->chan_data.ch_dat_str[temp_pos],
+                 &temp_desc1->buffer[sim_data.received_data_pos],
+                 temp_len);
+          /*
+           * updata length and position values and descriptors
+           */
+          temp_pos                       += temp_len;
+          sim_data.received_data_pos     += temp_len;
+          sim_data.received_data.list_len-= temp_len;
+          if (sim_data.received_data_pos >= temp_desc1->len)
+          {
+            temp_desc2                   = temp_desc1;
+            temp_desc1                   = (T_desc2*)temp_desc1->next;
+            sim_data.received_data_pos   = 0;
+            sim_data.received_data.first = (ULONG)temp_desc1;
+            MFREE(temp_desc2);
+          }
+        }
+        break;
+
+      case RSLT_BEARIND_PERR:
+      case RSLT_UNKN_DATA:
+        term_resp->v_chan_data = FALSE;
+        term_resp->chan_data.c_ch_dat_str = 0;
+        break;
+
+      default:
+        /*
+         * if an error is occured then do not provide data
+         */
+        term_resp->chan_data.c_ch_dat_str = 0;
+        break;
+      }
+
+      switch (general_result)
+      {
+      case RSLT_BEARIND_PERR:
+      case RSLT_UNKN_DATA:
+        break;
+
+      default:
+        /*
+         * set Channel Data Length
+         */
+        term_resp->v_chan_dat_lth = TRUE;
+        if (sim_data.received_data.list_len > 255)
+        {
+          /*
+           * more than 255 bytes are available in RX buffer
+           */
+          term_resp->chan_dat_lth = 0xff;
+        }
+        else
+        {
+          term_resp->chan_dat_lth = (UBYTE)sim_data.received_data.list_len;
+        }
+        break;
+      }
+      /*
+       * send Terminal Response
+       */
+      MALLOC(temp_sdu, (USHORT)(sizeof(T_sdu) - 1 + MAX_STK_CMD));
+      temp_sdu->l_buf = MAX_STK_CMD << 3;
+      temp_sdu->o_buf = 0;
+
+      ccdRet = ccd_codeMsg (CCDENT_SAT,
+                            UPLINK,
+                            (T_MSGBUF *) temp_sdu,
+                            (UBYTE    *) _decodedMsg,
+                            TERM_RESP);
+    }
+    CCD_END;
+
+    if ( ccdRet NEQ ccdOK )
+    {
+      TRACE_EVENT_P1("CCD Coding Error: %d",ccdRet );
+    }
+    else
+    {
+      FKT_TerminalResponse (temp_sdu->buf, (USHORT)(temp_sdu->l_buf >> 3));
+    }
+    MFREE(temp_sdu);
+  }
+
+  if ((sim_data.bip_rx_state EQ SIM_BIP_RX_DATA) AND
+     (sim_data.received_data.list_len EQ 0))
+  {
+    /*
+     * set new BIP state
+     */
+#ifdef _SIMULATION_
+    TRACE_EVENT("bip_rx_state = IDLE");
+#endif
+    sim_data.bip_rx_state = SIM_BIP_RX_IDLE;
+    /*
+     * start DTI reception
+     */
+    if ((sim_data.bip_state EQ SIM_BIP_CONNECTED) AND
+       (sim_data.dti_rx_state EQ SIM_DTI_RX_IDLE))
+    {
+      sim_data.dti_rx_state = SIM_DTI_RX_READY;
+      dti_start(sim_data.hDTI, 0, 0, 0);
+    }
+    /*
+     * start release timer
+     */
+    if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+        (sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED) AND
+        (sim_data.bip_tx_state EQ SIM_BIP_TX_IDLE)
+       )
+    {
+         /*
+          * no data trafic on the BIP channel,
+          * so use the timer
+          */
+          sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_
+          TRACE_EVENT("SIM_BIP_TIMER: start in stk_dti_bip_receive_data(..)");
+#endif
+          TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+    }
+  }
+  /*
+   * send return value
+   */
+  return func_ret;
+} /* stk_dti_bip_receive_data() */
+
+#ifdef FF_SAT_E
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_udp_bind_cnf           |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive UDP_BIND_CNF.
+
+*/
+
+GLOBAL void stk_udp_bind_cnf (T_UDP_BIND_CNF* udp_bind_cnf)
+{
+  TRACE_FUNCTION ("stk_udp_bind_cnf()");
+
+  if (sim_data.dti_connection_state EQ SIM_DTI_CONNECTION_BIND)
+  {
+    if (udp_bind_cnf->err EQ UDP_BIND_NOERROR)
+    {
+      /*
+       * store source port
+       */
+      sim_data.udp_parameters.src_port[0] =
+        ((udp_bind_cnf->port >> 8) & 0x00ff);
+      sim_data.udp_parameters.src_port[1] =
+        ((udp_bind_cnf->port)      & 0x00ff);
+      /*
+       * make sending of the confirmation primitive (SIM_BIP_CONFIG_CNF)
+       * out of "stk_dti_buffer_ready()" possible
+       */
+      sim_data.dti_connection_state = SIM_DTI_CONNECTION_SETUP;
+
+      /*###jk:OK? moved & changed from "stk_dti_connection_open()" */
+      if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+          (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+         )
+      {
+        sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_ 
+        TRACE_EVENT("stk_udp_bind_cnf(): SIM_BIP_TIMER: stopped");
+#endif  
+        TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+      }
+      /*
+       * update timer (if used) and DTI states
+       */
+      if ((sim_data.bip_state EQ SIM_BIP_CONNECTED) AND
+         (sim_data.bip_rx_state EQ SIM_BIP_RX_IDLE))
+      {
+        /*
+         * start reception
+         */
+        sim_data.dti_rx_state = SIM_DTI_RX_READY;
+        dti_start(sim_data.hDTI, 0, 0, 0);
+        /*
+         * start timer if used
+         */
+        if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+            (sim_data.bip_tx_state EQ SIM_BIP_TX_IDLE) AND
+            (sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED)
+           )
+        {
+          /*
+           * no data trafic on the BIP channel,
+           * so use the timer
+           */
+          sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_
+          TRACE_EVENT("SIM_BIP_TIMER: start in stk_dti_connection_opened()");
+#endif
+          TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+        }
+      } /*###jk:OK?*/
+    } 
+    else
+    {
+      /*
+       * can not open UDP port 
+       * so disconnect BIP channel from DTI
+       */
+      stk_close_dti_connection(TRUE);
+      /*
+       * send confirm primitive
+       */
+      stk_dti_inform_mmi(SIM_DTI_DISCONNECT, (UBYTE) SIM_BIP_UNKNOWN);
+    }
+  }
+  /*
+   * free primitive
+   */
+  PFREE(udp_bind_cnf);
+} /* stk_udp_bind_cnf() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_udp_closeport_cnf      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive UDP_CLOSEPORT_CNF.
+
+*/
+
+GLOBAL void stk_udp_closeport_cnf (
+                    T_UDP_CLOSEPORT_CNF* udp_closeport_cnf)
+{
+  TRACE_FUNCTION ("stk_udp_closeport_cnf()");
+
+  /*
+   * free primitive
+   */
+  PFREE(udp_closeport_cnf);
+} /* stk_udp_closeport_cnf() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_udp_error_ind          |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive UDP_ERROR_IND.
+
+*/
+
+GLOBAL void stk_udp_error_ind (T_UDP_ERROR_IND* udp_error_ind)
+{
+  TRACE_FUNCTION ("stk_udp_error_ind()");
+
+  /*
+   * free primitive
+   */
+  PFREE(udp_error_ind);
+  /*
+   * generate error response
+   */
+  {
+    PALLOC(udp_error_res, UDP_ERROR_RES);
+    PSEND(hCommUDP, udp_error_res);
+  }
+} /* stk_udp_error_ind() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_udp_shutdown_ind       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive UDP_SHUTDOWN_IND.
+
+*/
+
+GLOBAL void stk_udp_shutdown_ind (T_UDP_SHUTDOWN_IND* udp_shutdown_ind)
+{
+  TRACE_FUNCTION ("stk_udp_shutdown_ind()");
+
+  /*
+   * send confirm primitive
+   */
+  if (hCommUDP < VSI_OK)
+  {
+    hCommUDP = vsi_c_open (VSI_CALLER UDP_NAME);
+  }
+  if (hCommUDP >= VSI_OK)
+  {
+    PALLOC(udp_shutdown_res, UDP_SHUTDOWN_RES);
+    PSEND(hCommUDP, udp_shutdown_res);
+    /*
+     * release VSI channel
+     */
+    vsi_c_close (VSI_CALLER hCommUDP);
+    hCommUDP = VSI_ERROR;
+  }
+  /*
+   * close DTI connection
+   */
+  if (sim_data.con_type EQ SIM_CON_TYPE_UDP)
+  {
+    switch(sim_data.dti_connection_state)
+    {
+      case SIM_DTI_CONNECTION_OPEN:
+      case SIM_DTI_CONNECTION_SETUP:
+        stk_close_dti_connection(TRUE);
+        break;
+
+      default:
+        stk_close_dti_connection(FALSE);
+        break;
+    }
+    /*
+     * inform ACI about disconnection
+     */
+    stk_dti_inform_mmi(SIM_DTI_DISCONNECT, (UBYTE) SIM_BIP_UNKNOWN);
+  }
+} /* stk_udp_shutdown_ind() */
+#endif /* FF_SAT_E */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_dti_req            |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_DTI_REQ.
+
+*/
+
+GLOBAL void stk_sim_dti_req (T_SIM_DTI_REQ* sim_dti_req)
+{
+  UBYTE  dti_conn;
+
+  TRACE_FUNCTION ("stk_sim_dti_req()");
+
+#ifdef _SIMULATION_
+  /*
+   * set entity_name parameter
+   */
+switch(sim_dti_req->entity_name)
+  {
+    case 1:
+      sim_dti_req->entity_name = (ULONG)("UDP");
+      break;
+
+    case 2:
+      sim_dti_req->entity_name = (ULONG)("SND");
+      break;
+
+    case 3:
+      sim_dti_req->entity_name = (ULONG)("L2R");
+      break;
+
+    default:
+      sim_dti_req->entity_name = (ULONG)(NULL);
+      break;
+  }
+#endif /* _SIMULATION_ */
+  /*
+   * store the received primitive
+   */
+  if (sim_data.sim_dti_req)
+  {
+    /*
+     * free previous primitive before store the new one
+     */
+    PFREE(sim_data.sim_dti_req);
+  }
+  sim_data.sim_dti_req = sim_dti_req;
+
+  /*
+   * store requested operations
+   */
+  dti_conn = sim_dti_req->dti_conn;
+
+  switch (dti_conn)
+  {
+    case SIM_DTI_DISCONNECT: /* close DTI connection */
+      {
+        switch(sim_data.dti_connection_state)
+          {
+            case SIM_DTI_CONNECTION_OPEN:
+            case SIM_DTI_CONNECTION_SETUP:
+              stk_close_dti_connection(TRUE);
+              break;
+            default:
+              stk_close_dti_connection(FALSE);
+              break;
+          }
+        break;
+      }
+    case SIM_DTI_CONNECT: /* open DTI connection */
+      {
+        /*
+         * if a new DTI connection is requested close the old one before
+         */
+        switch(sim_data.dti_connection_state)
+          {
+            case SIM_DTI_CONNECTION_OPEN:
+            case SIM_DTI_CONNECTION_SETUP:
+              stk_close_dti_connection(TRUE);
+              break;
+            default:
+              stk_close_dti_connection(FALSE);
+          }
+        /*
+         * store relevant data
+         */
+        sim_data.link_id  = sim_dti_req->link_id;
+        sim_data.dti_connection_state = SIM_DTI_CONNECTION_SETUP;
+        dti_open(sim_data.hDTI,                 /* DTI handle */
+                 0,                             /* instance */
+                 0,                             /* interface */
+                 0,                             /* channel */
+                 0,                             /* queue size */
+                 sim_dti_req->dti_direction,    /* direction */
+                 FLOW_CNTRL_ENABLED,            /* comm_type */
+                 DTI_VERSION_10,                /* version */
+                 (UBYTE*)sim_dti_req->entity_name, /* entity name */
+                 sim_dti_req->link_id);         /* link identifier */
+      }
+  }
+  /*
+   * send confirm primitive
+   */
+  if (sim_data.sim_dti_req)
+  {
+    TRACE_EVENT_P1("if(sim_data.sim_dti_req): ~ ->dti_conn=0x%02X", sim_dti_req->dti_conn);
+
+    stk_dti_inform_mmi(sim_dti_req->dti_conn, (UBYTE)SIM_BIP_UNKNOWN);
+  }
+} /* stk_sim_dti_req() */
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_bip_req            |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_BIP_REQ.
+
+*/
+
+GLOBAL void stk_sim_bip_req (T_SIM_BIP_REQ* sim_bip_req)
+{
+  UBYTE   bip_conn;
+  USHORT  temp_len;
+  T_desc2* temp_desc1;
+  T_desc2* temp_desc2;
+
+  TRACE_FUNCTION ("stk_sim_bip_req()");
+
+  /*
+   * store the received primitive
+   */
+  if (sim_data.sim_bip_req)
+  {
+    /*
+     * free previous primitive before store the new one
+     */
+    PFREE(sim_data.sim_bip_req);
+  }
+  sim_data.sim_bip_req = sim_bip_req;
+  /*
+   * store requested operations
+   */
+  bip_conn = sim_bip_req->bip_conn;
+
+  /*
+   * resume BIP channel
+   */
+  if (bip_conn & SIM_BIP_CHANNEL_RESUMED)
+  {
+    /*
+     * set new suspension state
+     */
+    sim_data.bip_suspend = FALSE;
+    /*
+     * restart timer if used
+     */
+    if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+        (sim_data.bip_timer_state EQ SIM_BIP_TIMER_SUSPENDED)
+       )
+    {
+      sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+      if ((sim_data.bip_rx_state EQ SIM_BIP_RX_IDLE) AND
+          (sim_data.bip_tx_state EQ SIM_BIP_TX_IDLE)
+         )
+      {
+            /*
+             * no data trafic on the BIP channel,
+             * so use the timer
+             */
+            sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_
+            TRACE_EVENT("SIM_BIP_TIMER: start in stk_sim_bip_req(..)");
+#endif
+            TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+      }
+    }
+  }
+  /*
+   * close BIP channel
+   */
+  if (bip_conn & SIM_BIP_CLOSE_CHANNEL)
+  {
+    stk_close_bip_channel(sim_bip_req->general_result,
+                          sim_bip_req->add_info_result);
+  }
+  /*
+   * open BIP channel
+   */
+  if ((bip_conn & SIM_BIP_OPEN_CHANNEL) AND
+     (sim_data.bip_state EQ SIM_BIP_CLOSED))
+  {
+    /*
+     * set new BIP state and
+     * store BIP channel identifier
+     */
+    sim_data.bip_state = SIM_BIP_OPEN;
+    sim_data.bip_ch_id = sim_bip_req->bip_ch_id;
+    /*
+     * store relevant data
+     */
+    sim_data.bip_release_time =
+          (T_TIME)sim_bip_req->release_time * 100; /* convert to msec. */
+    if (sim_bip_req->general_result NEQ RSLT_PERF_SUCCESS)
+    {
+      sim_data.bip_general_result  = sim_bip_req->general_result;
+      sim_data.bip_add_info_result = sim_bip_req->add_info_result;
+    }
+  }
+  /*
+   * suspend BIP channel
+   */
+  if (bip_conn & SIM_BIP_CHANNEL_SUSPENDED)
+  {
+    /*
+     * set new suspension state
+     */
+    sim_data.bip_suspend = TRUE;
+    /*
+     * stop timer if timer is used
+     */
+    if (sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED)
+    {
+      if (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+      {
+        sim_data.bip_timer_state = SIM_BIP_TIMER_SUSPENDED;
+#ifdef _SIMULATION_
+        TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif
+        TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+      }
+      else if (sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED)
+      {
+        sim_data.bip_timer_state = SIM_BIP_TIMER_SUSPENDED;
+      }
+    }
+    /*
+     * store result codes
+     */
+    sim_data.bip_general_result  = sim_bip_req->general_result;
+    sim_data.bip_add_info_result = sim_bip_req->add_info_result;
+    /*
+     * inform SIM card
+     */
+    if (sim_data.bip_tx_state EQ SIM_BIP_TX_SEND)
+    {
+      /*
+       * free data of last SEND DATA message
+       */
+      temp_desc1            = (T_desc2*)sim_data.data_to_send.first;
+      sim_data.data_to_send = sim_data.prev_data_to_send;
+      if (sim_data.data_to_send.first EQ (ULONG)NULL)
+      {
+        while(temp_desc1)
+        {
+          temp_desc2 = temp_desc1;
+          temp_desc1 = (T_desc2*)temp_desc1->next;
+          MFREE(temp_desc2);
+        }
+      }
+      else
+      {
+        temp_len = 0;
+        while((temp_desc1) AND
+              (temp_len + temp_desc1->len) < sim_data.data_to_send.list_len)
+        {
+          temp_len  += temp_desc1->len;
+          temp_desc1 = (T_desc2*)temp_desc1->next;
+        }
+        if (temp_desc1)
+        {
+          temp_desc1->len  = sim_data.data_to_send.list_len - temp_len;
+          temp_desc2       = (T_desc2*)temp_desc1->next;
+          temp_desc1->next = (ULONG)NULL;
+          temp_desc1       = temp_desc2;
+          while(temp_desc1)
+          {
+            temp_desc2 = temp_desc1;
+            temp_desc1 = (T_desc2*)temp_desc1->next;
+            MFREE(temp_desc2);
+          }
+        }
+      }
+      /*
+       * set new BIP TX state
+       */
+      if (sim_data.data_to_send.first EQ (ULONG)NULL)
+      {
+#ifdef _SIMULATION_
+        TRACE_EVENT("bip_tx_state = IDLE");
+#endif
+        sim_data.bip_tx_state = SIM_BIP_TX_IDLE;
+      }
+      else
+      {
+#ifdef _SIMULATION_
+        TRACE_EVENT("bip_tx_state = STORE");
+#endif
+        sim_data.bip_tx_state = SIM_BIP_TX_STORE;
+        if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+            (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+           )
+        {
+          sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_
+          TRACE_EVENT("SIM_BIP_TIMER: stopped");
+#endif
+          TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+        }
+      }
+      /*
+       * send Terminal Response
+       */
+      stk_bip_send_data_terminal_response(sim_bip_req->general_result,
+                                          sim_bip_req->add_info_result);
+      /*
+       * suspension is not triggered from a proactive_polling function call
+       * so adjust timer and start polling
+       */
+      stk_start_timer_and_poll();
+    }
+  }
+  /*
+   * send confirm primitive
+   */
+  if (sim_data.sim_bip_req)
+  {
+    stk_dti_inform_mmi((UBYTE) SIM_DTI_UNKNOWN, sim_bip_req->bip_conn);
+  }
+} /* stk_sim_bip_req() */
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_bip_config_req     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_BIP_CONFIG_REQ.
+
+*/
+
+GLOBAL void stk_sim_bip_config_req(T_SIM_BIP_CONFIG_REQ * sim_bip_config_req)
+{
+  TRACE_FUNCTION ("stk_sim_bip_config_req()");
+  /*
+   * store the received primitive
+   */
+  if (sim_data.sim_bip_config_req)
+  {
+    /*
+     * free previous primitive before store the new one
+     */
+    PFREE(sim_data.sim_bip_config_req);
+  }
+  sim_data.sim_bip_config_req = sim_bip_config_req;
+  /*
+   * store relevant data
+   */
+  sim_data.con_type                   = sim_bip_config_req->con_type;
+
+#if 0
+  sim_data.udp_parameters.src_ip[0]   =
+      (UBYTE)((sim_bip_config_req->local_ip >> 24) & 0x000000ff);
+  sim_data.udp_parameters.src_ip[1]   =
+      (UBYTE)((sim_bip_config_req->local_ip >> 16) & 0x000000ff);
+  sim_data.udp_parameters.src_ip[2]   =
+      (UBYTE)((sim_bip_config_req->local_ip >>  8) & 0x000000ff);
+  sim_data.udp_parameters.src_ip[3]   =
+      (UBYTE)((sim_bip_config_req->local_ip)       & 0x000000ff);
+#else
+sim_data.udp_parameters.src_ip[3]   =
+    (UBYTE)((sim_bip_config_req->local_ip >> 24) & 0x000000ff);
+sim_data.udp_parameters.src_ip[2]   =
+    (UBYTE)((sim_bip_config_req->local_ip >> 16) & 0x000000ff);
+sim_data.udp_parameters.src_ip[1]   =
+    (UBYTE)((sim_bip_config_req->local_ip >>  8) & 0x000000ff);
+sim_data.udp_parameters.src_ip[0]   =
+    (UBYTE)((sim_bip_config_req->local_ip)       & 0x000000ff);
+#endif
+
+  sim_data.udp_parameters.des_ip[0]   =
+      (UBYTE)((sim_bip_config_req->destination_ip >> 24) & 0x000000ff);
+  sim_data.udp_parameters.des_ip[1]   =
+      (UBYTE)((sim_bip_config_req->destination_ip >> 16) & 0x000000ff);
+  sim_data.udp_parameters.des_ip[2]   =
+      (UBYTE)((sim_bip_config_req->destination_ip >>  8) & 0x000000ff);
+  sim_data.udp_parameters.des_ip[3]   =
+      (UBYTE)((sim_bip_config_req->destination_ip)       & 0x000000ff);
+
+#if 0
+  sim_data.udp_parameters.des_port[0] =
+      (UBYTE)((sim_bip_config_req->destination_port >> 8) & 0x00ff);
+  sim_data.udp_parameters.des_port[1] =
+      (UBYTE)((sim_bip_config_req->destination_port)      & 0x00ff);
+#else
+  sim_data.udp_parameters.des_port[1] =
+      (UBYTE)((sim_bip_config_req->destination_port >> 8) & 0x00ff);
+  sim_data.udp_parameters.des_port[0] =
+      (UBYTE)((sim_bip_config_req->destination_port)      & 0x00ff);
+#endif
+   
+    /*
+     * UDP connection
+     */
+    if (sim_data.con_type EQ SIM_CON_TYPE_UDP)
+    {
+      /*
+       * open VSI channel to UDP
+       */
+      if (hCommUDP < VSI_OK)            
+      {
+        TRACE_EVENT("if(hCommUDP < VSI_OK)");
+        if ((hCommUDP = vsi_c_open (VSI_CALLER UDP_NAME)) < VSI_OK)
+        {
+          TRACE_EVENT("if ((hCommUDP = vsi_c_open (VSI_CALLER UDP_NAME)) < VSI_OK)");
+          /*
+           * can not open VSI channel
+           * so act as if DTI close was requested
+           */
+          sim_data.sim_dti_req->dti_conn = SIM_DTI_DISCONNECT;
+          TRACE_EVENT_P1(": sim_data.sim_dti_req->dti_conn=0x%02X", sim_data.sim_dti_req->dti_conn);
+        }
+      }
+      /*
+       * send UDP_BIND_REQ
+       */
+      if (hCommUDP >= VSI_OK)
+      {
+        PALLOC(udp_bind_req, UDP_BIND_REQ);
+        sim_data.dti_connection_state = SIM_DTI_CONNECTION_BIND;
+        udp_bind_req->port            = UDP_AUTOASSIGN_PORT;
+        PSEND(hCommUDP, udp_bind_req);
+        /*
+         * send confirm primitive:
+         * will be sent out of "stk_dti_buffer_ready()" function in case of success,
+         * in case of udp_bind_cnf failure only indication primitive will be sent
+         * out of "stk_udp_bind_cnf" to MMI instead.
+         */
+      }
+    }
+    /*
+     * bearer level connection
+     */
+    else
+    {
+      /*###jk:OK? moved & changed from "stk_dti_connection_open()" */
+      if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+          (sim_data.bip_timer_state EQ SIM_BIP_TIMER_START)
+         )
+      {
+        sim_data.bip_timer_state = SIM_BIP_TIMER_STOPPED;
+#ifdef _SIMULATION_ 
+        TRACE_EVENT("stk_udp_bind_cnf(): SIM_BIP_TIMER: stopped");
+#endif  
+        TIMER_STOP (sim_handle, SIM_BIP_TIMER);
+      }
+      /*
+       * update timer (if used) and DTI states
+       */
+      if ((sim_data.bip_state EQ SIM_BIP_CONNECTED) AND
+         (sim_data.bip_rx_state EQ SIM_BIP_RX_IDLE))
+      {
+        /*
+         * start reception
+         */
+        sim_data.dti_rx_state = SIM_DTI_RX_READY;
+        dti_start(sim_data.hDTI, 0, 0, 0);
+        /*
+         * start timer if used
+         */
+        if ((sim_data.bip_timer_state NEQ SIM_BIP_TIMER_NOT_USED) AND
+            (sim_data.bip_tx_state EQ SIM_BIP_TX_IDLE) AND
+            (sim_data.bip_timer_state EQ SIM_BIP_TIMER_STOPPED)
+           )
+        {
+          /*
+           * no data trafic on the BIP channel,
+           * so use the timer
+           */
+          sim_data.bip_timer_state = SIM_BIP_TIMER_START;
+#ifdef _SIMULATION_
+          TRACE_EVENT("SIM_BIP_TIMER: start in stk_dti_connection_opened()");
+#endif
+          TIMER_START (sim_handle, SIM_BIP_TIMER, sim_data.bip_release_time);
+        }
+      } /*###jk:OK?*/ 
+
+      /*
+       * make sending of the confirmation primitive (SIM_BIP_CONFIG_CNF)
+       * out of "stk_dti_buffer_ready()" possible
+       */      
+       sim_data.dti_connection_state = SIM_DTI_CONNECTION_SETUP;
+
+      /*
+       * send confirm primitive:
+       * will be sent out of "stk_dti_buffer_ready()" function in order to
+       * prevent sending of the data to connected neighbour DTI-entity before
+       * this entity is ready to receive data.
+       */      
+#if 0 /*###jk:OK? -> */
+      /*
+       * send confirm primitive
+       */
+      if (sim_data.sim_bip_config_req)
+      {
+        PALLOC(sim_bip_config_cnf, SIM_BIP_CONFIG_CNF);
+        PSEND(hCommMMI, sim_bip_config_cnf);
+      }
+#endif
+    }
+} /* stk_bip_config_req() */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_eventlist_req      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_EVENTLIST_REQ.
+
+*/
+
+GLOBAL void stk_sim_eventlist_req (
+                    T_SIM_EVENTLIST_REQ* sim_eventlist_req)
+{
+  TRACE_FUNCTION ("stk_sim_eventlist_req()");
+
+  /*
+   * store new state of Data available event
+   */
+  sim_data.event_data_avail = sim_eventlist_req->event_data_avail;
+  /*
+   * free primitive
+   */
+  PFREE(sim_eventlist_req);
+  /*
+   * send confirm primitive
+   */
+  {
+    PALLOC(sim_eventlist_cnf, SIM_EVENTLIST_CNF);
+    sim_eventlist_cnf->event_data_avail = sim_data.event_data_avail;
+    PSEND(hCommMMI, sim_eventlist_cnf);
+  }
+} /* stk_sim_eventlist_req() */
+#endif /* FF_SAT_E */
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_toolkit_res        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_TOOLKIT_RES. MMI sends a
+            Terminal Response Message to SIM toolkit.
+
+*/
+
+GLOBAL void stk_sim_toolkit_res (T_SIM_TOOLKIT_RES * sim_toolkit_res)
+{
+  TRACE_FUNCTION ("stk_sim_toolkit_res()");
+
+  if (sim_data.ext_sat_cmd)
+  {
+    FKT_TerminalResponse (sim_toolkit_res->stk_cmd.cmd,
+                          (USHORT)(sim_toolkit_res->stk_cmd.l_cmd>>3));
+    PFREE (sim_toolkit_res);
+
+    sim_data.ext_sat_cmd = FALSE;
+    stk_start_timer_and_poll();
+  }
+  else
+  {
+    TRACE_EVENT("no outstanding TR");
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_toolkit_req        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_TOOLKIT_REQ. MMI sends an
+            Envelope Message to SIM toolkit.
+
+*/
+
+GLOBAL void stk_sim_toolkit_req (T_SIM_TOOLKIT_REQ * sim_toolkit_req)
+{
+  PALLOC (sim_toolkit_cnf, SIM_TOOLKIT_CNF);
+
+  sim_toolkit_cnf->stk_cmd.o_cmd = 0;
+  sim_toolkit_cnf->req_id = sim_toolkit_req->req_id;
+
+  TRACE_FUNCTION ("stk_sim_toolkit_req()");
+
+  switch (sim_toolkit_req->source)  // check valid source
+  {
+  case SRC_MMI:
+  case SRC_SMS:
+    break;
+  default:
+    TRACE_EVENT ("SIM_TOOLKIT_REQ: invalid source");
+    PFREE (sim_toolkit_cnf);
+    PFREE (sim_toolkit_req);
+    return;
+  }
+  /*
+   * Forward envelope command to SIM toolkit
+   */
+  sim_toolkit_cnf->cause = FKT_Envelope (sim_toolkit_cnf->stk_cmd.cmd,
+                                         sim_toolkit_req->stk_cmd.cmd,
+                                         (USHORT)(sim_toolkit_req->stk_cmd.l_cmd >> 3), 
+                                          NOT_PRESENT_16BIT);
+
+  /*
+   * Special treatment of SW1 is required for Call Control/MO-SM Control by SIM
+   */
+  if (sim_toolkit_cnf->cause NEQ SIM_NO_ERROR)
+  {
+    switch (sim_toolkit_req->stk_cmd.cmd[0])  /* ENVELOPE tag */
+    {
+    case 0xD4:  /* Call Control */
+    case 0xD5:  /* MO-SM Control */
+      if (sim_data.sw1 EQ 0x6F OR sim_data.sw1 EQ 0x92) /* Card problem */
+        sim_toolkit_cnf->cause = SIM_NO_ERROR;
+      break;
+    default:
+      break;
+    }
+  }
+
+  if (sim_data.sim_data_len > 0)
+  {
+      sim_toolkit_cnf->stk_cmd.l_cmd = stk_l_cmd;
+	    stk_l_cmd = 0;
+  }
+  else
+      sim_toolkit_cnf->stk_cmd.l_cmd = 0;
+
+  /*
+   * send confirmation to requesting entity
+   */
+  if (sim_toolkit_req->source EQ SRC_MMI)
+  {
+    PSENDX (MMI, sim_toolkit_cnf);
+  }
+  else
+  {
+    PSENDX (SMS, sim_toolkit_cnf);
+  }
+  PFREE (sim_toolkit_req);
+  stk_start_timer_and_poll();
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_file_update_res        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_FILE_UPDATE_RES. A File Change
+            Notification is responded.
+
+*/
+
+GLOBAL void stk_file_update_res (T_SIM_FILE_UPDATE_RES * file_update_res)
+{
+  UBYTE *p_res;     // access to result code
+
+  TRACE_FUNCTION ("stk_file_update_res()");
+
+  if (file_update_res->source EQ SRC_MMI)
+    sim_data.file_change_resp &= ~1;
+  else if (file_update_res->source EQ SRC_SMS)
+    sim_data.file_change_resp &= ~2;
+  else if (file_update_res->source EQ SRC_MM)
+    sim_data.file_change_resp &= ~4;
+  else
+  {
+    PFREE (file_update_res);
+    return;
+  }
+  p_res = &sim_data.stk_response[sim_data.stk_response[1] + 8];
+  if (file_update_res->fu_rsc EQ SIM_FU_SUCC_ADD)
+    *p_res = STK_RES_SUCC_ADD_EF_READ;
+
+  if (sim_data.file_change_resp EQ 0)
+  {
+    FKT_TerminalResponse (sim_data.stk_response, (USHORT)sim_data.stk_resp_len);
+    stk_start_timer_and_poll();
+  }
+  PFREE (file_update_res);
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_timeout                |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the timeout of a timer established by the SAT
+            command TIMER MANAGEMENT.
+
+*/
+
+static const  UBYTE timer_env[] = {
+  STK_TIMER_EXPIRATION_TAG,
+  STK_DEVICE_IDENTITY_LEN+STK_TIMER_ID_LEN+STK_TIMER_VALUE_LEN+6,
+  STK_DEVICE_IDENTITY_TAG|STK_COMPREHENSION_REQUIRED, STK_DEVICE_IDENTITY_LEN, 0x82, 0x81,
+  STK_TIMER_ID_TAG|STK_COMPREHENSION_REQUIRED, STK_TIMER_ID_LEN, 0,
+  STK_TIMER_VALUE_TAG|STK_COMPREHENSION_REQUIRED, STK_TIMER_VALUE_LEN, 0, 0, 0
+};
+
+extern UBYTE pending_timers[];
+extern UBYTE next_pos_to_fill;
+extern UBYTE next_pos_to_send;
+
+
+GLOBAL void stk_timeout (USHORT index)
+{
+  UBYTE env[sizeof(timer_env)];
+  UBYTE dummy[4];
+  USHORT error;
+
+  TRACE_FUNCTION("stk_timeout");
+#ifdef FF_SAT_E
+  /*
+   * handle BIP timeout
+   */
+  if (index EQ SIM_BIP_TIMER)
+  {
+    /*
+     * close DTI connection
+     */
+    switch(sim_data.dti_connection_state)
+    {
+      case SIM_DTI_CONNECTION_OPEN:
+      case SIM_DTI_CONNECTION_SETUP:
+        stk_close_dti_connection(TRUE);
+        break;
+
+      default:
+        stk_close_dti_connection(FALSE);
+        break;
+    }
+    /*
+     * close BIP channel and inform MMI
+     */
+    stk_close_bip_channel(RSLT_BEARIND_PERR, ADD_BIP_CHAN_CLOSD);
+    stk_dti_inform_mmi(SIM_DTI_DISCONNECT, SIM_BIP_CLOSE_CHANNEL);
+    return;
+  }
+#endif /* FF_SAT_E */
+
+  if ((unsigned)(--index) >= MAX_SAT_TIMER)   /* index range 0..7 */
+    return;
+
+  if (sim_data.timer[index].active)
+  {
+    memcpy (env, timer_env, sizeof(timer_env));
+    env[8] = (UBYTE)(index + 1);  /* Timer number range is 1..8 */
+    env[11] = sim_data.timer[index].hour;
+    env[12] = sim_data.timer[index].minute;
+    env[13] = sim_data.timer[index].second;
+  
+    error = FKT_Envelope (dummy, env, sizeof(timer_env), 0);
+//TISH, test patch for OMAPS00179771: SATK: Timer Expiration, modified by Jinshu Wang, 2008-09-01
+//start
+#if 0
+    if (error EQ SIM_NO_ERROR)
+      stk_start_timer_and_poll();
+#else
+    if (error EQ SIM_NO_ERROR)
+	{
+      stk_start_timer_and_poll();
+	    sim_data.timer[index].active = FALSE; //modified by Jinshu Wang, 2008-09-04
+	  if(sim_data.chk_sat_avail)
+	  {
+		sim_data.chk_sat_avail = FALSE;
+		stk_proactive_polling();
+		}
+	return;	 //modified by Jinshu Wang, 2008-09-04
+	}
+#endif
+//end
+   /*
+    * If SIM response is busy(9300), we have to once retry sending 
+    * timer-expiry envelope after SIM becomes OK on getting a TR
+   */  
+   if (error EQ SIM_CAUSE_SAT_BUSY)
+   {
+     pending_timers[next_pos_to_fill] = (UBYTE) index;
+     if (8 == next_pos_to_fill)
+     {
+       next_pos_to_fill = 0;
+     }
+     else
+     {
+       next_pos_to_fill++;
+     }
+   }
+    sim_data.timer[index].active = FALSE;
+  }
+}
+
+#ifdef TI_PS_FF_AT_P_CMD_CUST
+/*
++--------------------------------------------------------------------+
+| PROJECT : GSM-PS (8419)       MODULE  : SIM_STK                    |
+| STATE   : code                ROUTINE : stk_sim_refresh_user_res   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Process the primitive SIM_REFRESH_USER_RES. MMI sends a
+            Response Message to SIM_TOOLKIT_IND.
+            This Primitive should not occur when cust_mode is 0
+
+*/
+
+GLOBAL void stk_sim_refresh_user_res (T_SIM_REFRESH_USER_RES * sim_refresh_user_res)
+{
+  TRACE_FUNCTION ("stk_sim_refresh_user_res()");
+
+  /* primitive should not occur for cust_mode 0 */
+  if (sim_data.cust_mode EQ 0)
+  {
+    //Handle error condition
+    TRACE_FUNCTION_P1 ("!!!!Incorrect operation: Unexpected mode: cust_mode = %d !!!!",sim_data.cust_mode);
+    TRACE_FUNCTION ("Primitive should not occur if cust_mode = 0");
+    //MFREE (sim_data.context_switch_ptr); Don't free context as it should be freed by other thread. i.e. stk_proactive_polling()
+    PFREE (sim_refresh_user_res);
+    return;
+  }
+
+  /* check that we are expecting primitive */
+  if ( sim_data.user_confirmation_expected EQ FALSE )
+  {
+    //Handle error condition
+    TRACE_FUNCTION ("!!!!Incorrect operation: user_confirmation_expected is FALSE !!!!");
+    TRACE_FUNCTION ("Primitive should only occur if user_confirmation_expected is TRUE");
+    //MFREE (sim_data.context_switch_ptr); Don't free context switch as setup can not be guaranteed to be correct.
+    PFREE (sim_refresh_user_res);
+    return;
+  }
+  else
+  {
+    //Reset user_confirmation_expected
+    sim_data.user_confirmation_expected = FALSE;
+  }
+
+
+  if ((sim_refresh_user_res->user_accepts) EQ FALSE)
+  {
+    TRACE_FUNCTION ("User REJECTS Refresh Request");
+
+    FKT_TerminalResponse (sim_refresh_user_res->stk_cmd.cmd,
+                          (USHORT)(sim_refresh_user_res->stk_cmd.l_cmd>>3));
+    sim_data.ext_sat_cmd = FALSE;
+    stk_start_timer_and_poll();
+
+    //process_sim_refresh() automatically frees the signal.
+    //As we are not calling process_sim_refresh() we need to handle the freeing
+    TRACE_ASSERT(sim_data.context_switch_ptr->sig_ptr);
+    PFREE (sim_data.context_switch_ptr->sig_ptr); 
+  }
+  else
+  {
+    TRACE_FUNCTION ("User ACCEPTS Refresh Request");
+    process_sim_refresh(sim_data.context_switch_ptr);
+    TRACE_FUNCTION ("stk_sim_refresh_user_res() send end of SAT session indicator");
+    if ((sim_data.term_resp_sent) AND (sim_data.sat_session))
+    {
+      PALLOC (sim_toolkit_ind, SIM_TOOLKIT_IND);
+      memset (sim_toolkit_ind, 0, sizeof (T_SIM_TOOLKIT_IND));
+#ifdef _SIMULATION_
+      TRACE_EVENT("SAT session ended");
+#endif
+      sim_data.sat_session    = FALSE;
+      sim_data.term_resp_sent = FALSE;
+      PSENDX (MMI, sim_toolkit_ind);
+    }
+
+  }
+  TRACE_ASSERT(sim_data.context_switch_ptr);
+  MFREE (sim_data.context_switch_ptr);
+  sim_data.context_switch_ptr = NULL;
+
+  PFREE (sim_refresh_user_res);
+  TRACE_FUNCTION ("stk_sim_refresh_user_res() exited");
+}
+#endif /* TI_PS_FF_AT_P_CMD_CUST */
+
+#endif