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                                 /* create only, if call exists, othewhise it bchannel is freed below... */
1118                                 if (bchannel_create(bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0)))
1119                                         bchannel_activate(bchannel, 1);
1120                         }
1121                         /* acknowledge */
1122                         newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1123                         newparam.bchannel.handle = param->bchannel.handle;
1124                         send_message(MESSAGE_BCHANNEL, 0, &newparam);
1125                         /* if call has released before bchannel is assigned */
1126                         if (!call) {
1127                                 newparam.bchannel.type = BCHANNEL_RELEASE;
1128                                 newparam.bchannel.handle = param->bchannel.handle;
1129                                 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1130                         }
1131
1132                         break;
1133
1134                         case BCHANNEL_REMOVE:
1135                         CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1136                         if (!(bchannel = find_bchannel_handle(param->bchannel.handle)))
1137                         {
1138                                 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1139                                 return(-1);
1140                         }
1141                         /* unklink from call and destroy bchannel */
1142                         free_bchannel(bchannel);
1143
1144                         /* acknowledge */
1145                         newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1146                         newparam.bchannel.handle = param->bchannel.handle;
1147                         send_message(MESSAGE_BCHANNEL, 0, &newparam);
1148
1149                         break;
1150
1151                         default:
1152                         CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1153                 }
1154                 return(0);
1155         }
1156
1157         /* handle new ref */
1158         if (message_type == MESSAGE_NEWREF)
1159         {
1160                 if (param->direction)
1161                 {
1162                         /* new ref from lcr */
1163                         CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1164                         if (!ref || find_call_ref(ref))
1165                         {
1166                                 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1167                                 return(-1);
1168                         }
1169                         /* allocate new call instance */
1170                         call = alloc_call();
1171                         /* new state */
1172                         call->state = CHAN_LCR_STATE_IN_PREPARE;
1173                         /* set ref */
1174                         call->ref = ref;
1175                         /* wait for setup (or release from asterisk) */
1176                 } else
1177                 {
1178                         /* new ref, as requested from this remote application */
1179                         CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1180                         call = find_call_ref(0);
1181                         if (!call)
1182                         {
1183                                 /* send release, if ref does not exist */
1184                                 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1185                                 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1186                                 return(0);
1187                         }
1188                         /* store new ref */
1189                         call->ref = ref;
1190                         /* send pending setup info */
1191                         if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1192                                 send_setup_to_lcr(call);
1193                         /* release if asterisk has signed off */
1194                         else if (call->state == CHAN_LCR_STATE_RELEASE)
1195                         {
1196                                 /* send release */
1197                                 if (call->cause)
1198                                         send_release_and_import(call, call->cause, call->location);
1199                                 else
1200                                         send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1201                                 /* free call */
1202                                 free_call(call);
1203                                 return(0);
1204                         }
1205                 }
1206                 return(0);
1207         }
1208
1209         /* check ref */
1210         if (!ref)
1211         {
1212                 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1213                 return(-1);
1214         }
1215         call = find_call_ref(ref);
1216         if (!call)
1217         {
1218                 /* ignore ref that is not used (anymore) */
1219                 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1220                 return(0);
1221         }
1222
1223         /* handle messages */
1224         switch(message_type)
1225         {
1226                 case MESSAGE_SETUP:
1227                 lcr_in_setup(call, message_type, param);
1228                 break;
1229
1230                 case MESSAGE_OVERLAP:
1231                 lcr_in_overlap(call, message_type, param);
1232                 break;
1233
1234                 case MESSAGE_PROCEEDING:
1235                 lcr_in_proceeding(call, message_type, param);
1236                 break;
1237
1238                 case MESSAGE_ALERTING:
1239                 lcr_in_alerting(call, message_type, param);
1240                 break;
1241
1242                 case MESSAGE_CONNECT:
1243                 lcr_in_connect(call, message_type, param);
1244                 break;
1245
1246                 case MESSAGE_DISCONNECT:
1247                 lcr_in_disconnect(call, message_type, param);
1248                 break;
1249
1250                 case MESSAGE_RELEASE:
1251                 lcr_in_release(call, message_type, param);
1252                 break;
1253
1254                 case MESSAGE_INFORMATION:
1255                 lcr_in_information(call, message_type, param);
1256                 break;
1257
1258                 case MESSAGE_NOTIFY:
1259                 lcr_in_notify(call, message_type, param);
1260                 break;
1261
1262                 case MESSAGE_FACILITY:
1263                 lcr_in_facility(call, message_type, param);
1264                 break;
1265
1266                 case MESSAGE_PATTERN: // audio available from LCR
1267                 break;
1268
1269                 case MESSAGE_NOPATTERN: // audio not available from LCR
1270                 break;
1271
1272                 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1273                 call->audiopath = param->audiopath;
1274                 break;
1275
1276                 default:
1277                 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1278                 break;
1279         }
1280         return(0);
1281 }
1282
1283 /*
1284  * release all calls (due to broken socket)
1285  */
1286 static void release_all_calls(void)
1287 {
1288         struct chan_call *call;
1289
1290 again:
1291         call = call_first;
1292         while(call) {
1293                 /* no ast, so we may directly free call */
1294                 if (!call->ast) {
1295                         CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1296                         free_call(call);
1297                         goto again;
1298                 }
1299                 /* already in release process */
1300                 if (call->state == CHAN_LCR_STATE_RELEASE) {
1301                         call = call->next;
1302                         continue;
1303                 }
1304                 /* release or queue release */
1305                 call->ref = 0;
1306                 call->state = CHAN_LCR_STATE_RELEASE;
1307                 if (!call->pbx_started) {
1308                         CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1309                         ast_hangup(call->ast); // call will be destroyed here
1310                         goto again;
1311                 }
1312                 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1313                 ast_queue_hangup(call->ast);
1314                 call = call->next;
1315         }
1316
1317         /* release all bchannels */
1318         while(bchannel_first)
1319                 free_bchannel(bchannel_first);
1320 }
1321
1322
1323 /* asterisk handler
1324  * warning! not thread safe
1325  * returns -1 for socket error, 0 for no work, 1 for work
1326  */
1327 int handle_socket(void)
1328 {
1329         int work = 0;
1330         int len;
1331         struct admin_list *admin;
1332         struct admin_message msg;
1333
1334         /* read from socket */
1335         len = read(lcr_sock, &msg, sizeof(msg));
1336         if (len == 0)
1337         {
1338                 CERROR(NULL, NULL, "Socket closed.\n");
1339                 return(-1); // socket closed
1340         }
1341         if (len > 0)
1342         {
1343                 if (len != sizeof(msg))
1344                 {
1345                         CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1346                         return(-1); // socket error
1347                 }
1348                 if (msg.message != ADMIN_MESSAGE)
1349                 {
1350                         CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1351                         return(-1);
1352                 }
1353                 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1354                 work = 1;
1355         } else
1356         {
1357                 if (errno != EWOULDBLOCK)
1358                 {
1359                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1360                         return(-1);
1361                 }
1362         }
1363
1364         /* write to socket */
1365         if (!admin_first)
1366                 return(work);
1367         admin = admin_first;
1368         len = write(lcr_sock, &admin->msg, sizeof(msg));
1369         if (len == 0)
1370         {
1371                 CERROR(NULL, NULL, "Socket closed.\n");
1372                 return(-1); // socket closed
1373         }
1374         if (len > 0)
1375         {
1376                 if (len != sizeof(msg))
1377                 {
1378                         CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1379                         return(-1); // socket error
1380                 }
1381                 /* free head */
1382                 admin_first = admin->next;
1383                 free(admin);
1384
1385                 work = 1;
1386         } else
1387         {
1388                 if (errno != EWOULDBLOCK)
1389                 {
1390                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1391                         return(-1);
1392                 }
1393         }
1394
1395         return(work);
1396 }
1397
1398 /*
1399  * open and close socket and thread
1400  */
1401 int open_socket(void)
1402 {
1403         int ret;
1404         char *socket_name = SOCKET_NAME;
1405         int conn;
1406         struct sockaddr_un sock_address;
1407         unsigned int on = 1;
1408         union parameter param;
1409
1410         /* open socket */
1411         if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1412         {
1413                 CERROR(NULL, NULL, "Failed to create socket.\n");
1414                 return(lcr_sock);
1415         }
1416
1417         /* set socket address and name */
1418         memset(&sock_address, 0, sizeof(sock_address));
1419         sock_address.sun_family = PF_UNIX;
1420         strcpy(sock_address.sun_path, socket_name);
1421
1422         /* connect socket */
1423         if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0)
1424         {
1425                 close(lcr_sock);
1426                 lcr_sock = -1;
1427                 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1428                 return(conn);
1429         }
1430
1431         /* set non-blocking io */
1432         if ((ret = ioctl(lcr_sock, FIONBIO, (unsigned char *)(&on))) < 0)
1433         {
1434                 close(lcr_sock);
1435                 lcr_sock = -1;
1436                 CERROR(NULL, NULL, "Failed to set socket into non-blocking IO.\n");
1437                 return(ret);
1438         }
1439
1440         /* enque hello message */
1441         memset(&param, 0, sizeof(param));
1442         strcpy(param.hello.application, "asterisk");
1443         send_message(MESSAGE_HELLO, 0, &param);
1444
1445         return(lcr_sock);
1446 }
1447
1448 void close_socket(void)
1449 {
1450         struct admin_list *admin, *temp;
1451
1452         /* flush pending messages */
1453         admin = admin_first;
1454         while(admin) {
1455                 temp = admin;
1456                 admin = admin->next;
1457                 free(temp);
1458         }
1459         admin_first = NULL;
1460
1461         /* close socket */
1462         if (lcr_sock >= 0)
1463                 close(lcr_sock);
1464         lcr_sock = -1;
1465 }
1466
1467 void sighandler(int sigset)
1468 {
1469 }
1470
1471 static void *chan_thread(void *arg)
1472 {
1473         int work;
1474         int ret;
1475         union parameter param;
1476         time_t retry = 0, now;
1477
1478         bchannel_pid = getpid();
1479
1480 //      signal(SIGPIPE, sighandler);
1481
1482         memset(&param, 0, sizeof(union parameter));
1483         if (lcr_sock < 0)
1484                 time(&retry);
1485
1486         ast_mutex_lock(&chan_lock);
1487
1488         while(!quit) {
1489                 work = 0;
1490
1491                 if (lcr_sock > 0) {
1492                         /* handle socket */
1493                         ret = handle_socket();
1494                         if (ret < 0) {
1495                                 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1496                                 close_socket();
1497                                 release_all_calls();
1498                                 time(&retry);
1499                         }
1500                         if (ret)
1501                                 work = 1;
1502                 } else {
1503                         time(&now);
1504                         if (retry && now-retry > 5) {
1505                                 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1506                                 retry = 0;
1507                                 if (open_socket() < 0) {
1508                                         time(&retry);
1509                                 }
1510                                 work = 1;
1511                         }
1512
1513                 }
1514
1515                 /* handle mISDN */
1516                 ret = bchannel_handle();
1517                 if (ret)
1518                         work = 1;
1519
1520                 if (!work) {
1521                         ast_mutex_unlock(&chan_lock);
1522                         usleep(30000);
1523                         ast_mutex_lock(&chan_lock);
1524                 }
1525         }
1526
1527         close_socket();
1528
1529         CERROR(NULL, NULL, "Thread exit.\n");
1530
1531         ast_mutex_unlock(&chan_lock);
1532
1533 //      signal(SIGPIPE, SIG_DFL);
1534
1535         return NULL;
1536 }
1537
1538 /*
1539  * new asterisk instance
1540  */
1541 static
1542 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1543 {
1544         char exten[256], *dial, *interface, *opt;
1545         struct ast_channel *ast;
1546         struct chan_call *call;
1547
1548         ast_mutex_lock(&chan_lock);
1549         CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1550
1551         /* if socket is closed */
1552         if (lcr_sock < 0)
1553         {
1554                 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1555                 return NULL;
1556         }
1557
1558         /* create call instance */
1559         call = alloc_call();
1560         if (!call)
1561         {
1562                 /* failed to create instance */
1563                 return NULL;
1564         }
1565
1566         /* create asterisk channel instrance */
1567         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1568         if (!ast)
1569         {
1570                 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1571                 free_call(call);
1572                 /* failed to create instance */
1573                 return NULL;
1574         }
1575         ast->tech = &lcr_tech;
1576         ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1577         /* configure channel */
1578         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1579         ast->readformat = ast->rawreadformat = ast->nativeformats;
1580         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
1581         ast->priority = 1;
1582         ast->hangupcause = 0;
1583
1584         /* link together */
1585         call->ast = ast;
1586         ast->tech_pvt = call;
1587         ast->fds[0] = call->pipe[0];
1588         call->pbx_started = 0;
1589         /* set state */
1590         call->state = CHAN_LCR_STATE_OUT_PREPARE;
1591
1592         /*
1593          * Extract interface, dialstring, options from data.
1594          * Formats can be:
1595          *      <dialstring>
1596          *      <interface>/<dialstring>
1597          *      <interface>/<dialstring>/options
1598          */
1599         strncpy(exten, (char *)data, sizeof(exten)-1);
1600         exten[sizeof(exten)-1] = '\0';
1601         if ((dial = strchr(exten, '/'))) {
1602                 *dial++ = '\0';
1603                 interface = exten;
1604                 if ((opt = strchr(dial, '/')))
1605                         *opt++ = '\0';
1606                 else
1607                         opt = "";
1608         } else {
1609                 dial = exten;
1610                 interface = "";
1611                 opt = "";
1612         }
1613         strncpy(call->interface, interface, sizeof(call->interface)-1);
1614         strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1615         apply_opt(call, (char *)opt);
1616
1617         ast_mutex_unlock(&chan_lock);
1618         return ast;
1619 }
1620
1621 /*
1622  * call from asterisk
1623  */
1624 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1625 {
1626         union parameter newparam;
1627         struct chan_call *call;
1628
1629         ast_mutex_lock(&chan_lock);
1630         call = ast->tech_pvt;
1631         if (!call) {
1632                 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1633                 ast_mutex_unlock(&chan_lock);
1634                 return -1;
1635         }
1636
1637         CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1638
1639         /* pbx process is started */
1640         call->pbx_started = 1;
1641         /* send MESSAGE_NEWREF */
1642         memset(&newparam, 0, sizeof(union parameter));
1643         newparam.direction = 0; /* request from app */
1644         send_message(MESSAGE_NEWREF, 0, &newparam);
1645
1646         /* set hdlc if capability requires hdlc */
1647         if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1648          || ast->transfercapability == INFO_BC_DATARESTRICTED
1649          || ast->transfercapability == INFO_BC_VIDEO)
1650                 call->hdlc = 1;
1651         /* if hdlc is forced by option, we change transcap to data */
1652         if (call->hdlc
1653          && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1654          && ast->transfercapability != INFO_BC_DATARESTRICTED
1655          && ast->transfercapability != INFO_BC_VIDEO)
1656                 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1657
1658         call->cid_num[0] = 0;
1659         call->cid_name[0] = 0;
1660         call->cid_rdnis[0] = 0;
1661
1662         if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1663                 strncpy(call->cid_num, ast->cid.cid_num,
1664                         sizeof(call->cid_num)-1);
1665
1666         if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1667                 strncpy(call->cid_name, ast->cid.cid_name,
1668                         sizeof(call->cid_name)-1);
1669         if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1670                 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1671                         sizeof(call->cid_rdnis)-1);
1672
1673         ast_mutex_unlock(&chan_lock);
1674         return 0;
1675 }
1676
1677 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1678 {
1679         printf("DIGT BEGIN %c\n", digit);
1680         return (0);
1681 }
1682
1683 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
1684 {
1685         struct chan_call *call;
1686         union parameter newparam;
1687         char buf[]="x";
1688
1689         /* only pass IA5 number space */
1690         if (digit > 126 || digit < 32)
1691                 return 0;
1692
1693         ast_mutex_lock(&chan_lock);
1694         call = ast->tech_pvt;
1695         if (!call) {
1696                 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
1697                 ast_mutex_unlock(&chan_lock);
1698                 return -1;
1699         }
1700
1701         CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
1702
1703         /* send information or queue them */
1704         if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING)
1705         {
1706                 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
1707                 memset(&newparam, 0, sizeof(union parameter));
1708                 newparam.information.id[0] = digit;
1709                 newparam.information.id[1] = '\0';
1710                 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
1711         } else
1712         if (!call->ref
1713          && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP))
1714         {
1715                 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
1716                 *buf = digit;
1717                 strncat(call->dialque, buf, strlen(call->dialque)-1);
1718         }
1719
1720         ast_mutex_unlock(&chan_lock);
1721         return(0);
1722 }
1723
1724 static int lcr_answer(struct ast_channel *ast)
1725 {
1726         union parameter newparam;
1727         struct chan_call *call;
1728
1729         ast_mutex_lock(&chan_lock);
1730         call = ast->tech_pvt;
1731         if (!call) {
1732                 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
1733                 ast_mutex_unlock(&chan_lock);
1734                 return -1;
1735         }
1736
1737         CDEBUG(call, ast, "Received answer from Asterisk.\n");
1738
1739         /* copy connectinfo, if bridged */
1740         if (call->bridge_call)
1741                 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
1742         /* send connect message to lcr */
1743         memset(&newparam, 0, sizeof(union parameter));
1744         memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
1745         send_message(MESSAGE_CONNECT, call->ref, &newparam);
1746         /* change state */
1747         call->state = CHAN_LCR_STATE_CONNECT;
1748         /* request bchannel */
1749         if (!call->bchannel) {
1750                 CDEBUG(call, ast, "Requesting B-channel.\n");
1751                 memset(&newparam, 0, sizeof(union parameter));
1752                 newparam.bchannel.type = BCHANNEL_REQUEST;
1753                 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1754         }
1755         /* enable keypad */
1756 //      memset(&newparam, 0, sizeof(union parameter));
1757 //      send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
1758         /* enable dtmf */
1759         if (call->no_dtmf)
1760                 CDEBUG(call, ast, "DTMF is disabled by option.\n");
1761         else
1762                 call->dtmf = 1;
1763
1764         ast_mutex_unlock(&chan_lock);
1765         return 0;
1766 }
1767
1768 static int lcr_hangup(struct ast_channel *ast)
1769 {
1770         struct chan_call *call;
1771         pthread_t tid = pthread_self();
1772
1773         if (!pthread_equal(tid, chan_tid))
1774                 ast_mutex_lock(&chan_lock);
1775         call = ast->tech_pvt;
1776         if (!call) {
1777                 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
1778                 if (!pthread_equal(tid, chan_tid))
1779                         ast_mutex_unlock(&chan_lock);
1780                 return -1;
1781         }
1782
1783         if (!pthread_equal(tid, chan_tid))
1784                 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
1785         else
1786                 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
1787
1788         /* disconnect asterisk, maybe not required */
1789         ast->tech_pvt = NULL;
1790         ast->fds[0] = -1;
1791         if (call->ref)
1792         {
1793                 /* release */
1794                 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
1795                 if (ast->hangupcause > 0)
1796                         send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
1797                 else
1798                         send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
1799                 /* remove call */
1800                 free_call(call);
1801                 if (!pthread_equal(tid, chan_tid))
1802                         ast_mutex_unlock(&chan_lock);
1803                 return 0;
1804         } else
1805         {
1806                 /* ref is not set, due to prepare setup or release */
1807                 if (call->state == CHAN_LCR_STATE_RELEASE)
1808                 {
1809                         /* we get the response to our release */
1810                         CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
1811                         free_call(call);
1812                 } else
1813                 {
1814                         /* during prepare, we change to release state */
1815                         CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
1816                         call->state = CHAN_LCR_STATE_RELEASE;
1817                 }
1818         }
1819         if (!pthread_equal(tid, chan_tid))
1820                 ast_mutex_unlock(&chan_lock);
1821         return 0;
1822 }
1823
1824 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
1825 {
1826         struct chan_call *call;
1827
1828         if (!f->subclass)
1829                 CDEBUG(NULL, ast, "No subclass\n");
1830         if (!(f->subclass & ast->nativeformats))
1831                 CDEBUG(NULL, ast, "Unexpected format.\n");
1832
1833         ast_mutex_lock(&chan_lock);
1834         call = ast->tech_pvt;
1835         if (!call) {
1836                 ast_mutex_unlock(&chan_lock);
1837                 return -1;
1838         }
1839         if (call->bchannel && f->samples)
1840                 bchannel_transmit(call->bchannel, f->data, f->samples);
1841         ast_mutex_unlock(&chan_lock);
1842         return 0;
1843 }
1844
1845
1846 static struct ast_frame *lcr_read(struct ast_channel *ast)
1847 {
1848         struct chan_call *call;
1849         int i, len;
1850         unsigned char *p;
1851
1852         ast_mutex_lock(&chan_lock);
1853         call = ast->tech_pvt;
1854         if (!call) {
1855                 ast_mutex_unlock(&chan_lock);
1856                 return NULL;
1857         }
1858         if (call->pipe[0] > -1) {
1859                 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
1860                 if (len <= 0) {
1861                         close(call->pipe[0]);
1862                         call->pipe[0] = -1;
1863                         return NULL;
1864                 }
1865         }
1866
1867         p = call->read_buff;
1868         for (i = 0; i < len; i++) {
1869                 *p = flip_bits[*p];
1870                 p++;
1871         }
1872
1873         call->read_fr.frametype = AST_FRAME_VOICE;
1874         call->read_fr.subclass = ast->nativeformats;
1875         call->read_fr.datalen = len;
1876         call->read_fr.samples = len;
1877         call->read_fr.delivery = ast_tv(0,0);
1878         call->read_fr.data = call->read_buff;
1879         ast_mutex_unlock(&chan_lock);
1880
1881         return &call->read_fr;
1882 }
1883
1884 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
1885 {
1886         union parameter newparam;
1887         int res = 0;
1888         struct chan_call *call;
1889
1890         ast_mutex_lock(&chan_lock);
1891         call = ast->tech_pvt;
1892         if (!call) {
1893                 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
1894                 ast_mutex_unlock(&chan_lock);
1895                 return -1;
1896         }
1897
1898         switch (cond) {
1899                 case AST_CONTROL_BUSY:
1900                         CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
1901                         ast_setstate(ast, AST_STATE_BUSY);
1902                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
1903                                 /* send message to lcr */
1904                                 memset(&newparam, 0, sizeof(union parameter));
1905                                 newparam.disconnectinfo.cause = 17;
1906                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1907                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
1908                                 /* change state */
1909                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
1910                         }
1911                         break;
1912                 case AST_CONTROL_CONGESTION:
1913                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
1914                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
1915                                 /* send message to lcr */
1916                                 memset(&newparam, 0, sizeof(union parameter));
1917                                 newparam.disconnectinfo.cause = ast->hangupcause;
1918                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1919                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
1920                                 /* change state */
1921                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
1922                         }
1923                         break;
1924                 case AST_CONTROL_PROCEEDING:
1925                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
1926                         if (call->state == CHAN_LCR_STATE_IN_SETUP
1927                          || call->state == CHAN_LCR_STATE_IN_DIALING) {
1928                                 /* send message to lcr */
1929                                 memset(&newparam, 0, sizeof(union parameter));
1930                                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
1931                                 /* change state */
1932                                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
1933                         }
1934                         break;
1935                 case AST_CONTROL_RINGING:
1936                         CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
1937                         ast_setstate(ast, AST_STATE_RINGING);
1938                         if (call->state == CHAN_LCR_STATE_IN_SETUP
1939                          || call->state == CHAN_LCR_STATE_IN_DIALING
1940                          || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
1941                                 /* send message to lcr */
1942                                 memset(&newparam, 0, sizeof(union parameter));
1943                                 send_message(MESSAGE_ALERTING, call->ref, &newparam);
1944                                 /* change state */
1945                                 call->state = CHAN_LCR_STATE_IN_ALERTING;
1946                         }
1947                         break;
1948                 case -1:
1949                         CDEBUG(call, ast, "Received indicate -1.\n");
1950                         res = -1;
1951                         break;
1952
1953                 case AST_CONTROL_VIDUPDATE:
1954                         CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
1955                         res = -1;
1956                         break;
1957                 case AST_CONTROL_HOLD:
1958                         CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
1959                         /* send message to lcr */
1960                         memset(&newparam, 0, sizeof(union parameter));
1961                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
1962                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
1963
1964                         /*start music onhold*/
1965                         ast_moh_start(ast,data,ast->musicclass);
1966                         break;
1967                 case AST_CONTROL_UNHOLD:
1968                         CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
1969                         /* send message to lcr */
1970                         memset(&newparam, 0, sizeof(union parameter));
1971                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
1972                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
1973
1974                         /*stop moh*/
1975                         ast_moh_stop(ast);
1976                         break;
1977
1978                 default:
1979                         CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
1980                         res = -1;
1981                         break;
1982         }
1983
1984         /* return */
1985         ast_mutex_unlock(&chan_lock);
1986         return res;
1987 }
1988
1989 /*
1990  * fixup asterisk
1991  */
1992 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *newast)
1993 {
1994         struct chan_call *call;
1995
1996         ast_mutex_lock(&chan_lock);
1997         call = oldast->tech_pvt;
1998         if (!call) {
1999                 CERROR(NULL, oldast, "Received fixup from Asterisk, but no call instance exists.\n");
2000                 ast_mutex_unlock(&chan_lock);
2001                 return -1;
2002         }
2003
2004         CDEBUG(call, oldast, "Received fixup from Asterisk.\n");
2005         call->ast = newast;
2006         ast_mutex_lock(&chan_lock);
2007         return 0;
2008 }
2009
2010 /*
2011  * send_text asterisk
2012  */
2013 static int lcr_send_text(struct ast_channel *ast, const char *text)
2014 {
2015         struct chan_call *call;
2016         union parameter newparam;
2017
2018         ast_mutex_lock(&chan_lock);
2019         call = ast->tech_pvt;
2020         if (!call) {
2021                 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2022                 ast_mutex_unlock(&chan_lock);
2023                 return -1;
2024         }
2025
2026         CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2027         memset(&newparam, 0, sizeof(union parameter));
2028         strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2029         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2030         ast_mutex_lock(&chan_lock);
2031         return 0;
2032 }
2033
2034 /*
2035  * bridge process
2036  */
2037 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2038                                   struct ast_channel *ast2, int flags,
2039                                   struct ast_frame **fo,
2040                                   struct ast_channel **rc, int timeoutms)
2041
2042 {
2043         struct chan_call        *call1, *call2;
2044         struct ast_channel      *carr[2], *who;
2045         int                     to;
2046         struct ast_frame        *f;
2047         int                     bridge_id;
2048
2049         CDEBUG(NULL, NULL, "Received briding request from Asterisk.\n");
2050
2051         carr[0] = ast1;
2052         carr[1] = ast2;
2053
2054         /* join via dsp (if the channels are currently open) */
2055         ast_mutex_lock(&chan_lock);
2056         bridge_id = new_bridge_id();
2057         call1 = ast1->tech_pvt;
2058         call2 = ast2->tech_pvt;
2059         if (call1 && call2)
2060         {
2061                 call1->bridge_id = bridge_id;
2062                 if (call1->bchannel)
2063                         bchannel_join(call1->bchannel, bridge_id);
2064                 call1->bridge_call = call2;
2065         }
2066         if (call2)
2067         {
2068                 call2->bridge_id = bridge_id;
2069                 if (call2->bchannel)
2070                         bchannel_join(call2->bchannel, bridge_id);
2071                 call2->bridge_call = call1;
2072         }
2073         ast_mutex_unlock(&chan_lock);
2074
2075         while(1) {
2076                 to = -1;
2077                 who = ast_waitfor_n(carr, 2, &to);
2078
2079                 if (!who) {
2080                         CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2081                         break;
2082                 }
2083                 f = ast_read(who);
2084
2085                 if (!f || f->frametype == AST_FRAME_CONTROL) {
2086                         if (!f)
2087                                 CDEBUG(NULL, NULL, "Got hangup.\n");
2088                         else
2089                                 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2090                         /* got hangup .. */
2091                         *fo=f;
2092                         *rc=who;
2093                         break;
2094                 }
2095
2096                 if ( f->frametype == AST_FRAME_DTMF ) {
2097                         CDEBUG(NULL, NULL, "Got DTMF.\n");
2098                         *fo=f;
2099                         *rc=who;
2100                         break;
2101                 }
2102
2103
2104                 if (who == ast1) {
2105                         ast_write(ast2,f);
2106                 }
2107                 else {
2108                         ast_write(ast1,f);
2109                 }
2110
2111         }
2112
2113         CDEBUG(NULL, NULL, "Releasing bride.\n");
2114
2115         /* split channels */
2116         ast_mutex_lock(&chan_lock);
2117         call1 = ast1->tech_pvt;
2118         call2 = ast2->tech_pvt;
2119         if (call1)
2120         {
2121                 call1->bridge_id = 0;
2122                 if (call1->bchannel)
2123                         bchannel_join(call1->bchannel, 0);
2124                 if (call1->bridge_call)
2125                         call1->bridge_call->bridge_call = NULL;
2126                 call1->bridge_call = NULL;
2127         }
2128         if (call2)
2129         {
2130                 call2->bridge_id = 0;
2131                 if (call2->bchannel)
2132                         bchannel_join(call2->bchannel, 0);
2133                 if (call2->bridge_call)
2134                         call2->bridge_call->bridge_call = NULL;
2135                 call2->bridge_call = NULL;
2136         }
2137
2138         ast_mutex_unlock(&chan_lock);
2139         return AST_BRIDGE_COMPLETE;
2140 }
2141 static struct ast_channel_tech lcr_tech = {
2142         .type="LCR",
2143         .description="Channel driver for connecting to Linux-Call-Router",
2144         .requester=lcr_request,
2145         .send_digit_begin=lcr_digit_begin,
2146         .send_digit_end=lcr_digit_end,
2147         .call=lcr_call,
2148         .bridge=lcr_bridge,
2149         .hangup=lcr_hangup,
2150         .answer=lcr_answer,
2151         .read=lcr_read,
2152         .write=lcr_write,
2153         .indicate=lcr_indicate,
2154         .fixup=lcr_fixup,
2155         .send_text=lcr_send_text,
2156         .properties=0
2157 };
2158
2159
2160 /*
2161  * cli
2162  */
2163 #if 0
2164 static int lcr_show_lcr (int fd, int argc, char *argv[])
2165 {
2166         return 0;
2167 }
2168
2169 static int lcr_show_calls (int fd, int argc, char *argv[])
2170 {
2171         return 0;
2172 }
2173
2174 static int lcr_reload_routing (int fd, int argc, char *argv[])
2175 {
2176         return 0;
2177 }
2178
2179 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2180 {
2181         return 0;
2182 }
2183
2184 static int lcr_port_block (int fd, int argc, char *argv[])
2185 {
2186         return 0;
2187 }
2188
2189 static int lcr_port_unblock (int fd, int argc, char *argv[])
2190 {
2191         return 0;
2192 }
2193
2194 static int lcr_port_unload (int fd, int argc, char *argv[])
2195 {
2196         return 0;
2197 }
2198
2199 static struct ast_cli_entry cli_show_lcr =
2200 { {"lcr", "show", "lcr", NULL},
2201  lcr_show_lcr,
2202  "Shows current states of LCR core",
2203  "Usage: lcr show lcr\n",
2204 };
2205
2206 static struct ast_cli_entry cli_show_calls =
2207 { {"lcr", "show", "calls", NULL},
2208  lcr_show_calls,
2209  "Shows current calls made by LCR and Asterisk",
2210  "Usage: lcr show calls\n",
2211 };
2212
2213 static struct ast_cli_entry cli_reload_routing =
2214 { {"lcr", "reload", "routing", NULL},
2215  lcr_reload_routing,
2216  "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2217  "Usage: lcr reload routing\n",
2218 };
2219
2220 static struct ast_cli_entry cli_reload_interfaces =
2221 { {"lcr", "reload", "interfaces", NULL},
2222  lcr_reload_interfaces,
2223  "Reloads interfaces conf of LCR",
2224  "Usage: lcr reload interfaces\n",
2225 };
2226
2227 static struct ast_cli_entry cli_port_block =
2228 { {"lcr", "port", "block", NULL},
2229  lcr_port_block,
2230  "Blocks LCR port for further calls",
2231  "Usage: lcr port block \"<port>\"\n",
2232 };
2233
2234 static struct ast_cli_entry cli_port_unblock =
2235 { {"lcr", "port", "unblock", NULL},
2236  lcr_port_unblock,
2237  "Unblocks or loads LCR port, port is opened my mISDN",
2238  "Usage: lcr port unblock \"<port>\"\n",
2239 };
2240
2241 static struct ast_cli_entry cli_port_unload =
2242 { {"lcr", "port", "unload", NULL},
2243  lcr_port_unload,
2244  "Unloads LCR port, port is closes by mISDN",
2245  "Usage: lcr port unload \"<port>\"\n",
2246 };
2247 #endif
2248
2249
2250
2251 static int lcr_config_exec(struct ast_channel *ast, void *data)
2252 {
2253         struct chan_call *call;
2254
2255         ast_mutex_lock(&chan_lock);
2256         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2257         /* find channel */
2258         call = call_first;
2259         while(call) {
2260                 if (call->ast == ast)
2261                         break;
2262                 call = call->next;
2263         }
2264         if (call)
2265                 apply_opt(call, (char *)data);
2266         else
2267                 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2268
2269         ast_mutex_unlock(&chan_lock);
2270         return 0;
2271 }
2272
2273 /*
2274  * module loading and destruction
2275  */
2276 int load_module(void)
2277 {
2278         u_short i;
2279
2280         for (i = 0; i < 256; i++) {
2281                 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2282                              | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2283         }
2284
2285         if (read_options() == 0) {
2286                 CERROR(NULL, NULL, "%s", options_error);
2287                 return AST_MODULE_LOAD_DECLINE;
2288         }
2289
2290         ast_mutex_init(&chan_lock);
2291         ast_mutex_init(&log_lock);
2292
2293         if (open_socket() < 0) {
2294                 /* continue with closed socket */
2295         }
2296
2297         if (bchannel_initialize()) {
2298                 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2299                 close_socket();
2300                 return AST_MODULE_LOAD_DECLINE;
2301         }
2302         mISDN_created = 1;
2303
2304         lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2305         if (ast_channel_register(&lcr_tech)) {
2306                 CERROR(NULL, NULL, "Unable to register channel class\n");
2307                 bchannel_deinitialize();
2308                 close_socket();
2309                 return AST_MODULE_LOAD_DECLINE;
2310         }
2311
2312         ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2313                                  "lcr_config(<opt><optarg>:<opt>:...)\n"
2314                                  "Sets LCR opts. and optargs\n"
2315                                  "\n"
2316                                  "The available options are:\n"
2317                                  "    d - Send display text on called phone, text is the optarg.\n"
2318                                  "    n - Don't detect dtmf tones on called channel.\n"
2319                                  "    h - Force data call (HDLC).\n"
2320                                  "    t - Disable all audio features (required for fax application).\n"
2321                                  "    c - Make crypted outgoing call, optarg is keyindex.\n"
2322                                  "    e - Perform echo cancelation on this channel.\n"
2323                                  "        Takes mISDN pipeline option as optarg.\n"
2324 //                               "    s - Send Non Inband DTMF as inband.\n"
2325                                  "   vr - rxgain control\n"
2326                                  "   vt - txgain control\n"
2327                                  "        Volume changes at factor 2 ^ optarg.\n"
2328                 );
2329
2330
2331 #if 0
2332         ast_cli_register(&cli_show_lcr);
2333         ast_cli_register(&cli_show_calls);
2334         ast_cli_register(&cli_reload_routing);
2335         ast_cli_register(&cli_reload_interfaces);
2336         ast_cli_register(&cli_port_block);
2337         ast_cli_register(&cli_port_unblock);
2338         ast_cli_register(&cli_port_unload);
2339 #endif
2340
2341         quit = 0;
2342         if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0))
2343         {
2344                 /* failed to create thread */
2345                 bchannel_deinitialize();
2346                 close_socket();
2347                 ast_channel_unregister(&lcr_tech);
2348                 return AST_MODULE_LOAD_DECLINE;
2349         }
2350         return 0;
2351 }
2352
2353 int unload_module(void)
2354 {
2355         /* First, take us out of the channel loop */
2356         CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2357
2358         quit = 1;
2359         pthread_join(chan_tid, NULL);
2360
2361         ast_channel_unregister(&lcr_tech);
2362
2363         ast_unregister_application("lcr_config");
2364
2365
2366         if (mISDN_created) {
2367                 bchannel_deinitialize();
2368                 mISDN_created = 0;
2369         }
2370
2371         if (lcr_sock >= 0) {
2372                 close(lcr_sock);
2373                 lcr_sock = -1;
2374         }
2375
2376         return 0;
2377 }
2378
2379 int reload_module(void)
2380 {
2381 //      reload_config();
2382         return 0;
2383 }
2384
2385
2386 #define AST_MODULE "chan_lcr"
2387
2388 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2389                 .load = load_module,
2390                 .unload = unload_module,
2391                 .reload = reload_module,
2392                );
2393