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 if (!!strcmp(call->interface, "pbx"))
632 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
633 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
634 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
635 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
636 call->display[0] = '\0';
637 if (call->cid_num[0])
638 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
639 if (call->cid_name[0])
640 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
641 if (call->cid_rdnis[0]) {
642 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
643 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
644 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
646 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
647 case AST_PRES_RESTRICTED:
648 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
650 case AST_PRES_UNAVAILABLE:
651 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
653 case AST_PRES_ALLOWED:
655 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
657 switch(ast->cid.cid_ton) {
659 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
662 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
665 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
668 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
670 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
671 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
673 // ast->transfercapability = atoi(tmp);
674 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
675 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
677 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
679 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
680 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
682 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
683 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
684 send_message(MESSAGE_SETUP, call->ref, &newparam);
686 /* change to outgoing setup state */
687 call->state = CHAN_LCR_STATE_OUT_SETUP;
691 * send dialing info to LCR
692 * this function is called, when setup acknowledge is received and dialing
695 static void send_dialque_to_lcr(struct chan_call *call)
697 union parameter newparam;
699 if (!call->ast || !call->ref || !call->dialque[0])
702 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
704 /* send setup message to LCR */
705 memset(&newparam, 0, sizeof(union parameter));
707 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
709 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
710 call->dialque[0] = '\0';
711 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
715 * in case of a bridge, the unsupported message can be forwarded directly
716 * to the remote call.
718 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
722 if (!call->bridge_call) return;
723 CDEBUG(call, NULL, "Sending message due bridging.\n");
724 send_message(message_type, call->bridge_call->ref, param);
728 * send release message to LCR and import bchannel if exported
730 static void send_release_and_import(struct chan_call *call, int cause, int location)
732 union parameter newparam;
734 /* importing channel */
735 if (call->bchannel) {
736 memset(&newparam, 0, sizeof(union parameter));
737 newparam.bchannel.type = BCHANNEL_RELEASE;
738 newparam.bchannel.handle = call->bchannel->handle;
739 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
741 /* sending release */
742 memset(&newparam, 0, sizeof(union parameter));
743 newparam.disconnectinfo.cause = cause;
744 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
745 send_message(MESSAGE_RELEASE, call->ref, &newparam);
749 * check if extension matches and start asterisk
750 * if it can match, proceed
753 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
756 union parameter newparam;
757 char *exten = ast->exten;
761 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
765 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
766 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
770 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
771 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);
775 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
776 /* send setup acknowledge to lcr */
777 memset(&newparam, 0, sizeof(union parameter));
778 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
781 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
786 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
787 /* send setup acknowledge to lcr */
788 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
789 memset(&newparam, 0, sizeof(union parameter));
790 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
794 call->state = CHAN_LCR_STATE_IN_DIALING;
796 /* if match, start pbx */
797 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
798 CDEBUG(call, ast, "Extensions matches.\n");
803 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
809 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
817 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
818 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
820 /* release asterisk */
821 ast->hangupcause = call->cause;
822 /* change to release state */
823 call->state = CHAN_LCR_STATE_RELEASE;
824 ast_hangup(ast); // call will be destroyed here
828 /* send setup to asterisk */
829 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
831 #ifdef LCR_FOR_CALLWEAVER
833 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
836 ret = ast_pbx_start(ast);
838 cause = (ret==-2)?34:27;
841 call->pbx_started = 1;
842 ast_setstate(ast, AST_STATE_RING);
846 * incoming setup from LCR
848 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
850 struct ast_channel *ast;
852 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
854 /* create asterisk channel instrance */
856 #ifdef LCR_FOR_CALLWEAVER
857 ast = ast_channel_alloc(1);
860 #ifdef LCR_FOR_ASTERISK
861 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
866 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
867 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
874 ast->tech_pvt = call;
875 ast->tech = &lcr_tech;
876 ast->fds[0] = call->pipe[0];
878 /* fill setup information */
879 if (param->setup.dialinginfo.id)
880 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
881 if (param->setup.context[0])
882 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
884 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
885 memset(&ast->cid, 0, sizeof(ast->cid));
886 if (param->setup.callerinfo.id[0])
887 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
888 if (param->setup.callerinfo.id2[0])
889 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
890 if (param->setup.callerinfo.name[0])
891 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
892 if (param->setup.redirinfo.id[0])
893 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
894 switch (param->setup.callerinfo.present) {
895 case INFO_PRESENT_ALLOWED:
896 ast->cid.cid_pres = AST_PRES_ALLOWED;
898 case INFO_PRESENT_RESTRICTED:
899 ast->cid.cid_pres = AST_PRES_RESTRICTED;
902 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
904 switch (param->setup.callerinfo.ntype) {
905 case INFO_NTYPE_SUBSCRIBER:
906 ast->cid.cid_ton = 4;
908 case INFO_NTYPE_NATIONAL:
909 ast->cid.cid_ton = 2;
911 case INFO_NTYPE_INTERNATIONAL:
912 ast->cid.cid_ton = 1;
915 ast->cid.cid_ton = 0;
917 ast->transfercapability = param->setup.capainfo.bearer_capa;
918 /* enable hdlc if transcap is data */
919 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
921 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
923 /* configure channel */
924 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
925 ast->readformat = ast->rawreadformat = ast->nativeformats;
926 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
928 ast->hangupcause = 0;
931 call->state = CHAN_LCR_STATE_IN_SETUP;
933 if (!call->pbx_started)
934 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
938 * incoming setup acknowledge from LCR
940 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
942 if (!call->ast) return;
944 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
946 /* send pending digits in dialque */
947 if (call->dialque[0])
948 send_dialque_to_lcr(call);
949 /* change to overlap state */
950 call->state = CHAN_LCR_STATE_OUT_DIALING;
954 * incoming proceeding from LCR
956 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
958 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
961 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
962 /* queue event for asterisk */
963 if (call->ast && call->pbx_started) {
967 write(wake_pipe[1], &byte, 1);
969 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
975 * incoming alerting from LCR
977 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
979 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
982 call->state = CHAN_LCR_STATE_OUT_ALERTING;
983 /* queue event to asterisk */
984 if (call->ast && call->pbx_started) {
988 write(wake_pipe[1], &byte, 1);
990 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
995 * incoming connect from LCR
997 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
999 union parameter newparam;
1001 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1004 call->state = CHAN_LCR_STATE_CONNECT;
1005 /* request bchannel */
1006 if (!call->bchannel) {
1007 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1008 memset(&newparam, 0, sizeof(union parameter));
1009 newparam.bchannel.type = BCHANNEL_REQUEST;
1010 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1012 /* copy connectinfo */
1013 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1014 /* queue event to asterisk */
1015 if (call->ast && call->pbx_started) {
1019 write(wake_pipe[1], &byte, 1);
1021 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1026 * incoming disconnect from LCR
1028 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1030 struct ast_channel *ast = call->ast;
1032 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1035 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1037 call->cause = param->disconnectinfo.cause;
1038 call->location = param->disconnectinfo.location;
1039 /* if bridge, forward disconnect and return */
1042 if (call->bridge_call) {
1043 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1044 bridge_message_if_bridged(call, message_type, param);
1048 /* release lcr with same cause */
1049 send_release_and_import(call, call->cause, call->location);
1051 /* change to release state */
1052 call->state = CHAN_LCR_STATE_RELEASE;
1053 /* queue release asterisk */
1055 ast->hangupcause = call->cause;
1056 if (call->pbx_started) {
1060 write(wake_pipe[1], &byte, 1);
1062 strcpy(call->queue_string, "H"); // overwrite other indications
1064 ast_hangup(ast); // call will be destroyed here
1070 * incoming release from LCR
1072 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1074 struct ast_channel *ast = call->ast;
1076 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1080 /* change to release state */
1081 call->state = CHAN_LCR_STATE_RELEASE;
1082 /* copy release info */
1084 call->cause = param->disconnectinfo.cause;
1085 call->location = param->disconnectinfo.location;
1087 /* if we have an asterisk instance, queue hangup, else we are done */
1089 ast->hangupcause = call->cause;
1090 if (call->pbx_started) {
1094 write(wake_pipe[1], &byte, 1);
1096 strcpy(call->queue_string, "H");
1098 ast_hangup(ast); // call will be destroyed here
1107 * incoming information from LCR
1109 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1111 struct ast_channel *ast = call->ast;
1113 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1117 /* pbx not started */
1118 if (!call->pbx_started) {
1119 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1120 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1121 lcr_start_pbx(call, ast, param->information.sending_complete);
1125 /* change dailing state after setup */
1126 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1127 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1128 call->state = CHAN_LCR_STATE_IN_DIALING;
1129 // ast_setstate(ast, AST_STATE_DIALING);
1133 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1137 write(wake_pipe[1], &byte, 1);
1139 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1142 /* use bridge to forware message not supported by asterisk */
1143 if (call->state == CHAN_LCR_STATE_CONNECT) {
1144 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1145 bridge_message_if_bridged(call, message_type, param);
1150 * incoming information from LCR
1152 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1154 union parameter newparam;
1156 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1158 /* request bchannel, if call is resumed and we don't have it */
1159 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1160 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1161 memset(&newparam, 0, sizeof(union parameter));
1162 newparam.bchannel.type = BCHANNEL_REQUEST;
1163 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1166 if (!call->ast) return;
1168 /* use bridge to forware message not supported by asterisk */
1169 bridge_message_if_bridged(call, message_type, param);
1173 * incoming information from LCR
1175 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1177 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1179 if (!call->ast) return;
1181 /* use bridge to forware message not supported by asterisk */
1182 bridge_message_if_bridged(call, message_type, param);
1186 * incoming pattern from LCR
1188 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1190 union parameter newparam;
1192 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1194 if (!call->ast) return;
1196 /* pattern are indicated only once */
1197 if (call->has_pattern)
1199 call->has_pattern = 1;
1201 /* request bchannel */
1202 if (!call->bchannel) {
1203 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1204 memset(&newparam, 0, sizeof(union parameter));
1205 newparam.bchannel.type = BCHANNEL_REQUEST;
1206 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1208 /* queue PROGRESS, because tones are available */
1209 if (call->ast && call->pbx_started) {
1213 write(wake_pipe[1], &byte, 1);
1215 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1220 * got dtmf from bchannel (locked state)
1222 void lcr_in_dtmf(struct chan_call *call, int val)
1224 struct ast_channel *ast = call->ast;
1229 if (!call->pbx_started)
1232 if (!call->dsp_dtmf) {
1233 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1237 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1243 write(wake_pipe[1], &byte, 1);
1245 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1249 * message received from LCR
1251 int receive_message(int message_type, unsigned int ref, union parameter *param)
1253 struct bchannel *bchannel;
1254 struct chan_call *call;
1255 union parameter newparam;
1257 memset(&newparam, 0, sizeof(union parameter));
1259 /* handle bchannel message*/
1260 if (message_type == MESSAGE_BCHANNEL) {
1261 switch(param->bchannel.type) {
1262 case BCHANNEL_ASSIGN:
1263 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1264 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1265 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1268 /* create bchannel */
1269 bchannel = alloc_bchannel(param->bchannel.handle);
1271 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1275 /* configure channel */
1276 bchannel->b_tx_gain = param->bchannel.tx_gain;
1277 bchannel->b_rx_gain = param->bchannel.rx_gain;
1278 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1279 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1280 bchannel->b_bf_len = param->bchannel.crypt_len;
1281 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1283 bchannel->b_txdata = 0;
1284 bchannel->b_tx_dejitter = 1;
1286 /* in case, ref is not set, this bchannel instance must
1287 * be created until it is removed again by LCR */
1289 call = find_call_ref(ref);
1291 bchannel->call = call;
1292 call->bchannel = bchannel;
1294 bchannel_dtmf(bchannel, 1);
1296 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1297 if (call->pipeline[0])
1298 bchannel_pipeline(bchannel, call->pipeline);
1300 bchannel_gain(bchannel, call->rx_gain, 0);
1302 bchannel_gain(bchannel, call->tx_gain, 1);
1303 if (call->bridge_id) {
1304 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1305 bchannel_join(bchannel, call->bridge_id);
1307 /* ignore all dsp features, if it is a loopback interface */
1308 if (param->bchannel.isloopback)
1311 /* create only, if call exists, othewhise it bchannel is freed below... */
1312 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
1313 bchannel_activate(bchannel, 1);
1316 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1317 newparam.bchannel.handle = param->bchannel.handle;
1318 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1319 /* if call has released before bchannel is assigned */
1321 newparam.bchannel.type = BCHANNEL_RELEASE;
1322 newparam.bchannel.handle = param->bchannel.handle;
1323 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1328 case BCHANNEL_REMOVE:
1329 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1330 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1331 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1334 /* unklink from call and destroy bchannel */
1335 free_bchannel(bchannel);
1338 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1339 newparam.bchannel.handle = param->bchannel.handle;
1340 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1345 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1350 /* handle new ref */
1351 if (message_type == MESSAGE_NEWREF) {
1352 if (param->newref.direction) {
1353 /* new ref from lcr */
1354 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1355 if (!ref || find_call_ref(ref)) {
1356 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1359 /* allocate new call instance */
1360 call = alloc_call();
1362 call->state = CHAN_LCR_STATE_IN_PREPARE;
1365 call->ref_was_assigned = 1;
1366 /* set dtmf (default, use option 'n' to disable */
1368 /* wait for setup (or release from asterisk) */
1370 /* new ref, as requested from this remote application */
1371 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1372 call = find_call_ref(0);
1374 /* send release, if ref does not exist */
1375 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1376 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1381 call->ref_was_assigned = 1;
1382 /* set dtmf (default, use option 'n' to disable */
1384 /* send pending setup info */
1385 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1386 send_setup_to_lcr(call);
1387 /* release if asterisk has signed off */
1388 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1391 send_release_and_import(call, call->cause, call->location);
1393 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1404 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1407 call = find_call_ref(ref);
1409 /* ignore ref that is not used (anymore) */
1410 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1414 /* handle messages */
1415 switch(message_type) {
1417 lcr_in_setup(call, message_type, param);
1420 case MESSAGE_OVERLAP:
1421 lcr_in_overlap(call, message_type, param);
1424 case MESSAGE_PROCEEDING:
1425 lcr_in_proceeding(call, message_type, param);
1428 case MESSAGE_ALERTING:
1429 lcr_in_alerting(call, message_type, param);
1432 case MESSAGE_CONNECT:
1433 lcr_in_connect(call, message_type, param);
1436 case MESSAGE_DISCONNECT:
1437 lcr_in_disconnect(call, message_type, param);
1440 case MESSAGE_RELEASE:
1441 lcr_in_release(call, message_type, param);
1444 case MESSAGE_INFORMATION:
1445 lcr_in_information(call, message_type, param);
1448 case MESSAGE_NOTIFY:
1449 lcr_in_notify(call, message_type, param);
1452 case MESSAGE_FACILITY:
1453 lcr_in_facility(call, message_type, param);
1456 case MESSAGE_PATTERN: // audio available from LCR
1457 if (!call->has_pattern)
1458 lcr_in_pattern(call, message_type, param);
1461 case MESSAGE_NOPATTERN: // audio not available from LCR
1464 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1465 call->audiopath = param->audiopath;
1469 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1476 * release all calls (due to broken socket)
1478 static void release_all_calls(void)
1480 struct chan_call *call;
1485 /* no ast, so we may directly free call */
1487 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1491 /* already in release process */
1492 if (call->state == CHAN_LCR_STATE_RELEASE) {
1496 /* release or queue release */
1498 call->state = CHAN_LCR_STATE_RELEASE;
1499 if (!call->pbx_started) {
1500 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1501 ast_hangup(call->ast); // call will be destroyed here
1504 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1508 write(wake_pipe[1], &byte, 1);
1510 strcpy(call->queue_string, "H");
1514 /* release all bchannels */
1515 while(bchannel_first)
1516 free_bchannel(bchannel_first);
1519 void close_socket(void);
1522 * warning! not thread safe
1523 * returns -1 for socket error, 0 for no work, 1 for work
1525 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1528 struct admin_list *admin;
1529 struct admin_message msg;
1531 if ((what & LCR_FD_READ)) {
1532 /* read from socket */
1533 len = read(lcr_sock, &msg, sizeof(msg));
1535 CERROR(NULL, NULL, "Socket closed.(read)\n");
1537 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1539 release_all_calls();
1540 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1544 if (len != sizeof(msg)) {
1545 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1548 if (msg.message != ADMIN_MESSAGE) {
1549 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1552 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1554 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1559 if ((what & LCR_FD_WRITE)) {
1560 /* write to socket */
1562 socket_fd.when &= ~LCR_FD_WRITE;
1565 admin = admin_first;
1566 len = write(lcr_sock, &admin->msg, sizeof(msg));
1568 CERROR(NULL, NULL, "Socket closed.(write)\n");
1572 if (len != sizeof(msg)) {
1573 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1577 admin_first = admin->next;
1581 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1590 * open and close socket and thread
1592 int open_socket(void)
1595 struct sockaddr_un sock_address;
1596 union parameter param;
1599 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1600 CERROR(NULL, NULL, "Failed to create socket.\n");
1604 /* set socket address and name */
1605 memset(&sock_address, 0, sizeof(sock_address));
1606 sock_address.sun_family = PF_UNIX;
1607 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1609 /* connect socket */
1610 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1613 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1617 /* register socket fd */
1618 memset(&socket_fd, 0, sizeof(socket_fd));
1619 socket_fd.fd = lcr_sock;
1620 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1622 /* enque hello message */
1623 memset(¶m, 0, sizeof(param));
1624 strcpy(param.hello.application, "asterisk");
1625 send_message(MESSAGE_HELLO, 0, ¶m);
1630 void close_socket(void)
1632 struct admin_list *admin, *temp;
1634 unregister_fd(&socket_fd);
1636 /* flush pending messages */
1637 admin = admin_first;
1640 admin = admin->next;
1653 /* sending queue to asterisk */
1654 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1658 read(wake_pipe[0], &byte, 1);
1665 static void handle_queue()
1667 struct chan_call *call;
1668 struct ast_channel *ast;
1669 struct ast_frame fr;
1675 p = call->queue_string;
1678 if (ast_channel_trylock(ast)) {
1679 ast_mutex_unlock(&chan_lock);
1681 ast_mutex_lock(&chan_lock);
1687 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1688 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1691 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1692 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1695 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1696 ast_queue_control(ast, AST_CONTROL_RINGING);
1697 ast_setstate(ast, AST_STATE_RINGING);
1700 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1701 ast_queue_control(ast, AST_CONTROL_ANSWER);
1704 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1705 ast_queue_hangup(ast);
1707 case '1': case '2': case '3': case 'A':
1708 case '4': case '5': case '6': case 'B':
1709 case '7': case '8': case '9': case 'C':
1710 case '*': case '0': case '#': case 'D':
1711 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1712 /* send digit to asterisk */
1713 memset(&fr, 0, sizeof(fr));
1715 #ifdef LCR_FOR_ASTERISK
1716 fr.frametype = AST_FRAME_DTMF_BEGIN;
1719 #ifdef LCR_FOR_CALLWEAVER
1720 fr.frametype = AST_FRAME_DTMF;
1724 fr.delivery = ast_tv(0, 0);
1725 ast_queue_frame(ast, &fr);
1727 #ifdef LCR_FOR_ASTERISK
1728 fr.frametype = AST_FRAME_DTMF_END;
1729 ast_queue_frame(ast, &fr);
1734 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1738 call->queue_string[0] = '\0';
1739 ast_channel_unlock(ast);
1745 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1747 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1748 if (open_socket() < 0)
1749 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1754 void lock_chan(void)
1756 ast_mutex_lock(&chan_lock);
1759 void unlock_chan(void)
1761 ast_mutex_unlock(&chan_lock);
1764 /* chan_lcr thread */
1765 static void *chan_thread(void *arg)
1767 if (pipe(wake_pipe) < 0) {
1768 CERROR(NULL, NULL, "Failed to open pipe.\n");
1771 memset(&wake_fd, 0, sizeof(wake_fd));
1772 wake_fd.fd = wake_pipe[0];
1773 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1775 memset(&socket_retry, 0, sizeof(socket_retry));
1776 add_timer(&socket_retry, handle_retry, NULL, 0);
1778 bchannel_pid = getpid();
1780 /* open socket the first time */
1781 handle_retry(NULL, NULL, 0);
1783 ast_mutex_lock(&chan_lock);
1787 select_main(0, &global_change, lock_chan, unlock_chan);
1792 del_timer(&socket_retry);
1794 unregister_fd(&wake_fd);
1795 close(wake_pipe[0]);
1796 close(wake_pipe[1]);
1798 CERROR(NULL, NULL, "Thread exit.\n");
1800 ast_mutex_unlock(&chan_lock);
1806 * new asterisk instance
1809 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1811 char exten[256], *dial, *interface, *opt;
1812 struct ast_channel *ast;
1813 struct chan_call *call;
1815 ast_mutex_lock(&chan_lock);
1816 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1818 /* if socket is closed */
1820 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1821 ast_mutex_unlock(&chan_lock);
1825 /* create call instance */
1826 call = alloc_call();
1828 /* failed to create instance */
1829 ast_mutex_unlock(&chan_lock);
1833 /* create asterisk channel instrance */
1835 #ifdef LCR_FOR_ASTERISK
1836 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1839 #ifdef LCR_FOR_CALLWEAVER
1840 ast = ast_channel_alloc(1);
1844 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1846 /* failed to create instance */
1847 ast_mutex_unlock(&chan_lock);
1850 ast->tech = &lcr_tech;
1851 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1852 /* configure channel */
1853 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1854 ast->readformat = ast->rawreadformat = ast->nativeformats;
1855 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1857 ast->hangupcause = 0;
1861 ast->tech_pvt = call;
1862 ast->fds[0] = call->pipe[0];
1863 call->pbx_started = 0;
1865 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1868 * Extract interface, dialstring, options from data.
1871 * <interface>/<dialstring>
1872 * <interface>/<dialstring>/options
1874 strncpy(exten, (char *)data, sizeof(exten)-1);
1875 exten[sizeof(exten)-1] = '\0';
1876 if ((dial = strchr(exten, '/'))) {
1879 if ((opt = strchr(dial, '/')))
1888 strncpy(call->interface, interface, sizeof(call->interface)-1);
1889 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1890 apply_opt(call, (char *)opt);
1892 ast_mutex_unlock(&chan_lock);
1897 * call from asterisk
1899 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1901 union parameter newparam;
1902 struct chan_call *call;
1904 ast_mutex_lock(&chan_lock);
1905 call = ast->tech_pvt;
1907 #ifdef LCR_FOR_CALLWEAVER
1909 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1913 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1914 ast_mutex_unlock(&chan_lock);
1918 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1920 /* pbx process is started */
1921 call->pbx_started = 1;
1922 /* send MESSAGE_NEWREF */
1923 memset(&newparam, 0, sizeof(union parameter));
1924 newparam.newref.direction = 0; /* request from app */
1925 if (!strcmp(call->interface, "pbx"))
1926 newparam.newref.mode = 1;
1927 send_message(MESSAGE_NEWREF, 0, &newparam);
1929 /* set hdlc if capability requires hdlc */
1930 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1931 || ast->transfercapability == INFO_BC_DATARESTRICTED
1932 || ast->transfercapability == INFO_BC_VIDEO)
1934 /* if hdlc is forced by option, we change transcap to data */
1936 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1937 && ast->transfercapability != INFO_BC_DATARESTRICTED
1938 && ast->transfercapability != INFO_BC_VIDEO)
1939 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1941 call->cid_num[0] = 0;
1942 call->cid_name[0] = 0;
1943 call->cid_rdnis[0] = 0;
1945 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1946 strncpy(call->cid_num, ast->cid.cid_num,
1947 sizeof(call->cid_num)-1);
1949 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1950 strncpy(call->cid_name, ast->cid.cid_name,
1951 sizeof(call->cid_name)-1);
1952 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1953 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1954 sizeof(call->cid_rdnis)-1);
1956 ast_mutex_unlock(&chan_lock);
1960 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1962 static const char* dtmf_tones[] = {
1963 "!941+1336/100,!0/100", /* 0 */
1964 "!697+1209/100,!0/100", /* 1 */
1965 "!697+1336/100,!0/100", /* 2 */
1966 "!697+1477/100,!0/100", /* 3 */
1967 "!770+1209/100,!0/100", /* 4 */
1968 "!770+1336/100,!0/100", /* 5 */
1969 "!770+1477/100,!0/100", /* 6 */
1970 "!852+1209/100,!0/100", /* 7 */
1971 "!852+1336/100,!0/100", /* 8 */
1972 "!852+1477/100,!0/100", /* 9 */
1973 "!697+1633/100,!0/100", /* A */
1974 "!770+1633/100,!0/100", /* B */
1975 "!852+1633/100,!0/100", /* C */
1976 "!941+1633/100,!0/100", /* D */
1977 "!941+1209/100,!0/100", /* * */
1978 "!941+1477/100,!0/100" }; /* # */
1980 if (digit >= '0' && digit <='9')
1981 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1982 else if (digit >= 'A' && digit <= 'D')
1983 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1984 else if (digit == '*')
1985 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1986 else if (digit == '#')
1987 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1990 CDEBUG(NULL, ast, "Unable to handle DTMF tone "
1991 "'%c' for '%s'\n", digit, ast->name);
1995 #ifdef LCR_FOR_ASTERISK
1996 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1998 #ifdef LCR_FOR_CALLWEAVER
1999 static int lcr_digit(struct ast_channel *ast, char digit)
2002 struct chan_call *call;
2003 union parameter newparam;
2006 #ifdef LCR_FOR_CALLWEAVER
2007 int inband_dtmf = 0;
2010 /* only pass IA5 number space */
2011 if (digit > 126 || digit < 32)
2014 ast_mutex_lock(&chan_lock);
2015 call = ast->tech_pvt;
2017 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2018 ast_mutex_unlock(&chan_lock);
2022 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2024 /* send information or queue them */
2025 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2026 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2027 memset(&newparam, 0, sizeof(union parameter));
2029 newparam.information.keypad[0] = digit;
2030 newparam.information.keypad[1] = '\0';
2032 newparam.information.id[0] = digit;
2033 newparam.information.id[1] = '\0';
2035 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2038 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2039 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2041 strncat(call->dialque, buf, strlen(call->dialque)-1);
2044 ast_mutex_unlock(&chan_lock);
2046 #ifdef LCR_FOR_ASTERISK
2050 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2052 int inband_dtmf = 0;
2053 struct chan_call *call;
2056 ast_mutex_lock(&chan_lock);
2058 call = ast->tech_pvt;
2062 "Received digit from Asterisk, "
2063 "but no call instance exists.\n");
2064 ast_mutex_unlock(&chan_lock);
2068 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2070 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2074 ast_mutex_unlock(&chan_lock);
2077 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2078 send_digit_to_chan(ast, digit);
2084 static int lcr_answer(struct ast_channel *ast)
2086 union parameter newparam;
2087 struct chan_call *call;
2089 ast_mutex_lock(&chan_lock);
2090 call = ast->tech_pvt;
2092 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2093 ast_mutex_unlock(&chan_lock);
2097 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2099 /* copy connectinfo, if bridged */
2100 if (call->bridge_call)
2101 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2102 /* send connect message to lcr */
2103 if (call->state != CHAN_LCR_STATE_CONNECT) {
2104 memset(&newparam, 0, sizeof(union parameter));
2105 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2106 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2107 call->state = CHAN_LCR_STATE_CONNECT;
2110 /* request bchannel */
2111 if (!call->bchannel) {
2112 CDEBUG(call, ast, "Requesting B-channel.\n");
2113 memset(&newparam, 0, sizeof(union parameter));
2114 newparam.bchannel.type = BCHANNEL_REQUEST;
2115 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2118 // memset(&newparam, 0, sizeof(union parameter));
2119 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2121 ast_mutex_unlock(&chan_lock);
2125 static int lcr_hangup(struct ast_channel *ast)
2127 struct chan_call *call;
2128 pthread_t tid = pthread_self();
2130 if (!pthread_equal(tid, chan_tid)) {
2131 ast_mutex_lock(&chan_lock);
2133 call = ast->tech_pvt;
2135 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2136 if (!pthread_equal(tid, chan_tid)) {
2137 ast_mutex_unlock(&chan_lock);
2142 if (!pthread_equal(tid, chan_tid))
2143 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2145 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2147 /* disconnect asterisk, maybe not required */
2148 ast->tech_pvt = NULL;
2152 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2153 if (ast->hangupcause > 0)
2154 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2156 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2159 if (!pthread_equal(tid, chan_tid)) {
2160 ast_mutex_unlock(&chan_lock);
2164 /* ref is not set, due to prepare setup or release */
2165 if (call->state == CHAN_LCR_STATE_RELEASE) {
2166 /* we get the response to our release */
2167 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2170 /* during prepare, we change to release state */
2171 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2172 call->state = CHAN_LCR_STATE_RELEASE;
2176 if (!pthread_equal(tid, chan_tid)) {
2177 ast_mutex_unlock(&chan_lock);
2182 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2184 struct chan_call *call;
2185 struct ast_frame * f = fr;
2188 CDEBUG(NULL, ast, "No subclass\n");
2189 if (!(f->subclass & ast->nativeformats)) {
2191 "Unexpected format. "
2192 "Activating emergency conversion...\n");
2194 ast_set_write_format(ast, f->subclass);
2195 f = (ast->writetrans) ? ast_translate(
2196 ast->writetrans, fr, 0) : fr;
2199 ast_mutex_lock(&chan_lock);
2200 call = ast->tech_pvt;
2202 ast_mutex_unlock(&chan_lock);
2208 if (call->bchannel && f->samples)
2209 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2210 ast_mutex_unlock(&chan_lock);
2218 static struct ast_frame *lcr_read(struct ast_channel *ast)
2220 struct chan_call *call;
2223 ast_mutex_lock(&chan_lock);
2224 call = ast->tech_pvt;
2226 ast_mutex_unlock(&chan_lock);
2229 if (call->pipe[0] > -1) {
2230 if (call->rebuffer && !call->hdlc) {
2231 /* Make sure we have a complete 20ms (160byte) frame */
2232 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2234 call->framepos += len;
2237 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2239 if (len < 0 && errno == EAGAIN) {
2240 ast_mutex_unlock(&chan_lock);
2242 #ifdef LCR_FOR_ASTERISK
2243 return &ast_null_frame;
2246 #ifdef LCR_FOR_CALLWEAVER
2252 close(call->pipe[0]);
2255 ast_mutex_unlock(&chan_lock);
2257 } else if (call->rebuffer && call->framepos < 160) {
2258 /* Not a complete frame, so we send a null-frame */
2259 ast_mutex_unlock(&chan_lock);
2260 return &ast_null_frame;
2264 call->read_fr.frametype = AST_FRAME_VOICE;
2265 call->read_fr.subclass = ast->nativeformats;
2266 if (call->rebuffer) {
2267 call->read_fr.datalen = call->framepos;
2268 call->read_fr.samples = call->framepos;
2271 call->read_fr.datalen = len;
2272 call->read_fr.samples = len;
2274 call->read_fr.delivery = ast_tv(0,0);
2275 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2276 ast_mutex_unlock(&chan_lock);
2278 return &call->read_fr;
2281 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2283 union parameter newparam;
2285 struct chan_call *call;
2286 const struct tone_zone_sound *ts = NULL;
2288 ast_mutex_lock(&chan_lock);
2289 call = ast->tech_pvt;
2291 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2292 ast_mutex_unlock(&chan_lock);
2297 case AST_CONTROL_BUSY:
2298 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2299 ast_setstate(ast, AST_STATE_BUSY);
2300 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2301 /* send message to lcr */
2302 memset(&newparam, 0, sizeof(union parameter));
2303 newparam.disconnectinfo.cause = 17;
2304 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2305 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2307 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2309 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2310 ts = ast_get_indication_tone(ast->zone, "busy");
2313 case AST_CONTROL_CONGESTION:
2314 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2315 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2316 /* send message to lcr */
2317 memset(&newparam, 0, sizeof(union parameter));
2318 newparam.disconnectinfo.cause = ast->hangupcause;
2319 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2320 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2322 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2324 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2325 ts = ast_get_indication_tone(ast->zone, "congestion");
2328 case AST_CONTROL_PROCEEDING:
2329 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2330 if (call->state == CHAN_LCR_STATE_IN_SETUP
2331 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2332 /* send message to lcr */
2333 memset(&newparam, 0, sizeof(union parameter));
2334 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2336 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2339 case AST_CONTROL_RINGING:
2340 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2341 ast_setstate(ast, AST_STATE_RING);
2342 if (call->state == CHAN_LCR_STATE_IN_SETUP
2343 || call->state == CHAN_LCR_STATE_IN_DIALING
2344 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2345 /* send message to lcr */
2346 memset(&newparam, 0, sizeof(union parameter));
2347 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2349 call->state = CHAN_LCR_STATE_IN_ALERTING;
2351 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2352 ts = ast_get_indication_tone(ast->zone, "ring");
2355 case AST_CONTROL_PROGRESS:
2356 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2357 /* request bchannel */
2358 if (!call->bchannel) {
2359 CDEBUG(call, ast, "Requesting B-channel.\n");
2360 memset(&newparam, 0, sizeof(union parameter));
2361 newparam.bchannel.type = BCHANNEL_REQUEST;
2362 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2366 CDEBUG(call, ast, "Received indicate -1.\n");
2367 ast_playtones_stop(ast);
2371 case AST_CONTROL_VIDUPDATE:
2372 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2375 case AST_CONTROL_HOLD:
2376 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2377 /* send message to lcr */
2378 memset(&newparam, 0, sizeof(union parameter));
2379 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2380 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2382 /*start music onhold*/
2383 #ifdef LCR_FOR_ASTERISK
2384 ast_moh_start(ast,data,ast->musicclass);
2387 #ifdef LCR_FOR_CALLWEAVER
2388 ast_moh_start(ast, NULL);
2393 case AST_CONTROL_UNHOLD:
2394 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2395 /* send message to lcr */
2396 memset(&newparam, 0, sizeof(union parameter));
2397 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2398 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2404 #ifdef AST_CONTROL_SRCUPDATE
2405 case AST_CONTROL_SRCUPDATE:
2409 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2412 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2417 if (ts && ts->data[0]) {
2418 ast_playtones_start(ast, 0, ts->data, 1);
2422 ast_mutex_unlock(&chan_lock);
2429 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2431 struct chan_call *call;
2437 ast_mutex_lock(&chan_lock);
2438 call = ast->tech_pvt;
2440 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2441 ast_mutex_unlock(&chan_lock);
2445 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2447 ast_mutex_unlock(&chan_lock);
2452 * send_text asterisk
2454 static int lcr_send_text(struct ast_channel *ast, const char *text)
2456 struct chan_call *call;
2457 union parameter newparam;
2459 ast_mutex_lock(&chan_lock);
2460 call = ast->tech_pvt;
2462 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2463 ast_mutex_unlock(&chan_lock);
2467 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2468 memset(&newparam, 0, sizeof(union parameter));
2469 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2470 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2471 ast_mutex_unlock(&chan_lock);
2478 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2479 struct ast_channel *ast2, int flags,
2480 struct ast_frame **fo,
2481 struct ast_channel **rc, int timeoutms)
2484 struct chan_call *call1, *call2;
2485 struct ast_channel *carr[2], *who;
2487 struct ast_frame *f;
2490 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2495 /* join via dsp (if the channels are currently open) */
2496 ast_mutex_lock(&chan_lock);
2497 call1 = ast1->tech_pvt;
2498 call2 = ast2->tech_pvt;
2499 if (!call1 || !call2) {
2500 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2501 ast_mutex_unlock(&chan_lock);
2502 return AST_BRIDGE_COMPLETE;
2505 /* join, if both call instances uses dsp
2506 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2508 if (!call1->nodsp && !call2->nodsp) {
2509 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2511 /* get bridge id and join */
2512 bridge_id = new_bridge_id();
2514 call1->bridge_id = bridge_id;
2515 if (call1->bchannel)
2516 bchannel_join(call1->bchannel, bridge_id);
2518 call2->bridge_id = bridge_id;
2519 if (call2->bchannel)
2520 bchannel_join(call2->bchannel, bridge_id);
2522 if (call1->nodsp && call2->nodsp)
2523 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2525 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2526 call1->bridge_call = call2;
2527 call2->bridge_call = call1;
2529 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2530 || call1->state == CHAN_LCR_STATE_IN_DIALING
2531 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2532 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2533 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2536 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2537 || call2->state == CHAN_LCR_STATE_IN_DIALING
2538 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2539 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2540 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2544 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2545 so let's do it for them. Hmpf.
2548 if (call1->on_hold) {
2549 union parameter newparam;
2551 memset(&newparam, 0, sizeof(union parameter));
2552 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2553 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2558 if (call2->on_hold) {
2559 union parameter newparam;
2561 memset(&newparam, 0, sizeof(union parameter));
2562 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2563 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2568 ast_mutex_unlock(&chan_lock);
2572 who = ast_waitfor_n(carr, 2, &to);
2575 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2580 if (!f || f->frametype == AST_FRAME_CONTROL) {
2582 CDEBUG(NULL, NULL, "Got hangup.\n");
2584 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2591 if ( f->frametype == AST_FRAME_DTMF ) {
2592 CDEBUG(NULL, NULL, "Got DTMF.\n");
2608 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2610 /* split channels */
2611 ast_mutex_lock(&chan_lock);
2612 call1 = ast1->tech_pvt;
2613 call2 = ast2->tech_pvt;
2614 if (call1 && call1->bridge_id) {
2615 call1->bridge_id = 0;
2616 if (call1->bchannel)
2617 bchannel_join(call1->bchannel, 0);
2618 if (call1->bridge_call)
2619 call1->bridge_call->bridge_call = NULL;
2621 if (call2 && call1->bridge_id) {
2622 call2->bridge_id = 0;
2623 if (call2->bchannel)
2624 bchannel_join(call2->bchannel, 0);
2625 if (call2->bridge_call)
2626 call2->bridge_call->bridge_call = NULL;
2628 call1->bridge_call = NULL;
2629 call2->bridge_call = NULL;
2631 ast_mutex_unlock(&chan_lock);
2632 return AST_BRIDGE_COMPLETE;
2634 static struct ast_channel_tech lcr_tech = {
2636 .description = "Channel driver for connecting to Linux-Call-Router",
2637 .capabilities = AST_FORMAT_ALAW,
2638 .requester = lcr_request,
2640 #ifdef LCR_FOR_ASTERISK
2641 .send_digit_begin = lcr_digit_begin,
2642 .send_digit_end = lcr_digit_end,
2645 #ifdef LCR_FOR_CALLWEAVER
2646 .send_digit = lcr_digit,
2650 .bridge = lcr_bridge,
2651 .hangup = lcr_hangup,
2652 .answer = lcr_answer,
2655 .indicate = lcr_indicate,
2657 .send_text = lcr_send_text,
2666 static int lcr_show_lcr (int fd, int argc, char *argv[])
2671 static int lcr_show_calls (int fd, int argc, char *argv[])
2676 static int lcr_reload_routing (int fd, int argc, char *argv[])
2681 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2686 static int lcr_port_block (int fd, int argc, char *argv[])
2691 static int lcr_port_unblock (int fd, int argc, char *argv[])
2696 static int lcr_port_unload (int fd, int argc, char *argv[])
2701 static struct ast_cli_entry cli_show_lcr =
2702 { {"lcr", "show", "lcr", NULL},
2704 "Shows current states of LCR core",
2705 "Usage: lcr show lcr\n",
2708 static struct ast_cli_entry cli_show_calls =
2709 { {"lcr", "show", "calls", NULL},
2711 "Shows current calls made by LCR and Asterisk",
2712 "Usage: lcr show calls\n",
2715 static struct ast_cli_entry cli_reload_routing =
2716 { {"lcr", "reload", "routing", NULL},
2718 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2719 "Usage: lcr reload routing\n",
2722 static struct ast_cli_entry cli_reload_interfaces =
2723 { {"lcr", "reload", "interfaces", NULL},
2724 lcr_reload_interfaces,
2725 "Reloads interfaces conf of LCR",
2726 "Usage: lcr reload interfaces\n",
2729 static struct ast_cli_entry cli_port_block =
2730 { {"lcr", "port", "block", NULL},
2732 "Blocks LCR port for further calls",
2733 "Usage: lcr port block \"<port>\"\n",
2736 static struct ast_cli_entry cli_port_unblock =
2737 { {"lcr", "port", "unblock", NULL},
2739 "Unblocks or loads LCR port, port is opened my mISDN",
2740 "Usage: lcr port unblock \"<port>\"\n",
2743 static struct ast_cli_entry cli_port_unload =
2744 { {"lcr", "port", "unload", NULL},
2746 "Unloads LCR port, port is closes by mISDN",
2747 "Usage: lcr port unload \"<port>\"\n",
2752 #ifdef LCR_FOR_ASTERISK
2753 static int lcr_config_exec(struct ast_channel *ast, void *data)
2756 #ifdef LCR_FOR_CALLWEAVER
2757 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2760 struct chan_call *call;
2762 ast_mutex_lock(&chan_lock);
2764 #ifdef LCR_FOR_ASTERISK
2765 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2768 #ifdef LCR_FOR_CALLWEAVER
2769 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2775 if (call->ast == ast)
2781 #ifdef LCR_FOR_ASTERISK
2782 apply_opt(call, (char *)data);
2785 #ifdef LCR_FOR_CALLWEAVER
2786 apply_opt(call, (char *)argv[0]);
2790 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2792 ast_mutex_unlock(&chan_lock);
2797 * module loading and destruction
2799 int load_module(void)
2802 char options_error[256];
2804 for (i = 0; i < 256; i++) {
2805 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2806 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2809 if (read_options(options_error) == 0) {
2810 CERROR(NULL, NULL, "%s", options_error);
2812 #ifdef LCR_FOR_ASTERISK
2813 return AST_MODULE_LOAD_DECLINE;
2816 #ifdef LCR_FOR_CALLWEAVER
2822 ast_mutex_init(&chan_lock);
2823 ast_mutex_init(&log_lock);
2825 if (bchannel_initialize()) {
2826 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2829 #ifdef LCR_FOR_ASTERISK
2830 return AST_MODULE_LOAD_DECLINE;
2833 #ifdef LCR_FOR_CALLWEAVER
2839 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2840 if (ast_channel_register(&lcr_tech)) {
2841 CERROR(NULL, NULL, "Unable to register channel class\n");
2842 bchannel_deinitialize();
2845 #ifdef LCR_FOR_ASTERISK
2846 return AST_MODULE_LOAD_DECLINE;
2849 #ifdef LCR_FOR_CALLWEAVER
2854 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2856 #ifdef LCR_FOR_ASTERISK
2857 "lcr_config(<opt><optarg>:<opt>:...)\n"
2860 #ifdef LCR_FOR_CALLWEAVER
2861 "lcr_config(<opt><optarg>:<opt>:...)\n",
2864 "Sets LCR opts. and optargs\n"
2866 "The available options are:\n"
2867 " d - Send display text on called phone, text is the optarg.\n"
2868 " n - Don't detect dtmf tones on called channel.\n"
2869 " h - Force data call (HDLC).\n"
2870 " t - Disable mISDN_dsp features (required for fax application).\n"
2871 " q - Add queue to make fax stream seamless (required for fax app).\n"
2872 " Use queue size in miliseconds for optarg. (try 250)\n"
2873 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2874 " Use time to detect for optarg.\n"
2875 " c - Make crypted outgoing call, optarg is keyindex.\n"
2876 " e - Perform echo cancelation on this channel.\n"
2877 " Takes mISDN pipeline option as optarg.\n"
2878 " s - Send Non Inband DTMF as inband.\n"
2879 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2880 " vr - rxgain control\n"
2881 " vt - txgain control\n"
2882 " Volume changes at factor 2 ^ optarg.\n"
2883 " k - use keypad to dial this call.\n"
2885 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
2886 " -> use 16 for fax (3.1k audio)\n"
2888 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
2889 "options: \"n:t:q250\" for seamless audio transmission.\n"
2894 ast_cli_register(&cli_show_lcr);
2895 ast_cli_register(&cli_show_calls);
2896 ast_cli_register(&cli_reload_routing);
2897 ast_cli_register(&cli_reload_interfaces);
2898 ast_cli_register(&cli_port_block);
2899 ast_cli_register(&cli_port_unblock);
2900 ast_cli_register(&cli_port_unload);
2904 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2905 /* failed to create thread */
2906 bchannel_deinitialize();
2908 ast_channel_unregister(&lcr_tech);
2910 #ifdef LCR_FOR_ASTERISK
2911 return AST_MODULE_LOAD_DECLINE;
2914 #ifdef LCR_FOR_CALLWEAVER
2922 int unload_module(void)
2924 /* First, take us out of the channel loop */
2925 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2928 pthread_join(chan_tid, NULL);
2930 ast_channel_unregister(&lcr_tech);
2932 ast_unregister_application("lcr_config");
2935 if (mISDN_created) {
2936 bchannel_deinitialize();
2940 if (lcr_sock >= 0) {
2948 int reload_module(void)
2954 #ifdef LCR_FOR_ASTERISK
2955 #define AST_MODULE "chan_lcr"
2958 #ifdef LCR_FOR_CALLWEAVER
2963 ast_mutex_lock(&usecnt_lock);
2965 ast_mutex_unlock(&usecnt_lock);
2970 #ifdef LCR_FOR_ASTERISK
2971 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2972 .load = load_module,
2973 .unload = unload_module,
2974 .reload = reload_module,
2978 #ifdef LCR_FOR_CALLWEAVER
2979 char *description(void)