From c165771474dc37244be9e7d3c28da5a091bd6290 Mon Sep 17 00:00:00 2001 From: Moises Silva Date: Wed, 21 Apr 2010 11:20:05 -0400 Subject: [PATCH] freetdm: completion of compilation with initial reworked API --- libs/freetdm/mod_freetdm/mod_freetdm.c | 706 +++++++++++------- libs/freetdm/src/ftdm_io.c | 322 +++++++- libs/freetdm/src/include/freetdm.h | 132 +++- libs/freetdm/src/include/private/ftdm_core.h | 12 +- libs/freetdm/src/include/private/ftdm_types.h | 81 -- libs/freetdm/src/testanalog.c | 4 +- 6 files changed, 857 insertions(+), 400 deletions(-) diff --git a/libs/freetdm/mod_freetdm/mod_freetdm.c b/libs/freetdm/mod_freetdm/mod_freetdm.c index a4aa659f5c..edb409fe05 100644 --- a/libs/freetdm/mod_freetdm/mod_freetdm.c +++ b/libs/freetdm/mod_freetdm/mod_freetdm.c @@ -4,10 +4,10 @@ * * Version: MPL 1.1 * - * The contents of this file are subject to the Mftilla Public License Version + * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at - * http://www.mftilla.org/MPL/ + * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License @@ -138,14 +138,11 @@ void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t * static switch_core_session_t *ftdm_channel_get_session(ftdm_channel_t *channel, int32_t id) { switch_core_session_t *session = NULL; + const char *token = ftdm_channel_get_token(channel, id); - if (id > FTDM_MAX_TOKENS) { - return NULL; - } - - if (!zstr(channel->tokens[id])) { - if (!(session = switch_core_session_locate(channel->tokens[id]))) { - ftdm_channel_clear_token(channel, channel->tokens[id]); + if (!zstr(token)) { + if (!(session = switch_core_session_locate(token))) { + ftdm_channel_clear_token(channel, token); } } @@ -154,14 +151,7 @@ static switch_core_session_t *ftdm_channel_get_session(ftdm_channel_t *channel, static const char *ftdm_channel_get_uuid(ftdm_channel_t *channel, int32_t id) { - if (id > FTDM_MAX_TOKENS) { - return NULL; - } - - if (!zstr(channel->tokens[id])) { - return channel->tokens[id]; - } - return NULL; + return ftdm_channel_get_token(channel, id); } static void stop_hold(switch_core_session_t *session_a, const char *uuid) @@ -195,19 +185,20 @@ static void start_hold(ftdm_channel_t *ftdmchan, switch_core_session_t *session_ { switch_core_session_t *session; switch_channel_t *channel, *channel_a; + int32_t spanid = 0; if (!uuid) { return; } - + spanid = ftdm_channel_get_span_id(ftdmchan); if ((session = switch_core_session_locate(uuid))) { channel = switch_core_session_get_channel(session); if (zstr(stream)) { if (!strcasecmp(globals.hold_music, "indicate_hold")) { stream = "indicate_hold"; } - if (!strcasecmp(SPAN_CONFIG[ftdmchan->span->span_id].hold_music, "indicate_hold")) { + if (!strcasecmp(SPAN_CONFIG[spanid].hold_music, "indicate_hold")) { stream = "indicate_hold"; } } @@ -217,7 +208,7 @@ static void start_hold(ftdm_channel_t *ftdmchan, switch_core_session_t *session_ } if (zstr(stream)) { - stream = SPAN_CONFIG[ftdmchan->span->span_id].hold_music; + stream = SPAN_CONFIG[spanid].hold_music; } if (zstr(stream)) { @@ -250,9 +241,10 @@ static void cycle_foreground(ftdm_channel_t *ftdmchan, int flash, const char *bc switch_core_session_t *session; switch_channel_t *channel; private_t *tech_pvt; + int32_t tokencnt = ftdm_channel_get_token_count(ftdmchan); - for (i = 0; i < ftdmchan->token_count; i++) { + for (i = 0; i < tokencnt; i++) { if ((session = ftdm_channel_get_session(ftdmchan, i))) { const char *buuid; tech_pvt = switch_core_session_get_private(session); @@ -260,7 +252,7 @@ static void cycle_foreground(ftdm_channel_t *ftdmchan, int flash, const char *bc buuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE); - if (ftdmchan->token_count == 1 && flash) { + if (tokencnt == 1 && flash) { if (switch_test_flag(tech_pvt, TFLAG_HOLD)) { stop_hold(session, buuid); switch_clear_flag_locked(tech_pvt, TFLAG_HOLD); @@ -460,6 +452,8 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session) { switch_channel_t *channel = NULL; private_t *tech_pvt = NULL; + ftdm_chan_type_t chantype; + uint32_t tokencnt; channel = switch_core_session_get_channel(session); assert(channel != NULL); @@ -472,28 +466,31 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session) } ftdm_channel_clear_token(tech_pvt->ftdmchan, switch_core_session_get_uuid(session)); - - switch (tech_pvt->ftdmchan->type) { + + chantype = ftdm_channel_get_type(tech_pvt->ftdmchan); + switch (chantype) { case FTDM_CHAN_TYPE_FXO: case FTDM_CHAN_TYPE_EM: case FTDM_CHAN_TYPE_CAS: { - ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + ftdm_channel_call_hangup(tech_pvt->ftdmchan); } break; case FTDM_CHAN_TYPE_FXS: { - if (tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_BUSY && tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) { - if (tech_pvt->ftdmchan->token_count) { + if (!ftdm_channel_call_check_busy(tech_pvt->ftdmchan) && !ftdm_channel_call_check_done(tech_pvt->ftdmchan)) { + tokencnt = ftdm_channel_get_token_count(tech_pvt->ftdmchan); + if (tokencnt) { cycle_foreground(tech_pvt->ftdmchan, 0, NULL); } else { - ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_HANGUP); + ftdm_channel_call_hangup(tech_pvt->ftdmchan); } } } break; case FTDM_CHAN_TYPE_B: { +#if 0 if (tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_DOWN) { if (tech_pvt->ftdmchan->state != FTDM_CHANNEL_STATE_TERMINATING) { tech_pvt->ftdmchan->caller_data.hangup_cause = switch_channel_get_cause_q850(channel); @@ -503,11 +500,18 @@ static switch_status_t channel_on_hangup(switch_core_session_t *session) } ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_HANGUP); } +#else + ftdm_call_cause_t hcause = switch_channel_get_cause_q850(channel); + if (hcause < 1 || hcause > 127) { + hcause = FTDM_CAUSE_DESTINATION_OUT_OF_ORDER; + } + ftdm_channel_call_hangup_with_cause(tech_pvt->ftdmchan, hcause); +#endif } break; default: { - switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Unhandled channel type %d for channel %s\n", tech_pvt->ftdmchan->type, + switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Unhandled channel type %d for channel %s\n", chantype, switch_channel_get_name(channel)); } break; @@ -611,7 +615,7 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch /* Digium Cards sometimes timeout several times in a row here. Yes, we support digium cards, ain't we nice....... 6 double length intervals should compensate */ - chunk = tech_pvt->ftdmchan->effective_interval * 2; + chunk = ftdm_channel_get_io_interval(tech_pvt->ftdmchan) * 2; total_to = chunk * 6; top: @@ -626,12 +630,12 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch } if (switch_test_flag(tech_pvt, TFLAG_HOLD) || do_break) { - switch_yield(tech_pvt->ftdmchan->effective_interval * 1000); - tech_pvt->cng_frame.datalen = tech_pvt->ftdmchan->packet_len; + switch_yield(ftdm_channel_get_io_interval(tech_pvt->ftdmchan) * 1000); + tech_pvt->cng_frame.datalen = ftdm_channel_get_io_packet_len(tech_pvt->ftdmchan); tech_pvt->cng_frame.samples = tech_pvt->cng_frame.datalen; tech_pvt->cng_frame.flags = SFF_CNG; *frame = &tech_pvt->cng_frame; - if (tech_pvt->ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + if (ftdm_channel_get_codec(tech_pvt->ftdmchan) == FTDM_CODEC_SLIN) { tech_pvt->cng_frame.samples /= 2; } return SWITCH_STATUS_SUCCESS; @@ -672,7 +676,7 @@ static switch_status_t channel_read_frame(switch_core_session_t *session, switch tech_pvt->read_frame.datalen = (uint32_t)len; tech_pvt->read_frame.samples = tech_pvt->read_frame.datalen; - if (tech_pvt->ftdmchan->effective_codec == FTDM_CODEC_SLIN) { + if (ftdm_channel_get_codec(tech_pvt->ftdmchan) == FTDM_CODEC_SLIN) { tech_pvt->read_frame.samples /= 2; } @@ -738,7 +742,7 @@ static switch_status_t channel_write_frame(switch_core_session_t *session, switc wflags = FTDM_WRITE; - status = ftdm_channel_wait(tech_pvt->ftdmchan, &wflags, tech_pvt->ftdmchan->effective_interval * 10); + status = ftdm_channel_wait(tech_pvt->ftdmchan, &wflags, ftdm_channel_get_io_interval(tech_pvt->ftdmchan) * 10); if (!(wflags & FTDM_WRITE)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Dropping frame! (write not ready)\n"); @@ -768,6 +772,7 @@ static switch_status_t channel_receive_message_cas(switch_core_session_t *sessio { switch_channel_t *channel; private_t *tech_pvt; + uint32_t phy_id; channel = switch_core_session_get_channel(session); assert(channel != NULL); @@ -779,22 +784,31 @@ static switch_status_t channel_receive_message_cas(switch_core_session_t *sessio switch_channel_hangup(channel, SWITCH_CAUSE_LOSE_RACE); return SWITCH_STATUS_FALSE; } - - ftdm_log(FTDM_LOG_DEBUG, "Got Freeswitch message in R2 channel %d [%d]\n", tech_pvt->ftdmchan->physical_chan_id, - msg->message_id); + + phy_id = ftdm_channel_get_ph_id(tech_pvt->ftdmchan); + ftdm_log(FTDM_LOG_DEBUG, "Got Freeswitch message in R2 channel %d [%d]\n", phy_id, msg->message_id); + + if (switch_channel_test_flag(channel, CF_OUTBOUND)) { + return SWITCH_STATUS_SUCCESS; + } switch (msg->message_id) { case SWITCH_MESSAGE_INDICATE_RINGING: { +#if 0 if (switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); } else { ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } +#else + ftdm_channel_call_indicate(tech_pvt->ftdmchan, FTDM_CHANNEL_INDICATE_PROGRESS); +#endif } break; case SWITCH_MESSAGE_INDICATE_PROGRESS: { +#if 0 if (switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_MEDIA); @@ -802,24 +816,14 @@ static switch_status_t channel_receive_message_cas(switch_core_session_t *sessio ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } +#else + ftdm_channel_call_indicate(tech_pvt->ftdmchan, FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA); +#endif } break; case SWITCH_MESSAGE_INDICATE_ANSWER: { - if (switch_channel_test_flag(channel, CF_OUTBOUND)) { - ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); - } else { - /* lets make the ftmod_r2 module life easier by moving thru each - * state waiting for completion, clumsy, but does the job - */ - if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) { - ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); - } - if (tech_pvt->ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS_MEDIA) { - ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); - } - ftdm_set_state_locked_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); - } + ftdm_channel_call_answer(tech_pvt->ftdmchan); } break; default: @@ -845,23 +849,31 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session, return SWITCH_STATUS_FALSE; } - if (tech_pvt->ftdmchan->state == FTDM_CHANNEL_STATE_TERMINATING) { - ftdm_mutex_unlock(tech_pvt->ftdmchan->mutex); + if (ftdm_channel_call_check_hangup(tech_pvt->ftdmchan)) { + return SWITCH_STATUS_SUCCESS; + } + + if (switch_channel_test_flag(channel, CF_OUTBOUND)) { return SWITCH_STATUS_SUCCESS; } switch (msg->message_id) { case SWITCH_MESSAGE_INDICATE_RINGING: { +#if 0 if (switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); } else { ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); } +#else + ftdm_channel_call_indicate(tech_pvt->ftdmchan, FTDM_CHANNEL_INDICATE_PROGRESS); +#endif } break; case SWITCH_MESSAGE_INDICATE_PROGRESS: { +#if 0 if (switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_MEDIA); @@ -875,10 +887,14 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session, } ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); } +#else + ftdm_channel_call_indicate(tech_pvt->ftdmchan, FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA); +#endif } break; case SWITCH_MESSAGE_INDICATE_ANSWER: { +#if 0 if (switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); } else { @@ -894,6 +910,9 @@ static switch_status_t channel_receive_message_b(switch_core_session_t *session, } ftdm_set_state_wait(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); } +#else + ftdm_channel_call_answer(tech_pvt->ftdmchan); +#endif } break; default: @@ -919,9 +938,14 @@ static switch_status_t channel_receive_message_fxo(switch_core_session_t *sessio return SWITCH_STATUS_FALSE; } + if (switch_channel_test_flag(channel, CF_OUTBOUND)) { + return SWITCH_STATUS_SUCCESS; + } + switch (msg->message_id) { case SWITCH_MESSAGE_INDICATE_PROGRESS: case SWITCH_MESSAGE_INDICATE_ANSWER: +#if 0 if (switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); @@ -929,6 +953,9 @@ static switch_status_t channel_receive_message_fxo(switch_core_session_t *sessio } else { ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); } +#else + ftdm_channel_call_answer(tech_pvt->ftdmchan); +#endif break; default: break; @@ -952,10 +979,15 @@ static switch_status_t channel_receive_message_fxs(switch_core_session_t *sessio switch_channel_hangup(channel, SWITCH_CAUSE_LOSE_RACE); return SWITCH_STATUS_FALSE; } + + if (switch_channel_test_flag(channel, CF_OUTBOUND)) { + return SWITCH_STATUS_SUCCESS; + } switch (msg->message_id) { case SWITCH_MESSAGE_INDICATE_PROGRESS: case SWITCH_MESSAGE_INDICATE_ANSWER: +#if 0 if (!switch_channel_test_flag(channel, CF_OUTBOUND)) { ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_ANSWERED); ftdm_set_flag_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_PROGRESS); @@ -963,17 +995,22 @@ static switch_status_t channel_receive_message_fxs(switch_core_session_t *sessio ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_UP); switch_channel_mark_answered(channel); } +#else + ftdm_channel_call_answer(tech_pvt->ftdmchan); + switch_channel_mark_answered(channel); +#endif break; case SWITCH_MESSAGE_INDICATE_RINGING: - if (!switch_channel_test_flag(channel, CF_OUTBOUND)) { - - if (!switch_channel_test_flag(channel, CF_ANSWERED) && - !switch_channel_test_flag(channel, CF_EARLY_MEDIA) && - !switch_channel_test_flag(channel, CF_RING_READY) - ) { + if (!switch_channel_test_flag(channel, CF_ANSWERED) && + !switch_channel_test_flag(channel, CF_EARLY_MEDIA) && + !switch_channel_test_flag(channel, CF_RING_READY) + ) { +#if 0 ftdm_set_state_locked(tech_pvt->ftdmchan, FTDM_CHANNEL_STATE_RING); +#else + ftdm_channel_call_indicate(tech_pvt->ftdmchan, FTDM_CHANNEL_INDICATE_RING); +#endif switch_channel_mark_ring_ready(channel); - } } break; default: @@ -1006,12 +1043,9 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s return SWITCH_STATUS_FALSE; } - ftdm_mutex_lock(ftdmchan->mutex); - if (!tech_pvt->ftdmchan) { switch_channel_hangup(channel, SWITCH_CAUSE_LOSE_RACE); - status = SWITCH_STATUS_FALSE; - goto end; + return SWITCH_STATUS_FALSE; } switch (msg->message_id) { @@ -1035,7 +1069,7 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s break; } - switch (tech_pvt->ftdmchan->type) { + switch (ftdm_channel_get_type(tech_pvt->ftdmchan)) { case FTDM_CHAN_TYPE_FXS: case FTDM_CHAN_TYPE_EM: status = channel_receive_message_fxs(session, msg); @@ -1054,10 +1088,6 @@ static switch_status_t channel_receive_message(switch_core_session_t *session, s break; } - end: - - ftdm_mutex_unlock(ftdmchan->mutex); - return status; } @@ -1098,7 +1128,7 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi const char *dest = NULL; char *data = NULL; - int span_id = -1, group_id = -1,chan_id = 0; + int span_id = -1, group_id = -1, chan_id = 0; ftdm_channel_t *ftdmchan = NULL; switch_call_cause_t cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; char name[128]; @@ -1169,7 +1199,7 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi ftdm_span_t *span; ftdm_status_t zstatus = ftdm_span_find_by_name(span_name, &span); if (zstatus == FTDM_SUCCESS && span) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } } @@ -1178,7 +1208,7 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi ftdm_group_t *group; ftdm_status_t zstatus = ftdm_group_find_by_name(span_name, &group); if (zstatus == FTDM_SUCCESS && group) { - group_id = group->group_id; + group_id = ftdm_group_get_id(group); } else { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Missing ftdm span or group: %s\n", span_name); return SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; @@ -1275,12 +1305,12 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi goto fail; } - snprintf(name, sizeof(name), "FreeTDM/%u:%u/%s", ftdmchan->span_id, ftdmchan->chan_id, dest); + snprintf(name, sizeof(name), "FreeTDM/%u:%u/%s", ftdm_channel_get_span_id(ftdmchan), ftdm_channel_get_id(ftdmchan), dest); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Connect outbound channel %s\n", name); switch_channel_set_name(channel, name); - switch_channel_set_variable(channel, "freetdm_span_name", ftdmchan->span->name); - switch_channel_set_variable_printf(channel, "freetdm_span_number", "%d", ftdmchan->span_id); - switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", ftdmchan->chan_id); + switch_channel_set_variable(channel, "freetdm_span_name", ftdm_channel_get_span_name(ftdmchan)); + switch_channel_set_variable_printf(channel, "freetdm_span_number", "%d", ftdm_channel_get_span_id(ftdmchan)); + switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", ftdm_channel_get_id(ftdmchan)); ftdm_channel_set_caller_data(ftdmchan, &caller_data); caller_profile = switch_caller_profile_clone(*new_session, outbound_profile); caller_profile->destination_number = switch_core_strdup(caller_profile->pool, switch_str_nil(dest_num)); @@ -1291,14 +1321,14 @@ static switch_call_cause_t channel_outgoing_channel(switch_core_session_t *sessi switch_channel_set_flag(channel, CF_OUTBOUND); switch_channel_set_state(channel, CS_INIT); - if (ftdm_channel_add_token(ftdmchan, switch_core_session_get_uuid(*new_session), ftdmchan->token_count) != FTDM_SUCCESS) { + if (ftdm_channel_add_token(ftdmchan, switch_core_session_get_uuid(*new_session), ftdm_channel_get_token_count(ftdmchan)) != FTDM_SUCCESS) { switch_core_session_destroy(new_session); cause = SWITCH_CAUSE_DESTINATION_OUT_OF_ORDER; goto fail; } - if (ftdm_channel_outgoing_call(ftdmchan) != FTDM_SUCCESS) { + if (ftdm_channel_call_place(ftdmchan) != FTDM_SUCCESS) { if (tech_pvt->read_codec.implementation) { switch_core_codec_destroy(&tech_pvt->read_codec); } @@ -1331,9 +1361,14 @@ ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session switch_core_session_t *session = NULL; private_t *tech_pvt = NULL; switch_channel_t *channel = NULL; + uint32_t spanid, chanid; char name[128]; + ftdm_caller_data_t *channel_caller_data = sigmsg->raw_data; *sp = NULL; + + spanid = ftdm_channel_get_span_id(sigmsg->channel); + chanid = ftdm_channel_get_span_id(sigmsg->channel); if (!(session = switch_core_session_request(freetdm_endpoint_interface, SWITCH_CALL_DIRECTION_INBOUND, NULL))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Initilization Error!\n"); @@ -1350,61 +1385,61 @@ ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session switch_core_session_destroy(&session); return FTDM_FAIL; } + + channel_caller_data->collected[0] = '\0'; - *sigmsg->channel->caller_data.collected = '\0'; - - if (zstr(sigmsg->channel->caller_data.cid_name)) { - switch_set_string(sigmsg->channel->caller_data.cid_name, sigmsg->channel->chan_name); + if (zstr(channel_caller_data->cid_name)) { + switch_set_string(channel_caller_data->cid_name, ftdm_channel_get_name(sigmsg->channel)); } - if (zstr(sigmsg->channel->caller_data.cid_num.digits)) { - if (!zstr(sigmsg->channel->caller_data.ani.digits)) { - switch_set_string(sigmsg->channel->caller_data.cid_num.digits, sigmsg->channel->caller_data.ani.digits); + if (zstr(channel_caller_data->cid_num.digits)) { + if (!zstr(channel_caller_data->ani.digits)) { + switch_set_string(channel_caller_data->cid_num.digits, channel_caller_data->ani.digits); } else { - switch_set_string(sigmsg->channel->caller_data.cid_num.digits, sigmsg->channel->chan_number); + switch_set_string(channel_caller_data->cid_num.digits, ftdm_channel_get_number(sigmsg->channel)); } } tech_pvt->caller_profile = switch_caller_profile_new(switch_core_session_get_pool(session), "FreeTDM", - SPAN_CONFIG[sigmsg->channel->span_id].dialplan, - sigmsg->channel->caller_data.cid_name, - sigmsg->channel->caller_data.cid_num.digits, + SPAN_CONFIG[spanid].dialplan, + channel_caller_data->cid_name, + channel_caller_data->cid_num.digits, NULL, - sigmsg->channel->caller_data.ani.digits, - sigmsg->channel->caller_data.aniII, - sigmsg->channel->caller_data.rdnis.digits, - (char *) modname, - SPAN_CONFIG[sigmsg->channel->span_id].context, - sigmsg->channel->caller_data.dnis.digits); + channel_caller_data->ani.digits, + channel_caller_data->aniII, + channel_caller_data->rdnis.digits, + (char *)modname, + SPAN_CONFIG[spanid].context, + channel_caller_data->dnis.digits); assert(tech_pvt->caller_profile != NULL); - if (sigmsg->channel->caller_data.screen == 1 || sigmsg->channel->caller_data.screen == 3) { + if (channel_caller_data->screen == 1 || channel_caller_data->screen == 3) { switch_set_flag(tech_pvt->caller_profile, SWITCH_CPF_SCREEN); } - tech_pvt->caller_profile->caller_ton = sigmsg->channel->caller_data.cid_num.type; - tech_pvt->caller_profile->caller_numplan = sigmsg->channel->caller_data.cid_num.plan; - tech_pvt->caller_profile->ani_ton = sigmsg->channel->caller_data.ani.type; - tech_pvt->caller_profile->ani_numplan = sigmsg->channel->caller_data.ani.plan; - tech_pvt->caller_profile->destination_number_ton = sigmsg->channel->caller_data.dnis.type; - tech_pvt->caller_profile->destination_number_numplan = sigmsg->channel->caller_data.dnis.plan; - tech_pvt->caller_profile->rdnis_ton = sigmsg->channel->caller_data.rdnis.type; - tech_pvt->caller_profile->rdnis_numplan = sigmsg->channel->caller_data.rdnis.plan; + tech_pvt->caller_profile->caller_ton = channel_caller_data->cid_num.type; + tech_pvt->caller_profile->caller_numplan = channel_caller_data->cid_num.plan; + tech_pvt->caller_profile->ani_ton = channel_caller_data->ani.type; + tech_pvt->caller_profile->ani_numplan = channel_caller_data->ani.plan; + tech_pvt->caller_profile->destination_number_ton = channel_caller_data->dnis.type; + tech_pvt->caller_profile->destination_number_numplan = channel_caller_data->dnis.plan; + tech_pvt->caller_profile->rdnis_ton = channel_caller_data->rdnis.type; + tech_pvt->caller_profile->rdnis_numplan = channel_caller_data->rdnis.plan; - if (sigmsg->channel->caller_data.pres) { + if (channel_caller_data->pres) { switch_set_flag(tech_pvt->caller_profile, SWITCH_CPF_HIDE_NAME | SWITCH_CPF_HIDE_NUMBER); } - snprintf(name, sizeof(name), "FreeTDM/%u:%u/%s", sigmsg->channel->span_id, sigmsg->channel->chan_id, tech_pvt->caller_profile->destination_number); + snprintf(name, sizeof(name), "FreeTDM/%u:%u/%s", spanid, chanid, tech_pvt->caller_profile->destination_number); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG, "Connect inbound channel %s\n", name); switch_channel_set_name(channel, name); switch_channel_set_caller_profile(channel, tech_pvt->caller_profile); - switch_channel_set_variable(channel, "freetdm_span_name", sigmsg->channel->span->name); - switch_channel_set_variable_printf(channel, "freetdm_span_number", "%d", sigmsg->channel->span_id); - switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", sigmsg->channel->chan_id); + switch_channel_set_variable(channel, "freetdm_span_name", ftdm_channel_get_span_name(sigmsg->channel)); + switch_channel_set_variable_printf(channel, "freetdm_span_number", "%d", spanid); + switch_channel_set_variable_printf(channel, "freetdm_chan_number", "%d", chanid); switch_channel_set_state(channel, CS_INIT); if (switch_core_session_thread_launch(session) != SWITCH_STATUS_SUCCESS) { @@ -1426,13 +1461,16 @@ ftdm_status_t ftdm_channel_from_event(ftdm_sigmsg_t *sigmsg, switch_core_session static FIO_SIGNAL_CB_FUNCTION(on_common_signal) { switch_event_t *event = NULL; - + ftdm_alarm_flag_t alarmbits = FTDM_ALARM_NONE; + uint32_t chanid, spanid; + chanid = ftdm_channel_get_id(sigmsg->channel); + spanid = ftdm_channel_get_span_id(sigmsg->channel); switch (sigmsg->event_id) { case FTDM_SIGEVENT_ALARM_CLEAR: case FTDM_SIGEVENT_ALARM_TRAP: { - if (ftdm_channel_get_alarms(sigmsg->channel) != FTDM_SUCCESS) { + if (ftdm_channel_get_alarms(sigmsg->channel, &alarmbits) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "failed to retrieve alarms\n"); return FTDM_FAIL; } @@ -1441,10 +1479,10 @@ static FIO_SIGNAL_CB_FUNCTION(on_common_signal) return FTDM_FAIL; } if (sigmsg->event_id == FTDM_SIGEVENT_ALARM_CLEAR) { - ftdm_log(FTDM_LOG_NOTICE, "Alarm cleared on channel %d:%d\n", sigmsg->channel->span_id, sigmsg->channel->chan_id); + ftdm_log(FTDM_LOG_NOTICE, "Alarm cleared on channel %d:%d\n", spanid, chanid); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "ftdm-alarm-clear"); } else { - ftdm_log(FTDM_LOG_NOTICE, "Alarm raised on channel %d:%d\n", sigmsg->channel->span_id, sigmsg->channel->chan_id); + ftdm_log(FTDM_LOG_NOTICE, "Alarm raised on channel %d:%d\n", spanid, chanid); switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "condition", "ftdm-alarm-trap"); } } @@ -1454,35 +1492,26 @@ static FIO_SIGNAL_CB_FUNCTION(on_common_signal) break; } - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "span-name", "%s", sigmsg->channel->span->name); - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "span-number", "%d", sigmsg->channel->span_id); - switch_event_add_header(event, SWITCH_STACK_BOTTOM, "chan-number", "%d", sigmsg->channel->chan_id); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "span-name", "%s", ftdm_channel_get_span_name(sigmsg->channel)); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "span-number", "%d", ftdm_channel_get_span_id(sigmsg->channel)); + switch_event_add_header(event, SWITCH_STACK_BOTTOM, "chan-number", "%d", ftdm_channel_get_id(sigmsg->channel)); - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_RECOVER)) { - switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "recover"); - } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_LOOPBACK)) { - switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "loopback"); - } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_YELLOW)) { - switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "yellow"); - } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_RED)) { + if (alarmbits & FTDM_ALARM_RED) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "red"); } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_BLUE)) { - switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "blue"); + if (alarmbits & FTDM_ALARM_YELLOW) { + switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "yellow"); } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_NOTOPEN)) { - switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "notopen"); - } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_AIS)) { - switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "ais"); - } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_RAI)) { + if (alarmbits & FTDM_ALARM_RAI) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "rai"); } - if (ftdm_test_alarm_flag(sigmsg->channel, FTDM_ALARM_GENERAL)) { + if (alarmbits & FTDM_ALARM_BLUE) { + switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "blue"); + } + if (alarmbits & FTDM_ALARM_AIS) { + switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "ais"); + } + if (alarmbits & FTDM_ALARM_GENERAL) { switch_event_add_header_string(event, SWITCH_STACK_BOTTOM, "alarm", "general"); } switch_event_fire(&event); @@ -1495,8 +1524,15 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxo_signal) switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; ftdm_status_t status; + uint32_t spanid; + uint32_t chanid; + ftdm_caller_data_t *callerdata; - ftdm_log(FTDM_LOG_DEBUG, "got FXO sig %d:%d [%s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, ftdm_signal_event2str(sigmsg->event_id)); + spanid = ftdm_channel_get_span_id(sigmsg->channel); + chanid = ftdm_channel_get_id(sigmsg->channel); + callerdata = sigmsg->raw_data; + + ftdm_log(FTDM_LOG_DEBUG, "got FXO sig %d:%d [%s]\n", spanid, chanid, ftdm_signal_event2str(sigmsg->event_id)); switch(sigmsg->event_id) { @@ -1517,7 +1553,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxo_signal) switch_set_flag_locked(tech_pvt, TFLAG_DEAD); ftdm_channel_clear_token(sigmsg->channel, 0); channel = switch_core_session_get_channel(session); - switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause); + switch_channel_hangup(channel, callerdata->hangup_cause); ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } @@ -1536,7 +1572,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxo_signal) { status = ftdm_channel_from_event(sigmsg, &session); if (status != FTDM_SUCCESS) { - ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_DOWN); + ftdm_channel_call_hangup(sigmsg->channel); } } break; @@ -1544,7 +1580,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxo_signal) default: { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unhandled msg type %d for channel %d:%d\n", - sigmsg->event_id, sigmsg->channel->span_id, sigmsg->channel->chan_id); + sigmsg->event_id, spanid, chanid); } break; @@ -1558,6 +1594,11 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; ftdm_status_t status = FTDM_SUCCESS; + uint32_t chanid, spanid, tokencount; + + chanid = ftdm_channel_get_id(sigmsg->channel); + spanid = ftdm_channel_get_span_id(sigmsg->channel); + tokencount = ftdm_channel_get_token_count(sigmsg->channel); ftdm_log(FTDM_LOG_DEBUG, "got FXS sig [%s]\n", ftdm_signal_event2str(sigmsg->event_id)); @@ -1582,10 +1623,9 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) break; case FTDM_SIGEVENT_START: { - ftdm_clear_flag_locked(sigmsg->channel, FTDM_CHANNEL_HOLD); status = ftdm_channel_from_event(sigmsg, &session); if (status != FTDM_SUCCESS) { - ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_BUSY); + ftdm_channel_call_indicate(sigmsg->channel, FTDM_CHANNEL_INDICATE_BUSY); } } break; @@ -1593,15 +1633,19 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) { private_t *tech_pvt = NULL; switch_call_cause_t cause = SWITCH_CAUSE_NORMAL_CLEARING; - if (sigmsg->channel->token_count) { + if (tokencount) { switch_core_session_t *session_a, *session_b, *session_t = NULL; switch_channel_t *channel_a = NULL, *channel_b = NULL; +#if 0 int digits = !zstr(sigmsg->channel->caller_data.collected); +#else + int digits = 0; +#endif const char *br_a_uuid = NULL, *br_b_uuid = NULL; private_t *tech_pvt = NULL; - if ((session_a = switch_core_session_locate(sigmsg->channel->tokens[0]))) { + if ((session_a = switch_core_session_locate(ftdm_channel_get_token(sigmsg->channel, 0)))) { channel_a = switch_core_session_get_channel(session_a); br_a_uuid = switch_channel_get_variable(channel_a, SWITCH_SIGNAL_BOND_VARIABLE); @@ -1610,7 +1654,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) switch_clear_flag_locked(tech_pvt, TFLAG_HOLD); } - if ((session_b = switch_core_session_locate(sigmsg->channel->tokens[1]))) { + if ((session_b = switch_core_session_locate(ftdm_channel_get_token(sigmsg->channel, 1)))) { channel_b = switch_core_session_get_channel(session_b); br_b_uuid = switch_channel_get_variable(channel_b, SWITCH_SIGNAL_BOND_VARIABLE); @@ -1630,10 +1674,12 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) } } +#if 0 if (session_t) { switch_ivr_session_transfer(session_t, sigmsg->channel->caller_data.collected, NULL, NULL); switch_core_session_rwunlock(session_t); } +#endif if (session_a) { switch_core_session_rwunlock(session_a); @@ -1666,8 +1712,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) break; case FTDM_SIGEVENT_FLASH: { - - if (ftdm_test_flag(sigmsg->channel, FTDM_CHANNEL_HOLD) && sigmsg->channel->token_count == 1) { + if (ftdm_channel_call_check_hold(sigmsg->channel) && tokencount == 1) { switch_core_session_t *session; if ((session = ftdm_channel_get_session(sigmsg->channel, 0))) { const char *buuid; @@ -1677,12 +1722,13 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) tech_pvt = switch_core_session_get_private(session); channel = switch_core_session_get_channel(session); buuid = switch_channel_get_variable(channel, SWITCH_SIGNAL_BOND_VARIABLE); - ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_UP); + ftdm_channel_call_unhold(sigmsg->channel); stop_hold(session, buuid); switch_clear_flag_locked(tech_pvt, TFLAG_HOLD); switch_core_session_rwunlock(session); } - } else if (sigmsg->channel->token_count == 2 && (SPAN_CONFIG[sigmsg->span_id].analog_options & ANALOG_OPTION_3WAY)) { +#if 0 + } else if (tokencount == 2 && (SPAN_CONFIG[sigmsg->span_id].analog_options & ANALOG_OPTION_3WAY)) { if (ftdm_test_flag(sigmsg->channel, FTDM_CHANNEL_3WAY)) { ftdm_clear_flag(sigmsg->channel, FTDM_CHANNEL_3WAY); if ((session = ftdm_channel_get_session(sigmsg->channel, 1))) { @@ -1703,15 +1749,16 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) || (SPAN_CONFIG[sigmsg->span_id].analog_options & ANALOG_OPTION_3WAY) ) { cycle_foreground(sigmsg->channel, 1, NULL); - if (sigmsg->channel->token_count == 1) { - ftdm_set_flag_locked(sigmsg->channel, FTDM_CHANNEL_HOLD); - ftdm_set_state_locked(sigmsg->channel, FTDM_CHANNEL_STATE_DIALTONE); + if (tokencount == 1) { + ftdm_channel_call_hold(sigmsg->channel); } +#endif } } break; +#if 0 case FTDM_SIGEVENT_COLLECTED_DIGIT: { char *dtmf = sigmsg->raw_data; @@ -1750,11 +1797,12 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) } break; +#endif default: { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unhandled msg type %d for channel %d:%d\n", - sigmsg->event_id, sigmsg->channel->span_id, sigmsg->channel->chan_id); + sigmsg->event_id, spanid, chanid); } break; @@ -1765,11 +1813,17 @@ static FIO_SIGNAL_CB_FUNCTION(on_fxs_signal) static FIO_SIGNAL_CB_FUNCTION(on_r2_signal) { + uint32_t phyid, chanid, spanid; switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; ftdm_status_t status = FTDM_SUCCESS; + ftdm_caller_data_t *caller_data = sigmsg->raw_data; - ftdm_log(FTDM_LOG_DEBUG, "Got R2 channel sig [%s] in channel %d\n", ftdm_signal_event2str(sigmsg->event_id), sigmsg->channel->physical_chan_id); + phyid = ftdm_channel_get_ph_id(sigmsg->channel); + chanid = ftdm_channel_get_id(sigmsg->channel); + spanid = ftdm_channel_get_span_id(sigmsg->channel); + + ftdm_log(FTDM_LOG_DEBUG, "Got R2 channel sig [%s] in channel %d\n", ftdm_signal_event2str(sigmsg->event_id), phyid); if (on_common_signal(sigmsg) == FTDM_BREAK) { return FTDM_SUCCESS; @@ -1784,7 +1838,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_r2_signal) tech_pvt = switch_core_session_get_private(session); switch_set_flag_locked(tech_pvt, TFLAG_DEAD); channel = switch_core_session_get_channel(session); - switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause); + switch_channel_hangup(channel, caller_data->hangup_cause); ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } @@ -1798,6 +1852,8 @@ static FIO_SIGNAL_CB_FUNCTION(on_r2_signal) } break; +#if 0 +FIXME: collected DNIS /* on DNIS received from the R2 forward side, return status == FTDM_BREAK to stop requesting DNIS */ case FTDM_SIGEVENT_COLLECTED_DIGIT: { @@ -1834,6 +1890,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_r2_signal) } } break; +#endif case FTDM_SIGEVENT_PROGRESS: { @@ -1852,7 +1909,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_r2_signal) channel = switch_core_session_get_channel(session); switch_channel_mark_answered(channel); if (ftdm_channel_command(sigmsg->channel, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) { - ftdm_log(FTDM_LOG_ERROR, "Failed to enable DTMF detection in R2 channel %d:%d\n", sigmsg->channel->span_id, sigmsg->channel->chan_id); + ftdm_log(FTDM_LOG_ERROR, "Failed to enable DTMF detection in R2 channel %d:%d\n", spanid, chanid); } switch_core_session_rwunlock(session); } @@ -1862,7 +1919,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_r2_signal) default: { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unhandled event %d from R2 for channel %d:%d\n", - sigmsg->event_id, sigmsg->channel->span_id, sigmsg->channel->chan_id); + sigmsg->event_id, spanid, chanid); } break; } @@ -1874,9 +1931,15 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) { switch_core_session_t *session = NULL; switch_channel_t *channel = NULL; + ftdm_caller_data_t *caller_data; + uint32_t spanid, chanid; ftdm_log(FTDM_LOG_DEBUG, "got clear channel sig [%s]\n", ftdm_signal_event2str(sigmsg->event_id)); + caller_data = sigmsg->raw_data; + chanid = ftdm_channel_get_id(sigmsg->channel); + spanid = ftdm_channel_get_span_id(sigmsg->channel); + if (on_common_signal(sigmsg) == FTDM_BREAK) { return FTDM_SUCCESS; } @@ -1901,7 +1964,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) tech_pvt = switch_core_session_get_private(session); switch_set_flag_locked(tech_pvt, TFLAG_DEAD); channel = switch_core_session_get_channel(session); - switch_channel_hangup(channel, sigmsg->channel->caller_data.hangup_cause); + switch_channel_hangup(channel, caller_data->hangup_cause); ftdm_channel_clear_token(sigmsg->channel, switch_core_session_get_uuid(session)); switch_core_session_rwunlock(session); } @@ -1921,7 +1984,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) const char *uuid = ftdm_channel_get_uuid(sigmsg->channel, 0); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Session for channel %d:%d not found [UUID: %s]\n", - sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A"); + spanid, chanid, (uuid) ? uuid : "N/A"); } } case FTDM_SIGEVENT_PROGRESS_MEDIA: @@ -1934,7 +1997,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) const char *uuid = ftdm_channel_get_uuid(sigmsg->channel, 0); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Session for channel %d:%d not found [UUID: %s]\n", - sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A"); + spanid, chanid, (uuid) ? uuid : "N/A"); } } break; @@ -1948,7 +2011,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) const char *uuid = ftdm_channel_get_uuid(sigmsg->channel, 0); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Session for channel %d:%d not found [UUID: %s]\n", - sigmsg->channel->span_id, sigmsg->channel->chan_id, (uuid) ? uuid : "N/A"); + spanid, chanid, (uuid) ? uuid : "N/A"); } } break; @@ -1962,7 +2025,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) default: { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unhandled msg type %d for channel %d:%d\n", - sigmsg->event_id, sigmsg->channel->span_id, sigmsg->channel->chan_id); + sigmsg->event_id, spanid, chanid); } break; } @@ -1973,22 +2036,31 @@ static FIO_SIGNAL_CB_FUNCTION(on_clear_channel_signal) static FIO_SIGNAL_CB_FUNCTION(on_ss7_signal) { + uint32_t spanid, chanid; if (on_common_signal(sigmsg) == FTDM_BREAK) { return FTDM_SUCCESS; } - ftdm_log(FTDM_LOG_DEBUG, "got ss7 sig %d:%d [%s]\n", sigmsg->channel->span_id, sigmsg->channel->chan_id, ftdm_signal_event2str(sigmsg->event_id)); + spanid = ftdm_channel_get_span_id(sigmsg->channel); + chanid = ftdm_channel_get_span_id(sigmsg->channel); + ftdm_log(FTDM_LOG_DEBUG, "got ss7 sig %d:%d [%s]\n", spanid, chanid, ftdm_signal_event2str(sigmsg->event_id)); return FTDM_SUCCESS; } static FIO_SIGNAL_CB_FUNCTION(on_analog_signal) { + uint32_t spanid, chanid; + ftdm_chan_type_t type; switch_status_t status = SWITCH_STATUS_FALSE; + spanid = ftdm_channel_get_span_id(sigmsg->channel); + chanid = ftdm_channel_get_span_id(sigmsg->channel); + type = ftdm_channel_get_type(sigmsg->channel); + if (on_common_signal(sigmsg) == FTDM_BREAK) { return FTDM_SUCCESS; } - switch (sigmsg->channel->type) { + switch (type) { case FTDM_CHAN_TYPE_FXO: case FTDM_CHAN_TYPE_EM: { @@ -2003,7 +2075,7 @@ static FIO_SIGNAL_CB_FUNCTION(on_analog_signal) default: { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_WARNING, "Unhandled analog channel type %d for channel %d:%d\n", - sigmsg->channel->type, sigmsg->channel->span_id, sigmsg->channel->chan_id); + type, spanid, chanid); } break; } @@ -2243,7 +2315,7 @@ static switch_status_t load_config(void) } if (!span_id) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } ss7confnode = get_ss7_config_node(cfg, configname); @@ -2276,14 +2348,14 @@ static switch_status_t load_config(void) if (ftdm_configure_span("ss7", span, on_ss7_signal, "confnode", ss7confnode, "parameters", spanparameters, - TAG_END) != FTDM_SUCCESS) { + FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Error configuring ss7 FreeTDM span %d\n", span_id); continue; } - SPAN_CONFIG[span->span_id].span = span; - switch_copy_string(SPAN_CONFIG[span->span_id].context, context, sizeof(SPAN_CONFIG[span->span_id].context)); - switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); - switch_copy_string(SPAN_CONFIG[span->span_id].type, "Sangoma (SS7)", sizeof(SPAN_CONFIG[span->span_id].type)); + SPAN_CONFIG[span_id].span = span; + switch_copy_string(SPAN_CONFIG[span_id].context, context, sizeof(SPAN_CONFIG[span_id].context)); + switch_copy_string(SPAN_CONFIG[span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span_id].dialplan)); + switch_copy_string(SPAN_CONFIG[span_id].type, "Sangoma (SS7)", sizeof(SPAN_CONFIG[span_id].type)); ftdm_log(FTDM_LOG_DEBUG, "Configured ss7 FreeTDM span %d with config node %s\n", span_id, configname); } } @@ -2375,7 +2447,7 @@ static switch_status_t load_config(void) } if (!span_id) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } if (ftdm_configure_span("analog", span, on_analog_signal, @@ -2384,28 +2456,28 @@ static switch_status_t load_config(void) "max_dialstr", &max, "hotline", hotline, "enable_callerid", enable_callerid, - TAG_END) != FTDM_SUCCESS) { + FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d\n", span_id); continue; } - SPAN_CONFIG[span->span_id].span = span; - switch_set_string(SPAN_CONFIG[span->span_id].context, context); - switch_set_string(SPAN_CONFIG[span->span_id].dialplan, dialplan); - SPAN_CONFIG[span->span_id].analog_options = analog_options | globals.analog_options; + SPAN_CONFIG[span_id].span = span; + switch_set_string(SPAN_CONFIG[span_id].context, context); + switch_set_string(SPAN_CONFIG[span_id].dialplan, dialplan); + SPAN_CONFIG[span_id].analog_options = analog_options | globals.analog_options; if (dial_regex) { - switch_set_string(SPAN_CONFIG[span->span_id].dial_regex, dial_regex); + switch_set_string(SPAN_CONFIG[span_id].dial_regex, dial_regex); } if (fail_dial_regex) { - switch_set_string(SPAN_CONFIG[span->span_id].fail_dial_regex, fail_dial_regex); + switch_set_string(SPAN_CONFIG[span_id].fail_dial_regex, fail_dial_regex); } if (hold_music) { - switch_set_string(SPAN_CONFIG[span->span_id].hold_music, hold_music); + switch_set_string(SPAN_CONFIG[span_id].hold_music, hold_music); } - switch_copy_string(SPAN_CONFIG[span->span_id].type, "analog", sizeof(SPAN_CONFIG[span->span_id].type)); + switch_copy_string(SPAN_CONFIG[span_id].type, "analog", sizeof(SPAN_CONFIG[span_id].type)); ftdm_span_start(span); } } @@ -2490,7 +2562,7 @@ static switch_status_t load_config(void) } if (!span_id) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } @@ -2498,28 +2570,28 @@ static switch_status_t load_config(void) "tonemap", tonegroup, "digit_timeout", &to, "max_dialstr", &max, - TAG_END) != FTDM_SUCCESS) { + FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d\n", span_id); continue; } - SPAN_CONFIG[span->span_id].span = span; - switch_set_string(SPAN_CONFIG[span->span_id].context, context); - switch_set_string(SPAN_CONFIG[span->span_id].dialplan, dialplan); - SPAN_CONFIG[span->span_id].analog_options = analog_options | globals.analog_options; + SPAN_CONFIG[span_id].span = span; + switch_set_string(SPAN_CONFIG[span_id].context, context); + switch_set_string(SPAN_CONFIG[span_id].dialplan, dialplan); + SPAN_CONFIG[span_id].analog_options = analog_options | globals.analog_options; if (dial_regex) { - switch_set_string(SPAN_CONFIG[span->span_id].dial_regex, dial_regex); + switch_set_string(SPAN_CONFIG[span_id].dial_regex, dial_regex); } if (fail_dial_regex) { - switch_set_string(SPAN_CONFIG[span->span_id].fail_dial_regex, fail_dial_regex); + switch_set_string(SPAN_CONFIG[span_id].fail_dial_regex, fail_dial_regex); } if (hold_music) { - switch_set_string(SPAN_CONFIG[span->span_id].hold_music, hold_music); + switch_set_string(SPAN_CONFIG[span_id].hold_music, hold_music); } - switch_copy_string(SPAN_CONFIG[span->span_id].type, "analog_em", sizeof(SPAN_CONFIG[span->span_id].type)); + switch_copy_string(SPAN_CONFIG[span_id].type, "analog_em", sizeof(SPAN_CONFIG[span_id].type)); ftdm_span_start(span); } } @@ -2603,9 +2675,9 @@ static switch_status_t load_config(void) continue; } - if (!span_id) { - span_id = span->span_id; - } + if (!span_id) { + span_id = ftdm_span_get_id(span); + } if (!tonegroup) { tonegroup = "us"; @@ -2619,15 +2691,16 @@ static switch_status_t load_config(void) "tonemap", tonegroup, "q921loglevel", q921loglevel, "q931loglevel", q931loglevel, - TAG_END) != FTDM_SUCCESS) { - ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d mode: %s dialect: %s error: %s\n", span_id, mode, dialect, span->last_error); + FTDM_TAG_END) != FTDM_SUCCESS) { + ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d mode: %s dialect: %s error: %s\n", span_id, + mode, dialect, ftdm_span_get_last_error(span)); continue; } - SPAN_CONFIG[span->span_id].span = span; - switch_copy_string(SPAN_CONFIG[span->span_id].context, context, sizeof(SPAN_CONFIG[span->span_id].context)); - switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); - switch_copy_string(SPAN_CONFIG[span->span_id].type, "isdn", sizeof(SPAN_CONFIG[span->span_id].type)); + SPAN_CONFIG[span_id].span = span; + switch_copy_string(SPAN_CONFIG[span_id].context, context, sizeof(SPAN_CONFIG[span_id].context)); + switch_copy_string(SPAN_CONFIG[span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span_id].dialplan)); + switch_copy_string(SPAN_CONFIG[span_id].type, "isdn", sizeof(SPAN_CONFIG[span_id].type)); ftdm_span_start(span); } @@ -2701,7 +2774,7 @@ static switch_status_t load_config(void) } if (!span_id) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } @@ -2712,17 +2785,17 @@ static switch_status_t load_config(void) "l1", o_l1, "debug", o_debug, "opts", opts, - TAG_END) != FTDM_SUCCESS) { + FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d node: %s switch: %s dp: %s l1: %s debug: %s error: %s\n", span_id, switch_str_nil(o_node), switch_str_nil(o_switch), switch_str_nil(o_dp), switch_str_nil(o_l1), switch_str_nil(o_debug), - span->last_error); + ftdm_span_get_last_error(span)); continue; } - SPAN_CONFIG[span->span_id].span = span; - switch_copy_string(SPAN_CONFIG[span->span_id].context, context, sizeof(SPAN_CONFIG[span->span_id].context)); - switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); - switch_copy_string(SPAN_CONFIG[span->span_id].type, "isdn", sizeof(SPAN_CONFIG[span->span_id].type)); + SPAN_CONFIG[span_id].span = span; + switch_copy_string(SPAN_CONFIG[span_id].context, context, sizeof(SPAN_CONFIG[span_id].context)); + switch_copy_string(SPAN_CONFIG[span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span_id].dialplan)); + switch_copy_string(SPAN_CONFIG[span_id].type, "isdn", sizeof(SPAN_CONFIG[span_id].type)); ftdm_span_start(span); } @@ -2790,19 +2863,19 @@ static switch_status_t load_config(void) } if (!span_id) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } if (ftdm_configure_span_signaling("sangoma_boost", span, on_clear_channel_signal, spanparameters) != FTDM_SUCCESS) { - ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d error: %s\n", span_id, span->last_error); + ftdm_log(FTDM_LOG_ERROR, "Error starting FreeTDM span %d error: %s\n", span_id, ftdm_span_get_last_error(span)); continue; } - SPAN_CONFIG[span->span_id].span = span; - switch_copy_string(SPAN_CONFIG[span->span_id].context, context, sizeof(SPAN_CONFIG[span->span_id].context)); - switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); + SPAN_CONFIG[span_id].span = span; + switch_copy_string(SPAN_CONFIG[span_id].context, context, sizeof(SPAN_CONFIG[span_id].context)); + switch_copy_string(SPAN_CONFIG[span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span_id].dialplan)); - switch_copy_string(SPAN_CONFIG[span->span_id].type, "Sangoma (boost)", sizeof(SPAN_CONFIG[span->span_id].type)); + switch_copy_string(SPAN_CONFIG[span_id].type, "Sangoma (boost)", sizeof(SPAN_CONFIG[span_id].type)); boost_spans[boosti++] = span; } } @@ -2925,7 +2998,7 @@ static switch_status_t load_config(void) } if (!span_id) { - span_id = span->span_id; + span_id = ftdm_span_get_id(span); } if (ftdm_configure_span("r2", span, on_r2_signal, @@ -2946,27 +3019,27 @@ static switch_status_t load_config(void) "call_files", call_files, "mfback_timeout", mfback_timeout, "metering_pulse_timeout", metering_pulse_timeout, - TAG_END) != FTDM_SUCCESS) { + FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Error configuring R2 FreeTDM span %d, error: %s\n", - span_id, span->last_error); + span_id, ftdm_span_get_last_error(span)); continue; } if (dial_regex) { - switch_set_string(SPAN_CONFIG[span->span_id].dial_regex, dial_regex); + switch_set_string(SPAN_CONFIG[span_id].dial_regex, dial_regex); } if (fail_dial_regex) { - switch_set_string(SPAN_CONFIG[span->span_id].fail_dial_regex, fail_dial_regex); + switch_set_string(SPAN_CONFIG[span_id].fail_dial_regex, fail_dial_regex); } - SPAN_CONFIG[span->span_id].span = span; - switch_copy_string(SPAN_CONFIG[span->span_id].context, context, sizeof(SPAN_CONFIG[span->span_id].context)); - switch_copy_string(SPAN_CONFIG[span->span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span->span_id].dialplan)); - switch_copy_string(SPAN_CONFIG[span->span_id].type, "r2", sizeof(SPAN_CONFIG[span->span_id].type)); + SPAN_CONFIG[span_id].span = span; + switch_copy_string(SPAN_CONFIG[span_id].context, context, sizeof(SPAN_CONFIG[span_id].context)); + switch_copy_string(SPAN_CONFIG[span_id].dialplan, dialplan, sizeof(SPAN_CONFIG[span_id].dialplan)); + switch_copy_string(SPAN_CONFIG[span_id].type, "r2", sizeof(SPAN_CONFIG[span_id].type)); if (ftdm_span_start(span) == FTDM_FAIL) { - ftdm_log(FTDM_LOG_ERROR, "Error starting R2 FreeTDM span %d, error: %s\n", span_id, span->last_error); + ftdm_log(FTDM_LOG_ERROR, "Error starting R2 FreeTDM span %d, error: %s\n", span_id, ftdm_span_get_last_error(span)); continue; } } @@ -2976,9 +3049,10 @@ static switch_status_t load_config(void) * of needing all spans to be configured before starting them */ for ( ; i < boosti; i++) { boost_span = boost_spans[i]; - ftdm_log(FTDM_LOG_DEBUG, "Starting boost span %d\n", boost_span->span_id); + ftdm_log(FTDM_LOG_DEBUG, "Starting boost span %d\n", ftdm_span_get_id(boost_span)); if (ftdm_span_start(boost_span) == FTDM_FAIL) { - ftdm_log(FTDM_LOG_ERROR, "Error starting boost FreeTDM span %d, error: %s\n", boost_span->span_id, boost_span->last_error); + ftdm_log(FTDM_LOG_ERROR, "Error starting boost FreeTDM span %d, error: %s\n", + ftdm_span_get_id(boost_span), ftdm_span_get_last_error(boost_span)); continue; } } @@ -2989,15 +3063,37 @@ static switch_status_t load_config(void) return SWITCH_STATUS_SUCCESS; } - void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream) { + uint32_t span_id; + uint32_t phspan_id, phchan_id; + const char *chan_type; + const char *state; + const char *last_state; + float txgain, rxgain; + ftdm_alarm_flag_t alarmflag; + ftdm_caller_data_t *caller_data; + ftdm_channel_t *ftdmchan; ftdm_signaling_status_t sigstatus = FTDM_SIG_STATE_DOWN; - if (chan_id > span->chan_count) { + + if (chan_id > ftdm_span_get_chan_count(span)) { return; } - - ftdm_channel_get_sig_status(span->channels[chan_id], &sigstatus); + + ftdmchan = ftdm_span_get_channel(span, chan_id); + span_id = ftdm_span_get_id(span); + + phspan_id = ftdm_channel_get_ph_span_id(ftdmchan); + phchan_id = ftdm_channel_get_ph_id(ftdmchan); + chan_type = ftdm_chan_type2str(ftdm_channel_get_type(ftdmchan)); + state = ftdm_channel_get_state_str(ftdmchan); + last_state = ftdm_channel_get_last_state_str(ftdmchan); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_RX_GAIN, &rxgain); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_TX_GAIN, &txgain); + caller_data = ftdm_channel_get_caller_data(ftdmchan); + ftdm_channel_get_sig_status(ftdmchan, &sigstatus); + ftdm_channel_get_alarms(ftdmchan, &alarmflag); + stream->write_function(stream, "span_id: %u\n" "chan_id: %u\n" @@ -3018,35 +3114,59 @@ void dump_chan(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stre "dnis: %s\n" "rdnis: %s\n" "cause: %s\n\n", - span->channels[chan_id]->span_id, - span->channels[chan_id]->chan_id, - span->channels[chan_id]->physical_span_id, - span->channels[chan_id]->physical_chan_id, - (span->channels[chan_id]->alarm_flags) ? "DOWN" : "UP", - ftdm_signaling_status2str(sigstatus), - ftdm_chan_type2str(span->channels[chan_id]->type), - ftdm_channel_state2str(span->channels[chan_id]->state), - ftdm_channel_state2str(span->channels[chan_id]->last_state), - span->channels[chan_id]->txgain, - span->channels[chan_id]->rxgain, - span->channels[chan_id]->caller_data.cid_date, - span->channels[chan_id]->caller_data.cid_name, - span->channels[chan_id]->caller_data.cid_num.digits, - span->channels[chan_id]->caller_data.ani.digits, - span->channels[chan_id]->caller_data.aniII, - span->channels[chan_id]->caller_data.dnis.digits, - span->channels[chan_id]->caller_data.rdnis.digits, - switch_channel_cause2str(span->channels[chan_id]->caller_data.hangup_cause) - ); + span_id, + chan_id, + phspan_id, + phchan_id, + alarmflag ? "alarmed" : "ok", + ftdm_signaling_status2str(sigstatus), + chan_type, + state, + last_state, + txgain, + rxgain, + caller_data->cid_date, + caller_data->cid_name, + caller_data->cid_num.digits, + caller_data->ani.digits, + caller_data->aniII, + caller_data->dnis.digits, + caller_data->rdnis.digits, + switch_channel_cause2str(caller_data->hangup_cause)); } void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t *stream) { + uint32_t span_id; + uint32_t phspan_id, phchan_id; + const char *chan_type; + const char *state; + const char *last_state; + float txgain, rxgain; + ftdm_caller_data_t *caller_data; + ftdm_channel_t *ftdmchan; + ftdm_alarm_flag_t alarmflag; ftdm_signaling_status_t sigstatus = FTDM_SIG_STATE_DOWN; - if (chan_id > span->chan_count) { + + if (chan_id > ftdm_span_get_chan_count(span)) { return; } - ftdm_channel_get_sig_status(span->channels[chan_id], &sigstatus); + + ftdmchan = ftdm_span_get_channel(span, chan_id); + span_id = ftdm_span_get_id(span); + + phspan_id = ftdm_channel_get_ph_span_id(ftdmchan); + phchan_id = ftdm_channel_get_ph_id(ftdmchan); + chan_type = ftdm_chan_type2str(ftdm_channel_get_type(ftdmchan)); + state = ftdm_channel_get_state_str(ftdmchan); + last_state = ftdm_channel_get_last_state_str(ftdmchan); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_RX_GAIN, &rxgain); + ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_TX_GAIN, &txgain); + caller_data = ftdm_channel_get_caller_data(ftdmchan); + ftdm_channel_get_sig_status(ftdmchan, &sigstatus); + ftdm_channel_get_alarms(ftdmchan, &alarmflag); + + stream->write_function(stream, " \n" " %u\n" @@ -3069,26 +3189,25 @@ void dump_chan_xml(ftdm_span_t *span, uint32_t chan_id, switch_stream_handle_t * " %s\n" " %s\n" " \n", - span->channels[chan_id]->span_id, - span->channels[chan_id]->chan_id, - span->channels[chan_id]->physical_span_id, - span->channels[chan_id]->physical_chan_id, - (span->channels[chan_id]->alarm_flags) ? "DOWN" : "UP", - ftdm_signaling_status2str(sigstatus), - ftdm_chan_type2str(span->channels[chan_id]->type), - ftdm_channel_state2str(span->channels[chan_id]->state), - ftdm_channel_state2str(span->channels[chan_id]->last_state), - span->channels[chan_id]->txgain, - span->channels[chan_id]->rxgain, - span->channels[chan_id]->caller_data.cid_date, - span->channels[chan_id]->caller_data.cid_name, - span->channels[chan_id]->caller_data.cid_num.digits, - span->channels[chan_id]->caller_data.ani.digits, - span->channels[chan_id]->caller_data.aniII, - span->channels[chan_id]->caller_data.dnis.digits, - span->channels[chan_id]->caller_data.rdnis.digits, - switch_channel_cause2str(span->channels[chan_id]->caller_data.hangup_cause) - ); + span_id, + chan_id, + phspan_id, + phchan_id, + alarmflag ? "alarmed" : "ok", + ftdm_signaling_status2str(sigstatus), + chan_type, + state, + last_state, + txgain, + rxgain, + caller_data->cid_date, + caller_data->cid_name, + caller_data->cid_num.digits, + caller_data->ani.digits, + caller_data->aniII, + caller_data->dnis.digits, + caller_data->rdnis.digits, + switch_channel_cause2str(caller_data->hangup_cause)); } #define FT_SYNTAX "list || dump [] || q931_pcap on|off [pcapfilename without suffix] || gains []" @@ -3135,14 +3254,15 @@ SWITCH_STANDARD_API(ft_function) stream->write_function(stream, "invalid span\n"); } else { if (chan_id) { - if(chan_id > span->chan_count) { + if(chan_id > ftdm_span_get_chan_count(span)) { stream->write_function(stream, "invalid channel\n"); } else { dump_chan_xml(span, chan_id, stream); } } else { uint32_t j; - for (j = 1; j <= span->chan_count; j++) { + uint32_t ccount = ftdm_span_get_chan_count(span); + for (j = 1; j <= ccount; j++) { dump_chan_xml(span, j, stream); } @@ -3154,16 +3274,16 @@ SWITCH_STANDARD_API(ft_function) stream->write_function(stream, "-ERR invalid span\n"); } else { if (chan_id) { - if(chan_id > span->chan_count) { + if(chan_id > ftdm_span_get_chan_count(span)) { stream->write_function(stream, "-ERR invalid channel\n"); } else { dump_chan(span, chan_id, stream); } } else { uint32_t j; - + uint32_t ccount = ftdm_span_get_chan_count(span); stream->write_function(stream, "+OK\n"); - for (j = 1; j <= span->chan_count; j++) { + for (j = 1; j <= ccount; j++) { dump_chan(span, j, stream); } @@ -3198,10 +3318,10 @@ SWITCH_STANDARD_API(ft_function) "hold_music: %s\n" "analog_options %s\n", j, - SPAN_CONFIG[j].span->name, + ftdm_span_get_name(SPAN_CONFIG[j].span), SPAN_CONFIG[j].type, ftdm_signaling_status2str(sigstatus), - SPAN_CONFIG[j].span->chan_count, + ftdm_span_get_chan_count(SPAN_CONFIG[j].span), SPAN_CONFIG[j].dialplan, SPAN_CONFIG[j].context, SPAN_CONFIG[j].dial_regex, @@ -3222,9 +3342,9 @@ SWITCH_STANDARD_API(ft_function) "hold_music: %s\n" "analog_options %s\n", j, - SPAN_CONFIG[j].span->name, + ftdm_span_get_name(SPAN_CONFIG[j].span), SPAN_CONFIG[j].type, - SPAN_CONFIG[j].span->chan_count, + ftdm_span_get_chan_count(SPAN_CONFIG[j].span), SPAN_CONFIG[j].dialplan, SPAN_CONFIG[j].context, SPAN_CONFIG[j].dial_regex, @@ -3290,14 +3410,14 @@ SWITCH_STANDARD_API(ft_function) tmp_path=switch_mprintf("%s%s%s.pcap", SWITCH_GLOBAL_dirs.log_dir, SWITCH_PATH_SEPARATOR, pcapfn); if(!strcasecmp(argv[2], "on")) { - if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 1, "pcapfilename", tmp_path, TAG_END) != FTDM_SUCCESS) { + if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 1, "pcapfilename", tmp_path, FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_WARNING, "Error couldn't (re-)enable Q931-To-Pcap!\n"); goto end; } else { stream->write_function(stream, "+OK\n"); } } else if(!strcasecmp(argv[2], "off")) { - if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 0, TAG_END) != FTDM_SUCCESS) { + if (ftdm_configure_span("isdn", span, on_clear_channel_signal, "q931topcap", 0, FTDM_TAG_END) != FTDM_SUCCESS) { ftdm_log(FTDM_LOG_ERROR, "Error couldn't enable Q931-To-Pcap!\n"); goto end; } else { @@ -3313,6 +3433,8 @@ SWITCH_STANDARD_API(ft_function) float txgain = 0.0; float rxgain = 0.0; uint32_t chan_id = 0; + uint32_t ccount = 0; + ftdm_channel_t *chan; ftdm_span_t *span = NULL; if (argc < 4) { stream->write_function(stream, "-ERR Usage: ft gains []\n"); @@ -3325,7 +3447,7 @@ SWITCH_STANDARD_API(ft_function) } if (argc > 4) { chan_id = atoi(argv[4]); - if (chan_id > span->chan_count) { + if (chan_id > ftdm_span_get_chan_count(span)) { stream->write_function(stream, "-ERR invalid chan\n"); goto end; } @@ -3336,13 +3458,17 @@ SWITCH_STANDARD_API(ft_function) stream->write_function(stream, "-ERR invalid gains\n"); goto end; } + if (chan_id) { - ftdm_channel_command(span->channels[chan_id], FTDM_COMMAND_SET_RX_GAIN, &rxgain); - ftdm_channel_command(span->channels[chan_id], FTDM_COMMAND_SET_TX_GAIN, &txgain); + chan = ftdm_span_get_channel(span, chan_id); + ftdm_channel_command(chan, FTDM_COMMAND_SET_RX_GAIN, &rxgain); + ftdm_channel_command(chan, FTDM_COMMAND_SET_TX_GAIN, &txgain); } else { - for (i = 1; i < span->chan_count; i++) { - ftdm_channel_command(span->channels[i], FTDM_COMMAND_SET_RX_GAIN, &rxgain); - ftdm_channel_command(span->channels[i], FTDM_COMMAND_SET_TX_GAIN, &txgain); + ccount = ftdm_span_get_chan_count(span); + for (i = 1; i < ccount; i++) { + chan = ftdm_span_get_channel(span, i); + ftdm_channel_command(chan, FTDM_COMMAND_SET_RX_GAIN, &rxgain); + ftdm_channel_command(chan, FTDM_COMMAND_SET_TX_GAIN, &txgain); } } stream->write_function(stream, "+OK gains set to Rx %f and Tx %f\n", rxgain, txgain); @@ -3352,7 +3478,7 @@ SWITCH_STANDARD_API(ft_function) if (rply) { stream->write_function(stream, "%s", rply); - ftdm_safe_free(rply); + free(rply); } else { stream->write_function(stream, "-ERR Usage: %s\n", FT_SYNTAX); } diff --git a/libs/freetdm/src/ftdm_io.c b/libs/freetdm/src/ftdm_io.c index e72f177d67..e9d48ada56 100644 --- a/libs/freetdm/src/ftdm_io.c +++ b/libs/freetdm/src/ftdm_io.c @@ -452,28 +452,38 @@ static ftdm_status_t ftdm_span_destroy(ftdm_span_t *span) return status; } -FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan) +FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan, ftdm_alarm_flag_t *alarmbits) { ftdm_status_t status = FTDM_FAIL; + ftdm_assert_return(alarmbits != NULL, FTDM_FAIL, "null argument\n"); + + alarmbits = FTDM_ALARM_NONE; + + ftdm_channel_lock(ftdmchan); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CONFIGURED)) { if (ftdmchan->span->fio->get_alarms) { if ((status = ftdmchan->span->fio->get_alarms(ftdmchan)) == FTDM_SUCCESS) { *ftdmchan->last_error = '\0'; + *alarmbits = ftdmchan->alarm_flags; if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_RED)) { snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "RED/"); } if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_YELLOW)) { snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "YELLOW/"); } + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_RAI)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "RAI/"); + } if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_BLUE)) { snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "BLUE/"); } - if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_LOOPBACK)) { - snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "LOOP/"); + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_AIS)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "AIS/"); } - if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_RECOVER)) { - snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "RECOVER/"); + if (ftdm_test_alarm_flag(ftdmchan, FTDM_ALARM_GENERAL)) { + snprintf(ftdmchan->last_error + strlen(ftdmchan->last_error), sizeof(ftdmchan->last_error) - strlen(ftdmchan->last_error), "GENERAL"); } *(ftdmchan->last_error + strlen(ftdmchan->last_error) - 1) = '\0'; @@ -482,7 +492,9 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan) status = FTDM_NOTIMPL; } } - + + ftdm_channel_unlock(ftdmchan); + return status; } @@ -990,6 +1002,58 @@ FT_DECLARE(void) ftdm_channel_replace_token(ftdm_channel_t *ftdmchan, const char } } +FT_DECLARE(uint32_t) ftdm_channel_get_token_count(const ftdm_channel_t *ftdmchan) +{ + uint32_t count; + ftdm_mutex_lock(ftdmchan->mutex); + count = ftdmchan->token_count; + ftdm_mutex_unlock(ftdmchan->mutex); + return count; +} + +FT_DECLARE(uint32_t) ftdm_channel_get_io_interval(const ftdm_channel_t *ftdmchan) +{ + uint32_t count; + ftdm_mutex_lock(ftdmchan->mutex); + count = ftdmchan->effective_interval; + ftdm_mutex_unlock(ftdmchan->mutex); + return count; +} + +FT_DECLARE(uint32_t) ftdm_channel_get_io_packet_len(const ftdm_channel_t *ftdmchan) +{ + uint32_t count; + ftdm_mutex_lock(ftdmchan->mutex); + count = ftdmchan->packet_len; + ftdm_mutex_unlock(ftdmchan->mutex); + return count; +} + +FT_DECLARE(uint32_t) ftdm_channel_get_type(const ftdm_channel_t *ftdmchan) +{ + return ftdmchan->type; +} + +FT_DECLARE(ftdm_codec_t) ftdm_channel_get_codec(const ftdm_channel_t *ftdmchan) +{ + return ftdmchan->effective_codec; +} + +FT_DECLARE(const char *) ftdm_channel_get_token(const ftdm_channel_t *ftdmchan, uint32_t tokenid) +{ + const char *token = NULL; + ftdm_mutex_lock(ftdmchan->mutex); + + if (ftdmchan->token_count <= tokenid) { + ftdm_mutex_unlock(ftdmchan->mutex); + return NULL; + } + + token = ftdmchan->tokens[tokenid]; + ftdm_mutex_unlock(ftdmchan->mutex); + return token; +} + FT_DECLARE(ftdm_status_t) ftdm_channel_add_token(ftdm_channel_t *ftdmchan, char *token, int end) { ftdm_status_t status = FTDM_FAIL; @@ -1212,6 +1276,10 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(ftdm_channel_t *ftdmchan, ftdm_ return ok ? FTDM_SUCCESS : FTDM_FAIL; } +FT_DECLARE(uint32_t) ftdm_group_get_id(const ftdm_group_t *group) +{ + return group->group_id; +} FT_DECLARE(ftdm_status_t) ftdm_group_channel_use_count(ftdm_group_t *group, uint32_t *count) { @@ -1607,6 +1675,16 @@ FT_DECLARE(uint32_t) ftdm_channel_get_span_id(const ftdm_channel_t *ftdmchan) return ftdmchan->span_id; } +FT_DECLARE(ftdm_span_t *) ftdm_channel_get_span(const ftdm_channel_t *ftdmchan) +{ + return ftdmchan->span; +} + +FT_DECLARE(const char *) ftdm_channel_get_span_name(const ftdm_channel_t *ftdmchan) +{ + return ftdmchan->span->name; +} + FT_DECLARE(uint32_t) ftdm_span_get_id(const ftdm_span_t *span) { return span->span_id; @@ -1617,14 +1695,123 @@ FT_DECLARE(const char *) ftdm_span_get_name(const ftdm_span_t *span) return span->name; } -FT_DECLARE(ftdm_bool_t) ftdm_channel_call_active(const ftdm_channel_t *ftdmchan) +FT_DECLARE(const char *) ftdm_channel_get_name(const ftdm_channel_t *ftdmchan) { - return (ftdmchan->state == FTDM_CHANNEL_STATE_UP) ? FTDM_TRUE : FTDM_FALSE; + return ftdmchan->chan_name; +} + +FT_DECLARE(const char *) ftdm_channel_get_number(const ftdm_channel_t *ftdmchan) +{ + return ftdmchan->chan_number; +} + +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_hold(const ftdm_channel_t *ftdmchan) +{ + ftdm_bool_t condition; + ftdm_channel_lock(ftdmchan); + condition = ftdm_test_flag(ftdmchan, FTDM_CHANNEL_HOLD); + ftdm_channel_unlock(ftdmchan); + return condition; +} + +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_answered(const ftdm_channel_t *ftdmchan) +{ + ftdm_bool_t condition = FTDM_FALSE; + + ftdm_channel_lock(ftdmchan); + condition = (ftdmchan->state == FTDM_CHANNEL_STATE_UP) ? FTDM_TRUE : FTDM_FALSE; + ftdm_channel_unlock(ftdmchan); + + return condition; +} + +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_busy(const ftdm_channel_t *ftdmchan) +{ + ftdm_bool_t condition = FTDM_FALSE; + + ftdm_channel_lock(ftdmchan); + condition = (ftdmchan->state == FTDM_CHANNEL_STATE_BUSY) ? FTDM_TRUE : FTDM_FALSE; + ftdm_channel_unlock(ftdmchan); + + return condition; +} + +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_hangup(const ftdm_channel_t *ftdmchan) +{ + ftdm_bool_t condition = FTDM_FALSE; + + ftdm_channel_lock(ftdmchan); + condition = (ftdmchan->state == FTDM_CHANNEL_STATE_HANGUP || ftdmchan->state == FTDM_CHANNEL_STATE_TERMINATING) + ? FTDM_TRUE : FTDM_FALSE; + ftdm_channel_unlock(ftdmchan); + + return condition; +} + +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_done(const ftdm_channel_t *ftdmchan) +{ + ftdm_bool_t condition = FTDM_FALSE; + + ftdm_channel_lock(ftdmchan); + condition = (ftdmchan->state == FTDM_CHANNEL_STATE_DOWN) ? FTDM_TRUE : FTDM_FALSE; + ftdm_channel_unlock(ftdmchan); + + return condition; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_call_hold(ftdm_channel_t *ftdmchan) +{ + ftdm_channel_lock(ftdmchan); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_HOLD); + ftdm_set_state_wait(ftdmchan, FTDM_CHANNEL_STATE_DIALTONE); + ftdm_channel_unlock(ftdmchan); + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_call_unhold(ftdm_channel_t *ftdmchan) +{ + ftdm_channel_lock(ftdmchan); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_HOLD)) { + ftdm_set_state_wait(ftdmchan, FTDM_CHANNEL_STATE_UP); + } + ftdm_channel_unlock(ftdmchan); + return FTDM_SUCCESS; } FT_DECLARE(ftdm_status_t) ftdm_channel_call_answer(ftdm_channel_t *ftdmchan) { - ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_UP); + ftdm_channel_lock(ftdmchan); + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_ANSWERED)) { + return FTDM_SUCCESS; + } + + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_ANSWERED); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag(ftdmchan, FTDM_CHANNEL_MEDIA); + ftdm_channel_unlock(ftdmchan); + return FTDM_SUCCESS; + } + + if (ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) { + ftdm_set_state_wait(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); + } + + if (ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS_MEDIA) { + ftdm_set_state_wait(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); + } + + ftdm_set_state_wait(ftdmchan, FTDM_CHANNEL_STATE_UP); + + ftdm_channel_unlock(ftdmchan); + return FTDM_SUCCESS; +} + +FT_DECLARE(ftdm_status_t) ftdm_channel_call_hangup_with_cause(ftdm_channel_t *ftdmchan, ftdm_call_cause_t cause) +{ + ftdmchan->caller_data.hangup_cause = cause; + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_HANGUP); return FTDM_SUCCESS; } @@ -1639,15 +1826,101 @@ FT_DECLARE(const char *) ftdm_channel_get_last_error(const ftdm_channel_t *ftdmc return ftdmchan->last_error; } +FT_DECLARE(const char *) ftdm_span_get_last_error(const ftdm_span_t *span) +{ + return span->last_error; +} + +FT_DECLARE(ftdm_caller_data_t *) ftdm_channel_get_caller_data(ftdm_channel_t *ftdmchan) +{ + return &ftdmchan->caller_data; +} + +FT_DECLARE(const char *) ftdm_channel_get_state_str(const ftdm_channel_t *ftdmchan) +{ + const char *state; + ftdm_channel_lock(ftdmchan); + state = ftdm_channel_state2str(ftdmchan->state); + ftdm_channel_unlock(ftdmchan); + return state; +} + +FT_DECLARE(const char *) ftdm_channel_get_last_state_str(const ftdm_channel_t *ftdmchan) +{ + const char *state; + ftdm_channel_lock(ftdmchan); + state = ftdm_channel_state2str(ftdmchan->last_state); + ftdm_channel_unlock(ftdmchan); + return state; +} + +FT_DECLARE(ftdm_channel_t *) ftdm_span_get_channel(const ftdm_span_t *span, uint32_t chanid) +{ + ftdm_channel_t *chan; + ftdm_mutex_lock(span->mutex); + if (chanid == 0 || chanid > span->chan_count) { + ftdm_mutex_unlock(span->mutex); + return NULL; + } + chan = span->channels[chanid]; + ftdm_mutex_unlock(span->mutex); + return chan; +} + +FT_DECLARE(uint32_t) ftdm_span_get_chan_count(const ftdm_span_t *span) +{ + uint32_t count; + ftdm_mutex_lock(span->mutex); + count = span->chan_count; + ftdm_mutex_unlock(span->mutex); + return count; +} + +FT_DECLARE(uint32_t) ftdm_channel_get_ph_span_id(const ftdm_channel_t *ftdmchan) +{ + uint32_t id; + ftdm_channel_lock(ftdmchan); + id = ftdmchan->physical_span_id; + ftdm_channel_unlock(ftdmchan); + return id; +} + FT_DECLARE(ftdm_status_t) ftdm_channel_call_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication) { switch (indication) { + + /* FIXME: ring and busy cannot be used with all signaling stacks + * (particularly isdn stacks I think, we should emulate or just move to hangup with busy cause) */ case FTDM_CHANNEL_INDICATE_RING: ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_RING); + break; + + case FTDM_CHANNEL_INDICATE_BUSY: + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_BUSY); + break; + case FTDM_CHANNEL_INDICATE_PROGRESS: - ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_PROGRESS); + } else { + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); + } + break; + + case FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA: + if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) { + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_PROGRESS); + ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_MEDIA); + } else { + if (ftdmchan->state < FTDM_CHANNEL_STATE_PROGRESS) { + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS); + } + ftdm_set_state_locked_wait(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA); + } + break; + default: - ftdm_log(FTDM_LOG_DEBUG, "Do not know how to indicate %d\n", indication); + ftdm_log(FTDM_LOG_WARNING, "Do not know how to indicate %d\n", indication); return FTDM_FAIL; } return FTDM_SUCCESS; @@ -3762,17 +4035,41 @@ FT_DECLARE(ftdm_status_t) ftdm_group_create(ftdm_group_t **group, const char *na FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t *sigmsg) { ftdm_status_t status = FTDM_FAIL; + if (sigmsg->channel) { ftdm_mutex_lock(sigmsg->channel->mutex); } - if (sigmsg->event_id == FTDM_SIGEVENT_SIGSTATUS_CHANGED) { + /* some core things to do on special events */ + switch (sigmsg->event_id) { + + case FTDM_SIGEVENT_SIGSTATUS_CHANGED: if (*((ftdm_signaling_status_t*)(sigmsg->raw_data)) == FTDM_SIG_STATE_UP) { ftdm_set_flag(sigmsg->channel, FTDM_CHANNEL_SIG_UP); } else { ftdm_clear_flag(sigmsg->channel, FTDM_CHANNEL_SIG_UP); } + break; + + case FTDM_SIGEVENT_START: + sigmsg->raw_data = &sigmsg->channel->caller_data; + /* when cleaning up the public API I added this because mod_freetdm.c on_fxs_signal was + * doing it during SIGEVENT_START, but now that flags are private they can't, wonder if + * is needed at all? + * */ + ftdm_clear_flag(sigmsg->channel, FTDM_CHANNEL_HOLD); + break; + + case FTDM_SIGEVENT_STOP: + sigmsg->raw_data = &sigmsg->channel->caller_data; + break; + + default: + break; + } + + /* call the user callback only if set */ if (span->signal_cb) { status = span->signal_cb(sigmsg); } @@ -3780,6 +4077,7 @@ FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t if (sigmsg->channel) { ftdm_mutex_unlock(sigmsg->channel->mutex); } + return status; } diff --git a/libs/freetdm/src/include/freetdm.h b/libs/freetdm/src/include/freetdm.h index 1a021eaa91..fa599021e5 100644 --- a/libs/freetdm/src/include/freetdm.h +++ b/libs/freetdm/src/include/freetdm.h @@ -42,6 +42,15 @@ #include "ftdm_declare.h" +#define FTDM_MAX_CHANNELS_PHYSICAL_SPAN 32 +#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 32 +#define FTDM_MAX_CHANNELS_SPAN FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN +#define FTDM_MAX_SPANS_INTERFACE 128 + +#define FTDM_MAX_CHANNELS_GROUP 1024 +#define FTDM_MAX_GROUPS_INTERFACE FTDM_MAX_SPANS_INTERFACE + + typedef enum { FTDM_SUCCESS, FTDM_FAIL, @@ -63,6 +72,70 @@ extern "C" { #define FTDM_MAX_NAME_STR_SZ 80 #define FTDM_MAX_NUMBER_STR_SZ 20 +typedef enum { + FTDM_CAUSE_NONE = 0, + FTDM_CAUSE_UNALLOCATED = 1, + FTDM_CAUSE_NO_ROUTE_TRANSIT_NET = 2, + FTDM_CAUSE_NO_ROUTE_DESTINATION = 3, + FTDM_CAUSE_CHANNEL_UNACCEPTABLE = 6, + FTDM_CAUSE_CALL_AWARDED_DELIVERED = 7, + FTDM_CAUSE_NORMAL_CLEARING = 16, + FTDM_CAUSE_USER_BUSY = 17, + FTDM_CAUSE_NO_USER_RESPONSE = 18, + FTDM_CAUSE_NO_ANSWER = 19, + FTDM_CAUSE_SUBSCRIBER_ABSENT = 20, + FTDM_CAUSE_CALL_REJECTED = 21, + FTDM_CAUSE_NUMBER_CHANGED = 22, + FTDM_CAUSE_REDIRECTION_TO_NEW_DESTINATION = 23, + FTDM_CAUSE_EXCHANGE_ROUTING_ERROR = 25, + FTDM_CAUSE_DESTINATION_OUT_OF_ORDER = 27, + FTDM_CAUSE_INVALID_NUMBER_FORMAT = 28, + FTDM_CAUSE_FACILITY_REJECTED = 29, + FTDM_CAUSE_RESPONSE_TO_STATUS_ENQUIRY = 30, + FTDM_CAUSE_NORMAL_UNSPECIFIED = 31, + FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION = 34, + FTDM_CAUSE_NETWORK_OUT_OF_ORDER = 38, + FTDM_CAUSE_NORMAL_TEMPORARY_FAILURE = 41, + FTDM_CAUSE_SWITCH_CONGESTION = 42, + FTDM_CAUSE_ACCESS_INFO_DISCARDED = 43, + FTDM_CAUSE_REQUESTED_CHAN_UNAVAIL = 44, + FTDM_CAUSE_PRE_EMPTED = 45, + FTDM_CAUSE_FACILITY_NOT_SUBSCRIBED = 50, + FTDM_CAUSE_OUTGOING_CALL_BARRED = 52, + FTDM_CAUSE_INCOMING_CALL_BARRED = 54, + FTDM_CAUSE_BEARERCAPABILITY_NOTAUTH = 57, + FTDM_CAUSE_BEARERCAPABILITY_NOTAVAIL = 58, + FTDM_CAUSE_SERVICE_UNAVAILABLE = 63, + FTDM_CAUSE_BEARERCAPABILITY_NOTIMPL = 65, + FTDM_CAUSE_CHAN_NOT_IMPLEMENTED = 66, + FTDM_CAUSE_FACILITY_NOT_IMPLEMENTED = 69, + FTDM_CAUSE_SERVICE_NOT_IMPLEMENTED = 79, + FTDM_CAUSE_INVALID_CALL_REFERENCE = 81, + FTDM_CAUSE_INCOMPATIBLE_DESTINATION = 88, + FTDM_CAUSE_INVALID_MSG_UNSPECIFIED = 95, + FTDM_CAUSE_MANDATORY_IE_MISSING = 96, + FTDM_CAUSE_MESSAGE_TYPE_NONEXIST = 97, + FTDM_CAUSE_WRONG_MESSAGE = 98, + FTDM_CAUSE_IE_NONEXIST = 99, + FTDM_CAUSE_INVALID_IE_CONTENTS = 100, + FTDM_CAUSE_WRONG_CALL_STATE = 101, + FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE = 102, + FTDM_CAUSE_MANDATORY_IE_LENGTH_ERROR = 103, + FTDM_CAUSE_PROTOCOL_ERROR = 111, + FTDM_CAUSE_INTERWORKING = 127, + FTDM_CAUSE_SUCCESS = 142, + FTDM_CAUSE_ORIGINATOR_CANCEL = 487, + FTDM_CAUSE_CRASH = 500, + FTDM_CAUSE_SYSTEM_SHUTDOWN = 501, + FTDM_CAUSE_LOSE_RACE = 502, + FTDM_CAUSE_MANAGER_REQUEST = 503, + FTDM_CAUSE_BLIND_TRANSFER = 600, + FTDM_CAUSE_ATTENDED_TRANSFER = 601, + FTDM_CAUSE_ALLOTTED_TIMEOUT = 602, + FTDM_CAUSE_USER_CHALLENGE = 603, + FTDM_CAUSE_MEDIA_TIMEOUT = 604 +} ftdm_call_cause_t; + typedef enum { FTDM_TOP_DOWN, FTDM_BOTTOM_UP @@ -180,6 +253,10 @@ typedef struct ftdm_caller_data { uint32_t chan_id; } ftdm_caller_data_t; +typedef enum { + FTDM_TONE_DTMF = (1 << 0) +} ftdm_tone_type_t; + typedef enum { FTDM_SIGEVENT_START, FTDM_SIGEVENT_STOP, @@ -427,6 +504,7 @@ typedef enum { FTDM_CHANNEL_INDICATE_RING, FTDM_CHANNEL_INDICATE_PROCEED, FTDM_CHANNEL_INDICATE_PROGRESS, + FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA, FTDM_CHANNEL_INDICATE_BUSY, } ftdm_channel_indication_t; @@ -435,6 +513,16 @@ typedef enum { FTDM_TRUE } ftdm_bool_t; +typedef enum { + FTDM_ALARM_NONE = 0, + FTDM_ALARM_RED = (1 << 1), + FTDM_ALARM_YELLOW = (1 << 2), + FTDM_ALARM_RAI = (1 << 3), + FTDM_ALARM_BLUE = (1 << 4), + FTDM_ALARM_AIS = (1 << 5), + FTDM_ALARM_GENERAL = (1 << 30) +} ftdm_alarm_flag_t; + /*! \brief Override the default queue handler */ FT_DECLARE(ftdm_status_t) ftdm_global_set_queue_handler(ftdm_queue_handler_t *handler); @@ -442,22 +530,37 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_call_answer(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_call_place(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_call_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication); FT_DECLARE(ftdm_status_t) ftdm_channel_call_hangup(ftdm_channel_t *ftdmchan); -FT_DECLARE(ftdm_bool_t) ftdm_channel_call_active(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_status_t) ftdm_channel_call_hangup_with_cause(ftdm_channel_t *ftdmchan, ftdm_call_cause_t); +FT_DECLARE(ftdm_status_t) ftdm_channel_call_hold(ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_status_t) ftdm_channel_call_unhold(ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_answered(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_busy(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_hangup(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_done(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_hold(const ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_set_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status); FT_DECLARE(ftdm_status_t) ftdm_channel_get_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status); FT_DECLARE(ftdm_status_t) ftdm_span_set_sig_status(ftdm_span_t *span, ftdm_signaling_status_t status); FT_DECLARE(ftdm_status_t) ftdm_span_get_sig_status(ftdm_span_t *span, ftdm_signaling_status_t *status); -FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan); FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan); FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan); -FT_DECLARE(const char *) ftdm_channel_get_last_error(const ftdm_channel_t *ftdmchan); -FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan); +FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_clear_token(ftdm_channel_t *ftdmchan, const char *token); FT_DECLARE(void) ftdm_channel_replace_token(ftdm_channel_t *ftdmchan, const char *old_token, const char *new_token); FT_DECLARE(ftdm_status_t) ftdm_channel_add_token(ftdm_channel_t *ftdmchan, char *token, int end); +FT_DECLARE(const char *) ftdm_channel_get_token(const ftdm_channel_t *ftdmchan, uint32_t tokenid); +FT_DECLARE(uint32_t) ftdm_channel_get_token_count(const ftdm_channel_t *ftdmchan); + +FT_DECLARE(uint32_t) ftdm_channel_get_io_interval(const ftdm_channel_t *ftdmchan); +FT_DECLARE(uint32_t) ftdm_channel_get_io_packet_len(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_codec_t) ftdm_channel_get_codec(const ftdm_channel_t *ftdmchan); + +FT_DECLARE(const char *) ftdm_channel_get_last_error(const ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan, ftdm_alarm_flag_t *alarmbits); +FT_DECLARE(ftdm_chan_type_t) ftdm_channel_get_type(const ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_size_t) ftdm_channel_dequeue_dtmf(ftdm_channel_t *ftdmchan, char *dtmf, ftdm_size_t len); FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf); @@ -465,6 +568,7 @@ FT_DECLARE(void) ftdm_channel_flush_dtmf(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_span_poll_event(ftdm_span_t *span, uint32_t ms); FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event); FT_DECLARE(ftdm_status_t) ftdm_span_find(uint32_t id, ftdm_span_t **span); +FT_DECLARE(const char *) ftdm_span_get_last_error(const ftdm_span_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_span_create(ftdm_io_interface_t *fio, ftdm_span_t **span, const char *name); FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void); FT_DECLARE(ftdm_status_t) ftdm_span_add_channel(ftdm_span_t *span, ftdm_socket_t sockfd, ftdm_chan_type_t type, ftdm_channel_t **chan); @@ -479,6 +583,7 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_open(uint32_t span_id, uint32_t chan_id, FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_span_channel_use_count(ftdm_span_t *span, uint32_t *count); FT_DECLARE(ftdm_status_t) ftdm_group_channel_use_count(ftdm_group_t *group, uint32_t *count); +FT_DECLARE(uint32_t) ftdm_group_get_id(const ftdm_group_t *group); FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_span(uint32_t span_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_group(uint32_t group_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_close(ftdm_channel_t **ftdmchan); @@ -489,8 +594,13 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_write(ftdm_channel_t *ftdmchan, void *dat FT_DECLARE(ftdm_status_t) ftdm_channel_add_var(ftdm_channel_t *ftdmchan, const char *var_name, const char *value); FT_DECLARE(const char *) ftdm_channel_get_var(ftdm_channel_t *ftdmchan, const char *var_name); FT_DECLARE(ftdm_status_t) ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan); +FT_DECLARE(ftdm_span_t *) ftdm_channel_get_span(const ftdm_channel_t *ftdmchan); FT_DECLARE(uint32_t) ftdm_channel_get_span_id(const ftdm_channel_t *ftdmchan); +FT_DECLARE(uint32_t) ftdm_channel_get_ph_span_id(const ftdm_channel_t *ftdmchan); +FT_DECLARE(const char *) ftdm_channel_get_span_name(const ftdm_channel_t *ftdmchan); FT_DECLARE(uint32_t) ftdm_channel_get_id(const ftdm_channel_t *ftdmchan); +FT_DECLARE(const char *) ftdm_channel_get_name(const ftdm_channel_t *ftdmchan); +FT_DECLARE(const char *) ftdm_channel_get_number(const ftdm_channel_t *ftdmchan); FT_DECLARE(uint32_t) ftdm_channel_get_ph_id(const ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_global_init(void); FT_DECLARE(ftdm_status_t) ftdm_global_configuration(void); @@ -500,7 +610,6 @@ FT_DECLARE(void) ftdm_global_set_crash_policy(ftdm_crash_policy_t policy); FT_DECLARE(void) ftdm_global_set_logger(ftdm_logger_t logger); FT_DECLARE(void) ftdm_global_set_default_logger(int level); FT_DECLARE(ftdm_bool_t) ftdm_running(void); -FT_DECLARE(ftdm_status_t) ftdm_channel_init(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_configure_span(const char *type, ftdm_span_t *span, fio_signal_cb_t sig_cb, ...); FT_DECLARE(ftdm_status_t) ftdm_configure_span_signaling(const char *type, ftdm_span_t *span, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *parameters); FT_DECLARE(ftdm_status_t) ftdm_span_start(ftdm_span_t *span); @@ -510,12 +619,23 @@ FT_DECLARE(ftdm_status_t) ftdm_span_find_by_name(const char *name, ftdm_span_t * FT_DECLARE(uint32_t) ftdm_span_get_id(const ftdm_span_t *span); FT_DECLARE(const char *) ftdm_span_get_name(const ftdm_span_t *span); FT_DECLARE(char *) ftdm_api_execute(const char *type, const char *cmd); -FT_DECLARE(ftdm_status_t) ftdm_channel_set_caller_data(ftdm_channel_t *ftdmchan, ftdm_caller_data_t *caller_data); FT_DECLARE(void) ftdm_cpu_monitor_disable(void); FT_DECLARE(ftdm_status_t) ftdm_conf_node_create(const char *name, ftdm_conf_node_t **node, ftdm_conf_node_t *parent); FT_DECLARE(ftdm_status_t) ftdm_conf_node_add_param(ftdm_conf_node_t *node, const char *param, const char *val); FT_DECLARE(ftdm_status_t) ftdm_conf_node_destroy(ftdm_conf_node_t *node); FT_DECLARE(ftdm_status_t) ftdm_configure_span_channels(ftdm_span_t *span, const char *str, ftdm_channel_config_t *chan_config, unsigned *configured); +FT_DECLARE(ftdm_status_t) ftdm_channel_done(ftdm_channel_t *ftdmchan); + +FT_DECLARE(ftdm_channel_t *) ftdm_span_get_channel(const ftdm_span_t *span, uint32_t chanid); +FT_DECLARE(uint32_t) ftdm_span_get_chan_count(const ftdm_span_t *span); + +FT_DECLARE(ftdm_status_t) ftdm_channel_set_caller_data(ftdm_channel_t *ftdmchan, ftdm_caller_data_t *caller_data); +FT_DECLARE(ftdm_caller_data_t *) ftdm_channel_get_caller_data(ftdm_channel_t *channel); +FT_DECLARE(const char *) ftdm_channel_get_state_str(const ftdm_channel_t *channel); +FT_DECLARE(const char *) ftdm_channel_get_last_state_str(const ftdm_channel_t *channel); + +/* TODO: try to get rid of this API */ +FT_DECLARE(ftdm_status_t) ftdm_channel_init(ftdm_channel_t *ftdmchan); #define FIO_CODEC_ARGS (void *data, ftdm_size_t max, ftdm_size_t *datalen) #define FIO_CODEC_FUNCTION(name) FT_DECLARE_NONSTD(ftdm_status_t) name FIO_CODEC_ARGS diff --git a/libs/freetdm/src/include/private/ftdm_core.h b/libs/freetdm/src/include/private/ftdm_core.h index 13cfda2672..3c072cb958 100644 --- a/libs/freetdm/src/include/private/ftdm_core.h +++ b/libs/freetdm/src/include/private/ftdm_core.h @@ -120,14 +120,6 @@ extern "C" { #endif -#define FTDM_MAX_CHANNELS_PHYSICAL_SPAN 32 -#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 32 -#define FTDM_MAX_CHANNELS_SPAN FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN -#define FTDM_MAX_SPANS_INTERFACE 128 - -#define FTDM_MAX_CHANNELS_GROUP 1024 -#define FTDM_MAX_GROUPS_INTERFACE FTDM_MAX_SPANS_INTERFACE - #define GOTO_STATUS(label,st) status = st; goto label ; #define ftdm_copy_string(x,y,z) strncpy(x, y, z - 1) @@ -542,7 +534,6 @@ FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(ftdm_channel_t *ftdmchan, ftdm_ FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname); FT_DECLARE(ftdm_time_t) ftdm_current_time_in_ms(void); -FT_DECLARE(ftdm_status_t) ftdm_channel_done(ftdm_channel_t *ftdmchan); FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan); @@ -639,6 +630,9 @@ FIO_CODEC_FUNCTION(fio_alaw2ulaw); #define ftdm_array_len(array) sizeof(array)/sizeof(array[0]) +#define ftdm_channel_lock(chan) ftdm_mutex_lock(chan->mutex) +#define ftdm_channel_unlock(chan) ftdm_mutex_unlock(chan->mutex) + static __inline__ void ftdm_abort(void) { #ifdef __cplusplus diff --git a/libs/freetdm/src/include/private/ftdm_types.h b/libs/freetdm/src/include/private/ftdm_types.h index 90ace21b6a..d358850115 100644 --- a/libs/freetdm/src/include/private/ftdm_types.h +++ b/libs/freetdm/src/include/private/ftdm_types.h @@ -151,19 +151,6 @@ typedef enum { #define OOB_STRINGS "DTMF", "ONHOOK", "OFFHOOK", "WINK", "FLASH", "RING_START", "RING_STOP", "ALARM_TRAP", "ALARM_CLEAR", "NOOP", "CAS_BITS_CHANGE", "INVALID" FTDM_STR2ENUM_P(ftdm_str2ftdm_oob_event, ftdm_oob_event2str, ftdm_oob_event_t) -typedef enum { - FTDM_ALARM_NONE = 0, - FTDM_ALARM_RECOVER = (1 << 0), - FTDM_ALARM_LOOPBACK = (1 << 2), - FTDM_ALARM_YELLOW = (1 << 3), - FTDM_ALARM_RED = (1 << 4), - FTDM_ALARM_BLUE = (1 << 5), - FTDM_ALARM_NOTOPEN = ( 1 << 6), - FTDM_ALARM_AIS = ( 1 << 7), - FTDM_ALARM_RAI = ( 1 << 8), - FTDM_ALARM_GENERAL = ( 1 << 30) -} ftdm_alarm_flag_t; - typedef enum { FTDM_SIGTYPE_NONE, FTDM_SIGTYPE_ISDN, @@ -174,10 +161,6 @@ typedef enum { FTDM_SIGTYPE_R2 } ftdm_signal_type_t; -typedef enum { - FTDM_TONE_DTMF = (1 << 0) -} ftdm_tone_type_t; - typedef enum { FTDM_SPAN_CONFIGURED = (1 << 0), FTDM_SPAN_READY = (1 << 1), @@ -368,70 +351,6 @@ typedef struct ftdm_fsk_modulator ftdm_fsk_modulator_t; typedef ftdm_status_t (*ftdm_span_start_t)(ftdm_span_t *span); typedef ftdm_status_t (*ftdm_span_stop_t)(ftdm_span_t *span); -typedef enum { - FTDM_CAUSE_NONE = 0, - FTDM_CAUSE_UNALLOCATED = 1, - FTDM_CAUSE_NO_ROUTE_TRANSIT_NET = 2, - FTDM_CAUSE_NO_ROUTE_DESTINATION = 3, - FTDM_CAUSE_CHANNEL_UNACCEPTABLE = 6, - FTDM_CAUSE_CALL_AWARDED_DELIVERED = 7, - FTDM_CAUSE_NORMAL_CLEARING = 16, - FTDM_CAUSE_USER_BUSY = 17, - FTDM_CAUSE_NO_USER_RESPONSE = 18, - FTDM_CAUSE_NO_ANSWER = 19, - FTDM_CAUSE_SUBSCRIBER_ABSENT = 20, - FTDM_CAUSE_CALL_REJECTED = 21, - FTDM_CAUSE_NUMBER_CHANGED = 22, - FTDM_CAUSE_REDIRECTION_TO_NEW_DESTINATION = 23, - FTDM_CAUSE_EXCHANGE_ROUTING_ERROR = 25, - FTDM_CAUSE_DESTINATION_OUT_OF_ORDER = 27, - FTDM_CAUSE_INVALID_NUMBER_FORMAT = 28, - FTDM_CAUSE_FACILITY_REJECTED = 29, - FTDM_CAUSE_RESPONSE_TO_STATUS_ENQUIRY = 30, - FTDM_CAUSE_NORMAL_UNSPECIFIED = 31, - FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION = 34, - FTDM_CAUSE_NETWORK_OUT_OF_ORDER = 38, - FTDM_CAUSE_NORMAL_TEMPORARY_FAILURE = 41, - FTDM_CAUSE_SWITCH_CONGESTION = 42, - FTDM_CAUSE_ACCESS_INFO_DISCARDED = 43, - FTDM_CAUSE_REQUESTED_CHAN_UNAVAIL = 44, - FTDM_CAUSE_PRE_EMPTED = 45, - FTDM_CAUSE_FACILITY_NOT_SUBSCRIBED = 50, - FTDM_CAUSE_OUTGOING_CALL_BARRED = 52, - FTDM_CAUSE_INCOMING_CALL_BARRED = 54, - FTDM_CAUSE_BEARERCAPABILITY_NOTAUTH = 57, - FTDM_CAUSE_BEARERCAPABILITY_NOTAVAIL = 58, - FTDM_CAUSE_SERVICE_UNAVAILABLE = 63, - FTDM_CAUSE_BEARERCAPABILITY_NOTIMPL = 65, - FTDM_CAUSE_CHAN_NOT_IMPLEMENTED = 66, - FTDM_CAUSE_FACILITY_NOT_IMPLEMENTED = 69, - FTDM_CAUSE_SERVICE_NOT_IMPLEMENTED = 79, - FTDM_CAUSE_INVALID_CALL_REFERENCE = 81, - FTDM_CAUSE_INCOMPATIBLE_DESTINATION = 88, - FTDM_CAUSE_INVALID_MSG_UNSPECIFIED = 95, - FTDM_CAUSE_MANDATORY_IE_MISSING = 96, - FTDM_CAUSE_MESSAGE_TYPE_NONEXIST = 97, - FTDM_CAUSE_WRONG_MESSAGE = 98, - FTDM_CAUSE_IE_NONEXIST = 99, - FTDM_CAUSE_INVALID_IE_CONTENTS = 100, - FTDM_CAUSE_WRONG_CALL_STATE = 101, - FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE = 102, - FTDM_CAUSE_MANDATORY_IE_LENGTH_ERROR = 103, - FTDM_CAUSE_PROTOCOL_ERROR = 111, - FTDM_CAUSE_INTERWORKING = 127, - FTDM_CAUSE_SUCCESS = 142, - FTDM_CAUSE_ORIGINATOR_CANCEL = 487, - FTDM_CAUSE_CRASH = 500, - FTDM_CAUSE_SYSTEM_SHUTDOWN = 501, - FTDM_CAUSE_LOSE_RACE = 502, - FTDM_CAUSE_MANAGER_REQUEST = 503, - FTDM_CAUSE_BLIND_TRANSFER = 600, - FTDM_CAUSE_ATTENDED_TRANSFER = 601, - FTDM_CAUSE_ALLOTTED_TIMEOUT = 602, - FTDM_CAUSE_USER_CHALLENGE = 603, - FTDM_CAUSE_MEDIA_TIMEOUT = 604 -} ftdm_call_cause_t; - #ifdef __cplusplus } #endif diff --git a/libs/freetdm/src/testanalog.c b/libs/freetdm/src/testanalog.c index ab575e6c58..ccfa33a161 100644 --- a/libs/freetdm/src/testanalog.c +++ b/libs/freetdm/src/testanalog.c @@ -18,7 +18,7 @@ static void *test_call(ftdm_thread_t *me, void *obj) ftdm_channel_call_answer(chan); ftdm_channel_command(chan, FTDM_COMMAND_SEND_DTMF, number); - while (ftdm_channel_call_active(chan)) { + while (ftdm_channel_call_check_answered(chan)) { ftdm_wait_flag_t flags = FTDM_READ; if (ftdm_channel_wait(chan, &flags, -1) == FTDM_FAIL) { @@ -35,7 +35,7 @@ static void *test_call(ftdm_thread_t *me, void *obj) } } - if (ftdm_channel_call_active(chan)) { + if (ftdm_channel_call_check_answered(chan)) { ftdm_channel_call_indicate(chan, FTDM_CHANNEL_INDICATE_BUSY); }