This source file includes following definitions.
- copy_cgPtyNum_from_sngss7
- copy_cgPtyNum_to_sngss7
- copy_cdPtyNum_from_sngss7
- copy_cdPtyNum_to_sngss7
- copy_tknStr_from_sngss7
- check_for_state_change
- check_cics_in_range
- extract_chan_data
- check_for_reset
- get_unique_id
- check_if_rx_grs_started
- check_if_rx_grs_processed
- check_if_rx_gra_started
- check_for_res_sus_flag
- process_span_ucic
- clear_rx_grs_flags
- clear_rx_grs_data
- clear_rx_gra_data
- clear_tx_grs_flags
- clear_tx_grs_data
- clear_rx_rsc_flags
- clear_tx_rsc_flags
- encode_subAddrIE_nsap
- encode_subAddrIE_nat
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35 #include "ftmod_sangoma_ss7_main.h"
36
37
38
39
40
41
42 uint32_t sngss7_id;
43
44
45
46 uint8_t copy_tknStr_from_sngss7(TknStr str, char *ftdm, TknU8 oddEven);
47 uint8_t copy_cgPtyNum_from_sngss7(ftdm_caller_data_t *ftdm, SiCgPtyNum *cgPtyNum);
48 uint8_t copy_cgPtyNum_to_sngss7(ftdm_caller_data_t *ftdm, SiCgPtyNum *cgPtyNum);
49 uint8_t copy_cdPtyNum_from_sngss7(ftdm_caller_data_t *ftdm, SiCdPtyNum *cdPtyNum);
50 uint8_t copy_cdPtyNum_to_sngss7(ftdm_caller_data_t *ftdm, SiCdPtyNum *cdPtyNum);
51
52 int check_for_state_change(ftdm_channel_t *ftdmchan);
53 int check_cics_in_range(sngss7_chan_data_t *sngss7_info);
54 int check_for_reset(sngss7_chan_data_t *sngss7_info);
55
56 unsigned long get_unique_id(void);
57
58 ftdm_status_t extract_chan_data(uint32_t circuit, sngss7_chan_data_t **sngss7_info, ftdm_channel_t **ftdmchan);
59
60 ftdm_status_t check_if_rx_grs_started(ftdm_span_t *ftdmspan);
61 ftdm_status_t check_if_rx_grs_processed(ftdm_span_t *ftdmspan);
62 ftdm_status_t check_if_rx_gra_started(ftdm_span_t *ftdmspan);
63 ftdm_status_t check_for_res_sus_flag(ftdm_span_t *ftdmspan);
64
65 ftdm_status_t process_span_ucic(ftdm_span_t *ftdmspan);
66
67 ftdm_status_t clear_rx_grs_flags(sngss7_chan_data_t *sngss7_info);
68 ftdm_status_t clear_tx_grs_flags(sngss7_chan_data_t *sngss7_info);
69 ftdm_status_t clear_rx_rsc_flags(sngss7_chan_data_t *sngss7_info);
70 ftdm_status_t clear_tx_rsc_flags(sngss7_chan_data_t *sngss7_info);
71 ftdm_status_t clear_rx_grs_data(sngss7_chan_data_t *sngss7_info);
72 ftdm_status_t clear_rx_gra_data(sngss7_chan_data_t *sngss7_info);
73 ftdm_status_t clear_tx_grs_data(sngss7_chan_data_t *sngss7_info);
74
75 ftdm_status_t encode_subAddrIE_nsap(const char *subAddr, char *subAddrIE, int type);
76 ftdm_status_t encode_subAddrIE_nat(const char *subAddr, char *subAddrIE, int type);
77
78
79
80 uint8_t copy_cgPtyNum_from_sngss7(ftdm_caller_data_t *ftdm, SiCgPtyNum *cgPtyNum)
81 {
82
83 return 0;
84 }
85
86
87 uint8_t copy_cgPtyNum_to_sngss7(ftdm_caller_data_t *ftdm, SiCgPtyNum *cgPtyNum)
88 {
89 int k;
90 int j;
91 int flag;
92 int odd;
93 char tmp[2];
94 uint8_t lower;
95 uint8_t upper;
96
97
98 cgPtyNum->eh.pres = PRSNT_NODEF;
99
100 cgPtyNum->natAddrInd.pres = PRSNT_NODEF;
101 cgPtyNum->natAddrInd.val = 0x03;
102
103 cgPtyNum->scrnInd.pres = PRSNT_NODEF;
104 cgPtyNum->scrnInd.val = ftdm->screen;
105
106 cgPtyNum->presRest.pres = PRSNT_NODEF;
107 cgPtyNum->presRest.val = ftdm->pres;
108
109 cgPtyNum->numPlan.pres = PRSNT_NODEF;
110 cgPtyNum->numPlan.val = 0x01;
111
112 cgPtyNum->niInd.pres = PRSNT_NODEF;
113 cgPtyNum->niInd.val = 0x00;
114
115 cgPtyNum->addrSig.pres = PRSNT_NODEF;
116
117
118
119
120
121 tmp[1] = '\0';
122 k = 0;
123 j = 0;
124 flag = 0;
125 odd = 0;
126 upper = 0x0;
127 lower = 0x0;
128
129 while (1) {
130
131 tmp[0] = ftdm->cid_num.digits[k];
132
133
134 while (!(isdigit(tmp[0])) && (tmp[0] != '\0')) {
135
136 k++;
137 tmp[0] = ftdm->cid_num.digits[k];
138 }
139
140
141 if (tmp[0] != '\0') {
142
143 lower = atoi(&tmp[0]);
144
145 k++;
146
147 tmp[0] = ftdm->cid_num.digits[k];
148
149
150 while (!(isdigit(tmp[0])) && (tmp[0] != '\0')) {
151 k++;
152 tmp[0] = ftdm->cid_num.digits[k];
153 }
154
155
156 if (tmp[0] != '\0') {
157
158 upper = (atoi(&tmp[0])) << 4;
159 } else {
160
161 upper = 0x0;
162
163 odd = 1;
164
165 flag = 1;
166 }
167 } else {
168
169 odd = 0;
170
171 break;
172 }
173
174
175 cgPtyNum->addrSig.val[j] = upper | lower;
176
177
178 j++;
179
180
181 if (flag) break;
182
183
184 k++;
185 }
186
187 cgPtyNum->addrSig.len = j;
188
189
190 cgPtyNum->oddEven.pres = PRSNT_NODEF;
191 cgPtyNum->oddEven.val = odd;
192
193 return 0;
194 }
195
196
197 uint8_t copy_cdPtyNum_from_sngss7(ftdm_caller_data_t *ftdm, SiCdPtyNum *cdPtyNum)
198 {
199
200 return 0;
201 }
202
203
204 uint8_t copy_cdPtyNum_to_sngss7(ftdm_caller_data_t *ftdm, SiCdPtyNum *cdPtyNum)
205 {
206 int k;
207 int j;
208 int flag;
209 int odd;
210 char tmp[2];
211 uint8_t lower;
212 uint8_t upper;
213
214
215 cdPtyNum->eh.pres = PRSNT_NODEF;
216
217 cdPtyNum->natAddrInd.pres = PRSNT_NODEF;
218 cdPtyNum->natAddrInd.val = 0x03;
219
220 cdPtyNum->numPlan.pres = PRSNT_NODEF;
221 cdPtyNum->numPlan.val = 0x01;
222
223 cdPtyNum->innInd.pres = PRSNT_NODEF;
224 cdPtyNum->innInd.val = 0x01;
225
226 cdPtyNum->addrSig.pres = PRSNT_NODEF;
227
228
229
230
231
232 tmp[1] = '\0';
233 k = 0;
234 j = 0;
235 flag = 0;
236 odd = 0;
237 upper = 0x0;
238 lower = 0x0;
239
240 while (1) {
241
242 tmp[0] = ftdm->dnis.digits[k];
243
244
245 while (!(isdigit(tmp[0])) && (tmp[0] != '\0')) {
246
247 k++;
248 tmp[0] = ftdm->dnis.digits[k];
249 }
250
251
252 if (tmp[0] != '\0') {
253
254 lower = atoi(&tmp[0]);
255
256 k++;
257
258 tmp[0] = ftdm->dnis.digits[k];
259
260
261 while (!(isdigit(tmp[0])) && (tmp[0] != '\0')) {
262 k++;
263 tmp[0] = ftdm->dnis.digits[k];
264 }
265
266
267 if (tmp[0] != '\0') {
268
269 upper = (atoi(&tmp[0])) << 4;
270 } else {
271
272 upper = 0xF0;
273
274 odd = 0;
275
276 flag = 1;
277 }
278 } else {
279
280 odd = 1;
281
282 lower = 0xF;
283 upper = 0x0;
284
285 flag = 1;
286 }
287
288
289 cdPtyNum->addrSig.val[j] = upper | lower;
290
291
292 j++;
293
294
295 if (flag) break;
296
297
298 k++;
299 }
300
301 cdPtyNum->addrSig.len = j;
302
303
304 cdPtyNum->oddEven.pres = PRSNT_NODEF;
305
306 cdPtyNum->oddEven.val = odd;
307
308
309 return 0;
310 }
311
312
313 uint8_t copy_tknStr_from_sngss7(TknStr str, char *ftdm, TknU8 oddEven)
314 {
315 uint8_t i;
316 uint8_t j;
317
318
319
320 if (str.pres == 1) {
321 j = 0;
322
323 for (i = 0; i < str.len; i++) {
324 sprintf(&ftdm[j], "%X", (str.val[i] & 0x0F));
325 j++;
326 sprintf(&ftdm[j], "%X", ((str.val[i] & 0xF0) >> 4));
327 j++;
328 }
329
330
331 if ((oddEven.pres == 1) && (oddEven.val == 1)) {
332 ftdm[j-1] = '\0';
333 } else {
334 ftdm[j] = '\0';
335 }
336
337
338 } else {
339 SS7_ERROR("Asked to copy tknStr that is not present!\n");
340 return 1;
341 }
342
343 return 0;
344 }
345
346
347 int check_for_state_change(ftdm_channel_t *ftdmchan)
348 {
349
350
351 ftdm_wait_for_flag_cleared(ftdmchan, FTDM_CHANNEL_STATE_CHANGE, 500);
352
353
354
355 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
356
357 SS7_DEBUG_CHAN(ftdmchan, "FTDM_CHANNEL_STATE_CHANGE flag set for over 500ms, channel state = %s\n",
358 ftdm_channel_state2str (ftdmchan->state));
359
360 return 1;
361 }
362
363 return 0;
364 }
365
366
367 int check_cics_in_range(sngss7_chan_data_t *sngss7_info)
368 {
369
370
371 #if 0
372 ftdm_channel_t *tmp_ftdmchan;
373 sngss7_chan_data_t *tmp_sngss7_info;
374 int i = 0;
375
376
377 for ( i = sngss7_info->grs.circuit; i < ( sngss7_info->grs.range + 1 ); i++ ) {
378 if ( g_ftdm_sngss7_data.cfg.isupCircuit[i].siglink == 0 ) {
379
380
381 if (extract_chan_data(g_ftdm_sngss7_data.cfg.isupCircuit[i].id, &tmp_sngss7_info, &tmp_ftdmchan)) {
382 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", g_ftdm_sngss7_data.cfg.isupCircuit[i].id);
383 return 0;
384 }
385
386
387 if (!sngss7_test_flag(tmp_sngss7_info, FLAG_GRP_RESET_RX_DN)) {
388 SS7_DEBUG_CHAN(tmp_ftdmchan, "[CIC:%d] Still processing reset...\n", tmp_sngss7_info->circuit->cic);
389 return 0;
390 }
391 }
392 }
393
394 SS7_DEBUG("All circuits out of reset: circuit=%d, range=%d\n",
395 sngss7_info->grs.circuit,
396 sngss7_info->grs.range);
397 return 1;
398
399 #endif
400
401 return 0;
402
403 }
404
405
406 ftdm_status_t extract_chan_data(uint32_t circuit, sngss7_chan_data_t **sngss7_info, ftdm_channel_t **ftdmchan)
407 {
408
409
410 if (g_ftdm_sngss7_data.cfg.isupCkt[circuit].obj == NULL) {
411 SS7_ERROR("sngss7_info is Null for circuit #%d\n", circuit);
412 return FTDM_FAIL;
413 }
414
415 ftdm_assert_return(g_ftdm_sngss7_data.cfg.isupCkt[circuit].obj, FTDM_FAIL, "received message on signalling link or non-configured cic\n");
416
417 *sngss7_info = g_ftdm_sngss7_data.cfg.isupCkt[circuit].obj;
418
419 ftdm_assert_return((*sngss7_info)->ftdmchan, FTDM_FAIL, "received message on signalling link or non-configured cic\n");
420 *ftdmchan = (*sngss7_info)->ftdmchan;
421
422
423 return FTDM_SUCCESS;
424 }
425
426
427 int check_for_reset(sngss7_chan_data_t *sngss7_info)
428 {
429
430 if (sngss7_test_flag(sngss7_info,FLAG_RESET_RX)) {
431 return 1;
432 }
433
434 if (sngss7_test_flag(sngss7_info,FLAG_RESET_TX)) {
435 return 1;
436 }
437
438 if (sngss7_test_flag(sngss7_info,FLAG_GRP_RESET_RX)) {
439 return 1;
440 }
441
442 if (sngss7_test_flag(sngss7_info,FLAG_GRP_RESET_TX)) {
443 return 1;
444 }
445
446 return 0;
447
448 }
449
450
451 unsigned long get_unique_id(void)
452 {
453
454 if (sngss7_id < 420000000) {
455 sngss7_id++;
456 } else {
457 sngss7_id = 1;
458 }
459
460 return(sngss7_id);
461 }
462
463
464 ftdm_status_t check_if_rx_grs_started(ftdm_span_t *ftdmspan)
465 {
466 ftdm_channel_t *ftdmchan = NULL;
467 sngss7_chan_data_t *sngss7_info = NULL;
468 sngss7_span_data_t *sngss7_span = (sngss7_span_data_t *)ftdmspan->mod_data;
469 int i;
470
471 for ( i = sngss7_span->rx_grs.circuit; i < (sngss7_span->rx_grs.circuit + sngss7_span->rx_grs.range + 1); i++) {
472
473
474 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
475 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", i);
476 continue;
477 }
478
479
480 if (sngss7_test_flag(sngss7_info, FLAG_GRP_RESET_RX)) {
481
482 continue;
483 }
484
485
486 ftdm_mutex_lock(ftdmchan->mutex);
487
488
489 while (ftdm_test_flag (ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
490 ftdm_sangoma_ss7_process_state_change (ftdmchan);
491 }
492
493 SS7_INFO_CHAN(ftdmchan, "Rx GRS (%d:%d)\n",
494 g_ftdm_sngss7_data.cfg.isupCkt[sngss7_span->rx_grs.circuit].cic,
495 (g_ftdm_sngss7_data.cfg.isupCkt[sngss7_span->rx_grs.circuit].cic + sngss7_span->rx_grs.range));
496
497
498 sngss7_set_flag(sngss7_info, FLAG_GRP_RESET_RX);
499
500 switch (ftdmchan->state) {
501
502 case FTDM_CHANNEL_STATE_RESTART:
503
504
505 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE);
506
507 break;
508
509 default:
510
511
512 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
513 break;
514
515 }
516
517
518 ftdm_mutex_unlock(ftdmchan->mutex);
519
520 }
521
522 return FTDM_SUCCESS;
523 }
524
525
526 ftdm_status_t check_if_rx_grs_processed(ftdm_span_t *ftdmspan)
527 {
528 ftdm_channel_t *ftdmchan = NULL;
529 sngss7_chan_data_t *sngss7_info = NULL;
530 sngss7_span_data_t *sngss7_span = (sngss7_span_data_t *)ftdmspan->mod_data;
531 int i;
532 int byte = 0;
533 int bit = 0;
534
535
536 ftdm_log(FTDM_LOG_DEBUG, "Found Rx GRS on span %s...checking circuits\n", ftdmspan->name);
537
538
539 for ( i = sngss7_span->rx_grs.circuit; i < (sngss7_span->rx_grs.circuit + sngss7_span->rx_grs.range + 1); i++) {
540
541
542 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
543 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", i);
544 continue;
545 }
546
547
548 ftdm_mutex_lock(ftdmchan->mutex);
549
550
551 if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
552
553 if (!sngss7_test_flag(sngss7_info, FLAG_GRP_RESET_RX_DN)) {
554
555 goto GRS_UNLOCK_ALL;
556 }
557 } else {
558
559 goto GRS_UNLOCK_ALL;
560 }
561 }
562
563 SS7_DEBUG("All circuits out of reset for GRS: circuit=%d, range=%d\n",
564 sngss7_span->rx_grs.circuit,
565 sngss7_span->rx_grs.range);
566
567
568 for ( i = sngss7_span->rx_grs.circuit; i < (sngss7_span->rx_grs.circuit + sngss7_span->rx_grs.range + 1); i++) {
569
570
571 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
572 SS7_ERROR("Failed to extract channel data for circuit = %d!\n",i);
573
574 SS7_ASSERT;
575
576 continue;
577 }
578
579
580 sngss7_set_flag(sngss7_info, FLAG_GRP_RESET_RX_CMPLT);
581
582
583 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
584
585
586 if ((sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX)) ||
587 (sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_TX)) ||
588 (sngss7_test_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX)) ||
589 (sngss7_test_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX))) {
590
591 sngss7_span->rx_grs.status[byte] = (sngss7_span->rx_grs.status[byte] | (1 << bit));
592 }
593
594
595 bit ++;
596 if (bit == 8) {
597 byte++;
598 bit = 0;
599 }
600 }
601
602 GRS_UNLOCK_ALL:
603 for ( i = sngss7_span->rx_grs.circuit; i < (sngss7_span->rx_grs.circuit + sngss7_span->rx_grs.range + 1); i++) {
604
605 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
606 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", i);
607 continue;
608 }
609
610
611 ftdm_mutex_unlock(ftdmchan->mutex);
612 }
613
614 return FTDM_SUCCESS;
615 }
616
617
618 ftdm_status_t check_if_rx_gra_started(ftdm_span_t *ftdmspan)
619 {
620 ftdm_channel_t *ftdmchan = NULL;
621 sngss7_chan_data_t *sngss7_info = NULL;
622 sngss7_span_data_t *sngss7_span = (sngss7_span_data_t *)ftdmspan->mod_data;
623 int i;
624
625 for (i = sngss7_span->rx_gra.circuit; i < (sngss7_span->rx_gra.circuit + sngss7_span->rx_gra.range + 1); i++) {
626
627
628 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
629 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", i);
630 continue;
631 }
632
633
634 if (sngss7_test_flag(sngss7_info, FLAG_GRP_RESET_TX_RSP)) {
635
636 continue;
637 }
638
639
640 ftdm_mutex_lock(ftdmchan->mutex);
641
642
643 while (ftdm_test_flag (ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
644 ftdm_sangoma_ss7_process_state_change (ftdmchan);
645 }
646
647 SS7_INFO_CHAN(ftdmchan, "Rx GRA (%d:%d)\n",
648 g_ftdm_sngss7_data.cfg.isupCkt[sngss7_span->rx_gra.circuit].cic,
649 (g_ftdm_sngss7_data.cfg.isupCkt[sngss7_span->rx_gra.circuit].cic + sngss7_span->rx_gra.range));
650
651 switch (ftdmchan->state) {
652
653 case FTDM_CHANNEL_STATE_RESTART:
654
655
656 sngss7_set_flag(sngss7_info, FLAG_GRP_RESET_TX_RSP);
657
658
659 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
660
661 break;
662
663 case FTDM_CHANNEL_STATE_DOWN:
664
665
666 SS7_DEBUG("Receveived GRA in down state, dropping\n");
667
668 break;
669
670 case FTDM_CHANNEL_STATE_TERMINATING:
671 case FTDM_CHANNEL_STATE_HANGUP:
672 case FTDM_CHANNEL_STATE_HANGUP_COMPLETE:
673
674
675 sngss7_set_flag(sngss7_info, FLAG_GRP_RESET_TX_RSP);
676
677 break;
678
679 default:
680
681 if (sngss7_span->rx_gra.cause != 0) {
682 ftdmchan->caller_data.hangup_cause = sngss7_span->rx_gra.cause;
683 } else {
684 ftdmchan->caller_data.hangup_cause = 98;
685 }
686
687
688 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
689 break;
690
691 }
692
693
694 ftdm_mutex_unlock(ftdmchan->mutex);
695
696 }
697
698
699 return FTDM_SUCCESS;
700 }
701
702
703 ftdm_status_t check_for_res_sus_flag(ftdm_span_t *ftdmspan)
704 {
705 ftdm_channel_t *ftdmchan = NULL;
706 sngss7_chan_data_t *sngss7_info = NULL;
707 ftdm_sigmsg_t sigev;
708 int x;
709
710 for (x = 1; x < (ftdmspan->chan_count + 1); x++) {
711
712
713 ftdmchan = ftdmspan->channels[x];
714
715
716 if (ftdmchan->call_data == NULL) continue;
717
718 sngss7_info = ftdmchan->call_data;
719
720
721 ftdm_mutex_lock(ftdmchan->mutex);
722
723 memset (&sigev, 0, sizeof (sigev));
724
725 sigev.chan_id = ftdmchan->chan_id;
726 sigev.span_id = ftdmchan->span_id;
727 sigev.channel = ftdmchan;
728
729
730 if ((sngss7_test_flag(sngss7_info, FLAG_INFID_PAUSED)) &&
731 (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_SIG_UP))) {
732
733
734 while (ftdm_test_flag (ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
735 ftdm_sangoma_ss7_process_state_change (ftdmchan);
736 }
737
738
739
740 ftdm_set_state_locked (ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
741 }
742
743
744
745 if (sngss7_test_flag(sngss7_info, FLAG_INFID_RESUME)) {
746
747
748 while (ftdm_test_flag (ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
749 ftdm_sangoma_ss7_process_state_change (ftdmchan);
750 }
751
752
753 ftdm_set_state_locked (ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
754 }
755
756
757 ftdm_mutex_unlock(ftdmchan->mutex);
758
759 }
760
761
762 ftdm_span_trigger_signals(ftdmspan);
763
764 return FTDM_SUCCESS;
765 }
766
767
768 ftdm_status_t process_span_ucic(ftdm_span_t *ftdmspan)
769 {
770 ftdm_channel_t *ftdmchan = NULL;
771 sngss7_chan_data_t *sngss7_info = NULL;
772 sngss7_span_data_t *sngss7_span = (sngss7_span_data_t *)ftdmspan->mod_data;
773 int i;
774
775 for (i = sngss7_span->ucic.circuit; i < (sngss7_span->ucic.circuit + sngss7_span->ucic.range + 1); i++) {
776
777
778 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
779 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", i);
780 continue;
781 }
782
783
784 ftdm_mutex_lock(ftdmchan->mutex);
785
786 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx UCIC\n", sngss7_info->circuit->cic);
787
788
789 while (ftdm_test_flag (ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
790 ftdm_sangoma_ss7_process_state_change (ftdmchan);
791 }
792
793
794 sngss7_set_flag(sngss7_info, FLAG_CKT_UCIC_BLOCK);
795
796
797 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
798
799
800 ftdm_mutex_unlock(ftdmchan->mutex);
801 }
802
803
804 memset(&sngss7_span->ucic, 0x0, sizeof(sngss7_group_data_t));
805
806 return FTDM_SUCCESS;
807 }
808
809
810 ftdm_status_t clear_rx_grs_flags(sngss7_chan_data_t *sngss7_info)
811 {
812
813 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_RX);
814 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_RX_DN);
815 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_RX_CMPLT);
816
817 return FTDM_SUCCESS;
818 }
819
820
821 ftdm_status_t clear_rx_grs_data(sngss7_chan_data_t *sngss7_info)
822 {
823 ftdm_channel_t *ftdmchan = sngss7_info->ftdmchan;
824 sngss7_span_data_t *sngss7_span = ftdmchan->span->mod_data;
825
826
827 memset(&sngss7_span->rx_grs, 0x0, sizeof(sngss7_group_data_t));
828
829 return FTDM_SUCCESS;
830 }
831
832
833 ftdm_status_t clear_rx_gra_data(sngss7_chan_data_t *sngss7_info)
834 {
835 ftdm_channel_t *ftdmchan = sngss7_info->ftdmchan;
836 sngss7_span_data_t *sngss7_span = ftdmchan->span->mod_data;
837
838
839 memset(&sngss7_span->rx_gra, 0x0, sizeof(sngss7_group_data_t));
840
841 return FTDM_SUCCESS;
842 }
843
844 ftdm_status_t clear_tx_grs_flags(sngss7_chan_data_t *sngss7_info)
845 {
846
847 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_BASE);
848 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_TX);
849 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_SENT);
850 sngss7_clear_flag(sngss7_info, FLAG_GRP_RESET_TX_RSP);
851
852 return FTDM_SUCCESS;
853 }
854
855
856 ftdm_status_t clear_tx_grs_data(sngss7_chan_data_t *sngss7_info)
857 {
858 ftdm_channel_t *ftdmchan = sngss7_info->ftdmchan;
859 sngss7_span_data_t *sngss7_span = ftdmchan->span->mod_data;
860
861
862 memset(&sngss7_span->tx_grs, 0x0, sizeof(sngss7_group_data_t));
863
864 return FTDM_SUCCESS;
865 }
866
867
868
869
870 ftdm_status_t clear_rx_rsc_flags(sngss7_chan_data_t *sngss7_info)
871 {
872
873 sngss7_clear_flag(sngss7_info, FLAG_RESET_RX);
874
875 return FTDM_SUCCESS;
876 }
877
878
879 ftdm_status_t clear_tx_rsc_flags(sngss7_chan_data_t *sngss7_info)
880 {
881
882 sngss7_clear_flag(sngss7_info, FLAG_RESET_TX);
883 sngss7_clear_flag(sngss7_info, FLAG_RESET_SENT);
884 sngss7_clear_flag(sngss7_info, FLAG_RESET_TX_RSP);
885
886 return FTDM_SUCCESS;
887 }
888
889
890 ftdm_status_t encode_subAddrIE_nsap(const char *subAddr, char *subAddrIE, int type)
891 {
892
893
894
895
896
897
898
899
900
901 int x = 0;
902 int p = 0;
903 int len = 0;
904 char tmp[2];
905
906
907 tmp[1]='\0';
908
909
910 p = 0;
911 switch(type) {
912
913 case SNG_CALLED:
914 subAddrIE[p] = 0x71;
915 break;
916
917 case SNG_CALLING:
918 subAddrIE[p] = 0x6d;
919 break;
920
921 default:
922 SS7_ERROR("Sub-Address type is invalid: %d\n", type);
923 return FTDM_FAIL;
924 break;
925
926 }
927
928
929 p = 2;
930 subAddrIE[p] = 0x80;
931
932
933 p = 3;
934
935
936 while (subAddr[x] != '\0') {
937
938
939 tmp[0] = subAddr[x];
940
941
942 if (!isdigit(tmp[0])) {
943
944 x++;
945
946
947 continue;
948 }
949
950
951 subAddrIE[p] = atoi(&tmp[0]);
952 subAddrIE[p] |= 0x3 << 4;
953
954
955 len++;
956
957
958 p++;
959
960
961 x++;
962
963 }
964
965
966 p = 1;
967 subAddrIE[p] = len + 1;
968
969
970 return FTDM_SUCCESS;
971 }
972
973
974 ftdm_status_t encode_subAddrIE_nat(const char *subAddr, char *subAddrIE, int type)
975 {
976
977
978
979
980
981
982
983
984
985 int x = 0;
986 int p = 0;
987 int len = 0;
988 char tmp[2];
989 int flag = 0;
990 int odd = 0;
991 uint8_t lower = 0x0;
992 uint8_t upper = 0x0;
993
994
995 tmp[1]='\0';
996
997
998 p = 0;
999 switch(type) {
1000
1001 case SNG_CALLED:
1002 subAddrIE[p] = 0x71;
1003 break;
1004
1005 case SNG_CALLING:
1006 subAddrIE[p] = 0x6d;
1007 break;
1008
1009 default:
1010 SS7_ERROR("Sub-Address type is invalid: %d\n", type);
1011 return FTDM_FAIL;
1012 break;
1013
1014 }
1015
1016
1017 p = 3;
1018
1019
1020 while (1) {
1021
1022
1023 tmp[0] = subAddr[x];
1024
1025
1026 while ((!isxdigit(tmp[0])) && (tmp[0] != '\0')) {
1027
1028 x++;
1029 tmp[0] = subAddr[x];
1030 }
1031
1032
1033 if (tmp[0] != '\0') {
1034
1035 lower = strtol(&tmp[0], (char **)NULL, 16);
1036
1037 x++;
1038
1039 tmp[0] = subAddr[x];
1040
1041
1042 while (!(isxdigit(tmp[0])) && (tmp[0] != '\0')) {
1043 x++;
1044 tmp[0] = subAddr[x];
1045 }
1046
1047
1048 if (tmp[0] != '\0') {
1049
1050 upper = (strtol(&tmp[0], (char **)NULL, 16)) << 4;
1051 } else {
1052
1053 upper = 0x00;
1054
1055 odd = 1;
1056
1057 flag = 1;
1058 }
1059 } else {
1060
1061 odd = 0;
1062
1063
1064 flag = 1;
1065
1066
1067 break;
1068 }
1069
1070
1071 subAddrIE[p] = upper | lower;
1072
1073
1074 len++;
1075
1076
1077 if (flag) break;
1078
1079
1080 p++;
1081
1082
1083 x++;
1084
1085 }
1086
1087
1088 p = 1;
1089 subAddrIE[p] = len + 1;
1090
1091
1092 p = 2;
1093 subAddrIE[p] = 0xa0 | (odd << 3);
1094
1095
1096 return FTDM_SUCCESS;
1097 }
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110