FreeCalypso > hg > fc-magnetite
comparison src/g23m-aci/aci/cmh_smss.c @ 162:53929b40109c
src/g23m-aci: initial import from TCS3.2/LoCosto
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Tue, 11 Oct 2016 02:02:43 +0000 |
parents | |
children | b135e1505ae4 |
comparison
equal
deleted
inserted
replaced
161:4557e2a9c18e | 162:53929b40109c |
---|---|
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 "aci_all.h" | |
27 /*==== INCLUDES ===================================================*/ | |
28 #include "aci_cmh.h" | |
29 #include "ati_cmd.h" | |
30 #include "aci_cmd.h" | |
31 | |
32 #ifdef FAX_AND_DATA | |
33 #include "aci_fd.h" | |
34 #endif /* of #ifdef FAX_AND_DATA */ | |
35 | |
36 #include "gdi.h" | |
37 #include "aci.h" | |
38 #include "aci_lst.h" | |
39 #include "aci_mem.h" | |
40 | |
41 #if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_) | |
42 #include "conc_sms.h" | |
43 #endif | |
44 | |
45 #include "psa.h" | |
46 #include "psa_sms.h" | |
47 #include "psa_mmi.h" | |
48 #include "cmh.h" | |
49 #include "cmh_sms.h" | |
50 #include "pcm.h" | |
51 #include "Phb.h" | |
52 #include "cmh_phb.h" | |
53 | |
54 #ifdef SIM_TOOLKIT | |
55 #include "psa_sim.h" | |
56 #include "psa_cc.h" | |
57 #include "psa_sat.h" | |
58 #include "cmh_sat.h" | |
59 #endif /*of SIM_TOOLKIT */ | |
60 | |
61 | |
62 #if 1 | |
63 #include <stdio.h> | |
64 #endif | |
65 | |
66 /*==== CONSTANTS ==================================================*/ | |
67 | |
68 | |
69 #define SMS_CMH_IDX_MAX (255) /* memory location index */ | |
70 /* maximum value */ | |
71 #define SMS_CMH_IDX_MIN (1) /* memory location index */ | |
72 /* minimum value */ | |
73 /*--------------------------------------------------------------*/ | |
74 #define SMS_CMH_MN_MAX (255) /* message number maximum value */ | |
75 #define SMS_CMH_MN_MIN (0) /* message number minimum value */ | |
76 /*--------------------------------------------------------------*/ | |
77 #define SMS_CMH_CT_MAX (255) /* command type maximum value */ | |
78 #define SMS_CMH_CT_MIN (0) /* command type minimum value */ | |
79 /*--------------------------------------------------------------*/ | |
80 #define SMS_CMH_FO_MAX (255) /* first octet maximum value */ | |
81 #define SMS_CMH_FO_MIN (0) /* first octet minimum value */ | |
82 /*--------------------------------------------------------------*/ | |
83 #define SMS_CMH_VPREL_MAX (255) /* relative validity period */ | |
84 /* maximum value */ | |
85 #define SMS_CMH_VPREL_MIN (0) /* relative validity period */ | |
86 /* minimum value */ | |
87 /*--------------------------------------------------------------*/ | |
88 #define SMS_CMH_DCS_MAX (255) /* data coding scheme */ | |
89 /* maximum value */ | |
90 #define SMS_CMH_DCS_MIN (0) /* data coding scheme */ | |
91 /* minimum value */ | |
92 /*--------------------------------------------------------------*/ | |
93 #define SMS_CMH_PID_MAX (255) /* TP-Protocol-Identifier */ | |
94 /* maximum value */ | |
95 #define SMS_CMH_PID_MIN (0) /* TP-Protocol-Identifier */ | |
96 /* minimum value */ | |
97 | |
98 /*==== EXPORT =====================================================*/ | |
99 /*==== VARIABLES ==================================================*/ | |
100 EXTERN T_ACI_LIST *set_prm_list; | |
101 /*==== FUNCTIONS ==================================================*/ | |
102 /* | |
103 +-------------------------------------------------------------------+ | |
104 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
105 | STATE : code ROUTINE : sAT_PlusCSMP | | |
106 +-------------------------------------------------------------------+ | |
107 | |
108 PURPOSE : This is the functional counterpart of the +CSMP | |
109 AT command which is responsible for setting the text | |
110 mode parameter. | |
111 | |
112 <fo>: first octet of SMS-DELIVER, SMS-SUBMIT, etc. | |
113 <vprel>: relative validity period | |
114 <vpabs>: absolute validity period | |
115 <vpenh>: enhanced validity period | |
116 <pid>: TP-Protocol-Identifier | |
117 <dcs>: SMS data coding scheme | |
118 */ | |
119 GLOBAL T_ACI_RETURN sAT_PlusCSMP ( T_ACI_CMD_SRC srcId, | |
120 SHORT fo, | |
121 SHORT vprel, | |
122 T_ACI_VP_ABS* vpabs, | |
123 T_ACI_VP_ENH* vpenh, | |
124 SHORT pid, | |
125 SHORT dcs ) | |
126 { | |
127 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
128 T_SMS_SET_PRM * pSMSSetPrmCopy;/* points to SMS parameter set */ | |
129 UBYTE chkFo; /* checked parameter <fo> */ | |
130 UBYTE chkVprel = '\0'; /* checked parameter <vprel> */ | |
131 T_tp_vp_abs chkVpabs; /* checked parameter <vpabs> */ | |
132 T_tp_vp_enh chkVpenh; /* checked parameter <vpenh> */ | |
133 UBYTE chkPid; /* checked parameter <pid> */ | |
134 UBYTE chkDcs; /* checked parameter <dcs> */ | |
135 | |
136 TRACE_FUNCTION ("sAT_PlusCSMP ()"); | |
137 | |
138 /* | |
139 *----------------------------------------------------------------- | |
140 * check command source | |
141 *----------------------------------------------------------------- | |
142 */ | |
143 if(!cmh_IsVldCmdSrc (srcId)) | |
144 { | |
145 return( AT_FAIL ); | |
146 } | |
147 | |
148 /* | |
149 *----------------------------------------------------------------- | |
150 * check if command executable | |
151 *----------------------------------------------------------------- | |
152 */ | |
153 if(!cmhSMS_checkSIM ()) | |
154 return AT_FAIL; | |
155 | |
156 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
157 | |
158 /* | |
159 *----------------------------------------------------------------- | |
160 * create a temporary copy | |
161 *----------------------------------------------------------------- | |
162 */ | |
163 if ( pSMSSetPrm->isCopy EQ FALSE ) | |
164 { | |
165 ACI_MALLOC(pSMSSetPrmCopy, sizeof(T_SMS_SET_PRM)); | |
166 memcpy(pSMSSetPrmCopy, pSMSSetPrm, sizeof(T_SMS_SET_PRM)); | |
167 | |
168 pSMSSetPrm->numOfRefs--; | |
169 pSMSSetPrmCopy->isCopy = TRUE; | |
170 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmCopy; | |
171 pSMSSetPrm = pSMSSetPrmCopy; | |
172 } | |
173 | |
174 /* | |
175 *----------------------------------------------------------------- | |
176 * process the <fo> parameter | |
177 *----------------------------------------------------------------- | |
178 */ | |
179 if( fo NEQ ACI_NumParmNotPresent ) | |
180 { | |
181 if( fo > SMS_CMH_FO_MAX OR fo < SMS_CMH_FO_MIN OR | |
182 ( fo & TP_MTI_MASK ) EQ TP_MTI_SMS_RESERVED ) | |
183 { | |
184 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
185 return ( AT_FAIL ); | |
186 } | |
187 else | |
188 | |
189 chkFo = (UBYTE) fo; | |
190 } | |
191 else | |
192 | |
193 chkFo = pSMSSetPrm -> msgType; | |
194 | |
195 /* | |
196 *----------------------------------------------------------------- | |
197 * process the <vprel> parameter | |
198 *----------------------------------------------------------------- | |
199 */ | |
200 if( ( chkFo & VPF_MASK ) EQ VPF_RELATIVE ) | |
201 { | |
202 if ( vprel NEQ ACI_NumParmNotPresent ) | |
203 { | |
204 if( vprel > SMS_CMH_VPREL_MAX OR vprel < SMS_CMH_VPREL_MIN ) | |
205 { | |
206 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
207 return ( AT_FAIL ); | |
208 } | |
209 else | |
210 | |
211 chkVprel = (UBYTE) vprel; | |
212 } | |
213 else | |
214 | |
215 chkVprel = pSMSSetPrm -> vpRel; | |
216 | |
217 } | |
218 | |
219 /* | |
220 *----------------------------------------------------------------- | |
221 * process the <vpabs> parameter | |
222 *----------------------------------------------------------------- | |
223 */ | |
224 memset(&chkVpabs, 0, sizeof(T_tp_vp_abs)); | |
225 if( ( chkFo & VPF_MASK ) EQ VPF_ABSOLUTE ) | |
226 { | |
227 if (vpabs NEQ NULL ) | |
228 { | |
229 if ( ! cmhSMS_isVpabsVld ( vpabs ) ) | |
230 { | |
231 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
232 return ( AT_FAIL ); | |
233 } | |
234 else | |
235 | |
236 cmhSMS_setVpabsPsa ( &chkVpabs, vpabs ); | |
237 } | |
238 else | |
239 | |
240 memcpy ( ( CHAR * ) &chkVpabs, ( CHAR * ) &pSMSSetPrm -> vpAbs, | |
241 sizeof ( T_tp_vp_abs ) ); | |
242 | |
243 } | |
244 | |
245 /* | |
246 *----------------------------------------------------------------- | |
247 * process the <vpenh> parameter | |
248 *----------------------------------------------------------------- | |
249 */ | |
250 | |
251 memset(&chkVpenh, 0, sizeof(T_tp_vp_enh)); | |
252 if( ( chkFo & VPF_MASK ) EQ VPF_ENHANCED ) | |
253 { | |
254 if (vpenh NEQ NULL ) | |
255 { | |
256 if ( ! cmhSMS_isVpenhVld ( vpenh ) ) | |
257 { | |
258 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
259 return ( AT_FAIL ); | |
260 } | |
261 else | |
262 | |
263 cmhSMS_setVpenhPsa ( &chkVpenh, vpenh ); | |
264 } | |
265 else | |
266 | |
267 memcpy ( ( CHAR * ) &chkVpenh, ( CHAR * ) &pSMSSetPrm -> vpEnh, | |
268 sizeof ( T_tp_vp_enh ) ); | |
269 | |
270 } | |
271 | |
272 /* | |
273 *----------------------------------------------------------------- | |
274 * process the <pid> parameter | |
275 *----------------------------------------------------------------- | |
276 */ | |
277 if( pid NEQ ACI_NumParmNotPresent ) | |
278 { | |
279 if( pid > SMS_CMH_PID_MAX OR pid < SMS_CMH_PID_MIN ) | |
280 { | |
281 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
282 return ( AT_FAIL ); | |
283 } | |
284 else | |
285 | |
286 chkPid = (UBYTE) pid; | |
287 } | |
288 else | |
289 | |
290 chkPid = pSMSSetPrm -> pid; | |
291 | |
292 /* | |
293 *----------------------------------------------------------------- | |
294 * process the <dcs> parameter | |
295 *----------------------------------------------------------------- | |
296 */ | |
297 if( dcs NEQ ACI_NumParmNotPresent ) | |
298 { | |
299 if( dcs > SMS_CMH_DCS_MAX OR dcs < SMS_CMH_DCS_MIN ) | |
300 { | |
301 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
302 return ( AT_FAIL ); | |
303 } | |
304 else | |
305 | |
306 chkDcs = (UBYTE) dcs; | |
307 } | |
308 else | |
309 | |
310 chkDcs = pSMSSetPrm -> dcs; | |
311 | |
312 /* | |
313 *----------------------------------------------------------------- | |
314 * copy parameter | |
315 *----------------------------------------------------------------- | |
316 */ | |
317 pSMSSetPrm -> msgType = chkFo; | |
318 | |
319 | |
320 if( ( chkFo & VPF_MASK ) EQ VPF_RELATIVE ) | |
321 { | |
322 pSMSSetPrm -> vpRel = chkVprel; | |
323 } | |
324 else if ( ( chkFo & VPF_MASK ) EQ VPF_ABSOLUTE ) | |
325 { | |
326 memcpy ( ( CHAR * ) &pSMSSetPrm -> vpAbs, ( CHAR * ) &chkVpabs, | |
327 sizeof ( T_tp_vp_abs ) ); | |
328 } | |
329 else if ( ( chkFo & VPF_MASK ) EQ VPF_ENHANCED ) | |
330 { | |
331 memcpy ( ( CHAR * ) &pSMSSetPrm -> vpEnh, ( CHAR * ) &chkVpenh, | |
332 sizeof ( T_tp_vp_enh ) ); | |
333 } | |
334 | |
335 pSMSSetPrm -> pid = chkPid; | |
336 pSMSSetPrm -> dcs = chkDcs; | |
337 return( AT_CMPL ); | |
338 } | |
339 | |
340 /* | |
341 +-------------------------------------------------------------------+ | |
342 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
343 | STATE : code ROUTINE : sAT_PlusCSCA | | |
344 +-------------------------------------------------------------------+ | |
345 | |
346 PURPOSE : This is the functional counterpart of the +CSCA | |
347 AT command which is responsible for setting the | |
348 service center address. | |
349 | |
350 <sca>: service center address | |
351 <tosca>: type of service center address | |
352 */ | |
353 GLOBAL T_ACI_RETURN sAT_PlusCSCA ( T_ACI_CMD_SRC srcId, | |
354 CHAR* sca, | |
355 T_ACI_TOA* tosca ) | |
356 { | |
357 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
358 T_SMS_SET_PRM * pSMSSetPrmCopy; /* copy of SMS parameter set */ | |
359 CHAR* restSca = sca; /* service center address without */ | |
360 /* international access function */ | |
361 /* characters */ | |
362 | |
363 TRACE_FUNCTION ("sAT_PlusCSCA ()"); | |
364 | |
365 /* | |
366 *----------------------------------------------------------------- | |
367 * check command source | |
368 *----------------------------------------------------------------- | |
369 */ | |
370 if(!cmh_IsVldCmdSrc (srcId)) | |
371 { | |
372 return( AT_FAIL ); | |
373 } | |
374 | |
375 /* | |
376 *----------------------------------------------------------------- | |
377 * check if command executable | |
378 *----------------------------------------------------------------- | |
379 */ | |
380 if(!cmhSMS_checkSIM ()) | |
381 return AT_FAIL; | |
382 | |
383 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
384 | |
385 /* | |
386 *----------------------------------------------------------------- | |
387 * create a temporary copy | |
388 *----------------------------------------------------------------- | |
389 */ | |
390 if ( pSMSSetPrm->isCopy EQ FALSE ) | |
391 { | |
392 ACI_MALLOC(pSMSSetPrmCopy, sizeof(T_SMS_SET_PRM)); | |
393 memcpy(pSMSSetPrmCopy, pSMSSetPrm, sizeof(T_SMS_SET_PRM)); | |
394 | |
395 pSMSSetPrm->numOfRefs--; | |
396 pSMSSetPrmCopy->isCopy = TRUE; | |
397 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmCopy; | |
398 pSMSSetPrm = pSMSSetPrmCopy; | |
399 } | |
400 | |
401 /* | |
402 *----------------------------------------------------------------- | |
403 * process the <sca> parameter | |
404 *----------------------------------------------------------------- | |
405 */ | |
406 if ( sca NEQ NULL ) | |
407 { | |
408 /* | |
409 *--------------------------------------------------------------- | |
410 * process the <tosca> parameter | |
411 *--------------------------------------------------------------- | |
412 */ | |
413 if ( tosca NEQ NULL ) | |
414 { | |
415 pSMSSetPrm -> sca.ton = cmhSMS_getNType ( tosca -> ton ); | |
416 pSMSSetPrm -> sca.npi = cmhSMS_getNPlan ( tosca -> npi ); | |
417 } | |
418 else | |
419 { | |
420 restSca = cmhSMS_setToaDef ( sca, | |
421 &pSMSSetPrm -> sca.ton, | |
422 &pSMSSetPrm -> sca.npi ); | |
423 } | |
424 | |
425 cmhSMS_getAdrBcd ( pSMSSetPrm -> sca.num, | |
426 &pSMSSetPrm -> sca.c_num, | |
427 MAX_SMS_ADDR_DIG, restSca); | |
428 | |
429 pSMSSetPrm -> sca.v_npi = TRUE; | |
430 pSMSSetPrm -> sca.v_ton = TRUE; | |
431 return ( AT_CMPL ); | |
432 } | |
433 else | |
434 { | |
435 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
436 return ( AT_FAIL ); | |
437 } | |
438 } | |
439 | |
440 /* | |
441 +-------------------------------------------------------------------+ | |
442 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
443 | STATE : code ROUTINE : sAT_PlusCSMS | | |
444 +-------------------------------------------------------------------+ | |
445 | |
446 PURPOSE : This is the functional counterpart of the +CSMS | |
447 AT command which is responsible for setting the | |
448 message service. | |
449 | |
450 <service>: message service | |
451 */ | |
452 GLOBAL T_ACI_RETURN sAT_PlusCSMS ( T_ACI_CMD_SRC srcId, | |
453 T_ACI_CSMS_SERV service ) | |
454 { | |
455 T_ACI_RETURN ret; /* AT response code */ | |
456 | |
457 TRACE_FUNCTION ("sAT_PlusCSMS ()"); | |
458 | |
459 /* | |
460 *----------------------------------------------------------------- | |
461 * check if command executable | |
462 *----------------------------------------------------------------- | |
463 */ | |
464 if(!cmhSMS_checkAccess (srcId, &ret)) | |
465 return ret; | |
466 | |
467 /* | |
468 *----------------------------------------------------------------- | |
469 * process the <service> parameter | |
470 *----------------------------------------------------------------- | |
471 */ | |
472 switch( service ) | |
473 { | |
474 case( CSMS_SERV_NotPresent ): | |
475 break; | |
476 | |
477 case( CSMS_SERV_GsmPh2 ): | |
478 case( CSMS_SERV_GsmPh2Plus ): | |
479 smsShrdPrm.CSMSservice = service; | |
480 | |
481 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CSMS; | |
482 smsShrdPrm.owner = (T_OWN)srcId; | |
483 smsShrdPrm.smsEntStat.entOwn = srcId; | |
484 /* Implements measure 147,148, 149 */ | |
485 cmhSMS_sendConfigureReq(FALSE); | |
486 { | |
487 R_AT ( RAT_CSMS, smsShrdPrm.smsEntStat.entOwn ) | |
488 ( CSMS_SERV_NotPresent, | |
489 smsShrdPrm.CSMSmt, | |
490 smsShrdPrm.CSMSmo, | |
491 smsShrdPrm.CSMSbm ); | |
492 } | |
493 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
494 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
495 smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; | |
496 break; | |
497 | |
498 default: | |
499 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
500 return( AT_FAIL ); | |
501 } | |
502 | |
503 return( AT_CMPL ); | |
504 } | |
505 | |
506 /* | |
507 +-------------------------------------------------------------------+ | |
508 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
509 | STATE : code ROUTINE : sAT_PlusCMGF | | |
510 +-------------------------------------------------------------------+ | |
511 | |
512 PURPOSE : This is the functional counterpart of the +CMGF | |
513 AT command which is responsible for setting the | |
514 message format. | |
515 | |
516 <mode>: indicates the message format | |
517 */ | |
518 GLOBAL T_ACI_RETURN sAT_PlusCMGF ( T_ACI_CMD_SRC srcId, | |
519 T_ACI_CMGF_MOD mode ) | |
520 { | |
521 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
522 | |
523 TRACE_FUNCTION ("sAT_PlusCMGF ()"); | |
524 | |
525 /* | |
526 *----------------------------------------------------------------- | |
527 * check command source | |
528 *----------------------------------------------------------------- | |
529 */ | |
530 if(!cmh_IsVldCmdSrc (srcId)) | |
531 { | |
532 return( AT_FAIL ); | |
533 } | |
534 | |
535 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
536 | |
537 /* | |
538 *----------------------------------------------------------------- | |
539 * process the <mode> parameter | |
540 *----------------------------------------------------------------- | |
541 */ | |
542 switch( mode ) | |
543 { | |
544 case( CMGF_MOD_NotPresent ): | |
545 pSMSSetPrm -> CMGFmode = CMGF_MOD_Pdu; | |
546 break; | |
547 | |
548 case( CMGF_MOD_Txt ): | |
549 case (CMGF_MOD_Pdu ): | |
550 pSMSSetPrm -> CMGFmode = mode; | |
551 break; | |
552 | |
553 default: | |
554 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
555 return( AT_FAIL ); | |
556 } | |
557 | |
558 return( AT_CMPL ); | |
559 } | |
560 | |
561 /* | |
562 +-------------------------------------------------------------------+ | |
563 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
564 | STATE : code ROUTINE : sAT_PercentSMBS | | |
565 +-------------------------------------------------------------------+ | |
566 | |
567 PURPOSE : This is the functional counterpart of the %SMBS | |
568 AT command which is responsible for setting the SMS message format. | |
569 | |
570 <mode>: indicates the message format | |
571 */ | |
572 #ifdef FF_MMI_RIV | |
573 GLOBAL T_ACI_RETURN sAT_PercentSMBS ( T_ACI_CMD_SRC srcId, | |
574 T_ACI_PERC_SMBS_MOD mode ) | |
575 { | |
576 TRACE_FUNCTION ("sAT_PercentSMBS ()"); | |
577 | |
578 /* check command source */ | |
579 if(!cmh_IsVldCmdSrc (srcId)) | |
580 { | |
581 return( AT_FAIL ); | |
582 } | |
583 | |
584 /* process the <mode> parameter */ | |
585 switch( mode ) | |
586 { | |
587 case( PERC_SMBS_MOD_NotPresent ): | |
588 smsShrdPrm.perccmgf_smbs_mode = PERC_SMBS_MOD_DISABLE; /* default */ | |
589 break; | |
590 | |
591 case( PERC_SMBS_MOD_DISABLE ): | |
592 case (PERC_SMBS_MOD_ENABLE ): | |
593 smsShrdPrm.perccmgf_smbs_mode = mode; | |
594 break; | |
595 | |
596 default: | |
597 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
598 return( AT_FAIL ); | |
599 } | |
600 | |
601 return( AT_CMPL ); | |
602 } | |
603 #endif /* #ifdef FF_MMI_RIV */ | |
604 /* | |
605 +-------------------------------------------------------------------+ | |
606 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
607 | STATE : code ROUTINE : sAT_PlusCNMA | | |
608 +-------------------------------------------------------------------+ | |
609 | |
610 PURPOSE : This is the functional counterpart of the +CNMA | |
611 AT command which is responsible for sending the | |
612 new message acknowledgement. | |
613 | |
614 */ | |
615 GLOBAL T_ACI_RETURN sAT_PlusCNMA ( T_ACI_CMD_SRC srcId) | |
616 { | |
617 T_ACI_RETURN ret; /* AT response code */ | |
618 | |
619 TRACE_FUNCTION ("sAT_PlusCNMA ()"); | |
620 | |
621 /* | |
622 *----------------------------------------------------------------- | |
623 * check if command executable | |
624 *----------------------------------------------------------------- | |
625 */ | |
626 if(!cmhSMS_checkAccess (srcId, &ret)) | |
627 return ret; | |
628 | |
629 /* | |
630 *----------------------------------------------------------------- | |
631 * check current service and whether an acknowledgement is expected. | |
632 *----------------------------------------------------------------- | |
633 */ | |
634 | |
635 if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus AND | |
636 smsShrdPrm.cnma_ack_expected) | |
637 { | |
638 PALLOC (mnsms_ack_res, MNSMS_ACK_RES); | |
639 | |
640 smsShrdPrm.cnma_ack_expected = FALSE; | |
641 | |
642 mnsms_ack_res->resp = SMS_RP_ACK; | |
643 mnsms_ack_res->sms_sdu.o_buf = 0; | |
644 mnsms_ack_res->sms_sdu.l_buf = 0; | |
645 | |
646 PSENDX (SMS, mnsms_ack_res); | |
647 return ( AT_CMPL ); | |
648 } | |
649 else | |
650 { | |
651 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_NoCnmaAckExpect ); | |
652 return ( AT_FAIL ); | |
653 } | |
654 } | |
655 | |
656 #if defined (SMS_PDU_SUPPORT) | |
657 /* | |
658 +-------------------------------------------------------------------+ | |
659 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
660 | STATE : code ROUTINE : sAT_PlusCNMAPdu | | |
661 +-------------------------------------------------------------------+ | |
662 | |
663 PURPOSE : This is the functional counterpart of the +CNMA | |
664 AT command which is responsible for sending the | |
665 new message acknowledgement in PDU mode | |
666 | |
667 */ | |
668 GLOBAL T_ACI_RETURN sAT_PlusCNMAPdu ( T_ACI_CMD_SRC srcId, | |
669 SHORT n, | |
670 T_ACI_SM_DATA *pdu) | |
671 { | |
672 T_ACI_RETURN ret; /* AT response code */ | |
673 | |
674 TRACE_FUNCTION ("sAT_PlusCNMAPdu ()"); | |
675 | |
676 /* | |
677 *----------------------------------------------------------------- | |
678 * check if command executable | |
679 *----------------------------------------------------------------- | |
680 */ | |
681 if(!cmhSMS_checkAccess (srcId, &ret)) | |
682 return ret; | |
683 | |
684 /* | |
685 *----------------------------------------------------------------- | |
686 * check current service and whether an acknowledgement is expected. | |
687 *----------------------------------------------------------------- | |
688 */ | |
689 if (smsShrdPrm.CSMSservice EQ CSMS_SERV_GsmPh2Plus AND | |
690 smsShrdPrm.cnma_ack_expected) | |
691 { | |
692 PALLOC (mnsms_ack_res, MNSMS_ACK_RES); | |
693 | |
694 smsShrdPrm.cnma_ack_expected = FALSE; | |
695 | |
696 if (n EQ 2) | |
697 mnsms_ack_res->resp = SMS_RP_ERROR; | |
698 else | |
699 mnsms_ack_res->resp = SMS_RP_ACK; | |
700 | |
701 /* one byte for SCA length */ | |
702 if( pdu->len NEQ 0 ) | |
703 { | |
704 mnsms_ack_res->sms_sdu.l_buf = (pdu->len+1) * 8; | |
705 } | |
706 else | |
707 { | |
708 mnsms_ack_res->sms_sdu.l_buf = 0; | |
709 } | |
710 mnsms_ack_res->sms_sdu.o_buf = 0; | |
711 | |
712 /* length of SCA length (is always empty!) */ | |
713 mnsms_ack_res->sms_sdu.buf[0] = 0x00; | |
714 memcpy (&mnsms_ack_res->sms_sdu.buf[1], pdu->data, pdu->len); | |
715 | |
716 PSENDX (SMS, mnsms_ack_res); | |
717 return ( AT_CMPL ); | |
718 } | |
719 else | |
720 { | |
721 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_NoCnmaAckExpect ); | |
722 return ( AT_FAIL ); | |
723 } | |
724 } | |
725 | |
726 | |
727 | |
728 #endif | |
729 | |
730 | |
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 | |
795 chkMt = smsShrdPrm.CNMImt; | |
796 | |
797 else | |
798 | |
799 chkMt = mt; | |
800 | |
801 /* | |
802 *----------------------------------------------------------------- | |
803 * process the <bm> parameter, prm set | |
804 *----------------------------------------------------------------- | |
805 */ | |
806 switch( bm ) | |
807 { | |
808 case( CNMI_BM_NotPresent ): chkBmHndl = smsShrdPrm.cbmPrm.cbmHndl; | |
809 break; | |
810 case( CNMI_BM_NoCbmInd ): chkBmHndl = BM0; break; | |
811 case( CNMI_BM_Cbm ): chkBmHndl = BM2; break; | |
812 | |
813 default: | |
814 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
815 return( AT_FAIL ); | |
816 } | |
817 | |
818 /* | |
819 *----------------------------------------------------------------- | |
820 * process the <bm> parameter, cmd set | |
821 *----------------------------------------------------------------- | |
822 */ | |
823 if ( bm EQ CNMI_BM_NotPresent ) | |
824 | |
825 chkBm = smsShrdPrm.CNMIbm; | |
826 | |
827 else | |
828 | |
829 chkBm = bm; | |
830 | |
831 /* | |
832 *----------------------------------------------------------------- | |
833 * process the <ds> parameter, prm set | |
834 *----------------------------------------------------------------- | |
835 */ | |
836 switch( ds ) | |
837 { | |
838 case( CNMI_DS_NotPresent ): chkDsHndl = smsShrdPrm.srHndl; break; | |
839 case( CNMI_DS_NoSmsStatRpt ): chkDsHndl = DS0; break; | |
840 case( CNMI_DS_SmsStatRpt ): chkDsHndl = DS1; break; | |
841 | |
842 default: | |
843 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
844 return( AT_FAIL ); | |
845 } | |
846 | |
847 /* | |
848 *----------------------------------------------------------------- | |
849 * process the <ds> parameter, cmd set | |
850 *----------------------------------------------------------------- | |
851 */ | |
852 if ( ds EQ CNMI_DS_NotPresent ) | |
853 | |
854 chkDs = smsShrdPrm.CNMIds; | |
855 | |
856 else | |
857 | |
858 chkDs = ds; | |
859 | |
860 /* | |
861 *----------------------------------------------------------------- | |
862 * copy parameter | |
863 *----------------------------------------------------------------- | |
864 */ | |
865 smsShrdPrm.mtHndl = chkMtHndl; | |
866 smsShrdPrm.cbmPrm.cbmHndl = chkBmHndl; | |
867 smsShrdPrm.srHndl = chkDsHndl; | |
868 | |
869 smsShrdPrm.CNMImt = chkMt; | |
870 smsShrdPrm.CNMIbm = chkBm; | |
871 smsShrdPrm.CNMIds = chkDs; | |
872 | |
873 /* | |
874 *----------------------------------------------------------------- | |
875 * configure SMS | |
876 *----------------------------------------------------------------- | |
877 */ | |
878 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CNMI; | |
879 smsShrdPrm.owner = (T_OWN)srcId; | |
880 smsShrdPrm.smsEntStat.entOwn = srcId; | |
881 /* Implements measure 147,148, 149 */ | |
882 cmhSMS_sendConfigureReq (FALSE); | |
883 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
884 smsShrdPrm.owner = (T_OWN)CMD_SRC_NONE; | |
885 smsShrdPrm.smsEntStat.entOwn = CMD_SRC_NONE; | |
886 | |
887 /* | |
888 *----------------------------------------------------------------- | |
889 * set the new CBCH configuration | |
890 *----------------------------------------------------------------- | |
891 */ | |
892 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
893 | |
894 if( psaMMI_Cbch() < 0 ) | |
895 { | |
896 TRACE_EVENT( "FATAL RETURN psaSMS in +CNMI" ); | |
897 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
898 return( AT_FAIL ); | |
899 } | |
900 | |
901 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
902 | |
903 return ( AT_CMPL ); | |
904 } | |
905 | |
906 /* | |
907 +-------------------------------------------------------------------+ | |
908 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
909 | STATE : code ROUTINE : sAT_PlusCPMS | | |
910 +-------------------------------------------------------------------+ | |
911 | |
912 PURPOSE : This is the functional counterpart of the +CPMS | |
913 AT command which is responsible for setting the | |
914 preferred message storages. | |
915 | |
916 <mem1>: preferred memory 1 | |
917 <mem2>: preferred memory 2 | |
918 <mem3>: preferred memory 3 | |
919 */ | |
920 GLOBAL T_ACI_RETURN sAT_PlusCPMS ( T_ACI_CMD_SRC srcId, | |
921 T_ACI_SMS_STOR mem1, | |
922 T_ACI_SMS_STOR mem2, | |
923 T_ACI_SMS_STOR mem3 ) | |
924 { | |
925 T_ACI_RETURN ret; /* AT response code */ | |
926 | |
927 UBYTE chkMem1; /* checked parameter <mem1> */ | |
928 UBYTE chkMem2; /* checked parameter <mem2> */ | |
929 UBYTE chkMem3; /* checked parameter <mem3> */ | |
930 | |
931 T_ACI_SMS_STOR_OCC m1; | |
932 T_ACI_SMS_STOR_OCC m2; | |
933 T_ACI_SMS_STOR_OCC m3; | |
934 | |
935 UBYTE isModified = FALSE; | |
936 | |
937 TRACE_FUNCTION ("sAT_PlusCPMS ()"); | |
938 | |
939 | |
940 /* | |
941 *----------------------------------------------------------------- | |
942 * check if command executable | |
943 *----------------------------------------------------------------- | |
944 */ | |
945 if(!cmhSMS_checkAccess (srcId, &ret)) | |
946 return ret; | |
947 | |
948 /* | |
949 *----------------------------------------------------------------- | |
950 * process the <mem1> parameter | |
951 *----------------------------------------------------------------- | |
952 */ | |
953 if( mem1 NEQ SMS_STOR_NotPresent ) | |
954 { | |
955 if( ! cmhSMS_getMemPsa ( mem1, &chkMem1 ) ) | |
956 { | |
957 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
958 return ( AT_FAIL ); | |
959 } | |
960 smsShrdPrm.mem1 = chkMem1; | |
961 } | |
962 | |
963 /* | |
964 *----------------------------------------------------------------- | |
965 * process the <mem2> parameter | |
966 *----------------------------------------------------------------- | |
967 */ | |
968 if( mem2 NEQ SMS_STOR_NotPresent ) | |
969 { | |
970 if( ! cmhSMS_getMemPsa ( mem2, &chkMem2 ) ) | |
971 { | |
972 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
973 return ( AT_FAIL ); | |
974 } | |
975 smsShrdPrm.mem2 = chkMem2; | |
976 } | |
977 | |
978 /* | |
979 *----------------------------------------------------------------- | |
980 * process the <mem3> parameter | |
981 *----------------------------------------------------------------- | |
982 */ | |
983 if( mem3 NEQ SMS_STOR_NotPresent ) | |
984 { | |
985 if( ! cmhSMS_getMemPsa ( mem3, &chkMem3 ) ) | |
986 { | |
987 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
988 return ( AT_FAIL ); | |
989 } | |
990 if (smsShrdPrm.mem3 NEQ chkMem3) | |
991 { | |
992 smsShrdPrm.mem3 = chkMem3; | |
993 isModified = TRUE; | |
994 } | |
995 } | |
996 | |
997 | |
998 /*------------------------------------------------------------------- | |
999 * create and send primitive for configure request | |
1000 *------------------------------------------------------------------- | |
1001 */ | |
1002 if (isModified) | |
1003 /* Implements measure 147,148, 149 */ | |
1004 cmhSMS_sendConfigureReq (FALSE); | |
1005 | |
1006 | |
1007 /* | |
1008 * ----------------------------------------------------------------- | |
1009 * Fills the T_ACI_SMS_STOR_OCC structure with data from the | |
1010 * shared parameter buffer (used mem, total mem). | |
1011 * ----------------------------------------------------------------- | |
1012 */ | |
1013 cmhSMS_setStorOcc ( &m1, smsShrdPrm.mem1 ); | |
1014 cmhSMS_setStorOcc ( &m2, smsShrdPrm.mem2 ); | |
1015 cmhSMS_setStorOcc ( &m3, smsShrdPrm.mem3 ); | |
1016 | |
1017 #ifdef FF_ATI | |
1018 cpmsCallType = SAT_CALL; | |
1019 #endif /* FF_ATI */ | |
1020 | |
1021 R_AT ( RAT_CPMS, srcId ) ( &m1, &m2, &m3 ); | |
1022 | |
1023 return( AT_CMPL ); | |
1024 } | |
1025 | |
1026 /* | |
1027 +-------------------------------------------------------------------+ | |
1028 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1029 | STATE : code ROUTINE : sAT_PlusCMGS_Old | | |
1030 +-------------------------------------------------------------------+ | |
1031 | |
1032 PURPOSE : This is the functional counterpart of the +CMSS | |
1033 AT command which is responsible for sending a short | |
1034 message from memory. | |
1035 | |
1036 This function exists for compatibility reasons. | |
1037 | |
1038 */ | |
1039 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
1040 GLOBAL T_ACI_RETURN sAT_PlusCMGS_Old ( T_ACI_CMD_SRC srcId, | |
1041 CHAR* da, | |
1042 T_ACI_TOA* toda, | |
1043 T_ACI_SM_DATA* data, | |
1044 CHAR* sca, | |
1045 T_ACI_TOA* tosca, | |
1046 SHORT isReply ) | |
1047 { | |
1048 TRACE_FUNCTION ("sAT_PlusCMGS_Old ()"); | |
1049 | |
1050 return sAT_PlusCMGS_Gl | |
1051 (srcId, da, toda, data, NULL, sca, tosca, isReply, rAT_PlusCMGS, | |
1052 rAT_PlusCMS); | |
1053 } | |
1054 #endif /*#if defined SMI OR defined MFW OR defined FF_MMI_RIV*/ | |
1055 | |
1056 /* | |
1057 +-------------------------------------------------------------------+ | |
1058 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1059 | STATE : code ROUTINE : sAT_PlusCMGS | | |
1060 +-------------------------------------------------------------------+ | |
1061 | |
1062 PURPOSE : This is the functional counterpart of the +CMGS | |
1063 AT command which is responsible for sending a short | |
1064 message. | |
1065 | |
1066 Features Concatenated SMS. | |
1067 For GPF-MMI. | |
1068 | |
1069 <da>: destination address | |
1070 <toda>: type of destination address | |
1071 <data>: message data | |
1072 <sca>: service center address | |
1073 <tosca>: type of service center address | |
1074 <isReply>: > 0: set TP-Reply-Path explicitly | |
1075 EQ 0: clear TP-Reply-Path explicitly | |
1076 */ | |
1077 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
1078 GLOBAL T_ACI_RETURN sAT_PlusCMGS ( T_ACI_CMD_SRC srcId, | |
1079 CHAR* da, | |
1080 T_ACI_TOA* toda, | |
1081 T_SM_DATA_EXT* src_data, | |
1082 CHAR* sca, | |
1083 T_ACI_TOA* tosca, | |
1084 SHORT isReply ) | |
1085 { | |
1086 T_CONC_INIT_RETURN ret; | |
1087 T_ACI_UDH_DATA udh; | |
1088 | |
1089 T_ACI_SM_DATA tar_data; | |
1090 UBYTE alphabet; | |
1091 | |
1092 TRACE_FUNCTION ("sAT_PlusCMGS ()"); | |
1093 | |
1094 | |
1095 alphabet = cmhSMS_getAlphabetPp ( smsShrdPrm.pSetPrm[srcId]->dcs ); | |
1096 | |
1097 /* cut off more than CONC_MAX_SEGS segments */ | |
1098 if (alphabet EQ 0) | |
1099 { | |
1100 src_data->len = MINIMUM (src_data->len, concShrdPrm.l_uncomp7bit_data_conc*CONC_MAX_SEGS); | |
1101 } | |
1102 else | |
1103 { | |
1104 src_data->len = MINIMUM (src_data->len, concShrdPrm.l_uncomp8bit_data_conc*CONC_MAX_SEGS); | |
1105 } | |
1106 | |
1107 ret=concSMS_initSend(&tar_data, &udh, srcId, da, toda, src_data, sca, | |
1108 tosca, isReply, alphabet); | |
1109 | |
1110 if (ret EQ CONC_NEEDED) | |
1111 { | |
1112 SET_CONC; | |
1113 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, &udh, sca, tosca, | |
1114 isReply, rConcSMS_PlusCMGS, rConcSMS_PlusCMS_CMGS); | |
1115 } | |
1116 else | |
1117 { | |
1118 return sAT_PlusCMGS_Gl(srcId, da, toda, &tar_data, NULL, sca, tosca, | |
1119 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1120 } | |
1121 } | |
1122 #endif /* #if (defined (MFW) OR defined (_CONC_TESTING_) */ | |
1123 | |
1124 /* | |
1125 +-------------------------------------------------------------------+ | |
1126 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1127 | STATE : code ROUTINE : sAT_PlusCMGS | | |
1128 +-------------------------------------------------------------------+ | |
1129 | |
1130 PURPOSE : For Riv-MMI if conc. is not needed. | |
1131 */ | |
1132 #if defined (FF_MMI_RIV) OR !defined TI_PS_FF_CONC_SMS | |
1133 GLOBAL T_ACI_RETURN sAT_PlusCMGS ( T_ACI_CMD_SRC srcId, | |
1134 CHAR* da, | |
1135 T_ACI_TOA* toda, | |
1136 T_ACI_SM_DATA* src_data, | |
1137 CHAR* sca, | |
1138 T_ACI_TOA* tosca, | |
1139 SHORT isReply ) | |
1140 { | |
1141 TRACE_FUNCTION ("sAT_PlusCMGS ()"); | |
1142 | |
1143 return sAT_PlusCMGS_Gl(srcId, da, toda, src_data, NULL, sca, tosca, | |
1144 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1145 } | |
1146 #endif /*#if defined FF_MMI_RIV*/ | |
1147 /* | |
1148 +-------------------------------------------------------------------+ | |
1149 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
1150 | STATE : code ROUTINE : sAT_PercentCMGS | | |
1151 +-------------------------------------------------------------------+ | |
1152 | |
1153 PURPOSE : Handling Percent CMGS command from Riv-MMI side which | |
1154 contains the UDH also for each segment. | |
1155 */ | |
1156 GLOBAL T_ACI_RETURN sAT_PercentCMGS ( T_ACI_CMD_SRC srcId, | |
1157 CHAR* da, | |
1158 T_ACI_TOA* toda, | |
1159 T_ACI_SM_DATA* src_data, | |
1160 T_ACI_UDH_DATA* udh_data, | |
1161 CHAR* sca, | |
1162 T_ACI_TOA* tosca, | |
1163 SHORT isReply ) | |
1164 { | |
1165 TRACE_FUNCTION ("sAT_PercentCMGS () with udh"); | |
1166 | |
1167 return sAT_PlusCMGS_Gl(srcId, da, toda, src_data, udh_data, sca, tosca, | |
1168 isReply, rAT_PlusCMGS, rAT_PlusCMS); | |
1169 } | |
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 | |
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 | |
2356 | |
2357 | |
2358 | |
2359 | |
2360 TRACE_FUNCTION ("sAT_PlusCMGW ()"); | |
2361 | |
2362 return sAT_PlusCMGW_Gl(srcId, index, address, toa, stat, | |
2363 msg_ref, src_data, (T_ACI_UDH_DATA*)NULL, | |
2364 sca, tosca, isReply, | |
2365 rAT_PlusCMGW, rAT_PlusCMS); | |
2366 } | |
2367 | |
2368 /* | |
2369 +-------------------------------------------------------------------+ | |
2370 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2371 | STATE : code ROUTINE : sAT_PercentCMGW | | |
2372 +-------------------------------------------------------------------+ | |
2373 | |
2374 PURPOSE : Adding Percent CMGW command to handle udh and src | |
2375 data for each segment for conc module. | |
2376 | |
2377 For Riv-MMI if conc. is needed. | |
2378 */ | |
2379 GLOBAL T_ACI_RETURN sAT_PercentCMGW ( T_ACI_CMD_SRC srcId, | |
2380 SHORT index, | |
2381 CHAR* address, | |
2382 T_ACI_TOA* toa, | |
2383 T_ACI_SMS_STAT stat, | |
2384 UBYTE msg_ref, | |
2385 T_ACI_SM_DATA* src_data, | |
2386 T_ACI_UDH_DATA* udh_data, | |
2387 CHAR* sca, | |
2388 T_ACI_TOA* tosca, | |
2389 SHORT isReply ) | |
2390 { | |
2391 TRACE_FUNCTION ("sAT_PercentCMGW with udh()"); | |
2392 | |
2393 return sAT_PlusCMGW_Gl(srcId, index, address, toa, stat, | |
2394 msg_ref, src_data, udh_data, | |
2395 sca, tosca, isReply, | |
2396 rAT_PlusCMGW, rAT_PlusCMS); | |
2397 } | |
2398 | |
2399 #endif /*#if defined (FF_MMI_RIV)*/ | |
2400 | |
2401 /* | |
2402 +-------------------------------------------------------------------+ | |
2403 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2404 | STATE : code ROUTINE : sAT_PlusCMGW_Gl | | |
2405 +-------------------------------------------------------------------+ | |
2406 | |
2407 PURPOSE : This is the functional counterpart of the +CMGW | |
2408 AT command which is responsible for writing a short | |
2409 message to memory. | |
2410 | |
2411 <index>: index of location area to be written | |
2412 <address>: originating/destination address | |
2413 <toa>: type of address | |
2414 <stat>: message status | |
2415 <data>: message data | |
2416 <udh>: user data header | |
2417 <sca>: service center address | |
2418 <tosca>: type of service center address | |
2419 <isReply>: > 0: set TP-Reply-Path explicitly | |
2420 EQ 0: clear TP-Reply-Path explicitly | |
2421 <rplyCB>: reply call-back | |
2422 <errorCB>: error call-back | |
2423 */ | |
2424 GLOBAL T_ACI_RETURN sAT_PlusCMGW_Gl ( T_ACI_CMD_SRC srcId, | |
2425 SHORT index, | |
2426 CHAR* address, | |
2427 T_ACI_TOA* toa, | |
2428 T_ACI_SMS_STAT stat, | |
2429 UBYTE msg_ref, | |
2430 T_ACI_SM_DATA* data, | |
2431 T_ACI_UDH_DATA* udh, | |
2432 CHAR* sca, | |
2433 T_ACI_TOA* tosca, | |
2434 SHORT isReply, | |
2435 T_CMGW_FCT rplyCB, | |
2436 T_ERROR_FCT errorCB) | |
2437 { | |
2438 T_SMS_SET_PRM * pSMSSetPrm; /* points to SMS parameter set */ | |
2439 T_ACI_RETURN ret; /* AT response code */ | |
2440 CHAR * restAddress = address; | |
2441 /* address without international access */ | |
2442 /* function characters */ | |
2443 UBYTE chkIdx; /* checked parameter <index> */ | |
2444 UBYTE chkStat; /* checked parameter <stat> */ | |
2445 CHAR* restSca = sca; /* service center address without */ | |
2446 /* international access function */ | |
2447 /* characters */ | |
2448 UBYTE msgType; | |
2449 | |
2450 T_ACI_SM_DATA packedData; | |
2451 T_tp_da da_addr; | |
2452 T_rp_addr sc_addr; | |
2453 UBYTE mr; | |
2454 UBYTE byte_offset = 0; | |
2455 | |
2456 #ifdef _CONC_TESTING_ | |
2457 /* Implements Measure#32 */ | |
2458 #endif | |
2459 | |
2460 TRACE_FUNCTION ("sAT_PlusCMGW_Gl ()"); | |
2461 | |
2462 | |
2463 /* | |
2464 *----------------------------------------------------------------- | |
2465 * check if command executable | |
2466 *----------------------------------------------------------------- | |
2467 */ | |
2468 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2469 return ret; | |
2470 | |
2471 smsShrdPrm.rplyCB.cmgw = rplyCB; | |
2472 smsShrdPrm.errorCB = errorCB; | |
2473 | |
2474 pSMSSetPrm = smsShrdPrm.pSetPrm[srcId]; | |
2475 | |
2476 /* | |
2477 *----------------------------------------------------------------- | |
2478 * process the <index> parameter | |
2479 *----------------------------------------------------------------- | |
2480 */ | |
2481 if( index NEQ ACI_NumParmNotPresent ) | |
2482 { | |
2483 if( ( index > SMS_CMH_IDX_MAX OR index < SMS_CMH_IDX_MIN ) AND | |
2484 index NEQ CMGW_IDX_FREE_ENTRY ) | |
2485 { | |
2486 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2487 return ( AT_FAIL ); | |
2488 } | |
2489 else | |
2490 | |
2491 chkIdx = (UBYTE) index; | |
2492 } | |
2493 else | |
2494 | |
2495 chkIdx = CMGW_IDX_FREE_ENTRY; | |
2496 | |
2497 /* | |
2498 *----------------------------------------------------------------- | |
2499 * process the <address> parameter | |
2500 *----------------------------------------------------------------- | |
2501 */ | |
2502 | |
2503 memset (&da_addr, 0, sizeof(T_tp_da)); | |
2504 if ( address NEQ NULL ) | |
2505 { | |
2506 /* | |
2507 *--------------------------------------------------------------- | |
2508 * process the <toa> parameter | |
2509 *--------------------------------------------------------------- | |
2510 */ | |
2511 if ( toa NEQ NULL ) | |
2512 { | |
2513 da_addr.ton = toa -> ton; | |
2514 da_addr.npi = toa -> npi; | |
2515 } | |
2516 else | |
2517 { | |
2518 restAddress = cmhSMS_setToaDef ( address, | |
2519 &da_addr.ton, | |
2520 &da_addr.npi ); | |
2521 } | |
2522 | |
2523 if ( da_addr.ton EQ TON_Alphanumeric ) | |
2524 { | |
2525 if( cmhSMS_packAlphaNumAddr(restAddress, &da_addr) EQ AT_FAIL ) | |
2526 { | |
2527 return (AT_FAIL); | |
2528 } | |
2529 } | |
2530 else | |
2531 { | |
2532 cmhSMS_getAdrBcd ( da_addr.num, | |
2533 &da_addr.c_num, | |
2534 MAX_SMS_ADDR_DIG, | |
2535 restAddress ); | |
2536 da_addr.digits = da_addr.c_num; | |
2537 } | |
2538 | |
2539 } | |
2540 else /* if ( address NEQ NULL ) */ | |
2541 { | |
2542 /* | |
2543 *--------------------------------------------------------------- | |
2544 * process the <toa> parameter | |
2545 *--------------------------------------------------------------- | |
2546 */ | |
2547 if ( toa NEQ NULL ) | |
2548 { | |
2549 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2550 return ( AT_FAIL ); | |
2551 } | |
2552 else | |
2553 { | |
2554 da_addr.digits = 0; | |
2555 } | |
2556 } | |
2557 | |
2558 /* | |
2559 *----------------------------------------------------------------- | |
2560 * process the <stat> parameter | |
2561 *----------------------------------------------------------------- | |
2562 */ | |
2563 if( stat NEQ SMS_STAT_NotPresent ) | |
2564 { | |
2565 if( !cmhSMS_getStatPsa ( stat, &chkStat ) ) | |
2566 { | |
2567 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2568 return ( AT_FAIL ); | |
2569 } | |
2570 } | |
2571 else | |
2572 { | |
2573 chkStat = STO_UNSENT; | |
2574 } | |
2575 | |
2576 /* | |
2577 *------------------------------------------------------------------- | |
2578 * create and send primitive for SMS store | |
2579 *------------------------------------------------------------------- | |
2580 */ | |
2581 { | |
2582 PALLOC (mnsms_store_req, MNSMS_STORE_REQ); | |
2583 | |
2584 mnsms_store_req -> mem_type = smsShrdPrm.mem2; | |
2585 if (chkIdx EQ CMGW_IDX_FREE_ENTRY) | |
2586 mnsms_store_req -> condx = SMS_CONDX_OVR_NON; | |
2587 else | |
2588 mnsms_store_req -> condx = SMS_CONDX_OVR_ANY; | |
2589 | |
2590 /* | |
2591 *----------------------------------------------------------------- | |
2592 * process the <sca> parameter | |
2593 *----------------------------------------------------------------- | |
2594 */ | |
2595 if ( sca NEQ NULL AND *sca NEQ '\0' ) | |
2596 { | |
2597 /* | |
2598 *--------------------------------------------------------------- | |
2599 * process the <tosca> parameter | |
2600 *--------------------------------------------------------------- | |
2601 */ | |
2602 if ( tosca NEQ NULL ) | |
2603 { | |
2604 sc_addr.ton = tosca -> ton; | |
2605 sc_addr.npi = tosca -> npi; | |
2606 } | |
2607 else | |
2608 { | |
2609 restSca = cmhSMS_setToaDef( sca, &sc_addr.ton, | |
2610 &sc_addr.npi); | |
2611 } | |
2612 cmhSMS_getAdrBcd( sc_addr.num, | |
2613 &sc_addr.c_num, | |
2614 MAX_SMS_ADDR_DIG, | |
2615 restSca); | |
2616 } | |
2617 else | |
2618 { | |
2619 memcpy (&sc_addr, &pSMSSetPrm->sca, sizeof(T_rp_addr)); | |
2620 } | |
2621 | |
2622 /* | |
2623 *----------------------------------------------------------------- | |
2624 * process the <isReply> parameter | |
2625 *----------------------------------------------------------------- | |
2626 */ | |
2627 msgType = (pSMSSetPrm->msgType & ~TP_MTI_MASK) | |
2628 | TP_MTI_SMS_SUBMIT; | |
2629 if (isReply EQ 0) | |
2630 msgType &= ~TP_RP_MASK; /* set TP-Reply-Path bit to 0 */ | |
2631 else if (isReply > 0) | |
2632 msgType |= TP_RP_MASK; /* set TP-Reply-Path bit to 1 */ | |
2633 | |
2634 /* | |
2635 *----------------------------------------------------------------- | |
2636 * copy parameter | |
2637 *----------------------------------------------------------------- | |
2638 */ | |
2639 mnsms_store_req->rec_num = chkIdx; | |
2640 mnsms_store_req->status = chkStat; | |
2641 | |
2642 /* | |
2643 *----------------------------------------------------------------- | |
2644 * process the <msg_ref> parameter | |
2645 *----------------------------------------------------------------- | |
2646 */ | |
2647 if (msg_ref EQ NOT_PRESENT_8BIT) | |
2648 { | |
2649 mr = 0; | |
2650 } | |
2651 else | |
2652 { | |
2653 mr = msg_ref; | |
2654 } | |
2655 | |
2656 /* | |
2657 *----------------------------------------------------------------- | |
2658 * process the <data> parameter and | |
2659 * copy already to shared parameter | |
2660 *----------------------------------------------------------------- | |
2661 * reducing from 8 to 7 bit | |
2662 *----------------------------------------------------------------- | |
2663 */ | |
2664 if (udh) | |
2665 byte_offset = udh->len+1; | |
2666 | |
2667 if (data EQ NULL) | |
2668 { | |
2669 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2670 PFREE (mnsms_store_req); | |
2671 | |
2672 return ( AT_FAIL ); | |
2673 } | |
2674 | |
2675 cmhSMS_rdcSmsPp ( byte_offset, | |
2676 pSMSSetPrm -> dcs, | |
2677 ( UBYTE * ) data->data, ( UBYTE ) data->len, | |
2678 packedData.data, &packedData.len); | |
2679 | |
2680 if ( (chkStat EQ REC_UNREAD) OR (chkStat EQ REC_READ) ) | |
2681 { | |
2682 ACI_MALLOC(smsShrdPrm.tpdu.tp_deliver, sizeof(T_TP_DELIVER)); | |
2683 cmhSMS_fillTpDeliver (smsShrdPrm.tpdu.tp_deliver, | |
2684 srcId, | |
2685 msgType, | |
2686 (T_tp_oa *)&da_addr, | |
2687 &packedData, | |
2688 (UBYTE)data->len, | |
2689 udh ); | |
2690 | |
2691 /* code encode SMS-DELIVER here */ | |
2692 cmhSMS_codeMsg (&mnsms_store_req->sms_sdu, | |
2693 SMS_VT_DELIVER, | |
2694 &sc_addr, | |
2695 SMS_DELIVER, | |
2696 (UBYTE*)smsShrdPrm.tpdu.tp_deliver); | |
2697 | |
2698 PSENDX (SMS, mnsms_store_req); | |
2699 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
2700 if (smsShrdPrm.tpdu.tp_deliver NEQ NULL) | |
2701 { | |
2702 ACI_MFREE(smsShrdPrm.tpdu.tp_deliver); | |
2703 smsShrdPrm.tpdu.tp_deliver = NULL; | |
2704 } | |
2705 } | |
2706 else | |
2707 { | |
2708 ACI_MALLOC(smsShrdPrm.tpdu.tp_submit, sizeof(T_TP_SUBMIT)); | |
2709 cmhSMS_fillTpSubmit (smsShrdPrm.tpdu.tp_submit, | |
2710 srcId, | |
2711 msgType, | |
2712 mr, | |
2713 &da_addr, | |
2714 &packedData, | |
2715 data->len, | |
2716 udh ); | |
2717 | |
2718 /* encode SMS-SUBMIT here */ | |
2719 cmhSMS_codeMsg (&mnsms_store_req->sms_sdu, | |
2720 SMS_VT_SUBMIT, | |
2721 &sc_addr, | |
2722 SMS_SUBMIT, | |
2723 (UBYTE*)smsShrdPrm.tpdu.tp_submit); | |
2724 | |
2725 PSENDX (SMS, mnsms_store_req); | |
2726 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
2727 #ifdef _CONC_TESTING_ | |
2728 TRACE_EVENT_P1("cmgw:rec_num: %d", mnsms_store_req->rec_num); | |
2729 TRACE_EVENT_P1("cmgw:status: %d", mnsms_store_req->status); | |
2730 TRACE_EVENT_P1("cmgw:mem_type:%d", mnsms_store_req -> mem_type); | |
2731 TRACE_EVENT_P1("cmgw:condx: %d", mnsms_store_req -> condx); | |
2732 /* Implements Measure#32 */ | |
2733 cmhSMS_sdu_buf_print(&(mnsms_store_req->sms_sdu.buf[0]), 0); | |
2734 #endif | |
2735 if (smsShrdPrm.tpdu.tp_submit NEQ NULL) | |
2736 { | |
2737 ACI_MFREE(smsShrdPrm.tpdu.tp_submit); | |
2738 smsShrdPrm.tpdu.tp_submit = NULL; | |
2739 } | |
2740 } | |
2741 } | |
2742 | |
2743 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGW; | |
2744 smsShrdPrm.owner = (T_OWN)srcId; | |
2745 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2746 | |
2747 return( AT_EXCT ); | |
2748 } | |
2749 | |
2750 #if defined (SMS_PDU_SUPPORT) | |
2751 | |
2752 /* | |
2753 +-------------------------------------------------------------------+ | |
2754 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2755 | STATE : code ROUTINE : sAT_PlusCMGWPdu | | |
2756 +-------------------------------------------------------------------+ | |
2757 | |
2758 PURPOSE : This is the functional counterpart of the +CMGW | |
2759 AT command which is responsible for writing a short | |
2760 message to memory in PDU mode. | |
2761 | |
2762 */ | |
2763 | |
2764 GLOBAL T_ACI_RETURN sAT_PlusCMGWPdu ( T_ACI_CMD_SRC srcId, | |
2765 UBYTE stat, | |
2766 T_ACI_SM_DATA *pdu) | |
2767 { | |
2768 T_ACI_RETURN ret; /* AT response code */ | |
2769 UBYTE chkStat = '\0'; /* checked parameter <stat> */ | |
2770 | |
2771 TRACE_FUNCTION ("sAT_PlusCMGWPdu ()"); | |
2772 | |
2773 /* | |
2774 *----------------------------------------------------------------- | |
2775 * check if command executable | |
2776 *----------------------------------------------------------------- | |
2777 */ | |
2778 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2779 return ret; | |
2780 | |
2781 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
2782 smsShrdPrm.errorCB = rAT_PlusCMS; | |
2783 #endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */ | |
2784 | |
2785 /* | |
2786 *----------------------------------------------------------------- | |
2787 * process the <stat> parameter | |
2788 *----------------------------------------------------------------- | |
2789 */ | |
2790 switch (stat) | |
2791 { | |
2792 case SMS_STAT_RecUnread: | |
2793 chkStat = REC_UNREAD; | |
2794 break; | |
2795 case SMS_STAT_RecRead: | |
2796 chkStat = REC_READ; | |
2797 break; | |
2798 case SMS_STAT_StoUnsent: | |
2799 chkStat = STO_UNSENT; | |
2800 break; | |
2801 case SMS_STAT_StoSent: | |
2802 chkStat = STO_SENT; | |
2803 break; | |
2804 } | |
2805 | |
2806 /* | |
2807 *------------------------------------------------------------------- | |
2808 * create and send primitive for SMS store | |
2809 *------------------------------------------------------------------- | |
2810 */ | |
2811 { | |
2812 PALLOC (mnsms_store_req, MNSMS_STORE_REQ); | |
2813 | |
2814 mnsms_store_req -> mem_type = smsShrdPrm.mem2; | |
2815 mnsms_store_req -> rec_num = CMGW_IDX_FREE_ENTRY; | |
2816 mnsms_store_req -> condx = SMS_CONDX_OVR_NON; | |
2817 mnsms_store_req -> status = chkStat; | |
2818 | |
2819 if ( pdu->len > 0 ) | |
2820 { | |
2821 mnsms_store_req->sms_sdu.l_buf = pdu->len * 8; | |
2822 mnsms_store_req->sms_sdu.o_buf = 0; | |
2823 memcpy (mnsms_store_req->sms_sdu.buf, pdu->data, pdu->len); | |
2824 } | |
2825 else | |
2826 { | |
2827 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2828 PFREE (mnsms_store_req); | |
2829 return ( AT_FAIL ); | |
2830 } | |
2831 | |
2832 PSENDX (SMS, mnsms_store_req); | |
2833 } | |
2834 | |
2835 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGW; | |
2836 smsShrdPrm.owner = (T_OWN)srcId; | |
2837 smsShrdPrm.smsEntStat.entOwn = srcId; | |
2838 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
2839 | |
2840 return( AT_EXCT ); | |
2841 } | |
2842 | |
2843 #endif | |
2844 | |
2845 | |
2846 /* | |
2847 +-------------------------------------------------------------------+ | |
2848 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2849 | STATE : code ROUTINE : sAT_PlusCMGC | | |
2850 +-------------------------------------------------------------------+ | |
2851 | |
2852 PURPOSE : This is the functional counterpart of the +CMGC | |
2853 AT command which is responsible for sending a command. | |
2854 | |
2855 Features Concatenated SMS. | |
2856 For GPF-MMI. | |
2857 | |
2858 <fo>: first octet of SMS-COMMAND | |
2859 <ct>: command type | |
2860 <pid>: protocol identifier | |
2861 <mn>: message number | |
2862 <da>: destination address | |
2863 <toda>: type of destination address | |
2864 <data>: command data | |
2865 */ | |
2866 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
2867 GLOBAL T_ACI_RETURN sAT_PlusCMGC ( T_ACI_CMD_SRC srcId, | |
2868 SHORT fo, | |
2869 SHORT ct, | |
2870 SHORT pid, | |
2871 SHORT mn, | |
2872 CHAR* da, | |
2873 T_ACI_TOA* toda, | |
2874 T_ACI_CMD_DATA* data ) | |
2875 { | |
2876 T_CONC_INIT_RETURN ret; | |
2877 | |
2878 TRACE_FUNCTION ("sAT_PlusCMGC ()"); | |
2879 | |
2880 | |
2881 ret=concSMS_initCommand (srcId, fo, ct, pid, mn, da, toda, | |
2882 data); | |
2883 | |
2884 if (ret EQ CONC_NEEDED) | |
2885 { | |
2886 SET_CONC; | |
2887 return sAT_PlusCMGC_Gl(srcId, fo, ct, pid, mn, da, toda, | |
2888 data, rConcSMS_PlusCMGC); | |
2889 } | |
2890 else if (ret EQ CONC_NOT_NEEDED) | |
2891 { | |
2892 return sAT_PlusCMGC_Gl(srcId, fo, ct, pid, mn, da, toda, | |
2893 data, rAT_PlusCMGC); | |
2894 } | |
2895 else | |
2896 { | |
2897 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_UnknownErr ); | |
2898 return ( AT_FAIL ); | |
2899 } | |
2900 } | |
2901 #endif /*#if defined (MFW) OR defined (_CONC_TESTING_)*/ | |
2902 | |
2903 /* | |
2904 +-------------------------------------------------------------------+ | |
2905 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2906 | STATE : code ROUTINE : sAT_PlusCMGC | | |
2907 +-------------------------------------------------------------------+ | |
2908 | |
2909 PURPOSE : New Plus CMGC command for handling the conc module on | |
2910 the Riv-MMI side. | |
2911 */ | |
2912 #if defined (FF_MMI_RIV) OR !defined TI_PS_FF_CONC_SMS | |
2913 GLOBAL T_ACI_RETURN sAT_PlusCMGC ( T_ACI_CMD_SRC srcId, | |
2914 SHORT fo, | |
2915 SHORT ct, | |
2916 SHORT pid, | |
2917 SHORT mn, | |
2918 CHAR* da, | |
2919 T_ACI_TOA* toda, | |
2920 T_ACI_CMD_DATA* data ) | |
2921 { | |
2922 TRACE_FUNCTION ("sAT_PlusCMGC ()"); | |
2923 TRACE_EVENT_P1("sAT_PlusCMGC () mn: %d", mn); | |
2924 | |
2925 return sAT_PlusCMGC_Gl(srcId, fo, ct, pid, mn, da, toda, | |
2926 data, rAT_PlusCMGC); | |
2927 } | |
2928 #endif /*#if defined (FF_MMI_RIV)*/ | |
2929 | |
2930 /* | |
2931 +-------------------------------------------------------------------+ | |
2932 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
2933 | STATE : code ROUTINE : sAT_PlusCMGC_Gl | | |
2934 +-------------------------------------------------------------------+ | |
2935 | |
2936 PURPOSE : This is the functional counterpart of the +CMGC | |
2937 AT command which is responsible for sending a command. | |
2938 | |
2939 <fo>: first octet of SMS-COMMAND | |
2940 <ct>: command type | |
2941 <pid>: protocol identifier | |
2942 <mn>: message number | |
2943 <da>: destination address | |
2944 <toda>: type of destination address | |
2945 <data>: command data | |
2946 <rplyCB>: reply call-back | |
2947 */ | |
2948 GLOBAL T_ACI_RETURN sAT_PlusCMGC_Gl ( T_ACI_CMD_SRC srcId, | |
2949 SHORT fo, | |
2950 SHORT ct, | |
2951 SHORT pid, | |
2952 SHORT mn, | |
2953 CHAR* da, | |
2954 T_ACI_TOA* toda, | |
2955 T_ACI_CMD_DATA* data, | |
2956 T_CMGC_FCT rplyCB ) | |
2957 { | |
2958 T_ACI_RETURN ret; /* AT response code */ | |
2959 UBYTE chkFo; /* checked parameter <fo> */ | |
2960 UBYTE chkPid; /* checked parameter <pid> */ | |
2961 UBYTE chkCt; /* checked parameter <ct> */ | |
2962 UBYTE chkMn; /* checked parameter <mn> */ | |
2963 CHAR* restDa = da; /* destination address without */ | |
2964 /* international access function */ | |
2965 /* characters */ | |
2966 T_tp_da da_addr; /* destination address */ | |
2967 | |
2968 TRACE_FUNCTION ("sAT_PlusCMGC_Gl ()"); | |
2969 | |
2970 /* | |
2971 *----------------------------------------------------------------- | |
2972 * check if command executable | |
2973 *----------------------------------------------------------------- | |
2974 */ | |
2975 if(!cmhSMS_checkAccess (srcId, &ret)) | |
2976 return ret; | |
2977 | |
2978 smsShrdPrm.rplyCB.cmgc = rplyCB; | |
2979 /* | |
2980 *----------------------------------------------------------------- | |
2981 * process the <fo> parameter | |
2982 *----------------------------------------------------------------- | |
2983 */ | |
2984 if( fo NEQ ACI_NumParmNotPresent ) | |
2985 { | |
2986 if( fo > SMS_CMH_FO_MAX OR fo < SMS_CMH_FO_MIN OR | |
2987 ( fo & TP_MTI_MASK ) NEQ TP_MTI_SMS_COMMAND ) | |
2988 { | |
2989 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
2990 return ( AT_FAIL ); | |
2991 } | |
2992 else | |
2993 | |
2994 chkFo = (UBYTE) fo; | |
2995 | |
2996 } | |
2997 else | |
2998 | |
2999 chkFo = TP_MTI_SMS_COMMAND; | |
3000 | |
3001 /* | |
3002 *----------------------------------------------------------------- | |
3003 * process the <ct> parameter | |
3004 *----------------------------------------------------------------- | |
3005 */ | |
3006 if( ct NEQ ACI_NumParmNotPresent ) | |
3007 { | |
3008 if( ct > SMS_CMH_CT_MAX OR ct < SMS_CMH_CT_MIN ) | |
3009 { | |
3010 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3011 return ( AT_FAIL ); | |
3012 } | |
3013 else | |
3014 | |
3015 chkCt = (UBYTE) ct; | |
3016 | |
3017 } | |
3018 else | |
3019 /* | |
3020 * set to default value | |
3021 */ | |
3022 chkCt = SMS_CT_ENQUIRY; | |
3023 | |
3024 /* | |
3025 *----------------------------------------------------------------- | |
3026 * process the <pid> parameter | |
3027 *----------------------------------------------------------------- | |
3028 */ | |
3029 if( pid NEQ ACI_NumParmNotPresent ) | |
3030 { | |
3031 if( pid > SMS_CMH_PID_MAX OR pid < SMS_CMH_PID_MIN ) | |
3032 { | |
3033 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3034 return ( AT_FAIL ); | |
3035 } | |
3036 else | |
3037 | |
3038 chkPid = (UBYTE) pid; | |
3039 } | |
3040 else | |
3041 | |
3042 /* | |
3043 * set to default value | |
3044 */ | |
3045 chkPid = SMS_PID_DEFAULT; | |
3046 | |
3047 /* | |
3048 *----------------------------------------------------------------- | |
3049 * process the <mn> parameter | |
3050 *----------------------------------------------------------------- | |
3051 */ | |
3052 if( mn NEQ ACI_NumParmNotPresent ) | |
3053 { | |
3054 if( mn > SMS_CMH_MN_MAX OR mn < SMS_CMH_MN_MIN ) | |
3055 { | |
3056 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3057 return ( AT_FAIL ); | |
3058 } | |
3059 else | |
3060 | |
3061 chkMn = (UBYTE) mn; | |
3062 } | |
3063 else | |
3064 { | |
3065 chkMn = smsShrdPrm.aci_sms_parameter.snd_msg_ref; | |
3066 } | |
3067 | |
3068 /* | |
3069 *--------------------------------------------------------------- | |
3070 * process the <da> and <toda> parameter | |
3071 *--------------------------------------------------------------- | |
3072 */ | |
3073 if ( toda NEQ NULL ) | |
3074 { | |
3075 if ( da NEQ NULL ) | |
3076 { | |
3077 da_addr.ton = toda -> ton; | |
3078 da_addr.npi = toda -> npi; | |
3079 cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, restDa); | |
3080 da_addr.digits = da_addr.c_num; | |
3081 } | |
3082 else | |
3083 { | |
3084 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3085 return ( AT_FAIL ); | |
3086 } | |
3087 } | |
3088 else | |
3089 { | |
3090 if ( da NEQ NULL ) | |
3091 { | |
3092 restDa = cmhSMS_setToaDef ( da, &da_addr.ton, &da_addr.npi ); | |
3093 cmhSMS_getAdrBcd ( da_addr.num, &da_addr.c_num, MAX_SMS_ADDR_DIG, restDa); | |
3094 da_addr.digits = da_addr.c_num; | |
3095 } | |
3096 else | |
3097 { | |
3098 da_addr.digits = 0; | |
3099 } | |
3100 } | |
3101 | |
3102 /* | |
3103 *------------------------------------------------------------------- | |
3104 * create and send primitive for command request | |
3105 *------------------------------------------------------------------- | |
3106 */ | |
3107 { | |
3108 PALLOC (mnsms_command_req, MNSMS_COMMAND_REQ); | |
3109 | |
3110 ACI_MALLOC(smsShrdPrm.tpdu.tp_command, sizeof(T_TP_COMMAND)); | |
3111 cmhSMS_fillTpCommand( smsShrdPrm.tpdu.tp_command, | |
3112 chkFo, | |
3113 chkCt, | |
3114 0, | |
3115 chkPid, | |
3116 chkMn, | |
3117 &da_addr, | |
3118 data, | |
3119 NULL); | |
3120 | |
3121 #ifdef REL99 | |
3122 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
3123 { | |
3124 mnsms_command_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
3125 } | |
3126 else | |
3127 { | |
3128 mnsms_command_req -> auto_rep_flag = FALSE; | |
3129 } | |
3130 #endif | |
3131 | |
3132 /* code command here */ | |
3133 cmhSMS_codeMsg (&mnsms_command_req->sms_sdu, | |
3134 SMS_VT_COMMAND, | |
3135 &smsShrdPrm.pSetPrm[srcId]->sca, | |
3136 SMS_COMMAND, | |
3137 (UBYTE*)smsShrdPrm.tpdu.tp_command); | |
3138 | |
3139 PSENDX (SMS, mnsms_command_req); | |
3140 | |
3141 if (smsShrdPrm.tpdu.tp_command NEQ NULL) | |
3142 { | |
3143 ACI_MFREE(smsShrdPrm.tpdu.tp_command); | |
3144 smsShrdPrm.tpdu.tp_command = NULL; | |
3145 } | |
3146 } | |
3147 | |
3148 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGC; | |
3149 smsShrdPrm.owner = (T_OWN)srcId; | |
3150 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3151 | |
3152 return( AT_EXCT ); | |
3153 } | |
3154 | |
3155 | |
3156 #if defined (SMS_PDU_SUPPORT) || defined (SIM_TOOLKIT) | |
3157 | |
3158 /* | |
3159 +-------------------------------------------------------------------+ | |
3160 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3161 | STATE : code ROUTINE : sAT_PlusCMGCPdu | | |
3162 +-------------------------------------------------------------------+ | |
3163 | |
3164 PURPOSE : This is the functional counterpart of the +CMGC | |
3165 AT command which is responsible for sending a command | |
3166 message in pdu mode. | |
3167 | |
3168 */ | |
3169 GLOBAL T_ACI_RETURN sAT_PlusCMGCPdu ( T_ACI_CMD_SRC srcId, | |
3170 T_ACI_SM_DATA *pdu ) | |
3171 { | |
3172 T_ACI_RETURN ret; /* AT response code */ | |
3173 | |
3174 TRACE_FUNCTION ("sAT_PlusCMGCPdu ()"); | |
3175 | |
3176 /* | |
3177 *----------------------------------------------------------------- | |
3178 * check if command executable | |
3179 *----------------------------------------------------------------- | |
3180 */ | |
3181 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3182 return ret; | |
3183 | |
3184 #if defined SMI OR defined MFW OR defined FF_MMI_RIV | |
3185 smsShrdPrm.rplyCB.cmgc = rAT_PlusCMGC; | |
3186 smsShrdPrm.errorCB = rAT_PlusCMS; | |
3187 #endif /* defined SMI OR defined MFW OR defined FF_MMI_RIV */ | |
3188 | |
3189 /* | |
3190 *------------------------------------------------------------------- | |
3191 * create and send primitive for SMS command | |
3192 *------------------------------------------------------------------- | |
3193 */ | |
3194 { | |
3195 PALLOC (mnsms_command_req, MNSMS_COMMAND_REQ); | |
3196 #ifdef REL99 | |
3197 if(srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT) | |
3198 { | |
3199 mnsms_command_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
3200 } | |
3201 else | |
3202 { | |
3203 mnsms_command_req -> auto_rep_flag = FALSE; | |
3204 } | |
3205 #endif /* REL99 */ | |
3206 | |
3207 if ( pdu->len > 0 ) | |
3208 { | |
3209 mnsms_command_req->sms_sdu.l_buf = pdu->len * 8; | |
3210 mnsms_command_req->sms_sdu.o_buf = 0; | |
3211 memcpy (mnsms_command_req->sms_sdu.buf, pdu->data, pdu->len); | |
3212 } | |
3213 else | |
3214 { | |
3215 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3216 PFREE (mnsms_command_req); | |
3217 return ( AT_FAIL ); | |
3218 } | |
3219 | |
3220 PSENDX (SMS, mnsms_command_req); | |
3221 } | |
3222 | |
3223 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGC; | |
3224 smsShrdPrm.owner = (T_OWN)srcId; | |
3225 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3226 | |
3227 return( AT_EXCT ); | |
3228 } | |
3229 #endif | |
3230 | |
3231 | |
3232 /* | |
3233 +-------------------------------------------------------------------+ | |
3234 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3235 | STATE : code ROUTINE : sAT_PlusCMGR | | |
3236 +-------------------------------------------------------------------+ | |
3237 | |
3238 PURPOSE : This is the functional counterpart of the +CMGR | |
3239 AT command which is responsible for reading a short | |
3240 message from memory. | |
3241 | |
3242 Features Concatenated SMS. | |
3243 For GPF-MMI. | |
3244 | |
3245 <index>: storage area index | |
3246 <rdMode>: read mode | |
3247 */ | |
3248 #if (defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
3249 GLOBAL T_ACI_RETURN sAT_PlusCMGR ( T_ACI_CMD_SRC srcId, | |
3250 UBYTE index, | |
3251 T_ACI_SMS_READ rdMode ) | |
3252 { | |
3253 T_CONC_INIT_RETURN ret; | |
3254 | |
3255 TRACE_FUNCTION ("sAT_PlusCMGR ()"); | |
3256 | |
3257 TRACE_EVENT_P1("sAT_PlusCMGR () index: %d", index); | |
3258 | |
3259 ret=concSMS_initReadFromMem(srcId, index, rdMode); | |
3260 | |
3261 if (ret EQ CONC_NEEDED) | |
3262 { | |
3263 SET_CONC; | |
3264 TRACE_EVENT("sAT_PlusCMGR: CONC_NEEDED"); | |
3265 | |
3266 /* memorize mem1, this is for rConcSMS_PlusCMGR */ | |
3267 concShrdPrm.mem_store = smsShrdPrm.mem1; | |
3268 | |
3269 return sAT_PlusCMGR_Gl(srcId, index, rdMode, rConcSMS_PlusCMGR); | |
3270 } | |
3271 else if (ret EQ CONC_NOT_NEEDED) | |
3272 { | |
3273 TRACE_EVENT("sAT_PlusCMGR: CONC_NOT_NEEDED"); | |
3274 return sAT_PlusCMGR_Gl(srcId, index, rdMode, rAT_PlusCMGR); | |
3275 } | |
3276 else | |
3277 { | |
3278 TRACE_EVENT("ERROR: sAT_PlusCMGR: CMS_ERR_InValMemIdx"); | |
3279 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
3280 return ( AT_FAIL ); | |
3281 } | |
3282 } | |
3283 #endif /*#if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)*/ | |
3284 | |
3285 /* | |
3286 +-------------------------------------------------------------------+ | |
3287 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3288 | STATE : code ROUTINE : sAT_PlusCMGR | | |
3289 +-------------------------------------------------------------------+ | |
3290 | |
3291 PURPOSE : New Plus CMGR command for handling the conc module on | |
3292 the Riv-MMI side. | |
3293 */ | |
3294 #if defined (FF_MMI_RIV) OR !defined TI_PS_FF_CONC_SMS | |
3295 GLOBAL T_ACI_RETURN sAT_PlusCMGR ( T_ACI_CMD_SRC srcId, | |
3296 UBYTE index, | |
3297 T_ACI_SMS_READ rdMode ) | |
3298 { | |
3299 TRACE_FUNCTION ("sAT_PlusCMGR ()"); | |
3300 | |
3301 TRACE_EVENT_P1("sAT_PlusCMGR () index: %d", index); | |
3302 | |
3303 return sAT_PlusCMGR_Gl(srcId, index, rdMode, rAT_PlusCMGR); | |
3304 } | |
3305 #endif /*#if defined (FF_MMI_RIV)*/ | |
3306 | |
3307 | |
3308 /* | |
3309 +-------------------------------------------------------------------+ | |
3310 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3311 | STATE : code ROUTINE : sAT_PlusCMGR_Gl | | |
3312 +-------------------------------------------------------------------+ | |
3313 | |
3314 PURPOSE : This is the functional counterpart of the +CMGR | |
3315 AT command which is responsible for reading a short | |
3316 message from memory. | |
3317 | |
3318 <index>: storage area index | |
3319 <rdMode>: read mode | |
3320 <rplyCB>: reply call-back | |
3321 <errorCB>: error call-back | |
3322 */ | |
3323 GLOBAL T_ACI_RETURN sAT_PlusCMGR_Gl ( T_ACI_CMD_SRC srcId, | |
3324 UBYTE index, | |
3325 T_ACI_SMS_READ rdMode, | |
3326 T_CMGR_FCT rplyCB ) | |
3327 { | |
3328 T_ACI_RETURN ret = AT_EXCT; | |
3329 | |
3330 TRACE_FUNCTION ("sAT_PlusCMGR_Gl ()"); | |
3331 | |
3332 /* | |
3333 *----------------------------------------------------------------- | |
3334 * check if command executable | |
3335 *----------------------------------------------------------------- | |
3336 */ | |
3337 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3338 { | |
3339 return ret; | |
3340 } | |
3341 | |
3342 smsShrdPrm.rplyCB.cmgr = rplyCB; | |
3343 | |
3344 | |
3345 /* | |
3346 *----------------------------------------------------------------- | |
3347 * process the <index> parameter | |
3348 *----------------------------------------------------------------- | |
3349 */ | |
3350 switch (rdMode) | |
3351 { | |
3352 case SMS_READ_StatusChange: | |
3353 /* ret = AT_CMPL; Change to AT_EXCT, call back expected */ | |
3354 smsShrdPrm.rdMode = READ_STATUS_CHANGE; | |
3355 break; | |
3356 case SMS_READ_Preview: | |
3357 smsShrdPrm.rdMode = READ_PREVIEW; | |
3358 break; | |
3359 case SMS_READ_Normal: | |
3360 case SMS_READ_NotPresent: | |
3361 smsShrdPrm.rdMode = READ_NORMAL; | |
3362 break; | |
3363 default: | |
3364 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3365 return ( AT_FAIL ); | |
3366 } | |
3367 /* | |
3368 *----------------------------------------------------------------- | |
3369 * read a short message from memory | |
3370 *----------------------------------------------------------------- | |
3371 */ | |
3372 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGR; | |
3373 smsShrdPrm.owner = (T_OWN)srcId; | |
3374 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3375 | |
3376 psaSMS_ReadReq ( smsShrdPrm.mem1, index, | |
3377 smsShrdPrm.rdMode, SMS_STAT_NotPresent); | |
3378 | |
3379 return( ret ); | |
3380 } | |
3381 | |
3382 /* | |
3383 +-------------------------------------------------------------------+ | |
3384 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3385 | STATE : code ROUTINE : sAT_PlusCSCB | | |
3386 +-------------------------------------------------------------------+ | |
3387 | |
3388 PURPOSE : This is the functional counterpart of the +CSCB | |
3389 AT command which is responsible for selecting the | |
3390 cell broadcast message types. | |
3391 | |
3392 <mode>: acception mode | |
3393 <mids>: message identifiers | |
3394 <dcss>: data coding schemes | |
3395 */ | |
3396 GLOBAL T_ACI_RETURN sAT_PlusCSCB ( T_ACI_CMD_SRC srcId, | |
3397 T_ACI_CSCB_MOD mode, | |
3398 USHORT* mids, | |
3399 UBYTE* dcss) | |
3400 { | |
3401 UBYTE chkMode; /* checked parameter <mode> */ | |
3402 USHORT chkMids[MAX_IDENTS]; /* checked parameter <mids> */ | |
3403 UBYTE chkDcss[MAX_IDENTS]; /* checked parameter <dcss> */ | |
3404 int i; /* used for counting */ | |
3405 | |
3406 TRACE_FUNCTION ("sAT_PlusCSCB ()"); | |
3407 | |
3408 /* | |
3409 *----------------------------------------------------------------- | |
3410 * check command source | |
3411 *----------------------------------------------------------------- | |
3412 */ | |
3413 if(!cmh_IsVldCmdSrc (srcId)) | |
3414 { | |
3415 return( AT_FAIL ); | |
3416 } | |
3417 | |
3418 /* | |
3419 *----------------------------------------------------------------- | |
3420 * check access status | |
3421 *----------------------------------------------------------------- | |
3422 */ | |
3423 if (!cmhSMS_checkSIM ()) /* sets error code */ | |
3424 { | |
3425 return( AT_FAIL ); | |
3426 } | |
3427 | |
3428 /* | |
3429 *----------------------------------------------------------------- | |
3430 * check entity status | |
3431 *----------------------------------------------------------------- | |
3432 */ | |
3433 if( smsShrdPrm.cbmPrm.cbchOwner NEQ ((T_OWN)CMD_SRC_NONE) ) | |
3434 { | |
3435 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3436 return( AT_BUSY ); | |
3437 } | |
3438 | |
3439 /* | |
3440 *----------------------------------------------------------------- | |
3441 * process the <mode> parameter | |
3442 *----------------------------------------------------------------- | |
3443 */ | |
3444 switch ( mode ) | |
3445 { | |
3446 case (CSCB_MOD_NotPresent): chkMode = smsShrdPrm.cbmPrm.cbmMode; break; | |
3447 case (CSCB_MOD_Accept ): chkMode = CBCH_ACCEPT; break; | |
3448 case (CSCB_MOD_NotAccept ): chkMode = CBCH_IGNORE; break; | |
3449 | |
3450 default: | |
3451 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3452 return ( AT_FAIL ); | |
3453 } | |
3454 | |
3455 /* | |
3456 *----------------------------------------------------------------- | |
3457 * process the <mids> parameter | |
3458 *----------------------------------------------------------------- | |
3459 */ | |
3460 if( mids NEQ NULL ) | |
3461 | |
3462 memcpy ( ( CHAR * ) chkMids, ( CHAR * ) mids, sizeof (chkMids) ); | |
3463 | |
3464 else | |
3465 | |
3466 memcpy ( ( CHAR * ) chkMids, ( CHAR * ) smsShrdPrm.cbmPrm.msgId, | |
3467 sizeof ( chkMids ) ); | |
3468 | |
3469 /* | |
3470 *----------------------------------------------------------------- | |
3471 * process the <dcss> parameter | |
3472 *----------------------------------------------------------------- | |
3473 */ | |
3474 if( dcss NEQ NULL ) | |
3475 { | |
3476 i = 0; | |
3477 | |
3478 while ( i < MAX_IDENTS AND dcss[i] NEQ DEF_DCS_RANGE ) | |
3479 { | |
3480 /* Lint: this cannot happen | |
3481 if( dcss[i] > SMS_CMH_DCS_MAX OR dcss[i] < SMS_CMH_DCS_MIN ) | |
3482 { | |
3483 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3484 return ( AT_FAIL ); | |
3485 } | |
3486 else | |
3487 */ | |
3488 i++; | |
3489 } | |
3490 | |
3491 if ( i % 2 NEQ 0 ) | |
3492 { | |
3493 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3494 return ( AT_FAIL ); | |
3495 } | |
3496 | |
3497 memcpy ( ( CHAR * ) chkDcss, ( CHAR * ) dcss, sizeof (chkDcss) ); | |
3498 } | |
3499 else | |
3500 | |
3501 memcpy ( ( CHAR * ) chkDcss, ( CHAR * ) smsShrdPrm.cbmPrm.dcsId, | |
3502 sizeof ( chkDcss ) ); | |
3503 | |
3504 /* | |
3505 *----------------------------------------------------------------- | |
3506 * copy parameter | |
3507 *----------------------------------------------------------------- | |
3508 */ | |
3509 memcpy ( ( CHAR * ) smsShrdPrm.cbmPrm.msgId, | |
3510 ( CHAR * ) chkMids, | |
3511 sizeof ( smsShrdPrm.cbmPrm.msgId ) ); | |
3512 | |
3513 memcpy ( ( CHAR * ) smsShrdPrm.cbmPrm.dcsId, | |
3514 ( CHAR * ) chkDcss, | |
3515 sizeof ( smsShrdPrm.cbmPrm.dcsId ) ); | |
3516 | |
3517 smsShrdPrm.cbmPrm.cbmMode = chkMode; | |
3518 | |
3519 /* CSCBmode = mode; */ | |
3520 | |
3521 /* | |
3522 *----------------------------------------------------------------- | |
3523 * set the new CBCH configuration | |
3524 *----------------------------------------------------------------- | |
3525 */ | |
3526 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
3527 | |
3528 if( psaMMI_Cbch() < 0 ) | |
3529 { | |
3530 TRACE_EVENT( "FATAL RETURN psaSMS in +CSCB" ); | |
3531 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3532 return( AT_FAIL ); | |
3533 } | |
3534 | |
3535 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
3536 | |
3537 return ( AT_CMPL ); | |
3538 } | |
3539 | |
3540 | |
3541 #ifdef FF_HOMEZONE | |
3542 /* | |
3543 +-------------------------------------------------------------------+ | |
3544 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3545 | STATE : code ROUTINE : sAT_PercentCBHZ | | |
3546 +-------------------------------------------------------------------+ | |
3547 | |
3548 PURPOSE : This is the functional counterpart of the %CBHZ | |
3549 AT command which is responsible for activation and | |
3550 deactivation of the homezone feature. | |
3551 | |
3552 <mode> : activation mode | |
3553 <dcs> : datacoding scheme | |
3554 <timeout>: timeout period for homezone CBM | |
3555 */ | |
3556 GLOBAL T_ACI_RETURN sAT_PercentCBHZ ( T_ACI_CMD_SRC srcId, | |
3557 T_ACI_CBHZ_MOD mode, | |
3558 T_ACI_CS dcs, | |
3559 UBYTE timeout) | |
3560 { | |
3561 UBYTE chkMode; /* checked parameter <mode> */ | |
3562 UBYTE chkDcs; /* checked parameter <dcs> */ | |
3563 UBYTE chkTimeout; /* checked parameter <timeout> */ | |
3564 | |
3565 TRACE_FUNCTION ("sAT_PercentCBHZ()"); | |
3566 | |
3567 /* | |
3568 *----------------------------------------------------------------- | |
3569 * check command source | |
3570 *----------------------------------------------------------------- | |
3571 */ | |
3572 if(!cmh_IsVldCmdSrc (srcId)) | |
3573 { | |
3574 return( AT_FAIL ); | |
3575 } | |
3576 | |
3577 /* | |
3578 *----------------------------------------------------------------- | |
3579 * check access status | |
3580 *----------------------------------------------------------------- | |
3581 */ | |
3582 if (!cmhSMS_checkSIM ()) /* sets error code */ | |
3583 { | |
3584 return( AT_FAIL ); | |
3585 } | |
3586 | |
3587 /* | |
3588 *----------------------------------------------------------------- | |
3589 * check entity status | |
3590 *----------------------------------------------------------------- | |
3591 */ | |
3592 if( smsShrdPrm.cbmPrm.cbchOwner NEQ ((T_OWN)CMD_SRC_NONE) ) | |
3593 { | |
3594 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3595 return( AT_BUSY ); | |
3596 } | |
3597 | |
3598 /* | |
3599 *----------------------------------------------------------------- | |
3600 * process the <mode> parameter | |
3601 *----------------------------------------------------------------- | |
3602 */ | |
3603 switch ( mode ) | |
3604 { | |
3605 case (CBHZ_MOD_Active) : | |
3606 case (CBHZ_MOD_NotActive): | |
3607 chkMode = mode; | |
3608 break; | |
3609 | |
3610 default: | |
3611 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3612 return ( AT_FAIL ); | |
3613 } | |
3614 | |
3615 /* | |
3616 *----------------------------------------------------------------- | |
3617 * process the <dcs> parameter | |
3618 *----------------------------------------------------------------- | |
3619 */ | |
3620 switch ( dcs ) | |
3621 { | |
3622 case (CS_NotPresent): | |
3623 chkDcs = CS_GsmDef; | |
3624 break; | |
3625 | |
3626 case (CS_GsmDef) : | |
3627 case (CS_GsmInt) : | |
3628 case (CS_Hex) : | |
3629 case (CS_Ucs2) : | |
3630 case (CS_Sim) : | |
3631 case (CS_Ascii) : | |
3632 chkDcs = dcs; | |
3633 break; | |
3634 | |
3635 default: | |
3636 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3637 return ( AT_FAIL ); | |
3638 } | |
3639 | |
3640 /* | |
3641 *----------------------------------------------------------------- | |
3642 * process the <timeout> parameter | |
3643 *----------------------------------------------------------------- | |
3644 */ | |
3645 if ( (timeout >= CBHZ_MIN_TIMEOUT) AND (timeout <= CBHZ_MAX_TIMEOUT) ) | |
3646 { | |
3647 chkTimeout = timeout; | |
3648 } | |
3649 else if ( timeout EQ NOT_PRESENT_8BIT ) | |
3650 { | |
3651 chkTimeout = CBHZ_DEF_TIMEOUT; | |
3652 } | |
3653 else | |
3654 { | |
3655 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3656 return ( AT_FAIL ); | |
3657 } | |
3658 | |
3659 /* | |
3660 *----------------------------------------------------------------- | |
3661 * all parameters valid. now copy parameter | |
3662 *----------------------------------------------------------------- | |
3663 */ | |
3664 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)srcId; | |
3665 smsShrdPrm.cbmPrm.hzMode = chkMode; | |
3666 smsShrdPrm.cbmPrm.hzDcs = chkDcs; | |
3667 smsShrdPrm.cbmPrm.hzTimeout = chkTimeout; | |
3668 | |
3669 /* send homezone request */ | |
3670 if( psaMMI_homezone_req() < 0 ) | |
3671 { | |
3672 TRACE_EVENT( "FATAL RETURN psaSMS in %%CBHZ" ); | |
3673 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
3674 return( AT_FAIL ); | |
3675 } | |
3676 | |
3677 smsShrdPrm.cbmPrm.cbchOwner = (T_OWN)CMD_SRC_NONE; | |
3678 | |
3679 return ( AT_CMPL ); | |
3680 } | |
3681 #endif /* FF_HOMEZONE */ | |
3682 | |
3683 /* | |
3684 +-------------------------------------------------------------------+ | |
3685 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3686 | STATE : code ROUTINE : sAT_PlusCMGL | | |
3687 +-------------------------------------------------------------------+ | |
3688 | |
3689 PURPOSE : This is the functional counterpart of the +CMGL | |
3690 AT command which is responsible for creating a list of | |
3691 all stored short messages. | |
3692 | |
3693 <state>: state of stored short message | |
3694 */ | |
3695 GLOBAL T_ACI_RETURN sAT_PlusCMGL ( T_ACI_CMD_SRC srcId, | |
3696 T_ACI_SMS_STAT state, | |
3697 SHORT startIdx, | |
3698 T_ACI_SMS_READ rdMode ) | |
3699 { | |
3700 T_ACI_RETURN ret; /* AT response code */ | |
3701 T_ACI_SMS_STAT chk_state; | |
3702 | |
3703 TRACE_FUNCTION ("sAT_PlusCMGL ()"); | |
3704 | |
3705 /* | |
3706 *----------------------------------------------------------------- | |
3707 * check if command executable | |
3708 *----------------------------------------------------------------- | |
3709 */ | |
3710 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3711 { | |
3712 return ret; | |
3713 } | |
3714 | |
3715 /* | |
3716 *----------------------------------------------------------------- | |
3717 * process the <state> parameter | |
3718 *----------------------------------------------------------------- | |
3719 */ | |
3720 switch ( state ) | |
3721 { | |
3722 case( SMS_STAT_NotPresent ): | |
3723 chk_state = SMS_STAT_RecUnread; | |
3724 break; | |
3725 | |
3726 case( SMS_STAT_Invalid ): | |
3727 case( SMS_STAT_All ): | |
3728 case( SMS_STAT_RecUnread ): | |
3729 case( SMS_STAT_RecRead ): | |
3730 case( SMS_STAT_StoUnsent ): | |
3731 case( SMS_STAT_StoSent ): | |
3732 chk_state = state; | |
3733 break; | |
3734 | |
3735 default: | |
3736 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3737 return ( AT_FAIL ); | |
3738 } | |
3739 | |
3740 /* | |
3741 *----------------------------------------------------------------- | |
3742 * check if startIdx is in range | |
3743 *----------------------------------------------------------------- | |
3744 */ | |
3745 if ( startIdx >= MAX_SIM_ME_ENTRIES /*256*/ OR | |
3746 startIdx > SMS_CMH_MAX_START_IDX /*255*/ ) | |
3747 { | |
3748 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3749 return ( AT_FAIL ); | |
3750 } | |
3751 | |
3752 /* | |
3753 *----------------------------------------------------------------- | |
3754 * process the <rdMode> parameter | |
3755 *----------------------------------------------------------------- | |
3756 */ | |
3757 switch (rdMode) | |
3758 { | |
3759 case SMS_READ_StatusChange: | |
3760 default: | |
3761 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
3762 return ( AT_FAIL ); | |
3763 case SMS_READ_Preview: | |
3764 smsShrdPrm.rdMode = READ_PREVIEW; | |
3765 break; | |
3766 case SMS_READ_Normal: | |
3767 case SMS_READ_NotPresent: | |
3768 smsShrdPrm.rdMode = READ_NORMAL; | |
3769 break; | |
3770 } | |
3771 | |
3772 /* | |
3773 *--------------------------------------------------------------- | |
3774 * PSA notification | |
3775 *--------------------------------------------------------------- | |
3776 */ | |
3777 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMGL; | |
3778 smsShrdPrm.owner = (T_OWN)srcId; | |
3779 smsShrdPrm.smsEntStat.entOwn = srcId; | |
3780 | |
3781 /* | |
3782 *--------------------------------------------------------------- | |
3783 * request the list element | |
3784 *--------------------------------------------------------------- | |
3785 */ | |
3786 psaSMS_ReadReq ( smsShrdPrm.mem1, startIdx, | |
3787 smsShrdPrm.rdMode, chk_state ); | |
3788 | |
3789 return( AT_EXCT ); | |
3790 } | |
3791 | |
3792 /* | |
3793 +-------------------------------------------------------------------+ | |
3794 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3795 | STATE : code ROUTINE : sAT_PlusCSAS | | |
3796 +-------------------------------------------------------------------+ | |
3797 | |
3798 PURPOSE : This is the functional counterpart of the +CSAS | |
3799 AT command which is responsible for saving of certain | |
3800 SMS parameters to nonvolatile memory. | |
3801 | |
3802 <profile>: SMS profile number (1..max_record) | |
3803 */ | |
3804 GLOBAL T_ACI_RETURN sAT_PlusCSAS ( T_ACI_CMD_SRC srcId, | |
3805 SHORT profile) | |
3806 { | |
3807 T_ACI_RETURN ret; /* AT response code */ | |
3808 UBYTE tmpNumOfRefs; | |
3809 UBYTE max_record; | |
3810 | |
3811 TRACE_FUNCTION ("sAT_PlusCSAS ()"); | |
3812 | |
3813 /* | |
3814 *----------------------------------------------------------------- | |
3815 * check if command executable | |
3816 *----------------------------------------------------------------- | |
3817 */ | |
3818 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3819 return ret; | |
3820 | |
3821 max_record = (UBYTE)cmhSMS_getPrfRge (); | |
3822 if ((profile <= 0) OR (profile > max_record)) | |
3823 { | |
3824 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
3825 return AT_FAIL; | |
3826 } | |
3827 | |
3828 smsShrdPrm.cbmPrm.cbmFoundIds = 0; | |
3829 | |
3830 if ( (smsShrdPrm.pSetPrm[srcId]->prflId NEQ profile) OR | |
3831 (smsShrdPrm.pSetPrm[srcId]->isCopy EQ TRUE) ) | |
3832 { | |
3833 T_SMS_SET_PRM * elem; | |
3834 T_SMS_SET_PRM * pSMSSetPrmOld = smsShrdPrm.pSetPrm[srcId]; | |
3835 | |
3836 /* | |
3837 *----------------------------------------------------------------- | |
3838 * find or create new profile | |
3839 *----------------------------------------------------------------- | |
3840 */ | |
3841 elem = find_element(set_prm_list, (UBYTE)profile, cmhSMS_findPrflId); | |
3842 if (elem EQ NULL) | |
3843 { | |
3844 ACI_MALLOC(elem, sizeof(T_SMS_SET_PRM)); | |
3845 memset(elem, 0, sizeof(T_SMS_SET_PRM)); | |
3846 insert_list(set_prm_list, elem); | |
3847 } | |
3848 | |
3849 /* save the number of references of the list element */ | |
3850 tmpNumOfRefs = elem->numOfRefs; | |
3851 | |
3852 /* copy the old profile */ | |
3853 memcpy(elem, pSMSSetPrmOld, sizeof(T_SMS_SET_PRM)); | |
3854 | |
3855 /* decrease the numOfRefs of the old profile */ | |
3856 pSMSSetPrmOld->numOfRefs--; | |
3857 | |
3858 /* set the Prm Pointer to the (new or found) list element */ | |
3859 smsShrdPrm.pSetPrm[srcId] = elem; | |
3860 | |
3861 smsShrdPrm.pSetPrm[srcId]->numOfRefs = ++tmpNumOfRefs; | |
3862 smsShrdPrm.pSetPrm[srcId]->isCopy = FALSE; | |
3863 smsShrdPrm.pSetPrm[srcId]->prflId = (UBYTE)profile; | |
3864 | |
3865 /* | |
3866 *----------------------------------------------------------------- | |
3867 * destroy temporary copy | |
3868 *----------------------------------------------------------------- | |
3869 */ | |
3870 if ( pSMSSetPrmOld->isCopy EQ TRUE ) | |
3871 { | |
3872 ACI_MFREE(pSMSSetPrmOld); | |
3873 } | |
3874 } | |
3875 | |
3876 /* | |
3877 *------------------------------------------------------------- | |
3878 * store parameters to non-volatile memory | |
3879 *------------------------------------------------------------- | |
3880 */ | |
3881 ret = cmhSMS_WriteParams (srcId, AT_CMD_CSAS, profile); | |
3882 return ret; | |
3883 | |
3884 } | |
3885 | |
3886 /* | |
3887 +-------------------------------------------------------------------+ | |
3888 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3889 | STATE : code ROUTINE : sAT_PlusCRES | | |
3890 +-------------------------------------------------------------------+ | |
3891 | |
3892 PURPOSE : This is the functional counterpart of the +CRES | |
3893 AT command which is responsible for retrieving of | |
3894 certain SMS parameters from nonvolatile memory. | |
3895 | |
3896 <profile>: SMS profile number (1..max_record) | |
3897 */ | |
3898 GLOBAL T_ACI_RETURN sAT_PlusCRES ( T_ACI_CMD_SRC srcId, | |
3899 SHORT profile) | |
3900 { | |
3901 T_ACI_RETURN ret=AT_CMPL; /* AT response code */ | |
3902 UBYTE max_record; | |
3903 | |
3904 TRACE_FUNCTION ("sAT_PlusCRES ()"); | |
3905 | |
3906 /* | |
3907 *----------------------------------------------------------------- | |
3908 * check if command executable | |
3909 *----------------------------------------------------------------- | |
3910 */ | |
3911 if(!cmhSMS_checkAccess (srcId, &ret)) | |
3912 return ret; | |
3913 | |
3914 max_record = (UBYTE)cmhSMS_getPrfRge (); | |
3915 if ((profile <= 0) OR (profile > max_record)) | |
3916 { | |
3917 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
3918 return AT_FAIL; | |
3919 } | |
3920 | |
3921 smsShrdPrm.cbmPrm.cbmFoundIds = 0; | |
3922 | |
3923 if ( (smsShrdPrm.pSetPrm[srcId]->prflId NEQ profile) OR | |
3924 (smsShrdPrm.pSetPrm[srcId]->isCopy EQ TRUE) ) | |
3925 { | |
3926 T_SMS_SET_PRM * pSMSSetPrmOld; /* points to SMS parameter set */ | |
3927 T_SMS_SET_PRM * pSMSSetPrmNew; /* points to SMS parameter set */ | |
3928 | |
3929 pSMSSetPrmOld = smsShrdPrm.pSetPrm[srcId]; | |
3930 pSMSSetPrmOld->numOfRefs--; | |
3931 | |
3932 /* | |
3933 *----------------------------------------------------------------- | |
3934 * destroy temporary copy | |
3935 *----------------------------------------------------------------- | |
3936 */ | |
3937 if ( pSMSSetPrmOld->isCopy EQ TRUE) | |
3938 { | |
3939 ACI_MFREE(pSMSSetPrmOld); | |
3940 } | |
3941 | |
3942 /* | |
3943 *------------------------------------------------------------- | |
3944 * find the new profile in the SET PRM list | |
3945 *------------------------------------------------------------- | |
3946 */ | |
3947 pSMSSetPrmNew = find_element(set_prm_list, (UBYTE)profile, cmhSMS_findPrflId); | |
3948 if (pSMSSetPrmNew NEQ NULL) /* element was in SET PRM List */ | |
3949 { | |
3950 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmNew; | |
3951 smsShrdPrm.pSetPrm[srcId]->numOfRefs++; | |
3952 } | |
3953 else /* element was not found in SET PRM List */ | |
3954 { | |
3955 ACI_MALLOC(pSMSSetPrmNew, sizeof(T_SMS_SET_PRM)); | |
3956 memset(pSMSSetPrmNew, 0, sizeof(T_SMS_SET_PRM)); | |
3957 insert_list(set_prm_list, pSMSSetPrmNew); | |
3958 pSMSSetPrmNew->prflId = (UBYTE)profile; | |
3959 | |
3960 smsShrdPrm.pSetPrm[srcId] = pSMSSetPrmNew; | |
3961 } | |
3962 } | |
3963 | |
3964 /* | |
3965 *------------------------------------------------------------- | |
3966 * read parameters from non-volatile memory | |
3967 *------------------------------------------------------------- | |
3968 */ | |
3969 ret = cmhSMS_ReadParams (srcId, AT_CMD_CRES, profile); | |
3970 return ret; | |
3971 | |
3972 } | |
3973 | |
3974 | |
3975 | |
3976 /* | |
3977 +-------------------------------------------------------------------+ | |
3978 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
3979 | STATE : code ROUTINE : tAT_PlusCRES | | |
3980 +-------------------------------------------------------------------+ | |
3981 | |
3982 PURPOSE : This is the functional counterpart of the +CRES | |
3983 AT command which is responsible for retrieving of | |
3984 certain SMS parameters from nonvolatile memory. | |
3985 | |
3986 Shen,Chao July 1st, 2003 | |
3987 | |
3988 */ | |
3989 GLOBAL T_ACI_RETURN tAT_PlusCRES ( T_ACI_CMD_SRC srcId, T_ACI_CRES *values) | |
3990 { | |
3991 SHORT profile = -1; | |
3992 if ((profile = cmhSMS_getPrfRge ()) < 1) | |
3993 { | |
3994 return (AT_FAIL); | |
3995 } | |
3996 | |
3997 values->min = 0; | |
3998 values->max = profile - 1; | |
3999 | |
4000 return AT_CMPL; | |
4001 } | |
4002 | |
4003 #ifdef TI_PS_FF_AT_P_CMD_CPRSM | |
4004 /* | |
4005 +-------------------------------------------------------------------+ | |
4006 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4007 | STATE : code ROUTINE : sAT_PercentCPRSM | | |
4008 +-------------------------------------------------------------------+ | |
4009 | |
4010 PURPOSE : This is the functional counterpart of the %CPRSM | |
4011 AT command which is responsible for setting the receiving | |
4012 of SMS to pause or resume. | |
4013 [MDF: 07.04.2004] | |
4014 */ | |
4015 GLOBAL T_ACI_RETURN sAT_PercentCPRSM ( T_ACI_CMD_SRC srcId, | |
4016 T_ACI_CPRSM_MOD mode) | |
4017 { | |
4018 T_ACI_RETURN ret; | |
4019 | |
4020 TRACE_FUNCTION("sAT_PercentCPRSM()"); | |
4021 | |
4022 /* check whether SMS is currently accessible */ | |
4023 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4024 return ret; | |
4025 | |
4026 /* check mode and inform SMS entity */ | |
4027 switch ( mode ) | |
4028 { | |
4029 case CPRSM_MOD_Pause: | |
4030 /* send pause request to SMS */ | |
4031 psaSMS_PauseReq(); | |
4032 /* command complete */ | |
4033 ret = AT_CMPL; | |
4034 break; | |
4035 case CPRSM_MOD_Resume: | |
4036 /* store paramters for current command */ | |
4037 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CPRSM; | |
4038 smsShrdPrm.owner = (T_OWN)srcId; | |
4039 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4040 /* send resume request to SMS */ | |
4041 psaSMS_ResumeReq(); | |
4042 ret = AT_EXCT; | |
4043 break; | |
4044 default: | |
4045 TRACE_EVENT_P1("sAT_PercentCPRSM ERROR: mode %d not supported", mode); | |
4046 ret = AT_FAIL; | |
4047 } | |
4048 return ret; | |
4049 } | |
4050 | |
4051 /* | |
4052 +-------------------------------------------------------------------+ | |
4053 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4054 | STATE : code ROUTINE : qAT_PercentCPRSM | | |
4055 +-------------------------------------------------------------------+ | |
4056 | |
4057 PURPOSE : This is the functional counterpart of the %CPRSM | |
4058 AT command which is responsible for quering the status | |
4059 of receiving of SMS. It might be resume or pause. | |
4060 [MDF: 15.04.2004] | |
4061 */ | |
4062 GLOBAL T_ACI_RETURN qAT_PercentCPRSM ( T_ACI_CMD_SRC srcId ) | |
4063 { | |
4064 T_ACI_RETURN ret = AT_EXCT; | |
4065 | |
4066 TRACE_FUNCTION("qAT_PercentCPRSM()"); | |
4067 | |
4068 /* check whether SMS is currently accessible */ | |
4069 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4070 return ret; | |
4071 | |
4072 /* store paramters for current command */ | |
4073 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CPRSM; | |
4074 smsShrdPrm.owner = (T_OWN)srcId; | |
4075 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4076 | |
4077 /* add parameter for signaling which parameter has been requested */ | |
4078 psaSMS_QueryReq (SMS_QUERY_DELIVER_STATUS); | |
4079 | |
4080 return ret; | |
4081 } | |
4082 #endif /* TI_PS_FF_AT_P_CMD_CPRSM */ | |
4083 /* | |
4084 +-------------------------------------------------------------------+ | |
4085 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4086 | STATE : code ROUTINE : sAT_PlusCMMS | | |
4087 +-------------------------------------------------------------------+ | |
4088 | |
4089 PURPOSE : This is the functional counterpart of the +CMMS | |
4090 AT command which is responsible for setting the | |
4091 mode. | |
4092 | |
4093 <mode>: command mode | |
4094 */ | |
4095 GLOBAL T_ACI_RETURN sAT_PlusCMMS ( T_ACI_CMD_SRC srcId, | |
4096 UBYTE mode ) | |
4097 { | |
4098 T_ACI_RETURN ret = AT_FAIL; | |
4099 | |
4100 TRACE_FUNCTION ("sAT_PlusCMMS ()"); | |
4101 | |
4102 /* | |
4103 *----------------------------------------------------------------- | |
4104 * check source id and if command executable | |
4105 *----------------------------------------------------------------- | |
4106 */ | |
4107 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4108 return ret; | |
4109 | |
4110 smsShrdPrm.CMMSmode = mode; | |
4111 smsShrdPrm.smsEntStat.curCmd = AT_CMD_CMMS; | |
4112 | |
4113 /* Implements measure 147,148, 149 */ | |
4114 cmhSMS_sendConfigureReq(TRUE); | |
4115 smsShrdPrm.smsEntStat.curCmd = AT_CMD_NONE; | |
4116 | |
4117 return( AT_CMPL ); | |
4118 } | |
4119 | |
4120 /* | |
4121 +-------------------------------------------------------------------+ | |
4122 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4123 | STATE : code ROUTINE : sAT_PercentCMGMDU | | |
4124 +-------------------------------------------------------------------+ | |
4125 | |
4126 PURPOSE : Function is used to reset the reply path | |
4127 | |
4128 <index>: Index of the record | |
4129 */ | |
4130 | |
4131 #if (defined (MFW) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
4132 GLOBAL T_ACI_RETURN sAT_PercentCMGMDU ( T_ACI_CMD_SRC srcId, | |
4133 UBYTE index ) | |
4134 { | |
4135 T_CONC_INIT_RETURN ret; | |
4136 | |
4137 TRACE_FUNCTION ("sAT_PercentCMGMDU ()"); | |
4138 | |
4139 TRACE_EVENT_P1("sAT_PercentCMGMDU () index: %d", index); | |
4140 | |
4141 ret=concSMS_initReadFromMem(srcId, index, SMS_READ_Normal); | |
4142 | |
4143 if (ret EQ CONC_NEEDED) | |
4144 { | |
4145 SET_CONC; | |
4146 TRACE_EVENT("sAT_PercentCMGMDU: CONC_NEEDED"); | |
4147 return sAT_PercentCMGMDU_Gl(srcId, index, rConcSMS_PercentCMGMDU); | |
4148 } | |
4149 else if (ret EQ CONC_NOT_NEEDED) | |
4150 { | |
4151 TRACE_EVENT("sAT_PercentCMGMDU: CONC_NOT_NEEDED"); | |
4152 return sAT_PercentCMGMDU_Gl(srcId, index, NULL); | |
4153 } | |
4154 else | |
4155 { | |
4156 TRACE_EVENT("ERROR: sAT_PercentCMGMDU: CMS_ERR_InValMemIdx"); | |
4157 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
4158 return ( AT_FAIL ); | |
4159 } | |
4160 } | |
4161 #endif /* #if (defined (MFW) OR defined (_CONC_TESTING_) */ | |
4162 | |
4163 /* | |
4164 +-------------------------------------------------------------------+ | |
4165 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4166 | STATE : code ROUTINE : sAT_PercentCMGMDU | | |
4167 +-------------------------------------------------------------------+ | |
4168 | |
4169 PURPOSE : For Riv-MMI. | |
4170 */ | |
4171 #if defined (FF_MMI_RIV) OR !defined TI_PS_FF_CONC_SMS | |
4172 GLOBAL T_ACI_RETURN sAT_PercentCMGMDU ( T_ACI_CMD_SRC srcId, | |
4173 UBYTE index ) | |
4174 { | |
4175 TRACE_FUNCTION ("sAT_PercentCMGMDU ()"); | |
4176 TRACE_EVENT_P1("sAT_PercentCMGMDU () index: %d", index); | |
4177 | |
4178 return sAT_PercentCMGMDU_Gl(srcId, index, NULL); | |
4179 } | |
4180 #endif /*#if defined (FF_MMI_RIV)*/ | |
4181 | |
4182 GLOBAL T_ACI_RETURN sAT_PercentCMGMDU_Gl ( T_ACI_CMD_SRC srcId, | |
4183 UBYTE index, | |
4184 T_CMGMDU_FCT rplyCB ) | |
4185 { | |
4186 T_ACI_RETURN ret = AT_EXCT; | |
4187 | |
4188 TRACE_FUNCTION ("sAT_PercentCMGMDU_Gl ()"); | |
4189 | |
4190 /* | |
4191 *----------------------------------------------------------------- | |
4192 * check if command executable | |
4193 *----------------------------------------------------------------- | |
4194 */ | |
4195 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4196 { | |
4197 return ret; | |
4198 } | |
4199 | |
4200 smsShrdPrm.rplyCB.cmgmdu = rplyCB; | |
4201 smsShrdPrm.rdMode = READ_NORMAL; | |
4202 | |
4203 /* | |
4204 *----------------------------------------------------------------- | |
4205 * read a short message from memory | |
4206 *----------------------------------------------------------------- | |
4207 */ | |
4208 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGMDU; | |
4209 smsShrdPrm.owner = (T_OWN)srcId; | |
4210 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4211 | |
4212 psaSMS_ReadReq ( smsShrdPrm.mem1, index, | |
4213 smsShrdPrm.rdMode, SMS_STAT_NotPresent); | |
4214 | |
4215 return( ret ); | |
4216 } | |
4217 /* | |
4218 +-------------------------------------------------------------------+ | |
4219 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4220 | STATE : code ROUTINE : sAT_PercentCMGR_Gl | | |
4221 +-------------------------------------------------------------------+ | |
4222 | |
4223 PURPOSE : This is the functional counterpart of the %CMGR | |
4224 AT command which is responsible for reading a short | |
4225 message from memory. | |
4226 | |
4227 <index>: storage area index | |
4228 <rdMode>: read mode | |
4229 <rplyCB>: reply call-back | |
4230 <errorCB>: error call-back | |
4231 */ | |
4232 GLOBAL T_ACI_RETURN sAT_PercentCMGR_Gl ( T_ACI_CMD_SRC srcId, | |
4233 UBYTE index, | |
4234 T_ACI_SMS_READ rdMode, | |
4235 T_CMGR_FCT rplyCB ) | |
4236 { | |
4237 T_ACI_RETURN ret = AT_EXCT; | |
4238 | |
4239 TRACE_FUNCTION ("sAT_PercentCMGR_Gl ()"); | |
4240 | |
4241 /* | |
4242 *----------------------------------------------------------------- | |
4243 * check if command executable | |
4244 *----------------------------------------------------------------- | |
4245 */ | |
4246 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4247 { | |
4248 return ret; | |
4249 } | |
4250 | |
4251 smsShrdPrm.rplyCB.cmgr = rplyCB; | |
4252 | |
4253 | |
4254 /* | |
4255 *----------------------------------------------------------------- | |
4256 * process the <index> parameter | |
4257 *----------------------------------------------------------------- | |
4258 */ | |
4259 switch (rdMode) | |
4260 { | |
4261 case SMS_READ_StatusChange: | |
4262 smsShrdPrm.rdMode = READ_STATUS_CHANGE; | |
4263 break; | |
4264 case SMS_READ_Preview: | |
4265 smsShrdPrm.rdMode = READ_PREVIEW; | |
4266 break; | |
4267 case SMS_READ_Normal: | |
4268 case SMS_READ_NotPresent: | |
4269 smsShrdPrm.rdMode = READ_NORMAL; | |
4270 break; | |
4271 default: | |
4272 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4273 return ( AT_FAIL ); | |
4274 } | |
4275 /* | |
4276 *----------------------------------------------------------------- | |
4277 * read a short message from memory | |
4278 *----------------------------------------------------------------- | |
4279 */ | |
4280 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGR; | |
4281 smsShrdPrm.owner = (T_OWN)srcId; | |
4282 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4283 | |
4284 psaSMS_ReadReq ( smsShrdPrm.mem1, index, | |
4285 smsShrdPrm.rdMode, SMS_STAT_NotPresent); | |
4286 | |
4287 return( ret ); | |
4288 } | |
4289 | |
4290 | |
4291 /* | |
4292 +-------------------------------------------------------------------+ | |
4293 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4294 | STATE : code ROUTINE : sAT_PercentCMGR | | |
4295 +-------------------------------------------------------------------+ | |
4296 | |
4297 PURPOSE : This is the functional counterpart of the %CMGR | |
4298 AT command which is responsible for reading a short | |
4299 message from memory. | |
4300 | |
4301 Features Concatenated SMS. | |
4302 For GPF-MMI. | |
4303 | |
4304 <index>: storage area index | |
4305 <rdMode>: read mode | |
4306 */ | |
4307 #if (defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)) AND defined TI_PS_FF_CONC_SMS | |
4308 | |
4309 GLOBAL T_ACI_RETURN sAT_PercentCMGR ( T_ACI_CMD_SRC srcId, | |
4310 UBYTE index, | |
4311 T_ACI_SMS_READ rdMode ) | |
4312 { | |
4313 T_CONC_INIT_RETURN ret; | |
4314 | |
4315 TRACE_FUNCTION ("sAT_PercentCMGR ()"); | |
4316 | |
4317 ret=concSMS_initReadFromMem(srcId, index, rdMode); | |
4318 | |
4319 if (ret EQ CONC_NEEDED) | |
4320 { | |
4321 SET_CONC; | |
4322 TRACE_EVENT("sAT_PlusCMGR: CONC_NEEDED"); | |
4323 return sAT_PercentCMGR_Gl(srcId, index, rdMode, rConcSMS_PercentCMGR); | |
4324 } | |
4325 else if (ret EQ CONC_NOT_NEEDED) | |
4326 { | |
4327 TRACE_EVENT("sAT_PlusCMGR: CONC_NOT_NEEDED"); | |
4328 return sAT_PercentCMGR_Gl(srcId, index, rdMode, rAT_PercentCMGR); | |
4329 } | |
4330 else | |
4331 { | |
4332 TRACE_EVENT("ERROR: sAT_PercentCMGR: CMS_ERR_InValMemIdx"); | |
4333 ACI_ERR_DESC( ACI_ERR_CLASS_Cms, CMS_ERR_InValMemIdx ); | |
4334 return ( AT_FAIL ); | |
4335 } | |
4336 } | |
4337 #endif /*#if defined (MFW) OR defined (SMI) OR defined (_CONC_TESTING_)*/ | |
4338 | |
4339 /* | |
4340 +-------------------------------------------------------------------+ | |
4341 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4342 | STATE : code ROUTINE : sAT_PercentCMGR | | |
4343 +-------------------------------------------------------------------+ | |
4344 | |
4345 PURPOSE : %CMGR command for handling the conc module on | |
4346 the Riv-MMI side. | |
4347 */ | |
4348 #if defined (FF_MMI_RIV) OR !defined TI_PS_FF_CONC_SMS | |
4349 GLOBAL T_ACI_RETURN sAT_PercentCMGR ( T_ACI_CMD_SRC srcId, | |
4350 UBYTE index, | |
4351 T_ACI_SMS_READ rdMode ) | |
4352 { | |
4353 TRACE_FUNCTION ("sAT_PercentCMGR ()"); | |
4354 | |
4355 TRACE_EVENT_P1("sAT_PercentCMGR () index: %d", index); | |
4356 | |
4357 return sAT_PercentCMGR_Gl(srcId, index, rdMode, rAT_PercentCMGR); | |
4358 } | |
4359 #endif /*#if defined (FF_MMI_RIV)*/ | |
4360 | |
4361 /* | |
4362 +-------------------------------------------------------------------+ | |
4363 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4364 | STATE : code ROUTINE : sAT_PercentCMGL | | |
4365 +-------------------------------------------------------------------+ | |
4366 | |
4367 PURPOSE : This is the functional counterpart of the %CMGL | |
4368 AT command which is responsible for creating a list of | |
4369 all stored short messages. | |
4370 | |
4371 <state>: state of stored short message | |
4372 <rdmode>: Read mode | |
4373 */ | |
4374 GLOBAL T_ACI_RETURN sAT_PercentCMGL ( T_ACI_CMD_SRC srcId, | |
4375 T_ACI_SMS_STAT state, | |
4376 T_ACI_SMS_READ rdMode ) | |
4377 { | |
4378 T_ACI_RETURN ret; /* AT response code */ | |
4379 T_ACI_SMS_STAT chk_state; | |
4380 | |
4381 TRACE_FUNCTION ("sAT_PercentCMGL ()"); | |
4382 | |
4383 /* | |
4384 *----------------------------------------------------------------- | |
4385 * check if command executable | |
4386 *----------------------------------------------------------------- | |
4387 */ | |
4388 if(!cmhSMS_checkAccess (srcId, &ret)) | |
4389 { | |
4390 return ret; | |
4391 } | |
4392 | |
4393 /* | |
4394 *----------------------------------------------------------------- | |
4395 * process the <state> parameter | |
4396 *----------------------------------------------------------------- | |
4397 */ | |
4398 switch ( state ) | |
4399 { | |
4400 case( SMS_STAT_NotPresent ): | |
4401 chk_state = SMS_STAT_RecUnread; | |
4402 break; | |
4403 | |
4404 case( SMS_STAT_Invalid ): | |
4405 case( SMS_STAT_All ): | |
4406 case( SMS_STAT_RecUnread ): | |
4407 case( SMS_STAT_RecRead ): | |
4408 case( SMS_STAT_StoUnsent ): | |
4409 case( SMS_STAT_StoSent ): | |
4410 chk_state = state; | |
4411 break; | |
4412 | |
4413 default: | |
4414 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4415 return ( AT_FAIL ); | |
4416 } | |
4417 | |
4418 | |
4419 /* | |
4420 *----------------------------------------------------------------- | |
4421 * process the <rdMode> parameter | |
4422 *----------------------------------------------------------------- | |
4423 */ | |
4424 switch (rdMode) | |
4425 { | |
4426 case SMS_READ_StatusChange: | |
4427 smsShrdPrm.rdMode = READ_STATUS_CHANGE; | |
4428 break; | |
4429 case SMS_READ_Preview: | |
4430 smsShrdPrm.rdMode = READ_PREVIEW; | |
4431 break; | |
4432 case SMS_READ_Normal: | |
4433 case SMS_READ_NotPresent: | |
4434 smsShrdPrm.rdMode = READ_NORMAL; | |
4435 break; | |
4436 default: | |
4437 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4438 return ( AT_FAIL ); | |
4439 } | |
4440 | |
4441 /* | |
4442 *--------------------------------------------------------------- | |
4443 * PSA notification | |
4444 *--------------------------------------------------------------- | |
4445 */ | |
4446 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGL; | |
4447 smsShrdPrm.owner = (T_OWN)srcId; | |
4448 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4449 | |
4450 /* | |
4451 *--------------------------------------------------------------- | |
4452 * request the list element | |
4453 *--------------------------------------------------------------- | |
4454 */ | |
4455 psaSMS_ReadReq ( smsShrdPrm.mem1, 0, | |
4456 smsShrdPrm.rdMode, chk_state ); | |
4457 | |
4458 return( AT_EXCT ); | |
4459 } | |
4460 | |
4461 /* | |
4462 +-------------------------------------------------------------------+ | |
4463 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4464 | STATE : code ROUTINE : cmhSMS_SendDelete_Req | | |
4465 +-------------------------------------------------------------------+ | |
4466 | |
4467 PURPOSE : This is the functional used to send a delete request | |
4468 to SMS module. | |
4469 | |
4470 */ | |
4471 | |
4472 GLOBAL void cmhSMS_SendDelete_Req ( UBYTE index, | |
4473 UBYTE status ) | |
4474 { | |
4475 TRACE_FUNCTION ("cmhSMS_SendDelete_Req ()"); | |
4476 | |
4477 smsShrdPrm.index = index; | |
4478 smsShrdPrm.status = status; | |
4479 | |
4480 /*-------------------------------------------------------------------* | |
4481 * Create and Send primitive for SMS delete * | |
4482 *-------------------------------------------------------------------*/ | |
4483 { | |
4484 PALLOC (mnsms_delete_req, MNSMS_DELETE_REQ); | |
4485 | |
4486 /* fill in primitive parameter: delete message */ | |
4487 mnsms_delete_req -> mem_type = smsShrdPrm.mem1; | |
4488 mnsms_delete_req -> rec_num = index; | |
4489 mnsms_delete_req -> delete_status = status; | |
4490 | |
4491 PSENDX (SMS, mnsms_delete_req); | |
4492 | |
4493 TRACE_EVENT_P1("cmgd: delete rec_num: %d", mnsms_delete_req->rec_num); | |
4494 } | |
4495 } | |
4496 | |
4497 | |
4498 /* | |
4499 +-------------------------------------------------------------------+ | |
4500 | PROJECT : GSM-PS (6147) MODULE : CMH_SMSS | | |
4501 | STATE : code ROUTINE : sAT_PercentCMGRS | | |
4502 +-------------------------------------------------------------------+ | |
4503 | |
4504 PURPOSE : This is the functional counterpart of the %CMGRS | |
4505 AT command which is responsible for selecting auto | |
4506 retransmission mode/request manual retransmission of last | |
4507 failed SMS | |
4508 | |
4509 <mode>: requested mode | |
4510 */ | |
4511 #ifdef REL99 | |
4512 | |
4513 GLOBAL T_ACI_RETURN sAT_PercentCMGRS ( T_ACI_CMD_SRC srcId, | |
4514 T_ACI_CMGRS_MODE mode) | |
4515 { | |
4516 T_ACI_RETURN aci_ret_val = AT_CMPL; | |
4517 | |
4518 TRACE_FUNCTION ("sAT_PercentCMGRS ()"); | |
4519 | |
4520 /* | |
4521 *----------------------------------------------------------------- | |
4522 * check command source | |
4523 *----------------------------------------------------------------- | |
4524 */ | |
4525 if(!cmh_IsVldCmdSrc (srcId) AND (srcId NEQ (T_ACI_CMD_SRC)OWN_SRC_SAT)) | |
4526 { | |
4527 TRACE_ERROR ("[cmhSMS_checkAccess]: Cmd Src not valid"); | |
4528 return AT_FAIL; | |
4529 } | |
4530 /* | |
4531 *----------------------------------------------------------------- | |
4532 * check SMS access status | |
4533 *----------------------------------------------------------------- | |
4534 */ | |
4535 if (!cmhSMS_checkSIM ()) | |
4536 { | |
4537 return AT_FAIL; | |
4538 } | |
4539 | |
4540 switch( mode ) | |
4541 { | |
4542 case( CMGRS_MODE_DISABLE_AUTO_RETRANS ): | |
4543 case( CMGRS_MODE_ENABLE_AUTO_RETRANS ): | |
4544 smsShrdPrm.auto_repeat_flag = mode; | |
4545 aci_ret_val = AT_CMPL; | |
4546 break; | |
4547 | |
4548 case( CMGRS_MODE_MANUAL_RETRANS ): | |
4549 /* | |
4550 *----------------------------------------------------------------- | |
4551 * check entity status | |
4552 *----------------------------------------------------------------- | |
4553 */ | |
4554 if( smsShrdPrm.smsEntStat.curCmd NEQ AT_CMD_NONE ) | |
4555 { | |
4556 | |
4557 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Internal ); | |
4558 TRACE_ERROR ("[cmhSMS_checkAccess]: Entity is busy"); | |
4559 aci_ret_val = AT_BUSY; | |
4560 break ; | |
4561 } | |
4562 | |
4563 if(smsShrdPrm.is_msg_present_for_retrans EQ FALSE) | |
4564 { | |
4565 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_FailedMsgNotPresent ); | |
4566 aci_ret_val = AT_FAIL; | |
4567 } | |
4568 else | |
4569 { | |
4570 /*------------------------------------------------------------------- | |
4571 * create and send primitive for retrasnmission request | |
4572 *------------------------------------------------------------------- | |
4573 */ | |
4574 PALLOC (mnsms_retrans_req, MNSMS_RETRANS_REQ); | |
4575 mnsms_retrans_req -> auto_rep_flag = smsShrdPrm.auto_repeat_flag; | |
4576 PSENDX (SMS, mnsms_retrans_req); | |
4577 | |
4578 smsShrdPrm.smsEntStat.curCmd = AT_CMD_P_CMGRS; | |
4579 smsShrdPrm.smsEntStat.entOwn = srcId; | |
4580 smsShrdPrm.owner = (T_OWN)srcId; | |
4581 #if defined (MFW) OR defined (FF_MMI_RIV) | |
4582 smsShrdPrm.rplyCB.cmgrs = rAT_PercentCMGRS; | |
4583 smsShrdPrm.errorCB = rAT_PlusCMS; | |
4584 #else | |
4585 smsShrdPrm.rplyCB.cmgrs = NULL; | |
4586 smsShrdPrm.errorCB = NULL; | |
4587 #endif | |
4588 aci_ret_val = AT_EXCT; | |
4589 } | |
4590 break; | |
4591 | |
4592 default: | |
4593 ACI_ERR_DESC( ACI_ERR_CLASS_Ext, EXT_ERR_Parameter ); | |
4594 aci_ret_val = AT_FAIL; | |
4595 break; | |
4596 } | |
4597 | |
4598 return aci_ret_val; | |
4599 } | |
4600 #endif | |
4601 | |
4602 /*==== EOF ========================================================*/ |