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 A new chan_call instance is created. The call reference (ref) is given by
25 MESSAGE_NEWREF. The state is CHAN_LCR_STATE_IN_PREPARE.
26 After receiving MESSAGE_SETUP from LCR, the ast_channel instance is created
27 using ast_channel_alloc(1). The setup information is given to asterisk.
28 The new Asterisk instance pointer (ast) is stored to chan_call structure.
29 The state changes to CHAN_LCR_STATE_IN_SETUP.
32 Call is initiated by Asterisk:
34 If a call is requested from Asterisk, a new chan_call instance is created.
35 The new Asterisk instance pointer (ast) is stored to chan_call structure.
36 The current call ref is set to 0, the state is CHAN_LCR_STATE_OUT_PREPARE.
37 If the call is received (lcr_call) A MESSASGE_NEWREF is sent to LCR requesting
38 a new call reference (ref).
39 Further dialing information is queued.
40 After the new callref is received by special MESSAGE_NEWREF reply, new ref
41 is stored in the chan_call structure.
42 The setup information is sent to LCR using MESSAGE_SETUP.
43 The state changes to CHAN_LCR_STATE_OUT_SETUP.
48 During call process, messages are received and sent.
49 The state changes accordingly.
50 Any message is allowed to be sent to LCR at any time except MESSAGE_RELEASE.
51 If a MESSAGE_OVERLAP is received, further dialing is required.
52 Queued dialing information, if any, is sent to LCR using MESSAGE_DIALING.
53 In this case, the state changes to CHAN_LCR_STATE_OUT_DIALING.
56 Call is released by LCR:
58 A MESSAGE_RELEASE is received with the call reference (ref) to be released.
59 The current ref is set to 0, to indicate released reference.
60 The state changes to CHAN_LCR_STATE_RELEASE.
61 ast_queue_hangup() is called, if asterisk instance (ast) exists, if not,
62 the chan_call instance is destroyed.
63 After lcr_hangup() is called-back by Asterisk, the chan_call instance
64 is destroyed, because the current ref is set to 0 and the state equals
65 CHAN_LCR_STATE_RELEASE.
66 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, see the proceedure
67 "Call is released by Asterisk".
70 Call is released by Asterisk:
72 lcr_hangup() is called-back by Asterisk. If the call reference (ref) is set,
73 a MESSAGE_RELEASE is sent to LCR and the chan_call instance is destroyed.
74 If the ref is 0 and the state is not CHAN_LCR_STATE_RELEASE, the new state is
75 set to CHAN_LCR_STATE_RELEASE.
76 Later, if the MESSAGE_NEWREF reply is received, a MESSAGE_RELEASE is sent to
77 LCR and the chan_call instance is destroyed.
78 If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure
79 "Call is released by LCR".
84 The deadlocking problem:
86 - chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel
88 - ast_channel thread locks ast_channel and calls a tech function and waits
89 there for chan_lock to be unlocked.
93 Never call ast_queue_xxxx() if ast_channel is not locked and don't wait until
94 ast_channel can be locked. All messages to asterisk are queued inside call
95 instance and will be handled using a try-lock to get ast_channel lock.
96 If it succeeds to lock ast_channel, the ast_queue_xxxx can safely called even
97 if the lock is incremented and decremented there.
99 Exception: Calling ast_queue_frame inside ast->tech->read is safe, because
100 it is called from ast_channel process which has already locked ast_channel.
109 #include <sys/types.h>
111 //#include <signal.h>
114 #include <sys/ioctl.h>
115 #include <sys/socket.h>
118 #include <semaphore.h>
120 #include <asterisk/module.h>
121 #include <asterisk/channel.h>
122 #include <asterisk/config.h>
123 #include <asterisk/logger.h>
124 #include <asterisk/pbx.h>
125 #include <asterisk/options.h>
126 #include <asterisk/io.h>
127 #include <asterisk/frame.h>
128 #include <asterisk/translate.h>
129 #include <asterisk/cli.h>
130 #include <asterisk/musiconhold.h>
131 #include <asterisk/dsp.h>
132 #include <asterisk/translate.h>
133 #include <asterisk/file.h>
134 #include <asterisk/callerid.h>
135 #include <asterisk/indications.h>
136 #include <asterisk/app.h>
137 #include <asterisk/features.h>
138 #include <asterisk/sched.h>
140 #include "extension.h"
142 #include "callerid.h"
143 #include "lcrsocket.h"
145 #include "bchannel.h"
147 #include "chan_lcr.h"
149 CHAN_LCR_STATE // state description structure
150 MESSAGES // message text
152 unsigned char flip_bits[256];
157 char lcr_type[]="lcr";
160 ast_mutex_t chan_lock; /* global lock */
161 ast_mutex_t log_lock; /* logging log */
164 int glob_channel = 0;
169 struct admin_list *next;
170 struct admin_message msg;
171 } *admin_first = NULL;
173 static struct ast_channel_tech lcr_tech;
178 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, ...)
181 char call_text[128] = "NULL";
182 char ast_text[128] = "NULL";
185 ast_mutex_lock(&log_lock);
188 vsnprintf(buffer,sizeof(buffer)-1,fmt,args);
189 buffer[sizeof(buffer)-1]=0;
193 sprintf(call_text, "%d", call->ref);
195 strncpy(ast_text, ast->name, sizeof(ast_text)-1);
196 ast_text[sizeof(ast_text)-1] = '\0';
198 ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
200 ast_mutex_unlock(&log_lock);
204 * channel and call instances
206 struct chan_call *call_first;
208 struct chan_call *find_call_ref(unsigned int ref)
210 struct chan_call *call = call_first;
214 if (call->ref == ref)
222 struct chan_call *find_call_ast(struct ast_channel *ast)
224 struct chan_call *call = call_first;
228 if (call->ast == ast)
235 struct chan_call *find_call_handle(unsigned int handle)
237 struct chan_call *call = call_first;
241 if (call->bchannel_handle == handle)
249 void free_call(struct chan_call *call)
251 struct chan_call **temp = &call_first;
257 *temp = (*temp)->next;
258 if (call->pipe[0] > -1)
259 close(call->pipe[0]);
260 if (call->pipe[1] > -1)
261 close(call->pipe[1]);
264 if (call->bchannel->call != call)
265 CERROR(call, NULL, "Linked bchannel structure has no link to us.\n");
266 call->bchannel->call = NULL;
268 if (call->bridge_call)
270 if (call->bridge_call->bridge_call != call)
271 CERROR(call, NULL, "Linked call structure has no link to us.\n");
272 call->bridge_call->bridge_call = NULL;
274 CDEBUG(call, NULL, "Call instance freed.\n");
278 temp = &((*temp)->next);
280 CERROR(call, NULL, "Call instance not found in list.\n");
283 struct chan_call *alloc_call(void)
285 struct chan_call **callp = &call_first;
288 callp = &((*callp)->next);
290 *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call));
292 memset(*callp, 0, sizeof(struct chan_call));
293 if (pipe((*callp)->pipe) < 0) {
294 CERROR(*callp, NULL, "Failed to create pipe.\n");
298 CDEBUG(*callp, NULL, "Call instance allocated.\n");
303 unsigned short new_bridge_id(void)
305 struct chan_call *call;
306 unsigned short id = 1;
308 /* search for lowest bridge id that is not in use and not 0 */
314 if (call->bridge_id == id)
322 CDEBUG(NULL, NULL, "New bridge ID %d.\n", id);
327 * enque message to LCR
329 int send_message(int message_type, unsigned int ref, union parameter *param)
331 struct admin_list *admin, **adminp;
334 CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type);
337 CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]);
339 adminp = &admin_first;
341 adminp = &((*adminp)->next);
342 admin = (struct admin_list *)calloc(1, sizeof(struct admin_list));
344 CERROR(NULL, NULL, "No memory for message to LCR.\n");
349 admin->msg.message = ADMIN_MESSAGE;
350 admin->msg.u.msg.type = message_type;
351 admin->msg.u.msg.ref = ref;
352 memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter));
358 * apply options (in locked state)
360 void apply_opt(struct chan_call *call, char *data)
362 union parameter newparam;
363 char string[1024], *p = string, *opt, *key;
364 int gain, i, newmode = 0;
369 strncpy(string, data, sizeof(string)-1);
370 string[sizeof(string)-1] = '\0';
373 while((opt = strsep(&p, ":")))
377 if (opt[1] == '\0') {
378 CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt);
381 CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1);
382 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
383 strncpy(call->display, opt+1, sizeof(call->display)-1);
385 memset(&newparam, 0, sizeof(union parameter));
386 strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1);
387 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
391 if (opt[1] != '\0') {
392 CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt);
395 CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n");
399 if (opt[1] == '\0') {
400 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt);
404 /* check for 0xXXXX... type of key */
405 if (!!strncmp((char *)key, "0x", 2)) {
406 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt);
410 if (strlen(key) > 56*2 || (strlen(key) % 1)) {
411 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt);
417 if (*key>='0' && *key<='9')
418 call->bf_key[i] = (*key-'0') << 8;
419 else if (*key>='a' && *key<='f')
420 call->bf_key[i] = (*key-'a'+10) << 8;
421 else if (*key>='A' && *key<='F')
422 call->bf_key[i] = (*key-'A'+10) << 8;
426 if (*key>='0' && *key<='9')
427 call->bf_key[i] += (*key - '0');
428 else if (*key>='a' && *key<='f')
429 call->bf_key[i] += (*key - 'a' + 10);
430 else if (*key>='A' && *key<='F')
431 call->bf_key[i] += (*key - 'A' + 10);
438 CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n");
442 CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i);
444 bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len);
447 if (opt[1] != '\0') {
448 CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt);
451 CDEBUG(call, call->ast, "Option 'h' (HDLC).\n");
458 if (opt[1] != '\0') {
459 CERROR(call, call->ast, "Option 't' (transparent) expects no parameter.\n", opt);
462 CDEBUG(call, call->ast, "Option 't' (transparent).\n");
463 if (!call->transparent) {
464 call->transparent = 1;
469 if (opt[1] == '\0') {
470 CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt);
473 CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1);
474 strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1);
476 bchannel_pipeline(call->bchannel, call->pipeline);
479 if (opt[1] == '\0') {
480 CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt);
483 CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)");
488 if (opt[1] != '\0') {
489 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
492 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
493 call->inband_dtmf = 1;
498 if (opt[1] != 'r' && opt[1] != 't') {
499 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
503 if (gain < -8 || gain >8) {
504 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
507 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
509 call->rx_gain = gain;
511 bchannel_gain(call->bchannel, call->rx_gain, 0);
513 call->tx_gain = gain;
515 bchannel_gain(call->bchannel, call->tx_gain, 1);
519 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
523 /* re-open, if bchannel is created */
524 if (call->bchannel && call->bchannel->b_sock > -1) {
525 bchannel_destroy(call->bchannel);
526 if (bchannel_create(call->bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0)))
527 bchannel_activate(call->bchannel, 1);
532 * send setup info to LCR
533 * this function is called, when asterisk call is received and ref is received
535 static void send_setup_to_lcr(struct chan_call *call)
537 union parameter newparam;
538 struct ast_channel *ast = call->ast;
540 if (!call->ast || !call->ref)
543 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
545 /* send setup message to LCR */
546 memset(&newparam, 0, sizeof(union parameter));
547 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
548 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
549 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
550 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
551 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
552 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
553 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
554 call->display[0] = '\0';
555 if (call->cid_num[0])
556 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
557 if (call->cid_name[0])
558 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
559 if (call->cid_rdnis[0])
561 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
562 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
563 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
565 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION)
567 case AST_PRES_ALLOWED:
568 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
570 case AST_PRES_RESTRICTED:
571 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
573 case AST_PRES_UNAVAILABLE:
574 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
577 newparam.setup.callerinfo.present = INFO_PRESENT_NULL;
579 switch(ast->cid.cid_ton)
582 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
585 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
588 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
591 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
593 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
594 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
595 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
596 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
597 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
598 send_message(MESSAGE_SETUP, call->ref, &newparam);
600 /* change to outgoing setup state */
601 call->state = CHAN_LCR_STATE_OUT_SETUP;
605 * send dialing info to LCR
606 * this function is called, when setup acknowledge is received and dialing
609 static void send_dialque_to_lcr(struct chan_call *call)
611 union parameter newparam;
613 if (!call->ast || !call->ref || !call->dialque[0])
616 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
618 /* send setup message to LCR */
619 memset(&newparam, 0, sizeof(union parameter));
620 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
621 call->dialque[0] = '\0';
622 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
626 * in case of a bridge, the unsupported message can be forwarded directly
627 * to the remote call.
629 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
633 if (!call->bridge_call) return;
634 CDEBUG(call, NULL, "Sending message due briding.\n");
635 send_message(message_type, call->bridge_call->ref, param);
639 * send release message to LCR and import bchannel if exported
641 static void send_release_and_import(struct chan_call *call, int cause, int location)
643 union parameter newparam;
645 /* importing channel */
646 if (call->bchannel) {
647 memset(&newparam, 0, sizeof(union parameter));
648 newparam.bchannel.type = BCHANNEL_RELEASE;
649 newparam.bchannel.handle = call->bchannel->handle;
650 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
652 /* sending release */
653 memset(&newparam, 0, sizeof(union parameter));
654 newparam.disconnectinfo.cause = cause;
655 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
656 send_message(MESSAGE_RELEASE, call->ref, &newparam);
660 * check if extension matches and start asterisk
661 * if it can match, proceed
664 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
667 union parameter newparam;
669 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", ast->exten, ast->context, complete?"yes":"no");
674 if (!ast_canmatch_extension(ast, ast->context, ast->exten, 1, call->oad))
676 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", ast->exten, ast->context);
680 if (!ast_exists_extension(ast, ast->context, ast->exten, 1, call->oad))
682 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' would match at context '%s', if more digits would be dialed - releasing.\n", ast->exten, ast->context);
686 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
687 /* send setup acknowledge to lcr */
688 memset(&newparam, 0, sizeof(union parameter));
689 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
692 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
697 if (ast_canmatch_extension(ast, ast->context, ast->exten, 1, call->oad))
699 /* send setup acknowledge to lcr */
700 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
701 memset(&newparam, 0, sizeof(union parameter));
702 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
706 call->state = CHAN_LCR_STATE_IN_DIALING;
708 /* if match, start pbx */
709 if (ast_exists_extension(ast, ast->context, ast->exten, 1, call->oad)) {
710 CDEBUG(call, ast, "Extensions matches.\n");
715 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
723 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
724 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
726 /* release asterisk */
727 ast->hangupcause = call->cause;
728 /* change to release state */
729 call->state = CHAN_LCR_STATE_RELEASE;
730 ast_hangup(ast); // call will be destroyed here
734 /* send setup to asterisk */
735 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
736 ret = ast_pbx_start(ast);
739 cause = (ret==-2)?34:27;
742 call->pbx_started = 1;
747 * incoming setup from LCR
749 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
751 struct ast_channel *ast;
753 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
755 /* create asterisk channel instrance */
756 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
760 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
761 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
768 ast->tech_pvt = call;
769 ast->tech = &lcr_tech;
770 ast->fds[0] = call->pipe[0];
772 /* fill setup information */
773 if (param->setup.dialinginfo.id)
774 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
775 if (param->setup.context[0])
776 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
778 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
779 if (param->setup.callerinfo.id[0])
780 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
781 if (param->setup.callerinfo.name[0])
782 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
783 if (param->setup.redirinfo.id[0])
784 ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
785 switch (param->setup.callerinfo.present)
787 case INFO_PRESENT_ALLOWED:
788 ast->cid.cid_pres = AST_PRES_ALLOWED;
790 case INFO_PRESENT_RESTRICTED:
791 ast->cid.cid_pres = AST_PRES_RESTRICTED;
794 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
796 switch (param->setup.callerinfo.ntype)
798 case INFO_NTYPE_SUBSCRIBER:
799 ast->cid.cid_ton = 4;
801 case INFO_NTYPE_NATIONAL:
802 ast->cid.cid_ton = 2;
804 case INFO_NTYPE_INTERNATIONAL:
805 ast->cid.cid_ton = 1;
808 ast->cid.cid_ton = 0;
810 ast->transfercapability = param->setup.capainfo.bearer_capa;
811 /* enable hdlc if transcap is data */
812 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
813 || ast->transfercapability == INFO_BC_DATARESTRICTED
814 || ast->transfercapability == INFO_BC_VIDEO)
816 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
818 /* configure channel */
819 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
820 ast->readformat = ast->rawreadformat = ast->nativeformats;
821 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
823 ast->hangupcause = 0;
826 call->state = CHAN_LCR_STATE_IN_SETUP;
828 if (!call->pbx_started)
829 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
833 * incoming setup acknowledge from LCR
835 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
837 if (!call->ast) return;
839 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
841 /* send pending digits in dialque */
842 if (call->dialque[0])
843 send_dialque_to_lcr(call);
844 /* change to overlap state */
845 call->state = CHAN_LCR_STATE_OUT_DIALING;
849 * incoming proceeding from LCR
851 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
853 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
856 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
857 /* queue event for asterisk */
858 if (call->ast && call->pbx_started)
859 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
863 * incoming alerting from LCR
865 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
867 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
870 call->state = CHAN_LCR_STATE_OUT_ALERTING;
871 /* queue event to asterisk */
872 if (call->ast && call->pbx_started)
873 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
877 * incoming connect from LCR
879 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
881 union parameter newparam;
883 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
886 call->state = CHAN_LCR_STATE_CONNECT;
887 /* request bchannel */
888 if (!call->bchannel) {
889 CDEBUG(call, call->ast, "Requesting B-channel.\n");
890 memset(&newparam, 0, sizeof(union parameter));
891 newparam.bchannel.type = BCHANNEL_REQUEST;
892 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
894 /* copy connectinfo */
895 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
896 /* queue event to asterisk */
897 if (call->ast && call->pbx_started)
898 strncat(call->queue_string, "A", sizeof(call->queue_string)-1);
902 * incoming disconnect from LCR
904 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
906 struct ast_channel *ast = call->ast;
908 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
911 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
913 call->cause = param->disconnectinfo.cause;
914 call->location = param->disconnectinfo.location;
915 /* if bridge, forward disconnect and return */
918 if (call->bridge_call)
920 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
921 bridge_message_if_bridged(call, message_type, param);
925 /* release lcr with same cause */
926 send_release_and_import(call, call->cause, call->location);
928 /* change to release state */
929 call->state = CHAN_LCR_STATE_RELEASE;
930 /* queue release asterisk */
933 ast->hangupcause = call->cause;
934 if (call->pbx_started)
935 strcpy(call->queue_string, "H"); // overwrite other indications
937 ast_hangup(ast); // call will be destroyed here
943 * incoming setup acknowledge from LCR
945 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
947 struct ast_channel *ast = call->ast;
949 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
953 /* change to release state */
954 call->state = CHAN_LCR_STATE_RELEASE;
955 /* copy release info */
958 call->cause = param->disconnectinfo.cause;
959 call->location = param->disconnectinfo.location;
961 /* if we have an asterisk instance, queue hangup, else we are done */
964 ast->hangupcause = call->cause;
965 if (call->pbx_started)
966 strcpy(call->queue_string, "H");
968 ast_hangup(ast); // call will be destroyed here
978 * incoming information from LCR
980 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
982 struct ast_channel *ast = call->ast;
984 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
988 /* pbx not started */
989 if (!call->pbx_started)
991 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
992 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
993 lcr_start_pbx(call, ast, param->information.sending_complete);
998 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0])
999 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
1001 /* use bridge to forware message not supported by asterisk */
1002 if (call->state == CHAN_LCR_STATE_CONNECT) {
1003 CDEBUG(call, call->ast, "Call is connected, briding.\n");
1004 bridge_message_if_bridged(call, message_type, param);
1009 * incoming information from LCR
1011 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1013 union parameter newparam;
1015 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1017 /* request bchannel, if call is resumed and we don't have it */
1018 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1019 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1020 memset(&newparam, 0, sizeof(union parameter));
1021 newparam.bchannel.type = BCHANNEL_REQUEST;
1022 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1025 if (!call->ast) return;
1027 /* use bridge to forware message not supported by asterisk */
1028 bridge_message_if_bridged(call, message_type, param);
1032 * incoming information from LCR
1034 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1036 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1038 if (!call->ast) return;
1040 /* use bridge to forware message not supported by asterisk */
1041 bridge_message_if_bridged(call, message_type, param);
1045 * got dtmf from bchannel (locked state)
1047 void lcr_in_dtmf(struct chan_call *call, int val)
1049 struct ast_channel *ast = call->ast;
1054 if (!call->pbx_started)
1057 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1060 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1064 * message received from LCR
1066 int receive_message(int message_type, unsigned int ref, union parameter *param)
1068 struct bchannel *bchannel;
1069 struct chan_call *call;
1070 union parameter newparam;
1072 memset(&newparam, 0, sizeof(union parameter));
1074 /* handle bchannel message*/
1075 if (message_type == MESSAGE_BCHANNEL)
1077 switch(param->bchannel.type)
1079 case BCHANNEL_ASSIGN:
1080 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1081 if ((bchannel = find_bchannel_handle(param->bchannel.handle)))
1083 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1086 /* create bchannel */
1087 bchannel = alloc_bchannel(param->bchannel.handle);
1090 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1094 /* configure channel */
1095 bchannel->b_tx_gain = param->bchannel.tx_gain;
1096 bchannel->b_rx_gain = param->bchannel.rx_gain;
1097 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1098 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key))
1100 bchannel->b_bf_len = param->bchannel.crypt_len;
1101 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1103 bchannel->b_txdata = 0;
1104 bchannel->b_dtmf = 1;
1105 bchannel->b_tx_dejitter = 1;
1107 /* in case, ref is not set, this bchannel instance must
1108 * be created until it is removed again by LCR */
1110 call = find_call_ref(ref);
1113 bchannel->call = call;
1114 call->bchannel = bchannel;
1116 bchannel_dtmf(bchannel, 1);
1118 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1119 if (call->pipeline[0])
1120 bchannel_pipeline(bchannel, call->pipeline);
1122 bchannel_gain(bchannel, call->rx_gain, 0);
1124 bchannel_gain(bchannel, call->tx_gain, 1);
1125 if (call->bridge_id) {
1126 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1127 bchannel_join(bchannel, call->bridge_id);
1129 /* create only, if call exists, othewhise it bchannel is freed below... */
1130 if (bchannel_create(bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0)))
1131 bchannel_activate(bchannel, 1);
1134 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1135 newparam.bchannel.handle = param->bchannel.handle;
1136 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1137 /* if call has released before bchannel is assigned */
1139 newparam.bchannel.type = BCHANNEL_RELEASE;
1140 newparam.bchannel.handle = param->bchannel.handle;
1141 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1146 case BCHANNEL_REMOVE:
1147 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1148 if (!(bchannel = find_bchannel_handle(param->bchannel.handle)))
1150 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1153 /* unklink from call and destroy bchannel */
1154 free_bchannel(bchannel);
1157 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1158 newparam.bchannel.handle = param->bchannel.handle;
1159 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1164 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1169 /* handle new ref */
1170 if (message_type == MESSAGE_NEWREF)
1172 if (param->direction)
1174 /* new ref from lcr */
1175 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1176 if (!ref || find_call_ref(ref))
1178 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1181 /* allocate new call instance */
1182 call = alloc_call();
1184 call->state = CHAN_LCR_STATE_IN_PREPARE;
1187 /* wait for setup (or release from asterisk) */
1190 /* new ref, as requested from this remote application */
1191 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1192 call = find_call_ref(0);
1195 /* send release, if ref does not exist */
1196 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1197 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1202 /* send pending setup info */
1203 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1204 send_setup_to_lcr(call);
1205 /* release if asterisk has signed off */
1206 else if (call->state == CHAN_LCR_STATE_RELEASE)
1210 send_release_and_import(call, call->cause, call->location);
1212 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1224 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1227 call = find_call_ref(ref);
1230 /* ignore ref that is not used (anymore) */
1231 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1235 /* handle messages */
1236 switch(message_type)
1239 lcr_in_setup(call, message_type, param);
1242 case MESSAGE_OVERLAP:
1243 lcr_in_overlap(call, message_type, param);
1246 case MESSAGE_PROCEEDING:
1247 lcr_in_proceeding(call, message_type, param);
1250 case MESSAGE_ALERTING:
1251 lcr_in_alerting(call, message_type, param);
1254 case MESSAGE_CONNECT:
1255 lcr_in_connect(call, message_type, param);
1258 case MESSAGE_DISCONNECT:
1259 lcr_in_disconnect(call, message_type, param);
1262 case MESSAGE_RELEASE:
1263 lcr_in_release(call, message_type, param);
1266 case MESSAGE_INFORMATION:
1267 lcr_in_information(call, message_type, param);
1270 case MESSAGE_NOTIFY:
1271 lcr_in_notify(call, message_type, param);
1274 case MESSAGE_FACILITY:
1275 lcr_in_facility(call, message_type, param);
1278 case MESSAGE_PATTERN: // audio available from LCR
1281 case MESSAGE_NOPATTERN: // audio not available from LCR
1284 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1285 call->audiopath = param->audiopath;
1289 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1296 * release all calls (due to broken socket)
1298 static void release_all_calls(void)
1300 struct chan_call *call;
1305 /* no ast, so we may directly free call */
1307 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1311 /* already in release process */
1312 if (call->state == CHAN_LCR_STATE_RELEASE) {
1316 /* release or queue release */
1318 call->state = CHAN_LCR_STATE_RELEASE;
1319 if (!call->pbx_started) {
1320 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1321 ast_hangup(call->ast); // call will be destroyed here
1324 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1325 strcpy(call->queue_string, "H");
1329 /* release all bchannels */
1330 while(bchannel_first)
1331 free_bchannel(bchannel_first);
1336 * warning! not thread safe
1337 * returns -1 for socket error, 0 for no work, 1 for work
1339 int handle_socket(void)
1343 struct admin_list *admin;
1344 struct admin_message msg;
1346 /* read from socket */
1347 len = read(lcr_sock, &msg, sizeof(msg));
1350 CERROR(NULL, NULL, "Socket closed.\n");
1351 return(-1); // socket closed
1355 if (len != sizeof(msg))
1357 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1358 return(-1); // socket error
1360 if (msg.message != ADMIN_MESSAGE)
1362 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1365 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1369 if (errno != EWOULDBLOCK)
1371 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1376 /* write to socket */
1379 admin = admin_first;
1380 len = write(lcr_sock, &admin->msg, sizeof(msg));
1383 CERROR(NULL, NULL, "Socket closed.\n");
1384 return(-1); // socket closed
1388 if (len != sizeof(msg))
1390 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1391 return(-1); // socket error
1394 admin_first = admin->next;
1400 if (errno != EWOULDBLOCK)
1402 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1411 * open and close socket and thread
1413 int open_socket(void)
1416 char *socket_name = SOCKET_NAME;
1418 struct sockaddr_un sock_address;
1419 unsigned int on = 1;
1420 union parameter param;
1423 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1425 CERROR(NULL, NULL, "Failed to create socket.\n");
1429 /* set socket address and name */
1430 memset(&sock_address, 0, sizeof(sock_address));
1431 sock_address.sun_family = PF_UNIX;
1432 strcpy(sock_address.sun_path, socket_name);
1434 /* connect socket */
1435 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0)
1439 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1443 /* set non-blocking io */
1444 if ((ret = ioctl(lcr_sock, FIONBIO, (unsigned char *)(&on))) < 0)
1448 CERROR(NULL, NULL, "Failed to set socket into non-blocking IO.\n");
1452 /* enque hello message */
1453 memset(¶m, 0, sizeof(param));
1454 strcpy(param.hello.application, "asterisk");
1455 send_message(MESSAGE_HELLO, 0, ¶m);
1460 void close_socket(void)
1462 struct admin_list *admin, *temp;
1464 /* flush pending messages */
1465 admin = admin_first;
1468 admin = admin->next;
1480 /* sending queue to asterisk */
1481 static int queue_send(void)
1484 struct chan_call *call;
1485 struct ast_channel *ast;
1486 struct ast_frame fr;
1491 p = call->queue_string;
1494 /* there is something to queue */
1495 if (!ast_channel_trylock(ast)) { /* succeed */
1499 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1500 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1503 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1504 ast_queue_control(ast, AST_CONTROL_RINGING);
1507 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1508 ast_queue_control(ast, AST_CONTROL_ANSWER);
1511 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1512 ast_queue_hangup(ast);
1514 case '1': case '2': case '3': case 'a':
1515 case '4': case '5': case '6': case 'b':
1516 case '7': case '8': case '9': case 'c':
1517 case '*': case '0': case '#': case 'd':
1518 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1519 /* send digit to asterisk */
1520 memset(&fr, 0, sizeof(fr));
1521 fr.frametype = AST_FRAME_DTMF;
1523 fr.delivery = ast_tv(0, 0);
1525 ast_queue_frame(ast, &fr);
1528 CDEBUG(call, ast, "Ignoring queued digit 0x%02d.\n", *p);
1532 call->queue_string[0] = '\0';
1533 ast_channel_unlock(ast);
1543 /* signal handler */
1544 void sighandler(int sigset)
1548 /* chan_lcr thread */
1549 static void *chan_thread(void *arg)
1553 union parameter param;
1554 time_t retry = 0, now;
1556 bchannel_pid = getpid();
1558 // signal(SIGPIPE, sighandler);
1560 memset(¶m, 0, sizeof(union parameter));
1564 ast_mutex_lock(&chan_lock);
1571 ret = handle_socket();
1573 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1575 release_all_calls();
1582 if (retry && now-retry > 5) {
1583 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1585 if (open_socket() < 0) {
1594 ret = bchannel_handle();
1598 /* handle messages to asterisk */
1603 /* delay if no work done */
1605 ast_mutex_unlock(&chan_lock);
1607 ast_mutex_lock(&chan_lock);
1613 CERROR(NULL, NULL, "Thread exit.\n");
1615 ast_mutex_unlock(&chan_lock);
1617 // signal(SIGPIPE, SIG_DFL);
1623 * new asterisk instance
1626 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1628 char exten[256], *dial, *interface, *opt;
1629 struct ast_channel *ast;
1630 struct chan_call *call;
1632 ast_mutex_lock(&chan_lock);
1633 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1635 /* if socket is closed */
1638 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1639 ast_mutex_unlock(&chan_lock);
1643 /* create call instance */
1644 call = alloc_call();
1647 /* failed to create instance */
1648 ast_mutex_unlock(&chan_lock);
1652 /* create asterisk channel instrance */
1653 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1656 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1658 /* failed to create instance */
1659 ast_mutex_unlock(&chan_lock);
1662 ast->tech = &lcr_tech;
1663 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1664 /* configure channel */
1665 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1666 ast->readformat = ast->rawreadformat = ast->nativeformats;
1667 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1669 ast->hangupcause = 0;
1673 ast->tech_pvt = call;
1674 ast->fds[0] = call->pipe[0];
1675 call->pbx_started = 0;
1677 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1680 * Extract interface, dialstring, options from data.
1683 * <interface>/<dialstring>
1684 * <interface>/<dialstring>/options
1686 strncpy(exten, (char *)data, sizeof(exten)-1);
1687 exten[sizeof(exten)-1] = '\0';
1688 if ((dial = strchr(exten, '/'))) {
1691 if ((opt = strchr(dial, '/')))
1700 strncpy(call->interface, interface, sizeof(call->interface)-1);
1701 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1702 apply_opt(call, (char *)opt);
1704 ast_mutex_unlock(&chan_lock);
1709 * call from asterisk
1711 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1713 union parameter newparam;
1714 struct chan_call *call;
1716 ast_mutex_lock(&chan_lock);
1717 call = ast->tech_pvt;
1719 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1720 ast_mutex_unlock(&chan_lock);
1724 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1726 /* pbx process is started */
1727 call->pbx_started = 1;
1728 /* send MESSAGE_NEWREF */
1729 memset(&newparam, 0, sizeof(union parameter));
1730 newparam.direction = 0; /* request from app */
1731 send_message(MESSAGE_NEWREF, 0, &newparam);
1733 /* set hdlc if capability requires hdlc */
1734 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1735 || ast->transfercapability == INFO_BC_DATARESTRICTED
1736 || ast->transfercapability == INFO_BC_VIDEO)
1738 /* if hdlc is forced by option, we change transcap to data */
1740 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1741 && ast->transfercapability != INFO_BC_DATARESTRICTED
1742 && ast->transfercapability != INFO_BC_VIDEO)
1743 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1745 call->cid_num[0] = 0;
1746 call->cid_name[0] = 0;
1747 call->cid_rdnis[0] = 0;
1749 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1750 strncpy(call->cid_num, ast->cid.cid_num,
1751 sizeof(call->cid_num)-1);
1753 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1754 strncpy(call->cid_name, ast->cid.cid_name,
1755 sizeof(call->cid_name)-1);
1756 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1757 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1758 sizeof(call->cid_rdnis)-1);
1760 ast_mutex_unlock(&chan_lock);
1764 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1766 struct chan_call *call;
1767 union parameter newparam;
1770 /* only pass IA5 number space */
1771 if (digit > 126 || digit < 32)
1774 ast_mutex_lock(&chan_lock);
1775 call = ast->tech_pvt;
1777 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
1778 ast_mutex_unlock(&chan_lock);
1782 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
1784 /* send information or queue them */
1785 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING)
1787 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
1788 memset(&newparam, 0, sizeof(union parameter));
1789 newparam.information.id[0] = digit;
1790 newparam.information.id[1] = '\0';
1791 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
1794 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP))
1796 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
1798 strncat(call->dialque, buf, strlen(call->dialque)-1);
1801 ast_mutex_unlock(&chan_lock);
1805 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
1807 printf("DIGIT END %c\n", digit);
1811 static int lcr_answer(struct ast_channel *ast)
1813 union parameter newparam;
1814 struct chan_call *call;
1816 ast_mutex_lock(&chan_lock);
1817 call = ast->tech_pvt;
1819 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
1820 ast_mutex_unlock(&chan_lock);
1824 CDEBUG(call, ast, "Received answer from Asterisk.\n");
1826 /* copy connectinfo, if bridged */
1827 if (call->bridge_call)
1828 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
1829 /* send connect message to lcr */
1830 memset(&newparam, 0, sizeof(union parameter));
1831 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
1832 send_message(MESSAGE_CONNECT, call->ref, &newparam);
1834 call->state = CHAN_LCR_STATE_CONNECT;
1835 /* request bchannel */
1836 if (!call->bchannel) {
1837 CDEBUG(call, ast, "Requesting B-channel.\n");
1838 memset(&newparam, 0, sizeof(union parameter));
1839 newparam.bchannel.type = BCHANNEL_REQUEST;
1840 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1843 // memset(&newparam, 0, sizeof(union parameter));
1844 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
1847 CDEBUG(call, ast, "DTMF is disabled by option.\n");
1851 ast_mutex_unlock(&chan_lock);
1855 static int lcr_hangup(struct ast_channel *ast)
1857 struct chan_call *call;
1858 pthread_t tid = pthread_self();
1860 if (!pthread_equal(tid, chan_tid))
1861 ast_mutex_lock(&chan_lock);
1862 call = ast->tech_pvt;
1864 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
1865 if (!pthread_equal(tid, chan_tid))
1866 ast_mutex_unlock(&chan_lock);
1870 if (!pthread_equal(tid, chan_tid))
1871 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
1873 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
1875 /* disconnect asterisk, maybe not required */
1876 ast->tech_pvt = NULL;
1881 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
1882 if (ast->hangupcause > 0)
1883 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
1885 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
1888 if (!pthread_equal(tid, chan_tid))
1889 ast_mutex_unlock(&chan_lock);
1893 /* ref is not set, due to prepare setup or release */
1894 if (call->state == CHAN_LCR_STATE_RELEASE)
1896 /* we get the response to our release */
1897 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
1901 /* during prepare, we change to release state */
1902 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
1903 call->state = CHAN_LCR_STATE_RELEASE;
1906 if (!pthread_equal(tid, chan_tid))
1907 ast_mutex_unlock(&chan_lock);
1911 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
1913 struct chan_call *call;
1916 CDEBUG(NULL, ast, "No subclass\n");
1917 if (!(f->subclass & ast->nativeformats))
1918 CDEBUG(NULL, ast, "Unexpected format.\n");
1920 ast_mutex_lock(&chan_lock);
1921 call = ast->tech_pvt;
1923 ast_mutex_unlock(&chan_lock);
1926 if (call->bchannel && f->samples)
1927 bchannel_transmit(call->bchannel, f->data, f->samples);
1928 ast_mutex_unlock(&chan_lock);
1933 static struct ast_frame *lcr_read(struct ast_channel *ast)
1935 struct chan_call *call;
1939 ast_mutex_lock(&chan_lock);
1940 call = ast->tech_pvt;
1942 ast_mutex_unlock(&chan_lock);
1945 if (call->pipe[0] > -1) {
1946 if (call->rebuffer) {
1947 len = read(call->pipe[0], call->read_buff, 160);
1949 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
1952 close(call->pipe[0]);
1958 p = call->read_buff;
1959 for (i = 0; i < len; i++) {
1964 call->read_fr.frametype = AST_FRAME_VOICE;
1965 call->read_fr.subclass = ast->nativeformats;
1966 call->read_fr.datalen = len;
1967 call->read_fr.samples = len;
1968 call->read_fr.delivery = ast_tv(0,0);
1969 call->read_fr.data = call->read_buff;
1970 ast_mutex_unlock(&chan_lock);
1972 return &call->read_fr;
1975 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
1977 union parameter newparam;
1979 struct chan_call *call;
1981 ast_mutex_lock(&chan_lock);
1982 call = ast->tech_pvt;
1984 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
1985 ast_mutex_unlock(&chan_lock);
1990 case AST_CONTROL_BUSY:
1991 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
1992 ast_setstate(ast, AST_STATE_BUSY);
1993 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
1994 /* send message to lcr */
1995 memset(&newparam, 0, sizeof(union parameter));
1996 newparam.disconnectinfo.cause = 17;
1997 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1998 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2000 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2003 case AST_CONTROL_CONGESTION:
2004 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
2005 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
2006 /* send message to lcr */
2007 memset(&newparam, 0, sizeof(union parameter));
2008 newparam.disconnectinfo.cause = ast->hangupcause;
2009 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
2010 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
2012 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
2015 case AST_CONTROL_PROCEEDING:
2016 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2017 if (call->state == CHAN_LCR_STATE_IN_SETUP
2018 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2019 /* send message to lcr */
2020 memset(&newparam, 0, sizeof(union parameter));
2021 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2023 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2026 case AST_CONTROL_RINGING:
2027 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2028 ast_setstate(ast, AST_STATE_RINGING);
2029 if (call->state == CHAN_LCR_STATE_IN_SETUP
2030 || call->state == CHAN_LCR_STATE_IN_DIALING
2031 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2032 /* send message to lcr */
2033 memset(&newparam, 0, sizeof(union parameter));
2034 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2036 call->state = CHAN_LCR_STATE_IN_ALERTING;
2040 CDEBUG(call, ast, "Received indicate -1.\n");
2044 case AST_CONTROL_VIDUPDATE:
2045 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2048 case AST_CONTROL_HOLD:
2049 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2050 /* send message to lcr */
2051 memset(&newparam, 0, sizeof(union parameter));
2052 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2053 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2055 /*start music onhold*/
2056 ast_moh_start(ast,data,ast->musicclass);
2058 case AST_CONTROL_UNHOLD:
2059 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2060 /* send message to lcr */
2061 memset(&newparam, 0, sizeof(union parameter));
2062 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2063 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2070 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2076 ast_mutex_unlock(&chan_lock);
2083 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *newast)
2085 struct chan_call *call;
2087 ast_mutex_lock(&chan_lock);
2088 call = oldast->tech_pvt;
2090 CERROR(NULL, oldast, "Received fixup from Asterisk, but no call instance exists.\n");
2091 ast_mutex_unlock(&chan_lock);
2095 CDEBUG(call, oldast, "Received fixup from Asterisk.\n");
2097 ast_mutex_lock(&chan_lock);
2102 * send_text asterisk
2104 static int lcr_send_text(struct ast_channel *ast, const char *text)
2106 struct chan_call *call;
2107 union parameter newparam;
2109 ast_mutex_lock(&chan_lock);
2110 call = ast->tech_pvt;
2112 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2113 ast_mutex_unlock(&chan_lock);
2117 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2118 memset(&newparam, 0, sizeof(union parameter));
2119 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2120 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2121 ast_mutex_lock(&chan_lock);
2128 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2129 struct ast_channel *ast2, int flags,
2130 struct ast_frame **fo,
2131 struct ast_channel **rc, int timeoutms)
2134 struct chan_call *call1, *call2;
2135 struct ast_channel *carr[2], *who;
2137 struct ast_frame *f;
2140 CDEBUG(NULL, NULL, "Received briding request from Asterisk.\n");
2145 /* join via dsp (if the channels are currently open) */
2146 ast_mutex_lock(&chan_lock);
2147 bridge_id = new_bridge_id();
2148 call1 = ast1->tech_pvt;
2149 call2 = ast2->tech_pvt;
2152 call1->bridge_id = bridge_id;
2153 if (call1->bchannel)
2154 bchannel_join(call1->bchannel, bridge_id);
2155 call1->bridge_call = call2;
2159 call2->bridge_id = bridge_id;
2160 if (call2->bchannel)
2161 bchannel_join(call2->bchannel, bridge_id);
2162 call2->bridge_call = call1;
2164 ast_mutex_unlock(&chan_lock);
2168 who = ast_waitfor_n(carr, 2, &to);
2171 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2176 if (!f || f->frametype == AST_FRAME_CONTROL) {
2178 CDEBUG(NULL, NULL, "Got hangup.\n");
2180 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2187 if ( f->frametype == AST_FRAME_DTMF ) {
2188 CDEBUG(NULL, NULL, "Got DTMF.\n");
2204 CDEBUG(NULL, NULL, "Releasing bride.\n");
2206 /* split channels */
2207 ast_mutex_lock(&chan_lock);
2208 call1 = ast1->tech_pvt;
2209 call2 = ast2->tech_pvt;
2212 call1->bridge_id = 0;
2213 if (call1->bchannel)
2214 bchannel_join(call1->bchannel, 0);
2215 if (call1->bridge_call)
2216 call1->bridge_call->bridge_call = NULL;
2217 call1->bridge_call = NULL;
2221 call2->bridge_id = 0;
2222 if (call2->bchannel)
2223 bchannel_join(call2->bchannel, 0);
2224 if (call2->bridge_call)
2225 call2->bridge_call->bridge_call = NULL;
2226 call2->bridge_call = NULL;
2229 ast_mutex_unlock(&chan_lock);
2230 return AST_BRIDGE_COMPLETE;
2232 static struct ast_channel_tech lcr_tech = {
2234 .description="Channel driver for connecting to Linux-Call-Router",
2235 .requester=lcr_request,
2236 .send_digit_begin=lcr_digit_begin,
2237 .send_digit_end=lcr_digit_end,
2244 .indicate=lcr_indicate,
2246 .send_text=lcr_send_text,
2255 static int lcr_show_lcr (int fd, int argc, char *argv[])
2260 static int lcr_show_calls (int fd, int argc, char *argv[])
2265 static int lcr_reload_routing (int fd, int argc, char *argv[])
2270 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2275 static int lcr_port_block (int fd, int argc, char *argv[])
2280 static int lcr_port_unblock (int fd, int argc, char *argv[])
2285 static int lcr_port_unload (int fd, int argc, char *argv[])
2290 static struct ast_cli_entry cli_show_lcr =
2291 { {"lcr", "show", "lcr", NULL},
2293 "Shows current states of LCR core",
2294 "Usage: lcr show lcr\n",
2297 static struct ast_cli_entry cli_show_calls =
2298 { {"lcr", "show", "calls", NULL},
2300 "Shows current calls made by LCR and Asterisk",
2301 "Usage: lcr show calls\n",
2304 static struct ast_cli_entry cli_reload_routing =
2305 { {"lcr", "reload", "routing", NULL},
2307 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2308 "Usage: lcr reload routing\n",
2311 static struct ast_cli_entry cli_reload_interfaces =
2312 { {"lcr", "reload", "interfaces", NULL},
2313 lcr_reload_interfaces,
2314 "Reloads interfaces conf of LCR",
2315 "Usage: lcr reload interfaces\n",
2318 static struct ast_cli_entry cli_port_block =
2319 { {"lcr", "port", "block", NULL},
2321 "Blocks LCR port for further calls",
2322 "Usage: lcr port block \"<port>\"\n",
2325 static struct ast_cli_entry cli_port_unblock =
2326 { {"lcr", "port", "unblock", NULL},
2328 "Unblocks or loads LCR port, port is opened my mISDN",
2329 "Usage: lcr port unblock \"<port>\"\n",
2332 static struct ast_cli_entry cli_port_unload =
2333 { {"lcr", "port", "unload", NULL},
2335 "Unloads LCR port, port is closes by mISDN",
2336 "Usage: lcr port unload \"<port>\"\n",
2342 static int lcr_config_exec(struct ast_channel *ast, void *data)
2344 struct chan_call *call;
2346 ast_mutex_lock(&chan_lock);
2347 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2351 if (call->ast == ast)
2356 apply_opt(call, (char *)data);
2358 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2360 ast_mutex_unlock(&chan_lock);
2365 * module loading and destruction
2367 int load_module(void)
2371 for (i = 0; i < 256; i++) {
2372 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2373 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2376 if (read_options() == 0) {
2377 CERROR(NULL, NULL, "%s", options_error);
2378 return AST_MODULE_LOAD_DECLINE;
2381 ast_mutex_init(&chan_lock);
2382 ast_mutex_init(&log_lock);
2384 if (open_socket() < 0) {
2385 /* continue with closed socket */
2388 if (bchannel_initialize()) {
2389 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2391 return AST_MODULE_LOAD_DECLINE;
2395 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2396 if (ast_channel_register(&lcr_tech)) {
2397 CERROR(NULL, NULL, "Unable to register channel class\n");
2398 bchannel_deinitialize();
2400 return AST_MODULE_LOAD_DECLINE;
2403 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2404 "lcr_config(<opt><optarg>:<opt>:...)\n"
2405 "Sets LCR opts. and optargs\n"
2407 "The available options are:\n"
2408 " d - Send display text on called phone, text is the optarg.\n"
2409 " n - Don't detect dtmf tones on called channel.\n"
2410 " h - Force data call (HDLC).\n"
2411 " t - Disable all audio features (required for fax application).\n"
2412 " c - Make crypted outgoing call, optarg is keyindex.\n"
2413 " e - Perform echo cancelation on this channel.\n"
2414 " Takes mISDN pipeline option as optarg.\n"
2415 // " s - Send Non Inband DTMF as inband.\n"
2416 " vr - rxgain control\n"
2417 " vt - txgain control\n"
2418 " Volume changes at factor 2 ^ optarg.\n"
2423 ast_cli_register(&cli_show_lcr);
2424 ast_cli_register(&cli_show_calls);
2425 ast_cli_register(&cli_reload_routing);
2426 ast_cli_register(&cli_reload_interfaces);
2427 ast_cli_register(&cli_port_block);
2428 ast_cli_register(&cli_port_unblock);
2429 ast_cli_register(&cli_port_unload);
2433 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0))
2435 /* failed to create thread */
2436 bchannel_deinitialize();
2438 ast_channel_unregister(&lcr_tech);
2439 return AST_MODULE_LOAD_DECLINE;
2444 int unload_module(void)
2446 /* First, take us out of the channel loop */
2447 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2450 pthread_join(chan_tid, NULL);
2452 ast_channel_unregister(&lcr_tech);
2454 ast_unregister_application("lcr_config");
2457 if (mISDN_created) {
2458 bchannel_deinitialize();
2462 if (lcr_sock >= 0) {
2470 int reload_module(void)
2477 #define AST_MODULE "chan_lcr"
2479 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2480 .load = load_module,
2481 .unload = unload_module,
2482 .reload = reload_module,