Sat Nov 1 06:28:26 2008

Asterisk developer's documentation

---

chan_misdn.c

Go to the documentation of this file.

/*
 * Asterisk -- An open source telephony toolkit.
 * 
 * Copyright (C) 2004 - 2006, Christian Richter
 *
 * Christian Richter <crich@beronet.com>
 *
 * See http://www.asterisk.org for more information about
 * the Asterisk project. Please do not directly contact
 * any of the maintainers of this project for assistance;
 * the project provides a web site, mailing lists and IRC
 * channels for your use.
 *
 * This program is free software, distributed under the terms of
 * the GNU General Public License Version 2. See the LICENSE file
 * at the top of the source tree.
 *
 */

/*!
 * \file
 *
 * \brief the chan_misdn channel driver for Asterisk
 *
 * \author Christian Richter <crich@beronet.com>
 *
 * \extref MISDN http://www.misdn.org/
 *
 * \ingroup channel_drivers
 */

/*** MODULEINFO
   <depend>isdnnet</depend>
   <depend>misdn</depend>
   <depend>suppserv</depend>
 ***/
#include "asterisk.h"

ASTERISK_FILE_VERSION(__FILE__, "$Revision: 150124 $")

#include <stdio.h>
#include <pthread.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <errno.h>
#include <unistd.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <fcntl.h>
#include <sys/ioctl.h>
#include <signal.h>
#include <sys/file.h>
#include <semaphore.h>

#include "asterisk/channel.h"
#include "asterisk/config.h"
#include "asterisk/logger.h"
#include "asterisk/module.h"
#include "asterisk/pbx.h"
#include "asterisk/options.h"
#include "asterisk/io.h"
#include "asterisk/frame.h"
#include "asterisk/translate.h"
#include "asterisk/cli.h"
#include "asterisk/musiconhold.h"
#include "asterisk/dsp.h"
#include "asterisk/translate.h"
#include "asterisk/config.h"
#include "asterisk/file.h"
#include "asterisk/callerid.h"
#include "asterisk/indications.h"
#include "asterisk/app.h"
#include "asterisk/features.h"
#include "asterisk/term.h"
#include "asterisk/sched.h"
#include "asterisk/stringfields.h"
#include "asterisk/causes.h"

#include "chan_misdn_config.h"
#include "isdn_lib.h"

char global_tracefile[BUFFERSIZE + 1];

static int g_config_initialized = 0;

struct misdn_jb{
   int size;
   int upper_threshold;
   char *samples, *ok;
   int wp,rp;
   int state_empty;
   int state_full;
   int state_buffer;
   int bytes_wrote;
   ast_mutex_t mutexjb;
};



/*! \brief allocates the jb-structure and initialize the elements */
struct misdn_jb *misdn_jb_init(int size, int upper_threshold);

/*! \brief frees the data and destroys the given jitterbuffer struct */
void misdn_jb_destroy(struct misdn_jb *jb);

/*! \brief fills the jitterbuffer with len data returns < 0 if there was an
error (buffer overrun). */
int misdn_jb_fill(struct misdn_jb *jb, const char *data, int len);

/*! \brief gets len bytes out of the jitterbuffer if available, else only the
available data is returned and the return value indicates the number
of data. */
int misdn_jb_empty(struct misdn_jb *jb, char *data, int len);


/* BEGIN: chan_misdn.h */

ast_mutex_t release_lock;

enum misdn_chan_state {
   MISDN_NOTHING=0,  /*!< at beginning */
   MISDN_WAITING4DIGS, /*!<  when waiting for infos */
   MISDN_EXTCANTMATCH, /*!<  when asterisk couldn't match our ext */
   MISDN_INCOMING_SETUP, /*!<  for incoming setups*/
   MISDN_DIALING, /*!<  when pbx_start */
   MISDN_PROGRESS, /*!<  we got a progress */
   MISDN_PROCEEDING, /*!<  we got a progress */
   MISDN_CALLING, /*!<  when misdn_call is called */
   MISDN_CALLING_ACKNOWLEDGE, /*!<  when we get SETUP_ACK */
   MISDN_ALERTING, /*!<  when Alerting */
   MISDN_BUSY, /*!<  when BUSY */
   MISDN_CONNECTED, /*!<  when connected */
   MISDN_PRECONNECTED, /*!<  when connected */
   MISDN_DISCONNECTED, /*!<  when connected */
   MISDN_RELEASED, /*!<  when connected */
   MISDN_BRIDGED, /*!<  when bridged */
   MISDN_CLEANING, /*!< when hangup from * but we were connected before */
   MISDN_HUNGUP_FROM_MISDN, /*!< when DISCONNECT/RELEASE/REL_COMP  came from misdn */
   MISDN_HUNGUP_FROM_AST, /*!< when DISCONNECT/RELEASE/REL_COMP came out of misdn_hangup */
   MISDN_HOLDED, /*!< if this chan is holded */
   MISDN_HOLD_DISCONNECT, /*!< if this chan is holded */
  
};

