FreeCalypso > hg > freecalypso-citrine

comparison g23m-aci/aci/cmh_smss.c @ 0:75a11d740a02

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