chan_lcr.c

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** Linux Call Router                                                         **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** Asterisk socket client                                                    **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 /*
  13
  14 Registering to LCR:
  15
  16 To connect, open an LCR socket and send a MESSAGE_HELLO to socket with
  17 the application name. This name is unique an can be used for routing calls.
  18 Now the channel driver is linked to LCR and can receive and make calls.
  19
  20
  21 Call is initiated by LCR:
  22
  23 If a call is received from LCR, a MESSAGE_NEWREF is received first.
  24 The ref_was_assigned ist set to 1.
  25 A new chan_call instance is created. The call reference (ref) is given by
  26 the received MESSAGE_NEWREF. The state is CHAN_LCR_STATE_IN_PREPARE.
  27 After receiving MESSAGE_SETUP from LCR, the ast_channel instance is created
  28 using ast_channel_alloc(1).  The setup information is given to asterisk.
  29 The new Asterisk instance pointer (ast) is stored to chan_call structure.
  30 The state changes to CHAN_LCR_STATE_IN_SETUP.
  31
  32
  33 Call is initiated by Asterisk:
  34
  35 If a call is requested from Asterisk, a new chan_call instance is created.
  36 The new Asterisk instance pointer (ast) is stored to chan_call structure.
  37 The current call ref is set to 0, the state is CHAN_LCR_STATE_OUT_PREPARE.
  38 If the call is received (lcr_call) A MESSAGE_NEWREF is sent to LCR requesting
  39 a new call reference (ref).
  40 The ref_was_assigned ist set to 1.
  41 Further dialing information is queued.
  42 After the new callref is received by special MESSAGE_NEWREF reply, new ref
  43 is stored in the chan_call structure.
  44 The setup information is sent to LCR using MESSAGE_SETUP.
  45 The state changes to CHAN_LCR_STATE_OUT_SETUP.
  46
  47
  48 Call is in process:
  49
  50 During call process, messages are received and sent.
  51 The state changes accordingly.
  52 Any message is allowed to be sent to LCR at any time except MESSAGE_RELEASE.
  53 If a MESSAGE_OVERLAP is received, further dialing is required.
  54 Queued dialing information, if any, is sent to LCR using MESSAGE_DIALING.
  55 In this case, the state changes to CHAN_LCR_STATE_OUT_DIALING.
  56
  57
  58 Call is released by LCR:
  59
  60 A MESSAGE_RELEASE is received with the call reference (ref) to be released.
  61 The current ref is set to 0, to indicate released reference.
  62 The ref_was_assigned==1 shows that there is no other ref to be assigned.
  63 The state changes to CHAN_LCR_STATE_RELEASE.
  64 ast_queue_hangup() is called, if asterisk instance (ast) exists, if not,
  65 the chan_call instance is destroyed.
  66 After lcr_hangup() is called-back by Asterisk, the chan_call instance
  67 is destroyed, because the current ref is set to 0 and the state equals
  68 CHAN_LCR_STATE_RELEASE.
  69 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, see the proceedure
  70 "Call is released by Asterisk".
  71
  72
  73 Call is released by Asterisk:
  74
  75 lcr_hangup() is called-back by Asterisk. If the call reference (ref) is set,
  76 a MESSAGE_RELEASE is sent to LCR and the chan_call instance is destroyed.
  77 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, the new state is
  78 set to CHAN_LCR_STATE_RELEASE.
  79 The ref_was_assigned==0 shows that a ref is still requested.
  80 Later, if the MESSAGE_NEWREF reply is received, a MESSAGE_RELEASE is sent to
  81 LCR and the chan_call instance is destroyed.
  82 If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure
  83 "Call is released by LCR".
  84
  85
  86 Locking issues:
  87
  88 The deadlocking problem:
  89
  90 - chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel
  91 to be unlocked.
  92 - ast_channel thread locks ast_channel and calls a tech function and waits
  93 there for chan_lock to be unlocked.
  94
  95 The solution:
  96
  97 Never call ast_queue_xxxx() if ast_channel is not locked and don't wait until
  98 ast_channel can be locked. All messages to asterisk are queued inside call
  99 instance and will be handled using a try-lock to get ast_channel lock.
 100 If it succeeds to lock ast_channel, the ast_queue_xxxx can safely called even
 101 if the lock is incremented and decremented there.
 102
 103 Exception: Calling ast_queue_frame inside ast->tech->read is safe, because
 104 it is called from ast_channel process which has already locked ast_channel.
 105
 106 */
 107
 108 #include <stdio.h>
 109 #include <stdlib.h>
 110 #include <string.h>
 111 #include <stdarg.h>
 112 #include <errno.h>
 113 #include <sys/types.h>
 114 #include <time.h>
 115 //#include <signal.h>
 116 #include <unistd.h>
 117 #include <fcntl.h>
 118 #include <sys/ioctl.h>
 119 #include <sys/socket.h>
 120 #include <sys/un.h>
 121
 122 #include <semaphore.h>
 123
 124 #include <asterisk/module.h>
 125 #include <asterisk/channel.h>
 126 #include <asterisk/config.h>
 127 #include <asterisk/logger.h>
 128 #include <asterisk/pbx.h>
 129 #include <asterisk/options.h>
 130 #include <asterisk/io.h>
 131 #include <asterisk/frame.h>
 132 #include <asterisk/translate.h>
 133 #include <asterisk/cli.h>
 134 #include <asterisk/musiconhold.h>
 135 #include <asterisk/dsp.h>
 136 #include <asterisk/translate.h>
 137 #include <asterisk/file.h>
 138 #include <asterisk/callerid.h>
 139 #include <asterisk/indications.h>
 140 #include <asterisk/app.h>
 141 #include <asterisk/features.h>
 142 #include <asterisk/sched.h>
 143
 144 #include "extension.h"
 145 #include "message.h"
 146 #include "callerid.h"
 147 #include "lcrsocket.h"
 148 #include "cause.h"
 149 #include "bchannel.h"
 150 #include "options.h"
 151 #include "chan_lcr.h"
 152
 153 CHAN_LCR_STATE // state description structure
 154 MESSAGES // message text
 155
 156 unsigned char flip_bits[256];
 157
 158 int lcr_debug=1;
 159 int mISDN_created=1;
 160
 161 char lcr_type[]="lcr";
 162
 163 pthread_t chan_tid;
 164 ast_mutex_t chan_lock; /* global lock */
 165 ast_mutex_t log_lock; /* logging log */
 166 int quit;
 167
 168 int glob_channel = 0;
 169
 170 int lcr_sock = -1;
 171
 172 struct admin_list {
 173         struct admin_list *next;
 174         struct admin_message msg;
 175 } *admin_first = NULL;
 176
 177 static struct ast_channel_tech lcr_tech;
 178
 179 /*
 180  * logging
 181  */
 182 void chan_lcr_log(int type, const char *file, int line, const char *function, struct chan_call *call, struct ast_channel *ast, const char *fmt, ...)
 183 {
 184         char buffer[1024];
 185         char call_text[128] = "NULL";
 186         char ast_text[128] = "NULL";
 187         va_list args;
 188
 189         ast_mutex_lock(&log_lock);
 190
 191         va_start(args,fmt);
 192         vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
 193         buffer[sizeof(buffer)-1]=0;
 194         va_end(args);
 195
 196         if (call)
 197                 sprintf(call_text, "%d", call->ref);
 198         if (ast)
 199                 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
 200         ast_text[sizeof(ast_text)-1] = '\0';
 201
 202         ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
 203
 204         ast_mutex_unlock(&log_lock);
 205 }
 206
 207 /*
 208  * channel and call instances
 209  */
 210 struct chan_call *call_first;
 211
 212 /*
 213  * find call by ref
 214  * special case: 0: find new ref, that has not been assigned a ref yet
 215  */
 216
 217 struct chan_call *find_call_ref(unsigned int ref)
 218 {
 219         struct chan_call *call = call_first;
 220         int assigned = (ref > 0);
 221
 222         while(call)
 223         {
 224                 if (call->ref == ref && call->ref_was_assigned == assigned)
 225                         break;
 226                 call = call->next;
 227         }
 228         return(call);
 229 }
 230
 231 void free_call(struct chan_call *call)
 232 {
 233         struct chan_call **temp = &call_first;
 234
 235         while(*temp)
 236         {
 237                 if (*temp == call)
 238                 {
 239                         *temp = (*temp)->next;
 240                         if (call->pipe[0] > -1)
 241                                 close(call->pipe[0]);
 242                         if (call->pipe[1] > -1)
 243                                 close(call->pipe[1]);
 244                         if (call->bchannel)
 245                         {
 246                                 if (call->bchannel->call != call)
 247                                         CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
 248                                 call->bchannel->call = NULL;
 249                         }
 250                         if (call->bridge_call)
 251                         {
 252                                 if (call->bridge_call->bridge_call != call)
 253                                         CERROR(call, NULL, "Linked call structure has no link to us.\n");
 254                                 call->bridge_call->bridge_call = NULL;
 255                         }
 256                         CDEBUG(call, NULL, "Call instance freed.\n");
 257                         free(call);
 258                         return;
 259                 }
 260                 temp = &((*temp)->next);
 261         }
 262         CERROR(call, NULL, "Call instance not found in list.\n");
 263 }
 264
 265 struct chan_call *alloc_call(void)
 266 {
 267         struct chan_call **callp = &call_first;
 268
 269         while(*callp)
 270                 callp = &((*callp)->next);
 271
 272         *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
 273         if (*callp)
 274                 memset(*callp, 0, sizeof(struct chan_call));
 275         if (pipe((*callp)->pipe) < 0) {
 276                 CERROR(*callp, NULL, "Failed to create pipe.\n");
 277                 free_call(*callp);
 278                 return(NULL);
 279         }
 280         fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
 281         CDEBUG(*callp, NULL, "Call instance allocated.\n");
 282         return(*callp);
 283 }
 284
 285 unsigned short new_bridge_id(void)
 286 {
 287         struct chan_call *call;
 288         unsigned short id = 1;
 289
 290         /* search for lowest bridge id that is not in use and not 0 */
 291         while(id)
 292         {
 293                 call = call_first;
 294                 while(call)
 295                 {
 296                         if (call->bridge_id == id)
 297                                 break;
 298                         call = call->next;
 299                 }
 300                 if (!call)
 301                         break;
 302                 id++;
 303         }
 304         CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
 305         return(id);
 306 }
 307
 308 /*
 309  * enque message to LCR
 310  */
 311 int send_message(int message_type, unsigned int ref, union parameter *param)
 312 {
 313         struct admin_list *admin, **adminp;
 314
 315         if (lcr_sock < 0) {
 316                 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
 317                 return -1;
 318         }
 319         CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
 320
 321         adminp = &admin_first;
 322         while(*adminp)
 323                 adminp = &((*adminp)->next);
 324         admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
 325         if (!admin) {
 326                 CERROR(NULL, NULL, "No memory for message to LCR.\n");
 327                 return -1;
 328         }
 329         *adminp = admin;
 330
 331         admin->msg.message = ADMIN_MESSAGE;
 332         admin->msg.u.msg.type = message_type;
 333         admin->msg.u.msg.ref = ref;
 334         memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
 335
 336         return(0);
 337 }
 338
 339 /*
 340  * apply options (in locked state)
 341  */
 342 void apply_opt(struct chan_call *call, char *data)
 343 {
 344         union parameter newparam;
 345         char string[1024], *p = string, *opt, *key;
 346         int gain, i, newmode = 0;
 347
 348         if (!data[0])
 349                 return; // no opts
 350
 351         strncpy(string, data, sizeof(string)-1);
 352         string[sizeof(string)-1] = '\0';
 353
 354         /* parse options */
 355         while((opt = strsep(&p, ":")))
 356         {
 357                 switch(opt[0]) {
 358                 case 'd':
 359                         if (opt[1] == '\0') {
 360                                 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
 361                                 break;
 362                         }
 363                         CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
 364                         if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
 365                                 strncpy(call->display, opt+1, sizeof(call->display)-1);
 366                         else {
 367                                 memset(&newparam, 0, sizeof(union parameter));
 368                                 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
 369                                 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
 370                         }
 371                         break;
 372                 case 'n':
 373                         if (opt[1] != '\0') {
 374                                 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
 375                                 break;
 376                         }
 377                         CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
 378                         call->no_dtmf = 1;
 379                         break;
 380                 case 'c':
 381                         if (opt[1] == '\0') {
 382                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
 383                                 break;
 384                         }
 385                         key = opt+1;
 386                         /* check for 0xXXXX... type of key */
 387                         if (!!strncmp((char *)key, "0x", 2)) {
 388                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
 389                                 break;
 390                         }
 391                         key+=2;
 392                         if (strlen(key) > 56*2 || (strlen(key) % 1)) {
 393                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
 394                                 break;
 395                         }
 396                         i = 0;
 397                         while(*key)
 398                         {
 399                                 if (*key>='0' && *key<='9')
 400                                         call->bf_key[i] = (*key-'0') << 8;
 401                                 else if (*key>='a' && *key<='f')
 402                                         call->bf_key[i] = (*key-'a'+10) << 8;
 403                                 else if (*key>='A' && *key<='F')
 404                                         call->bf_key[i] = (*key-'A'+10) << 8;
 405                                 else
 406                                         break;
 407                                 key++;
 408                                 if (*key>='0' && *key<='9')
 409                                         call->bf_key[i] += (*key - '0');
 410                                 else if (*key>='a' && *key<='f')
 411                                         call->bf_key[i] += (*key - 'a' + 10);
 412                                 else if (*key>='A' && *key<='F')
 413                                         call->bf_key[i] += (*key - 'A' + 10);
 414                                 else
 415                                         break;
 416                                 key++;
 417                                 i++;
 418                         }
 419                         if (*key) {
 420                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
 421                                 break;
 422                         }
 423                         call->bf_len = i;
 424                         CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
 425                         if (call->bchannel)
 426                                 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
 427                         break;
 428                 case 'h':
 429                         if (opt[1] != '\0') {
 430                                 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
 431                                 break;
 432                         }
 433                         CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
 434                         if (!call->hdlc) {
 435                                 call->hdlc = 1;
 436                                 newmode = 1;
 437                         }
 438                         break;
 439                 case 't':
 440                         if (opt[1] != '\0') {
 441                                 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
 442                                 break;
 443                         }
 444                         CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
 445                         if (!call->nodsp) {
 446                                 call->nodsp = 1;
 447                                 newmode = 1;
 448                         }
 449                         break;
 450                 case 'e':
 451                         if (opt[1] == '\0') {
 452                                 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
 453                                 break;
 454                         }
 455                         CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
 456                         strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
 457                         if (call->bchannel)
 458                                 bchannel_pipeline(call->bchannel, call->pipeline);
 459                         break;
 460                 case 'r':
 461                         if (opt[1] != '\0') {
 462                                 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
 463                                 break;
 464                         }
 465                         CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
 466                         call->rebuffer = 1;
 467                         break;
 468                 case 's':
 469                         if (opt[1] != '\0') {
 470                                 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
 471                                 break;
 472                         }
 473                         CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
 474                         call->inband_dtmf = 1;
 475                         break;
 476                 case 'v':
 477                         if (opt[1] != 'r' && opt[1] != 't') {
 478                                 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
 479                                 break;
 480                         }
 481                         gain = atoi(opt+2);
 482                         if (gain < -8 || gain >8) {
 483                                 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
 484                                 break;
 485                         }
 486                         CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
 487                         if (opt[1] == 'r') {
 488                                 call->rx_gain = gain;
 489                                 if (call->bchannel)
 490                                         bchannel_gain(call->bchannel, call->rx_gain, 0);
 491                         } else {
 492                                 call->tx_gain = gain;
 493                                 if (call->bchannel)
 494                                         bchannel_gain(call->bchannel, call->tx_gain, 1);
 495                         }
 496                         break;
 497                 default:
 498                         CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
 499                 }
 500         }
 501
 502         /* re-open, if bchannel is created */
 503         if (call->bchannel && call->bchannel->b_sock > -1) {
 504                 bchannel_destroy(call->bchannel);
 505                 if (bchannel_create(call->bchannel, ((call->nodsp)?1:0) + ((call->hdlc)?2:0)))
 506                         bchannel_activate(call->bchannel, 1);
 507         }
 508 }
 509
 510 /*
 511  * send setup info to LCR
 512  * this function is called, when asterisk call is received and ref is received
 513  */
 514 static void send_setup_to_lcr(struct chan_call *call)
 515 {
 516         union parameter newparam;
 517         struct ast_channel *ast = call->ast;
 518
 519         if (!call->ast || !call->ref)
 520                 return;
 521
 522         CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
 523
 524         /* send setup message to LCR */
 525         memset(&newparam, 0, sizeof(union parameter));
 526         newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
 527         newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
 528         strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
 529         strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
 530         newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
 531         newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 532         strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
 533         call->display[0] = '\0';
 534         if (call->cid_num[0])
 535                 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
 536         if (call->cid_name[0])
 537                 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
 538         if (call->cid_rdnis[0])
 539         {
 540                 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
 541                 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
 542                 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
 543         }
 544         switch(ast->cid.cid_pres & AST_PRES_RESTRICTION)
 545         {
 546                 case AST_PRES_ALLOWED:
 547                 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
 548                 break;
 549                 case AST_PRES_RESTRICTED:
 550                 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
 551                 break;
 552                 case AST_PRES_UNAVAILABLE:
 553                 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
 554                 break;
 555                 default:
 556                 newparam.setup.callerinfo.present = INFO_PRESENT_NULL;
 557         }
 558         switch(ast->cid.cid_ton)
 559         {
 560                 case 4:
 561                 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
 562                 break;
 563                 case 2:
 564                 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
 565                 break;
 566                 case 1:
 567                 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
 568                 break;
 569                 default:
 570                 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 571         }
 572         newparam.setup.capainfo.bearer_capa = ast->transfercapability;
 573         newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
 574         if (call->hdlc)
 575                 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
 576         else {
 577                 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
 578                 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
 579         }
 580         newparam.setup.capainfo.hlc = INFO_HLC_NONE;
 581         newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
 582         send_message(MESSAGE_SETUP, call->ref, &newparam);
 583
 584         /* change to outgoing setup state */
 585         call->state = CHAN_LCR_STATE_OUT_SETUP;
 586 }
 587
 588 /*
 589  * send dialing info to LCR
 590  * this function is called, when setup acknowledge is received and dialing
 591  * info is available.
 592  */
 593 static void send_dialque_to_lcr(struct chan_call *call)
 594 {
 595         union parameter newparam;
 596
 597         if (!call->ast || !call->ref || !call->dialque[0])
 598                 return;
 599
 600         CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
 601
 602         /* send setup message to LCR */
 603         memset(&newparam, 0, sizeof(union parameter));
 604         strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
 605         call->dialque[0] = '\0';
 606         send_message(MESSAGE_INFORMATION, call->ref, &newparam);
 607 }
 608
 609 /*
 610  * in case of a bridge, the unsupported message can be forwarded directly
 611  * to the remote call.
 612  */
 613 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
 614 {
 615         /* check bridge */
 616         if (!call) return;
 617         if (!call->bridge_call) return;
 618         CDEBUG(call, NULL, "Sending message due bridging.\n");
 619         send_message(message_type, call->bridge_call->ref, param);
 620 }
 621
 622 /*
 623  * send release message to LCR and import bchannel if exported
 624  */
 625 static void send_release_and_import(struct chan_call *call, int cause, int location)
 626 {
 627         union parameter newparam;
 628
 629         /* importing channel */
 630         if (call->bchannel) {
 631                 memset(&newparam, 0, sizeof(union parameter));
 632                 newparam.bchannel.type = BCHANNEL_RELEASE;
 633                 newparam.bchannel.handle = call->bchannel->handle;
 634                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
 635         }
 636         /* sending release */
 637         memset(&newparam, 0, sizeof(union parameter));
 638         newparam.disconnectinfo.cause = cause;
 639         newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
 640         send_message(MESSAGE_RELEASE, call->ref, &newparam);
 641 }
 642
 643 /*
 644  * check if extension matches and start asterisk
 645  * if it can match, proceed
 646  * if not, release
 647  */
 648 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
 649 {
 650         int cause, ret;
 651         union parameter newparam;
 652         char *exten = ast->exten;
 653         if (!*exten)
 654                 exten = "s";
 655
 656         CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
 657
 658         if (complete)
 659         {
 660                 /* if not match */
 661                 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad))
 662                 {
 663                         CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
 664                         cause = 1;
 665                         goto release;
 666                 }
 667                 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad))
 668                 {
 669                         CDEBUG(call, ast, "Got 'sending complete', but extension '%s' would match at context '%s', if more digits would be dialed - releasing.\n", exten, ast->context);
 670                         cause = 28;
 671                         goto release;
 672                 }
 673                 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
 674                 /* send setup acknowledge to lcr */
 675                 memset(&newparam, 0, sizeof(union parameter));
 676                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
 677
 678                 /* change state */
 679                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
 680
 681                 goto start;
 682         }
 683
 684         if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad))
 685         {
 686                 /* send setup acknowledge to lcr */
 687                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 688                         memset(&newparam, 0, sizeof(union parameter));
 689                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 690                 }
 691
 692                 /* change state */
 693                 call->state = CHAN_LCR_STATE_IN_DIALING;
 694
 695                 /* if match, start pbx */
 696                 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
 697                         CDEBUG(call, ast, "Extensions matches.\n");
 698                         goto start;
 699                 }
 700
 701                 /* if can match */
 702                 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
 703                 return;
 704         }
 705
 706         /* if not match */
 707         cause = 1;
 708         release:
 709         /* release lcr */
 710         CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
 711         send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
 712         call->ref = 0;
 713         /* release asterisk */
 714         ast->hangupcause = call->cause;
 715         /* change to release state */
 716         call->state = CHAN_LCR_STATE_RELEASE;
 717         ast_hangup(ast); // call will be destroyed here
 718         return;
 719
 720         start:
 721         /* send setup to asterisk */
 722         CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
 723         ret = ast_pbx_start(ast);
 724         if (ret < 0)
 725         {
 726                 cause = (ret==-2)?34:27;
 727                 goto release;
 728         }
 729         call->pbx_started = 1;
 730                 ast_setstate(ast, AST_STATE_RING);
 731 }
 732
 733 /*
 734  * incoming setup from LCR
 735  */
 736 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
 737 {
 738         struct ast_channel *ast;
 739
 740         CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
 741
 742         /* create asterisk channel instrance */
 743         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
 744         if (!ast)
 745         {
 746                 /* release */
 747                 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
 748                 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
 749                 /* remove call */
 750                 free_call(call);
 751                 return;
 752         }
 753         /* link together */
 754         call->ast = ast;
 755         ast->tech_pvt = call;
 756         ast->tech = &lcr_tech;
 757         ast->fds[0] = call->pipe[0];
 758
 759         /* fill setup information */
 760         if (param->setup.dialinginfo.id)
 761                 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
 762         if (param->setup.context[0])
 763                 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
 764         else
 765                 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
 766         if (param->setup.callerinfo.id[0])
 767                 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
 768         if (param->setup.callerinfo.name[0])
 769                 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
 770         if (param->setup.redirinfo.id[0])
 771                 ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
 772         switch (param->setup.callerinfo.present)
 773         {
 774                 case INFO_PRESENT_ALLOWED:
 775                         ast->cid.cid_pres = AST_PRES_ALLOWED;
 776                 break;
 777                 case INFO_PRESENT_RESTRICTED:
 778                         ast->cid.cid_pres = AST_PRES_RESTRICTED;
 779                 break;
 780                 default:
 781                         ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
 782         }
 783         switch (param->setup.callerinfo.ntype)
 784         {
 785                 case INFO_NTYPE_SUBSCRIBER:
 786                         ast->cid.cid_ton = 4;
 787                 break;
 788                 case INFO_NTYPE_NATIONAL:
 789                         ast->cid.cid_ton = 2;
 790                 break;
 791                 case INFO_NTYPE_INTERNATIONAL:
 792                         ast->cid.cid_ton = 1;
 793                 break;
 794                 default:
 795                         ast->cid.cid_ton = 0;
 796         }
 797         ast->transfercapability = param->setup.capainfo.bearer_capa;
 798         /* enable hdlc if transcap is data */
 799         if (param->setup.capainfo.source_mode == B_MODE_HDLC)
 800                 call->hdlc = 1;
 801         strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
 802
 803         /* configure channel */
 804         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
 805         ast->readformat = ast->rawreadformat = ast->nativeformats;
 806         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
 807         ast->priority = 1;
 808         ast->hangupcause = 0;
 809
 810         /* change state */
 811         call->state = CHAN_LCR_STATE_IN_SETUP;
 812
 813         if (!call->pbx_started)
 814                 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
 815 }
 816
 817 /*
 818  * incoming setup acknowledge from LCR
 819  */
 820 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
 821 {
 822         if (!call->ast) return;
 823
 824         CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
 825
 826         /* send pending digits in dialque */
 827         if (call->dialque[0])
 828                 send_dialque_to_lcr(call);
 829         /* change to overlap state */
 830         call->state = CHAN_LCR_STATE_OUT_DIALING;
 831 }
 832
 833 /*
 834  * incoming proceeding from LCR
 835  */
 836 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
 837 {
 838         CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
 839
 840         /* change state */
 841         call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
 842         /* queue event for asterisk */
 843         if (call->ast && call->pbx_started)
 844                 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
 845 }
 846
 847 /*
 848  * incoming alerting from LCR
 849  */
 850 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
 851 {
 852         CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
 853
 854         /* change state */
 855         call->state = CHAN_LCR_STATE_OUT_ALERTING;
 856         /* queue event to asterisk */
 857         if (call->ast && call->pbx_started)
 858                 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
 859 }
 860
 861 /*
 862  * incoming connect from LCR
 863  */
 864 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
 865 {
 866         union parameter newparam;
 867
 868         CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
 869
 870         /* change state */
 871         call->state = CHAN_LCR_STATE_CONNECT;
 872         /* request bchannel */
 873         if (!call->bchannel) {
 874                 CDEBUG(call, call->ast, "Requesting B-channel.\n");
 875                 memset(&newparam, 0, sizeof(union parameter));
 876                 newparam.bchannel.type = BCHANNEL_REQUEST;
 877                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
 878         }
 879         /* copy connectinfo */
 880         memcpy(&call->connectinfo, &param->connectinfo, sizeof(struct connect_info));
 881         /* queue event to asterisk */
 882         if (call->ast && call->pbx_started)
 883                 strncat(call->queue_string, "A", sizeof(call->queue_string)-1);
 884 }
 885
 886 /*
 887  * incoming disconnect from LCR
 888  */
 889 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
 890 {
 891         struct ast_channel *ast = call->ast;
 892
 893         CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
 894
 895         /* change state */
 896         call->state = CHAN_LCR_STATE_IN_DISCONNECT;
 897         /* save cause */
 898         call->cause = param->disconnectinfo.cause;
 899         call->location = param->disconnectinfo.location;
 900         /* if bridge, forward disconnect and return */
 901 #ifdef TODO
 902         feature flag
 903         if (call->bridge_call)
 904         {
 905                 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
 906                 bridge_message_if_bridged(call, message_type, param);
 907                 return;
 908         }
 909 #endif
 910         /* release lcr with same cause */
 911         send_release_and_import(call, call->cause, call->location);
 912         call->ref = 0;
 913         /* change to release state */
 914         call->state = CHAN_LCR_STATE_RELEASE;
 915         /* queue release asterisk */
 916         if (ast)
 917         {
 918                 ast->hangupcause = call->cause;
 919                 if (call->pbx_started)
 920                         strcpy(call->queue_string, "H"); // overwrite other indications
 921                 else {
 922                         ast_hangup(ast); // call will be destroyed here
 923                 }
 924         }
 925 }
 926
 927 /*
 928  * incoming release from LCR
 929  */
 930 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
 931 {
 932         struct ast_channel *ast = call->ast;
 933
 934         CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
 935
 936         /* release ref */
 937         call->ref = 0;
 938         /* change to release state */
 939         call->state = CHAN_LCR_STATE_RELEASE;
 940         /* copy release info */
 941         if (!call->cause)
 942         {
 943                call->cause = param->disconnectinfo.cause;
 944                call->location = param->disconnectinfo.location;
 945         }
 946         /* if we have an asterisk instance, queue hangup, else we are done */
 947         if (ast)
 948         {
 949                 ast->hangupcause = call->cause;
 950                 if (call->pbx_started)
 951                         strcpy(call->queue_string, "H");
 952                 else {
 953                         ast_hangup(ast); // call will be destroyed here
 954                 }
 955         } else
 956         {
 957                 free_call(call);
 958         }
 959
 960 }
 961
 962 /*
 963  * incoming information from LCR
 964  */
 965 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
 966 {
 967         struct ast_channel *ast = call->ast;
 968
 969         CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
 970
 971         if (!ast) return;
 972
 973         /* pbx not started */
 974         if (!call->pbx_started)
 975         {
 976                 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
 977                 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
 978                 lcr_start_pbx(call, ast, param->information.sending_complete);
 979                 return;
 980         }
 981
 982         /* change dailing state after setup */
 983         if (call->state == CHAN_LCR_STATE_IN_SETUP) {
 984                 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
 985                 call->state = CHAN_LCR_STATE_IN_DIALING;
 986 //              ast_setstate(ast, AST_STATE_DIALING);
 987         }
 988
 989         /* queue digits */
 990         if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0])
 991                 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
 992
 993         /* use bridge to forware message not supported by asterisk */
 994         if (call->state == CHAN_LCR_STATE_CONNECT) {
 995                 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
 996                 bridge_message_if_bridged(call, message_type, param);
 997         }
 998 }
 999
