Fixed chan_lcr unload bug, found by Patrick

[lcr.git] / chan_lcr.c

diff --git a/chan_lcr.c b/chan_lcr.c
index 6a953a2..e8e2e7e 100644 (file)
--- a/chan_lcr.c
+++ b/chan_lcr.c
@@ -40,7 +40,7 @@ a new call reference (ref).
 The ref_was_assigned ist set to 1.
 Further dialing information is queued.
 After the new callref is received by special MESSAGE_NEWREF reply, new ref
 The ref_was_assigned ist set to 1.
 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. 
+is stored in the chan_call structure.

 The setup information is sent to LCR using MESSAGE_SETUP.
 The state changes to CHAN_LCR_STATE_OUT_SETUP.
 
 The setup information is sent to LCR using MESSAGE_SETUP.
 The state changes to CHAN_LCR_STATE_OUT_SETUP.
 


@@ -161,6 +161,7 @@ it is called from ast_channel process which has already locked ast_channel.
 #include <asterisk/app.h>
 #include <asterisk/features.h>
 #include <asterisk/sched.h>
 #include <asterisk/app.h>
 #include <asterisk/features.h>
 #include <asterisk/sched.h>

+#include <asterisk/version.h>

 
 #include "extension.h"
 #include "message.h"
 
 #include "extension.h"
 #include "message.h"


@@ -207,8 +208,6 @@ int global_change = 0;
 int wake_global = 0;
 int wake_pipe[2];
 struct lcr_fd wake_fd;
 int wake_global = 0;
 int wake_pipe[2];
 struct lcr_fd wake_fd;

-       
-int quit;

 
 int glob_channel = 0;
 
 
 int glob_channel = 0;
 


@@ -243,10 +242,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 (call)
                sprintf(call_text, "%d", call->ref);
        if (ast)

+#if ASTERISK_VERSION_NUM < 110000

                strncpy(ast_text, ast->name, sizeof(ast_text)-1);
                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_text[sizeof(ast_text)-1] = '\0';

-       
-       ast_log(type, file, line, function, "[call=%s ast=%s] %s", call_text, ast_text, buffer);
+
+//     ast_log(type, file, line, function, "[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);
 }
 
        ast_mutex_unlock(&log_lock);
 }


@@ -265,7 +269,7 @@ struct chan_call *find_call_ref(unsigned int ref)
 {
        struct chan_call *call = call_first;
        int assigned = (ref > 0);
 {
        struct chan_call *call = call_first;
        int assigned = (ref > 0);

-       
+

        while(call) {
                if (call->ref == ref && call->ref_was_assigned == assigned)
                        break;
        while(call) {
                if (call->ref == ref && call->ref_was_assigned == assigned)
                        break;


@@ -361,7 +365,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, "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)
 
        adminp = &admin_first;
        while(*adminp)


@@ -534,13 +538,22 @@ void apply_opt(struct chan_call *call, char *data)
                                #endif
 
                                #endif
                                #endif
 
                                #endif

-                               if (!call->trans)
+                               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
                                        #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);
                                        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
                                        #endif

+                               }

                        }
                        CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
                        break;
                        }
                        CDEBUG(call, call->ast, "Option 'f' (faxdetect) with config '%s'.\n", call->faxdetect);
                        break;


@@ -594,8 +607,8 @@ void apply_opt(struct chan_call *call, char *data)
                default:
                        CERROR(call, call->ast, "Option '%s' unknown.\n", opt);
                }
                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);
        /* re-open, if bchannel is created */
        if (call->bchannel && call->bchannel->b_sock > -1) {
                bchannel_destroy(call->bchannel);


@@ -612,34 +625,45 @@ static void send_setup_to_lcr(struct chan_call *call)
 {
        union parameter newparam;
        struct ast_channel *ast = call->ast;
 {
        union parameter newparam;
        struct ast_channel *ast = call->ast;

-       const char *tmp;
+//     const char *tmp;

 
        if (!call->ast || !call->ref)
                return;
 
 
        if (!call->ast || !call->ref)
                return;
 

+#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);
        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));
 
        /* 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);
        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);
-               newparam.setup.callerinfo.itype = INFO_ITYPE_CHAN;      
-               newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
+       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';
        strncpy(newparam.setup.callerinfo.display, call->display, sizeof(newparam.setup.callerinfo.display)-1);
        call->display[0] = '\0';

+
+#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);
        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;    
+               newparam.setup.redirinfo.itype = INFO_ITYPE_CHAN;
+               newparam.setup.redirinfo.ntype = INFO_NTYPE_UNKNOWN;

        }
        switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
                case AST_PRES_RESTRICTED:
        }
        switch(ast->cid.cid_pres & AST_PRES_RESTRICTION) {
                case AST_PRES_RESTRICTED:


@@ -665,9 +689,11 @@ static void send_setup_to_lcr(struct chan_call *call)
                default:
                newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
        }
                default:
                newparam.setup.callerinfo.ntype = INFO_NTYPE_UNKNOWN;
        }

-       tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
-       if (tmp && *tmp)
-               ast->transfercapability = atoi(tmp);
+#endif
+#warning DISABLED DUE TO DOUBLE LOCKING PROBLEM
+//     tmp = pbx_builtin_getvar_helper(ast, "LCR_TRANSFERCAPABILITY");
+//     if (tmp && *tmp)
+//             ast->transfercapability = atoi(tmp);

        newparam.setup.capainfo.bearer_capa = ast->transfercapability;
        newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
        if (call->hdlc)
        newparam.setup.capainfo.bearer_capa = ast->transfercapability;
        newparam.setup.capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
        if (call->hdlc)


@@ -695,7 +721,7 @@ static void send_dialque_to_lcr(struct chan_call *call)
 
        if (!call->ast || !call->ref || !call->dialque[0])
                return;
 
        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 */
        CDEBUG(call, call->ast, "Sending dial queue to LCR. (dialing=%s)\n", call->dialque);
 
        /* send setup message to LCR */


@@ -751,21 +777,39 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
 {
        int cause, ret;
        union parameter newparam;
 {
        int cause, ret;
        union parameter newparam;

+#if ASTERISK_VERSION_NUM < 110000

        char *exten = ast->exten;
        char *exten = ast->exten;

+#else
+       char *exten = ast_channel_exten(ast);
+#endif

        if (!*exten)
                exten = "s";
 
        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");
        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 (complete) {
                /* if not match */

+#if ASTERISK_VERSION_NUM < 110000

                if (!ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
                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;
                }
                        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);
                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;
                }
                        cause = 28;
                        goto release;
                }


@@ -780,7 +824,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
                goto start;
        }
 
                goto start;
        }
 

+#if ASTERISK_VERSION_NUM < 110000

        if (ast_canmatch_extension(ast, ast->context, exten, 1, call->oad)) {
        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));
                /* send setup acknowledge to lcr */
                if (call->state != CHAN_LCR_STATE_IN_DIALING) {
                        memset(&newparam, 0, sizeof(union parameter));


@@ -791,7 +839,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 */
                call->state = CHAN_LCR_STATE_IN_DIALING;
 
                /* if match, start pbx */

+#if ASTERISK_VERSION_NUM < 110000

                if (ast_exists_extension(ast, ast->context, exten, 1, call->oad)) {
                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;
                }
                        CDEBUG(call, ast, "Extensions matches.\n");
                        goto start;
                }


