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