FreeCalypso > hg > fc-magnetite
view src/aci2/mfw/mfw_sim.~c @ 139:3e16c8832c0e
src/cs/system/Main/create_RVtasks.c: header comment line length fix
| author | Mychaela Falconia <falcon@freecalypso.org> |
|---|---|
| date | Sat, 08 Oct 2016 16:16:49 +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 }