#define ORG_AST 1
#define ORG_MISDN 2

struct hold_info {
   int port;
   int channel;
};

struct chan_list {
  
   char allowed_bearers[BUFFERSIZE + 1];
   
   enum misdn_chan_state state;
   int need_queue_hangup;
   int need_hangup;
   int need_busy;
   
   int originator;
   int noautorespond_on_setup;
   
   int norxtone;
   int notxtone; 

   int toggle_ec;
   
   int incoming_early_audio;

   int ignore_dtmf;

   int pipe[2];
   char ast_rd_buf[4096];
   struct ast_frame frame;

   int faxdetect; /*!<  0:no 1:yes 2:yes+nojump */
   int faxdetect_timeout;
   struct timeval faxdetect_tv;
   int faxhandled;

   int ast_dsp;

   int jb_len;
   int jb_upper_threshold;
   struct misdn_jb *jb;
   
   struct ast_dsp *dsp;
   struct ast_trans_pvt *trans;
  
   struct ast_channel * ast;

   int dummy;
  
   struct misdn_bchannel *bc;

   struct hold_info hold_info;

   unsigned int l3id;
   int addr;

   char context[BUFFERSIZE];

   int zero_read_cnt;
   int dropped_frame_cnt;

   int far_alerting;

   int nttimeout;

   int other_pid;
   struct chan_list *other_ch;

   const struct ind_tone_zone_sound *ts;
   
   int overlap_dial;
   int overlap_dial_task;
   ast_mutex_t overlap_tv_lock;
   struct timeval overlap_tv;
  
   struct chan_list *peer;
   struct chan_list *next;
   struct chan_list *prev;
   struct chan_list *first;
};



void export_ch(struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_list *ch);
void import_ch(struct ast_channel *chan, struct misdn_bchannel *bc, struct chan_list *ch);

struct robin_list {
   char *group;
   int port;
   int channel;
   struct robin_list *next;
   struct robin_list *prev;
};
static struct robin_list *robin = NULL;



static struct ast_frame *process_ast_dsp(struct chan_list *tmp, struct ast_frame *frame);



static inline void free_robin_list_r (struct robin_list *r)
{
   if (r) {
      if (r->next)
         free_robin_list_r(r->next);
      if (r->group)
         free(r->group);
      free(r);
   }
}

static void free_robin_list ( void )
{
   free_robin_list_r(robin);
   robin = NULL;
}

static struct robin_list* get_robin_position (char *group) 
{
   struct robin_list *new;
   struct robin_list *iter = robin;
   for (; iter; iter = iter->next) {
      if (!strcasecmp(iter->group, group))
         return iter;
   }
   new = (struct robin_list *) calloc(1, sizeof(struct robin_list));
   new->group = strndup(group, strlen(group));
   new->port = 0;
   new->channel = 0;
   if (robin) {
      new->next = robin;
      robin->prev = new;
   }
   robin = new;
   return robin;
}


/*! \brief the main schedule context for stuff like l1 watcher, overlap dial, ... */
static struct sched_context *misdn_tasks = NULL;
static pthread_t misdn_tasks_thread;

static int *misdn_ports;

static void chan_misdn_log(int level, int port, char *tmpl, ...)
   __attribute__ ((format (printf, 3, 4)));

static struct ast_channel *misdn_new(struct chan_list *cl, int state,  char *exten, char *callerid, int format, int port, int c);
static void send_digit_to_chan(struct chan_list *cl, char digit );

static void hangup_chan(struct chan_list *ch);
static int pbx_start_chan(struct chan_list *ch);

#define MISDN_ASTERISK_TECH_PVT(ast) ast->tech_pvt
#define MISDN_ASTERISK_PVT(ast) 1

#include "asterisk/strings.h"

