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 lock_debug("rx1");
1268                         CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1269                         if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1270                                 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1271                                 return -1;
1272                         }
1273                         /* create bchannel */
1274                         bchannel = alloc_bchannel(param->bchannel.handle);
1275                         if (!bchannel) {
1276                                 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1277                                 return -1;
1278                         }
1279
1280                         /* configure channel */
1281                         bchannel->b_tx_gain = param->bchannel.tx_gain;
1282                         bchannel->b_rx_gain = param->bchannel.rx_gain;
1283                         strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1284                         if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1285                                 bchannel->b_bf_len = param->bchannel.crypt_len;
1286                                 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1287                         }
1288                         bchannel->b_txdata = 0;
1289                         bchannel->b_tx_dejitter = 1;
1290
1291                         /* in case, ref is not set, this bchannel instance must
1292                          * be created until it is removed again by LCR */
1293                         /* link to call */
1294                         call = find_call_ref(ref);
1295                         if (call) {
1296                                 bchannel->call = call;
1297                                 call->bchannel = bchannel;
1298                                 if (call->dsp_dtmf)
1299                                         bchannel_dtmf(bchannel, 1);
1300                                 if (call->bf_len)
1301                                         bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1302                                 if (call->pipeline[0])
1303                                         bchannel_pipeline(bchannel, call->pipeline);
1304                                 if (call->rx_gain)
1305                                         bchannel_gain(bchannel, call->rx_gain, 0);
1306                                 if (call->tx_gain)
1307                                         bchannel_gain(bchannel, call->tx_gain, 1);
1308                                 if (call->bridge_id) {
1309                                         CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1310                                         bchannel_join(bchannel, call->bridge_id);
1311                                 }
1312                                 /* create only, if call exists, othewhise it bchannel is freed below... */
1313                                 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1314                                         bchannel_activate(bchannel, 1);
1315                         }
1316                         /* acknowledge */
1317                         newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1318                         newparam.bchannel.handle = param->bchannel.handle;
1319                         send_message(MESSAGE_BCHANNEL, 0, &newparam);
1320                         /* if call has released before bchannel is assigned */
1321                         if (!call) {
1322                                 newparam.bchannel.type = BCHANNEL_RELEASE;
1323                                 newparam.bchannel.handle = param->bchannel.handle;
1324                                 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1325                         }
1326
1327                         break;
1328
1329                         case BCHANNEL_REMOVE:
1330                         CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1331                         if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1332                                 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1333                                 return -1;
1334                         }
1335                         /* unklink from call and destroy bchannel */
1336                         free_bchannel(bchannel);
1337
1338                         /* acknowledge */
1339                         newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1340                         newparam.bchannel.handle = param->bchannel.handle;
1341                         send_message(MESSAGE_BCHANNEL, 0, &newparam);
1342
1343                         break;
1344
1345                         default:
1346                         CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1347                 }
1348                 return 0;
1349         }
1350
1351         /* handle new ref */
1352         if (message_type == MESSAGE_NEWREF) {
1353                 if (param->direction) {
1354                         /* new ref from lcr */
1355                         CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1356                         if (!ref || find_call_ref(ref)) {
1357                                 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1358                                 return -1;
1359                         }
1360                         /* allocate new call instance */
1361                         call = alloc_call();
1362                         /* new state */
1363                         call->state = CHAN_LCR_STATE_IN_PREPARE;
1364                         /* set ref */
1365                         call->ref = ref;
1366                         call->ref_was_assigned = 1;
1367                         /* set dtmf (default, use option 'n' to disable */
1368                         call->dsp_dtmf = 1;
1369                         /* wait for setup (or release from asterisk) */
1370                 } else {
1371                         /* new ref, as requested from this remote application */
1372                         CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1373                         call = find_call_ref(0);
1374                         if (!call) {
1375                                 /* send release, if ref does not exist */
1376                                 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1377                                 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1378                                 return 0;
1379                         }
1380                         /* store new ref */
1381                         call->ref = ref;
1382                         call->ref_was_assigned = 1;
1383                         /* set dtmf (default, use option 'n' to disable */
1384                         call->dsp_dtmf = 1;
1385                         /* send pending setup info */
1386                         if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1387                                 send_setup_to_lcr(call);
1388                         /* release if asterisk has signed off */
1389                         else if (call->state == CHAN_LCR_STATE_RELEASE) {
1390                                 /* send release */
1391                                 if (call->cause)
1392                                         send_release_and_import(call, call->cause, call->location);
1393                                 else
1394                                         send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1395                                 /* free call */
1396                                 free_call(call);
1397                                 return 0;
1398                         }
1399                 }
1400                 return 0;
1401         }
1402
1403         /* check ref */
1404         if (!ref) {
1405                 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1406                 return -1;
1407         }
1408         call = find_call_ref(ref);
1409         if (!call) {
1410                 /* ignore ref that is not used (anymore) */
1411                 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1412                 return 0;
1413         }
1414
1415         /* handle messages */
1416         switch(message_type) {
1417                 case MESSAGE_SETUP:
1418                 lcr_in_setup(call, message_type, param);
1419                 break;
1420
1421                 case MESSAGE_OVERLAP:
1422                 lcr_in_overlap(call, message_type, param);
1423                 break;
1424
1425                 case MESSAGE_PROCEEDING:
1426                 lcr_in_proceeding(call, message_type, param);
1427                 break;
1428
1429                 case MESSAGE_ALERTING:
1430                 lcr_in_alerting(call, message_type, param);
1431                 break;
1432
1433                 case MESSAGE_CONNECT:
1434                 lcr_in_connect(call, message_type, param);
1435                 break;
1436
1437                 case MESSAGE_DISCONNECT:
1438                 lcr_in_disconnect(call, message_type, param);
1439                 break;
1440
1441                 case MESSAGE_RELEASE:
1442                 lcr_in_release(call, message_type, param);
1443                 break;
1444
1445                 case MESSAGE_INFORMATION:
1446                 lcr_in_information(call, message_type, param);
1447                 break;
1448
1449                 case MESSAGE_NOTIFY:
1450                 lcr_in_notify(call, message_type, param);
1451                 break;
1452
1453                 case MESSAGE_FACILITY:
1454                 lcr_in_facility(call, message_type, param);
1455                 break;
1456
1457                 case MESSAGE_PATTERN: // audio available from LCR
1458                 if (!call->has_pattern)
1459                         lcr_in_pattern(call, message_type, param);
1460                 break;
1461
1462                 case MESSAGE_NOPATTERN: // audio not available from LCR
1463                 break;
1464
1465                 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1466                 call->audiopath = param->audiopath;
1467                 break;
1468
1469                 default:
1470                 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1471                 break;
1472         }
1473         return 0;
1474 }
1475
1476 /*
1477  * release all calls (due to broken socket)
1478  */
1479 static void release_all_calls(void)
1480 {
1481         struct chan_call *call;
1482
1483 again:
1484         call = call_first;
1485         while(call) {
1486                 /* no ast, so we may directly free call */
1487                 if (!call->ast) {
1488                         CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1489                         free_call(call);
1490                         goto again;
1491                 }
1492                 /* already in release process */
1493                 if (call->state == CHAN_LCR_STATE_RELEASE) {
1494                         call = call->next;
1495                         continue;
1496                 }
1497                 /* release or queue release */
1498                 call->ref = 0;
1499                 call->state = CHAN_LCR_STATE_RELEASE;
1500                 if (!call->pbx_started) {
1501                         CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1502                         ast_hangup(call->ast); // call will be destroyed here
1503                         goto again;
1504                 }
1505                 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1506                 if (!wake_global) {
1507                         wake_global = 1;
1508                         char byte = 0;
1509                         write(wake_pipe[1], &byte, 1);
1510                 }
1511                 strcpy(call->queue_string, "H");
1512                 call = call->next;
1513         }
1514
1515         /* release all bchannels */
1516         while(bchannel_first)
1517                 free_bchannel(bchannel_first);
1518 }
1519
1520 void close_socket(void);
1521
1522 /* asterisk handler
1523  * warning! not thread safe
1524  * returns -1 for socket error, 0 for no work, 1 for work
1525  */
1526 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1527 {
1528         int len;
1529         struct admin_list *admin;
1530         struct admin_message msg;
1531
1532         lock_debug("handle+");
1533         if ((what & LCR_FD_READ)) {
1534                 /* read from socket */
1535                 lock_debug("handle1");
1536                 len = read(lcr_sock, &msg, sizeof(msg));
1537                 lock_debug("handle2");
1538                 if (len == 0) {
1539                         CERROR(NULL, NULL, "Socket closed.\n");
1540                         error:
1541                         CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1542                         lock_debug("handle3");
1543                         close_socket();
1544                         lock_debug("handle4");
1545                         release_all_calls();
1546                         lock_debug("handle5");
1547                         schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1548                         lock_debug("handle-");
1549                         return 0;
1550                 }
1551                 if (len > 0) {
1552                         if (len != sizeof(msg)) {
1553                                 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1554                                 goto error;
1555                         }
1556                         if (msg.message != ADMIN_MESSAGE) {
1557                                 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1558                                 goto error;
1559                         }
1560                         lock_debug("handleX");
1561                         receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1562                         lock_debug("handleY");
1563                 } else {
1564                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1565                         goto error;
1566                 }
1567         }
1568
1569         if ((what & LCR_FD_WRITE)) {
1570                 /* write to socket */
1571                 if (!admin_first) {
1572                         socket_fd.when &= ~LCR_FD_WRITE;
1573                         lock_debug("handle-");
1574                         return 0;
1575                 }
1576                 lock_debug("handle6");
1577                 admin = admin_first;
1578                 len = write(lcr_sock, &admin->msg, sizeof(msg));
1579                 lock_debug("handle7");
1580                 if (len == 0) {
1581                         CERROR(NULL, NULL, "Socket closed.\n");
1582                         goto error;
1583                 }
1584                 if (len > 0) {
1585                         if (len != sizeof(msg)) {
1586                                 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1587                                 goto error;
1588                         }
1589                         /* free head */
1590                         lock_debug("handle8");
1591                         admin_first = admin->next;
1592                         free(admin);
1593                         global_change = 1;
1594                 } else {
1595                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1596                         goto error;
1597                 }
1598         }
1599
1600         lock_debug("handle-");
1601         return 0;
1602 }
1603
1604 /*
1605  * open and close socket and thread
1606  */
1607 int open_socket(void)
1608 {
1609         int conn;
1610         struct sockaddr_un sock_address;
1611         union parameter param;
1612
1613         /* open socket */
1614         if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1615                 CERROR(NULL, NULL, "Failed to create socket.\n");
1616                 return lcr_sock;
1617         }
1618
1619         /* set socket address and name */
1620         memset(&sock_address, 0, sizeof(sock_address));
1621         sock_address.sun_family = PF_UNIX;
1622         sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1623
1624         /* connect socket */
1625         if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1626                 close(lcr_sock);
1627                 lcr_sock = -1;
1628                 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1629                 return conn;
1630         }
1631
1632         /* register socket fd */
1633         memset(&socket_fd, 0, sizeof(socket_fd));
1634         socket_fd.fd = lcr_sock;
1635         register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1636
1637         /* enque hello message */
1638         memset(&param, 0, sizeof(param));
1639         strcpy(param.hello.application, "asterisk");
1640         send_message(MESSAGE_HELLO, 0, &param);
1641
1642         return lcr_sock;
1643 }
1644
1645 void close_socket(void)
1646 {
1647         struct admin_list *admin, *temp;
1648
1649         unregister_fd(&socket_fd);
1650
1651         /* flush pending messages */
1652         admin = admin_first;
1653         while(admin) {
1654                 temp = admin;
1655                 admin = admin->next;
1656                 free(temp);
1657         }
1658         admin_first = NULL;
1659
1660         /* close socket */
1661         if (lcr_sock >= 0)
1662                 close(lcr_sock);
1663         lcr_sock = -1;
1664         global_change = 1;
1665 }
1666
1667
1668 /* sending queue to asterisk */
1669 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1670 {
1671         char byte;
1672
1673         lock_debug("wake+");
1674         read(wake_pipe[0], &byte, 1);
1675
1676         wake_global = 0;
1677         lock_debug("wake-");
1678
1679         return 0;
1680 }
1681
1682 static void handle_queue()
1683 {
1684         struct chan_call *call;
1685         struct ast_channel *ast;
1686         struct ast_frame fr;
1687         char *p;
1688
1689         call = call_first;
1690         while(call) {
1691                 p = call->queue_string;
1692                 ast = call->ast;
1693                 if (*p && ast) {
1694                         lock_debug("A1+");
1695 //                      ast_channel_lock(ast);
1696                         lock_debug("A1-");
1697                         while(*p) {
1698                                 switch (*p) {
1699                                 case 'T':
1700                                         CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1701                                         ast_queue_control(ast, AST_CONTROL_PROGRESS);
1702                                         break;
1703                                 case 'P':
1704                                         CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1705                                         ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1706                                         break;
1707                                 case 'R':
1708                                         CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1709                                         ast_queue_control(ast, AST_CONTROL_RINGING);
1710                                         ast_setstate(ast, AST_STATE_RINGING);
1711                                         break;
1712                                 case 'N':
1713                                         CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1714                                         ast_queue_control(ast, AST_CONTROL_ANSWER);
1715                                         break;
1716                                 case 'H':
1717                                         CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1718                                         ast_queue_hangup(ast);
1719                                         break;
1720                                 case '1': case '2': case '3': case 'A':
1721                                 case '4': case '5': case '6': case 'B':
1722                                 case '7': case '8': case '9': case 'C':
1723                                 case '*': case '0': case '#': case 'D':
1724                                         CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1725                                         /* send digit to asterisk */
1726                                         memset(&fr, 0, sizeof(fr));
1727
1728                                         #ifdef LCR_FOR_ASTERISK
1729                                         fr.frametype = AST_FRAME_DTMF_BEGIN;
1730                                         #endif
1731
1732                                         #ifdef LCR_FOR_CALLWEAVER
1733                                         fr.frametype = AST_FRAME_DTMF;
1734                                         #endif
1735
1736                                         fr.subclass = *p;
1737                                         fr.delivery = ast_tv(0, 0);
1738                                         ast_queue_frame(ast, &fr);
1739
1740                                         #ifdef LCR_FOR_ASTERISK
1741                                         fr.frametype = AST_FRAME_DTMF_END;
1742                                         ast_queue_frame(ast, &fr);
1743                                         #endif
1744
1745                                         break;
1746                                 default:
1747                                         CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1748                                 }
1749                                 p++;
1750                         }
1751                         call->queue_string[0] = '\0';
1752 //                      ast_channel_unlock(ast);
1753                         lock_debug("a1");
1754                 }
1755                 call = call->next;
1756         }
1757 }
1758
1759 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1760 {
1761         CDEBUG(NULL, NULL, "Retry to open socket.\n");
1762         if (open_socket() < 0)
1763                 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1764
1765         return 0;
1766 }
1767
1768 void lock_chan(void)
1769 {
1770         lock_debug("C+");
1771         ast_mutex_lock(&chan_lock);
1772         lock_debug("C-");
1773 }
1774
1775 void unlock_chan(void)
1776 {
1777         ast_mutex_unlock(&chan_lock);
1778         lock_debug("c");
1779 }
1780
1781 /* chan_lcr thread */
1782 static void *chan_thread(void *arg)
1783 {
1784         if (pipe(wake_pipe) < 0) {
1785                 CERROR(NULL, NULL, "Failed to open pipe.\n");
1786                 return NULL;
1787         }
1788         memset(&wake_fd, 0, sizeof(wake_fd));
1789         wake_fd.fd = wake_pipe[0];
1790         register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1791
1792         memset(&socket_retry, 0, sizeof(socket_retry));
1793         add_timer(&socket_retry, handle_retry, NULL, 0);
1794
1795         bchannel_pid = getpid();
1796
1797         /* open socket the first time */
1798         handle_retry(NULL, NULL, 0);
1799
1800         lock_debug("A2+");
1801         ast_mutex_lock(&chan_lock);
1802         lock_debug("A2-");
1803
1804         while(!quit) {
1805                 handle_queue();
1806                 select_main(0, &global_change, lock_chan, unlock_chan);
1807         }
1808
1809         close_socket();
1810
1811         del_timer(&socket_retry);
1812
1813         unregister_fd(&wake_fd);
1814         close(wake_pipe[0]);
1815         close(wake_pipe[1]);
1816
1817         CERROR(NULL, NULL, "Thread exit.\n");
1818
1819         ast_mutex_unlock(&chan_lock);
1820         lock_debug("a2");
1821
1822         return NULL;
1823 }
1824
1825 /*
1826  * new asterisk instance
1827  */
1828 static
1829 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1830 {
1831         char exten[256], *dial, *interface, *opt;
1832         struct ast_channel *ast;
1833         struct chan_call *call;
1834
1835         lock_debug("A3+");
1836         ast_mutex_lock(&chan_lock);
1837         lock_debug("A3-");
1838         CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1839
1840         /* if socket is closed */
1841         if (lcr_sock < 0) {
1842                 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1843                 ast_mutex_unlock(&chan_lock);
1844                 lock_debug("a3");
1845                 return NULL;
1846         }
1847
1848         /* create call instance */
1849         call = alloc_call();
1850         if (!call) {
1851                 /* failed to create instance */
1852                 ast_mutex_unlock(&chan_lock);
1853                 lock_debug("a3");
1854                 return NULL;
1855         }
1856
1857         /* create asterisk channel instrance */
1858
1859         #ifdef LCR_FOR_ASTERISK
1860         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1861         #endif
1862
1863         #ifdef LCR_FOR_CALLWEAVER
1864         ast = ast_channel_alloc(1);
1865         #endif
1866
1867         if (!ast) {
1868                 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1869                 free_call(call);
1870                 /* failed to create instance */
1871                 ast_mutex_unlock(&chan_lock);
1872                 lock_debug("a3");
1873                 return NULL;
1874         }
1875         ast->tech = &lcr_tech;
1876         ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1877         /* configure channel */
1878         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1879         ast->readformat = ast->rawreadformat = ast->nativeformats;
1880         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
1881         ast->priority = 1;
1882         ast->hangupcause = 0;
1883
1884         /* link together */
1885         call->ast = ast;
1886         ast->tech_pvt = call;
1887         ast->fds[0] = call->pipe[0];
1888         call->pbx_started = 0;
1889         /* set state */
1890         call->state = CHAN_LCR_STATE_OUT_PREPARE;
1891
1892         /*
1893          * Extract interface, dialstring, options from data.
1894          * Formats can be:
1895          *      <dialstring>
1896          *      <interface>/<dialstring>
1897          *      <interface>/<dialstring>/options
1898          */
1899         strncpy(exten, (char *)data, sizeof(exten)-1);
1900         exten[sizeof(exten)-1] = '\0';
1901         if ((dial = strchr(exten, '/'))) {
1902                 *dial++ = '\0';
1903                 interface = exten;
1904                 if ((opt = strchr(dial, '/')))
1905                         *opt++ = '\0';
1906                 else
1907                         opt = "";
1908         } else {
1909                 dial = exten;
1910                 interface = "";
1911                 opt = "";
1912         }
1913         strncpy(call->interface, interface, sizeof(call->interface)-1);
1914         strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1915         apply_opt(call, (char *)opt);
1916
1917         ast_mutex_unlock(&chan_lock);
1918         lock_debug("a3");
1919         return ast;
1920 }
1921
1922 /*
1923  * call from asterisk
1924  */
1925 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1926 {
1927         union parameter newparam;
1928         struct chan_call *call;
1929
1930         lock_debug("A4+");
1931         ast_mutex_lock(&chan_lock);
1932         lock_debug("A4-");
1933         call = ast->tech_pvt;
1934
1935         #ifdef LCR_FOR_CALLWEAVER
1936         ast->type = "LCR";
1937         snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1938         #endif
1939
1940         if (!call) {
1941                 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1942                 ast_mutex_unlock(&chan_lock);
1943                 lock_debug("a4");
1944                 return -1;
1945         }
1946
1947         CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1948
1949         /* pbx process is started */
1950         call->pbx_started = 1;
1951         /* send MESSAGE_NEWREF */
1952         memset(&newparam, 0, sizeof(union parameter));
1953         newparam.direction = 0; /* request from app */
1954         send_message(MESSAGE_NEWREF, 0, &newparam);
1955
1956         /* set hdlc if capability requires hdlc */
1957         if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1958          || ast->transfercapability == INFO_BC_DATARESTRICTED
1959          || ast->transfercapability == INFO_BC_VIDEO)
1960                 call->hdlc = 1;
1961         /* if hdlc is forced by option, we change transcap to data */
1962         if (call->hdlc
1963          && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1964          && ast->transfercapability != INFO_BC_DATARESTRICTED
1965          && ast->transfercapability != INFO_BC_VIDEO)
1966                 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1967
1968         call->cid_num[0] = 0;
1969         call->cid_name[0] = 0;
1970         call->cid_rdnis[0] = 0;
1971
1972         if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1973                 strncpy(call->cid_num, ast->cid.cid_num,
1974                         sizeof(call->cid_num)-1);
1975
1976         if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1977                 strncpy(call->cid_name, ast->cid.cid_name,
1978                         sizeof(call->cid_name)-1);
1979         if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1980                 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1981                         sizeof(call->cid_rdnis)-1);
1982
1983         ast_mutex_unlock(&chan_lock);
1984         lock_debug("a4");
1985         return 0;
1986 }
1987
1988 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1989 {
1990         static const char* dtmf_tones[] = {
1991                 "!941+1336/100,!0/100", /* 0 */
1992                 "!697+1209/100,!0/100", /* 1 */
1993                 "!697+1336/100,!0/100", /* 2 */
1994                 "!697+1477/100,!0/100", /* 3 */
1995                 "!770+1209/100,!0/100", /* 4 */
1996                 "!770+1336/100,!0/100", /* 5 */
1997                 "!770+1477/100,!0/100", /* 6 */
1998                 "!852+1209/100,!0/100", /* 7 */
1999                 "!852+1336/100,!0/100", /* 8 */
2000                 "!852+1477/100,!0/100", /* 9 */
2001                 "!697+1633/100,!0/100", /* A */
2002                 "!770+1633/100,!0/100", /* B */
2003                 "!852+1633/100,!0/100", /* C */
2004                 "!941+1633/100,!0/100", /* D */
2005                 "!941+1209/100,!0/100", /* * */
2006                 "!941+1477/100,!0/100" };       /* # */
2007
2008         if (digit >= '0' && digit <='9')
2009                 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2010         else if (digit >= 'A' && digit <= 'D')
2011                 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2012         else if (digit == '*')
2013                 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2014         else if (digit == '#')
2015                 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2016         else {
2017                 /* not handled */
2018                 ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
2019                         "'%c' for '%s'\n", digit, ast->name);
2020         }
2021 }
2022
2023 #ifdef LCR_FOR_ASTERISK
2024 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2025 #endif
2026 #ifdef LCR_FOR_CALLWEAVER
2027 static int lcr_digit(struct ast_channel *ast, char digit)
2028 #endif
2029 {
2030         struct chan_call *call;
2031         union parameter newparam;
2032         char buf[]="x";
2033
2034 #ifdef LCR_FOR_CALLWEAVER
2035         int inband_dtmf = 0;
2036 #endif
2037
2038         /* only pass IA5 number space */
2039         if (digit > 126 || digit < 32)
2040                 return 0;
2041
2042         lock_debug("A5+");
2043         ast_mutex_lock(&chan_lock);
2044         lock_debug("A5-");
2045         call = ast->tech_pvt;
2046         if (!call) {
2047                 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2048                 ast_mutex_unlock(&chan_lock);
2049                 lock_debug("a5");
2050                 return -1;
2051         }
2052
2053         CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2054
2055         /* send information or queue them */
2056         if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2057                 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2058                 memset(&newparam, 0, sizeof(union parameter));
2059                 if (call->keypad) {
2060                         newparam.information.keypad[0] = digit;
2061                         newparam.information.keypad[1] = '\0';
2062                 } else {
2063                         newparam.information.id[0] = digit;
2064                         newparam.information.id[1] = '\0';
2065                 }
2066                 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2067         } else
2068         if (!call->ref
2069          && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2070                 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2071                 *buf = digit;
2072                 strncat(call->dialque, buf, strlen(call->dialque)-1);
2073         }
2074
2075         ast_mutex_unlock(&chan_lock);
2076         lock_debug("a5");
2077
2078 #ifdef LCR_FOR_ASTERISK
2079         return 0;
2080 }
2081
2082 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2083 {
2084         int inband_dtmf = 0;
2085         struct chan_call *call;
2086 #endif
2087
2088         lock_debug("A6+");
2089         ast_mutex_lock(&chan_lock);
2090         lock_debug("A6-");
2091
2092         call = ast->tech_pvt;
2093
2094         if (!call) {
2095                 CERROR(NULL, ast,
2096                        "Received digit from Asterisk, "
2097                        "but no call instance exists.\n");
2098                 ast_mutex_unlock(&chan_lock);
2099                 lock_debug("a6");
2100                 return -1;
2101         }
2102
2103         CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2104
2105         if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2106                 inband_dtmf = 1;
2107         }
2108
2109         ast_mutex_unlock(&chan_lock);
2110         lock_debug("a6");
2111
2112         if (inband_dtmf) {
2113                 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2114                 send_digit_to_chan(ast, digit);
2115         }
2116
2117         return 0;
2118 }
2119
2120 static int lcr_answer(struct ast_channel *ast)
2121 {
2122         union parameter newparam;
2123         struct chan_call *call;
2124
2125         lock_debug("A7+");
2126         ast_mutex_lock(&chan_lock);
2127         lock_debug("A7-");
2128         call = ast->tech_pvt;
2129         if (!call) {
2130                 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2131                 ast_mutex_unlock(&chan_lock);
2132                 lock_debug("a7");
2133                 return -1;
2134         }
2135
2136         CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2137
2138         /* copy connectinfo, if bridged */
2139         if (call->bridge_call)
2140                 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2141         /* send connect message to lcr */
2142         if (call->state != CHAN_LCR_STATE_CONNECT) {
2143                 memset(&newparam, 0, sizeof(union parameter));
2144                 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2145                 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2146                 call->state = CHAN_LCR_STATE_CONNECT;
2147         }
2148         /* change state */
2149         /* request bchannel */
2150         if (!call->bchannel) {
2151                 CDEBUG(call, ast, "Requesting B-channel.\n");
2152                 memset(&newparam, 0, sizeof(union parameter));
2153                 newparam.bchannel.type = BCHANNEL_REQUEST;
2154                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2155         }
2156         /* enable keypad */
2157 //      memset(&newparam, 0, sizeof(union parameter));
2158 //      send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2159
2160         ast_mutex_unlock(&chan_lock);
2161         lock_debug("a7");
2162         return 0;
2163 }
2164
2165 static int lcr_hangup(struct ast_channel *ast)
2166 {
2167         struct chan_call *call;
2168         pthread_t tid = pthread_self();
2169
2170         if (!pthread_equal(tid, chan_tid)) {
2171                 lock_debug("H+");
2172                 ast_mutex_lock(&chan_lock);
2173                 lock_debug("H-");
2174         }
2175         call = ast->tech_pvt;
2176         if (!call) {
2177                 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2178                 if (!pthread_equal(tid, chan_tid)) {
2179                         ast_mutex_unlock(&chan_lock);
2180                         lock_debug("h");
2181                 }
2182                 return -1;
2183         }
2184
2185         if (!pthread_equal(tid, chan_tid))
2186                 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2187         else
2188                 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2189
2190         /* disconnect asterisk, maybe not required */
2191         ast->tech_pvt = NULL;
2192         ast->fds[0] = -1;
2193         if (call->ref) {
2194                 /* release */
2195                 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2196                 if (ast->hangupcause > 0)
2197                         send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2198                 else
2199                         send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2200                 /* remove call */
2201                 free_call(call);
2202                 if (!pthread_equal(tid, chan_tid)) {
2203                         ast_mutex_unlock(&chan_lock);
2204                         lock_debug("h");
2205                 }
2206                 return 0;
2207         } else {
2208                 /* ref is not set, due to prepare setup or release */
2209                 if (call->state == CHAN_LCR_STATE_RELEASE) {
2210                         /* we get the response to our release */
2211                         CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2212                         free_call(call);
2213                 } else {
2214                         /* during prepare, we change to release state */
2215                         CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2216                         call->state = CHAN_LCR_STATE_RELEASE;
2217                         call->ast = NULL;
2218                 }
2219         }
2220         if (!pthread_equal(tid, chan_tid)) {
2221                 ast_mutex_unlock(&chan_lock);
2222                 lock_debug("h");
2223         }
2224         return 0;
2225 }
2226
2227 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2228 {
2229         struct chan_call *call;
2230
2231         if (!f->subclass)
2232                 CDEBUG(NULL, ast, "No subclass\n");
2233         if (!(f->subclass & ast->nativeformats))
2234                 CDEBUG(NULL, ast, "Unexpected format.\n");
2235
2236         lock_debug("A8+");
2237         ast_mutex_lock(&chan_lock);
2238         lock_debug("A8-");
2239         call = ast->tech_pvt;
2240         if (!call) {
2241                 ast_mutex_unlock(&chan_lock);
2242                 lock_debug("a8");
2243                 return -1;
2244         }
2245         if (call->bchannel && f->samples)
2246                 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2247         ast_mutex_unlock(&chan_lock);
2248         lock_debug("a8");
2249         return 0;
2250 }
2251
2252
2253 static struct ast_frame *lcr_read(struct ast_channel *ast)
2254 {
2255         struct chan_call *call;
2256         int len;
2257
2258         lock_debug("A9+");
2259         ast_mutex_lock(&chan_lock);
2260         lock_debug("A9-");
2261         call = ast->tech_pvt;
2262         if (!call) {
2263                 ast_mutex_unlock(&chan_lock);
2264                 lock_debug("a9");
2265                 return NULL;
2266         }
2267         if (call->pipe[0] > -1) {
2268                 if (call->rebuffer && !call->hdlc) {
2269                         /* Make sure we have a complete 20ms (160byte) frame */
2270                         lock_debug("*1");
2271                         len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2272                         if (len > 0) {
2273                                 call->framepos += len;
2274                         }
2275                 } else {
2276                         lock_debug("*2");
2277                         len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2278                 }
2279                 lock_debug("*3");
2280                 if (len < 0 && errno == EAGAIN) {
2281                         ast_mutex_unlock(&chan_lock);
2282                         lock_debug("a9");
2283
2284                         #ifdef LCR_FOR_ASTERISK
2285                         return &ast_null_frame;
2286                         #endif
2287
2288                         #ifdef LCR_FOR_CALLWEAVER
2289                         return &nullframe;
2290                         #endif
2291
2292                 }
2293                 if (len <= 0) {
2294                         close(call->pipe[0]);
2295                         call->pipe[0] = -1;
2296                         global_change = 1;
2297                         ast_mutex_unlock(&chan_lock);
2298                         lock_debug("a9");
2299                         return NULL;
2300                 } else if (call->rebuffer && call->framepos < 160) {
2301                         /* Not a complete frame, so we send a null-frame */
2302                         ast_mutex_unlock(&chan_lock);
2303                         lock_debug("a9");
2304                         return &ast_null_frame;
2305                 }
2306         }
2307
2308         call->read_fr.frametype = AST_FRAME_VOICE;
2309         call->read_fr.subclass = ast->nativeformats;
2310         if (call->rebuffer) {
2311                 call->read_fr.datalen = call->framepos;
2312                 call->read_fr.samples = call->framepos;
2313                 call->framepos = 0;
2314         } else {
2315                 call->read_fr.datalen = len;
2316                 call->read_fr.samples = len;
2317         }
2318         call->read_fr.delivery = ast_tv(0,0);
2319         *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2320         ast_mutex_unlock(&chan_lock);
2321         lock_debug("a9");
2322
2323         return &call->read_fr;
2324 }
2325
2326 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2327 {
2328         union parameter newparam;
2329         int res = 0;
2330         struct chan_call *call;
2331         const struct tone_zone_sound *ts = NULL;
2332
2333         lock_debug("A0+");
2334         ast_mutex_lock(&chan_lock);
2335         lock_debug("A0-");
2336         call = ast->tech_pvt;
2337         if (!call) {
2338                 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2339                 ast_mutex_unlock(&chan_lock);
2340                 lock_debug("a0");
2341                 return -1;
2342         }
2343
2344         switch (cond) {
2345                 case AST_CONTROL_BUSY:
2346                         CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2347                         ast_setstate(ast, AST_STATE_BUSY);
2348                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2349                                 /* send message to lcr */
2350                                 memset(&newparam, 0, sizeof(union parameter));
2351                                 newparam.disconnectinfo.cause = 17;
2352                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2353                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2354                                 /* change state */
2355                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2356                         } else {
2357                                 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2358                                 ts = ast_get_indication_tone(ast->zone, "busy");
2359                         }
2360                         break;
2361                 case AST_CONTROL_CONGESTION:
2362                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2363                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2364                                 /* send message to lcr */
2365                                 memset(&newparam, 0, sizeof(union parameter));
2366                                 newparam.disconnectinfo.cause = ast->hangupcause;
2367                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2368                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2369                                 /* change state */
2370                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2371                         } else {
2372                                 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2373                                 ts = ast_get_indication_tone(ast->zone, "congestion");
2374                         }
2375                         break;
2376                 case AST_CONTROL_PROCEEDING:
2377                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2378                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2379                          || call->state == CHAN_LCR_STATE_IN_DIALING) {
2380                                 /* send message to lcr */
2381                                 memset(&newparam, 0, sizeof(union parameter));
2382                                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2383                                 /* change state */
2384                                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2385                         }
2386                         break;
2387                 case AST_CONTROL_RINGING:
2388                         CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2389                         ast_setstate(ast, AST_STATE_RING);
2390                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2391                          || call->state == CHAN_LCR_STATE_IN_DIALING
2392                          || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2393                                 /* send message to lcr */
2394                                 memset(&newparam, 0, sizeof(union parameter));
2395                                 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2396                                 /* change state */
2397                                 call->state = CHAN_LCR_STATE_IN_ALERTING;
2398                         } else {
2399                                 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2400                                 ts = ast_get_indication_tone(ast->zone, "ring");
2401                         }
2402                         break;
2403                 case AST_CONTROL_PROGRESS:
2404                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2405                         /* request bchannel */
2406                         if (!call->bchannel) {
2407                                 CDEBUG(call, ast, "Requesting B-channel.\n");
2408                                 memset(&newparam, 0, sizeof(union parameter));
2409                                 newparam.bchannel.type = BCHANNEL_REQUEST;
2410                                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2411                         }
2412                         break;
2413                 case -1:
2414                         CDEBUG(call, ast, "Received indicate -1.\n");
2415                         ast_playtones_stop(ast);
2416                         res = -1;
2417                         break;
2418
2419                 case AST_CONTROL_VIDUPDATE:
2420                         CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2421                         res = -1;
2422                         break;
2423                 case AST_CONTROL_HOLD:
2424                         CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2425                         /* send message to lcr */
2426                         memset(&newparam, 0, sizeof(union parameter));
2427                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2428                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2429
2430                         /*start music onhold*/
2431                         #ifdef LCR_FOR_ASTERISK
2432                         ast_moh_start(ast,data,ast->musicclass);
2433                         #endif
2434
2435                         #ifdef LCR_FOR_CALLWEAVER
2436                         ast_moh_start(ast, NULL);
2437                         #endif
2438
2439                         call->on_hold = 1;
2440                         break;
2441                 case AST_CONTROL_UNHOLD:
2442                         CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2443                         /* send message to lcr */
2444                         memset(&newparam, 0, sizeof(union parameter));
2445                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2446                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2447
2448                         /*stop moh*/
2449                         ast_moh_stop(ast);
2450                         call->on_hold = 0;
2451                         break;
2452 #ifdef AST_CONTROL_SRCUPDATE
2453                 case AST_CONTROL_SRCUPDATE:
2454 #else
2455                 case 20:
2456 #endif
2457                         CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2458                         break;
2459                 default:
2460                         CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2461                         res = -1;
2462                         break;
2463         }
2464
2465         if (ts && ts->data[0]) {
2466                 ast_playtones_start(ast, 0, ts->data, 1);
2467         }
2468
2469         /* return */
2470         ast_mutex_unlock(&chan_lock);
2471         lock_debug("a0");
2472         return res;
2473 }
2474
2475 /*
2476  * fixup asterisk
2477  */
2478 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2479 {
2480         struct chan_call *call;
2481
2482         if (!ast) {
2483                 return -1;
2484         }
2485
2486         lock_debug("Af+");
2487         ast_mutex_lock(&chan_lock);
2488         lock_debug("Af-");
2489         call = ast->tech_pvt;
2490         if (!call) {
2491                 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2492                 ast_mutex_unlock(&chan_lock);
2493                 lock_debug("af");
2494                 return -1;
2495         }
2496
2497         CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2498         call->ast = ast;
2499         ast_mutex_unlock(&chan_lock);
2500         lock_debug("af");
2501         return 0;
2502 }
2503
2504 /*
2505  * send_text asterisk
2506  */
2507 static int lcr_send_text(struct ast_channel *ast, const char *text)
2508 {
2509         struct chan_call *call;
2510         union parameter newparam;
2511
2512         lock_debug("At+");
2513         ast_mutex_lock(&chan_lock);
2514         lock_debug("At-");
2515         call = ast->tech_pvt;
2516         if (!call) {
2517                 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2518                 ast_mutex_unlock(&chan_lock);
2519                 lock_debug("at");
2520                 return -1;
2521         }
2522
2523         CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2524         memset(&newparam, 0, sizeof(union parameter));
2525         strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2526         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2527         ast_mutex_unlock(&chan_lock);
2528         lock_debug("at");
2529         return 0;
2530 }
2531
2532 /*
2533  * bridge process
2534  */
2535 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2536                                   struct ast_channel *ast2, int flags,
2537                                   struct ast_frame **fo,
2538                                   struct ast_channel **rc, int timeoutms)
2539
2540 {
2541         struct chan_call        *call1, *call2;
2542         struct ast_channel      *carr[2], *who;
2543         int                     to;
2544         struct ast_frame        *f;
2545         int                     bridge_id;
2546
2547         CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2548
2549         carr[0] = ast1;
2550         carr[1] = ast2;
2551
2552         /* join via dsp (if the channels are currently open) */
2553         lock_debug("Ab+");
2554         ast_mutex_lock(&chan_lock);
2555         lock_debug("Ab-");
2556         call1 = ast1->tech_pvt;
2557         call2 = ast2->tech_pvt;
2558         if (!call1 || !call2) {
2559                 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2560                 ast_mutex_unlock(&chan_lock);
2561                 lock_debug("ab");
2562                 return AST_BRIDGE_COMPLETE;
2563         }
2564
2565         /* join, if both call instances uses dsp
2566            ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2567         */
2568         if (!call1->nodsp && !call2->nodsp) {
2569                 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2570
2571                 /* get bridge id and join */
2572                 bridge_id = new_bridge_id();
2573
2574                 call1->bridge_id = bridge_id;
2575                 if (call1->bchannel)
2576                         bchannel_join(call1->bchannel, bridge_id);
2577
2578                 call2->bridge_id = bridge_id;
2579                 if (call2->bchannel)
2580                         bchannel_join(call2->bchannel, bridge_id);
2581         } else
2582         if (call1->nodsp && call2->nodsp)
2583                 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2584         else
2585                 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2586         call1->bridge_call = call2;
2587         call2->bridge_call = call1;
2588
2589         if (call1->state == CHAN_LCR_STATE_IN_SETUP
2590          || call1->state == CHAN_LCR_STATE_IN_DIALING
2591          || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2592          || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2593                 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2594                 lcr_answer(ast1);
2595         }
2596         if (call2->state == CHAN_LCR_STATE_IN_SETUP
2597          || call2->state == CHAN_LCR_STATE_IN_DIALING
2598          || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2599          || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2600                 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2601                 lcr_answer(ast2);
2602         }
2603
2604         /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2605            so let's do it for them. Hmpf.
2606         */
2607
2608         if (call1->on_hold) {
2609                 union parameter newparam;
2610
2611                 memset(&newparam, 0, sizeof(union parameter));
2612                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2613                 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2614
2615                 call1->on_hold = 0;
2616         }
2617
2618         if (call2->on_hold) {
2619                 union parameter newparam;
2620
2621                 memset(&newparam, 0, sizeof(union parameter));
2622                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2623                 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2624
2625                 call2->on_hold = 0;
2626         }
2627
2628         ast_mutex_unlock(&chan_lock);
2629         lock_debug("ab");
2630
2631         while(1) {
2632                 to = -1;
2633                 who = ast_waitfor_n(carr, 2, &to);
2634
2635                 if (!who) {
2636                         CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2637                         break;
2638                 }
2639                 f = ast_read(who);
2640
2641                 if (!f || f->frametype == AST_FRAME_CONTROL) {
2642                         if (!f)
2643                                 CDEBUG(NULL, NULL, "Got hangup.\n");
2644                         else
2645                                 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2646                         /* got hangup .. */
2647                         *fo=f;
2648                         *rc=who;
2649                         break;
2650                 }
2651
2652                 if ( f->frametype == AST_FRAME_DTMF ) {
2653                         CDEBUG(NULL, NULL, "Got DTMF.\n");
2654                         *fo=f;
2655                         *rc=who;
2656                         break;
2657                 }
2658
2659
2660                 if (who == ast1) {
2661                         ast_write(ast2,f);
2662                 }
2663                 else {
2664                         ast_write(ast1,f);
2665                 }
2666
2667         }
2668
2669         CDEBUG(NULL, NULL, "Releasing bridge.\n");
2670
2671         /* split channels */
2672         lock_debug("Ab+");
2673         ast_mutex_lock(&chan_lock);
2674         lock_debug("Ab-");
2675         call1 = ast1->tech_pvt;
2676         call2 = ast2->tech_pvt;
2677         if (call1 && call1->bridge_id) {
2678                 call1->bridge_id = 0;
2679                 if (call1->bchannel)
2680                         bchannel_join(call1->bchannel, 0);
2681                 if (call1->bridge_call)
2682                         call1->bridge_call->bridge_call = NULL;
2683         }
2684         if (call2 && call1->bridge_id) {
2685                 call2->bridge_id = 0;
2686                 if (call2->bchannel)
2687                         bchannel_join(call2->bchannel, 0);
2688                 if (call2->bridge_call)
2689                         call2->bridge_call->bridge_call = NULL;
2690         }
2691         call1->bridge_call = NULL;
2692         call2->bridge_call = NULL;
2693
2694         ast_mutex_unlock(&chan_lock);
2695         lock_debug("ab");
2696         return AST_BRIDGE_COMPLETE;
2697 }
2698 static struct ast_channel_tech lcr_tech = {
2699         .type="LCR",
2700         .description = "Channel driver for connecting to Linux-Call-Router",
2701         .capabilities = AST_FORMAT_ALAW,
2702         .requester = lcr_request,
2703
2704         #ifdef LCR_FOR_ASTERISK
2705         .send_digit_begin = lcr_digit_begin,
2706         .send_digit_end = lcr_digit_end,
2707         #endif
2708
2709         #ifdef LCR_FOR_CALLWEAVER
2710         .send_digit = lcr_digit,
2711         #endif
2712
2713         .call = lcr_call,
2714         .bridge = lcr_bridge,
2715         .hangup = lcr_hangup,
2716         .answer = lcr_answer,
2717         .read = lcr_read,
2718         .write = lcr_write,
2719         .indicate = lcr_indicate,
2720         .fixup = lcr_fixup,
2721         .send_text = lcr_send_text,
2722         .properties = 0
2723 };
2724
2725
2726 /*
2727  * cli
2728  */
2729 #if 0
2730 static int lcr_show_lcr (int fd, int argc, char *argv[])
2731 {
2732         return 0;
2733 }
2734
2735 static int lcr_show_calls (int fd, int argc, char *argv[])
2736 {
2737         return 0;
2738 }
2739
2740 static int lcr_reload_routing (int fd, int argc, char *argv[])
2741 {
2742         return 0;
2743 }
2744
2745 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2746 {
2747         return 0;
2748 }
2749
2750 static int lcr_port_block (int fd, int argc, char *argv[])
2751 {
2752         return 0;
2753 }
2754
2755 static int lcr_port_unblock (int fd, int argc, char *argv[])
2756 {
2757         return 0;
2758 }
2759
2760 static int lcr_port_unload (int fd, int argc, char *argv[])
2761 {
2762         return 0;
2763 }
2764
2765 static struct ast_cli_entry cli_show_lcr =
2766 { {"lcr", "show", "lcr", NULL},
2767  lcr_show_lcr,
2768  "Shows current states of LCR core",
2769  "Usage: lcr show lcr\n",
2770 };
2771
2772 static struct ast_cli_entry cli_show_calls =
2773 { {"lcr", "show", "calls", NULL},
2774  lcr_show_calls,
2775  "Shows current calls made by LCR and Asterisk",
2776  "Usage: lcr show calls\n",
2777 };
2778
2779 static struct ast_cli_entry cli_reload_routing =
2780 { {"lcr", "reload", "routing", NULL},
2781  lcr_reload_routing,
2782  "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2783  "Usage: lcr reload routing\n",
2784 };
2785
2786 static struct ast_cli_entry cli_reload_interfaces =
2787 { {"lcr", "reload", "interfaces", NULL},
2788  lcr_reload_interfaces,
2789  "Reloads interfaces conf of LCR",
2790  "Usage: lcr reload interfaces\n",
2791 };
2792
2793 static struct ast_cli_entry cli_port_block =
2794 { {"lcr", "port", "block", NULL},
2795  lcr_port_block,
2796  "Blocks LCR port for further calls",
2797  "Usage: lcr port block \"<port>\"\n",
2798 };
2799
2800 static struct ast_cli_entry cli_port_unblock =
2801 { {"lcr", "port", "unblock", NULL},
2802  lcr_port_unblock,
2803  "Unblocks or loads LCR port, port is opened my mISDN",
2804  "Usage: lcr port unblock \"<port>\"\n",
2805 };
2806
2807 static struct ast_cli_entry cli_port_unload =
2808 { {"lcr", "port", "unload", NULL},
2809  lcr_port_unload,
2810  "Unloads LCR port, port is closes by mISDN",
2811  "Usage: lcr port unload \"<port>\"\n",
2812 };
2813 #endif
2814
2815
2816 #ifdef LCR_FOR_ASTERISK
2817 static int lcr_config_exec(struct ast_channel *ast, void *data)
2818 #endif
2819
2820 #ifdef LCR_FOR_CALLWEAVER
2821 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2822 #endif
2823 {
2824         struct chan_call *call;
2825
2826         lock_debug("Ae+");
2827         ast_mutex_lock(&chan_lock);
2828         lock_debug("Ae-");
2829
2830         #ifdef LCR_FOR_ASTERISK
2831         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2832         #endif
2833
2834         #ifdef LCR_FOR_CALLWEAVER
2835         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2836         #endif
2837
2838         /* find channel */
2839         call = call_first;
2840         while(call) {
2841                 if (call->ast == ast)
2842                         break;
2843                 call = call->next;
2844         }
2845         if (call)
2846
2847                 #ifdef LCR_FOR_ASTERISK
2848                 apply_opt(call, (char *)data);
2849                 #endif
2850
2851                 #ifdef LCR_FOR_CALLWEAVER
2852                 apply_opt(call, (char *)argv[0]);
2853                 #endif
2854
2855         else
2856                 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2857
2858         ast_mutex_unlock(&chan_lock);
2859         lock_debug("ae");
2860         return 0;
2861 }
2862
2863 /*
2864  * module loading and destruction
2865  */
2866 int load_module(void)
2867 {
2868         u_short i;
2869         char options_error[256];
2870
2871         for (i = 0; i < 256; i++) {
2872                 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2873                              | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2874         }
2875
2876         if (read_options(options_error) == 0) {
2877                 CERROR(NULL, NULL, "%s", options_error);
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         }
2888
2889         ast_mutex_init(&chan_lock);
2890         ast_mutex_init(&log_lock);
2891
2892         if (bchannel_initialize()) {
2893                 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2894                 close_socket();
2895
2896                 #ifdef LCR_FOR_ASTERISK
2897                 return AST_MODULE_LOAD_DECLINE;
2898                 #endif
2899
2900                 #ifdef LCR_FOR_CALLWEAVER
2901                 return 0;
2902                 #endif
2903         }
2904         mISDN_created = 1;
2905
2906         lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2907         if (ast_channel_register(&lcr_tech)) {
2908                 CERROR(NULL, NULL, "Unable to register channel class\n");
2909                 bchannel_deinitialize();
2910                 close_socket();
2911
2912                 #ifdef LCR_FOR_ASTERISK
2913                 return AST_MODULE_LOAD_DECLINE;
2914                 #endif
2915
2916                 #ifdef LCR_FOR_CALLWEAVER
2917                 return 0;
2918                 #endif
2919         }
2920
2921         ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2922
2923                                  #ifdef LCR_FOR_ASTERISK
2924                                  "lcr_config(<opt><optarg>:<opt>:...)\n"
2925                                  #endif
2926
2927                                  #ifdef LCR_FOR_CALLWEAVER
2928                                  "lcr_config(<opt><optarg>:<opt>:...)\n",
2929                                  #endif
2930
2931                                  "Sets LCR opts. and optargs\n"
2932                                  "\n"
2933                                  "The available options are:\n"
2934                                  "    d - Send display text on called phone, text is the optarg.\n"
2935                                  "    n - Don't detect dtmf tones on called channel.\n"
2936                                  "    h - Force data call (HDLC).\n"
2937                                  "    t - Disable mISDN_dsp features (required for fax application).\n"
2938                                  "    q - Add queue to make fax stream seamless (required for fax app).\n"
2939                                  "        Use queue size in miliseconds for optarg. (try 250)\n"
2940                                  "    f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2941                                  "        Use time to detect for optarg.\n"
2942                                  "    c - Make crypted outgoing call, optarg is keyindex.\n"
2943                                  "    e - Perform echo cancelation on this channel.\n"
2944                                  "        Takes mISDN pipeline option as optarg.\n"
2945                                  "    s - Send Non Inband DTMF as inband.\n"
2946                                  "    r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2947                                  "   vr - rxgain control\n"
2948                                  "   vt - txgain control\n"
2949                                  "        Volume changes at factor 2 ^ optarg.\n"
2950                                  "    k - use keypad to dial this call.\n"
2951                                  "\n"
2952                                  "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2953                                  " -> use 16 for fax (3.1k audio)\n"
2954                                  "\n"
2955                                  "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2956                                  "options: \"n:t:q250\" for seamless audio transmission.\n"
2957                 );
2958
2959
2960 #if 0
2961         ast_cli_register(&cli_show_lcr);
2962         ast_cli_register(&cli_show_calls);
2963         ast_cli_register(&cli_reload_routing);
2964         ast_cli_register(&cli_reload_interfaces);
2965         ast_cli_register(&cli_port_block);
2966         ast_cli_register(&cli_port_unblock);
2967         ast_cli_register(&cli_port_unload);
2968 #endif
2969
2970         quit = 0;
2971         if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2972                 /* failed to create thread */
2973                 bchannel_deinitialize();
2974                 close_socket();
2975                 ast_channel_unregister(&lcr_tech);
2976
2977                 #ifdef LCR_FOR_ASTERISK
2978                 return AST_MODULE_LOAD_DECLINE;
2979                 #endif
2980
2981                 #ifdef LCR_FOR_CALLWEAVER
2982                 return 0;
2983                 #endif
2984
2985         }
2986         return 0;
2987 }
2988
2989 int unload_module(void)
2990 {
2991         /* First, take us out of the channel loop */
2992         CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2993
2994         quit = 1;
2995         pthread_join(chan_tid, NULL);
2996
2997         ast_channel_unregister(&lcr_tech);
2998
2999         ast_unregister_application("lcr_config");
3000
3001
3002         if (mISDN_created) {
3003                 bchannel_deinitialize();
3004                 mISDN_created = 0;
3005         }
3006
3007         if (lcr_sock >= 0) {
3008                 close(lcr_sock);
3009                 lcr_sock = -1;
3010         }
3011
3012         return 0;
3013 }
3014
3015 int reload_module(void)
3016 {
3017 //      reload_config();
3018         return 0;
3019 }
3020
3021 #ifdef LCR_FOR_ASTERISK
3022 #define AST_MODULE "chan_lcr"
3023 #endif
3024
3025 #ifdef LCR_FOR_CALLWEAVER
3026 int usecount(void)
3027 hae
3028 {
3029         int res;
3030         lock_debug("U+");
3031         ast_mutex_lock(&usecnt_lock);
3032         lock_debug("U-");
3033         res = usecnt;
3034         ast_mutex_unlock(&usecnt_lock);
3035         lock_debug("u");
3036         return res;
3037 }
3038 #endif
3039
3040 #ifdef LCR_FOR_ASTERISK
3041 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3042                 .load = load_module,
3043                 .unload = unload_module,
3044                 .reload = reload_module,
3045                );
3046 #endif
3047
3048 #ifdef LCR_FOR_CALLWEAVER
3049 char *description(void)
3050 {
3051         return desc;
3052 }
3053 #endif