root/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_cfg.c

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

DEFINITIONS

This source file includes following definitions.
  1. parse_switchtype
  2. parse_signalling
  3. ftmod_isdn_parse_cfg

   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 parse_switchtype(const char* switch_name, ftdm_span_t *span);
  38 ftdm_status_t parse_signalling(const char* signalling, ftdm_span_t *span);
  39 
  40 extern ftdm_sngisdn_data_t      g_sngisdn_data;
  41 
  42 ftdm_status_t parse_switchtype(const char* switch_name, ftdm_span_t *span)
  43 {
  44         unsigned i;
  45 
  46         sngisdn_dchan_data_t *dchan_data;
  47         sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
  48         switch(span->trunk_type) {
  49                 case FTDM_TRUNK_T1:
  50                         if (!strcasecmp(switch_name, "ni2") ||
  51                                 !strcasecmp(switch_name, "national")) {
  52                                 signal_data->switchtype = SNGISDN_SWITCH_NI2;
  53                         } else if (!strcasecmp(switch_name, "5ess")) {
  54                                 signal_data->switchtype = SNGISDN_SWITCH_5ESS;
  55                         } else if (!strcasecmp(switch_name, "4ess")) {
  56                                 signal_data->switchtype = SNGISDN_SWITCH_4ESS;
  57                         } else if (!strcasecmp(switch_name, "dms100")) {
  58                                 signal_data->switchtype = SNGISDN_SWITCH_DMS100;
  59                         } else {
  60                                 ftdm_log(FTDM_LOG_ERROR, "%s:Unsupported switchtype %s for trunktype:%s\n", span->name, switch_name, ftdm_trunk_type2str(span->trunk_type));
  61                                 return FTDM_FAIL;
  62                         }
  63                         break;
  64                 case FTDM_TRUNK_E1:
  65                         if (!strcasecmp(switch_name, "euroisdn") ||
  66                                 !strcasecmp(switch_name, "etsi")) {
  67                                 signal_data->switchtype = SNGISDN_SWITCH_EUROISDN;
  68                         } else if (!strcasecmp(switch_name, "qsig")) {
  69                                 signal_data->switchtype = SNGISDN_SWITCH_QSIG;
  70                         } else {
  71                                 ftdm_log(FTDM_LOG_ERROR, "%s:Unsupported switchtype %s for trunktype:%s\n", span->name, switch_name, ftdm_trunk_type2str(span->trunk_type));
  72                                 return FTDM_FAIL;
  73                         }
  74                         break;
  75                 case FTDM_TRUNK_BRI:
  76                 case FTDM_TRUNK_BRI_PTMP:
  77                         if (!strcasecmp(switch_name, "euroisdn") ||
  78                                 !strcasecmp(switch_name, "etsi")) {
  79                                 signal_data->switchtype = SNGISDN_SWITCH_EUROISDN;
  80                         } else if (!strcasecmp(switch_name, "insnet") ||
  81                                                 !strcasecmp(switch_name, "ntt")) {
  82                                 signal_data->switchtype = SNGISDN_SWITCH_INSNET;
  83                         } else {
  84                                 ftdm_log(FTDM_LOG_ERROR, "%s:Unsupported switchtype %s for trunktype:%s\n", span->name, switch_name, ftdm_trunk_type2str(span->trunk_type));
  85                                 return FTDM_FAIL;
  86                         }
  87                          /* can be > 1 for some BRI variants */
  88                         break;
  89                 default:
  90                         ftdm_log(FTDM_LOG_ERROR, "%s:Unsupported trunktype:%s\n", span->name, switch_name, ftdm_trunk_type2str(span->trunk_type));
  91                         return FTDM_FAIL;
  92         }
  93         /* see if we have profile with this switch_type already */
  94         for (i=1; i <= g_sngisdn_data.num_cc; i++) {
  95                 if (g_sngisdn_data.ccs[i].switchtype == signal_data->switchtype &&
  96                         g_sngisdn_data.ccs[i].trunktype == span->trunk_type) {
  97                         break;
  98                 }
  99         }
 100         /* need to create a new switch_type */
 101         if (i > g_sngisdn_data.num_cc) {
 102                 g_sngisdn_data.num_cc++;
 103                 g_sngisdn_data.ccs[i].switchtype = signal_data->switchtype;
 104                 g_sngisdn_data.ccs[i].trunktype = span->trunk_type;
 105                 ftdm_log(FTDM_LOG_DEBUG, "%s: New switchtype:%s  cc_id:%u\n", span->name, switch_name, i);
 106         }
 107 
 108         /* add this span to its ent_cc */
 109         signal_data->cc_id = i;
 110 
 111         /* create a new dchan */ /* for NFAS - no-dchan on b-channels only links */
 112         g_sngisdn_data.num_dchan++;
 113         signal_data->dchan_id =  g_sngisdn_data.num_dchan;
 114 
 115         dchan_data = &g_sngisdn_data.dchans[signal_data->dchan_id];
 116         dchan_data->num_spans++;
 117 
 118         signal_data->span_id = dchan_data->num_spans;
 119         dchan_data->spans[signal_data->span_id] = signal_data;
 120 
 121         g_sngisdn_data.spans[signal_data->link_id] = signal_data;
 122         
 123         ftdm_log(FTDM_LOG_DEBUG, "%s: cc_id:%d dchan_id:%d span_id:%d\n", span->name, signal_data->cc_id, signal_data->dchan_id, signal_data->span_id);
 124 
 125         /* Add the channels to the span */
 126         for (i=1;i<=span->chan_count;i++) {
 127                 unsigned chan_id;
 128                 ftdm_channel_t *ftdmchan = span->channels[i];
 129                 /* NFAS is not supported on E1, so span_id will always be 1 for E1 so this will work for E1 as well */
 130                 chan_id = ((signal_data->span_id-1)*NUM_T1_CHANNELS_PER_SPAN)+ftdmchan->physical_chan_id;
 131                 dchan_data->channels[chan_id] = (sngisdn_chan_data_t*)ftdmchan->call_data;
 132                 dchan_data->num_chans++;
 133         }
 134 
 135         return FTDM_SUCCESS;
 136 }
 137 
 138 ftdm_status_t parse_signalling(const char* signalling, ftdm_span_t *span)
 139 {
 140         sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
 141         if (!strcasecmp(signalling, "net") ||
 142                 !strcasecmp(signalling, "pri_net")||
 143                 !strcasecmp(signalling, "bri_net")) {
 144 
 145                 signal_data->signalling = SNGISDN_SIGNALING_NET;
 146         } else if (!strcasecmp(signalling, "cpe") ||
 147                 !strcasecmp(signalling, "pri_cpe")||
 148                 !strcasecmp(signalling, "bri_cpe")) {
 149 
 150                 signal_data->signalling = SNGISDN_SIGNALING_CPE;
 151         } else {
 152                 ftdm_log(FTDM_LOG_ERROR, "Unsupported signalling/interface %s\n", signalling);
 153                 return FTDM_FAIL;
 154         }
 155         return FTDM_SUCCESS;
 156 }
 157 
 158 ftdm_status_t ftmod_isdn_parse_cfg(ftdm_conf_parameter_t *ftdm_parameters, ftdm_span_t *span)
 159 {
 160         unsigned paramindex;
 161         const char *var, *val;
 162         sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*) span->signal_data;
 163         /* Set defaults here */
 164         signal_data->tei = 0;
 165         signal_data->min_digits = 8;
 166         signal_data->overlap_dial = SNGISDN_OPT_DEFAULT;
 167         signal_data->setup_arb = SNGISDN_OPT_DEFAULT;
 168 
 169         signal_data->link_id = span->span_id;
 170         span->default_caller_data.bearer_capability = IN_ITC_SPEECH;
 171 
 172         /* Cannot set default bearer_layer1 yet, as we do not know the switchtype */
 173         span->default_caller_data.bearer_layer1 = FTDM_INVALID_INT_PARM;
 174 
 175         if (span->trunk_type == FTDM_TRUNK_BRI ||
 176                 span->trunk_type == FTDM_TRUNK_BRI_PTMP) {
 177 
 178                 ftdm_span_set_npi("unknown", &span->default_caller_data.dnis.plan);
 179                 ftdm_span_set_ton("unknown", &span->default_caller_data.dnis.type);
 180                 ftdm_span_set_npi("unknown", &span->default_caller_data.cid_num.plan);
 181                 ftdm_span_set_ton("unknown", &span->default_caller_data.cid_num.type);
 182                 ftdm_span_set_npi("unknown", &span->default_caller_data.rdnis.plan);
 183                 ftdm_span_set_ton("unknown", &span->default_caller_data.rdnis.type);
 184         } else {
 185                 ftdm_span_set_npi("e164", &span->default_caller_data.dnis.plan);
 186                 ftdm_span_set_ton("national", &span->default_caller_data.dnis.type);
 187                 ftdm_span_set_npi("e164", &span->default_caller_data.cid_num.plan);
 188                 ftdm_span_set_ton("national", &span->default_caller_data.cid_num.type);
 189                 ftdm_span_set_npi("e164", &span->default_caller_data.rdnis.plan);
 190                 ftdm_span_set_ton("national", &span->default_caller_data.rdnis.type);
 191         }
 192 
 193         for (paramindex = 0; ftdm_parameters[paramindex].var; paramindex++) {
 194                 ftdm_log(FTDM_LOG_DEBUG, "Sangoma ISDN key=value, %s=%s\n", ftdm_parameters[paramindex].var, ftdm_parameters[paramindex].val);
 195                 var = ftdm_parameters[paramindex].var;
 196                 val = ftdm_parameters[paramindex].val;
 197                 
 198                 if (!strcasecmp(var, "switchtype")) {
 199                         if (parse_switchtype(val, span) != FTDM_SUCCESS) {
 200                                 return FTDM_FAIL;
 201                         }
 202                 } else if (!strcasecmp(var, "signalling") ||
 203                                    !strcasecmp(var, "interface")) {
 204                         if (parse_signalling(val, span) != FTDM_SUCCESS) {
 205                                 return FTDM_FAIL;
 206                         }
 207                 } else if (!strcasecmp(var, "tei")) {
 208                         uint8_t tei = atoi(val);
 209                         if (tei > 127) {
 210                                 ftdm_log(FTDM_LOG_ERROR, "Invalid TEI %d, valid values are (0-127)", tei);
 211                                 return FTDM_FAIL;
 212                         }
 213                         signal_data->tei = tei;
 214                 } else if (!strcasecmp(var, "overlap")) {
 215                         if (!strcasecmp(val, "yes")) {
 216                                 signal_data->overlap_dial = SNGISDN_OPT_TRUE;
 217                         } else if (!strcasecmp(val, "no")) {
 218                                 signal_data->overlap_dial = SNGISDN_OPT_FALSE;
 219                         } else {
 220                                 ftdm_log(FTDM_LOG_ERROR, "Invalid value for parameter:%s:%s\n", var, val);
 221                         }
 222                 } else if (!strcasecmp(var, "setup arbitration")) {
 223                         if (!strcasecmp(val, "yes")) {
 224                                 signal_data->setup_arb = SNGISDN_OPT_TRUE;
 225                         } else if (!strcasecmp(val, "no")) {
 226                                 signal_data->setup_arb = SNGISDN_OPT_FALSE;
 227                         } else {
 228                                 ftdm_log(FTDM_LOG_ERROR, "Invalid value for parameter:%s:%s\n", var, val);
 229                         }
 230                 } else if (!strcasecmp(var, "facility")) {
 231                         if (!strcasecmp(val, "yes")) {
 232                                 signal_data->facility = SNGISDN_OPT_TRUE;
 233                         } else if (!strcasecmp(val, "no")) {
 234                                 signal_data->facility = SNGISDN_OPT_FALSE;
 235                         } else {
 236                                 ftdm_log(FTDM_LOG_ERROR, "Invalid value for parameter:%s:%s\n", var, val);
 237                         }
 238                 } else if (!strcasecmp(var, "min_digits")) {
 239                         signal_data->min_digits = atoi(val);
 240                 } else if (!strcasecmp(var, "outbound-called-ton")) {
 241                         ftdm_span_set_ton(val, &span->default_caller_data.dnis.type);
 242                 } else if (!strcasecmp(var, "outbound-called-npi")) {
 243                         ftdm_span_set_npi(val, &span->default_caller_data.dnis.plan);
 244                 } else if (!strcasecmp(var, "outbound-calling-ton")) {
 245                         ftdm_span_set_ton(val, &span->default_caller_data.cid_num.type);
 246                 } else if (!strcasecmp(var, "outbound-calling-npi")) {
 247                         ftdm_span_set_npi(val, &span->default_caller_data.cid_num.plan);
 248                 } else if (!strcasecmp(var, "outbound-rdnis-ton")) {
 249                         ftdm_span_set_ton(val, &span->default_caller_data.rdnis.type);
 250                 } else if (!strcasecmp(var, "outbound-rdnis-npi")) {
 251                         ftdm_span_set_npi(val, &span->default_caller_data.rdnis.plan);
 252                 } else if (!strcasecmp(var, "outbound-bearer_cap")) {
 253                         ftdm_span_set_bearer_capability(val, &span->default_caller_data.bearer_capability);
 254                 } else if (!strcasecmp(var, "outbound-bearer_layer1")) {
 255                         ftdm_span_set_bearer_layer1(val, &span->default_caller_data.bearer_layer1);
 256                 } else if (!strcasecmp(var, "facility-timeout")) {
 257                         signal_data->facility_timeout = atoi(val);
 258                         if (signal_data->facility_timeout < 0) {
 259                                 signal_data->facility_timeout = 0;
 260                         }
 261                 } else {
 262                         ftdm_log(FTDM_LOG_WARNING, "Ignoring unknown parameter %s\n", ftdm_parameters[paramindex].var);
 263                 }
 264         }
 265         
 266         if (signal_data->switchtype == SNGISDN_SWITCH_INVALID) {
 267                 ftdm_log(FTDM_LOG_ERROR, "%s: switchtype not specified", span->name);
 268                 return FTDM_FAIL;
 269         }
 270         if (signal_data->signalling == SNGISDN_SIGNALING_INVALID) {
 271                 ftdm_log(FTDM_LOG_ERROR, "%s: signalling not specified", span->name);
 272                 return FTDM_FAIL;
 273         }
 274 
 275         if (span->default_caller_data.bearer_layer1 == FTDM_INVALID_INT_PARM) {
 276                 if (signal_data->switchtype == SNGISDN_SWITCH_EUROISDN) {
 277                         span->default_caller_data.bearer_layer1 = IN_UIL1_G711ULAW;
 278                 } else {
 279                         span->default_caller_data.bearer_layer1 = IN_UIL1_G711ALAW;
 280                 }
 281         }
 282         return FTDM_SUCCESS;
 283 }
 284 
 285 
 286 /******************************************************************************/
 287 /* For Emacs:
 288  * Local Variables:
 289  * mode:c
 290  * indent-tabs-mode:t
 291  * tab-width:4
 292  * c-basic-offset:4
 293  * End:
 294  * For VIM:
 295  * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
 296  */

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