/* #define MISDN_DEBUG 1 */

static const char misdn_type[] = "mISDN";

static int tracing = 0 ;

/*! \brief Only alaw and mulaw is allowed for now */
static int prefformat =  AST_FORMAT_ALAW ; /*  AST_FORMAT_SLINEAR ;  AST_FORMAT_ULAW | */

static int *misdn_debug;
static int *misdn_debug_only;
static int max_ports;

static int *misdn_in_calls;
static int *misdn_out_calls;


struct chan_list dummy_cl;

struct chan_list *cl_te=NULL;
ast_mutex_t cl_te_lock;

static enum event_response_e
cb_events(enum event_e event, struct misdn_bchannel *bc, void *user_data);

static void send_cause2ast(struct ast_channel *ast, struct misdn_bchannel*bc, struct chan_list *ch);

static void cl_queue_chan(struct chan_list **list, struct chan_list *chan);
static void cl_dequeue_chan(struct chan_list **list, struct chan_list *chan);
static struct chan_list *find_chan_by_bc(struct chan_list *list, struct misdn_bchannel *bc);
static struct chan_list *find_chan_by_pid(struct chan_list *list, int pid);



static int dialtone_indicate(struct chan_list *cl);
static int hanguptone_indicate(struct chan_list *cl);
static int stop_indicate(struct chan_list *cl);

static int start_bc_tones(struct chan_list *cl);
static int stop_bc_tones(struct chan_list *cl);
static void release_chan(struct misdn_bchannel *bc);

static int misdn_check_l2l1(struct ast_channel *chan, void *data);
static int misdn_set_opt_exec(struct ast_channel *chan, void *data);
static int misdn_facility_exec(struct ast_channel *chan, void *data);

int chan_misdn_jb_empty(struct misdn_bchannel *bc, char *buf, int len);


void debug_numplan(int port, int numplan, char *type);


int add_out_calls(int port);
int add_in_calls(int port);


#ifdef MISDN_1_2
static int update_pipeline_config(struct misdn_bchannel *bc);
#else
static int update_ec_config(struct misdn_bchannel *bc);
#endif



/*************** Helpers *****************/

static struct chan_list * get_chan_by_ast(struct ast_channel *ast)
{
   struct chan_list *tmp;
  
   for (tmp=cl_te; tmp; tmp = tmp->next) {
      if ( tmp->ast == ast ) return tmp;
   }
  
   return NULL;
}

static struct chan_list * get_chan_by_ast_name(char *name)
{
   struct chan_list *tmp;
  
   for (tmp=cl_te; tmp; tmp = tmp->next) {
      if ( tmp->ast  && strcmp(tmp->ast->name,name) == 0) return tmp;
   }
  
   return NULL;
}



struct allowed_bearers {
   char *name;       /*!< Bearer capability name string used in /etc/misdn.conf allowed_bearers */
   char *display;    /*!< Bearer capability displayable name */
   int cap;       /*!< SETUP message bearer capability field code value */
   int deprecated;      /*!< TRUE if this entry is deprecated. (Misspelled or bad name to use) */
};

/* *INDENT-OFF* */
static const struct allowed_bearers allowed_bearers_array[]= {
   /* Name,                      Displayable Name       Bearer Capability,                    Deprecated */
   { "speech",                  "Speech",               INFO_CAPABILITY_SPEECH,               0 },
   { "3_1khz",                  "3.1KHz Audio",         INFO_CAPABILITY_AUDIO_3_1K,           0 },
   { "digital_unrestricted",    "Unrestricted Digital", INFO_CAPABILITY_DIGITAL_UNRESTRICTED, 0 },
   { "digital_restricted",      "Restricted Digital",   INFO_CAPABILITY_DIGITAL_RESTRICTED,   0 },
   { "digital_restriced",       "Restricted Digital",   INFO_CAPABILITY_DIGITAL_RESTRICTED,   1 }, /* Allow misspelling for backwards compatibility */
   { "video",                   "Video",                INFO_CAPABILITY_VIDEO,                0 }
};
/* *INDENT-ON* */

static const char *bearer2str(int cap)
{
   unsigned index;

   for (index = 0; index < ARRAY_LEN(allowed_bearers_array); ++index) {
      if (allowed_bearers_array[index].cap == cap) {
         return allowed_bearers_array[index].display;
      }
   }  /* end for */

   return "Unknown Bearer";
}


