This source file includes following definitions.
- clear_call_data
- clear_call_glare_data
- get_unique_suInstId
- get_ftdmchan_by_suInstId
- get_ftdmchan_by_spInstId
- sng_isdn_set_avail_rate
- cpy_calling_num_from_stack
- cpy_called_num_from_stack
- cpy_redir_num_from_stack
- cpy_calling_name_from_stack
- cpy_calling_num_from_user
- cpy_called_num_from_user
- cpy_redir_num_from_user
- cpy_calling_name_from_user
- sngisdn_delayed_release
- sngisdn_delayed_connect
- sngisdn_delayed_disconnect
- sngisdn_facility_timeout
- sngisdn_check_free_ids
- get_memory_info
- sngisdn_get_infoTranCap_from_stack
- sngisdn_get_usrInfoLyr1Prot_from_stack
- sngisdn_get_infoTranCap_from_user
- sngisdn_get_usrInfoLyr1Prot_from_user
- sngisdn_print_phy_stats
- sngisdn_print_span
- sngisdn_print_spans
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_isdn.h"
36
37 ftdm_status_t cpy_calling_num_from_stack(ftdm_caller_data_t *ftdm, CgPtyNmb *cgPtyNmb);
38 ftdm_status_t cpy_called_num_from_stack(ftdm_caller_data_t *ftdm, CdPtyNmb *cdPtyNmb);
39 ftdm_status_t cpy_redir_num_from_stack(ftdm_caller_data_t *ftdm, RedirNmb *redirNmb);
40 ftdm_status_t cpy_calling_name_from_stack(ftdm_caller_data_t *ftdm, Display *display);
41
42 ftdm_status_t cpy_calling_num_from_user(CgPtyNmb *cgPtyNmb, ftdm_caller_data_t *ftdm);
43 ftdm_status_t cpy_called_num_from_user(CdPtyNmb *cdPtyNmb, ftdm_caller_data_t *ftdm);
44 ftdm_status_t cpy_redir_num_from_user(RedirNmb *redirNmb, ftdm_caller_data_t *ftdm);
45 ftdm_status_t cpy_calling_name_from_user(ConEvnt *conEvnt, ftdm_channel_t *ftdmchan);
46
47 ftdm_status_t sngisdn_check_free_ids(void);
48
49 extern ftdm_sngisdn_data_t g_sngisdn_data;
50 void get_memory_info(void);
51
52 void __inline__ clear_call_data(sngisdn_chan_data_t *sngisdn_info)
53 {
54 uint32_t cc_id = ((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->cc_id;
55
56 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_DEBUG, "Clearing call data (suId:%u suInstId:%u spInstId:%u)\n", cc_id, sngisdn_info->suInstId, sngisdn_info->spInstId);
57 ftdm_mutex_lock(g_sngisdn_data.ccs[cc_id].mutex);
58 g_sngisdn_data.ccs[cc_id].active_spInstIds[sngisdn_info->spInstId]=NULL;
59 g_sngisdn_data.ccs[cc_id].active_suInstIds[sngisdn_info->suInstId]=NULL;
60 ftdm_mutex_unlock(g_sngisdn_data.ccs[cc_id].mutex);
61
62 sngisdn_info->suInstId = 0;
63 sngisdn_info->spInstId = 0;
64 sngisdn_info->globalFlg = 0;
65 sngisdn_info->flags = 0;
66 return;
67 }
68
69 void __inline__ clear_call_glare_data(sngisdn_chan_data_t *sngisdn_info)
70 {
71 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_DEBUG, "Clearing glare data (suId:%d suInstId:%u spInstId:%u actv-suInstId:%u actv-spInstId:%u)\n",
72 sngisdn_info->glare.suId,
73 sngisdn_info->glare.suInstId, sngisdn_info->glare.spInstId,
74 sngisdn_info->suInstId, sngisdn_info->spInstId);
75
76 ftdm_mutex_lock(g_sngisdn_data.ccs[sngisdn_info->glare.suId].mutex);
77 if (sngisdn_info->glare.spInstId != sngisdn_info->spInstId) {
78 g_sngisdn_data.ccs[sngisdn_info->glare.suId].active_spInstIds[sngisdn_info->glare.spInstId]=NULL;
79 }
80 g_sngisdn_data.ccs[sngisdn_info->glare.suId].active_suInstIds[sngisdn_info->glare.suInstId]=NULL;
81 ftdm_mutex_unlock(g_sngisdn_data.ccs[sngisdn_info->glare.suId].mutex);
82
83 ftdm_clear_flag(sngisdn_info, FLAG_GLARE);
84 memset(&sngisdn_info->glare.setup, 0, sizeof(ConEvnt));
85 sngisdn_info->glare.suId = 0;
86 sngisdn_info->glare.suInstId = 0;
87 sngisdn_info->glare.spInstId = 0;
88 sngisdn_info->glare.dChan = 0;
89 sngisdn_info->glare.ces = 0;
90 return;
91 }
92
93
94 uint32_t __inline__ get_unique_suInstId(uint8_t cc_id)
95 {
96 uint32_t suInstId;
97 ftdm_mutex_lock(g_sngisdn_data.ccs[cc_id].mutex);
98 suInstId = g_sngisdn_data.ccs[cc_id].last_suInstId;
99
100 while(1) {
101 if (++suInstId == MAX_INSTID) {
102 suInstId = 1;
103 }
104 if (g_sngisdn_data.ccs[cc_id].active_suInstIds[suInstId] == NULL) {
105 g_sngisdn_data.ccs[cc_id].last_suInstId = suInstId;
106 ftdm_mutex_unlock(g_sngisdn_data.ccs[cc_id].mutex);
107 return suInstId;
108 }
109 }
110
111 ftdm_mutex_unlock(g_sngisdn_data.ccs[cc_id].mutex);
112 return 0;
113 }
114
115 ftdm_status_t __inline__ get_ftdmchan_by_suInstId(uint8_t cc_id, uint32_t suInstId, sngisdn_chan_data_t **sngisdn_data)
116 {
117 ftdm_assert_return(g_sngisdn_data.ccs[cc_id].activation_done, FTDM_FAIL, "Trying to find call on unconfigured CC\n");
118
119 if (g_sngisdn_data.ccs[cc_id].active_suInstIds[suInstId] == NULL) {
120 return FTDM_FAIL;
121 }
122 *sngisdn_data = g_sngisdn_data.ccs[cc_id].active_suInstIds[suInstId];
123 return FTDM_SUCCESS;
124 }
125
126 ftdm_status_t __inline__ get_ftdmchan_by_spInstId(uint8_t cc_id, uint32_t spInstId, sngisdn_chan_data_t **sngisdn_data)
127 {
128 ftdm_assert_return(g_sngisdn_data.ccs[cc_id].activation_done, FTDM_FAIL, "Trying to find call on unconfigured CC\n");
129
130 if (g_sngisdn_data.ccs[cc_id].active_spInstIds[spInstId] == NULL) {
131 return FTDM_FAIL;
132 }
133 *sngisdn_data = g_sngisdn_data.ccs[cc_id].active_spInstIds[spInstId];
134 return FTDM_SUCCESS;
135 }
136
137 ftdm_status_t sng_isdn_set_avail_rate(ftdm_span_t *span, sngisdn_avail_t avail)
138 {
139
140 if (span->trunk_type == FTDM_TRUNK_BRI ||
141 span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
142
143 ftdm_iterator_t *chaniter = NULL;
144 ftdm_iterator_t *curr = NULL;
145
146
147 chaniter = ftdm_span_get_chan_iterator(span, NULL);
148 for (curr = chaniter; curr; curr = ftdm_iterator_next(curr)) {
149 ftdm_log_chan(((ftdm_channel_t*)ftdm_iterator_current(curr)), FTDM_LOG_DEBUG, "Setting availability rate to:%d\n", avail);
150 ((ftdm_channel_t*)ftdm_iterator_current(curr))->availability_rate = avail;
151 }
152 ftdm_iterator_free(chaniter);
153 }
154 return FTDM_SUCCESS;
155 }
156
157 ftdm_status_t cpy_calling_num_from_stack(ftdm_caller_data_t *ftdm, CgPtyNmb *cgPtyNmb)
158 {
159 if (cgPtyNmb->eh.pres != PRSNT_NODEF) {
160 return FTDM_FAIL;
161 }
162
163 if (cgPtyNmb->screenInd.pres == PRSNT_NODEF) {
164 ftdm->screen = cgPtyNmb->screenInd.val;
165 }
166
167 if (cgPtyNmb->presInd0.pres == PRSNT_NODEF) {
168 ftdm->pres = cgPtyNmb->presInd0.val;
169 }
170
171 if (cgPtyNmb->nmbPlanId.pres == PRSNT_NODEF) {
172 ftdm->cid_num.plan = cgPtyNmb->nmbPlanId.val;
173 }
174 if (cgPtyNmb->typeNmb1.pres == PRSNT_NODEF) {
175 ftdm->cid_num.type = cgPtyNmb->typeNmb1.val;
176 }
177
178 if (cgPtyNmb->nmbDigits.pres == PRSNT_NODEF) {
179 ftdm_copy_string(ftdm->cid_num.digits, (const char*)cgPtyNmb->nmbDigits.val, cgPtyNmb->nmbDigits.len+1);
180 }
181 return FTDM_SUCCESS;
182 }
183
184 ftdm_status_t cpy_called_num_from_stack(ftdm_caller_data_t *ftdm, CdPtyNmb *cdPtyNmb)
185 {
186 if (cdPtyNmb->eh.pres != PRSNT_NODEF) {
187 return FTDM_FAIL;
188 }
189
190 if (cdPtyNmb->nmbPlanId.pres == PRSNT_NODEF) {
191 ftdm->dnis.plan = cdPtyNmb->nmbPlanId.val;
192 }
193
194 if (cdPtyNmb->typeNmb0.pres == PRSNT_NODEF) {
195 ftdm->dnis.type = cdPtyNmb->typeNmb0.val;
196 }
197
198 if (cdPtyNmb->nmbDigits.pres == PRSNT_NODEF) {
199 unsigned i = strlen(ftdm->dnis.digits);
200
201 ftdm_copy_string(&ftdm->dnis.digits[i], (const char*)cdPtyNmb->nmbDigits.val, cdPtyNmb->nmbDigits.len+1);
202 }
203 return FTDM_SUCCESS;
204 }
205
206 ftdm_status_t cpy_redir_num_from_stack(ftdm_caller_data_t *ftdm, RedirNmb *redirNmb)
207 {
208 if (redirNmb->eh.pres != PRSNT_NODEF) {
209 return FTDM_FAIL;
210 }
211
212 if (redirNmb->nmbPlanId.pres == PRSNT_NODEF) {
213 ftdm->rdnis.plan = redirNmb->nmbPlanId.val;
214 }
215
216 if (redirNmb->typeNmb.pres == PRSNT_NODEF) {
217 ftdm->rdnis.type = redirNmb->typeNmb.val;
218 }
219
220 if (redirNmb->nmbDigits.pres == PRSNT_NODEF) {
221 ftdm_copy_string(ftdm->rdnis.digits, (const char*)redirNmb->nmbDigits.val, redirNmb->nmbDigits.len+1);
222 }
223 return FTDM_SUCCESS;
224 }
225
226 ftdm_status_t cpy_calling_name_from_stack(ftdm_caller_data_t *ftdm, Display *display)
227 {
228 if (display->eh.pres != PRSNT_NODEF) {
229 return FTDM_FAIL;
230 }
231 if (display->dispInfo.pres != PRSNT_NODEF) {
232 return FTDM_FAIL;
233 }
234
235 ftdm_copy_string(ftdm->cid_name, (const char*)display->dispInfo.val, display->dispInfo.len+1);
236 return FTDM_SUCCESS;
237 }
238
239 ftdm_status_t cpy_calling_num_from_user(CgPtyNmb *cgPtyNmb, ftdm_caller_data_t *ftdm)
240 {
241 uint8_t len = strlen(ftdm->cid_num.digits);
242 if (!len) {
243 return FTDM_SUCCESS;
244 }
245 cgPtyNmb->eh.pres = PRSNT_NODEF;
246
247 cgPtyNmb->screenInd.pres = PRSNT_NODEF;
248 cgPtyNmb->screenInd.val = ftdm->screen;
249
250 cgPtyNmb->presInd0.pres = PRSNT_NODEF;
251 cgPtyNmb->presInd0.val = ftdm->pres;
252
253 cgPtyNmb->nmbPlanId.pres = PRSNT_NODEF;
254 cgPtyNmb->nmbPlanId.val = ftdm->cid_num.plan;
255
256 cgPtyNmb->typeNmb1.pres = PRSNT_NODEF;
257 cgPtyNmb->typeNmb1.val = ftdm->cid_num.type;
258
259 cgPtyNmb->nmbDigits.pres = PRSNT_NODEF;
260 cgPtyNmb->nmbDigits.len = len;
261
262 memcpy(cgPtyNmb->nmbDigits.val, ftdm->cid_num.digits, len);
263
264 return FTDM_SUCCESS;
265 }
266
267 ftdm_status_t cpy_called_num_from_user(CdPtyNmb *cdPtyNmb, ftdm_caller_data_t *ftdm)
268 {
269 uint8_t len = strlen(ftdm->dnis.digits);
270 if (!len) {
271 return FTDM_SUCCESS;
272 }
273 cdPtyNmb->eh.pres = PRSNT_NODEF;
274
275 cdPtyNmb->nmbPlanId.pres = PRSNT_NODEF;
276 if (ftdm->dnis.plan == FTDM_NPI_INVALID) {
277 cdPtyNmb->nmbPlanId.val = FTDM_NPI_UNKNOWN;
278 } else {
279 cdPtyNmb->nmbPlanId.val = ftdm->dnis.plan;
280 }
281
282 cdPtyNmb->typeNmb0.pres = PRSNT_NODEF;
283 if (ftdm->dnis.type == FTDM_TON_INVALID) {
284 cdPtyNmb->typeNmb0.val = FTDM_TON_UNKNOWN;
285 } else {
286 cdPtyNmb->typeNmb0.val = ftdm->dnis.type;
287 }
288
289 cdPtyNmb->nmbDigits.pres = PRSNT_NODEF;
290 cdPtyNmb->nmbDigits.len = len;
291
292
293 memcpy(cdPtyNmb->nmbDigits.val, ftdm->dnis.digits, len);
294 return FTDM_SUCCESS;
295 }
296
297 ftdm_status_t cpy_redir_num_from_user(RedirNmb *redirNmb, ftdm_caller_data_t *ftdm)
298 {
299 uint8_t len = strlen(ftdm->rdnis.digits);
300 if (!len) {
301 return FTDM_SUCCESS;
302 }
303
304 redirNmb->eh.pres = PRSNT_NODEF;
305
306 redirNmb->nmbPlanId.pres = PRSNT_NODEF;
307 if (ftdm->rdnis.plan == FTDM_NPI_INVALID) {
308 redirNmb->nmbPlanId.val = FTDM_NPI_UNKNOWN;
309 } else {
310 redirNmb->nmbPlanId.val = ftdm->rdnis.plan;
311 }
312
313 redirNmb->typeNmb.pres = PRSNT_NODEF;
314 if (ftdm->rdnis.type == FTDM_TON_INVALID) {
315 redirNmb->typeNmb.val = FTDM_TON_UNKNOWN;
316 } else {
317 redirNmb->typeNmb.val = ftdm->rdnis.type;
318 }
319
320 redirNmb->nmbDigits.pres = PRSNT_NODEF;
321 redirNmb->nmbDigits.len = len;
322
323 memcpy(redirNmb->nmbDigits.val, ftdm->rdnis.digits, len);
324
325 return FTDM_SUCCESS;
326 }
327
328
329 ftdm_status_t cpy_calling_name_from_user(ConEvnt *conEvnt, ftdm_channel_t *ftdmchan)
330 {
331 uint8_t len;
332 ftdm_caller_data_t *ftdm = &ftdmchan->caller_data;
333
334 sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
335
336 len = strlen(ftdm->cid_name);
337 if (!len) {
338 return FTDM_SUCCESS;
339 }
340
341 if (ftdmchan->span->trunk_type == FTDM_TRUNK_BRI ||
342 ftdmchan->span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
343
344 conEvnt->usrUsr.eh.pres = PRSNT_NODEF;
345 conEvnt->usrUsr.protocolDisc.pres = PRSNT_NODEF;
346 conEvnt->usrUsr.protocolDisc.val = PD_IA5;
347 conEvnt->usrUsr.usrInfo.pres = PRSNT_NODEF;
348 conEvnt->usrUsr.usrInfo.len = len;
349
350
351 memcpy(conEvnt->usrUsr.usrInfo.val, ftdm->cid_name, len);
352 } else {
353 switch (signal_data->switchtype) {
354 case SNGISDN_SWITCH_NI2:
355
356
357 break;
358 case SNGISDN_SWITCH_EUROISDN:
359 if (signal_data->signalling != SNGISDN_SIGNALING_NET) {
360 break;
361 }
362
363 case SNGISDN_SWITCH_5ESS:
364 case SNGISDN_SWITCH_4ESS:
365 case SNGISDN_SWITCH_DMS100:
366 conEvnt->display.eh.pres = PRSNT_NODEF;
367 conEvnt->display.dispInfo.pres = PRSNT_NODEF;
368 conEvnt->display.dispInfo.len = len;
369 memcpy(conEvnt->display.dispInfo.val, ftdm->cid_name, len);
370 break;
371 case SNGISDN_SWITCH_QSIG:
372
373 break;
374 case SNGISDN_SWITCH_INSNET:
375
376 break;
377 }
378 }
379 return FTDM_SUCCESS;
380 }
381
382 void sngisdn_delayed_release(void* p_sngisdn_info)
383 {
384 sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)p_sngisdn_info;
385 ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
386 sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
387
388 ftdm_mutex_lock(ftdmchan->mutex);
389
390 if (ftdm_test_flag(sngisdn_info, FLAG_DELAYED_REL)) {
391 ftdm_clear_flag(sngisdn_info, FLAG_DELAYED_REL);
392 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending delayed RELEASE (suId:%d suInstId:%u spInstId:%u)\n",
393 signal_data->cc_id, sngisdn_info->glare.spInstId, sngisdn_info->glare.suInstId);
394
395 sngisdn_snd_release(ftdmchan, 1);
396 clear_call_glare_data(sngisdn_info);
397 } else {
398 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Call was already released (suId:%d suInstId:%u spInstId:%u)\n",
399 signal_data->cc_id, sngisdn_info->glare.spInstId, sngisdn_info->glare.suInstId);
400 }
401 ftdm_mutex_unlock(ftdmchan->mutex);
402 return;
403 }
404
405 void sngisdn_delayed_connect(void* p_sngisdn_info)
406 {
407 sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)p_sngisdn_info;
408 ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
409 sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
410
411 ftdm_mutex_lock(ftdmchan->mutex);
412 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending delayed CONNECT (suId:%d suInstId:%u spInstId:%u)\n",
413 signal_data->cc_id, sngisdn_info->glare.spInstId, sngisdn_info->glare.suInstId);
414
415 sngisdn_snd_connect(ftdmchan);
416 ftdm_mutex_unlock(ftdmchan->mutex);
417 return;
418 }
419
420 void sngisdn_delayed_disconnect(void* p_sngisdn_info)
421 {
422 sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)p_sngisdn_info;
423 ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
424 sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
425
426 ftdm_mutex_lock(ftdmchan->mutex);
427 if (ftdmchan->caller_data.hangup_cause == IN_CCNORTTODEST || ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) {
428 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Sending delayed DISCONNECT (suId:%d suInstId:%u spInstId:%u)\n",
429 signal_data->cc_id, sngisdn_info->glare.spInstId, sngisdn_info->glare.suInstId);
430
431 sngisdn_snd_disconnect(ftdmchan);
432 if (ftdmchan->caller_data.hangup_cause == IN_CCNORTTODEST) {
433 ftdm_channel_t *close_chan = ftdmchan;
434 ftdm_channel_close(&close_chan);
435 }
436 }
437
438 ftdm_mutex_unlock(ftdmchan->mutex);
439 return;
440 }
441
442 void sngisdn_facility_timeout(void* p_sngisdn_info)
443 {
444 sngisdn_chan_data_t *sngisdn_info = (sngisdn_chan_data_t*)p_sngisdn_info;
445 ftdm_channel_t *ftdmchan = sngisdn_info->ftdmchan;
446 sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) ftdmchan->span->signal_data;
447
448 ftdm_mutex_lock(ftdmchan->mutex);
449 if (ftdmchan->state == FTDM_CHANNEL_STATE_GET_CALLERID) {
450 ftdm_log_chan(ftdmchan, FTDM_LOG_INFO, "Facility timeout reached proceeding with call (suId:%d suInstId:%u spInstId:%u)\n",
451 signal_data->cc_id, sngisdn_info->spInstId, sngisdn_info->suInstId);
452
453 ftdm_set_state(ftdmchan, FTDM_CHANNEL_STATE_RING);
454 }
455
456 ftdm_mutex_unlock(ftdmchan->mutex);
457 return;
458 }
459
460 ftdm_status_t sngisdn_check_free_ids(void)
461 {
462 unsigned i;
463 unsigned j;
464 ftdm_log(FTDM_LOG_INFO, "Checking suInstId's\n");
465 for(j=1;j<=MAX_VARIANTS;j++) {
466 if (g_sngisdn_data.ccs[j].config_done) {
467 for(i=1;i<MAX_INSTID;i++) {
468 if (g_sngisdn_data.ccs[j].active_suInstIds[i] != NULL) {
469 ftdm_log(FTDM_LOG_INFO, "suId:%u suInstId:%u is not free\n", j, i);
470
471
472 }
473 }
474 }
475 }
476
477 ftdm_log(FTDM_LOG_INFO, "Checking spInstId's\n");
478 for(j=1;j<=MAX_VARIANTS;j++) {
479 if (g_sngisdn_data.ccs[j].config_done) {
480 for(i=1;i<MAX_INSTID;i++) {
481 if (g_sngisdn_data.ccs[j].active_spInstIds[i] != NULL) {
482 ftdm_log(FTDM_LOG_INFO, "suId:%u spInstId:%u is not free\n", j, i);
483
484
485 }
486 }
487 }
488 }
489 ftdm_log(FTDM_LOG_INFO, "Checking ID's done\n");
490 return FTDM_SUCCESS;
491 }
492
493 void get_memory_info(void)
494 {
495 U32 availmen = 0;
496 SRegInfoShow(S_REG, &availmen);
497 return;
498 }
499
500 uint8_t sngisdn_get_infoTranCap_from_stack(ftdm_bearer_cap_t bearer_capability)
501 {
502 switch(bearer_capability) {
503 case FTDM_BEARER_CAP_SPEECH:
504 return IN_ITC_SPEECH;
505
506 case FTDM_BEARER_CAP_64K_UNRESTRICTED:
507 return IN_ITC_UNRDIG;
508
509 case FTDM_BEARER_CAP_3_1KHZ_AUDIO:
510 return IN_ITC_A31KHZ;
511
512
513 }
514 return FTDM_BEARER_CAP_SPEECH;
515 }
516
517 uint8_t sngisdn_get_usrInfoLyr1Prot_from_stack(ftdm_user_layer1_prot_t layer1_prot)
518 {
519 switch(layer1_prot) {
520 case FTDM_USER_LAYER1_PROT_V110:
521 return IN_UIL1_CCITTV110;
522
523 case FTDM_USER_LAYER1_PROT_ULAW:
524 return IN_UIL1_G711ULAW;
525
526 case FTDM_USER_LAYER1_PROT_ALAW:
527 return IN_UIL1_G711ALAW;
528
529
530 }
531 return IN_UIL1_G711ULAW;
532 }
533
534 ftdm_bearer_cap_t sngisdn_get_infoTranCap_from_user(uint8_t bearer_capability)
535 {
536 switch(bearer_capability) {
537 case IN_ITC_SPEECH:
538 return FTDM_BEARER_CAP_SPEECH;
539
540 case IN_ITC_UNRDIG:
541 return FTDM_BEARER_CAP_64K_UNRESTRICTED;
542
543 case IN_ITC_A31KHZ:
544 return FTDM_BEARER_CAP_3_1KHZ_AUDIO;
545
546 default:
547 return FTDM_BEARER_CAP_SPEECH;
548 }
549 return FTDM_BEARER_CAP_SPEECH;
550 }
551
552 ftdm_user_layer1_prot_t sngisdn_get_usrInfoLyr1Prot_from_user(uint8_t layer1_prot)
553 {
554 switch(layer1_prot) {
555 case IN_UIL1_CCITTV110:
556 return FTDM_USER_LAYER1_PROT_V110;
557 case IN_UIL1_G711ULAW:
558 return FTDM_USER_LAYER1_PROT_ULAW;
559 case IN_UIL1_G711ALAW:
560 return IN_UIL1_G711ALAW;
561 default:
562 return FTDM_USER_LAYER1_PROT_ULAW;
563 }
564 return FTDM_USER_LAYER1_PROT_ULAW;
565 }
566
567 void sngisdn_print_phy_stats(ftdm_stream_handle_t *stream, ftdm_span_t *span)
568 {
569 L1Mngmt sts;
570 sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)span->signal_data;
571
572 memset(&sts, 0, sizeof(sts));
573 sng_isdn_phy_stats(signal_data->link_id , &sts);
574
575 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
576 stream->write_function(stream, " Span:%s", span->name);
577 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
578 stream->write_function(stream, " Performance Counters");
579 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
580 stream->write_function(stream, "RX Packets:\t%u\tTX Packets:\t%u\tEvents:%u\n", sts.t.sts.rx_packets, sts.t.sts.tx_packets, sts.t.sts.rx_events);
581 stream->write_function(stream, "RX Bytes:\t%u\tTX Bytes:\t%u\n\n", sts.t.sts.rx_bytes, sts.t.sts.tx_bytes);
582 stream->write_function(stream, "TX Queue:\t%u/%u\tRX Queue:\t%u/%u\tEvents Queue:\t%u/%u\n",
583 sts.t.sts.num_frames_in_tx_queue,sts.t.sts.tx_queue_len,
584 sts.t.sts.num_frames_in_rx_queue, sts.t.sts.rx_queue_len,
585 sts.t.sts.rx_events_in_queue, sts.t.sts.event_queue_len);
586
587 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
588 stream->write_function(stream, " Errors");
589 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
590 stream->write_function(stream, "RX Errors:\t%u\tTX Errors:\t%u\n", sts.t.sts.rx_errors, sts.t.sts.tx_errors);
591 stream->write_function(stream, "RX Dropped:\t%u\tTX Dropped:\t%u\tEvents Dropped:\t%u\n", sts.t.sts.rx_dropped, sts.t.sts.tx_dropped,sts.t.sts.rx_events_dropped);
592
593
594 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
595 stream->write_function(stream, " RX Errors Details");
596 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
597 stream->write_function(stream, "CRC:\t\t%u\tFrame:\t\t%u\tOverruns:\t%u\n", sts.t.sts.rx_crc_errors, sts.t.sts.rx_frame_errors, sts.t.sts.rx_over_errors);
598 stream->write_function(stream, "Fifo:\t\t%u\tAborts:\t\t%u\tMissed:\t\t%u\n", sts.t.sts.rx_fifo_errors, sts.t.sts.rx_hdlc_abort_counter, sts.t.sts.rx_missed_errors);
599 stream->write_function(stream, "Length:\t\t%u\n", sts.t.sts.rx_length_errors);
600
601 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
602 stream->write_function(stream, " TX Errors Details");
603 stream->write_function(stream, "\n---------------------------------------------------------------------\n");
604 stream->write_function(stream, "Aborted:\t%u\tFifo:\t\t%u\tCarrier:\t%u\n", sts.t.sts.tx_aborted_errors, sts.t.sts.tx_fifo_errors, sts.t.sts.tx_carrier_errors);
605 return;
606 }
607
608
609 void sngisdn_print_span(ftdm_stream_handle_t *stream, ftdm_span_t *span)
610 {
611 ftdm_signaling_status_t sigstatus;
612 ftdm_alarm_flag_t alarmbits;
613 ftdm_channel_t *fchan;
614 alarmbits = FTDM_ALARM_NONE;
615 fchan = ftdm_span_get_channel(span, 1);
616 if (fchan) {
617 ftdm_channel_get_alarms(fchan, &alarmbits);
618 }
619
620 ftdm_span_get_sig_status(span, &sigstatus);
621 stream->write_function(stream, "span:%s physical:%s signalling:%s\n",
622 span->name, alarmbits ? "ALARMED" : "OK",
623 ftdm_signaling_status2str(sigstatus));
624 return;
625 }
626
627 void sngisdn_print_spans(ftdm_stream_handle_t *stream)
628 {
629 int i;
630 for(i=1;i<=MAX_L1_LINKS;i++) {
631 if (g_sngisdn_data.spans[i]) {
632 sngisdn_print_span(stream, g_sngisdn_data.spans[i]->ftdm_span);
633 }
634 }
635 return;
636 }
637
638
639
640
641
642
643
644
645
646
647
648
649