FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/cmh_smsf.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_SMSF | |
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 short message service. | |
19 +----------------------------------------------------------------------------- | |
20 */ | |
21 | |
22 #ifndef CMH_SMSF_C | |
23 #define CMH_SMSF_C | |
24 #endif | |
25 | |
26 #include "config.h" | |
27 #include "fixedconf.h" | |
28 #include "condat-features.h" | |
29 #include "aci_conf.h" | |
30 | |
31 #include "aci_all.h" | |
32 /*==== INCLUDES ===================================================*/ | |
33 #include "aci_cmh.h" | |
34 #include "ati_cmd.h" | |
35 #include "aci_cmd.h" | |
36 | |
37 #ifdef FAX_AND_DATA | |
38 #include "aci_fd.h" | |
39 #endif /* of #ifdef FAX_AND_DATA */ | |
40 | |
41 #include "aci.h" | |
42 #include "aci_lst.h" | |
43 #include "aci_mem.h" | |
44 #include "psa.h" | |
45 #include "psa_cc.h" | |
46 #ifdef SIM_TOOLKIT | |
47 #include "psa_sat.h" | |
48 #endif | |
49 #include "psa_sms.h" | |
50 #include "psa_sim.h" | |
51 #include "psa_mmi.h" | |
52 #include "psa_util.h" | |
53 #include "phb.h" | |
54 #include "cmh.h" | |
55 #include "cmh_sms.h" | |
56 #include "pcm.h" | |
57 | |
58 #include "aci_lst.h" | |
59 | |
60 #if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_) | |
61 #include "conc_sms.h" | |
62 #endif /* ##if (defined (MFW) AND !defined (FF_MMI_RIV)) OR defined (_CONC_TESTING_)*/ | |
63 | |
64 | |
65 #ifdef UART | |
66 #include "dti_conn_mng.h" | |
67 #endif | |
68 | |
69 #include "cmh_sim.h" | |
70 #ifndef _SIMULATION_ | |
71 | |
72 /* temporary solution to get ffs.h included without GPRS to be set ! */ | |
73 #ifdef GPRS | |
74 #include "../../services/ffs/ffs.h" | |
75 #else | |
76 #include "../../services/ffs/ffs.h" | |
77 #undef GPRS | |
78 #endif /* GPRS */ | |
79 | |
80 #include "ffs_coat.h" | |
81 | |
82 #endif /* !_SIMULATION_ */ | |
83 | |
84 #ifdef FF_CPHS | |
85 #include "cphs.h" | |
86 #endif /* FF_CPHS */ | |
87 | |
88 /*==== CONSTANTS ==================================================*/ | |
89 #define CMMS_MODE_TIMER_VAL (5000) | |
90 #define SMS_CMH_YEAR_MAX (99) /* maximum value for year in */ | |
91 /* absolute validity period */ | |
92 #define SMS_CMH_YEAR_MIN (0) /* minimum value for year in */ | |
93 /* absolute validity period */ | |
94 #define SMS_CMH_MONTH_MAX (12) /* maximum value for month in */ | |
95 /* absolute validity period */ | |
96 #define SMS_CMH_MONTH_MIN (1) /* minimum value for month in */ | |
97 /* absolute validity period */ | |
98 #define SMS_CMH_DAY_MAX (31) /* maximum value for day in */ | |
99 /* absolute validity period */ | |
100 #define SMS_CMH_DAY_MIN (1) /* minimum value for day in */ | |
101 /* absolute validity period */ | |
102 #define SMS_CMH_HOUR_MAX (23) /* maximum value for hour in */ | |
103 /* absolute validity period */ | |
104 #define SMS_CMH_HOUR_MIN (0) /* minimum value for hour in */ | |
105 /* absolute validity period */ | |
106 #define SMS_CMH_MINUTE_MAX (59) /* maximum value for minute in */ | |
107 /* absolute validity period */ | |
108 #define SMS_CMH_MINUTE_MIN (0) /* minimum value for minute in */ | |
109 /* absolute validity period */ | |
110 #define SMS_CMH_SECOND_MAX (59) /* maximum value for second in */ | |
111 /* absolute validity period */ | |
112 #define SMS_CMH_SECOND_MIN (0) /* minimum value for second in */ | |
113 /* absolute validity period */ | |
114 | |
115 #define SMS_CMH_TZ_MAX (47) /* maximum value for a time */ | |
116 /* zone in absolute validity */ | |
117 /* period */ | |
118 #define SMS_CMH_TZ_MIN (-47) /* minimum value for a time */ | |
119 /* zone in absolute validity */ | |
120 /* period */ | |
121 | |
122 | |
123 /* macro for converting a two digit BCD into an UBYTE */ | |
124 #define BCD2UBYTE(bcd) (UBYTE)(10 * bcd[0] + bcd[1]) | |
125 | |
126 /* macro for testing whether any digit of a two digit */ | |
127 /* BCD lies outside of a predefined value range */ | |
128 #define NOTBCD(bcd) (bcd[0] > 9 OR\ | |
129 bcd[1] > 9 ) | |
130 | |
131 | |
132 #define L_MAX_UD 140 | |
133 #define L_MAX_UD_CONC 134 | |
134 | |
135 #ifdef FF_CPHS_REL4 | |
136 typedef enum | |
137 { | |
138 MSG_WAITING_TYPE_INVALID = -1, | |
139 MSG_WAITING_TYPE_VOICE, | |
140 MSG_WAITING_TYPE_FAX, | |
141 MSG_WAITING_TYPE_EMAIL, | |
142 MSG_WAITING_TYPE_OTHER | |
143 } T_MSG_WAITING_TYPE; | |
144 #endif | |
145 | |
146 /*==== TYPES ======================================================*/ | |
147 | |
148 /*==== EXPORT =====================================================*/ | |
149 EXTERN T_ACI_LIST *set_prm_list; | |
150 | |
151 /*==== PROTOTYPES==================================================*/ | |
152 /* Implements Measure # 73 */ | |
153 LOCAL BOOL cmhSMS_findMessageIds (USHORT lower_mid, USHORT upper_mid); | |
154 /* Implements Measure # 126 */ | |
155 LOCAL void cmhSMS_processOrigDestAddr (T_ACI_CMGL_SM *sm, | |
156 T_rp_addr *rp_addr, | |
157 T_tp_da *tp_addr ); | |
158 /* Implements Measure # 9 */ | |
159 LOCAL void cmhSMS_clearCbmPrm (void); | |
160 | |
161 | |
162 /*==== VARIABLES ==================================================*/ | |
163 | |
164 const char * const ffs_smsprfl_fname[] = { FFS_SMSPRFL_FNAME01, | |
165 FFS_SMSPRFL_FNAME02, | |
166 FFS_SMSPRFL_FNAME03, | |
167 FFS_SMSPRFL_FNAME04 }; | |
168 | |
169 /*==== FUNCTIONS ==================================================*/ | |
170 | |
171 /* | |
172 +--------------------------------------------------------------------+ | |
173 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
174 | STATE : code ROUTINE : aci_encodeVpenh | | |
175 +--------------------------------------------------------------------+ | |
176 | |
177 PURPOSE : This function encodes a given T_ACI_VP_ENH type to a | |
178 string. | |
179 */ | |
180 GLOBAL void aci_encodeVpenh ( CHAR* vpenh_str, | |
181 T_ACI_VP_ENH* vpenh ) | |
182 { | |
183 UBYTE pos; | |
184 | |
185 /* functionality indicator */ | |
186 utl_binToHex (&vpenh->func_ind, 1, vpenh_str); | |
187 pos = 2; | |
188 | |
189 /* extension octet */ | |
190 if (vpenh->func_ind & TP_VPF_ENH_EXT_BIT_MASK) | |
191 { | |
192 utl_binToHex (&vpenh->ext_oct, 1, vpenh_str+pos); | |
193 pos += 2; | |
194 } | |
195 | |
196 /* process validity period values */ | |
197 if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_REL) | |
198 { | |
199 utl_binToHex (&vpenh->val.vpenh_relative, 1, vpenh_str+pos ); | |
200 pos += 2; | |
201 } | |
202 else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_SEC) | |
203 { | |
204 utl_binToHex (&vpenh->val.vpenh_seconds, 1, vpenh_str+pos ); | |
205 pos += 2; | |
206 } | |
207 else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS) | |
208 { | |
209 vpenh_str[pos++] = vpenh->val.vpenh_hours.hour[1] + '0'; | |
210 vpenh_str[pos++] = vpenh->val.vpenh_hours.hour[0] + '0'; | |
211 | |
212 vpenh_str[pos++] = vpenh->val.vpenh_hours.minute[1] + '0'; | |
213 vpenh_str[pos++] = vpenh->val.vpenh_hours.minute[0] + '0'; | |
214 | |
215 vpenh_str[pos++] = vpenh->val.vpenh_hours.second[1] + '0'; | |
216 vpenh_str[pos++] = vpenh->val.vpenh_hours.second[0] + '0'; | |
217 } | |
218 | |
219 /* fill the rest with zeros */ | |
220 while (pos < 14) | |
221 { | |
222 vpenh_str[pos++] = '0'; | |
223 } | |
224 | |
225 /* string terminator */ | |
226 vpenh_str[pos] = '\0'; | |
227 } | |
228 | |
229 /* | |
230 +-------------------------------------------------------------------+ | |
231 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
232 | STATE : code ROUTINE : cmhSMS_getNType | | |
233 +-------------------------------------------------------------------+ | |
234 | |
235 PURPOSE : This function calculates the 'numbering type' out of the | |
236 current 'type of numbering'. | |
237 */ | |
238 GLOBAL UBYTE cmhSMS_getNType ( T_ACI_TOA_TON ton ) | |
239 { | |
240 switch( ton ) | |
241 { | |
242 case( TON_International ): | |
243 case( TON_National ): | |
244 case( TON_NetSpecific ): | |
245 case( TON_DedAccess ): | |
246 case( TON_Alphanumeric ): | |
247 case( TON_Abbreviated ): return (UBYTE)ton; | |
248 default: return SMS_TON_UNKNOWN; | |
249 } | |
250 } | |
251 | |
252 | |
253 GLOBAL BOOL cmhSMS_findPrflId ( UBYTE critrerium, void* elem ) | |
254 { | |
255 T_SMS_SET_PRM *compared = (T_SMS_SET_PRM*)elem; | |
256 if ( compared->prflId == critrerium ) | |
257 return TRUE; | |
258 else | |
259 return FALSE; | |
260 } | |
261 | |
262 /* | |
263 +-------------------------------------------------------------------+ | |
264 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
265 | STATE : code ROUTINE : cmhSMS_getTon | | |
266 +-------------------------------------------------------------------+ | |
267 | |
268 PURPOSE : This function calculates the 'type of numbering' out of | |
269 the current 'numbering type'. | |
270 */ | |
271 GLOBAL T_ACI_TOA_TON cmhSMS_getTon ( UBYTE ntype ) | |
272 { | |
273 switch( ntype ) | |
274 { | |
275 case( SMS_TON_UNKNOWN ): | |
276 case( SMS_TON_INTERNATIONAL ): | |
277 case( SMS_TON_NATIONAL ): | |
278 case( SMS_TON_NETWORK_SPEC ): | |
279 case( SMS_TON_SUBSCRIBER ): | |
280 case( SMS_TON_ALPHANUMERIC ): | |
281 case( SMS_TON_ABBREVIATED ): return (T_ACI_TOA_TON)ntype; | |
282 default: return TON_NotPresent; | |
283 } | |
284 } | |
285 | |
286 /* | |
287 +-------------------------------------------------------------------+ | |
288 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
289 | STATE : code ROUTINE : cmhSMS_getNPlan | | |
290 +-------------------------------------------------------------------+ | |
291 | |
292 PURPOSE : This function calculates the 'numbering plan' out of the | |
293 current 'numbering plan identification'. | |
294 */ | |
295 GLOBAL UBYTE cmhSMS_getNPlan ( T_ACI_TOA_NPI npi ) | |
296 { | |
297 switch( npi ) | |
298 { | |
299 case( NPI_IsdnTelephony ): | |
300 case( NPI_Data ): | |
301 case( NPI_Telex ): | |
302 case( NPI_National ): | |
303 case( NPI_Private ): return (UBYTE)npi; | |
304 default: return NPI_Unknown; | |
305 } | |
306 } | |
307 | |
308 /* | |
309 +-------------------------------------------------------------------+ | |
310 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
311 | STATE : code ROUTINE : cmhSMS_getNpi | | |
312 +-------------------------------------------------------------------+ | |
313 | |
314 PURPOSE : This function calculates the 'numbering plan | |
315 identification' out of the current 'numbering plan'. | |
316 */ | |
317 GLOBAL T_ACI_TOA_NPI cmhSMS_getNpi ( UBYTE nplan ) | |
318 { | |
319 switch( nplan ) | |
320 { | |
321 case( SMS_TON_UNKNOWN ): | |
322 case( SMS_NPI_ISDN ): | |
323 case( SMS_NPI_X121 ): | |
324 case( SMS_NPI_F69 ): | |
325 case( SMS_NPI_NATIONAL ): | |
326 case( SMS_NPI_PRIVATE ): return (T_ACI_TOA_NPI)nplan; | |
327 default: return NPI_NotPresent; | |
328 } | |
329 } | |
330 | |
331 /* | |
332 +-------------------------------------------------------------------+ | |
333 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
334 | STATE : code ROUTINE : cmhSMS_getStatCmh | | |
335 +-------------------------------------------------------------------+ | |
336 | |
337 PURPOSE : This function converts the message status from | |
338 PSA type to CMH type. | |
339 */ | |
340 GLOBAL void cmhSMS_getStatCmh ( UBYTE inStat, | |
341 T_ACI_SMS_STAT* outStat ) | |
342 { | |
343 switch( inStat & STAT_MASK ) | |
344 { | |
345 case( REC_UNREAD ): *outStat = SMS_STAT_RecUnread; break; | |
346 case( REC_READ ): *outStat = SMS_STAT_RecRead; break; | |
347 case( STO_UNSENT ): *outStat = SMS_STAT_StoUnsent; break; | |
348 case( STO_SENT ): *outStat = SMS_STAT_StoSent; break; | |
349 default: *outStat = SMS_STAT_NotPresent; | |
350 } | |
351 } | |
352 | |
353 /* | |
354 +-------------------------------------------------------------------+ | |
355 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
356 | STATE : code ROUTINE : cmhSMS_getStatPsa | | |
357 +-------------------------------------------------------------------+ | |
358 | |
359 PURPOSE : This function converts the message status from | |
360 CMH type to PSA type. | |
361 */ | |
362 GLOBAL BOOL cmhSMS_getStatPsa ( T_ACI_SMS_STAT inStat, | |
363 UBYTE* outStat ) | |
364 { | |
365 switch( inStat ) | |
366 { | |
367 case( SMS_STAT_RecUnread ): *outStat = REC_UNREAD; break; | |
368 case( SMS_STAT_RecRead ): *outStat = REC_READ; break; | |
369 case( SMS_STAT_StoUnsent ): *outStat = STO_UNSENT; break; | |
370 case( SMS_STAT_StoSent ): *outStat = STO_SENT; break; | |
371 default : return (FALSE); | |
372 } | |
373 | |
374 return ( TRUE ); | |
375 } | |
376 | |
377 /* | |
378 +-------------------------------------------------------------------+ | |
379 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
380 | STATE : code ROUTINE : cmhSMS_isVpabsVld | | |
381 +-------------------------------------------------------------------+ | |
382 | |
383 PURPOSE : This function is used to process whether the given | |
384 absolute validity period is valid. | |
385 | |
386 Note: This function checks whether every individual | |
387 time value is within a valid range. It does not | |
388 check whether the whole expression is valid. | |
389 */ | |
390 GLOBAL BOOL cmhSMS_isVpabsVld ( T_ACI_VP_ABS* vpabs ) | |
391 { | |
392 if ( BCD2UBYTE ( vpabs -> year ) > SMS_CMH_YEAR_MAX OR | |
393 BCD2UBYTE ( vpabs -> month ) < SMS_CMH_MONTH_MIN OR | |
394 BCD2UBYTE ( vpabs -> month ) > SMS_CMH_MONTH_MAX OR | |
395 BCD2UBYTE ( vpabs -> day ) < SMS_CMH_DAY_MIN OR | |
396 BCD2UBYTE ( vpabs -> day ) > SMS_CMH_DAY_MAX OR | |
397 BCD2UBYTE ( vpabs -> hour ) > SMS_CMH_HOUR_MAX OR | |
398 BCD2UBYTE ( vpabs -> minute ) > SMS_CMH_MINUTE_MAX OR | |
399 BCD2UBYTE ( vpabs -> second ) > SMS_CMH_SECOND_MAX OR | |
400 vpabs -> timezone < SMS_CMH_TZ_MIN OR | |
401 vpabs -> timezone > SMS_CMH_TZ_MAX OR | |
402 NOTBCD ( vpabs -> year ) OR | |
403 NOTBCD ( vpabs -> month ) OR | |
404 NOTBCD ( vpabs -> day ) OR | |
405 NOTBCD ( vpabs -> hour ) OR | |
406 NOTBCD ( vpabs -> minute ) OR | |
407 NOTBCD ( vpabs -> second ) ) | |
408 | |
409 return ( FALSE ); | |
410 | |
411 return ( TRUE ); | |
412 } | |
413 | |
414 /* | |
415 +-------------------------------------------------------------------+ | |
416 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
417 | STATE : code ROUTINE : cmhSMS_isVpenhVld | | |
418 +-------------------------------------------------------------------+ | |
419 | |
420 PURPOSE : This function is used to process whether the given | |
421 enhanced validity period is valid. | |
422 | |
423 Note: This function checks whether every individual | |
424 time value is within a valid range. It does not | |
425 check whether the whole expression is valid. | |
426 */ | |
427 GLOBAL BOOL cmhSMS_isVpenhVld ( T_ACI_VP_ENH* vpenh ) | |
428 { | |
429 if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) > TP_VPF_ENH_HRS) | |
430 { | |
431 return FALSE; | |
432 } | |
433 | |
434 if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS) | |
435 { | |
436 if ( BCD2UBYTE ( vpenh->val.vpenh_hours.minute ) > SMS_CMH_MINUTE_MAX OR | |
437 BCD2UBYTE ( vpenh->val.vpenh_hours.second ) > SMS_CMH_SECOND_MAX OR | |
438 NOTBCD ( vpenh->val.vpenh_hours.hour ) OR | |
439 NOTBCD ( vpenh->val.vpenh_hours.minute ) OR | |
440 NOTBCD ( vpenh->val.vpenh_hours.second ) ) | |
441 { | |
442 return ( FALSE ); | |
443 } | |
444 } | |
445 | |
446 return ( TRUE ); | |
447 } | |
448 | |
449 /* | |
450 +-------------------------------------------------------------------+ | |
451 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
452 | STATE : code ROUTINE : cmhSMS_setVpabsPsa | | |
453 +-------------------------------------------------------------------+ | |
454 | |
455 PURPOSE : This function is used to copy the elements of the | |
456 absolute validity period structure of the ACI to the | |
457 corresponding structure of the PSA. | |
458 | |
459 Note: Copying of the structure elements might be | |
460 dangerous when array size of time elements differ | |
461 from MAX_VP_ABS_DIGIT due to changes in PSA | |
462 declaration. | |
463 */ | |
464 GLOBAL void cmhSMS_setVpabsPsa ( T_tp_vp_abs* psaVp, | |
465 T_ACI_VP_ABS* cmhVp ) | |
466 { | |
467 USHORT i; /* used for counting */ | |
468 | |
469 BOOL isNegative = ( cmhVp->timezone & 0x8000 ); | |
470 SHORT tz = ( UBYTE ) cmhVp->timezone; | |
471 | |
472 for (i = 0; i < MAX_VP_ABS_DIGITS; i++) | |
473 { | |
474 psaVp -> year [i] = cmhVp -> year [i]; | |
475 psaVp -> month [i] = cmhVp -> month [i]; | |
476 psaVp -> day [i] = cmhVp -> day [i]; | |
477 psaVp -> hour [i] = cmhVp -> hour [i]; | |
478 psaVp -> minute[i] = cmhVp -> minute[i]; | |
479 psaVp -> second[i] = cmhVp -> second[i]; | |
480 } | |
481 | |
482 if ( isNegative ) | |
483 { | |
484 tz = -tz; | |
485 psaVp -> tz_sign = 1; | |
486 } | |
487 else | |
488 { | |
489 psaVp -> tz_sign = 0; | |
490 } | |
491 | |
492 psaVp -> tz_lsb = tz & 0x000F; | |
493 psaVp -> tz_msb = tz & 0x00F0; | |
494 } | |
495 | |
496 /* | |
497 +-------------------------------------------------------------------+ | |
498 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
499 | STATE : code ROUTINE : cmhSMS_setVpenhPsa | | |
500 +-------------------------------------------------------------------+ | |
501 | |
502 PURPOSE : This function is used to copy the elements of the | |
503 enhanced validity period structure of the ACI to the | |
504 corresponding structure of the PSA. | |
505 */ | |
506 GLOBAL void cmhSMS_setVpenhPsa ( T_tp_vp_enh* psaVp, | |
507 T_ACI_VP_ENH* cmhVp ) | |
508 { | |
509 memset(psaVp, 0, sizeof(T_tp_vp_enh)); | |
510 | |
511 if (cmhVp->func_ind & TP_VPF_ENH_EXT_BIT_MASK) | |
512 { | |
513 psaVp->tp_ext = SMS_EXT_INCLUDED; | |
514 psaVp->v_tp_rsrvd = 1; | |
515 psaVp->tp_rsrvd = cmhVp->ext_oct; | |
516 } | |
517 | |
518 if (cmhVp->func_ind & TP_VPF_ENH_SINGLE_SHOT_MASK) | |
519 { | |
520 psaVp->tp_ss = SMS_SS_SET; | |
521 } | |
522 | |
523 if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_NOT_PRESENT) | |
524 { | |
525 psaVp->tvpf = SMS_TVPF_NOT_PRESENT; | |
526 } | |
527 else if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_REL) | |
528 { | |
529 psaVp->tvpf = SMS_TVPF_RELATIVE; | |
530 psaVp->v_tp_vp_rel = 1; | |
531 psaVp->tp_vp_rel = cmhVp->val.vpenh_relative; | |
532 } | |
533 else if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_SEC) | |
534 { | |
535 psaVp->tvpf = SMS_TVPF_SECONDS; | |
536 psaVp->v_tp_vp_sec = 1; | |
537 psaVp->tp_vp_sec = cmhVp->val.vpenh_seconds; | |
538 } | |
539 else if ((cmhVp->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS) | |
540 { | |
541 psaVp->tvpf = SMS_TVPF_HOURS; | |
542 psaVp->v_hour = 1; | |
543 psaVp->hour[0] = cmhVp->val.vpenh_hours.hour[0]; | |
544 psaVp->hour[1] = cmhVp->val.vpenh_hours.hour[1]; | |
545 psaVp->v_minute = 1; | |
546 psaVp->minute[0] = cmhVp->val.vpenh_hours.minute[0]; | |
547 psaVp->minute[1] = cmhVp->val.vpenh_hours.minute[1]; | |
548 psaVp->v_second = 1; | |
549 psaVp->second[0] = cmhVp->val.vpenh_hours.second[0]; | |
550 psaVp->second[1] = cmhVp->val.vpenh_hours.second[1]; | |
551 } | |
552 else | |
553 { | |
554 TRACE_EVENT("[ERR] cmhSMS_setVpenhPsa: wrong type of validity period format"); | |
555 } | |
556 } | |
557 | |
558 /* | |
559 +-------------------------------------------------------------------+ | |
560 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
561 | STATE : code ROUTINE : cmhSMS_setVpabsCmh | | |
562 +-------------------------------------------------------------------+ | |
563 | |
564 PURPOSE : This function is used to copy the elements of the | |
565 absolute validity period structure of the PSA to the | |
566 corresponding structure of the ACI. | |
567 | |
568 Note: Copying of the structure elements might be | |
569 dangerous when array size of time elements differ | |
570 from MAX_VP_ABS_DIGIT due to changes in PSA | |
571 declaration. | |
572 */ | |
573 GLOBAL void cmhSMS_setVpabsCmh ( T_ACI_VP_ABS* cmhVp, | |
574 T_tp_vp_abs* psaVp ) | |
575 { | |
576 USHORT i; /* used for counting */ | |
577 SHORT tz; | |
578 | |
579 for (i = 0; i < MAX_VP_ABS_DIGITS; i++) | |
580 { | |
581 cmhVp -> year [i] = psaVp -> year [i]; | |
582 cmhVp -> month [i] = psaVp -> month [i]; | |
583 cmhVp -> day [i] = psaVp -> day [i]; | |
584 cmhVp -> hour [i] = psaVp -> hour [i]; | |
585 cmhVp -> minute[i] = psaVp -> minute[i]; | |
586 cmhVp -> second[i] = psaVp -> second[i]; | |
587 } | |
588 | |
589 tz = ((psaVp->tz_msb & 0x07) * 10) + psaVp->tz_lsb; /* BCD */ | |
590 | |
591 if (psaVp->tz_sign) | |
592 cmhVp -> timezone = -tz; | |
593 else | |
594 cmhVp -> timezone = tz; | |
595 } | |
596 | |
597 /* | |
598 +-------------------------------------------------------------------+ | |
599 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
600 | STATE : code ROUTINE : cmhSMS_setVpenhCmh | | |
601 +-------------------------------------------------------------------+ | |
602 | |
603 PURPOSE : This function is used to copy the elements of the | |
604 enhanced validity period structure of the PSA to the | |
605 corresponding structure of the ACI. | |
606 | |
607 */ | |
608 GLOBAL void cmhSMS_setVpenhCmh ( T_ACI_VP_ENH* cmhVp, | |
609 T_tp_vp_enh* psaVp ) | |
610 { | |
611 memset(cmhVp, 0, sizeof(T_ACI_VP_ENH)); | |
612 | |
613 cmhVp->func_ind = psaVp->tvpf; | |
614 | |
615 if ((psaVp->tp_ext EQ SMS_EXT_INCLUDED) AND (psaVp->v_tp_rsrvd)) | |
616 { | |
617 cmhVp->func_ind |= TP_VPF_ENH_EXT_BIT_MASK; | |
618 cmhVp->ext_oct = psaVp->tp_rsrvd; | |
619 } | |
620 | |
621 if (psaVp->tp_ss EQ SMS_SS_SET) | |
622 { | |
623 cmhVp->func_ind |= TP_VPF_ENH_SINGLE_SHOT_MASK; | |
624 } | |
625 | |
626 if (psaVp->tvpf EQ SMS_TVPF_NOT_PRESENT) | |
627 { | |
628 /* do nothing */ | |
629 } | |
630 else if ((psaVp->tvpf EQ SMS_TVPF_RELATIVE) AND (psaVp->v_tp_vp_rel)) | |
631 { | |
632 cmhVp->val.vpenh_relative = psaVp->tp_vp_rel; | |
633 } | |
634 else if ((psaVp->tvpf EQ SMS_TVPF_SECONDS) AND (psaVp->v_tp_vp_sec)) | |
635 { | |
636 cmhVp->val.vpenh_seconds = psaVp->tp_vp_sec; | |
637 } | |
638 else if (psaVp->tvpf EQ SMS_TVPF_HOURS) | |
639 { | |
640 if (psaVp->v_hour) | |
641 { | |
642 cmhVp->val.vpenh_hours.hour[0] = psaVp->hour[0]; | |
643 cmhVp->val.vpenh_hours.hour[1] = psaVp->hour[1]; | |
644 } | |
645 if (psaVp->v_minute) | |
646 { | |
647 cmhVp->val.vpenh_hours.minute[0] = psaVp->minute[0]; | |
648 cmhVp->val.vpenh_hours.minute[1] = psaVp->minute[1]; | |
649 } | |
650 if (psaVp->v_second) | |
651 { | |
652 cmhVp->val.vpenh_hours.second[0] = psaVp->second[0]; | |
653 cmhVp->val.vpenh_hours.second[1] = psaVp->second[1]; | |
654 } | |
655 } | |
656 else | |
657 { | |
658 TRACE_EVENT("[ERR] cmhSMS_setVpenhCmh: wrong type of validity period format"); | |
659 } | |
660 } | |
661 | |
662 /* | |
663 +--------------------------------------------------------------------+ | |
664 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
665 | STATE : code ROUTINE : cmhSMS_getAdrStr | | |
666 +--------------------------------------------------------------------+ | |
667 | |
668 PURPOSE : This function is used to convert the service center | |
669 address in BCD to the service center address as a string. | |
670 */ | |
671 GLOBAL UBYTE cmhSMS_getAdrStr ( CHAR* pStr, | |
672 UBYTE maxIdx, | |
673 UBYTE* pBcd, | |
674 UBYTE numDigits ) | |
675 { | |
676 UBYTE bcdIdx; | |
677 UBYTE strIdx = 0; | |
678 | |
679 memset(pStr, 0x00, maxIdx); | |
680 | |
681 for(bcdIdx = 0; bcdIdx < numDigits AND strIdx < maxIdx; bcdIdx++) | |
682 { | |
683 switch (pBcd[bcdIdx]) | |
684 { | |
685 case 0: | |
686 case 1: | |
687 case 2: | |
688 case 3: | |
689 case 4: | |
690 case 5: | |
691 case 6: | |
692 case 7: | |
693 case 8: | |
694 case 9: | |
695 pStr[strIdx++] = pBcd[bcdIdx] + '0'; | |
696 break; | |
697 | |
698 case BCD_ASTSK: | |
699 pStr[strIdx++] = '*'; | |
700 break; | |
701 | |
702 case BCD_PND: | |
703 pStr[strIdx++] = '#'; | |
704 break; | |
705 | |
706 case BCD_A: | |
707 pStr[strIdx++] = 'A'; | |
708 break; | |
709 | |
710 case BCD_B: | |
711 pStr[strIdx++] = 'B'; | |
712 break; | |
713 | |
714 case BCD_C: | |
715 pStr[strIdx++] = 'C'; | |
716 break; | |
717 } | |
718 } | |
719 | |
720 pStr[strIdx] = '\0'; | |
721 | |
722 return ( strIdx ); | |
723 } | |
724 | |
725 /* | |
726 +--------------------------------------------------------------------+ | |
727 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
728 | STATE : code ROUTINE : cmhSMS_getAdrBcd | | |
729 +--------------------------------------------------------------------+ | |
730 | |
731 PURPOSE : This function is used to convert the service center | |
732 address as a string to the service center address in BCD. | |
733 */ | |
734 GLOBAL void cmhSMS_getAdrBcd ( UBYTE* pBcd, | |
735 UBYTE* pNumDigits, | |
736 UBYTE maxDigits, | |
737 CHAR* pStr ) | |
738 { | |
739 UBYTE bcdIdx = 0; | |
740 UBYTE strIdx; | |
741 | |
742 for(strIdx = 0; bcdIdx < maxDigits AND pStr[strIdx] NEQ '\0'; strIdx++) | |
743 { | |
744 switch (pStr[strIdx]) | |
745 { | |
746 case '0': | |
747 case '1': | |
748 case '2': | |
749 case '3': | |
750 case '4': | |
751 case '5': | |
752 case '6': | |
753 case '7': | |
754 case '8': | |
755 case '9': | |
756 pBcd[bcdIdx++] = pStr[strIdx] - '0'; | |
757 break; | |
758 | |
759 case '*': | |
760 pBcd[bcdIdx++] = BCD_ASTSK; | |
761 break; | |
762 | |
763 case '#': | |
764 pBcd[bcdIdx++] = BCD_PND; | |
765 break; | |
766 | |
767 case 'A': | |
768 pBcd[bcdIdx++] = BCD_A; | |
769 break; | |
770 | |
771 case 'B': | |
772 pBcd[bcdIdx++] = BCD_B; | |
773 break; | |
774 | |
775 case 'C': | |
776 pBcd[bcdIdx++] = BCD_C; | |
777 break; | |
778 } | |
779 } | |
780 | |
781 *pNumDigits = bcdIdx; | |
782 } | |
783 | |
784 /* | |
785 +--------------------------------------------------------------------+ | |
786 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
787 | STATE : code ROUTINE : cmhSMS_getAdrAlphaNum | | |
788 +--------------------------------------------------------------------+ | |
789 | |
790 PURPOSE : This function is used to pack the Alphanumeric | |
791 Destination Adress according to 23.038 | |
792 */ | |
793 GLOBAL T_ACI_RETURN cmhSMS_packAlphaNumAddr( CHAR* da, | |
794 T_tp_da* da_addr) | |
795 { | |
796 UBYTE dest[((MAX_SMS_ADDR_DIG/2) * 8) / 7]; | |
797 UBYTE dest_len; | |
798 USHORT dalen; | |
799 | |
800 if( (da NEQ NULL) AND (da_addr NEQ NULL) ) | |
801 { | |
802 dalen = strlen(da); | |
803 | |
804 dest_len = utl_cvt8To7( (UBYTE*)da, (UBYTE)dalen, dest, 0); | |
805 | |
806 if( dest_len > (MAX_SMS_ADDR_DIG/2) ) | |
807 { | |
808 TRACE_EVENT("DA length is greater then the supported length"); | |
809 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr ); | |
810 return(AT_FAIL); | |
811 } | |
812 if( ((dalen + 3) %7) <= 3 ) | |
813 { | |
814 da_addr->c_num = (dest_len*2) - 1; /* odd number of usefull nibbles */ | |
815 } | |
816 else | |
817 { | |
818 da_addr->c_num = dest_len*2; /* even number of usefull nibbles */ | |
819 } | |
820 | |
821 cmh_unpackBCD(da_addr->num, dest, dest_len ); | |
822 da_addr->digits = da_addr->c_num; | |
823 } | |
824 | |
825 return(AT_CMPL); | |
826 } | |
827 | |
828 /* | |
829 +-------------------------------------------------------------------+ | |
830 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
831 | STATE : code ROUTINE : cmhSMS_getMemCmh | | |
832 +-------------------------------------------------------------------+ | |
833 | |
834 PURPOSE : This function converts the preferred memory from | |
835 PSA type to CMH type. | |
836 */ | |
837 GLOBAL void cmhSMS_getMemCmh ( UBYTE inMem, T_ACI_SMS_STOR* outMem ) | |
838 { | |
839 switch( inMem ) | |
840 { | |
841 case( MEM_ME ): *outMem = SMS_STOR_Me; break; | |
842 case( MEM_SM ): *outMem = SMS_STOR_Sm; break; | |
843 } | |
844 } | |
845 | |
846 /* | |
847 +-------------------------------------------------------------------+ | |
848 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
849 | STATE : code ROUTINE : cmhSMS_getMemPsa | | |
850 +-------------------------------------------------------------------+ | |
851 | |
852 PURPOSE : This function converts the preferred memory from | |
853 CMH type to PSA type. | |
854 | |
855 returns: TRUE if conversion was successfull, | |
856 otherwise FALSE | |
857 */ | |
858 GLOBAL BOOL cmhSMS_getMemPsa ( T_ACI_SMS_STOR inMem, UBYTE* outMem ) | |
859 { | |
860 switch( inMem ) | |
861 { | |
862 case( SMS_STOR_Me ): *outMem = MEM_ME; break; | |
863 case( SMS_STOR_Sm ): *outMem = MEM_SM; break; | |
864 default : return ( FALSE ); | |
865 } | |
866 | |
867 return ( TRUE ); | |
868 } | |
869 | |
870 /* | |
871 +--------------------------------------------------------------------+ | |
872 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
873 | STATE : code ROUTINE : cmhSMS_getAlphabetPp | | |
874 +--------------------------------------------------------------------+ | |
875 | |
876 PURPOSE : This function is used to extract the used alphabet out | |
877 of the data coding scheme for point-to-point SMS. | |
878 */ | |
879 GLOBAL UBYTE cmhSMS_getAlphabetPp ( UBYTE dcs ) | |
880 { | |
881 UBYTE alphabet = 0; /* means 7 bit default alphabet */ | |
882 | |
883 switch (dcs & 0xF0) | |
884 { | |
885 case( 0x30 ): | |
886 case( 0x20 ): | |
887 alphabet = 0x01; /* compressed, counts as 8 bit data */ | |
888 break; | |
889 case( 0x10 ): | |
890 case( 0x00 ): | |
891 alphabet = (dcs & 0x0C) >> 2; | |
892 if (alphabet EQ 3) | |
893 alphabet = 0; /* reserved coding */ | |
894 break; | |
895 case( 0xE0 ): | |
896 alphabet = 0x02; /* UCS2 */ | |
897 break; | |
898 case( 0xF0 ): | |
899 alphabet = (dcs & 0x04) >> 2; | |
900 break; | |
901 } | |
902 | |
903 return alphabet; | |
904 } | |
905 | |
906 /* | |
907 +-------------------------------------------------------------------+ | |
908 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
909 | STATE : code ROUTINE : cmhSMS_expdSmsPp | | |
910 +-------------------------------------------------------------------+ | |
911 | |
912 PURPOSE : This function expands a point-to-point SMS from | |
913 7 to 8 bit. | |
914 */ | |
915 GLOBAL void cmhSMS_expdSmsPp ( UBYTE byte_offset, | |
916 UBYTE dcs, | |
917 UBYTE* source, | |
918 UBYTE source_len, | |
919 UBYTE* dest, | |
920 UBYTE* dest_len ) | |
921 { | |
922 UBYTE alphabet; | |
923 UBYTE bit_offset = 0; | |
924 | |
925 TRACE_FUNCTION ("cmhSMS_expdSmsPp ()"); | |
926 | |
927 | |
928 alphabet = cmhSMS_getAlphabetPp ( dcs ); | |
929 | |
930 switch (alphabet) | |
931 { | |
932 case( 0 ): /* 7 bit alphabet */ | |
933 | |
934 if ( byte_offset % 7 NEQ 0 ) | |
935 { | |
936 bit_offset = 7 - ((byte_offset*8) % 7); | |
937 } | |
938 | |
939 *dest_len = source_len - ((byte_offset*8+6)/7); /* adjust byte_offset to septets */ | |
940 | |
941 /* In 7-Bit mode we get number of septets but we need octets */ | |
942 source_len = (source_len*7+7)/8; /* round up to next octet*/ | |
943 source_len -= byte_offset; | |
944 | |
945 utl_cvt7To8 ( source, source_len, dest, bit_offset); | |
946 | |
947 | |
948 break; | |
949 | |
950 default: /* 8 bit alphabet, UCS2, reserved */ | |
951 | |
952 *dest_len = source_len-byte_offset; | |
953 memcpy ( (CHAR*) dest, (CHAR*)source, *dest_len ); | |
954 break; | |
955 } | |
956 } | |
957 | |
958 /* | |
959 +-------------------------------------------------------------------+ | |
960 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
961 | STATE : code ROUTINE : cmhSMS_rdcSmsPp | | |
962 +-------------------------------------------------------------------+ | |
963 | |
964 PURPOSE : This function reduces a point-to-point SMS from | |
965 8 to 7 bit. | |
966 */ | |
967 GLOBAL void cmhSMS_rdcSmsPp ( UBYTE byte_offset, | |
968 UBYTE dcs, | |
969 UBYTE* source, | |
970 UBYTE source_len, | |
971 UBYTE* dest, | |
972 UBYTE* dest_len ) | |
973 { | |
974 UBYTE data_len; | |
975 UBYTE alphabet; | |
976 UBYTE bit_offset = 0; | |
977 | |
978 TRACE_FUNCTION ("cmhSMS_rdcSmsPp ()"); | |
979 | |
980 if (source_len EQ 0) | |
981 { | |
982 *dest_len = source_len; | |
983 return; | |
984 } | |
985 | |
986 alphabet = cmhSMS_getAlphabetPp ( dcs ); | |
987 | |
988 switch (alphabet) | |
989 { | |
990 case( 0 ): /* 7 bit alphabet */ | |
991 | |
992 if ( byte_offset % 7 NEQ 0 ) | |
993 { | |
994 bit_offset = 7 - ((byte_offset*8) % 7); | |
995 } | |
996 | |
997 data_len = MINIMUM (source_len, (SMS_MSG_LEN * 8) / 7); | |
998 | |
999 data_len = utl_cvt8To7 ( source, data_len, dest, bit_offset ); | |
1000 break; | |
1001 | |
1002 default: /* 8 bit alphabet, UCS2, reserved */ | |
1003 data_len = MINIMUM ( source_len, SMS_MSG_LEN ); | |
1004 | |
1005 memcpy ( ( CHAR * ) dest, ( CHAR * ) source, data_len ); | |
1006 break; | |
1007 } | |
1008 | |
1009 *dest_len = data_len; | |
1010 } | |
1011 /* Implements Measure 25. This function is replaced by cmh_getAlphabetCb*/ | |
1012 /* | |
1013 +--------------------------------------------------------------------+ | |
1014 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1015 | STATE : code ROUTINE : cmhSMS_expdSmsCb | | |
1016 +--------------------------------------------------------------------+ | |
1017 | |
1018 PURPOSE : This function expands a cell broadcast SMS from | |
1019 7 to 8 bit. | |
1020 */ | |
1021 GLOBAL void cmhSMS_expdSmsCb ( UBYTE dcs, | |
1022 UBYTE *source, | |
1023 UBYTE source_len, | |
1024 UBYTE *dest, | |
1025 UBYTE *dest_len ) | |
1026 { | |
1027 UBYTE alphabet; | |
1028 | |
1029 TRACE_FUNCTION ("cmhSMS_expdSmsCb()"); | |
1030 alphabet = cmh_getAlphabetCb ( dcs ); | |
1031 | |
1032 switch (alphabet) | |
1033 { | |
1034 case( 0 ): /* 7 bit alphabet */ | |
1035 /* PATCH Add bit_offset parameter to function cvt7To8 */ | |
1036 /* utl_cvt7To8 ( source, source_len, dest ); */ | |
1037 utl_cvt7To8 ( source, source_len, dest, 0); | |
1038 /* PATCH END */ | |
1039 | |
1040 *dest_len = ( source_len * 8 ) / 7; | |
1041 break; | |
1042 | |
1043 default: /* 8 bit alphabet, UCS2, reserved */ | |
1044 memcpy ( ( CHAR * ) dest, ( CHAR * ) source, source_len ); | |
1045 | |
1046 *dest_len = source_len; | |
1047 break; | |
1048 } | |
1049 } | |
1050 | |
1051 /* | |
1052 +--------------------------------------------------------------------+ | |
1053 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1054 | STATE : code ROUTINE : cmhSMS_setToaDef | | |
1055 +--------------------------------------------------------------------+ | |
1056 | |
1057 PURPOSE : This function sets the type of address to default values | |
1058 (when the first character of address is '+' or the first | |
1059 two characters are '0' default is 145 otherwise default | |
1060 is 129) | |
1061 */ | |
1062 GLOBAL CHAR* cmhSMS_setToaDef ( CHAR* number, | |
1063 UBYTE* ntype, | |
1064 UBYTE* nplan ) | |
1065 { | |
1066 *nplan = SMS_NPI_ISDN; | |
1067 | |
1068 if ( *number EQ '+' ) | |
1069 { | |
1070 *ntype = SMS_TON_INTERNATIONAL; | |
1071 return number+1; | |
1072 } | |
1073 else | |
1074 { | |
1075 *ntype = SMS_TON_UNKNOWN; | |
1076 return number; | |
1077 } | |
1078 } | |
1079 | |
1080 /* | |
1081 +--------------------------------------------------------------------+ | |
1082 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1083 | STATE : code ROUTINE : cmhSMS_setTimezone | | |
1084 +--------------------------------------------------------------------+ | |
1085 | |
1086 PURPOSE : Codes the timezone format used in entity SMS. | |
1087 | |
1088 */ | |
1089 GLOBAL UBYTE cmhSMS_setTimezone (SHORT timezone) | |
1090 { | |
1091 UBYTE local_tz = ( UBYTE ) timezone; | |
1092 BOOL isNegative = ( local_tz & 0x80 ); | |
1093 | |
1094 if ( isNegative ) | |
1095 local_tz = ~local_tz + 1; | |
1096 | |
1097 local_tz = ( local_tz / 10 ) + ( ( local_tz % 10 ) << 4 ); | |
1098 | |
1099 return ( ( isNegative ) ? local_tz | 0x08 : local_tz ); | |
1100 } | |
1101 | |
1102 /* | |
1103 +--------------------------------------------------------------------+ | |
1104 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1105 | STATE : code ROUTINE : cmhSMS_getTimezone | | |
1106 +--------------------------------------------------------------------+ | |
1107 | |
1108 PURPOSE : Decodes the timezone format used in entity SMS. | |
1109 | |
1110 */ | |
1111 GLOBAL SHORT cmhSMS_getTimezone (UBYTE timezone) | |
1112 { | |
1113 signed char local_tz; | |
1114 | |
1115 local_tz = ( timezone & 0x07 ) * 10 + ( ( timezone & 0xF0 ) >> 4 ); | |
1116 | |
1117 return ( SHORT ) (( timezone & 0x08 ) ? -local_tz : local_tz ); | |
1118 } | |
1119 | |
1120 /* | |
1121 +--------------------------------------------------------------------+ | |
1122 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1123 | STATE : code ROUTINE : cmhSMS_setStorOcc | | |
1124 +--------------------------------------------------------------------+ | |
1125 | |
1126 PURPOSE : Fills the T_ACI_SMS_STOR_OCC structure with data from the | |
1127 shared parameter buffer. | |
1128 | |
1129 */ | |
1130 GLOBAL void cmhSMS_setStorOcc ( T_ACI_SMS_STOR_OCC* outMem, | |
1131 UBYTE inMem ) | |
1132 { | |
1133 cmhSMS_getMemCmh ( inMem, &outMem -> mem ); | |
1134 | |
1135 if ( outMem -> mem EQ SMS_STOR_Sm ) | |
1136 { | |
1137 outMem -> used = smsShrdPrm.aci_sms_parameter.simUsed; | |
1138 outMem -> total = smsShrdPrm.aci_sms_parameter.simTotal; | |
1139 } | |
1140 else | |
1141 { | |
1142 outMem -> used = smsShrdPrm.aci_sms_parameter.meUsed; | |
1143 outMem -> total = smsShrdPrm.aci_sms_parameter.meTotal; | |
1144 } | |
1145 } | |
1146 | |
1147 /* | |
1148 +-------------------------------------------------------------------+ | |
1149 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1150 | ROUTINE : cmhSMS_GetCmsFromSim | | |
1151 +-------------------------------------------------------------------+ | |
1152 | |
1153 PURPOSE : Mapping of SIM error code to ACI error code. | |
1154 | |
1155 */ | |
1156 GLOBAL T_ACI_CMS_ERR cmhSMS_GetCmsFromSim ( USHORT errCode ) | |
1157 { | |
1158 switch ( errCode ) | |
1159 { | |
1160 case SIM_NO_ERROR: | |
1161 return CMS_ERR_NotPresent; | |
1162 | |
1163 case SIM_CAUSE_PIN1_EXPECT: | |
1164 return CMS_ERR_SimPinReq; | |
1165 | |
1166 case SIM_CAUSE_PIN2_EXPECT: | |
1167 return CMS_ERR_SimPin2Req; | |
1168 | |
1169 case SIM_CAUSE_PUK1_EXPECT: | |
1170 case SIM_CAUSE_PIN1_BLOCKED: | |
1171 return CMS_ERR_SimPukReq; | |
1172 | |
1173 case SIM_CAUSE_PUK2_EXPECT: | |
1174 case SIM_CAUSE_PIN2_BLOCKED: | |
1175 return CMS_ERR_SimPuk2Req; | |
1176 | |
1177 case SIM_CAUSE_PUK1_BLOCKED: | |
1178 case SIM_CAUSE_PUK2_BLOCKED: | |
1179 return CMS_ERR_SimWrong; | |
1180 | |
1181 case SIM_CAUSE_UNKN_FILE_ID: | |
1182 case SIM_CAUSE_DNL_ERROR: | |
1183 return CMS_ERR_UnknownErr; | |
1184 | |
1185 case SIM_CAUSE_EF_INVALID: | |
1186 return CMS_ERR_OpNotSup; | |
1187 | |
1188 case SIM_CAUSE_ADDR_WRONG: | |
1189 return CMS_ERR_InValMemIdx; | |
1190 | |
1191 case SIM_CAUSE_CMD_INCONSIST: | |
1192 case SIM_CAUSE_MAX_INCREASE: | |
1193 case SIM_CAUSE_CHV_NOTSET: | |
1194 case SIM_CAUSE_CHV_VALIDATED: | |
1195 case SIM_CAUSE_ACCESS_PROHIBIT: | |
1196 return CMS_ERR_OpNotAllowed; | |
1197 | |
1198 case SIM_CAUSE_CARD_REMOVED: | |
1199 case SIM_CAUSE_DRV_NOCARD: | |
1200 return CMS_ERR_SimNotIns; | |
1201 | |
1202 case SIM_CAUSE_NO_SELECT: | |
1203 case SIM_CAUSE_CLA_WRONG: | |
1204 case SIM_CAUSE_INS_WRONG: | |
1205 case SIM_CAUSE_P1P2_WRONG: | |
1206 case SIM_CAUSE_P3_WRONG: | |
1207 case SIM_CAUSE_PARAM_WRONG: | |
1208 return CMS_ERR_MeFail; | |
1209 | |
1210 case SIM_CAUSE_SAT_BUSY: | |
1211 return CMS_ERR_SimBsy; | |
1212 | |
1213 case SIM_CAUSE_DRV_TEMPFAIL: | |
1214 return CMS_ERR_SimFail; | |
1215 | |
1216 default: | |
1217 if (GET_CAUSE_DEFBY(errCode) EQ DEFBY_CONDAT AND | |
1218 GET_CAUSE_ORIGSIDE(errCode) EQ ORIGSIDE_MS) | |
1219 { | |
1220 return CMS_ERR_UnknownErr; | |
1221 } | |
1222 return CMS_ERR_UnknownErr; | |
1223 } | |
1224 } | |
1225 | |
1226 | |
1227 | |
1228 /* | |
1229 +-------------------------------------------------------------------+ | |
1230 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1231 | ROUTINE : cmhSMS_GetCmsFromSms | | |
1232 +-------------------------------------------------------------------+ | |
1233 | |
1234 PURPOSE : Mapping of SMS causes (MNSMS.doc) to ACI error code. | |
1235 | |
1236 */ | |
1237 GLOBAL T_ACI_CMS_ERR cmhSMS_GetCmsFromSms ( USHORT errCode ) | |
1238 { | |
1239 switch ( errCode ) | |
1240 { | |
1241 case SMS_NO_ERROR: /* No error */ | |
1242 return CMS_ERR_NotPresent; | |
1243 | |
1244 case SMS_CAUSE_PARAM_WRONG: /* Wrong parameter in primitive */ | |
1245 | |
1246 case SMS_CAUSE_ENTITY_BUSY: /* Entity is busy */ | |
1247 return CMS_ERR_SimBsy; | |
1248 | |
1249 case SMS_CAUSE_OPER_NOT_ALLW: /* Operation not allowed */ | |
1250 return CMS_ERR_OpNotAllowed; | |
1251 | |
1252 case SMS_CAUSE_OPER_NOT_SUPP: /* Operation not supported */ | |
1253 return CMS_ERR_OpNotSup; | |
1254 | |
1255 case SMS_CAUSE_SIM_BUSY: /* SIM busy */ | |
1256 return CMS_ERR_SimBsy; | |
1257 default: | |
1258 break; | |
1259 } | |
1260 | |
1261 /* | |
1262 * The switch must be splitted because of a compiler bug | |
1263 * - asm files can not compiled | |
1264 * | |
1265 * TMS470 ANSI C Compiler Version 1.22e | |
1266 * | |
1267 * brz, 2004.02.14 | |
1268 */ | |
1269 | |
1270 switch(errCode) { | |
1271 case SMS_CAUSE_MEM_FAIL: /* Memory failure */ | |
1272 return CMS_ERR_MemFail; | |
1273 | |
1274 case SMS_CAUSE_INV_INDEX: /* Invalid memory index */ | |
1275 return CMS_ERR_InValMemIdx; | |
1276 | |
1277 case SMS_CAUSE_MEM_FULL: /* Memory full */ | |
1278 return CMS_ERR_MemFull; | |
1279 | |
1280 case SMS_CAUSE_NO_SERVICE: /* No network service */ | |
1281 return CMS_ERR_NoNetServ; | |
1282 | |
1283 case SMS_CAUSE_NET_TIMEOUT: /* Network timeout */ | |
1284 return CMS_ERR_NetTimeOut; | |
1285 | |
1286 case SMS_CAUSE_UNEXP_CNMA: /* No +CNMA acknowledgement expected */ | |
1287 return CMS_ERR_NoCnmaAckExpect; | |
1288 | |
1289 case SMS_CAUSE_OTHER_ERROR: /* Any other error */ | |
1290 return CMS_ERR_UnknownErr; | |
1291 | |
1292 default: | |
1293 return ((T_ACI_CMS_ERR) errCode); /* cmdCmsError(errCode) will figure out other error values from the first byte of the error code */ | |
1294 } | |
1295 } | |
1296 | |
1297 | |
1298 | |
1299 | |
1300 | |
1301 | |
1302 /* | |
1303 +-------------------------------------------------------------------+ | |
1304 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1305 | STATE : code ROUTINE : cmhSMS_ready | | |
1306 +-------------------------------------------------------------------+ | |
1307 | |
1308 PURPOSE : This function notifies SMS_READY to all sources. | |
1309 */ | |
1310 GLOBAL void cmhSMS_ready ( void ) | |
1311 { | |
1312 int idx; | |
1313 T_opl_field * ptr_opl; | |
1314 | |
1315 TRACE_FUNCTION ("cmhSMS_ready()"); | |
1316 | |
1317 { | |
1318 PALLOC (sim_sync_req, SIM_SYNC_REQ); | |
1319 sim_sync_req -> synccs = SYNC_MMI_FINISHED_READING; | |
1320 simShrdPrm.synCs = SYNC_MMI_FINISHED_READING; | |
1321 PSENDX (SIM, sim_sync_req); | |
1322 } | |
1323 | |
1324 smsShrdPrm.accessEnabled = TRUE; | |
1325 ptr_opl = cmhSIM_GetOPL(); | |
1326 ptr_opl->opl_status = FALSE; | |
1327 | |
1328 cmhSIM_UpdateOperatorName(NOT_PRESENT_16BIT); /* start EF_PNN and EF_OPL reading */ | |
1329 | |
1330 pb_start_build(FALSE); /* start phonebook reading, no guarantees */ | |
1331 | |
1332 percentCSTAT_indication(STATE_MSG_SMS, ENTITY_STATUS_Ready); | |
1333 | |
1334 for( idx = 0; idx < CMD_SRC_MAX; idx++ ) | |
1335 { | |
1336 R_AT( RAT_SMS_READY, (T_ACI_CMD_SRC)idx )(); | |
1337 } | |
1338 | |
1339 } | |
1340 | |
1341 | |
1342 /* | |
1343 +-------------------------------------------------------------------+ | |
1344 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1345 | STATE : code ROUTINE : cmhSMS_disableAccess | | |
1346 +-------------------------------------------------------------------+ | |
1347 | |
1348 PURPOSE : This function disables access to all SMS functions. | |
1349 */ | |
1350 GLOBAL void cmhSMS_disableAccess (void) | |
1351 { | |
1352 smsShrdPrm.accessEnabled = FALSE; | |
1353 } | |
1354 | |
1355 /* | |
1356 +-------------------------------------------------------------------+ | |
1357 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1358 | STATE : code ROUTINE : cmhSMS_checkSIM | | |
1359 +-------------------------------------------------------------------+ | |
1360 | |
1361 PURPOSE : This function checks if SMS is initialized. If not, the | |
1362 SIM state is checked. AN error code dependent of the | |
1363 SIM state is stored. | |
1364 */ | |
1365 GLOBAL BOOL cmhSMS_checkSIM (void) | |
1366 { | |
1367 if (smsShrdPrm.accessEnabled) | |
1368 return TRUE; /* SMS is accessible*/ | |
1369 /* | |
1370 *----------------------------------------------------------------- | |
1371 * check SIM status | |
1372 *----------------------------------------------------------------- | |
1373 */ | |
1374 | |
1375 switch (simShrdPrm.SIMStat) | |
1376 { | |
1377 case NO_VLD_SS: | |
1378 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimNotIns ); | |
1379 break; | |
1380 case SS_INV: | |
1381 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimFail ); | |
1382 break; | |
1383 /* case SS_BLKD: | |
1384 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPukReq ); | |
1385 break; */ | |
1386 case SS_URCHB: | |
1387 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimWrong ); | |
1388 break; | |
1389 case SS_OK: | |
1390 switch (simShrdPrm.PINStat) | |
1391 { | |
1392 case PS_PIN1: | |
1393 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPinReq); | |
1394 break; | |
1395 | |
1396 case PS_PIN2: | |
1397 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPin2Req); | |
1398 break; | |
1399 | |
1400 case PS_PUK1: | |
1401 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPukReq); | |
1402 break; | |
1403 | |
1404 case PS_PUK2: | |
1405 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimPuk2Req); | |
1406 break; | |
1407 | |
1408 default: | |
1409 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimBsy ); | |
1410 break; | |
1411 } | |
1412 break; | |
1413 default: | |
1414 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_SimBsy ); | |
1415 break; | |
1416 } | |
1417 return FALSE; | |
1418 } | |
1419 /* | |
1420 +-------------------------------------------------------------------+ | |
1421 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1422 | STATE : code ROUTINE : cmhSMS_checkAccess | | |
1423 +-------------------------------------------------------------------+ | |
1424 | |
1425 PURPOSE : This function checks if SMS is accessible. If an error | |
1426 condition is found, then *ret is set to either AT_FAIL or | |
1427 AT_BUSY, otherwise it remains unaffected. The error code | |
1428 is stored. | |
1429 */ | |
1430 GLOBAL BOOL cmhSMS_checkAccess (T_ACI_CMD_SRC srcId, | |
1431 T_ACI_RETURN *ret) | |
1432 { | |
1433 /* | |
1434 *----------------------------------------------------------------- | |
1435 * check command source | |
1436 *----------------------------------------------------------------- | |
1437 */ | |
1438 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
1439 { | |
1440 if(!cmh_IsVldCmdSrc (srcId)) | |
1441 { | |
1442 TRACE_ERROR ("[cmhSMS_checkAccess]: Cmd Src not valid"); | |
1443 *ret = AT_FAIL; | |
1444 return FALSE; | |
1445 } | |
1446 } | |
1447 /* | |
1448 *----------------------------------------------------------------- | |
1449 * check entity status | |
1450 *----------------------------------------------------------------- | |
1451 */ | |
1452 if( smsShrdPrm.smsEntStat.curCmd NEQ AT_CMD_NONE ) | |
1453 { | |
1454 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
1455 TRACE_ERROR ("[cmhSMS_checkAccess]: Entity is busy"); | |
1456 *ret = AT_BUSY; | |
1457 return FALSE; | |
1458 } | |
1459 | |
1460 /* | |
1461 *----------------------------------------------------------------- | |
1462 * check SMS access status | |
1463 *----------------------------------------------------------------- | |
1464 */ | |
1465 if (cmhSMS_checkSIM ()) | |
1466 return TRUE; | |
1467 | |
1468 TRACE_ERROR ("[cmhSMS_checkAccess]: Wrong SIM status"); | |
1469 | |
1470 *ret = AT_FAIL; | |
1471 return FALSE; | |
1472 } | |
1473 | |
1474 /* | |
1475 +-------------------------------------------------------------------+ | |
1476 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1477 | STATE : code ROUTINE : cmhSMS_getPrfRge | | |
1478 +-------------------------------------------------------------------+ | |
1479 | |
1480 PURPOSE : This function gets the number of available profiles for | |
1481 SMS related parameters. First, the SIM is checked. If | |
1482 there is no space, then PCM ist checked. | |
1483 */ | |
1484 GLOBAL SHORT cmhSMS_getPrfRge ( void ) | |
1485 { | |
1486 /* TEMPORARY, ONLY FOR TEST PURPOSES: Pretend that the SIM has no SMSP !!! */ | |
1487 /* smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0;*/ | |
1488 | |
1489 if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec > 0) | |
1490 { | |
1491 return (SHORT)smsShrdPrm.aci_sms_parameter.smsParamMaxRec; | |
1492 } | |
1493 else | |
1494 { | |
1495 return (MAX_FFS_SMSPRFLS); | |
1496 } | |
1497 } | |
1498 | |
1499 /* | |
1500 +-------------------------------------------------------------------+ | |
1501 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1502 | STATE : code ROUTINE : cmhSMS_ReadPrmFFS | | |
1503 +-------------------------------------------------------------------+ | |
1504 | |
1505 PURPOSE : This function reads one record of EF_SMSPRFL_ID from FFS. | |
1506 The processed parameters are controlled by bits in | |
1507 'access'. | |
1508 */ | |
1509 static T_ACI_RETURN cmhSMS_ReadPrmFFS (T_ACI_CMD_SRC srcId, | |
1510 SHORT recNr, | |
1511 int access) | |
1512 { | |
1513 T_SMS_SET_PRM *pSMSSetPrm; /* points to SMS parameter set */ | |
1514 int i; | |
1515 T_SMS_SET_PRM *elem; | |
1516 T_ACI_FFS_SMSPRFL smsPrfl; | |
1517 #ifndef _SIMULATION_ | |
1518 T_FFS_SIZE ffs_size; | |
1519 #endif | |
1520 | |
1521 TRACE_FUNCTION ("cmhSMS_ReadPrmFFS()"); | |
1522 | |
1523 #ifdef _SIMULATION_ | |
1524 smsPrfl.vldFlag = FFS_SMSPRFL_INVLD; /* trigger a failure since nothing can be read in simulation */ | |
1525 #else | |
1526 ffs_size = FFS_fread(ffs_smsprfl_fname[recNr-1], (void*)&smsPrfl, SIZE_FSS_SMSPRFL); | |
1527 /* | |
1528 Don't check FFS return for only specif ERRORS, as ACI will not know what | |
1529 ERROR FFS may send. So, it's walyws better to check for ERROR OK | |
1530 i.e EFFS_OK Considering this in mind the below condition is changes to | |
1531 do the same. | |
1532 */ | |
1533 if ( ffs_size < EFFS_OK ) | |
1534 { | |
1535 TRACE_EVENT_P1("error when reading FFS object \"%s\"", ffs_smsprfl_fname[recNr-1]); | |
1536 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_MemFail ); | |
1537 return AT_FAIL; | |
1538 } | |
1539 #endif | |
1540 | |
1541 if ( smsPrfl.vldFlag EQ FFS_SMSPRFL_INVLD ) | |
1542 { | |
1543 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed ); | |
1544 return AT_FAIL; | |
1545 } | |
1546 | |
1547 if (access & ACI_PCM_ACCESS_SMSP) | |
1548 { | |
1549 if (srcId >= CMD_SRC_MAX) | |
1550 { | |
1551 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr ); | |
1552 return AT_FAIL; | |
1553 } | |
1554 else | |
1555 { | |
1556 if (set_prm_list EQ NULL) | |
1557 { | |
1558 set_prm_list = new_list(); | |
1559 } | |
1560 | |
1561 elem = find_element(set_prm_list, (UBYTE)recNr, cmhSMS_findPrflId); | |
1562 if (elem EQ NULL) | |
1563 { | |
1564 ACI_MALLOC(elem, sizeof(T_SMS_SET_PRM)); | |
1565 memset(elem, 0, sizeof(T_SMS_SET_PRM)); | |
1566 insert_list(set_prm_list, elem); | |
1567 } | |
1568 if (srcId <= CMD_SRC_NONE) | |
1569 { | |
1570 elem->numOfRefs = OWN_SRC_MAX; | |
1571 for (i=0; i < OWN_SRC_MAX; i++) | |
1572 { | |
1573 smsShrdPrm.pSetPrm[i] = (T_SMS_SET_PRM*) elem; | |
1574 } | |
1575 } | |
1576 else | |
1577 { | |
1578 smsShrdPrm.pSetPrm[srcId] = (T_SMS_SET_PRM*) elem; | |
1579 (smsShrdPrm.pSetPrm[srcId])->numOfRefs++; | |
1580 } | |
1581 } | |
1582 | |
1583 pSMSSetPrm = (T_SMS_SET_PRM*) elem; | |
1584 pSMSSetPrm->prflId = (UBYTE)recNr; | |
1585 | |
1586 #ifndef _SIMULATION_ | |
1587 /* | |
1588 *------------------------------------------------------------- | |
1589 * restore the service center address | |
1590 *------------------------------------------------------------- | |
1591 */ | |
1592 pSMSSetPrm->sca.c_num = MINIMUM (smsPrfl.CSCAlenSca, MAX_SMS_ADDR_DIG); | |
1593 memcpy ( pSMSSetPrm->sca.num, smsPrfl.CSCAsca, pSMSSetPrm->sca.c_num); | |
1594 pSMSSetPrm->sca.ton = smsPrfl.CSCAton; | |
1595 pSMSSetPrm->sca.npi = smsPrfl.CSCAnpi; | |
1596 pSMSSetPrm->sca.v_ton = TRUE; | |
1597 pSMSSetPrm->sca.v_npi = TRUE; | |
1598 | |
1599 /* | |
1600 *------------------------------------------------------------- | |
1601 * restore the text mode parameters | |
1602 *------------------------------------------------------------- | |
1603 */ | |
1604 pSMSSetPrm->vpRel = smsPrfl.CSMPvprel; | |
1605 memcpy ( &pSMSSetPrm->vpAbs, smsPrfl.CSMPvpabs, SIZE_FFS_SMSPRFL_VPABS ); | |
1606 memcpy ( &pSMSSetPrm->vpEnh, smsPrfl.CSMPvpenh, SIZE_FFS_SMSPRFL_VPENH ); | |
1607 | |
1608 pSMSSetPrm->msgType = smsPrfl.CSMPfo; | |
1609 pSMSSetPrm->pid = smsPrfl.CSMPpid; | |
1610 pSMSSetPrm->dcs = smsPrfl.CSMPdcs; | |
1611 #endif | |
1612 } | |
1613 | |
1614 #ifndef _SIMULATION_ | |
1615 if (access & ACI_PCM_ACCESS_CBMP) | |
1616 { | |
1617 /* | |
1618 *------------------------------------------------------------- | |
1619 * restore the cell broadcast message types and data coding | |
1620 * schemes | |
1621 *------------------------------------------------------------- | |
1622 */ | |
1623 smsShrdPrm.cbmPrm.cbmMode = smsPrfl.CSCBmode; | |
1624 | |
1625 { /* default setting */ | |
1626 memset (smsShrdPrm.cbmPrm.msgId, DEF_MID_RANGE, sizeof (smsShrdPrm.cbmPrm.msgId)); | |
1627 memset (smsShrdPrm.cbmPrm.dcsId, DEF_DCS_RANGE, sizeof(smsShrdPrm.cbmPrm.dcsId)); | |
1628 } | |
1629 | |
1630 for ( i = 0; i < MINIMUM(MAX_IDENTS,SIZE_FFS_SMSPRFL_MIDS/2); i++ ) | |
1631 { | |
1632 smsShrdPrm.cbmPrm.msgId[i] = ( USHORT )smsPrfl.CSCBmids[2*i] << 8; | |
1633 smsShrdPrm.cbmPrm.msgId[i] |= ( USHORT )smsPrfl.CSCBmids[2*i+1]; | |
1634 } | |
1635 | |
1636 memcpy ( smsShrdPrm.cbmPrm.dcsId, smsPrfl.CSCBdcss, | |
1637 MINIMUM(MAX_IDENTS,SIZE_FFS_SMSPRFL_DCSS) ); | |
1638 | |
1639 memcpy (smsShrdPrm.cbmPrm.IMSI, smsPrfl.IMSI, MAX_IMSI); | |
1640 } | |
1641 #endif | |
1642 return AT_CMPL; | |
1643 } | |
1644 | |
1645 /* | |
1646 +-------------------------------------------------------------------+ | |
1647 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1648 | STATE : code ROUTINE : cmhSMS_WritePrmFFS | | |
1649 +-------------------------------------------------------------------+ | |
1650 | |
1651 PURPOSE : This function writes one record of EF_SMSPRFL_ID to FFS. | |
1652 The processed parameters are controlled by bits in | |
1653 'access'. | |
1654 */ | |
1655 static T_ACI_RETURN cmhSMS_WritePrmFFS (T_ACI_CMD_SRC srcId, | |
1656 SHORT recNr, | |
1657 int access) | |
1658 { | |
1659 T_SMS_SET_PRM *pSMSSetPrm; /* points to SMS parameter set */ | |
1660 T_ACI_FFS_SMSPRFL smsPrfl; | |
1661 int i; | |
1662 #ifndef _SIMULATION_ | |
1663 T_FFS_RET ffs_ret; | |
1664 #endif | |
1665 | |
1666 TRACE_FUNCTION ("cmhSMS_WritePrmFFS()"); | |
1667 | |
1668 if (access & ACI_PCM_ACCESS_SMSP) | |
1669 { | |
1670 if (srcId > CMD_SRC_NONE AND srcId < CMD_SRC_MAX) | |
1671 { | |
1672 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
1673 | |
1674 /* | |
1675 *------------------------------------------------------------- | |
1676 * save the service center address | |
1677 *------------------------------------------------------------- | |
1678 */ | |
1679 smsPrfl.CSCAlenSca = MINIMUM ( pSMSSetPrm->sca.c_num, SIZE_FFS_SMSPRFL_SCA ); | |
1680 memcpy ( smsPrfl.CSCAsca, pSMSSetPrm->sca.num, smsPrfl.CSCAlenSca ); | |
1681 | |
1682 i = (int)smsPrfl.CSCAlenSca; | |
1683 while ( i < SIZE_FFS_SMSPRFL_SCA ) | |
1684 smsPrfl.CSCAsca[i++] = 0xFF; | |
1685 | |
1686 smsPrfl.CSCAton = pSMSSetPrm->sca.ton; | |
1687 smsPrfl.CSCAnpi = pSMSSetPrm->sca.npi; | |
1688 | |
1689 /* | |
1690 *------------------------------------------------------------- | |
1691 * store the text mode parameters | |
1692 *------------------------------------------------------------- | |
1693 */ | |
1694 smsPrfl.CSMPfo = pSMSSetPrm->msgType; | |
1695 | |
1696 smsPrfl.CSMPvprel = pSMSSetPrm->vpRel; | |
1697 memcpy ( smsPrfl.CSMPvpabs, &pSMSSetPrm->vpAbs, SIZE_FFS_SMSPRFL_VPABS ); | |
1698 memcpy ( smsPrfl.CSMPvpenh, &pSMSSetPrm->vpEnh, SIZE_FFS_SMSPRFL_VPENH ); | |
1699 | |
1700 smsPrfl.CSMPpid = pSMSSetPrm->pid; | |
1701 smsPrfl.CSMPdcs = pSMSSetPrm->dcs; | |
1702 | |
1703 /* | |
1704 *------------------------------------------------------------- | |
1705 * set the valid flag | |
1706 *------------------------------------------------------------- | |
1707 */ | |
1708 smsPrfl.vldFlag = FFS_SMSPRFL_VLD; | |
1709 } | |
1710 else | |
1711 { | |
1712 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr ); | |
1713 return AT_FAIL; | |
1714 } | |
1715 } | |
1716 if (access & ACI_PCM_ACCESS_CBMP) | |
1717 { | |
1718 /* | |
1719 *------------------------------------------------------------- | |
1720 * save the cell broadcast message types | |
1721 *------------------------------------------------------------- | |
1722 */ | |
1723 smsPrfl.CSCBmode = smsShrdPrm.cbmPrm.cbmMode; | |
1724 | |
1725 { /* default setting */ | |
1726 memset (smsPrfl.CSCBmids, 0xFF, sizeof(smsPrfl.CSCBmids)); | |
1727 memset (smsPrfl.CSCBdcss, 0xFF, sizeof(smsPrfl.CSCBdcss)); | |
1728 } | |
1729 | |
1730 for ( i = 0; i < MINIMUM(MAX_IDENTS*2,SIZE_FFS_SMSPRFL_MIDS)-1; i += 2 ) | |
1731 { | |
1732 smsPrfl.CSCBmids[i] = (UBYTE)(smsShrdPrm.cbmPrm.msgId[i/2] >> 8); | |
1733 smsPrfl.CSCBmids[i+1] = (UBYTE)smsShrdPrm.cbmPrm.msgId[i/2]; | |
1734 } | |
1735 | |
1736 memcpy ( smsPrfl.CSCBdcss, smsShrdPrm.cbmPrm.dcsId, | |
1737 MINIMUM(MAX_IDENTS,SIZE_FFS_SMSPRFL_DCSS) ); | |
1738 | |
1739 /* | |
1740 * Save IMSI also in FFS | |
1741 */ | |
1742 memcpy (smsPrfl.IMSI, simShrdPrm.imsi.field, simShrdPrm.imsi.c_field); | |
1743 smsPrfl.vldFlag = FFS_SMSPRFL_VLD; | |
1744 } | |
1745 | |
1746 #ifndef _SIMULATION_ | |
1747 ffs_ret = FFS_mkdir(FFS_SMSPRFL_PATH); | |
1748 if (ffs_ret EQ EFFS_OK) | |
1749 { | |
1750 TRACE_EVENT_P1("FFS directory \"%s\" successfully created", FFS_SMSPRFL_PATH); | |
1751 } | |
1752 else if (ffs_ret EQ EFFS_EXISTS) | |
1753 { | |
1754 TRACE_EVENT_P1("FFS directory \"%s\" already exists", FFS_SMSPRFL_PATH); | |
1755 } | |
1756 else | |
1757 { | |
1758 TRACE_EVENT_P1("error when creating FFS directory \"%s\"", FFS_SMSPRFL_PATH); | |
1759 } | |
1760 | |
1761 ffs_ret = FFS_fwrite(ffs_smsprfl_fname[recNr-1], (void*)&smsPrfl, SIZE_FSS_SMSPRFL); | |
1762 if (ffs_ret NEQ EFFS_OK) | |
1763 { | |
1764 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_MemFail ); | |
1765 TRACE_EVENT_P1("error when writing FFS object \"%s\"", ffs_smsprfl_fname[recNr-1]); | |
1766 return AT_FAIL; | |
1767 } | |
1768 #endif | |
1769 | |
1770 return AT_CMPL; | |
1771 } | |
1772 | |
1773 /* | |
1774 +-------------------------------------------------------------------+ | |
1775 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1776 | STATE : code ROUTINE : cmhSMS_ReadParams | | |
1777 +-------------------------------------------------------------------+ | |
1778 | |
1779 PURPOSE : This function reads parameters from SIM and/or PCM. | |
1780 In case of AT command +CFUN the first record is read to | |
1781 be informed about storage capability of SIM. | |
1782 */ | |
1783 GLOBAL T_ACI_RETURN cmhSMS_ReadParams (T_ACI_CMD_SRC srcId, | |
1784 T_ACI_AT_CMD cmd, | |
1785 SHORT recNr) | |
1786 { | |
1787 T_ACI_RETURN ret = AT_CMPL; | |
1788 int access = 0; | |
1789 | |
1790 TRACE_FUNCTION ("cmhSMS_ReadParams()"); | |
1791 | |
1792 smsShrdPrm.smsEntStat.curCmd = cmd; | |
1793 smsShrdPrm.owner = (T_OWN)srcId; | |
1794 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1795 | |
1796 | |
1797 if (cmd EQ AT_CMD_CFUN) | |
1798 { | |
1799 /* initialization */ | |
1800 | |
1801 /* | |
1802 * Always read CSCB params from FFS so that previously stored mode and dcss | |
1803 * can also be restored from FFS | |
1804 */ | |
1805 access |= ACI_PCM_ACCESS_CBMP; | |
1806 /*if (!psaSIM_ChkSIMSrvSup( SRV_SMS_Parms ))*/ | |
1807 access |= ACI_PCM_ACCESS_SMSP; | |
1808 | |
1809 ret = cmhSMS_ReadPrmFFS (CMD_SRC_NONE, 1, access); | |
1810 | |
1811 if (psaSIM_ChkSIMSrvSup( SRV_SMS_Parms )) | |
1812 { | |
1813 smsShrdPrm.prmRdSeq = SMS_READ_SIM_SMSP; | |
1814 ret = cmhSIM_ReadRecordEF (CMD_SRC_NONE, cmd, FALSE, NULL, | |
1815 SIM_SMSP, 1, 255, | |
1816 NULL, cmhSMS_InitSMSP); | |
1817 } | |
1818 else if (psaSIM_ChkSIMSrvSup( SRV_CBMIdRnge )) | |
1819 { | |
1820 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMIR; | |
1821 ret = cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, | |
1822 SIM_CBMIR, 0, 255, | |
1823 NULL, cmhSMS_InitSMSP); | |
1824 } | |
1825 else if (psaSIM_ChkSIMSrvSup( SRV_CBM_Ident )) | |
1826 { | |
1827 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMI; | |
1828 ret = cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, | |
1829 SIM_CBMI, 0, 255, | |
1830 NULL, cmhSMS_InitSMSP); | |
1831 } | |
1832 #ifdef SIM_TOOLKIT | |
1833 else if ((psaSIM_ChkSIMSrvSup( SRV_DtaDownlCB )) AND | |
1834 smsShrdPrm.owner EQ OWN_SRC_SAT ) | |
1835 { | |
1836 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMID; | |
1837 ret = cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, | |
1838 SIM_CBMID, 0, 255, | |
1839 NULL, cmhSMS_InitSMSP); | |
1840 } | |
1841 #endif /* of SIM_TOOLKIT */ | |
1842 } | |
1843 else | |
1844 { | |
1845 | |
1846 /* TEMPORARY, ONLY FOR TEST PURPOSES: Pretend that the SIM has no SMSP !!! */ | |
1847 /* smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0; */ | |
1848 | |
1849 /* | |
1850 * Always read CSCB params from FFS so that previously stored mode and dcss | |
1851 * can also be restored from FFS | |
1852 */ | |
1853 /* normal operation */ | |
1854 access |= ACI_PCM_ACCESS_CBMP; | |
1855 /* if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec EQ 0)*/ | |
1856 access |= ACI_PCM_ACCESS_SMSP; | |
1857 ret = cmhSMS_ReadPrmFFS (srcId, recNr, access); | |
1858 | |
1859 if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec > 0) | |
1860 { | |
1861 if (recNr <= 0 | |
1862 OR recNr > (SHORT)smsShrdPrm.aci_sms_parameter.smsParamMaxRec) | |
1863 { | |
1864 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
1865 ret= AT_FAIL; | |
1866 } | |
1867 else | |
1868 { | |
1869 smsShrdPrm.prmRdSeq = SMS_READ_SIM_SMSP; | |
1870 return cmhSIM_ReadRecordEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_SMSP, | |
1871 (UBYTE)(recNr), | |
1872 smsShrdPrm.aci_sms_parameter.smsParamRecLen, | |
1873 NULL, cmhSMS_RdCnfCRES); | |
1874 } | |
1875 } | |
1876 if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0) | |
1877 { | |
1878 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMIR; | |
1879 return cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMIR, | |
1880 0, smsShrdPrm.cbmPrm.cbmSIMmaxIdRge, | |
1881 NULL, cmhSMS_RdCnfCRES); | |
1882 } | |
1883 if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0) | |
1884 { | |
1885 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMI; | |
1886 return cmhSIM_ReadTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMI, | |
1887 0, smsShrdPrm.cbmPrm.cbmSIMmaxId, | |
1888 NULL, cmhSMS_RdCnfCRES); | |
1889 } | |
1890 } | |
1891 if (ret NEQ AT_EXCT) | |
1892 { | |
1893 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
1894 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
1895 smsShrdPrm.smsEntStat.entOwn =CMD_SRC_NONE; | |
1896 | |
1897 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
1898 psaMMI_Cbch(); | |
1899 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
1900 } | |
1901 return ret; | |
1902 } | |
1903 | |
1904 /* | |
1905 +-------------------------------------------------------------------+ | |
1906 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1907 | STATE : code ROUTINE : cmhSMS_WriteParams | | |
1908 +-------------------------------------------------------------------+ | |
1909 | |
1910 PURPOSE : This function reads parameters from SIM and/or PCM. | |
1911 In case of AT command +CFUN the first record is read to | |
1912 be informed about storage capability of SIM. | |
1913 */ | |
1914 GLOBAL T_ACI_RETURN cmhSMS_WriteParams (T_ACI_CMD_SRC srcId, | |
1915 T_ACI_AT_CMD cmd, | |
1916 SHORT recNr) | |
1917 { | |
1918 T_ACI_RETURN ret = AT_CMPL; | |
1919 int access = 0; | |
1920 UBYTE data[MAX_SIM_CMD]; | |
1921 | |
1922 TRACE_FUNCTION ("cmhSMS_WriteParams()"); | |
1923 | |
1924 smsShrdPrm.smsEntStat.curCmd = cmd; | |
1925 smsShrdPrm.owner = (T_OWN)srcId; | |
1926 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1927 | |
1928 /* TEMPORARY, ONLY FOR TEST PURPOSES: Pretend that the SIM has no SMSP !!! */ | |
1929 /* smsShrdPrm.aci_sms_parameter.smsParamMaxRec = 0; */ | |
1930 | |
1931 /* | |
1932 * Always write CSCB params to FFS so that mode and dcss | |
1933 * can later be restored from FFS | |
1934 */ | |
1935 access |= ACI_PCM_ACCESS_CBMP; | |
1936 /*if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec EQ 0)*/ | |
1937 access |= ACI_PCM_ACCESS_SMSP; | |
1938 | |
1939 ret = cmhSMS_WritePrmFFS (srcId, recNr, access); | |
1940 | |
1941 if (smsShrdPrm.aci_sms_parameter.smsParamMaxRec > 0) | |
1942 { | |
1943 if (recNr <= 0 OR recNr > (SHORT)smsShrdPrm.aci_sms_parameter.smsParamMaxRec) | |
1944 { | |
1945 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
1946 ret= AT_FAIL; | |
1947 } | |
1948 else | |
1949 { | |
1950 smsShrdPrm.prmRdSeq = SMS_READ_SIM_SMSP; | |
1951 cmhSMS_PutPrmSIM (srcId, data, | |
1952 (int)smsShrdPrm.aci_sms_parameter.smsParamRecLen); | |
1953 return cmhSIM_WriteRecordEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_SMSP, | |
1954 (UBYTE)(recNr), | |
1955 smsShrdPrm.aci_sms_parameter.smsParamRecLen, | |
1956 data, cmhSMS_WrCnfCSAS); | |
1957 } | |
1958 } | |
1959 if (smsShrdPrm.cbmPrm.cbmSIMmaxIdRge > 0) | |
1960 { | |
1961 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMIR; | |
1962 cmhSMS_PutCbmirSIM (srcId, data, | |
1963 (int)smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4); | |
1964 | |
1965 return cmhSIM_WriteTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMIR, | |
1966 0, (UBYTE)(smsShrdPrm.cbmPrm.cbmSIMmaxIdRge * 4), | |
1967 data, cmhSMS_WrCnfCSAS); | |
1968 } | |
1969 if (smsShrdPrm.cbmPrm.cbmSIMmaxId > 0) | |
1970 { | |
1971 smsShrdPrm.prmRdSeq = SMS_READ_SIM_CBMI; | |
1972 cmhSMS_PutCbmiSIM (srcId, data, | |
1973 (int)smsShrdPrm.cbmPrm.cbmSIMmaxId * 2); | |
1974 | |
1975 return cmhSIM_WriteTranspEF (CMD_SRC_NONE, cmd, FALSE, NULL, SIM_CBMI, | |
1976 0, (UBYTE)(smsShrdPrm.cbmPrm.cbmSIMmaxId * 2), | |
1977 data, cmhSMS_WrCnfCSAS); | |
1978 } | |
1979 if (ret NEQ AT_EXCT) | |
1980 { | |
1981 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
1982 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
1983 smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; | |
1984 } | |
1985 return ret; | |
1986 } | |
1987 | |
1988 /* | |
1989 +-------------------------------------------------------------------+ | |
1990 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
1991 | STATE : code ROUTINE : cmhSMS_GetPrmSIM | | |
1992 +-------------------------------------------------------------------+ | |
1993 | |
1994 PURPOSE : This function extracts the parameters of one record of | |
1995 EF(SMSP) read from SIM. | |
1996 */ | |
1997 GLOBAL BOOL cmhSMS_GetPrmSIM (T_ACI_CMD_SRC srcId, | |
1998 UBYTE *data, | |
1999 int dataLen) | |
2000 { | |
2001 T_SMS_SET_PRM *pSMSSetPrm; /* points to SMS parameter set */ | |
2002 T_ACI_SMS_SIM_PARAMS *smsprm; | |
2003 | |
2004 TRACE_FUNCTION ("cmhSMS_GetPrmSIM ()"); | |
2005 | |
2006 if (data NEQ NULL) | |
2007 { | |
2008 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
2009 | |
2010 smsprm = (T_ACI_SMS_SIM_PARAMS *)&data[(dataLen <= MIN_SMS_PRM_LEN)? | |
2011 0: dataLen - MIN_SMS_PRM_LEN]; | |
2012 | |
2013 if (smsprm->par_ind EQ NOT_PRESENT_8BIT) | |
2014 { | |
2015 | |
2016 /* ACI-SPR-16431: reset sca number */ | |
2017 pSMSSetPrm->sca.c_num = 0; | |
2018 memset(pSMSSetPrm->sca.num, 0xFF, sizeof(pSMSSetPrm->sca.num)); | |
2019 /* end of ACI-SPR-16431: reset sca number */ | |
2020 | |
2021 return TRUE; /* record is empty */ | |
2022 } | |
2023 | |
2024 if ((smsprm->par_ind & SIM_SMSP_V_SCA) EQ 0) | |
2025 { | |
2026 cmh_demergeTOA (smsprm->sca_ton_npi, &pSMSSetPrm->sca.ton, | |
2027 &pSMSSetPrm->sca.npi); | |
2028 pSMSSetPrm->sca.c_num = (UBYTE)cmh_unpackBCD (pSMSSetPrm->sca.num, | |
2029 smsprm->sca_addr, | |
2030 (USHORT)(smsprm->sca_length - 1)); | |
2031 pSMSSetPrm->sca.v_ton = TRUE; | |
2032 pSMSSetPrm->sca.v_npi = TRUE; | |
2033 | |
2034 } | |
2035 if ((smsprm->par_ind & SIM_SMSP_V_PID) EQ 0) | |
2036 pSMSSetPrm->pid = smsprm->pid; | |
2037 | |
2038 if ((smsprm->par_ind & SIM_SMSP_V_DCS) EQ 0) | |
2039 pSMSSetPrm->dcs = smsprm->dcs; | |
2040 | |
2041 if ((smsprm->par_ind & SIM_SMSP_V_VPREL) EQ 0) | |
2042 { | |
2043 pSMSSetPrm->vpRel = smsprm->vp_rel; | |
2044 pSMSSetPrm->msgType &= ~TP_VPF_MASK; | |
2045 pSMSSetPrm->msgType |= TP_VPF_RELATIVE; | |
2046 } | |
2047 else if ((pSMSSetPrm->msgType & TP_VPF_MASK) EQ TP_VPF_RELATIVE) | |
2048 pSMSSetPrm->msgType &= ~TP_VPF_MASK; | |
2049 | |
2050 return TRUE; | |
2051 } | |
2052 return FALSE; | |
2053 } | |
2054 | |
2055 /* | |
2056 +-------------------------------------------------------------------+ | |
2057 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2058 | STATE : code ROUTINE : cmhSMS_PutPrmSIM | | |
2059 +-------------------------------------------------------------------+ | |
2060 | |
2061 PURPOSE : This function conbiness the parameters for one record of | |
2062 EF(SMSP) to be written to SIM. | |
2063 */ | |
2064 GLOBAL BOOL cmhSMS_PutPrmSIM (T_ACI_CMD_SRC srcId, | |
2065 UBYTE *data, | |
2066 int maxDataLen) | |
2067 { | |
2068 T_SMS_SET_PRM *pSMSSetPrm; /* points to SMS parameter set */ | |
2069 T_ACI_SMS_SIM_PARAMS *smsprm; | |
2070 size_t datalen; | |
2071 | |
2072 TRACE_FUNCTION ("cmhSMS_PutPrmSIM ()"); | |
2073 | |
2074 if (data NEQ NULL) | |
2075 { | |
2076 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
2077 | |
2078 if (maxDataLen < MIN_SMS_PRM_LEN) | |
2079 { | |
2080 datalen = MIN_SMS_PRM_LEN; | |
2081 smsprm = (T_ACI_SMS_SIM_PARAMS *)data; | |
2082 } | |
2083 else | |
2084 { | |
2085 datalen = (size_t)maxDataLen; | |
2086 smsprm = (T_ACI_SMS_SIM_PARAMS *)&data[datalen - MIN_SMS_PRM_LEN]; | |
2087 } | |
2088 memset (data, NOT_PRESENT_8BIT, datalen); | |
2089 | |
2090 /* | |
2091 *------------------------------------------------------------- | |
2092 * set the service center address | |
2093 *------------------------------------------------------------- | |
2094 */ | |
2095 if (pSMSSetPrm->sca.c_num > 0) | |
2096 { | |
2097 smsprm->sca_ton_npi = cmh_mergeTOA (pSMSSetPrm->sca.ton, | |
2098 pSMSSetPrm->sca.npi); | |
2099 smsprm->sca_length = (UBYTE)cmh_packBCD (smsprm->sca_addr, | |
2100 pSMSSetPrm->sca.num, | |
2101 (USHORT)MINIMUM(pSMSSetPrm->sca.c_num, | |
2102 MAX_SMS_ADDR_DIG)) + 1; | |
2103 smsprm->par_ind &= ~SIM_SMSP_V_SCA; | |
2104 } | |
2105 | |
2106 /* | |
2107 *------------------------------------------------------------- | |
2108 * set PID, DCS and VP-REL | |
2109 *------------------------------------------------------------- | |
2110 */ | |
2111 | |
2112 smsprm->pid = pSMSSetPrm->pid; | |
2113 smsprm->par_ind &= ~SIM_SMSP_V_PID; | |
2114 | |
2115 smsprm->dcs = pSMSSetPrm->dcs; | |
2116 smsprm->par_ind &= ~SIM_SMSP_V_DCS; | |
2117 | |
2118 if ((pSMSSetPrm->msgType & TP_VPF_MASK) EQ TP_VPF_RELATIVE) | |
2119 { | |
2120 smsprm->vp_rel = pSMSSetPrm->vpRel; | |
2121 smsprm->par_ind &= ~SIM_SMSP_V_VPREL; | |
2122 } | |
2123 return TRUE; | |
2124 } | |
2125 return FALSE; | |
2126 } | |
2127 | |
2128 /* | |
2129 +-------------------------------------------------------------------+ | |
2130 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2131 | STATE : code ROUTINE : cmhSMS_GetCbmirSIM | | |
2132 +-------------------------------------------------------------------+ | |
2133 | |
2134 PURPOSE : This function extracts the parameters of EF(CBMIR) | |
2135 read from SIM. | |
2136 */ | |
2137 GLOBAL BOOL cmhSMS_GetCbmirSIM (T_ACI_CMD_SRC srcId, | |
2138 UBYTE *data, | |
2139 int dataLen) | |
2140 { | |
2141 T_ACI_CBM_SIM_MID_RANGE *mid_range; | |
2142 USHORT lower_mid, upper_mid; | |
2143 int mid_entry; | |
2144 | |
2145 TRACE_FUNCTION ("cmhSMS_GetCbmirSIM ()"); | |
2146 | |
2147 if (data NEQ NULL) | |
2148 { | |
2149 /* Please be aware that to keep simulation test cases as less changed as | |
2150 possible lets assume that IMSI and CBMs stored in the FFS and from SIM | |
2151 card are the same, since we cannot access FFS under SIMULATION*/ | |
2152 #ifndef _SIMULATION_ | |
2153 /* | |
2154 * The CSCB parameters read from FFS should be restored only if the same SIM | |
2155 * is inserted ( check IMSI to ensure the same SIM), otherwise reset the CSCB | |
2156 * parameters to default values | |
2157 */ | |
2158 if (memcmp (smsShrdPrm.cbmPrm.IMSI, simShrdPrm.imsi.field, simShrdPrm.imsi.c_field) NEQ 0) | |
2159 { | |
2160 /* Implements Measure # 9 */ | |
2161 cmhSMS_clearCbmPrm(); | |
2162 return FALSE; | |
2163 } | |
2164 #endif | |
2165 mid_range = (T_ACI_CBM_SIM_MID_RANGE *)data; | |
2166 mid_entry = 0; | |
2167 | |
2168 while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND | |
2169 mid_entry < dataLen) | |
2170 { | |
2171 lower_mid = (USHORT)mid_range->lowerLSB | | |
2172 ((USHORT)mid_range->lowerMSB << 8); | |
2173 upper_mid = (USHORT)mid_range->upperLSB | | |
2174 ((USHORT)mid_range->upperMSB << 8); | |
2175 mid_range++; | |
2176 mid_entry += 4; | |
2177 | |
2178 if (lower_mid NEQ NOT_PRESENT_16BIT OR | |
2179 upper_mid NEQ NOT_PRESENT_16BIT) | |
2180 { | |
2181 /* Please be aware that to keep simulation test cases as less changed as | |
2182 possible lets assume that CBMs stored in the FFS and from SIM | |
2183 card are the same, since we cannot access FFS under SIMULATION*/ | |
2184 #ifndef _SIMULATION_ | |
2185 | |
2186 /* Implements Measure # 73 */ | |
2187 if (!cmhSMS_findMessageIds (lower_mid, upper_mid)) | |
2188 { | |
2189 return FALSE; | |
2190 } | |
2191 | |
2192 #else /* Just for simulation - copy data, received from SIM */ | |
2193 smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2] = lower_mid; | |
2194 smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1] = upper_mid; | |
2195 smsShrdPrm.cbmPrm.cbmFoundIds++; | |
2196 #endif | |
2197 } | |
2198 } | |
2199 return TRUE; | |
2200 } | |
2201 return FALSE; | |
2202 } | |
2203 | |
2204 /* | |
2205 +-------------------------------------------------------------------+ | |
2206 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2207 | STATE : code ROUTINE : cmhSMS_PutCbmirSIM | | |
2208 +-------------------------------------------------------------------+ | |
2209 | |
2210 PURPOSE : This function conbines the parameters of EF(CBMIR) | |
2211 to be written to SIM. | |
2212 */ | |
2213 GLOBAL BOOL cmhSMS_PutCbmirSIM (T_ACI_CMD_SRC srcId, | |
2214 UBYTE *data, | |
2215 int maxDataLen) | |
2216 { | |
2217 T_ACI_CBM_SIM_MID_RANGE *mid_range; | |
2218 USHORT lower_mid, upper_mid; | |
2219 int mid_entry; | |
2220 | |
2221 TRACE_FUNCTION ("cmhSMS_PutCbmirSIM ()"); | |
2222 | |
2223 if (data NEQ NULL) | |
2224 { | |
2225 memset (data, NOT_PRESENT_8BIT, maxDataLen); | |
2226 | |
2227 mid_range = (T_ACI_CBM_SIM_MID_RANGE *)data; | |
2228 mid_entry = 0; | |
2229 | |
2230 while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND | |
2231 mid_entry < maxDataLen) | |
2232 { | |
2233 lower_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2]; | |
2234 upper_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1]; | |
2235 smsShrdPrm.cbmPrm.cbmFoundIds++; | |
2236 | |
2237 if (lower_mid NEQ NOT_PRESENT_16BIT OR | |
2238 upper_mid NEQ NOT_PRESENT_16BIT) | |
2239 { | |
2240 mid_range->lowerLSB = (UBYTE)lower_mid; | |
2241 mid_range->lowerMSB = (UBYTE)(lower_mid >> 8); | |
2242 mid_range->upperLSB = (UBYTE)upper_mid; | |
2243 mid_range->upperMSB = (UBYTE)(upper_mid >> 8); | |
2244 mid_range++; | |
2245 mid_entry += 4; | |
2246 } | |
2247 } | |
2248 return TRUE; | |
2249 } | |
2250 return FALSE; | |
2251 } | |
2252 | |
2253 /* | |
2254 +-------------------------------------------------------------------+ | |
2255 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2256 | STATE : code ROUTINE : cmhSMS_GetCbmiSIM | | |
2257 +-------------------------------------------------------------------+ | |
2258 | |
2259 PURPOSE : This function extracts the parameters of one record of | |
2260 EF(SMSP) read from SIM. | |
2261 */ | |
2262 GLOBAL BOOL cmhSMS_GetCbmiSIM (T_ACI_CMD_SRC srcId, | |
2263 UBYTE *data, | |
2264 int dataLen) | |
2265 { | |
2266 T_ACI_CBM_SIM_MID_LIST **mid_list; | |
2267 USHORT mid; | |
2268 int mid_entry; | |
2269 | |
2270 TRACE_FUNCTION ("cmhSMS_GetCbmiSIM ()"); | |
2271 | |
2272 if (data NEQ NULL) | |
2273 { | |
2274 | |
2275 /* Please be aware that to keep simulation test cases as less changed as | |
2276 possible lets assume that IMSI and CBMs stored in the FFS and from SIM | |
2277 card are the same, since we cannot access FFS under SIMULATION*/ | |
2278 #ifndef _SIMULATION_ | |
2279 /* | |
2280 * The CSCB parameters read from FFS should be restored only if the same SIM | |
2281 * is inserted ( check IMSI to ensure the same SIM), otherwise reset the CSCB | |
2282 * parameters to default values | |
2283 */ | |
2284 if (memcmp (smsShrdPrm.cbmPrm.IMSI, simShrdPrm.imsi.field, simShrdPrm.imsi.c_field) NEQ 0) | |
2285 { | |
2286 /* Implements Measure # 9 */ | |
2287 cmhSMS_clearCbmPrm(); | |
2288 return FALSE; | |
2289 } | |
2290 #endif | |
2291 mid_list = (T_ACI_CBM_SIM_MID_LIST **)&data; | |
2292 mid_entry = 0; | |
2293 | |
2294 while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND | |
2295 mid_entry < dataLen) | |
2296 { | |
2297 mid = (USHORT)(*mid_list)->LSB | | |
2298 ((USHORT)(*mid_list)->MSB << 8); | |
2299 data += 2; /* overcome TI alignment problem */ | |
2300 mid_entry += 2; | |
2301 | |
2302 if (mid NEQ NOT_PRESENT_16BIT) | |
2303 { | |
2304 /* Please be aware that to keep simulation test cases as less changed as | |
2305 possible lets assume that CBMs stored in the FFS and from SIM | |
2306 card are the same, since we cannot access FFS under SIMULATION*/ | |
2307 #ifndef _SIMULATION_ | |
2308 | |
2309 /* Implements Measure # 73 */ | |
2310 if (!cmhSMS_findMessageIds (mid, mid)) | |
2311 { | |
2312 return FALSE; | |
2313 } | |
2314 | |
2315 #else /* Just for simulation - copy data, received from SIM */ | |
2316 smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2] = | |
2317 smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1] = mid; | |
2318 smsShrdPrm.cbmPrm.cbmFoundIds++; | |
2319 #endif | |
2320 } | |
2321 } | |
2322 return TRUE; | |
2323 } | |
2324 return FALSE; | |
2325 } | |
2326 | |
2327 /* | |
2328 +-------------------------------------------------------------------+ | |
2329 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2330 | STATE : code ROUTINE : cmhSMS_PutCbmiSIM | | |
2331 +-------------------------------------------------------------------+ | |
2332 | |
2333 PURPOSE : This function conbines the parameters of EF(CBMI) | |
2334 to be written to SIM. | |
2335 */ | |
2336 GLOBAL BOOL cmhSMS_PutCbmiSIM (T_ACI_CMD_SRC srcId, | |
2337 UBYTE *data, | |
2338 int maxDataLen) | |
2339 { | |
2340 T_ACI_CBM_SIM_MID_LIST **mid_list; | |
2341 USHORT lower_mid, upper_mid; | |
2342 UBYTE mid_entry; | |
2343 | |
2344 TRACE_FUNCTION ("cmhSMS_PutCbmiSIM ()"); | |
2345 | |
2346 if (data NEQ NULL) | |
2347 { | |
2348 memset (data, NOT_PRESENT_8BIT, maxDataLen); | |
2349 | |
2350 mid_list = (T_ACI_CBM_SIM_MID_LIST **)&data; | |
2351 mid_entry = 0; | |
2352 | |
2353 while (smsShrdPrm.cbmPrm.cbmFoundIds < MAX_IDENTS/2 AND | |
2354 mid_entry < maxDataLen) | |
2355 { | |
2356 lower_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2]; | |
2357 upper_mid = smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1]; | |
2358 smsShrdPrm.cbmPrm.cbmFoundIds++; | |
2359 | |
2360 if (lower_mid NEQ NOT_PRESENT_16BIT OR | |
2361 upper_mid NEQ NOT_PRESENT_16BIT) | |
2362 { | |
2363 while (lower_mid <= upper_mid AND mid_entry < maxDataLen) | |
2364 { | |
2365 (*mid_list)->LSB = (UBYTE)lower_mid; | |
2366 (*mid_list)->MSB = (UBYTE)(lower_mid >> 8); | |
2367 lower_mid++; | |
2368 data += 2; /* overcome TI alignment problem */ | |
2369 mid_entry += 2; | |
2370 } | |
2371 } | |
2372 } | |
2373 return TRUE; | |
2374 } | |
2375 return FALSE; | |
2376 } | |
2377 | |
2378 #ifdef SIM_TOOLKIT | |
2379 | |
2380 /* | |
2381 +-------------------------------------------------------------------+ | |
2382 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2383 | STATE : code ROUTINE : cmhSMS_FileUpdate | | |
2384 +-------------------------------------------------------------------+ | |
2385 | |
2386 PURPOSE : This function processes the primitive SIM_FILE_UPDATE_IND | |
2387 to update the SMS parameters stored on the SIM. | |
2388 */ | |
2389 GLOBAL BOOL cmhSMS_FileUpdate (int ref, T_SIM_FILE_UPDATE_IND *fu) | |
2390 { | |
2391 BOOL found = FALSE; | |
2392 int i; | |
2393 | |
2394 TRACE_FUNCTION ("cmhSMS_FileUpdate ()"); | |
2395 | |
2396 for (i = 0; i < (int)fu->val_nr; i++) | |
2397 { | |
2398 if (!found AND | |
2399 (fu->file_info[i].v_path_info EQ TRUE AND | |
2400 fu->file_info[i].path_info.df_level1 EQ SIM_DF_GSM AND | |
2401 fu->file_info[i].path_info.v_df_level2 EQ FALSE AND | |
2402 (fu->file_info[i].datafield EQ SIM_CBMI OR | |
2403 fu->file_info[i].datafield EQ SIM_CBMIR OR | |
2404 fu->file_info[i].datafield EQ SIM_CBMID)) OR | |
2405 | |
2406 (fu->file_info[i].v_path_info EQ TRUE AND | |
2407 fu->file_info[i].path_info.df_level1 EQ SIM_DF_TELECOM AND | |
2408 fu->file_info[i].path_info.v_df_level2 EQ FALSE AND | |
2409 fu->file_info[i].datafield EQ SIM_SMSP)) | |
2410 { | |
2411 found = TRUE; | |
2412 } | |
2413 if (fu->file_info[i].v_path_info EQ TRUE AND | |
2414 fu->file_info[i].path_info.df_level1 EQ SIM_DF_TELECOM AND | |
2415 fu->file_info[i].path_info.v_df_level2 EQ FALSE AND | |
2416 fu->file_info[i].datafield EQ SIM_SMS) | |
2417 { | |
2418 smsShrdPrm.aci_sms_parameter.simTotal = 0; | |
2419 smsShrdPrm.aci_sms_parameter.simUsed = 0; | |
2420 } | |
2421 } | |
2422 if (found) | |
2423 { | |
2424 smsShrdPrm.cbmPrm.cbmFoundIds = 0; /* new CBMI(R) */ | |
2425 | |
2426 if (cmhSMS_ReadParams ((T_ACI_CMD_SRC)OWN_SRC_SAT, AT_CMD_CFUN, 1) EQ AT_EXCT) | |
2427 { | |
2428 smsShrdPrm.accessEnabled = FALSE; | |
2429 | |
2430 simShrdPrm.fuRef = ref; | |
2431 return FALSE; /* reading files */ | |
2432 } | |
2433 else | |
2434 return TRUE; /* nothing to do */ | |
2435 } | |
2436 else | |
2437 { | |
2438 simShrdPrm.fuRef = -1; /* nothing to do */ | |
2439 return TRUE; | |
2440 } | |
2441 } | |
2442 | |
2443 /* | |
2444 +-------------------------------------------------------------------+ | |
2445 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
2446 | STATE : code ROUTINE : cmhSMS_GetCbDtaDwnlSIM | | |
2447 +-------------------------------------------------------------------+ | |
2448 | |
2449 PURPOSE : This function extracts the parameters of CBMID record of | |
2450 EF(CBMID) read from SIM. | |
2451 */ | |
2452 GLOBAL BOOL cmhSMS_GetCbDtaDwnlSIM (T_ACI_CMD_SRC srcId, | |
2453 UBYTE *data, | |
2454 int dataLen) | |
2455 { | |
2456 T_ACI_CBM_SIM_MID_LIST **mid_list; | |
2457 USHORT mid; | |
2458 int mid_entry; | |
2459 | |
2460 TRACE_FUNCTION ("cmhSMS_GetCbDtaDwnlSIM ()"); | |
2461 | |
2462 if (data NEQ NULL) | |
2463 { | |
2464 smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds = 0; | |
2465 memset (smsShrdPrm.cbmPrm.CBDtaDwnlIdent, NOT_PRESENT_8BIT, | |
2466 sizeof (smsShrdPrm.cbmPrm.CBDtaDwnlIdent)); | |
2467 | |
2468 mid_list = (T_ACI_CBM_SIM_MID_LIST **)&data; | |
2469 mid_entry = 0; | |
2470 | |
2471 while (smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds < MAX_IDENTS_SAT AND | |
2472 mid_entry < dataLen) | |
2473 { | |
2474 mid = (USHORT)(*mid_list)->LSB | | |
2475 ((USHORT)(*mid_list)->MSB << 8); | |
2476 data += 2; /* overcome TI alignment problem */ | |
2477 mid_entry += 2; | |
2478 | |
2479 if (mid NEQ NOT_PRESENT_16BIT) | |
2480 { | |
2481 smsShrdPrm.cbmPrm.CBDtaDwnlIdent[smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds] = mid; | |
2482 smsShrdPrm.cbmPrm.CBDtaDwnlFoundIds++; | |
2483 } | |
2484 } | |
2485 return TRUE; | |
2486 } | |
2487 return FALSE; | |
2488 } | |
2489 | |
2490 #endif /*of SIM_TOOLKIT */ | |
2491 | |
2492 | |
2493 | |
2494 | |
2495 /* | |
2496 +--------------------------------------------------------------------+ | |
2497 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
2498 | STATE : code ROUTINE : cmhSMS_decodeMsg | | |
2499 +--------------------------------------------------------------------+ | |
2500 | |
2501 PURPOSE : decodes a SM in two steps | |
2502 | |
2503 */ | |
2504 GLOBAL UBYTE* cmhSMS_decodeMsg (T_sms_sdu *sms_sdu, T_rp_addr* rp_addr, | |
2505 UBYTE vt_mti) | |
2506 { | |
2507 UBYTE ccdRet; | |
2508 UBYTE direction; | |
2509 UBYTE recover_from_error; | |
2510 | |
2511 BUF_tpdu sim_buf; /* source for the second decoding */ | |
2512 | |
2513 TRACE_FUNCTION("cmhSMS_decodeMsg ()"); | |
2514 | |
2515 if( sms_sdu->l_buf EQ 0) | |
2516 { | |
2517 TRACE_EVENT("empty SDU: no decoding"); | |
2518 return(NULL); | |
2519 } | |
2520 | |
2521 CCD_START; | |
2522 { | |
2523 | |
2524 MCAST( sim_pdu, SIM_PDU ); /* sim_pdu points to _decodedMsg */ | |
2525 /*memset( sim_pdu, 0, sizeof (T_SIM_PDU) ); */ | |
2526 | |
2527 /* decoding outer layer */ | |
2528 ccdRet = ccd_decodeMsg ( CCDENT_SMS, | |
2529 BOTH /* doesn't work with DOWNLINK!!! */, | |
2530 (T_MSGBUF *) sms_sdu, | |
2531 (UBYTE *) _decodedMsg, /* target */ | |
2532 SMS_VT_SIM_PDU); | |
2533 | |
2534 if ( (ccdRet NEQ ccdOK) OR (!sim_pdu->v_tpdu) | |
2535 OR (_decodedMsg[0] NEQ SMS_VT_SIM_PDU) ) | |
2536 { | |
2537 TRACE_EVENT_P1("CCD Decoding Error: %d", ccdRet); | |
2538 CCD_END; | |
2539 return NULL; | |
2540 } | |
2541 | |
2542 memcpy(rp_addr, &sim_pdu->rp_addr, sizeof(T_rp_addr) ); | |
2543 | |
2544 memcpy(&sim_buf, &sim_pdu->tpdu, sizeof(BUF_tpdu) ); | |
2545 | |
2546 /*memset( _decodedMsg, 0, sizeof (T_TP_SUBMIT) ); */ | |
2547 | |
2548 if (vt_mti EQ SMS_VT_SUBMIT) | |
2549 { | |
2550 /* for decoding of SMS-SUBMIT (in response to +CMGR, +CMGL) */ | |
2551 direction = UPLINK; | |
2552 } | |
2553 else | |
2554 { | |
2555 direction = DOWNLINK; | |
2556 } | |
2557 | |
2558 /* decoding inner layer */ | |
2559 ccdRet = ccd_decodeMsg ( CCDENT_SMS, | |
2560 direction, | |
2561 (T_MSGBUF *) &sim_buf, | |
2562 (UBYTE *) _decodedMsg, /* target */ | |
2563 vt_mti ); | |
2564 | |
2565 if (ccdRet EQ ccdWarning) | |
2566 recover_from_error = TRUE; /* Try to recover if a ccdWarning occoured */ | |
2567 else | |
2568 recover_from_error = FALSE; | |
2569 | |
2570 if ((ccdRet EQ ccdError) OR (ccdRet EQ ccdWarning)) | |
2571 { | |
2572 UBYTE ccd_err; | |
2573 USHORT parlist [6]; | |
2574 | |
2575 TRACE_EVENT_P1 ("ccd_decodeMsg(): %02x", ccdRet); | |
2576 /* | |
2577 * get the first error | |
2578 */ | |
2579 ccd_err = ccd_getFirstError (CCDENT_SMS, parlist); | |
2580 | |
2581 /* | |
2582 * Error Handling | |
2583 */ | |
2584 do | |
2585 { | |
2586 #ifndef NTRACE /* save some ROM */ | |
2587 /* Implements Measure#32: Row 1080,...,1093 */ | |
2588 if (ccdRet EQ ccdError) | |
2589 { | |
2590 TRACE_EVENT_P1 ("ERR: %u ", ccd_err); | |
2591 } | |
2592 else if (ccdRet EQ ccdWarning) | |
2593 { | |
2594 TRACE_EVENT_P1 ("WRN: %u ", ccd_err); | |
2595 } | |
2596 switch (ccd_err) | |
2597 { | |
2598 case ERR_NO_MORE_ERROR: | |
2599 TRACE_EVENT("the end of the error list is reached"); | |
2600 break; | |
2601 case ERR_INVALID_CALC: | |
2602 TRACE_EVENT("calculation of the element repeat value failed"); | |
2603 break; | |
2604 case ERR_PATTERN_MISMATCH: | |
2605 TRACE_EVENT("a bit pattern was not expected"); | |
2606 break; | |
2607 case ERR_COMPREH_REQUIRED: | |
2608 TRACE_EVENT("check for comprehension required failed"); | |
2609 break; | |
2610 case ERR_IE_NOT_EXPECTED: | |
2611 TRACE_EVENT("an information element was not expected"); | |
2612 break; | |
2613 case ERR_IE_SEQUENCE: | |
2614 TRACE_EVENT("wrong sequence of information elements"); | |
2615 break; | |
2616 case ERR_MAX_IE_EXCEED: | |
2617 TRACE_EVENT("maximum amount of repeatable information elements has exceeded"); | |
2618 break; | |
2619 case ERR_MAX_REPEAT: | |
2620 TRACE_EVENT("a repeatable element occurs too often in the message"); | |
2621 break; | |
2622 case ERR_MAND_ELEM_MISS: | |
2623 TRACE_EVENT("a mandatory information element is missing"); | |
2624 break; | |
2625 case ERR_INVALID_MID: | |
2626 TRACE_EVENT("the message ID is not correct"); | |
2627 break; | |
2628 case ERR_INVALID_TYPE: | |
2629 TRACE_EVENT("the information element is not a spare padding"); | |
2630 break; | |
2631 case ERR_EOC_TAG_MISSING: | |
2632 TRACE_EVENT("indefinite length is specified for the ASN.1-BER but the end tag is missing"); | |
2633 break; | |
2634 case ERR_INTERNAL_ERROR: | |
2635 TRACE_EVENT("an internal CCD error occured "); | |
2636 break; | |
2637 default: | |
2638 TRACE_EVENT("unknown error"); | |
2639 break; | |
2640 } | |
2641 #endif /* NTRACE */ | |
2642 | |
2643 if (ccdRet EQ ccdWarning) | |
2644 { | |
2645 switch (ccd_err) | |
2646 { | |
2647 case ERR_PATTERN_MISMATCH: /* recoverable warnings */ | |
2648 case ERR_COMPREH_REQUIRED: | |
2649 case ERR_INTERNAL_ERROR: | |
2650 break; | |
2651 default: | |
2652 recover_from_error = FALSE; /* in all other cases reset the recover flag */ | |
2653 } | |
2654 } | |
2655 | |
2656 ccd_err = ccd_getNextError (CCDENT_SMS, parlist); | |
2657 }while (ccd_err NEQ ERR_NO_MORE_ERROR); | |
2658 } | |
2659 | |
2660 if ( (ccdRet EQ ccdError) OR | |
2661 ((ccdRet EQ ccdWarning) AND (recover_from_error EQ FALSE)) OR /* not possible to recover */ | |
2662 (_decodedMsg[0] NEQ vt_mti) ) | |
2663 { | |
2664 TRACE_EVENT_P1("CCD Decoding Error Stage 2: %d", ccdRet); | |
2665 CCD_END; | |
2666 return NULL; | |
2667 } | |
2668 else if ((ccdRet EQ ccdWarning) AND (recover_from_error EQ TRUE)) | |
2669 { | |
2670 TRACE_EVENT ("recovered from warning"); | |
2671 } | |
2672 } | |
2673 CCD_END; | |
2674 | |
2675 return _decodedMsg; | |
2676 } | |
2677 | |
2678 | |
2679 | |
2680 /* | |
2681 +--------------------------------------------------------------------+ | |
2682 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
2683 | STATE : code ROUTINE : cmhSMS_codeMsg | | |
2684 +--------------------------------------------------------------------+ | |
2685 | |
2686 PURPOSE : encodes a SM in two steps | |
2687 | |
2688 */ | |
2689 GLOBAL void cmhSMS_codeMsg (T_sms_sdu *sms_sdu, UBYTE tp_vt_mti, | |
2690 T_rp_addr* sc_addr, UBYTE tp_mti, | |
2691 UBYTE* decoded_pdu ) | |
2692 { | |
2693 BUF_tpdu sim_buf; /* target for first coding */ | |
2694 UBYTE direction; | |
2695 | |
2696 TRACE_FUNCTION ("cmhSMS_codeMsg()"); | |
2697 | |
2698 | |
2699 CCD_START; | |
2700 { | |
2701 UBYTE ccdRet; | |
2702 | |
2703 MCAST( sim_pdu, SIM_PDU ); | |
2704 | |
2705 /* source of outer encoding */ | |
2706 memset( sim_pdu, 0, sizeof (T_SIM_PDU) ); | |
2707 | |
2708 /* target of outer encoding */ | |
2709 /* memset( sms_sdu, 0, sizeof (T_sms_sdu) ); */ | |
2710 sms_sdu->o_buf = 0; | |
2711 sms_sdu->l_buf = SIM_PDU_LEN << 3; | |
2712 | |
2713 sim_pdu->tp_vt_mti = SMS_VT_SIM_PDU; | |
2714 sim_pdu->tp_mti = tp_mti; | |
2715 | |
2716 /* service center address exists */ | |
2717 if (sc_addr) | |
2718 { | |
2719 memcpy(&sim_pdu->rp_addr, sc_addr, sizeof(T_rp_addr)); | |
2720 sim_pdu->rp_addr.v_ton = 1; | |
2721 sim_pdu->rp_addr.v_npi = 1; | |
2722 } | |
2723 | |
2724 /* pdu data exists */ | |
2725 if (decoded_pdu) | |
2726 { | |
2727 /* target of inner encoding */ | |
2728 /* memset(sim_buf, 0, sizeof(BUF_tpdu)); */ | |
2729 sim_buf.o_tpdu = 0; | |
2730 //TISH modified for MSIM | |
2731 //TISH: l_tpdu should be lenth of sim_buf.b_tpdu not BUF_tpdu. | |
2732 // sim_buf.l_tpdu = (sizeof(BUF_tpdu)) << 3; | |
2733 sim_buf.l_tpdu = (sizeof(sim_buf.b_tpdu)) << 3; | |
2734 | |
2735 if (tp_vt_mti EQ SMS_VT_DELIVER) | |
2736 { | |
2737 /* for encoding of SMS-DELIVER (only in +CMGW) */ | |
2738 direction = DOWNLINK; | |
2739 } | |
2740 else | |
2741 { | |
2742 direction = UPLINK; | |
2743 } | |
2744 | |
2745 /* encoding inner layer */ | |
2746 ccdRet = ccd_codeMsg (CCDENT_SMS, | |
2747 direction, | |
2748 (T_MSGBUF *) &sim_buf, /* target */ | |
2749 (UBYTE *) decoded_pdu, | |
2750 tp_vt_mti); | |
2751 | |
2752 if ( ccdRet NEQ ccdOK ) | |
2753 { | |
2754 TRACE_EVENT_P1("CCD Coding Error: %d", ccdRet); | |
2755 CCD_END; | |
2756 return; | |
2757 } | |
2758 if (sim_buf.l_tpdu EQ 0) | |
2759 { | |
2760 TRACE_EVENT("Encoded length is zero"); | |
2761 } | |
2762 | |
2763 memcpy(&sim_pdu->tpdu, &sim_buf, sizeof(BUF_tpdu)); | |
2764 sim_pdu->v_tpdu = 1; /* set validy flag */ | |
2765 } | |
2766 | |
2767 /* encoding outer layer */ | |
2768 ccdRet = ccd_codeMsg (CCDENT_SMS, | |
2769 UPLINK, | |
2770 (T_MSGBUF *) sms_sdu, /* target */ | |
2771 (UBYTE *) sim_pdu, | |
2772 SMS_VT_SIM_PDU); | |
2773 | |
2774 if ( ccdRet NEQ ccdOK ) | |
2775 { | |
2776 TRACE_EVENT_P1("CCD Coding Error: %d", ccdRet); | |
2777 CCD_END; | |
2778 return; | |
2779 } | |
2780 if (sms_sdu->l_buf EQ 0) | |
2781 { | |
2782 TRACE_EVENT("Encoded length is zero"); | |
2783 } | |
2784 } | |
2785 CCD_END; | |
2786 } | |
2787 | |
2788 | |
2789 | |
2790 /* | |
2791 +--------------------------------------------------------------------+ | |
2792 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
2793 | STATE : code ROUTINE : cmhSMS_cpyDeliver | | |
2794 +--------------------------------------------------------------------+ | |
2795 | |
2796 PURPOSE : converts a SMS-DELIVER message to the T_ACI_CMGL_SM | |
2797 structure | |
2798 | |
2799 */ | |
2800 GLOBAL BOOL cmhSMS_cpyDeliver ( T_ACI_CMGL_SM * sm, T_sms_sdu * sms_sdu ) | |
2801 { | |
2802 T_rp_addr rp_addr; | |
2803 UBYTE* message; | |
2804 T_TP_DELIVER *sms_deliver; | |
2805 UBYTE alphabet; | |
2806 | |
2807 TRACE_FUNCTION("cmhSMS_cpyDeliver()"); | |
2808 | |
2809 message = cmhSMS_decodeMsg(sms_sdu, &rp_addr, SMS_VT_DELIVER); | |
2810 | |
2811 if (message EQ NULL) | |
2812 { | |
2813 sm->stat = SMS_STAT_Invalid; | |
2814 return (FALSE); | |
2815 } | |
2816 | |
2817 if ( message[0] NEQ SMS_VT_DELIVER) | |
2818 { | |
2819 TRACE_EVENT_P1("wrong VTI = %x", message[0]); | |
2820 } | |
2821 | |
2822 sms_deliver = (T_TP_DELIVER*)message; | |
2823 | |
2824 /* | |
2825 *----------------------------------------------------------------- | |
2826 * process originator address | |
2827 *----------------------------------------------------------------- | |
2828 */ | |
2829 /* Implements Measure # 126 */ | |
2830 /* Since T_tp_oa and T_tp_da are of same type, there is no problem in | |
2831 passing sms_deliver->tp_oa */ | |
2832 cmhSMS_processOrigDestAddr (sm, | |
2833 &rp_addr, | |
2834 &sms_deliver->tp_oa); | |
2835 | |
2836 /* | |
2837 *----------------------------------------------------------------- | |
2838 * process first octet | |
2839 *----------------------------------------------------------------- | |
2840 */ | |
2841 sm -> fo = sms_sdu->buf[sms_sdu->buf[0] + 1]; | |
2842 | |
2843 /* | |
2844 *----------------------------------------------------------------- | |
2845 * process protocol identifier | |
2846 *----------------------------------------------------------------- | |
2847 */ | |
2848 sm -> pid = sms_deliver->tp_pid; | |
2849 | |
2850 /* | |
2851 *----------------------------------------------------------------- | |
2852 * process data coding scheme | |
2853 *----------------------------------------------------------------- | |
2854 */ | |
2855 sm -> dcs = sms_deliver->tp_dcs; | |
2856 | |
2857 | |
2858 /* | |
2859 *----------------------------------------------------------------- | |
2860 * process short message data, expanding from 7 to 8 bit | |
2861 *----------------------------------------------------------------- | |
2862 */ | |
2863 | |
2864 if (sms_deliver->v_tp_ud) | |
2865 { | |
2866 /* user data */ | |
2867 cmhSMS_expdSmsPp ( 0, | |
2868 sms_deliver->tp_dcs, | |
2869 sms_deliver->tp_ud.data, | |
2870 sms_deliver->tp_ud.length, | |
2871 sm -> data.data, | |
2872 &sm->data.len ); | |
2873 | |
2874 sm->udh.len = 0; | |
2875 } | |
2876 else | |
2877 { | |
2878 alphabet = cmhSMS_getAlphabetPp ( sms_deliver->tp_dcs ); | |
2879 | |
2880 /* user data header */ | |
2881 memcpy (sm->udh.data, sms_deliver->tp_udh_inc.tp_udh.data, | |
2882 sms_deliver->tp_udh_inc.tp_udh.c_data); | |
2883 sm->udh.len = sms_deliver->tp_udh_inc.tp_udh.c_data; | |
2884 | |
2885 /* user data (only user data can be 7bit data!!!) */ | |
2886 cmhSMS_expdSmsPp ( (UBYTE)(sm->udh.len+1), | |
2887 sms_deliver->tp_dcs, | |
2888 sms_deliver->tp_udh_inc.data, | |
2889 sms_deliver->tp_udh_inc.length, /* ACI-SPR-9440 */ | |
2890 sm->data.data, | |
2891 &sm->data.len ); | |
2892 | |
2893 /* 7-bit data */ | |
2894 if (alphabet EQ 0x00) | |
2895 { | |
2896 sm->data.len = sms_deliver->tp_udh_inc.length - ((sm->udh.len+1)*8)/7; | |
2897 | |
2898 /* minus space for the fill bits */ | |
2899 if (((sm->udh.len+1)*8)%7 NEQ 0) sm->data.len--; | |
2900 } | |
2901 /* 8-bit data */ | |
2902 else | |
2903 { | |
2904 sm->data.len = sms_deliver->tp_udh_inc.length-(sm->udh.len+1); | |
2905 } | |
2906 } | |
2907 | |
2908 /* | |
2909 *----------------------------------------------------------------- | |
2910 * process service center time stamp | |
2911 *----------------------------------------------------------------- | |
2912 */ | |
2913 sm -> vp_rel = 0; | |
2914 memset ( &sm->vp_enh, 0, sizeof(T_ACI_VP_ENH) ); | |
2915 | |
2916 cmhSMS_setVpabsCmh ( &sm -> scts, | |
2917 (T_tp_vp_abs*) &sms_deliver->tp_scts ); | |
2918 | |
2919 return (TRUE); | |
2920 } | |
2921 | |
2922 | |
2923 /* | |
2924 +--------------------------------------------------------------------+ | |
2925 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
2926 | STATE : code ROUTINE : cmhSMS_cpySubmit | | |
2927 +--------------------------------------------------------------------+ | |
2928 | |
2929 PURPOSE : converts a SMS-SUBMIT message to the T_ACI_CMGL_SM | |
2930 structure | |
2931 | |
2932 */ | |
2933 GLOBAL BOOL cmhSMS_cpySubmit ( T_ACI_CMGL_SM * sm, T_sms_sdu * sms_sdu ) | |
2934 { | |
2935 T_rp_addr rp_addr; | |
2936 UBYTE* message; | |
2937 T_TP_SUBMIT *sms_submit; | |
2938 UBYTE alphabet; | |
2939 | |
2940 TRACE_FUNCTION("cmhSMS_cpySubmit()"); | |
2941 | |
2942 message = cmhSMS_decodeMsg(sms_sdu, &rp_addr, SMS_VT_SUBMIT); | |
2943 | |
2944 if (message EQ NULL) | |
2945 { | |
2946 sm->stat = SMS_STAT_Invalid; | |
2947 return (FALSE); | |
2948 } | |
2949 | |
2950 if ( message[0] NEQ SMS_VT_SUBMIT) | |
2951 { | |
2952 TRACE_EVENT_P1("wrong VTI = %x", message[0]); | |
2953 } | |
2954 | |
2955 sms_submit = (T_TP_SUBMIT*)message; | |
2956 | |
2957 | |
2958 /* | |
2959 *----------------------------------------------------------------- | |
2960 * process recepient address | |
2961 *----------------------------------------------------------------- | |
2962 */ | |
2963 /* Implements Measure # 126 */ | |
2964 cmhSMS_processOrigDestAddr (sm, | |
2965 &rp_addr, | |
2966 &sms_submit->tp_da); | |
2967 | |
2968 /* | |
2969 *----------------------------------------------------------------- | |
2970 * process first octet | |
2971 *----------------------------------------------------------------- | |
2972 */ | |
2973 sm -> fo = sms_sdu->buf[sms_sdu->buf[0] + 1]; | |
2974 | |
2975 /* | |
2976 *----------------------------------------------------------------- | |
2977 * process protocol identifier | |
2978 *----------------------------------------------------------------- | |
2979 */ | |
2980 sm -> pid = sms_submit->tp_pid; | |
2981 | |
2982 /* | |
2983 *----------------------------------------------------------------- | |
2984 * process data coding scheme | |
2985 *----------------------------------------------------------------- | |
2986 */ | |
2987 sm -> dcs = sms_submit->tp_dcs; | |
2988 | |
2989 /* | |
2990 *----------------------------------------------------------------- | |
2991 * process short message data, expanding from 7 to 8 bit | |
2992 *----------------------------------------------------------------- | |
2993 */ | |
2994 | |
2995 if (sms_submit->v_tp_ud) | |
2996 { | |
2997 /* user data */ | |
2998 cmhSMS_expdSmsPp ( 0, | |
2999 sms_submit->tp_dcs, | |
3000 sms_submit->tp_ud.data, | |
3001 sms_submit->tp_ud.length, /* ACI-SPR-9440 */ | |
3002 sm->data.data, | |
3003 &sm->data.len ); | |
3004 | |
3005 sm->udh.len = 0; | |
3006 } | |
3007 else | |
3008 { | |
3009 alphabet = cmhSMS_getAlphabetPp ( sms_submit->tp_dcs ); | |
3010 | |
3011 /* user data header */ | |
3012 memcpy (sm->udh.data, sms_submit->tp_udh_inc.tp_udh.data, | |
3013 sms_submit->tp_udh_inc.tp_udh.c_data); | |
3014 sm->udh.len = sms_submit->tp_udh_inc.tp_udh.c_data; | |
3015 | |
3016 /* user data (only user data can be 7bit data!!!) */ | |
3017 cmhSMS_expdSmsPp ( (UBYTE)(sm->udh.len+1), | |
3018 sms_submit->tp_dcs, | |
3019 sms_submit->tp_udh_inc.data, | |
3020 sms_submit->tp_udh_inc.length, /* ACI-SPR-9440 */ | |
3021 sm->data.data, | |
3022 &sm->data.len ); | |
3023 | |
3024 /* 7-bit data */ | |
3025 if (alphabet EQ 0x00) | |
3026 { | |
3027 sm->data.len = sms_submit->tp_udh_inc.length - ((sm->udh.len+1)*8)/7; | |
3028 | |
3029 /* minus space for the fill bits */ | |
3030 if (((sm->udh.len+1)*8)%7 NEQ 0) sm->data.len--; | |
3031 } | |
3032 /* 8-bit data */ | |
3033 else | |
3034 { | |
3035 sm->data.len = sms_submit->tp_udh_inc.length-(sm->udh.len+1); | |
3036 } | |
3037 } | |
3038 | |
3039 /* | |
3040 *----------------------------------------------------------------- | |
3041 * process validity period | |
3042 *----------------------------------------------------------------- | |
3043 */ | |
3044 if (sms_submit->v_tp_vp_abs) | |
3045 { | |
3046 cmhSMS_setVpabsCmh ( &sm->scts, &sms_submit->tp_vp_abs ); | |
3047 sm -> vp_rel = 0; | |
3048 memset ( &sm->vp_enh, 0, sizeof(T_ACI_VP_ENH) ); | |
3049 } | |
3050 else if (sms_submit->v_tp_vp_enh) | |
3051 { | |
3052 cmhSMS_setVpenhCmh ( &sm->vp_enh, &sms_submit->tp_vp_enh ); | |
3053 sm -> vp_rel = 0; | |
3054 memset ( &sm->scts, 0, sizeof(T_ACI_VP_ABS) ); | |
3055 } | |
3056 else | |
3057 { | |
3058 sm -> vp_rel = sms_submit->tp_vp_rel; | |
3059 memset ( &sm -> scts, 0, sizeof(T_ACI_VP_ABS) ); | |
3060 memset ( &sm -> vp_enh, 0, sizeof(T_ACI_VP_ENH) ); | |
3061 } | |
3062 return (TRUE); | |
3063 } | |
3064 | |
3065 /* Implements Measure # 110 */ | |
3066 | |
3067 /* | |
3068 +--------------------------------------------------------------------+ | |
3069 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3070 | STATE : code ROUTINE : cmhSMS_cpyStatInd | | |
3071 +--------------------------------------------------------------------+ | |
3072 | |
3073 PURPOSE : handles a status indication | |
3074 | |
3075 */ | |
3076 GLOBAL BOOL cmhSMS_cpyStatInd ( T_ACI_CDS_SM * sm, | |
3077 T_MNSMS_STATUS_IND *mnsms_status_ind ) | |
3078 { | |
3079 T_rp_addr rp_addr; | |
3080 UBYTE* message; | |
3081 T_TP_STATUS *sms_status; | |
3082 | |
3083 TRACE_FUNCTION("cmhSMS_cpyStatInd()"); | |
3084 | |
3085 message = cmhSMS_decodeMsg(&mnsms_status_ind->sms_sdu, &rp_addr, SMS_VT_STATUS); | |
3086 | |
3087 if (message EQ NULL) | |
3088 { | |
3089 return (FALSE); | |
3090 } | |
3091 | |
3092 if ( message[0] NEQ SMS_VT_STATUS) | |
3093 { | |
3094 TRACE_EVENT_P1("wrong VTI = %x", message[0]); | |
3095 } | |
3096 | |
3097 sms_status = (T_TP_STATUS*)message; | |
3098 | |
3099 | |
3100 /* | |
3101 *----------------------------------------------------------------- | |
3102 * process message type | |
3103 *----------------------------------------------------------------- | |
3104 */ | |
3105 sm -> fo = mnsms_status_ind->sms_sdu.buf[mnsms_status_ind->sms_sdu.buf[0]+1]; | |
3106 | |
3107 /* | |
3108 *----------------------------------------------------------------- | |
3109 * process message reference | |
3110 *----------------------------------------------------------------- | |
3111 */ | |
3112 sm -> msg_ref = sms_status->tp_mr; | |
3113 | |
3114 /* | |
3115 *----------------------------------------------------------------- | |
3116 * process recipient address | |
3117 *----------------------------------------------------------------- | |
3118 */ | |
3119 cmhSMS_getAdrStr ( sm->addr, | |
3120 MAX_SMS_ADDR_DIG - 1, | |
3121 sms_status->tp_ra.num, | |
3122 sms_status->tp_ra.digits); | |
3123 | |
3124 sm->toa.ton = cmhSMS_getTon ( sms_status->tp_ra.ton ); | |
3125 sm->toa.npi = cmhSMS_getNpi ( sms_status->tp_ra.npi ); | |
3126 | |
3127 /* | |
3128 *----------------------------------------------------------------- | |
3129 * process service center time stamp | |
3130 *----------------------------------------------------------------- | |
3131 */ | |
3132 cmhSMS_setVpabsCmh ( &sm->vpabs_scts, (T_tp_vp_abs*) &sms_status->tp_scts ); | |
3133 | |
3134 /* | |
3135 *----------------------------------------------------------------- | |
3136 * process discharge time | |
3137 *----------------------------------------------------------------- | |
3138 */ | |
3139 cmhSMS_setVpabsCmh ( &sm->vpabs_dt, (T_tp_vp_abs*) &sms_status->tp_dt ); | |
3140 | |
3141 /* | |
3142 *----------------------------------------------------------------- | |
3143 * process status | |
3144 *----------------------------------------------------------------- | |
3145 */ | |
3146 sm -> tp_status = sms_status->tp_st; | |
3147 | |
3148 return (TRUE); | |
3149 } | |
3150 | |
3151 | |
3152 /* | |
3153 +--------------------------------------------------------------------+ | |
3154 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3155 | STATE : code ROUTINE : cmhSMS_getPhbEntry | | |
3156 +--------------------------------------------------------------------+ | |
3157 | |
3158 PURPOSE : gets phone book entry from coded SM | |
3159 | |
3160 */ | |
3161 GLOBAL void cmhSMS_getPhbEntry( UBYTE *buf, | |
3162 T_ACI_PB_TEXT *alpha, | |
3163 T_ACI_SMS_STAT status ) | |
3164 { | |
3165 UBYTE *p_data; | |
3166 UBYTE sca_len; | |
3167 UBYTE nplan; | |
3168 UBYTE no_bcd; | |
3169 UBYTE bcd[MAX_SMS_ADDR_DIG]; | |
3170 CHAR addr[MAX_SMS_ADDR_DIG+1]; /* for '\0' */ | |
3171 USHORT octets; | |
3172 | |
3173 alpha->len = 0; | |
3174 | |
3175 p_data = &buf[0]; | |
3176 sca_len = buf[0]; | |
3177 | |
3178 switch (status) | |
3179 { | |
3180 case SMS_STAT_RecUnread: | |
3181 case SMS_STAT_RecRead: | |
3182 if ((*(p_data+sca_len+1) & TP_MTI_MASK) EQ TP_MTI_SMS_STATUS_REP) | |
3183 { | |
3184 p_data++; | |
3185 } | |
3186 p_data += (sca_len+1) + 1; /* sms-deliver */ | |
3187 break; | |
3188 case SMS_STAT_StoUnsent: | |
3189 case SMS_STAT_StoSent: | |
3190 p_data += (sca_len+1) + 2; /* sms-submit */ | |
3191 break; | |
3192 default: | |
3193 return; | |
3194 } | |
3195 | |
3196 /* process originator/destination address */ | |
3197 no_bcd = *p_data++; | |
3198 no_bcd = MINIMUM(no_bcd, MAX_SMS_ADDR_DIG); | |
3199 | |
3200 nplan = *p_data++ & 0x0F; /* npi */ | |
3201 | |
3202 octets = (no_bcd+1)/2; | |
3203 | |
3204 no_bcd = (UBYTE)cmh_unpackBCD (bcd, p_data, octets); | |
3205 | |
3206 if (nplan EQ 0x05) /* VO patch - if (patch) else ... */ | |
3207 { | |
3208 UBYTE i,j = 0; | |
3209 for (i = 0 ; i < no_bcd; i=i+2) | |
3210 { | |
3211 addr[j] = (UBYTE)(bcd[i+1] << 4) + (UBYTE)(bcd[i]); | |
3212 j++; | |
3213 } | |
3214 addr[j] = '\0'; | |
3215 } | |
3216 else | |
3217 { | |
3218 cmhSMS_getAdrStr ( addr, | |
3219 MAX_SMS_ADDR_DIG, | |
3220 bcd, | |
3221 no_bcd ); | |
3222 } | |
3223 | |
3224 /* | |
3225 *----------------------------------------------------------------- | |
3226 * process alphanumerical phonebook entry | |
3227 *----------------------------------------------------------------- | |
3228 */ | |
3229 psaCC_phbMfwSrchNumPlnTxt ( addr, alpha ); | |
3230 } | |
3231 | |
3232 | |
3233 /* | |
3234 +--------------------------------------------------------------------+ | |
3235 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3236 | STATE : code ROUTINE : cmhSMS_codeDelRep | | |
3237 +--------------------------------------------------------------------+ | |
3238 | |
3239 PURPOSE : codes RP-ACK for SMS-DELIVER-REPORT (without PID, DCS, UD) | |
3240 | |
3241 */ | |
3242 GLOBAL void cmhSMS_codeDelRep(T_sms_sdu *sms_sdu, T_rp_addr *sc_addr) | |
3243 { | |
3244 UBYTE sca_len; /* SCA len incl. length byte and toa */ | |
3245 UBYTE sca_buf[MAX_SMS_ADDR_DIG/2 + 2]; | |
3246 | |
3247 sca_len = CodeRPAddress( sca_buf, | |
3248 sc_addr->c_num, | |
3249 sc_addr->ton, | |
3250 sc_addr->npi, | |
3251 sc_addr->num ); | |
3252 | |
3253 sms_sdu->l_buf = (sca_len+2)<<3; | |
3254 sms_sdu->o_buf = 0; | |
3255 | |
3256 memcpy ( sms_sdu->buf, sca_buf, sca_len); | |
3257 memset ( sms_sdu->buf+sca_len, 0, 2); | |
3258 } | |
3259 | |
3260 | |
3261 /* | |
3262 +--------------------------------------------------------------------+ | |
3263 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3264 | STATE : code ROUTINE : CodeRPAddress | | |
3265 +--------------------------------------------------------------------+ | |
3266 | |
3267 PURPOSE : converts address (in BCD format) to semi-octet representation | |
3268 (including address-length, ton and npi), | |
3269 for RP addresses (e.g SCA) | |
3270 | |
3271 returns number of octets including address-length, | |
3272 ton and npi | |
3273 | |
3274 */ | |
3275 GLOBAL UBYTE CodeRPAddress( UBYTE *buf, UBYTE numDigits, UBYTE ton, | |
3276 UBYTE npi, UBYTE *bcd ) | |
3277 { | |
3278 UBYTE length; | |
3279 | |
3280 if (numDigits EQ 0) | |
3281 { | |
3282 length = 1; | |
3283 *buf = 0x00; | |
3284 } | |
3285 else | |
3286 { | |
3287 *buf++ = (numDigits+1)/2 + 1; | |
3288 *buf++ = (ton << 4) + npi + 0x80; | |
3289 | |
3290 length = (UBYTE)cmh_packBCD ( buf, bcd, numDigits ); | |
3291 | |
3292 /* add length of length field, ton and npi */ | |
3293 length += 2; | |
3294 } | |
3295 | |
3296 return length; | |
3297 } | |
3298 | |
3299 | |
3300 /* | |
3301 +--------------------------------------------------------------------+ | |
3302 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3303 | STATE : code ROUTINE : CodeTPAddress | | |
3304 +--------------------------------------------------------------------+ | |
3305 | |
3306 PURPOSE : converts address (in BCD format) to semi-octet representation | |
3307 (including address-length, ton and npi), | |
3308 for TP addresses (e.g OA or DA) | |
3309 | |
3310 returns number of octets including including address-length, | |
3311 ton and npi | |
3312 | |
3313 */ | |
3314 GLOBAL UBYTE CodeTPAddress( UBYTE *buf, UBYTE numDigits, UBYTE ton, | |
3315 UBYTE npi, UBYTE *bcd ) | |
3316 { | |
3317 UBYTE length; | |
3318 | |
3319 *buf++ = numDigits; | |
3320 *buf++ = (ton << 4) + npi + 0x80; | |
3321 | |
3322 length = (UBYTE)cmh_packBCD ( buf, bcd, numDigits ); | |
3323 | |
3324 /* add length of length field, to and npi */ | |
3325 length += 2; | |
3326 | |
3327 return length; | |
3328 } | |
3329 | |
3330 | |
3331 /* | |
3332 +--------------------------------------------------------------------+ | |
3333 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3334 | STATE : code ROUTINE : DecodeRPAddress | | |
3335 +--------------------------------------------------------------------+ | |
3336 | |
3337 PURPOSE : converts RP address (SC address) from semi-octet | |
3338 representation to address in BCD format (including | |
3339 address-length, ton and npi) | |
3340 | |
3341 returns number of processed octets in buf | |
3342 | |
3343 */ | |
3344 GLOBAL UBYTE DecodeRPAddress(UBYTE *c_num, UBYTE *ton, | |
3345 UBYTE *npi, UBYTE *bcd, UBYTE *buf) | |
3346 { | |
3347 UBYTE sca_length; /* sca length is lenth in bytes plus TOA-octet */ | |
3348 UBYTE processed_octets; | |
3349 | |
3350 sca_length = *buf++; | |
3351 *ton = (*buf & 0x70)>>4; | |
3352 *npi = *buf++ & 0x0F; | |
3353 | |
3354 *c_num = (UBYTE)cmh_unpackBCD (bcd, buf, (USHORT)(sca_length-1)); | |
3355 | |
3356 processed_octets = (*c_num+1)/2 + 2; | |
3357 | |
3358 return processed_octets; | |
3359 } | |
3360 | |
3361 /* | |
3362 +--------------------------------------------------------------------+ | |
3363 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
3364 | STATE : code ROUTINE : DecodeTPAddress | | |
3365 +--------------------------------------------------------------------+ | |
3366 | |
3367 PURPOSE : converts TP address (DA, OA)from semi-octet | |
3368 representation to address in BCD format (including | |
3369 address-length, ton and npi) | |
3370 | |
3371 returns number of processed octets in buf | |
3372 | |
3373 */ | |
3374 GLOBAL UBYTE DecodeTPAddress(UBYTE *c_num, UBYTE *ton, | |
3375 UBYTE *npi, UBYTE *bcd, UBYTE *buf) | |
3376 { | |
3377 UBYTE digits; | |
3378 UBYTE processed_octets; | |
3379 | |
3380 digits = *buf++; | |
3381 *ton = (*buf & 0x70)>>4; | |
3382 *npi = *buf++ & 0x0F; | |
3383 | |
3384 *c_num = (UBYTE)cmh_unpackBCD (bcd, buf, (USHORT)((digits+1)/2)); | |
3385 | |
3386 processed_octets = (*c_num+1)/2 + 2; | |
3387 | |
3388 return processed_octets; | |
3389 } | |
3390 | |
3391 | |
3392 | |
3393 | |
3394 /* | |
3395 +--------------------------------------------------------------------+ | |
3396 | PROJECT : MODULE : CMH_SMSF | | |
3397 | STATE : code ROUTINE : cmhSMS_fillTpSubmit | | |
3398 +--------------------------------------------------------------------+ | |
3399 | |
3400 PURPOSE : fills a T_TP_SUBMIT | |
3401 | |
3402 */ | |
3403 GLOBAL void cmhSMS_fillTpSubmit (T_TP_SUBMIT* tp_submit, | |
3404 T_ACI_CMD_SRC srcId, | |
3405 UBYTE msgType, | |
3406 UBYTE mr, | |
3407 T_tp_da* da_addr, | |
3408 T_ACI_SM_DATA* data, | |
3409 UBYTE septets, | |
3410 T_ACI_UDH_DATA* udh ) | |
3411 { | |
3412 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
3413 UBYTE alphabet; | |
3414 | |
3415 TRACE_FUNCTION ("cmhSMS_fillTpSubmit()"); | |
3416 | |
3417 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
3418 | |
3419 memset(tp_submit, 0, sizeof(T_TP_SUBMIT)); | |
3420 | |
3421 tp_submit->tp_vt_mti = SMS_VT_SUBMIT; | |
3422 tp_submit->tp_rp = (msgType & TP_RP_MASK) ? 1 : 0; | |
3423 tp_submit->tp_mti = SMS_SUBMIT; | |
3424 tp_submit->tp_mr = mr; | |
3425 tp_submit->tp_srr = (msgType & TP_SRR_MASK) ? 1 : 0; | |
3426 | |
3427 if (da_addr->digits NEQ 0x00) | |
3428 memcpy(&tp_submit->tp_da, da_addr, sizeof(T_tp_da)); | |
3429 | |
3430 tp_submit->tp_pid = pSMSSetPrm -> pid; | |
3431 tp_submit->tp_dcs = pSMSSetPrm -> dcs; | |
3432 | |
3433 switch (msgType & VPF_MASK) | |
3434 { | |
3435 | |
3436 case VPF_RELATIVE: /* validity period relative */ | |
3437 tp_submit->v_tp_vp_rel = 1; | |
3438 tp_submit->tp_vpf = SMS_VPF_RELATIVE; | |
3439 tp_submit->tp_vp_rel = pSMSSetPrm -> vpRel; | |
3440 break; | |
3441 | |
3442 case VPF_ABSOLUTE: /* validity period absolute */ | |
3443 tp_submit->v_tp_vp_abs = 1; | |
3444 tp_submit->tp_vpf = SMS_VPF_ABSOLUTE; | |
3445 memcpy(&tp_submit->tp_vp_abs, &pSMSSetPrm -> vpAbs, sizeof(T_tp_vp_abs)); | |
3446 break; | |
3447 | |
3448 case VPF_ENHANCED: /* validity period enhanced */ | |
3449 tp_submit->v_tp_vp_enh = 1; | |
3450 tp_submit->tp_vpf = SMS_VPF_ENHANCED; | |
3451 memcpy(&tp_submit->tp_vp_enh, &pSMSSetPrm -> vpEnh, sizeof(T_tp_vp_enh)); | |
3452 break; | |
3453 | |
3454 default: /* validity period not present */ | |
3455 break; | |
3456 } | |
3457 | |
3458 | |
3459 alphabet = cmhSMS_getAlphabetPp ( pSMSSetPrm -> dcs ); | |
3460 | |
3461 if ((udh) AND (udh->len)) | |
3462 { | |
3463 tp_submit->tp_udhi = 1; | |
3464 tp_submit->v_tp_udh_inc = 1; | |
3465 tp_submit->tp_udh_inc.tp_udh.c_data = udh->len; | |
3466 memcpy(tp_submit->tp_udh_inc.tp_udh.data, udh->data, udh->len); | |
3467 | |
3468 /* copy user data */ | |
3469 if ((data) AND (data->len)) | |
3470 { | |
3471 tp_submit->tp_udh_inc.c_data = data->len; | |
3472 memcpy(tp_submit->tp_udh_inc.data, data->data, data->len); | |
3473 } | |
3474 | |
3475 /* 7-bit data */ | |
3476 if (alphabet EQ 0x00) | |
3477 { | |
3478 tp_submit->tp_udh_inc.length = septets + (((udh->len+1)*8)/7); | |
3479 | |
3480 /* space for the fill bits */ | |
3481 if (((udh->len+1)*8)%7 NEQ 0) | |
3482 { | |
3483 tp_submit->tp_udh_inc.length++; | |
3484 if ((data EQ NULL) OR (data->len EQ 0)) | |
3485 { | |
3486 tp_submit->tp_udh_inc.c_data = 1; | |
3487 tp_submit->tp_udh_inc.data[0] = 0; /* redundant */ | |
3488 } | |
3489 } | |
3490 } | |
3491 /* 8-bit data */ | |
3492 else | |
3493 { | |
3494 tp_submit->tp_udh_inc.length = tp_submit->tp_udh_inc.c_data+udh->len+1; /* UDH length should be also added */ | |
3495 } | |
3496 } | |
3497 else | |
3498 { | |
3499 /* validity flag set for both normal SMS and empty SMS */ | |
3500 tp_submit->v_tp_ud = 1; | |
3501 | |
3502 if ((data) AND (data->len)) | |
3503 { | |
3504 tp_submit->tp_ud.length = septets; | |
3505 tp_submit->tp_ud.c_data = data->len; | |
3506 memcpy(tp_submit->tp_ud.data, data->data, data->len); | |
3507 } | |
3508 else | |
3509 { | |
3510 /* enters when zero character SMS to be sent */ | |
3511 } | |
3512 } | |
3513 } | |
3514 | |
3515 | |
3516 | |
3517 /* | |
3518 +--------------------------------------------------------------------+ | |
3519 | PROJECT : MODULE : CMH_SMSF | | |
3520 | STATE : code ROUTINE : cmhSMS_fillTpDeliver | | |
3521 +--------------------------------------------------------------------+ | |
3522 | |
3523 PURPOSE : fills a T_TP_DELIVER (only used by +CMGW) | |
3524 | |
3525 */ | |
3526 GLOBAL void cmhSMS_fillTpDeliver (T_TP_DELIVER* tp_deliver, | |
3527 T_ACI_CMD_SRC srcId, | |
3528 UBYTE msgType, | |
3529 T_tp_oa* oa_addr, | |
3530 T_ACI_SM_DATA* data, | |
3531 UBYTE septets, | |
3532 T_ACI_UDH_DATA* udh ) | |
3533 { | |
3534 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
3535 UBYTE alphabet; | |
3536 | |
3537 TRACE_FUNCTION ("cmhSMS_fillTpDeliver()"); | |
3538 | |
3539 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
3540 | |
3541 memset(tp_deliver, 0, sizeof(T_TP_DELIVER)); | |
3542 | |
3543 tp_deliver->tp_vt_mti = SMS_VT_DELIVER; | |
3544 tp_deliver->tp_rp = (msgType & TP_RP_MASK) ? 1 : 0; | |
3545 tp_deliver->tp_mti = SMS_DELIVER; | |
3546 | |
3547 if (oa_addr->digits NEQ 0x00) | |
3548 memcpy(&tp_deliver->tp_oa, oa_addr, sizeof(T_tp_oa)); | |
3549 | |
3550 tp_deliver->tp_pid = pSMSSetPrm -> pid; | |
3551 tp_deliver->tp_dcs = pSMSSetPrm -> dcs; | |
3552 | |
3553 memcpy(&tp_deliver->tp_scts, &pSMSSetPrm -> vpAbs, sizeof(T_tp_scts)); | |
3554 | |
3555 if ((data) AND (data->len)) | |
3556 { | |
3557 alphabet = cmhSMS_getAlphabetPp ( pSMSSetPrm -> dcs ); | |
3558 | |
3559 if ((udh) AND (udh->len)) | |
3560 { | |
3561 tp_deliver->tp_udhi = 1; | |
3562 tp_deliver->v_tp_udh_inc = 1; | |
3563 tp_deliver->tp_udh_inc.tp_udh.c_data = udh->len; | |
3564 memcpy(tp_deliver->tp_udh_inc.tp_udh.data, udh->data, udh->len); | |
3565 | |
3566 /* copy user data */ | |
3567 tp_deliver->tp_udh_inc.c_data = data->len; | |
3568 memcpy(tp_deliver->tp_udh_inc.data, data->data, data->len); | |
3569 | |
3570 /* 7-bit data */ | |
3571 if (alphabet EQ 0x00) | |
3572 { | |
3573 tp_deliver->tp_udh_inc.length = septets + (((udh->len+1)*8)/7); | |
3574 | |
3575 /* space for the fill bits */ | |
3576 if (((udh->len+1)*8)%7 NEQ 0) tp_deliver->tp_udh_inc.length++; | |
3577 } | |
3578 /* 8-bit data */ | |
3579 else | |
3580 { | |
3581 tp_deliver->tp_udh_inc.length = tp_deliver->tp_udh_inc.c_data; | |
3582 } | |
3583 } | |
3584 else | |
3585 { | |
3586 tp_deliver->v_tp_ud = 1; | |
3587 tp_deliver->tp_ud.length = septets; | |
3588 tp_deliver->tp_ud.c_data = data->len; | |
3589 memcpy(tp_deliver->tp_ud.data, data->data, data->len); | |
3590 } | |
3591 } | |
3592 else /* if ((data) AND (data->len)) */ | |
3593 { | |
3594 tp_deliver->v_tp_ud = 1; | |
3595 tp_deliver->tp_ud.length = 0; | |
3596 } | |
3597 } | |
3598 | |
3599 | |
3600 /* | |
3601 +--------------------------------------------------------------------+ | |
3602 | PROJECT : MODULE : CMH_SMSF | | |
3603 | STATE : code ROUTINE : cmhSMS_fillTpCommand | | |
3604 +--------------------------------------------------------------------+ | |
3605 | |
3606 PURPOSE : fills a T_TP_COMMAND | |
3607 | |
3608 */ | |
3609 GLOBAL void cmhSMS_fillTpCommand ( T_TP_COMMAND* tp_command, | |
3610 UBYTE fo, | |
3611 UBYTE ct, | |
3612 UBYTE mr, | |
3613 UBYTE pid, | |
3614 UBYTE mn, | |
3615 T_tp_da* da_addr, | |
3616 T_ACI_CMD_DATA* data, | |
3617 T_ACI_UDH_DATA* udh) | |
3618 | |
3619 { | |
3620 TRACE_FUNCTION ("cmhSMS_fillTpCommand()"); | |
3621 | |
3622 memset(tp_command, 0, sizeof(T_TP_COMMAND)); | |
3623 | |
3624 tp_command->tp_vt_mti = SMS_VT_COMMAND; | |
3625 tp_command->tp_srr = (fo & TP_SRR_MASK) ? 1 : 0; | |
3626 tp_command->tp_mti = SMS_COMMAND; | |
3627 tp_command->tp_mr = mr; | |
3628 tp_command->tp_pid = pid; | |
3629 tp_command->tp_ct = ct; | |
3630 tp_command->tp_mn = mn; | |
3631 | |
3632 if (da_addr->digits NEQ 0x00) | |
3633 memcpy(&tp_command->tp_da, da_addr, sizeof(T_tp_da)); | |
3634 | |
3635 if ((data) AND (data->len)) | |
3636 { | |
3637 if ((udh) AND (udh->len)) | |
3638 { | |
3639 tp_command->tp_udhi = 1; | |
3640 tp_command->v_tp_cdh_inc = 1; | |
3641 tp_command->tp_cdh_inc.tp_udh.c_data = udh->len; | |
3642 memcpy(tp_command->tp_cdh_inc.tp_udh.data, udh->data, udh->len); | |
3643 tp_command->tp_cdh_inc.c_data = data->len; | |
3644 memcpy(tp_command->tp_cdh_inc.data, data->data, data->len); | |
3645 } | |
3646 else | |
3647 { | |
3648 tp_command->v_tp_cd = 1; | |
3649 tp_command->tp_cd.c_data = data->len; | |
3650 memcpy(tp_command->tp_cd.data, data->data, data->len); | |
3651 } | |
3652 } | |
3653 else | |
3654 { | |
3655 /* command length field must be present */ | |
3656 tp_command->v_tp_cd = 1; | |
3657 tp_command->tp_cd.c_data = 0; | |
3658 } | |
3659 | |
3660 } | |
3661 #ifdef FF_CPHS | |
3662 | |
3663 /* | |
3664 +----------------------------------------------------------------------+ | |
3665 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3666 | ROUTINE : cmhSMS_check_voice_mail_ind| | |
3667 +----------------------------------------------------------------------+ | |
3668 | |
3669 PURPOSE : | |
3670 */ | |
3671 | |
3672 LOCAL BOOL cmhSMS_check_voice_mail_ind( T_TP_DELIVER *sms_deliver ) | |
3673 { | |
3674 TRACE_FUNCTION("cmhSMS_check_voice_mail_ind()"); | |
3675 | |
3676 if ( sms_deliver->tp_oa.digits NEQ 4 OR | |
3677 sms_deliver->tp_oa.ton NEQ SMS_TON_ALPHANUMERIC ) | |
3678 { | |
3679 TRACE_EVENT_P2("no vmi -> oa... digits:%d ton:%d", | |
3680 sms_deliver->tp_oa.digits, sms_deliver->tp_oa.ton); | |
3681 return FALSE; | |
3682 } | |
3683 | |
3684 switch (sms_deliver->tp_dcs & 0xF0) | |
3685 { | |
3686 case SMS_DCS_GRP_DEF: | |
3687 case SMS_DCS_GRP_CLASS: | |
3688 if ( (sms_deliver->tp_dcs & 0xF) EQ 0 OR | |
3689 (sms_deliver->tp_dcs & 0xF) EQ 0xC ) | |
3690 { | |
3691 break; /* GSM Default Alphabet */ | |
3692 } | |
3693 /* no break, if FALSE */ | |
3694 /*lint -fallthrough*/ | |
3695 case SMS_DCS_GRP_COMPR: | |
3696 case SMS_DCS_GRP_CLASS_COMPR: | |
3697 case SMS_DCS_GRP_MW_STORE_UCS2: | |
3698 TRACE_EVENT_P1("no vmi -> dcs: %d", sms_deliver->tp_dcs); | |
3699 return FALSE; /* no GSM Default Alphabet */ | |
3700 case SMS_DCS_DATA_CLASS: | |
3701 if (sms_deliver->tp_dcs & 0x4) | |
3702 { | |
3703 TRACE_EVENT_P1("no vmi -> dcs: %d", sms_deliver->tp_dcs); | |
3704 return FALSE; /* no GSM Default Alphabet */ | |
3705 } | |
3706 } | |
3707 | |
3708 if (!sms_deliver->v_tp_ud) | |
3709 { | |
3710 TRACE_EVENT("no vmi -> no ud"); | |
3711 return FALSE; /* not only text present */ | |
3712 } | |
3713 if ( ( sms_deliver->tp_ud.length NEQ 1 ) OR | |
3714 ( (sms_deliver->tp_ud.data[0] & 0x7F) NEQ ' ') ) | |
3715 { | |
3716 TRACE_EVENT_P2("no vmi -> ud... length:%d data[0]:%d", | |
3717 sms_deliver->tp_ud.length, sms_deliver->tp_ud.data[0]); | |
3718 return FALSE; /* no single space */ | |
3719 } | |
3720 | |
3721 TRACE_FUNCTION ("CPHS VWI: send to cphs module"); | |
3722 | |
3723 return TRUE; | |
3724 } | |
3725 | |
3726 | |
3727 /* | |
3728 +-------------------------------------------------------------------------+ | |
3729 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3730 | ROUTINE : cmhSMS_voice_mail_ind_get_line| | |
3731 +-------------------------------------------------------------------------+ | |
3732 | |
3733 PURPOSE : | |
3734 */ | |
3735 LOCAL void cmhSMS_voice_mail_ind_get_data( T_TP_DELIVER *sms_deliver, | |
3736 UBYTE *flag_set, | |
3737 T_CPHS_LINES *line ) | |
3738 { | |
3739 TRACE_FUNCTION("cmhSMS_voice_mail_ind_get_line()"); | |
3740 | |
3741 /* get flag set, which is send in the first bit of the first | |
3742 byte of the originating address number. Due to the decoding | |
3743 each byte of the originating address number is now splitted | |
3744 into 2 bytes, so that the first 4 bits of the former first | |
3745 byte can be found in byte 1 */ | |
3746 *flag_set = sms_deliver->tp_oa.num[0] & 0x1; | |
3747 | |
3748 /* line is coded in character 1 bit 1 of second byte of GSM originating | |
3749 address based on 7bit default alphabet. In the message indication we | |
3750 get the data in the last bit of the first byte of the orginating address. | |
3751 Due to the decoding each byte of the originating address number is now | |
3752 splitted into 2 bytes, so that the last 4 bits of the former first | |
3753 byte can be found in byte 2 */ | |
3754 | |
3755 if (sms_deliver->tp_oa.num[1] & 0x8) | |
3756 | |
3757 { | |
3758 *line = CPHS_LINE2; | |
3759 } | |
3760 else | |
3761 { | |
3762 *line = CPHS_LINE1; | |
3763 } | |
3764 } | |
3765 | |
3766 | |
3767 /* | |
3768 +----------------------------------------------------------------------+ | |
3769 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3770 | ROUTINE : cmhSMS_voice_mail_ind | | |
3771 +----------------------------------------------------------------------+ | |
3772 | |
3773 PURPOSE : | |
3774 */ | |
3775 | |
3776 GLOBAL BOOL cmhSMS_voice_mail_ind( T_sms_sdu *sms_sdu) | |
3777 { | |
3778 T_TP_DELIVER *sms_deliver; | |
3779 T_rp_addr rp_addr; | |
3780 T_CPHS_LINES line; | |
3781 UBYTE flag_set; | |
3782 UBYTE *message; | |
3783 | |
3784 TRACE_FUNCTION("cmhSMS_voice_mail_ind()"); | |
3785 | |
3786 /* check if cphs is active */ | |
3787 | |
3788 | |
3789 /* check if indication is voice mail indication */ | |
3790 if ( sms_sdu ) | |
3791 { | |
3792 message = cmhSMS_decodeMsg(sms_sdu, &rp_addr, SMS_VT_DELIVER); | |
3793 | |
3794 if (message EQ NULL) | |
3795 return FALSE; | |
3796 | |
3797 if ( message[0] NEQ SMS_VT_DELIVER) | |
3798 { | |
3799 TRACE_EVENT_P1("wrong VTI = %x", message[0]); | |
3800 } | |
3801 | |
3802 sms_deliver = (T_TP_DELIVER*)message; | |
3803 | |
3804 if ( cphs_check_status() EQ CPHS_OK ) | |
3805 { | |
3806 if ( cmhSMS_check_voice_mail_ind(sms_deliver) ) | |
3807 { | |
3808 cmhSMS_voice_mail_ind_get_data(sms_deliver, &flag_set, &line); | |
3809 | |
3810 cphs_voice_mail_ind(flag_set, line); | |
3811 | |
3812 return TRUE; | |
3813 } | |
3814 } | |
3815 } | |
3816 return FALSE; | |
3817 } | |
3818 | |
3819 #endif /* FF_CPHS*/ | |
3820 | |
3821 | |
3822 /* | |
3823 +----------------------------------------------------------------------+ | |
3824 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3825 | ROUTINE : cmhSMS_resetMtDsCnmiParam | | |
3826 +----------------------------------------------------------------------+ | |
3827 PURPOSE : this function resets the <mt> and <ds> parameter for the | |
3828 SMS acknowledge in Phase2+ mode (+CNMA). | |
3829 */ | |
3830 GLOBAL void cmhSMS_resetMtDsCnmiParam(void) | |
3831 { | |
3832 smsShrdPrm.mtHndl = 0; /* reset <mt> and <ds> param in error case */ | |
3833 smsShrdPrm.srHndl = 0; | |
3834 | |
3835 smsShrdPrm.CNMImt = CNMI_MT_NoSmsDeliverInd; | |
3836 smsShrdPrm.CNMIds = CNMI_DS_NoSmsStatRpt; | |
3837 /* Implements measure 149 */ | |
3838 cmhSMS_sendConfigureReq (FALSE); | |
3839 } | |
3840 | |
3841 /* | |
3842 +-------------------------------------------------------------------+ | |
3843 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3844 | STATE : code ROUTINE : sAT_PlusCMGWPdu | | |
3845 +-------------------------------------------------------------------+ | |
3846 | |
3847 PURPOSE : This is the internal function which is responsible for | |
3848 storing messages into the mobile station or SIM card. | |
3849 AT command which is responsible for writing a short | |
3850 message to memory in PDU mode. | |
3851 */ | |
3852 GLOBAL BOOL cmhSMS_storePduToSim( T_ACI_CMD_SRC srcId, | |
3853 UBYTE stat, | |
3854 T_ACI_SM_DATA *pdu ) | |
3855 { | |
3856 T_ACI_RETURN ret; | |
3857 | |
3858 TRACE_FUNCTION ("cmhSMS_storePduToSim()"); | |
3859 | |
3860 /* check if command executable */ | |
3861 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3862 { | |
3863 return FALSE; | |
3864 } | |
3865 | |
3866 { | |
3867 PALLOC (mnsms_store_req, MNSMS_STORE_REQ); | |
3868 | |
3869 mnsms_store_req -> mem_type = smsShrdPrm.mem2; | |
3870 mnsms_store_req -> rec_num = CMGW_IDX_FREE_ENTRY; | |
3871 mnsms_store_req -> condx = SMS_CONDX_OVR_NON; | |
3872 mnsms_store_req -> status = stat; | |
3873 | |
3874 if ( (pdu->len > 0) AND (pdu->len <= SIM_PDU_LEN) ) | |
3875 { | |
3876 mnsms_store_req->sms_sdu.l_buf = pdu->len * 8; | |
3877 mnsms_store_req->sms_sdu.o_buf = 0; | |
3878 memcpy (mnsms_store_req->sms_sdu.buf, pdu->data, pdu->len); | |
3879 } | |
3880 else | |
3881 { | |
3882 TRACE_FUNCTION ("cmhSMS_storePduToSim() : wrong PDU len"); | |
3883 PFREE (mnsms_store_req); | |
3884 return FALSE; | |
3885 } | |
3886 | |
3887 PSENDX (SMS, mnsms_store_req); | |
3888 } | |
3889 | |
3890 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGW; | |
3891 smsShrdPrm.owner = (T_OWN)srcId; | |
3892 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3893 smsShrdPrm.uiInternalSmsStorage = srcId; | |
3894 | |
3895 return TRUE; | |
3896 } | |
3897 | |
3898 /* | |
3899 +--------------------------------------------------------------------+ | |
3900 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3901 | STATE : code ROUTINE : cmhSMS_removeStatusRFUBits | | |
3902 +--------------------------------------------------------------------+ | |
3903 | |
3904 PURPOSE : ACI-SPR-17004: Method for removing of SMS RFU status | |
3905 bits as defined by GSM 11.11 section 9.3 | |
3906 | |
3907 */ | |
3908 GLOBAL void cmhSMS_removeStatusRFUBits ( UBYTE* status ) | |
3909 { | |
3910 TRACE_FUNCTION("cmhSMS_removeStatusRFUBits()"); | |
3911 | |
3912 /* See GSM 11.11 section 10.5.3 for position of RFU bits in status */ | |
3913 | |
3914 /* test the pattern of the three lowest bits, match for "101" */ | |
3915 if ((*status & 0x07) EQ 0x05) | |
3916 { | |
3917 /* set the highest three bits to 0 */ | |
3918 *status &= 0x1F; | |
3919 } | |
3920 else | |
3921 { | |
3922 /* set the highest five bits to 0 */ | |
3923 *status &= 0x07; | |
3924 } | |
3925 | |
3926 } | |
3927 | |
3928 /* | |
3929 +-------------------------------------------------------------------------+ | |
3930 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3931 | STATE : code ROUTINE : cmhSMS_convertDeliverStatusToACI| | |
3932 +-------------------------------------------------------------------------+ | |
3933 | |
3934 PURPOSE : converts the SMS delivery status to ACI CPRSM status. | |
3935 | |
3936 */ | |
3937 GLOBAL T_ACI_CPRSM_MOD cmhSMS_convertDeliverStatusToACI ( UBYTE status ) | |
3938 { | |
3939 T_ACI_CPRSM_MOD mode; | |
3940 | |
3941 TRACE_FUNCTION("cmhSMS_convertDeliverStatusToACI()"); | |
3942 | |
3943 switch (status) | |
3944 { | |
3945 case SMS_DELIVER_STATUS_PAUSE: | |
3946 mode = CPRSM_MOD_Pause; | |
3947 break; | |
3948 case SMS_DELIVER_STATUS_RESUME: | |
3949 mode = CPRSM_MOD_Resume; | |
3950 break; | |
3951 default: | |
3952 mode = CPRSM_MOD_NotPresent; | |
3953 } | |
3954 return mode; | |
3955 } | |
3956 | |
3957 #ifdef FF_CPHS_REL4 | |
3958 /* | |
3959 +-------------------------------------------------------------------------+ | |
3960 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3961 | STATE : code ROUTINE : cmhSMS_chk_WtngInd | | |
3962 +-------------------------------------------------------------------------+ | |
3963 | |
3964 PURPOSE : This function expect an already decoded SMS in the T_TP_DELIVER | |
3965 format and checks if it is a "special SMS" (refer to TS 23.040, | |
3966 chpt. 9.2.3.24.2). | |
3967 | |
3968 */ | |
3969 LOCAL BOOL cmhSMS_chk_WtngInd( T_TP_DELIVER *pSms ) | |
3970 { | |
3971 | |
3972 TRACE_FUNCTION("cmhSMS_chk_WtngInd"); | |
3973 return ( (pSms->tp_udhi) AND /* it is an UDH message */ | |
3974 (pSms->v_tp_udh_inc) AND /* UDH successfuly decoded */ | |
3975 (pSms->tp_udh_inc.tp_udh.c_data >= 4) AND /* min len of special SMS */ | |
3976 (pSms->tp_udh_inc.tp_udh.data[0] EQ 0x01) | |
3977 ); | |
3978 } | |
3979 | |
3980 | |
3981 /* | |
3982 +-------------------------------------------------------------------------+ | |
3983 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
3984 | STATE : code ROUTINE : cmhSMS_chk_SpclMsg | | |
3985 +-------------------------------------------------------------------------+ | |
3986 | |
3987 PURPOSE : This function checks if the received SMS is a special sms which | |
3988 indicates the message waiting status.If so,the message will be processed | |
3989 and TRUE will be returned,indicating that the message was already handled. | |
3990 If it is no special message , the function will returns FALSE causing the | |
3991 SMS to be treated in the common way. | |
3992 | |
3993 */ | |
3994 | |
3995 GLOBAL BOOL cmhSMS_chk_SpclMsg( T_MNSMS_MESSAGE_IND *mnsms_message_ind ) | |
3996 { | |
3997 BOOL res = FALSE ; | |
3998 T_MSG_WAITING_TYPE msgType = MSG_WAITING_TYPE_INVALID; | |
3999 U8 *ptr; | |
4000 T_TP_DELIVER *smDlvr; | |
4001 | |
4002 TRACE_FUNCTION( "cmhSMS_chk_SpclMsg()" ); | |
4003 | |
4004 if(!psaSIM_ChkSIMSrvSup( SRV_No_54 )) | |
4005 { | |
4006 return res; | |
4007 } | |
4008 | |
4009 if (&mnsms_message_ind->sms_sdu) | |
4010 { | |
4011 T_rp_addr rpAddr; | |
4012 UBYTE *pMsg; | |
4013 | |
4014 pMsg = cmhSMS_decodeMsg( &mnsms_message_ind->sms_sdu, &rpAddr, SMS_VT_DELIVER ); | |
4015 smDlvr = (T_TP_DELIVER *)pMsg; | |
4016 | |
4017 if (pMsg) | |
4018 { | |
4019 if (pMsg[0] NEQ SMS_VT_DELIVER) | |
4020 { | |
4021 TRACE_EVENT_P1( "wrong VTI = %x", (int)pMsg[0] ); | |
4022 } | |
4023 | |
4024 /* Check the reqired fields in the SMS to qaulify for Special Message */ | |
4025 | |
4026 if (cmhSMS_chk_WtngInd( smDlvr )) | |
4027 { | |
4028 | |
4029 /* For Loop: Decode the SMS properly as ,more than one type of message | |
4030 can be indicated within one SMS message. A varible for | |
4031 tp_udh_inc.tp_udh.data has been avoided , therefore For loop | |
4032 seems to be lengthy, | |
4033 */ | |
4034 for( ptr = smDlvr->tp_udh_inc.tp_udh.data ; | |
4035 ptr < &smDlvr->tp_udh_inc.tp_udh.data[smDlvr->tp_udh_inc.tp_udh.c_data ]; | |
4036 ptr +=(ptr[1] + 2 )) | |
4037 { | |
4038 /* Filling the Message Type */ | |
4039 | |
4040 msgType = (ptr[2] & 0x03); /* see TS 23.040 */ | |
4041 | |
4042 /* Update Status field in EF-MWIS according to the values already | |
4043 present in the SIM and the current values in the recieved SMS. | |
4044 Also if the count for any type of Special SMS is ZERO then | |
4045 also update the status. | |
4046 */ | |
4047 if( (!(smsShrdPrm.MWISdata.mwiStat >> msgType & 1U)) OR (ptr[3] EQ 0) ) | |
4048 { | |
4049 smsShrdPrm.MWISdata.mwiStat ^= 1U << msgType; | |
4050 } | |
4051 | |
4052 /* Filling the count for specfic type of SMS */ | |
4053 | |
4054 switch ( msgType ) | |
4055 { | |
4056 case MSG_WAITING_TYPE_VOICE : | |
4057 smsShrdPrm.MWISdata.mwis_count_voice = ptr[3]; | |
4058 break; | |
4059 case MSG_WAITING_TYPE_FAX : | |
4060 smsShrdPrm.MWISdata.mwis_count_fax = ptr[3]; | |
4061 break; | |
4062 case MSG_WAITING_TYPE_EMAIL : | |
4063 smsShrdPrm.MWISdata.mwis_count_email = ptr[3]; | |
4064 break; | |
4065 case MSG_WAITING_TYPE_OTHER : | |
4066 smsShrdPrm.MWISdata.mwis_count_other = ptr[3]; | |
4067 break; | |
4068 default: | |
4069 TRACE_EVENT("INVALID MESSAGE TYPE"); | |
4070 return FALSE; | |
4071 } | |
4072 } | |
4073 | |
4074 /* Writing decoded data to EF-MWIS */ | |
4075 | |
4076 if(cmhSIM_WrMwis(CMD_SRC_NONE,MWIS_MOD_Write,1, | |
4077 &smsShrdPrm.MWISdata) NEQ AT_EXCT ) | |
4078 { | |
4079 TRACE_EVENT(" Error in Sending the Sim Update Request "); | |
4080 } | |
4081 | |
4082 /* If message was stored we need to indicate this, too */ | |
4083 | |
4084 if (mnsms_message_ind->rec_num NEQ SMS_RECORD_NOT_EXIST) | |
4085 { | |
4086 cmhSMS_SMSMemory( mnsms_message_ind ); | |
4087 } | |
4088 res = TRUE; /* message processed, nothing left to do */ | |
4089 } | |
4090 } | |
4091 } | |
4092 return res; | |
4093 } | |
4094 #endif | |
4095 /* Implements Measure # 73 */ | |
4096 | |
4097 /* | |
4098 +-------------------------------------------------------------------+ | |
4099 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSF | | |
4100 | ROUTINE : cmhSMS_findMessageIds | | |
4101 +-------------------------------------------------------------------+ | |
4102 PARAMETERS : lower_mid - lower message id | |
4103 upper_mid - upper message id | |
4104 RETURN : TRUE if message has been found, else FALSE | |
4105 | |
4106 PURPOSE : Find message ids based on the mids given as parameters and | |
4107 update smsShrdPrm.cbmPrm.cbmFoundIds based on the same. | |
4108 | |
4109 */ | |
4110 LOCAL BOOL cmhSMS_findMessageIds (USHORT lower_mid, USHORT upper_mid) | |
4111 { | |
4112 TRACE_FUNCTION("cmhSMS_findMessageIds()"); | |
4113 /* | |
4114 * If the msg ids are same that in FFS and SIM, then restore else reset | |
4115 * to default values | |
4116 */ | |
4117 if (smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2] EQ lower_mid | |
4118 AND smsShrdPrm.cbmPrm.msgId[smsShrdPrm.cbmPrm.cbmFoundIds * 2 + 1] EQ upper_mid) | |
4119 { | |
4120 smsShrdPrm.cbmPrm.cbmFoundIds++; | |
4121 } | |
4122 else | |
4123 { | |
4124 cmhSMS_clearCbmPrm(); | |
4125 return FALSE; | |
4126 } | |
4127 return TRUE; | |
4128 } | |
4129 | |
4130 /* Implements Measure # 126 */ | |
4131 /* | |
4132 +---------------------------------------------------------------------------+ | |
4133 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
4134 | STATE : code ROUTINE : cmhSMS_processOrigDestAddr| | |
4135 +---------------------------------------------------------------------------+ | |
4136 PARAMETERS : sm - Structure into which the data is filled. | |
4137 rp_addr - RP Address used for filling sm | |
4138 tp_addr - destination or origination address that has to be | |
4139 filled in sm | |
4140 RETURN : None | |
4141 | |
4142 PURPOSE : Processes originator address and converts it into 8 bit or string | |
4143 format as requried | |
4144 | |
4145 */ | |
4146 LOCAL void cmhSMS_processOrigDestAddr (T_ACI_CMGL_SM *sm, | |
4147 T_rp_addr *rp_addr, | |
4148 T_tp_da *tp_addr) | |
4149 { | |
4150 TRACE_FUNCTION("cmhSMS_processOrigDestAddr()"); | |
4151 /* | |
4152 *----------------------------------------------------------------- | |
4153 * process address | |
4154 *----------------------------------------------------------------- | |
4155 */ | |
4156 if (tp_addr->ton EQ SMS_TON_ALPHANUMERIC) | |
4157 { | |
4158 UBYTE i,j = 0; | |
4159 UBYTE dest_len; | |
4160 CHAR address_buf[MAX_SMS_ADDR_DIG/2]; | |
4161 | |
4162 for (i = 0 ; i < tp_addr->digits ; i=i+2) | |
4163 { | |
4164 address_buf[j] = (UBYTE)(tp_addr->num[i+1] << 4) + (UBYTE)(tp_addr->num[i]); | |
4165 j++; | |
4166 } | |
4167 | |
4168 if( tp_addr->digits % 2 ) | |
4169 { | |
4170 address_buf[j-1] = address_buf[j-1] & 0x0f; | |
4171 } | |
4172 | |
4173 dest_len = utl_cvt7To8 ( (UBYTE*)address_buf, j, (UBYTE*)sm->adress, 0); | |
4174 sm -> adress[dest_len] = '\0'; | |
4175 | |
4176 if( (tp_addr->digits % 2) AND (dest_len + 3) % 8 >= 4 ) | |
4177 sm -> adress[dest_len--] = '\0'; | |
4178 else | |
4179 sm -> adress[dest_len] = '\0'; | |
4180 | |
4181 } | |
4182 else | |
4183 { | |
4184 cmhSMS_getAdrStr ( sm -> adress, | |
4185 MAX_SMS_NUM_LEN - 1, | |
4186 tp_addr->num, | |
4187 tp_addr->digits ); | |
4188 } | |
4189 sm -> toa.ton = cmhSMS_getTon ( tp_addr->ton ); | |
4190 sm -> toa.npi = cmhSMS_getNpi ( tp_addr->npi ); | |
4191 /* | |
4192 *----------------------------------------------------------------- | |
4193 * process service center address | |
4194 *----------------------------------------------------------------- | |
4195 */ | |
4196 cmhSMS_getAdrStr ( sm -> sca, | |
4197 MAX_SMS_NUM_LEN - 1, | |
4198 rp_addr->num, | |
4199 rp_addr->c_num); | |
4200 | |
4201 sm -> tosca.ton = cmhSMS_getTon ( rp_addr->ton ); | |
4202 sm -> tosca.npi = cmhSMS_getNpi ( rp_addr->npi ); | |
4203 | |
4204 /* | |
4205 *----------------------------------------------------------------- | |
4206 * process alphanumerical phonebook entry | |
4207 *----------------------------------------------------------------- | |
4208 */ | |
4209 psaCC_phbMfwSrchNumPlnTxt ( sm -> adress, &sm -> alpha ); | |
4210 } | |
4211 | |
4212 /* Implements Measure # 149 */ | |
4213 /* | |
4214 +---------------------------------------------------------------------------+ | |
4215 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
4216 | STATE : code ROUTINE : cmhSMS_sendConfigureReq | | |
4217 +---------------------------------------------------------------------------+ | |
4218 PARAMETERS : v_cmms_val - Set to TRUE if cmms_mode and tmms_val has to be | |
4219 filled. | |
4220 RETURN : None | |
4221 | |
4222 PURPOSE : Sends mnsms_configure_req to inform the SMS entity | |
4223 about the parameter changes. v_cmms_val is TRUE if cmms_mode and | |
4224 tmms_val has to be filled. | |
4225 | |
4226 */ | |
4227 GLOBAL void cmhSMS_sendConfigureReq (BOOL v_cmms_val) | |
4228 { | |
4229 TRACE_FUNCTION("cmhSMS_sendConfigureReq()"); | |
4230 { /* inform the SMS entity about the parameter changes */ | |
4231 PALLOC (mnsms_configure_req, MNSMS_CONFIGURE_REQ); | |
4232 | |
4233 /* fill in primitive parameter: command request */ | |
4234 mnsms_configure_req -> pref_mem_3 = smsShrdPrm.mem3; | |
4235 mnsms_configure_req -> mt = smsShrdPrm.mtHndl; | |
4236 mnsms_configure_req -> ds = smsShrdPrm.srHndl; | |
4237 mnsms_configure_req -> mhc = (smsShrdPrm.CSMSservice NEQ CSMS_SERV_GsmPh2Plus) | |
4238 ? SMS_MHC_PH2 : SMS_MHC_PH2PLUS; | |
4239 mnsms_configure_req->v_cmms_mode = mnsms_configure_req->v_tmms_val = | |
4240 v_cmms_val; | |
4241 if(v_cmms_val) | |
4242 { | |
4243 mnsms_configure_req -> cmms_mode = smsShrdPrm.CMMSmode; | |
4244 mnsms_configure_req->tmms_val = CMMS_MODE_TIMER_VAL; | |
4245 } | |
4246 | |
4247 PSENDX (SMS, mnsms_configure_req); | |
4248 } | |
4249 } | |
4250 | |
4251 /* Implements Measure # 110 */ | |
4252 /* | |
4253 +---------------------------------------------------------------------------+ | |
4254 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
4255 | STATE : code ROUTINE : cmhSMS_cpyMsgIndReadCnf | | |
4256 +---------------------------------------------------------------------------+ | |
4257 PARAMETERS : sm - Structure into which the data is filled. | |
4258 status - SMS record status | |
4259 sms_sdu - SMS SDU from which data has to be filled in sm | |
4260 rec_num - Record number of the SMS | |
4261 RETURN : BOOL value indicating the status returned by cmhSMS_cpyDeliver | |
4262 or cmhSMS_cpySubmit | |
4263 | |
4264 PURPOSE : handles a message indication or a read cnf | |
4265 | |
4266 */ | |
4267 GLOBAL BOOL cmhSMS_cpyMsgIndReadCnf (T_ACI_CMGL_SM * sm, | |
4268 UBYTE *status, | |
4269 T_sms_sdu *sms_sdu, | |
4270 UBYTE rec_num) | |
4271 { | |
4272 BOOL ret = FALSE; | |
4273 TRACE_FUNCTION("cmhSMS_cpyMsgIndReadCnf()"); | |
4274 | |
4275 /* | |
4276 *----------------------------------------------------------------- | |
4277 * decode SMS-DELIVER or SMS-SUBMIT | |
4278 *----------------------------------------------------------------- | |
4279 */ | |
4280 | |
4281 /* | |
4282 * ACI-SPR-17004: set RFU bits of status to 0 if present since these | |
4283 * should be ignored in a GSM session (GSM 11.11 section 9.3) | |
4284 */ | |
4285 cmhSMS_removeStatusRFUBits( status ); | |
4286 | |
4287 switch (*status) | |
4288 { | |
4289 case SMS_RECORD_REC_UNREAD: | |
4290 case SMS_RECORD_REC_READ: | |
4291 ret = cmhSMS_cpyDeliver ( sm, sms_sdu ); | |
4292 break; | |
4293 case SMS_RECORD_STO_UNSENT: | |
4294 case SMS_RECORD_STO_SENT: | |
4295 /* ACI-SPR-17003: Handle unsupported statuses */ | |
4296 case SMS_RECORD_STAT_UNRCVD: | |
4297 case SMS_RECORD_STAT_UNSTRD: | |
4298 case SMS_RECORD_STAT_STRD: | |
4299 ret = cmhSMS_cpySubmit ( sm, sms_sdu ); | |
4300 break; | |
4301 /* 21.Mar.2003 currently not used by SMS entity */ | |
4302 /* | |
4303 * case SMS_RECORD_INVALID: | |
4304 * ret = FALSE; | |
4305 * break; | |
4306 */ | |
4307 default: | |
4308 TRACE_EVENT("incorrect status"); | |
4309 } | |
4310 | |
4311 /* | |
4312 *----------------------------------------------------------------- | |
4313 * process status (convert from PSA type to CMH type) | |
4314 *----------------------------------------------------------------- | |
4315 */ | |
4316 if (sm->stat NEQ SMS_STAT_Invalid) | |
4317 { | |
4318 cmhSMS_getStatCmh ( *status, &sm -> stat ); | |
4319 } | |
4320 | |
4321 /* | |
4322 *----------------------------------------------------------------- | |
4323 * process message reference | |
4324 *----------------------------------------------------------------- | |
4325 */ | |
4326 sm -> msg_ref = rec_num; | |
4327 | |
4328 /* | |
4329 *----------------------------------------------------------------- | |
4330 * process tp_status | |
4331 *----------------------------------------------------------------- | |
4332 */ | |
4333 sm ->tp_status = (UBYTE) -1; | |
4334 | |
4335 return (ret); | |
4336 } | |
4337 | |
4338 /* Implements Measure # 9 */ | |
4339 /* | |
4340 +---------------------------------------------------------------------------+ | |
4341 | PROJECT : GSM-F&D (8411) MODULE : CMH_SMSF | | |
4342 | STATE : code ROUTINE : cmhSMS_clearCbmPrm | | |
4343 +---------------------------------------------------------------------------+ | |
4344 PARAMETERS : None | |
4345 RETURN : None | |
4346 | |
4347 PURPOSE : Resets smsShrdPrm.cbmPrm to default values | |
4348 | |
4349 */ | |
4350 LOCAL void cmhSMS_clearCbmPrm (void) | |
4351 { | |
4352 TRACE_FUNCTION("cmhSMS_clearCbmPrm()"); | |
4353 | |
4354 smsShrdPrm.cbmPrm.cbmMode = CBCH_ACCEPT; | |
4355 memset (smsShrdPrm.cbmPrm.msgId, DEF_MID_RANGE, | |
4356 sizeof (smsShrdPrm.cbmPrm.msgId)); | |
4357 memset (smsShrdPrm.cbmPrm.dcsId, DEF_DCS_RANGE, | |
4358 sizeof(smsShrdPrm.cbmPrm.dcsId)); | |
4359 } | |
4360 /*==== EOF ========================================================*/ |