static void print_facility(struct FacParm *fac, struct misdn_bchannel *bc)
{
   switch (fac->Function) {
   case Fac_CD:
      chan_misdn_log(1,bc->port," --> calldeflect to: %s, screened: %s\n", fac->u.CDeflection.DeflectedToNumber,
         fac->u.CDeflection.PresentationAllowed ? "yes" : "no");
      break;
   case Fac_AOCDCurrency:
      if (fac->u.AOCDcur.chargeNotAvailable)
         chan_misdn_log(1,bc->port," --> AOCD currency: charge not available\n");
      else if (fac->u.AOCDcur.freeOfCharge)
         chan_misdn_log(1,bc->port," --> AOCD currency: free of charge\n");
      else if (fac->u.AOCDchu.billingId >= 0)
         chan_misdn_log(1,bc->port," --> AOCD currency: currency:%s amount:%d multiplier:%d typeOfChargingInfo:%s billingId:%d\n",
            fac->u.AOCDcur.currency, fac->u.AOCDcur.currencyAmount, fac->u.AOCDcur.multiplier,
            (fac->u.AOCDcur.typeOfChargingInfo == 0) ? "subTotal" : "total", fac->u.AOCDcur.billingId);
      else
         chan_misdn_log(1,bc->port," --> AOCD currency: currency:%s amount:%d multiplier:%d typeOfChargingInfo:%s\n",
            fac->u.AOCDcur.currency, fac->u.AOCDcur.currencyAmount, fac->u.AOCDcur.multiplier,
            (fac->u.AOCDcur.typeOfChargingInfo == 0) ? "subTotal" : "total");
      break;
   case Fac_AOCDChargingUnit:
      if (fac->u.AOCDchu.chargeNotAvailable)
         chan_misdn_log(1,bc->port," --> AOCD charging unit: charge not available\n");
      else if (fac->u.AOCDchu.freeOfCharge)
         chan_misdn_log(1,bc->port," --> AOCD charging unit: free of charge\n");
      else if (fac->u.AOCDchu.billingId >= 0)
         chan_misdn_log(1,bc->port," --> AOCD charging unit: recordedUnits:%d typeOfChargingInfo:%s billingId:%d\n",
            fac->u.AOCDchu.recordedUnits, (fac->u.AOCDchu.typeOfChargingInfo == 0) ? "subTotal" : "total", fac->u.AOCDchu.billingId);
      else
         chan_misdn_log(1,bc->port," --> AOCD charging unit: recordedUnits:%d typeOfChargingInfo:%s\n",
            fac->u.AOCDchu.recordedUnits, (fac->u.AOCDchu.typeOfChargingInfo == 0) ? "subTotal" : "total");
      break;
   default:
      chan_misdn_log(1,bc->port," --> unknown facility\n");
      break;
   }
}

static void print_bearer(struct misdn_bchannel *bc) 
{
   
   chan_misdn_log(2, bc->port, " --> Bearer: %s\n",bearer2str(bc->capability));
   
   switch(bc->law) {
   case INFO_CODEC_ALAW:
      chan_misdn_log(2, bc->port, " --> Codec: Alaw\n");
      break;
   case INFO_CODEC_ULAW:
      chan_misdn_log(2, bc->port, " --> Codec: Ulaw\n");
      break;
   }
}

