FreeCalypso > hg > fc-magnetite
view src/aci2/mfw/mfw_sim.~c @ 662:8cd8fd15a095
SIM speed enhancement re-enabled and made configurable
TI's original code supported SIM speed enhancement, but Openmoko had it
disabled, and OM's disabling of speed enhancement somehow caused certain
SIM cards to start working which didn't work before (OM's bug #666).
Because our FC community is much smaller in year 2020 than OM's community
was in their day, we are not able to find one of those #666-affected SIMs,
thus the real issue they had encountered remains elusive. Thus our
solution is to re-enable SIM speed enhancement and simply wait for if
and when someone runs into a #666-affected SIM once again. We provide
a SIM_allow_speed_enhancement global variable that allows SIM speed
enhancement to be enabled or disabled per session, and an /etc/SIM_spenh
file in FFS that allows it to enabled or disabled on a non-volatile
basis. SIM speed enhancement is now enabled by default.
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sun, 24 May 2020 05:02:28 +0000 |
| parents | 93999a60b835 |
| children |
line wrap: on
line source
/* +--------------------------------------------------------------------+ | 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 }