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