static void export_aoc_vars(int originator, struct ast_channel *ast, struct misdn_bchannel *bc)
{
   char buf[128];

   if (!ast)
      return;

   if (originator == ORG_AST) {
      ast = ast_bridged_channel(ast);
      if (!ast)
         return;
   }

   switch (bc->AOCDtype) {
   case Fac_AOCDCurrency:
      pbx_builtin_setvar_helper(ast, "AOCD_Type", "currency");
      if (bc->AOCD.currency.chargeNotAvailable)
         pbx_builtin_setvar_helper(ast, "AOCD_ChargeAvailable", "no");
      else {
         pbx_builtin_setvar_helper(ast, "AOCD_ChargeAvailable", "yes");
         if (bc->AOCD.currency.freeOfCharge)
            pbx_builtin_setvar_helper(ast, "AOCD_FreeOfCharge", "yes");
         else {
            pbx_builtin_setvar_helper(ast, "AOCD_FreeOfCharge", "no");
            if (snprintf(buf, sizeof(buf), "%d %s", bc->AOCD.currency.currencyAmount * bc->AOCD.currency.multiplier, bc->AOCD.currency.currency) < sizeof(buf)) {
               pbx_builtin_setvar_helper(ast, "AOCD_Amount", buf);
               if (bc->AOCD.currency.billingId >= 0 && snprintf(buf, sizeof(buf), "%d", bc->AOCD.currency.billingId) < sizeof(buf))
                  pbx_builtin_setvar_helper(ast, "AOCD_BillingId", buf);
            }
         }
      }
      break;
   case Fac_AOCDChargingUnit:
      pbx_builtin_setvar_helper(ast, "AOCD_Type", "charging_unit");
      if (bc->AOCD.chargingUnit.chargeNotAvailable)
         pbx_builtin_setvar_helper(ast, "AOCD_ChargeAvailable", "no");
      else {
         pbx_builtin_setvar_helper(ast, "AOCD_ChargeAvailable", "yes");
         if (bc->AOCD.chargingUnit.freeOfCharge)
            pbx_builtin_setvar_helper(ast, "AOCD_FreeOfCharge", "yes");
         else {
            pbx_builtin_setvar_helper(ast, "AOCD_FreeOfCharge", "no");
            if (snprintf(buf, sizeof(buf), "%d", bc->AOCD.chargingUnit.recordedUnits) < sizeof(buf)) {
               pbx_builtin_setvar_helper(ast, "AOCD_RecordedUnits", buf);
               if (bc->AOCD.chargingUnit.billingId >= 0 && snprintf(buf, sizeof(buf), "%d", bc->AOCD.chargingUnit.billingId) < sizeof(buf))
                  pbx_builtin_setvar_helper(ast, "AOCD_BillingId", buf);
            }
         }
      }
      break;
   default:
      break;
   }
}

/*************** Helpers END *************/

static void sighandler(int sig)
{}

static void* misdn_tasks_thread_func (void *data)
{
   int wait;
   struct sigaction sa;

   sa.sa_handler = sighandler;
   sa.sa_flags = SA_NODEFER;
   sigemptyset(&sa.sa_mask);
   sigaddset(&sa.sa_mask, SIGUSR1);
   sigaction(SIGUSR1, &sa, NULL);
   
   sem_post((sem_t *)data);

   while (1) {
      wait = ast_sched_wait(misdn_tasks);
      if (wait < 0)
         wait = 8000;
      if (poll(NULL, 0, wait) < 0)
         chan_misdn_log(4, 0, "Waking up misdn_tasks thread\n");
      ast_sched_runq(misdn_tasks);
   }
   return NULL;
}

static void misdn_tasks_init (void)
{
   sem_t blocker;
   int i = 5;

   if (sem_init(&blocker, 0, 0)) {
      perror("chan_misdn: Failed to initialize semaphore!");
      exit(1);
   }

   chan_misdn_log(4, 0, "Starting misdn_tasks thread\n");
   
   misdn_tasks = sched_context_create();
   pthread_create(&misdn_tasks_thread, NULL, misdn_tasks_thread_func, &blocker);

   while (sem_wait(&blocker) && --i);
   sem_destroy(&blocker);
}

static void misdn_tasks_destroy (void)
{
   if (misdn_tasks) {
      chan_misdn_log(4, 0, "Killing misdn_tasks thread\n");
      if ( pthread_cancel(misdn_tasks_thread) == 0 ) {
         cb_log(4, 0, "Joining misdn_tasks thread\n");
         pthread_join(misdn_tasks_thread, NULL);
      }
      sched_context_destroy(misdn_tasks);
   }
}

static inline void misdn_tasks_wakeup (void)
{
   pthread_kill(misdn_tasks_thread, SIGUSR1);
}

static inline int _misdn_tasks_add_variable (int timeout, ast_sched_cb callback, const void *data, int variable)
{
   int task_id;

   if (!misdn_tasks) {
      misdn_tasks_init();
   }
   task_id = ast_sched_add_variable(misdn_tasks, timeout, callback, data, variable);
   misdn_tasks_wakeup();

   return task_id;
}

static int misdn_tasks_add (int timeout, ast_sched_cb callback, const void *data)
{
   return _misdn_tasks_add_variable(timeout, callback, data, 0);
}

static int misdn_tasks_add_variable (int timeout, ast_sched_cb callback, const void *data)
{
   return _misdn_tasks_add_variable(timeout, callback, data, 1);
}

