FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/cmh_smss.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_SMSS | |
5 +----------------------------------------------------------------------------- | |
6 | Copyright 2002 Texas Instruments Berlin, AG | |
7 | All rights reserved. | |
8 | | |
9 | This file is confidential and a trade secret of Texas | |
10 | Instruments Berlin, AG | |
11 | The receipt of or possession of this file does not convey | |
12 | any rights to reproduce or disclose its contents or to | |
13 | manufacture, use, or sell anything it may describe, in | |
14 | whole, or in part, without the specific written consent of | |
15 | Texas Instruments Berlin, AG. | |
16 +----------------------------------------------------------------------------- | |
17 | Purpose : This module provides the set functions related to the | |
18 | protocol stack adapter for the short message service. | |
19 +----------------------------------------------------------------------------- | |
20 */ | |
21 | |
22 #ifndef CMH_SMSS_C | |
23 #define CMH_SMSS_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 "gdi.h" | |
42 #include "aci.h" | |
43 #include "aci_lst.h" | |
44 #include "aci_mem.h" | |
45 | |
46 #if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_) | |
47 #include "conc_sms.h" | |
48 #endif | |
49 | |
50 #include "psa.h" | |
51 #include "psa_sms.h" | |
52 #include "psa_mmi.h" | |
53 #include "cmh.h" | |
54 #include "cmh_sms.h" | |
55 #include "pcm.h" | |
56 #include "phb.h" | |
57 #include "cmh_phb.h" | |
58 | |
59 #ifdef SIM_TOOLKIT | |
60 #include "psa_sim.h" | |
61 #include "psa_cc.h" | |
62 #include "psa_sat.h" | |
63 #include "cmh_sat.h" | |
64 #endif /*of SIM_TOOLKIT */ | |
65 | |
66 | |
67 #if 1 | |
68 #include <stdio.h> | |
69 #endif | |
70 | |
71 /*==== CONSTANTS ==================================================*/ | |
72 | |
73 | |
74 #define SMS_CMH_IDX_MAX (255) /* memory location index */ | |
75 /* maximum value */ | |
76 #define SMS_CMH_IDX_MIN (1) /* memory location index */ | |
77 /* minimum value */ | |
78 /*--------------------------------------------------------------*/ | |
79 #define SMS_CMH_MN_MAX (255) /* message number maximum value */ | |
80 #define SMS_CMH_MN_MIN (0) /* message number minimum value */ | |
81 /*--------------------------------------------------------------*/ | |
82 #define SMS_CMH_CT_MAX (255) /* command type maximum value */ | |
83 #define SMS_CMH_CT_MIN (0) /* command type minimum value */ | |
84 /*--------------------------------------------------------------*/ | |
85 #define SMS_CMH_FO_MAX (255) /* first octet maximum value */ | |
86 #define SMS_CMH_FO_MIN (0) /* first octet minimum value */ | |
87 /*--------------------------------------------------------------*/ | |
88 #define SMS_CMH_VPREL_MAX (255) /* relative validity period */ | |
89 /* maximum value */ | |
90 #define SMS_CMH_VPREL_MIN (0) /* relative validity period */ | |
91 /* minimum value */ | |
92 /*--------------------------------------------------------------*/ | |
93 #define SMS_CMH_DCS_MAX (255) /* data coding scheme */ | |
94 /* maximum value */ | |
95 #define SMS_CMH_DCS_MIN (0) /* data coding scheme */ | |
96 /* minimum value */ | |
97 /*--------------------------------------------------------------*/ | |
98 #define SMS_CMH_PID_MAX (255) /* TP-Protocol-Identifier */ | |
99 /* maximum value */ | |
100 #define SMS_CMH_PID_MIN (0) /* TP-Protocol-Identifier */ | |
101 /* minimum value */ | |
102 | |
103 /*==== EXPORT =====================================================*/ | |
104 /*==== VARIABLES ==================================================*/ | |
105 EXTERN T_ACI_LIST *set_prm_list; | |
106 /*==== FUNCTIONS ==================================================*/ | |
107 /* | |
108 +-------------------------------------------------------------------+ | |
109 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
110 | STATE : code ROUTINE : sAT_PlusCSMP | | |
111 +-------------------------------------------------------------------+ | |
112 | |
113 PURPOSE : This is the functional counterpart of the +CSMP | |
114 AT command which is responsible for setting the text | |
115 mode parameter. | |
116 | |
117 <fo>: first octet of SMS-DELIVER, SMS-SUBMIT, etc. | |
118 <vprel>: relative validity period | |
119 <vpabs>: absolute validity period | |
120 <vpenh>: enhanced validity period | |
121 <pid>: TP-Protocol-Identifier | |
122 <dcs>: SMS data coding scheme | |
123 */ | |
124 GLOBAL T_ACI_RETURN sAT_PlusCSMP ( T_ACI_CMD_SRC srcId, | |
125 SHORT fo, | |
126 SHORT vprel, | |
127 T_ACI_VP_ABS* vpabs, | |
128 T_ACI_VP_ENH* vpenh, | |
129 SHORT pid, | |
130 SHORT dcs ) | |
131 { | |
132 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
133 T_SMS_SET_PRM * pSMSSetPrmCopy;/* points to SMS parameter set */ | |
134 UBYTE chkFo; /* checked parameter <fo> */ | |
135 UBYTE chkVprel = '\0'; /* checked parameter <vprel> */ | |
136 T_tp_vp_abs chkVpabs; /* checked parameter <vpabs> */ | |
137 T_tp_vp_enh chkVpenh; /* checked parameter <vpenh> */ | |
138 UBYTE chkPid; /* checked parameter <pid> */ | |
139 UBYTE chkDcs; /* checked parameter <dcs> */ | |
140 | |
141 TRACE_FUNCTION ("sAT_PlusCSMP ()"); | |
142 | |
143 /* | |
144 *----------------------------------------------------------------- | |
145 * check command source | |
146 *----------------------------------------------------------------- | |
147 */ | |
148 if(!cmh_IsVldCmdSrc (srcId)) | |
149 { | |
150 return( AT_FAIL ); | |
151 } | |
152 | |
153 /* | |
154 *----------------------------------------------------------------- | |
155 * check if command executable | |
156 *----------------------------------------------------------------- | |
157 */ | |
158 if(!cmhSMS_checkSIM ()) | |
159 return AT_FAIL; | |
160 | |
161 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
162 | |
163 /* | |
164 *----------------------------------------------------------------- | |
165 * create a temporary copy | |
166 *----------------------------------------------------------------- | |
167 */ | |
168 if ( pSMSSetPrm->isCopy EQ FALSE ) | |
169 { | |
170 ACI_MALLOC(pSMSSetPrmCopy, sizeof(T_SMS_SET_PRM)); | |
171 memcpy(pSMSSetPrmCopy, pSMSSetPrm, sizeof(T_SMS_SET_PRM)); | |
172 | |
173 pSMSSetPrm->numOfRefs--; | |
174 pSMSSetPrmCopy->isCopy = TRUE; | |
175 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmCopy; | |
176 pSMSSetPrm = pSMSSetPrmCopy; | |
177 } | |
178 | |
179 /* | |
180 *----------------------------------------------------------------- | |
181 * process the <fo> parameter | |
182 *----------------------------------------------------------------- | |
183 */ | |
184 if( fo NEQ ACI_NumParmNotPresent ) | |
185 { | |
186 if( fo > SMS_CMH_FO_MAX OR fo < SMS_CMH_FO_MIN OR | |
187 ( fo & TP_MTI_MASK ) EQ TP_MTI_SMS_RESERVED ) | |
188 { | |
189 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
190 return ( AT_FAIL ); | |
191 } | |
192 else | |
193 | |
194 chkFo = (UBYTE) fo; | |
195 } | |
196 else | |
197 | |
198 chkFo = pSMSSetPrm -> msgType; | |
199 | |
200 /* | |
201 *----------------------------------------------------------------- | |
202 * process the <vprel> parameter | |
203 *----------------------------------------------------------------- | |
204 */ | |
205 if( ( chkFo & VPF_MASK ) EQ VPF_RELATIVE ) | |
206 { | |
207 if ( vprel NEQ ACI_NumParmNotPresent ) | |
208 { | |
209 if( vprel > SMS_CMH_VPREL_MAX OR vprel < SMS_CMH_VPREL_MIN ) | |
210 { | |
211 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
212 return ( AT_FAIL ); | |
213 } | |
214 else | |
215 | |
216 chkVprel = (UBYTE) vprel; | |
217 } | |
218 else | |
219 | |
220 chkVprel = pSMSSetPrm -> vpRel; | |
221 | |
222 } | |
223 | |
224 /* | |
225 *----------------------------------------------------------------- | |
226 * process the <vpabs> parameter | |
227 *----------------------------------------------------------------- | |
228 */ | |
229 memset(&chkVpabs, 0, sizeof(T_tp_vp_abs)); | |
230 if( ( chkFo & VPF_MASK ) EQ VPF_ABSOLUTE ) | |
231 { | |
232 if (vpabs NEQ NULL ) | |
233 { | |
234 if ( ! cmhSMS_isVpabsVld ( vpabs ) ) | |
235 { | |
236 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
237 return ( AT_FAIL ); | |
238 } | |
239 else | |
240 | |
241 cmhSMS_setVpabsPsa ( &chkVpabs, vpabs ); | |
242 } | |
243 else | |
244 | |
245 memcpy ( ( CHAR * ) &chkVpabs, ( CHAR * ) &pSMSSetPrm -> vpAbs, | |
246 sizeof ( T_tp_vp_abs ) ); | |
247 | |
248 } | |
249 | |
250 /* | |
251 *----------------------------------------------------------------- | |
252 * process the <vpenh> parameter | |
253 *----------------------------------------------------------------- | |
254 */ | |
255 | |
256 memset(&chkVpenh, 0, sizeof(T_tp_vp_enh)); | |
257 if( ( chkFo & VPF_MASK ) EQ VPF_ENHANCED ) | |
258 { | |
259 if (vpenh NEQ NULL ) | |
260 { | |
261 if ( ! cmhSMS_isVpenhVld ( vpenh ) ) | |
262 { | |
263 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
264 return ( AT_FAIL ); | |
265 } | |
266 else | |
267 | |
268 cmhSMS_setVpenhPsa ( &chkVpenh, vpenh ); | |
269 } | |
270 else | |
271 | |
272 memcpy ( ( CHAR * ) &chkVpenh, ( CHAR * ) &pSMSSetPrm -> vpEnh, | |
273 sizeof ( T_tp_vp_enh ) ); | |
274 | |
275 } | |
276 | |
277 /* | |
278 *----------------------------------------------------------------- | |
279 * process the <pid> parameter | |
280 *----------------------------------------------------------------- | |
281 */ | |
282 if( pid NEQ ACI_NumParmNotPresent ) | |
283 { | |
284 if( pid > SMS_CMH_PID_MAX OR pid < SMS_CMH_PID_MIN ) | |
285 { | |
286 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
287 return ( AT_FAIL ); | |
288 } | |
289 else | |
290 | |
291 chkPid = (UBYTE) pid; | |
292 } | |
293 else | |
294 | |
295 chkPid = pSMSSetPrm -> pid; | |
296 | |
297 /* | |
298 *----------------------------------------------------------------- | |
299 * process the <dcs> parameter | |
300 *----------------------------------------------------------------- | |
301 */ | |
302 if( dcs NEQ ACI_NumParmNotPresent ) | |
303 { | |
304 if( dcs > SMS_CMH_DCS_MAX OR dcs < SMS_CMH_DCS_MIN ) | |
305 { | |
306 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
307 return ( AT_FAIL ); | |
308 } | |
309 else | |
310 | |
311 chkDcs = (UBYTE) dcs; | |
312 } | |
313 else | |
314 | |
315 chkDcs = pSMSSetPrm -> dcs; | |
316 | |
317 /* | |
318 *----------------------------------------------------------------- | |
319 * copy parameter | |
320 *----------------------------------------------------------------- | |
321 */ | |
322 pSMSSetPrm -> msgType = chkFo; | |
323 | |
324 | |
325 if( ( chkFo & VPF_MASK ) EQ VPF_RELATIVE ) | |
326 { | |
327 pSMSSetPrm -> vpRel = chkVprel; | |
328 } | |
329 else if ( ( chkFo & VPF_MASK ) EQ VPF_ABSOLUTE ) | |
330 { | |
331 memcpy ( ( CHAR * ) &pSMSSetPrm -> vpAbs, ( CHAR * ) &chkVpabs, | |
332 sizeof ( T_tp_vp_abs ) ); | |
333 } | |
334 else if ( ( chkFo & VPF_MASK ) EQ VPF_ENHANCED ) | |
335 { | |
336 memcpy ( ( CHAR * ) &pSMSSetPrm -> vpEnh, ( CHAR * ) &chkVpenh, | |
337 sizeof ( T_tp_vp_enh ) ); | |
338 } | |
339 | |
340 pSMSSetPrm -> pid = chkPid; | |
341 pSMSSetPrm -> dcs = chkDcs; | |
342 return( AT_CMPL ); | |
343 } | |
344 | |
345 /* | |
346 +-------------------------------------------------------------------+ | |
347 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
348 | STATE : code ROUTINE : sAT_PlusCSCA | | |
349 +-------------------------------------------------------------------+ | |
350 | |
351 PURPOSE : This is the functional counterpart of the +CSCA | |
352 AT command which is responsible for setting the | |
353 service center address. | |
354 | |
355 <sca>: service center address | |
356 <tosca>: type of service center address | |
357 */ | |
358 GLOBAL T_ACI_RETURN sAT_PlusCSCA ( T_ACI_CMD_SRC srcId, | |
359 CHAR* sca, | |
360 T_ACI_TOA* tosca ) | |
361 { | |
362 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
363 T_SMS_SET_PRM * pSMSSetPrmCopy; /* copy of SMS parameter set */ | |
364 CHAR* restSca = sca; /* service center address without */ | |
365 /* international access function */ | |
366 /* characters */ | |
367 | |
368 TRACE_FUNCTION ("sAT_PlusCSCA ()"); | |
369 | |
370 /* | |
371 *----------------------------------------------------------------- | |
372 * check command source | |
373 *----------------------------------------------------------------- | |
374 */ | |
375 if(!cmh_IsVldCmdSrc (srcId)) | |
376 { | |
377 return( AT_FAIL ); | |
378 } | |
379 | |
380 /* | |
381 *----------------------------------------------------------------- | |
382 * check if command executable | |
383 *----------------------------------------------------------------- | |
384 */ | |
385 if(!cmhSMS_checkSIM ()) | |
386 return AT_FAIL; | |
387 | |
388 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
389 | |
390 /* | |
391 *----------------------------------------------------------------- | |
392 * create a temporary copy | |
393 *----------------------------------------------------------------- | |
394 */ | |
395 if ( pSMSSetPrm->isCopy EQ FALSE ) | |
396 { | |
397 ACI_MALLOC(pSMSSetPrmCopy, sizeof(T_SMS_SET_PRM)); | |
398 memcpy(pSMSSetPrmCopy, pSMSSetPrm, sizeof(T_SMS_SET_PRM)); | |
399 | |
400 pSMSSetPrm->numOfRefs--; | |
401 pSMSSetPrmCopy->isCopy = TRUE; | |
402 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmCopy; | |
403 pSMSSetPrm = pSMSSetPrmCopy; | |
404 } | |
405 | |
406 /* | |
407 *----------------------------------------------------------------- | |
408 * process the <sca> parameter | |
409 *----------------------------------------------------------------- | |
410 */ | |
411 if ( sca NEQ NULL ) | |
412 { | |
413 /* | |
414 *--------------------------------------------------------------- | |
415 * process the <tosca> parameter | |
416 *--------------------------------------------------------------- | |
417 */ | |
418 if ( tosca NEQ NULL ) | |
419 { | |
420 pSMSSetPrm -> sca.ton = cmhSMS_getNType ( tosca -> ton ); | |
421 pSMSSetPrm -> sca.npi = cmhSMS_getNPlan ( tosca -> npi ); | |
422 } | |
423 else | |
424 { | |
425 restSca = cmhSMS_setToaDef ( sca, | |
426 &pSMSSetPrm -> sca.ton, | |
427 &pSMSSetPrm -> sca.npi ); | |
428 } | |
429 | |
430 cmhSMS_getAdrBcd ( pSMSSetPrm -> sca.num, | |
431 &pSMSSetPrm -> sca.c_num, | |
432 MAX_SMS_ADDR_DIG, restSca); | |
433 | |
434 pSMSSetPrm -> sca.v_npi = TRUE; | |
435 pSMSSetPrm -> sca.v_ton = TRUE; | |
436 return ( AT_CMPL ); | |
437 } | |
438 else | |
439 { | |
440 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
441 return ( AT_FAIL ); | |
442 } | |
443 } | |
444 | |
445 /* | |
446 +-------------------------------------------------------------------+ | |
447 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
448 | STATE : code ROUTINE : sAT_PlusCSMS | | |
449 +-------------------------------------------------------------------+ | |
450 | |
451 PURPOSE : This is the functional counterpart of the +CSMS | |
452 AT command which is responsible for setting the | |
453 message service. | |
454 | |
455 <service>: message service | |
456 */ | |
457 GLOBAL T_ACI_RETURN sAT_PlusCSMS ( T_ACI_CMD_SRC srcId, | |
458 T_ACI_CSMS_SERV service ) | |
459 { | |
460 T_ACI_RETURN ret; /* AT response code */ | |
461 | |
462 TRACE_FUNCTION ("sAT_PlusCSMS ()"); | |
463 | |
464 /* | |
465 *----------------------------------------------------------------- | |
466 * check if command executable | |
467 *----------------------------------------------------------------- | |
468 */ | |
469 if(!cmhSMS_checkAccess (srcId, &ret)) | |
470 return ret; | |
471 | |
472 /* | |
473 *----------------------------------------------------------------- | |
474 * process the <service> parameter | |
475 *----------------------------------------------------------------- | |
476 */ | |
477 switch( service ) | |
478 { | |
479 case( CSMS_SERV_NotPresent ): | |
480 break; | |
481 | |
482 case( CSMS_SERV_GsmPh2 ): | |
483 case( CSMS_SERV_GsmPh2Plus ): | |
484 smsShrdPrm.CSMSservice = service; | |
485 | |
486 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CSMS; | |
487 smsShrdPrm.owner = (T_OWN)srcId; | |
488 smsShrdPrm.smsEntStat.entOwn = srcId; | |
489 /* Implements measure 147,148, 149 */ | |
490 cmhSMS_sendConfigureReq(FALSE); | |
491 { | |
492 R_AT ( RAT_CSMS, smsShrdPrm.smsEntStat.entOwn ) | |
493 ( CSMS_SERV_NotPresent, | |
494 smsShrdPrm.CSMSmt, | |
495 smsShrdPrm.CSMSmo, | |
496 smsShrdPrm.CSMSbm ); | |
497 } | |
498 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
499 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
500 smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; | |
501 break; | |
502 | |
503 default: | |
504 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
505 return( AT_FAIL ); | |
506 } | |
507 | |
508 return( AT_CMPL ); | |
509 } | |
510 | |
511 /* | |
512 +-------------------------------------------------------------------+ | |
513 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
514 | STATE : code ROUTINE : sAT_PlusCMGF | | |
515 +-------------------------------------------------------------------+ | |
516 | |
517 PURPOSE : This is the functional counterpart of the +CMGF | |
518 AT command which is responsible for setting the | |
519 message format. | |
520 | |
521 <mode>: indicates the message format | |
522 */ | |
523 GLOBAL T_ACI_RETURN sAT_PlusCMGF ( T_ACI_CMD_SRC srcId, | |
524 T_ACI_CMGF_MOD mode ) | |
525 { | |
526 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
527 | |
528 TRACE_FUNCTION ("sAT_PlusCMGF ()"); | |
529 | |
530 /* | |
531 *----------------------------------------------------------------- | |
532 * check command source | |
533 *----------------------------------------------------------------- | |
534 */ | |
535 if(!cmh_IsVldCmdSrc (srcId)) | |
536 { | |
537 return( AT_FAIL ); | |
538 } | |
539 | |
540 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
541 | |
542 /* | |
543 *----------------------------------------------------------------- | |
544 * process the <mode> parameter | |
545 *----------------------------------------------------------------- | |
546 */ | |
547 switch( mode ) | |
548 { | |
549 case( CMGF_MOD_NotPresent ): | |
550 pSMSSetPrm -> CMGFmode = CMGF_MOD_Pdu; | |
551 break; | |
552 | |
553 case( CMGF_MOD_Txt ): | |
554 case (CMGF_MOD_Pdu ): | |
555 pSMSSetPrm -> CMGFmode = mode; | |
556 break; | |
557 | |
558 default: | |
559 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
560 return( AT_FAIL ); | |
561 } | |
562 | |
563 return( AT_CMPL ); | |
564 } | |
565 | |
566 /* | |
567 +-------------------------------------------------------------------+ | |
568 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
569 | STATE : code ROUTINE : sAT_PercentSMBS | | |
570 +-------------------------------------------------------------------+ | |
571 | |
572 PURPOSE : This is the functional counterpart of the %SMBS | |
573 AT command which is responsible for setting the SMS message format. | |
574 | |
575 <mode>: indicates the message format | |
576 */ | |
577 #ifdef FF_MMI_RIV | |
578 GLOBAL T_ACI_RETURN sAT_PercentSMBS ( T_ACI_CMD_SRC srcId, | |
579 T_ACI_PERC_SMBS_MOD mode ) | |
580 { | |
581 TRACE_FUNCTION ("sAT_PercentSMBS ()"); | |
582 | |
583 /* check command source */ | |
584 if(!cmh_IsVldCmdSrc (srcId)) | |
585 { | |
586 return( AT_FAIL ); | |
587 } | |
588 | |
589 /* process the <mode> parameter */ | |
590 switch( mode ) | |
591 { | |
592 case( PERC_SMBS_MOD_NotPresent ): | |
593 smsShrdPrm.perccmgf_smbs_mode = PERC_SMBS_MOD_DISABLE; /* default */ | |
594 break; | |
595 | |
596 case( PERC_SMBS_MOD_DISABLE ): | |
597 case (PERC_SMBS_MOD_ENABLE ): | |
598 smsShrdPrm.perccmgf_smbs_mode = mode; | |
599 break; | |
600 | |
601 default: | |
602 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
603 return( AT_FAIL ); | |
604 } | |
605 | |
606 return( AT_CMPL ); | |
607 } | |
608 #endif /* #ifdef FF_MMI_RIV */ | |
609 /* | |
610 +-------------------------------------------------------------------+ | |
611 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
612 | STATE : code ROUTINE : sAT_PlusCNMA | | |
613 +-------------------------------------------------------------------+ | |
614 | |
615 PURPOSE : This is the functional counterpart of the +CNMA | |
616 AT command which is responsible for sending the | |
617 new message acknowledgement. | |
618 | |
619 */ | |
620 GLOBAL T_ACI_RETURN sAT_PlusCNMA ( T_ACI_CMD_SRC srcId) | |
621 { | |
622 T_ACI_RETURN ret; /* AT response code */ | |
623 | |
624 TRACE_FUNCTION ("sAT_PlusCNMA ()"); | |
625 | |
626 /* | |
627 *----------------------------------------------------------------- | |
628 * check if command executable | |
629 *----------------------------------------------------------------- | |
630 */ | |
631 if(!cmhSMS_checkAccess (srcId, &ret)) | |
632 return ret; | |
633 | |
634 /* | |
635 *----------------------------------------------------------------- | |
636 * check current service and whether an acknowledgement is expected. | |
637 *----------------------------------------------------------------- | |
638 */ | |
639 | |
640 if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus AND | |
641 smsShrdPrm.cnma_ack_expected) | |
642 { | |
643 PALLOC (mnsms_ack_res, MNSMS_ACK_RES); | |
644 | |
645 smsShrdPrm.cnma_ack_expected = FALSE; | |
646 | |
647 mnsms_ack_res->resp = SMS_RP_ACK; | |
648 mnsms_ack_res->sms_sdu.o_buf = 0; | |
649 mnsms_ack_res->sms_sdu.l_buf = 0; | |
650 | |
651 PSENDX (SMS, mnsms_ack_res); | |
652 return ( AT_CMPL ); | |
653 } | |
654 else | |
655 { | |
656 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_NoCnmaAckExpect ); | |
657 return ( AT_FAIL ); | |
658 } | |
659 } | |
660 | |
661 #if defined (SMS_PDU_SUPPORT) | |
662 /* | |
663 +-------------------------------------------------------------------+ | |
664 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
665 | STATE : code ROUTINE : sAT_PlusCNMAPdu | | |
666 +-------------------------------------------------------------------+ | |
667 | |
668 PURPOSE : This is the functional counterpart of the +CNMA | |
669 AT command which is responsible for sending the | |
670 new message acknowledgement in PDU mode | |
671 | |
672 */ | |
673 GLOBAL T_ACI_RETURN sAT_PlusCNMAPdu ( T_ACI_CMD_SRC srcId, | |
674 SHORT n, | |
675 T_ACI_SM_DATA *pdu) | |
676 { | |
677 T_ACI_RETURN ret; /* AT response code */ | |
678 | |
679 TRACE_FUNCTION ("sAT_PlusCNMAPdu ()"); | |
680 | |
681 /* | |
682 *----------------------------------------------------------------- | |
683 * check if command executable | |
684 *----------------------------------------------------------------- | |
685 */ | |
686 if(!cmhSMS_checkAccess (srcId, &ret)) | |
687 return ret; | |
688 | |
689 /* | |
690 *----------------------------------------------------------------- | |
691 * check current service and whether an acknowledgement is expected. | |
692 *----------------------------------------------------------------- | |
693 */ | |
694 if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus AND | |
695 smsShrdPrm.cnma_ack_expected) | |
696 { | |
697 PALLOC (mnsms_ack_res, MNSMS_ACK_RES); | |
698 | |
699 smsShrdPrm.cnma_ack_expected = FALSE; | |
700 | |
701 if (n EQ 2) | |
702 mnsms_ack_res->resp = SMS_RP_ERROR; | |
703 else | |
704 mnsms_ack_res->resp = SMS_RP_ACK; | |
705 | |
706 /* one byte for SCA length */ | |
707 if( pdu->len NEQ 0 ) | |
708 { | |
709 mnsms_ack_res->sms_sdu.l_buf = (pdu->len+1) * 8; | |
710 } | |
711 else | |
712 { | |
713 mnsms_ack_res->sms_sdu.l_buf = 0; | |
714 } | |
715 mnsms_ack_res->sms_sdu.o_buf = 0; | |
716 | |
717 /* length of SCA length (is always empty!) */ | |
718 mnsms_ack_res->sms_sdu.buf[0] = 0x00; | |
719 memcpy (&mnsms_ack_res->sms_sdu.buf[1], pdu->data, pdu->len); | |
720 | |
721 PSENDX (SMS, mnsms_ack_res); | |
722 return ( AT_CMPL ); | |
723 } | |
724 else | |
725 { | |
726 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_NoCnmaAckExpect ); | |
727 return ( AT_FAIL ); | |
728 } | |
729 } | |
730 #endif /* SMS_PDU_SUPPORT */ | |
731 | |
732 /* | |
733 +-------------------------------------------------------------------+ | |
734 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
735 | STATE : code ROUTINE : sAT_PlusCNMI | | |
736 +-------------------------------------------------------------------+ | |
737 | |
738 PURPOSE : This is the functional counterpart of the +CNMI | |
739 AT command which is responsible for setting the | |
740 new message indication parameter. | |
741 | |
742 <mt>: indication routing for SMS-DELIVER | |
743 <bm>: indication routing for CBM | |
744 <ds>: indication routing for SMS-STATUS-REPORT | |
745 */ | |
746 GLOBAL T_ACI_RETURN sAT_PlusCNMI ( T_ACI_CMD_SRC srcId, | |
747 T_ACI_CNMI_MT mt, | |
748 T_ACI_CNMI_BM bm, | |
749 T_ACI_CNMI_DS ds ) | |
750 { | |
751 T_ACI_RETURN ret; /* AT response code */ | |
752 UBYTE chkMtHndl; /* checked parameter <mt>, prm set */ | |
753 UBYTE chkBmHndl; /* checked parameter <bm>, prm set */ | |
754 UBYTE chkDsHndl; /* checked parameter <ds>, prm set */ | |
755 | |
756 T_ACI_CNMI_MT chkMt; /* checked parameter <mt>, cmd set */ | |
757 T_ACI_CNMI_BM chkBm; /* checked parameter <bm>, cmd set */ | |
758 T_ACI_CNMI_DS chkDs; /* checked parameter <ds>, cmd set */ | |
759 | |
760 TRACE_FUNCTION ("sAT_PlusCNMI ()"); | |
761 | |
762 /* | |
763 *----------------------------------------------------------------- | |
764 * check if command executable | |
765 *----------------------------------------------------------------- | |
766 */ | |
767 if(!cmhSMS_checkAccess (srcId, &ret)) | |
768 return ret; | |
769 | |
770 /* | |
771 *----------------------------------------------------------------- | |
772 * process the <mt> parameter, prm set | |
773 *----------------------------------------------------------------- | |
774 */ | |
775 switch( mt ) | |
776 { | |
777 case(CNMI_MT_NotPresent ): chkMtHndl = smsShrdPrm.mtHndl; break; | |
778 case(CNMI_MT_NoSmsDeliverInd): chkMtHndl = MT0; break; | |
779 case(CNMI_MT_SmsDeliverInd ): chkMtHndl = MT1; break; | |
780 case(CNMI_MT_SmsDeliver ): chkMtHndl = MT2; break; | |
781 case(CNMI_MT_SmsDeliverCls3 ): chkMtHndl = MT3; break; | |
782 | |
783 default: | |
784 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
785 return( AT_FAIL ); | |
786 } | |
787 | |
788 /* | |
789 *----------------------------------------------------------------- | |
790 * process the <mt> parameter, cmd set | |
791 *----------------------------------------------------------------- | |
792 */ | |
793 if ( mt EQ CNMI_MT_NotPresent ) | |
794 chkMt = smsShrdPrm.CNMImt; | |
795 else | |
796 chkMt = mt; | |
797 | |
798 /* | |
799 *----------------------------------------------------------------- | |
800 * process the <bm> parameter, prm set | |
801 *----------------------------------------------------------------- | |
802 */ | |
803 switch( bm ) | |
804 { | |
805 case( CNMI_BM_NotPresent ): chkBmHndl = smsShrdPrm.cbmPrm.cbmHndl; | |
806 break; | |
807 case( CNMI_BM_NoCbmInd ): chkBmHndl = BM0; break; | |
808 case( CNMI_BM_Cbm ): chkBmHndl = BM2; break; | |
809 | |
810 default: | |
811 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
812 return( AT_FAIL ); | |
813 } | |
814 | |
815 /* | |
816 *----------------------------------------------------------------- | |
817 * process the <bm> parameter, cmd set | |
818 *----------------------------------------------------------------- | |
819 */ | |
820 if ( bm EQ CNMI_BM_NotPresent ) | |
821 chkBm = smsShrdPrm.CNMIbm; | |
822 else | |
823 chkBm = bm; | |
824 | |
825 /* | |
826 *----------------------------------------------------------------- | |
827 * process the <ds> parameter, prm set | |
828 *----------------------------------------------------------------- | |
829 */ | |
830 switch( ds ) | |
831 { | |
832 case( CNMI_DS_NotPresent ): chkDsHndl = smsShrdPrm.srHndl; break; | |
833 case( CNMI_DS_NoSmsStatRpt ): chkDsHndl = DS0; break; | |
834 case( CNMI_DS_SmsStatRpt ): chkDsHndl = DS1; break; | |
835 | |
836 default: | |
837 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
838 return( AT_FAIL ); | |
839 } | |
840 | |
841 /* | |
842 *----------------------------------------------------------------- | |
843 * process the <ds> parameter, cmd set | |
844 *----------------------------------------------------------------- | |
845 */ | |
846 if ( ds EQ CNMI_DS_NotPresent ) | |
847 chkDs = smsShrdPrm.CNMIds; | |
848 else | |
849 chkDs = ds; | |
850 | |
851 /* | |
852 *----------------------------------------------------------------- | |
853 * copy parameter | |
854 *----------------------------------------------------------------- | |
855 */ | |
856 smsShrdPrm.mtHndl = chkMtHndl; | |
857 smsShrdPrm.cbmPrm.cbmHndl = chkBmHndl; | |
858 smsShrdPrm.srHndl = chkDsHndl; | |
859 | |
860 smsShrdPrm.CNMImt = chkMt; | |
861 smsShrdPrm.CNMIbm = chkBm; | |
862 smsShrdPrm.CNMIds = chkDs; | |
863 | |
864 /* | |
865 *----------------------------------------------------------------- | |
866 * configure SMS | |
867 *----------------------------------------------------------------- | |
868 */ | |
869 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CNMI; | |
870 smsShrdPrm.owner = (T_OWN)srcId; | |
871 smsShrdPrm.smsEntStat.entOwn = srcId; | |
872 /* Implements measure 147,148, 149 */ | |
873 cmhSMS_sendConfigureReq (FALSE); | |
874 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
875 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
876 smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; | |
877 | |
878 /* | |
879 *----------------------------------------------------------------- | |
880 * set the new CBCH configuration | |
881 *----------------------------------------------------------------- | |
882 */ | |
883 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
884 | |
885 if( psaMMI_Cbch() < 0 ) | |
886 { | |
887 TRACE_EVENT( "FATAL RETURN psaSMS in +CNMI" ); | |
888 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
889 return( AT_FAIL ); | |
890 } | |
891 | |
892 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
893 | |
894 return ( AT_CMPL ); | |
895 } | |
896 | |
897 /* | |
898 +-------------------------------------------------------------------+ | |
899 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
900 | STATE : code ROUTINE : sAT_PlusCPMS | | |
901 +-------------------------------------------------------------------+ | |
902 | |
903 PURPOSE : This is the functional counterpart of the +CPMS | |
904 AT command which is responsible for setting the | |
905 preferred message storages. | |
906 | |
907 <mem1>: preferred memory 1 | |
908 <mem2>: preferred memory 2 | |
909 <mem3>: preferred memory 3 | |
910 */ | |
911 GLOBAL T_ACI_RETURN sAT_PlusCPMS ( T_ACI_CMD_SRC srcId, | |
912 T_ACI_SMS_STOR mem1, | |
913 T_ACI_SMS_STOR mem2, | |
914 T_ACI_SMS_STOR mem3 ) | |
915 { | |
916 T_ACI_RETURN ret; /* AT response code */ | |
917 | |
918 UBYTE chkMem1; /* checked parameter <mem1> */ | |
919 UBYTE chkMem2; /* checked parameter <mem2> */ | |
920 UBYTE chkMem3; /* checked parameter <mem3> */ | |
921 | |
922 T_ACI_SMS_STOR_OCC m1; | |
923 T_ACI_SMS_STOR_OCC m2; | |
924 T_ACI_SMS_STOR_OCC m3; | |
925 | |
926 UBYTE isModified = FALSE; | |
927 | |
928 TRACE_FUNCTION ("sAT_PlusCPMS ()"); | |
929 | |
930 | |
931 /* | |
932 *----------------------------------------------------------------- | |
933 * check if command executable | |
934 *----------------------------------------------------------------- | |
935 */ | |
936 if(!cmhSMS_checkAccess (srcId, &ret)) | |
937 return ret; | |
938 | |
939 /* | |
940 *----------------------------------------------------------------- | |
941 * process the <mem1> parameter | |
942 *----------------------------------------------------------------- | |
943 */ | |
944 if( mem1 NEQ SMS_STOR_NotPresent ) | |
945 { | |
946 if( ! cmhSMS_getMemPsa ( mem1, &chkMem1 ) ) | |
947 { | |
948 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
949 return ( AT_FAIL ); | |
950 } | |
951 smsShrdPrm.mem1 = chkMem1; | |
952 } | |
953 | |
954 /* | |
955 *----------------------------------------------------------------- | |
956 * process the <mem2> parameter | |
957 *----------------------------------------------------------------- | |
958 */ | |
959 if( mem2 NEQ SMS_STOR_NotPresent ) | |
960 { | |
961 if( ! cmhSMS_getMemPsa ( mem2, &chkMem2 ) ) | |
962 { | |
963 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
964 return ( AT_FAIL ); | |
965 } | |
966 smsShrdPrm.mem2 = chkMem2; | |
967 } | |
968 | |
969 /* | |
970 *----------------------------------------------------------------- | |
971 * process the <mem3> parameter | |
972 *----------------------------------------------------------------- | |
973 */ | |
974 if( mem3 NEQ SMS_STOR_NotPresent ) | |
975 { | |
976 if( ! cmhSMS_getMemPsa ( mem3, &chkMem3 ) ) | |
977 { | |
978 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
979 return ( AT_FAIL ); | |
980 } | |
981 if (smsShrdPrm.mem3 NEQ chkMem3) | |
982 { | |
983 smsShrdPrm.mem3 = chkMem3; | |
984 isModified = TRUE; | |
985 } | |
986 } | |
987 | |
988 | |
989 /*------------------------------------------------------------------- | |
990 * create and send primitive for configure request | |
991 *------------------------------------------------------------------- | |
992 */ | |
993 if (isModified) | |
994 /* Implements measure 147,148, 149 */ | |
995 cmhSMS_sendConfigureReq (FALSE); | |
996 | |
997 | |
998 /* | |
999 * ----------------------------------------------------------------- | |
1000 * Fills the T_ACI_SMS_STOR_OCC structure with data from the | |
1001 * shared parameter buffer (used mem, total mem). | |
1002 * ----------------------------------------------------------------- | |
1003 */ | |
1004 cmhSMS_setStorOcc ( &m1, smsShrdPrm.mem1 ); | |
1005 cmhSMS_setStorOcc ( &m2, smsShrdPrm.mem2 ); | |
1006 cmhSMS_setStorOcc ( &m3, smsShrdPrm.mem3 ); | |
1007 | |
1008 #ifdef FF_ATI | |
1009 cpmsCallType = SAT_CALL; | |
1010 #endif /* FF_ATI */ | |
1011 | |
1012 R_AT ( RAT_CPMS, srcId ) ( &m1, &m2, &m3 ); | |
1013 | |
1014 return( AT_CMPL ); | |
1015 } | |
1016 | |
1017 /* | |
1018 +-------------------------------------------------------------------+ | |
1019 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1020 | STATE : code ROUTINE : sAT_PlusCMGS_Old | | |
1021 +-------------------------------------------------------------------+ | |
1022 | |
1023 PURPOSE : This is the functional counterpart of the +CMSS | |
1024 AT command which is responsible for sending a short | |
1025 message from memory. | |
1026 | |
1027 This function exists for compatibility reasons. | |
1028 | |
1029 */ | |
1030 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
1031 GLOBAL T_ACI_RETURN sAT_PlusCMGS_Old ( T_ACI_CMD_SRC srcId, | |
1032 CHAR* da, | |
1033 T_ACI_TOA* toda, | |
1034 T_ACI_SM_DATA* data, | |
1035 CHAR* sca, | |
1036 T_ACI_TOA* tosca, | |
1037 SHORT isReply ) | |
1038 { | |
1039 TRACE_FUNCTION ("sAT_PlusCMGS_Old ()"); | |
1040 | |
1041 return sAT_PlusCMGS_Gl | |
1042 (srcId, da, toda, data, NULL, sca, tosca, isReply, rAT_PlusCMGS, | |
1043 rAT_PlusCMS); | |
1044 } | |
1045 #endif /*#if defined SMI OR defined MFW OR defined FF_MMI_RIV*/ | |
1046 | |
1047 /* | |
1048 +-------------------------------------------------------------------+ | |
1049 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1050 | STATE : code ROUTINE : sAT_PlusCMGS | | |
1051 +-------------------------------------------------------------------+ | |
1052 | |
1053 PURPOSE : This is the functional counterpart of the +CMGS | |
1054 AT command which is responsible for sending a short | |
1055 message. | |
1056 | |
1057 Features Concatenated SMS. | |
1058 For GPF-MMI. | |
1059 | |
1060 <da>: destination address | |
1061 <toda>: type of destination address | |
1062 <data>: message data | |
1063 <sca>: service center address | |
1064 <tosca>: type of service center address | |
1065 <isReply>: > 0: set TP-Reply-Path explicitly | |
1066 EQ 0: clear TP-Reply-Path explicitly | |
1067 */ | |
1068 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
1069 GLOBAL T_ACI_RETURN sAT_PlusCMGS ( T_ACI_CMD_SRC srcId, | |
1070 CHAR* da, | |
1071 T_ACI_TOA* toda, | |
1072 T_SM_DATA_EXT* src_data, | |
1073 CHAR* sca, | |
1074 T_ACI_TOA* tosca, | |
1075 SHORT isReply ) | |
1076 { | |
1077 T_CONC_INIT_RETURN ret; | |
1078 T_ACI_UDH_DATA udh; | |
1079 | |
1080 T_ACI_SM_DATA tar_data; | |
1081 UBYTE alphabet; | |
1082 | |
1083 TRACE_FUNCTION ("sAT_PlusCMGS ()"); | |
1084 | |
1085 | |
1086 alphabet = cmhSMS_getAlphabetPp ( smsShrdPrm.pSetPrm[srcId]->dcs ); | |
1087 | |
1088 /* cut off more than CONC_MAX_SEGS segments */ | |
1089 if (alphabet EQ 0) | |
1090 { | |
1091 src_data->len = MINIMUM (src_data->len, concShrdPrm.l_uncomp7bit_data_conc*CONC_MAX_SEGS); | |
1092 } | |
1093 else | |
1094 { | |
1095 src_data->len = MINIMUM (src_data->len, concShrdPrm.l_uncomp8bit_data_conc*CONC_MAX_SEGS); | |
1096 } | |
1097 | |
1098 ret=concSMS_initSend(&tar_data, &udh, srcId, da, toda, src_data, sca, | |
1099 tosca, isReply, alphabet); | |
1100 | |
1101 if (ret EQ CONC_NEEDED) | |
1102 { | |
1103 SET_CONC; | |
1104 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, &udh, sca, tosca, | |
1105 isReply, rConcSMS_PlusCMGS, rConcSMS_PlusCMS_CMGS); | |
1106 } | |
1107 else | |
1108 { | |
1109 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, NULL, sca, tosca, | |
1110 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1111 } | |
1112 } | |
1113 #endif /* #if (defined (MFW) OR defined (_CONC_TESTING_) */ | |
1114 | |
1115 /* | |
1116 +-------------------------------------------------------------------+ | |
1117 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1118 | STATE : code ROUTINE : sAT_PlusCMGS | | |
1119 +-------------------------------------------------------------------+ | |
1120 | |
1121 PURPOSE : For Riv-MMI if conc. is not needed. | |
1122 */ | |
1123 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
1124 GLOBAL T_ACI_RETURN sAT_PlusCMGS ( T_ACI_CMD_SRC srcId, | |
1125 CHAR* da, | |
1126 T_ACI_TOA* toda, | |
1127 T_ACI_SM_DATA* src_data, | |
1128 CHAR* sca, | |
1129 T_ACI_TOA* tosca, | |
1130 SHORT isReply ) | |
1131 { | |
1132 TRACE_FUNCTION ("sAT_PlusCMGS ()"); | |
1133 | |
1134 return sAT_PlusCMGS_Gl(srcId, da, toda, src_data, NULL, sca, tosca, | |
1135 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1136 } | |
1137 | |
1138 /* | |
1139 +-------------------------------------------------------------------+ | |
1140 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1141 | STATE : code ROUTINE : sAT_PercentCMGS | | |
1142 +-------------------------------------------------------------------+ | |
1143 | |
1144 PURPOSE : Handling Percent CMGS command from Riv-MMI side which | |
1145 contains the UDH also for each segment. | |
1146 */ | |
1147 GLOBAL T_ACI_RETURN sAT_PercentCMGS ( T_ACI_CMD_SRC srcId, | |
1148 CHAR* da, | |
1149 T_ACI_TOA* toda, | |
1150 T_ACI_SM_DATA* src_data, | |
1151 T_ACI_UDH_DATA* udh_data, | |
1152 CHAR* sca, | |
1153 T_ACI_TOA* tosca, | |
1154 SHORT isReply ) | |
1155 { | |
1156 TRACE_FUNCTION ("sAT_PercentCMGS () with udh"); | |
1157 | |
1158 return sAT_PlusCMGS_Gl(srcId, da, toda, src_data, udh_data, sca, tosca, | |
1159 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1160 } | |
1161 #endif /*#if defined FF_MMI_RIV*/ | |
1162 | |
1163 /* | |
1164 * The following function has been conditioned out for the FreeCalypso build | |
1165 * as it was failing compilation; it does not appear in the TCS211 version; | |
1166 * to be investigated later. | |
1167 */ | |
1168 | |
1169 #if 0 | |
1170 GLOBAL T_ACI_RETURN sAT_PlusCMGS_byPort( T_ACI_CMD_SRC srcId, | |
1171 CHAR* da, | |
1172 T_ACI_TOA* toda, | |
1173 T_SM_DATA_EXT* src_data, | |
1174 CHAR* sca, | |
1175 T_ACI_TOA* tosca, | |
1176 SHORT isReply, | |
1177 SHORT isSpPORT, | |
1178 SHORT destPORT, | |
1179 SHORT origPORT) | |
1180 { | |
1181 T_CONC_INIT_RETURN ret; | |
1182 T_ACI_UDH_DATA udh; | |
1183 | |
1184 | |
1185 | |
1186 T_ACI_SM_DATA tar_data; | |
1187 UBYTE alphabet; | |
1188 | |
1189 | |
1190 | |
1191 TRACE_FUNCTION ("sAT_PlusCMGS_byPort ()"); | |
1192 | |
1193 | |
1194 | |
1195 memset(&udh, 0, sizeof(T_ACI_UDH_DATA)); | |
1196 alphabet = cmhSMS_getAlphabetPp ( smsShrdPrm.pSetPrm[srcId]->dcs ); | |
1197 | |
1198 | |
1199 | |
1200 ret=concSMS_initSend(&tar_data, &udh, srcId, da, toda, src_data, sca, | |
1201 tosca, isReply, alphabet); | |
1202 if(isSpPORT)//add port data to udh | |
1203 { | |
1204 udh.data[udh.len] = 0x05;//Application Port Addressing 16 bit address | |
1205 udh.data[udh.len+1] = 0x04;//ud length | |
1206 udh.data[udh.len+2] = destPORT>>8;//destination port | |
1207 udh.data[udh.len+3] = destPORT&0xff; | |
1208 udh.data[udh.len+4] = origPORT>>8;//orignal port | |
1209 udh.data[udh.len+5] = origPORT&0xff; | |
1210 udh.len+=6; | |
1211 } | |
1212 if (ret EQ CONC_NEEDED) | |
1213 { | |
1214 SET_CONC; | |
1215 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, &udh, sca, tosca, | |
1216 isReply, rConcSMS_PlusCMGS, rConcSMS_PlusCMS_CMGS); | |
1217 } | |
1218 else if(isSpPORT) | |
1219 { | |
1220 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, &udh, sca, tosca, | |
1221 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1222 } | |
1223 else | |
1224 { | |
1225 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, NULL, sca, tosca, | |
1226 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1227 } | |
1228 } | |
1229 #endif | |
1230 | |
1231 /* | |
1232 +-------------------------------------------------------------------+ | |
1233 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1234 | STATE : code ROUTINE : sAT_PlusCMGS_Gl | | |
1235 +-------------------------------------------------------------------+ | |
1236 | |
1237 PURPOSE : This is the functional counterpart of the +CMGS | |
1238 AT command which is responsible for sending a short | |
1239 message. | |
1240 | |
1241 <da>: destination address | |
1242 <toda>: type of destination address | |
1243 <data>: message data | |
1244 <udh>: user data header | |
1245 <sca>: service center address | |
1246 <tosca>: type of service center address | |
1247 <isReply>: > 0: set TP-Reply-Path explicitly | |
1248 EQ 0: clear TP-Reply-Path explicitly | |
1249 <rplyCB>: reply call-back | |
1250 <errorCB>: error call-back | |
1251 */ | |
1252 GLOBAL T_ACI_RETURN sAT_PlusCMGS_Gl ( T_ACI_CMD_SRC srcId, | |
1253 CHAR* da, | |
1254 T_ACI_TOA* toda, | |
1255 T_ACI_SM_DATA* data, | |
1256 T_ACI_UDH_DATA* udh, | |
1257 CHAR* sca, | |
1258 T_ACI_TOA* tosca, | |
1259 SHORT isReply, | |
1260 T_CMSS_FCT rplyCB, | |
1261 T_ERROR_FCT errorCB) | |
1262 { | |
1263 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
1264 T_ACI_RETURN ret=AT_CMPL; /* AT response code */ | |
1265 CHAR* restDa = da; /* destination address without */ | |
1266 /* international access function */ | |
1267 /* characters */ | |
1268 CHAR* restSca = sca; /* service center address without */ | |
1269 /* international access function */ | |
1270 /* characters */ | |
1271 | |
1272 T_ACI_SM_DATA packedData; | |
1273 T_tp_da da_addr; | |
1274 UBYTE msgType; | |
1275 UBYTE byte_offset = 0; | |
1276 BOOL mtchFlag; | |
1277 | |
1278 #ifdef _CONC_TESTING_ | |
1279 /* Implements Measure#32 */ | |
1280 #endif | |
1281 | |
1282 TRACE_FUNCTION ("sAT_PlusCMGS_Gl ()"); | |
1283 | |
1284 | |
1285 /* | |
1286 *----------------------------------------------------------------- | |
1287 * check if command executable | |
1288 *----------------------------------------------------------------- | |
1289 */ | |
1290 if(!cmhSMS_checkAccess (srcId, &ret)) | |
1291 return ret; | |
1292 | |
1293 smsShrdPrm.rplyCB.cmgs = rplyCB; | |
1294 smsShrdPrm.errorCB = errorCB; | |
1295 | |
1296 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
1297 | |
1298 /* | |
1299 *----------------------------------------------------------------- | |
1300 * process the <da> parameter | |
1301 *----------------------------------------------------------------- | |
1302 */ | |
1303 if ( da NEQ NULL ) | |
1304 { | |
1305 /* | |
1306 *--------------------------------------------------------------- | |
1307 * process the <toda> parameter | |
1308 *--------------------------------------------------------------- | |
1309 */ | |
1310 if ( toda NEQ NULL ) | |
1311 { | |
1312 da_addr.ton = toda -> ton; | |
1313 da_addr.npi = toda -> npi; | |
1314 } | |
1315 else | |
1316 { | |
1317 restDa = cmhSMS_setToaDef ( da, &da_addr.ton, &da_addr.npi ); | |
1318 } | |
1319 | |
1320 /* start: check if fixed dialing phonebook is enabled */ | |
1321 if (pb_get_fdn_mode () EQ FDN_ENABLE AND | |
1322 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms ) | |
1323 { | |
1324 TRACE_FUNCTION("sAT_PlusCMGS_Gl: FDN"); | |
1325 if ( da_addr.ton NEQ TON_Alphanumeric ) /* not supported by Phonebook */ | |
1326 { | |
1327 TRACE_EVENT_P1("sAT_PlusCMGS_Gl: FDN checking: %s",da); | |
1328 | |
1329 if ( da[0] EQ '+' ) | |
1330 { | |
1331 /* check if '+' is within the string and remove it if it is */ | |
1332 mtchFlag = (pb_check_fdn (0, (const UBYTE *)(da + 1)) EQ PHB_OK); | |
1333 } | |
1334 else | |
1335 { | |
1336 mtchFlag = (pb_check_fdn (0, (const UBYTE *)(da )) EQ PHB_OK); | |
1337 } | |
1338 if ( mtchFlag ) | |
1339 { | |
1340 TRACE_EVENT("sAT_PlusCMGS_Gl: Found match in FDN!"); | |
1341 } | |
1342 else | |
1343 { | |
1344 TRACE_EVENT("sAT_PlusCMGS_Gl: No match in FDN found, SMS rejected!"); | |
1345 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed ); | |
1346 return ( AT_FAIL ); | |
1347 } | |
1348 } | |
1349 else /* TON signals ALPHANUMERIC */ | |
1350 { | |
1351 TRACE_EVENT("FDN doesn't support alphanumeric addr., SMS rejected"); | |
1352 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed ); | |
1353 return ( AT_FAIL ); | |
1354 } | |
1355 } | |
1356 /* end: check fixed dialing phonebook if enabled */ | |
1357 | |
1358 if ( da_addr.ton EQ TON_Alphanumeric ) | |
1359 { | |
1360 if( cmhSMS_packAlphaNumAddr(restDa, &da_addr) EQ AT_FAIL ) | |
1361 { | |
1362 return (AT_FAIL); | |
1363 } | |
1364 } | |
1365 else | |
1366 { | |
1367 cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, restDa); | |
1368 da_addr.digits = da_addr.c_num; | |
1369 } | |
1370 } | |
1371 else | |
1372 { | |
1373 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
1374 return ( AT_FAIL ); | |
1375 } | |
1376 | |
1377 /* | |
1378 *------------------------------------------------------------------- | |
1379 * create and send primitive for SMS submit | |
1380 *------------------------------------------------------------------- | |
1381 */ | |
1382 { | |
1383 PALLOC (mnsms_submit_req, MNSMS_SUBMIT_REQ); | |
1384 | |
1385 /* | |
1386 *----------------------------------------------------------------- | |
1387 * process the <sca> parameter | |
1388 *----------------------------------------------------------------- | |
1389 */ | |
1390 if ( sca NEQ NULL AND *sca NEQ '\0' ) | |
1391 { | |
1392 /* | |
1393 *--------------------------------------------------------------- | |
1394 * process the <tosca> parameter | |
1395 *--------------------------------------------------------------- | |
1396 */ | |
1397 if ( tosca NEQ NULL ) | |
1398 { | |
1399 smsShrdPrm.tpdu.sc_addr.ton = tosca -> ton; | |
1400 smsShrdPrm.tpdu.sc_addr.npi = tosca -> npi; | |
1401 | |
1402 } | |
1403 else | |
1404 { | |
1405 restSca = cmhSMS_setToaDef( sca, &smsShrdPrm.tpdu.sc_addr.ton, | |
1406 &smsShrdPrm.tpdu.sc_addr.npi); | |
1407 } | |
1408 cmhSMS_getAdrBcd( smsShrdPrm.tpdu.sc_addr.num, | |
1409 &smsShrdPrm.tpdu.sc_addr.c_num, | |
1410 MAX_SMS_ADDR_DIG, restSca); | |
1411 | |
1412 smsShrdPrm.tpdu.sc_addr.v_ton = TRUE; | |
1413 smsShrdPrm.tpdu.sc_addr.v_npi = TRUE; | |
1414 | |
1415 } | |
1416 else | |
1417 { | |
1418 memcpy (&smsShrdPrm.tpdu.sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr)); | |
1419 } | |
1420 | |
1421 /* | |
1422 *----------------------------------------------------------------- | |
1423 * process the <isReply> parameter | |
1424 *----------------------------------------------------------------- | |
1425 */ | |
1426 msgType = (pSMSSetPrm->msgType & ~TP_MTI_MASK) | |
1427 | TP_MTI_SMS_SUBMIT; | |
1428 if (isReply EQ 0) | |
1429 msgType &= ~TP_RP_MASK; /* set TP-Reply-Path bit to 0 */ | |
1430 else if (isReply > 0) | |
1431 msgType |= TP_RP_MASK; /* set TP-Reply-Path bit to 1 */ | |
1432 | |
1433 /* | |
1434 *----------------------------------------------------------------- | |
1435 * process the <data> parameter and | |
1436 * copy already to shared parameter | |
1437 *----------------------------------------------------------------- | |
1438 * reducing from 8 to 7 bit (if DCS is set) | |
1439 *----------------------------------------------------------------- | |
1440 */ | |
1441 | |
1442 if (udh) | |
1443 byte_offset = udh->len+1; | |
1444 | |
1445 if (data EQ NULL) | |
1446 { | |
1447 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
1448 PFREE (mnsms_submit_req); | |
1449 | |
1450 return ( AT_FAIL ); | |
1451 } | |
1452 | |
1453 cmhSMS_rdcSmsPp ( byte_offset, | |
1454 pSMSSetPrm -> dcs, | |
1455 ( UBYTE * ) data->data, ( UBYTE ) data->len, | |
1456 packedData.data, | |
1457 ( UBYTE * ) &packedData.len); | |
1458 | |
1459 ACI_MALLOC(smsShrdPrm.tpdu.tp_submit, sizeof(T_TP_SUBMIT)); | |
1460 cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit, | |
1461 srcId, | |
1462 msgType, | |
1463 0, | |
1464 &da_addr, | |
1465 &packedData, | |
1466 data->len, | |
1467 udh ); | |
1468 | |
1469 mnsms_submit_req -> mem_type = smsShrdPrm.mem2; | |
1470 mnsms_submit_req -> rec_num = SMS_RECORD_NOT_EXIST; | |
1471 mnsms_submit_req -> condx = SMS_CONDX_OVR_NON; | |
1472 mnsms_submit_req -> modify = SMS_MODIFY_NON; | |
1473 #ifdef REL99 | |
1474 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
1475 { | |
1476 mnsms_submit_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
1477 } | |
1478 else | |
1479 { | |
1480 mnsms_submit_req -> auto_rep_flag = FALSE; | |
1481 } | |
1482 #endif | |
1483 | |
1484 /* | |
1485 *----------------------------------------------------------------- | |
1486 * check if message should be transfered directly to SIM for SAT | |
1487 *----------------------------------------------------------------- | |
1488 */ | |
1489 | |
1490 #ifdef SIM_TOOLKIT | |
1491 | |
1492 if (psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM )) | |
1493 { | |
1494 if (simShrdPrm.setPrm[srcId].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_ACTIVE) | |
1495 { | |
1496 ret = cmhSAT_MoSmCntr( smsShrdPrm.tpdu.sc_addr, | |
1497 da_addr, | |
1498 (UBYTE)srcId); | |
1499 } | |
1500 else | |
1501 { | |
1502 simShrdPrm.setPrm[srcId].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; | |
1503 } | |
1504 } | |
1505 | |
1506 /* SIM_TOOLKIT_REQ was sent */ | |
1507 if (ret NEQ AT_CMPL) | |
1508 { | |
1509 /* save primitive address for SIM_TOOLKIT response */ | |
1510 sat_mnsms_submit_req = mnsms_submit_req; | |
1511 | |
1512 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGS; | |
1513 smsShrdPrm.owner = (T_OWN)srcId; | |
1514 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1515 | |
1516 /* mnsms_submit_req is send and coded in cmhSAT_ResSMCntrlBySIM() */ | |
1517 | |
1518 return ret; | |
1519 } | |
1520 #endif /* SIM_TOOLKIT */ | |
1521 | |
1522 /* code SMS-SUBMIT here */ | |
1523 cmhSMS_codeMsg (&mnsms_submit_req->sms_sdu, SMS_VT_SUBMIT, | |
1524 &smsShrdPrm.tpdu.sc_addr, SMS_SUBMIT, | |
1525 (UBYTE*)smsShrdPrm.tpdu.tp_submit); | |
1526 | |
1527 PSENDX (SMS, mnsms_submit_req); | |
1528 | |
1529 #ifdef _CONC_TESTING_ | |
1530 /* Implements Measure#32 */ | |
1531 cmhSMS_sdu_buf_print(&(mnsms_submit_req->sms_sdu.buf[0]), 0); | |
1532 #endif | |
1533 | |
1534 if (smsShrdPrm.tpdu.tp_submit NEQ NULL) | |
1535 { | |
1536 ACI_MFREE(smsShrdPrm.tpdu.tp_submit); | |
1537 smsShrdPrm.tpdu.tp_submit = NULL; | |
1538 } | |
1539 } | |
1540 | |
1541 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGS; | |
1542 smsShrdPrm.owner = (T_OWN)srcId; | |
1543 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1544 | |
1545 return( AT_EXCT ); | |
1546 } | |
1547 | |
1548 #if defined (SMS_PDU_SUPPORT) || defined (SIM_TOOLKIT) | |
1549 | |
1550 /* | |
1551 +-------------------------------------------------------------------+ | |
1552 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1553 | STATE : code ROUTINE : sAT_PlusCMGSPdu | | |
1554 +-------------------------------------------------------------------+ | |
1555 | |
1556 PURPOSE : This is the functional counterpart of the +CMGS | |
1557 AT command which is responsible for sending a short | |
1558 message in pdu mode. | |
1559 | |
1560 */ | |
1561 GLOBAL T_ACI_RETURN sAT_PlusCMGSPdu ( T_ACI_CMD_SRC srcId, | |
1562 T_ACI_SM_DATA *pdu ) | |
1563 { | |
1564 T_ACI_RETURN ret=AT_CMPL; /* AT response code */ | |
1565 T_rp_addr sc_addr; | |
1566 T_tp_da dest_addr; | |
1567 UBYTE len; | |
1568 | |
1569 CHAR daString[MAX_DIAL_LEN]; | |
1570 | |
1571 TRACE_FUNCTION ("sAT_PlusCMGSPdu()"); | |
1572 | |
1573 /* | |
1574 *----------------------------------------------------------------- | |
1575 * check if command executable | |
1576 *----------------------------------------------------------------- | |
1577 */ | |
1578 if(!cmhSMS_checkAccess (srcId, &ret)) | |
1579 return ret; | |
1580 | |
1581 | |
1582 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
1583 smsShrdPrm.rplyCB.cmgs = rAT_PlusCMGS; | |
1584 smsShrdPrm.errorCB = rAT_PlusCMS; | |
1585 #endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */ | |
1586 | |
1587 /* | |
1588 *------------------------------------------------------------------- | |
1589 * create and send primitive for SMS submit | |
1590 *------------------------------------------------------------------- | |
1591 */ | |
1592 { | |
1593 PALLOC (mnsms_submit_req, MNSMS_SUBMIT_REQ); | |
1594 | |
1595 mnsms_submit_req -> mem_type = smsShrdPrm.mem2; | |
1596 mnsms_submit_req -> rec_num = SMS_RECORD_NOT_EXIST; | |
1597 mnsms_submit_req -> condx = SMS_CONDX_OVR_NON; | |
1598 mnsms_submit_req -> modify = SMS_MODIFY_NON; | |
1599 | |
1600 #ifdef REL99 | |
1601 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
1602 { | |
1603 mnsms_submit_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
1604 } | |
1605 else | |
1606 { | |
1607 mnsms_submit_req -> auto_rep_flag = FALSE; | |
1608 } | |
1609 #endif /* REL99 */ | |
1610 | |
1611 if ( pdu->len > 0 ) | |
1612 { | |
1613 mnsms_submit_req->sms_sdu.l_buf = pdu->len * 8; | |
1614 mnsms_submit_req->sms_sdu.o_buf = 0; | |
1615 memcpy (mnsms_submit_req->sms_sdu.buf, pdu->data, pdu->len); | |
1616 } | |
1617 else | |
1618 { | |
1619 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
1620 PFREE (mnsms_submit_req); | |
1621 return ( AT_FAIL ); | |
1622 } | |
1623 | |
1624 | |
1625 len = DecodeRPAddress( &sc_addr.c_num, &sc_addr.ton, | |
1626 &sc_addr.npi, (UBYTE*)&sc_addr.num, pdu->data ); | |
1627 | |
1628 DecodeTPAddress( &dest_addr.c_num, &dest_addr.ton, | |
1629 &dest_addr.npi, (UBYTE*)&dest_addr.num, pdu->data+len+2); | |
1630 | |
1631 /* start: check number if fdn is activated and search number */ | |
1632 /* if( ( simShrdPrm.crdFun EQ SIM_FDN_ENABLED OR | |
1633 simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED ) AND | |
1634 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms )*/ | |
1635 //TISH, patch for OMAPS00129150 | |
1636 //start | |
1637 #if 0 | |
1638 if (pb_get_fdn_mode () EQ FDN_ENABLE AND | |
1639 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms ) | |
1640 #else | |
1641 if (pb_get_fdn_mode () EQ FDN_ENABLE AND | |
1642 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms AND srcId NEQ OWN_SRC_SAT) | |
1643 #endif | |
1644 //end | |
1645 { | |
1646 cmhPHB_getAdrStr(daString, MAX_DIAL_LEN-1, | |
1647 pdu->data+len+4, dest_addr.c_num); | |
1648 | |
1649 TRACE_EVENT_P1("sAT_PlusCMGSPdu: FDN checking %s:", daString); | |
1650 | |
1651 if ( dest_addr.ton NEQ TON_Alphanumeric ) /* not supported by Phonebook */ | |
1652 { | |
1653 | |
1654 if (pb_check_fdn (0, (const UBYTE*)daString) EQ PHB_OK) | |
1655 { | |
1656 TRACE_EVENT("sAT_PlusCMGSPdu: Found match in FDN"); | |
1657 } | |
1658 else | |
1659 { | |
1660 TRACE_EVENT("sAT_PlusCMGSPdu: No match in FDN found, SMS rejected"); | |
1661 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed ); | |
1662 return ( AT_FAIL ); | |
1663 } | |
1664 } | |
1665 else /* da alphanumeric encoded */ | |
1666 { | |
1667 TRACE_EVENT("FDN doesn't support alphanumeric addr., SMS rejected"); | |
1668 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed ); | |
1669 return ( AT_FAIL ); | |
1670 } | |
1671 } | |
1672 /* end: check number if fdn is activated and search number */ | |
1673 | |
1674 /* | |
1675 *----------------------------------------------------------------- | |
1676 * check if message should be transfered directly to SIM for SAT | |
1677 *----------------------------------------------------------------- | |
1678 */ | |
1679 | |
1680 #ifdef SIM_TOOLKIT | |
1681 | |
1682 | |
1683 if (psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM )) | |
1684 { | |
1685 if (simShrdPrm.setPrm[srcId].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_ACTIVE) | |
1686 { | |
1687 ret = cmhSAT_MoSmCntr( sc_addr, | |
1688 dest_addr, | |
1689 (UBYTE)srcId ); | |
1690 } | |
1691 else | |
1692 { | |
1693 simShrdPrm.setPrm[srcId].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; | |
1694 } | |
1695 } | |
1696 | |
1697 if (ret NEQ AT_CMPL) | |
1698 { | |
1699 /* save primitive address for SIM_TOOLKIT response */ | |
1700 sat_mnsms_submit_req = mnsms_submit_req; | |
1701 | |
1702 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGS; | |
1703 smsShrdPrm.owner = (T_OWN)srcId; | |
1704 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1705 | |
1706 return ret; | |
1707 /* PFREE(mnsms_submit_req); | |
1708 * NO PRIMITVE FREE !!! | |
1709 */ | |
1710 } | |
1711 #endif /* SIM_TOOLKIT */ | |
1712 | |
1713 | |
1714 #ifdef TI_PS_FF_AT_P_CMD_CUST | |
1715 if ((srcId EQ ((T_ACI_CMD_SRC)OWN_SRC_SAT)) AND | |
1716 (simShrdPrm.overall_cust_mode EQ (UBYTE)CUST_MODE_BEHAVIOUR_1)) | |
1717 { | |
1718 /* | |
1719 ** MMI is a Cust1 Application | |
1720 ** Forward the original PDU to the MMI, and free the Primitive | |
1721 ** (it will be recreated when the MMI sends its Request) | |
1722 */ | |
1723 cmhSAT_Cust1StkCmdInd(); | |
1724 PFREE(mnsms_submit_req); | |
1725 | |
1726 /* | |
1727 ** Ensure that the SMS parameters are reset, so that the SMS Entity is freed to | |
1728 ** process the command later. | |
1729 */ | |
1730 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
1731 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
1732 smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; | |
1733 | |
1734 return( AT_EXCT ); | |
1735 } | |
1736 #endif /* TI_PS_FF_AT_P_CMD_CUST */ | |
1737 PSENDX (SMS, mnsms_submit_req); | |
1738 } | |
1739 | |
1740 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGS; | |
1741 smsShrdPrm.owner = (T_OWN)srcId; | |
1742 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1743 | |
1744 return( AT_EXCT ); | |
1745 } | |
1746 | |
1747 #endif | |
1748 | |
1749 | |
1750 /* | |
1751 +-------------------------------------------------------------------+ | |
1752 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1753 | STATE : code ROUTINE : sAT_PlusCMSS | | |
1754 +-------------------------------------------------------------------+ | |
1755 | |
1756 PURPOSE : This is the functional counterpart of the +CMSS | |
1757 AT command which is responsible for sending a short | |
1758 message from memory. | |
1759 | |
1760 Features Concatenated SMS. | |
1761 For GPF-MMI. | |
1762 | |
1763 <index>: storage area index | |
1764 <da>: destination address | |
1765 <toda>: type of destination address | |
1766 */ | |
1767 #if (defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
1768 GLOBAL T_ACI_RETURN sAT_PlusCMSS ( T_ACI_CMD_SRC srcId, | |
1769 UBYTE index, | |
1770 CHAR* da, | |
1771 T_ACI_TOA* toda ) | |
1772 { | |
1773 T_CONC_INIT_RETURN ret; | |
1774 TRACE_FUNCTION ("sAT_PlusCMSS ()"); | |
1775 | |
1776 ret=concSMS_initSendFromMem(srcId, &index, da, toda); | |
1777 | |
1778 if (ret EQ CONC_NEEDED) | |
1779 { | |
1780 SET_CONC; | |
1781 | |
1782 /* memorize mem2, this is for rConcSMS_PlusCMGS */ | |
1783 concShrdPrm.mem_store = smsShrdPrm.mem2; | |
1784 | |
1785 return sAT_PlusCMSS_Gl(srcId, index, da, toda, rConcSMS_PlusCMSS, | |
1786 rConcSMS_PlusCMS_CMSS); | |
1787 } | |
1788 else if (ret EQ CONC_NOT_NEEDED) | |
1789 { | |
1790 return sAT_PlusCMSS_Gl(srcId, index, da, toda, rAT_PlusCMSS, | |
1791 rAT_PlusCMS); | |
1792 } | |
1793 else | |
1794 { | |
1795 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
1796 return ( AT_FAIL ); | |
1797 } | |
1798 } | |
1799 #endif /*#if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)*/ | |
1800 | |
1801 /* | |
1802 +-------------------------------------------------------------------+ | |
1803 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1804 | STATE : code ROUTINE : sAT_PlusCMSS | | |
1805 +-------------------------------------------------------------------+ | |
1806 | |
1807 PURPOSE : For Riv-MMI. | |
1808 */ | |
1809 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
1810 GLOBAL T_ACI_RETURN sAT_PlusCMSS ( T_ACI_CMD_SRC srcId, | |
1811 UBYTE index, | |
1812 CHAR* da, | |
1813 T_ACI_TOA* toda ) | |
1814 { | |
1815 | |
1816 TRACE_FUNCTION ("sAT_PlusCMSS ()"); | |
1817 TRACE_EVENT_P1("sAT_PlusCMGS () index: %d", index); | |
1818 return sAT_PlusCMSS_Gl(srcId, index, da, toda, rAT_PlusCMSS, | |
1819 rAT_PlusCMS); | |
1820 | |
1821 } | |
1822 #endif /*#if defined (FF_MMI_RIV)*/ | |
1823 | |
1824 /* | |
1825 +-------------------------------------------------------------------+ | |
1826 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1827 | STATE : code ROUTINE : sAT_PlusCMSS_Gl | | |
1828 +-------------------------------------------------------------------+ | |
1829 | |
1830 PURPOSE : This is the functional counterpart of the +CMSS | |
1831 AT command which is responsible for sending a short | |
1832 message from memory. | |
1833 | |
1834 <index>: storage area index | |
1835 <da>: destination address | |
1836 <toda>: type of destination address | |
1837 <rplyCB>: reply call-back | |
1838 <errorCB>: error call-back | |
1839 */ | |
1840 GLOBAL T_ACI_RETURN sAT_PlusCMSS_Gl ( T_ACI_CMD_SRC srcId, | |
1841 UBYTE index, | |
1842 CHAR* da, | |
1843 T_ACI_TOA* toda, | |
1844 T_CMSS_FCT rplyCB, | |
1845 T_ERROR_FCT errorCB ) | |
1846 { | |
1847 T_SMS_SET_PRM * pSMSSetPrm; | |
1848 T_ACI_RETURN ret; /* AT response code */ | |
1849 CHAR *restDa = da; /* destination address without */ | |
1850 /* international access function */ | |
1851 /* characters */ | |
1852 T_tp_da da_addr; | |
1853 | |
1854 #ifdef _CONC_TESTING_ | |
1855 /* Implements Measure#32 */ | |
1856 #endif | |
1857 | |
1858 TRACE_FUNCTION ("sAT_PlusCMSS_Gl ()"); | |
1859 | |
1860 /* | |
1861 *----------------------------------------------------------------- | |
1862 * check if command executable | |
1863 *----------------------------------------------------------------- | |
1864 */ | |
1865 if(!cmhSMS_checkAccess (srcId, &ret)) | |
1866 return ret; | |
1867 | |
1868 | |
1869 smsShrdPrm.rplyCB.cmss = rplyCB; | |
1870 smsShrdPrm.errorCB = errorCB; | |
1871 | |
1872 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
1873 | |
1874 | |
1875 /* | |
1876 *----------------------------------------------------------------- | |
1877 * process the <da> parameter | |
1878 *----------------------------------------------------------------- | |
1879 */ | |
1880 if ( da NEQ NULL ) | |
1881 { | |
1882 /* | |
1883 *--------------------------------------------------------------- | |
1884 * process the <toda> parameter | |
1885 *--------------------------------------------------------------- | |
1886 */ | |
1887 if ( toda NEQ NULL ) | |
1888 { | |
1889 da_addr.ton = toda -> ton; | |
1890 da_addr.npi = toda -> npi; | |
1891 } | |
1892 else | |
1893 { | |
1894 restDa = cmhSMS_setToaDef ( da, &da_addr.ton, | |
1895 &da_addr.npi ); | |
1896 } | |
1897 | |
1898 if ( da_addr.ton EQ TON_Alphanumeric ) | |
1899 { | |
1900 if( cmhSMS_packAlphaNumAddr(restDa, &da_addr) EQ AT_FAIL ) | |
1901 { | |
1902 return (AT_FAIL); | |
1903 } | |
1904 } | |
1905 else | |
1906 { | |
1907 cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, | |
1908 MAX_SMS_ADDR_DIG, restDa); | |
1909 da_addr.digits = da_addr.c_num; | |
1910 } | |
1911 | |
1912 /* check da_addr if FDN enabled */ | |
1913 /* if( ( simShrdPrm.crdFun EQ SIM_FDN_ENABLED OR | |
1914 simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED ) AND | |
1915 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms )*/ | |
1916 if (pb_get_fdn_mode () EQ FDN_ENABLE AND | |
1917 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms ) | |
1918 { | |
1919 | |
1920 TRACE_EVENT_P1("sAT_PlusCMSS_Gl: FDN check of %s", restDa ); | |
1921 | |
1922 if (pb_check_fdn (0, (const UBYTE*) restDa) EQ PHB_OK) | |
1923 { | |
1924 TRACE_EVENT("sAT_PlusCMSS_Gl: Found match in FDN!"); | |
1925 } | |
1926 else | |
1927 { | |
1928 TRACE_EVENT("sAT_PlusCMSS_Gl: No match in FDN found, SMS rejected!"); | |
1929 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_OpNotAllowed ); | |
1930 return ( AT_FAIL ); | |
1931 } | |
1932 } | |
1933 /* end: check FDN if enabled */ | |
1934 } | |
1935 else | |
1936 { | |
1937 #ifdef SIM_TOOLKIT | |
1938 /* FDN entry is already controlled by SAT */ | |
1939 if (psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM )) | |
1940 { | |
1941 memset (&da_addr, 0, sizeof(T_tp_da)); | |
1942 } | |
1943 else | |
1944 { | |
1945 #endif | |
1946 /* if FDN enabled read SMS from storage and verify address | |
1947 in callback function cmhSMS_SMReadCMSS() */ | |
1948 /* if( ( simShrdPrm.crdFun EQ SIM_FDN_ENABLED OR | |
1949 simShrdPrm.crdFun EQ SIM_FDN_BDN_ENABLED ) AND | |
1950 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms )*/ | |
1951 if (pb_get_fdn_mode () EQ FDN_ENABLE AND | |
1952 pb_get_fdn_classtype() EQ CLASS_VceDatFaxSms ) | |
1953 { | |
1954 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMSS; | |
1955 smsShrdPrm.owner = (T_OWN)srcId; | |
1956 smsShrdPrm.smsEntStat.entOwn = srcId; | |
1957 psaSMS_ReadReq(smsShrdPrm.mem2, index, READ_PREVIEW, SMS_STAT_NotPresent); | |
1958 return ( AT_EXCT ); | |
1959 } | |
1960 else /* proceed with empty address */ | |
1961 { | |
1962 memset (&da_addr, 0, sizeof(T_tp_da)); | |
1963 } | |
1964 #ifdef SIM_TOOLKIT | |
1965 } /* end else psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM )*/ | |
1966 #endif | |
1967 | |
1968 } | |
1969 | |
1970 | |
1971 ACI_MALLOC(smsShrdPrm.tpdu.tp_submit, sizeof(T_TP_SUBMIT)); | |
1972 cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit, | |
1973 srcId, | |
1974 0, /* fo */ | |
1975 0, | |
1976 &da_addr, | |
1977 NULL, /* data */ | |
1978 0, | |
1979 NULL /* udh */ ); | |
1980 | |
1981 | |
1982 { | |
1983 PALLOC (mnsms_submit_req, MNSMS_SUBMIT_REQ); | |
1984 memset (mnsms_submit_req, 0, sizeof(T_MNSMS_SUBMIT_REQ)); | |
1985 | |
1986 memcpy (&smsShrdPrm.tpdu.sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr)); | |
1987 mnsms_submit_req -> modify = SMS_MODIFY_SCA; | |
1988 | |
1989 if (da_addr.digits NEQ 0) | |
1990 { | |
1991 /* modify destination address */ | |
1992 mnsms_submit_req -> modify |= SMS_MODIFY_TPOA; | |
1993 } | |
1994 mnsms_submit_req -> mem_type = smsShrdPrm.mem2; | |
1995 mnsms_submit_req -> rec_num = index; | |
1996 mnsms_submit_req -> condx = SMS_CONDX_OVR_ANY; | |
1997 | |
1998 #ifdef REL99 | |
1999 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
2000 { | |
2001 mnsms_submit_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
2002 } | |
2003 else | |
2004 { | |
2005 mnsms_submit_req -> auto_rep_flag = FALSE; | |
2006 } | |
2007 #endif /* REL99 */ | |
2008 | |
2009 | |
2010 /* | |
2011 *----------------------------------------------------------------- | |
2012 * read the short message from memory | |
2013 *----------------------------------------------------------------- | |
2014 */ | |
2015 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMSS; | |
2016 smsShrdPrm.owner = (T_OWN)srcId; | |
2017 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2018 | |
2019 /* | |
2020 *----------------------------------------------------------------- | |
2021 * check if message should be transfered directly to SIM for SAT | |
2022 *----------------------------------------------------------------- | |
2023 */ | |
2024 #ifdef SIM_TOOLKIT | |
2025 | |
2026 if (psaSIM_ChkSIMSrvSup( SRV_MOSMCtrlSIM )) | |
2027 { | |
2028 if (simShrdPrm.setPrm[srcId].sat_cc_mode EQ SATCC_CONTROL_BY_SIM_ACTIVE) | |
2029 { | |
2030 if (da_addr.digits) | |
2031 { | |
2032 ret = cmhSAT_MoSmCntr( smsShrdPrm.tpdu.sc_addr, | |
2033 da_addr, | |
2034 (UBYTE)srcId ); | |
2035 if (ret NEQ AT_CMPL) | |
2036 { | |
2037 /* save primitive address for SIM_TOOLKIT response */ | |
2038 sat_mnsms_submit_req = mnsms_submit_req; | |
2039 return ret; | |
2040 } | |
2041 } | |
2042 else | |
2043 { | |
2044 /* send MNSMS_READ_REQ to SMS entity */ | |
2045 psaSMS_ReadReq ( smsShrdPrm.mem2, index, READ_PREVIEW, SMS_STAT_NotPresent); | |
2046 if (smsShrdPrm.tpdu.tp_submit NEQ NULL) | |
2047 { | |
2048 ACI_MFREE(smsShrdPrm.tpdu.tp_submit); | |
2049 smsShrdPrm.tpdu.tp_submit = NULL; | |
2050 } | |
2051 PFREE(mnsms_submit_req); | |
2052 return ( AT_EXCT ); | |
2053 } | |
2054 } | |
2055 else | |
2056 { | |
2057 simShrdPrm.setPrm[srcId].sat_cc_mode = SATCC_CONTROL_BY_SIM_ACTIVE; | |
2058 } | |
2059 } | |
2060 | |
2061 #endif /* SIM_TOOLKIT */ | |
2062 | |
2063 /* code SMS-SUBMIT here */ | |
2064 cmhSMS_codeMsg (&mnsms_submit_req->sms_sdu, SMS_VT_SUBMIT, | |
2065 &smsShrdPrm.tpdu.sc_addr, SMS_SUBMIT, | |
2066 (UBYTE*)smsShrdPrm.tpdu.tp_submit); | |
2067 | |
2068 /* send message */ | |
2069 PSENDX (SMS, mnsms_submit_req); | |
2070 #ifdef _CONC_TESTING_ | |
2071 /* Implements Measure#32 */ | |
2072 cmhSMS_sdu_buf_print(&(mnsms_submit_req->sms_sdu.buf[0]), 0); | |
2073 #endif | |
2074 if (smsShrdPrm.tpdu.tp_submit NEQ NULL) | |
2075 { | |
2076 ACI_MFREE(smsShrdPrm.tpdu.tp_submit); | |
2077 smsShrdPrm.tpdu.tp_submit = NULL; | |
2078 } | |
2079 } | |
2080 | |
2081 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMSS; | |
2082 smsShrdPrm.owner = (T_OWN)srcId; | |
2083 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2084 | |
2085 return( AT_EXCT ); | |
2086 } | |
2087 | |
2088 | |
2089 /* | |
2090 +-------------------------------------------------------------------+ | |
2091 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2092 | STATE : code ROUTINE : sAT_PlusCMGD | | |
2093 +-------------------------------------------------------------------+ | |
2094 | |
2095 PURPOSE : This is the functional counterpart of the +CMGD | |
2096 AT command which is responsible for deleting a short | |
2097 message from memory. | |
2098 | |
2099 Features Concatenated SMS. | |
2100 For GPF-MMI. | |
2101 | |
2102 <index>: storage area index | |
2103 */ | |
2104 #if (defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
2105 GLOBAL T_ACI_RETURN sAT_PlusCMGD ( T_ACI_CMD_SRC srcId, | |
2106 UBYTE index, | |
2107 UBYTE status ) | |
2108 { | |
2109 T_CONC_INIT_RETURN ret; | |
2110 | |
2111 TRACE_FUNCTION ("sAT_PlusCMGD ()"); | |
2112 | |
2113 ret=concSMS_initDeleteFromMem (srcId, index); | |
2114 | |
2115 if (ret EQ CONC_NEEDED) | |
2116 { | |
2117 SET_CONC; | |
2118 | |
2119 /* memorize mem1, this is for rConcSMS_PlusCMGD */ | |
2120 concShrdPrm.mem_store = smsShrdPrm.mem1; | |
2121 | |
2122 return sAT_PlusCMGD_Gl(srcId, index, status, rConcSMS_PlusCMGD, | |
2123 rConcSMS_PlusCMS_CMGD); | |
2124 } | |
2125 else if (ret EQ CONC_NOT_NEEDED) | |
2126 { | |
2127 return sAT_PlusCMGD_Gl(srcId, index, status, rAT_PlusCMGD, rAT_PlusCMS); | |
2128 } | |
2129 else | |
2130 { | |
2131 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
2132 return ( AT_FAIL ); | |
2133 } | |
2134 } | |
2135 #endif /*#if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)*/ | |
2136 | |
2137 /* | |
2138 +-------------------------------------------------------------------+ | |
2139 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2140 | STATE : code ROUTINE : sAT_PlusCMGD | | |
2141 +-------------------------------------------------------------------+ | |
2142 | |
2143 PURPOSE : For Riv-MMI. | |
2144 */ | |
2145 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
2146 GLOBAL T_ACI_RETURN sAT_PlusCMGD ( T_ACI_CMD_SRC srcId, | |
2147 UBYTE index, | |
2148 UBYTE status ) | |
2149 { | |
2150 TRACE_FUNCTION ("sAT_PlusCMGD ()"); | |
2151 TRACE_EVENT_P1("sAT_PlusCMGD () index: %d", index); | |
2152 | |
2153 return sAT_PlusCMGD_Gl(srcId, index, status, rAT_PlusCMGD, rAT_PlusCMS); | |
2154 } | |
2155 #endif /*#if defined (FF_MMI_RIV)*/ | |
2156 | |
2157 /* | |
2158 +-------------------------------------------------------------------+ | |
2159 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2160 | STATE : code ROUTINE : sAT_PlusCMGD_Gl | | |
2161 +-------------------------------------------------------------------+ | |
2162 | |
2163 PURPOSE : This is the functional counterpart of the +CMGD | |
2164 AT command which is responsible for deleting a short | |
2165 message from memory. | |
2166 | |
2167 <index>: storage area index | |
2168 <rplyCB>: reply call-back | |
2169 <errorCB>: error call-back | |
2170 */ | |
2171 GLOBAL T_ACI_RETURN sAT_PlusCMGD_Gl ( T_ACI_CMD_SRC srcId, | |
2172 UBYTE index, | |
2173 UBYTE status, | |
2174 T_CMGD_FCT rplyCB, | |
2175 T_ERROR_FCT errorCB ) | |
2176 { | |
2177 T_ACI_RETURN ret; /* AT response code */ | |
2178 | |
2179 TRACE_FUNCTION ("sAT_PlusCMGD_Gl ()"); | |
2180 | |
2181 /* | |
2182 *----------------------------------------------------------------- | |
2183 * check if command executable | |
2184 *----------------------------------------------------------------- | |
2185 */ | |
2186 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2187 return ret; | |
2188 | |
2189 smsShrdPrm.errorCB = errorCB; | |
2190 smsShrdPrm.rplyCB.cmgd = rplyCB; | |
2191 | |
2192 cmhSMS_SendDelete_Req (index, status); | |
2193 | |
2194 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGD; | |
2195 smsShrdPrm.owner = (T_OWN)srcId; | |
2196 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2197 | |
2198 return( AT_EXCT ); | |
2199 } | |
2200 | |
2201 | |
2202 | |
2203 | |
2204 /* | |
2205 +-------------------------------------------------------------------+ | |
2206 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2207 | STATE : code ROUTINE : sAT_PlusCMGW_Old | | |
2208 +-------------------------------------------------------------------+ | |
2209 | |
2210 PURPOSE : This is the functional counterpart of the +CMGW | |
2211 AT command which is responsible for writing a short | |
2212 message to memory. | |
2213 | |
2214 <index>: index of location area to be written | |
2215 <address>: originating/destination address | |
2216 <toa>: type of address | |
2217 <stat>: message status | |
2218 <data>: message data | |
2219 <sca>: service center address | |
2220 <tosca>: type of service center address | |
2221 <isReply>: > 0: set TP-Reply-Path explicitly | |
2222 EQ 0: clear TP-Reply-Path explicitly | |
2223 */ | |
2224 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
2225 GLOBAL T_ACI_RETURN sAT_PlusCMGW_Old ( T_ACI_CMD_SRC srcId, | |
2226 SHORT index, | |
2227 CHAR* address, | |
2228 T_ACI_TOA* toa, | |
2229 T_ACI_SMS_STAT stat, | |
2230 UBYTE msg_ref, | |
2231 T_ACI_SM_DATA* data, | |
2232 CHAR* sca, | |
2233 T_ACI_TOA* tosca, | |
2234 SHORT isReply ) | |
2235 { | |
2236 TRACE_FUNCTION ("sAT_PlusCMGW_Old ()"); | |
2237 | |
2238 return sAT_PlusCMGW_Gl | |
2239 (srcId, index, address, toa, stat, msg_ref, data, | |
2240 NULL, sca, tosca, isReply, rAT_PlusCMGW, rAT_PlusCMS); | |
2241 } | |
2242 #endif /*#if defined SMI OR defined MFW */ | |
2243 | |
2244 /* | |
2245 +-------------------------------------------------------------------+ | |
2246 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2247 | STATE : code ROUTINE : sAT_PlusCMGW | | |
2248 +-------------------------------------------------------------------+ | |
2249 | |
2250 PURPOSE : This is the functional counterpart of the +CMGW | |
2251 AT command which is responsible for writing a short | |
2252 message to memory. | |
2253 | |
2254 Features Concatenated SMS. | |
2255 For GPF-MMI. | |
2256 | |
2257 <index>: index of location area to be written | |
2258 <address>: originating/destination address | |
2259 <toa>: type of address | |
2260 <stat>: message status | |
2261 <data>: message data | |
2262 <sca>: service center address | |
2263 <tosca>: type of service center address | |
2264 <isReply>: > 0: set TP-Reply-Path explicitly | |
2265 EQ 0: clear TP-Reply-Path explicitly | |
2266 */ | |
2267 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
2268 GLOBAL T_ACI_RETURN sAT_PlusCMGW ( T_ACI_CMD_SRC srcId, | |
2269 SHORT index, | |
2270 CHAR* address, | |
2271 T_ACI_TOA* toa, | |
2272 T_ACI_SMS_STAT stat, | |
2273 UBYTE msg_ref, | |
2274 T_SM_DATA_EXT* src_data, | |
2275 CHAR* sca, | |
2276 T_ACI_TOA* tosca, | |
2277 SHORT isReply ) | |
2278 { | |
2279 T_CONC_INIT_RETURN ret; | |
2280 T_ACI_UDH_DATA udh; | |
2281 T_ACI_SM_DATA tar_data; | |
2282 UBYTE alphabet; | |
2283 | |
2284 TRACE_FUNCTION ("sAT_PlusCMGW ()"); | |
2285 | |
2286 | |
2287 alphabet = cmhSMS_getAlphabetPp ( smsShrdPrm.pSetPrm[srcId]->dcs ); | |
2288 | |
2289 /* cut off more than CONC_MAX_SEGS segments */ | |
2290 if (alphabet EQ 0) | |
2291 { | |
2292 src_data->len = MINIMUM (src_data->len, concShrdPrm.l_uncomp7bit_data_conc*CONC_MAX_SEGS); | |
2293 } | |
2294 else | |
2295 { | |
2296 src_data->len = MINIMUM (src_data->len, concShrdPrm.l_uncomp8bit_data_conc*CONC_MAX_SEGS); | |
2297 } | |
2298 | |
2299 ret=concSMS_initStoreInMem(&tar_data, &udh, srcId, index, address, toa, stat, | |
2300 msg_ref, src_data, sca, tosca, isReply, alphabet); | |
2301 | |
2302 if (ret EQ CONC_NEEDED) | |
2303 { | |
2304 /* check if concBuffer is already full */ | |
2305 if (concSMS_concBufferAvail() EQ FALSE) | |
2306 { | |
2307 TRACE_ERROR ("no concBuffer available, so CSMS can not be written"); | |
2308 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_MemFull ); | |
2309 return AT_FAIL; | |
2310 } | |
2311 | |
2312 /* limit the maximum number of CSMS segments to MAX_SEG_TOTAL */ | |
2313 if (concShrdPrm.elem_count+concShrdPrm.udh.max_num > MAX_SEG_TOTAL) | |
2314 { | |
2315 TRACE_ERROR ("total number of segments will exceed the maximum, so CSMS can not be written"); | |
2316 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr ); | |
2317 return AT_FAIL; | |
2318 } | |
2319 | |
2320 SET_CONC; | |
2321 return sAT_PlusCMGW_Gl(srcId, index, address, toa, stat, | |
2322 msg_ref, &tar_data, &udh, sca, tosca, isReply, | |
2323 rConcSMS_PlusCMGW, rConcSMS_PlusCMS_CMGW); | |
2324 } | |
2325 else | |
2326 { | |
2327 return sAT_PlusCMGW_Gl(srcId, index, address, toa, stat, | |
2328 msg_ref, &tar_data, (T_ACI_UDH_DATA*)NULL, | |
2329 sca, tosca, isReply, | |
2330 rAT_PlusCMGW, rAT_PlusCMS); | |
2331 } | |
2332 } | |
2333 #endif /*#if defined (MFW) OR defined (_CONC_TESTING_)*/ | |
2334 | |
2335 /* | |
2336 +-------------------------------------------------------------------+ | |
2337 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2338 | STATE : code ROUTINE : sAT_PlusCMGW | | |
2339 +-------------------------------------------------------------------+ | |
2340 | |
2341 PURPOSE : For Riv-MMI if conc. is not needed. | |
2342 */ | |
2343 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
2344 GLOBAL T_ACI_RETURN sAT_PlusCMGW ( T_ACI_CMD_SRC srcId, | |
2345 SHORT index, | |
2346 CHAR* address, | |
2347 T_ACI_TOA* toa, | |
2348 T_ACI_SMS_STAT stat, | |
2349 UBYTE msg_ref, | |
2350 T_ACI_SM_DATA* src_data, | |
2351 CHAR* sca, | |
2352 T_ACI_TOA* tosca, | |
2353 SHORT isReply ) | |
2354 { | |
2355 TRACE_FUNCTION ("sAT_PlusCMGW ()"); | |
2356 | |
2357 return sAT_PlusCMGW_Gl(srcId, index, address, toa, stat, | |
2358 msg_ref, src_data, (T_ACI_UDH_DATA*)NULL, | |
2359 sca, tosca, isReply, | |
2360 rAT_PlusCMGW, rAT_PlusCMS); | |
2361 } | |
2362 | |
2363 /* | |
2364 +-------------------------------------------------------------------+ | |
2365 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2366 | STATE : code ROUTINE : sAT_PercentCMGW | | |
2367 +-------------------------------------------------------------------+ | |
2368 | |
2369 PURPOSE : Adding Percent CMGW command to handle udh and src | |
2370 data for each segment for conc module. | |
2371 | |
2372 For Riv-MMI if conc. is needed. | |
2373 */ | |
2374 GLOBAL T_ACI_RETURN sAT_PercentCMGW ( T_ACI_CMD_SRC srcId, | |
2375 SHORT index, | |
2376 CHAR* address, | |
2377 T_ACI_TOA* toa, | |
2378 T_ACI_SMS_STAT stat, | |
2379 UBYTE msg_ref, | |
2380 T_ACI_SM_DATA* src_data, | |
2381 T_ACI_UDH_DATA* udh_data, | |
2382 CHAR* sca, | |
2383 T_ACI_TOA* tosca, | |
2384 SHORT isReply ) | |
2385 { | |
2386 TRACE_FUNCTION ("sAT_PercentCMGW with udh()"); | |
2387 | |
2388 return sAT_PlusCMGW_Gl(srcId, index, address, toa, stat, | |
2389 msg_ref, src_data, udh_data, | |
2390 sca, tosca, isReply, | |
2391 rAT_PlusCMGW, rAT_PlusCMS); | |
2392 } | |
2393 | |
2394 #endif /*#if defined (FF_MMI_RIV)*/ | |
2395 | |
2396 /* | |
2397 +-------------------------------------------------------------------+ | |
2398 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2399 | STATE : code ROUTINE : sAT_PlusCMGW_Gl | | |
2400 +-------------------------------------------------------------------+ | |
2401 | |
2402 PURPOSE : This is the functional counterpart of the +CMGW | |
2403 AT command which is responsible for writing a short | |
2404 message to memory. | |
2405 | |
2406 <index>: index of location area to be written | |
2407 <address>: originating/destination address | |
2408 <toa>: type of address | |
2409 <stat>: message status | |
2410 <data>: message data | |
2411 <udh>: user data header | |
2412 <sca>: service center address | |
2413 <tosca>: type of service center address | |
2414 <isReply>: > 0: set TP-Reply-Path explicitly | |
2415 EQ 0: clear TP-Reply-Path explicitly | |
2416 <rplyCB>: reply call-back | |
2417 <errorCB>: error call-back | |
2418 */ | |
2419 GLOBAL T_ACI_RETURN sAT_PlusCMGW_Gl ( T_ACI_CMD_SRC srcId, | |
2420 SHORT index, | |
2421 CHAR* address, | |
2422 T_ACI_TOA* toa, | |
2423 T_ACI_SMS_STAT stat, | |
2424 UBYTE msg_ref, | |
2425 T_ACI_SM_DATA* data, | |
2426 T_ACI_UDH_DATA* udh, | |
2427 CHAR* sca, | |
2428 T_ACI_TOA* tosca, | |
2429 SHORT isReply, | |
2430 T_CMGW_FCT rplyCB, | |
2431 T_ERROR_FCT errorCB) | |
2432 { | |
2433 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
2434 T_ACI_RETURN ret; /* AT response code */ | |
2435 CHAR * restAddress = address; | |
2436 /* address without international access */ | |
2437 /* function characters */ | |
2438 UBYTE chkIdx; /* checked parameter <index> */ | |
2439 UBYTE chkStat; /* checked parameter <stat> */ | |
2440 CHAR* restSca = sca; /* service center address without */ | |
2441 /* international access function */ | |
2442 /* characters */ | |
2443 UBYTE msgType; | |
2444 | |
2445 T_ACI_SM_DATA packedData; | |
2446 T_tp_da da_addr; | |
2447 T_rp_addr sc_addr; | |
2448 UBYTE mr; | |
2449 UBYTE byte_offset = 0; | |
2450 | |
2451 #ifdef _CONC_TESTING_ | |
2452 /* Implements Measure#32 */ | |
2453 #endif | |
2454 | |
2455 TRACE_FUNCTION ("sAT_PlusCMGW_Gl ()"); | |
2456 | |
2457 | |
2458 /* | |
2459 *----------------------------------------------------------------- | |
2460 * check if command executable | |
2461 *----------------------------------------------------------------- | |
2462 */ | |
2463 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2464 return ret; | |
2465 | |
2466 smsShrdPrm.rplyCB.cmgw = rplyCB; | |
2467 smsShrdPrm.errorCB = errorCB; | |
2468 | |
2469 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
2470 | |
2471 /* | |
2472 *----------------------------------------------------------------- | |
2473 * process the <index> parameter | |
2474 *----------------------------------------------------------------- | |
2475 */ | |
2476 if( index NEQ ACI_NumParmNotPresent ) | |
2477 { | |
2478 if( ( index > SMS_CMH_IDX_MAX OR index < SMS_CMH_IDX_MIN ) AND | |
2479 index NEQ CMGW_IDX_FREE_ENTRY ) | |
2480 { | |
2481 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2482 return ( AT_FAIL ); | |
2483 } | |
2484 else | |
2485 | |
2486 chkIdx = (UBYTE) index; | |
2487 } | |
2488 else | |
2489 | |
2490 chkIdx = CMGW_IDX_FREE_ENTRY; | |
2491 | |
2492 /* | |
2493 *----------------------------------------------------------------- | |
2494 * process the <address> parameter | |
2495 *----------------------------------------------------------------- | |
2496 */ | |
2497 | |
2498 memset (&da_addr, 0, sizeof(T_tp_da)); | |
2499 if ( address NEQ NULL ) | |
2500 { | |
2501 /* | |
2502 *--------------------------------------------------------------- | |
2503 * process the <toa> parameter | |
2504 *--------------------------------------------------------------- | |
2505 */ | |
2506 if ( toa NEQ NULL ) | |
2507 { | |
2508 da_addr.ton = toa -> ton; | |
2509 da_addr.npi = toa -> npi; | |
2510 } | |
2511 else | |
2512 { | |
2513 restAddress = cmhSMS_setToaDef ( address, | |
2514 &da_addr.ton, | |
2515 &da_addr.npi ); | |
2516 } | |
2517 | |
2518 if ( da_addr.ton EQ TON_Alphanumeric ) | |
2519 { | |
2520 if( cmhSMS_packAlphaNumAddr(restAddress, &da_addr) EQ AT_FAIL ) | |
2521 { | |
2522 return (AT_FAIL); | |
2523 } | |
2524 } | |
2525 else | |
2526 { | |
2527 cmhSMS_getAdrBcd ( da_addr.num, | |
2528 &da_addr.c_num, | |
2529 MAX_SMS_ADDR_DIG, | |
2530 restAddress ); | |
2531 da_addr.digits = da_addr.c_num; | |
2532 } | |
2533 | |
2534 } | |
2535 else /* if ( address NEQ NULL ) */ | |
2536 { | |
2537 /* | |
2538 *--------------------------------------------------------------- | |
2539 * process the <toa> parameter | |
2540 *--------------------------------------------------------------- | |
2541 */ | |
2542 if ( toa NEQ NULL ) | |
2543 { | |
2544 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2545 return ( AT_FAIL ); | |
2546 } | |
2547 else | |
2548 { | |
2549 da_addr.digits = 0; | |
2550 } | |
2551 } | |
2552 | |
2553 /* | |
2554 *----------------------------------------------------------------- | |
2555 * process the <stat> parameter | |
2556 *----------------------------------------------------------------- | |
2557 */ | |
2558 if( stat NEQ SMS_STAT_NotPresent ) | |
2559 { | |
2560 if( !cmhSMS_getStatPsa ( stat, &chkStat ) ) | |
2561 { | |
2562 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2563 return ( AT_FAIL ); | |
2564 } | |
2565 } | |
2566 else | |
2567 { | |
2568 chkStat = STO_UNSENT; | |
2569 } | |
2570 | |
2571 /* | |
2572 *------------------------------------------------------------------- | |
2573 * create and send primitive for SMS store | |
2574 *------------------------------------------------------------------- | |
2575 */ | |
2576 { | |
2577 PALLOC (mnsms_store_req, MNSMS_STORE_REQ); | |
2578 | |
2579 mnsms_store_req -> mem_type = smsShrdPrm.mem2; | |
2580 if (chkIdx EQ CMGW_IDX_FREE_ENTRY) | |
2581 mnsms_store_req -> condx = SMS_CONDX_OVR_NON; | |
2582 else | |
2583 mnsms_store_req -> condx = SMS_CONDX_OVR_ANY; | |
2584 | |
2585 /* | |
2586 *----------------------------------------------------------------- | |
2587 * process the <sca> parameter | |
2588 *----------------------------------------------------------------- | |
2589 */ | |
2590 if ( sca NEQ NULL AND *sca NEQ '\0' ) | |
2591 { | |
2592 /* | |
2593 *--------------------------------------------------------------- | |
2594 * process the <tosca> parameter | |
2595 *--------------------------------------------------------------- | |
2596 */ | |
2597 if ( tosca NEQ NULL ) | |
2598 { | |
2599 sc_addr.ton = tosca -> ton; | |
2600 sc_addr.npi = tosca -> npi; | |
2601 } | |
2602 else | |
2603 { | |
2604 restSca = cmhSMS_setToaDef( sca, &sc_addr.ton, | |
2605 &sc_addr.npi); | |
2606 } | |
2607 cmhSMS_getAdrBcd( sc_addr.num, | |
2608 &sc_addr.c_num, | |
2609 MAX_SMS_ADDR_DIG, | |
2610 restSca); | |
2611 } | |
2612 else | |
2613 { | |
2614 memcpy (&sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr)); | |
2615 } | |
2616 | |
2617 /* | |
2618 *----------------------------------------------------------------- | |
2619 * process the <isReply> parameter | |
2620 *----------------------------------------------------------------- | |
2621 */ | |
2622 msgType = (pSMSSetPrm->msgType & ~TP_MTI_MASK) | |
2623 | TP_MTI_SMS_SUBMIT; | |
2624 if (isReply EQ 0) | |
2625 msgType &= ~TP_RP_MASK; /* set TP-Reply-Path bit to 0 */ | |
2626 else if (isReply > 0) | |
2627 msgType |= TP_RP_MASK; /* set TP-Reply-Path bit to 1 */ | |
2628 | |
2629 /* | |
2630 *----------------------------------------------------------------- | |
2631 * copy parameter | |
2632 *----------------------------------------------------------------- | |
2633 */ | |
2634 mnsms_store_req->rec_num = chkIdx; | |
2635 mnsms_store_req->status = chkStat; | |
2636 | |
2637 /* | |
2638 *----------------------------------------------------------------- | |
2639 * process the <msg_ref> parameter | |
2640 *----------------------------------------------------------------- | |
2641 */ | |
2642 if (msg_ref EQ NOT_PRESENT_8BIT) | |
2643 { | |
2644 mr = 0; | |
2645 } | |
2646 else | |
2647 { | |
2648 mr = msg_ref; | |
2649 } | |
2650 | |
2651 /* | |
2652 *----------------------------------------------------------------- | |
2653 * process the <data> parameter and | |
2654 * copy already to shared parameter | |
2655 *----------------------------------------------------------------- | |
2656 * reducing from 8 to 7 bit | |
2657 *----------------------------------------------------------------- | |
2658 */ | |
2659 if (udh) | |
2660 byte_offset = udh->len+1; | |
2661 | |
2662 if (data EQ NULL) | |
2663 { | |
2664 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2665 PFREE (mnsms_store_req); | |
2666 | |
2667 return ( AT_FAIL ); | |
2668 } | |
2669 | |
2670 cmhSMS_rdcSmsPp ( byte_offset, | |
2671 pSMSSetPrm -> dcs, | |
2672 ( UBYTE * ) data->data, ( UBYTE ) data->len, | |
2673 packedData.data, &packedData.len); | |
2674 | |
2675 if ( (chkStat EQ REC_UNREAD) OR (chkStat EQ REC_READ) ) | |
2676 { | |
2677 ACI_MALLOC(smsShrdPrm.tpdu.tp_deliver, sizeof(T_TP_DELIVER)); | |
2678 cmhSMS_fillTpDeliver (smsShrdPrm.tpdu.tp_deliver, | |
2679 srcId, | |
2680 msgType, | |
2681 (T_tp_oa *)&da_addr, | |
2682 &packedData, | |
2683 (UBYTE)data->len, | |
2684 udh ); | |
2685 | |
2686 /* code encode SMS-DELIVER here */ | |
2687 cmhSMS_codeMsg (&mnsms_store_req->sms_sdu, | |
2688 SMS_VT_DELIVER, | |
2689 &sc_addr, | |
2690 SMS_DELIVER, | |
2691 (UBYTE*)smsShrdPrm.tpdu.tp_deliver); | |
2692 | |
2693 PSENDX (SMS, mnsms_store_req); | |
2694 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
2695 if (smsShrdPrm.tpdu.tp_deliver NEQ NULL) | |
2696 { | |
2697 ACI_MFREE(smsShrdPrm.tpdu.tp_deliver); | |
2698 smsShrdPrm.tpdu.tp_deliver = NULL; | |
2699 } | |
2700 } | |
2701 else | |
2702 { | |
2703 ACI_MALLOC(smsShrdPrm.tpdu.tp_submit, sizeof(T_TP_SUBMIT)); | |
2704 cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit, | |
2705 srcId, | |
2706 msgType, | |
2707 mr, | |
2708 &da_addr, | |
2709 &packedData, | |
2710 data->len, | |
2711 udh ); | |
2712 | |
2713 /* encode SMS-SUBMIT here */ | |
2714 cmhSMS_codeMsg (&mnsms_store_req->sms_sdu, | |
2715 SMS_VT_SUBMIT, | |
2716 &sc_addr, | |
2717 SMS_SUBMIT, | |
2718 (UBYTE*)smsShrdPrm.tpdu.tp_submit); | |
2719 | |
2720 PSENDX (SMS, mnsms_store_req); | |
2721 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
2722 #ifdef _CONC_TESTING_ | |
2723 TRACE_EVENT_P1("cmgw:rec_num: %d", mnsms_store_req->rec_num); | |
2724 TRACE_EVENT_P1("cmgw:status: %d", mnsms_store_req->status); | |
2725 TRACE_EVENT_P1("cmgw:mem_type:%d", mnsms_store_req -> mem_type); | |
2726 TRACE_EVENT_P1("cmgw:condx: %d", mnsms_store_req -> condx); | |
2727 /* Implements Measure#32 */ | |
2728 cmhSMS_sdu_buf_print(&(mnsms_store_req->sms_sdu.buf[0]), 0); | |
2729 #endif | |
2730 if (smsShrdPrm.tpdu.tp_submit NEQ NULL) | |
2731 { | |
2732 ACI_MFREE(smsShrdPrm.tpdu.tp_submit); | |
2733 smsShrdPrm.tpdu.tp_submit = NULL; | |
2734 } | |
2735 } | |
2736 } | |
2737 | |
2738 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGW; | |
2739 smsShrdPrm.owner = (T_OWN)srcId; | |
2740 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2741 | |
2742 return( AT_EXCT ); | |
2743 } | |
2744 | |
2745 #if defined (SMS_PDU_SUPPORT) | |
2746 | |
2747 /* | |
2748 +-------------------------------------------------------------------+ | |
2749 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2750 | STATE : code ROUTINE : sAT_PlusCMGWPdu | | |
2751 +-------------------------------------------------------------------+ | |
2752 | |
2753 PURPOSE : This is the functional counterpart of the +CMGW | |
2754 AT command which is responsible for writing a short | |
2755 message to memory in PDU mode. | |
2756 | |
2757 */ | |
2758 | |
2759 GLOBAL T_ACI_RETURN sAT_PlusCMGWPdu ( T_ACI_CMD_SRC srcId, | |
2760 UBYTE stat, | |
2761 T_ACI_SM_DATA *pdu) | |
2762 { | |
2763 T_ACI_RETURN ret; /* AT response code */ | |
2764 UBYTE chkStat = '\0'; /* checked parameter <stat> */ | |
2765 | |
2766 TRACE_FUNCTION ("sAT_PlusCMGWPdu ()"); | |
2767 | |
2768 /* | |
2769 *----------------------------------------------------------------- | |
2770 * check if command executable | |
2771 *----------------------------------------------------------------- | |
2772 */ | |
2773 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2774 return ret; | |
2775 | |
2776 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
2777 smsShrdPrm.errorCB = rAT_PlusCMS; | |
2778 #endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */ | |
2779 | |
2780 /* | |
2781 *----------------------------------------------------------------- | |
2782 * process the <stat> parameter | |
2783 *----------------------------------------------------------------- | |
2784 */ | |
2785 switch (stat) | |
2786 { | |
2787 case SMS_STAT_RecUnread: | |
2788 chkStat = REC_UNREAD; | |
2789 break; | |
2790 case SMS_STAT_RecRead: | |
2791 chkStat = REC_READ; | |
2792 break; | |
2793 case SMS_STAT_StoUnsent: | |
2794 chkStat = STO_UNSENT; | |
2795 break; | |
2796 case SMS_STAT_StoSent: | |
2797 chkStat = STO_SENT; | |
2798 break; | |
2799 } | |
2800 | |
2801 /* | |
2802 *------------------------------------------------------------------- | |
2803 * create and send primitive for SMS store | |
2804 *------------------------------------------------------------------- | |
2805 */ | |
2806 { | |
2807 PALLOC (mnsms_store_req, MNSMS_STORE_REQ); | |
2808 | |
2809 mnsms_store_req -> mem_type = smsShrdPrm.mem2; | |
2810 mnsms_store_req -> rec_num = CMGW_IDX_FREE_ENTRY; | |
2811 mnsms_store_req -> condx = SMS_CONDX_OVR_NON; | |
2812 mnsms_store_req -> status = chkStat; | |
2813 | |
2814 if ( pdu->len > 0 ) | |
2815 { | |
2816 mnsms_store_req->sms_sdu.l_buf = pdu->len * 8; | |
2817 mnsms_store_req->sms_sdu.o_buf = 0; | |
2818 memcpy (mnsms_store_req->sms_sdu.buf, pdu->data, pdu->len); | |
2819 } | |
2820 else | |
2821 { | |
2822 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2823 PFREE (mnsms_store_req); | |
2824 return ( AT_FAIL ); | |
2825 } | |
2826 | |
2827 PSENDX (SMS, mnsms_store_req); | |
2828 } | |
2829 | |
2830 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGW; | |
2831 smsShrdPrm.owner = (T_OWN)srcId; | |
2832 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2833 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
2834 | |
2835 return( AT_EXCT ); | |
2836 } | |
2837 | |
2838 #endif | |
2839 | |
2840 | |
2841 /* | |
2842 +-------------------------------------------------------------------+ | |
2843 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2844 | STATE : code ROUTINE : sAT_PlusCMGC | | |
2845 +-------------------------------------------------------------------+ | |
2846 | |
2847 PURPOSE : This is the functional counterpart of the +CMGC | |
2848 AT command which is responsible for sending a command. | |
2849 | |
2850 Features Concatenated SMS. | |
2851 For GPF-MMI. | |
2852 | |
2853 <fo>: first octet of SMS-COMMAND | |
2854 <ct>: command type | |
2855 <pid>: protocol identifier | |
2856 <mn>: message number | |
2857 <da>: destination address | |
2858 <toda>: type of destination address | |
2859 <data>: command data | |
2860 */ | |
2861 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
2862 GLOBAL T_ACI_RETURN sAT_PlusCMGC ( T_ACI_CMD_SRC srcId, | |
2863 SHORT fo, | |
2864 SHORT ct, | |
2865 SHORT pid, | |
2866 SHORT mn, | |
2867 CHAR* da, | |
2868 T_ACI_TOA* toda, | |
2869 T_ACI_CMD_DATA* data ) | |
2870 { | |
2871 T_CONC_INIT_RETURN ret; | |
2872 | |
2873 TRACE_FUNCTION ("sAT_PlusCMGC ()"); | |
2874 | |
2875 | |
2876 ret=concSMS_initCommand (srcId, fo, ct, pid, mn, da, toda, | |
2877 data); | |
2878 | |
2879 if (ret EQ CONC_NEEDED) | |
2880 { | |
2881 SET_CONC; | |
2882 return sAT_PlusCMGC_Gl(srcId, fo, ct, pid, mn, da, toda, | |
2883 data, rConcSMS_PlusCMGC); | |
2884 } | |
2885 else if (ret EQ CONC_NOT_NEEDED) | |
2886 { | |
2887 return sAT_PlusCMGC_Gl(srcId, fo, ct, pid, mn, da, toda, | |
2888 data, rAT_PlusCMGC); | |
2889 } | |
2890 else | |
2891 { | |
2892 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr ); | |
2893 return ( AT_FAIL ); | |
2894 } | |
2895 } | |
2896 #endif /*#if defined (MFW) OR defined (_CONC_TESTING_)*/ | |
2897 | |
2898 /* | |
2899 +-------------------------------------------------------------------+ | |
2900 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2901 | STATE : code ROUTINE : sAT_PlusCMGC | | |
2902 +-------------------------------------------------------------------+ | |
2903 | |
2904 PURPOSE : New Plus CMGC command for handling the conc module on | |
2905 the Riv-MMI side. | |
2906 */ | |
2907 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
2908 GLOBAL T_ACI_RETURN sAT_PlusCMGC ( T_ACI_CMD_SRC srcId, | |
2909 SHORT fo, | |
2910 SHORT ct, | |
2911 SHORT pid, | |
2912 SHORT mn, | |
2913 CHAR* da, | |
2914 T_ACI_TOA* toda, | |
2915 T_ACI_CMD_DATA* data ) | |
2916 { | |
2917 TRACE_FUNCTION ("sAT_PlusCMGC ()"); | |
2918 TRACE_EVENT_P1("sAT_PlusCMGC () mn: %d", mn); | |
2919 | |
2920 return sAT_PlusCMGC_Gl(srcId, fo, ct, pid, mn, da, toda, | |
2921 data, rAT_PlusCMGC); | |
2922 } | |
2923 #endif /*#if defined (FF_MMI_RIV)*/ | |
2924 | |
2925 /* | |
2926 +-------------------------------------------------------------------+ | |
2927 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2928 | STATE : code ROUTINE : sAT_PlusCMGC_Gl | | |
2929 +-------------------------------------------------------------------+ | |
2930 | |
2931 PURPOSE : This is the functional counterpart of the +CMGC | |
2932 AT command which is responsible for sending a command. | |
2933 | |
2934 <fo>: first octet of SMS-COMMAND | |
2935 <ct>: command type | |
2936 <pid>: protocol identifier | |
2937 <mn>: message number | |
2938 <da>: destination address | |
2939 <toda>: type of destination address | |
2940 <data>: command data | |
2941 <rplyCB>: reply call-back | |
2942 */ | |
2943 GLOBAL T_ACI_RETURN sAT_PlusCMGC_Gl ( T_ACI_CMD_SRC srcId, | |
2944 SHORT fo, | |
2945 SHORT ct, | |
2946 SHORT pid, | |
2947 SHORT mn, | |
2948 CHAR* da, | |
2949 T_ACI_TOA* toda, | |
2950 T_ACI_CMD_DATA* data, | |
2951 T_CMGC_FCT rplyCB ) | |
2952 { | |
2953 T_ACI_RETURN ret; /* AT response code */ | |
2954 UBYTE chkFo; /* checked parameter <fo> */ | |
2955 UBYTE chkPid; /* checked parameter <pid> */ | |
2956 UBYTE chkCt; /* checked parameter <ct> */ | |
2957 UBYTE chkMn; /* checked parameter <mn> */ | |
2958 CHAR* restDa = da; /* destination address without */ | |
2959 /* international access function */ | |
2960 /* characters */ | |
2961 T_tp_da da_addr; /* destination address */ | |
2962 | |
2963 TRACE_FUNCTION ("sAT_PlusCMGC_Gl ()"); | |
2964 | |
2965 /* | |
2966 *----------------------------------------------------------------- | |
2967 * check if command executable | |
2968 *----------------------------------------------------------------- | |
2969 */ | |
2970 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2971 return ret; | |
2972 | |
2973 smsShrdPrm.rplyCB.cmgc = rplyCB; | |
2974 /* | |
2975 *----------------------------------------------------------------- | |
2976 * process the <fo> parameter | |
2977 *----------------------------------------------------------------- | |
2978 */ | |
2979 if( fo NEQ ACI_NumParmNotPresent ) | |
2980 { | |
2981 if( fo > SMS_CMH_FO_MAX OR fo < SMS_CMH_FO_MIN OR | |
2982 ( fo & TP_MTI_MASK ) NEQ TP_MTI_SMS_COMMAND ) | |
2983 { | |
2984 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2985 return ( AT_FAIL ); | |
2986 } | |
2987 else | |
2988 | |
2989 chkFo = (UBYTE) fo; | |
2990 | |
2991 } | |
2992 else | |
2993 | |
2994 chkFo = TP_MTI_SMS_COMMAND; | |
2995 | |
2996 /* | |
2997 *----------------------------------------------------------------- | |
2998 * process the <ct> parameter | |
2999 *----------------------------------------------------------------- | |
3000 */ | |
3001 if( ct NEQ ACI_NumParmNotPresent ) | |
3002 { | |
3003 if( ct > SMS_CMH_CT_MAX OR ct < SMS_CMH_CT_MIN ) | |
3004 { | |
3005 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3006 return ( AT_FAIL ); | |
3007 } | |
3008 else | |
3009 | |
3010 chkCt = (UBYTE) ct; | |
3011 | |
3012 } | |
3013 else | |
3014 /* | |
3015 * set to default value | |
3016 */ | |
3017 chkCt = SMS_CT_ENQUIRY; | |
3018 | |
3019 /* | |
3020 *----------------------------------------------------------------- | |
3021 * process the <pid> parameter | |
3022 *----------------------------------------------------------------- | |
3023 */ | |
3024 if( pid NEQ ACI_NumParmNotPresent ) | |
3025 { | |
3026 if( pid > SMS_CMH_PID_MAX OR pid < SMS_CMH_PID_MIN ) | |
3027 { | |
3028 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3029 return ( AT_FAIL ); | |
3030 } | |
3031 else | |
3032 | |
3033 chkPid = (UBYTE) pid; | |
3034 } | |
3035 else | |
3036 | |
3037 /* | |
3038 * set to default value | |
3039 */ | |
3040 chkPid = SMS_PID_DEFAULT; | |
3041 | |
3042 /* | |
3043 *----------------------------------------------------------------- | |
3044 * process the <mn> parameter | |
3045 *----------------------------------------------------------------- | |
3046 */ | |
3047 if( mn NEQ ACI_NumParmNotPresent ) | |
3048 { | |
3049 if( mn > SMS_CMH_MN_MAX OR mn < SMS_CMH_MN_MIN ) | |
3050 { | |
3051 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3052 return ( AT_FAIL ); | |
3053 } | |
3054 else | |
3055 | |
3056 chkMn = (UBYTE) mn; | |
3057 } | |
3058 else | |
3059 { | |
3060 chkMn = smsShrdPrm.aci_sms_parameter.snd_msg_ref; | |
3061 } | |
3062 | |
3063 /* | |
3064 *--------------------------------------------------------------- | |
3065 * process the <da> and <toda> parameter | |
3066 *--------------------------------------------------------------- | |
3067 */ | |
3068 if ( toda NEQ NULL ) | |
3069 { | |
3070 if ( da NEQ NULL ) | |
3071 { | |
3072 da_addr.ton = toda -> ton; | |
3073 da_addr.npi = toda -> npi; | |
3074 cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, restDa); | |
3075 da_addr.digits = da_addr.c_num; | |
3076 } | |
3077 else | |
3078 { | |
3079 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3080 return ( AT_FAIL ); | |
3081 } | |
3082 } | |
3083 else | |
3084 { | |
3085 if ( da NEQ NULL ) | |
3086 { | |
3087 restDa = cmhSMS_setToaDef ( da, &da_addr.ton, &da_addr.npi ); | |
3088 cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, restDa); | |
3089 da_addr.digits = da_addr.c_num; | |
3090 } | |
3091 else | |
3092 { | |
3093 da_addr.digits = 0; | |
3094 } | |
3095 } | |
3096 | |
3097 /* | |
3098 *------------------------------------------------------------------- | |
3099 * create and send primitive for command request | |
3100 *------------------------------------------------------------------- | |
3101 */ | |
3102 { | |
3103 PALLOC (mnsms_command_req, MNSMS_COMMAND_REQ); | |
3104 | |
3105 ACI_MALLOC(smsShrdPrm.tpdu.tp_command, sizeof(T_TP_COMMAND)); | |
3106 cmhSMS_fillTpCommand( smsShrdPrm.tpdu.tp_command, | |
3107 chkFo, | |
3108 chkCt, | |
3109 0, | |
3110 chkPid, | |
3111 chkMn, | |
3112 &da_addr, | |
3113 data, | |
3114 NULL); | |
3115 | |
3116 #ifdef REL99 | |
3117 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
3118 { | |
3119 mnsms_command_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
3120 } | |
3121 else | |
3122 { | |
3123 mnsms_command_req -> auto_rep_flag = FALSE; | |
3124 } | |
3125 #endif | |
3126 | |
3127 /* code command here */ | |
3128 cmhSMS_codeMsg (&mnsms_command_req->sms_sdu, | |
3129 SMS_VT_COMMAND, | |
3130 &smsShrdPrm.pSetPrm[srcId]->sca, | |
3131 SMS_COMMAND, | |
3132 (UBYTE*)smsShrdPrm.tpdu.tp_command); | |
3133 | |
3134 PSENDX (SMS, mnsms_command_req); | |
3135 | |
3136 if (smsShrdPrm.tpdu.tp_command NEQ NULL) | |
3137 { | |
3138 ACI_MFREE(smsShrdPrm.tpdu.tp_command); | |
3139 smsShrdPrm.tpdu.tp_command = NULL; | |
3140 } | |
3141 } | |
3142 | |
3143 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGC; | |
3144 smsShrdPrm.owner = (T_OWN)srcId; | |
3145 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3146 | |
3147 return( AT_EXCT ); | |
3148 } | |
3149 | |
3150 | |
3151 #if defined (SMS_PDU_SUPPORT) || defined (SIM_TOOLKIT) | |
3152 | |
3153 /* | |
3154 +-------------------------------------------------------------------+ | |
3155 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3156 | STATE : code ROUTINE : sAT_PlusCMGCPdu | | |
3157 +-------------------------------------------------------------------+ | |
3158 | |
3159 PURPOSE : This is the functional counterpart of the +CMGC | |
3160 AT command which is responsible for sending a command | |
3161 message in pdu mode. | |
3162 | |
3163 */ | |
3164 GLOBAL T_ACI_RETURN sAT_PlusCMGCPdu ( T_ACI_CMD_SRC srcId, | |
3165 T_ACI_SM_DATA *pdu ) | |
3166 { | |
3167 T_ACI_RETURN ret; /* AT response code */ | |
3168 | |
3169 TRACE_FUNCTION ("sAT_PlusCMGCPdu ()"); | |
3170 | |
3171 /* | |
3172 *----------------------------------------------------------------- | |
3173 * check if command executable | |
3174 *----------------------------------------------------------------- | |
3175 */ | |
3176 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3177 return ret; | |
3178 | |
3179 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
3180 smsShrdPrm.rplyCB.cmgc = rAT_PlusCMGC; | |
3181 smsShrdPrm.errorCB = rAT_PlusCMS; | |
3182 #endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */ | |
3183 | |
3184 /* | |
3185 *------------------------------------------------------------------- | |
3186 * create and send primitive for SMS command | |
3187 *------------------------------------------------------------------- | |
3188 */ | |
3189 { | |
3190 PALLOC (mnsms_command_req, MNSMS_COMMAND_REQ); | |
3191 #ifdef REL99 | |
3192 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
3193 { | |
3194 mnsms_command_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
3195 } | |
3196 else | |
3197 { | |
3198 mnsms_command_req -> auto_rep_flag = FALSE; | |
3199 } | |
3200 #endif /* REL99 */ | |
3201 | |
3202 if ( pdu->len > 0 ) | |
3203 { | |
3204 mnsms_command_req->sms_sdu.l_buf = pdu->len * 8; | |
3205 mnsms_command_req->sms_sdu.o_buf = 0; | |
3206 memcpy (mnsms_command_req->sms_sdu.buf, pdu->data, pdu->len); | |
3207 } | |
3208 else | |
3209 { | |
3210 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3211 PFREE (mnsms_command_req); | |
3212 return ( AT_FAIL ); | |
3213 } | |
3214 | |
3215 PSENDX (SMS, mnsms_command_req); | |
3216 } | |
3217 | |
3218 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGC; | |
3219 smsShrdPrm.owner = (T_OWN)srcId; | |
3220 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3221 | |
3222 return( AT_EXCT ); | |
3223 } | |
3224 #endif | |
3225 | |
3226 | |
3227 /* | |
3228 +-------------------------------------------------------------------+ | |
3229 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3230 | STATE : code ROUTINE : sAT_PlusCMGR | | |
3231 +-------------------------------------------------------------------+ | |
3232 | |
3233 PURPOSE : This is the functional counterpart of the +CMGR | |
3234 AT command which is responsible for reading a short | |
3235 message from memory. | |
3236 | |
3237 Features Concatenated SMS. | |
3238 For GPF-MMI. | |
3239 | |
3240 <index>: storage area index | |
3241 <rdMode>: read mode | |
3242 */ | |
3243 #if (defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
3244 GLOBAL T_ACI_RETURN sAT_PlusCMGR ( T_ACI_CMD_SRC srcId, | |
3245 UBYTE index, | |
3246 T_ACI_SMS_READ rdMode ) | |
3247 { | |
3248 T_CONC_INIT_RETURN ret; | |
3249 | |
3250 TRACE_FUNCTION ("sAT_PlusCMGR ()"); | |
3251 | |
3252 TRACE_EVENT_P1("sAT_PlusCMGR () index: %d", index); | |
3253 | |
3254 ret=concSMS_initReadFromMem(srcId, index, rdMode); | |
3255 | |
3256 if (ret EQ CONC_NEEDED) | |
3257 { | |
3258 SET_CONC; | |
3259 TRACE_EVENT("sAT_PlusCMGR: CONC_NEEDED"); | |
3260 | |
3261 /* memorize mem1, this is for rConcSMS_PlusCMGR */ | |
3262 concShrdPrm.mem_store = smsShrdPrm.mem1; | |
3263 | |
3264 return sAT_PlusCMGR_Gl(srcId, index, rdMode, rConcSMS_PlusCMGR); | |
3265 } | |
3266 else if (ret EQ CONC_NOT_NEEDED) | |
3267 { | |
3268 TRACE_EVENT("sAT_PlusCMGR: CONC_NOT_NEEDED"); | |
3269 return sAT_PlusCMGR_Gl(srcId, index, rdMode, rAT_PlusCMGR); | |
3270 } | |
3271 else | |
3272 { | |
3273 TRACE_EVENT("ERROR: sAT_PlusCMGR: CMS_ERR_InValMemIdx"); | |
3274 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
3275 return ( AT_FAIL ); | |
3276 } | |
3277 } | |
3278 #endif /*#if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)*/ | |
3279 | |
3280 /* | |
3281 +-------------------------------------------------------------------+ | |
3282 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3283 | STATE : code ROUTINE : sAT_PlusCMGR | | |
3284 +-------------------------------------------------------------------+ | |
3285 | |
3286 PURPOSE : New Plus CMGR command for handling the conc module on | |
3287 the Riv-MMI side. | |
3288 */ | |
3289 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
3290 GLOBAL T_ACI_RETURN sAT_PlusCMGR ( T_ACI_CMD_SRC srcId, | |
3291 UBYTE index, | |
3292 T_ACI_SMS_READ rdMode ) | |
3293 { | |
3294 TRACE_FUNCTION ("sAT_PlusCMGR ()"); | |
3295 | |
3296 TRACE_EVENT_P1("sAT_PlusCMGR () index: %d", index); | |
3297 | |
3298 return sAT_PlusCMGR_Gl(srcId, index, rdMode, rAT_PlusCMGR); | |
3299 } | |
3300 #endif /*#if defined (FF_MMI_RIV)*/ | |
3301 | |
3302 | |
3303 /* | |
3304 +-------------------------------------------------------------------+ | |
3305 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3306 | STATE : code ROUTINE : sAT_PlusCMGR_Gl | | |
3307 +-------------------------------------------------------------------+ | |
3308 | |
3309 PURPOSE : This is the functional counterpart of the +CMGR | |
3310 AT command which is responsible for reading a short | |
3311 message from memory. | |
3312 | |
3313 <index>: storage area index | |
3314 <rdMode>: read mode | |
3315 <rplyCB>: reply call-back | |
3316 <errorCB>: error call-back | |
3317 */ | |
3318 GLOBAL T_ACI_RETURN sAT_PlusCMGR_Gl ( T_ACI_CMD_SRC srcId, | |
3319 UBYTE index, | |
3320 T_ACI_SMS_READ rdMode, | |
3321 T_CMGR_FCT rplyCB ) | |
3322 { | |
3323 T_ACI_RETURN ret = AT_EXCT; | |
3324 | |
3325 TRACE_FUNCTION ("sAT_PlusCMGR_Gl ()"); | |
3326 | |
3327 /* | |
3328 *----------------------------------------------------------------- | |
3329 * check if command executable | |
3330 *----------------------------------------------------------------- | |
3331 */ | |
3332 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3333 { | |
3334 return ret; | |
3335 } | |
3336 | |
3337 smsShrdPrm.rplyCB.cmgr = rplyCB; | |
3338 | |
3339 | |
3340 /* | |
3341 *----------------------------------------------------------------- | |
3342 * process the <index> parameter | |
3343 *----------------------------------------------------------------- | |
3344 */ | |
3345 switch (rdMode) | |
3346 { | |
3347 case SMS_READ_StatusChange: | |
3348 /* ret = AT_CMPL; Change to AT_EXCT, call back expected */ | |
3349 smsShrdPrm.rdMode = READ_STATUS_CHANGE; | |
3350 break; | |
3351 case SMS_READ_Preview: | |
3352 smsShrdPrm.rdMode = READ_PREVIEW; | |
3353 break; | |
3354 case SMS_READ_Normal: | |
3355 case SMS_READ_NotPresent: | |
3356 smsShrdPrm.rdMode = READ_NORMAL; | |
3357 break; | |
3358 default: | |
3359 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3360 return ( AT_FAIL ); | |
3361 } | |
3362 /* | |
3363 *----------------------------------------------------------------- | |
3364 * read a short message from memory | |
3365 *----------------------------------------------------------------- | |
3366 */ | |
3367 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGR; | |
3368 smsShrdPrm.owner = (T_OWN)srcId; | |
3369 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3370 | |
3371 psaSMS_ReadReq ( smsShrdPrm.mem1, index, | |
3372 smsShrdPrm.rdMode, SMS_STAT_NotPresent); | |
3373 | |
3374 return( ret ); | |
3375 } | |
3376 | |
3377 /* | |
3378 +-------------------------------------------------------------------+ | |
3379 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3380 | STATE : code ROUTINE : sAT_PlusCSCB | | |
3381 +-------------------------------------------------------------------+ | |
3382 | |
3383 PURPOSE : This is the functional counterpart of the +CSCB | |
3384 AT command which is responsible for selecting the | |
3385 cell broadcast message types. | |
3386 | |
3387 <mode>: acception mode | |
3388 <mids>: message identifiers | |
3389 <dcss>: data coding schemes | |
3390 */ | |
3391 GLOBAL T_ACI_RETURN sAT_PlusCSCB ( T_ACI_CMD_SRC srcId, | |
3392 T_ACI_CSCB_MOD mode, | |
3393 USHORT* mids, | |
3394 UBYTE* dcss) | |
3395 { | |
3396 UBYTE chkMode; /* checked parameter <mode> */ | |
3397 USHORT chkMids[MAX_IDENTS]; /* checked parameter <mids> */ | |
3398 UBYTE chkDcss[MAX_IDENTS]; /* checked parameter <dcss> */ | |
3399 int i; /* used for counting */ | |
3400 | |
3401 TRACE_FUNCTION ("sAT_PlusCSCB ()"); | |
3402 | |
3403 /* | |
3404 *----------------------------------------------------------------- | |
3405 * check command source | |
3406 *----------------------------------------------------------------- | |
3407 */ | |
3408 if(!cmh_IsVldCmdSrc (srcId)) | |
3409 { | |
3410 return( AT_FAIL ); | |
3411 } | |
3412 | |
3413 /* | |
3414 *----------------------------------------------------------------- | |
3415 * check access status | |
3416 *----------------------------------------------------------------- | |
3417 */ | |
3418 if (!cmhSMS_checkSIM ()) /* sets error code */ | |
3419 { | |
3420 return( AT_FAIL ); | |
3421 } | |
3422 | |
3423 /* | |
3424 *----------------------------------------------------------------- | |
3425 * check entity status | |
3426 *----------------------------------------------------------------- | |
3427 */ | |
3428 if( smsShrdPrm.cbmPrm.cbchOwner NEQ ((T_OWN)CMD_SRC_NONE) ) | |
3429 { | |
3430 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3431 return( AT_BUSY ); | |
3432 } | |
3433 | |
3434 /* | |
3435 *----------------------------------------------------------------- | |
3436 * process the <mode> parameter | |
3437 *----------------------------------------------------------------- | |
3438 */ | |
3439 switch ( mode ) | |
3440 { | |
3441 case (CSCB_MOD_NotPresent): chkMode = smsShrdPrm.cbmPrm.cbmMode; break; | |
3442 case (CSCB_MOD_Accept ): chkMode = CBCH_ACCEPT; break; | |
3443 case (CSCB_MOD_NotAccept ): chkMode = CBCH_IGNORE; break; | |
3444 | |
3445 default: | |
3446 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3447 return ( AT_FAIL ); | |
3448 } | |
3449 | |
3450 /* | |
3451 *----------------------------------------------------------------- | |
3452 * process the <mids> parameter | |
3453 *----------------------------------------------------------------- | |
3454 */ | |
3455 if( mids NEQ NULL ) | |
3456 | |
3457 memcpy ( ( CHAR * ) chkMids, ( CHAR * ) mids, sizeof (chkMids) ); | |
3458 | |
3459 else | |
3460 | |
3461 memcpy ( ( CHAR * ) chkMids, ( CHAR * ) smsShrdPrm.cbmPrm.msgId, | |
3462 sizeof ( chkMids ) ); | |
3463 | |
3464 /* | |
3465 *----------------------------------------------------------------- | |
3466 * process the <dcss> parameter | |
3467 *----------------------------------------------------------------- | |
3468 */ | |
3469 if( dcss NEQ NULL ) | |
3470 { | |
3471 i = 0; | |
3472 | |
3473 while ( i < MAX_IDENTS AND dcss[i] NEQ DEF_DCS_RANGE ) | |
3474 { | |
3475 /* Lint: this cannot happen | |
3476 if( dcss[i] > SMS_CMH_DCS_MAX OR dcss[i] < SMS_CMH_DCS_MIN ) | |
3477 { | |
3478 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3479 return ( AT_FAIL ); | |
3480 } | |
3481 else | |
3482 */ | |
3483 i++; | |
3484 } | |
3485 | |
3486 if ( i % 2 NEQ 0 ) | |
3487 { | |
3488 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3489 return ( AT_FAIL ); | |
3490 } | |
3491 | |
3492 memcpy ( ( CHAR * ) chkDcss, ( CHAR * ) dcss, sizeof (chkDcss) ); | |
3493 } | |
3494 else | |
3495 | |
3496 memcpy ( ( CHAR * ) chkDcss, ( CHAR * ) smsShrdPrm.cbmPrm.dcsId, | |
3497 sizeof ( chkDcss ) ); | |
3498 | |
3499 /* | |
3500 *----------------------------------------------------------------- | |
3501 * copy parameter | |
3502 *----------------------------------------------------------------- | |
3503 */ | |
3504 memcpy ( ( CHAR * ) smsShrdPrm.cbmPrm.msgId, | |
3505 ( CHAR * ) chkMids, | |
3506 sizeof ( smsShrdPrm.cbmPrm.msgId ) ); | |
3507 | |
3508 memcpy ( ( CHAR * ) smsShrdPrm.cbmPrm.dcsId, | |
3509 ( CHAR * ) chkDcss, | |
3510 sizeof ( smsShrdPrm.cbmPrm.dcsId ) ); | |
3511 | |
3512 smsShrdPrm.cbmPrm.cbmMode = chkMode; | |
3513 | |
3514 /* CSCBmode = mode; */ | |
3515 | |
3516 /* | |
3517 *----------------------------------------------------------------- | |
3518 * set the new CBCH configuration | |
3519 *----------------------------------------------------------------- | |
3520 */ | |
3521 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
3522 | |
3523 if( psaMMI_Cbch() < 0 ) | |
3524 { | |
3525 TRACE_EVENT( "FATAL RETURN psaSMS in +CSCB" ); | |
3526 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3527 return( AT_FAIL ); | |
3528 } | |
3529 | |
3530 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
3531 | |
3532 return ( AT_CMPL ); | |
3533 } | |
3534 | |
3535 | |
3536 #ifdef FF_HOMEZONE | |
3537 /* | |
3538 +-------------------------------------------------------------------+ | |
3539 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3540 | STATE : code ROUTINE : sAT_PercentCBHZ | | |
3541 +-------------------------------------------------------------------+ | |
3542 | |
3543 PURPOSE : This is the functional counterpart of the %CBHZ | |
3544 AT command which is responsible for activation and | |
3545 deactivation of the homezone feature. | |
3546 | |
3547 <mode> : activation mode | |
3548 <dcs> : datacoding scheme | |
3549 <timeout>: timeout period for homezone CBM | |
3550 */ | |
3551 GLOBAL T_ACI_RETURN sAT_PercentCBHZ ( T_ACI_CMD_SRC srcId, | |
3552 T_ACI_CBHZ_MOD mode, | |
3553 T_ACI_CS dcs, | |
3554 UBYTE timeout) | |
3555 { | |
3556 UBYTE chkMode; /* checked parameter <mode> */ | |
3557 UBYTE chkDcs; /* checked parameter <dcs> */ | |
3558 UBYTE chkTimeout; /* checked parameter <timeout> */ | |
3559 | |
3560 TRACE_FUNCTION ("sAT_PercentCBHZ()"); | |
3561 | |
3562 /* | |
3563 *----------------------------------------------------------------- | |
3564 * check command source | |
3565 *----------------------------------------------------------------- | |
3566 */ | |
3567 if(!cmh_IsVldCmdSrc (srcId)) | |
3568 { | |
3569 return( AT_FAIL ); | |
3570 } | |
3571 | |
3572 /* | |
3573 *----------------------------------------------------------------- | |
3574 * check access status | |
3575 *----------------------------------------------------------------- | |
3576 */ | |
3577 if (!cmhSMS_checkSIM ()) /* sets error code */ | |
3578 { | |
3579 return( AT_FAIL ); | |
3580 } | |
3581 | |
3582 /* | |
3583 *----------------------------------------------------------------- | |
3584 * check entity status | |
3585 *----------------------------------------------------------------- | |
3586 */ | |
3587 if( smsShrdPrm.cbmPrm.cbchOwner NEQ ((T_OWN)CMD_SRC_NONE) ) | |
3588 { | |
3589 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3590 return( AT_BUSY ); | |
3591 } | |
3592 | |
3593 /* | |
3594 *----------------------------------------------------------------- | |
3595 * process the <mode> parameter | |
3596 *----------------------------------------------------------------- | |
3597 */ | |
3598 switch ( mode ) | |
3599 { | |
3600 case (CBHZ_MOD_Active) : | |
3601 case (CBHZ_MOD_NotActive): | |
3602 chkMode = mode; | |
3603 break; | |
3604 | |
3605 default: | |
3606 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3607 return ( AT_FAIL ); | |
3608 } | |
3609 | |
3610 /* | |
3611 *----------------------------------------------------------------- | |
3612 * process the <dcs> parameter | |
3613 *----------------------------------------------------------------- | |
3614 */ | |
3615 switch ( dcs ) | |
3616 { | |
3617 case (CS_NotPresent): | |
3618 chkDcs = CS_GsmDef; | |
3619 break; | |
3620 | |
3621 case (CS_GsmDef) : | |
3622 case (CS_GsmInt) : | |
3623 case (CS_Hex) : | |
3624 case (CS_Ucs2) : | |
3625 case (CS_Sim) : | |
3626 case (CS_Ascii) : | |
3627 chkDcs = dcs; | |
3628 break; | |
3629 | |
3630 default: | |
3631 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3632 return ( AT_FAIL ); | |
3633 } | |
3634 | |
3635 /* | |
3636 *----------------------------------------------------------------- | |
3637 * process the <timeout> parameter | |
3638 *----------------------------------------------------------------- | |
3639 */ | |
3640 if ( (timeout >= CBHZ_MIN_TIMEOUT) AND (timeout <= CBHZ_MAX_TIMEOUT) ) | |
3641 { | |
3642 chkTimeout = timeout; | |
3643 } | |
3644 else if ( timeout EQ NOT_PRESENT_8BIT ) | |
3645 { | |
3646 chkTimeout = CBHZ_DEF_TIMEOUT; | |
3647 } | |
3648 else | |
3649 { | |
3650 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3651 return ( AT_FAIL ); | |
3652 } | |
3653 | |
3654 /* | |
3655 *----------------------------------------------------------------- | |
3656 * all parameters valid. now copy parameter | |
3657 *----------------------------------------------------------------- | |
3658 */ | |
3659 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
3660 smsShrdPrm.cbmPrm.hzMode = chkMode; | |
3661 smsShrdPrm.cbmPrm.hzDcs = chkDcs; | |
3662 smsShrdPrm.cbmPrm.hzTimeout = chkTimeout; | |
3663 | |
3664 /* send homezone request */ | |
3665 if( psaMMI_homezone_req() < 0 ) | |
3666 { | |
3667 TRACE_EVENT( "FATAL RETURN psaSMS in %%CBHZ" ); | |
3668 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3669 return( AT_FAIL ); | |
3670 } | |
3671 | |
3672 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
3673 | |
3674 return ( AT_CMPL ); | |
3675 } | |
3676 #endif /* FF_HOMEZONE */ | |
3677 | |
3678 /* | |
3679 +-------------------------------------------------------------------+ | |
3680 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3681 | STATE : code ROUTINE : sAT_PlusCMGL | | |
3682 +-------------------------------------------------------------------+ | |
3683 | |
3684 PURPOSE : This is the functional counterpart of the +CMGL | |
3685 AT command which is responsible for creating a list of | |
3686 all stored short messages. | |
3687 | |
3688 <state>: state of stored short message | |
3689 */ | |
3690 GLOBAL T_ACI_RETURN sAT_PlusCMGL ( T_ACI_CMD_SRC srcId, | |
3691 T_ACI_SMS_STAT state, | |
3692 SHORT startIdx, | |
3693 T_ACI_SMS_READ rdMode ) | |
3694 { | |
3695 T_ACI_RETURN ret; /* AT response code */ | |
3696 T_ACI_SMS_STAT chk_state; | |
3697 | |
3698 TRACE_FUNCTION ("sAT_PlusCMGL ()"); | |
3699 | |
3700 /* | |
3701 *----------------------------------------------------------------- | |
3702 * check if command executable | |
3703 *----------------------------------------------------------------- | |
3704 */ | |
3705 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3706 { | |
3707 return ret; | |
3708 } | |
3709 | |
3710 /* | |
3711 *----------------------------------------------------------------- | |
3712 * process the <state> parameter | |
3713 *----------------------------------------------------------------- | |
3714 */ | |
3715 switch ( state ) | |
3716 { | |
3717 case( SMS_STAT_NotPresent ): | |
3718 chk_state = SMS_STAT_RecUnread; | |
3719 break; | |
3720 | |
3721 case( SMS_STAT_Invalid ): | |
3722 case( SMS_STAT_All ): | |
3723 case( SMS_STAT_RecUnread ): | |
3724 case( SMS_STAT_RecRead ): | |
3725 case( SMS_STAT_StoUnsent ): | |
3726 case( SMS_STAT_StoSent ): | |
3727 chk_state = state; | |
3728 break; | |
3729 | |
3730 default: | |
3731 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3732 return ( AT_FAIL ); | |
3733 } | |
3734 | |
3735 /* | |
3736 *----------------------------------------------------------------- | |
3737 * check if startIdx is in range | |
3738 *----------------------------------------------------------------- | |
3739 */ | |
3740 if ( startIdx >= MAX_SIM_ME_ENTRIES /*256*/ OR | |
3741 startIdx > SMS_CMH_MAX_START_IDX /*255*/ ) | |
3742 { | |
3743 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3744 return ( AT_FAIL ); | |
3745 } | |
3746 | |
3747 /* | |
3748 *----------------------------------------------------------------- | |
3749 * process the <rdMode> parameter | |
3750 *----------------------------------------------------------------- | |
3751 */ | |
3752 switch (rdMode) | |
3753 { | |
3754 case SMS_READ_StatusChange: | |
3755 default: | |
3756 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3757 return ( AT_FAIL ); | |
3758 case SMS_READ_Preview: | |
3759 smsShrdPrm.rdMode = READ_PREVIEW; | |
3760 break; | |
3761 case SMS_READ_Normal: | |
3762 case SMS_READ_NotPresent: | |
3763 smsShrdPrm.rdMode = READ_NORMAL; | |
3764 break; | |
3765 } | |
3766 | |
3767 /* | |
3768 *--------------------------------------------------------------- | |
3769 * PSA notification | |
3770 *--------------------------------------------------------------- | |
3771 */ | |
3772 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGL; | |
3773 smsShrdPrm.owner = (T_OWN)srcId; | |
3774 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3775 | |
3776 /* | |
3777 *--------------------------------------------------------------- | |
3778 * request the list element | |
3779 *--------------------------------------------------------------- | |
3780 */ | |
3781 psaSMS_ReadReq ( smsShrdPrm.mem1, startIdx, | |
3782 smsShrdPrm.rdMode, chk_state ); | |
3783 | |
3784 return( AT_EXCT ); | |
3785 } | |
3786 | |
3787 /* | |
3788 +-------------------------------------------------------------------+ | |
3789 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3790 | STATE : code ROUTINE : sAT_PlusCSAS | | |
3791 +-------------------------------------------------------------------+ | |
3792 | |
3793 PURPOSE : This is the functional counterpart of the +CSAS | |
3794 AT command which is responsible for saving of certain | |
3795 SMS parameters to nonvolatile memory. | |
3796 | |
3797 <profile>: SMS profile number (1..max_record) | |
3798 */ | |
3799 GLOBAL T_ACI_RETURN sAT_PlusCSAS ( T_ACI_CMD_SRC srcId, | |
3800 SHORT profile) | |
3801 { | |
3802 T_ACI_RETURN ret; /* AT response code */ | |
3803 UBYTE tmpNumOfRefs; | |
3804 UBYTE max_record; | |
3805 | |
3806 TRACE_FUNCTION ("sAT_PlusCSAS ()"); | |
3807 | |
3808 /* | |
3809 *----------------------------------------------------------------- | |
3810 * check if command executable | |
3811 *----------------------------------------------------------------- | |
3812 */ | |
3813 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3814 return ret; | |
3815 | |
3816 max_record = (UBYTE)cmhSMS_getPrfRge (); | |
3817 if ((profile <= 0) OR (profile > max_record)) | |
3818 { | |
3819 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
3820 return AT_FAIL; | |
3821 } | |
3822 | |
3823 smsShrdPrm.cbmPrm.cbmFoundIds = 0; | |
3824 | |
3825 if ( (smsShrdPrm.pSetPrm[srcId]->prflId NEQ profile) OR | |
3826 (smsShrdPrm.pSetPrm[srcId]->isCopy EQ TRUE) ) | |
3827 { | |
3828 T_SMS_SET_PRM * elem; | |
3829 T_SMS_SET_PRM * pSMSSetPrmOld = smsShrdPrm.pSetPrm[srcId]; | |
3830 | |
3831 /* | |
3832 *----------------------------------------------------------------- | |
3833 * find or create new profile | |
3834 *----------------------------------------------------------------- | |
3835 */ | |
3836 elem = find_element(set_prm_list, (UBYTE)profile, cmhSMS_findPrflId); | |
3837 if (elem EQ NULL) | |
3838 { | |
3839 ACI_MALLOC(elem, sizeof(T_SMS_SET_PRM)); | |
3840 memset(elem, 0, sizeof(T_SMS_SET_PRM)); | |
3841 insert_list(set_prm_list, elem); | |
3842 } | |
3843 | |
3844 /* save the number of references of the list element */ | |
3845 tmpNumOfRefs = elem->numOfRefs; | |
3846 | |
3847 /* copy the old profile */ | |
3848 memcpy(elem, pSMSSetPrmOld, sizeof(T_SMS_SET_PRM)); | |
3849 | |
3850 /* decrease the numOfRefs of the old profile */ | |
3851 pSMSSetPrmOld->numOfRefs--; | |
3852 | |
3853 /* set the Prm Pointer to the (new or found) list element */ | |
3854 smsShrdPrm.pSetPrm[srcId] = elem; | |
3855 | |
3856 smsShrdPrm.pSetPrm[srcId]->numOfRefs = ++tmpNumOfRefs; | |
3857 smsShrdPrm.pSetPrm[srcId]->isCopy = FALSE; | |
3858 smsShrdPrm.pSetPrm[srcId]->prflId = (UBYTE)profile; | |
3859 | |
3860 /* | |
3861 *----------------------------------------------------------------- | |
3862 * destroy temporary copy | |
3863 *----------------------------------------------------------------- | |
3864 */ | |
3865 if ( pSMSSetPrmOld->isCopy EQ TRUE ) | |
3866 { | |
3867 ACI_MFREE(pSMSSetPrmOld); | |
3868 } | |
3869 } | |
3870 | |
3871 /* | |
3872 *------------------------------------------------------------- | |
3873 * store parameters to non-volatile memory | |
3874 *------------------------------------------------------------- | |
3875 */ | |
3876 ret = cmhSMS_WriteParams (srcId, AT_CMD_CSAS, profile); | |
3877 return ret; | |
3878 | |
3879 } | |
3880 | |
3881 /* | |
3882 +-------------------------------------------------------------------+ | |
3883 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3884 | STATE : code ROUTINE : sAT_PlusCRES | | |
3885 +-------------------------------------------------------------------+ | |
3886 | |
3887 PURPOSE : This is the functional counterpart of the +CRES | |
3888 AT command which is responsible for retrieving of | |
3889 certain SMS parameters from nonvolatile memory. | |
3890 | |
3891 <profile>: SMS profile number (1..max_record) | |
3892 */ | |
3893 GLOBAL T_ACI_RETURN sAT_PlusCRES ( T_ACI_CMD_SRC srcId, | |
3894 SHORT profile) | |
3895 { | |
3896 T_ACI_RETURN ret=AT_CMPL; /* AT response code */ | |
3897 UBYTE max_record; | |
3898 | |
3899 TRACE_FUNCTION ("sAT_PlusCRES ()"); | |
3900 | |
3901 /* | |
3902 *----------------------------------------------------------------- | |
3903 * check if command executable | |
3904 *----------------------------------------------------------------- | |
3905 */ | |
3906 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3907 return ret; | |
3908 | |
3909 max_record = (UBYTE)cmhSMS_getPrfRge (); | |
3910 if ((profile <= 0) OR (profile > max_record)) | |
3911 { | |
3912 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
3913 return AT_FAIL; | |
3914 } | |
3915 | |
3916 smsShrdPrm.cbmPrm.cbmFoundIds = 0; | |
3917 | |
3918 if ( (smsShrdPrm.pSetPrm[srcId]->prflId NEQ profile) OR | |
3919 (smsShrdPrm.pSetPrm[srcId]->isCopy EQ TRUE) ) | |
3920 { | |
3921 T_SMS_SET_PRM * pSMSSetPrmOld; /* points to SMS parameter set */ | |
3922 T_SMS_SET_PRM * pSMSSetPrmNew; /* points to SMS parameter set */ | |
3923 | |
3924 pSMSSetPrmOld = smsShrdPrm.pSetPrm[srcId]; | |
3925 pSMSSetPrmOld->numOfRefs--; | |
3926 | |
3927 /* | |
3928 *----------------------------------------------------------------- | |
3929 * destroy temporary copy | |
3930 *----------------------------------------------------------------- | |
3931 */ | |
3932 if ( pSMSSetPrmOld->isCopy EQ TRUE) | |
3933 { | |
3934 ACI_MFREE(pSMSSetPrmOld); | |
3935 } | |
3936 | |
3937 /* | |
3938 *------------------------------------------------------------- | |
3939 * find the new profile in the SET PRM list | |
3940 *------------------------------------------------------------- | |
3941 */ | |
3942 pSMSSetPrmNew = find_element(set_prm_list, (UBYTE)profile, cmhSMS_findPrflId); | |
3943 if (pSMSSetPrmNew NEQ NULL) /* element was in SET PRM List */ | |
3944 { | |
3945 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmNew; | |
3946 smsShrdPrm.pSetPrm[srcId]->numOfRefs++; | |
3947 } | |
3948 else /* element was not found in SET PRM List */ | |
3949 { | |
3950 ACI_MALLOC(pSMSSetPrmNew, sizeof(T_SMS_SET_PRM)); | |
3951 memset(pSMSSetPrmNew, 0, sizeof(T_SMS_SET_PRM)); | |
3952 insert_list(set_prm_list, pSMSSetPrmNew); | |
3953 pSMSSetPrmNew->prflId = (UBYTE)profile; | |
3954 | |
3955 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmNew; | |
3956 } | |
3957 } | |
3958 | |
3959 /* | |
3960 *------------------------------------------------------------- | |
3961 * read parameters from non-volatile memory | |
3962 *------------------------------------------------------------- | |
3963 */ | |
3964 ret = cmhSMS_ReadParams (srcId, AT_CMD_CRES, profile); | |
3965 return ret; | |
3966 | |
3967 } | |
3968 | |
3969 | |
3970 | |
3971 /* | |
3972 +-------------------------------------------------------------------+ | |
3973 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3974 | STATE : code ROUTINE : tAT_PlusCRES | | |
3975 +-------------------------------------------------------------------+ | |
3976 | |
3977 PURPOSE : This is the functional counterpart of the +CRES | |
3978 AT command which is responsible for retrieving of | |
3979 certain SMS parameters from nonvolatile memory. | |
3980 | |
3981 Shen,Chao July 1st, 2003 | |
3982 | |
3983 */ | |
3984 GLOBAL T_ACI_RETURN tAT_PlusCRES ( T_ACI_CMD_SRC srcId, T_ACI_CRES *values) | |
3985 { | |
3986 SHORT profile = -1; | |
3987 if ((profile = cmhSMS_getPrfRge ()) < 1) | |
3988 { | |
3989 return (AT_FAIL); | |
3990 } | |
3991 | |
3992 values->min = 0; | |
3993 values->max = profile - 1; | |
3994 | |
3995 return AT_CMPL; | |
3996 } | |
3997 | |
3998 #ifdef TI_PS_FF_AT_P_CMD_CPRSM | |
3999 /* | |
4000 +-------------------------------------------------------------------+ | |
4001 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4002 | STATE : code ROUTINE : sAT_PercentCPRSM | | |
4003 +-------------------------------------------------------------------+ | |
4004 | |
4005 PURPOSE : This is the functional counterpart of the %CPRSM | |
4006 AT command which is responsible for setting the receiving | |
4007 of SMS to pause or resume. | |
4008 [MDF: 07.04.2004] | |
4009 */ | |
4010 GLOBAL T_ACI_RETURN sAT_PercentCPRSM ( T_ACI_CMD_SRC srcId, | |
4011 T_ACI_CPRSM_MOD mode) | |
4012 { | |
4013 T_ACI_RETURN ret; | |
4014 | |
4015 TRACE_FUNCTION("sAT_PercentCPRSM()"); | |
4016 | |
4017 /* check whether SMS is currently accessible */ | |
4018 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4019 return ret; | |
4020 | |
4021 /* check mode and inform SMS entity */ | |
4022 switch ( mode ) | |
4023 { | |
4024 case CPRSM_MOD_Pause: | |
4025 /* send pause request to SMS */ | |
4026 psaSMS_PauseReq(); | |
4027 /* command complete */ | |
4028 ret = AT_CMPL; | |
4029 break; | |
4030 case CPRSM_MOD_Resume: | |
4031 /* store paramters for current command */ | |
4032 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CPRSM; | |
4033 smsShrdPrm.owner = (T_OWN)srcId; | |
4034 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4035 /* send resume request to SMS */ | |
4036 psaSMS_ResumeReq(); | |
4037 ret = AT_EXCT; | |
4038 break; | |
4039 default: | |
4040 TRACE_EVENT_P1("sAT_PercentCPRSM ERROR: mode %d not supported", mode); | |
4041 ret = AT_FAIL; | |
4042 } | |
4043 return ret; | |
4044 } | |
4045 | |
4046 /* | |
4047 +-------------------------------------------------------------------+ | |
4048 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4049 | STATE : code ROUTINE : qAT_PercentCPRSM | | |
4050 +-------------------------------------------------------------------+ | |
4051 | |
4052 PURPOSE : This is the functional counterpart of the %CPRSM | |
4053 AT command which is responsible for quering the status | |
4054 of receiving of SMS. It might be resume or pause. | |
4055 [MDF: 15.04.2004] | |
4056 */ | |
4057 GLOBAL T_ACI_RETURN qAT_PercentCPRSM ( T_ACI_CMD_SRC srcId ) | |
4058 { | |
4059 T_ACI_RETURN ret = AT_EXCT; | |
4060 | |
4061 TRACE_FUNCTION("qAT_PercentCPRSM()"); | |
4062 | |
4063 /* check whether SMS is currently accessible */ | |
4064 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4065 return ret; | |
4066 | |
4067 /* store paramters for current command */ | |
4068 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CPRSM; | |
4069 smsShrdPrm.owner = (T_OWN)srcId; | |
4070 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4071 | |
4072 /* add parameter for signaling which parameter has been requested */ | |
4073 psaSMS_QueryReq (SMS_QUERY_DELIVER_STATUS); | |
4074 | |
4075 return ret; | |
4076 } | |
4077 #endif /* TI_PS_FF_AT_P_CMD_CPRSM */ | |
4078 /* | |
4079 +-------------------------------------------------------------------+ | |
4080 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4081 | STATE : code ROUTINE : sAT_PlusCMMS | | |
4082 +-------------------------------------------------------------------+ | |
4083 | |
4084 PURPOSE : This is the functional counterpart of the +CMMS | |
4085 AT command which is responsible for setting the | |
4086 mode. | |
4087 | |
4088 <mode>: command mode | |
4089 */ | |
4090 GLOBAL T_ACI_RETURN sAT_PlusCMMS ( T_ACI_CMD_SRC srcId, | |
4091 UBYTE mode ) | |
4092 { | |
4093 T_ACI_RETURN ret = AT_FAIL; | |
4094 | |
4095 TRACE_FUNCTION ("sAT_PlusCMMS ()"); | |
4096 | |
4097 /* | |
4098 *----------------------------------------------------------------- | |
4099 * check source id and if command executable | |
4100 *----------------------------------------------------------------- | |
4101 */ | |
4102 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4103 return ret; | |
4104 | |
4105 smsShrdPrm.CMMSmode = mode; | |
4106 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMMS; | |
4107 | |
4108 /* Implements measure 147,148, 149 */ | |
4109 cmhSMS_sendConfigureReq(TRUE); | |
4110 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
4111 | |
4112 return( AT_CMPL ); | |
4113 } | |
4114 | |
4115 /* | |
4116 +-------------------------------------------------------------------+ | |
4117 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4118 | STATE : code ROUTINE : sAT_PercentCMGMDU | | |
4119 +-------------------------------------------------------------------+ | |
4120 | |
4121 PURPOSE : Function is used to reset the reply path | |
4122 | |
4123 <index>: Index of the record | |
4124 */ | |
4125 | |
4126 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
4127 GLOBAL T_ACI_RETURN sAT_PercentCMGMDU ( T_ACI_CMD_SRC srcId, | |
4128 UBYTE index ) | |
4129 { | |
4130 T_CONC_INIT_RETURN ret; | |
4131 | |
4132 TRACE_FUNCTION ("sAT_PercentCMGMDU ()"); | |
4133 | |
4134 TRACE_EVENT_P1("sAT_PercentCMGMDU () index: %d", index); | |
4135 | |
4136 ret=concSMS_initReadFromMem(srcId, index, SMS_READ_Normal); | |
4137 | |
4138 if (ret EQ CONC_NEEDED) | |
4139 { | |
4140 SET_CONC; | |
4141 TRACE_EVENT("sAT_PercentCMGMDU: CONC_NEEDED"); | |
4142 return sAT_PercentCMGMDU_Gl(srcId, index, rConcSMS_PercentCMGMDU); | |
4143 } | |
4144 else if (ret EQ CONC_NOT_NEEDED) | |
4145 { | |
4146 TRACE_EVENT("sAT_PercentCMGMDU: CONC_NOT_NEEDED"); | |
4147 return sAT_PercentCMGMDU_Gl(srcId, index, NULL); | |
4148 } | |
4149 else | |
4150 { | |
4151 TRACE_EVENT("ERROR: sAT_PercentCMGMDU: CMS_ERR_InValMemIdx"); | |
4152 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
4153 return ( AT_FAIL ); | |
4154 } | |
4155 } | |
4156 #endif /* #if (defined (MFW) OR defined (_CONC_TESTING_) */ | |
4157 | |
4158 /* | |
4159 +-------------------------------------------------------------------+ | |
4160 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4161 | STATE : code ROUTINE : sAT_PercentCMGMDU | | |
4162 +-------------------------------------------------------------------+ | |
4163 | |
4164 PURPOSE : For Riv-MMI. | |
4165 */ | |
4166 #if defined (FF_MMI_RIV) OR !defined TI_PS_FF_CONC_SMS | |
4167 GLOBAL T_ACI_RETURN sAT_PercentCMGMDU ( T_ACI_CMD_SRC srcId, | |
4168 UBYTE index ) | |
4169 { | |
4170 TRACE_FUNCTION ("sAT_PercentCMGMDU ()"); | |
4171 TRACE_EVENT_P1("sAT_PercentCMGMDU () index: %d", index); | |
4172 | |
4173 return sAT_PercentCMGMDU_Gl(srcId, index, NULL); | |
4174 } | |
4175 #endif /*#if defined (FF_MMI_RIV)*/ | |
4176 | |
4177 GLOBAL T_ACI_RETURN sAT_PercentCMGMDU_Gl ( T_ACI_CMD_SRC srcId, | |
4178 UBYTE index, | |
4179 T_CMGMDU_FCT rplyCB ) | |
4180 { | |
4181 T_ACI_RETURN ret = AT_EXCT; | |
4182 | |
4183 TRACE_FUNCTION ("sAT_PercentCMGMDU_Gl ()"); | |
4184 | |
4185 /* | |
4186 *----------------------------------------------------------------- | |
4187 * check if command executable | |
4188 *----------------------------------------------------------------- | |
4189 */ | |
4190 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4191 { | |
4192 return ret; | |
4193 } | |
4194 | |
4195 smsShrdPrm.rplyCB.cmgmdu = rplyCB; | |
4196 smsShrdPrm.rdMode = READ_NORMAL; | |
4197 | |
4198 /* | |
4199 *----------------------------------------------------------------- | |
4200 * read a short message from memory | |
4201 *----------------------------------------------------------------- | |
4202 */ | |
4203 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGMDU; | |
4204 smsShrdPrm.owner = (T_OWN)srcId; | |
4205 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4206 | |
4207 psaSMS_ReadReq ( smsShrdPrm.mem1, index, | |
4208 smsShrdPrm.rdMode, SMS_STAT_NotPresent); | |
4209 | |
4210 return( ret ); | |
4211 } | |
4212 /* | |
4213 +-------------------------------------------------------------------+ | |
4214 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4215 | STATE : code ROUTINE : sAT_PercentCMGR_Gl | | |
4216 +-------------------------------------------------------------------+ | |
4217 | |
4218 PURPOSE : This is the functional counterpart of the %CMGR | |
4219 AT command which is responsible for reading a short | |
4220 message from memory. | |
4221 | |
4222 <index>: storage area index | |
4223 <rdMode>: read mode | |
4224 <rplyCB>: reply call-back | |
4225 <errorCB>: error call-back | |
4226 */ | |
4227 GLOBAL T_ACI_RETURN sAT_PercentCMGR_Gl ( T_ACI_CMD_SRC srcId, | |
4228 UBYTE index, | |
4229 T_ACI_SMS_READ rdMode, | |
4230 T_CMGR_FCT rplyCB ) | |
4231 { | |
4232 T_ACI_RETURN ret = AT_EXCT; | |
4233 | |
4234 TRACE_FUNCTION ("sAT_PercentCMGR_Gl ()"); | |
4235 | |
4236 /* | |
4237 *----------------------------------------------------------------- | |
4238 * check if command executable | |
4239 *----------------------------------------------------------------- | |
4240 */ | |
4241 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4242 { | |
4243 return ret; | |
4244 } | |
4245 | |
4246 smsShrdPrm.rplyCB.cmgr = rplyCB; | |
4247 | |
4248 | |
4249 /* | |
4250 *----------------------------------------------------------------- | |
4251 * process the <index> parameter | |
4252 *----------------------------------------------------------------- | |
4253 */ | |
4254 switch (rdMode) | |
4255 { | |
4256 case SMS_READ_StatusChange: | |
4257 smsShrdPrm.rdMode = READ_STATUS_CHANGE; | |
4258 break; | |
4259 case SMS_READ_Preview: | |
4260 smsShrdPrm.rdMode = READ_PREVIEW; | |
4261 break; | |
4262 case SMS_READ_Normal: | |
4263 case SMS_READ_NotPresent: | |
4264 smsShrdPrm.rdMode = READ_NORMAL; | |
4265 break; | |
4266 default: | |
4267 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4268 return ( AT_FAIL ); | |
4269 } | |
4270 /* | |
4271 *----------------------------------------------------------------- | |
4272 * read a short message from memory | |
4273 *----------------------------------------------------------------- | |
4274 */ | |
4275 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGR; | |
4276 smsShrdPrm.owner = (T_OWN)srcId; | |
4277 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4278 | |
4279 psaSMS_ReadReq ( smsShrdPrm.mem1, index, | |
4280 smsShrdPrm.rdMode, SMS_STAT_NotPresent); | |
4281 | |
4282 return( ret ); | |
4283 } | |
4284 | |
4285 | |
4286 /* | |
4287 +-------------------------------------------------------------------+ | |
4288 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4289 | STATE : code ROUTINE : sAT_PercentCMGR | | |
4290 +-------------------------------------------------------------------+ | |
4291 | |
4292 PURPOSE : This is the functional counterpart of the %CMGR | |
4293 AT command which is responsible for reading a short | |
4294 message from memory. | |
4295 | |
4296 Features Concatenated SMS. | |
4297 For GPF-MMI. | |
4298 | |
4299 <index>: storage area index | |
4300 <rdMode>: read mode | |
4301 */ | |
4302 #if (defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
4303 | |
4304 GLOBAL T_ACI_RETURN sAT_PercentCMGR ( T_ACI_CMD_SRC srcId, | |
4305 UBYTE index, | |
4306 T_ACI_SMS_READ rdMode ) | |
4307 { | |
4308 T_CONC_INIT_RETURN ret; | |
4309 | |
4310 TRACE_FUNCTION ("sAT_PercentCMGR ()"); | |
4311 | |
4312 ret=concSMS_initReadFromMem(srcId, index, rdMode); | |
4313 | |
4314 if (ret EQ CONC_NEEDED) | |
4315 { | |
4316 SET_CONC; | |
4317 TRACE_EVENT("sAT_PlusCMGR: CONC_NEEDED"); | |
4318 return sAT_PercentCMGR_Gl(srcId, index, rdMode, rConcSMS_PercentCMGR); | |
4319 } | |
4320 else if (ret EQ CONC_NOT_NEEDED) | |
4321 { | |
4322 TRACE_EVENT("sAT_PlusCMGR: CONC_NOT_NEEDED"); | |
4323 return sAT_PercentCMGR_Gl(srcId, index, rdMode, rAT_PercentCMGR); | |
4324 } | |
4325 else | |
4326 { | |
4327 TRACE_EVENT("ERROR: sAT_PercentCMGR: CMS_ERR_InValMemIdx"); | |
4328 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
4329 return ( AT_FAIL ); | |
4330 } | |
4331 } | |
4332 #endif /*#if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)*/ | |
4333 | |
4334 /* | |
4335 +-------------------------------------------------------------------+ | |
4336 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4337 | STATE : code ROUTINE : sAT_PercentCMGR | | |
4338 +-------------------------------------------------------------------+ | |
4339 | |
4340 PURPOSE : %CMGR command for handling the conc module on | |
4341 the Riv-MMI side. | |
4342 */ | |
4343 #if defined (FF_MMI_RIV) /* OR !defined TI_PS_FF_CONC_SMS */ | |
4344 GLOBAL T_ACI_RETURN sAT_PercentCMGR ( T_ACI_CMD_SRC srcId, | |
4345 UBYTE index, | |
4346 T_ACI_SMS_READ rdMode ) | |
4347 { | |
4348 TRACE_FUNCTION ("sAT_PercentCMGR ()"); | |
4349 | |
4350 TRACE_EVENT_P1("sAT_PercentCMGR () index: %d", index); | |
4351 | |
4352 return sAT_PercentCMGR_Gl(srcId, index, rdMode, rAT_PercentCMGR); | |
4353 } | |
4354 #endif /*#if defined (FF_MMI_RIV)*/ | |
4355 | |
4356 /* | |
4357 +-------------------------------------------------------------------+ | |
4358 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4359 | STATE : code ROUTINE : sAT_PercentCMGL | | |
4360 +-------------------------------------------------------------------+ | |
4361 | |
4362 PURPOSE : This is the functional counterpart of the %CMGL | |
4363 AT command which is responsible for creating a list of | |
4364 all stored short messages. | |
4365 | |
4366 <state>: state of stored short message | |
4367 <rdmode>: Read mode | |
4368 */ | |
4369 GLOBAL T_ACI_RETURN sAT_PercentCMGL ( T_ACI_CMD_SRC srcId, | |
4370 T_ACI_SMS_STAT state, | |
4371 T_ACI_SMS_READ rdMode ) | |
4372 { | |
4373 T_ACI_RETURN ret; /* AT response code */ | |
4374 T_ACI_SMS_STAT chk_state; | |
4375 | |
4376 TRACE_FUNCTION ("sAT_PercentCMGL ()"); | |
4377 | |
4378 /* | |
4379 *----------------------------------------------------------------- | |
4380 * check if command executable | |
4381 *----------------------------------------------------------------- | |
4382 */ | |
4383 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4384 { | |
4385 return ret; | |
4386 } | |
4387 | |
4388 /* | |
4389 *----------------------------------------------------------------- | |
4390 * process the <state> parameter | |
4391 *----------------------------------------------------------------- | |
4392 */ | |
4393 switch ( state ) | |
4394 { | |
4395 case( SMS_STAT_NotPresent ): | |
4396 chk_state = SMS_STAT_RecUnread; | |
4397 break; | |
4398 | |
4399 case( SMS_STAT_Invalid ): | |
4400 case( SMS_STAT_All ): | |
4401 case( SMS_STAT_RecUnread ): | |
4402 case( SMS_STAT_RecRead ): | |
4403 case( SMS_STAT_StoUnsent ): | |
4404 case( SMS_STAT_StoSent ): | |
4405 chk_state = state; | |
4406 break; | |
4407 | |
4408 default: | |
4409 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4410 return ( AT_FAIL ); | |
4411 } | |
4412 | |
4413 | |
4414 /* | |
4415 *----------------------------------------------------------------- | |
4416 * process the <rdMode> parameter | |
4417 *----------------------------------------------------------------- | |
4418 */ | |
4419 switch (rdMode) | |
4420 { | |
4421 case SMS_READ_StatusChange: | |
4422 smsShrdPrm.rdMode = READ_STATUS_CHANGE; | |
4423 break; | |
4424 case SMS_READ_Preview: | |
4425 smsShrdPrm.rdMode = READ_PREVIEW; | |
4426 break; | |
4427 case SMS_READ_Normal: | |
4428 case SMS_READ_NotPresent: | |
4429 smsShrdPrm.rdMode = READ_NORMAL; | |
4430 break; | |
4431 default: | |
4432 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4433 return ( AT_FAIL ); | |
4434 } | |
4435 | |
4436 /* | |
4437 *--------------------------------------------------------------- | |
4438 * PSA notification | |
4439 *--------------------------------------------------------------- | |
4440 */ | |
4441 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGL; | |
4442 smsShrdPrm.owner = (T_OWN)srcId; | |
4443 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4444 | |
4445 /* | |
4446 *--------------------------------------------------------------- | |
4447 * request the list element | |
4448 *--------------------------------------------------------------- | |
4449 */ | |
4450 psaSMS_ReadReq ( smsShrdPrm.mem1, 0, | |
4451 smsShrdPrm.rdMode, chk_state ); | |
4452 | |
4453 return( AT_EXCT ); | |
4454 } | |
4455 | |
4456 /* | |
4457 +-------------------------------------------------------------------+ | |
4458 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4459 | STATE : code ROUTINE : cmhSMS_SendDelete_Req | | |
4460 +-------------------------------------------------------------------+ | |
4461 | |
4462 PURPOSE : This is the functional used to send a delete request | |
4463 to SMS module. | |
4464 | |
4465 */ | |
4466 | |
4467 GLOBAL void cmhSMS_SendDelete_Req ( UBYTE index, | |
4468 UBYTE status ) | |
4469 { | |
4470 TRACE_FUNCTION ("cmhSMS_SendDelete_Req ()"); | |
4471 | |
4472 smsShrdPrm.index = index; | |
4473 smsShrdPrm.status = status; | |
4474 | |
4475 /*-------------------------------------------------------------------* | |
4476 * Create and Send primitive for SMS delete * | |
4477 *-------------------------------------------------------------------*/ | |
4478 { | |
4479 PALLOC (mnsms_delete_req, MNSMS_DELETE_REQ); | |
4480 | |
4481 /* fill in primitive parameter: delete message */ | |
4482 mnsms_delete_req -> mem_type = smsShrdPrm.mem1; | |
4483 mnsms_delete_req -> rec_num = index; | |
4484 mnsms_delete_req -> delete_status = status; | |
4485 | |
4486 PSENDX (SMS, mnsms_delete_req); | |
4487 | |
4488 TRACE_EVENT_P1("cmgd: delete rec_num: %d", mnsms_delete_req->rec_num); | |
4489 } | |
4490 } | |
4491 | |
4492 | |
4493 /* | |
4494 +-------------------------------------------------------------------+ | |
4495 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4496 | STATE : code ROUTINE : sAT_PercentCMGRS | | |
4497 +-------------------------------------------------------------------+ | |
4498 | |
4499 PURPOSE : This is the functional counterpart of the %CMGRS | |
4500 AT command which is responsible for selecting auto | |
4501 retransmission mode/request manual retransmission of last | |
4502 failed SMS | |
4503 | |
4504 <mode>: requested mode | |
4505 */ | |
4506 #ifdef REL99 | |
4507 | |
4508 GLOBAL T_ACI_RETURN sAT_PercentCMGRS ( T_ACI_CMD_SRC srcId, | |
4509 T_ACI_CMGRS_MODE mode) | |
4510 { | |
4511 T_ACI_RETURN aci_ret_val = AT_CMPL; | |
4512 | |
4513 TRACE_FUNCTION ("sAT_PercentCMGRS ()"); | |
4514 | |
4515 /* | |
4516 *----------------------------------------------------------------- | |
4517 * check command source | |
4518 *----------------------------------------------------------------- | |
4519 */ | |
4520 if(!cmh_IsVldCmdSrc (srcId) AND (srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT)) | |
4521 { | |
4522 TRACE_ERROR ("[cmhSMS_checkAccess]: Cmd Src not valid"); | |
4523 return AT_FAIL; | |
4524 } | |
4525 /* | |
4526 *----------------------------------------------------------------- | |
4527 * check SMS access status | |
4528 *----------------------------------------------------------------- | |
4529 */ | |
4530 if (!cmhSMS_checkSIM ()) | |
4531 { | |
4532 return AT_FAIL; | |
4533 } | |
4534 | |
4535 switch( mode ) | |
4536 { | |
4537 case( CMGRS_MODE_DISABLE_AUTO_RETRANS ): | |
4538 case( CMGRS_MODE_ENABLE_AUTO_RETRANS ): | |
4539 smsShrdPrm.auto_repeat_flag = mode; | |
4540 aci_ret_val = AT_CMPL; | |
4541 break; | |
4542 | |
4543 case( CMGRS_MODE_MANUAL_RETRANS ): | |
4544 /* | |
4545 *----------------------------------------------------------------- | |
4546 * check entity status | |
4547 *----------------------------------------------------------------- | |
4548 */ | |
4549 if( smsShrdPrm.smsEntStat.curCmd NEQ AT_CMD_NONE ) | |
4550 { | |
4551 | |
4552 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
4553 TRACE_ERROR ("[cmhSMS_checkAccess]: Entity is busy"); | |
4554 aci_ret_val = AT_BUSY; | |
4555 break ; | |
4556 } | |
4557 | |
4558 if(smsShrdPrm.is_msg_present_for_retrans EQ FALSE) | |
4559 { | |
4560 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_FailedMsgNotPresent ); | |
4561 aci_ret_val = AT_FAIL; | |
4562 } | |
4563 else | |
4564 { | |
4565 /*------------------------------------------------------------------- | |
4566 * create and send primitive for retrasnmission request | |
4567 *------------------------------------------------------------------- | |
4568 */ | |
4569 PALLOC (mnsms_retrans_req, MNSMS_RETRANS_REQ); | |
4570 mnsms_retrans_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
4571 PSENDX (SMS, mnsms_retrans_req); | |
4572 | |
4573 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGRS; | |
4574 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4575 smsShrdPrm.owner = (T_OWN)srcId; | |
4576 #if defined (MFW) OR defined (FF_MMI_RIV) | |
4577 smsShrdPrm.rplyCB.cmgrs = rAT_PercentCMGRS; | |
4578 smsShrdPrm.errorCB = rAT_PlusCMS; | |
4579 #else | |
4580 smsShrdPrm.rplyCB.cmgrs = NULL; | |
4581 smsShrdPrm.errorCB = NULL; | |
4582 #endif | |
4583 aci_ret_val = AT_EXCT; | |
4584 } | |
4585 break; | |
4586 | |
4587 default: | |
4588 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4589 aci_ret_val = AT_FAIL; | |
4590 break; | |
4591 } | |
4592 | |
4593 return aci_ret_val; | |
4594 } | |
4595 #endif | |
4596 | |
4597 /*==== EOF ========================================================*/ |