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 printf("\n[call=%s ast=%s] %s\n", call_text, ast_text, buffer);
259 // ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
261 ast_mutex_unlock(&log_lock);
266 * channel and call instances
268 struct chan_call *call_first;
272 * special case: 0: find new ref, that has not been assigned a ref yet
275 struct chan_call *find_call_ref(unsigned int ref)
277 struct chan_call *call = call_first;
278 int assigned = (ref > 0);
281 if (call->ref == ref && call->ref_was_assigned == assigned)
288 void free_call(struct chan_call *call)
290 struct chan_call **temp = &call_first;
294 *temp = (*temp)->next;
295 if (call->pipe[0] > -1)
296 close(call->pipe[0]);
297 if (call->pipe[1] > -1)
298 close(call->pipe[1]);
299 if (call->bchannel) {
300 if (call->bchannel->call != call)
301 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
302 call->bchannel->call = NULL;
304 if (call->bridge_call) {
305 if (call->bridge_call->bridge_call != call)
306 CERROR(call, NULL, "Linked call structure has no link to us.\n");
307 call->bridge_call->bridge_call = NULL;
310 ast_translator_free_path(call->trans);
312 ast_dsp_free(call->dsp);
313 CDEBUG(call, NULL, "Call instance freed.\n");
318 temp = &((*temp)->next);
320 CERROR(call, NULL, "Call instance not found in list.\n");
323 struct chan_call *alloc_call(void)
325 struct chan_call **callp = &call_first;
328 callp = &((*callp)->next);
330 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
332 memset(*callp, 0, sizeof(struct chan_call));
333 if (pipe((*callp)->pipe) < 0) {
334 CERROR(*callp, NULL, "Failed to create pipe.\n");
338 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
339 CDEBUG(*callp, NULL, "Call instance allocated.\n");
343 unsigned short new_bridge_id(void)
345 struct chan_call *call;
346 unsigned short id = 1;
348 /* search for lowest bridge id that is not in use and not 0 */
352 if (call->bridge_id == id)
360 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
365 * enque message to LCR
367 int send_message(int message_type, unsigned int ref, union parameter *param)
369 struct admin_list *admin, **adminp;
372 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
375 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
377 adminp = &admin_first;
379 adminp = &((*adminp)->next);
380 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
382 CERROR(NULL, NULL, "No memory for message to LCR.\n");
387 admin->msg.message = ADMIN_MESSAGE;
388 admin->msg.u.msg.type = message_type;
389 admin->msg.u.msg.ref = ref;
390 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
391 socket_fd.when |= LCR_FD_WRITE;
395 write(wake_pipe[1], &byte, 1);
402 * apply options (in locked state)
404 void apply_opt(struct chan_call *call, char *data)
406 union parameter newparam;
407 char string[1024], *p = string, *opt, *key;
413 strncpy(string, data, sizeof(string)-1);
414 string[sizeof(string)-1] = '\0';
417 while((opt = strsep(&p, ":"))) {
420 if (opt[1] == '\0') {
421 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
424 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
425 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
426 strncpy(call->display, opt+1, sizeof(call->display)-1);
428 memset(&newparam, 0, sizeof(union parameter));
429 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
430 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
434 if (opt[1] != '\0') {
435 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
438 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
439 if (call->dsp_dtmf) {
442 bchannel_dtmf(call->bchannel, 0);
446 if (opt[1] == '\0') {
447 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
451 /* check for 0xXXXX... type of key */
452 if (!!strncmp((char *)key, "0x", 2)) {
453 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
457 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
458 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
463 if (*key>='0' && *key<='9')
464 call->bf_key[i] = (*key-'0') << 8;
465 else if (*key>='a' && *key<='f')
466 call->bf_key[i] = (*key-'a'+10) << 8;
467 else if (*key>='A' && *key<='F')
468 call->bf_key[i] = (*key-'A'+10) << 8;
472 if (*key>='0' && *key<='9')
473 call->bf_key[i] += (*key - '0');
474 else if (*key>='a' && *key<='f')
475 call->bf_key[i] += (*key - 'a' + 10);
476 else if (*key>='A' && *key<='F')
477 call->bf_key[i] += (*key - 'A' + 10);
484 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
488 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
490 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
493 if (opt[1] != '\0') {
494 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
497 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
502 if (opt[1] != '\0') {
503 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
506 CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
511 if (opt[1] == '\0') {
512 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
515 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
516 call->nodsp_queue = atoi(opt+1);
519 if (opt[1] == '\0') {
520 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
523 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
524 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
526 bchannel_pipeline(call->bchannel, call->pipeline);
529 if (opt[1] == '\0') {
530 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
533 call->faxdetect=atoi(opt+1);
535 call->dsp=ast_dsp_new();
537 #ifdef LCR_FOR_CALLWEAVER
538 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
540 #ifdef LCR_FOR_ASTERISK
541 #ifdef DSP_FEATURE_DTMF_DETECT
542 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
544 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
549 #ifdef LCR_FOR_CALLWEAVER
550 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
552 #ifdef LCR_FOR_ASTERISK
553 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
556 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
559 if (opt[1] != '\0') {
560 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
563 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
568 if (opt[1] != '\0') {
569 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
572 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
573 call->inband_dtmf = 1;
576 if (opt[1] != 'r' && opt[1] != 't') {
577 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
581 if (gain < -8 || gain >8) {
582 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
585 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
587 call->rx_gain = gain;
589 bchannel_gain(call->bchannel, call->rx_gain, 0);
591 call->tx_gain = gain;
593 bchannel_gain(call->bchannel, call->tx_gain, 1);
597 if (opt[1] != '\0') {
598 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
601 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
606 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
610 /* re-open, if bchannel is created */
611 if (call->bchannel && call->bchannel->b_sock > -1) {
612 bchannel_destroy(call->bchannel);
613 if (bchannel_create(call->bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
614 bchannel_activate(call->bchannel, 1);
619 * send setup info to LCR
620 * this function is called, when asterisk call is received and ref is received
622 static void send_setup_to_lcr(struct chan_call *call)
624 union parameter newparam;
625 struct ast_channel *ast = call->ast;
628 if (!call->ast || !call->ref)
631 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
633 /* send setup message to LCR */
634 memset(&newparam, 0, sizeof(union parameter));
635 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
636 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
638 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
640 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
641 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
642 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
643 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
644 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
645 call->display[0] = '\0';
646 if (call->cid_num[0])
647 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
648 if (call->cid_name[0])
649 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
650 if (call->cid_rdnis[0]) {
651 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
652 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
653 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
655 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
656 case AST_PRES_RESTRICTED:
657 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
659 case AST_PRES_UNAVAILABLE:
660 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
662 case AST_PRES_ALLOWED:
664 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
666 switch(ast->cid.cid_ton) {
668 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
671 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
674 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
677 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
679 tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
681 ast->transfercapability = atoi(tmp);
682 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
683 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
685 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
687 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
688 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
690 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
691 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
692 send_message(MESSAGE_SETUP, call->ref, &newparam);
694 /* change to outgoing setup state */
695 call->state = CHAN_LCR_STATE_OUT_SETUP;
699 * send dialing info to LCR
700 * this function is called, when setup acknowledge is received and dialing
703 static void send_dialque_to_lcr(struct chan_call *call)
705 union parameter newparam;
707 if (!call->ast || !call->ref || !call->dialque[0])
710 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
712 /* send setup message to LCR */
713 memset(&newparam, 0, sizeof(union parameter));
715 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
717 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
718 call->dialque[0] = '\0';
719 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
723 * in case of a bridge, the unsupported message can be forwarded directly
724 * to the remote call.
726 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
730 if (!call->bridge_call) return;
731 CDEBUG(call, NULL, "Sending message due bridging.\n");
732 send_message(message_type, call->bridge_call->ref, param);
736 * send release message to LCR and import bchannel if exported
738 static void send_release_and_import(struct chan_call *call, int cause, int location)
740 union parameter newparam;
742 /* importing channel */
743 if (call->bchannel) {
744 memset(&newparam, 0, sizeof(union parameter));
745 newparam.bchannel.type = BCHANNEL_RELEASE;
746 newparam.bchannel.handle = call->bchannel->handle;
747 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
749 /* sending release */
750 memset(&newparam, 0, sizeof(union parameter));
751 newparam.disconnectinfo.cause = cause;
752 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
753 send_message(MESSAGE_RELEASE, call->ref, &newparam);
757 * check if extension matches and start asterisk
758 * if it can match, proceed
761 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
764 union parameter newparam;
765 char *exten = ast->exten;
769 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
773 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
774 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
778 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
779 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);
783 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
784 /* send setup acknowledge to lcr */
785 memset(&newparam, 0, sizeof(union parameter));
786 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
789 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
794 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
795 /* send setup acknowledge to lcr */
796 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
797 memset(&newparam, 0, sizeof(union parameter));
798 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
802 call->state = CHAN_LCR_STATE_IN_DIALING;
804 /* if match, start pbx */
805 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
806 CDEBUG(call, ast, "Extensions matches.\n");
811 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
817 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
825 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
826 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
828 /* release asterisk */
829 ast->hangupcause = call->cause;
830 /* change to release state */
831 call->state = CHAN_LCR_STATE_RELEASE;
832 ast_hangup(ast); // call will be destroyed here
836 /* send setup to asterisk */
837 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
839 #ifdef LCR_FOR_CALLWEAVER
841 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
844 ret = ast_pbx_start(ast);
846 cause = (ret==-2)?34:27;
849 call->pbx_started = 1;
850 ast_setstate(ast, AST_STATE_RING);
854 * incoming setup from LCR
856 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
858 struct ast_channel *ast;
860 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
862 /* create asterisk channel instrance */
864 #ifdef LCR_FOR_CALLWEAVER
865 ast = ast_channel_alloc(1);
868 #ifdef LCR_FOR_ASTERISK
869 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
874 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
875 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
882 ast->tech_pvt = call;
883 ast->tech = &lcr_tech;
884 ast->fds[0] = call->pipe[0];
886 /* fill setup information */
887 if (param->setup.dialinginfo.id)
888 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
889 if (param->setup.context[0])
890 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
892 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
893 if (param->setup.callerinfo.id[0])
894 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
895 if (param->setup.callerinfo.name[0])
896 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
897 if (param->setup.redirinfo.id[0])
898 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
899 switch (param->setup.callerinfo.present) {
900 case INFO_PRESENT_ALLOWED:
901 ast->cid.cid_pres = AST_PRES_ALLOWED;
903 case INFO_PRESENT_RESTRICTED:
904 ast->cid.cid_pres = AST_PRES_RESTRICTED;
907 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
909 switch (param->setup.callerinfo.ntype) {
910 case INFO_NTYPE_SUBSCRIBER:
911 ast->cid.cid_ton = 4;
913 case INFO_NTYPE_NATIONAL:
914 ast->cid.cid_ton = 2;
916 case INFO_NTYPE_INTERNATIONAL:
917 ast->cid.cid_ton = 1;
920 ast->cid.cid_ton = 0;
922 ast->transfercapability = param->setup.capainfo.bearer_capa;
923 /* enable hdlc if transcap is data */
924 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
926 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
928 /* configure channel */
929 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
930 ast->readformat = ast->rawreadformat = ast->nativeformats;
931 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
933 ast->hangupcause = 0;
936 call->state = CHAN_LCR_STATE_IN_SETUP;
938 if (!call->pbx_started)
939 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
943 * incoming setup acknowledge from LCR
945 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
947 if (!call->ast) return;
949 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
951 /* send pending digits in dialque */
952 if (call->dialque[0])
953 send_dialque_to_lcr(call);
954 /* change to overlap state */
955 call->state = CHAN_LCR_STATE_OUT_DIALING;
959 * incoming proceeding from LCR
961 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
963 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
966 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
967 /* queue event for asterisk */
968 if (call->ast && call->pbx_started) {
972 write(wake_pipe[1], &byte, 1);
974 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
980 * incoming alerting from LCR
982 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
984 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
987 call->state = CHAN_LCR_STATE_OUT_ALERTING;
988 /* queue event to asterisk */
989 if (call->ast && call->pbx_started) {
993 write(wake_pipe[1], &byte, 1);
995 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1000 * incoming connect from LCR
1002 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1004 union parameter newparam;
1006 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1009 call->state = CHAN_LCR_STATE_CONNECT;
1010 /* request bchannel */
1011 if (!call->bchannel) {
1012 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1013 memset(&newparam, 0, sizeof(union parameter));
1014 newparam.bchannel.type = BCHANNEL_REQUEST;
1015 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1017 /* copy connectinfo */
1018 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1019 /* queue event to asterisk */
1020 if (call->ast && call->pbx_started) {
1024 write(wake_pipe[1], &byte, 1);
1026 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1031 * incoming disconnect from LCR
1033 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1035 struct ast_channel *ast = call->ast;
1037 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1040 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1042 call->cause = param->disconnectinfo.cause;
1043 call->location = param->disconnectinfo.location;
1044 /* if bridge, forward disconnect and return */
1047 if (call->bridge_call) {
1048 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1049 bridge_message_if_bridged(call, message_type, param);
1053 /* release lcr with same cause */
1054 send_release_and_import(call, call->cause, call->location);
1056 /* change to release state */
1057 call->state = CHAN_LCR_STATE_RELEASE;
1058 /* queue release asterisk */
1060 ast->hangupcause = call->cause;
1061 if (call->pbx_started) {
1065 write(wake_pipe[1], &byte, 1);
1067 strcpy(call->queue_string, "H"); // overwrite other indications
1069 ast_hangup(ast); // call will be destroyed here
1075 * incoming release from LCR
1077 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1079 struct ast_channel *ast = call->ast;
1081 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1085 /* change to release state */
1086 call->state = CHAN_LCR_STATE_RELEASE;
1087 /* copy release info */
1089 call->cause = param->disconnectinfo.cause;
1090 call->location = param->disconnectinfo.location;
1092 /* if we have an asterisk instance, queue hangup, else we are done */
1094 ast->hangupcause = call->cause;
1095 if (call->pbx_started) {
1099 write(wake_pipe[1], &byte, 1);
1101 strcpy(call->queue_string, "H");
1103 ast_hangup(ast); // call will be destroyed here
1112 * incoming information from LCR
1114 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1116 struct ast_channel *ast = call->ast;
1118 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1122 /* pbx not started */
1123 if (!call->pbx_started) {
1124 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1125 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1126 lcr_start_pbx(call, ast, param->information.sending_complete);
1130 /* change dailing state after setup */
1131 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1132 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1133 call->state = CHAN_LCR_STATE_IN_DIALING;
1134 // ast_setstate(ast, AST_STATE_DIALING);
1138 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1142 write(wake_pipe[1], &byte, 1);
1144 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1147 /* use bridge to forware message not supported by asterisk */
1148 if (call->state == CHAN_LCR_STATE_CONNECT) {
1149 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1150 bridge_message_if_bridged(call, message_type, param);
1155 * incoming information from LCR
1157 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1159 union parameter newparam;
1161 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1163 /* request bchannel, if call is resumed and we don't have it */
1164 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1165 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1166 memset(&newparam, 0, sizeof(union parameter));
1167 newparam.bchannel.type = BCHANNEL_REQUEST;
1168 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1171 if (!call->ast) return;
1173 /* use bridge to forware message not supported by asterisk */
1174 bridge_message_if_bridged(call, message_type, param);
1178 * incoming information from LCR
1180 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1182 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1184 if (!call->ast) return;
1186 /* use bridge to forware message not supported by asterisk */
1187 bridge_message_if_bridged(call, message_type, param);
1191 * incoming pattern from LCR
1193 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1195 union parameter newparam;
1197 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1199 if (!call->ast) return;
1201 /* pattern are indicated only once */
1202 if (call->has_pattern)
1204 call->has_pattern = 1;
1206 /* request bchannel */
1207 if (!call->bchannel) {
1208 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1209 memset(&newparam, 0, sizeof(union parameter));
1210 newparam.bchannel.type = BCHANNEL_REQUEST;
1211 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1213 /* queue PROGRESS, because tones are available */
1214 if (call->ast && call->pbx_started) {
1218 write(wake_pipe[1], &byte, 1);
1220 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1225 * got dtmf from bchannel (locked state)
1227 void lcr_in_dtmf(struct chan_call *call, int val)
1229 struct ast_channel *ast = call->ast;
1234 if (!call->pbx_started)
1237 if (!call->dsp_dtmf) {
1238 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1242 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1248 write(wake_pipe[1], &byte, 1);
1250 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1254 * message received from LCR
1256 int receive_message(int message_type, unsigned int ref, union parameter *param)
1258 struct bchannel *bchannel;
1259 struct chan_call *call;
1260 union parameter newparam;
1262 memset(&newparam, 0, sizeof(union parameter));
1264 /* handle bchannel message*/
1265 if (message_type == MESSAGE_BCHANNEL) {
1266 switch(param->bchannel.type) {
1267 case BCHANNEL_ASSIGN:
1269 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1270 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1271 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1274 /* create bchannel */
1275 bchannel = alloc_bchannel(param->bchannel.handle);
1277 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1281 /* configure channel */
1282 bchannel->b_tx_gain = param->bchannel.tx_gain;
1283 bchannel->b_rx_gain = param->bchannel.rx_gain;
1284 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1285 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1286 bchannel->b_bf_len = param->bchannel.crypt_len;
1287 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1289 bchannel->b_txdata = 0;
1290 bchannel->b_tx_dejitter = 1;
1292 /* in case, ref is not set, this bchannel instance must
1293 * be created until it is removed again by LCR */
1295 call = find_call_ref(ref);
1297 bchannel->call = call;
1298 call->bchannel = bchannel;
1300 bchannel_dtmf(bchannel, 1);
1302 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1303 if (call->pipeline[0])
1304 bchannel_pipeline(bchannel, call->pipeline);
1306 bchannel_gain(bchannel, call->rx_gain, 0);
1308 bchannel_gain(bchannel, call->tx_gain, 1);
1309 if (call->bridge_id) {
1310 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1311 bchannel_join(bchannel, call->bridge_id);
1313 /* create only, if call exists, othewhise it bchannel is freed below... */
1314 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1315 bchannel_activate(bchannel, 1);
1318 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1319 newparam.bchannel.handle = param->bchannel.handle;
1320 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1321 /* if call has released before bchannel is assigned */
1323 newparam.bchannel.type = BCHANNEL_RELEASE;
1324 newparam.bchannel.handle = param->bchannel.handle;
1325 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1330 case BCHANNEL_REMOVE:
1331 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1332 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1333 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1336 /* unklink from call and destroy bchannel */
1337 free_bchannel(bchannel);
1340 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1341 newparam.bchannel.handle = param->bchannel.handle;
1342 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1347 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1352 /* handle new ref */
1353 if (message_type == MESSAGE_NEWREF) {
1354 if (param->direction) {
1355 /* new ref from lcr */
1356 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1357 if (!ref || find_call_ref(ref)) {
1358 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1361 /* allocate new call instance */
1362 call = alloc_call();
1364 call->state = CHAN_LCR_STATE_IN_PREPARE;
1367 call->ref_was_assigned = 1;
1368 /* set dtmf (default, use option 'n' to disable */
1370 /* wait for setup (or release from asterisk) */
1372 /* new ref, as requested from this remote application */
1373 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1374 call = find_call_ref(0);
1376 /* send release, if ref does not exist */
1377 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1378 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1383 call->ref_was_assigned = 1;
1384 /* set dtmf (default, use option 'n' to disable */
1386 /* send pending setup info */
1387 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1388 send_setup_to_lcr(call);
1389 /* release if asterisk has signed off */
1390 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1393 send_release_and_import(call, call->cause, call->location);
1395 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1406 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1409 call = find_call_ref(ref);
1411 /* ignore ref that is not used (anymore) */
1412 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1416 /* handle messages */
1417 switch(message_type) {
1419 lcr_in_setup(call, message_type, param);
1422 case MESSAGE_OVERLAP:
1423 lcr_in_overlap(call, message_type, param);
1426 case MESSAGE_PROCEEDING:
1427 lcr_in_proceeding(call, message_type, param);
1430 case MESSAGE_ALERTING:
1431 lcr_in_alerting(call, message_type, param);
1434 case MESSAGE_CONNECT:
1435 lcr_in_connect(call, message_type, param);
1438 case MESSAGE_DISCONNECT:
1439 lcr_in_disconnect(call, message_type, param);
1442 case MESSAGE_RELEASE:
1443 lcr_in_release(call, message_type, param);
1446 case MESSAGE_INFORMATION:
1447 lcr_in_information(call, message_type, param);
1450 case MESSAGE_NOTIFY:
1451 lcr_in_notify(call, message_type, param);
1454 case MESSAGE_FACILITY:
1455 lcr_in_facility(call, message_type, param);
1458 case MESSAGE_PATTERN: // audio available from LCR
1459 if (!call->has_pattern)
1460 lcr_in_pattern(call, message_type, param);
1463 case MESSAGE_NOPATTERN: // audio not available from LCR
1466 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1467 call->audiopath = param->audiopath;
1471 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1478 * release all calls (due to broken socket)
1480 static void release_all_calls(void)
1482 struct chan_call *call;
1487 /* no ast, so we may directly free call */
1489 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1493 /* already in release process */
1494 if (call->state == CHAN_LCR_STATE_RELEASE) {
1498 /* release or queue release */
1500 call->state = CHAN_LCR_STATE_RELEASE;
1501 if (!call->pbx_started) {
1502 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1503 ast_hangup(call->ast); // call will be destroyed here
1506 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1510 write(wake_pipe[1], &byte, 1);
1512 strcpy(call->queue_string, "H");
1516 /* release all bchannels */
1517 while(bchannel_first)
1518 free_bchannel(bchannel_first);
1521 void close_socket(void);
1524 * warning! not thread safe
1525 * returns -1 for socket error, 0 for no work, 1 for work
1527 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1530 struct admin_list *admin;
1531 struct admin_message msg;
1533 lock_debug("handle+");
1534 if ((what & LCR_FD_READ)) {
1535 /* read from socket */
1536 lock_debug("handle1");
1537 len = read(lcr_sock, &msg, sizeof(msg));
1538 lock_debug("handle2");
1540 CERROR(NULL, NULL, "Socket closed.\n");
1542 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1543 lock_debug("handle3");
1545 lock_debug("handle4");
1546 release_all_calls();
1547 lock_debug("handle5");
1548 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1549 lock_debug("handle-");
1553 if (len != sizeof(msg)) {
1554 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1557 if (msg.message != ADMIN_MESSAGE) {
1558 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1561 lock_debug("handleX");
1562 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1563 lock_debug("handleY");
1565 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1570 if ((what & LCR_FD_WRITE)) {
1571 /* write to socket */
1573 socket_fd.when &= ~LCR_FD_WRITE;
1574 lock_debug("handle-");
1577 lock_debug("handle6");
1578 admin = admin_first;
1579 len = write(lcr_sock, &admin->msg, sizeof(msg));
1580 lock_debug("handle7");
1582 CERROR(NULL, NULL, "Socket closed.\n");
1586 if (len != sizeof(msg)) {
1587 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1591 lock_debug("handle8");
1592 admin_first = admin->next;
1596 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1601 lock_debug("handle-");
1606 * open and close socket and thread
1608 int open_socket(void)
1611 struct sockaddr_un sock_address;
1612 union parameter param;
1615 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1616 CERROR(NULL, NULL, "Failed to create socket.\n");
1620 /* set socket address and name */
1621 memset(&sock_address, 0, sizeof(sock_address));
1622 sock_address.sun_family = PF_UNIX;
1623 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1625 /* connect socket */
1626 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1629 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1633 /* register socket fd */
1634 memset(&socket_fd, 0, sizeof(socket_fd));
1635 socket_fd.fd = lcr_sock;
1636 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1638 /* enque hello message */
1639 memset(¶m, 0, sizeof(param));
1640 strcpy(param.hello.application, "asterisk");
1641 send_message(MESSAGE_HELLO, 0, ¶m);
1646 void close_socket(void)
1648 struct admin_list *admin, *temp;
1650 unregister_fd(&socket_fd);
1652 /* flush pending messages */
1653 admin = admin_first;
1656 admin = admin->next;
1669 /* sending queue to asterisk */
1670 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1674 lock_debug("wake+");
1675 read(wake_pipe[0], &byte, 1);
1678 lock_debug("wake-");
1683 static void handle_queue()
1685 struct chan_call *call;
1686 struct ast_channel *ast;
1687 struct ast_frame fr;
1693 p = call->queue_string;
1697 if (ast_channel_trylock(ast)) {
1698 lock_debug("<trylock failed>");
1699 ast_mutex_unlock(&chan_lock);
1702 ast_mutex_lock(&chan_lock);
1710 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1711 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1714 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1715 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1718 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1719 ast_queue_control(ast, AST_CONTROL_RINGING);
1720 ast_setstate(ast, AST_STATE_RINGING);
1723 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1724 ast_queue_control(ast, AST_CONTROL_ANSWER);
1727 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1728 ast_queue_hangup(ast);
1730 case '1': case '2': case '3': case 'A':
1731 case '4': case '5': case '6': case 'B':
1732 case '7': case '8': case '9': case 'C':
1733 case '*': case '0': case '#': case 'D':
1734 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1735 /* send digit to asterisk */
1736 memset(&fr, 0, sizeof(fr));
1738 #ifdef LCR_FOR_ASTERISK
1739 fr.frametype = AST_FRAME_DTMF_BEGIN;
1742 #ifdef LCR_FOR_CALLWEAVER
1743 fr.frametype = AST_FRAME_DTMF;
1747 fr.delivery = ast_tv(0, 0);
1748 ast_queue_frame(ast, &fr);
1750 #ifdef LCR_FOR_ASTERISK
1751 fr.frametype = AST_FRAME_DTMF_END;
1752 ast_queue_frame(ast, &fr);
1757 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1761 call->queue_string[0] = '\0';
1762 ast_channel_unlock(ast);
1769 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1771 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1772 if (open_socket() < 0)
1773 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1778 void lock_chan(void)
1781 ast_mutex_lock(&chan_lock);
1785 void unlock_chan(void)
1787 ast_mutex_unlock(&chan_lock);
1791 /* chan_lcr thread */
1792 static void *chan_thread(void *arg)
1794 if (pipe(wake_pipe) < 0) {
1795 CERROR(NULL, NULL, "Failed to open pipe.\n");
1798 memset(&wake_fd, 0, sizeof(wake_fd));
1799 wake_fd.fd = wake_pipe[0];
1800 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1802 memset(&socket_retry, 0, sizeof(socket_retry));
1803 add_timer(&socket_retry, handle_retry, NULL, 0);
1805 bchannel_pid = getpid();
1807 /* open socket the first time */
1808 handle_retry(NULL, NULL, 0);
1811 ast_mutex_lock(&chan_lock);
1816 select_main(0, &global_change, lock_chan, unlock_chan);
1821 del_timer(&socket_retry);
1823 unregister_fd(&wake_fd);
1824 close(wake_pipe[0]);
1825 close(wake_pipe[1]);
1827 CERROR(NULL, NULL, "Thread exit.\n");
1829 ast_mutex_unlock(&chan_lock);
1836 * new asterisk instance
1839 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1841 char exten[256], *dial, *interface, *opt;
1842 struct ast_channel *ast;
1843 struct chan_call *call;
1846 ast_mutex_lock(&chan_lock);
1848 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1850 /* if socket is closed */
1852 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1853 ast_mutex_unlock(&chan_lock);
1858 /* create call instance */
1859 call = alloc_call();
1861 /* failed to create instance */
1862 ast_mutex_unlock(&chan_lock);
1867 /* create asterisk channel instrance */
1869 #ifdef LCR_FOR_ASTERISK
1870 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1873 #ifdef LCR_FOR_CALLWEAVER
1874 ast = ast_channel_alloc(1);
1878 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1880 /* failed to create instance */
1881 ast_mutex_unlock(&chan_lock);
1885 ast->tech = &lcr_tech;
1886 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1887 /* configure channel */
1888 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1889 ast->readformat = ast->rawreadformat = ast->nativeformats;
1890 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1892 ast->hangupcause = 0;
1896 ast->tech_pvt = call;
1897 ast->fds[0] = call->pipe[0];
1898 call->pbx_started = 0;
1900 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1903 * Extract interface, dialstring, options from data.
1906 * <interface>/<dialstring>
1907 * <interface>/<dialstring>/options
1909 strncpy(exten, (char *)data, sizeof(exten)-1);
1910 exten[sizeof(exten)-1] = '\0';
1911 if ((dial = strchr(exten, '/'))) {
1914 if ((opt = strchr(dial, '/')))
1923 strncpy(call->interface, interface, sizeof(call->interface)-1);
1924 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1925 apply_opt(call, (char *)opt);
1927 ast_mutex_unlock(&chan_lock);
1933 * call from asterisk
1935 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1937 union parameter newparam;
1938 struct chan_call *call;
1941 ast_mutex_lock(&chan_lock);
1943 call = ast->tech_pvt;
1945 #ifdef LCR_FOR_CALLWEAVER
1947 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1951 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1952 ast_mutex_unlock(&chan_lock);
1957 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1959 /* pbx process is started */
1960 call->pbx_started = 1;
1961 /* send MESSAGE_NEWREF */
1962 memset(&newparam, 0, sizeof(union parameter));
1963 newparam.direction = 0; /* request from app */
1964 send_message(MESSAGE_NEWREF, 0, &newparam);
1966 /* set hdlc if capability requires hdlc */
1967 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1968 || ast->transfercapability == INFO_BC_DATARESTRICTED
1969 || ast->transfercapability == INFO_BC_VIDEO)
1971 /* if hdlc is forced by option, we change transcap to data */
1973 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1974 && ast->transfercapability != INFO_BC_DATARESTRICTED
1975 && ast->transfercapability != INFO_BC_VIDEO)
1976 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1978 call->cid_num[0] = 0;
1979 call->cid_name[0] = 0;
1980 call->cid_rdnis[0] = 0;
1982 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1983 strncpy(call->cid_num, ast->cid.cid_num,
1984 sizeof(call->cid_num)-1);
1986 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1987 strncpy(call->cid_name, ast->cid.cid_name,
1988 sizeof(call->cid_name)-1);
1989 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1990 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1991 sizeof(call->cid_rdnis)-1);
1993 ast_mutex_unlock(&chan_lock);
1998 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2000 static const char* dtmf_tones[] = {
2001 "!941+1336/100,!0/100", /* 0 */
2002 "!697+1209/100,!0/100", /* 1 */
2003 "!697+1336/100,!0/100", /* 2 */
2004 "!697+1477/100,!0/100", /* 3 */
2005 "!770+1209/100,!0/100", /* 4 */
2006 "!770+1336/100,!0/100", /* 5 */
2007 "!770+1477/100,!0/100", /* 6 */
2008 "!852+1209/100,!0/100", /* 7 */
2009 "!852+1336/100,!0/100", /* 8 */
2010 "!852+1477/100,!0/100", /* 9 */
2011 "!697+1633/100,!0/100", /* A */
2012 "!770+1633/100,!0/100", /* B */
2013 "!852+1633/100,!0/100", /* C */
2014 "!941+1633/100,!0/100", /* D */
2015 "!941+1209/100,!0/100", /* * */
2016 "!941+1477/100,!0/100" }; /* # */
2018 if (digit >= '0' && digit <='9')
2019 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2020 else if (digit >= 'A' && digit <= 'D')
2021 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2022 else if (digit == '*')
2023 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2024 else if (digit == '#')
2025 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2028 // ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
2029 // "'%c' for '%s'\n", digit, ast->name);
2033 #ifdef LCR_FOR_ASTERISK
2034 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2036 #ifdef LCR_FOR_CALLWEAVER
2037 static int lcr_digit(struct ast_channel *ast, char digit)
2040 struct chan_call *call;
2041 union parameter newparam;
2044 #ifdef LCR_FOR_CALLWEAVER
2045 int inband_dtmf = 0;
2048 /* only pass IA5 number space */
2049 if (digit > 126 || digit < 32)
2053 ast_mutex_lock(&chan_lock);
2055 call = ast->tech_pvt;
2057 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2058 ast_mutex_unlock(&chan_lock);
2063 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2065 /* send information or queue them */
2066 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2067 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2068 memset(&newparam, 0, sizeof(union parameter));
2070 newparam.information.keypad[0] = digit;
2071 newparam.information.keypad[1] = '\0';
2073 newparam.information.id[0] = digit;
2074 newparam.information.id[1] = '\0';
2076 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2079 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2080 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2082 strncat(call->dialque, buf, strlen(call->dialque)-1);
2085 ast_mutex_unlock(&chan_lock);
2088 #ifdef LCR_FOR_ASTERISK
2092 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2094 int inband_dtmf = 0;
2095 struct chan_call *call;
2099 ast_mutex_lock(&chan_lock);
2102 call = ast->tech_pvt;
2106 "Received digit from Asterisk, "
2107 "but no call instance exists.\n");
2108 ast_mutex_unlock(&chan_lock);
2113 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2115 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2119 ast_mutex_unlock(&chan_lock);
2123 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2124 send_digit_to_chan(ast, digit);
2130 static int lcr_answer(struct ast_channel *ast)
2132 union parameter newparam;
2133 struct chan_call *call;
2136 ast_mutex_lock(&chan_lock);
2138 call = ast->tech_pvt;
2140 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2141 ast_mutex_unlock(&chan_lock);
2146 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2148 /* copy connectinfo, if bridged */
2149 if (call->bridge_call)
2150 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2151 /* send connect message to lcr */
2152 if (call->state != CHAN_LCR_STATE_CONNECT) {
2153 memset(&newparam, 0, sizeof(union parameter));
2154 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2155 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2156 call->state = CHAN_LCR_STATE_CONNECT;
2159 /* request bchannel */
2160 if (!call->bchannel) {
2161 CDEBUG(call, ast, "Requesting B-channel.\n");
2162 memset(&newparam, 0, sizeof(union parameter));
2163 newparam.bchannel.type = BCHANNEL_REQUEST;
2164 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2167 // memset(&newparam, 0, sizeof(union parameter));
2168 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2170 ast_mutex_unlock(&chan_lock);
2175 static int lcr_hangup(struct ast_channel *ast)
2177 struct chan_call *call;
2178 pthread_t tid = pthread_self();
2180 if (!pthread_equal(tid, chan_tid)) {
2182 ast_mutex_lock(&chan_lock);
2185 call = ast->tech_pvt;
2187 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2188 if (!pthread_equal(tid, chan_tid)) {
2189 ast_mutex_unlock(&chan_lock);
2195 if (!pthread_equal(tid, chan_tid))
2196 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2198 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2200 /* disconnect asterisk, maybe not required */
2201 ast->tech_pvt = NULL;
2205 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2206 if (ast->hangupcause > 0)
2207 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2209 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2212 if (!pthread_equal(tid, chan_tid)) {
2213 ast_mutex_unlock(&chan_lock);
2218 /* ref is not set, due to prepare setup or release */
2219 if (call->state == CHAN_LCR_STATE_RELEASE) {
2220 /* we get the response to our release */
2221 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2224 /* during prepare, we change to release state */
2225 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2226 call->state = CHAN_LCR_STATE_RELEASE;
2230 if (!pthread_equal(tid, chan_tid)) {
2231 ast_mutex_unlock(&chan_lock);
2237 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2239 struct chan_call *call;
2242 CDEBUG(NULL, ast, "No subclass\n");
2243 if (!(f->subclass & ast->nativeformats))
2244 CDEBUG(NULL, ast, "Unexpected format.\n");
2247 ast_mutex_lock(&chan_lock);
2249 call = ast->tech_pvt;
2251 ast_mutex_unlock(&chan_lock);
2255 if (call->bchannel && f->samples)
2256 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2257 ast_mutex_unlock(&chan_lock);
2263 static struct ast_frame *lcr_read(struct ast_channel *ast)
2265 struct chan_call *call;
2269 ast_mutex_lock(&chan_lock);
2271 call = ast->tech_pvt;
2273 ast_mutex_unlock(&chan_lock);
2277 if (call->pipe[0] > -1) {
2278 if (call->rebuffer && !call->hdlc) {
2279 /* Make sure we have a complete 20ms (160byte) frame */
2281 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2283 call->framepos += len;
2287 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2290 if (len < 0 && errno == EAGAIN) {
2291 ast_mutex_unlock(&chan_lock);
2294 #ifdef LCR_FOR_ASTERISK
2295 return &ast_null_frame;
2298 #ifdef LCR_FOR_CALLWEAVER
2304 close(call->pipe[0]);
2307 ast_mutex_unlock(&chan_lock);
2310 } else if (call->rebuffer && call->framepos < 160) {
2311 /* Not a complete frame, so we send a null-frame */
2312 ast_mutex_unlock(&chan_lock);
2314 return &ast_null_frame;
2318 call->read_fr.frametype = AST_FRAME_VOICE;
2319 call->read_fr.subclass = ast->nativeformats;
2320 if (call->rebuffer) {
2321 call->read_fr.datalen = call->framepos;
2322 call->read_fr.samples = call->framepos;
2325 call->read_fr.datalen = len;
2326 call->read_fr.samples = len;
2328 call->read_fr.delivery = ast_tv(0,0);
2329 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2330 ast_mutex_unlock(&chan_lock);
2333 return &call->read_fr;
2336 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2338 union parameter newparam;
2340 struct chan_call *call;
2341 const struct tone_zone_sound *ts = NULL;
2344 ast_mutex_lock(&chan_lock);
2346 call = ast->tech_pvt;
2348 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2349 ast_mutex_unlock(&chan_lock);
2355 case AST_CONTROL_BUSY:
2356 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2357 ast_setstate(ast, AST_STATE_BUSY);
2358 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2359 /* send message to lcr */
2360 memset(&newparam, 0, sizeof(union parameter));
2361 newparam.disconnectinfo.cause = 17;
2362 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2363 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2365 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2367 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2368 ts = ast_get_indication_tone(ast->zone, "busy");
2371 case AST_CONTROL_CONGESTION:
2372 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2373 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2374 /* send message to lcr */
2375 memset(&newparam, 0, sizeof(union parameter));
2376 newparam.disconnectinfo.cause = ast->hangupcause;
2377 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2378 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2380 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2382 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2383 ts = ast_get_indication_tone(ast->zone, "congestion");
2386 case AST_CONTROL_PROCEEDING:
2387 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2388 if (call->state == CHAN_LCR_STATE_IN_SETUP
2389 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2390 /* send message to lcr */
2391 memset(&newparam, 0, sizeof(union parameter));
2392 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2394 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2397 case AST_CONTROL_RINGING:
2398 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2399 ast_setstate(ast, AST_STATE_RING);
2400 if (call->state == CHAN_LCR_STATE_IN_SETUP
2401 || call->state == CHAN_LCR_STATE_IN_DIALING
2402 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2403 /* send message to lcr */
2404 memset(&newparam, 0, sizeof(union parameter));
2405 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2407 call->state = CHAN_LCR_STATE_IN_ALERTING;
2409 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2410 ts = ast_get_indication_tone(ast->zone, "ring");
2413 case AST_CONTROL_PROGRESS:
2414 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2415 /* request bchannel */
2416 if (!call->bchannel) {
2417 CDEBUG(call, ast, "Requesting B-channel.\n");
2418 memset(&newparam, 0, sizeof(union parameter));
2419 newparam.bchannel.type = BCHANNEL_REQUEST;
2420 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2424 CDEBUG(call, ast, "Received indicate -1.\n");
2425 ast_playtones_stop(ast);
2429 case AST_CONTROL_VIDUPDATE:
2430 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2433 case AST_CONTROL_HOLD:
2434 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2435 /* send message to lcr */
2436 memset(&newparam, 0, sizeof(union parameter));
2437 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2438 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2440 /*start music onhold*/
2441 #ifdef LCR_FOR_ASTERISK
2442 ast_moh_start(ast,data,ast->musicclass);
2445 #ifdef LCR_FOR_CALLWEAVER
2446 ast_moh_start(ast, NULL);
2451 case AST_CONTROL_UNHOLD:
2452 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2453 /* send message to lcr */
2454 memset(&newparam, 0, sizeof(union parameter));
2455 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2456 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2462 #ifdef AST_CONTROL_SRCUPDATE
2463 case AST_CONTROL_SRCUPDATE:
2467 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2470 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2475 if (ts && ts->data[0]) {
2476 ast_playtones_start(ast, 0, ts->data, 1);
2480 ast_mutex_unlock(&chan_lock);
2488 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2490 struct chan_call *call;
2497 ast_mutex_lock(&chan_lock);
2499 call = ast->tech_pvt;
2501 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2502 ast_mutex_unlock(&chan_lock);
2507 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2509 ast_mutex_unlock(&chan_lock);
2515 * send_text asterisk
2517 static int lcr_send_text(struct ast_channel *ast, const char *text)
2519 struct chan_call *call;
2520 union parameter newparam;
2523 ast_mutex_lock(&chan_lock);
2525 call = ast->tech_pvt;
2527 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2528 ast_mutex_unlock(&chan_lock);
2533 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2534 memset(&newparam, 0, sizeof(union parameter));
2535 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2536 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2537 ast_mutex_unlock(&chan_lock);
2545 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2546 struct ast_channel *ast2, int flags,
2547 struct ast_frame **fo,
2548 struct ast_channel **rc, int timeoutms)
2551 struct chan_call *call1, *call2;
2552 struct ast_channel *carr[2], *who;
2554 struct ast_frame *f;
2557 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2562 /* join via dsp (if the channels are currently open) */
2564 ast_mutex_lock(&chan_lock);
2566 call1 = ast1->tech_pvt;
2567 call2 = ast2->tech_pvt;
2568 if (!call1 || !call2) {
2569 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2570 ast_mutex_unlock(&chan_lock);
2572 return AST_BRIDGE_COMPLETE;
2575 /* join, if both call instances uses dsp
2576 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2578 if (!call1->nodsp && !call2->nodsp) {
2579 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2581 /* get bridge id and join */
2582 bridge_id = new_bridge_id();
2584 call1->bridge_id = bridge_id;
2585 if (call1->bchannel)
2586 bchannel_join(call1->bchannel, bridge_id);
2588 call2->bridge_id = bridge_id;
2589 if (call2->bchannel)
2590 bchannel_join(call2->bchannel, bridge_id);
2592 if (call1->nodsp && call2->nodsp)
2593 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2595 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2596 call1->bridge_call = call2;
2597 call2->bridge_call = call1;
2599 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2600 || call1->state == CHAN_LCR_STATE_IN_DIALING
2601 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2602 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2603 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2606 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2607 || call2->state == CHAN_LCR_STATE_IN_DIALING
2608 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2609 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2610 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2614 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2615 so let's do it for them. Hmpf.
2618 if (call1->on_hold) {
2619 union parameter newparam;
2621 memset(&newparam, 0, sizeof(union parameter));
2622 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2623 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2628 if (call2->on_hold) {
2629 union parameter newparam;
2631 memset(&newparam, 0, sizeof(union parameter));
2632 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2633 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2638 ast_mutex_unlock(&chan_lock);
2643 who = ast_waitfor_n(carr, 2, &to);
2646 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2651 if (!f || f->frametype == AST_FRAME_CONTROL) {
2653 CDEBUG(NULL, NULL, "Got hangup.\n");
2655 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2662 if ( f->frametype == AST_FRAME_DTMF ) {
2663 CDEBUG(NULL, NULL, "Got DTMF.\n");
2679 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2681 /* split channels */
2683 ast_mutex_lock(&chan_lock);
2685 call1 = ast1->tech_pvt;
2686 call2 = ast2->tech_pvt;
2687 if (call1 && call1->bridge_id) {
2688 call1->bridge_id = 0;
2689 if (call1->bchannel)
2690 bchannel_join(call1->bchannel, 0);
2691 if (call1->bridge_call)
2692 call1->bridge_call->bridge_call = NULL;
2694 if (call2 && call1->bridge_id) {
2695 call2->bridge_id = 0;
2696 if (call2->bchannel)
2697 bchannel_join(call2->bchannel, 0);
2698 if (call2->bridge_call)
2699 call2->bridge_call->bridge_call = NULL;
2701 call1->bridge_call = NULL;
2702 call2->bridge_call = NULL;
2704 ast_mutex_unlock(&chan_lock);
2706 return AST_BRIDGE_COMPLETE;
2708 static struct ast_channel_tech lcr_tech = {
2710 .description = "Channel driver for connecting to Linux-Call-Router",
2711 .capabilities = AST_FORMAT_ALAW,
2712 .requester = lcr_request,
2714 #ifdef LCR_FOR_ASTERISK
2715 .send_digit_begin = lcr_digit_begin,
2716 .send_digit_end = lcr_digit_end,
2719 #ifdef LCR_FOR_CALLWEAVER
2720 .send_digit = lcr_digit,
2724 .bridge = lcr_bridge,
2725 .hangup = lcr_hangup,
2726 .answer = lcr_answer,
2729 .indicate = lcr_indicate,
2731 .send_text = lcr_send_text,
2740 static int lcr_show_lcr (int fd, int argc, char *argv[])
2745 static int lcr_show_calls (int fd, int argc, char *argv[])
2750 static int lcr_reload_routing (int fd, int argc, char *argv[])
2755 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2760 static int lcr_port_block (int fd, int argc, char *argv[])
2765 static int lcr_port_unblock (int fd, int argc, char *argv[])
2770 static int lcr_port_unload (int fd, int argc, char *argv[])
2775 static struct ast_cli_entry cli_show_lcr =
2776 { {"lcr", "show", "lcr", NULL},
2778 "Shows current states of LCR core",
2779 "Usage: lcr show lcr\n",
2782 static struct ast_cli_entry cli_show_calls =
2783 { {"lcr", "show", "calls", NULL},
2785 "Shows current calls made by LCR and Asterisk",
2786 "Usage: lcr show calls\n",
2789 static struct ast_cli_entry cli_reload_routing =
2790 { {"lcr", "reload", "routing", NULL},
2792 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2793 "Usage: lcr reload routing\n",
2796 static struct ast_cli_entry cli_reload_interfaces =
2797 { {"lcr", "reload", "interfaces", NULL},
2798 lcr_reload_interfaces,
2799 "Reloads interfaces conf of LCR",
2800 "Usage: lcr reload interfaces\n",
2803 static struct ast_cli_entry cli_port_block =
2804 { {"lcr", "port", "block", NULL},
2806 "Blocks LCR port for further calls",
2807 "Usage: lcr port block \"<port>\"\n",
2810 static struct ast_cli_entry cli_port_unblock =
2811 { {"lcr", "port", "unblock", NULL},
2813 "Unblocks or loads LCR port, port is opened my mISDN",
2814 "Usage: lcr port unblock \"<port>\"\n",
2817 static struct ast_cli_entry cli_port_unload =
2818 { {"lcr", "port", "unload", NULL},
2820 "Unloads LCR port, port is closes by mISDN",
2821 "Usage: lcr port unload \"<port>\"\n",
2826 #ifdef LCR_FOR_ASTERISK
2827 static int lcr_config_exec(struct ast_channel *ast, void *data)
2830 #ifdef LCR_FOR_CALLWEAVER
2831 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2834 struct chan_call *call;
2837 ast_mutex_lock(&chan_lock);
2840 #ifdef LCR_FOR_ASTERISK
2841 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2844 #ifdef LCR_FOR_CALLWEAVER
2845 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2851 if (call->ast == ast)
2857 #ifdef LCR_FOR_ASTERISK
2858 apply_opt(call, (char *)data);
2861 #ifdef LCR_FOR_CALLWEAVER
2862 apply_opt(call, (char *)argv[0]);
2866 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2868 ast_mutex_unlock(&chan_lock);
2874 * module loading and destruction
2876 int load_module(void)
2879 char options_error[256];
2881 for (i = 0; i < 256; i++) {
2882 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2883 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2886 if (read_options(options_error) == 0) {
2887 CERROR(NULL, NULL, "%s", options_error);
2889 #ifdef LCR_FOR_ASTERISK
2890 return AST_MODULE_LOAD_DECLINE;
2893 #ifdef LCR_FOR_CALLWEAVER
2899 ast_mutex_init(&chan_lock);
2900 ast_mutex_init(&log_lock);
2902 if (bchannel_initialize()) {
2903 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2906 #ifdef LCR_FOR_ASTERISK
2907 return AST_MODULE_LOAD_DECLINE;
2910 #ifdef LCR_FOR_CALLWEAVER
2916 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2917 if (ast_channel_register(&lcr_tech)) {
2918 CERROR(NULL, NULL, "Unable to register channel class\n");
2919 bchannel_deinitialize();
2922 #ifdef LCR_FOR_ASTERISK
2923 return AST_MODULE_LOAD_DECLINE;
2926 #ifdef LCR_FOR_CALLWEAVER
2931 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2933 #ifdef LCR_FOR_ASTERISK
2934 "lcr_config(<opt><optarg>:<opt>:...)\n"
2937 #ifdef LCR_FOR_CALLWEAVER
2938 "lcr_config(<opt><optarg>:<opt>:...)\n",
2941 "Sets LCR opts. and optargs\n"
2943 "The available options are:\n"
2944 " d - Send display text on called phone, text is the optarg.\n"
2945 " n - Don't detect dtmf tones on called channel.\n"
2946 " h - Force data call (HDLC).\n"
2947 " t - Disable mISDN_dsp features (required for fax application).\n"
2948 " q - Add queue to make fax stream seamless (required for fax app).\n"
2949 " Use queue size in miliseconds for optarg. (try 250)\n"
2950 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2951 " Use time to detect for optarg.\n"
2952 " c - Make crypted outgoing call, optarg is keyindex.\n"
2953 " e - Perform echo cancelation on this channel.\n"
2954 " Takes mISDN pipeline option as optarg.\n"
2955 " s - Send Non Inband DTMF as inband.\n"
2956 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2957 " vr - rxgain control\n"
2958 " vt - txgain control\n"
2959 " Volume changes at factor 2 ^ optarg.\n"
2960 " k - use keypad to dial this call.\n"
2962 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2963 " -> use 16 for fax (3.1k audio)\n"
2965 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2966 "options: \"n:t:q250\" for seamless audio transmission.\n"
2971 ast_cli_register(&cli_show_lcr);
2972 ast_cli_register(&cli_show_calls);
2973 ast_cli_register(&cli_reload_routing);
2974 ast_cli_register(&cli_reload_interfaces);
2975 ast_cli_register(&cli_port_block);
2976 ast_cli_register(&cli_port_unblock);
2977 ast_cli_register(&cli_port_unload);
2981 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2982 /* failed to create thread */
2983 bchannel_deinitialize();
2985 ast_channel_unregister(&lcr_tech);
2987 #ifdef LCR_FOR_ASTERISK
2988 return AST_MODULE_LOAD_DECLINE;
2991 #ifdef LCR_FOR_CALLWEAVER
2999 int unload_module(void)
3001 /* First, take us out of the channel loop */
3002 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
3005 pthread_join(chan_tid, NULL);
3007 ast_channel_unregister(&lcr_tech);
3009 ast_unregister_application("lcr_config");
3012 if (mISDN_created) {
3013 bchannel_deinitialize();
3017 if (lcr_sock >= 0) {
3025 int reload_module(void)
3031 #ifdef LCR_FOR_ASTERISK
3032 #define AST_MODULE "chan_lcr"
3035 #ifdef LCR_FOR_CALLWEAVER
3041 ast_mutex_lock(&usecnt_lock);
3044 ast_mutex_unlock(&usecnt_lock);
3050 #ifdef LCR_FOR_ASTERISK
3051 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3052 .load = load_module,
3053 .unload = unload_module,
3054 .reload = reload_module,
3058 #ifdef LCR_FOR_CALLWEAVER
3059 char *description(void)