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 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
669 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
671 // ast->transfercapability = atoi(tmp);
672 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
673 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
675 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
677 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
678 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
680 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
681 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
682 send_message(MESSAGE_SETUP, call->ref, &newparam);
684 /* change to outgoing setup state */
685 call->state = CHAN_LCR_STATE_OUT_SETUP;
689 * send dialing info to LCR
690 * this function is called, when setup acknowledge is received and dialing
693 static void send_dialque_to_lcr(struct chan_call *call)
695 union parameter newparam;
697 if (!call->ast || !call->ref || !call->dialque[0])
700 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
702 /* send setup message to LCR */
703 memset(&newparam, 0, sizeof(union parameter));
705 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
707 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
708 call->dialque[0] = '\0';
709 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
713 * in case of a bridge, the unsupported message can be forwarded directly
714 * to the remote call.
716 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
720 if (!call->bridge_call) return;
721 CDEBUG(call, NULL, "Sending message due bridging.\n");
722 send_message(message_type, call->bridge_call->ref, param);
726 * send release message to LCR and import bchannel if exported
728 static void send_release_and_import(struct chan_call *call, int cause, int location)
730 union parameter newparam;
732 /* importing channel */
733 if (call->bchannel) {
734 memset(&newparam, 0, sizeof(union parameter));
735 newparam.bchannel.type = BCHANNEL_RELEASE;
736 newparam.bchannel.handle = call->bchannel->handle;
737 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
739 /* sending release */
740 memset(&newparam, 0, sizeof(union parameter));
741 newparam.disconnectinfo.cause = cause;
742 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
743 send_message(MESSAGE_RELEASE, call->ref, &newparam);
747 * check if extension matches and start asterisk
748 * if it can match, proceed
751 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
754 union parameter newparam;
755 char *exten = ast->exten;
759 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
763 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
764 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
768 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
769 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);
773 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
774 /* send setup acknowledge to lcr */
775 memset(&newparam, 0, sizeof(union parameter));
776 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
779 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
784 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
785 /* send setup acknowledge to lcr */
786 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
787 memset(&newparam, 0, sizeof(union parameter));
788 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
792 call->state = CHAN_LCR_STATE_IN_DIALING;
794 /* if match, start pbx */
795 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
796 CDEBUG(call, ast, "Extensions matches.\n");
801 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
807 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
815 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
816 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
818 /* release asterisk */
819 ast->hangupcause = call->cause;
820 /* change to release state */
821 call->state = CHAN_LCR_STATE_RELEASE;
822 ast_hangup(ast); // call will be destroyed here
826 /* send setup to asterisk */
827 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
829 #ifdef LCR_FOR_CALLWEAVER
831 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
834 ret = ast_pbx_start(ast);
836 cause = (ret==-2)?34:27;
839 call->pbx_started = 1;
840 ast_setstate(ast, AST_STATE_RING);
844 * incoming setup from LCR
846 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
848 struct ast_channel *ast;
850 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
852 /* create asterisk channel instrance */
854 #ifdef LCR_FOR_CALLWEAVER
855 ast = ast_channel_alloc(1);
858 #ifdef LCR_FOR_ASTERISK
859 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
864 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
865 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
872 ast->tech_pvt = call;
873 ast->tech = &lcr_tech;
874 ast->fds[0] = call->pipe[0];
876 /* fill setup information */
877 if (param->setup.dialinginfo.id)
878 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
879 if (param->setup.context[0])
880 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
882 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
883 if (param->setup.callerinfo.id[0])
884 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
885 if (param->setup.callerinfo.name[0])
886 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
887 if (param->setup.redirinfo.id[0])
888 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
889 switch (param->setup.callerinfo.present) {
890 case INFO_PRESENT_ALLOWED:
891 ast->cid.cid_pres = AST_PRES_ALLOWED;
893 case INFO_PRESENT_RESTRICTED:
894 ast->cid.cid_pres = AST_PRES_RESTRICTED;
897 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
899 switch (param->setup.callerinfo.ntype) {
900 case INFO_NTYPE_SUBSCRIBER:
901 ast->cid.cid_ton = 4;
903 case INFO_NTYPE_NATIONAL:
904 ast->cid.cid_ton = 2;
906 case INFO_NTYPE_INTERNATIONAL:
907 ast->cid.cid_ton = 1;
910 ast->cid.cid_ton = 0;
912 ast->transfercapability = param->setup.capainfo.bearer_capa;
913 /* enable hdlc if transcap is data */
914 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
916 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
918 /* configure channel */
919 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
920 ast->readformat = ast->rawreadformat = ast->nativeformats;
921 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
923 ast->hangupcause = 0;
926 call->state = CHAN_LCR_STATE_IN_SETUP;
928 if (!call->pbx_started)
929 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
933 * incoming setup acknowledge from LCR
935 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
937 if (!call->ast) return;
939 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
941 /* send pending digits in dialque */
942 if (call->dialque[0])
943 send_dialque_to_lcr(call);
944 /* change to overlap state */
945 call->state = CHAN_LCR_STATE_OUT_DIALING;
949 * incoming proceeding from LCR
951 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
953 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
956 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
957 /* queue event for asterisk */
958 if (call->ast && call->pbx_started) {
962 write(wake_pipe[1], &byte, 1);
964 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
970 * incoming alerting from LCR
972 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
974 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
977 call->state = CHAN_LCR_STATE_OUT_ALERTING;
978 /* queue event to asterisk */
979 if (call->ast && call->pbx_started) {
983 write(wake_pipe[1], &byte, 1);
985 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
990 * incoming connect from LCR
992 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
994 union parameter newparam;
996 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
999 call->state = CHAN_LCR_STATE_CONNECT;
1000 /* request bchannel */
1001 if (!call->bchannel) {
1002 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1003 memset(&newparam, 0, sizeof(union parameter));
1004 newparam.bchannel.type = BCHANNEL_REQUEST;
1005 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1007 /* copy connectinfo */
1008 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1009 /* queue event to asterisk */
1010 if (call->ast && call->pbx_started) {
1014 write(wake_pipe[1], &byte, 1);
1016 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1021 * incoming disconnect from LCR
1023 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1025 struct ast_channel *ast = call->ast;
1027 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1030 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1032 call->cause = param->disconnectinfo.cause;
1033 call->location = param->disconnectinfo.location;
1034 /* if bridge, forward disconnect and return */
1037 if (call->bridge_call) {
1038 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1039 bridge_message_if_bridged(call, message_type, param);
1043 /* release lcr with same cause */
1044 send_release_and_import(call, call->cause, call->location);
1046 /* change to release state */
1047 call->state = CHAN_LCR_STATE_RELEASE;
1048 /* queue release asterisk */
1050 ast->hangupcause = call->cause;
1051 if (call->pbx_started) {
1055 write(wake_pipe[1], &byte, 1);
1057 strcpy(call->queue_string, "H"); // overwrite other indications
1059 ast_hangup(ast); // call will be destroyed here
1065 * incoming release from LCR
1067 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1069 struct ast_channel *ast = call->ast;
1071 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1075 /* change to release state */
1076 call->state = CHAN_LCR_STATE_RELEASE;
1077 /* copy release info */
1079 call->cause = param->disconnectinfo.cause;
1080 call->location = param->disconnectinfo.location;
1082 /* if we have an asterisk instance, queue hangup, else we are done */
1084 ast->hangupcause = call->cause;
1085 if (call->pbx_started) {
1089 write(wake_pipe[1], &byte, 1);
1091 strcpy(call->queue_string, "H");
1093 ast_hangup(ast); // call will be destroyed here
1102 * incoming information from LCR
1104 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1106 struct ast_channel *ast = call->ast;
1108 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1112 /* pbx not started */
1113 if (!call->pbx_started) {
1114 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1115 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1116 lcr_start_pbx(call, ast, param->information.sending_complete);
1120 /* change dailing state after setup */
1121 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1122 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1123 call->state = CHAN_LCR_STATE_IN_DIALING;
1124 // ast_setstate(ast, AST_STATE_DIALING);
1128 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1132 write(wake_pipe[1], &byte, 1);
1134 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1137 /* use bridge to forware message not supported by asterisk */
1138 if (call->state == CHAN_LCR_STATE_CONNECT) {
1139 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1140 bridge_message_if_bridged(call, message_type, param);
1145 * incoming information from LCR
1147 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1149 union parameter newparam;
1151 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1153 /* request bchannel, if call is resumed and we don't have it */
1154 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1155 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1156 memset(&newparam, 0, sizeof(union parameter));
1157 newparam.bchannel.type = BCHANNEL_REQUEST;
1158 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1161 if (!call->ast) return;
1163 /* use bridge to forware message not supported by asterisk */
1164 bridge_message_if_bridged(call, message_type, param);
1168 * incoming information from LCR
1170 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1172 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1174 if (!call->ast) return;
1176 /* use bridge to forware message not supported by asterisk */
1177 bridge_message_if_bridged(call, message_type, param);
1181 * incoming pattern from LCR
1183 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1185 union parameter newparam;
1187 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1189 if (!call->ast) return;
1191 /* pattern are indicated only once */
1192 if (call->has_pattern)
1194 call->has_pattern = 1;
1196 /* request bchannel */
1197 if (!call->bchannel) {
1198 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1199 memset(&newparam, 0, sizeof(union parameter));
1200 newparam.bchannel.type = BCHANNEL_REQUEST;
1201 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1203 /* queue PROGRESS, because tones are available */
1204 if (call->ast && call->pbx_started) {
1208 write(wake_pipe[1], &byte, 1);
1210 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1215 * got dtmf from bchannel (locked state)
1217 void lcr_in_dtmf(struct chan_call *call, int val)
1219 struct ast_channel *ast = call->ast;
1224 if (!call->pbx_started)
1227 if (!call->dsp_dtmf) {
1228 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1232 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1238 write(wake_pipe[1], &byte, 1);
1240 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1244 * message received from LCR
1246 int receive_message(int message_type, unsigned int ref, union parameter *param)
1248 struct bchannel *bchannel;
1249 struct chan_call *call;
1250 union parameter newparam;
1252 memset(&newparam, 0, sizeof(union parameter));
1254 /* handle bchannel message*/
1255 if (message_type == MESSAGE_BCHANNEL) {
1256 switch(param->bchannel.type) {
1257 case BCHANNEL_ASSIGN:
1258 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1259 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1260 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1263 /* create bchannel */
1264 bchannel = alloc_bchannel(param->bchannel.handle);
1266 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1270 /* configure channel */
1271 bchannel->b_tx_gain = param->bchannel.tx_gain;
1272 bchannel->b_rx_gain = param->bchannel.rx_gain;
1273 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1274 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1275 bchannel->b_bf_len = param->bchannel.crypt_len;
1276 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1278 bchannel->b_txdata = 0;
1279 bchannel->b_tx_dejitter = 1;
1281 /* in case, ref is not set, this bchannel instance must
1282 * be created until it is removed again by LCR */
1284 call = find_call_ref(ref);
1286 bchannel->call = call;
1287 call->bchannel = bchannel;
1289 bchannel_dtmf(bchannel, 1);
1291 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1292 if (call->pipeline[0])
1293 bchannel_pipeline(bchannel, call->pipeline);
1295 bchannel_gain(bchannel, call->rx_gain, 0);
1297 bchannel_gain(bchannel, call->tx_gain, 1);
1298 if (call->bridge_id) {
1299 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1300 bchannel_join(bchannel, call->bridge_id);
1302 /* create only, if call exists, othewhise it bchannel is freed below... */
1303 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1304 bchannel_activate(bchannel, 1);
1307 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1308 newparam.bchannel.handle = param->bchannel.handle;
1309 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1310 /* if call has released before bchannel is assigned */
1312 newparam.bchannel.type = BCHANNEL_RELEASE;
1313 newparam.bchannel.handle = param->bchannel.handle;
1314 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1319 case BCHANNEL_REMOVE:
1320 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1321 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1322 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1325 /* unklink from call and destroy bchannel */
1326 free_bchannel(bchannel);
1329 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1330 newparam.bchannel.handle = param->bchannel.handle;
1331 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1336 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1341 /* handle new ref */
1342 if (message_type == MESSAGE_NEWREF) {
1343 if (param->direction) {
1344 /* new ref from lcr */
1345 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1346 if (!ref || find_call_ref(ref)) {
1347 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1350 /* allocate new call instance */
1351 call = alloc_call();
1353 call->state = CHAN_LCR_STATE_IN_PREPARE;
1356 call->ref_was_assigned = 1;
1357 /* set dtmf (default, use option 'n' to disable */
1359 /* wait for setup (or release from asterisk) */
1361 /* new ref, as requested from this remote application */
1362 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1363 call = find_call_ref(0);
1365 /* send release, if ref does not exist */
1366 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1367 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1372 call->ref_was_assigned = 1;
1373 /* set dtmf (default, use option 'n' to disable */
1375 /* send pending setup info */
1376 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1377 send_setup_to_lcr(call);
1378 /* release if asterisk has signed off */
1379 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1382 send_release_and_import(call, call->cause, call->location);
1384 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1395 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1398 call = find_call_ref(ref);
1400 /* ignore ref that is not used (anymore) */
1401 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1405 /* handle messages */
1406 switch(message_type) {
1408 lcr_in_setup(call, message_type, param);
1411 case MESSAGE_OVERLAP:
1412 lcr_in_overlap(call, message_type, param);
1415 case MESSAGE_PROCEEDING:
1416 lcr_in_proceeding(call, message_type, param);
1419 case MESSAGE_ALERTING:
1420 lcr_in_alerting(call, message_type, param);
1423 case MESSAGE_CONNECT:
1424 lcr_in_connect(call, message_type, param);
1427 case MESSAGE_DISCONNECT:
1428 lcr_in_disconnect(call, message_type, param);
1431 case MESSAGE_RELEASE:
1432 lcr_in_release(call, message_type, param);
1435 case MESSAGE_INFORMATION:
1436 lcr_in_information(call, message_type, param);
1439 case MESSAGE_NOTIFY:
1440 lcr_in_notify(call, message_type, param);
1443 case MESSAGE_FACILITY:
1444 lcr_in_facility(call, message_type, param);
1447 case MESSAGE_PATTERN: // audio available from LCR
1448 if (!call->has_pattern)
1449 lcr_in_pattern(call, message_type, param);
1452 case MESSAGE_NOPATTERN: // audio not available from LCR
1455 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1456 call->audiopath = param->audiopath;
1460 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1467 * release all calls (due to broken socket)
1469 static void release_all_calls(void)
1471 struct chan_call *call;
1476 /* no ast, so we may directly free call */
1478 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1482 /* already in release process */
1483 if (call->state == CHAN_LCR_STATE_RELEASE) {
1487 /* release or queue release */
1489 call->state = CHAN_LCR_STATE_RELEASE;
1490 if (!call->pbx_started) {
1491 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1492 ast_hangup(call->ast); // call will be destroyed here
1495 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1499 write(wake_pipe[1], &byte, 1);
1501 strcpy(call->queue_string, "H");
1505 /* release all bchannels */
1506 while(bchannel_first)
1507 free_bchannel(bchannel_first);
1510 void close_socket(void);
1513 * warning! not thread safe
1514 * returns -1 for socket error, 0 for no work, 1 for work
1516 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1519 struct admin_list *admin;
1520 struct admin_message msg;
1522 if ((what & LCR_FD_READ)) {
1523 /* read from socket */
1524 len = read(lcr_sock, &msg, sizeof(msg));
1526 CERROR(NULL, NULL, "Socket closed.\n");
1528 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1530 release_all_calls();
1531 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1535 if (len != sizeof(msg)) {
1536 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1539 if (msg.message != ADMIN_MESSAGE) {
1540 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1543 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1545 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1550 if ((what & LCR_FD_WRITE)) {
1551 /* write to socket */
1553 socket_fd.when &= ~LCR_FD_WRITE;
1556 admin = admin_first;
1557 len = write(lcr_sock, &admin->msg, sizeof(msg));
1559 CERROR(NULL, NULL, "Socket closed.\n");
1563 if (len != sizeof(msg)) {
1564 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1568 admin_first = admin->next;
1572 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1581 * open and close socket and thread
1583 int open_socket(void)
1586 struct sockaddr_un sock_address;
1587 union parameter param;
1590 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1591 CERROR(NULL, NULL, "Failed to create socket.\n");
1595 /* set socket address and name */
1596 memset(&sock_address, 0, sizeof(sock_address));
1597 sock_address.sun_family = PF_UNIX;
1598 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1600 /* connect socket */
1601 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1604 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1608 /* register socket fd */
1609 memset(&socket_fd, 0, sizeof(socket_fd));
1610 socket_fd.fd = lcr_sock;
1611 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1613 /* enque hello message */
1614 memset(¶m, 0, sizeof(param));
1615 strcpy(param.hello.application, "asterisk");
1616 send_message(MESSAGE_HELLO, 0, ¶m);
1621 void close_socket(void)
1623 struct admin_list *admin, *temp;
1625 unregister_fd(&socket_fd);
1627 /* flush pending messages */
1628 admin = admin_first;
1631 admin = admin->next;
1644 /* sending queue to asterisk */
1645 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1649 read(wake_pipe[0], &byte, 1);
1656 static void handle_queue()
1658 struct chan_call *call;
1659 struct ast_channel *ast;
1660 struct ast_frame fr;
1666 p = call->queue_string;
1669 if (ast_channel_trylock(ast)) {
1670 ast_mutex_unlock(&chan_lock);
1672 ast_mutex_lock(&chan_lock);
1678 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1679 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1682 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1683 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1686 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1687 ast_queue_control(ast, AST_CONTROL_RINGING);
1688 ast_setstate(ast, AST_STATE_RINGING);
1691 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1692 ast_queue_control(ast, AST_CONTROL_ANSWER);
1695 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1696 ast_queue_hangup(ast);
1698 case '1': case '2': case '3': case 'A':
1699 case '4': case '5': case '6': case 'B':
1700 case '7': case '8': case '9': case 'C':
1701 case '*': case '0': case '#': case 'D':
1702 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1703 /* send digit to asterisk */
1704 memset(&fr, 0, sizeof(fr));
1706 #ifdef LCR_FOR_ASTERISK
1707 fr.frametype = AST_FRAME_DTMF_BEGIN;
1710 #ifdef LCR_FOR_CALLWEAVER
1711 fr.frametype = AST_FRAME_DTMF;
1715 fr.delivery = ast_tv(0, 0);
1716 ast_queue_frame(ast, &fr);
1718 #ifdef LCR_FOR_ASTERISK
1719 fr.frametype = AST_FRAME_DTMF_END;
1720 ast_queue_frame(ast, &fr);
1725 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1729 call->queue_string[0] = '\0';
1730 ast_channel_unlock(ast);
1736 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1738 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1739 if (open_socket() < 0)
1740 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1745 void lock_chan(void)
1747 ast_mutex_lock(&chan_lock);
1750 void unlock_chan(void)
1752 ast_mutex_unlock(&chan_lock);
1755 /* chan_lcr thread */
1756 static void *chan_thread(void *arg)
1758 if (pipe(wake_pipe) < 0) {
1759 CERROR(NULL, NULL, "Failed to open pipe.\n");
1762 memset(&wake_fd, 0, sizeof(wake_fd));
1763 wake_fd.fd = wake_pipe[0];
1764 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1766 memset(&socket_retry, 0, sizeof(socket_retry));
1767 add_timer(&socket_retry, handle_retry, NULL, 0);
1769 bchannel_pid = getpid();
1771 /* open socket the first time */
1772 handle_retry(NULL, NULL, 0);
1774 ast_mutex_lock(&chan_lock);
1778 select_main(0, &global_change, lock_chan, unlock_chan);
1783 del_timer(&socket_retry);
1785 unregister_fd(&wake_fd);
1786 close(wake_pipe[0]);
1787 close(wake_pipe[1]);
1789 CERROR(NULL, NULL, "Thread exit.\n");
1791 ast_mutex_unlock(&chan_lock);
1797 * new asterisk instance
1800 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1802 char exten[256], *dial, *interface, *opt;
1803 struct ast_channel *ast;
1804 struct chan_call *call;
1806 ast_mutex_lock(&chan_lock);
1807 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1809 /* if socket is closed */
1811 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1812 ast_mutex_unlock(&chan_lock);
1816 /* create call instance */
1817 call = alloc_call();
1819 /* failed to create instance */
1820 ast_mutex_unlock(&chan_lock);
1824 /* create asterisk channel instrance */
1826 #ifdef LCR_FOR_ASTERISK
1827 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1830 #ifdef LCR_FOR_CALLWEAVER
1831 ast = ast_channel_alloc(1);
1835 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1837 /* failed to create instance */
1838 ast_mutex_unlock(&chan_lock);
1841 ast->tech = &lcr_tech;
1842 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1843 /* configure channel */
1844 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1845 ast->readformat = ast->rawreadformat = ast->nativeformats;
1846 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1848 ast->hangupcause = 0;
1852 ast->tech_pvt = call;
1853 ast->fds[0] = call->pipe[0];
1854 call->pbx_started = 0;
1856 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1859 * Extract interface, dialstring, options from data.
1862 * <interface>/<dialstring>
1863 * <interface>/<dialstring>/options
1865 strncpy(exten, (char *)data, sizeof(exten)-1);
1866 exten[sizeof(exten)-1] = '\0';
1867 if ((dial = strchr(exten, '/'))) {
1870 if ((opt = strchr(dial, '/')))
1879 strncpy(call->interface, interface, sizeof(call->interface)-1);
1880 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1881 apply_opt(call, (char *)opt);
1883 ast_mutex_unlock(&chan_lock);
1888 * call from asterisk
1890 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1892 union parameter newparam;
1893 struct chan_call *call;
1895 ast_mutex_lock(&chan_lock);
1896 call = ast->tech_pvt;
1898 #ifdef LCR_FOR_CALLWEAVER
1900 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1904 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1905 ast_mutex_unlock(&chan_lock);
1909 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1911 /* pbx process is started */
1912 call->pbx_started = 1;
1913 /* send MESSAGE_NEWREF */
1914 memset(&newparam, 0, sizeof(union parameter));
1915 newparam.direction = 0; /* request from app */
1916 send_message(MESSAGE_NEWREF, 0, &newparam);
1918 /* set hdlc if capability requires hdlc */
1919 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1920 || ast->transfercapability == INFO_BC_DATARESTRICTED
1921 || ast->transfercapability == INFO_BC_VIDEO)
1923 /* if hdlc is forced by option, we change transcap to data */
1925 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1926 && ast->transfercapability != INFO_BC_DATARESTRICTED
1927 && ast->transfercapability != INFO_BC_VIDEO)
1928 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1930 call->cid_num[0] = 0;
1931 call->cid_name[0] = 0;
1932 call->cid_rdnis[0] = 0;
1934 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1935 strncpy(call->cid_num, ast->cid.cid_num,
1936 sizeof(call->cid_num)-1);
1938 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1939 strncpy(call->cid_name, ast->cid.cid_name,
1940 sizeof(call->cid_name)-1);
1941 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1942 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1943 sizeof(call->cid_rdnis)-1);
1945 ast_mutex_unlock(&chan_lock);
1949 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1951 static const char* dtmf_tones[] = {
1952 "!941+1336/100,!0/100", /* 0 */
1953 "!697+1209/100,!0/100", /* 1 */
1954 "!697+1336/100,!0/100", /* 2 */
1955 "!697+1477/100,!0/100", /* 3 */
1956 "!770+1209/100,!0/100", /* 4 */
1957 "!770+1336/100,!0/100", /* 5 */
1958 "!770+1477/100,!0/100", /* 6 */
1959 "!852+1209/100,!0/100", /* 7 */
1960 "!852+1336/100,!0/100", /* 8 */
1961 "!852+1477/100,!0/100", /* 9 */
1962 "!697+1633/100,!0/100", /* A */
1963 "!770+1633/100,!0/100", /* B */
1964 "!852+1633/100,!0/100", /* C */
1965 "!941+1633/100,!0/100", /* D */
1966 "!941+1209/100,!0/100", /* * */
1967 "!941+1477/100,!0/100" }; /* # */
1969 if (digit >= '0' && digit <='9')
1970 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1971 else if (digit >= 'A' && digit <= 'D')
1972 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1973 else if (digit == '*')
1974 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1975 else if (digit == '#')
1976 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1979 CDEBUG(NULL, ast, "Unable to handle DTMF tone "
1980 "'%c' for '%s'\n", digit, ast->name);
1984 #ifdef LCR_FOR_ASTERISK
1985 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1987 #ifdef LCR_FOR_CALLWEAVER
1988 static int lcr_digit(struct ast_channel *ast, char digit)
1991 struct chan_call *call;
1992 union parameter newparam;
1995 #ifdef LCR_FOR_CALLWEAVER
1996 int inband_dtmf = 0;
1999 /* only pass IA5 number space */
2000 if (digit > 126 || digit < 32)
2003 ast_mutex_lock(&chan_lock);
2004 call = ast->tech_pvt;
2006 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2007 ast_mutex_unlock(&chan_lock);
2011 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2013 /* send information or queue them */
2014 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2015 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2016 memset(&newparam, 0, sizeof(union parameter));
2018 newparam.information.keypad[0] = digit;
2019 newparam.information.keypad[1] = '\0';
2021 newparam.information.id[0] = digit;
2022 newparam.information.id[1] = '\0';
2024 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2027 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2028 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2030 strncat(call->dialque, buf, strlen(call->dialque)-1);
2033 ast_mutex_unlock(&chan_lock);
2035 #ifdef LCR_FOR_ASTERISK
2039 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2041 int inband_dtmf = 0;
2042 struct chan_call *call;
2045 ast_mutex_lock(&chan_lock);
2047 call = ast->tech_pvt;
2051 "Received digit from Asterisk, "
2052 "but no call instance exists.\n");
2053 ast_mutex_unlock(&chan_lock);
2057 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2059 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2063 ast_mutex_unlock(&chan_lock);
2066 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2067 send_digit_to_chan(ast, digit);
2073 static int lcr_answer(struct ast_channel *ast)
2075 union parameter newparam;
2076 struct chan_call *call;
2078 ast_mutex_lock(&chan_lock);
2079 call = ast->tech_pvt;
2081 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2082 ast_mutex_unlock(&chan_lock);
2086 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2088 /* copy connectinfo, if bridged */
2089 if (call->bridge_call)
2090 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2091 /* send connect message to lcr */
2092 if (call->state != CHAN_LCR_STATE_CONNECT) {
2093 memset(&newparam, 0, sizeof(union parameter));
2094 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2095 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2096 call->state = CHAN_LCR_STATE_CONNECT;
2099 /* request bchannel */
2100 if (!call->bchannel) {
2101 CDEBUG(call, ast, "Requesting B-channel.\n");
2102 memset(&newparam, 0, sizeof(union parameter));
2103 newparam.bchannel.type = BCHANNEL_REQUEST;
2104 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2107 // memset(&newparam, 0, sizeof(union parameter));
2108 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2110 ast_mutex_unlock(&chan_lock);
2114 static int lcr_hangup(struct ast_channel *ast)
2116 struct chan_call *call;
2117 pthread_t tid = pthread_self();
2119 if (!pthread_equal(tid, chan_tid)) {
2120 ast_mutex_lock(&chan_lock);
2122 call = ast->tech_pvt;
2124 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2125 if (!pthread_equal(tid, chan_tid)) {
2126 ast_mutex_unlock(&chan_lock);
2131 if (!pthread_equal(tid, chan_tid))
2132 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2134 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2136 /* disconnect asterisk, maybe not required */
2137 ast->tech_pvt = NULL;
2141 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2142 if (ast->hangupcause > 0)
2143 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2145 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2148 if (!pthread_equal(tid, chan_tid)) {
2149 ast_mutex_unlock(&chan_lock);
2153 /* ref is not set, due to prepare setup or release */
2154 if (call->state == CHAN_LCR_STATE_RELEASE) {
2155 /* we get the response to our release */
2156 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2159 /* during prepare, we change to release state */
2160 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2161 call->state = CHAN_LCR_STATE_RELEASE;
2165 if (!pthread_equal(tid, chan_tid)) {
2166 ast_mutex_unlock(&chan_lock);
2171 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2173 struct chan_call *call;
2176 CDEBUG(NULL, ast, "No subclass\n");
2177 if (!(f->subclass & ast->nativeformats))
2178 CDEBUG(NULL, ast, "Unexpected format.\n");
2180 ast_mutex_lock(&chan_lock);
2181 call = ast->tech_pvt;
2183 ast_mutex_unlock(&chan_lock);
2186 if (call->bchannel && f->samples)
2187 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2188 ast_mutex_unlock(&chan_lock);
2193 static struct ast_frame *lcr_read(struct ast_channel *ast)
2195 struct chan_call *call;
2198 ast_mutex_lock(&chan_lock);
2199 call = ast->tech_pvt;
2201 ast_mutex_unlock(&chan_lock);
2204 if (call->pipe[0] > -1) {
2205 if (call->rebuffer && !call->hdlc) {
2206 /* Make sure we have a complete 20ms (160byte) frame */
2207 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2209 call->framepos += len;
2212 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2214 if (len < 0 && errno == EAGAIN) {
2215 ast_mutex_unlock(&chan_lock);
2217 #ifdef LCR_FOR_ASTERISK
2218 return &ast_null_frame;
2221 #ifdef LCR_FOR_CALLWEAVER
2227 close(call->pipe[0]);
2230 ast_mutex_unlock(&chan_lock);
2232 } else if (call->rebuffer && call->framepos < 160) {
2233 /* Not a complete frame, so we send a null-frame */
2234 ast_mutex_unlock(&chan_lock);
2235 return &ast_null_frame;
2239 call->read_fr.frametype = AST_FRAME_VOICE;
2240 call->read_fr.subclass = ast->nativeformats;
2241 if (call->rebuffer) {
2242 call->read_fr.datalen = call->framepos;
2243 call->read_fr.samples = call->framepos;
2246 call->read_fr.datalen = len;
2247 call->read_fr.samples = len;
2249 call->read_fr.delivery = ast_tv(0,0);
2250 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2251 ast_mutex_unlock(&chan_lock);
2253 return &call->read_fr;
2256 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2258 union parameter newparam;
2260 struct chan_call *call;
2261 const struct tone_zone_sound *ts = NULL;
2263 ast_mutex_lock(&chan_lock);
2264 call = ast->tech_pvt;
2266 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2267 ast_mutex_unlock(&chan_lock);
2272 case AST_CONTROL_BUSY:
2273 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2274 ast_setstate(ast, AST_STATE_BUSY);
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 = 17;
2279 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2280 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2282 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2284 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2285 ts = ast_get_indication_tone(ast->zone, "busy");
2288 case AST_CONTROL_CONGESTION:
2289 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2290 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2291 /* send message to lcr */
2292 memset(&newparam, 0, sizeof(union parameter));
2293 newparam.disconnectinfo.cause = ast->hangupcause;
2294 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2295 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2297 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2299 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2300 ts = ast_get_indication_tone(ast->zone, "congestion");
2303 case AST_CONTROL_PROCEEDING:
2304 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2305 if (call->state == CHAN_LCR_STATE_IN_SETUP
2306 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2307 /* send message to lcr */
2308 memset(&newparam, 0, sizeof(union parameter));
2309 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2311 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2314 case AST_CONTROL_RINGING:
2315 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2316 ast_setstate(ast, AST_STATE_RING);
2317 if (call->state == CHAN_LCR_STATE_IN_SETUP
2318 || call->state == CHAN_LCR_STATE_IN_DIALING
2319 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2320 /* send message to lcr */
2321 memset(&newparam, 0, sizeof(union parameter));
2322 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2324 call->state = CHAN_LCR_STATE_IN_ALERTING;
2326 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2327 ts = ast_get_indication_tone(ast->zone, "ring");
2330 case AST_CONTROL_PROGRESS:
2331 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2332 /* request bchannel */
2333 if (!call->bchannel) {
2334 CDEBUG(call, ast, "Requesting B-channel.\n");
2335 memset(&newparam, 0, sizeof(union parameter));
2336 newparam.bchannel.type = BCHANNEL_REQUEST;
2337 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2341 CDEBUG(call, ast, "Received indicate -1.\n");
2342 ast_playtones_stop(ast);
2346 case AST_CONTROL_VIDUPDATE:
2347 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2350 case AST_CONTROL_HOLD:
2351 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2352 /* send message to lcr */
2353 memset(&newparam, 0, sizeof(union parameter));
2354 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2355 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2357 /*start music onhold*/
2358 #ifdef LCR_FOR_ASTERISK
2359 ast_moh_start(ast,data,ast->musicclass);
2362 #ifdef LCR_FOR_CALLWEAVER
2363 ast_moh_start(ast, NULL);
2368 case AST_CONTROL_UNHOLD:
2369 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2370 /* send message to lcr */
2371 memset(&newparam, 0, sizeof(union parameter));
2372 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2373 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2379 #ifdef AST_CONTROL_SRCUPDATE
2380 case AST_CONTROL_SRCUPDATE:
2384 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2387 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2392 if (ts && ts->data[0]) {
2393 ast_playtones_start(ast, 0, ts->data, 1);
2397 ast_mutex_unlock(&chan_lock);
2404 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2406 struct chan_call *call;
2412 ast_mutex_lock(&chan_lock);
2413 call = ast->tech_pvt;
2415 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2416 ast_mutex_unlock(&chan_lock);
2420 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2422 ast_mutex_unlock(&chan_lock);
2427 * send_text asterisk
2429 static int lcr_send_text(struct ast_channel *ast, const char *text)
2431 struct chan_call *call;
2432 union parameter newparam;
2434 ast_mutex_lock(&chan_lock);
2435 call = ast->tech_pvt;
2437 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2438 ast_mutex_unlock(&chan_lock);
2442 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2443 memset(&newparam, 0, sizeof(union parameter));
2444 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2445 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2446 ast_mutex_unlock(&chan_lock);
2453 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2454 struct ast_channel *ast2, int flags,
2455 struct ast_frame **fo,
2456 struct ast_channel **rc, int timeoutms)
2459 struct chan_call *call1, *call2;
2460 struct ast_channel *carr[2], *who;
2462 struct ast_frame *f;
2465 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2470 /* join via dsp (if the channels are currently open) */
2471 ast_mutex_lock(&chan_lock);
2472 call1 = ast1->tech_pvt;
2473 call2 = ast2->tech_pvt;
2474 if (!call1 || !call2) {
2475 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2476 ast_mutex_unlock(&chan_lock);
2477 return AST_BRIDGE_COMPLETE;
2480 /* join, if both call instances uses dsp
2481 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2483 if (!call1->nodsp && !call2->nodsp) {
2484 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2486 /* get bridge id and join */
2487 bridge_id = new_bridge_id();
2489 call1->bridge_id = bridge_id;
2490 if (call1->bchannel)
2491 bchannel_join(call1->bchannel, bridge_id);
2493 call2->bridge_id = bridge_id;
2494 if (call2->bchannel)
2495 bchannel_join(call2->bchannel, bridge_id);
2497 if (call1->nodsp && call2->nodsp)
2498 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2500 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2501 call1->bridge_call = call2;
2502 call2->bridge_call = call1;
2504 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2505 || call1->state == CHAN_LCR_STATE_IN_DIALING
2506 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2507 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2508 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2511 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2512 || call2->state == CHAN_LCR_STATE_IN_DIALING
2513 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2514 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2515 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2519 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2520 so let's do it for them. Hmpf.
2523 if (call1->on_hold) {
2524 union parameter newparam;
2526 memset(&newparam, 0, sizeof(union parameter));
2527 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2528 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2533 if (call2->on_hold) {
2534 union parameter newparam;
2536 memset(&newparam, 0, sizeof(union parameter));
2537 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2538 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2543 ast_mutex_unlock(&chan_lock);
2547 who = ast_waitfor_n(carr, 2, &to);
2550 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2555 if (!f || f->frametype == AST_FRAME_CONTROL) {
2557 CDEBUG(NULL, NULL, "Got hangup.\n");
2559 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2566 if ( f->frametype == AST_FRAME_DTMF ) {
2567 CDEBUG(NULL, NULL, "Got DTMF.\n");
2583 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2585 /* split channels */
2586 ast_mutex_lock(&chan_lock);
2587 call1 = ast1->tech_pvt;
2588 call2 = ast2->tech_pvt;
2589 if (call1 && call1->bridge_id) {
2590 call1->bridge_id = 0;
2591 if (call1->bchannel)
2592 bchannel_join(call1->bchannel, 0);
2593 if (call1->bridge_call)
2594 call1->bridge_call->bridge_call = NULL;
2596 if (call2 && call1->bridge_id) {
2597 call2->bridge_id = 0;
2598 if (call2->bchannel)
2599 bchannel_join(call2->bchannel, 0);
2600 if (call2->bridge_call)
2601 call2->bridge_call->bridge_call = NULL;
2603 call1->bridge_call = NULL;
2604 call2->bridge_call = NULL;
2606 ast_mutex_unlock(&chan_lock);
2607 return AST_BRIDGE_COMPLETE;
2609 static struct ast_channel_tech lcr_tech = {
2611 .description = "Channel driver for connecting to Linux-Call-Router",
2612 .capabilities = AST_FORMAT_ALAW,
2613 .requester = lcr_request,
2615 #ifdef LCR_FOR_ASTERISK
2616 .send_digit_begin = lcr_digit_begin,
2617 .send_digit_end = lcr_digit_end,
2620 #ifdef LCR_FOR_CALLWEAVER
2621 .send_digit = lcr_digit,
2625 .bridge = lcr_bridge,
2626 .hangup = lcr_hangup,
2627 .answer = lcr_answer,
2630 .indicate = lcr_indicate,
2632 .send_text = lcr_send_text,
2641 static int lcr_show_lcr (int fd, int argc, char *argv[])
2646 static int lcr_show_calls (int fd, int argc, char *argv[])
2651 static int lcr_reload_routing (int fd, int argc, char *argv[])
2656 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2661 static int lcr_port_block (int fd, int argc, char *argv[])
2666 static int lcr_port_unblock (int fd, int argc, char *argv[])
2671 static int lcr_port_unload (int fd, int argc, char *argv[])
2676 static struct ast_cli_entry cli_show_lcr =
2677 { {"lcr", "show", "lcr", NULL},
2679 "Shows current states of LCR core",
2680 "Usage: lcr show lcr\n",
2683 static struct ast_cli_entry cli_show_calls =
2684 { {"lcr", "show", "calls", NULL},
2686 "Shows current calls made by LCR and Asterisk",
2687 "Usage: lcr show calls\n",
2690 static struct ast_cli_entry cli_reload_routing =
2691 { {"lcr", "reload", "routing", NULL},
2693 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2694 "Usage: lcr reload routing\n",
2697 static struct ast_cli_entry cli_reload_interfaces =
2698 { {"lcr", "reload", "interfaces", NULL},
2699 lcr_reload_interfaces,
2700 "Reloads interfaces conf of LCR",
2701 "Usage: lcr reload interfaces\n",
2704 static struct ast_cli_entry cli_port_block =
2705 { {"lcr", "port", "block", NULL},
2707 "Blocks LCR port for further calls",
2708 "Usage: lcr port block \"<port>\"\n",
2711 static struct ast_cli_entry cli_port_unblock =
2712 { {"lcr", "port", "unblock", NULL},
2714 "Unblocks or loads LCR port, port is opened my mISDN",
2715 "Usage: lcr port unblock \"<port>\"\n",
2718 static struct ast_cli_entry cli_port_unload =
2719 { {"lcr", "port", "unload", NULL},
2721 "Unloads LCR port, port is closes by mISDN",
2722 "Usage: lcr port unload \"<port>\"\n",
2727 #ifdef LCR_FOR_ASTERISK
2728 static int lcr_config_exec(struct ast_channel *ast, void *data)
2731 #ifdef LCR_FOR_CALLWEAVER
2732 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2735 struct chan_call *call;
2737 ast_mutex_lock(&chan_lock);
2739 #ifdef LCR_FOR_ASTERISK
2740 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2743 #ifdef LCR_FOR_CALLWEAVER
2744 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2750 if (call->ast == ast)
2756 #ifdef LCR_FOR_ASTERISK
2757 apply_opt(call, (char *)data);
2760 #ifdef LCR_FOR_CALLWEAVER
2761 apply_opt(call, (char *)argv[0]);
2765 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2767 ast_mutex_unlock(&chan_lock);
2772 * module loading and destruction
2774 int load_module(void)
2777 char options_error[256];
2779 for (i = 0; i < 256; i++) {
2780 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2781 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2784 if (read_options(options_error) == 0) {
2785 CERROR(NULL, NULL, "%s", options_error);
2787 #ifdef LCR_FOR_ASTERISK
2788 return AST_MODULE_LOAD_DECLINE;
2791 #ifdef LCR_FOR_CALLWEAVER
2797 ast_mutex_init(&chan_lock);
2798 ast_mutex_init(&log_lock);
2800 if (bchannel_initialize()) {
2801 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2804 #ifdef LCR_FOR_ASTERISK
2805 return AST_MODULE_LOAD_DECLINE;
2808 #ifdef LCR_FOR_CALLWEAVER
2814 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2815 if (ast_channel_register(&lcr_tech)) {
2816 CERROR(NULL, NULL, "Unable to register channel class\n");
2817 bchannel_deinitialize();
2820 #ifdef LCR_FOR_ASTERISK
2821 return AST_MODULE_LOAD_DECLINE;
2824 #ifdef LCR_FOR_CALLWEAVER
2829 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2831 #ifdef LCR_FOR_ASTERISK
2832 "lcr_config(<opt><optarg>:<opt>:...)\n"
2835 #ifdef LCR_FOR_CALLWEAVER
2836 "lcr_config(<opt><optarg>:<opt>:...)\n",
2839 "Sets LCR opts. and optargs\n"
2841 "The available options are:\n"
2842 " d - Send display text on called phone, text is the optarg.\n"
2843 " n - Don't detect dtmf tones on called channel.\n"
2844 " h - Force data call (HDLC).\n"
2845 " t - Disable mISDN_dsp features (required for fax application).\n"
2846 " q - Add queue to make fax stream seamless (required for fax app).\n"
2847 " Use queue size in miliseconds for optarg. (try 250)\n"
2848 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2849 " Use time to detect for optarg.\n"
2850 " c - Make crypted outgoing call, optarg is keyindex.\n"
2851 " e - Perform echo cancelation on this channel.\n"
2852 " Takes mISDN pipeline option as optarg.\n"
2853 " s - Send Non Inband DTMF as inband.\n"
2854 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2855 " vr - rxgain control\n"
2856 " vt - txgain control\n"
2857 " Volume changes at factor 2 ^ optarg.\n"
2858 " k - use keypad to dial this call.\n"
2860 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2861 " -> use 16 for fax (3.1k audio)\n"
2863 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2864 "options: \"n:t:q250\" for seamless audio transmission.\n"
2869 ast_cli_register(&cli_show_lcr);
2870 ast_cli_register(&cli_show_calls);
2871 ast_cli_register(&cli_reload_routing);
2872 ast_cli_register(&cli_reload_interfaces);
2873 ast_cli_register(&cli_port_block);
2874 ast_cli_register(&cli_port_unblock);
2875 ast_cli_register(&cli_port_unload);
2879 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2880 /* failed to create thread */
2881 bchannel_deinitialize();
2883 ast_channel_unregister(&lcr_tech);
2885 #ifdef LCR_FOR_ASTERISK
2886 return AST_MODULE_LOAD_DECLINE;
2889 #ifdef LCR_FOR_CALLWEAVER
2897 int unload_module(void)
2899 /* First, take us out of the channel loop */
2900 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2903 pthread_join(chan_tid, NULL);
2905 ast_channel_unregister(&lcr_tech);
2907 ast_unregister_application("lcr_config");
2910 if (mISDN_created) {
2911 bchannel_deinitialize();
2915 if (lcr_sock >= 0) {
2923 int reload_module(void)
2929 #ifdef LCR_FOR_ASTERISK
2930 #define AST_MODULE "chan_lcr"
2933 #ifdef LCR_FOR_CALLWEAVER
2938 ast_mutex_lock(&usecnt_lock);
2940 ast_mutex_unlock(&usecnt_lock);
2945 #ifdef LCR_FOR_ASTERISK
2946 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2947 .load = load_module,
2948 .unload = unload_module,
2949 .reload = reload_module,
2953 #ifdef LCR_FOR_CALLWEAVER
2954 char *description(void)