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