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