X-Git-Url: http://git.eversberg.eu/gitweb.cgi?p=lcr.git;a=blobdiff_plain;f=chan_lcr.c;h=a2951ae2c384a7e3c603be4d1bfaf4b72e074b15;hp=3e3d7ce00c21a6c9cee6d575997d4949cc01e311;hb=14da759465d6597908f27a31ec14eda3d5a47520;hpb=728df7a8a9a31fddf0c276cf3fe9914fd9b17ad6

diff --git a/chan_lcr.c b/chan_lcr.c
index 3e3d7ce..a2951ae 100644
--- a/chan_lcr.c
+++ b/chan_lcr.c
@@ -106,6 +106,10 @@ it is called from ast_channel process which has already locked ast_channel.
 */
 
 
+/* Choose if you want to have chan_lcr for Asterisk 1.4.x or CallWeaver 1.2.x */
+#define LCR_FOR_ASTERISK
+/* #define LCR_FOR_CALLWEAVER */
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -129,7 +133,9 @@ it is called from ast_channel process which has already locked ast_channel.
 #define HAVE_INET_ATON 1
 
 #include <asterisk/compiler.h>
+#ifdef LCR_FOR_ASTERISK
 #include <asterisk/buildopts.h>
+#endif
 #include <asterisk/module.h>
 #include <asterisk/channel.h>
 #include <asterisk/config.h>
@@ -144,12 +150,20 @@ it is called from ast_channel process which has already locked ast_channel.
 #include <asterisk/dsp.h>
 #include <asterisk/translate.h>
 #include <asterisk/file.h>
+#ifdef LCR_FOR_ASTERISK
 #include <asterisk/callerid.h>
+#endif
+#ifdef LCR_FOR_CALLWEAVER
+#include <asterisk/phone_no_utils.h>
+#endif
+
 #include <asterisk/indications.h>
 #include <asterisk/app.h>
 #include <asterisk/features.h>
 #include <asterisk/sched.h>
-
+#if ASTERISK_VERSION_NUM < 110000
+#include <asterisk/version.h>
+#endif
 #include "extension.h"
 #include "message.h"
 #include "callerid.h"
@@ -163,13 +177,27 @@ it is called from ast_channel process which has already locked ast_channel.
 CHAN_LCR_STATE // state description structure
 MESSAGES // message text
 
+#ifdef LCR_FOR_CALLWEAVER
+AST_MUTEX_DEFINE_STATIC(rand_lock);
+#endif
+
 unsigned char flip_bits[256];
 
+#ifdef LCR_FOR_CALLWEAVER
+static struct ast_frame nullframe = { AST_FRAME_NULL, };
+#endif
+
 int lcr_debug=1;
 int mISDN_created=1;
 
 char lcr_type[]="lcr";
 
+#ifdef LCR_FOR_CALLWEAVER
+static ast_mutex_t usecnt_lock;
+static int usecnt=0;
+static char *desc = "Channel driver for mISDN/LCR Support (Bri/Pri)";
+#endif
+
 pthread_t chan_tid;
 ast_mutex_t chan_lock; /* global lock */
 ast_mutex_t log_lock; /* logging log */
@@ -182,8 +210,6 @@ int wake_global = 0;
 int wake_pipe[2];
 struct lcr_fd wake_fd;
 
-int quit;
-
 int glob_channel = 0;
 
 int lcr_sock = -1;
@@ -217,11 +243,15 @@ void chan_lcr_log(int type, const char *file, int line, const char *function, st
 	if (call)
 		sprintf(call_text, "%d", call->ref);
 	if (ast)
+#if ASTERISK_VERSION_NUM < 110000
 		strncpy(ast_text, ast->name, sizeof(ast_text)-1);
+#else
+		strncpy(ast_text, ast_channel_name(ast), sizeof(ast_text)-1);
+#endif
 	ast_text[sizeof(ast_text)-1] = '\0';
 
 //	ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
-	printf("[call=%s ast=%s] %s", call_text, ast_text, buffer);
+	printf("[call=%s ast=%s line=%d] %s", call_text, ast_text, line, buffer);
 
 	ast_mutex_unlock(&log_lock);
 }
@@ -336,7 +366,7 @@ int send_message(int message_type, unsigned int ref, union parameter *param)
 		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]);
+	CDEBUG(NULL, NULL, "Sending %s to socket. (ref=%d)\n", messages_txt[message_type], ref);
 
 	adminp = &admin_first;
 	while(*adminp)
@@ -498,13 +528,33 @@ void apply_opt(struct chan_call *call, char *data)
 			if (!call->dsp)
 				call->dsp=ast_dsp_new();
 			if (call->dsp) {
+				#ifdef LCR_FOR_CALLWEAVER
+				ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_CNG_DETECT);
+				#endif
+				#ifdef LCR_FOR_ASTERISK
 				#ifdef DSP_FEATURE_DTMF_DETECT
 				ast_dsp_set_features(call->dsp, DSP_FEATURE_DTMF_DETECT| DSP_FEATURE_FAX_DETECT);
 				#else
 				ast_dsp_set_features(call->dsp, DSP_FEATURE_DIGIT_DETECT| DSP_FEATURE_FAX_DETECT);
 				#endif
-				if (!call->trans)
+
+				#endif
+				if (!call->trans) {
+					#ifdef LCR_FOR_CALLWEAVER
+					call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, 8000, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW, 8000);
+					#endif
+					#ifdef LCR_FOR_ASTERISK
+					#if ASTERISK_VERSION_NUM < 100000
 					call->trans=ast_translator_build_path(AST_FORMAT_SLINEAR, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
+					#else
+					struct ast_format src;
+					struct ast_format dst;
+					ast_format_set(&dst, AST_FORMAT_SLINEAR, 0);
+					ast_format_set(&dst,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
+					call->trans=ast_translator_build_path(&dst, &src);
+					#endif
+					#endif
+				}
 			}
 			CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
 			break;
@@ -576,42 +626,47 @@ static void send_setup_to_lcr(struct chan_call *call)
 {
 	union parameter newparam;
 	struct ast_channel *ast = call->ast;
+//	const char *tmp;
 
 	if (!call->ast || !call->ref)
 		return;
 
-	CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, ast->exten, ast->caller.id.number.str);
+#ifdef AST_1_8_OR_HIGHER
+	CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->callerinfo.id);
+#else
+	CDEBUG(call, call->ast, "Sending setup to LCR. (interface=%s dialstring=%s, cid=%s)\n", call->interface, call->dialstring, call->cid_num);
+#endif
 
 	/* 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;
+	newparam.setup.dialinginfo.itype = INFO_ITYPE_ISDN;
+	newparam.setup.dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
 	if (call->keypad)
 		strncpy(newparam.setup.dialinginfo.keypad, call->dialstring, sizeof(newparam.setup.dialinginfo.keypad)-1);
 	else
 		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);
+	if (!!strcmp(call->interface, "pbx"))
+		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;
 	strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
 	call->display[0] = '\0';
-	newparam.setup.callerinfo.id[0] = '\0';
-	if (ast->caller.id.number.valid)
-	  if (ast->caller.id.number.str)
-	    if (ast->caller.id.number.str[0])
-		strncpy(newparam.setup.callerinfo.id, ast->caller.id.number.str, sizeof(newparam.setup.callerinfo.id)-1);
-	if (ast->caller.id.name.valid)
-	  if (ast->caller.id.name.str)
-	    if (ast->caller.id.name.str[0])
-		strncpy(newparam.setup.callerinfo.name, ast->caller.id.name.str, sizeof(newparam.setup.callerinfo.name)-1);
-	if (ast->redirecting.from.number.valid)
-	  if (ast->redirecting.from.number.str)
-	    if (ast->redirecting.from.number.str[0]) {
-		strncpy(newparam.setup.redirinfo.id, ast->redirecting.from.number.str, sizeof(newparam.setup.redirinfo.id)-1);
+
+#ifdef AST_1_8_OR_HIGHER
+	/* set stored call information */
+	memcpy(&newparam.setup.callerinfo, &call->callerinfo, sizeof(struct caller_info));
+	memcpy(&newparam.setup.redirinfo, &call->redirinfo, sizeof(struct redir_info));
+#else
+	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->cid_rdnis, sizeof(newparam.setup.redirinfo.id)-1);
 		newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
 		newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;
-	    }
-	switch(ast->caller.id.number.presentation & AST_PRES_RESTRICTION) {
+	}
+	switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
 		case AST_PRES_RESTRICTED:
 		newparam.setup.callerinfo.present = INFO_PRESENT_RESTRICTED;
 		break;
@@ -622,7 +677,7 @@ static void send_setup_to_lcr(struct chan_call *call)
 		default:
 		newparam.setup.callerinfo.present = INFO_PRESENT_ALLOWED;
 	}
