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