--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/src/aci2/mfw/mfw_sim.~c	Mon Sep 26 00:29:36 2016 +0000
@@ -0,0 +1,2946 @@
+/*
++--------------------------------------------------------------------+
+| PROJECT: MMI-Framework (8417)         $Workfile:: mfw_sim.c       $|
+| $Author:: Vo                          $Revision::  1              $|
+| CREATED: 13.10.98                     $Modtime:: 22.03.00 17:21   $|
+| STATE  : code                                                      |
++--------------------------------------------------------------------+
+
+   MODULE  : MFW_SIM
+
+   PURPOSE : This modul contains the functions for SIM management.
+
+
+   $History:: mfw_sim.c                                              $
+ *
+ * *****************  Version 43  *****************
+ * User: Vo           Date: 22.03.00   Time: 17:29
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * Add new parameter PIN type in structure T_MFW_SIM_STATUS to
+ * identify PIN type
+ * Change in SIM lock
+ *
+ * *****************  Version 42  *****************
+ * User: Es           Date: 2.03.00    Time: 16:18
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * use 'aci_delete()' instead of 'aci_ext_init()' to clear the
+ * primitive routing for mfw_sim. (because other routings may have to
+ * be preserved!)
+ *
+ * *****************  Version 41  *****************
+ * User: Vo           Date: 22.12.99   Time: 16:03
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * Remove maximum preferred PLMN records and used preferred PLMN
+ * records in local memory
+ *
+ * *****************  Version 40  *****************
+ * User: Vo           Date: 2.12.99    Time: 13:18
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * New: request of max/used perferred PLMN list
+ *
+ * *****************  Version 39  *****************
+ * User: Vo           Date: 17.11.99   Time: 11:37
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * Bug fix: de-personalisation for SIM lock
+ * New: SIM inserted
+ *
+ * *****************  Version 38  *****************
+ * User: Vo           Date: 21.10.99   Time: 13:26
+ * Updated in $/GSM/Condat/MS/SRC/MFW
+ * add response of de-registration
+|
+| *****************  Version 37  *****************
+| User: Le           Date: 11.10.99   Time: 16:27
+| Updated in $/GSM/Condat/MS/SRC/MFW
+|
+| *****************  Version 36  *****************
+| User: Le           Date: 8.10.99    Time: 13:38
+| Updated in $/GSM/Condat/MS/SRC/MFW
+|
+| *****************  Version 35  *****************
+| User: Le           Date: 4.10.99    Time: 10:33
+| Updated in $/GSM/Condat/MS/SRC/MFW
+ *
+ * *****************  Version 34  *****************
+ * User: Es           Date: 29.09.99   Time: 11:20
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * including CFUN_OK enhancement by AK, not fully implemented
+ *
+ * *****************  Version 33  *****************
+ * User: Es           Date: 16.09.99   Time: 16:56
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * reordered include statements due to addons in mfw_phb.h
+ *
+ * *****************  Version 32  *****************
+ * User: Vo           Date: 13.09.99   Time: 12:05
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * change comment
+ *
+ * *****************  Version 31  *****************
+ * User: Vo           Date: 12.09.99   Time: 15:32
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * Bug fix: change PIN
+ * Bug fix/New: SIM lock
+ * New: request of PIN status
+ * New: save preferred language
+ * New: read group identifier level 1 & 2
+ *
+ * *****************  Version 30  *****************
+ * User: Vo           Date: 30.08.99   Time: 14:23
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * bug fix
+ * new function
+ *
+ * *****************  Version 29  *****************
+ * User: Vo           Date: 9.08.99    Time: 13:11
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * PIN/PUK count
+ *
+ * *****************  Version 28  *****************
+ * User: Vo           Date: 26.07.99   Time: 14:34
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * Move include file mfw_cb.h
+ *
+ * *****************  Version 27  *****************
+ * User: Vo           Date: 21.07.99   Time: 14:41
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 26  *****************
+ * User: Vo           Date: 16.07.99   Time: 13:50
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 25  *****************
+ * User: Vo           Date: 9.07.99    Time: 14:34
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 24  *****************
+ * User: Vo           Date: 2.07.99    Time: 19:03
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 23  *****************
+ * User: Vo           Date: 28.05.99   Time: 9:52
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 22  *****************
+ * User: Vo           Date: 31.03.99   Time: 14:09
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 21  *****************
+ * User: Es           Date: 15.03.99   Time: 18:21
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * recode
+ *
+ * *****************  Version 20  *****************
+ * User: Vo           Date: 25.02.99   Time: 16:47
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 19  *****************
+ * User: Vo           Date: 17.02.99   Time: 19:03
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 18  *****************
+ * User: Vo           Date: 12.02.99   Time: 18:05
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 17  *****************
+ * User: Vo           Date: 12.02.99   Time: 17:46
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 16  *****************
+ * User: Vo           Date: 9.02.99    Time: 14:54
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 15  *****************
+ * User: Vo           Date: 12.01.99   Time: 14:27
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 14  *****************
+ * User: Es           Date: 23.12.98   Time: 15:47
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 12  *****************
+ * User: Es           Date: 18.12.98   Time: 13:05
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 11  *****************
+ * User: Vo           Date: 17.12.98   Time: 14:31
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 10  *****************
+ * User: Es           Date: 8.12.98    Time: 16:53
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ *
+ * *****************  Version 8  *****************
+ * User: Vo           Date: 24.11.98   Time: 21:40
+ * Updated in $/GSM/DEV/MS/SRC/MFW
+ * first successful compilation of MFW
+|
+| *****************  Version 6  *****************
+| User: Le           Date: 11.11.98   Time: 13:35
+| Updated in $/GSM/DEV/MS/SRC/MFW
+|
+| *****************  Version 5  *****************
+| User: Le           Date: 10.11.98   Time: 16:07
+| Updated in $/GSM/DEV/MS/SRC/MFW
+|
+| *****************  Version 4  *****************
+| User: Le           Date: 10.11.98   Time: 11:08
+| Updated in $/GSM/DEV/MS/SRC/MFW
+|
+| *****************  Version 3  *****************
+| User: Le           Date: 27.10.98   Time: 15:59
+| Updated in $/GSM/DEV/MS/SRC/MFW
+|
+| *****************  Version 2  *****************
+| User: Le           Date: 21.10.98   Time: 16:20
+| Updated in $/GSM/DEV/MS/SRC/MFW
+*/
+
+#define ENTITY_MFW
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined (NEW_FRAME)
+
+#include "typedefs.h"
+#include "vsi.h"
+#include "pei.h"
+#include "custom.h"
+#include "gsm.h"
+
+#else
+
+#include "stddefs.h"
+#include "custom.h"
+#include "gsm.h"
+#include "vsi.h"
+
+#endif
+
+#include "p_sim.h"
+#include "aci_cmh.h"
+#include "psa.h"
+#include "psa_sim.h"
+#include "pcm.h"
+#include "mfw_mfw.h"
+#include "mfw_nm.h"
+#include "mfw_sim.h"
+#include "mfw_sima.h"
+#include "mfw_simi.h"
+#include "mfw_nmi.h"
+#include "mfw_nma.h"
+#include "mfw_phb.h"
+#include "mfw_cm.h"
+#include "mfw_cmi.h"
+#include "mfw_acie.h"
+#include "mfw_sms.h"
+#include "mfw_smsi.h"
+#include "mfw_win.h"
+
+
+#include "ksd.h"
+#include "psa.h"
+
+#if defined (FAX_AND_DATA)
+#include "aci_fd.h"
+#endif
+
+#include "cmh.h"
+#include "phb.h"
+#include "cmh_phb.h"
+
+#include "mfw_ss.h"
+#include "mfw_ssi.h"
+
+#ifdef SIM_TOOLKIT
+#include "mfw_sat.h"
+#endif
+
+extern BOOL sima_response_cb (USHORT opc, void * data);
+extern void  simDecodeIMSI (UBYTE *ci, UBYTE li, UBYTE *di);
+extern UBYTE mfw_IMSI [];                  /* expanded IMSI (ASCIIZ)   */
+static T_MFW_SIM_STATUS sim_status;
+static T_MFW_SIM_CONFIG sim_config;
+static int pin_flag;
+static UBYTE pin_ident;
+
+UBYTE sim_nlock;                          /* Network lock             */
+UBYTE sim_splock;                         /* Service provider lock    */
+UBYTE sim_plock;                          /* SIM lock                 */
+UBYTE sim_nslock;                         /* Network SUBSET lock      */
+UBYTE sim_clock;                          /* corporate lock           */
+UBYTE sim_blocked;         					  		/* blocked flag			        */
+
+static UBYTE sim_service_table [10];      /* SIM service table        */
+static UBYTE sim_stat = SIM_NOT_ACTIVE;
+
+static int simCommand (ULONG cmd, void *h); /* handle win commands      */
+
+UBYTE pin1_set = MFW_SIM_UNKNOWN;
+UBYTE pin2_set = MFW_SIM_ENABLE;
+
+static BOOL sat_update = FALSE;
+
+static int pSlot;                       /* primitive handler slot   */
+
+EXTERN MfwHdr * current_mfw_elem;
+#if defined (WIN32)
+/*
+ * Only for windows to check several SIM lock combinations
+ */
+UBYTE sim_lock_mode = 0;     
+#endif
+UBYTE sim_lock_field = NOT_PRESENT_8BIT;  /* type of sim lock field   */
+
+static UBYTE sim_get_sim_lock      (EF_SIMLCKEXT * simlck);
+static void  sim_set_sim_lock      (EF_SIMLCKEXT * simlck);
+static void  sim_fill_sim_lock     (EF_SIMLCKEXT * simlck);
+static void  sim_check_unblock_sim (EF_SIMLCKEXT * simlck);
+
+#define SIMLOCK_DISABLED 0
+#define SIMLOCK_ENABLED  1
+#define SIMLOCK_LOCKED   2
+#define SIMLOCK_BLOCKED  3
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_init           |
++--------------------------------------------------------------------+
+
+  PURPOSE : initialize SIM manager
+
+*/
+
+int sim_init (void)
+{
+    EF_SIMLCKEXT simlck;
+
+    TRACE_FUNCTION("sim_init()");
+
+    /* 
+     * initialise SIM lock flags        
+     */
+    sim_nslock  = sim_plock = sim_nlock = sim_clock = sim_splock = 0; 
+    sim_blocked = FALSE;
+
+    /*
+     * Read SIM Lock Flags
+     */
+    if (sim_get_sim_lock (&simlck) EQ PCM_OK)
+    {
+      sim_plock  = (UBYTE) FldGet(simlck.locks1,plock);    
+      sim_nlock  = (UBYTE) FldGet(simlck.locks1,nlock);                                                        
+      sim_nslock = (UBYTE) FldGet(simlck.locks1,nslock); 
+      sim_splock = (UBYTE) FldGet(simlck.locks1,splock);   
+      sim_clock  = (UBYTE) FldGet(simlck.locks2,clock);   
+
+		  if (simlck.cnt >= simlck.maxcnt)
+			  sim_blocked = TRUE;
+		  else
+			  sim_blocked = FALSE;
+    }
+
+    pin_flag  = -1;
+	  pin_ident = MFW_SIM_UNKNOWN;
+
+    /* 
+     * install prim handler     
+     */
+    pSlot = aci_create(sima_response_cb,NULL);
+    mfwCommand[MfwTypSim] = (MfwCb) simCommand;
+
+    return TRUE;
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_init_sim_insert |
++---------------------------------------------------------------------+
+
+  PURPOSE : initialize SIM manager
+
+*/
+
+void sim_init_sim_insert()
+{
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_exit           |
++--------------------------------------------------------------------+
+
+  PURPOSE : finalize SIM manager
+
+*/
+
+void sim_exit (void)
+{
+    TRACE_FUNCTION("sim_exit()");
+
+    /* 
+     * remove prim handler      
+     */
+    aci_delete(pSlot);
+    sim_stat = SIM_NOT_ACTIVE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_create         |
++--------------------------------------------------------------------+
+
+  PURPOSE : create SIM event handler
+
+*/
+
+T_MFW_HND sim_create (MfwHnd hWin, MfwEvt event, MfwCb cbfunc)
+{
+    MfwHdr *hdr;
+    T_MFW_SIM *sim_para;
+
+    TRACE_FUNCTION("sim_create()");
+
+    hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
+    sim_para = (T_MFW_SIM *) mfwAlloc(sizeof(T_MFW_SIM));
+
+    if (!hdr || !sim_para)
+        return 0;
+
+    sim_para->emask = event;
+    sim_para->handler = cbfunc;
+
+    hdr->data = sim_para;
+    hdr->type = MfwTypSim;
+
+    return mfwInsert((MfwHdr *) hWin,hdr);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_delete         |
++--------------------------------------------------------------------+
+
+  PURPOSE : delete SIM event handler
+
+*/
+
+MfwRes sim_delete (MfwHnd h)
+{
+    TRACE_FUNCTION("sim_delete()");
+
+    if (!h || !((MfwHdr *) h)->data)
+        return MfwResIllHnd;
+
+    if (!mfwRemove((MfwHdr *) h))
+        return MfwResIllHnd;
+
+    mfwFree((U8 *) ((MfwHdr *) h)->data,sizeof(T_MFW_SIM));
+    mfwFree((U8 *) h,sizeof(MfwHdr));
+
+    return MfwResOk;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_signal         |
++--------------------------------------------------------------------+
+
+  PURPOSE : Send a signal
+
+*/
+
+void sim_signal (MfwEvt event, void *para)
+{
+    TRACE_FUNCTION ("sim_signal()");
+
+  if (mfwSignallingMethod EQ 0)
+  {
+    if (mfwFocus)
+        if (sim_sign_exec(mfwFocus,event,para))
+            return;
+    if (mfwRoot)
+        sim_sign_exec(mfwRoot,event,para);
+  }
+  else
+    {
+      MfwHdr * h = 0;
+
+      /*
+       * Focus set, then start here
+       */
+      if (mfwFocus)
+        h = mfwFocus;
+      /*
+       * Focus not set, then start root
+       */
+      if (!h)
+        h = mfwRoot;
+
+      /*
+       * No elements available, return
+       */
+
+      while (h)
+
+
+      {
+        /*
+         * Signal consumed, then return
+         */
+        if (sim_sign_exec (h, event, para))
+          return;
+
+        /*
+         * All windows tried inclusive root
+         */
+        if (h == mfwRoot)
+          return;
+
+        /*
+         * get parent window
+         */
+        h = mfwParent(mfwParent(h));
+		if(h)
+			h = ((MfwWin * )(h->data))->elems;
+      }
+      sim_sign_exec (mfwRoot, event, para);
+    }      
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_sign_exec      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Send a signal if SIM management handler
+
+*/
+
+int sim_sign_exec (MfwHdr *cur_elem, MfwEvt event, T_MFW_SIM_PARA *para)
+{
+
+    TRACE_FUNCTION("sim_sign_exec()");
+
+    while (cur_elem)
+    {
+        if (cur_elem->type == MfwTypSim)
+        {
+            T_MFW_SIM *sim_data;
+            sim_data = (T_MFW_SIM *) cur_elem->data;
+            if (sim_data->emask & event)
+            {
+                sim_data->event = event;
+                switch (event)
+                {
+                    case E_SIM_STATUS:
+                        memcpy(&sim_data->para.status,
+                                para,sizeof(T_MFW_SIM_STATUS));
+                        break;
+                }
+                if (sim_data->handler)
+                {
+                  // PATCH LE 06.06.00
+                  // store current mfw elem
+                  current_mfw_elem = cur_elem;
+                  // END PATCH LE 06.06.00
+                  if ((*(sim_data->handler))(sim_data->event,
+                                             (void *) &sim_data->para))
+                    return TRUE;
+                }
+            }
+        }
+        cur_elem = cur_elem->next;
+    }
+
+    return FALSE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_activate       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Start SIM card activation
+
+*/
+
+void sim_activate (void)
+{
+    TRACE_FUNCTION("sim_activate()");
+
+    /* 
+     * Full functionality is used donīt reset the ME 
+     */
+    if (sAT_PlusCFUN(CMD_SRC_LCL,CFUN_FUN_Full,CFUN_RST_NotPresent)
+        NEQ AT_EXCT)
+    {
+        TRACE_ERROR("sAT_PlusCFUN error");
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_spn_req        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request service provider name
+
+*/
+
+void sim_spn_req (void)
+{
+    T_EF_SPN spn;
+
+    TRACE_FUNCTION("sim_spn_req()");
+
+    memset(&spn,0,sizeof(T_EF_SPN));
+
+    if (sim_check_service(17,sim_service_table)
+        EQ ALLOCATED_AND_ACTIVATED)
+        sim_read_sim(SIM_SPN,17,17);
+    else
+        nm_spn_cnf(&spn);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_ok_cfun        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Notify successful end of SIM card activation
+
+*/
+
+void sim_ok_cfun (void)
+{
+    T_ACI_CFUN_FUN fun;
+
+    TRACE_FUNCTION ("sim_ok_cfun()");
+
+    qAT_PlusCFUN( CMD_SRC_LCL, &fun );
+
+    if( fun EQ CFUN_FUN_Full )
+    {
+      sim_stat = SIM_ACTIVE;
+      sim_status.sim_status = MFW_SIM_NO_PIN;
+      sim_status.sim_operation_mode = sim_config.oper_mode;
+      sim_status.sim_pin_retries = 0;
+      sim_status.sim_procedure = MFW_SIM_ACTIVATION;
+      sim_status.sim_status_type = pin_ident;
+
+      pin_ident = MFW_SIM_UNKNOWN;
+      sim_signal(E_SIM_STATUS,&sim_status);
+      nm_activate(MFW_SIM_NO_PIN);
+
+      pin1_set = MFW_SIM_DISABLE;
+    }
+    else if( fun EQ CFUN_FUN_Minimum )
+    {
+	    nm_ok_deregistration();
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_error_cfun     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Notify error status of SIM card
+
+*/
+
+void sim_error_cfun (U8 result)
+{
+    TRACE_FUNCTION("sim_error_cfun()");
+
+    sim_status.sim_procedure = MFW_SIM_ACTIVATION;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+
+    switch (result)
+    {
+        case CME_ERR_SimPinReq:         /* PIN 1 must be entered    */
+            sim_status.sim_status = MFW_SIM_PIN_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
+            sim_status.sim_status_type = MFW_SIM_PIN1;
+            sim_stat = SIM_ACTIVE;
+            break;
+        case CME_ERR_SimPin2Req:        /* PIN 2 must be entered    */
+            sim_status.sim_status = MFW_SIM_PIN2_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN2);
+            sim_status.sim_status_type = MFW_SIM_PIN2;
+            sim_stat = SIM_ACTIVE;
+            break;
+        case CME_ERR_SimPukReq:         /* PUK 1 must be entered    */
+            sim_status.sim_status = MFW_SIM_PUK_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK1);
+            sim_status.sim_status_type = MFW_SIM_PUK1;
+            sim_stat = SIM_ACTIVE;
+            break;
+        case CME_ERR_SimPuk2Req:        /* PUK 2 must be entered    */
+            sim_status.sim_status = MFW_SIM_PUK2_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK2);
+            sim_status.sim_status_type = MFW_SIM_PUK2;
+            sim_stat = SIM_ACTIVE;
+            break;
+        case CME_ERR_SimFail:           /* SIM card is invalid      */
+        case CME_ERR_SimWrong:
+            sim_status.sim_status = MFW_SIM_INVALID_CARD;
+            sim_status.sim_pin_retries = 0;
+            sim_status.sim_status_type = MFW_SIM_UNKNOWN;
+            sim_stat = SIM_NOT_ACTIVE;
+            break;
+        case CME_ERR_SimNotIns:         /* no SIM card inserted     */
+            sim_status.sim_status = MFW_SIM_NO_SIM_CARD;
+            sim_status.sim_pin_retries = 0;
+            sim_status.sim_status_type = MFW_SIM_UNKNOWN;
+            sim_stat = SIM_NOT_ACTIVE;
+            break;
+        default:
+            TRACE_ERROR("sim_error_cfun(): result");
+            return;
+    }
+
+    sim_signal(E_SIM_STATUS,&sim_status);
+
+    if ((result == CME_ERR_SimPinReq)
+        OR (result == CME_ERR_SimPukReq))
+        pin1_set = MFW_SIM_ENABLE;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_error_cpin     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Inform about error of PIN entering or PUK entering
+
+*/
+
+void sim_error_cpin (T_ACI_CME_ERR reason)
+{
+    T_ACI_CPIN_RSLT code;
+
+    TRACE_FUNCTION("sim_error_cpin()");
+
+    sim_status.sim_procedure = pin_flag;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_status = MFW_SIM_FAILURE;
+    sim_status.sim_status_type = pin_ident;
+
+	  pin_flag = -1;
+	  pin_ident = MFW_SIM_UNKNOWN;
+
+    switch (reason)
+    {
+        case CME_ERR_WrongPasswd:
+            if (qAT_PlusCPIN(CMD_SRC_LCL,&code) != AT_CMPL)
+            {
+                TRACE_ERROR("sim_error_cpin():CPIN? failed");
+                sim_signal(E_SIM_STATUS,&sim_status);
+                return;
+            }
+            break;
+        case CME_ERR_SimWrong:
+			sim_status.sim_status = MFW_SIM_INVALID_CARD;
+            sim_signal(E_SIM_STATUS,&sim_status);
+            return;
+        default:
+            TRACE_ERROR("sim_error_cpin():Ill reason");
+            sim_signal(E_SIM_STATUS,&sim_status);
+            return;
+    }
+
+    switch (code)
+    {
+        case CPIN_RSLT_SimPinReq:
+            sim_status.sim_status = MFW_SIM_PIN_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
+            break;
+        case CPIN_RSLT_SimPukReq:
+            sim_status.sim_status = MFW_SIM_PUK_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK1);
+            break;
+        case CPIN_RSLT_SimPin2Req:
+            sim_status.sim_status = MFW_SIM_PIN2_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN2);
+            break;
+        case CPIN_RSLT_SimPuk2Req:
+            sim_status.sim_status = MFW_SIM_PUK2_REQ;
+            sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK2);
+            break;
+        case CPIN_RSLT_NotPresent:
+        case CPIN_RSLT_SimReady:
+        default:
+            TRACE_ERROR("sim_error_cpin():Ill code");
+            break;
+    }
+
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_ok_cpin        |
++--------------------------------------------------------------------+
+
+  PURPOSE : Successful end of PIN entering or PUK entering
+
+*/
+
+void sim_ok_cpin (void)
+{
+    TRACE_FUNCTION("sim_ok_cpin()");
+
+    switch (pin_flag)
+    {
+        case MFW_SIM_VERIFY:
+            sim_status.sim_procedure = MFW_SIM_VERIFY;
+            sim_status.sim_status = MFW_SIM_NO_PIN;
+            sim_status.sim_status_type = pin_ident;
+            break;
+        case MFW_SIM_UNBLOCK:
+            sim_status.sim_procedure = MFW_SIM_UNBLOCK;
+            sim_status.sim_status = MFW_SIM_SUCCESS;
+            sim_status.sim_status_type = pin_ident;
+            break;
+        default:
+            break;
+    }
+
+    pin_flag = -1;
+	  pin_ident = MFW_SIM_UNKNOWN;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_pin_retries = 0;
+
+    sim_signal (E_SIM_STATUS, &sim_status);
+    if (nm_reg_flag_req())
+      nm_activate(MFW_SIM_NO_PIN);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_ss_unblock     |
++--------------------------------------------------------------------+
+
+  PURPOSE : SIM unblock via SS string
+
+*/
+
+void sim_ss_unblock(UBYTE result, T_ACI_CME_ERR reason)
+{
+    TRACE_FUNCTION("sim_ss_unblock()");
+        
+    pin_flag = MFW_SIM_UNBLOCK;
+
+    if (result == SIM_UBLK_ERROR)
+        sim_error_cpin (reason);
+    if (result == SIM_UBLK_OK)
+        sim_ok_cpin ();
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_verify_pin     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Verify PIN
+
+*/
+
+void sim_verify_pin (U8 pin_id, char *pin)
+{
+	TRACE_FUNCTION("sim_verify_pin()");
+
+    pin_flag = MFW_SIM_VERIFY;
+	  pin_ident = pin_id;
+    switch (pin_id)
+    {
+        case MFW_SIM_PIN1:
+            sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Pin1, pin, 0);
+            break;
+        case MFW_SIM_PIN2:
+            sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Pin2, pin, 0);
+            break;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_unblock_pin    |
++--------------------------------------------------------------------+
+
+  PURPOSE : unblock SIM
+
+*/
+
+void sim_unblock_pin (U8 pin_id, char *puk, char *newpin)
+{
+    TRACE_FUNCTION("sim_unblock_pin()");
+
+    pin_flag = MFW_SIM_UNBLOCK;
+	  pin_ident = pin_id;
+    switch (pin_id)
+    {
+        case MFW_SIM_PUK1:
+            sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Puk1, puk, newpin);
+            break;
+        case MFW_SIM_PUK2:
+            sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Puk2, puk, newpin);
+            break;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_change_pin     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request of PIN change
+
+*/
+
+void sim_change_pin (U8 pin_id, U8 *old_pin, U8 *new_pin)
+{
+    TRACE_FUNCTION("sim_change_pin()");
+
+    pin_ident = pin_id;
+    switch (pin_id)
+    {
+        case MFW_SIM_PIN1:
+            sAT_PlusCPWD(CMD_SRC_LCL, CPWD_FAC_Sc,
+                         (char *)old_pin, (char *)new_pin);
+            break;
+        case MFW_SIM_PIN2:
+            sAT_PlusCPWD(CMD_SRC_LCL, CPWD_FAC_P2,
+                         (char *)old_pin, (char *)new_pin);
+            break;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_ok_cpinc       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Notify successful end of PIN change
+
+*/
+
+void sim_ok_cpinc (void)
+{
+    TRACE_FUNCTION("sim_ok_cpinc()");
+
+    sim_status.sim_procedure = MFW_SIM_CHANGE;
+    sim_status.sim_status = MFW_SIM_SUCCESS;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_pin_retries = 0;
+    sim_status.sim_status_type = pin_ident;
+
+    pin_ident = MFW_SIM_UNKNOWN;
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_error_cpinc    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Notify failed PIN change
+
+*/
+
+void sim_error_cpinc (void)
+{
+    TRACE_FUNCTION("sim_error_cpinc()");
+
+    sim_status.sim_procedure = MFW_SIM_CHANGE;
+    sim_status.sim_status = MFW_SIM_FAILURE;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    if (pin_ident EQ MFW_SIM_PIN1)
+      sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
+    else if (pin_ident EQ MFW_SIM_PIN2)
+      sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN2);
+    else
+      sim_status.sim_pin_retries = 0;
+    sim_status.sim_status_type = pin_ident;
+
+    pin_ident = MFW_SIM_UNKNOWN;
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_disable_pin    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request PIN disability
+
+*/
+
+void sim_disable_pin (U8 *pin)
+{
+    TRACE_FUNCTION("sim_disable_pin()");
+
+    ss_set_clck(CLCK_FAC_Sc, CLCK_MOD_Unlock,
+               (char *)pin, -1, MFW_SIM_CPIND);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_ok_cpind       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Successful end of PIN disability
+
+*/
+
+void sim_ok_cpind (void)
+{
+    TRACE_FUNCTION("sim_ok_cpind()");
+
+    sim_status.sim_procedure = MFW_SIM_DISABLE;
+    sim_status.sim_status = MFW_SIM_SUCCESS;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_pin_retries = 0;
+    sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
+
+    pin1_set = MFW_SIM_DISABLE;
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_error_cpind    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Failed PIN disability
+
+*/
+
+void sim_error_cpind (void)
+{
+    TRACE_FUNCTION("sim_error_cpind()");
+
+    sim_status.sim_procedure = MFW_SIM_DISABLE;
+    sim_status.sim_status = MFW_SIM_FAILURE;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
+    sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
+
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_enable_pin     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request PIN enability
+
+*/
+
+void sim_enable_pin (U8 *pin)
+{
+    TRACE_FUNCTION("sim_enable_pin()");
+
+    ss_set_clck(CLCK_FAC_Sc, CLCK_MOD_Lock,
+               (char *)pin, -1, MFW_SIM_CPINE);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_ok_cpine       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Successful end of PIN enability
+
+*/
+
+void sim_ok_cpine()
+{
+    TRACE_FUNCTION("sim_ok_cpine()");
+
+    sim_status.sim_procedure = MFW_SIM_ENABLE;
+    sim_status.sim_status = MFW_SIM_SUCCESS;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_pin_retries = 0;
+    sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
+
+    pin1_set = MFW_SIM_ENABLE;
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_error_cpine    |
++--------------------------------------------------------------------+
+
+  PURPOSE : Failed PIN enability
+
+*/
+
+void sim_error_cpine (void)
+{
+    TRACE_FUNCTION("sim_error_cpine()");
+
+    sim_status.sim_procedure = MFW_SIM_ENABLE;
+    sim_status.sim_status = MFW_SIM_FAILURE;
+    sim_status.sim_operation_mode = sim_config.oper_mode;
+    sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
+    sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
+
+    sim_signal(E_SIM_STATUS,&sim_status);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM           |
+| STATE   : code                         ROUTINE : sim_check_service |
++--------------------------------------------------------------------+
+
+  PURPOSE : Checks a service status
+
+*/
+
+U8 sim_check_service (U8 nr, U8 *serv_table)
+{
+    U8 value;
+
+    TRACE_FUNCTION("sim_check_service()");
+
+    value = *(serv_table + (nr - 1) / 4);
+    value >>=  ((nr - 1) & 3) * 2;
+
+    return (value & 3);
+}
+
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM              |
+| STATE   : code                         ROUTINE : sim_serv_table_check |
++-----------------------------------------------------------------------+
+
+  PURPOSE : Checks a service status in SIM service table
+
+*/
+
+T_MFW sim_serv_table_check(UBYTE serv_num)
+{
+  TRACE_FUNCTION("sim_serv_table_check()");
+  return sim_check_service(serv_num, sim_service_table);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM           |
+| STATE   : code                         ROUTINE : rAT_PlusCFUNP     |
++--------------------------------------------------------------------+
+
+  PURPOSE : MMI relevant parameters from the SIM card
+
+*/
+
+void rAT_PlusCFUNP (T_SIM_MMI_INSERT_IND *mmi_insert_ind)
+{
+    TRACE_FUNCTION("rAT_PlusCFUNP()");
+
+    sim_stat = SIM_ACTIVE;
+
+    sim_config.oper_mode = mmi_insert_ind->func;
+    //  sms_mmi_parameter(mmi_insert_ind->cbmid);
+    nm_mmi_parameters(&mmi_insert_ind->imsi_field,
+                        &mmi_insert_ind->pref_plmn);
+    memcpy(sim_service_table,mmi_insert_ind->sim_serv,
+                                sizeof(sim_service_table));
+    //memcpy(sim_config.deper_key,mmi_insert_ind->deper_key,
+    //                            sizeof(sim_config.deper_key));
+    sim_config.phase = mmi_insert_ind->phase;
+    sim_config.access_acm = mmi_insert_ind->access_acm;
+    sim_config.access_acmmax = mmi_insert_ind->access_acmmax;
+    sim_config.access_puct = mmi_insert_ind->access_puct;
+
+//    sim_init_sim_insert();
+
+    if (sim_check_service(15,sim_service_table)
+        == ALLOCATED_AND_ACTIVATED)
+        sim_read_sim(SIM_GID1, NOT_PRESENT_8BIT, 5);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM           |
+| STATE   : code                         ROUTINE : sim_mmi_parameter |
++--------------------------------------------------------------------+
+
+  PURPOSE : MMI relevant parameters from the SIM card
+
+*/
+
+void sim_mmi_parameter(T_SIM_ACTIVATE_CNF *sim_act_cnf)
+{
+  TRACE_FUNCTION("sim_mmi_parameter()");
+
+  memcpy( sim_config.pref_lang, sim_act_cnf->pref_lang, 5);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM           |
+| STATE   : code                         ROUTINE : sim_gid1_cnf      |
++--------------------------------------------------------------------+
+
+  PURPOSE : read SIM group identifier 1 from SIM card
+
+*/
+
+void sim_gid1_cnf(SHORT error, UBYTE *data)
+{
+  TRACE_FUNCTION("sim_gid1_cnf()");
+
+  if (error EQ SIM_NO_ERROR)
+    memcpy(sim_config.sim_gidl1, data, 5);
+
+  if (!sat_update)
+  {
+    if (sim_check_service(16,sim_service_table)
+        == ALLOCATED_AND_ACTIVATED)
+        sim_read_sim(SIM_GID2, NOT_PRESENT_8BIT, 5);
+  }
+#ifdef SIM_TOOLKIT
+  else
+  {
+    sat_update = FALSE;
+    satUpdateFiles ( TRUE, SIM_GID1 );
+  }
+#endif
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM           |
+| STATE   : code                         ROUTINE : sim_gid2_cnf      |
++--------------------------------------------------------------------+
+
+  PURPOSE : read SIM group identifier 2 from SIM card
+
+*/
+
+void sim_gid2_cnf(SHORT error, UBYTE *data)
+{
+  TRACE_FUNCTION("sim_gid2_cnf()");
+  if (error EQ SIM_NO_ERROR)
+    memcpy(sim_config.sim_gidl2, data, 5);
+
+#ifdef SIM_TOOLKIT
+  if ( sat_update )
+  {
+    sat_update = FALSE;
+    satUpdateFiles ( TRUE, SIM_GID2 );
+  }
+#endif
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_save_pref_lang |
++--------------------------------------------------------------------+
+
+  PURPOSE : save preferred language
+
+*/
+
+void sim_save_pref_lang (UBYTE *lang, UBYTE len)
+{
+  UBYTE sim_data[7];
+  UBYTE i;
+
+  TRACE_FUNCTION("sim_save_pref_lang()");
+
+  //
+  // copy a maximum of 5 bytes for storing on the SIM card
+  //
+  for (i=0;i<len AND i<5;i++)
+    sim_data[i] = lang[i];
+
+  //
+  // if less than 5 bytes fill with dummy values
+  //
+  for (i=len; i<5;i++)
+    sim_data[i] = 0xFF;
+
+  //
+  // write to the SIM card
+  //
+  sim_write_sim(SIM_LP, sim_data, 5);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : rAT_PercentSIMREM  |
++--------------------------------------------------------------------+
+
+  PURPOSE : call back for SIM removed
+
+*/
+
+void rAT_PercentSIMREM( T_ACI_SIMREM_TYPE srType )
+{
+    TRACE_FUNCTION("rAT_PercentSIMREM()");
+
+    if ( srType EQ SIMREM_FAILURE )
+    {
+      sim_status.sim_procedure = MFW_SIM_REMOVED;
+      sim_status.sim_status = MFW_SIM_NO_SIM_CARD;
+      sim_status.sim_operation_mode = sim_config.oper_mode;
+      sim_status.sim_pin_retries = 0;
+      sim_status.sim_status_type = MFW_SIM_UNKNOWN;
+      sim_stat = SIM_NOT_ACTIVE;
+      sim_signal(E_SIM_STATUS,&sim_status);
+    }
+    else if ( srType EQ SIMREM_RESET )
+    {
+#ifdef SIM_TOOLKIT
+      sim_signal(E_SIM_RESET, 0); 
+#endif
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : rAT_percentSIMINS  |
++--------------------------------------------------------------------+
+
+  PURPOSE : call back for SIM inserted
+
+*/
+
+void rAT_PercentSIMINS( T_ACI_CME_ERR err )
+{
+    TRACE_FUNCTION("rAT_percentSIMINS()");
+
+    sim_signal(E_SIM_INSERTED, 0);
+
+    switch ( err )
+    {
+      case CME_ERR_SimPinReq:
+        sim_status.sim_status = MFW_SIM_PIN_REQ;
+        sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
+        sim_status.sim_status_type = MFW_SIM_PIN1;
+        sim_stat = SIM_ACTIVE;
+        sim_signal(E_SIM_STATUS, &sim_status);
+        break;
+
+      case CME_ERR_SimPukReq:
+        sim_status.sim_status = MFW_SIM_PUK_REQ;
+        sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK1);
+        sim_status.sim_status_type = MFW_SIM_PUK1;
+        sim_stat = SIM_ACTIVE;
+        sim_signal(E_SIM_STATUS, &sim_status);
+        break;
+
+      default:
+        break;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_configuration  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request the configuration of SIM card
+
+*/
+
+UBYTE sim_cvt_access_status(UBYTE acs)
+{
+    TRACE_FUNCTION("sim_cvt_access_status()");
+    
+    switch(acs)
+    {
+        case ACCESS_ALWAYS: return MFW_SIM_NO_PIN;
+        case ACCESS_PIN_1:  return MFW_SIM_PIN1;
+        case ACCESS_PIN_2:  return MFW_SIM_PIN2;
+        default:            return MFW_SIM_UNKNOWN;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_configuration  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request the configuration of SIM card
+
+*/
+
+MfwRes sim_configuration (U8 *phase, U8 *serv, U8 *slen,
+                          U8 *lang, U8 *llen,
+                          T_MFW_AOC_ACCESS *access)
+{
+    U8 l;
+    TRACE_FUNCTION("sim_configuration()");
+
+		//PATCH2 TB 1310: Add test of NULL parameter to avoid to declare parameter of unwanted data
+    if (sim_stat != SIM_ACTIVE)
+        return MFW_SIM_FAILURE;
+
+		if (phase != NULL)
+			*phase = sim_config.phase;
+
+		if ((serv != NULL) && (slen != NULL))
+		{			
+			l = sizeof(sim_service_table);
+			if (l < *slen)
+					*slen = l;
+			memcpy(serv,sim_service_table,*slen);
+		}
+
+    //PATCH1 TB 1310: replace slen by llen
+		if ((lang != NULL) && (llen != NULL))
+		{
+			l = sizeof(sim_config.pref_lang);
+			if (l < *llen)
+					*llen = l;
+			memcpy(lang, sim_config.pref_lang, *llen);
+		}
+		//END PATCH1 TB
+
+		if (access != NULL)
+		{
+			access->access_acm    = sim_cvt_access_status(sim_config.access_acm);
+			access->access_acmmax = sim_cvt_access_status(sim_config.access_acmmax);
+			access->access_puct   = sim_cvt_access_status(sim_config.access_puct);
+		}
+		//END PATCH2 TB
+
+    return MFW_SIM_SUCCESS;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_status_check   |
++--------------------------------------------------------------------+
+
+  PURPOSE : check activation of SIM card
+
+*/
+
+int sim_status_check (void)
+{
+    TRACE_FUNCTION("sim_status_check()");
+
+    return sim_stat;
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_pin_count      |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request PIN/PUK count
+
+*/
+
+int sim_pin_count(U8 pin_id)
+{
+    SHORT        pn1Cnt;
+    SHORT        pn2Cnt;
+    SHORT        pk1Cnt;
+    SHORT        pk2Cnt;
+    T_ACI_PVRF_STAT ps1;
+    T_ACI_PVRF_STAT ps2;
+        
+    TRACE_FUNCTION("sim_pin_count()");
+
+
+    if (qAT_PercentPVRF(CMD_SRC_LCL, &pn1Cnt,
+                        &pn2Cnt, &pk1Cnt, &pk2Cnt, &ps1, &ps2) != AT_CMPL)
+        return -1;
+
+    switch (pin_id)
+    {
+        case MFW_SIM_PIN1:  return pn1Cnt;
+        case MFW_SIM_PIN2:  return pn2Cnt;
+        case MFW_SIM_PUK1:  return pk1Cnt;
+        case MFW_SIM_PUK2:  return pk2Cnt;
+        default:            return -1;
+    }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : simDecodeB2A       |
++--------------------------------------------------------------------+
+
+  PURPOSE : convert bcd to ASCII
+
+*/
+
+void simDecodeB2A (U8 *ci, U8 li, U8 *di)
+{
+    int i;
+    
+    TRACE_FUNCTION("simDecodeB2A()");
+
+    for (i = 0; i < li * 2; i++)
+    {
+        di[i] = (i & 1) ? (ci[i/2] >> 4) + '0'
+                        : (ci[i/2] & 0x0f) + '0';
+        if (di[i] > '9')
+        {
+            di[i] = 0;
+            break;
+        }
+    }
+    di[i] = 0;
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_unlock_sim_lock |
++---------------------------------------------------------------------+
+
+  PURPOSE : de-personalisation for SIM lock.
+
+*/
+
+T_MFW sim_unlock_sim_lock(UBYTE type, UBYTE *passwd)
+{
+  UBYTE        eep_ckey [LONG_NAME];  // extracted version of PCM content          
+  EF_SIMLCKEXT simlck;
+
+  TRACE_FUNCTION("sim_unlock_sim_lock()");
+
+  /*
+   * Read SIM LOCK Record from PCM
+   */
+  if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+  {
+    TRACE_ERROR("No SIMLCK");
+    return MFW_SIM_UNLOCK_ERR;
+  }
+
+  /*
+   * check whether card is already blocked
+   */
+	if (simlck.cnt >= simlck.maxcnt)
+		return MFW_SIM_BLOCKED;
+
+  switch (type)
+  {
+    /*
+     * N-Lock
+     */
+    case MFW_SIM_NLOCK:
+      /*
+       * Extract Key from PCM record
+       */
+      simDecodeB2A (simlck.NKey, 8, eep_ckey);
+      if (!strcmp((char *)eep_ckey, (char *)passwd))
+			{
+        /*
+         * unblock password is okay
+         */
+				sim_nlock     = SIMLOCK_ENABLED;
+				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nlock,sim_nlock);
+				simlck.cnt    = 0;
+				sim_set_sim_lock (&simlck);
+
+				return MFW_SIM_NLOCK;
+			}
+			break;
+
+    /*
+     * SP-Lock
+     */
+    case MFW_SIM_SPLOCK:
+      /*
+       * Extract Key from PCM record
+       */
+      simDecodeB2A (simlck.SPKey, 8, eep_ckey);
+      if (!strcmp((char *)eep_ckey, (char *)passwd))
+      {
+        /*
+         * unblock password is okay
+         */
+				sim_splock    = SIMLOCK_ENABLED;
+				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
+				simlck.cnt    = 0;
+				sim_set_sim_lock (&simlck);
+
+        return MFW_SIM_SPLOCK;
+			}
+			break;
+    
+    /*
+     * NS-Lock
+     */
+    case MFW_SIM_NSLOCK:
+      /*
+       * Extract Key from PCM record
+       */
+      simDecodeB2A (simlck.NSKey, 8, eep_ckey);
+      if (!strcmp((char *)eep_ckey, (char *)passwd))
+      {
+        /*
+         * unblock password is okay
+         */
+   			sim_nslock    = SIMLOCK_ENABLED;
+				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nslock,sim_nslock);
+				simlck.cnt    = 0;
+				sim_set_sim_lock (&simlck);
+
+				return MFW_SIM_NSLOCK;
+			}
+			break;
+
+    /*
+     * C-Lock
+     */
+    case MFW_SIM_CLOCK:
+      /*
+       * Extract Key from PCM record
+       */
+      simDecodeB2A (simlck.CKey, 8, eep_ckey);
+      if (!strcmp((char *)eep_ckey, (char *)passwd))
+      {
+        /*
+         * unblock password is okay
+         */
+				sim_clock     = SIMLOCK_ENABLED;
+				simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
+				simlck.cnt    = 0;
+				sim_set_sim_lock (&simlck);
+
+				return MFW_SIM_CLOCK;
+			}
+			break;
+
+    /*
+     * P-Lock
+     */
+    case MFW_SIM_PLOCK:
+      /*
+       * Extract Key from PCM record
+       */
+      simDecodeB2A (simlck.PKey, 8, eep_ckey);
+      if (!strcmp((char *)eep_ckey, (char *)passwd))
+      {
+        /*
+         * unblock password is correct
+         */
+				sim_plock     = SIMLOCK_ENABLED;
+				simlck.locks1 = (UBYTE) FldSet(simlck.locks1,plock,sim_plock);
+				simlck.cnt    = 0;
+				sim_set_sim_lock (&simlck);
+
+				return MFW_SIM_PLOCK;
+			}
+			break;
+
+    default:
+      return MFW_SIM_UNLOCK_ERR;
+  }
+
+  /*
+   * another failed attempt
+   * increment counter, store in PCM and may change the status
+   */
+	simlck.cnt++;
+	sim_set_sim_lock (&simlck);
+
+	if (simlck.cnt >= simlck.maxcnt)
+	{
+		sim_blocked = TRUE;    
+		return MFW_SIM_BLOCKED;
+	}
+	else
+		return MFW_SIM_UNLOCK_ERR;
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_check_sim_Plock |
++---------------------------------------------------------------------+
+
+  PURPOSE : check SIM lock
+
+*/
+
+int sim_check_sim_Plock (void)
+{
+  EF_SIMLCKEXT simlck;
+  UBYTE        i;
+
+  TRACE_FUNCTION ("sim_check_sim_Plock()");
+
+
+	if (sim_blocked EQ TRUE OR 
+      sim_plock   EQ SIMLOCK_BLOCKED)
+  {
+    /*
+     * Try to reset unlock attempt counter
+     */
+    sim_check_unblock_sim (&simlck);
+		return MFW_SIM_BLOCKED;
+  }
+
+  /* 
+   * lock check disabled      
+   */
+  if (sim_plock EQ SIMLOCK_DISABLED) 
+    return MFW_SIM_DISABLE;
+
+  /* 
+   * lock check blocked      
+   */
+  if (sim_plock EQ SIMLOCK_LOCKED)              
+    return MFW_SIM_LOCKED;
+
+  /*
+   * lock check enabled       
+   */
+  if (sim_plock EQ SIMLOCK_ENABLED)              
+  {
+    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+    {
+      TRACE_ERROR("No SIMLCK");
+      return MFW_SIM_FAILURE;     
+    }
+
+    /*
+     * Check all digits
+     */
+		for (i=0; i<simlck.len_p_imsi; i++)
+		{
+			if (sim_check_imsi_digit(simlck.p_imsi[i], mfw_IMSI[i]) EQ FALSE)
+				break;
+		}
+    
+    /*
+     * all digits okay
+     */
+		if (i EQ simlck.len_p_imsi)
+			return MFW_SIM_ENABLE;
+
+    /*
+     * P-LOCK check failed
+     */
+
+    sim_plock     = SIMLOCK_LOCKED;
+		simlck.locks1 = (UBYTE) FldSet(simlck.locks1,plock,sim_plock);
+		sim_set_sim_lock (&simlck);
+    return MFW_SIM_LOCKED;
+  }
+
+  /*
+   * shall not happen
+   */
+  return MFW_SIM_FAILURE;
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_check_sim_Nlock |
++---------------------------------------------------------------------+
+
+  PURPOSE : Check network lock
+
+*/
+
+int sim_check_sim_Nlock (void)
+{
+  EF_SIMLCKEXT simlck;
+	UBYTE        i;
+
+  TRACE_FUNCTION ("sim_check_sim_Nlock()");
+
+	if (sim_blocked EQ TRUE OR 
+      sim_nlock   EQ SIMLOCK_BLOCKED)
+  {
+    /*
+     * Try to reset unlock attempt counter
+     */
+    sim_check_unblock_sim (&simlck);
+		return MFW_SIM_BLOCKED;
+  }
+
+  /*
+   * lock check disabled
+   */
+  if (sim_nlock EQ SIMLOCK_DISABLED)             
+    return MFW_SIM_DISABLE;
+
+  /*
+   * lock check blocked
+   */
+  if (sim_nlock EQ SIMLOCK_LOCKED)            
+        return MFW_SIM_LOCKED;
+
+  /*
+   * lock check enabled
+   */
+  if (sim_nlock EQ SIMLOCK_ENABLED)
+  {
+    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+    {
+      TRACE_ERROR("No SIMLCK");
+      return MFW_SIM_FAILURE;     
+    }
+
+    /*
+     * check all digits
+     */
+		for (i=0; i<simlck.len_n_imsi; i++)	
+    {
+      if (sim_check_imsi_digit(simlck.n_imsi[i], mfw_IMSI[i]) EQ FALSE)
+				break;
+		}
+
+    /*
+     * all digits okay
+     */
+		if (i EQ simlck.len_n_imsi)
+			return MFW_SIM_ENABLE;
+
+    /*
+     * N-LOCK check failed
+     */
+    sim_nlock     = SIMLOCK_LOCKED;
+		simlck.locks1 = (U8) FldSet(simlck.locks1,nlock,sim_nlock);
+		sim_set_sim_lock (&simlck);
+    return MFW_SIM_LOCKED;
+  }
+  /*
+   * shall not happen
+   */
+  return MFW_SIM_FAILURE;
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_check_sim_SPlock|
++---------------------------------------------------------------------+
+
+  PURPOSE : Check SIM service provider lock. It only works with SIMs
+            which support GID1 file.
+
+*/
+
+int sim_check_sim_SPlock (void)
+{
+  EF_SIMLCKEXT simlck;
+	UBYTE        i;
+
+  TRACE_FUNCTION ("sim_check_sim_SPlock()");
+
+  /*
+   * Only if Service 15 is activated and allocated
+   */
+  if (sim_check_service(15,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
+    return MFW_SIM_FAILURE;
+
+	if (sim_blocked EQ TRUE OR 
+      sim_splock  EQ SIMLOCK_BLOCKED)
+  {
+    /*
+     * Try to reset unlock attempt counter
+     */
+    sim_check_unblock_sim (&simlck);
+		return MFW_SIM_BLOCKED;
+  }
+
+  /*
+   * lock check disabled
+   */
+  if (sim_splock EQ SIMLOCK_DISABLED)
+    return MFW_SIM_DISABLE;
+
+  /*
+   * lock check blocked
+   */
+  if (sim_splock EQ SIMLOCK_LOCKED)
+    return MFW_SIM_LOCKED;
+
+  /*
+   * lock check enabled
+   */
+  if (sim_splock EQ SIMLOCK_ENABLED)             
+  {
+    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+    {
+      TRACE_ERROR("No SIMLCK");
+      return MFW_SIM_FAILURE;     
+    }
+
+    /* 
+     * check SP group identifier 
+     */
+    if (memcmp(&simlck.gidl1, sim_config.sim_gidl1, 1))
+    {
+      sim_splock    = SIMLOCK_LOCKED;
+			simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
+			sim_set_sim_lock (&simlck);
+      
+      return MFW_SIM_LOCKED;
+    }
+
+    /* 
+     * check all digits
+     */
+		for (i=0; i<simlck.len_sp_imsi; i++)
+		{
+			if (sim_check_imsi_digit(simlck.sp_imsi[i], mfw_IMSI[i]) EQ FALSE)
+				break;
+		}
+
+    /*
+     * all digits okay
+     */
+		if (i EQ simlck.len_sp_imsi)
+			return MFW_SIM_ENABLE;
+
+    /*
+     * failed SP-Lock
+     */
+    sim_splock    = SIMLOCK_LOCKED;
+		simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
+		sim_set_sim_lock (&simlck);
+
+    return MFW_SIM_LOCKED;
+  }
+  /*
+   * shall not happen
+   */
+  return MFW_SIM_FAILURE;
+}
+
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_check_sim_NSlock|
++---------------------------------------------------------------------+
+
+  PURPOSE : Check network subset lock
+
+*/
+
+int sim_check_sim_NSlock (void)
+{
+  EF_SIMLCKEXT simlck;
+	UBYTE        i;
+
+  TRACE_FUNCTION ("sim_check_sim_NSlock()");
+
+	if (sim_blocked EQ TRUE OR 
+      sim_nslock  EQ SIMLOCK_BLOCKED)
+  {
+    /*
+     * Try to reset unlock attempt counter
+     */
+    sim_check_unblock_sim (&simlck);
+		return MFW_SIM_BLOCKED;
+  }
+
+  /* 
+   * lock check disabled
+   */
+  if (sim_nslock EQ SIMLOCK_DISABLED)
+    return MFW_SIM_DISABLE;
+
+  /*
+   * lock check blocked
+   */
+  if (sim_nslock EQ SIMLOCK_LOCKED)
+    return MFW_SIM_LOCKED;
+
+  /*
+   * lock check enabled
+   */
+  if (sim_nslock EQ SIMLOCK_ENABLED)
+  {
+    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+    {
+      TRACE_ERROR("No SIMLCK");
+      return MFW_SIM_FAILURE;     
+    }
+
+    /*
+     * check all digits
+     */
+    for (i=0; i<simlck.len_ns_imsi; i++)
+		{
+			if (sim_check_imsi_digit(simlck.ns_imsi[i], mfw_IMSI[i]) EQ FALSE)
+				break;
+		}
+
+    /*
+     * all digits okay
+     */
+		if (i EQ simlck.len_ns_imsi)
+			return MFW_SIM_ENABLE;
+
+    /*
+     * Lock has failed
+     */
+    sim_nslock    = SIMLOCK_LOCKED;
+		simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nslock,sim_nslock);
+		sim_set_sim_lock (&simlck);
+
+    return MFW_SIM_LOCKED;
+  }
+
+  /*
+   * shall not happen
+   */
+  return MFW_SIM_FAILURE;
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM             |
+| STATE   : code                        ROUTINE : sim_check_sim_Clock |
++---------------------------------------------------------------------+
+
+  PURPOSE : Check corporate lock. It only works with SIMs
+            which support GID1 and GID2 files.
+
+*/
+
+int sim_check_sim_Clock (void)
+{
+  EF_SIMLCKEXT simlck;
+  UBYTE        i;
+
+  TRACE_FUNCTION ("sim_check_sim_Clock()");
+
+  /* 
+   * check the SIM supports GID1 and GID2 
+   */
+  if (sim_check_service(15,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
+    return MFW_SIM_FAILURE;
+
+  if (sim_check_service(16,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
+    return MFW_SIM_FAILURE;
+
+	if (sim_blocked EQ TRUE OR
+      sim_clock   EQ SIMLOCK_BLOCKED)
+  {
+    /*
+     * Try to reset unlock attempt counter
+     */
+    sim_check_unblock_sim (&simlck);
+		return MFW_SIM_BLOCKED;
+  }
+
+  /*
+   * lock check disabled
+   */
+  if (sim_clock EQ SIMLOCK_DISABLED)
+    return MFW_SIM_DISABLE;
+
+  /*
+   * lock check blocked
+   */
+  if (sim_clock EQ SIMLOCK_LOCKED)
+    return MFW_SIM_LOCKED;
+
+  /*
+   * lock check enabled
+   */
+  if (sim_clock EQ SIMLOCK_ENABLED)            
+  {
+    if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+    {
+      TRACE_ERROR("No SIMLCK");
+      return MFW_SIM_FAILURE;     
+    }
+
+    /* 
+     * check SP group identifier 1 and 2 
+     */
+    if (simlck.gidl1 NEQ sim_config.sim_gidl1[0] OR 
+        simlck.gidl2 NEQ sim_config.sim_gidl2[0])
+    {
+      sim_clock     = SIMLOCK_LOCKED;
+  		simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
+ 	 		sim_set_sim_lock (&simlck);
+      return MFW_SIM_LOCKED;
+    }
+
+    /* 
+     * check all digits */
+		for (i=0; i<simlck.len_c_imsi; i++)
+		{
+			if (sim_check_imsi_digit(simlck.c_imsi[i], mfw_IMSI[i]) EQ FALSE)
+				break;
+		}
+
+    /*
+     * all digits okay
+     */
+		if (i EQ simlck.len_c_imsi)
+			return MFW_SIM_ENABLE;
+
+    /*
+     * C-Lock has failed
+     */
+    sim_clock     = SIMLOCK_LOCKED;
+		simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
+		sim_set_sim_lock (&simlck);
+
+    return MFW_SIM_LOCKED;
+  }
+  return MFW_SIM_FAILURE;
+}
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM               |
+| STATE   : code                        ROUTINE : sim_get_simlock_count |
++-----------------------------------------------------------------------+
+
+  PURPOSE : Request the count of SIMLOCK
+
+*/
+
+T_MFW sim_get_simlock_count(UBYTE *cnt)
+{
+  EF_SIMLCKEXT simlck;
+
+  TRACE_FUNCTION("sim_get_simlock_count()");
+
+  if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
+    return MFW_SIM_FAILURE;
+  else
+    *cnt = simlck.cnt;
+  return MFW_SIM_SUCCESS;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_pin_status     |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request PIN1/PIN2 status
+
+*/
+
+void sim_pin_status(T_MFW_SIM_PIN_STATUS *status)
+{
+  SHORT           pn1Cnt;
+  SHORT           pn2Cnt;
+  SHORT           pk1Cnt;
+  SHORT           pk2Cnt;
+  T_ACI_PVRF_STAT ps1;
+  T_ACI_PVRF_STAT ps2;
+
+  TRACE_FUNCTION("sim_pin_status()");
+
+  status->stat = MFW_SIM_UNKNOWN;
+  status->set  = MFW_SIM_UNKNOWN;
+  if (qAT_PercentPVRF(CMD_SRC_LCL, &pn1Cnt, 
+                      &pn2Cnt, &pk1Cnt, &pk2Cnt, &ps1, &ps2) == AT_CMPL)
+  {
+    switch (status->type)
+    {
+      case MFW_SIM_PIN1:
+        status->stat = sim_cvtPINstatus(ps1, MFW_SIM_PIN1);
+        status->set = pin1_set;
+        break;
+      case MFW_SIM_PIN2:
+        status->stat = sim_cvtPINstatus(ps2, MFW_SIM_PIN2);
+        status->set  = pin2_set;
+        break;
+    }
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_cvtPINstatus   |
++--------------------------------------------------------------------+
+
+  PURPOSE :
+
+*/
+
+UBYTE sim_cvtPINstatus(T_ACI_PVRF_STAT ps, UBYTE type)
+{
+  TRACE_FUNCTION("sim_cvtPINstatus()");
+
+  switch (ps)
+  {
+    case PVRF_STAT_NotRequired: 
+      return MFW_SIM_NO_PIN;
+    case PVRF_STAT_Required:
+      if (type EQ MFW_SIM_PIN1) 
+        return MFW_SIM_PIN_REQ;
+      if (type EQ MFW_SIM_PIN2) 
+        return MFW_SIM_PIN2_REQ;
+      return MFW_SIM_UNKNOWN;
+    default:                    
+      return MFW_SIM_UNKNOWN;
+  }
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : simDecodeIMSI      |
++--------------------------------------------------------------------+
+
+  PURPOSE : convert imsi (packed bcd to ASCIIZ; ->11.11)
+
+*/
+
+void simDecodeIMSI (UBYTE * imsi_field, 
+                    UBYTE   imsi_c_field, 
+                    UBYTE * imsi_extracted)
+{
+  UBYTE length;
+  UBYTE i;
+  UBYTE digit;
+
+  TRACE_FUNCTION ("simDecodeImsi()");
+
+  /*
+   * calculate number of digits
+   */
+  length = (imsi_c_field-1)*2;
+
+  /*
+   * if odd number of digits add one
+   */
+  if (imsi_field[0] & 0x08)
+    length++;
+
+  /*
+   * extract all digits
+   */
+  for (i = 0; i < length; i++)
+  {
+    digit = (i & 1) ?
+        imsi_field[(i + 1) / 2] & 0x0f :
+       (imsi_field[(i + 1) / 2] & 0xf0) >> 4;
+
+#if defined (WIN32)
+    {
+      char buf[40];
+      sprintf (buf, "DIGIT [%d] = %d",i, digit);
+      TRACE_FUNCTION (buf);
+    }
+#endif
+    if (i < LONG_NAME)
+      imsi_extracted [i] = digit + 0x30;
+    else
+    {
+      imsi_extracted [i] = 0;
+      return;
+    }
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_pin_ident      |
++--------------------------------------------------------------------+
+
+  PURPOSE : handle mfw windows command
+
+*/
+
+void sim_pin_ident(UBYTE id)
+{
+  TRACE_FUNCTION("sim_pin_ident()");
+  pin_ident = id;
+}
+
+/*
++-----------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)         MODULE  : MFW_SIM              |
+| STATE   : code                         ROUTINE : sim_check_imsi_digit |
++-----------------------------------------------------------------------+
+
+  PURPOSE : Check a IMSI digit
+
+*/
+
+T_MFW sim_check_imsi_digit(UBYTE pcm_imsi, UBYTE sim_imsi)
+{
+	UBYTE h;
+	UBYTE l;
+
+  TRACE_FUNCTION("sim_check_imsi_digit()");
+
+	h = pcm_imsi >> 4 | 0x30;
+	l = pcm_imsi & 0x0F | 0x30;
+
+#if defined (WIN32)
+  {
+    char buf[40];
+    sprintf (buf, "check %c shall be in the range [%c..%c]",
+             sim_imsi, h, l);
+    TRACE_FUNCTION (buf);
+  }
+#endif
+
+	if (h > l)
+		return FALSE;
+
+	if ((sim_imsi < h) OR (sim_imsi > l))
+		return FALSE;
+
+	return TRUE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : simCommand         |
++--------------------------------------------------------------------+
+
+  PURPOSE : handle mfw windows command
+
+*/
+
+static int simCommand (U32 cmd, void *h)
+{
+    switch (cmd)
+    {
+        case MfwCmdDelete:              /* delete me                */
+            if (!h)
+                return 0;
+            sim_delete(h);
+            return 1;
+        default:
+            break;
+    }
+
+    return 0;
+}
+
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_get_sim_lock   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Reads the SIM LOCK Record content from PCM
+
+*/
+
+#if defined (WIN32)
+static const UBYTE sim_lock_table_1 [] =
+{
+  //
+  // all locks enabled, wrong IMSI
+  //
+  0x55, 0x01,                // locks
+  0x00,                      // unblock counter
+  0x0F,                      // maximum attempt
+  0x21, 0x43, 0x65, 0x87,    // P control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // N control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // NS control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // SP control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // C control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x0F,                      // length of IMSI
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x00,	0x00                 // Group Identifier
+};
+
+static const UBYTE sim_lock_table_2 [] =
+{
+  //
+  // all locks enabled, IMSI ok
+  //
+  0x55, 0x01,                // locks
+  0x00,                      // unblock counter
+  0x0F,                      // maximum attempt
+  0x21, 0x43, 0x65, 0x87,    // P control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // N control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // NS control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // SP control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // C control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x0D,                      // length of IMSI
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x00,	0x00                 // Group Identifier
+};
+
+static const UBYTE sim_lock_table_3 [] =
+{
+  //
+  // all locks enabled, wrong IMSI, extended format
+  //
+  0x55, 0x01,                // locks
+  0x00,                      // unblock counter
+  0x0F,                      // maximum attempt
+  0x21, 0x43, 0x65, 0x87,    // P control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // N control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // NS control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // SP control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // C control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x0F,                      // length of IMSI P-Lock
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition P-Lock
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x0F,                      // length of IMSI SP-Lock
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition SP-Lock
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x0F,                      // length of IMSI NS-Lock
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition NS-Lock
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x0F,                      // length of IMSI C-Lock
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition C-Lock
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x0F,                      // length of IMSI N-Lock
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition N-Lock
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x0F,                      // length of IMSI U-Lock
+  0x22, 0x00, 0x22, 0x01,    // IMSI range definition U-Lock
+  0x23, 0x15, 0x22, 0x35,
+  0x24, 0x25, 0x11, 0x22,
+  0x46, 0x55, 0x66,   
+  0x00,	0x00                 // Group Identifier
+};
+
+static const UBYTE sim_lock_table_4 [] =
+{
+  //
+  // all locks enabled, IMSI ok, extended format
+  //
+  0x55, 0x01,                // locks
+  0x00,                      // unblock counter
+  0x0F,                      // maximum attempt
+  0x21, 0x43, 0x65, 0x87,    // P control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // N control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // NS control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // SP control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // C control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x0D,                      // length of IMSI P-Lock 
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition P-Lock
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x0D,                      // length of IMSI SP-Lock 
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition SP-Lock
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x0D,                      // length of IMSI NS-Lock 
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition NS-Lock
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x0D,                      // length of IMSI C-Lock 
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition C-Lock
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x0D,                      // length of IMSI N-Lock 
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition N-Lock
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x0D,                      // length of IMSI U-Lock 
+  0x22, 0x66, 0x22, 0x00,    // IMSI range definition U-Lock
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x00,	0x00                 // Group Identifier
+};
+
+static const UBYTE sim_lock_table_5 [] =
+{
+  //
+  // one lock enabled, wrong IMSI ok
+  //
+  0x01, 0x00,                // locks
+  0x00,                      // unblock counter
+  0x0F,                      // maximum attempt
+  0x21, 0x43, 0x65, 0x87,    // P control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // N control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // NS control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // SP control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x21, 0x43, 0x65, 0x87,    // C control key
+  0xFF, 0xFF, 0xFF, 0xFF,
+  0x0D,                      // length of IMSI
+  0x22, 0x00, 0x22, 0x00,    // IMSI range definition
+  0x11, 0x44, 0x77, 0x09,
+  0x09, 0x09, 0x09, 0x09,
+  0x09, 0x09, 0x09,   
+  0x00,	0x00                 // Group Identifier
+};
+
+#endif
+
+static UBYTE sim_get_sim_lock (EF_SIMLCKEXT * simlck)
+{
+  UBYTE version;
+  UBYTE sim_lock_type = 0;
+
+  TRACE_FUNCTION("sim_get_sim_lock()");
+
+#if defined (WIN32)
+  version = 0;
+
+  switch (sim_lock_mode)
+  {
+    case 1:
+      memcpy (simlck, sim_lock_table_1, SIZE_EF_SIMLCK);
+      sim_lock_field = 1;
+      sim_fill_sim_lock (simlck);
+      break;
+    case 2:
+      memcpy (simlck, sim_lock_table_2, SIZE_EF_SIMLCK);
+      sim_lock_field = 1;
+      sim_fill_sim_lock (simlck);
+      break;
+    case 3:
+      memcpy (simlck, sim_lock_table_3, SIZE_EF_SIMLCKEXT);
+      sim_lock_field = 2;
+      break;
+    case 4:
+      memcpy (simlck, sim_lock_table_4, SIZE_EF_SIMLCKEXT);
+      sim_lock_field = 2;
+      break;
+    case 5:
+      memcpy (simlck, sim_lock_table_5, SIZE_EF_SIMLCKEXT);
+      sim_lock_field = 1;
+      break;
+    default:
+      memset (simlck, 0, SIZE_EF_SIMLCKEXT);
+      sim_lock_field = 2;
+      break;
+  }
+  return PCM_OK;
+#else
+
+  if (sim_lock_field EQ NOT_PRESENT_8BIT)
+  {
+    if (pcm_ReadFile((UBYTE *) EF_SIMLCK_ID,
+                     SIZE_EF_SIMLCK,
+                     (UBYTE *) simlck,
+                     &version) EQ PCM_OK)
+    {
+      sim_lock_field = 1;
+      sim_fill_sim_lock (simlck);
+      return PCM_OK;
+    }
+    if (pcm_ReadFile((UBYTE *) EF_SIMLCKEXT_ID,
+                     SIZE_EF_SIMLCKEXT,
+                     (UBYTE *) simlck,
+                     &version) EQ PCM_OK)
+    {
+      sim_lock_field = 2;
+      return PCM_OK;
+    }
+    return PCM_NVRAM_ACCS_FAIL;
+  }
+
+  if (sim_lock_field EQ 1)
+  {
+    if (pcm_ReadFile((UBYTE *) EF_SIMLCK_ID,
+                     SIZE_EF_SIMLCK,
+                     (UBYTE *) simlck,
+                     &version) EQ PCM_OK)
+    {
+      sim_fill_sim_lock (simlck);
+      return PCM_OK;
+    }
+  }
+
+  if (sim_lock_field EQ 2)
+  {
+    if (pcm_ReadFile((UBYTE *) EF_SIMLCKEXT_ID,
+                     SIZE_EF_SIMLCKEXT,
+                     (UBYTE *) simlck,
+                     &version) EQ PCM_OK)
+    {
+      return PCM_OK;
+    }
+  }
+  return PCM_NVRAM_ACCS_FAIL;
+#endif
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_get_sim_lock   |
++--------------------------------------------------------------------+
+
+  PURPOSE : Reads the SIM LOCK Record content from PCM
+
+*/
+
+static void sim_set_sim_lock (EF_SIMLCKEXT * simlck)
+{
+  TRACE_FUNCTION("sim_set_sim_lock()");
+
+  if (sim_lock_field EQ 1)
+  {
+    /*
+     * set GDL1 and 2 on the expected location
+     * => len_sp_imsi = gdl1, sp_imsi[0] = gdl2
+     */
+    simlck->len_sp_imsi = simlck->gidl1;
+    simlck->sp_imsi [0] = simlck->gidl2;
+    pcm_WriteFile((UBYTE *) EF_SIMLCK_ID,SIZE_EF_SIMLCK,
+	  						  (UBYTE *) simlck);
+  }
+  else
+    pcm_WriteFile((UBYTE *) EF_SIMLCKEXT_ID,SIZE_EF_SIMLCKEXT,
+	  						  (UBYTE *) simlck);
+}
+
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_fill_sim_lock  |
++--------------------------------------------------------------------+
+
+  PURPOSE : Fills the extended SIM Lock record with defaults if
+            only the simple SIM Lock Record is available.
+
+*/
+
+static void sim_fill_sim_lock (EF_SIMLCKEXT * simlck)
+{
+  TRACE_FUNCTION("sim_fill_sim_lock()");
+
+  if (sim_lock_field EQ 1)
+  {
+    /*
+     * PCM contains SIMLOCK record. Must be mapped to the internal
+     * used SIMLOCKEXT record.
+     *
+     * gidl1, gidl2 to the end of record:
+     */
+    simlck->gidl1 = simlck->len_sp_imsi;
+    simlck->gidl2 = simlck->sp_imsi [0];
+    /*
+     * IMSI must be copied for the other locks
+     * N-Lock   digits 1..5, rest filled with 0x09 to suppress compare
+     * SP-Lock  digits 1..5, rest filled with 0x09 to suppress compare
+     * NS-Lock  digits 1..7, rest filled with 0x09 to suppress compare     
+     * C-Lock   digits 1..5, rest filled with 0x09 to suppress compare
+     */
+    memset (simlck->n_imsi, 0x09, 15);
+    memcpy (simlck->n_imsi, simlck->p_imsi, 5);
+    simlck->len_n_imsi = 5;
+    memset (simlck->sp_imsi, 0x09, 15);
+    memcpy (simlck->sp_imsi, simlck->p_imsi, 5);
+    simlck->len_ns_imsi = 5;
+    memset (simlck->ns_imsi, 0x09, 15);
+    memcpy (simlck->ns_imsi, simlck->p_imsi, 7);
+    simlck->len_ns_imsi = 7;
+    memset (simlck->c_imsi, 0x09, 15);
+    memcpy (simlck->c_imsi, simlck->p_imsi, 5);
+    simlck->len_c_imsi = 5;
+    /*
+     * initialise unblock imsi so that it never will fit
+     */
+    simlck->len_u_imsi = 0;
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)     MODULE  : MFW_SIM               |
+| STATE   : code                     ROUTINE : sim_check_unblock_sim |
++--------------------------------------------------------------------+
+
+  PURPOSE : Checks the IMSI against a stored unblock SIM. If the
+            check is positive, the unlock attempt counter will 
+            be resetted.
+            
+*/
+
+static void sim_check_unblock_sim (EF_SIMLCKEXT * simlck)
+{
+  UBYTE i;
+
+  TRACE_FUNCTION("sim_check_unblock_sim()");
+
+  if (sim_get_sim_lock (simlck) EQ PCM_OK)
+  {
+    if (simlck->len_u_imsi EQ 0)
+      return;
+
+    /* 
+     * check all digits */
+	  for (i=0; i<simlck->len_u_imsi; i++)
+    {
+  	  if (sim_check_imsi_digit(simlck->u_imsi[i], mfw_IMSI[i]) EQ FALSE)
+		    break;
+    }
+
+    /*
+     * all digits okay, then reset counter and nothing else
+     */
+	  if (i EQ simlck->len_u_imsi)
+    {
+  	  simlck->cnt = 0;
+	    sim_set_sim_lock (simlck);
+    }
+  }
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)     MODULE  : MFW_SIM               |
+| STATE   : code                     ROUTINE : sim_simlock_ok        |
++--------------------------------------------------------------------+
+
+  PURPOSE : The function checks whether the SIM LOCK is active or not.
+            
+*/
+
+UBYTE sim_simlock_ok (void)
+{
+  if (sim_nslock EQ SIMLOCK_BLOCKED OR
+      sim_nslock EQ SIMLOCK_LOCKED)
+    return FALSE;
+
+  if (sim_plock EQ SIMLOCK_BLOCKED OR
+      sim_plock EQ SIMLOCK_LOCKED)
+    return FALSE;
+
+  if (sim_splock EQ SIMLOCK_BLOCKED OR
+      sim_splock EQ SIMLOCK_LOCKED)
+    return FALSE;
+
+  if (sim_nlock EQ SIMLOCK_BLOCKED OR
+      sim_nlock EQ SIMLOCK_LOCKED)
+    return FALSE;
+
+  if (sim_clock EQ SIMLOCK_BLOCKED OR
+      sim_clock EQ SIMLOCK_LOCKED)
+    return FALSE;
+
+  return TRUE;
+}
+
+/*
++--------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)        MODULE  : MFW_SIM            |
+| STATE   : code                        ROUTINE : sim_get_imsi       |
++--------------------------------------------------------------------+
+
+  PURPOSE : Request IMSI number in SIM card
+
+*/
+
+UBYTE * sim_get_imsi (void)
+{
+  return mfw_IMSI;
+}
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)   MODULE  : MFW_SIM                  |
+| STATE   : code                   ROUTINE : sim_mmi_update_parameter |
++---------------------------------------------------------------------+
+
+  PURPOSE : MMI relevant parameters from the SIM card
+
+*/
+
+void sim_mmi_update_parameter(T_SIM_ACTIVATE_IND *sim_act_ind)
+{
+  TRACE_FUNCTION("sim_mmi_update_parameter()");
+
+  memcpy( sim_config.pref_lang, sim_act_ind->pref_lang, 5);
+}
+
+#ifdef SIM_TOOLKIT
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)   MODULE  : MFW_SIM                  |
+| STATE   : code                   ROUTINE : sim_sat_file_update      |
++---------------------------------------------------------------------+
+
+  PURPOSE : SIM file change indication
+
+*/
+
+void sim_sat_file_update(USHORT dataId)
+{
+  TRACE_FUNCTION("sim_sat_file_update()");
+
+  sat_update = TRUE;
+  switch (dataId)
+  {
+    case SIM_SST:
+      sim_read_sim(SIM_SST, NOT_PRESENT_8BIT, 10);
+      break;
+    case SIM_GID1:
+      sim_read_sim(SIM_GID1, NOT_PRESENT_8BIT, 5);
+      break;
+    case SIM_GID2:
+      sim_read_sim(SIM_GID2, NOT_PRESENT_8BIT, 5);
+      break;
+    default:
+      break;
+  }
+}
+#endif
+
+/*
++---------------------------------------------------------------------+
+| PROJECT : MMI-Framework (8417)   MODULE  : MFW_SIM                  |
+| STATE   : code                   ROUTINE : sim_read_sst_cnf         |
++---------------------------------------------------------------------+
+
+  PURPOSE : SIM file change indication
+
+*/
+
+void sim_read_sst_cnf (SHORT error, UBYTE *data)
+{
+  TRACE_FUNCTION("sim_read_sst_cnf()");
+
+  if (error EQ SIM_NO_ERROR)
+    memcpy(sim_service_table, data, sizeof(sim_service_table));
+  else
+    TRACE_EVENT("SST read error");
+
+#ifdef SIM_TOOLKIT
+  if (sat_update)
+  {
+    sat_update = FALSE;
+    satUpdateFiles ( TRUE, SIM_SST );
+  }
+#endif
+}