-	switch(ast->caller.id.number.plan) {
+	switch(ast->cid.cid_ton) {
 		case 4:
 		newparam.setup.callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
 		break;
@@ -635,11 +690,17 @@ static void send_setup_to_lcr(struct chan_call *call)
 		default:
 		newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
 	}
+#endif
 #warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
 //	tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
 //	if (tmp && *tmp)
+#if ASTERISK_VERSION_NUM < 110000
 //		ast->transfercapability = atoi(tmp);
 	newparam.setup.capainfo.bearer_capa = ast->transfercapability;
+#else
+//		ast_channel_transfercapability_set(ast, atoi(tmp));
+	newparam.setup.capainfo.bearer_capa = ast_channel_transfercapability(ast);
+#endif
 	newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
 	if (call->hdlc)
 		newparam.setup.capainfo.source_mode = B_MODE_HDLC;
@@ -722,21 +783,43 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 {
 	int cause, ret;
 	union parameter newparam;
+#if ASTERISK_VERSION_NUM < 110000
 	char *exten = ast->exten;
-	if (!*exten)
+#else
+	char s_exten[AST_MAX_EXTENSION];
+	char *exten=s_exten;
+
+	strncpy(exten, ast_channel_exten(ast), AST_MAX_EXTENSION-1);
+#endif
+
+if (!*exten)
 		exten = "s";
 
+#if ASTERISK_VERSION_NUM < 110000
 	CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast->context, complete?"yes":"no");
+#else
+	CDEBUG(call, ast, "Try to start pbx. (exten=%s context=%s complete=%s)\n", exten, ast_channel_context(ast), complete?"yes":"no");
+#endif
 
 	if (complete) {
 		/* if not match */
+#if ASTERISK_VERSION_NUM < 110000
 		if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
-			CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
+CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast->context);
+#else
+		if (!ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
+CDEBUG(call, ast, "Got 'sending complete', but extension '%s' will not match at context '%s' - releasing.\n", exten, ast_channel_context(ast));
+#endif
 			cause = 1;
 			goto release;
 		}
+#if ASTERISK_VERSION_NUM < 110000
 		if (!ast_exists_extension(ast, ast->context, 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", exten, ast->context);
+#else
+		if (!ast_exists_extension(ast, ast_channel_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", exten, ast_channel_context(ast));
+#endif
 			cause = 28;
 			goto release;
 		}
@@ -751,7 +834,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 		goto start;
 	}
 
+#if ASTERISK_VERSION_NUM < 110000
 	if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
+#else
+	if (ast_canmatch_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
+#endif
 		/* send setup acknowledge to lcr */
 		if (call->state != CHAN_LCR_STATE_IN_DIALING) {
 			memset(&newparam, 0, sizeof(union parameter));
@@ -762,7 +849,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 		call->state = CHAN_LCR_STATE_IN_DIALING;
 
 		/* if match, start pbx */
-		if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
+#if ASTERISK_VERSION_NUM < 110000
+	if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
+#else
+	if (ast_exists_extension(ast, ast_channel_context(ast), exten, 1, call->oad)) {
+#endif
 			CDEBUG(call, ast, "Extensions matches.\n");
 			goto start;
 		}
@@ -772,7 +863,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 		return;
 	}
 
+#if ASTERISK_VERSION_NUM < 110000
 	if (!*ast->exten) {
+#else
+	if (!*ast_channel_exten(ast)) {
+#endif
 		/* if can match */
 		CDEBUG(call, ast, "There is no 's' extension (and we tried to match it implicitly). Extensions may match, if more digits are dialed.\n");
 		return;
@@ -786,7 +881,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 	send_release_and_import(call, cause, LOCATION_PRIVATE_LOCAL);
 	call->ref = 0;
 	/* release asterisk */
+#if ASTERISK_VERSION_NUM < 110000
 	ast->hangupcause = call->cause;
+#else
+	ast_channel_hangupcause_set(ast, call->cause);
+#endif
 	/* change to release state */
 	call->state = CHAN_LCR_STATE_RELEASE;
 	ast_hangup(ast); // call will be destroyed here
@@ -796,6 +895,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 	/* send setup to asterisk */
 	CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
 
+	#ifdef LCR_FOR_CALLWEAVER
+	ast->type = "LCR";
+	snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);
+	#endif
+
 	ret = ast_pbx_start(ast);
 	if (ret < 0) {
 		cause = (ret==-2)?34:27;
@@ -811,12 +915,37 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 static void lcr_in_setup(struct chan_call *call, int message_type, union parameter *param)
 {
 	struct ast_channel *ast;
-
+	struct ast_party_redirecting *ast_redir;
+	struct ast_party_caller *ast_caller;
+#if ASTERISK_VERSION_NUM >= 110000
+	struct ast_party_redirecting s_ast_redir;
+	struct ast_party_caller s_ast_caller;
+	ast_party_redirecting_init(&s_ast_redir);
+	ast_party_caller_init(&s_ast_caller);
+#endif
 	CDEBUG(call, NULL, "Incomming setup from LCR. (callerid %s, dialing %s)\n", param->setup.callerinfo.id, param->setup.dialinginfo.id);
 
 	/* create asterisk channel instrance */
 
+	#ifdef LCR_FOR_CALLWEAVER
+	ast = ast_channel_alloc(1);
+	#endif
+
+	#ifdef LCR_FOR_ASTERISK
+#ifdef AST_1_8_OR_HIGHER
 	ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", "", 0, "%s/%d", lcr_type, ++glob_channel);
+#else
+	ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
+#endif
+	#endif
+
+#if ASTERISK_VERSION_NUM < 110000
+	ast_redir = &ast->redirecting;
+	ast_caller = &ast->caller;
+#else
+	ast_redir = &s_ast_redir;
+	ast_caller = &s_ast_caller;
+#endif
 
 	if (!ast) {
 		/* release */
@@ -828,70 +957,240 @@ static void lcr_in_setup(struct chan_call *call, int message_type, union paramet
 	}
 	/* link together */
 	call->ast = ast;
+#if ASTERISK_VERSION_NUM < 110000
 	ast->tech_pvt = call;
 	ast->tech = &lcr_tech;
 	ast->fds[0] = call->pipe[0];
+#else
+	ast_channel_tech_pvt_set(ast, call);
+	ast_channel_tech_set(ast, &lcr_tech);
+	ast_channel_set_fd(ast, 0, call->pipe[0]);
+#endif
 
 	/* fill setup information */
 	if (param->setup.dialinginfo.id)
+#if ASTERISK_VERSION_NUM < 110000
 		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);
+#else
+		ast_channel_exten_set(ast, param->setup.dialinginfo.id);
+	if (param->setup.context[0])
+		ast_channel_context_set(ast, param->setup.context);
+	else
+		ast_channel_context_set(ast, param->setup.callerinfo.interface);
+#endif
+
+
+#ifdef AST_1_8_OR_HIGHER
 	if (param->setup.callerinfo.id[0]) {
-		ast->caller.id.number.str = strdup(param->setup.callerinfo.id);
-	} else {
-		ast->caller.id.number.str = strdup("");
-		ast->caller.id.number.presentation = AST_PRES_RESTRICTED;
-		ast->caller.id.number.plan = 0;
+		ast_caller->id.number.valid = 1;
+		ast_caller->id.number.str = strdup(param->setup.callerinfo.id);
+		if (!param->setup.callerinfo.id[0]) {
+			ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
+			ast_caller->id.number.plan = (0 << 4) | 1;
+		}
+		switch (param->setup.callerinfo.present) {
+			case INFO_PRESENT_ALLOWED:
+				ast_caller->id.number.presentation = AST_PRES_ALLOWED;
+			break;
+			case INFO_PRESENT_RESTRICTED:
+				ast_caller->id.number.presentation = AST_PRES_RESTRICTED;
+			break;
+			default:
+				ast_caller->id.number.presentation = AST_PRES_UNAVAILABLE;
+		}
+		switch (param->setup.callerinfo.screen) {
+			case INFO_SCREEN_USER:
+				ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
+			break;
+			case INFO_SCREEN_USER_VERIFIED_PASSED:
+				ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
+			break;
+			case INFO_SCREEN_USER_VERIFIED_FAILED:
+				ast_caller->id.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
+			break;
+			default:
+				ast_caller->id.number.presentation |= AST_PRES_NETWORK_NUMBER;
+		}
+		switch (param->setup.callerinfo.ntype) {
+			case INFO_NTYPE_SUBSCRIBER:
+				ast_caller->id.number.plan = (4 << 4) | 1;
+			break;
+			case INFO_NTYPE_NATIONAL:
+				ast_caller->id.number.plan = (2 << 4) | 1;
+			break;
+			case INFO_NTYPE_INTERNATIONAL:
+				ast_caller->id.number.plan = (1 << 4) | 1;
+			break;
+			default:
+				ast_caller->id.number.plan = (0 << 4) | 1;
+		}
 	}
-	ast->caller.id.number.valid = 1;
 	if (param->setup.callerinfo.id2[0]) {
-		ast->caller.ani.number.str = strdup(param->setup.callerinfo.id);
-		ast->caller.ani.number.valid = 1;
+		ast_caller->ani.number.valid = 1;
+		ast_caller->ani.number.str = strdup(param->setup.callerinfo.id2);
+		switch (param->setup.callerinfo.present2) {
+			case INFO_PRESENT_ALLOWED:
+				ast_caller->ani.number.presentation = AST_PRES_ALLOWED;
+			break;
+			case INFO_PRESENT_RESTRICTED:
+				ast_caller->ani.number.presentation = AST_PRES_RESTRICTED;
+			break;
+			default:
+				ast_caller->ani.number.presentation = AST_PRES_UNAVAILABLE;
+		}
+		switch (param->setup.callerinfo.screen2) {
+			case INFO_SCREEN_USER:
+				ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
+			break;
+			case INFO_SCREEN_USER_VERIFIED_PASSED:
+				ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
+			break;
+			case INFO_SCREEN_USER_VERIFIED_FAILED:
+				ast_caller->ani.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
+			break;
+			default:
+				ast_caller->ani.number.presentation |= AST_PRES_NETWORK_NUMBER;
+		}
+		switch (param->setup.callerinfo.ntype2) {
+			case INFO_NTYPE_SUBSCRIBER:
+				ast_caller->ani.number.plan = (4 << 4) | 1;
+			break;
+			case INFO_NTYPE_NATIONAL:
+				ast_caller->ani.number.plan = (2 << 4) | 1;
+			break;
+			case INFO_NTYPE_INTERNATIONAL:
+				ast_caller->ani.number.plan = (1 << 4) | 1;
+			break;
+			default:
+				ast_caller->ani.number.plan = (0 << 4) | 1;
+		}
 	}
 	if (param->setup.callerinfo.name[0]) {
-		ast->caller.id.name.str = strdup(param->setup.callerinfo.name);
-		ast->caller.id.name.valid = 1;
+		ast_caller->id.name.valid = 1;
+		ast_caller->id.name.str = strdup(param->setup.callerinfo.name);
 	}
+#if ASTERISK_VERSION_NUM >= 110000
+	ast_channel_caller_set(ast, ast_caller);
+#endif
+	if (param->setup.redirinfo.id[0]) {
+		ast_redir->from.number.valid = 1;
+		ast_redir->from.number.str = strdup(param->setup.redirinfo.id);
+		switch (param->setup.redirinfo.present) {
+			case INFO_PRESENT_ALLOWED:
+				ast_redir->from.number.presentation = AST_PRES_ALLOWED;
+			break;
+			case INFO_PRESENT_RESTRICTED:
+				ast_redir->from.number.presentation = AST_PRES_RESTRICTED;
+			break;
+			default:
+				ast_redir->from.number.presentation = AST_PRES_UNAVAILABLE;
+		}
+		switch (param->setup.redirinfo.screen) {
+			case INFO_SCREEN_USER:
+				ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
+			break;
+			case INFO_SCREEN_USER_VERIFIED_PASSED:
+				ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
+			break;
+			case INFO_SCREEN_USER_VERIFIED_FAILED:
+				ast_redir->from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
+			break;
+			default:
+				ast_redir->from.number.presentation |= AST_PRES_NETWORK_NUMBER;
+		}
+		switch (param->setup.redirinfo.ntype) {
+			case INFO_NTYPE_SUBSCRIBER:
+				ast_redir->from.number.plan = (4 << 4) | 1;
+			break;
+			case INFO_NTYPE_NATIONAL:
+				ast_redir->from.number.plan = (2 << 4) | 1;
+			break;
+			case INFO_NTYPE_INTERNATIONAL:
+				ast_redir->from.number.plan = (1 << 4) | 1;
+			break;
+			default:
+				ast_redir->from.number.plan = (0 << 4) | 1;
+		}
+#if ASTERISK_VERSION_NUM >= 110000
+		ast_channel_redirecting_set(ast, ast_redir);
+#endif
+	}
+#else
+	memset(&ast->cid, 0, sizeof(ast->cid));
+	if (param->setup.callerinfo.id[0])
+		ast->cid.cid_num = strdup(param->setup.callerinfo.id);
+	if (param->setup.callerinfo.id2[0])
+		ast->cid.cid_ani = strdup(param->setup.callerinfo.id2);
+	if (param->setup.callerinfo.name[0])
+		ast->cid.cid_name = strdup(param->setup.callerinfo.name);
 	if (param->setup.redirinfo.id[0])
-		ast->redirecting.from.number.str = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
+		ast->cid.cid_rdnis = strdup(numberrize_callerinfo(param->setup.redirinfo.id, param->setup.redirinfo.ntype, options.national, options.international));
 	switch (param->setup.callerinfo.present) {
 		case INFO_PRESENT_ALLOWED:
-			ast->caller.id.number.presentation = AST_PRES_ALLOWED;
+			ast->cid.cid_pres = AST_PRES_ALLOWED;
 		break;
 		case INFO_PRESENT_RESTRICTED:
-			ast->caller.id.number.presentation = AST_PRES_RESTRICTED;
+			ast->cid.cid_pres = AST_PRES_RESTRICTED;
 		break;
 		default:
-			ast->caller.id.number.presentation = AST_PRES_UNAVAILABLE;
+			ast->cid.cid_pres = AST_PRES_UNAVAILABLE;
 	}
 	switch (param->setup.callerinfo.ntype) {
 		case INFO_NTYPE_SUBSCRIBER:
-			ast->caller.id.number.plan = 4;
+			ast->cid.cid_ton = 4;
 		break;
 		case INFO_NTYPE_NATIONAL:
-			ast->caller.id.number.plan = 2;
+			ast->cid.cid_ton = 2;
 		break;
 		case INFO_NTYPE_INTERNATIONAL:
-			ast->caller.id.number.plan = 1;
+			ast->cid.cid_ton = 1;
 		break;
 		default:
-			ast->caller.id.number.plan = 0;
+			ast->cid.cid_ton = 0;
 	}
+#endif
+
+#if ASTERISK_VERSION_NUM < 110000
 	ast->transfercapability = param->setup.capainfo.bearer_capa;
+#else
+	ast_channel_transfercapability_set(ast, param->setup.capainfo.bearer_capa);
+#endif
 	/* enable hdlc if transcap is data */
 	if (param->setup.capainfo.source_mode == B_MODE_HDLC)
 		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 */
+#if ASTERISK_VERSION_NUM < 100000
 	ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
 	ast->readformat = ast->rawreadformat = ast->nativeformats;
 	ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
+#else
+#if ASTERISK_VERSION_NUM < 110000
+	ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
+	ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
+	ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
+	ast_set_write_format(ast, &ast->rawwriteformat);
+	ast_set_read_format(ast, &ast->rawreadformat);
+#else
+	ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
+	ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
+	ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
+	ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
+	ast_set_read_format(ast, ast_channel_rawreadformat(ast));
+#endif
+#endif
+#if ASTERISK_VERSION_NUM < 110000
 	ast->priority = 1;
 	ast->hangupcause = 0;
+#else
+	ast_channel_priority_set(ast, 1);
+	ast_channel_hangupcause_set(ast, 0);
+#endif
 
 	/* change state */
 	call->state = CHAN_LCR_STATE_IN_SETUP;
@@ -970,7 +1269,7 @@ static void lcr_in_connect(struct chan_call *call, int message_type, union param
 	call->state = CHAN_LCR_STATE_CONNECT;
 	/* request bchannel */
 	if (!call->bchannel) {
-		CDEBUG(call, call->ast, "Requesting B-channel.\n");
+		CDEBUG(call, call->ast, "Requesting B-channel. (ref=%d)\n", call->ref);
 		memset(&newparam, 0, sizeof(union parameter));
 		newparam.bchannel.type = BCHANNEL_REQUEST;
 		send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
@@ -1018,7 +1317,11 @@ static void lcr_in_disconnect(struct chan_call *call, int message_type, union pa
 	call->state = CHAN_LCR_STATE_RELEASE;
 	/* queue release asterisk */
 	if (ast) {
+#if ASTERISK_VERSION_NUM < 110000
 		ast->hangupcause = call->cause;
+#else
+		ast_channel_hangupcause_set(ast, call->cause);
+#endif
 		if (call->pbx_started) {
 			if (!wake_global) {
 				wake_global = 1;
@@ -1047,12 +1350,16 @@ static void lcr_in_release(struct chan_call *call, int message_type, union param
 	call->state = CHAN_LCR_STATE_RELEASE;
 	/* copy release info */
 	if (!call->cause) {
-	       call->cause = param->disconnectinfo.cause;
-	       call->location = param->disconnectinfo.location;
+		call->cause = param->disconnectinfo.cause;
+		call->location = param->disconnectinfo.location;
 	}
 	/* if we have an asterisk instance, queue hangup, else we are done */
 	if (ast) {
+#if ASTERISK_VERSION_NUM < 110000
 		ast->hangupcause = call->cause;
+#else
+		ast_channel_hangupcause_set(ast, call->cause);
+#endif
 		if (call->pbx_started) {
 			if (!wake_global) {
 				wake_global = 1;
@@ -1083,7 +1390,11 @@ static void lcr_in_information(struct chan_call *call, int message_type, union p
 	/* pbx not started */
 	if (!call->pbx_started) {
 		CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
+#if ASTERISK_VERSION_NUM < 110000
 		strncat(ast->exten, param->information.id, AST_MAX_EXTENSION-1);
+#else
+		ast_channel_exten_set(ast, param->information.id);
+#endif
 		lcr_start_pbx(call, ast, param->information.sending_complete);
 		return;
 	}
@@ -1123,7 +1434,7 @@ static void lcr_in_notify(struct chan_call *call, int message_type, union parame
 
 	/* 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");
+		CDEBUG(call, call->ast, "Reqesting bchannel at resume. (ref=%d)\n", call->ref);
 		memset(&newparam, 0, sizeof(union parameter));
 		newparam.bchannel.type = BCHANNEL_REQUEST;
 		send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
@@ -1166,7 +1477,7 @@ static void lcr_in_pattern(struct chan_call *call, int message_type, union param
 
 	/* request bchannel */
 	if (!call->bchannel) {
-		CDEBUG(call, call->ast, "Requesting B-channel.\n");
+		CDEBUG(call, call->ast, "Requesting B-channel. (ref=%d)\n", call->ref);
 		memset(&newparam, 0, sizeof(union parameter));
 		newparam.bchannel.type = BCHANNEL_REQUEST;
 		send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
@@ -1270,6 +1581,10 @@ int receive_message(int message_type, unsigned int ref, union parameter *param)
 					CDEBUG(call, call->ast, "Join bchannel, because call is already bridged.\n");
 					bchannel_join(bchannel, call->bridge_id);
 				}
+				/* ignore all dsp features, if it is a loopback interface */
+				if (param->bchannel.isloopback)
+					call->nodsp = 1;
+
 				/* create only, if call exists, othewhise it bchannel is freed below... */
 				if (bchannel_create(bchannel, ((call->nodsp || call->faxdetect > 0)?1:0) + ((call->hdlc)?2:0), call->nodsp_queue))
 					bchannel_activate(bchannel, 1);
@@ -1311,7 +1626,7 @@ int receive_message(int message_type, unsigned int ref, union parameter *param)
 
 	/* handle new ref */
 	if (message_type == MESSAGE_NEWREF) {
-		if (param->direction) {
+		if (param->newref.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)) {
@@ -1334,8 +1649,7 @@ int receive_message(int message_type, unsigned int ref, union parameter *param)
 			call = find_call_ref(0);
 			if (!call) {
 				/* send release, if ref does not exist */
-				CDEBUG(NULL, NULL, "No call found, that requests a ref.\n");
-				send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
+				CERROR(NULL, NULL, "No call found, that requests a ref.\n");
 				return 0;
 			}
 			/* store new ref */
@@ -1494,7 +1808,7 @@ static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, i
 		/* read from socket */
 		len = read(lcr_sock, &msg, sizeof(msg));
 		if (len == 0) {
-			CERROR(NULL, NULL, "Socket closed.\n");
+			CERROR(NULL, NULL, "Socket closed.(read)\n");
 			error:
 			CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
 			close_socket();
@@ -1527,7 +1841,7 @@ static int handle_socket(struct lcr_fd *fd, unsigned int what, void *instance, i
 		admin = admin_first;
 		len = write(lcr_sock, &admin->msg, sizeof(msg));
 		if (len == 0) {
-			CERROR(NULL, NULL, "Socket closed.\n");
+			CERROR(NULL, NULL, "Socket closed.(write)\n");
 			goto error;
 		}
 		if (len > 0) {
@@ -1593,6 +1907,10 @@ void close_socket(void)
 {
 	struct admin_list *admin, *temp;
 
+	/* socket not created */
+	if (lcr_sock < 0)
+		return;
+
 	unregister_fd(&socket_fd);
 
 	/* flush pending messages */
@@ -1605,8 +1923,7 @@ void close_socket(void)
 	admin_first = NULL;
 
 	/* close socket */
-	if (lcr_sock >= 0)
-		close(lcr_sock);
+	close(lcr_sock);
 	lcr_sock = -1;
 	global_change = 1;
 }
@@ -1673,12 +1990,28 @@ again:
 					CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
 					/* send digit to asterisk */
 					memset(&fr, 0, sizeof(fr));
+
+					#ifdef LCR_FOR_ASTERISK
 					fr.frametype = AST_FRAME_DTMF_BEGIN;
+					#endif
+
+					#ifdef LCR_FOR_CALLWEAVER
+					fr.frametype = AST_FRAME_DTMF;
+					#endif
+
+#ifdef AST_1_8_OR_HIGHER
 					fr.subclass.integer = *p;
+#else
+					fr.subclass = *p;
+#endif
 					fr.delivery = ast_tv(0, 0);
 					ast_queue_frame(ast, &fr);
+
+					#ifdef LCR_FOR_ASTERISK
 					fr.frametype = AST_FRAME_DTMF_END;
 					ast_queue_frame(ast, &fr);
+					#endif
+
 					break;
 				default:
 					CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);
@@ -1732,23 +2065,11 @@ static void *chan_thread(void *arg)
 
 	ast_mutex_lock(&chan_lock);
 
-	while(!quit) {
+	while(1) {
 		handle_queue();
 		select_main(0, &global_change, lock_chan, unlock_chan);
 	}
 
-	close_socket();
-
-	del_timer(&socket_retry);
-
-	unregister_fd(&wake_fd);
-	close(wake_pipe[0]);
-	close(wake_pipe[1]);
-
-	CERROR(NULL, NULL, "Thread exit.\n");
-
-	ast_mutex_unlock(&chan_lock);
-
 	return NULL;
 }
 
@@ -1756,11 +2077,21 @@ static void *chan_thread(void *arg)
  * new asterisk instance
  */
 static
+#ifdef AST_1_8_OR_HIGHER
+#if ASTERISK_VERSION_NUM < 100000
 struct ast_channel *lcr_request(const char *type, format_t format, const struct ast_channel *requestor, void *data, int *cause)
+#else
+struct ast_channel *lcr_request(const char *type, struct ast_format_cap *format, struct ast_channel *requestor, void *data, int *cause)
+#endif
+#else
+struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
+#endif
 {
 	char exten[256], *dial, *interface, *opt;
 	struct ast_channel *ast;
 	struct chan_call *call;
+	struct ast_party_redirecting *req_redir;
+	struct ast_party_caller *req_caller;
 
 	ast_mutex_lock(&chan_lock);
 	CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
@@ -1781,7 +2112,18 @@ struct ast_channel *lcr_request(const char *type, format_t format, const struct
 	}
 
 	/* create asterisk channel instrance */
-	ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL,   NULL,    NULL, NULL, NULL,   NULL,    0,   "%s/%d", lcr_type, ++glob_channel);
+
+	#ifdef LCR_FOR_ASTERISK
+#ifdef AST_1_8_OR_HIGHER
+	ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, NULL, NULL, NULL, NULL, 0, "%s/%d", lcr_type, ++glob_channel);
+#else
+	ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);
+#endif
+	#endif
+
+	#ifdef LCR_FOR_CALLWEAVER
+	ast = ast_channel_alloc(1);
+	#endif
 
 	if (!ast) {
 		CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
@@ -1790,20 +2132,60 @@ struct ast_channel *lcr_request(const char *type, format_t format, const struct
 		ast_mutex_unlock(&chan_lock);
 		return NULL;
 	}
-
+#if ASTERISK_VERSION_NUM < 110000
 	ast->tech = &lcr_tech;
 	ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
+	req_redir = &requestor->redirecting;
+	req_caller = &requestor->caller;
+#else
+	ast_channel_tech_set(ast, &lcr_tech);
+	ast_channel_tech_pvt_set(ast, (void *)1L); // set pointer or asterisk will not call
+	req_redir = ast_channel_redirecting(requestor);
+	req_caller = ast_channel_caller(requestor);
+#endif
 	/* configure channel */
+#if ASTERISK_VERSION_NUM < 100000
+#if ASTERISK_VERSION_NUM < 110000
 	ast->nativeformats = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
 	ast->readformat = ast->rawreadformat = ast->nativeformats;
 	ast->writeformat = ast->rawwriteformat =  ast->nativeformats;
+#else
+	ast_channel_nativeformats_set(ast, (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW);
+	ast->readformat = ast->rawreadformat = ast_channel_nativeformats(ast);
+	ast->writeformat = ast->rawwriteformat =  ast_channel_nativeformats(ast);
+#endif
+#else
+#if ASTERISK_VERSION_NUM < 110000
+	ast_format_set(&ast->rawwriteformat ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
+	ast_format_copy(&ast->rawreadformat, &ast->rawwriteformat);
+	ast_format_cap_set(ast->nativeformats, &ast->rawwriteformat);
+	ast_set_write_format(ast, &ast->rawwriteformat);
+	ast_set_read_format(ast, &ast->rawreadformat);
+#else
+	ast_format_set(ast_channel_rawwriteformat(ast) ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
+	ast_format_copy(ast_channel_rawreadformat(ast), ast_channel_rawwriteformat(ast));
+	ast_format_cap_set(ast_channel_nativeformats(ast), ast_channel_rawwriteformat(ast));
+	ast_set_write_format(ast, ast_channel_rawwriteformat(ast));
+	ast_set_read_format(ast, ast_channel_rawreadformat(ast));
+#endif
+#endif
+#if ASTERISK_VERSION_NUM < 110000
 	ast->priority = 1;
 	ast->hangupcause = 0;
+#else
+	ast_channel_priority_set(ast, 1);
+	ast_channel_hangupcause_set(ast, 0);
+#endif
 
 	/* link together */
 	call->ast = ast;
+#if ASTERISK_VERSION_NUM < 110000
 	ast->tech_pvt = call;
 	ast->fds[0] = call->pipe[0];
+#else
+	ast_channel_tech_pvt_set(ast, call);
+	ast_channel_set_fd(ast, 0, call->pipe[0]);
+#endif
 	call->pbx_started = 0;
 	/* set state */
 	call->state = CHAN_LCR_STATE_OUT_PREPARE;
@@ -1833,51 +2215,53 @@ struct ast_channel *lcr_request(const char *type, format_t format, const struct
 	strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
 	apply_opt(call, (char *)opt);
 
+#ifdef AST_1_8_OR_HIGHER
 //	clone_variables(requestor, ast);
 
-	ast->caller.ani.number.valid=			requestor->caller.ani.number.valid;
-	if (requestor->caller.ani.number.valid)
-	  if (requestor->caller.ani.number.str)
-	    if (requestor->caller.ani.number.str[0])
-		ast->caller.ani.number.str=		strdup(requestor->caller.ani.number.str);
-	ast->caller.ani.number.plan=			requestor->caller.ani.number.plan;
-	ast->caller.ani.number.presentation=		requestor->caller.ani.number.presentation;
-
-	ast->caller.ani.name.valid=			requestor->caller.ani.name.valid;
-	if (requestor->caller.ani.name.valid)
-	  if (requestor->caller.ani.name.str)
-	    if (requestor->caller.ani.name.str[0])
-		ast->caller.ani.name.str=		strdup(requestor->caller.ani.name.str);
-	ast->caller.ani.name.presentation=		requestor->caller.ani.name.presentation;
-
-	ast->caller.ani.subaddress.valid=		requestor->caller.ani.subaddress.valid;
-	if (requestor->caller.ani.subaddress.valid)
-	  if (requestor->caller.ani.subaddress.str)
-	    if (requestor->caller.ani.subaddress.str[0])
-		ast->caller.ani.subaddress.str=		strdup(requestor->caller.ani.subaddress.str);
-	ast->caller.ani.subaddress.type=		requestor->caller.ani.subaddress.type;
-
-	ast->caller.id.number.valid=			requestor->caller.id.number.valid;
-	if (requestor->caller.id.number.valid)
-	  if (requestor->caller.id.number.str)
-	    if (requestor->caller.id.number.str[0])
-		ast->caller.id.number.str=		strdup(requestor->caller.id.number.str);
-	ast->caller.id.number.plan=			requestor->caller.id.number.plan;
-	ast->caller.id.number.presentation=		requestor->caller.id.number.presentation;
-
-	ast->caller.id.name.valid=			requestor->caller.id.name.valid;
-	if (requestor->caller.id.name.valid)
-	  if (requestor->caller.id.name.str)
-	    if (requestor->caller.id.name.str[0])
-		ast->caller.id.name.str=		strdup(requestor->caller.id.name.str);
-	ast->caller.id.name.presentation=		requestor->caller.id.name.presentation;
-
-	ast->caller.id.subaddress.valid=		requestor->caller.id.subaddress.valid;
-	if (requestor->caller.id.subaddress.valid)
-	  if (requestor->caller.id.subaddress.str)
-	    if (requestor->caller.id.subaddress.str[0])
-		ast->caller.id.subaddress.str=		strdup(requestor->caller.id.subaddress.str);
-	ast->caller.id.subaddress.type=			requestor->caller.id.subaddress.type;
+#if 0
+	ast->caller.ani.number.valid=			req_caller->ani.number.valid;
+	if (req_caller->ani.number.valid)
+	  if (req_caller->ani.number.str)
+	    if (req_caller->ani.number.str[0])
+		ast->caller.ani.number.str=		strdup(req_caller->ani.number.str);
+	ast->caller.ani.number.plan=			req_caller->ani.number.plan;
+	ast->caller.ani.number.presentation=		req_caller->ani.number.presentation;
+
+	ast->caller.ani.name.valid=			req_caller->ani.name.valid;
+	if (req_caller->ani.name.valid)
+	  if (req_caller->ani.name.str)
+	    if (req_caller->ani.name.str[0])
+		ast->caller.ani.name.str=		strdup(req_caller->ani.name.str);
+	ast->caller.ani.name.presentation=		req_caller->ani.name.presentation;
+
+	ast->caller.ani.subaddress.valid=		req_caller->ani.subaddress.valid;
+	if (req_caller->ani.subaddress.valid)
+	  if (req_caller->ani.subaddress.str)
+	    if (req_caller->ani.subaddress.str[0])
+		ast->caller.ani.subaddress.str=		strdup(req_caller->ani.subaddress.str);
+	ast->caller.ani.subaddress.type=		req_caller->ani.subaddress.type;
+
+	ast->caller.id.number.valid=			req_caller->id.number.valid;
+	if (req_caller->id.number.valid)
+	  if (req_caller->id.number.str)
+	    if (req_caller->id.number.str[0])
+		ast->caller.id.number.str=		strdup(req_caller->id.number.str);
+	ast->caller.id.number.plan=			req_caller->id.number.plan;
+	ast->caller.id.number.presentation=		req_caller->id.number.presentation;
+
+	ast->caller.id.name.valid=			req_caller->id.name.valid;
+	if (req_caller->id.name.valid)
+	  if (req_caller->id.name.str)
+	    if (req_caller->id.name.str[0])
+		ast->caller.id.name.str=		strdup(req_caller->id.name.str);
+	ast->caller.id.name.presentation=		req_caller->id.name.presentation;
+
+	ast->caller.id.subaddress.valid=		req_caller->id.subaddress.valid;
+	if (req_caller->id.subaddress.valid)
+	  if (req_caller->id.subaddress.str)
+	    if (req_caller->id.subaddress.str[0])
+		ast->caller.id.subaddress.str=		strdup(req_caller->id.subaddress.str);
+	ast->caller.id.subaddress.type=			req_caller->id.subaddress.type;
 
 	if (requestor->dialed.number.str)
 	  if (requestor->dialed.number.str[0])
@@ -1892,24 +2276,165 @@ struct ast_channel *lcr_request(const char *type, format_t format, const struct
 	ast->dialed.subaddress.type=			requestor->dialed.subaddress.type;
 
 	ast->dialed.transit_network_select=		requestor->dialed.transit_network_select;
-	ast->redirecting.count=				requestor->redirecting.count;
-	ast->redirecting.reason=			requestor->redirecting.reason;
-
-	ast->redirecting.from.number.valid=		requestor->redirecting.from.number.valid;
-	if (requestor->redirecting.from.number.valid)
-	  if (requestor->redirecting.from.number.str)
-	    if (requestor->redirecting.from.number.str[0])
-		ast->redirecting.from.number.str=	strdup(requestor->redirecting.from.number.str);
-	ast->redirecting.from.number.plan=		requestor->redirecting.from.number.plan;
-	ast->redirecting.from.number.presentation=	requestor->redirecting.from.number.presentation;
-
-	ast->redirecting.to.number.valid=		requestor->redirecting.to.number.valid;
-	if (requestor->redirecting.to.number.valid)
-	  if (requestor->redirecting.to.number.str)
-	    if (requestor->redirecting.to.number.str[0])
-		ast->redirecting.to.number.str=		strdup(requestor->redirecting.to.number.str);
-	ast->redirecting.to.number.plan=		requestor->redirecting.to.number.plan;
-	ast->redirecting.to.number.presentation=	requestor->redirecting.to.number.presentation;
+	ast->redirecting.count=				req_redir->count;
+	ast->redirecting.reason=			req_redir->reason;
+
+	ast->redirecting.from.number.valid=		req_redir->from.number.valid;
+	if (req_redir->from.number.valid)
+	  if (req_redir->from.number.str)
+	    if (req_redir->from.number.str[0])
+		ast->redirecting.from.number.str=	strdup(req_redir->from.number.str);
+	ast->redirecting.from.number.plan=		req_redir->from.number.plan;
+	ast->redirecting.from.number.presentation=	req_redir->from.number.presentation;
+
+	ast->redirecting.to.number.valid=		req_redir->to.number.valid;
+	if (req_redir->to.number.valid)
+	  if (req_redir->to.number.str)
+	    if (req_redir->to.number.str[0])
+		ast->redirecting.to.number.str=		strdup(req_redir->to.number.str);
+	ast->redirecting.to.number.plan=		req_redir->to.number.plan;
+	ast->redirecting.to.number.presentation=	req_redir->to.number.presentation;
+#endif
+	/* store call information for setup */
+
+	/* caller ID */
+	if (requestor && req_caller->id.number.valid) {
+		if (req_caller->id.number.str)
+			strncpy(call->callerinfo.id, req_caller->id.number.str, sizeof(call->callerinfo.id)-1);
+		switch(req_caller->id.number.presentation & AST_PRES_RESTRICTION) {
+			case AST_PRES_RESTRICTED:
+			call->callerinfo.present = INFO_PRESENT_RESTRICTED;
+			break;
+			case AST_PRES_UNAVAILABLE:
+			call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
+			break;
+			case AST_PRES_ALLOWED:
+			default:
+			call->callerinfo.present = INFO_PRESENT_ALLOWED;
+		}
+		switch(req_caller->id.number.presentation & AST_PRES_NUMBER_TYPE) {
+			case AST_PRES_USER_NUMBER_UNSCREENED:
+			call->callerinfo.screen = INFO_SCREEN_USER;
+			break;
+			case AST_PRES_USER_NUMBER_PASSED_SCREEN:
+			call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
+			break;
+			case AST_PRES_USER_NUMBER_FAILED_SCREEN:
+			call->callerinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
+			break;
+			default:
+			call->callerinfo.screen = INFO_SCREEN_NETWORK;
+		}
+		switch((req_caller->id.number.plan >> 4) & 7) {
+			case 4:
+			call->callerinfo.ntype = INFO_NTYPE_SUBSCRIBER;
+			break;
+			case 2:
+			call->callerinfo.ntype = INFO_NTYPE_NATIONAL;
+			break;
+			case 1:
+			call->callerinfo.ntype = INFO_NTYPE_INTERNATIONAL;
+			break;
+			default:
+			call->callerinfo.ntype = INFO_NTYPE_UNKNOWN;
+		}
+	} else
+		call->callerinfo.present = INFO_PRESENT_NOTAVAIL;
+
+	/* caller ID 2 */
+	if (requestor && req_caller->ani.number.valid) {
+		if (req_caller->ani.number.str)
+			strncpy(call->callerinfo.id2, req_caller->ani.number.str, sizeof(call->callerinfo.id2)-1);
+		switch(req_caller->ani.number.presentation & AST_PRES_RESTRICTION) {
+			case AST_PRES_RESTRICTED:
+			call->callerinfo.present2 = INFO_PRESENT_RESTRICTED;
+			break;
+			case AST_PRES_UNAVAILABLE:
+			call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
+			break;
+			case AST_PRES_ALLOWED:
+			default:
+			call->callerinfo.present2 = INFO_PRESENT_ALLOWED;
+		}
+		switch(req_caller->ani.number.presentation & AST_PRES_NUMBER_TYPE) {
+			case AST_PRES_USER_NUMBER_UNSCREENED:
+			call->callerinfo.screen2 = INFO_SCREEN_USER;
+			break;
+			case AST_PRES_USER_NUMBER_PASSED_SCREEN:
+			call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_PASSED;
+			break;
+			case AST_PRES_USER_NUMBER_FAILED_SCREEN:
+			call->callerinfo.screen2 = INFO_SCREEN_USER_VERIFIED_FAILED;
+			break;
+			default:
+			call->callerinfo.screen2 = INFO_SCREEN_NETWORK;
+		}
+		switch((req_caller->ani.number.plan >> 4) & 7) {
+			case 4:
+			call->callerinfo.ntype2 = INFO_NTYPE_SUBSCRIBER;
+			break;
+			case 2:
+			call->callerinfo.ntype2 = INFO_NTYPE_NATIONAL;
+			break;
+			case 1:
+			call->callerinfo.ntype2 = INFO_NTYPE_INTERNATIONAL;
+			break;
+			default:
+			call->callerinfo.ntype2 = INFO_NTYPE_UNKNOWN;
+		}
+	} else
+		call->callerinfo.present2 = INFO_PRESENT_NOTAVAIL;
+
+	/* caller name */
+	if (requestor && req_caller->id.name.valid) {
+		if (req_caller->id.name.str)
+			strncpy(call->callerinfo.name, req_caller->id.name.str, sizeof(call->callerinfo.name)-1);
+	}
+
+	/* redir number */
+	if (requestor && req_redir->from.number.valid) {
+		call->redirinfo.itype = INFO_ITYPE_CHAN;
+		if (req_redir->from.number.str)
+			strncpy(call->redirinfo.id, req_redir->from.number.str, sizeof(call->redirinfo.id)-1);
+		switch(req_redir->from.number.presentation & AST_PRES_RESTRICTION) {
+			case AST_PRES_RESTRICTED:
+			call->redirinfo.present = INFO_PRESENT_RESTRICTED;
+			break;
+			case AST_PRES_UNAVAILABLE:
+			call->redirinfo.present = INFO_PRESENT_NOTAVAIL;
+			break;
+			case AST_PRES_ALLOWED:
+			default:
+			call->redirinfo.present = INFO_PRESENT_ALLOWED;
+		}
+		switch(req_redir->from.number.presentation & AST_PRES_NUMBER_TYPE) {
+			case AST_PRES_USER_NUMBER_UNSCREENED:
+			call->redirinfo.screen = INFO_SCREEN_USER;
+			break;
+			case AST_PRES_USER_NUMBER_PASSED_SCREEN:
+			call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_PASSED;
+			break;
+			case AST_PRES_USER_NUMBER_FAILED_SCREEN:
+			call->redirinfo.screen = INFO_SCREEN_USER_VERIFIED_FAILED;
+			break;
+			default:
+			call->redirinfo.screen = INFO_SCREEN_NETWORK;
+		}
+		switch((req_redir->from.number.plan >> 4) & 7) {
+			case 4:
+			call->redirinfo.ntype = INFO_NTYPE_SUBSCRIBER;
+			break;
+			case 2:
+			call->redirinfo.ntype = INFO_NTYPE_NATIONAL;
+			break;
+			case 1:
+			call->redirinfo.ntype = INFO_NTYPE_INTERNATIONAL;
+			break;
+			default:
+			call->redirinfo.ntype = INFO_NTYPE_UNKNOWN;
+		}
+	}
+#endif
 
 	ast_mutex_unlock(&chan_lock);
 	return ast;
@@ -1922,9 +2447,21 @@ static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
 {
 	union parameter newparam;
 	struct chan_call *call;
+#if ASTERISK_VERSION_NUM >= 110000
+	int transfercapability;
+#endif
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
+
+	#ifdef LCR_FOR_CALLWEAVER
+	ast->type = "LCR";
+	snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type, call->dialstring, ast_random() & 0xffff);
+	#endif
 
 	if (!call) {
 		CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
@@ -1938,20 +2475,52 @@ static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
 	call->pbx_started = 1;
 	/* send MESSAGE_NEWREF */
 	memset(&newparam, 0, sizeof(union parameter));
-	newparam.direction = 0; /* request from app */
+	newparam.newref.direction = 0; /* request from app */
+	if (!strcmp(call->interface, "pbx"))
+		newparam.newref.mode = 1;
 	send_message(MESSAGE_NEWREF, 0, &newparam);
 
 	/* set hdlc if capability requires hdlc */
+#if ASTERISK_VERSION_NUM < 110000
 	if (ast->transfercapability == INFO_BC_DATAUNRESTRICTED
 	 || ast->transfercapability == INFO_BC_DATARESTRICTED
 	 || ast->transfercapability == INFO_BC_VIDEO)
+#else
+	transfercapability=ast_channel_transfercapability(ast);
+	if (transfercapability == INFO_BC_DATAUNRESTRICTED
+	 || transfercapability == INFO_BC_DATARESTRICTED
+	 || transfercapability == INFO_BC_VIDEO)
+#endif
 		call->hdlc = 1;
 	/* if hdlc is forced by option, we change transcap to data */
 	if (call->hdlc
+#if ASTERISK_VERSION_NUM < 110000
 	 && ast->transfercapability != INFO_BC_DATAUNRESTRICTED
 	 && ast->transfercapability != INFO_BC_DATARESTRICTED
 	 && ast->transfercapability != INFO_BC_VIDEO)
 		ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
+#else
+	 && transfercapability != INFO_BC_DATAUNRESTRICTED
+	 && transfercapability != INFO_BC_DATARESTRICTED
+	 && transfercapability != INFO_BC_VIDEO)
+		transfercapability = INFO_BC_DATAUNRESTRICTED;
+#endif
+
+#ifndef AST_1_8_OR_HIGHER
+	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);
+#endif
 
 	ast_mutex_unlock(&chan_lock);
 	return 0;
@@ -1986,24 +2555,39 @@ static void send_digit_to_chan(struct ast_channel * ast, char digit )
 	else if (digit == '#')
 		ast_playtones_start(ast,0,dtmf_tones[15], 0);
 	else {
-		/* not handled */
-		CDEBUG(NULL, ast, "Unable to handle DTMF tone "
-			"'%c' for '%s'\n", digit, ast->name);
-        }
+#if ASTERISK_VERSION_NUM < 110000
+		CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast->name);
+#else
+		CDEBUG(NULL, ast, "Unable to handle DTMF tone '%c' for '%s'\n", digit, ast_channel_name(ast));
+#endif
+	}
 }
 
+#ifdef LCR_FOR_ASTERISK
 static int lcr_digit_begin(struct ast_channel *ast, char digit)
+#endif
+#ifdef LCR_FOR_CALLWEAVER
+static int lcr_digit(struct ast_channel *ast, char digit)
+#endif
 {
 	struct chan_call *call;
 	union parameter newparam;
 	char buf[]="x";
 
+#ifdef LCR_FOR_CALLWEAVER
+	int inband_dtmf = 0;
+#endif
+
 	/* only pass IA5 number space */
 	if (digit > 126 || digit < 32)
 		return 0;
 
 	ast_mutex_lock(&chan_lock);
-        call = ast->tech_pvt;
+#if ASTERISK_VERSION_NUM < 110000
+	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
 		ast_mutex_unlock(&chan_lock);
@@ -2033,6 +2617,8 @@ static int lcr_digit_begin(struct ast_channel *ast, char digit)
 	}
 
 	ast_mutex_unlock(&chan_lock);
+
+#ifdef LCR_FOR_ASTERISK
 	return 0;
 }
 
@@ -2040,15 +2626,20 @@ static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int durat
 {
 	int inband_dtmf = 0;
 	struct chan_call *call;
+#endif
 
 	ast_mutex_lock(&chan_lock);
 
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 
 	if (!call) {
 		CERROR(NULL, ast,
-		       "Received digit from Asterisk, "
-		       "but no call instance exists.\n");
+			"Received digit from Asterisk, "
+			"but no call instance exists.\n");
 		ast_mutex_unlock(&chan_lock);
 		return -1;
 	}
@@ -2075,7 +2666,11 @@ static int lcr_answer(struct ast_channel *ast)
 	struct chan_call *call;
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		CERROR(NULL, ast, "Received answer from Asterisk, but no call instance exists.\n");
 		ast_mutex_unlock(&chan_lock);
@@ -2106,7 +2701,7 @@ static int lcr_answer(struct ast_channel *ast)
 //	memset(&newparam, 0, sizeof(union parameter));
 //	send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
 
-	ast_mutex_unlock(&chan_lock);
+  	ast_mutex_unlock(&chan_lock);
 	return 0;
 }
 
@@ -2118,7 +2713,11 @@ static int lcr_hangup(struct ast_channel *ast)
 	if (!pthread_equal(tid, chan_tid)) {
 		ast_mutex_lock(&chan_lock);
 	}
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
 		if (!pthread_equal(tid, chan_tid)) {
@@ -2133,13 +2732,23 @@ static int lcr_hangup(struct ast_channel *ast)
 		CDEBUG(call, ast, "Received hangup from LCR thread.\n");
 
 	/* disconnect asterisk, maybe not required */
+#if ASTERISK_VERSION_NUM < 110000
 	ast->tech_pvt = NULL;
 	ast->fds[0] = -1;
+#else
+	ast_channel_tech_pvt_set(ast, NULL);
+	ast_channel_set_fd(ast, 0, -1);
+#endif
 	if (call->ref) {
 		/* release */
 		CDEBUG(call, ast, "Releasing ref and freeing call instance.\n");
+#if ASTERISK_VERSION_NUM < 110000
 		if (ast->hangupcause > 0)
 			send_release_and_import(call, ast->hangupcause, LOCATION_PRIVATE_LOCAL);
+#else
+		if (ast_channel_hangupcause(ast) > 0)
+			send_release_and_import(call, ast_channel_hangupcause(ast), LOCATION_PRIVATE_LOCAL);
+#endif
 		else
 			send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
 		/* remove call */
@@ -2167,24 +2776,81 @@ static int lcr_hangup(struct ast_channel *ast)
 	return 0;
 }
 
-static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
+static int lcr_write(struct ast_channel *ast, struct ast_frame *fr)
 {
 	struct chan_call *call;
+	struct ast_frame * f = fr;
 
-	if (!f->subclass.integer)
+#if ASTERISK_VERSION_NUM < 100000
+#ifdef AST_1_8_OR_HIGHER
+	if (!f->subclass.codec)
+#else
+	if (!f->subclass)
+#endif
 		CDEBUG(NULL, ast, "No subclass\n");
-	if (!(f->subclass.integer & ast->nativeformats))
-		CDEBUG(NULL, ast, "Unexpected format.\n");
+#endif
+#ifdef AST_1_8_OR_HIGHER
+#if ASTERISK_VERSION_NUM < 100000
+#if ASTERISK_VERSION_NUM < 110000
+	if (!(f->subclass.codec & ast->nativeformats)) {
+#else
+	if (!(f->subclass.codec & ast_channel_nativeformats(ast))) {
+#endif
+#else
+#if ASTERISK_VERSION_NUM < 110000
+	if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
+#else
+	if (!ast_format_cap_iscompatible(ast_channel_nativeformats(ast), &f->subclass.format)) {
+#endif
+#endif
+#else
+#if ASTERISK_VERSION_NUM < 110000
+	if (!(f->subclass & ast->nativeformats)) {
+#else
+	if (!(f->subclass & ast_channel_nativeformats(ast))) {
+#endif
+#endif
+		CDEBUG(NULL, ast,
+	        	       "Unexpected format. "
+		       "Activating emergency conversion...\n");
+
+#ifdef AST_1_8_OR_HIGHER
+#if ASTERISK_VERSION_NUM < 100000
+		ast_set_write_format(ast, f->subclass.codec);
+#else
+		ast_set_write_format(ast, &f->subclass.format);
+#endif
+#else
+		ast_set_write_format(ast, f->subclass);
+#endif
+#if ASTERISK_VERSION_NUM < 110000
+		f = (ast->writetrans) ? ast_translate(
+			ast->writetrans, fr, 0) : fr;
+#else
+		f = (ast_channel_writetrans(ast)) ? ast_translate(
+			ast_channel_writetrans(ast), fr, 0) : fr;
+#endif
+	}
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		ast_mutex_unlock(&chan_lock);
+		if (f != fr) {
+			ast_frfree(f);
+		}
 		return -1;
 	}
 	if (call->bchannel && f->samples)
 		bchannel_transmit(call->bchannel, *((unsigned char **)&(f->data)), f->samples);
 	ast_mutex_unlock(&chan_lock);
+	if (f != fr) {
+		ast_frfree(f);
+	}
 	return 0;
 }
 
@@ -2192,10 +2858,14 @@ static int lcr_write(struct ast_channel *ast, struct ast_frame *f)
 static struct ast_frame *lcr_read(struct ast_channel *ast)
 {
 	struct chan_call *call;
-	int len=0;
+	int len = 0;
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		ast_mutex_unlock(&chan_lock);
 		return NULL;
@@ -2212,7 +2882,15 @@ static struct ast_frame *lcr_read(struct ast_channel *ast)
 		}
 		if (len < 0 && errno == EAGAIN) {
 			ast_mutex_unlock(&chan_lock);
+
+			#ifdef LCR_FOR_ASTERISK
 			return &ast_null_frame;
+			#endif
+
+			#ifdef LCR_FOR_CALLWEAVER
+			return &nullframe;
+			#endif
+
 		}
 		if (len <= 0) {
 			close(call->pipe[0]);
@@ -2228,7 +2906,28 @@ static struct ast_frame *lcr_read(struct ast_channel *ast)
 	}
 
 	call->read_fr.frametype = AST_FRAME_VOICE;
-	call->read_fr.subclass.integer = ast->nativeformats;
+#ifdef AST_1_8_OR_HIGHER
+#if ASTERISK_VERSION_NUM < 100000
+#if ASTERISK_VERSION_NUM < 110000
+	call->read_fr.subclass.codec = ast->nativeformats;
+#else
+	call->read_fr.subclass.codec = ast_channel_nativeformats(ast);
+#endif
+#else
+#if ASTERISK_VERSION_NUM < 110000
+	ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
+#else
+	ast_best_codec(ast_channel_nativeformats(ast), &call->read_fr.subclass.format);
+#endif
+	call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
+#endif
+#else
+#if ASTERISK_VERSION_NUM < 110000
+	call->read_fr.subclass = ast->nativeformats;
+#else
+	call->read_fr.subclass = ast_channel_nativeformats(ast);
+#endif
+#endif
 	if (call->rebuffer) {
 		call->read_fr.datalen = call->framepos;
 		call->read_fr.samples = call->framepos;
@@ -2252,7 +2951,11 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 	const struct tone_zone_sound *ts = NULL;
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		CERROR(NULL, ast, "Received indicate from Asterisk, but no call instance exists.\n");
 		ast_mutex_unlock(&chan_lock);
@@ -2273,22 +2976,38 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 				call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
 			} else {
 				CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
+#if ASTERISK_VERSION_NUM < 110000
 				ts = ast_get_indication_tone(ast->zone, "busy");
+#else
+				ts = ast_get_indication_tone(ast_channel_zone(ast), "busy");
+#endif
 			}
 			break;
 		case AST_CONTROL_CONGESTION:
+#if ASTERISK_VERSION_NUM < 110000
 			CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast->hangupcause);
+#else
+			CDEBUG(call, ast, "Received indicate AST_CONTROL_CONGESTION from Asterisk. (cause %d)\n", ast_channel_hangupcause(ast));
+#endif
 			if (call->state != CHAN_LCR_STATE_OUT_DISCONNECT) {
 				/* send message to lcr */
 				memset(&newparam, 0, sizeof(union parameter));
+#if ASTERISK_VERSION_NUM < 110000
 				newparam.disconnectinfo.cause = ast->hangupcause;
+#else
+				newparam.disconnectinfo.cause = ast_channel_hangupcause(ast);
+#endif
 				newparam.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
 				send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
 				/* change state */
 				call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
 			} else {
 				CDEBUG(call, ast, "Using Asterisk 'congestion' indication\n");
+#if ASTERISK_VERSION_NUM < 110000
 				ts = ast_get_indication_tone(ast->zone, "congestion");
+#else
+				ts = ast_get_indication_tone(ast_channel_zone(ast), "congestion");
+#endif
 			}
 			break;
 		case AST_CONTROL_PROCEEDING:
@@ -2315,7 +3034,11 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 				call->state = CHAN_LCR_STATE_IN_ALERTING;
 			} else {
 				CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
+#if ASTERISK_VERSION_NUM < 110000
 				ts = ast_get_indication_tone(ast->zone, "ring");
+#else
+				ts = ast_get_indication_tone(ast_channel_zone(ast), "ring");
+#endif
 			}
 			break;
 		case AST_CONTROL_PROGRESS:
@@ -2331,7 +3054,7 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 		case -1:
 			CDEBUG(call, ast, "Received indicate -1.\n");
 			ast_playtones_stop(ast);
-                        res = -1;
+			res = -1;
 			break;
 
 		case AST_CONTROL_VIDUPDATE:
@@ -2346,10 +3069,21 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 			send_message(MESSAGE_NOTIFY, call->ref, &newparam);
 
 			/*start music onhold*/
+			#ifdef LCR_FOR_ASTERISK
+			#if ASTERISK_VERSION_NUM <110000
 			ast_moh_start(ast,data,ast->musicclass);
+			#else
+			ast_moh_start(ast,data,ast_channel_musicclass(ast));
+			#endif
+			#endif
+
+			#ifdef LCR_FOR_CALLWEAVER
+			ast_moh_start(ast, NULL);
+			#endif
+
 			call->on_hold = 1;
-                        break;
-                case AST_CONTROL_UNHOLD:
+			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));
@@ -2366,12 +3100,12 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 		case 20:
 #endif
 			CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
-                        break;
+			break;
 		default:
 			CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
-                        res = -1;
+			res = -1;
 			break;
-        }
+	}
 
 	if (ts && ts->data[0]) {
 		ast_playtones_start(ast, 0, ts->data, 1);
@@ -2379,7 +3113,7 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
 
 	/* return */
 	ast_mutex_unlock(&chan_lock);
-        return res;
+	return res;
 }
 
 /*
@@ -2394,7 +3128,11 @@ static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
 	}
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		CERROR(NULL, ast, "Received fixup from Asterisk, but no call instance exists.\n");
 		ast_mutex_unlock(&chan_lock);
@@ -2416,7 +3154,11 @@ static int lcr_send_text(struct ast_channel *ast, const char *text)
 	union parameter newparam;
 
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call = ast->tech_pvt;
+#else
+	call = ast_channel_tech_pvt(ast);
+#endif
 	if (!call) {
 		CERROR(NULL, ast, "Received send_text from Asterisk, but no call instance exists.\n");
 		ast_mutex_unlock(&chan_lock);
@@ -2453,8 +3195,13 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
 
 	/* join via dsp (if the channels are currently open) */
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call1 = ast1->tech_pvt;
 	call2 = ast2->tech_pvt;
+#else
+	call1 = ast_channel_tech_pvt(ast1);
+	call2 = ast_channel_tech_pvt(ast2);
+#endif
 	if (!call1 || !call2) {
 		CDEBUG(NULL, NULL, "Bridge, but we don't have two call instances, exitting.\n");
 		ast_mutex_unlock(&chan_lock);
@@ -2568,8 +3315,13 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
 
 	/* split channels */
 	ast_mutex_lock(&chan_lock);
+#if ASTERISK_VERSION_NUM < 110000
 	call1 = ast1->tech_pvt;
 	call2 = ast2->tech_pvt;
+#else
+	call1 = ast_channel_tech_pvt(ast1);
+	call2 = ast_channel_tech_pvt(ast2);
+#endif
 	if (call1 && call1->bridge_id) {
 		call1->bridge_id = 0;
 		if (call1->bchannel)
@@ -2591,12 +3343,22 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
 	return AST_BRIDGE_COMPLETE;
 }
 static struct ast_channel_tech lcr_tech = {
-	.type="LCR",
+	.type= lcr_type,
 	.description = "Channel driver for connecting to Linux-Call-Router",
+	#if ASTERISK_VERSION_NUM < 100000
 	.capabilities = AST_FORMAT_ALAW,
+	#endif
 	.requester = lcr_request,
+
+	#ifdef LCR_FOR_ASTERISK
 	.send_digit_begin = lcr_digit_begin,
 	.send_digit_end = lcr_digit_end,
+	#endif
+
+	#ifdef LCR_FOR_CALLWEAVER
+	.send_digit = lcr_digit,
+	#endif
+
 	.call = lcr_call,
 	.bridge = lcr_bridge,
 	.hangup = lcr_hangup,
@@ -2700,13 +3462,29 @@ static struct ast_cli_entry cli_port_unload =
 #endif
 
 
+#ifdef LCR_FOR_ASTERISK
+#ifdef AST_1_8_OR_HIGHER
+static int lcr_config_exec(struct ast_channel *ast, const char *data)
+#else
 static int lcr_config_exec(struct ast_channel *ast, void *data)
+#endif
+#endif
+
+#ifdef LCR_FOR_CALLWEAVER
+static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
+#endif
 {
 	struct chan_call *call;
 
 	ast_mutex_lock(&chan_lock);
 
+	#ifdef LCR_FOR_ASTERISK
 	CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
+	#endif
+
+	#ifdef LCR_FOR_CALLWEAVER
+	CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
+	#endif
 
 	/* find channel */
 	call = call_first;
@@ -2716,7 +3494,15 @@ static int lcr_config_exec(struct ast_channel *ast, void *data)
 		call = call->next;
 	}
 	if (call)
+
+		#ifdef LCR_FOR_ASTERISK
 		apply_opt(call, (char *)data);
+		#endif
+
+		#ifdef LCR_FOR_CALLWEAVER
+		apply_opt(call, (char *)argv[0]);
+		#endif
+
 	else
 		CERROR(NULL, ast, "lcr_config app not called by chan_lcr channel.\n");
 
@@ -2739,7 +3525,15 @@ int load_module(void)
 
 	if (read_options(options_error) == 0) {
 		CERROR(NULL, NULL, "%s", options_error);
+
+		#ifdef LCR_FOR_ASTERISK
 		return AST_MODULE_LOAD_DECLINE;
+		#endif
+
+		#ifdef LCR_FOR_CALLWEAVER
+		return 0;
+		#endif
+
 	}
 
 	ast_mutex_init(&chan_lock);
@@ -2748,20 +3542,51 @@ int load_module(void)
 	if (bchannel_initialize()) {
 		CERROR(NULL, NULL, "Unable to open mISDN device\n");
 		close_socket();
+
+		#ifdef LCR_FOR_ASTERISK
 		return AST_MODULE_LOAD_DECLINE;
+		#endif
+
+		#ifdef LCR_FOR_CALLWEAVER
+		return 0;
+		#endif
 	}
 	mISDN_created = 1;
 
+	#if ASTERISK_VERSION_NUM < 100000
 	lcr_tech.capabilities = (options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW;
+	#else
+	struct ast_format tmp;
+	ast_format_set(&tmp ,(options.law=='a')?AST_FORMAT_ALAW:AST_FORMAT_ULAW , 0);
+	if (!(lcr_tech.capabilities = ast_format_cap_alloc())) {
+		return AST_MODULE_LOAD_DECLINE;
+	}
+	ast_format_cap_add(lcr_tech.capabilities, &tmp);
+	#endif
 	if (ast_channel_register(&lcr_tech)) {
 		CERROR(NULL, NULL, "Unable to register channel class\n");
 		bchannel_deinitialize();
 		close_socket();
+
+		#ifdef LCR_FOR_ASTERISK
 		return AST_MODULE_LOAD_DECLINE;
+		#endif
+
+		#ifdef LCR_FOR_CALLWEAVER
+		return 0;
+		#endif
 	}
 
 	ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
+
+				 #ifdef LCR_FOR_ASTERISK
 				 "lcr_config(<opt><optarg>:<opt>:...)\n"
+				 #endif
+
+				 #ifdef LCR_FOR_CALLWEAVER
+				 "lcr_config(<opt><optarg>:<opt>:...)\n",
+				 #endif
+
 				 "Sets LCR opts. and optargs\n"
 				 "\n"
 				 "The available options are:\n"
@@ -2801,13 +3626,20 @@ int load_module(void)
 	ast_cli_register(&cli_port_unload);
 #endif
 
-	quit = 0;
 	if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
 		/* failed to create thread */
 		bchannel_deinitialize();
 		close_socket();
 		ast_channel_unregister(&lcr_tech);
+
+		#ifdef LCR_FOR_ASTERISK
 		return AST_MODULE_LOAD_DECLINE;
+		#endif
+
+		#ifdef LCR_FOR_CALLWEAVER
+		return 0;
+		#endif
+
 	}
 	return 0;
 }
@@ -2815,16 +3647,24 @@ int load_module(void)
 int unload_module(void)
 {
 	/* First, take us out of the channel loop */
-	CDEBUG(NULL, NULL, "-- Unregistering mISDN Channel Driver --\n");
+	CDEBUG(NULL, NULL, "-- Unregistering Linux-Call-Router Channel Driver --\n");
+
+	pthread_cancel(chan_tid);
+
+	close_socket();
+
+	del_timer(&socket_retry);
 
-	quit = 1;
-	pthread_join(chan_tid, NULL);
+	unregister_fd(&wake_fd);
+	close(wake_pipe[0]);
+	close(wake_pipe[1]);
+
+//	ast_mutex_unlock(&chan_lock);
 
 	ast_channel_unregister(&lcr_tech);
 
 	ast_unregister_application("lcr_config");
 
-
 	if (mISDN_created) {
 		bchannel_deinitialize();
 		mISDN_created = 0;
@@ -2835,6 +3675,9 @@ int unload_module(void)
 		lcr_sock = -1;
 	}
 
+#if ASTERISK_VERSION_NUM >= 100000
+	lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
+#endif
 	return 0;
 }
 
@@ -2844,9 +3687,33 @@ int reload_module(void)
 	return 0;
 }
 
+#ifdef LCR_FOR_ASTERISK
 #define AST_MODULE "chan_lcr"
+#endif
+
+#ifdef LCR_FOR_CALLWEAVER
+int usecount(void)
+hae
+{
+	int res;
+	ast_mutex_lock(&usecnt_lock);
+	res = usecnt;
+	ast_mutex_unlock(&usecnt_lock);
+	return res;
+}
+#endif
+
+#ifdef LCR_FOR_ASTERISK
 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,
 	       );
+#endif
+
+#ifdef LCR_FOR_CALLWEAVER
+char *description(void)
+{
+	return desc;
+}
+#endif