chan_lcr.c

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