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