chan_lcr.c

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