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         newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
 650         newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 651         strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
 652         call->display[0] = '\0';
 653
 654 #ifdef AST_1_8_OR_HIGHER
 655         /* set stored call information */
 656         memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
 657         memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
 658 #else
 659         if (call->cid_num[0])
 660                 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
 661         if (call->cid_name[0])
 662                 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
 663         if (call->cid_rdnis[0]) {
 664                 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
 665                 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
 666                 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
 667         }
 668         switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
 669                 case AST_PRES_RESTRICTED:
 670                 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
 671                 break;
 672                 case AST_PRES_UNAVAILABLE:
 673                 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
 674                 break;
 675                 case AST_PRES_ALLOWED:
 676                 default:
 677                 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
 678         }
 679         switch(ast->cid.cid_ton) {
 680                 case 4:
 681                 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
 682                 break;
 683                 case 2:
 684                 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
 685                 break;
 686                 case 1:
 687                 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
 688                 break;
 689                 default:
 690                 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 691         }
 692 #endif
 693 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
 694 //      tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
 695 //      if (tmp && *tmp)
 696 #if ASTERISK_VERSION_NUM < 110000
 697 //              ast->transfercapability = atoi(tmp);
 698         newparam.setup.capainfo.bearer_capa = ast->transfercapability;
 699 #else
 700 //              ast_channel_transfercapability_set(ast, atoi(tmp));
 701         newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
 702 #endif
 703         newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
 704         if (call->hdlc)
 705                 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
 706         else {
 707                 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
 708                 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
 709         }
 710         newparam.setup.capainfo.hlc = INFO_HLC_NONE;
 711         newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
 712         send_message(MESSAGE_SETUP, call->ref, &newparam);
 713         if (call->tx_queue) {
 714                 memset(&newparam, 0, sizeof(union parameter));
 715                 newparam.queue = call->tx_queue * 8;
 716                 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
 717         }
 718
 719         /* change to outgoing setup state */
 720         call->state = CHAN_LCR_STATE_OUT_SETUP;
 721 }
 722
 723 /*
 724  * send dialing info to LCR
 725  * this function is called, when setup acknowledge is received and dialing
 726  * info is available.
 727  */
 728 static void send_dialque_to_lcr(struct chan_call *call)
 729 {
 730         union parameter newparam;
 731
 732         if (!call->ast || !call->ref || !call->dialque[0])
 733                 return;
 734
 735         CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
 736
 737         /* send setup message to LCR */
 738         memset(&newparam, 0, sizeof(union parameter));
 739         if (call->keypad)
 740                 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
 741         else
 742                 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
 743         call->dialque[0] = '\0';
 744         send_message(MESSAGE_INFORMATION, call->ref, &newparam);
 745 }
 746
 747 /*
 748  * in case of a bridge, the unsupported message can be forwarded directly
 749  * to the remote call.
 750  */
 751 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
 752 {
 753         /* check bridge */
 754         if (!call) return;
 755         if (!call->bridge_call) return;
 756         CDEBUG(call, NULL, "Sending message due bridging.\n");
 757         send_message(message_type, call->bridge_call->ref, param);
 758 }
 759
 760 /*
 761  * send release message to LCR
 762  */
 763 static void send_release(struct chan_call *call, int cause, int location)
 764 {
 765         union parameter newparam;
 766
 767         /* sending release */
 768         memset(&newparam, 0, sizeof(union parameter));
 769         newparam.disconnectinfo.cause = cause;
 770         newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
 771         send_message(MESSAGE_RELEASE, call->ref, &newparam);
 772 }
 773
 774 /*
 775  * check if extension matches and start asterisk
 776  * if it can match, proceed
 777  * if not, release
 778  */
 779 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
 780 {
 781         int cause, ret;
 782         union parameter newparam;
 783 #if ASTERISK_VERSION_NUM < 110000
 784         char *exten = ast->exten;
 785 #else
 786         char s_exten[AST_MAX_EXTENSION];
 787         char *exten=s_exten;
 788
 789         strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
 790 #endif
 791
 792 if (!*exten)
 793                 exten = "s";
 794
 795 #if ASTERISK_VERSION_NUM < 110000
 796         CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
 797 #else
 798         CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
 799 #endif
 800
 801         if (complete) {
 802                 /* if not match */
 803 #if ASTERISK_VERSION_NUM < 110000
 804                 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
 805 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
 806 #else
 807                 if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 808 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
 809 #endif
 810                         cause = 1;
 811                         goto release;
 812                 }
 813 #if ASTERISK_VERSION_NUM < 110000
 814                 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
 815                         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);
 816 #else
 817                 if (!ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 818                         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));
 819 #endif
 820                         cause = 28;
 821                         goto release;
 822                 }
 823                 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
 824                 /* send setup acknowledge to lcr */
 825                 memset(&newparam, 0, sizeof(union parameter));
 826                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
 827
 828                 /* change state */
 829                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
 830
 831                 goto start;
 832         }
 833
 834 #if ASTERISK_VERSION_NUM < 110000
 835         if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
 836 #else
 837         if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 838 #endif
 839                 /* send setup acknowledge to lcr */
 840                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 841                         memset(&newparam, 0, sizeof(union parameter));
 842                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 843                 }
 844
 845                 /* change state */
 846                 call->state = CHAN_LCR_STATE_IN_DIALING;
 847
 848                 /* if match, start pbx */
 849 #if ASTERISK_VERSION_NUM < 110000
 850         if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
 851 #else
 852         if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
 853 #endif
 854                         CDEBUG(call, ast, "Extensions matches.\n");
 855                         goto start;
 856                 }
 857
 858                 /* send setup acknowledge to lcr */
 859                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 860                         memset(&newparam, 0, sizeof(union parameter));
 861                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 862                 }
 863
 864                 /* change state */
 865                 call->state = CHAN_LCR_STATE_IN_DIALING;
 866
 867                 /* if can match */
 868                 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
 869                 return;
 870         }
 871
 872 #if ASTERISK_VERSION_NUM < 110000
 873         if (!*ast->exten) {
 874 #else
 875         if (!*ast_channel_exten(ast)) {
 876 #endif
 877                 /* send setup acknowledge to lcr */
 878                 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 879                         memset(&newparam, 0, sizeof(union parameter));
 880                         send_message(MESSAGE_OVERLAP, call->ref, &newparam);
 881                 }
 882
 883                 /* change state */
 884                 call->state = CHAN_LCR_STATE_IN_DIALING;
 885
 886                 /* if can match */
 887                 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
 888                 return;
 889         }
 890
 891         /* if not match */
 892         cause = 1;
 893         release:
 894         /* release lcr */
 895         CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
 896         send_release(call, cause, LOCATION_PRIVATE_LOCAL);
 897         call->ref = 0;
 898         /* release asterisk */
 899 #if ASTERISK_VERSION_NUM < 110000
 900         ast->hangupcause = call->cause;
 901 #else
 902         ast_channel_hangupcause_set(ast, call->cause);
 903 #endif
 904         /* change to release state */
 905         call->state = CHAN_LCR_STATE_RELEASE;
 906         ast_hangup(ast); // call will be destroyed here
 907         return;
 908
 909         start:
 910         /* send setup to asterisk */
 911         CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
 912
 913         #ifdef LCR_FOR_CALLWEAVER
 914         ast->type = "LCR";
 915         snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
 916         #endif
 917
 918         ret = ast_pbx_start(ast);
 919         if (ret < 0) {
 920                 cause = (ret==-2)?34:27;
 921                 goto release;
 922         }
 923         call->pbx_started = 1;
 924                 ast_setstate(ast, AST_STATE_RING);
 925 }
 926
 927 /*
 928  * incoming setup from LCR
 929  */
 930 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
 931 {
 932         struct ast_channel *ast;
 933 #ifdef AST_1_8_OR_HIGHER
 934         struct ast_party_redirecting *ast_redir;
 935         struct ast_party_caller *ast_caller;
 936 #else
 937         struct ast_callerid *ast_caller;
 938 #endif
 939 #if ASTERISK_VERSION_NUM >= 110000
 940         struct ast_party_redirecting s_ast_redir;
 941         struct ast_party_caller s_ast_caller;
 942         ast_party_redirecting_init(&s_ast_redir);
 943         ast_party_caller_init(&s_ast_caller);
 944 #endif
 945         CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
 946
 947         /* create asterisk channel instrance */
 948
 949         #ifdef LCR_FOR_CALLWEAVER
 950         ast = ast_channel_alloc(1);
 951         #endif
 952
 953         #ifdef LCR_FOR_ASTERISK
 954 #ifdef AST_1_8_OR_HIGHER
 955         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
 956 #else
 957         ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
 958 #endif
 959         #endif
 960
 961 #if ASTERISK_VERSION_NUM < 110000
 962 #ifdef AST_1_8_OR_HIGHER
 963         ast_redir = &ast->redirecting;
 964         ast_caller = &ast->caller;
 965 #else
 966         ast_caller = &ast->cid;
 967 #endif
 968 #else
 969         ast_redir = &s_ast_redir;
 970         ast_caller = &s_ast_caller;
 971 #endif
 972
 973         if (!ast) {
 974                 /* release */
 975                 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
 976                 send_release(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
 977                 /* remove call */
 978                 free_call(call);
 979                 return;
 980         }
 981         /* link together */
 982         call->ast = ast;
 983 #if ASTERISK_VERSION_NUM < 110000
 984         ast->tech_pvt = call;
 985         ast->tech = &lcr_tech;
 986         ast->fds[0] = call->pipe[0];
 987 #else
 988         ast_channel_tech_pvt_set(ast, call);
 989         ast_channel_tech_set(ast, &lcr_tech);
 990         ast_channel_set_fd(ast, 0, call->pipe[0]);
 991 #endif
 992
 993         /* fill setup information */
 994         if (param->setup.dialinginfo.id)
 995 #if ASTERISK_VERSION_NUM < 110000
 996                 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
 997         if (param->setup.dialinginfo.context[0])
 998                 strncpy(ast->context, param->setup.dialinginfo.context, AST_MAX_CONTEXT-1);
 999         else
1000                 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
1001 #else
1002                 ast_channel_exten_set(ast, param->setup.dialinginfo.id);
1003         if (param->setup.dialinginfo.context[0])
1004                 ast_channel_context_set(ast, param->setup.dialinginfo.context);
1005         else
1006                 ast_channel_context_set(ast, param->setup.callerinfo.interface);
1007 #endif
1008
1009
1010 #ifdef AST_1_8_OR_HIGHER
1011         if (param->setup.callerinfo.id[0]) {
1012                 ast_caller->id.number.valid = 1;
1013                 ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
1014                 if (!param->setup.callerinfo.id[0]) {
1015                         ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1016                         ast_caller->id.number.plan = (0 << 4) | 1;
1017                 }
1018                 switch (param->setup.callerinfo.present) {
1019                         case INFO_PRESENT_ALLOWED:
1020                                 ast_caller->id.number.presentation = AST_PRES_ALLOWED;
1021                         break;
1022                         case INFO_PRESENT_RESTRICTED:
1023                                 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1024                         break;
1025                         default:
1026                                 ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
1027                 }
1028                 switch (param->setup.callerinfo.screen) {
1029                         case INFO_SCREEN_USER:
1030                                 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1031                         break;
1032                         case INFO_SCREEN_USER_VERIFIED_PASSED:
1033                                 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1034                         break;
1035                         case INFO_SCREEN_USER_VERIFIED_FAILED:
1036                                 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1037                         break;
1038                         default:
1039                                 ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
1040                 }
1041                 switch (param->setup.callerinfo.ntype) {
1042                         case INFO_NTYPE_SUBSCRIBER:
1043                                 ast_caller->id.number.plan = (4 << 4) | 1;
1044                         break;
1045                         case INFO_NTYPE_NATIONAL:
1046                                 ast_caller->id.number.plan = (2 << 4) | 1;
1047                         break;
1048                         case INFO_NTYPE_INTERNATIONAL:
1049                                 ast_caller->id.number.plan = (1 << 4) | 1;
1050                         break;
1051                         default:
1052                                 ast_caller->id.number.plan = (0 << 4) | 1;
1053                 }
1054         }
1055         if (param->setup.callerinfo.id2[0]) {
1056                 ast_caller->ani.number.valid = 1;
1057                 ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
1058                 switch (param->setup.callerinfo.present2) {
1059                         case INFO_PRESENT_ALLOWED:
1060                                 ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
1061                         break;
1062                         case INFO_PRESENT_RESTRICTED:
1063                                 ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
1064                         break;
1065                         default:
1066                                 ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
1067                 }
1068                 switch (param->setup.callerinfo.screen2) {
1069                         case INFO_SCREEN_USER:
1070                                 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1071                         break;
1072                         case INFO_SCREEN_USER_VERIFIED_PASSED:
1073                                 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1074                         break;
1075                         case INFO_SCREEN_USER_VERIFIED_FAILED:
1076                                 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1077                         break;
1078                         default:
1079                                 ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
1080                 }
1081                 switch (param->setup.callerinfo.ntype2) {
1082                         case INFO_NTYPE_SUBSCRIBER:
1083                                 ast_caller->ani.number.plan = (4 << 4) | 1;
1084                         break;
1085                         case INFO_NTYPE_NATIONAL:
1086                                 ast_caller->ani.number.plan = (2 << 4) | 1;
1087                         break;
1088                         case INFO_NTYPE_INTERNATIONAL:
1089                                 ast_caller->ani.number.plan = (1 << 4) | 1;
1090                         break;
1091                         default:
1092                                 ast_caller->ani.number.plan = (0 << 4) | 1;
1093                 }
1094         }
1095         if (param->setup.callerinfo.name[0]) {
1096                 ast_caller->id.name.valid = 1;
1097                 ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
1098         }
1099 #if ASTERISK_VERSION_NUM >= 110000
1100         ast_channel_caller_set(ast, ast_caller);
1101 #endif
1102         if (param->setup.redirinfo.id[0]) {
1103                 ast_redir->from.number.valid = 1;
1104                 ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
1105                 switch (param->setup.redirinfo.present) {
1106                         case INFO_PRESENT_ALLOWED:
1107                                 ast_redir->from.number.presentation = AST_PRES_ALLOWED;
1108                         break;
1109                         case INFO_PRESENT_RESTRICTED:
1110                                 ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
1111                         break;
1112                         default:
1113                                 ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
1114                 }
1115                 switch (param->setup.redirinfo.screen) {
1116                         case INFO_SCREEN_USER:
1117                                 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1118                         break;
1119                         case INFO_SCREEN_USER_VERIFIED_PASSED:
1120                                 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1121                         break;
1122                         case INFO_SCREEN_USER_VERIFIED_FAILED:
1123                                 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1124                         break;
1125                         default:
1126                                 ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
1127                 }
1128                 switch (param->setup.redirinfo.ntype) {
1129                         case INFO_NTYPE_SUBSCRIBER:
1130                                 ast_redir->from.number.plan = (4 << 4) | 1;
1131                         break;
1132                         case INFO_NTYPE_NATIONAL:
1133                                 ast_redir->from.number.plan = (2 << 4) | 1;
1134                         break;
1135                         case INFO_NTYPE_INTERNATIONAL:
1136                                 ast_redir->from.number.plan = (1 << 4) | 1;
1137                         break;
1138                         default:
1139                                 ast_redir->from.number.plan = (0 << 4) | 1;
1140                 }
1141 #if ASTERISK_VERSION_NUM >= 110000
1142                 ast_channel_redirecting_set(ast, ast_redir);
1143 #endif
1144         }
1145 #else
1146         memset(&ast->cid, 0, sizeof(ast->cid));
1147         if (param->setup.callerinfo.id[0])
1148                 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
1149         if (param->setup.callerinfo.id2[0])
1150                 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
1151         if (param->setup.callerinfo.name[0])
1152                 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
1153         if (param->setup.redirinfo.id[0])
1154                 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
1155         switch (param->setup.callerinfo.present) {
1156                 case INFO_PRESENT_ALLOWED:
1157                         ast->cid.cid_pres = AST_PRES_ALLOWED;
1158                 break;
1159                 case INFO_PRESENT_RESTRICTED:
1160                         ast->cid.cid_pres = AST_PRES_RESTRICTED;
1161                 break;
1162                 default:
1163                         ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
1164         }
1165         switch (param->setup.callerinfo.ntype) {
1166                 case INFO_NTYPE_SUBSCRIBER:
1167                         ast->cid.cid_ton = 4;
1168                 break;
1169                 case INFO_NTYPE_NATIONAL:
1170                         ast->cid.cid_ton = 2;
1171                 break;
1172                 case INFO_NTYPE_INTERNATIONAL:
1173                         ast->cid.cid_ton = 1;
1174                 break;
1175                 default:
1176                         ast->cid.cid_ton = 0;
1177         }
1178 #endif
1179
1180 #if ASTERISK_VERSION_NUM < 110000
1181         ast->transfercapability = param->setup.capainfo.bearer_capa;
1182 #else
1183         ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
1184 #endif
1185         /* enable hdlc if transcap is data */
1186         if (param->setup.capainfo.source_mode == B_MODE_HDLC)
1187                 call->hdlc = 1;
1188         strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
1189
1190         /* configure channel */
1191 #if ASTERISK_VERSION_NUM < 100000
1192         ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1193         ast->readformat = ast->rawreadformat = ast->nativeformats;
1194         ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
1195 #else
1196 #if ASTERISK_VERSION_NUM < 110000
1197         ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1198         ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
1199         ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
1200         ast_set_write_format(ast, &ast->rawwriteformat);
1201         ast_set_read_format(ast, &ast->rawreadformat);
1202 #else
1203         ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1204         ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
1205         ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
1206         ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
1207         ast_set_read_format(ast, ast_channel_rawreadformat(ast));
1208 #endif
1209 #endif
1210 #if ASTERISK_VERSION_NUM < 110000
1211         ast->priority = 1;
1212         ast->hangupcause = 0;
1213 #else
1214         ast_channel_priority_set(ast, 1);
1215         ast_channel_hangupcause_set(ast, 0);
1216 #endif
1217
1218         /* change state */
1219         call->state = CHAN_LCR_STATE_IN_SETUP;
1220
1221         if (!call->pbx_started)
1222                 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
1223 }
1224
1225 /*
1226  * incoming setup acknowledge from LCR
1227  */
1228 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
1229 {
1230         if (!call->ast) return;
1231
1232         CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
1233
1234         /* send pending digits in dialque */
1235         if (call->dialque[0])
1236                 send_dialque_to_lcr(call);
1237         /* change to overlap state */
1238         call->state = CHAN_LCR_STATE_OUT_DIALING;
1239 }
1240
1241 /*
1242  * incoming proceeding from LCR
1243  */
1244 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
1245 {
1246         CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
1247
1248         /* change state */
1249         call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
1250         /* queue event for asterisk */
1251         if (call->ast && call->pbx_started) {
1252                 if (!wake_global) {
1253                         wake_global = 1;
1254                         char byte = 0;
1255                         int rc;
1256                         rc = write(wake_pipe[1], &byte, 1);
1257                 }
1258                 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
1259         }
1260
1261 }
1262
1263 /*
1264  * incoming alerting from LCR
1265  */
1266 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
1267 {
1268         CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
1269
1270         /* change state */
1271         call->state = CHAN_LCR_STATE_OUT_ALERTING;
1272         /* queue event to asterisk */
1273         if (call->ast && call->pbx_started) {
1274                 if (!wake_global) {
1275                         wake_global = 1;
1276                         char byte = 0;
1277                         int rc;
1278                         rc = write(wake_pipe[1], &byte, 1);
1279                 }
1280                 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1281         }
1282 }
1283
1284 /*
1285  * incoming connect from LCR
1286  */
1287 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1288 {
1289         CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1290
1291         /* change state */
1292         call->state = CHAN_LCR_STATE_CONNECT;
1293         /* copy connectinfo */
1294         memcpy(&call->connectinfo, &param->connectinfo, sizeof(struct connect_info));
1295         /* queue event to asterisk */
1296         if (call->ast && call->pbx_started) {
1297                 if (!wake_global) {
1298                         wake_global = 1;
1299                         char byte = 0;
1300                         int rc;
1301                         rc = write(wake_pipe[1], &byte, 1);
1302                 }
1303                 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1304         }
1305 }
1306
1307 /*
1308  * incoming disconnect from LCR
1309  */
1310 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1311 {
1312         struct ast_channel *ast = call->ast;
1313
1314         CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1315
1316         /* change state */
1317         call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1318         /* save cause */
1319         call->cause = param->disconnectinfo.cause;
1320         call->location = param->disconnectinfo.location;
1321         /* if bridge, forward disconnect and return */
1322 #ifdef TODO
1323         feature flag
1324         if (call->bridge_call) {
1325                 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1326                 bridge_message_if_bridged(call, message_type, param);
1327                 return;
1328         }
1329 #endif
1330         /* release lcr with same cause */
1331         send_release(call, call->cause, call->location);
1332         call->ref = 0;
1333         /* change to release state */
1334         call->state = CHAN_LCR_STATE_RELEASE;
1335         /* queue release asterisk */
1336         if (ast) {
1337 #if ASTERISK_VERSION_NUM < 110000
1338                 ast->hangupcause = call->cause;
1339 #else
1340                 ast_channel_hangupcause_set(ast, call->cause);
1341 #endif
1342                 if (call->pbx_started) {
1343                         if (!wake_global) {
1344                                 wake_global = 1;
1345                                 char byte = 0;
1346                                 int rc;
1347                                 rc = write(wake_pipe[1], &byte, 1);
1348                         }
1349                         strcpy(call->queue_string, "H"); // overwrite other indications
1350                 } else {
1351                         ast_hangup(ast); // call will be destroyed here
1352                 }
1353         }
1354 }
1355
1356 /*
1357  * incoming release from LCR
1358  */
1359 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1360 {
1361         struct ast_channel *ast = call->ast;
1362
1363         CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1364
1365         /* release ref */
1366         call->ref = 0;
1367         /* change to release state */
1368         call->state = CHAN_LCR_STATE_RELEASE;
1369         /* copy release info */
1370         if (!call->cause) {
1371                 call->cause = param->disconnectinfo.cause;
1372                 call->location = param->disconnectinfo.location;
1373         }
1374         /* if we have an asterisk instance, queue hangup, else we are done */
1375         if (ast) {
1376 #if ASTERISK_VERSION_NUM < 110000
1377                 ast->hangupcause = call->cause;
1378 #else
1379                 ast_channel_hangupcause_set(ast, call->cause);
1380 #endif
1381                 if (call->pbx_started) {
1382                         if (!wake_global) {
1383                                 wake_global = 1;
1384                                 char byte = 0;
1385                                 int rc;
1386                                 rc = write(wake_pipe[1], &byte, 1);
1387                         }
1388                         strcpy(call->queue_string, "H");
1389                 } else {
1390                         ast_hangup(ast); // call will be destroyed here
1391                 }
1392         } else {
1393                 free_call(call);
1394         }
1395
1396 }
1397
1398 /*
1399  * incoming information from LCR
1400  */
1401 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1402 {
1403         struct ast_channel *ast = call->ast;
1404
1405         CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1406
1407         if (!ast) return;
1408
1409         /* pbx not started */
1410         if (!call->pbx_started) {
1411                 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1412 #if ASTERISK_VERSION_NUM < 110000
1413                 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1414 #else
1415                 char *tmp[AST_MAX_EXTENSION];
1416                 snprintf(tmp,AST_MAX_EXTENSION,"%s%s",ast_channel_exten(ast),param->information.id);
1417                 ast_channel_exten_set(ast, tmp);
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         strncpy(newparam.newref.interface, call->interface, sizeof(newparam.newref.interface) - 1);
2429         send_message(MESSAGE_NEWREF, 0, &newparam);
2430
2431         /* set hdlc if capability requires hdlc */
2432 #if ASTERISK_VERSION_NUM < 110000
2433         if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
2434          || ast->transfercapability == INFO_BC_DATARESTRICTED
2435          || ast->transfercapability == INFO_BC_VIDEO)
2436 #else
2437         transfercapability=ast_channel_transfercapability(ast);
2438         if (transfercapability == INFO_BC_DATAUNRESTRICTED
2439          || transfercapability == INFO_BC_DATARESTRICTED
2440          || transfercapability == INFO_BC_VIDEO)
2441 #endif
2442                 call->hdlc = 1;
2443         /* if hdlc is forced by option, we change transcap to data */
2444         if (call->hdlc
2445 #if ASTERISK_VERSION_NUM < 110000
2446          && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
2447          && ast->transfercapability != INFO_BC_DATARESTRICTED
2448          && ast->transfercapability != INFO_BC_VIDEO)
2449                 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
2450 #else
2451          && transfercapability != INFO_BC_DATAUNRESTRICTED
2452          && transfercapability != INFO_BC_DATARESTRICTED
2453          && transfercapability != INFO_BC_VIDEO)
2454                 transfercapability = INFO_BC_DATAUNRESTRICTED;
2455 #endif
2456
2457 #ifndef AST_1_8_OR_HIGHER
2458         call->cid_num[0] = 0;
2459         call->cid_name[0] = 0;
2460         call->cid_rdnis[0] = 0;
2461
2462         if (ast->cid.cid_num) if (ast->cid.cid_num[0])
2463                 strncpy(call->cid_num, ast->cid.cid_num,
2464                         sizeof(call->cid_num)-1);
2465         if (ast->cid.cid_name) if (ast->cid.cid_name[0])
2466                 strncpy(call->cid_name, ast->cid.cid_name,
2467                         sizeof(call->cid_name)-1);
2468         if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
2469                 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
2470                         sizeof(call->cid_rdnis)-1);
2471 #endif
2472
2473         ast_mutex_unlock(&chan_lock);
2474         return 0;
2475 }
2476
2477 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2478 {
2479         static const char* dtmf_tones[] = {
2480                 "!941+1336/100,!0/100", /* 0 */
2481                 "!697+1209/100,!0/100", /* 1 */
2482                 "!697+1336/100,!0/100", /* 2 */
2483                 "!697+1477/100,!0/100", /* 3 */
2484                 "!770+1209/100,!0/100", /* 4 */
2485                 "!770+1336/100,!0/100", /* 5 */
2486                 "!770+1477/100,!0/100", /* 6 */
2487                 "!852+1209/100,!0/100", /* 7 */
2488                 "!852+1336/100,!0/100", /* 8 */
2489                 "!852+1477/100,!0/100", /* 9 */
2490                 "!697+1633/100,!0/100", /* A */
2491                 "!770+1633/100,!0/100", /* B */
2492                 "!852+1633/100,!0/100", /* C */
2493                 "!941+1633/100,!0/100", /* D */
2494                 "!941+1209/100,!0/100", /* * */
2495                 "!941+1477/100,!0/100" };       /* # */
2496
2497         if (digit >= '0' && digit <='9')
2498                 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2499         else if (digit >= 'A' && digit <= 'D')
2500                 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2501         else if (digit == '*')
2502                 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2503         else if (digit == '#')
2504                 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2505         else {
2506 #if ASTERISK_VERSION_NUM < 110000
2507                 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
2508 #else
2509                 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
2510 #endif
2511         }
2512 }
2513
2514 #ifdef LCR_FOR_ASTERISK
2515 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2516 #endif
2517 #ifdef LCR_FOR_CALLWEAVER
2518 static int lcr_digit(struct ast_channel *ast, char digit)
2519 #endif
2520 {
2521         struct chan_call *call;
2522         union parameter newparam;
2523         char buf[]="x";
2524
2525 #ifdef LCR_FOR_CALLWEAVER
2526         int inband_dtmf = 0;
2527 #endif
2528
2529         /* only pass IA5 number space */
2530         if (digit > 126 || digit < 32)
2531                 return 0;
2532
2533         ast_mutex_lock(&chan_lock);
2534 #if ASTERISK_VERSION_NUM < 110000
2535         call = ast->tech_pvt;
2536 #else
2537         call = ast_channel_tech_pvt(ast);
2538 #endif
2539         if (!call) {
2540                 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2541                 ast_mutex_unlock(&chan_lock);
2542                 return -1;
2543         }
2544
2545         CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2546
2547         /* send information or queue them */
2548         if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2549                 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2550                 memset(&newparam, 0, sizeof(union parameter));
2551                 if (call->keypad) {
2552                         newparam.information.keypad[0] = digit;
2553                         newparam.information.keypad[1] = '\0';
2554                 } else {
2555                         newparam.information.id[0] = digit;
2556                         newparam.information.id[1] = '\0';
2557                 }
2558                 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2559         } else
2560         if (!call->ref
2561          && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2562                 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2563                 *buf = digit;
2564                 strncat(call->dialque, buf, strlen(call->dialque)-1);
2565         }
2566
2567         ast_mutex_unlock(&chan_lock);
2568
2569 #ifdef LCR_FOR_ASTERISK
2570         return 0;
2571 }
2572
2573 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2574 {
2575         int inband_dtmf = 0;
2576         struct chan_call *call;
2577 #endif
2578
2579         ast_mutex_lock(&chan_lock);
2580
2581 #if ASTERISK_VERSION_NUM < 110000
2582         call = ast->tech_pvt;
2583 #else
2584         call = ast_channel_tech_pvt(ast);
2585 #endif
2586
2587         if (!call) {
2588                 CERROR(NULL, ast,
2589                         "Received digit from Asterisk, "
2590                         "but no call instance exists.\n");
2591                 ast_mutex_unlock(&chan_lock);
2592                 return -1;
2593         }
2594
2595         CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2596
2597         if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2598                 inband_dtmf = 1;
2599         }
2600
2601         ast_mutex_unlock(&chan_lock);
2602
2603         if (inband_dtmf) {
2604                 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2605                 send_digit_to_chan(ast, digit);
2606         }
2607
2608         return 0;
2609 }
2610
2611 static int lcr_answer(struct ast_channel *ast)
2612 {
2613         union parameter newparam;
2614         struct chan_call *call;
2615
2616         ast_mutex_lock(&chan_lock);
2617 #if ASTERISK_VERSION_NUM < 110000
2618         call = ast->tech_pvt;
2619 #else
2620         call = ast_channel_tech_pvt(ast);
2621 #endif
2622         if (!call) {
2623                 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2624                 ast_mutex_unlock(&chan_lock);
2625                 return -1;
2626         }
2627
2628         CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2629
2630         /* copy connectinfo, if bridged */
2631         if (call->bridge_call)
2632                 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2633         /* send connect message to lcr */
2634         if (call->state != CHAN_LCR_STATE_CONNECT) {
2635                 memset(&newparam, 0, sizeof(union parameter));
2636                 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2637                 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2638                 call->state = CHAN_LCR_STATE_CONNECT;
2639         }
2640         /* change state */
2641         /* enable keypad */
2642 //      memset(&newparam, 0, sizeof(union parameter));
2643 //      send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2644
2645         ast_mutex_unlock(&chan_lock);
2646         return 0;
2647 }
2648
2649 static int lcr_hangup(struct ast_channel *ast)
2650 {
2651         struct chan_call *call;
2652         pthread_t tid = pthread_self();
2653
2654         if (!pthread_equal(tid, chan_tid)) {
2655                 ast_mutex_lock(&chan_lock);
2656         }
2657 #if ASTERISK_VERSION_NUM < 110000
2658         call = ast->tech_pvt;
2659 #else
2660         call = ast_channel_tech_pvt(ast);
2661 #endif
2662         if (!call) {
2663                 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2664                 if (!pthread_equal(tid, chan_tid)) {
2665                         ast_mutex_unlock(&chan_lock);
2666                 }
2667                 return -1;
2668         }
2669
2670         if (!pthread_equal(tid, chan_tid))
2671                 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2672         else
2673                 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2674
2675         /* disconnect asterisk, maybe not required */
2676 #if ASTERISK_VERSION_NUM < 110000
2677         ast->tech_pvt = NULL;
2678         ast->fds[0] = -1;
2679 #else
2680         ast_channel_tech_pvt_set(ast, NULL);
2681         ast_channel_set_fd(ast, 0, -1);
2682 #endif
2683         if (call->ref) {
2684                 /* release */
2685                 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2686 #if ASTERISK_VERSION_NUM < 110000
2687                 if (ast->hangupcause > 0)
2688                         send_release(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2689 #else
2690                 if (ast_channel_hangupcause(ast) > 0)
2691                         send_release(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
2692 #endif
2693                 else
2694                         send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2695                 /* remove call */
2696                 free_call(call);
2697                 if (!pthread_equal(tid, chan_tid)) {
2698                         ast_mutex_unlock(&chan_lock);
2699                 }
2700                 return 0;
2701         } else {
2702                 /* ref is not set, due to prepare setup or release */
2703                 if (call->state == CHAN_LCR_STATE_RELEASE) {
2704                         /* we get the response to our release */
2705                         CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2706                         free_call(call);
2707                 } else {
2708                         /* during prepare, we change to release state */
2709                         CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2710                         call->state = CHAN_LCR_STATE_RELEASE;
2711                         call->ast = NULL;
2712                 }
2713         }
2714         if (!pthread_equal(tid, chan_tid)) {
2715                 ast_mutex_unlock(&chan_lock);
2716         }
2717         return 0;
2718 }
2719
2720 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2721 {
2722         union parameter newparam;
2723         struct chan_call *call;
2724         struct ast_frame * f = fr;
2725         unsigned char *p, *q;
2726         int len, l;
2727
2728 #if ASTERISK_VERSION_NUM < 100000
2729 #ifdef AST_1_8_OR_HIGHER
2730         if (!f->subclass.codec)
2731 #else
2732         if (!f->subclass)
2733 #endif
2734                 CDEBUG(NULL, ast, "No subclass\n");
2735 #endif
2736 #ifdef AST_1_8_OR_HIGHER
2737 #if ASTERISK_VERSION_NUM < 100000
2738 #if ASTERISK_VERSION_NUM < 110000
2739         if (!(f->subclass.codec & ast->nativeformats)) {
2740 #else
2741         if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
2742 #endif
2743 #else
2744 #if ASTERISK_VERSION_NUM < 110000
2745         if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
2746 #else
2747         if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
2748 #endif
2749 #endif
2750 #else
2751 #if ASTERISK_VERSION_NUM < 110000
2752         if (!(f->subclass & ast->nativeformats)) {
2753 #else
2754         if (!(f->subclass & ast_channel_nativeformats(ast))) {
2755 #endif
2756 #endif
2757                 CDEBUG(NULL, ast,
2758                                "Unexpected format. "
2759                        "Activating emergency conversion...\n");
2760
2761 #ifdef AST_1_8_OR_HIGHER
2762 #if ASTERISK_VERSION_NUM < 100000
2763                 ast_set_write_format(ast, f->subclass.codec);
2764 #else
2765                 ast_set_write_format(ast, &f->subclass.format);
2766 #endif
2767 #else
2768                 ast_set_write_format(ast, f->subclass);
2769 #endif
2770 #if ASTERISK_VERSION_NUM < 110000
2771                 f = (ast->writetrans) ? ast_translate(
2772                         ast->writetrans, fr, 0) : fr;
2773 #else
2774                 f = (ast_channel_writetrans(ast)) ? ast_translate(
2775                         ast_channel_writetrans(ast), fr, 0) : fr;
2776 #endif
2777         }
2778
2779         ast_mutex_lock(&chan_lock);
2780 #if ASTERISK_VERSION_NUM < 110000
2781         call = ast->tech_pvt;
2782 #else
2783         call = ast_channel_tech_pvt(ast);
2784 #endif
2785         if (!call || !call->ref) {
2786                 /* drop the frame, if no ref exists, but return successfull delivery, or asterisk will abort connection */
2787                 ast_mutex_unlock(&chan_lock);
2788                 if (f != fr) {
2789                         ast_frfree(f);
2790                 }
2791                 return 0;
2792         }
2793         len = f->samples;
2794         p = *((unsigned char **)&(f->data));
2795         q = newparam.traffic.data;
2796         memset(&newparam, 0, sizeof(union parameter));
2797         while (len) {
2798                 l = (len > sizeof(newparam.traffic.data)) ? sizeof(newparam.traffic.data) : len;
2799                 newparam.traffic.len = l;
2800                 len -= l;
2801                 for (; l; l--)
2802                         *q++ = flip_bits[*p++];
2803                 send_message(MESSAGE_TRAFFIC, call->ref, &newparam);
2804         }
2805         ast_mutex_unlock(&chan_lock);
2806         if (f != fr) {
2807                 ast_frfree(f);
2808         }
2809         return 0;
2810 }
2811
2812
2813 static struct ast_frame *lcr_read(struct ast_channel *ast)
2814 {
2815         struct chan_call *call;
2816         int len = 0;
2817         struct ast_frame *f = NULL;
2818
2819         ast_mutex_lock(&chan_lock);
2820 #if ASTERISK_VERSION_NUM < 110000
2821         call = ast->tech_pvt;
2822 #else
2823         call = ast_channel_tech_pvt(ast);
2824 #endif
2825         if (!call) {
2826                 ast_mutex_unlock(&chan_lock);
2827                 return NULL;
2828         }
2829         if (call->pipe[0] > -1) {
2830                 if (call->rebuffer && !call->hdlc) {
2831                         /* Make sure we have a complete 20ms (160byte) frame */
2832                         len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2833                         if (len > 0) {
2834                                 call->framepos += len;
2835                         }
2836                 } else {
2837                         len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2838                 }
2839                 if (len < 0 && errno == EAGAIN) {
2840                         ast_mutex_unlock(&chan_lock);
2841
2842                         #ifdef LCR_FOR_ASTERISK
2843                         return &ast_null_frame;
2844                         #endif
2845
2846                         #ifdef LCR_FOR_CALLWEAVER
2847                         return &nullframe;
2848                         #endif
2849
2850                 }
2851                 if (len <= 0) {
2852                         close(call->pipe[0]);
2853                         call->pipe[0] = -1;
2854                         global_change = 1;
2855                         ast_mutex_unlock(&chan_lock);
2856                         return NULL;
2857                 } else if (call->rebuffer && call->framepos < 160) {
2858                         /* Not a complete frame, so we send a null-frame */
2859                         ast_mutex_unlock(&chan_lock);
2860                         return &ast_null_frame;
2861                 }
2862         }
2863
2864         call->read_fr.frametype = AST_FRAME_VOICE;
2865 #ifdef AST_1_8_OR_HIGHER
2866 #if ASTERISK_VERSION_NUM < 100000
2867 #if ASTERISK_VERSION_NUM < 110000
2868         call->read_fr.subclass.codec = ast->nativeformats;
2869 #else
2870         call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
2871 #endif
2872 #else
2873 #if ASTERISK_VERSION_NUM < 110000
2874         ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
2875 #else
2876         ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
2877 #endif
2878         call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
2879 #endif
2880 #else
2881 #if ASTERISK_VERSION_NUM < 110000
2882         call->read_fr.subclass = ast->nativeformats;
2883 #else
2884         call->read_fr.subclass = ast_channel_nativeformats(ast);
2885 #endif
2886 #endif
2887         if (call->rebuffer) {
2888                 call->read_fr.datalen = call->framepos;
2889                 call->read_fr.samples = call->framepos;
2890                 call->framepos = 0;
2891         } else {
2892                 call->read_fr.datalen = len;
2893                 call->read_fr.samples = len;
2894         }
2895         call->read_fr.delivery = ast_tv(0,0);
2896         *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2897
2898         if (call->dsp)
2899                 f = ast_dsp_process(ast, call->dsp, &call->read_fr);
2900         if (f && f->frametype == AST_FRAME_DTMF)
2901                 CDEBUG(call, ast, "Asterisk detected inband DTMF: %c.\n", f->subclass.integer);
2902
2903         ast_mutex_unlock(&chan_lock);
2904
2905         if (f && f->frametype == AST_FRAME_DTMF)
2906                 return f;
2907
2908         return &call->read_fr;
2909 }
2910
2911 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2912 {
2913         union parameter newparam;
2914         int res = 0;
2915         struct chan_call *call;
2916         const struct ast_tone_zone_sound *ts = NULL;
2917
2918         ast_mutex_lock(&chan_lock);
2919 #if ASTERISK_VERSION_NUM < 110000
2920         call = ast->tech_pvt;
2921 #else
2922         call = ast_channel_tech_pvt(ast);
2923 #endif
2924         if (!call) {
2925                 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2926                 ast_mutex_unlock(&chan_lock);
2927                 return -1;
2928         }
2929
2930         switch (cond) {
2931                 case AST_CONTROL_BUSY:
2932                         CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2933                         ast_setstate(ast, AST_STATE_BUSY);
2934                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2935                                 /* send message to lcr */
2936                                 memset(&newparam, 0, sizeof(union parameter));
2937                                 newparam.disconnectinfo.cause = 17;
2938                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2939                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2940                                 /* change state */
2941                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2942                         } else {
2943                                 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2944 #if ASTERISK_VERSION_NUM < 110000
2945                                 ts = ast_get_indication_tone(ast->zone, "busy");
2946 #else
2947                                 ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
2948 #endif
2949                         }
2950                         break;
2951                 case AST_CONTROL_CONGESTION:
2952 #if ASTERISK_VERSION_NUM < 110000
2953                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2954 #else
2955                         CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
2956 #endif
2957                         if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2958                                 /* send message to lcr */
2959                                 memset(&newparam, 0, sizeof(union parameter));
2960 #if ASTERISK_VERSION_NUM < 110000
2961                                 newparam.disconnectinfo.cause = ast->hangupcause;
2962 #else
2963                                 newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
2964 #endif
2965                                 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2966                                 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2967                                 /* change state */
2968                                 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2969                         } else {
2970                                 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2971 #if ASTERISK_VERSION_NUM < 110000
2972                                 ts = ast_get_indication_tone(ast->zone, "congestion");
2973 #else
2974                                 ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
2975 #endif
2976                         }
2977                         break;
2978                 case AST_CONTROL_PROCEEDING:
2979                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2980                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2981                          || call->state == CHAN_LCR_STATE_IN_DIALING) {
2982                                 /* send message to lcr */
2983                                 memset(&newparam, 0, sizeof(union parameter));
2984                                 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2985                                 /* change state */
2986                                 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2987                         }
2988                         break;
2989                 case AST_CONTROL_RINGING:
2990                         CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2991                         ast_setstate(ast, AST_STATE_RING);
2992                         if (call->state == CHAN_LCR_STATE_IN_SETUP
2993                          || call->state == CHAN_LCR_STATE_IN_DIALING
2994                          || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2995                                 /* send message to lcr */
2996                                 memset(&newparam, 0, sizeof(union parameter));
2997                                 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2998                                 /* change state */
2999                                 call->state = CHAN_LCR_STATE_IN_ALERTING;
3000                         } else {
3001                                 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
3002 #if ASTERISK_VERSION_NUM < 110000
3003                                 ts = ast_get_indication_tone(ast->zone, "ring");
3004 #else
3005                                 ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
3006 #endif
3007                         }
3008                         break;
3009                 case AST_CONTROL_PROGRESS:
3010                         CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
3011                         /* request bchannel */
3012                         CDEBUG(call, ast, "Requesting audio path.\n");
3013                         memset(&newparam, 0, sizeof(union parameter));
3014                         send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
3015                         break;
3016                 case -1:
3017                         CDEBUG(call, ast, "Received indicate -1.\n");
3018                         ast_playtones_stop(ast);
3019                         res = -1;
3020                         break;
3021
3022                 case AST_CONTROL_VIDUPDATE:
3023                         CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
3024                         res = -1;
3025                         break;
3026                 case AST_CONTROL_HOLD:
3027                         CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
3028                         /* send message to lcr */
3029                         memset(&newparam, 0, sizeof(union parameter));
3030                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
3031                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3032
3033                         /*start music onhold*/
3034                         #ifdef LCR_FOR_ASTERISK
3035                         #if ASTERISK_VERSION_NUM <110000
3036                         ast_moh_start(ast,data,ast->musicclass);
3037                         #else
3038                         ast_moh_start(ast,data,ast_channel_musicclass(ast));
3039                         #endif
3040                         #endif
3041
3042                         #ifdef LCR_FOR_CALLWEAVER
3043                         ast_moh_start(ast, NULL);
3044                         #endif
3045
3046                         call->on_hold = 1;
3047                         break;
3048                 case AST_CONTROL_UNHOLD:
3049                         CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
3050                         /* send message to lcr */
3051                         memset(&newparam, 0, sizeof(union parameter));
3052                         newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3053                         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3054
3055                         /*stop moh*/
3056                         ast_moh_stop(ast);
3057                         call->on_hold = 0;
3058                         break;
3059 #ifdef AST_CONTROL_SRCUPDATE
3060                 case AST_CONTROL_SRCUPDATE:
3061 #else
3062                 case 20:
3063 #endif
3064                         CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
3065                         break;
3066                 default:
3067                         CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
3068                         res = -1;
3069                         break;
3070         }
3071
3072         if (ts && ts->data[0]) {
3073                 ast_playtones_start(ast, 0, ts->data, 1);
3074         }
3075
3076         /* return */
3077         ast_mutex_unlock(&chan_lock);
3078         return res;
3079 }
3080
3081 /*
3082  * fixup asterisk
3083  */
3084 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
3085 {
3086         struct chan_call *call;
3087
3088         if (!ast) {
3089                 return -1;
3090         }
3091
3092         ast_mutex_lock(&chan_lock);
3093 #if ASTERISK_VERSION_NUM < 110000
3094         call = ast->tech_pvt;
3095 #else
3096         call = ast_channel_tech_pvt(ast);
3097 #endif
3098         if (!call) {
3099                 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
3100                 ast_mutex_unlock(&chan_lock);
3101                 return -1;
3102         }
3103
3104         CDEBUG(call, ast, "Received fixup from Asterisk.\n");
3105         call->ast = ast;
3106         ast_mutex_unlock(&chan_lock);
3107         return 0;
3108 }
3109
3110 /*
3111  * send_text asterisk
3112  */
3113 static int lcr_send_text(struct ast_channel *ast, const char *text)
3114 {
3115         struct chan_call *call;
3116         union parameter newparam;
3117
3118         ast_mutex_lock(&chan_lock);
3119 #if ASTERISK_VERSION_NUM < 110000
3120         call = ast->tech_pvt;
3121 #else
3122         call = ast_channel_tech_pvt(ast);
3123 #endif
3124         if (!call) {
3125                 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
3126                 ast_mutex_unlock(&chan_lock);
3127                 return -1;
3128         }
3129
3130         CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
3131         memset(&newparam, 0, sizeof(union parameter));
3132         strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
3133         send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3134         ast_mutex_unlock(&chan_lock);
3135         return 0;
3136 }
3137
3138 /*
3139  * bridge process
3140  */
3141 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
3142                                   struct ast_channel *ast2, int flags,
3143                                   struct ast_frame **fo,
3144                                   struct ast_channel **rc, int timeoutms)
3145
3146 {
3147         struct chan_call        *call1, *call2;
3148         struct ast_channel      *carr[2], *who;
3149         int                     to;
3150         struct ast_frame        *f;
3151         int                     bridge_id;
3152
3153 /* bridge is disabled, because there is currerntly no concept to bridge mISDN channels */
3154 return AST_BRIDGE_FAILED;
3155
3156         CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
3157
3158         carr[0] = ast1;
3159         carr[1] = ast2;
3160
3161         /* join via dsp (if the channels are currently open) */
3162         ast_mutex_lock(&chan_lock);
3163 #if ASTERISK_VERSION_NUM < 110000
3164         call1 = ast1->tech_pvt;
3165         call2 = ast2->tech_pvt;
3166 #else
3167         call1 = ast_channel_tech_pvt(ast1);
3168         call2 = ast_channel_tech_pvt(ast2);
3169 #endif
3170         if (!call1 || !call2) {
3171                 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
3172                 ast_mutex_unlock(&chan_lock);
3173                 return AST_BRIDGE_COMPLETE;
3174         }
3175
3176         /* join, if both call instances uses dsp
3177            ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
3178         */
3179         CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
3180
3181         /* get bridge id and join */
3182         bridge_id = new_bridge_id();
3183
3184         call1->bridge_id = bridge_id;
3185         call2->bridge_id = bridge_id;
3186         // FIXME: do bridiging
3187         // bchannel_join(call1->bchannel, bridge_id);
3188         // bchannel_join(call2->bchannel, bridge_id);
3189
3190         call1->bridge_call = call2;
3191         call2->bridge_call = call1;
3192
3193         if (call1->state == CHAN_LCR_STATE_IN_SETUP
3194          || call1->state == CHAN_LCR_STATE_IN_DIALING
3195          || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
3196          || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
3197                 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3198                 lcr_answer(ast1);
3199         }
3200         if (call2->state == CHAN_LCR_STATE_IN_SETUP
3201          || call2->state == CHAN_LCR_STATE_IN_DIALING
3202          || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
3203          || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
3204                 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3205                 lcr_answer(ast2);
3206         }
3207
3208         /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
3209            so let's do it for them. Hmpf.
3210         */
3211
3212         if (call1->on_hold) {
3213                 union parameter newparam;
3214
3215                 memset(&newparam, 0, sizeof(union parameter));
3216                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3217                 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
3218
3219                 call1->on_hold = 0;
3220         }
3221
3222         if (call2->on_hold) {
3223                 union parameter newparam;
3224
3225                 memset(&newparam, 0, sizeof(union parameter));
3226                 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3227                 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
3228
3229                 call2->on_hold = 0;
3230         }
3231
3232         ast_mutex_unlock(&chan_lock);
3233
3234         while(1) {
3235                 to = -1;
3236                 who = ast_waitfor_n(carr, 2, &to);
3237
3238                 if (!who) {
3239                         CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
3240                         break;
3241                 }
3242                 f = ast_read(who);
3243
3244                 if (!f || f->frametype == AST_FRAME_CONTROL) {
3245                         if (!f)
3246                                 CDEBUG(NULL, NULL, "Got hangup.\n");
3247                         else
3248                                 CDEBUG(NULL, NULL, "Got CONTROL.\n");
3249                         /* got hangup .. */
3250                         *fo=f;
3251                         *rc=who;
3252                         break;
3253                 }
3254
3255                 if ( f->frametype == AST_FRAME_DTMF ) {
3256                         CDEBUG(NULL, NULL, "Got DTMF.\n");
3257                         *fo=f;
3258                         *rc=who;
3259                         break;
3260                 }
3261
3262
3263                 if (who == ast1) {
3264                         ast_write(ast2,f);
3265                 }
3266                 else {
3267                         ast_write(ast1,f);
3268                 }
3269
3270         }
3271
3272         CDEBUG(NULL, NULL, "Releasing bridge.\n");
3273
3274         /* split channels */
3275         ast_mutex_lock(&chan_lock);
3276 #if ASTERISK_VERSION_NUM < 110000
3277         call1 = ast1->tech_pvt;
3278         call2 = ast2->tech_pvt;
3279 #else
3280         call1 = ast_channel_tech_pvt(ast1);
3281         call2 = ast_channel_tech_pvt(ast2);
3282 #endif
3283         if (call1 && call1->bridge_id) {
3284                 call1->bridge_id = 0;
3285                 if (call1->bridge_call)
3286                         call1->bridge_call->bridge_call = NULL;
3287         }
3288         if (call2 && call1->bridge_id) {
3289                 call2->bridge_id = 0;
3290                 if (call2->bridge_call)
3291                         call2->bridge_call->bridge_call = NULL;
3292         }
3293         call1->bridge_call = NULL;
3294         call2->bridge_call = NULL;
3295
3296         ast_mutex_unlock(&chan_lock);
3297         return AST_BRIDGE_COMPLETE;
3298 }
3299 static struct ast_channel_tech lcr_tech = {
3300         .type= lcr_type,
3301         .description = "Channel driver for connecting to Linux-Call-Router",
3302         #if ASTERISK_VERSION_NUM < 100000
3303         .capabilities = AST_FORMAT_ALAW,
3304         #endif
3305         .requester = lcr_request,
3306
3307         #ifdef LCR_FOR_ASTERISK
3308         .send_digit_begin = lcr_digit_begin,
3309         .send_digit_end = lcr_digit_end,
3310         #endif
3311
3312         #ifdef LCR_FOR_CALLWEAVER
3313         .send_digit = lcr_digit,
3314         #endif
3315
3316         .call = lcr_call,
3317         .bridge = lcr_bridge,
3318         .hangup = lcr_hangup,
3319         .answer = lcr_answer,
3320         .read = lcr_read,
3321         .write = lcr_write,
3322         .indicate = lcr_indicate,
3323         .fixup = lcr_fixup,
3324         .send_text = lcr_send_text,
3325         .properties = 0
3326 };
3327
3328
3329 /*
3330  * cli
3331  */
3332 #if 0
3333 static int lcr_show_lcr (int fd, int argc, char *argv[])
3334 {
3335         return 0;
3336 }
3337
3338 static int lcr_show_calls (int fd, int argc, char *argv[])
3339 {
3340         return 0;
3341 }
3342
3343 static int lcr_reload_routing (int fd, int argc, char *argv[])
3344 {
3345         return 0;
3346 }
3347
3348 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
3349 {
3350         return 0;
3351 }
3352
3353 static int lcr_port_block (int fd, int argc, char *argv[])
3354 {
3355         return 0;
3356 }
3357
3358 static int lcr_port_unblock (int fd, int argc, char *argv[])
3359 {
3360         return 0;
3361 }
3362
3363 static int lcr_port_unload (int fd, int argc, char *argv[])
3364 {
3365         return 0;
3366 }
3367
3368 static struct ast_cli_entry cli_show_lcr =
3369 { {"lcr", "show", "lcr", NULL},
3370  lcr_show_lcr,
3371  "Shows current states of LCR core",
3372  "Usage: lcr show lcr\n",
3373 };
3374
3375 static struct ast_cli_entry cli_show_calls =
3376 { {"lcr", "show", "calls", NULL},
3377  lcr_show_calls,
3378  "Shows current calls made by LCR and Asterisk",
3379  "Usage: lcr show calls\n",
3380 };
3381
3382 static struct ast_cli_entry cli_reload_routing =
3383 { {"lcr", "reload", "routing", NULL},
3384  lcr_reload_routing,
3385  "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
3386  "Usage: lcr reload routing\n",
3387 };
3388
3389 static struct ast_cli_entry cli_reload_interfaces =
3390 { {"lcr", "reload", "interfaces", NULL},
3391  lcr_reload_interfaces,
3392  "Reloads interfaces conf of LCR",
3393  "Usage: lcr reload interfaces\n",
3394 };
3395
3396 static struct ast_cli_entry cli_port_block =
3397 { {"lcr", "port", "block", NULL},
3398  lcr_port_block,
3399  "Blocks LCR port for further calls",
3400  "Usage: lcr port block \"<port>\"\n",
3401 };
3402
3403 static struct ast_cli_entry cli_port_unblock =
3404 { {"lcr", "port", "unblock", NULL},
3405  lcr_port_unblock,
3406  "Unblocks or loads LCR port, port is opened my mISDN",
3407  "Usage: lcr port unblock \"<port>\"\n",
3408 };
3409
3410 static struct ast_cli_entry cli_port_unload =
3411 { {"lcr", "port", "unload", NULL},
3412  lcr_port_unload,
3413  "Unloads LCR port, port is closes by mISDN",
3414  "Usage: lcr port unload \"<port>\"\n",
3415 };
3416 #endif
3417
3418
3419 #ifdef LCR_FOR_ASTERISK
3420 #ifdef AST_1_8_OR_HIGHER
3421 static int lcr_config_exec(struct ast_channel *ast, const char *data)
3422 #else
3423 static int lcr_config_exec(struct ast_channel *ast, void *data)
3424 #endif
3425 #endif
3426
3427 #ifdef LCR_FOR_CALLWEAVER
3428 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
3429 #endif
3430 {
3431         struct chan_call *call;
3432
3433         ast_mutex_lock(&chan_lock);
3434
3435         #ifdef LCR_FOR_ASTERISK
3436         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
3437         #endif
3438
3439         #ifdef LCR_FOR_CALLWEAVER
3440         CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
3441         #endif
3442
3443         /* find channel */
3444         call = call_first;
3445         while(call) {
3446                 if (call->ast == ast)
3447                         break;
3448                 call = call->next;
3449         }
3450         if (call)
3451
3452                 #ifdef LCR_FOR_ASTERISK
3453                 apply_opt(call, (char *)data);
3454                 #endif
3455
3456                 #ifdef LCR_FOR_CALLWEAVER
3457                 apply_opt(call, (char *)argv[0]);
3458                 #endif
3459
3460                 /* send options */
3461                 if (call->tx_queue) {
3462                         union parameter newparam;
3463
3464                         memset(&newparam, 0, sizeof(union parameter));
3465                         newparam.queue = call->tx_queue * 8;
3466                         send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
3467                 }
3468         else
3469                 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
3470
3471         ast_mutex_unlock(&chan_lock);
3472         return 0;
3473 }
3474
3475 /*
3476  * module loading and destruction
3477  */
3478 int load_module(void)
3479 {
3480         u_short i;
3481         char options_error[256];
3482
3483         for (i = 0; i < 256; i++) {
3484                 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
3485                              | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
3486         }
3487
3488         if (read_options(options_error) == 0) {
3489                 CERROR(NULL, NULL, "%s", options_error);
3490
3491                 #ifdef LCR_FOR_ASTERISK
3492                 return AST_MODULE_LOAD_DECLINE;
3493                 #endif
3494
3495                 #ifdef LCR_FOR_CALLWEAVER
3496                 return 0;
3497                 #endif
3498
3499         }
3500
3501         ast_mutex_init(&chan_lock);
3502         ast_mutex_init(&log_lock);
3503
3504         #if ASTERISK_VERSION_NUM < 100000
3505         lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
3506         #else
3507         struct ast_format tmp;
3508         ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
3509         if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
3510                 return AST_MODULE_LOAD_DECLINE;
3511         }
3512         ast_format_cap_add(lcr_tech.capabilities, &tmp);
3513         #endif
3514         if (ast_channel_register(&lcr_tech)) {
3515                 CERROR(NULL, NULL, "Unable to register channel class\n");
3516                 close_socket();
3517
3518                 #ifdef LCR_FOR_ASTERISK
3519                 return AST_MODULE_LOAD_DECLINE;
3520                 #endif
3521
3522                 #ifdef LCR_FOR_CALLWEAVER
3523                 return 0;
3524                 #endif
3525         }
3526
3527         ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
3528
3529                                  #ifdef LCR_FOR_ASTERISK
3530                                  "lcr_config(<opt><optarg>:<opt>:...)\n"
3531                                  #endif
3532
3533                                  #ifdef LCR_FOR_CALLWEAVER
3534                                  "lcr_config(<opt><optarg>:<opt>:...)\n",
3535                                  #endif
3536
3537                                  "Sets LCR opts. and optargs\n"
3538                                  "\n"
3539                                  "The available options are:\n"
3540                                  "    d - Send display text on called phone, text is the optarg.\n"
3541                                  "    n - Don't detect dtmf tones from LCR.\n"
3542                                  "    h - Force data call (HDLC).\n"
3543                                  "    q - Add queue to make fax stream seamless (required for fax app).\n"
3544                                  "        Use queue size in miliseconds for optarg. (try 250)\n"
3545                                  "    a - Adding DTMF detection.\n"
3546                                  "    f - Adding fax detection.\n"
3547 #if 0
3548                                  "    c - Make crypted outgoing call, optarg is keyindex.\n"
3549                                  "    e - Perform echo cancelation on this channel.\n"
3550 #endif
3551                                  "        Takes mISDN pipeline option as optarg.\n"
3552                                  "    s - Send Non Inband DTMF as inband. (disables LCR's DTMF)\n"
3553                                  "    r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
3554 #if 0
3555                                  "   vr - rxgain control\n"
3556                                  "   vt - txgain control\n"
3557 #endif
3558                                  "        Volume changes at factor 2 ^ optarg.\n"
3559                                  "    k - use keypad to dial this call.\n"
3560                                  "\n"
3561                                  "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
3562                                  " -> use 16 for fax (3.1k audio)\n"
3563                                  "\n"
3564                                  "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
3565                                  "options: \"n:t:q250\" for seamless audio transmission.\n"
3566                 );
3567
3568
3569 #if 0
3570         ast_cli_register(&cli_show_lcr);
3571         ast_cli_register(&cli_show_calls);
3572         ast_cli_register(&cli_reload_routing);
3573         ast_cli_register(&cli_reload_interfaces);
3574         ast_cli_register(&cli_port_block);
3575         ast_cli_register(&cli_port_unblock);
3576         ast_cli_register(&cli_port_unload);
3577 #endif
3578
3579         if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
3580                 /* failed to create thread */
3581                 close_socket();
3582                 ast_channel_unregister(&lcr_tech);
3583
3584                 #ifdef LCR_FOR_ASTERISK
3585                 return AST_MODULE_LOAD_DECLINE;
3586                 #endif
3587
3588                 #ifdef LCR_FOR_CALLWEAVER
3589                 return 0;
3590                 #endif
3591
3592         }
3593         return 0;
3594 }
3595
3596 int unload_module(void)
3597 {
3598         /* First, take us out of the channel loop */
3599         CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
3600
3601         pthread_cancel(chan_tid);
3602
3603         close_socket();
3604
3605         del_timer(&socket_retry);
3606
3607         unregister_fd(&wake_fd);
3608         close(wake_pipe[0]);
3609         close(wake_pipe[1]);
3610
3611 //      ast_mutex_unlock(&chan_lock);
3612
3613         ast_channel_unregister(&lcr_tech);
3614
3615         ast_unregister_application("lcr_config");
3616
3617         if (lcr_sock >= 0) {
3618                 close(lcr_sock);
3619                 lcr_sock = -1;
3620         }
3621
3622 #if ASTERISK_VERSION_NUM >= 100000
3623         lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
3624 #endif
3625         return 0;
3626 }
3627
3628 int reload_module(void)
3629 {
3630 //      reload_config();
3631         return 0;
3632 }
3633
3634 #ifdef LCR_FOR_ASTERISK
3635 #define AST_MODULE "chan_lcr"
3636 #endif
3637
3638 #ifdef LCR_FOR_CALLWEAVER
3639 int usecount(void)
3640 hae
3641 {
3642         int res;
3643         ast_mutex_lock(&usecnt_lock);
3644         res = usecnt;
3645         ast_mutex_unlock(&usecnt_lock);
3646         return res;
3647 }
3648 #endif
3649
3650 #ifdef LCR_FOR_ASTERISK
3651 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3652                 .load = load_module,
3653                 .unload = unload_module,
3654                 .reload = reload_module,
3655                );
3656 #endif
3657
3658 #ifdef LCR_FOR_CALLWEAVER
3659 char *description(void)
3660 {
3661         return desc;
3662 }
3663 #endif