kenmirrors/freeswitch
1
0
Fork 0
mirror of https://github.com/signalwire/freeswitch.git synced 2025-05-18 13:41:20 +00:00
Code Issues Projects Releases Wiki Activity

skypopen: indented

Browse Source
This commit is contained in:
Giovanni Maruzzelli 2010-10-28 04:21:52 -05:00
parent bc067ebc69
commit 38215f9d5c
2 changed files with 82 additions and 80 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

53
src/mod/endpoints/mod_skypopen/mod_skypopen.c
View File

@ -447,9 +447,9 @@ static switch_status_t channel_on_init(switch_core_session_t *session)
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
switch_assert(channel != NULL); switch_assert(channel != NULL);
switch_channel_set_variable(channel, "skype_user", tech_pvt->skype_user); switch_channel_set_variable(channel, "skype_user", tech_pvt->skype_user);
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_set_flag(tech_pvt, TFLAG_IO); switch_set_flag(tech_pvt, TFLAG_IO);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
/* Move channel's state machine to ROUTING. This means the call is trying /* Move channel's state machine to ROUTING. This means the call is trying
to get from the initial start where the call because, to the point to get from the initial start where the call because, to the point
@ -484,21 +484,21 @@ static switch_status_t channel_on_destroy(switch_core_session_t *session)
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
DEBUGA_SKYPE("audio tcp threads to DIE\n", SKYPOPEN_P_LOG); DEBUGA_SKYPE("audio tcp threads to DIE\n", SKYPOPEN_P_LOG);
conta=0; conta = 0;
while(tech_pvt->tcp_srv_thread){ while (tech_pvt->tcp_srv_thread) {
switch_sleep(5000); switch_sleep(5000);
conta++; conta++;
if(conta==200){ if (conta == 200) {
ERRORA("tcp_srv_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG); ERRORA("tcp_srv_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG);
break; break;
} }
} }
DEBUGA_SKYPE("audio tcp srv thread DEAD %d\n", SKYPOPEN_P_LOG, conta); DEBUGA_SKYPE("audio tcp srv thread DEAD %d\n", SKYPOPEN_P_LOG, conta);
conta=0; conta = 0;
while(tech_pvt->tcp_cli_thread){ while (tech_pvt->tcp_cli_thread) {
switch_sleep(5000); switch_sleep(5000);
conta++; conta++;
if(conta==200){ if (conta == 200) {
ERRORA("tcp_cli_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG); ERRORA("tcp_cli_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG);
break; break;
} }
@ -618,7 +618,6 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session)
if (globals.calls < 0) { if (globals.calls < 0) {
globals.calls = 0; globals.calls = 0;
} }
//DEBUGA_SKYPE("debugging_hangup 9\n", SKYPOPEN_P_LOG); //DEBUGA_SKYPE("debugging_hangup 9\n", SKYPOPEN_P_LOG);
tech_pvt->interface_state = SKYPOPEN_STATE_DOWN; tech_pvt->interface_state = SKYPOPEN_STATE_DOWN;
if (tech_pvt->skype_callflow == CALLFLOW_STATUS_FINISHED) { if (tech_pvt->skype_callflow == CALLFLOW_STATUS_FINISHED) {
@ -869,15 +868,15 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
tech_pvt->read_frame.datalen = 640; tech_pvt->read_frame.datalen = 640;
} }
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_set_flag(tech_pvt, TFLAG_VOICE); switch_set_flag(tech_pvt, TFLAG_VOICE);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
while (switch_test_flag(tech_pvt, TFLAG_IO)) { while (switch_test_flag(tech_pvt, TFLAG_IO)) {
if (switch_test_flag(tech_pvt, TFLAG_BREAK)) { if (switch_test_flag(tech_pvt, TFLAG_BREAK)) {
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_clear_flag(tech_pvt, TFLAG_BREAK); switch_clear_flag(tech_pvt, TFLAG_BREAK);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
DEBUGA_SKYPE("CHANNEL READ FRAME goto CNG\n", SKYPOPEN_P_LOG); DEBUGA_SKYPE("CHANNEL READ FRAME goto CNG\n", SKYPOPEN_P_LOG);
goto cng; goto cng;
} }
@ -888,9 +887,9 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch
} }
if (switch_test_flag(tech_pvt, TFLAG_IO) && switch_test_flag(tech_pvt, TFLAG_VOICE)) { if (switch_test_flag(tech_pvt, TFLAG_IO) && switch_test_flag(tech_pvt, TFLAG_VOICE)) {
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_clear_flag(tech_pvt, TFLAG_VOICE); switch_clear_flag(tech_pvt, TFLAG_VOICE);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
if (!tech_pvt->read_frame.datalen) { if (!tech_pvt->read_frame.datalen) {
DEBUGA_SKYPE("CHANNEL READ CONTINUE\n", SKYPOPEN_P_LOG); DEBUGA_SKYPE("CHANNEL READ CONTINUE\n", SKYPOPEN_P_LOG);
continue; continue;
@ -1024,9 +1023,9 @@ static switch_status_t channel_answer_channel(switch_core_session_t *session)
tech_pvt = switch_core_session_get_private(session); tech_pvt = switch_core_session_get_private(session);
switch_assert(tech_pvt != NULL); switch_assert(tech_pvt != NULL);
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_clear_flag(tech_pvt, TFLAG_IO); switch_clear_flag(tech_pvt, TFLAG_IO);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
skypopen_answer(tech_pvt); skypopen_answer(tech_pvt);
while (!switch_test_flag(tech_pvt, TFLAG_IO)) { while (!switch_test_flag(tech_pvt, TFLAG_IO)) {
@ -1069,9 +1068,9 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s
case SWITCH_MESSAGE_INDICATE_PROGRESS: case SWITCH_MESSAGE_INDICATE_PROGRESS:
{ {
DEBUGA_SKYPE("%s CHANNEL got SWITCH_MESSAGE_INDICATE_PROGRESS\n", SKYPOPEN_P_LOG, switch_channel_get_name(channel)); DEBUGA_SKYPE("%s CHANNEL got SWITCH_MESSAGE_INDICATE_PROGRESS\n", SKYPOPEN_P_LOG, switch_channel_get_name(channel));
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_set_flag(tech_pvt, TFLAG_PROGRESS); switch_set_flag(tech_pvt, TFLAG_PROGRESS);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
} }
break; break;
case SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS: case SWITCH_MESSAGE_INDICATE_CLEAR_PROGRESS:
@ -1406,21 +1405,21 @@ static void *SWITCH_THREAD_FUNC skypopen_signaling_thread_func(switch_thread_t *
tech_pvt->interface_state = SKYPOPEN_STATE_DOWN; tech_pvt->interface_state = SKYPOPEN_STATE_DOWN;
DEBUGA_SKYPE("audio tcp threads to DIE\n", SKYPOPEN_P_LOG); DEBUGA_SKYPE("audio tcp threads to DIE\n", SKYPOPEN_P_LOG);
conta=0; conta = 0;
while(tech_pvt->tcp_srv_thread){ while (tech_pvt->tcp_srv_thread) {
switch_sleep(5000); switch_sleep(5000);
conta++; conta++;
if(conta==200){ if (conta == 200) {
ERRORA("tcp_srv_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG); ERRORA("tcp_srv_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG);
break; break;
} }
} }
DEBUGA_SKYPE("audio tcp srv thread DEAD %d\n", SKYPOPEN_P_LOG, conta); DEBUGA_SKYPE("audio tcp srv thread DEAD %d\n", SKYPOPEN_P_LOG, conta);
conta=0; conta = 0;
while(tech_pvt->tcp_cli_thread){ while (tech_pvt->tcp_cli_thread) {
switch_sleep(5000); switch_sleep(5000);
conta++; conta++;
if(conta==200){ if (conta == 200) {
ERRORA("tcp_cli_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG); ERRORA("tcp_cli_thread is NOT dead, this can LEAK MEMORY\n", SKYPOPEN_P_LOG);
break; break;
} }
@ -3073,7 +3072,7 @@ struct SkypopenHandles *skypopen_list_remove_by_value(struct SkypopenList *list,
// CLOUDTREE (THomas Hazel) - is there a capable freeswitch list? // CLOUDTREE (THomas Hazel) - is there a capable freeswitch list?
struct SkypopenHandles *skypopen_list_remove_by_reference(struct SkypopenList *list, struct SkypopenHandles *handle) struct SkypopenHandles *skypopen_list_remove_by_reference(struct SkypopenList *list, struct SkypopenHandles *handle)
{ {
private_t *tech_pvt=NULL; private_t *tech_pvt = NULL;
switch_mutex_lock(globals.list_mutex); switch_mutex_lock(globals.list_mutex);
@ -3081,7 +3080,7 @@ struct SkypopenHandles *skypopen_list_remove_by_reference(struct SkypopenList *l
if (handle->managed == SWITCH_FALSE) { if (handle->managed == SWITCH_FALSE) {
// already removed // already removed
switch_mutex_unlock(globals.list_mutex); switch_mutex_unlock(globals.list_mutex);
DEBUGA_SKYPE("EXIT REMOVE\n", SKYPOPEN_P_LOG); DEBUGA_SKYPE("EXIT REMOVE\n", SKYPOPEN_P_LOG);
return 0; return 0;
} }

89
src/mod/endpoints/mod_skypopen/skypopen_protocol.c
View File

@ -227,27 +227,29 @@ int skypopen_signaling_read(private_t *tech_pvt)
} }
} else if (!strncasecmp(message, "ERROR 36 Not online", 18)) { } else if (!strncasecmp(message, "ERROR 36 Not online", 18)) {
char msg_to_skype[256]; char msg_to_skype[256];
ERRORA("Skype client is not online, eg: not connected to Skype network, probably got a temporary net outage: |||%s|||\n", SKYPOPEN_P_LOG, message); ERRORA("Skype client is not online, eg: not connected to Skype network, probably got a temporary net outage: |||%s|||\n",
if(strlen(tech_pvt->skype_call_id)){ SKYPOPEN_P_LOG, message);
sprintf(msg_to_skype, "ALTER CALL %s HANGUP", tech_pvt->skype_call_id); if (strlen(tech_pvt->skype_call_id)) {
skypopen_signaling_write(tech_pvt, msg_to_skype); sprintf(msg_to_skype, "ALTER CALL %s HANGUP", tech_pvt->skype_call_id);
skypopen_signaling_write(tech_pvt, msg_to_skype);
} }
if(strlen(tech_pvt->ring_id)){ if (strlen(tech_pvt->ring_id)) {
sprintf(msg_to_skype, "ALTER CALL %s END HANGUP", tech_pvt->ring_id); sprintf(msg_to_skype, "ALTER CALL %s END HANGUP", tech_pvt->ring_id);
skypopen_signaling_write(tech_pvt, msg_to_skype); skypopen_signaling_write(tech_pvt, msg_to_skype);
} }
tech_pvt->interface_state = SKYPOPEN_STATE_DOWN; tech_pvt->interface_state = SKYPOPEN_STATE_DOWN;
return CALLFLOW_INCOMING_HANGUP; return CALLFLOW_INCOMING_HANGUP;
} else if (!strncasecmp(message, "ERROR 589 ALTER CALL", 19)) { } else if (!strncasecmp(message, "ERROR 589 ALTER CALL", 19)) {
char msg_to_skype[256]; char msg_to_skype[256];
DEBUGA_SKYPE("Skype client was not able to correctly manage tcp audio sockets, probably got a local or remote hangup: |||%s|||\n", SKYPOPEN_P_LOG, message); DEBUGA_SKYPE("Skype client was not able to correctly manage tcp audio sockets, probably got a local or remote hangup: |||%s|||\n",
if(strlen(tech_pvt->skype_call_id)){ SKYPOPEN_P_LOG, message);
sprintf(msg_to_skype, "ALTER CALL %s HANGUP", tech_pvt->skype_call_id); if (strlen(tech_pvt->skype_call_id)) {
skypopen_signaling_write(tech_pvt, msg_to_skype); sprintf(msg_to_skype, "ALTER CALL %s HANGUP", tech_pvt->skype_call_id);
skypopen_signaling_write(tech_pvt, msg_to_skype);
} }
if(strlen(tech_pvt->ring_id)){ if (strlen(tech_pvt->ring_id)) {
sprintf(msg_to_skype, "ALTER CALL %s END HANGUP", tech_pvt->ring_id); sprintf(msg_to_skype, "ALTER CALL %s END HANGUP", tech_pvt->ring_id);
skypopen_signaling_write(tech_pvt, msg_to_skype); skypopen_signaling_write(tech_pvt, msg_to_skype);
} }
tech_pvt->interface_state = SKYPOPEN_STATE_DOWN; tech_pvt->interface_state = SKYPOPEN_STATE_DOWN;
return CALLFLOW_INCOMING_HANGUP; return CALLFLOW_INCOMING_HANGUP;
@ -497,7 +499,7 @@ int skypopen_signaling_read(private_t *tech_pvt)
//SKYPOPEN_P_LOG, message, obj, id, prop, value, where ? where : "NULL"); //SKYPOPEN_P_LOG, message, obj, id, prop, value, where ? where : "NULL");
if (!strcasecmp(prop, "PARTNER_HANDLE")) { if (!strcasecmp(prop, "PARTNER_HANDLE")) {
if (tech_pvt->interface_state == SKYPOPEN_STATE_IDLE){ if (tech_pvt->interface_state == SKYPOPEN_STATE_IDLE) {
/* we are NOT inside an active call */ /* we are NOT inside an active call */
DEBUGA_SKYPE("Call %s go to skypopen_partner_handle_ring\n", SKYPOPEN_P_LOG, id); DEBUGA_SKYPE("Call %s go to skypopen_partner_handle_ring\n", SKYPOPEN_P_LOG, id);
skypopen_strncpy(tech_pvt->ring_id, id, sizeof(tech_pvt->ring_id)); skypopen_strncpy(tech_pvt->ring_id, id, sizeof(tech_pvt->ring_id));
@ -579,7 +581,7 @@ int skypopen_signaling_read(private_t *tech_pvt)
if (!strcasecmp(value, "RINGING")) { if (!strcasecmp(value, "RINGING")) {
char msg_to_skype[1024]; char msg_to_skype[1024];
if (tech_pvt->interface_state == SKYPOPEN_STATE_IDLE){ if (tech_pvt->interface_state == SKYPOPEN_STATE_IDLE) {
// CLOUDTREE (Thomas Hazel) // CLOUDTREE (Thomas Hazel)
skypopen_strncpy(tech_pvt->skype_call_id, id, sizeof(tech_pvt->skype_call_id) - 1); skypopen_strncpy(tech_pvt->skype_call_id, id, sizeof(tech_pvt->skype_call_id) - 1);
@ -604,8 +606,9 @@ int skypopen_signaling_read(private_t *tech_pvt)
skypopen_strncpy(tech_pvt->skype_call_id, id, sizeof(tech_pvt->skype_call_id) - 1); skypopen_strncpy(tech_pvt->skype_call_id, id, sizeof(tech_pvt->skype_call_id) - 1);
DEBUGA_SKYPE("Our remote party in skype_call %s is RINGING\n", SKYPOPEN_P_LOG, id); DEBUGA_SKYPE("Our remote party in skype_call %s is RINGING\n", SKYPOPEN_P_LOG, id);
if (remote_party_is_ringing(tech_pvt) != SWITCH_STATUS_SUCCESS) { if (remote_party_is_ringing(tech_pvt) != SWITCH_STATUS_SUCCESS) {
DEBUGA_SKYPE("We are getting the RINGING from a call we probably canceled, trying to get out hanging up call id: %s.\n", DEBUGA_SKYPE
SKYPOPEN_P_LOG, id); ("We are getting the RINGING from a call we probably canceled, trying to get out hanging up call id: %s.\n",
SKYPOPEN_P_LOG, id);
sprintf(msg_to_skype, "ALTER CALL %s END HANGUP", id); sprintf(msg_to_skype, "ALTER CALL %s END HANGUP", id);
skypopen_signaling_write(tech_pvt, msg_to_skype); skypopen_signaling_write(tech_pvt, msg_to_skype);
sprintf(msg_to_skype, "ALTER CALL %s HANGUP", id); sprintf(msg_to_skype, "ALTER CALL %s HANGUP", id);
@ -735,7 +738,7 @@ int skypopen_signaling_read(private_t *tech_pvt)
skypopen_signaling_write(tech_pvt, msg_to_skype); skypopen_signaling_write(tech_pvt, msg_to_skype);
} }
tech_pvt->skype_callflow = CALLFLOW_STATUS_INPROGRESS; tech_pvt->skype_callflow = CALLFLOW_STATUS_INPROGRESS;
if(skypopen_answered(tech_pvt)!= SWITCH_STATUS_SUCCESS){ if (skypopen_answered(tech_pvt) != SWITCH_STATUS_SUCCESS) {
sprintf(msg_to_skype, "ALTER CALL %s HANGUP", id); sprintf(msg_to_skype, "ALTER CALL %s HANGUP", id);
skypopen_signaling_write(tech_pvt, msg_to_skype); skypopen_signaling_write(tech_pvt, msg_to_skype);
} }
@ -866,8 +869,8 @@ void *skypopen_do_tcp_srv_thread_func(void *obj)
if (!(running && tech_pvt->running)) if (!(running && tech_pvt->running))
break; break;
while (tech_pvt && tech_pvt->interface_state != SKYPOPEN_STATE_DOWN while (tech_pvt && tech_pvt->interface_state != SKYPOPEN_STATE_DOWN
&& tech_pvt->interface_state != SKYPOPEN_STATE_IDLE && tech_pvt->interface_state != SKYPOPEN_STATE_IDLE
&& tech_pvt->interface_state != SKYPOPEN_STATE_HANGUP_REQUESTED && tech_pvt->interface_state != SKYPOPEN_STATE_HANGUP_REQUESTED
&& (tech_pvt->skype_callflow == CALLFLOW_STATUS_INPROGRESS && (tech_pvt->skype_callflow == CALLFLOW_STATUS_INPROGRESS
|| tech_pvt->skype_callflow == CALLFLOW_STATUS_EARLYMEDIA || tech_pvt->skype_callflow == CALLFLOW_STATUS_EARLYMEDIA
|| tech_pvt->skype_callflow == CALLFLOW_STATUS_REMOTEHOLD || tech_pvt->skype_callflow == SKYPOPEN_STATE_UP)) { || tech_pvt->skype_callflow == CALLFLOW_STATUS_REMOTEHOLD || tech_pvt->skype_callflow == SKYPOPEN_STATE_UP)) {
@ -1026,8 +1029,8 @@ void *skypopen_do_tcp_cli_thread_func(void *obj)
if (!(running && tech_pvt->running)) if (!(running && tech_pvt->running))
break; break;
while (tech_pvt && tech_pvt->interface_state != SKYPOPEN_STATE_DOWN while (tech_pvt && tech_pvt->interface_state != SKYPOPEN_STATE_DOWN
&& tech_pvt->interface_state != SKYPOPEN_STATE_IDLE && tech_pvt->interface_state != SKYPOPEN_STATE_IDLE
&& tech_pvt->interface_state != SKYPOPEN_STATE_HANGUP_REQUESTED && tech_pvt->interface_state != SKYPOPEN_STATE_HANGUP_REQUESTED
&& (tech_pvt->skype_callflow == CALLFLOW_STATUS_INPROGRESS && (tech_pvt->skype_callflow == CALLFLOW_STATUS_INPROGRESS
|| tech_pvt->skype_callflow == CALLFLOW_STATUS_EARLYMEDIA || tech_pvt->skype_callflow == CALLFLOW_STATUS_EARLYMEDIA
|| tech_pvt->skype_callflow == CALLFLOW_STATUS_REMOTEHOLD || tech_pvt->skype_callflow == SKYPOPEN_STATE_UP)) { || tech_pvt->skype_callflow == CALLFLOW_STATUS_REMOTEHOLD || tech_pvt->skype_callflow == SKYPOPEN_STATE_UP)) {
@ -1916,9 +1919,9 @@ int inbound_channel_answered(private_t *tech_pvt)
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
if (channel) { if (channel) {
switch_mutex_lock(tech_pvt->flag_mutex); switch_mutex_lock(tech_pvt->flag_mutex);
switch_set_flag(tech_pvt, TFLAG_IO); switch_set_flag(tech_pvt, TFLAG_IO);
switch_mutex_unlock(tech_pvt->flag_mutex); switch_mutex_unlock(tech_pvt->flag_mutex);
} else { } else {
ERRORA("no channel\n", SKYPOPEN_P_LOG); ERRORA("no channel\n", SKYPOPEN_P_LOG);
} }
@ -1938,30 +1941,30 @@ int skypopen_answered(private_t *tech_pvt)
switch_core_session_t *session = NULL; switch_core_session_t *session = NULL;
switch_channel_t *channel = NULL; switch_channel_t *channel = NULL;
if(strlen(tech_pvt->session_uuid_str)){ if (strlen(tech_pvt->session_uuid_str)) {
session = switch_core_session_locate(tech_pvt->session_uuid_str); session = switch_core_session_locate(tech_pvt->session_uuid_str);
if (session) { if (session) {
channel = switch_core_session_get_channel(session); channel = switch_core_session_get_channel(session);
if (channel) {
if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
tech_pvt->interface_state = SKYPOPEN_STATE_UP;
DEBUGA_SKYPE("Outbound Channel Answered! session_uuid_str=%s\n", SKYPOPEN_P_LOG, tech_pvt->session_uuid_str);
outbound_channel_answered(tech_pvt);
} else {
DEBUGA_SKYPE("answered Inbound Channel!\n\n\n\n", SKYPOPEN_P_LOG);
inbound_channel_answered(tech_pvt);
}
if (channel) {
if (switch_channel_direction(channel) == SWITCH_CALL_DIRECTION_OUTBOUND) {
tech_pvt->interface_state = SKYPOPEN_STATE_UP;
DEBUGA_SKYPE("Outbound Channel Answered! session_uuid_str=%s\n", SKYPOPEN_P_LOG, tech_pvt->session_uuid_str);
outbound_channel_answered(tech_pvt);
} else { } else {
DEBUGA_SKYPE("answered Inbound Channel!\n\n\n\n", SKYPOPEN_P_LOG); ERRORA("no channel after INPROGRESS?\n", SKYPOPEN_P_LOG);
inbound_channel_answered(tech_pvt); return SWITCH_STATUS_FALSE;
} }
switch_core_session_rwunlock(session);
} else { } else {
ERRORA("no channel after INPROGRESS?\n", SKYPOPEN_P_LOG); WARNINGA("no session after INPROGRESS, let's hangup\n", SKYPOPEN_P_LOG);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;
} }
switch_core_session_rwunlock(session);
} else {
WARNINGA("no session after INPROGRESS, let's hangup\n", SKYPOPEN_P_LOG);
return SWITCH_STATUS_FALSE;
}
} else { } else {
WARNINGA("no tech_pvt->session_uuid_str after INPROGRESS, let's hangup\n", SKYPOPEN_P_LOG); WARNINGA("no tech_pvt->session_uuid_str after INPROGRESS, let's hangup\n", SKYPOPEN_P_LOG);
return SWITCH_STATUS_FALSE; return SWITCH_STATUS_FALSE;