X-Git-Url: http://git.eversberg.eu/gitweb.cgi?p=lcr.git;a=blobdiff_plain;f=chan_lcr.c;h=7eabe0e6cdf84f86417526983d78ad3cb208bdd1;hp=8b82d5f44e3c4967d2170ab000e932072f9674c8;hb=ab4a1270e9c99ab7a21a957759de2a885100afb1;hpb=2fb748e1da2e291e68c51f4f42e7f9bc6fa370db diff --git a/chan_lcr.c b/chan_lcr.c index 8b82d5f..7eabe0e 100644 --- a/chan_lcr.c +++ b/chan_lcr.c @@ -31,10 +31,11 @@ The state changes to CHAN_LCR_STATE_IN_SETUP. Call is initiated by Asterisk: -If a call is reveiced from Asterisk, a new chan_call instance is created. +If a call is requested from Asterisk, a new chan_call instance is created. The new Asterisk instance pointer (ast) is stored to chan_call structure. -A MESSASGE_NEWREF is sent to LCR requesting a new call reference (ref). The current call ref is set to 0, the state is CHAN_LCR_STATE_OUT_PREPARE. +If the call is received (lcr_call) A MESSASGE_NEWREF is sent to LCR requesting +a new call reference (ref). Further dialing information is queued. After the new callref is received by special MESSAGE_NEWREF reply, new ref is stored in the chan_call structure. @@ -77,12 +78,28 @@ LCR and the chan_call instance is destroyed. If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure "Call is released by LCR". -*/ -#warning reconnect after socket closed, release all calls. -#warning debug of call handling -#warning ausloesen beim socket-verlust +Locking issues: + +The deadlocking problem: + +- chan_lcr locks chan_lock and waits inside ast_queue_xxxx() for ast_channel +to be unlocked. +- ast_channel thread locks ast_channel and calls a tech function and waits +there for chan_lock to be unlocked. + +The solution: +Never call ast_queue_xxxx() if ast_channel is not locked and don't wait until +ast_channel can be locked. All messages to asterisk are queued inside call +instance and will be handled using a try-lock to get ast_channel lock. +If it succeeds to lock ast_channel, the ast_queue_xxxx can safely called even +if the lock is incremented and decremented there. + +Exception: Calling ast_queue_frame inside ast->tech->read is safe, because +it is called from ast_channel process which has already locked ast_channel. + +*/ #include #include @@ -91,17 +108,15 @@ If the ref is 0 and the state is CHAN_LCR_STATE_RELEASE, see the proceedure #include #include #include +//#include #include #include #include #include #include -#include #include -pthread_mutex_t chan_lock; - #include #include #include @@ -124,13 +139,17 @@ pthread_mutex_t chan_lock; #include "extension.h" #include "message.h" +#include "callerid.h" #include "lcrsocket.h" #include "cause.h" #include "bchannel.h" +#include "options.h" #include "chan_lcr.h" -#include "callerid.h" CHAN_LCR_STATE // state description structure +MESSAGES // message text + +unsigned char flip_bits[256]; int lcr_debug=1; int mISDN_created=1; @@ -138,6 +157,8 @@ int mISDN_created=1; char lcr_type[]="lcr"; pthread_t chan_tid; +ast_mutex_t chan_lock; /* global lock */ +ast_mutex_t log_lock; /* logging log */ int quit; int glob_channel = 0; @@ -146,17 +167,45 @@ int lcr_sock = -1; struct admin_list { struct admin_list *next; - struct admin_msg msg; + struct admin_message msg; } *admin_first = NULL; static struct ast_channel_tech lcr_tech; /* + * logging + */ +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, ...) +{ + char buffer[1024]; + char call_text[128] = "NULL"; + char ast_text[128] = "NULL"; + va_list args; + + ast_mutex_lock(&log_lock); + + va_start(args,fmt); + vsnprintf(buffer,sizeof(buffer)-1,fmt,args); + buffer[sizeof(buffer)-1]=0; + va_end(args); + + if (call) + sprintf(call_text, "%d", call->ref); + if (ast) + strncpy(ast_text, ast->name, sizeof(ast_text)-1); + ast_text[sizeof(ast_text)-1] = '\0'; + + ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer); + + ast_mutex_unlock(&log_lock); +} + +/* * channel and call instances */ struct chan_call *call_first; -struct chan_call *find_call_ref(unsigned long ref) +struct chan_call *find_call_ref(unsigned int ref) { struct chan_call *call = call_first; @@ -170,32 +219,32 @@ struct chan_call *find_call_ref(unsigned long ref) } #if 0 -struct chan_call *find_call_handle(unsigned long handle) +struct chan_call *find_call_ast(struct ast_channel *ast) { struct chan_call *call = call_first; while(call) { - if (call->bchannel_handle == handle) + if (call->ast == ast) break; call = call->next; } return(call); } -#endif -struct chan_call *alloc_call(void) +struct chan_call *find_call_handle(unsigned int handle) { - struct chan_call **callp = &call_first; - - while(*callp) - callp = &((*callp)->next); + struct chan_call *call = call_first; - *callp = (struct chan_call *)malloc(sizeof(struct chan_call)); - if (*callp) - memset(*callp, 0, sizeof(struct chan_call)); - return(*callp); + while(call) + { + if (call->bchannel_handle == handle) + break; + call = call->next; + } + return(call); } +#endif void free_call(struct chan_call *call) { @@ -206,98 +255,314 @@ void free_call(struct chan_call *call) if (*temp == call) { *temp = (*temp)->next; - if (call->channel) + if (call->pipe[0] > -1) + close(call->pipe[0]); + if (call->pipe[1] > -1) + close(call->pipe[1]); + if (call->bchannel) + { + if (call->bchannel->call != call) + CERROR(call, NULL, "Linked bchannel structure has no link to us.\n"); + call->bchannel->call = NULL; + } + if (call->bridge_call) { - if (call->channel->call) - call->channel->call = NULL; + if (call->bridge_call->bridge_call != call) + CERROR(call, NULL, "Linked call structure has no link to us.\n"); + call->bridge_call->bridge_call = NULL; } + CDEBUG(call, NULL, "Call instance freed.\n"); free(call); return; } temp = &((*temp)->next); } + CERROR(call, NULL, "Call instance not found in list.\n"); +} + +struct chan_call *alloc_call(void) +{ + struct chan_call **callp = &call_first; + + while(*callp) + callp = &((*callp)->next); + + *callp = (struct chan_call *)calloc(1, sizeof(struct chan_call)); + if (*callp) + memset(*callp, 0, sizeof(struct chan_call)); + if (pipe((*callp)->pipe) < 0) { + CERROR(*callp, NULL, "Failed to create pipe.\n"); + free_call(*callp); + return(NULL); + } + CDEBUG(*callp, NULL, "Call instance allocated.\n"); + return(*callp); } -unsigned short new_brige_id(void) + +unsigned short new_bridge_id(void) { - struct bchannel *channel; + struct chan_call *call; unsigned short id = 1; /* search for lowest bridge id that is not in use and not 0 */ while(id) { - channel = bchannel_first; - while(channel) + call = call_first; + while(call) { - if (channel->bridge_id == id) + if (call->bridge_id == id) break; - channel = channel->next; + call = call->next; } - if (!channel) + if (!call) break; id++; } + CDEBUG(NULL, NULL, "New bridge ID %d.\n", id); return(id); } - -/* - * receive bchannel data - */ -void rx_data(struct bchannel *bchannel, unsigned char *data, int len) -{ -} - -void rx_dtmf(struct bchannel *bchannel, char tone) -{ -} - /* * enque message to LCR */ -int send_message(int message_type, unsigned long ref, union parameter *param) +int send_message(int message_type, unsigned int ref, union parameter *param) { struct admin_list *admin, **adminp; + if (lcr_sock < 0) { + CDEBUG(NULL, NULL, "Ignoring message %d, because socket is closed.\n", message_type); + return -1; + } + CDEBUG(NULL, NULL, "Sending %s to socket.\n", messages_txt[message_type]); + adminp = &admin_first; while(*adminp) adminp = &((*adminp)->next); - admin = (struct admin_list *)malloc(sizeof(struct admin_list)); + admin = (struct admin_list *)calloc(1, sizeof(struct admin_list)); + if (!admin) { + CERROR(NULL, NULL, "No memory for message to LCR.\n"); + return -1; + } *adminp = admin; - admin->msg.type = message_type; - admin->msg.ref = ref; - memcpy(&admin->msg.param, param, sizeof(union parameter)); + admin->msg.message = ADMIN_MESSAGE; + admin->msg.u.msg.type = message_type; + admin->msg.u.msg.ref = ref; + memcpy(&admin->msg.u.msg.param, param, sizeof(union parameter)); return(0); } /* + * apply options (in locked state) + */ +void apply_opt(struct chan_call *call, char *data) +{ + union parameter newparam; + char string[1024], *p = string, *opt, *key; + int gain, i, newmode = 0; + + if (!data[0]) + return; // no opts + + strncpy(string, data, sizeof(string)-1); + string[sizeof(string)-1] = '\0'; + + /* parse options */ + while((opt = strsep(&p, ":"))) + { + switch(opt[0]) { + case 'd': + if (opt[1] == '\0') { + CERROR(call, call->ast, "Option 'd' (display) expects parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 'd' (display) with text '%s'.\n", opt+1); + if (call->state == CHAN_LCR_STATE_OUT_PREPARE) + strncpy(call->display, opt+1, sizeof(call->display)-1); + else { + memset(&newparam, 0, sizeof(union parameter)); + strncpy(newparam.notifyinfo.display, opt+1, sizeof(newparam.notifyinfo.display)-1); + send_message(MESSAGE_NOTIFY, call->ref, &newparam); + } + break; + case 'n': + if (opt[1] != '\0') { + CERROR(call, call->ast, "Option 'n' (no DTMF) expects no parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 'n' (no DTMF).\n"); + call->no_dtmf = 1; + break; + case 'c': + if (opt[1] == '\0') { + CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter.\n", opt); + break; + } + key = opt+1; + /* check for 0xXXXX... type of key */ + if (!!strncmp((char *)key, "0x", 2)) { + CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter starting with '0x'.\n", opt); + break; + } + key+=2; + if (strlen(key) > 56*2 || (strlen(key) % 1)) { + CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with max 56 bytes ('0x' + 112 characters)\n", opt); + break; + } + i = 0; + while(*key) + { + if (*key>='0' && *key<='9') + call->bf_key[i] = (*key-'0') << 8; + else if (*key>='a' && *key<='f') + call->bf_key[i] = (*key-'a'+10) << 8; + else if (*key>='A' && *key<='F') + call->bf_key[i] = (*key-'A'+10) << 8; + else + break; + key++; + if (*key>='0' && *key<='9') + call->bf_key[i] += (*key - '0'); + else if (*key>='a' && *key<='f') + call->bf_key[i] += (*key - 'a' + 10); + else if (*key>='A' && *key<='F') + call->bf_key[i] += (*key - 'A' + 10); + else + break; + key++; + i++; + } + if (*key) { + CERROR(call, call->ast, "Option 'c' (encrypt) expects key parameter with hex values 0-9,a-f.\n"); + break; + } + call->bf_len = i; + CDEBUG(call, call->ast, "Option 'c' (encrypt) blowfish key '%s' (len=%d).\n", opt+1, i); + if (call->bchannel) + bchannel_blowfish(call->bchannel, call->bf_key, call->bf_len); + break; + case 'h': + if (opt[1] != '\0') { + CERROR(call, call->ast, "Option 'h' (HDLC) expects no parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 'h' (HDLC).\n"); + if (!call->hdlc) { + call->hdlc = 1; + newmode = 1; + } + break; + case 't': + if (opt[1] != '\0') { + CERROR(call, call->ast, "Option 't' (transparent) expects no parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 't' (transparent).\n"); + if (!call->transparent) { + call->transparent = 1; + newmode = 1; + } + break; + case 'e': + if (opt[1] == '\0') { + CERROR(call, call->ast, "Option 'e' (echo cancel) expects parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 'e' (echo cancel) with config '%s'.\n", opt+1); + strncpy(call->pipeline, opt+1, sizeof(call->pipeline)-1); + if (call->bchannel) + bchannel_pipeline(call->bchannel, call->pipeline); + break; + case 'r': + if (opt[1] == '\0') { + CERROR(call, call->ast, "Option 'r' (re-buffer 160 bytes) expects no parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 'r' (re-buffer 160 bytes)"); + call->rebuffer = 1; + break; +#if 0 + case 's': + if (opt[1] != '\0') { + CERROR(call, call->ast, "Option 's' (inband DTMF) expects no parameter.\n", opt); + break; + } + CDEBUG(call, call->ast, "Option 's' (inband DTMF).\n"); + call->inband_dtmf = 1; +todo + break; +#endif + case 'v': + if (opt[1] != 'r' && opt[1] != 't') { + CERROR(call, call->ast, "Option 'v' (volume) expects parameter.\n", opt); + break; + } + gain = atoi(opt+2); + if (gain < -8 || gain >8) { + CERROR(call, call->ast, "Option 'v' (volume) expects parameter in range of -8 through 8.\n"); + break; + } + CDEBUG(call, call->ast, "Option 'v' (volume) with gain 2^%d.\n", gain); + if (opt[1] == 'r') { + call->rx_gain = gain; + if (call->bchannel) + bchannel_gain(call->bchannel, call->rx_gain, 0); + } else { + call->tx_gain = gain; + if (call->bchannel) + bchannel_gain(call->bchannel, call->tx_gain, 1); + } + break; + default: + CERROR(call, call->ast, "Option '%s' unknown.\n", opt); + } + } + + /* re-open, if bchannel is created */ + if (call->bchannel && call->bchannel->b_sock > -1) { + bchannel_destroy(call->bchannel); + if (bchannel_create(call->bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0))) + bchannel_activate(call->bchannel, 1); + } +} + +/* * send setup info to LCR * this function is called, when asterisk call is received and ref is received */ static void send_setup_to_lcr(struct chan_call *call) { union parameter newparam; + struct ast_channel *ast = call->ast; if (!call->ast || !call->ref) return; + CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num); + /* send setup message to LCR */ memset(&newparam, 0, sizeof(union parameter)); + newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN; + newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN; + strncpy(newparam.setup.dialinginfo.id, call->dialstring, sizeof(newparam.setup.dialinginfo.id)-1); + strncpy(newparam.setup.dialinginfo.interfaces, call->interface, sizeof(newparam.setup.dialinginfo.interfaces)-1); newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN; - newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN; - if (call->ast->cid.cid_num) if (call->ast->cid.cid_num[0]) - strncpy(newparam.setup.callerinfo.id, call->ast->cid.cid_num, sizeof(newparam.setup.callerinfo.id)-1); - if (call->ast->cid.cid_name) if (call->ast->cid.cid_name[0]) - strncpy(newparam.setup.callerinfo.name, call->ast->cid.cid_name, sizeof(newparam.setup.callerinfo.name)-1); - if (call->ast->cid.cid_rdnis) if (call->ast->cid.cid_rdnis[0]) + newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN; + strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1); + call->display[0] = '\0'; + if (call->cid_num[0]) + strncpy(newparam.setup.callerinfo.id, call->cid_num, sizeof(newparam.setup.callerinfo.id)-1); + if (call->cid_name[0]) + strncpy(newparam.setup.callerinfo.name, call->cid_name, sizeof(newparam.setup.callerinfo.name)-1); + if (call->cid_rdnis[0]) { - strncpy(newparam.setup.redirinfo.id, call->ast->cid.cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1); + strncpy(newparam.setup.redirinfo.id, call->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1); newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN; newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN; } - switch(call->ast->cid.cid_pres & AST_PRES_RESTRICTION) + switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) { case AST_PRES_ALLOWED: newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED; @@ -311,7 +576,7 @@ static void send_setup_to_lcr(struct chan_call *call) default: newparam.setup.callerinfo.present = INFO_PRESENT_NULL; } - switch(call->ast->cid.cid_ton) + switch(ast->cid.cid_ton) { case 4: newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER; @@ -325,9 +590,8 @@ static void send_setup_to_lcr(struct chan_call *call) default: newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN; } - newparam.setup.capainfo.bearer_capa = call->ast->transfercapability; -#warning todo -// newparam.setup.capainfo.bearer_user = alaw 3, ulaw 2; + newparam.setup.capainfo.bearer_capa = ast->transfercapability; + newparam.setup.capainfo.bearer_info1 = (options.law=='a')?3:2; newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT; newparam.setup.capainfo.hlc = INFO_HLC_NONE; newparam.setup.capainfo.exthlc = INFO_HLC_NONE; @@ -346,9 +610,11 @@ static void send_dialque_to_lcr(struct chan_call *call) { union parameter newparam; - if (!call->ast || !call->ref || !call->dialque) + if (!call->ast || !call->ref || !call->dialque[0]) return; + CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque); + /* send setup message to LCR */ memset(&newparam, 0, sizeof(union parameter)); strncpy(newparam.information.id, call->dialque, sizeof(newparam.information.id)-1); @@ -364,11 +630,119 @@ static void bridge_message_if_bridged(struct chan_call *call, int message_type, { /* check bridge */ if (!call) return; - if (!call->channel) return; - if (!call->channel->bridge_channel) return; - if (!call->channel->bridge_channel->call) return; - if (!call->channel->bridge_channel->call->ref) return; - send_message(MESSAGE_RELEASE, call->channel->bridge_channel->call->ref, param); + if (!call->bridge_call) return; + CDEBUG(call, NULL, "Sending message due briding.\n"); + send_message(message_type, call->bridge_call->ref, param); +} + +/* + * send release message to LCR and import bchannel if exported + */ +static void send_release_and_import(struct chan_call *call, int cause, int location) +{ + union parameter newparam; + + /* importing channel */ + if (call->bchannel) { + memset(&newparam, 0, sizeof(union parameter)); + newparam.bchannel.type = BCHANNEL_RELEASE; + newparam.bchannel.handle = call->bchannel->handle; + send_message(MESSAGE_BCHANNEL, call->ref, &newparam); + } + /* sending release */ + memset(&newparam, 0, sizeof(union parameter)); + newparam.disconnectinfo.cause = cause; + newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; + send_message(MESSAGE_RELEASE, call->ref, &newparam); +} + +/* + * check if extension matches and start asterisk + * if it can match, proceed + * if not, release + */ +static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int complete) +{ + int cause, ret; + union parameter newparam; + + CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", ast->exten, ast->context, complete?"yes":"no"); + + if (complete) + { + /* if not match */ + if (!ast_canmatch_extension(ast, ast->context, ast->exten, 1, call->oad)) + { + CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", ast->exten, ast->context); + cause = 1; + goto release; + } + if (!ast_exists_extension(ast, ast->context, ast->exten, 1, call->oad)) + { + 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); + cause = 28; + goto release; + } + CDEBUG(call, ast, "Got 'sending complete', extensions matches.\n"); + /* send setup acknowledge to lcr */ + memset(&newparam, 0, sizeof(union parameter)); + send_message(MESSAGE_PROCEEDING, call->ref, &newparam); + + /* change state */ + call->state = CHAN_LCR_STATE_IN_PROCEEDING; + ast_setstate(ast, AST_STATE_OFFHOOK); + + goto start; + } + + if (ast_canmatch_extension(ast, ast->context, ast->exten, 1, call->oad)) + { + /* send setup acknowledge to lcr */ + if (call->state != CHAN_LCR_STATE_IN_DIALING) { + memset(&newparam, 0, sizeof(union parameter)); + send_message(MESSAGE_OVERLAP, call->ref, &newparam); + } + + /* change state */ + call->state = CHAN_LCR_STATE_IN_DIALING; + ast_setstate(ast, AST_STATE_OFFHOOK); + + /* if match, start pbx */ + if (ast_exists_extension(ast, ast->context, ast->exten, 1, call->oad)) { + CDEBUG(call, ast, "Extensions matches.\n"); + goto start; + } + + /* if can match */ + CDEBUG(call, ast, "Extensions may match, if more digits are dialed.\n"); + return; + } + + /* if not match */ + cause = 1; + release: + /* release lcr */ + CDEBUG(call, ast, "Releasing due to extension missmatch.\n"); + send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL); + call->ref = 0; + /* release asterisk */ + ast->hangupcause = call->cause; + /* change to release state */ + call->state = CHAN_LCR_STATE_RELEASE; + ast_hangup(ast); // call will be destroyed here + return; + + start: + /* send setup to asterisk */ + CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n"); + ret = ast_pbx_start(ast); + if (ret < 0) + { + cause = (ret==-2)?34:27; + goto release; + } + call->pbx_started = 1; + return; } /* @@ -377,39 +751,39 @@ static void bridge_message_if_bridged(struct chan_call *call, int message_type, static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param) { struct ast_channel *ast; - union parameter newparam; + + CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id); /* create asterisk channel instrance */ -#warning anstatt vom lcr "setup.exten" zu bekommen, sollten wir den context übertragen, der dann in der channel.conf zu dem richtigen ruleset führt. ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel); - if (!call->ast) + if (!ast) { /* release */ - memset(&newparam, 0, sizeof(union parameter)); - newparam.disconnectinfo.cause = CAUSE_RESSOURCEUNAVAIL; - newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - send_message(MESSAGE_RELEASE, call->ref, &newparam); + CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n"); + send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL); /* remove call */ free_call(call); return; } - /* set ast pointer */ + /* link together */ call->ast = ast; ast->tech_pvt = call; ast->tech = &lcr_tech; + ast->fds[0] = call->pipe[0]; /* fill setup information */ - if (param->setup.exten[0]) - strncpy(ast->exten, param->setup.exten, AST_MAX_EXTENSION); + if (param->setup.dialinginfo.id) + strncpy(ast->exten, param->setup.dialinginfo.id, AST_MAX_EXTENSION-1); + if (param->setup.context[0]) + strncpy(ast->context, param->setup.context, AST_MAX_CONTEXT-1); + else + strncpy(ast->context, param->setup.callerinfo.interface, AST_MAX_CONTEXT-1); if (param->setup.callerinfo.id[0]) ast->cid.cid_num = strdup(param->setup.callerinfo.id); if (param->setup.callerinfo.name[0]) ast->cid.cid_name = strdup(param->setup.callerinfo.name); -#warning todo -#if 0 if (param->setup.redirinfo.id[0]) - ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.name, param->setup.callerinfo.ntype, configfile->prefix_nat, configfile->prefix_inter)); -#endif + ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international)); switch (param->setup.callerinfo.present) { case INFO_PRESENT_ALLOWED: @@ -436,28 +810,25 @@ static void lcr_in_setup(struct chan_call *call, int message_type, union paramet ast->cid.cid_ton = 0; } ast->transfercapability = param->setup.capainfo.bearer_capa; + /* enable hdlc if transcap is data */ + if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED + || ast->transfercapability == INFO_BC_DATARESTRICTED + || ast->transfercapability == INFO_BC_VIDEO) + call->hdlc = 1; + strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1); /* configure channel */ -#warning todo -#if 0 - ast->nativeformat = configfile->lawformat; - ast->readformat = ast->rawreadformat = configfile->lawformat; - ast->writeformat = ast->rawwriteformat = configfile->lawformat; -#endif + ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW; + ast->readformat = ast->rawreadformat = ast->nativeformats; + ast->writeformat = ast->rawwriteformat = ast->nativeformats; + ast->priority = 1; ast->hangupcause = 0; /* change state */ call->state = CHAN_LCR_STATE_IN_SETUP; - /* send setup to asterisk */ - ast_pbx_start(ast); - - /* send setup acknowledge to lcr */ - memset(&newparam, 0, sizeof(union parameter)); - send_message(MESSAGE_OVERLAP, call->ref, &newparam); - - /* change state */ - call->state = CHAN_LCR_STATE_IN_DIALING; + if (!call->pbx_started) + lcr_start_pbx(call, ast, param->setup.dialinginfo.sending_complete); } /* @@ -467,8 +838,10 @@ static void lcr_in_overlap(struct chan_call *call, int message_type, union param { if (!call->ast) return; + CDEBUG(call, call->ast, "Incomming setup acknowledge from LCR.\n"); + /* send pending digits in dialque */ - if (call->dialque) + if (call->dialque[0]) send_dialque_to_lcr(call); /* change to overlap state */ call->state = CHAN_LCR_STATE_OUT_DIALING; @@ -479,11 +852,13 @@ static void lcr_in_overlap(struct chan_call *call, int message_type, union param */ static void lcr_in_proceeding(struct chan_call *call, int message_type, union parameter *param) { + CDEBUG(call, call->ast, "Incomming proceeding from LCR.\n"); + /* change state */ call->state = CHAN_LCR_STATE_OUT_PROCEEDING; - /* send event to asterisk */ - if (call->ast) - ast_queue_control(call->ast, AST_CONTROL_PROCEEDING); + /* queue event for asterisk */ + if (call->ast && call->pbx_started) + strncat(call->queue_string, "P", sizeof(call->queue_string)-1); } /* @@ -491,11 +866,13 @@ static void lcr_in_proceeding(struct chan_call *call, int message_type, union pa */ static void lcr_in_alerting(struct chan_call *call, int message_type, union parameter *param) { + CDEBUG(call, call->ast, "Incomming alerting from LCR.\n"); + /* change state */ call->state = CHAN_LCR_STATE_OUT_ALERTING; - /* send event to asterisk */ - if (call->ast) - ast_queue_control(call->ast, AST_CONTROL_RINGING); + /* queue event to asterisk */ + if (call->ast && call->pbx_started) + strncat(call->queue_string, "R", sizeof(call->queue_string)-1); } /* @@ -503,13 +880,24 @@ static void lcr_in_alerting(struct chan_call *call, int message_type, union para */ static void lcr_in_connect(struct chan_call *call, int message_type, union parameter *param) { + union parameter newparam; + + CDEBUG(call, call->ast, "Incomming connect (answer) from LCR.\n"); + /* change state */ call->state = CHAN_LCR_STATE_CONNECT; + /* request bchannel */ + if (!call->bchannel) { + CDEBUG(call, call->ast, "Requesting B-channel.\n"); + memset(&newparam, 0, sizeof(union parameter)); + newparam.bchannel.type = BCHANNEL_REQUEST; + send_message(MESSAGE_BCHANNEL, call->ref, &newparam); + } /* copy connectinfo */ memcpy(&call->connectinfo, ¶m->connectinfo, sizeof(struct connect_info)); - /* send event to asterisk */ - if (call->ast) - ast_queue_control(call->ast, AST_CONTROL_ANSWER); + /* queue event to asterisk */ + if (call->ast && call->pbx_started) + strncat(call->queue_string, "A", sizeof(call->queue_string)-1); } /* @@ -517,7 +905,9 @@ static void lcr_in_connect(struct chan_call *call, int message_type, union param */ static void lcr_in_disconnect(struct chan_call *call, int message_type, union parameter *param) { - union parameter newparam; + struct ast_channel *ast = call->ast; + + CDEBUG(call, call->ast, "Incomming disconnect from LCR. (cause=%d)\n", param->disconnectinfo.cause); /* change state */ call->state = CHAN_LCR_STATE_IN_DISCONNECT; @@ -525,23 +915,30 @@ static void lcr_in_disconnect(struct chan_call *call, int message_type, union pa call->cause = param->disconnectinfo.cause; call->location = param->disconnectinfo.location; /* if bridge, forward disconnect and return */ - if (call->channel) - if (call->channel->bridge_channel) - if (call->channel->bridge_channel->call) - { - bridge_message_if_bridged(call, message_type, param); - return; - } - /* release lcr */ - newparam.disconnectinfo.cause = CAUSE_NORMAL; - newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - send_message(MESSAGE_RELEASE, call->ref, &newparam); +#ifdef TODO + feature flag + if (call->bridge_call) + { + CDEBUG(call, call->ast, "Only signal disconnect via bridge.\n"); + bridge_message_if_bridged(call, message_type, param); + return; + } +#endif + /* release lcr with same cause */ + send_release_and_import(call, call->cause, call->location); call->ref = 0; - /* release asterisk */ - call->ast->hangupcause = call->cause; - ast_queue_hangup(call->ast); /* change to release state */ call->state = CHAN_LCR_STATE_RELEASE; + /* queue release asterisk */ + if (ast) + { + ast->hangupcause = call->cause; + if (call->pbx_started) + strcpy(call->queue_string, "H"); // overwrite other indications + else { + ast_hangup(ast); // call will be destroyed here + } + } } /* @@ -549,6 +946,10 @@ static void lcr_in_disconnect(struct chan_call *call, int message_type, union pa */ static void lcr_in_release(struct chan_call *call, int message_type, union parameter *param) { + struct ast_channel *ast = call->ast; + + CDEBUG(call, call->ast, "Incomming release from LCR, releasing ref. (cause=%d)\n", param->disconnectinfo.cause); + /* release ref */ call->ref = 0; /* change to release state */ @@ -559,11 +960,15 @@ static void lcr_in_release(struct chan_call *call, int message_type, union param call->cause = param->disconnectinfo.cause; call->location = param->disconnectinfo.location; } - /* if we have an asterisk instance, send hangup, else we are done */ - if (call->ast) + /* if we have an asterisk instance, queue hangup, else we are done */ + if (ast) { - call->ast->hangupcause = call->cause; - ast_queue_hangup(call->ast); + ast->hangupcause = call->cause; + if (call->pbx_started) + strcpy(call->queue_string, "H"); + else { + ast_hangup(ast); // call will be destroyed here + } } else { free_call(call); @@ -576,29 +981,30 @@ static void lcr_in_release(struct chan_call *call, int message_type, union param */ static void lcr_in_information(struct chan_call *call, int message_type, union parameter *param) { - struct ast_frame fr; - char *p; + struct ast_channel *ast = call->ast; - if (!call->ast) return; + CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id); - /* copy digits */ - p = param->information.id; - if (call->state == CHAN_LCR_STATE_IN_DIALING && *p) + if (!ast) return; + + /* pbx not started */ + if (!call->pbx_started) { - while (*p) - { - /* send digit to asterisk */ - memset(&fr, 0, sizeof(fr)); - fr.frametype = AST_FRAME_DTMF; - fr.subclass = *p; - fr.delivery = ast_tv(0, 0); - ast_queue_frame(call->ast, &fr); - p++; - } + CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n"); + strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1); + lcr_start_pbx(call, ast, param->information.sending_complete); + return; } + + /* queue digits */ + if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) + strncat(call->queue_string, param->information.id, sizeof(call->queue_string)-1); + /* use bridge to forware message not supported by asterisk */ - if (call->state == CHAN_LCR_STATE_CONNECT) + if (call->state == CHAN_LCR_STATE_CONNECT) { + CDEBUG(call, call->ast, "Call is connected, briding.\n"); bridge_message_if_bridged(call, message_type, param); + } } /* @@ -606,6 +1012,18 @@ static void lcr_in_information(struct chan_call *call, int message_type, union p */ static void lcr_in_notify(struct chan_call *call, int message_type, union parameter *param) { + union parameter newparam; + + CDEBUG(call, call->ast, "Incomming notify from LCR. (notify=%d)\n", param->notifyinfo.notify); + + /* request bchannel, if call is resumed and we don't have it */ + if (param->notifyinfo.notify == INFO_NOTIFY_USER_RESUMED && !call->bchannel && call->ref) { + CDEBUG(call, call->ast, "Reqesting bchannel at resume.\n"); + memset(&newparam, 0, sizeof(union parameter)); + newparam.bchannel.type = BCHANNEL_REQUEST; + send_message(MESSAGE_BCHANNEL, call->ref, &newparam); + } + if (!call->ast) return; /* use bridge to forware message not supported by asterisk */ @@ -617,6 +1035,8 @@ static void lcr_in_notify(struct chan_call *call, int message_type, union parame */ static void lcr_in_facility(struct chan_call *call, int message_type, union parameter *param) { + CDEBUG(call, call->ast, "Incomming facility from LCR.\n"); + if (!call->ast) return; /* use bridge to forware message not supported by asterisk */ @@ -624,13 +1044,32 @@ static void lcr_in_facility(struct chan_call *call, int message_type, union para } /* + * got dtmf from bchannel (locked state) + */ +void lcr_in_dtmf(struct chan_call *call, int val) +{ + struct ast_channel *ast = call->ast; + char digit[2]; + + if (!ast) + return; + if (!call->pbx_started) + return; + + CDEBUG(call, call->ast, "Recognised DTMF digit '%c'.\n", val); + digit[0] = val; + digit[1] = '\0'; + strncat(call->queue_string, digit, sizeof(call->queue_string)-1); +} + +/* * message received from LCR */ -int receive_message(int message_type, unsigned long ref, union parameter *param) +int receive_message(int message_type, unsigned int ref, union parameter *param) { - union parameter newparam; struct bchannel *bchannel; struct chan_call *call; + union parameter newparam; memset(&newparam, 0, sizeof(union parameter)); @@ -640,16 +1079,17 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) switch(param->bchannel.type) { case BCHANNEL_ASSIGN: + CDEBUG(NULL, NULL, "Received BCHANNEL_ASSIGN message. (handle=%08lx) for ref %d\n", param->bchannel.handle, ref); if ((bchannel = find_bchannel_handle(param->bchannel.handle))) { - fprintf(stderr, "error: bchannel handle %x already assigned.\n", (int)param->bchannel.handle); + CERROR(NULL, NULL, "bchannel handle %x already assigned.\n", (int)param->bchannel.handle); return(-1); } /* create bchannel */ bchannel = alloc_bchannel(param->bchannel.handle); if (!bchannel) { - fprintf(stderr, "error: alloc bchannel handle %x failed.\n", (int)param->bchannel.handle); + CERROR(NULL, NULL, "alloc bchannel handle %x failed.\n", (int)param->bchannel.handle); return(-1); } @@ -657,11 +1097,10 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) bchannel->b_tx_gain = param->bchannel.tx_gain; bchannel->b_rx_gain = param->bchannel.rx_gain; strncpy(bchannel->b_pipeline, param->bchannel.pipeline, sizeof(bchannel->b_pipeline)-1); - if (param->bchannel.crypt_len) + if (param->bchannel.crypt_len && param->bchannel.crypt_len <= sizeof(bchannel->b_bf_key)) { - bchannel->b_crypt_len = param->bchannel.crypt_len; - bchannel->b_crypt_type = param->bchannel.crypt_type; - memcpy(bchannel->b_crypt_key, param->bchannel.crypt, param->bchannel.crypt_len); + bchannel->b_bf_len = param->bchannel.crypt_len; + memcpy(bchannel->b_bf_key, param->bchannel.crypt, param->bchannel.crypt_len); } bchannel->b_txdata = 0; bchannel->b_dtmf = 1; @@ -670,28 +1109,47 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) /* in case, ref is not set, this bchannel instance must * be created until it is removed again by LCR */ /* link to call */ - if ((call = find_call_ref(ref))) + call = find_call_ref(ref); + if (call) { bchannel->call = call; - call->channel = bchannel; -#warning hier muesen alle stati gesetzt werden falls sie vor dem b-kanal verfügbar waren - if (bchannel->bridge_id) - bchannel_join(bchannel, bchannel->bridge_id); + call->bchannel = bchannel; + if (call->dtmf) + bchannel_dtmf(bchannel, 1); + if (call->bf_len) + bchannel_blowfish(bchannel, call->bf_key, call->bf_len); + if (call->pipeline[0]) + bchannel_pipeline(bchannel, call->pipeline); + if (call->rx_gain) + bchannel_gain(bchannel, call->rx_gain, 0); + if (call->tx_gain) + bchannel_gain(bchannel, call->tx_gain, 1); + if (call->bridge_id) { + CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n"); + bchannel_join(bchannel, call->bridge_id); + } + /* create only, if call exists, othewhise it bchannel is freed below... */ + if (bchannel_create(bchannel, ((call->transparent)?1:0) + ((call->hdlc)?2:0))) + bchannel_activate(bchannel, 1); } - if (bchannel_create(bchannel)) - bchannel_activate(bchannel, 1); - /* acknowledge */ newparam.bchannel.type = BCHANNEL_ASSIGN_ACK; newparam.bchannel.handle = param->bchannel.handle; send_message(MESSAGE_BCHANNEL, 0, &newparam); + /* if call has released before bchannel is assigned */ + if (!call) { + newparam.bchannel.type = BCHANNEL_RELEASE; + newparam.bchannel.handle = param->bchannel.handle; + send_message(MESSAGE_BCHANNEL, 0, &newparam); + } + break; case BCHANNEL_REMOVE: + CDEBUG(NULL, NULL, "Received BCHANNEL_REMOVE message. (handle=%08lx)\n", param->bchannel.handle); if (!(bchannel = find_bchannel_handle(param->bchannel.handle))) { - #warning alle fprintf nach ast_log - fprintf(stderr, "error: bchannel handle %x not assigned.\n", (int)param->bchannel.handle); + CERROR(NULL, NULL, "Bchannel handle %x not assigned.\n", (int)param->bchannel.handle); return(-1); } /* unklink from call and destroy bchannel */ @@ -705,7 +1163,7 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) break; default: - fprintf(stderr, "received unknown bchannel message %d\n", param->bchannel.type); + CDEBUG(NULL, NULL, "Received unknown bchannel message %d.\n", param->bchannel.type); } return(0); } @@ -716,9 +1174,10 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) if (param->direction) { /* new ref from lcr */ + CDEBUG(NULL, NULL, "Received new ref by LCR, due to incomming call. (ref=%ld)\n", ref); if (!ref || find_call_ref(ref)) { - fprintf(stderr, "illegal new ref %ld received\n", ref); + CERROR(NULL, NULL, "Illegal new ref %ld received.\n", ref); return(-1); } /* allocate new call instance */ @@ -731,13 +1190,13 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) } else { /* new ref, as requested from this remote application */ + CDEBUG(NULL, NULL, "Received new ref by LCR, as requested from chan_lcr. (ref=%ld)\n", ref); call = find_call_ref(0); if (!call) { /* send release, if ref does not exist */ - newparam.disconnectinfo.cause = CAUSE_NORMAL; - newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - send_message(MESSAGE_RELEASE, ref, &newparam); + CDEBUG(NULL, NULL, "No call found, that requests a ref.\n"); + send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL); return(0); } /* store new ref */ @@ -750,15 +1209,9 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) { /* send release */ if (call->cause) - { - newparam.disconnectinfo.cause = call->cause; - newparam.disconnectinfo.location = call->location; - } else - { - newparam.disconnectinfo.cause = 16; - newparam.disconnectinfo.location = 5; - } - send_message(MESSAGE_RELEASE, ref, &newparam); + send_release_and_import(call, call->cause, call->location); + else + send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL); /* free call */ free_call(call); return(0); @@ -770,13 +1223,14 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) /* check ref */ if (!ref) { - fprintf(stderr, "received message %d without ref\n", message_type); + CERROR(NULL, NULL, "Received message %d without ref.\n", message_type); return(-1); } call = find_call_ref(ref); if (!call) { /* ignore ref that is not used (anymore) */ + CDEBUG(NULL, NULL, "Message %d from LCR ignored, because no call instance found.\n", message_type); return(0); } @@ -812,7 +1266,7 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) break; case MESSAGE_INFORMATION: - lcr_in_disconnect(call, message_type, param); + lcr_in_information(call, message_type, param); break; case MESSAGE_NOTIFY: @@ -823,26 +1277,63 @@ int receive_message(int message_type, unsigned long ref, union parameter *param) lcr_in_facility(call, message_type, param); break; - case MESSAGE_PATTERN: -#warning todo + case MESSAGE_PATTERN: // audio available from LCR break; - case MESSAGE_NOPATTERN: -#warning todo + case MESSAGE_NOPATTERN: // audio not available from LCR break; - case MESSAGE_AUDIOPATH: -#warning todo + case MESSAGE_AUDIOPATH: // if remote audio connected or hold + call->audiopath = param->audiopath; break; default: -#warning unhandled + CDEBUG(call, call->ast, "Message %d from LCR unhandled.\n", message_type); break; } return(0); } - +/* + * release all calls (due to broken socket) + */ +static void release_all_calls(void) +{ + struct chan_call *call; + +again: + call = call_first; + while(call) { + /* no ast, so we may directly free call */ + if (!call->ast) { + CDEBUG(call, NULL, "Freeing call, because no Asterisk channel is linked.\n"); + free_call(call); + goto again; + } + /* already in release process */ + if (call->state == CHAN_LCR_STATE_RELEASE) { + call = call->next; + continue; + } + /* release or queue release */ + call->ref = 0; + call->state = CHAN_LCR_STATE_RELEASE; + if (!call->pbx_started) { + CDEBUG(call, call->ast, "Releasing call, because no Asterisk channel is not started.\n"); + ast_hangup(call->ast); // call will be destroyed here + goto again; + } + CDEBUG(call, call->ast, "Queue call release, because Asterisk channel is running.\n"); + strcpy(call->queue_string, "H"); + call = call->next; + } + + /* release all bchannels */ + while(bchannel_first) + free_bchannel(bchannel_first); +} + + /* asterisk handler * warning! not thread safe * returns -1 for socket error, 0 for no work, 1 for work @@ -851,39 +1342,35 @@ int handle_socket(void) { int work = 0; int len; - struct admin_message msg; struct admin_list *admin; + struct admin_message msg; - int sock; - - #warning SOCKET FEHLT! /* read from socket */ - len = read(sock, &msg, sizeof(msg)); + len = read(lcr_sock, &msg, sizeof(msg)); if (len == 0) { - printf("Socket closed\n"); + CERROR(NULL, NULL, "Socket closed.\n"); return(-1); // socket closed } if (len > 0) { if (len != sizeof(msg)) { - fprintf(stderr, "Socket short read (%d)\n", len); + CERROR(NULL, NULL, "Socket short read. (len %d)\n", len); return(-1); // socket error } if (msg.message != ADMIN_MESSAGE) { - fprintf(stderr, "Socket received illegal message %d\n", msg.message); - return(-1); // socket error + CERROR(NULL, NULL, "Socket received illegal message %d.\n", msg.message); + return(-1); } receive_message(msg.u.msg.type, msg.u.msg.ref, &msg.u.msg.param); - printf("message received %d\n", msg.u.msg.type); work = 1; } else { if (errno != EWOULDBLOCK) { - fprintf(stderr, "Socket error %d\n", errno); + CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno); return(-1); } } @@ -892,17 +1379,17 @@ int handle_socket(void) if (!admin_first) return(work); admin = admin_first; - len = write(sock, &admin->msg, sizeof(msg)); + len = write(lcr_sock, &admin->msg, sizeof(msg)); if (len == 0) { - printf("Socket closed\n"); + CERROR(NULL, NULL, "Socket closed.\n"); return(-1); // socket closed } if (len > 0) { if (len != sizeof(msg)) { - fprintf(stderr, "Socket short write (%d)\n", len); + CERROR(NULL, NULL, "Socket short write. (len %d)\n", len); return(-1); // socket error } /* free head */ @@ -914,7 +1401,7 @@ int handle_socket(void) { if (errno != EWOULDBLOCK) { - fprintf(stderr, "Socket error %d\n", errno); + CERROR(NULL, NULL, "Socket failed (errno %d).\n", errno); return(-1); } } @@ -928,18 +1415,17 @@ int handle_socket(void) int open_socket(void) { int ret; - int sock; char *socket_name = SOCKET_NAME; int conn; struct sockaddr_un sock_address; - unsigned long on = 1; + unsigned int on = 1; union parameter param; /* open socket */ - if ((sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) + if ((lcr_sock = socket(PF_UNIX, SOCK_STREAM, 0)) < 0) { - ast_log(LOG_ERROR, "Failed to create socket.\n"); - return(sock); + CERROR(NULL, NULL, "Failed to create socket.\n"); + return(lcr_sock); } /* set socket address and name */ @@ -948,18 +1434,20 @@ int open_socket(void) strcpy(sock_address.sun_path, socket_name); /* connect socket */ - if ((conn = connect(sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) + if ((conn = connect(lcr_sock, (struct sockaddr *)&sock_address, SUN_LEN(&sock_address))) < 0) { - close(sock); - ast_log(LOG_ERROR, "Failed to connect to socket \"%s\". Is LCR running?\n", sock_address.sun_path); + close(lcr_sock); + lcr_sock = -1; + CDEBUG(NULL, NULL, "Failed to connect to socket '%s'. Is LCR running?\n", sock_address.sun_path); return(conn); } /* set non-blocking io */ - if ((ret = ioctl(sock, FIONBIO, (unsigned char *)(&on))) < 0) + if ((ret = ioctl(lcr_sock, FIONBIO, (unsigned char *)(&on))) < 0) { - close(sock); - ast_log(LOG_ERROR, "Failed to set socket into non-blocking IO.\n"); + close(lcr_sock); + lcr_sock = -1; + CERROR(NULL, NULL, "Failed to set socket into non-blocking IO.\n"); return(ret); } @@ -968,47 +1456,167 @@ int open_socket(void) strcpy(param.hello.application, "asterisk"); send_message(MESSAGE_HELLO, 0, ¶m); - return(sock); + return(lcr_sock); } -void close_socket(int sock) +void close_socket(void) { + struct admin_list *admin, *temp; + + /* flush pending messages */ + admin = admin_first; + while(admin) { + temp = admin; + admin = admin->next; + free(temp); + } + admin_first = NULL; + /* close socket */ - if (socket >= 0) - close(sock); + if (lcr_sock >= 0) + close(lcr_sock); + lcr_sock = -1; +} + + +/* sending queue to asterisk */ +static int queue_send(void) +{ + int work = 0; + struct chan_call *call; + struct ast_channel *ast; + struct ast_frame fr; + char *p; + + call = call_first; + while(call) { + p = call->queue_string; + ast = call->ast; + if (*p && ast) { + /* there is something to queue */ + if (!ast_channel_trylock(ast)) { /* succeed */ + while(*p) { + switch (*p) { + case 'P': + CDEBUG(call, ast, "Sending queued PROCEEDING to Asterisk.\n"); + ast_queue_control(ast, AST_CONTROL_PROCEEDING); + break; + case 'R': + CDEBUG(call, ast, "Sending queued RINGING to Asterisk.\n"); + ast_queue_control(ast, AST_CONTROL_RINGING); + break; + case 'A': + CDEBUG(call, ast, "Sending queued ANSWER to Asterisk.\n"); + ast_queue_control(ast, AST_CONTROL_ANSWER); + break; + case 'H': + CDEBUG(call, ast, "Sending queued HANGUP to Asterisk.\n"); + ast_queue_hangup(ast); + break; + case '1': case '2': case '3': case 'a': + case '4': case '5': case '6': case 'b': + case '7': case '8': case '9': case 'c': + case '*': case '0': case '#': case 'd': + CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p); + /* send digit to asterisk */ + memset(&fr, 0, sizeof(fr)); + fr.frametype = AST_FRAME_DTMF; + fr.subclass = *p; + fr.delivery = ast_tv(0, 0); + fr.len = 100; + ast_queue_frame(ast, &fr); + break; + default: + CDEBUG(call, ast, "Ignoring queued digit 0x%02d.\n", *p); + } + p++; + } + call->queue_string[0] = '\0'; + ast_channel_unlock(ast); + work = 1; + } + } + call = call->next; + } + + return work; } +/* signal handler */ +void sighandler(int sigset) +{ +} + +/* chan_lcr thread */ static void *chan_thread(void *arg) { int work; + int ret; + union parameter param; + time_t retry = 0, now; - pthread_mutex_lock(&chan_lock); + bchannel_pid = getpid(); - while(!quit) - { +// signal(SIGPIPE, sighandler); + + memset(¶m, 0, sizeof(union parameter)); + if (lcr_sock < 0) + time(&retry); + + ast_mutex_lock(&chan_lock); + + while(!quit) { work = 0; - /* handle socket */ - int ret = handle_socket(); - if (ret < 0) - break; - if (ret) - work = 1; + if (lcr_sock > 0) { + /* handle socket */ + ret = handle_socket(); + if (ret < 0) { + CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n"); + close_socket(); + release_all_calls(); + time(&retry); + } + if (ret) + work = 1; + } else { + time(&now); + if (retry && now-retry > 5) { + CDEBUG(NULL, NULL, "Retry to open socket.\n"); + retry = 0; + if (open_socket() < 0) { + time(&retry); + } + work = 1; + } + + } /* handle mISDN */ ret = bchannel_handle(); if (ret) work = 1; - - if (!work) - { - pthread_mutex_unlock(&chan_lock); + + /* handle messages to asterisk */ + ret = queue_send(); + if (ret) + work = 1; + + /* delay if no work done */ + if (!work) { + ast_mutex_unlock(&chan_lock); usleep(30000); - pthread_mutex_lock(&chan_lock); + ast_mutex_lock(&chan_lock); } } + + close_socket(); + + CERROR(NULL, NULL, "Thread exit.\n"); - pthread_mutex_unlock(&chan_lock); + ast_mutex_unlock(&chan_lock); + +// signal(SIGPIPE, SIG_DFL); return NULL; } @@ -1016,49 +1624,87 @@ static void *chan_thread(void *arg) /* * new asterisk instance */ -static struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause) +static +struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause) { - union parameter newparam; + char exten[256], *dial, *interface, *opt; struct ast_channel *ast; + struct chan_call *call; + + ast_mutex_lock(&chan_lock); + CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data); - pthread_mutex_lock(&chan_lock); + /* if socket is closed */ + if (lcr_sock < 0) + { + CERROR(NULL, NULL, "Rejecting call from Asterisk, because LCR not running.\n"); + ast_mutex_unlock(&chan_lock); + return NULL; + } /* create call instance */ call = alloc_call(); if (!call) { /* failed to create instance */ + ast_mutex_unlock(&chan_lock); return NULL; } + /* create asterisk channel instrance */ - ast = ast_channel_alloc(1); + ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel); if (!ast) { + CERROR(NULL, NULL, "Failed to create Asterisk channel.\n"); free_call(call); /* failed to create instance */ + ast_mutex_unlock(&chan_lock); return NULL; } - /* link together */ - ast->tech_pvt = call; - call->ast = ast; ast->tech = &lcr_tech; + ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call /* configure channel */ - ast->state = AST_STATE_RESERVED; - snprintf(ast->name, sizeof(ast->name), "%s/%d", lcr_type, ++glob_channel); - ast->name[sizeof(ast->name)-1] = '\0'; - ast->type = lcr_type; - ast->nativeformat = configfile->lawformat; - ast->readformat = ast->rawreadformat = configfile->lawformat; - ast->writeformat = ast->rawwriteformat = configfile->lawformat; + ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW; + ast->readformat = ast->rawreadformat = ast->nativeformats; + ast->writeformat = ast->rawwriteformat = ast->nativeformats; + ast->priority = 1; ast->hangupcause = 0; - /* send MESSAGE_NEWREF */ - memset(&newparam, 0, sizeof(union parameter)); - newparam.direction = 0; /* request from app */ - send_message(MESSAGE_NEWREF, 0, &newparam); + + /* link together */ + call->ast = ast; + ast->tech_pvt = call; + ast->fds[0] = call->pipe[0]; + call->pbx_started = 0; /* set state */ call->state = CHAN_LCR_STATE_OUT_PREPARE; - pthread_mutex_unlock(&chan_lock); + /* + * Extract interface, dialstring, options from data. + * Formats can be: + * + * / + * //options + */ + strncpy(exten, (char *)data, sizeof(exten)-1); + exten[sizeof(exten)-1] = '\0'; + if ((dial = strchr(exten, '/'))) { + *dial++ = '\0'; + interface = exten; + if ((opt = strchr(dial, '/'))) + *opt++ = '\0'; + else + opt = ""; + } else { + dial = exten; + interface = ""; + opt = ""; + } + strncpy(call->interface, interface, sizeof(call->interface)-1); + strncpy(call->dialstring, dial, sizeof(call->dialstring)-1); + apply_opt(call, (char *)opt); + + ast_mutex_unlock(&chan_lock); + return ast; } /* @@ -1067,114 +1713,182 @@ static struct ast_channel *lcr_request(const char *type, int format, void *data, static int lcr_call(struct ast_channel *ast, char *dest, int timeout) { union parameter newparam; - struct chan_call *call=ast->tech_pvt; - char buf[128]; - char *port_str, *dad, *p; - - if (!call) return -1; + struct chan_call *call; - pthread_mutex_lock(&chan_lock); - - hier muss noch - ast_copy_string(buf, dest, sizeof(buf)-1); - p=buf; - port_str=strsep(&p, "/"); - dad=strsep(&p, "/"); + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n"); + ast_mutex_unlock(&chan_lock); + return -1; + } - /* send setup message, if we already have a callref */ - if (call->ref) - send_setup_to_lcr(call); + CDEBUG(NULL, ast, "Received call from Asterisk.\n"); - if (lcr_debug) - ast_verbose("Call: ext:%s dest:(%s) -> dad(%s) \n", ast->exten,dest, dad); + /* pbx process is started */ + call->pbx_started = 1; + /* send MESSAGE_NEWREF */ + memset(&newparam, 0, sizeof(union parameter)); + newparam.direction = 0; /* request from app */ + send_message(MESSAGE_NEWREF, 0, &newparam); -#warning hier müssen wi eine der geholten REFs nehmen und ein SETUP schicken, die INFOS zum SETUP stehen im Ast pointer drin, bzw. werden hier übergeben. - - pthread_mutex_unlock(&chan_lock); + /* set hdlc if capability requires hdlc */ + if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED + || ast->transfercapability == INFO_BC_DATARESTRICTED + || ast->transfercapability == INFO_BC_VIDEO) + call->hdlc = 1; + /* if hdlc is forced by option, we change transcap to data */ + if (call->hdlc + && ast->transfercapability != INFO_BC_DATAUNRESTRICTED + && ast->transfercapability != INFO_BC_DATARESTRICTED + && ast->transfercapability != INFO_BC_VIDEO) + ast->transfercapability = INFO_BC_DATAUNRESTRICTED; + + call->cid_num[0] = 0; + call->cid_name[0] = 0; + call->cid_rdnis[0] = 0; + + if (ast->cid.cid_num) if (ast->cid.cid_num[0]) + strncpy(call->cid_num, ast->cid.cid_num, + sizeof(call->cid_num)-1); + + if (ast->cid.cid_name) if (ast->cid.cid_name[0]) + strncpy(call->cid_name, ast->cid.cid_name, + sizeof(call->cid_name)-1); + if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0]) + strncpy(call->cid_rdnis, ast->cid.cid_rdnis, + sizeof(call->cid_rdnis)-1); + + ast_mutex_unlock(&chan_lock); return 0; } -static int lcr_digit(struct ast_channel *ast, char digit) +static int lcr_digit_begin(struct ast_channel *ast, char digit) { + struct chan_call *call; union parameter newparam; char buf[]="x"; - if (!call) return -1; - /* only pass IA5 number space */ if (digit > 126 || digit < 32) return 0; - pthread_mutex_lock(&chan_lock); + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n"); + ast_mutex_unlock(&chan_lock); + return -1; + } + + CDEBUG(call, ast, "Received digit '%c' from Asterisk.\n", digit); /* send information or queue them */ if (call->ref && call->state == CHAN_LCR_STATE_OUT_DIALING) { + CDEBUG(call, ast, "Sending digit to LCR, because we are in dialing state.\n"); memset(&newparam, 0, sizeof(union parameter)); - newparam.dialinginfo.id[0] = digit; - newparam.dialinginfo.id[1] = '\0'; + newparam.information.id[0] = digit; + newparam.information.id[1] = '\0'; send_message(MESSAGE_INFORMATION, call->ref, &newparam); } else if (!call->ref - && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)); + && (call->state == CHAN_LCR_STATE_OUT_PREPARE || call->state == CHAN_LCR_STATE_OUT_SETUP)) { + CDEBUG(call, ast, "Queue digits, because we are in setup/dialing state and have no ref yet.\n"); *buf = digit; - strncat(call->dialque, buf, strlen(char->dialque)-1); + strncat(call->dialque, buf, strlen(call->dialque)-1); } - pthread_mutex_unlock(&chan_lock); - + ast_mutex_unlock(&chan_lock); return(0); } -static int lcr_answer(struct ast_channel *c) +static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration) { - union parameter newparam; - struct chan_call *call=c->tech_pvt; - - if (!call) return -1; + printf("DIGIT END %c\n", digit); + return (0); +} - pthread_mutex_lock(&chan_lock); +static int lcr_answer(struct ast_channel *ast) +{ + union parameter newparam; + struct chan_call *call; - /* check bridged connectinfo */ - if (call->bchannel) - if (call->bchannel->bridge_channel) - if (call->bchannel->bridge_channel->call) - { - memcpy(call->connectinfo, call->bchannel->bridge_channel->call->connectinfo, sizeof(struct connect_info)); - } + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n"); + ast_mutex_unlock(&chan_lock); + return -1; + } + + CDEBUG(call, ast, "Received answer from Asterisk.\n"); + + /* copy connectinfo, if bridged */ + if (call->bridge_call) + memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info)); /* send connect message to lcr */ memset(&newparam, 0, sizeof(union parameter)); - memcpy(param->connectinfo, call->connectinfo, sizeof(struct connect_info)); + memcpy(&newparam.connectinfo, &call->connectinfo, sizeof(struct connect_info)); send_message(MESSAGE_CONNECT, call->ref, &newparam); /* change state */ call->state = CHAN_LCR_STATE_CONNECT; + /* request bchannel */ + if (!call->bchannel) { + CDEBUG(call, ast, "Requesting B-channel.\n"); + memset(&newparam, 0, sizeof(union parameter)); + newparam.bchannel.type = BCHANNEL_REQUEST; + send_message(MESSAGE_BCHANNEL, call->ref, &newparam); + } + /* enable keypad */ +// memset(&newparam, 0, sizeof(union parameter)); +// send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam); + /* enable dtmf */ + if (call->no_dtmf) + CDEBUG(call, ast, "DTMF is disabled by option.\n"); + else + call->dtmf = 1; - pthread_mutex_unlock(&chan_lock); + ast_mutex_unlock(&chan_lock); return 0; } static int lcr_hangup(struct ast_channel *ast) { - union parameter newparam; - struct chan_call *call = ast->tech_pvt; + struct chan_call *call; + pthread_t tid = pthread_self(); + + if (!pthread_equal(tid, chan_tid)) + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n"); + if (!pthread_equal(tid, chan_tid)) + ast_mutex_unlock(&chan_lock); + return -1; + } - if (!call) - return 0; + if (!pthread_equal(tid, chan_tid)) + CDEBUG(call, ast, "Received hangup from Asterisk thread.\n"); + else + CDEBUG(call, ast, "Received hangup from LCR thread.\n"); - pthread_mutex_lock(&chan_lock); /* disconnect asterisk, maybe not required */ ast->tech_pvt = NULL; + ast->fds[0] = -1; if (call->ref) { /* release */ - memset(&newparam, 0, sizeof(union parameter)); - newparam.disconnectinfo.cause = CAUSE_RESSOURCEUNAVAIL; - newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; - send_message(MESSAGE_RELEASE, call->ref, &newparam); + CDEBUG(call, ast, "Releasing ref and freeing call instance.\n"); + if (ast->hangupcause > 0) + send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL); + else + send_release_and_import(call, CAUSE_RESSOURCEUNAVAIL, LOCATION_PRIVATE_LOCAL); /* remove call */ free_call(call); - pthread_mutex_unlock(&chan_lock); + if (!pthread_equal(tid, chan_tid)) + ast_mutex_unlock(&chan_lock); return 0; } else { @@ -1182,107 +1896,347 @@ static int lcr_hangup(struct ast_channel *ast) if (call->state == CHAN_LCR_STATE_RELEASE) { /* we get the response to our release */ + CDEBUG(call, ast, "Freeing call instance, because we have no ref AND we are requesting no ref.\n"); free_call(call); } else { /* during prepare, we change to release state */ + CDEBUG(call, ast, "We must wait until we received our ref, until we can free call instance.\n"); call->state = CHAN_LCR_STATE_RELEASE; } } - pthread_mutex_unlock(&chan_lock); + if (!pthread_equal(tid, chan_tid)) + ast_mutex_unlock(&chan_lock); return 0; } static int lcr_write(struct ast_channel *ast, struct ast_frame *f) { - struct chan_call *call= ast->tech_pvt; - if (!call) return 0; - pthread_mutex_lock(&chan_lock); - pthread_mutex_unlock(&chan_lock); + struct chan_call *call; + + if (!f->subclass) + CDEBUG(NULL, ast, "No subclass\n"); + if (!(f->subclass & ast->nativeformats)) + CDEBUG(NULL, ast, "Unexpected format.\n"); + + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + ast_mutex_unlock(&chan_lock); + return -1; + } + if (call->bchannel && f->samples) + bchannel_transmit(call->bchannel, f->data, f->samples); + ast_mutex_unlock(&chan_lock); + return 0; } static struct ast_frame *lcr_read(struct ast_channel *ast) { - struct chan_call *call = ast->tech_pvt; - if (!call) return 0; - pthread_mutex_lock(&chan_lock); - pthread_mutex_unlock(&chan_lock); + struct chan_call *call; + int i, len; + unsigned char *p; + + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + ast_mutex_unlock(&chan_lock); + return NULL; + } + if (call->pipe[0] > -1) { + if (call->rebuffer) { + len = read(call->pipe[0], call->read_buff, 160); + } else { + len = read(call->pipe[0], call->read_buff, sizeof(call->read_buff)); + } + if (len <= 0) { + close(call->pipe[0]); + call->pipe[0] = -1; + return NULL; + } + } + + p = call->read_buff; + for (i = 0; i < len; i++) { + *p = flip_bits[*p]; + p++; + } + + call->read_fr.frametype = AST_FRAME_VOICE; + call->read_fr.subclass = ast->nativeformats; + call->read_fr.datalen = len; + call->read_fr.samples = len; + call->read_fr.delivery = ast_tv(0,0); + call->read_fr.data = call->read_buff; + ast_mutex_unlock(&chan_lock); + + return &call->read_fr; } static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen) { union parameter newparam; - int res = -1; - - if (!call) return -1; - - pthread_mutex_lock(&chan_lock); + int res = 0; + struct chan_call *call; + + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n"); + ast_mutex_unlock(&chan_lock); + return -1; + } switch (cond) { case AST_CONTROL_BUSY: - /* send message to lcr */ - memset(&newparam, 0, sizeof(union parameter)); - newparam.disconnectinfo.cause = 17; - newparam.disconnectinfo.location = 5; - send_message(MESSAGE_DISCONNECT, call->ref, &newparam); - /* change state */ - call->state = CHAN_LCR_STATE_OUT_DISCONNECT; - /* return */ - pthread_mutex_unlock(&chan_lock); - return 0; + CDEBUG(call, ast, "Received indicate AST_CONTROL_BUSY from Asterisk.\n"); + ast_setstate(ast, AST_STATE_BUSY); + if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) { + /* send message to lcr */ + memset(&newparam, 0, sizeof(union parameter)); + newparam.disconnectinfo.cause = 17; + newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; + send_message(MESSAGE_DISCONNECT, call->ref, &newparam); + /* change state */ + call->state = CHAN_LCR_STATE_OUT_DISCONNECT; + } + break; case AST_CONTROL_CONGESTION: - /* return */ - pthread_mutex_unlock(&chan_lock); - return -1; + CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause); + if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) { + /* send message to lcr */ + memset(&newparam, 0, sizeof(union parameter)); + newparam.disconnectinfo.cause = ast->hangupcause; + newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL; + send_message(MESSAGE_DISCONNECT, call->ref, &newparam); + /* change state */ + call->state = CHAN_LCR_STATE_OUT_DISCONNECT; + } + break; + case AST_CONTROL_PROCEEDING: + CDEBUG(call, ast, "Received indicate AST_CONTROL_PROCEEDING from Asterisk.\n"); + if (call->state == CHAN_LCR_STATE_IN_SETUP + || call->state == CHAN_LCR_STATE_IN_DIALING) { + /* send message to lcr */ + memset(&newparam, 0, sizeof(union parameter)); + send_message(MESSAGE_PROCEEDING, call->ref, &newparam); + /* change state */ + call->state = CHAN_LCR_STATE_IN_PROCEEDING; + } + break; case AST_CONTROL_RINGING: - /* send message to lcr */ - memset(&newparam, 0, sizeof(union parameter)); - send_message(MESSAGE_ALERTING, call->ref, &newparam); - /* change state */ - call->state = CHAN_LCR_STATE_OUT_ALERTING; - /* return */ - pthread_mutex_unlock(&chan_lock); - return 0; + CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n"); + ast_setstate(ast, AST_STATE_RINGING); + if (call->state == CHAN_LCR_STATE_IN_SETUP + || call->state == CHAN_LCR_STATE_IN_DIALING + || call->state == CHAN_LCR_STATE_IN_PROCEEDING) { + /* send message to lcr */ + memset(&newparam, 0, sizeof(union parameter)); + send_message(MESSAGE_ALERTING, call->ref, &newparam); + /* change state */ + call->state = CHAN_LCR_STATE_IN_ALERTING; + } + break; case -1: - /* return */ - pthread_mutex_unlock(&chan_lock); - return 0; + CDEBUG(call, ast, "Received indicate -1.\n"); + res = -1; + break; case AST_CONTROL_VIDUPDATE: + CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n"); res = -1; break; case AST_CONTROL_HOLD: + CDEBUG(call, ast, "Received indicate AST_CONTROL_HOLD from Asterisk.\n"); /* send message to lcr */ memset(&newparam, 0, sizeof(union parameter)); newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_HOLD; send_message(MESSAGE_NOTIFY, call->ref, &newparam); + + /*start music onhold*/ + ast_moh_start(ast,data,ast->musicclass); break; case AST_CONTROL_UNHOLD: + CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n"); /* send message to lcr */ memset(&newparam, 0, sizeof(union parameter)); newparam.notifyinfo.notify = INFO_NOTIFY_REMOTE_RETRIEVAL; send_message(MESSAGE_NOTIFY, call->ref, &newparam); - break; + + /*stop moh*/ + ast_moh_stop(ast); + break; default: - ast_log(LOG_WARNING, "Don't know how to display condition %d on %s\n", cond, c->name); - /* return */ - pthread_mutex_unlock(&chan_lock); - return -1; + CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond); + res = -1; + break; } /* return */ - pthread_mutex_unlock(&chan_lock); - return 0; + ast_mutex_unlock(&chan_lock); + return res; +} + +/* + * fixup asterisk + */ +static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *newast) +{ + struct chan_call *call; + + ast_mutex_lock(&chan_lock); + call = oldast->tech_pvt; + if (!call) { + CERROR(NULL, oldast, "Received fixup from Asterisk, but no call instance exists.\n"); + ast_mutex_unlock(&chan_lock); + return -1; + } + + CDEBUG(call, oldast, "Received fixup from Asterisk.\n"); + call->ast = newast; + ast_mutex_lock(&chan_lock); + return 0; +} + +/* + * send_text asterisk + */ +static int lcr_send_text(struct ast_channel *ast, const char *text) +{ + struct chan_call *call; + union parameter newparam; + + ast_mutex_lock(&chan_lock); + call = ast->tech_pvt; + if (!call) { + CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n"); + ast_mutex_unlock(&chan_lock); + return -1; + } + + CDEBUG(call, ast, "Received send_text from Asterisk. (text=%s)\n", text); + memset(&newparam, 0, sizeof(union parameter)); + strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1); + send_message(MESSAGE_NOTIFY, call->ref, &newparam); + ast_mutex_lock(&chan_lock); + return 0; } +/* + * bridge process + */ +enum ast_bridge_result lcr_bridge(struct ast_channel *ast1, + struct ast_channel *ast2, int flags, + struct ast_frame **fo, + struct ast_channel **rc, int timeoutms) + +{ + struct chan_call *call1, *call2; + struct ast_channel *carr[2], *who; + int to; + struct ast_frame *f; + int bridge_id; + + CDEBUG(NULL, NULL, "Received briding request from Asterisk.\n"); + + carr[0] = ast1; + carr[1] = ast2; + + /* join via dsp (if the channels are currently open) */ + ast_mutex_lock(&chan_lock); + bridge_id = new_bridge_id(); + call1 = ast1->tech_pvt; + call2 = ast2->tech_pvt; + if (call1 && call2) + { + call1->bridge_id = bridge_id; + if (call1->bchannel) + bchannel_join(call1->bchannel, bridge_id); + call1->bridge_call = call2; + } + if (call2) + { + call2->bridge_id = bridge_id; + if (call2->bchannel) + bchannel_join(call2->bchannel, bridge_id); + call2->bridge_call = call1; + } + ast_mutex_unlock(&chan_lock); + + while(1) { + to = -1; + who = ast_waitfor_n(carr, 2, &to); + + if (!who) { + CDEBUG(NULL, NULL, "Empty read on bridge, breaking out.\n"); + break; + } + f = ast_read(who); + + if (!f || f->frametype == AST_FRAME_CONTROL) { + if (!f) + CDEBUG(NULL, NULL, "Got hangup.\n"); + else + CDEBUG(NULL, NULL, "Got CONTROL.\n"); + /* got hangup .. */ + *fo=f; + *rc=who; + break; + } + + if ( f->frametype == AST_FRAME_DTMF ) { + CDEBUG(NULL, NULL, "Got DTMF.\n"); + *fo=f; + *rc=who; + break; + } + + + if (who == ast1) { + ast_write(ast2,f); + } + else { + ast_write(ast1,f); + } + + } + + CDEBUG(NULL, NULL, "Releasing bride.\n"); + + /* split channels */ + ast_mutex_lock(&chan_lock); + call1 = ast1->tech_pvt; + call2 = ast2->tech_pvt; + if (call1) + { + call1->bridge_id = 0; + if (call1->bchannel) + bchannel_join(call1->bchannel, 0); + if (call1->bridge_call) + call1->bridge_call->bridge_call = NULL; + call1->bridge_call = NULL; + } + if (call2) + { + call2->bridge_id = 0; + if (call2->bchannel) + bchannel_join(call2->bchannel, 0); + if (call2->bridge_call) + call2->bridge_call->bridge_call = NULL; + call2->bridge_call = NULL; + } + + ast_mutex_unlock(&chan_lock); + return AST_BRIDGE_COMPLETE; +} static struct ast_channel_tech lcr_tech = { - .type=lcr_type, + .type="LCR", .description="Channel driver for connecting to Linux-Call-Router", - .capabilities=AST_FORMAT_ALAW, .requester=lcr_request, - .send_digit=lcr_digit, + .send_digit_begin=lcr_digit_begin, + .send_digit_end=lcr_digit_end, .call=lcr_call, .bridge=lcr_bridge, .hangup=lcr_hangup, @@ -1290,8 +2244,8 @@ static struct ast_channel_tech lcr_tech = { .read=lcr_read, .write=lcr_write, .indicate=lcr_indicate, -// .fixup=lcr_fixup, -// .send_text=lcr_send_text, + .fixup=lcr_fixup, + .send_text=lcr_send_text, .properties=0 }; @@ -1299,32 +2253,40 @@ static struct ast_channel_tech lcr_tech = { /* * cli */ +#if 0 static int lcr_show_lcr (int fd, int argc, char *argv[]) { + return 0; } static int lcr_show_calls (int fd, int argc, char *argv[]) { + return 0; } static int lcr_reload_routing (int fd, int argc, char *argv[]) { + return 0; } static int lcr_reload_interfaces (int fd, int argc, char *argv[]) { + return 0; } static int lcr_port_block (int fd, int argc, char *argv[]) { + return 0; } static int lcr_port_unblock (int fd, int argc, char *argv[]) { + return 0; } static int lcr_port_unload (int fd, int argc, char *argv[]) { + return 0; } static struct ast_cli_entry cli_show_lcr = @@ -1375,81 +2337,108 @@ static struct ast_cli_entry cli_port_unload = "Unloads LCR port, port is closes by mISDN", "Usage: lcr port unload \"\"\n", }; +#endif + +static int lcr_config_exec(struct ast_channel *ast, void *data) +{ + struct chan_call *call; + + ast_mutex_lock(&chan_lock); + CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data); + /* find channel */ + call = call_first; + while(call) { + if (call->ast == ast) + break; + call = call->next; + } + if (call) + apply_opt(call, (char *)data); + else + CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n"); + + ast_mutex_unlock(&chan_lock); + return 0; +} + /* * module loading and destruction */ int load_module(void) { -// ast_mutex_init(&release_lock); + u_short i; -// lcr_cfg_update_ptp(); + for (i = 0; i < 256; i++) { + flip_bits[i] = (i>>7) | ((i>>5)&2) | ((i>>3)&4) | ((i>>1)&8) + | (i<<7) | ((i&2)<<5) | ((i&4)<<3) | ((i&8)<<1); + } - pthread_mutex_init(&chan_lock, NULL); - - if (!(lcr_sock = open_socket())) { - ast_log(LOG_ERROR, "Unable to connect\n"); - lcr_sock = -1; + if (read_options() == 0) { + CERROR(NULL, NULL, "%s", options_error); + return AST_MODULE_LOAD_DECLINE; + } + + ast_mutex_init(&chan_lock); + ast_mutex_init(&log_lock); + + if (open_socket() < 0) { /* continue with closed socket */ } - if (!bchannel_initialize()) { - ast_log(LOG_ERROR, "Unable to open mISDN device\n"); - close_socket(lcr_sock); - return -1; + if (bchannel_initialize()) { + CERROR(NULL, NULL, "Unable to open mISDN device\n"); + close_socket(); + return AST_MODULE_LOAD_DECLINE; } mISDN_created = 1; + lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW; if (ast_channel_register(&lcr_tech)) { - ast_log(LOG_ERROR, "Unable to register channel class\n"); + CERROR(NULL, NULL, "Unable to register channel class\n"); bchannel_deinitialize(); - close_socket(lcr_sock); - return -1; + close_socket(); + return AST_MODULE_LOAD_DECLINE; } + + ast_register_application("lcr_config", lcr_config_exec, "lcr_config", + "lcr_config(::...)\n" + "Sets LCR opts. and optargs\n" + "\n" + "The available options are:\n" + " d - Send display text on called phone, text is the optarg.\n" + " n - Don't detect dtmf tones on called channel.\n" + " h - Force data call (HDLC).\n" + " t - Disable all audio features (required for fax application).\n" + " c - Make crypted outgoing call, optarg is keyindex.\n" + " e - Perform echo cancelation on this channel.\n" + " Takes mISDN pipeline option as optarg.\n" +// " s - Send Non Inband DTMF as inband.\n" + " vr - rxgain control\n" + " vt - txgain control\n" + " Volume changes at factor 2 ^ optarg.\n" + ); + #if 0 ast_cli_register(&cli_show_lcr); ast_cli_register(&cli_show_calls); - ast_cli_register(&cli_reload_routing); ast_cli_register(&cli_reload_interfaces); ast_cli_register(&cli_port_block); ast_cli_register(&cli_port_unblock); ast_cli_register(&cli_port_unload); - - ast_register_application("misdn_set_opt", misdn_set_opt_exec, "misdn_set_opt", - "misdn_set_opt(::..):\n" - "Sets mISDN opts. and optargs\n" - "\n" - "The available options are:\n" - " d - Send display text on called phone, text is the optparam\n" - " n - don't detect dtmf tones on called channel\n" - " h - make digital outgoing call\n" - " c - make crypted outgoing call, param is keyindex\n" - " e - perform echo cancelation on this channel,\n" - " takes taps as arguments (32,64,128,256)\n" - " s - send Non Inband DTMF as inband\n" - " vr - rxgain control\n" - " vt - txgain control\n" - ); - - - lcr_cfg_get( 0, LCR_GEN_TRACEFILE, global_tracefile, BUFFERSIZE); - - chan_lcr_log(0, 0, "-- mISDN Channel Driver Registred -- (BE AWARE THIS DRIVER IS EXPERIMENTAL!)\n"); -======= - //lcr_cfg_get( 0, LCR_GEN_TRACEFILE, global_tracefile, BUFFERSIZE); #endif - quit = 1; - if ((pthread_create(&chan_tid, NULL, chan_thread, arg)<0)) + quit = 0; + if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) { - failed to create thread + /* failed to create thread */ bchannel_deinitialize(); - close_socket(lcr_sock); + close_socket(); ast_channel_unregister(&lcr_tech); - return -1; + return AST_MODULE_LOAD_DECLINE; } return 0; } @@ -1457,13 +2446,16 @@ int load_module(void) int unload_module(void) { /* First, take us out of the channel loop */ - ast_log(LOG_VERBOSE, "-- Unregistering mISDN Channel Driver --\n"); + CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n"); quit = 1; pthread_join(chan_tid, NULL); ast_channel_unregister(&lcr_tech); + ast_unregister_application("lcr_config"); + + if (mISDN_created) { bchannel_deinitialize(); mISDN_created = 0; @@ -1477,44 +2469,18 @@ int unload_module(void) return 0; } -static int reload_module(void) +int reload_module(void) { // reload_config(); return 0; } -ast_mutex_t usecnt_lock; -int usecnt; - -int usecount(void) -{ - int res; - ast_mutex_lock(&usecnt_lock); - res = usecnt; - ast_mutex_unlock(&usecnt_lock); - return res; -} - - -char *desc="Channel driver for lcr"; - -char *description(void) -{ - return desc; -} - -char *key(void) -{ - return ASTERISK_GPL_KEY; -} - #define AST_MODULE "chan_lcr" -AST_MODULE_INFO(ASTERISK_GPL_KEY, - AST_MODFLAG_DEFAULT, - "Channel driver for LCR", - .load = load_module, - .unload = unload_module, - .reload = reload_module, - ); + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Channel driver for Linux-Call-Router Support (ISDN BRI/PRI)", + .load = load_module, + .unload = unload_module, + .reload = reload_module, + );