retronetworking
/
freeswitch
13
0
Fork 0
Code Pull Requests Releases Activity

freetdm: completion of compilation with initial reworked API

This commit is contained in:
Moises Silva 2010-04-21 11:20:05 -04:00
parent 73a80ba939
commit c165771474
6 changed files with 857 additions and 400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

706
libs/freetdm/mod_freetdm/mod_freetdm.c
View File

File diff suppressed because it is too large Load Diff

322
libs/freetdm/src/ftdm_io.c
View File

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

132
libs/freetdm/src/include/freetdm.h
View File

@ -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

12
libs/freetdm/src/include/private/ftdm_core.h
View File

@ -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

81
libs/freetdm/src/include/private/ftdm_types.h
View File

@ -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

4
libs/freetdm/src/testanalog.c
View File

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