chan_lcr.c

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** Linux Call Router                                                         **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** Asterisk socket client                                                    **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 /*
  13
  14 Registering to LCR:
  15
  16 To connect, open an LCR socket and send a MESSAGE_HELLO to socket with
  17 the application name. This name is unique an can be used for routing calls.
  18 Now the channel driver is linked to LCR and can receive and make calls.
  19
  20
  21 Call is initiated by LCR:
  22
  23 If a call is received from LCR, a MESSAGE_NEWREF is received first.
  24 The ref_was_assigned ist set to 1.
  25 A new chan_call instance is created. The call reference (ref) is given by
  26 the received MESSAGE_NEWREF. The state is CHAN_LCR_STATE_IN_PREPARE.
  27 After receiving MESSAGE_SETUP from LCR, the ast_channel instance is created
  28 using ast_channel_alloc(1).  The setup information is given to asterisk.
  29 The new Asterisk instance pointer (ast) is stored to chan_call structure.
  30 The state changes to CHAN_LCR_STATE_IN_SETUP.
  31
  32
  33 Call is initiated by Asterisk:
  34
  35 If a call is requested from Asterisk, a new chan_call instance is created.
  36 The new Asterisk instance pointer (ast) is stored to chan_call structure.
  37 The current call ref is set to 0, the state is CHAN_LCR_STATE_OUT_PREPARE.
  38 If the call is received (lcr_call) A MESSAGE_NEWREF is sent to LCR requesting
  39 a new call reference (ref).
  40 The ref_was_assigned ist set to 1.
  41 Further dialing information is queued.
  42 After the new callref is received by special MESSAGE_NEWREF reply, new ref
  43 is stored in the chan_call structure.
  44 The setup information is sent to LCR using MESSAGE_SETUP.
  45 The state changes to CHAN_LCR_STATE_OUT_SETUP.
  46
  47
  48 Call is in process:
  49
  50 During call process, messages are received and sent.
  51 The state changes accordingly.
  52 Any message is allowed to be sent to LCR at any time except MESSAGE_RELEASE.
  53 If a MESSAGE_OVERLAP is received, further dialing is required.
  54 Queued dialing information, if any, is sent to LCR using MESSAGE_DIALING.
  55 In this case, the state changes to CHAN_LCR_STATE_OUT_DIALING.
  56
  57
  58 Call is released by LCR:
  59
  60 A MESSAGE_RELEASE is received with the call reference (ref) to be released.
  61 The current ref is set to 0, to indicate released reference.
  62 The ref_was_assigned==1 shows that there is no other ref to be assigned.
  63 The state changes to CHAN_LCR_STATE_RELEASE.
  64 ast_queue_hangup() is called, if asterisk instance (ast) exists, if not,
  65 the chan_call instance is destroyed.
  66 After lcr_hangup() is called-back by Asterisk, the chan_call instance
  67 is destroyed, because the current ref is set to 0 and the state equals
  68 CHAN_LCR_STATE_RELEASE.
  69 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, see the proceedure
  70 "Call is released by Asterisk".
  71
  72
  73 Call is released by Asterisk:
  74
  75 lcr_hangup() is called-back by Asterisk. If the call reference (ref) is set,
  76 a MESSAGE_RELEASE is sent to LCR and the chan_call instance is destroyed.
  77 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, the new state is
  78 set to CHAN_LCR_STATE_RELEASE.
  79 The ref_was_assigned==0 shows that a ref is still requested.
  80 Later, if the MESSAGE_NEWREF reply is received, a MESSAGE_RELEASE is sent to
  81 LCR and the chan_call instance is destroyed.
  82 If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure
  83 "Call is released by LCR".
  84
  85
  86 Locking issues:
  87
  88 The deadlocking problem:
  89
  90 - chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel
  91 to be unlocked.
  92 - ast_channel thread locks ast_channel and calls a tech function and waits
  93 there for chan_lock to be unlocked.
  94
  95 The solution:
  96
  97 Never call ast_queue_xxxx() if ast_channel is not locked and don't wait until
  98 ast_channel can be locked. All messages to asterisk are queued inside call
  99 instance and will be handled using a try-lock to get ast_channel lock.
 100 If it succeeds to lock ast_channel, the ast_queue_xxxx can safely called even
 101 if the lock is incremented and decremented there.
 102
 103 Exception: Calling ast_queue_frame inside ast->tech->read is safe, because
 104 it is called from ast_channel process which has already locked ast_channel.
 105
 106 */
 107
 108
 109 /* Choose if you want to have chan_lcr for Asterisk 1.4.x or CallWeaver 1.2.x */
 110 #define LCR_FOR_ASTERISK
 111 /* #define LCR_FOR_CALLWEAVER */
 112
 113 #include <stdio.h>
 114 #include <stdlib.h>
 115 #include <string.h>
 116 #include <stdarg.h>
 117 #include <errno.h>
 118 #include <sys/types.h>
 119 #include <time.h>
 120 //#include <signal.h>
 121 #include <unistd.h>
 122 #include <fcntl.h>
 123 #include <sys/ioctl.h>
 124 #include <sys/socket.h>
 125 #include <sys/un.h>
 126
 127 #include <semaphore.h>
 128
 129 #define HAVE_ATTRIBUTE_always_inline 1
 130 #define HAVE_ARPA_INET_H 1
 131 #define HAVE_TIMERSUB 1
 132 #define HAVE_STRTOQ 1
 133 #define HAVE_INET_ATON 1
 134
 135 #include <asterisk/compiler.h>
 136 #ifdef LCR_FOR_ASTERISK
 137 #include <asterisk/buildopts.h>
 138 #endif
 139
 140 /*
 141  * Fwd declare struct ast_channel to get rid of gcc warning about
 142  * incompatible pointer type passed to ast_register_application2.
 143  */
 144 struct ast_channel;
 145
 146 #include <asterisk/module.h>
 147 #include <asterisk/channel.h>
 148 #include <asterisk/config.h>
 149 #include <asterisk/logger.h>
 150 #include <asterisk/pbx.h>
 151 #include <asterisk/options.h>
 152 #include <asterisk/io.h>
 153 #include <asterisk/frame.h>
 154 #include <asterisk/translate.h>
 155 #include <asterisk/cli.h>
 156 #include <asterisk/musiconhold.h>
 157 #include <asterisk/dsp.h>
 158 #include <asterisk/translate.h>
 159 #include <asterisk/file.h>
 160 #ifdef LCR_FOR_ASTERISK
 161 #include <asterisk/callerid.h>
 162 #endif
 163 #ifdef LCR_FOR_CALLWEAVER
 164 #include <asterisk/phone_no_utils.h>
 165 #endif
 166
 167 #include <asterisk/indications.h>
 168 #include <asterisk/app.h>
 169 #include <asterisk/features.h>
 170 #include <asterisk/sched.h>
 171 #if ASTERISK_VERSION_NUM < 110000
 172 #include <asterisk/version.h>
 173 #endif
 174 #include "extension.h"
 175 #include "message.h"
 176 #include "callerid.h"
 177 #include "lcrsocket.h"
 178 #include "cause.h"
 179 #include "select.h"
 180 #include "options.h"
 181 #include "chan_lcr.h"
 182
 183 CHAN_LCR_STATE // state description structure
 184 MESSAGES // message text
 185
 186 #ifdef LCR_FOR_CALLWEAVER
 187 AST_MUTEX_DEFINE_STATIC(rand_lock);
 188 #endif
 189
 190 unsigned char flip_bits[256];
 191
 192 #ifdef LCR_FOR_CALLWEAVER
 193 static struct ast_frame nullframe = { AST_FRAME_NULL, };
 194 #endif
 195
 196 int lcr_debug=1;
 197
 198 char lcr_type[]="lcr";
 199
 200 #ifdef LCR_FOR_CALLWEAVER
 201 static ast_mutex_t usecnt_lock;
 202 static int usecnt=0;
 203 static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
 204 #endif
 205
 206 pthread_t chan_tid;
 207 ast_mutex_t chan_lock; /* global lock */
 208 ast_mutex_t log_lock; /* logging log */
 209 /* global_change:
 210  * used to indicate change in file descriptors, so select function's result may
 211  * be obsolete.
 212  */
 213 int global_change = 0;
 214 int wake_global = 0;
 215 int wake_pipe[2];
 216 struct lcr_fd wake_fd;
 217
 218 int glob_channel = 0;
 219
 220 int lcr_sock = -1;
 221 struct lcr_fd socket_fd;
 222 struct lcr_timer socket_retry;
 223
 224 struct admin_list {
 225         struct admin_list *next;
 226         struct admin_message msg;
 227 } *admin_first = NULL;
 228
 229 static struct ast_channel_tech lcr_tech;
 230
 231 /*
 232  * logging
 233  */
 234 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, ...)
 235 {
 236         char buffer[1024];
 237         char call_text[128] = "NULL";
 238         char ast_text[128] = "NULL";
 239         va_list args;
 240
 241         ast_mutex_lock(&log_lock);
 242
 243         va_start(args,fmt);
 244         vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
 245         buffer[sizeof(buffer)-1]=0;
 246         va_end(args);
 247
 248         if (call)
 249                 sprintf(call_text, "%d", call->ref);
 250         if (ast)
 251 #if ASTERISK_VERSION_NUM < 110000
 252                 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
 253 #else
 254                 strncpy(ast_text, ast_channel_name(ast), sizeof(ast_text)-1);
 255 #endif
 256         ast_text[sizeof(ast_text)-1] = '\0';
 257
 258 //      ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
 259         printf("[call=%s ast=%s line=%d] %s", call_text, ast_text, line, buffer);
 260
 261         ast_mutex_unlock(&log_lock);
 262 }
 263
 264 /*
 265  * channel and call instances
 266  */
 267 struct chan_call *call_first;
 268
 269 /*
 270  * find call by ref
 271  * special case: 0: find new ref, that has not been assigned a ref yet
 272  */
 273
 274 struct chan_call *find_call_ref(unsigned int ref)
 275 {
 276         struct chan_call *call = call_first;
 277         int assigned = (ref > 0);
 278
 279         while(call) {
 280                 if (call->ref == ref && call->ref_was_assigned == assigned)
 281                         break;
 282                 call = call->next;
 283         }
 284         return call;
 285 }
 286
 287 void free_call(struct chan_call *call)
 288 {
 289         struct chan_call **temp = &call_first;
 290
 291         while(*temp) {
 292                 if (*temp == call) {
 293                         *temp = (*temp)->next;
 294                         if (call->pipe[0] > -1)
 295                                 close(call->pipe[0]);
 296                         if (call->pipe[1] > -1)
 297                                 close(call->pipe[1]);
 298                         if (call->bridge_call) {
 299                                 if (call->bridge_call->bridge_call != call)
 300                                         CERROR(call, NULL, "Linked call structure has no link to us.\n");
 301                                 call->bridge_call->bridge_call = NULL;
 302                         }
 303                         if (call->trans)
 304                                 ast_translator_free_path(call->trans);
 305                         if (call->dsp)
 306                                 ast_dsp_free(call->dsp);
 307                         CDEBUG(call, NULL, "Call instance freed.\n");
 308                         free(call);
 309                         global_change = 1;
 310                         return;
 311                 }
 312                 temp = &((*temp)->next);
 313         }
 314         CERROR(call, NULL, "Call instance not found in list.\n");
 315 }
 316
 317 struct chan_call *alloc_call(void)
 318 {
 319         struct chan_call **callp = &call_first;
 320
 321         while(*callp)
 322                 callp = &((*callp)->next);
 323
 324         *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
 325         if (*callp)
 326                 memset(*callp, 0, sizeof(struct chan_call));
 327         if (pipe((*callp)->pipe) < 0) {
 328                 CERROR(*callp, NULL, "Failed to create pipe.\n");
 329                 free_call(*callp);
 330                 return NULL;
 331         }
 332         fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
 333         CDEBUG(*callp, NULL, "Call instance allocated.\n");
 334         return *callp;
 335 }
 336
 337 unsigned short new_bridge_id(void)
 338 {
 339         struct chan_call *call;
 340         unsigned short id = 1;
 341
 342         /* search for lowest bridge id that is not in use and not 0 */
 343         while(id) {
 344                 call = call_first;
 345                 while(call) {
 346                         if (call->bridge_id == id)
 347                                 break;
 348                         call = call->next;
 349                 }
 350                 if (!call)
 351                         break;
 352                 id++;
 353         }
 354         CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
 355         return id;
 356 }
 357
 358 /*
 359  * enque message to LCR
 360  */
 361 int send_message(int message_type, unsigned int ref, union parameter *param)
 362 {
 363         struct admin_list *admin, **adminp;
 364
 365         if (lcr_sock < 0) {
 366                 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
 367                 return -1;
 368         }
 369         if (message_type != MESSAGE_TRAFFIC)
 370                 CDEBUG(NULL, NULL, "Sending %s to socket. (ref=%d)\n", messages_txt[message_type], ref);
 371
 372         adminp = &admin_first;
 373         while(*adminp)
 374                 adminp = &((*adminp)->next);
 375         admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
 376         if (!admin) {
 377                 CERROR(NULL, NULL, "No memory for message to LCR.\n");
 378                 return -1;
 379         }
 380         *adminp = admin;
 381
 382         admin->msg.message = ADMIN_MESSAGE;
 383         admin->msg.u.msg.type = message_type;
 384         admin->msg.u.msg.ref = ref;
 385         memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
 386         socket_fd.when |= LCR_FD_WRITE;
 387         if (!wake_global) {
 388                 wake_global = 1;
 389                 char byte = 0;
 390                 int rc;
 391                 rc = write(wake_pipe[1], &byte, 1);
 392         }
 393
 394         return 0;
 395 }
 396
 397 /*
 398  * apply options (in locked state)
 399  */
 400 void apply_opt(struct chan_call *call, char *data)
 401 {
 402         union parameter newparam;
 403         char string[1024], *p = string, *opt;//, *key;
 404 //      int gain, i;
 405
 406         if (!data[0])
 407                 return; // no opts
 408
 409         strncpy(string, data, sizeof(string)-1);
 410         string[sizeof(string)-1] = '\0';
 411
 412         /* parse options */
 413         while((opt = strsep(&p, ":"))) {
 414                 switch(opt[0]) {
 415                 case 'd':
 416                         if (opt[1] == '\0') {
 417                                 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
 418                                 break;
 419                         }
 420                         CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
 421                         if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
 422                                 strncpy(call->display, opt+1, sizeof(call->display)-1);
 423                         else {
 424                                 memset(&newparam, 0, sizeof(union parameter));
 425                                 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
 426                                 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
 427                         }
 428                         break;
 429                 case 'n':
 430                         if (opt[1] != '\0') {
 431                                 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
 432                                 break;
 433                         }
 434                         CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
 435                         call->dsp_dtmf = 0;
 436                         break;
 437 #if 0
 438                 case 'c':
 439                         if (opt[1] == '\0') {
 440                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
 441                                 break;
 442                         }
 443                         key = opt+1;
 444                         /* check for 0xXXXX... type of key */
 445                         if (!!strncmp((char *)key, "0x", 2)) {
 446                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
 447                                 break;
 448                         }
 449                         key+=2;
 450                         if (strlen(key) > 56*2 || (strlen(key) % 1)) {
 451                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
 452                                 break;
 453                         }
 454                         i = 0;
 455                         while(*key) {
 456                                 if (*key>='0' && *key<='9')
 457                                         call->bf_key[i] = (*key-'0') << 8;
 458                                 else if (*key>='a' && *key<='f')
 459                                         call->bf_key[i] = (*key-'a'+10) << 8;
 460                                 else if (*key>='A' && *key<='F')
 461                                         call->bf_key[i] = (*key-'A'+10) << 8;
 462                                 else
 463                                         break;
 464                                 key++;
 465                                 if (*key>='0' && *key<='9')
 466                                         call->bf_key[i] += (*key - '0');
 467                                 else if (*key>='a' && *key<='f')
 468                                         call->bf_key[i] += (*key - 'a' + 10);
 469                                 else if (*key>='A' && *key<='F')
 470                                         call->bf_key[i] += (*key - 'A' + 10);
 471                                 else
 472                                         break;
 473                                 key++;
 474                                 i++;
 475                         }
 476                         if (*key) {
 477                                 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
 478                                 break;
 479                         }
 480                         call->bf_len = i;
 481                         CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
 482                         if (call->bchannel)
 483                                 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
 484                         break;
 485 #endif
 486                 case 'h':
 487                         if (opt[1] != '\0') {
 488                                 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
 489                                 break;
 490                         }
 491                         CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
 492                         if (!call->hdlc)
 493                                 call->hdlc = 1;
 494                         break;
 495                 case 'q':
 496                         if (opt[1] == '\0') {
 497                                 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
 498                                 break;
 499                         }
 500                         CDEBUG(call, call->ast, "Option 'q' (queue).\n");
 501                         call->tx_queue = atoi(opt+1);
 502                         break;
 503 #if 0
 504                 case 'e':
 505                         if (opt[1] == '\0') {
 506                                 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
 507                                 break;
 508                         }
 509                         CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
 510                         strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
 511                         if (call->bchannel)
 512                                 bchannel_pipeline(call->bchannel, call->pipeline);
 513                         break;
 514 #endif
 515                 case 'f':
 516                         if (opt[1] == '\0') {
 517                                 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
 518                                 break;
 519                         }
 520                         call->faxdetect=atoi(opt+1);
 521                         if (!call->dsp)
 522                                 call->dsp=ast_dsp_new();
 523                         if (call->dsp) {
 524                                 #ifdef LCR_FOR_CALLWEAVER
 525                                 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
 526                                 #endif
 527                                 #ifdef LCR_FOR_ASTERISK
 528                                 #ifdef DSP_FEATURE_DTMF_DETECT
 529                                 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
 530                                 #else
 531                                 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
 532                                 #endif
 533
 534                                 #endif
 535                                 if (!call->trans) {
 536                                         #ifdef LCR_FOR_CALLWEAVER
 537                                         call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
 538                                         #endif
 539                                         #ifdef LCR_FOR_ASTERISK
 540                                         #if ASTERISK_VERSION_NUM < 100000
 541                                         call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
 542                                         #else
 543                                         struct ast_format src;
 544                                         struct ast_format dst;
 545                                         ast_format_set(&dst, AST_FORMAT_SLINEAR, 0);
 546                                         ast_format_set(&dst,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
 547                                         call->trans=ast_translator_build_path(&dst, &src);
 548                                         #endif
 549                                         #endif
 550                                 }
 551                         }
 552                         CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
 553                         break;
 554                 case 'r':
 555                         if (opt[1] != '\0') {
 556                                 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
 557                                 break;
 558                         }
 559                         CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
 560                         call->rebuffer = 1;
 561                         call->framepos = 0;
 562                         break;
 563                 case 's':
 564                         if (opt[1] != '\0') {
 565                                 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
 566                                 break;
 567                         }
 568                         CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
 569                         call->inband_dtmf = 1;
 570                         break;
 571 #if 0
 572                 case 'v':
 573                         if (opt[1] != 'r' && opt[1] != 't') {
 574                                 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
 575                                 break;
 576                         }
 577                         gain = atoi(opt+2);
 578                         if (gain < -8 || gain >8) {
 579                                 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
 580                                 break;
 581                         }
 582                         CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
 583                         if (opt[1] == 'r') {
 584                                 call->rx_gain = gain;
 585                                 if (call->bchannel)
 586                                         bchannel_gain(call->bchannel, call->rx_gain, 0);
 587                         } else {
 588                                 call->tx_gain = gain;
 589                                 if (call->bchannel)
 590                                         bchannel_gain(call->bchannel, call->tx_gain, 1);
 591                         }
 592                         break;
 593 #endif
 594                 case 'k':
 595                         if (opt[1] != '\0') {
 596                                 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
 597                                 break;
 598                         }
 599                         CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
 600                         if (!call->keypad)
 601                                 call->keypad = 1;
 602                         break;
 603                 default:
 604                         CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
 605                 }
 606         }
 607 }
 608
 609 /*
 610  * send setup info to LCR
 611  * this function is called, when asterisk call is received and ref is received
 612  */
 613 static void send_setup_to_lcr(struct chan_call *call)
 614 {
 615         union parameter newparam;
 616         struct ast_channel *ast = call->ast;
 617 //      const char *tmp;
 618
 619         if (!call->ast || !call->ref)
 620                 return;
 621
 622 #ifdef AST_1_8_OR_HIGHER
 623         CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->callerinfo.id);
 624 #else
 625         CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
 626 #endif
 627
 628         /* send setup message to LCR */
 629         memset(&newparam, 0, sizeof(union parameter));
 630         newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
 631         newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
 632         if (call->keypad)
 633                 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
 634         else
 635                 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
 636         if (!!strcmp(call->interface, "pbx"))
 637                 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
 638         newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
 639         newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 640         strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
 641         call->display[0] = '\0';
 642
 643 #ifdef AST_1_8_OR_HIGHER
 644         /* set stored call information */
 645         memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
 646         memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
 647 #else
 648         if (call->cid_num[0])
 649                 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
 650         if (call->cid_name[0])
 651                 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
 652         if (call->cid_rdnis[0]) {
 653                 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
 654                 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
 655                 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
 656         }
 657         switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
 658                 case AST_PRES_RESTRICTED:
 659                 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
 660                 break;
 661                 case AST_PRES_UNAVAILABLE:
 662                 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
 663                 break;
 664                 case AST_PRES_ALLOWED:
 665                 default:
 666                 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
 667         }
 668         switch(ast->cid.cid_ton) {
 669                 case 4:
 670                 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
 671                 break;
 672                 case 2:
 673                 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
 674                 break;
 675                 case 1:
 676                 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
 677                 break;
 678                 default:
 679                 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 680         }
 681 #endif
 682 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
 683 //      tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
 684 //      if (tmp && *tmp)
 685 #if ASTERISK_VERSION_NUM < 110000
 686 //              ast->transfercapability = atoi(tmp);
 687         newparam.setup.capainfo.bearer_capa = ast->transfercapability;
 688 #else
 689 //              ast_channel_transfercapability_set(ast, atoi(tmp));
 690         newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
 691 #endif
 692         newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
 693         if (call->hdlc)
 694                 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
 695         else {
 696                 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
 697                 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
 698         }
 699         newparam.setup.capainfo.hlc = INFO_HLC_NONE;
 700         newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
 701         send_message(MESSAGE_SETUP, call->ref, &newparam);
 702         if (call->tx_queue) {
 703                 memset(&newparam, 0, sizeof(union parameter));
 704                 newparam.queue = call->tx_queue * 8;
 705                 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
 706         }
 707
 708         /* change to outgoing setup state */
 709         call->state = CHAN_LCR_STATE_OUT_SETUP;
 710 }
 711
 712 /*
 713  * send dialing info to LCR
 714  * this function is called, when setup acknowledge is received and dialing
 715  * info is available.
 716  */
 717 static void send_dialque_to_lcr(struct chan_call *call)
 718 {
 719         union parameter newparam;
 720
 721         if (!call->ast || !call->ref || !call->dialque[0])
 722                 return;
 723
 724         CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
 725
 726         /* send setup message to LCR */
 727         memset(&newparam, 0, sizeof(union parameter));
 728         if (call->keypad)
 729                 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
 730         else
 731                 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
 732         call->dialque[0] = '\0';
 733         send_message(MESSAGE_INFORMATION, call->ref, &newparam);
 734 }
 735
 736 /*
 737  * in case of a bridge, the unsupported message can be forwarded directly
 738  * to the remote call.
 739  */
 740 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
 741 {
 742         /* check bridge */
 743         if (!call) return;
 744         if (!call->bridge_call) return;
 745         CDEBUG(call, NULL, "Sending message due bridging.\n");
 746         send_message(message_type, call->bridge_call->ref, param);
 747 }
 748
 749 /*
 750  * send release message to LCR
 751  */
 752 static void send_release(struct chan_call *call, int cause, int location)
 753 {
 754         union parameter newparam;
 755
 756         /* sending release */
 757         memset(&newparam, 0, sizeof(union parameter));
 758         newparam.disconnectinfo.cause = cause;
 759         newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
 760         send_message(MESSAGE_RELEASE, call->ref, &newparam);
 761 }
 762
 763 /*
 764  * check if extension matches and start asterisk
 765  * if it can match, proceed
 766  * if not, release
 767  */
 768 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
 769 {
 770         int cause, ret;
 771         union parameter newparam;
 772 #if ASTERISK_VERSION_NUM < 110000
 773         char *exten = ast->exten;
 774 #else
 775         char s_exten[AST_MAX_EXTENSION];
 776         char *exten=s_exten;
 777
 778         strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
 779 #endif
 780
 781 if (!*exten)
 782                 exten = "s";
 783
 784 #if ASTERISK_VERSION_NUM < 110000
 785         CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
 786 #else
 787         CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
 788 #endif
 789
 790         if (complete) {
 791                 /* if not match */
 792 #if ASTERISK_VERSION_NUM < 110000
 793                 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
 794 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
 795 #else
 796                 if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 797 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
 798 #endif
 799                         cause = 1;
 800                         goto release;
 801                 }
 802 #if ASTERISK_VERSION_NUM < 110000
 803                 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
 804                         CDEBUG(call, ast, "Got 'sending complete', but extension '%s' would match at context '%s', if more digits would be dialed - releasing.\n", exten, ast->context);
 805 #else
 806                 if (!ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 807                         CDEBUG(call, ast, "Got 'sending complete', but extension '%s' would match at context '%s', if more digits would be dialed - releasing.\n", exten, ast_channel_context(ast));
 808 #endif
 809                         cause = 28;
 810                         goto release;
 811                 }
 812                 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
 813                 /* send setup acknowledge to lcr */
 814                 memset(&newparam, 0, sizeof(union parameter));
 815                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
 816
 817                 /* change state */
 818                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
 819
 820                 goto start;
 821         }
 822
 823 #if ASTERISK_VERSION_NUM < 110000
 824         if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
 825 #else
 826         if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 827 #endif
 828                 /* send setup acknowledge to lcr */
 829                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 830                         memset(&newparam, 0, sizeof(union parameter));
 831                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 832                 }
 833
 834                 /* change state */
 835                 call->state = CHAN_LCR_STATE_IN_DIALING;
 836
 837                 /* if match, start pbx */
 838 #if ASTERISK_VERSION_NUM < 110000
 839         if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
 840 #else
 841         if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 842 #endif
 843                         CDEBUG(call, ast, "Extensions matches.\n");
 844                         goto start;
 845                 }
 846
 847                 /* send setup acknowledge to lcr */
 848                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 849                         memset(&newparam, 0, sizeof(union parameter));
 850                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 851                 }
 852
 853                 /* change state */
 854                 call->state = CHAN_LCR_STATE_IN_DIALING;
 855
 856                 /* if can match */
 857                 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
 858                 return;
 859         }
 860
 861 #if ASTERISK_VERSION_NUM < 110000
 862         if (!*ast->exten) {
 863 #else
 864         if (!*ast_channel_exten(ast)) {
 865 #endif
 866                 /* send setup acknowledge to lcr */
 867                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 868                         memset(&newparam, 0, sizeof(union parameter));
 869                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 870                 }
 871
 872                 /* change state */
 873                 call->state = CHAN_LCR_STATE_IN_DIALING;
 874
 875                 /* if can match */
 876                 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
 877                 return;
 878         }
 879
 880         /* if not match */
 881         cause = 1;
 882         release:
 883         /* release lcr */
 884         CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
 885         send_release(call, cause, LOCATION_PRIVATE_LOCAL);
 886         call->ref = 0;
 887         /* release asterisk */
 888 #if ASTERISK_VERSION_NUM < 110000
 889         ast->hangupcause = call->cause;
 890 #else
 891         ast_channel_hangupcause_set(ast, call->cause);
 892 #endif
 893         /* change to release state */
 894         call->state = CHAN_LCR_STATE_RELEASE;
 895         ast_hangup(ast); // call will be destroyed here
 896         return;
 897
 898         start:
 899         /* send setup to asterisk */
 900         CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
 901
 902         #ifdef LCR_FOR_CALLWEAVER
 903         ast->type = "LCR";
 904         snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
 905         #endif
 906
 907         ret = ast_pbx_start(ast);
 908         if (ret < 0) {
 909                 cause = (ret==-2)?34:27;
 910                 goto release;
 911         }
 912         call->pbx_started = 1;
 913                 ast_setstate(ast, AST_STATE_RING);
 914 }
 915
 916 /*
 917  * incoming setup from LCR
 918  */
 919 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
 920 {
 921         struct ast_channel *ast;
 922 #ifdef AST_1_8_OR_HIGHER
 923         struct ast_party_redirecting *ast_redir;
 924 #endif
 925 //      struct ast_party_caller *ast_caller;
 926         struct ast_callerid *ast_caller;
 927 #if ASTERISK_VERSION_NUM >= 110000
 928         struct ast_party_redirecting s_ast_redir;
 929         struct ast_party_caller s_ast_caller;
 930         ast_party_redirecting_init(&s_ast_redir);
 931         ast_party_caller_init(&s_ast_caller);
 932 #endif
 933         CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
 934
 935         /* create asterisk channel instrance */
 936
 937         #ifdef LCR_FOR_CALLWEAVER
 938         ast = ast_channel_alloc(1);
 939         #endif
 940
 941         #ifdef LCR_FOR_ASTERISK
 942 #ifdef AST_1_8_OR_HIGHER
 943         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
 944 #else
 945         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
 946 #endif
 947         #endif
 948
 949 #if ASTERISK_VERSION_NUM < 110000
 950 //      ast_redir = &ast->redirecting;
 951 //      ast_caller = &ast->caller;
 952         ast_caller = &ast->cid;
 953 #else
 954         ast_redir = &s_ast_redir;
 955         ast_caller = &s_ast_caller;
 956 #endif
 957
 958         if (!ast) {
 959                 /* release */
 960                 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
 961                 send_release(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
 962                 /* remove call */
 963                 free_call(call);
 964                 return;
 965         }
 966         /* link together */
 967         call->ast = ast;
 968 #if ASTERISK_VERSION_NUM < 110000
 969         ast->tech_pvt = call;
 970         ast->tech = &lcr_tech;
 971         ast->fds[0] = call->pipe[0];
 972 #else
 973         ast_channel_tech_pvt_set(ast, call);
 974         ast_channel_tech_set(ast, &lcr_tech);
 975         ast_channel_set_fd(ast, 0, call->pipe[0]);
 976 #endif
 977
 978         /* fill setup information */
 979         if (param->setup.dialinginfo.id)
 980 #if ASTERISK_VERSION_NUM < 110000
 981                 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
 982         if (param->setup.dialinginfo.context[0])
 983                 strncpy(ast->context, param->setup.dialinginfo.context, AST_MAX_CONTEXT-1);
 984         else
 985                 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
 986 #else
 987                 ast_channel_exten_set(ast, param->setup.dialinginfo.id);
 988         if (param->setup.context[0])
 989                 ast_channel_context_set(ast, param->setup.context);
 990         else
 991                 ast_channel_context_set(ast, param->setup.callerinfo.interface);
 992 #endif
 993
 994
 995 #ifdef AST_1_8_OR_HIGHER
 996         if (param->setup.callerinfo.id[0]) {
 997                 ast_caller->id.number.valid = 1;
 998                 ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
 999                 if (!param->setup.callerinfo.id[0]) {
1000                         ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1001                         ast_caller->id.number.plan = (0 << 4) | 1;
1002                 }
1003                 switch (param->setup.callerinfo.present) {
1004                         case INFO_PRESENT_ALLOWED:
1005                                 ast_caller->id.number.presentation = AST_PRES_ALLOWED;
1006                         break;
1007                         case INFO_PRESENT_RESTRICTED:
1008                                 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1009                         break;
1010                         default:
1011                                 ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
1012                 }
1013                 switch (param->setup.callerinfo.screen) {
1014                         case INFO_SCREEN_USER:
1015                                 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1016                         break;
1017                         case INFO_SCREEN_USER_VERIFIED_PASSED:
1018                                 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1019                         break;
1020                         case INFO_SCREEN_USER_VERIFIED_FAILED:
1021                                 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1022                         break;
1023                         default:
1024                                 ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
1025                 }
1026                 switch (param->setup.callerinfo.ntype) {
1027                         case INFO_NTYPE_SUBSCRIBER:
1028                                 ast_caller->id.number.plan = (4 << 4) | 1;
1029                         break;
1030                         case INFO_NTYPE_NATIONAL:
1031                                 ast_caller->id.number.plan = (2 << 4) | 1;
1032                         break;
1033                         case INFO_NTYPE_INTERNATIONAL:
1034                                 ast_caller->id.number.plan = (1 << 4) | 1;
1035                         break;
1036                         default:
1037                                 ast_caller->id.number.plan = (0 << 4) | 1;
1038                 }
1039         }
1040         if (param->setup.callerinfo.id2[0]) {
1041                 ast_caller->ani.number.valid = 1;
1042                 ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
1043                 switch (param->setup.callerinfo.present2) {
1044                         case INFO_PRESENT_ALLOWED:
1045                                 ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
1046                         break;
1047                         case INFO_PRESENT_RESTRICTED:
1048                                 ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
1049                         break;
1050                         default:
1051                                 ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
1052                 }
1053                 switch (param->setup.callerinfo.screen2) {
1054                         case INFO_SCREEN_USER:
1055                                 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1056                         break;
1057                         case INFO_SCREEN_USER_VERIFIED_PASSED:
1058                                 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1059                         break;
1060                         case INFO_SCREEN_USER_VERIFIED_FAILED:
1061                                 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1062                         break;
1063                         default:
1064                                 ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
1065                 }
1066                 switch (param->setup.callerinfo.ntype2) {
1067                         case INFO_NTYPE_SUBSCRIBER:
1068                                 ast_caller->ani.number.plan = (4 << 4) | 1;
1069                         break;
1070                         case INFO_NTYPE_NATIONAL:
1071                                 ast_caller->ani.number.plan = (2 << 4) | 1;
1072                         break;
1073                         case INFO_NTYPE_INTERNATIONAL:
1074                                 ast_caller->ani.number.plan = (1 << 4) | 1;
1075                         break;
1076                         default:
1077                                 ast_caller->ani.number.plan = (0 << 4) | 1;
1078                 }
1079         }
1080         if (param->setup.callerinfo.name[0]) {
1081                 ast_caller->id.name.valid = 1;
1082                 ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
1083         }
1084 #if ASTERISK_VERSION_NUM >= 110000
1085         ast_channel_caller_set(ast, ast_caller);
1086 #endif
1087         if (param->setup.redirinfo.id[0]) {
1088                 ast_redir->from.number.valid = 1;
1089                 ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
1090                 switch (param->setup.redirinfo.present) {
1091                         case INFO_PRESENT_ALLOWED:
1092                                 ast_redir->from.number.presentation = AST_PRES_ALLOWED;
1093                         break;
1094                         case INFO_PRESENT_RESTRICTED:
1095                                 ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
1096                         break;
1097                         default:
1098                                 ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
1099                 }
1100                 switch (param->setup.redirinfo.screen) {
1101                         case INFO_SCREEN_USER:
1102                                 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1103                         break;
1104                         case INFO_SCREEN_USER_VERIFIED_PASSED:
1105                                 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1106                         break;
1107                         case INFO_SCREEN_USER_VERIFIED_FAILED:
1108                                 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1109                         break;
1110                         default:
1111                                 ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
1112                 }
1113                 switch (param->setup.redirinfo.ntype) {
1114                         case INFO_NTYPE_SUBSCRIBER:
1115                                 ast_redir->from.number.plan = (4 << 4) | 1;
1116                         break;
1117                         case INFO_NTYPE_NATIONAL:
1118                                 ast_redir->from.number.plan = (2 << 4) | 1;
1119                         break;
1120                         case INFO_NTYPE_INTERNATIONAL:
1121                                 ast_redir->from.number.plan = (1 << 4) | 1;
1122                         break;
1123                         default:
1124                                 ast_redir->from.number.plan = (0 << 4) | 1;
1125                 }
1126 #if ASTERISK_VERSION_NUM >= 110000
1127                 ast_channel_redirecting_set(ast, ast_redir);
1128 #endif
1129         }
1130 #else
1131         memset(&ast->cid, 0, sizeof(ast->cid));
1132         if (param->setup.callerinfo.id[0])
1133                 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
1134         if (param->setup.callerinfo.id2[0])
1135                 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
1136         if (param->setup.callerinfo.name[0])
1137                 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
1138         if (param->setup.redirinfo.id[0])
1139                 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
1140         switch (param->setup.callerinfo.present) {
1141                 case INFO_PRESENT_ALLOWED:
1142                         ast->cid.cid_pres = AST_PRES_ALLOWED;
1143                 break;
1144                 case INFO_PRESENT_RESTRICTED:
1145                         ast->cid.cid_pres = AST_PRES_RESTRICTED;
1146                 break;
1147                 default:
1148                         ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
1149         }
1150         switch (param->setup.callerinfo.ntype) {
1151                 case INFO_NTYPE_SUBSCRIBER:
1152                         ast->cid.cid_ton = 4;
1153                 break;
1154                 case INFO_NTYPE_NATIONAL:
1155                         ast->cid.cid_ton = 2;
1156                 break;
1157                 case INFO_NTYPE_INTERNATIONAL:
1158                         ast->cid.cid_ton = 1;
1159                 break;
1160                 default:
1161                         ast->cid.cid_ton = 0;
1162         }
1163 #endif
1164
1165 #if ASTERISK_VERSION_NUM < 110000
1166         ast->transfercapability = param->setup.capainfo.bearer_capa;
1167 #else
1168         ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
1169 #endif
1170         /* enable hdlc if transcap is data */
1171         if (param->setup.capainfo.source_mode == B_MODE_HDLC)
1172                 call->hdlc = 1;
1173         strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
1174
1175         /* configure channel */
1176 #if ASTERISK_VERSION_NUM < 100000
1177         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1178         ast->readformat = ast->rawreadformat = ast->nativeformats;
1179         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
1180 #else
1181 #if ASTERISK_VERSION_NUM < 110000
1182         ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1183         ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
1184         ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
1185         ast_set_write_format(ast, &ast->rawwriteformat);
1186         ast_set_read_format(ast, &ast->rawreadformat);
1187 #else
1188         ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1189         ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
1190         ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
1191         ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
1192         ast_set_read_format(ast, ast_channel_rawreadformat(ast));
1193 #endif
1194 #endif
1195 #if ASTERISK_VERSION_NUM < 110000
1196         ast->priority = 1;
1197         ast->hangupcause = 0;
1198 #else
1199         ast_channel_priority_set(ast, 1);
1200         ast_channel_hangupcause_set(ast, 0);
1201 #endif
1202
1203         /* change state */
1204         call->state = CHAN_LCR_STATE_IN_SETUP;
1205
1206         if (!call->pbx_started)
1207                 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
1208 }
1209
1210 /*
1211  * incoming setup acknowledge from LCR
1212  */
1213 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
1214 {
1215         if (!call->ast) return;
1216
1217         CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
1218
1219         /* send pending digits in dialque */
1220         if (call->dialque[0])
1221                 send_dialque_to_lcr(call);
1222         /* change to overlap state */
1223         call->state = CHAN_LCR_STATE_OUT_DIALING;
1224 }
1225
1226 /*
1227  * incoming proceeding from LCR
1228  */
1229 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
1230 {
1231         CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
1232
1233         /* change state */
1234         call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
1235         /* queue event for asterisk */
1236         if (call->ast && call->pbx_started) {
1237                 if (!wake_global) {
1238                         wake_global = 1;
1239                         char byte = 0;
1240                         int rc;
1241                         rc = write(wake_pipe[1], &byte, 1);
1242                 }
1243                 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
1244         }
1245
1246 }
1247
1248 /*
1249  * incoming alerting from LCR
1250  */
1251 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
1252 {
1253         CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
1254
1255         /* change state */
1256         call->state = CHAN_LCR_STATE_OUT_ALERTING;
1257         /* queue event to asterisk */
1258         if (call->ast && call->pbx_started) {
1259                 if (!wake_global) {
1260                         wake_global = 1;
1261                         char byte = 0;
1262                         int rc;
1263                         rc = write(wake_pipe[1], &byte, 1);
1264                 }
1265                 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1266         }
1267 }
1268
1269 /*
1270  * incoming connect from LCR
1271  */
1272 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1273 {
1274         CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1275
1276         /* change state */
1277         call->state = CHAN_LCR_STATE_CONNECT;
1278         /* copy connectinfo */
1279         memcpy(&call->connectinfo, &param->connectinfo, sizeof(struct connect_info));
1280         /* queue event to asterisk */
1281         if (call->ast && call->pbx_started) {
1282                 if (!wake_global) {
1283                         wake_global = 1;
1284                         char byte = 0;
1285                         int rc;
1286                         rc = write(wake_pipe[1], &byte, 1);
1287                 }
1288                 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1289         }
1290 }
1291
1292 /*
1293  * incoming disconnect from LCR
1294  */
1295 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1296 {
1297         struct ast_channel *ast = call->ast;
1298
1299         CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1300
1301         /* change state */
1302         call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1303         /* save cause */
1304         call->cause = param->disconnectinfo.cause;
1305         call->location = param->disconnectinfo.location;
1306         /* if bridge, forward disconnect and return */
1307 #ifdef TODO
1308         feature flag
1309         if (call->bridge_call) {
1310                 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1311                 bridge_message_if_bridged(call, message_type, param);
1312                 return;
1313         }
1314 #endif
1315         /* release lcr with same cause */
1316         send_release(call, call->cause, call->location);
1317         call->ref = 0;
1318         /* change to release state */
1319         call->state = CHAN_LCR_STATE_RELEASE;
1320         /* queue release asterisk */
1321         if (ast) {
1322 #if ASTERISK_VERSION_NUM < 110000
1323                 ast->hangupcause = call->cause;
1324 #else
1325                 ast_channel_hangupcause_set(ast, call->cause);
1326 #endif
1327                 if (call->pbx_started) {
1328                         if (!wake_global) {
1329                                 wake_global = 1;
1330                                 char byte = 0;
1331                                 int rc;
1332                                 rc = write(wake_pipe[1], &byte, 1);
1333                         }
1334                         strcpy(call->queue_string, "H"); // overwrite other indications
1335                 } else {
1336                         ast_hangup(ast); // call will be destroyed here
1337                 }
1338         }
1339 }
1340
1341 /*
1342  * incoming release from LCR
1343  */
1344 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1345 {
1346         struct ast_channel *ast = call->ast;
1347
1348         CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1349
1350         /* release ref */
1351         call->ref = 0;
1352         /* change to release state */
1353         call->state = CHAN_LCR_STATE_RELEASE;
1354         /* copy release info */
1355         if (!call->cause) {
1356                 call->cause = param->disconnectinfo.cause;
1357                 call->location = param->disconnectinfo.location;
1358         }
1359         /* if we have an asterisk instance, queue hangup, else we are done */
1360         if (ast) {
1361 #if ASTERISK_VERSION_NUM < 110000
1362                 ast->hangupcause = call->cause;
1363 #else
1364                 ast_channel_hangupcause_set(ast, call->cause);
1365 #endif
1366                 if (call->pbx_started) {
1367                         if (!wake_global) {
1368                                 wake_global = 1;
1369                                 char byte = 0;
1370                                 int rc;
1371                                 rc = write(wake_pipe[1], &byte, 1);
1372                         }
1373                         strcpy(call->queue_string, "H");
1374                 } else {
1375                         ast_hangup(ast); // call will be destroyed here
1376                 }
1377         } else {
1378                 free_call(call);
1379         }
1380
1381 }
1382
1383 /*
1384  * incoming information from LCR
1385  */
1386 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1387 {
1388         struct ast_channel *ast = call->ast;
1389
1390         CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1391
1392         if (!ast) return;
1393
1394         /* pbx not started */
1395         if (!call->pbx_started) {
1396                 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1397 #if ASTERISK_VERSION_NUM < 110000
1398                 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1399 #else
1400                 ast_channel_exten_set(ast, param->information.id);
1401 #endif
1402                 lcr_start_pbx(call, ast, param->information.sending_complete);
1403                 return;
1404         }
1405
1406         /* change dailing state after setup */
1407         if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1408                 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1409                 call->state = CHAN_LCR_STATE_IN_DIALING;
1410 //              ast_setstate(ast, AST_STATE_DIALING);
1411         }
1412
1413         /* queue digits */
1414         if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1415                 if (!wake_global) {
1416                         wake_global = 1;
1417                         char byte = 0;
1418                         int rc;
1419                         rc = write(wake_pipe[1], &byte, 1);
1420                 }
1421                 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1422         }
1423
1424         /* use bridge to forware message not supported by asterisk */
1425         if (call->state == CHAN_LCR_STATE_CONNECT) {
1426                 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1427                 bridge_message_if_bridged(call, message_type, param);
1428         }
1429 }
1430
1431 /*
1432  * incoming information from LCR
1433  */
1434 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1435 {
1436         CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1437
1438         if (!call->ast) return;
1439
1440         /* use bridge to forware message not supported by asterisk */
1441         bridge_message_if_bridged(call, message_type, param);
1442 }
1443
1444 /*
1445  * incoming information from LCR
1446  */
1447 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1448 {
1449         CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1450
1451         if (!call->ast) return;
1452
1453         /* use bridge to forware message not supported by asterisk */
1454         bridge_message_if_bridged(call, message_type, param);
1455 }
1456
1457 /*
1458  * incoming pattern from LCR
1459  */
1460 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1461 {
1462         union parameter newparam;
1463
1464         CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1465
1466         if (!call->ast) return;
1467
1468         /* pattern are indicated only once */
1469         if (call->has_pattern)
1470                 return;
1471         call->has_pattern = 1;
1472
1473         /* request bchannel */
1474         CDEBUG(call, call->ast, "Requesting audio path (ref=%d)\n", call->ref);
1475         memset(&newparam, 0, sizeof(union parameter));
1476         send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
1477
1478         /* queue PROGRESS, because tones are available */
1479         if (call->ast && call->pbx_started) {
1480                 if (!wake_global) {
1481                         wake_global = 1;
1482                         char byte = 0;
1483                         int rc;
1484                         rc = write(wake_pipe[1], &byte, 1);
1485                 }
1486                 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1487         }
1488 }
1489
1490 /*
1491  * got dtmf from bchannel (locked state)
1492  */
1493 void lcr_in_dtmf(struct chan_call *call, int val)
1494 {
1495         struct ast_channel *ast = call->ast;
1496         char digit[2];
1497
1498         if (!ast)
1499                 return;
1500         if (!call->pbx_started)
1501                 return;
1502
1503         if (!call->dsp_dtmf) {
1504                 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1505                 return;
1506         }
1507
1508         CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1509         digit[0] = val;
1510         digit[1] = '\0';
1511         if (!wake_global) {
1512                 wake_global = 1;
1513                 char byte = 0;
1514                 int rc;
1515                 rc = write(wake_pipe[1], &byte, 1);
1516         }
1517         strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1518 }
1519
1520 /*
1521  * message received from LCR
1522  */
1523 int receive_message(int message_type, unsigned int ref, union parameter *param)
1524 {
1525         struct chan_call *call;
1526         union parameter newparam;
1527         int rc = 0;
1528
1529         memset(&newparam, 0, sizeof(union parameter));
1530
1531         /* handle new ref */
1532         if (message_type == MESSAGE_NEWREF) {
1533                 if (param->newref.direction) {
1534                         /* new ref from lcr */
1535                         CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1536                         if (!ref || find_call_ref(ref)) {
1537                                 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1538                                 return -1;
1539                         }
1540                         /* allocate new call instance */
1541                         call = alloc_call();
1542                         /* new state */
1543                         call->state = CHAN_LCR_STATE_IN_PREPARE;
1544                         /* set ref */
1545                         call->ref = ref;
1546                         call->ref_was_assigned = 1;
1547                         /* set dtmf (default, use option 'n' to disable */
1548                         call->dsp_dtmf = 1;
1549                         /* wait for setup (or release from asterisk) */
1550                 } else {
1551                         /* new ref, as requested from this remote application */
1552                         CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1553                         call = find_call_ref(0);
1554                         if (!call) {
1555                                 /* send release, if ref does not exist */
1556                                 CERROR(NULL, NULL, "No call found, that requests a ref.\n");
1557                                 return 0;
1558                         }
1559                         /* store new ref */
1560                         call->ref = ref;
1561                         call->ref_was_assigned = 1;
1562                         /* set dtmf (default, use option 'n' to disable */
1563                         call->dsp_dtmf = 1;
1564                         /* send pending setup info */
1565                         if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1566                                 send_setup_to_lcr(call);
1567                         /* release if asterisk has signed off */
1568                         else if (call->state == CHAN_LCR_STATE_RELEASE) {
1569                                 /* send release */
1570                                 if (call->cause)
1571                                         send_release(call, call->cause, call->location);
1572                                 else
1573                                         send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1574                                 /* free call */
1575                                 free_call(call);
1576                                 return 0;
1577                         }
1578                 }
1579                 return 0;
1580         }
1581
1582         /* check ref */
1583         if (!ref) {
1584                 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1585                 return -1;
1586         }
1587         call = find_call_ref(ref);
1588         if (!call) {
1589                 /* ignore ref that is not used (anymore) */
1590                 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1591                 return 0;
1592         }
1593
1594         /* handle messages */
1595         switch(message_type) {
1596                 case MESSAGE_SETUP:
1597                 lcr_in_setup(call, message_type, param);
1598                 break;
1599
1600                 case MESSAGE_OVERLAP:
1601                 lcr_in_overlap(call, message_type, param);
1602                 break;
1603
1604                 case MESSAGE_PROCEEDING:
1605                 lcr_in_proceeding(call, message_type, param);
1606                 break;
1607
1608                 case MESSAGE_ALERTING:
1609                 lcr_in_alerting(call, message_type, param);
1610                 break;
1611
1612                 case MESSAGE_CONNECT:
1613                 lcr_in_connect(call, message_type, param);
1614                 break;
1615
1616                 case MESSAGE_DISCONNECT:
1617                 lcr_in_disconnect(call, message_type, param);
1618                 break;
1619
1620                 case MESSAGE_RELEASE:
1621                 lcr_in_release(call, message_type, param);
1622                 break;
1623
1624                 case MESSAGE_INFORMATION:
1625                 lcr_in_information(call, message_type, param);
1626                 break;
1627
1628                 case MESSAGE_NOTIFY:
1629                 lcr_in_notify(call, message_type, param);
1630                 break;
1631
1632                 case MESSAGE_FACILITY:
1633                 lcr_in_facility(call, message_type, param);
1634                 break;
1635
1636                 case MESSAGE_PATTERN: // audio available from LCR
1637                 if (!call->has_pattern)
1638                         lcr_in_pattern(call, message_type, param);
1639                 break;
1640
1641                 case MESSAGE_NOPATTERN: // audio not available from LCR
1642                 break;
1643
1644                 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1645                 call->audiopath = param->audiopath;
1646                 break;
1647
1648                 case MESSAGE_TRAFFIC: // if remote audio connected or hold
1649                 {
1650                         unsigned char *p = param->traffic.data;
1651                         int i, len = param->traffic.len;
1652                         for (i = 0; i < len; i++, p++)
1653                                 *p = flip_bits[*p];
1654                 }
1655                 rc = write(call->pipe[1], param->traffic.data, param->traffic.len);
1656                 break;
1657
1658                 default:
1659                 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1660                 break;
1661         }
1662         return rc;
1663 }
1664
1665 /*
1666  * release all calls (due to broken socket)
1667  */
1668 static void release_all_calls(void)
1669 {
1670         struct chan_call *call;
1671
1672 again:
1673         call = call_first;
1674         while(call) {
1675                 /* no ast, so we may directly free call */
1676                 if (!call->ast) {
1677                         CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1678                         free_call(call);
1679                         goto again;
1680                 }
1681                 /* already in release process */
1682                 if (call->state == CHAN_LCR_STATE_RELEASE) {
1683                         call = call->next;
1684                         continue;
1685                 }
1686                 /* release or queue release */
1687                 call->ref = 0;
1688                 call->state = CHAN_LCR_STATE_RELEASE;
1689                 if (!call->pbx_started) {
1690                         CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1691                         ast_hangup(call->ast); // call will be destroyed here
1692                         goto again;
1693                 }
1694                 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1695                 if (!wake_global) {
1696                         wake_global = 1;
1697                         char byte = 0;
1698                         int rc;
1699                         rc = write(wake_pipe[1], &byte, 1);
1700                 }
1701                 strcpy(call->queue_string, "H");
1702                 call = call->next;
1703         }
1704 }
1705
1706 void close_socket(void);
1707
1708 /* asterisk handler
1709  * warning! not thread safe
1710  * returns -1 for socket error, 0 for no work, 1 for work
1711  */
1712 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1713 {
1714         int len;
1715         struct admin_list *admin;
1716         struct admin_message msg;
1717
1718         if ((what & LCR_FD_READ)) {
1719                 /* read from socket */
1720                 len = read(lcr_sock, &msg, sizeof(msg));
1721                 if (len == 0) {
1722                         CERROR(NULL, NULL, "Socket closed.(read)\n");
1723                         error:
1724                         CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1725                         close_socket();
1726                         release_all_calls();
1727                         schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1728                         return 0;
1729                 }
1730                 if (len > 0) {
1731                         if (len != sizeof(msg)) {
1732                                 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1733                                 goto error;
1734                         }
1735                         if (msg.message != ADMIN_MESSAGE) {
1736                                 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1737                                 goto error;
1738                         }
1739                         receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1740                 } else {
1741                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1742                         goto error;
1743                 }
1744         }
1745
1746         if ((what & LCR_FD_WRITE)) {
1747                 /* write to socket */
1748                 if (!admin_first) {
1749                         socket_fd.when &= ~LCR_FD_WRITE;
1750                         return 0;
1751                 }
1752                 admin = admin_first;
1753                 len = write(lcr_sock, &admin->msg, sizeof(msg));
1754                 if (len == 0) {
1755                         CERROR(NULL, NULL, "Socket closed.(write)\n");
1756                         goto error;
1757                 }
1758                 if (len > 0) {
1759                         if (len != sizeof(msg)) {
1760                                 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1761                                 goto error;
1762                         }
1763                         /* free head */
1764                         admin_first = admin->next;
1765                         free(admin);
1766                         global_change = 1;
1767                 } else {
1768                         CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1769                         goto error;
1770                 }
1771         }
1772
1773         return 0;
1774 }
1775
1776 /*
1777  * open and close socket and thread
1778  */
1779 int open_socket(void)
1780 {
1781         int conn;
1782         struct sockaddr_un sock_address;
1783         union parameter param;
1784
1785         /* open socket */
1786         if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1787                 CERROR(NULL, NULL, "Failed to create socket.\n");
1788                 return lcr_sock;
1789         }
1790
1791         /* set socket address and name */
1792         memset(&sock_address, 0, sizeof(sock_address));
1793         sock_address.sun_family = PF_UNIX;
1794         sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1795
1796         /* connect socket */
1797         if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1798                 close(lcr_sock);
1799                 lcr_sock = -1;
1800                 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1801                 return conn;
1802         }
1803
1804         /* register socket fd */
1805         memset(&socket_fd, 0, sizeof(socket_fd));
1806         socket_fd.fd = lcr_sock;
1807         register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1808
1809         /* enque hello message */
1810         memset(&param, 0, sizeof(param));
1811         strcpy(param.hello.application, "asterisk");
1812         send_message(MESSAGE_HELLO, 0, &param);
1813
1814         return lcr_sock;
1815 }
1816
1817 void close_socket(void)
1818 {
1819         struct admin_list *admin, *temp;
1820
1821         /* socket not created */
1822         if (lcr_sock < 0)
1823                 return;
1824
1825         unregister_fd(&socket_fd);
1826
1827         /* flush pending messages */
1828         admin = admin_first;
1829         while(admin) {
1830                 temp = admin;
1831                 admin = admin->next;
1832                 free(temp);
1833         }
1834         admin_first = NULL;
1835
1836         /* close socket */
1837         close(lcr_sock);
1838         lcr_sock = -1;
1839         global_change = 1;
1840 }
1841
1842
1843 /* sending queue to asterisk */
1844 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1845 {
1846         char byte;
1847         int rc;
1848
1849         rc = read(wake_pipe[0], &byte, 1);
1850
1851         wake_global = 0;
1852
1853         return 0;
1854 }
1855
1856 static void handle_queue()
1857 {
1858         struct chan_call *call;
1859         struct ast_channel *ast;
1860         struct ast_frame fr;
1861         char *p;
1862
1863 again:
1864         call = call_first;
1865         while(call) {
1866                 p = call->queue_string;
1867                 ast = call->ast;
1868                 if (*p && ast) {
1869                         if (ast_channel_trylock(ast)) {
1870                                 ast_mutex_unlock(&chan_lock);
1871                                 usleep(1);
1872                                 ast_mutex_lock(&chan_lock);
1873                                 goto again;
1874                         }
1875                         while(*p) {
1876                                 switch (*p) {
1877                                 case 'T':
1878                                         CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1879                                         ast_queue_control(ast, AST_CONTROL_PROGRESS);
1880                                         break;
1881                                 case 'P':
1882                                         CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1883                                         ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1884                                         break;
1885                                 case 'R':
1886                                         CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1887                                         ast_queue_control(ast, AST_CONTROL_RINGING);
1888                                         ast_setstate(ast, AST_STATE_RINGING);
1889                                         break;
1890                                 case 'N':
1891                                         CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1892                                         ast_queue_control(ast, AST_CONTROL_ANSWER);
1893                                         break;
1894                                 case 'H':
1895                                         CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1896                                         ast_queue_hangup(ast);
1897                                         break;
1898                                 case '1': case '2': case '3': case 'A':
1899                                 case '4': case '5': case '6': case 'B':
1900                                 case '7': case '8': case '9': case 'C':
1901                                 case '*': case '0': case '#': case 'D':
1902                                         CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1903                                         /* send digit to asterisk */
1904                                         memset(&fr, 0, sizeof(fr));
1905
1906                                         #ifdef LCR_FOR_ASTERISK
1907                                         fr.frametype = AST_FRAME_DTMF_BEGIN;
1908                                         #endif
1909
1910                                         #ifdef LCR_FOR_CALLWEAVER
1911                                         fr.frametype = AST_FRAME_DTMF;
1912                                         #endif
1913
1914 #ifdef AST_1_8_OR_HIGHER
1915                                         fr.subclass.integer = *p;
1916 #else
1917                                         fr.subclass = *p;
1918 #endif
1919                                         fr.delivery = ast_tv(0, 0);
1920                                         ast_queue_frame(ast, &fr);
1921
1922                                         #ifdef LCR_FOR_ASTERISK
1923                                         fr.frametype = AST_FRAME_DTMF_END;
1924                                         ast_queue_frame(ast, &fr);
1925                                         #endif
1926
1927                                         break;
1928                                 default:
1929                                         CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1930                                 }
1931                                 p++;
1932                         }
1933                         call->queue_string[0] = '\0';
1934                         ast_channel_unlock(ast);
1935                 }
1936                 call = call->next;
1937         }
1938 }
1939
1940 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1941 {
1942         CDEBUG(NULL, NULL, "Retry to open socket.\n");
1943         if (open_socket() < 0)
1944                 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1945
1946         return 0;
1947 }
1948
1949 void lock_chan(void)
1950 {
1951         ast_mutex_lock(&chan_lock);
1952 }
1953
1954 void unlock_chan(void)
1955 {
1956         ast_mutex_unlock(&chan_lock);
1957 }
1958
1959 /* chan_lcr thread */
1960 static void *chan_thread(void *arg)
1961 {
1962         if (pipe(wake_pipe) < 0) {
1963                 CERROR(NULL, NULL, "Failed to open pipe.\n");
1964                 return NULL;
1965         }
1966         memset(&wake_fd, 0, sizeof(wake_fd));
1967         wake_fd.fd = wake_pipe[0];
1968         register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1969
1970         memset(&socket_retry, 0, sizeof(socket_retry));
1971         add_timer(&socket_retry, handle_retry, NULL, 0);
1972
1973         /* open socket the first time */
1974         handle_retry(NULL, NULL, 0);
1975
1976         ast_mutex_lock(&chan_lock);
1977
1978         while(1) {
1979                 handle_queue();
1980                 select_main(0, &global_change, lock_chan, unlock_chan);
1981         }
1982
1983         return NULL;
1984 }
1985
1986 /*
1987  * new asterisk instance
1988  */
1989 static
1990 #ifdef AST_1_8_OR_HIGHER
1991 #if ASTERISK_VERSION_NUM < 100000
1992 struct ast_channel *lcr_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
1993 #else
1994 struct ast_channel *lcr_request(const char *type, struct ast_format_cap *format, const struct ast_channel *requestor, void *data, int *cause)
1995 #endif
1996 #else
1997 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1998 #endif
1999 {
2000         char exten[256], *dial, *interface, *opt;
2001         struct ast_channel *ast;
2002         struct chan_call *call;
2003 #ifdef AST_1_8_OR_HIGHER
2004         const struct ast_party_redirecting *req_redir;
2005         const struct ast_party_caller *req_caller;
2006 #endif
2007
2008         ast_mutex_lock(&chan_lock);
2009         CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
2010
2011         /* if socket is closed */
2012         if (lcr_sock < 0) {
2013                 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
2014                 ast_mutex_unlock(&chan_lock);
2015                 return NULL;
2016         }
2017
2018         /* create call instance */
2019         call = alloc_call();
2020         if (!call) {
2021                 /* failed to create instance */
2022                 ast_mutex_unlock(&chan_lock);
2023                 return NULL;
2024         }
2025
2026         /* create asterisk channel instrance */
2027
2028         #ifdef LCR_FOR_ASTERISK
2029 #ifdef AST_1_8_OR_HIGHER
2030         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, NULL, NULL, NULL, NULL, 0, "%s/%d", lcr_type, ++glob_channel);
2031 #else
2032         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
2033 #endif
2034         #endif
2035
2036         #ifdef LCR_FOR_CALLWEAVER
2037         ast = ast_channel_alloc(1);
2038         #endif
2039
2040         if (!ast) {
2041                 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
2042                 free_call(call);
2043                 /* failed to create instance */
2044                 ast_mutex_unlock(&chan_lock);
2045                 return NULL;
2046         }
2047 #if ASTERISK_VERSION_NUM < 110000
2048         ast->tech = &lcr_tech;
2049         ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
2050 #ifdef AST_1_8_OR_HIGHER
2051         req_redir = &requestor->redirecting;
2052         req_caller = &requestor->caller;
2053 #endif
2054 #else
2055         ast_channel_tech_set(ast, &lcr_tech);
2056         ast_channel_tech_pvt_set(ast, (void *)1L); // set pointer or asterisk will not call
2057         req_redir = ast_channel_redirecting(requestor);
2058         req_caller = ast_channel_caller(requestor);
2059 #endif
2060         /* configure channel */
2061 #if ASTERISK_VERSION_NUM < 100000
2062 #if ASTERISK_VERSION_NUM < 110000
2063         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2064         ast->readformat = ast->rawreadformat = ast->nativeformats;
2065         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
2066 #else
2067         ast_channel_nativeformats_set(ast, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
2068         ast->readformat = ast->rawreadformat = ast_channel_nativeformats(ast);
2069         ast->writeformat = ast->rawwriteformat =  ast_channel_nativeformats(ast);
2070 #endif
2071 #else
2072 #if ASTERISK_VERSION_NUM < 110000
2073         ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2074         ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
2075         ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
2076         ast_set_write_format(ast, &ast->rawwriteformat);
2077         ast_set_read_format(ast, &ast->rawreadformat);
2078 #else
2079         ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2080         ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
2081         ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
2082         ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
2083         ast_set_read_format(ast, ast_channel_rawreadformat(ast));
2084 #endif
2085 #endif
2086 #if ASTERISK_VERSION_NUM < 110000
2087         ast->priority = 1;
2088         ast->hangupcause = 0;
2089 #else
2090         ast_channel_priority_set(ast, 1);
2091         ast_channel_hangupcause_set(ast, 0);
2092 #endif
2093
2094         /* link together */
2095         call->ast = ast;
2096 #if ASTERISK_VERSION_NUM < 110000
2097         ast->tech_pvt = call;
2098         ast->fds[0] = call->pipe[0];
2099 #else
2100         ast_channel_tech_pvt_set(ast, call);
2101         ast_channel_set_fd(ast, 0, call->pipe[0]);
2102 #endif
2103         call->pbx_started = 0;
2104         /* set state */
2105         call->state = CHAN_LCR_STATE_OUT_PREPARE;
2106
2107         /*
2108          * Extract interface, dialstring, options from data.
2109          * Formats can be:
2110          *      <dialstring>
2111          *      <interface>/<dialstring>
2112          *      <interface>/<dialstring>/options
2113          */
2114         strncpy(exten, (char *)data, sizeof(exten)-1);
2115         exten[sizeof(exten)-1] = '\0';
2116         if ((dial = strchr(exten, '/'))) {
2117                 *dial++ = '\0';
2118                 interface = exten;
2119                 if ((opt = strchr(dial, '/')))
2120                         *opt++ = '\0';
2121                 else
2122                         opt = "";
2123         } else {
2124                 dial = exten;
2125                 interface = "";
2126                 opt = "";
2127         }
2128         strncpy(call->interface, interface, sizeof(call->interface)-1);
2129         strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
2130         apply_opt(call, (char *)opt);
2131
2132 #ifdef AST_1_8_OR_HIGHER
2133 //      clone_variables(requestor, ast);
2134
2135 #if 0
2136         ast->caller.ani.number.valid=                   req_caller->ani.number.valid;
2137         if (req_caller->ani.number.valid)
2138           if (req_caller->ani.number.str)
2139             if (req_caller->ani.number.str[0])
2140                 ast->caller.ani.number.str=             strdup(req_caller->ani.number.str);
2141         ast->caller.ani.number.plan=                    req_caller->ani.number.plan;
2142         ast->caller.ani.number.presentation=            req_caller->ani.number.presentation;
2143
2144         ast->caller.ani.name.valid=                     req_caller->ani.name.valid;
2145         if (req_caller->ani.name.valid)
2146           if (req_caller->ani.name.str)
2147             if (req_caller->ani.name.str[0])
2148                 ast->caller.ani.name.str=               strdup(req_caller->ani.name.str);
2149         ast->caller.ani.name.presentation=              req_caller->ani.name.presentation;
2150
2151         ast->caller.ani.subaddress.valid=               req_caller->ani.subaddress.valid;
2152         if (req_caller->ani.subaddress.valid)
2153           if (req_caller->ani.subaddress.str)
2154             if (req_caller->ani.subaddress.str[0])
2155                 ast->caller.ani.subaddress.str=         strdup(req_caller->ani.subaddress.str);
2156         ast->caller.ani.subaddress.type=                req_caller->ani.subaddress.type;
2157
2158         ast->caller.id.number.valid=                    req_caller->id.number.valid;
2159         if (req_caller->id.number.valid)
2160           if (req_caller->id.number.str)
2161             if (req_caller->id.number.str[0])
2162                 ast->caller.id.number.str=              strdup(req_caller->id.number.str);
2163         ast->caller.id.number.plan=                     req_caller->id.number.plan;
2164         ast->caller.id.number.presentation=             req_caller->id.number.presentation;
2165
2166         ast->caller.id.name.valid=                      req_caller->id.name.valid;
2167         if (req_caller->id.name.valid)
2168           if (req_caller->id.name.str)
2169             if (req_caller->id.name.str[0])
2170                 ast->caller.id.name.str=                strdup(req_caller->id.name.str);
2171         ast->caller.id.name.presentation=               req_caller->id.name.presentation;
2172
2173         ast->caller.id.subaddress.valid=                req_caller->id.subaddress.valid;
2174         if (req_caller->id.subaddress.valid)
2175           if (req_caller->id.subaddress.str)
2176             if (req_caller->id.subaddress.str[0])
2177                 ast->caller.id.subaddress.str=          strdup(req_caller->id.subaddress.str);
2178         ast->caller.id.subaddress.type=                 req_caller->id.subaddress.type;
2179
2180         if (requestor->dialed.number.str)
2181           if (requestor->dialed.number.str[0])
2182                 ast->dialed.number.str=                 strdup(requestor->dialed.number.str);
2183         ast->dialed.number.plan=                        requestor->dialed.number.plan;
2184
2185         ast->dialed.subaddress.valid=                   requestor->dialed.subaddress.valid;
2186         if (requestor->dialed.subaddress.valid)
2187           if (requestor->dialed.subaddress.str)
2188             if (requestor->dialed.subaddress.str[0])
2189                 ast->dialed.subaddress.str=             strdup(requestor->dialed.subaddress.str);
2190         ast->dialed.subaddress.type=                    requestor->dialed.subaddress.type;
2191
2192         ast->dialed.transit_network_select=             requestor->dialed.transit_network_select;
2193         ast->redirecting.count=                         req_redir->count;
2194         ast->redirecting.reason=                        req_redir->reason;
2195
2196         ast->redirecting.from.number.valid=             req_redir->from.number.valid;
2197         if (req_redir->from.number.valid)
2198           if (req_redir->from.number.str)
2199             if (req_redir->from.number.str[0])
2200                 ast->redirecting.from.number.str=       strdup(req_redir->from.number.str);
2201         ast->redirecting.from.number.plan=              req_redir->from.number.plan;
2202         ast->redirecting.from.number.presentation=      req_redir->from.number.presentation;
2203
2204         ast->redirecting.to.number.valid=               req_redir->to.number.valid;
2205         if (req_redir->to.number.valid)
2206           if (req_redir->to.number.str)
2207             if (req_redir->to.number.str[0])
2208                 ast->redirecting.to.number.str=         strdup(req_redir->to.number.str);
2209         ast->redirecting.to.number.plan=                req_redir->to.number.plan;
2210         ast->redirecting.to.number.presentation=        req_redir->to.number.presentation;
2211 #endif
2212         /* store call information for setup */
2213
2214         /* caller ID */
2215         if (requestor && req_caller->id.number.valid) {
2216                 if (req_caller->id.number.str)
2217                         strncpy(call->callerinfo.id, req_caller->id.number.str, sizeof(call->callerinfo.id)-1);
2218                 switch(req_caller->id.number.presentation & AST_PRES_RESTRICTION) {
2219                         case AST_PRES_RESTRICTED:
2220                         call->callerinfo.present = INFO_PRESENT_RESTRICTED;
2221                         break;
2222                         case AST_PRES_UNAVAILABLE:
2223                         call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2224                         break;
2225                         case AST_PRES_ALLOWED:
2226                         default:
2227                         call->callerinfo.present = INFO_PRESENT_ALLOWED;
2228                 }
2229                 switch(req_caller->id.number.presentation & AST_PRES_NUMBER_TYPE) {
2230                         case AST_PRES_USER_NUMBER_UNSCREENED:
2231                         call->callerinfo.screen = INFO_SCREEN_USER;
2232                         break;
2233                         case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2234                         call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2235                         break;
2236                         case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2237                         call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2238                         break;
2239                         default:
2240                         call->callerinfo.screen = INFO_SCREEN_NETWORK;
2241                 }
2242                 switch((req_caller->id.number.plan >> 4) & 7) {
2243                         case 4:
2244                         call->callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2245                         break;
2246                         case 2:
2247                         call->callerinfo.ntype = INFO_NTYPE_NATIONAL;
2248                         break;
2249                         case 1:
2250                         call->callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2251                         break;
2252                         default:
2253                         call->callerinfo.ntype = INFO_NTYPE_UNKNOWN;
2254                 }
2255         } else
2256                 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2257
2258         /* caller ID 2 */
2259         if (requestor && req_caller->ani.number.valid) {
2260                 if (req_caller->ani.number.str)
2261                         strncpy(call->callerinfo.id2, req_caller->ani.number.str, sizeof(call->callerinfo.id2)-1);
2262                 switch(req_caller->ani.number.presentation & AST_PRES_RESTRICTION) {
2263                         case AST_PRES_RESTRICTED:
2264                         call->callerinfo.present2 = INFO_PRESENT_RESTRICTED;
2265                         break;
2266                         case AST_PRES_UNAVAILABLE:
2267                         call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2268                         break;
2269                         case AST_PRES_ALLOWED:
2270                         default:
2271                         call->callerinfo.present2 = INFO_PRESENT_ALLOWED;
2272                 }
2273                 switch(req_caller->ani.number.presentation & AST_PRES_NUMBER_TYPE) {
2274                         case AST_PRES_USER_NUMBER_UNSCREENED:
2275                         call->callerinfo.screen2 = INFO_SCREEN_USER;
2276                         break;
2277                         case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2278                         call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_PASSED;
2279                         break;
2280                         case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2281                         call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_FAILED;
2282                         break;
2283                         default:
2284                         call->callerinfo.screen2 = INFO_SCREEN_NETWORK;
2285                 }
2286                 switch((req_caller->ani.number.plan >> 4) & 7) {
2287                         case 4:
2288                         call->callerinfo.ntype2 = INFO_NTYPE_SUBSCRIBER;
2289                         break;
2290                         case 2:
2291                         call->callerinfo.ntype2 = INFO_NTYPE_NATIONAL;
2292                         break;
2293                         case 1:
2294                         call->callerinfo.ntype2 = INFO_NTYPE_INTERNATIONAL;
2295                         break;
2296                         default:
2297                         call->callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
2298                 }
2299         } else
2300                 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2301
2302         /* caller name */
2303         if (requestor && req_caller->id.name.valid) {
2304                 if (req_caller->id.name.str)
2305                         strncpy(call->callerinfo.name, req_caller->id.name.str, sizeof(call->callerinfo.name)-1);
2306         }
2307
2308         /* redir number */
2309         if (requestor && req_redir->from.number.valid) {
2310                 call->redirinfo.itype = INFO_ITYPE_CHAN;
2311                 if (req_redir->from.number.str)
2312                         strncpy(call->redirinfo.id, req_redir->from.number.str, sizeof(call->redirinfo.id)-1);
2313                 switch(req_redir->from.number.presentation & AST_PRES_RESTRICTION) {
2314                         case AST_PRES_RESTRICTED:
2315                         call->redirinfo.present = INFO_PRESENT_RESTRICTED;
2316                         break;
2317                         case AST_PRES_UNAVAILABLE:
2318                         call->redirinfo.present = INFO_PRESENT_NOTAVAIL;
2319                         break;
2320                         case AST_PRES_ALLOWED:
2321                         default:
2322                         call->redirinfo.present = INFO_PRESENT_ALLOWED;
2323                 }
2324                 switch(req_redir->from.number.presentation & AST_PRES_NUMBER_TYPE) {
2325                         case AST_PRES_USER_NUMBER_UNSCREENED:
2326                         call->redirinfo.screen = INFO_SCREEN_USER;
2327                         break;
2328                         case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2329                         call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2330                         break;
2331                         case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2332                         call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2333                         break;
2334                         default:
2335                         call->redirinfo.screen = INFO_SCREEN_NETWORK;
2336                 }
2337                 switch((req_redir->from.number.plan >> 4) & 7) {
2338                         case 4:
2339                         call->redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2340                         break;
2341                         case 2:
2342                         call->redirinfo.ntype = INFO_NTYPE_NATIONAL;
2343                         break;
2344                         case 1:
2345                         call->redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2346                         break;
2347                         default:
2348                         call->redirinfo.ntype = INFO_NTYPE_UNKNOWN;
2349                 }
2350         }
2351 #endif
2352
2353         ast_mutex_unlock(&chan_lock);
2354         return ast;
2355 }
2356
2357 /*
2358  * call from asterisk
2359  */
2360 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
2361 {
2362         union parameter newparam;
2363         struct chan_call *call;
2364 #if ASTERISK_VERSION_NUM >= 110000
2365         int transfercapability;
2366 #endif
2367
2368         ast_mutex_lock(&chan_lock);
2369 #if ASTERISK_VERSION_NUM < 110000
2370         call = ast->tech_pvt;
2371 #else
2372         call = ast_channel_tech_pvt(ast);
2373 #endif
2374
2375         #ifdef LCR_FOR_CALLWEAVER
2376         ast->type = "LCR";
2377         snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type, call->dialstring, ast_random() & 0xffff);
2378         #endif
2379
2380         if (!call) {
2381                 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
2382                 ast_mutex_unlock(&chan_lock);
2383                 return -1;
2384         }
2385
2386         CDEBUG(NULL, ast, "Received call from Asterisk.\n");
2387
2388         /* pbx process is started */
2389         call->pbx_started = 1;
2390         /* send MESSAGE_NEWREF */
2391         memset(&newparam, 0, sizeof(union parameter));
2392         newparam.newref.direction = 0; /* request from app */
2393         send_message(MESSAGE_NEWREF, 0, &newparam);
2394
2395         /* set hdlc if capability requires hdlc */
2396 #if ASTERISK_VERSION_NUM < 110000
2397         if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
2398          || ast->transfercapability == INFO_BC_DATARESTRICTED
2399          || ast->transfercapability == INFO_BC_VIDEO)
2400 #else
2401         transfercapability=ast_channel_transfercapability(ast);
2402         if (transfercapability == INFO_BC_DATAUNRESTRICTED
2403          || transfercapability == INFO_BC_DATARESTRICTED
2404          || transfercapability == INFO_BC_VIDEO)
2405 #endif
2406                 call->hdlc = 1;
2407         /* if hdlc is forced by option, we change transcap to data */
2408         if (call->hdlc
2409 #if ASTERISK_VERSION_NUM < 110000
2410          && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
2411          && ast->transfercapability != INFO_BC_DATARESTRICTED
2412          && ast->transfercapability != INFO_BC_VIDEO)
2413                 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
2414 #else
2415          && transfercapability != INFO_BC_DATAUNRESTRICTED
2416          && transfercapability != INFO_BC_DATARESTRICTED
2417          && transfercapability != INFO_BC_VIDEO)
2418                 transfercapability = INFO_BC_DATAUNRESTRICTED;
2419 #endif
2420
2421 #ifndef AST_1_8_OR_HIGHER
2422         call->cid_num[0] = 0;
2423         call->cid_name[0] = 0;
2424         call->cid_rdnis[0] = 0;
2425
2426         if (ast->cid.cid_num) if (ast->cid.cid_num[0])
2427                 strncpy(call->cid_num, ast->cid.cid_num,
2428                         sizeof(call->cid_num)-1);
2429         if (ast->cid.cid_name) if (ast->cid.cid_name[0])
2430                 strncpy(call->cid_name, ast->cid.cid_name,
2431                         sizeof(call->cid_name)-1);
2432         if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
2433                 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
2434                         sizeof(call->cid_rdnis)-1);
2435 #endif
2436
2437         ast_mutex_unlock(&chan_lock);
2438         return 0;
2439 }
2440
2441 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2442 {
2443         static const char* dtmf_tones[] = {
2444                 "!941+1336/100,!0/100", /* 0 */
2445                 "!697+1209/100,!0/100", /* 1 */
2446                 "!697+1336/100,!0/100", /* 2 */
2447                 "!697+1477/100,!0/100", /* 3 */
2448                 "!770+1209/100,!0/100", /* 4 */
2449                 "!770+1336/100,!0/100", /* 5 */
2450                 "!770+1477/100,!0/100", /* 6 */
2451                 "!852+1209/100,!0/100", /* 7 */
2452                 "!852+1336/100,!0/100", /* 8 */
2453                 "!852+1477/100,!0/100", /* 9 */
2454                 "!697+1633/100,!0/100", /* A */
2455                 "!770+1633/100,!0/100", /* B */
2456                 "!852+1633/100,!0/100", /* C */
2457                 "!941+1633/100,!0/100", /* D */
2458                 "!941+1209/100,!0/100", /* * */
2459                 "!941+1477/100,!0/100" };       /* # */
2460
2461         if (digit >= '0' && digit <='9')
2462                 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2463         else if (digit >= 'A' && digit <= 'D')
2464                 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2465         else if (digit == '*')
2466                 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2467         else if (digit == '#')
2468                 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2469         else {
2470 #if ASTERISK_VERSION_NUM < 110000
2471                 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
2472 #else
2473                 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
2474 #endif
2475         }
2476 }
2477
2478 #ifdef LCR_FOR_ASTERISK
2479 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2480 #endif
2481 #ifdef LCR_FOR_CALLWEAVER
2482 static int lcr_digit(struct ast_channel *ast, char digit)
2483 #endif
2484 {
2485         struct chan_call *call;
2486         union parameter newparam;
2487         char buf[]="x";
2488
2489 #ifdef LCR_FOR_CALLWEAVER
2490         int inband_dtmf = 0;
2491 #endif
2492
2493         /* only pass IA5 number space */
2494         if (digit > 126 || digit < 32)
2495                 return 0;
2496
2497         ast_mutex_lock(&chan_lock);
2498 #if ASTERISK_VERSION_NUM < 110000
2499         call = ast->tech_pvt;
2500 #else
2501         call = ast_channel_tech_pvt(ast);
2502 #endif
2503         if (!call) {
2504                 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2505                 ast_mutex_unlock(&chan_lock);
2506                 return -1;
2507         }
2508
2509         CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2510
2511         /* send information or queue them */
2512         if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2513                 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2514                 memset(&newparam, 0, sizeof(union parameter));
2515                 if (call->keypad) {
2516                         newparam.information.keypad[0] = digit;
2517                         newparam.information.keypad[1] = '\0';
2518                 } else {
2519                         newparam.information.id[0] = digit;
2520                         newparam.information.id[1] = '\0';
2521                 }
2522                 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2523         } else
2524         if (!call->ref
2525          && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2526                 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2527                 *buf = digit;
2528                 strncat(call->dialque, buf, strlen(call->dialque)-1);
2529         }
2530
2531         ast_mutex_unlock(&chan_lock);
2532
2533 #ifdef LCR_FOR_ASTERISK
2534         return 0;
2535 }
2536
2537 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2538 {
2539         int inband_dtmf = 0;
2540         struct chan_call *call;
2541 #endif
2542
2543         ast_mutex_lock(&chan_lock);
2544
2545 #if ASTERISK_VERSION_NUM < 110000
2546         call = ast->tech_pvt;
2547 #else
2548         call = ast_channel_tech_pvt(ast);
2549 #endif
2550
2551         if (!call) {
2552                 CERROR(NULL, ast,
2553                         "Received digit from Asterisk, "
2554                         "but no call instance exists.\n");
2555                 ast_mutex_unlock(&chan_lock);
2556                 return -1;
2557         }
2558
2559         CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2560
2561         if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2562                 inband_dtmf = 1;
2563         }
2564
2565         ast_mutex_unlock(&chan_lock);
2566
2567         if (inband_dtmf) {
2568                 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2569                 send_digit_to_chan(ast, digit);
2570         }
2571
2572         return 0;
2573 }
2574
2575 static int lcr_answer(struct ast_channel *ast)
2576 {
2577         union parameter newparam;
2578         struct chan_call *call;
2579
2580         ast_mutex_lock(&chan_lock);
2581 #if ASTERISK_VERSION_NUM < 110000
2582         call = ast->tech_pvt;
2583 #else
2584         call = ast_channel_tech_pvt(ast);
2585 #endif
2586         if (!call) {
2587                 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2588                 ast_mutex_unlock(&chan_lock);
2589                 return -1;
2590         }
2591
2592         CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2593
2594         /* copy connectinfo, if bridged */
2595         if (call->bridge_call)
2596                 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2597         /* send connect message to lcr */
2598         if (call->state != CHAN_LCR_STATE_CONNECT) {
2599                 memset(&newparam, 0, sizeof(union parameter));
2600                 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2601                 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2602                 call->state = CHAN_LCR_STATE_CONNECT;
2603         }
2604         /* change state */
2605         /* enable keypad */
2606 //      memset(&newparam, 0, sizeof(union parameter));
2607 //      send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2608
2609         ast_mutex_unlock(&chan_lock);
2610         return 0;
2611 }
2612
2613 static int lcr_hangup(struct ast_channel *ast)
2614 {
2615         struct chan_call *call;
2616         pthread_t tid = pthread_self();
2617
2618         if (!pthread_equal(tid, chan_tid)) {
2619                 ast_mutex_lock(&chan_lock);
2620         }
2621 #if ASTERISK_VERSION_NUM < 110000
2622         call = ast->tech_pvt;
2623 #else
2624         call = ast_channel_tech_pvt(ast);
2625 #endif
2626         if (!call) {
2627                 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2628                 if (!pthread_equal(tid, chan_tid)) {
2629                         ast_mutex_unlock(&chan_lock);
2630                 }
2631                 return -1;
2632         }
2633
2634         if (!pthread_equal(tid, chan_tid))
2635                 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2636         else
2637                 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2638
2639         /* disconnect asterisk, maybe not required */
2640 #if ASTERISK_VERSION_NUM < 110000
2641         ast->tech_pvt = NULL;
2642         ast->fds[0] = -1;
2643 #else
2644         ast_channel_tech_pvt_set(ast, NULL);
2645         ast_channel_set_fd(ast, 0, -1);
2646 #endif
2647         if (call->ref) {
2648                 /* release */
2649                 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2650 #if ASTERISK_VERSION_NUM < 110000
2651                 if (ast->hangupcause > 0)
2652                         send_release(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2653 #else
2654                 if (ast_channel_hangupcause(ast) > 0)
2655                         send_release(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
2656 #endif
2657                 else
2658                         send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2659                 /* remove call */
2660                 free_call(call);
2661                 if (!pthread_equal(tid, chan_tid)) {
2662                         ast_mutex_unlock(&chan_lock);
2663                 }
2664                 return 0;
2665         } else {
2666                 /* ref is not set, due to prepare setup or release */
2667                 if (call->state == CHAN_LCR_STATE_RELEASE) {
2668                         /* we get the response to our release */
2669                         CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2670                         free_call(call);
2671                 } else {
2672                         /* during prepare, we change to release state */
2673                         CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2674                         call->state = CHAN_LCR_STATE_RELEASE;
2675                         call->ast = NULL;
2676                 }
2677         }
2678         if (!pthread_equal(tid, chan_tid)) {
2679                 ast_mutex_unlock(&chan_lock);
2680         }
2681         return 0;
2682 }
2683
2684 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2685 {
2686         union parameter newparam;
2687         struct chan_call *call;
2688         struct ast_frame * f = fr;
2689         unsigned char *p, *q;
2690         int len, l;
2691
2692 #if ASTERISK_VERSION_NUM < 100000
2693 #ifdef AST_1_8_OR_HIGHER
2694         if (!f->subclass.codec)
2695 #else
2696         if (!f->subclass)
2697 #endif
2698                 CDEBUG(NULL, ast, "No subclass\n");
2699 #endif
2700 #ifdef AST_1_8_OR_HIGHER
2701 #if ASTERISK_VERSION_NUM < 100000
2702 #if ASTERISK_VERSION_NUM < 110000
2703         if (!(f->subclass.codec & ast->nativeformats)) {
2704 #else
2705         if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
2706 #endif
2707 #else
2708 #if ASTERISK_VERSION_NUM < 110000
2709         if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
2710 #else
2711         if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
2712 #endif
2713 #endif
2714 #else
2715 #if ASTERISK_VERSION_NUM < 110000
2716         if (!(f->subclass & ast->nativeformats)) {
2717 #else
2718         if (!(f->subclass & ast_channel_nativeformats(ast))) {
2719 #endif
2720 #endif
2721                 CDEBUG(NULL, ast,
2722                                "Unexpected format. "
2723                        "Activating emergency conversion...\n");
2724
2725 #ifdef AST_1_8_OR_HIGHER
2726 #if ASTERISK_VERSION_NUM < 100000
2727                 ast_set_write_format(ast, f->subclass.codec);
2728 #else
2729                 ast_set_write_format(ast, &f->subclass.format);
2730 #endif
2731 #else
2732                 ast_set_write_format(ast, f->subclass);
2733 #endif
2734 #if ASTERISK_VERSION_NUM < 110000
2735                 f = (ast->writetrans) ? ast_translate(
2736                         ast->writetrans, fr, 0) : fr;
2737 #else
2738                 f = (ast_channel_writetrans(ast)) ? ast_translate(
2739                         ast_channel_writetrans(ast), fr, 0) : fr;
2740 #endif
2741         }
2742
2743         ast_mutex_lock(&chan_lock);
2744 #if ASTERISK_VERSION_NUM < 110000
2745         call = ast->tech_pvt;
2746 #else
2747         call = ast_channel_tech_pvt(ast);
2748 #endif
2749         if (!call) {
2750                 ast_mutex_unlock(&chan_lock);
2751                 if (f != fr) {
2752                         ast_frfree(f);
2753                 }
2754                 return -1;
2755         }
2756         len = f->samples;
2757         p = *((unsigned char **)&(f->data));
2758         q = newparam.traffic.data;
2759         memset(&newparam, 0, sizeof(union parameter));
2760         while (len) {
2761                 l = (len > sizeof(newparam.traffic.data)) ? sizeof(newparam.traffic.data) : len;
2762                 newparam.traffic.len = l;
2763                 len -= l;
2764                 for (; l; l--)
2765                         *q++ = flip_bits[*p++];
2766                 send_message(MESSAGE_TRAFFIC, call->ref, &newparam);
2767         }
2768         ast_mutex_unlock(&chan_lock);
2769         if (f != fr) {
2770                 ast_frfree(f);
2771         }
2772         return 0;
2773 }
2774
2775
2776 static struct ast_frame *lcr_read(struct ast_channel *ast)
2777 {
2778         struct chan_call *call;
2779         int len = 0;
2780
2781         ast_mutex_lock(&chan_lock);
2782 #if ASTERISK_VERSION_NUM < 110000
2783         call = ast->tech_pvt;
2784 #else
2785         call = ast_channel_tech_pvt(ast);
2786 #endif
2787         if (!call) {
2788                 ast_mutex_unlock(&chan_lock);
2789                 return NULL;
2790         }
2791         if (call->pipe[0] > -1) {
2792                 if (call->rebuffer && !call->hdlc) {
2793                         /* Make sure we have a complete 20ms (160byte) frame */
2794                         len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2795                         if (len > 0) {
2796                                 call->framepos += len;
2797                         }
2798                 } else {
2799                         len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2800                 }
2801                 if (len < 0 && errno == EAGAIN) {
2802                         ast_mutex_unlock(&chan_lock);
2803
2804                         #ifdef LCR_FOR_ASTERISK
2805                         return &ast_null_frame;
2806                         #endif
2807
2808                         #ifdef LCR_FOR_CALLWEAVER
2809                         return &nullframe;
2810                         #endif
2811
2812                 }
2813                 if (len <= 0) {
2814                         close(call->pipe[0]);
2815                         call->pipe[0] = -1;
2816                         global_change = 1;
2817                         ast_mutex_unlock(&chan_lock);
2818                         return NULL;
2819                 } else if (call->rebuffer && call->framepos < 160) {
2820                         /* Not a complete frame, so we send a null-frame */
2821                         ast_mutex_unlock(&chan_lock);
2822                         return &ast_null_frame;
2823                 }
2824         }
2825
2826         call->read_fr.frametype = AST_FRAME_VOICE;
2827 #ifdef AST_1_8_OR_HIGHER
2828 #if ASTERISK_VERSION_NUM < 100000
2829 #if ASTERISK_VERSION_NUM < 110000
2830         call->read_fr.subclass.codec = ast->nativeformats;
2831 #else
2832         call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
2833 #endif
2834 #else
2835 #if ASTERISK_VERSION_NUM < 110000
2836         ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
2837 #else
2838         ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
2839 #endif
2840         call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
2841 #endif
2842 #else
2843 #if ASTERISK_VERSION_NUM < 110000
2844         call->read_fr.subclass = ast->nativeformats;
2845 #else
2846         call->read_fr.subclass = ast_channel_nativeformats(ast);
2847 #endif
2848 #endif
2849         if (call->rebuffer) {
2850                 call->read_fr.datalen = call->framepos;
2851                 call->read_fr.samples = call->framepos;
2852                 call->framepos = 0;
2853         } else {
2854                 call->read_fr.datalen = len;
2855                 call->read_fr.samples = len;
2856         }
2857         call->read_fr.delivery = ast_tv(0,0);
2858         *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2859         ast_mutex_unlock(&chan_lock);
2860
2861         return &call->read_fr;
2862 }
2863
2864 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2865 {
2866         union parameter newparam;
2867         int res = 0;
2868         struct chan_call *call;
2869         const struct ast_tone_zone_sound *ts = NULL;
2870
2871         ast_mutex_lock(&chan_lock);
2872 #if ASTERISK_VERSION_NUM < 110000
2873         call = ast->tech_pvt;
2874 #else
2875         call = ast_channel_tech_pvt(ast);
2876 #endif
2877         if (!call) {
2878                 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2879                 ast_mutex_unlock(&chan_lock);
2880                 return -1;
2881         }
2882
2883         switch (cond) {
2884                 case AST_CONTROL_BUSY:
2885                         CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2886                         ast_setstate(ast, AST_STATE_BUSY);
2887                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2888                                 /* send message to lcr */
2889                                 memset(&newparam, 0, sizeof(union parameter));
2890                                 newparam.disconnectinfo.cause = 17;
2891                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2892                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2893                                 /* change state */
2894                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2895                         } else {
2896                                 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2897 #if ASTERISK_VERSION_NUM < 110000
2898                                 ts = ast_get_indication_tone(ast->zone, "busy");
2899 #else
2900                                 ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
2901 #endif
2902                         }
2903                         break;
2904                 case AST_CONTROL_CONGESTION:
2905 #if ASTERISK_VERSION_NUM < 110000
2906                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2907 #else
2908                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
2909 #endif
2910                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2911                                 /* send message to lcr */
2912                                 memset(&newparam, 0, sizeof(union parameter));
2913 #if ASTERISK_VERSION_NUM < 110000
2914                                 newparam.disconnectinfo.cause = ast->hangupcause;
2915 #else
2916                                 newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
2917 #endif
2918                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2919                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2920                                 /* change state */
2921                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2922                         } else {
2923                                 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2924 #if ASTERISK_VERSION_NUM < 110000
2925                                 ts = ast_get_indication_tone(ast->zone, "congestion");
2926 #else
2927                                 ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
2928 #endif
2929                         }
2930                         break;
2931                 case AST_CONTROL_PROCEEDING:
2932                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2933                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2934                          || call->state == CHAN_LCR_STATE_IN_DIALING) {
2935                                 /* send message to lcr */
2936                                 memset(&newparam, 0, sizeof(union parameter));
2937                                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2938                                 /* change state */
2939                                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2940                         }
2941                         break;
2942                 case AST_CONTROL_RINGING:
2943                         CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2944                         ast_setstate(ast, AST_STATE_RING);
2945                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2946                          || call->state == CHAN_LCR_STATE_IN_DIALING
2947                          || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2948                                 /* send message to lcr */
2949                                 memset(&newparam, 0, sizeof(union parameter));
2950                                 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2951                                 /* change state */
2952                                 call->state = CHAN_LCR_STATE_IN_ALERTING;
2953                         } else {
2954                                 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2955 #if ASTERISK_VERSION_NUM < 110000
2956                                 ts = ast_get_indication_tone(ast->zone, "ring");
2957 #else
2958                                 ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
2959 #endif
2960                         }
2961                         break;
2962                 case AST_CONTROL_PROGRESS:
2963                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2964                         /* request bchannel */
2965                         CDEBUG(call, ast, "Requesting audio path.\n");
2966                         memset(&newparam, 0, sizeof(union parameter));
2967                         send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
2968                         break;
2969                 case -1:
2970                         CDEBUG(call, ast, "Received indicate -1.\n");
2971                         ast_playtones_stop(ast);
2972                         res = -1;
2973                         break;
2974
2975                 case AST_CONTROL_VIDUPDATE:
2976                         CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2977                         res = -1;
2978                         break;
2979                 case AST_CONTROL_HOLD:
2980                         CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2981                         /* send message to lcr */
2982                         memset(&newparam, 0, sizeof(union parameter));
2983                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2984                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2985
2986                         /*start music onhold*/
2987                         #ifdef LCR_FOR_ASTERISK
2988                         #if ASTERISK_VERSION_NUM <110000
2989                         ast_moh_start(ast,data,ast->musicclass);
2990                         #else
2991                         ast_moh_start(ast,data,ast_channel_musicclass(ast));
2992                         #endif
2993                         #endif
2994
2995                         #ifdef LCR_FOR_CALLWEAVER
2996                         ast_moh_start(ast, NULL);
2997                         #endif
2998
2999                         call->on_hold = 1;
3000                         break;
3001                 case AST_CONTROL_UNHOLD:
3002                         CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
3003                         /* send message to lcr */
3004                         memset(&newparam, 0, sizeof(union parameter));
3005                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3006                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3007
3008                         /*stop moh*/
3009                         ast_moh_stop(ast);
3010                         call->on_hold = 0;
3011                         break;
3012 #ifdef AST_CONTROL_SRCUPDATE
3013                 case AST_CONTROL_SRCUPDATE:
3014 #else
3015                 case 20:
3016 #endif
3017                         CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
3018                         break;
3019                 default:
3020                         CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
3021                         res = -1;
3022                         break;
3023         }
3024
3025         if (ts && ts->data[0]) {
3026                 ast_playtones_start(ast, 0, ts->data, 1);
3027         }
3028
3029         /* return */
3030         ast_mutex_unlock(&chan_lock);
3031         return res;
3032 }
3033
3034 /*
3035  * fixup asterisk
3036  */
3037 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
3038 {
3039         struct chan_call *call;
3040
3041         if (!ast) {
3042                 return -1;
3043         }
3044
3045         ast_mutex_lock(&chan_lock);
3046 #if ASTERISK_VERSION_NUM < 110000
3047         call = ast->tech_pvt;
3048 #else
3049         call = ast_channel_tech_pvt(ast);
3050 #endif
3051         if (!call) {
3052                 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
3053                 ast_mutex_unlock(&chan_lock);
3054                 return -1;
3055         }
3056
3057         CDEBUG(call, ast, "Received fixup from Asterisk.\n");
3058         call->ast = ast;
3059         ast_mutex_unlock(&chan_lock);
3060         return 0;
3061 }
3062
3063 /*
3064  * send_text asterisk
3065  */
3066 static int lcr_send_text(struct ast_channel *ast, const char *text)
3067 {
3068         struct chan_call *call;
3069         union parameter newparam;
3070
3071         ast_mutex_lock(&chan_lock);
3072 #if ASTERISK_VERSION_NUM < 110000
3073         call = ast->tech_pvt;
3074 #else
3075         call = ast_channel_tech_pvt(ast);
3076 #endif
3077         if (!call) {
3078                 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
3079                 ast_mutex_unlock(&chan_lock);
3080                 return -1;
3081         }
3082
3083         CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
3084         memset(&newparam, 0, sizeof(union parameter));
3085         strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
3086         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3087         ast_mutex_unlock(&chan_lock);
3088         return 0;
3089 }
3090
3091 /*
3092  * bridge process
3093  */
3094 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
3095                                   struct ast_channel *ast2, int flags,
3096                                   struct ast_frame **fo,
3097                                   struct ast_channel **rc, int timeoutms)
3098
3099 {
3100         struct chan_call        *call1, *call2;
3101         struct ast_channel      *carr[2], *who;
3102         int                     to;
3103         struct ast_frame        *f;
3104         int                     bridge_id;
3105
3106         CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
3107
3108         carr[0] = ast1;
3109         carr[1] = ast2;
3110
3111         /* join via dsp (if the channels are currently open) */
3112         ast_mutex_lock(&chan_lock);
3113 #if ASTERISK_VERSION_NUM < 110000
3114         call1 = ast1->tech_pvt;
3115         call2 = ast2->tech_pvt;
3116 #else
3117         call1 = ast_channel_tech_pvt(ast1);
3118         call2 = ast_channel_tech_pvt(ast2);
3119 #endif
3120         if (!call1 || !call2) {
3121                 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
3122                 ast_mutex_unlock(&chan_lock);
3123                 return AST_BRIDGE_COMPLETE;
3124         }
3125
3126         /* join, if both call instances uses dsp
3127            ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
3128         */
3129         CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
3130
3131         /* get bridge id and join */
3132         bridge_id = new_bridge_id();
3133
3134 #if 0
3135         call1->bridge_id = bridge_id;
3136         if (call1->bchannel)
3137                 bchannel_join(call1->bchannel, bridge_id);
3138
3139         call2->bridge_id = bridge_id;
3140         if (call2->bchannel)
3141                 bchannel_join(call2->bchannel, bridge_id);
3142 #else
3143         printf("FIXME");
3144         exit(0);
3145 #endif
3146
3147         call1->bridge_call = call2;
3148         call2->bridge_call = call1;
3149
3150         if (call1->state == CHAN_LCR_STATE_IN_SETUP
3151          || call1->state == CHAN_LCR_STATE_IN_DIALING
3152          || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
3153          || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
3154                 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3155                 lcr_answer(ast1);
3156         }
3157         if (call2->state == CHAN_LCR_STATE_IN_SETUP
3158          || call2->state == CHAN_LCR_STATE_IN_DIALING
3159          || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
3160          || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
3161                 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3162                 lcr_answer(ast2);
3163         }
3164
3165         /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
3166            so let's do it for them. Hmpf.
3167         */
3168
3169         if (call1->on_hold) {
3170                 union parameter newparam;
3171
3172                 memset(&newparam, 0, sizeof(union parameter));
3173                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3174                 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
3175
3176                 call1->on_hold = 0;
3177         }
3178
3179         if (call2->on_hold) {
3180                 union parameter newparam;
3181
3182                 memset(&newparam, 0, sizeof(union parameter));
3183                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3184                 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
3185
3186                 call2->on_hold = 0;
3187         }
3188
3189         ast_mutex_unlock(&chan_lock);
3190
3191         while(1) {
3192                 to = -1;
3193                 who = ast_waitfor_n(carr, 2, &to);
3194
3195                 if (!who) {
3196                         CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
3197                         break;
3198                 }
3199                 f = ast_read(who);
3200
3201                 if (!f || f->frametype == AST_FRAME_CONTROL) {
3202                         if (!f)
3203                                 CDEBUG(NULL, NULL, "Got hangup.\n");
3204                         else
3205                                 CDEBUG(NULL, NULL, "Got CONTROL.\n");
3206                         /* got hangup .. */
3207                         *fo=f;
3208                         *rc=who;
3209                         break;
3210                 }
3211
3212                 if ( f->frametype == AST_FRAME_DTMF ) {
3213                         CDEBUG(NULL, NULL, "Got DTMF.\n");
3214                         *fo=f;
3215                         *rc=who;
3216                         break;
3217                 }
3218
3219
3220                 if (who == ast1) {
3221                         ast_write(ast2,f);
3222                 }
3223                 else {
3224                         ast_write(ast1,f);
3225                 }
3226
3227         }
3228
3229         CDEBUG(NULL, NULL, "Releasing bridge.\n");
3230
3231         /* split channels */
3232         ast_mutex_lock(&chan_lock);
3233 #if ASTERISK_VERSION_NUM < 110000
3234         call1 = ast1->tech_pvt;
3235         call2 = ast2->tech_pvt;
3236 #else
3237         call1 = ast_channel_tech_pvt(ast1);
3238         call2 = ast_channel_tech_pvt(ast2);
3239 #endif
3240         if (call1 && call1->bridge_id) {
3241                 call1->bridge_id = 0;
3242                 if (call1->bridge_call)
3243                         call1->bridge_call->bridge_call = NULL;
3244         }
3245         if (call2 && call1->bridge_id) {
3246                 call2->bridge_id = 0;
3247                 if (call2->bridge_call)
3248                         call2->bridge_call->bridge_call = NULL;
3249         }
3250         call1->bridge_call = NULL;
3251         call2->bridge_call = NULL;
3252
3253         ast_mutex_unlock(&chan_lock);
3254         return AST_BRIDGE_COMPLETE;
3255 }
3256 static struct ast_channel_tech lcr_tech = {
3257         .type= lcr_type,
3258         .description = "Channel driver for connecting to Linux-Call-Router",
3259         #if ASTERISK_VERSION_NUM < 100000
3260         .capabilities = AST_FORMAT_ALAW,
3261         #endif
3262         .requester = lcr_request,
3263
3264         #ifdef LCR_FOR_ASTERISK
3265         .send_digit_begin = lcr_digit_begin,
3266         .send_digit_end = lcr_digit_end,
3267         #endif
3268
3269         #ifdef LCR_FOR_CALLWEAVER
3270         .send_digit = lcr_digit,
3271         #endif
3272
3273         .call = lcr_call,
3274         .bridge = lcr_bridge,
3275         .hangup = lcr_hangup,
3276         .answer = lcr_answer,
3277         .read = lcr_read,
3278         .write = lcr_write,
3279         .indicate = lcr_indicate,
3280         .fixup = lcr_fixup,
3281         .send_text = lcr_send_text,
3282         .properties = 0
3283 };
3284
3285
3286 /*
3287  * cli
3288  */
3289 #if 0
3290 static int lcr_show_lcr (int fd, int argc, char *argv[])
3291 {
3292         return 0;
3293 }
3294
3295 static int lcr_show_calls (int fd, int argc, char *argv[])
3296 {
3297         return 0;
3298 }
3299
3300 static int lcr_reload_routing (int fd, int argc, char *argv[])
3301 {
3302         return 0;
3303 }
3304
3305 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
3306 {
3307         return 0;
3308 }
3309
3310 static int lcr_port_block (int fd, int argc, char *argv[])
3311 {
3312         return 0;
3313 }
3314
3315 static int lcr_port_unblock (int fd, int argc, char *argv[])
3316 {
3317         return 0;
3318 }
3319
3320 static int lcr_port_unload (int fd, int argc, char *argv[])
3321 {
3322         return 0;
3323 }
3324
3325 static struct ast_cli_entry cli_show_lcr =
3326 { {"lcr", "show", "lcr", NULL},
3327  lcr_show_lcr,
3328  "Shows current states of LCR core",
3329  "Usage: lcr show lcr\n",
3330 };
3331
3332 static struct ast_cli_entry cli_show_calls =
3333 { {"lcr", "show", "calls", NULL},
3334  lcr_show_calls,
3335  "Shows current calls made by LCR and Asterisk",
3336  "Usage: lcr show calls\n",
3337 };
3338
3339 static struct ast_cli_entry cli_reload_routing =
3340 { {"lcr", "reload", "routing", NULL},
3341  lcr_reload_routing,
3342  "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
3343  "Usage: lcr reload routing\n",
3344 };
3345
3346 static struct ast_cli_entry cli_reload_interfaces =
3347 { {"lcr", "reload", "interfaces", NULL},
3348  lcr_reload_interfaces,
3349  "Reloads interfaces conf of LCR",
3350  "Usage: lcr reload interfaces\n",
3351 };
3352
3353 static struct ast_cli_entry cli_port_block =
3354 { {"lcr", "port", "block", NULL},
3355  lcr_port_block,
3356  "Blocks LCR port for further calls",
3357  "Usage: lcr port block \"<port>\"\n",
3358 };
3359
3360 static struct ast_cli_entry cli_port_unblock =
3361 { {"lcr", "port", "unblock", NULL},
3362  lcr_port_unblock,
3363  "Unblocks or loads LCR port, port is opened my mISDN",
3364  "Usage: lcr port unblock \"<port>\"\n",
3365 };
3366
3367 static struct ast_cli_entry cli_port_unload =
3368 { {"lcr", "port", "unload", NULL},
3369  lcr_port_unload,
3370  "Unloads LCR port, port is closes by mISDN",
3371  "Usage: lcr port unload \"<port>\"\n",
3372 };
3373 #endif
3374
3375
3376 #ifdef LCR_FOR_ASTERISK
3377 #ifdef AST_1_8_OR_HIGHER
3378 static int lcr_config_exec(struct ast_channel *ast, const char *data)
3379 #else
3380 static int lcr_config_exec(struct ast_channel *ast, void *data)
3381 #endif
3382 #endif
3383
3384 #ifdef LCR_FOR_CALLWEAVER
3385 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
3386 #endif
3387 {
3388         struct chan_call *call;
3389
3390         ast_mutex_lock(&chan_lock);
3391
3392         #ifdef LCR_FOR_ASTERISK
3393         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
3394         #endif
3395
3396         #ifdef LCR_FOR_CALLWEAVER
3397         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
3398         #endif
3399
3400         /* find channel */
3401         call = call_first;
3402         while(call) {
3403                 if (call->ast == ast)
3404                         break;
3405                 call = call->next;
3406         }
3407         if (call)
3408
3409                 #ifdef LCR_FOR_ASTERISK
3410                 apply_opt(call, (char *)data);
3411                 #endif
3412
3413                 #ifdef LCR_FOR_CALLWEAVER
3414                 apply_opt(call, (char *)argv[0]);
3415                 #endif
3416
3417                 /* send options */
3418                 if (call->tx_queue) {
3419                         union parameter newparam;
3420
3421                         memset(&newparam, 0, sizeof(union parameter));
3422                         newparam.queue = call->tx_queue * 8;
3423                         send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
3424                 }
3425         else
3426                 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
3427
3428         ast_mutex_unlock(&chan_lock);
3429         return 0;
3430 }
3431
3432 /*
3433  * module loading and destruction
3434  */
3435 int load_module(void)
3436 {
3437         u_short i;
3438         char options_error[256];
3439
3440         for (i = 0; i < 256; i++) {
3441                 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
3442                              | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
3443         }
3444
3445         if (read_options(options_error) == 0) {
3446                 CERROR(NULL, NULL, "%s", options_error);
3447
3448                 #ifdef LCR_FOR_ASTERISK
3449                 return AST_MODULE_LOAD_DECLINE;
3450                 #endif
3451
3452                 #ifdef LCR_FOR_CALLWEAVER
3453                 return 0;
3454                 #endif
3455
3456         }
3457
3458         ast_mutex_init(&chan_lock);
3459         ast_mutex_init(&log_lock);
3460
3461         #if ASTERISK_VERSION_NUM < 100000
3462         lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
3463         #else
3464         struct ast_format tmp;
3465         ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
3466         if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
3467                 return AST_MODULE_LOAD_DECLINE;
3468         }
3469         ast_format_cap_add(lcr_tech.capabilities, &tmp);
3470         #endif
3471         if (ast_channel_register(&lcr_tech)) {
3472                 CERROR(NULL, NULL, "Unable to register channel class\n");
3473                 close_socket();
3474
3475                 #ifdef LCR_FOR_ASTERISK
3476                 return AST_MODULE_LOAD_DECLINE;
3477                 #endif
3478
3479                 #ifdef LCR_FOR_CALLWEAVER
3480                 return 0;
3481                 #endif
3482         }
3483
3484         ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
3485
3486                                  #ifdef LCR_FOR_ASTERISK
3487                                  "lcr_config(<opt><optarg>:<opt>:...)\n"
3488                                  #endif
3489
3490                                  #ifdef LCR_FOR_CALLWEAVER
3491                                  "lcr_config(<opt><optarg>:<opt>:...)\n",
3492                                  #endif
3493
3494                                  "Sets LCR opts. and optargs\n"
3495                                  "\n"
3496                                  "The available options are:\n"
3497                                  "    d - Send display text on called phone, text is the optarg.\n"
3498                                  "    n - Don't detect dtmf tones on called channel.\n"
3499                                  "    h - Force data call (HDLC).\n"
3500                                  "    q - Add queue to make fax stream seamless (required for fax app).\n"
3501                                  "        Use queue size in miliseconds for optarg. (try 250)\n"
3502                                  "    f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
3503                                  "        Use time to detect for optarg.\n"
3504 #if 0
3505                                  "    c - Make crypted outgoing call, optarg is keyindex.\n"
3506                                  "    e - Perform echo cancelation on this channel.\n"
3507 #endif
3508                                  "        Takes mISDN pipeline option as optarg.\n"
3509                                  "    s - Send Non Inband DTMF as inband.\n"
3510                                  "    r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
3511 #if 0
3512                                  "   vr - rxgain control\n"
3513                                  "   vt - txgain control\n"
3514 #endif
3515                                  "        Volume changes at factor 2 ^ optarg.\n"
3516                                  "    k - use keypad to dial this call.\n"
3517                                  "\n"
3518                                  "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
3519                                  " -> use 16 for fax (3.1k audio)\n"
3520                                  "\n"
3521                                  "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
3522                                  "options: \"n:t:q250\" for seamless audio transmission.\n"
3523                 );
3524
3525
3526 #if 0
3527         ast_cli_register(&cli_show_lcr);
3528         ast_cli_register(&cli_show_calls);
3529         ast_cli_register(&cli_reload_routing);
3530         ast_cli_register(&cli_reload_interfaces);
3531         ast_cli_register(&cli_port_block);
3532         ast_cli_register(&cli_port_unblock);
3533         ast_cli_register(&cli_port_unload);
3534 #endif
3535
3536         if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
3537                 /* failed to create thread */
3538                 close_socket();
3539                 ast_channel_unregister(&lcr_tech);
3540
3541                 #ifdef LCR_FOR_ASTERISK
3542                 return AST_MODULE_LOAD_DECLINE;
3543                 #endif
3544
3545                 #ifdef LCR_FOR_CALLWEAVER
3546                 return 0;
3547                 #endif
3548
3549         }
3550         return 0;
3551 }
3552
3553 int unload_module(void)
3554 {
3555         /* First, take us out of the channel loop */
3556         CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
3557
3558         pthread_cancel(chan_tid);
3559
3560         close_socket();
3561
3562         del_timer(&socket_retry);
3563
3564         unregister_fd(&wake_fd);
3565         close(wake_pipe[0]);
3566         close(wake_pipe[1]);
3567
3568 //      ast_mutex_unlock(&chan_lock);
3569
3570         ast_channel_unregister(&lcr_tech);
3571
3572         ast_unregister_application("lcr_config");
3573
3574         if (lcr_sock >= 0) {
3575                 close(lcr_sock);
3576                 lcr_sock = -1;
3577         }
3578
3579 #if ASTERISK_VERSION_NUM >= 100000
3580         lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
3581 #endif
3582         return 0;
3583 }
3584
3585 int reload_module(void)
3586 {
3587 //      reload_config();
3588         return 0;
3589 }
3590
3591 #ifdef LCR_FOR_ASTERISK
3592 #define AST_MODULE "chan_lcr"
3593 #endif
3594
3595 #ifdef LCR_FOR_CALLWEAVER
3596 int usecount(void)
3597 hae
3598 {
3599         int res;
3600         ast_mutex_lock(&usecnt_lock);
3601         res = usecnt;
3602         ast_mutex_unlock(&usecnt_lock);
3603         return res;
3604 }
3605 #endif
3606
3607 #ifdef LCR_FOR_ASTERISK
3608 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3609                 .load = load_module,
3610                 .unload = unload_module,
3611                 .reload = reload_module,
3612                );
3613 #endif
3614
3615 #ifdef LCR_FOR_CALLWEAVER
3616 char *description(void)
3617 {
3618         return desc;
3619 }
3620 #endif