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_l1_data_req
  25. sngisdn_rcv_l1_cmd_req
  26. sngisdn_rcv_sng_assert
  27. 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 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                 /* TODO: Implement me */
  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                 /* It seems that Trillium has a bug where they sometimes send release twice on a call, so do not crash on these for now */
 241                 /* ftdm_assert(0, "Inconsistent call states\n"); */
 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         /* Enqueue the event to each span within the dChan */
 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         /* Enqueue the event to each span within the dChan */
 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         /* Enqueue the event to each span within the dChan */
 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         /* Enqueue the event to each span within the dChan */
 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: /* Entering Congestion */
 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: /* Exiting Congestion */
 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 /* The stacks is wants to transmit a frame */
 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                 /* On WIN32, it is possible for poll to return without FTDM_WRITE flag set, so we try to retransmit */
 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                         /*ftdm_assert(0, "Got an error from stack");*/
 990                         break;
 991                 case SNG_LOGLEVEL_CRIT:
 992                         ftdm_log(FTDM_LOG_CRIT, "sng_isdn->%s", data);
 993                         /* ftdm_assert(0, "Got an error from stack"); */
 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 /* For Emacs:
1004  * Local Variables:
1005  * mode:c
1006  * indent-tabs-mode:t
1007  * tab-width:4
1008  * c-basic-offset:4
1009  * End:
1010  * For VIM:
1011  * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
1012  */
1013 
1014 /******************************************************************************/

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