fc-tourmaline: src/g23m-gsm/sim/sim

comparison src/g23m-gsm/sim/sim_stk.c @ 1:fa8dc04885d8

src/g23m-*: import from Magnetite

author	Mychaela Falconia <falcon@freecalypso.org>
date	Fri, 16 Oct 2020 06:25:50 +0000
parents
children

comparison

equal deleted inserted replaced

-:4e78acac3d88
+:fa8dc04885d8
+/*
++-----------------------------------------------------------------------------
+|  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

FreeCalypso > hg > fc-tourmaline

comparison src/g23m-gsm/sim/sim_stk.c @ 1:fa8dc04885d8