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;
229 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, ...)
232 char call_text[128] = "NULL";
233 char ast_text[128] = "NULL";
236 ast_mutex_lock(&log_lock);
239 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
240 buffer[sizeof(buffer)-1]=0;
244 sprintf(call_text, "%d", call->ref);
246 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
247 ast_text[sizeof(ast_text)-1] = '\0';
249 ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
251 ast_mutex_unlock(&log_lock);
255 * channel and call instances
257 struct chan_call *call_first;
261 * special case: 0: find new ref, that has not been assigned a ref yet
264 struct chan_call *find_call_ref(unsigned int ref)
266 struct chan_call *call = call_first;
267 int assigned = (ref > 0);
270 if (call->ref == ref && call->ref_was_assigned == assigned)
277 void free_call(struct chan_call *call)
279 struct chan_call **temp = &call_first;
283 *temp = (*temp)->next;
284 if (call->pipe[0] > -1)
285 close(call->pipe[0]);
286 if (call->pipe[1] > -1)
287 close(call->pipe[1]);
288 if (call->bchannel) {
289 if (call->bchannel->call != call)
290 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
291 call->bchannel->call = NULL;
293 if (call->bridge_call) {
294 if (call->bridge_call->bridge_call != call)
295 CERROR(call, NULL, "Linked call structure has no link to us.\n");
296 call->bridge_call->bridge_call = NULL;
299 ast_translator_free_path(call->trans);
301 ast_dsp_free(call->dsp);
302 CDEBUG(call, NULL, "Call instance freed.\n");
307 temp = &((*temp)->next);
309 CERROR(call, NULL, "Call instance not found in list.\n");
312 struct chan_call *alloc_call(void)
314 struct chan_call **callp = &call_first;
317 callp = &((*callp)->next);
319 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
321 memset(*callp, 0, sizeof(struct chan_call));
322 if (pipe((*callp)->pipe) < 0) {
323 CERROR(*callp, NULL, "Failed to create pipe.\n");
327 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
328 CDEBUG(*callp, NULL, "Call instance allocated.\n");
332 unsigned short new_bridge_id(void)
334 struct chan_call *call;
335 unsigned short id = 1;
337 /* search for lowest bridge id that is not in use and not 0 */
341 if (call->bridge_id == id)
349 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
354 * enque message to LCR
356 int send_message(int message_type, unsigned int ref, union parameter *param)
358 struct admin_list *admin, **adminp;
361 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
364 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
366 adminp = &admin_first;
368 adminp = &((*adminp)->next);
369 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
371 CERROR(NULL, NULL, "No memory for message to LCR.\n");
376 admin->msg.message = ADMIN_MESSAGE;
377 admin->msg.u.msg.type = message_type;
378 admin->msg.u.msg.ref = ref;
379 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
380 socket_fd.when |= LCR_FD_WRITE;
384 write(wake_pipe[1], &byte, 1);
391 * apply options (in locked state)
393 void apply_opt(struct chan_call *call, char *data)
395 union parameter newparam;
396 char string[1024], *p = string, *opt, *key;
402 strncpy(string, data, sizeof(string)-1);
403 string[sizeof(string)-1] = '\0';
406 while((opt = strsep(&p, ":"))) {
409 if (opt[1] == '\0') {
410 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
413 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
414 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
415 strncpy(call->display, opt+1, sizeof(call->display)-1);
417 memset(&newparam, 0, sizeof(union parameter));
418 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
419 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
423 if (opt[1] != '\0') {
424 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
427 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
428 if (call->dsp_dtmf) {
431 bchannel_dtmf(call->bchannel, 0);
435 if (opt[1] == '\0') {
436 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
440 /* check for 0xXXXX... type of key */
441 if (!!strncmp((char *)key, "0x", 2)) {
442 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
446 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
447 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
452 if (*key>='0' && *key<='9')
453 call->bf_key[i] = (*key-'0') << 8;
454 else if (*key>='a' && *key<='f')
455 call->bf_key[i] = (*key-'a'+10) << 8;
456 else if (*key>='A' && *key<='F')
457 call->bf_key[i] = (*key-'A'+10) << 8;
461 if (*key>='0' && *key<='9')
462 call->bf_key[i] += (*key - '0');
463 else if (*key>='a' && *key<='f')
464 call->bf_key[i] += (*key - 'a' + 10);
465 else if (*key>='A' && *key<='F')
466 call->bf_key[i] += (*key - 'A' + 10);
473 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
477 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
479 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
482 if (opt[1] != '\0') {
483 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
486 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
491 if (opt[1] != '\0') {
492 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
495 CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
500 if (opt[1] == '\0') {
501 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
504 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
505 call->nodsp_queue = atoi(opt+1);
508 if (opt[1] == '\0') {
509 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
512 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
513 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
515 bchannel_pipeline(call->bchannel, call->pipeline);
518 if (opt[1] == '\0') {
519 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
522 call->faxdetect=atoi(opt+1);
524 call->dsp=ast_dsp_new();
526 #ifdef LCR_FOR_CALLWEAVER
527 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
529 #ifdef LCR_FOR_ASTERISK
530 #ifdef DSP_FEATURE_DTMF_DETECT
531 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
533 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
538 #ifdef LCR_FOR_CALLWEAVER
539 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
541 #ifdef LCR_FOR_ASTERISK
542 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
545 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
548 if (opt[1] != '\0') {
549 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
552 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
557 if (opt[1] != '\0') {
558 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
561 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
562 call->inband_dtmf = 1;
565 if (opt[1] != 'r' && opt[1] != 't') {
566 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
570 if (gain < -8 || gain >8) {
571 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
574 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
576 call->rx_gain = gain;
578 bchannel_gain(call->bchannel, call->rx_gain, 0);
580 call->tx_gain = gain;
582 bchannel_gain(call->bchannel, call->tx_gain, 1);
586 if (opt[1] != '\0') {
587 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
590 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
595 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
599 /* re-open, if bchannel is created */
600 if (call->bchannel && call->bchannel->b_sock > -1) {
601 bchannel_destroy(call->bchannel);
602 if (bchannel_create(call->bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
603 bchannel_activate(call->bchannel, 1);
608 * send setup info to LCR
609 * this function is called, when asterisk call is received and ref is received
611 static void send_setup_to_lcr(struct chan_call *call)
613 union parameter newparam;
614 struct ast_channel *ast = call->ast;
617 if (!call->ast || !call->ref)
620 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
622 /* send setup message to LCR */
623 memset(&newparam, 0, sizeof(union parameter));
624 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
625 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
627 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
629 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
630 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
631 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
632 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
633 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
634 call->display[0] = '\0';
635 if (call->cid_num[0])
636 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
637 if (call->cid_name[0])
638 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
639 if (call->cid_rdnis[0]) {
640 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
641 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
642 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
644 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
645 case AST_PRES_RESTRICTED:
646 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
648 case AST_PRES_UNAVAILABLE:
649 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
651 case AST_PRES_ALLOWED:
653 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
655 switch(ast->cid.cid_ton) {
657 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
660 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
663 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
666 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
668 tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
670 ast->transfercapability = atoi(tmp);
671 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
672 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
674 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
676 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
677 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
679 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
680 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
681 send_message(MESSAGE_SETUP, call->ref, &newparam);
683 /* change to outgoing setup state */
684 call->state = CHAN_LCR_STATE_OUT_SETUP;
688 * send dialing info to LCR
689 * this function is called, when setup acknowledge is received and dialing
692 static void send_dialque_to_lcr(struct chan_call *call)
694 union parameter newparam;
696 if (!call->ast || !call->ref || !call->dialque[0])
699 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
701 /* send setup message to LCR */
702 memset(&newparam, 0, sizeof(union parameter));
704 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
706 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
707 call->dialque[0] = '\0';
708 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
712 * in case of a bridge, the unsupported message can be forwarded directly
713 * to the remote call.
715 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
719 if (!call->bridge_call) return;
720 CDEBUG(call, NULL, "Sending message due bridging.\n");
721 send_message(message_type, call->bridge_call->ref, param);
725 * send release message to LCR and import bchannel if exported
727 static void send_release_and_import(struct chan_call *call, int cause, int location)
729 union parameter newparam;
731 /* importing channel */
732 if (call->bchannel) {
733 memset(&newparam, 0, sizeof(union parameter));
734 newparam.bchannel.type = BCHANNEL_RELEASE;
735 newparam.bchannel.handle = call->bchannel->handle;
736 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
738 /* sending release */
739 memset(&newparam, 0, sizeof(union parameter));
740 newparam.disconnectinfo.cause = cause;
741 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
742 send_message(MESSAGE_RELEASE, call->ref, &newparam);
746 * check if extension matches and start asterisk
747 * if it can match, proceed
750 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
753 union parameter newparam;
754 char *exten = ast->exten;
758 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
762 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
763 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
767 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
768 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);
772 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
773 /* send setup acknowledge to lcr */
774 memset(&newparam, 0, sizeof(union parameter));
775 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
778 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
783 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
784 /* send setup acknowledge to lcr */
785 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
786 memset(&newparam, 0, sizeof(union parameter));
787 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
791 call->state = CHAN_LCR_STATE_IN_DIALING;
793 /* if match, start pbx */
794 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
795 CDEBUG(call, ast, "Extensions matches.\n");
800 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
806 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
814 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
815 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
817 /* release asterisk */
818 ast->hangupcause = call->cause;
819 /* change to release state */
820 call->state = CHAN_LCR_STATE_RELEASE;
821 ast_hangup(ast); // call will be destroyed here
825 /* send setup to asterisk */
826 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
828 #ifdef LCR_FOR_CALLWEAVER
830 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
833 ret = ast_pbx_start(ast);
835 cause = (ret==-2)?34:27;
838 call->pbx_started = 1;
839 ast_setstate(ast, AST_STATE_RING);
843 * incoming setup from LCR
845 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
847 struct ast_channel *ast;
849 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
851 /* create asterisk channel instrance */
853 #ifdef LCR_FOR_CALLWEAVER
854 ast = ast_channel_alloc(1);
857 #ifdef LCR_FOR_ASTERISK
858 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
863 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
864 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
871 ast->tech_pvt = call;
872 ast->tech = &lcr_tech;
873 ast->fds[0] = call->pipe[0];
875 /* fill setup information */
876 if (param->setup.dialinginfo.id)
877 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
878 if (param->setup.context[0])
879 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
881 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
882 if (param->setup.callerinfo.id[0])
883 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
884 if (param->setup.callerinfo.name[0])
885 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
886 if (param->setup.redirinfo.id[0])
887 ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
888 switch (param->setup.callerinfo.present) {
889 case INFO_PRESENT_ALLOWED:
890 ast->cid.cid_pres = AST_PRES_ALLOWED;
892 case INFO_PRESENT_RESTRICTED:
893 ast->cid.cid_pres = AST_PRES_RESTRICTED;
896 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
898 switch (param->setup.callerinfo.ntype) {
899 case INFO_NTYPE_SUBSCRIBER:
900 ast->cid.cid_ton = 4;
902 case INFO_NTYPE_NATIONAL:
903 ast->cid.cid_ton = 2;
905 case INFO_NTYPE_INTERNATIONAL:
906 ast->cid.cid_ton = 1;
909 ast->cid.cid_ton = 0;
911 ast->transfercapability = param->setup.capainfo.bearer_capa;
912 /* enable hdlc if transcap is data */
913 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
915 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
917 /* configure channel */
918 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
919 ast->readformat = ast->rawreadformat = ast->nativeformats;
920 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
922 ast->hangupcause = 0;
925 call->state = CHAN_LCR_STATE_IN_SETUP;
927 if (!call->pbx_started)
928 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
932 * incoming setup acknowledge from LCR
934 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
936 if (!call->ast) return;
938 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
940 /* send pending digits in dialque */
941 if (call->dialque[0])
942 send_dialque_to_lcr(call);
943 /* change to overlap state */
944 call->state = CHAN_LCR_STATE_OUT_DIALING;
948 * incoming proceeding from LCR
950 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
952 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
955 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
956 /* queue event for asterisk */
957 if (call->ast && call->pbx_started) {
961 write(wake_pipe[1], &byte, 1);
963 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
969 * incoming alerting from LCR
971 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
973 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
976 call->state = CHAN_LCR_STATE_OUT_ALERTING;
977 /* queue event to asterisk */
978 if (call->ast && call->pbx_started) {
982 write(wake_pipe[1], &byte, 1);
984 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
989 * incoming connect from LCR
991 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
993 union parameter newparam;
995 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
998 call->state = CHAN_LCR_STATE_CONNECT;
999 /* request bchannel */
1000 if (!call->bchannel) {
1001 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1002 memset(&newparam, 0, sizeof(union parameter));
1003 newparam.bchannel.type = BCHANNEL_REQUEST;
1004 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1006 /* copy connectinfo */
1007 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1008 /* queue event to asterisk */
1009 if (call->ast && call->pbx_started) {
1013 write(wake_pipe[1], &byte, 1);
1015 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1020 * incoming disconnect from LCR
1022 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1024 struct ast_channel *ast = call->ast;
1026 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1029 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1031 call->cause = param->disconnectinfo.cause;
1032 call->location = param->disconnectinfo.location;
1033 /* if bridge, forward disconnect and return */
1036 if (call->bridge_call) {
1037 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1038 bridge_message_if_bridged(call, message_type, param);
1042 /* release lcr with same cause */
1043 send_release_and_import(call, call->cause, call->location);
1045 /* change to release state */
1046 call->state = CHAN_LCR_STATE_RELEASE;
1047 /* queue release asterisk */
1049 ast->hangupcause = call->cause;
1050 if (call->pbx_started) {
1054 write(wake_pipe[1], &byte, 1);
1056 strcpy(call->queue_string, "H"); // overwrite other indications
1058 ast_hangup(ast); // call will be destroyed here
1064 * incoming release from LCR
1066 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1068 struct ast_channel *ast = call->ast;
1070 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1074 /* change to release state */
1075 call->state = CHAN_LCR_STATE_RELEASE;
1076 /* copy release info */
1078 call->cause = param->disconnectinfo.cause;
1079 call->location = param->disconnectinfo.location;
1081 /* if we have an asterisk instance, queue hangup, else we are done */
1083 ast->hangupcause = call->cause;
1084 if (call->pbx_started) {
1088 write(wake_pipe[1], &byte, 1);
1090 strcpy(call->queue_string, "H");
1092 ast_hangup(ast); // call will be destroyed here
1101 * incoming information from LCR
1103 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1105 struct ast_channel *ast = call->ast;
1107 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1111 /* pbx not started */
1112 if (!call->pbx_started) {
1113 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1114 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1115 lcr_start_pbx(call, ast, param->information.sending_complete);
1119 /* change dailing state after setup */
1120 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1121 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1122 call->state = CHAN_LCR_STATE_IN_DIALING;
1123 // ast_setstate(ast, AST_STATE_DIALING);
1127 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1131 write(wake_pipe[1], &byte, 1);
1133 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1136 /* use bridge to forware message not supported by asterisk */
1137 if (call->state == CHAN_LCR_STATE_CONNECT) {
1138 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1139 bridge_message_if_bridged(call, message_type, param);
1144 * incoming information from LCR
1146 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1148 union parameter newparam;
1150 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1152 /* request bchannel, if call is resumed and we don't have it */
1153 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1154 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1155 memset(&newparam, 0, sizeof(union parameter));
1156 newparam.bchannel.type = BCHANNEL_REQUEST;
1157 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1160 if (!call->ast) return;
1162 /* use bridge to forware message not supported by asterisk */
1163 bridge_message_if_bridged(call, message_type, param);
1167 * incoming information from LCR
1169 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1171 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1173 if (!call->ast) return;
1175 /* use bridge to forware message not supported by asterisk */
1176 bridge_message_if_bridged(call, message_type, param);
1180 * incoming pattern from LCR
1182 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1184 union parameter newparam;
1186 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1188 if (!call->ast) return;
1190 /* pattern are indicated only once */
1191 if (call->has_pattern)
1193 call->has_pattern = 1;
1195 /* request bchannel */
1196 if (!call->bchannel) {
1197 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1198 memset(&newparam, 0, sizeof(union parameter));
1199 newparam.bchannel.type = BCHANNEL_REQUEST;
1200 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1202 /* queue PROGRESS, because tones are available */
1203 if (call->ast && call->pbx_started) {
1207 write(wake_pipe[1], &byte, 1);
1209 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1214 * got dtmf from bchannel (locked state)
1216 void lcr_in_dtmf(struct chan_call *call, int val)
1218 struct ast_channel *ast = call->ast;
1223 if (!call->pbx_started)
1226 if (!call->dsp_dtmf) {
1227 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1231 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1237 write(wake_pipe[1], &byte, 1);
1239 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1243 * message received from LCR
1245 int receive_message(int message_type, unsigned int ref, union parameter *param)
1247 struct bchannel *bchannel;
1248 struct chan_call *call;
1249 union parameter newparam;
1251 memset(&newparam, 0, sizeof(union parameter));
1253 /* handle bchannel message*/
1254 if (message_type == MESSAGE_BCHANNEL) {
1255 switch(param->bchannel.type) {
1256 case BCHANNEL_ASSIGN:
1257 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1258 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1259 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1262 /* create bchannel */
1263 bchannel = alloc_bchannel(param->bchannel.handle);
1265 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1269 /* configure channel */
1270 bchannel->b_tx_gain = param->bchannel.tx_gain;
1271 bchannel->b_rx_gain = param->bchannel.rx_gain;
1272 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1273 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1274 bchannel->b_bf_len = param->bchannel.crypt_len;
1275 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1277 bchannel->b_txdata = 0;
1278 bchannel->b_tx_dejitter = 1;
1280 /* in case, ref is not set, this bchannel instance must
1281 * be created until it is removed again by LCR */
1283 call = find_call_ref(ref);
1285 bchannel->call = call;
1286 call->bchannel = bchannel;
1288 bchannel_dtmf(bchannel, 1);
1290 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1291 if (call->pipeline[0])
1292 bchannel_pipeline(bchannel, call->pipeline);
1294 bchannel_gain(bchannel, call->rx_gain, 0);
1296 bchannel_gain(bchannel, call->tx_gain, 1);
1297 if (call->bridge_id) {
1298 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1299 bchannel_join(bchannel, call->bridge_id);
1301 /* create only, if call exists, othewhise it bchannel is freed below... */
1302 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1303 bchannel_activate(bchannel, 1);
1306 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1307 newparam.bchannel.handle = param->bchannel.handle;
1308 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1309 /* if call has released before bchannel is assigned */
1311 newparam.bchannel.type = BCHANNEL_RELEASE;
1312 newparam.bchannel.handle = param->bchannel.handle;
1313 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1318 case BCHANNEL_REMOVE:
1319 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1320 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1321 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1324 /* unklink from call and destroy bchannel */
1325 free_bchannel(bchannel);
1328 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1329 newparam.bchannel.handle = param->bchannel.handle;
1330 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1335 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1340 /* handle new ref */
1341 if (message_type == MESSAGE_NEWREF) {
1342 if (param->direction) {
1343 /* new ref from lcr */
1344 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1345 if (!ref || find_call_ref(ref)) {
1346 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1349 /* allocate new call instance */
1350 call = alloc_call();
1352 call->state = CHAN_LCR_STATE_IN_PREPARE;
1355 call->ref_was_assigned = 1;
1356 /* set dtmf (default, use option 'n' to disable */
1358 /* wait for setup (or release from asterisk) */
1360 /* new ref, as requested from this remote application */
1361 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1362 call = find_call_ref(0);
1364 /* send release, if ref does not exist */
1365 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1366 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1371 call->ref_was_assigned = 1;
1372 /* set dtmf (default, use option 'n' to disable */
1374 /* send pending setup info */
1375 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1376 send_setup_to_lcr(call);
1377 /* release if asterisk has signed off */
1378 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1381 send_release_and_import(call, call->cause, call->location);
1383 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1394 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1397 call = find_call_ref(ref);
1399 /* ignore ref that is not used (anymore) */
1400 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1404 /* handle messages */
1405 switch(message_type) {
1407 lcr_in_setup(call, message_type, param);
1410 case MESSAGE_OVERLAP:
1411 lcr_in_overlap(call, message_type, param);
1414 case MESSAGE_PROCEEDING:
1415 lcr_in_proceeding(call, message_type, param);
1418 case MESSAGE_ALERTING:
1419 lcr_in_alerting(call, message_type, param);
1422 case MESSAGE_CONNECT:
1423 lcr_in_connect(call, message_type, param);
1426 case MESSAGE_DISCONNECT:
1427 lcr_in_disconnect(call, message_type, param);
1430 case MESSAGE_RELEASE:
1431 lcr_in_release(call, message_type, param);
1434 case MESSAGE_INFORMATION:
1435 lcr_in_information(call, message_type, param);
1438 case MESSAGE_NOTIFY:
1439 lcr_in_notify(call, message_type, param);
1442 case MESSAGE_FACILITY:
1443 lcr_in_facility(call, message_type, param);
1446 case MESSAGE_PATTERN: // audio available from LCR
1447 if (!call->has_pattern)
1448 lcr_in_pattern(call, message_type, param);
1451 case MESSAGE_NOPATTERN: // audio not available from LCR
1454 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1455 call->audiopath = param->audiopath;
1459 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1466 * release all calls (due to broken socket)
1468 static void release_all_calls(void)
1470 struct chan_call *call;
1475 /* no ast, so we may directly free call */
1477 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1481 /* already in release process */
1482 if (call->state == CHAN_LCR_STATE_RELEASE) {
1486 /* release or queue release */
1488 call->state = CHAN_LCR_STATE_RELEASE;
1489 if (!call->pbx_started) {
1490 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1491 ast_hangup(call->ast); // call will be destroyed here
1494 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1498 write(wake_pipe[1], &byte, 1);
1500 strcpy(call->queue_string, "H");
1504 /* release all bchannels */
1505 while(bchannel_first)
1506 free_bchannel(bchannel_first);
1509 void close_socket(void);
1512 * warning! not thread safe
1513 * returns -1 for socket error, 0 for no work, 1 for work
1515 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1518 struct admin_list *admin;
1519 struct admin_message msg;
1521 if ((what & LCR_FD_READ)) {
1522 /* read from socket */
1523 len = read(lcr_sock, &msg, sizeof(msg));
1525 CERROR(NULL, NULL, "Socket closed.\n");
1527 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1529 release_all_calls();
1530 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1534 if (len != sizeof(msg)) {
1535 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1538 if (msg.message != ADMIN_MESSAGE) {
1539 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1542 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1544 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1549 if ((what & LCR_FD_WRITE)) {
1550 /* write to socket */
1552 socket_fd.when &= ~LCR_FD_WRITE;
1555 admin = admin_first;
1556 len = write(lcr_sock, &admin->msg, sizeof(msg));
1558 CERROR(NULL, NULL, "Socket closed.\n");
1562 if (len != sizeof(msg)) {
1563 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1567 admin_first = admin->next;
1571 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1580 * open and close socket and thread
1582 int open_socket(void)
1585 struct sockaddr_un sock_address;
1586 union parameter param;
1589 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1590 CERROR(NULL, NULL, "Failed to create socket.\n");
1594 /* set socket address and name */
1595 memset(&sock_address, 0, sizeof(sock_address));
1596 sock_address.sun_family = PF_UNIX;
1597 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1599 /* connect socket */
1600 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1603 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1607 /* register socket fd */
1608 memset(&socket_fd, 0, sizeof(socket_fd));
1609 socket_fd.fd = lcr_sock;
1610 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1612 /* enque hello message */
1613 memset(¶m, 0, sizeof(param));
1614 strcpy(param.hello.application, "asterisk");
1615 send_message(MESSAGE_HELLO, 0, ¶m);
1620 void close_socket(void)
1622 struct admin_list *admin, *temp;
1624 unregister_fd(&socket_fd);
1626 /* flush pending messages */
1627 admin = admin_first;
1630 admin = admin->next;
1643 /* sending queue to asterisk */
1644 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1648 read(wake_pipe[0], &byte, 1);
1655 static void handle_queue()
1657 struct chan_call *call;
1658 struct ast_channel *ast;
1659 struct ast_frame fr;
1664 p = call->queue_string;
1667 ast_channel_lock(ast);
1671 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1672 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1675 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1676 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1679 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1680 ast_queue_control(ast, AST_CONTROL_RINGING);
1681 ast_setstate(ast, AST_STATE_RINGING);
1684 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1685 ast_queue_control(ast, AST_CONTROL_ANSWER);
1688 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1689 ast_queue_hangup(ast);
1691 case '1': case '2': case '3': case 'A':
1692 case '4': case '5': case '6': case 'B':
1693 case '7': case '8': case '9': case 'C':
1694 case '*': case '0': case '#': case 'D':
1695 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1696 /* send digit to asterisk */
1697 memset(&fr, 0, sizeof(fr));
1699 #ifdef LCR_FOR_ASTERISK
1700 fr.frametype = AST_FRAME_DTMF_BEGIN;
1703 #ifdef LCR_FOR_CALLWEAVER
1704 fr.frametype = AST_FRAME_DTMF;
1708 fr.delivery = ast_tv(0, 0);
1709 ast_queue_frame(ast, &fr);
1711 #ifdef LCR_FOR_ASTERISK
1712 fr.frametype = AST_FRAME_DTMF_END;
1713 ast_queue_frame(ast, &fr);
1718 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1722 call->queue_string[0] = '\0';
1723 ast_channel_unlock(ast);
1729 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1731 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1732 if (open_socket() < 0)
1733 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1738 void lock_chan(void)
1740 ast_mutex_lock(&chan_lock);
1743 void unlock_chan(void)
1745 ast_mutex_unlock(&chan_lock);
1748 /* chan_lcr thread */
1749 static void *chan_thread(void *arg)
1751 if (pipe(wake_pipe) < 0) {
1752 CERROR(NULL, NULL, "Failed to open pipe.\n");
1755 memset(&wake_fd, 0, sizeof(wake_fd));
1756 wake_fd.fd = wake_pipe[0];
1757 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1759 memset(&socket_retry, 0, sizeof(socket_retry));
1760 add_timer(&socket_retry, handle_retry, NULL, 0);
1762 bchannel_pid = getpid();
1764 /* open socket the first time */
1765 handle_retry(NULL, NULL, 0);
1767 ast_mutex_lock(&chan_lock);
1771 select_main(0, &global_change, lock_chan, unlock_chan);
1776 del_timer(&socket_retry);
1778 unregister_fd(&wake_fd);
1779 close(wake_pipe[0]);
1780 close(wake_pipe[1]);
1782 CERROR(NULL, NULL, "Thread exit.\n");
1784 ast_mutex_unlock(&chan_lock);
1790 * new asterisk instance
1793 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1795 char exten[256], *dial, *interface, *opt;
1796 struct ast_channel *ast;
1797 struct chan_call *call;
1799 ast_mutex_lock(&chan_lock);
1800 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1802 /* if socket is closed */
1804 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1805 ast_mutex_unlock(&chan_lock);
1809 /* create call instance */
1810 call = alloc_call();
1812 /* failed to create instance */
1813 ast_mutex_unlock(&chan_lock);
1817 /* create asterisk channel instrance */
1819 #ifdef LCR_FOR_ASTERISK
1820 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1823 #ifdef LCR_FOR_CALLWEAVER
1824 ast = ast_channel_alloc(1);
1828 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1830 /* failed to create instance */
1831 ast_mutex_unlock(&chan_lock);
1834 ast->tech = &lcr_tech;
1835 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1836 /* configure channel */
1837 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1838 ast->readformat = ast->rawreadformat = ast->nativeformats;
1839 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1841 ast->hangupcause = 0;
1845 ast->tech_pvt = call;
1846 ast->fds[0] = call->pipe[0];
1847 call->pbx_started = 0;
1849 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1852 * Extract interface, dialstring, options from data.
1855 * <interface>/<dialstring>
1856 * <interface>/<dialstring>/options
1858 strncpy(exten, (char *)data, sizeof(exten)-1);
1859 exten[sizeof(exten)-1] = '\0';
1860 if ((dial = strchr(exten, '/'))) {
1863 if ((opt = strchr(dial, '/')))
1872 strncpy(call->interface, interface, sizeof(call->interface)-1);
1873 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1874 apply_opt(call, (char *)opt);
1876 ast_mutex_unlock(&chan_lock);
1881 * call from asterisk
1883 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1885 union parameter newparam;
1886 struct chan_call *call;
1888 ast_mutex_lock(&chan_lock);
1889 call = ast->tech_pvt;
1891 #ifdef LCR_FOR_CALLWEAVER
1893 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1897 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1898 ast_mutex_unlock(&chan_lock);
1902 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1904 /* pbx process is started */
1905 call->pbx_started = 1;
1906 /* send MESSAGE_NEWREF */
1907 memset(&newparam, 0, sizeof(union parameter));
1908 newparam.direction = 0; /* request from app */
1909 send_message(MESSAGE_NEWREF, 0, &newparam);
1911 /* set hdlc if capability requires hdlc */
1912 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1913 || ast->transfercapability == INFO_BC_DATARESTRICTED
1914 || ast->transfercapability == INFO_BC_VIDEO)
1916 /* if hdlc is forced by option, we change transcap to data */
1918 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1919 && ast->transfercapability != INFO_BC_DATARESTRICTED
1920 && ast->transfercapability != INFO_BC_VIDEO)
1921 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1923 call->cid_num[0] = 0;
1924 call->cid_name[0] = 0;
1925 call->cid_rdnis[0] = 0;
1927 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1928 strncpy(call->cid_num, ast->cid.cid_num,
1929 sizeof(call->cid_num)-1);
1931 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1932 strncpy(call->cid_name, ast->cid.cid_name,
1933 sizeof(call->cid_name)-1);
1934 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1935 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1936 sizeof(call->cid_rdnis)-1);
1938 ast_mutex_unlock(&chan_lock);
1942 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1944 static const char* dtmf_tones[] = {
1945 "!941+1336/100,!0/100", /* 0 */
1946 "!697+1209/100,!0/100", /* 1 */
1947 "!697+1336/100,!0/100", /* 2 */
1948 "!697+1477/100,!0/100", /* 3 */
1949 "!770+1209/100,!0/100", /* 4 */
1950 "!770+1336/100,!0/100", /* 5 */
1951 "!770+1477/100,!0/100", /* 6 */
1952 "!852+1209/100,!0/100", /* 7 */
1953 "!852+1336/100,!0/100", /* 8 */
1954 "!852+1477/100,!0/100", /* 9 */
1955 "!697+1633/100,!0/100", /* A */
1956 "!770+1633/100,!0/100", /* B */
1957 "!852+1633/100,!0/100", /* C */
1958 "!941+1633/100,!0/100", /* D */
1959 "!941+1209/100,!0/100", /* * */
1960 "!941+1477/100,!0/100" }; /* # */
1962 if (digit >= '0' && digit <='9')
1963 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1964 else if (digit >= 'A' && digit <= 'D')
1965 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1966 else if (digit == '*')
1967 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1968 else if (digit == '#')
1969 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1972 ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
1973 "'%c' for '%s'\n", digit, ast->name);
1977 #ifdef LCR_FOR_ASTERISK
1978 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1980 #ifdef LCR_FOR_CALLWEAVER
1981 static int lcr_digit(struct ast_channel *ast, char digit)
1984 struct chan_call *call;
1985 union parameter newparam;
1988 #ifdef LCR_FOR_CALLWEAVER
1989 int inband_dtmf = 0;
1992 /* only pass IA5 number space */
1993 if (digit > 126 || digit < 32)
1996 ast_mutex_lock(&chan_lock);
1997 call = ast->tech_pvt;
1999 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2000 ast_mutex_unlock(&chan_lock);
2004 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2006 /* send information or queue them */
2007 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2008 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2009 memset(&newparam, 0, sizeof(union parameter));
2011 newparam.information.keypad[0] = digit;
2012 newparam.information.keypad[1] = '\0';
2014 newparam.information.id[0] = digit;
2015 newparam.information.id[1] = '\0';
2017 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2020 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2021 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2023 strncat(call->dialque, buf, strlen(call->dialque)-1);
2026 ast_mutex_unlock(&chan_lock);
2028 #ifdef LCR_FOR_ASTERISK
2032 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2034 int inband_dtmf = 0;
2035 struct chan_call *call;
2038 ast_mutex_lock(&chan_lock);
2040 call = ast->tech_pvt;
2044 "Received digit from Asterisk, "
2045 "but no call instance exists.\n");
2046 ast_mutex_unlock(&chan_lock);
2050 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2052 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2056 ast_mutex_unlock(&chan_lock);
2059 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2060 send_digit_to_chan(ast, digit);
2066 static int lcr_answer(struct ast_channel *ast)
2068 union parameter newparam;
2069 struct chan_call *call;
2071 ast_mutex_lock(&chan_lock);
2072 call = ast->tech_pvt;
2074 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2075 ast_mutex_unlock(&chan_lock);
2079 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2081 /* copy connectinfo, if bridged */
2082 if (call->bridge_call)
2083 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2084 /* send connect message to lcr */
2085 if (call->state != CHAN_LCR_STATE_CONNECT) {
2086 memset(&newparam, 0, sizeof(union parameter));
2087 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2088 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2089 call->state = CHAN_LCR_STATE_CONNECT;
2092 /* request bchannel */
2093 if (!call->bchannel) {
2094 CDEBUG(call, ast, "Requesting B-channel.\n");
2095 memset(&newparam, 0, sizeof(union parameter));
2096 newparam.bchannel.type = BCHANNEL_REQUEST;
2097 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2100 // memset(&newparam, 0, sizeof(union parameter));
2101 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2103 ast_mutex_unlock(&chan_lock);
2107 static int lcr_hangup(struct ast_channel *ast)
2109 struct chan_call *call;
2110 pthread_t tid = pthread_self();
2112 if (!pthread_equal(tid, chan_tid))
2113 ast_mutex_lock(&chan_lock);
2114 call = ast->tech_pvt;
2116 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2117 if (!pthread_equal(tid, chan_tid))
2118 ast_mutex_unlock(&chan_lock);
2122 if (!pthread_equal(tid, chan_tid))
2123 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2125 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2127 /* disconnect asterisk, maybe not required */
2128 ast->tech_pvt = NULL;
2132 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2133 if (ast->hangupcause > 0)
2134 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2136 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2139 if (!pthread_equal(tid, chan_tid))
2140 ast_mutex_unlock(&chan_lock);
2143 /* ref is not set, due to prepare setup or release */
2144 if (call->state == CHAN_LCR_STATE_RELEASE) {
2145 /* we get the response to our release */
2146 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2149 /* during prepare, we change to release state */
2150 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2151 call->state = CHAN_LCR_STATE_RELEASE;
2155 if (!pthread_equal(tid, chan_tid))
2156 ast_mutex_unlock(&chan_lock);
2160 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2162 struct chan_call *call;
2165 CDEBUG(NULL, ast, "No subclass\n");
2166 if (!(f->subclass & ast->nativeformats))
2167 CDEBUG(NULL, ast, "Unexpected format.\n");
2169 ast_mutex_lock(&chan_lock);
2170 call = ast->tech_pvt;
2172 ast_mutex_unlock(&chan_lock);
2175 if (call->bchannel && f->samples)
2176 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2177 ast_mutex_unlock(&chan_lock);
2182 static struct ast_frame *lcr_read(struct ast_channel *ast)
2184 struct chan_call *call;
2187 ast_mutex_lock(&chan_lock);
2188 call = ast->tech_pvt;
2190 ast_mutex_unlock(&chan_lock);
2193 if (call->pipe[0] > -1) {
2194 if (call->rebuffer && !call->hdlc) {
2195 /* Make sure we have a complete 20ms (160byte) frame */
2196 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2198 call->framepos += len;
2201 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2203 if (len < 0 && errno == EAGAIN) {
2204 ast_mutex_unlock(&chan_lock);
2206 #ifdef LCR_FOR_ASTERISK
2207 return &ast_null_frame;
2210 #ifdef LCR_FOR_CALLWEAVER
2216 close(call->pipe[0]);
2219 ast_mutex_unlock(&chan_lock);
2221 } else if (call->rebuffer && call->framepos < 160) {
2222 /* Not a complete frame, so we send a null-frame */
2223 ast_mutex_unlock(&chan_lock);
2224 return &ast_null_frame;
2228 call->read_fr.frametype = AST_FRAME_VOICE;
2229 call->read_fr.subclass = ast->nativeformats;
2230 if (call->rebuffer) {
2231 call->read_fr.datalen = call->framepos;
2232 call->read_fr.samples = call->framepos;
2235 call->read_fr.datalen = len;
2236 call->read_fr.samples = len;
2238 call->read_fr.delivery = ast_tv(0,0);
2239 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2240 ast_mutex_unlock(&chan_lock);
2242 return &call->read_fr;
2245 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2247 union parameter newparam;
2249 struct chan_call *call;
2251 ast_mutex_lock(&chan_lock);
2252 call = ast->tech_pvt;
2254 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2255 ast_mutex_unlock(&chan_lock);
2260 case AST_CONTROL_BUSY:
2261 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2262 ast_setstate(ast, AST_STATE_BUSY);
2263 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2264 /* send message to lcr */
2265 memset(&newparam, 0, sizeof(union parameter));
2266 newparam.disconnectinfo.cause = 17;
2267 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2268 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2270 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2273 case AST_CONTROL_CONGESTION:
2274 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2275 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2276 /* send message to lcr */
2277 memset(&newparam, 0, sizeof(union parameter));
2278 newparam.disconnectinfo.cause = ast->hangupcause;
2279 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2280 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2282 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2285 case AST_CONTROL_PROCEEDING:
2286 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2287 if (call->state == CHAN_LCR_STATE_IN_SETUP
2288 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2289 /* send message to lcr */
2290 memset(&newparam, 0, sizeof(union parameter));
2291 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2293 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2296 case AST_CONTROL_RINGING:
2297 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2298 ast_setstate(ast, AST_STATE_RING);
2299 if (call->state == CHAN_LCR_STATE_IN_SETUP
2300 || call->state == CHAN_LCR_STATE_IN_DIALING
2301 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2302 /* send message to lcr */
2303 memset(&newparam, 0, sizeof(union parameter));
2304 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2306 call->state = CHAN_LCR_STATE_IN_ALERTING;
2309 case AST_CONTROL_PROGRESS:
2310 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2311 /* request bchannel */
2312 if (!call->bchannel) {
2313 CDEBUG(call, ast, "Requesting B-channel.\n");
2314 memset(&newparam, 0, sizeof(union parameter));
2315 newparam.bchannel.type = BCHANNEL_REQUEST;
2316 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2320 CDEBUG(call, ast, "Received indicate -1.\n");
2324 case AST_CONTROL_VIDUPDATE:
2325 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2328 case AST_CONTROL_HOLD:
2329 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2330 /* send message to lcr */
2331 memset(&newparam, 0, sizeof(union parameter));
2332 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2333 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2335 /*start music onhold*/
2336 #ifdef LCR_FOR_ASTERISK
2337 ast_moh_start(ast,data,ast->musicclass);
2340 #ifdef LCR_FOR_CALLWEAVER
2341 ast_moh_start(ast, NULL);
2346 case AST_CONTROL_UNHOLD:
2347 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2348 /* send message to lcr */
2349 memset(&newparam, 0, sizeof(union parameter));
2350 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2351 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2357 #ifdef AST_CONTROL_SRCUPDATE
2358 case AST_CONTROL_SRCUPDATE:
2362 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2365 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2371 ast_mutex_unlock(&chan_lock);
2378 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2380 struct chan_call *call;
2386 ast_mutex_lock(&chan_lock);
2387 call = ast->tech_pvt;
2389 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2390 ast_mutex_unlock(&chan_lock);
2394 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2396 ast_mutex_unlock(&chan_lock);
2401 * send_text asterisk
2403 static int lcr_send_text(struct ast_channel *ast, const char *text)
2405 struct chan_call *call;
2406 union parameter newparam;
2408 ast_mutex_lock(&chan_lock);
2409 call = ast->tech_pvt;
2411 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2412 ast_mutex_unlock(&chan_lock);
2416 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2417 memset(&newparam, 0, sizeof(union parameter));
2418 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2419 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2420 ast_mutex_lock(&chan_lock);
2427 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2428 struct ast_channel *ast2, int flags,
2429 struct ast_frame **fo,
2430 struct ast_channel **rc, int timeoutms)
2433 struct chan_call *call1, *call2;
2434 struct ast_channel *carr[2], *who;
2436 struct ast_frame *f;
2439 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2444 /* join via dsp (if the channels are currently open) */
2445 ast_mutex_lock(&chan_lock);
2446 call1 = ast1->tech_pvt;
2447 call2 = ast2->tech_pvt;
2448 if (!call1 || !call2) {
2449 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2450 ast_mutex_unlock(&chan_lock);
2451 return AST_BRIDGE_COMPLETE;
2454 /* join, if both call instances uses dsp
2455 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2457 if (!call1->nodsp && !call2->nodsp) {
2458 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2460 /* get bridge id and join */
2461 bridge_id = new_bridge_id();
2463 call1->bridge_id = bridge_id;
2464 if (call1->bchannel)
2465 bchannel_join(call1->bchannel, bridge_id);
2467 call2->bridge_id = bridge_id;
2468 if (call2->bchannel)
2469 bchannel_join(call2->bchannel, bridge_id);
2471 if (call1->nodsp && call2->nodsp)
2472 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2474 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2475 call1->bridge_call = call2;
2476 call2->bridge_call = call1;
2478 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2479 || call1->state == CHAN_LCR_STATE_IN_DIALING
2480 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2481 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2482 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2485 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2486 || call2->state == CHAN_LCR_STATE_IN_DIALING
2487 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2488 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2489 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2493 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2494 so let's do it for them. Hmpf.
2497 if (call1->on_hold) {
2498 union parameter newparam;
2500 memset(&newparam, 0, sizeof(union parameter));
2501 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2502 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2507 if (call2->on_hold) {
2508 union parameter newparam;
2510 memset(&newparam, 0, sizeof(union parameter));
2511 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2512 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2517 ast_mutex_unlock(&chan_lock);
2521 who = ast_waitfor_n(carr, 2, &to);
2524 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2529 if (!f || f->frametype == AST_FRAME_CONTROL) {
2531 CDEBUG(NULL, NULL, "Got hangup.\n");
2533 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2540 if ( f->frametype == AST_FRAME_DTMF ) {
2541 CDEBUG(NULL, NULL, "Got DTMF.\n");
2557 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2559 /* split channels */
2560 ast_mutex_lock(&chan_lock);
2561 call1 = ast1->tech_pvt;
2562 call2 = ast2->tech_pvt;
2563 if (call1 && call1->bridge_id) {
2564 call1->bridge_id = 0;
2565 if (call1->bchannel)
2566 bchannel_join(call1->bchannel, 0);
2567 if (call1->bridge_call)
2568 call1->bridge_call->bridge_call = NULL;
2570 if (call2 && call1->bridge_id) {
2571 call2->bridge_id = 0;
2572 if (call2->bchannel)
2573 bchannel_join(call2->bchannel, 0);
2574 if (call2->bridge_call)
2575 call2->bridge_call->bridge_call = NULL;
2577 call1->bridge_call = NULL;
2578 call2->bridge_call = NULL;
2580 ast_mutex_unlock(&chan_lock);
2581 return AST_BRIDGE_COMPLETE;
2583 static struct ast_channel_tech lcr_tech = {
2585 .description = "Channel driver for connecting to Linux-Call-Router",
2586 .capabilities = AST_FORMAT_ALAW,
2587 .requester = lcr_request,
2589 #ifdef LCR_FOR_ASTERISK
2590 .send_digit_begin = lcr_digit_begin,
2591 .send_digit_end = lcr_digit_end,
2594 #ifdef LCR_FOR_CALLWEAVER
2595 .send_digit = lcr_digit,
2599 .bridge = lcr_bridge,
2600 .hangup = lcr_hangup,
2601 .answer = lcr_answer,
2604 .indicate = lcr_indicate,
2606 .send_text = lcr_send_text,
2615 static int lcr_show_lcr (int fd, int argc, char *argv[])
2620 static int lcr_show_calls (int fd, int argc, char *argv[])
2625 static int lcr_reload_routing (int fd, int argc, char *argv[])
2630 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2635 static int lcr_port_block (int fd, int argc, char *argv[])
2640 static int lcr_port_unblock (int fd, int argc, char *argv[])
2645 static int lcr_port_unload (int fd, int argc, char *argv[])
2650 static struct ast_cli_entry cli_show_lcr =
2651 { {"lcr", "show", "lcr", NULL},
2653 "Shows current states of LCR core",
2654 "Usage: lcr show lcr\n",
2657 static struct ast_cli_entry cli_show_calls =
2658 { {"lcr", "show", "calls", NULL},
2660 "Shows current calls made by LCR and Asterisk",
2661 "Usage: lcr show calls\n",
2664 static struct ast_cli_entry cli_reload_routing =
2665 { {"lcr", "reload", "routing", NULL},
2667 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2668 "Usage: lcr reload routing\n",
2671 static struct ast_cli_entry cli_reload_interfaces =
2672 { {"lcr", "reload", "interfaces", NULL},
2673 lcr_reload_interfaces,
2674 "Reloads interfaces conf of LCR",
2675 "Usage: lcr reload interfaces\n",
2678 static struct ast_cli_entry cli_port_block =
2679 { {"lcr", "port", "block", NULL},
2681 "Blocks LCR port for further calls",
2682 "Usage: lcr port block \"<port>\"\n",
2685 static struct ast_cli_entry cli_port_unblock =
2686 { {"lcr", "port", "unblock", NULL},
2688 "Unblocks or loads LCR port, port is opened my mISDN",
2689 "Usage: lcr port unblock \"<port>\"\n",
2692 static struct ast_cli_entry cli_port_unload =
2693 { {"lcr", "port", "unload", NULL},
2695 "Unloads LCR port, port is closes by mISDN",
2696 "Usage: lcr port unload \"<port>\"\n",
2701 #ifdef LCR_FOR_ASTERISK
2702 static int lcr_config_exec(struct ast_channel *ast, void *data)
2705 #ifdef LCR_FOR_CALLWEAVER
2706 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2709 struct chan_call *call;
2711 ast_mutex_lock(&chan_lock);
2713 #ifdef LCR_FOR_ASTERISK
2714 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2717 #ifdef LCR_FOR_CALLWEAVER
2718 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2724 if (call->ast == ast)
2730 #ifdef LCR_FOR_ASTERISK
2731 apply_opt(call, (char *)data);
2734 #ifdef LCR_FOR_CALLWEAVER
2735 apply_opt(call, (char *)argv[0]);
2739 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2741 ast_mutex_unlock(&chan_lock);
2746 * module loading and destruction
2748 int load_module(void)
2752 for (i = 0; i < 256; i++) {
2753 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2754 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2757 if (read_options() == 0) {
2758 CERROR(NULL, NULL, "%s", options_error);
2760 #ifdef LCR_FOR_ASTERISK
2761 return AST_MODULE_LOAD_DECLINE;
2764 #ifdef LCR_FOR_CALLWEAVER
2770 ast_mutex_init(&chan_lock);
2771 ast_mutex_init(&log_lock);
2773 if (bchannel_initialize()) {
2774 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2777 #ifdef LCR_FOR_ASTERISK
2778 return AST_MODULE_LOAD_DECLINE;
2781 #ifdef LCR_FOR_CALLWEAVER
2787 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2788 if (ast_channel_register(&lcr_tech)) {
2789 CERROR(NULL, NULL, "Unable to register channel class\n");
2790 bchannel_deinitialize();
2793 #ifdef LCR_FOR_ASTERISK
2794 return AST_MODULE_LOAD_DECLINE;
2797 #ifdef LCR_FOR_CALLWEAVER
2802 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2804 #ifdef LCR_FOR_ASTERISK
2805 "lcr_config(<opt><optarg>:<opt>:...)\n"
2808 #ifdef LCR_FOR_CALLWEAVER
2809 "lcr_config(<opt><optarg>:<opt>:...)\n",
2812 "Sets LCR opts. and optargs\n"
2814 "The available options are:\n"
2815 " d - Send display text on called phone, text is the optarg.\n"
2816 " n - Don't detect dtmf tones on called channel.\n"
2817 " h - Force data call (HDLC).\n"
2818 " t - Disable mISDN_dsp features (required for fax application).\n"
2819 " q - Add queue to make fax stream seamless (required for fax app).\n"
2820 " Use queue size in miliseconds for optarg. (try 250)\n"
2821 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2822 " Use time to detect for optarg.\n"
2823 " c - Make crypted outgoing call, optarg is keyindex.\n"
2824 " e - Perform echo cancelation on this channel.\n"
2825 " Takes mISDN pipeline option as optarg.\n"
2826 " s - Send Non Inband DTMF as inband.\n"
2827 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2828 " vr - rxgain control\n"
2829 " vt - txgain control\n"
2830 " Volume changes at factor 2 ^ optarg.\n"
2831 " k - use keypad to dial this call.\n"
2833 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2834 " -> use 16 for fax (3.1k audio)\n"
2836 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2837 "options: \"n:t:q250\" for seamless audio transmission.\n"
2842 ast_cli_register(&cli_show_lcr);
2843 ast_cli_register(&cli_show_calls);
2844 ast_cli_register(&cli_reload_routing);
2845 ast_cli_register(&cli_reload_interfaces);
2846 ast_cli_register(&cli_port_block);
2847 ast_cli_register(&cli_port_unblock);
2848 ast_cli_register(&cli_port_unload);
2852 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2853 /* failed to create thread */
2854 bchannel_deinitialize();
2856 ast_channel_unregister(&lcr_tech);
2858 #ifdef LCR_FOR_ASTERISK
2859 return AST_MODULE_LOAD_DECLINE;
2862 #ifdef LCR_FOR_CALLWEAVER
2870 int unload_module(void)
2872 /* First, take us out of the channel loop */
2873 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2876 pthread_join(chan_tid, NULL);
2878 ast_channel_unregister(&lcr_tech);
2880 ast_unregister_application("lcr_config");
2883 if (mISDN_created) {
2884 bchannel_deinitialize();
2888 if (lcr_sock >= 0) {
2896 int reload_module(void)
2902 #ifdef LCR_FOR_ASTERISK
2903 #define AST_MODULE "chan_lcr"
2906 #ifdef LCR_FOR_CALLWEAVER
2911 ast_mutex_lock(&usecnt_lock);
2913 ast_mutex_unlock(&usecnt_lock);
2918 #ifdef LCR_FOR_ASTERISK
2919 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2920 .load = load_module,
2921 .unload = unload_module,
2922 .reload = reload_module,
2926 #ifdef LCR_FOR_CALLWEAVER
2927 char *description(void)