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