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 parameter.\n", opt);
520 call->faxdetect=atoi(opt+1);
522 call->dsp=ast_dsp_new();
524 #ifdef LCR_FOR_CALLWEAVER
525 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
527 #ifdef LCR_FOR_ASTERISK
528 #ifdef DSP_FEATURE_DTMF_DETECT
529 ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
531 ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
536 #ifdef LCR_FOR_CALLWEAVER
537 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
539 #ifdef LCR_FOR_ASTERISK
540 #if ASTERISK_VERSION_NUM < 100000
541 call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
543 struct ast_format src;
544 struct ast_format dst;
545 ast_format_set(&dst, AST_FORMAT_SLINEAR, 0);
546 ast_format_set(&dst,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
547 call->trans=ast_translator_build_path(&dst, &src);
552 CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
555 if (opt[1] != '\0') {
556 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
559 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
564 if (opt[1] != '\0') {
565 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
568 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
569 call->inband_dtmf = 1;
573 if (opt[1] != 'r' && opt[1] != 't') {
574 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
578 if (gain < -8 || gain >8) {
579 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
582 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
584 call->rx_gain = gain;
586 bchannel_gain(call->bchannel, call->rx_gain, 0);
588 call->tx_gain = gain;
590 bchannel_gain(call->bchannel, call->tx_gain, 1);
595 if (opt[1] != '\0') {
596 CERROR(call, call->ast, "Option 'k' (keypad) expects no parameter.\n", opt);
599 CDEBUG(call, call->ast, "Option 'k' (keypad).\n");
604 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
610 * send setup info to LCR
611 * this function is called, when asterisk call is received and ref is received
613 static void send_setup_to_lcr(struct chan_call *call)
615 union parameter newparam;
616 struct ast_channel *ast = call->ast;
619 if (!call->ast || !call->ref)
622 #ifdef AST_1_8_OR_HIGHER
623 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->callerinfo.id);
625 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
628 /* send setup message to LCR */
629 memset(&newparam, 0, sizeof(union parameter));
630 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
631 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
633 strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
635 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
636 if (!!strcmp(call->interface, "pbx"))
637 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
638 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
639 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
640 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
641 call->display[0] = '\0';
643 #ifdef AST_1_8_OR_HIGHER
644 /* set stored call information */
645 memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
646 memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
648 if (call->cid_num[0])
649 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
650 if (call->cid_name[0])
651 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
652 if (call->cid_rdnis[0]) {
653 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
654 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
655 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
657 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
658 case AST_PRES_RESTRICTED:
659 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
661 case AST_PRES_UNAVAILABLE:
662 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
664 case AST_PRES_ALLOWED:
666 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
668 switch(ast->cid.cid_ton) {
670 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
673 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
676 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
679 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
682 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
683 // tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
685 #if ASTERISK_VERSION_NUM < 110000
686 // ast->transfercapability = atoi(tmp);
687 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
689 // ast_channel_transfercapability_set(ast, atoi(tmp));
690 newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
692 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
694 newparam.setup.capainfo.source_mode = B_MODE_HDLC;
696 newparam.setup.capainfo.source_mode = B_MODE_TRANSPARENT;
697 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
699 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
700 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
701 send_message(MESSAGE_SETUP, call->ref, &newparam);
702 if (call->tx_queue) {
703 memset(&newparam, 0, sizeof(union parameter));
704 newparam.queue = call->tx_queue * 8;
705 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
708 /* change to outgoing setup state */
709 call->state = CHAN_LCR_STATE_OUT_SETUP;
713 * send dialing info to LCR
714 * this function is called, when setup acknowledge is received and dialing
717 static void send_dialque_to_lcr(struct chan_call *call)
719 union parameter newparam;
721 if (!call->ast || !call->ref || !call->dialque[0])
724 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
726 /* send setup message to LCR */
727 memset(&newparam, 0, sizeof(union parameter));
729 strncpy(newparam.information.keypad, call->dialque, sizeof(newparam.information.keypad)-1);
731 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
732 call->dialque[0] = '\0';
733 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
737 * in case of a bridge, the unsupported message can be forwarded directly
738 * to the remote call.
740 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
744 if (!call->bridge_call) return;
745 CDEBUG(call, NULL, "Sending message due bridging.\n");
746 send_message(message_type, call->bridge_call->ref, param);
750 * send release message to LCR
752 static void send_release(struct chan_call *call, int cause, int location)
754 union parameter newparam;
756 /* sending release */
757 memset(&newparam, 0, sizeof(union parameter));
758 newparam.disconnectinfo.cause = cause;
759 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
760 send_message(MESSAGE_RELEASE, call->ref, &newparam);
764 * check if extension matches and start asterisk
765 * if it can match, proceed
768 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
771 union parameter newparam;
772 #if ASTERISK_VERSION_NUM < 110000
773 char *exten = ast->exten;
775 char s_exten[AST_MAX_EXTENSION];
778 strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
784 #if ASTERISK_VERSION_NUM < 110000
785 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
787 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
792 #if ASTERISK_VERSION_NUM < 110000
793 if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
794 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
796 if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
797 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
802 #if ASTERISK_VERSION_NUM < 110000
803 if (!ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
804 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);
806 if (!ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
807 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));
812 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
813 /* send setup acknowledge to lcr */
814 memset(&newparam, 0, sizeof(union parameter));
815 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
818 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
823 #if ASTERISK_VERSION_NUM < 110000
824 if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
826 if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
828 /* send setup acknowledge to lcr */
829 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
830 memset(&newparam, 0, sizeof(union parameter));
831 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
835 call->state = CHAN_LCR_STATE_IN_DIALING;
837 /* if match, start pbx */
838 #if ASTERISK_VERSION_NUM < 110000
839 if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
841 if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
843 CDEBUG(call, ast, "Extensions matches.\n");
847 /* send setup acknowledge to lcr */
848 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
849 memset(&newparam, 0, sizeof(union parameter));
850 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
854 call->state = CHAN_LCR_STATE_IN_DIALING;
857 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
861 #if ASTERISK_VERSION_NUM < 110000
864 if (!*ast_channel_exten(ast)) {
866 /* send setup acknowledge to lcr */
867 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
868 memset(&newparam, 0, sizeof(union parameter));
869 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
873 call->state = CHAN_LCR_STATE_IN_DIALING;
876 CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
884 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
885 send_release(call, cause, LOCATION_PRIVATE_LOCAL);
887 /* release asterisk */
888 #if ASTERISK_VERSION_NUM < 110000
889 ast->hangupcause = call->cause;
891 ast_channel_hangupcause_set(ast, call->cause);
893 /* change to release state */
894 call->state = CHAN_LCR_STATE_RELEASE;
895 ast_hangup(ast); // call will be destroyed here
899 /* send setup to asterisk */
900 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
902 #ifdef LCR_FOR_CALLWEAVER
904 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
907 ret = ast_pbx_start(ast);
909 cause = (ret==-2)?34:27;
912 call->pbx_started = 1;
913 ast_setstate(ast, AST_STATE_RING);
917 * incoming setup from LCR
919 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
921 struct ast_channel *ast;
922 #ifdef AST_1_8_OR_HIGHER
923 struct ast_party_redirecting *ast_redir;
925 // struct ast_party_caller *ast_caller;
926 struct ast_callerid *ast_caller;
927 #if ASTERISK_VERSION_NUM >= 110000
928 struct ast_party_redirecting s_ast_redir;
929 struct ast_party_caller s_ast_caller;
930 ast_party_redirecting_init(&s_ast_redir);
931 ast_party_caller_init(&s_ast_caller);
933 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
935 /* create asterisk channel instrance */
937 #ifdef LCR_FOR_CALLWEAVER
938 ast = ast_channel_alloc(1);
941 #ifdef LCR_FOR_ASTERISK
942 #ifdef AST_1_8_OR_HIGHER
943 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
945 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
949 #if ASTERISK_VERSION_NUM < 110000
950 // ast_redir = &ast->redirecting;
951 // ast_caller = &ast->caller;
952 ast_caller = &ast->cid;
954 ast_redir = &s_ast_redir;
955 ast_caller = &s_ast_caller;
960 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
961 send_release(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
968 #if ASTERISK_VERSION_NUM < 110000
969 ast->tech_pvt = call;
970 ast->tech = &lcr_tech;
971 ast->fds[0] = call->pipe[0];
973 ast_channel_tech_pvt_set(ast, call);
974 ast_channel_tech_set(ast, &lcr_tech);
975 ast_channel_set_fd(ast, 0, call->pipe[0]);
978 /* fill setup information */
979 if (param->setup.dialinginfo.id)
980 #if ASTERISK_VERSION_NUM < 110000
981 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
982 if (param->setup.dialinginfo.context[0])
983 strncpy(ast->context, param->setup.dialinginfo.context, AST_MAX_CONTEXT-1);
985 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
987 ast_channel_exten_set(ast, param->setup.dialinginfo.id);
988 if (param->setup.context[0])
989 ast_channel_context_set(ast, param->setup.context);
991 ast_channel_context_set(ast, param->setup.callerinfo.interface);
995 #ifdef AST_1_8_OR_HIGHER
996 if (param->setup.callerinfo.id[0]) {
997 ast_caller->id.number.valid = 1;
998 ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
999 if (!param->setup.callerinfo.id[0]) {
1000 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1001 ast_caller->id.number.plan = (0 << 4) | 1;
1003 switch (param->setup.callerinfo.present) {
1004 case INFO_PRESENT_ALLOWED:
1005 ast_caller->id.number.presentation = AST_PRES_ALLOWED;
1007 case INFO_PRESENT_RESTRICTED:
1008 ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
1011 ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
1013 switch (param->setup.callerinfo.screen) {
1014 case INFO_SCREEN_USER:
1015 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1017 case INFO_SCREEN_USER_VERIFIED_PASSED:
1018 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1020 case INFO_SCREEN_USER_VERIFIED_FAILED:
1021 ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1024 ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
1026 switch (param->setup.callerinfo.ntype) {
1027 case INFO_NTYPE_SUBSCRIBER:
1028 ast_caller->id.number.plan = (4 << 4) | 1;
1030 case INFO_NTYPE_NATIONAL:
1031 ast_caller->id.number.plan = (2 << 4) | 1;
1033 case INFO_NTYPE_INTERNATIONAL:
1034 ast_caller->id.number.plan = (1 << 4) | 1;
1037 ast_caller->id.number.plan = (0 << 4) | 1;
1040 if (param->setup.callerinfo.id2[0]) {
1041 ast_caller->ani.number.valid = 1;
1042 ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
1043 switch (param->setup.callerinfo.present2) {
1044 case INFO_PRESENT_ALLOWED:
1045 ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
1047 case INFO_PRESENT_RESTRICTED:
1048 ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
1051 ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
1053 switch (param->setup.callerinfo.screen2) {
1054 case INFO_SCREEN_USER:
1055 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1057 case INFO_SCREEN_USER_VERIFIED_PASSED:
1058 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1060 case INFO_SCREEN_USER_VERIFIED_FAILED:
1061 ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1064 ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
1066 switch (param->setup.callerinfo.ntype2) {
1067 case INFO_NTYPE_SUBSCRIBER:
1068 ast_caller->ani.number.plan = (4 << 4) | 1;
1070 case INFO_NTYPE_NATIONAL:
1071 ast_caller->ani.number.plan = (2 << 4) | 1;
1073 case INFO_NTYPE_INTERNATIONAL:
1074 ast_caller->ani.number.plan = (1 << 4) | 1;
1077 ast_caller->ani.number.plan = (0 << 4) | 1;
1080 if (param->setup.callerinfo.name[0]) {
1081 ast_caller->id.name.valid = 1;
1082 ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
1084 #if ASTERISK_VERSION_NUM >= 110000
1085 ast_channel_caller_set(ast, ast_caller);
1087 if (param->setup.redirinfo.id[0]) {
1088 ast_redir->from.number.valid = 1;
1089 ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
1090 switch (param->setup.redirinfo.present) {
1091 case INFO_PRESENT_ALLOWED:
1092 ast_redir->from.number.presentation = AST_PRES_ALLOWED;
1094 case INFO_PRESENT_RESTRICTED:
1095 ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
1098 ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
1100 switch (param->setup.redirinfo.screen) {
1101 case INFO_SCREEN_USER:
1102 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
1104 case INFO_SCREEN_USER_VERIFIED_PASSED:
1105 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
1107 case INFO_SCREEN_USER_VERIFIED_FAILED:
1108 ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
1111 ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
1113 switch (param->setup.redirinfo.ntype) {
1114 case INFO_NTYPE_SUBSCRIBER:
1115 ast_redir->from.number.plan = (4 << 4) | 1;
1117 case INFO_NTYPE_NATIONAL:
1118 ast_redir->from.number.plan = (2 << 4) | 1;
1120 case INFO_NTYPE_INTERNATIONAL:
1121 ast_redir->from.number.plan = (1 << 4) | 1;
1124 ast_redir->from.number.plan = (0 << 4) | 1;
1126 #if ASTERISK_VERSION_NUM >= 110000
1127 ast_channel_redirecting_set(ast, ast_redir);
1131 memset(&ast->cid, 0, sizeof(ast->cid));
1132 if (param->setup.callerinfo.id[0])
1133 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
1134 if (param->setup.callerinfo.id2[0])
1135 ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
1136 if (param->setup.callerinfo.name[0])
1137 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
1138 if (param->setup.redirinfo.id[0])
1139 ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
1140 switch (param->setup.callerinfo.present) {
1141 case INFO_PRESENT_ALLOWED:
1142 ast->cid.cid_pres = AST_PRES_ALLOWED;
1144 case INFO_PRESENT_RESTRICTED:
1145 ast->cid.cid_pres = AST_PRES_RESTRICTED;
1148 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
1150 switch (param->setup.callerinfo.ntype) {
1151 case INFO_NTYPE_SUBSCRIBER:
1152 ast->cid.cid_ton = 4;
1154 case INFO_NTYPE_NATIONAL:
1155 ast->cid.cid_ton = 2;
1157 case INFO_NTYPE_INTERNATIONAL:
1158 ast->cid.cid_ton = 1;
1161 ast->cid.cid_ton = 0;
1165 #if ASTERISK_VERSION_NUM < 110000
1166 ast->transfercapability = param->setup.capainfo.bearer_capa;
1168 ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
1170 /* enable hdlc if transcap is data */
1171 if (param->setup.capainfo.source_mode == B_MODE_HDLC)
1173 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
1175 /* configure channel */
1176 #if ASTERISK_VERSION_NUM < 100000
1177 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1178 ast->readformat = ast->rawreadformat = ast->nativeformats;
1179 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1181 #if ASTERISK_VERSION_NUM < 110000
1182 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1183 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
1184 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
1185 ast_set_write_format(ast, &ast->rawwriteformat);
1186 ast_set_read_format(ast, &ast->rawreadformat);
1188 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
1189 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
1190 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
1191 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
1192 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
1195 #if ASTERISK_VERSION_NUM < 110000
1197 ast->hangupcause = 0;
1199 ast_channel_priority_set(ast, 1);
1200 ast_channel_hangupcause_set(ast, 0);
1204 call->state = CHAN_LCR_STATE_IN_SETUP;
1206 if (!call->pbx_started)
1207 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
1211 * incoming setup acknowledge from LCR
1213 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
1215 if (!call->ast) return;
1217 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
1219 /* send pending digits in dialque */
1220 if (call->dialque[0])
1221 send_dialque_to_lcr(call);
1222 /* change to overlap state */
1223 call->state = CHAN_LCR_STATE_OUT_DIALING;
1227 * incoming proceeding from LCR
1229 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
1231 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
1234 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
1235 /* queue event for asterisk */
1236 if (call->ast && call->pbx_started) {
1241 rc = write(wake_pipe[1], &byte, 1);
1243 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
1249 * incoming alerting from LCR
1251 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
1253 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
1256 call->state = CHAN_LCR_STATE_OUT_ALERTING;
1257 /* queue event to asterisk */
1258 if (call->ast && call->pbx_started) {
1263 rc = write(wake_pipe[1], &byte, 1);
1265 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
1270 * incoming connect from LCR
1272 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
1274 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
1277 call->state = CHAN_LCR_STATE_CONNECT;
1278 /* copy connectinfo */
1279 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
1280 /* queue event to asterisk */
1281 if (call->ast && call->pbx_started) {
1286 rc = write(wake_pipe[1], &byte, 1);
1288 strncat(call->queue_string, "N", sizeof(call->queue_string)-1);
1293 * incoming disconnect from LCR
1295 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
1297 struct ast_channel *ast = call->ast;
1299 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
1302 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
1304 call->cause = param->disconnectinfo.cause;
1305 call->location = param->disconnectinfo.location;
1306 /* if bridge, forward disconnect and return */
1309 if (call->bridge_call) {
1310 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
1311 bridge_message_if_bridged(call, message_type, param);
1315 /* release lcr with same cause */
1316 send_release(call, call->cause, call->location);
1318 /* change to release state */
1319 call->state = CHAN_LCR_STATE_RELEASE;
1320 /* queue release asterisk */
1322 #if ASTERISK_VERSION_NUM < 110000
1323 ast->hangupcause = call->cause;
1325 ast_channel_hangupcause_set(ast, call->cause);
1327 if (call->pbx_started) {
1332 rc = write(wake_pipe[1], &byte, 1);
1334 strcpy(call->queue_string, "H"); // overwrite other indications
1336 ast_hangup(ast); // call will be destroyed here
1342 * incoming release from LCR
1344 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
1346 struct ast_channel *ast = call->ast;
1348 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
1352 /* change to release state */
1353 call->state = CHAN_LCR_STATE_RELEASE;
1354 /* copy release info */
1356 call->cause = param->disconnectinfo.cause;
1357 call->location = param->disconnectinfo.location;
1359 /* if we have an asterisk instance, queue hangup, else we are done */
1361 #if ASTERISK_VERSION_NUM < 110000
1362 ast->hangupcause = call->cause;
1364 ast_channel_hangupcause_set(ast, call->cause);
1366 if (call->pbx_started) {
1371 rc = write(wake_pipe[1], &byte, 1);
1373 strcpy(call->queue_string, "H");
1375 ast_hangup(ast); // call will be destroyed here
1384 * incoming information from LCR
1386 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
1388 struct ast_channel *ast = call->ast;
1390 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
1394 /* pbx not started */
1395 if (!call->pbx_started) {
1396 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
1397 #if ASTERISK_VERSION_NUM < 110000
1398 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
1400 ast_channel_exten_set(ast, param->information.id);
1402 lcr_start_pbx(call, ast, param->information.sending_complete);
1406 /* change dailing state after setup */
1407 if (call->state == CHAN_LCR_STATE_IN_SETUP) {
1408 CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
1409 call->state = CHAN_LCR_STATE_IN_DIALING;
1410 // ast_setstate(ast, AST_STATE_DIALING);
1414 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
1419 rc = write(wake_pipe[1], &byte, 1);
1421 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1424 /* use bridge to forware message not supported by asterisk */
1425 if (call->state == CHAN_LCR_STATE_CONNECT) {
1426 CDEBUG(call, call->ast, "Call is connected, bridging.\n");
1427 bridge_message_if_bridged(call, message_type, param);
1432 * incoming information from LCR
1434 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1436 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1438 if (!call->ast) return;
1440 /* use bridge to forware message not supported by asterisk */
1441 bridge_message_if_bridged(call, message_type, param);
1445 * incoming information from LCR
1447 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1449 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1451 if (!call->ast) return;
1453 /* use bridge to forware message not supported by asterisk */
1454 bridge_message_if_bridged(call, message_type, param);
1458 * incoming pattern from LCR
1460 static void lcr_in_pattern(struct chan_call *call, int message_type, union parameter *param)
1462 union parameter newparam;
1464 CDEBUG(call, call->ast, "Incomming pattern indication from LCR.\n");
1466 if (!call->ast) return;
1468 /* pattern are indicated only once */
1469 if (call->has_pattern)
1471 call->has_pattern = 1;
1473 /* request bchannel */
1474 CDEBUG(call, call->ast, "Requesting audio path (ref=%d)\n", call->ref);
1475 memset(&newparam, 0, sizeof(union parameter));
1476 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
1478 /* queue PROGRESS, because tones are available */
1479 if (call->ast && call->pbx_started) {
1484 rc = write(wake_pipe[1], &byte, 1);
1486 strncat(call->queue_string, "T", sizeof(call->queue_string)-1);
1491 * got dtmf from bchannel (locked state)
1493 void lcr_in_dtmf(struct chan_call *call, int val)
1495 struct ast_channel *ast = call->ast;
1500 if (!call->pbx_started)
1503 if (!call->dsp_dtmf) {
1504 CDEBUG(call, call->ast, "Recognised DTMF digit '%c', but ignoring. This is fixed in later mISDN driver.\n", val);
1508 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1515 rc = write(wake_pipe[1], &byte, 1);
1517 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1521 * message received from LCR
1523 int receive_message(int message_type, unsigned int ref, union parameter *param)
1525 struct chan_call *call;
1526 union parameter newparam;
1529 memset(&newparam, 0, sizeof(union parameter));
1531 /* handle new ref */
1532 if (message_type == MESSAGE_NEWREF) {
1533 if (param->newref.direction) {
1534 /* new ref from lcr */
1535 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1536 if (!ref || find_call_ref(ref)) {
1537 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1540 /* allocate new call instance */
1541 call = alloc_call();
1543 call->state = CHAN_LCR_STATE_IN_PREPARE;
1546 call->ref_was_assigned = 1;
1547 /* set dtmf (default, use option 'n' to disable */
1549 /* wait for setup (or release from asterisk) */
1551 /* new ref, as requested from this remote application */
1552 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1553 call = find_call_ref(0);
1555 /* send release, if ref does not exist */
1556 CERROR(NULL, NULL, "No call found, that requests a ref.\n");
1561 call->ref_was_assigned = 1;
1562 /* set dtmf (default, use option 'n' to disable */
1564 /* send pending setup info */
1565 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1566 send_setup_to_lcr(call);
1567 /* release if asterisk has signed off */
1568 else if (call->state == CHAN_LCR_STATE_RELEASE) {
1571 send_release(call, call->cause, call->location);
1573 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1584 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1587 call = find_call_ref(ref);
1589 /* ignore ref that is not used (anymore) */
1590 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1594 /* handle messages */
1595 switch(message_type) {
1597 lcr_in_setup(call, message_type, param);
1600 case MESSAGE_OVERLAP:
1601 lcr_in_overlap(call, message_type, param);
1604 case MESSAGE_PROCEEDING:
1605 lcr_in_proceeding(call, message_type, param);
1608 case MESSAGE_ALERTING:
1609 lcr_in_alerting(call, message_type, param);
1612 case MESSAGE_CONNECT:
1613 lcr_in_connect(call, message_type, param);
1616 case MESSAGE_DISCONNECT:
1617 lcr_in_disconnect(call, message_type, param);
1620 case MESSAGE_RELEASE:
1621 lcr_in_release(call, message_type, param);
1624 case MESSAGE_INFORMATION:
1625 lcr_in_information(call, message_type, param);
1628 case MESSAGE_NOTIFY:
1629 lcr_in_notify(call, message_type, param);
1632 case MESSAGE_FACILITY:
1633 lcr_in_facility(call, message_type, param);
1636 case MESSAGE_PATTERN: // audio available from LCR
1637 if (!call->has_pattern)
1638 lcr_in_pattern(call, message_type, param);
1641 case MESSAGE_NOPATTERN: // audio not available from LCR
1644 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1645 call->audiopath = param->audiopath;
1648 case MESSAGE_TRAFFIC: // if remote audio connected or hold
1650 unsigned char *p = param->traffic.data;
1651 int i, len = param->traffic.len;
1652 for (i = 0; i < len; i++, p++)
1655 rc = write(call->pipe[1], param->traffic.data, param->traffic.len);
1659 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1666 * release all calls (due to broken socket)
1668 static void release_all_calls(void)
1670 struct chan_call *call;
1675 /* no ast, so we may directly free call */
1677 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1681 /* already in release process */
1682 if (call->state == CHAN_LCR_STATE_RELEASE) {
1686 /* release or queue release */
1688 call->state = CHAN_LCR_STATE_RELEASE;
1689 if (!call->pbx_started) {
1690 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1691 ast_hangup(call->ast); // call will be destroyed here
1694 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1699 rc = write(wake_pipe[1], &byte, 1);
1701 strcpy(call->queue_string, "H");
1706 void close_socket(void);
1709 * warning! not thread safe
1710 * returns -1 for socket error, 0 for no work, 1 for work
1712 static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1715 struct admin_list *admin;
1716 struct admin_message msg;
1718 if ((what & LCR_FD_READ)) {
1719 /* read from socket */
1720 len = read(lcr_sock, &msg, sizeof(msg));
1722 CERROR(NULL, NULL, "Socket closed.(read)\n");
1724 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1726 release_all_calls();
1727 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1731 if (len != sizeof(msg)) {
1732 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1735 if (msg.message != ADMIN_MESSAGE) {
1736 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1739 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1741 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1746 if ((what & LCR_FD_WRITE)) {
1747 /* write to socket */
1749 socket_fd.when &= ~LCR_FD_WRITE;
1752 admin = admin_first;
1753 len = write(lcr_sock, &admin->msg, sizeof(msg));
1755 CERROR(NULL, NULL, "Socket closed.(write)\n");
1759 if (len != sizeof(msg)) {
1760 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1764 admin_first = admin->next;
1768 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1777 * open and close socket and thread
1779 int open_socket(void)
1782 struct sockaddr_un sock_address;
1783 union parameter param;
1786 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) {
1787 CERROR(NULL, NULL, "Failed to create socket.\n");
1791 /* set socket address and name */
1792 memset(&sock_address, 0, sizeof(sock_address));
1793 sock_address.sun_family = PF_UNIX;
1794 sprintf(sock_address.sun_path, SOCKET_NAME, options.lock);
1796 /* connect socket */
1797 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) {
1800 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1804 /* register socket fd */
1805 memset(&socket_fd, 0, sizeof(socket_fd));
1806 socket_fd.fd = lcr_sock;
1807 register_fd(&socket_fd, LCR_FD_READ | LCR_FD_EXCEPT, handle_socket, NULL, 0);
1809 /* enque hello message */
1810 memset(¶m, 0, sizeof(param));
1811 strcpy(param.hello.application, "asterisk");
1812 send_message(MESSAGE_HELLO, 0, ¶m);
1817 void close_socket(void)
1819 struct admin_list *admin, *temp;
1821 /* socket not created */
1825 unregister_fd(&socket_fd);
1827 /* flush pending messages */
1828 admin = admin_first;
1831 admin = admin->next;
1843 /* sending queue to asterisk */
1844 static int wake_event(struct lcr_fd *fd, unsigned int what, void *instance, int index)
1849 rc = read(wake_pipe[0], &byte, 1);
1856 static void handle_queue()
1858 struct chan_call *call;
1859 struct ast_channel *ast;
1860 struct ast_frame fr;
1866 p = call->queue_string;
1869 if (ast_channel_trylock(ast)) {
1870 ast_mutex_unlock(&chan_lock);
1872 ast_mutex_lock(&chan_lock);
1878 CDEBUG(call, ast, "Sending queued PROGRESS to Asterisk.\n");
1879 ast_queue_control(ast, AST_CONTROL_PROGRESS);
1882 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1883 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1886 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1887 ast_queue_control(ast, AST_CONTROL_RINGING);
1888 ast_setstate(ast, AST_STATE_RINGING);
1891 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1892 ast_queue_control(ast, AST_CONTROL_ANSWER);
1895 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1896 ast_queue_hangup(ast);
1898 case '1': case '2': case '3': case 'A':
1899 case '4': case '5': case '6': case 'B':
1900 case '7': case '8': case '9': case 'C':
1901 case '*': case '0': case '#': case 'D':
1902 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1903 /* send digit to asterisk */
1904 memset(&fr, 0, sizeof(fr));
1906 #ifdef LCR_FOR_ASTERISK
1907 fr.frametype = AST_FRAME_DTMF_BEGIN;
1910 #ifdef LCR_FOR_CALLWEAVER
1911 fr.frametype = AST_FRAME_DTMF;
1914 #ifdef AST_1_8_OR_HIGHER
1915 fr.subclass.integer = *p;
1919 fr.delivery = ast_tv(0, 0);
1920 ast_queue_frame(ast, &fr);
1922 #ifdef LCR_FOR_ASTERISK
1923 fr.frametype = AST_FRAME_DTMF_END;
1924 ast_queue_frame(ast, &fr);
1929 CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
1933 call->queue_string[0] = '\0';
1934 ast_channel_unlock(ast);
1940 static int handle_retry(struct lcr_timer *timer, void *instance, int index)
1942 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1943 if (open_socket() < 0)
1944 schedule_timer(&socket_retry, SOCKET_RETRY_TIMER, 0);
1949 void lock_chan(void)
1951 ast_mutex_lock(&chan_lock);
1954 void unlock_chan(void)
1956 ast_mutex_unlock(&chan_lock);
1959 /* chan_lcr thread */
1960 static void *chan_thread(void *arg)
1962 if (pipe(wake_pipe) < 0) {
1963 CERROR(NULL, NULL, "Failed to open pipe.\n");
1966 memset(&wake_fd, 0, sizeof(wake_fd));
1967 wake_fd.fd = wake_pipe[0];
1968 register_fd(&wake_fd, LCR_FD_READ, wake_event, NULL, 0);
1970 memset(&socket_retry, 0, sizeof(socket_retry));
1971 add_timer(&socket_retry, handle_retry, NULL, 0);
1973 /* open socket the first time */
1974 handle_retry(NULL, NULL, 0);
1976 ast_mutex_lock(&chan_lock);
1980 select_main(0, &global_change, lock_chan, unlock_chan);
1987 * new asterisk instance
1990 #ifdef AST_1_8_OR_HIGHER
1991 #if ASTERISK_VERSION_NUM < 100000
1992 struct ast_channel *lcr_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
1994 struct ast_channel *lcr_request(const char *type, struct ast_format_cap *format, const struct ast_channel *requestor, void *data, int *cause)
1997 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
2000 char exten[256], *dial, *interface, *opt;
2001 struct ast_channel *ast;
2002 struct chan_call *call;
2003 #ifdef AST_1_8_OR_HIGHER
2004 const struct ast_party_redirecting *req_redir;
2005 const struct ast_party_caller *req_caller;
2008 ast_mutex_lock(&chan_lock);
2009 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
2011 /* if socket is closed */
2013 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
2014 ast_mutex_unlock(&chan_lock);
2018 /* create call instance */
2019 call = alloc_call();
2021 /* failed to create instance */
2022 ast_mutex_unlock(&chan_lock);
2026 /* create asterisk channel instrance */
2028 #ifdef LCR_FOR_ASTERISK
2029 #ifdef AST_1_8_OR_HIGHER
2030 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, NULL, NULL, NULL, NULL, 0, "%s/%d", lcr_type, ++glob_channel);
2032 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
2036 #ifdef LCR_FOR_CALLWEAVER
2037 ast = ast_channel_alloc(1);
2041 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
2043 /* failed to create instance */
2044 ast_mutex_unlock(&chan_lock);
2047 #if ASTERISK_VERSION_NUM < 110000
2048 ast->tech = &lcr_tech;
2049 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
2050 #ifdef AST_1_8_OR_HIGHER
2051 req_redir = &requestor->redirecting;
2052 req_caller = &requestor->caller;
2055 ast_channel_tech_set(ast, &lcr_tech);
2056 ast_channel_tech_pvt_set(ast, (void *)1L); // set pointer or asterisk will not call
2057 req_redir = ast_channel_redirecting(requestor);
2058 req_caller = ast_channel_caller(requestor);
2060 /* configure channel */
2061 #if ASTERISK_VERSION_NUM < 100000
2062 #if ASTERISK_VERSION_NUM < 110000
2063 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2064 ast->readformat = ast->rawreadformat = ast->nativeformats;
2065 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
2067 ast_channel_nativeformats_set(ast, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
2068 ast->readformat = ast->rawreadformat = ast_channel_nativeformats(ast);
2069 ast->writeformat = ast->rawwriteformat = ast_channel_nativeformats(ast);
2072 #if ASTERISK_VERSION_NUM < 110000
2073 ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2074 ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
2075 ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
2076 ast_set_write_format(ast, &ast->rawwriteformat);
2077 ast_set_read_format(ast, &ast->rawreadformat);
2079 ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
2080 ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
2081 ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
2082 ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
2083 ast_set_read_format(ast, ast_channel_rawreadformat(ast));
2086 #if ASTERISK_VERSION_NUM < 110000
2088 ast->hangupcause = 0;
2090 ast_channel_priority_set(ast, 1);
2091 ast_channel_hangupcause_set(ast, 0);
2096 #if ASTERISK_VERSION_NUM < 110000
2097 ast->tech_pvt = call;
2098 ast->fds[0] = call->pipe[0];
2100 ast_channel_tech_pvt_set(ast, call);
2101 ast_channel_set_fd(ast, 0, call->pipe[0]);
2103 call->pbx_started = 0;
2105 call->state = CHAN_LCR_STATE_OUT_PREPARE;
2108 * Extract interface, dialstring, options from data.
2111 * <interface>/<dialstring>
2112 * <interface>/<dialstring>/options
2114 strncpy(exten, (char *)data, sizeof(exten)-1);
2115 exten[sizeof(exten)-1] = '\0';
2116 if ((dial = strchr(exten, '/'))) {
2119 if ((opt = strchr(dial, '/')))
2128 strncpy(call->interface, interface, sizeof(call->interface)-1);
2129 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
2130 apply_opt(call, (char *)opt);
2132 #ifdef AST_1_8_OR_HIGHER
2133 // clone_variables(requestor, ast);
2136 ast->caller.ani.number.valid= req_caller->ani.number.valid;
2137 if (req_caller->ani.number.valid)
2138 if (req_caller->ani.number.str)
2139 if (req_caller->ani.number.str[0])
2140 ast->caller.ani.number.str= strdup(req_caller->ani.number.str);
2141 ast->caller.ani.number.plan= req_caller->ani.number.plan;
2142 ast->caller.ani.number.presentation= req_caller->ani.number.presentation;
2144 ast->caller.ani.name.valid= req_caller->ani.name.valid;
2145 if (req_caller->ani.name.valid)
2146 if (req_caller->ani.name.str)
2147 if (req_caller->ani.name.str[0])
2148 ast->caller.ani.name.str= strdup(req_caller->ani.name.str);
2149 ast->caller.ani.name.presentation= req_caller->ani.name.presentation;
2151 ast->caller.ani.subaddress.valid= req_caller->ani.subaddress.valid;
2152 if (req_caller->ani.subaddress.valid)
2153 if (req_caller->ani.subaddress.str)
2154 if (req_caller->ani.subaddress.str[0])
2155 ast->caller.ani.subaddress.str= strdup(req_caller->ani.subaddress.str);
2156 ast->caller.ani.subaddress.type= req_caller->ani.subaddress.type;
2158 ast->caller.id.number.valid= req_caller->id.number.valid;
2159 if (req_caller->id.number.valid)
2160 if (req_caller->id.number.str)
2161 if (req_caller->id.number.str[0])
2162 ast->caller.id.number.str= strdup(req_caller->id.number.str);
2163 ast->caller.id.number.plan= req_caller->id.number.plan;
2164 ast->caller.id.number.presentation= req_caller->id.number.presentation;
2166 ast->caller.id.name.valid= req_caller->id.name.valid;
2167 if (req_caller->id.name.valid)
2168 if (req_caller->id.name.str)
2169 if (req_caller->id.name.str[0])
2170 ast->caller.id.name.str= strdup(req_caller->id.name.str);
2171 ast->caller.id.name.presentation= req_caller->id.name.presentation;
2173 ast->caller.id.subaddress.valid= req_caller->id.subaddress.valid;
2174 if (req_caller->id.subaddress.valid)
2175 if (req_caller->id.subaddress.str)
2176 if (req_caller->id.subaddress.str[0])
2177 ast->caller.id.subaddress.str= strdup(req_caller->id.subaddress.str);
2178 ast->caller.id.subaddress.type= req_caller->id.subaddress.type;
2180 if (requestor->dialed.number.str)
2181 if (requestor->dialed.number.str[0])
2182 ast->dialed.number.str= strdup(requestor->dialed.number.str);
2183 ast->dialed.number.plan= requestor->dialed.number.plan;
2185 ast->dialed.subaddress.valid= requestor->dialed.subaddress.valid;
2186 if (requestor->dialed.subaddress.valid)
2187 if (requestor->dialed.subaddress.str)
2188 if (requestor->dialed.subaddress.str[0])
2189 ast->dialed.subaddress.str= strdup(requestor->dialed.subaddress.str);
2190 ast->dialed.subaddress.type= requestor->dialed.subaddress.type;
2192 ast->dialed.transit_network_select= requestor->dialed.transit_network_select;
2193 ast->redirecting.count= req_redir->count;
2194 ast->redirecting.reason= req_redir->reason;
2196 ast->redirecting.from.number.valid= req_redir->from.number.valid;
2197 if (req_redir->from.number.valid)
2198 if (req_redir->from.number.str)
2199 if (req_redir->from.number.str[0])
2200 ast->redirecting.from.number.str= strdup(req_redir->from.number.str);
2201 ast->redirecting.from.number.plan= req_redir->from.number.plan;
2202 ast->redirecting.from.number.presentation= req_redir->from.number.presentation;
2204 ast->redirecting.to.number.valid= req_redir->to.number.valid;
2205 if (req_redir->to.number.valid)
2206 if (req_redir->to.number.str)
2207 if (req_redir->to.number.str[0])
2208 ast->redirecting.to.number.str= strdup(req_redir->to.number.str);
2209 ast->redirecting.to.number.plan= req_redir->to.number.plan;
2210 ast->redirecting.to.number.presentation= req_redir->to.number.presentation;
2212 /* store call information for setup */
2215 if (requestor && req_caller->id.number.valid) {
2216 if (req_caller->id.number.str)
2217 strncpy(call->callerinfo.id, req_caller->id.number.str, sizeof(call->callerinfo.id)-1);
2218 switch(req_caller->id.number.presentation & AST_PRES_RESTRICTION) {
2219 case AST_PRES_RESTRICTED:
2220 call->callerinfo.present = INFO_PRESENT_RESTRICTED;
2222 case AST_PRES_UNAVAILABLE:
2223 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2225 case AST_PRES_ALLOWED:
2227 call->callerinfo.present = INFO_PRESENT_ALLOWED;
2229 switch(req_caller->id.number.presentation & AST_PRES_NUMBER_TYPE) {
2230 case AST_PRES_USER_NUMBER_UNSCREENED:
2231 call->callerinfo.screen = INFO_SCREEN_USER;
2233 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2234 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2236 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2237 call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2240 call->callerinfo.screen = INFO_SCREEN_NETWORK;
2242 switch((req_caller->id.number.plan >> 4) & 7) {
2244 call->callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2247 call->callerinfo.ntype = INFO_NTYPE_NATIONAL;
2250 call->callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2253 call->callerinfo.ntype = INFO_NTYPE_UNKNOWN;
2256 call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
2259 if (requestor && req_caller->ani.number.valid) {
2260 if (req_caller->ani.number.str)
2261 strncpy(call->callerinfo.id2, req_caller->ani.number.str, sizeof(call->callerinfo.id2)-1);
2262 switch(req_caller->ani.number.presentation & AST_PRES_RESTRICTION) {
2263 case AST_PRES_RESTRICTED:
2264 call->callerinfo.present2 = INFO_PRESENT_RESTRICTED;
2266 case AST_PRES_UNAVAILABLE:
2267 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2269 case AST_PRES_ALLOWED:
2271 call->callerinfo.present2 = INFO_PRESENT_ALLOWED;
2273 switch(req_caller->ani.number.presentation & AST_PRES_NUMBER_TYPE) {
2274 case AST_PRES_USER_NUMBER_UNSCREENED:
2275 call->callerinfo.screen2 = INFO_SCREEN_USER;
2277 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2278 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_PASSED;
2280 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2281 call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_FAILED;
2284 call->callerinfo.screen2 = INFO_SCREEN_NETWORK;
2286 switch((req_caller->ani.number.plan >> 4) & 7) {
2288 call->callerinfo.ntype2 = INFO_NTYPE_SUBSCRIBER;
2291 call->callerinfo.ntype2 = INFO_NTYPE_NATIONAL;
2294 call->callerinfo.ntype2 = INFO_NTYPE_INTERNATIONAL;
2297 call->callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
2300 call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
2303 if (requestor && req_caller->id.name.valid) {
2304 if (req_caller->id.name.str)
2305 strncpy(call->callerinfo.name, req_caller->id.name.str, sizeof(call->callerinfo.name)-1);
2309 if (requestor && req_redir->from.number.valid) {
2310 call->redirinfo.itype = INFO_ITYPE_CHAN;
2311 if (req_redir->from.number.str)
2312 strncpy(call->redirinfo.id, req_redir->from.number.str, sizeof(call->redirinfo.id)-1);
2313 switch(req_redir->from.number.presentation & AST_PRES_RESTRICTION) {
2314 case AST_PRES_RESTRICTED:
2315 call->redirinfo.present = INFO_PRESENT_RESTRICTED;
2317 case AST_PRES_UNAVAILABLE:
2318 call->redirinfo.present = INFO_PRESENT_NOTAVAIL;
2320 case AST_PRES_ALLOWED:
2322 call->redirinfo.present = INFO_PRESENT_ALLOWED;
2324 switch(req_redir->from.number.presentation & AST_PRES_NUMBER_TYPE) {
2325 case AST_PRES_USER_NUMBER_UNSCREENED:
2326 call->redirinfo.screen = INFO_SCREEN_USER;
2328 case AST_PRES_USER_NUMBER_PASSED_SCREEN:
2329 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
2331 case AST_PRES_USER_NUMBER_FAILED_SCREEN:
2332 call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
2335 call->redirinfo.screen = INFO_SCREEN_NETWORK;
2337 switch((req_redir->from.number.plan >> 4) & 7) {
2339 call->redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
2342 call->redirinfo.ntype = INFO_NTYPE_NATIONAL;
2345 call->redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
2348 call->redirinfo.ntype = INFO_NTYPE_UNKNOWN;
2353 ast_mutex_unlock(&chan_lock);
2358 * call from asterisk
2360 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
2362 union parameter newparam;
2363 struct chan_call *call;
2364 #if ASTERISK_VERSION_NUM >= 110000
2365 int transfercapability;
2368 ast_mutex_lock(&chan_lock);
2369 #if ASTERISK_VERSION_NUM < 110000
2370 call = ast->tech_pvt;
2372 call = ast_channel_tech_pvt(ast);
2375 #ifdef LCR_FOR_CALLWEAVER
2377 snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type, call->dialstring, ast_random() & 0xffff);
2381 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
2382 ast_mutex_unlock(&chan_lock);
2386 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
2388 /* pbx process is started */
2389 call->pbx_started = 1;
2390 /* send MESSAGE_NEWREF */
2391 memset(&newparam, 0, sizeof(union parameter));
2392 newparam.newref.direction = 0; /* request from app */
2393 send_message(MESSAGE_NEWREF, 0, &newparam);
2395 /* set hdlc if capability requires hdlc */
2396 #if ASTERISK_VERSION_NUM < 110000
2397 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
2398 || ast->transfercapability == INFO_BC_DATARESTRICTED
2399 || ast->transfercapability == INFO_BC_VIDEO)
2401 transfercapability=ast_channel_transfercapability(ast);
2402 if (transfercapability == INFO_BC_DATAUNRESTRICTED
2403 || transfercapability == INFO_BC_DATARESTRICTED
2404 || transfercapability == INFO_BC_VIDEO)
2407 /* if hdlc is forced by option, we change transcap to data */
2409 #if ASTERISK_VERSION_NUM < 110000
2410 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
2411 && ast->transfercapability != INFO_BC_DATARESTRICTED
2412 && ast->transfercapability != INFO_BC_VIDEO)
2413 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
2415 && transfercapability != INFO_BC_DATAUNRESTRICTED
2416 && transfercapability != INFO_BC_DATARESTRICTED
2417 && transfercapability != INFO_BC_VIDEO)
2418 transfercapability = INFO_BC_DATAUNRESTRICTED;
2421 #ifndef AST_1_8_OR_HIGHER
2422 call->cid_num[0] = 0;
2423 call->cid_name[0] = 0;
2424 call->cid_rdnis[0] = 0;
2426 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
2427 strncpy(call->cid_num, ast->cid.cid_num,
2428 sizeof(call->cid_num)-1);
2429 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
2430 strncpy(call->cid_name, ast->cid.cid_name,
2431 sizeof(call->cid_name)-1);
2432 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
2433 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
2434 sizeof(call->cid_rdnis)-1);
2437 ast_mutex_unlock(&chan_lock);
2441 static void send_digit_to_chan(struct ast_channel * ast, char digit )
2443 static const char* dtmf_tones[] = {
2444 "!941+1336/100,!0/100", /* 0 */
2445 "!697+1209/100,!0/100", /* 1 */
2446 "!697+1336/100,!0/100", /* 2 */
2447 "!697+1477/100,!0/100", /* 3 */
2448 "!770+1209/100,!0/100", /* 4 */
2449 "!770+1336/100,!0/100", /* 5 */
2450 "!770+1477/100,!0/100", /* 6 */
2451 "!852+1209/100,!0/100", /* 7 */
2452 "!852+1336/100,!0/100", /* 8 */
2453 "!852+1477/100,!0/100", /* 9 */
2454 "!697+1633/100,!0/100", /* A */
2455 "!770+1633/100,!0/100", /* B */
2456 "!852+1633/100,!0/100", /* C */
2457 "!941+1633/100,!0/100", /* D */
2458 "!941+1209/100,!0/100", /* * */
2459 "!941+1477/100,!0/100" }; /* # */
2461 if (digit >= '0' && digit <='9')
2462 ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
2463 else if (digit >= 'A' && digit <= 'D')
2464 ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
2465 else if (digit == '*')
2466 ast_playtones_start(ast,0,dtmf_tones[14], 0);
2467 else if (digit == '#')
2468 ast_playtones_start(ast,0,dtmf_tones[15], 0);
2470 #if ASTERISK_VERSION_NUM < 110000
2471 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
2473 CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
2478 #ifdef LCR_FOR_ASTERISK
2479 static int lcr_digit_begin(struct ast_channel *ast, char digit)
2481 #ifdef LCR_FOR_CALLWEAVER
2482 static int lcr_digit(struct ast_channel *ast, char digit)
2485 struct chan_call *call;
2486 union parameter newparam;
2489 #ifdef LCR_FOR_CALLWEAVER
2490 int inband_dtmf = 0;
2493 /* only pass IA5 number space */
2494 if (digit > 126 || digit < 32)
2497 ast_mutex_lock(&chan_lock);
2498 #if ASTERISK_VERSION_NUM < 110000
2499 call = ast->tech_pvt;
2501 call = ast_channel_tech_pvt(ast);
2504 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
2505 ast_mutex_unlock(&chan_lock);
2509 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
2511 /* send information or queue them */
2512 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) {
2513 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
2514 memset(&newparam, 0, sizeof(union parameter));
2516 newparam.information.keypad[0] = digit;
2517 newparam.information.keypad[1] = '\0';
2519 newparam.information.id[0] = digit;
2520 newparam.information.id[1] = '\0';
2522 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
2525 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) {
2526 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
2528 strncat(call->dialque, buf, strlen(call->dialque)-1);
2531 ast_mutex_unlock(&chan_lock);
2533 #ifdef LCR_FOR_ASTERISK
2537 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
2539 int inband_dtmf = 0;
2540 struct chan_call *call;
2543 ast_mutex_lock(&chan_lock);
2545 #if ASTERISK_VERSION_NUM < 110000
2546 call = ast->tech_pvt;
2548 call = ast_channel_tech_pvt(ast);
2553 "Received digit from Asterisk, "
2554 "but no call instance exists.\n");
2555 ast_mutex_unlock(&chan_lock);
2559 CDEBUG(call, ast, "DIGIT END '%c' from Asterisk.\n", digit);
2561 if (call->state == CHAN_LCR_STATE_CONNECT && call->inband_dtmf) {
2565 ast_mutex_unlock(&chan_lock);
2568 CDEBUG(call, ast, "-> sending '%c' inband.\n", digit);
2569 send_digit_to_chan(ast, digit);
2575 static int lcr_answer(struct ast_channel *ast)
2577 union parameter newparam;
2578 struct chan_call *call;
2580 ast_mutex_lock(&chan_lock);
2581 #if ASTERISK_VERSION_NUM < 110000
2582 call = ast->tech_pvt;
2584 call = ast_channel_tech_pvt(ast);
2587 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
2588 ast_mutex_unlock(&chan_lock);
2592 CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");
2594 /* copy connectinfo, if bridged */
2595 if (call->bridge_call)
2596 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
2597 /* send connect message to lcr */
2598 if (call->state != CHAN_LCR_STATE_CONNECT) {
2599 memset(&newparam, 0, sizeof(union parameter));
2600 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
2601 send_message(MESSAGE_CONNECT, call->ref, &newparam);
2602 call->state = CHAN_LCR_STATE_CONNECT;
2606 // memset(&newparam, 0, sizeof(union parameter));
2607 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
2609 ast_mutex_unlock(&chan_lock);
2613 static int lcr_hangup(struct ast_channel *ast)
2615 struct chan_call *call;
2616 pthread_t tid = pthread_self();
2618 if (!pthread_equal(tid, chan_tid)) {
2619 ast_mutex_lock(&chan_lock);
2621 #if ASTERISK_VERSION_NUM < 110000
2622 call = ast->tech_pvt;
2624 call = ast_channel_tech_pvt(ast);
2627 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
2628 if (!pthread_equal(tid, chan_tid)) {
2629 ast_mutex_unlock(&chan_lock);
2634 if (!pthread_equal(tid, chan_tid))
2635 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
2637 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
2639 /* disconnect asterisk, maybe not required */
2640 #if ASTERISK_VERSION_NUM < 110000
2641 ast->tech_pvt = NULL;
2644 ast_channel_tech_pvt_set(ast, NULL);
2645 ast_channel_set_fd(ast, 0, -1);
2649 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
2650 #if ASTERISK_VERSION_NUM < 110000
2651 if (ast->hangupcause > 0)
2652 send_release(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
2654 if (ast_channel_hangupcause(ast) > 0)
2655 send_release(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
2658 send_release(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
2661 if (!pthread_equal(tid, chan_tid)) {
2662 ast_mutex_unlock(&chan_lock);
2666 /* ref is not set, due to prepare setup or release */
2667 if (call->state == CHAN_LCR_STATE_RELEASE) {
2668 /* we get the response to our release */
2669 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
2672 /* during prepare, we change to release state */
2673 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
2674 call->state = CHAN_LCR_STATE_RELEASE;
2678 if (!pthread_equal(tid, chan_tid)) {
2679 ast_mutex_unlock(&chan_lock);
2684 static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
2686 union parameter newparam;
2687 struct chan_call *call;
2688 struct ast_frame * f = fr;
2689 unsigned char *p, *q;
2692 #if ASTERISK_VERSION_NUM < 100000
2693 #ifdef AST_1_8_OR_HIGHER
2694 if (!f->subclass.codec)
2698 CDEBUG(NULL, ast, "No subclass\n");
2700 #ifdef AST_1_8_OR_HIGHER
2701 #if ASTERISK_VERSION_NUM < 100000
2702 #if ASTERISK_VERSION_NUM < 110000
2703 if (!(f->subclass.codec & ast->nativeformats)) {
2705 if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
2708 #if ASTERISK_VERSION_NUM < 110000
2709 if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
2711 if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
2715 #if ASTERISK_VERSION_NUM < 110000
2716 if (!(f->subclass & ast->nativeformats)) {
2718 if (!(f->subclass & ast_channel_nativeformats(ast))) {
2722 "Unexpected format. "
2723 "Activating emergency conversion...\n");
2725 #ifdef AST_1_8_OR_HIGHER
2726 #if ASTERISK_VERSION_NUM < 100000
2727 ast_set_write_format(ast, f->subclass.codec);
2729 ast_set_write_format(ast, &f->subclass.format);
2732 ast_set_write_format(ast, f->subclass);
2734 #if ASTERISK_VERSION_NUM < 110000
2735 f = (ast->writetrans) ? ast_translate(
2736 ast->writetrans, fr, 0) : fr;
2738 f = (ast_channel_writetrans(ast)) ? ast_translate(
2739 ast_channel_writetrans(ast), fr, 0) : fr;
2743 ast_mutex_lock(&chan_lock);
2744 #if ASTERISK_VERSION_NUM < 110000
2745 call = ast->tech_pvt;
2747 call = ast_channel_tech_pvt(ast);
2750 ast_mutex_unlock(&chan_lock);
2757 p = *((unsigned char **)&(f->data));
2758 q = newparam.traffic.data;
2759 memset(&newparam, 0, sizeof(union parameter));
2761 l = (len > sizeof(newparam.traffic.data)) ? sizeof(newparam.traffic.data) : len;
2762 newparam.traffic.len = l;
2765 *q++ = flip_bits[*p++];
2766 send_message(MESSAGE_TRAFFIC, call->ref, &newparam);
2768 ast_mutex_unlock(&chan_lock);
2776 static struct ast_frame *lcr_read(struct ast_channel *ast)
2778 struct chan_call *call;
2781 ast_mutex_lock(&chan_lock);
2782 #if ASTERISK_VERSION_NUM < 110000
2783 call = ast->tech_pvt;
2785 call = ast_channel_tech_pvt(ast);
2788 ast_mutex_unlock(&chan_lock);
2791 if (call->pipe[0] > -1) {
2792 if (call->rebuffer && !call->hdlc) {
2793 /* Make sure we have a complete 20ms (160byte) frame */
2794 len=read(call->pipe[0],call->read_buff + call->framepos, 160 - call->framepos);
2796 call->framepos += len;
2799 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
2801 if (len < 0 && errno == EAGAIN) {
2802 ast_mutex_unlock(&chan_lock);
2804 #ifdef LCR_FOR_ASTERISK
2805 return &ast_null_frame;
2808 #ifdef LCR_FOR_CALLWEAVER
2814 close(call->pipe[0]);
2817 ast_mutex_unlock(&chan_lock);
2819 } else if (call->rebuffer && call->framepos < 160) {
2820 /* Not a complete frame, so we send a null-frame */
2821 ast_mutex_unlock(&chan_lock);
2822 return &ast_null_frame;
2826 call->read_fr.frametype = AST_FRAME_VOICE;
2827 #ifdef AST_1_8_OR_HIGHER
2828 #if ASTERISK_VERSION_NUM < 100000
2829 #if ASTERISK_VERSION_NUM < 110000
2830 call->read_fr.subclass.codec = ast->nativeformats;
2832 call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
2835 #if ASTERISK_VERSION_NUM < 110000
2836 ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
2838 ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
2840 call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
2843 #if ASTERISK_VERSION_NUM < 110000
2844 call->read_fr.subclass = ast->nativeformats;
2846 call->read_fr.subclass = ast_channel_nativeformats(ast);
2849 if (call->rebuffer) {
2850 call->read_fr.datalen = call->framepos;
2851 call->read_fr.samples = call->framepos;
2854 call->read_fr.datalen = len;
2855 call->read_fr.samples = len;
2857 call->read_fr.delivery = ast_tv(0,0);
2858 *((unsigned char **)&(call->read_fr.data)) = call->read_buff;
2859 ast_mutex_unlock(&chan_lock);
2861 return &call->read_fr;
2864 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
2866 union parameter newparam;
2868 struct chan_call *call;
2869 const struct ast_tone_zone_sound *ts = NULL;
2871 ast_mutex_lock(&chan_lock);
2872 #if ASTERISK_VERSION_NUM < 110000
2873 call = ast->tech_pvt;
2875 call = ast_channel_tech_pvt(ast);
2878 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
2879 ast_mutex_unlock(&chan_lock);
2884 case AST_CONTROL_BUSY:
2885 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
2886 ast_setstate(ast, AST_STATE_BUSY);
2887 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2888 /* send message to lcr */
2889 memset(&newparam, 0, sizeof(union parameter));
2890 newparam.disconnectinfo.cause = 17;
2891 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2892 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2894 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2896 CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
2897 #if ASTERISK_VERSION_NUM < 110000
2898 ts = ast_get_indication_tone(ast->zone, "busy");
2900 ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
2904 case AST_CONTROL_CONGESTION:
2905 #if ASTERISK_VERSION_NUM < 110000
2906 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2908 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
2910 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2911 /* send message to lcr */
2912 memset(&newparam, 0, sizeof(union parameter));
2913 #if ASTERISK_VERSION_NUM < 110000
2914 newparam.disconnectinfo.cause = ast->hangupcause;
2916 newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
2918 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2919 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2921 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2923 CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
2924 #if ASTERISK_VERSION_NUM < 110000
2925 ts = ast_get_indication_tone(ast->zone, "congestion");
2927 ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
2931 case AST_CONTROL_PROCEEDING:
2932 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2933 if (call->state == CHAN_LCR_STATE_IN_SETUP
2934 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2935 /* send message to lcr */
2936 memset(&newparam, 0, sizeof(union parameter));
2937 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2939 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2942 case AST_CONTROL_RINGING:
2943 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2944 ast_setstate(ast, AST_STATE_RING);
2945 if (call->state == CHAN_LCR_STATE_IN_SETUP
2946 || call->state == CHAN_LCR_STATE_IN_DIALING
2947 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2948 /* send message to lcr */
2949 memset(&newparam, 0, sizeof(union parameter));
2950 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2952 call->state = CHAN_LCR_STATE_IN_ALERTING;
2954 CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
2955 #if ASTERISK_VERSION_NUM < 110000
2956 ts = ast_get_indication_tone(ast->zone, "ring");
2958 ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
2962 case AST_CONTROL_PROGRESS:
2963 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROGRESS from Asterisk.\n");
2964 /* request bchannel */
2965 CDEBUG(call, ast, "Requesting audio path.\n");
2966 memset(&newparam, 0, sizeof(union parameter));
2967 send_message(MESSAGE_AUDIOPATH, call->ref, &newparam);
2970 CDEBUG(call, ast, "Received indicate -1.\n");
2971 ast_playtones_stop(ast);
2975 case AST_CONTROL_VIDUPDATE:
2976 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2979 case AST_CONTROL_HOLD:
2980 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2981 /* send message to lcr */
2982 memset(&newparam, 0, sizeof(union parameter));
2983 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2984 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2986 /*start music onhold*/
2987 #ifdef LCR_FOR_ASTERISK
2988 #if ASTERISK_VERSION_NUM <110000
2989 ast_moh_start(ast,data,ast->musicclass);
2991 ast_moh_start(ast,data,ast_channel_musicclass(ast));
2995 #ifdef LCR_FOR_CALLWEAVER
2996 ast_moh_start(ast, NULL);
3001 case AST_CONTROL_UNHOLD:
3002 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
3003 /* send message to lcr */
3004 memset(&newparam, 0, sizeof(union parameter));
3005 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3006 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3012 #ifdef AST_CONTROL_SRCUPDATE
3013 case AST_CONTROL_SRCUPDATE:
3017 CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
3020 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
3025 if (ts && ts->data[0]) {
3026 ast_playtones_start(ast, 0, ts->data, 1);
3030 ast_mutex_unlock(&chan_lock);
3037 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
3039 struct chan_call *call;
3045 ast_mutex_lock(&chan_lock);
3046 #if ASTERISK_VERSION_NUM < 110000
3047 call = ast->tech_pvt;
3049 call = ast_channel_tech_pvt(ast);
3052 CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
3053 ast_mutex_unlock(&chan_lock);
3057 CDEBUG(call, ast, "Received fixup from Asterisk.\n");
3059 ast_mutex_unlock(&chan_lock);
3064 * send_text asterisk
3066 static int lcr_send_text(struct ast_channel *ast, const char *text)
3068 struct chan_call *call;
3069 union parameter newparam;
3071 ast_mutex_lock(&chan_lock);
3072 #if ASTERISK_VERSION_NUM < 110000
3073 call = ast->tech_pvt;
3075 call = ast_channel_tech_pvt(ast);
3078 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
3079 ast_mutex_unlock(&chan_lock);
3083 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
3084 memset(&newparam, 0, sizeof(union parameter));
3085 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
3086 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
3087 ast_mutex_unlock(&chan_lock);
3094 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
3095 struct ast_channel *ast2, int flags,
3096 struct ast_frame **fo,
3097 struct ast_channel **rc, int timeoutms)
3100 struct chan_call *call1, *call2;
3101 struct ast_channel *carr[2], *who;
3103 struct ast_frame *f;
3106 CDEBUG(NULL, NULL, "Received bridging request from Asterisk.\n");
3111 /* join via dsp (if the channels are currently open) */
3112 ast_mutex_lock(&chan_lock);
3113 #if ASTERISK_VERSION_NUM < 110000
3114 call1 = ast1->tech_pvt;
3115 call2 = ast2->tech_pvt;
3117 call1 = ast_channel_tech_pvt(ast1);
3118 call2 = ast_channel_tech_pvt(ast2);
3120 if (!call1 || !call2) {
3121 CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
3122 ast_mutex_unlock(&chan_lock);
3123 return AST_BRIDGE_COMPLETE;
3126 /* join, if both call instances uses dsp
3127 ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
3129 CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
3131 /* get bridge id and join */
3132 bridge_id = new_bridge_id();
3135 call1->bridge_id = bridge_id;
3136 if (call1->bchannel)
3137 bchannel_join(call1->bchannel, bridge_id);
3139 call2->bridge_id = bridge_id;
3140 if (call2->bchannel)
3141 bchannel_join(call2->bchannel, bridge_id);
3147 call1->bridge_call = call2;
3148 call2->bridge_call = call1;
3150 if (call1->state == CHAN_LCR_STATE_IN_SETUP
3151 || call1->state == CHAN_LCR_STATE_IN_DIALING
3152 || call1->state == CHAN_LCR_STATE_IN_PROCEEDING
3153 || call1->state == CHAN_LCR_STATE_IN_ALERTING) {
3154 CDEBUG(call1, ast1, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3157 if (call2->state == CHAN_LCR_STATE_IN_SETUP
3158 || call2->state == CHAN_LCR_STATE_IN_DIALING
3159 || call2->state == CHAN_LCR_STATE_IN_PROCEEDING
3160 || call2->state == CHAN_LCR_STATE_IN_ALERTING) {
3161 CDEBUG(call2, ast2, "Bridge established before lcr_answer, so we call it ourself: Calling lcr_answer...\n");
3165 /* sometimes SIP phones forget to send RETRIEVE before TRANSFER
3166 so let's do it for them. Hmpf.
3169 if (call1->on_hold) {
3170 union parameter newparam;
3172 memset(&newparam, 0, sizeof(union parameter));
3173 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3174 send_message(MESSAGE_NOTIFY, call1->ref, &newparam);
3179 if (call2->on_hold) {
3180 union parameter newparam;
3182 memset(&newparam, 0, sizeof(union parameter));
3183 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
3184 send_message(MESSAGE_NOTIFY, call2->ref, &newparam);
3189 ast_mutex_unlock(&chan_lock);
3193 who = ast_waitfor_n(carr, 2, &to);
3196 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
3201 if (!f || f->frametype == AST_FRAME_CONTROL) {
3203 CDEBUG(NULL, NULL, "Got hangup.\n");
3205 CDEBUG(NULL, NULL, "Got CONTROL.\n");
3212 if ( f->frametype == AST_FRAME_DTMF ) {
3213 CDEBUG(NULL, NULL, "Got DTMF.\n");
3229 CDEBUG(NULL, NULL, "Releasing bridge.\n");
3231 /* split channels */
3232 ast_mutex_lock(&chan_lock);
3233 #if ASTERISK_VERSION_NUM < 110000
3234 call1 = ast1->tech_pvt;
3235 call2 = ast2->tech_pvt;
3237 call1 = ast_channel_tech_pvt(ast1);
3238 call2 = ast_channel_tech_pvt(ast2);
3240 if (call1 && call1->bridge_id) {
3241 call1->bridge_id = 0;
3242 if (call1->bridge_call)
3243 call1->bridge_call->bridge_call = NULL;
3245 if (call2 && call1->bridge_id) {
3246 call2->bridge_id = 0;
3247 if (call2->bridge_call)
3248 call2->bridge_call->bridge_call = NULL;
3250 call1->bridge_call = NULL;
3251 call2->bridge_call = NULL;
3253 ast_mutex_unlock(&chan_lock);
3254 return AST_BRIDGE_COMPLETE;
3256 static struct ast_channel_tech lcr_tech = {
3258 .description = "Channel driver for connecting to Linux-Call-Router",
3259 #if ASTERISK_VERSION_NUM < 100000
3260 .capabilities = AST_FORMAT_ALAW,
3262 .requester = lcr_request,
3264 #ifdef LCR_FOR_ASTERISK
3265 .send_digit_begin = lcr_digit_begin,
3266 .send_digit_end = lcr_digit_end,
3269 #ifdef LCR_FOR_CALLWEAVER
3270 .send_digit = lcr_digit,
3274 .bridge = lcr_bridge,
3275 .hangup = lcr_hangup,
3276 .answer = lcr_answer,
3279 .indicate = lcr_indicate,
3281 .send_text = lcr_send_text,
3290 static int lcr_show_lcr (int fd, int argc, char *argv[])
3295 static int lcr_show_calls (int fd, int argc, char *argv[])
3300 static int lcr_reload_routing (int fd, int argc, char *argv[])
3305 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
3310 static int lcr_port_block (int fd, int argc, char *argv[])
3315 static int lcr_port_unblock (int fd, int argc, char *argv[])
3320 static int lcr_port_unload (int fd, int argc, char *argv[])
3325 static struct ast_cli_entry cli_show_lcr =
3326 { {"lcr", "show", "lcr", NULL},
3328 "Shows current states of LCR core",
3329 "Usage: lcr show lcr\n",
3332 static struct ast_cli_entry cli_show_calls =
3333 { {"lcr", "show", "calls", NULL},
3335 "Shows current calls made by LCR and Asterisk",
3336 "Usage: lcr show calls\n",
3339 static struct ast_cli_entry cli_reload_routing =
3340 { {"lcr", "reload", "routing", NULL},
3342 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
3343 "Usage: lcr reload routing\n",
3346 static struct ast_cli_entry cli_reload_interfaces =
3347 { {"lcr", "reload", "interfaces", NULL},
3348 lcr_reload_interfaces,
3349 "Reloads interfaces conf of LCR",
3350 "Usage: lcr reload interfaces\n",
3353 static struct ast_cli_entry cli_port_block =
3354 { {"lcr", "port", "block", NULL},
3356 "Blocks LCR port for further calls",
3357 "Usage: lcr port block \"<port>\"\n",
3360 static struct ast_cli_entry cli_port_unblock =
3361 { {"lcr", "port", "unblock", NULL},
3363 "Unblocks or loads LCR port, port is opened my mISDN",
3364 "Usage: lcr port unblock \"<port>\"\n",
3367 static struct ast_cli_entry cli_port_unload =
3368 { {"lcr", "port", "unload", NULL},
3370 "Unloads LCR port, port is closes by mISDN",
3371 "Usage: lcr port unload \"<port>\"\n",
3376 #ifdef LCR_FOR_ASTERISK
3377 #ifdef AST_1_8_OR_HIGHER
3378 static int lcr_config_exec(struct ast_channel *ast, const char *data)
3380 static int lcr_config_exec(struct ast_channel *ast, void *data)
3384 #ifdef LCR_FOR_CALLWEAVER
3385 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
3388 struct chan_call *call;
3390 ast_mutex_lock(&chan_lock);
3392 #ifdef LCR_FOR_ASTERISK
3393 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
3396 #ifdef LCR_FOR_CALLWEAVER
3397 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
3403 if (call->ast == ast)
3409 #ifdef LCR_FOR_ASTERISK
3410 apply_opt(call, (char *)data);
3413 #ifdef LCR_FOR_CALLWEAVER
3414 apply_opt(call, (char *)argv[0]);
3418 if (call->tx_queue) {
3419 union parameter newparam;
3421 memset(&newparam, 0, sizeof(union parameter));
3422 newparam.queue = call->tx_queue * 8;
3423 send_message(MESSAGE_DISABLE_DEJITTER, call->ref, &newparam);
3426 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
3428 ast_mutex_unlock(&chan_lock);
3433 * module loading and destruction
3435 int load_module(void)
3438 char options_error[256];
3440 for (i = 0; i < 256; i++) {
3441 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
3442 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
3445 if (read_options(options_error) == 0) {
3446 CERROR(NULL, NULL, "%s", options_error);
3448 #ifdef LCR_FOR_ASTERISK
3449 return AST_MODULE_LOAD_DECLINE;
3452 #ifdef LCR_FOR_CALLWEAVER
3458 ast_mutex_init(&chan_lock);
3459 ast_mutex_init(&log_lock);
3461 #if ASTERISK_VERSION_NUM < 100000
3462 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
3464 struct ast_format tmp;
3465 ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
3466 if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
3467 return AST_MODULE_LOAD_DECLINE;
3469 ast_format_cap_add(lcr_tech.capabilities, &tmp);
3471 if (ast_channel_register(&lcr_tech)) {
3472 CERROR(NULL, NULL, "Unable to register channel class\n");
3475 #ifdef LCR_FOR_ASTERISK
3476 return AST_MODULE_LOAD_DECLINE;
3479 #ifdef LCR_FOR_CALLWEAVER
3484 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
3486 #ifdef LCR_FOR_ASTERISK
3487 "lcr_config(<opt><optarg>:<opt>:...)\n"
3490 #ifdef LCR_FOR_CALLWEAVER
3491 "lcr_config(<opt><optarg>:<opt>:...)\n",
3494 "Sets LCR opts. and optargs\n"
3496 "The available options are:\n"
3497 " d - Send display text on called phone, text is the optarg.\n"
3498 " n - Don't detect dtmf tones on called channel.\n"
3499 " h - Force data call (HDLC).\n"
3500 " q - Add queue to make fax stream seamless (required for fax app).\n"
3501 " Use queue size in miliseconds for optarg. (try 250)\n"
3502 " f - Adding fax detection. It it timeouts, mISDN_dsp is used.\n"
3503 " Use time to detect for optarg.\n"
3505 " c - Make crypted outgoing call, optarg is keyindex.\n"
3506 " e - Perform echo cancelation on this channel.\n"
3508 " Takes mISDN pipeline option as optarg.\n"
3509 " s - Send Non Inband DTMF as inband.\n"
3510 " r - re-buffer packets (160 bytes). Required for some SIP-phones and fax applications.\n"
3512 " vr - rxgain control\n"
3513 " vt - txgain control\n"
3515 " Volume changes at factor 2 ^ optarg.\n"
3516 " k - use keypad to dial this call.\n"
3518 "set LCR_TRANSFERCAPABILITY to the numerical bearer capabilty in order to alter caller's capability\n"
3519 " -> use 16 for fax (3.1k audio)\n"
3521 "To send a fax, you need to set LCR_TRANSFERCAPABILITY environment to 16, also you need to set\n"
3522 "options: \"n:t:q250\" for seamless audio transmission.\n"
3527 ast_cli_register(&cli_show_lcr);
3528 ast_cli_register(&cli_show_calls);
3529 ast_cli_register(&cli_reload_routing);
3530 ast_cli_register(&cli_reload_interfaces);
3531 ast_cli_register(&cli_port_block);
3532 ast_cli_register(&cli_port_unblock);
3533 ast_cli_register(&cli_port_unload);
3536 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
3537 /* failed to create thread */
3539 ast_channel_unregister(&lcr_tech);
3541 #ifdef LCR_FOR_ASTERISK
3542 return AST_MODULE_LOAD_DECLINE;
3545 #ifdef LCR_FOR_CALLWEAVER
3553 int unload_module(void)
3555 /* First, take us out of the channel loop */
3556 CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
3558 pthread_cancel(chan_tid);
3562 del_timer(&socket_retry);
3564 unregister_fd(&wake_fd);
3565 close(wake_pipe[0]);
3566 close(wake_pipe[1]);
3568 // ast_mutex_unlock(&chan_lock);
3570 ast_channel_unregister(&lcr_tech);
3572 ast_unregister_application("lcr_config");
3574 if (lcr_sock >= 0) {
3579 #if ASTERISK_VERSION_NUM >= 100000
3580 lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
3585 int reload_module(void)
3591 #ifdef LCR_FOR_ASTERISK
3592 #define AST_MODULE "chan_lcr"
3595 #ifdef LCR_FOR_CALLWEAVER
3600 ast_mutex_lock(&usecnt_lock);
3602 ast_mutex_unlock(&usecnt_lock);
3607 #ifdef LCR_FOR_ASTERISK
3608 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
3609 .load = load_module,
3610 .unload = unload_module,
3611 .reload = reload_module,
3615 #ifdef LCR_FOR_CALLWEAVER
3616 char *description(void)