1 /*****************************************************************************\
3 ** Linux Call Router **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** Asterisk socket client **
10 \*****************************************************************************/
16 To connect, open an LCR socket and send a MESSAGE_HELLO to socket with
17 the application name. This name is unique an can be used for routing calls.
18 Now the channel driver is linked to LCR and can receive and make calls.
21 Call is initiated by LCR:
23 If a call is received from LCR, a MESSAGE_NEWREF is received first.
24 The ref_was_assigned ist set to 1.
25 A new chan_call instance is created. The call reference (ref) is given by
26 the received MESSAGE_NEWREF. The state is CHAN_LCR_STATE_IN_PREPARE.
27 After receiving MESSAGE_SETUP from LCR, the ast_channel instance is created
28 using ast_channel_alloc(1). The setup information is given to asterisk.
29 The new Asterisk instance pointer (ast) is stored to chan_call structure.
30 The state changes to CHAN_LCR_STATE_IN_SETUP.
33 Call is initiated by Asterisk:
35 If a call is requested from Asterisk, a new chan_call instance is created.
36 The new Asterisk instance pointer (ast) is stored to chan_call structure.
37 The current call ref is set to 0, the state is CHAN_LCR_STATE_OUT_PREPARE.
38 If the call is received (lcr_call) A MESSAGE_NEWREF is sent to LCR requesting
39 a new call reference (ref).
40 The ref_was_assigned ist set to 1.
41 Further dialing information is queued.
42 After the new callref is received by special MESSAGE_NEWREF reply, new ref
43 is stored in the chan_call structure.
44 The setup information is sent to LCR using MESSAGE_SETUP.
45 The state changes to CHAN_LCR_STATE_OUT_SETUP.
50 During call process, messages are received and sent.
51 The state changes accordingly.
52 Any message is allowed to be sent to LCR at any time except MESSAGE_RELEASE.
53 If a MESSAGE_OVERLAP is received, further dialing is required.
54 Queued dialing information, if any, is sent to LCR using MESSAGE_DIALING.
55 In this case, the state changes to CHAN_LCR_STATE_OUT_DIALING.
58 Call is released by LCR:
60 A MESSAGE_RELEASE is received with the call reference (ref) to be released.
61 The current ref is set to 0, to indicate released reference.
62 The ref_was_assigned==1 shows that there is no other ref to be assigned.
63 The state changes to CHAN_LCR_STATE_RELEASE.
64 ast_queue_hangup() is called, if asterisk instance (ast) exists, if not,
65 the chan_call instance is destroyed.
66 After lcr_hangup() is called-back by Asterisk, the chan_call instance
67 is destroyed, because the current ref is set to 0 and the state equals
68 CHAN_LCR_STATE_RELEASE.
69 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, see the proceedure
70 "Call is released by Asterisk".
73 Call is released by Asterisk:
75 lcr_hangup() is called-back by Asterisk. If the call reference (ref) is set,
76 a MESSAGE_RELEASE is sent to LCR and the chan_call instance is destroyed.
77 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, the new state is
78 set to CHAN_LCR_STATE_RELEASE.
79 The ref_was_assigned==0 shows that a ref is still requested.
80 Later, if the MESSAGE_NEWREF reply is received, a MESSAGE_RELEASE is sent to
81 LCR and the chan_call instance is destroyed.
82 If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure
83 "Call is released by LCR".
88 The deadlocking problem:
90 - chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel
92 - ast_channel thread locks ast_channel and calls a tech function and waits
93 there for chan_lock to be unlocked.
97 Never call ast_queue_xxxx() if ast_channel is not locked and don't wait until
98 ast_channel can be locked. All messages to asterisk are queued inside call
99 instance and will be handled using a try-lock to get ast_channel lock.
100 If it succeeds to lock ast_channel, the ast_queue_xxxx can safely called even
101 if the lock is incremented and decremented there.
103 Exception: Calling ast_queue_frame inside ast->tech->read is safe, because
104 it is called from ast_channel process which has already locked ast_channel.
109 /* Choose if you want to have chan_lcr for Asterisk 1.4.x or CallWeaver 1.2.x */
110 #define LCR_FOR_ASTERISK
111 /* #define LCR_FOR_CALLWEAVER */
118 #include <sys/types.h>
120 //#include <signal.h>
123 #include <sys/ioctl.h>
124 #include <sys/socket.h>
127 #include <semaphore.h>
129 #define HAVE_ATTRIBUTE_always_inline 1
130 #define HAVE_ARPA_INET_H 1
131 #define HAVE_TIMERSUB 1
132 #define HAVE_STRTOQ 1
133 #define HAVE_INET_ATON 1
135 #include <asterisk/compiler.h>
136 #ifdef LCR_FOR_ASTERISK
137 #include <asterisk/buildopts.h>
139 #include <asterisk/module.h>
140 #include <asterisk/channel.h>
141 #include <asterisk/config.h>
142 #include <asterisk/logger.h>
143 #include <asterisk/pbx.h>
144 #include <asterisk/options.h>
145 #include <asterisk/io.h>
146 #include <asterisk/frame.h>
147 #include <asterisk/translate.h>
148 #include <asterisk/cli.h>
149 #include <asterisk/musiconhold.h>
150 #include <asterisk/dsp.h>
151 #include <asterisk/translate.h>
152 #include <asterisk/file.h>
153 #ifdef LCR_FOR_ASTERISK
154 #include <asterisk/callerid.h>
156 #ifdef LCR_FOR_CALLWEAVER
157 #include <asterisk/phone_no_utils.h>
160 #include <asterisk/indications.h>
161 #include <asterisk/app.h>
162 #include <asterisk/features.h>
163 #include <asterisk/sched.h>
165 #include "extension.h"
167 #include "callerid.h"
168 #include "lcrsocket.h"
171 #include "bchannel.h"
173 #include "chan_lcr.h"
175 CHAN_LCR_STATE // state description structure
176 MESSAGES // message text
178 #ifdef LCR_FOR_CALLWEAVER
179 AST_MUTEX_DEFINE_STATIC(rand_lock);
182 unsigned char flip_bits[256];
184 #ifdef LCR_FOR_CALLWEAVER
185 static struct ast_frame nullframe = { AST_FRAME_NULL, };
191 char lcr_type[]="lcr";
193 #ifdef LCR_FOR_CALLWEAVER
194 static ast_mutex_t usecnt_lock;
196 static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
200 ast_mutex_t chan_lock; /* global lock */
201 ast_mutex_t log_lock; /* logging log */
203 * used to indicate change in file descriptors, so select function's result may
206 int global_change = 0;
209 struct lcr_fd wake_fd;
213 int glob_channel = 0;
216 struct lcr_fd socket_fd;
217 struct lcr_timer socket_retry;
220 struct admin_list *next;
221 struct admin_message msg;
222 } *admin_first = NULL;
224 static struct ast_channel_tech lcr_tech;
229 void chan_lcr_log(int type, const char *file, int line, const char *function, struct chan_call *call, struct ast_channel *ast, const char *fmt, ...)
232 char call_text[128] = "NULL";
233 char ast_text[128] = "NULL";
236 ast_mutex_lock(&log_lock);
239 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
240 buffer[sizeof(buffer)-1]=0;
244 sprintf(call_text, "%d", call->ref);
246 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
247 ast_text[sizeof(ast_text)-1] = '\0';
249 ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
251 ast_mutex_unlock(&log_lock);
255 * channel and call instances
257 struct chan_call *call_first;
261 * special case: 0: find new ref, that has not been assigned a ref yet
264 struct chan_call *find_call_ref(unsigned int ref)
266 struct chan_call *call = call_first;
267 int assigned = (ref > 0);
270 if (call->ref == ref && call->ref_was_assigned == assigned)
277 void free_call(struct chan_call *call)
279 struct chan_call **temp = &call_first;
283 *temp = (*temp)->next;
284 if (call->pipe[0] > -1)
285 close(call->pipe[0]);
286 if (call->pipe[1] > -1)
287 close(call->pipe[1]);
288 if (call->bchannel) {
289 if (call->bchannel->call != call)
290 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
291 call->bchannel->call = NULL;
293 if (call->bridge_call) {
294 if (call->bridge_call->bridge_call != call)
295 CERROR(call, NULL, "Linked call structure has no link to us.\n");
296 call->bridge_call->bridge_call = NULL;
299 ast_translator_free_path(call->trans);
301 ast_dsp_free(call->dsp);
302 CDEBUG(call, NULL, "Call instance freed.\n");
307 temp = &((*temp)->next);
309 CERROR(call, NULL, "Call instance not found in list.\n");
312 struct chan_call *alloc_call(void)
314 struct chan_call **callp = &call_first;
317 callp = &((*callp)->next);
319 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
321 memset(*callp, 0, sizeof(struct chan_call));
322 if (pipe((*callp)->pipe) < 0) {
323 CERROR(*callp, NULL, "Failed to create pipe.\n");
327 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
328 CDEBUG(*callp, NULL, "Call instance allocated.\n");
332 unsigned short new_bridge_id(void)
334 struct chan_call *call;
335 unsigned short id = 1;
337 /* search for lowest bridge id that is not in use and not 0 */
341 if (call->bridge_id == id)
349 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
354 * enque message to LCR
356 int send_message(int message_type, unsigned int ref, union parameter *param)
358 struct admin_list *admin, **adminp;
361 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
364 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
366 adminp = &admin_first;
368 adminp = &((*adminp)->next);
369 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
371 CERROR(NULL, NULL, "No memory for message to LCR.\n");
376 admin->msg.message = ADMIN_MESSAGE;
377 admin->msg.u.msg.type = message_type;
378 admin->msg.u.msg.ref = ref;
379 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
380 socket_fd.when |= LCR_FD_WRITE;
384 write(wake_pipe[1], &byte, 1);
391 * apply options (in locked state)
393 void apply_opt(struct chan_call *call, char *data)
395 union parameter newparam;
396 char string[1024], *p = string, *opt, *key;
402 strncpy(string, data, sizeof(string)-1);
403 string[sizeof(string)-1] = '\0';
406 while((opt = strsep(&p, ":"))) {
409 if (opt[1] == '\0') {
410 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
413 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
414 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
415 strncpy(call->display, opt+1, sizeof(call->display)-1);
417 memset(&newparam, 0, sizeof(union parameter));
418 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
419 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
423 if (opt[1] != '\0') {
424 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
427 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
428 if (call->dsp_dtmf) {
431 bchannel_dtmf(call->bchannel, 0);
435 if (opt[1] == '\0') {
436 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
440 /* check for 0xXXXX... type of key */
441 if (!!strncmp((char *)key, "0x", 2)) {
442 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
446 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
447 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
452 if (*key>='0' && *key<='9')
453 call->bf_key[i] = (*key-'0') << 8;
454 else if (*key>='a' && *key<='f')
455 call->bf_key[i] = (*key-'a'+10) << 8;
456 else if (*key>='A' && *key<='F')
457 call->bf_key[i] = (*key-'A'+10) << 8;
461 if (*key>='0' && *key<='9')
462 call->bf_key[i] += (*key - '0');
463 else if (*key>='a' && *key<='f')
464 call->bf_key[i] += (*key - 'a' + 10);
465 else if (*key>='A' && *key<='F')
466 call->bf_key[i] += (*key - 'A' + 10);
473 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
477 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
479 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
482 if (opt[1] != '\0') {
483 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
486 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
491 if (opt[1] != '\0') {
492 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
495 CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
500 if (opt[1] == '\0') {
501 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
504 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
505 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
507 bchannel_pipeline(call->bchannel, call->pipeline);
510 if (opt[1] == '\0') {
511 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
514 call->faxdetect=atoi(opt+1);
516 call->dsp=ast_dsp_new();
518 #ifdef LCR_FOR_CALLWEAVER
519 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
521 #ifdef LCR_FOR_ASTERISK
522 #ifdef DSP_FEATURE_DTMF_DETECT
523 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
525 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
530 #ifdef LCR_FOR_CALLWEAVER
531 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
533 #ifdef LCR_FOR_ASTERISK
534 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
537 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
540 if (opt[1] != '\0') {
541 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
544 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
549 if (opt[1] != '\0') {
550 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
553 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
554 call->inband_dtmf = 1;
557 if (opt[1] != 'r' && opt[1] != 't') {
558 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
562 if (gain < -8 || gain >8) {
563 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
566 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
568 call->rx_gain = gain;
570 bchannel_gain(call->bchannel, call->rx_gain, 0);
572 call->tx_gain = gain;
574 bchannel_gain(call->bchannel, call->tx_gain, 1);
578 if (opt[1] != '\0') {
579 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
582 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
587 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
591 /* re-open, if bchannel is created */
592 if (call->bchannel && call->bchannel->b_sock > -1) {
593 bchannel_destroy(call->bchannel);
594 if (bchannel_create(call->bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0)))
595 bchannel_activate(call->bchannel, 1);
600 * send setup info to LCR
601 * this function is called, when asterisk call is received and ref is received
603 static void send_setup_to_lcr(struct chan_call *call)
605 union parameter newparam;
606 struct ast_channel *ast = call->ast;
608 if (!call->ast || !call->ref)
611 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
613 /* send setup message to LCR */
614 memset(&newparam, 0, sizeof(union parameter));
615 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
616 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
618 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
620 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
621 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
622 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
623 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
624 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
625 call->display[0] = '\0';
626 if (call->cid_num[0])
627 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
628 if (call->cid_name[0])
629 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
630 if (call->cid_rdnis[0]) {
631 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
632 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
633 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
635 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
636 case AST_PRES_RESTRICTED:
637 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
639 case AST_PRES_UNAVAILABLE:
640 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
642 case AST_PRES_ALLOWED:
644 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
646 switch(ast->cid.cid_ton) {
648 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
651 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
654 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
657 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
659 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
660 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
662 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
664 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
665 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
667 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
668 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
669 send_message(MESSAGE_SETUP, call->ref, &newparam);
671 /* change to outgoing setup state */
672 call->state = CHAN_LCR_STATE_OUT_SETUP;
676 * send dialing info to LCR
677 * this function is called, when setup acknowledge is received and dialing
680 static void send_dialque_to_lcr(struct chan_call *call)
682 union parameter newparam;
684 if (!call->ast || !call->ref || !call->dialque[0])
687 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
689 /* send setup message to LCR */
690 memset(&newparam, 0, sizeof(union parameter));
692 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
694 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
695 call->dialque[0] = '\0';
696 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
700 * in case of a bridge, the unsupported message can be forwarded directly
701 * to the remote call.
703 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
707 if (!call->bridge_call) return;
708 CDEBUG(call, NULL, "Sending message due bridging.\n");
709 send_message(message_type, call->bridge_call->ref, param);
713 * send release message to LCR and import bchannel if exported
715 static void send_release_and_import(struct chan_call *call, int cause, int location)
717 union parameter newparam;
719 /* importing channel */
720 if (call->bchannel) {
721 memset(&newparam, 0, sizeof(union parameter));
722 newparam.bchannel.type = BCHANNEL_RELEASE;
723 newparam.bchannel.handle = call->bchannel->handle;
724 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
726 /* sending release */
727 memset(&newparam, 0, sizeof(union parameter));
728 newparam.disconnectinfo.cause = cause;
729 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
730 send_message(MESSAGE_RELEASE, call->ref, &newparam);
734 * check if extension matches and start asterisk
735 * if it can match, proceed
738 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
741 union parameter newparam;
742 char *exten = ast->exten;
746 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
750 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
751 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
755 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
756 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);
760 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
761 /* send setup acknowledge to lcr */
762 memset(&newparam, 0, sizeof(union parameter));
763 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
766 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
771 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
772 /* send setup acknowledge to lcr */
773 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
774 memset(&newparam, 0, sizeof(union parameter));
775 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
779 call->state = CHAN_LCR_STATE_IN_DIALING;
781 /* if match, start pbx */
782 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
783 CDEBUG(call, ast, "Extensions matches.\n");
788 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
794 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
802 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
803 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
805 /* release asterisk */
806 ast->hangupcause = call->cause;
807 /* change to release state */
808 call->state = CHAN_LCR_STATE_RELEASE;
809 ast_hangup(ast); // call will be destroyed here
813 /* send setup to asterisk */
814 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
816 #ifdef LCR_FOR_CALLWEAVER
818 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
821 ret = ast_pbx_start(ast);
823 cause = (ret==-2)?34:27;
826 call->pbx_started = 1;
827 ast_setstate(ast, AST_STATE_RING);
831 * incoming setup from LCR
833 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
835 struct ast_channel *ast;
837 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
839 /* create asterisk channel instrance */
841 #ifdef LCR_FOR_CALLWEAVER
842 ast = ast_channel_alloc(1);
845 #ifdef LCR_FOR_ASTERISK
846 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
851 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
852 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
859 ast->tech_pvt = call;
860 ast->tech = &lcr_tech;
861 ast->fds[0] = call->pipe[0];
863 /* fill setup information */
864 if (param->setup.dialinginfo.id)
865 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
866 if (param->setup.context[0])
867 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
869 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
870 if (param->setup.callerinfo.id[0])
871 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
872 if (param->setup.callerinfo.name[0])
873 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
874 if (param->setup.redirinfo.id[0])
875 ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
876 switch (param->setup.callerinfo.present) {
877 case INFO_PRESENT_ALLOWED:
878 ast->cid.cid_pres = AST_PRES_ALLOWED;
880 case INFO_PRESENT_RESTRICTED:
881 ast->cid.cid_pres = AST_PRES_RESTRICTED;
884 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
886 switch (param->setup.callerinfo.ntype) {
887 case INFO_NTYPE_SUBSCRIBER:
888 ast->cid.cid_ton = 4;
890 case INFO_NTYPE_NATIONAL:
891 ast->cid.cid_ton = 2;
893 case INFO_NTYPE_INTERNATIONAL:
894 ast->cid.cid_ton = 1;
897 ast->cid.cid_ton = 0;
899 ast->transfercapability = param->setup.capainfo.bearer_capa;
900 /* enable hdlc if transcap is data */
901 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
903 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
905 /* configure channel */
906 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
907 ast->readformat = ast->rawreadformat = ast->nativeformats;
908 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
910 ast->hangupcause = 0;
913 call->state = CHAN_LCR_STATE_IN_SETUP;
915 if (!call->pbx_started)
916 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
920 * incoming setup acknowledge from LCR
922 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
924 if (!call->ast) return;
926 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
928 /* send pending digits in dialque */
929 if (call->dialque[0])
930 send_dialque_to_lcr(call);
931 /* change to overlap state */
932 call->state = CHAN_LCR_STATE_OUT_DIALING;
936 * incoming proceeding from LCR
938 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
940 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
943 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
944 /* queue event for asterisk */
945 if (call->ast && call->pbx_started) {
949 write(wake_pipe[1], &byte, 1);
951 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
957 * incoming alerting from LCR
959 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
961 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
964 call->state = CHAN_LCR_STATE_OUT_ALERTING;
965 /* queue event to asterisk */
966 if (call->ast && call->pbx_started) {
970 write(wake_pipe[1], &byte, 1);
972 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
977 * incoming connect from LCR
979 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
981 union parameter newparam;
983 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
986 call->state = CHAN_LCR_STATE_CONNECT;
987 /* request bchannel */
988 if (!call->bchannel) {
989 CDEBUG(call, call->ast, "Requesting B-channel.\n");
990 memset(&newparam, 0, sizeof(union parameter));
991 newparam.bchannel.type = BCHANNEL_REQUEST;
992 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
994 /* copy connectinfo */
995 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
996 /* queue event to asterisk */
997 if (call->ast && call->pbx_started) {
1001 write(wake_pipe[1], &byte, 1);
1003 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1008 * incoming disconnect from LCR
1010 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1012 struct ast_channel *ast = call->ast;
1014 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1017 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1019 call->cause = param->disconnectinfo.cause;
1020 call->location = param->disconnectinfo.location;
1021 /* if bridge, forward disconnect and return */
1024 if (call->bridge_call) {
1025 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1026 bridge_message_if_bridged(call, message_type, param);
1030 /* release lcr with same cause */
1031 send_release_and_import(call, call->cause, call->location);
1033 /* change to release state */
1034 call->state = CHAN_LCR_STATE_RELEASE;
1035 /* queue release asterisk */
1037 ast->hangupcause = call->cause;
1038 if (call->pbx_started) {
1042 write(wake_pipe[1], &byte, 1);
1044 strcpy(call->queue_string, "H"); // overwrite other indications
1046 ast_hangup(ast); // call will be destroyed here
1052 * incoming release from LCR
1054 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1056 struct ast_channel *ast = call->ast;
1058 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1062 /* change to release state */
1063 call->state = CHAN_LCR_STATE_RELEASE;
1064 /* copy release info */
1066 call->cause = param->disconnectinfo.cause;
1067 call->location = param->disconnectinfo.location;
1069 /* if we have an asterisk instance, queue hangup, else we are done */
1071 ast->hangupcause = call->cause;
1072 if (call->pbx_started) {
1076 write(wake_pipe[1], &byte, 1);
1078 strcpy(call->queue_string, "H");
1080 ast_hangup(ast); // call will be destroyed here
1089 * incoming information from LCR
1091 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1093 struct ast_channel *ast = call->ast;
1095 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1099 /* pbx not started */
1100 if (!call->pbx_started) {
1101 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1102 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1103 lcr_start_pbx(call, ast, param->information.sending_complete);
1107 /* change dailing state after setup */
1108 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1109 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1110 call->state = CHAN_LCR_STATE_IN_DIALING;
1111 // ast_setstate(ast, AST_STATE_DIALING);
1115 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1119 write(wake_pipe[1], &byte, 1);
1121 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1124 /* use bridge to forware message not supported by asterisk */
1125 if (call->state == CHAN_LCR_STATE_CONNECT) {
1126 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1127 bridge_message_if_bridged(call, message_type, param);
1132 * incoming information from LCR
1134 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1136 union parameter newparam;
1138 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1140 /* request bchannel, if call is resumed and we don't have it */
1141 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1142 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1143 memset(&newparam, 0, sizeof(union parameter));
1144 newparam.bchannel.type = BCHANNEL_REQUEST;
1145 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1148 if (!call->ast) return;
1150 /* use bridge to forware message not supported by asterisk */
1151 bridge_message_if_bridged(call, message_type, param);
1155 * incoming information from LCR
1157 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1159 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1161 if (!call->ast) return;
1163 /* use bridge to forware message not supported by asterisk */
1164 bridge_message_if_bridged(call, message_type, param);
1168 * incoming pattern from LCR
1170 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1172 union parameter newparam;
1174 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1176 if (!call->ast) return;
1178 /* pattern are indicated only once */
1179 if (call->has_pattern)
1181 call->has_pattern = 1;
1183 /* request bchannel */
1184 if (!call->bchannel) {
1185 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1186 memset(&newparam, 0, sizeof(union parameter));
1187 newparam.bchannel.type = BCHANNEL_REQUEST;
1188 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1190 /* queue PROGRESS, because tones are available */
1191 if (call->ast && call->pbx_started) {
1195 write(wake_pipe[1], &byte, 1);
1197 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1202 * got dtmf from bchannel (locked state)
1204 void lcr_in_dtmf(struct chan_call *call, int val)
1206 struct ast_channel *ast = call->ast;
1211 if (!call->pbx_started)
1214 if (!call->dsp_dtmf) {
1215 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1219 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1225 write(wake_pipe[1], &byte, 1);
1227 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1231 * message received from LCR
1233 int receive_message(int message_type, unsigned int ref, union parameter *param)
1235 struct bchannel *bchannel;
1236 struct chan_call *call;
1237 union parameter newparam;
1239 memset(&newparam, 0, sizeof(union parameter));
1241 /* handle bchannel message*/
1242 if (message_type == MESSAGE_BCHANNEL) {
1243 switch(param->bchannel.type) {
1244 case BCHANNEL_ASSIGN:
1245 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1246 if ((bchannel = find_bchannel_handle(param->bchannel.handle))) {
1247 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1250 /* create bchannel */
1251 bchannel = alloc_bchannel(param->bchannel.handle);
1253 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1257 /* configure channel */
1258 bchannel->b_tx_gain = param->bchannel.tx_gain;
1259 bchannel->b_rx_gain = param->bchannel.rx_gain;
1260 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1261 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) {
1262 bchannel->b_bf_len = param->bchannel.crypt_len;
1263 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1265 bchannel->b_txdata = 0;
1266 bchannel->b_tx_dejitter = 1;
1268 /* in case, ref is not set, this bchannel instance must
1269 * be created until it is removed again by LCR */
1271 call = find_call_ref(ref);
1273 bchannel->call = call;
1274 call->bchannel = bchannel;
1276 bchannel_dtmf(bchannel, 1);
1278 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1279 if (call->pipeline[0])
1280 bchannel_pipeline(bchannel, call->pipeline);
1282 bchannel_gain(bchannel, call->rx_gain, 0);
1284 bchannel_gain(bchannel, call->tx_gain, 1);
1285 if (call->bridge_id) {
1286 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1287 bchannel_join(bchannel, call->bridge_id);
1289 /* create only, if call exists, othewhise it bchannel is freed below... */
1290 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0)))
1291 bchannel_activate(bchannel, 1);
1294 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1295 newparam.bchannel.handle = param->bchannel.handle;
1296 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1297 /* if call has released before bchannel is assigned */
1299 newparam.bchannel.type = BCHANNEL_RELEASE;
1300 newparam.bchannel.handle = param->bchannel.handle;
1301 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1306 case BCHANNEL_REMOVE:
1307 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1308 if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) {
1309 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1312 /* unklink from call and destroy bchannel */
1313 free_bchannel(bchannel);
1316 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1317 newparam.bchannel.handle = param->bchannel.handle;
1318 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1323 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1328 /* handle new ref */
1329 if (message_type == MESSAGE_NEWREF) {
1330 if (param->direction) {
1331 /* new ref from lcr */
1332 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1333 if (!ref || find_call_ref(ref)) {
1334 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1337 /* allocate new call instance */
1338 call = alloc_call();
1340 call->state = CHAN_LCR_STATE_IN_PREPARE;
1343 call->ref_was_assigned = 1;
1344 /* set dtmf (default, use option 'n' to disable */
1346 /* wait for setup (or release from asterisk) */
1348 /* new ref, as requested from this remote application */
1349 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1350 call = find_call_ref(0);
1352 /* send release, if ref does not exist */
1353 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1354 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1359 call->ref_was_assigned = 1;
1360 /* set dtmf (default, use option 'n' to disable */
1362 /* send pending setup info */
1363 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1364 send_setup_to_lcr(call);
1365 /* release if asterisk has signed off */
1366 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1369 send_release_and_import(call, call->cause, call->location);
1371 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1382 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1385 call = find_call_ref(ref);
1387 /* ignore ref that is not used (anymore) */
1388 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1392 /* handle messages */
1393 switch(message_type) {
1395 lcr_in_setup(call, message_type, param);
1398 case MESSAGE_OVERLAP:
1399 lcr_in_overlap(call, message_type, param);
1402 case MESSAGE_PROCEEDING:
1403 lcr_in_proceeding(call, message_type, param);
1406 case MESSAGE_ALERTING:
1407 lcr_in_alerting(call, message_type, param);
1410 case MESSAGE_CONNECT:
1411 lcr_in_connect(call, message_type, param);
1414 case MESSAGE_DISCONNECT:
1415 lcr_in_disconnect(call, message_type, param);
1418 case MESSAGE_RELEASE:
1419 lcr_in_release(call, message_type, param);
1422 case MESSAGE_INFORMATION:
1423 lcr_in_information(call, message_type, param);
1426 case MESSAGE_NOTIFY:
1427 lcr_in_notify(call, message_type, param);
1430 case MESSAGE_FACILITY:
1431 lcr_in_facility(call, message_type, param);
1434 case MESSAGE_PATTERN: // audio available from LCR
1435 if (!call->has_pattern)
1436 lcr_in_pattern(call, message_type, param);
1439 case MESSAGE_NOPATTERN: // audio not available from LCR
1442 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1443 call->audiopath = param->audiopath;
1447 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1454 * release all calls (due to broken socket)
1456 static void release_all_calls(void)
1458 struct chan_call *call;
1463 /* no ast, so we may directly free call */
1465 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1469 /* already in release process */
1470 if (call->state == CHAN_LCR_STATE_RELEASE) {
1474 /* release or queue release */
1476 call->state = CHAN_LCR_STATE_RELEASE;
1477 if (!call->pbx_started) {
1478 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1479 ast_hangup(call->ast); // call will be destroyed here
1482 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1486 write(wake_pipe[1], &byte, 1);
1488 strcpy(call->queue_string, "H");
1492 /* release all bchannels */
1493 while(bchannel_first)
1494 free_bchannel(bchannel_first);
1497 void close_socket(void);
1500 * warning! not thread safe
1501 * returns -1 for socket error, 0 for no work, 1 for work
1503 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1506 struct admin_list *admin;
1507 struct admin_message msg;
1509 if ((what & LCR_FD_READ)) {
1510 /* read from socket */
1511 len = read(lcr_sock, &msg, sizeof(msg));
1513 CERROR(NULL, NULL, "Socket closed.\n");
1515 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1517 release_all_calls();
1518 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1522 if (len != sizeof(msg)) {
1523 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1526 if (msg.message != ADMIN_MESSAGE) {
1527 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1530 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1532 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1537 if ((what & LCR_FD_WRITE)) {
1538 /* write to socket */
1540 socket_fd.when &= ~LCR_FD_WRITE;
1543 admin = admin_first;
1544 len = write(lcr_sock, &admin->msg, sizeof(msg));
1546 CERROR(NULL, NULL, "Socket closed.\n");
1550 if (len != sizeof(msg)) {
1551 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1555 admin_first = admin->next;
1559 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1568 * open and close socket and thread
1570 int open_socket(void)
1573 struct sockaddr_un sock_address;
1574 union parameter param;
1577 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1578 CERROR(NULL, NULL, "Failed to create socket.\n");
1582 /* set socket address and name */
1583 memset(&sock_address, 0, sizeof(sock_address));
1584 sock_address.sun_family = PF_UNIX;
1585 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1587 /* connect socket */
1588 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1591 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1595 /* register socket fd */
1596 memset(&socket_fd, 0, sizeof(socket_fd));
1597 socket_fd.fd = lcr_sock;
1598 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1600 /* enque hello message */
1601 memset(¶m, 0, sizeof(param));
1602 strcpy(param.hello.application, "asterisk");
1603 send_message(MESSAGE_HELLO, 0, ¶m);
1608 void close_socket(void)
1610 struct admin_list *admin, *temp;
1612 unregister_fd(&socket_fd);
1614 /* flush pending messages */
1615 admin = admin_first;
1618 admin = admin->next;
1631 /* sending queue to asterisk */
1632 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1636 read(wake_pipe[0], &byte, 1);
1643 static void handle_queue()
1645 struct chan_call *call;
1646 struct ast_channel *ast;
1647 struct ast_frame fr;
1652 p = call->queue_string;
1655 ast_channel_lock(ast);
1659 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1660 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1663 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1664 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1667 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1668 ast_queue_control(ast, AST_CONTROL_RINGING);
1669 ast_setstate(ast, AST_STATE_RINGING);
1672 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1673 ast_queue_control(ast, AST_CONTROL_ANSWER);
1676 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1677 ast_queue_hangup(ast);
1679 case '1': case '2': case '3': case 'A':
1680 case '4': case '5': case '6': case 'B':
1681 case '7': case '8': case '9': case 'C':
1682 case '*': case '0': case '#': case 'D':
1683 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1684 /* send digit to asterisk */
1685 memset(&fr, 0, sizeof(fr));
1687 #ifdef LCR_FOR_ASTERISK
1688 fr.frametype = AST_FRAME_DTMF_BEGIN;
1691 #ifdef LCR_FOR_CALLWEAVER
1692 fr.frametype = AST_FRAME_DTMF;
1696 fr.delivery = ast_tv(0, 0);
1697 ast_queue_frame(ast, &fr);
1699 #ifdef LCR_FOR_ASTERISK
1700 fr.frametype = AST_FRAME_DTMF_END;
1701 ast_queue_frame(ast, &fr);
1706 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1710 call->queue_string[0] = '\0';
1711 ast_channel_unlock(ast);
1717 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1719 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1720 if (open_socket() < 0)
1721 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1726 void lock_chan(void)
1728 ast_mutex_lock(&chan_lock);
1731 void unlock_chan(void)
1733 ast_mutex_unlock(&chan_lock);
1736 /* chan_lcr thread */
1737 static void *chan_thread(void *arg)
1739 if (pipe(wake_pipe) < 0) {
1740 CERROR(NULL, NULL, "Failed to open pipe.\n");
1743 memset(&wake_fd, 0, sizeof(wake_fd));
1744 wake_fd.fd = wake_pipe[0];
1745 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1747 memset(&socket_retry, 0, sizeof(socket_retry));
1748 add_timer(&socket_retry, handle_retry, NULL, 0);
1750 bchannel_pid = getpid();
1752 /* open socket the first time */
1753 handle_retry(NULL, NULL, 0);
1755 ast_mutex_lock(&chan_lock);
1759 select_main(0, &global_change, lock_chan, unlock_chan);
1764 del_timer(&socket_retry);
1766 unregister_fd(&wake_fd);
1767 close(wake_pipe[0]);
1768 close(wake_pipe[1]);
1770 CERROR(NULL, NULL, "Thread exit.\n");
1772 ast_mutex_unlock(&chan_lock);
1778 * new asterisk instance
1781 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1783 char exten[256], *dial, *interface, *opt;
1784 struct ast_channel *ast;
1785 struct chan_call *call;
1787 ast_mutex_lock(&chan_lock);
1788 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1790 /* if socket is closed */
1792 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1793 ast_mutex_unlock(&chan_lock);
1797 /* create call instance */
1798 call = alloc_call();
1800 /* failed to create instance */
1801 ast_mutex_unlock(&chan_lock);
1805 /* create asterisk channel instrance */
1807 #ifdef LCR_FOR_ASTERISK
1808 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1811 #ifdef LCR_FOR_CALLWEAVER
1812 ast = ast_channel_alloc(1);
1816 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1818 /* failed to create instance */
1819 ast_mutex_unlock(&chan_lock);
1822 ast->tech = &lcr_tech;
1823 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1824 /* configure channel */
1825 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1826 ast->readformat = ast->rawreadformat = ast->nativeformats;
1827 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1829 ast->hangupcause = 0;
1833 ast->tech_pvt = call;
1834 ast->fds[0] = call->pipe[0];
1835 call->pbx_started = 0;
1837 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1840 * Extract interface, dialstring, options from data.
1843 * <interface>/<dialstring>
1844 * <interface>/<dialstring>/options
1846 strncpy(exten, (char *)data, sizeof(exten)-1);
1847 exten[sizeof(exten)-1] = '\0';
1848 if ((dial = strchr(exten, '/'))) {
1851 if ((opt = strchr(dial, '/')))
1860 strncpy(call->interface, interface, sizeof(call->interface)-1);
1861 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1862 apply_opt(call, (char *)opt);
1864 ast_mutex_unlock(&chan_lock);
1869 * call from asterisk
1871 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1873 union parameter newparam;
1874 struct chan_call *call;
1876 ast_mutex_lock(&chan_lock);
1877 call = ast->tech_pvt;
1879 #ifdef LCR_FOR_CALLWEAVER
1881 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1885 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1886 ast_mutex_unlock(&chan_lock);
1890 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1892 /* pbx process is started */
1893 call->pbx_started = 1;
1894 /* send MESSAGE_NEWREF */
1895 memset(&newparam, 0, sizeof(union parameter));
1896 newparam.direction = 0; /* request from app */
1897 send_message(MESSAGE_NEWREF, 0, &newparam);
1899 /* set hdlc if capability requires hdlc */
1900 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1901 || ast->transfercapability == INFO_BC_DATARESTRICTED
1902 || ast->transfercapability == INFO_BC_VIDEO)
1904 /* if hdlc is forced by option, we change transcap to data */
1906 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1907 && ast->transfercapability != INFO_BC_DATARESTRICTED
1908 && ast->transfercapability != INFO_BC_VIDEO)
1909 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1911 call->cid_num[0] = 0;
1912 call->cid_name[0] = 0;
1913 call->cid_rdnis[0] = 0;
1915 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1916 strncpy(call->cid_num, ast->cid.cid_num,
1917 sizeof(call->cid_num)-1);
1919 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1920 strncpy(call->cid_name, ast->cid.cid_name,
1921 sizeof(call->cid_name)-1);
1922 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1923 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1924 sizeof(call->cid_rdnis)-1);
1926 ast_mutex_unlock(&chan_lock);
1930 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1932 static const char* dtmf_tones[] = {
1933 "!941+1336/100,!0/100", /* 0 */
1934 "!697+1209/100,!0/100", /* 1 */
1935 "!697+1336/100,!0/100", /* 2 */
1936 "!697+1477/100,!0/100", /* 3 */
1937 "!770+1209/100,!0/100", /* 4 */
1938 "!770+1336/100,!0/100", /* 5 */
1939 "!770+1477/100,!0/100", /* 6 */
1940 "!852+1209/100,!0/100", /* 7 */
1941 "!852+1336/100,!0/100", /* 8 */
1942 "!852+1477/100,!0/100", /* 9 */
1943 "!697+1633/100,!0/100", /* A */
1944 "!770+1633/100,!0/100", /* B */
1945 "!852+1633/100,!0/100", /* C */
1946 "!941+1633/100,!0/100", /* D */
1947 "!941+1209/100,!0/100", /* * */
1948 "!941+1477/100,!0/100" }; /* # */
1950 if (digit >= '0' && digit <='9')
1951 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1952 else if (digit >= 'A' && digit <= 'D')
1953 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1954 else if (digit == '*')
1955 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1956 else if (digit == '#')
1957 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1960 ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
1961 "'%c' for '%s'\n", digit, ast->name);
1965 #ifdef LCR_FOR_ASTERISK
1966 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1968 #ifdef LCR_FOR_CALLWEAVER
1969 static int lcr_digit(struct ast_channel *ast, char digit)
1972 struct chan_call *call;
1973 union parameter newparam;
1976 #ifdef LCR_FOR_CALLWEAVER
1977 int inband_dtmf = 0;
1980 /* only pass IA5 number space */
1981 if (digit > 126 || digit < 32)
1984 ast_mutex_lock(&chan_lock);
1985 call = ast->tech_pvt;
1987 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
1988 ast_mutex_unlock(&chan_lock);
1992 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
1994 /* send information or queue them */
1995 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
1996 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
1997 memset(&newparam, 0, sizeof(union parameter));
1999 newparam.information.keypad[0] = digit;
2000 newparam.information.keypad[1] = '\0';
2002 newparam.information.id[0] = digit;
2003 newparam.information.id[1] = '\0';
2005 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2008 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2009 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2011 strncat(call->dialque, buf, strlen(call->dialque)-1);
2014 ast_mutex_unlock(&chan_lock);
2016 #ifdef LCR_FOR_ASTERISK
2020 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2022 int inband_dtmf = 0;
2023 struct chan_call *call;
2026 ast_mutex_lock(&chan_lock);
2028 call = ast->tech_pvt;
2032 "Received digit from Asterisk, "
2033 "but no call instance exists.\n");
2034 ast_mutex_unlock(&chan_lock);
2038 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2040 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2044 ast_mutex_unlock(&chan_lock);
2047 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2048 send_digit_to_chan(ast, digit);
2054 static int lcr_answer(struct ast_channel *ast)
2056 union parameter newparam;
2057 struct chan_call *call;
2059 ast_mutex_lock(&chan_lock);
2060 call = ast->tech_pvt;
2062 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2063 ast_mutex_unlock(&chan_lock);
2067 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2069 /* copy connectinfo, if bridged */
2070 if (call->bridge_call)
2071 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2072 /* send connect message to lcr */
2073 if (call->state != CHAN_LCR_STATE_CONNECT) {
2074 memset(&newparam, 0, sizeof(union parameter));
2075 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2076 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2077 call->state = CHAN_LCR_STATE_CONNECT;
2080 /* request bchannel */
2081 if (!call->bchannel) {
2082 CDEBUG(call, ast, "Requesting B-channel.\n");
2083 memset(&newparam, 0, sizeof(union parameter));
2084 newparam.bchannel.type = BCHANNEL_REQUEST;
2085 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2088 // memset(&newparam, 0, sizeof(union parameter));
2089 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2091 ast_mutex_unlock(&chan_lock);
2095 static int lcr_hangup(struct ast_channel *ast)
2097 struct chan_call *call;
2098 pthread_t tid = pthread_self();
2100 if (!pthread_equal(tid, chan_tid))
2101 ast_mutex_lock(&chan_lock);
2102 call = ast->tech_pvt;
2104 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2105 if (!pthread_equal(tid, chan_tid))
2106 ast_mutex_unlock(&chan_lock);
2110 if (!pthread_equal(tid, chan_tid))
2111 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2113 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2115 /* disconnect asterisk, maybe not required */
2116 ast->tech_pvt = NULL;
2120 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2121 if (ast->hangupcause > 0)
2122 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2124 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2127 if (!pthread_equal(tid, chan_tid))
2128 ast_mutex_unlock(&chan_lock);
2131 /* ref is not set, due to prepare setup or release */
2132 if (call->state == CHAN_LCR_STATE_RELEASE) {
2133 /* we get the response to our release */
2134 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2137 /* during prepare, we change to release state */
2138 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2139 call->state = CHAN_LCR_STATE_RELEASE;
2143 if (!pthread_equal(tid, chan_tid))
2144 ast_mutex_unlock(&chan_lock);
2148 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2150 struct chan_call *call;
2153 CDEBUG(NULL, ast, "No subclass\n");
2154 if (!(f->subclass & ast->nativeformats))
2155 CDEBUG(NULL, ast, "Unexpected format.\n");
2157 ast_mutex_lock(&chan_lock);
2158 call = ast->tech_pvt;
2160 ast_mutex_unlock(&chan_lock);
2163 if (call->bchannel && f->samples)
2164 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2165 ast_mutex_unlock(&chan_lock);
2170 static struct ast_frame *lcr_read(struct ast_channel *ast)
2172 struct chan_call *call;
2175 ast_mutex_lock(&chan_lock);
2176 call = ast->tech_pvt;
2178 ast_mutex_unlock(&chan_lock);
2181 if (call->pipe[0] > -1) {
2182 if (call->rebuffer && !call->hdlc) {
2183 /* Make sure we have a complete 20ms (160byte) frame */
2184 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2186 call->framepos += len;
2189 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2191 if (len < 0 && errno == EAGAIN) {
2192 ast_mutex_unlock(&chan_lock);
2194 #ifdef LCR_FOR_ASTERISK
2195 return &ast_null_frame;
2198 #ifdef LCR_FOR_CALLWEAVER
2204 close(call->pipe[0]);
2207 ast_mutex_unlock(&chan_lock);
2209 } else if (call->rebuffer && call->framepos < 160) {
2210 /* Not a complete frame, so we send a null-frame */
2211 ast_mutex_unlock(&chan_lock);
2212 return &ast_null_frame;
2216 call->read_fr.frametype = AST_FRAME_VOICE;
2217 call->read_fr.subclass = ast->nativeformats;
2218 if (call->rebuffer) {
2219 call->read_fr.datalen = call->framepos;
2220 call->read_fr.samples = call->framepos;
2223 call->read_fr.datalen = len;
2224 call->read_fr.samples = len;
2226 call->read_fr.delivery = ast_tv(0,0);
2227 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2228 ast_mutex_unlock(&chan_lock);
2230 return &call->read_fr;
2233 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2235 union parameter newparam;
2237 struct chan_call *call;
2239 ast_mutex_lock(&chan_lock);
2240 call = ast->tech_pvt;
2242 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2243 ast_mutex_unlock(&chan_lock);
2248 case AST_CONTROL_BUSY:
2249 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2250 ast_setstate(ast, AST_STATE_BUSY);
2251 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2252 /* send message to lcr */
2253 memset(&newparam, 0, sizeof(union parameter));
2254 newparam.disconnectinfo.cause = 17;
2255 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2256 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2258 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2261 case AST_CONTROL_CONGESTION:
2262 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2263 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2264 /* send message to lcr */
2265 memset(&newparam, 0, sizeof(union parameter));
2266 newparam.disconnectinfo.cause = ast->hangupcause;
2267 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2268 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2270 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2273 case AST_CONTROL_PROCEEDING:
2274 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2275 if (call->state == CHAN_LCR_STATE_IN_SETUP
2276 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2277 /* send message to lcr */
2278 memset(&newparam, 0, sizeof(union parameter));
2279 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2281 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2284 case AST_CONTROL_RINGING:
2285 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2286 ast_setstate(ast, AST_STATE_RING);
2287 if (call->state == CHAN_LCR_STATE_IN_SETUP
2288 || call->state == CHAN_LCR_STATE_IN_DIALING
2289 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2290 /* send message to lcr */
2291 memset(&newparam, 0, sizeof(union parameter));
2292 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2294 call->state = CHAN_LCR_STATE_IN_ALERTING;
2297 case AST_CONTROL_PROGRESS:
2298 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2299 /* request bchannel */
2300 if (!call->bchannel) {
2301 CDEBUG(call, ast, "Requesting B-channel.\n");
2302 memset(&newparam, 0, sizeof(union parameter));
2303 newparam.bchannel.type = BCHANNEL_REQUEST;
2304 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2308 CDEBUG(call, ast, "Received indicate -1.\n");
2312 case AST_CONTROL_VIDUPDATE:
2313 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2316 case AST_CONTROL_HOLD:
2317 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2318 /* send message to lcr */
2319 memset(&newparam, 0, sizeof(union parameter));
2320 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2321 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2323 /*start music onhold*/
2324 #ifdef LCR_FOR_ASTERISK
2325 ast_moh_start(ast,data,ast->musicclass);
2328 #ifdef LCR_FOR_CALLWEAVER
2329 ast_moh_start(ast, NULL);
2334 case AST_CONTROL_UNHOLD:
2335 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2336 /* send message to lcr */
2337 memset(&newparam, 0, sizeof(union parameter));
2338 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2339 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2345 #ifdef AST_CONTROL_SRCUPDATE
2346 case AST_CONTROL_SRCUPDATE:
2347 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2351 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2357 ast_mutex_unlock(&chan_lock);
2364 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2366 struct chan_call *call;
2372 ast_mutex_lock(&chan_lock);
2373 call = ast->tech_pvt;
2375 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2376 ast_mutex_unlock(&chan_lock);
2380 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2382 ast_mutex_unlock(&chan_lock);
2387 * send_text asterisk
2389 static int lcr_send_text(struct ast_channel *ast, const char *text)
2391 struct chan_call *call;
2392 union parameter newparam;
2394 ast_mutex_lock(&chan_lock);
2395 call = ast->tech_pvt;
2397 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2398 ast_mutex_unlock(&chan_lock);
2402 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2403 memset(&newparam, 0, sizeof(union parameter));
2404 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2405 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2406 ast_mutex_lock(&chan_lock);
2413 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2414 struct ast_channel *ast2, int flags,
2415 struct ast_frame **fo,
2416 struct ast_channel **rc, int timeoutms)
2419 struct chan_call *call1, *call2;
2420 struct ast_channel *carr[2], *who;
2422 struct ast_frame *f;
2425 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2430 /* join via dsp (if the channels are currently open) */
2431 ast_mutex_lock(&chan_lock);
2432 call1 = ast1->tech_pvt;
2433 call2 = ast2->tech_pvt;
2434 if (!call1 || !call2) {
2435 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2436 ast_mutex_unlock(&chan_lock);
2437 return AST_BRIDGE_COMPLETE;
2440 /* join, if both call instances uses dsp
2441 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2443 if (!call1->nodsp && !call2->nodsp) {
2444 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2446 /* get bridge id and join */
2447 bridge_id = new_bridge_id();
2449 call1->bridge_id = bridge_id;
2450 if (call1->bchannel)
2451 bchannel_join(call1->bchannel, bridge_id);
2453 call2->bridge_id = bridge_id;
2454 if (call2->bchannel)
2455 bchannel_join(call2->bchannel, bridge_id);
2457 if (call1->nodsp && call2->nodsp)
2458 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2460 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2461 call1->bridge_call = call2;
2462 call2->bridge_call = call1;
2464 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2465 || call1->state == CHAN_LCR_STATE_IN_DIALING
2466 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2467 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2468 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2471 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2472 || call2->state == CHAN_LCR_STATE_IN_DIALING
2473 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2474 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2475 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2479 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2480 so let's do it for them. Hmpf.
2483 if (call1->on_hold) {
2484 union parameter newparam;
2486 memset(&newparam, 0, sizeof(union parameter));
2487 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2488 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2493 if (call2->on_hold) {
2494 union parameter newparam;
2496 memset(&newparam, 0, sizeof(union parameter));
2497 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2498 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2503 ast_mutex_unlock(&chan_lock);
2507 who = ast_waitfor_n(carr, 2, &to);
2510 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2515 if (!f || f->frametype == AST_FRAME_CONTROL) {
2517 CDEBUG(NULL, NULL, "Got hangup.\n");
2519 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2526 if ( f->frametype == AST_FRAME_DTMF ) {
2527 CDEBUG(NULL, NULL, "Got DTMF.\n");
2543 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2545 /* split channels */
2546 ast_mutex_lock(&chan_lock);
2547 call1 = ast1->tech_pvt;
2548 call2 = ast2->tech_pvt;
2549 if (call1 && call1->bridge_id) {
2550 call1->bridge_id = 0;
2551 if (call1->bchannel)
2552 bchannel_join(call1->bchannel, 0);
2553 if (call1->bridge_call)
2554 call1->bridge_call->bridge_call = NULL;
2556 if (call2 && call1->bridge_id) {
2557 call2->bridge_id = 0;
2558 if (call2->bchannel)
2559 bchannel_join(call2->bchannel, 0);
2560 if (call2->bridge_call)
2561 call2->bridge_call->bridge_call = NULL;
2563 call1->bridge_call = NULL;
2564 call2->bridge_call = NULL;
2566 ast_mutex_unlock(&chan_lock);
2567 return AST_BRIDGE_COMPLETE;
2569 static struct ast_channel_tech lcr_tech = {
2571 .description = "Channel driver for connecting to Linux-Call-Router",
2572 .capabilities = AST_FORMAT_ALAW,
2573 .requester = lcr_request,
2575 #ifdef LCR_FOR_ASTERISK
2576 .send_digit_begin = lcr_digit_begin,
2577 .send_digit_end = lcr_digit_end,
2580 #ifdef LCR_FOR_CALLWEAVER
2581 .send_digit = lcr_digit,
2585 .bridge = lcr_bridge,
2586 .hangup = lcr_hangup,
2587 .answer = lcr_answer,
2590 .indicate = lcr_indicate,
2592 .send_text = lcr_send_text,
2601 static int lcr_show_lcr (int fd, int argc, char *argv[])
2606 static int lcr_show_calls (int fd, int argc, char *argv[])
2611 static int lcr_reload_routing (int fd, int argc, char *argv[])
2616 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2621 static int lcr_port_block (int fd, int argc, char *argv[])
2626 static int lcr_port_unblock (int fd, int argc, char *argv[])
2631 static int lcr_port_unload (int fd, int argc, char *argv[])
2636 static struct ast_cli_entry cli_show_lcr =
2637 { {"lcr", "show", "lcr", NULL},
2639 "Shows current states of LCR core",
2640 "Usage: lcr show lcr\n",
2643 static struct ast_cli_entry cli_show_calls =
2644 { {"lcr", "show", "calls", NULL},
2646 "Shows current calls made by LCR and Asterisk",
2647 "Usage: lcr show calls\n",
2650 static struct ast_cli_entry cli_reload_routing =
2651 { {"lcr", "reload", "routing", NULL},
2653 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2654 "Usage: lcr reload routing\n",
2657 static struct ast_cli_entry cli_reload_interfaces =
2658 { {"lcr", "reload", "interfaces", NULL},
2659 lcr_reload_interfaces,
2660 "Reloads interfaces conf of LCR",
2661 "Usage: lcr reload interfaces\n",
2664 static struct ast_cli_entry cli_port_block =
2665 { {"lcr", "port", "block", NULL},
2667 "Blocks LCR port for further calls",
2668 "Usage: lcr port block \"<port>\"\n",
2671 static struct ast_cli_entry cli_port_unblock =
2672 { {"lcr", "port", "unblock", NULL},
2674 "Unblocks or loads LCR port, port is opened my mISDN",
2675 "Usage: lcr port unblock \"<port>\"\n",
2678 static struct ast_cli_entry cli_port_unload =
2679 { {"lcr", "port", "unload", NULL},
2681 "Unloads LCR port, port is closes by mISDN",
2682 "Usage: lcr port unload \"<port>\"\n",
2687 #ifdef LCR_FOR_ASTERISK
2688 static int lcr_config_exec(struct ast_channel *ast, void *data)
2691 #ifdef LCR_FOR_CALLWEAVER
2692 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2695 struct chan_call *call;
2697 ast_mutex_lock(&chan_lock);
2699 #ifdef LCR_FOR_ASTERISK
2700 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2703 #ifdef LCR_FOR_CALLWEAVER
2704 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2710 if (call->ast == ast)
2716 #ifdef LCR_FOR_ASTERISK
2717 apply_opt(call, (char *)data);
2720 #ifdef LCR_FOR_CALLWEAVER
2721 apply_opt(call, (char *)argv[0]);
2725 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2727 ast_mutex_unlock(&chan_lock);
2732 * module loading and destruction
2734 int load_module(void)
2738 for (i = 0; i < 256; i++) {
2739 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2740 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2743 if (read_options() == 0) {
2744 CERROR(NULL, NULL, "%s", options_error);
2746 #ifdef LCR_FOR_ASTERISK
2747 return AST_MODULE_LOAD_DECLINE;
2750 #ifdef LCR_FOR_CALLWEAVER
2756 ast_mutex_init(&chan_lock);
2757 ast_mutex_init(&log_lock);
2759 if (bchannel_initialize()) {
2760 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2763 #ifdef LCR_FOR_ASTERISK
2764 return AST_MODULE_LOAD_DECLINE;
2767 #ifdef LCR_FOR_CALLWEAVER
2773 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2774 if (ast_channel_register(&lcr_tech)) {
2775 CERROR(NULL, NULL, "Unable to register channel class\n");
2776 bchannel_deinitialize();
2779 #ifdef LCR_FOR_ASTERISK
2780 return AST_MODULE_LOAD_DECLINE;
2783 #ifdef LCR_FOR_CALLWEAVER
2788 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2790 #ifdef LCR_FOR_ASTERISK
2791 "lcr_config(<opt><optarg>:<opt>:...)\n"
2794 #ifdef LCR_FOR_CALLWEAVER
2795 "lcr_config(<opt><optarg>:<opt>:...)\n",
2798 "Sets LCR opts. and optargs\n"
2800 "The available options are:\n"
2801 " d - Send display text on called phone, text is the optarg.\n"
2802 " n - Don't detect dtmf tones on called channel.\n"
2803 " h - Force data call (HDLC).\n"
2804 " t - Disable mISDN_dsp features (required for fax application).\n"
2805 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2806 " Use time to detect for optarg.\n"
2807 " c - Make crypted outgoing call, optarg is keyindex.\n"
2808 " e - Perform echo cancelation on this channel.\n"
2809 " Takes mISDN pipeline option as optarg.\n"
2810 " s - Send Non Inband DTMF as inband.\n"
2811 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2812 " vr - rxgain control\n"
2813 " vt - txgain control\n"
2814 " Volume changes at factor 2 ^ optarg.\n"
2815 " k - use keypad to dial this call.\n"
2820 ast_cli_register(&cli_show_lcr);
2821 ast_cli_register(&cli_show_calls);
2822 ast_cli_register(&cli_reload_routing);
2823 ast_cli_register(&cli_reload_interfaces);
2824 ast_cli_register(&cli_port_block);
2825 ast_cli_register(&cli_port_unblock);
2826 ast_cli_register(&cli_port_unload);
2830 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
2831 /* failed to create thread */
2832 bchannel_deinitialize();
2834 ast_channel_unregister(&lcr_tech);
2836 #ifdef LCR_FOR_ASTERISK
2837 return AST_MODULE_LOAD_DECLINE;
2840 #ifdef LCR_FOR_CALLWEAVER
2848 int unload_module(void)
2850 /* First, take us out of the channel loop */
2851 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2854 pthread_join(chan_tid, NULL);
2856 ast_channel_unregister(&lcr_tech);
2858 ast_unregister_application("lcr_config");
2861 if (mISDN_created) {
2862 bchannel_deinitialize();
2866 if (lcr_sock >= 0) {
2874 int reload_module(void)
2880 #ifdef LCR_FOR_ASTERISK
2881 #define AST_MODULE "chan_lcr"
2884 #ifdef LCR_FOR_CALLWEAVER
2889 ast_mutex_lock(&usecnt_lock);
2891 ast_mutex_unlock(&usecnt_lock);
2896 #ifdef LCR_FOR_ASTERISK
2897 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2898 .load = load_module,
2899 .unload = unload_module,
2900 .reload = reload_module,
2904 #ifdef LCR_FOR_CALLWEAVER
2905 char *description(void)