1000 /*
1001  * incoming information from LCR
1002  */
1003 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1004 {
1005         union parameter newparam;
1006
1007         CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1008
1009         /* request bchannel, if call is resumed and we don't have it */
1010         if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1011                 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1012                 memset(&newparam, 0, sizeof(union parameter));
1013                 newparam.bchannel.type = BCHANNEL_REQUEST;
1014                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1015         }
1016
1017         if (!call->ast) return;
1018
1019         /* use bridge to forware message not supported by asterisk */
1020         bridge_message_if_bridged(call, message_type, param);
1021 }
1022
1023 /*
1024  * incoming information from LCR
1025  */
1026 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1027 {
1028         CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1029
1030         if (!call->ast) return;
1031
1032         /* use bridge to forware message not supported by asterisk */
1033         bridge_message_if_bridged(call, message_type, param);
1034 }
1035
1036 /*
1037  * got dtmf from bchannel (locked state)
1038  */
1039 void lcr_in_dtmf(struct chan_call *call, int val)
1040 {
1041         struct ast_channel *ast = call->ast;
1042         char digit[2];
1043
1044         if (!ast)
1045                 return;
1046         if (!call->pbx_started)
1047                 return;
1048
1049         CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1050         digit[0] = val;
1051         digit[1] = '\0';
1052         strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1053 }
1054
1055 /*
1056  * message received from LCR
1057  */
1058 int receive_message(int message_type, unsigned int ref, union parameter *param)
1059 {
1060         struct bchannel *bchannel;
1061         struct chan_call *call;
1062         union parameter newparam;
1063
1064         memset(&newparam, 0, sizeof(union parameter));
1065
1066         /* handle bchannel message*/
1067         if (message_type == MESSAGE_BCHANNEL)
1068         {
1069                 switch(param->bchannel.type)
1070                 {
1071                         case BCHANNEL_ASSIGN:
1072                         CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1073                         if ((bchannel = find_bchannel_handle(param->bchannel.handle)))
1074                         {
1075                                 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1076                                 return(-1);
1077                         }
1078                         /* create bchannel */
1079                         bchannel = alloc_bchannel(param->bchannel.handle);
1080                         if (!bchannel)
1081                         {
1082                                 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1083                                 return(-1);
1084                         }
1085
1086                         /* configure channel */
1087                         bchannel->b_tx_gain = param->bchannel.tx_gain;
1088                         bchannel->b_rx_gain = param->bchannel.rx_gain;
1089                         strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1090                         if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key))
1091                         {
1092                                 bchannel->b_bf_len = param->bchannel.crypt_len;
1093                                 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1094                         }
1095                         bchannel->b_txdata = 0;
1096                         bchannel->b_dtmf = 1;
1097                         bchannel->b_tx_dejitter = 1;
1098
1099                         /* in case, ref is not set, this bchannel instance must
1100                          * be created until it is removed again by LCR */
1101                         /* link to call */
1102                         call = find_call_ref(ref);
1103                         if (call)
1104                         {
1105                                 bchannel->call = call;
1106                                 call->bchannel = bchannel;
1107                                 if (call->dtmf)
1108                                         bchannel_dtmf(bchannel, 1);
1109                                 if (call->bf_len)
1110                                         bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1111                                 if (call->pipeline[0])
1112                                         bchannel_pipeline(bchannel, call->pipeline);
1113                                 if (call->rx_gain)
1114                                         bchannel_gain(bchannel, call->rx_gain, 0);
1115                                 if (call->tx_gain)
1116                                         bchannel_gain(bchannel, call->tx_gain, 1);
1117                                 if (call->bridge_id) {
1118                                         CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1119                                         bchannel_join(bchannel, call->bridge_id);
1120                                 }
1121                                 /* create only, if call exists, othewhise it bchannel is freed below... */
1122                                 if (bchannel_create(bchannel, ((call->nodsp)?1:0) + ((call->hdlc)?2:0)))
1123                                         bchannel_activate(bchannel, 1);
1124                         }
1125                         /* acknowledge */
1126                         newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1127                         newparam.bchannel.handle = param->bchannel.handle;
1128                         send_message(MESSAGE_BCHANNEL, 0, &newparam);
1129                         /* if call has released before bchannel is assigned */
1130                         if (!call) {
1131                                 newparam.bchannel.type = BCHANNEL_RELEASE;
1132                                 newparam.bchannel.handle = param->bchannel.handle;
1133                                 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1134                         }
1135
1136                         break;
1137
1138                         case BCHANNEL_REMOVE:
1139                         CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1140                         if (!(bchannel = find_bchannel_handle(param->bchannel.handle)))
1141                         {
1142                                 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1143                                 return(-1);
1144                         }
1145                         /* unklink from call and destroy bchannel */
1146                         free_bchannel(bchannel);
1147
1148                         /* acknowledge */
1149                         newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1150                         newparam.bchannel.handle = param->bchannel.handle;
1151                         send_message(MESSAGE_BCHANNEL, 0, &newparam);
1152
1153                         break;
1154
1155                         default:
1156                         CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1157                 }
1158                 return(0);
1159         }
1160
1161         /* handle new ref */
1162         if (message_type == MESSAGE_NEWREF)
1163         {
1164                 if (param->direction)
1165                 {
1166                         /* new ref from lcr */
1167                         CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1168                         if (!ref || find_call_ref(ref))
1169                         {
1170                                 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1171                                 return(-1);
1172                         }
1173                         /* allocate new call instance */
1174                         call = alloc_call();
1175                         /* new state */
1176                         call->state = CHAN_LCR_STATE_IN_PREPARE;
1177                         /* set ref */
1178                         call->ref = ref;
1179                         call->ref_was_assigned = 1;
1180                         /* wait for setup (or release from asterisk) */
1181                 } else
1182                 {
1183                         /* new ref, as requested from this remote application */
1184                         CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1185                         call = find_call_ref(0);
1186                         if (!call)
1187                         {
1188                                 /* send release, if ref does not exist */
1189                                 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1190                                 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1191                                 return(0);
1192                         }
1193                         /* store new ref */
1194                         call->ref = ref;
1195                         call->ref_was_assigned = 1;
1196                         /* send pending setup info */
1197                         if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1198                                 send_setup_to_lcr(call);
1199                         /* release if asterisk has signed off */
1200                         else if (call->state == CHAN_LCR_STATE_RELEASE)
1201                         {
1202                                 /* send release */
1203                                 if (call->cause)
1204                                         send_release_and_import(call, call->cause, call->location);
1205                                 else
1206                                         send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1207                                 /* free call */
1208                                 free_call(call);
1209                                 return(0);
1210                         }
1211                 }
1212                 return(0);
1213         }
1214
1215         /* check ref */
1216         if (!ref)
1217         {
1218                 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1219                 return(-1);
1220         }
1221         call = find_call_ref(ref);
1222         if (!call)
1223         {
1224                 /* ignore ref that is not used (anymore) */
1225                 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1226                 return(0);
1227         }
1228
1229         /* handle messages */
1230         switch(message_type)
1231         {
1232                 case MESSAGE_SETUP:
1233                 lcr_in_setup(call, message_type, param);
1234                 break;
1235
1236                 case MESSAGE_OVERLAP:
1237                 lcr_in_overlap(call, message_type, param);
1238                 break;
1239
1240                 case MESSAGE_PROCEEDING:
1241                 lcr_in_proceeding(call, message_type, param);
1242                 break;
1243
1244                 case MESSAGE_ALERTING:
1245                 lcr_in_alerting(call, message_type, param);
1246                 break;
1247
1248                 case MESSAGE_CONNECT:
1249                 lcr_in_connect(call, message_type, param);
1250                 break;
1251
1252                 case MESSAGE_DISCONNECT:
1253                 lcr_in_disconnect(call, message_type, param);
1254                 break;
1255
1256                 case MESSAGE_RELEASE:
1257                 lcr_in_release(call, message_type, param);
1258                 break;
1259
1260                 case MESSAGE_INFORMATION:
1261                 lcr_in_information(call, message_type, param);
1262                 break;
1263
1264                 case MESSAGE_NOTIFY:
1265                 lcr_in_notify(call, message_type, param);
1266                 break;
1267
1268                 case MESSAGE_FACILITY:
1269                 lcr_in_facility(call, message_type, param);
1270                 break;
1271
1272                 case MESSAGE_PATTERN: // audio available from LCR
1273                 break;
1274
1275                 case MESSAGE_NOPATTERN: // audio not available from LCR
1276                 break;
1277
1278                 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1279                 call->audiopath = param->audiopath;
1280                 break;
1281
1282                 default:
1283                 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1284                 break;
1285         }
1286         return(0);
1287 }
1288
1289 /*
1290  * release all calls (due to broken socket)
1291  */
1292 static void release_all_calls(void)
1293 {
1294         struct chan_call *call;
1295
1296 again:
1297         call = call_first;
1298         while(call) {
1299                 /* no ast, so we may directly free call */
1300                 if (!call->ast) {
1301                         CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1302                         free_call(call);
1303                         goto again;
1304                 }
1305                 /* already in release process */
1306                 if (call->state == CHAN_LCR_STATE_RELEASE) {
1307                         call = call->next;
1308                         continue;
1309                 }
1310                 /* release or queue release */
1311                 call->ref = 0;
1312                 call->state = CHAN_LCR_STATE_RELEASE;
1313                 if (!call->pbx_started) {
1314                         CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1315                         ast_hangup(call->ast); // call will be destroyed here
1316                         goto again;
1317                 }
1318                 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1319                 strcpy(call->queue_string, "H");
1320                 call = call->next;
1321         }
1322
1323         /* release all bchannels */
1324         while(bchannel_first)
1325                 free_bchannel(bchannel_first);
1326 }
1327
1328
1329 /* asterisk handler
1330  * warning! not thread safe
1331  * returns -1 for socket error, 0 for no work, 1 for work
1332  */
1333 int handle_socket(void)
1334 {
1335         int work = 0;
1336         int len;
1337         struct admin_list *admin;
1338         struct admin_message msg;
1339
1340         /* read from socket */
1341         len = read(lcr_sock, &msg, sizeof(msg));
1342         if (len == 0)
1343         {
1344                 CERROR(NULL, NULL, "Socket closed.\n");
1345                 return(-1); // socket closed
1346         }
1347         if (len > 0)
1348         {
1349                 if (len != sizeof(msg))
1350                 {
1351                         CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1352                         return(-1); // socket error
1353                 }
1354                 if (msg.message != ADMIN_MESSAGE)
1355                 {
1356                         CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1357                         return(-1);
1358                 }
1359                 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1360                 work = 1;
1361         } else
1362         {
1363                 if (errno != EWOULDBLOCK)
1364                 {
1365                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1366                         return(-1);
1367                 }
1368         }
1369
1370         /* write to socket */
1371         if (!admin_first)
1372                 return(work);
1373         admin = admin_first;
1374         len = write(lcr_sock, &admin->msg, sizeof(msg));
1375         if (len == 0)
1376         {
1377                 CERROR(NULL, NULL, "Socket closed.\n");
1378                 return(-1); // socket closed
1379         }
1380         if (len > 0)
1381         {
1382                 if (len != sizeof(msg))
1383                 {
1384                         CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1385                         return(-1); // socket error
1386                 }
1387                 /* free head */
1388                 admin_first = admin->next;
1389                 free(admin);
1390
1391                 work = 1;
1392         } else
1393         {
1394                 if (errno != EWOULDBLOCK)
1395                 {
1396                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1397                         return(-1);
1398                 }
1399         }
1400
1401         return(work);
1402 }
1403
1404 /*
1405  * open and close socket and thread
1406  */
1407 int open_socket(void)
1408 {
1409         int ret;
1410         int conn;
1411         struct sockaddr_un sock_address;
1412         unsigned int on = 1;
1413         union parameter param;
1414
1415         /* open socket */
1416         if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1417         {
1418                 CERROR(NULL, NULL, "Failed to create socket.\n");
1419                 return(lcr_sock);
1420         }
1421
1422         /* set socket address and name */
1423         memset(&sock_address, 0, sizeof(sock_address));
1424         sock_address.sun_family = PF_UNIX;
1425         sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1426
1427         /* connect socket */
1428         if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0)
1429         {
1430                 close(lcr_sock);
1431                 lcr_sock = -1;
1432                 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1433                 return(conn);
1434         }
1435
1436         /* set non-blocking io */
1437         if ((ret = ioctl(lcr_sock, FIONBIO, (unsigned char *)(&on))) < 0)
1438         {
1439                 close(lcr_sock);
1440                 lcr_sock = -1;
1441                 CERROR(NULL, NULL, "Failed to set socket into non-blocking IO.\n");
1442                 return(ret);
1443         }
1444
1445         /* enque hello message */
1446         memset(&param, 0, sizeof(param));
1447         strcpy(param.hello.application, "asterisk");
1448         send_message(MESSAGE_HELLO, 0, &param);
1449
1450         return(lcr_sock);
1451 }
1452
1453 void close_socket(void)
1454 {
1455         struct admin_list *admin, *temp;
1456
1457         /* flush pending messages */
1458         admin = admin_first;
1459         while(admin) {
1460                 temp = admin;
1461                 admin = admin->next;
1462                 free(temp);
1463         }
1464         admin_first = NULL;
1465
1466         /* close socket */
1467         if (lcr_sock >= 0)
1468                 close(lcr_sock);
1469         lcr_sock = -1;
1470 }
1471
1472
1473 /* sending queue to asterisk */
1474 static int queue_send(void)
1475 {
1476         int work = 0;
1477         struct chan_call *call;
1478         struct ast_channel *ast;
1479         struct ast_frame fr;
1480         char *p;
1481
1482         call = call_first;
1483         while(call) {
1484                 p = call->queue_string;
1485                 ast = call->ast;
1486                 if (*p && ast) {
1487                         /* there is something to queue */
1488                         if (!ast_channel_trylock(ast)) { /* succeed */
1489                                 while(*p) {
1490                                         switch (*p) {
1491                                         case 'P':
1492                                                 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1493                                                 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1494                                                 break;
1495                                         case 'R':
1496                                                 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1497                                                 ast_queue_control(ast, AST_CONTROL_RINGING);
1498                                                 break;
1499                                         case 'A':
1500                                                 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1501                                                 ast_queue_control(ast, AST_CONTROL_ANSWER);
1502                                                 break;
1503                                         case 'H':
1504                                                 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1505                                                 ast_queue_hangup(ast);
1506                                                 break;
1507                                         case '1': case '2': case '3': case 'a':
1508                                         case '4': case '5': case '6': case 'b':
1509                                         case '7': case '8': case '9': case 'c':
1510                                         case '*': case '0': case '#': case 'd':
1511                                                 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1512                                                 /* send digit to asterisk */
1513                                                 memset(&fr, 0, sizeof(fr));
1514                                                 fr.frametype = AST_FRAME_DTMF_BEGIN;
1515                                                 fr.subclass = *p;
1516                                                 fr.delivery = ast_tv(0, 0);
1517                                                 ast_queue_frame(ast, &fr);
1518                                                 fr.frametype = AST_FRAME_DTMF_END;
1519                                                 ast_queue_frame(ast, &fr);
1520                                                 break;
1521                                         default:
1522                                                 CDEBUG(call, ast, "Ignoring queued digit 0x%02d.\n", *p);
1523                                         }
1524                                         p++;
1525                                 }
1526                                 call->queue_string[0] = '\0';
1527                                 ast_channel_unlock(ast);
1528                                 work = 1;
1529                         }
1530                 }
1531                 call = call->next;
1532         }
1533
1534         return work;
1535 }
1536
1537 /* signal handler */
1538 void sighandler(int sigset)
1539 {
1540 }
1541
1542 /* chan_lcr thread */
1543 static void *chan_thread(void *arg)
1544 {
1545         int work;
1546         int ret;
1547         union parameter param;
1548         time_t retry = 0, now;
1549
1550         bchannel_pid = getpid();
1551
1552 //      signal(SIGPIPE, sighandler);
1553
1554         memset(&param, 0, sizeof(union parameter));
1555         if (lcr_sock < 0)
1556                 time(&retry);
1557
1558         ast_mutex_lock(&chan_lock);
1559
1560         while(!quit) {
1561                 work = 0;
1562
1563                 if (lcr_sock > 0) {
1564                         /* handle socket */
1565                         ret = handle_socket();
1566                         if (ret < 0) {
1567                                 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1568                                 close_socket();
1569                                 release_all_calls();
1570                                 time(&retry);
1571                         }
1572                         if (ret)
1573                                 work = 1;
1574                 } else {
1575                         time(&now);
1576                         if (retry && now-retry > 5) {
1577                                 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1578                                 retry = 0;
1579                                 if (open_socket() < 0) {
1580                                         time(&retry);
1581                                 }
1582                                 work = 1;
1583                         }
1584
1585                 }
1586
1587                 /* handle mISDN */
1588                 ret = bchannel_handle();
1589                 if (ret)
1590                         work = 1;
1591
1592                 /* handle messages to asterisk */
1593                 ret = queue_send();
1594                 if (ret)
1595                         work = 1;
1596
1597                 /* delay if no work done */
1598                 if (!work) {
1599                         ast_mutex_unlock(&chan_lock);
1600                         usleep(30000);
1601                         ast_mutex_lock(&chan_lock);
1602                 }
1603         }
1604
1605         close_socket();
1606
1607         CERROR(NULL, NULL, "Thread exit.\n");
1608
1609         ast_mutex_unlock(&chan_lock);
1610
1611 //      signal(SIGPIPE, SIG_DFL);
1612
1613         return NULL;
1614 }
1615
1616 /*
1617  * new asterisk instance
1618  */
1619 static
1620 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1621 {
1622         char exten[256], *dial, *interface, *opt;
1623         struct ast_channel *ast;
1624         struct chan_call *call;
1625
1626         ast_mutex_lock(&chan_lock);
1627         CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1628
1629         /* if socket is closed */
1630         if (lcr_sock < 0)
1631         {
1632                 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1633                 ast_mutex_unlock(&chan_lock);
1634                 return NULL;
1635         }
1636
1637         /* create call instance */
1638         call = alloc_call();
1639         if (!call)
1640         {
1641                 /* failed to create instance */
1642                 ast_mutex_unlock(&chan_lock);
1643                 return NULL;
1644         }
1645
1646         /* create asterisk channel instrance */
1647         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1648         if (!ast)
1649         {
1650                 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1651                 free_call(call);
1652                 /* failed to create instance */
1653                 ast_mutex_unlock(&chan_lock);
1654                 return NULL;
1655         }
1656         ast->tech = &lcr_tech;
1657         ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1658         /* configure channel */
1659         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1660         ast->readformat = ast->rawreadformat = ast->nativeformats;
1661         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
1662         ast->priority = 1;
1663         ast->hangupcause = 0;
1664
1665         /* link together */
1666         call->ast = ast;
1667         ast->tech_pvt = call;
1668         ast->fds[0] = call->pipe[0];
1669         call->pbx_started = 0;
1670         /* set state */
1671         call->state = CHAN_LCR_STATE_OUT_PREPARE;
1672
1673         /*
1674          * Extract interface, dialstring, options from data.
1675          * Formats can be:
1676          *      <dialstring>
1677          *      <interface>/<dialstring>
1678          *      <interface>/<dialstring>/options
1679          */
1680         strncpy(exten, (char *)data, sizeof(exten)-1);
1681         exten[sizeof(exten)-1] = '\0';
1682         if ((dial = strchr(exten, '/'))) {
1683                 *dial++ = '\0';
1684                 interface = exten;
1685                 if ((opt = strchr(dial, '/')))
1686                         *opt++ = '\0';
1687                 else
1688                         opt = "";
1689         } else {
1690                 dial = exten;
1691                 interface = "";
1692                 opt = "";
1693         }
1694         strncpy(call->interface, interface, sizeof(call->interface)-1);
1695         strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1696         apply_opt(call, (char *)opt);
1697
1698         ast_mutex_unlock(&chan_lock);
1699         return ast;
1700 }
1701
1702 /*
1703  * call from asterisk
1704  */
1705 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1706 {
1707         union parameter newparam;
1708         struct chan_call *call;
1709
1710         ast_mutex_lock(&chan_lock);
1711         call = ast->tech_pvt;
1712         if (!call) {
1713                 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1714                 ast_mutex_unlock(&chan_lock);
1715                 return -1;
1716         }
1717
1718         CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1719
1720         /* pbx process is started */
1721         call->pbx_started = 1;
1722         /* send MESSAGE_NEWREF */
1723         memset(&newparam, 0, sizeof(union parameter));
1724         newparam.direction = 0; /* request from app */
1725         send_message(MESSAGE_NEWREF, 0, &newparam);
1726
1727         /* set hdlc if capability requires hdlc */
1728         if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1729          || ast->transfercapability == INFO_BC_DATARESTRICTED
1730          || ast->transfercapability == INFO_BC_VIDEO)
1731                 call->hdlc = 1;
1732         /* if hdlc is forced by option, we change transcap to data */
1733         if (call->hdlc
1734          && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1735          && ast->transfercapability != INFO_BC_DATARESTRICTED
1736          && ast->transfercapability != INFO_BC_VIDEO)
1737                 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1738
1739         call->cid_num[0] = 0;
1740         call->cid_name[0] = 0;
1741         call->cid_rdnis[0] = 0;
1742
1743         if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1744                 strncpy(call->cid_num, ast->cid.cid_num,
1745                         sizeof(call->cid_num)-1);
1746
1747         if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1748                 strncpy(call->cid_name, ast->cid.cid_name,
1749                         sizeof(call->cid_name)-1);
1750         if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1751                 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1752                         sizeof(call->cid_rdnis)-1);
1753
1754         ast_mutex_unlock(&chan_lock);
1755         return 0;
1756 }
1757
1758 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1759 {
1760         static const char* dtmf_tones[] = {
1761                 "!941+1336/100,!0/100", /* 0 */
1762                 "!697+1209/100,!0/100", /* 1 */
1763                 "!697+1336/100,!0/100", /* 2 */
1764                 "!697+1477/100,!0/100", /* 3 */
1765                 "!770+1209/100,!0/100", /* 4 */
1766                 "!770+1336/100,!0/100", /* 5 */
1767                 "!770+1477/100,!0/100", /* 6 */
1768                 "!852+1209/100,!0/100", /* 7 */
1769                 "!852+1336/100,!0/100", /* 8 */
1770                 "!852+1477/100,!0/100", /* 9 */
1771                 "!697+1633/100,!0/100", /* A */
1772                 "!770+1633/100,!0/100", /* B */
1773                 "!852+1633/100,!0/100", /* C */
1774                 "!941+1633/100,!0/100", /* D */
1775                 "!941+1209/100,!0/100", /* * */
1776                 "!941+1477/100,!0/100" };       /* # */
1777
1778         if (digit >= '0' && digit <='9')
1779                 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1780         else if (digit >= 'A' && digit <= 'D')
1781                 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1782         else if (digit == '*')
1783                 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1784         else if (digit == '#')
1785                 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1786         else {
1787                 /* not handled */
1788                 ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
1789                         "'%c' for '%s'\n", digit, ast->name);
1790         }
1791 }
1792
1793
1794 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1795 {
1796         struct chan_call *call;
1797         union parameter newparam;
1798         char buf[]="x";
1799
1800         /* only pass IA5 number space */
1801         if (digit > 126 || digit < 32)
1802                 return 0;
1803
1804         ast_mutex_lock(&chan_lock);
1805         call = ast->tech_pvt;
1806         if (!call) {
1807                 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
1808                 ast_mutex_unlock(&chan_lock);
1809                 return -1;
1810         }
1811
1812         CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
1813
1814         /* send information or queue them */
1815         if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING)
1816         {
1817                 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
1818                 memset(&newparam, 0, sizeof(union parameter));
1819                 newparam.information.id[0] = digit;
1820                 newparam.information.id[1] = '\0';
1821                 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
1822         } else
1823         if (!call->ref
1824          && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP))
1825         {
1826                 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
1827                 *buf = digit;
1828                 strncat(call->dialque, buf, strlen(call->dialque)-1);
1829         }
1830
1831         ast_mutex_unlock(&chan_lock);
1832         return(0);
1833 }
1834
1835 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
1836 {
1837         int inband_dtmf = 0;
1838         struct chan_call *call;
1839
1840         ast_mutex_lock(&chan_lock);
1841
1842         call = ast->tech_pvt;
1843
1844         if (!call) {
1845                 CERROR(NULL, ast,
1846                        "Received digit from Asterisk, "
1847                        "but no call instance exists.\n");
1848                 ast_mutex_unlock(&chan_lock);
1849                 return -1;
1850         }
1851
1852         CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
1853
1854         if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
1855                 inband_dtmf = 1;
1856         }
1857
1858         ast_mutex_unlock(&chan_lock);
1859
1860         if (inband_dtmf) {
1861                 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
1862                 send_digit_to_chan(ast, digit);
1863         }
1864
1865         return (0);
1866 }
1867
1868 static int lcr_answer(struct ast_channel *ast)
1869 {
1870         union parameter newparam;
1871         struct chan_call *call;
1872
1873         ast_mutex_lock(&chan_lock);
1874         call = ast->tech_pvt;
1875         if (!call) {
1876                 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
1877                 ast_mutex_unlock(&chan_lock);
1878                 return -1;
1879         }
1880
1881         CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
1882
1883         /* copy connectinfo, if bridged */
1884         if (call->bridge_call)
1885                 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
1886         /* send connect message to lcr */
1887         if (call->state != CHAN_LCR_STATE_CONNECT) {
1888                 memset(&newparam, 0, sizeof(union parameter));
1889                 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
1890                 send_message(MESSAGE_CONNECT, call->ref, &newparam);
1891                 call->state = CHAN_LCR_STATE_CONNECT;
1892         }
1893         /* change state */
1894         /* request bchannel */
1895         if (!call->bchannel) {
1896                 CDEBUG(call, ast, "Requesting B-channel.\n");
1897                 memset(&newparam, 0, sizeof(union parameter));
1898                 newparam.bchannel.type = BCHANNEL_REQUEST;
1899                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1900         }
1901         /* enable keypad */
1902 //      memset(&newparam, 0, sizeof(union parameter));
1903 //      send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
1904         /* enable dtmf */
1905         if (call->no_dtmf)
1906                 CDEBUG(call, ast, "DTMF is disabled by option.\n");
1907         else
1908                 call->dtmf = 1;
1909
1910         ast_mutex_unlock(&chan_lock);
1911         return 0;
1912 }
1913
1914 static int lcr_hangup(struct ast_channel *ast)
1915 {
1916         struct chan_call *call;
1917         pthread_t tid = pthread_self();
1918
1919         if (!pthread_equal(tid, chan_tid))
1920                 ast_mutex_lock(&chan_lock);
1921         call = ast->tech_pvt;
1922         if (!call) {
1923                 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
1924                 if (!pthread_equal(tid, chan_tid))
1925                         ast_mutex_unlock(&chan_lock);
1926                 return -1;
1927         }
1928
1929         if (!pthread_equal(tid, chan_tid))
1930                 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
1931         else
1932                 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
1933
1934         /* disconnect asterisk, maybe not required */
1935         ast->tech_pvt = NULL;
1936         ast->fds[0] = -1;
1937         if (call->ref)
1938         {
1939                 /* release */
1940                 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
1941                 if (ast->hangupcause > 0)
1942                         send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
1943                 else
1944                         send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1945                 /* remove call */
1946                 free_call(call);
1947                 if (!pthread_equal(tid, chan_tid))
1948                         ast_mutex_unlock(&chan_lock);
1949                 return 0;
1950         } else
1951         {
1952                 /* ref is not set, due to prepare setup or release */
1953                 if (call->state == CHAN_LCR_STATE_RELEASE)
1954                 {
1955                         /* we get the response to our release */
1956                         CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
1957                         free_call(call);
1958                 } else
1959                 {
1960                         /* during prepare, we change to release state */
1961                         CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
1962                         call->state = CHAN_LCR_STATE_RELEASE;
1963                         call->ast = NULL;
1964                 }
1965         }
1966         if (!pthread_equal(tid, chan_tid))
1967                 ast_mutex_unlock(&chan_lock);
1968         return 0;
1969 }
1970
1971 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
1972 {
1973         struct chan_call *call;
1974
1975         if (!f->subclass)
1976                 CDEBUG(NULL, ast, "No subclass\n");
1977         if (!(f->subclass & ast->nativeformats))
1978                 CDEBUG(NULL, ast, "Unexpected format.\n");
1979
1980         ast_mutex_lock(&chan_lock);
1981         call = ast->tech_pvt;
1982         if (!call) {
1983                 ast_mutex_unlock(&chan_lock);
1984                 return -1;
1985         }
1986         if (call->bchannel && f->samples)
1987                 bchannel_transmit(call->bchannel, f->data, f->samples);
1988         ast_mutex_unlock(&chan_lock);
1989         return 0;
1990 }
1991
1992
1993 static struct ast_frame *lcr_read(struct ast_channel *ast)
1994 {
1995         struct chan_call *call;
1996         int len;
1997
1998         ast_mutex_lock(&chan_lock);
1999         call = ast->tech_pvt;
2000         if (!call) {
2001                 ast_mutex_unlock(&chan_lock);
2002                 return NULL;
2003         }
2004         if (call->pipe[0] > -1) {
2005                 if (call->rebuffer && !call->hdlc) {
2006                         len = read(call->pipe[0], call->read_buff, 160);
2007                 } else {
2008                         len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2009                 }
2010                 if (len < 0 && errno == EAGAIN) {
2011                         ast_mutex_unlock(&chan_lock);
2012                         return &ast_null_frame;
2013                 }
2014                 if (len <= 0) {
2015                         close(call->pipe[0]);
2016                         call->pipe[0] = -1;
2017                         ast_mutex_unlock(&chan_lock);
2018                         return NULL;
2019                 }
2020         }
2021
2022         call->read_fr.frametype = AST_FRAME_VOICE;
2023         call->read_fr.subclass = ast->nativeformats;
2024         call->read_fr.datalen = len;
2025         call->read_fr.samples = len;
2026         call->read_fr.delivery = ast_tv(0,0);
2027         call->read_fr.data = call->read_buff;
2028         ast_mutex_unlock(&chan_lock);
2029
2030         return &call->read_fr;
2031 }
2032
2033 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2034 {
2035         union parameter newparam;
2036         int res = 0;
2037         struct chan_call *call;
2038
2039         ast_mutex_lock(&chan_lock);
2040         call = ast->tech_pvt;
2041         if (!call) {
2042                 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2043                 ast_mutex_unlock(&chan_lock);
2044                 return -1;
2045         }
2046
2047         switch (cond) {
2048                 case AST_CONTROL_BUSY:
2049                         CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2050                         ast_setstate(ast, AST_STATE_BUSY);
2051                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2052                                 /* send message to lcr */
2053                                 memset(&newparam, 0, sizeof(union parameter));
2054                                 newparam.disconnectinfo.cause = 17;
2055                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2056                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2057                                 /* change state */
2058                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2059                         }
2060                         break;
2061                 case AST_CONTROL_CONGESTION:
2062                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2063                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2064                                 /* send message to lcr */
2065                                 memset(&newparam, 0, sizeof(union parameter));
2066                                 newparam.disconnectinfo.cause = ast->hangupcause;
2067                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2068                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2069                                 /* change state */
2070                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2071                         }
2072                         break;
2073                 case AST_CONTROL_PROCEEDING:
2074                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2075                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2076                          || call->state == CHAN_LCR_STATE_IN_DIALING) {
2077                                 /* send message to lcr */
2078                                 memset(&newparam, 0, sizeof(union parameter));
2079                                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2080                                 /* change state */
2081                                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2082                         }
2083                         break;
2084                 case AST_CONTROL_RINGING:
2085                         CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2086                         ast_setstate(ast, AST_STATE_RINGING);
2087                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2088                          || call->state == CHAN_LCR_STATE_IN_DIALING
2089                          || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2090                                 /* send message to lcr */
2091                                 memset(&newparam, 0, sizeof(union parameter));
2092                                 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2093                                 /* change state */
2094                                 call->state = CHAN_LCR_STATE_IN_ALERTING;
2095                         }
2096                         break;
2097                 case -1:
2098                         CDEBUG(call, ast, "Received indicate -1.\n");
2099                         res = -1;
2100                         break;
2101
2102                 case AST_CONTROL_VIDUPDATE:
2103                         CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2104                         res = -1;
2105                         break;
2106                 case AST_CONTROL_HOLD:
2107                         CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2108                         /* send message to lcr */
2109                         memset(&newparam, 0, sizeof(union parameter));
2110                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2111                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2112
2113                         /*start music onhold*/
2114                         ast_moh_start(ast,data,ast->musicclass);
2115                         call->on_hold = 1;
2116                         break;
2117                 case AST_CONTROL_UNHOLD:
2118                         CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2119                         /* send message to lcr */
2120                         memset(&newparam, 0, sizeof(union parameter));
2121                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2122                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2123
2124                         /*stop moh*/
2125                         ast_moh_stop(ast);
2126                         call->on_hold = 0;
2127                         break;
2128 #if ASTERISK_VERSION_NUM >= 10600
2129                 case AST_CONTROL_SRCUPDATE:
2130                         CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2131                         break;
2132 #endif
2133                 default:
2134                         CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2135                         res = -1;
2136                         break;
2137         }
2138
2139         /* return */
2140         ast_mutex_unlock(&chan_lock);
2141         return res;
2142 }
2143
2144 /*
2145  * fixup asterisk
2146  */
2147 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2148 {
2149         struct chan_call *call;
2150
2151         if (!ast) {
2152                 return -1;
2153         }
2154
2155         ast_mutex_lock(&chan_lock);
2156         call = ast->tech_pvt;
2157         if (!call) {
2158                 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2159                 ast_mutex_unlock(&chan_lock);
2160                 return -1;
2161         }
2162
2163         CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2164         call->ast = ast;
2165         ast_mutex_unlock(&chan_lock);
2166         return 0;
2167 }
2168
2169 /*
2170  * send_text asterisk
2171  */
2172 static int lcr_send_text(struct ast_channel *ast, const char *text)
2173 {
2174         struct chan_call *call;
2175         union parameter newparam;
2176
2177         ast_mutex_lock(&chan_lock);
2178         call = ast->tech_pvt;
2179         if (!call) {
2180                 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2181                 ast_mutex_unlock(&chan_lock);
2182                 return -1;
2183         }
2184
2185         CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2186         memset(&newparam, 0, sizeof(union parameter));
2187         strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2188         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2189         ast_mutex_lock(&chan_lock);
2190         return 0;
2191 }
2192
2193 /*
2194  * bridge process
2195  */
2196 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2197                                   struct ast_channel *ast2, int flags,
2198                                   struct ast_frame **fo,
2199                                   struct ast_channel **rc, int timeoutms)
2200
2201 {
2202         struct chan_call        *call1, *call2;
2203         struct ast_channel      *carr[2], *who;
2204         int                     to;
2205         struct ast_frame        *f;
2206         int                     bridge_id;
2207
2208         CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2209
2210         carr[0] = ast1;
2211         carr[1] = ast2;
2212
2213         /* join via dsp (if the channels are currently open) */
2214         ast_mutex_lock(&chan_lock);
2215         call1 = ast1->tech_pvt;
2216         call2 = ast2->tech_pvt;
2217         if (!call1 || !call2) {
2218                 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2219                 ast_mutex_unlock(&chan_lock);
2220                 return AST_BRIDGE_COMPLETE;
2221         }
2222
2223         /* join, if both call instances uses dsp */
2224         if (!call1->nodsp && !call2->nodsp) {
2225                 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2226
2227                 /* get bridge id and join */
2228                 bridge_id = new_bridge_id();
2229
2230                 call1->bridge_id = bridge_id;
2231                 if (call1->bchannel)
2232                         bchannel_join(call1->bchannel, bridge_id);
2233
2234                 call2->bridge_id = bridge_id;
2235                 if (call2->bchannel)
2236                         bchannel_join(call2->bchannel, bridge_id);
2237         } else
2238         if (call1->nodsp && call2->nodsp)
2239                 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2240         else
2241                 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2242         call1->bridge_call = call2;
2243         call2->bridge_call = call1;
2244
2245         if (call1->state == CHAN_LCR_STATE_IN_SETUP
2246          || call1->state == CHAN_LCR_STATE_IN_DIALING
2247          || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2248          || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2249                 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2250                 lcr_answer(ast1);
2251         }
2252         if (call2->state == CHAN_LCR_STATE_IN_SETUP
2253          || call2->state == CHAN_LCR_STATE_IN_DIALING
2254          || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2255          || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2256                 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2257                 lcr_answer(ast2);
2258         }
2259
2260         /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2261            so let's do it for them. Hmpf.
2262         */
2263
2264         if (call1->on_hold) {
2265                 union parameter newparam;
2266
2267                 memset(&newparam, 0, sizeof(union parameter));
2268                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2269                 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2270
2271                 call1->on_hold = 0;
2272         }
2273
2274         if (call2->on_hold) {
2275                 union parameter newparam;
2276
2277                 memset(&newparam, 0, sizeof(union parameter));
2278                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2279                 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2280
2281                 call2->on_hold = 0;
2282         }
2283
2284         ast_mutex_unlock(&chan_lock);
2285
2286         while(1) {
2287                 to = -1;
2288                 who = ast_waitfor_n(carr, 2, &to);
2289
2290                 if (!who) {
2291                         CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2292                         break;
2293                 }
2294                 f = ast_read(who);
2295
2296                 if (!f || f->frametype == AST_FRAME_CONTROL) {
2297                         if (!f)
2298                                 CDEBUG(NULL, NULL, "Got hangup.\n");
2299                         else
2300                                 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2301                         /* got hangup .. */
2302                         *fo=f;
2303                         *rc=who;
2304                         break;
2305                 }
2306
2307                 if ( f->frametype == AST_FRAME_DTMF ) {
2308                         CDEBUG(NULL, NULL, "Got DTMF.\n");
2309                         *fo=f;
2310                         *rc=who;
2311                         break;
2312                 }
2313
2314
2315                 if (who == ast1) {
2316                         ast_write(ast2,f);
2317                 }
2318                 else {
2319                         ast_write(ast1,f);
2320                 }
2321
2322         }
2323
2324         CDEBUG(NULL, NULL, "Releasing bridge.\n");
2325
2326         /* split channels */
2327         ast_mutex_lock(&chan_lock);
2328         call1 = ast1->tech_pvt;
2329         call2 = ast2->tech_pvt;
2330         if (call1 && call1->bridge_id)
2331         {
2332                 call1->bridge_id = 0;
2333                 if (call1->bchannel)
2334                         bchannel_join(call1->bchannel, 0);
2335                 if (call1->bridge_call)
2336                         call1->bridge_call->bridge_call = NULL;
2337         }
2338         if (call2 && call1->bridge_id)
2339         {
2340                 call2->bridge_id = 0;
2341                 if (call2->bchannel)
2342                         bchannel_join(call2->bchannel, 0);
2343                 if (call2->bridge_call)
2344                         call2->bridge_call->bridge_call = NULL;
2345         }
2346         call1->bridge_call = NULL;
2347         call2->bridge_call = NULL;
2348
2349         ast_mutex_unlock(&chan_lock);
2350         return AST_BRIDGE_COMPLETE;
2351 }
2352 static struct ast_channel_tech lcr_tech = {
2353         .type="LCR",
2354         .description="Channel driver for connecting to Linux-Call-Router",
2355         .requester=lcr_request,
2356         .send_digit_begin=lcr_digit_begin,
2357         .send_digit_end=lcr_digit_end,
2358         .call=lcr_call,
2359         .bridge=lcr_bridge,
2360         .hangup=lcr_hangup,
2361         .answer=lcr_answer,
2362         .read=lcr_read,
2363         .write=lcr_write,
2364         .indicate=lcr_indicate,
2365         .fixup=lcr_fixup,
2366         .send_text=lcr_send_text,
2367         .properties=0
2368 };
2369
2370
2371 /*
2372  * cli
2373  */
2374 #if 0
2375 static int lcr_show_lcr (int fd, int argc, char *argv[])
2376 {
2377         return 0;
2378 }
2379
2380 static int lcr_show_calls (int fd, int argc, char *argv[])
2381 {
2382         return 0;
2383 }
2384
2385 static int lcr_reload_routing (int fd, int argc, char *argv[])
2386 {
2387         return 0;
2388 }
2389
2390 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2391 {
2392         return 0;
2393 }
2394
2395 static int lcr_port_block (int fd, int argc, char *argv[])
2396 {
2397         return 0;
2398 }
2399
2400 static int lcr_port_unblock (int fd, int argc, char *argv[])
2401 {
2402         return 0;
2403 }
2404
2405 static int lcr_port_unload (int fd, int argc, char *argv[])
2406 {
2407         return 0;
2408 }
2409
2410 static struct ast_cli_entry cli_show_lcr =
2411 { {"lcr", "show", "lcr", NULL},
2412  lcr_show_lcr,
2413  "Shows current states of LCR core",
2414  "Usage: lcr show lcr\n",
2415 };
2416
2417 static struct ast_cli_entry cli_show_calls =
2418 { {"lcr", "show", "calls", NULL},
2419  lcr_show_calls,
2420  "Shows current calls made by LCR and Asterisk",
2421  "Usage: lcr show calls\n",
2422 };
2423
2424 static struct ast_cli_entry cli_reload_routing =
2425 { {"lcr", "reload", "routing", NULL},
2426  lcr_reload_routing,
2427  "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2428  "Usage: lcr reload routing\n",
2429 };
2430
2431 static struct ast_cli_entry cli_reload_interfaces =
2432 { {"lcr", "reload", "interfaces", NULL},
2433  lcr_reload_interfaces,
2434  "Reloads interfaces conf of LCR",
2435  "Usage: lcr reload interfaces\n",
2436 };
2437
2438 static struct ast_cli_entry cli_port_block =
2439 { {"lcr", "port", "block", NULL},
2440  lcr_port_block,
2441  "Blocks LCR port for further calls",
2442  "Usage: lcr port block \"<port>\"\n",
2443 };
2444
2445 static struct ast_cli_entry cli_port_unblock =
2446 { {"lcr", "port", "unblock", NULL},
2447  lcr_port_unblock,
2448  "Unblocks or loads LCR port, port is opened my mISDN",
2449  "Usage: lcr port unblock \"<port>\"\n",
2450 };
2451
2452 static struct ast_cli_entry cli_port_unload =
2453 { {"lcr", "port", "unload", NULL},
2454  lcr_port_unload,
2455  "Unloads LCR port, port is closes by mISDN",
2456  "Usage: lcr port unload \"<port>\"\n",
2457 };
2458 #endif
2459
2460
2461
2462 static int lcr_config_exec(struct ast_channel *ast, void *data)
2463 {
2464         struct chan_call *call;
2465
2466         ast_mutex_lock(&chan_lock);
2467         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2468         /* find channel */
2469         call = call_first;
2470         while(call) {
2471                 if (call->ast == ast)
2472                         break;
2473                 call = call->next;
2474         }
2475         if (call)
2476                 apply_opt(call, (char *)data);
2477         else
2478                 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2479
2480         ast_mutex_unlock(&chan_lock);
2481         return 0;
2482 }
2483
2484 /*
2485  * module loading and destruction
2486  */
2487 int load_module(void)
2488 {
2489         u_short i;
2490
2491         for (i = 0; i < 256; i++) {
2492                 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2493                              | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2494         }
2495
2496         if (read_options() == 0) {
2497                 CERROR(NULL, NULL, "%s", options_error);
2498                 return AST_MODULE_LOAD_DECLINE;
2499         }
2500
2501         ast_mutex_init(&chan_lock);
2502         ast_mutex_init(&log_lock);
2503
2504         if (open_socket() < 0) {
2505                 /* continue with closed socket */
2506         }
2507
2508         if (bchannel_initialize()) {
2509                 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2510                 close_socket();
2511                 return AST_MODULE_LOAD_DECLINE;
2512         }
2513         mISDN_created = 1;
2514
2515         lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2516         if (ast_channel_register(&lcr_tech)) {
2517                 CERROR(NULL, NULL, "Unable to register channel class\n");
2518                 bchannel_deinitialize();
2519                 close_socket();
2520                 return AST_MODULE_LOAD_DECLINE;
2521         }
2522
2523         ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2524                                  "lcr_config(<opt><optarg>:<opt>:...)\n"
2525                                  "Sets LCR opts. and optargs\n"
2526                                  "\n"
2527                                  "The available options are:\n"
2528                                  "    d - Send display text on called phone, text is the optarg.\n"
2529                                  "    n - Don't detect dtmf tones on called channel.\n"
2530                                  "    h - Force data call (HDLC).\n"
2531                                  "    t - Disable mISDN_dsp features (required for fax application).\n"
2532                                  "    c - Make crypted outgoing call, optarg is keyindex.\n"
2533                                  "    e - Perform echo cancelation on this channel.\n"
2534                                  "        Takes mISDN pipeline option as optarg.\n"
2535                                  "    s - Send Non Inband DTMF as inband.\n"
2536                                  "   vr - rxgain control\n"
2537                                  "   vt - txgain control\n"
2538                                  "        Volume changes at factor 2 ^ optarg.\n"
2539                 );
2540
2541
2542 #if 0
2543         ast_cli_register(&cli_show_lcr);
2544         ast_cli_register(&cli_show_calls);
2545         ast_cli_register(&cli_reload_routing);
2546         ast_cli_register(&cli_reload_interfaces);
2547         ast_cli_register(&cli_port_block);
2548         ast_cli_register(&cli_port_unblock);
2549         ast_cli_register(&cli_port_unload);
2550 #endif
2551
2552         quit = 0;
2553         if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0))
2554         {
2555                 /* failed to create thread */
2556                 bchannel_deinitialize();
2557                 close_socket();
2558                 ast_channel_unregister(&lcr_tech);
2559                 return AST_MODULE_LOAD_DECLINE;
2560         }
2561         return 0;
2562 }
2563
2564 int unload_module(void)
2565 {
2566         /* First, take us out of the channel loop */
2567         CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2568
2569         quit = 1;
2570         pthread_join(chan_tid, NULL);
2571
2572         ast_channel_unregister(&lcr_tech);
2573
2574         ast_unregister_application("lcr_config");
2575
2576
2577         if (mISDN_created) {
2578                 bchannel_deinitialize();
2579                 mISDN_created = 0;
2580         }
2581
2582         if (lcr_sock >= 0) {
2583                 close(lcr_sock);
2584                 lcr_sock = -1;
2585         }
2586
2587         return 0;
2588 }
2589
2590 int reload_module(void)
2591 {
2592 //      reload_config();
2593         return 0;
2594 }
2595
2596
2597 #define AST_MODULE "chan_lcr"
2598
2599 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2600                 .load = load_module,
2601                 .unload = unload_module,
2602                 .reload = reload_module,
2603                );
2604