FreeCalypso > hg > fc-magnetite
comparison src/aci2/aci/aci_bat_cphs.c @ 3:93999a60b835
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 (2016-09-26) |
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 "cphs.h" | |
27 #include "aci_cphs.h" | |
28 #include "aci_cmd.h" | |
29 | |
30 /* | |
31 * commonly used query for %CPCFU and %CPVWI | |
32 * %CPCFU: <status>[,<line>] | |
33 * %CPVWI: <status>[,<line>] | |
34 * | |
35 * status acts as a global status information for all lines. | |
36 * if any line is set then status is set/activated | |
37 * and in the line bit field you can check which one. | |
38 * the strange thing is that the numerical value for status | |
39 * is exactly complementary between %CPCFU and %CPVWI | |
40 * see also 8415_052.doc | |
41 */ | |
42 LOCAL T_ACI_BAT_RSLT query_cphs_lines (T_ACI_DTI_PRC_PSI *src_infos_psi, | |
43 T_BAT_cmd_send *cmd, | |
44 T_CPHS_LINES lines) | |
45 { | |
46 T_ACI_BAT_RSLT ret; | |
47 T_ACI_BAT_RSLT (*fptr)(T_ACI_CMD_SRC srcId, U8 *cfu_set, T_CPHS_LINES line); | |
48 T_CPHS_LINES line = CPHS_LINE_NULL; | |
49 T_CPHS_LINES line_bitmask = CPHS_LINE_NULL; | |
50 U16 i, end; | |
51 U8 flag_set; | |
52 | |
53 T_BAT_res_set_percent_cpvwi cpvwi; | |
54 T_BAT_res_set_percent_cpcfu cpcfu; | |
55 T_BAT_cmd_response resp; | |
56 | |
57 switch (cmd->ctrl_params) | |
58 { | |
59 case (BAT_CMD_SET_PERCENT_CPCFU): | |
60 { | |
61 fptr = qAT_PercentCPCFU; | |
62 break; | |
63 } | |
64 case (BAT_CMD_SET_PERCENT_CPVWI): | |
65 { | |
66 fptr = qAT_PercentCPVWI; | |
67 break; | |
68 } | |
69 default: | |
70 { | |
71 return (ACI_BAT_FAIL); | |
72 } | |
73 } | |
74 | |
75 end = 8 * sizeof(T_CPHS_LINES); | |
76 /* rotate over all bits */ | |
77 for (i=0; i<end; i++) | |
78 { | |
79 line = 1 << i; | |
80 if (lines & line) | |
81 { | |
82 ret = (T_ACI_BAT_RSLT)fptr(src_infos_psi->srcId, &flag_set, line); | |
83 | |
84 if(ret NEQ AT_CMPL) | |
85 { | |
86 return(ACI_BAT_FAIL); | |
87 } | |
88 | |
89 if(flag_set EQ CPHS_FLAG_ACTIVATED) | |
90 { | |
91 line_bitmask |= line; | |
92 } | |
93 } | |
94 else | |
95 { | |
96 continue; /* bit not set --> do not check this line */ | |
97 } | |
98 } | |
99 | |
100 switch (cmd->ctrl_params) | |
101 { | |
102 case (BAT_CMD_SET_PERCENT_CPCFU): | |
103 { | |
104 cpcfu.line = line_bitmask; | |
105 cpcfu.status = (line_bitmask EQ CPHS_LINE_NULL) | |
106 ? BAT_P_CPCFU_STATUS_DEACTIVATE | |
107 : BAT_P_CPCFU_STATUS_ACTIVATED; | |
108 resp.ctrl_response = BAT_RES_SET_PERCENT_CPCFU; | |
109 resp.response.ptr_set_percent_cpcfu = &cpcfu; | |
110 /* | |
111 * according to 8415_052.doc CPCFU status: 0 Activated, 1 Deactivated, | |
112 * which must be an error, because on ATI the status is given as 1, when any line has been set. | |
113 * But the nice thing with BAT is the using of symbolic constants, where the actual numeric | |
114 * value for BAT_P_CPCFU_STATUS_ACTIVATED is unimportant as long as the client code uses it. | |
115 * If they use numerical value instead of symbolic constant, then ... we cannot help ... | |
116 */ | |
117 TRACE_EVENT_P2("query_cphs_lines(): status = %i, line = 0x%02X",cpcfu.status, cpcfu.line); | |
118 break; | |
119 } | |
120 case (BAT_CMD_SET_PERCENT_CPVWI): | |
121 { | |
122 cpvwi.line = line_bitmask; | |
123 cpvwi.status = (line_bitmask EQ CPHS_LINE_NULL) | |
124 ? BAT_P_CPVWI_FLAG_DEACTIVATED | |
125 : BAT_P_CPVWI_FLAG_ACTIVATED; | |
126 resp.ctrl_response = BAT_RES_SET_PERCENT_CPVWI; | |
127 resp.response.ptr_set_percent_cpvwi = &cpvwi; | |
128 TRACE_EVENT_P2("query_cphs_lines(): status = %i, line = 0x%02X",cpvwi.status, cpvwi.line); | |
129 break; | |
130 } | |
131 default: | |
132 { | |
133 return (ACI_BAT_FAIL); | |
134 } | |
135 } | |
136 | |
137 aci_bat_send(src_infos_psi, &resp); | |
138 return (ACI_BAT_CMPL); | |
139 } | |
140 | |
141 /* | |
142 +--------------------------------------------------------------------+ | |
143 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
144 | STATE : code ROUTINE : sBAT_PercentCPHS | | |
145 +--------------------------------------------------------------------+ | |
146 | |
147 PURPOSE : | |
148 */ | |
149 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPHS(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
150 T_BAT_cmd_send *cmd) | |
151 { | |
152 T_ACI_BAT_RSLT ret; | |
153 | |
154 TRACE_FUNCTION ("sBAT_PercentCPHS()"); | |
155 ret = sAT_PercentCPHS(src_infos_psi->srcId, | |
156 cmd->params.ptr_set_percent_cphs->init_mode); | |
157 return(ret); | |
158 } | |
159 | |
160 /* | |
161 +--------------------------------------------------------------------+ | |
162 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
163 | STATE : code ROUTINE : qBAT_PercentCPHS | | |
164 +--------------------------------------------------------------------+ | |
165 | |
166 PURPOSE : | |
167 */ | |
168 GLOBAL T_ACI_BAT_RSLT qBAT_PercentCPHS(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
169 T_BAT_cmd_send *cmd) | |
170 { | |
171 T_ACI_BAT_RSLT ret; | |
172 T_BAT_cmd_response resp; | |
173 T_BAT_res_que_percent_cphs cphs; | |
174 | |
175 TRACE_FUNCTION ("qBAT_PercentCPHS()"); | |
176 | |
177 resp.ctrl_response = BAT_RES_QUE_PERCENT_CPHS; | |
178 resp.response.ptr_que_percent_cphs = &cphs; | |
179 | |
180 ret = qAT_PercentCPHS(src_infos_psi->srcId,(T_ACI_CPHS_INIT*)&cphs.init_mode); | |
181 | |
182 aci_bat_send(src_infos_psi, &resp); | |
183 return(ret); | |
184 } | |
185 | |
186 /* | |
187 +--------------------------------------------------------------------+ | |
188 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
189 | STATE : code ROUTINE : sBAT_PercentCPNUMS | | |
190 +--------------------------------------------------------------------+ | |
191 | |
192 PURPOSE : | |
193 */ | |
194 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPNUMS(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
195 T_BAT_cmd_send *cmd) | |
196 { | |
197 T_ACI_BAT_RSLT ret; | |
198 | |
199 TRACE_FUNCTION ("sBAT_PercentCPNUMS()"); | |
200 | |
201 ret = sAT_PercentCPNUMS(src_infos_psi->srcId, | |
202 cmd->params.ptr_set_percent_cpnums->element_id, | |
203 (U8)cmd->params.ptr_set_percent_cpnums->mode); | |
204 return(ret); | |
205 } | |
206 | |
207 /* | |
208 +--------------------------------------------------------------------+ | |
209 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
210 | STATE : code ROUTINE : tBAT_PercentCPNUMS | | |
211 +--------------------------------------------------------------------+ | |
212 | |
213 PURPOSE : | |
214 */ | |
215 GLOBAL T_ACI_BAT_RSLT tBAT_PercentCPNUMS(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
216 T_BAT_cmd_send *cmd) | |
217 { | |
218 return(ACI_BAT_FAIL); | |
219 } | |
220 | |
221 /* | |
222 +--------------------------------------------------------------------+ | |
223 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
224 | STATE : code ROUTINE : sBAT_PercentCPALS | | |
225 +--------------------------------------------------------------------+ | |
226 | |
227 PURPOSE : | |
228 */ | |
229 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPALS(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
230 T_BAT_cmd_send *cmd) | |
231 { | |
232 T_ACI_BAT_RSLT ret = ACI_BAT_FAIL; | |
233 | |
234 TRACE_FUNCTION ("sBAT_PercentCPALS()"); | |
235 /* adjust the left hand side | |
236 xxx = cmd->params.ptr_set_percent_cpals->call_id; | |
237 */ | |
238 /* hmm, do not know which ACI function to call ! */ | |
239 return(ret); | |
240 } | |
241 | |
242 /* | |
243 +--------------------------------------------------------------------+ | |
244 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
245 | STATE : code ROUTINE : qBAT_PercentCPALS | | |
246 +--------------------------------------------------------------------+ | |
247 | |
248 PURPOSE : | |
249 */ | |
250 GLOBAL T_ACI_BAT_RSLT qBAT_PercentCPALS(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
251 T_BAT_cmd_send *cmd) | |
252 { | |
253 T_ACI_BAT_RSLT ret; | |
254 T_BAT_cmd_response resp; | |
255 T_BAT_res_que_percent_cpals cpals; | |
256 | |
257 T_CPHS_LINES active_line; | |
258 CHAR *line_desc; | |
259 U8 max_line_desc = 30; /* should be enough ! */ | |
260 | |
261 TRACE_FUNCTION ("qBAT_PercentCPALS()"); | |
262 | |
263 MALLOC(line_desc, max_line_desc); | |
264 | |
265 resp.ctrl_response = BAT_RES_QUE_PERCENT_CPALS; | |
266 resp.response.ptr_que_percent_cpals = &cpals; | |
267 | |
268 ret = qAT_PercentCPALS( src_infos_psi->srcId, | |
269 (U8)cpals.lines, | |
270 &active_line, | |
271 line_desc, | |
272 &max_line_desc); | |
273 MFREE(line_desc); | |
274 | |
275 aci_bat_send(src_infos_psi, &resp); | |
276 return(ret); | |
277 } | |
278 | |
279 /* | |
280 +--------------------------------------------------------------------+ | |
281 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
282 | STATE : code ROUTINE : sBAT_PercentCPVWI | | |
283 +--------------------------------------------------------------------+ | |
284 | |
285 PURPOSE : | |
286 */ | |
287 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPVWI(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
288 T_BAT_cmd_send *cmd) | |
289 { | |
290 T_ACI_BAT_RSLT ret = ACI_BAT_FAIL; | |
291 T_CPHS_LINES lines = CPHS_LINE_NULL; | |
292 | |
293 TRACE_FUNCTION ("sBAT_PercentCPVWI()"); | |
294 | |
295 /* According to 8415_52.doc the parameter line is mandatory, | |
296 * but implementation in ATI/ACI allows this one to be omittable. | |
297 * So, BAT goes with them. In case of line is omitted, | |
298 * set it to all possible. Else leave the bitfield as is (BAT == ACI). | |
299 */ | |
300 if (cmd->params.ptr_set_percent_cpvwi->lines EQ BAT_P_CPVWI_LINES_NOT_PRESENT) | |
301 { | |
302 lines = CPHS_LINE1 + CPHS_LINE_DATA + CPHS_LINE_FAX + CPHS_LINE2; | |
303 } | |
304 else | |
305 { | |
306 lines = (T_CPHS_LINES)cmd->params.ptr_set_percent_cpvwi->lines; | |
307 } | |
308 | |
309 if (cmd->params.ptr_set_percent_cpvwi->mode EQ BAT_P_CPVWI_MODE_QUERY) | |
310 { | |
311 ret = query_cphs_lines(src_infos_psi, cmd, lines); | |
312 } | |
313 else | |
314 { | |
315 ret = sAT_PercentCPVWI(src_infos_psi->srcId, | |
316 (U8)cmd->params.ptr_set_percent_cpvwi->mode, | |
317 lines); | |
318 } | |
319 | |
320 return(ret); | |
321 | |
322 } | |
323 | |
324 /* | |
325 +--------------------------------------------------------------------+ | |
326 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
327 | STATE : code ROUTINE : qBAT_PercentCPOPN | | |
328 +--------------------------------------------------------------------+ | |
329 | |
330 PURPOSE : | |
331 */ | |
332 GLOBAL T_ACI_BAT_RSLT qBAT_PercentCPOPN(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
333 T_BAT_cmd_send *cmd) | |
334 { | |
335 T_ACI_BAT_RSLT ret = ACI_BAT_FAIL; | |
336 T_BAT_cmd_response resp; | |
337 T_BAT_res_que_percent_cpopn cpopn; | |
338 | |
339 TRACE_FUNCTION ("qBAT_PercentCPOPN()"); | |
340 | |
341 resp.ctrl_response = BAT_RES_QUE_PERCENT_CPOPN; | |
342 resp.response.ptr_que_percent_cpopn = &cpopn; | |
343 | |
344 ret = qAT_PercentCPOPN( src_infos_psi->srcId, | |
345 (CHAR*)cpopn.long_name, | |
346 &cpopn.c_long_name, | |
347 (CHAR*)cpopn.short_name, | |
348 &cpopn.c_short_name); | |
349 | |
350 aci_bat_send(src_infos_psi, &resp); | |
351 return(ret); | |
352 } | |
353 | |
354 /* | |
355 +--------------------------------------------------------------------+ | |
356 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
357 | STATE : code ROUTINE : sBAT_PercentCPINF | | |
358 +--------------------------------------------------------------------+ | |
359 | |
360 PURPOSE : | |
361 */ | |
362 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPINF(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
363 T_BAT_cmd_send *cmd) | |
364 { | |
365 T_ACI_BAT_RSLT ret; | |
366 T_BAT_cmd_set_percent_cpinf *cpinf = cmd->params.ptr_set_percent_cpinf; | |
367 UBYTE serv_group[CPHS_MAX_CSP]; | |
368 UBYTE serv_len = 0; | |
369 | |
370 TRACE_FUNCTION ("sBAT_PercentCPINF()"); | |
371 | |
372 memset(serv_group,0,sizeof(serv_group)); | |
373 | |
374 /* CSP exceeding maximum value display text too long */ | |
375 if ( cpinf->c_csp > BAT_MAX_CPINF_CSP_LEN ) | |
376 { | |
377 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_TxtToLong); | |
378 return(ACI_BAT_FAIL); | |
379 } | |
380 | |
381 serv_len = utl_HexStrToBin((UBYTE*)cpinf->csp, cpinf->c_csp, serv_group, CPHS_MAX_CSP); | |
382 | |
383 /* Odd length CSP or empty CSP display operation not allowed */ | |
384 if(((serv_len % 2) NEQ 0) OR (serv_len EQ 0)) | |
385 { | |
386 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_OpNotAllow); | |
387 return(ACI_BAT_FAIL); | |
388 } | |
389 | |
390 ret = sAT_PercentCPINF( src_infos_psi->srcId, | |
391 serv_group, | |
392 serv_len); | |
393 | |
394 return(ret); | |
395 } | |
396 /* | |
397 +--------------------------------------------------------------------+ | |
398 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
399 | STATE : code ROUTINE : qBAT_PercentCPINF | | |
400 +--------------------------------------------------------------------+ | |
401 | |
402 PURPOSE : | |
403 */ | |
404 GLOBAL T_ACI_BAT_RSLT qBAT_PercentCPINF(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
405 T_BAT_cmd_send *cmd) | |
406 { | |
407 T_ACI_RETURN ret = AT_FAIL; | |
408 T_BAT_cmd_response resp; | |
409 T_BAT_res_que_percent_cpinf cpinf; | |
410 | |
411 TRACE_FUNCTION ("qBAT_PercentCPINF()"); | |
412 | |
413 resp.ctrl_response = BAT_RES_QUE_PERCENT_CPINF; | |
414 resp.response.ptr_que_percent_cpinf = &cpinf; | |
415 | |
416 cpinf.phase = BAT_P_CPINF_PHASE_1; | |
417 cpinf.sst = 0; | |
418 cpinf.c_csp = BAT_MAX_CPINF_CSP_LEN; | |
419 cpinf.c_csp2 = BAT_MAX_CPINF_CSP2_LEN; | |
420 memset(cpinf.csp, 0x00, BAT_MAX_CPINF_CSP_LEN); | |
421 memset(cpinf.csp2, 0x00, BAT_MAX_CPINF_CSP2_LEN); | |
422 | |
423 ret = qAT_PercentCPINF( src_infos_psi->srcId, | |
424 (U8*)&cpinf.phase, | |
425 &cpinf.sst, | |
426 (CHAR*)cpinf.csp, | |
427 (CHAR*)cpinf.csp2, | |
428 &cpinf.c_csp, | |
429 &cpinf.c_csp2); | |
430 | |
431 if (ret EQ AT_CMPL) | |
432 { | |
433 aci_bat_send(src_infos_psi, &resp); | |
434 return (ACI_BAT_CMPL); | |
435 } | |
436 | |
437 return (ACI_BAT_FAIL); | |
438 } | |
439 | |
440 /* | |
441 +--------------------------------------------------------------------+ | |
442 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
443 | STATE : code ROUTINE : sBAT_PercentCPMB | | |
444 +--------------------------------------------------------------------+ | |
445 | |
446 PURPOSE : | |
447 */ | |
448 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPMB(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
449 T_BAT_cmd_send *cmd) | |
450 { | |
451 T_ACI_BAT_RSLT ret; | |
452 T_CPHS_LINES line; | |
453 CHAR number[CPHS_MAX_MB_NUMBER_LEN]; | |
454 CHAR alpha_id[CPHS_MAX_MB_ALPHA_LEN]; | |
455 T_ACI_TOA_TON ton; | |
456 T_ACI_TOA_NPI npi; | |
457 | |
458 TRACE_FUNCTION ("sBAT_PercentCPMB()"); | |
459 | |
460 /* | |
461 * Call the corresponding ACI function. T_ACI_BAT_RSLT is | |
462 * assumed to be equivalent to T_ACI_RESULT. | |
463 */ | |
464 ret=(T_ACI_BAT_RSLT)qAT_PercentCPMB( | |
465 src_infos_psi->srcId, | |
466 (UBYTE)cmd->params.ptr_set_percent_cpmb->record_id, | |
467 &line,number,&ton,&npi,alpha_id,NULL); | |
468 | |
469 /* | |
470 * If the query completes, send the response now. | |
471 */ | |
472 if (ret EQ ACI_BAT_CMPL) | |
473 { | |
474 T_BAT_cmd_response resp; | |
475 T_BAT_res_set_percent_cpmb cpmb_data; | |
476 UBYTE len; | |
477 T_ACI_TOA toa; | |
478 | |
479 resp.ctrl_response=BAT_RES_SET_PERCENT_CPMB; | |
480 resp.response.ptr_set_percent_cpmb=&cpmb_data; | |
481 | |
482 cpmb_data.record_id=(T_BAT_record_id)cmd->params.ptr_set_percent_cpmb->record_id; | |
483 cpmb_data.line=(T_BAT_percent_cpmb_line)line; | |
484 | |
485 len=strlen(number); | |
486 | |
487 /* | |
488 * This is in line with the existing ATI implementation (see | |
489 * setatPercentCPMB()) and is necessary to pass tests such as | |
490 * ACI583. | |
491 */ | |
492 if (len EQ 0) | |
493 { | |
494 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_NotFound); | |
495 return(ACI_BAT_FAIL); | |
496 } | |
497 | |
498 /* | |
499 * Check that the number isn't too long for the BAT message, | |
500 * if it is it will effectively be truncated. | |
501 */ | |
502 if (len>BAT_MAX_CPMB_NUMBER_LEN) | |
503 len=BAT_MAX_CPMB_NUMBER_LEN; | |
504 | |
505 if (len) | |
506 { | |
507 memcpy(cpmb_data.number,number,len); | |
508 cpmb_data.v_number=TRUE; | |
509 cpmb_data.c_number=(U8)len; | |
510 } | |
511 else | |
512 { | |
513 cpmb_data.v_number=FALSE; | |
514 } | |
515 | |
516 len=strlen(alpha_id); | |
517 | |
518 if (len) | |
519 { | |
520 USHORT len_cvtd_text=0; | |
521 | |
522 /* | |
523 * Convert the data read from the SIM into the currently | |
524 * selected character set. | |
525 */ | |
526 utl_chsetFromSim( | |
527 (UBYTE *)alpha_id, | |
528 (USHORT)len, | |
529 (UBYTE *)cpmb_data.alpha_id, | |
530 BAT_MAX_CPMB_ALPHA_ID_LEN, | |
531 &len_cvtd_text, | |
532 GSM_ALPHA_Def); | |
533 | |
534 cpmb_data.v_alpha_id=TRUE; | |
535 cpmb_data.c_alpha_id=(U8)len_cvtd_text; | |
536 } | |
537 else | |
538 { | |
539 cpmb_data.v_alpha_id=FALSE; | |
540 } | |
541 | |
542 /* | |
543 * Get the type of number and numbering plan into a T_ACI_TOA structure | |
544 * so that we can use toa_merge(). | |
545 */ | |
546 toa.ton=ton; | |
547 toa.npi=npi; | |
548 | |
549 /* | |
550 * BAT stores the type of address in a single 8-bit value (it is S16 in | |
551 * the message only to allow for a 'not present' value of -1). | |
552 */ | |
553 cpmb_data.type=(S16)toa_merge(toa); | |
554 | |
555 aci_bat_send(src_infos_psi,&resp); | |
556 } | |
557 | |
558 return(ret); | |
559 } | |
560 | |
561 | |
562 /* | |
563 +--------------------------------------------------------------------+ | |
564 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
565 | STATE : code ROUTINE : qBAT_PercentCPMB | | |
566 +--------------------------------------------------------------------+ | |
567 | |
568 PURPOSE : | |
569 */ | |
570 GLOBAL T_ACI_BAT_RSLT qBAT_PercentCPMB(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
571 T_BAT_cmd_send *cmd) | |
572 { | |
573 T_ACI_BAT_RSLT ret; | |
574 UBYTE first; | |
575 | |
576 TRACE_FUNCTION ("qBAT_PercentCPMB()"); | |
577 | |
578 /* | |
579 * Call the corresponding qAT function. T_ACI_BAT_RSLT is | |
580 * assumed to be equivalent to T_ACI_RESULT. | |
581 */ | |
582 ret=(T_ACI_BAT_RSLT)qAT_PercentCPMB( | |
583 src_infos_psi->srcId, | |
584 (UBYTE)ACI_NumParmNotPresent,NULL,NULL,NULL,NULL,NULL,&first); | |
585 | |
586 /* | |
587 * If the query completes, send the response now. | |
588 */ | |
589 if (ret EQ ACI_BAT_CMPL) | |
590 { | |
591 T_BAT_cmd_response resp; | |
592 T_BAT_res_que_percent_cpmb cpmb_data; | |
593 | |
594 resp.ctrl_response=BAT_RES_QUE_PERCENT_CPMB; | |
595 resp.response.ptr_que_percent_cpmb=&cpmb_data; | |
596 | |
597 cpmb_data.first=(U8)first; | |
598 | |
599 aci_bat_send(src_infos_psi,&resp); | |
600 } | |
601 | |
602 return(ret); | |
603 } | |
604 | |
605 | |
606 /* | |
607 +--------------------------------------------------------------------+ | |
608 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
609 | STATE : code ROUTINE : sBAT_PercentCPMBW | | |
610 +--------------------------------------------------------------------+ | |
611 | |
612 PURPOSE : | |
613 */ | |
614 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPMBW(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
615 T_BAT_cmd_send *cmd) | |
616 { | |
617 T_ACI_BAT_RSLT ret; | |
618 T_BAT_cmd_set_percent_cpmbw *cpmbw = cmd->params.ptr_set_percent_cpmbw; | |
619 T_ACI_TOA type; | |
620 T_ACI_TOA *p_type; | |
621 CHAR number[BAT_MAX_CPMBW_NUMBER_LEN+1]; | |
622 CHAR *p_number; | |
623 T_CPHS_PB_TEXT text; | |
624 T_CPHS_PB_TEXT *p_text; | |
625 | |
626 TRACE_FUNCTION ("sBAT_PercentCPMBW()"); | |
627 | |
628 if (cpmbw->type EQ -1) | |
629 { | |
630 p_type=NULL; | |
631 } | |
632 else | |
633 { | |
634 p_type=&type; | |
635 type=toa_demerge(cpmbw->type); | |
636 } | |
637 | |
638 if (cpmbw->v_number EQ FALSE) | |
639 { | |
640 p_number=NULL; | |
641 } | |
642 else | |
643 { | |
644 /* | |
645 * Mailbox number is present, so make a zero-terminated version | |
646 * and set a pointer to it. | |
647 */ | |
648 p_number=number; | |
649 memset(number,0,sizeof(number)); | |
650 memcpy(number,cpmbw->number,cpmbw->c_number); | |
651 } | |
652 | |
653 if (cpmbw->v_text EQ FALSE) | |
654 { | |
655 p_text=NULL; | |
656 } | |
657 else | |
658 { | |
659 USHORT len; | |
660 | |
661 p_text=&text; | |
662 | |
663 /* | |
664 * Convert from the currently selected character set into the | |
665 * SIM format. | |
666 */ | |
667 utl_chsetToSim( | |
668 (UBYTE *)cpmbw->text, | |
669 (USHORT)cpmbw->c_text, | |
670 (UBYTE *)text.data, | |
671 &len, | |
672 GSM_ALPHA_Def); | |
673 | |
674 if (len>CPHS_MAX_MB_ALPHA_LEN) | |
675 { | |
676 /* | |
677 * Shouldn't get here as that would mean that memory has been | |
678 * overwritten. Currently utl_chsetToSim() has no specific mechanism | |
679 * to prevent this. | |
680 */ | |
681 ACI_ERR_DESC(ACI_ERR_CLASS_Cme,CME_ERR_TxtToLong); | |
682 return(ACI_BAT_FAIL); | |
683 } | |
684 | |
685 /* | |
686 * Set the length. Note that we cannot do this by passing a | |
687 * reference to text.len into utl_chsetToSim() because it is | |
688 * the wrong type. | |
689 */ | |
690 text.len=(UBYTE)len; | |
691 | |
692 p_text=&text; | |
693 } | |
694 | |
695 /* | |
696 * Call the corresponding sAT function. T_ACI_BAT_RSLT is | |
697 * assumed to be equivalent to T_ACI_RESULT. | |
698 */ | |
699 ret=sAT_PercentCPMBW( | |
700 src_infos_psi->srcId, | |
701 (SHORT)cpmbw->record_id, | |
702 p_number, | |
703 p_type, | |
704 p_text); | |
705 | |
706 return(ret); | |
707 } | |
708 | |
709 /* | |
710 +--------------------------------------------------------------------+ | |
711 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
712 | STATE : code ROUTINE : tBAT_PercentCPMBW | | |
713 +--------------------------------------------------------------------+ | |
714 | |
715 PURPOSE : | |
716 */ | |
717 GLOBAL T_ACI_BAT_RSLT tBAT_PercentCPMBW(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
718 T_BAT_cmd_send *cmd) | |
719 { | |
720 TRACE_FUNCTION ("tBAT_PercentCPMBW()"); | |
721 return(ACI_BAT_FAIL); | |
722 } | |
723 | |
724 /* | |
725 +--------------------------------------------------------------------+ | |
726 | PROJECT : GSM-F&D (8411) MODULE : ACI_BAT | | |
727 | STATE : code ROUTINE : sBAT_PercentCPCFU | | |
728 +--------------------------------------------------------------------+ | |
729 | |
730 PURPOSE : | |
731 */ | |
732 GLOBAL T_ACI_BAT_RSLT sBAT_PercentCPCFU(T_ACI_DTI_PRC_PSI *src_infos_psi, | |
733 T_BAT_cmd_send *cmd) | |
734 { | |
735 T_ACI_BAT_RSLT ret = ACI_BAT_FAIL; | |
736 T_CPHS_LINES lines = CPHS_LINE_NULL; | |
737 | |
738 TRACE_FUNCTION ("sBAT_PercentCPCFU()"); | |
739 | |
740 /* According to 8415_52.doc the parameter line is mandatory, | |
741 * but implementation in ATI/ACI allows this one to be omittable. | |
742 * So, BAT goes with them. In case of line is omitted, | |
743 * set it to all possible. Else leave the bitfield as is (BAT == ACI). | |
744 */ | |
745 if (cmd->params.ptr_set_percent_cpcfu->line EQ BAT_P_CPCFU_LINE_NOT_PRESENT) | |
746 { | |
747 lines = CPHS_LINE1 + CPHS_LINE_DATA + CPHS_LINE_FAX + CPHS_LINE2; | |
748 } | |
749 else | |
750 { | |
751 lines = (T_CPHS_LINES)cmd->params.ptr_set_percent_cpcfu->line; | |
752 } | |
753 | |
754 if (cmd->params.ptr_set_percent_cpcfu->mode EQ BAT_P_CPCFU_MODE_QUERY) | |
755 { | |
756 ret = query_cphs_lines(src_infos_psi, cmd, lines); | |
757 } | |
758 else | |
759 { | |
760 ret = sAT_PercentCPCFU(src_infos_psi->srcId, | |
761 (U8)cmd->params.ptr_set_percent_cpcfu->mode, | |
762 lines); | |
763 } | |
764 return(ret); | |
765 } | |
766 |