This source file includes following definitions.
- sngisdn_rcv_con_ind
- sngisdn_rcv_con_cfm
- sngisdn_rcv_cnst_ind
- sngisdn_rcv_disc_ind
- sngisdn_rcv_rel_ind
- sngisdn_rcv_dat_ind
- sngisdn_rcv_sshl_ind
- sngisdn_rcv_sshl_cfm
- sngisdn_rcv_rmrt_ind
- sngisdn_rcv_rmrt_cfm
- sngisdn_rcv_flc_ind
- sngisdn_rcv_fac_ind
- sngisdn_rcv_sta_cfm
- sngisdn_rcv_srv_ind
- sngisdn_rcv_srv_cfm
- sngisdn_rcv_rst_ind
- sngisdn_rcv_rst_cfm
- sngisdn_rcv_phy_ind
- sngisdn_rcv_q921_ind
- sngisdn_rcv_q931_ind
- sngisdn_rcv_cc_ind
- sngisdn_rcv_q931_trace
- sngisdn_rcv_q921_trace
- sngisdn_rcv_l1_data_req
- sngisdn_rcv_l1_cmd_req
- sngisdn_rcv_sng_assert
- sngisdn_rcv_sng_log
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 void sngisdn_rcv_con_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, ConEvnt *conEvnt, int16_t dChan, uint8_t ces)
38 {
39 uint8_t bchan_no = 0;
40 sngisdn_chan_data_t *sngisdn_info = NULL;
41 sngisdn_event_data_t *sngisdn_event = NULL;
42
43 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
44
45 ftdm_assert(g_sngisdn_data.ccs[suId].activation_done != 0, "Con Ind on unconfigured cc\n");
46 ftdm_assert(g_sngisdn_data.dchans[dChan].num_spans != 0, "Con Ind on unconfigured dchan\n");
47
48 if (conEvnt->chanId.eh.pres != PRSNT_NODEF) {
49
50 ftdm_log(FTDM_LOG_ERROR, "Incoming call without Channel Id not supported yet\n");
51 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
52 return;
53 }
54
55 if (conEvnt->chanId.chanNmbSlotMap.pres) {
56 bchan_no = conEvnt->chanId.chanNmbSlotMap.val[0];
57 } else if (conEvnt->chanId.infoChanSel.pres) {
58 bchan_no = conEvnt->chanId.infoChanSel.val;
59 }
60
61 if (!bchan_no) {
62 ftdm_log(FTDM_LOG_ERROR, "Failed to obtain b-channel number from SETUP message\n");
63 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
64 return;
65 }
66
67 if (g_sngisdn_data.dchans[dChan].channels[bchan_no] == NULL) {
68 ftdm_log(FTDM_LOG_ERROR, "Incoming call on unconfigured b-channel:%d\n", bchan_no);
69 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
70 return;
71 }
72
73 sngisdn_info = g_sngisdn_data.dchans[dChan].channels[bchan_no];
74
75 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received SETUP (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
76
77 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
78 ftdm_assert(sngisdn_event, "Failed to allocate memory\n");
79 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
80
81 sngisdn_event->event_id = SNGISDN_EVENT_CON_IND;
82 sngisdn_event->sngisdn_info = sngisdn_info;
83 sngisdn_event->suId = suId;
84 sngisdn_event->spInstId = spInstId;
85 sngisdn_event->dChan = dChan;
86 sngisdn_event->ces = ces;
87
88 ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex);
89 g_sngisdn_data.ccs[suId].active_spInstIds[spInstId] = sngisdn_info;
90 ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex);
91
92 memcpy(&sngisdn_event->event.conEvnt, conEvnt, sizeof(*conEvnt));
93
94 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
95 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
96 }
97
98 void sngisdn_rcv_con_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, CnStEvnt *cnStEvnt, int16_t dChan, uint8_t ces)
99 {
100 sngisdn_chan_data_t *sngisdn_info = NULL;
101 sngisdn_event_data_t *sngisdn_event = NULL;
102
103 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
104
105 ftdm_assert(g_sngisdn_data.ccs[suId].activation_done != 0, "Con Cfm on unconfigured cc\n");
106 ftdm_assert(g_sngisdn_data.dchans[dChan].num_spans != 0, "Con Cfm on unconfigured dchan\n");
107
108 if (get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) != FTDM_SUCCESS) {
109 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
110 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
111 return;
112 }
113
114 if (!sngisdn_info->spInstId) {
115 ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex);
116
117 sngisdn_info->spInstId = spInstId;
118 g_sngisdn_data.ccs[suId].active_spInstIds[spInstId] = sngisdn_info;
119 ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex);
120 }
121
122
123 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received CONNECT/CONNECT ACK (suId:%u suInstId:%u spInstId:%u ces:%d)\n", suId, suInstId, spInstId, ces);
124
125 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
126 ftdm_assert(sngisdn_event, "Failed to allocate memory\n");
127 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
128
129 sngisdn_event->event_id = SNGISDN_EVENT_CON_CFM;
130 sngisdn_event->sngisdn_info = sngisdn_info;
131 sngisdn_event->suId = suId;
132 sngisdn_event->suInstId = suInstId;
133 sngisdn_event->spInstId = spInstId;
134 sngisdn_event->dChan = dChan;
135 sngisdn_event->ces = ces;
136 memcpy(&sngisdn_event->event.cnStEvnt, cnStEvnt, sizeof(*cnStEvnt));
137
138 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
139 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
140 }
141
142 void sngisdn_rcv_cnst_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, CnStEvnt *cnStEvnt, uint8_t evntType, int16_t dChan, uint8_t ces)
143 {
144 sngisdn_chan_data_t *sngisdn_info = NULL;
145 sngisdn_event_data_t *sngisdn_event = NULL;
146
147 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
148
149 ftdm_assert(g_sngisdn_data.ccs[suId].activation_done != 0, "Cnst Ind on unconfigured cc\n");
150 ftdm_assert(g_sngisdn_data.dchans[dChan].num_spans != 0, "Cnst Ind on unconfigured dchan\n");
151
152 if (get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) != FTDM_SUCCESS) {
153 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
154 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
155 return;
156 }
157
158 if (!sngisdn_info->spInstId) {
159 ftdm_mutex_lock(g_sngisdn_data.ccs[suId].mutex);
160
161 sngisdn_info->spInstId = spInstId;
162 g_sngisdn_data.ccs[suId].active_spInstIds[spInstId] = sngisdn_info;
163 ftdm_mutex_unlock(g_sngisdn_data.ccs[suId].mutex);
164 }
165
166 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received %s (suId:%u suInstId:%u spInstId:%u ces:%d)\n",
167 (evntType == MI_ALERTING)?"ALERT":
168 (evntType == MI_CALLPROC)?"PROCEED":
169 (evntType == MI_PROGRESS)?"PROGRESS":
170 (evntType == MI_SETUPACK)?"SETUP ACK":
171 (evntType == MI_INFO)?"INFO":"UNKNOWN",
172 suId, suInstId, spInstId, ces);
173
174 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
175 ftdm_assert(sngisdn_event, "Failed to allocate memory\n");
176 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
177
178 sngisdn_event->event_id = SNGISDN_EVENT_CNST_IND;
179 sngisdn_event->sngisdn_info = sngisdn_info;
180 sngisdn_event->suId = suId;
181 sngisdn_event->suInstId = suInstId;
182 sngisdn_event->spInstId = spInstId;
183 sngisdn_event->dChan = dChan;
184 sngisdn_event->ces = ces;
185 sngisdn_event->evntType = evntType;
186
187 memcpy(&sngisdn_event->event.cnStEvnt, cnStEvnt, sizeof(*cnStEvnt));
188
189 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
190 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
191 }
192
193 void sngisdn_rcv_disc_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, DiscEvnt *discEvnt)
194 {
195 sngisdn_chan_data_t *sngisdn_info = NULL;
196 sngisdn_event_data_t *sngisdn_event = NULL;
197
198 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
199
200 ftdm_assert(spInstId != 0, "Received DISCONNECT with invalid id");
201
202 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
203 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
204
205 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
206 ftdm_assert(0, "Inconsistent call states\n");
207 return;
208 }
209
210 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received DISCONNECT (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
211
212 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
213 ftdm_assert(sngisdn_event, "Failed to allocate memory\n");
214 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
215
216 sngisdn_event->event_id = SNGISDN_EVENT_DISC_IND;
217 sngisdn_event->sngisdn_info = sngisdn_info;
218 sngisdn_event->suId = suId;
219 sngisdn_event->suInstId = suInstId;
220 sngisdn_event->spInstId = spInstId;
221
222 memcpy(&sngisdn_event->event.discEvnt, discEvnt, sizeof(*discEvnt));
223
224 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
225
226 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
227 }
228
229 void sngisdn_rcv_rel_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, RelEvnt *relEvnt)
230 {
231 sngisdn_chan_data_t *sngisdn_info = NULL;
232 sngisdn_event_data_t *sngisdn_event = NULL;
233
234 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
235
236 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
237 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
238
239 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
240
241
242 return;
243 }
244
245 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received RELEASE/RELEASE COMPLETE (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
246
247 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
248 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
249 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
250
251 sngisdn_event->event_id = SNGISDN_EVENT_REL_IND;
252 sngisdn_event->sngisdn_info = sngisdn_info;
253 sngisdn_event->suId = suId;
254 sngisdn_event->suInstId = suInstId;
255 sngisdn_event->spInstId = spInstId;
256
257 memcpy(&sngisdn_event->event.relEvnt, relEvnt, sizeof(*relEvnt));
258
259 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
260 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
261 }
262
263 void sngisdn_rcv_dat_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, InfoEvnt *infoEvnt)
264 {
265 sngisdn_chan_data_t *sngisdn_info;
266 sngisdn_event_data_t *sngisdn_event = NULL;
267
268 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
269
270 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
271 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
272
273 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
274 ftdm_assert(0, "Inconsistent call states\n");
275 return;
276 }
277
278 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received DATA IND suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
279
280 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
281 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
282 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
283
284 sngisdn_event->event_id = SNGISDN_EVENT_DAT_IND;
285 sngisdn_event->sngisdn_info = sngisdn_info;
286 sngisdn_event->suId = suId;
287 sngisdn_event->suInstId = suInstId;
288 sngisdn_event->spInstId = spInstId;
289
290 memcpy(&sngisdn_event->event.infoEvnt, infoEvnt, sizeof(*infoEvnt));
291
292 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
293 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
294 }
295
296 void sngisdn_rcv_sshl_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, SsHlEvnt *ssHlEvnt, uint8_t action)
297 {
298 sngisdn_chan_data_t *sngisdn_info;
299 sngisdn_event_data_t *sngisdn_event = NULL;
300
301 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
302
303 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
304 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
305
306 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
307 ftdm_assert(0, "Inconsistent call states\n");
308 return;
309 }
310
311 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received SSHL IND (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
312
313 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
314 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
315 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
316
317 sngisdn_event->event_id = SNGISDN_EVENT_SSHL_IND;
318 sngisdn_event->sngisdn_info = sngisdn_info;
319 sngisdn_event->suId = suId;
320 sngisdn_event->suInstId = suInstId;
321 sngisdn_event->spInstId = spInstId;
322 sngisdn_event->action = action;
323
324 memcpy(&sngisdn_event->event.ssHlEvnt, ssHlEvnt, sizeof(*ssHlEvnt));
325
326 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
327 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
328 }
329
330 void sngisdn_rcv_sshl_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, SsHlEvnt *ssHlEvnt, uint8_t action)
331 {
332 sngisdn_chan_data_t *sngisdn_info;
333 sngisdn_event_data_t *sngisdn_event = NULL;
334
335 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
336
337 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
338 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
339
340 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
341 ftdm_assert(0, "Inconsistent call states\n");
342 return;
343 }
344
345 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received SSHL CFM (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
346
347 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
348 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
349 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
350
351 sngisdn_event->event_id = SNGISDN_EVENT_SSHL_CFM;
352 sngisdn_event->sngisdn_info = sngisdn_info;
353 sngisdn_event->suId = suId;
354 sngisdn_event->suInstId = suInstId;
355 sngisdn_event->spInstId = spInstId;
356 sngisdn_event->action = action;
357
358 memcpy(&sngisdn_event->event.ssHlEvnt, ssHlEvnt, sizeof(*ssHlEvnt));
359
360 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
361 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
362 }
363 void sngisdn_rcv_rmrt_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, RmRtEvnt *rmRtEvnt, uint8_t action)
364 {
365 sngisdn_chan_data_t *sngisdn_info;
366 sngisdn_event_data_t *sngisdn_event = NULL;
367
368 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
369
370 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
371 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
372
373 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
374 ftdm_assert(0, "Inconsistent call states\n");
375 return;
376 }
377
378 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received RMRT IND (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
379
380 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
381 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
382 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
383
384 sngisdn_event->event_id = SNGISDN_EVENT_RMRT_IND;
385 sngisdn_event->sngisdn_info = sngisdn_info;
386 sngisdn_event->suId = suId;
387 sngisdn_event->suInstId = suInstId;
388 sngisdn_event->spInstId = spInstId;
389 sngisdn_event->action = action;
390
391 memcpy(&sngisdn_event->event.rmRtEvnt, rmRtEvnt, sizeof(*rmRtEvnt));
392
393 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
394 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
395 }
396
397 void sngisdn_rcv_rmrt_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, RmRtEvnt *rmRtEvnt, uint8_t action)
398 {
399 sngisdn_chan_data_t *sngisdn_info;
400 sngisdn_event_data_t *sngisdn_event = NULL;
401
402 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
403
404 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
405 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
406
407 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
408 ftdm_assert(0, "Inconsistent call states\n");
409 return;
410 }
411
412 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received RESUME/RETRIEVE CFM (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
413
414 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
415 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
416 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
417
418 sngisdn_event->event_id = SNGISDN_EVENT_RMRT_CFM;
419 sngisdn_event->sngisdn_info = sngisdn_info;
420 sngisdn_event->suId = suId;
421 sngisdn_event->suInstId = suInstId;
422 sngisdn_event->spInstId = spInstId;
423 sngisdn_event->action = action;
424
425 memcpy(&sngisdn_event->event.rmRtEvnt, rmRtEvnt, sizeof(*rmRtEvnt));
426
427 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
428 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
429 }
430
431 void sngisdn_rcv_flc_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, StaEvnt *staEvnt)
432 {
433 sngisdn_chan_data_t *sngisdn_info;
434 sngisdn_event_data_t *sngisdn_event = NULL;
435
436 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
437
438 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
439 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
440
441 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
442 ftdm_assert(0, "Inconsistent call states\n");
443 return;
444 }
445
446 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received FLOW CONTROL IND (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
447
448 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
449 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
450 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
451
452 sngisdn_event->event_id = SNGISDN_EVENT_FLC_IND;
453 sngisdn_event->sngisdn_info = sngisdn_info;
454 sngisdn_event->suId = suId;
455 sngisdn_event->suInstId = suInstId;
456 sngisdn_event->spInstId = spInstId;
457
458 memcpy(&sngisdn_event->event.staEvnt, staEvnt, sizeof(*staEvnt));
459
460 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
461 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
462 }
463
464
465 void sngisdn_rcv_fac_ind (int16_t suId, uint32_t suInstId, uint32_t spInstId, FacEvnt *facEvnt, uint8_t evntType, int16_t dChan, uint8_t ces)
466 {
467 sngisdn_chan_data_t *sngisdn_info;
468 sngisdn_event_data_t *sngisdn_event = NULL;
469
470 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
471
472 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
473 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
474
475 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
476 ftdm_assert(0, "Inconsistent call states\n");
477 return;
478 }
479
480 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received FACILITY IND (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
481 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
482 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
483 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
484
485 sngisdn_event->event_id = SNGISDN_EVENT_FAC_IND;
486 sngisdn_event->sngisdn_info = sngisdn_info;
487 sngisdn_event->suId = suId;
488 sngisdn_event->suInstId = suInstId;
489 sngisdn_event->spInstId = spInstId;
490 sngisdn_event->evntType = evntType;
491
492 memcpy(&sngisdn_event->event.facEvnt, facEvnt, sizeof(*facEvnt));
493
494 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
495 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
496 }
497
498
499 void sngisdn_rcv_sta_cfm (int16_t suId, uint32_t suInstId, uint32_t spInstId, StaEvnt *staEvnt)
500 {
501 sngisdn_chan_data_t *sngisdn_info;
502 sngisdn_event_data_t *sngisdn_event = NULL;
503
504 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
505
506 if (!(spInstId && get_ftdmchan_by_spInstId(suId, spInstId, &sngisdn_info) == FTDM_SUCCESS) &&
507 !(suInstId && get_ftdmchan_by_suInstId(suId, suInstId, &sngisdn_info) == FTDM_SUCCESS)) {
508
509 ftdm_log(FTDM_LOG_CRIT, "Could not find matching call suId:%u suInstId:%u spInstId:%u\n", suId, suInstId, spInstId);
510 ftdm_assert(0, "Inconsistent call states\n");
511 return;
512 }
513
514 ftdm_log_chan(sngisdn_info->ftdmchan, FTDM_LOG_INFO, "Received STATUS CONFIRM (suId:%u suInstId:%u spInstId:%u)\n", suId, suInstId, spInstId);
515
516 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
517 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
518 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
519
520 sngisdn_event->event_id = SNGISDN_EVENT_STA_CFM;
521 sngisdn_event->sngisdn_info = sngisdn_info;
522 sngisdn_event->suId = suId;
523 sngisdn_event->suInstId = suInstId;
524 sngisdn_event->spInstId = spInstId;
525
526 memcpy(&sngisdn_event->event.staEvnt, staEvnt, sizeof(*staEvnt));
527
528 ftdm_queue_enqueue(((sngisdn_span_data_t*)sngisdn_info->ftdmchan->span->signal_data)->event_queue, sngisdn_event);
529 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
530 }
531
532 void sngisdn_rcv_srv_ind (int16_t suId, Srv *srvEvnt, int16_t dChan, uint8_t ces)
533 {
534 unsigned i;
535 sngisdn_span_data_t *signal_data;
536 sngisdn_event_data_t *sngisdn_event = NULL;
537
538 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
539
540 ftdm_log(FTDM_LOG_INFO, "Received SERVICE IND (dChan:%d ces:%u)\n", dChan, ces);
541
542
543 for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) {
544 signal_data = g_sngisdn_data.dchans[dChan].spans[i];
545 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
546 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
547 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
548
549 sngisdn_event->event_id = SNGISDN_EVENT_SRV_IND;
550 sngisdn_event->suId = suId;
551 sngisdn_event->dChan = dChan;
552 sngisdn_event->ces = ces;
553 sngisdn_event->signal_data = signal_data;
554
555 memcpy(&sngisdn_event->event.srvEvnt, srvEvnt, sizeof(*srvEvnt));
556 ftdm_queue_enqueue((signal_data)->event_queue, sngisdn_event);
557 }
558 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
559 }
560
561
562 void sngisdn_rcv_srv_cfm (int16_t suId, Srv *srvEvnt, int16_t dChan, uint8_t ces)
563 {
564 unsigned i;
565 sngisdn_span_data_t *signal_data = NULL;
566 sngisdn_event_data_t *sngisdn_event = NULL;
567
568 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
569
570 ftdm_log(FTDM_LOG_INFO, "Received SERVICE CFM (dChan:%d ces:%u)\n", dChan, ces);
571
572
573 for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) {
574 signal_data = g_sngisdn_data.dchans[dChan].spans[i];
575 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
576 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
577 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
578
579 sngisdn_event->event_id = SNGISDN_EVENT_SRV_CFM;
580 sngisdn_event->suId = suId;
581 sngisdn_event->dChan = dChan;
582 sngisdn_event->ces = ces;
583 sngisdn_event->signal_data = signal_data;
584
585 memcpy(&sngisdn_event->event.srvEvnt, srvEvnt, sizeof(*srvEvnt));
586 ftdm_queue_enqueue((signal_data)->event_queue, sngisdn_event);
587 }
588 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
589 }
590
591 void sngisdn_rcv_rst_ind (int16_t suId, Rst *rstEvnt, int16_t dChan, uint8_t ces, uint8_t evntType)
592 {
593 unsigned i;
594 sngisdn_span_data_t *signal_data = NULL;
595 sngisdn_event_data_t *sngisdn_event = NULL;
596
597 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
598
599 ftdm_log(FTDM_LOG_INFO, "Received RESTART IND (dChan:%d ces:%u type:%u)\n", dChan, ces, evntType);
600
601
602 for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) {
603 signal_data = g_sngisdn_data.dchans[dChan].spans[i];
604
605 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
606 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
607 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
608
609 sngisdn_event->event_id = SNGISDN_EVENT_RST_IND;
610 sngisdn_event->suId = suId;
611 sngisdn_event->dChan = dChan;
612 sngisdn_event->ces = ces;
613 sngisdn_event->evntType = evntType;
614 sngisdn_event->signal_data = signal_data;
615
616 memcpy(&sngisdn_event->event.rstEvnt, rstEvnt, sizeof(*rstEvnt));
617 ftdm_queue_enqueue(signal_data->event_queue, sngisdn_event);
618 }
619 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
620 }
621
622 void sngisdn_rcv_rst_cfm (int16_t suId, Rst *rstEvnt, int16_t dChan, uint8_t ces, uint8_t evntType)
623 {
624 unsigned i;
625 sngisdn_span_data_t *signal_data;
626 sngisdn_event_data_t *sngisdn_event = NULL;
627
628 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
629
630
631 ftdm_log(FTDM_LOG_INFO, "Received RESTART CFM (dChan:%d ces:%u type:%u)\n", dChan, ces, evntType);
632
633
634 for(i=1; i<=g_sngisdn_data.dchans[dChan].num_spans; i++) {
635 signal_data = g_sngisdn_data.dchans[dChan].spans[i];
636 sngisdn_event = ftdm_malloc(sizeof(*sngisdn_event));
637 ftdm_assert(sngisdn_event != NULL, "Failed to allocate memory\n");
638 memset(sngisdn_event, 0, sizeof(*sngisdn_event));
639
640 sngisdn_event->event_id = SNGISDN_EVENT_RST_CFM;
641 sngisdn_event->suId = suId;
642 sngisdn_event->dChan = dChan;
643 sngisdn_event->ces = ces;
644 sngisdn_event->evntType = evntType;
645 sngisdn_event->signal_data = signal_data;
646
647 memcpy(&sngisdn_event->event.rstEvnt, rstEvnt, sizeof(*rstEvnt));
648 ftdm_queue_enqueue((signal_data)->event_queue, sngisdn_event);
649 }
650 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
651 }
652
653
654 void sngisdn_rcv_phy_ind(SuId suId, Reason reason)
655 {
656 if (reason != LL1_REASON_CON_REQ_FAIL) {
657 ftdm_log(FTDM_LOG_INFO, "[SNGISDN PHY] D-chan %d : %s\n", suId, DECODE_LL1_REASON(reason));
658 }
659 return;
660 }
661
662 void sngisdn_rcv_q921_ind(BdMngmt *status)
663 {
664 ftdm_span_t *ftdmspan;
665
666 sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[status->t.usta.lnkNmb].spans[1];
667
668 if (!signal_data) {
669 ftdm_log(FTDM_LOG_INFO, "Received q921 status on unconfigured span (lnkNmb:%d)\n", status->t.usta.lnkNmb);
670 return;
671 }
672 ftdmspan = signal_data->ftdm_span;
673
674 if (!ftdmspan) {
675 ftdm_log(FTDM_LOG_INFO, "Received q921 status on unconfigured span (lnkNmb:%d)\n", status->t.usta.lnkNmb);
676 return;
677 }
678
679 switch (status->t.usta.alarm.category) {
680 case (LCM_CATEGORY_INTERFACE):
681 ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q921] %s: %s: %s(%d): %s(%d)\n",
682 ftdmspan->name,
683 DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
684 DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
685 DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
686 break;
687 default:
688 ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q921] %s: %s: %s(%d): %s(%d)\n",
689 ftdmspan->name,
690 DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
691 DECODE_LLD_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
692 DECODE_LLD_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
693
694 switch (status->t.usta.alarm.event) {
695 case ENTR_CONG:
696 ftdm_log(FTDM_LOG_WARNING, "s%d: Entering Congestion\n", ftdmspan->span_id);
697 ftdm_set_flag(ftdmspan, FTDM_SPAN_SUSPENDED);
698 break;
699 case EXIT_CONG:
700 ftdm_log(FTDM_LOG_WARNING, "s%d: Exiting Congestion\n", ftdmspan->span_id);
701 ftdm_clear_flag(ftdmspan, FTDM_SPAN_SUSPENDED);
702 break;
703 }
704 break;
705 }
706 return;
707 }
708 void sngisdn_rcv_q931_ind(InMngmt *status)
709 {
710 if (status->t.usta.alarm.cause == 287) {
711 get_memory_info();
712 return;
713 }
714
715 switch (status->t.usta.alarm.event) {
716 case LCM_EVENT_UP:
717 case LCM_EVENT_DOWN:
718 {
719 ftdm_span_t *ftdmspan;
720 sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[status->t.usta.suId].spans[1];
721 if (!signal_data) {
722 ftdm_log(FTDM_LOG_INFO, "Received q931 status on unconfigured span (lnkNmb:%d)\n", status->t.usta.suId);
723 return;
724 }
725 ftdmspan = signal_data->ftdm_span;
726
727 if (status->t.usta.alarm.event == LCM_EVENT_UP) {
728 uint32_t chan_no = status->t.usta.evntParm[2];
729 ftdm_log(FTDM_LOG_INFO, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
730 status->t.usta.suId,
731 DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
732 DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
733 DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
734
735 if (chan_no) {
736 ftdm_channel_t *ftdmchan = ftdm_span_get_channel(ftdmspan, chan_no);
737 if (ftdmchan) {
738 sngisdn_set_chan_sig_status(ftdmchan, FTDM_SIG_STATE_UP);
739 sngisdn_set_chan_avail_rate(ftdmchan, SNGISDN_AVAIL_UP);
740 } else {
741 ftdm_log(FTDM_LOG_CRIT, "stack alarm event on invalid channel :%d\n", chan_no);
742 }
743 } else {
744 sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_UP);
745 sngisdn_set_span_avail_rate(ftdmspan, SNGISDN_AVAIL_UP);
746 }
747 } else {
748 ftdm_log(FTDM_LOG_WARNING, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
749 status->t.usta.suId,
750 DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
751 DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
752 DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
753
754 sngisdn_set_span_sig_status(ftdmspan, FTDM_SIG_STATE_DOWN);
755 sngisdn_set_span_avail_rate(ftdmspan, SNGISDN_AVAIL_PWR_SAVING);
756 }
757 }
758 break;
759 default:
760 ftdm_log(FTDM_LOG_WARNING, "[SNGISDN Q931] s%d: %s: %s(%d): %s(%d)\n",
761 status->t.usta.suId,
762 DECODE_LCM_CATEGORY(status->t.usta.alarm.category),
763 DECODE_LCM_EVENT(status->t.usta.alarm.event), status->t.usta.alarm.event,
764 DECODE_LCM_CAUSE(status->t.usta.alarm.cause), status->t.usta.alarm.cause);
765 }
766
767 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
768 return;
769 }
770
771 void sngisdn_rcv_cc_ind(CcMngmt *status)
772 {
773 ISDN_FUNC_TRACE_ENTER(__FUNCTION__);
774 ftdm_log(FTDM_LOG_INFO, "RECEIVED %s\n", __FUNCTION__);
775 ISDN_FUNC_TRACE_EXIT(__FUNCTION__);
776 return;
777 }
778
779 void sngisdn_rcv_q931_trace(InMngmt *trc, Buffer *mBuf)
780 {
781 MsgLen mlen;
782 MsgLen i;
783 int16_t j;
784 Buffer *tmp;
785 Data *cptr;
786 uint8_t data;
787 ftdm_trace_dir_t dir;
788 uint8_t tdata[1000];
789
790 sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[trc->t.trc.suId].spans[1];
791
792 ftdm_assert(mBuf != NULLP, "Received a Q931 trace with no buffer");
793 mlen = ((SsMsgInfo*)(mBuf->b_rptr))->len;
794
795 if (trc->t.trc.evnt == TL3PKTTX) {
796 dir = FTDM_TRACE_DIR_OUTGOING;
797 } else {
798 dir = FTDM_TRACE_DIR_INCOMING;
799 }
800
801 if (mlen) {
802 tmp = mBuf->b_cont;
803 cptr = tmp->b_rptr;
804 data = *cptr++;
805 i = 0;
806
807 for(j=0;j<mlen;j++) {
808 tdata[j]= data;
809
810 if (cptr == tmp->b_wptr) {
811 tmp = tmp->b_cont;
812 if (tmp) cptr = tmp->b_rptr;
813 }
814 data = *cptr++;
815 }
816 if (signal_data->raw_trace_q931 == SNGISDN_OPT_TRUE) {
817 sngisdn_trace_raw_q931(signal_data, dir, tdata, mlen);
818 } else {
819 sngisdn_trace_interpreted_q931(signal_data, dir, tdata, mlen);
820 }
821 }
822 return;
823 }
824
825
826 void sngisdn_rcv_q921_trace(BdMngmt *trc, Buffer *mBuf)
827 {
828 MsgLen mlen;
829 Buffer *tmp;
830 MsgLen i;
831 int16_t j;
832 Data *cptr;
833 uint8_t data;
834 ftdm_trace_dir_t dir;
835 uint8_t tdata[1000];
836
837 sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[trc->t.trc.lnkNmb].spans[1];
838
839 if (trc->t.trc.evnt == TL2TMR) {
840 return;
841 }
842
843 if (trc->t.trc.evnt == TL2FRMTX) {
844 dir = FTDM_TRACE_DIR_OUTGOING;
845 } else {
846 dir = FTDM_TRACE_DIR_INCOMING;
847 }
848
849 ftdm_assert(mBuf != NULLP, "Received a Q921 trace with no buffer");
850 mlen = ((SsMsgInfo*)(mBuf->b_rptr))->len;
851 if (mlen != 0) {
852 tmp = mBuf->b_cont;
853 cptr = tmp->b_rptr;
854 data = *cptr++;
855 i = 0;
856 while (i < mlen) {
857 j = 0;
858 for(j=0;j<16;j++) {
859 if (i<mlen) {
860 tdata[j]= data;
861
862 if (cptr == tmp->b_wptr) {
863 tmp = tmp->b_cont;
864 if (tmp) cptr = tmp->b_rptr;
865 }
866 i++;
867 if (i<mlen) data = *cptr++;
868 }
869 }
870
871 }
872 if (signal_data->raw_trace_q921 == SNGISDN_OPT_TRUE) {
873 sngisdn_trace_raw_q921(signal_data, dir, tdata, mlen);
874 } else {
875 sngisdn_trace_interpreted_q921(signal_data, dir, tdata, mlen);
876 }
877 }
878 return;
879 }
880
881
882 int16_t sngisdn_rcv_l1_data_req(uint16_t spId, sng_l1_frame_t *l1_frame)
883 {
884 ftdm_status_t status;
885 ftdm_wait_flag_t flags = FTDM_WRITE;
886 sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[spId].spans[1];
887 ftdm_size_t length = l1_frame->len;
888
889 ftdm_assert(signal_data, "Received Data request on unconfigured span\n");
890
891 do {
892 flags = FTDM_WRITE;
893 status = signal_data->dchan->fio->wait(signal_data->dchan, &flags, 1000);
894 if (status != FTDM_SUCCESS) {
895 ftdm_log_chan_msg(signal_data->dchan, FTDM_LOG_WARNING, "transmit timed-out\n");
896 return -1;
897 }
898
899
900 if ((flags & FTDM_WRITE)) {
901 status = signal_data->dchan->fio->write(signal_data->dchan, l1_frame->data, (ftdm_size_t*)&length);
902 if (status != FTDM_SUCCESS) {
903 ftdm_log_chan_msg(signal_data->dchan, FTDM_LOG_CRIT, "Failed to transmit frame\n");
904 return -1;
905 }
906 break;
907
908 #ifndef WIN32
909 } else {
910 ftdm_log_chan_msg(signal_data->dchan, FTDM_LOG_WARNING, "Failed to poll for d-channel\n");
911 return -1;
912 #endif
913 }
914 } while(1);
915 return 0;
916 }
917
918 int16_t sngisdn_rcv_l1_cmd_req(uint16_t spId, sng_l1_cmd_t *l1_cmd)
919 {
920 sngisdn_span_data_t *signal_data = g_sngisdn_data.dchans[spId].spans[1];
921 ftdm_assert(signal_data, "Received Data request on unconfigured span\n");
922
923 switch(l1_cmd->type) {
924 case SNG_L1CMD_SET_LINK_STATUS:
925 {
926 ftdm_channel_hw_link_status_t status = FTDM_HW_LINK_CONNECTED;
927 ftdm_channel_command(signal_data->dchan, FTDM_COMMAND_SET_LINK_STATUS, &status);
928 }
929 break;
930 case SNG_L1CMD_GET_LINK_STATUS:
931 {
932 ftdm_channel_hw_link_status_t status = 0;
933 ftdm_channel_command(signal_data->dchan, FTDM_COMMAND_GET_LINK_STATUS, &status);
934 if (status == FTDM_HW_LINK_CONNECTED) {
935 l1_cmd->cmd.status = 1;
936 } else if (status == FTDM_HW_LINK_DISCONNECTED) {
937 l1_cmd->cmd.status = 0;
938 } else {
939 ftdm_log_chan(signal_data->dchan, FTDM_LOG_CRIT, "Invalid link status reported %d\n", status);
940 l1_cmd->cmd.status = 0;
941 }
942 }
943 break;
944 case SNG_L1CMD_FLUSH_STATS:
945 ftdm_channel_command(signal_data->dchan, FTDM_COMMAND_FLUSH_IOSTATS, NULL);
946 break;
947 case SNG_L1CMD_FLUSH_BUFFERS:
948 ftdm_channel_command(signal_data->dchan, FTDM_COMMAND_FLUSH_BUFFERS, NULL);
949 break;
950 default:
951 ftdm_log_chan(signal_data->dchan, FTDM_LOG_CRIT, "Unsupported channel command:%d\n", l1_cmd->type);
952 return -1;
953 }
954 return 0;
955 }
956
957 void sngisdn_rcv_sng_assert(char *message)
958 {
959 ftdm_assert(0, message);
960 }
961
962 void sngisdn_rcv_sng_log(uint8_t level, char *fmt,...)
963 {
964 char *data;
965 int ret;
966 va_list ap;
967
968 va_start(ap, fmt);
969 ret = ftdm_vasprintf(&data, fmt, ap);
970 if (ret == -1) {
971 return;
972 }
973
974 switch (level) {
975 case SNG_LOGLEVEL_DEBUG:
976 ftdm_log(FTDM_LOG_DEBUG, "sng_isdn->%s", data);
977 break;
978 case SNG_LOGLEVEL_WARN:
979 ftdm_log(FTDM_LOG_INFO, "sng_isdn->%s", data);
980 break;
981 case SNG_LOGLEVEL_INFO:
982 ftdm_log(FTDM_LOG_INFO, "sng_isdn->%s", data);
983 break;
984 case SNG_LOGLEVEL_STATS:
985 ftdm_log(FTDM_LOG_INFO, "sng_isdn->%s", data);
986 break;
987 case SNG_LOGLEVEL_ERROR:
988 ftdm_log(FTDM_LOG_ERROR, "sng_isdn->%s", data);
989
990 break;
991 case SNG_LOGLEVEL_CRIT:
992 ftdm_log(FTDM_LOG_CRIT, "sng_isdn->%s", data);
993
994 break;
995 default:
996 ftdm_log(FTDM_LOG_INFO, "sng_isdn->%s", data);
997 break;
998 }
999 ftdm_safe_free(data);
1000 return;
1001 }
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014