FreeCalypso > hg > fc-magnetite

comparison src/aci2/mfw/mfw_sim.~c @ 3:93999a60b835

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/aci2, src/condat2: import of g23m/condat source pieces from TCS211
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 26 Sep 2016 00:29:36 +0000
parents
children
comparison
equal deleted inserted replaced
2:c41a534f33c6 3:93999a60b835
1 /*
2 +--------------------------------------------------------------------+
3 | PROJECT: MMI-Framework (8417) $Workfile:: mfw_sim.c $|
4 | $Author:: Vo $Revision:: 1 $|
5 | CREATED: 13.10.98 $Modtime:: 22.03.00 17:21 $|
6 | STATE : code |
7 +--------------------------------------------------------------------+
8
9 MODULE : MFW_SIM
10
11 PURPOSE : This modul contains the functions for SIM management.
12
13
14 $History:: mfw_sim.c $
15 *
16 * ***************** Version 43 *****************
17 * User: Vo Date: 22.03.00 Time: 17:29
18 * Updated in $/GSM/Condat/MS/SRC/MFW
19 * Add new parameter PIN type in structure T_MFW_SIM_STATUS to
20 * identify PIN type
21 * Change in SIM lock
22 *
23 * ***************** Version 42 *****************
24 * User: Es Date: 2.03.00 Time: 16:18
25 * Updated in $/GSM/Condat/MS/SRC/MFW
26 * use 'aci_delete()' instead of 'aci_ext_init()' to clear the
27 * primitive routing for mfw_sim. (because other routings may have to
28 * be preserved!)
29 *
30 * ***************** Version 41 *****************
31 * User: Vo Date: 22.12.99 Time: 16:03
32 * Updated in $/GSM/Condat/MS/SRC/MFW
33 * Remove maximum preferred PLMN records and used preferred PLMN
34 * records in local memory
35 *
36 * ***************** Version 40 *****************
37 * User: Vo Date: 2.12.99 Time: 13:18
38 * Updated in $/GSM/Condat/MS/SRC/MFW
39 * New: request of max/used perferred PLMN list
40 *
41 * ***************** Version 39 *****************
42 * User: Vo Date: 17.11.99 Time: 11:37
43 * Updated in $/GSM/Condat/MS/SRC/MFW
44 * Bug fix: de-personalisation for SIM lock
45 * New: SIM inserted
46 *
47 * ***************** Version 38 *****************
48 * User: Vo Date: 21.10.99 Time: 13:26
49 * Updated in $/GSM/Condat/MS/SRC/MFW
50 * add response of de-registration
51 |
52 | ***************** Version 37 *****************
53 | User: Le Date: 11.10.99 Time: 16:27
54 | Updated in $/GSM/Condat/MS/SRC/MFW
55 |
56 | ***************** Version 36 *****************
57 | User: Le Date: 8.10.99 Time: 13:38
58 | Updated in $/GSM/Condat/MS/SRC/MFW
59 |
60 | ***************** Version 35 *****************
61 | User: Le Date: 4.10.99 Time: 10:33
62 | Updated in $/GSM/Condat/MS/SRC/MFW
63 *
64 * ***************** Version 34 *****************
65 * User: Es Date: 29.09.99 Time: 11:20
66 * Updated in $/GSM/DEV/MS/SRC/MFW
67 * including CFUN_OK enhancement by AK, not fully implemented
68 *
69 * ***************** Version 33 *****************
70 * User: Es Date: 16.09.99 Time: 16:56
71 * Updated in $/GSM/DEV/MS/SRC/MFW
72 * reordered include statements due to addons in mfw_phb.h
73 *
74 * ***************** Version 32 *****************
75 * User: Vo Date: 13.09.99 Time: 12:05
76 * Updated in $/GSM/DEV/MS/SRC/MFW
77 * change comment
78 *
79 * ***************** Version 31 *****************
80 * User: Vo Date: 12.09.99 Time: 15:32
81 * Updated in $/GSM/DEV/MS/SRC/MFW
82 * Bug fix: change PIN
83 * Bug fix/New: SIM lock
84 * New: request of PIN status
85 * New: save preferred language
86 * New: read group identifier level 1 & 2
87 *
88 * ***************** Version 30 *****************
89 * User: Vo Date: 30.08.99 Time: 14:23
90 * Updated in $/GSM/DEV/MS/SRC/MFW
91 * bug fix
92 * new function
93 *
94 * ***************** Version 29 *****************
95 * User: Vo Date: 9.08.99 Time: 13:11
96 * Updated in $/GSM/DEV/MS/SRC/MFW
97 * PIN/PUK count
98 *
99 * ***************** Version 28 *****************
100 * User: Vo Date: 26.07.99 Time: 14:34
101 * Updated in $/GSM/DEV/MS/SRC/MFW
102 * Move include file mfw_cb.h
103 *
104 * ***************** Version 27 *****************
105 * User: Vo Date: 21.07.99 Time: 14:41
106 * Updated in $/GSM/DEV/MS/SRC/MFW
107 *
108 * ***************** Version 26 *****************
109 * User: Vo Date: 16.07.99 Time: 13:50
110 * Updated in $/GSM/DEV/MS/SRC/MFW
111 *
112 * ***************** Version 25 *****************
113 * User: Vo Date: 9.07.99 Time: 14:34
114 * Updated in $/GSM/DEV/MS/SRC/MFW
115 *
116 * ***************** Version 24 *****************
117 * User: Vo Date: 2.07.99 Time: 19:03
118 * Updated in $/GSM/DEV/MS/SRC/MFW
119 *
120 * ***************** Version 23 *****************
121 * User: Vo Date: 28.05.99 Time: 9:52
122 * Updated in $/GSM/DEV/MS/SRC/MFW
123 *
124 * ***************** Version 22 *****************
125 * User: Vo Date: 31.03.99 Time: 14:09
126 * Updated in $/GSM/DEV/MS/SRC/MFW
127 *
128 * ***************** Version 21 *****************
129 * User: Es Date: 15.03.99 Time: 18:21
130 * Updated in $/GSM/DEV/MS/SRC/MFW
131 * recode
132 *
133 * ***************** Version 20 *****************
134 * User: Vo Date: 25.02.99 Time: 16:47
135 * Updated in $/GSM/DEV/MS/SRC/MFW
136 *
137 * ***************** Version 19 *****************
138 * User: Vo Date: 17.02.99 Time: 19:03
139 * Updated in $/GSM/DEV/MS/SRC/MFW
140 *
141 * ***************** Version 18 *****************
142 * User: Vo Date: 12.02.99 Time: 18:05
143 * Updated in $/GSM/DEV/MS/SRC/MFW
144 *
145 * ***************** Version 17 *****************
146 * User: Vo Date: 12.02.99 Time: 17:46
147 * Updated in $/GSM/DEV/MS/SRC/MFW
148 *
149 * ***************** Version 16 *****************
150 * User: Vo Date: 9.02.99 Time: 14:54
151 * Updated in $/GSM/DEV/MS/SRC/MFW
152 *
153 * ***************** Version 15 *****************
154 * User: Vo Date: 12.01.99 Time: 14:27
155 * Updated in $/GSM/DEV/MS/SRC/MFW
156 *
157 * ***************** Version 14 *****************
158 * User: Es Date: 23.12.98 Time: 15:47
159 * Updated in $/GSM/DEV/MS/SRC/MFW
160 *
161 * ***************** Version 12 *****************
162 * User: Es Date: 18.12.98 Time: 13:05
163 * Updated in $/GSM/DEV/MS/SRC/MFW
164 *
165 * ***************** Version 11 *****************
166 * User: Vo Date: 17.12.98 Time: 14:31
167 * Updated in $/GSM/DEV/MS/SRC/MFW
168 *
169 * ***************** Version 10 *****************
170 * User: Es Date: 8.12.98 Time: 16:53
171 * Updated in $/GSM/DEV/MS/SRC/MFW
172 *
173 * ***************** Version 8 *****************
174 * User: Vo Date: 24.11.98 Time: 21:40
175 * Updated in $/GSM/DEV/MS/SRC/MFW
176 * first successful compilation of MFW
177 |
178 | ***************** Version 6 *****************
179 | User: Le Date: 11.11.98 Time: 13:35
180 | Updated in $/GSM/DEV/MS/SRC/MFW
181 |
182 | ***************** Version 5 *****************
183 | User: Le Date: 10.11.98 Time: 16:07
184 | Updated in $/GSM/DEV/MS/SRC/MFW
185 |
186 | ***************** Version 4 *****************
187 | User: Le Date: 10.11.98 Time: 11:08
188 | Updated in $/GSM/DEV/MS/SRC/MFW
189 |
190 | ***************** Version 3 *****************
191 | User: Le Date: 27.10.98 Time: 15:59
192 | Updated in $/GSM/DEV/MS/SRC/MFW
193 |
194 | ***************** Version 2 *****************
195 | User: Le Date: 21.10.98 Time: 16:20
196 | Updated in $/GSM/DEV/MS/SRC/MFW
197 */
198
199 #define ENTITY_MFW
200
201 #include <string.h>
202 #include <stdio.h>
203 #include <stdlib.h>
204
205 #if defined (NEW_FRAME)
206
207 #include "typedefs.h"
208 #include "vsi.h"
209 #include "pei.h"
210 #include "custom.h"
211 #include "gsm.h"
212
213 #else
214
215 #include "stddefs.h"
216 #include "custom.h"
217 #include "gsm.h"
218 #include "vsi.h"
219
220 #endif
221
222 #include "p_sim.h"
223 #include "aci_cmh.h"
224 #include "psa.h"
225 #include "psa_sim.h"
226 #include "pcm.h"
227 #include "mfw_mfw.h"
228 #include "mfw_nm.h"
229 #include "mfw_sim.h"
230 #include "mfw_sima.h"
231 #include "mfw_simi.h"
232 #include "mfw_nmi.h"
233 #include "mfw_nma.h"
234 #include "mfw_phb.h"
235 #include "mfw_cm.h"
236 #include "mfw_cmi.h"
237 #include "mfw_acie.h"
238 #include "mfw_sms.h"
239 #include "mfw_smsi.h"
240 #include "mfw_win.h"
241
242
243 #include "ksd.h"
244 #include "psa.h"
245
246 #if defined (FAX_AND_DATA)
247 #include "aci_fd.h"
248 #endif
249
250 #include "cmh.h"
251 #include "phb.h"
252 #include "cmh_phb.h"
253
254 #include "mfw_ss.h"
255 #include "mfw_ssi.h"
256
257 #ifdef SIM_TOOLKIT
258 #include "mfw_sat.h"
259 #endif
260
261 extern BOOL sima_response_cb (USHORT opc, void * data);
262 extern void simDecodeIMSI (UBYTE *ci, UBYTE li, UBYTE *di);
263 extern UBYTE mfw_IMSI []; /* expanded IMSI (ASCIIZ) */
264 static T_MFW_SIM_STATUS sim_status;
265 static T_MFW_SIM_CONFIG sim_config;
266 static int pin_flag;
267 static UBYTE pin_ident;
268
269 UBYTE sim_nlock; /* Network lock */
270 UBYTE sim_splock; /* Service provider lock */
271 UBYTE sim_plock; /* SIM lock */
272 UBYTE sim_nslock; /* Network SUBSET lock */
273 UBYTE sim_clock; /* corporate lock */
274 UBYTE sim_blocked; /* blocked flag */
275
276 static UBYTE sim_service_table [10]; /* SIM service table */
277 static UBYTE sim_stat = SIM_NOT_ACTIVE;
278
279 static int simCommand (ULONG cmd, void *h); /* handle win commands */
280
281 UBYTE pin1_set = MFW_SIM_UNKNOWN;
282 UBYTE pin2_set = MFW_SIM_ENABLE;
283
284 static BOOL sat_update = FALSE;
285
286 static int pSlot; /* primitive handler slot */
287
288 EXTERN MfwHdr * current_mfw_elem;
289 #if defined (WIN32)
290 /*
291 * Only for windows to check several SIM lock combinations
292 */
293 UBYTE sim_lock_mode = 0;
294 #endif
295 UBYTE sim_lock_field = NOT_PRESENT_8BIT; /* type of sim lock field */
296
297 static UBYTE sim_get_sim_lock (EF_SIMLCKEXT * simlck);
298 static void sim_set_sim_lock (EF_SIMLCKEXT * simlck);
299 static void sim_fill_sim_lock (EF_SIMLCKEXT * simlck);
300 static void sim_check_unblock_sim (EF_SIMLCKEXT * simlck);
301
302 #define SIMLOCK_DISABLED 0
303 #define SIMLOCK_ENABLED 1
304 #define SIMLOCK_LOCKED 2
305 #define SIMLOCK_BLOCKED 3
306
307 /*
308 +--------------------------------------------------------------------+
309 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
310 | STATE : code ROUTINE : sim_init |
311 +--------------------------------------------------------------------+
312
313 PURPOSE : initialize SIM manager
314
315 */
316
317 int sim_init (void)
318 {
319 EF_SIMLCKEXT simlck;
320
321 TRACE_FUNCTION("sim_init()");
322
323 /*
324 * initialise SIM lock flags
325 */
326 sim_nslock = sim_plock = sim_nlock = sim_clock = sim_splock = 0;
327 sim_blocked = FALSE;
328
329 /*
330 * Read SIM Lock Flags
331 */
332 if (sim_get_sim_lock (&simlck) EQ PCM_OK)
333 {
334 sim_plock = (UBYTE) FldGet(simlck.locks1,plock);
335 sim_nlock = (UBYTE) FldGet(simlck.locks1,nlock);
336 sim_nslock = (UBYTE) FldGet(simlck.locks1,nslock);
337 sim_splock = (UBYTE) FldGet(simlck.locks1,splock);
338 sim_clock = (UBYTE) FldGet(simlck.locks2,clock);
339
340 if (simlck.cnt >= simlck.maxcnt)
341 sim_blocked = TRUE;
342 else
343 sim_blocked = FALSE;
344 }
345
346 pin_flag = -1;
347 pin_ident = MFW_SIM_UNKNOWN;
348
349 /*
350 * install prim handler
351 */
352 pSlot = aci_create(sima_response_cb,NULL);
353 mfwCommand[MfwTypSim] = (MfwCb) simCommand;
354
355 return TRUE;
356 }
357
358
359 /*
360 +---------------------------------------------------------------------+
361 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
362 | STATE : code ROUTINE : sim_init_sim_insert |
363 +---------------------------------------------------------------------+
364
365 PURPOSE : initialize SIM manager
366
367 */
368
369 void sim_init_sim_insert()
370 {
371 }
372
373
374 /*
375 +--------------------------------------------------------------------+
376 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
377 | STATE : code ROUTINE : sim_exit |
378 +--------------------------------------------------------------------+
379
380 PURPOSE : finalize SIM manager
381
382 */
383
384 void sim_exit (void)
385 {
386 TRACE_FUNCTION("sim_exit()");
387
388 /*
389 * remove prim handler
390 */
391 aci_delete(pSlot);
392 sim_stat = SIM_NOT_ACTIVE;
393 }
394
395
396 /*
397 +--------------------------------------------------------------------+
398 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
399 | STATE : code ROUTINE : sim_create |
400 +--------------------------------------------------------------------+
401
402 PURPOSE : create SIM event handler
403
404 */
405
406 T_MFW_HND sim_create (MfwHnd hWin, MfwEvt event, MfwCb cbfunc)
407 {
408 MfwHdr *hdr;
409 T_MFW_SIM *sim_para;
410
411 TRACE_FUNCTION("sim_create()");
412
413 hdr = (MfwHdr *) mfwAlloc(sizeof(MfwHdr));
414 sim_para = (T_MFW_SIM *) mfwAlloc(sizeof(T_MFW_SIM));
415
416 if (!hdr || !sim_para)
417 return 0;
418
419 sim_para->emask = event;
420 sim_para->handler = cbfunc;
421
422 hdr->data = sim_para;
423 hdr->type = MfwTypSim;
424
425 return mfwInsert((MfwHdr *) hWin,hdr);
426 }
427
428
429 /*
430 +--------------------------------------------------------------------+
431 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
432 | STATE : code ROUTINE : sim_delete |
433 +--------------------------------------------------------------------+
434
435 PURPOSE : delete SIM event handler
436
437 */
438
439 MfwRes sim_delete (MfwHnd h)
440 {
441 TRACE_FUNCTION("sim_delete()");
442
443 if (!h || !((MfwHdr *) h)->data)
444 return MfwResIllHnd;
445
446 if (!mfwRemove((MfwHdr *) h))
447 return MfwResIllHnd;
448
449 mfwFree((U8 *) ((MfwHdr *) h)->data,sizeof(T_MFW_SIM));
450 mfwFree((U8 *) h,sizeof(MfwHdr));
451
452 return MfwResOk;
453 }
454
455
456 /*
457 +--------------------------------------------------------------------+
458 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
459 | STATE : code ROUTINE : sim_signal |
460 +--------------------------------------------------------------------+
461
462 PURPOSE : Send a signal
463
464 */
465
466 void sim_signal (MfwEvt event, void *para)
467 {
468 TRACE_FUNCTION ("sim_signal()");
469
470 if (mfwSignallingMethod EQ 0)
471 {
472 if (mfwFocus)
473 if (sim_sign_exec(mfwFocus,event,para))
474 return;
475 if (mfwRoot)
476 sim_sign_exec(mfwRoot,event,para);
477 }
478 else
479 {
480 MfwHdr * h = 0;
481
482 /*
483 * Focus set, then start here
484 */
485 if (mfwFocus)
486 h = mfwFocus;
487 /*
488 * Focus not set, then start root
489 */
490 if (!h)
491 h = mfwRoot;
492
493 /*
494 * No elements available, return
495 */
496
497 while (h)
498
499
500 {
501 /*
502 * Signal consumed, then return
503 */
504 if (sim_sign_exec (h, event, para))
505 return;
506
507 /*
508 * All windows tried inclusive root
509 */
510 if (h == mfwRoot)
511 return;
512
513 /*
514 * get parent window
515 */
516 h = mfwParent(mfwParent(h));
517 if(h)
518 h = ((MfwWin * )(h->data))->elems;
519 }
520 sim_sign_exec (mfwRoot, event, para);
521 }
522 }
523
524
525 /*
526 +--------------------------------------------------------------------+
527 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
528 | STATE : code ROUTINE : sim_sign_exec |
529 +--------------------------------------------------------------------+
530
531 PURPOSE : Send a signal if SIM management handler
532
533 */
534
535 int sim_sign_exec (MfwHdr *cur_elem, MfwEvt event, T_MFW_SIM_PARA *para)
536 {
537
538 TRACE_FUNCTION("sim_sign_exec()");
539
540 while (cur_elem)
541 {
542 if (cur_elem->type == MfwTypSim)
543 {
544 T_MFW_SIM *sim_data;
545 sim_data = (T_MFW_SIM *) cur_elem->data;
546 if (sim_data->emask & event)
547 {
548 sim_data->event = event;
549 switch (event)
550 {
551 case E_SIM_STATUS:
552 memcpy(&sim_data->para.status,
553 para,sizeof(T_MFW_SIM_STATUS));
554 break;
555 }
556 if (sim_data->handler)
557 {
558 // PATCH LE 06.06.00
559 // store current mfw elem
560 current_mfw_elem = cur_elem;
561 // END PATCH LE 06.06.00
562 if ((*(sim_data->handler))(sim_data->event,
563 (void *) &sim_data->para))
564 return TRUE;
565 }
566 }
567 }
568 cur_elem = cur_elem->next;
569 }
570
571 return FALSE;
572 }
573
574
575 /*
576 +--------------------------------------------------------------------+
577 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
578 | STATE : code ROUTINE : sim_activate |
579 +--------------------------------------------------------------------+
580
581 PURPOSE : Start SIM card activation
582
583 */
584
585 void sim_activate (void)
586 {
587 TRACE_FUNCTION("sim_activate()");
588
589 /*
590 * Full functionality is used don´t reset the ME
591 */
592 if (sAT_PlusCFUN(CMD_SRC_LCL,CFUN_FUN_Full,CFUN_RST_NotPresent)
593 NEQ AT_EXCT)
594 {
595 TRACE_ERROR("sAT_PlusCFUN error");
596 }
597 }
598
599
600 /*
601 +--------------------------------------------------------------------+
602 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
603 | STATE : code ROUTINE : sim_spn_req |
604 +--------------------------------------------------------------------+
605
606 PURPOSE : Request service provider name
607
608 */
609
610 void sim_spn_req (void)
611 {
612 T_EF_SPN spn;
613
614 TRACE_FUNCTION("sim_spn_req()");
615
616 memset(&spn,0,sizeof(T_EF_SPN));
617
618 if (sim_check_service(17,sim_service_table)
619 EQ ALLOCATED_AND_ACTIVATED)
620 sim_read_sim(SIM_SPN,17,17);
621 else
622 nm_spn_cnf(&spn);
623 }
624
625
626 /*
627 +--------------------------------------------------------------------+
628 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
629 | STATE : code ROUTINE : sim_ok_cfun |
630 +--------------------------------------------------------------------+
631
632 PURPOSE : Notify successful end of SIM card activation
633
634 */
635
636 void sim_ok_cfun (void)
637 {
638 T_ACI_CFUN_FUN fun;
639
640 TRACE_FUNCTION ("sim_ok_cfun()");
641
642 qAT_PlusCFUN( CMD_SRC_LCL, &fun );
643
644 if( fun EQ CFUN_FUN_Full )
645 {
646 sim_stat = SIM_ACTIVE;
647 sim_status.sim_status = MFW_SIM_NO_PIN;
648 sim_status.sim_operation_mode = sim_config.oper_mode;
649 sim_status.sim_pin_retries = 0;
650 sim_status.sim_procedure = MFW_SIM_ACTIVATION;
651 sim_status.sim_status_type = pin_ident;
652
653 pin_ident = MFW_SIM_UNKNOWN;
654 sim_signal(E_SIM_STATUS,&sim_status);
655 nm_activate(MFW_SIM_NO_PIN);
656
657 pin1_set = MFW_SIM_DISABLE;
658 }
659 else if( fun EQ CFUN_FUN_Minimum )
660 {
661 nm_ok_deregistration();
662 }
663 }
664
665
666 /*
667 +--------------------------------------------------------------------+
668 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
669 | STATE : code ROUTINE : sim_error_cfun |
670 +--------------------------------------------------------------------+
671
672 PURPOSE : Notify error status of SIM card
673
674 */
675
676 void sim_error_cfun (U8 result)
677 {
678 TRACE_FUNCTION("sim_error_cfun()");
679
680 sim_status.sim_procedure = MFW_SIM_ACTIVATION;
681 sim_status.sim_operation_mode = sim_config.oper_mode;
682
683 switch (result)
684 {
685 case CME_ERR_SimPinReq: /* PIN 1 must be entered */
686 sim_status.sim_status = MFW_SIM_PIN_REQ;
687 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
688 sim_status.sim_status_type = MFW_SIM_PIN1;
689 sim_stat = SIM_ACTIVE;
690 break;
691 case CME_ERR_SimPin2Req: /* PIN 2 must be entered */
692 sim_status.sim_status = MFW_SIM_PIN2_REQ;
693 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN2);
694 sim_status.sim_status_type = MFW_SIM_PIN2;
695 sim_stat = SIM_ACTIVE;
696 break;
697 case CME_ERR_SimPukReq: /* PUK 1 must be entered */
698 sim_status.sim_status = MFW_SIM_PUK_REQ;
699 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK1);
700 sim_status.sim_status_type = MFW_SIM_PUK1;
701 sim_stat = SIM_ACTIVE;
702 break;
703 case CME_ERR_SimPuk2Req: /* PUK 2 must be entered */
704 sim_status.sim_status = MFW_SIM_PUK2_REQ;
705 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK2);
706 sim_status.sim_status_type = MFW_SIM_PUK2;
707 sim_stat = SIM_ACTIVE;
708 break;
709 case CME_ERR_SimFail: /* SIM card is invalid */
710 case CME_ERR_SimWrong:
711 sim_status.sim_status = MFW_SIM_INVALID_CARD;
712 sim_status.sim_pin_retries = 0;
713 sim_status.sim_status_type = MFW_SIM_UNKNOWN;
714 sim_stat = SIM_NOT_ACTIVE;
715 break;
716 case CME_ERR_SimNotIns: /* no SIM card inserted */
717 sim_status.sim_status = MFW_SIM_NO_SIM_CARD;
718 sim_status.sim_pin_retries = 0;
719 sim_status.sim_status_type = MFW_SIM_UNKNOWN;
720 sim_stat = SIM_NOT_ACTIVE;
721 break;
722 default:
723 TRACE_ERROR("sim_error_cfun(): result");
724 return;
725 }
726
727 sim_signal(E_SIM_STATUS,&sim_status);
728
729 if ((result == CME_ERR_SimPinReq)
730 OR (result == CME_ERR_SimPukReq))
731 pin1_set = MFW_SIM_ENABLE;
732 }
733
734
735 /*
736 +--------------------------------------------------------------------+
737 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
738 | STATE : code ROUTINE : sim_error_cpin |
739 +--------------------------------------------------------------------+
740
741 PURPOSE : Inform about error of PIN entering or PUK entering
742
743 */
744
745 void sim_error_cpin (T_ACI_CME_ERR reason)
746 {
747 T_ACI_CPIN_RSLT code;
748
749 TRACE_FUNCTION("sim_error_cpin()");
750
751 sim_status.sim_procedure = pin_flag;
752 sim_status.sim_operation_mode = sim_config.oper_mode;
753 sim_status.sim_status = MFW_SIM_FAILURE;
754 sim_status.sim_status_type = pin_ident;
755
756 pin_flag = -1;
757 pin_ident = MFW_SIM_UNKNOWN;
758
759 switch (reason)
760 {
761 case CME_ERR_WrongPasswd:
762 if (qAT_PlusCPIN(CMD_SRC_LCL,&code) != AT_CMPL)
763 {
764 TRACE_ERROR("sim_error_cpin():CPIN? failed");
765 sim_signal(E_SIM_STATUS,&sim_status);
766 return;
767 }
768 break;
769 case CME_ERR_SimWrong:
770 sim_status.sim_status = MFW_SIM_INVALID_CARD;
771 sim_signal(E_SIM_STATUS,&sim_status);
772 return;
773 default:
774 TRACE_ERROR("sim_error_cpin():Ill reason");
775 sim_signal(E_SIM_STATUS,&sim_status);
776 return;
777 }
778
779 switch (code)
780 {
781 case CPIN_RSLT_SimPinReq:
782 sim_status.sim_status = MFW_SIM_PIN_REQ;
783 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
784 break;
785 case CPIN_RSLT_SimPukReq:
786 sim_status.sim_status = MFW_SIM_PUK_REQ;
787 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK1);
788 break;
789 case CPIN_RSLT_SimPin2Req:
790 sim_status.sim_status = MFW_SIM_PIN2_REQ;
791 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN2);
792 break;
793 case CPIN_RSLT_SimPuk2Req:
794 sim_status.sim_status = MFW_SIM_PUK2_REQ;
795 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK2);
796 break;
797 case CPIN_RSLT_NotPresent:
798 case CPIN_RSLT_SimReady:
799 default:
800 TRACE_ERROR("sim_error_cpin():Ill code");
801 break;
802 }
803
804 sim_signal(E_SIM_STATUS,&sim_status);
805 }
806
807
808 /*
809 +--------------------------------------------------------------------+
810 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
811 | STATE : code ROUTINE : sim_ok_cpin |
812 +--------------------------------------------------------------------+
813
814 PURPOSE : Successful end of PIN entering or PUK entering
815
816 */
817
818 void sim_ok_cpin (void)
819 {
820 TRACE_FUNCTION("sim_ok_cpin()");
821
822 switch (pin_flag)
823 {
824 case MFW_SIM_VERIFY:
825 sim_status.sim_procedure = MFW_SIM_VERIFY;
826 sim_status.sim_status = MFW_SIM_NO_PIN;
827 sim_status.sim_status_type = pin_ident;
828 break;
829 case MFW_SIM_UNBLOCK:
830 sim_status.sim_procedure = MFW_SIM_UNBLOCK;
831 sim_status.sim_status = MFW_SIM_SUCCESS;
832 sim_status.sim_status_type = pin_ident;
833 break;
834 default:
835 break;
836 }
837
838 pin_flag = -1;
839 pin_ident = MFW_SIM_UNKNOWN;
840 sim_status.sim_operation_mode = sim_config.oper_mode;
841 sim_status.sim_pin_retries = 0;
842
843 sim_signal (E_SIM_STATUS, &sim_status);
844 if (nm_reg_flag_req())
845 nm_activate(MFW_SIM_NO_PIN);
846 }
847
848
849 /*
850 +--------------------------------------------------------------------+
851 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
852 | STATE : code ROUTINE : sim_ss_unblock |
853 +--------------------------------------------------------------------+
854
855 PURPOSE : SIM unblock via SS string
856
857 */
858
859 void sim_ss_unblock(UBYTE result, T_ACI_CME_ERR reason)
860 {
861 TRACE_FUNCTION("sim_ss_unblock()");
862
863 pin_flag = MFW_SIM_UNBLOCK;
864
865 if (result == SIM_UBLK_ERROR)
866 sim_error_cpin (reason);
867 if (result == SIM_UBLK_OK)
868 sim_ok_cpin ();
869 }
870
871
872 /*
873 +--------------------------------------------------------------------+
874 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
875 | STATE : code ROUTINE : sim_verify_pin |
876 +--------------------------------------------------------------------+
877
878 PURPOSE : Verify PIN
879
880 */
881
882 void sim_verify_pin (U8 pin_id, char *pin)
883 {
884 TRACE_FUNCTION("sim_verify_pin()");
885
886 pin_flag = MFW_SIM_VERIFY;
887 pin_ident = pin_id;
888 switch (pin_id)
889 {
890 case MFW_SIM_PIN1:
891 sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Pin1, pin, 0);
892 break;
893 case MFW_SIM_PIN2:
894 sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Pin2, pin, 0);
895 break;
896 }
897 }
898
899
900 /*
901 +--------------------------------------------------------------------+
902 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
903 | STATE : code ROUTINE : sim_unblock_pin |
904 +--------------------------------------------------------------------+
905
906 PURPOSE : unblock SIM
907
908 */
909
910 void sim_unblock_pin (U8 pin_id, char *puk, char *newpin)
911 {
912 TRACE_FUNCTION("sim_unblock_pin()");
913
914 pin_flag = MFW_SIM_UNBLOCK;
915 pin_ident = pin_id;
916 switch (pin_id)
917 {
918 case MFW_SIM_PUK1:
919 sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Puk1, puk, newpin);
920 break;
921 case MFW_SIM_PUK2:
922 sAT_PercentPVRF(CMD_SRC_LCL, PVRF_TYPE_Puk2, puk, newpin);
923 break;
924 }
925 }
926
927
928 /*
929 +--------------------------------------------------------------------+
930 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
931 | STATE : code ROUTINE : sim_change_pin |
932 +--------------------------------------------------------------------+
933
934 PURPOSE : Request of PIN change
935
936 */
937
938 void sim_change_pin (U8 pin_id, U8 *old_pin, U8 *new_pin)
939 {
940 TRACE_FUNCTION("sim_change_pin()");
941
942 pin_ident = pin_id;
943 switch (pin_id)
944 {
945 case MFW_SIM_PIN1:
946 sAT_PlusCPWD(CMD_SRC_LCL, CPWD_FAC_Sc,
947 (char *)old_pin, (char *)new_pin);
948 break;
949 case MFW_SIM_PIN2:
950 sAT_PlusCPWD(CMD_SRC_LCL, CPWD_FAC_P2,
951 (char *)old_pin, (char *)new_pin);
952 break;
953 }
954 }
955
956
957 /*
958 +--------------------------------------------------------------------+
959 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
960 | STATE : code ROUTINE : sim_ok_cpinc |
961 +--------------------------------------------------------------------+
962
963 PURPOSE : Notify successful end of PIN change
964
965 */
966
967 void sim_ok_cpinc (void)
968 {
969 TRACE_FUNCTION("sim_ok_cpinc()");
970
971 sim_status.sim_procedure = MFW_SIM_CHANGE;
972 sim_status.sim_status = MFW_SIM_SUCCESS;
973 sim_status.sim_operation_mode = sim_config.oper_mode;
974 sim_status.sim_pin_retries = 0;
975 sim_status.sim_status_type = pin_ident;
976
977 pin_ident = MFW_SIM_UNKNOWN;
978 sim_signal(E_SIM_STATUS,&sim_status);
979 }
980
981
982 /*
983 +--------------------------------------------------------------------+
984 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
985 | STATE : code ROUTINE : sim_error_cpinc |
986 +--------------------------------------------------------------------+
987
988 PURPOSE : Notify failed PIN change
989
990 */
991
992 void sim_error_cpinc (void)
993 {
994 TRACE_FUNCTION("sim_error_cpinc()");
995
996 sim_status.sim_procedure = MFW_SIM_CHANGE;
997 sim_status.sim_status = MFW_SIM_FAILURE;
998 sim_status.sim_operation_mode = sim_config.oper_mode;
999 if (pin_ident EQ MFW_SIM_PIN1)
1000 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
1001 else if (pin_ident EQ MFW_SIM_PIN2)
1002 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN2);
1003 else
1004 sim_status.sim_pin_retries = 0;
1005 sim_status.sim_status_type = pin_ident;
1006
1007 pin_ident = MFW_SIM_UNKNOWN;
1008 sim_signal(E_SIM_STATUS,&sim_status);
1009 }
1010
1011
1012 /*
1013 +--------------------------------------------------------------------+
1014 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1015 | STATE : code ROUTINE : sim_disable_pin |
1016 +--------------------------------------------------------------------+
1017
1018 PURPOSE : Request PIN disability
1019
1020 */
1021
1022 void sim_disable_pin (U8 *pin)
1023 {
1024 TRACE_FUNCTION("sim_disable_pin()");
1025
1026 ss_set_clck(CLCK_FAC_Sc, CLCK_MOD_Unlock,
1027 (char *)pin, -1, MFW_SIM_CPIND);
1028 }
1029
1030
1031 /*
1032 +--------------------------------------------------------------------+
1033 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1034 | STATE : code ROUTINE : sim_ok_cpind |
1035 +--------------------------------------------------------------------+
1036
1037 PURPOSE : Successful end of PIN disability
1038
1039 */
1040
1041 void sim_ok_cpind (void)
1042 {
1043 TRACE_FUNCTION("sim_ok_cpind()");
1044
1045 sim_status.sim_procedure = MFW_SIM_DISABLE;
1046 sim_status.sim_status = MFW_SIM_SUCCESS;
1047 sim_status.sim_operation_mode = sim_config.oper_mode;
1048 sim_status.sim_pin_retries = 0;
1049 sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
1050
1051 pin1_set = MFW_SIM_DISABLE;
1052 sim_signal(E_SIM_STATUS,&sim_status);
1053 }
1054
1055
1056 /*
1057 +--------------------------------------------------------------------+
1058 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1059 | STATE : code ROUTINE : sim_error_cpind |
1060 +--------------------------------------------------------------------+
1061
1062 PURPOSE : Failed PIN disability
1063
1064 */
1065
1066 void sim_error_cpind (void)
1067 {
1068 TRACE_FUNCTION("sim_error_cpind()");
1069
1070 sim_status.sim_procedure = MFW_SIM_DISABLE;
1071 sim_status.sim_status = MFW_SIM_FAILURE;
1072 sim_status.sim_operation_mode = sim_config.oper_mode;
1073 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
1074 sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
1075
1076 sim_signal(E_SIM_STATUS,&sim_status);
1077 }
1078
1079
1080 /*
1081 +--------------------------------------------------------------------+
1082 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1083 | STATE : code ROUTINE : sim_enable_pin |
1084 +--------------------------------------------------------------------+
1085
1086 PURPOSE : Request PIN enability
1087
1088 */
1089
1090 void sim_enable_pin (U8 *pin)
1091 {
1092 TRACE_FUNCTION("sim_enable_pin()");
1093
1094 ss_set_clck(CLCK_FAC_Sc, CLCK_MOD_Lock,
1095 (char *)pin, -1, MFW_SIM_CPINE);
1096 }
1097
1098
1099 /*
1100 +--------------------------------------------------------------------+
1101 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1102 | STATE : code ROUTINE : sim_ok_cpine |
1103 +--------------------------------------------------------------------+
1104
1105 PURPOSE : Successful end of PIN enability
1106
1107 */
1108
1109 void sim_ok_cpine()
1110 {
1111 TRACE_FUNCTION("sim_ok_cpine()");
1112
1113 sim_status.sim_procedure = MFW_SIM_ENABLE;
1114 sim_status.sim_status = MFW_SIM_SUCCESS;
1115 sim_status.sim_operation_mode = sim_config.oper_mode;
1116 sim_status.sim_pin_retries = 0;
1117 sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
1118
1119 pin1_set = MFW_SIM_ENABLE;
1120 sim_signal(E_SIM_STATUS,&sim_status);
1121 }
1122
1123
1124 /*
1125 +--------------------------------------------------------------------+
1126 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1127 | STATE : code ROUTINE : sim_error_cpine |
1128 +--------------------------------------------------------------------+
1129
1130 PURPOSE : Failed PIN enability
1131
1132 */
1133
1134 void sim_error_cpine (void)
1135 {
1136 TRACE_FUNCTION("sim_error_cpine()");
1137
1138 sim_status.sim_procedure = MFW_SIM_ENABLE;
1139 sim_status.sim_status = MFW_SIM_FAILURE;
1140 sim_status.sim_operation_mode = sim_config.oper_mode;
1141 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
1142 sim_status.sim_status_type = MFW_SIM_UNKNOWN; // no indication
1143
1144 sim_signal(E_SIM_STATUS,&sim_status);
1145 }
1146
1147
1148 /*
1149 +--------------------------------------------------------------------+
1150 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1151 | STATE : code ROUTINE : sim_check_service |
1152 +--------------------------------------------------------------------+
1153
1154 PURPOSE : Checks a service status
1155
1156 */
1157
1158 U8 sim_check_service (U8 nr, U8 *serv_table)
1159 {
1160 U8 value;
1161
1162 TRACE_FUNCTION("sim_check_service()");
1163
1164 value = *(serv_table + (nr - 1) / 4);
1165 value >>= ((nr - 1) & 3) * 2;
1166
1167 return (value & 3);
1168 }
1169
1170
1171 /*
1172 +-----------------------------------------------------------------------+
1173 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1174 | STATE : code ROUTINE : sim_serv_table_check |
1175 +-----------------------------------------------------------------------+
1176
1177 PURPOSE : Checks a service status in SIM service table
1178
1179 */
1180
1181 T_MFW sim_serv_table_check(UBYTE serv_num)
1182 {
1183 TRACE_FUNCTION("sim_serv_table_check()");
1184 return sim_check_service(serv_num, sim_service_table);
1185 }
1186
1187
1188 /*
1189 +--------------------------------------------------------------------+
1190 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1191 | STATE : code ROUTINE : rAT_PlusCFUNP |
1192 +--------------------------------------------------------------------+
1193
1194 PURPOSE : MMI relevant parameters from the SIM card
1195
1196 */
1197
1198 void rAT_PlusCFUNP (T_SIM_MMI_INSERT_IND *mmi_insert_ind)
1199 {
1200 TRACE_FUNCTION("rAT_PlusCFUNP()");
1201
1202 sim_stat = SIM_ACTIVE;
1203
1204 sim_config.oper_mode = mmi_insert_ind->func;
1205 // sms_mmi_parameter(mmi_insert_ind->cbmid);
1206 nm_mmi_parameters(&mmi_insert_ind->imsi_field,
1207 &mmi_insert_ind->pref_plmn);
1208 memcpy(sim_service_table,mmi_insert_ind->sim_serv,
1209 sizeof(sim_service_table));
1210 //memcpy(sim_config.deper_key,mmi_insert_ind->deper_key,
1211 // sizeof(sim_config.deper_key));
1212 sim_config.phase = mmi_insert_ind->phase;
1213 sim_config.access_acm = mmi_insert_ind->access_acm;
1214 sim_config.access_acmmax = mmi_insert_ind->access_acmmax;
1215 sim_config.access_puct = mmi_insert_ind->access_puct;
1216
1217 // sim_init_sim_insert();
1218
1219 if (sim_check_service(15,sim_service_table)
1220 == ALLOCATED_AND_ACTIVATED)
1221 sim_read_sim(SIM_GID1, NOT_PRESENT_8BIT, 5);
1222 }
1223
1224
1225 /*
1226 +--------------------------------------------------------------------+
1227 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1228 | STATE : code ROUTINE : sim_mmi_parameter |
1229 +--------------------------------------------------------------------+
1230
1231 PURPOSE : MMI relevant parameters from the SIM card
1232
1233 */
1234
1235 void sim_mmi_parameter(T_SIM_ACTIVATE_CNF *sim_act_cnf)
1236 {
1237 TRACE_FUNCTION("sim_mmi_parameter()");
1238
1239 memcpy( sim_config.pref_lang, sim_act_cnf->pref_lang, 5);
1240 }
1241
1242
1243 /*
1244 +--------------------------------------------------------------------+
1245 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1246 | STATE : code ROUTINE : sim_gid1_cnf |
1247 +--------------------------------------------------------------------+
1248
1249 PURPOSE : read SIM group identifier 1 from SIM card
1250
1251 */
1252
1253 void sim_gid1_cnf(SHORT error, UBYTE *data)
1254 {
1255 TRACE_FUNCTION("sim_gid1_cnf()");
1256
1257 if (error EQ SIM_NO_ERROR)
1258 memcpy(sim_config.sim_gidl1, data, 5);
1259
1260 if (!sat_update)
1261 {
1262 if (sim_check_service(16,sim_service_table)
1263 == ALLOCATED_AND_ACTIVATED)
1264 sim_read_sim(SIM_GID2, NOT_PRESENT_8BIT, 5);
1265 }
1266 #ifdef SIM_TOOLKIT
1267 else
1268 {
1269 sat_update = FALSE;
1270 satUpdateFiles ( TRUE, SIM_GID1 );
1271 }
1272 #endif
1273 }
1274
1275
1276 /*
1277 +--------------------------------------------------------------------+
1278 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1279 | STATE : code ROUTINE : sim_gid2_cnf |
1280 +--------------------------------------------------------------------+
1281
1282 PURPOSE : read SIM group identifier 2 from SIM card
1283
1284 */
1285
1286 void sim_gid2_cnf(SHORT error, UBYTE *data)
1287 {
1288 TRACE_FUNCTION("sim_gid2_cnf()");
1289 if (error EQ SIM_NO_ERROR)
1290 memcpy(sim_config.sim_gidl2, data, 5);
1291
1292 #ifdef SIM_TOOLKIT
1293 if ( sat_update )
1294 {
1295 sat_update = FALSE;
1296 satUpdateFiles ( TRUE, SIM_GID2 );
1297 }
1298 #endif
1299 }
1300
1301
1302 /*
1303 +--------------------------------------------------------------------+
1304 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1305 | STATE : code ROUTINE : sim_save_pref_lang |
1306 +--------------------------------------------------------------------+
1307
1308 PURPOSE : save preferred language
1309
1310 */
1311
1312 void sim_save_pref_lang (UBYTE *lang, UBYTE len)
1313 {
1314 UBYTE sim_data[7];
1315 UBYTE i;
1316
1317 TRACE_FUNCTION("sim_save_pref_lang()");
1318
1319 //
1320 // copy a maximum of 5 bytes for storing on the SIM card
1321 //
1322 for (i=0;i<len AND i<5;i++)
1323 sim_data[i] = lang[i];
1324
1325 //
1326 // if less than 5 bytes fill with dummy values
1327 //
1328 for (i=len; i<5;i++)
1329 sim_data[i] = 0xFF;
1330
1331 //
1332 // write to the SIM card
1333 //
1334 sim_write_sim(SIM_LP, sim_data, 5);
1335 }
1336
1337
1338 /*
1339 +--------------------------------------------------------------------+
1340 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1341 | STATE : code ROUTINE : rAT_PercentSIMREM |
1342 +--------------------------------------------------------------------+
1343
1344 PURPOSE : call back for SIM removed
1345
1346 */
1347
1348 void rAT_PercentSIMREM( T_ACI_SIMREM_TYPE srType )
1349 {
1350 TRACE_FUNCTION("rAT_PercentSIMREM()");
1351
1352 if ( srType EQ SIMREM_FAILURE )
1353 {
1354 sim_status.sim_procedure = MFW_SIM_REMOVED;
1355 sim_status.sim_status = MFW_SIM_NO_SIM_CARD;
1356 sim_status.sim_operation_mode = sim_config.oper_mode;
1357 sim_status.sim_pin_retries = 0;
1358 sim_status.sim_status_type = MFW_SIM_UNKNOWN;
1359 sim_stat = SIM_NOT_ACTIVE;
1360 sim_signal(E_SIM_STATUS,&sim_status);
1361 }
1362 else if ( srType EQ SIMREM_RESET )
1363 {
1364 #ifdef SIM_TOOLKIT
1365 sim_signal(E_SIM_RESET, 0);
1366 #endif
1367 }
1368 }
1369
1370
1371 /*
1372 +--------------------------------------------------------------------+
1373 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1374 | STATE : code ROUTINE : rAT_percentSIMINS |
1375 +--------------------------------------------------------------------+
1376
1377 PURPOSE : call back for SIM inserted
1378
1379 */
1380
1381 void rAT_PercentSIMINS( T_ACI_CME_ERR err )
1382 {
1383 TRACE_FUNCTION("rAT_percentSIMINS()");
1384
1385 sim_signal(E_SIM_INSERTED, 0);
1386
1387 switch ( err )
1388 {
1389 case CME_ERR_SimPinReq:
1390 sim_status.sim_status = MFW_SIM_PIN_REQ;
1391 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PIN1);
1392 sim_status.sim_status_type = MFW_SIM_PIN1;
1393 sim_stat = SIM_ACTIVE;
1394 sim_signal(E_SIM_STATUS, &sim_status);
1395 break;
1396
1397 case CME_ERR_SimPukReq:
1398 sim_status.sim_status = MFW_SIM_PUK_REQ;
1399 sim_status.sim_pin_retries = sim_pin_count(MFW_SIM_PUK1);
1400 sim_status.sim_status_type = MFW_SIM_PUK1;
1401 sim_stat = SIM_ACTIVE;
1402 sim_signal(E_SIM_STATUS, &sim_status);
1403 break;
1404
1405 default:
1406 break;
1407 }
1408 }
1409
1410
1411 /*
1412 +--------------------------------------------------------------------+
1413 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1414 | STATE : code ROUTINE : sim_configuration |
1415 +--------------------------------------------------------------------+
1416
1417 PURPOSE : Request the configuration of SIM card
1418
1419 */
1420
1421 UBYTE sim_cvt_access_status(UBYTE acs)
1422 {
1423 TRACE_FUNCTION("sim_cvt_access_status()");
1424
1425 switch(acs)
1426 {
1427 case ACCESS_ALWAYS: return MFW_SIM_NO_PIN;
1428 case ACCESS_PIN_1: return MFW_SIM_PIN1;
1429 case ACCESS_PIN_2: return MFW_SIM_PIN2;
1430 default: return MFW_SIM_UNKNOWN;
1431 }
1432 }
1433
1434
1435 /*
1436 +--------------------------------------------------------------------+
1437 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1438 | STATE : code ROUTINE : sim_configuration |
1439 +--------------------------------------------------------------------+
1440
1441 PURPOSE : Request the configuration of SIM card
1442
1443 */
1444
1445 MfwRes sim_configuration (U8 *phase, U8 *serv, U8 *slen,
1446 U8 *lang, U8 *llen,
1447 T_MFW_AOC_ACCESS *access)
1448 {
1449 U8 l;
1450 TRACE_FUNCTION("sim_configuration()");
1451
1452 //PATCH2 TB 1310: Add test of NULL parameter to avoid to declare parameter of unwanted data
1453 if (sim_stat != SIM_ACTIVE)
1454 return MFW_SIM_FAILURE;
1455
1456 if (phase != NULL)
1457 *phase = sim_config.phase;
1458
1459 if ((serv != NULL) && (slen != NULL))
1460 {
1461 l = sizeof(sim_service_table);
1462 if (l < *slen)
1463 *slen = l;
1464 memcpy(serv,sim_service_table,*slen);
1465 }
1466
1467 //PATCH1 TB 1310: replace slen by llen
1468 if ((lang != NULL) && (llen != NULL))
1469 {
1470 l = sizeof(sim_config.pref_lang);
1471 if (l < *llen)
1472 *llen = l;
1473 memcpy(lang, sim_config.pref_lang, *llen);
1474 }
1475 //END PATCH1 TB
1476
1477 if (access != NULL)
1478 {
1479 access->access_acm = sim_cvt_access_status(sim_config.access_acm);
1480 access->access_acmmax = sim_cvt_access_status(sim_config.access_acmmax);
1481 access->access_puct = sim_cvt_access_status(sim_config.access_puct);
1482 }
1483 //END PATCH2 TB
1484
1485 return MFW_SIM_SUCCESS;
1486 }
1487
1488
1489 /*
1490 +--------------------------------------------------------------------+
1491 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1492 | STATE : code ROUTINE : sim_status_check |
1493 +--------------------------------------------------------------------+
1494
1495 PURPOSE : check activation of SIM card
1496
1497 */
1498
1499 int sim_status_check (void)
1500 {
1501 TRACE_FUNCTION("sim_status_check()");
1502
1503 return sim_stat;
1504 }
1505
1506
1507 /*
1508 +--------------------------------------------------------------------+
1509 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1510 | STATE : code ROUTINE : sim_pin_count |
1511 +--------------------------------------------------------------------+
1512
1513 PURPOSE : Request PIN/PUK count
1514
1515 */
1516
1517 int sim_pin_count(U8 pin_id)
1518 {
1519 SHORT pn1Cnt;
1520 SHORT pn2Cnt;
1521 SHORT pk1Cnt;
1522 SHORT pk2Cnt;
1523 T_ACI_PVRF_STAT ps1;
1524 T_ACI_PVRF_STAT ps2;
1525
1526 TRACE_FUNCTION("sim_pin_count()");
1527
1528
1529 if (qAT_PercentPVRF(CMD_SRC_LCL, &pn1Cnt,
1530 &pn2Cnt, &pk1Cnt, &pk2Cnt, &ps1, &ps2) != AT_CMPL)
1531 return -1;
1532
1533 switch (pin_id)
1534 {
1535 case MFW_SIM_PIN1: return pn1Cnt;
1536 case MFW_SIM_PIN2: return pn2Cnt;
1537 case MFW_SIM_PUK1: return pk1Cnt;
1538 case MFW_SIM_PUK2: return pk2Cnt;
1539 default: return -1;
1540 }
1541 }
1542
1543
1544 /*
1545 +--------------------------------------------------------------------+
1546 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1547 | STATE : code ROUTINE : simDecodeB2A |
1548 +--------------------------------------------------------------------+
1549
1550 PURPOSE : convert bcd to ASCII
1551
1552 */
1553
1554 void simDecodeB2A (U8 *ci, U8 li, U8 *di)
1555 {
1556 int i;
1557
1558 TRACE_FUNCTION("simDecodeB2A()");
1559
1560 for (i = 0; i < li * 2; i++)
1561 {
1562 di[i] = (i & 1) ? (ci[i/2] >> 4) + '0'
1563 : (ci[i/2] & 0x0f) + '0';
1564 if (di[i] > '9')
1565 {
1566 di[i] = 0;
1567 break;
1568 }
1569 }
1570 di[i] = 0;
1571 }
1572
1573
1574 /*
1575 +---------------------------------------------------------------------+
1576 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1577 | STATE : code ROUTINE : sim_unlock_sim_lock |
1578 +---------------------------------------------------------------------+
1579
1580 PURPOSE : de-personalisation for SIM lock.
1581
1582 */
1583
1584 T_MFW sim_unlock_sim_lock(UBYTE type, UBYTE *passwd)
1585 {
1586 UBYTE eep_ckey [LONG_NAME]; // extracted version of PCM content
1587 EF_SIMLCKEXT simlck;
1588
1589 TRACE_FUNCTION("sim_unlock_sim_lock()");
1590
1591 /*
1592 * Read SIM LOCK Record from PCM
1593 */
1594 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
1595 {
1596 TRACE_ERROR("No SIMLCK");
1597 return MFW_SIM_UNLOCK_ERR;
1598 }
1599
1600 /*
1601 * check whether card is already blocked
1602 */
1603 if (simlck.cnt >= simlck.maxcnt)
1604 return MFW_SIM_BLOCKED;
1605
1606 switch (type)
1607 {
1608 /*
1609 * N-Lock
1610 */
1611 case MFW_SIM_NLOCK:
1612 /*
1613 * Extract Key from PCM record
1614 */
1615 simDecodeB2A (simlck.NKey, 8, eep_ckey);
1616 if (!strcmp((char *)eep_ckey, (char *)passwd))
1617 {
1618 /*
1619 * unblock password is okay
1620 */
1621 sim_nlock = SIMLOCK_ENABLED;
1622 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nlock,sim_nlock);
1623 simlck.cnt = 0;
1624 sim_set_sim_lock (&simlck);
1625
1626 return MFW_SIM_NLOCK;
1627 }
1628 break;
1629
1630 /*
1631 * SP-Lock
1632 */
1633 case MFW_SIM_SPLOCK:
1634 /*
1635 * Extract Key from PCM record
1636 */
1637 simDecodeB2A (simlck.SPKey, 8, eep_ckey);
1638 if (!strcmp((char *)eep_ckey, (char *)passwd))
1639 {
1640 /*
1641 * unblock password is okay
1642 */
1643 sim_splock = SIMLOCK_ENABLED;
1644 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
1645 simlck.cnt = 0;
1646 sim_set_sim_lock (&simlck);
1647
1648 return MFW_SIM_SPLOCK;
1649 }
1650 break;
1651
1652 /*
1653 * NS-Lock
1654 */
1655 case MFW_SIM_NSLOCK:
1656 /*
1657 * Extract Key from PCM record
1658 */
1659 simDecodeB2A (simlck.NSKey, 8, eep_ckey);
1660 if (!strcmp((char *)eep_ckey, (char *)passwd))
1661 {
1662 /*
1663 * unblock password is okay
1664 */
1665 sim_nslock = SIMLOCK_ENABLED;
1666 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nslock,sim_nslock);
1667 simlck.cnt = 0;
1668 sim_set_sim_lock (&simlck);
1669
1670 return MFW_SIM_NSLOCK;
1671 }
1672 break;
1673
1674 /*
1675 * C-Lock
1676 */
1677 case MFW_SIM_CLOCK:
1678 /*
1679 * Extract Key from PCM record
1680 */
1681 simDecodeB2A (simlck.CKey, 8, eep_ckey);
1682 if (!strcmp((char *)eep_ckey, (char *)passwd))
1683 {
1684 /*
1685 * unblock password is okay
1686 */
1687 sim_clock = SIMLOCK_ENABLED;
1688 simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
1689 simlck.cnt = 0;
1690 sim_set_sim_lock (&simlck);
1691
1692 return MFW_SIM_CLOCK;
1693 }
1694 break;
1695
1696 /*
1697 * P-Lock
1698 */
1699 case MFW_SIM_PLOCK:
1700 /*
1701 * Extract Key from PCM record
1702 */
1703 simDecodeB2A (simlck.PKey, 8, eep_ckey);
1704 if (!strcmp((char *)eep_ckey, (char *)passwd))
1705 {
1706 /*
1707 * unblock password is correct
1708 */
1709 sim_plock = SIMLOCK_ENABLED;
1710 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,plock,sim_plock);
1711 simlck.cnt = 0;
1712 sim_set_sim_lock (&simlck);
1713
1714 return MFW_SIM_PLOCK;
1715 }
1716 break;
1717
1718 default:
1719 return MFW_SIM_UNLOCK_ERR;
1720 }
1721
1722 /*
1723 * another failed attempt
1724 * increment counter, store in PCM and may change the status
1725 */
1726 simlck.cnt++;
1727 sim_set_sim_lock (&simlck);
1728
1729 if (simlck.cnt >= simlck.maxcnt)
1730 {
1731 sim_blocked = TRUE;
1732 return MFW_SIM_BLOCKED;
1733 }
1734 else
1735 return MFW_SIM_UNLOCK_ERR;
1736 }
1737
1738 /*
1739 +---------------------------------------------------------------------+
1740 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1741 | STATE : code ROUTINE : sim_check_sim_Plock |
1742 +---------------------------------------------------------------------+
1743
1744 PURPOSE : check SIM lock
1745
1746 */
1747
1748 int sim_check_sim_Plock (void)
1749 {
1750 EF_SIMLCKEXT simlck;
1751 UBYTE i;
1752
1753 TRACE_FUNCTION ("sim_check_sim_Plock()");
1754
1755
1756 if (sim_blocked EQ TRUE OR
1757 sim_plock EQ SIMLOCK_BLOCKED)
1758 {
1759 /*
1760 * Try to reset unlock attempt counter
1761 */
1762 sim_check_unblock_sim (&simlck);
1763 return MFW_SIM_BLOCKED;
1764 }
1765
1766 /*
1767 * lock check disabled
1768 */
1769 if (sim_plock EQ SIMLOCK_DISABLED)
1770 return MFW_SIM_DISABLE;
1771
1772 /*
1773 * lock check blocked
1774 */
1775 if (sim_plock EQ SIMLOCK_LOCKED)
1776 return MFW_SIM_LOCKED;
1777
1778 /*
1779 * lock check enabled
1780 */
1781 if (sim_plock EQ SIMLOCK_ENABLED)
1782 {
1783 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
1784 {
1785 TRACE_ERROR("No SIMLCK");
1786 return MFW_SIM_FAILURE;
1787 }
1788
1789 /*
1790 * Check all digits
1791 */
1792 for (i=0; i<simlck.len_p_imsi; i++)
1793 {
1794 if (sim_check_imsi_digit(simlck.p_imsi[i], mfw_IMSI[i]) EQ FALSE)
1795 break;
1796 }
1797
1798 /*
1799 * all digits okay
1800 */
1801 if (i EQ simlck.len_p_imsi)
1802 return MFW_SIM_ENABLE;
1803
1804 /*
1805 * P-LOCK check failed
1806 */
1807
1808 sim_plock = SIMLOCK_LOCKED;
1809 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,plock,sim_plock);
1810 sim_set_sim_lock (&simlck);
1811 return MFW_SIM_LOCKED;
1812 }
1813
1814 /*
1815 * shall not happen
1816 */
1817 return MFW_SIM_FAILURE;
1818 }
1819
1820
1821 /*
1822 +---------------------------------------------------------------------+
1823 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1824 | STATE : code ROUTINE : sim_check_sim_Nlock |
1825 +---------------------------------------------------------------------+
1826
1827 PURPOSE : Check network lock
1828
1829 */
1830
1831 int sim_check_sim_Nlock (void)
1832 {
1833 EF_SIMLCKEXT simlck;
1834 UBYTE i;
1835
1836 TRACE_FUNCTION ("sim_check_sim_Nlock()");
1837
1838 if (sim_blocked EQ TRUE OR
1839 sim_nlock EQ SIMLOCK_BLOCKED)
1840 {
1841 /*
1842 * Try to reset unlock attempt counter
1843 */
1844 sim_check_unblock_sim (&simlck);
1845 return MFW_SIM_BLOCKED;
1846 }
1847
1848 /*
1849 * lock check disabled
1850 */
1851 if (sim_nlock EQ SIMLOCK_DISABLED)
1852 return MFW_SIM_DISABLE;
1853
1854 /*
1855 * lock check blocked
1856 */
1857 if (sim_nlock EQ SIMLOCK_LOCKED)
1858 return MFW_SIM_LOCKED;
1859
1860 /*
1861 * lock check enabled
1862 */
1863 if (sim_nlock EQ SIMLOCK_ENABLED)
1864 {
1865 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
1866 {
1867 TRACE_ERROR("No SIMLCK");
1868 return MFW_SIM_FAILURE;
1869 }
1870
1871 /*
1872 * check all digits
1873 */
1874 for (i=0; i<simlck.len_n_imsi; i++)
1875 {
1876 if (sim_check_imsi_digit(simlck.n_imsi[i], mfw_IMSI[i]) EQ FALSE)
1877 break;
1878 }
1879
1880 /*
1881 * all digits okay
1882 */
1883 if (i EQ simlck.len_n_imsi)
1884 return MFW_SIM_ENABLE;
1885
1886 /*
1887 * N-LOCK check failed
1888 */
1889 sim_nlock = SIMLOCK_LOCKED;
1890 simlck.locks1 = (U8) FldSet(simlck.locks1,nlock,sim_nlock);
1891 sim_set_sim_lock (&simlck);
1892 return MFW_SIM_LOCKED;
1893 }
1894 /*
1895 * shall not happen
1896 */
1897 return MFW_SIM_FAILURE;
1898 }
1899
1900
1901 /*
1902 +---------------------------------------------------------------------+
1903 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
1904 | STATE : code ROUTINE : sim_check_sim_SPlock|
1905 +---------------------------------------------------------------------+
1906
1907 PURPOSE : Check SIM service provider lock. It only works with SIMs
1908 which support GID1 file.
1909
1910 */
1911
1912 int sim_check_sim_SPlock (void)
1913 {
1914 EF_SIMLCKEXT simlck;
1915 UBYTE i;
1916
1917 TRACE_FUNCTION ("sim_check_sim_SPlock()");
1918
1919 /*
1920 * Only if Service 15 is activated and allocated
1921 */
1922 if (sim_check_service(15,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
1923 return MFW_SIM_FAILURE;
1924
1925 if (sim_blocked EQ TRUE OR
1926 sim_splock EQ SIMLOCK_BLOCKED)
1927 {
1928 /*
1929 * Try to reset unlock attempt counter
1930 */
1931 sim_check_unblock_sim (&simlck);
1932 return MFW_SIM_BLOCKED;
1933 }
1934
1935 /*
1936 * lock check disabled
1937 */
1938 if (sim_splock EQ SIMLOCK_DISABLED)
1939 return MFW_SIM_DISABLE;
1940
1941 /*
1942 * lock check blocked
1943 */
1944 if (sim_splock EQ SIMLOCK_LOCKED)
1945 return MFW_SIM_LOCKED;
1946
1947 /*
1948 * lock check enabled
1949 */
1950 if (sim_splock EQ SIMLOCK_ENABLED)
1951 {
1952 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
1953 {
1954 TRACE_ERROR("No SIMLCK");
1955 return MFW_SIM_FAILURE;
1956 }
1957
1958 /*
1959 * check SP group identifier
1960 */
1961 if (memcmp(&simlck.gidl1, sim_config.sim_gidl1, 1))
1962 {
1963 sim_splock = SIMLOCK_LOCKED;
1964 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
1965 sim_set_sim_lock (&simlck);
1966
1967 return MFW_SIM_LOCKED;
1968 }
1969
1970 /*
1971 * check all digits
1972 */
1973 for (i=0; i<simlck.len_sp_imsi; i++)
1974 {
1975 if (sim_check_imsi_digit(simlck.sp_imsi[i], mfw_IMSI[i]) EQ FALSE)
1976 break;
1977 }
1978
1979 /*
1980 * all digits okay
1981 */
1982 if (i EQ simlck.len_sp_imsi)
1983 return MFW_SIM_ENABLE;
1984
1985 /*
1986 * failed SP-Lock
1987 */
1988 sim_splock = SIMLOCK_LOCKED;
1989 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,splock,sim_splock);
1990 sim_set_sim_lock (&simlck);
1991
1992 return MFW_SIM_LOCKED;
1993 }
1994 /*
1995 * shall not happen
1996 */
1997 return MFW_SIM_FAILURE;
1998 }
1999
2000
2001 /*
2002 +---------------------------------------------------------------------+
2003 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2004 | STATE : code ROUTINE : sim_check_sim_NSlock|
2005 +---------------------------------------------------------------------+
2006
2007 PURPOSE : Check network subset lock
2008
2009 */
2010
2011 int sim_check_sim_NSlock (void)
2012 {
2013 EF_SIMLCKEXT simlck;
2014 UBYTE i;
2015
2016 TRACE_FUNCTION ("sim_check_sim_NSlock()");
2017
2018 if (sim_blocked EQ TRUE OR
2019 sim_nslock EQ SIMLOCK_BLOCKED)
2020 {
2021 /*
2022 * Try to reset unlock attempt counter
2023 */
2024 sim_check_unblock_sim (&simlck);
2025 return MFW_SIM_BLOCKED;
2026 }
2027
2028 /*
2029 * lock check disabled
2030 */
2031 if (sim_nslock EQ SIMLOCK_DISABLED)
2032 return MFW_SIM_DISABLE;
2033
2034 /*
2035 * lock check blocked
2036 */
2037 if (sim_nslock EQ SIMLOCK_LOCKED)
2038 return MFW_SIM_LOCKED;
2039
2040 /*
2041 * lock check enabled
2042 */
2043 if (sim_nslock EQ SIMLOCK_ENABLED)
2044 {
2045 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
2046 {
2047 TRACE_ERROR("No SIMLCK");
2048 return MFW_SIM_FAILURE;
2049 }
2050
2051 /*
2052 * check all digits
2053 */
2054 for (i=0; i<simlck.len_ns_imsi; i++)
2055 {
2056 if (sim_check_imsi_digit(simlck.ns_imsi[i], mfw_IMSI[i]) EQ FALSE)
2057 break;
2058 }
2059
2060 /*
2061 * all digits okay
2062 */
2063 if (i EQ simlck.len_ns_imsi)
2064 return MFW_SIM_ENABLE;
2065
2066 /*
2067 * Lock has failed
2068 */
2069 sim_nslock = SIMLOCK_LOCKED;
2070 simlck.locks1 = (UBYTE) FldSet(simlck.locks1,nslock,sim_nslock);
2071 sim_set_sim_lock (&simlck);
2072
2073 return MFW_SIM_LOCKED;
2074 }
2075
2076 /*
2077 * shall not happen
2078 */
2079 return MFW_SIM_FAILURE;
2080 }
2081
2082 /*
2083 +---------------------------------------------------------------------+
2084 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2085 | STATE : code ROUTINE : sim_check_sim_Clock |
2086 +---------------------------------------------------------------------+
2087
2088 PURPOSE : Check corporate lock. It only works with SIMs
2089 which support GID1 and GID2 files.
2090
2091 */
2092
2093 int sim_check_sim_Clock (void)
2094 {
2095 EF_SIMLCKEXT simlck;
2096 UBYTE i;
2097
2098 TRACE_FUNCTION ("sim_check_sim_Clock()");
2099
2100 /*
2101 * check the SIM supports GID1 and GID2
2102 */
2103 if (sim_check_service(15,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
2104 return MFW_SIM_FAILURE;
2105
2106 if (sim_check_service(16,sim_service_table) NEQ ALLOCATED_AND_ACTIVATED)
2107 return MFW_SIM_FAILURE;
2108
2109 if (sim_blocked EQ TRUE OR
2110 sim_clock EQ SIMLOCK_BLOCKED)
2111 {
2112 /*
2113 * Try to reset unlock attempt counter
2114 */
2115 sim_check_unblock_sim (&simlck);
2116 return MFW_SIM_BLOCKED;
2117 }
2118
2119 /*
2120 * lock check disabled
2121 */
2122 if (sim_clock EQ SIMLOCK_DISABLED)
2123 return MFW_SIM_DISABLE;
2124
2125 /*
2126 * lock check blocked
2127 */
2128 if (sim_clock EQ SIMLOCK_LOCKED)
2129 return MFW_SIM_LOCKED;
2130
2131 /*
2132 * lock check enabled
2133 */
2134 if (sim_clock EQ SIMLOCK_ENABLED)
2135 {
2136 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
2137 {
2138 TRACE_ERROR("No SIMLCK");
2139 return MFW_SIM_FAILURE;
2140 }
2141
2142 /*
2143 * check SP group identifier 1 and 2
2144 */
2145 if (simlck.gidl1 NEQ sim_config.sim_gidl1[0] OR
2146 simlck.gidl2 NEQ sim_config.sim_gidl2[0])
2147 {
2148 sim_clock = SIMLOCK_LOCKED;
2149 simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
2150 sim_set_sim_lock (&simlck);
2151 return MFW_SIM_LOCKED;
2152 }
2153
2154 /*
2155 * check all digits */
2156 for (i=0; i<simlck.len_c_imsi; i++)
2157 {
2158 if (sim_check_imsi_digit(simlck.c_imsi[i], mfw_IMSI[i]) EQ FALSE)
2159 break;
2160 }
2161
2162 /*
2163 * all digits okay
2164 */
2165 if (i EQ simlck.len_c_imsi)
2166 return MFW_SIM_ENABLE;
2167
2168 /*
2169 * C-Lock has failed
2170 */
2171 sim_clock = SIMLOCK_LOCKED;
2172 simlck.locks2 = (UBYTE) FldSet(simlck.locks2,clock,sim_clock);
2173 sim_set_sim_lock (&simlck);
2174
2175 return MFW_SIM_LOCKED;
2176 }
2177 return MFW_SIM_FAILURE;
2178 }
2179
2180 /*
2181 +-----------------------------------------------------------------------+
2182 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2183 | STATE : code ROUTINE : sim_get_simlock_count |
2184 +-----------------------------------------------------------------------+
2185
2186 PURPOSE : Request the count of SIMLOCK
2187
2188 */
2189
2190 T_MFW sim_get_simlock_count(UBYTE *cnt)
2191 {
2192 EF_SIMLCKEXT simlck;
2193
2194 TRACE_FUNCTION("sim_get_simlock_count()");
2195
2196 if (sim_get_sim_lock (&simlck) NEQ PCM_OK)
2197 return MFW_SIM_FAILURE;
2198 else
2199 *cnt = simlck.cnt;
2200 return MFW_SIM_SUCCESS;
2201 }
2202
2203 /*
2204 +--------------------------------------------------------------------+
2205 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2206 | STATE : code ROUTINE : sim_pin_status |
2207 +--------------------------------------------------------------------+
2208
2209 PURPOSE : Request PIN1/PIN2 status
2210
2211 */
2212
2213 void sim_pin_status(T_MFW_SIM_PIN_STATUS *status)
2214 {
2215 SHORT pn1Cnt;
2216 SHORT pn2Cnt;
2217 SHORT pk1Cnt;
2218 SHORT pk2Cnt;
2219 T_ACI_PVRF_STAT ps1;
2220 T_ACI_PVRF_STAT ps2;
2221
2222 TRACE_FUNCTION("sim_pin_status()");
2223
2224 status->stat = MFW_SIM_UNKNOWN;
2225 status->set = MFW_SIM_UNKNOWN;
2226 if (qAT_PercentPVRF(CMD_SRC_LCL, &pn1Cnt,
2227 &pn2Cnt, &pk1Cnt, &pk2Cnt, &ps1, &ps2) == AT_CMPL)
2228 {
2229 switch (status->type)
2230 {
2231 case MFW_SIM_PIN1:
2232 status->stat = sim_cvtPINstatus(ps1, MFW_SIM_PIN1);
2233 status->set = pin1_set;
2234 break;
2235 case MFW_SIM_PIN2:
2236 status->stat = sim_cvtPINstatus(ps2, MFW_SIM_PIN2);
2237 status->set = pin2_set;
2238 break;
2239 }
2240 }
2241 }
2242
2243
2244 /*
2245 +--------------------------------------------------------------------+
2246 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2247 | STATE : code ROUTINE : sim_cvtPINstatus |
2248 +--------------------------------------------------------------------+
2249
2250 PURPOSE :
2251
2252 */
2253
2254 UBYTE sim_cvtPINstatus(T_ACI_PVRF_STAT ps, UBYTE type)
2255 {
2256 TRACE_FUNCTION("sim_cvtPINstatus()");
2257
2258 switch (ps)
2259 {
2260 case PVRF_STAT_NotRequired:
2261 return MFW_SIM_NO_PIN;
2262 case PVRF_STAT_Required:
2263 if (type EQ MFW_SIM_PIN1)
2264 return MFW_SIM_PIN_REQ;
2265 if (type EQ MFW_SIM_PIN2)
2266 return MFW_SIM_PIN2_REQ;
2267 return MFW_SIM_UNKNOWN;
2268 default:
2269 return MFW_SIM_UNKNOWN;
2270 }
2271 }
2272
2273
2274 /*
2275 +--------------------------------------------------------------------+
2276 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2277 | STATE : code ROUTINE : simDecodeIMSI |
2278 +--------------------------------------------------------------------+
2279
2280 PURPOSE : convert imsi (packed bcd to ASCIIZ; ->11.11)
2281
2282 */
2283
2284 void simDecodeIMSI (UBYTE * imsi_field,
2285 UBYTE imsi_c_field,
2286 UBYTE * imsi_extracted)
2287 {
2288 UBYTE length;
2289 UBYTE i;
2290 UBYTE digit;
2291
2292 TRACE_FUNCTION ("simDecodeImsi()");
2293
2294 /*
2295 * calculate number of digits
2296 */
2297 length = (imsi_c_field-1)*2;
2298
2299 /*
2300 * if odd number of digits add one
2301 */
2302 if (imsi_field[0] & 0x08)
2303 length++;
2304
2305 /*
2306 * extract all digits
2307 */
2308 for (i = 0; i < length; i++)
2309 {
2310 digit = (i & 1) ?
2311 imsi_field[(i + 1) / 2] & 0x0f :
2312 (imsi_field[(i + 1) / 2] & 0xf0) >> 4;
2313
2314 #if defined (WIN32)
2315 {
2316 char buf[40];
2317 sprintf (buf, "DIGIT [%d] = %d",i, digit);
2318 TRACE_FUNCTION (buf);
2319 }
2320 #endif
2321 if (i < LONG_NAME)
2322 imsi_extracted [i] = digit + 0x30;
2323 else
2324 {
2325 imsi_extracted [i] = 0;
2326 return;
2327 }
2328 }
2329 }
2330
2331 /*
2332 +--------------------------------------------------------------------+
2333 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2334 | STATE : code ROUTINE : sim_pin_ident |
2335 +--------------------------------------------------------------------+
2336
2337 PURPOSE : handle mfw windows command
2338
2339 */
2340
2341 void sim_pin_ident(UBYTE id)
2342 {
2343 TRACE_FUNCTION("sim_pin_ident()");
2344 pin_ident = id;
2345 }
2346
2347 /*
2348 +-----------------------------------------------------------------------+
2349 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2350 | STATE : code ROUTINE : sim_check_imsi_digit |
2351 +-----------------------------------------------------------------------+
2352
2353 PURPOSE : Check a IMSI digit
2354
2355 */
2356
2357 T_MFW sim_check_imsi_digit(UBYTE pcm_imsi, UBYTE sim_imsi)
2358 {
2359 UBYTE h;
2360 UBYTE l;
2361
2362 TRACE_FUNCTION("sim_check_imsi_digit()");
2363
2364 h = pcm_imsi >> 4 | 0x30;
2365 l = pcm_imsi & 0x0F | 0x30;
2366
2367 #if defined (WIN32)
2368 {
2369 char buf[40];
2370 sprintf (buf, "check %c shall be in the range [%c..%c]",
2371 sim_imsi, h, l);
2372 TRACE_FUNCTION (buf);
2373 }
2374 #endif
2375
2376 if (h > l)
2377 return FALSE;
2378
2379 if ((sim_imsi < h) OR (sim_imsi > l))
2380 return FALSE;
2381
2382 return TRUE;
2383 }
2384
2385 /*
2386 +--------------------------------------------------------------------+
2387 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2388 | STATE : code ROUTINE : simCommand |
2389 +--------------------------------------------------------------------+
2390
2391 PURPOSE : handle mfw windows command
2392
2393 */
2394
2395 static int simCommand (U32 cmd, void *h)
2396 {
2397 switch (cmd)
2398 {
2399 case MfwCmdDelete: /* delete me */
2400 if (!h)
2401 return 0;
2402 sim_delete(h);
2403 return 1;
2404 default:
2405 break;
2406 }
2407
2408 return 0;
2409 }
2410
2411
2412
2413 /*
2414 +--------------------------------------------------------------------+
2415 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2416 | STATE : code ROUTINE : sim_get_sim_lock |
2417 +--------------------------------------------------------------------+
2418
2419 PURPOSE : Reads the SIM LOCK Record content from PCM
2420
2421 */
2422
2423 #if defined (WIN32)
2424 static const UBYTE sim_lock_table_1 [] =
2425 {
2426 //
2427 // all locks enabled, wrong IMSI
2428 //
2429 0x55, 0x01, // locks
2430 0x00, // unblock counter
2431 0x0F, // maximum attempt
2432 0x21, 0x43, 0x65, 0x87, // P control key
2433 0xFF, 0xFF, 0xFF, 0xFF,
2434 0x21, 0x43, 0x65, 0x87, // N control key
2435 0xFF, 0xFF, 0xFF, 0xFF,
2436 0x21, 0x43, 0x65, 0x87, // NS control key
2437 0xFF, 0xFF, 0xFF, 0xFF,
2438 0x21, 0x43, 0x65, 0x87, // SP control key
2439 0xFF, 0xFF, 0xFF, 0xFF,
2440 0x21, 0x43, 0x65, 0x87, // C control key
2441 0xFF, 0xFF, 0xFF, 0xFF,
2442 0x0F, // length of IMSI
2443 0x22, 0x00, 0x22, 0x01, // IMSI range definition
2444 0x23, 0x15, 0x22, 0x35,
2445 0x24, 0x25, 0x11, 0x22,
2446 0x46, 0x55, 0x66,
2447 0x00, 0x00 // Group Identifier
2448 };
2449
2450 static const UBYTE sim_lock_table_2 [] =
2451 {
2452 //
2453 // all locks enabled, IMSI ok
2454 //
2455 0x55, 0x01, // locks
2456 0x00, // unblock counter
2457 0x0F, // maximum attempt
2458 0x21, 0x43, 0x65, 0x87, // P control key
2459 0xFF, 0xFF, 0xFF, 0xFF,
2460 0x21, 0x43, 0x65, 0x87, // N control key
2461 0xFF, 0xFF, 0xFF, 0xFF,
2462 0x21, 0x43, 0x65, 0x87, // NS control key
2463 0xFF, 0xFF, 0xFF, 0xFF,
2464 0x21, 0x43, 0x65, 0x87, // SP control key
2465 0xFF, 0xFF, 0xFF, 0xFF,
2466 0x21, 0x43, 0x65, 0x87, // C control key
2467 0xFF, 0xFF, 0xFF, 0xFF,
2468 0x0D, // length of IMSI
2469 0x22, 0x66, 0x22, 0x00, // IMSI range definition
2470 0x11, 0x44, 0x77, 0x09,
2471 0x09, 0x09, 0x09, 0x09,
2472 0x09, 0x09, 0x09,
2473 0x00, 0x00 // Group Identifier
2474 };
2475
2476 static const UBYTE sim_lock_table_3 [] =
2477 {
2478 //
2479 // all locks enabled, wrong IMSI, extended format
2480 //
2481 0x55, 0x01, // locks
2482 0x00, // unblock counter
2483 0x0F, // maximum attempt
2484 0x21, 0x43, 0x65, 0x87, // P control key
2485 0xFF, 0xFF, 0xFF, 0xFF,
2486 0x21, 0x43, 0x65, 0x87, // N control key
2487 0xFF, 0xFF, 0xFF, 0xFF,
2488 0x21, 0x43, 0x65, 0x87, // NS control key
2489 0xFF, 0xFF, 0xFF, 0xFF,
2490 0x21, 0x43, 0x65, 0x87, // SP control key
2491 0xFF, 0xFF, 0xFF, 0xFF,
2492 0x21, 0x43, 0x65, 0x87, // C control key
2493 0xFF, 0xFF, 0xFF, 0xFF,
2494 0x0F, // length of IMSI P-Lock
2495 0x22, 0x00, 0x22, 0x01, // IMSI range definition P-Lock
2496 0x23, 0x15, 0x22, 0x35,
2497 0x24, 0x25, 0x11, 0x22,
2498 0x46, 0x55, 0x66,
2499 0x0F, // length of IMSI SP-Lock
2500 0x22, 0x00, 0x22, 0x01, // IMSI range definition SP-Lock
2501 0x23, 0x15, 0x22, 0x35,
2502 0x24, 0x25, 0x11, 0x22,
2503 0x46, 0x55, 0x66,
2504 0x0F, // length of IMSI NS-Lock
2505 0x22, 0x00, 0x22, 0x01, // IMSI range definition NS-Lock
2506 0x23, 0x15, 0x22, 0x35,
2507 0x24, 0x25, 0x11, 0x22,
2508 0x46, 0x55, 0x66,
2509 0x0F, // length of IMSI C-Lock
2510 0x22, 0x00, 0x22, 0x01, // IMSI range definition C-Lock
2511 0x23, 0x15, 0x22, 0x35,
2512 0x24, 0x25, 0x11, 0x22,
2513 0x46, 0x55, 0x66,
2514 0x0F, // length of IMSI N-Lock
2515 0x22, 0x00, 0x22, 0x01, // IMSI range definition N-Lock
2516 0x23, 0x15, 0x22, 0x35,
2517 0x24, 0x25, 0x11, 0x22,
2518 0x46, 0x55, 0x66,
2519 0x0F, // length of IMSI U-Lock
2520 0x22, 0x00, 0x22, 0x01, // IMSI range definition U-Lock
2521 0x23, 0x15, 0x22, 0x35,
2522 0x24, 0x25, 0x11, 0x22,
2523 0x46, 0x55, 0x66,
2524 0x00, 0x00 // Group Identifier
2525 };
2526
2527 static const UBYTE sim_lock_table_4 [] =
2528 {
2529 //
2530 // all locks enabled, IMSI ok, extended format
2531 //
2532 0x55, 0x01, // locks
2533 0x00, // unblock counter
2534 0x0F, // maximum attempt
2535 0x21, 0x43, 0x65, 0x87, // P control key
2536 0xFF, 0xFF, 0xFF, 0xFF,
2537 0x21, 0x43, 0x65, 0x87, // N control key
2538 0xFF, 0xFF, 0xFF, 0xFF,
2539 0x21, 0x43, 0x65, 0x87, // NS control key
2540 0xFF, 0xFF, 0xFF, 0xFF,
2541 0x21, 0x43, 0x65, 0x87, // SP control key
2542 0xFF, 0xFF, 0xFF, 0xFF,
2543 0x21, 0x43, 0x65, 0x87, // C control key
2544 0xFF, 0xFF, 0xFF, 0xFF,
2545 0x0D, // length of IMSI P-Lock
2546 0x22, 0x66, 0x22, 0x00, // IMSI range definition P-Lock
2547 0x11, 0x44, 0x77, 0x09,
2548 0x09, 0x09, 0x09, 0x09,
2549 0x09, 0x09, 0x09,
2550 0x0D, // length of IMSI SP-Lock
2551 0x22, 0x66, 0x22, 0x00, // IMSI range definition SP-Lock
2552 0x11, 0x44, 0x77, 0x09,
2553 0x09, 0x09, 0x09, 0x09,
2554 0x09, 0x09, 0x09,
2555 0x0D, // length of IMSI NS-Lock
2556 0x22, 0x66, 0x22, 0x00, // IMSI range definition NS-Lock
2557 0x11, 0x44, 0x77, 0x09,
2558 0x09, 0x09, 0x09, 0x09,
2559 0x09, 0x09, 0x09,
2560 0x0D, // length of IMSI C-Lock
2561 0x22, 0x66, 0x22, 0x00, // IMSI range definition C-Lock
2562 0x11, 0x44, 0x77, 0x09,
2563 0x09, 0x09, 0x09, 0x09,
2564 0x09, 0x09, 0x09,
2565 0x0D, // length of IMSI N-Lock
2566 0x22, 0x66, 0x22, 0x00, // IMSI range definition N-Lock
2567 0x11, 0x44, 0x77, 0x09,
2568 0x09, 0x09, 0x09, 0x09,
2569 0x09, 0x09, 0x09,
2570 0x0D, // length of IMSI U-Lock
2571 0x22, 0x66, 0x22, 0x00, // IMSI range definition U-Lock
2572 0x11, 0x44, 0x77, 0x09,
2573 0x09, 0x09, 0x09, 0x09,
2574 0x09, 0x09, 0x09,
2575 0x00, 0x00 // Group Identifier
2576 };
2577
2578 static const UBYTE sim_lock_table_5 [] =
2579 {
2580 //
2581 // one lock enabled, wrong IMSI ok
2582 //
2583 0x01, 0x00, // locks
2584 0x00, // unblock counter
2585 0x0F, // maximum attempt
2586 0x21, 0x43, 0x65, 0x87, // P control key
2587 0xFF, 0xFF, 0xFF, 0xFF,
2588 0x21, 0x43, 0x65, 0x87, // N control key
2589 0xFF, 0xFF, 0xFF, 0xFF,
2590 0x21, 0x43, 0x65, 0x87, // NS control key
2591 0xFF, 0xFF, 0xFF, 0xFF,
2592 0x21, 0x43, 0x65, 0x87, // SP control key
2593 0xFF, 0xFF, 0xFF, 0xFF,
2594 0x21, 0x43, 0x65, 0x87, // C control key
2595 0xFF, 0xFF, 0xFF, 0xFF,
2596 0x0D, // length of IMSI
2597 0x22, 0x00, 0x22, 0x00, // IMSI range definition
2598 0x11, 0x44, 0x77, 0x09,
2599 0x09, 0x09, 0x09, 0x09,
2600 0x09, 0x09, 0x09,
2601 0x00, 0x00 // Group Identifier
2602 };
2603
2604 #endif
2605
2606 static UBYTE sim_get_sim_lock (EF_SIMLCKEXT * simlck)
2607 {
2608 UBYTE version;
2609 UBYTE sim_lock_type = 0;
2610
2611 TRACE_FUNCTION("sim_get_sim_lock()");
2612
2613 #if defined (WIN32)
2614 version = 0;
2615
2616 switch (sim_lock_mode)
2617 {
2618 case 1:
2619 memcpy (simlck, sim_lock_table_1, SIZE_EF_SIMLCK);
2620 sim_lock_field = 1;
2621 sim_fill_sim_lock (simlck);
2622 break;
2623 case 2:
2624 memcpy (simlck, sim_lock_table_2, SIZE_EF_SIMLCK);
2625 sim_lock_field = 1;
2626 sim_fill_sim_lock (simlck);
2627 break;
2628 case 3:
2629 memcpy (simlck, sim_lock_table_3, SIZE_EF_SIMLCKEXT);
2630 sim_lock_field = 2;
2631 break;
2632 case 4:
2633 memcpy (simlck, sim_lock_table_4, SIZE_EF_SIMLCKEXT);
2634 sim_lock_field = 2;
2635 break;
2636 case 5:
2637 memcpy (simlck, sim_lock_table_5, SIZE_EF_SIMLCKEXT);
2638 sim_lock_field = 1;
2639 break;
2640 default:
2641 memset (simlck, 0, SIZE_EF_SIMLCKEXT);
2642 sim_lock_field = 2;
2643 break;
2644 }
2645 return PCM_OK;
2646 #else
2647
2648 if (sim_lock_field EQ NOT_PRESENT_8BIT)
2649 {
2650 if (pcm_ReadFile((UBYTE *) EF_SIMLCK_ID,
2651 SIZE_EF_SIMLCK,
2652 (UBYTE *) simlck,
2653 &version) EQ PCM_OK)
2654 {
2655 sim_lock_field = 1;
2656 sim_fill_sim_lock (simlck);
2657 return PCM_OK;
2658 }
2659 if (pcm_ReadFile((UBYTE *) EF_SIMLCKEXT_ID,
2660 SIZE_EF_SIMLCKEXT,
2661 (UBYTE *) simlck,
2662 &version) EQ PCM_OK)
2663 {
2664 sim_lock_field = 2;
2665 return PCM_OK;
2666 }
2667 return PCM_NVRAM_ACCS_FAIL;
2668 }
2669
2670 if (sim_lock_field EQ 1)
2671 {
2672 if (pcm_ReadFile((UBYTE *) EF_SIMLCK_ID,
2673 SIZE_EF_SIMLCK,
2674 (UBYTE *) simlck,
2675 &version) EQ PCM_OK)
2676 {
2677 sim_fill_sim_lock (simlck);
2678 return PCM_OK;
2679 }
2680 }
2681
2682 if (sim_lock_field EQ 2)
2683 {
2684 if (pcm_ReadFile((UBYTE *) EF_SIMLCKEXT_ID,
2685 SIZE_EF_SIMLCKEXT,
2686 (UBYTE *) simlck,
2687 &version) EQ PCM_OK)
2688 {
2689 return PCM_OK;
2690 }
2691 }
2692 return PCM_NVRAM_ACCS_FAIL;
2693 #endif
2694 }
2695
2696 /*
2697 +--------------------------------------------------------------------+
2698 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2699 | STATE : code ROUTINE : sim_get_sim_lock |
2700 +--------------------------------------------------------------------+
2701
2702 PURPOSE : Reads the SIM LOCK Record content from PCM
2703
2704 */
2705
2706 static void sim_set_sim_lock (EF_SIMLCKEXT * simlck)
2707 {
2708 TRACE_FUNCTION("sim_set_sim_lock()");
2709
2710 if (sim_lock_field EQ 1)
2711 {
2712 /*
2713 * set GDL1 and 2 on the expected location
2714 * => len_sp_imsi = gdl1, sp_imsi[0] = gdl2
2715 */
2716 simlck->len_sp_imsi = simlck->gidl1;
2717 simlck->sp_imsi [0] = simlck->gidl2;
2718 pcm_WriteFile((UBYTE *) EF_SIMLCK_ID,SIZE_EF_SIMLCK,
2719 (UBYTE *) simlck);
2720 }
2721 else
2722 pcm_WriteFile((UBYTE *) EF_SIMLCKEXT_ID,SIZE_EF_SIMLCKEXT,
2723 (UBYTE *) simlck);
2724 }
2725
2726
2727 /*
2728 +--------------------------------------------------------------------+
2729 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2730 | STATE : code ROUTINE : sim_fill_sim_lock |
2731 +--------------------------------------------------------------------+
2732
2733 PURPOSE : Fills the extended SIM Lock record with defaults if
2734 only the simple SIM Lock Record is available.
2735
2736 */
2737
2738 static void sim_fill_sim_lock (EF_SIMLCKEXT * simlck)
2739 {
2740 TRACE_FUNCTION("sim_fill_sim_lock()");
2741
2742 if (sim_lock_field EQ 1)
2743 {
2744 /*
2745 * PCM contains SIMLOCK record. Must be mapped to the internal
2746 * used SIMLOCKEXT record.
2747 *
2748 * gidl1, gidl2 to the end of record:
2749 */
2750 simlck->gidl1 = simlck->len_sp_imsi;
2751 simlck->gidl2 = simlck->sp_imsi [0];
2752 /*
2753 * IMSI must be copied for the other locks
2754 * N-Lock digits 1..5, rest filled with 0x09 to suppress compare
2755 * SP-Lock digits 1..5, rest filled with 0x09 to suppress compare
2756 * NS-Lock digits 1..7, rest filled with 0x09 to suppress compare
2757 * C-Lock digits 1..5, rest filled with 0x09 to suppress compare
2758 */
2759 memset (simlck->n_imsi, 0x09, 15);
2760 memcpy (simlck->n_imsi, simlck->p_imsi, 5);
2761 simlck->len_n_imsi = 5;
2762 memset (simlck->sp_imsi, 0x09, 15);
2763 memcpy (simlck->sp_imsi, simlck->p_imsi, 5);
2764 simlck->len_ns_imsi = 5;
2765 memset (simlck->ns_imsi, 0x09, 15);
2766 memcpy (simlck->ns_imsi, simlck->p_imsi, 7);
2767 simlck->len_ns_imsi = 7;
2768 memset (simlck->c_imsi, 0x09, 15);
2769 memcpy (simlck->c_imsi, simlck->p_imsi, 5);
2770 simlck->len_c_imsi = 5;
2771 /*
2772 * initialise unblock imsi so that it never will fit
2773 */
2774 simlck->len_u_imsi = 0;
2775 }
2776 }
2777
2778 /*
2779 +--------------------------------------------------------------------+
2780 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2781 | STATE : code ROUTINE : sim_check_unblock_sim |
2782 +--------------------------------------------------------------------+
2783
2784 PURPOSE : Checks the IMSI against a stored unblock SIM. If the
2785 check is positive, the unlock attempt counter will
2786 be resetted.
2787
2788 */
2789
2790 static void sim_check_unblock_sim (EF_SIMLCKEXT * simlck)
2791 {
2792 UBYTE i;
2793
2794 TRACE_FUNCTION("sim_check_unblock_sim()");
2795
2796 if (sim_get_sim_lock (simlck) EQ PCM_OK)
2797 {
2798 if (simlck->len_u_imsi EQ 0)
2799 return;
2800
2801 /*
2802 * check all digits */
2803 for (i=0; i<simlck->len_u_imsi; i++)
2804 {
2805 if (sim_check_imsi_digit(simlck->u_imsi[i], mfw_IMSI[i]) EQ FALSE)
2806 break;
2807 }
2808
2809 /*
2810 * all digits okay, then reset counter and nothing else
2811 */
2812 if (i EQ simlck->len_u_imsi)
2813 {
2814 simlck->cnt = 0;
2815 sim_set_sim_lock (simlck);
2816 }
2817 }
2818 }
2819
2820 /*
2821 +--------------------------------------------------------------------+
2822 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2823 | STATE : code ROUTINE : sim_simlock_ok |
2824 +--------------------------------------------------------------------+
2825
2826 PURPOSE : The function checks whether the SIM LOCK is active or not.
2827
2828 */
2829
2830 UBYTE sim_simlock_ok (void)
2831 {
2832 if (sim_nslock EQ SIMLOCK_BLOCKED OR
2833 sim_nslock EQ SIMLOCK_LOCKED)
2834 return FALSE;
2835
2836 if (sim_plock EQ SIMLOCK_BLOCKED OR
2837 sim_plock EQ SIMLOCK_LOCKED)
2838 return FALSE;
2839
2840 if (sim_splock EQ SIMLOCK_BLOCKED OR
2841 sim_splock EQ SIMLOCK_LOCKED)
2842 return FALSE;
2843
2844 if (sim_nlock EQ SIMLOCK_BLOCKED OR
2845 sim_nlock EQ SIMLOCK_LOCKED)
2846 return FALSE;
2847
2848 if (sim_clock EQ SIMLOCK_BLOCKED OR
2849 sim_clock EQ SIMLOCK_LOCKED)
2850 return FALSE;
2851
2852 return TRUE;
2853 }
2854
2855 /*
2856 +--------------------------------------------------------------------+
2857 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2858 | STATE : code ROUTINE : sim_get_imsi |
2859 +--------------------------------------------------------------------+
2860
2861 PURPOSE : Request IMSI number in SIM card
2862
2863 */
2864
2865 UBYTE * sim_get_imsi (void)
2866 {
2867 return mfw_IMSI;
2868 }
2869
2870 /*
2871 +---------------------------------------------------------------------+
2872 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2873 | STATE : code ROUTINE : sim_mmi_update_parameter |
2874 +---------------------------------------------------------------------+
2875
2876 PURPOSE : MMI relevant parameters from the SIM card
2877
2878 */
2879
2880 void sim_mmi_update_parameter(T_SIM_ACTIVATE_IND *sim_act_ind)
2881 {
2882 TRACE_FUNCTION("sim_mmi_update_parameter()");
2883
2884 memcpy( sim_config.pref_lang, sim_act_ind->pref_lang, 5);
2885 }
2886
2887 #ifdef SIM_TOOLKIT
2888 /*
2889 +---------------------------------------------------------------------+
2890 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2891 | STATE : code ROUTINE : sim_sat_file_update |
2892 +---------------------------------------------------------------------+
2893
2894 PURPOSE : SIM file change indication
2895
2896 */
2897
2898 void sim_sat_file_update(USHORT dataId)
2899 {
2900 TRACE_FUNCTION("sim_sat_file_update()");
2901
2902 sat_update = TRUE;
2903 switch (dataId)
2904 {
2905 case SIM_SST:
2906 sim_read_sim(SIM_SST, NOT_PRESENT_8BIT, 10);
2907 break;
2908 case SIM_GID1:
2909 sim_read_sim(SIM_GID1, NOT_PRESENT_8BIT, 5);
2910 break;
2911 case SIM_GID2:
2912 sim_read_sim(SIM_GID2, NOT_PRESENT_8BIT, 5);
2913 break;
2914 default:
2915 break;
2916 }
2917 }
2918 #endif
2919
2920 /*
2921 +---------------------------------------------------------------------+
2922 | PROJECT : MMI-Framework (8417) MODULE : MFW_SIM |
2923 | STATE : code ROUTINE : sim_read_sst_cnf |
2924 +---------------------------------------------------------------------+
2925
2926 PURPOSE : SIM file change indication
2927
2928 */
2929
2930 void sim_read_sst_cnf (SHORT error, UBYTE *data)
2931 {
2932 TRACE_FUNCTION("sim_read_sst_cnf()");
2933
2934 if (error EQ SIM_NO_ERROR)
2935 memcpy(sim_service_table, data, sizeof(sim_service_table));
2936 else
2937 TRACE_EVENT("SST read error");
2938
2939 #ifdef SIM_TOOLKIT
2940 if (sat_update)
2941 {
2942 sat_update = FALSE;
2943 satUpdateFiles ( TRUE, SIM_SST );
2944 }
2945 #endif
2946 }