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);
480 if (opt[1] != '\0') {
481 CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt);
484 CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n");
485 call->inband_dtmf = 1;
490 if (opt[1] != 'r' && opt[1] != 't') {
491 CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt);
495 if (gain < -8 || gain >8) {
496 CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n");
499 CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain);
501 call->rx_gain = gain;
503 bchannel_gain(call->bchannel, call->rx_gain, 0);
505 call->tx_gain = gain;
507 bchannel_gain(call->bchannel, call->tx_gain, 1);
511 CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
515 /* re-open, if bchannel is created */
516 if (call->bchannel && call->bchannel->b_sock > -1) {
517 bchannel_destroy(call->bchannel);
518 if (bchannel_create(call->bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0)))
519 bchannel_activate(call->bchannel, 1);
524 * send setup info to LCR
525 * this function is called, when asterisk call is received and ref is received
527 static void send_setup_to_lcr(struct chan_call *call)
529 union parameter newparam;
530 struct ast_channel *ast = call->ast;
532 if (!call->ast || !call->ref)
535 CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
537 /* send setup message to LCR */
538 memset(&newparam, 0, sizeof(union parameter));
539 newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
540 newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
541 strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1);
542 strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1);
543 newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;
544 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
545 strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
546 call->display[0] = '\0';
547 if (call->cid_num[0])
548 strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1);
549 if (call->cid_name[0])
550 strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1);
551 if (call->cid_rdnis[0])
553 strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
554 newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
555 newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
557 switch(ast->cid.cid_pres & AST_PRES_RESTRICTION)
559 case AST_PRES_ALLOWED:
560 newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
562 case AST_PRES_RESTRICTED:
563 newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
565 case AST_PRES_UNAVAILABLE:
566 newparam.setup.callerinfo.present = INFO_PRESENT_NOTAVAIL;
569 newparam.setup.callerinfo.present = INFO_PRESENT_NULL;
571 switch(ast->cid.cid_ton)
574 newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
577 newparam.setup.callerinfo.ntype = INFO_NTYPE_NATIONAL;
580 newparam.setup.callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
583 newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
585 newparam.setup.capainfo.bearer_capa = ast->transfercapability;
586 newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2;
587 newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
588 newparam.setup.capainfo.hlc = INFO_HLC_NONE;
589 newparam.setup.capainfo.exthlc = INFO_HLC_NONE;
590 send_message(MESSAGE_SETUP, call->ref, &newparam);
592 /* change to outgoing setup state */
593 call->state = CHAN_LCR_STATE_OUT_SETUP;
597 * send dialing info to LCR
598 * this function is called, when setup acknowledge is received and dialing
601 static void send_dialque_to_lcr(struct chan_call *call)
603 union parameter newparam;
605 if (!call->ast || !call->ref || !call->dialque[0])
608 CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
610 /* send setup message to LCR */
611 memset(&newparam, 0, sizeof(union parameter));
612 strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1);
613 call->dialque[0] = '\0';
614 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
618 * in case of a bridge, the unsupported message can be forwarded directly
619 * to the remote call.
621 static void bridge_message_if_bridged(struct chan_call *call, int message_type, union parameter *param)
625 if (!call->bridge_call) return;
626 CDEBUG(call, NULL, "Sending message due briding.\n");
627 send_message(message_type, call->bridge_call->ref, param);
631 * send release message to LCR and import bchannel if exported
633 static void send_release_and_import(struct chan_call *call, int cause, int location)
635 union parameter newparam;
637 /* importing channel */
638 if (call->bchannel) {
639 memset(&newparam, 0, sizeof(union parameter));
640 newparam.bchannel.type = BCHANNEL_RELEASE;
641 newparam.bchannel.handle = call->bchannel->handle;
642 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
644 /* sending release */
645 memset(&newparam, 0, sizeof(union parameter));
646 newparam.disconnectinfo.cause = cause;
647 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
648 send_message(MESSAGE_RELEASE, call->ref, &newparam);
652 * check if extension matches and start asterisk
653 * if it can match, proceed
656 static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete)
659 union parameter newparam;
661 CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", ast->exten, ast->context, complete?"yes":"no");
666 if (!ast_canmatch_extension(ast, ast->context, ast->exten, 1, call->oad))
668 CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", ast->exten, ast->context);
672 if (!ast_exists_extension(ast, ast->context, ast->exten, 1, call->oad))
674 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);
678 CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n");
679 /* send setup acknowledge to lcr */
680 memset(&newparam, 0, sizeof(union parameter));
681 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
684 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
689 if (ast_canmatch_extension(ast, ast->context, ast->exten, 1, call->oad))
691 /* send setup acknowledge to lcr */
692 if (call->state != CHAN_LCR_STATE_IN_DIALING) {
693 memset(&newparam, 0, sizeof(union parameter));
694 send_message(MESSAGE_OVERLAP, call->ref, &newparam);
698 call->state = CHAN_LCR_STATE_IN_DIALING;
700 /* if match, start pbx */
701 if (ast_exists_extension(ast, ast->context, ast->exten, 1, call->oad)) {
702 CDEBUG(call, ast, "Extensions matches.\n");
707 CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n");
715 CDEBUG(call, ast, "Releasing due to extension missmatch.\n");
716 send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
718 /* release asterisk */
719 ast->hangupcause = call->cause;
720 /* change to release state */
721 call->state = CHAN_LCR_STATE_RELEASE;
722 ast_hangup(ast); // call will be destroyed here
726 /* send setup to asterisk */
727 CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
728 ret = ast_pbx_start(ast);
731 cause = (ret==-2)?34:27;
734 call->pbx_started = 1;
739 * incoming setup from LCR
741 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
743 struct ast_channel *ast;
745 CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
747 /* create asterisk channel instrance */
748 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
752 CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
753 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
760 ast->tech_pvt = call;
761 ast->tech = &lcr_tech;
762 ast->fds[0] = call->pipe[0];
764 /* fill setup information */
765 if (param->setup.dialinginfo.id)
766 strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
767 if (param->setup.context[0])
768 strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1);
770 strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
771 if (param->setup.callerinfo.id[0])
772 ast->cid.cid_num = strdup(param->setup.callerinfo.id);
773 if (param->setup.callerinfo.name[0])
774 ast->cid.cid_name = strdup(param->setup.callerinfo.name);
775 if (param->setup.redirinfo.id[0])
776 ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international));
777 switch (param->setup.callerinfo.present)
779 case INFO_PRESENT_ALLOWED:
780 ast->cid.cid_pres = AST_PRES_ALLOWED;
782 case INFO_PRESENT_RESTRICTED:
783 ast->cid.cid_pres = AST_PRES_RESTRICTED;
786 ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
788 switch (param->setup.callerinfo.ntype)
790 case INFO_NTYPE_SUBSCRIBER:
791 ast->cid.cid_ton = 4;
793 case INFO_NTYPE_NATIONAL:
794 ast->cid.cid_ton = 2;
796 case INFO_NTYPE_INTERNATIONAL:
797 ast->cid.cid_ton = 1;
800 ast->cid.cid_ton = 0;
802 ast->transfercapability = param->setup.capainfo.bearer_capa;
803 /* enable hdlc if transcap is data */
804 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
805 || ast->transfercapability == INFO_BC_DATARESTRICTED
806 || ast->transfercapability == INFO_BC_VIDEO)
808 strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
810 /* configure channel */
811 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
812 ast->readformat = ast->rawreadformat = ast->nativeformats;
813 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
815 ast->hangupcause = 0;
818 call->state = CHAN_LCR_STATE_IN_SETUP;
820 if (!call->pbx_started)
821 lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete);
825 * incoming setup acknowledge from LCR
827 static void lcr_in_overlap(struct chan_call *call, int message_type, union parameter *param)
829 if (!call->ast) return;
831 CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n");
833 /* send pending digits in dialque */
834 if (call->dialque[0])
835 send_dialque_to_lcr(call);
836 /* change to overlap state */
837 call->state = CHAN_LCR_STATE_OUT_DIALING;
841 * incoming proceeding from LCR
843 static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param)
845 CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n");
848 call->state = CHAN_LCR_STATE_OUT_PROCEEDING;
849 /* queue event for asterisk */
850 if (call->ast && call->pbx_started)
851 strncat(call->queue_string, "P", sizeof(call->queue_string)-1);
855 * incoming alerting from LCR
857 static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param)
859 CDEBUG(call, call->ast, "Incomming alerting from LCR.\n");
862 call->state = CHAN_LCR_STATE_OUT_ALERTING;
863 /* queue event to asterisk */
864 if (call->ast && call->pbx_started)
865 strncat(call->queue_string, "R", sizeof(call->queue_string)-1);
869 * incoming connect from LCR
871 static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param)
873 union parameter newparam;
875 CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n");
878 call->state = CHAN_LCR_STATE_CONNECT;
879 /* request bchannel */
880 if (!call->bchannel) {
881 CDEBUG(call, call->ast, "Requesting B-channel.\n");
882 memset(&newparam, 0, sizeof(union parameter));
883 newparam.bchannel.type = BCHANNEL_REQUEST;
884 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
886 /* copy connectinfo */
887 memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info));
888 /* queue event to asterisk */
889 if (call->ast && call->pbx_started)
890 strncat(call->queue_string, "A", sizeof(call->queue_string)-1);
894 * incoming disconnect from LCR
896 static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param)
898 struct ast_channel *ast = call->ast;
900 CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause);
903 call->state = CHAN_LCR_STATE_IN_DISCONNECT;
905 call->cause = param->disconnectinfo.cause;
906 call->location = param->disconnectinfo.location;
907 /* if bridge, forward disconnect and return */
910 if (call->bridge_call)
912 CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n");
913 bridge_message_if_bridged(call, message_type, param);
917 /* release lcr with same cause */
918 send_release_and_import(call, call->cause, call->location);
920 /* change to release state */
921 call->state = CHAN_LCR_STATE_RELEASE;
922 /* queue release asterisk */
925 ast->hangupcause = call->cause;
926 if (call->pbx_started)
927 strcpy(call->queue_string, "H"); // overwrite other indications
929 ast_hangup(ast); // call will be destroyed here
935 * incoming setup acknowledge from LCR
937 static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param)
939 struct ast_channel *ast = call->ast;
941 CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause);
945 /* change to release state */
946 call->state = CHAN_LCR_STATE_RELEASE;
947 /* copy release info */
950 call->cause = param->disconnectinfo.cause;
951 call->location = param->disconnectinfo.location;
953 /* if we have an asterisk instance, queue hangup, else we are done */
956 ast->hangupcause = call->cause;
957 if (call->pbx_started)
958 strcpy(call->queue_string, "H");
960 ast_hangup(ast); // call will be destroyed here
970 * incoming information from LCR
972 static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param)
974 struct ast_channel *ast = call->ast;
976 CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
980 /* pbx not started */
981 if (!call->pbx_started)
983 CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
984 strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
985 lcr_start_pbx(call, ast, param->information.sending_complete);
990 if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0])
991 strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1);
993 /* use bridge to forware message not supported by asterisk */
994 if (call->state == CHAN_LCR_STATE_CONNECT) {
995 CDEBUG(call, call->ast, "Call is connected, briding.\n");
996 bridge_message_if_bridged(call, message_type, param);
1001 * incoming information from LCR
1003 static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param)
1005 union parameter newparam;
1007 CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify);
1009 /* request bchannel, if call is resumed and we don't have it */
1010 if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) {
1011 CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n");
1012 memset(&newparam, 0, sizeof(union parameter));
1013 newparam.bchannel.type = BCHANNEL_REQUEST;
1014 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1017 if (!call->ast) return;
1019 /* use bridge to forware message not supported by asterisk */
1020 bridge_message_if_bridged(call, message_type, param);
1024 * incoming information from LCR
1026 static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param)
1028 CDEBUG(call, call->ast, "Incomming facility from LCR.\n");
1030 if (!call->ast) return;
1032 /* use bridge to forware message not supported by asterisk */
1033 bridge_message_if_bridged(call, message_type, param);
1037 * got dtmf from bchannel (locked state)
1039 void lcr_in_dtmf(struct chan_call *call, int val)
1041 struct ast_channel *ast = call->ast;
1046 if (!call->pbx_started)
1049 CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val);
1052 strncat(call->queue_string, digit, sizeof(call->queue_string)-1);
1056 * message received from LCR
1058 int receive_message(int message_type, unsigned int ref, union parameter *param)
1060 struct bchannel *bchannel;
1061 struct chan_call *call;
1062 union parameter newparam;
1064 memset(&newparam, 0, sizeof(union parameter));
1066 /* handle bchannel message*/
1067 if (message_type == MESSAGE_BCHANNEL)
1069 switch(param->bchannel.type)
1071 case BCHANNEL_ASSIGN:
1072 CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref);
1073 if ((bchannel = find_bchannel_handle(param->bchannel.handle)))
1075 CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle);
1078 /* create bchannel */
1079 bchannel = alloc_bchannel(param->bchannel.handle);
1082 CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle);
1086 /* configure channel */
1087 bchannel->b_tx_gain = param->bchannel.tx_gain;
1088 bchannel->b_rx_gain = param->bchannel.rx_gain;
1089 strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1);
1090 if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key))
1092 bchannel->b_bf_len = param->bchannel.crypt_len;
1093 memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len);
1095 bchannel->b_txdata = 0;
1096 bchannel->b_dtmf = 1;
1097 bchannel->b_tx_dejitter = 1;
1099 /* in case, ref is not set, this bchannel instance must
1100 * be created until it is removed again by LCR */
1102 call = find_call_ref(ref);
1105 bchannel->call = call;
1106 call->bchannel = bchannel;
1108 bchannel_dtmf(bchannel, 1);
1110 bchannel_blowfish(bchannel, call->bf_key, call->bf_len);
1111 if (call->pipeline[0])
1112 bchannel_pipeline(bchannel, call->pipeline);
1114 bchannel_gain(bchannel, call->rx_gain, 0);
1116 bchannel_gain(bchannel, call->tx_gain, 1);
1117 if (call->bridge_id) {
1118 CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
1119 bchannel_join(bchannel, call->bridge_id);
1121 /* create only, if call exists, othewhise it bchannel is freed below... */
1122 if (bchannel_create(bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0)))
1123 bchannel_activate(bchannel, 1);
1126 newparam.bchannel.type = BCHANNEL_ASSIGN_ACK;
1127 newparam.bchannel.handle = param->bchannel.handle;
1128 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1129 /* if call has released before bchannel is assigned */
1131 newparam.bchannel.type = BCHANNEL_RELEASE;
1132 newparam.bchannel.handle = param->bchannel.handle;
1133 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1138 case BCHANNEL_REMOVE:
1139 CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle);
1140 if (!(bchannel = find_bchannel_handle(param->bchannel.handle)))
1142 CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle);
1145 /* unklink from call and destroy bchannel */
1146 free_bchannel(bchannel);
1149 newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
1150 newparam.bchannel.handle = param->bchannel.handle;
1151 send_message(MESSAGE_BCHANNEL, 0, &newparam);
1156 CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type);
1161 /* handle new ref */
1162 if (message_type == MESSAGE_NEWREF)
1164 if (param->direction)
1166 /* new ref from lcr */
1167 CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref);
1168 if (!ref || find_call_ref(ref))
1170 CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref);
1173 /* allocate new call instance */
1174 call = alloc_call();
1176 call->state = CHAN_LCR_STATE_IN_PREPARE;
1179 /* wait for setup (or release from asterisk) */
1182 /* new ref, as requested from this remote application */
1183 CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref);
1184 call = find_call_ref(0);
1187 /* send release, if ref does not exist */
1188 CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
1189 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1194 /* send pending setup info */
1195 if (call->state == CHAN_LCR_STATE_OUT_PREPARE)
1196 send_setup_to_lcr(call);
1197 /* release if asterisk has signed off */
1198 else if (call->state == CHAN_LCR_STATE_RELEASE)
1202 send_release_and_import(call, call->cause, call->location);
1204 send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
1216 CERROR(NULL, NULL, "Received message %d without ref.\n", message_type);
1219 call = find_call_ref(ref);
1222 /* ignore ref that is not used (anymore) */
1223 CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type);
1227 /* handle messages */
1228 switch(message_type)
1231 lcr_in_setup(call, message_type, param);
1234 case MESSAGE_OVERLAP:
1235 lcr_in_overlap(call, message_type, param);
1238 case MESSAGE_PROCEEDING:
1239 lcr_in_proceeding(call, message_type, param);
1242 case MESSAGE_ALERTING:
1243 lcr_in_alerting(call, message_type, param);
1246 case MESSAGE_CONNECT:
1247 lcr_in_connect(call, message_type, param);
1250 case MESSAGE_DISCONNECT:
1251 lcr_in_disconnect(call, message_type, param);
1254 case MESSAGE_RELEASE:
1255 lcr_in_release(call, message_type, param);
1258 case MESSAGE_INFORMATION:
1259 lcr_in_information(call, message_type, param);
1262 case MESSAGE_NOTIFY:
1263 lcr_in_notify(call, message_type, param);
1266 case MESSAGE_FACILITY:
1267 lcr_in_facility(call, message_type, param);
1270 case MESSAGE_PATTERN: // audio available from LCR
1273 case MESSAGE_NOPATTERN: // audio not available from LCR
1276 case MESSAGE_AUDIOPATH: // if remote audio connected or hold
1277 call->audiopath = param->audiopath;
1281 CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type);
1288 * release all calls (due to broken socket)
1290 static void release_all_calls(void)
1292 struct chan_call *call;
1297 /* no ast, so we may directly free call */
1299 CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n");
1303 /* already in release process */
1304 if (call->state == CHAN_LCR_STATE_RELEASE) {
1308 /* release or queue release */
1310 call->state = CHAN_LCR_STATE_RELEASE;
1311 if (!call->pbx_started) {
1312 CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n");
1313 ast_hangup(call->ast); // call will be destroyed here
1316 CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n");
1317 strcpy(call->queue_string, "H");
1321 /* release all bchannels */
1322 while(bchannel_first)
1323 free_bchannel(bchannel_first);
1328 * warning! not thread safe
1329 * returns -1 for socket error, 0 for no work, 1 for work
1331 int handle_socket(void)
1335 struct admin_list *admin;
1336 struct admin_message msg;
1338 /* read from socket */
1339 len = read(lcr_sock, &msg, sizeof(msg));
1342 CERROR(NULL, NULL, "Socket closed.\n");
1343 return(-1); // socket closed
1347 if (len != sizeof(msg))
1349 CERROR(NULL, NULL, "Socket short read. (len %d)\n", len);
1350 return(-1); // socket error
1352 if (msg.message != ADMIN_MESSAGE)
1354 CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message);
1357 receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param);
1361 if (errno != EWOULDBLOCK)
1363 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1368 /* write to socket */
1371 admin = admin_first;
1372 len = write(lcr_sock, &admin->msg, sizeof(msg));
1375 CERROR(NULL, NULL, "Socket closed.\n");
1376 return(-1); // socket closed
1380 if (len != sizeof(msg))
1382 CERROR(NULL, NULL, "Socket short write. (len %d)\n", len);
1383 return(-1); // socket error
1386 admin_first = admin->next;
1392 if (errno != EWOULDBLOCK)
1394 CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno);
1403 * open and close socket and thread
1405 int open_socket(void)
1408 char *socket_name = SOCKET_NAME;
1410 struct sockaddr_un sock_address;
1411 unsigned int on = 1;
1412 union parameter param;
1415 if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0)
1417 CERROR(NULL, NULL, "Failed to create socket.\n");
1421 /* set socket address and name */
1422 memset(&sock_address, 0, sizeof(sock_address));
1423 sock_address.sun_family = PF_UNIX;
1424 strcpy(sock_address.sun_path, socket_name);
1426 /* connect socket */
1427 if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0)
1431 CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path);
1435 /* set non-blocking io */
1436 if ((ret = ioctl(lcr_sock, FIONBIO, (unsigned char *)(&on))) < 0)
1440 CERROR(NULL, NULL, "Failed to set socket into non-blocking IO.\n");
1444 /* enque hello message */
1445 memset(¶m, 0, sizeof(param));
1446 strcpy(param.hello.application, "asterisk");
1447 send_message(MESSAGE_HELLO, 0, ¶m);
1452 void close_socket(void)
1454 struct admin_list *admin, *temp;
1456 /* flush pending messages */
1457 admin = admin_first;
1460 admin = admin->next;
1472 /* sending queue to asterisk */
1473 static int queue_send(void)
1476 struct chan_call *call;
1477 struct ast_channel *ast;
1478 struct ast_frame fr;
1483 p = call->queue_string;
1486 /* there is something to queue */
1487 if (!ast_channel_trylock(ast)) { /* succeed */
1491 CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n");
1492 ast_queue_control(ast, AST_CONTROL_PROCEEDING);
1495 CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n");
1496 ast_queue_control(ast, AST_CONTROL_RINGING);
1499 CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n");
1500 ast_queue_control(ast, AST_CONTROL_ANSWER);
1503 CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n");
1504 ast_queue_hangup(ast);
1506 case '1': case '2': case '3': case 'a':
1507 case '4': case '5': case '6': case 'b':
1508 case '7': case '8': case '9': case 'c':
1509 case '*': case '0': case '#': case 'd':
1510 CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
1511 /* send digit to asterisk */
1512 memset(&fr, 0, sizeof(fr));
1513 fr.frametype = AST_FRAME_DTMF;
1515 fr.delivery = ast_tv(0, 0);
1517 ast_queue_frame(ast, &fr);
1520 CDEBUG(call, ast, "Ignoring queued digit 0x%02d.\n", *p);
1524 call->queue_string[0] = '\0';
1525 ast_channel_unlock(ast);
1535 /* signal handler */
1536 void sighandler(int sigset)
1540 /* chan_lcr thread */
1541 static void *chan_thread(void *arg)
1545 union parameter param;
1546 time_t retry = 0, now;
1548 bchannel_pid = getpid();
1550 // signal(SIGPIPE, sighandler);
1552 memset(¶m, 0, sizeof(union parameter));
1556 ast_mutex_lock(&chan_lock);
1563 ret = handle_socket();
1565 CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
1567 release_all_calls();
1574 if (retry && now-retry > 5) {
1575 CDEBUG(NULL, NULL, "Retry to open socket.\n");
1577 if (open_socket() < 0) {
1586 ret = bchannel_handle();
1590 /* handle messages to asterisk */
1595 /* delay if no work done */
1597 ast_mutex_unlock(&chan_lock);
1599 ast_mutex_lock(&chan_lock);
1605 CERROR(NULL, NULL, "Thread exit.\n");
1607 ast_mutex_unlock(&chan_lock);
1609 // signal(SIGPIPE, SIG_DFL);
1615 * new asterisk instance
1618 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
1620 char exten[256], *dial, *interface, *opt;
1621 struct ast_channel *ast;
1622 struct chan_call *call;
1624 ast_mutex_lock(&chan_lock);
1625 CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
1627 /* if socket is closed */
1630 CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n");
1631 ast_mutex_unlock(&chan_lock);
1635 /* create call instance */
1636 call = alloc_call();
1639 /* failed to create instance */
1640 ast_mutex_unlock(&chan_lock);
1644 /* create asterisk channel instrance */
1645 ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
1648 CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
1650 /* failed to create instance */
1651 ast_mutex_unlock(&chan_lock);
1654 ast->tech = &lcr_tech;
1655 ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
1656 /* configure channel */
1657 ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
1658 ast->readformat = ast->rawreadformat = ast->nativeformats;
1659 ast->writeformat = ast->rawwriteformat = ast->nativeformats;
1661 ast->hangupcause = 0;
1665 ast->tech_pvt = call;
1666 ast->fds[0] = call->pipe[0];
1667 call->pbx_started = 0;
1669 call->state = CHAN_LCR_STATE_OUT_PREPARE;
1672 * Extract interface, dialstring, options from data.
1675 * <interface>/<dialstring>
1676 * <interface>/<dialstring>/options
1678 strncpy(exten, (char *)data, sizeof(exten)-1);
1679 exten[sizeof(exten)-1] = '\0';
1680 if ((dial = strchr(exten, '/'))) {
1683 if ((opt = strchr(dial, '/')))
1692 strncpy(call->interface, interface, sizeof(call->interface)-1);
1693 strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
1694 apply_opt(call, (char *)opt);
1696 ast_mutex_unlock(&chan_lock);
1701 * call from asterisk
1703 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
1705 union parameter newparam;
1706 struct chan_call *call;
1708 ast_mutex_lock(&chan_lock);
1709 call = ast->tech_pvt;
1711 CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
1712 ast_mutex_unlock(&chan_lock);
1716 CDEBUG(NULL, ast, "Received call from Asterisk.\n");
1718 /* pbx process is started */
1719 call->pbx_started = 1;
1720 /* send MESSAGE_NEWREF */
1721 memset(&newparam, 0, sizeof(union parameter));
1722 newparam.direction = 0; /* request from app */
1723 send_message(MESSAGE_NEWREF, 0, &newparam);
1725 /* set hdlc if capability requires hdlc */
1726 if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
1727 || ast->transfercapability == INFO_BC_DATARESTRICTED
1728 || ast->transfercapability == INFO_BC_VIDEO)
1730 /* if hdlc is forced by option, we change transcap to data */
1732 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
1733 && ast->transfercapability != INFO_BC_DATARESTRICTED
1734 && ast->transfercapability != INFO_BC_VIDEO)
1735 ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
1737 call->cid_num[0] = 0;
1738 call->cid_name[0] = 0;
1739 call->cid_rdnis[0] = 0;
1741 if (ast->cid.cid_num) if (ast->cid.cid_num[0])
1742 strncpy(call->cid_num, ast->cid.cid_num,
1743 sizeof(call->cid_num)-1);
1745 if (ast->cid.cid_name) if (ast->cid.cid_name[0])
1746 strncpy(call->cid_name, ast->cid.cid_name,
1747 sizeof(call->cid_name)-1);
1748 if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
1749 strncpy(call->cid_rdnis, ast->cid.cid_rdnis,
1750 sizeof(call->cid_rdnis)-1);
1752 ast_mutex_unlock(&chan_lock);
1756 static int lcr_digit_begin(struct ast_channel *ast, char digit)
1758 struct chan_call *call;
1759 union parameter newparam;
1762 /* only pass IA5 number space */
1763 if (digit > 126 || digit < 32)
1766 ast_mutex_lock(&chan_lock);
1767 call = ast->tech_pvt;
1769 CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
1770 ast_mutex_unlock(&chan_lock);
1774 CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit);
1776 /* send information or queue them */
1777 if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING)
1779 CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n");
1780 memset(&newparam, 0, sizeof(union parameter));
1781 newparam.information.id[0] = digit;
1782 newparam.information.id[1] = '\0';
1783 send_message(MESSAGE_INFORMATION, call->ref, &newparam);
1786 && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP))
1788 CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n");
1790 strncat(call->dialque, buf, strlen(call->dialque)-1);
1793 ast_mutex_unlock(&chan_lock);
1797 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
1799 printf("DIGIT END %c\n", digit);
1803 static int lcr_answer(struct ast_channel *ast)
1805 union parameter newparam;
1806 struct chan_call *call;
1808 ast_mutex_lock(&chan_lock);
1809 call = ast->tech_pvt;
1811 CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
1812 ast_mutex_unlock(&chan_lock);
1816 CDEBUG(call, ast, "Received answer from Asterisk.\n");
1818 /* copy connectinfo, if bridged */
1819 if (call->bridge_call)
1820 memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
1821 /* send connect message to lcr */
1822 memset(&newparam, 0, sizeof(union parameter));
1823 memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info));
1824 send_message(MESSAGE_CONNECT, call->ref, &newparam);
1826 call->state = CHAN_LCR_STATE_CONNECT;
1827 /* request bchannel */
1828 if (!call->bchannel) {
1829 CDEBUG(call, ast, "Requesting B-channel.\n");
1830 memset(&newparam, 0, sizeof(union parameter));
1831 newparam.bchannel.type = BCHANNEL_REQUEST;
1832 send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
1835 // memset(&newparam, 0, sizeof(union parameter));
1836 // send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
1839 CDEBUG(call, ast, "DTMF is disabled by option.\n");
1843 ast_mutex_unlock(&chan_lock);
1847 static int lcr_hangup(struct ast_channel *ast)
1849 struct chan_call *call;
1850 pthread_t tid = pthread_self();
1852 if (!pthread_equal(tid, chan_tid))
1853 ast_mutex_lock(&chan_lock);
1854 call = ast->tech_pvt;
1856 CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
1857 if (!pthread_equal(tid, chan_tid))
1858 ast_mutex_unlock(&chan_lock);
1862 if (!pthread_equal(tid, chan_tid))
1863 CDEBUG(call, ast, "Received hangup from Asterisk thread.\n");
1865 CDEBUG(call, ast, "Received hangup from LCR thread.\n");
1867 /* disconnect asterisk, maybe not required */
1868 ast->tech_pvt = NULL;
1873 CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
1874 if (ast->hangupcause > 0)
1875 send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
1877 send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL);
1880 if (!pthread_equal(tid, chan_tid))
1881 ast_mutex_unlock(&chan_lock);
1885 /* ref is not set, due to prepare setup or release */
1886 if (call->state == CHAN_LCR_STATE_RELEASE)
1888 /* we get the response to our release */
1889 CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n");
1893 /* during prepare, we change to release state */
1894 CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n");
1895 call->state = CHAN_LCR_STATE_RELEASE;
1898 if (!pthread_equal(tid, chan_tid))
1899 ast_mutex_unlock(&chan_lock);
1903 static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
1905 struct chan_call *call;
1908 CDEBUG(NULL, ast, "No subclass\n");
1909 if (!(f->subclass & ast->nativeformats))
1910 CDEBUG(NULL, ast, "Unexpected format.\n");
1912 ast_mutex_lock(&chan_lock);
1913 call = ast->tech_pvt;
1915 ast_mutex_unlock(&chan_lock);
1918 if (call->bchannel && f->samples)
1919 bchannel_transmit(call->bchannel, f->data, f->samples);
1920 ast_mutex_unlock(&chan_lock);
1925 static struct ast_frame *lcr_read(struct ast_channel *ast)
1927 struct chan_call *call;
1931 ast_mutex_lock(&chan_lock);
1932 call = ast->tech_pvt;
1934 ast_mutex_unlock(&chan_lock);
1937 if (call->pipe[0] > -1) {
1938 len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff));
1940 close(call->pipe[0]);
1946 p = call->read_buff;
1947 for (i = 0; i < len; i++) {
1952 call->read_fr.frametype = AST_FRAME_VOICE;
1953 call->read_fr.subclass = ast->nativeformats;
1954 call->read_fr.datalen = len;
1955 call->read_fr.samples = len;
1956 call->read_fr.delivery = ast_tv(0,0);
1957 call->read_fr.data = call->read_buff;
1958 ast_mutex_unlock(&chan_lock);
1960 return &call->read_fr;
1963 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
1965 union parameter newparam;
1967 struct chan_call *call;
1969 ast_mutex_lock(&chan_lock);
1970 call = ast->tech_pvt;
1972 CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
1973 ast_mutex_unlock(&chan_lock);
1978 case AST_CONTROL_BUSY:
1979 CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n");
1980 ast_setstate(ast, AST_STATE_BUSY);
1981 if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
1982 /* send message to lcr */
1983 memset(&newparam, 0, sizeof(union parameter));
1984 newparam.disconnectinfo.cause = 17;
1985 newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1986 send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
1988 call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
1991 case AST_CONTROL_CONGESTION:
1992 CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
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 = ast->hangupcause;
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_PROCEEDING:
2004 CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n");
2005 if (call->state == CHAN_LCR_STATE_IN_SETUP
2006 || call->state == CHAN_LCR_STATE_IN_DIALING) {
2007 /* send message to lcr */
2008 memset(&newparam, 0, sizeof(union parameter));
2009 send_message(MESSAGE_PROCEEDING, call->ref, &newparam);
2011 call->state = CHAN_LCR_STATE_IN_PROCEEDING;
2014 case AST_CONTROL_RINGING:
2015 CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
2016 ast_setstate(ast, AST_STATE_RINGING);
2017 if (call->state == CHAN_LCR_STATE_IN_SETUP
2018 || call->state == CHAN_LCR_STATE_IN_DIALING
2019 || call->state == CHAN_LCR_STATE_IN_PROCEEDING) {
2020 /* send message to lcr */
2021 memset(&newparam, 0, sizeof(union parameter));
2022 send_message(MESSAGE_ALERTING, call->ref, &newparam);
2024 call->state = CHAN_LCR_STATE_IN_ALERTING;
2028 CDEBUG(call, ast, "Received indicate -1.\n");
2032 case AST_CONTROL_VIDUPDATE:
2033 CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
2036 case AST_CONTROL_HOLD:
2037 CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n");
2038 /* send message to lcr */
2039 memset(&newparam, 0, sizeof(union parameter));
2040 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD;
2041 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2043 /*start music onhold*/
2044 ast_moh_start(ast,data,ast->musicclass);
2046 case AST_CONTROL_UNHOLD:
2047 CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
2048 /* send message to lcr */
2049 memset(&newparam, 0, sizeof(union parameter));
2050 newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL;
2051 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2058 CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
2064 ast_mutex_unlock(&chan_lock);
2071 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *newast)
2073 struct chan_call *call;
2075 ast_mutex_lock(&chan_lock);
2076 call = oldast->tech_pvt;
2078 CERROR(NULL, oldast, "Received fixup from Asterisk, but no call instance exists.\n");
2079 ast_mutex_unlock(&chan_lock);
2083 CDEBUG(call, oldast, "Received fixup from Asterisk.\n");
2085 ast_mutex_lock(&chan_lock);
2090 * send_text asterisk
2092 static int lcr_send_text(struct ast_channel *ast, const char *text)
2094 struct chan_call *call;
2095 union parameter newparam;
2097 ast_mutex_lock(&chan_lock);
2098 call = ast->tech_pvt;
2100 CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
2101 ast_mutex_unlock(&chan_lock);
2105 CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text);
2106 memset(&newparam, 0, sizeof(union parameter));
2107 strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
2108 send_message(MESSAGE_NOTIFY, call->ref, &newparam);
2109 ast_mutex_lock(&chan_lock);
2116 enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
2117 struct ast_channel *ast2, int flags,
2118 struct ast_frame **fo,
2119 struct ast_channel **rc, int timeoutms)
2122 struct chan_call *call1, *call2;
2123 struct ast_channel *carr[2], *who;
2125 struct ast_frame *f;
2128 CDEBUG(NULL, NULL, "Received briding request from Asterisk.\n");
2133 /* join via dsp (if the channels are currently open) */
2134 ast_mutex_lock(&chan_lock);
2135 bridge_id = new_bridge_id();
2136 call1 = ast1->tech_pvt;
2137 call2 = ast2->tech_pvt;
2140 call1->bridge_id = bridge_id;
2141 if (call1->bchannel)
2142 bchannel_join(call1->bchannel, bridge_id);
2143 call1->bridge_call = call2;
2147 call2->bridge_id = bridge_id;
2148 if (call2->bchannel)
2149 bchannel_join(call2->bchannel, bridge_id);
2150 call2->bridge_call = call1;
2152 ast_mutex_unlock(&chan_lock);
2156 who = ast_waitfor_n(carr, 2, &to);
2159 CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n");
2164 if (!f || f->frametype == AST_FRAME_CONTROL) {
2166 CDEBUG(NULL, NULL, "Got hangup.\n");
2168 CDEBUG(NULL, NULL, "Got CONTROL.\n");
2175 if ( f->frametype == AST_FRAME_DTMF ) {
2176 CDEBUG(NULL, NULL, "Got DTMF.\n");
2192 CDEBUG(NULL, NULL, "Releasing bride.\n");
2194 /* split channels */
2195 ast_mutex_lock(&chan_lock);
2196 call1 = ast1->tech_pvt;
2197 call2 = ast2->tech_pvt;
2200 call1->bridge_id = 0;
2201 if (call1->bchannel)
2202 bchannel_join(call1->bchannel, 0);
2203 if (call1->bridge_call)
2204 call1->bridge_call->bridge_call = NULL;
2205 call1->bridge_call = NULL;
2209 call2->bridge_id = 0;
2210 if (call2->bchannel)
2211 bchannel_join(call2->bchannel, 0);
2212 if (call2->bridge_call)
2213 call2->bridge_call->bridge_call = NULL;
2214 call2->bridge_call = NULL;
2217 ast_mutex_unlock(&chan_lock);
2218 return AST_BRIDGE_COMPLETE;
2220 static struct ast_channel_tech lcr_tech = {
2222 .description="Channel driver for connecting to Linux-Call-Router",
2223 .requester=lcr_request,
2224 .send_digit_begin=lcr_digit_begin,
2225 .send_digit_end=lcr_digit_end,
2232 .indicate=lcr_indicate,
2234 .send_text=lcr_send_text,
2243 static int lcr_show_lcr (int fd, int argc, char *argv[])
2248 static int lcr_show_calls (int fd, int argc, char *argv[])
2253 static int lcr_reload_routing (int fd, int argc, char *argv[])
2258 static int lcr_reload_interfaces (int fd, int argc, char *argv[])
2263 static int lcr_port_block (int fd, int argc, char *argv[])
2268 static int lcr_port_unblock (int fd, int argc, char *argv[])
2273 static int lcr_port_unload (int fd, int argc, char *argv[])
2278 static struct ast_cli_entry cli_show_lcr =
2279 { {"lcr", "show", "lcr", NULL},
2281 "Shows current states of LCR core",
2282 "Usage: lcr show lcr\n",
2285 static struct ast_cli_entry cli_show_calls =
2286 { {"lcr", "show", "calls", NULL},
2288 "Shows current calls made by LCR and Asterisk",
2289 "Usage: lcr show calls\n",
2292 static struct ast_cli_entry cli_reload_routing =
2293 { {"lcr", "reload", "routing", NULL},
2295 "Reloads routing conf of LCR, current uncomplete calls will be disconnected",
2296 "Usage: lcr reload routing\n",
2299 static struct ast_cli_entry cli_reload_interfaces =
2300 { {"lcr", "reload", "interfaces", NULL},
2301 lcr_reload_interfaces,
2302 "Reloads interfaces conf of LCR",
2303 "Usage: lcr reload interfaces\n",
2306 static struct ast_cli_entry cli_port_block =
2307 { {"lcr", "port", "block", NULL},
2309 "Blocks LCR port for further calls",
2310 "Usage: lcr port block \"<port>\"\n",
2313 static struct ast_cli_entry cli_port_unblock =
2314 { {"lcr", "port", "unblock", NULL},
2316 "Unblocks or loads LCR port, port is opened my mISDN",
2317 "Usage: lcr port unblock \"<port>\"\n",
2320 static struct ast_cli_entry cli_port_unload =
2321 { {"lcr", "port", "unload", NULL},
2323 "Unloads LCR port, port is closes by mISDN",
2324 "Usage: lcr port unload \"<port>\"\n",
2330 static int lcr_config_exec(struct ast_channel *ast, void *data)
2332 struct chan_call *call;
2334 ast_mutex_lock(&chan_lock);
2335 CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
2339 if (call->ast == ast)
2344 apply_opt(call, (char *)data);
2346 CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
2348 ast_mutex_unlock(&chan_lock);
2353 * module loading and destruction
2355 int load_module(void)
2359 for (i = 0; i < 256; i++) {
2360 flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8)
2361 | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1);
2364 if (read_options() == 0) {
2365 CERROR(NULL, NULL, "%s", options_error);
2366 return AST_MODULE_LOAD_DECLINE;
2369 ast_mutex_init(&chan_lock);
2370 ast_mutex_init(&log_lock);
2372 if (open_socket() < 0) {
2373 /* continue with closed socket */
2376 if (bchannel_initialize()) {
2377 CERROR(NULL, NULL, "Unable to open mISDN device\n");
2379 return AST_MODULE_LOAD_DECLINE;
2383 lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
2384 if (ast_channel_register(&lcr_tech)) {
2385 CERROR(NULL, NULL, "Unable to register channel class\n");
2386 bchannel_deinitialize();
2388 return AST_MODULE_LOAD_DECLINE;
2391 ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
2392 "lcr_config(<opt><optarg>:<opt>:...)\n"
2393 "Sets LCR opts. and optargs\n"
2395 "The available options are:\n"
2396 " d - Send display text on called phone, text is the optarg.\n"
2397 " n - Don't detect dtmf tones on called channel.\n"
2398 " h - Force data call (HDLC).\n"
2399 " t - Disable all audio features (required for fax application).\n"
2400 " c - Make crypted outgoing call, optarg is keyindex.\n"
2401 " e - Perform echo cancelation on this channel.\n"
2402 " Takes mISDN pipeline option as optarg.\n"
2403 // " s - Send Non Inband DTMF as inband.\n"
2404 " vr - rxgain control\n"
2405 " vt - txgain control\n"
2406 " Volume changes at factor 2 ^ optarg.\n"
2411 ast_cli_register(&cli_show_lcr);
2412 ast_cli_register(&cli_show_calls);
2413 ast_cli_register(&cli_reload_routing);
2414 ast_cli_register(&cli_reload_interfaces);
2415 ast_cli_register(&cli_port_block);
2416 ast_cli_register(&cli_port_unblock);
2417 ast_cli_register(&cli_port_unload);
2421 if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0))
2423 /* failed to create thread */
2424 bchannel_deinitialize();
2426 ast_channel_unregister(&lcr_tech);
2427 return AST_MODULE_LOAD_DECLINE;
2432 int unload_module(void)
2434 /* First, take us out of the channel loop */
2435 CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
2438 pthread_join(chan_tid, NULL);
2440 ast_channel_unregister(&lcr_tech);
2442 ast_unregister_application("lcr_config");
2445 if (mISDN_created) {
2446 bchannel_deinitialize();
2450 if (lcr_sock >= 0) {
2458 int reload_module(void)
2465 #define AST_MODULE "chan_lcr"
2467 AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)",
2468 .load = load_module,
2469 .unload = unload_module,
2470 .reload = reload_module,