root/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_stack_rcv.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. sngisdn_rcv_con_ind
  2. sngisdn_rcv_con_cfm
  3. sngisdn_rcv_cnst_ind
  4. sngisdn_rcv_disc_ind
  5. sngisdn_rcv_rel_ind
  6. sngisdn_rcv_dat_ind
  7. sngisdn_rcv_sshl_ind
  8. sngisdn_rcv_sshl_cfm
  9. sngisdn_rcv_rmrt_ind
  10. sngisdn_rcv_rmrt_cfm
  11. sngisdn_rcv_flc_ind
  12. sngisdn_rcv_fac_ind
  13. sngisdn_rcv_sta_cfm
  14. sngisdn_rcv_srv_ind
  15. sngisdn_rcv_srv_cfm
  16. sngisdn_rcv_rst_ind
  17. sngisdn_rcv_rst_cfm
  18. sngisdn_rcv_phy_ind
  19. sngisdn_rcv_q921_ind
  20. sngisdn_rcv_q931_ind
  21. sngisdn_rcv_cc_ind
  22. sngisdn_rcv_q931_trace
  23. sngisdn_rcv_q921_trace
  24. sngisdn_rcv_sng_assert
  25. sngisdn_rcv_sng_log

   1 /*
   2  * Copyright (c) 2010, Sangoma Technologies
   3  * David Yat Sin <dyatsin@sangoma.com>
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * * Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer.
  12  *
  13  * * Redistributions in binary form must reproduce the above copyright
  14  * notice, this list of conditions and the following disclaimer in the
  15  * documentation and/or other materials provided with the distribution.
  16  *
  17  * * Neither the name of the original author; nor the names of any contributors
  18  * may be used to endorse or promote products derived from this software
  19  * without specific prior written permission.
  20  *
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  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                 /* TODO: Implement me */
  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                 /* It seems that Trillium has a bug where they sometimes send release twice on a call, so do not crash on these for now */
 243                 /* ftdm_assert(0, "Inconsistent call states\n"); */
 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         /* Enqueue the event to each span within the dChan */
 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         /* Enqueue the event to each span within the dChan */
 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         /* Enqueue the event to each span within the dChan */
 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         /* Enqueue the event to each span within the dChan */
 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: /* Entering Congestion */
 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: /* Exiting Congestion */
 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); /* TODO Find a proper size */
 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         /* We do not need to free mBuf in this case because stack does it */
 794         /* SPutMsg(mBuf); */
 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); /* TODO Find a proper size */
 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                         /*ftdm_assert(0, "Got an error from stack");*/
 885                         break;
 886                 case SNG_LOGLEVEL_CRIT:
 887                         ftdm_log(FTDM_LOG_CRIT, "sng_isdn->%s", data);
 888                         /* ftdm_assert(0, "Got an error from stack"); */
 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 /* For Emacs:
 899  * Local Variables:
 900  * mode:c
 901  * indent-tabs-mode:t
 902  * tab-width:4
 903  * c-basic-offset:4
 904  * End:
 905  * For VIM:
 906  * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
 907  */
 908 
 909 /******************************************************************************/

/* [<][>][^][v][top][bottom][index][help] */