FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/cmh_ssf.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_SSF
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 defines the functions used by the command
18 | handler for the supplementary service module.
19 +-----------------------------------------------------------------------------
20 */
21 #ifndef CMH_SSF_C
22 #define CMH_SSF_C
23 #endif
24
25 #include "config.h"
26 #include "fixedconf.h"
27 #include "condat-features.h"
28 #include "aci_conf.h"
29
30 #include "aci_all.h"
31 /*==== INCLUDES ===================================================*/
32 #include "aci_cmh.h"
33 #include "ati_cmd.h"
34 #include "aci_cmd.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 "pcm.h"
46 #include "ksd.h"
47 #include "aci.h"
48 #include "psa.h"
49 #include "psa_ss.h"
50 #include "psa_sim.h"
51 #include "psa_util.h"
52 #include "cmh.h"
53 #include "cmh_ss.h"
54 #include "cmh_sim.h"
55 #include "psa_cc.h"
56 #include "psa_sat.h"
57
58 #include "cl_imei.h"
59
60 /* For SAT and FDN check */
61 #include "cmh_cc.h"
62 #include "cmh_sat.h"
63 #include "phb.h"
64 #include "aci_ext_pers.h"
65
66 /*
67 * FreeCalypso hack: gcc is complaining about integer/pointer mix violations
68 * with regard to NULL being used in integer contexts, so we are going to
69 * silence it as follows:
70 */
71 #undef NULL
72 #define NULL 0
73
74 /*==== CONSTANTS ==================================================*/
75 #ifdef SIM_TOOLKIT
76 /* cModMapTable maps Mode into SS Mode Code. */
77 const T_IDX_TO_STR_MAP cModMapTable[] =
78 {{CCFC_MOD_Disable, "#"}, {CCFC_MOD_Enable, "*"}, {CCFC_MOD_Register, "**"},
79 {CCFC_MOD_Erasure, "##"}, {CCFC_MOD_Query, "*#"}, {NULL, NULL}};
80
81 /* Call Forwarding */
82 /* cRsnMapTable maps Reason into SS Service Code. Must correspond to T_ACI_CCFC_RSN*/
83 const T_IDX_TO_STR_MAP cCFRsnMapTable[] =
84 {{CCFC_RSN_Uncond, "21"}, {CCFC_RSN_Busy, "67"}, {CCFC_RSN_NoReply, "61"},
85 {CCFC_RSN_NotReach, "62"}, {CCFC_RSN_Forward, "002"}, {CCFC_RSN_CondForward, "004"},
86 {NULL, NULL}};
87
88 /* Call Barring */
89 /* cRsnMapTable maps Reason into SS Service Code. Must correspond to T_ACI_CLCK_FAC*/
90 const T_IDX_TO_STR_MAP cCBRsnMapTable[] =
91 {{FAC_Ao, "33"}, {FAC_Oi, "331"}, {FAC_Ox, "332"},
92 {FAC_Ai, "35"}, {FAC_Ir, "351"}, {FAC_Ab, "330"},
93 {FAC_Ag, "333"}, {FAC_Ac, "353"},
94 {NULL, NULL}};
95
96
97 const T_IDX_TO_DIG_MAP cCFBSMapTable[] =
98 {{CLASS_Vce, KSD_BS_Telephony}, {CLASS_Dat, KSD_BS_AllBearer}, {CLASS_VceDat, KSD_BS_Telephony},
99 {CLASS_Fax, KSD_BS_AllFax}, {CLASS_VceFax, KSD_BS_AllTeleXcptSMS}, {CLASS_DatFax, KSD_BS_AllFax},
100 {CLASS_VceDatFax, KSD_BS_AllTeleXcptSMS}, {CLASS_Sms, KSD_BS_SMS}, {CLASS_DatSms, KSD_BS_SMS},
101 {CLASS_VceDatFaxSms, KSD_BS_AllTele}, {CLASS_DatCirSync, KSD_BS_AllDataCircSync},
102 {CLASS_DatCirAsync, KSD_BS_AllDataCircAsync}, {CLASS_AllSync, KSD_BS_AllSync}, {CLASS_AllAsync, KSD_BS_AllAsync},
103 {CLASS_DedPacAccess, KSD_BS_AllDedPackAcc}, {CLASS_DedPADAcess, KSD_BS_AllDedPADAcc},
104 {CLASS_AuxVce, KSD_BS_PLMN1}, {NULL, NULL}};
105
106 const T_IDX_TO_DIG_MAP cCFBSAllBearMapTable[] =
107 {{CLASS_VceDat, KSD_BS_AllBearer}, {CLASS_DatFax, KSD_BS_AllBearer}, {CLASS_VceDatFax, KSD_BS_AllBearer},
108 {CLASS_Sms, KSD_BS_AllBearer}, {CLASS_VceDatFaxSms, KSD_BS_AllBearer}, {NULL, NULL}};
109 #endif /* SIM_TOOLKIT */
110
111 /*==== TYPES ======================================================*/
112
113 LOCAL UBYTE cmhSS_getSumOf2Digits ( UBYTE digits );
114
115 #if defined (SIM_PERS) || defined (FF_PHONE_LOCK)
116 T_ACI_RETURN cmhSS_check_oper_result(T_OPER_RET_STATUS result);
117 #endif
118
119 /*==== EXPORT =====================================================*/
120
121
122 /*==== VARIABLES ==================================================*/
123
124 EXTERN T_PCEER causeMod;
125 EXTERN SHORT causeCeer;
126
127 /*==== FUNCTIONS ==================================================*/
128
129 /*
130 +-------------------------------------------------------------------+
131 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
132 | ROUTINE : cmhSS_GetClass |
133 +-------------------------------------------------------------------+
134
135 PURPOSE : Get class value out of a basic service type.
136
137 */
138
139 GLOBAL T_ACI_CLASS cmhSS_GetClass( T_basicService * bs )
140 {
141 TRACE_FUNCTION ("cmhSS_GetClass()");
142
143 if( bs -> v_bearerService )
144 {
145 return( CLASS_Dat );
146 }
147
148 else if( bs -> v_teleservice )
149 {
150 switch( bs -> teleservice )
151 {
152 case( TS_CD_ALL_SPCH ): return( CLASS_Vce );
153 case( TS_CD_ALL_FAX ): return( CLASS_Fax );
154 case( TS_CD_ALL_XCPT_SMS ): return( CLASS_VceFax );
155 case( TS_CD_PLMN1 ): return( CLASS_AuxVce );
156 default: return( CLASS_None );
157 }
158 }
159
160 else
161
162 return( CLASS_None );
163 }
164
165 /*
166 +-------------------------------------------------------------------+
167 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
168 | ROUTINE : cmhSS_GetClassLst |
169 +-------------------------------------------------------------------+
170
171 PURPOSE : Get combined class value out of a basic service list.
172
173 */
174
175 GLOBAL T_ACI_CLASS cmhSS_GetClassLst( T_basicServiceGroupList * bs )
176 {
177 T_ACI_CLASS class_type = CLASS_None;
178 UBYTE idx;
179
180 TRACE_FUNCTION ("cmhSS_GetClassLst()");
181
182 for (idx = 0; idx < bs -> c_basicServiceGroupList_value; idx++)
183 {
184 if( bs -> basicServiceGroupList_value[idx].v_bearerService )
185 {
186 switch(bs-> basicServiceGroupList_value[idx].bearerService)
187 {
188 case( BS_CD_ALL_DC_SYN ): class_type |= CLASS_DatCirSync; break;
189 case( BS_CD_ALL_DC_ASYN ): class_type |= CLASS_DatCirAsync; break;
190 case( BS_CD_ALL_DATA_PDS ): class_type |= CLASS_DedPacAccess; break;
191 case( BS_CD_ALL_DATA_PAD ): class_type |= CLASS_DedPADAcess; break;
192 default: class_type |= CLASS_Dat; break;
193 }
194 }
195 }
196
197 for (idx = 0; idx < bs -> c_basicServiceGroupList_value; idx++)
198 {
199 if( bs -> basicServiceGroupList_value[idx].v_teleservice )
200 {
201 switch( bs -> basicServiceGroupList_value[idx].teleservice )
202 {
203
204 case( TS_CD_ALL_SPCH ): class_type |= CLASS_Vce; break;
205 case( TS_CD_ALL_FAX ): class_type |= CLASS_Fax; break;
206 case( TS_CD_ALL_XCPT_SMS ): class_type |= CLASS_VceFax; break;
207 case( TS_CD_ALL_SMS ):
208 case( TS_CD_SMS_MT ):
209 case( TS_CD_SMS_MO ): class_type |= CLASS_Sms; break;
210 case( TS_CD_PLMN1 ): class_type |= CLASS_AuxVce; break;
211 }
212 }
213 }
214
215 return( class_type );
216 }
217
218 /*
219 +-------------------------------------------------------------------+
220 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
221 | ROUTINE : cmhSS_CheckClass |
222 +-------------------------------------------------------------------+
223
224 PURPOSE : Check class value.
225
226 */
227
228 GLOBAL BOOL cmhSS_CheckClassInterr( T_ACI_CLASS class_type)
229 {
230 TRACE_FUNCTION ("cmhSS_CheckClassInterr()");
231
232 switch( class_type )
233 {
234 case( CLASS_None ):
235 case( CLASS_Vce ):
236 case( CLASS_Dat ):
237 case( CLASS_VceDat ):
238 case( CLASS_Fax ):
239 case( CLASS_VceFax ):
240 case( CLASS_DatFax ):
241 case( CLASS_NotPresent ):
242 case( CLASS_VceDatFax ):
243 case( CLASS_DatCirSync ):
244 case( CLASS_DatCirAsync ):
245 case( CLASS_DedPacAccess ):
246 case( CLASS_AllSync ):
247 case( CLASS_AllAsync ):
248 case( CLASS_DedPADAcess ):
249 case( CLASS_AuxVce ):
250 return( TRUE );
251
252 default:
253 return( FALSE );
254 }
255 }
256
257 GLOBAL BOOL cmhSS_CheckCbClassInterr( T_ACI_CLASS class_type)
258 {
259 TRACE_FUNCTION ("cmhSS_CheckClassInterr()");
260
261 switch( class_type )
262 {
263 case( CLASS_None ):
264 case( CLASS_Vce ):
265 case( CLASS_Dat ):
266 case( CLASS_VceDat ):
267 case( CLASS_Fax ):
268 case( CLASS_VceFax ):
269 case( CLASS_DatFax ):
270 case( CLASS_NotPresent ):
271 case( CLASS_VceDatFax ):
272 case( CLASS_Sms ):
273 case( CLASS_VceSms ):
274 case( CLASS_DatSms ):
275 case( CLASS_VceDatSms ):
276 case( CLASS_FaxSms ):
277 case( CLASS_VceFaxSms ):
278 case( CLASS_DatFaxSms ):
279 case( CLASS_VceDatFaxSms ):
280 case( CLASS_DatCirSync ):
281 case( CLASS_DatCirAsync ):
282 case( CLASS_DedPacAccess ):
283 case( CLASS_AllSync ):
284 case( CLASS_AllAsync ):
285 case( CLASS_DedPADAcess ):
286 case( CLASS_AuxVce) :
287 return( TRUE );
288
289 default:
290 return( FALSE );
291 }
292 }
293
294 GLOBAL BOOL cmhSS_CheckClass( T_ACI_CLASS class_type,
295 UBYTE *bs1, UBYTE *bst1,
296 UBYTE *bs2, UBYTE *bst2,
297 BOOL *mltyTrnFlg )
298 {
299 TRACE_FUNCTION ("cmhSS_CheckClass()");
300
301 *bs1 = *bs2 = *bst1 = *bst2 = SS_NO_PRM;
302 *mltyTrnFlg = FALSE;
303
304 switch( class_type )
305 {
306 case( CLASS_NotPresent ):
307 case( CLASS_None ): *bs1 = *bst1 = SS_NO_PRM;
308 break;
309 case( CLASS_Vce ): *bs1 = TS_CD_ALL_SPCH; *bst1 = BS_TELE_SRV;
310 break;
311 case( CLASS_AuxVce ): *bs1 = TS_CD_PLMN1; *bst1 = BS_TELE_SRV;
312 break;
313 case( CLASS_Dat ): *bs1 = BS_CD_ALL_BS; *bst1 = BS_BEAR_SRV;
314 break;
315 case( CLASS_VceDat ): *bs1 = TS_CD_ALL_SPCH; *bst1 = BS_TELE_SRV;
316 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
317 *mltyTrnFlg = TRUE;
318 break;
319 case( CLASS_Fax ): *bs1 = TS_CD_ALL_FAX; *bst1 = BS_TELE_SRV;
320 break;
321 case( CLASS_VceFax ): *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
322 break;
323 case( CLASS_DatFax ): *bs1 = TS_CD_ALL_FAX; *bst1 = BS_TELE_SRV;
324 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
325 *mltyTrnFlg = TRUE;
326 break;
327
328 case( CLASS_VceDatFax ): *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
329 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
330 *mltyTrnFlg = TRUE;
331 break;
332 case( CLASS_DatCirSync ):
333 *bs1 = BS_CD_ALL_DC_SYN; *bst1 = BS_BEAR_SRV;
334 break;
335 case( CLASS_DatCirAsync ):
336 *bs1 = BS_CD_ALL_DC_ASYN; *bst1 = BS_BEAR_SRV;
337 break;
338 case( CLASS_DedPacAccess ):
339 *bs1 = BS_CD_ALL_DATA_PDS; *bst1 = BS_BEAR_SRV;
340 break;
341 case( CLASS_AllSync ):
342 *bs1 = BS_CD_ALL_SYN; *bst1 = BS_BEAR_SRV;
343 break;
344 case( CLASS_AllAsync ):
345 *bs1 = BS_CD_ALL_ASYN; *bst1 = BS_BEAR_SRV;
346 break;
347 case( CLASS_DedPADAcess ):
348 *bs1 = BS_CD_ALL_DATA_PAD; *bst1 = BS_BEAR_SRV;
349 break;
350 default:
351 return( FALSE );
352 }
353
354 return( TRUE );
355 }
356
357 GLOBAL BOOL cmhSS_CheckCbClass( T_ACI_CLASS class_type,
358 UBYTE *bs1, UBYTE *bst1,
359 UBYTE *bs2, UBYTE *bst2,
360 BOOL *mltyTrnFlg )
361 {
362 TRACE_FUNCTION ("cmhSS_CheckCBClass()");
363
364 *bs1 = *bs2 = *bst1 = *bst2 = SS_NO_PRM;
365 *mltyTrnFlg = FALSE;
366
367 switch( class_type )
368 {
369 case CLASS_NotPresent:
370 case CLASS_None: *bs1 = *bst1 = SS_NO_PRM;
371 break;
372 case CLASS_Vce: *bs1 = TS_CD_ALL_SPCH; *bst1 = BS_TELE_SRV;
373 break;
374 case CLASS_AuxVce: *bs1 = TS_CD_PLMN1; *bst1 = BS_TELE_SRV;
375 break;
376 case CLASS_Dat : *bs1 = BS_CD_ALL_BS; *bst1 = BS_BEAR_SRV;
377 break;
378 case CLASS_VceDat: *bs1 = TS_CD_ALL_SPCH; *bst1 = BS_TELE_SRV;
379 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
380 *mltyTrnFlg = TRUE;
381 break;
382 case CLASS_Fax: *bs1 = TS_CD_ALL_FAX; *bst1 = BS_TELE_SRV;
383 break;
384 case CLASS_VceFax: *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
385 break;
386 case CLASS_DatFax: *bs1 = TS_CD_ALL_FAX; *bst1 = BS_TELE_SRV;
387 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
388 *mltyTrnFlg = TRUE;
389 break;
390 case CLASS_VceDatFax: *bs1 = TS_CD_ALL_XCPT_SMS; *bst1 = BS_TELE_SRV;
391 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
392 *mltyTrnFlg = TRUE;
393 break;
394 case CLASS_Sms: *bs1 = TS_CD_ALL_SMS; *bst1 = BS_TELE_SRV;
395 break;
396 case CLASS_DatSms: *bs1 = TS_CD_ALL_SMS; *bst1 = BS_TELE_SRV;
397 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
398 *mltyTrnFlg = TRUE;
399 break;
400 case CLASS_VceDatFaxSms: *bs1 = TS_CD_ALL_TS; *bst1 = BS_TELE_SRV;
401 *bs2 = BS_CD_ALL_BS; *bst2 = BS_BEAR_SRV;
402 *mltyTrnFlg = TRUE;
403 break;
404 case( CLASS_DatCirSync ):
405 *bs1 = BS_CD_ALL_DC_SYN; *bst1 = BS_BEAR_SRV;
406 break;
407 case( CLASS_DatCirAsync ):
408 *bs1 = BS_CD_ALL_DC_ASYN; *bst1 = BS_BEAR_SRV;
409 break;
410 case( CLASS_DedPacAccess ):
411 *bs1 = BS_CD_ALL_DATA_PDS; *bst1 = BS_BEAR_SRV;
412 break;
413 case( CLASS_AllSync ):
414 *bs1 = BS_CD_ALL_SYN; *bst1 = BS_BEAR_SRV;
415 break;
416 case( CLASS_AllAsync ):
417 *bs1 = BS_CD_ALL_ASYN; *bst1 = BS_BEAR_SRV;
418 break;
419 case( CLASS_DedPADAcess ):
420 *bs1 = BS_CD_ALL_DATA_PAD; *bst1 = BS_BEAR_SRV;
421 break;
422
423 case CLASS_VceSms:
424 case CLASS_VceDatSms:
425 case CLASS_FaxSms:
426 case CLASS_VceFaxSms:
427 case CLASS_DatFaxSms:
428 return( FALSE );
429
430 default:
431 return( FALSE );
432 }
433
434
435 return( TRUE );
436 }
437
438 /*
439 +-------------------------------------------------------------------+
440 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
441 | ROUTINE : cmhSS_CheckBscSrv |
442 +-------------------------------------------------------------------+
443
444 PURPOSE : Check basic service value.
445
446 */
447
448 GLOBAL BOOL cmhSS_CheckBscSrv ( UBYTE bsCd,
449 UBYTE *bs, UBYTE *bst, T_ACI_CLASS *class_type )
450 {
451 T_ACI_CLASS dummy_class;
452
453 TRACE_FUNCTION ("cmhSS_CheckBscSrv()");
454
455 if(class_type EQ NULL)
456 {
457 class_type = &dummy_class;
458 }
459
460 *bs = *bst = SS_NO_PRM;
461 *class_type = CLASS_None;
462
463 switch( bsCd )
464 {
465 case( KSD_BS_None ):
466 case( KSD_BS_AllTeleAllBearer ): /* no code required */
467 *class_type = (T_ACI_CLASS)(CLASS_VceDatFaxSms + CLASS_AuxVce);
468 break;
469 case( KSD_BS_AllTele ): *bs = TS_CD_ALL_TS; *bst = BS_TELE_SRV;
470 *class_type =(T_ACI_CLASS)( CLASS_VceFaxSms + CLASS_AuxVce);
471 break;
472 /* For MMI service Code Telephony, use the corresponding Service Group
473 "Speech"... The MS shall always send the Service Group... See GSM: 03.11 */
474 case( KSD_BS_Telephony ): *bs = TS_CD_ALL_SPCH; *bst = BS_TELE_SRV;
475 *class_type =(T_ACI_CLASS) (CLASS_Vce + CLASS_AuxVce);
476 break;
477 case( KSD_BS_AllData ): *bs = TS_CD_ALL_DATA; *bst = BS_TELE_SRV; *class_type = CLASS_Dat;
478 break;
479 case( KSD_BS_AllFax ): *bs = TS_CD_ALL_FAX; *bst = BS_TELE_SRV; *class_type = CLASS_Fax;
480 break;
481 case( KSD_BS_SMS ): *bs = TS_CD_ALL_SMS; *bst = BS_TELE_SRV; *class_type = CLASS_Sms;
482 break;
483 case( KSD_BS_VoiceGroup ): *bs = TS_CD_ALL_SPCH; *bst = BS_TELE_SRV;
484 *class_type = (T_ACI_CLASS)(CLASS_Vce + CLASS_AuxVce);
485 break;
486 case( KSD_BS_AllTeleXcptSMS ): *bs = TS_CD_ALL_XCPT_SMS; *bst = BS_TELE_SRV;
487 *class_type = (T_ACI_CLASS)(CLASS_VceFax + CLASS_AuxVce);
488 break;
489 case( KSD_BS_AllBearer ): *bs = BS_CD_ALL_BS; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
490 break;
491 case( KSD_BS_AllAsync ): *bs = BS_CD_ALL_ASYN; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
492 break;
493 case( KSD_BS_AllSync ): *bs = BS_CD_ALL_SYN; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
494 break;
495 case( KSD_BS_AllDataCircSync ): *bs = BS_CD_ALL_DC_SYN; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
496 break;
497 case( KSD_BS_AllDataCircAsync ): *bs = BS_CD_ALL_DC_ASYN; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
498 break;
499 case( KSD_BS_AllDedPackAcc ): *bs = BS_CD_ALL_DATA_PDS; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
500 break;
501 case( KSD_BS_AllDedPADAcc ): *bs = BS_CD_ALL_DATA_PAD; *bst = BS_BEAR_SRV; *class_type = CLASS_Dat;
502 break;
503 case( KSD_BS_AllPLMNSpecTele ): *bs = TS_CD_ALL_PSSS; *bst = BS_TELE_SRV;
504 break;
505 case( KSD_BS_PLMNSpecTele1 ): *bs = TS_CD_PLMN1; *bst = BS_TELE_SRV;
506 break;
507 case( KSD_BS_PLMNSpecTele2 ): *bs = TS_CD_PLMN2; *bst = BS_TELE_SRV;
508 break;
509 case( KSD_BS_PLMNSpecTele3 ): *bs = TS_CD_PLMN3; *bst = BS_TELE_SRV;
510 break;
511 case( KSD_BS_PLMNSpecTele4 ): *bs = TS_CD_PLMN4; *bst = BS_TELE_SRV;
512 break;
513 case( KSD_BS_PLMNSpecTele5 ): *bs = TS_CD_PLMN5; *bst = BS_TELE_SRV;
514 break;
515 case( KSD_BS_PLMNSpecTele6 ): *bs = TS_CD_PLMN6; *bst = BS_TELE_SRV;
516 break;
517 case( KSD_BS_PLMNSpecTele7 ): *bs = TS_CD_PLMN7; *bst = BS_TELE_SRV;
518 break;
519 case( KSD_BS_PLMNSpecTele8 ): *bs = TS_CD_PLMN8; *bst = BS_TELE_SRV;
520 break;
521 case( KSD_BS_PLMNSpecTele9 ): *bs = TS_CD_PLMN9; *bst = BS_TELE_SRV;
522 break;
523 case( KSD_BS_PLMNSpecTele10 ): *bs = TS_CD_PLMNA; *bst = BS_TELE_SRV;
524 break;
525 case( KSD_BS_PLMNSpecTele11 ): *bs = TS_CD_PLMNB; *bst = BS_TELE_SRV;
526 break;
527 case( KSD_BS_PLMNSpecTele12 ): *bs = TS_CD_PLMNC; *bst = BS_TELE_SRV;
528 break;
529 case( KSD_BS_PLMNSpecTele13 ): *bs = TS_CD_PLMND; *bst = BS_TELE_SRV;
530 break;
531 case( KSD_BS_PLMNSpecTele14 ): *bs = TS_CD_PLMNE; *bst = BS_TELE_SRV;
532 break;
533 case( KSD_BS_PLMNSpecTele15 ): *bs = TS_CD_PLMNF; *bst = BS_TELE_SRV;
534 break;
535 case( KSD_BS_AllPLMNSpecBearer ):*bs = BS_CD_ALL_PSSS; *bst = BS_BEAR_SRV;
536 break;
537 case( KSD_BS_PLMNSpecBearer1 ): *bs = BS_CD_PLMN1; *bst = BS_BEAR_SRV;
538 break;
539 case( KSD_BS_PLMNSpecBearer2 ): *bs = BS_CD_PLMN2; *bst = BS_BEAR_SRV;
540 break;
541 case( KSD_BS_PLMNSpecBearer3 ): *bs = BS_CD_PLMN3; *bst = BS_BEAR_SRV;
542 break;
543 case( KSD_BS_PLMNSpecBearer4 ): *bs = BS_CD_PLMN4; *bst = BS_BEAR_SRV;
544 break;
545 case( KSD_BS_PLMNSpecBearer5 ): *bs = BS_CD_PLMN5; *bst = BS_BEAR_SRV;
546 break;
547 case( KSD_BS_PLMNSpecBearer6 ): *bs = BS_CD_PLMN6; *bst = BS_BEAR_SRV;
548 break;
549 case( KSD_BS_PLMNSpecBearer7 ): *bs = BS_CD_PLMN7; *bst = BS_BEAR_SRV;
550 break;
551 case( KSD_BS_PLMNSpecBearer8 ): *bs = BS_CD_PLMN8; *bst = BS_BEAR_SRV;
552 break;
553 case( KSD_BS_PLMNSpecBearer9 ): *bs = BS_CD_PLMN9; *bst = BS_BEAR_SRV;
554 break;
555 case( KSD_BS_PLMNSpecBearer10 ): *bs = BS_CD_PLMNA; *bst = BS_BEAR_SRV;
556 break;
557 case( KSD_BS_PLMNSpecBearer11 ): *bs = BS_CD_PLMNB; *bst = BS_BEAR_SRV;
558 break;
559 case( KSD_BS_PLMNSpecBearer12 ): *bs = BS_CD_PLMNC; *bst = BS_BEAR_SRV;
560 break;
561 case( KSD_BS_PLMNSpecBearer13 ): *bs = BS_CD_PLMND; *bst = BS_BEAR_SRV;
562 break;
563 case( KSD_BS_PLMNSpecBearer14 ): *bs = BS_CD_PLMNE; *bst = BS_BEAR_SRV;
564 break;
565 case( KSD_BS_PLMNSpecBearer15 ): *bs = BS_CD_PLMNF; *bst = BS_BEAR_SRV;
566 break;
567 case( KSD_BS_AuxTelephony ): *bs = TS_CD_PLMN1; *bst = BS_TELE_SRV; *class_type = CLASS_AuxVce;
568 break;
569
570 default:
571
572 return( FALSE );
573 }
574
575
576 return( TRUE );
577 }
578
579 /*
580 +-------------------------------------------------------------------+
581 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
582 | ROUTINE : cmhSS_GetBscSrv |
583 +-------------------------------------------------------------------+
584
585 PURPOSE : Get basic service code out of a basic service type.
586
587 */
588
589 GLOBAL void cmhSS_GetBscSrv( T_basicService * p, UBYTE * bs,
590 UBYTE * bst )
591 {
592 TRACE_FUNCTION ("cmhSS_GetBscSrv()");
593
594 if( p -> v_bearerService )
595 {
596 *bst = KSD_BS_TP_Bearer;
597 *bs = p -> bearerService;
598 }
599
600 else if( p -> v_teleservice )
601 {
602 *bst = KSD_BS_TP_Tele;
603 *bs = p -> teleservice;
604 }
605
606 else
607 {
608 *bst = KSD_BS_None;
609 *bs = KSD_BS_TeleBearerUnknown;
610 }
611 }
612
613 /*
614 +-------------------------------------------------------------------+
615 | PROJECT : GSM-PS (6147) MODULE : CMH_F |
616 | ROUTINE : cmhSS_flagTrn |
617 +-------------------------------------------------------------------+
618
619 PURPOSE : flag a call for multy-transaction operation
620
621 */
622
623 GLOBAL void cmhSS_flagTrn ( SHORT sId, USHORT * flags )
624 {
625 *flags |= (0x1 << sId);
626 }
627
628 /*
629 +-------------------------------------------------------------------+
630 | PROJECT : GSM-PS (6147) MODULE : CMH_F |
631 | ROUTINE : cmhSS_tstAndUnflagTrn |
632 +-------------------------------------------------------------------+
633
634 PURPOSE : test and unflag a call for multy-transaction operation.
635 Return the test result.
636
637 */
638
639 GLOBAL BOOL cmhSS_tstAndUnflagTrn ( SHORT sId, USHORT * flags )
640 {
641 if( *flags & (1u << sId))
642 {
643 *flags &= ~(1u << sId);
644 return( TRUE );
645 }
646 return( FALSE );
647 }
648
649 /*
650 +--------------------------------------------------------------------+
651 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
652 | STATE : code ROUTINE : cmhSS_ksdCF |
653 +--------------------------------------------------------------------+
654
655 PURPOSE : This function invokes the operation for key sequence
656 command for call forwarding supplementary services.
657 */
658
659 GLOBAL T_ACI_RETURN cmhSS_ksdCF ( T_ACI_CMD_SRC srcId,
660 T_ACI_KSD_CF_PRM * cfPrm )
661 {
662 SHORT sId; /* holds service id */
663 UBYTE bst; /* holds basic service type */
664 UBYTE bs; /* holds basic service */
665 T_ACI_CLASS user_class;
666
667 TRACE_FUNCTION ("cmhSS_ksdCF");
668
669 /*
670 *-------------------------------------------------------------------
671 * check parameter ss code
672 *-------------------------------------------------------------------
673 */
674 switch( cfPrm->ssCd )
675 {
676 case( KSD_SS_CFU ):
677 case( KSD_SS_CFB ):
678 case( KSD_SS_CFNRY ):
679 case( KSD_SS_CFNRC ):
680 case( KSD_SS_ALL_FWSS ):
681 case( KSD_SS_ALL_CFWSS ):
682
683 break;
684
685 default:
686
687 return( AT_FAIL );
688 }
689
690 /*
691 *-------------------------------------------------------------------
692 * check parameter basic service code
693 *-------------------------------------------------------------------
694 */
695 if( !cmhSS_CheckBscSrv( cfPrm->bsCd, &bs, &bst, &user_class ))
696
697 return( AT_FAIL );
698
699 /*
700 *-------------------------------------------------------------------
701 * check parameter <class> against possible ALS-Lock
702 *-------------------------------------------------------------------
703 */
704 if ((ALSlock EQ ALS_MOD_SPEECH AND user_class EQ CLASS_AuxVce) OR
705 (ALSlock EQ ALS_MOD_AUX_SPEECH AND user_class NEQ CLASS_AuxVce))
706 {
707 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_AlsLock );
708 return( AT_FAIL );
709 }
710
711 /*
712 *-------------------------------------------------------------------
713 * get a new service table entry
714 *-------------------------------------------------------------------
715 */
716 sId = psaSS_stbNewEntry();
717
718 if( sId EQ NO_ENTRY )
719 {
720 return( AT_FAIL );
721 }
722
723 /*
724 *-------------------------------------------------------------------
725 * check parameter operation code
726 *-------------------------------------------------------------------
727 */
728 CCD_START;
729
730 switch( cfPrm->opCd )
731 {
732 /* interrogate call forwarding service */
733 case( KSD_OP_IRGT ):
734 psaSS_asmInterrogateSS( cfPrm->ssCd, bst, bs );
735 break;
736
737 /* register call forwarding service */
738 case( KSD_OP_REG ):
739
740 psaSS_asmRegisterSS( cfPrm->ssCd, bst, bs,
741 cfPrm->ton, cfPrm->npi, cfPrm->num,
742 cfPrm->tos, cfPrm->oe, cfPrm->sub,
743 cfPrm->time );
744 break;
745
746 /* erase call forwarding service */
747 case( KSD_OP_ERS ):
748 psaSS_asmEraseSS( cfPrm->ssCd, bst, bs );
749 break;
750
751 /* activate call forwarding service */
752 case( KSD_OP_ACT ):
753 psaSS_asmActivateSS( cfPrm->ssCd, bst, bs );
754 break;
755
756 /* deactivate call forwarding service */
757 case( KSD_OP_DEACT ):
758 psaSS_asmDeactivateSS( cfPrm->ssCd, bst, bs );
759 break;
760
761 /* unexpected operation code */
762 default:
763
764 CCD_END;
765 return( AT_FAIL );
766 }
767
768 /*
769 *-------------------------------------------------------------------
770 * start transaction
771 *-------------------------------------------------------------------
772 */
773 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
774 ssShrdPrm.stb[sId].ssCode = cfPrm->ssCd;
775 ssShrdPrm.stb[sId].orgOPC = cfPrm->opCd;
776 ssShrdPrm.stb[sId].opCode = cfPrm->opCd;
777 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
778 ssShrdPrm.stb[sId].ClassType = user_class;
779
780 TRACE_EVENT_P1("USER_CLASS: %d", user_class);
781
782 ssShrdPrm.stb[sId].curCmd = (T_ACI_AT_CMD)KSD_CMD_CF;
783
784 psaSS_NewTrns(sId);
785
786 CCD_END;
787 /*
788 *-------------------------------------------------------------------
789 * log command execution
790 *-------------------------------------------------------------------
791 */
792 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
793 if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
794 {
795 T_ACI_CLOG cmdLog; /* holds logging info */
796
797 cmdLog.atCmd = (T_ACI_AT_CMD) KSD_CMD_CF;
798 cmdLog.cmdType = CLOG_TYPE_Set;
799 cmdLog.retCode = AT_EXCT;
800 cmdLog.cId = ACI_NumParmNotPresent;
801 cmdLog.sId = sId+1;
802 cmdLog.cmdPrm.sKSCF.srcId = srcId;
803 cmdLog.cmdPrm.sKSCF.opCd = cfPrm->opCd;
804 cmdLog.cmdPrm.sKSCF.ssCd = cfPrm->ssCd;
805 cmdLog.cmdPrm.sKSCF.bsTp = bst;
806 cmdLog.cmdPrm.sKSCF.bsCd = bs;
807 cmdLog.cmdPrm.sKSCF.num = cfPrm->num;
808 cmdLog.cmdPrm.sKSCF.ton = cfPrm->ton;
809 cmdLog.cmdPrm.sKSCF.npi = cfPrm->npi;
810 cmdLog.cmdPrm.sKSCF.sub = cfPrm->sub;
811 cmdLog.cmdPrm.sKSCF.tos = cfPrm->tos;
812 cmdLog.cmdPrm.sKSCF.oe = cfPrm->oe;
813 cmdLog.cmdPrm.sKSCF.time = cfPrm->time;
814
815 rAT_PercentCLOG( &cmdLog );
816 }
817 #endif
818
819 return( AT_EXCT );
820 }
821
822 /*
823 +--------------------------------------------------------------------+
824 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
825 | STATE : code ROUTINE : cmhSS_ksdPW |
826 +--------------------------------------------------------------------+
827
828 PURPOSE : This function invokes the operation for key sequence
829 command for password registration supplementary services.
830 */
831
832 GLOBAL T_ACI_RETURN cmhSS_ksdPW ( T_ACI_CMD_SRC srcId,
833 T_ACI_KSD_PWD_PRM * pwPrm )
834 {
835 SHORT sId=NO_ENTRY; /* holds service id */
836
837 TRACE_FUNCTION ("cmhSS_ksdPW");
838
839 /*
840 *-------------------------------------------------------------------
841 * check password parameter
842 *-------------------------------------------------------------------
843 */
844 if( !pwPrm->oldPwd OR !pwPrm->newPwd )
845 {
846 TRACE_EVENT("parameters are missing");
847 return( AT_FAIL );
848 }
849
850 /*
851 *-------------------------------------------------------------------
852 * check parameter ss code
853 *-------------------------------------------------------------------
854 */
855 switch( pwPrm->ssCd )
856 {
857 /*
858 *-------------------------------------------------------------------
859 * if password relates to SS
860 *-------------------------------------------------------------------
861 */
862 case( KSD_SS_BOC ):
863 case( KSD_SS_BOICXH ):
864 case( KSD_SS_BOIC ):
865 case( KSD_SS_ALL_CBSS ):
866 case( KSD_SS_BAOC ):
867 case( KSD_SS_BIC ):
868 case( KSD_SS_BAIC ):
869 case( KSD_SS_BICRM ):
870 case( KSD_SS_NONE ):
871 case( KSD_SS_ALL_SERV ):
872
873
874 /*
875 *-------------------------------------------------------------------
876 * check password length
877 *-------------------------------------------------------------------
878 */
879 if( strlen( (char *) pwPrm->oldPwd ) > MAX_PWD_NUM OR
880 strlen( (char *) pwPrm->newPwd ) > MAX_PWD_NUM OR
881 strlen( (char *) pwPrm->newPwd2) > MAX_PWD_NUM )
882 {
883 TRACE_EVENT("password too long");
884 return( AT_FAIL );
885 }
886
887 /*
888 *-------------------------------------------------------------------
889 * get a new service table entry
890 *-------------------------------------------------------------------
891 */
892 sId = psaSS_stbNewEntry();
893
894 if( sId EQ NO_ENTRY )
895 {
896 return( AT_FAIL );
897 }
898
899 /*
900 *-------------------------------------------------------------------
901 * check parameter operation code
902 *-------------------------------------------------------------------
903 */
904 CCD_START;
905
906 psaSS_asmRegisterPWD( pwPrm->ssCd );
907
908 /*
909 *-------------------------------------------------------------------
910 * start transaction
911 *-------------------------------------------------------------------
912 */
913 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
914 ssShrdPrm.stb[sId].ssCode = pwPrm->ssCd;
915 ssShrdPrm.stb[sId].orgOPC = KSD_OP_REG;
916 ssShrdPrm.stb[sId].opCode = KSD_OP_REG;
917 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
918
919 ssShrdPrm.stb[sId].curCmd = (T_ACI_AT_CMD)KSD_CMD_PWD;
920
921 psaSS_NewTrns(sId);
922
923 CCD_END;
924
925 /*
926 *-------------------------------------------------------------------
927 * store passwords for later use
928 *-------------------------------------------------------------------
929 */
930 strncpy
931 (
932 (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
933 (char *) pwPrm->oldPwd,
934 MAX_PWD_NUM
935 );
936 cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
937
938 strncpy
939 (
940 (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd,
941 (char *) pwPrm->newPwd,
942 MAX_PWD_NUM
943 );
944 cmhPrm[srcId].ssCmdPrm.CXXXnewPwd[MAX_PWD_NUM] = '\0';
945
946 strncpy
947 (
948 (char *) cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2,
949 (char *) pwPrm->newPwd2,
950 MAX_PWD_NUM
951 );
952 cmhPrm[srcId].ssCmdPrm.CXXXnewPwd2[MAX_PWD_NUM] = '\0';
953 break;
954
955 /*
956 *-------------------------------------------------------------------
957 * if password relates to SIM
958 *-------------------------------------------------------------------
959 */
960 case( KSD_SS_PIN1 ):
961 case( KSD_SS_PIN2 ):
962
963 if( simEntStat.curCmd NEQ AT_CMD_NONE )
964
965 return( AT_BUSY );
966
967 if( strlen( (char *) pwPrm->oldPwd ) > PIN_LEN OR
968 strlen( (char *) pwPrm->newPwd ) > PIN_LEN )
969
970 return( AT_FAIL );
971
972 /* Marcus: Issue 1589: 28/01/2003: Start */
973 if( strlen( (char *) pwPrm->oldPwd ) < MIN_PIN_LEN OR
974 strlen( (char *) pwPrm->newPwd ) < MIN_PIN_LEN )
975
976 return( AT_FAIL );
977 /* Marcus: Issue 1589: 28/01/2003: End */
978
979 /* if newPwd2 (verify new PIN ) is given, then check if
980 newPwd2 is identical with newPwd */
981 if( strlen( (char *) pwPrm->newPwd2 ) > 0 )
982 {
983 if( strlen( (char *) pwPrm->newPwd ) > PIN_LEN )
984 {
985 return( AT_FAIL );
986 }
987 if( strcmp((char *)pwPrm->newPwd, (char *)pwPrm->newPwd2) )
988 {
989 TRACE_EVENT_P2("new PIN (%s) differs from verify new PIN (%s)",
990 (char *)pwPrm->newPwd, (char *)pwPrm->newPwd2 );
991 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_WrongPasswd);
992 return( AT_FAIL );
993 }
994 }
995
996 cmhSIM_FillInPIN ( (char *) pwPrm->oldPwd, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
997 cmhSIM_FillInPIN ( (char *) pwPrm->newPwd, simShrdPrm.setPrm[srcId].newPIN, PIN_LEN );
998
999 simShrdPrm.setPrm[srcId].PINType = (pwPrm->ssCd EQ KSD_SS_PIN1)?
1000 PHASE_2_PIN_1:PHASE_2_PIN_2;
1001
1002 if ( simShrdPrm.setPrm[srcId].PINType EQ PHASE_2_PIN_1 AND
1003 simShrdPrm.PEDStat EQ PEDS_DIS )
1004 {
1005 TRACE_EVENT( "FATAL RETURN PIN not enabled" );
1006 return( AT_FAIL );
1007 }
1008
1009 simEntStat.curCmd = (T_ACI_AT_CMD)KSD_CMD_PWD;
1010 simShrdPrm.owner = (T_OWN)srcId;
1011 simEntStat.entOwn = srcId;
1012
1013 if( psaSIM_ChangePIN() < 0 ) /* change PIN */
1014 {
1015 TRACE_EVENT( "FATAL RETURN psaSIM in key sequence" );
1016 return( AT_FAIL );
1017 }
1018 break;
1019
1020 default:
1021 TRACE_EVENT("unexpected SS code");
1022 return( AT_FAIL );
1023 }
1024
1025 /*
1026 *-------------------------------------------------------------------
1027 * log command execution
1028 *-------------------------------------------------------------------
1029 */
1030 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1031 if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
1032 {
1033 T_ACI_CLOG cmdLog; /* holds logging info */
1034
1035 cmdLog.atCmd = (T_ACI_AT_CMD)KSD_CMD_PWD;
1036 cmdLog.cmdType = CLOG_TYPE_Set;
1037 cmdLog.retCode = AT_EXCT;
1038 cmdLog.cId = ACI_NumParmNotPresent;
1039 cmdLog.sId = sId+1;
1040 cmdLog.cmdPrm.sKSPW.srcId = srcId;
1041 cmdLog.cmdPrm.sKSPW.ssCd = pwPrm->ssCd;
1042 cmdLog.cmdPrm.sKSPW.oldPwd = pwPrm->oldPwd;
1043 cmdLog.cmdPrm.sKSPW.newPwd = pwPrm->newPwd;
1044
1045 rAT_PercentCLOG( &cmdLog );
1046 }
1047 #endif
1048
1049 return( AT_EXCT );
1050 }
1051
1052 /*
1053 +--------------------------------------------------------------------+
1054 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1055 | STATE : code ROUTINE : cmhSS_ksdUSSD |
1056 +--------------------------------------------------------------------+
1057
1058 PURPOSE : This function invokes the operation for key sequence
1059 command for unstructured supplementary services.
1060 */
1061
1062 GLOBAL T_ACI_RETURN cmhSS_ksdUSSD ( T_ACI_CMD_SRC srcId,
1063 T_ACI_KSD_USSD_PRM * ussdPrm )
1064 {
1065 SHORT sId; /* holds service id */
1066 T_ACI_RETURN retCd; /* holds return code */
1067 UBYTE ussdLen;
1068 UBYTE *ussdString;
1069 UBYTE src_len;
1070
1071 TRACE_FUNCTION ("cmhSS_ksdUSSD");
1072
1073 /*
1074 *-------------------------------------------------------------------
1075 * check for ussd string
1076 *-------------------------------------------------------------------
1077 */
1078 if( !ussdPrm->ussd )
1079
1080 return( AT_FAIL );
1081
1082 /*
1083 *-------------------------------------------------------------------
1084 * get a new service table entry
1085 *-------------------------------------------------------------------
1086 */
1087 sId = psaSS_stbNewEntry();
1088
1089 if( sId EQ NO_ENTRY )
1090 {
1091 return( AT_FAIL );
1092 }
1093
1094 /*
1095 *-------------------------------------------------------------------
1096 * check parameter operation code
1097 *-------------------------------------------------------------------
1098 */
1099 sId = psaSS_stbFindUssdReq();
1100
1101 if( sId EQ NO_ENTRY )
1102 {
1103 /* check if there is another service in progress */
1104 if( psaSS_stbFindActSrv( sId ) NEQ NO_ENTRY )
1105 return( AT_FAIL );
1106
1107 /* get new service table entry */
1108 sId = psaSS_stbNewEntry();
1109 if( sId EQ NO_ENTRY ) return( AT_FAIL );
1110
1111 ssShrdPrm.ussdLen = strlen((char *)ussdPrm->ussd);
1112
1113 if( !utl_cvtGsmIra ( ussdPrm->ussd,
1114 ssShrdPrm.ussdLen,
1115 ssShrdPrm.ussdBuf,
1116 MAX_USSD_DATA,
1117 CSCS_DIR_IraToGsm ) ) return( AT_FAIL );
1118 CCD_START;
1119
1120 MALLOC(ussdString, MAX_USSD_STRING);
1121
1122 src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, ssShrdPrm.ussdLen);
1123 /* to be sent as dcs = 0x0F: so always pack */
1124 ussdLen = utl_cvt8To7( ssShrdPrm.ussdBuf,
1125 src_len,
1126 ussdString, 0 );
1127
1128 /* According to spec 23.038 section 6.1.2.3 for USSD packing, for bytes end with
1129 * (8*n)-1 i.e where n is 1,2,3....i.e byte 7, 15, 23 ... to be padded
1130 * with carriage return <CR>(0xD)
1131 */
1132 if ((src_len+1)%8 EQ 0)
1133 {
1134 ussdString[ussdLen-1] |= (0xD << 1);
1135 }
1136
1137 psaSS_asmProcUSSDReq( 0x0F, ussdString, ussdLen );
1138
1139 MFREE(ussdString);
1140
1141 /* start new transaction */
1142 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
1143 ssShrdPrm.stb[sId].curCmd = (T_ACI_AT_CMD)KSD_CMD_USSD;
1144 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
1145 psaSS_NewTrns(sId);
1146
1147 CCD_END;
1148
1149 if(satShrdPrm.SIMCCParm.owner EQ OWN_SRC_SAT)
1150 {
1151 TRACE_EVENT("OWN_SRC_SAT in ksdUSSD");
1152 /* some more info needed if sat initiated USSD*/
1153 satShrdPrm.SentUSSDid = sId;
1154 }
1155 retCd = AT_CMPL;
1156 }
1157 else
1158 {
1159 ssShrdPrm.ussdLen = strlen((char *)ussdPrm->ussd);
1160
1161 if( !utl_cvtGsmIra ( ussdPrm->ussd,
1162 ssShrdPrm.ussdLen,
1163 ssShrdPrm.ussdBuf,
1164 MAX_USSD_DATA,
1165 CSCS_DIR_IraToGsm ) ) return( AT_FAIL );
1166
1167 CCD_START;
1168
1169 psaSS_asmCnfUSSDReq( 0x0F, ssShrdPrm.ussdBuf, ssShrdPrm.ussdLen );
1170
1171 ssShrdPrm.stb[sId].ussdReqFlg = FALSE;
1172
1173 /* continue existing transaction */
1174 psaSS_CntTrns(sId);
1175
1176 CCD_END;
1177
1178 retCd = AT_CMPL;
1179 }
1180
1181 /*
1182 *-------------------------------------------------------------------
1183 * log command execution
1184 *-------------------------------------------------------------------
1185 */
1186 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1187 if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
1188 {
1189 T_ACI_CLOG cmdLog; /* holds logging info */
1190
1191 cmdLog.atCmd = (T_ACI_AT_CMD)KSD_CMD_USSD;
1192 cmdLog.cmdType = CLOG_TYPE_Set;
1193 cmdLog.retCode = retCd;
1194 cmdLog.cId = ACI_NumParmNotPresent;
1195 cmdLog.sId = sId+1;
1196 cmdLog.cmdPrm.sKSUS.srcId = srcId;
1197 cmdLog.cmdPrm.sKSUS.ussd = ussdPrm->ussd;
1198
1199 rAT_PercentCLOG( &cmdLog );
1200 }
1201 #endif
1202
1203 return( retCd );
1204 }
1205
1206 /*
1207 +--------------------------------------------------------------------+
1208 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1209 | STATE : code ROUTINE : cmhSS_ksdUBLK |
1210 +--------------------------------------------------------------------+
1211
1212 PURPOSE : This function invokes the operation for key sequence
1213 command for unblocking PIN.
1214 */
1215
1216 GLOBAL T_ACI_RETURN cmhSS_ksdUBLK ( T_ACI_CMD_SRC srcId,
1217 T_ACI_KSD_UBLK_PRM * ublkPrm )
1218 {
1219 TRACE_FUNCTION ("cmhSS_ksdUBLK");
1220
1221 /*
1222 *-------------------------------------------------------------------
1223 * check parameter puk
1224 *-------------------------------------------------------------------
1225 */
1226 if( !ublkPrm->puk OR strlen( (char *) ublkPrm->puk ) NEQ PUK_LEN )
1227
1228 return( AT_FAIL );
1229
1230 /*
1231 *-------------------------------------------------------------------
1232 * check parameter pin
1233 *-------------------------------------------------------------------
1234 */
1235 if( !ublkPrm->pin OR strlen( (char *) ublkPrm->pin ) > PIN_LEN
1236 OR strlen( (char *) ublkPrm->pin ) < MIN_PIN_LEN)
1237
1238 return( AT_FAIL );
1239
1240 /*
1241 *-------------------------------------------------------------------
1242 * check parameter ss code
1243 *-------------------------------------------------------------------
1244 */
1245 switch( ublkPrm->ssCd )
1246 {
1247 case( KSD_SS_PIN1 ):
1248 case( KSD_SS_PIN2 ):
1249
1250 break;
1251
1252 default:
1253
1254 return( AT_FAIL );
1255 }
1256
1257 /*
1258 *-------------------------------------------------------------------
1259 * unblock PIN
1260 *-------------------------------------------------------------------
1261 */
1262 if( simEntStat.curCmd NEQ AT_CMD_NONE )
1263
1264 return( AT_BUSY );
1265
1266 cmhSIM_FillInPIN ( (char *) ublkPrm->puk, simShrdPrm.setPrm[srcId].unblkKey, PUK_LEN );
1267 cmhSIM_FillInPIN ( (char *) ublkPrm->pin, simShrdPrm.setPrm[srcId].curPIN, PIN_LEN );
1268
1269 simShrdPrm.setPrm[srcId].PINType = (ublkPrm->ssCd EQ KSD_SS_PIN1)?
1270 PHASE_2_PUK_1:PHASE_2_PUK_2;
1271
1272 simEntStat.curCmd = (T_ACI_AT_CMD)KSD_CMD_UBLK;
1273 simShrdPrm.owner = (T_OWN)srcId;
1274 simEntStat.entOwn = srcId;
1275
1276 if( psaSIM_UnblockCard( ) < 0 ) /* verify PIN */
1277 {
1278 TRACE_EVENT( "FATAL RETURN psaSIM in KSD" );
1279 return( AT_FAIL );
1280 }
1281
1282 /*
1283 *-------------------------------------------------------------------
1284 * log command execution
1285 *-------------------------------------------------------------------
1286 */
1287 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1288 if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
1289 {
1290 T_ACI_CLOG cmdLog; /* holds logging info */
1291
1292 cmdLog.atCmd = (T_ACI_AT_CMD)KSD_CMD_UBLK;
1293 cmdLog.cmdType = CLOG_TYPE_Set;
1294 cmdLog.retCode = AT_EXCT;
1295 cmdLog.cId = ACI_NumParmNotPresent;
1296 cmdLog.sId = ACI_NumParmNotPresent;
1297 cmdLog.cmdPrm.sKSUB.srcId = srcId;
1298 cmdLog.cmdPrm.sKSUB.ssCd = ublkPrm->ssCd;
1299 cmdLog.cmdPrm.sKSUB.puk = ublkPrm->puk;
1300 cmdLog.cmdPrm.sKSUB.pin = ublkPrm->pin;
1301
1302 rAT_PercentCLOG( &cmdLog );
1303 }
1304 #endif
1305
1306 return( AT_EXCT );
1307 }
1308
1309 /*
1310 +--------------------------------------------------------------------+
1311 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1312 | STATE : code ROUTINE : cmhSS_ksdCL |
1313 +--------------------------------------------------------------------+
1314
1315 PURPOSE : This function invokes the operation for key sequence
1316 command for calling line supplementary services.
1317 */
1318
1319 GLOBAL T_ACI_RETURN cmhSS_ksdCL ( T_ACI_CMD_SRC srcId,
1320 T_ACI_KSD_CL_PRM * clPrm )
1321 {
1322 SHORT sId; /* holds service id */
1323
1324 TRACE_FUNCTION ("cmhSS_ksdCL");
1325
1326 /*
1327 *-------------------------------------------------------------------
1328 * check parameter ss code
1329 *-------------------------------------------------------------------
1330 */
1331 switch( clPrm->ssCd )
1332 {
1333 case( KSD_SS_CLIP ):
1334 case( KSD_SS_CLIR ):
1335 case( KSD_SS_COLP ):
1336 case( KSD_SS_COLR ):
1337 case( KSD_SS_CNAP ):
1338
1339 break;
1340
1341 default:
1342
1343 return( AT_FAIL );
1344 }
1345
1346 /*
1347 *-------------------------------------------------------------------
1348 * get a new service table entry
1349 *-------------------------------------------------------------------
1350 */
1351 sId = psaSS_stbNewEntry();
1352
1353 if( sId EQ NO_ENTRY )
1354 {
1355 return( AT_FAIL );
1356 }
1357
1358 /*
1359 *-------------------------------------------------------------------
1360 * check parameter operation code
1361 *-------------------------------------------------------------------
1362 */
1363 CCD_START;
1364
1365 switch( clPrm->opCd )
1366 {
1367 /* interrogate call forwarding service */
1368 case( KSD_OP_IRGT ):
1369 psaSS_asmInterrogateSS( clPrm->ssCd, SS_NO_PRM, SS_NO_PRM );
1370 break;
1371
1372 /* activate call forwarding service */
1373 case( KSD_OP_ACT ):
1374 /* deactivate call forwarding service */
1375 case( KSD_OP_DEACT ):
1376 /* register call forwarding service */
1377 case( KSD_OP_REG ):
1378 /* erase call forwarding service */
1379 case( KSD_OP_ERS ):
1380 /* unexpected operation code */
1381 default:
1382
1383 CCD_END;
1384 return( AT_FAIL );
1385 }
1386
1387 /*
1388 *-------------------------------------------------------------------
1389 * start transaction
1390 *-------------------------------------------------------------------
1391 */
1392 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
1393 ssShrdPrm.stb[sId].ssCode = clPrm->ssCd;
1394 ssShrdPrm.stb[sId].orgOPC = clPrm->opCd;
1395 ssShrdPrm.stb[sId].opCode = clPrm->opCd;
1396 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
1397
1398 if (clPrm->ssCd EQ KSD_SS_CNAP)
1399 {
1400 ssShrdPrm.stb[sId].curCmd = AT_CMD_CNAP;
1401 }
1402 else
1403 {
1404 ssShrdPrm.stb[sId].curCmd = (T_ACI_AT_CMD)KSD_CMD_CL;
1405 }
1406
1407 psaSS_NewTrns(sId);
1408
1409 CCD_END;
1410
1411 /*
1412 *-------------------------------------------------------------------
1413 * log command execution
1414 *-------------------------------------------------------------------
1415 */
1416 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1417 if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
1418 {
1419 T_ACI_CLOG cmdLog; /* holds logging info */
1420
1421 cmdLog.atCmd = (T_ACI_AT_CMD)KSD_CMD_CW;
1422 cmdLog.cmdType = CLOG_TYPE_Set;
1423 cmdLog.retCode = AT_EXCT;
1424 cmdLog.cId = ACI_NumParmNotPresent;
1425 cmdLog.sId = sId+1;
1426 cmdLog.cmdPrm.sKSCL.srcId = srcId;
1427 cmdLog.cmdPrm.sKSCL.opCd = clPrm->opCd;
1428 cmdLog.cmdPrm.sKSCL.ssCd = clPrm->ssCd;
1429
1430 rAT_PercentCLOG( &cmdLog );
1431 }
1432 #endif
1433
1434 return( AT_EXCT );
1435 }
1436
1437 /*
1438 +--------------------------------------------------------------------+
1439 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1440 | STATE : code ROUTINE : cmhSS_ksdCCBS |
1441 +--------------------------------------------------------------------+
1442
1443 PURPOSE : This function invokes the operation for key sequence
1444 command for call completion to busy subscriber
1445 supplementary services.
1446 */
1447
1448 GLOBAL T_ACI_RETURN cmhSS_ksdCCBS ( T_ACI_CMD_SRC srcId,
1449 T_ACI_KSD_CCBS_PRM * ccbsPrm )
1450 {
1451 SHORT sId; /* holds service id */
1452
1453 TRACE_FUNCTION ("cmhSS_ksdCCBS");
1454
1455 /*
1456 *-------------------------------------------------------------------
1457 * check parameter ccbs index
1458 *-------------------------------------------------------------------
1459 */
1460 if( ccbsPrm->idx NEQ KSD_IDX_NONE AND
1461 (ccbsPrm->idx < 1 OR ccbsPrm->idx > 5 ))
1462
1463 return( AT_FAIL );
1464
1465 /*
1466 *-------------------------------------------------------------------
1467 * get a new service table entry
1468 *-------------------------------------------------------------------
1469 */
1470 sId = psaSS_stbNewEntry();
1471
1472 if( sId EQ NO_ENTRY )
1473 {
1474 return( AT_FAIL );
1475 }
1476
1477 /*
1478 *-------------------------------------------------------------------
1479 * check parameter operation code
1480 *-------------------------------------------------------------------
1481 */
1482 CCD_START;
1483
1484 switch( ccbsPrm->opCd )
1485 {
1486 #if 0 /* For further study, so not yet used */
1487 case( KSD_OP_ACT ):
1488 psaSS_asmActivateCCBS( );
1489 break;
1490 #endif
1491
1492 /* interrogate CCBS */
1493 case( KSD_OP_IRGT ):
1494 psaSS_asmInterrogateSS( SS_CD_CCBS, SS_NO_PRM, SS_NO_PRM );
1495 ssShrdPrm.stb[sId].SSver = MNCC_SS_VERSION_2;
1496 break;
1497
1498 /* deactivate CCBS */
1499 case( KSD_OP_DEACT ):
1500 psaSS_asmDeactivateCCBS( ccbsPrm -> idx );
1501 ssShrdPrm.stb[sId].SSver = MNCC_SS_VERSION_3;
1502 break;
1503
1504 default:
1505
1506 CCD_END;
1507 return( AT_FAIL );
1508 }
1509
1510 /*
1511 *-------------------------------------------------------------------
1512 * start transaction
1513 *-------------------------------------------------------------------
1514 */
1515 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
1516 ssShrdPrm.stb[sId].ssCode = KSD_SS_CCBS;
1517 ssShrdPrm.stb[sId].orgOPC = ccbsPrm->opCd;
1518 ssShrdPrm.stb[sId].opCode = ccbsPrm->opCd;
1519 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
1520
1521 ssShrdPrm.stb[sId].curCmd = (T_ACI_AT_CMD)KSD_CMD_CCBS;
1522
1523 psaSS_NewTrns(sId);
1524
1525 CCD_END;
1526
1527 /*
1528 *-------------------------------------------------------------------
1529 * log command execution
1530 *-------------------------------------------------------------------
1531 */
1532 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
1533 if( srcId NEQ ((T_ACI_CMD_SRC)OWN_SRC_SAT) )
1534 {
1535 T_ACI_CLOG cmdLog; /* holds logging info */
1536
1537 cmdLog.atCmd = (T_ACI_AT_CMD)KSD_CMD_CCBS;
1538 cmdLog.cmdType = CLOG_TYPE_Set;
1539 cmdLog.retCode = AT_EXCT;
1540 cmdLog.cId = ACI_NumParmNotPresent;
1541 cmdLog.sId = sId+1;
1542 cmdLog.cmdPrm.sKSCC.srcId = srcId;
1543 cmdLog.cmdPrm.sKSCC.opCd = ccbsPrm->opCd;
1544 cmdLog.cmdPrm.sKSCC.ssCd = KSD_SS_CCBS;
1545 cmdLog.cmdPrm.sKSCC.idx = ccbsPrm->idx;
1546
1547 rAT_PercentCLOG( &cmdLog );
1548 }
1549 #endif
1550
1551 return( AT_EXCT );
1552 }
1553
1554 /*
1555 +--------------------------------------------------------------------+
1556 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1557 | STATE : code ROUTINE : cmhSS_getSumOf2Digits |
1558 +--------------------------------------------------------------------+
1559
1560 PURPOSE : This function is used to compute the sum of an even and
1561 an odd labeled digit acc. to GSM 02.16. Only used for
1562 computing the CD for an IMEI.
1563 */
1564
1565 LOCAL UBYTE cmhSS_getSumOf2Digits ( UBYTE digits )
1566 {
1567 UBYTE dval;
1568
1569 /* compute odd labeled digit */
1570 dval = 2 * ( digits & 0x0F );
1571 dval = dval - ( dval < 10 ? 0 : 9 );
1572
1573 /*
1574 return sum of even labeled digit and
1575 already processed odd labeled digit
1576 */
1577 return dval + ( ( digits >> 4 ) & 0x0F );
1578 }
1579
1580 /*
1581 +--------------------------------------------------------------------+
1582 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1583 | STATE : code ROUTINE : cmhSS_getCdFromImei |
1584 +--------------------------------------------------------------------+
1585
1586 PURPOSE : This function is used to compute the CD for an IMEI
1587 according to GSM 02.16.
1588 */
1589
1590 GLOBAL UBYTE cmhSS_getCdFromImei ( T_ACI_IMEI* imei )
1591 {
1592 UBYTE sum = 0; /* sum of step 2 */
1593 UBYTE cd; /* Luhn Check Digit */
1594
1595 /* Step 1 and 2 of CD computation acc. GSM 02.16 */
1596 sum += cmhSS_getSumOf2Digits ( imei -> tac1 );
1597 sum += cmhSS_getSumOf2Digits ( imei -> tac2 );
1598 sum += cmhSS_getSumOf2Digits ( imei -> tac3 );
1599 sum += cmhSS_getSumOf2Digits ( imei -> fac );
1600 sum += cmhSS_getSumOf2Digits ( imei -> snr1 );
1601 sum += cmhSS_getSumOf2Digits ( imei -> snr2 );
1602 sum += cmhSS_getSumOf2Digits ( imei -> snr3 );
1603
1604 /* Step 3 of CD computation acc. GSM 02.16 */
1605 cd = 10 - ( sum % 10 );
1606 cd = ( cd EQ 10 ? 0 : cd );
1607
1608 return ( cd );
1609 }
1610
1611 /*
1612 +--------------------------------------------------------------------+
1613 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1614 | STATE : code ROUTINE : cmhSS_ksdIMEI |
1615 +--------------------------------------------------------------------+
1616
1617 PURPOSE : This function invokes the operation for key sequence
1618 command for getting the IMEI.
1619 */
1620
1621 GLOBAL T_ACI_RETURN cmhSS_ksdIMEI( T_ACI_CMD_SRC srcId )
1622 {
1623 UBYTE IMEIBuf[CL_IMEI_SIZE]; /* IMEI buffer */
1624 EF_IMEI *pIMEI; /* points to IMEI */
1625 BYTE retVal; /* holds return value */
1626 T_ACI_KSIR ksStat; /* ksd status */
1627
1628 pIMEI = (EF_IMEI *)IMEIBuf;
1629 /*
1630 * ACI-SPR-19706: Get IMEISV from IMEI common library
1631 */
1632 retVal = cl_get_imeisv(CL_IMEI_SIZE, IMEIBuf, CL_IMEI_GET_STORED_IMEI);
1633 if(retVal != CL_IMEI_OK)
1634 {
1635 TRACE_ERROR("ACI ERROR: no IMEISV available!");
1636 return( AT_FAIL );
1637 }
1638 TRACE_EVENT("ACI INFO IMEI: got IMEI");
1639 TRACE_EVENT_P8("%02x%02x%02x%02x %02x%02x%02x %02x",
1640 IMEIBuf[0], IMEIBuf[1], IMEIBuf[2], IMEIBuf[3],
1641 IMEIBuf[4], IMEIBuf[5], IMEIBuf[6], IMEIBuf[7]);
1642
1643 ksStat.ksdCmd = KSD_CMD_IMEI;
1644 ksStat.ir.rKSIMEI.tac1 = pIMEI->tac1;
1645 ksStat.ir.rKSIMEI.tac2 = pIMEI->tac2;
1646 ksStat.ir.rKSIMEI.tac3 = pIMEI->tac3;
1647 ksStat.ir.rKSIMEI.fac = pIMEI->fac;
1648 ksStat.ir.rKSIMEI.snr1 = pIMEI->snr1;
1649 ksStat.ir.rKSIMEI.snr2 = pIMEI->snr2;
1650 ksStat.ir.rKSIMEI.snr3 = pIMEI->snr3;
1651 ksStat.ir.rKSIMEI.svn = pIMEI->svn;
1652 ksStat.ir.rKSIMEI.cd = cmhSS_getCdFromImei ( &ksStat.ir.rKSIMEI );
1653
1654 /*
1655 ** CQ12314 : NDH : 23/9/2003
1656 ** Added srcID field to ksStat to enable called entity to determine the originator of the command
1657 ** and take appropriate action. (eg to Activate Call Forwarding Icon)
1658 */
1659 ksStat.srcId = srcId;
1660
1661 #if defined (MFW)
1662 if (srcId NEQ CMD_SRC_LCL)
1663 {
1664 R_AT( RAT_KSIR, CMD_SRC_LCL)( &ksStat );
1665 }
1666 #endif
1667
1668 R_AT( RAT_KSIR, srcId )( &ksStat );
1669
1670 return( AT_CMPL );
1671 }
1672
1673 /*
1674 +--------------------------------------------------------------------+
1675 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1676 | STATE : code ROUTINE : cmhSS_ksdGetOpCd |
1677 +--------------------------------------------------------------------+
1678
1679 PURPOSE : Transforms SS operation code into KSD operation code.
1680 Returns KSD operation code.
1681 */
1682 #if(0)
1683 GLOBAL UBYTE cmhSS_ksdGetOpCd ( UBYTE opcSS )
1684 {
1685 switch( opcSS )
1686 {
1687 case( OPC_REGISTER_SS ): return( KSD_OP_REG );
1688 case( OPC_ERASE_SS ): return( KSD_OP_ERS );
1689 case( OPC_ACTIVATE_SS ): return( KSD_OP_ACT );
1690 case( OPC_DEACTIVATE_SS ): return( KSD_OP_DEACT );
1691 case( OPC_INTERROGATE_SS ): return( KSD_OP_IRGT );
1692 case( OPC_REGISTER_PASSWORD ): return( KSD_OP_REG );
1693 }
1694
1695 return( KSD_OP_NONE );
1696 }
1697 #endif
1698 /*
1699 +--------------------------------------------------------------------+
1700 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1701 | STATE : code ROUTINE : cmhSS_ksdBuildErrRslt |
1702 +--------------------------------------------------------------------+
1703
1704 PURPOSE : This function build an error result for a failed KSD
1705 action.
1706 */
1707
1708 GLOBAL void cmhSS_ksdBuildErrRslt ( SHORT sId, T_ACI_KSIR * ksStat, UBYTE err )
1709 {
1710
1711 /*
1712 *-------------------------------------------------------------------
1713 * find error value
1714 *-------------------------------------------------------------------
1715 */
1716 if( err EQ KSD_NO_ERROR )
1717 {
1718 switch( ssShrdPrm.stb[sId].failType )
1719 {
1720 case( SSF_SS_ERR ):
1721
1722 err = ssShrdPrm.stb[sId].errCd;
1723 break;
1724
1725 case( SSF_GEN_PRB ):
1726
1727 err = ssShrdPrm.stb[sId].rejPrb + 0xA0;
1728 break;
1729
1730 case( SSF_INV_PRB ):
1731
1732 err = ssShrdPrm.stb[sId].rejPrb + 0xB0;
1733 break;
1734
1735 case( SSF_RSL_PRB ):
1736
1737 err = ssShrdPrm.stb[sId].rejPrb + 0xC0;
1738 break;
1739
1740 case( SSF_ERR_PRB ):
1741
1742 err = ssShrdPrm.stb[sId].rejPrb + 0xD0;
1743 break;
1744
1745 case( SSF_CCD_DEC ):
1746
1747 err = KSD_ERR_FATAL_CCD_DEC;
1748 break;
1749
1750 case( SSF_SS_ENT ):
1751
1752 err = KSD_ERR_FATAL_SS_ENT;
1753 break;
1754 }
1755 }
1756
1757 /*
1758 *-------------------------------------------------------------------
1759 * check for command context
1760 *-------------------------------------------------------------------
1761 */
1762 switch((T_ACI_KSD_CMD) ssShrdPrm.stb[sId].curCmd )
1763 {
1764 /*
1765 *----------------------------------------------------------------
1766 * process result for KSD CF command
1767 *----------------------------------------------------------------
1768 */
1769 case( KSD_CMD_CF ):
1770
1771 ksStat->ksdCmd = KSD_CMD_CF;
1772 ksStat->ir.rKSCF.opCd = ssShrdPrm.stb[sId].orgOPC;
1773 ksStat->ir.rKSCF.ssCd = ssShrdPrm.stb[sId].ssCode;
1774 ksStat->ir.rKSCF.ssErr = err;
1775 break;
1776 /*
1777 *----------------------------------------------------------------
1778 * process result for KSD CB command
1779 *----------------------------------------------------------------
1780 */
1781 case( KSD_CMD_CB ):
1782
1783 ksStat->ksdCmd = KSD_CMD_CB;
1784 ksStat->ir.rKSCB.opCd = ssShrdPrm.stb[sId].orgOPC;
1785 ksStat->ir.rKSCB.ssCd = ssShrdPrm.stb[sId].ssCode;
1786 ksStat->ir.rKSCB.ssErr = err;
1787 break;
1788 /*
1789 *----------------------------------------------------------------
1790 * process result for KSD CL command
1791 *----------------------------------------------------------------
1792 */
1793 case( KSD_CMD_CL ):
1794
1795 ksStat->ksdCmd = KSD_CMD_CL;
1796 ksStat->ir.rKSCL.opCd = ssShrdPrm.stb[sId].orgOPC;
1797 ksStat->ir.rKSCL.ssCd = ssShrdPrm.stb[sId].ssCode;
1798 ksStat->ir.rKSCL.ssErr = err;
1799 ksStat->ir.rKSCL.ssSt = KSD_ST_NOT_VALID;
1800 ksStat->ir.rKSCL.clirOpt = KSD_CO_NOT_VALID;
1801 ksStat->ir.rKSCL.ovrdCtg = KSD_OVR_CAT_NOT_VALID;
1802 break;
1803 /*
1804 *----------------------------------------------------------------
1805 * process result for KSD CW command
1806 *----------------------------------------------------------------
1807 */
1808 case( KSD_CMD_CW ):
1809
1810 ksStat->ksdCmd = KSD_CMD_CW;
1811 ksStat->ir.rKSCW.opCd = ssShrdPrm.stb[sId].orgOPC;
1812 ksStat->ir.rKSCW.ssCd = ssShrdPrm.stb[sId].ssCode;
1813 ksStat->ir.rKSCW.ssErr = err;
1814 ksStat->ir.rKSCW.ssSt = KSD_ST_NOT_VALID;
1815 break;
1816 /*
1817 *----------------------------------------------------------------
1818 * process result for KSD PW command
1819 *----------------------------------------------------------------
1820 */
1821 case( KSD_CMD_PWD ):
1822
1823 ksStat->ksdCmd = KSD_CMD_PWD;
1824 ksStat->ir.rKSPW.opCd = ssShrdPrm.stb[sId].orgOPC;
1825 ksStat->ir.rKSPW.ssCd = ssShrdPrm.stb[sId].ssCode;
1826 ksStat->ir.rKSPW.ssErr = err;
1827 if(ssShrdPrm.stb[sId].errPrms NEQ NOT_PRESENT_8BIT)
1828 ksStat->ir.rKSPW.errPrms = ssShrdPrm.stb[sId].errPrms;
1829
1830 break;
1831 /*
1832 *----------------------------------------------------------------
1833 * process result for KSD USSD command
1834 *----------------------------------------------------------------
1835 */
1836 case( KSD_CMD_USSD ):
1837
1838 ksStat->ksdCmd = KSD_CMD_USSD;
1839 ksStat->ir.rKSUS.ssErr = err;
1840 break;
1841 }
1842 }
1843
1844 /*
1845 +--------------------------------------------------------------------+
1846 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1847 | STATE : code ROUTINE : cmhSS_ksdFillFwdFeatList |
1848 +--------------------------------------------------------------------+
1849
1850 PURPOSE : This function fills in the values of a forwarding
1851 feature list and returns the number of filled entries.
1852 */
1853
1854 GLOBAL UBYTE cmhSS_ksdFillFwdFeatList( T_forwardingFeatureList * ffSS,
1855 T_CF_FEAT * cfFeat )
1856 {
1857 UBYTE idx; /* holds list index */
1858
1859 for( idx=0;
1860 idx < MINIMUM( ffSS->c_ff, MAX_CF_FEAT_NR );
1861 idx++, cfFeat++ )
1862 {
1863 cmhSS_GetBscSrv( &ffSS->ff[idx].basicService,
1864 &cfFeat->bsCd,
1865 &cfFeat->bsTp );
1866
1867 if( !ffSS->ff[idx].v_ssStatus )
1868 cfFeat->ssSt = KSD_ST_NOT_VALID;
1869 else
1870 cfFeat->ssSt = ffSS->ff[idx].ssStatus;
1871
1872 if( ffSS->ff[idx].v_forwardedToNumber AND
1873 ffSS->ff[idx].forwardedToNumber.c_bcdDigit )
1874 {
1875 utl_BCD2DialStr
1876 (ffSS->ff[idx].forwardedToNumber.bcdDigit,
1877 (char*)cfFeat->num,
1878 ffSS->ff[idx].forwardedToNumber.c_bcdDigit);
1879
1880 cfFeat->npi = ffSS->ff[idx].forwardedToNumber.npi;
1881 cfFeat->ton = ffSS->ff[idx].forwardedToNumber.noa;
1882 }
1883 else
1884 {
1885 cfFeat->npi = 0xFF;
1886 cfFeat->ton = 0xFF;
1887 }
1888
1889 if( ffSS->ff[idx].v_forwardedToSubaddress AND
1890 ffSS->ff[idx].forwardedToSubaddress.c_subadr_str )
1891 {
1892 utl_BCD2DialStr
1893 (ffSS->ff[idx].forwardedToSubaddress.subadr_str,
1894 (char*)cfFeat->sub,
1895 ffSS->ff[idx].forwardedToSubaddress.c_subadr_str);
1896
1897 cfFeat->tos = ffSS->ff[idx].forwardedToSubaddress.tos;
1898 cfFeat->oe = ffSS->ff[idx].forwardedToSubaddress.oei;
1899 }
1900 else
1901 {
1902 cfFeat->tos = 0xFF;
1903 cfFeat->oe = 0xFF;
1904 }
1905
1906 if( ffSS->ff[idx].v_noReplyConditionTime )
1907 cfFeat->time = ffSS->ff[idx].noReplyConditionTime;
1908 else
1909 cfFeat->time = 0xFF;
1910 }
1911
1912 return( idx );
1913 }
1914
1915 /*
1916 +--------------------------------------------------------------------+
1917 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1918 | STATE : code ROUTINE : cmhSS_ksdFillCbFeatList |
1919 +--------------------------------------------------------------------+
1920
1921 PURPOSE : This function fills in the values of a call barring
1922 feature list and returns the number of filled entries.
1923 */
1924
1925 GLOBAL UBYTE cmhSS_ksdFillCbFeatList( T_callBarringFeatureList * bfSS,
1926 T_CB_INFO * cbInfo )
1927 {
1928 UBYTE idx; /* holds list index */
1929
1930 for( idx=0;
1931 idx < MINIMUM( bfSS->c_cbf, MAX_CB_INFO_NR);
1932 idx++, cbInfo++ )
1933 {
1934 cbInfo->ssSt = (bfSS->cbf[idx].v_ssStatus)?
1935 bfSS->cbf[idx].ssStatus :
1936 (UBYTE)KSD_ST_NOT_VALID;
1937
1938 cmhSS_GetBscSrv(&bfSS->cbf[idx].basicService,
1939 &cbInfo->bsCd,
1940 &cbInfo->bsTp );
1941 }
1942
1943 return( idx );
1944 }
1945
1946 /*
1947 +--------------------------------------------------------------------+
1948 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1949 | STATE : code ROUTINE : cmhSS_ksdFillBSGList |
1950 +--------------------------------------------------------------------+
1951
1952 PURPOSE : This function fills in the values of a basic service
1953 group list and returns the number of filled entries.
1954 */
1955
1956 GLOBAL UBYTE cmhSS_ksdFillBSGList( T_basicServiceGroupList * bsgSS,
1957 T_Cx_BSG * cxBSG )
1958 {
1959 UBYTE idx; /* holds list index */
1960 UBYTE lstSpce; /* holds list space */
1961
1962 lstSpce = MAX_CW_BSG_NR;
1963
1964 for( idx=0;
1965 idx < bsgSS->c_basicServiceGroupList_value AND lstSpce;
1966 idx++ )
1967 {
1968 if (bsgSS->basicServiceGroupList_value[idx].v_teleservice)
1969 {
1970 cxBSG->bsCd = bsgSS->basicServiceGroupList_value[idx].teleservice;
1971 cxBSG->bsTp = KSD_BS_TP_Tele;
1972 cxBSG++;
1973 lstSpce--;
1974 }
1975 if (bsgSS->basicServiceGroupList_value[idx].v_bearerService)
1976 {
1977 cxBSG->bsCd = bsgSS->basicServiceGroupList_value[idx].bearerService;
1978 cxBSG->bsTp = KSD_BS_TP_Bearer;
1979 cxBSG++;
1980 lstSpce--;
1981 }
1982 }
1983
1984 return( MAX_CW_BSG_NR - lstSpce );
1985 }
1986
1987 /*
1988 +--------------------------------------------------------------------+
1989 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
1990 | STATE : code ROUTINE : cmhSS_ksdFillCCBSFeatList|
1991 +--------------------------------------------------------------------+
1992
1993 PURPOSE : This function fills in the values of a forwarding
1994 feature list and returns the number of filled entries.
1995 */
1996
1997 GLOBAL UBYTE cmhSS_ksdFillCCBSFeatList( T_ccbsFeatureList * ccbsfSS,
1998 T_CC_FEAT * ccFeat )
1999 {
2000 UBYTE idx; /* holds list index */
2001
2002 for( idx=0;
2003 idx < MINIMUM( ccbsfSS->c_ccbsf, MAX_CC_FEAT_NR );
2004 idx++, ccFeat++ )
2005 {
2006 cmhSS_GetBscSrv( (T_basicService*)&ccbsfSS->ccbsf[idx].basicServiceGroup,
2007 &ccFeat->bsCd,
2008 &ccFeat->bsTp );
2009
2010 if( ccbsfSS->ccbsf[idx].v_b_subscriberNumber AND
2011 ccbsfSS->ccbsf[idx].b_subscriberNumber.c_bcdDigit )
2012 {
2013 utl_BCD2DialStr
2014 (ccbsfSS->ccbsf[idx].b_subscriberNumber.bcdDigit,
2015 (char*)ccFeat->num,
2016 ccbsfSS->ccbsf[idx].b_subscriberNumber.c_bcdDigit);
2017
2018 ccFeat->npi = ccbsfSS->ccbsf[idx].b_subscriberNumber.npi;
2019 ccFeat->ton = ccbsfSS->ccbsf[idx].b_subscriberNumber.noa;
2020 }
2021 else
2022 {
2023 ccFeat->npi = 0xFF;
2024 ccFeat->ton = 0xFF;
2025 }
2026
2027 if( ccbsfSS->ccbsf[idx].v_b_subscriberSubaddress AND
2028 ccbsfSS->ccbsf[idx].b_subscriberSubaddress.c_subadr_str )
2029 {
2030 utl_BCD2DialStr
2031 (ccbsfSS->ccbsf[idx].b_subscriberSubaddress.subadr_str,
2032 (char*)ccFeat->sub,
2033 ccbsfSS->ccbsf[idx].b_subscriberSubaddress.c_subadr_str);
2034
2035 ccFeat->tos = ccbsfSS->ccbsf[idx].b_subscriberSubaddress.tos;
2036 ccFeat->oe = ccbsfSS->ccbsf[idx].b_subscriberSubaddress.oei;
2037 }
2038 else
2039 {
2040 ccFeat->tos = 0xFF;
2041 ccFeat->oe = 0xFF;
2042 }
2043
2044 if( ccbsfSS->ccbsf[idx].v_ccbsIndex )
2045 ccFeat->idx = ccbsfSS->ccbsf[idx].ccbsIndex;
2046 else
2047 ccFeat->idx = 0xFF;
2048 }
2049
2050 return( idx );
2051 }
2052
2053 /*
2054 +--------------------------------------------------------------------+
2055 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
2056 | STATE : code ROUTINE : cmhSS_ksdFillFwdRes |
2057 +--------------------------------------------------------------------+
2058
2059 PURPOSE : This function fills in a forwarding info
2060 into a forwarding result structure.
2061 */
2062
2063 GLOBAL void cmhSS_ksdFillFwdRes( T_forwardingInfo * fiSS,
2064 T_ACI_KSIR *ksStat,
2065 T_CF_FEAT * cfFeat )
2066 {
2067 /* if SS code is present */
2068 ksStat->ir.rKSCF.ssCd= (fiSS->v_ssCode)?
2069 fiSS->ssCode:
2070 (UBYTE)KSD_SS_NONE;
2071
2072 /* if forwarding feature list is present, decode the forwarding
2073 information */
2074 if( fiSS->v_forwardingFeatureList )
2075 {
2076 /* no forwarding features present */
2077 if( fiSS->forwardingFeatureList.c_ff EQ 0 )
2078 {
2079 TRACE_EVENT("UNEXP: NO FORWARDING FEATURE IN FEATURE LIST");
2080 }
2081
2082 /* fowarding feature list present */
2083 else
2084 {
2085 ksStat->ir.rKSCF.cfFeatLst = cfFeat;
2086
2087 ksStat->ir.rKSCF.c_cfFeatLst =
2088 cmhSS_ksdFillFwdFeatList( &fiSS->forwardingFeatureList, cfFeat );
2089 }
2090 }
2091 }
2092
2093 /*
2094 +--------------------------------------------------------------------+
2095 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
2096 | STATE : code ROUTINE : cmhSS_ksdFillCbRes |
2097 +--------------------------------------------------------------------+
2098
2099 PURPOSE : This function fills in a barring info
2100 into a barring result structure.
2101 */
2102
2103 GLOBAL void cmhSS_ksdFillCbRes( T_callBarringInfo * biSS,
2104 T_ACI_KSIR *ksStat,
2105 T_CB_INFO * cbInfo )
2106 {
2107 /* if SS code is present */
2108 ksStat->ir.rKSCB.ssCd= (biSS->v_ssCode)?
2109 biSS->ssCode:
2110 (UBYTE)KSD_SS_NONE;
2111
2112 /* if barring feature list is present, decode the barring
2113 information */
2114 if( biSS->v_callBarringFeatureList )
2115 {
2116 /* no forwarding features present */
2117 if( biSS->callBarringFeatureList.c_cbf EQ 0 )
2118 {
2119 TRACE_EVENT("UNEXP: NO BARRING FEATURE IN FEATURE LIST");
2120 }
2121
2122 /* fowarding feature list present */
2123 else
2124 {
2125 ksStat->ir.rKSCB.cbInfoLst = cbInfo;
2126
2127 ksStat->ir.rKSCB.c_cbInfoLst =
2128 cmhSS_ksdFillCbFeatList( &biSS->callBarringFeatureList, cbInfo );
2129 }
2130 }
2131 }
2132
2133 /*
2134 +--------------------------------------------------------------------+
2135 | PROJECT : GSM-PS (6147) MODULE : CMH_SSS |
2136 | STATE : code ROUTINE : cmhSS_ksdFillCwRes |
2137 +--------------------------------------------------------------------+
2138
2139 PURPOSE : This function fills in a SS data
2140 into a waiting result structure.
2141 */
2142
2143 GLOBAL void cmhSS_ksdFillCwRes( T_ssData *datSS,
2144 T_ACI_KSIR *ksStat,
2145 T_Cx_BSG *cwBSG )
2146 {
2147 /* if SS code is present */
2148 ksStat->ir.rKSCW.ssCd= (datSS->v_ssCode)?
2149 datSS->ssCode:
2150 (UBYTE)KSD_SS_NONE;
2151
2152 /* if SS status is present */
2153 ksStat->ir.rKSCW.ssSt= (datSS->v_ssStatus)?
2154 datSS->ssStatus:
2155 (UBYTE)KSD_ST_NONE;
2156
2157 /* if basic service list is present, decode the basic service
2158 information */
2159 if( datSS->v_basicServiceGroupList )
2160 {
2161 /* no forwarding features present */
2162 if( datSS->basicServiceGroupList.c_basicServiceGroupList_value EQ 0 )
2163 {
2164 TRACE_EVENT("UNEXP: NO BASIC SERVICE IN SERVICE LIST");
2165 }
2166
2167 /* fowarding feature list present */
2168 else
2169 {
2170 ksStat->ir.rKSCW.cwBSGLst = cwBSG;
2171
2172 ksStat->ir.rKSCW.c_cwBSGLst =
2173 cmhSS_ksdFillBSGList( &datSS->basicServiceGroupList, cwBSG );
2174 }
2175 }
2176 }
2177
2178 /*
2179 +-------------------------------------------------------------------+
2180 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2181 | ROUTINE : cmhSS_GetClassType |
2182 +-------------------------------------------------------------------+
2183
2184 PURPOSE : Convert class type value.
2185
2186 */
2187
2188 GLOBAL T_ACI_CLASS cmhSS_GetClassType( UBYTE bsTp, UBYTE bsCd )
2189 {
2190 TRACE_FUNCTION ("cmhSS_GetClassType()");
2191
2192 if ( bsTp EQ KSD_BS_TP_None AND
2193 bsCd EQ KSD_BS_TeleBearerUnknown )
2194 return CLASS_VceDatFax;
2195
2196 if (bsTp EQ KSD_BS_TP_Bearer)
2197 {
2198 return( CLASS_Dat );
2199 }
2200 if (bsTp EQ KSD_BS_TP_Tele)
2201 {
2202 switch( bsCd )
2203 {
2204 case( TS_CD_TLPHNY ): /* no break */
2205 case( TS_CD_ALL_SPCH ):
2206 return( CLASS_Vce );
2207 case( TS_CD_PLMN1 ):
2208 return( CLASS_AuxVce);
2209
2210 case( TS_CD_ALL_FAX ):
2211 return( CLASS_Fax );
2212
2213 case( TS_CD_ALL_TS ): /* no break */
2214 case( TS_CD_ALL_XCPT_SMS ):
2215 return( CLASS_VceFax );
2216
2217 default:
2218 return( CLASS_None );
2219 }
2220 }
2221 return( CLASS_None );
2222 }
2223
2224 GLOBAL T_ACI_CLASS cmhSS_GetCbClassType( UBYTE bsTp, UBYTE bsCd )
2225 {
2226 TRACE_FUNCTION ("cmhSS_GetCbClassType()");
2227
2228 if ( bsTp EQ KSD_BS_TP_None AND
2229 bsCd EQ KSD_BS_TeleBearerUnknown )
2230 return CLASS_VceDatFaxSms;
2231
2232 if (bsTp EQ KSD_BS_TP_Bearer)
2233 {
2234 return( CLASS_Dat );
2235 }
2236 if (bsTp EQ KSD_BS_TP_Tele)
2237 {
2238 switch( bsCd )
2239 {
2240 case( TS_CD_TLPHNY ): /* no break */
2241 case( TS_CD_ALL_SPCH ): return( CLASS_Vce );
2242 case( TS_CD_PLMN1 ): return( CLASS_AuxVce);
2243
2244 case( TS_CD_ALL_FAX ): return( CLASS_Fax );
2245
2246 case( TS_CD_ALL_XCPT_SMS ): return( CLASS_VceFax );
2247
2248 case( TS_CD_ALL_SMS ):
2249 case( TS_CD_SMS_MT ):
2250 case( TS_CD_SMS_MO ): return (CLASS_Sms );
2251
2252 case( TS_CD_ALL_TS ): return (CLASS_VceFaxSms );
2253
2254 default: return( CLASS_None );
2255 }
2256 }
2257 return( CLASS_None );
2258 }
2259
2260
2261 /*
2262 +-------------------------------------------------------------------+
2263 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2264 | ROUTINE : checkSSforFDN |
2265 +-------------------------------------------------------------------+
2266
2267 PURPOSE : Check, if SS string exists in FDN phone book
2268 Returns FALSE if not found
2269
2270 */
2271 BOOL checkSSforFDN(char *cSSString)
2272 {
2273
2274 T_CLPTY_PRM ssCldPty;
2275
2276 if(cSSString NEQ NULL)
2277 {
2278 cmhCC_init_cldPty( &ssCldPty );
2279 cmh_bldCalPrms ( cSSString, &ssCldPty );
2280 /*
2281 *-------------------------------------------------------------------
2282 * check fixed dialing phonebook if enabled
2283 *-------------------------------------------------------------------
2284 */
2285 if((simShrdPrm.crdFun EQ SIM_FDN_ENABLED OR
2286 simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED) )
2287 {
2288 if( ksd_isFDNCheckSeq ( ssCldPty.num ) )
2289 {
2290 if(!psaCC_phbNtryFnd( FDN, &ssCldPty ))
2291 {
2292 TRACE_EVENT ( "SS FDN check failed" );
2293 return FALSE;
2294 }
2295 }
2296 }
2297 }
2298 return TRUE;
2299 }
2300
2301 /*
2302 +-------------------------------------------------------------------+
2303 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2304 | ROUTINE : checkFDNSendSS |
2305 +-------------------------------------------------------------------+
2306
2307 PURPOSE : Check, if SS string exists in FDN phone book and send to STK if allowed
2308 Returns AT_FAIL if FDN is not allowed or send to STK fails
2309
2310 */
2311 T_ACI_RETURN checkFDNSendSS(T_ACI_CMD_SRC srcId, CHAR *pSSString)
2312 {
2313 /* If SS string should be checked, but not found in FDN - return error */
2314 if (!checkSSforFDN(pSSString))
2315 {
2316 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_FdnCheck );
2317 return AT_FAIL;
2318 }
2319 #ifdef SIM_TOOLKIT
2320 return cmhSS_SendToSAT(srcId, pSSString);
2321 #else /* SIM_TOOLKIT */
2322 return AT_CMPL;
2323 #endif /* SIM_TOOLKIT */
2324
2325 }
2326
2327 /*
2328 +-------------------------------------------------------------------+
2329 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2330 | ROUTINE : mapIdxToString |
2331 +-------------------------------------------------------------------+
2332
2333 PURPOSE : Find the occurence of the record of type T_IDX_TO_STR_MAP with "idx" field
2334 equal index and returns field "cod"
2335 If NULL is reurned, no record with correct "idx" has been found
2336
2337 */
2338 char *mapIdxToString(const T_IDX_TO_STR_MAP *table, BYTE index)
2339 {
2340 int i=0;
2341 while (table[i].cod NEQ NULL)
2342 {
2343 if (table[i].idx EQ index)
2344 return table[i].cod;
2345 i++;
2346 }
2347 return NULL;
2348 }
2349
2350 /*
2351 +-------------------------------------------------------------------+
2352 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2353 | ROUTINE : mapIdxToDigit |
2354 +-------------------------------------------------------------------+
2355
2356 PURPOSE : Find the occurence of the record of type T_IDX_TO_STR_MAP with "idx" field
2357 equal index and returns field "cod"
2358
2359 */
2360
2361 BYTE mapIdxToDigit(const T_IDX_TO_DIG_MAP *table, BYTE index, BYTE * result)
2362 {
2363 int i=0;
2364 while (table[i].cod NEQ NULL || table[i].idx NEQ NULL)
2365 {
2366 if (table[i].idx EQ index)
2367 {
2368 *result = table[i].cod;
2369 return 0;
2370 }
2371 i++;
2372 }
2373 return(BYTE)-1;
2374 }
2375
2376 #ifdef SIM_TOOLKIT
2377 /*
2378 +-------------------------------------------------------------------+
2379 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2380 | ROUTINE : cmhSS_SendToSAT |
2381 +-------------------------------------------------------------------+
2382
2383 PURPOSE : Send SS string to SIM
2384
2385 */
2386 T_ACI_RETURN cmhSS_SendToSAT(T_ACI_CMD_SRC srcId, CHAR *pSSString)
2387 {
2388 T_CLPTY_PRM *cldPty_sim;
2389 T_ACI_RETURN retVal;
2390
2391 TRACE_EVENT_P1("cmhSS_SendToSAT SS String = %s", pSSString);
2392
2393 retVal = AT_CMPL;
2394
2395 MALLOC(cldPty_sim, sizeof(T_CLPTY_PRM));
2396
2397 cmhCC_init_cldPty( cldPty_sim );
2398 cmh_bldCalPrms ( pSSString, cldPty_sim );
2399
2400 if( ksd_isSATSscs (cldPty_sim->num) )
2401 {
2402 retVal = cmhSAT_SSCntrlBySIM( cldPty_sim, (UBYTE)srcId );
2403 }
2404
2405 MFREE(cldPty_sim);
2406
2407 switch (retVal)
2408 {
2409 case AT_FAIL:
2410 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2411 break;
2412
2413 case AT_BUSY:
2414 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_SimBusy);
2415 break;
2416
2417 default:
2418 break;
2419 }
2420 return( retVal );
2421
2422 }
2423 #endif /* SIM_TOOLKIT */
2424 /*
2425 +-------------------------------------------------------------------+
2426 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2427 | ROUTINE : cmhSS_CF_SAT_Handle |
2428 +-------------------------------------------------------------------+
2429
2430 PURPOSE : Builds SS string from parameters of AT+CCFC command
2431 and sends to SIM
2432
2433 */
2434 T_ACI_RETURN cmhSS_CF_SAT_Handle(T_ACI_CMD_SRC srcId,
2435 T_ACI_CCFC_RSN reason,
2436 T_ACI_CCFC_MOD mode,
2437 CHAR* number,
2438 T_ACI_TOA* type,
2439 T_ACI_CLASS class_type,
2440 CHAR* subaddr,
2441 T_ACI_TOS* satype,
2442 SHORT time)
2443 {
2444
2445 int ii;
2446 BYTE bMapResult;
2447
2448 CHAR cSIString[MAX_DIAL_LEN];
2449 CHAR cSIbuf[MAX_DIAL_LEN];
2450 CHAR cSSString[MAX_DIAL_LEN];
2451
2452
2453 char *stReason;
2454 char *stMode;
2455 BYTE bBaseService;
2456
2457
2458 cSIString[0]= '\0';
2459
2460 TRACE_EVENT("cmhSS_CF_SAT_Handle()");
2461
2462
2463 stReason = mapIdxToString(cCFRsnMapTable/*lint -e40 */, reason);
2464 stMode = mapIdxToString(cModMapTable, mode);
2465 bMapResult = mapIdxToDigit(cCFBSMapTable, class_type, &bBaseService);
2466
2467
2468 if (stMode NEQ NULL AND stReason NEQ NULL)
2469 {
2470 /* Build SI string */
2471 for (ii=0; ii<3; ii++)
2472 {
2473 cSIbuf[0] = '\0';
2474 if (ii EQ 0) /* Step 1 - check Time */
2475 {
2476 if (time NEQ 0 AND reason NEQ CCFC_RSN_Uncond
2477 AND reason NEQ CCFC_RSN_Busy AND reason NEQ CCFC_RSN_NotReach) /*No time for these Service code*/
2478 {
2479 sprintf(cSIbuf, "%d", time);
2480 }
2481 }
2482 else if(ii EQ 1) /* Step 2 - check BS */
2483 {
2484 if (bMapResult EQ NULL)
2485 sprintf(cSIbuf, "%d", bBaseService);
2486 }
2487 else if(ii EQ 2) /* Step 3 - check DN */
2488 {
2489 if (number NEQ NULL)
2490 sprintf(cSIbuf, "%s", number);
2491 }
2492 strcat(cSIbuf, cSIString);
2493 if (strlen(cSIbuf) NEQ 0) /* If some parameters are already filled...*/
2494 {
2495 sprintf(cSIString, "*%s", cSIbuf);
2496 }
2497 }
2498
2499 sprintf(cSSString,"%s%s%s#",stMode, stReason, cSIString); /* Build SS string */
2500
2501 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2502 return checkFDNSendSS(srcId, cSSString);
2503 }
2504 else
2505 {
2506 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2507 return AT_FAIL;
2508 }
2509 }
2510
2511 /*
2512 +-------------------------------------------------------------------+
2513 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2514 | ROUTINE : cmhSS_CW_SAT_Handle |
2515 +-------------------------------------------------------------------+
2516
2517 PURPOSE : Builds SS string from parameters of AT+CCWA command
2518 and sends to SIM
2519
2520 */
2521 T_ACI_RETURN cmhSS_CW_SAT_Handle(T_ACI_CMD_SRC srcId,
2522 T_ACI_CCFC_MOD mode,
2523 T_ACI_CLASS class_type)
2524 {
2525
2526 BYTE bMapResult;
2527 CHAR cSSString[MAX_DIAL_LEN];
2528
2529 char *stMode;
2530 BYTE bBaseService;
2531
2532 TRACE_EVENT("cmhSS_CW_SAT_Handle()");
2533 stMode = mapIdxToString(cModMapTable, mode);
2534 bMapResult = mapIdxToDigit(cCFBSMapTable, class_type, &bBaseService);
2535
2536
2537 if (stMode NEQ NULL)
2538 {
2539 /* Build SS string */
2540 if (bMapResult NEQ 0)
2541 sprintf(cSSString,"%s43#",stMode);
2542 else
2543 sprintf(cSSString,"%s43*%d#",stMode, bBaseService);
2544
2545 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2546 return checkFDNSendSS(srcId, cSSString);
2547 }
2548 else
2549 {
2550 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2551 return AT_FAIL;
2552 }
2553 }
2554
2555 /*
2556 +-------------------------------------------------------------------+
2557 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2558 | ROUTINE : cmhSS_CLIP_SAT_Handle |
2559 +-------------------------------------------------------------------+
2560
2561 PURPOSE : Builds SS string from parameters of AT+CLIP command
2562 and sends to SIM
2563
2564 */
2565 T_ACI_RETURN cmhSS_CLIP_SAT_Handle(T_ACI_CMD_SRC srcId)
2566 {
2567 CHAR cSSString[] = "*#30#"; /* Only Query */
2568
2569 TRACE_EVENT("cmhSS_CLIP_SAT_Handle()");
2570
2571 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2572 return checkFDNSendSS(srcId, cSSString);
2573 }
2574
2575 /*
2576 +-------------------------------------------------------------------+
2577 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2578 | ROUTINE : cmhSS_CLIR_SAT_Handle |
2579 +-------------------------------------------------------------------+
2580
2581 PURPOSE : Builds SS string from parameters of AT+CLIR command
2582 and sends to SIM
2583
2584 */
2585 T_ACI_RETURN cmhSS_CLIR_SAT_Handle(T_ACI_CMD_SRC srcId)
2586 {
2587 CHAR cSSString[] = "*#31#"; /* Only Query */
2588
2589 TRACE_EVENT("cmhSS_CLIR_SAT_Handle()");
2590
2591 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2592 return checkFDNSendSS(srcId, cSSString);
2593 }
2594
2595 /*
2596 +-------------------------------------------------------------------+
2597 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2598 | ROUTINE : cmhSS_COLP_SAT_Handle |
2599 +-------------------------------------------------------------------+
2600
2601 PURPOSE : Builds SS string from parameters of AT+COLP command
2602 and sends to SIM
2603
2604 */
2605 T_ACI_RETURN cmhSS_COLP_SAT_Handle(T_ACI_CMD_SRC srcId)
2606 {
2607 CHAR cSSString[] = "*#76#"; /* Only Query */
2608
2609 TRACE_EVENT("cmhSS_COLP_SAT_Handle()");
2610
2611 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2612 return checkFDNSendSS(srcId, cSSString);
2613 }
2614
2615
2616 /*
2617 +-------------------------------------------------------------------+
2618 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2619 | ROUTINE : cmhSS_COLR_SAT_Handle |
2620 +-------------------------------------------------------------------+
2621
2622 PURPOSE : Builds SS string from parameters of AT+COLR command
2623 and sends to SIM
2624
2625 */
2626 T_ACI_RETURN cmhSS_COLR_SAT_Handle(T_ACI_CMD_SRC srcId)
2627 {
2628 CHAR cSSString[] = "*#77#"; /* Only Query */
2629
2630 TRACE_EVENT("cmhSS_COLR_SAT_Handle()");
2631
2632 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2633 return checkFDNSendSS(srcId, cSSString);
2634 }
2635
2636 /*
2637 +-------------------------------------------------------------------+
2638 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2639 | ROUTINE : cmhSS_CCBS_SAT_Handle |
2640 +-------------------------------------------------------------------+
2641
2642 PURPOSE : Builds SS string from parameters of AT+CCBS command
2643 and sends to SIM
2644
2645 */
2646 T_ACI_RETURN cmhSS_CCBS_SAT_Handle(T_ACI_CMD_SRC srcId, T_ACI_CCBS_MOD mode, SHORT idx)
2647 {
2648 char *stMode;
2649 CHAR cSSString[MAX_DIAL_LEN];
2650
2651 TRACE_EVENT("cmhSS_CCBS_SAT_Handle()");
2652
2653 stMode = mapIdxToString(cModMapTable, mode);
2654
2655 if (stMode NEQ NULL)
2656 {
2657 /* Build SS string */
2658 if (idx EQ -1) /* According to GSM 02.30 Index can vary 1..5*/
2659 sprintf(cSSString,"%s37#",stMode);
2660 else
2661 sprintf(cSSString,"%s37*%d#",stMode, idx);
2662
2663 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2664 return checkFDNSendSS(srcId, cSSString);
2665 }
2666 else
2667 {
2668 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2669 return AT_FAIL;
2670 }
2671 }
2672
2673 /*
2674 +-------------------------------------------------------------------+
2675 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2676 | ROUTINE : cmhSS_CNAP_SAT_Handle |
2677 +-------------------------------------------------------------------+
2678
2679 PURPOSE : Builds SS string from parameters of AT+CNAP command
2680 and sends to SIM
2681
2682 */
2683 T_ACI_RETURN cmhSS_CNAP_SAT_Handle(T_ACI_CMD_SRC srcId)
2684 {
2685 CHAR cSSString[] = "*#300#"; /* Only Query */
2686
2687 TRACE_EVENT("cmhSS_CNAP_SAT_Handle()");
2688
2689 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2690 return checkFDNSendSS(srcId, cSSString);
2691 }
2692
2693 /*
2694 +-------------------------------------------------------------------+
2695 | PROJECT : GSM-PS (6147) MODULE : CMH_SSF |
2696 | ROUTINE : cmhSS_Call_Barr_SAT_Handle |
2697 +-------------------------------------------------------------------+
2698
2699 PURPOSE : Builds SS string from parameters of AT+CLCK command
2700 and sends to SIM
2701
2702 */
2703 T_ACI_RETURN cmhSS_Call_Barr_SAT_Handle(T_ACI_CMD_SRC srcId,
2704 T_ACI_CLCK_MOD mode,
2705 T_ACI_FAC fac,
2706 CHAR *passwd,
2707 T_ACI_CLASS class_type)
2708 {
2709 int ii;
2710 BYTE bBaseService;
2711 BYTE bMapResult;
2712
2713 char *stMode;
2714 char *stFac;
2715
2716 CHAR cSIString[MAX_DIAL_LEN];
2717 CHAR cSIbuf[MAX_DIAL_LEN];
2718 CHAR cSSString[MAX_DIAL_LEN];
2719
2720
2721 TRACE_EVENT("cmhSS_Call_Barr_SAT_Handle()");
2722
2723 cSIString[0]= '\0';
2724
2725 stMode = mapIdxToString(cModMapTable, mode);
2726 stFac = mapIdxToString(cCBRsnMapTable, fac);
2727 bMapResult = mapIdxToDigit(cCFBSMapTable, class_type, &bBaseService);
2728
2729 if (stFac EQ NULL ) return AT_CMPL; /* If no call barring facility - continue executing sAT_PlusCLCK*/
2730
2731 if (stMode NEQ NULL)
2732 {
2733 for (ii=0; ii<2; ii++)
2734 {
2735 cSIbuf[0] = '\0';
2736 if(ii EQ 0) /* Step 2 - check BS */
2737 {
2738 if (bMapResult EQ NULL)
2739 sprintf(cSIbuf, "%d", bBaseService);
2740 }
2741 else if(ii EQ 1) /* Step 2 - check PW */
2742 {
2743 if (passwd NEQ NULL)
2744 sprintf(cSIbuf, "%s", passwd);
2745 }
2746 strcat(cSIbuf, cSIString);
2747 if (strlen(cSIbuf) NEQ 0) /* If some parameters are already filled...*/
2748 {
2749 sprintf(cSIString, "*%s", cSIbuf);
2750 }
2751 }
2752
2753 /* Build SS string */
2754 sprintf(cSSString,"%s%s%s#",stMode, stFac, cSIString); /* Build SS string */
2755
2756 /* check is FDN is on and string is in FDN phone book. If OK - send to STK */
2757 return checkFDNSendSS(srcId, cSSString);
2758
2759 }
2760 else
2761 {
2762 ACI_ERR_DESC( ACI_ERR_CLASS_Cme, CME_ERR_OpNotAllow );
2763 return AT_FAIL;
2764 }
2765 }
2766
2767 /* Implements Measure # 166 */
2768 /*
2769 +-------------------------------------------------------------------+
2770 | PROJECT : GSM-PS (6147) MODULE : CMH_SS |
2771 | STATE : code ROUTINE : cmhSMS_getSSCd |
2772 +-------------------------------------------------------------------+
2773 PARAMETERS : fac - CLCK facility for which SS code has to be
2774 returned.
2775 ssCd - SS Code is filled in this variable.
2776 RETURN : FALSE if unknown CLCK facility is passed
2777
2778 PURPOSE : This function returns the SS code for CLCK functions
2779
2780 */
2781
2782 GLOBAL BOOL cmhSS_getSSCd(T_ACI_FAC fac, UBYTE *ssCd)
2783 {
2784 /*
2785 *-------------------------------------------------------------------
2786 * check parameter <fac>
2787 *-------------------------------------------------------------------
2788 */
2789 switch( fac )
2790 {
2791 case( FAC_Ao ): *ssCd = SS_CD_BAOC; break;
2792 case( FAC_Oi ): *ssCd = SS_CD_BOIC; break;
2793 case( FAC_Ox ): *ssCd = SS_CD_BOICXH; break;
2794 case( FAC_Ai ): *ssCd = SS_CD_BAIC; break;
2795 case( FAC_Ir ): *ssCd = SS_CD_BICRM; break;
2796 case( FAC_Ab ): *ssCd = SS_CD_ALL_CBSS; break;
2797 case( FAC_Ag ): *ssCd = SS_CD_BOC; break;
2798 case( FAC_Ac ): *ssCd = SS_CD_BIC; break;
2799
2800 case( FAC_Sc ):
2801 case( FAC_Fd ):
2802 case( FAC_Al ):
2803 #ifdef SIM_PERS
2804 case( FAC_Pn ):
2805 case( FAC_Pu ):
2806 case( FAC_Pc ):
2807 case( FAC_Pp ):
2808 case( FAC_Ps ):
2809 case( FAC_Pf ):
2810 case( FAC_Bl ):
2811 case( FAC_Mu ):
2812 case( FAC_Mum ):
2813 #endif
2814 #ifdef FF_PHONE_LOCK
2815 case( FAC_Pl ):
2816 case( FAC_Apl):
2817 #endif
2818 *ssCd = NOT_PRESENT_8BIT; break;
2819
2820 case( FAC_NotPresent ):
2821 default:
2822
2823 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
2824 return( FALSE );
2825 }
2826 return TRUE;
2827 }
2828
2829 #if defined (SIM_PERS) || defined (FF_PHONE_LOCK)
2830
2831 /*
2832 +-------------------------------------------------------------------+
2833 | PROJECT : GSM-PS (6147) MODULE : CMH_SS |
2834 | STATE : code ROUTINE : cmhSS_check_oper_result |
2835 +-------------------------------------------------------------------+
2836 PARAMETERS : result - CLCK operation result for SIMP and Phone Lock .
2837
2838 RETURN : AT_CMPL for success and AT_FAIL for Failure case
2839
2840 PURPOSE : This function returns AT_CMPL for success case and
2841 returns AT_FAIL for Failure cases with proper Error code
2842
2843 */
2844
2845 T_ACI_RETURN cmhSS_check_oper_result(T_OPER_RET_STATUS result)
2846 {
2847
2848 switch( result )
2849 {
2850 case( OPER_SUCCESS ):
2851 return ( AT_CMPL );
2852
2853 case( OPER_WRONG_PASSWORD ):
2854 {
2855 ACI_ERR_DESC( ACI_ERR_CLASS_Cme,CME_ERR_WrongPasswd );
2856 return( AT_FAIL );
2857 }
2858 case( OPER_BUSY ):
2859 {
2860 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Busy );
2861 return( AT_FAIL );
2862 }
2863
2864 default:
2865 ACI_ERR_DESC( ACI_ERR_CLASS_Cme,CME_ERR_Unknown );
2866 return( AT_FAIL );
2867
2868 }
2869
2870 }
2871
2872 #endif
2873
2874 /* Implements Measure # 38 */
2875 /*
2876 +-------------------------------------------------------------------+
2877 | PROJECT : GSM-PS (6147) MODULE : CMH_SS |
2878 | STATE : code ROUTINE : cmhSS_ksdCWCBStartTrans |
2879 +-------------------------------------------------------------------+
2880 PARAMETERS : srcId - source of AT Command
2881 ksdCmd- Contains KSD command identifier. Used to
2882 identify whether to operate on key sequence
2883 command for CB or for CW supplementary services
2884
2885 seqPrm - T_KSD_SEQPARAM structure containing the CB
2886 and CW parameter information
2887 RETURN : Status of operation
2888 PURPOSE : This function invokes the operation for key sequence
2889 command for CB and CW supplementary services.
2890 */
2891
2892 GLOBAL T_ACI_RETURN cmhSS_ksdCWCBStartTrans(T_ACI_CMD_SRC srcId,
2893 T_ACI_KSD_CMD ksdCmd,
2894 T_KSD_SEQPARAM *seqPrm)
2895 {
2896 SHORT sId; /* holds service id */
2897 UBYTE bst,bs, opCd, ssCd, bsCd;
2898
2899 if(ksdCmd EQ KSD_CMD_CB)
2900 {
2901 /*
2902 *-------------------------------------------------------------------
2903 * check parameter ss code
2904 *-------------------------------------------------------------------
2905 */
2906 switch( seqPrm->cb.ssCd )
2907 {
2908 case( KSD_SS_BOC ):
2909 case( KSD_SS_BOICXH ):
2910 case( KSD_SS_BOIC ):
2911 case( KSD_SS_ALL_CBSS ):
2912 case( KSD_SS_BAOC ):
2913 case( KSD_SS_BIC ):
2914 case( KSD_SS_BAIC ):
2915 case( KSD_SS_BICRM ):
2916
2917 break;
2918
2919 default:
2920
2921 return( AT_FAIL );
2922 }
2923 opCd = seqPrm->cb.opCd;
2924 ssCd = seqPrm->cb.ssCd;
2925 bsCd = seqPrm->cb.bsCd;
2926 }
2927 else if(ksdCmd EQ KSD_CMD_CW)
2928 {
2929 opCd = seqPrm->cw.opCd;
2930 ssCd = KSD_SS_CW;
2931 bsCd = seqPrm->cw.bsCd;
2932 }
2933 else
2934 {
2935 return( AT_FAIL );
2936 }
2937 /*
2938 *-------------------------------------------------------------------
2939 * check parameter basic service code
2940 *-------------------------------------------------------------------
2941 */
2942 if( !cmhSS_CheckBscSrv( bsCd, &bs, &bst, NULL ))
2943 {
2944 return( AT_FAIL );
2945 }
2946 /*
2947 *-------------------------------------------------------------------
2948 * get a new service table entry
2949 *-------------------------------------------------------------------
2950 */
2951 sId = psaSS_stbNewEntry();
2952
2953 if( sId EQ NO_ENTRY )
2954 {
2955 return( AT_FAIL );
2956 }
2957
2958 /*
2959 *-------------------------------------------------------------------
2960 * check parameter operation code
2961 *-------------------------------------------------------------------
2962 */
2963 CCD_START;
2964
2965 switch( opCd )
2966 {
2967 /* interrogate call forwarding service */
2968 case( KSD_OP_IRGT ):
2969 psaSS_asmInterrogateSS( ssCd, bst, bs );
2970 break;
2971
2972 /* activate call forwarding service */
2973 case( KSD_OP_ACT ):
2974 psaSS_asmActivateSS( ssCd, bst, bs );
2975 break;
2976
2977 /* deactivate call forwarding service */
2978 case( KSD_OP_DEACT ):
2979 psaSS_asmDeactivateSS( ssCd, bst, bs );
2980 break;
2981
2982 /* register call forwarding service */
2983 case( KSD_OP_REG ):
2984 /* erase call forwarding service */
2985 case( KSD_OP_ERS ):
2986 /* unexpected operation code */
2987 default:
2988
2989 CCD_END;
2990 return( AT_FAIL );
2991 }
2992
2993 /*
2994 *-------------------------------------------------------------------
2995 * start transaction
2996 *-------------------------------------------------------------------
2997 */
2998 ssShrdPrm.stb[sId].ntryUsdFlg = TRUE;
2999 ssShrdPrm.stb[sId].ssCode = ssCd;
3000 ssShrdPrm.stb[sId].orgOPC = opCd;
3001 ssShrdPrm.stb[sId].opCode = opCd;
3002 ssShrdPrm.stb[sId].srvOwn = (T_OWN)srcId;
3003 ssShrdPrm.stb[sId].curCmd = (T_ACI_AT_CMD)ksdCmd;
3004
3005 psaSS_NewTrns(sId);
3006
3007 CCD_END;
3008 /*
3009 *-------------------------------------------------------------------
3010 * store password for later use
3011 *-------------------------------------------------------------------
3012 */
3013 if(ksdCmd EQ KSD_CMD_CB)
3014 {
3015 if( seqPrm->cb.pwd )
3016 {
3017 strncpy
3018 (
3019 (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
3020 (char *) seqPrm->cb.pwd,
3021 MAX_PWD_NUM
3022 );
3023 cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
3024 }
3025 else
3026 {
3027 /* No password was given reset to default */
3028 /* Implements Measure#32: Row 1115 */
3029 strncpy
3030 (
3031 (char *) cmhPrm[srcId].ssCmdPrm.CXXXpwd,
3032 ffff_str,
3033 MAX_PWD_NUM
3034 );
3035 cmhPrm[srcId].ssCmdPrm.CXXXpwd[MAX_PWD_NUM] = '\0';
3036 }
3037 }
3038 #if defined SMI OR defined MFW OR defined FF_MMI_RIV
3039 if( srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT )
3040 {
3041 T_ACI_CLOG cmdLog; /* holds logging info */
3042 cmdLog.cmdType = CLOG_TYPE_Set;
3043 cmdLog.retCode = AT_EXCT;
3044 cmdLog.cId = ACI_NumParmNotPresent;
3045 cmdLog.sId = sId+1;
3046 cmdLog.atCmd = (T_ACI_AT_CMD)ksdCmd;
3047
3048 if(ksdCmd EQ KSD_CMD_CB)
3049 {
3050 cmdLog.cmdPrm.sKSCB.srcId = srcId;
3051 cmdLog.cmdPrm.sKSCB.opCd = seqPrm->cb.opCd;
3052 cmdLog.cmdPrm.sKSCB.ssCd = seqPrm->cb.ssCd;
3053 cmdLog.cmdPrm.sKSCB.bsTp = bst;
3054 cmdLog.cmdPrm.sKSCB.bsCd = bs;
3055 cmdLog.cmdPrm.sKSCB.pwd = seqPrm->cb.pwd;
3056 }
3057 else
3058 {
3059 cmdLog.cmdPrm.sKSCW.srcId = srcId;
3060 cmdLog.cmdPrm.sKSCW.opCd = seqPrm->cw.opCd;
3061 cmdLog.cmdPrm.sKSCW.bsTp = bst;
3062 cmdLog.cmdPrm.sKSCW.bsCd = bs;
3063 }
3064 rAT_PercentCLOG( &cmdLog );
3065 }
3066 #endif
3067
3068 return AT_EXCT;
3069 }
3070 /* Implements Measure # 85 */
3071 /*
3072 +-------------------------------------------------------------------+
3073 | PROJECT : GSM-PS (6147) MODULE : CMH_SS |
3074 | STATE : code ROUTINE : cmhSS_checkCCFC_RSN |
3075 +-------------------------------------------------------------------+
3076 PARAMETERS : reason - T_ACI_CCFC_RSN that has to be converted to
3077 appropriate SS code
3078 ssCd - Parameter in which SS Code is filled
3079 RETURN : Boolean value indicates FALSE if unknown T_ACI_CCFC_RSN
3080 is sent
3081 PURPOSE : This function converts the T_ACI_CCFC_RSN to the
3082 appropriate ss Code.
3083 */
3084
3085 GLOBAL BOOL cmhSS_checkCCFC_RSN(T_ACI_CCFC_RSN reason, UBYTE *ssCd)
3086 {
3087 /*
3088 *-------------------------------------------------------------------
3089 * check parameter <reason>
3090 *-------------------------------------------------------------------
3091 */
3092 switch( reason )
3093 {
3094 case( CCFC_RSN_Uncond ): *ssCd = SS_CD_CFU; break;
3095 case( CCFC_RSN_Busy ): *ssCd = SS_CD_CFB; break;
3096 case( CCFC_RSN_NoReply ): *ssCd = SS_CD_CFNRY; break;
3097 case( CCFC_RSN_NotReach ): *ssCd = SS_CD_CFNRC; break;
3098 case( CCFC_RSN_Forward ): *ssCd = SS_CD_ALL_FWSS; break;
3099 case( CCFC_RSN_CondForward ): *ssCd = SS_CD_ALL_CFWSS; break;
3100
3101 case( CCFC_RSN_NotPresent ):
3102 default:
3103 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter );
3104 return( FALSE );
3105 }
3106 return TRUE;
3107 }
3108
3109 /*==== EOF ========================================================*/