FreeCalypso > hg > freecalypso-citrine
comparison g23m-aci/aci/ati_sms.c @ 0:75a11d740a02
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author | Mychaela Falconia <falcon@freecalypso.org> |
---|---|
date | Thu, 09 Jun 2016 00:02:41 +0000 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:75a11d740a02 |
---|---|
1 /* | |
2 +----------------------------------------------------------------------------- | |
3 | Project : GSM-F&D (8411) | |
4 | Modul : ATI | |
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 : AT Command Interpreter: SMS related functions. | |
18 +----------------------------------------------------------------------------- | |
19 */ | |
20 | |
21 #ifndef ATI_SMS_C | |
22 #define ATI_SMS_C | |
23 | |
24 #include "config.h" | |
25 #include "fixedconf.h" | |
26 #include "condat-features.h" | |
27 #include "aci_conf.h" | |
28 | |
29 #undef DUMMY_ATI_STRINGS | |
30 | |
31 #include "aci_all.h" | |
32 | |
33 #include "aci_cmh.h" | |
34 #include "ati_cmd.h" | |
35 #include "aci_io.h" | |
36 #include "aci_cmd.h" | |
37 #include "l4_tim.h" | |
38 | |
39 #include "aci_mem.h" | |
40 | |
41 #include "aci_lst.h" | |
42 #include "conc_sms.h" | |
43 #include "aci_prs.h" | |
44 | |
45 #include "ati_int.h" | |
46 | |
47 #include "cmh_sms.h" | |
48 #include "psa.h" | |
49 #include "psa_sms.h" | |
50 #include "aci.h" | |
51 | |
52 #ifdef FF_ATI_BAT | |
53 | |
54 #include "typedefs.h" | |
55 #include "gdd.h" | |
56 #include "bat.h" | |
57 | |
58 #include "ati_bat.h" | |
59 | |
60 #endif /*FF_ATI_BAT*/ | |
61 | |
62 //TISH modified for MSIM | |
63 #undef WIN32 | |
64 | |
65 EXTERN T_SMS_SHRD_PRM smsShrdPrm; | |
66 | |
67 const SMS_Memory sms_mem [] = | |
68 { | |
69 {"ME", SMS_STOR_Me}, | |
70 {"SM", SMS_STOR_Sm}, | |
71 {0,SMS_STOR_Me} | |
72 }; | |
73 | |
74 #if defined (SMS_PDU_SUPPORT) | |
75 LOCAL T_ATI_RSLT atPlusCMGSText (char *cl, UBYTE srcId); | |
76 LOCAL T_ATI_RSLT atPlusCMGWText (char *cl, UBYTE srcId); | |
77 LOCAL T_ATI_RSLT atPlusCMGCText (char *cl, UBYTE srcId); | |
78 LOCAL T_ATI_RSLT atPlusCNMAText (char *cl, UBYTE srcId); | |
79 #endif | |
80 | |
81 /* move the define into aci_cmd.h */ | |
82 | |
83 GLOBAL void cmd_clearCnmiBuf (void); | |
84 | |
85 LOCAL T_CNMI_BUFFER cnmiBuf; | |
86 GLOBAL BOOL cnmiFlushInProgress = FALSE; | |
87 GLOBAL S16 waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE; | |
88 LOCAL CHAR daBuf[MAX_SMS_NUM_LEN*4]; /* multyply by 4 is required in case of UCS2 charecters */ | |
89 | |
90 EXTERN SHORT cmhSMS_getPrfRge ( void ); | |
91 EXTERN BOOL check_str(char * string,char * sample); | |
92 | |
93 #ifdef _SIMULATION_ | |
94 GLOBAL char subBuf[MAX_SUBADDR_LEN*4]; | |
95 #endif /* _SIMULATION_ */ | |
96 | |
97 GLOBAL SHORT toda_val; | |
98 GLOBAL SHORT fo, ct, pid, mn; | |
99 | |
100 GLOBAL UBYTE cpmsCallType = NONE_CALL; | |
101 | |
102 /* | |
103 * | |
104 ----------------------------SMS Commands----------------------------------- | |
105 * | |
106 */ | |
107 | |
108 /* | |
109 +--------------------------------------------------------------------+ | |
110 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
111 | STATE : code ROUTINE : atPlusCSMS | | |
112 +--------------------------------------------------------------------+ | |
113 | |
114 PURPOSE : +CSMS command (Select Message Service) | |
115 */ | |
116 | |
117 GLOBAL T_ATI_RSLT atPlusCSMS (char *cl, UBYTE srcId) | |
118 { | |
119 T_ACI_RETURN ret = AT_FAIL; | |
120 T_ACI_CSMS_SERV service; | |
121 | |
122 TRACE_FUNCTION("atPlusCSMS()"); | |
123 | |
124 /*input functionality*/ | |
125 cl = parse (cl,"d",&service); | |
126 if ( !cl ) | |
127 { | |
128 cmdCmsError(CMS_ERR_OpNotAllowed); | |
129 return (ATI_FAIL); | |
130 } | |
131 ret = sAT_PlusCSMS((T_ACI_CMD_SRC)srcId,service); | |
132 if (ret EQ AT_FAIL) | |
133 { | |
134 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
135 return (ATI_FAIL); | |
136 } | |
137 return (ATI_CMPL); | |
138 } | |
139 | |
140 GLOBAL T_ATI_RSLT queatPlusCSMS (char *cl, UBYTE srcId) | |
141 { | |
142 T_ACI_RETURN ret = AT_FAIL; | |
143 T_ACI_CSMS_SERV service; | |
144 T_ACI_CSMS_SUPP mt; | |
145 T_ACI_CSMS_SUPP mo; | |
146 T_ACI_CSMS_SUPP bm; | |
147 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
148 | |
149 | |
150 ret = qAT_PlusCSMS((T_ACI_CMD_SRC)srcId,&service,&mt,&mo,&bm); | |
151 if (ret EQ AT_CMPL) | |
152 { | |
153 sprintf(g_sa,"+CSMS: %d,%d,%d,%d",service,mt,mo,bm); | |
154 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
155 return (ATI_CMPL); | |
156 } | |
157 if (ret EQ AT_EXCT) | |
158 { | |
159 src_params->curAtCmd = AT_CMD_CSMS; | |
160 return (ATI_EXCT); | |
161 } | |
162 else | |
163 { | |
164 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
165 return (ATI_FAIL); | |
166 } | |
167 } | |
168 | |
169 /* | |
170 +--------------------------------------------------------------------+ | |
171 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
172 | STATE : code ROUTINE : atPlusCPMS | | |
173 +--------------------------------------------------------------------+ | |
174 | |
175 PURPOSE : +CPMS command (Select Preferred Message Storage) | |
176 */ | |
177 | |
178 GLOBAL T_ATI_RSLT atPlusCPMS (char *cl, UBYTE srcId) | |
179 { | |
180 CHAR memstr1[3] = {0}; | |
181 CHAR memstr2[3] = {0}; | |
182 CHAR memstr3[3] = {0}; | |
183 T_ACI_RETURN ret = AT_FAIL; | |
184 T_ACI_SMS_STOR_OCC mem1; | |
185 T_ACI_SMS_STOR_OCC mem2; | |
186 T_ACI_SMS_STOR_OCC mem3; | |
187 BOOL f1 = TRUE; | |
188 BOOL f2 = TRUE; | |
189 BOOL f3 = TRUE; | |
190 SHORT i; | |
191 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
192 | |
193 TRACE_FUNCTION("atPlusCPMS()"); | |
194 | |
195 mem1.mem = SMS_STOR_NotPresent; | |
196 mem2.mem = SMS_STOR_NotPresent; | |
197 mem3.mem = SMS_STOR_NotPresent; | |
198 | |
199 /*input functionality*/ | |
200 cl = parse ( cl, "sss", (LONG)3, memstr1, | |
201 (LONG)3, memstr2, | |
202 (LONG)3, memstr3 ); | |
203 | |
204 strupper ( memstr1 ); | |
205 strupper ( memstr2 ); | |
206 strupper ( memstr3 ); | |
207 | |
208 for ( i=0; sms_mem[i].name NEQ NULL; i++ ) | |
209 { | |
210 if ( ( strcmp ( sms_mem[i].name, memstr1 ) EQ 0 ) AND f1 ) | |
211 { | |
212 mem1.mem = sms_mem[i].stor; | |
213 f1 = FALSE; | |
214 } | |
215 | |
216 if ( ( strcmp ( sms_mem[i].name, memstr2 ) EQ 0 ) AND f2 ) | |
217 { | |
218 mem2.mem = sms_mem[i].stor; | |
219 f2 = FALSE; | |
220 } | |
221 | |
222 if ( ( strcmp ( sms_mem[i].name, memstr3 ) EQ 0 ) AND f3 ) | |
223 { | |
224 mem3.mem = sms_mem[i].stor; | |
225 f3 = FALSE; | |
226 } | |
227 } | |
228 | |
229 if (!cl OR f1 /*OR f2 OR f3*/ ) | |
230 { | |
231 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
232 return (ATI_FAIL); | |
233 } | |
234 | |
235 #ifdef FF_ATI_BAT | |
236 { | |
237 T_BAT_cmd_send cmd; | |
238 T_BAT_cmd_set_plus_cpms cpms; | |
239 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPMS; | |
240 cmd.params.ptr_set_plus_cpms = &cpms; | |
241 | |
242 cpms.mem1 = (T_BAT_plus_cpms_mem1)mem1.mem; | |
243 cpms.mem2 = (T_BAT_plus_cpms_mem2)mem2.mem; | |
244 cpms.mem3 = (T_BAT_plus_cpms_mem3)mem3.mem; | |
245 | |
246 TRACE_FUNCTION("atPlusCPMS() calls bat_send() <=== as APPLICATION"); | |
247 bat_send(ati_bat_get_client(srcId), &cmd); | |
248 | |
249 return (AT_EXCT); | |
250 } | |
251 #else /* FF_ATI_BAT */ | |
252 | |
253 ret = sAT_PlusCPMS ( (T_ACI_CMD_SRC)srcId, mem1.mem, mem2.mem, mem3.mem ); | |
254 | |
255 switch(ret) | |
256 { | |
257 case(AT_CMPL): | |
258 { | |
259 src_params->curAtCmd = AT_CMD_NONE; | |
260 return (ATI_CMPL); | |
261 } | |
262 default: | |
263 { | |
264 cmdCmsError (CMS_ERR_NotPresent); /* use aciErrDesc */ | |
265 return (ATI_FAIL); | |
266 } | |
267 } | |
268 #endif /* FF_ATI_BAT */ | |
269 } | |
270 | |
271 GLOBAL T_ATI_RSLT queatPlusCPMS (char *cl, UBYTE srcId) | |
272 { | |
273 T_ACI_RETURN ret; | |
274 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
275 | |
276 /*returns current Memory setting*/ | |
277 ret = qAT_PlusCPMS ((T_ACI_CMD_SRC)srcId ); | |
278 | |
279 if ( ret EQ AT_CMPL ) | |
280 { | |
281 src_params->curAtCmd = AT_CMD_NONE; | |
282 return (ATI_CMPL); | |
283 } | |
284 else if ( ret EQ AT_EXCT ) | |
285 { | |
286 src_params->curAtCmd = AT_CMD_CPMS; | |
287 return (ATI_EXCT); | |
288 } | |
289 else | |
290 { | |
291 cmdCmsError ( CMS_ERR_NotPresent); /* use aciErrDesc */ | |
292 return (ATI_FAIL); | |
293 } | |
294 } | |
295 | |
296 /* | |
297 +--------------------------------------------------------------------+ | |
298 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
299 | STATE : code ROUTINE : atPlusCMGF | | |
300 +--------------------------------------------------------------------+ | |
301 | |
302 PURPOSE : +CMGF command (Select Message Format) | |
303 */ | |
304 | |
305 GLOBAL T_ATI_RSLT atPlusCMGF (char *cl, UBYTE srcId) | |
306 { | |
307 T_ACI_RETURN ret = AT_FAIL; | |
308 T_ACI_CMGF_MOD mode=CMGF_MOD_NotPresent; | |
309 | |
310 TRACE_FUNCTION("atPlusCMGF()"); | |
311 | |
312 /* | |
313 * input functionality | |
314 */ | |
315 cl = parse(cl,"d",&mode); | |
316 if ( cl) | |
317 { | |
318 switch (mode) | |
319 { | |
320 case CMGF_MOD_Pdu: /* PDU mode */ | |
321 #if !defined (SMS_PDU_SUPPORT) | |
322 cmdCmsError(CMS_ERR_OpNotAllowed); | |
323 return (ATI_FAIL); | |
324 #else | |
325 break; | |
326 #endif | |
327 case CMGF_MOD_Txt: /* Text Mode */ | |
328 default: | |
329 break; | |
330 } | |
331 } | |
332 else | |
333 { | |
334 /* | |
335 * parse problems | |
336 */ | |
337 cmdCmsError(CMS_ERR_OpNotAllowed); | |
338 return (ATI_FAIL); | |
339 } | |
340 /* | |
341 * Parameter is allowed then set | |
342 */ | |
343 ret = sAT_PlusCMGF ((T_ACI_CMD_SRC)srcId,mode); | |
344 if (ret EQ AT_FAIL) | |
345 { | |
346 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
347 return (ATI_FAIL); | |
348 } | |
349 return (map_aci_2_ati_rslt(ret)); | |
350 } | |
351 | |
352 GLOBAL T_ATI_RSLT queatPlusCMGF (char *cl, UBYTE srcId) | |
353 { | |
354 char *me="+CMGF: "; | |
355 T_ACI_RETURN ret = AT_FAIL; | |
356 T_ACI_CMGF_MOD mode=CMGF_MOD_NotPresent; | |
357 | |
358 TRACE_FUNCTION("queatPlusCMGF()"); | |
359 | |
360 /* | |
361 * returns current message format PDU/TEXT | |
362 */ | |
363 ret = qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
364 if (ret EQ AT_CMPL) | |
365 { | |
366 sprintf(g_sa,"%s%d",me,mode); | |
367 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
368 return (ATI_CMPL); | |
369 } | |
370 else | |
371 { | |
372 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
373 return (ATI_FAIL); | |
374 } | |
375 } | |
376 | |
377 /* | |
378 +--------------------------------------------------------------------+ | |
379 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
380 | STATE : code ROUTINE : atPlusCSCA | | |
381 +--------------------------------------------------------------------+ | |
382 | |
383 PURPOSE : +CSCA command (Select Message Service Centre) | |
384 */ | |
385 | |
386 GLOBAL T_ATI_RSLT atPlusCSCA (char *cl, UBYTE srcId) | |
387 { | |
388 T_ACI_RETURN ret = AT_FAIL; | |
389 T_ACI_TOA tosca; | |
390 T_ACI_TOA *p_tosca; | |
391 SHORT octet=0; | |
392 CHAR sca[MAX_SMS_NUM_LEN]; | |
393 | |
394 memset (sca, 0, sizeof(sca)); | |
395 p_tosca=&tosca; | |
396 | |
397 TRACE_FUNCTION("atPlusCSCA()"); | |
398 | |
399 /*input functionality*/ | |
400 cl = parse (cl,"sr",(LONG)MAX_SMS_NUM_LEN,sca,&octet); | |
401 if ( !cl OR octet > 0xC9 OR sca[0] EQ '\0') | |
402 { | |
403 cmdCmsError(CMS_ERR_OpNotAllowed); | |
404 return (ATI_FAIL); | |
405 } | |
406 if(octet EQ 0) | |
407 p_tosca=NULL; | |
408 else | |
409 { | |
410 tosca=toa_demerge(octet); | |
411 if (tosca.ton < 0 OR tosca.npi < 0) | |
412 { | |
413 cmdCmsError(CMS_ERR_OpNotAllowed); | |
414 return (ATI_FAIL); | |
415 } | |
416 } | |
417 #ifdef FF_ATI_BAT | |
418 { | |
419 T_BAT_cmd_send cmd; | |
420 T_BAT_cmd_set_plus_csca csca; | |
421 | |
422 cmd.ctrl_params = BAT_CMD_SET_PLUS_CSCA; | |
423 cmd.params.ptr_set_plus_csca = &csca; | |
424 | |
425 csca.c_sca = strlen(sca); | |
426 memcpy(csca.sca, sca, csca.c_sca); | |
427 csca.tosca = octet; | |
428 | |
429 TRACE_FUNCTION("atPlusCSCA() calls bat_send() <=== as APPLICATION"); | |
430 bat_send(ati_bat_get_client(srcId), &cmd); | |
431 | |
432 return (AT_EXCT); | |
433 } | |
434 #else /* FF_ATI_BAT */ | |
435 | |
436 ret = sAT_PlusCSCA((T_ACI_CMD_SRC)srcId,sca,p_tosca); | |
437 if (ret EQ AT_FAIL) | |
438 { | |
439 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
440 return (ATI_FAIL); | |
441 } | |
442 return (map_aci_2_ati_rslt(ret)); | |
443 #endif /* FF_ATI_BAT */ | |
444 } | |
445 | |
446 GLOBAL T_ATI_RSLT queatPlusCSCA (char *cl, UBYTE srcId) | |
447 { | |
448 #ifdef FF_ATI_BAT | |
449 T_BAT_cmd_send cmd; | |
450 T_BAT_no_parameter dummy; | |
451 | |
452 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CSCA; | |
453 dummy.bat_dummy = 0xFF; | |
454 cmd.params.ptr_que_plus_csca = &dummy; | |
455 | |
456 TRACE_FUNCTION("queatPlusCSCA() calls bat_send() <=== as APPLICATION"); | |
457 bat_send(ati_bat_get_client(srcId), &cmd); | |
458 | |
459 return (AT_EXCT); | |
460 | |
461 #else /* FF_ATI_BAT */ | |
462 | |
463 T_ACI_RETURN ret = AT_FAIL; | |
464 T_ACI_TOA tosca; | |
465 SHORT octet=0; | |
466 CHAR sca[MAX_SMS_NUM_LEN]; | |
467 | |
468 ret = qAT_PlusCSCA ((T_ACI_CMD_SRC)srcId,sca,&tosca); | |
469 if (ret EQ AT_CMPL) | |
470 { | |
471 octet=toa_merge(tosca); | |
472 sprintf(g_sa, "+CSCA: \"%s%s\",%d", (tosca.ton EQ TON_International)?"+":"", sca, octet); | |
473 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
474 return (ATI_CMPL); | |
475 } | |
476 else | |
477 { | |
478 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
479 return (ATI_FAIL); | |
480 } | |
481 #endif /* FF_ATI_BAT */ | |
482 } | |
483 | |
484 /* | |
485 +--------------------------------------------------------------------+ | |
486 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
487 | STATE : code ROUTINE : aci_decodeVpabs | | |
488 +--------------------------------------------------------------------+ | |
489 | |
490 PURPOSE : This function decodes a given string to the T_ACI_VP_ABS | |
491 enumeration type. | |
492 */ | |
493 LOCAL BOOL aci_decodeVpabs ( CHAR* vpabs_str, | |
494 T_ACI_VP_ABS* vpabs_enum ) | |
495 { | |
496 if ( strlen( vpabs_str ) NEQ 20 OR | |
497 | |
498 vpabs_str[2] NEQ '/' OR vpabs_str[5] NEQ '/' OR | |
499 vpabs_str[8] NEQ ',' OR vpabs_str[11] NEQ ':' OR | |
500 vpabs_str[14] NEQ ':' OR | |
501 | |
502 ( vpabs_str[17] NEQ '+' AND vpabs_str[17] NEQ '-' ) OR | |
503 | |
504 vpabs_str[18] < '0' OR vpabs_str[18] > '9' OR | |
505 vpabs_str[19] < '0' OR vpabs_str[19] > '9' ) | |
506 | |
507 return FALSE; | |
508 | |
509 vpabs_enum->year [0] = vpabs_str[0] - 0x30; | |
510 vpabs_enum->year [1] = vpabs_str[1] - 0x30; | |
511 | |
512 vpabs_enum->month [0] = vpabs_str[3] - 0x30; | |
513 vpabs_enum->month [1] = vpabs_str[4] - 0x30; | |
514 | |
515 vpabs_enum->day [0] = vpabs_str[6] - 0x30; | |
516 vpabs_enum->day [1] = vpabs_str[7] - 0x30; | |
517 | |
518 vpabs_enum->hour [0] = vpabs_str[9] - 0x30; | |
519 vpabs_enum->hour [1] = vpabs_str[10] - 0x30; | |
520 | |
521 vpabs_enum->minute[0] = vpabs_str[12] - 0x30; | |
522 vpabs_enum->minute[1] = vpabs_str[13] - 0x30; | |
523 | |
524 vpabs_enum->second[0] = vpabs_str[15] - 0x30; | |
525 vpabs_enum->second[1] = vpabs_str[16] - 0x30; | |
526 | |
527 vpabs_enum->timezone = (SHORT) atoi( &vpabs_str[17] ); | |
528 | |
529 return TRUE; | |
530 } | |
531 | |
532 /* | |
533 +--------------------------------------------------------------------+ | |
534 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
535 | STATE : code ROUTINE : aci_decodeVpenh | | |
536 +--------------------------------------------------------------------+ | |
537 | |
538 PURPOSE : This function decodes a given string to the T_ACI_VP_ENH | |
539 type. | |
540 */ | |
541 LOCAL BOOL aci_decodeVpenh ( CHAR* vpenh_str, | |
542 T_ACI_VP_ENH* vpenh ) | |
543 { | |
544 UBYTE shift_byte = 0; | |
545 | |
546 if (vpenh_str[0] EQ '\0') | |
547 { | |
548 return FALSE; | |
549 } | |
550 | |
551 /* functionality indicator */ | |
552 vpenh->func_ind = (vpenh_str[0] - 0x30) << 4; | |
553 vpenh->func_ind += (vpenh_str[1] - 0x30); | |
554 | |
555 /* extension octet */ | |
556 if (vpenh->func_ind & TP_VPF_ENH_EXT_BIT_MASK) | |
557 { | |
558 shift_byte = 2; | |
559 vpenh->ext_oct = (vpenh_str[2] - 0x30) << 4; | |
560 vpenh->ext_oct += (vpenh_str[3] - 0x30); | |
561 } | |
562 | |
563 if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) > TP_VPF_ENH_HRS) | |
564 { | |
565 return FALSE; | |
566 } | |
567 | |
568 /* process validity period values */ | |
569 if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_REL) | |
570 { | |
571 utl_HexStrToBin ((UBYTE*)&vpenh_str[2+shift_byte], 2, &vpenh->val.vpenh_relative, 1); | |
572 } | |
573 else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_SEC) | |
574 { | |
575 utl_HexStrToBin ((UBYTE*)&vpenh_str[2+shift_byte], 2, &vpenh->val.vpenh_seconds, 1); | |
576 } | |
577 else if ((vpenh->func_ind & TP_VPF_ENH_FORMAT_MASK) EQ TP_VPF_ENH_HRS) | |
578 { | |
579 vpenh->val.vpenh_hours.hour [0] = vpenh_str[3+shift_byte] - 0x30; | |
580 vpenh->val.vpenh_hours.hour [1] = vpenh_str[2+shift_byte] - 0x30; | |
581 | |
582 vpenh->val.vpenh_hours.minute[0] = vpenh_str[5+shift_byte] - 0x30; | |
583 vpenh->val.vpenh_hours.minute[1] = vpenh_str[4+shift_byte] - 0x30; | |
584 | |
585 vpenh->val.vpenh_hours.second[0] = vpenh_str[7+shift_byte] - 0x30; | |
586 vpenh->val.vpenh_hours.second[1] = vpenh_str[6+shift_byte] - 0x30; | |
587 } | |
588 | |
589 return TRUE; | |
590 } | |
591 | |
592 | |
593 /* | |
594 +--------------------------------------------------------------------+ | |
595 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
596 | STATE : code ROUTINE : atPlusCSMP | | |
597 +--------------------------------------------------------------------+ | |
598 | |
599 PURPOSE : +CSMP command (Select Text Mode Parameters) | |
600 */ | |
601 | |
602 GLOBAL T_ATI_RSLT atPlusCSMP (char *cl, UBYTE srcId) | |
603 { | |
604 T_ACI_RETURN ret = AT_FAIL; | |
605 SHORT fo = ACI_NumParmNotPresent, | |
606 vprel = ACI_NumParmNotPresent, | |
607 pid = ACI_NumParmNotPresent, | |
608 dcs = ACI_NumParmNotPresent; | |
609 USHORT i = 0; | |
610 char vpabs_str[25] = {'\0'}, | |
611 vpenh_str[15] = {'\0'}, | |
612 fo_str[4]; | |
613 | |
614 T_ACI_VP_ABS vpabs; | |
615 T_ACI_VP_ABS* pVpabs = NULL; | |
616 T_ACI_VP_ENH vpenh; | |
617 | |
618 TRACE_FUNCTION("atPlusCSMP()"); | |
619 | |
620 /*input functionality*/ | |
621 while (*cl NEQ ',' AND *cl NEQ '\0' AND i < sizeof(fo_str) - 1) | |
622 { | |
623 fo_str[i]=*cl; | |
624 cl++; | |
625 i++; | |
626 } | |
627 if (*cl) | |
628 { | |
629 cl++; | |
630 } | |
631 fo_str[i]='\0'; | |
632 if (strlen (fo_str) > 0) | |
633 { | |
634 fo=atoi(fo_str); | |
635 } | |
636 if (fo > 255) | |
637 { | |
638 cmdCmsError(CMS_ERR_OpNotAllowed); | |
639 return ATI_FAIL; | |
640 } | |
641 if (fo NEQ ACI_NumParmNotPresent AND | |
642 (fo & TP_VPF_MASK) EQ TP_VPF_ABSOLUTE) | |
643 { | |
644 pVpabs = &vpabs; | |
645 | |
646 cl = parse(cl,"srr",(LONG)25,vpabs_str,&pid,&dcs); | |
647 | |
648 if (!cl OR strlen(vpabs_str) > 20 OR pid > 255 OR | |
649 dcs > 255 OR !aci_decodeVpabs (vpabs_str, &vpabs)) | |
650 { | |
651 cmdCmsError(CMS_ERR_OpNotAllowed); | |
652 return (ATI_FAIL); | |
653 } | |
654 } | |
655 else if (fo NEQ ACI_NumParmNotPresent AND | |
656 (fo & TP_VPF_MASK) EQ TP_VPF_ENHANCED) | |
657 { | |
658 cl = parse(cl,"srr",(LONG)19,vpenh_str,&pid,&dcs); | |
659 if (!cl OR strlen(vpenh_str) > 14 OR pid > 255 OR | |
660 dcs > 255 OR !aci_decodeVpenh (vpenh_str, &vpenh)) | |
661 { | |
662 cmdCmsError(CMS_ERR_OpNotAllowed); | |
663 return (ATI_FAIL); | |
664 } | |
665 } | |
666 else if (fo NEQ ACI_NumParmNotPresent AND | |
667 (fo & TP_VPF_MASK) EQ TP_VPF_RELATIVE) | |
668 { | |
669 cl = parse(cl,"rrr",&vprel,&pid,&dcs); | |
670 } | |
671 else | |
672 { | |
673 if (*cl EQ '\"') | |
674 { | |
675 pVpabs = &vpabs; | |
676 | |
677 cl = parse(cl,"srr",(LONG)25,vpabs_str,&pid,&dcs); | |
678 | |
679 if (!cl OR strlen(vpabs_str) > 20 OR pid > 255 OR | |
680 dcs > 255 OR !aci_decodeVpabs (vpabs_str, &vpabs)) | |
681 { | |
682 cmdCmsError(CMS_ERR_OpNotAllowed); | |
683 return (ATI_FAIL); | |
684 } | |
685 } | |
686 else | |
687 { | |
688 cl = parse(cl,"rrr",&vprel,&pid,&dcs); | |
689 | |
690 if ( !cl OR vprel > 255 OR pid > 255 OR dcs > 255) | |
691 { | |
692 cmdCmsError(CMS_ERR_OpNotAllowed); | |
693 return (ATI_FAIL); | |
694 } | |
695 } | |
696 } | |
697 ret = sAT_PlusCSMP((T_ACI_CMD_SRC)srcId,fo,vprel,pVpabs,&vpenh,pid,dcs); | |
698 if (ret EQ AT_FAIL) | |
699 { | |
700 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
701 return (ATI_FAIL); | |
702 } | |
703 return (map_aci_2_ati_rslt(ret)); | |
704 } | |
705 | |
706 GLOBAL T_ATI_RSLT queatPlusCSMP (char *cl, UBYTE srcId) | |
707 { | |
708 char* me = "+CSMP: "; | |
709 T_ACI_RETURN ret = AT_FAIL; | |
710 SHORT fo = ACI_NumParmNotPresent, | |
711 vprel = ACI_NumParmNotPresent, | |
712 pid = ACI_NumParmNotPresent, | |
713 dcs = ACI_NumParmNotPresent; | |
714 char vpabs_str[25] = {'\0'}; | |
715 char vpenh_str[15] = {'\0'}; | |
716 T_ACI_VP_ABS vpabs; | |
717 T_ACI_VP_ENH vpenh; | |
718 | |
719 TRACE_FUNCTION("queatPlusCSMP()"); | |
720 | |
721 ret = qAT_PlusCSMP((T_ACI_CMD_SRC)srcId,&fo,&vprel,&vpabs,&vpenh,&pid,&dcs); | |
722 if (ret EQ AT_CMPL) | |
723 { | |
724 if ((fo & TP_VPF_MASK) EQ TP_VPF_ABSOLUTE) /*Bits 4,3 -> 11*/ | |
725 { | |
726 sprintf(vpabs_str,"\"%d%d/%d%d/%d%d,%d%d:%d%d:%d%d%+03d\"", | |
727 vpabs.year [0], vpabs.year [1], | |
728 vpabs.month [0], vpabs.month [1], | |
729 vpabs.day [0], vpabs.day [1], | |
730 vpabs.hour [0], vpabs.hour [1], | |
731 vpabs.minute[0], vpabs.minute[1], | |
732 vpabs.second[0], vpabs.second[1], | |
733 vpabs.timezone); | |
734 sprintf(g_sa,"%s%d,%s,%d,%d",me,fo,vpabs_str,pid,dcs); | |
735 } | |
736 else if ((fo & TP_VPF_MASK) EQ TP_VPF_ENHANCED) | |
737 { | |
738 aci_encodeVpenh ( vpenh_str, &vpenh ); | |
739 sprintf(g_sa,"%s%d,\"%s\",%d,%d",me,fo,vpenh_str,pid,dcs); | |
740 } | |
741 else if ((fo & TP_VPF_MASK) EQ TP_VPF_RELATIVE) /*Bits 4,3 -> 10*/ | |
742 { | |
743 sprintf(g_sa,"%s%d,%d,%d,%d",me,fo,vprel,pid,dcs); | |
744 } | |
745 else | |
746 { | |
747 sprintf(g_sa,"%s%d,,%d,%d",me,fo,pid,dcs); | |
748 } | |
749 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
750 return (ATI_CMPL); | |
751 } | |
752 else | |
753 { | |
754 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
755 return (ATI_FAIL); | |
756 } | |
757 } | |
758 | |
759 /* | |
760 +--------------------------------------------------------------------+ | |
761 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
762 | STATE : code ROUTINE : atPlusCSDH | | |
763 +--------------------------------------------------------------------+ | |
764 | |
765 PURPOSE : +CSDH command (Show Text Mode Parameters) | |
766 */ | |
767 | |
768 GLOBAL T_ATI_RSLT atPlusCSDH (char *cl, UBYTE srcId) | |
769 { | |
770 | |
771 T_ACI_CSDH_SHOW ena = CSDH_SHOW_Disable; | |
772 | |
773 TRACE_FUNCTION("atPlusCSDH()"); | |
774 | |
775 /*input functionality*/ | |
776 cl = parse(cl,"d",&ena); | |
777 if ( !cl ) | |
778 { | |
779 cmdCmsError(CMS_ERR_OpNotAllowed); | |
780 return (ATI_FAIL); | |
781 } | |
782 ati_user_output_cfg[srcId].CSDH_stat=ena; | |
783 return (ATI_CMPL); | |
784 } | |
785 | |
786 GLOBAL T_ATI_RSLT tesatPlusCSDH (char *cl, UBYTE srcId) | |
787 { | |
788 return(atPlusCSDH (cl, srcId)); | |
789 } | |
790 | |
791 GLOBAL T_ATI_RSLT queatPlusCSDH (char *cl, UBYTE srcId) | |
792 { | |
793 sprintf(g_sa,"+CSDH: %d",ati_user_output_cfg[srcId].CSDH_stat); | |
794 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
795 return (ATI_CMPL); | |
796 } | |
797 | |
798 /* | |
799 +--------------------------------------------------------------------+ | |
800 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
801 | STATE : code ROUTINE : atPlusCSCB | | |
802 +--------------------------------------------------------------------+ | |
803 | |
804 PURPOSE : +CSCB command (select cell broadcast message type) | |
805 */ | |
806 | |
807 GLOBAL T_ATI_RSLT atPlusCSCB (char *cl, UBYTE srcId) | |
808 { | |
809 T_ACI_RETURN ret = AT_FAIL; | |
810 T_ACI_CSCB_MOD mode; | |
811 char mids_str[6*MAX_CBM_TYPES]={0}; /* CHECK IF LONG ENOUGH !!*/ | |
812 char dcss_str[4*MAX_CBM_TYPES]={0}; | |
813 CHAR buf[6]={0}; | |
814 USHORT mids[MAX_CBM_TYPES]; | |
815 UBYTE dcss[MAX_CBM_TYPES]; | |
816 SHORT pos=0,i=0,j=0; | |
817 | |
818 #ifdef FF_ATI_BAT | |
819 T_BAT_cmd_set_plus_cscb cscb; | |
820 #endif | |
821 | |
822 | |
823 TRACE_FUNCTION("atPlusCSCB()"); | |
824 | |
825 /*input functionality*/ | |
826 cl = parse(cl,"dss",&mode,(LONG)sizeof(mids_str),mids_str,(LONG)sizeof(dcss_str),dcss_str); | |
827 if ( !cl ) | |
828 { | |
829 cmdCmsError(CMS_ERR_OpNotAllowed); | |
830 return (ATI_FAIL); | |
831 } | |
832 i = j = 0; | |
833 memset (mids, NOT_PRESENT_8BIT, sizeof (mids)); | |
834 while (mids_str[i] NEQ '\0' AND j < MAX_CBM_TYPES - 1) | |
835 { | |
836 pos=0; | |
837 while (mids_str[i] >= '0' AND mids_str[i] <= '9') | |
838 { | |
839 if (pos >= 5) | |
840 { | |
841 cmdCmsError(CMS_ERR_OpNotAllowed); | |
842 return (ATI_FAIL); | |
843 } | |
844 buf[pos++]=mids_str[i]; | |
845 i++; | |
846 } | |
847 buf[pos]='\0'; | |
848 if (mids_str[i] NEQ ',' AND mids_str[i] NEQ '-' AND mids_str[i] NEQ '\0') | |
849 { | |
850 cmdCmsError(CMS_ERR_OpNotAllowed); | |
851 return (ATI_FAIL); | |
852 } | |
853 else | |
854 { | |
855 if (mids_str[i] EQ ',' OR mids_str[i] EQ '\0') | |
856 { | |
857 i++; | |
858 mids[j++]=atoi(buf); | |
859 mids[j++]=atoi(buf); | |
860 } | |
861 else | |
862 { | |
863 i++; | |
864 mids[j++]=atoi(buf); | |
865 pos=0; | |
866 while (mids_str[i] NEQ ',' AND mids_str[i] NEQ '\0') | |
867 { | |
868 if (pos >= 5) | |
869 { | |
870 cmdCmsError(CMS_ERR_OpNotAllowed); | |
871 return (ATI_FAIL); | |
872 } | |
873 buf[pos++]=mids_str[i]; | |
874 i++; | |
875 } | |
876 i++; | |
877 mids[j++]=atoi(buf); | |
878 } | |
879 } | |
880 } | |
881 | |
882 if (compact(&mids_str[i],(USHORT)strlen(&mids_str[i])) NEQ 0) | |
883 { | |
884 cmdCmsError(CMS_ERR_OpNotAllowed); | |
885 return (ATI_FAIL); | |
886 } | |
887 | |
888 #ifdef FF_ATI_BAT | |
889 memset(cscb.mids, NOT_PRESENT_8BIT, sizeof(cscb.mids)); | |
890 cscb.v_mids = j ? TRUE : FALSE; | |
891 cscb.c_mids = (U8)j; | |
892 memcpy(cscb.mids, mids, j*2); | |
893 #endif | |
894 | |
895 i = j = 0; | |
896 memset (dcss, NOT_PRESENT_8BIT, sizeof (dcss)); | |
897 while (dcss_str[i] NEQ '\0' AND j < MAX_CBM_TYPES - 1) | |
898 { | |
899 pos=0; | |
900 while (dcss_str[i] >= '0' AND dcss_str[i] <= '9') | |
901 { | |
902 if (pos >= 3) | |
903 { | |
904 cmdCmsError(CMS_ERR_OpNotAllowed); | |
905 return (ATI_FAIL); | |
906 } | |
907 buf[pos++]=dcss_str[i]; | |
908 i++; | |
909 } | |
910 buf[pos]='\0'; | |
911 if (dcss_str[i] NEQ ',' AND dcss_str[i] NEQ '-' AND dcss_str[i] NEQ '\0') | |
912 { | |
913 cmdCmsError(CMS_ERR_OpNotAllowed); | |
914 return (ATI_FAIL); | |
915 } | |
916 else | |
917 { | |
918 if (dcss_str[i] EQ ',' OR dcss_str[i] EQ '\0') | |
919 { | |
920 i++; | |
921 dcss[j++]=atoi(buf); | |
922 dcss[j++]=atoi(buf); | |
923 } | |
924 else | |
925 { | |
926 i++; | |
927 dcss[j++]=atoi(buf); | |
928 pos=0; | |
929 while (dcss_str[i] NEQ ',' AND dcss_str[i] NEQ '\0') | |
930 { | |
931 if (pos >= 3) | |
932 { | |
933 cmdCmsError(CMS_ERR_OpNotAllowed); | |
934 return (ATI_FAIL); | |
935 } | |
936 buf[pos++]=dcss_str[i]; | |
937 i++; | |
938 } | |
939 i++; | |
940 dcss[j++]=atoi(buf); | |
941 } | |
942 } | |
943 } | |
944 if (compact(&dcss_str[i],(USHORT)strlen(&dcss_str[i])) NEQ 0) | |
945 { | |
946 cmdCmsError(CMS_ERR_OpNotAllowed); | |
947 return (ATI_FAIL); | |
948 } | |
949 | |
950 #ifdef FF_ATI_BAT | |
951 { | |
952 T_BAT_cmd_send cmd; | |
953 | |
954 cmd.ctrl_params = BAT_CMD_SET_PLUS_CSCB; | |
955 cmd.params.ptr_set_plus_cscb = &cscb; | |
956 | |
957 cscb.mode = (T_BAT_VAL_plus_cscb_mode)mode; | |
958 | |
959 memset(cscb.dcss, NOT_PRESENT_8BIT, sizeof(cscb.dcss)); | |
960 cscb.v_dcss = j ? TRUE : FALSE;; | |
961 cscb.c_dcss = (U8)j; | |
962 memcpy(cscb.dcss, dcss, cscb.c_dcss); | |
963 | |
964 | |
965 TRACE_FUNCTION("atPlusCSCB() calls bat_send() <=== as APPLICATION"); | |
966 bat_send(ati_bat_get_client(srcId), &cmd); | |
967 return (AT_EXCT); | |
968 } | |
969 #else /* FF_ATI_BAT */ | |
970 ret=sAT_PlusCSCB((T_ACI_CMD_SRC)srcId,mode,mids,dcss); | |
971 if (ret EQ AT_FAIL) | |
972 { | |
973 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
974 return (ATI_FAIL); | |
975 } | |
976 return (map_aci_2_ati_rslt(ret)); | |
977 #endif /* FF_ATI_BAT */ | |
978 } | |
979 | |
980 GLOBAL T_ATI_RSLT queatPlusCSCB (char *cl, UBYTE srcId) | |
981 { | |
982 #ifdef FF_ATI_BAT | |
983 T_BAT_cmd_send cmd; | |
984 T_BAT_no_parameter dummy; | |
985 | |
986 cmd.ctrl_params = BAT_CMD_QUE_PLUS_CSCB; | |
987 dummy.bat_dummy = 0xFF; | |
988 cmd.params.ptr_que_plus_cscb = &dummy; | |
989 | |
990 TRACE_FUNCTION("queatPlusCSCB() calls bat_send() <=== as APPLICATION"); | |
991 bat_send(ati_bat_get_client(srcId), &cmd); | |
992 | |
993 return (AT_EXCT); | |
994 | |
995 #else /* FF_ATI_BAT */ | |
996 T_ACI_CSCB_MOD mode; | |
997 char mids_str[6*MAX_CBM_TYPES+1]={'\0'}; /* +1 for '\0' */ /* CHECK IF LONG ENOUGH !!*/ | |
998 char dcss_str[4*MAX_CBM_TYPES+1]={'\0'}; | |
999 USHORT mids[MAX_CBM_TYPES]; | |
1000 UBYTE dcss[MAX_CBM_TYPES]; | |
1001 SHORT pos=0,i=0; | |
1002 T_ACI_RETURN ret = AT_FAIL; | |
1003 | |
1004 TRACE_FUNCTION("queatPlusCSCB()"); | |
1005 | |
1006 ret = qAT_PlusCSCB((T_ACI_CMD_SRC)srcId, &mode,mids,dcss); | |
1007 if (ret EQ AT_CMPL) | |
1008 { | |
1009 /* | |
1010 *----------------------------------------------------------- | |
1011 * assemble the string for message identifiers | |
1012 *----------------------------------------------------------- | |
1013 */ | |
1014 pos = i = 0; | |
1015 while( mids[i] NEQ 0xFFFF AND | |
1016 mids[i+1] NEQ 0xFFFF AND | |
1017 i < MAX_CBM_TYPES - 1 ) | |
1018 { | |
1019 if ( mids[i] EQ mids[i+1] ) | |
1020 pos += sprintf ( mids_str + pos, "%d,", mids[i] ); | |
1021 else | |
1022 pos += sprintf ( mids_str + pos, "%d-%d,", mids[i], mids[i+1] ); /* "65534-65535," max 12 chars */ | |
1023 | |
1024 i += 2; | |
1025 } | |
1026 | |
1027 /*lint -e(661) -e(662) */ /* lint 7.5 has here some problems ... */ | |
1028 if ( pos > 0 ) /* remove the last ',' */ | |
1029 { | |
1030 mids_str[pos-1] = '\0'; | |
1031 } | |
1032 | |
1033 /* | |
1034 *----------------------------------------------------------- | |
1035 * assemble the string for data coding schemes | |
1036 *----------------------------------------------------------- | |
1037 */ | |
1038 pos = i = 0; | |
1039 while( dcss[i] NEQ 0xFF AND | |
1040 dcss[i+1] NEQ 0xFF AND | |
1041 i < MAX_CBM_TYPES - 1 ) | |
1042 { | |
1043 if ( dcss[i] EQ dcss[i+1] ) | |
1044 pos += sprintf ( dcss_str + pos, "%d,", dcss[i] ); | |
1045 else | |
1046 pos += sprintf ( dcss_str + pos, "%d-%d,", dcss[i], dcss[i+1] ); | |
1047 | |
1048 i += 2; | |
1049 } | |
1050 | |
1051 /*lint -e(661) -e(662) */ | |
1052 if ( pos > 0 ) /* remove the last ',' */ | |
1053 { | |
1054 dcss_str[pos-1] = '\0'; | |
1055 } | |
1056 | |
1057 sprintf(g_sa,"+CSCB: %d,\"%s\",\"%s\"",mode,mids_str,dcss_str); | |
1058 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1059 return (ATI_CMPL); | |
1060 } | |
1061 else | |
1062 { | |
1063 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1064 return (ATI_FAIL); | |
1065 } | |
1066 #endif /* FF_ATI_BAT */ | |
1067 } | |
1068 | |
1069 #ifdef FF_HOMEZONE | |
1070 /* | |
1071 +--------------------------------------------------------------------+ | |
1072 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1073 | STATE : code ROUTINE : atPercentCBHZ | | |
1074 +--------------------------------------------------------------------+ | |
1075 | |
1076 PURPOSE : %CBHZ command (set homezone activity) | |
1077 */ | |
1078 | |
1079 GLOBAL T_ATI_RSLT setatPercentCBHZ (char *cl, UBYTE srcId) | |
1080 { | |
1081 T_ACI_CBHZ_MOD mode = CBHZ_MOD_NotPresent; | |
1082 T_ACI_CS dcs = CS_NotPresent; | |
1083 UBYTE timeout = NOT_PRESENT_8BIT; | |
1084 T_ACI_RETURN ret = AT_FAIL; | |
1085 | |
1086 TRACE_FUNCTION("setatPercentCBHZ()"); | |
1087 | |
1088 | |
1089 /*input functionality*/ | |
1090 | |
1091 /*check first parameter */ | |
1092 switch (*cl) | |
1093 { | |
1094 case '0': | |
1095 case '1': | |
1096 mode = (T_ACI_CBHZ_MOD)(*cl - 0x30); | |
1097 cl++; | |
1098 break; | |
1099 | |
1100 default: | |
1101 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1102 return (ATI_FAIL); | |
1103 } | |
1104 | |
1105 /* check second parameter */ | |
1106 if ( *cl NEQ '\0' ) | |
1107 { | |
1108 if ( *cl NEQ ',') | |
1109 { | |
1110 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1111 return (ATI_FAIL); | |
1112 } | |
1113 cl++; | |
1114 | |
1115 if ( (*cl >= '0') AND (*cl <= '9') ) | |
1116 { | |
1117 dcs = (T_ACI_CS)(*cl -0x30); | |
1118 cl++; | |
1119 } | |
1120 | |
1121 /* check third parameter */ | |
1122 if ( *cl NEQ '\0' ) | |
1123 { | |
1124 if ( *cl NEQ ',') | |
1125 { | |
1126 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1127 return (ATI_FAIL); | |
1128 } | |
1129 cl++; | |
1130 | |
1131 cl = parse(cl,"d",&timeout); | |
1132 if ( *cl NEQ '\0' ) | |
1133 { | |
1134 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1135 return (ATI_FAIL); | |
1136 } | |
1137 } | |
1138 } | |
1139 | |
1140 /* parameters ok... process homezone request */ | |
1141 ret = sAT_PercentCBHZ((T_ACI_CMD_SRC)srcId,mode,dcs,timeout); | |
1142 if (ret EQ AT_FAIL) | |
1143 { | |
1144 cmdCmeError(CME_ERR_Unknown); | |
1145 return (ATI_FAIL); | |
1146 } | |
1147 | |
1148 return (ATI_CMPL); | |
1149 } | |
1150 | |
1151 | |
1152 GLOBAL T_ATI_RSLT tesatPercentCBHZ (char *cl, UBYTE srcId) | |
1153 { | |
1154 TRACE_FUNCTION("tesatPercentCBHZ()"); | |
1155 | |
1156 sprintf( g_sa, "%s: (%d,%d),(%d-%d),(%d-%d)", | |
1157 "%CBHZ", CBHZ_MOD_NotActive, CBHZ_MOD_Active, | |
1158 CS_GsmDef, CS_Ascii, CBHZ_MIN_TIMEOUT, CBHZ_MAX_TIMEOUT); | |
1159 | |
1160 | |
1161 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1162 | |
1163 return (ATI_CMPL); | |
1164 } | |
1165 | |
1166 GLOBAL T_ATI_RSLT queatPercentCBHZ (char *cl, UBYTE srcId) | |
1167 { | |
1168 T_ACI_RETURN ret; | |
1169 T_ACI_CBHZ_MOD mode; | |
1170 T_ACI_CS dcs; | |
1171 UBYTE timeout; | |
1172 | |
1173 TRACE_FUNCTION("queatPercentCBSHZ()"); | |
1174 | |
1175 ret = qAT_PercentCBHZ((T_ACI_CMD_SRC)srcId, &mode, &dcs, &timeout); | |
1176 | |
1177 if (ret EQ AT_FAIL) | |
1178 { | |
1179 cmdCmeError(CME_ERR_Unknown); | |
1180 return (ATI_FAIL); | |
1181 } | |
1182 | |
1183 /* | |
1184 *----------------------------------------------------------- | |
1185 * assemble the string for output | |
1186 *----------------------------------------------------------- | |
1187 */ | |
1188 | |
1189 sprintf( g_sa, "%s: %d,%d,%d", "%CBHZ", mode, dcs, timeout); | |
1190 | |
1191 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
1192 | |
1193 return (ATI_CMPL); | |
1194 } | |
1195 #endif /* FF_HOMEZONE */ | |
1196 | |
1197 /* | |
1198 +--------------------------------------------------------------------+ | |
1199 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1200 | STATE : code ROUTINE : atPlusCSAS | | |
1201 +--------------------------------------------------------------------+ | |
1202 | |
1203 PURPOSE : +CSAS command (Save SMS Profile) | |
1204 */ | |
1205 | |
1206 GLOBAL T_ATI_RSLT atPlusCSAS (char *cl, UBYTE srcId) | |
1207 { | |
1208 SHORT profile = -1; | |
1209 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1210 | |
1211 TRACE_FUNCTION("atPlusCSAS()"); | |
1212 | |
1213 if ( *cl EQ '\0' ) | |
1214 { | |
1215 profile = 1; | |
1216 } | |
1217 else | |
1218 { | |
1219 cl = parse ( cl, "r", &profile ); | |
1220 if ( !cl ) | |
1221 { | |
1222 cmdCmsError ( CMS_ERR_MemFail ); | |
1223 return (ATI_FAIL); | |
1224 } | |
1225 profile++; | |
1226 } | |
1227 #ifdef FF_ATI_BAT | |
1228 { | |
1229 T_BAT_cmd_send cmd; | |
1230 T_BAT_cmd_set_plus_csas csas; | |
1231 | |
1232 cmd.ctrl_params = BAT_CMD_SET_PLUS_CSAS; | |
1233 cmd.params.ptr_set_plus_csas = &csas; | |
1234 | |
1235 csas.profile = profile; | |
1236 | |
1237 TRACE_FUNCTION("atPlusCSAS() calls bat_send() <=== as APPLICATION"); | |
1238 bat_send(ati_bat_get_client(srcId), &cmd); | |
1239 return (AT_EXCT); | |
1240 } | |
1241 #else /* FF_ATI_BAT */ | |
1242 switch (sAT_PlusCSAS ((T_ACI_CMD_SRC)srcId, profile)) | |
1243 { | |
1244 case AT_EXCT: | |
1245 src_params->curAtCmd = AT_CMD_CSAS; | |
1246 return (ATI_EXCT); | |
1247 | |
1248 case AT_BUSY: | |
1249 return (ATI_BUSY); | |
1250 | |
1251 case AT_CMPL: | |
1252 return (ATI_CMPL_NO_OUTPUT); | |
1253 | |
1254 case AT_FAIL: /* execution of command failed */ | |
1255 default: | |
1256 cmdCmsError ( CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1257 return (ATI_FAIL); | |
1258 } | |
1259 #endif /* FF_ATI_BAT */ | |
1260 } | |
1261 | |
1262 GLOBAL T_ATI_RSLT tesatPlusCSAS (char *cl, UBYTE srcId) | |
1263 { | |
1264 SHORT profile = -1; | |
1265 | |
1266 if ((profile = cmhSMS_getPrfRge ()) < 1) | |
1267 { | |
1268 cmdCmsError ( CMS_ERR_MemFail ); | |
1269 return (ATI_FAIL); | |
1270 } | |
1271 else | |
1272 { | |
1273 sprintf ( g_sa, "+CSAS: (0-%d)", profile - 1 ); | |
1274 io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT ); | |
1275 return (ATI_CMPL); | |
1276 } | |
1277 } | |
1278 | |
1279 /* | |
1280 +--------------------------------------------------------------------+ | |
1281 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1282 | STATE : code ROUTINE : atPlusCRES | | |
1283 +--------------------------------------------------------------------+ | |
1284 | |
1285 PURPOSE : +CRES command (Load SMS Profile) | |
1286 */ | |
1287 | |
1288 GLOBAL T_ATI_RSLT atPlusCRES (char *cl, UBYTE srcId) | |
1289 { | |
1290 SHORT profile = -1; | |
1291 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1292 | |
1293 TRACE_FUNCTION("atPlusCRES()"); | |
1294 | |
1295 if ( *cl EQ '\0' ) | |
1296 { | |
1297 profile = 1; | |
1298 } | |
1299 else | |
1300 { | |
1301 cl = parse ( cl, "r", &profile ); | |
1302 | |
1303 if ( !cl ) | |
1304 { | |
1305 cmdCmsError ( CMS_ERR_MemFail ); | |
1306 return (ATI_FAIL); | |
1307 } | |
1308 profile++; | |
1309 } | |
1310 | |
1311 switch (sAT_PlusCRES ((T_ACI_CMD_SRC)srcId, profile)) | |
1312 { | |
1313 case AT_EXCT: | |
1314 src_params->curAtCmd = AT_CMD_CRES; | |
1315 return (ATI_EXCT); | |
1316 | |
1317 case AT_BUSY: | |
1318 return (ATI_BUSY); | |
1319 | |
1320 case AT_CMPL: | |
1321 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
1322 return (ATI_CMPL_NO_OUTPUT); | |
1323 | |
1324 case AT_FAIL: | |
1325 default: | |
1326 cmdCmsError ( CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1327 return (ATI_FAIL); | |
1328 } | |
1329 } | |
1330 | |
1331 GLOBAL T_ATI_RSLT tesatPlusCRES (char *cl, UBYTE srcId) | |
1332 { | |
1333 T_ACI_CRES profile; | |
1334 T_ACI_RETURN result; | |
1335 | |
1336 result = tAT_PlusCRES ((T_ACI_CMD_SRC)srcId, &profile); | |
1337 switch (result) | |
1338 { | |
1339 case AT_FAIL: | |
1340 cmdCmsError ( CMS_ERR_MemFail ); | |
1341 return (ATI_FAIL); | |
1342 | |
1343 case AT_CMPL: | |
1344 break; | |
1345 | |
1346 default: | |
1347 cmdCmsError ( CMS_ERR_MemFail ); | |
1348 return (ATI_FAIL); | |
1349 } | |
1350 | |
1351 sprintf ( g_sa, "+CRES: (%d-%d)", profile.min, profile.max); | |
1352 io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT ); | |
1353 return (ATI_CMPL); | |
1354 } | |
1355 | |
1356 /* | |
1357 +--------------------------------------------------------------------+ | |
1358 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1359 | STATE : code ROUTINE : atPlusCMGR | | |
1360 +--------------------------------------------------------------------+ | |
1361 | |
1362 PURPOSE : +CMGR command (Read Message) | |
1363 */ | |
1364 | |
1365 GLOBAL T_ATI_RSLT atPlusCMGR (char *cl, UBYTE srcId) | |
1366 { | |
1367 T_ACI_RETURN ret = AT_FAIL; | |
1368 SHORT idx=-1; | |
1369 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1370 | |
1371 TRACE_FUNCTION("atPlusCMGR()"); | |
1372 | |
1373 #ifndef WIN32 | |
1374 cl = parse(cl,"r",&idx); | |
1375 #else | |
1376 cl = parse(cl,"rd",&idx, &smsReadMode ); | |
1377 #endif | |
1378 if ( !cl OR idx > 255 OR idx < 0) | |
1379 { | |
1380 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1381 return (ATI_FAIL); | |
1382 } | |
1383 | |
1384 #ifdef FF_ATI_BAT | |
1385 | |
1386 { | |
1387 T_BAT_cmd_send cmd; | |
1388 T_BAT_cmd_set_plus_cmgr cmgr; | |
1389 | |
1390 cmd.ctrl_params=BAT_CMD_SET_PLUS_CMGR; | |
1391 cmd.params.ptr_set_plus_cmgr=&cmgr; | |
1392 | |
1393 cmgr.sms_index=(U16)idx; | |
1394 | |
1395 bat_send(ati_bat_get_client(srcId), &cmd); | |
1396 | |
1397 src_params->curAtCmd=AT_CMD_CMGR; | |
1398 return(ATI_EXCT); | |
1399 } | |
1400 | |
1401 #else | |
1402 | |
1403 #ifndef _CONC_TESTING_ | |
1404 #ifndef _SIMULATION_ | |
1405 ret = sAT_PlusCMGR_Gl((T_ACI_CMD_SRC)srcId, (UBYTE)idx, SMS_READ_Normal, NULL); | |
1406 #else | |
1407 ret = sAT_PlusCMGR_Gl(srcId, (UBYTE)idx, smsReadMode , NULL); | |
1408 #endif | |
1409 #else | |
1410 #ifndef _SIMULATION_ | |
1411 ret = sAT_PlusCMGR (srcId, (UBYTE)idx, SMS_READ_Normal); | |
1412 #else | |
1413 ret = sAT_PlusCMGR (srcId, (UBYTE)idx, smsReadMode ); | |
1414 #endif | |
1415 #endif | |
1416 if ( ret EQ AT_CMPL ) | |
1417 { | |
1418 return (ATI_CMPL); | |
1419 } | |
1420 else if (ret EQ AT_EXCT) | |
1421 { | |
1422 src_params->curAtCmd = AT_CMD_CMGR; | |
1423 return (ATI_EXCT); | |
1424 } | |
1425 else | |
1426 { | |
1427 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1428 return (ATI_FAIL); | |
1429 } | |
1430 | |
1431 #endif /*FF_ATI_BAT*/ | |
1432 } | |
1433 | |
1434 /* | |
1435 +--------------------------------------------------------------------+ | |
1436 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1437 | STATE : code ROUTINE : atPlusCMGS | | |
1438 +--------------------------------------------------------------------+ | |
1439 | |
1440 PURPOSE : +CMGS command (SEND Message) | |
1441 */ | |
1442 | |
1443 GLOBAL T_ATI_RSLT tesatPlusCMGS (char *cl, UBYTE srcId) | |
1444 { | |
1445 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
1446 return ATI_CMPL_NO_OUTPUT; | |
1447 } | |
1448 | |
1449 GLOBAL T_ATI_RSLT queatPlusCMGS (char *cl, UBYTE srcId) | |
1450 { | |
1451 cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CMGS not specified in 07.05 */ | |
1452 return (ATI_FAIL); | |
1453 } | |
1454 | |
1455 | |
1456 GLOBAL T_ATI_RSLT atPlusCMGS (char *cl, UBYTE srcId) | |
1457 #if defined (SMS_PDU_SUPPORT) | |
1458 { | |
1459 T_ACI_CMGF_MOD mode; | |
1460 | |
1461 TRACE_FUNCTION("atPlusCMGS()"); | |
1462 /* | |
1463 * request current mode | |
1464 */ | |
1465 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
1466 if (mode EQ 0) | |
1467 { | |
1468 /* | |
1469 * handle PDU mode | |
1470 */ | |
1471 return (atPlusCMGSPdu (cl, srcId)); | |
1472 } | |
1473 else | |
1474 { | |
1475 /* | |
1476 * handle Text mode | |
1477 */ | |
1478 return (atPlusCMGSText (cl, srcId)); | |
1479 } | |
1480 } | |
1481 | |
1482 | |
1483 /* | |
1484 +--------------------------------------------------------------------+ | |
1485 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1486 | STATE : code ROUTINE : str_to_bcd | | |
1487 +--------------------------------------------------------------------+ | |
1488 | |
1489 PURPOSE : A very specialised routine for converting a 2-byte string | |
1490 into one byte of BCD, intended to be used by atPlusCMGSText() | |
1491 only. | |
1492 */ | |
1493 LOCAL T_ATI_RSLT atPlusCMGSText(char *cl, UBYTE srcId) | |
1494 #endif /* (SMS_PDU_SUPPORT) */ | |
1495 { | |
1496 T_ACI_VP_ABS vpabs; | |
1497 SHORT fo, | |
1498 vprel, | |
1499 pid, | |
1500 dcs; | |
1501 T_ACI_RETURN ret = AT_FAIL; | |
1502 T_ACI_TOA toda; | |
1503 T_ACI_TOA* p_toda; | |
1504 T_ACI_SM_DATA msg; | |
1505 USHORT lenMsg; | |
1506 CHAR* da = daBuf; | |
1507 USHORT dalen = 0; | |
1508 UBYTE dest_addr[MAX_SMS_NUM_LEN]; | |
1509 | |
1510 size_t strg_len; | |
1511 #ifdef WIN32 | |
1512 static T_ACI_TOA tosca; | |
1513 SHORT octet=0; | |
1514 #endif /* WIN32 */ | |
1515 #if defined WIN32 OR defined _SIMULATION_ | |
1516 static T_ACI_TOA *p_tosca; | |
1517 static SHORT isReply; | |
1518 #endif | |
1519 #ifdef _SIMULATION_ | |
1520 CHAR *sca =subBuf; | |
1521 #endif /* _SIMULATION_ */ | |
1522 | |
1523 #if defined _CONC_TESTING_ AND defined TI_PS_FF_CONC_SMS | |
1524 T_SM_DATA_EXT msg_conc; | |
1525 #endif | |
1526 | |
1527 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1528 | |
1529 if (src_params->text_mode EQ CMD_MODE) | |
1530 { | |
1531 TRACE_FUNCTION("atPlusCMGSText() CMD_MODE"); | |
1532 memset (da, 0, MAX_SMS_NUM_LEN); | |
1533 toda_val = 0; | |
1534 /* input functionality */ | |
1535 da[0]='\0'; | |
1536 #ifndef WIN32 | |
1537 switch(ati_user_output_cfg[srcId].cscsChset) | |
1538 { | |
1539 case CSCS_CHSET_Hex: | |
1540 cl = parse (cl,"sr",(LONG)MAX_SMS_NUM_LEN*2,da,&toda_val); | |
1541 break; | |
1542 case CSCS_CHSET_Ucs2: | |
1543 cl = parse (cl,"sr",(LONG)MAX_SMS_NUM_LEN*4,da,&toda_val); | |
1544 break; | |
1545 default: | |
1546 cl = parse (cl,"sr",(LONG)MAX_SMS_NUM_LEN,da,&toda_val); | |
1547 break; | |
1548 } | |
1549 | |
1550 if ( !cl OR da[0] EQ '\0') | |
1551 { | |
1552 cmdCmsError (CMS_ERR_OpNotAllowed); | |
1553 return (ATI_FAIL); | |
1554 } | |
1555 #else | |
1556 *sca ='\0'; | |
1557 isReply = -1; | |
1558 switch(ati_user_output_cfg[srcId].cscsChset) | |
1559 { | |
1560 case CSCS_CHSET_Hex: | |
1561 cl = parse (cl,"srsrb",(LONG)MAX_SMS_NUM_LEN*2,da,&toda_val, | |
1562 (LONG)MAX_SMS_NUM_LEN*2,sca,&octet,&isReply); | |
1563 break; | |
1564 case CSCS_CHSET_Ucs2: | |
1565 cl = parse (cl,"srsrb",(LONG)MAX_SMS_NUM_LEN*4,da,&toda_val, | |
1566 (LONG)MAX_SMS_NUM_LEN*4,sca,&octet,&isReply); | |
1567 break; | |
1568 default: | |
1569 cl = parse (cl,"srsrb",(LONG)MAX_SMS_NUM_LEN,da,&toda_val, | |
1570 (LONG)MAX_SMS_NUM_LEN,sca,&octet,&isReply); | |
1571 break; | |
1572 } | |
1573 | |
1574 if ( !cl OR da[0] EQ '\0') | |
1575 { | |
1576 cmdCmsError (CMS_ERR_OpNotAllowed); | |
1577 return (ATI_FAIL); | |
1578 } | |
1579 if (octet EQ 0) | |
1580 { | |
1581 p_tosca=NULL; | |
1582 } | |
1583 else | |
1584 { | |
1585 tosca=toa_demerge(octet); | |
1586 if (tosca.ton < 0 OR tosca.npi < 0) | |
1587 { | |
1588 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1589 return (ATI_FAIL); | |
1590 } | |
1591 } | |
1592 #endif | |
1593 if (toda_val) | |
1594 { | |
1595 toda=toa_sms_demerge(toda_val); | |
1596 if (toda.ton < 0 OR toda.npi < 0) | |
1597 { | |
1598 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1599 return (ATI_FAIL); | |
1600 } | |
1601 } | |
1602 | |
1603 src_params->text_mode = TXT_MODE; | |
1604 return (ATI_EXCT); | |
1605 } /* end of if (src_params->text_mode EQ CMD_MODE) */ | |
1606 else | |
1607 { | |
1608 TRACE_FUNCTION("atPlusCMGSText() TXT_MODE"); | |
1609 | |
1610 src_params->text_mode = CMD_MODE; | |
1611 /* if the character sent is ESC, then abort command CLB 16.11.00 */ | |
1612 if (*cl EQ 0x1B) | |
1613 { | |
1614 TRACE_EVENT("Send message command cancelled by user"); | |
1615 | |
1616 return ATI_CMPL_NO_OUTPUT; | |
1617 } | |
1618 | |
1619 if ( toda_val EQ 0 ) | |
1620 { | |
1621 #ifndef _SIMULATION_ | |
1622 #endif /* ndef _SIMULATION_ */ | |
1623 p_toda = NULL; | |
1624 } | |
1625 else | |
1626 { | |
1627 toda = toa_sms_demerge ( toda_val ); | |
1628 p_toda = &toda; | |
1629 if( toda.ton EQ TON_Alphanumeric) | |
1630 { | |
1631 dalen = strlen(da); | |
1632 | |
1633 switch (ati_user_output_cfg[srcId].cscsChset) | |
1634 { | |
1635 case CSCS_CHSET_Ucs2: | |
1636 utl_chsetToGsm ( (UBYTE*)da, | |
1637 dalen, | |
1638 dest_addr, | |
1639 &dalen, | |
1640 #ifdef REL99 | |
1641 sizeof(dest_addr), | |
1642 #endif | |
1643 GSM_ALPHA_Def ); | |
1644 break; | |
1645 | |
1646 case CSCS_CHSET_Hex: | |
1647 utl_chsetToGsm ( (UBYTE*)da, | |
1648 dalen, | |
1649 dest_addr, | |
1650 &dalen, | |
1651 #ifdef REL99 | |
1652 sizeof(dest_addr), | |
1653 #endif | |
1654 GSM_ALPHA_Def ); | |
1655 break; | |
1656 | |
1657 default: | |
1658 utl_chsetToGsm ( (UBYTE*)da, | |
1659 dalen, | |
1660 dest_addr, | |
1661 &dalen, | |
1662 #ifdef REL99 | |
1663 sizeof(dest_addr), | |
1664 #endif | |
1665 GSM_ALPHA_Def ); | |
1666 break; | |
1667 } | |
1668 if( dalen > (((MAX_SMS_ADDR_DIG/2) * 8) / 7) ) | |
1669 { | |
1670 TRACE_EVENT("DA length is greater then the supported length"); | |
1671 return(ATI_FAIL); | |
1672 } | |
1673 da = (CHAR*)dest_addr; | |
1674 da[dalen] = '\0'; /* dest_addr is a non NULL terminated string, so it should be terminated by 0 for internal processing */ | |
1675 } | |
1676 } | |
1677 | |
1678 qAT_PlusCSMP ( (T_ACI_CMD_SRC)srcId, &fo, &vprel, &vpabs, NULL, &pid, &dcs ); | |
1679 | |
1680 srcId_cb = srcId; | |
1681 strg_len=strlen(cl); | |
1682 | |
1683 switch (ati_user_output_cfg[srcId].cscsChset) | |
1684 { | |
1685 case CSCS_CHSET_Ucs2: | |
1686 utl_smDtaFromTe ((UBYTE*)cl, | |
1687 (USHORT)MINIMUM(strg_len,sizeof(msg.data)*4), | |
1688 msg.data, | |
1689 &lenMsg, | |
1690 #ifdef REL99 | |
1691 sizeof(msg.data), | |
1692 #endif | |
1693 (UBYTE)fo, | |
1694 (UBYTE)dcs ); | |
1695 break; | |
1696 case CSCS_CHSET_Hex: | |
1697 utl_smDtaFromTe ((UBYTE*)cl, | |
1698 (USHORT)MINIMUM(strg_len,sizeof(msg.data)*2), | |
1699 msg.data, | |
1700 &lenMsg, | |
1701 #ifdef REL99 | |
1702 sizeof(msg.data), | |
1703 #endif | |
1704 (UBYTE)fo, | |
1705 (UBYTE)dcs ); | |
1706 break; | |
1707 default: | |
1708 utl_smDtaFromTe ((UBYTE*)cl, | |
1709 (USHORT)MINIMUM(strg_len,sizeof(msg.data)), | |
1710 msg.data, | |
1711 &lenMsg, | |
1712 #ifdef REL99 | |
1713 sizeof(msg.data), | |
1714 #endif | |
1715 (UBYTE)fo, | |
1716 (UBYTE)dcs ); | |
1717 break; | |
1718 } | |
1719 | |
1720 msg.len = (UBYTE)lenMsg; | |
1721 #if !defined _CONC_TESTING_ OR !defined TI_PS_FF_CONC_SMS | |
1722 #ifndef _SIMULATION_ | |
1723 ret = sAT_PlusCMGS_Gl((T_ACI_CMD_SRC)srcId, da, p_toda, &msg, NULL, NULL, NULL, -1, NULL, NULL); | |
1724 #else | |
1725 ret = sAT_PlusCMGS_Gl(srcId, da, p_toda, &msg, NULL, sca, p_tosca, isReply, NULL, NULL); | |
1726 #endif | |
1727 #else | |
1728 ACI_MALLOC(msg_conc.data, msg.len); | |
1729 memcpy ( msg_conc.data, msg.data, msg.len); | |
1730 msg_conc.len = msg.len; | |
1731 #ifndef _SIMULATION_ | |
1732 ret = sAT_PlusCMGS (srcId, da, p_toda, &msg_conc, NULL, NULL, -1); | |
1733 #else | |
1734 ret = sAT_PlusCMGS (srcId, da, p_toda, &msg_conc, sca, p_tosca, isReply); | |
1735 #endif | |
1736 #endif | |
1737 | |
1738 if ( ret NEQ AT_EXCT ) | |
1739 { | |
1740 cmdCmsError (CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1741 return (ATI_FAIL); | |
1742 } | |
1743 /* | |
1744 * rCI_OK will emitting +CMGS: <mr>[,<scts>] | |
1745 */ | |
1746 | |
1747 return (ATI_EXCT); | |
1748 } | |
1749 } | |
1750 | |
1751 | |
1752 /* | |
1753 +--------------------------------------------------------------------+ | |
1754 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1755 | STATE : code ROUTINE : atPlusCMSS | | |
1756 +--------------------------------------------------------------------+ | |
1757 | |
1758 PURPOSE : +CMSS command (send message from storage) | |
1759 */ | |
1760 | |
1761 GLOBAL T_ATI_RSLT atPlusCMSS (char *cl, UBYTE srcId) | |
1762 { | |
1763 CHAR *p_da; | |
1764 T_ACI_RETURN ret = AT_FAIL; | |
1765 T_ACI_TOA toda; | |
1766 T_ACI_TOA *p_toda; | |
1767 SHORT index=-1, | |
1768 toda_val=0; | |
1769 CHAR da[MAX_SMS_NUM_LEN*4]; /* 4 is for UCS2 chars */ | |
1770 USHORT dalen = 0; | |
1771 UBYTE dest_addr[MAX_SMS_NUM_LEN]; | |
1772 | |
1773 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
1774 | |
1775 TRACE_FUNCTION("atPlusCMSS()"); | |
1776 | |
1777 p_toda=&toda; | |
1778 p_da=da; | |
1779 /*input functionality*/ | |
1780 da[0]='\0'; | |
1781 switch(ati_user_output_cfg[srcId].cscsChset) | |
1782 { | |
1783 case CSCS_CHSET_Hex: | |
1784 cl = parse(cl,"rsr",&index,(LONG)MAX_SMS_NUM_LEN*2,da,&toda_val); | |
1785 break; | |
1786 case CSCS_CHSET_Ucs2: | |
1787 cl = parse(cl,"rsr",&index,(LONG)MAX_SMS_NUM_LEN*4,da,&toda_val); | |
1788 break; | |
1789 default: | |
1790 cl = parse(cl,"rsr",&index,(LONG)MAX_SMS_NUM_LEN,da,&toda_val); | |
1791 break; | |
1792 } | |
1793 if ( !cl OR toda_val > 0xD9 OR index > 255 OR index < 0) | |
1794 { | |
1795 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1796 return (ATI_FAIL); | |
1797 } | |
1798 p_toda=&toda; | |
1799 if(toda_val EQ 0) | |
1800 { | |
1801 p_toda=NULL; | |
1802 } | |
1803 else | |
1804 { | |
1805 toda=toa_sms_demerge(toda_val); | |
1806 if (toda.ton < 0 OR toda.npi < 0) | |
1807 { | |
1808 cmdCmsError(CMS_ERR_OpNotAllowed); | |
1809 return (ATI_FAIL); | |
1810 } | |
1811 } | |
1812 if(!da[0]) | |
1813 p_da=NULL; | |
1814 else | |
1815 { | |
1816 if( toda.ton EQ TON_Alphanumeric) | |
1817 { | |
1818 dalen = strlen(da); | |
1819 | |
1820 switch (ati_user_output_cfg[srcId].cscsChset) | |
1821 { | |
1822 case CSCS_CHSET_Ucs2: | |
1823 utl_chsetToGsm ( (UBYTE*)da, | |
1824 dalen, | |
1825 dest_addr, | |
1826 &dalen, | |
1827 #ifdef REL99 | |
1828 sizeof(dest_addr), | |
1829 #endif | |
1830 GSM_ALPHA_Def ); | |
1831 break; | |
1832 | |
1833 case CSCS_CHSET_Hex: | |
1834 utl_chsetToGsm ( (UBYTE*)da, | |
1835 dalen, | |
1836 dest_addr, | |
1837 &dalen, | |
1838 #ifdef REL99 | |
1839 sizeof(dest_addr), | |
1840 #endif | |
1841 GSM_ALPHA_Def ); | |
1842 break; | |
1843 | |
1844 default: | |
1845 utl_chsetToGsm ( (UBYTE*)da, | |
1846 dalen, | |
1847 dest_addr, | |
1848 &dalen, | |
1849 #ifdef REL99 | |
1850 sizeof(dest_addr), | |
1851 #endif | |
1852 GSM_ALPHA_Def ); | |
1853 break; | |
1854 } | |
1855 if( dalen > (((MAX_SMS_ADDR_DIG/2) * 8) / 7) ) | |
1856 { | |
1857 TRACE_EVENT("DA length is greater then the supported length"); | |
1858 return(ATI_FAIL); | |
1859 } | |
1860 p_da = (CHAR*)dest_addr; | |
1861 p_da[dalen] = '\0'; /* dest_addr is a non NULL terminated string, so it should be terminated by 0 for internal processing */ | |
1862 } | |
1863 } | |
1864 | |
1865 #ifdef _CONC_TESTING_ | |
1866 ret = sAT_PlusCMSS(srcId,(UBYTE)index,p_da,p_toda); | |
1867 #else | |
1868 ret = sAT_PlusCMSS_Gl((T_ACI_CMD_SRC)srcId, (UBYTE)index, p_da, p_toda, NULL, NULL); | |
1869 #endif | |
1870 if (ret EQ AT_EXCT) | |
1871 { | |
1872 src_params->curAtCmd = AT_CMD_CMSS; | |
1873 return (ATI_EXCT); | |
1874 } | |
1875 else | |
1876 { | |
1877 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1878 return (ATI_FAIL); | |
1879 } | |
1880 } | |
1881 | |
1882 /* | |
1883 +--------------------------------------------------------------------+ | |
1884 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1885 | STATE : code ROUTINE : atPlusCNMA | | |
1886 +--------------------------------------------------------------------+ | |
1887 | |
1888 PURPOSE : +CNMA command (new message acknowledgement) | |
1889 */ | |
1890 GLOBAL T_ATI_RSLT queatPlusCNMA (char *cl, UBYTE srcId) | |
1891 { | |
1892 cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CNMA not specified in 07.05 */ | |
1893 return (ATI_FAIL); | |
1894 } | |
1895 | |
1896 GLOBAL T_ATI_RSLT tesatPlusCNMA (char *cl, UBYTE srcId) | |
1897 { | |
1898 T_ACI_CMGF_MOD mode; | |
1899 | |
1900 /* | |
1901 * request current mode | |
1902 */ | |
1903 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
1904 if (mode EQ 0) | |
1905 { | |
1906 /* | |
1907 * handle PDU mode: response is +CNMA: (list of supported <n>s) | |
1908 */ | |
1909 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
1910 return ATI_CMPL_NO_OUTPUT; | |
1911 } | |
1912 else | |
1913 { | |
1914 /* | |
1915 * handle Text mode: there is no response | |
1916 */ | |
1917 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
1918 return ATI_CMPL_NO_OUTPUT; | |
1919 } | |
1920 } | |
1921 | |
1922 | |
1923 GLOBAL T_ATI_RSLT atPlusCNMA (char *cl, UBYTE srcId) | |
1924 #if defined (SMS_PDU_SUPPORT) | |
1925 { | |
1926 T_ACI_CMGF_MOD mode; | |
1927 | |
1928 if(srcId NEQ smsShrdPrm.smsSrcId) | |
1929 { | |
1930 cmdCmsError(CMS_ERR_NoCnmaAckExpect); | |
1931 return ( ATI_FAIL ); | |
1932 } | |
1933 | |
1934 if( waitForCnmaFromBuffer_SrcId NEQ CMD_SRC_NONE ) | |
1935 { /* incomming +CNMA acknowledges an +CMT from CNMI buffer | |
1936 -> acknowledge has been sent to SMS entity */ | |
1937 TIMERSTOP( ACI_CNMA_TIMER_HANDLE ); | |
1938 cmd_clearFirstCnmiMessage(); /* The first message in CNMI buffer is cleared */ | |
1939 waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE; | |
1940 /* look for more messages in CNMI buffer for this srcId */ | |
1941 cmd_flushCnmiBufOneByOne(); | |
1942 return(ATI_CMPL); | |
1943 } | |
1944 /* | |
1945 * request current mode | |
1946 */ | |
1947 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
1948 if (mode EQ 0) | |
1949 /* | |
1950 * handle PDU mode | |
1951 */ | |
1952 return atPlusCNMAPdu (cl,srcId); | |
1953 else | |
1954 /* | |
1955 * handle Text mode | |
1956 */ | |
1957 return atPlusCNMAText (cl,srcId); | |
1958 } | |
1959 | |
1960 LOCAL T_ATI_RSLT atPlusCNMAText (char *cl, UBYTE srcId) | |
1961 #endif /* (SMS_PDU_SUPPORT) */ | |
1962 { | |
1963 TRACE_FUNCTION("atPlusCNMAText()"); | |
1964 | |
1965 switch (*cl) | |
1966 { | |
1967 case(0x0): | |
1968 switch (sAT_PlusCNMA((T_ACI_CMD_SRC)srcId)) | |
1969 { | |
1970 case( AT_CMPL ): | |
1971 cmdAtError ( atOk ); | |
1972 return (ATI_CMPL); | |
1973 | |
1974 default: | |
1975 cmdCmsError (CMS_ERR_NotPresent); /* use aciErrDesc */ | |
1976 return (ATI_FAIL); | |
1977 } | |
1978 default: | |
1979 cmdCmeError(CME_ERR_Unknown); | |
1980 return (ATI_FAIL); | |
1981 } | |
1982 } | |
1983 | |
1984 | |
1985 /* | |
1986 +--------------------------------------------------------------------+ | |
1987 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
1988 | STATE : code ROUTINE : atPlusCMGW | | |
1989 +--------------------------------------------------------------------+ | |
1990 | |
1991 PURPOSE : +CMGW command (Write message to memory) | |
1992 */ | |
1993 | |
1994 GLOBAL T_ATI_RSLT tesatPlusCMGW (char *cl, UBYTE srcId) | |
1995 { | |
1996 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
1997 return ATI_CMPL_NO_OUTPUT; | |
1998 } | |
1999 | |
2000 GLOBAL T_ATI_RSLT queatPlusCMGW (char *cl, UBYTE srcId) | |
2001 { | |
2002 cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CMGW not specified in 07.05 */ | |
2003 return (ATI_FAIL); | |
2004 } | |
2005 | |
2006 | |
2007 GLOBAL T_ATI_RSLT atPlusCMGW (char *cl, UBYTE srcId) | |
2008 #if defined (SMS_PDU_SUPPORT) | |
2009 { | |
2010 T_ACI_CMGF_MOD mode; | |
2011 | |
2012 /* | |
2013 * request current mode | |
2014 */ | |
2015 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
2016 if (mode EQ 0) | |
2017 /* | |
2018 * handle PDU mode | |
2019 */ | |
2020 return atPlusCMGWPdu (cl, srcId); | |
2021 else | |
2022 /* | |
2023 * handle Text mode | |
2024 */ | |
2025 return atPlusCMGWText (cl, srcId); | |
2026 } | |
2027 LOCAL T_ATI_RSLT atPlusCMGWText(char *cl, UBYTE srcId) | |
2028 #endif /* (SMS_PDU_SUPPORT) */ | |
2029 { | |
2030 T_ACI_VP_ABS vpabs; | |
2031 SHORT fo, | |
2032 vprel, | |
2033 pid, | |
2034 dcs; | |
2035 T_ACI_RETURN ret; | |
2036 T_ACI_TOA toa; | |
2037 T_ACI_TOA* p_toa; | |
2038 CHAR txtStat[15] = {0x00}; | |
2039 USHORT i; | |
2040 T_ACI_SM_DATA msg; | |
2041 USHORT lenMsg; | |
2042 static T_ACI_SMS_STAT stat; | |
2043 #if defined _SIMULATION_ OR defined WIN32 | |
2044 static T_ACI_TOA *p_tosca; | |
2045 static SHORT isReply; | |
2046 #endif | |
2047 #ifdef _SIMULATION_ | |
2048 CHAR *sca =subBuf; | |
2049 #endif /* ndef _SIMULATION_ */ | |
2050 #ifdef WIN32 | |
2051 SHORT octet=0; | |
2052 static T_ACI_TOA tosca; | |
2053 #endif /* WIN32 */ | |
2054 | |
2055 #if defined _CONC_TESTING_ AND defined TI_PS_FF_CONC_SMS | |
2056 T_SM_DATA_EXT msg_conc; | |
2057 #endif | |
2058 CHAR *da = daBuf; | |
2059 USHORT dalen = 0; | |
2060 UBYTE dest_addr[MAX_SMS_NUM_LEN]; | |
2061 | |
2062 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2063 | |
2064 TRACE_FUNCTION("atPlusCMGWText()"); | |
2065 | |
2066 p_toa=&toa; | |
2067 | |
2068 if (src_params->text_mode EQ CMD_MODE) | |
2069 { | |
2070 toda_val=0; | |
2071 memset(da, 0, MAX_SMS_NUM_LEN); | |
2072 stat = SMS_STAT_NotPresent; | |
2073 /*input functionality*/ | |
2074 *da='\0'; /*sets global destination address to empty string*/ | |
2075 #ifndef WIN32 | |
2076 switch(ati_user_output_cfg[srcId].cscsChset) | |
2077 { | |
2078 case CSCS_CHSET_Hex: | |
2079 cl = parse(cl,"srs",(LONG)MAX_SMS_NUM_LEN*2, | |
2080 da, | |
2081 &toda_val, | |
2082 (LONG)sizeof(txtStat), | |
2083 txtStat); | |
2084 break; | |
2085 case CSCS_CHSET_Ucs2: | |
2086 cl = parse(cl,"srs",(LONG)MAX_SMS_NUM_LEN*4, | |
2087 da, | |
2088 &toda_val, | |
2089 (LONG)sizeof(txtStat), | |
2090 txtStat); | |
2091 break; | |
2092 default: | |
2093 cl = parse(cl,"srs",(LONG)MAX_SMS_NUM_LEN, | |
2094 da, | |
2095 &toda_val, | |
2096 (LONG)sizeof(txtStat), | |
2097 txtStat); | |
2098 break; | |
2099 } | |
2100 | |
2101 if ( !cl ) | |
2102 { | |
2103 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2104 return (ATI_FAIL); | |
2105 } | |
2106 #else | |
2107 *sca='\0'; | |
2108 isReply = -1; | |
2109 switch(ati_user_output_cfg[srcId].cscsChset) | |
2110 { | |
2111 case CSCS_CHSET_Hex: | |
2112 cl = parse(cl,"srssrb",(LONG)MAX_SMS_NUM_LEN*2, | |
2113 da, | |
2114 &toda_val, | |
2115 (LONG)sizeof(txtStat), | |
2116 txtStat, | |
2117 (LONG)MAX_SMS_NUM_LEN*2,sca,&octet,&isReply); | |
2118 break; | |
2119 case CSCS_CHSET_Ucs2: | |
2120 cl = parse(cl,"srssrb",(LONG)MAX_SMS_NUM_LEN*4, | |
2121 da, | |
2122 &toda_val, | |
2123 (LONG)sizeof(txtStat), | |
2124 txtStat, | |
2125 (LONG)MAX_SMS_NUM_LEN*4,sca,&octet,&isReply); | |
2126 break; | |
2127 default: | |
2128 cl = parse(cl,"srssrb",(LONG)MAX_SMS_NUM_LEN, | |
2129 da, | |
2130 &toda_val, | |
2131 (LONG)sizeof(txtStat), | |
2132 txtStat, | |
2133 (LONG)MAX_SMS_NUM_LEN,sca,&octet,&isReply); | |
2134 break; | |
2135 } | |
2136 | |
2137 if ( !cl ) | |
2138 { | |
2139 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2140 return (ATI_FAIL); | |
2141 } | |
2142 if(octet EQ 0) | |
2143 p_tosca = NULL; | |
2144 else | |
2145 { | |
2146 tosca=toa_demerge(octet); | |
2147 if (tosca.ton < 0 OR tosca.npi < 0) | |
2148 { | |
2149 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2150 return 0; | |
2151 } | |
2152 p_tosca = &tosca; | |
2153 } | |
2154 #endif | |
2155 if (toda_val) | |
2156 { | |
2157 toa = toa_sms_demerge(toda_val); | |
2158 if (toa.ton < 0 OR toa.npi < 0) | |
2159 { | |
2160 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2161 return (ATI_FAIL); | |
2162 } | |
2163 } | |
2164 i = 0; | |
2165 while ( sms_stat[i].name NEQ NULL AND | |
2166 strcmp ( sms_stat[i].name, txtStat ) NEQ 0 ) | |
2167 { | |
2168 i++; | |
2169 } | |
2170 stat = sms_stat[i].stat; | |
2171 | |
2172 src_params->text_mode = TXT_MODE; | |
2173 return (ATI_EXCT); | |
2174 } /* end of if (src_params->text_mode EQ CMD_MODE) */ | |
2175 else | |
2176 { | |
2177 src_params->text_mode = CMD_MODE; | |
2178 /* if the character sent is ESC, then abort command CLB 16.11.00 */ | |
2179 if (*cl EQ 0x1B) | |
2180 { | |
2181 TRACE_EVENT("Send message command cancelled by user"); | |
2182 | |
2183 return ATI_CMPL_NO_OUTPUT; | |
2184 } | |
2185 | |
2186 if ( toda_val EQ 0 ) | |
2187 p_toa = NULL; | |
2188 else | |
2189 { | |
2190 toa = toa_sms_demerge ( toda_val ); | |
2191 p_toa = &toa; | |
2192 } | |
2193 | |
2194 qAT_PlusCSMP ( (T_ACI_CMD_SRC)srcId, &fo, &vprel, &vpabs, NULL, &pid, &dcs ); | |
2195 | |
2196 srcId_cb = srcId; | |
2197 if( toa.ton EQ TON_Alphanumeric) | |
2198 { | |
2199 dalen = strlen(da); | |
2200 | |
2201 switch (ati_user_output_cfg[srcId].cscsChset) | |
2202 { | |
2203 case CSCS_CHSET_Ucs2: | |
2204 utl_chsetToGsm ( (UBYTE*)da, | |
2205 dalen, | |
2206 dest_addr, | |
2207 &dalen, | |
2208 #ifdef REL99 | |
2209 sizeof(dest_addr), | |
2210 #endif | |
2211 GSM_ALPHA_Def ); | |
2212 break; | |
2213 | |
2214 case CSCS_CHSET_Hex: | |
2215 utl_chsetToGsm ( (UBYTE*)da, | |
2216 dalen, | |
2217 dest_addr, | |
2218 &dalen, | |
2219 #ifdef REL99 | |
2220 sizeof(dest_addr), | |
2221 #endif | |
2222 GSM_ALPHA_Def ); | |
2223 break; | |
2224 default: | |
2225 utl_chsetToGsm ( (UBYTE*)da, | |
2226 dalen, | |
2227 dest_addr, | |
2228 &dalen, | |
2229 #ifdef REL99 | |
2230 sizeof(dest_addr), | |
2231 #endif | |
2232 GSM_ALPHA_Def ); | |
2233 break; | |
2234 } | |
2235 if( dalen > (((MAX_SMS_ADDR_DIG/2) * 8) / 7) ) | |
2236 { | |
2237 TRACE_EVENT("DA length is greater then the supported length"); | |
2238 return(ATI_FAIL); | |
2239 } | |
2240 da = (CHAR*)dest_addr; | |
2241 da[dalen] = '\0'; /* dest_addr is a non NULL terminated string, so it should be terminated by 0 for internal processing */ | |
2242 } | |
2243 | |
2244 utl_smDtaFromTe ( (UBYTE*)cl, | |
2245 (USHORT)strlen(cl), | |
2246 (UBYTE*)msg.data, | |
2247 &lenMsg, | |
2248 #ifdef REL99 | |
2249 sizeof(msg.data), | |
2250 #endif | |
2251 (UBYTE)fo, | |
2252 (UBYTE)dcs ); | |
2253 | |
2254 msg.len = (UBYTE)lenMsg; | |
2255 | |
2256 #if !defined _CONC_TESTING_ OR !defined TI_PS_FF_CONC_SMS | |
2257 #ifndef _SIMULATION_ | |
2258 ret = sAT_PlusCMGW_Gl((T_ACI_CMD_SRC)srcId, | |
2259 CMGW_IDX_FREE_ENTRY, | |
2260 da, p_toa, stat, NOT_PRESENT_8BIT, | |
2261 &msg, NULL, NULL, NULL, -1, | |
2262 NULL, NULL); | |
2263 #else | |
2264 ret = sAT_PlusCMGW_Gl( srcId, | |
2265 CMGW_IDX_FREE_ENTRY, | |
2266 da, p_toa, stat, NOT_PRESENT_8BIT, | |
2267 &msg, NULL, sca, p_tosca, isReply, | |
2268 NULL, NULL); | |
2269 #endif | |
2270 #else | |
2271 ACI_MALLOC(msg_conc.data, msg.len); | |
2272 memcpy ( msg_conc.data, msg.data, msg.len); | |
2273 msg_conc.len = msg.len; | |
2274 #ifndef _SIMULATION_ | |
2275 ret = sAT_PlusCMGW ( srcId, | |
2276 CMGW_IDX_FREE_ENTRY, | |
2277 da, p_toa, stat, NOT_PRESENT_8BIT, | |
2278 &msg_conc, NULL, NULL, -1 ); | |
2279 #else | |
2280 ret = sAT_PlusCMGW ( srcId, | |
2281 CMGW_IDX_FREE_ENTRY, | |
2282 da, p_toa, stat, NOT_PRESENT_8BIT, | |
2283 &msg_conc, sca, p_tosca, isReply ); | |
2284 #endif | |
2285 #endif | |
2286 | |
2287 if ( ret NEQ AT_EXCT ) | |
2288 { | |
2289 cmdCmsError (CMS_ERR_NotPresent); /* use aciErrDesc */ | |
2290 return (ATI_FAIL); | |
2291 } | |
2292 /* | |
2293 * rCI_OK will emitting +CMGW: <index> | |
2294 */ | |
2295 return (ATI_EXCT); | |
2296 } | |
2297 } | |
2298 | |
2299 | |
2300 /* | |
2301 +--------------------------------------------------------------------+ | |
2302 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2303 | STATE : code ROUTINE : atPlusCMGD | | |
2304 +--------------------------------------------------------------------+ | |
2305 | |
2306 PURPOSE : +CMGD command (delete message from storage) | |
2307 */ | |
2308 | |
2309 GLOBAL T_ATI_RSLT setatPlusCMGD (char *cl, UBYTE srcId) | |
2310 { | |
2311 T_ACI_RETURN ret = AT_FAIL; | |
2312 SHORT index=-1; | |
2313 SHORT status = CMGD_DEL_INDEX; | |
2314 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2315 | |
2316 src_params->curAtCmd = AT_CMD_CMGD; | |
2317 | |
2318 /*input functionality*/ | |
2319 if(!cl OR !*cl) | |
2320 { | |
2321 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2322 return ATI_FAIL; | |
2323 } | |
2324 | |
2325 cl=parse(cl,"rr",&index,&status); | |
2326 if ( !cl OR (index > 255) OR (index < 0) OR | |
2327 ((status < CMGD_DEL_INDEX) OR (status > CMGD_DEL_ALL))) | |
2328 { | |
2329 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2330 return ATI_FAIL; | |
2331 } | |
2332 | |
2333 #ifdef FF_ATI_BAT | |
2334 { | |
2335 T_BAT_cmd_send cmd; | |
2336 T_BAT_cmd_set_plus_cmgd my_bat_set_plus_cmgd; | |
2337 | |
2338 TRACE_FUNCTION("setatPlusCMGD() calls bat_send() <=== as APPLICATION"); | |
2339 | |
2340 memset(&my_bat_set_plus_cmgd, 0, sizeof(my_bat_set_plus_cmgd)); | |
2341 cmd.ctrl_params = BAT_CMD_SET_PLUS_CMGD; | |
2342 cmd.params.ptr_set_plus_cmgd = &my_bat_set_plus_cmgd; | |
2343 | |
2344 my_bat_set_plus_cmgd.index = (U8)index; | |
2345 my_bat_set_plus_cmgd.status = status; | |
2346 | |
2347 bat_send(ati_bat_get_client(srcId), &cmd); | |
2348 | |
2349 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
2350 } | |
2351 #else /* OLD FUNCTION BODY */ | |
2352 | |
2353 TRACE_FUNCTION("setatPlusCMGD()"); | |
2354 /*----------------------------------------------------------------------- | |
2355 * Del flag is greater than zero, set index as Zero so that SMS module | |
2356 * starts searching for records satisfying the status from first record | |
2357 *----------------------------------------------------------------------- | |
2358 */ | |
2359 if ( status > CMGD_DEL_INDEX ) | |
2360 { | |
2361 index = 0; | |
2362 } | |
2363 #ifdef _CONC_TESTING_ | |
2364 ret = sAT_PlusCMGD(srcId,(UBYTE)index, status); | |
2365 #else | |
2366 ret = sAT_PlusCMGD_Gl((T_ACI_CMD_SRC)srcId, (UBYTE)index, status, NULL, NULL); | |
2367 #endif | |
2368 | |
2369 if (ret EQ AT_EXCT) | |
2370 { | |
2371 return (ATI_EXCT); | |
2372 } | |
2373 else | |
2374 { | |
2375 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
2376 return (ATI_FAIL); | |
2377 } | |
2378 | |
2379 #endif /* no FF_ATI_BAT*/ | |
2380 } | |
2381 | |
2382 /* | |
2383 +--------------------------------------------------------------------+ | |
2384 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2385 | STATE : code ROUTINE : atPlusCMGC | | |
2386 +--------------------------------------------------------------------+ | |
2387 | |
2388 PURPOSE : +CMGC command (Send SMS command) | |
2389 */ | |
2390 | |
2391 GLOBAL T_ATI_RSLT tesatPlusCMGC (char *cl, UBYTE srcId) | |
2392 { | |
2393 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
2394 return ATI_CMPL_NO_OUTPUT; | |
2395 } | |
2396 | |
2397 GLOBAL T_ATI_RSLT queatPlusCMGC (char *cl, UBYTE srcId) | |
2398 { | |
2399 cmdCmsError(CMS_ERR_OpNotAllowed); /* querying CMGC not specified in 07.05 */ | |
2400 return (ATI_FAIL); | |
2401 } | |
2402 | |
2403 GLOBAL T_ATI_RSLT atPlusCMGC (char *cl, UBYTE srcId) | |
2404 #if defined (SMS_PDU_SUPPORT) | |
2405 { | |
2406 T_ACI_CMGF_MOD mode; | |
2407 | |
2408 /* | |
2409 * request current mode | |
2410 */ | |
2411 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
2412 if (mode EQ 0) | |
2413 /* | |
2414 * handle PDU mode | |
2415 */ | |
2416 return atPlusCMGCPdu (cl, srcId); | |
2417 else | |
2418 /* | |
2419 * handle Text mode | |
2420 */ | |
2421 return atPlusCMGCText (cl, srcId); | |
2422 } | |
2423 | |
2424 LOCAL T_ATI_RSLT atPlusCMGCText(char *cl, UBYTE srcId) | |
2425 #endif /* (SMS_PDU_SUPPORT) */ | |
2426 { | |
2427 /* char buf[80]; */ | |
2428 T_ACI_RETURN ret = AT_FAIL; | |
2429 T_ACI_TOA toa; | |
2430 T_ACI_TOA* p_toa; | |
2431 T_ACI_CMD_DATA cmd; | |
2432 USHORT lenCmd; | |
2433 CHAR* da = daBuf; | |
2434 | |
2435 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2436 | |
2437 TRACE_FUNCTION("atPlusCMGCText()"); | |
2438 p_toa=&toa; | |
2439 if (src_params->text_mode EQ CMD_MODE) | |
2440 { | |
2441 memset(da, 0, MAX_SMS_NUM_LEN); | |
2442 fo=-1; | |
2443 ct=-1; | |
2444 pid=-1; | |
2445 mn=-1; | |
2446 toda_val=0; | |
2447 /*input functionality*/ | |
2448 da[0]='\0'; | |
2449 cl = parse(cl,"rrrrsr",&fo,&ct,&pid,&mn,(LONG)MAX_SMS_NUM_LEN,da,&toda_val); | |
2450 | |
2451 if ( !cl OR fo > 255 OR ct > 255 OR | |
2452 pid > 255 OR mn > 255 OR toda_val > 0xC9 OR da[0] EQ '\0') | |
2453 { | |
2454 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2455 return (ATI_FAIL); | |
2456 } | |
2457 if(toda_val) | |
2458 { | |
2459 toa = toa_demerge(toda_val); | |
2460 if (toa.ton < 0 OR toa.npi < 0) | |
2461 { | |
2462 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2463 return (ATI_FAIL); | |
2464 } | |
2465 } | |
2466 | |
2467 src_params->text_mode = TXT_MODE; | |
2468 return (ATI_EXCT); | |
2469 } /* end of if (src_params->text_mode EQ CMD_MODE) */ | |
2470 else | |
2471 { | |
2472 src_params->text_mode = CMD_MODE; | |
2473 p_toa=&toa; | |
2474 if(toda_val EQ 0) | |
2475 { | |
2476 p_toa = NULL; | |
2477 } | |
2478 else | |
2479 { | |
2480 toa = toa_demerge(toda_val); | |
2481 } | |
2482 if (!(check_str(cl,"0123456789ABCDEF"))) | |
2483 { | |
2484 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2485 return (ATI_FAIL); | |
2486 } | |
2487 utl_hexToGsm ( (UBYTE*)cl, | |
2488 (USHORT)strlen(cl), | |
2489 (UBYTE*)cmd.data, | |
2490 &lenCmd, | |
2491 GSM_ALPHA_Def, | |
2492 CSCS_ALPHA_8_Bit); | |
2493 cmd.len = (UBYTE)lenCmd; | |
2494 | |
2495 #ifndef _CONC_TESTING_ | |
2496 ret = sAT_PlusCMGC_Gl ((T_ACI_CMD_SRC)srcId,fo,ct,pid,mn,da,p_toa,&cmd,NULL); | |
2497 #else | |
2498 ret= sAT_PlusCMGC(srcId,fo,ct,pid,mn,da,p_toa,&cmd); | |
2499 #endif | |
2500 | |
2501 if ( ret NEQ AT_EXCT ) | |
2502 { | |
2503 cmdCmsError (CMS_ERR_NotPresent); /* use aciErrDesc */ | |
2504 return (ATI_FAIL); | |
2505 } | |
2506 /* | |
2507 * rCI_OK will emitting +CMGC: <mr>[,<scts>] | |
2508 */ | |
2509 return (ATI_EXCT); | |
2510 } | |
2511 } | |
2512 | |
2513 /* | |
2514 +--------------------------------------------------------------------+ | |
2515 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2516 | STATE : code ROUTINE : atPlusCMGL | | |
2517 +--------------------------------------------------------------------+ | |
2518 | |
2519 PURPOSE : +CMGL command (List Messages) | |
2520 */ | |
2521 | |
2522 GLOBAL T_ATI_RSLT queatPlusCMGL (char *cl, UBYTE srcId) | |
2523 { | |
2524 TRACE_FUNCTION("queatPlusCMGL()"); | |
2525 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
2526 return (ATI_FAIL); | |
2527 } | |
2528 | |
2529 GLOBAL T_ATI_RSLT tesatPlusCMGL (char *cl, UBYTE srcId) | |
2530 { | |
2531 #ifdef SMS_PDU_SUPPORT | |
2532 T_ACI_CMGF_MOD mode; | |
2533 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2534 | |
2535 TRACE_FUNCTION("tesatPlusCMGL()"); | |
2536 /* | |
2537 * request current mode | |
2538 */ | |
2539 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
2540 if (mode EQ 0) | |
2541 /* | |
2542 * handle PDU mode | |
2543 */ | |
2544 io_sendMessage(srcId, "+CMGL: (0,1,2,3,4)", ATI_NORMAL_OUTPUT); | |
2545 else | |
2546 /* | |
2547 * handle Text mode | |
2548 */ | |
2549 #endif | |
2550 io_sendMessage(srcId, "+CMGL: (\"REC UNREAD\",\"REC READ\",\"STO UNSENT\",\"STO SENT\",\"ALL\")", ATI_NORMAL_OUTPUT); | |
2551 | |
2552 return (ATI_CMPL); | |
2553 } | |
2554 | |
2555 GLOBAL T_ATI_RSLT atPlusCMGL (char *cl, UBYTE srcId) | |
2556 { | |
2557 #ifndef FF_ATI_BAT | |
2558 T_ACI_RETURN ret; | |
2559 #endif | |
2560 | |
2561 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2562 | |
2563 #ifdef SMS_PDU_SUPPORT | |
2564 T_ACI_CMGF_MOD mode; | |
2565 #endif | |
2566 CHAR txtStat[15]; | |
2567 USHORT i; | |
2568 | |
2569 TRACE_FUNCTION("atPlusCMGL()"); | |
2570 | |
2571 | |
2572 if (*cl EQ '\0') | |
2573 { | |
2574 cmglStat = SMS_STAT_NotPresent; | |
2575 #ifdef WIN32 | |
2576 smsReadMode = SMS_READ_Normal; | |
2577 #endif | |
2578 } | |
2579 else | |
2580 { | |
2581 /* | |
2582 * Request of a list of stored SMS messages | |
2583 * Parameter stat is optional | |
2584 */ | |
2585 #ifdef SMS_PDU_SUPPORT | |
2586 /* | |
2587 * request current mode | |
2588 */ | |
2589 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
2590 if (mode EQ 0) | |
2591 { | |
2592 #ifndef WIN32 | |
2593 /* | |
2594 * On the target is the definition according GSM 7.05 CMGL=[stat] | |
2595 */ | |
2596 cmglStat = SMS_STAT_All; | |
2597 cl = parse (cl, "d", &cmglStat); | |
2598 if ( !cl OR cmglStat < SMS_STAT_RecUnread OR cmglStat > SMS_STAT_All) | |
2599 { | |
2600 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
2601 return (ATI_FAIL); | |
2602 } | |
2603 #else | |
2604 /* | |
2605 * Under Windows the definition is CMGL=[stat],[preview] | |
2606 * to test the capabilities of the functional interface | |
2607 */ | |
2608 cl = parse (cl, "dd", &cmglStat, &smsReadMode ); | |
2609 if ( !cl OR ((cmglStat < SMS_STAT_RecUnread OR cmglStat > SMS_STAT_All) | |
2610 AND smsReadMode EQ SMS_READ_NotPresent)) | |
2611 { | |
2612 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
2613 return (ATI_FAIL); | |
2614 } | |
2615 #endif | |
2616 } | |
2617 else | |
2618 #endif | |
2619 { | |
2620 #ifndef WIN32 | |
2621 /* | |
2622 * On the target is the definition according GSM 7.05 CMGL=[stat] | |
2623 */ | |
2624 cl = parse (cl, "s", (LONG)sizeof(txtStat), txtStat); | |
2625 if ( !cl OR txtStat[0] EQ '\0') | |
2626 { | |
2627 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
2628 return (ATI_FAIL); | |
2629 } | |
2630 #else | |
2631 /* | |
2632 * Under Windows the definition is CMGL=[stat],[preview] | |
2633 * to test the capabilities of the functional interface | |
2634 */ | |
2635 cl = parse (cl, "sd", (LONG)sizeof(txtStat), txtStat, &smsReadMode ); | |
2636 if ( !cl OR (txtStat[0] EQ '\0' AND smsReadMode EQ SMS_READ_NotPresent)) | |
2637 { | |
2638 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
2639 return (ATI_FAIL); | |
2640 } | |
2641 if (txtStat[0] EQ '\0') | |
2642 strcpy (txtStat, sms_stat[4].name); /* ALL as default */ | |
2643 #endif | |
2644 i = 0; | |
2645 while ( sms_stat[i].name NEQ NULL AND | |
2646 strcmp ( sms_stat[i].name, txtStat ) NEQ 0 ) | |
2647 i++; | |
2648 | |
2649 if ( sms_stat[i].name EQ NULL ) | |
2650 { | |
2651 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
2652 return (ATI_FAIL); | |
2653 } | |
2654 | |
2655 cmglStat = sms_stat[i].stat; | |
2656 } | |
2657 } | |
2658 | |
2659 #ifdef FF_ATI_BAT | |
2660 | |
2661 { | |
2662 T_BAT_cmd_send cmd; | |
2663 T_BAT_cmd_set_plus_cmgl cmgl; | |
2664 | |
2665 cmd.ctrl_params=BAT_CMD_SET_PLUS_CMGL; | |
2666 cmd.params.ptr_set_plus_cmgl=&cmgl; | |
2667 | |
2668 /* | |
2669 * T_ACI_SMS_STAT and T_BAT_plus_cmgl_stat are not quite | |
2670 * identical - the ACI version has the extra value | |
2671 * SMS_STAT_Invalid. | |
2672 */ | |
2673 if (cmglStat EQ SMS_STAT_Invalid) | |
2674 cmgl.stat=BAT_CMGL_STAT_NOT_PRESENT; | |
2675 else | |
2676 cmgl.stat=(T_BAT_plus_cmgl_stat)cmglStat; | |
2677 | |
2678 bat_send(ati_bat_get_client(srcId),&cmd); | |
2679 | |
2680 src_params->curAtCmd=AT_CMD_CMGL; | |
2681 return(ATI_EXCT); | |
2682 } | |
2683 | |
2684 #else | |
2685 | |
2686 /* | |
2687 * Request the first five SMS messages | |
2688 */ | |
2689 #ifndef WIN32 | |
2690 ret = sAT_PlusCMGL ( (T_ACI_CMD_SRC)srcId, cmglStat, 0, SMS_READ_Normal ); | |
2691 #else | |
2692 ret = sAT_PlusCMGL ( srcId, cmglStat, 0, smsReadMode ); | |
2693 #endif | |
2694 | |
2695 if ( ret EQ AT_EXCT ) | |
2696 { | |
2697 src_params->curAtCmd = AT_CMD_CMGL; | |
2698 return (ATI_EXCT); | |
2699 } | |
2700 else | |
2701 { | |
2702 cmdCmsError ( CMS_ERR_NotPresent ); /* use aciErrDesc */ | |
2703 return (ATI_FAIL); | |
2704 } | |
2705 | |
2706 #endif /*FF_ATI_BAT*/ | |
2707 } | |
2708 | |
2709 /* | |
2710 +--------------------------------------------------------------------+ | |
2711 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2712 | STATE : code ROUTINE : atPlusCNMI | | |
2713 +--------------------------------------------------------------------+ | |
2714 | |
2715 PURPOSE : +CNMI command (new messgae indication settings ) | |
2716 */ | |
2717 | |
2718 GLOBAL T_ATI_RSLT atPlusCNMI (char *cl, UBYTE srcId) | |
2719 { | |
2720 T_ACI_CNMI_MT mt = CNMI_MT_NotPresent; | |
2721 T_ACI_CNMI_BM bm = CNMI_BM_NotPresent; | |
2722 T_ACI_CNMI_DS ds = CNMI_DS_NotPresent; | |
2723 T_ACI_CNMI_MOD mode = CNMI_MOD_NotPresent; | |
2724 T_ACI_CNMI_BFR bfr = CNMI_BFR_NotPresent; | |
2725 T_ACI_RETURN ret = AT_FAIL; | |
2726 | |
2727 TRACE_FUNCTION("atPlusCNMI()"); | |
2728 | |
2729 /* input functionality */ | |
2730 cl = parse ( cl, "ddddd", &mode, &mt, &bm, &ds, &bfr ); | |
2731 | |
2732 if ( !cl OR | |
2733 mode < CNMI_MOD_NotPresent OR | |
2734 mode > CNMI_MOD_BufferAndFlush OR | |
2735 bfr < CNMI_BFR_NotPresent OR | |
2736 bfr > CNMI_BFR_Clear OR /*lint !e685 (Warning: Relational operator '>' always evaluates to 'false')*/ | |
2737 ( bfr EQ CNMI_BFR_Flush AND | |
2738 strlen ( cl ) > 0 ) ) | |
2739 { | |
2740 io_sendConfirm ( srcId, cmdCmsError ( CMS_ERR_OpNotAllowed ), ATI_ERROR_OUTPUT ); | |
2741 cmdErrStr = NULL; | |
2742 return ATI_FAIL_NO_OUTPUT; | |
2743 } | |
2744 | |
2745 ret = sAT_PlusCNMI ((T_ACI_CMD_SRC) srcId, mt, bm, ds ); | |
2746 if ( (ret EQ AT_FAIL) OR (ret EQ AT_BUSY) ) | |
2747 { | |
2748 io_sendConfirm ( srcId, cmdCmsError ( CMS_ERR_NotPresent ), ATI_ERROR_OUTPUT ); | |
2749 cmdErrStr = NULL; | |
2750 return ATI_FAIL_NO_OUTPUT; | |
2751 } | |
2752 | |
2753 /* | |
2754 *----------------------Issue 25033-------------------------------- | |
2755 * The source ID issuing the CNMI command is stored and henceforth | |
2756 * all the unsolicited SMS indications are sent to this source | |
2757 *----------------------------------------------------------------- | |
2758 */ | |
2759 if(srcId NEQ CMD_SRC_LCL) | |
2760 smsShrdPrm.smsSrcId = (T_ACI_CMD_SRC)srcId; | |
2761 | |
2762 if ( bfr NEQ CNMI_BFR_NotPresent ) | |
2763 at.CNMI_bfr = ( UBYTE ) bfr; | |
2764 | |
2765 if ( mode NEQ CNMI_MOD_NotPresent ) | |
2766 at.CNMI_mode = ( UBYTE ) mode; | |
2767 | |
2768 if (mode EQ CNMI_MOD_DiscardOrForward OR /* 07.05:3.4.1: check for <mode> 1...3 */ | |
2769 mode EQ CNMI_MOD_BufferAndFlush) | |
2770 { | |
2771 if ( at.CNMI_bfr EQ CNMI_BFR_Flush ) | |
2772 { | |
2773 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
2774 cmdErrStr = NULL; | |
2775 | |
2776 if( smsShrdPrm.CSMSservice NEQ CSMS_SERV_GsmPh2Plus ) | |
2777 { | |
2778 cmd_flushCnmiBuf(); | |
2779 } | |
2780 else | |
2781 { | |
2782 cmd_flushCnmiBufOneByOne(); | |
2783 } | |
2784 return ATI_CMPL_NO_OUTPUT; | |
2785 } | |
2786 else | |
2787 { | |
2788 cmd_clearCnmiBuf (); | |
2789 } | |
2790 } | |
2791 | |
2792 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
2793 cmdErrStr = NULL; | |
2794 | |
2795 return ATI_CMPL_NO_OUTPUT; | |
2796 } | |
2797 | |
2798 GLOBAL T_ATI_RSLT tesatPlusCNMI (char *cl, UBYTE srcId) | |
2799 { | |
2800 /* query parameter ranges */ | |
2801 io_sendMessage ( srcId, "+CNMI: (0-2),(0-3),(0,2),(0,1),(0,1)", ATI_NORMAL_OUTPUT ); | |
2802 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
2803 cmdErrStr = NULL; | |
2804 | |
2805 return ATI_CMPL_NO_OUTPUT; | |
2806 } | |
2807 | |
2808 GLOBAL T_ATI_RSLT queatPlusCNMI (char *cl, UBYTE srcId) | |
2809 { | |
2810 char* me = "+CNMI: "; | |
2811 T_ACI_CNMI_MT mt = CNMI_MT_NotPresent; | |
2812 T_ACI_CNMI_BM bm = CNMI_BM_NotPresent; | |
2813 T_ACI_CNMI_DS ds = CNMI_DS_NotPresent; | |
2814 | |
2815 if ( qAT_PlusCNMI ( (T_ACI_CMD_SRC)srcId, &mt, &bm, &ds ) EQ AT_CMPL ) | |
2816 { | |
2817 sprintf ( g_sa,"%s%d,%d,%d,%d,%d", me, at.CNMI_mode, | |
2818 mt, bm, ds, at.CNMI_bfr ); | |
2819 io_sendMessage ( srcId, g_sa, ATI_NORMAL_OUTPUT ); | |
2820 } | |
2821 else | |
2822 { | |
2823 io_sendConfirm ( srcId, cmdCmsError ( CMS_ERR_NotPresent ), ATI_ERROR_OUTPUT ); | |
2824 cmdErrStr = NULL; | |
2825 return ATI_FAIL_NO_OUTPUT; | |
2826 } | |
2827 | |
2828 io_sendConfirm ( srcId, cmdAtError ( atOk ), ATI_NORMAL_OUTPUT ); | |
2829 cmdErrStr = NULL; | |
2830 return ATI_CMPL_NO_OUTPUT; | |
2831 } | |
2832 | |
2833 #ifdef TI_PS_FF_AT_P_CMD_CPRSM | |
2834 /* | |
2835 +--------------------------------------------------------------------+ | |
2836 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2837 | STATE : code ROUTINE : setatPercentCPRSM | | |
2838 +--------------------------------------------------------------------+ | |
2839 | |
2840 PURPOSE : %CPRSM set command | |
2841 set the receiving of SMS to | |
2842 1 -- Pause or | |
2843 2 -- Resume | |
2844 | |
2845 */ | |
2846 | |
2847 GLOBAL T_ATI_RSLT setatPercentCPRSM (char *cl, UBYTE srcId) | |
2848 { | |
2849 T_ACI_RETURN ret = AT_FAIL; | |
2850 T_ACI_CPRSM_MOD mode = CPRSM_MOD_NotPresent; | |
2851 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2852 | |
2853 src_params->curAtCmd = AT_CMD_CPRSM; | |
2854 | |
2855 /* parse command */ | |
2856 cl = parse (cl, "d", &mode); | |
2857 | |
2858 /* check whether parsing has been successful */ | |
2859 if (!cl) | |
2860 { | |
2861 /* undefined value for mode */ | |
2862 TRACE_EVENT("+CPRSM ERROR: parse cmd failed!"); | |
2863 cmdCmsError(CMS_ERR_OpNotAllowed); | |
2864 return ATI_FAIL; | |
2865 } | |
2866 | |
2867 #ifdef FF_ATI_BAT | |
2868 { | |
2869 T_BAT_cmd_send cmd; | |
2870 T_BAT_cmd_set_percent_cprsm my_bat_set_percent_cprsm; | |
2871 | |
2872 TRACE_FUNCTION("setatPercentCPRSM() calls bat_send() <=== as APPLICATION"); | |
2873 | |
2874 memset(&my_bat_set_percent_cprsm, 0, sizeof(my_bat_set_percent_cprsm)); | |
2875 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CPRSM; | |
2876 cmd.params.ptr_set_percent_cprsm = &my_bat_set_percent_cprsm; | |
2877 | |
2878 my_bat_set_percent_cprsm.mode = mode; | |
2879 | |
2880 bat_send(ati_bat_get_client(srcId), &cmd); | |
2881 | |
2882 return ATI_EXCT; /* executing, because response is passed by callback function */ | |
2883 } | |
2884 #else /* OLD FUNCTION BODY */ | |
2885 | |
2886 TRACE_FUNCTION("setatPercentCPRSM()"); | |
2887 | |
2888 switch (mode) /* check which mode has to be set and set it */ | |
2889 { | |
2890 case(CPRSM_MOD_Resume): | |
2891 case(CPRSM_MOD_Pause): | |
2892 { | |
2893 /* AT interface function called */ | |
2894 ret = sAT_PercentCPRSM((T_ACI_CMD_SRC)srcId, mode); | |
2895 break; | |
2896 } | |
2897 default: | |
2898 /* undefined value for mode */ | |
2899 TRACE_EVENT_P1("+CPRSM ERROR: undefined value for mode: %d", mode); | |
2900 cmdCmsError(CMS_ERR_OpNotSup); | |
2901 return ATI_FAIL; | |
2902 } | |
2903 | |
2904 /* check result */ | |
2905 switch (ret) | |
2906 { | |
2907 case (AT_CMPL): | |
2908 /* operation successfully completed */ | |
2909 break; | |
2910 case (AT_EXCT): | |
2911 /* operation still executing */ | |
2912 src_params->curAtCmd = AT_CMD_COPS; | |
2913 break; | |
2914 default: | |
2915 /* unknown result type */ | |
2916 TRACE_EVENT_P1("+CPRSM ERROR: undefined result: %d", ret); | |
2917 cmdCmsError(CMS_ERR_UnknownErr); /*Command failed*/ | |
2918 return ATI_FAIL; | |
2919 } | |
2920 | |
2921 /* map error to ATI type and return */ | |
2922 return (map_aci_2_ati_rslt(ret)); | |
2923 | |
2924 #endif /* no FF_ATI_BAT*/ | |
2925 } | |
2926 | |
2927 /* | |
2928 +--------------------------------------------------------------------+ | |
2929 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2930 | STATE : code ROUTINE : queatPercentCPRSM | | |
2931 +--------------------------------------------------------------------+ | |
2932 | |
2933 PURPOSE : %CPRSM query command | |
2934 request the current state of the pause flag for receiving SMS | |
2935 */ | |
2936 | |
2937 GLOBAL T_ATI_RSLT queatPercentCPRSM (char *cl, UBYTE srcId) | |
2938 { | |
2939 T_ACI_RETURN ret = AT_FAIL; | |
2940 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
2941 | |
2942 TRACE_FUNCTION("queatPercentCPRSM()"); | |
2943 | |
2944 ret = qAT_PercentCPRSM( (T_ACI_CMD_SRC)srcId ); | |
2945 | |
2946 | |
2947 if (ret EQ AT_EXCT) | |
2948 { | |
2949 src_params->curAtCmd = AT_CMD_CPRSM; | |
2950 return (ATI_EXCT); | |
2951 } | |
2952 else | |
2953 { | |
2954 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
2955 return (ATI_FAIL); | |
2956 } | |
2957 } | |
2958 #endif /* TI_PS_FF_AT_P_CMD_CPRSM */ | |
2959 | |
2960 /* | |
2961 +--------------------------------------------------------------------+ | |
2962 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2963 | STATE : code ROUTINE : cmd_clearCnmiBuf | | |
2964 +--------------------------------------------------------------------+ | |
2965 | |
2966 PURPOSE : This function clears the buffer for storing new message | |
2967 indications while the serial interface is reserved for | |
2968 data transmission. | |
2969 */ | |
2970 GLOBAL void cmd_clearCnmiBuf (void) | |
2971 { | |
2972 UBYTE i; | |
2973 | |
2974 for ( i = 0; i < CNMI_BUF_SIZE; i++ ) | |
2975 cnmiBuf.sCnmiElement[i].type = CNMI_NONE; | |
2976 | |
2977 cnmiBuf.next = 0; | |
2978 } | |
2979 | |
2980 /* | |
2981 +--------------------------------------------------------------------+ | |
2982 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
2983 | STATE : code ROUTINE : cmd_flushCnmiBuf | | |
2984 +--------------------------------------------------------------------+ | |
2985 | |
2986 PURPOSE : This function flushes the buffer for storing new message | |
2987 indications while the serial interface is released from | |
2988 data transmission. | |
2989 */ | |
2990 GLOBAL void cmd_flushCnmiBuf (void) | |
2991 { | |
2992 UBYTE i = cnmiBuf.next; | |
2993 UBYTE entries_read = 0; | |
2994 | |
2995 TRACE_FUNCTION("cmd_flushCnmiBuf"); | |
2996 | |
2997 if ( cnmiBuf.sCnmiElement[0].type EQ CNMI_NONE ) | |
2998 { | |
2999 entries_read = CNMI_BUF_SIZE; /* no need to read anything at all */ | |
3000 /*moreEntries = FALSE; */ | |
3001 } | |
3002 else if ( cnmiBuf.next EQ CNMI_BUF_SIZE OR | |
3003 cnmiBuf.sCnmiElement[cnmiBuf.next].type EQ CNMI_NONE ) | |
3004 { | |
3005 i = 0; | |
3006 } | |
3007 | |
3008 cnmiFlushInProgress = TRUE; | |
3009 | |
3010 while ( entries_read < CNMI_BUF_SIZE /*moreEntries*/ ) | |
3011 { | |
3012 if (smsShrdPrm.pDecMsg) | |
3013 { /* clear p_sm buffer */ | |
3014 ACI_MFREE(smsShrdPrm.pDecMsg); | |
3015 smsShrdPrm.pDecMsg = NULL; | |
3016 } | |
3017 | |
3018 switch ( cnmiBuf.sCnmiElement[i].type ) | |
3019 { | |
3020 | |
3021 case ( CNMI_CMT ): | |
3022 srcId_cb = smsShrdPrm.smsSrcId; | |
3023 rCI_PlusCMT ( &cnmiBuf.sCnmiElement[i].indct.cmt ); | |
3024 break; | |
3025 | |
3026 case ( CNMI_CMTI ): | |
3027 srcId_cb = smsShrdPrm.smsSrcId; | |
3028 rCI_PlusCMTI ( cnmiBuf.sCnmiElement[i].indct.cmti.mem, | |
3029 cnmiBuf.sCnmiElement[i].indct.cmti.index ); | |
3030 break; | |
3031 | |
3032 case ( CNMI_CBM ): | |
3033 srcId_cb = smsShrdPrm.smsSrcId; | |
3034 rCI_PlusCBM ( &cnmiBuf.sCnmiElement[i].indct.cbm ); | |
3035 break; | |
3036 | |
3037 case ( CNMI_CDS ): | |
3038 srcId_cb = smsShrdPrm.smsSrcId; | |
3039 rCI_PlusCDS ( &cnmiBuf.sCnmiElement[i].indct.cds ); | |
3040 break; | |
3041 | |
3042 default: | |
3043 /* moreEntries = FALSE; */ | |
3044 break; | |
3045 } | |
3046 | |
3047 cnmiBuf.sCnmiElement[i].type = CNMI_NONE; | |
3048 i++; | |
3049 entries_read++; | |
3050 | |
3051 if ( i EQ CNMI_BUF_SIZE ) | |
3052 i = 0; | |
3053 } | |
3054 | |
3055 cnmiFlushInProgress = FALSE; | |
3056 cnmiBuf.next = 0; | |
3057 } | |
3058 | |
3059 /* | |
3060 +--------------------------------------------------------------------------+ | |
3061 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3062 | STATE : code ROUTINE : cmd_flushCnmiBufOneByOne | | |
3063 +--------------------------------------------------------------------------+ | |
3064 | |
3065 PURPOSE : This function flushes the CNMI buffer in case of Phase2+ mode, | |
3066 while the serial interface is released from | |
3067 data transmission or an +CNMI <bfr>==Flush is requested. | |
3068 */ | |
3069 | |
3070 GLOBAL void cmd_flushCnmiBufOneByOne(void) | |
3071 { /* flushing +CMT one by one, because acknowledge is necessary */ | |
3072 T_CNMI_BUFFER_ELEMENT* psMsgInCnmiBuffer = NULL; | |
3073 UINT16 uiCnmiMsgCounter = 0; | |
3074 | |
3075 for( uiCnmiMsgCounter=0; | |
3076 (uiCnmiMsgCounter<cmd_getNumberOfCnmiEntrys()) AND | |
3077 (waitForCnmaFromBuffer_SrcId EQ CMD_SRC_NONE); | |
3078 uiCnmiMsgCounter++ ) | |
3079 { /* there are entrys in the CNMI buffer --> read it */ | |
3080 psMsgInCnmiBuffer = cmd_getCnmiMessage(uiCnmiMsgCounter); /* FIFO */ | |
3081 | |
3082 if( psMsgInCnmiBuffer EQ NULL ) | |
3083 { | |
3084 TRACE_EVENT("ati_switch_mode() : Error at CNMI-buffer handling: NULL-pointer access!!"); | |
3085 return; | |
3086 } | |
3087 | |
3088 cnmiFlushInProgress = TRUE; /* needed for the rCI_...commands */ | |
3089 | |
3090 if (smsShrdPrm.pDecMsg) | |
3091 { /* clear p_sm buffer */ | |
3092 ACI_MFREE(smsShrdPrm.pDecMsg); | |
3093 smsShrdPrm.pDecMsg = NULL; | |
3094 } | |
3095 | |
3096 switch ( psMsgInCnmiBuffer->type ) | |
3097 { | |
3098 case ( CNMI_CMTI ) : | |
3099 srcId_cb = smsShrdPrm.smsSrcId; | |
3100 rCI_PlusCMTI ( psMsgInCnmiBuffer->indct.cmti.mem, psMsgInCnmiBuffer->indct.cmti.index ); | |
3101 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3102 uiCnmiMsgCounter--; | |
3103 break; | |
3104 | |
3105 case ( CNMI_CBM ) : | |
3106 srcId_cb = smsShrdPrm.smsSrcId; | |
3107 rCI_PlusCBM ( &psMsgInCnmiBuffer->indct.cbm ); | |
3108 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3109 uiCnmiMsgCounter--; | |
3110 break; | |
3111 | |
3112 case ( CNMI_CDS ) : | |
3113 srcId_cb = smsShrdPrm.smsSrcId; | |
3114 rCI_PlusCDS ( &psMsgInCnmiBuffer->indct.cds ); | |
3115 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3116 uiCnmiMsgCounter--; | |
3117 break; | |
3118 | |
3119 /* special handling for +CMT --> acknowledge needed */ | |
3120 case ( CNMI_CMT ) : | |
3121 { | |
3122 srcId_cb = smsShrdPrm.smsSrcId; | |
3123 rCI_PlusCMT ( &psMsgInCnmiBuffer->indct.cmt ); | |
3124 TIMERSTART(ACI_CNMA_TIMER_VALUE, ACI_CNMA_TIMER_HANDLE); | |
3125 waitForCnmaFromBuffer_SrcId = smsShrdPrm.smsSrcId; | |
3126 break; | |
3127 } | |
3128 default: | |
3129 TRACE_EVENT("ati_switch_mode() : wrong CNMI-buffer handling: wrong Msg. type"); | |
3130 } | |
3131 } | |
3132 cnmiFlushInProgress = FALSE; | |
3133 } | |
3134 | |
3135 /* | |
3136 +--------------------------------------------------------------------+ | |
3137 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3138 | STATE : code ROUTINE : cmd_addCnmiNtry | | |
3139 +--------------------------------------------------------------------+ | |
3140 | |
3141 PURPOSE : This function add a new entry to the buffer for storing | |
3142 new message indications while the serial interface is | |
3143 reserved for data transmission. | |
3144 */ | |
3145 GLOBAL void cmd_addCnmiNtry ( UBYTE type, T_CNMI_IND* newInd ) | |
3146 { | |
3147 TRACE_FUNCTION("cmd_addCnmiNtry"); | |
3148 | |
3149 if ( type > CNMI_CDS OR type < CNMI_CMT ) | |
3150 return; | |
3151 | |
3152 if ( cnmiBuf.next EQ CNMI_BUF_SIZE ) | |
3153 { | |
3154 cnmiBuf.next = 0; | |
3155 } | |
3156 | |
3157 switch ( type ) | |
3158 { | |
3159 case ( CNMI_CMT ): | |
3160 cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cmt = newInd -> cmt; | |
3161 break; | |
3162 | |
3163 case ( CNMI_CMTI ): | |
3164 cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cmti = newInd -> cmti; | |
3165 break; | |
3166 | |
3167 | |
3168 case ( CNMI_CBM ): | |
3169 cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cbm = newInd -> cbm; | |
3170 break; | |
3171 | |
3172 case ( CNMI_CDS ): | |
3173 cnmiBuf.sCnmiElement[cnmiBuf.next].indct.cds = newInd -> cds; | |
3174 break; | |
3175 } | |
3176 | |
3177 cnmiBuf.sCnmiElement[cnmiBuf.next].type = type; | |
3178 cnmiBuf.next++; | |
3179 } | |
3180 | |
3181 | |
3182 /* | |
3183 +-----------------------------------------------------------------------+ | |
3184 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3185 | STATE : code ROUTINE : getNumberOfCnmiEntrys | | |
3186 +-----------------------------------------------------------------------+ | |
3187 | |
3188 PURPOSE : This function is the responsible to get the count | |
3189 of CNMI entrys in the CNMI buffer. | |
3190 */ | |
3191 GLOBAL UINT16 cmd_getNumberOfCnmiEntrys(void) | |
3192 { | |
3193 return cnmiBuf.next; | |
3194 } | |
3195 | |
3196 | |
3197 /* | |
3198 +-----------------------------------------------------------------------+ | |
3199 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3200 | STATE : code ROUTINE : getCnmiMessage | | |
3201 +-----------------------------------------------------------------------+ | |
3202 | |
3203 PURPOSE : This function is the responsible to get an entire Msg. | |
3204 from the CNMI buffer. That means, this function only returns | |
3205 the pointer to the beginning of the CNMI buffer element. | |
3206 If the buffer is empty or if the uiIndex parameter is bigger | |
3207 than allowed, the return pointer will be NULL. | |
3208 */ | |
3209 GLOBAL T_CNMI_BUFFER_ELEMENT* cmd_getCnmiMessage(UINT16 uiIndex) | |
3210 { | |
3211 T_CNMI_BUFFER_ELEMENT* psCnmiBufferElement = NULL; | |
3212 | |
3213 if( (cnmiBuf.next EQ 0) OR | |
3214 (cnmiBuf.sCnmiElement[0].type EQ CNMI_NONE) OR | |
3215 (uiIndex >= CNMI_BUF_SIZE ) ) | |
3216 { | |
3217 return NULL; | |
3218 } | |
3219 | |
3220 psCnmiBufferElement = &cnmiBuf.sCnmiElement[uiIndex]; | |
3221 return psCnmiBufferElement; /* returns the pointer to the element */ | |
3222 } | |
3223 | |
3224 | |
3225 /* | |
3226 +-----------------------------------------------------------------------+ | |
3227 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3228 | STATE : code ROUTINE : clearFirstCnmiMessage | | |
3229 +-----------------------------------------------------------------------+ | |
3230 | |
3231 PURPOSE : This function is the responsible to clear an entire Msg. | |
3232 specified by uiIndex from the CNMI buffer. | |
3233 After succesful return, the message was delete from the CNMI | |
3234 buffer and the buffer has been resorted. | |
3235 */ | |
3236 GLOBAL BOOL cmd_clearCnmiMessage(UINT16 uiIndex) | |
3237 { | |
3238 UINT16 uiBufCount; | |
3239 | |
3240 if( (cnmiBuf.next EQ 0) OR | |
3241 (cnmiBuf.sCnmiElement[0].type EQ CNMI_NONE)) | |
3242 { | |
3243 return FALSE; /* CNMI buffer is empty or flushing is in progress */ | |
3244 } | |
3245 | |
3246 /* delete first entry while resorting the buffer */ | |
3247 for( uiBufCount = uiIndex; uiBufCount<(CNMI_BUF_SIZE-1); uiBufCount++ ) | |
3248 { | |
3249 memcpy( &cnmiBuf.sCnmiElement[uiBufCount], &cnmiBuf.sCnmiElement[uiBufCount+1], sizeof(T_CNMI_BUFFER_ELEMENT) ); | |
3250 } | |
3251 | |
3252 cnmiBuf.next--; | |
3253 | |
3254 return TRUE; | |
3255 } | |
3256 | |
3257 /* | |
3258 +-----------------------------------------------------------------------+ | |
3259 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3260 | STATE : code ROUTINE : getCnmiMessage | | |
3261 +-----------------------------------------------------------------------+ | |
3262 | |
3263 PURPOSE : This function is the responsible to get the first entire Msg. | |
3264 from the CNMI buffer. That means, this function only returns | |
3265 the pointer to the beginning of the CNMI buffer. | |
3266 If the buffer is empty, the return pointer will be NULL. | |
3267 */ | |
3268 GLOBAL T_CNMI_BUFFER_ELEMENT* cmd_getFirstCnmiMessage(void) | |
3269 { | |
3270 return cmd_getCnmiMessage(0); | |
3271 } | |
3272 | |
3273 | |
3274 /* | |
3275 +-----------------------------------------------------------------------+ | |
3276 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3277 | STATE : code ROUTINE : clearFirstCnmiMessage | | |
3278 +-----------------------------------------------------------------------+ | |
3279 | |
3280 PURPOSE : This function is the responsible to clear the first entire Msg. | |
3281 from the CNMI buffer. After succesful return, the | |
3282 message was delete from the CNMI buffer. | |
3283 */ | |
3284 GLOBAL BOOL cmd_clearFirstCnmiMessage(void) | |
3285 { | |
3286 return cmd_clearCnmiMessage(0); | |
3287 } | |
3288 | |
3289 | |
3290 /* | |
3291 +--------------------------------------------------------------------+ | |
3292 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3293 | STATE : code ROUTINE : rCI_IoMode | | |
3294 +--------------------------------------------------------------------+ | |
3295 | |
3296 PURPOSE : This function will be called when IO mode of serial | |
3297 interface has changed. | |
3298 */ | |
3299 GLOBAL void rCI_IoMode ( void ) | |
3300 { | |
3301 TRACE_FUNCTION ( "rCI_IoMode (): actually not awaited !!" ); | |
3302 | |
3303 /* if ( io_getIoMode () EQ IO_MODE_CMD AND | |
3304 at.CNMI_mode EQ CNMI_MOD_Buffer ) | |
3305 cmd_flushCnmiBuf (CMD_SRC_ATI);*/ | |
3306 } | |
3307 | |
3308 | |
3309 | |
3310 /* | |
3311 +--------------------------------------------------------------------+ | |
3312 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3313 | STATE : code ROUTINE : setatPercentCMGRS | | |
3314 +--------------------------------------------------------------------+ | |
3315 | |
3316 PURPOSE : %CMGRS command (Select auto retransmission mode/ | |
3317 request manual retransmission of last failed SMS) | |
3318 */ | |
3319 #ifdef REL99 | |
3320 | |
3321 GLOBAL T_ATI_RSLT setatPercentCMGRS (char *cl, UBYTE srcId) | |
3322 { | |
3323 T_ACI_RETURN ret = AT_FAIL; | |
3324 T_ACI_CMGRS_MODE mode; | |
3325 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3326 | |
3327 TRACE_FUNCTION("setatPercentCMGRS()"); | |
3328 | |
3329 cl = parse (cl,"d",&mode); | |
3330 if ( !cl OR mode > CMGRS_MODE_MANUAL_RETRANS) | |
3331 { | |
3332 cmdCmsError(CMS_ERR_OpNotAllowed); | |
3333 return (ATI_FAIL); | |
3334 } | |
3335 | |
3336 #ifdef FF_ATI_BAT | |
3337 { | |
3338 T_BAT_cmd_send cmd; | |
3339 T_BAT_cmd_set_percent_cmgrs cmgrs; | |
3340 cmd.ctrl_params = BAT_CMD_SET_PERCENT_CMGRS; | |
3341 cmd.params.ptr_set_percent_cmgrs = &cmgrs; | |
3342 | |
3343 cmgrs.mode = (U8)mode; | |
3344 bat_send(ati_bat_get_client(srcId), &cmd); | |
3345 src_params->curAtCmd = AT_CMD_P_CMGRS; | |
3346 return(ATI_EXCT); | |
3347 } | |
3348 #else | |
3349 | |
3350 ret = sAT_PercentCMGRS((T_ACI_CMD_SRC)srcId,mode); | |
3351 | |
3352 if(ret EQ AT_EXCT) | |
3353 { | |
3354 src_params->curAtCmd = AT_CMD_P_CMGRS; | |
3355 return ATI_EXCT; | |
3356 } | |
3357 else if(ret EQ AT_CMPL) | |
3358 { | |
3359 return ATI_CMPL; | |
3360 } | |
3361 else | |
3362 { | |
3363 cmdCmeError( CME_ERR_Unknown ); // use aciErrDesc | |
3364 return (ATI_FAIL); | |
3365 } | |
3366 #endif | |
3367 } | |
3368 | |
3369 GLOBAL T_ATI_RSLT queatPercentCMGRS (char *cl, UBYTE srcId) | |
3370 { | |
3371 T_ACI_RETURN ret = AT_FAIL; | |
3372 | |
3373 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3374 | |
3375 #ifdef FF_ATI_BAT | |
3376 T_BAT_cmd_send cmd; | |
3377 T_BAT_no_parameter dummy; | |
3378 | |
3379 cmd.ctrl_params = BAT_RES_QUE_PERCENT_CMGRS; | |
3380 dummy.bat_dummy = 0xFF; | |
3381 cmd.params.ptr_que_percent_cmgrs = &dummy; | |
3382 | |
3383 bat_send(ati_bat_get_client(srcId),&cmd); | |
3384 | |
3385 return ATI_EXCT; | |
3386 #else | |
3387 UBYTE auto_rep_flag; | |
3388 | |
3389 ret = qAT_PercentCMGRS((T_ACI_CMD_SRC)srcId,&auto_rep_flag); | |
3390 if (ret EQ AT_CMPL) | |
3391 { | |
3392 sprintf(g_sa,"%s: %d","%CMGRS",auto_rep_flag); | |
3393 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
3394 return (ATI_CMPL); | |
3395 } | |
3396 else | |
3397 { | |
3398 cmdCmsError(CMS_ERR_NotPresent); // use aciErrDesc | |
3399 return (ATI_FAIL); | |
3400 } | |
3401 #endif | |
3402 } | |
3403 | |
3404 #endif /* REL99 */ | |
3405 | |
3406 | |
3407 /* | |
3408 +-----------------------------------------------------------------------+ | |
3409 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3410 | STATE : code ROUTINE : cmd_handleCnmaTimeout | | |
3411 +-----------------------------------------------------------------------+ | |
3412 | |
3413 PURPOSE : This function will be called when the +CNMA Timer has expired. | |
3414 Now all to be acknowledged +CMT messages whithin the CNMI | |
3415 buffer must be stored in the non-volatile buffer e.g. SIM... | |
3416 Note: all other Msgs. different from +CMT will be deliver | |
3417 to the source and remove from buffer. */ | |
3418 | |
3419 GLOBAL void cmd_handleCnmaTimeout( void ) | |
3420 { | |
3421 UINT16 uiCnmiMsgCounter = 0; | |
3422 T_CNMI_BUFFER_ELEMENT *psMsgInCnmiBuffer = NULL; | |
3423 | |
3424 TRACE_FUNCTION ( "cmd_handleCnmaTimeout()" ); | |
3425 | |
3426 cmhSMS_resetMtDsCnmiParam(); | |
3427 | |
3428 if( waitForCnmaFromBuffer_SrcId EQ CMD_SRC_NONE OR | |
3429 waitForCnmaFromBuffer_SrcId NEQ smsShrdPrm.smsSrcId) | |
3430 { | |
3431 TRACE_EVENT("cmd_handleCnmaTimeout() : Error at CNMI-buffer handling: No +CNMA acknowledge expected!!"); | |
3432 waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE; | |
3433 return; | |
3434 } | |
3435 | |
3436 for( uiCnmiMsgCounter=0; uiCnmiMsgCounter<cmd_getNumberOfCnmiEntrys(); uiCnmiMsgCounter++ ) | |
3437 { /* there are entrys in the CNMI buffer --> read it */ | |
3438 psMsgInCnmiBuffer = cmd_getCnmiMessage(uiCnmiMsgCounter); /* FIFO */ | |
3439 | |
3440 if( psMsgInCnmiBuffer EQ NULL ) | |
3441 { | |
3442 TRACE_EVENT("cmd_handleCnmaTimeout() : Error at CNMI-buffer handling: NULL-pointer access!!"); | |
3443 waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE; | |
3444 return; | |
3445 } | |
3446 | |
3447 cnmiFlushInProgress = TRUE; | |
3448 | |
3449 switch ( psMsgInCnmiBuffer->type ) | |
3450 { | |
3451 case ( CNMI_CMTI ) : | |
3452 srcId_cb = smsShrdPrm.smsSrcId; | |
3453 rCI_PlusCMTI ( psMsgInCnmiBuffer->indct.cmti.mem, psMsgInCnmiBuffer->indct.cmti.index ); | |
3454 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3455 uiCnmiMsgCounter--; | |
3456 break; | |
3457 | |
3458 case ( CNMI_CBM ) : | |
3459 srcId_cb = smsShrdPrm.smsSrcId; | |
3460 rCI_PlusCBM ( &psMsgInCnmiBuffer->indct.cbm ); | |
3461 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3462 uiCnmiMsgCounter--; | |
3463 break; | |
3464 | |
3465 case ( CNMI_CDS ) : | |
3466 srcId_cb = smsShrdPrm.smsSrcId; | |
3467 rCI_PlusCDS ( &psMsgInCnmiBuffer->indct.cds ); | |
3468 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3469 uiCnmiMsgCounter--; | |
3470 break; | |
3471 | |
3472 /* special handling for +CMT --> acknowledge needed */ | |
3473 case ( CNMI_CMT ) : | |
3474 { | |
3475 T_ACI_SM_DATA sPduData; | |
3476 | |
3477 waitForCnmaFromBuffer_SrcId = CMD_SRC_NONE; /* clear CNMA waiting flag */ | |
3478 srcId_cb = smsShrdPrm.smsSrcId; | |
3479 sPduData.len = psMsgInCnmiBuffer->indct.cmt.sms_sdu.l_buf / 8; /* l_buf is in BIT !! */ | |
3480 memcpy( &sPduData.data, &psMsgInCnmiBuffer->indct.cmt.sms_sdu.buf, SIM_PDU_LEN ); | |
3481 cmhSMS_storePduToSim( smsShrdPrm.smsSrcId, SMS_RECORD_REC_UNREAD, &sPduData ); | |
3482 cnmiFlushInProgress = FALSE; | |
3483 return; /* only one SMS can be stored at the SIM here */ | |
3484 } | |
3485 | |
3486 default: | |
3487 TRACE_EVENT("cmd_handleCnmaTimeout() : wrong CNMI-buffer handling: wrong Msg. type"); | |
3488 } | |
3489 cnmiFlushInProgress = FALSE; | |
3490 } | |
3491 } | |
3492 | |
3493 /* | |
3494 +-----------------------------------------------------------------------+ | |
3495 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3496 | STATE : code ROUTINE : cmd_handleCnmaTimeout | | |
3497 +-----------------------------------------------------------------------+ | |
3498 | |
3499 PURPOSE : This function stores the next message - correxponding | |
3500 to a specified source - into the non volatile memory. | |
3501 Note: all other Msgs. different from +CMT will be deliver | |
3502 to the source and remove from buffer. | |
3503 */ | |
3504 GLOBAL BOOL cmd_storeNextCnmiBufMsgToSim( void ) | |
3505 { | |
3506 UINT16 uiCnmiMsgCounter = 0; | |
3507 T_CNMI_BUFFER_ELEMENT *psMsgInCnmiBuffer = NULL; | |
3508 | |
3509 TRACE_FUNCTION ( "cmd_storeNextCnmiBufMsgToSim()" ); | |
3510 | |
3511 if( smsShrdPrm.uiInternalSmsStorage EQ CMD_SRC_NONE OR | |
3512 smsShrdPrm.uiInternalSmsStorage NEQ smsShrdPrm.smsSrcId) | |
3513 { | |
3514 TRACE_EVENT("cmd_storeNextCnmiBufMsgToSim() : no valid source -> abort !!"); | |
3515 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
3516 return(FALSE); | |
3517 } | |
3518 | |
3519 for( uiCnmiMsgCounter=0; uiCnmiMsgCounter<cmd_getNumberOfCnmiEntrys(); uiCnmiMsgCounter++ ) | |
3520 { /* there are entrys in the CNMI buffer --> read it */ | |
3521 psMsgInCnmiBuffer = cmd_getCnmiMessage(uiCnmiMsgCounter); /* FIFO */ | |
3522 | |
3523 if( psMsgInCnmiBuffer EQ NULL ) | |
3524 { | |
3525 TRACE_EVENT("cmd_storeNextCnmiBufMsgToSim() : Error at CNMI-buffer handling: NULL-pointer access!!"); | |
3526 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; | |
3527 return(FALSE); | |
3528 } | |
3529 | |
3530 cnmiFlushInProgress = TRUE; | |
3531 | |
3532 switch ( psMsgInCnmiBuffer->type ) | |
3533 { | |
3534 case ( CNMI_CMTI ) : | |
3535 srcId_cb = smsShrdPrm.smsSrcId; | |
3536 rCI_PlusCMTI ( psMsgInCnmiBuffer->indct.cmti.mem, psMsgInCnmiBuffer->indct.cmti.index ); | |
3537 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3538 uiCnmiMsgCounter--; | |
3539 break; | |
3540 | |
3541 case ( CNMI_CBM ) : | |
3542 srcId_cb = smsShrdPrm.smsSrcId; | |
3543 rCI_PlusCBM ( &psMsgInCnmiBuffer->indct.cbm ); | |
3544 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3545 uiCnmiMsgCounter--; | |
3546 break; | |
3547 | |
3548 case ( CNMI_CDS ) : | |
3549 srcId_cb = smsShrdPrm.smsSrcId; | |
3550 rCI_PlusCDS ( &psMsgInCnmiBuffer->indct.cds ); | |
3551 cmd_clearCnmiMessage(uiCnmiMsgCounter); | |
3552 uiCnmiMsgCounter--; | |
3553 break; | |
3554 | |
3555 /* special handling for +CMT --> acknowledge needed */ | |
3556 case ( CNMI_CMT ) : | |
3557 { | |
3558 T_ACI_SM_DATA sPduData; | |
3559 | |
3560 srcId_cb = smsShrdPrm.smsSrcId; | |
3561 sPduData.len = psMsgInCnmiBuffer->indct.cmt.sms_sdu.l_buf / 8; /* l_buf is in BIT !! */ | |
3562 memcpy( &sPduData.data, &psMsgInCnmiBuffer->indct.cmt.sms_sdu.buf, SIM_PDU_LEN ); | |
3563 cmhSMS_storePduToSim( smsShrdPrm.smsSrcId, SMS_RECORD_REC_UNREAD, &sPduData ); | |
3564 cnmiFlushInProgress = FALSE; | |
3565 return(TRUE); /* only one SMS can be stored at the SIM here */ | |
3566 } | |
3567 | |
3568 default: | |
3569 TRACE_EVENT("cmd_handleCnmaTimeout() : wrong CNMI-buffer handling: wrong Msg. type"); | |
3570 } | |
3571 cnmiFlushInProgress = FALSE; | |
3572 } | |
3573 smsShrdPrm.uiInternalSmsStorage = CMD_SRC_NONE; /* no more +CMT has to be store */ | |
3574 return(FALSE); | |
3575 } | |
3576 | |
3577 /* | |
3578 +--------------------------------------------------------------------+ | |
3579 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3580 | STATE : code ROUTINE : setatPlusCMMS | | |
3581 +--------------------------------------------------------------------+ | |
3582 | |
3583 PURPOSE : +CMMS command (More Messages To Send) | |
3584 */ | |
3585 | |
3586 GLOBAL T_ATI_RSLT setatPlusCMMS (char *cl, UBYTE srcId) | |
3587 { | |
3588 T_ACI_RETURN ret = AT_FAIL; | |
3589 S8 mode = 0; | |
3590 | |
3591 TRACE_FUNCTION("setatPlusCMMS()"); | |
3592 | |
3593 cl = parse (cl,"r",&mode); | |
3594 | |
3595 /* | |
3596 * no mode values allowed other than 0-2 | |
3597 */ | |
3598 if ( !cl OR (mode < CMMS_MODE_DEF OR mode > CMMS_MODE_TWO)) | |
3599 { | |
3600 cmdCmsError(CMS_ERR_OpNotAllowed); | |
3601 return (ATI_FAIL); | |
3602 } | |
3603 ret = sAT_PlusCMMS((T_ACI_CMD_SRC)srcId,mode); | |
3604 if (ret NEQ AT_CMPL) | |
3605 { | |
3606 cmdCmsError(CMS_ERR_UnknownErr); | |
3607 return (ATI_FAIL); | |
3608 } | |
3609 return (map_aci_2_ati_rslt(ret)); | |
3610 } | |
3611 | |
3612 /* | |
3613 +--------------------------------------------------------------------+ | |
3614 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3615 | STATE : code ROUTINE : queatPlusCMMS | | |
3616 +--------------------------------------------------------------------+ | |
3617 | |
3618 PURPOSE : +CMMS query command | |
3619 */ | |
3620 GLOBAL T_ATI_RSLT queatPlusCMMS (char *cl, UBYTE srcId) | |
3621 { | |
3622 T_ACI_RETURN ret = AT_FAIL; | |
3623 UBYTE mode = CMMS_MODE_DEF; | |
3624 | |
3625 TRACE_FUNCTION("queatPlusCMMS()"); | |
3626 | |
3627 ret = qAT_PlusCMMS ((T_ACI_CMD_SRC)srcId,&mode); | |
3628 if (ret EQ AT_CMPL) | |
3629 { | |
3630 sprintf(g_sa, "+CMMS: %d", mode); | |
3631 io_sendMessage(srcId, g_sa, ATI_NORMAL_OUTPUT); | |
3632 return (ATI_CMPL); | |
3633 } | |
3634 else | |
3635 { | |
3636 cmdCmsError(CMS_ERR_NotPresent); | |
3637 return (ATI_FAIL); | |
3638 } | |
3639 } | |
3640 | |
3641 /* | |
3642 +-------------------------------------------------------------------------+ | |
3643 | PROJECT : GSM-F&D MODULE : ATI_SMS | | |
3644 | STATE : finished ROUTINE : txt_rdmode_to_smsrdmode| | |
3645 +-------------------------------------------------------------------------+ | |
3646 | |
3647 PURPOSE : converts the text read mode to smsReadMode. | |
3648 | |
3649 */ | |
3650 GLOBAL T_ATI_RSLT txt_rdmode_to_smsrdmode(char *txt_rdmode) | |
3651 { | |
3652 UBYTE i = 0; | |
3653 | |
3654 if (txt_rdmode[0] EQ '\0') | |
3655 { | |
3656 strcpy (txt_rdmode, sms_rdmode[0].name); /* NORMAL as default */ | |
3657 } | |
3658 while ( sms_rdmode[i].name NEQ NULL AND | |
3659 strcmp ( sms_rdmode[i].name, txt_rdmode ) NEQ 0 ) | |
3660 { | |
3661 i++; | |
3662 } | |
3663 | |
3664 if ( sms_rdmode[i].name EQ NULL ) | |
3665 { | |
3666 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
3667 return (ATI_FAIL); | |
3668 } | |
3669 smsReadMode = sms_rdmode[i].rdmode; | |
3670 return ATI_CMPL; | |
3671 } | |
3672 | |
3673 | |
3674 /* | |
3675 +--------------------------------------------------------------------+ | |
3676 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3677 | STATE : code ROUTINE : atPercentCMGL | | |
3678 +--------------------------------------------------------------------+ | |
3679 | |
3680 PURPOSE : %CMGL command (List Message) | |
3681 */ | |
3682 | |
3683 GLOBAL T_ATI_RSLT atPercentCMGL (char *cl, UBYTE srcId) | |
3684 { | |
3685 T_ACI_RETURN ret; | |
3686 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3687 | |
3688 #ifdef SMS_PDU_SUPPORT | |
3689 T_ACI_CMGF_MOD mode; | |
3690 #endif | |
3691 CHAR txtStat[15]= {0}; | |
3692 CHAR txtRdMode[20] = {0}; | |
3693 USHORT i; | |
3694 | |
3695 TRACE_FUNCTION("atPercentCMGL()"); | |
3696 | |
3697 cmglStat = SMS_STAT_NotPresent; | |
3698 smsReadMode = SMS_READ_NotPresent; | |
3699 | |
3700 if (*cl EQ '\0') | |
3701 { | |
3702 smsReadMode = SMS_READ_Normal; | |
3703 } | |
3704 else | |
3705 { | |
3706 /* | |
3707 * Request of a list of stored SMS messages | |
3708 * Parameter stat is optional | |
3709 */ | |
3710 #ifdef SMS_PDU_SUPPORT | |
3711 /* | |
3712 * request current mode | |
3713 */ | |
3714 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
3715 if (mode EQ 0) | |
3716 { | |
3717 | |
3718 /* | |
3719 * %CMGL=[stat],[preview] | |
3720 */ | |
3721 cl = parse (cl, "dd", &cmglStat, &smsReadMode ); | |
3722 if ( !cl | |
3723 OR ((cmglStat < SMS_STAT_RecUnread OR cmglStat > SMS_STAT_All) | |
3724 AND smsReadMode EQ SMS_READ_NotPresent) | |
3725 OR (cmglStat < SMS_STAT_RecUnread AND smsReadMode > SMS_READ_NotPresent) | |
3726 OR (smsReadMode > SMS_READ_StatusChange)) | |
3727 { | |
3728 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
3729 return (ATI_FAIL); | |
3730 } | |
3731 } | |
3732 else | |
3733 #endif | |
3734 { | |
3735 | |
3736 /* | |
3737 * %CMGL=[stat],[preview] | |
3738 */ | |
3739 cl = parse (cl, "ss", (LONG)sizeof(txtStat), txtStat, | |
3740 (LONG)sizeof(txtRdMode), txtRdMode); | |
3741 if ( !cl OR (txtStat[0] EQ '\0' AND txtRdMode[0] NEQ '\0')) | |
3742 { | |
3743 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
3744 return (ATI_FAIL); | |
3745 } | |
3746 if (txtStat[0] EQ '\0') | |
3747 strcpy (txtStat, sms_stat[4].name); /* ALL as default */ | |
3748 | |
3749 i = 0; | |
3750 while ( sms_stat[i].name NEQ NULL AND | |
3751 strcmp ( sms_stat[i].name, txtStat ) NEQ 0 ) | |
3752 i++; | |
3753 | |
3754 if ( sms_stat[i].name EQ NULL ) | |
3755 { | |
3756 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
3757 return (ATI_FAIL); | |
3758 } | |
3759 cmglStat = sms_stat[i].stat; | |
3760 | |
3761 if (txt_rdmode_to_smsrdmode(txtRdMode) EQ ATI_FAIL) | |
3762 { | |
3763 return (ATI_FAIL); | |
3764 } | |
3765 } | |
3766 } | |
3767 | |
3768 #ifdef FF_ATI_BAT | |
3769 { | |
3770 T_BAT_cmd_send cmd; | |
3771 T_BAT_cmd_set_percent_cmgl cmgl; | |
3772 | |
3773 cmd.ctrl_params=BAT_CMD_SET_PERCENT_CMGL; | |
3774 cmd.params.ptr_set_percent_cmgl=&cmgl; | |
3775 | |
3776 /* | |
3777 * T_ACI_SMS_STAT and T_BAT_percent_cmgl_stat are not quite | |
3778 * identical - the ACI version has the extra value | |
3779 * SMS_STAT_Invalid. | |
3780 */ | |
3781 if (cmglStat EQ SMS_STAT_Invalid) | |
3782 cmgl.stat=BAT_CMGL_STAT_NOT_PRESENT; | |
3783 else | |
3784 cmgl.stat=(T_BAT_percent_cmgl_stat)cmglStat; | |
3785 | |
3786 cmgl.rdmode = smsReadMode ; | |
3787 | |
3788 bat_send(ati_bat_get_client(srcId),&cmd); | |
3789 | |
3790 src_params->curAtCmd=AT_CMD_P_CMGL; | |
3791 return(ATI_EXCT); | |
3792 } | |
3793 | |
3794 #else | |
3795 | |
3796 ret = sAT_PercentCMGL ( (T_ACI_CMD_SRC)srcId, cmglStat, smsReadMode ); | |
3797 | |
3798 if ( ret EQ AT_EXCT ) | |
3799 { | |
3800 src_params->curAtCmd = AT_CMD_P_CMGL; | |
3801 return (ATI_EXCT); | |
3802 } | |
3803 else | |
3804 { | |
3805 cmdCmsError ( CMS_ERR_NotPresent ); | |
3806 return (ATI_FAIL); | |
3807 } | |
3808 #endif | |
3809 } | |
3810 | |
3811 /* | |
3812 +--------------------------------------------------------------------+ | |
3813 | PROJECT : GSM-F&D (8411) MODULE : ACI_CMD | | |
3814 | STATE : code ROUTINE : atPercentCMGR | | |
3815 +--------------------------------------------------------------------+ | |
3816 | |
3817 PURPOSE : %CMGR command (Read Message) | |
3818 */ | |
3819 | |
3820 GLOBAL T_ATI_RSLT atPercentCMGR (char *cl, UBYTE srcId) | |
3821 { | |
3822 T_ACI_RETURN ret = AT_FAIL; | |
3823 SHORT idx=-1; | |
3824 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3825 #ifdef SMS_PDU_SUPPORT | |
3826 T_ACI_CMGF_MOD mode; | |
3827 #endif | |
3828 CHAR txtRdMode[20]={0}; | |
3829 | |
3830 | |
3831 TRACE_FUNCTION("atPercentCMGR()"); | |
3832 | |
3833 smsReadMode = SMS_READ_Normal; | |
3834 | |
3835 #ifdef SMS_PDU_SUPPORT | |
3836 /* | |
3837 * request current mode | |
3838 */ | |
3839 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
3840 if (mode EQ 0) | |
3841 { | |
3842 /* | |
3843 * %CMGR=[index],[preview] | |
3844 */ | |
3845 cl = parse (cl, "rd", &idx, &smsReadMode ); | |
3846 if ( !cl OR idx > 255 OR idx < 0 OR smsReadMode > SMS_READ_StatusChange) | |
3847 { | |
3848 cmdCmsError ( CMS_ERR_OpNotAllowed ); | |
3849 return (ATI_FAIL); | |
3850 } | |
3851 } | |
3852 else | |
3853 #endif | |
3854 { | |
3855 /* | |
3856 * %CMGR=[index],[preview] | |
3857 */ | |
3858 cl = parse (cl, "rs", &idx, | |
3859 (LONG)sizeof(txtRdMode), txtRdMode); | |
3860 | |
3861 if ( !cl OR idx > 255 OR idx < 0) | |
3862 { | |
3863 cmdCmsError(CMS_ERR_OpNotAllowed); | |
3864 return (ATI_FAIL); | |
3865 } | |
3866 if (txt_rdmode_to_smsrdmode(txtRdMode) EQ ATI_FAIL) | |
3867 { | |
3868 return (ATI_FAIL); | |
3869 } | |
3870 } | |
3871 | |
3872 #ifdef FF_ATI_BAT | |
3873 { | |
3874 T_BAT_cmd_send cmd; | |
3875 T_BAT_cmd_set_percent_cmgr cmgr; | |
3876 | |
3877 cmd.ctrl_params=BAT_CMD_SET_PERCENT_CMGR; | |
3878 cmd.params.ptr_set_percent_cmgr=&cmgr; | |
3879 | |
3880 cmgr.sms_index=(U16)idx; | |
3881 | |
3882 cmgr.rdmode = smsReadMode ; | |
3883 | |
3884 bat_send(ati_bat_get_client(srcId), &cmd); | |
3885 | |
3886 src_params->curAtCmd=AT_CMD_P_CMGR; | |
3887 return(ATI_EXCT); | |
3888 } | |
3889 | |
3890 #else | |
3891 | |
3892 #ifndef _CONC_TESTING_ | |
3893 ret = sAT_PercentCMGR_Gl((T_ACI_CMD_SRC)srcId, (UBYTE)idx, smsReadMode , NULL); | |
3894 #else | |
3895 ret = sAT_PercentCMGR (srcId, (UBYTE)idx, smsReadMode ); | |
3896 #endif | |
3897 if ( ret EQ AT_CMPL ) | |
3898 { | |
3899 return (ATI_CMPL); | |
3900 } | |
3901 else if (ret EQ AT_EXCT) | |
3902 { | |
3903 src_params->curAtCmd = AT_CMD_P_CMGR; | |
3904 return (ATI_EXCT); | |
3905 } | |
3906 else | |
3907 { | |
3908 cmdCmsError(CMS_ERR_NotPresent); /* use aciErrDesc */ | |
3909 return (ATI_FAIL); | |
3910 } | |
3911 | |
3912 #endif /*FF_ATI_BAT*/ | |
3913 } | |
3914 | |
3915 GLOBAL T_ATI_RSLT tesatPercentCMGL (char *cl, UBYTE srcId) | |
3916 { | |
3917 #ifdef SMS_PDU_SUPPORT | |
3918 T_ACI_CMGF_MOD mode; | |
3919 T_ATI_SRC_PARAMS *src_params = find_element (ati_src_list, srcId, search_ati_src_id); | |
3920 | |
3921 TRACE_FUNCTION("tesatPercentCMGL()"); | |
3922 /* | |
3923 * request current mode | |
3924 */ | |
3925 qAT_PlusCMGF((T_ACI_CMD_SRC)srcId, &mode); | |
3926 if (mode EQ 0) | |
3927 /* | |
3928 * handle PDU mode | |
3929 */ | |
3930 io_sendMessage(srcId, "+CMGL: (0,1,2,3,4), (0,1,2)", ATI_NORMAL_OUTPUT); | |
3931 else | |
3932 /* | |
3933 * handle Text mode | |
3934 */ | |
3935 #endif | |
3936 io_sendMessage(srcId, "+CMGL: (\"REC UNREAD\",\"REC READ\",\"STO UNSENT\",\"STO SENT\",\"ALL\"), \ | |
3937 (\"READ NORMAL\",\"READ PREVIEW\",\"STATUS CHANGE\")", ATI_NORMAL_OUTPUT); | |
3938 | |
3939 return (ATI_CMPL); | |
3940 } | |
3941 | |
3942 #endif /* ATI_SMS_C */ |