1 /*****************************************************************************\
3 ** Linux Call Router **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** Asterisk socket client **
10 \*****************************************************************************/
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.
21 Call is initiated by LCR:
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.
33 Call is initiated by Asterisk:
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.
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.
58 Call is released by LCR:
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".
73 Call is released by Asterisk:
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".
88 The deadlocking problem:
90 - chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel
92 - ast_channel thread locks ast_channel and calls a tech function and waits
93 there for chan_lock to be unlocked.
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.
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.
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 */
118 #include <sys/types.h>
120 //#include <signal.h>
123 #include <sys/ioctl.h>
124 #include <sys/socket.h>
127 #include <semaphore.h>
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
135 #include <asterisk/compiler.h>
136 #ifdef LCR_FOR_ASTERISK
137 #include <asterisk/buildopts.h>
139 #include <asterisk/module.h>
140 #include <asterisk/channel.h>
141 #include <asterisk/config.h>
142 #include <asterisk/logger.h>
143 #include <asterisk/pbx.h>
144 #include <asterisk/options.h>
145 #include <asterisk/io.h>
146 #include <asterisk/frame.h>
147 #include <asterisk/translate.h>
148 #include <asterisk/cli.h>
149 #include <asterisk/musiconhold.h>
150 #include <asterisk/dsp.h>
151 #include <asterisk/translate.h>
152 #include <asterisk/file.h>
153 #ifdef LCR_FOR_ASTERISK
154 #include <asterisk/callerid.h>
156 #ifdef LCR_FOR_CALLWEAVER
157 #include <asterisk/phone_no_utils.h>
160 #include <asterisk/indications.h>
161 #include <asterisk/app.h>
162 #include <asterisk/features.h>
163 #include <asterisk/sched.h>
165 #include "extension.h"
167 #include "callerid.h"
168 #include "lcrsocket.h"
171 #include "bchannel.h"
173 #include "chan_lcr.h"
175 CHAN_LCR_STATE // state description structure
176 MESSAGES // message text
178 #ifdef LCR_FOR_CALLWEAVER
179 AST_MUTEX_DEFINE_STATIC(rand_lock);
182 unsigned char flip_bits[256];
184 #ifdef LCR_FOR_CALLWEAVER
185 static struct ast_frame nullframe = { AST_FRAME_NULL, };
191 char lcr_type[]="lcr";
193 #ifdef LCR_FOR_CALLWEAVER
194 static ast_mutex_t usecnt_lock;
196 static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
200 ast_mutex_t chan_lock; /* global lock */
201 ast_mutex_t log_lock; /* logging log */
203 * used to indicate change in file descriptors, so select function's result may
206 int global_change = 0;
209 struct lcr_fd wake_fd;
213 int glob_channel = 0;
216 struct lcr_fd socket_fd;
217 struct lcr_timer socket_retry;
220 struct admin_list *next;
221 struct admin_message msg;
222 } *admin_first = NULL;
224 static struct ast_channel_tech lcr_tech;
226 void lock_debug(char *text)
228 pthread_t tid = pthread_self();
229 // printf("%s|%03x\n", text, ((tid>>6) | (tid>>3) | tid) & 0xfff); fflush(stdout);
230 printf(" %s(%x) ", text, (int)tid); fflush(stdout);
236 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, ...)
239 char call_text[128] = "NULL";
240 char ast_text[128] = "NULL";
244 ast_mutex_lock(&log_lock);
248 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
249 buffer[sizeof(buffer)-1]=0;
253 sprintf(call_text, "%d", call->ref);
255 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
256 ast_text[sizeof(ast_text)-1] = '\0';
258 ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
260 ast_mutex_unlock(&log_lock);
265 * channel and call instances
267 struct chan_call *call_first;
271 * special case: 0: find new ref, that has not been assigned a ref yet
274 struct chan_call *find_call_ref(unsigned int ref)
276 struct chan_call *call = call_first;
277 int assigned = (ref > 0);
280 if (call->ref == ref && call->ref_was_assigned == assigned)
287 void free_call(struct chan_call *call)
289 struct chan_call **temp = &call_first;
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->bchannel) {
299 if (call->bchannel->call != call)
300 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
301 call->bchannel->call = NULL;
303 if (call->bridge_call) {
304 if (call->bridge_call->bridge_call != call)
305 CERROR(call, NULL, "Linked call structure has no link to us.\n");
306 call->bridge_call->bridge_call = NULL;
309 ast_translator_free_path(call->trans);
311 ast_dsp_free(call->dsp);
312 CDEBUG(call, NULL, "Call instance freed.\n");
317 temp = &((*temp)->next);
319 CERROR(call, NULL, "Call instance not found in list.\n");
322 struct chan_call *alloc_call(void)
324 struct chan_call **callp = &call_first;
327 callp = &((*callp)->next);
329 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
331 memset(*callp, 0, sizeof(struct chan_call));
332 if (pipe((*callp)->pipe) < 0) {
333 CERROR(*callp, NULL, "Failed to create pipe.\n");
337 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
338 CDEBUG(*callp, NULL, "Call instance allocated.\n");
342 unsigned short new_bridge_id(void)
344 struct chan_call *call;
345 unsigned short id = 1;
347 /* search for lowest bridge id that is not in use and not 0 */
351 if (call->bridge_id == id)
359 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
364 * enque message to LCR
366 int send_message(int message_type, unsigned int ref, union parameter *param)
368 struct admin_list *admin, **adminp;
371 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
374 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
376 adminp = &admin_first;
378 adminp = &((*adminp)->next);
379 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
381 CERROR(NULL, NULL, "No memory for message to LCR.\n");
386 admin->msg.message = ADMIN_MESSAGE;
387 admin->msg.u.msg.type = message_type;
388 admin->msg.u.msg.ref = ref;
389 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
390 socket_fd.when |= LCR_FD_WRITE;
394 write(wake_pipe[1], &byte, 1);
401 * apply options (in locked state)
403 void apply_opt(struct chan_call *call, char *data)
405 union parameter newparam;
406 char string[1024], *p = string, *opt, *key;
412 strncpy(string, data, sizeof(string)-1);
413 string[sizeof(string)-1] = '\0';
416 while((opt = strsep(&p, ":"))) {
419 if (opt[1] == '\0') {
420 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
423 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
424 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
425 strncpy(call->display, opt+1, sizeof(call->display)-1);
427 memset(&newparam, 0, sizeof(union parameter));
428 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
429 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
433 if (opt[1] != '\0') {
434 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
437 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
438 if (call->dsp_dtmf) {
441 bchannel_dtmf(call->bchannel, 0);
445 if (opt[1] == '\0') {
446 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
450 /* check for 0xXXXX... type of key */
451 if (!!strncmp((char *)key, "0x", 2)) {
452 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
456 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
457 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
462 if (*key>='0' && *key<='9')
463 call->bf_key[i] = (*key-'0') << 8;
464 else if (*key>='a' && *key<='f')
465 call->bf_key[i] = (*key-'a'+10) << 8;
466 else if (*key>='A' && *key<='F')
467 call->bf_key[i] = (*key-'A'+10) << 8;
471 if (*key>='0' && *key<='9')
472 call->bf_key[i] += (*key - '0');
473 else if (*key>='a' && *key<='f')
474 call->bf_key[i] += (*key - 'a' + 10);
475 else if (*key>='A' && *key<='F')
476 call->bf_key[i] += (*key - 'A' + 10);
483 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
487 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
489 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
492 if (opt[1] != '\0') {
493 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
496 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
501 if (opt[1] != '\0') {
502 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
505 CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
510 if (opt[1] == '\0') {
511 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
514 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
515 call->nodsp_queue = atoi(opt+1);
518 if (opt[1] == '\0') {
519 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
522 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
523 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
525 bchannel_pipeline(call->bchannel, call->pipeline);
528 if (opt[1] == '\0') {
529 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
532 call->faxdetect=atoi(opt+1);
534 call->dsp=ast_dsp_new();
536 #ifdef LCR_FOR_CALLWEAVER
537 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
539 #ifdef LCR_FOR_ASTERISK
540 #ifdef DSP_FEATURE_DTMF_DETECT
541 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
543 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
548 #ifdef LCR_FOR_CALLWEAVER
549 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
551 #ifdef LCR_FOR_ASTERISK
552 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
555 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
558 if (opt[1] != '\0') {
559 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
562 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
567 if (opt[1] != '\0') {
568 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
571 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
572 call->inband_dtmf = 1;
575 if (opt[1] != 'r' && opt[1] != 't') {
576 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
580 if (gain < -8 || gain >8) {
581 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
584 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
586 call->rx_gain = gain;
588 bchannel_gain(call->bchannel, call->rx_gain, 0);
590 call->tx_gain = gain;
592 bchannel_gain(call->bchannel, call->tx_gain, 1);
596 if (opt[1] != '\0') {
597 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
600 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
605 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
609 /* re-open, if bchannel is created */
610 if (call->bchannel && call->bchannel->b_sock > -1) {
611 bchannel_destroy(call->bchannel);
612 if (bchannel_create(call->bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
613 bchannel_activate(call->bchannel, 1);
618 * send setup info to LCR
619 * this function is called, when asterisk call is received and ref is received
621 static void send_setup_to_lcr(struct chan_call *call)
623 union parameter newparam;
624 struct ast_channel *ast = call->ast;
627 if (!call->ast || !call->ref)
630 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
632 /* send setup message to LCR */
633 memset(&newparam, 0, sizeof(union parameter));
634 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
635 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
637 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
639 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
640 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
641 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
642 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
643 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
644 call->display[0] = '\0';
645 if (call->cid_num[0])
646 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
647 if (call->cid_name[0])
648 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
649 if (call->cid_rdnis[0]) {
650 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
651 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
652 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
654 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
655 case AST_PRES_RESTRICTED:
656 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
658 case AST_PRES_UNAVAILABLE:
659 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
661 case AST_PRES_ALLOWED:
663 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
665 switch(ast->cid.cid_ton) {
667 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
670 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
673 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
676 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
678 tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
680 ast->transfercapability = atoi(tmp);
681 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
682 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
684 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
686 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
687 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
689 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
690 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
691 send_message(MESSAGE_SETUP, call->ref, &newparam);
693 /* change to outgoing setup state */
694 call->state = CHAN_LCR_STATE_OUT_SETUP;
698 * send dialing info to LCR
699 * this function is called, when setup acknowledge is received and dialing
702 static void send_dialque_to_lcr(struct chan_call *call)
704 union parameter newparam;
706 if (!call->ast || !call->ref || !call->dialque[0])
709 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
711 /* send setup message to LCR */
712 memset(&newparam, 0, sizeof(union parameter));
714 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
716 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
717 call->dialque[0] = '\0';
718 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
722 * in case of a bridge, the unsupported message can be forwarded directly
723 * to the remote call.
725 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
729 if (!call->bridge_call) return;
730 CDEBUG(call, NULL, "Sending message due bridging.\n");
731 send_message(message_type, call->bridge_call->ref, param);
735 * send release message to LCR and import bchannel if exported
737 static void send_release_and_import(struct chan_call *call, int cause, int location)
739 union parameter newparam;
741 /* importing channel */
742 if (call->bchannel) {
743 memset(&newparam, 0, sizeof(union parameter));
744 newparam.bchannel.type = BCHANNEL_RELEASE;
745 newparam.bchannel.handle = call->bchannel->handle;
746 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
748 /* sending release */
749 memset(&newparam, 0, sizeof(union parameter));
750 newparam.disconnectinfo.cause = cause;
751 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
752 send_message(MESSAGE_RELEASE, call->ref, &newparam);
756 * check if extension matches and start asterisk
757 * if it can match, proceed
760 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
763 union parameter newparam;
764 char *exten = ast->exten;
768 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
772 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
773 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
777 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
778 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);
782 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
783 /* send setup acknowledge to lcr */
784 memset(&newparam, 0, sizeof(union parameter));
785 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
788 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
793 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
794 /* send setup acknowledge to lcr */
795 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
796 memset(&newparam, 0, sizeof(union parameter));
797 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
801 call->state = CHAN_LCR_STATE_IN_DIALING;
803 /* if match, start pbx */
804 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
805 CDEBUG(call, ast, "Extensions matches.\n");
810 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
816 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
824 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
825 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
827 /* release asterisk */
828 ast->hangupcause = call->cause;
829 /* change to release state */
830 call->state = CHAN_LCR_STATE_RELEASE;
831 ast_hangup(ast); // call will be destroyed here
835 /* send setup to asterisk */
836 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
838 #ifdef LCR_FOR_CALLWEAVER
840 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
843 ret = ast_pbx_start(ast);
845 cause = (ret==-2)?34:27;
848 call->pbx_started = 1;
849 ast_setstate(ast, AST_STATE_RING);
853 * incoming setup from LCR
855 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
857 struct ast_channel *ast;
859 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
861 /* create asterisk channel instrance */
863 #ifdef LCR_FOR_CALLWEAVER
864 ast = ast_channel_alloc(1);
867 #ifdef LCR_FOR_ASTERISK
868 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
873 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
874 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
881 ast->tech_pvt = call;
882 ast->tech = &lcr_tech;
883 ast->fds[0] = call->pipe[0];
885 /* fill setup information */
886 if (param->setup.dialinginfo.id)
887 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
888 if (param->setup.context[0])
889 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
891 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
892 if (param->setup.callerinfo.id[0])
893 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
894 if (param->setup.callerinfo.name[0])
895 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
896 if (param->setup.redirinfo.id[0])
897 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
898 switch (param->setup.callerinfo.present) {
899 case INFO_PRESENT_ALLOWED:
900 ast->cid.cid_pres = AST_PRES_ALLOWED;
902 case INFO_PRESENT_RESTRICTED:
903 ast->cid.cid_pres = AST_PRES_RESTRICTED;
906 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
908 switch (param->setup.callerinfo.ntype) {
909 case INFO_NTYPE_SUBSCRIBER:
910 ast->cid.cid_ton = 4;
912 case INFO_NTYPE_NATIONAL:
913 ast->cid.cid_ton = 2;
915 case INFO_NTYPE_INTERNATIONAL:
916 ast->cid.cid_ton = 1;
919 ast->cid.cid_ton = 0;
921 ast->transfercapability = param->setup.capainfo.bearer_capa;
922 /* enable hdlc if transcap is data */
923 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
925 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
927 /* configure channel */
928 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
929 ast->readformat = ast->rawreadformat = ast->nativeformats;
930 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
932 ast->hangupcause = 0;
935 call->state = CHAN_LCR_STATE_IN_SETUP;
937 if (!call->pbx_started)
938 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
942 * incoming setup acknowledge from LCR
944 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
946 if (!call->ast) return;
948 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
950 /* send pending digits in dialque */
951 if (call->dialque[0])
952 send_dialque_to_lcr(call);
953 /* change to overlap state */
954 call->state = CHAN_LCR_STATE_OUT_DIALING;
958 * incoming proceeding from LCR
960 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
962 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
965 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
966 /* queue event for asterisk */
967 if (call->ast && call->pbx_started) {
971 write(wake_pipe[1], &byte, 1);
973 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
979 * incoming alerting from LCR
981 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
983 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
986 call->state = CHAN_LCR_STATE_OUT_ALERTING;
987 /* queue event to asterisk */
988 if (call->ast && call->pbx_started) {
992 write(wake_pipe[1], &byte, 1);
994 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
999 * incoming connect from LCR
1001 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1003 union parameter newparam;
1005 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1008 call->state = CHAN_LCR_STATE_CONNECT;
1009 /* request bchannel */
1010 if (!call->bchannel) {
1011 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1012 memset(&newparam, 0, sizeof(union parameter));
1013 newparam.bchannel.type = BCHANNEL_REQUEST;
1014 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1016 /* copy connectinfo */
1017 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1018 /* queue event to asterisk */
1019 if (call->ast && call->pbx_started) {
1023 write(wake_pipe[1], &byte, 1);
1025 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1030 * incoming disconnect from LCR
1032 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1034 struct ast_channel *ast = call->ast;
1036 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1039 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1041 call->cause = param->disconnectinfo.cause;
1042 call->location = param->disconnectinfo.location;
1043 /* if bridge, forward disconnect and return */
1046 if (call->bridge_call) {
1047 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1048 bridge_message_if_bridged(call, message_type, param);
1052 /* release lcr with same cause */
1053 send_release_and_import(call, call->cause, call->location);
1055 /* change to release state */
1056 call->state = CHAN_LCR_STATE_RELEASE;
1057 /* queue release asterisk */
1059 ast->hangupcause = call->cause;
1060 if (call->pbx_started) {
1064 write(wake_pipe[1], &byte, 1);
1066 strcpy(call->queue_string, "H"); // overwrite other indications
1068 ast_hangup(ast); // call will be destroyed here
1074 * incoming release from LCR
1076 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1078 struct ast_channel *ast = call->ast;
1080 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1084 /* change to release state */
1085 call->state = CHAN_LCR_STATE_RELEASE;
1086 /* copy release info */
1088 call->cause = param->disconnectinfo.cause;
1089 call->location = param->disconnectinfo.location;
1091 /* if we have an asterisk instance, queue hangup, else we are done */
1093 ast->hangupcause = call->cause;
1094 if (call->pbx_started) {
1098 write(wake_pipe[1], &byte, 1);
1100 strcpy(call->queue_string, "H");
1102 ast_hangup(ast); // call will be destroyed here
1111 * incoming information from LCR
1113 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1115 struct ast_channel *ast = call->ast;
1117 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1121 /* pbx not started */
1122 if (!call->pbx_started) {
1123 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1124 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1125 lcr_start_pbx(call, ast, param->information.sending_complete);
1129 /* change dailing state after setup */
1130 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1131 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1132 call->state = CHAN_LCR_STATE_IN_DIALING;
1133 // ast_setstate(ast, AST_STATE_DIALING);
1137 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1141 write(wake_pipe[1], &byte, 1);
1143 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1146 /* use bridge to forware message not supported by asterisk */
1147 if (call->state == CHAN_LCR_STATE_CONNECT) {
1148 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1149 bridge_message_if_bridged(call, message_type, param);
1154 * incoming information from LCR
1156 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1158 union parameter newparam;
1160 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1162 /* request bchannel, if call is resumed and we don't have it */
1163 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1164 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1165 memset(&newparam, 0, sizeof(union parameter));
1166 newparam.bchannel.type = BCHANNEL_REQUEST;
1167 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1170 if (!call->ast) return;
1172 /* use bridge to forware message not supported by asterisk */
1173 bridge_message_if_bridged(call, message_type, param);
1177 * incoming information from LCR
1179 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1181 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1183 if (!call->ast) return;
1185 /* use bridge to forware message not supported by asterisk */
1186 bridge_message_if_bridged(call, message_type, param);
1190 * incoming pattern from LCR
1192 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1194 union parameter newparam;
1196 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1198 if (!call->ast) return;
1200 /* pattern are indicated only once */
1201 if (call->has_pattern)
1203 call->has_pattern = 1;
1205 /* request bchannel */
1206 if (!call->bchannel) {
1207 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1208 memset(&newparam, 0, sizeof(union parameter));
1209 newparam.bchannel.type = BCHANNEL_REQUEST;
1210 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1212 /* queue PROGRESS, because tones are available */
1213 if (call->ast && call->pbx_started) {
1217 write(wake_pipe[1], &byte, 1);
1219 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1224 * got dtmf from bchannel (locked state)
1226 void lcr_in_dtmf(struct chan_call *call, int val)
1228 struct ast_channel *ast = call->ast;
1233 if (!call->pbx_started)
1236 if (!call->dsp_dtmf) {
1237 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1241 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1247 write(wake_pipe[1], &byte, 1);
1249 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1253 * message received from LCR
1255 int receive_message(int message_type, unsigned int ref, union parameter *param)
1257 struct bchannel *bchannel;
1258 struct chan_call *call;
1259 union parameter newparam;
1261 memset(&newparam, 0, sizeof(union parameter));
1263 /* handle bchannel message*/
1264 if (message_type == MESSAGE_BCHANNEL) {
1265 switch(param->bchannel.type) {
1266 case BCHANNEL_ASSIGN:
1267 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1268 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1269 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1272 /* create bchannel */
1273 bchannel = alloc_bchannel(param->bchannel.handle);
1275 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1279 /* configure channel */
1280 bchannel->b_tx_gain = param->bchannel.tx_gain;
1281 bchannel->b_rx_gain = param->bchannel.rx_gain;
1282 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1283 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1284 bchannel->b_bf_len = param->bchannel.crypt_len;
1285 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1287 bchannel->b_txdata = 0;
1288 bchannel->b_tx_dejitter = 1;
1290 /* in case, ref is not set, this bchannel instance must
1291 * be created until it is removed again by LCR */
1293 call = find_call_ref(ref);
1295 bchannel->call = call;
1296 call->bchannel = bchannel;
1298 bchannel_dtmf(bchannel, 1);
1300 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1301 if (call->pipeline[0])
1302 bchannel_pipeline(bchannel, call->pipeline);
1304 bchannel_gain(bchannel, call->rx_gain, 0);
1306 bchannel_gain(bchannel, call->tx_gain, 1);
1307 if (call->bridge_id) {
1308 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1309 bchannel_join(bchannel, call->bridge_id);
1311 /* create only, if call exists, othewhise it bchannel is freed below... */
1312 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1313 bchannel_activate(bchannel, 1);
1316 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1317 newparam.bchannel.handle = param->bchannel.handle;
1318 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1319 /* if call has released before bchannel is assigned */
1321 newparam.bchannel.type = BCHANNEL_RELEASE;
1322 newparam.bchannel.handle = param->bchannel.handle;
1323 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1328 case BCHANNEL_REMOVE:
1329 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1330 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1331 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1334 /* unklink from call and destroy bchannel */
1335 free_bchannel(bchannel);
1338 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1339 newparam.bchannel.handle = param->bchannel.handle;
1340 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1345 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1350 /* handle new ref */
1351 if (message_type == MESSAGE_NEWREF) {
1352 if (param->direction) {
1353 /* new ref from lcr */
1354 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1355 if (!ref || find_call_ref(ref)) {
1356 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1359 /* allocate new call instance */
1360 call = alloc_call();
1362 call->state = CHAN_LCR_STATE_IN_PREPARE;
1365 call->ref_was_assigned = 1;
1366 /* set dtmf (default, use option 'n' to disable */
1368 /* wait for setup (or release from asterisk) */
1370 /* new ref, as requested from this remote application */
1371 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1372 call = find_call_ref(0);
1374 /* send release, if ref does not exist */
1375 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1376 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1381 call->ref_was_assigned = 1;
1382 /* set dtmf (default, use option 'n' to disable */
1384 /* send pending setup info */
1385 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1386 send_setup_to_lcr(call);
1387 /* release if asterisk has signed off */
1388 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1391 send_release_and_import(call, call->cause, call->location);
1393 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1404 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1407 call = find_call_ref(ref);
1409 /* ignore ref that is not used (anymore) */
1410 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1414 /* handle messages */
1415 switch(message_type) {
1417 lcr_in_setup(call, message_type, param);
1420 case MESSAGE_OVERLAP:
1421 lcr_in_overlap(call, message_type, param);
1424 case MESSAGE_PROCEEDING:
1425 lcr_in_proceeding(call, message_type, param);
1428 case MESSAGE_ALERTING:
1429 lcr_in_alerting(call, message_type, param);
1432 case MESSAGE_CONNECT:
1433 lcr_in_connect(call, message_type, param);
1436 case MESSAGE_DISCONNECT:
1437 lcr_in_disconnect(call, message_type, param);
1440 case MESSAGE_RELEASE:
1441 lcr_in_release(call, message_type, param);
1444 case MESSAGE_INFORMATION:
1445 lcr_in_information(call, message_type, param);
1448 case MESSAGE_NOTIFY:
1449 lcr_in_notify(call, message_type, param);
1452 case MESSAGE_FACILITY:
1453 lcr_in_facility(call, message_type, param);
1456 case MESSAGE_PATTERN: // audio available from LCR
1457 if (!call->has_pattern)
1458 lcr_in_pattern(call, message_type, param);
1461 case MESSAGE_NOPATTERN: // audio not available from LCR
1464 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1465 call->audiopath = param->audiopath;
1469 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1476 * release all calls (due to broken socket)
1478 static void release_all_calls(void)
1480 struct chan_call *call;
1485 /* no ast, so we may directly free call */
1487 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1491 /* already in release process */
1492 if (call->state == CHAN_LCR_STATE_RELEASE) {
1496 /* release or queue release */
1498 call->state = CHAN_LCR_STATE_RELEASE;
1499 if (!call->pbx_started) {
1500 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1501 ast_hangup(call->ast); // call will be destroyed here
1504 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1508 write(wake_pipe[1], &byte, 1);
1510 strcpy(call->queue_string, "H");
1514 /* release all bchannels */
1515 while(bchannel_first)
1516 free_bchannel(bchannel_first);
1519 void close_socket(void);
1522 * warning! not thread safe
1523 * returns -1 for socket error, 0 for no work, 1 for work
1525 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1528 struct admin_list *admin;
1529 struct admin_message msg;
1531 lock_debug("handle+");
1532 if ((what & LCR_FD_READ)) {
1533 /* read from socket */
1534 len = read(lcr_sock, &msg, sizeof(msg));
1536 CERROR(NULL, NULL, "Socket closed.\n");
1538 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1540 release_all_calls();
1541 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1542 lock_debug("handle-");
1546 if (len != sizeof(msg)) {
1547 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1550 if (msg.message != ADMIN_MESSAGE) {
1551 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1554 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1556 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1561 if ((what & LCR_FD_WRITE)) {
1562 /* write to socket */
1564 socket_fd.when &= ~LCR_FD_WRITE;
1565 lock_debug("handle-");
1568 admin = admin_first;
1569 len = write(lcr_sock, &admin->msg, sizeof(msg));
1571 CERROR(NULL, NULL, "Socket closed.\n");
1575 if (len != sizeof(msg)) {
1576 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1580 admin_first = admin->next;
1584 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1589 lock_debug("handle-");
1594 * open and close socket and thread
1596 int open_socket(void)
1599 struct sockaddr_un sock_address;
1600 union parameter param;
1603 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1604 CERROR(NULL, NULL, "Failed to create socket.\n");
1608 /* set socket address and name */
1609 memset(&sock_address, 0, sizeof(sock_address));
1610 sock_address.sun_family = PF_UNIX;
1611 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1613 /* connect socket */
1614 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1617 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1621 /* register socket fd */
1622 memset(&socket_fd, 0, sizeof(socket_fd));
1623 socket_fd.fd = lcr_sock;
1624 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1626 /* enque hello message */
1627 memset(¶m, 0, sizeof(param));
1628 strcpy(param.hello.application, "asterisk");
1629 send_message(MESSAGE_HELLO, 0, ¶m);
1634 void close_socket(void)
1636 struct admin_list *admin, *temp;
1638 unregister_fd(&socket_fd);
1640 /* flush pending messages */
1641 admin = admin_first;
1644 admin = admin->next;
1657 /* sending queue to asterisk */
1658 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1662 lock_debug("wake+");
1663 read(wake_pipe[0], &byte, 1);
1666 lock_debug("wake-");
1671 static void handle_queue()
1673 struct chan_call *call;
1674 struct ast_channel *ast;
1675 struct ast_frame fr;
1680 p = call->queue_string;
1684 ast_channel_lock(ast);
1689 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1690 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1693 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1694 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1697 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1698 ast_queue_control(ast, AST_CONTROL_RINGING);
1699 ast_setstate(ast, AST_STATE_RINGING);
1702 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1703 ast_queue_control(ast, AST_CONTROL_ANSWER);
1706 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1707 ast_queue_hangup(ast);
1709 case '1': case '2': case '3': case 'A':
1710 case '4': case '5': case '6': case 'B':
1711 case '7': case '8': case '9': case 'C':
1712 case '*': case '0': case '#': case 'D':
1713 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1714 /* send digit to asterisk */
1715 memset(&fr, 0, sizeof(fr));
1717 #ifdef LCR_FOR_ASTERISK
1718 fr.frametype = AST_FRAME_DTMF_BEGIN;
1721 #ifdef LCR_FOR_CALLWEAVER
1722 fr.frametype = AST_FRAME_DTMF;
1726 fr.delivery = ast_tv(0, 0);
1727 ast_queue_frame(ast, &fr);
1729 #ifdef LCR_FOR_ASTERISK
1730 fr.frametype = AST_FRAME_DTMF_END;
1731 ast_queue_frame(ast, &fr);
1736 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1740 call->queue_string[0] = '\0';
1741 ast_channel_unlock(ast);
1748 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1750 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1751 if (open_socket() < 0)
1752 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1757 void lock_chan(void)
1760 ast_mutex_lock(&chan_lock);
1764 void unlock_chan(void)
1766 ast_mutex_unlock(&chan_lock);
1770 /* chan_lcr thread */
1771 static void *chan_thread(void *arg)
1773 if (pipe(wake_pipe) < 0) {
1774 CERROR(NULL, NULL, "Failed to open pipe.\n");
1777 memset(&wake_fd, 0, sizeof(wake_fd));
1778 wake_fd.fd = wake_pipe[0];
1779 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1781 memset(&socket_retry, 0, sizeof(socket_retry));
1782 add_timer(&socket_retry, handle_retry, NULL, 0);
1784 bchannel_pid = getpid();
1786 /* open socket the first time */
1787 handle_retry(NULL, NULL, 0);
1790 ast_mutex_lock(&chan_lock);
1795 select_main(0, &global_change, lock_chan, unlock_chan);
1800 del_timer(&socket_retry);
1802 unregister_fd(&wake_fd);
1803 close(wake_pipe[0]);
1804 close(wake_pipe[1]);
1806 CERROR(NULL, NULL, "Thread exit.\n");
1808 ast_mutex_unlock(&chan_lock);
1815 * new asterisk instance
1818 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1820 char exten[256], *dial, *interface, *opt;
1821 struct ast_channel *ast;
1822 struct chan_call *call;
1825 ast_mutex_lock(&chan_lock);
1827 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1829 /* if socket is closed */
1831 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1832 ast_mutex_unlock(&chan_lock);
1837 /* create call instance */
1838 call = alloc_call();
1840 /* failed to create instance */
1841 ast_mutex_unlock(&chan_lock);
1846 /* create asterisk channel instrance */
1848 #ifdef LCR_FOR_ASTERISK
1849 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1852 #ifdef LCR_FOR_CALLWEAVER
1853 ast = ast_channel_alloc(1);
1857 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1859 /* failed to create instance */
1860 ast_mutex_unlock(&chan_lock);
1864 ast->tech = &lcr_tech;
1865 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1866 /* configure channel */
1867 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1868 ast->readformat = ast->rawreadformat = ast->nativeformats;
1869 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1871 ast->hangupcause = 0;
1875 ast->tech_pvt = call;
1876 ast->fds[0] = call->pipe[0];
1877 call->pbx_started = 0;
1879 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1882 * Extract interface, dialstring, options from data.
1885 * <interface>/<dialstring>
1886 * <interface>/<dialstring>/options
1888 strncpy(exten, (char *)data, sizeof(exten)-1);
1889 exten[sizeof(exten)-1] = '\0';
1890 if ((dial = strchr(exten, '/'))) {
1893 if ((opt = strchr(dial, '/')))
1902 strncpy(call->interface, interface, sizeof(call->interface)-1);
1903 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1904 apply_opt(call, (char *)opt);
1906 ast_mutex_unlock(&chan_lock);
1912 * call from asterisk
1914 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1916 union parameter newparam;
1917 struct chan_call *call;
1920 ast_mutex_lock(&chan_lock);
1922 call = ast->tech_pvt;
1924 #ifdef LCR_FOR_CALLWEAVER
1926 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1930 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1931 ast_mutex_unlock(&chan_lock);
1936 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1938 /* pbx process is started */
1939 call->pbx_started = 1;
1940 /* send MESSAGE_NEWREF */
1941 memset(&newparam, 0, sizeof(union parameter));
1942 newparam.direction = 0; /* request from app */
1943 send_message(MESSAGE_NEWREF, 0, &newparam);
1945 /* set hdlc if capability requires hdlc */
1946 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1947 || ast->transfercapability == INFO_BC_DATARESTRICTED
1948 || ast->transfercapability == INFO_BC_VIDEO)
1950 /* if hdlc is forced by option, we change transcap to data */
1952 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1953 && ast->transfercapability != INFO_BC_DATARESTRICTED
1954 && ast->transfercapability != INFO_BC_VIDEO)
1955 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1957 call->cid_num[0] = 0;
1958 call->cid_name[0] = 0;
1959 call->cid_rdnis[0] = 0;
1961 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1962 strncpy(call->cid_num, ast->cid.cid_num,
1963 sizeof(call->cid_num)-1);
1965 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1966 strncpy(call->cid_name, ast->cid.cid_name,
1967 sizeof(call->cid_name)-1);
1968 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1969 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1970 sizeof(call->cid_rdnis)-1);
1972 ast_mutex_unlock(&chan_lock);
1977 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1979 static const char* dtmf_tones[] = {
1980 "!941+1336/100,!0/100", /* 0 */
1981 "!697+1209/100,!0/100", /* 1 */
1982 "!697+1336/100,!0/100", /* 2 */
1983 "!697+1477/100,!0/100", /* 3 */
1984 "!770+1209/100,!0/100", /* 4 */
1985 "!770+1336/100,!0/100", /* 5 */
1986 "!770+1477/100,!0/100", /* 6 */
1987 "!852+1209/100,!0/100", /* 7 */
1988 "!852+1336/100,!0/100", /* 8 */
1989 "!852+1477/100,!0/100", /* 9 */
1990 "!697+1633/100,!0/100", /* A */
1991 "!770+1633/100,!0/100", /* B */
1992 "!852+1633/100,!0/100", /* C */
1993 "!941+1633/100,!0/100", /* D */
1994 "!941+1209/100,!0/100", /* * */
1995 "!941+1477/100,!0/100" }; /* # */
1997 if (digit >= '0' && digit <='9')
1998 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1999 else if (digit >= 'A' && digit <= 'D')
2000 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2001 else if (digit == '*')
2002 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2003 else if (digit == '#')
2004 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2007 ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
2008 "'%c' for '%s'\n", digit, ast->name);
2012 #ifdef LCR_FOR_ASTERISK
2013 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2015 #ifdef LCR_FOR_CALLWEAVER
2016 static int lcr_digit(struct ast_channel *ast, char digit)
2019 struct chan_call *call;
2020 union parameter newparam;
2023 #ifdef LCR_FOR_CALLWEAVER
2024 int inband_dtmf = 0;
2027 /* only pass IA5 number space */
2028 if (digit > 126 || digit < 32)
2032 ast_mutex_lock(&chan_lock);
2034 call = ast->tech_pvt;
2036 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2037 ast_mutex_unlock(&chan_lock);
2042 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2044 /* send information or queue them */
2045 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2046 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2047 memset(&newparam, 0, sizeof(union parameter));
2049 newparam.information.keypad[0] = digit;
2050 newparam.information.keypad[1] = '\0';
2052 newparam.information.id[0] = digit;
2053 newparam.information.id[1] = '\0';
2055 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2058 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2059 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2061 strncat(call->dialque, buf, strlen(call->dialque)-1);
2064 ast_mutex_unlock(&chan_lock);
2067 #ifdef LCR_FOR_ASTERISK
2071 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2073 int inband_dtmf = 0;
2074 struct chan_call *call;
2078 ast_mutex_lock(&chan_lock);
2081 call = ast->tech_pvt;
2085 "Received digit from Asterisk, "
2086 "but no call instance exists.\n");
2087 ast_mutex_unlock(&chan_lock);
2092 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2094 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2098 ast_mutex_unlock(&chan_lock);
2102 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2103 send_digit_to_chan(ast, digit);
2109 static int lcr_answer(struct ast_channel *ast)
2111 union parameter newparam;
2112 struct chan_call *call;
2115 ast_mutex_lock(&chan_lock);
2117 call = ast->tech_pvt;
2119 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2120 ast_mutex_unlock(&chan_lock);
2125 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2127 /* copy connectinfo, if bridged */
2128 if (call->bridge_call)
2129 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2130 /* send connect message to lcr */
2131 if (call->state != CHAN_LCR_STATE_CONNECT) {
2132 memset(&newparam, 0, sizeof(union parameter));
2133 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2134 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2135 call->state = CHAN_LCR_STATE_CONNECT;
2138 /* request bchannel */
2139 if (!call->bchannel) {
2140 CDEBUG(call, ast, "Requesting B-channel.\n");
2141 memset(&newparam, 0, sizeof(union parameter));
2142 newparam.bchannel.type = BCHANNEL_REQUEST;
2143 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2146 // memset(&newparam, 0, sizeof(union parameter));
2147 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2149 ast_mutex_unlock(&chan_lock);
2154 static int lcr_hangup(struct ast_channel *ast)
2156 struct chan_call *call;
2157 pthread_t tid = pthread_self();
2159 if (!pthread_equal(tid, chan_tid)) {
2161 ast_mutex_lock(&chan_lock);
2164 call = ast->tech_pvt;
2166 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2167 if (!pthread_equal(tid, chan_tid)) {
2168 ast_mutex_unlock(&chan_lock);
2174 if (!pthread_equal(tid, chan_tid))
2175 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2177 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2179 /* disconnect asterisk, maybe not required */
2180 ast->tech_pvt = NULL;
2184 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2185 if (ast->hangupcause > 0)
2186 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2188 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2191 if (!pthread_equal(tid, chan_tid)) {
2192 ast_mutex_unlock(&chan_lock);
2197 /* ref is not set, due to prepare setup or release */
2198 if (call->state == CHAN_LCR_STATE_RELEASE) {
2199 /* we get the response to our release */
2200 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2203 /* during prepare, we change to release state */
2204 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2205 call->state = CHAN_LCR_STATE_RELEASE;
2209 if (!pthread_equal(tid, chan_tid)) {
2210 ast_mutex_unlock(&chan_lock);
2216 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2218 struct chan_call *call;
2221 CDEBUG(NULL, ast, "No subclass\n");
2222 if (!(f->subclass & ast->nativeformats))
2223 CDEBUG(NULL, ast, "Unexpected format.\n");
2226 ast_mutex_lock(&chan_lock);
2228 call = ast->tech_pvt;
2230 ast_mutex_unlock(&chan_lock);
2234 if (call->bchannel && f->samples)
2235 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2236 ast_mutex_unlock(&chan_lock);
2242 static struct ast_frame *lcr_read(struct ast_channel *ast)
2244 struct chan_call *call;
2248 ast_mutex_lock(&chan_lock);
2250 call = ast->tech_pvt;
2252 ast_mutex_unlock(&chan_lock);
2256 if (call->pipe[0] > -1) {
2257 if (call->rebuffer && !call->hdlc) {
2258 /* Make sure we have a complete 20ms (160byte) frame */
2260 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2262 call->framepos += len;
2266 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2269 if (len < 0 && errno == EAGAIN) {
2270 ast_mutex_unlock(&chan_lock);
2273 #ifdef LCR_FOR_ASTERISK
2274 return &ast_null_frame;
2277 #ifdef LCR_FOR_CALLWEAVER
2283 close(call->pipe[0]);
2286 ast_mutex_unlock(&chan_lock);
2289 } else if (call->rebuffer && call->framepos < 160) {
2290 /* Not a complete frame, so we send a null-frame */
2291 ast_mutex_unlock(&chan_lock);
2293 return &ast_null_frame;
2297 call->read_fr.frametype = AST_FRAME_VOICE;
2298 call->read_fr.subclass = ast->nativeformats;
2299 if (call->rebuffer) {
2300 call->read_fr.datalen = call->framepos;
2301 call->read_fr.samples = call->framepos;
2304 call->read_fr.datalen = len;
2305 call->read_fr.samples = len;
2307 call->read_fr.delivery = ast_tv(0,0);
2308 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2309 ast_mutex_unlock(&chan_lock);
2312 return &call->read_fr;
2315 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2317 union parameter newparam;
2319 struct chan_call *call;
2320 const struct tone_zone_sound *ts = NULL;
2323 ast_mutex_lock(&chan_lock);
2325 call = ast->tech_pvt;
2327 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2328 ast_mutex_unlock(&chan_lock);
2334 case AST_CONTROL_BUSY:
2335 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2336 ast_setstate(ast, AST_STATE_BUSY);
2337 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2338 /* send message to lcr */
2339 memset(&newparam, 0, sizeof(union parameter));
2340 newparam.disconnectinfo.cause = 17;
2341 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2342 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2344 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2346 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2347 ts = ast_get_indication_tone(ast->zone, "busy");
2350 case AST_CONTROL_CONGESTION:
2351 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2352 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2353 /* send message to lcr */
2354 memset(&newparam, 0, sizeof(union parameter));
2355 newparam.disconnectinfo.cause = ast->hangupcause;
2356 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2357 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2359 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2361 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2362 ts = ast_get_indication_tone(ast->zone, "congestion");
2365 case AST_CONTROL_PROCEEDING:
2366 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2367 if (call->state == CHAN_LCR_STATE_IN_SETUP
2368 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2369 /* send message to lcr */
2370 memset(&newparam, 0, sizeof(union parameter));
2371 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2373 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2376 case AST_CONTROL_RINGING:
2377 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2378 ast_setstate(ast, AST_STATE_RING);
2379 if (call->state == CHAN_LCR_STATE_IN_SETUP
2380 || call->state == CHAN_LCR_STATE_IN_DIALING
2381 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2382 /* send message to lcr */
2383 memset(&newparam, 0, sizeof(union parameter));
2384 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2386 call->state = CHAN_LCR_STATE_IN_ALERTING;
2388 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2389 ts = ast_get_indication_tone(ast->zone, "ring");
2392 case AST_CONTROL_PROGRESS:
2393 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2394 /* request bchannel */
2395 if (!call->bchannel) {
2396 CDEBUG(call, ast, "Requesting B-channel.\n");
2397 memset(&newparam, 0, sizeof(union parameter));
2398 newparam.bchannel.type = BCHANNEL_REQUEST;
2399 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2403 CDEBUG(call, ast, "Received indicate -1.\n");
2404 ast_playtones_stop(ast);
2408 case AST_CONTROL_VIDUPDATE:
2409 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2412 case AST_CONTROL_HOLD:
2413 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2414 /* send message to lcr */
2415 memset(&newparam, 0, sizeof(union parameter));
2416 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2417 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2419 /*start music onhold*/
2420 #ifdef LCR_FOR_ASTERISK
2421 ast_moh_start(ast,data,ast->musicclass);
2424 #ifdef LCR_FOR_CALLWEAVER
2425 ast_moh_start(ast, NULL);
2430 case AST_CONTROL_UNHOLD:
2431 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2432 /* send message to lcr */
2433 memset(&newparam, 0, sizeof(union parameter));
2434 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2435 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2441 #ifdef AST_CONTROL_SRCUPDATE
2442 case AST_CONTROL_SRCUPDATE:
2446 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2449 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2454 if (ts && ts->data[0]) {
2455 ast_playtones_start(ast, 0, ts->data, 1);
2459 ast_mutex_unlock(&chan_lock);
2467 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2469 struct chan_call *call;
2476 ast_mutex_lock(&chan_lock);
2478 call = ast->tech_pvt;
2480 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2481 ast_mutex_unlock(&chan_lock);
2486 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2488 ast_mutex_unlock(&chan_lock);
2494 * send_text asterisk
2496 static int lcr_send_text(struct ast_channel *ast, const char *text)
2498 struct chan_call *call;
2499 union parameter newparam;
2502 ast_mutex_lock(&chan_lock);
2504 call = ast->tech_pvt;
2506 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2507 ast_mutex_unlock(&chan_lock);
2512 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2513 memset(&newparam, 0, sizeof(union parameter));
2514 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2515 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2516 ast_mutex_unlock(&chan_lock);
2524 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2525 struct ast_channel *ast2, int flags,
2526 struct ast_frame **fo,
2527 struct ast_channel **rc, int timeoutms)
2530 struct chan_call *call1, *call2;
2531 struct ast_channel *carr[2], *who;
2533 struct ast_frame *f;
2536 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2541 /* join via dsp (if the channels are currently open) */
2543 ast_mutex_lock(&chan_lock);
2545 call1 = ast1->tech_pvt;
2546 call2 = ast2->tech_pvt;
2547 if (!call1 || !call2) {
2548 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2549 ast_mutex_unlock(&chan_lock);
2551 return AST_BRIDGE_COMPLETE;
2554 /* join, if both call instances uses dsp
2555 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2557 if (!call1->nodsp && !call2->nodsp) {
2558 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2560 /* get bridge id and join */
2561 bridge_id = new_bridge_id();
2563 call1->bridge_id = bridge_id;
2564 if (call1->bchannel)
2565 bchannel_join(call1->bchannel, bridge_id);
2567 call2->bridge_id = bridge_id;
2568 if (call2->bchannel)
2569 bchannel_join(call2->bchannel, bridge_id);
2571 if (call1->nodsp && call2->nodsp)
2572 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2574 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2575 call1->bridge_call = call2;
2576 call2->bridge_call = call1;
2578 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2579 || call1->state == CHAN_LCR_STATE_IN_DIALING
2580 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2581 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2582 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2585 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2586 || call2->state == CHAN_LCR_STATE_IN_DIALING
2587 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2588 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2589 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2593 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2594 so let's do it for them. Hmpf.
2597 if (call1->on_hold) {
2598 union parameter newparam;
2600 memset(&newparam, 0, sizeof(union parameter));
2601 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2602 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2607 if (call2->on_hold) {
2608 union parameter newparam;
2610 memset(&newparam, 0, sizeof(union parameter));
2611 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2612 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2617 ast_mutex_unlock(&chan_lock);
2622 who = ast_waitfor_n(carr, 2, &to);
2625 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2630 if (!f || f->frametype == AST_FRAME_CONTROL) {
2632 CDEBUG(NULL, NULL, "Got hangup.\n");
2634 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2641 if ( f->frametype == AST_FRAME_DTMF ) {
2642 CDEBUG(NULL, NULL, "Got DTMF.\n");
2658 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2660 /* split channels */
2662 ast_mutex_lock(&chan_lock);
2664 call1 = ast1->tech_pvt;
2665 call2 = ast2->tech_pvt;
2666 if (call1 && call1->bridge_id) {
2667 call1->bridge_id = 0;
2668 if (call1->bchannel)
2669 bchannel_join(call1->bchannel, 0);
2670 if (call1->bridge_call)
2671 call1->bridge_call->bridge_call = NULL;
2673 if (call2 && call1->bridge_id) {
2674 call2->bridge_id = 0;
2675 if (call2->bchannel)
2676 bchannel_join(call2->bchannel, 0);
2677 if (call2->bridge_call)
2678 call2->bridge_call->bridge_call = NULL;
2680 call1->bridge_call = NULL;
2681 call2->bridge_call = NULL;
2683 ast_mutex_unlock(&chan_lock);
2685 return AST_BRIDGE_COMPLETE;
2687 static struct ast_channel_tech lcr_tech = {
2689 .description = "Channel driver for connecting to Linux-Call-Router",
2690 .capabilities = AST_FORMAT_ALAW,
2691 .requester = lcr_request,
2693 #ifdef LCR_FOR_ASTERISK
2694 .send_digit_begin = lcr_digit_begin,
2695 .send_digit_end = lcr_digit_end,
2698 #ifdef LCR_FOR_CALLWEAVER
2699 .send_digit = lcr_digit,
2703 .bridge = lcr_bridge,
2704 .hangup = lcr_hangup,
2705 .answer = lcr_answer,
2708 .indicate = lcr_indicate,
2710 .send_text = lcr_send_text,
2719 static int lcr_show_lcr (int fd, int argc, char *argv[])
2724 static int lcr_show_calls (int fd, int argc, char *argv[])
2729 static int lcr_reload_routing (int fd, int argc, char *argv[])
2734 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2739 static int lcr_port_block (int fd, int argc, char *argv[])
2744 static int lcr_port_unblock (int fd, int argc, char *argv[])
2749 static int lcr_port_unload (int fd, int argc, char *argv[])
2754 static struct ast_cli_entry cli_show_lcr =
2755 { {"lcr", "show", "lcr", NULL},
2757 "Shows current states of LCR core",
2758 "Usage: lcr show lcr\n",
2761 static struct ast_cli_entry cli_show_calls =
2762 { {"lcr", "show", "calls", NULL},
2764 "Shows current calls made by LCR and Asterisk",
2765 "Usage: lcr show calls\n",
2768 static struct ast_cli_entry cli_reload_routing =
2769 { {"lcr", "reload", "routing", NULL},
2771 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2772 "Usage: lcr reload routing\n",
2775 static struct ast_cli_entry cli_reload_interfaces =
2776 { {"lcr", "reload", "interfaces", NULL},
2777 lcr_reload_interfaces,
2778 "Reloads interfaces conf of LCR",
2779 "Usage: lcr reload interfaces\n",
2782 static struct ast_cli_entry cli_port_block =
2783 { {"lcr", "port", "block", NULL},
2785 "Blocks LCR port for further calls",
2786 "Usage: lcr port block \"<port>\"\n",
2789 static struct ast_cli_entry cli_port_unblock =
2790 { {"lcr", "port", "unblock", NULL},
2792 "Unblocks or loads LCR port, port is opened my mISDN",
2793 "Usage: lcr port unblock \"<port>\"\n",
2796 static struct ast_cli_entry cli_port_unload =
2797 { {"lcr", "port", "unload", NULL},
2799 "Unloads LCR port, port is closes by mISDN",
2800 "Usage: lcr port unload \"<port>\"\n",
2805 #ifdef LCR_FOR_ASTERISK
2806 static int lcr_config_exec(struct ast_channel *ast, void *data)
2809 #ifdef LCR_FOR_CALLWEAVER
2810 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2813 struct chan_call *call;
2816 ast_mutex_lock(&chan_lock);
2819 #ifdef LCR_FOR_ASTERISK
2820 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2823 #ifdef LCR_FOR_CALLWEAVER
2824 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2830 if (call->ast == ast)
2836 #ifdef LCR_FOR_ASTERISK
2837 apply_opt(call, (char *)data);
2840 #ifdef LCR_FOR_CALLWEAVER
2841 apply_opt(call, (char *)argv[0]);
2845 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2847 ast_mutex_unlock(&chan_lock);
2853 * module loading and destruction
2855 int load_module(void)
2858 char options_error[256];
2860 for (i = 0; i < 256; i++) {
2861 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2862 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2865 if (read_options(options_error) == 0) {
2866 CERROR(NULL, NULL, "%s", options_error);
2868 #ifdef LCR_FOR_ASTERISK
2869 return AST_MODULE_LOAD_DECLINE;
2872 #ifdef LCR_FOR_CALLWEAVER
2878 ast_mutex_init(&chan_lock);
2879 ast_mutex_init(&log_lock);
2881 if (bchannel_initialize()) {
2882 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2885 #ifdef LCR_FOR_ASTERISK
2886 return AST_MODULE_LOAD_DECLINE;
2889 #ifdef LCR_FOR_CALLWEAVER
2895 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2896 if (ast_channel_register(&lcr_tech)) {
2897 CERROR(NULL, NULL, "Unable to register channel class\n");
2898 bchannel_deinitialize();
2901 #ifdef LCR_FOR_ASTERISK
2902 return AST_MODULE_LOAD_DECLINE;
2905 #ifdef LCR_FOR_CALLWEAVER
2910 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2912 #ifdef LCR_FOR_ASTERISK
2913 "lcr_config(<opt><optarg>:<opt>:...)\n"
2916 #ifdef LCR_FOR_CALLWEAVER
2917 "lcr_config(<opt><optarg>:<opt>:...)\n",
2920 "Sets LCR opts. and optargs\n"
2922 "The available options are:\n"
2923 " d - Send display text on called phone, text is the optarg.\n"
2924 " n - Don't detect dtmf tones on called channel.\n"
2925 " h - Force data call (HDLC).\n"
2926 " t - Disable mISDN_dsp features (required for fax application).\n"
2927 " q - Add queue to make fax stream seamless (required for fax app).\n"
2928 " Use queue size in miliseconds for optarg. (try 250)\n"
2929 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2930 " Use time to detect for optarg.\n"
2931 " c - Make crypted outgoing call, optarg is keyindex.\n"
2932 " e - Perform echo cancelation on this channel.\n"
2933 " Takes mISDN pipeline option as optarg.\n"
2934 " s - Send Non Inband DTMF as inband.\n"
2935 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2936 " vr - rxgain control\n"
2937 " vt - txgain control\n"
2938 " Volume changes at factor 2 ^ optarg.\n"
2939 " k - use keypad to dial this call.\n"
2941 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2942 " -> use 16 for fax (3.1k audio)\n"
2944 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2945 "options: \"n:t:q250\" for seamless audio transmission.\n"
2950 ast_cli_register(&cli_show_lcr);
2951 ast_cli_register(&cli_show_calls);
2952 ast_cli_register(&cli_reload_routing);
2953 ast_cli_register(&cli_reload_interfaces);
2954 ast_cli_register(&cli_port_block);
2955 ast_cli_register(&cli_port_unblock);
2956 ast_cli_register(&cli_port_unload);
2960 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2961 /* failed to create thread */
2962 bchannel_deinitialize();
2964 ast_channel_unregister(&lcr_tech);
2966 #ifdef LCR_FOR_ASTERISK
2967 return AST_MODULE_LOAD_DECLINE;
2970 #ifdef LCR_FOR_CALLWEAVER
2978 int unload_module(void)
2980 /* First, take us out of the channel loop */
2981 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2984 pthread_join(chan_tid, NULL);
2986 ast_channel_unregister(&lcr_tech);
2988 ast_unregister_application("lcr_config");
2991 if (mISDN_created) {
2992 bchannel_deinitialize();
2996 if (lcr_sock >= 0) {
3004 int reload_module(void)
3010 #ifdef LCR_FOR_ASTERISK
3011 #define AST_MODULE "chan_lcr"
3014 #ifdef LCR_FOR_CALLWEAVER
3020 ast_mutex_lock(&usecnt_lock);
3023 ast_mutex_unlock(&usecnt_lock);
3029 #ifdef LCR_FOR_ASTERISK
3030 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3031 .load = load_module,
3032 .unload = unload_module,
3033 .reload = reload_module,
3037 #ifdef LCR_FOR_CALLWEAVER
3038 char *description(void)