FreeCalypso > hg > freecalypso-citrine

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

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial import of gsm-fw from freecalypso-sw rev 1033:5ab737ac3ad7
author Mychaela Falconia <falcon@freecalypso.org>
date Thu, 09 Jun 2016 00:02:41 +0000
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:75a11d740a02
1 /*
2 +-----------------------------------------------------------------------------
3 | Project : GSM-PS (6147)
4 | Modul : PSA_SSF
5 +-----------------------------------------------------------------------------
6 | Copyright 2002 Texas Instruments Berlin, AG
7 | All rights reserved.
8 |
9 | This file is confidential and a trade secret of Texas
10 | Instruments Berlin, AG
11 | The receipt of or possession of this file does not convey
12 | any rights to reproduce or disclose its contents or to
13 | manufacture, use, or sell anything it may describe, in
14 | whole, or in part, without the specific written consent of
15 | Texas Instruments Berlin, AG.
16 +-----------------------------------------------------------------------------
17 | Purpose : This module defines the functions for the protocol
18 | stack adapter for supplementary services.
19 +-----------------------------------------------------------------------------
20 */
21
22 #ifndef PSA_SSF_C
23 #define PSA_SSF_C
24 #endif
25
26 #include "config.h"
27 #include "fixedconf.h"
28 #include "condat-features.h"
29 #include "aci_conf.h"
30
31 #include "aci_all.h"
32
33 #undef TRACING
34
35 /*==== INCLUDES ===================================================*/
36 #include "aci_cmh.h"
37 #include "ati_cmd.h"
38 #include "aci_cmd.h"
39
40 #include "ksd.h"
41 #include "aci.h"
42 #include "psa.h"
43 #include "psa_ss.h"
44 #include "psa_util.h"
45 #include "cmh_ss.h"
46 #include "cmh.h"
47
48 /*==== CONSTANTS ==================================================*/
49 #define MAX_MOSTI_NR (7) /* max number of ti's for MOS */
50
51 #define MAX_ITM (5) /* max number of items per line */
52 #define ITM_WDT (14) /* item width in chars */
53 #define HDR_WDT (10) /* header width in chars */
54
55 /*==== TYPES ======================================================*/
56
57
58 /*==== EXPORT =====================================================*/
59
60 /*==== VARIABLES ==================================================*/
61 LOCAL UBYTE tiPool = 0xFF; /* holds pool of transaction identifiers */
62
63 /*==== FUNCTIONS ==================================================*/
64
65 LOCAL void psaSS_asmSSForBS ( UBYTE ssCode, UBYTE bscSrvType,
66 UBYTE bscSrv, T_ssForBS *ssForBS);
67
68 /*
69 +-------------------------------------------------------------------+
70 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
71 | ROUTINE : psaSS_asmEmptyRslt |
72 +-------------------------------------------------------------------+
73
74 PURPOSE : assemble an empty return result facility information
75 element.
76
77 */
78
79 GLOBAL void psaSS_asmEmptyRslt ( void )
80 {
81 TRACE_FUNCTION("psaSS_asmEmptyRslt");
82
83 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
84
85 ssFIECodeBuf.l_buf = 8;
86
87 ssShrdPrm.cmpType = CT_RET_RSLT;
88 }
89
90 /*
91 +-------------------------------------------------------------------+
92 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
93 | ROUTINE : psaSS_asmErrorRslt |
94 +-------------------------------------------------------------------+
95
96 PURPOSE : assemble an return error facility information
97 element.
98
99 */
100
101 GLOBAL void psaSS_asmErrorRslt ( SHORT sId, UBYTE err )
102 {
103 TRACE_FUNCTION("psaSS_asmErrorRslt");
104
105 ssShrdPrm.stb[sId].failType = SSF_SS_ERR;
106 ssShrdPrm.stb[sId].errCd = err;
107 ssShrdPrm.cmpType = CT_RET_ERR;
108 }
109
110 /*
111 +-------------------------------------------------------------------+
112 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
113 | ROUTINE : psaSS_asmInterrogateSS |
114 +-------------------------------------------------------------------+
115
116 PURPOSE : assemble the interrogate SS facility information element.
117
118 */
119
120 GLOBAL void psaSS_asmInterrogateSS ( UBYTE ssCode,
121 UBYTE bscSrvType,
122 UBYTE bscSrv )
123 {
124 MCAST( irgtSS, INTERROGATE_SS_INV );
125
126 TRACE_FUNCTION("psaSS_asmInterrogateSS");
127
128 memset( irgtSS, 0, sizeof( T_INTERROGATE_SS_INV ));
129
130 /* set basic settings */
131 irgtSS->msg_type = INTERROGATE_SS_INV;
132 irgtSS->v_ssForBS = TRUE;
133
134 /* set service code */
135 irgtSS->ssForBS.v_ssCode = TRUE;
136 irgtSS->ssForBS.ssCode = ssCode;
137
138 /* set basic service type */
139 switch( bscSrvType )
140 {
141 case( BS_BEAR_SRV ):
142
143 irgtSS->ssForBS.basicService.v_bearerService = TRUE;
144 irgtSS->ssForBS.basicService.bearerService = bscSrv;
145 break;
146
147 case( BS_TELE_SRV ):
148
149 irgtSS->ssForBS.basicService.v_teleservice = TRUE;
150 irgtSS->ssForBS.basicService.teleservice = bscSrv;
151 break;
152
153 default:
154 irgtSS->ssForBS.basicService.v_bearerService = FALSE;
155 irgtSS->ssForBS.basicService.v_teleservice = FALSE;
156 }
157
158 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
159 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
160 ccd_codeMsg (CCDENT_FAC, UPLINK,
161 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
162 NOT_PRESENT_8BIT);
163
164 ssShrdPrm.cmpType = CT_INV;
165 }
166
167 /*
168 +-------------------------------------------------------------------+
169 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
170 | ROUTINE : psaSS_asmRegisterSS |
171 +-------------------------------------------------------------------+
172
173 PURPOSE : assemble the register SS facility information element.
174
175 */
176
177 GLOBAL void psaSS_asmRegisterSS ( UBYTE ssCode, UBYTE bscSrvType,
178 UBYTE bscSrv, UBYTE ton, UBYTE npi,
179 UBYTE *num, UBYTE tos, UBYTE oe,
180 UBYTE *sub, UBYTE time )
181 {
182 MCAST( regSS, REGISTER_SS_INV );
183
184 TRACE_FUNCTION("psaSS_asmRegisterSS");
185
186 memset( regSS, 0, sizeof( T_REGISTER_SS_INV ));
187
188 /* set basic settings */
189 regSS->msg_type = REGISTER_SS_INV;
190 regSS->v_registerSSArg = TRUE;
191
192 /* set service code */
193 regSS->registerSSArg.v_ssCode = TRUE;
194 regSS->registerSSArg.ssCode = ssCode;
195
196 /* set basic service type */
197 switch( bscSrvType )
198 {
199 case( BS_BEAR_SRV ):
200
201 regSS->registerSSArg.basicService.v_bearerService = TRUE;
202 regSS->registerSSArg.basicService.bearerService = bscSrv;
203 break;
204
205 case( BS_TELE_SRV ):
206
207 regSS->registerSSArg.basicService.v_teleservice = TRUE;
208 regSS->registerSSArg.basicService.teleservice = bscSrv;
209 break;
210 }
211
212 /* set forwarded to number */
213 if( num NEQ NULL )
214 {
215 regSS->registerSSArg.v_forwardedToNumber = TRUE;
216 regSS->registerSSArg.forwardedToNumber.c_bcdDigit
217 = (UBYTE)utl_dialStr2BCD((char *) num,
218 regSS->registerSSArg.forwardedToNumber.bcdDigit,
219 MAX_PARTY_NUM);
220
221 if(ton NEQ MNCC_TON_NOT_PRES AND
222 npi NEQ MNCC_NPI_NOT_PRES)
223 {
224 regSS->registerSSArg.forwardedToNumber.v_noa = TRUE;
225 regSS->registerSSArg.forwardedToNumber.noa = ton;
226
227 regSS->registerSSArg.forwardedToNumber.v_npi = TRUE;
228 regSS->registerSSArg.forwardedToNumber.npi = npi;
229 }
230 }
231
232 /* set forwarded to subaddress */
233 if( sub NEQ NULL )
234 {
235 regSS->registerSSArg.v_forwardedToSubaddress = TRUE;
236 regSS->registerSSArg.forwardedToSubaddress.c_subadr_str
237 = (UBYTE)utl_dialStr2BCD((char *) sub,
238 regSS->registerSSArg.forwardedToSubaddress.subadr_str,
239 MAX_SUBADDR_NUM);
240
241 regSS->registerSSArg.forwardedToSubaddress.v_tos = TRUE;
242 regSS->registerSSArg.forwardedToSubaddress.tos = tos;
243
244 regSS->registerSSArg.forwardedToSubaddress.v_oei = TRUE;
245 regSS->registerSSArg.forwardedToSubaddress.oei = oe;
246 }
247
248 /* set no reply timer */
249 //TISH, patch for OMAPS00130690
250 #if 0
251 if( ssCode EQ SS_CD_CFNRY AND time NEQ KSD_TIME_NONE )
252 #else
253 if( ((ssCode EQ SS_CD_CFNRY) OR (ssCode EQ SS_CD_ALL_FWSS) OR (ssCode EQ SS_CD_ALL_CFWSS)) AND time NEQ KSD_TIME_NONE )
254 #endif
255 //end
256 {
257 regSS->registerSSArg.v_noReplyConditionTime = TRUE;
258 regSS->registerSSArg.noReplyConditionTime = time;
259 }
260
261 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
262 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
263 ccd_codeMsg (CCDENT_FAC, UPLINK,
264 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
265 NOT_PRESENT_8BIT);
266
267 ssShrdPrm.cmpType = CT_INV;
268 }
269
270 /*
271 +-------------------------------------------------------------------+
272 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
273 | ROUTINE : psaSS_asmEraseSS |
274 +-------------------------------------------------------------------+
275
276 PURPOSE : assemble the erase SS facility information element.
277
278 */
279
280 GLOBAL void psaSS_asmEraseSS ( UBYTE ssCode, UBYTE bscSrvType,
281 UBYTE bscSrv )
282 {
283 MCAST( ersSS, ERASE_SS_INV );
284
285 TRACE_FUNCTION("psaSS_asmEraseSS");
286
287 memset( ersSS, 0, sizeof( T_ERASE_SS_INV ));
288
289 /* set basic settings */
290 ersSS->msg_type = ERASE_SS_INV;
291 ersSS->v_ssForBS = TRUE;
292
293 /* Implements Measure # 194 */
294 psaSS_asmSSForBS ( ssCode, bscSrvType, bscSrv, &(ersSS->ssForBS));
295
296 }
297
298 /*
299 +-------------------------------------------------------------------+
300 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
301 | ROUTINE : psaSS_asmActivateSS |
302 +-------------------------------------------------------------------+
303
304 PURPOSE : assemble the interrogate SS facility information element.
305
306 */
307
308 GLOBAL void psaSS_asmActivateSS ( UBYTE ssCode, UBYTE bscSrvType,
309 UBYTE bscSrv )
310 {
311 MCAST( actSS, ACTIVATE_SS_INV );
312
313 TRACE_FUNCTION("psaSS_asmActivateSS");
314
315 memset( actSS, 0, sizeof( T_ACTIVATE_SS_INV ));
316
317 /* set basic settings */
318 actSS->msg_type = ACTIVATE_SS_INV;
319 actSS->v_ssForBS = TRUE;
320
321 /* Implements Measure # 194 */
322 psaSS_asmSSForBS ( ssCode, bscSrvType, bscSrv, &(actSS->ssForBS));
323
324 }
325
326 /*
327 +-------------------------------------------------------------------+
328 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
329 | ROUTINE : psaSS_asmDeactivateSS |
330 +-------------------------------------------------------------------+
331
332 PURPOSE : assemble the deactivate SS facility information element.
333
334 */
335
336 GLOBAL void psaSS_asmDeactivateSS ( UBYTE ssCode, UBYTE bscSrvType,
337 UBYTE bscSrv )
338 {
339 MCAST( deactSS, DEACTIVATE_SS_INV );
340
341 TRACE_FUNCTION("psaSS_asmDeactivateSS");
342
343 memset( deactSS, 0, sizeof( T_DEACTIVATE_SS_INV ));
344
345 /* set basic settings */
346 deactSS->msg_type = DEACTIVATE_SS_INV;
347 deactSS->v_ssForBS = TRUE;
348
349 /* Implements Measure # 195 */
350 psaSS_asmSSForBS ( ssCode, bscSrvType, bscSrv, &(deactSS->ssForBS));
351
352 }
353
354 /*
355 +-------------------------------------------------------------------+
356 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
357 | ROUTINE : psaSS_asmRegisterPWD |
358 +-------------------------------------------------------------------+
359
360 PURPOSE : assemble the register password facility information
361 element.
362
363 */
364
365 GLOBAL void psaSS_asmRegisterPWD ( UBYTE ssCode )
366 {
367 MCAST( regPWD, REGISTER_PWD_INV );
368
369 TRACE_FUNCTION("psaSS_asmRegisterPWD");
370
371 memset( regPWD, 0, sizeof( T_REGISTER_PWD_INV ));
372
373 /* set service code */
374 regPWD->v_ssCode = TRUE;
375 regPWD->ssCode = ssCode;
376 regPWD->msg_type = REGISTER_PWD_INV;
377
378 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
379 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
380 ccd_codeMsg (CCDENT_FAC, UPLINK,
381 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
382 NOT_PRESENT_8BIT);
383
384 ssShrdPrm.cmpType = CT_INV;
385
386 }
387
388 /*
389 +-------------------------------------------------------------------+
390 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
391 | ROUTINE : psaSS_asmVerifyPWD |
392 +-------------------------------------------------------------------+
393
394 PURPOSE : assemble the verify password facility information
395 element.
396
397 */
398
399 GLOBAL void psaSS_asmVerifyPWD ( UBYTE *pwd )
400 {
401 MCAST( vrfPWD, GET_PWD_RES );
402
403 TRACE_FUNCTION("psaSS_asmVerifyPWD");
404
405 memset( vrfPWD, 0, sizeof( T_GET_PWD_RES ));
406
407 /* set service code */
408 vrfPWD->v_currPassword = TRUE;
409 vrfPWD->msg_type = GET_PWD_RES;
410
411 strncpy( (char *) vrfPWD->currPassword.digit, (char *) pwd, MAX_PWD_NUM );
412
413 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
414 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
415 ccd_codeMsg (CCDENT_FAC, UPLINK,
416 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
417 NOT_PRESENT_8BIT);
418
419 ssShrdPrm.cmpType = CT_RET_RSLT;
420
421 }
422
423 /*
424 +-------------------------------------------------------------------+
425 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
426 | ROUTINE : psaSS_asmProcUSSDReq |
427 +-------------------------------------------------------------------+
428
429 PURPOSE : assemble the process USSD request facility information
430 element.
431
432 */
433
434 GLOBAL void psaSS_asmProcUSSDReq ( UBYTE dcs, UBYTE *ussd, UBYTE len )
435 {
436 /* UBYTE cmpLen;*/
437
438 MCAST( ussdReq, PROCESS_USSD_REQ_INV );
439
440 TRACE_FUNCTION("psaSS_asmProcUSSDReq");
441
442 memset( ussdReq, 0, sizeof( T_PROCESS_USSD_REQ_INV ));
443
444 /* set service code */
445 ussdReq->v_ussdArg = TRUE;
446 ussdReq->msg_type = PROCESS_USSD_REQ_INV;
447
448 /* set data coding scheme */
449 ussdReq->ussdArg.v_ussdDataCodingScheme = TRUE;
450 ussdReq->ussdArg.ussdDataCodingScheme = dcs;
451
452 /* set ussd response string */
453 /* if( utl_getAlphabetCb( dcs ) EQ 0 ) *//* 7bit alphabet */
454 /* cmpLen = utl_cvt8To7( ussd, (UBYTE)MINIMUM( MAX_USSD_STRING, len),
455 ussdReq->ussdArg.ussdString.b_ussdString, 0 );
456 else*/
457 {
458 /* cmpLen = len;*/
459 memcpy( ussdReq->ussdArg.ussdString.b_ussdString, ussd,
460 MINIMUM( MAX_USSD_STRING, len));
461 }
462
463 ussdReq->ussdArg.v_ussdString = TRUE;
464 ussdReq->ussdArg.ussdString.o_ussdString = 0;
465 ussdReq->ussdArg.ussdString.l_ussdString = len<<3; /*cmpLen<<3;*/
466
467 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
468 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
469 ccd_codeMsg (CCDENT_FAC, UPLINK,
470 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
471 NOT_PRESENT_8BIT);
472
473 ssShrdPrm.cmpType = CT_INV;
474 }
475
476 /*
477 +-------------------------------------------------------------------+
478 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
479 | ROUTINE : psaSS_asmCnfUSSDReq |
480 +-------------------------------------------------------------------+
481
482 PURPOSE : assemble the confirm USSD request facility information
483 element.
484 */
485
486 GLOBAL void psaSS_asmCnfUSSDReq ( UBYTE dcs, UBYTE *ussd, UBYTE len )
487 {
488 UBYTE cmpLen;
489 UBYTE src_len;
490
491 MCAST( ussdReq, USSD_REQ_RES );
492
493 TRACE_FUNCTION("psaSS_asmCnfUSSDReq");
494
495 memset( ussdReq, 0, sizeof( T_USSD_REQ_RES ));
496
497 /* set service code */
498 ussdReq->v_ussdRes = TRUE;
499 ussdReq->msg_type = USSD_REQ_RES;
500
501 /* set data coding scheme */
502 ussdReq->ussdRes.v_ussdDataCodingScheme = TRUE;
503 ussdReq->ussdRes.ussdDataCodingScheme = dcs;
504
505 /* set ussd response string */
506 /* Implements Measure 25 */
507 /* This function is more correct than utl_getAlphabetCb as it takes care
508 of reserved codings */
509 if( cmh_getAlphabetCb( dcs ) EQ 0 ) /* 7bit alphabet */
510 {
511 src_len = (UBYTE)MINIMUM( MAX_USSD_STRING, len);
512 cmpLen = utl_cvt8To7( ussd, src_len,
513 ussdReq->ussdRes.ussdString.b_ussdString, 0 );
514 /* According to spec 23.038 section 6.1.2.3 for USSD packing, for bytes end with
515 * (8*n)-1 i.e where n is 1,2,3....i.e byte 7, 15, 23 ... to be padded
516 * with carriage return <CR>(0xD)
517 */
518 if ((src_len+1)%8 EQ 0)
519 {
520 ussdReq->ussdRes.ussdString.b_ussdString[cmpLen-1] |= (0xD << 1);
521 }
522 }
523 else
524 {
525 cmpLen = len;
526 memcpy( ussdReq->ussdRes.ussdString.b_ussdString, ussd,
527 MINIMUM( MAX_USSD_STRING, len));
528 }
529
530 ussdReq->ussdRes.v_ussdString = TRUE;
531 ussdReq->ussdRes.ussdString.o_ussdString = 0;
532 ussdReq->ussdRes.ussdString.l_ussdString = cmpLen<<3;
533
534 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
535 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
536 ccd_codeMsg (CCDENT_FAC, UPLINK,
537 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
538 NOT_PRESENT_8BIT);
539
540 ssShrdPrm.cmpType = CT_RET_RSLT;
541 }
542
543 /*
544 +-------------------------------------------------------------------+
545 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
546 | ROUTINE : psaSS_USSDProt1 |
547 +-------------------------------------------------------------------+
548
549 PURPOSE : send USSD according to protocol version 1.
550 */
551
552 GLOBAL BOOL psaSS_asmUSSDProt1 ( SHORT sId )
553 {
554 UBYTE ussdBuf8Bit[MAX_USSD_STRING]; /* buffers 8 bit ussd string */
555 USHORT ussdLen8Bit;
556
557 TRACE_FUNCTION("psaSS_asmUSSDProt1");
558
559 if( ssShrdPrm.ussdLen AND
560 ssShrdPrm.stb[sId].SSver NEQ NOT_PRESENT_8BIT )
561 {
562 MCAST( ussdData, PROCESS_USSD_INV );
563
564 memset( ussdData, 0, sizeof( T_PROCESS_USSD_INV ));
565
566 /* set service code */
567 ussdData->v_ssUserData = TRUE;
568 ussdData->msg_type = PROCESS_USSD_INV;
569
570 /* GSM data must be 8-bit coded */
571 if (ssShrdPrm.ussdDcs EQ 0x0F)
572 {
573 ussdLen8Bit = utl_cvt7To8 (ssShrdPrm.ussdBuf, ssShrdPrm.ussdLen, ussdBuf8Bit, 0);
574 }
575 else
576 {
577 memcpy ( ussdBuf8Bit, ssShrdPrm.ussdBuf, ssShrdPrm.ussdLen);
578 ussdLen8Bit = ssShrdPrm.ussdLen;
579 }
580
581 /* set ussd data string, if convertible */
582 if( !utl_cvtGsmIra ( ussdBuf8Bit,
583 ussdLen8Bit,
584 ussdData->ssUserData.b_ssUserData,
585 MAX_USSD_DATA,
586 CSCS_DIR_GsmToIra ) )
587 {
588 return( FALSE );
589 }
590
591 ussdData->ssUserData.o_ssUserData = 0;
592 ussdData->ssUserData.l_ssUserData = ssShrdPrm.ussdLen<<3;
593
594 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
595 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
596 ccd_codeMsg (CCDENT_FAC, UPLINK,
597 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
598 NOT_PRESENT_8BIT);
599
600 ssShrdPrm.cmpType = CT_INV;
601
602 /* skip SS version indicator */
603 ssShrdPrm.stb[sId].SSver = NOT_PRESENT_8BIT;
604
605 /* repeat USSD string */
606 psaSS_NewTrns(sId);
607
608 return( TRUE );
609 }
610
611 return( FALSE );
612 }
613
614
615 /*
616 +-------------------------------------------------------------------+
617 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
618 | ROUTINE : psaSS_asmDeactivateCCBS |
619 +-------------------------------------------------------------------+
620
621 PURPOSE : assemble the deactivate CCBS facility information
622 element.
623
624 */
625
626 GLOBAL void psaSS_asmDeactivateCCBS ( UBYTE idx )
627 {
628 MCAST( ersCCBS, ERASE_CC_ENTRY_INV );
629
630 TRACE_FUNCTION("psaSS_asmDeactivateCCBS");
631
632 memset( ersCCBS, 0, sizeof( T_ERASE_CC_ENTRY_INV ));
633
634 /* set service code */
635 ersCCBS->v_eraseCCEntryArg = TRUE;
636 ersCCBS->msg_type = ERASE_CC_ENTRY_INV;
637
638 ersCCBS->eraseCCEntryArg.v_ssCode = TRUE;
639 ersCCBS->eraseCCEntryArg.ssCode = SS_CD_CCBS;
640
641 if( idx NEQ KSD_IDX_NONE )
642 {
643 ersCCBS->eraseCCEntryArg.v_ccbsIndex = TRUE;
644 ersCCBS->eraseCCEntryArg.ccbsIndex = idx;
645 }
646
647 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
648 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
649 ccd_codeMsg (CCDENT_FAC, UPLINK,
650 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
651 NOT_PRESENT_8BIT);
652
653 ssShrdPrm.cmpType = CT_INV;
654 }
655
656 /*
657 +-------------------------------------------------------------------+
658 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
659 | ROUTINE : psaSS_dasmInvokeCmp |
660 +-------------------------------------------------------------------+
661
662 PURPOSE : disassemble the result component.
663 */
664
665 GLOBAL void psaSS_dasmInvokeCmp ( SHORT sId, T_inv_comp *invCmp )
666 {
667 USHORT ivId; /* holds invoke Id */
668 UBYTE opCode; /* holds operation code */
669
670 TRACE_FUNCTION("psaSS_dasmInvokeCmp");
671
672 if( invCmp -> v_inv_id )
673 ivId = invCmp -> inv_id;
674 else
675 ivId = NOT_PRESENT_16BIT;
676
677 if( invCmp -> v_op_code )
678 opCode = invCmp -> op_code;
679 else
680 opCode = NOT_PRESENT_8BIT;
681
682 /* store op code and invoke id for result */
683 ssShrdPrm.stb[sId].iId = (UBYTE)ivId;
684 ssShrdPrm.stb[sId].opCode = opCode;
685
686 if( invCmp -> params.l_params )
687 {
688 UBYTE ccdRet;
689
690 memcpy( ssFIEDecodeBuf, &invCmp -> params, MNCC_FACILITY_LEN );
691
692 ccdRet = ccd_decodeMsg (CCDENT_FAC,
693 DOWNLINK,
694 (T_MSGBUF *) ssFIEDecodeBuf,
695 (UBYTE *) _decodedMsg,
696 opCode);
697
698 if( ccdRet NEQ ccdOK )
699 {
700 TRACE_EVENT_P1("CCD Decoding Error: %d",ccdRet );
701 ssShrdPrm.stb[sId].failType = SSF_CCD_DEC;
702 cmhSS_TransFail(sId);
703 }
704 }
705 else
706 memset( ssFIEDecodeBuf, 0, MNCC_FACILITY_LEN ); /* put all valid flags to FALSE */
707
708 switch( opCode )
709 {
710 case( OPC_GET_PASSWORD ):
711 {
712 MCAST( getPWD, GET_PWD_INV );
713
714 cmhSS_getPassword( sId, getPWD );
715 }
716 break;
717
718 case( OPC_UNSTRUCT_SS_NOTIFY ):
719 {
720 MCAST( ussdNtfy, USSD_NOTIFY_INV );
721
722 cmhSS_USSDNotify( sId, ussdNtfy );
723 }
724 break;
725
726 case( OPC_UNSTRUCT_SS_REQ ):
727 {
728 MCAST( ussdReq, USSD_REQ_INV );
729
730 cmhSS_USSDRequest( sId, ussdReq );
731 }
732 break;
733
734 case( OPC_FWD_CHECK_SS_IND ):
735 {
736 cmhSS_FwdChckSS( sId );
737 }
738 break;
739 }
740 }
741
742 /*
743 +-------------------------------------------------------------------+
744 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
745 | ROUTINE : psaSS_dasmResultCmp |
746 +-------------------------------------------------------------------+
747
748 PURPOSE : disassemble the result component.
749 */
750
751 GLOBAL void psaSS_dasmResultCmp ( SHORT sId, T_res_comp *resCmp )
752 {
753 UBYTE opCode; /* holds operation code */
754
755 TRACE_FUNCTION("psaSS_dasmResultCmp");
756
757 /* get operation code of the result */
758 if( resCmp -> v_sequence AND
759 resCmp -> sequence.v_op_code )
760 {
761 opCode = resCmp -> sequence.op_code;
762 }
763 else
764 opCode = ssShrdPrm.stb[sId].opCode;
765
766 /* decode additional parameters of result */
767 if( resCmp -> v_sequence AND
768 resCmp -> sequence.params.l_params )
769 {
770 UBYTE ccdRet;
771
772 memcpy( ssFIEDecodeBuf, &resCmp -> sequence.params, MNCC_FACILITY_LEN);
773
774 ccdRet = ccd_decodeMsg (CCDENT_FAC,
775 DOWNLINK,
776 (T_MSGBUF *) ssFIEDecodeBuf,
777 (UBYTE *) _decodedMsg,
778 opCode);
779
780 if( ccdRet NEQ ccdOK )
781 {
782 /* Implements Measure#32: Row 1310 */
783 TRACE_EVENT_P1("CCD Decoding Error: %d", ccdRet );
784 cmhSS_SSResultFailure( sId );
785 return;
786 }
787 }
788
789 /* determine to which operation the result belongs to */
790 switch( opCode )
791 {
792 case( OPC_REGISTER_SS ):
793 {
794 MCAST( regSS, REGISTER_SS_RES );
795
796 cmhSS_SSRegistrated( sId, regSS );
797 }
798 break;
799
800 case( OPC_ERASE_SS ):
801 {
802 MCAST( ersSS, ERASE_SS_RES );
803
804 cmhSS_SSErased( sId, ersSS );
805 }
806 break;
807
808 case( OPC_ACTIVATE_SS ):
809 {
810 MCAST( actSS, ACTIVATE_SS_RES );
811
812 if( !(resCmp -> v_sequence) OR !(resCmp -> sequence.params.l_params) )
813 {
814 memset(actSS, 0, sizeof(T_ACTIVATE_SS_RES));
815 }
816 cmhSS_SSActivated( sId, actSS );
817 }
818 break;
819
820 case( OPC_DEACTIVATE_SS ):
821 {
822 MCAST( deactSS, DEACTIVATE_SS_RES );
823
824 cmhSS_SSDeactivated( sId, deactSS );
825 }
826 break;
827
828 case( OPC_INTERROGATE_SS ):
829 {
830 MCAST( irgtSS, INTERROGATE_SS_RES );
831
832 cmhSS_SSInterrogated( sId, irgtSS );
833 }
834 break;
835
836 case( OPC_REGISTER_PASSWORD ):
837 {
838 MCAST( regPWD, REGISTER_PWD_RES );
839
840 cmhSS_SSPWDRegistrated( sId, regPWD );
841 }
842 break;
843
844 case( OPC_PROC_UNSTRUCT_SS_DATA ):
845 {
846 MCAST( prcUSSDDat, PROCESS_USSD_RES );
847
848 cmhSS_USSDDatProcessed( sId, prcUSSDDat );
849 }
850 break;
851
852 case( OPC_PROC_UNSTRUCT_SS_REQ ):
853 {
854 MCAST( prcUSSDReq, PROCESS_USSD_REQ_RES );
855
856 cmhSS_USSDReqProcessed( sId, prcUSSDReq );
857 }
858 break;
859
860 case( OPC_ERASE_CC_ENTRY ):
861 {
862 MCAST( ersCCNtry, ERASE_CC_ENTRY_RES );
863
864 cmhSS_CCNtryErased( sId, ersCCNtry );
865 }
866 break;
867 }
868 }
869
870 /*
871 +-------------------------------------------------------------------+
872 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
873 | ROUTINE : psaSS_dasmErrorCmp |
874 +-------------------------------------------------------------------+
875
876 PURPOSE : disassemble the error component.
877 */
878
879 GLOBAL T_ACI_RETURN psaSS_dasmErrorCmp ( SHORT sId, T_err_comp *errCmp, BOOL is_fac_ussd )
880 {
881 TRACE_EVENT_P1("psaSS_dasmErrorCmp: errCmp: %02x",errCmp -> err_code);
882
883 if( errCmp -> v_err_code )
884 {
885 ssShrdPrm.stb[sId].failType = SSF_SS_ERR;
886 ssShrdPrm.stb[sId].errCd = errCmp -> err_code;
887
888
889 switch(errCmp -> err_code)
890 {
891 case ERR_PWD_REG_FAIL:
892 if( errCmp -> v_params AND errCmp -> params.l_params )
893 {
894 T_PW_REGISTRATION_FAILURE_ERR *pwRegFail;
895
896 pwRegFail = (T_PW_REGISTRATION_FAILURE_ERR *)errCmp -> params.b_params;
897
898 TRACE_EVENT_P1("VGK:Error reported %d", errCmp -> err_code);
899 TRACE_EVENT_P1("VGK:Error params %d", pwRegFail->pwRegistrationFailureCause);
900
901 if (pwRegFail->v_pwRegistrationFailureCause)
902 ssShrdPrm.stb[sId].errPrms = pwRegFail->pwRegistrationFailureCause;
903 }
904 break;
905
906 default:
907 break;
908 }
909
910 /* check for protocol incompatibility for USSD */
911 if( is_fac_ussd AND
912 errCmp -> err_code EQ ERR_FAC_NOT_SUPPORTED )
913 {
914 if( psaSS_asmUSSDProt1(sId) )
915 {
916 return( AT_CMPL );
917 }
918 }
919
920 }
921 return( AT_FAIL );
922 }
923
924 /*
925 +-------------------------------------------------------------------+
926 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
927 | ROUTINE : psaSS_dasmRejectCmp |
928 +-------------------------------------------------------------------+
929
930 PURPOSE : disassemble the error component.
931 */
932
933 GLOBAL T_ACI_RETURN psaSS_dasmRejectCmp ( SHORT sId, T_rej_comp *rejCmp, BOOL is_fac_ussd )
934 {
935 TRACE_FUNCTION("psaSS_dasmRejectCmp");
936
937 if( rejCmp -> v_gen_problem )
938 {
939 ssShrdPrm.stb[sId].failType = SSF_GEN_PRB;
940 ssShrdPrm.stb[sId].rejPrb = rejCmp -> gen_problem;
941 }
942
943 else if( rejCmp -> v_inv_problem )
944 {
945 ssShrdPrm.stb[sId].failType = SSF_INV_PRB;
946 ssShrdPrm.stb[sId].rejPrb = rejCmp -> inv_problem;
947
948 /* check for protocol incompatibility for USSD */
949 if( is_fac_ussd AND
950 rejCmp -> inv_problem EQ INV_PROB_UNRECOG_OP )
951 {
952 if( psaSS_asmUSSDProt1(sId) )
953 {
954 return( AT_CMPL );
955 }
956 }
957 }
958
959 else if( rejCmp -> v_res_problem )
960 {
961 ssShrdPrm.stb[sId].failType = SSF_RSL_PRB;
962 ssShrdPrm.stb[sId].rejPrb = rejCmp -> res_problem;
963 }
964
965 else if( rejCmp -> v_err_problem )
966 {
967 ssShrdPrm.stb[sId].failType = SSF_ERR_PRB;
968 ssShrdPrm.stb[sId].rejPrb = rejCmp -> err_problem;
969 }
970 return( AT_FAIL );
971 }
972
973 /*
974 +-------------------------------------------------------------------+
975 | PROJECT : GSM-PS (6147) MODULE : PSA_SATF |
976 | ROUTINE : psaSAT_ss_end_ind |
977 +-------------------------------------------------------------------+
978
979 PURPOSE : handles responses to user after a SS.
980 is_fac_ussd TRUE if facility is a USSD
981 */
982
983 GLOBAL T_ACI_RETURN psaSS_ss_end_ind ( SHORT sId, T_COMPONENT *com, BOOL is_fac_ussd )
984 {
985 if( com->v_res_comp )
986 {
987 psaSS_dasmResultCmp( sId, &com->res_comp );
988 return( AT_EXCT );
989 }
990
991 if( com->v_err_comp )
992 {
993 return(psaSS_dasmErrorCmp( sId, &com->err_comp, is_fac_ussd ));
994 }
995
996 if( com->v_rej_comp )
997 {
998 return(psaSS_dasmRejectCmp( sId, &com->rej_comp, is_fac_ussd ));
999 }
1000
1001 TRACE_EVENT( "WRONG COMPONENT TYPE RECEIVED" );
1002 return(AT_FAIL);
1003 }
1004
1005 /*
1006 +-------------------------------------------------------------------+
1007 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1008 | ROUTINE : psaSS_stbNewEntry |
1009 +-------------------------------------------------------------------+
1010
1011 PURPOSE : returns the service table index for a free entry to be
1012 used, otherwise the function returns -1 to indicate that
1013 no entry is free.
1014 */
1015
1016 GLOBAL SHORT psaSS_stbNewEntry ( void )
1017 {
1018 SHORT stbIdx; /* holds service table index */
1019
1020 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx++ )
1021 {
1022 if( (ssShrdPrm.stb[stbIdx].ntryUsdFlg EQ FALSE) OR
1023 (ssShrdPrm.stb[stbIdx].srvStat EQ SSS_IDL) )
1024 {
1025 psaSS_InitStbNtry( stbIdx );
1026
1027 return( stbIdx );
1028 }
1029 }
1030
1031 return( -1 );
1032 }
1033
1034 /*
1035 +-------------------------------------------------------------------+
1036 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1037 | ROUTINE : psaSS_stbFindTi |
1038 +-------------------------------------------------------------------+
1039
1040 PURPOSE : returns the service table index for the entry that holds
1041 service parameters for the passed transaction identifier.
1042 Returning -1 indicates that the passed ti was not found.
1043 */
1044
1045 GLOBAL SHORT psaSS_stbFindTi ( UBYTE ti2Find )
1046 {
1047 SHORT stbIdx; /* holds service table index */
1048
1049 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx++ )
1050 {
1051 if( ssShrdPrm.stb[stbIdx].ti EQ ti2Find )
1052
1053 return( stbIdx );
1054 }
1055
1056 return( -1 );
1057 }
1058
1059 /*
1060 +-------------------------------------------------------------------+
1061 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1062 | ROUTINE : psaSS_stbFindInvId |
1063 +-------------------------------------------------------------------+
1064
1065 PURPOSE : returns the service table index for the entry that holds
1066 service parameters for the passed invoke id.
1067 Returning -1 indicates that the passed ti was not found.
1068 */
1069
1070 GLOBAL SHORT psaSS_stbFindInvId ( UBYTE iId2Find )
1071 {
1072 SHORT stbIdx; /* holds service table index */
1073
1074 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx++ )
1075 {
1076 if( ssShrdPrm.stb[stbIdx].ntryUsdFlg EQ TRUE AND
1077 ssShrdPrm.stb[stbIdx].iId EQ iId2Find )
1078
1079 return( stbIdx );
1080 }
1081
1082 return( -1 );
1083 }
1084
1085 /*
1086 +-------------------------------------------------------------------+
1087 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1088 | ROUTINE : psaSS_chgSrvTypCnt |
1089 +-------------------------------------------------------------------+
1090
1091 PURPOSE : this function modifies the service type counter (MOS/MTS)
1092 defined by the passed service id by the passed delta value.
1093 */
1094
1095 GLOBAL void psaSS_chngSrvTypCnt ( SHORT sId, SHORT dlt )
1096 {
1097
1098 switch( ssShrdPrm.stb[sId].srvType )
1099 {
1100 case( ST_MOS ):
1101
1102 ssShrdPrm.nrOfMOS += dlt;
1103
1104 if( ssShrdPrm.nrOfMOS < 0 ) ssShrdPrm.nrOfMOS = 0;
1105
1106 break;
1107
1108 case( ST_MTS ):
1109
1110 ssShrdPrm.nrOfMTS += dlt;
1111
1112 if( ssShrdPrm.nrOfMTS < 0 ) ssShrdPrm.nrOfMTS = 0;
1113
1114 break;
1115
1116 default:
1117
1118 TRACE_EVENT( "UNEXP SERVICE TYPE IN STB" );
1119 }
1120 }
1121
1122 /*
1123 +-------------------------------------------------------------------+
1124 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1125 | ROUTINE : psaSS_getMOSTi |
1126 +-------------------------------------------------------------------+
1127
1128 PURPOSE : this function selects a ti out of a pool of valid ti's
1129 and inserts it into the passed service table entry. if no
1130 ti is available the function returns -1.
1131 a bit of the pool stands for a valid ti.
1132 0 indicates a used ti, 1 indicates a free ti.
1133 */
1134
1135 GLOBAL SHORT psaSS_getMOSTi( SHORT sId )
1136 {
1137 UBYTE idx; /* holds pool idx */
1138
1139 for( idx = 0; idx < MAX_MOSTI_NR; idx++ )
1140 {
1141 if( tiPool & (1u << idx) )
1142 {
1143 tiPool &= ~(1u << idx);
1144 ssShrdPrm.stb[sId].ti = idx;
1145 return( 0 );
1146 }
1147 }
1148 return( -1 );
1149 }
1150
1151 /*
1152 +-------------------------------------------------------------------+
1153 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1154 | ROUTINE : psaSS_retMOSTi |
1155 +-------------------------------------------------------------------+
1156
1157 PURPOSE : this function returns a used ti to the ti pool if the
1158 call was a MOS. the ti is free for the next MOS
1159 afterwards.
1160 a bit of the pool stands for a valid ti.
1161 0 indicates a used ti, 1 indicates a free ti.
1162 */
1163
1164 GLOBAL void psaSS_retMOSTi( SHORT sId )
1165 {
1166 if( ssShrdPrm.stb[sId].srvType EQ ST_MOS )
1167
1168 if( ssShrdPrm.stb[sId].ti < MAX_MOSTI_NR )
1169
1170 tiPool |= (0x01 << ssShrdPrm.stb[sId].ti);
1171 }
1172
1173 /*
1174 +-------------------------------------------------------------------+
1175 | PROJECT : GSM-PS (6147) MODULE : PSA_SS |
1176 | ROUTINE : psaSS_InitStbNtry |
1177 +-------------------------------------------------------------------+
1178
1179 PURPOSE : initialize the indexed service table entry.
1180
1181 */
1182
1183 GLOBAL void psaSS_InitStbNtry ( SHORT idx )
1184 {
1185
1186 /*
1187 *-------------------------------------------------------------------
1188 * initialize call table entry
1189 *-------------------------------------------------------------------
1190 */
1191 ssShrdPrm.stb[idx].ntryUsdFlg = FALSE;
1192 ssShrdPrm.stb[idx].ti = (UBYTE)-1; /* NO_ENTRY is -1 and ti where is is assigning is UBYTE,so typecast with UBYTE */
1193 ssShrdPrm.stb[idx].iId = 0;
1194 ssShrdPrm.stb[idx].srvStat = NO_VLD_SSS;
1195 ssShrdPrm.stb[idx].srvType = NO_VLD_ST;
1196 ssShrdPrm.stb[idx].orgOPC = NOT_PRESENT_8BIT;
1197 ssShrdPrm.stb[idx].opCode = NOT_PRESENT_8BIT;
1198 ssShrdPrm.stb[idx].ssCode = NOT_PRESENT_8BIT;
1199 ssShrdPrm.stb[idx].ussdReqFlg = FALSE;
1200 ssShrdPrm.stb[idx].failType = NO_VLD_SSF;
1201 ssShrdPrm.stb[idx].entCs = NOT_PRESENT_16BIT;
1202 ssShrdPrm.stb[idx].rejPrb = NOT_PRESENT_8BIT;
1203 ssShrdPrm.stb[idx].errCd = NOT_PRESENT_8BIT;
1204 ssShrdPrm.stb[idx].errPrms = NOT_PRESENT_8BIT;
1205 ssShrdPrm.stb[idx].curCmd = AT_CMD_NONE;
1206 ssShrdPrm.stb[idx].srvOwn = (T_OWN)CMD_SRC_NONE;
1207 ssShrdPrm.stb[idx].SSver = DEF_SS_VER;
1208 ssShrdPrm.stb[idx].ussd_operation = FALSE;
1209 }
1210
1211 /*
1212 +-------------------------------------------------------------------+
1213 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1214 | ROUTINE : psaSS_stbFindUssdReq |
1215 +-------------------------------------------------------------------+
1216
1217 PURPOSE : returns the service table index for the entry that has a
1218 USSD request pending.
1219 Returning -1 indicates that no such service was found.
1220 */
1221
1222 GLOBAL SHORT psaSS_stbFindUssdReq ( void )
1223 {
1224 SHORT stbIdx; /* holds call table index */
1225
1226 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx++ )
1227 {
1228 if( ssShrdPrm.stb[stbIdx].ntryUsdFlg EQ TRUE AND
1229 ssShrdPrm.stb[stbIdx].ussdReqFlg EQ TRUE AND
1230 ssShrdPrm.stb[stbIdx].srvStat EQ SSS_ACT )
1231 {
1232 return( stbIdx );
1233 }
1234 }
1235
1236 return( -1 );
1237 }
1238
1239 /*
1240 +-------------------------------------------------------------------+
1241 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1242 | ROUTINE : psaSS_stbFindActSrv |
1243 +-------------------------------------------------------------------+
1244
1245 PURPOSE : returns the service table index for the first entry that
1246 holds an active service which is not the passed index.
1247 Returning -1 indicates that no active service was found.
1248 */
1249
1250 GLOBAL SHORT psaSS_stbFindActSrv ( SHORT sId )
1251 {
1252 SHORT stbIdx; /* holds call table index */
1253
1254 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx++ )
1255 {
1256 if( ssShrdPrm.stb[stbIdx].ntryUsdFlg EQ TRUE AND
1257 ssShrdPrm.stb[stbIdx].srvStat EQ SSS_ACT )
1258 {
1259 if( stbIdx NEQ sId )
1260
1261 return( stbIdx );
1262 }
1263 }
1264
1265 return( -1 );
1266 }
1267
1268 /*
1269 +-------------------------------------------------------------------+
1270 | PROJECT : GSM-PS (6147) MODULE : PSA_SS |
1271 | ROUTINE : psaSS_Init |
1272 +-------------------------------------------------------------------+
1273
1274 PURPOSE : initialize the protocol stack adapter for SS.
1275
1276 */
1277
1278 GLOBAL void psaSS_Init ( void )
1279 {
1280 UBYTE stbIdx; /* holds index to service table */
1281
1282 /*
1283 *-------------------------------------------------------------------
1284 * initialize service table
1285 *-------------------------------------------------------------------
1286 */
1287 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx++ )
1288 {
1289 psaSS_InitStbNtry( stbIdx );
1290 }
1291
1292 /*
1293 *-------------------------------------------------------------------
1294 * initialize shared parameter
1295 *-------------------------------------------------------------------
1296 */
1297 ssShrdPrm.nrOfMOS = 0;
1298 ssShrdPrm.nrOfMTS = 0;
1299 ssShrdPrm.iIdNxt = 0;
1300 }
1301
1302 /*
1303 +-------------------------------------------------------------------+
1304 | PROJECT : GSM-PS (6147) MODULE : PSA_SS |
1305 | ROUTINE : psaSS_DumpFIE |
1306 +-------------------------------------------------------------------+
1307
1308 PURPOSE : Dump facility information element to debug output.
1309
1310 */
1311
1312 GLOBAL void psaSS_DumpFIE ( T_fac_inf * fie )
1313 {
1314
1315 CHAR strBuf[40+1]; /* holds string buffer */
1316 UBYTE idx, cnt, mcnt; /* buffer index */
1317 CHAR *pDest; /* points to destination */
1318
1319 /*
1320 *-------------------------------------------------------------------
1321 * format FIE
1322 *-------------------------------------------------------------------
1323 */
1324 TRACE_EVENT( "FIE SENT/RECEIVED:" );
1325
1326 mcnt = fie->l_fac >> 3;
1327
1328 if( mcnt EQ 0 )
1329 {
1330 TRACE_EVENT("Empty Facility");
1331 return;
1332 }
1333
1334 for( cnt = 0; cnt < mcnt; cnt+=idx )
1335 {
1336 pDest = strBuf;
1337
1338 for( idx = 0; idx < 20 AND idx+cnt < mcnt; idx++ )
1339 {
1340 /* Implements Measure#32: Row 1312 */
1341 pDest += sprintf( pDest, format_2X_str, (UBYTE)fie->fac[idx+cnt] );
1342 }
1343
1344 *pDest = 0x0;
1345
1346 TRACE_EVENT( strBuf );
1347 }
1348 }
1349
1350 /*
1351 +-------------------------------------------------------------------+
1352 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1353 | ROUTINE : psaSS_stbDump |
1354 +-------------------------------------------------------------------+
1355
1356 PURPOSE : this function dumps the service table to the debug output.
1357 */
1358
1359 GLOBAL void psaSS_stbDump ( void )
1360 {
1361 #ifdef TRACING
1362
1363 SHORT stbIdx; /* holds service table index */
1364 char lnBuf[HDR_WDT+(MAX_ITM*ITM_WDT)+1]; /* holds buffer for output line */
1365 char verBuf[VERSION_LEN+1]; /* holds buffer for SS version */
1366 SHORT itmIdx; /* holds items per line index */
1367 SHORT chrNr; /* holds number of processed chars */
1368
1369 for( stbIdx = 0; stbIdx < MAX_SS_NR; stbIdx+=MAX_ITM )
1370 {
1371 /* --- service id ----------------------------------------------------------*/
1372 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, " srv id");
1373
1374 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx+stbIdx<MAX_SS_NR); itmIdx++ )
1375 {
1376 chrNr += sprintf( lnBuf+chrNr, "%*d", ITM_WDT, stbIdx + itmIdx );
1377 }
1378 TRACE_EVENT( lnBuf );
1379
1380 /* --- entry used flag -----------------------------------------------------*/
1381 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, "entry used" );
1382
1383 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1384 {
1385 chrNr += sprintf( lnBuf+chrNr, "%*hd", ITM_WDT,
1386 ssShrdPrm.stb[stbIdx+itmIdx].ntryUsdFlg );
1387 }
1388 TRACE_EVENT( lnBuf );
1389
1390 /* --- transaction identifier ----------------------------------------------*/
1391 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, " ti" );
1392
1393 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1394 {
1395 chrNr += sprintf( lnBuf+chrNr, "%*hd", ITM_WDT,
1396 ssShrdPrm.stb[stbIdx+itmIdx].ti );
1397 }
1398 TRACE_EVENT( lnBuf );
1399
1400 /* --- service status ------------------------------------------------------*/
1401 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, "srv status" );
1402
1403 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1404 {
1405 chrNr += sprintf( lnBuf+chrNr, "%*hd", ITM_WDT,
1406 ssShrdPrm.stb[stbIdx+itmIdx].srvStat );
1407 }
1408 TRACE_EVENT( lnBuf );
1409
1410 /* --- service type --------------------------------------------------------*/
1411 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, " srv type" );
1412
1413 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1414 {
1415 chrNr += sprintf( lnBuf+chrNr, "%*hd", ITM_WDT,
1416 ssShrdPrm.stb[stbIdx+itmIdx].srvType );
1417 }
1418 TRACE_EVENT( lnBuf );
1419
1420 /* --- SS version ----------------------------------------------------------*/
1421 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, "SS version" );
1422
1423 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1424 {
1425 chrNr += sprintf( lnBuf+chrNr, "%*d", ITM_WDT,
1426 ssShrdPrm.stb[stbIdx+itmIdx].SSver );
1427 }
1428 TRACE_EVENT( lnBuf );
1429
1430 /* --- failure type ------------------------------------------------------*/
1431 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, "fail. type" );
1432
1433 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1434 {
1435 chrNr += sprintf( lnBuf+chrNr, "%*d", ITM_WDT,
1436 ssShrdPrm.stb[stbIdx+itmIdx].failType );
1437 }
1438 TRACE_EVENT( lnBuf );
1439
1440 /* --- entity cause ------------------------------------------------------*/
1441 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, "ent. cause" );
1442
1443 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1444 {
1445 chrNr += sprintf( lnBuf+chrNr, "%*d", ITM_WDT,
1446 ssShrdPrm.stb[stbIdx+itmIdx].entCs );
1447 }
1448 TRACE_EVENT( lnBuf );
1449
1450 /* --- reject problem ----------------------------------------------------*/
1451 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, " rej. prob" );
1452
1453 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1454 {
1455 chrNr += sprintf( lnBuf+chrNr, "%*hd", ITM_WDT,
1456 ssShrdPrm.stb[stbIdx+itmIdx].rejPrb );
1457 }
1458 TRACE_EVENT( lnBuf );
1459
1460 /* --- error code ----------------------------------------------------*/
1461 chrNr = sprintf( lnBuf, "%*.*s", HDR_WDT, HDR_WDT, " err. code" );
1462
1463 for( itmIdx = 0; (itmIdx<MAX_ITM)AND(itmIdx<MAX_SS_NR); itmIdx++ )
1464 {
1465 chrNr += sprintf( lnBuf+chrNr, "%*hd", ITM_WDT,
1466 ssShrdPrm.stb[stbIdx+itmIdx].errCd );
1467 }
1468 TRACE_EVENT( lnBuf );
1469
1470 }
1471
1472 #endif /* of #ifdef TRACING */
1473 }
1474 /*
1475 +-------------------------------------------------------------------+
1476 | PROJECT : GSM-PS (6147) MODULE : CMH_F |
1477 | ROUTINE : psaSS_GetPendingTrn |
1478 +-------------------------------------------------------------------+
1479
1480 PURPOSE : Find Id of a pending call for multy-transaction operation
1481
1482 */
1483
1484 GLOBAL SHORT psaSS_GetPendingTrn ( void )
1485 {
1486 SHORT bit_len;
1487 SHORT i;
1488
1489 bit_len = 8 * sizeof(ssShrdPrm.mltyTrnFlg);
1490 for (i = 0; i < bit_len; i++)
1491 {
1492 if ( ssShrdPrm.mltyTrnFlg & ( 0x1 << i ) )
1493 return i;
1494 }
1495
1496 return -1;
1497 }
1498
1499 GLOBAL void psaSS_KillAllPendingTrn ( void ) /* sId: main transaction: not to be killed */
1500 {
1501 SHORT pending_idx;
1502
1503 TRACE_FUNCTION("psaSS_KillAllPendingTrn( )");
1504
1505 while ( ssShrdPrm.mltyTrnFlg )
1506 {
1507 pending_idx = psaSS_GetPendingTrn( );
1508 ssShrdPrm.mltyTrnFlg &= ~( 1u << pending_idx ); /* unsent id flag */
1509
1510 ssShrdPrm.stb[ pending_idx ].ntryUsdFlg = FALSE; /* free entry in ss table */
1511 ssShrdPrm.stb[ pending_idx ].srvStat = NO_VLD_SSS; /* not sure if it's necessary...? */
1512
1513 PFREE( ssShrdPrm.stb[pending_idx].save_prim ); /* free pending primitive */
1514 }
1515 }
1516
1517 /* Implements Measure # 195 */
1518 /*
1519 +-------------------------------------------------------------------+
1520 | PROJECT : GSM-PS (6147) MODULE : PSA_SSF |
1521 | ROUTINE : psaSS_asmEraseSS |
1522 +-------------------------------------------------------------------+
1523
1524 PURPOSE : Assemble the erase, activate and deactivate SS facility
1525 information element.
1526
1527 */
1528
1529 LOCAL void psaSS_asmSSForBS ( UBYTE ssCode, UBYTE bscSrvType,
1530 UBYTE bscSrv, T_ssForBS *ssForBS)
1531 {
1532
1533 TRACE_FUNCTION("psaSS_asmSSForBS( )");
1534
1535 /* set service code */
1536 ssForBS->v_ssCode = TRUE;
1537 ssForBS->ssCode = ssCode;
1538
1539 /* set basic service type */
1540 switch( bscSrvType )
1541 {
1542 case( BS_BEAR_SRV ):
1543
1544 ssForBS->basicService.v_bearerService = TRUE;
1545 ssForBS->basicService.bearerService = bscSrv;
1546 break;
1547
1548 case( BS_TELE_SRV ):
1549
1550 ssForBS->basicService.v_teleservice = TRUE;
1551 ssForBS->basicService.teleservice = bscSrv;
1552 break;
1553 }
1554
1555 memset( &ssFIECodeBuf, 0, sizeof( ssFIECodeBuf ));
1556 ssFIECodeBuf.l_buf = MAX_FIE_CODE_BUF_LEN<<3;
1557 ccd_codeMsg (CCDENT_FAC, UPLINK,
1558 (T_MSGBUF *)&ssFIECodeBuf, _decodedMsg,
1559 NOT_PRESENT_8BIT);
1560
1561 ssShrdPrm.cmpType = CT_INV;
1562
1563 }
1564
1565 /*==== EOF ========================================================*/
1566