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