This source file includes following definitions.
- handle_con_ind
- handle_con_sta
- handle_con_cfm
- handle_rel_ind
- handle_rel_cfm
- handle_dat_ind
- handle_fac_ind
- handle_fac_cfm
- handle_umsg_ind
- handle_sta_ind
- handle_reattempt
- handle_pause
- handle_resume
- handle_cot_start
- handle_cot_stop
- handle_cot
- handle_blo_req
- handle_blo_rsp
- handle_ubl_req
- handle_ubl_rsp
- handle_rsc_req
- handle_local_rsc_req
- handle_rsc_rsp
- handle_grs_req
- handle_grs_rsp
- handle_local_blk
- handle_local_ubl
- handle_ucic
- handle_cgb_req
- handle_cgu_req
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
43
44
45 ftdm_status_t handle_con_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiConEvnt *siConEvnt);
46 ftdm_status_t handle_con_sta(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiCnStEvnt *siCnStEvnt, uint8_t evntType);
47 ftdm_status_t handle_con_cfm(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiConEvnt *siConEvnt);
48 ftdm_status_t handle_rel_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiRelEvnt *siRelEvnt);
49 ftdm_status_t handle_rel_cfm(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiRelEvnt *siRelEvnt);
50 ftdm_status_t handle_dat_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiInfoEvnt *siInfoEvnt);
51 ftdm_status_t handle_fac_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t evntType, SiFacEvnt *siFacEvnt);
52 ftdm_status_t handle_fac_cfm(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t evntType, SiFacEvnt *siFacEvnt);
53 ftdm_status_t handle_umsg_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit);
54 ftdm_status_t handle_sta_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
55
56 ftdm_status_t handle_reattempt(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
57 ftdm_status_t handle_pause(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
58 ftdm_status_t handle_resume(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
59 ftdm_status_t handle_cot_start(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
60 ftdm_status_t handle_cot_stop(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
61 ftdm_status_t handle_cot(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
62 ftdm_status_t handle_rsc_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
63 ftdm_status_t handle_local_rsc_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
64 ftdm_status_t handle_rsc_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
65 ftdm_status_t handle_grs_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
66 ftdm_status_t handle_grs_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
67 ftdm_status_t handle_blo_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
68 ftdm_status_t handle_blo_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
69 ftdm_status_t handle_ubl_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
70 ftdm_status_t handle_ubl_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
71 ftdm_status_t handle_local_blk(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
72 ftdm_status_t handle_local_ubl(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
73 ftdm_status_t handle_ucic(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
74 ftdm_status_t handle_cgb_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
75 ftdm_status_t handle_cgu_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt);
76
77
78
79 ftdm_status_t handle_con_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiConEvnt *siConEvnt)
80 {
81 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
82
83 sngss7_chan_data_t *sngss7_info = NULL;
84 ftdm_channel_t *ftdmchan = NULL;
85 char nadi[2];
86
87 memset(nadi, '\0', sizeof(nadi));
88
89
90 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
91 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
92 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
93 return FTDM_FAIL;
94 }
95
96
97 ftdm_mutex_lock(ftdmchan->mutex);
98
99 if (sngss7_test_flag(sngss7_info, FLAG_GLARE)) {
100 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx IAM (glare)\n", sngss7_info->circuit->cic);
101 } else {
102 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx IAM\n", sngss7_info->circuit->cic);
103 }
104
105
106 if ((sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX)) ||
107 (sngss7_test_flag(sngss7_info, FLAG_GRP_HW_BLOCK_RX)) ||
108 (sngss7_test_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX))) {
109
110
111 sngss7_clear_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX);
112 sngss7_clear_flag(sngss7_info, FLAG_GRP_HW_BLOCK_RX);
113 sngss7_clear_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX);
114
115
116 }
117
118
119 switch (ftdmchan->state) {
120
121 case (FTDM_CHANNEL_STATE_DOWN):
122
123
124 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE)) {
125
126 goto handle_glare;
127 } else if(ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) {
128
129 SS7_ERROR("Failed to open span: %d, chan: %d\n",
130 ftdmchan->physical_span_id,
131 ftdmchan->physical_chan_id);
132
133
134 sngss7_set_flag(sngss7_info, FLAG_LOCAL_REL);
135
136 ftdmchan->caller_data.hangup_cause = 41;
137
138
139 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_CANCEL);
140
141 } else {
142
143
144 sngss7_info->suInstId = get_unique_id();
145 sngss7_info->spInstId = spInstId;
146
147
148 if (siConEvnt->cgPtyNum.eh.pres) {
149 if (siConEvnt->cgPtyNum.addrSig.pres) {
150
151 copy_tknStr_from_sngss7(siConEvnt->cgPtyNum.addrSig,
152 ftdmchan->caller_data.cid_num.digits,
153 siConEvnt->cgPtyNum.oddEven);
154
155
156 ftdm_set_string(ftdmchan->caller_data.cid_name, ftdmchan->caller_data.cid_num.digits);
157
158
159 ftdm_set_string(ftdmchan->caller_data.ani.digits, ftdmchan->caller_data.cid_num.digits);
160 }
161
162 if (siConEvnt->cgPtyNum.scrnInd.pres) {
163
164 ftdmchan->caller_data.screen = siConEvnt->cgPtyNum.scrnInd.val;
165 }
166
167 if (siConEvnt->cgPtyNum.presRest.pres) {
168
169 ftdmchan->caller_data.pres = siConEvnt->cgPtyNum.presRest.val;
170 }
171 } else {
172 SS7_INFO_CHAN(ftdmchan,"No Calling party (ANI) information in IAM!%s\n", " ");
173 }
174
175
176 if (siConEvnt->cdPtyNum.eh.pres) {
177 if (siConEvnt->cdPtyNum.addrSig.pres) {
178
179 copy_tknStr_from_sngss7(siConEvnt->cdPtyNum.addrSig,
180 ftdmchan->caller_data.dnis.digits,
181 siConEvnt->cdPtyNum.oddEven);
182 }
183 } else {
184 SS7_INFO_CHAN(ftdmchan,"No Called party (DNIS) information in IAM!%s\n", " ");
185 }
186
187
188 if (siConEvnt->redirgNum.eh.pres) {
189 if (siConEvnt->redirgNum.addrSig.pres) {
190
191 copy_tknStr_from_sngss7(siConEvnt->redirgNum.addrSig,
192 ftdmchan->caller_data.rdnis.digits,
193 siConEvnt->cgPtyNum.oddEven);
194 }
195 } else {
196 SS7_DEBUG_CHAN(ftdmchan,"No RDNIS party information in IAM!%s\n", " ");
197 }
198
199
200 if (siConEvnt->txMedReq.eh.pres) {
201 if (siConEvnt->txMedReq.trMedReq.pres) {
202
203 ftdmchan->caller_data.bearer_capability = siConEvnt->txMedReq.trMedReq.val;
204 }
205 } else {
206 SS7_DEBUG_CHAN(ftdmchan,"No TMR/Bearer Cap information in IAM!%s\n", " ");
207 }
208
209
210 sprintf(nadi, "%d", siConEvnt->cgPtyNum.natAddrInd.val);
211 ftdm_channel_add_var(ftdmchan, "ss7_nadi", nadi);
212
213
214 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_COLLECT);
215
216 }
217
218 break;
219
220 case (FTDM_CHANNEL_STATE_DIALING):
221 case (FTDM_CHANNEL_STATE_TERMINATING):
222 case (FTDM_CHANNEL_STATE_HANGUP):
223 case (FTDM_CHANNEL_STATE_HANGUP_COMPLETE):
224 handle_glare:
225
226 SS7_INFO_CHAN(ftdmchan, "Got IAM on channel that is already inuse (state=%s|inuse=%d)...glare!\n",
227 ftdm_channel_state2str (ftdmchan->state),
228 ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INUSE));
229
230
231 sngss7_info->glare.spInstId = spInstId;
232 sngss7_info->glare.circuit = circuit;
233 memcpy(&sngss7_info->glare.iam, siConEvnt, sizeof(*siConEvnt));
234
235 if (!(sngss7_test_flag(sngss7_info, FLAG_GLARE))) {
236
237 sngss7_set_flag(sngss7_info, FLAG_GLARE);
238
239
240 ftdmchan->caller_data.hangup_cause = 34;
241
242
243 sngss7_set_flag(sngss7_info, FLAG_REMOTE_REL);
244
245
246 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
247 }
248 break;
249
250 default:
251 SS7_ERROR_CHAN(ftdmchan, "Got IAM on channel in invalid state(%s)...reset!\n", ftdm_channel_state2str (ftdmchan->state));
252
253
254 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
255
256 break;
257
258 }
259
260
261 ftdm_mutex_unlock(ftdmchan->mutex);
262
263 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
264 return FTDM_SUCCESS;
265 }
266
267
268 ftdm_status_t handle_con_sta(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiCnStEvnt *siCnStEvnt, uint8_t evntType)
269 {
270 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
271
272 sngss7_chan_data_t *sngss7_info ;
273 ftdm_channel_t *ftdmchan;
274
275
276 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
277 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
278 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
279 return FTDM_FAIL;
280 }
281
282
283 ftdm_mutex_lock(ftdmchan->mutex);
284
285 switch (evntType) {
286
287 case (ADDRCMPLT):
288 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx ACM\n", sngss7_info->circuit->cic);
289 switch (ftdmchan->state) {
290
291 case FTDM_CHANNEL_STATE_DIALING:
292
293
294
295 sngss7_info->spInstId = spInstId;
296
297
298 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS);
299 break;
300
301 default:
302
303 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS);
304 break;
305
306 }
307
308 case (MODIFY):
309 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx MODIFY\n", sngss7_info->circuit->cic);
310 break;
311
312 case (MODCMPLT):
313 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx MODIFY-COMPLETE\n", sngss7_info->circuit->cic);
314 break;
315
316 case (MODREJ):
317 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx MODIFY-REJECT\n", sngss7_info->circuit->cic);
318 break;
319
320 case (PROGRESS):
321 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CPG\n", sngss7_info->circuit->cic);
322 break;
323
324 case (FRWDTRSFR):
325 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx FOT\n", sngss7_info->circuit->cic);
326 break;
327
328 case (INFORMATION):
329 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx INF\n", sngss7_info->circuit->cic);
330 break;
331
332 case (INFORMATREQ):
333 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx INR\n", sngss7_info->circuit->cic);
334 break;
335
336 case (SUBSADDR):
337 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx SAM\n", sngss7_info->circuit->cic);
338 break;
339
340 case (EXIT):
341 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx EXIT\n", sngss7_info->circuit->cic);
342 break;
343
344 case (NETRESMGT):
345 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx NRM\n", sngss7_info->circuit->cic);
346 break;
347
348 case (IDENTREQ):
349 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx IDR\n", sngss7_info->circuit->cic);
350 break;
351
352 case (IDENTRSP):
353 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx IRS\n", sngss7_info->circuit->cic);
354 break;
355
356 case (MALCLLPRNT):
357 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx MALICIOUS CALL\n", sngss7_info->circuit->cic);
358 break;
359
360 case (CHARGE):
361 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CRG\n", sngss7_info->circuit->cic);
362 break;
363
364 case (TRFFCHGE):
365 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CRG-TARIFF\n", sngss7_info->circuit->cic);
366 break;
367
368 case (CHARGEACK):
369 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CRG-ACK\n", sngss7_info->circuit->cic);
370 break;
371
372 case (CALLOFFMSG):
373 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CALL-OFFER\n", sngss7_info->circuit->cic);
374 break;
375
376 case (LOOPPRVNT):
377 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx LOP\n", sngss7_info->circuit->cic);
378 break;
379
380 case (TECT_TIMEOUT):
381 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx ECT-Timeout\n", sngss7_info->circuit->cic);
382 break;
383
384 case (RINGSEND):
385 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx RINGING-SEND\n", sngss7_info->circuit->cic);
386 break;
387
388 case (CALLCLEAR):
389 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CALL-LINE Clear\n", sngss7_info->circuit->cic);
390 break;
391
392 case (PRERELEASE):
393 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx PRI\n", sngss7_info->circuit->cic);
394 break;
395
396 case (APPTRANSPORT):
397 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx APM\n", sngss7_info->circuit->cic);
398 break;
399
400 case (OPERATOR):
401 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx OPERATOR\n", sngss7_info->circuit->cic);
402 break;
403
404 case (METPULSE):
405 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx METERING-PULSE\n", sngss7_info->circuit->cic);
406 break;
407
408 case (CLGPTCLR):
409 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CALLING_PARTY_CLEAR\n", sngss7_info->circuit->cic);
410 break;
411
412 case (SUBDIRNUM):
413 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx SUB-DIR\n", sngss7_info->circuit->cic);
414 break;
415
416 default:
417 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Unknown Msg\n", sngss7_info->circuit->cic);
418 break;
419
420 }
421
422
423 ftdm_mutex_unlock(ftdmchan->mutex);
424
425 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
426 return FTDM_SUCCESS;
427 }
428
429
430 ftdm_status_t handle_con_cfm(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiConEvnt *siConEvnt)
431 {
432 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
433
434 sngss7_chan_data_t *sngss7_info ;
435 ftdm_channel_t *ftdmchan;
436
437
438 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
439 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
440 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
441 return FTDM_FAIL;
442 }
443
444
445 ftdm_mutex_lock(ftdmchan->mutex);
446
447
448 switch (ftdmchan->state) {
449
450 case FTDM_CHANNEL_STATE_PROGRESS:
451 case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
452
453 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx ANM\n", sngss7_info->circuit->cic);
454
455
456 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
457
458 break;
459
460 case FTDM_CHANNEL_STATE_DIALING:
461
462 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CON\n", sngss7_info->circuit->cic);
463
464
465 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
466
467 break;
468
469 default:
470
471 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx ANM/CON\n", sngss7_info->circuit->cic);
472
473
474 sngss7_set_flag(sngss7_info, FLAG_GRP_RESET_TX);
475
476
477 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
478
479 break;
480
481 }
482
483
484 ftdm_mutex_unlock(ftdmchan->mutex);
485
486 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
487 return FTDM_SUCCESS;
488 }
489
490
491 ftdm_status_t handle_rel_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiRelEvnt *siRelEvnt)
492 {
493 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
494
495 sngss7_chan_data_t *sngss7_info ;
496 ftdm_channel_t *ftdmchan;
497
498
499 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
500 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
501 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
502 return FTDM_FAIL;
503 }
504
505
506 ftdm_mutex_lock(ftdmchan->mutex);
507
508 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx REL cause=%d\n",
509 sngss7_info->circuit->cic,
510 siRelEvnt->causeDgn.causeVal.val);
511
512
513 switch (ftdmchan->state) {
514
515 case FTDM_CHANNEL_STATE_DIALING:
516
517
518 if (siRelEvnt->causeDgn.causeVal.pres) {
519 ftdmchan->caller_data.hangup_cause = siRelEvnt->causeDgn.causeVal.val;
520 } else {
521 SS7_ERROR("REL does not have a cause code!\n");
522 ftdmchan->caller_data.hangup_cause = 0;
523 }
524
525
526 sngss7_set_flag(sngss7_info, FLAG_REMOTE_REL);
527
528
529 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
530
531 break;
532
533 case FTDM_CHANNEL_STATE_RING:
534 case FTDM_CHANNEL_STATE_PROGRESS:
535 case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
536 case FTDM_CHANNEL_STATE_UP:
537
538
539 if (siRelEvnt->causeDgn.causeVal.pres) {
540 ftdmchan->caller_data.hangup_cause = siRelEvnt->causeDgn.causeVal.val;
541 } else {
542 SS7_ERROR("REL does not have a cause code!\n");
543 ftdmchan->caller_data.hangup_cause = 0;
544 }
545
546
547 sngss7_set_flag(sngss7_info, FLAG_REMOTE_REL);
548
549
550 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
551
552 break;
553
554 default:
555
556
557 sngss7_set_flag(sngss7_info, FLAG_RESET_RX);
558
559
560 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
561 break;
562
563 }
564
565
566
567 ftdm_mutex_unlock(ftdmchan->mutex);
568
569 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
570 return FTDM_SUCCESS;
571 }
572
573
574 ftdm_status_t handle_rel_cfm(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiRelEvnt *siRelEvnt)
575 {
576 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
577
578 sngss7_chan_data_t *sngss7_info ;
579 ftdm_channel_t *ftdmchan;
580
581
582 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
583 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
584 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
585 return FTDM_FAIL;
586 }
587
588
589 ftdm_mutex_lock(ftdmchan->mutex);
590
591 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx RLC\n", sngss7_info->circuit->cic);
592
593
594 switch (ftdmchan->state) {
595
596 case FTDM_CHANNEL_STATE_HANGUP_COMPLETE:
597
598
599 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
600
601 break;
602
603 case FTDM_CHANNEL_STATE_DOWN:
604
605 break;
606
607 default:
608
609
610
611 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
612
613 break;
614
615 }
616
617
618 ftdm_mutex_unlock(ftdmchan->mutex);
619
620 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
621 return FTDM_SUCCESS;
622 }
623
624
625 ftdm_status_t handle_dat_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, SiInfoEvnt *siInfoEvnt)
626 {
627 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
628
629 sngss7_chan_data_t *sngss7_info ;
630 ftdm_channel_t *ftdmchan;
631
632
633 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
634 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
635 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
636 return FTDM_FAIL;
637 }
638
639
640 ftdm_mutex_lock(ftdmchan->mutex);
641
642 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx DATA IND\n", sngss7_info->circuit->cic);
643
644
645 ftdm_mutex_unlock(ftdmchan->mutex);
646
647 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
648 return FTDM_SUCCESS;
649 }
650
651
652 ftdm_status_t handle_fac_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t evntType, SiFacEvnt *siFacEvnt)
653 {
654 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
655
656 sngss7_chan_data_t *sngss7_info ;
657 ftdm_channel_t *ftdmchan;
658
659
660 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
661 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
662 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
663 return FTDM_FAIL;
664 }
665
666
667 ftdm_mutex_lock(ftdmchan->mutex);
668
669 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx FAC\n", sngss7_info->circuit->cic);
670
671
672 ftdm_mutex_unlock(ftdmchan->mutex);
673
674 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
675 return FTDM_SUCCESS;
676 }
677
678
679 ftdm_status_t handle_fac_cfm(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t evntType, SiFacEvnt *siFacEvnt)
680 {
681 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
682
683 sngss7_chan_data_t *sngss7_info ;
684 ftdm_channel_t *ftdmchan;
685
686
687 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
688 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
689 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
690 return FTDM_FAIL;
691 }
692
693
694 ftdm_mutex_lock(ftdmchan->mutex);
695
696 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx FAC-CON\n", sngss7_info->circuit->cic);
697
698
699 ftdm_mutex_unlock(ftdmchan->mutex);
700
701 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
702 return FTDM_SUCCESS;
703 }
704
705
706 ftdm_status_t handle_umsg_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit)
707 {
708 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
709
710 sngss7_chan_data_t *sngss7_info ;
711 ftdm_channel_t *ftdmchan;
712
713
714 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
715 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
716 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
717 return FTDM_FAIL;
718 }
719
720
721 ftdm_mutex_lock(ftdmchan->mutex);
722
723 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx USER-USER msg\n", sngss7_info->circuit->cic);
724
725
726 ftdm_mutex_unlock(ftdmchan->mutex);
727
728 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
729 return FTDM_SUCCESS;
730 }
731
732
733 ftdm_status_t handle_sta_ind(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
734 {
735 sngss7_chan_data_t *sngss7_info ;
736 ftdm_channel_t *ftdmchan;
737
738
739 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
740 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
741 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
742 return FTDM_FAIL;
743 }
744
745 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
746
747 switch (evntType) {
748
749 case SIT_STA_REATTEMPT:
750 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Reattempt indication\n", sngss7_info->circuit->cic);
751 handle_reattempt(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
752 break;
753
754 case SIT_STA_ERRORIND:
755 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Error indication\n", sngss7_info->circuit->cic);
756 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
757 break;
758
759 case SIT_STA_CONTCHK:
760 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx COT start\n", sngss7_info->circuit->cic);
761 handle_cot_start(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
762 break;
763
764 case SIT_STA_CONTREP:
765 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx COT report\n", sngss7_info->circuit->cic);
766 handle_cot(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
767 break;
768
769 case SIT_STA_STPCONTIN:
770 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx COT stop\n", sngss7_info->circuit->cic);
771 handle_cot_stop(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
772 break;
773
774 case SIT_STA_CGQRYRSP:
775 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CQM\n", sngss7_info->circuit->cic);
776 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
777 break;
778
779 case SIT_STA_CONFUSION:
780 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CFN\n", sngss7_info->circuit->cic);
781 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
782 break;
783
784 case SIT_STA_LOOPBACKACK:
785 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx LPA\n", sngss7_info->circuit->cic);
786 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
787 break;
788
789 case SIT_STA_CIRRSRVREQ:
790 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Ckt Resveration req\n", sngss7_info->circuit->cic);
791 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
792 break;
793
794 case SIT_STA_CIRRSRVACK:
795 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Ckt Res ack\n", sngss7_info->circuit->cic);
796 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
797 break;
798
799 case SIT_STA_CIRBLOREQ:
800 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx BLO\n", sngss7_info->circuit->cic);
801 handle_blo_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
802 break;
803
804 case SIT_STA_CIRBLORSP:
805 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx BLA\n", sngss7_info->circuit->cic);
806 handle_blo_rsp(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
807 break;
808
809 case SIT_STA_CIRUBLREQ:
810 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx UBL\n", sngss7_info->circuit->cic);
811 handle_ubl_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
812 break;
813
814 case SIT_STA_CIRUBLRSP:
815 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx UBA\n", sngss7_info->circuit->cic);
816 handle_ubl_rsp(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
817 break;
818
819 case SIT_STA_CIRRESREQ:
820 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx RSC\n", sngss7_info->circuit->cic);
821 handle_rsc_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
822 break;
823
824 case SIT_STA_CIRLOCRES:
825 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Local RSC\n", sngss7_info->circuit->cic);
826 handle_local_rsc_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
827 break;
828
829 case SIT_STA_CIRRESRSP:
830 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx RSC-RLC\n", sngss7_info->circuit->cic);
831 handle_rsc_rsp(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
832 break;
833
834 case SIT_STA_CGBREQ:
835 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CGB\n", sngss7_info->circuit->cic);
836 handle_cgb_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
837 break;
838
839 case SIT_STA_CGUREQ:
840 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CGU\n", sngss7_info->circuit->cic);
841 handle_cgu_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
842 break;
843
844 case SIT_STA_CGQRYREQ:
845 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx CQM\n", sngss7_info->circuit->cic);
846 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
847 break;
848
849 case SIT_STA_CGBRSP:
850 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx mntc CGB\n", sngss7_info->circuit->cic);
851
852 break;
853
854 case SIT_STA_CGURSP:
855 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx mntc CGU\n", sngss7_info->circuit->cic);
856
857 break;
858
859 case SIT_STA_GRSREQ:
860 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx GRS\n", sngss7_info->circuit->cic);
861 handle_grs_req(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
862 break;
863
864 case SIT_STA_CIRUNEQPD:
865 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx UCIC\n", sngss7_info->circuit->cic);
866 handle_ucic(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
867 break;
868
869 case SIT_STA_GRSRSP:
870 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx GRA\n", sngss7_info->circuit->cic);
871 handle_grs_rsp(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
872 break;
873
874 case SIT_STA_PAUSEIND:
875 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx SUS\n", sngss7_info->circuit->cic);
876 handle_pause(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
877 break;
878
879 case SIT_STA_RESUMEIND:
880 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx RES\n", sngss7_info->circuit->cic);
881 handle_resume(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
882 break;
883
884 case SIT_STA_USRPARTA:
885 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx UPA\n", sngss7_info->circuit->cic);
886 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
887 break;
888
889 case SIT_STA_RMTUSRUNAV:
890 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Remote User not Available\n", sngss7_info->circuit->cic);
891 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
892 break;
893
894 case SIT_STA_MTPCONG0:
895 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Congestion L0\n", sngss7_info->circuit->cic);
896 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
897 break;
898
899 case SIT_STA_MTPCONG1:
900 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Congestion L1\n", sngss7_info->circuit->cic);
901 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
902 break;
903
904 case SIT_STA_MTPCONG2:
905 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Congestion L2\n", sngss7_info->circuit->cic);
906 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
907 break;
908
909 case SIT_STA_MTPCONG3:
910 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Congestion L3\n", sngss7_info->circuit->cic);
911 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
912 break;
913
914 case SIT_STA_MTPSTPCONG:
915 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Stop Congestion\n", sngss7_info->circuit->cic);
916 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
917 break;
918
919 case SIT_STA_CIRLOCALBLOIND:
920 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Local BLO\n", sngss7_info->circuit->cic);
921 handle_local_blk(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
922 break;
923
924 case SIT_STA_CIRLOCALUBLIND:
925 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Local UBL\n", sngss7_info->circuit->cic);
926 handle_local_ubl(suInstId, spInstId, circuit, globalFlg, evntType, siStaEvnt);
927 break;
928
929 case SIT_STA_OVERLOAD:
930 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Overload\n", sngss7_info->circuit->cic);
931 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
932 break;
933
934 case SIT_STA_LMCGBREQ:
935 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx LM CGB\n", sngss7_info->circuit->cic);
936 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
937 break;
938
939 case SIT_STA_LMCGUREQ:
940 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx LM CGU\n", sngss7_info->circuit->cic);
941 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
942 break;
943
944 case SIT_STA_LMGRSREQ:
945 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx LM RSC\n", sngss7_info->circuit->cic);
946 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
947 break;
948
949 case SIT_STA_CGBINFOIND:
950
951
952 break;
953
954 case SIT_STA_LMCQMINFOREQ:
955 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx LM CQM\n", sngss7_info->circuit->cic);
956
957 break;
958
959 case SIT_STA_CIRLOCGRS:
960 SS7_INFO_CHAN(ftdmchan,"[CIC:%d]Rx Local GRS\n", sngss7_info->circuit->cic);
961 SS7_WARN(" %s indication not currently supported\n", DECODE_LCC_EVENT(evntType));
962 break;
963
964 default:
965 SS7_INFO("[SNG-CC] Received Unknown indication %d\n", evntType);
966 break;
967 }
968
969 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
970 return FTDM_SUCCESS;
971
972 }
973
974
975 ftdm_status_t handle_reattempt(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
976 {
977 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
978
979 sngss7_chan_data_t *sngss7_info = NULL;
980 ftdm_channel_t *ftdmchan = NULL;
981
982
983 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
984 SS7_ERROR("Failed to extract channel data for ISUP circuit = %d!\n", circuit);
985 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
986 return FTDM_FAIL;
987 }
988
989
990 ftdm_mutex_lock(ftdmchan->mutex);
991
992 if (sngss7_test_flag(sngss7_info, FLAG_GLARE)) {
993
994 SS7_DEBUG_CHAN(ftdmchan, "Glare flag is already up...nothing to do!%s\n", " ");
995 } else {
996 SS7_DEBUG_CHAN(ftdmchan, "Glare flag is not up yet...indicating glare from reattempt!%s\n", " ");
997
998 sngss7_set_flag(sngss7_info, FLAG_GLARE);
999
1000
1001 memset(&sngss7_info->glare, 0x0, sizeof(sngss7_glare_data_t));
1002
1003
1004 ftdmchan->caller_data.hangup_cause = 34;
1005
1006
1007 sngss7_set_flag(sngss7_info, FLAG_REMOTE_REL);
1008
1009
1010 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
1011 }
1012
1013
1014 ftdm_mutex_unlock(ftdmchan->mutex);
1015
1016 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1017 return FTDM_SUCCESS;
1018 }
1019
1020
1021 ftdm_status_t handle_pause(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1022 {
1023 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1024
1025 sngss7_chan_data_t *sngss7_info = NULL;
1026 ftdm_channel_t *ftdmchan = NULL;
1027 int infId;
1028 int i;
1029
1030
1031 infId = g_ftdm_sngss7_data.cfg.isupCkt[circuit].infId;
1032
1033
1034 sngss7_set_flag(&g_ftdm_sngss7_data.cfg.isupIntf[infId], SNGSS7_PAUSED);
1035
1036
1037 i = 1;
1038 while (g_ftdm_sngss7_data.cfg.isupCkt[i].id != 0) {
1039
1040
1041 if ((g_ftdm_sngss7_data.cfg.isupCkt[i].infId == infId) &&
1042 (g_ftdm_sngss7_data.cfg.isupCkt[i].type == VOICE)) {
1043
1044
1045 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
1046 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1047 i++;
1048 continue;
1049 }
1050
1051
1052 ftdm_mutex_lock(ftdmchan->mutex);
1053
1054
1055 if (ftdm_test_flag(ftdmchan->span, FTDM_SPAN_IN_THREAD)) {
1056 SS7_DEBUG_CHAN(ftdmchan, "Rx PAUSE%s\n", "");
1057
1058 sngss7_set_flag(sngss7_info, FLAG_INFID_PAUSED);
1059 }
1060
1061
1062 ftdm_mutex_unlock(ftdmchan->mutex);
1063
1064 }
1065
1066
1067 i++;
1068
1069 }
1070
1071 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1072 return FTDM_SUCCESS;
1073 }
1074
1075
1076 ftdm_status_t handle_resume(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1077 {
1078 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1079
1080 sngss7_chan_data_t *sngss7_info = NULL;
1081 ftdm_channel_t *ftdmchan = NULL;
1082 int infId;
1083 int i;
1084
1085
1086 infId = g_ftdm_sngss7_data.cfg.isupCkt[circuit].infId;
1087
1088
1089 sngss7_clear_flag(&g_ftdm_sngss7_data.cfg.isupIntf[infId], SNGSS7_PAUSED);
1090
1091
1092 i = 1;
1093 while (g_ftdm_sngss7_data.cfg.isupCkt[i].id != 0) {
1094
1095
1096 if ((g_ftdm_sngss7_data.cfg.isupCkt[i].infId == infId) &&
1097 (g_ftdm_sngss7_data.cfg.isupCkt[i].type == VOICE)) {
1098
1099
1100 if (extract_chan_data(i, &sngss7_info, &ftdmchan)) {
1101 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1102 i++;
1103 continue;
1104 }
1105
1106
1107 ftdm_mutex_lock(ftdmchan->mutex);
1108
1109
1110 if (sngss7_test_flag(sngss7_info, FLAG_INFID_PAUSED)) {
1111 SS7_DEBUG_CHAN(ftdmchan, "Rx RESUME%s\n", "");
1112
1113
1114 sngss7_set_flag(sngss7_info, FLAG_INFID_RESUME);
1115
1116
1117 sngss7_clear_flag(sngss7_info, FLAG_INFID_PAUSED);
1118 }
1119
1120
1121 ftdm_mutex_unlock(ftdmchan->mutex);
1122
1123 }
1124
1125
1126 i++;
1127
1128 }
1129
1130 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1131 return FTDM_SUCCESS;
1132 }
1133
1134
1135 ftdm_status_t handle_cot_start(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1136 {
1137 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1138
1139 sngss7_chan_data_t *sngss7_info = NULL;
1140 ftdm_channel_t *ftdmchan = NULL;
1141
1142
1143 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1144 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1145 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1146 return FTDM_FAIL;
1147 }
1148
1149
1150 ftdm_mutex_lock(ftdmchan->mutex);
1151
1152
1153 if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OPEN)) {
1154 if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) {
1155 SS7_ERROR("Failed to open CIC %d for COT test!\n", sngss7_info->circuit->cic);
1156
1157 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1158 return FTDM_FAIL;
1159 }
1160 }
1161
1162
1163 ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_LOOP, NULL);
1164
1165
1166 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IN_LOOP);
1167
1168
1169 if (suInstId == 0) {
1170 sngss7_info->suInstId = get_unique_id();
1171 } else {
1172 sngss7_info->suInstId = suInstId;
1173 }
1174 sngss7_info->spInstId = spInstId;
1175 sngss7_info->globalFlg = globalFlg;
1176
1177
1178 ftdm_mutex_unlock(ftdmchan->mutex);
1179
1180 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1181 return FTDM_SUCCESS;
1182 }
1183
1184
1185 ftdm_status_t handle_cot_stop(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1186 {
1187 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1188
1189 sngss7_chan_data_t *sngss7_info = NULL;
1190 ftdm_channel_t *ftdmchan = NULL;
1191
1192
1193 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1194 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1195 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1196 return FTDM_FAIL;
1197 }
1198
1199
1200 ftdm_mutex_lock(ftdmchan->mutex);
1201
1202
1203 ftdm_channel_command(ftdmchan, FTDM_COMMAND_DISABLE_LOOP, NULL);
1204
1205
1206 ftdm_set_state_locked(ftdmchan, ftdmchan->last_state);
1207
1208
1209 ftdm_mutex_unlock(ftdmchan->mutex);
1210
1211 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1212 return FTDM_SUCCESS;
1213 }
1214
1215
1216 ftdm_status_t handle_cot(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1217 {
1218 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1219
1220 if ( (siStaEvnt->contInd.eh.pres > 0) && (siStaEvnt->contInd.contInd.pres > 0)) {
1221 SS7_INFO("Continuity Test result for CIC = %d (span %d, chan %d) is: \"%s\"\n",
1222 g_ftdm_sngss7_data.cfg.isupCkt[circuit].cic,
1223 g_ftdm_sngss7_data.cfg.isupCkt[circuit].span,
1224 g_ftdm_sngss7_data.cfg.isupCkt[circuit].chan,
1225 (siStaEvnt->contInd.contInd.val) ? "PASS" : "FAIL");
1226 } else {
1227 SS7_ERROR("Recieved Continuity report containing no results!\n");
1228 }
1229
1230 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1231 return FTDM_SUCCESS;
1232 }
1233
1234
1235
1236
1237
1238 ftdm_status_t handle_blo_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1239 {
1240 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1241
1242 sngss7_chan_data_t *sngss7_info = NULL;
1243 ftdm_channel_t *ftdmchan = NULL;
1244
1245
1246 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1247 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1248 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1249 return FTDM_FAIL;
1250 }
1251
1252
1253 ftdm_mutex_lock(ftdmchan->mutex);
1254
1255
1256 if (sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX)) {
1257 SS7_WARN("Received BLO on circuit that is already blocked!\n");
1258 }
1259
1260
1261 sngss7_set_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX);
1262
1263
1264 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
1265
1266
1267 ftdm_mutex_unlock(ftdmchan->mutex);
1268
1269 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1270 return FTDM_SUCCESS;
1271 }
1272
1273
1274 ftdm_status_t handle_blo_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1275 {
1276 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1277
1278 sngss7_chan_data_t *sngss7_info = NULL;
1279 ftdm_channel_t *ftdmchan = NULL;
1280
1281
1282 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1283 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1284 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1285 return FTDM_FAIL;
1286 }
1287
1288
1289 ftdm_mutex_lock(ftdmchan->mutex);
1290
1291
1292
1293
1294 ftdm_mutex_unlock(ftdmchan->mutex);
1295
1296 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1297 return FTDM_SUCCESS;
1298 }
1299
1300
1301 ftdm_status_t handle_ubl_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1302 {
1303 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1304
1305 sngss7_chan_data_t *sngss7_info = NULL;
1306 ftdm_channel_t *ftdmchan = NULL;
1307
1308
1309 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1310 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1311 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1312 return FTDM_FAIL;
1313 }
1314
1315
1316 ftdm_mutex_lock(ftdmchan->mutex);
1317
1318
1319 if (!(sngss7_test_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX))) {
1320 SS7_WARN("Received UBL on circuit that is not blocked!\n");
1321 }
1322
1323
1324 sngss7_set_flag(sngss7_info, FLAG_CKT_MN_UNBLK_RX);
1325
1326
1327 sngss7_clear_flag(sngss7_info, FLAG_CKT_MN_BLOCK_RX);
1328
1329
1330 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
1331
1332
1333 ftdm_mutex_unlock(ftdmchan->mutex);
1334
1335 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1336 return FTDM_SUCCESS;
1337 }
1338
1339
1340 ftdm_status_t handle_ubl_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1341 {
1342 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1343
1344 sngss7_chan_data_t *sngss7_info = NULL;
1345 ftdm_channel_t *ftdmchan = NULL;
1346
1347
1348 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1349 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1350 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1351 return FTDM_FAIL;
1352 }
1353
1354
1355 ftdm_mutex_lock(ftdmchan->mutex);
1356
1357
1358
1359
1360 ftdm_mutex_unlock(ftdmchan->mutex);
1361
1362 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1363 return FTDM_SUCCESS;
1364 }
1365
1366
1367 ftdm_status_t handle_rsc_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1368 {
1369 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1370
1371 sngss7_chan_data_t *sngss7_info = NULL;
1372 ftdm_channel_t *ftdmchan = NULL;
1373
1374
1375 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1376 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1377 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1378 return FTDM_FAIL;
1379 }
1380
1381
1382 ftdm_mutex_lock(ftdmchan->mutex);
1383
1384
1385 sngss7_set_flag(sngss7_info, FLAG_RESET_RX);
1386
1387 switch (ftdmchan->state) {
1388
1389 case FTDM_CHANNEL_STATE_RESTART:
1390
1391
1392 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE);
1393
1394 break;
1395
1396 default:
1397
1398
1399 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
1400 break;
1401
1402 }
1403
1404
1405 ftdm_mutex_unlock(ftdmchan->mutex);
1406
1407 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1408 return FTDM_SUCCESS;
1409 }
1410
1411
1412 ftdm_status_t handle_local_rsc_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1413 {
1414 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1415
1416 sngss7_chan_data_t *sngss7_info = NULL;
1417 ftdm_channel_t *ftdmchan = NULL;
1418
1419
1420 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1421 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1422 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1423 return FTDM_FAIL;
1424 }
1425
1426
1427 ftdm_mutex_lock(ftdmchan->mutex);
1428
1429
1430 sngss7_set_flag(sngss7_info, FLAG_RESET_RX);
1431
1432 switch (ftdmchan->state) {
1433
1434 case FTDM_CHANNEL_STATE_RESTART:
1435
1436
1437 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_IDLE);
1438
1439 break;
1440
1441 default:
1442
1443
1444 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RESTART);
1445 break;
1446
1447 }
1448
1449
1450 ftdm_mutex_unlock(ftdmchan->mutex);
1451
1452 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1453 return FTDM_SUCCESS;
1454 }
1455
1456
1457 ftdm_status_t handle_rsc_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1458 {
1459 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1460
1461 sngss7_chan_data_t *sngss7_info = NULL;
1462 ftdm_channel_t *ftdmchan = NULL;
1463
1464
1465 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1466 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1467 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1468 return FTDM_FAIL;
1469 }
1470
1471
1472 ftdm_mutex_lock(ftdmchan->mutex);
1473
1474 switch (ftdmchan->state) {
1475
1476 case FTDM_CHANNEL_STATE_RESTART:
1477
1478 if ( sngss7_test_flag(sngss7_info, FLAG_RESET_TX) ) {
1479
1480 sngss7_set_flag(sngss7_info, FLAG_RESET_TX_RSP);
1481
1482
1483 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
1484 } else {
1485 SS7_ERROR("Received RSC-RLC but we're not waiting on a RSC-RLC on CIC #, dropping\n", sngss7_info->circuit->cic);
1486 }
1487
1488 break;
1489
1490 case FTDM_CHANNEL_STATE_DOWN:
1491
1492
1493 SS7_DEBUG("Receveived RSC-RLC in down state, dropping\n");
1494
1495 break;
1496
1497 case FTDM_CHANNEL_STATE_TERMINATING:
1498 case FTDM_CHANNEL_STATE_HANGUP:
1499 case FTDM_CHANNEL_STATE_HANGUP_COMPLETE:
1500
1501
1502 sngss7_set_flag(sngss7_info, FLAG_RESET_TX_RSP);
1503
1504
1505 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
1506
1507 break;
1508
1509 default:
1510
1511 if ((siStaEvnt != NULL) &&
1512 (siStaEvnt->causeDgn.eh.pres ==PRSNT_NODEF) &&
1513 (siStaEvnt->causeDgn.causeVal.pres == PRSNT_NODEF)) {
1514 ftdmchan->caller_data.hangup_cause = siStaEvnt->causeDgn.causeVal.val;
1515 } else {
1516 ftdmchan->caller_data.hangup_cause = 98;
1517 }
1518
1519 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_TERMINATING);
1520 break;
1521
1522 }
1523
1524
1525 ftdm_mutex_unlock(ftdmchan->mutex);
1526
1527 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1528 return FTDM_SUCCESS;
1529 }
1530
1531 ftdm_status_t handle_grs_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1532 {
1533 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1534
1535 sngss7_chan_data_t *sngss7_info = NULL;
1536 ftdm_channel_t *ftdmchan = NULL;
1537 sngss7_span_data_t *sngss7_span = NULL;
1538 int range;
1539
1540
1541 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1542 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1543 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1544 return FTDM_FAIL;
1545 }
1546
1547
1548 if ((siStaEvnt->rangStat.eh.pres == PRSNT_NODEF) && (siStaEvnt->rangStat.range.pres == PRSNT_NODEF)) {
1549 range = siStaEvnt->rangStat.range.val;
1550 } else {
1551 SS7_ERROR("Received GRS with no range value on CIC = %d\n", sngss7_info->circuit->cic);
1552 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1553 return FTDM_FAIL;
1554 }
1555
1556
1557 sngss7_span = ftdmchan->span->mod_data;
1558 sngss7_span->rx_grs.circuit = circuit;
1559 sngss7_span->rx_grs.range = range;
1560
1561
1562
1563 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1564 return FTDM_SUCCESS;
1565 }
1566
1567
1568 ftdm_status_t handle_grs_rsp(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1569 {
1570 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1571
1572 sngss7_chan_data_t *sngss7_info = NULL;
1573 ftdm_channel_t *ftdmchan = NULL;
1574 sngss7_span_data_t *sngss7_span = NULL;
1575 int range;
1576
1577 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1578 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1579 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1580 return FTDM_FAIL;
1581 }
1582
1583
1584 if ((siStaEvnt->rangStat.eh.pres == PRSNT_NODEF) && (siStaEvnt->rangStat.range.pres == PRSNT_NODEF)) {
1585 range = siStaEvnt->rangStat.range.val;
1586 } else {
1587 SS7_ERROR("Received GRA with no range value on CIC = %d\n", sngss7_info->circuit->cic);
1588 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1589 return FTDM_FAIL;
1590 }
1591
1592
1593 sngss7_span = ftdmchan->span->mod_data;
1594 sngss7_span->rx_gra.circuit = circuit;
1595 sngss7_span->rx_gra.range = range;
1596
1597
1598 if ((siStaEvnt != NULL) &&
1599 (siStaEvnt->causeDgn.eh.pres == PRSNT_NODEF) &&
1600 (siStaEvnt->causeDgn.causeVal.pres == PRSNT_NODEF)) {
1601
1602 sngss7_span->rx_gra.cause = siStaEvnt->causeDgn.causeVal.val;
1603 }
1604
1605
1606
1607 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1608 return FTDM_SUCCESS;
1609 }
1610
1611
1612 ftdm_status_t handle_local_blk(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1613 {
1614 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1615
1616 sngss7_chan_data_t *sngss7_info = NULL;
1617 ftdm_channel_t *ftdmchan = NULL;
1618
1619
1620 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1621 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1622 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1623 return FTDM_FAIL;
1624 }
1625
1626
1627 ftdm_mutex_lock(ftdmchan->mutex);
1628
1629
1630 if (sngss7_test_flag(sngss7_info, FLAG_CKT_LC_BLOCK_RX)) {
1631 SS7_WARN("Received local BLO on circuit that is already blocked!\n");
1632 }
1633
1634
1635 sngss7_set_flag(sngss7_info, FLAG_CKT_LC_BLOCK_RX);
1636
1637
1638 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
1639
1640
1641 ftdm_mutex_unlock(ftdmchan->mutex);
1642
1643 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1644 return FTDM_SUCCESS;
1645 }
1646
1647
1648 ftdm_status_t handle_local_ubl(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1649 {
1650 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1651
1652 sngss7_chan_data_t *sngss7_info = NULL;
1653 ftdm_channel_t *ftdmchan = NULL;
1654
1655
1656 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1657 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1658 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1659 return FTDM_FAIL;
1660 }
1661
1662
1663 ftdm_mutex_lock(ftdmchan->mutex);
1664
1665
1666 if (sngss7_test_flag(sngss7_info, FLAG_CKT_LC_UNBLK_RX)) {
1667 SS7_WARN("Received local UBL on circuit that is already unblocked!\n");
1668 }
1669
1670
1671 sngss7_set_flag(sngss7_info, FLAG_CKT_LC_UNBLK_RX);
1672
1673
1674 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
1675
1676
1677 ftdm_mutex_unlock(ftdmchan->mutex);
1678
1679 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1680 return FTDM_SUCCESS;
1681 }
1682
1683
1684 ftdm_status_t handle_ucic(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1685 {
1686 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1687
1688 sngss7_chan_data_t *sngss7_info = NULL;
1689 ftdm_channel_t *ftdmchan = NULL;
1690
1691
1692 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1693 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1694 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1695 return FTDM_FAIL;
1696 }
1697
1698
1699 ftdm_mutex_lock(ftdmchan->mutex);
1700
1701
1702 sngss7_set_flag(sngss7_info, FLAG_CKT_UCIC_BLOCK);
1703
1704
1705 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_SUSPENDED);
1706
1707
1708 ftdm_mutex_unlock(ftdmchan->mutex);
1709
1710 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1711 return FTDM_SUCCESS;
1712 }
1713
1714
1715 ftdm_status_t handle_cgb_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1716 {
1717 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1718
1719 sngss7_chan_data_t *sngss7_info = NULL;
1720 sngss7_span_data_t *sngss7_span = NULL;
1721 ftdm_channel_t *ftdmchan = NULL;
1722 int range;
1723 uint8_t status[255];
1724 int blockType = 0;
1725 int byte = 0;
1726 int bit = 0;
1727 int x;
1728 ftdm_sigmsg_t sigev;
1729
1730 memset(&sigev, 0, sizeof (sigev));
1731 memset(&status[0], '\0', sizeof(status));
1732
1733
1734 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1735 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1736 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1737 return FTDM_FAIL;
1738 }
1739
1740
1741 sngss7_span = ftdmchan->span->mod_data;
1742
1743
1744 if ((siStaEvnt->cgsmti.eh.pres == PRSNT_NODEF) && (siStaEvnt->cgsmti.typeInd.pres == PRSNT_NODEF)) {
1745 blockType = siStaEvnt->cgsmti.typeInd.val;
1746 } else {
1747 SS7_ERROR("Received CGB with no circuit group supervision value on CIC = %d\n", sngss7_info->circuit->cic);
1748 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1749 return FTDM_FAIL;
1750 }
1751
1752
1753 if ((siStaEvnt->rangStat.eh.pres == PRSNT_NODEF) && (siStaEvnt->rangStat.range.pres == PRSNT_NODEF)) {
1754 range = siStaEvnt->rangStat.range.val;
1755 } else {
1756 SS7_ERROR("Received CGB with no range value on CIC = %d\n", sngss7_info->circuit->cic);
1757 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1758 return FTDM_FAIL;
1759 }
1760
1761
1762 if ((siStaEvnt->rangStat.eh.pres == PRSNT_NODEF) && (siStaEvnt->rangStat.status.pres == PRSNT_NODEF)) {
1763 for (x = 0; x < siStaEvnt->rangStat.status.len; x++) {
1764 status[x] = siStaEvnt->rangStat.status.val[x];
1765 }
1766 } else {
1767 SS7_ERROR("Received CGB with no status value on CIC = %d\n", sngss7_info->circuit->cic);
1768 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1769 return FTDM_FAIL;
1770 }
1771
1772
1773 sngss7_span->rx_cgb.circuit = circuit;
1774 sngss7_span->rx_cgb.range = range;
1775 sngss7_span->rx_cgb.type = blockType;
1776 for (x = 0; x < siStaEvnt->rangStat.status.len; x++) {
1777 sngss7_span->rx_cgb.status[x] = status[x];
1778 }
1779
1780
1781 for (x = circuit; x < (circuit + range + 1); x++) {
1782
1783 if (g_ftdm_sngss7_data.cfg.isupCkt[x].type != VOICE) continue;
1784
1785
1786 if (extract_chan_data(x, &sngss7_info, &ftdmchan)) {
1787 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", x);
1788 break;
1789 }
1790
1791
1792 ftdm_mutex_lock(ftdmchan->mutex);
1793
1794 #if 0
1795 SS7_ERROR("KONRAD -> circuit=%d, byte=%d, bit=%d, status[byte]=%d, math=%d\n",
1796 x,
1797 byte,
1798 bit,
1799 status[byte],
1800 (status[byte] & (1 << bit)));
1801 #endif
1802 if (status[byte] & (1 << bit)) {
1803 switch (blockType) {
1804
1805 case 0:
1806 sngss7_set_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX);
1807 break;
1808
1809 case 1:
1810 sngss7_set_flag(sngss7_info, FLAG_GRP_HW_BLOCK_RX);
1811 break;
1812
1813 case 2:
1814 break;
1815
1816 default:
1817 break;
1818
1819 }
1820 }
1821
1822 sigev.chan_id = ftdmchan->chan_id;
1823 sigev.span_id = ftdmchan->span_id;
1824 sigev.channel = ftdmchan;
1825
1826
1827 sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
1828 sigev.sigstatus = FTDM_SIG_STATE_DOWN;
1829 ftdm_span_send_signal(ftdmchan->span, &sigev);
1830
1831
1832 ftdm_mutex_unlock(ftdmchan->mutex);
1833
1834
1835 bit ++;
1836 if (bit == 8) {
1837 byte++;
1838 bit = 0;
1839 }
1840
1841 }
1842
1843
1844 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1845 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1846 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1847 return FTDM_FAIL;
1848 }
1849
1850 ft_to_sngss7_cgba(ftdmchan);
1851
1852 return FTDM_SUCCESS;
1853 }
1854
1855
1856 ftdm_status_t handle_cgu_req(uint32_t suInstId, uint32_t spInstId, uint32_t circuit, uint8_t globalFlg, uint8_t evntType, SiStaEvnt *siStaEvnt)
1857 {
1858 SS7_FUNC_TRACE_ENTER(__FUNCTION__);
1859
1860 sngss7_chan_data_t *sngss7_info = NULL;
1861 sngss7_span_data_t *sngss7_span = NULL;
1862 ftdm_channel_t *ftdmchan = NULL;
1863 int range;
1864 uint8_t status[255];
1865 int blockType = 0;
1866 int byte = 0;
1867 int bit = 0;
1868 int x;
1869 ftdm_sigmsg_t sigev;
1870
1871 memset(&sigev, 0, sizeof (sigev));
1872 memset(&status[0], '\0', sizeof(status));
1873
1874
1875 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1876 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1877 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1878 return FTDM_FAIL;
1879 }
1880
1881
1882 sngss7_span = ftdmchan->span->mod_data;
1883
1884
1885 if ((siStaEvnt->cgsmti.eh.pres == PRSNT_NODEF) && (siStaEvnt->cgsmti.typeInd.pres == PRSNT_NODEF)) {
1886 blockType = siStaEvnt->cgsmti.typeInd.val;
1887 } else {
1888 SS7_ERROR("Received CGU with no circuit group supervision value on CIC = %d\n", sngss7_info->circuit->cic);
1889 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1890 return FTDM_FAIL;
1891 }
1892
1893
1894 if ((siStaEvnt->rangStat.eh.pres == PRSNT_NODEF) && (siStaEvnt->rangStat.range.pres == PRSNT_NODEF)) {
1895 range = siStaEvnt->rangStat.range.val;
1896 } else {
1897 SS7_ERROR("Received CGU with no range value on CIC = %d\n", sngss7_info->circuit->cic);
1898 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1899 return FTDM_FAIL;
1900 }
1901
1902
1903 if ((siStaEvnt->rangStat.eh.pres == PRSNT_NODEF) && (siStaEvnt->rangStat.status.pres == PRSNT_NODEF)) {
1904 for (x = 0; x < siStaEvnt->rangStat.status.len; x++) {
1905 status[x] = siStaEvnt->rangStat.status.val[x];
1906 }
1907 } else {
1908 SS7_ERROR("Received CGU with no status value on CIC = %d\n", sngss7_info->circuit->cic);
1909 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1910 return FTDM_FAIL;
1911 }
1912
1913
1914 sngss7_span->rx_cgu.circuit = circuit;
1915 sngss7_span->rx_cgu.range = range;
1916 sngss7_span->rx_cgu.type = blockType;
1917 for (x = 0; x < siStaEvnt->rangStat.status.len; x++) {
1918 sngss7_span->rx_cgu.status[x] = status[x];
1919 }
1920
1921
1922 for (x = circuit; x < (circuit + range + 1); x++) {
1923 if (g_ftdm_sngss7_data.cfg.isupCkt[x].type != VOICE) continue;
1924
1925 if (extract_chan_data(x, &sngss7_info, &ftdmchan)) {
1926 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", x);
1927 break;
1928 }
1929
1930
1931 ftdm_mutex_lock(ftdmchan->mutex);
1932
1933 if (status[byte] & (1 << bit)) {
1934 switch (blockType) {
1935
1936 case 0:
1937 sngss7_clear_flag(sngss7_info, FLAG_GRP_MN_BLOCK_RX);
1938 break;
1939
1940 case 1:
1941 sngss7_clear_flag(sngss7_info, FLAG_GRP_HW_BLOCK_RX);
1942 break;
1943
1944 case 2:
1945 break;
1946
1947 default:
1948 break;
1949
1950 }
1951 }
1952
1953 sigev.chan_id = ftdmchan->chan_id;
1954 sigev.span_id = ftdmchan->span_id;
1955 sigev.channel = ftdmchan;
1956
1957
1958 sigev.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
1959 sigev.sigstatus = FTDM_SIG_STATE_UP;
1960 ftdm_span_send_signal(ftdmchan->span, &sigev);
1961
1962
1963 ftdm_mutex_unlock(ftdmchan->mutex);
1964
1965
1966 bit ++;
1967 if (bit == 8) {
1968 byte++;
1969 bit = 0;
1970 }
1971
1972 }
1973
1974
1975 if (extract_chan_data(circuit, &sngss7_info, &ftdmchan)) {
1976 SS7_ERROR("Failed to extract channel data for circuit = %d!\n", circuit);
1977 SS7_FUNC_TRACE_EXIT(__FUNCTION__);
1978 return FTDM_FAIL;
1979 }
1980
1981 ft_to_sngss7_cgua(ftdmchan);
1982
1983 return FTDM_SUCCESS;
1984 }
1985
1986
1987
1988
1989
1990
1991
1992
1993
1994
1995
1996
1997