freetdm: completion of compilation with initial reworked API

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)) {
+				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), "LOOP/");
+					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)) {
+				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), "RECOVER/");
+					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;
 }
 

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(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan);
-FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(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

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

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

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