static void misdn_tasks_remove (int task_id)
{
   AST_SCHED_DEL(misdn_tasks, task_id);
}

static int misdn_l1_task (const void *data)
{
   misdn_lib_isdn_l1watcher(*(int *)data);
   chan_misdn_log(5, *(int *)data, "L1watcher timeout\n");
   return 1;
}

static int misdn_overlap_dial_task (const void *data)
{
   struct timeval tv_end, tv_now;
   int diff;
   struct chan_list *ch = (struct chan_list *)data;

   chan_misdn_log(4, ch->bc->port, "overlap dial task, chan_state: %d\n", ch->state);

   if (ch->state != MISDN_WAITING4DIGS) {
      ch->overlap_dial_task = -1;
      return 0;
   }
   
   ast_mutex_lock(&ch->overlap_tv_lock);
   tv_end = ch->overlap_tv;
   ast_mutex_unlock(&ch->overlap_tv_lock);
   
   tv_end.tv_sec += ch->overlap_dial;
   tv_now = ast_tvnow();

   diff = ast_tvdiff_ms(tv_end, tv_now);

   if (diff <= 100) {
      char *dad=ch->bc->dad, sexten[]="s";
      /* if we are 100ms near the timeout, we are satisfied.. */
      stop_indicate(ch);
      
      if (ast_strlen_zero(ch->bc->dad)) {
         dad=sexten;
         strcpy(ch->ast->exten, sexten);
      }

      if (ast_exists_extension(ch->ast, ch->context, dad, 1, ch->bc->oad)) {
         ch->state=MISDN_DIALING;
         if (pbx_start_chan(ch) < 0) {
            chan_misdn_log(-1, ch->bc->port, "ast_pbx_start returned < 0 in misdn_overlap_dial_task\n");
            goto misdn_overlap_dial_task_disconnect;
         }
      } else {
misdn_overlap_dial_task_disconnect:
         hanguptone_indicate(ch);
         ch->bc->out_cause = AST_CAUSE_UNALLOCATED;
         ch->state=MISDN_CLEANING;
         misdn_lib_send_event(ch->bc, EVENT_DISCONNECT);
      }
      ch->overlap_dial_task = -1;
      return 0;
   } else
      return diff;
}

static void send_digit_to_chan(struct chan_list *cl, char digit )
{
   static const char* dtmf_tones[] = {
      "!941+1336/100,!0/100", /* 0 */
      "!697+1209/100,!0/100", /* 1 */
      "!697+1336/100,!0/100", /* 2 */
      "!697+1477/100,!0/100", /* 3 */
      "!770+1209/100,!0/100", /* 4 */
      "!770+1336/100,!0/100", /* 5 */
      "!770+1477/100,!0/100", /* 6 */
      "!852+1209/100,!0/100", /* 7 */
      "!852+1336/100,!0/100", /* 8 */
      "!852+1477/100,!0/100", /* 9 */
      "!697+1633/100,!0/100", /* A */
      "!770+1633/100,!0/100", /* B */
      "!852+1633/100,!0/100", /* C */
      "!941+1633/100,!0/100", /* D */
      "!941+1209/100,!0/100", /* * */
      "!941+1477/100,!0/100" };  /* # */
   struct ast_channel *chan=cl->ast; 
  
   if (digit >= '0' && digit <='9')
      ast_playtones_start(chan,0,dtmf_tones[digit-'0'], 0);
   else if (digit >= 'A' && digit <= 'D')
      ast_playtones_start(chan,0,dtmf_tones[digit-'A'+10], 0);
   else if (digit == '*')
      ast_playtones_start(chan,0,dtmf_tones[14], 0);
   else if (digit == '#')
      ast_playtones_start(chan,0,dtmf_tones[15], 0);
   else {
      /* not handled */
      ast_log(LOG_DEBUG, "Unable to handle DTMF tone '%c' for '%s'\n", digit, chan->name);
   }
}