@@ -801,7 +853,11 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
                return;
        }
 
                return;
        }
 

+#if ASTERISK_VERSION_NUM < 110000

        if (!*ast->exten) {
        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;
                /* 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;


@@ -820,16 +876,16 @@ static void lcr_start_pbx(struct chan_call *call, struct ast_channel *ast, int c
        call->state = CHAN_LCR_STATE_RELEASE;
        ast_hangup(ast); // call will be destroyed here
        return;
        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");
 
        start:
        /* send setup to asterisk */
        CDEBUG(call, ast, "Starting call to Asterisk due to matching extension.\n");
 

-       #ifdef LCR_FOR_CALLWEAVER       
+       #ifdef LCR_FOR_CALLWEAVER

        ast->type = "LCR";
        ast->type = "LCR";

-       snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",ast->cid.cid_num, ast_random() & 0xffff);
+       snprintf(ast->name, sizeof(ast->name), "%s/%s-%04x",lcr_type ,ast->cid.cid_num, ast_random() & 0xffff);

        #endif
        #endif

-       
+

        ret = ast_pbx_start(ast);
        if (ret < 0) {
                cause = (ret==-2)?34:27;
        ret = ast_pbx_start(ast);
        if (ret < 0) {
                cause = (ret==-2)?34:27;


@@ -855,9 +911,13 @@ static void lcr_in_setup(struct chan_call *call, int message_type, union paramet
        #endif
 
        #ifdef LCR_FOR_ASTERISK
        #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);
        ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);

+#endif

        #endif
        #endif

-       
+

        if (!ast) {
                /* release */
                CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");
        if (!ast) {
                /* release */
                CERROR(call, NULL, "Failed to create Asterisk channel - releasing.\n");


@@ -871,20 +931,163 @@ static void lcr_in_setup(struct chan_call *call, int message_type, union paramet
        ast->tech_pvt = call;
        ast->tech = &lcr_tech;
        ast->fds[0] = call->pipe[0];
        ast->tech_pvt = call;
        ast->tech = &lcr_tech;
        ast->fds[0] = call->pipe[0];

-       
+

        /* fill setup information */
        if (param->setup.dialinginfo.id)
        /* 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);
                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
+               strncpy(ast_channel_exten(ast), param->setup.dialinginfo.id, AST_MAX_EXTENSION-1);
+       if (param->setup.context[0])
+               strncpy(ast_channel_context(ast), param->setup.context, AST_MAX_CONTEXT-1);
+       else
+               strncpy(ast_channel_context(ast), param->setup.callerinfo.interface, AST_MAX_CONTEXT-1);
+#endif
+
+
+#ifdef AST_1_8_OR_HIGHER
+       if (param->setup.callerinfo.id[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;
+               }
+       }
+       if (param->setup.callerinfo.id2[0]) {
+               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.valid = 1;
+               ast->caller.id.name.str = strdup(param->setup.callerinfo.name);
+       }
+       if (param->setup.redirinfo.id[0]) {
+               ast->redirecting.from.number.valid = 1;
+               ast->redirecting.from.number.str = strdup(param->setup.redirinfo.id);
+               switch (param->setup.redirinfo.present) {
+                       case INFO_PRESENT_ALLOWED:
+                               ast->redirecting.from.number.presentation = AST_PRES_ALLOWED;
+                       break;
+                       case INFO_PRESENT_RESTRICTED:
+                               ast->redirecting.from.number.presentation = AST_PRES_RESTRICTED;
+                       break;
+                       default:
+                               ast->redirecting.from.number.presentation = AST_PRES_UNAVAILABLE;
+               }
+               switch (param->setup.redirinfo.screen) {
+                       case INFO_SCREEN_USER:
+                               ast->redirecting.from.number.presentation |= AST_PRES_USER_NUMBER_UNSCREENED;
+                       break;
+                       case INFO_SCREEN_USER_VERIFIED_PASSED:
+                               ast->redirecting.from.number.presentation |= AST_PRES_USER_NUMBER_PASSED_SCREEN;
+                       break;
+                       case INFO_SCREEN_USER_VERIFIED_FAILED:
+                               ast->redirecting.from.number.presentation |= AST_PRES_USER_NUMBER_FAILED_SCREEN;
+                       break;
+                       default:
+                               ast->redirecting.from.number.presentation |= AST_PRES_NETWORK_NUMBER;
+               }
+               switch (param->setup.redirinfo.ntype) {
+                       case INFO_NTYPE_SUBSCRIBER:
+                               ast->redirecting.from.number.plan = (4 << 4) | 1;
+                       break;
+                       case INFO_NTYPE_NATIONAL:
+                               ast->redirecting.from.number.plan = (2 << 4) | 1;
+                       break;
+                       case INFO_NTYPE_INTERNATIONAL:
+                               ast->redirecting.from.number.plan = (1 << 4) | 1;
+                       break;
+                       default:
+                               ast->redirecting.from.number.plan = (0 << 4) | 1;
+               }
+       }
+#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.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])
        if (param->setup.callerinfo.name[0])
                ast->cid.cid_name = strdup(param->setup.callerinfo.name);
        if (param->setup.redirinfo.id[0])

-               ast->cid.cid_name = strdup(numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.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->cid.cid_pres = AST_PRES_ALLOWED;
        switch (param->setup.callerinfo.present) {
                case INFO_PRESENT_ALLOWED:
                        ast->cid.cid_pres = AST_PRES_ALLOWED;


@@ -908,6 +1111,8 @@ static void lcr_in_setup(struct chan_call *call, int message_type, union paramet
                default:
                        ast->cid.cid_ton = 0;
        }
                default:
                        ast->cid.cid_ton = 0;
        }

+#endif
+

        ast->transfercapability = param->setup.capainfo.bearer_capa;
        /* enable hdlc if transcap is data */
        if (param->setup.capainfo.source_mode == B_MODE_HDLC)
        ast->transfercapability = param->setup.capainfo.bearer_capa;
        /* enable hdlc if transcap is data */
        if (param->setup.capainfo.source_mode == B_MODE_HDLC)


@@ -915,9 +1120,17 @@ static void lcr_in_setup(struct chan_call *call, int message_type, union paramet
        strncpy(call->oad, numberrize_callerinfo(param->setup.callerinfo.id, param->setup.callerinfo.ntype, options.national, options.international), sizeof(call->oad)-1);
 
        /* configure channel */
        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;
        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_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);
+#endif

        ast->priority = 1;
        ast->hangupcause = 0;
 
        ast->priority = 1;
        ast->hangupcause = 0;
 


@@ -998,7 +1211,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) {
        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);
                memset(&newparam, 0, sizeof(union parameter));
                newparam.bchannel.type = BCHANNEL_REQUEST;
                send_message(MESSAGE_BCHANNEL, call->ref, &newparam);


@@ -1075,8 +1288,8 @@ 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->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 we have an asterisk instance, queue hangup, else we are done */
        if (ast) {


@@ -1094,7 +1307,7 @@ static void lcr_in_release(struct chan_call *call, int message_type, union param
        } else {
                free_call(call);
        }
        } else {
                free_call(call);
        }

-       
+

 }
 
 /*
 }
 
 /*


@@ -1105,24 +1318,28 @@ static void lcr_in_information(struct chan_call *call, int message_type, union p
        struct ast_channel *ast = call->ast;
 
        CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);
        struct ast_channel *ast = call->ast;
 
        CDEBUG(call, call->ast, "Incoming information from LCR. (dialing=%s)\n", param->information.id);

-       
+

        if (!ast) return;
 
        /* pbx not started */
        if (!call->pbx_started) {
                CDEBUG(call, call->ast, "Asterisk not started, adding digits to number.\n");
        if (!ast) return;
 
        /* 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);
                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;
        }
                lcr_start_pbx(call, ast, param->information.sending_complete);
                return;
        }

-       
+

        /* change dailing state after setup */
        if (call->state == CHAN_LCR_STATE_IN_SETUP) {
                CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
                call->state = CHAN_LCR_STATE_IN_DIALING;
 //             ast_setstate(ast, AST_STATE_DIALING);
        }
        /* change dailing state after setup */
        if (call->state == CHAN_LCR_STATE_IN_SETUP) {
                CDEBUG(call, call->ast, "Changing from SETUP to DIALING state.\n");
                call->state = CHAN_LCR_STATE_IN_DIALING;
 //             ast_setstate(ast, AST_STATE_DIALING);
        }

-       
+

        /* queue digits */
        if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
                if (!wake_global) {
        /* queue digits */
        if (call->state == CHAN_LCR_STATE_IN_DIALING && param->information.id[0]) {
                if (!wake_global) {


@@ -1151,7 +1368,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) {
 
        /* 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);
                memset(&newparam, 0, sizeof(union parameter));
                newparam.bchannel.type = BCHANNEL_REQUEST;
                send_message(MESSAGE_BCHANNEL, call->ref, &newparam);


@@ -1194,7 +1411,7 @@ static void lcr_in_pattern(struct chan_call *call, int message_type, union param
 
        /* request bchannel */
        if (!call->bchannel) {
 
        /* 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);
                memset(&newparam, 0, sizeof(union parameter));
                newparam.bchannel.type = BCHANNEL_REQUEST;
                send_message(MESSAGE_BCHANNEL, call->ref, &newparam);


@@ -1298,6 +1515,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);
                                }
                                        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);
                                /* 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);


@@ -1328,7 +1549,7 @@ int receive_message(int message_type, unsigned int ref, union parameter *param)
                        newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
                        newparam.bchannel.handle = param->bchannel.handle;
                        send_message(MESSAGE_BCHANNEL, 0, &newparam);
                        newparam.bchannel.type = BCHANNEL_REMOVE_ACK;
                        newparam.bchannel.handle = param->bchannel.handle;
                        send_message(MESSAGE_BCHANNEL, 0, &newparam);

-                       
+

                        break;
 
                        default:
                        break;
 
                        default:


@@ -1339,7 +1560,7 @@ int receive_message(int message_type, unsigned int ref, union parameter *param)
 
        /* handle new ref */
        if (message_type == MESSAGE_NEWREF) {
 
        /* 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)) {
                        /* 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)) {


@@ -1362,8 +1583,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 */
                        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 */
                                return 0;
                        }
                        /* store new ref */


@@ -1522,7 +1742,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) {
                /* 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();
                        error:
                        CERROR(NULL, NULL, "Handling of socket failed - closing for some seconds.\n");
                        close_socket();


@@ -1555,7 +1775,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) {
                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) {
                        goto error;
                }
                if (len > 0) {


@@ -1621,6 +1841,10 @@ void close_socket(void)
 {
        struct admin_list *admin, *temp;
 
 {
        struct admin_list *admin, *temp;
 

+       /* socket not created */
+       if (lcr_sock < 0)
+               return;
+

        unregister_fd(&socket_fd);
 
        /* flush pending messages */
        unregister_fd(&socket_fd);
 
        /* flush pending messages */


@@ -1633,8 +1857,7 @@ void close_socket(void)
        admin_first = NULL;
 
        /* close socket */
        admin_first = NULL;
 
        /* close socket */

-       if (lcr_sock >= 0)      
-               close(lcr_sock);
+       close(lcr_sock);

        lcr_sock = -1;
        global_change = 1;
 }
        lcr_sock = -1;
        global_change = 1;
 }


@@ -1659,12 +1882,18 @@ static void handle_queue()
        struct ast_frame fr;
        char *p;
 
        struct ast_frame fr;
        char *p;
 

+again:

        call = call_first;
        while(call) {
                p = call->queue_string;
                ast = call->ast;
                if (*p && ast) {
        call = call_first;
        while(call) {
                p = call->queue_string;
                ast = call->ast;
                if (*p && ast) {

-                       ast_channel_lock(ast);
+                       if (ast_channel_trylock(ast)) {
+                               ast_mutex_unlock(&chan_lock);
+                               usleep(1);
+                               ast_mutex_lock(&chan_lock);
+                               goto again;
+                       }

                        while(*p) {
                                switch (*p) {
                                case 'T':
                        while(*p) {
                                switch (*p) {
                                case 'T':


@@ -1695,7 +1924,7 @@ static void handle_queue()
                                        CDEBUG(call, ast, "Sending queued digit '%c' to Asterisk.\n", *p);
                                        /* send digit to asterisk */
                                        memset(&fr, 0, sizeof(fr));
                                        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_ASTERISK
                                        fr.frametype = AST_FRAME_DTMF_BEGIN;
                                        #endif


@@ -1703,16 +1932,20 @@ static void handle_queue()
                                        #ifdef LCR_FOR_CALLWEAVER
                                        fr.frametype = AST_FRAME_DTMF;
                                        #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;
                                        fr.subclass = *p;

+#endif

                                        fr.delivery = ast_tv(0, 0);
                                        ast_queue_frame(ast, &fr);
                                        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
                                        #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);
                                        break;
                                default:
                                        CDEBUG(call, ast, "Ignoring queued digit 0x%02x.\n", *p);


@@ -1766,23 +1999,11 @@ static void *chan_thread(void *arg)
 
        ast_mutex_lock(&chan_lock);
 
 
        ast_mutex_lock(&chan_lock);
 

-       while(!quit) {
+       while(1) {

                handle_queue();
                select_main(0, &global_change, lock_chan, unlock_chan);
        }
 
                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;
 }
 
        return NULL;
 }
 


@@ -1790,11 +2011,19 @@ static void *chan_thread(void *arg)
  * new asterisk instance
  */
 static
  * 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, const struct ast_channel *requestor, void *data, int *cause)
+#endif
+#else

 struct ast_channel *lcr_request(const char *type, int format, void *data, int *cause)
 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;
 {
        char exten[256], *dial, *interface, *opt;
        struct ast_channel *ast;

-        struct chan_call *call;
+       struct chan_call *call;

 
        ast_mutex_lock(&chan_lock);
        CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);
 
        ast_mutex_lock(&chan_lock);
        CDEBUG(NULL, NULL, "Received request from Asterisk. (data=%s)\n", (char *)data);


@@ -1817,13 +2046,17 @@ struct ast_channel *lcr_request(const char *type, int format, void *data, int *c
        /* create asterisk channel instrance */
 
        #ifdef LCR_FOR_ASTERISK
        /* create asterisk channel instrance */
 
        #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);
        ast = ast_channel_alloc(1, AST_STATE_RESERVED, NULL, NULL, "", NULL, "", 0, "%s/%d", lcr_type, ++glob_channel);

+#endif

        #endif
        #endif

-       
+

        #ifdef LCR_FOR_CALLWEAVER
        ast = ast_channel_alloc(1);
        #endif
        #ifdef LCR_FOR_CALLWEAVER
        ast = ast_channel_alloc(1);
        #endif

-               
+

        if (!ast) {
                CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
                free_call(call);
        if (!ast) {
                CERROR(NULL, NULL, "Failed to create Asterisk channel.\n");
                free_call(call);


@@ -1834,9 +2067,17 @@ struct ast_channel *lcr_request(const char *type, int format, void *data, int *c
        ast->tech = &lcr_tech;
        ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
        /* configure channel */
        ast->tech = &lcr_tech;
        ast->tech_pvt = (void *)1L; // set pointer or asterisk will not call
        /* 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;
        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_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);
+#endif

        ast->priority = 1;
        ast->hangupcause = 0;
 
        ast->priority = 1;
        ast->hangupcause = 0;
 


@@ -1873,6 +2114,227 @@ struct ast_channel *lcr_request(const char *type, int format, void *data, int *c
        strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
        apply_opt(call, (char *)opt);
 
        strncpy(call->dialstring, dial, sizeof(call->dialstring)-1);
        apply_opt(call, (char *)opt);
 

+#ifdef AST_1_8_OR_HIGHER
+//     clone_variables(requestor, ast);
+
+#if 0
+       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 (requestor->dialed.number.str)
+         if (requestor->dialed.number.str[0])
+               ast->dialed.number.str=                 strdup(requestor->dialed.number.str);
+       ast->dialed.number.plan=                        requestor->dialed.number.plan;
+
+       ast->dialed.subaddress.valid=                   requestor->dialed.subaddress.valid;
+       if (requestor->dialed.subaddress.valid)
+         if (requestor->dialed.subaddress.str)
+           if (requestor->dialed.subaddress.str[0])
+               ast->dialed.subaddress.str=             strdup(requestor->dialed.subaddress.str);
+       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;
+#endif
+       /* store call information for setup */
+
+       /* caller ID */
+       if (requestor && requestor->caller.id.number.valid) {
+               if (requestor->caller.id.number.str)
+                       strncpy(call->callerinfo.id, requestor->caller.id.number.str, sizeof(call->callerinfo.id)-1);
+               switch(requestor->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(requestor->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((requestor->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 && requestor->caller.ani.number.valid) {
+               if (requestor->caller.ani.number.str)
+                       strncpy(call->callerinfo.id2, requestor->caller.ani.number.str, sizeof(call->callerinfo.id2)-1);
+               switch(requestor->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(requestor->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((requestor->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 && requestor->caller.id.name.valid) {
+               if (requestor->caller.id.name.str)
+                       strncpy(call->callerinfo.name, requestor->caller.id.name.str, sizeof(call->callerinfo.name)-1);
+       }
+
+       /* redir number */
+       if (requestor && requestor->redirecting.from.number.valid) {
+               call->redirinfo.itype = INFO_ITYPE_CHAN;
+               if (requestor->redirecting.from.number.str)
+                       strncpy(call->redirinfo.id, requestor->redirecting.from.number.str, sizeof(call->redirinfo.id)-1);
+               switch(requestor->redirecting.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(requestor->redirecting.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((requestor->redirecting.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;
 }
        ast_mutex_unlock(&chan_lock);
        return ast;
 }


@@ -1883,16 +2345,16 @@ struct ast_channel *lcr_request(const char *type, int format, void *data, int *c
 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
 {
        union parameter newparam;
 static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
 {
        union parameter newparam;

-        struct chan_call *call;
+       struct chan_call *call;

 
        ast_mutex_lock(&chan_lock);
 
        ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
-        
-        #ifdef LCR_FOR_CALLWEAVER
-        ast->type = "LCR";
-        snprintf(ast->name, sizeof(ast->name), "LCR/%s-%04x",call->dialstring, ast_random() & 0xffff);
-        #endif
-        
+       call = ast->tech_pvt;
+
+       #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");
                ast_mutex_unlock(&chan_lock);
        if (!call) {
                CERROR(NULL, ast, "Received call from Asterisk, but call instance does not exist.\n");
                ast_mutex_unlock(&chan_lock);


@@ -1905,7 +2367,9 @@ 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));
        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 */
        send_message(MESSAGE_NEWREF, 0, &newparam);
 
        /* set hdlc if capability requires hdlc */


@@ -1920,6 +2384,7 @@ static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
         && ast->transfercapability != INFO_BC_VIDEO)
                ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
 
         && ast->transfercapability != INFO_BC_VIDEO)
                ast->transfercapability = INFO_BC_DATAUNRESTRICTED;
 

+#ifndef AST_1_8_OR_HIGHER

        call->cid_num[0] = 0;
        call->cid_name[0] = 0;
        call->cid_rdnis[0] = 0;
        call->cid_num[0] = 0;
        call->cid_name[0] = 0;
        call->cid_rdnis[0] = 0;


@@ -1927,51 +2392,53 @@ static int lcr_call(struct ast_channel *ast, char *dest, int timeout)
        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_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])
        if (ast->cid.cid_name) if (ast->cid.cid_name[0])

-               strncpy(call->cid_name, ast->cid.cid_name, 
+               strncpy(call->cid_name, ast->cid.cid_name,

                        sizeof(call->cid_name)-1);
        if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])
                        sizeof(call->cid_name)-1);
        if (ast->cid.cid_rdnis) if (ast->cid.cid_rdnis[0])

-               strncpy(call->cid_rdnis, ast->cid.cid_rdnis, 
+               strncpy(call->cid_rdnis, ast->cid.cid_rdnis,

                        sizeof(call->cid_rdnis)-1);
                        sizeof(call->cid_rdnis)-1);

+#endif

 
        ast_mutex_unlock(&chan_lock);
 
        ast_mutex_unlock(&chan_lock);

-       return 0; 
+       return 0;

 }
 
 static void send_digit_to_chan(struct ast_channel * ast, char digit )
 {
 }
 
 static void send_digit_to_chan(struct ast_channel * ast, char digit )
 {

-        static const char* dtmf_tones[] = {
-                "!941+1336/100,!0/100", /* 0 */
-                "!697+1209/100,!0/100", /* 1 */
-                "!697+1336/100,!0/100", /* 2 */
-                "!697+1477/100,!0/100", /* 3 */
-                "!770+1209/100,!0/100", /* 4 */
-                "!770+1336/100,!0/100", /* 5 */
-                "!770+1477/100,!0/100", /* 6 */
-                "!852+1209/100,!0/100", /* 7 */
-                "!852+1336/100,!0/100", /* 8 */
-                "!852+1477/100,!0/100", /* 9 */
-                "!697+1633/100,!0/100", /* A */
-                "!770+1633/100,!0/100", /* B */
-                "!852+1633/100,!0/100", /* C */
-                "!941+1633/100,!0/100", /* D */
-                "!941+1209/100,!0/100", /* * */
-                "!941+1477/100,!0/100" };       /* # */
-
-        if (digit >= '0' && digit <='9')
-                ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
-        else if (digit >= 'A' && digit <= 'D')
-                ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
-        else if (digit == '*')
-                ast_playtones_start(ast,0,dtmf_tones[14], 0);
-        else if (digit == '#')
-                ast_playtones_start(ast,0,dtmf_tones[15], 0);
-        else {
-                /* not handled */
-                ast_log(LOG_DEBUG, "Unable to handle DTMF tone "
-                       "'%c' for '%s'\n", digit, ast->name);
-        }
+       static const char* dtmf_tones[] = {
+               "!941+1336/100,!0/100", /* 0 */
+               "!697+1209/100,!0/100", /* 1 */
+               "!697+1336/100,!0/100", /* 2 */
+               "!697+1477/100,!0/100", /* 3 */
+               "!770+1209/100,!0/100", /* 4 */
+               "!770+1336/100,!0/100", /* 5 */
+               "!770+1477/100,!0/100", /* 6 */
+               "!852+1209/100,!0/100", /* 7 */
+               "!852+1336/100,!0/100", /* 8 */
+               "!852+1477/100,!0/100", /* 9 */
+               "!697+1633/100,!0/100", /* A */
+               "!770+1633/100,!0/100", /* B */
+               "!852+1633/100,!0/100", /* C */
+               "!941+1633/100,!0/100", /* D */
+               "!941+1209/100,!0/100", /* * */
+               "!941+1477/100,!0/100" };       /* # */
+
+       if (digit >= '0' && digit <='9')
+               ast_playtones_start(ast,0,dtmf_tones[digit-'0'], 0);
+       else if (digit >= 'A' && digit <= 'D')
+               ast_playtones_start(ast,0,dtmf_tones[digit-'A'+10], 0);
+       else if (digit == '*')
+               ast_playtones_start(ast,0,dtmf_tones[14], 0);
+       else if (digit == '#')
+               ast_playtones_start(ast,0,dtmf_tones[15], 0);
+       else {
+#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
 }
 
 #ifdef LCR_FOR_ASTERISK


@@ -1981,7 +2448,7 @@ static int lcr_digit_begin(struct ast_channel *ast, char digit)
 static int lcr_digit(struct ast_channel *ast, char digit)
 #endif
 {
 static int lcr_digit(struct ast_channel *ast, char digit)
 #endif
 {

-        struct chan_call *call;
+       struct chan_call *call;

        union parameter newparam;
        char buf[]="x";
 
        union parameter newparam;
        char buf[]="x";
 


@@ -1994,7 +2461,7 @@ static int lcr_digit(struct ast_channel *ast, char digit)
                return 0;
 
        ast_mutex_lock(&chan_lock);
                return 0;
 
        ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
+       call = ast->tech_pvt;

        if (!call) {
                CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
                ast_mutex_unlock(&chan_lock);
        if (!call) {
                CERROR(NULL, ast, "Received digit from Asterisk, but no call instance exists.\n");
                ast_mutex_unlock(&chan_lock);


@@ -2032,17 +2499,17 @@ static int lcr_digit(struct ast_channel *ast, char digit)
 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
 {
        int inband_dtmf = 0;
 static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int duration)
 {
        int inband_dtmf = 0;

-        struct chan_call *call;
+       struct chan_call *call;

 #endif
 
        ast_mutex_lock(&chan_lock);
 
 #endif
 
        ast_mutex_lock(&chan_lock);
 

-        call = ast->tech_pvt;
+       call = ast->tech_pvt;

 
        if (!call) {
 
        if (!call) {

-               CERROR(NULL, ast, 
-                      "Received digit from Asterisk, "
-                      "but no call instance exists.\n");
+               CERROR(NULL, ast,
+                       "Received digit from Asterisk, "
+                       "but no call instance exists.\n");

                ast_mutex_unlock(&chan_lock);
                return -1;
        }
                ast_mutex_unlock(&chan_lock);
                return -1;
        }


@@ -2066,18 +2533,18 @@ static int lcr_digit_end(struct ast_channel *ast, char digit, unsigned int durat
 static int lcr_answer(struct ast_channel *ast)
 {
        union parameter newparam;
 static int lcr_answer(struct ast_channel *ast)
 {
        union parameter newparam;

-        struct chan_call *call;
+       struct chan_call *call;

 
        ast_mutex_lock(&chan_lock);
 
        ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
+       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;
        }
        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 (maybe during lcr_bridge).\n");
        CDEBUG(call, ast, "Received answer from Asterisk (maybe during lcr_bridge).\n");

-               
+

        /* copy connectinfo, if bridged */
        if (call->bridge_call)
                memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));
        /* copy connectinfo, if bridged */
        if (call->bridge_call)
                memcpy(&call->connectinfo, &call->bridge_call->connectinfo, sizeof(struct connect_info));


@@ -2099,23 +2566,25 @@ static int lcr_answer(struct ast_channel *ast)
        /* enable keypad */
 //     memset(&newparam, 0, sizeof(union parameter));
 //     send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);
        /* enable keypad */
 //     memset(&newparam, 0, sizeof(union parameter));
 //     send_message(MESSAGE_ENABLEKEYPAD, call->ref, &newparam);

-       
-       ast_mutex_unlock(&chan_lock);
-        return 0;
+
+       ast_mutex_unlock(&chan_lock);
+       return 0;

 }
 
 static int lcr_hangup(struct ast_channel *ast)
 {
 }
 
 static int lcr_hangup(struct ast_channel *ast)
 {

-        struct chan_call *call;
+       struct chan_call *call;

        pthread_t tid = pthread_self();
 
        pthread_t tid = pthread_self();
 

-       if (!pthread_equal(tid, chan_tid))
+       if (!pthread_equal(tid, chan_tid)) {

                ast_mutex_lock(&chan_lock);
                ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
+       }
+       call = ast->tech_pvt;

        if (!call) {
                CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");
        if (!call) {
                CERROR(NULL, ast, "Received hangup from Asterisk, but no call instance exists.\n");

-               if (!pthread_equal(tid, chan_tid))
+               if (!pthread_equal(tid, chan_tid)) {

                        ast_mutex_unlock(&chan_lock);
                        ast_mutex_unlock(&chan_lock);

+               }

                return -1;
        }
 
                return -1;
        }
 


@@ -2136,8 +2605,9 @@ static int lcr_hangup(struct ast_channel *ast)
                        send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
                /* remove call */
                free_call(call);
                        send_release_and_import(call, CAUSE_NORMAL, LOCATION_PRIVATE_LOCAL);
                /* remove call */
                free_call(call);

-               if (!pthread_equal(tid, chan_tid))
+               if (!pthread_equal(tid, chan_tid)) {

                        ast_mutex_unlock(&chan_lock);
                        ast_mutex_unlock(&chan_lock);

+               }

                return 0;
        } else {
                /* ref is not set, due to prepare setup or release */
                return 0;
        } else {
                /* ref is not set, due to prepare setup or release */


@@ -2151,41 +2621,78 @@ static int lcr_hangup(struct ast_channel *ast)
                        call->state = CHAN_LCR_STATE_RELEASE;
                        call->ast = NULL;
                }
                        call->state = CHAN_LCR_STATE_RELEASE;
                        call->ast = NULL;
                }

-       } 
-       if (!pthread_equal(tid, chan_tid))
+       }
+       if (!pthread_equal(tid, chan_tid)) {

                ast_mutex_unlock(&chan_lock);
                ast_mutex_unlock(&chan_lock);

+       }

        return 0;
 }
 
        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 chan_call *call;
+       struct ast_frame * f = fr;

 
 

+#if ASTERISK_VERSION_NUM < 100000
+#ifdef AST_1_8_OR_HIGHER
+       if (!f->subclass.codec)
+#else

        if (!f->subclass)
        if (!f->subclass)

+#endif

                CDEBUG(NULL, ast, "No subclass\n");
                CDEBUG(NULL, ast, "No subclass\n");

-       if (!(f->subclass & ast->nativeformats))
-               CDEBUG(NULL, ast, "Unexpected format.\n");
-       
+#endif
+#ifdef AST_1_8_OR_HIGHER
+#if ASTERISK_VERSION_NUM < 100000
+       if (!(f->subclass.codec & ast->nativeformats)) {
+#else
+       if (!ast_format_cap_iscompatible(ast->nativeformats, &f->subclass.format)) {
+#endif
+#else
+       if (!(f->subclass & ast->nativeformats)) {
+#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
+               f = (ast->writetrans) ? ast_translate(
+                       ast->writetrans, fr, 0) : fr;
+       }
+

        ast_mutex_lock(&chan_lock);
        ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
+       call = ast->tech_pvt;

        if (!call) {
                ast_mutex_unlock(&chan_lock);
        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);
                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;
 }
 
 
 static struct ast_frame *lcr_read(struct ast_channel *ast)
 {
        return 0;
 }
 
 
 static struct ast_frame *lcr_read(struct ast_channel *ast)
 {

-        struct chan_call *call;
-       int len;
+       struct chan_call *call;
+       int len = 0;

 
        ast_mutex_lock(&chan_lock);
 
        ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
+       call = ast->tech_pvt;

        if (!call) {
                ast_mutex_unlock(&chan_lock);
                return NULL;
        if (!call) {
                ast_mutex_unlock(&chan_lock);
                return NULL;


@@ -2206,11 +2713,11 @@ static struct ast_frame *lcr_read(struct ast_channel *ast)
                        #ifdef LCR_FOR_ASTERISK
                        return &ast_null_frame;
                        #endif
                        #ifdef LCR_FOR_ASTERISK
                        return &ast_null_frame;
                        #endif

-                       
+

                        #ifdef LCR_FOR_CALLWEAVER
                        return &nullframe;
                        #endif
                        #ifdef LCR_FOR_CALLWEAVER
                        return &nullframe;
                        #endif

-                       
+

                }
                if (len <= 0) {
                        close(call->pipe[0]);
                }
                if (len <= 0) {
                        close(call->pipe[0]);


@@ -2226,7 +2733,16 @@ static struct ast_frame *lcr_read(struct ast_channel *ast)
        }
 
        call->read_fr.frametype = AST_FRAME_VOICE;
        }
 
        call->read_fr.frametype = AST_FRAME_VOICE;

+#ifdef AST_1_8_OR_HIGHER
+#if ASTERISK_VERSION_NUM < 100000
+       call->read_fr.subclass.codec = ast->nativeformats;
+#else
+       ast_best_codec(ast->nativeformats, &call->read_fr.subclass.format);
+       call->read_fr.subclass.integer = call->read_fr.subclass.format.id;
+#endif
+#else

        call->read_fr.subclass = ast->nativeformats;
        call->read_fr.subclass = ast->nativeformats;

+#endif

        if (call->rebuffer) {
                call->read_fr.datalen = call->framepos;
                call->read_fr.samples = call->framepos;
        if (call->rebuffer) {
                call->read_fr.datalen = call->framepos;
                call->read_fr.samples = call->framepos;


@@ -2245,19 +2761,20 @@ static struct ast_frame *lcr_read(struct ast_channel *ast)
 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
 {
        union parameter newparam;
 static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, size_t datalen)
 {
        union parameter newparam;

-        int res = 0;
-        struct chan_call *call;
+       int res = 0;
+       struct chan_call *call;
+       const struct tone_zone_sound *ts = NULL;

 
        ast_mutex_lock(&chan_lock);
 
        ast_mutex_lock(&chan_lock);

-        call = ast->tech_pvt;
+       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;
        }
 
        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:
+       switch (cond) {
+               case AST_CONTROL_BUSY:

                        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) {
                        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) {


@@ -2268,9 +2785,12 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
                                send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
                                /* change state */
                                call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
                                send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
                                /* change state */
                                call->state = CHAN_LCR_STATE_OUT_DISCONNECT;

+                       } else {
+                               CDEBUG(call, ast, "Using Asterisk 'busy' indication\n");
+                               ts = ast_get_indication_tone(ast->zone, "busy");

                        }
                        break;
                        }
                        break;

-                case AST_CONTROL_CONGESTION:
+               case AST_CONTROL_CONGESTION:

                        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 */
                        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 */


@@ -2280,9 +2800,12 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
                                send_message(MESSAGE_DISCONNECT, call->ref, &newparam);
                                /* change state */
                                call->state = CHAN_LCR_STATE_OUT_DISCONNECT;
                                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");
+                               ts = ast_get_indication_tone(ast->zone, "congestion");

                        }
                        break;
                        }
                        break;

-                case AST_CONTROL_PROCEEDING:
+               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) {
                        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) {


@@ -2293,7 +2816,7 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
                                call->state = CHAN_LCR_STATE_IN_PROCEEDING;
                        }
                        break;
                                call->state = CHAN_LCR_STATE_IN_PROCEEDING;
                        }
                        break;

-                case AST_CONTROL_RINGING:
+               case AST_CONTROL_RINGING:

                        CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
                        ast_setstate(ast, AST_STATE_RING);
                        if (call->state == CHAN_LCR_STATE_IN_SETUP
                        CDEBUG(call, ast, "Received indicate AST_CONTROL_RINGING from Asterisk.\n");
                        ast_setstate(ast, AST_STATE_RING);
                        if (call->state == CHAN_LCR_STATE_IN_SETUP


@@ -2304,6 +2827,9 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
                                send_message(MESSAGE_ALERTING, call->ref, &newparam);
                                /* change state */
                                call->state = CHAN_LCR_STATE_IN_ALERTING;
                                send_message(MESSAGE_ALERTING, call->ref, &newparam);
                                /* change state */
                                call->state = CHAN_LCR_STATE_IN_ALERTING;

+                       } else {
+                               CDEBUG(call, ast, "Using Asterisk 'ring' indication\n");
+                               ts = ast_get_indication_tone(ast->zone, "ring");

                        }
                        break;
                case AST_CONTROL_PROGRESS:
                        }
                        break;
                case AST_CONTROL_PROGRESS:


@@ -2316,34 +2842,39 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
                                send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
                        }
                        break;
                                send_message(MESSAGE_BCHANNEL, call->ref, &newparam);
                        }
                        break;

-                case -1:
+               case -1:

                        CDEBUG(call, ast, "Received indicate -1.\n");
                        CDEBUG(call, ast, "Received indicate -1.\n");

-                        res = -1;
+                       ast_playtones_stop(ast);
+                       res = -1;

                        break;
 
                        break;
 

-                case AST_CONTROL_VIDUPDATE:
+               case AST_CONTROL_VIDUPDATE:

                        CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");
                        CDEBUG(call, ast, "Received indicate AST_CONTROL_VIDUPDATE.\n");

-                        res = -1;
-                        break;
-                case AST_CONTROL_HOLD:
+                       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);
                        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*/
                        #ifdef LCR_FOR_ASTERISK
                        /*start music onhold*/
                        #ifdef LCR_FOR_ASTERISK

+                       #if ASTERISK_VERSION_NUM <110000

                        ast_moh_start(ast,data,ast->musicclass);
                        ast_moh_start(ast,data,ast->musicclass);

+                       #else
+                       ast_moh_start(ast,data,ast_channel_musicclass(ast));

                        #endif
                        #endif

-                       
+                       #endif
+

                        #ifdef LCR_FOR_CALLWEAVER
                        ast_moh_start(ast, NULL);
                        #endif
                        #ifdef LCR_FOR_CALLWEAVER
                        ast_moh_start(ast, NULL);
                        #endif

-                       
+

                        call->on_hold = 1;
                        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));
                        CDEBUG(call, ast, "Received indicate AST_CONTROL_UNHOLD from Asterisk.\n");
                        /* send message to lcr */
                        memset(&newparam, 0, sizeof(union parameter));


@@ -2351,25 +2882,29 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
                        send_message(MESSAGE_NOTIFY, call->ref, &newparam);
 
                        /*stop moh*/
                        send_message(MESSAGE_NOTIFY, call->ref, &newparam);
 
                        /*stop moh*/

-                       ast_moh_stop(ast);
+                       ast_moh_stop(ast);

                        call->on_hold = 0;
                        call->on_hold = 0;

-                       break;
+                       break;

 #ifdef AST_CONTROL_SRCUPDATE
 #ifdef AST_CONTROL_SRCUPDATE

-               case AST_CONTROL_SRCUPDATE:
+               case AST_CONTROL_SRCUPDATE:

 #else
 #else

-               case 20:
+               case 20:

 #endif
                        CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");
 #endif
                        CDEBUG(call, ast, "Received AST_CONTROL_SRCUPDATE from Asterisk.\n");

-                        break;
-                default:
+                       break;
+               default:

                        CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);
                        CERROR(call, ast, "Received indicate from Asterisk with unknown condition %d.\n", cond);

-                        res = -1;
+                       res = -1;

                        break;
                        break;

-        }
+       }
+
+       if (ts && ts->data[0]) {
+               ast_playtones_start(ast, 0, ts->data, 1);
+       }

 
        /* return */
        ast_mutex_unlock(&chan_lock);
 
        /* return */
        ast_mutex_unlock(&chan_lock);

-        return res;
+       return res;

 }
 
 /*
 }
 
 /*


@@ -2377,7 +2912,7 @@ static int lcr_indicate(struct ast_channel *ast, int cond, const void *data, siz
  */
 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
 {
  */
 static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
 {

-        struct chan_call *call;
+       struct chan_call *call;

 
        if (!ast) {
                return -1;
 
        if (!ast) {
                return -1;


@@ -2402,7 +2937,7 @@ static int lcr_fixup(struct ast_channel *oldast, struct ast_channel *ast)
  */
 static int lcr_send_text(struct ast_channel *ast, const char *text)
 {
  */
 static int lcr_send_text(struct ast_channel *ast, const char *text)
 {

-        struct chan_call *call;
+       struct chan_call *call;

        union parameter newparam;
 
        ast_mutex_lock(&chan_lock);
        union parameter newparam;
 
        ast_mutex_lock(&chan_lock);


@@ -2417,7 +2952,7 @@ static int lcr_send_text(struct ast_channel *ast, const char *text)
        memset(&newparam, 0, sizeof(union parameter));
        strncpy(newparam.notifyinfo.display, text, sizeof(newparam.notifyinfo.display)-1);
        send_message(MESSAGE_NOTIFY, call->ref, &newparam);
        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);
+       ast_mutex_unlock(&chan_lock);

        return 0;
 }
 
        return 0;
 }
 


@@ -2451,15 +2986,15 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
                return AST_BRIDGE_COMPLETE;
        }
 
                return AST_BRIDGE_COMPLETE;
        }
 

-       /* join, if both call instances uses dsp 
+       /* join, if both call instances uses dsp

           ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.
           ignore the case of fax detection here it may be benificial for ISDN fax machines or pass through.

-       */
+       */

        if (!call1->nodsp && !call2->nodsp) {
                CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
 
                /* get bridge id and join */
                bridge_id = new_bridge_id();
        if (!call1->nodsp && !call2->nodsp) {
                CDEBUG(NULL, NULL, "Both calls use DSP, bridging via DSP.\n");
 
                /* get bridge id and join */
                bridge_id = new_bridge_id();

-               
+

                call1->bridge_id = bridge_id;
                if (call1->bchannel)
                        bchannel_join(call1->bchannel, bridge_id);
                call1->bridge_id = bridge_id;
                if (call1->bchannel)
                        bchannel_join(call1->bchannel, bridge_id);


@@ -2513,9 +3048,9 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
 
                call2->on_hold = 0;
        }
 
                call2->on_hold = 0;
        }

-       
+

        ast_mutex_unlock(&chan_lock);
        ast_mutex_unlock(&chan_lock);

-       
+

        while(1) {
                to = -1;
                who = ast_waitfor_n(carr, 2, &to);
        while(1) {
                to = -1;
                who = ast_waitfor_n(carr, 2, &to);


@@ -2525,7 +3060,7 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
                        break;
                }
                f = ast_read(who);
                        break;
                }
                f = ast_read(who);

-    
+

                if (!f || f->frametype == AST_FRAME_CONTROL) {
                        if (!f)
                                CDEBUG(NULL, NULL, "Got hangup.\n");
                if (!f || f->frametype == AST_FRAME_CONTROL) {
                        if (!f)
                                CDEBUG(NULL, NULL, "Got hangup.\n");


@@ -2536,14 +3071,14 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
                        *rc=who;
                        break;
                }
                        *rc=who;
                        break;
                }

-               
+

                if ( f->frametype == AST_FRAME_DTMF ) {
                        CDEBUG(NULL, NULL, "Got DTMF.\n");
                        *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);
 
                if (who == ast1) {
                        ast_write(ast2,f);


@@ -2551,9 +3086,9 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
                else {
                        ast_write(ast1,f);
                }
                else {
                        ast_write(ast1,f);
                }

-    
+

        }
        }

-       
+

        CDEBUG(NULL, NULL, "Releasing bridge.\n");
 
        /* split channels */
        CDEBUG(NULL, NULL, "Releasing bridge.\n");
 
        /* split channels */


@@ -2581,9 +3116,11 @@ enum ast_bridge_result lcr_bridge(struct ast_channel *ast1,
        return AST_BRIDGE_COMPLETE;
 }
 static struct ast_channel_tech lcr_tech = {
        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",
        .description = "Channel driver for connecting to Linux-Call-Router",

+       #if ASTERISK_VERSION_NUM < 100000

        .capabilities = AST_FORMAT_ALAW,
        .capabilities = AST_FORMAT_ALAW,

+       #endif

        .requester = lcr_request,
 
        #ifdef LCR_FOR_ASTERISK
        .requester = lcr_request,
 
        #ifdef LCR_FOR_ASTERISK


@@ -2596,7 +3133,7 @@ static struct ast_channel_tech lcr_tech = {
        #endif
 
        .call = lcr_call,
        #endif
 
        .call = lcr_call,

-       .bridge = lcr_bridge, 
+       .bridge = lcr_bridge,

        .hangup = lcr_hangup,
        .answer = lcr_answer,
        .read = lcr_read,
        .hangup = lcr_hangup,
        .answer = lcr_answer,
        .read = lcr_read,


@@ -2699,8 +3236,12 @@ static struct ast_cli_entry cli_port_unload =
 
 
 #ifdef LCR_FOR_ASTERISK
 
 
 #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
 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)
 
 #ifdef LCR_FOR_CALLWEAVER
 static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)


@@ -2713,11 +3254,11 @@ static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
        #ifdef LCR_FOR_ASTERISK
        CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", (char *)data);
        #endif
        #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
        #ifdef LCR_FOR_CALLWEAVER
        CDEBUG(NULL, ast, "Received lcr_config (data=%s)\n", argv[0]);
        #endif

-       
+

        /* find channel */
        call = call_first;
        while(call) {
        /* find channel */
        call = call_first;
        while(call) {


@@ -2726,12 +3267,12 @@ static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
                call = call->next;
        }
        if (call)
                call = call->next;
        }
        if (call)

-               
+

                #ifdef LCR_FOR_ASTERISK
                apply_opt(call, (char *)data);
                #ifdef LCR_FOR_ASTERISK
                apply_opt(call, (char *)data);

-               #endif          
-               
-               #ifdef LCR_FOR_CALLWEAVER               
+               #endif
+
+               #ifdef LCR_FOR_CALLWEAVER

                apply_opt(call, (char *)argv[0]);
                #endif
 
                apply_opt(call, (char *)argv[0]);
                #endif
 


@@ -2748,23 +3289,24 @@ static int lcr_config_exec(struct ast_channel *ast, void *data, char **argv)
 int load_module(void)
 {
        u_short i;
 int load_module(void)
 {
        u_short i;

+       char options_error[256];

 
        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);
        }
 
 
        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);
        }
 

-       if (read_options() == 0) {
+       if (read_options(options_error) == 0) {

                CERROR(NULL, NULL, "%s", options_error);
 
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;
                CERROR(NULL, NULL, "%s", options_error);
 
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;

-               #endif          
-               
+               #endif
+

                #ifdef LCR_FOR_CALLWEAVER
                return 0;
                #endif
                #ifdef LCR_FOR_CALLWEAVER
                return 0;
                #endif

-                       
+

        }
 
        ast_mutex_init(&chan_lock);
        }
 
        ast_mutex_init(&chan_lock);


@@ -2773,18 +3315,27 @@ int load_module(void)
        if (bchannel_initialize()) {
                CERROR(NULL, NULL, "Unable to open mISDN device\n");
                close_socket();
        if (bchannel_initialize()) {
                CERROR(NULL, NULL, "Unable to open mISDN device\n");
                close_socket();

-               
+

                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;

-               #endif          
-               
+               #endif
+

                #ifdef LCR_FOR_CALLWEAVER
                return 0;
                #endif
        }
        mISDN_created = 1;
 
                #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;
        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();
        if (ast_channel_register(&lcr_tech)) {
                CERROR(NULL, NULL, "Unable to register channel class\n");
                bchannel_deinitialize();


@@ -2792,29 +3343,29 @@ int load_module(void)
 
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;
 
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;

-               #endif          
-               
+               #endif
+

                #ifdef LCR_FOR_CALLWEAVER
                return 0;
                #endif
        }
 
        ast_register_application("lcr_config", lcr_config_exec, "lcr_config",
                #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_ASTERISK
                                 "lcr_config(<opt><optarg>:<opt>:...)\n"
                                 #endif

-                                
+

                                 #ifdef LCR_FOR_CALLWEAVER
                                 #ifdef LCR_FOR_CALLWEAVER

-                                "lcr_config(<opt><optarg>:<opt>:...)\n",                                
+                                "lcr_config(<opt><optarg>:<opt>:...)\n",

                                 #endif
                                 #endif

-                                                        
+

                                 "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"
                                 "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" 
+                                "    h - Force data call (HDLC).\n"

                                 "    t - Disable mISDN_dsp features (required for fax application).\n"
                                 "    q - Add queue to make fax stream seamless (required for fax app).\n"
                                 "        Use queue size in miliseconds for optarg. (try 250)\n"
                                 "    t - Disable mISDN_dsp features (required for fax application).\n"
                                 "    q - Add queue to make fax stream seamless (required for fax app).\n"
                                 "        Use queue size in miliseconds for optarg. (try 250)\n"


@@ -2837,8 +3388,8 @@ int load_module(void)
                                 "options: \"n:t:q250\" for seamless audio transmission.\n"
                );
 
                                 "options: \"n:t:q250\" for seamless audio transmission.\n"
                );
 

- 
-#if 0  
+
+#if 0

        ast_cli_register(&cli_show_lcr);
        ast_cli_register(&cli_show_calls);
        ast_cli_register(&cli_reload_routing);
        ast_cli_register(&cli_show_lcr);
        ast_cli_register(&cli_show_calls);
        ast_cli_register(&cli_reload_routing);


@@ -2848,7 +3399,6 @@ int load_module(void)
        ast_cli_register(&cli_port_unload);
 #endif
 
        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();
        if ((pthread_create(&chan_tid, NULL, chan_thread, NULL)<0)) {
                /* failed to create thread */
                bchannel_deinitialize();


@@ -2857,12 +3407,12 @@ int load_module(void)
 
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;
 
                #ifdef LCR_FOR_ASTERISK
                return AST_MODULE_LOAD_DECLINE;

-               #endif          
-               
+               #endif
+

                #ifdef LCR_FOR_CALLWEAVER
                return 0;
                #endif
                #ifdef LCR_FOR_CALLWEAVER
                return 0;
                #endif

-               
+

        }
        return 0;
 }
        }
        return 0;
 }


@@ -2870,15 +3420,23 @@ int load_module(void)
 int unload_module(void)
 {
        /* First, take us out of the channel loop */
 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");

 
 

-       quit = 1;
-       pthread_join(chan_tid, NULL);   
-       
-       ast_channel_unregister(&lcr_tech);
+       pthread_cancel(chan_tid);

 
 

-        ast_unregister_application("lcr_config");
+       close_socket();

 
 

+       del_timer(&socket_retry);
+
+       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();
 
        if (mISDN_created) {
                bchannel_deinitialize();


@@ -2890,6 +3448,9 @@ int unload_module(void)
                lcr_sock = -1;
        }
 
                lcr_sock = -1;
        }
 

+#if ASTERISK_VERSION_NUM >= 100000
+       lcr_tech.capabilities = ast_format_cap_destroy(lcr_tech.capabilities);
+#endif

        return 0;
 }
 
        return 0;
 }