FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/cmh_sss.c @ 0:75a11d740a02

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-PS (6147)
4 | Modul : CMH_SSS
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This module provides the set functions related to the
18 | protocol stack adapter for SS.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef CMH_SSS_C
23 #define CMH_SSS_C
24 #endif
25
26 #include "config.h"
27 #include "fixedconf.h"
28 #include "condat-features.h"
29 #include "aci_conf.h"
30
31 #include "aci_all.h"
32 /*==== INCLUDES ===================================================*/
33 #include "aci.h"
34 #include "aci_cmh.h"
35
36 #ifdef FAX_AND_DATA
37 #include "aci_fd.h"
38 #endif /* of #ifdef FAX_AND_DATA */
39
40 #ifdef UART
41 #include "dti.h"
42 #include "dti_conn_mng.h"
43 #endif
44
45 #include "ksd.h"
46 #include "psa.h"
47 #include "psa_ss.h"
48 #include "psa_sim.h"
49 #include "psa_sms.h"
50 #include "psa_cc.h"
51 #include "cmh.h"
52 #include "cmh_ss.h"
53 #include "cmh_sim.h"
54 #include "cmh_sms.h"
55 #include "cmh_cc.h"
56
57 #ifdef SIM_TOOLKIT
58 #include "psa_cc.h"
59 #include "psa_sat.h"
60 #include "cmh_sat.h"
61 #include "ati_cmd.h"
62 #include "aci_cmd.h"
63 #include "cmh_cc.h"
64 #endif /* of SIM_TOOLKIT */
65
66 #include "psa_util.h"
67 #ifdef GPRS
68 #include "gaci_cmh.h"
69 #endif /* GPRS */
70 #include "phb.h"
71
72
73 #include "aci_ext_pers.h"
74 #include "aci_slock.h"
75
76 #ifdef SIM_PERS
77 #include "general.h" // inluded for UINT8 compilation error in sec_drv.h
78 #include "sec_drv.h"
79
80 EXTERN T_SEC_DRV_CONFIGURATION *cfg_data;
81 EXTERN T_SIM_MMI_INSERT_IND *last_sim_mmi_insert_ind;
82 #endif
83
84 #ifdef FF_PHONE_LOCK
85 EXTERN T_OPER_RET_STATUS aci_ext_set_phone_lock_satus(T_SEC_DRV_EXT_PHONE_LOCK_TYPE type,T_SEC_DRV_EXT_PHONE_LOCK_STATUS status,const char *passwd);
86 EXTERN T_OPER_RET_STATUS aci_ext_set_phone_lock_key(const char *pOldKey,const char *pNewKey);
87 #endif
88
89 #if defined (SIM_PERS) || defined (FF_PHONE_LOCK)
90 EXTERN T_ACI_RETURN cmhSS_check_oper_result(T_OPER_RET_STATUS result);
91 #endif
92
93 /*==== CONSTANTS ==================================================*/
94 #define AT_TOA_DEF_INT (129) /* toa default for international no.*/
95 #define AT_TOA_DEF_NAT (145) /* toa default for national no.*/
96 #define AT_TOS_DEF (128) /* tos default */
97 #define AT_CFNRY_DEF_TIME (20) /* default no reply time */
98
99
100
101
102 /*==== EXPORT =====================================================*/
103
104 /*==== VARIABLES ==================================================*/
105 #ifdef TI_PS_FF_AT_P_CMD_CUSCFG
106 EXTERN T_ACI_CUSCFG_PARAMS cuscfgParams;
107 #endif
108 GLOBAL SHORT Ext_USSD_Res_Pending_sId;
109 GLOBAL T_CUSDR_EXT_USSD_RES Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
110
111 /*==== FUNCTIONS ==================================================*/
112
113 /*
114 +--------------------------------------------------------------------+
115 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
116 | STATE : code ROUTINE : sAT_PlusCCFC |
117 +--------------------------------------------------------------------+
118
119 PURPOSE : This is the functional counterpart to the +CCFC AT command
120 which is responsible to set the parameters for call
121 forwarding supplementary services.
122
123 <reason> : reason for CF.
124 <mode> : CF mode.
125 <number> : number to be forwarded to.
126 <type> : type of number.
127 <class> : class of calls.
128 <subaddr>: subaddress of number.
129 <satype> : type of subaddress.
130 <time> : no reply time.
131 */
132
133 GLOBAL T_ACI_RETURN sAT_PlusCCFC ( T_ACI_CMD_SRC srcId,
134 T_ACI_CCFC_RSN reason,
135 T_ACI_CCFC_MOD mode,
136 CHAR* number,
137 T_ACI_TOA* type,
138 T_ACI_CLASS class_type,
139 CHAR* subaddr,
140 T_ACI_TOS* satype,
141 SHORT time)
142 {
143 SHORT sId1, sId2; /* holds service id */
144 UBYTE ssCd; /* holds ss code */
145 UBYTE bst1, bst2; /* holds basic service type */
146 UBYTE bs1, bs2; /* holds basic service */
147 UBYTE ton, tos; /* holds type of number/subaddress */
148 UBYTE npi, oe; /* holds numbering plan/odd.even indicator */
149 BOOL mltyTrnFlg = FALSE; /* flags for multi transaction */
150 T_CLPTY_PRM *ccfc_cldPty;
151
152 #ifdef SIM_TOOLKIT
153 T_ACI_RETURN retVal;
154 #endif /* of SIM_TOOLKIT */
155
156 TRACE_FUNCTION ("sAT_PlusCCFC");
157
158 /*
159 *-------------------------------------------------------------------
160 * check command source
161 *-------------------------------------------------------------------
162 */
163 if(!cmh_IsVldCmdSrc (srcId))
164 {
165 return( AT_FAIL );
166 }
167
168 if( cmhPrm[srcId].ssCmdPrm.mltyTrnFlg NEQ 0 )
169 {
170 TRACE_EVENT("ssCmdPrm.mltyTrnFlg NEQ 0 !!! CCFC busy");
171 return( AT_BUSY );
172 }
173
174 /*
175 *-------------------------------------------------------------------
176 * check parameter <time>
177 *-------------------------------------------------------------------
178 */
179 if( time EQ ACI_NumParmNotPresent )
180 {
181 time = AT_CFNRY_DEF_TIME;
182 }
183 else if (time < CCFC_TIME_MIN AND time >= 1)
184 {
185 /* 07.07 allows [1...30] for time while
186 09.02 allows [5...30]. So map [1..4] to 5 */
187 time = CCFC_TIME_MIN;
188 }
189 else if( time > CCFC_TIME_MAX OR time < CCFC_TIME_MIN )
190 {
191 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
192 return( AT_FAIL );
193 }
194
195 /* Implements Measure # 85 */
196 if(!cmhSS_checkCCFC_RSN(reason, &ssCd))
197 {
198 return( AT_FAIL );
199 }
200 /*
201 *-------------------------------------------------------------------
202 * check parameter <class>
203 *-------------------------------------------------------------------
204 */
205 if( !cmhSS_CheckClass( class_type, &bs1, &bst1, &bs2, &bst2, &mltyTrnFlg ))
206 {
207 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
208 return( AT_FAIL );
209 }
210
211 /* SIM TOOLKIT & FDN HANDLING */
212
213 retVal = cmhSS_CF_SAT_Handle( srcId, reason, mode, number, type, class_type, subaddr, satype, time);
214
215 if( retVal NEQ AT_CMPL )
216 return( retVal );
217
218 /*
219 *-------------------------------------------------------------------
220 * check parameter <class> against possible ALS-Lock
221 *-------------------------------------------------------------------
222 */
223 if ((ALSlock EQ ALS_MOD_SPEECH AND class_type EQ CLASS_AuxVce) OR
224 (ALSlock EQ ALS_MOD_AUX_SPEECH AND class_type NEQ CLASS_AuxVce))
225 {
226 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_AlsLock );
227 return( AT_FAIL );
228 }
229
230 /*
231 *-------------------------------------------------------------------
232 * get a new service table entry
233 *-------------------------------------------------------------------
234 */
235 sId1 = psaSS_stbNewEntry();
236
237 if( sId1 EQ NO_ENTRY )
238 {
239 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
240 return( AT_FAIL );
241 }
242
243 sId2 = NO_ENTRY;
244
245 if( mltyTrnFlg )
246 {
247 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
248
249 sId2 = psaSS_stbNewEntry();
250
251 if( sId2 EQ NO_ENTRY )
252 {
253 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
254 return( AT_FAIL );
255 }
256 }
257
258 /*
259 *-------------------------------------------------------------------
260 * check parameter <mode>
261 *-------------------------------------------------------------------
262 */
263 switch( mode )
264 {
265 /*
266 *---------------------------------------------------------------
267 * enable, disable and erase call forwarding service
268 *---------------------------------------------------------------
269 */
270 case( CCFC_MOD_Disable ):
271 case( CCFC_MOD_Enable ):
272 case( CCFC_MOD_Erasure ):
273
274 CCD_START;
275
276 if( mode EQ CCFC_MOD_Disable )
277 psaSS_asmDeactivateSS( ssCd, bst1, bs1 );
278
279 else if( mode EQ CCFC_MOD_Enable )
280 psaSS_asmActivateSS( ssCd, bst1, bs1 );
281
282 else if( mode EQ CCFC_MOD_Erasure )
283 psaSS_asmEraseSS( ssCd, bst1, bs1 );
284
285 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
286 ssShrdPrm.stb[sId1].ssCode = ssCd;
287 ssShrdPrm.stb[sId1].srvOwn = (T_OWN)srcId;
288 ssShrdPrm.stb[sId1].ClassType = class_type; /* the complete classes defined by the user */
289
290 /* start first transaction */
291 ssShrdPrm.stb[sId1].curCmd = AT_CMD_CCFC;
292
293 cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
294 psaSS_NewTrns(sId1);
295
296 if( mltyTrnFlg )
297 {
298 if( mode EQ CCFC_MOD_Disable )
299 psaSS_asmDeactivateSS( ssCd, bst2, bs2 );
300
301 else if( mode EQ CCFC_MOD_Enable )
302 psaSS_asmActivateSS( ssCd, bst2, bs2 );
303
304 else if( mode EQ CCFC_MOD_Erasure )
305 psaSS_asmEraseSS( ssCd, bst2, bs2 );
306
307 ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
308 ssShrdPrm.stb[sId2].ssCode = ssCd;
309 ssShrdPrm.stb[sId2].srvOwn = (T_OWN)srcId;
310 ssShrdPrm.stb[sId2].ClassType =class_type; /* the complete classes defined by the user */
311
312 /* start second transaction */
313 ssShrdPrm.stb[sId2].curCmd = AT_CMD_CCFC;
314
315 cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
316 cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
317
318 psaSS_NewTrns(sId2);
319 }
320
321 CCD_END;
322 break;
323
324 /*
325 *---------------------------------------------------------------
326 * register call forwarding service
327 *---------------------------------------------------------------
328 */
329 case( CCFC_MOD_Register ):
330
331 if(number EQ NULL)
332 {
333 TRACE_EVENT("ERROR: cannot register CCFC without a number");
334 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
335 return( AT_FAIL );
336 }
337 MALLOC(ccfc_cldPty, sizeof(T_CLPTY_PRM));
338 cmhCC_init_cldPty( ccfc_cldPty );
339
340 cmh_bldCalPrms( number, ccfc_cldPty );
341
342 /* check for TOA default */
343 if(type EQ NULL)
344 {
345 ton = ccfc_cldPty->ton;
346 npi = ccfc_cldPty->npi;
347 }
348 else if(type->ton EQ TON_NotPresent OR
349 type->npi EQ NPI_NotPresent)
350 {
351 ton = ccfc_cldPty->ton;
352 npi = ccfc_cldPty->npi;
353 }
354 else
355 {
356 ton = type->ton;
357 npi = type->npi;
358 }
359
360 /* check for TOS default */
361 if(satype EQ NULL)
362 {
363 tos = TOS_X213;
364 oe = OEI_EVEN;
365 }
366 else if(satype->tos EQ TOS_NotPresent OR
367 satype->oe EQ OE_NotPresent)
368 {
369 tos = TOS_X213;
370 oe = OEI_EVEN;
371 }
372 else
373 {
374 tos = satype -> tos;
375 oe = satype -> oe;
376 }
377
378 if(subaddr EQ NULL AND
379 ccfc_cldPty->sub[0] NEQ 0) /* if not set by user AND number contained a subaddress */
380 {
381 subaddr = (CHAR *)ccfc_cldPty->sub;
382 }
383
384 CCD_START;
385
386 psaSS_asmRegisterSS( ssCd, bst1, bs1,
387 ton, npi, (UBYTE*)ccfc_cldPty->num, tos, oe, (UBYTE *)subaddr, (UBYTE)time );
388
389 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
390 ssShrdPrm.stb[sId1].ssCode = ssCd;
391 ssShrdPrm.stb[sId1].srvOwn = (T_OWN)srcId;
392
393 /* start first transaction */
394 ssShrdPrm.stb[sId1].curCmd = AT_CMD_CCFC;
395 cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
396 psaSS_NewTrns(sId1);
397
398 if( mltyTrnFlg )
399 {
400 psaSS_asmRegisterSS( ssCd, bst2, bs2,
401 ton, npi, (UBYTE*)ccfc_cldPty->num, tos, oe, (UBYTE *)subaddr, (UBYTE)time );
402
403 ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
404 ssShrdPrm.stb[sId2].ssCode = ssCd;
405 ssShrdPrm.stb[sId2].srvOwn = (T_OWN)srcId;
406
407 /* start second transaction */
408 ssShrdPrm.stb[sId2].curCmd = AT_CMD_CCFC;
409 cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
410 cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
411 psaSS_NewTrns(sId2);
412 }
413 MFREE(ccfc_cldPty);
414 CCD_END;
415 break;
416
417 /*
418 *---------------------------------------------------------------
419 * unexpected mode
420 *---------------------------------------------------------------
421 */
422 case( CCFC_MOD_NotPresent ):
423 default:
424
425 ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
426 if( sId2 NEQ NO_ENTRY ) ssShrdPrm.stb[sId2].ntryUsdFlg = FALSE;
427
428 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
429 return( AT_FAIL );
430 }
431
432 /*
433 *-------------------------------------------------------------------
434 * log command execution
435 *-------------------------------------------------------------------
436 */
437 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
438 {
439 T_ACI_CLOG cmdLog; /* holds logging info */
440
441 cmdLog.atCmd = AT_CMD_CCFC;
442 cmdLog.cmdType = CLOG_TYPE_Set;
443 cmdLog.retCode = AT_EXCT;
444 cmdLog.cId = ACI_NumParmNotPresent;
445 cmdLog.sId = sId1+1;
446 cmdLog.cmdPrm.sCCFC.srcId = srcId;
447 cmdLog.cmdPrm.sCCFC.reason = reason;
448 cmdLog.cmdPrm.sCCFC.mode = mode;
449 cmdLog.cmdPrm.sCCFC.number = number;
450 cmdLog.cmdPrm.sCCFC.type = type;
451 cmdLog.cmdPrm.sCCFC.class_type = class_type;
452 cmdLog.cmdPrm.sCCFC.subaddr = subaddr;
453 cmdLog.cmdPrm.sCCFC.satype = satype;
454 cmdLog.cmdPrm.sCCFC.time = time;
455
456 rAT_PercentCLOG( &cmdLog );
457 }
458 #endif
459
460 return( AT_EXCT );
461 }
462
463 /*
464 +--------------------------------------------------------------------+
465 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
466 | STATE : code ROUTINE : sAT_PlusCLCK |
467 +--------------------------------------------------------------------+
468
469 PURPOSE : This is the functional counterpart to the +CLCK AT command
470 which is responsible to set the parameters for call
471 barring supplementary services.
472
473 <fac> : CB facility.
474 <mode> : CB mode.
475 <passwd> : password for CB facility.
476 <class_type>: class of calls.
477 */
478 LOCAL BOOL check_sat_cb_pwd_required(UBYTE ssCd, CHAR *passwd)
479 {
480 #ifdef SIM_TOOLKIT
481 SHORT ss_id = NO_ENTRY;
482 T_OWN owner;
483
484 /* Special case: there was an SS (by STK) transaction running.
485 It returned get password, handle the password for this transaction */
486
487 TRACE_FUNCTION ("check_sat_ss_pwd_required ()");
488
489 /* satShrdPrm.sId_pwd_requested will be reset by any mnss_end_ind
490 to be sure it has been reset.
491 This means: user has to give password right after error has been
492 shown. */
493 ss_id = satShrdPrm.sId_pwd_requested;
494 if( ss_id EQ NO_ENTRY)
495 {
496 return(FALSE);
497 }
498
499 if( ssShrdPrm.stb[ss_id].srvOwn NEQ OWN_SRC_SAT )
500 {
501 satShrdPrm.sId_pwd_requested = NO_ENTRY;
502 return(FALSE);
503 }
504 TRACE_EVENT("Password required during a SAT session");
505
506 if( ssShrdPrm.stb[ss_id].curCmd NEQ ((T_ACI_AT_CMD)KSD_CMD_CB) )
507 {
508 TRACE_EVENT_P1("Wrong command context: %d", ssShrdPrm.stb[ss_id].curCmd);
509 satShrdPrm.sId_pwd_requested = NO_ENTRY;
510 return(FALSE);
511 }
512 owner = ssShrdPrm.stb[ss_id].srvOwn;
513
514 if(ssShrdPrm.stb[ss_id].ssCode EQ ssCd)
515 {
516 /* store for later use (as usual)*/
517 strncpy
518 (
519 (char *) cmhPrm[owner].ssCmdPrm.CXXXpwd,
520 (char *) passwd,
521 MAX_PWD_NUM
522 );
523 cmhPrm[owner].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
524 psaSS_asmVerifyPWD( cmhPrm[owner].ssCmdPrm.CXXXpwd);
525 psaSS_CntTrns(ss_id);
526 satShrdPrm.sId_pwd_requested = NO_ENTRY;
527 return(TRUE); /* as pwd only needed for SAT session*/
528 }
529 else
530 {
531 TRACE_EVENT_P1("Wrong Service type: %d", ssCd);
532 }
533 satShrdPrm.sId_pwd_requested = NO_ENTRY;
534 #endif /* SIM_TOOLKIT */
535 return(FALSE);
536 }
537
538 /*
539 +------------------------------------------------------------------------------
540 | Function : sAT_PlusCLCK
541 +------------------------------------------------------------------------------
542 | Description : This is the functional counterpart to the +CLCK AT command
543 | which is responsible to set the parameters for call
544 | barring supplementary services. also fo locking and unlocking ME for categories
545 | Networl lock, Network Subset lock, Service Provider Lock, Corporate Lock, SIM Lock
546 |
547 | Parameters : <fac> : CB facility.
548 | <mode> : CB mode.
549 | <passwd> : password for CB facility.
550 | <class_type>: class of calls.
551 |
552 | Return : AT_FAIL - execution of command failed
553 | AT_CMPL - execution of command completed
554 | AT_EXCT - execution of command is in progress
555 | AT_BUSY - execution of command is rejected due
556 |
557 +------------------------------------------------------------------------------
558 */
559
560 GLOBAL T_ACI_RETURN sAT_PlusCLCK ( T_ACI_CMD_SRC srcId,
561 T_ACI_FAC fac,
562 T_ACI_CLCK_MOD mode,
563 CHAR * passwd,
564 T_ACI_CLASS class_type)
565 {
566 SHORT sId1, sId2; /* holds service id */
567 UBYTE ssCd; /* holds ss code */
568 UBYTE bst1, bst2; /* holds basic service type */
569 UBYTE bs1, bs2; /* holds basic service */
570 BOOL mltyTrnFlg = FALSE; /* flags for multi transaction */
571 #ifdef SIM_PERS
572 T_SIMLOCK_TYPE slocktype;
573 T_SIMLOCK_STATUS rlockstatus;
574 #endif
575 SHORT psasim_ret;
576 BOOL done = FALSE;
577 #ifdef SIM_PERS
578 T_ACI_CME_ERR err_code = CME_ERR_NotPresent; /* code holding the correct error code calculated */
579 UBYTE cmdBuf; /* buffers current command */
580 #endif
581 #ifdef SIM_PERS
582 T_OPER_RET_STATUS fcResetStat; /*holds Failure Counter Reset Return Status Introduced on 11/03/2005*/
583 T_OPER_RET_STATUS masterunlockStat;
584 T_SIMLOCK_STATUS retSlStatus; /* holds return code */
585 #endif
586 #ifdef FF_PHONE_LOCK
587 T_OPER_RET_STATUS phone_lock_oper_ret_stat;
588 #endif
589 T_ACI_RETURN retVal;
590
591 TRACE_FUNCTION ("sAT_PlusCLCK ()");
592
593 /*
594 *-------------------------------------------------------------------
595 * check command source
596 *-------------------------------------------------------------------
597 */
598 if(!cmh_IsVldCmdSrc (srcId))
599 {
600 return( AT_FAIL );
601 }
602
603 /*
604 *-------------------------------------------------------------------
605 * check parameter <fac>
606 *-------------------------------------------------------------------
607 */
608 /* Implements Measure # 166 */
609 #ifdef SIM_PERS
610 if((fac EQ FAC_Fc) OR ( fac EQ FAC_Fcm) OR ( fac EQ FAC_Mu) OR (fac EQ FAC_Mum))
611 {
612 ssCd = NOT_PRESENT_8BIT;
613 }
614 else
615 #endif
616 if( !cmhSS_getSSCd(fac, &ssCd) )
617 {
618 return( AT_FAIL );
619 }
620 /*
621 *-------------------------------------------------------------------
622 * if action is related to SS
623 *-------------------------------------------------------------------
624 */
625 if( ssCd NEQ NOT_PRESENT_8BIT )
626 {
627 /*
628 *-------------------------------------------------------------------
629 * check parameter <passwd>
630 *-------------------------------------------------------------------
631 */
632 if( passwd AND strlen( passwd ) > MAX_PWD_NUM )
633 {
634 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
635 return( AT_FAIL );
636 }
637
638 /*
639 *-------------------------------------------------------------------
640 * check parameter <class>
641 *-------------------------------------------------------------------
642 */
643 if( !cmhSS_CheckCbClass( class_type, &bs1, &bst1, &bs2, &bst2, &mltyTrnFlg ))
644 {
645 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
646 return( AT_FAIL );
647 }
648
649 if( cmhPrm[srcId].ssCmdPrm.mltyTrnFlg NEQ 0 )
650 return( AT_BUSY );
651
652 /*
653 *-------------------------------------------------------------------
654 * check combination of <mode> and <fac>
655 *-------------------------------------------------------------------
656 */
657 if((fac EQ FAC_Ab OR fac EQ FAC_Ag OR fac EQ FAC_Ac)
658 AND mode NEQ CLCK_MOD_Unlock )
659 {
660 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
661 return( AT_FAIL );
662 }
663
664 /*** Shangai's labs tessession fix: adapted to this version from 1.3.3 (TCS 2.0) ****/
665 /* Special case: there was an SS (by STK) transaction running.
666 It returned get password, handle the password for this transaction */
667 done = check_sat_cb_pwd_required(ssCd, passwd);
668 if(done)
669 {
670 return(AT_CMPL); /* as pwd only needed for SAT session*/
671 }
672 /* End fix */
673
674
675 /* SIM TOOLKIT & FDN HANDLING */
676 retVal = cmhSS_Call_Barr_SAT_Handle( srcId, mode, fac, passwd, class_type);
677
678 if( retVal NEQ AT_CMPL )
679 return( retVal );
680
681 /*
682 *-------------------------------------------------------------------
683 * get a new service table entry
684 *-------------------------------------------------------------------
685 */
686 sId1 = psaSS_stbNewEntry();
687
688 if( sId1 EQ NO_ENTRY )
689 {
690 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
691 return( AT_FAIL );
692 }
693
694 sId2 = NO_ENTRY;
695
696 if( mltyTrnFlg )
697 {
698 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
699 sId2 = psaSS_stbNewEntry();
700
701 if( sId2 EQ NO_ENTRY )
702 {
703 ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
704 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
705 return( AT_FAIL );
706 }
707 }
708
709 /*
710 *-------------------------------------------------------------------
711 * check parameter <mode>
712 *-------------------------------------------------------------------
713 */
714 switch( mode )
715 {
716 /*
717 *---------------------------------------------------------------
718 * lock and unlock call barring service
719 *---------------------------------------------------------------
720 */
721 case( CLCK_MOD_Unlock ):
722 case( CLCK_MOD_Lock ):
723
724 CCD_START;
725
726 if( mode EQ CLCK_MOD_Unlock )
727 psaSS_asmDeactivateSS( ssCd, bst1, bs1 );
728
729 else if( mode EQ CLCK_MOD_Lock )
730 psaSS_asmActivateSS( ssCd, bst1, bs1 );
731
732 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
733 ssShrdPrm.stb[sId1].ssCode = ssCd;
734 ssShrdPrm.stb[sId1].srvOwn = (T_OWN)srcId;
735
736 /* start first transaction */
737 ssShrdPrm.stb[sId1].curCmd = AT_CMD_CLCK;
738 cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
739 psaSS_NewTrns(sId1);
740
741 if( mltyTrnFlg )
742 {
743 if( mode EQ CLCK_MOD_Unlock )
744 psaSS_asmDeactivateSS( ssCd, bst2, bs2 );
745
746 else if( mode EQ CLCK_MOD_Lock )
747 psaSS_asmActivateSS( ssCd, bst2, bs2 );
748
749 ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
750 ssShrdPrm.stb[sId2].ssCode = ssCd;
751 ssShrdPrm.stb[sId2].srvOwn = (T_OWN)srcId;
752
753 /* start second transaction */
754 ssShrdPrm.stb[sId2].curCmd = AT_CMD_CLCK;
755 cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
756 cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
757 psaSS_NewTrns(sId2);
758 }
759 CCD_END;
760 break;
761
762 /*
763 *---------------------------------------------------------------
764 * unexpected mode
765 *---------------------------------------------------------------
766 */
767 case( CLCK_MOD_NotPresent ):
768 default:
769
770 ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
771 if( sId2 NEQ NO_ENTRY ) ssShrdPrm.stb[sId2].ntryUsdFlg = FALSE;
772
773 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
774 return( AT_FAIL );
775 }
776
777 /*
778 *-------------------------------------------------------------------
779 * store password for later use
780 *-------------------------------------------------------------------
781 */
782 if( passwd )
783 {
784 strncpy
785 (
786 (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
787 (char *) passwd,
788 MAX_PWD_NUM
789 );
790 cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
791 }
792 }
793
794 /*
795 *-------------------------------------------------------------------
796 * if action is related to SIM
797 *-------------------------------------------------------------------
798 */
799 else
800 {
801 if( simEntStat.curCmd NEQ AT_CMD_NONE )
802 return( AT_BUSY );
803
804 switch (fac)
805 {
806 /*
807 *---------------------------------------------------------------
808 * access PIN 1
809 *---------------------------------------------------------------
810 */
811 case FAC_Sc:
812 switch( mode )
813 {
814 case( CLCK_MOD_Unlock ):
815 case( CLCK_MOD_Lock ):
816 if (simShrdPrm.PINStat EQ PS_PUK1)
817 {
818 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPukReq);
819 return( AT_FAIL );
820 }
821 if (!psaSIM_ChkSIMSrvSup(SRV_CHV1_Disable))
822 {
823 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow);
824 return( AT_FAIL );
825 }
826 if( !passwd OR (strlen( passwd ) > PIN_LEN) )
827 {
828 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
829 return( AT_FAIL );
830 }
831 if( strlen( passwd ) < MIN_PIN_LEN OR
832 strlen( passwd ) > PIN_LEN )
833 {
834 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
835 return( AT_FAIL );
836 }
837 cmhSIM_FillInPIN ( passwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
838 simShrdPrm.setPrm[srcId].PINType = PHASE_2_PIN_1;
839 simEntStat.curCmd = AT_CMD_CLCK;
840 simShrdPrm.owner = (T_OWN)srcId;
841 simEntStat.entOwn = srcId;
842
843 if( mode EQ CLCK_MOD_Lock )
844 {
845 psasim_ret = psaSIM_EnablePIN( );
846 }
847 else /* if( mode EQ CLCK_MOD_Unlock ) */
848 {
849 psasim_ret = psaSIM_DisablePIN( );
850 }
851
852 if(psasim_ret < 0)
853 {
854 TRACE_EVENT( "FATAL RETURN psaSIM in +CLCK" );
855 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
856 return( AT_FAIL );
857 }
858 break;
859
860 default:
861
862 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
863 return( AT_FAIL );
864 }
865 break;
866
867 /*
868 *---------------------------------------------------------------
869 * access fixed dialling feature
870 *---------------------------------------------------------------
871 */
872 case FAC_Fd:
873 if (!psaSIM_ChkSIMSrvSup(SRV_FDN))
874 {
875 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow);
876 return( AT_FAIL );
877 }
878 /*
879 Check the SIM PIN States before sending any request to SIM
880 */
881 if ( simShrdPrm.PINStat EQ PS_PUK2 )
882 {
883 TRACE_EVENT("sAT_PlusCLCK_ME(): SIM PIN-2 Bolcked PUK-2 Required");
884 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPuk2Req );
885 return( AT_FAIL );
886 }
887
888 /*
889 According to the standards 27.007 Sec 7.4 for facility "FDN":
890 if PIN2 authentication has not been done during the current session,
891 PIN2 is required as <passwd>; Below condition will do the
892 same to check to see whether <passwd> is required / not.
893 */
894
895 if ( simShrdPrm.pn2Stat EQ PS_PIN2 OR
896 simShrdPrm.pn2Stat EQ NO_VLD_PS )
897 {
898 if ( simShrdPrm.PINStat EQ PS_RDY OR
899 simShrdPrm.PINStat EQ PS_PIN2 )
900 {
901 simShrdPrm.PINStat = PS_PIN2;
902 }
903 else
904 {
905 TRACE_EVENT("sAT_PlusCLCK_ME(): SIM PIN State is NOT Valid");
906 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimFail );
907 return( AT_FAIL );
908 }
909
910 if( !passwd OR ( strlen( passwd ) > PIN_LEN OR
911 strlen( passwd ) < MIN_PIN_LEN ) )
912 {
913 TRACE_EVENT("sAT_PlusCLCK_ME(): SIM PIN-2 Password is Omitted");
914 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimPin2Req );
915 return( AT_FAIL );
916 }
917 }
918
919 /*
920 * test class_type whether it is supported and store it temporarily for further use
921 */
922 if( class_type EQ CLASS_NotPresent OR /* default case */
923 class_type EQ CLASS_VceDatFax ) /* case 7 */
924 {
925 simShrdPrm.classFDN = CLASS_VceDatFax;
926 }
927 else if ( class_type EQ CLASS_VceDatFaxSms ) /* case 15 */
928 {
929 simShrdPrm.classFDN = CLASS_VceDatFaxSms; /* set global class type */
930 }
931 else /* parameter not supported */
932 {
933 TRACE_EVENT( "class type not supported, +CLCK rejected" );
934 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotSupp );
935 return( AT_FAIL );
936 }
937 simShrdPrm.setPrm[srcId].actProc = (mode EQ CLCK_MOD_Lock)?
938 SIM_FDN_ENABLE:SIM_FDN_DISABLE;
939
940 simEntStat.curCmd = AT_CMD_CLCK;
941 simShrdPrm.owner = (T_OWN)srcId;
942 simEntStat.entOwn = srcId;
943
944 if( psaSIM_ActivateSIM() < 0 ) /* activate SIM card */
945 {
946 TRACE_EVENT( "FATAL RETURN psaSIM in +CLCK" );
947 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
948 return( AT_FAIL );
949 }
950
951 /* store PIN 2 for later use */
952 /* if( passwd ) ... already checked in the beginning! */
953 cmhSIM_FillInPIN ( passwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
954
955 break;
956
957 /*
958 *---------------------------------------------------------------
959 * lock ALS setting with PIN2
960 *---------------------------------------------------------------
961 */
962 case FAC_Al:
963
964 if( !passwd OR ( strlen( passwd ) > PIN_LEN OR
965 strlen( passwd ) < MIN_PIN_LEN ) )
966 {
967 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
968 return( AT_FAIL );
969 }
970
971 cmhSIM_FillInPIN ( passwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
972
973 simShrdPrm.setPrm[srcId].actProc = (mode EQ CLCK_MOD_Lock)?
974 SIM_ALS_LOCK:SIM_ALS_UNLOCK;
975
976 simShrdPrm.setPrm[srcId].PINType = PHASE_2_PIN_2;
977
978 simEntStat.curCmd = AT_CMD_CLCK;
979 simShrdPrm.owner = (T_OWN)srcId;
980 simEntStat.entOwn = srcId;
981
982 if( psaSIM_VerifyPIN() < 0 ) /* check PIN2 card */
983 {
984 TRACE_EVENT( "FATAL RETURN psaSIM in +CLCK" );
985 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
986 return( AT_FAIL );
987 }
988
989 break;
990
991 /*
992 *---------------------------------------------------------------
993 * ME Personalisation
994 *---------------------------------------------------------------
995 */
996 #ifdef SIM_PERS
997 case FAC_Pn:
998 case FAC_Pu:
999 case FAC_Pp:
1000 case FAC_Pc:
1001 case FAC_Ps:
1002 case FAC_Pf:
1003 case FAC_Bl:
1004
1005 switch (fac)
1006 {
1007 case FAC_Pn: slocktype = SIMLOCK_NETWORK; break;
1008 case FAC_Pu: slocktype = SIMLOCK_NETWORK_SUBSET; break;
1009 case FAC_Pp: slocktype = SIMLOCK_SERVICE_PROVIDER; break;
1010 case FAC_Pc: slocktype = SIMLOCK_CORPORATE; break;
1011 case FAC_Ps: slocktype = SIMLOCK_SIM; break;
1012 case FAC_Pf: slocktype = SIMLOCK_FIRST_SIM; break;
1013 case FAC_Bl: slocktype = SIMLOCK_BLOCKED_NETWORK; break;
1014 default: slocktype = SIMLOCK_NETWORK;
1015 }
1016
1017 /*
1018 * Check whether sim is inserted or not before trying to lock/Unlock
1019 */
1020
1021 if(simShrdPrm.SIMStat EQ SS_OK)
1022 {
1023 rlockstatus = (mode EQ CLCK_MOD_Lock)?
1024 aci_slock_lock(slocktype, passwd):
1025 aci_slock_unlock(slocktype, passwd);
1026 }
1027 else
1028 {
1029 /*
1030 * Sim is not present: unlocking is allowed if No_SIM_Unlock flag is OFF
1031 */
1032 if(!aci_slock_set_CFG())
1033 {
1034 ACI_ERR_DESC( ACI_ERR_CLASS_Ext,EXT_ERR_NoMEPD);
1035 return( AT_FAIL );
1036 }
1037
1038 if( (mode EQ CLCK_MOD_Unlock) AND !(cfg_data->Flags & SEC_DRV_HDR_FLAG_No_SIM_Unlock))
1039 {
1040 MFREE(cfg_data);
1041 rlockstatus = aci_slock_unlock(slocktype, passwd);
1042 }
1043 else
1044 {
1045 MFREE(cfg_data);
1046 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimNotIns);
1047 return( AT_FAIL );
1048 }
1049 }
1050 cmdBuf = AT_CMD_CLCK ;
1051 if ( ( (mode EQ CLCK_MOD_Lock) AND (rlockstatus EQ SIMLOCK_ENABLED) ) OR
1052 ( (mode EQ CLCK_MOD_Unlock) AND (rlockstatus EQ SIMLOCK_DISABLED) ) )
1053 {
1054 return (AT_CMPL);
1055 }
1056 else
1057 {
1058 if (rlockstatus EQ SIMLOCK_BLOCKED) /* Special error description on blocked personalisation */
1059 {
1060 if(!aci_slock_set_CFG())
1061 {
1062 ACI_ERR_DESC( ACI_ERR_CLASS_Ext,EXT_ERR_NoMEPD);
1063 return( AT_FAIL );
1064 }
1065 aci_set_cme_error(slocktype);
1066 MFREE(cfg_data);
1067 }
1068 else if(rlockstatus EQ SIMLOCK_WAIT)
1069 {
1070 simEntStat.curCmd = AT_CMD_CLCK;
1071 simShrdPrm.owner = (T_OWN)srcId;
1072 simEntStat.entOwn = srcId;
1073 AciSLockShrd.check_lock = SIMLOCK_CHECK_LOCK;
1074 AciSLockShrd.lock_type = slocktype;
1075 AciSLockShrd.lock_passwd = passwd;
1076
1077 return( AT_EXCT);
1078 }
1079 else if(rlockstatus EQ SIMLOCK_BUSY)
1080 {
1081 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Busy );
1082 }
1083 else
1084 {
1085 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
1086 }
1087 return( AT_FAIL );
1088 }
1089
1090 /*
1091 *---------------------------------------------------------------
1092 * FC RESET Handling
1093 Added on 11/03/2005
1094 *---------------------------------------------------------------
1095 */
1096 case FAC_Fc:
1097 {
1098 fcResetStat=aci_slock_reset_fc(passwd);
1099 simEntStat.curCmd = AT_CMD_CLCK;
1100 if (fcResetStat EQ OPER_SUCCESS)
1101 {
1102 if( !aci_slock_set_CFG())
1103 {
1104 ACI_ERR_DESC( ACI_ERR_CLASS_Ext,EXT_ERR_NoMEPD);
1105 return( AT_FAIL );
1106 }
1107 aci_slock_init();
1108 AciSLockShrd.check_lock = SIMLOCK_CHECK_RESET_FC;
1109 retSlStatus = aci_slock_checkpersonalisation(AciSLockShrd.current_lock);
1110 switch(retSlStatus)
1111 {
1112 case SIMLOCK_ENABLED :
1113 return( AT_CMPL);
1114 case SIMLOCK_WAIT :
1115 return (AT_EXCT);
1116 default :
1117 return( AT_FAIL);
1118 }
1119 }
1120 else
1121 {
1122 cmdBuf = simEntStat.curCmd;
1123 simEntStat.curCmd = AT_CMD_NONE;
1124
1125 if (fcResetStat EQ OPER_WRONG_PASSWORD)
1126 {
1127 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
1128 aci_slock_send_RAT(cmdBuf,CME_ERR_WrongPasswd);
1129 }
1130 else if (fcResetStat EQ OPER_BUSY)
1131 {
1132 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Busy );
1133 aci_slock_send_RAT(cmdBuf,err_code);
1134 }
1135 else
1136 {
1137 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown );
1138 aci_slock_send_RAT(cmdBuf,CME_ERR_Unknown);
1139 }
1140 return( AT_FAIL );
1141 }
1142 }
1143 case FAC_Fcm:
1144 {
1145 fcResetStat=aci_slock_reset_fc(passwd);
1146 return(cmhSS_check_oper_result(fcResetStat));
1147 }
1148 case( FAC_Mu ):
1149 {
1150 masterunlockStat = aci_slock_master_unlock(passwd);
1151 simEntStat.curCmd = AT_CMD_CLCK;
1152 if( masterunlockStat EQ OPER_SUCCESS )
1153 {
1154 if(!aci_slock_set_CFG())
1155 {
1156 ACI_ERR_DESC( ACI_ERR_CLASS_Ext,EXT_ERR_NoMEPD);
1157 return( AT_FAIL );
1158 }
1159 aci_slock_init();
1160 AciSLockShrd.check_lock = SIMLOCK_CHECK_MASTER_UNLOCK;
1161 retSlStatus = aci_slock_checkpersonalisation(AciSLockShrd.current_lock);
1162 switch(retSlStatus)
1163 {
1164 case SIMLOCK_ENABLED :
1165 return( AT_CMPL);
1166 case SIMLOCK_WAIT :
1167 return (AT_EXCT);
1168 default :
1169 return( AT_FAIL);
1170 }
1171 }
1172 else
1173 {
1174 cmdBuf = simEntStat.curCmd;
1175 simEntStat.curCmd = AT_CMD_NONE;
1176 if( masterunlockStat EQ OPER_WRONG_PASSWORD )
1177 {
1178 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
1179 aci_slock_send_RAT(cmdBuf,CME_ERR_WrongPasswd);
1180 }
1181 else
1182 {
1183 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown );
1184 aci_slock_send_RAT(cmdBuf,CME_ERR_Unknown);
1185 }
1186 return( AT_FAIL );
1187 }
1188 }
1189 case( FAC_Mum ):
1190 {
1191 masterunlockStat = aci_slock_master_unlock(passwd);
1192 return(cmhSS_check_oper_result(masterunlockStat));
1193 }
1194 #endif /* SIM_PERS */
1195 #ifdef FF_PHONE_LOCK
1196 case ( FAC_Pl ):
1197 {
1198 phone_lock_oper_ret_stat = aci_ext_set_phone_lock_satus(PHONE_LOCK,(T_SEC_DRV_EXT_PHONE_LOCK_STATUS)mode,passwd);
1199 return(cmhSS_check_oper_result(phone_lock_oper_ret_stat));
1200 }
1201
1202 case ( FAC_Apl ):
1203 {
1204 phone_lock_oper_ret_stat = aci_ext_set_phone_lock_satus(AUTO_LOCK,(T_SEC_DRV_EXT_PHONE_LOCK_STATUS)mode,passwd);
1205 return(cmhSS_check_oper_result(phone_lock_oper_ret_stat));
1206
1207 }
1208 #endif
1209 /*
1210 *---------------------------------------------------------------
1211 * Error handling
1212 *---------------------------------------------------------------
1213 */
1214 default:
1215 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_Unknown );
1216 return( AT_FAIL );
1217 }
1218 }
1219
1220 /*
1221 *-------------------------------------------------------------------
1222 * log command execution
1223 *-------------------------------------------------------------------
1224 */
1225 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1226 {
1227 T_ACI_CLOG cmdLog; /* holds logging info */
1228
1229 cmdLog.atCmd = AT_CMD_CLCK;
1230 cmdLog.cmdType = CLOG_TYPE_Set;
1231 cmdLog.retCode = AT_EXCT;
1232 cmdLog.cId = ACI_NumParmNotPresent;
1233 cmdLog.sId = (ssCd EQ NOT_PRESENT_8BIT)?
1234 ACI_NumParmNotPresent:/*lint -e(644)*/sId1+1;
1235 cmdLog.cmdPrm.sCLCK.srcId = srcId;
1236 cmdLog.cmdPrm.sCLCK.fac = fac;
1237 cmdLog.cmdPrm.sCLCK.mode = mode;
1238 cmdLog.cmdPrm.sCLCK.passwd = passwd;
1239 cmdLog.cmdPrm.sCLCK.class_type = class_type;
1240 rAT_PercentCLOG( &cmdLog );
1241 }
1242 #endif
1243 return( AT_EXCT );
1244 }
1245
1246 /*
1247 +--------------------------------------------------------------------+
1248 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1249 | STATE : code ROUTINE : sAT_PlusCPWD |
1250 +--------------------------------------------------------------------+
1251
1252 PURPOSE : This is the functional counterpart to the +CPWD AT command
1253 which is responsible to change the password for call
1254 barring supplementary services.
1255
1256 <fac> : CB facility.
1257 <oldpwd> : current password.
1258 <newpwd> : new password.
1259 */
1260
1261 GLOBAL T_ACI_RETURN sAT_PlusCPWD ( T_ACI_CMD_SRC srcId,
1262 T_ACI_FAC fac,
1263 CHAR * oldpwd,
1264 CHAR * newpwd)
1265 {
1266 T_ACI_RETURN retCd = AT_FAIL; /* holds return code */
1267 UBYTE ssCd; /* holds ss code */
1268 SHORT sId; /* holds service id */
1269 T_OPER_RET_STATUS phone_lock_oper_ret_stat;
1270
1271 TRACE_FUNCTION ("sAT_PlusCPWD");
1272
1273 /*
1274 *-------------------------------------------------------------------
1275 * check password parameter
1276 *-------------------------------------------------------------------
1277 */
1278 if( !newpwd OR !oldpwd )
1279 {
1280 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1281 return( AT_FAIL );
1282 }
1283
1284 /*
1285 *-------------------------------------------------------------------
1286 * check parameter <fac>
1287 *-------------------------------------------------------------------
1288 */
1289 switch( fac )
1290 {
1291 /* All Baring Services share the same password so only SS_CD_ALL_CBSS is valid,
1292 everything else will be rejected by the network! */
1293 case( FAC_Ao ):
1294 case( FAC_Oi ):
1295 case( FAC_Ox ):
1296 case( FAC_Ai ):
1297 case( FAC_Ir ):
1298 case( FAC_Ab ):
1299 case( FAC_Ag ):
1300 case( FAC_Ac ): ssCd = SS_CD_ALL_CBSS; break;
1301
1302 case( FAC_Sc ):
1303 case( FAC_P2 ):
1304 #ifdef SIM_PERS
1305 case( FAC_Pn ):
1306 case( FAC_Pu ):
1307 case( FAC_Pc ):
1308 case( FAC_Pp ):
1309 case( FAC_Pf ):
1310 case( FAC_Ps ):
1311 case( FAC_Bl ):
1312 #endif
1313 #ifdef FF_PHONE_LOCK
1314 case(FAC_Pl):
1315 case(FAC_Apl):
1316 #endif
1317
1318 ssCd = NOT_PRESENT_8BIT; break;
1319
1320 case( FAC_NotPresent ):
1321 default:
1322
1323 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1324 return( AT_FAIL );
1325 }
1326
1327 /*
1328 *-------------------------------------------------------------------
1329 * if password relates to SS
1330 *-------------------------------------------------------------------
1331 */
1332 if( ssCd NEQ NOT_PRESENT_8BIT )
1333 {
1334 /*
1335 *-------------------------------------------------------------------
1336 * check parameter <oldpwd>
1337 *-------------------------------------------------------------------
1338 */
1339 if( strlen( newpwd ) > MAX_PWD_NUM OR
1340 strlen( oldpwd ) > MAX_PWD_NUM )
1341 {
1342 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1343 return( AT_FAIL );
1344 }
1345
1346 /*
1347 *-----------------------------------------------------------------
1348 * get a new service table entry to interrogate SS
1349 *-----------------------------------------------------------------
1350 */
1351 sId = psaSS_stbNewEntry();
1352
1353 if( sId EQ NO_ENTRY )
1354 {
1355 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
1356 return( AT_FAIL );
1357 }
1358
1359 /*
1360 *-----------------------------------------------------------------
1361 * set up facility information element
1362 *-----------------------------------------------------------------
1363 */
1364 CCD_START;
1365
1366 psaSS_asmRegisterPWD( ssCd );
1367 /*
1368 *---------------------------------------------------------------
1369 * declare service table entry as used and the owner of the service
1370 *---------------------------------------------------------------
1371 */
1372 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
1373 ssShrdPrm.stb[sId].ssCode = ssCd;
1374 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
1375
1376 /*
1377 *-----------------------------------------------------------------
1378 * start a new transaction
1379 *-----------------------------------------------------------------
1380 */
1381 ssShrdPrm.stb[sId].curCmd = AT_CMD_CPWD;
1382 psaSS_NewTrns(sId);
1383
1384 CCD_END;
1385
1386 /*
1387 *-----------------------------------------------------------------
1388 * store passwords for later use
1389 *-----------------------------------------------------------------
1390 */
1391 strncpy
1392 (
1393 (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
1394 (char *) oldpwd,
1395 MAX_PWD_NUM
1396 );
1397 cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
1398
1399 strncpy
1400 (
1401 (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd,
1402 (char *) newpwd,
1403 MAX_PWD_NUM
1404 );
1405 cmhPrm[srcId].ssCmdPrm.CXXXnewPwd[MAX_PWD_NUM] = '\0';
1406
1407 strncpy
1408 (
1409 (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2,
1410 (char *) newpwd,
1411 MAX_PWD_NUM
1412 );
1413 cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2[MAX_PWD_NUM] = '\0';
1414 retCd = AT_EXCT;
1415 }
1416 else
1417 {
1418 /*
1419 *-------------------------------------------------------------------
1420 * if password relates to SIM
1421 *-------------------------------------------------------------------
1422 */
1423 switch (fac)
1424 {
1425 /*
1426 *---------------------------------------------------------------
1427 * change PIN 1 / PIN 2
1428 *---------------------------------------------------------------
1429 */
1430 case( FAC_Sc ):
1431 case( FAC_P2 ):
1432 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1433 return( AT_BUSY );
1434
1435 if( strlen( newpwd ) > PIN_LEN OR
1436 strlen( newpwd ) < MIN_PIN_LEN OR
1437 strlen( oldpwd ) > PIN_LEN OR
1438 strlen( oldpwd ) < MIN_PIN_LEN )
1439 {
1440 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1441 return( AT_FAIL );
1442 }
1443
1444 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1445 return( AT_BUSY );
1446
1447 cmhSIM_FillInPIN ( oldpwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
1448 cmhSIM_FillInPIN ( newpwd, simShrdPrm.setPrm[srcId].newPIN, PIN_LEN );
1449
1450 simShrdPrm.setPrm[srcId].PINType = (fac EQ FAC_Sc)?
1451 PHASE_2_PIN_1:PHASE_2_PIN_2;
1452
1453 simEntStat.curCmd = AT_CMD_CPWD;
1454 simShrdPrm.owner = (T_OWN)srcId;
1455 simEntStat.entOwn = srcId;
1456
1457 if( psaSIM_ChangePIN() < 0 ) /* change PIN */
1458 {
1459 TRACE_EVENT( "FATAL RETURN psaSIM in +CPWD" );
1460 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal );
1461 return( AT_FAIL );
1462 }
1463 retCd = AT_EXCT;
1464 break;
1465
1466 #ifdef SIM_PERS
1467 case( FAC_Pn ):
1468 case( FAC_Pu ):
1469 case( FAC_Pc ):
1470 case( FAC_Pp ):
1471 case( FAC_Pf ):
1472 case( FAC_Ps ):
1473 case( FAC_Bl):
1474 {
1475 T_SIMLOCK_TYPE slocktype;
1476 T_OPER_RET_STATUS status;
1477
1478 switch (fac)
1479 {
1480 case FAC_Pn: slocktype = SIMLOCK_NETWORK; break;
1481 case FAC_Pu: slocktype = SIMLOCK_NETWORK_SUBSET; break;
1482 case FAC_Pp: slocktype = SIMLOCK_SERVICE_PROVIDER; break;
1483 case FAC_Pc: slocktype = SIMLOCK_CORPORATE; break;
1484 case FAC_Ps: slocktype = SIMLOCK_SIM; break;
1485 case FAC_Pf: slocktype = SIMLOCK_FIRST_SIM; break;
1486 case FAC_Bl: slocktype = SIMLOCK_BLOCKED_NETWORK; break;
1487 default: slocktype = SIMLOCK_NETWORK; break;
1488
1489 }
1490
1491 status = aci_slock_change_password( slocktype, oldpwd, newpwd );
1492 if (status EQ OPER_SUCCESS)
1493 return(AT_CMPL);
1494 else if(status EQ OPER_FAIL )
1495 {
1496 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd );
1497 return( AT_FAIL );
1498 }
1499 else if (status EQ OPER_BLOCKED)
1500 {
1501 if(!aci_slock_set_CFG())
1502 {
1503 ACI_ERR_DESC( ACI_ERR_CLASS_Ext,EXT_ERR_NoMEPD);
1504 return( AT_FAIL );
1505 }
1506 aci_set_cme_error(slocktype);
1507 MFREE(cfg_data);
1508 return( AT_FAIL );
1509 }
1510 }
1511 retCd = AT_CMPL;
1512 break;
1513 #endif
1514
1515 #ifdef FF_PHONE_LOCK
1516 case FAC_Pl:
1517 case FAC_Apl:
1518 {
1519 phone_lock_oper_ret_stat = aci_ext_set_phone_lock_key(oldpwd,newpwd);
1520 return(cmhSS_check_oper_result(phone_lock_oper_ret_stat));
1521 }
1522 #endif
1523 }
1524 }
1525
1526 /*
1527 *-------------------------------------------------------------------
1528 * log command execution
1529 *-------------------------------------------------------------------
1530 */
1531 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1532 {
1533 T_ACI_CLOG cmdLog; /* holds logging info */
1534
1535 cmdLog.atCmd = AT_CMD_CPWD;
1536 cmdLog.cmdType = CLOG_TYPE_Set;
1537 cmdLog.retCode = retCd;
1538 cmdLog.cId = ACI_NumParmNotPresent;
1539 cmdLog.sId = (ssCd EQ NOT_PRESENT_8BIT)?
1540 ACI_NumParmNotPresent:/*lint -e(644)*/sId+1;
1541 cmdLog.cmdPrm.sCPWD.srcId = srcId;
1542 cmdLog.cmdPrm.sCPWD.fac = fac;
1543 cmdLog.cmdPrm.sCPWD.oldpwd = oldpwd;
1544 cmdLog.cmdPrm.sCPWD.newpwd = newpwd;
1545
1546 rAT_PercentCLOG( &cmdLog );
1547 }
1548 #endif
1549
1550 return( retCd );
1551 }
1552
1553 /*
1554 +--------------------------------------------------------------------+
1555 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1556 | STATE : code ROUTINE : sAT_PlusCCWA |
1557 +--------------------------------------------------------------------+
1558
1559 PURPOSE : This is the functional counterpart to the +CCWA AT command
1560 which is responsible to set the parameters for call
1561 waiting supplementary services.
1562
1563 <mode> : CW mode.
1564 <class_type>: class of call.
1565 */
1566
1567 GLOBAL T_ACI_RETURN sAT_PlusCCWA ( T_ACI_CMD_SRC srcId,
1568 T_ACI_CCWA_MOD mode,
1569 T_ACI_CLASS class_type)
1570 {
1571 SHORT sId1, sId2; /* holds service id */
1572 UBYTE bst1, bst2; /* holds basic service type */
1573 UBYTE bs1, bs2; /* holds basic service */
1574 BOOL mltyTrnFlg = FALSE; /* flags for multi transaction */
1575
1576 T_ACI_RETURN retVal;
1577
1578 TRACE_FUNCTION ("sAT_PlusCCWA ()");
1579
1580 /*
1581 *-------------------------------------------------------------------
1582 * check command source
1583 *-------------------------------------------------------------------
1584 */
1585 if(!cmh_IsVldCmdSrc (srcId))
1586 {
1587 return( AT_FAIL );
1588 }
1589
1590 if( cmhPrm[srcId].ssCmdPrm.mltyTrnFlg NEQ 0 )
1591
1592 return( AT_BUSY );
1593
1594 /*
1595 *-------------------------------------------------------------------
1596 * check parameter <class>
1597 *-------------------------------------------------------------------
1598 */
1599 if( !cmhSS_CheckClass( class_type, &bs1, &bst1, &bs2, &bst2, &mltyTrnFlg ))
1600 {
1601 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1602 return( AT_FAIL );
1603 }
1604
1605 /* SIM TOOLKIT & FDN HANDLING */
1606 if (mode NEQ CCWA_MOD_NotInterrogate) /* mode should be valid */
1607 {
1608 retVal = cmhSS_CW_SAT_Handle( srcId, (T_ACI_CCFC_MOD)mode, class_type);
1609
1610 if( retVal NEQ AT_CMPL )
1611 return( retVal );
1612 }
1613
1614
1615 /*
1616 *-------------------------------------------------------------------
1617 * get a new service table entry to interrogate SS
1618 *-------------------------------------------------------------------
1619 */
1620 sId1 = psaSS_stbNewEntry();
1621
1622 if( sId1 EQ NO_ENTRY )
1623 {
1624 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
1625 return( AT_FAIL );
1626 }
1627
1628 sId2 = NO_ENTRY;
1629
1630 if( mltyTrnFlg )
1631 {
1632 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
1633
1634 sId2 = psaSS_stbNewEntry();
1635
1636 if( sId2 EQ NO_ENTRY )
1637 {
1638 ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
1639 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
1640 return( AT_FAIL );
1641 }
1642 }
1643
1644 /*
1645 *-------------------------------------------------------------------
1646 * check parameter <mode>
1647 *-------------------------------------------------------------------
1648 */
1649 switch( mode )
1650 {
1651 /*
1652 *---------------------------------------------------------------
1653 * lock and unlock call barring service
1654 *---------------------------------------------------------------
1655 */
1656 case( CCWA_MOD_Disable ):
1657 case( CCWA_MOD_Enable ):
1658
1659 CCD_START;
1660
1661 if( mode EQ CCWA_MOD_Disable )
1662 psaSS_asmDeactivateSS( SS_CD_CW, bst1, bs1 );
1663
1664 else if( mode EQ CCWA_MOD_Enable )
1665 psaSS_asmActivateSS( SS_CD_CW, bst1, bs1 );
1666
1667 ssShrdPrm.stb[sId1].ntryUsdFlg = TRUE;
1668 ssShrdPrm.stb[sId1].ssCode = SS_CD_CW;
1669 ssShrdPrm.stb[sId1].srvOwn = (T_OWN)srcId;
1670
1671 /* start first transaction */
1672 ssShrdPrm.stb[sId1].curCmd = AT_CMD_CCWA;
1673 cmhSS_flagTrn( sId1, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
1674 psaSS_NewTrns(sId1);
1675
1676 if( mltyTrnFlg )
1677 {
1678 if( mode EQ CCWA_MOD_Disable )
1679 psaSS_asmDeactivateSS( SS_CD_CW, bst2, bs2 );
1680
1681 else if( mode EQ CCWA_MOD_Enable )
1682 psaSS_asmActivateSS( SS_CD_CW, bst2, bs2 );
1683
1684 ssShrdPrm.stb[sId2].ntryUsdFlg = TRUE;
1685 ssShrdPrm.stb[sId2].ssCode = SS_CD_CW;
1686 ssShrdPrm.stb[sId2].srvOwn = (T_OWN)srcId;
1687
1688 /* start second transaction */
1689 ssShrdPrm.stb[sId2].curCmd = AT_CMD_CCWA;
1690 cmhSS_flagTrn( sId2, &(ssShrdPrm.mltyTrnFlg)); /* only for the second one */
1691 cmhSS_flagTrn( sId2, &(cmhPrm[srcId].ssCmdPrm.mltyTrnFlg));
1692 psaSS_NewTrns(sId2);
1693 }
1694 CCD_END;
1695 break;
1696
1697 /*
1698 *---------------------------------------------------------------
1699 * unexpected mode
1700 *---------------------------------------------------------------
1701 */
1702 case( CCWA_MOD_NotInterrogate ):
1703
1704 ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
1705 return( AT_CMPL );
1706
1707 default:
1708
1709 ssShrdPrm.stb[sId1].ntryUsdFlg = FALSE;
1710 if( sId2 NEQ NO_ENTRY ) ssShrdPrm.stb[sId2].ntryUsdFlg = FALSE;
1711
1712 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1713 return( AT_FAIL );
1714 }
1715
1716 /*
1717 *-------------------------------------------------------------------
1718 * log command execution
1719 *-------------------------------------------------------------------
1720 */
1721 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1722 {
1723 T_ACI_CLOG cmdLog; /* holds logging info */
1724
1725 cmdLog.atCmd = AT_CMD_CCWA;
1726 cmdLog.cmdType = CLOG_TYPE_Set;
1727 cmdLog.retCode = AT_EXCT;
1728 cmdLog.cId = ACI_NumParmNotPresent;
1729 cmdLog.sId = sId1+1;
1730 cmdLog.cmdPrm.sCCWA.srcId = srcId;
1731 cmdLog.cmdPrm.sCCWA.mode = mode;
1732 cmdLog.cmdPrm.sCCWA.class_type = class_type;
1733
1734 rAT_PercentCLOG( &cmdLog );
1735 }
1736 #endif
1737
1738 return( AT_EXCT );
1739 }
1740
1741
1742 /*
1743 +--------------------------------------------------------------------+
1744 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1745 | STATE : code ROUTINE : sAT_PlusCUSD |
1746 +--------------------------------------------------------------------+
1747
1748 PURPOSE : This is the functional counterpart to the +CUSD AT command
1749 which is responsible to invoke an unstructured
1750 supplementary services.
1751
1752 <str> : USSD string.
1753 <dcs> : data coding scheme.
1754 */
1755 LOCAL T_ACI_RETURN ussd_call_control_by_sim(T_ACI_CMD_SRC srcId,
1756 T_ACI_USSD_DATA *str,
1757 SHORT dcs)
1758 {
1759 T_ACI_RETURN retCd = AT_CMPL; /* holds return code */
1760
1761 #ifdef SIM_TOOLKIT
1762 T_sat_ussd SATussd; /* to hold USSD string in case of SAT Control */
1763 T_CLPTY_PRM *sat_ss_cldPty;
1764
1765 if(!psaSIM_ChkSIMSrvSup( SRV_CalCntrl )) /* call control by SAT enabled */
1766 {
1767 return(AT_CMPL);
1768 }
1769
1770 if (psaSIM_ChkSIMSrvSup(SRV_USSDsupportInCC))
1771 {
1772 SATussd.dcs = (UBYTE)dcs;
1773 SATussd.c_ussd_str = str->len;
1774 SATussd.ussd_str = str->data;
1775
1776 retCd = cmhSAT_USSDCntrlBySIM( &SATussd, (UBYTE)srcId );
1777 }
1778 else /* USSD structure not known by SAT */
1779 {
1780 MALLOC(sat_ss_cldPty, sizeof(T_CLPTY_PRM));
1781 cmhCC_init_cldPty( sat_ss_cldPty );
1782
1783 if( !utl_cvtGsmIra ( str -> data,
1784 str->len,
1785 (UBYTE *)sat_ss_cldPty->num,
1786 MAX_USSD_DATA,
1787 CSCS_DIR_IraToGsm ) )
1788 {
1789 TRACE_EVENT("utl_cvtGsmIra( ) returned FALSE");
1790 MFREE(sat_ss_cldPty);
1791 return( AT_FAIL );
1792 }
1793 retCd = cmhSAT_SSCntrlBySIM( sat_ss_cldPty, (UBYTE)srcId );
1794 MFREE(sat_ss_cldPty);
1795 }
1796 return( retCd );
1797 #else
1798 return( AT_CMPL);
1799 #endif /* of SIM_TOOLKIT */
1800 }
1801
1802 GLOBAL T_ACI_RETURN sAT_PlusCUSD ( T_ACI_CMD_SRC srcId,
1803 T_ACI_USSD_DATA *str,
1804 SHORT dcs)
1805 {
1806 SHORT sId; /* holds service id */
1807 T_ACI_RETURN retCd = AT_CMPL; /* holds return code */
1808 UBYTE ussdLen;
1809 UBYTE *ussdString;
1810 UBYTE src_len;
1811
1812 TRACE_FUNCTION ("sAT_PlusCUSD ()");
1813
1814 /*
1815 *-------------------------------------------------------------------
1816 * check command source
1817 *-------------------------------------------------------------------
1818 */
1819 if(!cmh_IsVldCmdSrc (srcId))
1820 {
1821 TRACE_EVENT_P1("Wrong source: %d", srcId);
1822 return( AT_FAIL );
1823 }
1824
1825 /*
1826 *-------------------------------------------------------------------
1827 * check parameter str
1828 *-------------------------------------------------------------------
1829 */
1830 if( !str )
1831 {
1832 TRACE_EVENT("Empty string");
1833 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
1834 return( AT_FAIL );
1835 }
1836
1837 /*
1838 *-------------------------------------------------------------------
1839 * check parameter dcs
1840 *-------------------------------------------------------------------
1841 */
1842 if( dcs EQ ACI_NumParmNotPresent )
1843
1844 dcs = 0;
1845
1846 /*
1847 *-------------------------------------------------------------------
1848 * check if there is a USSD request pending
1849 *-------------------------------------------------------------------
1850 */
1851 sId = psaSS_stbFindUssdReq();
1852
1853 if( sId EQ NO_ENTRY )
1854 {
1855 /* check if there is another service in progress */
1856 if( psaSS_stbFindActSrv( sId ) NEQ NO_ENTRY )
1857 {
1858 TRACE_EVENT("Parallel USSD Transaction not allowed");
1859 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_ParallelUSSD );
1860 return( AT_FAIL );
1861 }
1862
1863 /* get new service table entry */
1864 sId = psaSS_stbNewEntry();
1865 if( sId EQ NO_ENTRY )
1866 {
1867 TRACE_EVENT("Service table is full");
1868 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
1869 return( AT_FAIL );
1870 }
1871
1872 /* check ussd call control by sim */
1873 retCd = ussd_call_control_by_sim(srcId, str, dcs);
1874 if(retCd NEQ AT_CMPL)
1875 {
1876 TRACE_EVENT_P1("ussd_call_control_by_sim() returned with %d", retCd);
1877
1878 return( retCd );
1879 }
1880
1881 CCD_START;
1882
1883 MALLOC(ussdString, MAX_USSD_STRING);
1884
1885 /* Implements Measure 25 */
1886 /* This function is more correct than utl_getAlphabetCb as it takes care
1887 of reserved codings */
1888 if( cmh_getAlphabetCb( (UBYTE)dcs ) EQ 0 ) /* 7bit alphabet */
1889 {
1890 src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, str->len);
1891 ussdLen = utl_cvt8To7( str->data,
1892 src_len,
1893 ussdString, 0 );
1894 /* According to spec 23.038 section 6.1.2.3 for USSD packing, for bytes end with
1895 * (8*n)-1 i.e where n is 1,2,3....i.e byte 7, 15, 23 ... to be padded
1896 * with carriage return <CR>(0xD)
1897 */
1898 if ((src_len+1)%8 EQ 0)
1899 {
1900 ussdString[ussdLen-1] |= (0xD << 1);
1901 }
1902 }
1903 else
1904 {
1905 ussdLen = str->len;
1906 memcpy(ussdString, str->data, MAX_USSD_STRING);
1907 }
1908
1909 psaSS_asmProcUSSDReq( (UBYTE)dcs, ussdString, ussdLen );
1910
1911 MFREE(ussdString);
1912
1913 /* start new transaction */
1914 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
1915 ssShrdPrm.stb[sId].curCmd = AT_CMD_CUSD;
1916 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
1917 psaSS_NewTrns(sId);
1918
1919 CCD_END;
1920
1921 retCd = AT_CMPL;
1922
1923
1924 }
1925 else
1926 {
1927 CCD_START;
1928
1929 psaSS_asmCnfUSSDReq( (UBYTE)dcs, str->data, str->len );
1930
1931 ssShrdPrm.stb[sId].ussdReqFlg = FALSE;
1932
1933 /* continue existing transaction */
1934 psaSS_CntTrns(sId);
1935
1936 CCD_END;
1937
1938 retCd = AT_CMPL;
1939 }
1940
1941 ssShrdPrm.ussdLen = 0;
1942
1943 /* save ussd string for possible version 1 retry */
1944 if( cmh_getAlphabetCb( (UBYTE)dcs ) EQ 0 ) /* 7bit alphabet */
1945 {
1946 if( str->len <= MAX_USSD_STRING )
1947 {
1948 ssShrdPrm.ussdLen = str->len;
1949 memcpy( ssShrdPrm.ussdBuf, str->data, str->len );
1950 }
1951 }
1952
1953 /*
1954 *-------------------------------------------------------------------
1955 * log command execution
1956 *-------------------------------------------------------------------
1957 */
1958 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1959 {
1960 T_ACI_CLOG cmdLog; /* holds logging info */
1961
1962 cmdLog.atCmd = AT_CMD_CUSD;
1963 cmdLog.cmdType = CLOG_TYPE_Set;
1964 cmdLog.retCode = retCd;
1965 cmdLog.cId = ACI_NumParmNotPresent;
1966 cmdLog.sId = sId+1;
1967 cmdLog.cmdPrm.sCUSD.srcId = srcId;
1968 cmdLog.cmdPrm.sCUSD.dcs = dcs;
1969 cmdLog.cmdPrm.sCUSD.str = str;
1970
1971 rAT_PercentCLOG( &cmdLog );
1972 }
1973 #endif
1974
1975 return( retCd );
1976 }
1977
1978 /*
1979 +--------------------------------------------------------------------+
1980 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1981 | STATE : code ROUTINE : sAT_PercentCCBS |
1982 +--------------------------------------------------------------------+
1983
1984 PURPOSE : This is the functional counterpart to the %CCBS AT command
1985 which is responsible to clear CCBS entries. Index value set
1986 to 0 indicates clear all entries.
1987
1988 <idx> : ccbs index
1989 */
1990
1991 GLOBAL T_ACI_RETURN sAT_PercentCCBS( T_ACI_CMD_SRC srcId,
1992 SHORT idx )
1993 {
1994 SHORT sId; /* holds service id */
1995
1996 T_ACI_RETURN retVal;
1997
1998 TRACE_FUNCTION ("sAT_PercentCCBS ()");
1999
2000 /*
2001 *-------------------------------------------------------------------
2002 * check command source
2003 *-------------------------------------------------------------------
2004 */
2005 if(!cmh_IsVldCmdSrc (srcId))
2006 {
2007 return( AT_FAIL );
2008 }
2009
2010 /*
2011 *-------------------------------------------------------------------
2012 * check parameter idx
2013 *-------------------------------------------------------------------
2014 */
2015 if( idx EQ ACI_NumParmNotPresent OR idx > 5 OR idx < 0 )
2016 {
2017 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2018 return( AT_FAIL );
2019 }
2020
2021 /* SIM TOOLKIT & FDN HANDLING */
2022 retVal = cmhSS_CCBS_SAT_Handle( srcId, CCBS_MOD_Erasure, idx);
2023
2024 if( retVal NEQ AT_CMPL )
2025 return( retVal );
2026
2027
2028 /*
2029 *-------------------------------------------------------------------
2030 * get a new service table entry to interrogate SS
2031 *-------------------------------------------------------------------
2032 */
2033 sId = psaSS_stbNewEntry();
2034
2035 if( sId EQ NO_ENTRY )
2036 {
2037 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_SrvTabFull );
2038 return( AT_FAIL );
2039 }
2040
2041 /*
2042 *-------------------------------------------------------------------
2043 * check parameter <mode>
2044 *-------------------------------------------------------------------
2045 */
2046 CCD_START;
2047
2048 if( idx EQ 0 ) idx = KSD_IDX_NONE;
2049
2050 psaSS_asmDeactivateCCBS((UBYTE)idx);
2051
2052 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
2053 ssShrdPrm.stb[sId].ssCode = SS_CD_CCBS;
2054 ssShrdPrm.stb[sId].SSver = MNCC_SS_VERSION_3;
2055
2056 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
2057
2058 ssShrdPrm.stb[sId].curCmd = AT_CMD_CCBS;
2059
2060 psaSS_NewTrns(sId);
2061
2062 CCD_END;
2063
2064 /*
2065 *-------------------------------------------------------------------
2066 * log command execution
2067 *-------------------------------------------------------------------
2068 */
2069 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
2070 {
2071 T_ACI_CLOG cmdLog; /* holds logging info */
2072
2073 cmdLog.atCmd = AT_CMD_CCBS;
2074 cmdLog.cmdType = CLOG_TYPE_Set;
2075 cmdLog.retCode = AT_EXCT;
2076 cmdLog.cId = ACI_NumParmNotPresent;
2077 cmdLog.sId = sId+1;
2078 cmdLog.cmdPrm.sCCBS.srcId = srcId;
2079 cmdLog.cmdPrm.sCCBS.idx = idx;
2080
2081 rAT_PercentCLOG( &cmdLog );
2082 }
2083 #endif
2084
2085 return( AT_EXCT );
2086 }
2087
2088 #ifdef TI_PS_FF_AT_P_CMD_CSCN
2089 /*
2090 +--------------------------------------------------------------------+
2091 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
2092 | STATE : code ROUTINE : sAT_PercentCSCN |
2093 +--------------------------------------------------------------------+
2094
2095 PURPOSE : This is the functional counterpart to the %CSCN AT command
2096 which is responsible to set the switches for debugging
2097 mode at terminal interface.
2098 */
2099 GLOBAL T_ACI_RETURN sAT_PercentCSCN ( T_ACI_CMD_SRC srcId,
2100 T_ACI_SS_CSCN_MOD_STATE ss_switch,
2101 T_ACI_SS_CSCN_MOD_DIRECTION ss_direction,
2102 T_ACI_CC_CSCN_MOD_STATE cc_switch,
2103 T_ACI_CC_CSCN_MOD_DIRECTION cc_direction )
2104 {
2105 TRACE_FUNCTION ("sAT_PercentCSCN ()");
2106
2107 if(!cmh_IsVldCmdSrc (srcId)) /* check command source */
2108 {
2109 return( AT_FAIL );
2110 }
2111
2112 if (ss_switch NEQ SS_CSCN_MOD_STATE_INVALID)
2113 cmhPrm[srcId].ssCmdPrm.CSCNss_mode.SsCSCNModeState = ss_switch;
2114
2115 if (ss_direction NEQ SS_CSCN_MOD_DIR_INVALID)
2116 cmhPrm[srcId].ssCmdPrm.CSCNss_mode.SsCSCNModeDirection = ss_direction;
2117
2118 if (cc_switch NEQ CC_CSCN_MOD_STATE_INVALID)
2119 cmhPrm[srcId].ccCmdPrm.CSCNcc_mode.CcCSCNModeState = cc_switch;
2120
2121 if (cc_direction NEQ CC_CSCN_MOD_DIR_INVALID)
2122 cmhPrm[srcId].ccCmdPrm.CSCNcc_mode.CcCSCNModeDirection = cc_direction;
2123
2124 return( AT_CMPL );
2125 }
2126 #endif /* TI_PS_FF_AT_P_CMD_CSCN */
2127
2128 #ifdef TI_PS_FF_AT_P_CMD_CUSDR
2129 /*
2130 +--------------------------------------------------------------------+
2131 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
2132 | STATE : code ROUTINE : sAT_PercentCUSDR |
2133 +--------------------------------------------------------------------+
2134
2135 PURPOSE : This is the functional counterpart to the %CUSDR AT command
2136 which is responsible for extended user/MMI response to n/w
2137 initaiated USSD.
2138 */
2139 GLOBAL T_ACI_RETURN sAT_PercentCUSDR(T_ACI_CMD_SRC srcId, T_ACI_CUSDR_RES response)
2140 {
2141 TRACE_FUNCTION ("sAT_PercentCUSDR()");
2142
2143 if(!cmh_IsVldCmdSrc (srcId)) /* check command source */
2144 {
2145 return( AT_FAIL );
2146 }
2147
2148 if(cuscfgParams.Ext_USSD_Response EQ CUSCFG_STAT_Disabled)
2149 {
2150 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2151 return( AT_FAIL );
2152 }
2153
2154 if(Ext_USSD_Res_Pending EQ CUSDR_EXT_USSD_RES_Not_Pending OR Ext_USSD_Res_Pending_sId EQ (SHORT)NOT_PRESENT_8BIT)
2155 {
2156 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2157 return( AT_FAIL );
2158 }
2159
2160 switch(response)
2161 {
2162 case CUSDR_RES_Ok:
2163 if(Ext_USSD_Res_Pending NEQ CUSDR_EXT_USSD_RES_Request)
2164 {
2165 psaSS_asmEmptyRslt();
2166 psaSS_CntTrns(Ext_USSD_Res_Pending_sId);
2167 }
2168 Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
2169 Ext_USSD_Res_Pending_sId = NOT_PRESENT_8BIT;
2170 return(AT_CMPL);
2171
2172 case CUSDR_RES_Unknown_Alphabet:
2173 psaSS_asmErrorRslt( Ext_USSD_Res_Pending_sId, ERR_UNKNOWN_ALPHA );
2174 psaSS_CntTrns(Ext_USSD_Res_Pending_sId);
2175 ssShrdPrm.stb[Ext_USSD_Res_Pending_sId].ntryUsdFlg = FALSE;
2176 Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
2177 Ext_USSD_Res_Pending_sId = NOT_PRESENT_8BIT;
2178 return(AT_CMPL);
2179
2180 case CUSDR_RES_Busy:
2181 psaSS_asmErrorRslt( Ext_USSD_Res_Pending_sId, ERR_USSD_BUSY );
2182 psaSS_EndTrns(Ext_USSD_Res_Pending_sId);
2183 ssShrdPrm.stb[Ext_USSD_Res_Pending_sId].ntryUsdFlg = FALSE;
2184 Ext_USSD_Res_Pending = CUSDR_EXT_USSD_RES_Not_Pending;
2185 Ext_USSD_Res_Pending_sId = NOT_PRESENT_8BIT;
2186 return(AT_CMPL);
2187
2188 default:
2189 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2190 return( AT_FAIL );
2191
2192 }
2193
2194 }
2195 #endif /* TI_PS_FF_AT_P_CMD_CUSDR */
2196
2197 /*==== EOF ========================================================*/