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);
250 printf("[call=%s ast=%s] %s", call_text, ast_text, buffer);
252 ast_mutex_unlock(&log_lock);
256 * channel and call instances
258 struct chan_call *call_first;
262 * special case: 0: find new ref, that has not been assigned a ref yet
265 struct chan_call *find_call_ref(unsigned int ref)
267 struct chan_call *call = call_first;
268 int assigned = (ref > 0);
271 if (call->ref == ref && call->ref_was_assigned == assigned)
278 void free_call(struct chan_call *call)
280 struct chan_call **temp = &call_first;
284 *temp = (*temp)->next;
285 if (call->pipe[0] > -1)
286 close(call->pipe[0]);
287 if (call->pipe[1] > -1)
288 close(call->pipe[1]);
289 if (call->bchannel) {
290 if (call->bchannel->call != call)
291 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
292 call->bchannel->call = NULL;
294 if (call->bridge_call) {
295 if (call->bridge_call->bridge_call != call)
296 CERROR(call, NULL, "Linked call structure has no link to us.\n");
297 call->bridge_call->bridge_call = NULL;
300 ast_translator_free_path(call->trans);
302 ast_dsp_free(call->dsp);
303 CDEBUG(call, NULL, "Call instance freed.\n");
308 temp = &((*temp)->next);
310 CERROR(call, NULL, "Call instance not found in list.\n");
313 struct chan_call *alloc_call(void)
315 struct chan_call **callp = &call_first;
318 callp = &((*callp)->next);
320 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
322 memset(*callp, 0, sizeof(struct chan_call));
323 if (pipe((*callp)->pipe) < 0) {
324 CERROR(*callp, NULL, "Failed to create pipe.\n");
328 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
329 CDEBUG(*callp, NULL, "Call instance allocated.\n");
333 unsigned short new_bridge_id(void)
335 struct chan_call *call;
336 unsigned short id = 1;
338 /* search for lowest bridge id that is not in use and not 0 */
342 if (call->bridge_id == id)
350 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
355 * enque message to LCR
357 int send_message(int message_type, unsigned int ref, union parameter *param)
359 struct admin_list *admin, **adminp;
362 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
365 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
367 adminp = &admin_first;
369 adminp = &((*adminp)->next);
370 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
372 CERROR(NULL, NULL, "No memory for message to LCR.\n");
377 admin->msg.message = ADMIN_MESSAGE;
378 admin->msg.u.msg.type = message_type;
379 admin->msg.u.msg.ref = ref;
380 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
381 socket_fd.when |= LCR_FD_WRITE;
385 write(wake_pipe[1], &byte, 1);
392 * apply options (in locked state)
394 void apply_opt(struct chan_call *call, char *data)
396 union parameter newparam;
397 char string[1024], *p = string, *opt, *key;
403 strncpy(string, data, sizeof(string)-1);
404 string[sizeof(string)-1] = '\0';
407 while((opt = strsep(&p, ":"))) {
410 if (opt[1] == '\0') {
411 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
414 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
415 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
416 strncpy(call->display, opt+1, sizeof(call->display)-1);
418 memset(&newparam, 0, sizeof(union parameter));
419 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
420 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
424 if (opt[1] != '\0') {
425 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
428 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
429 if (call->dsp_dtmf) {
432 bchannel_dtmf(call->bchannel, 0);
436 if (opt[1] == '\0') {
437 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
441 /* check for 0xXXXX... type of key */
442 if (!!strncmp((char *)key, "0x", 2)) {
443 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
447 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
448 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
453 if (*key>='0' && *key<='9')
454 call->bf_key[i] = (*key-'0') << 8;
455 else if (*key>='a' && *key<='f')
456 call->bf_key[i] = (*key-'a'+10) << 8;
457 else if (*key>='A' && *key<='F')
458 call->bf_key[i] = (*key-'A'+10) << 8;
462 if (*key>='0' && *key<='9')
463 call->bf_key[i] += (*key - '0');
464 else if (*key>='a' && *key<='f')
465 call->bf_key[i] += (*key - 'a' + 10);
466 else if (*key>='A' && *key<='F')
467 call->bf_key[i] += (*key - 'A' + 10);
474 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
478 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
480 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
483 if (opt[1] != '\0') {
484 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
487 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
492 if (opt[1] != '\0') {
493 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
496 CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
501 if (opt[1] == '\0') {
502 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
505 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
506 call->nodsp_queue = atoi(opt+1);
509 if (opt[1] == '\0') {
510 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
513 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
514 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
516 bchannel_pipeline(call->bchannel, call->pipeline);
519 if (opt[1] == '\0') {
520 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
523 call->faxdetect=atoi(opt+1);
525 call->dsp=ast_dsp_new();
527 #ifdef LCR_FOR_CALLWEAVER
528 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
530 #ifdef LCR_FOR_ASTERISK
531 #ifdef DSP_FEATURE_DTMF_DETECT
532 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
534 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
539 #ifdef LCR_FOR_CALLWEAVER
540 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
542 #ifdef LCR_FOR_ASTERISK
543 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
546 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
549 if (opt[1] != '\0') {
550 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
553 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
558 if (opt[1] != '\0') {
559 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
562 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
563 call->inband_dtmf = 1;
566 if (opt[1] != 'r' && opt[1] != 't') {
567 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
571 if (gain < -8 || gain >8) {
572 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
575 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
577 call->rx_gain = gain;
579 bchannel_gain(call->bchannel, call->rx_gain, 0);
581 call->tx_gain = gain;
583 bchannel_gain(call->bchannel, call->tx_gain, 1);
587 if (opt[1] != '\0') {
588 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
591 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
596 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
600 /* re-open, if bchannel is created */
601 if (call->bchannel && call->bchannel->b_sock > -1) {
602 bchannel_destroy(call->bchannel);
603 if (bchannel_create(call->bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
604 bchannel_activate(call->bchannel, 1);
609 * send setup info to LCR
610 * this function is called, when asterisk call is received and ref is received
612 static void send_setup_to_lcr(struct chan_call *call)
614 union parameter newparam;
615 struct ast_channel *ast = call->ast;
618 if (!call->ast || !call->ref)
621 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
623 /* send setup message to LCR */
624 memset(&newparam, 0, sizeof(union parameter));
625 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
626 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
628 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
630 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
631 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
632 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
633 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
634 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
635 call->display[0] = '\0';
636 if (call->cid_num[0])
637 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
638 if (call->cid_name[0])
639 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
640 if (call->cid_rdnis[0]) {
641 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
642 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
643 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
645 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
646 case AST_PRES_RESTRICTED:
647 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
649 case AST_PRES_UNAVAILABLE:
650 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
652 case AST_PRES_ALLOWED:
654 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
656 switch(ast->cid.cid_ton) {
658 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
661 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
664 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
667 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
669 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
670 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
672 // ast->transfercapability = atoi(tmp);
673 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
674 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
676 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
678 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
679 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
681 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
682 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
683 send_message(MESSAGE_SETUP, call->ref, &newparam);
685 /* change to outgoing setup state */
686 call->state = CHAN_LCR_STATE_OUT_SETUP;
690 * send dialing info to LCR
691 * this function is called, when setup acknowledge is received and dialing
694 static void send_dialque_to_lcr(struct chan_call *call)
696 union parameter newparam;
698 if (!call->ast || !call->ref || !call->dialque[0])
701 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
703 /* send setup message to LCR */
704 memset(&newparam, 0, sizeof(union parameter));
706 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
708 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
709 call->dialque[0] = '\0';
710 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
714 * in case of a bridge, the unsupported message can be forwarded directly
715 * to the remote call.
717 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
721 if (!call->bridge_call) return;
722 CDEBUG(call, NULL, "Sending message due bridging.\n");
723 send_message(message_type, call->bridge_call->ref, param);
727 * send release message to LCR and import bchannel if exported
729 static void send_release_and_import(struct chan_call *call, int cause, int location)
731 union parameter newparam;
733 /* importing channel */
734 if (call->bchannel) {
735 memset(&newparam, 0, sizeof(union parameter));
736 newparam.bchannel.type = BCHANNEL_RELEASE;
737 newparam.bchannel.handle = call->bchannel->handle;
738 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
740 /* sending release */
741 memset(&newparam, 0, sizeof(union parameter));
742 newparam.disconnectinfo.cause = cause;
743 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
744 send_message(MESSAGE_RELEASE, call->ref, &newparam);
748 * check if extension matches and start asterisk
749 * if it can match, proceed
752 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
755 union parameter newparam;
756 char *exten = ast->exten;
760 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
764 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
765 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
769 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
770 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);
774 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
775 /* send setup acknowledge to lcr */
776 memset(&newparam, 0, sizeof(union parameter));
777 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
780 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
785 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
786 /* send setup acknowledge to lcr */
787 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
788 memset(&newparam, 0, sizeof(union parameter));
789 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
793 call->state = CHAN_LCR_STATE_IN_DIALING;
795 /* if match, start pbx */
796 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
797 CDEBUG(call, ast, "Extensions matches.\n");
802 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
808 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
816 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
817 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
819 /* release asterisk */
820 ast->hangupcause = call->cause;
821 /* change to release state */
822 call->state = CHAN_LCR_STATE_RELEASE;
823 ast_hangup(ast); // call will be destroyed here
827 /* send setup to asterisk */
828 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
830 #ifdef LCR_FOR_CALLWEAVER
832 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
835 ret = ast_pbx_start(ast);
837 cause = (ret==-2)?34:27;
840 call->pbx_started = 1;
841 ast_setstate(ast, AST_STATE_RING);
845 * incoming setup from LCR
847 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
849 struct ast_channel *ast;
851 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
853 /* create asterisk channel instrance */
855 #ifdef LCR_FOR_CALLWEAVER
856 ast = ast_channel_alloc(1);
859 #ifdef LCR_FOR_ASTERISK
860 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
865 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
866 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
873 ast->tech_pvt = call;
874 ast->tech = &lcr_tech;
875 ast->fds[0] = call->pipe[0];
877 /* fill setup information */
878 if (param->setup.dialinginfo.id)
879 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
880 if (param->setup.context[0])
881 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
883 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
884 memset(&ast->cid, 0, sizeof(ast->cid));
885 if (param->setup.callerinfo.id[0])
886 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
887 if (param->setup.callerinfo.id2[0])
888 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
889 if (param->setup.callerinfo.name[0])
890 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
891 if (param->setup.redirinfo.id[0])
892 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
893 switch (param->setup.callerinfo.present) {
894 case INFO_PRESENT_ALLOWED:
895 ast->cid.cid_pres = AST_PRES_ALLOWED;
897 case INFO_PRESENT_RESTRICTED:
898 ast->cid.cid_pres = AST_PRES_RESTRICTED;
901 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
903 switch (param->setup.callerinfo.ntype) {
904 case INFO_NTYPE_SUBSCRIBER:
905 ast->cid.cid_ton = 4;
907 case INFO_NTYPE_NATIONAL:
908 ast->cid.cid_ton = 2;
910 case INFO_NTYPE_INTERNATIONAL:
911 ast->cid.cid_ton = 1;
914 ast->cid.cid_ton = 0;
916 ast->transfercapability = param->setup.capainfo.bearer_capa;
917 /* enable hdlc if transcap is data */
918 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
920 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
922 /* configure channel */
923 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
924 ast->readformat = ast->rawreadformat = ast->nativeformats;
925 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
927 ast->hangupcause = 0;
930 call->state = CHAN_LCR_STATE_IN_SETUP;
932 if (!call->pbx_started)
933 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
937 * incoming setup acknowledge from LCR
939 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
941 if (!call->ast) return;
943 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
945 /* send pending digits in dialque */
946 if (call->dialque[0])
947 send_dialque_to_lcr(call);
948 /* change to overlap state */
949 call->state = CHAN_LCR_STATE_OUT_DIALING;
953 * incoming proceeding from LCR
955 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
957 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
960 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
961 /* queue event for asterisk */
962 if (call->ast && call->pbx_started) {
966 write(wake_pipe[1], &byte, 1);
968 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
974 * incoming alerting from LCR
976 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
978 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
981 call->state = CHAN_LCR_STATE_OUT_ALERTING;
982 /* queue event to asterisk */
983 if (call->ast && call->pbx_started) {
987 write(wake_pipe[1], &byte, 1);
989 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
994 * incoming connect from LCR
996 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
998 union parameter newparam;
1000 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1003 call->state = CHAN_LCR_STATE_CONNECT;
1004 /* request bchannel */
1005 if (!call->bchannel) {
1006 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1007 memset(&newparam, 0, sizeof(union parameter));
1008 newparam.bchannel.type = BCHANNEL_REQUEST;
1009 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1011 /* copy connectinfo */
1012 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1013 /* queue event to asterisk */
1014 if (call->ast && call->pbx_started) {
1018 write(wake_pipe[1], &byte, 1);
1020 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1025 * incoming disconnect from LCR
1027 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1029 struct ast_channel *ast = call->ast;
1031 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1034 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1036 call->cause = param->disconnectinfo.cause;
1037 call->location = param->disconnectinfo.location;
1038 /* if bridge, forward disconnect and return */
1041 if (call->bridge_call) {
1042 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1043 bridge_message_if_bridged(call, message_type, param);
1047 /* release lcr with same cause */
1048 send_release_and_import(call, call->cause, call->location);
1050 /* change to release state */
1051 call->state = CHAN_LCR_STATE_RELEASE;
1052 /* queue release asterisk */
1054 ast->hangupcause = call->cause;
1055 if (call->pbx_started) {
1059 write(wake_pipe[1], &byte, 1);
1061 strcpy(call->queue_string, "H"); // overwrite other indications
1063 ast_hangup(ast); // call will be destroyed here
1069 * incoming release from LCR
1071 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1073 struct ast_channel *ast = call->ast;
1075 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1079 /* change to release state */
1080 call->state = CHAN_LCR_STATE_RELEASE;
1081 /* copy release info */
1083 call->cause = param->disconnectinfo.cause;
1084 call->location = param->disconnectinfo.location;
1086 /* if we have an asterisk instance, queue hangup, else we are done */
1088 ast->hangupcause = call->cause;
1089 if (call->pbx_started) {
1093 write(wake_pipe[1], &byte, 1);
1095 strcpy(call->queue_string, "H");
1097 ast_hangup(ast); // call will be destroyed here
1106 * incoming information from LCR
1108 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1110 struct ast_channel *ast = call->ast;
1112 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1116 /* pbx not started */
1117 if (!call->pbx_started) {
1118 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1119 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1120 lcr_start_pbx(call, ast, param->information.sending_complete);
1124 /* change dailing state after setup */
1125 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1126 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1127 call->state = CHAN_LCR_STATE_IN_DIALING;
1128 // ast_setstate(ast, AST_STATE_DIALING);
1132 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1136 write(wake_pipe[1], &byte, 1);
1138 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1141 /* use bridge to forware message not supported by asterisk */
1142 if (call->state == CHAN_LCR_STATE_CONNECT) {
1143 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1144 bridge_message_if_bridged(call, message_type, param);
1149 * incoming information from LCR
1151 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1153 union parameter newparam;
1155 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1157 /* request bchannel, if call is resumed and we don't have it */
1158 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1159 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1160 memset(&newparam, 0, sizeof(union parameter));
1161 newparam.bchannel.type = BCHANNEL_REQUEST;
1162 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1165 if (!call->ast) return;
1167 /* use bridge to forware message not supported by asterisk */
1168 bridge_message_if_bridged(call, message_type, param);
1172 * incoming information from LCR
1174 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1176 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1178 if (!call->ast) return;
1180 /* use bridge to forware message not supported by asterisk */
1181 bridge_message_if_bridged(call, message_type, param);
1185 * incoming pattern from LCR
1187 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1189 union parameter newparam;
1191 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1193 if (!call->ast) return;
1195 /* pattern are indicated only once */
1196 if (call->has_pattern)
1198 call->has_pattern = 1;
1200 /* request bchannel */
1201 if (!call->bchannel) {
1202 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1203 memset(&newparam, 0, sizeof(union parameter));
1204 newparam.bchannel.type = BCHANNEL_REQUEST;
1205 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1207 /* queue PROGRESS, because tones are available */
1208 if (call->ast && call->pbx_started) {
1212 write(wake_pipe[1], &byte, 1);
1214 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1219 * got dtmf from bchannel (locked state)
1221 void lcr_in_dtmf(struct chan_call *call, int val)
1223 struct ast_channel *ast = call->ast;
1228 if (!call->pbx_started)
1231 if (!call->dsp_dtmf) {
1232 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1236 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1242 write(wake_pipe[1], &byte, 1);
1244 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1248 * message received from LCR
1250 int receive_message(int message_type, unsigned int ref, union parameter *param)
1252 struct bchannel *bchannel;
1253 struct chan_call *call;
1254 union parameter newparam;
1256 memset(&newparam, 0, sizeof(union parameter));
1258 /* handle bchannel message*/
1259 if (message_type == MESSAGE_BCHANNEL) {
1260 switch(param->bchannel.type) {
1261 case BCHANNEL_ASSIGN:
1262 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1263 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1264 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1267 /* create bchannel */
1268 bchannel = alloc_bchannel(param->bchannel.handle);
1270 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1274 /* configure channel */
1275 bchannel->b_tx_gain = param->bchannel.tx_gain;
1276 bchannel->b_rx_gain = param->bchannel.rx_gain;
1277 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1278 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1279 bchannel->b_bf_len = param->bchannel.crypt_len;
1280 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1282 bchannel->b_txdata = 0;
1283 bchannel->b_tx_dejitter = 1;
1285 /* in case, ref is not set, this bchannel instance must
1286 * be created until it is removed again by LCR */
1288 call = find_call_ref(ref);
1290 bchannel->call = call;
1291 call->bchannel = bchannel;
1293 bchannel_dtmf(bchannel, 1);
1295 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1296 if (call->pipeline[0])
1297 bchannel_pipeline(bchannel, call->pipeline);
1299 bchannel_gain(bchannel, call->rx_gain, 0);
1301 bchannel_gain(bchannel, call->tx_gain, 1);
1302 if (call->bridge_id) {
1303 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1304 bchannel_join(bchannel, call->bridge_id);
1306 /* create only, if call exists, othewhise it bchannel is freed below... */
1307 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1308 bchannel_activate(bchannel, 1);
1311 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1312 newparam.bchannel.handle = param->bchannel.handle;
1313 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1314 /* if call has released before bchannel is assigned */
1316 newparam.bchannel.type = BCHANNEL_RELEASE;
1317 newparam.bchannel.handle = param->bchannel.handle;
1318 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1323 case BCHANNEL_REMOVE:
1324 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1325 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1326 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1329 /* unklink from call and destroy bchannel */
1330 free_bchannel(bchannel);
1333 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1334 newparam.bchannel.handle = param->bchannel.handle;
1335 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1340 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1345 /* handle new ref */
1346 if (message_type == MESSAGE_NEWREF) {
1347 if (param->direction) {
1348 /* new ref from lcr */
1349 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1350 if (!ref || find_call_ref(ref)) {
1351 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1354 /* allocate new call instance */
1355 call = alloc_call();
1357 call->state = CHAN_LCR_STATE_IN_PREPARE;
1360 call->ref_was_assigned = 1;
1361 /* set dtmf (default, use option 'n' to disable */
1363 /* wait for setup (or release from asterisk) */
1365 /* new ref, as requested from this remote application */
1366 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1367 call = find_call_ref(0);
1369 /* send release, if ref does not exist */
1370 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1371 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1376 call->ref_was_assigned = 1;
1377 /* set dtmf (default, use option 'n' to disable */
1379 /* send pending setup info */
1380 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1381 send_setup_to_lcr(call);
1382 /* release if asterisk has signed off */
1383 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1386 send_release_and_import(call, call->cause, call->location);
1388 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1399 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1402 call = find_call_ref(ref);
1404 /* ignore ref that is not used (anymore) */
1405 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1409 /* handle messages */
1410 switch(message_type) {
1412 lcr_in_setup(call, message_type, param);
1415 case MESSAGE_OVERLAP:
1416 lcr_in_overlap(call, message_type, param);
1419 case MESSAGE_PROCEEDING:
1420 lcr_in_proceeding(call, message_type, param);
1423 case MESSAGE_ALERTING:
1424 lcr_in_alerting(call, message_type, param);
1427 case MESSAGE_CONNECT:
1428 lcr_in_connect(call, message_type, param);
1431 case MESSAGE_DISCONNECT:
1432 lcr_in_disconnect(call, message_type, param);
1435 case MESSAGE_RELEASE:
1436 lcr_in_release(call, message_type, param);
1439 case MESSAGE_INFORMATION:
1440 lcr_in_information(call, message_type, param);
1443 case MESSAGE_NOTIFY:
1444 lcr_in_notify(call, message_type, param);
1447 case MESSAGE_FACILITY:
1448 lcr_in_facility(call, message_type, param);
1451 case MESSAGE_PATTERN: // audio available from LCR
1452 if (!call->has_pattern)
1453 lcr_in_pattern(call, message_type, param);
1456 case MESSAGE_NOPATTERN: // audio not available from LCR
1459 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1460 call->audiopath = param->audiopath;
1464 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1471 * release all calls (due to broken socket)
1473 static void release_all_calls(void)
1475 struct chan_call *call;
1480 /* no ast, so we may directly free call */
1482 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1486 /* already in release process */
1487 if (call->state == CHAN_LCR_STATE_RELEASE) {
1491 /* release or queue release */
1493 call->state = CHAN_LCR_STATE_RELEASE;
1494 if (!call->pbx_started) {
1495 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1496 ast_hangup(call->ast); // call will be destroyed here
1499 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1503 write(wake_pipe[1], &byte, 1);
1505 strcpy(call->queue_string, "H");
1509 /* release all bchannels */
1510 while(bchannel_first)
1511 free_bchannel(bchannel_first);
1514 void close_socket(void);
1517 * warning! not thread safe
1518 * returns -1 for socket error, 0 for no work, 1 for work
1520 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1523 struct admin_list *admin;
1524 struct admin_message msg;
1526 if ((what & LCR_FD_READ)) {
1527 /* read from socket */
1528 len = read(lcr_sock, &msg, sizeof(msg));
1530 CERROR(NULL, NULL, "Socket closed.\n");
1532 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1534 release_all_calls();
1535 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1539 if (len != sizeof(msg)) {
1540 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1543 if (msg.message != ADMIN_MESSAGE) {
1544 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1547 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1549 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1554 if ((what & LCR_FD_WRITE)) {
1555 /* write to socket */
1557 socket_fd.when &= ~LCR_FD_WRITE;
1560 admin = admin_first;
1561 len = write(lcr_sock, &admin->msg, sizeof(msg));
1563 CERROR(NULL, NULL, "Socket closed.\n");
1567 if (len != sizeof(msg)) {
1568 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1572 admin_first = admin->next;
1576 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1585 * open and close socket and thread
1587 int open_socket(void)
1590 struct sockaddr_un sock_address;
1591 union parameter param;
1594 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1595 CERROR(NULL, NULL, "Failed to create socket.\n");
1599 /* set socket address and name */
1600 memset(&sock_address, 0, sizeof(sock_address));
1601 sock_address.sun_family = PF_UNIX;
1602 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1604 /* connect socket */
1605 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1608 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1612 /* register socket fd */
1613 memset(&socket_fd, 0, sizeof(socket_fd));
1614 socket_fd.fd = lcr_sock;
1615 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1617 /* enque hello message */
1618 memset(¶m, 0, sizeof(param));
1619 strcpy(param.hello.application, "asterisk");
1620 send_message(MESSAGE_HELLO, 0, ¶m);
1625 void close_socket(void)
1627 struct admin_list *admin, *temp;
1629 unregister_fd(&socket_fd);
1631 /* flush pending messages */
1632 admin = admin_first;
1635 admin = admin->next;
1648 /* sending queue to asterisk */
1649 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1653 read(wake_pipe[0], &byte, 1);
1660 static void handle_queue()
1662 struct chan_call *call;
1663 struct ast_channel *ast;
1664 struct ast_frame fr;
1670 p = call->queue_string;
1673 if (ast_channel_trylock(ast)) {
1674 ast_mutex_unlock(&chan_lock);
1676 ast_mutex_lock(&chan_lock);
1682 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1683 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1686 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1687 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1690 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1691 ast_queue_control(ast, AST_CONTROL_RINGING);
1692 ast_setstate(ast, AST_STATE_RINGING);
1695 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1696 ast_queue_control(ast, AST_CONTROL_ANSWER);
1699 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1700 ast_queue_hangup(ast);
1702 case '1': case '2': case '3': case 'A':
1703 case '4': case '5': case '6': case 'B':
1704 case '7': case '8': case '9': case 'C':
1705 case '*': case '0': case '#': case 'D':
1706 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1707 /* send digit to asterisk */
1708 memset(&fr, 0, sizeof(fr));
1710 #ifdef LCR_FOR_ASTERISK
1711 fr.frametype = AST_FRAME_DTMF_BEGIN;
1714 #ifdef LCR_FOR_CALLWEAVER
1715 fr.frametype = AST_FRAME_DTMF;
1719 fr.delivery = ast_tv(0, 0);
1720 ast_queue_frame(ast, &fr);
1722 #ifdef LCR_FOR_ASTERISK
1723 fr.frametype = AST_FRAME_DTMF_END;
1724 ast_queue_frame(ast, &fr);
1729 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1733 call->queue_string[0] = '\0';
1734 ast_channel_unlock(ast);
1740 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1742 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1743 if (open_socket() < 0)
1744 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1749 void lock_chan(void)
1751 ast_mutex_lock(&chan_lock);
1754 void unlock_chan(void)
1756 ast_mutex_unlock(&chan_lock);
1759 /* chan_lcr thread */
1760 static void *chan_thread(void *arg)
1762 if (pipe(wake_pipe) < 0) {
1763 CERROR(NULL, NULL, "Failed to open pipe.\n");
1766 memset(&wake_fd, 0, sizeof(wake_fd));
1767 wake_fd.fd = wake_pipe[0];
1768 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1770 memset(&socket_retry, 0, sizeof(socket_retry));
1771 add_timer(&socket_retry, handle_retry, NULL, 0);
1773 bchannel_pid = getpid();
1775 /* open socket the first time */
1776 handle_retry(NULL, NULL, 0);
1778 ast_mutex_lock(&chan_lock);
1782 select_main(0, &global_change, lock_chan, unlock_chan);
1787 del_timer(&socket_retry);
1789 unregister_fd(&wake_fd);
1790 close(wake_pipe[0]);
1791 close(wake_pipe[1]);
1793 CERROR(NULL, NULL, "Thread exit.\n");
1795 ast_mutex_unlock(&chan_lock);
1801 * new asterisk instance
1804 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1806 char exten[256], *dial, *interface, *opt;
1807 struct ast_channel *ast;
1808 struct chan_call *call;
1810 ast_mutex_lock(&chan_lock);
1811 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1813 /* if socket is closed */
1815 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1816 ast_mutex_unlock(&chan_lock);
1820 /* create call instance */
1821 call = alloc_call();
1823 /* failed to create instance */
1824 ast_mutex_unlock(&chan_lock);
1828 /* create asterisk channel instrance */
1830 #ifdef LCR_FOR_ASTERISK
1831 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1834 #ifdef LCR_FOR_CALLWEAVER
1835 ast = ast_channel_alloc(1);
1839 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1841 /* failed to create instance */
1842 ast_mutex_unlock(&chan_lock);
1845 ast->tech = &lcr_tech;
1846 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1847 /* configure channel */
1848 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1849 ast->readformat = ast->rawreadformat = ast->nativeformats;
1850 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1852 ast->hangupcause = 0;
1856 ast->tech_pvt = call;
1857 ast->fds[0] = call->pipe[0];
1858 call->pbx_started = 0;
1860 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1863 * Extract interface, dialstring, options from data.
1866 * <interface>/<dialstring>
1867 * <interface>/<dialstring>/options
1869 strncpy(exten, (char *)data, sizeof(exten)-1);
1870 exten[sizeof(exten)-1] = '\0';
1871 if ((dial = strchr(exten, '/'))) {
1874 if ((opt = strchr(dial, '/')))
1883 strncpy(call->interface, interface, sizeof(call->interface)-1);
1884 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1885 apply_opt(call, (char *)opt);
1887 ast_mutex_unlock(&chan_lock);
1892 * call from asterisk
1894 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1896 union parameter newparam;
1897 struct chan_call *call;
1899 ast_mutex_lock(&chan_lock);
1900 call = ast->tech_pvt;
1902 #ifdef LCR_FOR_CALLWEAVER
1904 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1908 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1909 ast_mutex_unlock(&chan_lock);
1913 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1915 /* pbx process is started */
1916 call->pbx_started = 1;
1917 /* send MESSAGE_NEWREF */
1918 memset(&newparam, 0, sizeof(union parameter));
1919 newparam.direction = 0; /* request from app */
1920 send_message(MESSAGE_NEWREF, 0, &newparam);
1922 /* set hdlc if capability requires hdlc */
1923 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1924 || ast->transfercapability == INFO_BC_DATARESTRICTED
1925 || ast->transfercapability == INFO_BC_VIDEO)
1927 /* if hdlc is forced by option, we change transcap to data */
1929 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1930 && ast->transfercapability != INFO_BC_DATARESTRICTED
1931 && ast->transfercapability != INFO_BC_VIDEO)
1932 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1934 call->cid_num[0] = 0;
1935 call->cid_name[0] = 0;
1936 call->cid_rdnis[0] = 0;
1938 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1939 strncpy(call->cid_num, ast->cid.cid_num,
1940 sizeof(call->cid_num)-1);
1942 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1943 strncpy(call->cid_name, ast->cid.cid_name,
1944 sizeof(call->cid_name)-1);
1945 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1946 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1947 sizeof(call->cid_rdnis)-1);
1949 ast_mutex_unlock(&chan_lock);
1953 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1955 static const char* dtmf_tones[] = {
1956 "!941+1336/100,!0/100", /* 0 */
1957 "!697+1209/100,!0/100", /* 1 */
1958 "!697+1336/100,!0/100", /* 2 */
1959 "!697+1477/100,!0/100", /* 3 */
1960 "!770+1209/100,!0/100", /* 4 */
1961 "!770+1336/100,!0/100", /* 5 */
1962 "!770+1477/100,!0/100", /* 6 */
1963 "!852+1209/100,!0/100", /* 7 */
1964 "!852+1336/100,!0/100", /* 8 */
1965 "!852+1477/100,!0/100", /* 9 */
1966 "!697+1633/100,!0/100", /* A */
1967 "!770+1633/100,!0/100", /* B */
1968 "!852+1633/100,!0/100", /* C */
1969 "!941+1633/100,!0/100", /* D */
1970 "!941+1209/100,!0/100", /* * */
1971 "!941+1477/100,!0/100" }; /* # */
1973 if (digit >= '0' && digit <='9')
1974 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1975 else if (digit >= 'A' && digit <= 'D')
1976 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1977 else if (digit == '*')
1978 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1979 else if (digit == '#')
1980 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1983 CDEBUG(NULL, ast, "Unable to handle DTMF tone "
1984 "'%c' for '%s'\n", digit, ast->name);
1988 #ifdef LCR_FOR_ASTERISK
1989 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1991 #ifdef LCR_FOR_CALLWEAVER
1992 static int lcr_digit(struct ast_channel *ast, char digit)
1995 struct chan_call *call;
1996 union parameter newparam;
1999 #ifdef LCR_FOR_CALLWEAVER
2000 int inband_dtmf = 0;
2003 /* only pass IA5 number space */
2004 if (digit > 126 || digit < 32)
2007 ast_mutex_lock(&chan_lock);
2008 call = ast->tech_pvt;
2010 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2011 ast_mutex_unlock(&chan_lock);
2015 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2017 /* send information or queue them */
2018 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2019 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2020 memset(&newparam, 0, sizeof(union parameter));
2022 newparam.information.keypad[0] = digit;
2023 newparam.information.keypad[1] = '\0';
2025 newparam.information.id[0] = digit;
2026 newparam.information.id[1] = '\0';
2028 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2031 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2032 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2034 strncat(call->dialque, buf, strlen(call->dialque)-1);
2037 ast_mutex_unlock(&chan_lock);
2039 #ifdef LCR_FOR_ASTERISK
2043 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2045 int inband_dtmf = 0;
2046 struct chan_call *call;
2049 ast_mutex_lock(&chan_lock);
2051 call = ast->tech_pvt;
2055 "Received digit from Asterisk, "
2056 "but no call instance exists.\n");
2057 ast_mutex_unlock(&chan_lock);
2061 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2063 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2067 ast_mutex_unlock(&chan_lock);
2070 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2071 send_digit_to_chan(ast, digit);
2077 static int lcr_answer(struct ast_channel *ast)
2079 union parameter newparam;
2080 struct chan_call *call;
2082 ast_mutex_lock(&chan_lock);
2083 call = ast->tech_pvt;
2085 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2086 ast_mutex_unlock(&chan_lock);
2090 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2092 /* copy connectinfo, if bridged */
2093 if (call->bridge_call)
2094 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2095 /* send connect message to lcr */
2096 if (call->state != CHAN_LCR_STATE_CONNECT) {
2097 memset(&newparam, 0, sizeof(union parameter));
2098 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2099 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2100 call->state = CHAN_LCR_STATE_CONNECT;
2103 /* request bchannel */
2104 if (!call->bchannel) {
2105 CDEBUG(call, ast, "Requesting B-channel.\n");
2106 memset(&newparam, 0, sizeof(union parameter));
2107 newparam.bchannel.type = BCHANNEL_REQUEST;
2108 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2111 // memset(&newparam, 0, sizeof(union parameter));
2112 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2114 ast_mutex_unlock(&chan_lock);
2118 static int lcr_hangup(struct ast_channel *ast)
2120 struct chan_call *call;
2121 pthread_t tid = pthread_self();
2123 if (!pthread_equal(tid, chan_tid)) {
2124 ast_mutex_lock(&chan_lock);
2126 call = ast->tech_pvt;
2128 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2129 if (!pthread_equal(tid, chan_tid)) {
2130 ast_mutex_unlock(&chan_lock);
2135 if (!pthread_equal(tid, chan_tid))
2136 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2138 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2140 /* disconnect asterisk, maybe not required */
2141 ast->tech_pvt = NULL;
2145 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2146 if (ast->hangupcause > 0)
2147 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2149 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2152 if (!pthread_equal(tid, chan_tid)) {
2153 ast_mutex_unlock(&chan_lock);
2157 /* ref is not set, due to prepare setup or release */
2158 if (call->state == CHAN_LCR_STATE_RELEASE) {
2159 /* we get the response to our release */
2160 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2163 /* during prepare, we change to release state */
2164 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2165 call->state = CHAN_LCR_STATE_RELEASE;
2169 if (!pthread_equal(tid, chan_tid)) {
2170 ast_mutex_unlock(&chan_lock);
2175 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2177 struct chan_call *call;
2180 CDEBUG(NULL, ast, "No subclass\n");
2181 if (!(f->subclass & ast->nativeformats))
2182 CDEBUG(NULL, ast, "Unexpected format.\n");
2184 ast_mutex_lock(&chan_lock);
2185 call = ast->tech_pvt;
2187 ast_mutex_unlock(&chan_lock);
2190 if (call->bchannel && f->samples)
2191 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2192 ast_mutex_unlock(&chan_lock);
2197 static struct ast_frame *lcr_read(struct ast_channel *ast)
2199 struct chan_call *call;
2202 ast_mutex_lock(&chan_lock);
2203 call = ast->tech_pvt;
2205 ast_mutex_unlock(&chan_lock);
2208 if (call->pipe[0] > -1) {
2209 if (call->rebuffer && !call->hdlc) {
2210 /* Make sure we have a complete 20ms (160byte) frame */
2211 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2213 call->framepos += len;
2216 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2218 if (len < 0 && errno == EAGAIN) {
2219 ast_mutex_unlock(&chan_lock);
2221 #ifdef LCR_FOR_ASTERISK
2222 return &ast_null_frame;
2225 #ifdef LCR_FOR_CALLWEAVER
2231 close(call->pipe[0]);
2234 ast_mutex_unlock(&chan_lock);
2236 } else if (call->rebuffer && call->framepos < 160) {
2237 /* Not a complete frame, so we send a null-frame */
2238 ast_mutex_unlock(&chan_lock);
2239 return &ast_null_frame;
2243 call->read_fr.frametype = AST_FRAME_VOICE;
2244 call->read_fr.subclass = ast->nativeformats;
2245 if (call->rebuffer) {
2246 call->read_fr.datalen = call->framepos;
2247 call->read_fr.samples = call->framepos;
2250 call->read_fr.datalen = len;
2251 call->read_fr.samples = len;
2253 call->read_fr.delivery = ast_tv(0,0);
2254 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2255 ast_mutex_unlock(&chan_lock);
2257 return &call->read_fr;
2260 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2262 union parameter newparam;
2264 struct chan_call *call;
2265 const struct tone_zone_sound *ts = NULL;
2267 ast_mutex_lock(&chan_lock);
2268 call = ast->tech_pvt;
2270 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2271 ast_mutex_unlock(&chan_lock);
2276 case AST_CONTROL_BUSY:
2277 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2278 ast_setstate(ast, AST_STATE_BUSY);
2279 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2280 /* send message to lcr */
2281 memset(&newparam, 0, sizeof(union parameter));
2282 newparam.disconnectinfo.cause = 17;
2283 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2284 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2286 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2288 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2289 ts = ast_get_indication_tone(ast->zone, "busy");
2292 case AST_CONTROL_CONGESTION:
2293 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2294 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2295 /* send message to lcr */
2296 memset(&newparam, 0, sizeof(union parameter));
2297 newparam.disconnectinfo.cause = ast->hangupcause;
2298 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2299 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2301 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2303 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2304 ts = ast_get_indication_tone(ast->zone, "congestion");
2307 case AST_CONTROL_PROCEEDING:
2308 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2309 if (call->state == CHAN_LCR_STATE_IN_SETUP
2310 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2311 /* send message to lcr */
2312 memset(&newparam, 0, sizeof(union parameter));
2313 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2315 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2318 case AST_CONTROL_RINGING:
2319 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2320 ast_setstate(ast, AST_STATE_RING);
2321 if (call->state == CHAN_LCR_STATE_IN_SETUP
2322 || call->state == CHAN_LCR_STATE_IN_DIALING
2323 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2324 /* send message to lcr */
2325 memset(&newparam, 0, sizeof(union parameter));
2326 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2328 call->state = CHAN_LCR_STATE_IN_ALERTING;
2330 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2331 ts = ast_get_indication_tone(ast->zone, "ring");
2334 case AST_CONTROL_PROGRESS:
2335 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2336 /* request bchannel */
2337 if (!call->bchannel) {
2338 CDEBUG(call, ast, "Requesting B-channel.\n");
2339 memset(&newparam, 0, sizeof(union parameter));
2340 newparam.bchannel.type = BCHANNEL_REQUEST;
2341 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2345 CDEBUG(call, ast, "Received indicate -1.\n");
2346 ast_playtones_stop(ast);
2350 case AST_CONTROL_VIDUPDATE:
2351 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2354 case AST_CONTROL_HOLD:
2355 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2356 /* send message to lcr */
2357 memset(&newparam, 0, sizeof(union parameter));
2358 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2359 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2361 /*start music onhold*/
2362 #ifdef LCR_FOR_ASTERISK
2363 ast_moh_start(ast,data,ast->musicclass);
2366 #ifdef LCR_FOR_CALLWEAVER
2367 ast_moh_start(ast, NULL);
2372 case AST_CONTROL_UNHOLD:
2373 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2374 /* send message to lcr */
2375 memset(&newparam, 0, sizeof(union parameter));
2376 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2377 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2383 #ifdef AST_CONTROL_SRCUPDATE
2384 case AST_CONTROL_SRCUPDATE:
2388 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2391 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2396 if (ts && ts->data[0]) {
2397 ast_playtones_start(ast, 0, ts->data, 1);
2401 ast_mutex_unlock(&chan_lock);
2408 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2410 struct chan_call *call;
2416 ast_mutex_lock(&chan_lock);
2417 call = ast->tech_pvt;
2419 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2420 ast_mutex_unlock(&chan_lock);
2424 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2426 ast_mutex_unlock(&chan_lock);
2431 * send_text asterisk
2433 static int lcr_send_text(struct ast_channel *ast, const char *text)
2435 struct chan_call *call;
2436 union parameter newparam;
2438 ast_mutex_lock(&chan_lock);
2439 call = ast->tech_pvt;
2441 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2442 ast_mutex_unlock(&chan_lock);
2446 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2447 memset(&newparam, 0, sizeof(union parameter));
2448 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2449 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2450 ast_mutex_unlock(&chan_lock);
2457 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2458 struct ast_channel *ast2, int flags,
2459 struct ast_frame **fo,
2460 struct ast_channel **rc, int timeoutms)
2463 struct chan_call *call1, *call2;
2464 struct ast_channel *carr[2], *who;
2466 struct ast_frame *f;
2469 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2474 /* join via dsp (if the channels are currently open) */
2475 ast_mutex_lock(&chan_lock);
2476 call1 = ast1->tech_pvt;
2477 call2 = ast2->tech_pvt;
2478 if (!call1 || !call2) {
2479 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2480 ast_mutex_unlock(&chan_lock);
2481 return AST_BRIDGE_COMPLETE;
2484 /* join, if both call instances uses dsp
2485 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2487 if (!call1->nodsp && !call2->nodsp) {
2488 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2490 /* get bridge id and join */
2491 bridge_id = new_bridge_id();
2493 call1->bridge_id = bridge_id;
2494 if (call1->bchannel)
2495 bchannel_join(call1->bchannel, bridge_id);
2497 call2->bridge_id = bridge_id;
2498 if (call2->bchannel)
2499 bchannel_join(call2->bchannel, bridge_id);
2501 if (call1->nodsp && call2->nodsp)
2502 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2504 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2505 call1->bridge_call = call2;
2506 call2->bridge_call = call1;
2508 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2509 || call1->state == CHAN_LCR_STATE_IN_DIALING
2510 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2511 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2512 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2515 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2516 || call2->state == CHAN_LCR_STATE_IN_DIALING
2517 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2518 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2519 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2523 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2524 so let's do it for them. Hmpf.
2527 if (call1->on_hold) {
2528 union parameter newparam;
2530 memset(&newparam, 0, sizeof(union parameter));
2531 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2532 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2537 if (call2->on_hold) {
2538 union parameter newparam;
2540 memset(&newparam, 0, sizeof(union parameter));
2541 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2542 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2547 ast_mutex_unlock(&chan_lock);
2551 who = ast_waitfor_n(carr, 2, &to);
2554 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2559 if (!f || f->frametype == AST_FRAME_CONTROL) {
2561 CDEBUG(NULL, NULL, "Got hangup.\n");
2563 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2570 if ( f->frametype == AST_FRAME_DTMF ) {
2571 CDEBUG(NULL, NULL, "Got DTMF.\n");
2587 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2589 /* split channels */
2590 ast_mutex_lock(&chan_lock);
2591 call1 = ast1->tech_pvt;
2592 call2 = ast2->tech_pvt;
2593 if (call1 && call1->bridge_id) {
2594 call1->bridge_id = 0;
2595 if (call1->bchannel)
2596 bchannel_join(call1->bchannel, 0);
2597 if (call1->bridge_call)
2598 call1->bridge_call->bridge_call = NULL;
2600 if (call2 && call1->bridge_id) {
2601 call2->bridge_id = 0;
2602 if (call2->bchannel)
2603 bchannel_join(call2->bchannel, 0);
2604 if (call2->bridge_call)
2605 call2->bridge_call->bridge_call = NULL;
2607 call1->bridge_call = NULL;
2608 call2->bridge_call = NULL;
2610 ast_mutex_unlock(&chan_lock);
2611 return AST_BRIDGE_COMPLETE;
2613 static struct ast_channel_tech lcr_tech = {
2615 .description = "Channel driver for connecting to Linux-Call-Router",
2616 .capabilities = AST_FORMAT_ALAW,
2617 .requester = lcr_request,
2619 #ifdef LCR_FOR_ASTERISK
2620 .send_digit_begin = lcr_digit_begin,
2621 .send_digit_end = lcr_digit_end,
2624 #ifdef LCR_FOR_CALLWEAVER
2625 .send_digit = lcr_digit,
2629 .bridge = lcr_bridge,
2630 .hangup = lcr_hangup,
2631 .answer = lcr_answer,
2634 .indicate = lcr_indicate,
2636 .send_text = lcr_send_text,
2645 static int lcr_show_lcr (int fd, int argc, char *argv[])
2650 static int lcr_show_calls (int fd, int argc, char *argv[])
2655 static int lcr_reload_routing (int fd, int argc, char *argv[])
2660 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2665 static int lcr_port_block (int fd, int argc, char *argv[])
2670 static int lcr_port_unblock (int fd, int argc, char *argv[])
2675 static int lcr_port_unload (int fd, int argc, char *argv[])
2680 static struct ast_cli_entry cli_show_lcr =
2681 { {"lcr", "show", "lcr", NULL},
2683 "Shows current states of LCR core",
2684 "Usage: lcr show lcr\n",
2687 static struct ast_cli_entry cli_show_calls =
2688 { {"lcr", "show", "calls", NULL},
2690 "Shows current calls made by LCR and Asterisk",
2691 "Usage: lcr show calls\n",
2694 static struct ast_cli_entry cli_reload_routing =
2695 { {"lcr", "reload", "routing", NULL},
2697 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2698 "Usage: lcr reload routing\n",
2701 static struct ast_cli_entry cli_reload_interfaces =
2702 { {"lcr", "reload", "interfaces", NULL},
2703 lcr_reload_interfaces,
2704 "Reloads interfaces conf of LCR",
2705 "Usage: lcr reload interfaces\n",
2708 static struct ast_cli_entry cli_port_block =
2709 { {"lcr", "port", "block", NULL},
2711 "Blocks LCR port for further calls",
2712 "Usage: lcr port block \"<port>\"\n",
2715 static struct ast_cli_entry cli_port_unblock =
2716 { {"lcr", "port", "unblock", NULL},
2718 "Unblocks or loads LCR port, port is opened my mISDN",
2719 "Usage: lcr port unblock \"<port>\"\n",
2722 static struct ast_cli_entry cli_port_unload =
2723 { {"lcr", "port", "unload", NULL},
2725 "Unloads LCR port, port is closes by mISDN",
2726 "Usage: lcr port unload \"<port>\"\n",
2731 #ifdef LCR_FOR_ASTERISK
2732 static int lcr_config_exec(struct ast_channel *ast, void *data)
2735 #ifdef LCR_FOR_CALLWEAVER
2736 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2739 struct chan_call *call;
2741 ast_mutex_lock(&chan_lock);
2743 #ifdef LCR_FOR_ASTERISK
2744 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2747 #ifdef LCR_FOR_CALLWEAVER
2748 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2754 if (call->ast == ast)
2760 #ifdef LCR_FOR_ASTERISK
2761 apply_opt(call, (char *)data);
2764 #ifdef LCR_FOR_CALLWEAVER
2765 apply_opt(call, (char *)argv[0]);
2769 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2771 ast_mutex_unlock(&chan_lock);
2776 * module loading and destruction
2778 int load_module(void)
2781 char options_error[256];
2783 for (i = 0; i < 256; i++) {
2784 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2785 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2788 if (read_options(options_error) == 0) {
2789 CERROR(NULL, NULL, "%s", options_error);
2791 #ifdef LCR_FOR_ASTERISK
2792 return AST_MODULE_LOAD_DECLINE;
2795 #ifdef LCR_FOR_CALLWEAVER
2801 ast_mutex_init(&chan_lock);
2802 ast_mutex_init(&log_lock);
2804 if (bchannel_initialize()) {
2805 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2808 #ifdef LCR_FOR_ASTERISK
2809 return AST_MODULE_LOAD_DECLINE;
2812 #ifdef LCR_FOR_CALLWEAVER
2818 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2819 if (ast_channel_register(&lcr_tech)) {
2820 CERROR(NULL, NULL, "Unable to register channel class\n");
2821 bchannel_deinitialize();
2824 #ifdef LCR_FOR_ASTERISK
2825 return AST_MODULE_LOAD_DECLINE;
2828 #ifdef LCR_FOR_CALLWEAVER
2833 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2835 #ifdef LCR_FOR_ASTERISK
2836 "lcr_config(<opt><optarg>:<opt>:...)\n"
2839 #ifdef LCR_FOR_CALLWEAVER
2840 "lcr_config(<opt><optarg>:<opt>:...)\n",
2843 "Sets LCR opts. and optargs\n"
2845 "The available options are:\n"
2846 " d - Send display text on called phone, text is the optarg.\n"
2847 " n - Don't detect dtmf tones on called channel.\n"
2848 " h - Force data call (HDLC).\n"
2849 " t - Disable mISDN_dsp features (required for fax application).\n"
2850 " q - Add queue to make fax stream seamless (required for fax app).\n"
2851 " Use queue size in miliseconds for optarg. (try 250)\n"
2852 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2853 " Use time to detect for optarg.\n"
2854 " c - Make crypted outgoing call, optarg is keyindex.\n"
2855 " e - Perform echo cancelation on this channel.\n"
2856 " Takes mISDN pipeline option as optarg.\n"
2857 " s - Send Non Inband DTMF as inband.\n"
2858 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2859 " vr - rxgain control\n"
2860 " vt - txgain control\n"
2861 " Volume changes at factor 2 ^ optarg.\n"
2862 " k - use keypad to dial this call.\n"
2864 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2865 " -> use 16 for fax (3.1k audio)\n"
2867 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2868 "options: \"n:t:q250\" for seamless audio transmission.\n"
2873 ast_cli_register(&cli_show_lcr);
2874 ast_cli_register(&cli_show_calls);
2875 ast_cli_register(&cli_reload_routing);
2876 ast_cli_register(&cli_reload_interfaces);
2877 ast_cli_register(&cli_port_block);
2878 ast_cli_register(&cli_port_unblock);
2879 ast_cli_register(&cli_port_unload);
2883 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2884 /* failed to create thread */
2885 bchannel_deinitialize();
2887 ast_channel_unregister(&lcr_tech);
2889 #ifdef LCR_FOR_ASTERISK
2890 return AST_MODULE_LOAD_DECLINE;
2893 #ifdef LCR_FOR_CALLWEAVER
2901 int unload_module(void)
2903 /* First, take us out of the channel loop */
2904 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2907 pthread_join(chan_tid, NULL);
2909 ast_channel_unregister(&lcr_tech);
2911 ast_unregister_application("lcr_config");
2914 if (mISDN_created) {
2915 bchannel_deinitialize();
2919 if (lcr_sock >= 0) {
2927 int reload_module(void)
2933 #ifdef LCR_FOR_ASTERISK
2934 #define AST_MODULE "chan_lcr"
2937 #ifdef LCR_FOR_CALLWEAVER
2942 ast_mutex_lock(&usecnt_lock);
2944 ast_mutex_unlock(&usecnt_lock);
2949 #ifdef LCR_FOR_ASTERISK
2950 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2951 .load = load_module,
2952 .unload = unload_module,
2953 .reload = reload_module,
2957 #ifdef LCR_FOR_CALLWEAVER
2958 char *description(void)