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>
141 * Fwd declare struct ast_channel to get rid of gcc warning about
142 * incompatible pointer type passed to ast_register_application2.
146 #include <asterisk/module.h>
147 #include <asterisk/channel.h>
148 #include <asterisk/config.h>
149 #include <asterisk/logger.h>
150 #include <asterisk/pbx.h>
151 #include <asterisk/options.h>
152 #include <asterisk/io.h>
153 #include <asterisk/frame.h>
154 #include <asterisk/translate.h>
155 #include <asterisk/cli.h>
156 #include <asterisk/musiconhold.h>
157 #include <asterisk/dsp.h>
158 #include <asterisk/translate.h>
159 #include <asterisk/file.h>
160 #ifdef LCR_FOR_ASTERISK
161 #include <asterisk/callerid.h>
163 #ifdef LCR_FOR_CALLWEAVER
164 #include <asterisk/phone_no_utils.h>
167 #include <asterisk/indications.h>
168 #include <asterisk/app.h>
169 #include <asterisk/features.h>
170 #include <asterisk/sched.h>
171 #if ASTERISK_VERSION_NUM < 110000
172 #include <asterisk/version.h>
174 #include "extension.h"
176 #include "callerid.h"
177 #include "lcrsocket.h"
181 #include "chan_lcr.h"
183 CHAN_LCR_STATE // state description structure
184 MESSAGES // message text
186 #ifdef LCR_FOR_CALLWEAVER
187 AST_MUTEX_DEFINE_STATIC(rand_lock);
190 unsigned char flip_bits[256];
192 #ifdef LCR_FOR_CALLWEAVER
193 static struct ast_frame nullframe = { AST_FRAME_NULL, };
198 char lcr_type[]="lcr";
200 #ifdef LCR_FOR_CALLWEAVER
201 static ast_mutex_t usecnt_lock;
203 static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
207 ast_mutex_t chan_lock; /* global lock */
208 ast_mutex_t log_lock; /* logging log */
210 * used to indicate change in file descriptors, so select function's result may
213 int global_change = 0;
216 struct lcr_fd wake_fd;
218 int glob_channel = 0;
221 struct lcr_fd socket_fd;
222 struct lcr_timer socket_retry;
225 struct admin_list *next;
226 struct admin_message msg;
227 } *admin_first = NULL;
229 static struct ast_channel_tech lcr_tech;
234 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, ...)
237 char call_text[128] = "NULL";
238 char ast_text[128] = "NULL";
241 ast_mutex_lock(&log_lock);
244 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
245 buffer[sizeof(buffer)-1]=0;
249 sprintf(call_text, "%d", call->ref);
251 #if ASTERISK_VERSION_NUM < 110000
252 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
254 strncpy(ast_text, ast_channel_name(ast), sizeof(ast_text)-1);
256 ast_text[sizeof(ast_text)-1] = '\0';
258 // ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
259 printf("[call=%s ast=%s line=%d] %s", call_text, ast_text, line, buffer);
261 ast_mutex_unlock(&log_lock);
265 * channel and call instances
267 struct chan_call *call_first;
271 * special case: 0: find new ref, that has not been assigned a ref yet
274 struct chan_call *find_call_ref(unsigned int ref)
276 struct chan_call *call = call_first;
277 int assigned = (ref > 0);
280 if (call->ref == ref && call->ref_was_assigned == assigned)
287 void free_call(struct chan_call *call)
289 struct chan_call **temp = &call_first;
293 *temp = (*temp)->next;
294 if (call->pipe[0] > -1)
295 close(call->pipe[0]);
296 if (call->pipe[1] > -1)
297 close(call->pipe[1]);
298 if (call->bridge_call) {
299 if (call->bridge_call->bridge_call != call)
300 CERROR(call, NULL, "Linked call structure has no link to us.\n");
301 call->bridge_call->bridge_call = NULL;
304 ast_translator_free_path(call->trans);
306 ast_dsp_free(call->dsp);
307 CDEBUG(call, NULL, "Call instance freed.\n");
312 temp = &((*temp)->next);
314 CERROR(call, NULL, "Call instance not found in list.\n");
317 struct chan_call *alloc_call(void)
319 struct chan_call **callp = &call_first;
322 callp = &((*callp)->next);
324 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
326 memset(*callp, 0, sizeof(struct chan_call));
327 if (pipe((*callp)->pipe) < 0) {
328 CERROR(*callp, NULL, "Failed to create pipe.\n");
332 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
333 CDEBUG(*callp, NULL, "Call instance allocated.\n");
337 unsigned short new_bridge_id(void)
339 struct chan_call *call;
340 unsigned short id = 1;
342 /* search for lowest bridge id that is not in use and not 0 */
346 if (call->bridge_id == id)
354 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
359 * enque message to LCR
361 int send_message(int message_type, unsigned int ref, union parameter *param)
363 struct admin_list *admin, **adminp;
366 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
369 if (message_type != MESSAGE_TRAFFIC)
370 CDEBUG(NULL, NULL, "Sending %s to socket. (ref=%d)\n", messages_txt[message_type], ref);
372 adminp = &admin_first;
374 adminp = &((*adminp)->next);
375 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
377 CERROR(NULL, NULL, "No memory for message to LCR.\n");
382 admin->msg.message = ADMIN_MESSAGE;
383 admin->msg.u.msg.type = message_type;
384 admin->msg.u.msg.ref = ref;
385 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
386 socket_fd.when |= LCR_FD_WRITE;
391 rc = write(wake_pipe[1], &byte, 1);
398 * apply options (in locked state)
400 void apply_opt(struct chan_call *call, char *data)
402 union parameter newparam;
403 char string[1024], *p = string, *opt;//, *key;
409 strncpy(string, data, sizeof(string)-1);
410 string[sizeof(string)-1] = '\0';
413 while((opt = strsep(&p, ":"))) {
416 if (opt[1] == '\0') {
417 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
420 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
421 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
422 strncpy(call->display, opt+1, sizeof(call->display)-1);
424 memset(&newparam, 0, sizeof(union parameter));
425 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
426 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
430 if (opt[1] != '\0') {
431 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
434 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
439 if (opt[1] == '\0') {
440 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
444 /* check for 0xXXXX... type of key */
445 if (!!strncmp((char *)key, "0x", 2)) {
446 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
450 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
451 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
456 if (*key>='0' && *key<='9')
457 call->bf_key[i] = (*key-'0') << 8;
458 else if (*key>='a' && *key<='f')
459 call->bf_key[i] = (*key-'a'+10) << 8;
460 else if (*key>='A' && *key<='F')
461 call->bf_key[i] = (*key-'A'+10) << 8;
465 if (*key>='0' && *key<='9')
466 call->bf_key[i] += (*key - '0');
467 else if (*key>='a' && *key<='f')
468 call->bf_key[i] += (*key - 'a' + 10);
469 else if (*key>='A' && *key<='F')
470 call->bf_key[i] += (*key - 'A' + 10);
477 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
481 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
483 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
487 if (opt[1] != '\0') {
488 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
491 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
496 if (opt[1] == '\0') {
497 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
500 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
501 call->tx_queue = atoi(opt+1);
505 if (opt[1] == '\0') {
506 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
509 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
510 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
512 bchannel_pipeline(call->bchannel, call->pipeline);
516 if (opt[1] != '\0') {
517 CERROR(call, call->ast, "Option 'f' (faxdetect) expects no parameter.\n", opt);
522 CDEBUG(call, call->ast, "Option 'f' (faxdetect).\n");
525 if (opt[1] != '\0') {
526 CERROR(call, call->ast, "Option 'a' (asterisk DTMF) expects no parameter.\n", opt);
531 CDEBUG(call, call->ast, "Option 'a' (Asterisk DTMF detection).\n");
534 if (opt[1] != '\0') {
535 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
538 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
543 if (opt[1] != '\0') {
544 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
547 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
548 call->inband_dtmf = 1;
552 if (opt[1] != 'r' && opt[1] != 't') {
553 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
557 if (gain < -8 || gain >8) {
558 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
561 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
563 call->rx_gain = gain;
565 bchannel_gain(call->bchannel, call->rx_gain, 0);
567 call->tx_gain = gain;
569 bchannel_gain(call->bchannel, call->tx_gain, 1);
574 if (opt[1] != '\0') {
575 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
578 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
583 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
587 if (call->faxdetect || call->ast_dsp) {
589 call->dsp=ast_dsp_new();
591 #ifdef LCR_FOR_CALLWEAVER
592 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_CNG_DETECT : 0));
594 #ifdef LCR_FOR_ASTERISK
595 #ifdef DSP_FEATURE_DTMF_DETECT
596 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_DETECT : 0));
598 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_DETECT : 0));
603 #ifdef LCR_FOR_CALLWEAVER
604 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
606 #ifdef LCR_FOR_ASTERISK
607 #if ASTERISK_VERSION_NUM < 100000
608 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
610 // struct ast_format src;
611 // struct ast_format dst;
612 // ast_format_set(&dst, AST_FORMAT_SLINEAR, 0);
613 // ast_format_set(&dst,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
614 // call->trans=ast_translator_build_path(&dst, &src);
623 * send setup info to LCR
624 * this function is called, when asterisk call is received and ref is received
626 static void send_setup_to_lcr(struct chan_call *call)
628 union parameter newparam;
629 struct ast_channel *ast = call->ast;
632 if (!call->ast || !call->ref)
635 #ifdef AST_1_8_OR_HIGHER
636 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->callerinfo.id);
638 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
641 /* send setup message to LCR */
642 memset(&newparam, 0, sizeof(union parameter));
643 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
644 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
646 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
648 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
649 if (!!strcmp(call->interface, "pbx"))
650 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
651 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
652 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
653 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
654 call->display[0] = '\0';
656 #ifdef AST_1_8_OR_HIGHER
657 /* set stored call information */
658 memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
659 memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
661 if (call->cid_num[0])
662 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
663 if (call->cid_name[0])
664 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
665 if (call->cid_rdnis[0]) {
666 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
667 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
668 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
670 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
671 case AST_PRES_RESTRICTED:
672 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
674 case AST_PRES_UNAVAILABLE:
675 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
677 case AST_PRES_ALLOWED:
679 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
681 switch(ast->cid.cid_ton) {
683 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
686 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
689 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
692 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
695 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
696 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
698 #if ASTERISK_VERSION_NUM < 110000
699 // ast->transfercapability = atoi(tmp);
700 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
702 // ast_channel_transfercapability_set(ast, atoi(tmp));
703 newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
705 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
707 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
709 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
710 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
712 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
713 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
714 send_message(MESSAGE_SETUP, call->ref, &newparam);
715 if (call->tx_queue) {
716 memset(&newparam, 0, sizeof(union parameter));
717 newparam.queue = call->tx_queue * 8;
718 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
721 /* change to outgoing setup state */
722 call->state = CHAN_LCR_STATE_OUT_SETUP;
726 * send dialing info to LCR
727 * this function is called, when setup acknowledge is received and dialing
730 static void send_dialque_to_lcr(struct chan_call *call)
732 union parameter newparam;
734 if (!call->ast || !call->ref || !call->dialque[0])
737 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
739 /* send setup message to LCR */
740 memset(&newparam, 0, sizeof(union parameter));
742 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
744 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
745 call->dialque[0] = '\0';
746 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
750 * in case of a bridge, the unsupported message can be forwarded directly
751 * to the remote call.
753 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
757 if (!call->bridge_call) return;
758 CDEBUG(call, NULL, "Sending message due bridging.\n");
759 send_message(message_type, call->bridge_call->ref, param);
763 * send release message to LCR
765 static void send_release(struct chan_call *call, int cause, int location)
767 union parameter newparam;
769 /* sending release */
770 memset(&newparam, 0, sizeof(union parameter));
771 newparam.disconnectinfo.cause = cause;
772 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
773 send_message(MESSAGE_RELEASE, call->ref, &newparam);
777 * check if extension matches and start asterisk
778 * if it can match, proceed
781 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
784 union parameter newparam;
785 #if ASTERISK_VERSION_NUM < 110000
786 char *exten = ast->exten;
788 char s_exten[AST_MAX_EXTENSION];
791 strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
797 #if ASTERISK_VERSION_NUM < 110000
798 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
800 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
805 #if ASTERISK_VERSION_NUM < 110000
806 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
807 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
809 if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
810 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
815 #if ASTERISK_VERSION_NUM < 110000
816 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
817 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);
819 if (!ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
820 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' would match at context '%s', if more digits would be dialed - releasing.\n", exten, ast_channel_context(ast));
825 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
826 /* send setup acknowledge to lcr */
827 memset(&newparam, 0, sizeof(union parameter));
828 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
831 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
836 #if ASTERISK_VERSION_NUM < 110000
837 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
839 if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
841 /* send setup acknowledge to lcr */
842 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
843 memset(&newparam, 0, sizeof(union parameter));
844 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
848 call->state = CHAN_LCR_STATE_IN_DIALING;
850 /* if match, start pbx */
851 #if ASTERISK_VERSION_NUM < 110000
852 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
854 if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
856 CDEBUG(call, ast, "Extensions matches.\n");
860 /* send setup acknowledge to lcr */
861 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
862 memset(&newparam, 0, sizeof(union parameter));
863 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
867 call->state = CHAN_LCR_STATE_IN_DIALING;
870 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
874 #if ASTERISK_VERSION_NUM < 110000
877 if (!*ast_channel_exten(ast)) {
879 /* send setup acknowledge to lcr */
880 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
881 memset(&newparam, 0, sizeof(union parameter));
882 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
886 call->state = CHAN_LCR_STATE_IN_DIALING;
889 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
897 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
898 send_release(call, cause, LOCATION_PRIVATE_LOCAL);
900 /* release asterisk */
901 #if ASTERISK_VERSION_NUM < 110000
902 ast->hangupcause = call->cause;
904 ast_channel_hangupcause_set(ast, call->cause);
906 /* change to release state */
907 call->state = CHAN_LCR_STATE_RELEASE;
908 ast_hangup(ast); // call will be destroyed here
912 /* send setup to asterisk */
913 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
915 #ifdef LCR_FOR_CALLWEAVER
917 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
920 ret = ast_pbx_start(ast);
922 cause = (ret==-2)?34:27;
925 call->pbx_started = 1;
926 ast_setstate(ast, AST_STATE_RING);
930 * incoming setup from LCR
932 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
934 struct ast_channel *ast;
935 #ifdef AST_1_8_OR_HIGHER
936 struct ast_party_redirecting *ast_redir;
937 struct ast_party_caller *ast_caller;
939 struct ast_callerid *ast_caller;
941 #if ASTERISK_VERSION_NUM >= 110000
942 struct ast_party_redirecting s_ast_redir;
943 struct ast_party_caller s_ast_caller;
944 ast_party_redirecting_init(&s_ast_redir);
945 ast_party_caller_init(&s_ast_caller);
947 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
949 /* create asterisk channel instrance */
951 #ifdef LCR_FOR_CALLWEAVER
952 ast = ast_channel_alloc(1);
955 #ifdef LCR_FOR_ASTERISK
956 #ifdef AST_1_8_OR_HIGHER
957 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
959 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
963 #if ASTERISK_VERSION_NUM < 110000
964 #ifdef AST_1_8_OR_HIGHER
965 ast_redir = &ast->redirecting;
966 ast_caller = &ast->caller;
968 ast_caller = &ast->cid;
971 ast_redir = &s_ast_redir;
972 ast_caller = &s_ast_caller;
977 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
978 send_release(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
985 #if ASTERISK_VERSION_NUM < 110000
986 ast->tech_pvt = call;
987 ast->tech = &lcr_tech;
988 ast->fds[0] = call->pipe[0];
990 ast_channel_tech_pvt_set(ast, call);
991 ast_channel_tech_set(ast, &lcr_tech);
992 ast_channel_set_fd(ast, 0, call->pipe[0]);
995 /* fill setup information */
996 if (param->setup.dialinginfo.id)
997 #if ASTERISK_VERSION_NUM < 110000
998 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
999 if (param->setup.dialinginfo.context[0])
1000 strncpy(ast->context, param->setup.dialinginfo.context, AST_MAX_CONTEXT-1);
1002 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
1004 ast_channel_exten_set(ast, param->setup.dialinginfo.id);
1005 if (param->setup.context[0])
1006 ast_channel_context_set(ast, param->setup.context);
1008 ast_channel_context_set(ast, param->setup.callerinfo.interface);
1012 #ifdef AST_1_8_OR_HIGHER
1013 if (param->setup.callerinfo.id[0]) {
1014 ast_caller->id.number.valid = 1;
1015 ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
1016 if (!param->setup.callerinfo.id[0]) {
1017 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1018 ast_caller->id.number.plan = (0 << 4) | 1;
1020 switch (param->setup.callerinfo.present) {
1021 case INFO_PRESENT_ALLOWED:
1022 ast_caller->id.number.presentation = AST_PRES_ALLOWED;
1024 case INFO_PRESENT_RESTRICTED:
1025 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1028 ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
1030 switch (param->setup.callerinfo.screen) {
1031 case INFO_SCREEN_USER:
1032 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1034 case INFO_SCREEN_USER_VERIFIED_PASSED:
1035 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1037 case INFO_SCREEN_USER_VERIFIED_FAILED:
1038 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1041 ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
1043 switch (param->setup.callerinfo.ntype) {
1044 case INFO_NTYPE_SUBSCRIBER:
1045 ast_caller->id.number.plan = (4 << 4) | 1;
1047 case INFO_NTYPE_NATIONAL:
1048 ast_caller->id.number.plan = (2 << 4) | 1;
1050 case INFO_NTYPE_INTERNATIONAL:
1051 ast_caller->id.number.plan = (1 << 4) | 1;
1054 ast_caller->id.number.plan = (0 << 4) | 1;
1057 if (param->setup.callerinfo.id2[0]) {
1058 ast_caller->ani.number.valid = 1;
1059 ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
1060 switch (param->setup.callerinfo.present2) {
1061 case INFO_PRESENT_ALLOWED:
1062 ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
1064 case INFO_PRESENT_RESTRICTED:
1065 ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
1068 ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
1070 switch (param->setup.callerinfo.screen2) {
1071 case INFO_SCREEN_USER:
1072 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1074 case INFO_SCREEN_USER_VERIFIED_PASSED:
1075 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1077 case INFO_SCREEN_USER_VERIFIED_FAILED:
1078 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1081 ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
1083 switch (param->setup.callerinfo.ntype2) {
1084 case INFO_NTYPE_SUBSCRIBER:
1085 ast_caller->ani.number.plan = (4 << 4) | 1;
1087 case INFO_NTYPE_NATIONAL:
1088 ast_caller->ani.number.plan = (2 << 4) | 1;
1090 case INFO_NTYPE_INTERNATIONAL:
1091 ast_caller->ani.number.plan = (1 << 4) | 1;
1094 ast_caller->ani.number.plan = (0 << 4) | 1;
1097 if (param->setup.callerinfo.name[0]) {
1098 ast_caller->id.name.valid = 1;
1099 ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
1101 #if ASTERISK_VERSION_NUM >= 110000
1102 ast_channel_caller_set(ast, ast_caller);
1104 if (param->setup.redirinfo.id[0]) {
1105 ast_redir->from.number.valid = 1;
1106 ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
1107 switch (param->setup.redirinfo.present) {
1108 case INFO_PRESENT_ALLOWED:
1109 ast_redir->from.number.presentation = AST_PRES_ALLOWED;
1111 case INFO_PRESENT_RESTRICTED:
1112 ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
1115 ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
1117 switch (param->setup.redirinfo.screen) {
1118 case INFO_SCREEN_USER:
1119 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1121 case INFO_SCREEN_USER_VERIFIED_PASSED:
1122 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1124 case INFO_SCREEN_USER_VERIFIED_FAILED:
1125 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1128 ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
1130 switch (param->setup.redirinfo.ntype) {
1131 case INFO_NTYPE_SUBSCRIBER:
1132 ast_redir->from.number.plan = (4 << 4) | 1;
1134 case INFO_NTYPE_NATIONAL:
1135 ast_redir->from.number.plan = (2 << 4) | 1;
1137 case INFO_NTYPE_INTERNATIONAL:
1138 ast_redir->from.number.plan = (1 << 4) | 1;
1141 ast_redir->from.number.plan = (0 << 4) | 1;
1143 #if ASTERISK_VERSION_NUM >= 110000
1144 ast_channel_redirecting_set(ast, ast_redir);
1148 memset(&ast->cid, 0, sizeof(ast->cid));
1149 if (param->setup.callerinfo.id[0])
1150 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
1151 if (param->setup.callerinfo.id2[0])
1152 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
1153 if (param->setup.callerinfo.name[0])
1154 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
1155 if (param->setup.redirinfo.id[0])
1156 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
1157 switch (param->setup.callerinfo.present) {
1158 case INFO_PRESENT_ALLOWED:
1159 ast->cid.cid_pres = AST_PRES_ALLOWED;
1161 case INFO_PRESENT_RESTRICTED:
1162 ast->cid.cid_pres = AST_PRES_RESTRICTED;
1165 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
1167 switch (param->setup.callerinfo.ntype) {
1168 case INFO_NTYPE_SUBSCRIBER:
1169 ast->cid.cid_ton = 4;
1171 case INFO_NTYPE_NATIONAL:
1172 ast->cid.cid_ton = 2;
1174 case INFO_NTYPE_INTERNATIONAL:
1175 ast->cid.cid_ton = 1;
1178 ast->cid.cid_ton = 0;
1182 #if ASTERISK_VERSION_NUM < 110000
1183 ast->transfercapability = param->setup.capainfo.bearer_capa;
1185 ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
1187 /* enable hdlc if transcap is data */
1188 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
1190 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
1192 /* configure channel */
1193 #if ASTERISK_VERSION_NUM < 100000
1194 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1195 ast->readformat = ast->rawreadformat = ast->nativeformats;
1196 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1198 #if ASTERISK_VERSION_NUM < 110000
1199 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1200 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
1201 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
1202 ast_set_write_format(ast, &ast->rawwriteformat);
1203 ast_set_read_format(ast, &ast->rawreadformat);
1205 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1206 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
1207 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
1208 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
1209 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
1212 #if ASTERISK_VERSION_NUM < 110000
1214 ast->hangupcause = 0;
1216 ast_channel_priority_set(ast, 1);
1217 ast_channel_hangupcause_set(ast, 0);
1221 call->state = CHAN_LCR_STATE_IN_SETUP;
1223 if (!call->pbx_started)
1224 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
1228 * incoming setup acknowledge from LCR
1230 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
1232 if (!call->ast) return;
1234 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
1236 /* send pending digits in dialque */
1237 if (call->dialque[0])
1238 send_dialque_to_lcr(call);
1239 /* change to overlap state */
1240 call->state = CHAN_LCR_STATE_OUT_DIALING;
1244 * incoming proceeding from LCR
1246 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
1248 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
1251 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
1252 /* queue event for asterisk */
1253 if (call->ast && call->pbx_started) {
1258 rc = write(wake_pipe[1], &byte, 1);
1260 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
1266 * incoming alerting from LCR
1268 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
1270 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
1273 call->state = CHAN_LCR_STATE_OUT_ALERTING;
1274 /* queue event to asterisk */
1275 if (call->ast && call->pbx_started) {
1280 rc = write(wake_pipe[1], &byte, 1);
1282 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1287 * incoming connect from LCR
1289 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1291 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1294 call->state = CHAN_LCR_STATE_CONNECT;
1295 /* copy connectinfo */
1296 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1297 /* queue event to asterisk */
1298 if (call->ast && call->pbx_started) {
1303 rc = write(wake_pipe[1], &byte, 1);
1305 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1310 * incoming disconnect from LCR
1312 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1314 struct ast_channel *ast = call->ast;
1316 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1319 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1321 call->cause = param->disconnectinfo.cause;
1322 call->location = param->disconnectinfo.location;
1323 /* if bridge, forward disconnect and return */
1326 if (call->bridge_call) {
1327 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1328 bridge_message_if_bridged(call, message_type, param);
1332 /* release lcr with same cause */
1333 send_release(call, call->cause, call->location);
1335 /* change to release state */
1336 call->state = CHAN_LCR_STATE_RELEASE;
1337 /* queue release asterisk */
1339 #if ASTERISK_VERSION_NUM < 110000
1340 ast->hangupcause = call->cause;
1342 ast_channel_hangupcause_set(ast, call->cause);
1344 if (call->pbx_started) {
1349 rc = write(wake_pipe[1], &byte, 1);
1351 strcpy(call->queue_string, "H"); // overwrite other indications
1353 ast_hangup(ast); // call will be destroyed here
1359 * incoming release from LCR
1361 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1363 struct ast_channel *ast = call->ast;
1365 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1369 /* change to release state */
1370 call->state = CHAN_LCR_STATE_RELEASE;
1371 /* copy release info */
1373 call->cause = param->disconnectinfo.cause;
1374 call->location = param->disconnectinfo.location;
1376 /* if we have an asterisk instance, queue hangup, else we are done */
1378 #if ASTERISK_VERSION_NUM < 110000
1379 ast->hangupcause = call->cause;
1381 ast_channel_hangupcause_set(ast, call->cause);
1383 if (call->pbx_started) {
1388 rc = write(wake_pipe[1], &byte, 1);
1390 strcpy(call->queue_string, "H");
1392 ast_hangup(ast); // call will be destroyed here
1401 * incoming information from LCR
1403 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1405 struct ast_channel *ast = call->ast;
1407 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1411 /* pbx not started */
1412 if (!call->pbx_started) {
1413 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1414 #if ASTERISK_VERSION_NUM < 110000
1415 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1417 ast_channel_exten_set(ast, param->information.id);
1419 lcr_start_pbx(call, ast, param->information.sending_complete);
1423 /* change dailing state after setup */
1424 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1425 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1426 call->state = CHAN_LCR_STATE_IN_DIALING;
1427 // ast_setstate(ast, AST_STATE_DIALING);
1431 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1436 rc = write(wake_pipe[1], &byte, 1);
1438 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1441 /* use bridge to forware message not supported by asterisk */
1442 if (call->state == CHAN_LCR_STATE_CONNECT) {
1443 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1444 bridge_message_if_bridged(call, message_type, param);
1449 * incoming information from LCR
1451 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1453 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1455 if (!call->ast) return;
1457 /* use bridge to forware message not supported by asterisk */
1458 bridge_message_if_bridged(call, message_type, param);
1462 * incoming information from LCR
1464 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1466 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1468 if (!call->ast) return;
1470 /* use bridge to forware message not supported by asterisk */
1471 bridge_message_if_bridged(call, message_type, param);
1475 * incoming pattern from LCR
1477 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1479 union parameter newparam;
1481 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1483 if (!call->ast) return;
1485 /* pattern are indicated only once */
1486 if (call->has_pattern)
1488 call->has_pattern = 1;
1490 /* request bchannel */
1491 CDEBUG(call, call->ast, "Requesting audio path (ref=%d)\n", call->ref);
1492 memset(&newparam, 0, sizeof(union parameter));
1493 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
1495 /* queue PROGRESS, because tones are available */
1496 if (call->ast && call->pbx_started) {
1501 rc = write(wake_pipe[1], &byte, 1);
1503 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1508 * got dtmf from bchannel (locked state)
1510 void lcr_in_dtmf(struct chan_call *call, int val)
1512 struct ast_channel *ast = call->ast;
1517 if (!call->pbx_started)
1520 if (!call->dsp_dtmf) {
1521 CDEBUG(call, call->ast, "Recognised DTMF digit '%c' by LCR, but ignoring. (disabled by option)\n", val);
1525 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1532 rc = write(wake_pipe[1], &byte, 1);
1534 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1538 * message received from LCR
1540 int receive_message(int message_type, unsigned int ref, union parameter *param)
1542 struct chan_call *call;
1543 union parameter newparam;
1546 memset(&newparam, 0, sizeof(union parameter));
1548 /* handle new ref */
1549 if (message_type == MESSAGE_NEWREF) {
1550 if (param->newref.direction) {
1551 /* new ref from lcr */
1552 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1553 if (!ref || find_call_ref(ref)) {
1554 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1557 /* allocate new call instance */
1558 call = alloc_call();
1560 call->state = CHAN_LCR_STATE_IN_PREPARE;
1563 call->ref_was_assigned = 1;
1564 /* set dtmf (default, use option 'n' to disable */
1566 /* wait for setup (or release from asterisk) */
1568 /* new ref, as requested from this remote application */
1569 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1570 call = find_call_ref(0);
1572 /* send release, if ref does not exist */
1573 CERROR(NULL, NULL, "No call found, that requests a ref.\n");
1578 call->ref_was_assigned = 1;
1579 /* set dtmf (default, use option 'n' to disable */
1581 /* send pending setup info */
1582 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1583 send_setup_to_lcr(call);
1584 /* release if asterisk has signed off */
1585 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1588 send_release(call, call->cause, call->location);
1590 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1601 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1604 call = find_call_ref(ref);
1606 /* ignore ref that is not used (anymore) */
1607 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1611 /* handle messages */
1612 switch(message_type) {
1614 lcr_in_setup(call, message_type, param);
1617 case MESSAGE_OVERLAP:
1618 lcr_in_overlap(call, message_type, param);
1621 case MESSAGE_PROCEEDING:
1622 lcr_in_proceeding(call, message_type, param);
1625 case MESSAGE_ALERTING:
1626 lcr_in_alerting(call, message_type, param);
1629 case MESSAGE_CONNECT:
1630 lcr_in_connect(call, message_type, param);
1633 case MESSAGE_DISCONNECT:
1634 lcr_in_disconnect(call, message_type, param);
1637 case MESSAGE_RELEASE:
1638 lcr_in_release(call, message_type, param);
1641 case MESSAGE_INFORMATION:
1642 lcr_in_information(call, message_type, param);
1645 case MESSAGE_NOTIFY:
1646 lcr_in_notify(call, message_type, param);
1649 case MESSAGE_FACILITY:
1650 lcr_in_facility(call, message_type, param);
1653 case MESSAGE_PATTERN: // audio available from LCR
1654 if (!call->has_pattern)
1655 lcr_in_pattern(call, message_type, param);
1658 case MESSAGE_NOPATTERN: // audio not available from LCR
1661 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1662 call->audiopath = param->audiopath;
1665 case MESSAGE_TRAFFIC: // if remote audio connected or hold
1667 unsigned char *p = param->traffic.data;
1668 int i, len = param->traffic.len;
1669 for (i = 0; i < len; i++, p++)
1672 rc = write(call->pipe[1], param->traffic.data, param->traffic.len);
1676 lcr_in_dtmf(call, param->dtmf);
1680 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1687 * release all calls (due to broken socket)
1689 static void release_all_calls(void)
1691 struct chan_call *call;
1696 /* no ast, so we may directly free call */
1698 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1702 /* already in release process */
1703 if (call->state == CHAN_LCR_STATE_RELEASE) {
1707 /* release or queue release */
1709 call->state = CHAN_LCR_STATE_RELEASE;
1710 if (!call->pbx_started) {
1711 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1712 ast_hangup(call->ast); // call will be destroyed here
1715 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1720 rc = write(wake_pipe[1], &byte, 1);
1722 strcpy(call->queue_string, "H");
1727 void close_socket(void);
1730 * warning! not thread safe
1731 * returns -1 for socket error, 0 for no work, 1 for work
1733 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1736 struct admin_list *admin;
1737 struct admin_message msg;
1739 if ((what & LCR_FD_READ)) {
1740 /* read from socket */
1741 len = read(lcr_sock, &msg, sizeof(msg));
1743 CERROR(NULL, NULL, "Socket closed.(read)\n");
1745 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1747 release_all_calls();
1748 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1752 if (len != sizeof(msg)) {
1753 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1756 if (msg.message != ADMIN_MESSAGE) {
1757 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1760 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1762 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1767 if ((what & LCR_FD_WRITE)) {
1768 /* write to socket */
1770 socket_fd.when &= ~LCR_FD_WRITE;
1773 admin = admin_first;
1774 len = write(lcr_sock, &admin->msg, sizeof(msg));
1776 CERROR(NULL, NULL, "Socket closed.(write)\n");
1780 if (len != sizeof(msg)) {
1781 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1785 admin_first = admin->next;
1789 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1798 * open and close socket and thread
1800 int open_socket(void)
1803 struct sockaddr_un sock_address;
1804 union parameter param;
1807 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1808 CERROR(NULL, NULL, "Failed to create socket.\n");
1812 /* set socket address and name */
1813 memset(&sock_address, 0, sizeof(sock_address));
1814 sock_address.sun_family = PF_UNIX;
1815 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1817 /* connect socket */
1818 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1821 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1825 /* register socket fd */
1826 memset(&socket_fd, 0, sizeof(socket_fd));
1827 socket_fd.fd = lcr_sock;
1828 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1830 /* enque hello message */
1831 memset(¶m, 0, sizeof(param));
1832 strcpy(param.hello.application, "asterisk");
1833 send_message(MESSAGE_HELLO, 0, ¶m);
1838 void close_socket(void)
1840 struct admin_list *admin, *temp;
1842 /* socket not created */
1846 unregister_fd(&socket_fd);
1848 /* flush pending messages */
1849 admin = admin_first;
1852 admin = admin->next;
1864 /* sending queue to asterisk */
1865 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1870 rc = read(wake_pipe[0], &byte, 1);
1877 static void handle_queue()
1879 struct chan_call *call;
1880 struct ast_channel *ast;
1881 struct ast_frame fr;
1887 p = call->queue_string;
1890 if (ast_channel_trylock(ast)) {
1891 ast_mutex_unlock(&chan_lock);
1893 ast_mutex_lock(&chan_lock);
1899 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1900 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1903 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1904 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1907 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1908 ast_queue_control(ast, AST_CONTROL_RINGING);
1909 ast_setstate(ast, AST_STATE_RINGING);
1912 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1913 ast_queue_control(ast, AST_CONTROL_ANSWER);
1916 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1917 ast_queue_hangup(ast);
1919 case '1': case '2': case '3': case 'A':
1920 case '4': case '5': case '6': case 'B':
1921 case '7': case '8': case '9': case 'C':
1922 case '*': case '0': case '#': case 'D':
1923 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1924 /* send digit to asterisk */
1925 memset(&fr, 0, sizeof(fr));
1927 #ifdef LCR_FOR_ASTERISK
1928 fr.frametype = AST_FRAME_DTMF_BEGIN;
1931 #ifdef LCR_FOR_CALLWEAVER
1932 fr.frametype = AST_FRAME_DTMF;
1935 #ifdef AST_1_8_OR_HIGHER
1936 fr.subclass.integer = *p;
1940 fr.delivery = ast_tv(0, 0);
1941 ast_queue_frame(ast, &fr);
1943 #ifdef LCR_FOR_ASTERISK
1944 fr.frametype = AST_FRAME_DTMF_END;
1945 ast_queue_frame(ast, &fr);
1950 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1954 call->queue_string[0] = '\0';
1955 ast_channel_unlock(ast);
1961 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1963 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1964 if (open_socket() < 0)
1965 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1970 void lock_chan(void)
1972 ast_mutex_lock(&chan_lock);
1975 void unlock_chan(void)
1977 ast_mutex_unlock(&chan_lock);
1980 /* chan_lcr thread */
1981 static void *chan_thread(void *arg)
1983 if (pipe(wake_pipe) < 0) {
1984 CERROR(NULL, NULL, "Failed to open pipe.\n");
1987 memset(&wake_fd, 0, sizeof(wake_fd));
1988 wake_fd.fd = wake_pipe[0];
1989 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1991 memset(&socket_retry, 0, sizeof(socket_retry));
1992 add_timer(&socket_retry, handle_retry, NULL, 0);
1994 /* open socket the first time */
1995 handle_retry(NULL, NULL, 0);
1997 ast_mutex_lock(&chan_lock);
2001 select_main(0, &global_change, lock_chan, unlock_chan);
2008 * new asterisk instance
2011 #ifdef AST_1_8_OR_HIGHER
2012 #if ASTERISK_VERSION_NUM < 100000
2013 struct ast_channel *lcr_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
2015 struct ast_channel *lcr_request(const char *type, struct ast_format_cap *format, const struct ast_channel *requestor, void *data, int *cause)
2018 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
2021 char exten[256], *dial, *interface, *opt;
2022 struct ast_channel *ast;
2023 struct chan_call *call;
2024 #ifdef AST_1_8_OR_HIGHER
2025 const struct ast_party_redirecting *req_redir;
2026 const struct ast_party_caller *req_caller;
2029 ast_mutex_lock(&chan_lock);
2030 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
2032 /* if socket is closed */
2034 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
2035 ast_mutex_unlock(&chan_lock);
2039 /* create call instance */
2040 call = alloc_call();
2042 /* failed to create instance */
2043 ast_mutex_unlock(&chan_lock);
2047 /* create asterisk channel instrance */
2049 #ifdef LCR_FOR_ASTERISK
2050 #ifdef AST_1_8_OR_HIGHER
2051 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, NULL, NULL, NULL, NULL, 0, "%s/%d", lcr_type, ++glob_channel);
2053 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
2057 #ifdef LCR_FOR_CALLWEAVER
2058 ast = ast_channel_alloc(1);
2062 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
2064 /* failed to create instance */
2065 ast_mutex_unlock(&chan_lock);
2068 #if ASTERISK_VERSION_NUM < 110000
2069 ast->tech = &lcr_tech;
2070 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
2071 #ifdef AST_1_8_OR_HIGHER
2072 req_redir = &requestor->redirecting;
2073 req_caller = &requestor->caller;
2076 ast_channel_tech_set(ast, &lcr_tech);
2077 ast_channel_tech_pvt_set(ast, (void *)1L); // set pointer or asterisk will not call
2078 req_redir = ast_channel_redirecting(requestor);
2079 req_caller = ast_channel_caller(requestor);
2081 /* configure channel */
2082 #if ASTERISK_VERSION_NUM < 100000
2083 #if ASTERISK_VERSION_NUM < 110000
2084 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2085 ast->readformat = ast->rawreadformat = ast->nativeformats;
2086 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
2088 ast_channel_nativeformats_set(ast, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
2089 ast->readformat = ast->rawreadformat = ast_channel_nativeformats(ast);
2090 ast->writeformat = ast->rawwriteformat = ast_channel_nativeformats(ast);
2093 #if ASTERISK_VERSION_NUM < 110000
2094 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2095 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
2096 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
2097 ast_set_write_format(ast, &ast->rawwriteformat);
2098 ast_set_read_format(ast, &ast->rawreadformat);
2100 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2101 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
2102 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
2103 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
2104 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
2107 #if ASTERISK_VERSION_NUM < 110000
2109 ast->hangupcause = 0;
2111 ast_channel_priority_set(ast, 1);
2112 ast_channel_hangupcause_set(ast, 0);
2117 #if ASTERISK_VERSION_NUM < 110000
2118 ast->tech_pvt = call;
2119 ast->fds[0] = call->pipe[0];
2121 ast_channel_tech_pvt_set(ast, call);
2122 ast_channel_set_fd(ast, 0, call->pipe[0]);
2124 call->pbx_started = 0;
2126 call->state = CHAN_LCR_STATE_OUT_PREPARE;
2129 * Extract interface, dialstring, options from data.
2132 * <interface>/<dialstring>
2133 * <interface>/<dialstring>/options
2135 strncpy(exten, (char *)data, sizeof(exten)-1);
2136 exten[sizeof(exten)-1] = '\0';
2137 if ((dial = strchr(exten, '/'))) {
2140 if ((opt = strchr(dial, '/')))
2149 strncpy(call->interface, interface, sizeof(call->interface)-1);
2150 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
2151 apply_opt(call, (char *)opt);
2153 #ifdef AST_1_8_OR_HIGHER
2154 // clone_variables(requestor, ast);
2157 ast->caller.ani.number.valid= req_caller->ani.number.valid;
2158 if (req_caller->ani.number.valid)
2159 if (req_caller->ani.number.str)
2160 if (req_caller->ani.number.str[0])
2161 ast->caller.ani.number.str= strdup(req_caller->ani.number.str);
2162 ast->caller.ani.number.plan= req_caller->ani.number.plan;
2163 ast->caller.ani.number.presentation= req_caller->ani.number.presentation;
2165 ast->caller.ani.name.valid= req_caller->ani.name.valid;
2166 if (req_caller->ani.name.valid)
2167 if (req_caller->ani.name.str)
2168 if (req_caller->ani.name.str[0])
2169 ast->caller.ani.name.str= strdup(req_caller->ani.name.str);
2170 ast->caller.ani.name.presentation= req_caller->ani.name.presentation;
2172 ast->caller.ani.subaddress.valid= req_caller->ani.subaddress.valid;
2173 if (req_caller->ani.subaddress.valid)
2174 if (req_caller->ani.subaddress.str)
2175 if (req_caller->ani.subaddress.str[0])
2176 ast->caller.ani.subaddress.str= strdup(req_caller->ani.subaddress.str);
2177 ast->caller.ani.subaddress.type= req_caller->ani.subaddress.type;
2179 ast->caller.id.number.valid= req_caller->id.number.valid;
2180 if (req_caller->id.number.valid)
2181 if (req_caller->id.number.str)
2182 if (req_caller->id.number.str[0])
2183 ast->caller.id.number.str= strdup(req_caller->id.number.str);
2184 ast->caller.id.number.plan= req_caller->id.number.plan;
2185 ast->caller.id.number.presentation= req_caller->id.number.presentation;
2187 ast->caller.id.name.valid= req_caller->id.name.valid;
2188 if (req_caller->id.name.valid)
2189 if (req_caller->id.name.str)
2190 if (req_caller->id.name.str[0])
2191 ast->caller.id.name.str= strdup(req_caller->id.name.str);
2192 ast->caller.id.name.presentation= req_caller->id.name.presentation;
2194 ast->caller.id.subaddress.valid= req_caller->id.subaddress.valid;
2195 if (req_caller->id.subaddress.valid)
2196 if (req_caller->id.subaddress.str)
2197 if (req_caller->id.subaddress.str[0])
2198 ast->caller.id.subaddress.str= strdup(req_caller->id.subaddress.str);
2199 ast->caller.id.subaddress.type= req_caller->id.subaddress.type;
2201 if (requestor->dialed.number.str)
2202 if (requestor->dialed.number.str[0])
2203 ast->dialed.number.str= strdup(requestor->dialed.number.str);
2204 ast->dialed.number.plan= requestor->dialed.number.plan;
2206 ast->dialed.subaddress.valid= requestor->dialed.subaddress.valid;
2207 if (requestor->dialed.subaddress.valid)
2208 if (requestor->dialed.subaddress.str)
2209 if (requestor->dialed.subaddress.str[0])
2210 ast->dialed.subaddress.str= strdup(requestor->dialed.subaddress.str);
2211 ast->dialed.subaddress.type= requestor->dialed.subaddress.type;
2213 ast->dialed.transit_network_select= requestor->dialed.transit_network_select;
2214 ast->redirecting.count= req_redir->count;
2215 ast->redirecting.reason= req_redir->reason;
2217 ast->redirecting.from.number.valid= req_redir->from.number.valid;
2218 if (req_redir->from.number.valid)
2219 if (req_redir->from.number.str)
2220 if (req_redir->from.number.str[0])
2221 ast->redirecting.from.number.str= strdup(req_redir->from.number.str);
2222 ast->redirecting.from.number.plan= req_redir->from.number.plan;
2223 ast->redirecting.from.number.presentation= req_redir->from.number.presentation;
2225 ast->redirecting.to.number.valid= req_redir->to.number.valid;
2226 if (req_redir->to.number.valid)
2227 if (req_redir->to.number.str)
2228 if (req_redir->to.number.str[0])
2229 ast->redirecting.to.number.str= strdup(req_redir->to.number.str);
2230 ast->redirecting.to.number.plan= req_redir->to.number.plan;
2231 ast->redirecting.to.number.presentation= req_redir->to.number.presentation;
2233 /* store call information for setup */
2236 if (requestor && req_caller->id.number.valid) {
2237 if (req_caller->id.number.str)
2238 strncpy(call->callerinfo.id, req_caller->id.number.str, sizeof(call->callerinfo.id)-1);
2239 switch(req_caller->id.number.presentation & AST_PRES_RESTRICTION) {
2240 case AST_PRES_RESTRICTED:
2241 call->callerinfo.present = INFO_PRESENT_RESTRICTED;
2243 case AST_PRES_UNAVAILABLE:
2244 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2246 case AST_PRES_ALLOWED:
2248 call->callerinfo.present = INFO_PRESENT_ALLOWED;
2250 switch(req_caller->id.number.presentation & AST_PRES_NUMBER_TYPE) {
2251 case AST_PRES_USER_NUMBER_UNSCREENED:
2252 call->callerinfo.screen = INFO_SCREEN_USER;
2254 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2255 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2257 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2258 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2261 call->callerinfo.screen = INFO_SCREEN_NETWORK;
2263 switch((req_caller->id.number.plan >> 4) & 7) {
2265 call->callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2268 call->callerinfo.ntype = INFO_NTYPE_NATIONAL;
2271 call->callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2274 call->callerinfo.ntype = INFO_NTYPE_UNKNOWN;
2277 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2280 if (requestor && req_caller->ani.number.valid) {
2281 if (req_caller->ani.number.str)
2282 strncpy(call->callerinfo.id2, req_caller->ani.number.str, sizeof(call->callerinfo.id2)-1);
2283 switch(req_caller->ani.number.presentation & AST_PRES_RESTRICTION) {
2284 case AST_PRES_RESTRICTED:
2285 call->callerinfo.present2 = INFO_PRESENT_RESTRICTED;
2287 case AST_PRES_UNAVAILABLE:
2288 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2290 case AST_PRES_ALLOWED:
2292 call->callerinfo.present2 = INFO_PRESENT_ALLOWED;
2294 switch(req_caller->ani.number.presentation & AST_PRES_NUMBER_TYPE) {
2295 case AST_PRES_USER_NUMBER_UNSCREENED:
2296 call->callerinfo.screen2 = INFO_SCREEN_USER;
2298 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2299 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_PASSED;
2301 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2302 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_FAILED;
2305 call->callerinfo.screen2 = INFO_SCREEN_NETWORK;
2307 switch((req_caller->ani.number.plan >> 4) & 7) {
2309 call->callerinfo.ntype2 = INFO_NTYPE_SUBSCRIBER;
2312 call->callerinfo.ntype2 = INFO_NTYPE_NATIONAL;
2315 call->callerinfo.ntype2 = INFO_NTYPE_INTERNATIONAL;
2318 call->callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
2321 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2324 if (requestor && req_caller->id.name.valid) {
2325 if (req_caller->id.name.str)
2326 strncpy(call->callerinfo.name, req_caller->id.name.str, sizeof(call->callerinfo.name)-1);
2330 if (requestor && req_redir->from.number.valid) {
2331 call->redirinfo.itype = INFO_ITYPE_CHAN;
2332 if (req_redir->from.number.str)
2333 strncpy(call->redirinfo.id, req_redir->from.number.str, sizeof(call->redirinfo.id)-1);
2334 switch(req_redir->from.number.presentation & AST_PRES_RESTRICTION) {
2335 case AST_PRES_RESTRICTED:
2336 call->redirinfo.present = INFO_PRESENT_RESTRICTED;
2338 case AST_PRES_UNAVAILABLE:
2339 call->redirinfo.present = INFO_PRESENT_NOTAVAIL;
2341 case AST_PRES_ALLOWED:
2343 call->redirinfo.present = INFO_PRESENT_ALLOWED;
2345 switch(req_redir->from.number.presentation & AST_PRES_NUMBER_TYPE) {
2346 case AST_PRES_USER_NUMBER_UNSCREENED:
2347 call->redirinfo.screen = INFO_SCREEN_USER;
2349 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2350 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2352 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2353 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2356 call->redirinfo.screen = INFO_SCREEN_NETWORK;
2358 switch((req_redir->from.number.plan >> 4) & 7) {
2360 call->redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2363 call->redirinfo.ntype = INFO_NTYPE_NATIONAL;
2366 call->redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2369 call->redirinfo.ntype = INFO_NTYPE_UNKNOWN;
2374 ast_mutex_unlock(&chan_lock);
2379 * call from asterisk
2381 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
2383 union parameter newparam;
2384 struct chan_call *call;
2385 #if ASTERISK_VERSION_NUM >= 110000
2386 int transfercapability;
2389 ast_mutex_lock(&chan_lock);
2390 #if ASTERISK_VERSION_NUM < 110000
2391 call = ast->tech_pvt;
2393 call = ast_channel_tech_pvt(ast);
2396 #ifdef LCR_FOR_CALLWEAVER
2398 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type, call->dialstring, ast_random() & 0xffff);
2402 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
2403 ast_mutex_unlock(&chan_lock);
2407 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
2409 /* pbx process is started */
2410 call->pbx_started = 1;
2411 /* send MESSAGE_NEWREF */
2412 memset(&newparam, 0, sizeof(union parameter));
2413 newparam.newref.direction = 0; /* request from app */
2414 send_message(MESSAGE_NEWREF, 0, &newparam);
2416 /* set hdlc if capability requires hdlc */
2417 #if ASTERISK_VERSION_NUM < 110000
2418 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
2419 || ast->transfercapability == INFO_BC_DATARESTRICTED
2420 || ast->transfercapability == INFO_BC_VIDEO)
2422 transfercapability=ast_channel_transfercapability(ast);
2423 if (transfercapability == INFO_BC_DATAUNRESTRICTED
2424 || transfercapability == INFO_BC_DATARESTRICTED
2425 || transfercapability == INFO_BC_VIDEO)
2428 /* if hdlc is forced by option, we change transcap to data */
2430 #if ASTERISK_VERSION_NUM < 110000
2431 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
2432 && ast->transfercapability != INFO_BC_DATARESTRICTED
2433 && ast->transfercapability != INFO_BC_VIDEO)
2434 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
2436 && transfercapability != INFO_BC_DATAUNRESTRICTED
2437 && transfercapability != INFO_BC_DATARESTRICTED
2438 && transfercapability != INFO_BC_VIDEO)
2439 transfercapability = INFO_BC_DATAUNRESTRICTED;
2442 #ifndef AST_1_8_OR_HIGHER
2443 call->cid_num[0] = 0;
2444 call->cid_name[0] = 0;
2445 call->cid_rdnis[0] = 0;
2447 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
2448 strncpy(call->cid_num, ast->cid.cid_num,
2449 sizeof(call->cid_num)-1);
2450 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
2451 strncpy(call->cid_name, ast->cid.cid_name,
2452 sizeof(call->cid_name)-1);
2453 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
2454 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
2455 sizeof(call->cid_rdnis)-1);
2458 ast_mutex_unlock(&chan_lock);
2462 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2464 static const char* dtmf_tones[] = {
2465 "!941+1336/100,!0/100", /* 0 */
2466 "!697+1209/100,!0/100", /* 1 */
2467 "!697+1336/100,!0/100", /* 2 */
2468 "!697+1477/100,!0/100", /* 3 */
2469 "!770+1209/100,!0/100", /* 4 */
2470 "!770+1336/100,!0/100", /* 5 */
2471 "!770+1477/100,!0/100", /* 6 */
2472 "!852+1209/100,!0/100", /* 7 */
2473 "!852+1336/100,!0/100", /* 8 */
2474 "!852+1477/100,!0/100", /* 9 */
2475 "!697+1633/100,!0/100", /* A */
2476 "!770+1633/100,!0/100", /* B */
2477 "!852+1633/100,!0/100", /* C */
2478 "!941+1633/100,!0/100", /* D */
2479 "!941+1209/100,!0/100", /* * */
2480 "!941+1477/100,!0/100" }; /* # */
2482 if (digit >= '0' && digit <='9')
2483 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2484 else if (digit >= 'A' && digit <= 'D')
2485 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2486 else if (digit == '*')
2487 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2488 else if (digit == '#')
2489 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2491 #if ASTERISK_VERSION_NUM < 110000
2492 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
2494 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
2499 #ifdef LCR_FOR_ASTERISK
2500 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2502 #ifdef LCR_FOR_CALLWEAVER
2503 static int lcr_digit(struct ast_channel *ast, char digit)
2506 struct chan_call *call;
2507 union parameter newparam;
2510 #ifdef LCR_FOR_CALLWEAVER
2511 int inband_dtmf = 0;
2514 /* only pass IA5 number space */
2515 if (digit > 126 || digit < 32)
2518 ast_mutex_lock(&chan_lock);
2519 #if ASTERISK_VERSION_NUM < 110000
2520 call = ast->tech_pvt;
2522 call = ast_channel_tech_pvt(ast);
2525 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2526 ast_mutex_unlock(&chan_lock);
2530 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2532 /* send information or queue them */
2533 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2534 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2535 memset(&newparam, 0, sizeof(union parameter));
2537 newparam.information.keypad[0] = digit;
2538 newparam.information.keypad[1] = '\0';
2540 newparam.information.id[0] = digit;
2541 newparam.information.id[1] = '\0';
2543 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2546 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2547 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2549 strncat(call->dialque, buf, strlen(call->dialque)-1);
2552 ast_mutex_unlock(&chan_lock);
2554 #ifdef LCR_FOR_ASTERISK
2558 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2560 int inband_dtmf = 0;
2561 struct chan_call *call;
2564 ast_mutex_lock(&chan_lock);
2566 #if ASTERISK_VERSION_NUM < 110000
2567 call = ast->tech_pvt;
2569 call = ast_channel_tech_pvt(ast);
2574 "Received digit from Asterisk, "
2575 "but no call instance exists.\n");
2576 ast_mutex_unlock(&chan_lock);
2580 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2582 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2586 ast_mutex_unlock(&chan_lock);
2589 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2590 send_digit_to_chan(ast, digit);
2596 static int lcr_answer(struct ast_channel *ast)
2598 union parameter newparam;
2599 struct chan_call *call;
2601 ast_mutex_lock(&chan_lock);
2602 #if ASTERISK_VERSION_NUM < 110000
2603 call = ast->tech_pvt;
2605 call = ast_channel_tech_pvt(ast);
2608 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2609 ast_mutex_unlock(&chan_lock);
2613 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2615 /* copy connectinfo, if bridged */
2616 if (call->bridge_call)
2617 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2618 /* send connect message to lcr */
2619 if (call->state != CHAN_LCR_STATE_CONNECT) {
2620 memset(&newparam, 0, sizeof(union parameter));
2621 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2622 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2623 call->state = CHAN_LCR_STATE_CONNECT;
2627 // memset(&newparam, 0, sizeof(union parameter));
2628 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2630 ast_mutex_unlock(&chan_lock);
2634 static int lcr_hangup(struct ast_channel *ast)
2636 struct chan_call *call;
2637 pthread_t tid = pthread_self();
2639 if (!pthread_equal(tid, chan_tid)) {
2640 ast_mutex_lock(&chan_lock);
2642 #if ASTERISK_VERSION_NUM < 110000
2643 call = ast->tech_pvt;
2645 call = ast_channel_tech_pvt(ast);
2648 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2649 if (!pthread_equal(tid, chan_tid)) {
2650 ast_mutex_unlock(&chan_lock);
2655 if (!pthread_equal(tid, chan_tid))
2656 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2658 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2660 /* disconnect asterisk, maybe not required */
2661 #if ASTERISK_VERSION_NUM < 110000
2662 ast->tech_pvt = NULL;
2665 ast_channel_tech_pvt_set(ast, NULL);
2666 ast_channel_set_fd(ast, 0, -1);
2670 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2671 #if ASTERISK_VERSION_NUM < 110000
2672 if (ast->hangupcause > 0)
2673 send_release(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2675 if (ast_channel_hangupcause(ast) > 0)
2676 send_release(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
2679 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2682 if (!pthread_equal(tid, chan_tid)) {
2683 ast_mutex_unlock(&chan_lock);
2687 /* ref is not set, due to prepare setup or release */
2688 if (call->state == CHAN_LCR_STATE_RELEASE) {
2689 /* we get the response to our release */
2690 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2693 /* during prepare, we change to release state */
2694 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2695 call->state = CHAN_LCR_STATE_RELEASE;
2699 if (!pthread_equal(tid, chan_tid)) {
2700 ast_mutex_unlock(&chan_lock);
2705 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2707 union parameter newparam;
2708 struct chan_call *call;
2709 struct ast_frame * f = fr;
2710 unsigned char *p, *q;
2713 #if ASTERISK_VERSION_NUM < 100000
2714 #ifdef AST_1_8_OR_HIGHER
2715 if (!f->subclass.codec)
2719 CDEBUG(NULL, ast, "No subclass\n");
2721 #ifdef AST_1_8_OR_HIGHER
2722 #if ASTERISK_VERSION_NUM < 100000
2723 #if ASTERISK_VERSION_NUM < 110000
2724 if (!(f->subclass.codec & ast->nativeformats)) {
2726 if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
2729 #if ASTERISK_VERSION_NUM < 110000
2730 if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
2732 if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
2736 #if ASTERISK_VERSION_NUM < 110000
2737 if (!(f->subclass & ast->nativeformats)) {
2739 if (!(f->subclass & ast_channel_nativeformats(ast))) {
2743 "Unexpected format. "
2744 "Activating emergency conversion...\n");
2746 #ifdef AST_1_8_OR_HIGHER
2747 #if ASTERISK_VERSION_NUM < 100000
2748 ast_set_write_format(ast, f->subclass.codec);
2750 ast_set_write_format(ast, &f->subclass.format);
2753 ast_set_write_format(ast, f->subclass);
2755 #if ASTERISK_VERSION_NUM < 110000
2756 f = (ast->writetrans) ? ast_translate(
2757 ast->writetrans, fr, 0) : fr;
2759 f = (ast_channel_writetrans(ast)) ? ast_translate(
2760 ast_channel_writetrans(ast), fr, 0) : fr;
2764 ast_mutex_lock(&chan_lock);
2765 #if ASTERISK_VERSION_NUM < 110000
2766 call = ast->tech_pvt;
2768 call = ast_channel_tech_pvt(ast);
2770 if (!call || !call->ref) {
2771 ast_mutex_unlock(&chan_lock);
2778 p = *((unsigned char **)&(f->data));
2779 q = newparam.traffic.data;
2780 memset(&newparam, 0, sizeof(union parameter));
2782 l = (len > sizeof(newparam.traffic.data)) ? sizeof(newparam.traffic.data) : len;
2783 newparam.traffic.len = l;
2786 *q++ = flip_bits[*p++];
2787 send_message(MESSAGE_TRAFFIC, call->ref, &newparam);
2789 ast_mutex_unlock(&chan_lock);
2797 static struct ast_frame *lcr_read(struct ast_channel *ast)
2799 struct chan_call *call;
2801 struct ast_frame *f;
2803 ast_mutex_lock(&chan_lock);
2804 #if ASTERISK_VERSION_NUM < 110000
2805 call = ast->tech_pvt;
2807 call = ast_channel_tech_pvt(ast);
2810 ast_mutex_unlock(&chan_lock);
2813 if (call->pipe[0] > -1) {
2814 if (call->rebuffer && !call->hdlc) {
2815 /* Make sure we have a complete 20ms (160byte) frame */
2816 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2818 call->framepos += len;
2821 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2823 if (len < 0 && errno == EAGAIN) {
2824 ast_mutex_unlock(&chan_lock);
2826 #ifdef LCR_FOR_ASTERISK
2827 return &ast_null_frame;
2830 #ifdef LCR_FOR_CALLWEAVER
2836 close(call->pipe[0]);
2839 ast_mutex_unlock(&chan_lock);
2841 } else if (call->rebuffer && call->framepos < 160) {
2842 /* Not a complete frame, so we send a null-frame */
2843 ast_mutex_unlock(&chan_lock);
2844 return &ast_null_frame;
2848 call->read_fr.frametype = AST_FRAME_VOICE;
2849 #ifdef AST_1_8_OR_HIGHER
2850 #if ASTERISK_VERSION_NUM < 100000
2851 #if ASTERISK_VERSION_NUM < 110000
2852 call->read_fr.subclass.codec = ast->nativeformats;
2854 call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
2857 #if ASTERISK_VERSION_NUM < 110000
2858 ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
2860 ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
2862 call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
2865 #if ASTERISK_VERSION_NUM < 110000
2866 call->read_fr.subclass = ast->nativeformats;
2868 call->read_fr.subclass = ast_channel_nativeformats(ast);
2871 if (call->rebuffer) {
2872 call->read_fr.datalen = call->framepos;
2873 call->read_fr.samples = call->framepos;
2876 call->read_fr.datalen = len;
2877 call->read_fr.samples = len;
2879 call->read_fr.delivery = ast_tv(0,0);
2880 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2882 f = ast_dsp_process(ast, call->dsp, &call->read_fr);
2883 if (f && f->frametype == AST_FRAME_DTMF)
2884 CDEBUG(call, ast, "Asterisk detected inband DTMF: %c.\n", f->subclass.integer);
2886 ast_mutex_unlock(&chan_lock);
2888 if (f && f->frametype == AST_FRAME_DTMF)
2891 return &call->read_fr;
2894 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2896 union parameter newparam;
2898 struct chan_call *call;
2899 const struct ast_tone_zone_sound *ts = NULL;
2901 ast_mutex_lock(&chan_lock);
2902 #if ASTERISK_VERSION_NUM < 110000
2903 call = ast->tech_pvt;
2905 call = ast_channel_tech_pvt(ast);
2908 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2909 ast_mutex_unlock(&chan_lock);
2914 case AST_CONTROL_BUSY:
2915 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2916 ast_setstate(ast, AST_STATE_BUSY);
2917 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2918 /* send message to lcr */
2919 memset(&newparam, 0, sizeof(union parameter));
2920 newparam.disconnectinfo.cause = 17;
2921 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2922 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2924 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2926 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2927 #if ASTERISK_VERSION_NUM < 110000
2928 ts = ast_get_indication_tone(ast->zone, "busy");
2930 ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
2934 case AST_CONTROL_CONGESTION:
2935 #if ASTERISK_VERSION_NUM < 110000
2936 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2938 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
2940 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2941 /* send message to lcr */
2942 memset(&newparam, 0, sizeof(union parameter));
2943 #if ASTERISK_VERSION_NUM < 110000
2944 newparam.disconnectinfo.cause = ast->hangupcause;
2946 newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
2948 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2949 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2951 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2953 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2954 #if ASTERISK_VERSION_NUM < 110000
2955 ts = ast_get_indication_tone(ast->zone, "congestion");
2957 ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
2961 case AST_CONTROL_PROCEEDING:
2962 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2963 if (call->state == CHAN_LCR_STATE_IN_SETUP
2964 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2965 /* send message to lcr */
2966 memset(&newparam, 0, sizeof(union parameter));
2967 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2969 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2972 case AST_CONTROL_RINGING:
2973 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2974 ast_setstate(ast, AST_STATE_RING);
2975 if (call->state == CHAN_LCR_STATE_IN_SETUP
2976 || call->state == CHAN_LCR_STATE_IN_DIALING
2977 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2978 /* send message to lcr */
2979 memset(&newparam, 0, sizeof(union parameter));
2980 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2982 call->state = CHAN_LCR_STATE_IN_ALERTING;
2984 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2985 #if ASTERISK_VERSION_NUM < 110000
2986 ts = ast_get_indication_tone(ast->zone, "ring");
2988 ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
2992 case AST_CONTROL_PROGRESS:
2993 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2994 /* request bchannel */
2995 CDEBUG(call, ast, "Requesting audio path.\n");
2996 memset(&newparam, 0, sizeof(union parameter));
2997 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
3000 CDEBUG(call, ast, "Received indicate -1.\n");
3001 ast_playtones_stop(ast);
3005 case AST_CONTROL_VIDUPDATE:
3006 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
3009 case AST_CONTROL_HOLD:
3010 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
3011 /* send message to lcr */
3012 memset(&newparam, 0, sizeof(union parameter));
3013 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
3014 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3016 /*start music onhold*/
3017 #ifdef LCR_FOR_ASTERISK
3018 #if ASTERISK_VERSION_NUM <110000
3019 ast_moh_start(ast,data,ast->musicclass);
3021 ast_moh_start(ast,data,ast_channel_musicclass(ast));
3025 #ifdef LCR_FOR_CALLWEAVER
3026 ast_moh_start(ast, NULL);
3031 case AST_CONTROL_UNHOLD:
3032 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
3033 /* send message to lcr */
3034 memset(&newparam, 0, sizeof(union parameter));
3035 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3036 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3042 #ifdef AST_CONTROL_SRCUPDATE
3043 case AST_CONTROL_SRCUPDATE:
3047 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
3050 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
3055 if (ts && ts->data[0]) {
3056 ast_playtones_start(ast, 0, ts->data, 1);
3060 ast_mutex_unlock(&chan_lock);
3067 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
3069 struct chan_call *call;
3075 ast_mutex_lock(&chan_lock);
3076 #if ASTERISK_VERSION_NUM < 110000
3077 call = ast->tech_pvt;
3079 call = ast_channel_tech_pvt(ast);
3082 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
3083 ast_mutex_unlock(&chan_lock);
3087 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
3089 ast_mutex_unlock(&chan_lock);
3094 * send_text asterisk
3096 static int lcr_send_text(struct ast_channel *ast, const char *text)
3098 struct chan_call *call;
3099 union parameter newparam;
3101 ast_mutex_lock(&chan_lock);
3102 #if ASTERISK_VERSION_NUM < 110000
3103 call = ast->tech_pvt;
3105 call = ast_channel_tech_pvt(ast);
3108 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
3109 ast_mutex_unlock(&chan_lock);
3113 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
3114 memset(&newparam, 0, sizeof(union parameter));
3115 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
3116 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3117 ast_mutex_unlock(&chan_lock);
3124 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
3125 struct ast_channel *ast2, int flags,
3126 struct ast_frame **fo,
3127 struct ast_channel **rc, int timeoutms)
3130 struct chan_call *call1, *call2;
3131 struct ast_channel *carr[2], *who;
3133 struct ast_frame *f;
3136 /* bridge is disabled, because there is currerntly no concept to bridge mISDN channels */
3137 return AST_BRIDGE_FAILED;
3139 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
3144 /* join via dsp (if the channels are currently open) */
3145 ast_mutex_lock(&chan_lock);
3146 #if ASTERISK_VERSION_NUM < 110000
3147 call1 = ast1->tech_pvt;
3148 call2 = ast2->tech_pvt;
3150 call1 = ast_channel_tech_pvt(ast1);
3151 call2 = ast_channel_tech_pvt(ast2);
3153 if (!call1 || !call2) {
3154 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
3155 ast_mutex_unlock(&chan_lock);
3156 return AST_BRIDGE_COMPLETE;
3159 /* join, if both call instances uses dsp
3160 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
3162 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
3164 /* get bridge id and join */
3165 bridge_id = new_bridge_id();
3167 call1->bridge_id = bridge_id;
3168 call2->bridge_id = bridge_id;
3169 // FIXME: do bridiging
3170 // bchannel_join(call1->bchannel, bridge_id);
3171 // bchannel_join(call2->bchannel, bridge_id);
3173 call1->bridge_call = call2;
3174 call2->bridge_call = call1;
3176 if (call1->state == CHAN_LCR_STATE_IN_SETUP
3177 || call1->state == CHAN_LCR_STATE_IN_DIALING
3178 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
3179 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
3180 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3183 if (call2->state == CHAN_LCR_STATE_IN_SETUP
3184 || call2->state == CHAN_LCR_STATE_IN_DIALING
3185 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
3186 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
3187 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3191 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
3192 so let's do it for them. Hmpf.
3195 if (call1->on_hold) {
3196 union parameter newparam;
3198 memset(&newparam, 0, sizeof(union parameter));
3199 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3200 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
3205 if (call2->on_hold) {
3206 union parameter newparam;
3208 memset(&newparam, 0, sizeof(union parameter));
3209 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3210 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
3215 ast_mutex_unlock(&chan_lock);
3219 who = ast_waitfor_n(carr, 2, &to);
3222 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
3227 if (!f || f->frametype == AST_FRAME_CONTROL) {
3229 CDEBUG(NULL, NULL, "Got hangup.\n");
3231 CDEBUG(NULL, NULL, "Got CONTROL.\n");
3238 if ( f->frametype == AST_FRAME_DTMF ) {
3239 CDEBUG(NULL, NULL, "Got DTMF.\n");
3255 CDEBUG(NULL, NULL, "Releasing bridge.\n");
3257 /* split channels */
3258 ast_mutex_lock(&chan_lock);
3259 #if ASTERISK_VERSION_NUM < 110000
3260 call1 = ast1->tech_pvt;
3261 call2 = ast2->tech_pvt;
3263 call1 = ast_channel_tech_pvt(ast1);
3264 call2 = ast_channel_tech_pvt(ast2);
3266 if (call1 && call1->bridge_id) {
3267 call1->bridge_id = 0;
3268 if (call1->bridge_call)
3269 call1->bridge_call->bridge_call = NULL;
3271 if (call2 && call1->bridge_id) {
3272 call2->bridge_id = 0;
3273 if (call2->bridge_call)
3274 call2->bridge_call->bridge_call = NULL;
3276 call1->bridge_call = NULL;
3277 call2->bridge_call = NULL;
3279 ast_mutex_unlock(&chan_lock);
3280 return AST_BRIDGE_COMPLETE;
3282 static struct ast_channel_tech lcr_tech = {
3284 .description = "Channel driver for connecting to Linux-Call-Router",
3285 #if ASTERISK_VERSION_NUM < 100000
3286 .capabilities = AST_FORMAT_ALAW,
3288 .requester = lcr_request,
3290 #ifdef LCR_FOR_ASTERISK
3291 .send_digit_begin = lcr_digit_begin,
3292 .send_digit_end = lcr_digit_end,
3295 #ifdef LCR_FOR_CALLWEAVER
3296 .send_digit = lcr_digit,
3300 .bridge = lcr_bridge,
3301 .hangup = lcr_hangup,
3302 .answer = lcr_answer,
3305 .indicate = lcr_indicate,
3307 .send_text = lcr_send_text,
3316 static int lcr_show_lcr (int fd, int argc, char *argv[])
3321 static int lcr_show_calls (int fd, int argc, char *argv[])
3326 static int lcr_reload_routing (int fd, int argc, char *argv[])
3331 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
3336 static int lcr_port_block (int fd, int argc, char *argv[])
3341 static int lcr_port_unblock (int fd, int argc, char *argv[])
3346 static int lcr_port_unload (int fd, int argc, char *argv[])
3351 static struct ast_cli_entry cli_show_lcr =
3352 { {"lcr", "show", "lcr", NULL},
3354 "Shows current states of LCR core",
3355 "Usage: lcr show lcr\n",
3358 static struct ast_cli_entry cli_show_calls =
3359 { {"lcr", "show", "calls", NULL},
3361 "Shows current calls made by LCR and Asterisk",
3362 "Usage: lcr show calls\n",
3365 static struct ast_cli_entry cli_reload_routing =
3366 { {"lcr", "reload", "routing", NULL},
3368 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
3369 "Usage: lcr reload routing\n",
3372 static struct ast_cli_entry cli_reload_interfaces =
3373 { {"lcr", "reload", "interfaces", NULL},
3374 lcr_reload_interfaces,
3375 "Reloads interfaces conf of LCR",
3376 "Usage: lcr reload interfaces\n",
3379 static struct ast_cli_entry cli_port_block =
3380 { {"lcr", "port", "block", NULL},
3382 "Blocks LCR port for further calls",
3383 "Usage: lcr port block \"<port>\"\n",
3386 static struct ast_cli_entry cli_port_unblock =
3387 { {"lcr", "port", "unblock", NULL},
3389 "Unblocks or loads LCR port, port is opened my mISDN",
3390 "Usage: lcr port unblock \"<port>\"\n",
3393 static struct ast_cli_entry cli_port_unload =
3394 { {"lcr", "port", "unload", NULL},
3396 "Unloads LCR port, port is closes by mISDN",
3397 "Usage: lcr port unload \"<port>\"\n",
3402 #ifdef LCR_FOR_ASTERISK
3403 #ifdef AST_1_8_OR_HIGHER
3404 static int lcr_config_exec(struct ast_channel *ast, const char *data)
3406 static int lcr_config_exec(struct ast_channel *ast, void *data)
3410 #ifdef LCR_FOR_CALLWEAVER
3411 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
3414 struct chan_call *call;
3416 ast_mutex_lock(&chan_lock);
3418 #ifdef LCR_FOR_ASTERISK
3419 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
3422 #ifdef LCR_FOR_CALLWEAVER
3423 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
3429 if (call->ast == ast)
3435 #ifdef LCR_FOR_ASTERISK
3436 apply_opt(call, (char *)data);
3439 #ifdef LCR_FOR_CALLWEAVER
3440 apply_opt(call, (char *)argv[0]);
3444 if (call->tx_queue) {
3445 union parameter newparam;
3447 memset(&newparam, 0, sizeof(union parameter));
3448 newparam.queue = call->tx_queue * 8;
3449 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
3452 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
3454 ast_mutex_unlock(&chan_lock);
3459 * module loading and destruction
3461 int load_module(void)
3464 char options_error[256];
3466 for (i = 0; i < 256; i++) {
3467 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
3468 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
3471 if (read_options(options_error) == 0) {
3472 CERROR(NULL, NULL, "%s", options_error);
3474 #ifdef LCR_FOR_ASTERISK
3475 return AST_MODULE_LOAD_DECLINE;
3478 #ifdef LCR_FOR_CALLWEAVER
3484 ast_mutex_init(&chan_lock);
3485 ast_mutex_init(&log_lock);
3487 #if ASTERISK_VERSION_NUM < 100000
3488 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
3490 struct ast_format tmp;
3491 ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
3492 if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
3493 return AST_MODULE_LOAD_DECLINE;
3495 ast_format_cap_add(lcr_tech.capabilities, &tmp);
3497 if (ast_channel_register(&lcr_tech)) {
3498 CERROR(NULL, NULL, "Unable to register channel class\n");
3501 #ifdef LCR_FOR_ASTERISK
3502 return AST_MODULE_LOAD_DECLINE;
3505 #ifdef LCR_FOR_CALLWEAVER
3510 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
3512 #ifdef LCR_FOR_ASTERISK
3513 "lcr_config(<opt><optarg>:<opt>:...)\n"
3516 #ifdef LCR_FOR_CALLWEAVER
3517 "lcr_config(<opt><optarg>:<opt>:...)\n",
3520 "Sets LCR opts. and optargs\n"
3522 "The available options are:\n"
3523 " d - Send display text on called phone, text is the optarg.\n"
3524 " n - Don't detect dtmf tones on called channel.\n"
3525 " h - Force data call (HDLC).\n"
3526 " q - Add queue to make fax stream seamless (required for fax app).\n"
3527 " Use queue size in miliseconds for optarg. (try 250)\n"
3528 " a - Adding DTMF detection.\n"
3529 " f - Adding fax detection.\n"
3531 " c - Make crypted outgoing call, optarg is keyindex.\n"
3532 " e - Perform echo cancelation on this channel.\n"
3534 " Takes mISDN pipeline option as optarg.\n"
3535 " s - Send Non Inband DTMF as inband.\n"
3536 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
3538 " vr - rxgain control\n"
3539 " vt - txgain control\n"
3541 " Volume changes at factor 2 ^ optarg.\n"
3542 " k - use keypad to dial this call.\n"
3544 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
3545 " -> use 16 for fax (3.1k audio)\n"
3547 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
3548 "options: \"n:t:q250\" for seamless audio transmission.\n"
3553 ast_cli_register(&cli_show_lcr);
3554 ast_cli_register(&cli_show_calls);
3555 ast_cli_register(&cli_reload_routing);
3556 ast_cli_register(&cli_reload_interfaces);
3557 ast_cli_register(&cli_port_block);
3558 ast_cli_register(&cli_port_unblock);
3559 ast_cli_register(&cli_port_unload);
3562 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
3563 /* failed to create thread */
3565 ast_channel_unregister(&lcr_tech);
3567 #ifdef LCR_FOR_ASTERISK
3568 return AST_MODULE_LOAD_DECLINE;
3571 #ifdef LCR_FOR_CALLWEAVER
3579 int unload_module(void)
3581 /* First, take us out of the channel loop */
3582 CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
3584 pthread_cancel(chan_tid);
3588 del_timer(&socket_retry);
3590 unregister_fd(&wake_fd);
3591 close(wake_pipe[0]);
3592 close(wake_pipe[1]);
3594 // ast_mutex_unlock(&chan_lock);
3596 ast_channel_unregister(&lcr_tech);
3598 ast_unregister_application("lcr_config");
3600 if (lcr_sock >= 0) {
3605 #if ASTERISK_VERSION_NUM >= 100000
3606 lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
3611 int reload_module(void)
3617 #ifdef LCR_FOR_ASTERISK
3618 #define AST_MODULE "chan_lcr"
3621 #ifdef LCR_FOR_CALLWEAVER
3626 ast_mutex_lock(&usecnt_lock);
3628 ast_mutex_unlock(&usecnt_lock);
3633 #ifdef LCR_FOR_ASTERISK
3634 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3635 .load = load_module,
3636 .unload = unload_module,
3637 .reload = reload_module,
3641 #ifdef LCR_FOR_CALLWEAVER
3642 char *description(void)