root/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_support.c

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

DEFINITIONS

This source file includes following definitions.
  1. clear_call_data
  2. clear_call_glare_data
  3. get_unique_suInstId
  4. get_ftdmchan_by_suInstId
  5. get_ftdmchan_by_spInstId
  6. sng_isdn_set_avail_rate
  7. cpy_calling_num_from_stack
  8. cpy_called_num_from_stack
  9. cpy_redir_num_from_stack
  10. cpy_calling_name_from_stack
  11. cpy_calling_num_from_user
  12. cpy_called_num_from_user
  13. cpy_redir_num_from_user
  14. cpy_calling_name_from_user
  15. sngisdn_delayed_release
  16. sngisdn_delayed_connect
  17. sngisdn_delayed_disconnect
  18. sngisdn_facility_timeout
  19. sngisdn_check_free_ids
  20. get_memory_info
  21. sngisdn_get_infoTranCap_from_stack
  22. sngisdn_get_usrInfoLyr1Prot_from_stack
  23. sngisdn_get_infoTranCap_from_user
  24. sngisdn_get_usrInfoLyr1Prot_from_user
  25. sngisdn_print_phy_stats
  26. sngisdn_print_span
  27. sngisdn_print_spans

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

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