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"
170 #include "bchannel.h"
172 #include "chan_lcr.h"
174 CHAN_LCR_STATE // state description structure
175 MESSAGES // message text
177 #ifdef LCR_FOR_CALLWEAVER
178 AST_MUTEX_DEFINE_STATIC(rand_lock);
181 unsigned char flip_bits[256];
183 #ifdef LCR_FOR_CALLWEAVER
184 static struct ast_frame nullframe = { AST_FRAME_NULL, };
190 char lcr_type[]="lcr";
192 #ifdef LCR_FOR_CALLWEAVER
193 static ast_mutex_t usecnt_lock;
195 static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
199 ast_mutex_t chan_lock; /* global lock */
200 ast_mutex_t log_lock; /* logging log */
203 int glob_channel = 0;
208 struct admin_list *next;
209 struct admin_message msg;
210 } *admin_first = NULL;
212 static struct ast_channel_tech lcr_tech;
217 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, ...)
220 char call_text[128] = "NULL";
221 char ast_text[128] = "NULL";
224 ast_mutex_lock(&log_lock);
227 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
228 buffer[sizeof(buffer)-1]=0;
232 sprintf(call_text, "%d", call->ref);
234 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
235 ast_text[sizeof(ast_text)-1] = '\0';
237 ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
239 ast_mutex_unlock(&log_lock);
243 * channel and call instances
245 struct chan_call *call_first;
249 * special case: 0: find new ref, that has not been assigned a ref yet
252 struct chan_call *find_call_ref(unsigned int ref)
254 struct chan_call *call = call_first;
255 int assigned = (ref > 0);
259 if (call->ref == ref && call->ref_was_assigned == assigned)
266 void free_call(struct chan_call *call)
268 struct chan_call **temp = &call_first;
274 *temp = (*temp)->next;
275 if (call->pipe[0] > -1)
276 close(call->pipe[0]);
277 if (call->pipe[1] > -1)
278 close(call->pipe[1]);
281 if (call->bchannel->call != call)
282 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
283 call->bchannel->call = NULL;
285 if (call->bridge_call)
287 if (call->bridge_call->bridge_call != call)
288 CERROR(call, NULL, "Linked call structure has no link to us.\n");
289 call->bridge_call->bridge_call = NULL;
292 ast_translator_free_path(call->trans);
294 ast_dsp_free(call->dsp);
295 CDEBUG(call, NULL, "Call instance freed.\n");
299 temp = &((*temp)->next);
301 CERROR(call, NULL, "Call instance not found in list.\n");
304 struct chan_call *alloc_call(void)
306 struct chan_call **callp = &call_first;
309 callp = &((*callp)->next);
311 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
313 memset(*callp, 0, sizeof(struct chan_call));
314 if (pipe((*callp)->pipe) < 0) {
315 CERROR(*callp, NULL, "Failed to create pipe.\n");
319 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
320 CDEBUG(*callp, NULL, "Call instance allocated.\n");
324 unsigned short new_bridge_id(void)
326 struct chan_call *call;
327 unsigned short id = 1;
329 /* search for lowest bridge id that is not in use and not 0 */
335 if (call->bridge_id == id)
343 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
348 * enque message to LCR
350 int send_message(int message_type, unsigned int ref, union parameter *param)
352 struct admin_list *admin, **adminp;
355 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
358 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
360 adminp = &admin_first;
362 adminp = &((*adminp)->next);
363 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
365 CERROR(NULL, NULL, "No memory for message to LCR.\n");
370 admin->msg.message = ADMIN_MESSAGE;
371 admin->msg.u.msg.type = message_type;
372 admin->msg.u.msg.ref = ref;
373 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
379 * apply options (in locked state)
381 void apply_opt(struct chan_call *call, char *data)
383 union parameter newparam;
384 char string[1024], *p = string, *opt, *key;
390 strncpy(string, data, sizeof(string)-1);
391 string[sizeof(string)-1] = '\0';
394 while((opt = strsep(&p, ":")))
398 if (opt[1] == '\0') {
399 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
402 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
403 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
404 strncpy(call->display, opt+1, sizeof(call->display)-1);
406 memset(&newparam, 0, sizeof(union parameter));
407 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
408 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
412 if (opt[1] != '\0') {
413 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
416 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
420 if (opt[1] == '\0') {
421 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
425 /* check for 0xXXXX... type of key */
426 if (!!strncmp((char *)key, "0x", 2)) {
427 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
431 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
432 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
438 if (*key>='0' && *key<='9')
439 call->bf_key[i] = (*key-'0') << 8;
440 else if (*key>='a' && *key<='f')
441 call->bf_key[i] = (*key-'a'+10) << 8;
442 else if (*key>='A' && *key<='F')
443 call->bf_key[i] = (*key-'A'+10) << 8;
447 if (*key>='0' && *key<='9')
448 call->bf_key[i] += (*key - '0');
449 else if (*key>='a' && *key<='f')
450 call->bf_key[i] += (*key - 'a' + 10);
451 else if (*key>='A' && *key<='F')
452 call->bf_key[i] += (*key - 'A' + 10);
459 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
463 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
465 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
468 if (opt[1] != '\0') {
469 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
472 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
477 if (opt[1] != '\0') {
478 CERROR(call, call->ast, "Option 't' (no_dsp) expects no parameter.\n", opt);
481 CDEBUG(call, call->ast, "Option 't' (no dsp).\n");
486 if (opt[1] == '\0') {
487 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
490 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
491 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
493 bchannel_pipeline(call->bchannel, call->pipeline);
496 if (opt[1] == '\0') {
497 CERROR(call, call->ast, "Option 'f' (faxdetect) expects parameter.\n", opt);
500 call->faxdetect=atoi(opt+1);
502 call->dsp=ast_dsp_new();
504 #ifdef LCR_FOR_CALLWEAVER
505 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
507 #ifdef LCR_FOR_ASTERISK
508 #ifdef DSP_FEATURE_DTMF_DETECT
509 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
511 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
516 #ifdef LCR_FOR_CALLWEAVER
517 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
519 #ifdef LCR_FOR_ASTERISK
520 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
523 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
526 if (opt[1] != '\0') {
527 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
530 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
535 if (opt[1] != '\0') {
536 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
539 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
540 call->inband_dtmf = 1;
543 if (opt[1] != 'r' && opt[1] != 't') {
544 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
548 if (gain < -8 || gain >8) {
549 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
552 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
554 call->rx_gain = gain;
556 bchannel_gain(call->bchannel, call->rx_gain, 0);
558 call->tx_gain = gain;
560 bchannel_gain(call->bchannel, call->tx_gain, 1);
564 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
568 /* re-open, if bchannel is created */
569 if (call->bchannel && call->bchannel->b_sock > -1) {
570 bchannel_destroy(call->bchannel);
571 if (bchannel_create(call->bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0)))
572 bchannel_activate(call->bchannel, 1);
577 * send setup info to LCR
578 * this function is called, when asterisk call is received and ref is received
580 static void send_setup_to_lcr(struct chan_call *call)
582 union parameter newparam;
583 struct ast_channel *ast = call->ast;
585 if (!call->ast || !call->ref)
588 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
590 /* send setup message to LCR */
591 memset(&newparam, 0, sizeof(union parameter));
592 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
593 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
594 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
595 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
596 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
597 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
598 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
599 call->display[0] = '\0';
600 if (call->cid_num[0])
601 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
602 if (call->cid_name[0])
603 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
604 if (call->cid_rdnis[0])
606 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
607 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
608 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
610 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION)
612 case AST_PRES_RESTRICTED:
613 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
615 case AST_PRES_UNAVAILABLE:
616 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
618 case AST_PRES_ALLOWED:
620 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
622 switch(ast->cid.cid_ton)
625 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
628 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
631 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
634 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
636 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
637 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
639 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
641 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
642 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
644 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
645 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
646 send_message(MESSAGE_SETUP, call->ref, &newparam);
648 /* change to outgoing setup state */
649 call->state = CHAN_LCR_STATE_OUT_SETUP;
653 * send dialing info to LCR
654 * this function is called, when setup acknowledge is received and dialing
657 static void send_dialque_to_lcr(struct chan_call *call)
659 union parameter newparam;
661 if (!call->ast || !call->ref || !call->dialque[0])
664 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
666 /* send setup message to LCR */
667 memset(&newparam, 0, sizeof(union parameter));
668 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
669 call->dialque[0] = '\0';
670 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
674 * in case of a bridge, the unsupported message can be forwarded directly
675 * to the remote call.
677 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
681 if (!call->bridge_call) return;
682 CDEBUG(call, NULL, "Sending message due bridging.\n");
683 send_message(message_type, call->bridge_call->ref, param);
687 * send release message to LCR and import bchannel if exported
689 static void send_release_and_import(struct chan_call *call, int cause, int location)
691 union parameter newparam;
693 /* importing channel */
694 if (call->bchannel) {
695 memset(&newparam, 0, sizeof(union parameter));
696 newparam.bchannel.type = BCHANNEL_RELEASE;
697 newparam.bchannel.handle = call->bchannel->handle;
698 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
700 /* sending release */
701 memset(&newparam, 0, sizeof(union parameter));
702 newparam.disconnectinfo.cause = cause;
703 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
704 send_message(MESSAGE_RELEASE, call->ref, &newparam);
708 * check if extension matches and start asterisk
709 * if it can match, proceed
712 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
715 union parameter newparam;
716 char *exten = ast->exten;
720 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
725 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad))
727 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
731 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad))
733 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);
737 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
738 /* send setup acknowledge to lcr */
739 memset(&newparam, 0, sizeof(union parameter));
740 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
743 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
748 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad))
750 /* send setup acknowledge to lcr */
751 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
752 memset(&newparam, 0, sizeof(union parameter));
753 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
757 call->state = CHAN_LCR_STATE_IN_DIALING;
759 /* if match, start pbx */
760 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
761 CDEBUG(call, ast, "Extensions matches.\n");
766 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
772 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
780 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
781 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
783 /* release asterisk */
784 ast->hangupcause = call->cause;
785 /* change to release state */
786 call->state = CHAN_LCR_STATE_RELEASE;
787 ast_hangup(ast); // call will be destroyed here
791 /* send setup to asterisk */
792 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
794 #ifdef LCR_FOR_CALLWEAVER
796 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
799 ret = ast_pbx_start(ast);
802 cause = (ret==-2)?34:27;
805 call->pbx_started = 1;
806 ast_setstate(ast, AST_STATE_RING);
810 * incoming setup from LCR
812 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
814 struct ast_channel *ast;
816 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
818 /* create asterisk channel instrance */
820 #ifdef LCR_FOR_CALLWEAVER
821 ast = ast_channel_alloc(1);
824 #ifdef LCR_FOR_ASTERISK
825 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
831 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
832 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
839 ast->tech_pvt = call;
840 ast->tech = &lcr_tech;
841 ast->fds[0] = call->pipe[0];
843 /* fill setup information */
844 if (param->setup.dialinginfo.id)
845 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
846 if (param->setup.context[0])
847 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
849 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
850 if (param->setup.callerinfo.id[0])
851 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
852 if (param->setup.callerinfo.name[0])
853 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
854 if (param->setup.redirinfo.id[0])
855 ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
856 switch (param->setup.callerinfo.present)
858 case INFO_PRESENT_ALLOWED:
859 ast->cid.cid_pres = AST_PRES_ALLOWED;
861 case INFO_PRESENT_RESTRICTED:
862 ast->cid.cid_pres = AST_PRES_RESTRICTED;
865 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
867 switch (param->setup.callerinfo.ntype)
869 case INFO_NTYPE_SUBSCRIBER:
870 ast->cid.cid_ton = 4;
872 case INFO_NTYPE_NATIONAL:
873 ast->cid.cid_ton = 2;
875 case INFO_NTYPE_INTERNATIONAL:
876 ast->cid.cid_ton = 1;
879 ast->cid.cid_ton = 0;
881 ast->transfercapability = param->setup.capainfo.bearer_capa;
882 /* enable hdlc if transcap is data */
883 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
885 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
887 /* configure channel */
888 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
889 ast->readformat = ast->rawreadformat = ast->nativeformats;
890 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
892 ast->hangupcause = 0;
895 call->state = CHAN_LCR_STATE_IN_SETUP;
897 if (!call->pbx_started)
898 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
902 * incoming setup acknowledge from LCR
904 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
906 if (!call->ast) return;
908 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
910 /* send pending digits in dialque */
911 if (call->dialque[0])
912 send_dialque_to_lcr(call);
913 /* change to overlap state */
914 call->state = CHAN_LCR_STATE_OUT_DIALING;
918 * incoming proceeding from LCR
920 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
922 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
925 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
926 /* queue event for asterisk */
927 if (call->ast && call->pbx_started)
928 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
932 * incoming alerting from LCR
934 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
936 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
939 call->state = CHAN_LCR_STATE_OUT_ALERTING;
940 /* queue event to asterisk */
941 if (call->ast && call->pbx_started)
942 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
946 * incoming connect from LCR
948 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
950 union parameter newparam;
952 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
955 call->state = CHAN_LCR_STATE_CONNECT;
956 /* request bchannel */
957 if (!call->bchannel) {
958 CDEBUG(call, call->ast, "Requesting B-channel.\n");
959 memset(&newparam, 0, sizeof(union parameter));
960 newparam.bchannel.type = BCHANNEL_REQUEST;
961 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
963 /* copy connectinfo */
964 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
965 /* queue event to asterisk */
966 if (call->ast && call->pbx_started)
967 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
971 * incoming disconnect from LCR
973 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
975 struct ast_channel *ast = call->ast;
977 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
980 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
982 call->cause = param->disconnectinfo.cause;
983 call->location = param->disconnectinfo.location;
984 /* if bridge, forward disconnect and return */
987 if (call->bridge_call)
989 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
990 bridge_message_if_bridged(call, message_type, param);
994 /* release lcr with same cause */
995 send_release_and_import(call, call->cause, call->location);
997 /* change to release state */
998 call->state = CHAN_LCR_STATE_RELEASE;
999 /* queue release asterisk */
1002 ast->hangupcause = call->cause;
1003 if (call->pbx_started)
1004 strcpy(call->queue_string, "H"); // overwrite other indications
1006 ast_hangup(ast); // call will be destroyed here
1012 * incoming release from LCR
1014 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1016 struct ast_channel *ast = call->ast;
1018 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1022 /* change to release state */
1023 call->state = CHAN_LCR_STATE_RELEASE;
1024 /* copy release info */
1027 call->cause = param->disconnectinfo.cause;
1028 call->location = param->disconnectinfo.location;
1030 /* if we have an asterisk instance, queue hangup, else we are done */
1033 ast->hangupcause = call->cause;
1034 if (call->pbx_started)
1035 strcpy(call->queue_string, "H");
1037 ast_hangup(ast); // call will be destroyed here
1047 * incoming information from LCR
1049 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1051 struct ast_channel *ast = call->ast;
1053 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1057 /* pbx not started */
1058 if (!call->pbx_started)
1060 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1061 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1062 lcr_start_pbx(call, ast, param->information.sending_complete);
1066 /* change dailing state after setup */
1067 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1068 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1069 call->state = CHAN_LCR_STATE_IN_DIALING;
1070 // ast_setstate(ast, AST_STATE_DIALING);
1074 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0])
1075 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1077 /* use bridge to forware message not supported by asterisk */
1078 if (call->state == CHAN_LCR_STATE_CONNECT) {
1079 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1080 bridge_message_if_bridged(call, message_type, param);
1085 * incoming information from LCR
1087 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1089 union parameter newparam;
1091 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1093 /* request bchannel, if call is resumed and we don't have it */
1094 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1095 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1096 memset(&newparam, 0, sizeof(union parameter));
1097 newparam.bchannel.type = BCHANNEL_REQUEST;
1098 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1101 if (!call->ast) return;
1103 /* use bridge to forware message not supported by asterisk */
1104 bridge_message_if_bridged(call, message_type, param);
1108 * incoming information from LCR
1110 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1112 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1114 if (!call->ast) return;
1116 /* use bridge to forware message not supported by asterisk */
1117 bridge_message_if_bridged(call, message_type, param);
1121 * incoming pattern from LCR
1123 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1125 union parameter newparam;
1127 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1129 if (!call->ast) return;
1131 /* pattern are indicated only once */
1132 if (call->has_pattern)
1134 call->has_pattern = 1;
1136 /* request bchannel */
1137 if (!call->bchannel) {
1138 CDEBUG(call, call->ast, "Requesting B-channel.\n");
1139 memset(&newparam, 0, sizeof(union parameter));
1140 newparam.bchannel.type = BCHANNEL_REQUEST;
1141 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1143 /* queue PROGRESS, because tones are available */
1144 if (call->ast && call->pbx_started)
1145 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1149 * got dtmf from bchannel (locked state)
1151 void lcr_in_dtmf(struct chan_call *call, int val)
1153 struct ast_channel *ast = call->ast;
1158 if (!call->pbx_started)
1161 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1164 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1168 * message received from LCR
1170 int receive_message(int message_type, unsigned int ref, union parameter *param)
1172 struct bchannel *bchannel;
1173 struct chan_call *call;
1174 union parameter newparam;
1176 memset(&newparam, 0, sizeof(union parameter));
1178 /* handle bchannel message*/
1179 if (message_type == MESSAGE_BCHANNEL)
1181 switch(param->bchannel.type)
1183 case BCHANNEL_ASSIGN:
1184 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1185 if ((bchannel = find_bchannel_handle(param->bchannel.handle)))
1187 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1190 /* create bchannel */
1191 bchannel = alloc_bchannel(param->bchannel.handle);
1194 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1198 /* configure channel */
1199 bchannel->b_tx_gain = param->bchannel.tx_gain;
1200 bchannel->b_rx_gain = param->bchannel.rx_gain;
1201 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1202 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key))
1204 bchannel->b_bf_len = param->bchannel.crypt_len;
1205 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1207 bchannel->b_txdata = 0;
1208 bchannel->b_dtmf = 1;
1209 bchannel->b_tx_dejitter = 1;
1211 /* in case, ref is not set, this bchannel instance must
1212 * be created until it is removed again by LCR */
1214 call = find_call_ref(ref);
1217 bchannel->call = call;
1218 call->bchannel = bchannel;
1220 bchannel_dtmf(bchannel, 1);
1222 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1223 if (call->pipeline[0])
1224 bchannel_pipeline(bchannel, call->pipeline);
1226 bchannel_gain(bchannel, call->rx_gain, 0);
1228 bchannel_gain(bchannel, call->tx_gain, 1);
1229 if (call->bridge_id) {
1230 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1231 bchannel_join(bchannel, call->bridge_id);
1233 /* create only, if call exists, othewhise it bchannel is freed below... */
1234 if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0)))
1235 bchannel_activate(bchannel, 1);
1238 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1239 newparam.bchannel.handle = param->bchannel.handle;
1240 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1241 /* if call has released before bchannel is assigned */
1243 newparam.bchannel.type = BCHANNEL_RELEASE;
1244 newparam.bchannel.handle = param->bchannel.handle;
1245 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1250 case BCHANNEL_REMOVE:
1251 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1252 if (!(bchannel = find_bchannel_handle(param->bchannel.handle)))
1254 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1257 /* unklink from call and destroy bchannel */
1258 free_bchannel(bchannel);
1261 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1262 newparam.bchannel.handle = param->bchannel.handle;
1263 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1268 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1273 /* handle new ref */
1274 if (message_type == MESSAGE_NEWREF)
1276 if (param->direction)
1278 /* new ref from lcr */
1279 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1280 if (!ref || find_call_ref(ref))
1282 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1285 /* allocate new call instance */
1286 call = alloc_call();
1288 call->state = CHAN_LCR_STATE_IN_PREPARE;
1291 call->ref_was_assigned = 1;
1292 /* wait for setup (or release from asterisk) */
1295 /* new ref, as requested from this remote application */
1296 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1297 call = find_call_ref(0);
1300 /* send release, if ref does not exist */
1301 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1302 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1307 call->ref_was_assigned = 1;
1308 /* send pending setup info */
1309 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1310 send_setup_to_lcr(call);
1311 /* release if asterisk has signed off */
1312 else if (call->state == CHAN_LCR_STATE_RELEASE)
1316 send_release_and_import(call, call->cause, call->location);
1318 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1330 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1333 call = find_call_ref(ref);
1336 /* ignore ref that is not used (anymore) */
1337 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1341 /* handle messages */
1342 switch(message_type)
1345 lcr_in_setup(call, message_type, param);
1348 case MESSAGE_OVERLAP:
1349 lcr_in_overlap(call, message_type, param);
1352 case MESSAGE_PROCEEDING:
1353 lcr_in_proceeding(call, message_type, param);
1356 case MESSAGE_ALERTING:
1357 lcr_in_alerting(call, message_type, param);
1360 case MESSAGE_CONNECT:
1361 lcr_in_connect(call, message_type, param);
1364 case MESSAGE_DISCONNECT:
1365 lcr_in_disconnect(call, message_type, param);
1368 case MESSAGE_RELEASE:
1369 lcr_in_release(call, message_type, param);
1372 case MESSAGE_INFORMATION:
1373 lcr_in_information(call, message_type, param);
1376 case MESSAGE_NOTIFY:
1377 lcr_in_notify(call, message_type, param);
1380 case MESSAGE_FACILITY:
1381 lcr_in_facility(call, message_type, param);
1384 case MESSAGE_PATTERN: // audio available from LCR
1385 if (!call->has_pattern)
1386 lcr_in_pattern(call, message_type, param);
1389 case MESSAGE_NOPATTERN: // audio not available from LCR
1392 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1393 call->audiopath = param->audiopath;
1397 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1404 * release all calls (due to broken socket)
1406 static void release_all_calls(void)
1408 struct chan_call *call;
1413 /* no ast, so we may directly free call */
1415 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1419 /* already in release process */
1420 if (call->state == CHAN_LCR_STATE_RELEASE) {
1424 /* release or queue release */
1426 call->state = CHAN_LCR_STATE_RELEASE;
1427 if (!call->pbx_started) {
1428 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1429 ast_hangup(call->ast); // call will be destroyed here
1432 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1433 strcpy(call->queue_string, "H");
1437 /* release all bchannels */
1438 while(bchannel_first)
1439 free_bchannel(bchannel_first);
1444 * warning! not thread safe
1445 * returns -1 for socket error, 0 for no work, 1 for work
1447 int handle_socket(void)
1451 struct admin_list *admin;
1452 struct admin_message msg;
1454 /* read from socket */
1455 len = read(lcr_sock, &msg, sizeof(msg));
1458 CERROR(NULL, NULL, "Socket closed.\n");
1459 return(-1); // socket closed
1463 if (len != sizeof(msg))
1465 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1466 return(-1); // socket error
1468 if (msg.message != ADMIN_MESSAGE)
1470 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1473 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1477 if (errno != EWOULDBLOCK)
1479 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1484 /* write to socket */
1487 admin = admin_first;
1488 len = write(lcr_sock, &admin->msg, sizeof(msg));
1491 CERROR(NULL, NULL, "Socket closed.\n");
1492 return(-1); // socket closed
1496 if (len != sizeof(msg))
1498 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1499 return(-1); // socket error
1502 admin_first = admin->next;
1508 if (errno != EWOULDBLOCK)
1510 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1519 * open and close socket and thread
1521 int open_socket(void)
1525 struct sockaddr_un sock_address;
1526 unsigned int on = 1;
1527 union parameter param;
1530 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1532 CERROR(NULL, NULL, "Failed to create socket.\n");
1536 /* set socket address and name */
1537 memset(&sock_address, 0, sizeof(sock_address));
1538 sock_address.sun_family = PF_UNIX;
1539 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1541 /* connect socket */
1542 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0)
1546 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1550 /* set non-blocking io */
1551 if ((ret = ioctl(lcr_sock, FIONBIO, (unsigned char *)(&on))) < 0)
1555 CERROR(NULL, NULL, "Failed to set socket into non-blocking IO.\n");
1559 /* enque hello message */
1560 memset(¶m, 0, sizeof(param));
1561 strcpy(param.hello.application, "asterisk");
1562 send_message(MESSAGE_HELLO, 0, ¶m);
1567 void close_socket(void)
1569 struct admin_list *admin, *temp;
1571 /* flush pending messages */
1572 admin = admin_first;
1575 admin = admin->next;
1587 /* sending queue to asterisk */
1588 static int queue_send(void)
1591 struct chan_call *call;
1592 struct ast_channel *ast;
1593 struct ast_frame fr;
1598 p = call->queue_string;
1601 /* there is something to queue */
1602 if (!ast_channel_trylock(ast)) { /* succeed */
1606 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1607 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1610 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1611 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1614 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1615 ast_queue_control(ast, AST_CONTROL_RINGING);
1616 ast_setstate(ast, AST_STATE_RINGING);
1619 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1620 ast_queue_control(ast, AST_CONTROL_ANSWER);
1623 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1624 ast_queue_hangup(ast);
1626 case '1': case '2': case '3': case 'A':
1627 case '4': case '5': case '6': case 'B':
1628 case '7': case '8': case '9': case 'C':
1629 case '*': case '0': case '#': case 'D':
1630 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1631 /* send digit to asterisk */
1632 memset(&fr, 0, sizeof(fr));
1634 #ifdef LCR_FOR_ASTERISK
1635 fr.frametype = AST_FRAME_DTMF_BEGIN;
1638 #ifdef LCR_FOR_CALLWEAVER
1639 fr.frametype = AST_FRAME_DTMF;
1643 fr.delivery = ast_tv(0, 0);
1644 ast_queue_frame(ast, &fr);
1646 #ifdef LCR_FOR_ASTERISK
1647 fr.frametype = AST_FRAME_DTMF_END;
1648 ast_queue_frame(ast, &fr);
1653 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1657 call->queue_string[0] = '\0';
1658 ast_channel_unlock(ast);
1668 /* signal handler */
1669 void sighandler(int sigset)
1673 /* chan_lcr thread */
1674 static void *chan_thread(void *arg)
1678 union parameter param;
1679 time_t retry = 0, now;
1681 bchannel_pid = getpid();
1683 // signal(SIGPIPE, sighandler);
1685 memset(¶m, 0, sizeof(union parameter));
1689 ast_mutex_lock(&chan_lock);
1696 ret = handle_socket();
1698 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1700 release_all_calls();
1707 if (retry && now-retry > 5) {
1708 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1710 if (open_socket() < 0) {
1719 ret = bchannel_handle();
1723 /* handle messages to asterisk */
1728 /* delay if no work done */
1730 ast_mutex_unlock(&chan_lock);
1732 #ifdef LCR_FOR_ASTERISK
1736 #ifdef LCR_FOR_CALLWEAVER
1740 ast_mutex_lock(&chan_lock);
1746 CERROR(NULL, NULL, "Thread exit.\n");
1748 ast_mutex_unlock(&chan_lock);
1750 // signal(SIGPIPE, SIG_DFL);
1756 * new asterisk instance
1759 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1761 char exten[256], *dial, *interface, *opt;
1762 struct ast_channel *ast;
1763 struct chan_call *call;
1765 ast_mutex_lock(&chan_lock);
1766 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1768 /* if socket is closed */
1771 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1772 ast_mutex_unlock(&chan_lock);
1776 /* create call instance */
1777 call = alloc_call();
1780 /* failed to create instance */
1781 ast_mutex_unlock(&chan_lock);
1785 /* create asterisk channel instrance */
1787 #ifdef LCR_FOR_ASTERISK
1788 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1791 #ifdef LCR_FOR_CALLWEAVER
1792 ast = ast_channel_alloc(1);
1797 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1799 /* failed to create instance */
1800 ast_mutex_unlock(&chan_lock);
1803 ast->tech = &lcr_tech;
1804 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1805 /* configure channel */
1806 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1807 ast->readformat = ast->rawreadformat = ast->nativeformats;
1808 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1810 ast->hangupcause = 0;
1814 ast->tech_pvt = call;
1815 ast->fds[0] = call->pipe[0];
1816 call->pbx_started = 0;
1818 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1821 * Extract interface, dialstring, options from data.
1824 * <interface>/<dialstring>
1825 * <interface>/<dialstring>/options
1827 strncpy(exten, (char *)data, sizeof(exten)-1);
1828 exten[sizeof(exten)-1] = '\0';
1829 if ((dial = strchr(exten, '/'))) {
1832 if ((opt = strchr(dial, '/')))
1841 strncpy(call->interface, interface, sizeof(call->interface)-1);
1842 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1843 apply_opt(call, (char *)opt);
1845 ast_mutex_unlock(&chan_lock);
1850 * call from asterisk
1852 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1854 union parameter newparam;
1855 struct chan_call *call;
1857 ast_mutex_lock(&chan_lock);
1858 call = ast->tech_pvt;
1860 #ifdef LCR_FOR_CALLWEAVER
1862 snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
1866 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1867 ast_mutex_unlock(&chan_lock);
1871 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1873 /* pbx process is started */
1874 call->pbx_started = 1;
1875 /* send MESSAGE_NEWREF */
1876 memset(&newparam, 0, sizeof(union parameter));
1877 newparam.direction = 0; /* request from app */
1878 send_message(MESSAGE_NEWREF, 0, &newparam);
1880 /* set hdlc if capability requires hdlc */
1881 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1882 || ast->transfercapability == INFO_BC_DATARESTRICTED
1883 || ast->transfercapability == INFO_BC_VIDEO)
1885 /* if hdlc is forced by option, we change transcap to data */
1887 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1888 && ast->transfercapability != INFO_BC_DATARESTRICTED
1889 && ast->transfercapability != INFO_BC_VIDEO)
1890 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1892 call->cid_num[0] = 0;
1893 call->cid_name[0] = 0;
1894 call->cid_rdnis[0] = 0;
1896 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1897 strncpy(call->cid_num, ast->cid.cid_num,
1898 sizeof(call->cid_num)-1);
1900 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1901 strncpy(call->cid_name, ast->cid.cid_name,
1902 sizeof(call->cid_name)-1);
1903 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1904 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1905 sizeof(call->cid_rdnis)-1);
1907 ast_mutex_unlock(&chan_lock);
1911 static void send_digit_to_chan(struct ast_channel * ast, char digit )
1913 static const char* dtmf_tones[] = {
1914 "!941+1336/100,!0/100", /* 0 */
1915 "!697+1209/100,!0/100", /* 1 */
1916 "!697+1336/100,!0/100", /* 2 */
1917 "!697+1477/100,!0/100", /* 3 */
1918 "!770+1209/100,!0/100", /* 4 */
1919 "!770+1336/100,!0/100", /* 5 */
1920 "!770+1477/100,!0/100", /* 6 */
1921 "!852+1209/100,!0/100", /* 7 */
1922 "!852+1336/100,!0/100", /* 8 */
1923 "!852+1477/100,!0/100", /* 9 */
1924 "!697+1633/100,!0/100", /* A */
1925 "!770+1633/100,!0/100", /* B */
1926 "!852+1633/100,!0/100", /* C */
1927 "!941+1633/100,!0/100", /* D */
1928 "!941+1209/100,!0/100", /* * */
1929 "!941+1477/100,!0/100" }; /* # */
1931 if (digit >= '0' && digit <='9')
1932 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
1933 else if (digit >= 'A' && digit <= 'D')
1934 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
1935 else if (digit == '*')
1936 ast_playtones_start(ast,0,dtmf_tones[14], 0);
1937 else if (digit == '#')
1938 ast_playtones_start(ast,0,dtmf_tones[15], 0);
1941 ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
1942 "'%c' for '%s'\n", digit, ast->name);
1946 #ifdef LCR_FOR_ASTERISK
1947 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1949 #ifdef LCR_FOR_CALLWEAVER
1950 static int lcr_digit(struct ast_channel *ast, char digit)
1953 struct chan_call *call;
1954 union parameter newparam;
1957 #ifdef LCR_FOR_CALLWEAVER
1958 int inband_dtmf = 0;
1961 /* only pass IA5 number space */
1962 if (digit > 126 || digit < 32)
1965 ast_mutex_lock(&chan_lock);
1966 call = ast->tech_pvt;
1968 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
1969 ast_mutex_unlock(&chan_lock);
1973 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
1975 /* send information or queue them */
1976 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING)
1978 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
1979 memset(&newparam, 0, sizeof(union parameter));
1980 newparam.information.id[0] = digit;
1981 newparam.information.id[1] = '\0';
1982 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
1985 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP))
1987 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
1989 strncat(call->dialque, buf, strlen(call->dialque)-1);
1992 ast_mutex_unlock(&chan_lock);
1994 #ifdef LCR_FOR_ASTERISK
1998 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2000 int inband_dtmf = 0;
2001 struct chan_call *call;
2004 ast_mutex_lock(&chan_lock);
2006 call = ast->tech_pvt;
2010 "Received digit from Asterisk, "
2011 "but no call instance exists.\n");
2012 ast_mutex_unlock(&chan_lock);
2016 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2018 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2022 ast_mutex_unlock(&chan_lock);
2025 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2026 send_digit_to_chan(ast, digit);
2032 static int lcr_answer(struct ast_channel *ast)
2034 union parameter newparam;
2035 struct chan_call *call;
2037 ast_mutex_lock(&chan_lock);
2038 call = ast->tech_pvt;
2040 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2041 ast_mutex_unlock(&chan_lock);
2045 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2047 /* copy connectinfo, if bridged */
2048 if (call->bridge_call)
2049 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2050 /* send connect message to lcr */
2051 if (call->state != CHAN_LCR_STATE_CONNECT) {
2052 memset(&newparam, 0, sizeof(union parameter));
2053 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2054 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2055 call->state = CHAN_LCR_STATE_CONNECT;
2058 /* request bchannel */
2059 if (!call->bchannel) {
2060 CDEBUG(call, ast, "Requesting B-channel.\n");
2061 memset(&newparam, 0, sizeof(union parameter));
2062 newparam.bchannel.type = BCHANNEL_REQUEST;
2063 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2066 // memset(&newparam, 0, sizeof(union parameter));
2067 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2070 CDEBUG(call, ast, "DTMF is disabled by option.\n");
2074 ast_mutex_unlock(&chan_lock);
2078 static int lcr_hangup(struct ast_channel *ast)
2080 struct chan_call *call;
2081 pthread_t tid = pthread_self();
2083 if (!pthread_equal(tid, chan_tid))
2084 ast_mutex_lock(&chan_lock);
2085 call = ast->tech_pvt;
2087 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2088 if (!pthread_equal(tid, chan_tid))
2089 ast_mutex_unlock(&chan_lock);
2093 if (!pthread_equal(tid, chan_tid))
2094 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2096 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2098 /* disconnect asterisk, maybe not required */
2099 ast->tech_pvt = NULL;
2104 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2105 if (ast->hangupcause > 0)
2106 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2108 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2111 if (!pthread_equal(tid, chan_tid))
2112 ast_mutex_unlock(&chan_lock);
2116 /* ref is not set, due to prepare setup or release */
2117 if (call->state == CHAN_LCR_STATE_RELEASE)
2119 /* we get the response to our release */
2120 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2124 /* during prepare, we change to release state */
2125 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2126 call->state = CHAN_LCR_STATE_RELEASE;
2130 if (!pthread_equal(tid, chan_tid))
2131 ast_mutex_unlock(&chan_lock);
2135 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
2137 struct chan_call *call;
2140 CDEBUG(NULL, ast, "No subclass\n");
2141 if (!(f->subclass & ast->nativeformats))
2142 CDEBUG(NULL, ast, "Unexpected format.\n");
2144 ast_mutex_lock(&chan_lock);
2145 call = ast->tech_pvt;
2147 ast_mutex_unlock(&chan_lock);
2150 if (call->bchannel && f->samples)
2151 bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
2152 ast_mutex_unlock(&chan_lock);
2157 static struct ast_frame *lcr_read(struct ast_channel *ast)
2159 struct chan_call *call;
2162 ast_mutex_lock(&chan_lock);
2163 call = ast->tech_pvt;
2165 ast_mutex_unlock(&chan_lock);
2168 if (call->pipe[0] > -1) {
2169 if (call->rebuffer && !call->hdlc) {
2170 /* Make sure we have a complete 20ms (160byte) frame */
2171 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2173 call->framepos += len;
2176 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2178 if (len < 0 && errno == EAGAIN) {
2179 ast_mutex_unlock(&chan_lock);
2181 #ifdef LCR_FOR_ASTERISK
2182 return &ast_null_frame;
2185 #ifdef LCR_FOR_CALLWEAVER
2191 close(call->pipe[0]);
2193 ast_mutex_unlock(&chan_lock);
2195 } else if (call->rebuffer && call->framepos < 160) {
2196 /* Not a complete frame, so we send a null-frame */
2197 ast_mutex_unlock(&chan_lock);
2198 return &ast_null_frame;
2202 call->read_fr.frametype = AST_FRAME_VOICE;
2203 call->read_fr.subclass = ast->nativeformats;
2204 if (call->rebuffer) {
2205 call->read_fr.datalen = call->framepos;
2206 call->read_fr.samples = call->framepos;
2209 call->read_fr.datalen = len;
2210 call->read_fr.samples = len;
2212 call->read_fr.delivery = ast_tv(0,0);
2213 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2214 ast_mutex_unlock(&chan_lock);
2216 return &call->read_fr;
2219 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2221 union parameter newparam;
2223 struct chan_call *call;
2225 ast_mutex_lock(&chan_lock);
2226 call = ast->tech_pvt;
2228 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2229 ast_mutex_unlock(&chan_lock);
2234 case AST_CONTROL_BUSY:
2235 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2236 ast_setstate(ast, AST_STATE_BUSY);
2237 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2238 /* send message to lcr */
2239 memset(&newparam, 0, sizeof(union parameter));
2240 newparam.disconnectinfo.cause = 17;
2241 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2242 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2244 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2247 case AST_CONTROL_CONGESTION:
2248 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2249 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2250 /* send message to lcr */
2251 memset(&newparam, 0, sizeof(union parameter));
2252 newparam.disconnectinfo.cause = ast->hangupcause;
2253 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2254 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2256 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2259 case AST_CONTROL_PROCEEDING:
2260 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2261 if (call->state == CHAN_LCR_STATE_IN_SETUP
2262 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2263 /* send message to lcr */
2264 memset(&newparam, 0, sizeof(union parameter));
2265 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2267 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2270 case AST_CONTROL_RINGING:
2271 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2272 ast_setstate(ast, AST_STATE_RINGING);
2273 if (call->state == CHAN_LCR_STATE_IN_SETUP
2274 || call->state == CHAN_LCR_STATE_IN_DIALING
2275 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2276 /* send message to lcr */
2277 memset(&newparam, 0, sizeof(union parameter));
2278 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2280 call->state = CHAN_LCR_STATE_IN_ALERTING;
2283 case AST_CONTROL_PROGRESS:
2284 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2285 /* request bchannel */
2286 if (!call->bchannel) {
2287 CDEBUG(call, ast, "Requesting B-channel.\n");
2288 memset(&newparam, 0, sizeof(union parameter));
2289 newparam.bchannel.type = BCHANNEL_REQUEST;
2290 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
2294 CDEBUG(call, ast, "Received indicate -1.\n");
2298 case AST_CONTROL_VIDUPDATE:
2299 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2302 case AST_CONTROL_HOLD:
2303 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2304 /* send message to lcr */
2305 memset(&newparam, 0, sizeof(union parameter));
2306 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2307 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2309 /*start music onhold*/
2310 #ifdef LCR_FOR_ASTERISK
2311 ast_moh_start(ast,data,ast->musicclass);
2314 #ifdef LCR_FOR_CALLWEAVER
2315 ast_moh_start(ast, NULL);
2320 case AST_CONTROL_UNHOLD:
2321 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2322 /* send message to lcr */
2323 memset(&newparam, 0, sizeof(union parameter));
2324 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2325 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2331 #ifdef AST_CONTROL_SRCUPDATE
2332 case AST_CONTROL_SRCUPDATE:
2333 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
2337 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2343 ast_mutex_unlock(&chan_lock);
2350 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
2352 struct chan_call *call;
2358 ast_mutex_lock(&chan_lock);
2359 call = ast->tech_pvt;
2361 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
2362 ast_mutex_unlock(&chan_lock);
2366 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
2368 ast_mutex_unlock(&chan_lock);
2373 * send_text asterisk
2375 static int lcr_send_text(struct ast_channel *ast, const char *text)
2377 struct chan_call *call;
2378 union parameter newparam;
2380 ast_mutex_lock(&chan_lock);
2381 call = ast->tech_pvt;
2383 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2384 ast_mutex_unlock(&chan_lock);
2388 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2389 memset(&newparam, 0, sizeof(union parameter));
2390 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2391 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2392 ast_mutex_lock(&chan_lock);
2399 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2400 struct ast_channel *ast2, int flags,
2401 struct ast_frame **fo,
2402 struct ast_channel **rc, int timeoutms)
2405 struct chan_call *call1, *call2;
2406 struct ast_channel *carr[2], *who;
2408 struct ast_frame *f;
2411 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
2416 /* join via dsp (if the channels are currently open) */
2417 ast_mutex_lock(&chan_lock);
2418 call1 = ast1->tech_pvt;
2419 call2 = ast2->tech_pvt;
2420 if (!call1 || !call2) {
2421 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
2422 ast_mutex_unlock(&chan_lock);
2423 return AST_BRIDGE_COMPLETE;
2426 /* join, if both call instances uses dsp
2427 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
2429 if (!call1->nodsp && !call2->nodsp) {
2430 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
2432 /* get bridge id and join */
2433 bridge_id = new_bridge_id();
2435 call1->bridge_id = bridge_id;
2436 if (call1->bchannel)
2437 bchannel_join(call1->bchannel, bridge_id);
2439 call2->bridge_id = bridge_id;
2440 if (call2->bchannel)
2441 bchannel_join(call2->bchannel, bridge_id);
2443 if (call1->nodsp && call2->nodsp)
2444 CDEBUG(NULL, NULL, "Both calls use no DSP, bridging in channel driver.\n");
2446 CDEBUG(NULL, NULL, "One call uses no DSP, bridging in channel driver.\n");
2447 call1->bridge_call = call2;
2448 call2->bridge_call = call1;
2450 if (call1->state == CHAN_LCR_STATE_IN_SETUP
2451 || call1->state == CHAN_LCR_STATE_IN_DIALING
2452 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
2453 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
2454 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2457 if (call2->state == CHAN_LCR_STATE_IN_SETUP
2458 || call2->state == CHAN_LCR_STATE_IN_DIALING
2459 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
2460 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
2461 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
2465 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
2466 so let's do it for them. Hmpf.
2469 if (call1->on_hold) {
2470 union parameter newparam;
2472 memset(&newparam, 0, sizeof(union parameter));
2473 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2474 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
2479 if (call2->on_hold) {
2480 union parameter newparam;
2482 memset(&newparam, 0, sizeof(union parameter));
2483 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2484 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
2489 ast_mutex_unlock(&chan_lock);
2493 who = ast_waitfor_n(carr, 2, &to);
2496 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2501 if (!f || f->frametype == AST_FRAME_CONTROL) {
2503 CDEBUG(NULL, NULL, "Got hangup.\n");
2505 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2512 if ( f->frametype == AST_FRAME_DTMF ) {
2513 CDEBUG(NULL, NULL, "Got DTMF.\n");
2529 CDEBUG(NULL, NULL, "Releasing bridge.\n");
2531 /* split channels */
2532 ast_mutex_lock(&chan_lock);
2533 call1 = ast1->tech_pvt;
2534 call2 = ast2->tech_pvt;
2535 if (call1 && call1->bridge_id)
2537 call1->bridge_id = 0;
2538 if (call1->bchannel)
2539 bchannel_join(call1->bchannel, 0);
2540 if (call1->bridge_call)
2541 call1->bridge_call->bridge_call = NULL;
2543 if (call2 && call1->bridge_id)
2545 call2->bridge_id = 0;
2546 if (call2->bchannel)
2547 bchannel_join(call2->bchannel, 0);
2548 if (call2->bridge_call)
2549 call2->bridge_call->bridge_call = NULL;
2551 call1->bridge_call = NULL;
2552 call2->bridge_call = NULL;
2554 ast_mutex_unlock(&chan_lock);
2555 return AST_BRIDGE_COMPLETE;
2557 static struct ast_channel_tech lcr_tech = {
2559 .description = "Channel driver for connecting to Linux-Call-Router",
2560 .capabilities = AST_FORMAT_ALAW,
2561 .requester = lcr_request,
2563 #ifdef LCR_FOR_ASTERISK
2564 .send_digit_begin = lcr_digit_begin,
2565 .send_digit_end = lcr_digit_end,
2568 #ifdef LCR_FOR_CALLWEAVER
2569 .send_digit = lcr_digit,
2573 .bridge = lcr_bridge,
2574 .hangup = lcr_hangup,
2575 .answer = lcr_answer,
2578 .indicate = lcr_indicate,
2580 .send_text = lcr_send_text,
2589 static int lcr_show_lcr (int fd, int argc, char *argv[])
2594 static int lcr_show_calls (int fd, int argc, char *argv[])
2599 static int lcr_reload_routing (int fd, int argc, char *argv[])
2604 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2609 static int lcr_port_block (int fd, int argc, char *argv[])
2614 static int lcr_port_unblock (int fd, int argc, char *argv[])
2619 static int lcr_port_unload (int fd, int argc, char *argv[])
2624 static struct ast_cli_entry cli_show_lcr =
2625 { {"lcr", "show", "lcr", NULL},
2627 "Shows current states of LCR core",
2628 "Usage: lcr show lcr\n",
2631 static struct ast_cli_entry cli_show_calls =
2632 { {"lcr", "show", "calls", NULL},
2634 "Shows current calls made by LCR and Asterisk",
2635 "Usage: lcr show calls\n",
2638 static struct ast_cli_entry cli_reload_routing =
2639 { {"lcr", "reload", "routing", NULL},
2641 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2642 "Usage: lcr reload routing\n",
2645 static struct ast_cli_entry cli_reload_interfaces =
2646 { {"lcr", "reload", "interfaces", NULL},
2647 lcr_reload_interfaces,
2648 "Reloads interfaces conf of LCR",
2649 "Usage: lcr reload interfaces\n",
2652 static struct ast_cli_entry cli_port_block =
2653 { {"lcr", "port", "block", NULL},
2655 "Blocks LCR port for further calls",
2656 "Usage: lcr port block \"<port>\"\n",
2659 static struct ast_cli_entry cli_port_unblock =
2660 { {"lcr", "port", "unblock", NULL},
2662 "Unblocks or loads LCR port, port is opened my mISDN",
2663 "Usage: lcr port unblock \"<port>\"\n",
2666 static struct ast_cli_entry cli_port_unload =
2667 { {"lcr", "port", "unload", NULL},
2669 "Unloads LCR port, port is closes by mISDN",
2670 "Usage: lcr port unload \"<port>\"\n",
2675 #ifdef LCR_FOR_ASTERISK
2676 static int lcr_config_exec(struct ast_channel *ast, void *data)
2679 #ifdef LCR_FOR_CALLWEAVER
2680 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
2683 struct chan_call *call;
2685 ast_mutex_lock(&chan_lock);
2687 #ifdef LCR_FOR_ASTERISK
2688 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2691 #ifdef LCR_FOR_CALLWEAVER
2692 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
2698 if (call->ast == ast)
2704 #ifdef LCR_FOR_ASTERISK
2705 apply_opt(call, (char *)data);
2708 #ifdef LCR_FOR_CALLWEAVER
2709 apply_opt(call, (char *)argv[0]);
2713 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2715 ast_mutex_unlock(&chan_lock);
2720 * module loading and destruction
2722 int load_module(void)
2726 for (i = 0; i < 256; i++) {
2727 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2728 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2731 if (read_options() == 0) {
2732 CERROR(NULL, NULL, "%s", options_error);
2734 #ifdef LCR_FOR_ASTERISK
2735 return AST_MODULE_LOAD_DECLINE;
2738 #ifdef LCR_FOR_CALLWEAVER
2744 ast_mutex_init(&chan_lock);
2745 ast_mutex_init(&log_lock);
2747 if (open_socket() < 0) {
2748 /* continue with closed socket */
2751 if (bchannel_initialize()) {
2752 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2755 #ifdef LCR_FOR_ASTERISK
2756 return AST_MODULE_LOAD_DECLINE;
2759 #ifdef LCR_FOR_CALLWEAVER
2765 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2766 if (ast_channel_register(&lcr_tech)) {
2767 CERROR(NULL, NULL, "Unable to register channel class\n");
2768 bchannel_deinitialize();
2771 #ifdef LCR_FOR_ASTERISK
2772 return AST_MODULE_LOAD_DECLINE;
2775 #ifdef LCR_FOR_CALLWEAVER
2780 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2782 #ifdef LCR_FOR_ASTERISK
2783 "lcr_config(<opt><optarg>:<opt>:...)\n"
2786 #ifdef LCR_FOR_CALLWEAVER
2787 "lcr_config(<opt><optarg>:<opt>:...)\n",
2790 "Sets LCR opts. and optargs\n"
2792 "The available options are:\n"
2793 " d - Send display text on called phone, text is the optarg.\n"
2794 " n - Don't detect dtmf tones on called channel.\n"
2795 " h - Force data call (HDLC).\n"
2796 " t - Disable mISDN_dsp features (required for fax application).\n"
2797 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
2798 " Use time to detect for optarg.\n"
2799 " c - Make crypted outgoing call, optarg is keyindex.\n"
2800 " e - Perform echo cancelation on this channel.\n"
2801 " Takes mISDN pipeline option as optarg.\n"
2802 " s - Send Non Inband DTMF as inband.\n"
2803 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
2804 " vr - rxgain control\n"
2805 " vt - txgain control\n"
2806 " Volume changes at factor 2 ^ optarg.\n"
2811 ast_cli_register(&cli_show_lcr);
2812 ast_cli_register(&cli_show_calls);
2813 ast_cli_register(&cli_reload_routing);
2814 ast_cli_register(&cli_reload_interfaces);
2815 ast_cli_register(&cli_port_block);
2816 ast_cli_register(&cli_port_unblock);
2817 ast_cli_register(&cli_port_unload);
2821 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0))
2823 /* failed to create thread */
2824 bchannel_deinitialize();
2826 ast_channel_unregister(&lcr_tech);
2828 #ifdef LCR_FOR_ASTERISK
2829 return AST_MODULE_LOAD_DECLINE;
2832 #ifdef LCR_FOR_CALLWEAVER
2840 int unload_module(void)
2842 /* First, take us out of the channel loop */
2843 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2846 pthread_join(chan_tid, NULL);
2848 ast_channel_unregister(&lcr_tech);
2850 ast_unregister_application("lcr_config");
2853 if (mISDN_created) {
2854 bchannel_deinitialize();
2858 if (lcr_sock >= 0) {
2866 int reload_module(void)
2872 #ifdef LCR_FOR_ASTERISK
2873 #define AST_MODULE "chan_lcr"
2876 #ifdef LCR_FOR_CALLWEAVER
2880 ast_mutex_lock(&usecnt_lock);
2882 ast_mutex_unlock(&usecnt_lock);
2887 #ifdef LCR_FOR_ASTERISK
2888 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2889 .load = load_module,
2890 .unload = unload_module,
2891 .reload = reload_module,
2895 #ifdef LCR_FOR_CALLWEAVER
2896 char *description(void)