/*** CLI HANDLING ***/
static int misdn_set_debug(int fd, int argc, char *argv[])
{
   int level;

   if (argc != 4 && argc != 5 && argc != 6 && argc != 7)
      return RESULT_SHOWUSAGE; 

   level = atoi(argv[3]);

   switch (argc) {
   case 4:
   case 5:
      {
         int i;
         int only = 0;
         if (argc == 5) {
            if (strncasecmp(argv[4], "only", strlen(argv[4])))
               return RESULT_SHOWUSAGE;
            else
               only = 1;
         }
   
         for (i = 0; i <= max_ports; i++) {
            misdn_debug[i] = level;
            misdn_debug_only[i] = only;
         }
         ast_cli(fd, "changing debug level for all ports to %d%s\n",misdn_debug[0], only?" (only)":"");
      }
      break;
   case 6:
   case 7:
      {
         int port;
         if (strncasecmp(argv[4], "port", strlen(argv[4])))
            return RESULT_SHOWUSAGE;
         port = atoi(argv[5]);
         if (port <= 0 || port > max_ports) {
            switch (max_ports) {
            case 0:
               ast_cli(fd, "port number not valid! no ports available so you won't get lucky with any number here...\n");
               break;
            case 1:
               ast_cli(fd, "port number not valid! only port 1 is available.\n");
               break;
            default:
               ast_cli(fd, "port number not valid! only ports 1 to %d are available.\n", max_ports);
            }
            return 0;
         }
         if (argc == 7) {
            if (strncasecmp(argv[6], "only", strlen(argv[6])))
               return RESULT_SHOWUSAGE;
            else
               misdn_debug_only[port] = 1;
         } else
            misdn_debug_only[port] = 0;
         misdn_debug[port] = level;
         ast_cli(fd, "changing debug level to %d%s for port %d\n", misdn_debug[port], misdn_debug_only[port]?" (only)":"", port);
      }
   }
   return 0;
}

static int misdn_set_crypt_debug(int fd, int argc, char *argv[])
{
   if (argc != 5) return RESULT_SHOWUSAGE; 

   return 0;
}

static int misdn_port_block(int fd, int argc, char *argv[])
{
   int port;

   if (argc != 4)
      return RESULT_SHOWUSAGE;
  
   port = atoi(argv[3]);

   misdn_lib_port_block(port);

   return 0;
}

static int misdn_port_unblock(int fd, int argc, char *argv[])
{
   int port;
  
   if (argc != 4)
      return RESULT_SHOWUSAGE;
  
   port = atoi(argv[3]);

   misdn_lib_port_unblock(port);

   return 0;
}


static int misdn_restart_port (int fd, int argc, char *argv[])
{
   int port;
  
   if (argc != 4)
      return RESULT_SHOWUSAGE;
  
   port = atoi(argv[3]);

   misdn_lib_port_restart(port);

   return 0;
}

static int misdn_restart_pid (int fd, int argc, char *argv[])
{
   int pid;
  
   if (argc != 4)
      return RESULT_SHOWUSAGE;
  
   pid = atoi(argv[3]);

   misdn_lib_pid_restart(pid);

   return 0;
}

static int misdn_port_up (int fd, int argc, char *argv[])
{
   int port;
   
   if (argc != 4)
      return RESULT_SHOWUSAGE;
   
   port = atoi(argv[3]);
   
   misdn_lib_get_port_up(port);
  
   return 0;
}

static int misdn_port_down (int fd, int argc, char *argv[])
{
   int port;

   if (argc != 4)
      return RESULT_SHOWUSAGE;
   
   port = atoi(argv[3]);
   
   misdn_lib_get_port_down(port);
  
   return 0;
}

static inline void show_config_description (int fd, enum misdn_cfg_elements elem)
{
   char section[BUFFERSIZE];
   char name[BUFFERSIZE];
   char desc[BUFFERSIZE];
   char def[BUFFERSIZE];
   char tmp[BUFFERSIZE];

   misdn_cfg_get_name(elem, tmp, sizeof(tmp));
   term_color(name, tmp, COLOR_BRWHITE, 0, sizeof(tmp));
   misdn_cfg_get_desc(elem, desc, sizeof(desc), def, sizeof(def));

   if (elem < MISDN_CFG_LAST)
      term_color(section, "PORTS SECTION", COLOR_YELLOW, 0, sizeof(section));
   else
      term_color(section, "GENERAL SECTION", COLOR_YELLOW, 0, sizeof(section));

   if (*def)
      ast_cli(fd, "[%s] %s   (Default: %s)\n\t%s\n", section, name, def, desc);
   else
      ast_cli(fd, "[%s] %s\n\t%s\n", section, name, desc);
}

static int misdn_show_config (int fd, int argc, char *argv[])
{
   char buffer[