1 /*****************************************************************************\
3 ** Linux Call Router **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg **
8 ** Asterisk socket client **
10 \*****************************************************************************/
16 To connect, open an LCR socket and send a MESSAGE_HELLO to socket with
17 the application name. This name is unique an can be used for routing calls.
18 Now the channel driver is linked to LCR and can receive and make calls.
21 Call is initiated by LCR:
23 If a call is received from LCR, a MESSAGE_NEWREF is received first.
24 The ref_was_assigned ist set to 1.
25 A new chan_call instance is created. The call reference (ref) is given by
26 the received MESSAGE_NEWREF. The state is CHAN_LCR_STATE_IN_PREPARE.
27 After receiving MESSAGE_SETUP from LCR, the ast_channel instance is created
28 using ast_channel_alloc(1). The setup information is given to asterisk.
29 The new Asterisk instance pointer (ast) is stored to chan_call structure.
30 The state changes to CHAN_LCR_STATE_IN_SETUP.
33 Call is initiated by Asterisk:
35 If a call is requested from Asterisk, a new chan_call instance is created.
36 The new Asterisk instance pointer (ast) is stored to chan_call structure.
37 The current call ref is set to 0, the state is CHAN_LCR_STATE_OUT_PREPARE.
38 If the call is received (lcr_call) A MESSAGE_NEWREF is sent to LCR requesting
39 a new call reference (ref).
40 The ref_was_assigned ist set to 1.
41 Further dialing information is queued.
42 After the new callref is received by special MESSAGE_NEWREF reply, new ref
43 is stored in the chan_call structure.
44 The setup information is sent to LCR using MESSAGE_SETUP.
45 The state changes to CHAN_LCR_STATE_OUT_SETUP.
50 During call process, messages are received and sent.
51 The state changes accordingly.
52 Any message is allowed to be sent to LCR at any time except MESSAGE_RELEASE.
53 If a MESSAGE_OVERLAP is received, further dialing is required.
54 Queued dialing information, if any, is sent to LCR using MESSAGE_DIALING.
55 In this case, the state changes to CHAN_LCR_STATE_OUT_DIALING.
58 Call is released by LCR:
60 A MESSAGE_RELEASE is received with the call reference (ref) to be released.
61 The current ref is set to 0, to indicate released reference.
62 The ref_was_assigned==1 shows that there is no other ref to be assigned.
63 The state changes to CHAN_LCR_STATE_RELEASE.
64 ast_queue_hangup() is called, if asterisk instance (ast) exists, if not,
65 the chan_call instance is destroyed.
66 After lcr_hangup() is called-back by Asterisk, the chan_call instance
67 is destroyed, because the current ref is set to 0 and the state equals
68 CHAN_LCR_STATE_RELEASE.
69 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, see the proceedure
70 "Call is released by Asterisk".
73 Call is released by Asterisk:
75 lcr_hangup() is called-back by Asterisk. If the call reference (ref) is set,
76 a MESSAGE_RELEASE is sent to LCR and the chan_call instance is destroyed.
77 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, the new state is
78 set to CHAN_LCR_STATE_RELEASE.
79 The ref_was_assigned==0 shows that a ref is still requested.
80 Later, if the MESSAGE_NEWREF reply is received, a MESSAGE_RELEASE is sent to
81 LCR and the chan_call instance is destroyed.
82 If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure
83 "Call is released by LCR".
88 The deadlocking problem:
90 - chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel
92 - ast_channel thread locks ast_channel and calls a tech function and waits
93 there for chan_lock to be unlocked.
97 Never call ast_queue_xxxx() if ast_channel is not locked and don't wait until
98 ast_channel can be locked. All messages to asterisk are queued inside call
99 instance and will be handled using a try-lock to get ast_channel lock.
100 If it succeeds to lock ast_channel, the ast_queue_xxxx can safely called even
101 if the lock is incremented and decremented there.
103 Exception: Calling ast_queue_frame inside ast->tech->read is safe, because
104 it is called from ast_channel process which has already locked ast_channel.
109 /* Choose if you want to have chan_lcr for Asterisk 1.4.x or CallWeaver 1.2.x */
110 #define LCR_FOR_ASTERISK
111 /* #define LCR_FOR_CALLWEAVER */
118 #include <sys/types.h>
120 //#include <signal.h>
123 #include <sys/ioctl.h>
124 #include <sys/socket.h>
127 #include <semaphore.h>
129 #define HAVE_ATTRIBUTE_always_inline 1
130 #define HAVE_ARPA_INET_H 1
131 #define HAVE_TIMERSUB 1
132 #define HAVE_STRTOQ 1
133 #define HAVE_INET_ATON 1
135 #include <asterisk/compiler.h>
136 #ifdef LCR_FOR_ASTERISK
137 #include <asterisk/buildopts.h>
141 * Fwd declare struct ast_channel to get rid of gcc warning about
142 * incompatible pointer type passed to ast_register_application2.
146 #include <asterisk/module.h>
147 #include <asterisk/channel.h>
148 #include <asterisk/config.h>
149 #include <asterisk/logger.h>
150 #include <asterisk/pbx.h>
151 #include <asterisk/options.h>
152 #include <asterisk/io.h>
153 #include <asterisk/frame.h>
154 #include <asterisk/translate.h>
155 #include <asterisk/cli.h>
156 #include <asterisk/musiconhold.h>
157 #include <asterisk/dsp.h>
158 #include <asterisk/translate.h>
159 #include <asterisk/file.h>
160 #ifdef LCR_FOR_ASTERISK
161 #include <asterisk/callerid.h>
163 #ifdef LCR_FOR_CALLWEAVER
164 #include <asterisk/phone_no_utils.h>
167 #include <asterisk/indications.h>
168 #include <asterisk/app.h>
169 #include <asterisk/features.h>
170 #include <asterisk/sched.h>
171 #if ASTERISK_VERSION_NUM < 110000
172 #include <asterisk/version.h>
174 #include "extension.h"
176 #include "callerid.h"
177 #include "lcrsocket.h"
181 #include "chan_lcr.h"
183 CHAN_LCR_STATE // state description structure
184 MESSAGES // message text
186 #ifdef LCR_FOR_CALLWEAVER
187 AST_MUTEX_DEFINE_STATIC(rand_lock);
190 unsigned char flip_bits[256];
192 #ifdef LCR_FOR_CALLWEAVER
193 static struct ast_frame nullframe = { AST_FRAME_NULL, };
198 char lcr_type[]="lcr";
200 #ifdef LCR_FOR_CALLWEAVER
201 static ast_mutex_t usecnt_lock;
203 static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
207 ast_mutex_t chan_lock; /* global lock */
208 ast_mutex_t log_lock; /* logging log */
210 * used to indicate change in file descriptors, so select function's result may
213 int global_change = 0;
216 struct lcr_fd wake_fd;
218 int glob_channel = 0;
221 struct lcr_fd socket_fd;
222 struct lcr_timer socket_retry;
225 struct admin_list *next;
226 struct admin_message msg;
227 } *admin_first = NULL;
229 static struct ast_channel_tech lcr_tech;
234 void chan_lcr_log(int type, const char *file, int line, const char *function, struct chan_call *call, struct ast_channel *ast, const char *fmt, ...)
237 char call_text[128] = "NULL";
238 char ast_text[128] = "NULL";
241 ast_mutex_lock(&log_lock);
244 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
245 buffer[sizeof(buffer)-1]=0;
249 sprintf(call_text, "%d", call->ref);
251 #if ASTERISK_VERSION_NUM < 110000
252 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
254 strncpy(ast_text, ast_channel_name(ast), sizeof(ast_text)-1);
256 ast_text[sizeof(ast_text)-1] = '\0';
258 // ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
259 printf("[call=%s ast=%s line=%d] %s", call_text, ast_text, line, buffer);
261 ast_mutex_unlock(&log_lock);
265 * channel and call instances
267 struct chan_call *call_first;
271 * special case: 0: find new ref, that has not been assigned a ref yet
274 struct chan_call *find_call_ref(unsigned int ref)
276 struct chan_call *call = call_first;
277 int assigned = (ref > 0);
280 if (call->ref == ref && call->ref_was_assigned == assigned)
287 void free_call(struct chan_call *call)
289 struct chan_call **temp = &call_first;
293 *temp = (*temp)->next;
294 if (call->pipe[0] > -1)
295 close(call->pipe[0]);
296 if (call->pipe[1] > -1)
297 close(call->pipe[1]);
298 if (call->bridge_call) {
299 if (call->bridge_call->bridge_call != call)
300 CERROR(call, NULL, "Linked call structure has no link to us.\n");
301 call->bridge_call->bridge_call = NULL;
304 ast_translator_free_path(call->trans);
306 ast_dsp_free(call->dsp);
307 CDEBUG(call, NULL, "Call instance freed.\n");
312 temp = &((*temp)->next);
314 CERROR(call, NULL, "Call instance not found in list.\n");
317 struct chan_call *alloc_call(void)
319 struct chan_call **callp = &call_first;
322 callp = &((*callp)->next);
324 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
326 memset(*callp, 0, sizeof(struct chan_call));
327 if (pipe((*callp)->pipe) < 0) {
328 CERROR(*callp, NULL, "Failed to create pipe.\n");
332 fcntl((*callp)->pipe[0], F_SETFL, O_NONBLOCK);
333 CDEBUG(*callp, NULL, "Call instance allocated.\n");
337 unsigned short new_bridge_id(void)
339 struct chan_call *call;
340 unsigned short id = 1;
342 /* search for lowest bridge id that is not in use and not 0 */
346 if (call->bridge_id == id)
354 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
359 * enque message to LCR
361 int send_message(int message_type, unsigned int ref, union parameter *param)
363 struct admin_list *admin, **adminp;
366 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
369 if (message_type != MESSAGE_TRAFFIC)
370 CDEBUG(NULL, NULL, "Sending %s to socket. (ref=%d)\n", messages_txt[message_type], ref);
372 adminp = &admin_first;
374 adminp = &((*adminp)->next);
375 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
377 CERROR(NULL, NULL, "No memory for message to LCR.\n");
382 admin->msg.message = ADMIN_MESSAGE;
383 admin->msg.u.msg.type = message_type;
384 admin->msg.u.msg.ref = ref;
385 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
386 socket_fd.when |= LCR_FD_WRITE;
391 rc = write(wake_pipe[1], &byte, 1);
398 * apply options (in locked state)
400 void apply_opt(struct chan_call *call, char *data)
402 union parameter newparam;
403 char string[1024], *p = string, *opt;//, *key;
409 strncpy(string, data, sizeof(string)-1);
410 string[sizeof(string)-1] = '\0';
413 while((opt = strsep(&p, ":"))) {
416 if (opt[1] == '\0') {
417 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
420 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
421 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
422 strncpy(call->display, opt+1, sizeof(call->display)-1);
424 memset(&newparam, 0, sizeof(union parameter));
425 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
426 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
430 if (opt[1] != '\0') {
431 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
434 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
439 if (opt[1] == '\0') {
440 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
444 /* check for 0xXXXX... type of key */
445 if (!!strncmp((char *)key, "0x", 2)) {
446 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
450 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
451 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
456 if (*key>='0' && *key<='9')
457 call->bf_key[i] = (*key-'0') << 8;
458 else if (*key>='a' && *key<='f')
459 call->bf_key[i] = (*key-'a'+10) << 8;
460 else if (*key>='A' && *key<='F')
461 call->bf_key[i] = (*key-'A'+10) << 8;
465 if (*key>='0' && *key<='9')
466 call->bf_key[i] += (*key - '0');
467 else if (*key>='a' && *key<='f')
468 call->bf_key[i] += (*key - 'a' + 10);
469 else if (*key>='A' && *key<='F')
470 call->bf_key[i] += (*key - 'A' + 10);
477 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
481 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
483 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
487 if (opt[1] != '\0') {
488 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
491 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
496 if (opt[1] == '\0') {
497 CERROR(call, call->ast, "Option 'q' (queue) expects parameter.\n", opt);
500 CDEBUG(call, call->ast, "Option 'q' (queue).\n");
501 call->tx_queue = atoi(opt+1);
505 if (opt[1] == '\0') {
506 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
509 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
510 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
512 bchannel_pipeline(call->bchannel, call->pipeline);
516 if (opt[1] != '\0') {
517 CERROR(call, call->ast, "Option 'f' (faxdetect) expects no parameter.\n", opt);
522 CDEBUG(call, call->ast, "Option 'f' (faxdetect).\n");
525 if (opt[1] != '\0') {
526 CERROR(call, call->ast, "Option 'a' (asterisk DTMF) expects no parameter.\n", opt);
531 CDEBUG(call, call->ast, "Option 'a' (Asterisk DTMF detection).\n");
534 if (opt[1] != '\0') {
535 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
538 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
543 if (opt[1] != '\0') {
544 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
547 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
548 call->inband_dtmf = 1;
552 if (opt[1] != 'r' && opt[1] != 't') {
553 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
557 if (gain < -8 || gain >8) {
558 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
561 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
563 call->rx_gain = gain;
565 bchannel_gain(call->bchannel, call->rx_gain, 0);
567 call->tx_gain = gain;
569 bchannel_gain(call->bchannel, call->tx_gain, 1);
574 if (opt[1] != '\0') {
575 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
578 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
583 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
587 if (call->faxdetect || call->ast_dsp) {
589 call->dsp=ast_dsp_new();
591 #ifdef LCR_FOR_CALLWEAVER
592 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_CNG_DETECT : 0));
594 #ifdef LCR_FOR_ASTERISK
595 #ifdef DSP_FEATURE_DTMF_DETECT
596 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_DETECT : 0));
598 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT | ((call->faxdetect) ? DSP_FEATURE_FAX_DETECT : 0));
603 #ifdef LCR_FOR_CALLWEAVER
604 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
606 #ifdef LCR_FOR_ASTERISK
607 #if ASTERISK_VERSION_NUM < 100000
608 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
610 // struct ast_format src;
611 // struct ast_format dst;
612 // ast_format_set(&dst, AST_FORMAT_SLINEAR, 0);
613 // ast_format_set(&dst,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
614 // call->trans=ast_translator_build_path(&dst, &src);
623 * send setup info to LCR
624 * this function is called, when asterisk call is received and ref is received
626 static void send_setup_to_lcr(struct chan_call *call)
628 union parameter newparam;
629 struct ast_channel *ast = call->ast;
632 if (!call->ast || !call->ref)
635 #ifdef AST_1_8_OR_HIGHER
636 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->callerinfo.id);
638 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
641 /* send setup message to LCR */
642 memset(&newparam, 0, sizeof(union parameter));
643 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
644 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
646 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
648 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
649 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
650 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
651 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
652 call->display[0] = '\0';
654 #ifdef AST_1_8_OR_HIGHER
655 /* set stored call information */
656 memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
657 memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
659 if (call->cid_num[0])
660 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
661 if (call->cid_name[0])
662 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
663 if (call->cid_rdnis[0]) {
664 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
665 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
666 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
668 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
669 case AST_PRES_RESTRICTED:
670 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
672 case AST_PRES_UNAVAILABLE:
673 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
675 case AST_PRES_ALLOWED:
677 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
679 switch(ast->cid.cid_ton) {
681 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
684 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
687 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
690 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
693 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
694 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
696 #if ASTERISK_VERSION_NUM < 110000
697 // ast->transfercapability = atoi(tmp);
698 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
700 // ast_channel_transfercapability_set(ast, atoi(tmp));
701 newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
703 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
705 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
707 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
708 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
710 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
711 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
712 send_message(MESSAGE_SETUP, call->ref, &newparam);
713 if (call->tx_queue) {
714 memset(&newparam, 0, sizeof(union parameter));
715 newparam.queue = call->tx_queue * 8;
716 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
719 /* change to outgoing setup state */
720 call->state = CHAN_LCR_STATE_OUT_SETUP;
724 * send dialing info to LCR
725 * this function is called, when setup acknowledge is received and dialing
728 static void send_dialque_to_lcr(struct chan_call *call)
730 union parameter newparam;
732 if (!call->ast || !call->ref || !call->dialque[0])
735 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
737 /* send setup message to LCR */
738 memset(&newparam, 0, sizeof(union parameter));
740 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
742 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
743 call->dialque[0] = '\0';
744 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
748 * in case of a bridge, the unsupported message can be forwarded directly
749 * to the remote call.
751 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
755 if (!call->bridge_call) return;
756 CDEBUG(call, NULL, "Sending message due bridging.\n");
757 send_message(message_type, call->bridge_call->ref, param);
761 * send release message to LCR
763 static void send_release(struct chan_call *call, int cause, int location)
765 union parameter newparam;
767 /* sending release */
768 memset(&newparam, 0, sizeof(union parameter));
769 newparam.disconnectinfo.cause = cause;
770 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
771 send_message(MESSAGE_RELEASE, call->ref, &newparam);
775 * check if extension matches and start asterisk
776 * if it can match, proceed
779 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
782 union parameter newparam;
783 #if ASTERISK_VERSION_NUM < 110000
784 char *exten = ast->exten;
786 char s_exten[AST_MAX_EXTENSION];
789 strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
795 #if ASTERISK_VERSION_NUM < 110000
796 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
798 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
803 #if ASTERISK_VERSION_NUM < 110000
804 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
805 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
807 if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
808 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
813 #if ASTERISK_VERSION_NUM < 110000
814 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
815 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);
817 if (!ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
818 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));
823 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
824 /* send setup acknowledge to lcr */
825 memset(&newparam, 0, sizeof(union parameter));
826 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
829 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
834 #if ASTERISK_VERSION_NUM < 110000
835 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
837 if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
839 /* send setup acknowledge to lcr */
840 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
841 memset(&newparam, 0, sizeof(union parameter));
842 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
846 call->state = CHAN_LCR_STATE_IN_DIALING;
848 /* if match, start pbx */
849 #if ASTERISK_VERSION_NUM < 110000
850 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
852 if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
854 CDEBUG(call, ast, "Extensions matches.\n");
858 /* send setup acknowledge to lcr */
859 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
860 memset(&newparam, 0, sizeof(union parameter));
861 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
865 call->state = CHAN_LCR_STATE_IN_DIALING;
868 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
872 #if ASTERISK_VERSION_NUM < 110000
875 if (!*ast_channel_exten(ast)) {
877 /* send setup acknowledge to lcr */
878 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
879 memset(&newparam, 0, sizeof(union parameter));
880 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
884 call->state = CHAN_LCR_STATE_IN_DIALING;
887 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
895 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
896 send_release(call, cause, LOCATION_PRIVATE_LOCAL);
898 /* release asterisk */
899 #if ASTERISK_VERSION_NUM < 110000
900 ast->hangupcause = call->cause;
902 ast_channel_hangupcause_set(ast, call->cause);
904 /* change to release state */
905 call->state = CHAN_LCR_STATE_RELEASE;
906 ast_hangup(ast); // call will be destroyed here
910 /* send setup to asterisk */
911 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
913 #ifdef LCR_FOR_CALLWEAVER
915 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
918 ret = ast_pbx_start(ast);
920 cause = (ret==-2)?34:27;
923 call->pbx_started = 1;
924 ast_setstate(ast, AST_STATE_RING);
928 * incoming setup from LCR
930 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
932 struct ast_channel *ast;
933 #ifdef AST_1_8_OR_HIGHER
934 struct ast_party_redirecting *ast_redir;
935 struct ast_party_caller *ast_caller;
937 struct ast_callerid *ast_caller;
939 #if ASTERISK_VERSION_NUM >= 110000
940 struct ast_party_redirecting s_ast_redir;
941 struct ast_party_caller s_ast_caller;
942 ast_party_redirecting_init(&s_ast_redir);
943 ast_party_caller_init(&s_ast_caller);
945 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
947 /* create asterisk channel instrance */
949 #ifdef LCR_FOR_CALLWEAVER
950 ast = ast_channel_alloc(1);
953 #ifdef LCR_FOR_ASTERISK
954 #ifdef AST_1_8_OR_HIGHER
955 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
957 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
961 #if ASTERISK_VERSION_NUM < 110000
962 #ifdef AST_1_8_OR_HIGHER
963 ast_redir = &ast->redirecting;
964 ast_caller = &ast->caller;
966 ast_caller = &ast->cid;
969 ast_redir = &s_ast_redir;
970 ast_caller = &s_ast_caller;
975 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
976 send_release(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
983 #if ASTERISK_VERSION_NUM < 110000
984 ast->tech_pvt = call;
985 ast->tech = &lcr_tech;
986 ast->fds[0] = call->pipe[0];
988 ast_channel_tech_pvt_set(ast, call);
989 ast_channel_tech_set(ast, &lcr_tech);
990 ast_channel_set_fd(ast, 0, call->pipe[0]);
993 /* fill setup information */
994 if (param->setup.dialinginfo.id)
995 #if ASTERISK_VERSION_NUM < 110000
996 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
997 if (param->setup.dialinginfo.context[0])
998 strncpy(ast->context, param->setup.dialinginfo.context, AST_MAX_CONTEXT-1);
1000 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
1002 ast_channel_exten_set(ast, param->setup.dialinginfo.id);
1003 if (param->setup.context[0])
1004 ast_channel_context_set(ast, param->setup.context);
1006 ast_channel_context_set(ast, param->setup.callerinfo.interface);
1010 #ifdef AST_1_8_OR_HIGHER
1011 if (param->setup.callerinfo.id[0]) {
1012 ast_caller->id.number.valid = 1;
1013 ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
1014 if (!param->setup.callerinfo.id[0]) {
1015 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1016 ast_caller->id.number.plan = (0 << 4) | 1;
1018 switch (param->setup.callerinfo.present) {
1019 case INFO_PRESENT_ALLOWED:
1020 ast_caller->id.number.presentation = AST_PRES_ALLOWED;
1022 case INFO_PRESENT_RESTRICTED:
1023 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1026 ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
1028 switch (param->setup.callerinfo.screen) {
1029 case INFO_SCREEN_USER:
1030 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1032 case INFO_SCREEN_USER_VERIFIED_PASSED:
1033 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1035 case INFO_SCREEN_USER_VERIFIED_FAILED:
1036 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1039 ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
1041 switch (param->setup.callerinfo.ntype) {
1042 case INFO_NTYPE_SUBSCRIBER:
1043 ast_caller->id.number.plan = (4 << 4) | 1;
1045 case INFO_NTYPE_NATIONAL:
1046 ast_caller->id.number.plan = (2 << 4) | 1;
1048 case INFO_NTYPE_INTERNATIONAL:
1049 ast_caller->id.number.plan = (1 << 4) | 1;
1052 ast_caller->id.number.plan = (0 << 4) | 1;
1055 if (param->setup.callerinfo.id2[0]) {
1056 ast_caller->ani.number.valid = 1;
1057 ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
1058 switch (param->setup.callerinfo.present2) {
1059 case INFO_PRESENT_ALLOWED:
1060 ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
1062 case INFO_PRESENT_RESTRICTED:
1063 ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
1066 ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
1068 switch (param->setup.callerinfo.screen2) {
1069 case INFO_SCREEN_USER:
1070 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1072 case INFO_SCREEN_USER_VERIFIED_PASSED:
1073 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1075 case INFO_SCREEN_USER_VERIFIED_FAILED:
1076 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1079 ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
1081 switch (param->setup.callerinfo.ntype2) {
1082 case INFO_NTYPE_SUBSCRIBER:
1083 ast_caller->ani.number.plan = (4 << 4) | 1;
1085 case INFO_NTYPE_NATIONAL:
1086 ast_caller->ani.number.plan = (2 << 4) | 1;
1088 case INFO_NTYPE_INTERNATIONAL:
1089 ast_caller->ani.number.plan = (1 << 4) | 1;
1092 ast_caller->ani.number.plan = (0 << 4) | 1;
1095 if (param->setup.callerinfo.name[0]) {
1096 ast_caller->id.name.valid = 1;
1097 ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
1099 #if ASTERISK_VERSION_NUM >= 110000
1100 ast_channel_caller_set(ast, ast_caller);
1102 if (param->setup.redirinfo.id[0]) {
1103 ast_redir->from.number.valid = 1;
1104 ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
1105 switch (param->setup.redirinfo.present) {
1106 case INFO_PRESENT_ALLOWED:
1107 ast_redir->from.number.presentation = AST_PRES_ALLOWED;
1109 case INFO_PRESENT_RESTRICTED:
1110 ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
1113 ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
1115 switch (param->setup.redirinfo.screen) {
1116 case INFO_SCREEN_USER:
1117 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1119 case INFO_SCREEN_USER_VERIFIED_PASSED:
1120 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1122 case INFO_SCREEN_USER_VERIFIED_FAILED:
1123 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1126 ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
1128 switch (param->setup.redirinfo.ntype) {
1129 case INFO_NTYPE_SUBSCRIBER:
1130 ast_redir->from.number.plan = (4 << 4) | 1;
1132 case INFO_NTYPE_NATIONAL:
1133 ast_redir->from.number.plan = (2 << 4) | 1;
1135 case INFO_NTYPE_INTERNATIONAL:
1136 ast_redir->from.number.plan = (1 << 4) | 1;
1139 ast_redir->from.number.plan = (0 << 4) | 1;
1141 #if ASTERISK_VERSION_NUM >= 110000
1142 ast_channel_redirecting_set(ast, ast_redir);
1146 memset(&ast->cid, 0, sizeof(ast->cid));
1147 if (param->setup.callerinfo.id[0])
1148 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
1149 if (param->setup.callerinfo.id2[0])
1150 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
1151 if (param->setup.callerinfo.name[0])
1152 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
1153 if (param->setup.redirinfo.id[0])
1154 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
1155 switch (param->setup.callerinfo.present) {
1156 case INFO_PRESENT_ALLOWED:
1157 ast->cid.cid_pres = AST_PRES_ALLOWED;
1159 case INFO_PRESENT_RESTRICTED:
1160 ast->cid.cid_pres = AST_PRES_RESTRICTED;
1163 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
1165 switch (param->setup.callerinfo.ntype) {
1166 case INFO_NTYPE_SUBSCRIBER:
1167 ast->cid.cid_ton = 4;
1169 case INFO_NTYPE_NATIONAL:
1170 ast->cid.cid_ton = 2;
1172 case INFO_NTYPE_INTERNATIONAL:
1173 ast->cid.cid_ton = 1;
1176 ast->cid.cid_ton = 0;
1180 #if ASTERISK_VERSION_NUM < 110000
1181 ast->transfercapability = param->setup.capainfo.bearer_capa;
1183 ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
1185 /* enable hdlc if transcap is data */
1186 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
1188 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
1190 /* configure channel */
1191 #if ASTERISK_VERSION_NUM < 100000
1192 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1193 ast->readformat = ast->rawreadformat = ast->nativeformats;
1194 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1196 #if ASTERISK_VERSION_NUM < 110000
1197 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1198 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
1199 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
1200 ast_set_write_format(ast, &ast->rawwriteformat);
1201 ast_set_read_format(ast, &ast->rawreadformat);
1203 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1204 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
1205 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
1206 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
1207 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
1210 #if ASTERISK_VERSION_NUM < 110000
1212 ast->hangupcause = 0;
1214 ast_channel_priority_set(ast, 1);
1215 ast_channel_hangupcause_set(ast, 0);
1219 call->state = CHAN_LCR_STATE_IN_SETUP;
1221 if (!call->pbx_started)
1222 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
1226 * incoming setup acknowledge from LCR
1228 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
1230 if (!call->ast) return;
1232 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
1234 /* send pending digits in dialque */
1235 if (call->dialque[0])
1236 send_dialque_to_lcr(call);
1237 /* change to overlap state */
1238 call->state = CHAN_LCR_STATE_OUT_DIALING;
1242 * incoming proceeding from LCR
1244 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
1246 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
1249 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
1250 /* queue event for asterisk */
1251 if (call->ast && call->pbx_started) {
1256 rc = write(wake_pipe[1], &byte, 1);
1258 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
1264 * incoming alerting from LCR
1266 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
1268 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
1271 call->state = CHAN_LCR_STATE_OUT_ALERTING;
1272 /* queue event to asterisk */
1273 if (call->ast && call->pbx_started) {
1278 rc = write(wake_pipe[1], &byte, 1);
1280 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1285 * incoming connect from LCR
1287 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1289 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1292 call->state = CHAN_LCR_STATE_CONNECT;
1293 /* copy connectinfo */
1294 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1295 /* queue event to asterisk */
1296 if (call->ast && call->pbx_started) {
1301 rc = write(wake_pipe[1], &byte, 1);
1303 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1308 * incoming disconnect from LCR
1310 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1312 struct ast_channel *ast = call->ast;
1314 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1317 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1319 call->cause = param->disconnectinfo.cause;
1320 call->location = param->disconnectinfo.location;
1321 /* if bridge, forward disconnect and return */
1324 if (call->bridge_call) {
1325 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1326 bridge_message_if_bridged(call, message_type, param);
1330 /* release lcr with same cause */
1331 send_release(call, call->cause, call->location);
1333 /* change to release state */
1334 call->state = CHAN_LCR_STATE_RELEASE;
1335 /* queue release asterisk */
1337 #if ASTERISK_VERSION_NUM < 110000
1338 ast->hangupcause = call->cause;
1340 ast_channel_hangupcause_set(ast, call->cause);
1342 if (call->pbx_started) {
1347 rc = write(wake_pipe[1], &byte, 1);
1349 strcpy(call->queue_string, "H"); // overwrite other indications
1351 ast_hangup(ast); // call will be destroyed here
1357 * incoming release from LCR
1359 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1361 struct ast_channel *ast = call->ast;
1363 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1367 /* change to release state */
1368 call->state = CHAN_LCR_STATE_RELEASE;
1369 /* copy release info */
1371 call->cause = param->disconnectinfo.cause;
1372 call->location = param->disconnectinfo.location;
1374 /* if we have an asterisk instance, queue hangup, else we are done */
1376 #if ASTERISK_VERSION_NUM < 110000
1377 ast->hangupcause = call->cause;
1379 ast_channel_hangupcause_set(ast, call->cause);
1381 if (call->pbx_started) {
1386 rc = write(wake_pipe[1], &byte, 1);
1388 strcpy(call->queue_string, "H");
1390 ast_hangup(ast); // call will be destroyed here
1399 * incoming information from LCR
1401 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1403 struct ast_channel *ast = call->ast;
1405 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1409 /* pbx not started */
1410 if (!call->pbx_started) {
1411 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1412 #if ASTERISK_VERSION_NUM < 110000
1413 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1415 ast_channel_exten_set(ast, param->information.id);
1417 lcr_start_pbx(call, ast, param->information.sending_complete);
1421 /* change dailing state after setup */
1422 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1423 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1424 call->state = CHAN_LCR_STATE_IN_DIALING;
1425 // ast_setstate(ast, AST_STATE_DIALING);
1429 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1434 rc = write(wake_pipe[1], &byte, 1);
1436 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1439 /* use bridge to forware message not supported by asterisk */
1440 if (call->state == CHAN_LCR_STATE_CONNECT) {
1441 if (call->bridge_call) {
1442 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1443 bridge_message_if_bridged(call, message_type, param);
1445 if (call->dsp_dtmf) {
1450 rc = write(wake_pipe[1], &byte, 1);
1452 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1454 CDEBUG(call, call->ast, "LCR's DTMF detection is disabled.\n");
1460 * incoming information from LCR
1462 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1464 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1466 if (!call->ast) return;
1468 /* use bridge to forware message not supported by asterisk */
1469 bridge_message_if_bridged(call, message_type, param);
1473 * incoming information from LCR
1475 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1477 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1479 if (!call->ast) return;
1481 /* use bridge to forware message not supported by asterisk */
1482 bridge_message_if_bridged(call, message_type, param);
1486 * incoming pattern from LCR
1488 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1490 union parameter newparam;
1492 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1494 if (!call->ast) return;
1496 /* pattern are indicated only once */
1497 if (call->has_pattern)
1499 call->has_pattern = 1;
1501 /* request bchannel */
1502 CDEBUG(call, call->ast, "Requesting audio path (ref=%d)\n", call->ref);
1503 memset(&newparam, 0, sizeof(union parameter));
1504 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
1506 /* queue PROGRESS, because tones are available */
1507 if (call->ast && call->pbx_started) {
1512 rc = write(wake_pipe[1], &byte, 1);
1514 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1519 * got dtmf from bchannel (locked state)
1521 void lcr_in_dtmf(struct chan_call *call, int val)
1523 struct ast_channel *ast = call->ast;
1528 if (!call->pbx_started)
1531 if (!call->dsp_dtmf) {
1532 CDEBUG(call, call->ast, "Recognised DTMF digit '%c' by LCR, but ignoring. (disabled by option)\n", val);
1536 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1543 rc = write(wake_pipe[1], &byte, 1);
1545 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1549 * message received from LCR
1551 int receive_message(int message_type, unsigned int ref, union parameter *param)
1553 struct chan_call *call;
1554 union parameter newparam;
1557 memset(&newparam, 0, sizeof(union parameter));
1559 /* handle new ref */
1560 if (message_type == MESSAGE_NEWREF) {
1561 if (param->newref.direction) {
1562 /* new ref from lcr */
1563 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1564 if (!ref || find_call_ref(ref)) {
1565 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1568 /* allocate new call instance */
1569 call = alloc_call();
1571 call->state = CHAN_LCR_STATE_IN_PREPARE;
1574 call->ref_was_assigned = 1;
1575 /* set dtmf (default, use option 'n' to disable */
1577 /* wait for setup (or release from asterisk) */
1579 /* new ref, as requested from this remote application */
1580 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1581 call = find_call_ref(0);
1583 /* send release, if ref does not exist */
1584 CERROR(NULL, NULL, "No call found, that requests a ref.\n");
1589 call->ref_was_assigned = 1;
1590 /* set dtmf (default, use option 'n' to disable */
1592 /* send pending setup info */
1593 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1594 send_setup_to_lcr(call);
1595 /* release if asterisk has signed off */
1596 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1599 send_release(call, call->cause, call->location);
1601 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1607 send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
1613 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1616 call = find_call_ref(ref);
1618 /* ignore ref that is not used (anymore) */
1619 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1623 /* handle messages */
1624 switch(message_type) {
1626 lcr_in_setup(call, message_type, param);
1629 case MESSAGE_OVERLAP:
1630 lcr_in_overlap(call, message_type, param);
1633 case MESSAGE_PROCEEDING:
1634 lcr_in_proceeding(call, message_type, param);
1637 case MESSAGE_ALERTING:
1638 lcr_in_alerting(call, message_type, param);
1641 case MESSAGE_CONNECT:
1642 lcr_in_connect(call, message_type, param);
1645 case MESSAGE_DISCONNECT:
1646 lcr_in_disconnect(call, message_type, param);
1649 case MESSAGE_RELEASE:
1650 lcr_in_release(call, message_type, param);
1653 case MESSAGE_INFORMATION:
1654 lcr_in_information(call, message_type, param);
1657 case MESSAGE_NOTIFY:
1658 lcr_in_notify(call, message_type, param);
1661 case MESSAGE_FACILITY:
1662 lcr_in_facility(call, message_type, param);
1665 case MESSAGE_PATTERN: // audio available from LCR
1666 if (!call->has_pattern)
1667 lcr_in_pattern(call, message_type, param);
1670 case MESSAGE_NOPATTERN: // audio not available from LCR
1673 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1674 call->audiopath = param->audiopath;
1677 case MESSAGE_TRAFFIC: // if remote audio connected or hold
1679 unsigned char *p = param->traffic.data;
1680 int i, len = param->traffic.len;
1681 for (i = 0; i < len; i++, p++)
1684 rc = write(call->pipe[1], param->traffic.data, param->traffic.len);
1688 lcr_in_dtmf(call, param->dtmf);
1692 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1699 * release all calls (due to broken socket)
1701 static void release_all_calls(void)
1703 struct chan_call *call;
1708 /* no ast, so we may directly free call */
1710 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1714 /* already in release process */
1715 if (call->state == CHAN_LCR_STATE_RELEASE) {
1719 /* release or queue release */
1721 call->state = CHAN_LCR_STATE_RELEASE;
1722 if (!call->pbx_started) {
1723 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1724 ast_hangup(call->ast); // call will be destroyed here
1727 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1732 rc = write(wake_pipe[1], &byte, 1);
1734 strcpy(call->queue_string, "H");
1739 void close_socket(void);
1742 * warning! not thread safe
1743 * returns -1 for socket error, 0 for no work, 1 for work
1745 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1748 struct admin_list *admin;
1749 struct admin_message msg;
1751 if ((what & LCR_FD_READ)) {
1752 /* read from socket */
1753 len = read(lcr_sock, &msg, sizeof(msg));
1755 CERROR(NULL, NULL, "Socket closed.(read)\n");
1757 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1759 release_all_calls();
1760 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1764 if (len != sizeof(msg)) {
1765 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1768 if (msg.message != ADMIN_MESSAGE) {
1769 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1772 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1774 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1779 if ((what & LCR_FD_WRITE)) {
1780 /* write to socket */
1782 socket_fd.when &= ~LCR_FD_WRITE;
1785 admin = admin_first;
1786 len = write(lcr_sock, &admin->msg, sizeof(msg));
1788 CERROR(NULL, NULL, "Socket closed.(write)\n");
1792 if (len != sizeof(msg)) {
1793 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1797 admin_first = admin->next;
1801 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1810 * open and close socket and thread
1812 int open_socket(void)
1815 struct sockaddr_un sock_address;
1816 union parameter param;
1819 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1820 CERROR(NULL, NULL, "Failed to create socket.\n");
1824 /* set socket address and name */
1825 memset(&sock_address, 0, sizeof(sock_address));
1826 sock_address.sun_family = PF_UNIX;
1827 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1829 /* connect socket */
1830 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1833 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1837 /* register socket fd */
1838 memset(&socket_fd, 0, sizeof(socket_fd));
1839 socket_fd.fd = lcr_sock;
1840 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1842 /* enque hello message */
1843 memset(¶m, 0, sizeof(param));
1844 strcpy(param.hello.application, "asterisk");
1845 send_message(MESSAGE_HELLO, 0, ¶m);
1850 void close_socket(void)
1852 struct admin_list *admin, *temp;
1854 /* socket not created */
1858 unregister_fd(&socket_fd);
1860 /* flush pending messages */
1861 admin = admin_first;
1864 admin = admin->next;
1876 /* sending queue to asterisk */
1877 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1882 rc = read(wake_pipe[0], &byte, 1);
1889 static void handle_queue()
1891 struct chan_call *call;
1892 struct ast_channel *ast;
1893 struct ast_frame fr;
1899 p = call->queue_string;
1902 if (ast_channel_trylock(ast)) {
1903 ast_mutex_unlock(&chan_lock);
1905 ast_mutex_lock(&chan_lock);
1911 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1912 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1915 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1916 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1919 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1920 ast_queue_control(ast, AST_CONTROL_RINGING);
1921 ast_setstate(ast, AST_STATE_RINGING);
1924 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1925 ast_queue_control(ast, AST_CONTROL_ANSWER);
1928 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1929 ast_queue_hangup(ast);
1931 case '1': case '2': case '3': case 'A':
1932 case '4': case '5': case '6': case 'B':
1933 case '7': case '8': case '9': case 'C':
1934 case '*': case '0': case '#': case 'D':
1935 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1936 /* send digit to asterisk */
1937 memset(&fr, 0, sizeof(fr));
1939 #ifdef LCR_FOR_ASTERISK
1940 fr.frametype = AST_FRAME_DTMF_BEGIN;
1943 #ifdef LCR_FOR_CALLWEAVER
1944 fr.frametype = AST_FRAME_DTMF;
1947 #ifdef AST_1_8_OR_HIGHER
1948 fr.subclass.integer = *p;
1952 fr.delivery = ast_tv(0, 0);
1953 ast_queue_frame(ast, &fr);
1955 #ifdef LCR_FOR_ASTERISK
1956 fr.frametype = AST_FRAME_DTMF_END;
1957 ast_queue_frame(ast, &fr);
1962 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1966 call->queue_string[0] = '\0';
1967 ast_channel_unlock(ast);
1973 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1975 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1976 if (open_socket() < 0)
1977 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1982 void lock_chan(void)
1984 ast_mutex_lock(&chan_lock);
1987 void unlock_chan(void)
1989 ast_mutex_unlock(&chan_lock);
1992 /* chan_lcr thread */
1993 static void *chan_thread(void *arg)
1995 if (pipe(wake_pipe) < 0) {
1996 CERROR(NULL, NULL, "Failed to open pipe.\n");
1999 memset(&wake_fd, 0, sizeof(wake_fd));
2000 wake_fd.fd = wake_pipe[0];
2001 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
2003 memset(&socket_retry, 0, sizeof(socket_retry));
2004 add_timer(&socket_retry, handle_retry, NULL, 0);
2006 /* open socket the first time */
2007 handle_retry(NULL, NULL, 0);
2009 ast_mutex_lock(&chan_lock);
2013 select_main(0, &global_change, lock_chan, unlock_chan);
2020 * new asterisk instance
2023 #ifdef AST_1_8_OR_HIGHER
2024 #if ASTERISK_VERSION_NUM < 100000
2025 struct ast_channel *lcr_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
2027 struct ast_channel *lcr_request(const char *type, struct ast_format_cap *format, const struct ast_channel *requestor, void *data, int *cause)
2030 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
2033 char exten[256], *dial, *interface, *opt;
2034 struct ast_channel *ast;
2035 struct chan_call *call;
2036 #ifdef AST_1_8_OR_HIGHER
2037 const struct ast_party_redirecting *req_redir;
2038 const struct ast_party_caller *req_caller;
2041 ast_mutex_lock(&chan_lock);
2042 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
2044 /* if socket is closed */
2046 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
2047 ast_mutex_unlock(&chan_lock);
2051 /* create call instance */
2052 call = alloc_call();
2054 /* failed to create instance */
2055 ast_mutex_unlock(&chan_lock);
2059 /* create asterisk channel instrance */
2061 #ifdef LCR_FOR_ASTERISK
2062 #ifdef AST_1_8_OR_HIGHER
2063 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, NULL, NULL, NULL, NULL, 0, "%s/%d", lcr_type, ++glob_channel);
2065 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
2069 #ifdef LCR_FOR_CALLWEAVER
2070 ast = ast_channel_alloc(1);
2074 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
2076 /* failed to create instance */
2077 ast_mutex_unlock(&chan_lock);
2080 #if ASTERISK_VERSION_NUM < 110000
2081 ast->tech = &lcr_tech;
2082 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
2083 #ifdef AST_1_8_OR_HIGHER
2084 req_redir = &requestor->redirecting;
2085 req_caller = &requestor->caller;
2088 ast_channel_tech_set(ast, &lcr_tech);
2089 ast_channel_tech_pvt_set(ast, (void *)1L); // set pointer or asterisk will not call
2090 req_redir = ast_channel_redirecting(requestor);
2091 req_caller = ast_channel_caller(requestor);
2093 /* configure channel */
2094 #if ASTERISK_VERSION_NUM < 100000
2095 #if ASTERISK_VERSION_NUM < 110000
2096 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2097 ast->readformat = ast->rawreadformat = ast->nativeformats;
2098 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
2100 ast_channel_nativeformats_set(ast, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
2101 ast->readformat = ast->rawreadformat = ast_channel_nativeformats(ast);
2102 ast->writeformat = ast->rawwriteformat = ast_channel_nativeformats(ast);
2105 #if ASTERISK_VERSION_NUM < 110000
2106 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2107 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
2108 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
2109 ast_set_write_format(ast, &ast->rawwriteformat);
2110 ast_set_read_format(ast, &ast->rawreadformat);
2112 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2113 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
2114 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
2115 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
2116 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
2119 #if ASTERISK_VERSION_NUM < 110000
2121 ast->hangupcause = 0;
2123 ast_channel_priority_set(ast, 1);
2124 ast_channel_hangupcause_set(ast, 0);
2129 #if ASTERISK_VERSION_NUM < 110000
2130 ast->tech_pvt = call;
2131 ast->fds[0] = call->pipe[0];
2133 ast_channel_tech_pvt_set(ast, call);
2134 ast_channel_set_fd(ast, 0, call->pipe[0]);
2136 call->pbx_started = 0;
2138 call->state = CHAN_LCR_STATE_OUT_PREPARE;
2141 * Extract interface, dialstring, options from data.
2144 * <interface>/<dialstring>
2145 * <interface>/<dialstring>/options
2147 strncpy(exten, (char *)data, sizeof(exten)-1);
2148 exten[sizeof(exten)-1] = '\0';
2149 if ((dial = strchr(exten, '/'))) {
2152 if ((opt = strchr(dial, '/')))
2161 strncpy(call->interface, interface, sizeof(call->interface)-1);
2162 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
2163 apply_opt(call, (char *)opt);
2165 #ifdef AST_1_8_OR_HIGHER
2166 // clone_variables(requestor, ast);
2169 ast->caller.ani.number.valid= req_caller->ani.number.valid;
2170 if (req_caller->ani.number.valid)
2171 if (req_caller->ani.number.str)
2172 if (req_caller->ani.number.str[0])
2173 ast->caller.ani.number.str= strdup(req_caller->ani.number.str);
2174 ast->caller.ani.number.plan= req_caller->ani.number.plan;
2175 ast->caller.ani.number.presentation= req_caller->ani.number.presentation;
2177 ast->caller.ani.name.valid= req_caller->ani.name.valid;
2178 if (req_caller->ani.name.valid)
2179 if (req_caller->ani.name.str)
2180 if (req_caller->ani.name.str[0])
2181 ast->caller.ani.name.str= strdup(req_caller->ani.name.str);
2182 ast->caller.ani.name.presentation= req_caller->ani.name.presentation;
2184 ast->caller.ani.subaddress.valid= req_caller->ani.subaddress.valid;
2185 if (req_caller->ani.subaddress.valid)
2186 if (req_caller->ani.subaddress.str)
2187 if (req_caller->ani.subaddress.str[0])
2188 ast->caller.ani.subaddress.str= strdup(req_caller->ani.subaddress.str);
2189 ast->caller.ani.subaddress.type= req_caller->ani.subaddress.type;
2191 ast->caller.id.number.valid= req_caller->id.number.valid;
2192 if (req_caller->id.number.valid)
2193 if (req_caller->id.number.str)
2194 if (req_caller->id.number.str[0])
2195 ast->caller.id.number.str= strdup(req_caller->id.number.str);
2196 ast->caller.id.number.plan= req_caller->id.number.plan;
2197 ast->caller.id.number.presentation= req_caller->id.number.presentation;
2199 ast->caller.id.name.valid= req_caller->id.name.valid;
2200 if (req_caller->id.name.valid)
2201 if (req_caller->id.name.str)
2202 if (req_caller->id.name.str[0])
2203 ast->caller.id.name.str= strdup(req_caller->id.name.str);
2204 ast->caller.id.name.presentation= req_caller->id.name.presentation;
2206 ast->caller.id.subaddress.valid= req_caller->id.subaddress.valid;
2207 if (req_caller->id.subaddress.valid)
2208 if (req_caller->id.subaddress.str)
2209 if (req_caller->id.subaddress.str[0])
2210 ast->caller.id.subaddress.str= strdup(req_caller->id.subaddress.str);
2211 ast->caller.id.subaddress.type= req_caller->id.subaddress.type;
2213 if (requestor->dialed.number.str)
2214 if (requestor->dialed.number.str[0])
2215 ast->dialed.number.str= strdup(requestor->dialed.number.str);
2216 ast->dialed.number.plan= requestor->dialed.number.plan;
2218 ast->dialed.subaddress.valid= requestor->dialed.subaddress.valid;
2219 if (requestor->dialed.subaddress.valid)
2220 if (requestor->dialed.subaddress.str)
2221 if (requestor->dialed.subaddress.str[0])
2222 ast->dialed.subaddress.str= strdup(requestor->dialed.subaddress.str);
2223 ast->dialed.subaddress.type= requestor->dialed.subaddress.type;
2225 ast->dialed.transit_network_select= requestor->dialed.transit_network_select;
2226 ast->redirecting.count= req_redir->count;
2227 ast->redirecting.reason= req_redir->reason;
2229 ast->redirecting.from.number.valid= req_redir->from.number.valid;
2230 if (req_redir->from.number.valid)
2231 if (req_redir->from.number.str)
2232 if (req_redir->from.number.str[0])
2233 ast->redirecting.from.number.str= strdup(req_redir->from.number.str);
2234 ast->redirecting.from.number.plan= req_redir->from.number.plan;
2235 ast->redirecting.from.number.presentation= req_redir->from.number.presentation;
2237 ast->redirecting.to.number.valid= req_redir->to.number.valid;
2238 if (req_redir->to.number.valid)
2239 if (req_redir->to.number.str)
2240 if (req_redir->to.number.str[0])
2241 ast->redirecting.to.number.str= strdup(req_redir->to.number.str);
2242 ast->redirecting.to.number.plan= req_redir->to.number.plan;
2243 ast->redirecting.to.number.presentation= req_redir->to.number.presentation;
2245 /* store call information for setup */
2248 if (requestor && req_caller->id.number.valid) {
2249 if (req_caller->id.number.str)
2250 strncpy(call->callerinfo.id, req_caller->id.number.str, sizeof(call->callerinfo.id)-1);
2251 switch(req_caller->id.number.presentation & AST_PRES_RESTRICTION) {
2252 case AST_PRES_RESTRICTED:
2253 call->callerinfo.present = INFO_PRESENT_RESTRICTED;
2255 case AST_PRES_UNAVAILABLE:
2256 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2258 case AST_PRES_ALLOWED:
2260 call->callerinfo.present = INFO_PRESENT_ALLOWED;
2262 switch(req_caller->id.number.presentation & AST_PRES_NUMBER_TYPE) {
2263 case AST_PRES_USER_NUMBER_UNSCREENED:
2264 call->callerinfo.screen = INFO_SCREEN_USER;
2266 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2267 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2269 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2270 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2273 call->callerinfo.screen = INFO_SCREEN_NETWORK;
2275 switch((req_caller->id.number.plan >> 4) & 7) {
2277 call->callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2280 call->callerinfo.ntype = INFO_NTYPE_NATIONAL;
2283 call->callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2286 call->callerinfo.ntype = INFO_NTYPE_UNKNOWN;
2289 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2292 if (requestor && req_caller->ani.number.valid) {
2293 if (req_caller->ani.number.str)
2294 strncpy(call->callerinfo.id2, req_caller->ani.number.str, sizeof(call->callerinfo.id2)-1);
2295 switch(req_caller->ani.number.presentation & AST_PRES_RESTRICTION) {
2296 case AST_PRES_RESTRICTED:
2297 call->callerinfo.present2 = INFO_PRESENT_RESTRICTED;
2299 case AST_PRES_UNAVAILABLE:
2300 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2302 case AST_PRES_ALLOWED:
2304 call->callerinfo.present2 = INFO_PRESENT_ALLOWED;
2306 switch(req_caller->ani.number.presentation & AST_PRES_NUMBER_TYPE) {
2307 case AST_PRES_USER_NUMBER_UNSCREENED:
2308 call->callerinfo.screen2 = INFO_SCREEN_USER;
2310 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2311 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_PASSED;
2313 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2314 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_FAILED;
2317 call->callerinfo.screen2 = INFO_SCREEN_NETWORK;
2319 switch((req_caller->ani.number.plan >> 4) & 7) {
2321 call->callerinfo.ntype2 = INFO_NTYPE_SUBSCRIBER;
2324 call->callerinfo.ntype2 = INFO_NTYPE_NATIONAL;
2327 call->callerinfo.ntype2 = INFO_NTYPE_INTERNATIONAL;
2330 call->callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
2333 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2336 if (requestor && req_caller->id.name.valid) {
2337 if (req_caller->id.name.str)
2338 strncpy(call->callerinfo.name, req_caller->id.name.str, sizeof(call->callerinfo.name)-1);
2342 if (requestor && req_redir->from.number.valid) {
2343 call->redirinfo.itype = INFO_ITYPE_CHAN;
2344 if (req_redir->from.number.str)
2345 strncpy(call->redirinfo.id, req_redir->from.number.str, sizeof(call->redirinfo.id)-1);
2346 switch(req_redir->from.number.presentation & AST_PRES_RESTRICTION) {
2347 case AST_PRES_RESTRICTED:
2348 call->redirinfo.present = INFO_PRESENT_RESTRICTED;
2350 case AST_PRES_UNAVAILABLE:
2351 call->redirinfo.present = INFO_PRESENT_NOTAVAIL;
2353 case AST_PRES_ALLOWED:
2355 call->redirinfo.present = INFO_PRESENT_ALLOWED;
2357 switch(req_redir->from.number.presentation & AST_PRES_NUMBER_TYPE) {
2358 case AST_PRES_USER_NUMBER_UNSCREENED:
2359 call->redirinfo.screen = INFO_SCREEN_USER;
2361 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2362 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2364 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2365 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2368 call->redirinfo.screen = INFO_SCREEN_NETWORK;
2370 switch((req_redir->from.number.plan >> 4) & 7) {
2372 call->redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2375 call->redirinfo.ntype = INFO_NTYPE_NATIONAL;
2378 call->redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2381 call->redirinfo.ntype = INFO_NTYPE_UNKNOWN;
2386 ast_mutex_unlock(&chan_lock);
2391 * call from asterisk
2393 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
2395 union parameter newparam;
2396 struct chan_call *call;
2397 #if ASTERISK_VERSION_NUM >= 110000
2398 int transfercapability;
2401 ast_mutex_lock(&chan_lock);
2402 #if ASTERISK_VERSION_NUM < 110000
2403 call = ast->tech_pvt;
2405 call = ast_channel_tech_pvt(ast);
2408 #ifdef LCR_FOR_CALLWEAVER
2410 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type, call->dialstring, ast_random() & 0xffff);
2414 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
2415 ast_mutex_unlock(&chan_lock);
2419 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
2421 /* pbx process is started */
2422 call->pbx_started = 1;
2423 /* send MESSAGE_NEWREF */
2424 memset(&newparam, 0, sizeof(union parameter));
2425 newparam.newref.direction = 0; /* request from app */
2426 strncpy(newparam.newref.interface, call->interface, sizeof(newparam.newref.interface) - 1);
2427 send_message(MESSAGE_NEWREF, 0, &newparam);
2429 /* set hdlc if capability requires hdlc */
2430 #if ASTERISK_VERSION_NUM < 110000
2431 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
2432 || ast->transfercapability == INFO_BC_DATARESTRICTED
2433 || ast->transfercapability == INFO_BC_VIDEO)
2435 transfercapability=ast_channel_transfercapability(ast);
2436 if (transfercapability == INFO_BC_DATAUNRESTRICTED
2437 || transfercapability == INFO_BC_DATARESTRICTED
2438 || transfercapability == INFO_BC_VIDEO)
2441 /* if hdlc is forced by option, we change transcap to data */
2443 #if ASTERISK_VERSION_NUM < 110000
2444 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
2445 && ast->transfercapability != INFO_BC_DATARESTRICTED
2446 && ast->transfercapability != INFO_BC_VIDEO)
2447 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
2449 && transfercapability != INFO_BC_DATAUNRESTRICTED
2450 && transfercapability != INFO_BC_DATARESTRICTED
2451 && transfercapability != INFO_BC_VIDEO)
2452 transfercapability = INFO_BC_DATAUNRESTRICTED;
2455 #ifndef AST_1_8_OR_HIGHER
2456 call->cid_num[0] = 0;
2457 call->cid_name[0] = 0;
2458 call->cid_rdnis[0] = 0;
2460 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
2461 strncpy(call->cid_num, ast->cid.cid_num,
2462 sizeof(call->cid_num)-1);
2463 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
2464 strncpy(call->cid_name, ast->cid.cid_name,
2465 sizeof(call->cid_name)-1);
2466 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
2467 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
2468 sizeof(call->cid_rdnis)-1);
2471 ast_mutex_unlock(&chan_lock);
2475 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2477 static const char* dtmf_tones[] = {
2478 "!941+1336/100,!0/100", /* 0 */
2479 "!697+1209/100,!0/100", /* 1 */
2480 "!697+1336/100,!0/100", /* 2 */
2481 "!697+1477/100,!0/100", /* 3 */
2482 "!770+1209/100,!0/100", /* 4 */
2483 "!770+1336/100,!0/100", /* 5 */
2484 "!770+1477/100,!0/100", /* 6 */
2485 "!852+1209/100,!0/100", /* 7 */
2486 "!852+1336/100,!0/100", /* 8 */
2487 "!852+1477/100,!0/100", /* 9 */
2488 "!697+1633/100,!0/100", /* A */
2489 "!770+1633/100,!0/100", /* B */
2490 "!852+1633/100,!0/100", /* C */
2491 "!941+1633/100,!0/100", /* D */
2492 "!941+1209/100,!0/100", /* * */
2493 "!941+1477/100,!0/100" }; /* # */
2495 if (digit >= '0' && digit <='9')
2496 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2497 else if (digit >= 'A' && digit <= 'D')
2498 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2499 else if (digit == '*')
2500 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2501 else if (digit == '#')
2502 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2504 #if ASTERISK_VERSION_NUM < 110000
2505 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
2507 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
2512 #ifdef LCR_FOR_ASTERISK
2513 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2515 #ifdef LCR_FOR_CALLWEAVER
2516 static int lcr_digit(struct ast_channel *ast, char digit)
2519 struct chan_call *call;
2520 union parameter newparam;
2523 #ifdef LCR_FOR_CALLWEAVER
2524 int inband_dtmf = 0;
2527 /* only pass IA5 number space */
2528 if (digit > 126 || digit < 32)
2531 ast_mutex_lock(&chan_lock);
2532 #if ASTERISK_VERSION_NUM < 110000
2533 call = ast->tech_pvt;
2535 call = ast_channel_tech_pvt(ast);
2538 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2539 ast_mutex_unlock(&chan_lock);
2543 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2545 /* send information or queue them */
2546 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2547 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2548 memset(&newparam, 0, sizeof(union parameter));
2550 newparam.information.keypad[0] = digit;
2551 newparam.information.keypad[1] = '\0';
2553 newparam.information.id[0] = digit;
2554 newparam.information.id[1] = '\0';
2556 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2559 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2560 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2562 strncat(call->dialque, buf, strlen(call->dialque)-1);
2565 ast_mutex_unlock(&chan_lock);
2567 #ifdef LCR_FOR_ASTERISK
2571 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2573 int inband_dtmf = 0;
2574 struct chan_call *call;
2577 ast_mutex_lock(&chan_lock);
2579 #if ASTERISK_VERSION_NUM < 110000
2580 call = ast->tech_pvt;
2582 call = ast_channel_tech_pvt(ast);
2587 "Received digit from Asterisk, "
2588 "but no call instance exists.\n");
2589 ast_mutex_unlock(&chan_lock);
2593 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2595 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2599 ast_mutex_unlock(&chan_lock);
2602 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2603 send_digit_to_chan(ast, digit);
2609 static int lcr_answer(struct ast_channel *ast)
2611 union parameter newparam;
2612 struct chan_call *call;
2614 ast_mutex_lock(&chan_lock);
2615 #if ASTERISK_VERSION_NUM < 110000
2616 call = ast->tech_pvt;
2618 call = ast_channel_tech_pvt(ast);
2621 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2622 ast_mutex_unlock(&chan_lock);
2626 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2628 /* copy connectinfo, if bridged */
2629 if (call->bridge_call)
2630 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2631 /* send connect message to lcr */
2632 if (call->state != CHAN_LCR_STATE_CONNECT) {
2633 memset(&newparam, 0, sizeof(union parameter));
2634 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2635 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2636 call->state = CHAN_LCR_STATE_CONNECT;
2640 // memset(&newparam, 0, sizeof(union parameter));
2641 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2643 ast_mutex_unlock(&chan_lock);
2647 static int lcr_hangup(struct ast_channel *ast)
2649 struct chan_call *call;
2650 pthread_t tid = pthread_self();
2652 if (!pthread_equal(tid, chan_tid)) {
2653 ast_mutex_lock(&chan_lock);
2655 #if ASTERISK_VERSION_NUM < 110000
2656 call = ast->tech_pvt;
2658 call = ast_channel_tech_pvt(ast);
2661 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2662 if (!pthread_equal(tid, chan_tid)) {
2663 ast_mutex_unlock(&chan_lock);
2668 if (!pthread_equal(tid, chan_tid))
2669 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2671 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2673 /* disconnect asterisk, maybe not required */
2674 #if ASTERISK_VERSION_NUM < 110000
2675 ast->tech_pvt = NULL;
2678 ast_channel_tech_pvt_set(ast, NULL);
2679 ast_channel_set_fd(ast, 0, -1);
2683 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2684 #if ASTERISK_VERSION_NUM < 110000
2685 if (ast->hangupcause > 0)
2686 send_release(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2688 if (ast_channel_hangupcause(ast) > 0)
2689 send_release(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
2692 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2695 if (!pthread_equal(tid, chan_tid)) {
2696 ast_mutex_unlock(&chan_lock);
2700 /* ref is not set, due to prepare setup or release */
2701 if (call->state == CHAN_LCR_STATE_RELEASE) {
2702 /* we get the response to our release */
2703 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2706 /* during prepare, we change to release state */
2707 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2708 call->state = CHAN_LCR_STATE_RELEASE;
2712 if (!pthread_equal(tid, chan_tid)) {
2713 ast_mutex_unlock(&chan_lock);
2718 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2720 union parameter newparam;
2721 struct chan_call *call;
2722 struct ast_frame * f = fr;
2723 unsigned char *p, *q;
2726 #if ASTERISK_VERSION_NUM < 100000
2727 #ifdef AST_1_8_OR_HIGHER
2728 if (!f->subclass.codec)
2732 CDEBUG(NULL, ast, "No subclass\n");
2734 #ifdef AST_1_8_OR_HIGHER
2735 #if ASTERISK_VERSION_NUM < 100000
2736 #if ASTERISK_VERSION_NUM < 110000
2737 if (!(f->subclass.codec & ast->nativeformats)) {
2739 if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
2742 #if ASTERISK_VERSION_NUM < 110000
2743 if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
2745 if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
2749 #if ASTERISK_VERSION_NUM < 110000
2750 if (!(f->subclass & ast->nativeformats)) {
2752 if (!(f->subclass & ast_channel_nativeformats(ast))) {
2756 "Unexpected format. "
2757 "Activating emergency conversion...\n");
2759 #ifdef AST_1_8_OR_HIGHER
2760 #if ASTERISK_VERSION_NUM < 100000
2761 ast_set_write_format(ast, f->subclass.codec);
2763 ast_set_write_format(ast, &f->subclass.format);
2766 ast_set_write_format(ast, f->subclass);
2768 #if ASTERISK_VERSION_NUM < 110000
2769 f = (ast->writetrans) ? ast_translate(
2770 ast->writetrans, fr, 0) : fr;
2772 f = (ast_channel_writetrans(ast)) ? ast_translate(
2773 ast_channel_writetrans(ast), fr, 0) : fr;
2777 ast_mutex_lock(&chan_lock);
2778 #if ASTERISK_VERSION_NUM < 110000
2779 call = ast->tech_pvt;
2781 call = ast_channel_tech_pvt(ast);
2783 if (!call || !call->ref) {
2784 /* drop the frame, if no ref exists, but return successfull delivery, or asterisk will abort connection */
2785 ast_mutex_unlock(&chan_lock);
2792 p = *((unsigned char **)&(f->data));
2793 q = newparam.traffic.data;
2794 memset(&newparam, 0, sizeof(union parameter));
2796 l = (len > sizeof(newparam.traffic.data)) ? sizeof(newparam.traffic.data) : len;
2797 newparam.traffic.len = l;
2800 *q++ = flip_bits[*p++];
2801 send_message(MESSAGE_TRAFFIC, call->ref, &newparam);
2803 ast_mutex_unlock(&chan_lock);
2811 static struct ast_frame *lcr_read(struct ast_channel *ast)
2813 struct chan_call *call;
2815 struct ast_frame *f = NULL;
2817 ast_mutex_lock(&chan_lock);
2818 #if ASTERISK_VERSION_NUM < 110000
2819 call = ast->tech_pvt;
2821 call = ast_channel_tech_pvt(ast);
2824 ast_mutex_unlock(&chan_lock);
2827 if (call->pipe[0] > -1) {
2828 if (call->rebuffer && !call->hdlc) {
2829 /* Make sure we have a complete 20ms (160byte) frame */
2830 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2832 call->framepos += len;
2835 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2837 if (len < 0 && errno == EAGAIN) {
2838 ast_mutex_unlock(&chan_lock);
2840 #ifdef LCR_FOR_ASTERISK
2841 return &ast_null_frame;
2844 #ifdef LCR_FOR_CALLWEAVER
2850 close(call->pipe[0]);
2853 ast_mutex_unlock(&chan_lock);
2855 } else if (call->rebuffer && call->framepos < 160) {
2856 /* Not a complete frame, so we send a null-frame */
2857 ast_mutex_unlock(&chan_lock);
2858 return &ast_null_frame;
2862 call->read_fr.frametype = AST_FRAME_VOICE;
2863 #ifdef AST_1_8_OR_HIGHER
2864 #if ASTERISK_VERSION_NUM < 100000
2865 #if ASTERISK_VERSION_NUM < 110000
2866 call->read_fr.subclass.codec = ast->nativeformats;
2868 call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
2871 #if ASTERISK_VERSION_NUM < 110000
2872 ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
2874 ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
2876 call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
2879 #if ASTERISK_VERSION_NUM < 110000
2880 call->read_fr.subclass = ast->nativeformats;
2882 call->read_fr.subclass = ast_channel_nativeformats(ast);
2885 if (call->rebuffer) {
2886 call->read_fr.datalen = call->framepos;
2887 call->read_fr.samples = call->framepos;
2890 call->read_fr.datalen = len;
2891 call->read_fr.samples = len;
2893 call->read_fr.delivery = ast_tv(0,0);
2894 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2897 f = ast_dsp_process(ast, call->dsp, &call->read_fr);
2898 if (f && f->frametype == AST_FRAME_DTMF)
2899 CDEBUG(call, ast, "Asterisk detected inband DTMF: %c.\n", f->subclass.integer);
2901 ast_mutex_unlock(&chan_lock);
2903 if (f && f->frametype == AST_FRAME_DTMF)
2906 return &call->read_fr;
2909 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2911 union parameter newparam;
2913 struct chan_call *call;
2914 const struct ast_tone_zone_sound *ts = NULL;
2916 ast_mutex_lock(&chan_lock);
2917 #if ASTERISK_VERSION_NUM < 110000
2918 call = ast->tech_pvt;
2920 call = ast_channel_tech_pvt(ast);
2923 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2924 ast_mutex_unlock(&chan_lock);
2929 case AST_CONTROL_BUSY:
2930 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2931 ast_setstate(ast, AST_STATE_BUSY);
2932 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2933 /* send message to lcr */
2934 memset(&newparam, 0, sizeof(union parameter));
2935 newparam.disconnectinfo.cause = 17;
2936 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2937 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2939 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2941 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2942 #if ASTERISK_VERSION_NUM < 110000
2943 ts = ast_get_indication_tone(ast->zone, "busy");
2945 ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
2949 case AST_CONTROL_CONGESTION:
2950 #if ASTERISK_VERSION_NUM < 110000
2951 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2953 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
2955 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2956 /* send message to lcr */
2957 memset(&newparam, 0, sizeof(union parameter));
2958 #if ASTERISK_VERSION_NUM < 110000
2959 newparam.disconnectinfo.cause = ast->hangupcause;
2961 newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
2963 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2964 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2966 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2968 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2969 #if ASTERISK_VERSION_NUM < 110000
2970 ts = ast_get_indication_tone(ast->zone, "congestion");
2972 ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
2976 case AST_CONTROL_PROCEEDING:
2977 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2978 if (call->state == CHAN_LCR_STATE_IN_SETUP
2979 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2980 /* send message to lcr */
2981 memset(&newparam, 0, sizeof(union parameter));
2982 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2984 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2987 case AST_CONTROL_RINGING:
2988 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2989 ast_setstate(ast, AST_STATE_RING);
2990 if (call->state == CHAN_LCR_STATE_IN_SETUP
2991 || call->state == CHAN_LCR_STATE_IN_DIALING
2992 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2993 /* send message to lcr */
2994 memset(&newparam, 0, sizeof(union parameter));
2995 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2997 call->state = CHAN_LCR_STATE_IN_ALERTING;
2999 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
3000 #if ASTERISK_VERSION_NUM < 110000
3001 ts = ast_get_indication_tone(ast->zone, "ring");
3003 ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
3007 case AST_CONTROL_PROGRESS:
3008 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
3009 /* request bchannel */
3010 CDEBUG(call, ast, "Requesting audio path.\n");
3011 memset(&newparam, 0, sizeof(union parameter));
3012 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
3015 CDEBUG(call, ast, "Received indicate -1.\n");
3016 ast_playtones_stop(ast);
3020 case AST_CONTROL_VIDUPDATE:
3021 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
3024 case AST_CONTROL_HOLD:
3025 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
3026 /* send message to lcr */
3027 memset(&newparam, 0, sizeof(union parameter));
3028 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
3029 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3031 /*start music onhold*/
3032 #ifdef LCR_FOR_ASTERISK
3033 #if ASTERISK_VERSION_NUM <110000
3034 ast_moh_start(ast,data,ast->musicclass);
3036 ast_moh_start(ast,data,ast_channel_musicclass(ast));
3040 #ifdef LCR_FOR_CALLWEAVER
3041 ast_moh_start(ast, NULL);
3046 case AST_CONTROL_UNHOLD:
3047 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
3048 /* send message to lcr */
3049 memset(&newparam, 0, sizeof(union parameter));
3050 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3051 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3057 #ifdef AST_CONTROL_SRCUPDATE
3058 case AST_CONTROL_SRCUPDATE:
3062 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
3065 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
3070 if (ts && ts->data[0]) {
3071 ast_playtones_start(ast, 0, ts->data, 1);
3075 ast_mutex_unlock(&chan_lock);
3082 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
3084 struct chan_call *call;
3090 ast_mutex_lock(&chan_lock);
3091 #if ASTERISK_VERSION_NUM < 110000
3092 call = ast->tech_pvt;
3094 call = ast_channel_tech_pvt(ast);
3097 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
3098 ast_mutex_unlock(&chan_lock);
3102 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
3104 ast_mutex_unlock(&chan_lock);
3109 * send_text asterisk
3111 static int lcr_send_text(struct ast_channel *ast, const char *text)
3113 struct chan_call *call;
3114 union parameter newparam;
3116 ast_mutex_lock(&chan_lock);
3117 #if ASTERISK_VERSION_NUM < 110000
3118 call = ast->tech_pvt;
3120 call = ast_channel_tech_pvt(ast);
3123 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
3124 ast_mutex_unlock(&chan_lock);
3128 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
3129 memset(&newparam, 0, sizeof(union parameter));
3130 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
3131 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3132 ast_mutex_unlock(&chan_lock);
3139 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
3140 struct ast_channel *ast2, int flags,
3141 struct ast_frame **fo,
3142 struct ast_channel **rc, int timeoutms)
3145 struct chan_call *call1, *call2;
3146 struct ast_channel *carr[2], *who;
3148 struct ast_frame *f;
3151 /* bridge is disabled, because there is currerntly no concept to bridge mISDN channels */
3152 return AST_BRIDGE_FAILED;
3154 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
3159 /* join via dsp (if the channels are currently open) */
3160 ast_mutex_lock(&chan_lock);
3161 #if ASTERISK_VERSION_NUM < 110000
3162 call1 = ast1->tech_pvt;
3163 call2 = ast2->tech_pvt;
3165 call1 = ast_channel_tech_pvt(ast1);
3166 call2 = ast_channel_tech_pvt(ast2);
3168 if (!call1 || !call2) {
3169 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
3170 ast_mutex_unlock(&chan_lock);
3171 return AST_BRIDGE_COMPLETE;
3174 /* join, if both call instances uses dsp
3175 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
3177 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
3179 /* get bridge id and join */
3180 bridge_id = new_bridge_id();
3182 call1->bridge_id = bridge_id;
3183 call2->bridge_id = bridge_id;
3184 // FIXME: do bridiging
3185 // bchannel_join(call1->bchannel, bridge_id);
3186 // bchannel_join(call2->bchannel, bridge_id);
3188 call1->bridge_call = call2;
3189 call2->bridge_call = call1;
3191 if (call1->state == CHAN_LCR_STATE_IN_SETUP
3192 || call1->state == CHAN_LCR_STATE_IN_DIALING
3193 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
3194 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
3195 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3198 if (call2->state == CHAN_LCR_STATE_IN_SETUP
3199 || call2->state == CHAN_LCR_STATE_IN_DIALING
3200 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
3201 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
3202 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3206 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
3207 so let's do it for them. Hmpf.
3210 if (call1->on_hold) {
3211 union parameter newparam;
3213 memset(&newparam, 0, sizeof(union parameter));
3214 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3215 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
3220 if (call2->on_hold) {
3221 union parameter newparam;
3223 memset(&newparam, 0, sizeof(union parameter));
3224 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3225 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
3230 ast_mutex_unlock(&chan_lock);
3234 who = ast_waitfor_n(carr, 2, &to);
3237 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
3242 if (!f || f->frametype == AST_FRAME_CONTROL) {
3244 CDEBUG(NULL, NULL, "Got hangup.\n");
3246 CDEBUG(NULL, NULL, "Got CONTROL.\n");
3253 if ( f->frametype == AST_FRAME_DTMF ) {
3254 CDEBUG(NULL, NULL, "Got DTMF.\n");
3270 CDEBUG(NULL, NULL, "Releasing bridge.\n");
3272 /* split channels */
3273 ast_mutex_lock(&chan_lock);
3274 #if ASTERISK_VERSION_NUM < 110000
3275 call1 = ast1->tech_pvt;
3276 call2 = ast2->tech_pvt;
3278 call1 = ast_channel_tech_pvt(ast1);
3279 call2 = ast_channel_tech_pvt(ast2);
3281 if (call1 && call1->bridge_id) {
3282 call1->bridge_id = 0;
3283 if (call1->bridge_call)
3284 call1->bridge_call->bridge_call = NULL;
3286 if (call2 && call1->bridge_id) {
3287 call2->bridge_id = 0;
3288 if (call2->bridge_call)
3289 call2->bridge_call->bridge_call = NULL;
3291 call1->bridge_call = NULL;
3292 call2->bridge_call = NULL;
3294 ast_mutex_unlock(&chan_lock);
3295 return AST_BRIDGE_COMPLETE;
3297 static struct ast_channel_tech lcr_tech = {
3299 .description = "Channel driver for connecting to Linux-Call-Router",
3300 #if ASTERISK_VERSION_NUM < 100000
3301 .capabilities = AST_FORMAT_ALAW,
3303 .requester = lcr_request,
3305 #ifdef LCR_FOR_ASTERISK
3306 .send_digit_begin = lcr_digit_begin,
3307 .send_digit_end = lcr_digit_end,
3310 #ifdef LCR_FOR_CALLWEAVER
3311 .send_digit = lcr_digit,
3315 .bridge = lcr_bridge,
3316 .hangup = lcr_hangup,
3317 .answer = lcr_answer,
3320 .indicate = lcr_indicate,
3322 .send_text = lcr_send_text,
3331 static int lcr_show_lcr (int fd, int argc, char *argv[])
3336 static int lcr_show_calls (int fd, int argc, char *argv[])
3341 static int lcr_reload_routing (int fd, int argc, char *argv[])
3346 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
3351 static int lcr_port_block (int fd, int argc, char *argv[])
3356 static int lcr_port_unblock (int fd, int argc, char *argv[])
3361 static int lcr_port_unload (int fd, int argc, char *argv[])
3366 static struct ast_cli_entry cli_show_lcr =
3367 { {"lcr", "show", "lcr", NULL},
3369 "Shows current states of LCR core",
3370 "Usage: lcr show lcr\n",
3373 static struct ast_cli_entry cli_show_calls =
3374 { {"lcr", "show", "calls", NULL},
3376 "Shows current calls made by LCR and Asterisk",
3377 "Usage: lcr show calls\n",
3380 static struct ast_cli_entry cli_reload_routing =
3381 { {"lcr", "reload", "routing", NULL},
3383 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
3384 "Usage: lcr reload routing\n",
3387 static struct ast_cli_entry cli_reload_interfaces =
3388 { {"lcr", "reload", "interfaces", NULL},
3389 lcr_reload_interfaces,
3390 "Reloads interfaces conf of LCR",
3391 "Usage: lcr reload interfaces\n",
3394 static struct ast_cli_entry cli_port_block =
3395 { {"lcr", "port", "block", NULL},
3397 "Blocks LCR port for further calls",
3398 "Usage: lcr port block \"<port>\"\n",
3401 static struct ast_cli_entry cli_port_unblock =
3402 { {"lcr", "port", "unblock", NULL},
3404 "Unblocks or loads LCR port, port is opened my mISDN",
3405 "Usage: lcr port unblock \"<port>\"\n",
3408 static struct ast_cli_entry cli_port_unload =
3409 { {"lcr", "port", "unload", NULL},
3411 "Unloads LCR port, port is closes by mISDN",
3412 "Usage: lcr port unload \"<port>\"\n",
3417 #ifdef LCR_FOR_ASTERISK
3418 #ifdef AST_1_8_OR_HIGHER
3419 static int lcr_config_exec(struct ast_channel *ast, const char *data)
3421 static int lcr_config_exec(struct ast_channel *ast, void *data)
3425 #ifdef LCR_FOR_CALLWEAVER
3426 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
3429 struct chan_call *call;
3431 ast_mutex_lock(&chan_lock);
3433 #ifdef LCR_FOR_ASTERISK
3434 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
3437 #ifdef LCR_FOR_CALLWEAVER
3438 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
3444 if (call->ast == ast)
3450 #ifdef LCR_FOR_ASTERISK
3451 apply_opt(call, (char *)data);
3454 #ifdef LCR_FOR_CALLWEAVER
3455 apply_opt(call, (char *)argv[0]);
3459 if (call->tx_queue) {
3460 union parameter newparam;
3462 memset(&newparam, 0, sizeof(union parameter));
3463 newparam.queue = call->tx_queue * 8;
3464 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
3467 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
3469 ast_mutex_unlock(&chan_lock);
3474 * module loading and destruction
3476 int load_module(void)
3479 char options_error[256];
3481 for (i = 0; i < 256; i++) {
3482 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
3483 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
3486 if (read_options(options_error) == 0) {
3487 CERROR(NULL, NULL, "%s", options_error);
3489 #ifdef LCR_FOR_ASTERISK
3490 return AST_MODULE_LOAD_DECLINE;
3493 #ifdef LCR_FOR_CALLWEAVER
3499 ast_mutex_init(&chan_lock);
3500 ast_mutex_init(&log_lock);
3502 #if ASTERISK_VERSION_NUM < 100000
3503 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
3505 struct ast_format tmp;
3506 ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
3507 if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
3508 return AST_MODULE_LOAD_DECLINE;
3510 ast_format_cap_add(lcr_tech.capabilities, &tmp);
3512 if (ast_channel_register(&lcr_tech)) {
3513 CERROR(NULL, NULL, "Unable to register channel class\n");
3516 #ifdef LCR_FOR_ASTERISK
3517 return AST_MODULE_LOAD_DECLINE;
3520 #ifdef LCR_FOR_CALLWEAVER
3525 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
3527 #ifdef LCR_FOR_ASTERISK
3528 "lcr_config(<opt><optarg>:<opt>:...)\n"
3531 #ifdef LCR_FOR_CALLWEAVER
3532 "lcr_config(<opt><optarg>:<opt>:...)\n",
3535 "Sets LCR opts. and optargs\n"
3537 "The available options are:\n"
3538 " d - Send display text on called phone, text is the optarg.\n"
3539 " n - Don't detect dtmf tones from LCR.\n"
3540 " h - Force data call (HDLC).\n"
3541 " q - Add queue to make fax stream seamless (required for fax app).\n"
3542 " Use queue size in miliseconds for optarg. (try 250)\n"
3543 " a - Adding DTMF detection.\n"
3544 " f - Adding fax detection.\n"
3546 " c - Make crypted outgoing call, optarg is keyindex.\n"
3547 " e - Perform echo cancelation on this channel.\n"
3549 " Takes mISDN pipeline option as optarg.\n"
3550 " s - Send Non Inband DTMF as inband. (disables LCR's DTMF)\n"
3551 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
3553 " vr - rxgain control\n"
3554 " vt - txgain control\n"
3556 " Volume changes at factor 2 ^ optarg.\n"
3557 " k - use keypad to dial this call.\n"
3559 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
3560 " -> use 16 for fax (3.1k audio)\n"
3562 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
3563 "options: \"n:t:q250\" for seamless audio transmission.\n"
3568 ast_cli_register(&cli_show_lcr);
3569 ast_cli_register(&cli_show_calls);
3570 ast_cli_register(&cli_reload_routing);
3571 ast_cli_register(&cli_reload_interfaces);
3572 ast_cli_register(&cli_port_block);
3573 ast_cli_register(&cli_port_unblock);
3574 ast_cli_register(&cli_port_unload);
3577 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
3578 /* failed to create thread */
3580 ast_channel_unregister(&lcr_tech);
3582 #ifdef LCR_FOR_ASTERISK
3583 return AST_MODULE_LOAD_DECLINE;
3586 #ifdef LCR_FOR_CALLWEAVER
3594 int unload_module(void)
3596 /* First, take us out of the channel loop */
3597 CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
3599 pthread_cancel(chan_tid);
3603 del_timer(&socket_retry);
3605 unregister_fd(&wake_fd);
3606 close(wake_pipe[0]);
3607 close(wake_pipe[1]);
3609 // ast_mutex_unlock(&chan_lock);
3611 ast_channel_unregister(&lcr_tech);
3613 ast_unregister_application("lcr_config");
3615 if (lcr_sock >= 0) {
3620 #if ASTERISK_VERSION_NUM >= 100000
3621 lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
3626 int reload_module(void)
3632 #ifdef LCR_FOR_ASTERISK
3633 #define AST_MODULE "chan_lcr"
3636 #ifdef LCR_FOR_CALLWEAVER
3641 ast_mutex_lock(&usecnt_lock);
3643 ast_mutex_unlock(&usecnt_lock);
3648 #ifdef LCR_FOR_ASTERISK
3649 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3650 .load = load_module,
3651 .unload = unload_module,
3652 .reload = reload_module,
3656 #ifdef LCR_FOR_CALLWEAVER
3657 char *description(void)