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");
335 /* unset dtmf (default, use option 'd' to enable) */
336 (*callp)->dsp_dtmf = 0;
341 unsigned short new_bridge_id(void)
343 struct chan_call *call;
344 unsigned short id = 1;
346 /* search for lowest bridge id that is not in use and not 0 */
350 if (call->bridge_id == id)
358 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
363 * enque message to LCR
365 int send_message(int message_type, unsigned int ref, union parameter *param)
367 struct admin_list *admin, **adminp;
370 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
373 if (message_type != MESSAGE_TRAFFIC)
374 CDEBUG(NULL, NULL, "Sending %s to socket. (ref=%d)\n", messages_txt[message_type], ref);
376 adminp = &admin_first;
378 adminp = &((*adminp)->next);
379 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
381 CERROR(NULL, NULL, "No memory for message to LCR.\n");
386 admin->msg.message = ADMIN_MESSAGE;
387 admin->msg.u.msg.type = message_type;
388 admin->msg.u.msg.ref = ref;
389 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
390 socket_fd.when |= LCR_FD_WRITE;
395 rc = write(wake_pipe[1], &byte, 1);
402 * apply options (in locked state)
404 void apply_opt(struct chan_call *call, char *data)
406 union parameter newparam;
407 char string[1024], *p = string, *opt;//, *key;
413 strncpy(string, data, sizeof(string)-1);
414 string[sizeof(string)-1] = '\0';
417 while((opt = strsep(&p, ":"))) {
420 if (opt[1] == '\0') {
421 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
424 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
425 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
426 strncpy(call->display, opt+1, sizeof(call->display)-1);
428 memset(&newparam, 0, sizeof(union parameter));
429 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
430 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
434 if (opt[1] != '\0') {
435 CERROR(call, call->ast, "Option 'D' (DTMF) expects no parameter.\n", opt);
438 CDEBUG(call, call->ast, "Option 'D' (DTMF).\n");
443 if (opt[1] == '\0') {
444 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
448 /* check for 0xXXXX... type of key */
449 if (!!strncmp((char *)key, "0x", 2)) {
450 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
454 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
455 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
460 if (*key>='0' && *key<='9')
461 call->bf_key[i] = (*key-'0') << 8;
462 else if (*key>='a' && *key<='f')
463 call->bf_key[i] = (*key-'a'+10) << 8;
464 else if (*key>='A' && *key<='F')
465 call->bf_key[i] = (*key-'A'+10) << 8;
469 if (*key>='0' && *key<='9')
470 call->bf_key[i] += (*key - '0');
471 else if (*key>='a' && *key<='f')
472 call->bf_key[i] += (*key - 'a' + 10);
473 else if (*key>='A' && *key<='F')
474 call->bf_key[i] += (*key - 'A' + 10);
481 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
485 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
487 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
491 if (opt[1] != '\0') {
492 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
495 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
500 if (opt[1] == '\0') {
501 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
504 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
505 call->tx_queue = atoi(opt+1);
509 if (opt[1] == '\0') {
510 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
513 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
514 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
516 bchannel_pipeline(call->bchannel, call->pipeline);
520 if (opt[1] != '\0') {
521 CERROR(call, call->ast, "Option 'f' (faxdetect) expects no parameter.\n", opt);
526 CDEBUG(call, call->ast, "Option 'f' (faxdetect).\n");
529 if (opt[1] != '\0') {
530 CERROR(call, call->ast, "Option 'a' (asterisk DTMF) expects no parameter.\n", opt);
535 CDEBUG(call, call->ast, "Option 'a' (Asterisk DTMF detection).\n");
538 if (opt[1] != '\0') {
539 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
542 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
547 if (opt[1] != '\0') {
548 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
551 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
552 call->inband_dtmf = 1;
556 if (opt[1] != 'r' && opt[1] != 't') {
557 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
561 if (gain < -8 || gain >8) {
562 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
565 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
567 call->rx_gain = gain;
569 bchannel_gain(call->bchannel, call->rx_gain, 0);
571 call->tx_gain = gain;
573 bchannel_gain(call->bchannel, call->tx_gain, 1);
578 if (opt[1] != '\0') {
579 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
582 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
587 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
591 if (call->faxdetect || call->ast_dsp) {
593 call->dsp=ast_dsp_new();
595 #ifdef LCR_FOR_CALLWEAVER
596 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_CNG_DETECT : 0));
598 #ifdef LCR_FOR_ASTERISK
599 #ifdef DSP_FEATURE_DTMF_DETECT
600 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_DETECT : 0));
602 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_DETECT : 0));
607 #ifdef LCR_FOR_CALLWEAVER
608 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
610 #ifdef LCR_FOR_ASTERISK
611 #if ASTERISK_VERSION_NUM < 100000
612 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
614 // struct ast_format src;
615 // struct ast_format dst;
616 // ast_format_set(&dst, AST_FORMAT_SLINEAR, 0);
617 // ast_format_set(&dst,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
618 // call->trans=ast_translator_build_path(&dst, &src);
627 * send setup info to LCR
628 * this function is called, when asterisk call is received and ref is received
630 static void send_setup_to_lcr(struct chan_call *call)
632 union parameter newparam;
633 struct ast_channel *ast = call->ast;
636 if (!call->ast || !call->ref)
639 #ifdef AST_1_8_OR_HIGHER
640 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->callerinfo.id);
642 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
645 /* send setup message to LCR */
646 memset(&newparam, 0, sizeof(union parameter));
647 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
648 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
650 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
652 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
653 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
654 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
655 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
656 call->display[0] = '\0';
658 #ifdef AST_1_8_OR_HIGHER
659 /* set stored call information */
660 memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
661 memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
663 if (call->cid_num[0])
664 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
665 if (call->cid_name[0])
666 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
667 if (call->cid_rdnis[0]) {
668 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
669 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
670 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
672 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
673 case AST_PRES_RESTRICTED:
674 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
676 case AST_PRES_UNAVAILABLE:
677 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
679 case AST_PRES_ALLOWED:
681 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
683 switch(ast->cid.cid_ton) {
685 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
688 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
691 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
694 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
697 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
698 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
700 #if ASTERISK_VERSION_NUM < 110000
701 // ast->transfercapability = atoi(tmp);
702 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
704 // ast_channel_transfercapability_set(ast, atoi(tmp));
705 newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
707 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
709 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
711 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
712 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
714 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
715 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
716 send_message(MESSAGE_SETUP, call->ref, &newparam);
717 if (call->tx_queue) {
718 memset(&newparam, 0, sizeof(union parameter));
719 newparam.queue = call->tx_queue * 8;
720 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
723 /* change to outgoing setup state */
724 call->state = CHAN_LCR_STATE_OUT_SETUP;
728 * send dialing info to LCR
729 * this function is called, when setup acknowledge is received and dialing
732 static void send_dialque_to_lcr(struct chan_call *call)
734 union parameter newparam;
736 if (!call->ast || !call->ref || !call->dialque[0])
739 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
741 /* send setup message to LCR */
742 memset(&newparam, 0, sizeof(union parameter));
744 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
746 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
747 call->dialque[0] = '\0';
748 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
752 * in case of a bridge, the unsupported message can be forwarded directly
753 * to the remote call.
755 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
759 if (!call->bridge_call) return;
760 CDEBUG(call, NULL, "Sending message due bridging.\n");
761 send_message(message_type, call->bridge_call->ref, param);
765 * send release message to LCR
767 static void send_release(struct chan_call *call, int cause, int location)
769 union parameter newparam;
771 /* sending release */
772 memset(&newparam, 0, sizeof(union parameter));
773 newparam.disconnectinfo.cause = cause;
774 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
775 send_message(MESSAGE_RELEASE, call->ref, &newparam);
779 * check if extension matches and start asterisk
780 * if it can match, proceed
783 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
786 union parameter newparam;
787 #if ASTERISK_VERSION_NUM < 110000
788 char *exten = ast->exten;
790 char s_exten[AST_MAX_EXTENSION];
793 strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
799 #if ASTERISK_VERSION_NUM < 110000
800 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
802 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
807 #if ASTERISK_VERSION_NUM < 110000
808 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
809 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
811 if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
812 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
817 #if ASTERISK_VERSION_NUM < 110000
818 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
819 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);
821 if (!ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
822 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));
827 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
828 /* send setup acknowledge to lcr */
829 memset(&newparam, 0, sizeof(union parameter));
830 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
833 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
838 #if ASTERISK_VERSION_NUM < 110000
839 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
841 if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
843 /* send setup acknowledge to lcr */
844 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
845 memset(&newparam, 0, sizeof(union parameter));
846 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
850 call->state = CHAN_LCR_STATE_IN_DIALING;
852 /* if match, start pbx */
853 #if ASTERISK_VERSION_NUM < 110000
854 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
856 if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
858 CDEBUG(call, ast, "Extensions matches.\n");
862 /* send setup acknowledge to lcr */
863 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
864 memset(&newparam, 0, sizeof(union parameter));
865 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
869 call->state = CHAN_LCR_STATE_IN_DIALING;
872 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
876 #if ASTERISK_VERSION_NUM < 110000
879 if (!*ast_channel_exten(ast)) {
881 /* send setup acknowledge to lcr */
882 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
883 memset(&newparam, 0, sizeof(union parameter));
884 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
888 call->state = CHAN_LCR_STATE_IN_DIALING;
891 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
899 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
900 send_release(call, cause, LOCATION_PRIVATE_LOCAL);
902 /* release asterisk */
903 #if ASTERISK_VERSION_NUM < 110000
904 ast->hangupcause = call->cause;
906 ast_channel_hangupcause_set(ast, call->cause);
908 /* change to release state */
909 call->state = CHAN_LCR_STATE_RELEASE;
910 ast_hangup(ast); // call will be destroyed here
914 /* send setup to asterisk */
915 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
917 #ifdef LCR_FOR_CALLWEAVER
919 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
922 ret = ast_pbx_start(ast);
924 cause = (ret==-2)?34:27;
927 call->pbx_started = 1;
928 ast_setstate(ast, AST_STATE_RING);
932 * incoming setup from LCR
934 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
936 struct ast_channel *ast;
937 #ifdef AST_1_8_OR_HIGHER
938 struct ast_party_redirecting *ast_redir;
939 struct ast_party_caller *ast_caller;
941 struct ast_callerid *ast_caller;
943 #if ASTERISK_VERSION_NUM >= 110000
944 struct ast_party_redirecting s_ast_redir;
945 struct ast_party_caller s_ast_caller;
946 ast_party_redirecting_init(&s_ast_redir);
947 ast_party_caller_init(&s_ast_caller);
949 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
951 /* create asterisk channel instrance */
953 #ifdef LCR_FOR_CALLWEAVER
954 ast = ast_channel_alloc(1);
957 #ifdef LCR_FOR_ASTERISK
958 #ifdef AST_1_8_OR_HIGHER
959 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
961 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
965 #if ASTERISK_VERSION_NUM < 110000
966 #ifdef AST_1_8_OR_HIGHER
967 ast_redir = &ast->redirecting;
968 ast_caller = &ast->caller;
970 ast_caller = &ast->cid;
973 ast_redir = &s_ast_redir;
974 ast_caller = &s_ast_caller;
979 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
980 send_release(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
987 #if ASTERISK_VERSION_NUM < 110000
988 ast->tech_pvt = call;
989 ast->tech = &lcr_tech;
990 ast->fds[0] = call->pipe[0];
992 ast_channel_tech_pvt_set(ast, call);
993 ast_channel_tech_set(ast, &lcr_tech);
994 ast_channel_set_fd(ast, 0, call->pipe[0]);
997 /* fill setup information */
998 if (param->setup.dialinginfo.id)
999 #if ASTERISK_VERSION_NUM < 110000
1000 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
1001 if (param->setup.dialinginfo.context[0])
1002 strncpy(ast->context, param->setup.dialinginfo.context, AST_MAX_CONTEXT-1);
1004 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
1006 ast_channel_exten_set(ast, param->setup.dialinginfo.id);
1007 if (param->setup.dialinginfo.context[0])
1008 ast_channel_context_set(ast, param->setup.dialinginfo.context);
1010 ast_channel_context_set(ast, param->setup.callerinfo.interface);
1014 #ifdef AST_1_8_OR_HIGHER
1015 if (param->setup.callerinfo.id[0]) {
1016 ast_caller->id.number.valid = 1;
1017 ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
1018 if (!param->setup.callerinfo.id[0]) {
1019 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1020 ast_caller->id.number.plan = (0 << 4) | 1;
1022 switch (param->setup.callerinfo.present) {
1023 case INFO_PRESENT_ALLOWED:
1024 ast_caller->id.number.presentation = AST_PRES_ALLOWED;
1026 case INFO_PRESENT_RESTRICTED:
1027 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1030 ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
1032 switch (param->setup.callerinfo.screen) {
1033 case INFO_SCREEN_USER:
1034 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1036 case INFO_SCREEN_USER_VERIFIED_PASSED:
1037 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1039 case INFO_SCREEN_USER_VERIFIED_FAILED:
1040 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1043 ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
1045 switch (param->setup.callerinfo.ntype) {
1046 case INFO_NTYPE_SUBSCRIBER:
1047 ast_caller->id.number.plan = (4 << 4) | 1;
1049 case INFO_NTYPE_NATIONAL:
1050 ast_caller->id.number.plan = (2 << 4) | 1;
1052 case INFO_NTYPE_INTERNATIONAL:
1053 ast_caller->id.number.plan = (1 << 4) | 1;
1056 ast_caller->id.number.plan = (0 << 4) | 1;
1059 if (param->setup.callerinfo.id2[0]) {
1060 ast_caller->ani.number.valid = 1;
1061 ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
1062 switch (param->setup.callerinfo.present2) {
1063 case INFO_PRESENT_ALLOWED:
1064 ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
1066 case INFO_PRESENT_RESTRICTED:
1067 ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
1070 ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
1072 switch (param->setup.callerinfo.screen2) {
1073 case INFO_SCREEN_USER:
1074 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1076 case INFO_SCREEN_USER_VERIFIED_PASSED:
1077 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1079 case INFO_SCREEN_USER_VERIFIED_FAILED:
1080 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1083 ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
1085 switch (param->setup.callerinfo.ntype2) {
1086 case INFO_NTYPE_SUBSCRIBER:
1087 ast_caller->ani.number.plan = (4 << 4) | 1;
1089 case INFO_NTYPE_NATIONAL:
1090 ast_caller->ani.number.plan = (2 << 4) | 1;
1092 case INFO_NTYPE_INTERNATIONAL:
1093 ast_caller->ani.number.plan = (1 << 4) | 1;
1096 ast_caller->ani.number.plan = (0 << 4) | 1;
1099 if (param->setup.callerinfo.name[0]) {
1100 ast_caller->id.name.valid = 1;
1101 ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
1103 #if ASTERISK_VERSION_NUM >= 110000
1104 ast_channel_caller_set(ast, ast_caller);
1106 if (param->setup.redirinfo.id[0]) {
1107 ast_redir->from.number.valid = 1;
1108 ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
1109 switch (param->setup.redirinfo.present) {
1110 case INFO_PRESENT_ALLOWED:
1111 ast_redir->from.number.presentation = AST_PRES_ALLOWED;
1113 case INFO_PRESENT_RESTRICTED:
1114 ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
1117 ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
1119 switch (param->setup.redirinfo.screen) {
1120 case INFO_SCREEN_USER:
1121 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1123 case INFO_SCREEN_USER_VERIFIED_PASSED:
1124 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1126 case INFO_SCREEN_USER_VERIFIED_FAILED:
1127 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1130 ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
1132 switch (param->setup.redirinfo.ntype) {
1133 case INFO_NTYPE_SUBSCRIBER:
1134 ast_redir->from.number.plan = (4 << 4) | 1;
1136 case INFO_NTYPE_NATIONAL:
1137 ast_redir->from.number.plan = (2 << 4) | 1;
1139 case INFO_NTYPE_INTERNATIONAL:
1140 ast_redir->from.number.plan = (1 << 4) | 1;
1143 ast_redir->from.number.plan = (0 << 4) | 1;
1145 #if ASTERISK_VERSION_NUM >= 110000
1146 ast_channel_redirecting_set(ast, ast_redir);
1150 memset(&ast->cid, 0, sizeof(ast->cid));
1151 if (param->setup.callerinfo.id[0])
1152 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
1153 if (param->setup.callerinfo.id2[0])
1154 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
1155 if (param->setup.callerinfo.name[0])
1156 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
1157 if (param->setup.redirinfo.id[0])
1158 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
1159 switch (param->setup.callerinfo.present) {
1160 case INFO_PRESENT_ALLOWED:
1161 ast->cid.cid_pres = AST_PRES_ALLOWED;
1163 case INFO_PRESENT_RESTRICTED:
1164 ast->cid.cid_pres = AST_PRES_RESTRICTED;
1167 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
1169 switch (param->setup.callerinfo.ntype) {
1170 case INFO_NTYPE_SUBSCRIBER:
1171 ast->cid.cid_ton = 4;
1173 case INFO_NTYPE_NATIONAL:
1174 ast->cid.cid_ton = 2;
1176 case INFO_NTYPE_INTERNATIONAL:
1177 ast->cid.cid_ton = 1;
1180 ast->cid.cid_ton = 0;
1184 #if ASTERISK_VERSION_NUM < 110000
1185 ast->transfercapability = param->setup.capainfo.bearer_capa;
1187 ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
1189 /* enable hdlc if transcap is data */
1190 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
1192 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
1194 /* configure channel */
1195 #if ASTERISK_VERSION_NUM < 100000
1196 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1197 ast->readformat = ast->rawreadformat = ast->nativeformats;
1198 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1200 #if ASTERISK_VERSION_NUM < 110000
1201 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1202 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
1203 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
1204 ast_set_write_format(ast, &ast->rawwriteformat);
1205 ast_set_read_format(ast, &ast->rawreadformat);
1207 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1208 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
1209 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
1210 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
1211 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
1214 #if ASTERISK_VERSION_NUM < 110000
1216 ast->hangupcause = 0;
1218 ast_channel_priority_set(ast, 1);
1219 ast_channel_hangupcause_set(ast, 0);
1223 call->state = CHAN_LCR_STATE_IN_SETUP;
1225 if (!call->pbx_started)
1226 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
1230 * incoming setup acknowledge from LCR
1232 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
1234 if (!call->ast) return;
1236 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
1238 /* send pending digits in dialque */
1239 if (call->dialque[0])
1240 send_dialque_to_lcr(call);
1241 /* change to overlap state */
1242 call->state = CHAN_LCR_STATE_OUT_DIALING;
1246 * incoming proceeding from LCR
1248 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
1250 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
1253 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
1254 /* queue event for asterisk */
1255 if (call->ast && call->pbx_started) {
1260 rc = write(wake_pipe[1], &byte, 1);
1262 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
1268 * incoming alerting from LCR
1270 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
1272 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
1275 call->state = CHAN_LCR_STATE_OUT_ALERTING;
1276 /* queue event to asterisk */
1277 if (call->ast && call->pbx_started) {
1282 rc = write(wake_pipe[1], &byte, 1);
1284 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1289 * incoming connect from LCR
1291 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1293 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1296 call->state = CHAN_LCR_STATE_CONNECT;
1297 /* copy connectinfo */
1298 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1299 /* queue event to asterisk */
1300 if (call->ast && call->pbx_started) {
1305 rc = write(wake_pipe[1], &byte, 1);
1307 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1312 * incoming disconnect from LCR
1314 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1316 struct ast_channel *ast = call->ast;
1318 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1321 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1323 call->cause = param->disconnectinfo.cause;
1324 call->location = param->disconnectinfo.location;
1325 /* if bridge, forward disconnect and return */
1328 if (call->bridge_call) {
1329 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1330 bridge_message_if_bridged(call, message_type, param);
1334 /* release lcr with same cause */
1335 send_release(call, call->cause, call->location);
1337 /* change to release state */
1338 call->state = CHAN_LCR_STATE_RELEASE;
1339 /* queue release asterisk */
1341 #if ASTERISK_VERSION_NUM < 110000
1342 ast->hangupcause = call->cause;
1344 ast_channel_hangupcause_set(ast, call->cause);
1346 if (call->pbx_started) {
1351 rc = write(wake_pipe[1], &byte, 1);
1353 strcpy(call->queue_string, "H"); // overwrite other indications
1355 ast_hangup(ast); // call will be destroyed here
1361 * incoming release from LCR
1363 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1365 struct ast_channel *ast = call->ast;
1367 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1371 /* change to release state */
1372 call->state = CHAN_LCR_STATE_RELEASE;
1373 /* copy release info */
1375 call->cause = param->disconnectinfo.cause;
1376 call->location = param->disconnectinfo.location;
1378 /* if we have an asterisk instance, queue hangup, else we are done */
1380 #if ASTERISK_VERSION_NUM < 110000
1381 ast->hangupcause = call->cause;
1383 ast_channel_hangupcause_set(ast, call->cause);
1385 if (call->pbx_started) {
1390 rc = write(wake_pipe[1], &byte, 1);
1392 strcpy(call->queue_string, "H");
1394 ast_hangup(ast); // call will be destroyed here
1403 * incoming information from LCR
1405 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1407 struct ast_channel *ast = call->ast;
1409 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1413 /* pbx not started */
1414 if (!call->pbx_started) {
1415 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1416 #if ASTERISK_VERSION_NUM < 110000
1417 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1419 char *tmp[AST_MAX_EXTENSION];
1420 snprintf(tmp,AST_MAX_EXTENSION,"%s%s",ast_channel_exten(ast),param->information.id);
1421 ast_channel_exten_set(ast, tmp);
1423 lcr_start_pbx(call, ast, param->information.sending_complete);
1427 /* change dailing state after setup */
1428 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1429 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1430 call->state = CHAN_LCR_STATE_IN_DIALING;
1431 // ast_setstate(ast, AST_STATE_DIALING);
1435 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1440 rc = write(wake_pipe[1], &byte, 1);
1442 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1445 /* use bridge to forware message not supported by asterisk */
1446 if (call->state == CHAN_LCR_STATE_CONNECT) {
1447 if (call->bridge_call) {
1448 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1449 bridge_message_if_bridged(call, message_type, param);
1451 if (call->dsp_dtmf) {
1456 rc = write(wake_pipe[1], &byte, 1);
1458 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1460 CDEBUG(call, call->ast, "LCR's DTMF detection is disabled.\n");
1466 * incoming information from LCR
1468 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1470 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1472 if (!call->ast) return;
1474 /* use bridge to forware message not supported by asterisk */
1475 bridge_message_if_bridged(call, message_type, param);
1479 * incoming information from LCR
1481 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1483 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1485 if (!call->ast) return;
1487 /* use bridge to forware message not supported by asterisk */
1488 bridge_message_if_bridged(call, message_type, param);
1492 * incoming pattern from LCR
1494 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1496 union parameter newparam;
1498 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1500 if (!call->ast) return;
1502 /* pattern are indicated only once */
1503 if (call->has_pattern)
1505 call->has_pattern = 1;
1507 /* request bchannel */
1508 CDEBUG(call, call->ast, "Requesting audio path (ref=%d)\n", call->ref);
1509 memset(&newparam, 0, sizeof(union parameter));
1510 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
1512 /* queue PROGRESS, because tones are available */
1513 if (call->ast && call->pbx_started) {
1518 rc = write(wake_pipe[1], &byte, 1);
1520 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1525 * got dtmf from bchannel (locked state)
1527 void lcr_in_dtmf(struct chan_call *call, int val)
1529 struct ast_channel *ast = call->ast;
1534 if (!call->pbx_started)
1537 if (!call->dsp_dtmf) {
1538 CDEBUG(call, call->ast, "Recognised DTMF digit '%c' by LCR, but ignoring. (disabled by option)\n", val);
1542 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1549 rc = write(wake_pipe[1], &byte, 1);
1551 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1555 * message received from LCR
1557 int receive_message(int message_type, unsigned int ref, union parameter *param)
1559 struct chan_call *call;
1560 union parameter newparam;
1563 memset(&newparam, 0, sizeof(union parameter));
1565 /* handle new ref */
1566 if (message_type == MESSAGE_NEWREF) {
1567 if (param->newref.direction) {
1568 /* new ref from lcr */
1569 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1570 if (!ref || find_call_ref(ref)) {
1571 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1574 /* allocate new call instance */
1575 call = alloc_call();
1577 call->state = CHAN_LCR_STATE_IN_PREPARE;
1580 call->ref_was_assigned = 1;
1581 /* wait for setup (or release from asterisk) */
1583 /* new ref, as requested from this remote application */
1584 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1585 call = find_call_ref(0);
1587 /* send release, if ref does not exist */
1588 CERROR(NULL, NULL, "No call found, that requests a ref.\n");
1593 call->ref_was_assigned = 1;
1594 /* send pending setup info */
1595 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1596 send_setup_to_lcr(call);
1597 /* release if asterisk has signed off */
1598 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1601 send_release(call, call->cause, call->location);
1603 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1609 send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
1615 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1618 call = find_call_ref(ref);
1620 /* ignore ref that is not used (anymore) */
1621 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1625 /* handle messages */
1626 switch(message_type) {
1628 lcr_in_setup(call, message_type, param);
1631 case MESSAGE_OVERLAP:
1632 lcr_in_overlap(call, message_type, param);
1635 case MESSAGE_PROCEEDING:
1636 lcr_in_proceeding(call, message_type, param);
1639 case MESSAGE_ALERTING:
1640 lcr_in_alerting(call, message_type, param);
1643 case MESSAGE_CONNECT:
1644 lcr_in_connect(call, message_type, param);
1647 case MESSAGE_DISCONNECT:
1648 lcr_in_disconnect(call, message_type, param);
1651 case MESSAGE_RELEASE:
1652 lcr_in_release(call, message_type, param);
1655 case MESSAGE_INFORMATION:
1656 lcr_in_information(call, message_type, param);
1659 case MESSAGE_NOTIFY:
1660 lcr_in_notify(call, message_type, param);
1663 case MESSAGE_FACILITY:
1664 lcr_in_facility(call, message_type, param);
1667 case MESSAGE_PATTERN: // audio available from LCR
1668 if (!call->has_pattern)
1669 lcr_in_pattern(call, message_type, param);
1672 case MESSAGE_NOPATTERN: // audio not available from LCR
1675 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1676 call->audiopath = param->audiopath;
1679 case MESSAGE_TRAFFIC: // if remote audio connected or hold
1681 unsigned char *p = param->traffic.data;
1682 int i, len = param->traffic.len;
1683 for (i = 0; i < len; i++, p++)
1686 rc = write(call->pipe[1], param->traffic.data, param->traffic.len);
1690 lcr_in_dtmf(call, param->dtmf);
1694 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1701 * release all calls (due to broken socket)
1703 static void release_all_calls(void)
1705 struct chan_call *call;
1710 /* no ast, so we may directly free call */
1712 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1716 /* already in release process */
1717 if (call->state == CHAN_LCR_STATE_RELEASE) {
1721 /* release or queue release */
1723 call->state = CHAN_LCR_STATE_RELEASE;
1724 if (!call->pbx_started) {
1725 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1726 ast_hangup(call->ast); // call will be destroyed here
1729 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1734 rc = write(wake_pipe[1], &byte, 1);
1736 strcpy(call->queue_string, "H");
1741 void close_socket(void);
1744 * warning! not thread safe
1745 * returns -1 for socket error, 0 for no work, 1 for work
1747 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1750 struct admin_list *admin;
1751 struct admin_message msg;
1753 if ((what & LCR_FD_READ)) {
1754 /* read from socket */
1755 len = read(lcr_sock, &msg, sizeof(msg));
1757 CERROR(NULL, NULL, "Socket closed.(read)\n");
1759 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1761 release_all_calls();
1762 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1766 if (len != sizeof(msg)) {
1767 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1770 if (msg.message != ADMIN_MESSAGE) {
1771 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1774 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1776 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1781 if ((what & LCR_FD_WRITE)) {
1782 /* write to socket */
1784 socket_fd.when &= ~LCR_FD_WRITE;
1787 admin = admin_first;
1788 len = write(lcr_sock, &admin->msg, sizeof(msg));
1790 CERROR(NULL, NULL, "Socket closed.(write)\n");
1794 if (len != sizeof(msg)) {
1795 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1799 admin_first = admin->next;
1803 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1812 * open and close socket and thread
1814 int open_socket(void)
1817 struct sockaddr_un sock_address;
1818 union parameter param;
1821 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1822 CERROR(NULL, NULL, "Failed to create socket.\n");
1826 /* set socket address and name */
1827 memset(&sock_address, 0, sizeof(sock_address));
1828 sock_address.sun_family = PF_UNIX;
1829 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1831 /* connect socket */
1832 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1835 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1839 /* register socket fd */
1840 memset(&socket_fd, 0, sizeof(socket_fd));
1841 socket_fd.fd = lcr_sock;
1842 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1844 /* enque hello message */
1845 memset(¶m, 0, sizeof(param));
1846 strcpy(param.hello.application, "asterisk");
1847 send_message(MESSAGE_HELLO, 0, ¶m);
1852 void close_socket(void)
1854 struct admin_list *admin, *temp;
1856 /* socket not created */
1860 unregister_fd(&socket_fd);
1862 /* flush pending messages */
1863 admin = admin_first;
1866 admin = admin->next;
1878 /* sending queue to asterisk */
1879 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1884 rc = read(wake_pipe[0], &byte, 1);
1891 static void handle_queue()
1893 struct chan_call *call;
1894 struct ast_channel *ast;
1895 struct ast_frame fr;
1901 p = call->queue_string;
1904 if (ast_channel_trylock(ast)) {
1905 ast_mutex_unlock(&chan_lock);
1907 ast_mutex_lock(&chan_lock);
1913 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1914 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1917 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1918 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1921 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1922 ast_queue_control(ast, AST_CONTROL_RINGING);
1923 ast_setstate(ast, AST_STATE_RINGING);
1926 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1927 ast_queue_control(ast, AST_CONTROL_ANSWER);
1930 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1931 ast_queue_hangup(ast);
1933 case '1': case '2': case '3': case 'A':
1934 case '4': case '5': case '6': case 'B':
1935 case '7': case '8': case '9': case 'C':
1936 case '*': case '0': case '#': case 'D':
1937 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1938 /* send digit to asterisk */
1939 memset(&fr, 0, sizeof(fr));
1941 #ifdef LCR_FOR_ASTERISK
1942 fr.frametype = AST_FRAME_DTMF_BEGIN;
1945 #ifdef LCR_FOR_CALLWEAVER
1946 fr.frametype = AST_FRAME_DTMF;
1949 #ifdef AST_1_8_OR_HIGHER
1950 fr.subclass.integer = *p;
1954 fr.delivery = ast_tv(0, 0);
1955 ast_queue_frame(ast, &fr);
1957 #ifdef LCR_FOR_ASTERISK
1958 fr.frametype = AST_FRAME_DTMF_END;
1959 ast_queue_frame(ast, &fr);
1964 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1968 call->queue_string[0] = '\0';
1969 ast_channel_unlock(ast);
1975 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1977 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1978 if (open_socket() < 0)
1979 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1984 void lock_chan(void)
1986 ast_mutex_lock(&chan_lock);
1989 void unlock_chan(void)
1991 ast_mutex_unlock(&chan_lock);
1994 /* chan_lcr thread */
1995 static void *chan_thread(void *arg)
1997 if (pipe(wake_pipe) < 0) {
1998 CERROR(NULL, NULL, "Failed to open pipe.\n");
2001 memset(&wake_fd, 0, sizeof(wake_fd));
2002 wake_fd.fd = wake_pipe[0];
2003 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
2005 memset(&socket_retry, 0, sizeof(socket_retry));
2006 add_timer(&socket_retry, handle_retry, NULL, 0);
2008 /* open socket the first time */
2009 handle_retry(NULL, NULL, 0);
2011 ast_mutex_lock(&chan_lock);
2015 select_main(0, &global_change, lock_chan, unlock_chan);
2022 * new asterisk instance
2025 #ifdef AST_1_8_OR_HIGHER
2026 #if ASTERISK_VERSION_NUM < 100000
2027 struct ast_channel *lcr_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
2029 struct ast_channel *lcr_request(const char *type, struct ast_format_cap *format, const struct ast_channel *requestor, void *data, int *cause)
2032 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
2035 char exten[256], *dial, *interface, *opt;
2036 struct ast_channel *ast;
2037 struct chan_call *call;
2038 #ifdef AST_1_8_OR_HIGHER
2039 const struct ast_party_redirecting *req_redir;
2040 const struct ast_party_caller *req_caller;
2043 ast_mutex_lock(&chan_lock);
2044 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
2046 /* if socket is closed */
2048 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
2049 ast_mutex_unlock(&chan_lock);
2053 /* create call instance */
2054 call = alloc_call();
2056 /* failed to create instance */
2057 ast_mutex_unlock(&chan_lock);
2061 /* create asterisk channel instrance */
2063 #ifdef LCR_FOR_ASTERISK
2064 #ifdef AST_1_8_OR_HIGHER
2065 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, NULL, NULL, NULL, NULL, 0, "%s/%d", lcr_type, ++glob_channel);
2067 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
2071 #ifdef LCR_FOR_CALLWEAVER
2072 ast = ast_channel_alloc(1);
2076 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
2078 /* failed to create instance */
2079 ast_mutex_unlock(&chan_lock);
2082 #if ASTERISK_VERSION_NUM < 110000
2083 ast->tech = &lcr_tech;
2084 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
2085 #ifdef AST_1_8_OR_HIGHER
2086 req_redir = &requestor->redirecting;
2087 req_caller = &requestor->caller;
2090 ast_channel_tech_set(ast, &lcr_tech);
2091 ast_channel_tech_pvt_set(ast, (void *)1L); // set pointer or asterisk will not call
2092 req_redir = ast_channel_redirecting(requestor);
2093 req_caller = ast_channel_caller(requestor);
2095 /* configure channel */
2096 #if ASTERISK_VERSION_NUM < 100000
2097 #if ASTERISK_VERSION_NUM < 110000
2098 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2099 ast->readformat = ast->rawreadformat = ast->nativeformats;
2100 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
2102 ast_channel_nativeformats_set(ast, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
2103 ast->readformat = ast->rawreadformat = ast_channel_nativeformats(ast);
2104 ast->writeformat = ast->rawwriteformat = ast_channel_nativeformats(ast);
2107 #if ASTERISK_VERSION_NUM < 110000
2108 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2109 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
2110 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
2111 ast_set_write_format(ast, &ast->rawwriteformat);
2112 ast_set_read_format(ast, &ast->rawreadformat);
2114 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2115 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
2116 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
2117 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
2118 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
2121 #if ASTERISK_VERSION_NUM < 110000
2123 ast->hangupcause = 0;
2125 ast_channel_priority_set(ast, 1);
2126 ast_channel_hangupcause_set(ast, 0);
2131 #if ASTERISK_VERSION_NUM < 110000
2132 ast->tech_pvt = call;
2133 ast->fds[0] = call->pipe[0];
2135 ast_channel_tech_pvt_set(ast, call);
2136 ast_channel_set_fd(ast, 0, call->pipe[0]);
2138 call->pbx_started = 0;
2140 call->state = CHAN_LCR_STATE_OUT_PREPARE;
2143 * Extract interface, dialstring, options from data.
2146 * <interface>/<dialstring>
2147 * <interface>/<dialstring>/options
2149 strncpy(exten, (char *)data, sizeof(exten)-1);
2150 exten[sizeof(exten)-1] = '\0';
2151 if ((dial = strchr(exten, '/'))) {
2154 if ((opt = strchr(dial, '/')))
2163 strncpy(call->interface, interface, sizeof(call->interface)-1);
2164 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
2165 apply_opt(call, (char *)opt);
2167 #ifdef AST_1_8_OR_HIGHER
2168 // clone_variables(requestor, ast);
2171 ast->caller.ani.number.valid= req_caller->ani.number.valid;
2172 if (req_caller->ani.number.valid)
2173 if (req_caller->ani.number.str)
2174 if (req_caller->ani.number.str[0])
2175 ast->caller.ani.number.str= strdup(req_caller->ani.number.str);
2176 ast->caller.ani.number.plan= req_caller->ani.number.plan;
2177 ast->caller.ani.number.presentation= req_caller->ani.number.presentation;
2179 ast->caller.ani.name.valid= req_caller->ani.name.valid;
2180 if (req_caller->ani.name.valid)
2181 if (req_caller->ani.name.str)
2182 if (req_caller->ani.name.str[0])
2183 ast->caller.ani.name.str= strdup(req_caller->ani.name.str);
2184 ast->caller.ani.name.presentation= req_caller->ani.name.presentation;
2186 ast->caller.ani.subaddress.valid= req_caller->ani.subaddress.valid;
2187 if (req_caller->ani.subaddress.valid)
2188 if (req_caller->ani.subaddress.str)
2189 if (req_caller->ani.subaddress.str[0])
2190 ast->caller.ani.subaddress.str= strdup(req_caller->ani.subaddress.str);
2191 ast->caller.ani.subaddress.type= req_caller->ani.subaddress.type;
2193 ast->caller.id.number.valid= req_caller->id.number.valid;
2194 if (req_caller->id.number.valid)
2195 if (req_caller->id.number.str)
2196 if (req_caller->id.number.str[0])
2197 ast->caller.id.number.str= strdup(req_caller->id.number.str);
2198 ast->caller.id.number.plan= req_caller->id.number.plan;
2199 ast->caller.id.number.presentation= req_caller->id.number.presentation;
2201 ast->caller.id.name.valid= req_caller->id.name.valid;
2202 if (req_caller->id.name.valid)
2203 if (req_caller->id.name.str)
2204 if (req_caller->id.name.str[0])
2205 ast->caller.id.name.str= strdup(req_caller->id.name.str);
2206 ast->caller.id.name.presentation= req_caller->id.name.presentation;
2208 ast->caller.id.subaddress.valid= req_caller->id.subaddress.valid;
2209 if (req_caller->id.subaddress.valid)
2210 if (req_caller->id.subaddress.str)
2211 if (req_caller->id.subaddress.str[0])
2212 ast->caller.id.subaddress.str= strdup(req_caller->id.subaddress.str);
2213 ast->caller.id.subaddress.type= req_caller->id.subaddress.type;
2215 if (requestor->dialed.number.str)
2216 if (requestor->dialed.number.str[0])
2217 ast->dialed.number.str= strdup(requestor->dialed.number.str);
2218 ast->dialed.number.plan= requestor->dialed.number.plan;
2220 ast->dialed.subaddress.valid= requestor->dialed.subaddress.valid;
2221 if (requestor->dialed.subaddress.valid)
2222 if (requestor->dialed.subaddress.str)
2223 if (requestor->dialed.subaddress.str[0])
2224 ast->dialed.subaddress.str= strdup(requestor->dialed.subaddress.str);
2225 ast->dialed.subaddress.type= requestor->dialed.subaddress.type;
2227 ast->dialed.transit_network_select= requestor->dialed.transit_network_select;
2228 ast->redirecting.count= req_redir->count;
2229 ast->redirecting.reason= req_redir->reason;
2231 ast->redirecting.from.number.valid= req_redir->from.number.valid;
2232 if (req_redir->from.number.valid)
2233 if (req_redir->from.number.str)
2234 if (req_redir->from.number.str[0])
2235 ast->redirecting.from.number.str= strdup(req_redir->from.number.str);
2236 ast->redirecting.from.number.plan= req_redir->from.number.plan;
2237 ast->redirecting.from.number.presentation= req_redir->from.number.presentation;
2239 ast->redirecting.to.number.valid= req_redir->to.number.valid;
2240 if (req_redir->to.number.valid)
2241 if (req_redir->to.number.str)
2242 if (req_redir->to.number.str[0])
2243 ast->redirecting.to.number.str= strdup(req_redir->to.number.str);
2244 ast->redirecting.to.number.plan= req_redir->to.number.plan;
2245 ast->redirecting.to.number.presentation= req_redir->to.number.presentation;
2247 /* store call information for setup */
2250 if (requestor && req_caller->id.number.valid) {
2251 if (req_caller->id.number.str)
2252 strncpy(call->callerinfo.id, req_caller->id.number.str, sizeof(call->callerinfo.id)-1);
2253 switch(req_caller->id.number.presentation & AST_PRES_RESTRICTION) {
2254 case AST_PRES_RESTRICTED:
2255 call->callerinfo.present = INFO_PRESENT_RESTRICTED;
2257 case AST_PRES_UNAVAILABLE:
2258 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2260 case AST_PRES_ALLOWED:
2262 call->callerinfo.present = INFO_PRESENT_ALLOWED;
2264 switch(req_caller->id.number.presentation & AST_PRES_NUMBER_TYPE) {
2265 case AST_PRES_USER_NUMBER_UNSCREENED:
2266 call->callerinfo.screen = INFO_SCREEN_USER;
2268 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2269 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2271 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2272 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2275 call->callerinfo.screen = INFO_SCREEN_NETWORK;
2277 switch((req_caller->id.number.plan >> 4) & 7) {
2279 call->callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2282 call->callerinfo.ntype = INFO_NTYPE_NATIONAL;
2285 call->callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2288 call->callerinfo.ntype = INFO_NTYPE_UNKNOWN;
2291 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2294 if (requestor && req_caller->ani.number.valid) {
2295 if (req_caller->ani.number.str)
2296 strncpy(call->callerinfo.id2, req_caller->ani.number.str, sizeof(call->callerinfo.id2)-1);
2297 switch(req_caller->ani.number.presentation & AST_PRES_RESTRICTION) {
2298 case AST_PRES_RESTRICTED:
2299 call->callerinfo.present2 = INFO_PRESENT_RESTRICTED;
2301 case AST_PRES_UNAVAILABLE:
2302 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2304 case AST_PRES_ALLOWED:
2306 call->callerinfo.present2 = INFO_PRESENT_ALLOWED;
2308 switch(req_caller->ani.number.presentation & AST_PRES_NUMBER_TYPE) {
2309 case AST_PRES_USER_NUMBER_UNSCREENED:
2310 call->callerinfo.screen2 = INFO_SCREEN_USER;
2312 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2313 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_PASSED;
2315 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2316 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_FAILED;
2319 call->callerinfo.screen2 = INFO_SCREEN_NETWORK;
2321 switch((req_caller->ani.number.plan >> 4) & 7) {
2323 call->callerinfo.ntype2 = INFO_NTYPE_SUBSCRIBER;
2326 call->callerinfo.ntype2 = INFO_NTYPE_NATIONAL;
2329 call->callerinfo.ntype2 = INFO_NTYPE_INTERNATIONAL;
2332 call->callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
2335 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2338 if (requestor && req_caller->id.name.valid) {
2339 if (req_caller->id.name.str)
2340 strncpy(call->callerinfo.name, req_caller->id.name.str, sizeof(call->callerinfo.name)-1);
2344 if (requestor && req_redir->from.number.valid) {
2345 call->redirinfo.itype = INFO_ITYPE_CHAN;
2346 if (req_redir->from.number.str)
2347 strncpy(call->redirinfo.id, req_redir->from.number.str, sizeof(call->redirinfo.id)-1);
2348 switch(req_redir->from.number.presentation & AST_PRES_RESTRICTION) {
2349 case AST_PRES_RESTRICTED:
2350 call->redirinfo.present = INFO_PRESENT_RESTRICTED;
2352 case AST_PRES_UNAVAILABLE:
2353 call->redirinfo.present = INFO_PRESENT_NOTAVAIL;
2355 case AST_PRES_ALLOWED:
2357 call->redirinfo.present = INFO_PRESENT_ALLOWED;
2359 switch(req_redir->from.number.presentation & AST_PRES_NUMBER_TYPE) {
2360 case AST_PRES_USER_NUMBER_UNSCREENED:
2361 call->redirinfo.screen = INFO_SCREEN_USER;
2363 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2364 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2366 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2367 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2370 call->redirinfo.screen = INFO_SCREEN_NETWORK;
2372 switch((req_redir->from.number.plan >> 4) & 7) {
2374 call->redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2377 call->redirinfo.ntype = INFO_NTYPE_NATIONAL;
2380 call->redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2383 call->redirinfo.ntype = INFO_NTYPE_UNKNOWN;
2388 ast_mutex_unlock(&chan_lock);
2393 * call from asterisk
2395 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
2397 union parameter newparam;
2398 struct chan_call *call;
2399 #if ASTERISK_VERSION_NUM >= 110000
2400 int transfercapability;
2403 ast_mutex_lock(&chan_lock);
2404 #if ASTERISK_VERSION_NUM < 110000
2405 call = ast->tech_pvt;
2407 call = ast_channel_tech_pvt(ast);
2410 #ifdef LCR_FOR_CALLWEAVER
2412 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type, call->dialstring, ast_random() & 0xffff);
2416 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
2417 ast_mutex_unlock(&chan_lock);
2421 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
2423 /* pbx process is started */
2424 call->pbx_started = 1;
2425 /* send MESSAGE_NEWREF */
2426 memset(&newparam, 0, sizeof(union parameter));
2427 newparam.newref.direction = 0; /* request from app */
2428 strncpy(newparam.newref.interface, call->interface, sizeof(newparam.newref.interface) - 1);
2429 send_message(MESSAGE_NEWREF, 0, &newparam);
2431 /* set hdlc if capability requires hdlc */
2432 #if ASTERISK_VERSION_NUM < 110000
2433 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
2434 || ast->transfercapability == INFO_BC_DATARESTRICTED
2435 || ast->transfercapability == INFO_BC_VIDEO)
2437 transfercapability=ast_channel_transfercapability(ast);
2438 if (transfercapability == INFO_BC_DATAUNRESTRICTED
2439 || transfercapability == INFO_BC_DATARESTRICTED
2440 || transfercapability == INFO_BC_VIDEO)
2443 /* if hdlc is forced by option, we change transcap to data */
2445 #if ASTERISK_VERSION_NUM < 110000
2446 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
2447 && ast->transfercapability != INFO_BC_DATARESTRICTED
2448 && ast->transfercapability != INFO_BC_VIDEO)
2449 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
2451 && transfercapability != INFO_BC_DATAUNRESTRICTED
2452 && transfercapability != INFO_BC_DATARESTRICTED
2453 && transfercapability != INFO_BC_VIDEO)
2454 transfercapability = INFO_BC_DATAUNRESTRICTED;
2457 #ifndef AST_1_8_OR_HIGHER
2458 call->cid_num[0] = 0;
2459 call->cid_name[0] = 0;
2460 call->cid_rdnis[0] = 0;
2462 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
2463 strncpy(call->cid_num, ast->cid.cid_num,
2464 sizeof(call->cid_num)-1);
2465 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
2466 strncpy(call->cid_name, ast->cid.cid_name,
2467 sizeof(call->cid_name)-1);
2468 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
2469 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
2470 sizeof(call->cid_rdnis)-1);
2473 ast_mutex_unlock(&chan_lock);
2477 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2479 static const char* dtmf_tones[] = {
2480 "!941+1336/100,!0/100", /* 0 */
2481 "!697+1209/100,!0/100", /* 1 */
2482 "!697+1336/100,!0/100", /* 2 */
2483 "!697+1477/100,!0/100", /* 3 */
2484 "!770+1209/100,!0/100", /* 4 */
2485 "!770+1336/100,!0/100", /* 5 */
2486 "!770+1477/100,!0/100", /* 6 */
2487 "!852+1209/100,!0/100", /* 7 */
2488 "!852+1336/100,!0/100", /* 8 */
2489 "!852+1477/100,!0/100", /* 9 */
2490 "!697+1633/100,!0/100", /* A */
2491 "!770+1633/100,!0/100", /* B */
2492 "!852+1633/100,!0/100", /* C */
2493 "!941+1633/100,!0/100", /* D */
2494 "!941+1209/100,!0/100", /* * */
2495 "!941+1477/100,!0/100" }; /* # */
2497 if (digit >= '0' && digit <='9')
2498 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2499 else if (digit >= 'A' && digit <= 'D')
2500 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2501 else if (digit == '*')
2502 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2503 else if (digit == '#')
2504 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2506 #if ASTERISK_VERSION_NUM < 110000
2507 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
2509 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
2514 #ifdef LCR_FOR_ASTERISK
2515 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2517 #ifdef LCR_FOR_CALLWEAVER
2518 static int lcr_digit(struct ast_channel *ast, char digit)
2521 struct chan_call *call;
2522 union parameter newparam;
2525 #ifdef LCR_FOR_CALLWEAVER
2526 int inband_dtmf = 0;
2529 /* only pass IA5 number space */
2530 if (digit > 126 || digit < 32)
2533 ast_mutex_lock(&chan_lock);
2534 #if ASTERISK_VERSION_NUM < 110000
2535 call = ast->tech_pvt;
2537 call = ast_channel_tech_pvt(ast);
2540 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2541 ast_mutex_unlock(&chan_lock);
2545 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2547 /* send information or queue them */
2548 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2549 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2550 memset(&newparam, 0, sizeof(union parameter));
2552 newparam.information.keypad[0] = digit;
2553 newparam.information.keypad[1] = '\0';
2555 newparam.information.id[0] = digit;
2556 newparam.information.id[1] = '\0';
2558 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2561 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2562 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2564 strncat(call->dialque, buf, strlen(call->dialque)-1);
2567 ast_mutex_unlock(&chan_lock);
2569 #ifdef LCR_FOR_ASTERISK
2573 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2575 int inband_dtmf = 0;
2576 struct chan_call *call;
2579 ast_mutex_lock(&chan_lock);
2581 #if ASTERISK_VERSION_NUM < 110000
2582 call = ast->tech_pvt;
2584 call = ast_channel_tech_pvt(ast);
2589 "Received digit from Asterisk, "
2590 "but no call instance exists.\n");
2591 ast_mutex_unlock(&chan_lock);
2595 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2597 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2601 ast_mutex_unlock(&chan_lock);
2604 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2605 send_digit_to_chan(ast, digit);
2611 static int lcr_answer(struct ast_channel *ast)
2613 union parameter newparam;
2614 struct chan_call *call;
2616 ast_mutex_lock(&chan_lock);
2617 #if ASTERISK_VERSION_NUM < 110000
2618 call = ast->tech_pvt;
2620 call = ast_channel_tech_pvt(ast);
2623 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2624 ast_mutex_unlock(&chan_lock);
2628 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2630 /* copy connectinfo, if bridged */
2631 if (call->bridge_call)
2632 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2633 /* send connect message to lcr */
2634 if (call->state != CHAN_LCR_STATE_CONNECT) {
2635 memset(&newparam, 0, sizeof(union parameter));
2636 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2637 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2638 call->state = CHAN_LCR_STATE_CONNECT;
2642 // memset(&newparam, 0, sizeof(union parameter));
2643 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2645 ast_mutex_unlock(&chan_lock);
2649 static int lcr_hangup(struct ast_channel *ast)
2651 struct chan_call *call;
2652 pthread_t tid = pthread_self();
2654 if (!pthread_equal(tid, chan_tid)) {
2655 ast_mutex_lock(&chan_lock);
2657 #if ASTERISK_VERSION_NUM < 110000
2658 call = ast->tech_pvt;
2660 call = ast_channel_tech_pvt(ast);
2663 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2664 if (!pthread_equal(tid, chan_tid)) {
2665 ast_mutex_unlock(&chan_lock);
2670 if (!pthread_equal(tid, chan_tid))
2671 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2673 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2675 /* disconnect asterisk, maybe not required */
2676 #if ASTERISK_VERSION_NUM < 110000
2677 ast->tech_pvt = NULL;
2680 ast_channel_tech_pvt_set(ast, NULL);
2681 ast_channel_set_fd(ast, 0, -1);
2685 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2686 #if ASTERISK_VERSION_NUM < 110000
2687 if (ast->hangupcause > 0)
2688 send_release(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2690 if (ast_channel_hangupcause(ast) > 0)
2691 send_release(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
2694 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2697 if (!pthread_equal(tid, chan_tid)) {
2698 ast_mutex_unlock(&chan_lock);
2702 /* ref is not set, due to prepare setup or release */
2703 if (call->state == CHAN_LCR_STATE_RELEASE) {
2704 /* we get the response to our release */
2705 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2708 /* during prepare, we change to release state */
2709 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2710 call->state = CHAN_LCR_STATE_RELEASE;
2714 if (!pthread_equal(tid, chan_tid)) {
2715 ast_mutex_unlock(&chan_lock);
2720 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2722 union parameter newparam;
2723 struct chan_call *call;
2724 struct ast_frame * f = fr;
2725 unsigned char *p, *q;
2728 #if ASTERISK_VERSION_NUM < 100000
2729 #ifdef AST_1_8_OR_HIGHER
2730 if (!f->subclass.codec)
2734 CDEBUG(NULL, ast, "No subclass\n");
2736 #ifdef AST_1_8_OR_HIGHER
2737 #if ASTERISK_VERSION_NUM < 100000
2738 #if ASTERISK_VERSION_NUM < 110000
2739 if (!(f->subclass.codec & ast->nativeformats)) {
2741 if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
2744 #if ASTERISK_VERSION_NUM < 110000
2745 if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
2747 if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
2751 #if ASTERISK_VERSION_NUM < 110000
2752 if (!(f->subclass & ast->nativeformats)) {
2754 if (!(f->subclass & ast_channel_nativeformats(ast))) {
2758 "Unexpected format. "
2759 "Activating emergency conversion...\n");
2761 #ifdef AST_1_8_OR_HIGHER
2762 #if ASTERISK_VERSION_NUM < 100000
2763 ast_set_write_format(ast, f->subclass.codec);
2765 ast_set_write_format(ast, &f->subclass.format);
2768 ast_set_write_format(ast, f->subclass);
2770 #if ASTERISK_VERSION_NUM < 110000
2771 f = (ast->writetrans) ? ast_translate(
2772 ast->writetrans, fr, 0) : fr;
2774 f = (ast_channel_writetrans(ast)) ? ast_translate(
2775 ast_channel_writetrans(ast), fr, 0) : fr;
2779 ast_mutex_lock(&chan_lock);
2780 #if ASTERISK_VERSION_NUM < 110000
2781 call = ast->tech_pvt;
2783 call = ast_channel_tech_pvt(ast);
2785 if (!call || !call->ref) {
2786 /* drop the frame, if no ref exists, but return successfull delivery, or asterisk will abort connection */
2787 ast_mutex_unlock(&chan_lock);
2794 p = *((unsigned char **)&(f->data));
2795 q = newparam.traffic.data;
2796 memset(&newparam, 0, sizeof(union parameter));
2798 l = (len > sizeof(newparam.traffic.data)) ? sizeof(newparam.traffic.data) : len;
2799 newparam.traffic.len = l;
2802 *q++ = flip_bits[*p++];
2803 send_message(MESSAGE_TRAFFIC, call->ref, &newparam);
2805 ast_mutex_unlock(&chan_lock);
2813 static struct ast_frame *lcr_read(struct ast_channel *ast)
2815 struct chan_call *call;
2817 struct ast_frame *f = NULL;
2819 ast_mutex_lock(&chan_lock);
2820 #if ASTERISK_VERSION_NUM < 110000
2821 call = ast->tech_pvt;
2823 call = ast_channel_tech_pvt(ast);
2826 ast_mutex_unlock(&chan_lock);
2829 if (call->pipe[0] > -1) {
2830 if (call->rebuffer && !call->hdlc) {
2831 /* Make sure we have a complete 20ms (160byte) frame */
2832 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2834 call->framepos += len;
2837 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2839 if (len < 0 && errno == EAGAIN) {
2840 ast_mutex_unlock(&chan_lock);
2842 #ifdef LCR_FOR_ASTERISK
2843 return &ast_null_frame;
2846 #ifdef LCR_FOR_CALLWEAVER
2852 close(call->pipe[0]);
2855 ast_mutex_unlock(&chan_lock);
2857 } else if (call->rebuffer && call->framepos < 160) {
2858 /* Not a complete frame, so we send a null-frame */
2859 ast_mutex_unlock(&chan_lock);
2860 return &ast_null_frame;
2864 call->read_fr.frametype = AST_FRAME_VOICE;
2865 #ifdef AST_1_8_OR_HIGHER
2866 #if ASTERISK_VERSION_NUM < 100000
2867 #if ASTERISK_VERSION_NUM < 110000
2868 call->read_fr.subclass.codec = ast->nativeformats;
2870 call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
2873 #if ASTERISK_VERSION_NUM < 110000
2874 ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
2876 ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
2878 call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
2881 #if ASTERISK_VERSION_NUM < 110000
2882 call->read_fr.subclass = ast->nativeformats;
2884 call->read_fr.subclass = ast_channel_nativeformats(ast);
2887 if (call->rebuffer) {
2888 call->read_fr.datalen = call->framepos;
2889 call->read_fr.samples = call->framepos;
2892 call->read_fr.datalen = len;
2893 call->read_fr.samples = len;
2895 call->read_fr.delivery = ast_tv(0,0);
2896 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2899 f = ast_dsp_process(ast, call->dsp, &call->read_fr);
2900 if (f && f->frametype == AST_FRAME_DTMF)
2901 #ifdef AST_1_8_OR_HIGHER
2902 CDEBUG(call, ast, "Asterisk detected inband DTMF: %c.\n", f->subclass.integer);
2904 CDEBUG(call, ast, "Asterisk detected inband DTMF: %c.\n", f->subclass);
2907 ast_mutex_unlock(&chan_lock);
2909 if (f && f->frametype == AST_FRAME_DTMF)
2912 return &call->read_fr;
2915 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2917 union parameter newparam;
2919 struct chan_call *call;
2920 const struct ast_tone_zone_sound *ts = NULL;
2922 ast_mutex_lock(&chan_lock);
2923 #if ASTERISK_VERSION_NUM < 110000
2924 call = ast->tech_pvt;
2926 call = ast_channel_tech_pvt(ast);
2929 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2930 ast_mutex_unlock(&chan_lock);
2935 case AST_CONTROL_BUSY:
2936 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2937 ast_setstate(ast, AST_STATE_BUSY);
2938 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2939 /* send message to lcr */
2940 memset(&newparam, 0, sizeof(union parameter));
2941 newparam.disconnectinfo.cause = 17;
2942 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2943 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2945 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2947 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2948 #if ASTERISK_VERSION_NUM < 110000
2949 ts = ast_get_indication_tone(ast->zone, "busy");
2951 ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
2955 case AST_CONTROL_CONGESTION:
2956 #if ASTERISK_VERSION_NUM < 110000
2957 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2959 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
2961 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2962 /* send message to lcr */
2963 memset(&newparam, 0, sizeof(union parameter));
2964 #if ASTERISK_VERSION_NUM < 110000
2965 newparam.disconnectinfo.cause = ast->hangupcause;
2967 newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
2969 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2970 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2972 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2974 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2975 #if ASTERISK_VERSION_NUM < 110000
2976 ts = ast_get_indication_tone(ast->zone, "congestion");
2978 ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
2982 case AST_CONTROL_PROCEEDING:
2983 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2984 if (call->state == CHAN_LCR_STATE_IN_SETUP
2985 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2986 /* send message to lcr */
2987 memset(&newparam, 0, sizeof(union parameter));
2988 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2990 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2993 case AST_CONTROL_RINGING:
2994 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2995 ast_setstate(ast, AST_STATE_RING);
2996 if (call->state == CHAN_LCR_STATE_IN_SETUP
2997 || call->state == CHAN_LCR_STATE_IN_DIALING
2998 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2999 /* send message to lcr */
3000 memset(&newparam, 0, sizeof(union parameter));
3001 send_message(MESSAGE_ALERTING, call->ref, &newparam);
3003 call->state = CHAN_LCR_STATE_IN_ALERTING;
3005 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
3006 #if ASTERISK_VERSION_NUM < 110000
3007 ts = ast_get_indication_tone(ast->zone, "ring");
3009 ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
3013 case AST_CONTROL_PROGRESS:
3014 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
3015 if (call->state == CHAN_LCR_STATE_IN_SETUP
3016 || call->state == CHAN_LCR_STATE_IN_DIALING) {
3017 CDEBUG(call, ast, "Changing to proceeding state, because no more dialing possible.\n");
3018 /* send message to lcr */
3019 memset(&newparam, 0, sizeof(union parameter));
3020 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
3022 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
3024 /* request bchannel */
3025 CDEBUG(call, ast, "Requesting audio path.\n");
3026 memset(&newparam, 0, sizeof(union parameter));
3027 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
3030 CDEBUG(call, ast, "Received indicate -1.\n");
3031 ast_playtones_stop(ast);
3035 case AST_CONTROL_VIDUPDATE:
3036 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
3039 case AST_CONTROL_HOLD:
3040 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
3041 /* send message to lcr */
3042 memset(&newparam, 0, sizeof(union parameter));
3043 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
3044 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3046 /*start music onhold*/
3047 #ifdef LCR_FOR_ASTERISK
3048 #if ASTERISK_VERSION_NUM <110000
3049 ast_moh_start(ast,data,ast->musicclass);
3051 ast_moh_start(ast,data,ast_channel_musicclass(ast));
3055 #ifdef LCR_FOR_CALLWEAVER
3056 ast_moh_start(ast, NULL);
3061 case AST_CONTROL_UNHOLD:
3062 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
3063 /* send message to lcr */
3064 memset(&newparam, 0, sizeof(union parameter));
3065 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3066 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3072 #ifdef AST_CONTROL_SRCUPDATE
3073 case AST_CONTROL_SRCUPDATE:
3077 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
3080 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
3085 if (ts && ts->data[0]) {
3086 ast_playtones_start(ast, 0, ts->data, 1);
3090 ast_mutex_unlock(&chan_lock);
3097 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
3099 struct chan_call *call;
3105 ast_mutex_lock(&chan_lock);
3106 #if ASTERISK_VERSION_NUM < 110000
3107 call = ast->tech_pvt;
3109 call = ast_channel_tech_pvt(ast);
3112 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
3113 ast_mutex_unlock(&chan_lock);
3117 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
3119 ast_mutex_unlock(&chan_lock);
3124 * send_text asterisk
3126 static int lcr_send_text(struct ast_channel *ast, const char *text)
3128 struct chan_call *call;
3129 union parameter newparam;
3131 ast_mutex_lock(&chan_lock);
3132 #if ASTERISK_VERSION_NUM < 110000
3133 call = ast->tech_pvt;
3135 call = ast_channel_tech_pvt(ast);
3138 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
3139 ast_mutex_unlock(&chan_lock);
3143 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
3144 memset(&newparam, 0, sizeof(union parameter));
3145 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
3146 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3147 ast_mutex_unlock(&chan_lock);
3154 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
3155 struct ast_channel *ast2, int flags,
3156 struct ast_frame **fo,
3157 struct ast_channel **rc, int timeoutms)
3160 struct chan_call *call1, *call2;
3161 struct ast_channel *carr[2], *who;
3163 struct ast_frame *f;
3166 /* bridge is disabled, because there is currerntly no concept to bridge mISDN channels */
3167 return AST_BRIDGE_FAILED;
3169 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
3174 /* join via dsp (if the channels are currently open) */
3175 ast_mutex_lock(&chan_lock);
3176 #if ASTERISK_VERSION_NUM < 110000
3177 call1 = ast1->tech_pvt;
3178 call2 = ast2->tech_pvt;
3180 call1 = ast_channel_tech_pvt(ast1);
3181 call2 = ast_channel_tech_pvt(ast2);
3183 if (!call1 || !call2) {
3184 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
3185 ast_mutex_unlock(&chan_lock);
3186 return AST_BRIDGE_COMPLETE;
3189 /* join, if both call instances uses dsp
3190 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
3192 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
3194 /* get bridge id and join */
3195 bridge_id = new_bridge_id();
3197 call1->bridge_id = bridge_id;
3198 call2->bridge_id = bridge_id;
3199 // FIXME: do bridiging
3200 // bchannel_join(call1->bchannel, bridge_id);
3201 // bchannel_join(call2->bchannel, bridge_id);
3203 call1->bridge_call = call2;
3204 call2->bridge_call = call1;
3206 if (call1->state == CHAN_LCR_STATE_IN_SETUP
3207 || call1->state == CHAN_LCR_STATE_IN_DIALING
3208 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
3209 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
3210 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3213 if (call2->state == CHAN_LCR_STATE_IN_SETUP
3214 || call2->state == CHAN_LCR_STATE_IN_DIALING
3215 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
3216 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
3217 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3221 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
3222 so let's do it for them. Hmpf.
3225 if (call1->on_hold) {
3226 union parameter newparam;
3228 memset(&newparam, 0, sizeof(union parameter));
3229 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3230 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
3235 if (call2->on_hold) {
3236 union parameter newparam;
3238 memset(&newparam, 0, sizeof(union parameter));
3239 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3240 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
3245 ast_mutex_unlock(&chan_lock);
3249 who = ast_waitfor_n(carr, 2, &to);
3252 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
3257 if (!f || f->frametype == AST_FRAME_CONTROL) {
3259 CDEBUG(NULL, NULL, "Got hangup.\n");
3261 CDEBUG(NULL, NULL, "Got CONTROL.\n");
3268 if ( f->frametype == AST_FRAME_DTMF ) {
3269 CDEBUG(NULL, NULL, "Got DTMF.\n");
3285 CDEBUG(NULL, NULL, "Releasing bridge.\n");
3287 /* split channels */
3288 ast_mutex_lock(&chan_lock);
3289 #if ASTERISK_VERSION_NUM < 110000
3290 call1 = ast1->tech_pvt;
3291 call2 = ast2->tech_pvt;
3293 call1 = ast_channel_tech_pvt(ast1);
3294 call2 = ast_channel_tech_pvt(ast2);
3296 if (call1 && call1->bridge_id) {
3297 call1->bridge_id = 0;
3298 if (call1->bridge_call)
3299 call1->bridge_call->bridge_call = NULL;
3301 if (call2 && call1->bridge_id) {
3302 call2->bridge_id = 0;
3303 if (call2->bridge_call)
3304 call2->bridge_call->bridge_call = NULL;
3306 call1->bridge_call = NULL;
3307 call2->bridge_call = NULL;
3309 ast_mutex_unlock(&chan_lock);
3310 return AST_BRIDGE_COMPLETE;
3312 static struct ast_channel_tech lcr_tech = {
3314 .description = "Channel driver for connecting to Linux-Call-Router",
3315 #if ASTERISK_VERSION_NUM < 100000
3316 .capabilities = AST_FORMAT_ALAW,
3318 .requester = lcr_request,
3320 #ifdef LCR_FOR_ASTERISK
3321 .send_digit_begin = lcr_digit_begin,
3322 .send_digit_end = lcr_digit_end,
3325 #ifdef LCR_FOR_CALLWEAVER
3326 .send_digit = lcr_digit,
3330 .bridge = lcr_bridge,
3331 .hangup = lcr_hangup,
3332 .answer = lcr_answer,
3335 .indicate = lcr_indicate,
3337 .send_text = lcr_send_text,
3346 static int lcr_show_lcr (int fd, int argc, char *argv[])
3351 static int lcr_show_calls (int fd, int argc, char *argv[])
3356 static int lcr_reload_routing (int fd, int argc, char *argv[])
3361 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
3366 static int lcr_port_block (int fd, int argc, char *argv[])
3371 static int lcr_port_unblock (int fd, int argc, char *argv[])
3376 static int lcr_port_unload (int fd, int argc, char *argv[])
3381 static struct ast_cli_entry cli_show_lcr =
3382 { {"lcr", "show", "lcr", NULL},
3384 "Shows current states of LCR core",
3385 "Usage: lcr show lcr\n",
3388 static struct ast_cli_entry cli_show_calls =
3389 { {"lcr", "show", "calls", NULL},
3391 "Shows current calls made by LCR and Asterisk",
3392 "Usage: lcr show calls\n",
3395 static struct ast_cli_entry cli_reload_routing =
3396 { {"lcr", "reload", "routing", NULL},
3398 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
3399 "Usage: lcr reload routing\n",
3402 static struct ast_cli_entry cli_reload_interfaces =
3403 { {"lcr", "reload", "interfaces", NULL},
3404 lcr_reload_interfaces,
3405 "Reloads interfaces conf of LCR",
3406 "Usage: lcr reload interfaces\n",
3409 static struct ast_cli_entry cli_port_block =
3410 { {"lcr", "port", "block", NULL},
3412 "Blocks LCR port for further calls",
3413 "Usage: lcr port block \"<port>\"\n",
3416 static struct ast_cli_entry cli_port_unblock =
3417 { {"lcr", "port", "unblock", NULL},
3419 "Unblocks or loads LCR port, port is opened my mISDN",
3420 "Usage: lcr port unblock \"<port>\"\n",
3423 static struct ast_cli_entry cli_port_unload =
3424 { {"lcr", "port", "unload", NULL},
3426 "Unloads LCR port, port is closes by mISDN",
3427 "Usage: lcr port unload \"<port>\"\n",
3432 #ifdef LCR_FOR_ASTERISK
3433 #ifdef AST_1_8_OR_HIGHER
3434 static int lcr_config_exec(struct ast_channel *ast, const char *data)
3436 static int lcr_config_exec(struct ast_channel *ast, void *data)
3440 #ifdef LCR_FOR_CALLWEAVER
3441 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
3444 struct chan_call *call;
3446 ast_mutex_lock(&chan_lock);
3448 #ifdef LCR_FOR_ASTERISK
3449 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
3452 #ifdef LCR_FOR_CALLWEAVER
3453 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
3459 if (call->ast == ast)
3465 #ifdef LCR_FOR_ASTERISK
3466 apply_opt(call, (char *)data);
3469 #ifdef LCR_FOR_CALLWEAVER
3470 apply_opt(call, (char *)argv[0]);
3474 if (call->tx_queue) {
3475 union parameter newparam;
3477 memset(&newparam, 0, sizeof(union parameter));
3478 newparam.queue = call->tx_queue * 8;
3479 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
3482 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
3484 ast_mutex_unlock(&chan_lock);
3489 * module loading and destruction
3491 int load_module(void)
3494 char options_error[256];
3496 for (i = 0; i < 256; i++) {
3497 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
3498 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
3501 if (read_options(options_error) == 0) {
3502 CERROR(NULL, NULL, "%s", options_error);
3504 #ifdef LCR_FOR_ASTERISK
3505 return AST_MODULE_LOAD_DECLINE;
3508 #ifdef LCR_FOR_CALLWEAVER
3514 ast_mutex_init(&chan_lock);
3515 ast_mutex_init(&log_lock);
3517 #if ASTERISK_VERSION_NUM < 100000
3518 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
3520 struct ast_format tmp;
3521 ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
3522 if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
3523 return AST_MODULE_LOAD_DECLINE;
3525 ast_format_cap_add(lcr_tech.capabilities, &tmp);
3527 if (ast_channel_register(&lcr_tech)) {
3528 CERROR(NULL, NULL, "Unable to register channel class\n");
3531 #ifdef LCR_FOR_ASTERISK
3532 return AST_MODULE_LOAD_DECLINE;
3535 #ifdef LCR_FOR_CALLWEAVER
3540 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
3542 #ifdef LCR_FOR_ASTERISK
3543 "lcr_config(<opt><optarg>:<opt>:...)\n"
3546 #ifdef LCR_FOR_CALLWEAVER
3547 "lcr_config(<opt><optarg>:<opt>:...)\n",
3550 "Sets LCR opts. and optargs\n"
3552 "The available options are:\n"
3553 " d - Send display text on called phone, text is the optarg.\n"
3554 " D - Forward detected dtmf tones from LCR.\n"
3555 " h - Force data call (HDLC).\n"
3556 " q - Add queue to make fax stream seamless (required for fax app).\n"
3557 " Use queue size in miliseconds for optarg. (try 250)\n"
3558 " a - Adding DTMF detection.\n"
3559 " f - Adding fax detection.\n"
3561 " c - Make crypted outgoing call, optarg is keyindex.\n"
3562 " e - Perform echo cancelation on this channel.\n"
3564 " Takes mISDN pipeline option as optarg.\n"
3565 " s - Send Non Inband DTMF as inband. (disables LCR's DTMF)\n"
3566 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
3568 " vr - rxgain control\n"
3569 " vt - txgain control\n"
3571 " Volume changes at factor 2 ^ optarg.\n"
3572 " k - use keypad to dial this call.\n"
3574 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
3575 " -> use 16 for fax (3.1k audio)\n"
3577 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
3578 "options: \"n:t:q250\" for seamless audio transmission.\n"
3583 ast_cli_register(&cli_show_lcr);
3584 ast_cli_register(&cli_show_calls);
3585 ast_cli_register(&cli_reload_routing);
3586 ast_cli_register(&cli_reload_interfaces);
3587 ast_cli_register(&cli_port_block);
3588 ast_cli_register(&cli_port_unblock);
3589 ast_cli_register(&cli_port_unload);
3592 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
3593 /* failed to create thread */
3595 ast_channel_unregister(&lcr_tech);
3597 #ifdef LCR_FOR_ASTERISK
3598 return AST_MODULE_LOAD_DECLINE;
3601 #ifdef LCR_FOR_CALLWEAVER
3609 int unload_module(void)
3611 /* First, take us out of the channel loop */
3612 CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
3614 pthread_cancel(chan_tid);
3618 del_timer(&socket_retry);
3620 unregister_fd(&wake_fd);
3621 close(wake_pipe[0]);
3622 close(wake_pipe[1]);
3624 // ast_mutex_unlock(&chan_lock);
3626 ast_channel_unregister(&lcr_tech);
3628 ast_unregister_application("lcr_config");
3630 if (lcr_sock >= 0) {
3635 #if ASTERISK_VERSION_NUM >= 100000
3636 lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
3641 int reload_module(void)
3647 #ifdef LCR_FOR_ASTERISK
3648 #define AST_MODULE "chan_lcr"
3651 #ifdef LCR_FOR_CALLWEAVER
3656 ast_mutex_lock(&usecnt_lock);
3658 ast_mutex_unlock(&usecnt_lock);
3663 #ifdef LCR_FOR_ASTERISK
3664 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3665 .load = load_module,
3666 .unload = unload_module,
3667 .reload = reload_module,
3671 #ifdef LCR_FOR_CALLWEAVER
3672 char *description(void)