FreeCalypso > hg > fc-magnetite

comparison src/aci2/aci/aci_bat_phb.c @ 3:93999a60b835

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/aci2, src/condat2: import of g23m/condat source pieces from TCS211
author Mychaela Falconia <falcon@freecalypso.org>
date Mon, 26 Sep 2016 00:29:36 +0000
parents
children
comparison
equal deleted inserted replaced
2:c41a534f33c6 3:93999a60b835
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-F&D (8411)
4 | Modul : ACI_BAT
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This BAT wrapper modul is ...
18 |
19 +-----------------------------------------------------------------------------
20 */
21
22 #include "aci_all.h" /* includes prim.h, which includes p_bat.h */
23 #include "aci_cmh.h" /* prototypes of sAT_,qAT_,tAT_ */
24 #include "aci_bat_cmh.h" /* prototypes of sBAT_,qBAT_,tBAT_ */
25 #include "aci_bat.h"
26 #include "ati_cmd.h"
27 #include "aci_cmd.h"
28 #include "aci_mem.h" /* MAKROS ACI_MALLOC, ACI_MFREE*/
29
30
31 /*
32 +--------------------------------------------------------------------+
33 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
34 | STATE : code ROUTINE : sBAT_PercentPBCF |
35 +--------------------------------------------------------------------+
36
37 PURPOSE : Select Phonebook Configuration.
38 */
39
40 GLOBAL T_ACI_BAT_RSLT sBAT_PercentPBCF (T_ACI_DTI_PRC_PSI *src_infos_psi,
41 T_BAT_cmd_send *cmd)
42 {
43 T_ACI_BAT_RSLT ret;
44 T_ACI_PBCF_LDN ldn = PBCF_LDN_NotPresent;
45 T_ACI_PBCF_LRN lrn = PBCF_LRN_NotPresent;
46 T_ACI_PBCF_LMN lmn = PBCF_LMN_NotPresent;
47
48 TRACE_FUNCTION ("sBAT_PercentPBCF()");
49
50 ldn = (T_ACI_PBCF_LDN)cmd->params.ptr_set_percent_pbcf->ldn;
51 lrn = (T_ACI_PBCF_LRN)cmd->params.ptr_set_percent_pbcf->lrn;
52 lmn = (T_ACI_PBCF_LMN)cmd->params.ptr_set_percent_pbcf->lmn;
53
54 /*
55 * Call the corresponding sAT function. T_ACI_BAT_RSLT is
56 * assumed to be equivalent to T_ACI_RESULT.
57 */
58 /* for BAT we use the old spec, which means the third param is not supported */
59 ret = (T_ACI_BAT_RSLT)sAT_PercentPBCF(src_infos_psi->srcId, ldn, lrn, lmn);
60
61 return(ret);
62 }
63
64 /*
65 +--------------------------------------------------------------------+
66 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
67 | STATE : code ROUTINE : qBAT_PlusCPBS |
68 +--------------------------------------------------------------------+
69
70 PURPOSE :
71 */
72 GLOBAL T_ACI_BAT_RSLT qBAT_PercentPBCF (T_ACI_DTI_PRC_PSI *src_infos_psi,
73 T_BAT_cmd_send *cmd)
74 {
75 T_ACI_BAT_RSLT ret;
76 T_ACI_PBCF_LDN ldn = PBCF_LDN_NotPresent;
77 T_ACI_PBCF_LRN lrn = PBCF_LRN_NotPresent;
78 T_ACI_PBCF_LMN lmn = PBCF_LMN_NotPresent;
79
80 TRACE_FUNCTION ("qBAT_PercentPBCF()");
81
82 /*
83 * Call the corresponding qAT function. T_ACI_BAT_RSLT is
84 * assumed to be equivalent to T_ACI_RESULT.
85 */
86 ret=(T_ACI_BAT_RSLT)qAT_PercentPBCF(src_infos_psi->srcId, &ldn, &lrn, &lmn);
87
88 /*
89 * If the query completes, send the response now.
90 */
91 if (ret==ACI_BAT_CMPL)
92 {
93 T_BAT_cmd_response resp;
94 T_BAT_res_que_percent_pbcf pbcf_data;
95
96 resp.ctrl_response=BAT_RES_QUE_PERCENT_PBCF;
97 resp.response.ptr_que_percent_pbcf = &pbcf_data;
98
99 /*
100 * This relies on T_BAT_percent_pbcf_ldn being identical to
101 * T_ACI_PBCF_LDN and so forth for LRN and LMN.
102 */
103 pbcf_data.ldn=(T_BAT_percent_pbcf_ldn)ldn;
104 pbcf_data.lrn=(T_BAT_percent_pbcf_ldn)lrn;
105 pbcf_data.lmn=(T_BAT_percent_pbcf_ldn)lmn;
106
107 aci_bat_send(src_infos_psi,&resp);
108 }
109
110 return(ret);
111 }
112
113 /*
114 +--------------------------------------------------------------------+
115 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
116 | STATE : code ROUTINE : sBAT_PlusCPBS |
117 +--------------------------------------------------------------------+
118
119 PURPOSE : Select phonebook memory storage.
120 */
121 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCPBS (T_ACI_DTI_PRC_PSI *src_infos_psi,
122 T_BAT_cmd_send *cmd)
123 {
124 T_ACI_BAT_RSLT ret;
125 T_ACI_PB_STOR stor;
126
127 TRACE_FUNCTION ("sBAT_PlusCPBS()");
128
129 /*
130 * This relies on T_BAT_storage being identical to
131 * T_ACI_PB_STOR.
132 */
133 stor=(T_ACI_PB_STOR)cmd->params.ptr_set_plus_cpbs->storage;
134
135 /*
136 * Call the corresponding sAT function. T_ACI_BAT_RSLT is
137 * assumed to be equivalent to T_ACI_RESULT.
138 */
139 /* for BAT we use the old spec, which means the third param is not supported */
140 ret=(T_ACI_BAT_RSLT)sAT_PlusCPBS(src_infos_psi->srcId,stor, NULL);
141
142 return(ret);
143 }
144
145 /*
146 +--------------------------------------------------------------------+
147 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
148 | STATE : code ROUTINE : qBAT_PlusCPBS |
149 +--------------------------------------------------------------------+
150
151 PURPOSE :
152 */
153 GLOBAL T_ACI_BAT_RSLT qBAT_PlusCPBS (T_ACI_DTI_PRC_PSI *src_infos_psi,
154 T_BAT_cmd_send *cmd)
155 {
156 T_ACI_BAT_RSLT ret;
157 T_ACI_PB_STOR stor;
158 SHORT used;
159 SHORT total;
160
161 TRACE_FUNCTION ("qBAT_PlusCPBS()");
162
163 /*
164 * Call the corresponding qAT function. T_ACI_BAT_RSLT is
165 * assumed to be equivalent to T_ACI_RESULT.
166 */
167 ret=(T_ACI_BAT_RSLT)qAT_PlusCPBS(src_infos_psi->srcId,&stor,&used,&total);
168
169 /*
170 * If the query completes, send the response now.
171 */
172 if (ret==ACI_BAT_CMPL)
173 {
174 T_BAT_cmd_response resp;
175 T_BAT_res_que_plus_cpbs cpbs_data;
176
177 resp.ctrl_response=BAT_RES_QUE_PLUS_CPBS;
178 resp.response.ptr_que_plus_cpbs=&cpbs_data;
179
180 /*
181 * This relies on T_BAT_storage being identical to
182 * T_ACI_PB_STOR.
183 */
184 cpbs_data.storage=(T_BAT_storage)stor;
185
186 cpbs_data.total=(S16)total;
187 cpbs_data.used=(S16)used;
188
189 aci_bat_send(src_infos_psi,&resp);
190 }
191
192 return(ret);
193 }
194
195 /*
196 +--------------------------------------------------------------------+
197 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
198 | STATE : code ROUTINE : qBAT_PercentCPBS |
199 +--------------------------------------------------------------------+
200
201 PURPOSE :
202 */
203 GLOBAL T_ACI_BAT_RSLT qBAT_PercentCPBS (T_ACI_DTI_PRC_PSI *src_infos_psi,
204 T_BAT_cmd_send *cmd)
205 {
206 T_ACI_BAT_RSLT ret;
207 T_ACI_PB_STOR stor;
208 SHORT used;
209 SHORT total;
210 SHORT first;
211
212 TRACE_FUNCTION ("qBAT_PercentCPBS()");
213
214 /*
215 * Call the corresponding qAT function. T_ACI_BAT_RSLT is
216 * assumed to be equivalent to T_ACI_RESULT.
217 */
218 ret=(T_ACI_BAT_RSLT)qAT_PercentCPBS(src_infos_psi->srcId,&stor,&used,&total,&first);
219
220 /*
221 * If the query completes, send the response now.
222 */
223 if (ret EQ ACI_BAT_CMPL)
224 {
225 T_BAT_cmd_response resp;
226 T_BAT_res_que_percent_cpbs cpbs_data;
227
228 resp.ctrl_response=BAT_RES_QUE_PERCENT_CPBS;
229 resp.response.ptr_que_percent_cpbs=&cpbs_data;
230
231 /*
232 * This relies on T_BAT_storage being identical to
233 * T_ACI_PB_STOR.
234 */
235 cpbs_data.storage=(T_BAT_storage)stor;
236
237 cpbs_data.total=(S16)total;
238 cpbs_data.used=(S16)used;
239 cpbs_data.first=(S16)first;
240
241 aci_bat_send(src_infos_psi,&resp);
242 }
243
244 return(ret);
245 }
246
247 /*
248 +--------------------------------------------------------------------+
249 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
250 | STATE : code ROUTINE : sBAT_PlusCPBW |
251 +--------------------------------------------------------------------+
252
253 PURPOSE :
254 */
255 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCPBW (T_ACI_DTI_PRC_PSI *src_infos_psi,
256 T_BAT_cmd_send *cmd)
257 {
258 T_ACI_BAT_RSLT ret;
259 SHORT index;
260 CHAR number[BAT_MAX_CPBW_NUMBER_LEN+1];
261 CHAR *p_number;
262 T_ACI_TOA toa;
263 T_ACI_TOA *p_toa;
264 T_ACI_PB_TEXT text;
265 T_ACI_PB_TEXT *p_text;
266 T_ACI_VP_ABS dmy_date_time;
267 T_BAT_cmd_set_plus_cpbw *cpbw;
268
269 TRACE_FUNCTION ("sBAT_PlusCPBW()");
270
271 /*
272 * Get a pointer to the CPBW structure for convenience.
273 */
274 cpbw=cmd->params.ptr_set_plus_cpbw;
275
276 index=(SHORT)cpbw->index;
277
278 if (cpbw->v_number==TRUE)
279 {
280 /*
281 * The idea here is to get the 'number' parameter into a
282 * null terminated string, which is what sAT_PlusCPBW() expects, but
283 * is not guaranteed by BAT.
284 */
285 memset(number,0,sizeof(number));
286 memcpy(number,cpbw->number,cpbw->c_number);
287 p_number=number;
288
289 /*
290 * BAT stores the type of address in a single value.
291 */
292 if (cpbw->type!=-1)
293 {
294 toa=toa_demerge(cpbw->type);
295 p_toa=&toa;
296 }
297 else
298 {
299 p_toa=NULL;
300 }
301 }
302 else
303 {
304 p_number=NULL;
305 p_toa=NULL;
306 }
307
308 /*
309 * Associated text
310 */
311 if (cpbw->v_text==TRUE)
312 {
313 USHORT len;
314
315 /*
316 * Convert from the currently selected character set into the
317 * SIM format.
318 */
319 utl_chsetToSim(
320 (UBYTE *)cpbw->text,
321 (USHORT)cpbw->c_text,
322 (UBYTE *)text.data,
323 &len,
324 GSM_ALPHA_Def);
325
326 /*
327 * Set the length. Note that we cannot do this by passing a
328 * reference to text.len into utl_chsetToSim() because it is
329 * the wrong type.
330 */
331 text.len=(UBYTE)len;
332
333 text.cs=CS_Sim;
334
335 p_text=&text;
336 }
337 else
338 {
339 p_text=NULL;
340 }
341
342 /*
343 * Call the corresponding sAT function. T_ACI_BAT_RSLT is
344 * assumed to be equivalent to T_ACI_RESULT.
345 */
346 ret=sAT_PlusCPBW(
347 src_infos_psi->srcId,
348 index,
349 p_number,
350 p_toa,
351 p_text,
352 &dmy_date_time);
353
354 return(ret);
355 }
356
357 /*
358 +--------------------------------------------------------------------+
359 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
360 | STATE : code ROUTINE : tBAT_PlusCPBW |
361 +--------------------------------------------------------------------+
362
363 PURPOSE :
364 */
365 GLOBAL T_ACI_BAT_RSLT tBAT_PlusCPBW (T_ACI_DTI_PRC_PSI *src_infos_psi,
366 T_BAT_cmd_send *cmd)
367 {
368 T_ACI_BAT_RSLT ret;
369 SHORT first;
370 SHORT last;
371 UBYTE nlength;
372 UBYTE tlength;
373
374 TRACE_FUNCTION ("tBAT_PlusCPBW()");
375
376 /*
377 * Call the corresponding tAT function. T_ACI_BAT_RSLT is
378 * assumed to be equivalent to T_ACI_RESULT.
379 */
380 ret=(T_ACI_BAT_RSLT)tAT_PlusCPBW(src_infos_psi->srcId,&first,&last,&nlength,&tlength);
381
382 /*
383 * If the command completes, send the response now.
384 */
385 if (ret==ACI_BAT_CMPL)
386 {
387 T_BAT_cmd_response resp;
388 T_BAT_res_tst_plus_cpbw cpbw_data;
389
390 resp.ctrl_response=BAT_RES_TST_PLUS_CPBW;
391 resp.response.ptr_tst_plus_cpbw=&cpbw_data;
392
393 cpbw_data.index1=(U8)first;
394 cpbw_data.index2=(U8)last;
395 cpbw_data.nlength=(S16)nlength;
396 cpbw_data.tlength=(S16)tlength;
397
398 #pragma message(__TODO__"+CPBW types")
399 cpbw_data.c_types=0;
400 cpbw_data.types[0]=0;
401
402 aci_bat_send(src_infos_psi,&resp);
403 }
404
405 return(ret);
406 }
407
408 /*
409 +--------------------------------------------------------------------+
410 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
411 | STATE : code ROUTINE : sBAT_PlusCPBR |
412 +--------------------------------------------------------------------+
413
414 PURPOSE : Read phonebook entries. If the application wants to read
415 more than ACI_BAT_MAX_RESPONSES, then the responses are
416 sent block by block (one block = ACI_BAT_MAX_RESPONSES).
417 */
418 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCPBR_CB (T_ACI_DTI_PRC_PSI *src_infos_psi)
419 {
420 T_BAT_cmd_send cmd;
421 T_BAT_cmd_set_plus_cpbr cpbr;
422
423 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPBR;
424 cmd.params.ptr_set_plus_cpbr = &cpbr;
425
426 cpbr.index1 = (U8)src_infos_psi->index1;
427 cpbr.index2 = (S16)src_infos_psi->index2;
428
429 return (sBAT_PlusCPBR(src_infos_psi, &cmd));
430 }
431
432
433 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCPBR (T_ACI_DTI_PRC_PSI *src_infos_psi,
434 T_BAT_cmd_send *cmd)
435 {
436 T_ACI_BAT_RSLT ret;
437 SHORT start_idx;
438 SHORT stop_idx;
439 SHORT last_idx = ACI_NumParmNotPresent;
440 T_ACI_PB_ENTR pb_lst[MAX_PB_ENTR];
441
442 TRACE_FUNCTION ("sBAT_PlusCPBR()");
443
444 /* define here the variables, which are passed as parameters to sAT_PlusCPBR */
445 start_idx = (SHORT)cmd->params.ptr_set_plus_cpbr->index1;
446 stop_idx = (SHORT)cmd->params.ptr_set_plus_cpbr->index2;
447
448 ret = (T_ACI_BAT_RSLT)sAT_PlusCPBR(src_infos_psi->srcId, start_idx, stop_idx, &last_idx, &pb_lst[0]);
449 if (ret EQ ACI_BAT_CMPL)
450 {
451 SHORT i;
452 T_BAT_cmd_response resp;
453 T_BAT_res_set_plus_cpbr cpbr_data;
454
455 resp.ctrl_response = BAT_RES_SET_PLUS_CPBR;
456 resp.response.ptr_set_plus_cpbr = &cpbr_data;
457
458 /*
459 * sAT_PlusCPBR() provides in pb_lst[] up to five entries (MAX_PB_ENTR)
460 */
461 for (i = 0; ((i < MAX_PB_ENTR) AND (pb_lst[i].index NEQ ACI_NumParmNotPresent)); i++)
462 {
463 USHORT len_cvtd_text=0;
464
465 cpbr_data.index = (U8)pb_lst[i].index;
466
467 cpbr_data.c_number = strlen((CHAR*)pb_lst[i].number);
468
469 cpbr_data.c_number = (cpbr_data.c_number > BAT_MAX_CPBR_NUMBER_LEN)
470 ? BAT_MAX_CPBR_NUMBER_LEN
471 : cpbr_data.c_number;
472
473 strncpy((CHAR*)cpbr_data.number, pb_lst[i].number, cpbr_data.c_number+1); /* Include null terminator for Resp_.. () */
474
475 /* BAT stores the type of address in a single 8-bit value. */
476 cpbr_data.type = toa_merge(pb_lst[i].type);
477
478 /*
479 * Convert the data read from the SIM into the currently
480 * selected character set.
481 */
482 utl_chsetFromSim(
483 (UBYTE *)pb_lst[i].text.data,
484 pb_lst[i].text.len,
485 (UBYTE *)cpbr_data.text,
486 BAT_MAX_CPBR_TEXT_LEN,
487 &len_cvtd_text,
488 GSM_ALPHA_Def);
489
490 cpbr_data.c_text=(U8)len_cvtd_text;
491
492 TRACE_EVENT_P2("sBAT_PlusCPBR(): index = %i c_text = %d", cpbr_data.index, cpbr_data.c_text);
493
494 /* vsi_t_sleep (aci_handle, 500); */
495 aci_bat_send(src_infos_psi,&resp);
496 }
497 /* remember updated start index and initial stop index for possible next block of entries to send to APP */
498 src_infos_psi->index1 = last_idx + 1;
499 src_infos_psi->index2 = stop_idx;
500 }
501 else
502 {
503 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_Unknown);
504 return(ACI_BAT_FAIL);
505 }
506
507 if (last_idx < stop_idx)
508 {
509 src_infos_psi->large_type = TRUE;
510 return (ACI_BAT_EXCT);
511 }
512
513 src_infos_psi->large_type = FALSE;
514 return (ACI_BAT_CMPL);
515 }
516
517 /*
518 +--------------------------------------------------------------------+
519 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
520 | STATE : code ROUTINE : tBAT_PlusCPBR |
521 +--------------------------------------------------------------------+
522
523 PURPOSE :
524 */
525
526 GLOBAL T_ACI_BAT_RSLT tBAT_PlusCPBR (T_ACI_DTI_PRC_PSI *src_infos_psi,
527 T_BAT_cmd_send *cmd)
528 {
529 T_ACI_BAT_RSLT ret=ACI_BAT_FAIL;
530 SHORT first;
531 SHORT last;
532 UBYTE nlength;
533 UBYTE tlength;
534
535 TRACE_FUNCTION ("tBAT_PlusCPBR()");
536
537 /*
538 * Call the corresponding tAT function. T_ACI_BAT_RSLT is
539 * assumed to be equivalent to T_ACI_RESULT.
540 */
541 ret=(T_ACI_BAT_RSLT)tAT_PlusCPBR(src_infos_psi->srcId,&first,&last,&nlength,&tlength);
542
543 /*
544 * If the command completes, send the response now.
545 */
546 if (ret==ACI_BAT_CMPL)
547 {
548 T_BAT_cmd_response resp;
549 T_BAT_res_tst_plus_cpbr cpbr_data;
550
551 resp.ctrl_response=BAT_RES_TST_PLUS_CPBR;
552 resp.response.ptr_tst_plus_cpbr=&cpbr_data;
553
554 cpbr_data.index_f=(U8)first;
555 cpbr_data.index_l=(U8)last;
556 cpbr_data.nlength=(S16)nlength;
557 cpbr_data.tlength=(S16)tlength;
558
559 aci_bat_send(src_infos_psi,&resp);
560 }
561
562 return(ret);
563 }
564
565 /*
566 +--------------------------------------------------------------------+
567 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
568 | STATE : code ROUTINE : sBAT_PlusCPBF |
569 +--------------------------------------------------------------------+
570
571 PURPOSE :
572 */
573 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCPBF_CB (T_ACI_DTI_PRC_PSI *src_infos_psi)
574 {
575 T_BAT_cmd_send cmd;
576 T_BAT_cmd_set_plus_cpbf cpbf;
577
578 cmd.ctrl_params = BAT_CMD_SET_PLUS_CPBF;
579 cmd.params.ptr_set_plus_cpbf = &cpbf;
580
581 TRACE_FUNCTION ("sBAT_PlusCPBF_CB()");
582
583 /* restore search string if ongoing command */
584 if ( src_infos_psi->search_str_ptr NEQ NULL )
585 {
586 TRACE_EVENT("Restore search string");
587 /* index 1 stores the length of the string in the case of cpbf */
588 cpbf.c_findtext = (U8)src_infos_psi->index1;
589 memcpy(cpbf.findtext, src_infos_psi->search_str_ptr, BAT_MAX_CPBF_FIND_TEXT_LEN);
590 }
591 return (sBAT_PlusCPBF(src_infos_psi, &cmd));
592 }
593
594 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCPBF (T_ACI_DTI_PRC_PSI *src_infos_psi,
595 T_BAT_cmd_send *cmd)
596 {
597 T_ACI_PB_TEXT pbtext;
598 USHORT len;
599 T_ACI_BAT_RSLT ret;
600 T_BAT_cmd_set_plus_cpbf *cpbf_cmd;
601 SHORT found = -1;
602 T_ACI_PB_ENTR pb[MAX_PB_ENTR];
603 SHORT i;
604 T_ACI_CPBF_MOD search_mode; // replaced by global var
605 T_BAT_cmd_response resp;
606 T_BAT_res_set_plus_cpbf cpbf_rsp;
607
608 TRACE_FUNCTION ("sBAT_PlusCPBF()");
609
610 resp.ctrl_response = BAT_RES_SET_PLUS_CPBF;
611 resp.response.ptr_set_plus_cpbf = &cpbf_rsp;
612
613 /*
614 * Get a pointer to the CPBF data for convenience.
615 */
616 cpbf_cmd = cmd->params.ptr_set_plus_cpbf;
617
618 /*
619 * We may have to call sAT_PlusCPBF() more than once, if there are
620 * more than MAX_PB_ENTR entries found. The search mode is used
621 * to tell the ACI whether this is a new search or a continuation of
622 * the old one.
623 * If there has been a valid string pointer saved to the search_str_ptr
624 * the seek has to be continued.
625 */
626
627 if ((src_infos_psi->search_str_ptr NEQ NULL)
628 AND (strncmp(src_infos_psi->search_str_ptr, cpbf_cmd->findtext, cpbf_cmd->c_findtext) EQ 0))
629 {
630 found = src_infos_psi->index2; /* recover number found*/
631 search_mode = CPBF_MOD_NextSearch;
632 TRACE_EVENT_P1("Stored Search string: %s", src_infos_psi->search_str_ptr);
633 TRACE_EVENT_P1("Stored String length: %d", src_infos_psi->index1);
634 }
635 else
636 {
637 search_mode = CPBF_MOD_NewSearch;
638 }
639
640 /*
641 * If the search string has zero length or is larger than the ACI function
642 * can handle then there's no point continuing.
643 * In fact there should be a differentiation between UCS2 and 8bit based coding schemes.
644 * Additionally it has to be considered that the string given within the BAT command is ACSII encoded.
645 */
646 if (((ati_user_output_cfg[src_infos_psi->srcId].cscsChset EQ CSCS_CHSET_Ucs2)
647 && ((cpbf_cmd->c_findtext>BAT_MAX_CPBF_FIND_TEXT_LEN)||(cpbf_cmd->c_findtext<1)) )
648 ||
649 ((ati_user_output_cfg[src_infos_psi->srcId].cscsChset NEQ CSCS_CHSET_Ucs2)
650 && ((cpbf_cmd->c_findtext>MAX_PHB_NUM_LEN)||(cpbf_cmd->c_findtext<1)) ) )
651 {
652 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_Unknown);
653 return(ACI_BAT_FAIL);
654 }
655
656 TRACE_EVENT_P1("Search string: %s", cpbf_cmd->findtext);
657 TRACE_EVENT_P1("String length: %d", cpbf_cmd->c_findtext);
658
659 utl_chsetToSim(
660 (UBYTE *)cpbf_cmd->findtext,
661 (USHORT)cpbf_cmd->c_findtext,
662 (UBYTE *)pbtext.data,
663 &len,
664 GSM_ALPHA_Def);
665
666 if (len > MAX_PHB_NUM_LEN)
667 {
668 /*
669 * Shouldn't get here as that would mean that memory has been
670 * overwritten. Currently utl_chsetToSim() has no specific mechanism
671 * to prevent this.
672 */
673 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_TxtToLong);
674 return(ACI_BAT_FAIL);
675 }
676
677 pbtext.len = (UBYTE)len;
678 pbtext.cs = (T_ACI_CS)CS_Sim;
679
680
681 /*
682 * Call the corresponding sAT function. T_ACI_BAT_RSLT is
683 * assumed to be equivalent to T_ACI_RESULT.
684 */
685
686 TRACE_EVENT_P1("search_mode: %d", search_mode);
687 TRACE_EVENT_P1("pbtext.data: %s", pbtext.data);
688 TRACE_EVENT_P1("pbtext.len: %d", pbtext.len);
689
690
691 /* found is not overwritten in the case of NEXT_SEARCH */
692 ret=(T_ACI_BAT_RSLT)sAT_PlusCPBF(
693 src_infos_psi->srcId,
694 &pbtext,
695 search_mode,
696 &found,
697 pb);
698
699 TRACE_EVENT_P1("sAT_PlusCPBF returns: %d", ret);
700 TRACE_EVENT_P1("-- found entries: %d", found);
701
702 /*
703 * If the command fails, get out now.
704 */
705 if (ret!=ACI_BAT_CMPL)
706 return(ret);
707
708 /*
709 * We have received a list, however the BAT response only
710 * allows for single items. So we must send each one
711 * individually.
712 */
713 for (i=0;((i<found) && (i<MAX_PB_ENTR));i++)
714 {
715 USHORT len_cvtd_text=0;
716
717 cpbf_rsp.index=(U8)pb[i].index;
718
719 TRACE_EVENT("send the found entry");
720 strncpy((CHAR*)cpbf_rsp.number,pb[i].number,BAT_MAX_CPBF_NUMBER_LEN);
721 cpbf_rsp.c_number=strlen((CHAR*)cpbf_rsp.number);
722
723 /*
724 * BAT stores the type of address in a single 8-bit value.
725 */
726 cpbf_rsp.type=toa_merge(pb[i].type);
727
728 /*
729 * Convert the data read from the SIM into the currently
730 * selected character set.
731 */
732 utl_chsetFromSim(
733 (UBYTE *)pb[i].text.data,
734 pb[i].text.len,
735 (UBYTE *)cpbf_rsp.text,
736 BAT_MAX_CPBF_TEXT_LEN,
737 &len_cvtd_text,
738 GSM_ALPHA_Def);
739
740 cpbf_rsp.c_text=(U8)len_cvtd_text;
741
742 /* vsi_t_sleep (aci_handle, 500); */
743
744 aci_bat_send(src_infos_psi,&resp);
745 }
746
747 /*
748 * Set the search mode for the next iteration, should there be
749 * one.
750 */
751
752 if (found>MAX_PB_ENTR)
753 {
754 TRACE_EVENT("More entries found");
755 /* remember the string to search for (only necessary for first iteration)*/
756 if (search_mode EQ CPBF_MOD_NewSearch)
757 {
758 TRACE_EVENT("Store string");
759 src_infos_psi->index1 = (U16)cpbf_cmd->c_findtext; /* str length */
760 ACI_MALLOC(src_infos_psi->search_str_ptr, BAT_MAX_CPBF_FIND_TEXT_LEN);
761 memcpy(src_infos_psi->search_str_ptr, cpbf_cmd->findtext, BAT_MAX_CPBF_FIND_TEXT_LEN);
762 }
763 /* This is a multi-line response */
764 src_infos_psi->large_type = TRUE;
765 /* Save the number of found items - MAX_PB_ENTR send to user */
766 src_infos_psi->index2 = found - MAX_PB_ENTR;
767 /* Still executing */
768 ret = ACI_BAT_EXCT;
769 }
770 else /* no further entries to find */
771 {
772 TRACE_EVENT("reset search string");
773 /* reset search string info for iterations */
774 src_infos_psi->index1 = 0; /* str length reset */
775 src_infos_psi->index2 = 0; /* number found reset */
776 if (src_infos_psi->search_str_ptr NEQ NULL) /* str mem reset, if necessary */
777 {
778 ACI_MFREE(src_infos_psi->search_str_ptr);
779 src_infos_psi->search_str_ptr = NULL;
780 }
781 /* This is NO multiline response */
782 src_infos_psi->large_type = FALSE;
783 /* completed */
784 ret = ACI_BAT_CMPL;
785 }
786
787 return (ret);
788
789 }
790
791 /*
792 +--------------------------------------------------------------------+
793 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
794 | STATE : code ROUTINE : tBAT_PlusCPBF |
795 +--------------------------------------------------------------------+
796
797 PURPOSE :
798 */
799 GLOBAL T_ACI_BAT_RSLT tBAT_PlusCPBF (T_ACI_DTI_PRC_PSI *src_infos_psi,
800 T_BAT_cmd_send *cmd)
801 {
802 T_ACI_BAT_RSLT ret;
803 UBYTE nlength;
804 UBYTE tlength;
805
806 TRACE_FUNCTION ("tBAT_PlusCPBF()");
807
808 /*
809 * Call the corresponding ACI function. T_ACI_BAT_RSLT is
810 * assumed to be equivalent to T_ACI_RESULT.
811 */
812 ret=(T_ACI_BAT_RSLT)tAT_PlusCPBF(src_infos_psi->srcId,&nlength,&tlength);
813
814 /*
815 * If the command completes, send the response now.
816 */
817 if (ret==ACI_BAT_CMPL)
818 {
819 T_BAT_cmd_response resp;
820 T_BAT_res_tst_plus_cpbf cpbf_data;
821
822 resp.ctrl_response=BAT_RES_TST_PLUS_CPBF;
823 resp.response.ptr_tst_plus_cpbf=&cpbf_data;
824
825 cpbf_data.nlength=(S16)nlength;
826 cpbf_data.tlength=(S16)tlength;
827
828 aci_bat_send(src_infos_psi,&resp);
829 }
830
831 return(ret);
832 }
833
834 /*
835 +--------------------------------------------------------------------+
836 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
837 | STATE : code ROUTINE : sBAT_PlusCSVM |
838 +--------------------------------------------------------------------+
839
840 PURPOSE :
841 */
842 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCSVM (T_ACI_DTI_PRC_PSI *src_infos_psi,
843 T_BAT_cmd_send *cmd)
844 {
845 T_ACI_BAT_RSLT ret;
846 T_ACI_TOA toa;
847 CHAR number[BAT_MAX_CSVM_NUMBER_LEN+1];
848 CHAR *pnumber;
849 T_ACI_CSVM_MOD mode;
850 T_BAT_cmd_set_plus_csvm *csvm;
851 UBYTE num_len;
852
853 TRACE_FUNCTION ("sBAT_PlusCSVM()");
854
855 /*
856 * Get a pointer to the BAT structure for convenience.
857 */
858 csvm=cmd->params.ptr_set_plus_csvm;
859
860 /*
861 * This assumes that T_ACI_CSVM_MOD and T_BAT_plus_csvm_mode are
862 * equivalent. They are, except that the ACI version has a
863 * NotPresent value - this is not a problem here as we are converting
864 * from BAT format to ACI format.
865 */
866 mode=(T_ACI_CSVM_MOD)csvm->mode;
867
868 if (csvm->v_number==TRUE)
869 {
870 /*
871 * I don't think that CSVM requires a null-terminated string, but
872 * it's best to err on the side of caution.
873 */
874 pnumber=number;
875 memset(number,0,sizeof(number));
876 memcpy(number,csvm->number,BAT_MAX_CSVM_NUMBER_LEN);
877
878 if (csvm->c_number>BAT_MAX_CSVM_NUMBER_LEN)
879 num_len=(UBYTE)BAT_MAX_CSVM_NUMBER_LEN;
880 else
881 num_len=(UBYTE)csvm->c_number;
882 }
883 else
884 {
885 pnumber=NULL;
886 num_len=0;
887 }
888
889 /*
890 * BAT stores the type of address in a single 8-bit value. We need to
891 * convert this to the ACI format.
892 */
893 toa=toa_demerge(csvm->type);
894
895 /*
896 * Call the corresponding ACI function. T_ACI_BAT_RSLT is
897 * assumed to be equivalent to T_ACI_RESULT.
898 */
899 ret=(T_ACI_BAT_RSLT)sAT_PlusCSVM(src_infos_psi->srcId,mode,pnumber,num_len,&toa);
900
901 return(ret);
902 }
903
904 /*
905 +--------------------------------------------------------------------+
906 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
907 | STATE : code ROUTINE : qBAT_PlusCSVM |
908 +--------------------------------------------------------------------+
909
910 PURPOSE :
911 */
912 GLOBAL T_ACI_BAT_RSLT qBAT_PlusCSVM (T_ACI_DTI_PRC_PSI *src_infos_psi,
913 T_BAT_cmd_send *cmd)
914 {
915 T_ACI_BAT_RSLT ret = ACI_BAT_FAIL;
916 T_ACI_CSVM_MOD mode;
917 CHAR number[BAT_MAX_CSVM_NUMBER_LEN+1];
918 SHORT toa_val;
919
920 TRACE_FUNCTION ("qBAT_PlusCSVM()");
921
922 /*
923 * Call the corresponding qAT function. T_ACI_BAT_RSLT is
924 * assumed to be equivalent to T_ACI_RESULT.
925 */
926 ret=(T_ACI_BAT_RSLT)qAT_PlusCSVM(
927 src_infos_psi->srcId,
928 &mode,
929 number,
930 BAT_MAX_CSVM_NUMBER_LEN,
931 &toa_val);
932
933 /*
934 * If the query completes, send the response now.
935 */
936 if (ret==ACI_BAT_CMPL)
937 {
938 T_BAT_cmd_response resp;
939 T_BAT_res_que_plus_csvm csvm_data;
940
941 resp.ctrl_response=BAT_RES_QUE_PLUS_CSVM;
942 resp.response.ptr_que_plus_csvm=&csvm_data;
943
944 /*
945 * We can't just cast the ACI value to the BAT value as it
946 * might be CSVM_MOD_NotPresent, for which the BAT has no
947 * equivalent.
948 */
949 csvm_data.mode=(mode==CSVM_MOD_Enable) ? BAT_CSVM_MODE_ENABLE:BAT_CSVM_MODE_DISABLE;
950
951 /*
952 * We trust the ACI to give us a null-terminated string.
953 */
954 strcpy((CHAR*)csvm_data.number,number);
955 csvm_data.c_number=strlen((CHAR*)csvm_data.number);
956
957 /*
958 * Note that in this instance the ACI is giving us the TOA as
959 * a single number, rather than in its usual T_ACI_TOA format.
960 */
961 csvm_data.type=(U8)toa_val;
962
963 aci_bat_send(src_infos_psi,&resp);
964 }
965
966 return(ret);
967 }
968
969 /*
970 +--------------------------------------------------------------------+
971 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
972 | STATE : code ROUTINE : sBAT_PlusCLAN |
973 +--------------------------------------------------------------------+
974
975 PURPOSE :
976 */
977 GLOBAL T_ACI_BAT_RSLT sBAT_PlusCLAN (T_ACI_DTI_PRC_PSI *src_infos_psi,
978 T_BAT_cmd_send *cmd)
979 {
980 T_ACI_BAT_RSLT ret;
981 T_ACI_LAN_SUP lng;
982 CHAR str[BAT_MAX_CLAN_CODE_LEN+1];
983 USHORT i;
984
985 TRACE_FUNCTION ("sBAT_PlusCLAN()");
986
987 /*
988 * Ensure that we have a null-terminated string.
989 */
990 memset(str,0,sizeof(str));
991 memcpy(str,cmd->params.ptr_set_plus_clan->code,BAT_MAX_CLAN_CODE_LEN);
992
993 lng.str=NULL;
994
995 /*
996 * The BAT provides the language in string form only, we must also
997 * calculate the corresponding value. To do this we use the lookup
998 * table "lngs".
999 *
1000 * GSM 07.07 says that "AUTO" should be used for automatic mode, but
1001 * the (ATI) code uses "au". Here we want to accept both.
1002 */
1003 if (!strcmp(str,"AUTO"))
1004 {
1005 lng.lng=CLAN_LNG_AUT;
1006 lng.str="AUTO";
1007 }
1008 else
1009 {
1010 for (i=0;lngs[i].str;i++)
1011 {
1012 if (!strcmp(lngs[i].str,str))
1013 {
1014 lng.str=lngs[i].str;
1015 lng.lng=lngs[i].lng;
1016 break;
1017 }
1018 }
1019 }
1020
1021 if (lng.str==NULL)
1022 {
1023 /*
1024 * Can't work out the language so give up.
1025 */
1026 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_OpNotSupp);
1027 return(ACI_BAT_FAIL);
1028 }
1029
1030 /*
1031 * Call the corresponding ACI function. T_ACI_BAT_RSLT is
1032 * assumed to be equivalent to T_ACI_RESULT.
1033 */
1034 ret=(T_ACI_BAT_RSLT)sAT_PlusCLAN(src_infos_psi->srcId,&lng);
1035
1036 return(ret);
1037 }
1038
1039 /*
1040 +--------------------------------------------------------------------+
1041 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
1042 | STATE : code ROUTINE : qBAT_PlusCLAN |
1043 +--------------------------------------------------------------------+
1044
1045 PURPOSE :
1046 */
1047 GLOBAL T_ACI_BAT_RSLT qBAT_PlusCLAN (T_ACI_DTI_PRC_PSI *src_infos_psi,
1048 T_BAT_cmd_send *cmd)
1049 {
1050 T_ACI_BAT_RSLT ret;
1051 T_ACI_LAN_SUP lng;
1052 T_BAT_cmd_response resp;
1053 T_BAT_res_que_plus_clan clan_data;
1054
1055 TRACE_FUNCTION ("qBAT_PlusCLAN()");
1056
1057 resp.ctrl_response=BAT_RES_QUE_PLUS_CLAN;
1058 resp.response.ptr_que_plus_clan=&clan_data;
1059
1060 memset(&clan_data,0,sizeof(clan_data));
1061 lng.str=(CHAR *)clan_data.code;
1062
1063 /*
1064 * Call the corresponding ACI function. T_ACI_BAT_RSLT is
1065 * assumed to be equivalent to T_ACI_RESULT.
1066 * We are trusting this function not to deliver too long
1067 * a string. At the time of writing, it can only give us two
1068 * characters, which we easily have room for in the BAT
1069 * message.
1070 */
1071 ret=(T_ACI_BAT_RSLT)qAT_PlusCLAN(src_infos_psi->srcId,&lng);
1072
1073 /*
1074 * If the query completes, send the response now.
1075 */
1076 if (ret==ACI_BAT_CMPL)
1077 {
1078 clan_data.c_code=strlen(lng.str);
1079 aci_bat_send(src_infos_psi,&resp);
1080 }
1081
1082 return(ret);
1083 }
1084
1085 /*
1086 +--------------------------------------------------------------------+
1087 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT |
1088 | STATE : code ROUTINE : tBAT_PlusCLAN |
1089 +--------------------------------------------------------------------+
1090
1091 PURPOSE :
1092 */
1093 GLOBAL T_ACI_BAT_RSLT tBAT_PlusCLAN (T_ACI_DTI_PRC_PSI *src_infos_psi,
1094 T_BAT_cmd_send *cmd)
1095 {
1096 T_ACI_BAT_RSLT ret;
1097 T_ACI_LAN_SUP lng[MAX_LAN];
1098 SHORT last_idx;
1099
1100 TRACE_FUNCTION ("tBAT_PlusCLAN()");
1101
1102 /*
1103 * Call the corresponding ACI function. T_ACI_BAT_RSLT is
1104 * assumed to be equivalent to T_ACI_RESULT.
1105 */
1106 ret=(T_ACI_BAT_RSLT)tAT_PlusCLAN(src_infos_psi->srcId,&last_idx,lng);
1107
1108 /*
1109 * If the command completes, send the response now.
1110 */
1111 if (ret==ACI_BAT_CMPL)
1112 {
1113 USHORT i;
1114 T_BAT_cmd_response resp;
1115 T_BAT_res_tst_plus_clan clan_data;
1116
1117 resp.ctrl_response=BAT_RES_TST_PLUS_CLAN;
1118 resp.response.ptr_tst_plus_clan=&clan_data;
1119
1120 /*
1121 * We have received a list, however the BAT response only
1122 * allows for single items. So we must send each one
1123 * individually.
1124 */
1125 for (i=0;i<last_idx;i++)
1126 {
1127 clan_data.c_code=strlen(lng[i].str);
1128
1129 /*
1130 * Discard any languages for which the string is too long for
1131 * BAT (this should never happen).
1132 */
1133 if (clan_data.c_code<=BAT_MAX_CLAN_CODE_LEN)
1134 {
1135 memcpy(clan_data.code,lng[i].str,BAT_MAX_CLAN_CODE_LEN);
1136 aci_bat_send(src_infos_psi,&resp);
1137 }
1138 }
1139 }
1140
1141 return(ret);
1142 }
1143