FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/cmh_ssf.c @ 0:75a11d740a02
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 ========================================================*/ |