freetdm.h File Reference


Data Structures

struct  ftdm_queue_handler
struct  ftdm_caller_data
 Caller information. More...
struct  ftdm_span_hunt_t
 Structure used for FTDM_HUNT_SPAN mode. More...
struct  ftdm_group_hunt_t
 Structure used for FTDM_HUNT_GROUP mode. More...
struct  ftdm_chan_hunt_t
 Structure used for FTDM_HUNT_CHAN mode. More...
struct  ftdm_hunting_scheme_t
 Channel Hunting provided to ftdm_call_place(). More...
struct  ftdm_event_collected_t
struct  ftdm_sigmsg
 Generic signaling message. More...
struct  ftdm_conf_parameter
 Signaling configuration parameter for the stacks (variable=value pair). More...
struct  ftdm_memory_handler
struct  ftdm_io_interface
 FreeTDM I/O layer function prototype wrapper macros You don't need these unless your implementing an I/O interface module (most users don't). More...

Defines

#define FTDM_MAX_CHANNELS_PHYSICAL_SPAN   32
 Max number of channels per physical span.
#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN   32
 Max number of physical spans per logical span.
#define FTDM_MAX_CHANNELS_SPAN   FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN
 Max number of channels a logical span can contain.
#define FTDM_MAX_SPANS_INTERFACE   128
 Max number of logical spans.
#define FTDM_MAX_CHANNELS_GROUP   1024
 Max number of channels per hunting group.
#define FTDM_MAX_GROUPS_INTERFACE   FTDM_MAX_SPANS_INTERFACE
 Max number of groups.
#define FTDM_INVALID_INT_PARM   0xFF
#define FTDM_MAX_NAME_STR_SZ   80
 Thread/Mutex OS abstraction API. Limit to span names.
#define FTDM_MAX_NUMBER_STR_SZ   20
 Limit to channel number strings.
#define CHAN_TYPE_STRINGS   "B", "DQ921", "DQ931", "FXS", "FXO", "EM", "CAS", "INVALID"
#define FTDM_IS_VOICE_CHANNEL(ftdm_chan)   ((ftdm_chan)->type != FTDM_CHAN_TYPE_DQ921 && (ftdm_chan)->type != FTDM_CHAN_TYPE_DQ931)
#define FTDM_IS_DCHAN(ftdm_chan)   ((ftdm_chan)->type == FTDM_CHAN_TYPE_DQ921 || (ftdm_chan)->type == FTDM_CHAN_TYPE_DQ931)
#define TON_STRINGS   "unknown", "international", "national", "network-specific", "subscriber-number", "abbreviated-number", "reserved", "invalid"
#define NPI_STRINGS   "unknown", "ISDN", "data", "telex", "national", "private", "reserved", "invalid"
#define PRESENTATION_STRINGS   "presentation-allowed", "presentation-restricted", "number-not-available", "reserved", "Invalid"
#define SCREENING_STRINGS   "user-provided-not-screened", "user-provided-verified-and-passed", "user-provided-verified-and-failed", "network-provided", "invalid"
#define BEARER_CAP_STRINGS   "speech", "unrestricted-digital-information", "3.1-Khz-audio", "invalid"
#define USER_LAYER1_PROT_STRINGS   "V.110", "u-law", "a-law", "Invalid"
#define CALLING_PARTY_CATEGORY_STRINGS   "unknown", "operator", "ordinary", "priority", "data-call", "test-call", "payphone", "invalid"
#define FTDM_DIGITS_LIMIT   25
#define SIGNAL_STRINGS
#define TRUNK_STRINGS   "E1", "T1", "J1", "BRI", "BRI_PTMP", "FXO", "FXS", "EM", "NONE"
#define SIGSTATUS_STRINGS   "DOWN", "SUSPENDED", "UP", "INVALID"
#define TRACE_DIR_STRINGS   "INCOMING", "OUTGOING", "INVALID"
#define TRACE_TYPE_STRINGS   "Q931", "Q921", "INVALID"
#define INDICATION_STRINGS   "NONE", "RINGING", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "BUSY", "ANSWER", "INVALID"
#define FIO_CHANNEL_REQUEST_ARGS   (ftdm_span_t *span, uint32_t chan_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan)
 FreeTDM I/O layer interface argument macros You don't need these unless your implementing an I/O interface module (most users don't).
#define FIO_CHANNEL_OUTGOING_CALL_ARGS   (ftdm_channel_t *ftdmchan)
#define FIO_CHANNEL_SEND_MSG_ARGS   (ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)
#define FIO_CHANNEL_SET_SIG_STATUS_ARGS   (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)
#define FIO_CHANNEL_GET_SIG_STATUS_ARGS   (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status)
#define FIO_SPAN_SET_SIG_STATUS_ARGS   (ftdm_span_t *span, ftdm_signaling_status_t status)
#define FIO_SPAN_GET_SIG_STATUS_ARGS   (ftdm_span_t *span, ftdm_signaling_status_t *status)
#define FIO_SPAN_POLL_EVENT_ARGS   (ftdm_span_t *span, uint32_t ms, short *poll_events)
#define FIO_SPAN_NEXT_EVENT_ARGS   (ftdm_span_t *span, ftdm_event_t **event)
#define FIO_CHANNEL_NEXT_EVENT_ARGS   (ftdm_channel_t *ftdmchan, ftdm_event_t **event)
#define FIO_SIGNAL_CB_ARGS   (ftdm_sigmsg_t *sigmsg)
#define FIO_EVENT_CB_ARGS   (ftdm_channel_t *ftdmchan, ftdm_event_t *event)
#define FIO_CONFIGURE_SPAN_ARGS   (ftdm_span_t *span, const char *str, ftdm_chan_type_t type, char *name, char *number)
#define FIO_CONFIGURE_ARGS   (const char *category, const char *var, const char *val, int lineno)
#define FIO_OPEN_ARGS   (ftdm_channel_t *ftdmchan)
#define FIO_CLOSE_ARGS   (ftdm_channel_t *ftdmchan)
#define FIO_CHANNEL_DESTROY_ARGS   (ftdm_channel_t *ftdmchan)
#define FIO_SPAN_DESTROY_ARGS   (ftdm_span_t *span)
#define FIO_COMMAND_ARGS   (ftdm_channel_t *ftdmchan, ftdm_command_t command, void *obj)
#define FIO_WAIT_ARGS   (ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t to)
#define FIO_GET_ALARMS_ARGS   (ftdm_channel_t *ftdmchan)
#define FIO_READ_ARGS   (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)
#define FIO_WRITE_ARGS   (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)
#define FIO_IO_LOAD_ARGS   (ftdm_io_interface_t **fio)
#define FIO_IO_UNLOAD_ARGS   (void)
#define FIO_SIG_LOAD_ARGS   (void)
#define FIO_SIG_CONFIGURE_ARGS   (ftdm_span_t *span, fio_signal_cb_t sig_cb, va_list ap)
#define FIO_CONFIGURE_SPAN_SIGNALING_ARGS   (ftdm_span_t *span, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *ftdm_parameters)
#define FIO_SIG_UNLOAD_ARGS   (void)
#define FIO_API_ARGS   (ftdm_stream_handle_t *stream, const char *data)
#define FIO_CHANNEL_REQUEST_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_REQUEST_ARGS
 FreeTDM I/O layer interface function prototype wrapper macros You don't need these unless your implementing an I/O interface module (most users don't).
#define FIO_CHANNEL_OUTGOING_CALL_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_OUTGOING_CALL_ARGS
#define FIO_CHANNEL_SEND_MSG_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_SEND_MSG_ARGS
#define FIO_CHANNEL_SET_SIG_STATUS_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_SET_SIG_STATUS_ARGS
#define FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_GET_SIG_STATUS_ARGS
#define FIO_SPAN_SET_SIG_STATUS_FUNCTION(name)   ftdm_status_t name FIO_SPAN_SET_SIG_STATUS_ARGS
#define FIO_SPAN_GET_SIG_STATUS_FUNCTION(name)   ftdm_status_t name FIO_SPAN_GET_SIG_STATUS_ARGS
#define FIO_SPAN_POLL_EVENT_FUNCTION(name)   ftdm_status_t name FIO_SPAN_POLL_EVENT_ARGS
#define FIO_SPAN_NEXT_EVENT_FUNCTION(name)   ftdm_status_t name FIO_SPAN_NEXT_EVENT_ARGS
#define FIO_CHANNEL_NEXT_EVENT_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_NEXT_EVENT_ARGS
#define FIO_SIGNAL_CB_FUNCTION(name)   ftdm_status_t name FIO_SIGNAL_CB_ARGS
#define FIO_EVENT_CB_FUNCTION(name)   ftdm_status_t name FIO_EVENT_CB_ARGS
#define FIO_CONFIGURE_SPAN_FUNCTION(name)   ftdm_status_t name FIO_CONFIGURE_SPAN_ARGS
#define FIO_CONFIGURE_FUNCTION(name)   ftdm_status_t name FIO_CONFIGURE_ARGS
#define FIO_OPEN_FUNCTION(name)   ftdm_status_t name FIO_OPEN_ARGS
#define FIO_CLOSE_FUNCTION(name)   ftdm_status_t name FIO_CLOSE_ARGS
#define FIO_CHANNEL_DESTROY_FUNCTION(name)   ftdm_status_t name FIO_CHANNEL_DESTROY_ARGS
#define FIO_SPAN_DESTROY_FUNCTION(name)   ftdm_status_t name FIO_SPAN_DESTROY_ARGS
#define FIO_GET_ALARMS_FUNCTION(name)   ftdm_status_t name FIO_GET_ALARMS_ARGS
#define FIO_COMMAND_FUNCTION(name)   ftdm_status_t name FIO_COMMAND_ARGS
#define FIO_WAIT_FUNCTION(name)   ftdm_status_t name FIO_WAIT_ARGS
#define FIO_READ_FUNCTION(name)   ftdm_status_t name FIO_READ_ARGS
#define FIO_WRITE_FUNCTION(name)   ftdm_status_t name FIO_WRITE_ARGS
#define FIO_IO_LOAD_FUNCTION(name)   ftdm_status_t name FIO_IO_LOAD_ARGS
#define FIO_SIG_LOAD_FUNCTION(name)   ftdm_status_t name FIO_SIG_LOAD_ARGS
#define FIO_SIG_CONFIGURE_FUNCTION(name)   ftdm_status_t name FIO_SIG_CONFIGURE_ARGS
#define FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION(name)   ftdm_status_t name FIO_CONFIGURE_SPAN_SIGNALING_ARGS
#define FIO_IO_UNLOAD_FUNCTION(name)   ftdm_status_t name FIO_IO_UNLOAD_ARGS
#define FIO_SIG_UNLOAD_FUNCTION(name)   ftdm_status_t name FIO_SIG_UNLOAD_ARGS
#define FIO_API_FUNCTION(name)   ftdm_status_t name FIO_API_ARGS
#define ftdm_channel_call_answer(ftdmchan)   _ftdm_channel_call_answer(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
 Answer call. This can also be accomplished by ftdm_channel_call_indicate with FTDM_CHANNEL_INDICATE_ANSWER, in both cases you will get a FTDM_SIGEVENT_INDICATION_COMPLETED when the indication is sent (or an error occurs). Just as with ftdm_channel_call_indicate you won't receive FTDM_SIGEVENT_INDICATION_COMPLETED when this function returns anything else than FTDM_SUCCESS.
#define ftdm_channel_call_place(ftdmchan)   _ftdm_channel_call_place(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
 Place an outgoing call in the given channel.
#define ftdm_call_place(callerdata, hunting)   _ftdm_call_place(__FILE__, __FUNCTION__, __LINE__, (callerdata), (hunting))
 Place an outgoing call with the given caller data in a channel according to the hunting scheme provided.
#define ftdm_channel_call_indicate(ftdmchan, indication)   _ftdm_channel_call_indicate(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (indication))
 Indicate a new condition in an incoming call.
#define ftdm_channel_call_send_msg(ftdmchan, sigmsg)   _ftdm_channel_call_send_msg(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (sigmsg))
 Send a message on a call.
#define ftdm_channel_call_hangup(ftdmchan)   _ftdm_channel_call_hangup(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
 Hangup the call without cause.
#define ftdm_channel_call_hangup_with_cause(ftdmchan, cause)   _ftdm_channel_call_hangup_with_cause(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (cause))
 Hangup the call with cause.
#define ftdm_channel_reset(ftdmchan)   _ftdm_channel_reset(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
 Reset the channel.
#define ftdm_channel_call_hold(ftdmchan)   _ftdm_channel_call_hold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
 Put a call on hold (if supported by the signaling stack).
#define ftdm_channel_call_unhold(ftdmchan)   _ftdm_channel_call_unhold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))
 Unhold a call.
#define FTDM_TAG_END   NULL
#define FIO_CODEC_ARGS   (void *data, ftdm_size_t max, ftdm_size_t *datalen)
 Basic transcoding function prototype.
#define FIO_CODEC_FUNCTION(name)   FT_DECLARE_NONSTD(ftdm_status_t) name FIO_CODEC_ARGS
#define FTDM_PRE   __FILE__, __FUNCTION__, __LINE__
#define FTDM_LOG_LEVEL_DEBUG   7
#define FTDM_LOG_LEVEL_INFO   6
#define FTDM_LOG_LEVEL_NOTICE   5
#define FTDM_LOG_LEVEL_WARNING   4
#define FTDM_LOG_LEVEL_ERROR   3
#define FTDM_LOG_LEVEL_CRIT   2
#define FTDM_LOG_LEVEL_ALERT   1
#define FTDM_LOG_LEVEL_EMERG   0
#define FTDM_LOG_DEBUG   FTDM_PRE, FTDM_LOG_LEVEL_DEBUG
 Log levels.
#define FTDM_LOG_INFO   FTDM_PRE, FTDM_LOG_LEVEL_INFO
#define FTDM_LOG_NOTICE   FTDM_PRE, FTDM_LOG_LEVEL_NOTICE
#define FTDM_LOG_WARNING   FTDM_PRE, FTDM_LOG_LEVEL_WARNING
#define FTDM_LOG_ERROR   FTDM_PRE, FTDM_LOG_LEVEL_ERROR
#define FTDM_LOG_CRIT   FTDM_PRE, FTDM_LOG_LEVEL_CRIT
#define FTDM_LOG_ALERT   FTDM_PRE, FTDM_LOG_LEVEL_ALERT
#define FTDM_LOG_EMERG   FTDM_PRE, FTDM_LOG_LEVEL_EMERG

Typedefs

typedef ftdm_status_t(*) ftdm_queue_enqueue_func_t (ftdm_queue_t *queue, void *obj)
typedef void *(*) ftdm_queue_dequeue_func_t (ftdm_queue_t *queue)
typedef ftdm_status_t(*) ftdm_queue_wait_func_t (ftdm_queue_t *queue, int ms)
typedef ftdm_status_t(*) ftdm_queue_get_interrupt_func_t (ftdm_queue_t *queue, ftdm_interrupt_t **interrupt)
typedef ftdm_status_t(*) ftdm_queue_destroy_func_t (ftdm_queue_t **queue)
typedef ftdm_queue_handler ftdm_queue_handler_t
typedef void * ftdm_variable_container_t
typedef ftdm_caller_data ftdm_caller_data_t
 Caller information.
typedef ftdm_status_t(*) ftdm_hunt_result_cb_t (ftdm_channel_t *fchan, ftdm_caller_data_t *caller_data)
 Function called before placing the call in the hunted channel The user can have a last saying in whether to proceed or abort the call attempt. Be aware that this callback will be called with the channel lock and you must not do any blocking operations during its execution.
typedef ftdm_conf_parameter ftdm_conf_parameter_t
 Signaling configuration parameter for the stacks (variable=value pair).
typedef ftdm_iterator ftdm_iterator_t
 Opaque general purpose iterator.
typedef void *(*) ftdm_malloc_func_t (void *pool, ftdm_size_t len)
 Custom memory handler hooks. Not recommended to use unless you need memory allocation customizations.
typedef void *(*) ftdm_calloc_func_t (void *pool, ftdm_size_t elements, ftdm_size_t len)
typedef void *(*) ftdm_realloc_func_t (void *pool, void *buff, ftdm_size_t len)
typedef void(*) ftdm_free_func_t (void *pool, void *ptr)
typedef ftdm_status_t(*) fio_channel_request_t (ftdm_span_t *span, uint32_t chan_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan)
 FreeTDM I/O layer interface function typedefs You don't need these unless your implementing an I/O interface module (most users don't).
typedef ftdm_status_t(*) fio_channel_outgoing_call_t (ftdm_channel_t *ftdmchan)
typedef ftdm_status_t(*) fio_channel_send_msg_t (ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)
typedef ftdm_status_t(*) fio_channel_set_sig_status_t (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)
typedef ftdm_status_t(*) fio_channel_get_sig_status_t (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status)
typedef ftdm_status_t(*) fio_span_set_sig_status_t (ftdm_span_t *span, ftdm_signaling_status_t status)
typedef ftdm_status_t(*) fio_span_get_sig_status_t (ftdm_span_t *span, ftdm_signaling_status_t *status)
typedef ftdm_status_t(*) fio_span_poll_event_t (ftdm_span_t *span, uint32_t ms, short *poll_events)
typedef ftdm_status_t(*) fio_span_next_event_t (ftdm_span_t *span, ftdm_event_t **event)
typedef ftdm_status_t(*) fio_channel_next_event_t (ftdm_channel_t *ftdmchan, ftdm_event_t **event)
typedef ftdm_status_t(*) fio_signal_cb_t (ftdm_sigmsg_t *sigmsg)
 Callback for signal delivery (FTDM_SIGEVENT_START and friends).
typedef ftdm_status_t(*) fio_event_cb_t (ftdm_channel_t *ftdmchan, ftdm_event_t *event)
typedef ftdm_status_t(*) fio_configure_span_t (ftdm_span_t *span, const char *str, ftdm_chan_type_t type, char *name, char *number)
typedef ftdm_status_t(*) fio_configure_t (const char *category, const char *var, const char *val, int lineno)
typedef ftdm_status_t(*) fio_open_t (ftdm_channel_t *ftdmchan)
typedef ftdm_status_t(*) fio_close_t (ftdm_channel_t *ftdmchan)
typedef ftdm_status_t(*) fio_channel_destroy_t (ftdm_channel_t *ftdmchan)
typedef ftdm_status_t(*) fio_span_destroy_t (ftdm_span_t *span)
typedef ftdm_status_t(*) fio_get_alarms_t (ftdm_channel_t *ftdmchan)
typedef ftdm_status_t(*) fio_command_t (ftdm_channel_t *ftdmchan, ftdm_command_t command, void *obj)
typedef ftdm_status_t(*) fio_wait_t (ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t to)
typedef ftdm_status_t(*) fio_read_t (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)
typedef ftdm_status_t(*) fio_write_t (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)
typedef ftdm_status_t(*) fio_io_load_t (ftdm_io_interface_t **fio)
typedef ftdm_status_t(*) fio_sig_load_t (void)
typedef ftdm_status_t(*) fio_sig_configure_t (ftdm_span_t *span, fio_signal_cb_t sig_cb, va_list ap)
typedef ftdm_status_t(*) fio_configure_span_signaling_t (ftdm_span_t *span, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *ftdm_parameters)
typedef ftdm_status_t(*) fio_io_unload_t (void)
typedef ftdm_status_t(*) fio_sig_unload_t (void)
typedef ftdm_status_t(*) fio_api_t (ftdm_stream_handle_t *stream, const char *data)
typedef ftdm_status_t(*) fio_codec_t (void *data, ftdm_size_t max, ftdm_size_t *datalen)

Enumerations

enum  ftdm_call_cause_t {
  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
}
 Hangup cause codes. More...
enum  ftdm_direction_t { FTDM_TOP_DOWN, FTDM_BOTTOM_UP, FTDM_RR_DOWN, FTDM_RR_UP }
 Hunting direction (when hunting for free channels). More...
enum  ftdm_chan_type_t {
  FTDM_CHAN_TYPE_B, FTDM_CHAN_TYPE_DQ921, FTDM_CHAN_TYPE_DQ931, FTDM_CHAN_TYPE_FXS,
  FTDM_CHAN_TYPE_FXO, FTDM_CHAN_TYPE_EM, FTDM_CHAN_TYPE_CAS, FTDM_CHAN_TYPE_COUNT
}
 I/O channel type. More...
enum  ftdm_ton_t {
  FTDM_TON_UNKNOWN = 0, FTDM_TON_INTERNATIONAL, FTDM_TON_NATIONAL, FTDM_TON_NETWORK_SPECIFIC,
  FTDM_TON_SUBSCRIBER_NUMBER, FTDM_TON_ABBREVIATED_NUMBER, FTDM_TON_RESERVED, FTDM_TON_INVALID
}
 Type Of Number (TON). More...
enum  ftdm_hunt_mode_t { FTDM_HUNT_SPAN, FTDM_HUNT_GROUP, FTDM_HUNT_CHAN }
 Hunting mode. More...
enum  ftdm_tone_type_t { FTDM_TONE_DTMF = (1 << 0) }
 Tone type. More...
enum  ftdm_signal_event_t {
  FTDM_SIGEVENT_START, FTDM_SIGEVENT_STOP, FTDM_SIGEVENT_RELEASED, FTDM_SIGEVENT_UP,
  FTDM_SIGEVENT_FLASH, FTDM_SIGEVENT_PROCEED, FTDM_SIGEVENT_RINGING, FTDM_SIGEVENT_PROGRESS,
  FTDM_SIGEVENT_PROGRESS_MEDIA, FTDM_SIGEVENT_ALARM_TRAP, FTDM_SIGEVENT_ALARM_CLEAR, FTDM_SIGEVENT_COLLECTED_DIGIT,
  FTDM_SIGEVENT_ADD_CALL, FTDM_SIGEVENT_RESTART, FTDM_SIGEVENT_SIGSTATUS_CHANGED, FTDM_SIGEVENT_COLLISION,
  FTDM_SIGEVENT_FACILITY, FTDM_SIGEVENT_TRACE, FTDM_SIGEVENT_TRACE_RAW, FTDM_SIGEVENT_INDICATION_COMPLETED,
  FTDM_SIGEVENT_DIALING, FTDM_SIGEVENT_INVALID
}
 Signaling messages sent by the stacks. More...
enum  ftdm_signaling_status_t { FTDM_SIG_STATE_DOWN, FTDM_SIG_STATE_SUSPENDED, FTDM_SIG_STATE_UP, FTDM_SIG_STATE_INVALID }
 Signaling status on a given span or specific channel on protocols that support it. More...
enum  ftdm_trace_dir_t { FTDM_TRACE_DIR_INCOMING, FTDM_TRACE_DIR_OUTGOING, FTDM_TRACE_DIR_INVALID }
enum  ftdm_channel_indication_t {
  FTDM_CHANNEL_INDICATE_NONE, FTDM_CHANNEL_INDICATE_RINGING, FTDM_CHANNEL_INDICATE_PROCEED, FTDM_CHANNEL_INDICATE_PROGRESS,
  FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA, FTDM_CHANNEL_INDICATE_BUSY, FTDM_CHANNEL_INDICATE_ANSWER, FTDM_CHANNEL_INDICATE_INVALID
}
 FreeTDM supported indications. This is used during incoming calls when you want to request the signaling stack to notify about indications occurring locally. See ftdm_channel_call_indicate for more info. More...
enum  ftdm_crash_policy_t { FTDM_CRASH_NEVER = 0, FTDM_CRASH_ON_ASSERT }
 Crash policy Useful for debugging only, default policy is never, if you wish to crash on asserts then use ftdm_global_set_crash_policy. More...
enum  ftdm_wait_flag_t { FTDM_NO_FLAGS = 0, FTDM_READ = (1 << 0), FTDM_WRITE = (1 << 1), FTDM_EVENTS = (1 << 2) }
 I/O waiting flags. More...
enum  ftdm_command_t {
  FTDM_COMMAND_NOOP, FTDM_COMMAND_SET_INTERVAL, FTDM_COMMAND_GET_INTERVAL, FTDM_COMMAND_SET_CODEC,
  FTDM_COMMAND_GET_CODEC, FTDM_COMMAND_SET_NATIVE_CODEC, FTDM_COMMAND_GET_NATIVE_CODEC, FTDM_COMMAND_ENABLE_DTMF_DETECT,
  FTDM_COMMAND_DISABLE_DTMF_DETECT, FTDM_COMMAND_SEND_DTMF, FTDM_COMMAND_SET_DTMF_ON_PERIOD, FTDM_COMMAND_GET_DTMF_ON_PERIOD,
  FTDM_COMMAND_SET_DTMF_OFF_PERIOD, FTDM_COMMAND_GET_DTMF_OFF_PERIOD, FTDM_COMMAND_GENERATE_RING_ON, FTDM_COMMAND_GENERATE_RING_OFF,
  FTDM_COMMAND_OFFHOOK, FTDM_COMMAND_ONHOOK, FTDM_COMMAND_FLASH, FTDM_COMMAND_WINK,
  FTDM_COMMAND_ENABLE_PROGRESS_DETECT, FTDM_COMMAND_DISABLE_PROGRESS_DETECT, FTDM_COMMAND_TRACE_INPUT, FTDM_COMMAND_TRACE_OUTPUT,
  FTDM_COMMAND_TRACE_END_ALL, FTDM_COMMAND_ENABLE_DEBUG_DTMF, FTDM_COMMAND_DISABLE_DEBUG_DTMF, FTDM_COMMAND_ENABLE_INPUT_DUMP,
  FTDM_COMMAND_DISABLE_INPUT_DUMP, FTDM_COMMAND_ENABLE_OUTPUT_DUMP, FTDM_COMMAND_DISABLE_OUTPUT_DUMP, FTDM_COMMAND_DUMP_INPUT,
  FTDM_COMMAND_DUMP_OUTPUT, FTDM_COMMAND_ENABLE_CALLERID_DETECT, FTDM_COMMAND_DISABLE_CALLERID_DETECT, FTDM_COMMAND_ENABLE_ECHOCANCEL,
  FTDM_COMMAND_DISABLE_ECHOCANCEL, FTDM_COMMAND_ENABLE_ECHOTRAIN, FTDM_COMMAND_DISABLE_ECHOTRAIN, FTDM_COMMAND_SET_CAS_BITS,
  FTDM_COMMAND_GET_CAS_BITS, FTDM_COMMAND_SET_RX_GAIN, FTDM_COMMAND_GET_RX_GAIN, FTDM_COMMAND_SET_TX_GAIN,
  FTDM_COMMAND_GET_TX_GAIN, FTDM_COMMAND_FLUSH_TX_BUFFERS, FTDM_COMMAND_FLUSH_RX_BUFFERS, FTDM_COMMAND_FLUSH_BUFFERS,
  FTDM_COMMAND_FLUSH_IOSTATS, FTDM_COMMAND_SET_PRE_BUFFER_SIZE, FTDM_COMMAND_SET_LINK_STATUS, FTDM_COMMAND_GET_LINK_STATUS,
  FTDM_COMMAND_ENABLE_LOOP, FTDM_COMMAND_DISABLE_LOOP, FTDM_COMMAND_SET_RX_QUEUE_SIZE, FTDM_COMMAND_SET_TX_QUEUE_SIZE,
  FTDM_COMMAND_SET_POLARITY, FTDM_COMMAND_COUNT
}
 Channel commands that can be executed through ftdm_channel_command(). More...
enum  ftdm_polarity_t { FTDM_POLARITY_FORWARD = 0, FTDM_POLARITY_REVERSE = 1 }
enum  ftdm_codec_t { FTDM_CODEC_ULAW = 0, FTDM_CODEC_ALAW = 8, FTDM_CODEC_SLIN = 10, FTDM_CODEC_NONE = (1 << 30) }
 FreeTDM supported I/O codecs. More...
enum  ftdm_alarm_flag_t {
  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)
}
 FreeTDM supported hardware alarms. More...

Functions

 FTDM_STR2ENUM_P (ftdm_str2ftdm_chan_type, ftdm_chan_type2str, ftdm_chan_type_t) typedef void(*ftdm_logger_t)(const char *file
 transform from channel type to string and from string to channel type ftdm_str2ftdm_chan_type transforms a channel string (ie: "FXO" to FTDM_CHAN_TYPE_FXO) ftdm_chan_type2str transforms a channel type to string (ie: FTDM_CHAN_TYPE_B to "B") Test if a channel is a voice channel Test if a channel is a D-channel Logging function prototype to be used for all FreeTDM logs you should use ftdm_global_set_logger to set your own logger
 FTDM_STR2ENUM_P (ftdm_str2ftdm_ton, ftdm_ton2str, ftdm_ton_t) typedef enum
 FTDM_STR2ENUM_P (ftdm_str2ftdm_npi, ftdm_npi2str, ftdm_npi_t) typedef enum
 FTDM_STR2ENUM_P (ftdm_str2ftdm_presentation, ftdm_presentation2str, ftdm_presentation_t) typedef enum
 FTDM_STR2ENUM_P (ftdm_str2ftdm_screening, ftdm_screening2str, ftdm_screening_t) typedef enum
 bearer capability
 FTDM_STR2ENUM_P (ftdm_str2ftdm_bearer_cap, ftdm_bearer_cap2str, ftdm_bearer_cap_t) typedef enum
 user information layer 1 protocol
 FTDM_STR2ENUM_P (ftdm_str2ftdm_usr_layer1_prot, ftdm_user_layer1_prot2str, ftdm_user_layer1_prot_t) typedef enum
 FTDM_STR2ENUM_P (ftdm_str2ftdm_calling_party_category, ftdm_calling_party_category2str, ftdm_calling_party_category_t) typedef struct
 Digit limit used in DNIS/ANI Number abstraction.
 FTDM_STR2ENUM_P (ftdm_str2ftdm_signal_event, ftdm_signal_event2str, ftdm_signal_event_t) typedef enum
 Move from string to ftdm_signal_event_t and viceversa Span trunk types.
 FTDM_STR2ENUM_P (ftdm_str2ftdm_trunk_type, ftdm_trunk_type2str, ftdm_trunk_type_t) typedef struct ftdm_channel_config
 Move from string to ftdm_trunk_type_t and viceversa Basic channel configuration provided to ftdm_configure_span_channels.
 FTDM_STR2ENUM_P (ftdm_str2ftdm_signaling_status, ftdm_signaling_status2str, ftdm_signaling_status_t) typedef struct
 Move from string to ftdm_signaling_status_t and viceversa.
 FTDM_STR2ENUM_P (ftdm_str2ftdm_trace_dir, ftdm_trace_dir2str, ftdm_trace_dir_t) typedef enum
 Move string to ftdm_trace_dir_t and viceversa.
 FTDM_STR2ENUM_P (ftdm_str2ftdm_trace_type, ftdm_trace_type2str, ftdm_trace_type_t) typedef struct
 Move string to ftdm_trace_type_t and viceversa.
 FTDM_STR2ENUM_P (ftdm_str2channel_indication, ftdm_channel_indication2str, ftdm_channel_indication_t) typedef struct
 Move from string to ftdm_channel_indication_t and viceversa.
ftdm_status_t ftdm_global_set_queue_handler (ftdm_queue_handler_t *handler)
 Override the default queue handler.
int ftdm_channel_get_availability (ftdm_channel_t *ftdmchan)
 Return the availability rate for a channel.
ftdm_status_t _ftdm_channel_call_answer (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
 Answer call recording the source code point where the it was called (see ftdm_channel_call_answer for an easy to use macro).
ftdm_status_t _ftdm_channel_call_place (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
 Place an outgoing call recording the source code point where it was called (see ftdm_channel_call_place for an easy to use macro).
ftdm_status_t _ftdm_call_place (const char *file, const char *func, int line, ftdm_caller_data_t *caller_data, ftdm_hunting_scheme_t *hunting)
 Place an outgoing call with the given caller data in a channel according to the hunting scheme provided and records the place where it was called. See ftdm_call_place for an easy to use macro.
ftdm_status_t _ftdm_channel_call_indicate (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication)
 Indicate a new condition in an incoming call recording the source code point where it was called (see ftdm_channel_call_indicate for an easy to use macro).
ftdm_status_t _ftdm_channel_call_send_msg (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)
 Send a signal on a call recording the source code point where it was called (see ftdm_channel_call_send_msg for an easy to use macro).
ftdm_status_t _ftdm_channel_call_hangup (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
 Hangup the call without cause recording the source code point where it was called (see ftdm_channel_call_hangup for an easy to use macro).
ftdm_status_t _ftdm_channel_call_hangup_with_cause (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan, ftdm_call_cause_t)
 Hangup the call with cause recording the source code point where it was called (see ftdm_channel_call_hangup_with_cause for an easy to use macro).
ftdm_status_t _ftdm_channel_reset (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
 Reset the channel (see _ftdm_channel_reset for an easy to use macro).
ftdm_status_t _ftdm_channel_call_hold (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
 Put a call on hold recording the source code point where it was called (see ftdm_channel_call_hold for an easy to use macro).
ftdm_status_t _ftdm_channel_call_unhold (const char *file, const char *func, int line, ftdm_channel_t *ftdmchan)
 Unhold a call recording the source code point where it was called (see ftdm_channel_call_unhold for an easy to use macro).
ftdm_bool_t ftdm_channel_call_check_answered (const ftdm_channel_t *ftdmchan)
 Check if the call is answered already.
ftdm_bool_t ftdm_channel_call_check_busy (const ftdm_channel_t *ftdmchan)
 Check if the call is busy.
ftdm_bool_t ftdm_channel_call_check_hangup (const ftdm_channel_t *ftdmchan)
 Check if the call is hangup.
ftdm_bool_t ftdm_channel_call_check_done (const ftdm_channel_t *ftdmchan)
 Check if the call is done (final state for a call, just after hangup).
ftdm_bool_t ftdm_channel_call_check_hold (const ftdm_channel_t *ftdmchan)
 Check if the call is in hold.
ftdm_status_t ftdm_channel_set_sig_status (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)
 Set channel signaling status (ie: put specific circuit down) only if supported by the signaling.
ftdm_status_t ftdm_channel_get_sig_status (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status)
 Get channel signaling status (ie: whether protocol layer is up or down).
ftdm_status_t ftdm_span_set_sig_status (ftdm_span_t *span, ftdm_signaling_status_t status)
 Set span signaling status (ie: put the whole span protocol layer down) only if supported by the signaling.
ftdm_status_t ftdm_span_get_sig_status (ftdm_span_t *span, ftdm_signaling_status_t *status)
 Get span signaling status (ie: whether protocol layer is up or down).
void ftdm_channel_set_private (ftdm_channel_t *ftdmchan, void *pvt)
 Set user private data in the channel.
void * ftdm_channel_get_private (const ftdm_channel_t *ftdmchan)
 Get user private data in the channel.
ftdm_status_t ftdm_channel_clear_token (ftdm_channel_t *ftdmchan, const char *token)
 Remove the given token from the channel.
void ftdm_channel_replace_token (ftdm_channel_t *ftdmchan, const char *old_token, const char *new_token)
 Replace the given token with the new token.
ftdm_status_t ftdm_channel_add_token (ftdm_channel_t *ftdmchan, char *token, int end)
 Add a new token to the channel.
const char * ftdm_channel_get_token (const ftdm_channel_t *ftdmchan, uint32_t tokenid)
 Get the requested token.
uint32_t ftdm_channel_get_token_count (const ftdm_channel_t *ftdmchan)
 Get the token count.
uint32_t ftdm_channel_get_io_interval (const ftdm_channel_t *ftdmchan)
 Get the I/O read/write interval.
uint32_t ftdm_channel_get_io_packet_len (const ftdm_channel_t *ftdmchan)
 Get the I/O read/write packet length per interval.
ftdm_codec_t ftdm_channel_get_codec (const ftdm_channel_t *ftdmchan)
 Get the I/O read/write codec.
const char * ftdm_channel_get_last_error (const ftdm_channel_t *ftdmchan)
 Get the last error string for the channel.
ftdm_status_t ftdm_channel_get_alarms (ftdm_channel_t *ftdmchan, ftdm_alarm_flag_t *alarmbits)
 Get the current alarm bitmask for the channel.
ftdm_chan_type_t ftdm_channel_get_type (const ftdm_channel_t *ftdmchan)
 Get the channel type.
ftdm_size_t ftdm_channel_dequeue_dtmf (ftdm_channel_t *ftdmchan, char *dtmf, ftdm_size_t len)
 Dequeue DTMF from the given channel.
void ftdm_channel_flush_dtmf (ftdm_channel_t *ftdmchan)
 Flush the DTMF queue.
ftdm_status_t ftdm_span_poll_event (ftdm_span_t *span, uint32_t ms, short *poll_events)
 Wait for an event in the span.
ftdm_status_t ftdm_span_find (uint32_t id, ftdm_span_t **span)
 Find a span by its id.
const char * ftdm_span_get_last_error (const ftdm_span_t *span)
 Get the last error string for the given span.
ftdm_status_t ftdm_span_create (const char *iotype, const char *name, ftdm_span_t **span)
 Create a new span (not needed if you are using freetdm.conf).
ftdm_status_t ftdm_span_add_channel (ftdm_span_t *span, ftdm_socket_t sockfd, ftdm_chan_type_t type, ftdm_channel_t **chan)
 Add a new channel to a span.
ftdm_status_t ftdm_channel_add_to_group (const char *name, ftdm_channel_t *ftdmchan)
 Add the channel to a hunt group.
ftdm_status_t ftdm_channel_remove_from_group (ftdm_group_t *group, ftdm_channel_t *ftdmchan)
 Remove the channel from a hunt group.
ftdm_status_t ftdm_channel_read_event (ftdm_channel_t *ftdmchan, ftdm_event_t **event)
 Retrieves an event from the span.
ftdm_status_t ftdm_group_find (uint32_t id, ftdm_group_t **group)
 Find a hunt group by id.
ftdm_status_t ftdm_group_find_by_name (const char *name, ftdm_group_t **group)
 Find a hunt group by name.
ftdm_status_t ftdm_group_create (ftdm_group_t **group, const char *name)
 Create a group with the given name.
ftdm_status_t ftdm_span_channel_use_count (ftdm_span_t *span, uint32_t *count)
 Get the number of channels in use on a span.
ftdm_status_t ftdm_group_channel_use_count (ftdm_group_t *group, uint32_t *count)
 Get the number of channels in use on a group.
uint32_t ftdm_group_get_id (const ftdm_group_t *group)
 Get the id of a group.
ftdm_status_t ftdm_channel_open (uint32_t span_id, uint32_t chan_id, ftdm_channel_t **ftdmchan)
 Open a channel specifying the span id and chan id (required before placing a call on the channel).
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)
 Hunts and opens a channel specifying the span id only.
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)
 Hunts and opens a channel specifying group id.
ftdm_status_t ftdm_channel_close (ftdm_channel_t **ftdmchan)
 Close a previously open channel.
ftdm_status_t ftdm_channel_command (ftdm_channel_t *ftdmchan, ftdm_command_t command, void *arg)
 Execute a command in a channel (same semantics as the ioctl() unix system call).
ftdm_status_t ftdm_channel_wait (ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t timeout)
 Wait for I/O events in a channel.
ftdm_status_t ftdm_channel_read (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)
 Read data from a channel.
ftdm_status_t ftdm_channel_write (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t datasize, ftdm_size_t *datalen)
 Write data to a channel.
ftdm_status_t ftdm_channel_add_var (ftdm_channel_t *ftdmchan, const char *var_name, const char *value)
 Add a custom variable to the channel.
const char * ftdm_channel_get_var (ftdm_channel_t *ftdmchan, const char *var_name)
 Get a custom variable from the channel.
ftdm_iterator_tftdm_channel_get_var_iterator (const ftdm_channel_t *ftdmchan, ftdm_iterator_t *iter)
 Get an iterator to iterate over the channel variables.
void * ftdm_iterator_current (ftdm_iterator_t *iter)
 Get iterator current value (depends on the iterator type).
ftdm_status_t ftdm_channel_get_current_var (ftdm_iterator_t *iter, const char **var_name, const char **var_val)
 Get variable name and value for the current iterator position.
ftdm_iterator_tftdm_iterator_next (ftdm_iterator_t *iter)
 Advance iterator.
ftdm_status_t ftdm_iterator_free (ftdm_iterator_t *iter)
 Free iterator.
ftdm_status_t ftdm_call_add_var (ftdm_caller_data_t *caller_data, const char *var_name, const char *value)
 Add a custom variable to the call.
const char * ftdm_call_get_var (ftdm_caller_data_t *caller_data, const char *var_name)
 Get a custom variable from the call.
ftdm_iterator_tftdm_call_get_var_iterator (const ftdm_caller_data_t *caller_data, ftdm_iterator_t *iter)
 Get an iterator to iterate over the channel variables.
ftdm_status_t ftdm_call_get_current_var (ftdm_iterator_t *iter, const char **var_name, const char **var_val)
 Get variable name and value for the current iterator position.
ftdm_status_t ftdm_call_clear_vars (ftdm_caller_data_t *caller_data)
 Clear all variables attached to the call.
ftdm_status_t ftdm_call_remove_var (ftdm_caller_data_t *caller_data, const char *var_name)
 Remove a variable attached to the call.
void ftdm_call_clear_data (ftdm_caller_data_t *caller_data)
 Clears all the temporary data attached to this call.
ftdm_span_t * ftdm_channel_get_span (const ftdm_channel_t *ftdmchan)
 Get the span pointer associated to the channel.
uint32_t ftdm_channel_get_span_id (const ftdm_channel_t *ftdmchan)
 Get the span pointer associated to the channel.
uint32_t ftdm_channel_get_ph_span_id (const ftdm_channel_t *ftdmchan)
 Get the physical span id associated to the channel.
const char * ftdm_channel_get_span_name (const ftdm_channel_t *ftdmchan)
 Get the span name associated to the channel.
uint32_t ftdm_channel_get_id (const ftdm_channel_t *ftdmchan)
 Get the id associated to the channel.
const char * ftdm_channel_get_name (const ftdm_channel_t *ftdmchan)
 Get the name associated to the channel.
const char * ftdm_channel_get_number (const ftdm_channel_t *ftdmchan)
 Get the number associated to the channel.
uint32_t ftdm_channel_get_ph_id (const ftdm_channel_t *ftdmchan)
 Get the number physical id associated to the channel.
ftdm_status_t ftdm_configure_span (ftdm_span_t *span, const char *type, fio_signal_cb_t sig_cb,...)
 Configure span with a signaling type.
ftdm_status_t ftdm_configure_span_signaling (ftdm_span_t *span, const char *type, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *parameters)
 Configure span with a signaling type.
ftdm_status_t ftdm_span_start (ftdm_span_t *span)
 Start the span signaling (must call ftdm_configure_span_signaling first).
ftdm_status_t ftdm_span_stop (ftdm_span_t *span)
 Stop the span signaling (must call ftdm_span_start first).
ftdm_status_t ftdm_global_add_io_interface (ftdm_io_interface_t *io_interface)
 Register a custom I/O interface with the FreeTDM core.
ftdm_status_t ftdm_span_find_by_name (const char *name, ftdm_span_t **span)
 Find a span by name.
uint32_t ftdm_span_get_id (const ftdm_span_t *span)
 Get the span id.
const char * ftdm_span_get_name (const ftdm_span_t *span)
 Get the span name.
ftdm_iterator_tftdm_span_get_chan_iterator (const ftdm_span_t *span, ftdm_iterator_t *iter)
 Get iterator for the span channels.
char * ftdm_api_execute (const char *cmd)
 Execute a text command. The text command output will be returned and must be free'd.
ftdm_status_t ftdm_conf_node_create (const char *name, ftdm_conf_node_t **node, ftdm_conf_node_t *parent)
 Create a configuration node.
ftdm_status_t ftdm_conf_node_add_param (ftdm_conf_node_t *node, const char *param, const char *val)
 Adds a new parameter to the specified configuration node.
ftdm_status_t ftdm_conf_node_destroy (ftdm_conf_node_t *node)
 Destroy the memory allocated for a configuration node (and all of its descendance).
ftdm_status_t ftdm_configure_span_channels (ftdm_span_t *span, const char *str, ftdm_channel_config_t *chan_config, unsigned *configured)
 Create and configure channels in the given span.
void ftdm_span_set_trunk_type (ftdm_span_t *span, ftdm_trunk_type_t type)
 Set the trunk type for a span This must be called before configuring any channels within the span.
ftdm_trunk_type_t ftdm_span_get_trunk_type (const ftdm_span_t *span)
 Get the trunk type for a span.
const char * ftdm_span_get_trunk_type_str (const ftdm_span_t *span)
 For display debugging purposes you can display this string which describes the trunk type of a span.
ftdm_channel_t * ftdm_span_get_channel (const ftdm_span_t *span, uint32_t chanid)
 Return the channel identified by the provided id.
uint32_t ftdm_span_get_chan_count (const ftdm_span_t *span)
 Return the channel count number for the given span.
ftdm_status_t ftdm_channel_set_caller_data (ftdm_channel_t *ftdmchan, ftdm_caller_data_t *caller_data)
 Set the caller data for a channel. Be sure to call this before ftdm_channel_call_place().
ftdm_caller_data_tftdm_channel_get_caller_data (ftdm_channel_t *channel)
 Get the caller data for a channel, typically you need this when receiving FTDM_SIGEVENT_START.
int ftdm_channel_get_state (const ftdm_channel_t *ftdmchan)
 Get current state of a channel.
int ftdm_channel_get_last_state (const ftdm_channel_t *ftdmchan)
 Get last state of a channel.
const char * ftdm_channel_get_state_str (const ftdm_channel_t *channel)
 For display debugging purposes you can display this string which describes the current channel internal state.
const char * ftdm_channel_get_last_state_str (const ftdm_channel_t *channel)
 For display debugging purposes you can display this string which describes the last channel internal state.
char * ftdm_channel_get_history_str (const ftdm_channel_t *channel)
 For display debugging purposes you can display this string which describes the history of the channel.
ftdm_status_t ftdm_channel_init (ftdm_channel_t *ftdmchan)
 Initialize channel state for an outgoing call.
ftdm_status_t ftdm_span_set_blocking_mode (const ftdm_span_t *span, ftdm_bool_t enabled)
 Enable/disable blocking mode in the channels for this span.
ftdm_status_t ftdm_global_init (void)
 Initialize the library.
ftdm_status_t ftdm_global_configuration (void)
 Create spans and channels reading the freetdm.conf file.
ftdm_status_t ftdm_global_destroy (void)
 Shutdown the library.
ftdm_status_t ftdm_global_set_memory_handler (ftdm_memory_handler_t *handler)
 Set memory handler for the library.
void ftdm_global_set_crash_policy (ftdm_crash_policy_t policy)
 Set the crash policy for the library.
void ftdm_global_set_logger (ftdm_logger_t logger)
 Set the logger handler for the library.
void ftdm_global_set_default_logger (int level)
 Set the default logger level.
void ftdm_global_set_mod_directory (const char *path)
 Set the directory to look for modules.
void ftdm_global_set_config_directory (const char *path)
 Set the directory to look for configs.
ftdm_bool_t ftdm_running (void)
 Check if the FTDM library is initialized and running.
 FT_DECLARE_NONSTD (ftdm_status_t) fio_slin2ulaw(void *data
 Basic transcoding functions.

Variables

const char * func
const char int line
const char int int level
const char int int const char * fmt
const char int int const char
typedef ftdm_status_t(*) 
ftdm_queue_create_func_t (ftdm_queue_t **queue, ftdm_size_t capacity)
 Data queue operation functions you can use ftdm_global_set_queue_handler if you want to override the default implementation (not recommended).
 ftdm_npi_t
 ftdm_presentation_t
 ftdm_screening_t
 ftdm_bearer_cap_t
 ftdm_user_layer1_prot_t
 ftdm_calling_party_category_t
 ftdm_number_t
 ftdm_trunk_type_t
 ftdm_channel_config_t
 ftdm_event_sigstatus_t
 ftdm_trace_type_t
 ftdm_event_trace_t
 ftdm_event_indication_completed_t
FT_DECLARE_DATA ftdm_logger_t ftdm_log
ftdm_size_t max
ftdm_size_t ftdm_size_t * datalen
ftdm_size_t max
ftdm_size_t ftdm_size_t * datalen
ftdm_size_t max
ftdm_size_t ftdm_size_t * datalen
ftdm_size_t max
ftdm_size_t ftdm_size_t * datalen
ftdm_size_t max
ftdm_size_t ftdm_size_t * datalen
ftdm_size_t max
ftdm_size_t ftdm_size_t * datalen

Define Documentation

#define BEARER_CAP_STRINGS   "speech", "unrestricted-digital-information", "3.1-Khz-audio", "invalid"

#define CALLING_PARTY_CATEGORY_STRINGS   "unknown", "operator", "ordinary", "priority", "data-call", "test-call", "payphone", "invalid"

#define CHAN_TYPE_STRINGS   "B", "DQ921", "DQ931", "FXS", "FXO", "EM", "CAS", "INVALID"

#define FIO_API_ARGS   (ftdm_stream_handle_t *stream, const char *data)

#define FIO_API_FUNCTION ( name   )     ftdm_status_t name FIO_API_ARGS

#define FIO_CHANNEL_DESTROY_ARGS   (ftdm_channel_t *ftdmchan)

#define FIO_CHANNEL_DESTROY_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_DESTROY_ARGS

#define FIO_CHANNEL_GET_SIG_STATUS_ARGS   (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status)

#define FIO_CHANNEL_GET_SIG_STATUS_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_GET_SIG_STATUS_ARGS

#define FIO_CHANNEL_NEXT_EVENT_ARGS   (ftdm_channel_t *ftdmchan, ftdm_event_t **event)

#define FIO_CHANNEL_NEXT_EVENT_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_NEXT_EVENT_ARGS

#define FIO_CHANNEL_OUTGOING_CALL_ARGS   (ftdm_channel_t *ftdmchan)

#define FIO_CHANNEL_OUTGOING_CALL_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_OUTGOING_CALL_ARGS

#define FIO_CHANNEL_REQUEST_ARGS   (ftdm_span_t *span, uint32_t chan_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan)

FreeTDM I/O layer interface argument macros You don't need these unless your implementing an I/O interface module (most users don't).

#define FIO_CHANNEL_REQUEST_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_REQUEST_ARGS

FreeTDM I/O layer interface function prototype wrapper macros You don't need these unless your implementing an I/O interface module (most users don't).

#define FIO_CHANNEL_SEND_MSG_ARGS   (ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)

#define FIO_CHANNEL_SEND_MSG_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_SEND_MSG_ARGS

#define FIO_CHANNEL_SET_SIG_STATUS_ARGS   (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)

#define FIO_CHANNEL_SET_SIG_STATUS_FUNCTION ( name   )     ftdm_status_t name FIO_CHANNEL_SET_SIG_STATUS_ARGS

#define FIO_CLOSE_ARGS   (ftdm_channel_t *ftdmchan)

#define FIO_CLOSE_FUNCTION ( name   )     ftdm_status_t name FIO_CLOSE_ARGS

#define FIO_CODEC_ARGS   (void *data, ftdm_size_t max, ftdm_size_t *datalen)

Basic transcoding function prototype.

#define FIO_CODEC_FUNCTION ( name   )     FT_DECLARE_NONSTD(ftdm_status_t) name FIO_CODEC_ARGS

#define FIO_COMMAND_ARGS   (ftdm_channel_t *ftdmchan, ftdm_command_t command, void *obj)

#define FIO_COMMAND_FUNCTION ( name   )     ftdm_status_t name FIO_COMMAND_ARGS

#define FIO_CONFIGURE_ARGS   (const char *category, const char *var, const char *val, int lineno)

#define FIO_CONFIGURE_FUNCTION ( name   )     ftdm_status_t name FIO_CONFIGURE_ARGS

#define FIO_CONFIGURE_SPAN_ARGS   (ftdm_span_t *span, const char *str, ftdm_chan_type_t type, char *name, char *number)

#define FIO_CONFIGURE_SPAN_FUNCTION ( name   )     ftdm_status_t name FIO_CONFIGURE_SPAN_ARGS

#define FIO_CONFIGURE_SPAN_SIGNALING_ARGS   (ftdm_span_t *span, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *ftdm_parameters)

#define FIO_CONFIGURE_SPAN_SIGNALING_FUNCTION ( name   )     ftdm_status_t name FIO_CONFIGURE_SPAN_SIGNALING_ARGS

#define FIO_EVENT_CB_ARGS   (ftdm_channel_t *ftdmchan, ftdm_event_t *event)

#define FIO_EVENT_CB_FUNCTION ( name   )     ftdm_status_t name FIO_EVENT_CB_ARGS

#define FIO_GET_ALARMS_ARGS   (ftdm_channel_t *ftdmchan)

#define FIO_GET_ALARMS_FUNCTION ( name   )     ftdm_status_t name FIO_GET_ALARMS_ARGS

#define FIO_IO_LOAD_ARGS   (ftdm_io_interface_t **fio)

#define FIO_IO_LOAD_FUNCTION ( name   )     ftdm_status_t name FIO_IO_LOAD_ARGS

#define FIO_IO_UNLOAD_ARGS   (void)

#define FIO_IO_UNLOAD_FUNCTION ( name   )     ftdm_status_t name FIO_IO_UNLOAD_ARGS

#define FIO_OPEN_ARGS   (ftdm_channel_t *ftdmchan)

#define FIO_OPEN_FUNCTION ( name   )     ftdm_status_t name FIO_OPEN_ARGS

#define FIO_READ_ARGS   (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)

#define FIO_READ_FUNCTION ( name   )     ftdm_status_t name FIO_READ_ARGS

#define FIO_SIG_CONFIGURE_ARGS   (ftdm_span_t *span, fio_signal_cb_t sig_cb, va_list ap)

#define FIO_SIG_CONFIGURE_FUNCTION ( name   )     ftdm_status_t name FIO_SIG_CONFIGURE_ARGS

#define FIO_SIG_LOAD_ARGS   (void)

#define FIO_SIG_LOAD_FUNCTION ( name   )     ftdm_status_t name FIO_SIG_LOAD_ARGS

#define FIO_SIG_UNLOAD_ARGS   (void)

#define FIO_SIG_UNLOAD_FUNCTION ( name   )     ftdm_status_t name FIO_SIG_UNLOAD_ARGS

#define FIO_SIGNAL_CB_ARGS   (ftdm_sigmsg_t *sigmsg)

#define FIO_SIGNAL_CB_FUNCTION ( name   )     ftdm_status_t name FIO_SIGNAL_CB_ARGS

#define FIO_SPAN_DESTROY_ARGS   (ftdm_span_t *span)

#define FIO_SPAN_DESTROY_FUNCTION ( name   )     ftdm_status_t name FIO_SPAN_DESTROY_ARGS

#define FIO_SPAN_GET_SIG_STATUS_ARGS   (ftdm_span_t *span, ftdm_signaling_status_t *status)

#define FIO_SPAN_GET_SIG_STATUS_FUNCTION ( name   )     ftdm_status_t name FIO_SPAN_GET_SIG_STATUS_ARGS

#define FIO_SPAN_NEXT_EVENT_ARGS   (ftdm_span_t *span, ftdm_event_t **event)

#define FIO_SPAN_NEXT_EVENT_FUNCTION ( name   )     ftdm_status_t name FIO_SPAN_NEXT_EVENT_ARGS

#define FIO_SPAN_POLL_EVENT_ARGS   (ftdm_span_t *span, uint32_t ms, short *poll_events)

#define FIO_SPAN_POLL_EVENT_FUNCTION ( name   )     ftdm_status_t name FIO_SPAN_POLL_EVENT_ARGS

#define FIO_SPAN_SET_SIG_STATUS_ARGS   (ftdm_span_t *span, ftdm_signaling_status_t status)

#define FIO_SPAN_SET_SIG_STATUS_FUNCTION ( name   )     ftdm_status_t name FIO_SPAN_SET_SIG_STATUS_ARGS

#define FIO_WAIT_ARGS   (ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t to)

#define FIO_WAIT_FUNCTION ( name   )     ftdm_status_t name FIO_WAIT_ARGS

#define FIO_WRITE_ARGS   (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)

#define FIO_WRITE_FUNCTION ( name   )     ftdm_status_t name FIO_WRITE_ARGS

#define ftdm_call_place ( callerdata,
hunting   )     _ftdm_call_place(__FILE__, __FUNCTION__, __LINE__, (callerdata), (hunting))

Place an outgoing call with the given caller data in a channel according to the hunting scheme provided.

#define ftdm_channel_call_answer ( ftdmchan   )     _ftdm_channel_call_answer(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

Answer call. This can also be accomplished by ftdm_channel_call_indicate with FTDM_CHANNEL_INDICATE_ANSWER, in both cases you will get a FTDM_SIGEVENT_INDICATION_COMPLETED when the indication is sent (or an error occurs). Just as with ftdm_channel_call_indicate you won't receive FTDM_SIGEVENT_INDICATION_COMPLETED when this function returns anything else than FTDM_SUCCESS.

Note:
Although this API may result in FTDM_SIGEVENT_INDICATION_COMPLETED event being delivered, there is no guarantee of whether the event will arrive after or before your execution thread returns from ftdm_channel_call_answer

#define ftdm_channel_call_hangup ( ftdmchan   )     _ftdm_channel_call_hangup(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

Hangup the call without cause.

#define ftdm_channel_call_hangup_with_cause ( ftdmchan,
cause   )     _ftdm_channel_call_hangup_with_cause(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (cause))

Hangup the call with cause.

#define ftdm_channel_call_hold ( ftdmchan   )     _ftdm_channel_call_hold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

Put a call on hold (if supported by the signaling stack).

#define ftdm_channel_call_indicate ( ftdmchan,
indication   )     _ftdm_channel_call_indicate(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (indication))

Indicate a new condition in an incoming call.

Note:
Every indication request will result in FTDM_SIGEVENT_INDICATION_COMPLETED event being delivered with the proper status that will inform you if the request was successful or not. The exception is if this function returns something different to FTDM_SUCCESS, in which case the request failed right away and no further FTDM_SIGEVENT_INDICATION_COMPLETED will be delivered Be aware there is no guarantee of whether the completion event will arrive after or before your execution thread returns from ftdm_channel_call_indicate. This means you could get FTDM_SIGEVENT_INDICATION_COMPLETED even before your execution thread returns from the ftdm_channel_call_indicate() API

You cannot send more than one indication at the time. You must wait for the completed event before calling this function again (unless the return code was different than FTDM_SUCCESS)

#define ftdm_channel_call_place ( ftdmchan   )     _ftdm_channel_call_place(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

Place an outgoing call in the given channel.

Deprecated:
This macro is deprecated since leaves the door open to glare issues, use ftdm_call_place instead

#define ftdm_channel_call_send_msg ( ftdmchan,
sigmsg   )     _ftdm_channel_call_send_msg(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (sigmsg))

Send a message on a call.

#define ftdm_channel_call_unhold ( ftdmchan   )     _ftdm_channel_call_unhold(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

Unhold a call.

#define ftdm_channel_reset ( ftdmchan   )     _ftdm_channel_reset(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

Reset the channel.

#define FTDM_DIGITS_LIMIT   25

#define FTDM_INVALID_INT_PARM   0xFF

#define FTDM_IS_DCHAN ( ftdm_chan   )     ((ftdm_chan)->type == FTDM_CHAN_TYPE_DQ921 || (ftdm_chan)->type == FTDM_CHAN_TYPE_DQ931)

#define FTDM_IS_VOICE_CHANNEL ( ftdm_chan   )     ((ftdm_chan)->type != FTDM_CHAN_TYPE_DQ921 && (ftdm_chan)->type != FTDM_CHAN_TYPE_DQ931)

#define FTDM_LOG_ALERT   FTDM_PRE, FTDM_LOG_LEVEL_ALERT

#define FTDM_LOG_CRIT   FTDM_PRE, FTDM_LOG_LEVEL_CRIT

#define FTDM_LOG_DEBUG   FTDM_PRE, FTDM_LOG_LEVEL_DEBUG

Log levels.

#define FTDM_LOG_EMERG   FTDM_PRE, FTDM_LOG_LEVEL_EMERG

#define FTDM_LOG_ERROR   FTDM_PRE, FTDM_LOG_LEVEL_ERROR

#define FTDM_LOG_INFO   FTDM_PRE, FTDM_LOG_LEVEL_INFO

#define FTDM_LOG_LEVEL_ALERT   1

#define FTDM_LOG_LEVEL_CRIT   2

#define FTDM_LOG_LEVEL_DEBUG   7

#define FTDM_LOG_LEVEL_EMERG   0

#define FTDM_LOG_LEVEL_ERROR   3

#define FTDM_LOG_LEVEL_INFO   6

#define FTDM_LOG_LEVEL_NOTICE   5

#define FTDM_LOG_LEVEL_WARNING   4

#define FTDM_LOG_NOTICE   FTDM_PRE, FTDM_LOG_LEVEL_NOTICE

#define FTDM_LOG_WARNING   FTDM_PRE, FTDM_LOG_LEVEL_WARNING

#define FTDM_MAX_CHANNELS_GROUP   1024

Max number of channels per hunting group.

#define FTDM_MAX_CHANNELS_PHYSICAL_SPAN   32

Max number of channels per physical span.

#define FTDM_MAX_CHANNELS_SPAN   FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN

Max number of channels a logical span can contain.

#define FTDM_MAX_GROUPS_INTERFACE   FTDM_MAX_SPANS_INTERFACE

Max number of groups.

#define FTDM_MAX_NAME_STR_SZ   80

Thread/Mutex OS abstraction API. Limit to span names.

#define FTDM_MAX_NUMBER_STR_SZ   20

Limit to channel number strings.

#define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN   32

Max number of physical spans per logical span.

#define FTDM_MAX_SPANS_INTERFACE   128

Max number of logical spans.

#define FTDM_PRE   __FILE__, __FUNCTION__, __LINE__

#define FTDM_TAG_END   NULL

#define INDICATION_STRINGS   "NONE", "RINGING", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "BUSY", "ANSWER", "INVALID"

#define NPI_STRINGS   "unknown", "ISDN", "data", "telex", "national", "private", "reserved", "invalid"

#define PRESENTATION_STRINGS   "presentation-allowed", "presentation-restricted", "number-not-available", "reserved", "Invalid"

#define SCREENING_STRINGS   "user-provided-not-screened", "user-provided-verified-and-passed", "user-provided-verified-and-failed", "network-provided", "invalid"

#define SIGNAL_STRINGS

Value:

"START", "STOP", "RELEASED", "UP", "FLASH", "PROCEED", "RINGING", "PROGRESS", \
                "PROGRESS_MEDIA", "ALARM_TRAP", "ALARM_CLEAR", \
                "COLLECTED_DIGIT", "ADD_CALL", "RESTART", "SIGSTATUS_CHANGED", "COLLISION", "FACILITY", \
                "TRACE", "TRACE_RAW", "INDICATION_COMPLETED", "DIALING", "INVALID"

#define SIGSTATUS_STRINGS   "DOWN", "SUSPENDED", "UP", "INVALID"

#define TON_STRINGS   "unknown", "international", "national", "network-specific", "subscriber-number", "abbreviated-number", "reserved", "invalid"

#define TRACE_DIR_STRINGS   "INCOMING", "OUTGOING", "INVALID"

#define TRACE_TYPE_STRINGS   "Q931", "Q921", "INVALID"

#define TRUNK_STRINGS   "E1", "T1", "J1", "BRI", "BRI_PTMP", "FXO", "FXS", "EM", "NONE"

#define USER_LAYER1_PROT_STRINGS   "V.110", "u-law", "a-law", "Invalid"


Typedef Documentation

typedef ftdm_status_t(*) fio_api_t(ftdm_stream_handle_t *stream, const char *data)

typedef ftdm_status_t(*) fio_channel_destroy_t(ftdm_channel_t *ftdmchan)

typedef ftdm_status_t(*) fio_channel_get_sig_status_t(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status)

typedef ftdm_status_t(*) fio_channel_next_event_t(ftdm_channel_t *ftdmchan, ftdm_event_t **event)

typedef ftdm_status_t(*) fio_channel_outgoing_call_t(ftdm_channel_t *ftdmchan)

typedef ftdm_status_t(*) fio_channel_request_t(ftdm_span_t *span, uint32_t chan_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan)

FreeTDM I/O layer interface function typedefs You don't need these unless your implementing an I/O interface module (most users don't).

typedef ftdm_status_t(*) fio_channel_send_msg_t(ftdm_channel_t *ftdmchan, ftdm_sigmsg_t *sigmsg)

typedef ftdm_status_t(*) fio_channel_set_sig_status_t(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)

typedef ftdm_status_t(*) fio_close_t(ftdm_channel_t *ftdmchan)

typedef ftdm_status_t(*) fio_codec_t(void *data, ftdm_size_t max, ftdm_size_t *datalen)

typedef ftdm_status_t(*) fio_command_t(ftdm_channel_t *ftdmchan, ftdm_command_t command, void *obj)

typedef ftdm_status_t(*) fio_configure_span_signaling_t(ftdm_span_t *span, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *ftdm_parameters)

typedef ftdm_status_t(*) fio_configure_span_t(ftdm_span_t *span, const char *str, ftdm_chan_type_t type, char *name, char *number)

typedef ftdm_status_t(*) fio_configure_t(const char *category, const char *var, const char *val, int lineno)

typedef ftdm_status_t(*) fio_event_cb_t(ftdm_channel_t *ftdmchan, ftdm_event_t *event)

typedef ftdm_status_t(*) fio_get_alarms_t(ftdm_channel_t *ftdmchan)

typedef ftdm_status_t(*) fio_io_load_t(ftdm_io_interface_t **fio)

typedef ftdm_status_t(*) fio_io_unload_t(void)

typedef ftdm_status_t(*) fio_open_t(ftdm_channel_t *ftdmchan)

typedef ftdm_status_t(*) fio_read_t(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)

typedef ftdm_status_t(*) fio_sig_configure_t(ftdm_span_t *span, fio_signal_cb_t sig_cb, va_list ap)

typedef ftdm_status_t(*) fio_sig_load_t(void)

typedef ftdm_status_t(*) fio_sig_unload_t(void)

typedef ftdm_status_t(*) fio_signal_cb_t(ftdm_sigmsg_t *sigmsg)

Callback for signal delivery (FTDM_SIGEVENT_START and friends).

Note:
This callback is provided by the user during ftdm_configure_span_signaling

You must NOT do any blocking during this callback since this function is most likely called in an internal signaling thread that can potentially be shared for all the channels in a span and blocking will delay processing (sometimes even audio processing) for other channels

Although some simple FreeTDM APIs can work (ie: ftdm_span_get_id etc), the use of any FreeTDM call API (ie ftdm_channel_call_answer) is discouraged

typedef ftdm_status_t(*) fio_span_destroy_t(ftdm_span_t *span)

typedef ftdm_status_t(*) fio_span_get_sig_status_t(ftdm_span_t *span, ftdm_signaling_status_t *status)

typedef ftdm_status_t(*) fio_span_next_event_t(ftdm_span_t *span, ftdm_event_t **event)

typedef ftdm_status_t(*) fio_span_poll_event_t(ftdm_span_t *span, uint32_t ms, short *poll_events)

typedef ftdm_status_t(*) fio_span_set_sig_status_t(ftdm_span_t *span, ftdm_signaling_status_t status)

typedef ftdm_status_t(*) fio_wait_t(ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t to)

typedef ftdm_status_t(*) fio_write_t(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen)

typedef struct ftdm_caller_data ftdm_caller_data_t

Caller information.

typedef void*(*) ftdm_calloc_func_t(void *pool, ftdm_size_t elements, ftdm_size_t len)

typedef struct ftdm_conf_parameter ftdm_conf_parameter_t

Signaling configuration parameter for the stacks (variable=value pair).

typedef void(*) ftdm_free_func_t(void *pool, void *ptr)

typedef ftdm_status_t(*) ftdm_hunt_result_cb_t(ftdm_channel_t *fchan, ftdm_caller_data_t *caller_data)

Function called before placing the call in the hunted channel The user can have a last saying in whether to proceed or abort the call attempt. Be aware that this callback will be called with the channel lock and you must not do any blocking operations during its execution.

Parameters:
fchan The channel that will be used to place the call
caller_data The caller data provided to ftdm_call_place
Returns:
FTDM_SUCCESS to proceed or FTDM_BREAK to abort the hunting

typedef struct ftdm_iterator ftdm_iterator_t

Opaque general purpose iterator.

typedef void*(*) ftdm_malloc_func_t(void *pool, ftdm_size_t len)

Custom memory handler hooks. Not recommended to use unless you need memory allocation customizations.

typedef void*(*) ftdm_queue_dequeue_func_t(ftdm_queue_t *queue)

typedef ftdm_status_t(*) ftdm_queue_destroy_func_t(ftdm_queue_t **queue)

typedef ftdm_status_t(*) ftdm_queue_enqueue_func_t(ftdm_queue_t *queue, void *obj)

typedef ftdm_status_t(*) ftdm_queue_get_interrupt_func_t(ftdm_queue_t *queue, ftdm_interrupt_t **interrupt)

typedef struct ftdm_queue_handler ftdm_queue_handler_t

typedef ftdm_status_t(*) ftdm_queue_wait_func_t(ftdm_queue_t *queue, int ms)

typedef void*(*) ftdm_realloc_func_t(void *pool, void *buff, ftdm_size_t len)

typedef void* ftdm_variable_container_t


Enumeration Type Documentation

enum ftdm_alarm_flag_t

FreeTDM supported hardware alarms.

Enumerator:
FTDM_ALARM_NONE 
FTDM_ALARM_RED 
FTDM_ALARM_YELLOW 
FTDM_ALARM_RAI 
FTDM_ALARM_BLUE 
FTDM_ALARM_AIS 
FTDM_ALARM_GENERAL 
00813              {
00814         FTDM_ALARM_NONE    = 0,
00815         FTDM_ALARM_RED     = (1 << 1),
00816         FTDM_ALARM_YELLOW  = (1 << 2),
00817         FTDM_ALARM_RAI     = (1 << 3),
00818         FTDM_ALARM_BLUE    = (1 << 4),
00819         FTDM_ALARM_AIS     = (1 << 5),
00820         FTDM_ALARM_GENERAL = (1 << 30)
00821 } ftdm_alarm_flag_t;

enum ftdm_call_cause_t

Hangup cause codes.

Enumerator:
FTDM_CAUSE_NONE 
FTDM_CAUSE_UNALLOCATED 
FTDM_CAUSE_NO_ROUTE_TRANSIT_NET 
FTDM_CAUSE_NO_ROUTE_DESTINATION 
FTDM_CAUSE_CHANNEL_UNACCEPTABLE 
FTDM_CAUSE_CALL_AWARDED_DELIVERED 
FTDM_CAUSE_NORMAL_CLEARING 
FTDM_CAUSE_USER_BUSY 
FTDM_CAUSE_NO_USER_RESPONSE 
FTDM_CAUSE_NO_ANSWER 
FTDM_CAUSE_SUBSCRIBER_ABSENT 
FTDM_CAUSE_CALL_REJECTED 
FTDM_CAUSE_NUMBER_CHANGED 
FTDM_CAUSE_REDIRECTION_TO_NEW_DESTINATION 
FTDM_CAUSE_EXCHANGE_ROUTING_ERROR 
FTDM_CAUSE_DESTINATION_OUT_OF_ORDER 
FTDM_CAUSE_INVALID_NUMBER_FORMAT 
FTDM_CAUSE_FACILITY_REJECTED 
FTDM_CAUSE_RESPONSE_TO_STATUS_ENQUIRY 
FTDM_CAUSE_NORMAL_UNSPECIFIED 
FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION 
FTDM_CAUSE_NETWORK_OUT_OF_ORDER 
FTDM_CAUSE_NORMAL_TEMPORARY_FAILURE 
FTDM_CAUSE_SWITCH_CONGESTION 
FTDM_CAUSE_ACCESS_INFO_DISCARDED 
FTDM_CAUSE_REQUESTED_CHAN_UNAVAIL 
FTDM_CAUSE_PRE_EMPTED 
FTDM_CAUSE_FACILITY_NOT_SUBSCRIBED 
FTDM_CAUSE_OUTGOING_CALL_BARRED 
FTDM_CAUSE_INCOMING_CALL_BARRED 
FTDM_CAUSE_BEARERCAPABILITY_NOTAUTH 
FTDM_CAUSE_BEARERCAPABILITY_NOTAVAIL 
FTDM_CAUSE_SERVICE_UNAVAILABLE 
FTDM_CAUSE_BEARERCAPABILITY_NOTIMPL 
FTDM_CAUSE_CHAN_NOT_IMPLEMENTED 
FTDM_CAUSE_FACILITY_NOT_IMPLEMENTED 
FTDM_CAUSE_SERVICE_NOT_IMPLEMENTED 
FTDM_CAUSE_INVALID_CALL_REFERENCE 
FTDM_CAUSE_INCOMPATIBLE_DESTINATION 
FTDM_CAUSE_INVALID_MSG_UNSPECIFIED 
FTDM_CAUSE_MANDATORY_IE_MISSING 
FTDM_CAUSE_MESSAGE_TYPE_NONEXIST 
FTDM_CAUSE_WRONG_MESSAGE 
FTDM_CAUSE_IE_NONEXIST 
FTDM_CAUSE_INVALID_IE_CONTENTS 
FTDM_CAUSE_WRONG_CALL_STATE 
FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE 
FTDM_CAUSE_MANDATORY_IE_LENGTH_ERROR 
FTDM_CAUSE_PROTOCOL_ERROR 
FTDM_CAUSE_INTERWORKING 
FTDM_CAUSE_SUCCESS 
FTDM_CAUSE_ORIGINATOR_CANCEL 
FTDM_CAUSE_CRASH 
FTDM_CAUSE_SYSTEM_SHUTDOWN 
FTDM_CAUSE_LOSE_RACE 
FTDM_CAUSE_MANAGER_REQUEST 
FTDM_CAUSE_BLIND_TRANSFER 
FTDM_CAUSE_ATTENDED_TRANSFER 
FTDM_CAUSE_ALLOTTED_TIMEOUT 
FTDM_CAUSE_USER_CHALLENGE 
FTDM_CAUSE_MEDIA_TIMEOUT 
00080              {
00081         FTDM_CAUSE_NONE = 0,
00082         FTDM_CAUSE_UNALLOCATED = 1,
00083         FTDM_CAUSE_NO_ROUTE_TRANSIT_NET = 2,
00084         FTDM_CAUSE_NO_ROUTE_DESTINATION = 3,
00085         FTDM_CAUSE_CHANNEL_UNACCEPTABLE = 6,
00086         FTDM_CAUSE_CALL_AWARDED_DELIVERED = 7,
00087         FTDM_CAUSE_NORMAL_CLEARING = 16,
00088         FTDM_CAUSE_USER_BUSY = 17,
00089         FTDM_CAUSE_NO_USER_RESPONSE = 18,
00090         FTDM_CAUSE_NO_ANSWER = 19,
00091         FTDM_CAUSE_SUBSCRIBER_ABSENT = 20,
00092         FTDM_CAUSE_CALL_REJECTED = 21,
00093         FTDM_CAUSE_NUMBER_CHANGED = 22,
00094         FTDM_CAUSE_REDIRECTION_TO_NEW_DESTINATION = 23,
00095         FTDM_CAUSE_EXCHANGE_ROUTING_ERROR = 25,
00096         FTDM_CAUSE_DESTINATION_OUT_OF_ORDER = 27,
00097         FTDM_CAUSE_INVALID_NUMBER_FORMAT = 28,
00098         FTDM_CAUSE_FACILITY_REJECTED = 29,
00099         FTDM_CAUSE_RESPONSE_TO_STATUS_ENQUIRY = 30,
00100         FTDM_CAUSE_NORMAL_UNSPECIFIED = 31,
00101         FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION = 34,
00102         FTDM_CAUSE_NETWORK_OUT_OF_ORDER = 38,
00103         FTDM_CAUSE_NORMAL_TEMPORARY_FAILURE = 41,
00104         FTDM_CAUSE_SWITCH_CONGESTION = 42,
00105         FTDM_CAUSE_ACCESS_INFO_DISCARDED = 43,
00106         FTDM_CAUSE_REQUESTED_CHAN_UNAVAIL = 44,
00107         FTDM_CAUSE_PRE_EMPTED = 45,
00108         FTDM_CAUSE_FACILITY_NOT_SUBSCRIBED = 50,
00109         FTDM_CAUSE_OUTGOING_CALL_BARRED = 52,
00110         FTDM_CAUSE_INCOMING_CALL_BARRED = 54,
00111         FTDM_CAUSE_BEARERCAPABILITY_NOTAUTH = 57,
00112         FTDM_CAUSE_BEARERCAPABILITY_NOTAVAIL = 58,
00113         FTDM_CAUSE_SERVICE_UNAVAILABLE = 63,
00114         FTDM_CAUSE_BEARERCAPABILITY_NOTIMPL = 65,
00115         FTDM_CAUSE_CHAN_NOT_IMPLEMENTED = 66,
00116         FTDM_CAUSE_FACILITY_NOT_IMPLEMENTED = 69,
00117         FTDM_CAUSE_SERVICE_NOT_IMPLEMENTED = 79,
00118         FTDM_CAUSE_INVALID_CALL_REFERENCE = 81,
00119         FTDM_CAUSE_INCOMPATIBLE_DESTINATION = 88,
00120         FTDM_CAUSE_INVALID_MSG_UNSPECIFIED = 95,
00121         FTDM_CAUSE_MANDATORY_IE_MISSING = 96,
00122         FTDM_CAUSE_MESSAGE_TYPE_NONEXIST = 97,
00123         FTDM_CAUSE_WRONG_MESSAGE = 98,
00124         FTDM_CAUSE_IE_NONEXIST = 99,
00125         FTDM_CAUSE_INVALID_IE_CONTENTS = 100,
00126         FTDM_CAUSE_WRONG_CALL_STATE = 101,
00127         FTDM_CAUSE_RECOVERY_ON_TIMER_EXPIRE = 102,
00128         FTDM_CAUSE_MANDATORY_IE_LENGTH_ERROR = 103,
00129         FTDM_CAUSE_PROTOCOL_ERROR = 111,
00130         FTDM_CAUSE_INTERWORKING = 127,
00131         FTDM_CAUSE_SUCCESS = 142,
00132         FTDM_CAUSE_ORIGINATOR_CANCEL = 487,
00133         FTDM_CAUSE_CRASH = 500,
00134         FTDM_CAUSE_SYSTEM_SHUTDOWN = 501,
00135         FTDM_CAUSE_LOSE_RACE = 502,
00136         FTDM_CAUSE_MANAGER_REQUEST = 503,
00137         FTDM_CAUSE_BLIND_TRANSFER = 600,
00138         FTDM_CAUSE_ATTENDED_TRANSFER = 601,
00139         FTDM_CAUSE_ALLOTTED_TIMEOUT = 602,
00140         FTDM_CAUSE_USER_CHALLENGE = 603,
00141         FTDM_CAUSE_MEDIA_TIMEOUT = 604
00142 } ftdm_call_cause_t;

enum ftdm_chan_type_t

I/O channel type.

Enumerator:
FTDM_CHAN_TYPE_B  Bearer channel
FTDM_CHAN_TYPE_DQ921 
FTDM_CHAN_TYPE_DQ931  DQ931 channel
FTDM_CHAN_TYPE_FXS  FXS analog channel
FTDM_CHAN_TYPE_FXO  FXO analog channel
FTDM_CHAN_TYPE_EM  E & M channel
FTDM_CHAN_TYPE_CAS  CAS channel
FTDM_CHAN_TYPE_COUNT  Count of channel types
00153              {
00154         FTDM_CHAN_TYPE_B, 
00155         FTDM_CHAN_TYPE_DQ921, /*< DQ921 channel (D-channel) */
00156         FTDM_CHAN_TYPE_DQ931, 
00157         FTDM_CHAN_TYPE_FXS, 
00158         FTDM_CHAN_TYPE_FXO, 
00159         FTDM_CHAN_TYPE_EM, 
00160         FTDM_CHAN_TYPE_CAS, 
00161         FTDM_CHAN_TYPE_COUNT 
00162 } ftdm_chan_type_t;

enum ftdm_channel_indication_t

FreeTDM supported indications. This is used during incoming calls when you want to request the signaling stack to notify about indications occurring locally. See ftdm_channel_call_indicate for more info.

Enumerator:
FTDM_CHANNEL_INDICATE_NONE 
FTDM_CHANNEL_INDICATE_RINGING 
FTDM_CHANNEL_INDICATE_PROCEED 
FTDM_CHANNEL_INDICATE_PROGRESS 
FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA 
FTDM_CHANNEL_INDICATE_BUSY 
FTDM_CHANNEL_INDICATE_ANSWER 
FTDM_CHANNEL_INDICATE_INVALID 

enum ftdm_codec_t

FreeTDM supported I/O codecs.

Enumerator:
FTDM_CODEC_ULAW 
FTDM_CODEC_ALAW 
FTDM_CODEC_SLIN 
FTDM_CODEC_NONE 
00805              {
00806         FTDM_CODEC_ULAW = 0,
00807         FTDM_CODEC_ALAW = 8,
00808         FTDM_CODEC_SLIN = 10,
00809         FTDM_CODEC_NONE = (1 << 30)
00810 } ftdm_codec_t;

enum ftdm_command_t

Channel commands that can be executed through ftdm_channel_command().

Enumerator:
FTDM_COMMAND_NOOP 
FTDM_COMMAND_SET_INTERVAL 
FTDM_COMMAND_GET_INTERVAL 
FTDM_COMMAND_SET_CODEC 
FTDM_COMMAND_GET_CODEC 
FTDM_COMMAND_SET_NATIVE_CODEC 
FTDM_COMMAND_GET_NATIVE_CODEC 
FTDM_COMMAND_ENABLE_DTMF_DETECT 
FTDM_COMMAND_DISABLE_DTMF_DETECT 
FTDM_COMMAND_SEND_DTMF 
FTDM_COMMAND_SET_DTMF_ON_PERIOD 
FTDM_COMMAND_GET_DTMF_ON_PERIOD 
FTDM_COMMAND_SET_DTMF_OFF_PERIOD 
FTDM_COMMAND_GET_DTMF_OFF_PERIOD 
FTDM_COMMAND_GENERATE_RING_ON 
FTDM_COMMAND_GENERATE_RING_OFF 
FTDM_COMMAND_OFFHOOK 
FTDM_COMMAND_ONHOOK 
FTDM_COMMAND_FLASH 
FTDM_COMMAND_WINK 
FTDM_COMMAND_ENABLE_PROGRESS_DETECT 
FTDM_COMMAND_DISABLE_PROGRESS_DETECT  Start tracing input and output from channel to the given file
FTDM_COMMAND_TRACE_INPUT 
FTDM_COMMAND_TRACE_OUTPUT  Stop both Input and Output trace, closing the files
FTDM_COMMAND_TRACE_END_ALL  Enable DTMF debugging
FTDM_COMMAND_ENABLE_DEBUG_DTMF  Disable DTMF debugging (if not disabled explicitly, it is disabled automatically when calls hangup)
FTDM_COMMAND_DISABLE_DEBUG_DTMF  Start dumping all input to a circular buffer. The size of the circular buffer can be specified, default used otherwise
FTDM_COMMAND_ENABLE_INPUT_DUMP  Stop dumping all input to a circular buffer.
FTDM_COMMAND_DISABLE_INPUT_DUMP  Start dumping all output to a circular buffer. The size of the circular buffer can be specified, default used otherwise
FTDM_COMMAND_ENABLE_OUTPUT_DUMP  Stop dumping all output to a circular buffer.
FTDM_COMMAND_DISABLE_OUTPUT_DUMP  Dump the current input circular buffer to the specified FILE* structure
FTDM_COMMAND_DUMP_INPUT  Dump the current output circular buffer to the specified FILE* structure
FTDM_COMMAND_DUMP_OUTPUT 
FTDM_COMMAND_ENABLE_CALLERID_DETECT 
FTDM_COMMAND_DISABLE_CALLERID_DETECT 
FTDM_COMMAND_ENABLE_ECHOCANCEL 
FTDM_COMMAND_DISABLE_ECHOCANCEL 
FTDM_COMMAND_ENABLE_ECHOTRAIN 
FTDM_COMMAND_DISABLE_ECHOTRAIN 
FTDM_COMMAND_SET_CAS_BITS 
FTDM_COMMAND_GET_CAS_BITS 
FTDM_COMMAND_SET_RX_GAIN 
FTDM_COMMAND_GET_RX_GAIN 
FTDM_COMMAND_SET_TX_GAIN 
FTDM_COMMAND_GET_TX_GAIN 
FTDM_COMMAND_FLUSH_TX_BUFFERS 
FTDM_COMMAND_FLUSH_RX_BUFFERS 
FTDM_COMMAND_FLUSH_BUFFERS 
FTDM_COMMAND_FLUSH_IOSTATS 
FTDM_COMMAND_SET_PRE_BUFFER_SIZE 
FTDM_COMMAND_SET_LINK_STATUS 
FTDM_COMMAND_GET_LINK_STATUS 
FTDM_COMMAND_ENABLE_LOOP 
FTDM_COMMAND_DISABLE_LOOP 
FTDM_COMMAND_SET_RX_QUEUE_SIZE 
FTDM_COMMAND_SET_TX_QUEUE_SIZE 
FTDM_COMMAND_SET_POLARITY 
FTDM_COMMAND_COUNT 
00570              {
00571         FTDM_COMMAND_NOOP,
00572         FTDM_COMMAND_SET_INTERVAL,
00573         FTDM_COMMAND_GET_INTERVAL,
00574         FTDM_COMMAND_SET_CODEC,
00575         FTDM_COMMAND_GET_CODEC,
00576         FTDM_COMMAND_SET_NATIVE_CODEC,
00577         FTDM_COMMAND_GET_NATIVE_CODEC,
00578         FTDM_COMMAND_ENABLE_DTMF_DETECT,
00579         FTDM_COMMAND_DISABLE_DTMF_DETECT,
00580         FTDM_COMMAND_SEND_DTMF,
00581         FTDM_COMMAND_SET_DTMF_ON_PERIOD,
00582         FTDM_COMMAND_GET_DTMF_ON_PERIOD,
00583         FTDM_COMMAND_SET_DTMF_OFF_PERIOD,
00584         FTDM_COMMAND_GET_DTMF_OFF_PERIOD,
00585         FTDM_COMMAND_GENERATE_RING_ON,
00586         FTDM_COMMAND_GENERATE_RING_OFF,
00587         FTDM_COMMAND_OFFHOOK,
00588         FTDM_COMMAND_ONHOOK,
00589         FTDM_COMMAND_FLASH,
00590         FTDM_COMMAND_WINK,
00591         FTDM_COMMAND_ENABLE_PROGRESS_DETECT,
00592         FTDM_COMMAND_DISABLE_PROGRESS_DETECT,
00593 
00595         FTDM_COMMAND_TRACE_INPUT,
00596         FTDM_COMMAND_TRACE_OUTPUT,
00597 
00599         FTDM_COMMAND_TRACE_END_ALL,
00600 
00602         FTDM_COMMAND_ENABLE_DEBUG_DTMF,
00603 
00605         FTDM_COMMAND_DISABLE_DEBUG_DTMF,
00606 
00608         FTDM_COMMAND_ENABLE_INPUT_DUMP,
00609 
00611         FTDM_COMMAND_DISABLE_INPUT_DUMP,
00612 
00614         FTDM_COMMAND_ENABLE_OUTPUT_DUMP,
00615 
00617         FTDM_COMMAND_DISABLE_OUTPUT_DUMP,
00618 
00620         FTDM_COMMAND_DUMP_INPUT,
00621 
00623         FTDM_COMMAND_DUMP_OUTPUT,
00624 
00625         FTDM_COMMAND_ENABLE_CALLERID_DETECT,
00626         FTDM_COMMAND_DISABLE_CALLERID_DETECT,
00627         FTDM_COMMAND_ENABLE_ECHOCANCEL,
00628         FTDM_COMMAND_DISABLE_ECHOCANCEL,
00629         FTDM_COMMAND_ENABLE_ECHOTRAIN,
00630         FTDM_COMMAND_DISABLE_ECHOTRAIN,
00631         FTDM_COMMAND_SET_CAS_BITS,
00632         FTDM_COMMAND_GET_CAS_BITS,
00633         FTDM_COMMAND_SET_RX_GAIN,
00634         FTDM_COMMAND_GET_RX_GAIN,
00635         FTDM_COMMAND_SET_TX_GAIN,
00636         FTDM_COMMAND_GET_TX_GAIN,
00637         FTDM_COMMAND_FLUSH_TX_BUFFERS,
00638         FTDM_COMMAND_FLUSH_RX_BUFFERS,
00639         FTDM_COMMAND_FLUSH_BUFFERS,
00640         FTDM_COMMAND_FLUSH_IOSTATS,
00641         FTDM_COMMAND_SET_PRE_BUFFER_SIZE,
00642         FTDM_COMMAND_SET_LINK_STATUS,
00643         FTDM_COMMAND_GET_LINK_STATUS,
00644         FTDM_COMMAND_ENABLE_LOOP,
00645         FTDM_COMMAND_DISABLE_LOOP,
00646         FTDM_COMMAND_SET_RX_QUEUE_SIZE,
00647         FTDM_COMMAND_SET_TX_QUEUE_SIZE,
00648         FTDM_COMMAND_SET_POLARITY,
00649         FTDM_COMMAND_COUNT,
00650 } ftdm_command_t;

enum ftdm_crash_policy_t

Crash policy Useful for debugging only, default policy is never, if you wish to crash on asserts then use ftdm_global_set_crash_policy.

Enumerator:
FTDM_CRASH_NEVER 
FTDM_CRASH_ON_ASSERT 
00546              {
00547         FTDM_CRASH_NEVER = 0,
00548         FTDM_CRASH_ON_ASSERT
00549 } ftdm_crash_policy_t;

enum ftdm_direction_t

Hunting direction (when hunting for free channels).

Enumerator:
FTDM_TOP_DOWN 
FTDM_BOTTOM_UP 
FTDM_RR_DOWN 
FTDM_RR_UP 
00145              {
00146         FTDM_TOP_DOWN,
00147         FTDM_BOTTOM_UP,
00148         FTDM_RR_DOWN,
00149         FTDM_RR_UP,
00150 } ftdm_direction_t;

enum ftdm_hunt_mode_t

Hunting mode.

Enumerator:
FTDM_HUNT_SPAN  Hunt channels in a given span
FTDM_HUNT_GROUP  Hunt channels in a given group
FTDM_HUNT_CHAN  Hunt for a specific channel
00328              {
00329         FTDM_HUNT_SPAN, 
00330         FTDM_HUNT_GROUP, 
00331         FTDM_HUNT_CHAN, 
00332 } ftdm_hunt_mode_t;

enum ftdm_polarity_t

Enumerator:
FTDM_POLARITY_FORWARD 
FTDM_POLARITY_REVERSE 
00652              {
00653         FTDM_POLARITY_FORWARD = 0,
00654         FTDM_POLARITY_REVERSE = 1
00655 } ftdm_polarity_t;

enum ftdm_signal_event_t

Signaling messages sent by the stacks.

Enumerator:
FTDM_SIGEVENT_START  Incoming call (ie: incoming SETUP msg or Ring)
FTDM_SIGEVENT_STOP  Hangup
FTDM_SIGEVENT_RELEASED  Channel is completely released and available
FTDM_SIGEVENT_UP  Outgoing call has been answered
FTDM_SIGEVENT_FLASH  Flash event (typically on-hook/off-hook for analog devices)
FTDM_SIGEVENT_PROCEED  Outgoing call got an initial positive response from the other end
FTDM_SIGEVENT_RINGING  Remote side is in ringing state
FTDM_SIGEVENT_PROGRESS  Outgoing call is making progress
FTDM_SIGEVENT_PROGRESS_MEDIA  Outgoing call is making progress and there is media available
FTDM_SIGEVENT_ALARM_TRAP  Hardware alarm ON
FTDM_SIGEVENT_ALARM_CLEAR  Hardware alarm OFF
FTDM_SIGEVENT_COLLECTED_DIGIT  Digit collected (in signalings where digits are collected one by one)
FTDM_SIGEVENT_ADD_CALL  New call should be added to the channel
FTDM_SIGEVENT_RESTART  Restart has been requested. Typically you hangup your call resources here
FTDM_SIGEVENT_SIGSTATUS_CHANGED  Signaling protocol status changed (ie: D-chan up), see new status in raw_data ftdm_sigmsg_t member
FTDM_SIGEVENT_COLLISION  Outgoing call was dropped because an incoming call arrived at the same time
FTDM_SIGEVENT_FACILITY  In call facility event
FTDM_SIGEVENT_TRACE  Interpreted trace event
FTDM_SIGEVENT_TRACE_RAW  Raw trace event
FTDM_SIGEVENT_INDICATION_COMPLETED  Last requested indication was completed
FTDM_SIGEVENT_DIALING 
FTDM_SIGEVENT_INVALID  Invalid

enum ftdm_signaling_status_t

Signaling status on a given span or specific channel on protocols that support it.

Note:
see docs/sigstatus.txt for more extensive documentation on signaling status
Enumerator:
FTDM_SIG_STATE_DOWN 
FTDM_SIG_STATE_SUSPENDED 
FTDM_SIG_STATE_UP 
FTDM_SIG_STATE_INVALID 
00444              {
00445         /* The signaling link is down (no d-chans up in the span/group, MFC-R2 bit pattern unidentified) */
00446         FTDM_SIG_STATE_DOWN,
00447         /* The signaling link is suspended (MFC-R2 bit pattern blocked, ss7 blocked?) */
00448         FTDM_SIG_STATE_SUSPENDED,
00449         /* The signaling link is ready and calls can be placed (ie: d-chan up) */
00450         FTDM_SIG_STATE_UP,
00451         /* Invalid status */
00452         FTDM_SIG_STATE_INVALID
00453 } ftdm_signaling_status_t;

enum ftdm_ton_t

Type Of Number (TON).

Enumerator:
FTDM_TON_UNKNOWN 
FTDM_TON_INTERNATIONAL 
FTDM_TON_NATIONAL 
FTDM_TON_NETWORK_SPECIFIC 
FTDM_TON_SUBSCRIBER_NUMBER 
FTDM_TON_ABBREVIATED_NUMBER 
FTDM_TON_RESERVED 
FTDM_TON_INVALID 

enum ftdm_tone_type_t

Tone type.

Enumerator:
FTDM_TONE_DTMF 
00376              {
00377         FTDM_TONE_DTMF = (1 << 0)
00378 } ftdm_tone_type_t;

enum ftdm_trace_dir_t

Enumerator:
FTDM_TRACE_DIR_INCOMING 
FTDM_TRACE_DIR_OUTGOING 
FTDM_TRACE_DIR_INVALID 
00464              {
00465         /* This is an received frame */
00466         FTDM_TRACE_DIR_INCOMING,
00467         /* This is a transmitted frame */
00468         FTDM_TRACE_DIR_OUTGOING,
00469         /* Invalid */
00470         FTDM_TRACE_DIR_INVALID,
00471 } ftdm_trace_dir_t;

enum ftdm_wait_flag_t

I/O waiting flags.

Enumerator:
FTDM_NO_FLAGS 
FTDM_READ 
FTDM_WRITE 
FTDM_EVENTS 
00552              {
00553         FTDM_NO_FLAGS = 0,
00554         FTDM_READ =  (1 << 0),
00555         FTDM_WRITE = (1 << 1),
00556         FTDM_EVENTS = (1 << 2)
00557 } ftdm_wait_flag_t;


Function Documentation

ftdm_status_t _ftdm_call_place ( const char *  file,
const char *  func,
int  line,
ftdm_caller_data_t caller_data,
ftdm_hunting_scheme_t hunting 
)

Place an outgoing call with the given caller data in a channel according to the hunting scheme provided and records the place where it was called. See ftdm_call_place for an easy to use macro.

Returns:
FTDM_SUCCESS if the call attempt was successful FTDM_FAIL if there was an unspecified error FTDM_EBUSY if the channel was busy FTDM_BREAK if glare was detected and you must try again
Note:
Even when FTDM_SUCCESS is returned, the call may still fail later on due to glare, in such case FTDM_SIGEVENT_STOP will be sent with the hangup cause field set to FTDM_CAUSE_REQUESTED_CHAN_UNAVAIL

When this function returns FTDM_SUCCESS, the member .fchan from caller_data will be set to the channel used to place the call and .call_id to the generated call id for that call

When this function is successful you are guaranteed to receive FTDM_SIGEVENT_DIALING, this event could even be delivered before your execution thread returns from this function

ftdm_status_t _ftdm_channel_call_answer ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan 
)

Answer call recording the source code point where the it was called (see ftdm_channel_call_answer for an easy to use macro).

ftdm_status_t _ftdm_channel_call_hangup ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan 
)

Hangup the call without cause recording the source code point where it was called (see ftdm_channel_call_hangup for an easy to use macro).

ftdm_status_t _ftdm_channel_call_hangup_with_cause ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan,
ftdm_call_cause_t   
)

Hangup the call with cause recording the source code point where it was called (see ftdm_channel_call_hangup_with_cause for an easy to use macro).

ftdm_status_t _ftdm_channel_call_hold ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan 
)

Put a call on hold recording the source code point where it was called (see ftdm_channel_call_hold for an easy to use macro).

ftdm_status_t _ftdm_channel_call_indicate ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan,
ftdm_channel_indication_t  indication 
)

Indicate a new condition in an incoming call recording the source code point where it was called (see ftdm_channel_call_indicate for an easy to use macro).

ftdm_status_t _ftdm_channel_call_place ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan 
)

Place an outgoing call recording the source code point where it was called (see ftdm_channel_call_place for an easy to use macro).

Deprecated:
This function is deprecated since leaves the door open to glare issues, use ftdm_call_place instead

ftdm_status_t _ftdm_channel_call_send_msg ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan,
ftdm_sigmsg_t *  sigmsg 
)

Send a signal on a call recording the source code point where it was called (see ftdm_channel_call_send_msg for an easy to use macro).

ftdm_status_t _ftdm_channel_call_unhold ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan 
)

Unhold a call recording the source code point where it was called (see ftdm_channel_call_unhold for an easy to use macro).

ftdm_status_t _ftdm_channel_reset ( const char *  file,
const char *  func,
int  line,
ftdm_channel_t *  ftdmchan 
)

Reset the channel (see _ftdm_channel_reset for an easy to use macro).

Note:
if there was a call on this channel, call will be cleared without any notifications to the user

FT_DECLARE_NONSTD ( ftdm_status_t   ) 

Basic transcoding functions.

char* ftdm_api_execute ( const char *  cmd  ) 

Execute a text command. The text command output will be returned and must be free'd.

Parameters:
cmd The command to execute
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_call_add_var ( ftdm_caller_data_t caller_data,
const char *  var_name,
const char *  value 
)

Add a custom variable to the call.

Note:
This variables may be used by signaling modules to override signaling parameters
Todo:
Document which signaling variables are available

void ftdm_call_clear_data ( ftdm_caller_data_t caller_data  ) 

Clears all the temporary data attached to this call.

Note:
Clears caller_data->variables and caller_data->raw_data.

ftdm_status_t ftdm_call_clear_vars ( ftdm_caller_data_t caller_data  ) 

Clear all variables attached to the call.

Note:
Variables are cleared at the end of each call back, so it is not necessary for the user to call this function.
Todo:
Document which signaling variables are available

ftdm_status_t ftdm_call_get_current_var ( ftdm_iterator_t iter,
const char **  var_name,
const char **  var_val 
)

Get variable name and value for the current iterator position.

const char* ftdm_call_get_var ( ftdm_caller_data_t caller_data,
const char *  var_name 
)

Get a custom variable from the call.

Note:
The variable pointer returned is only valid during the callback receiving SIGEVENT.

ftdm_iterator_t* ftdm_call_get_var_iterator ( const ftdm_caller_data_t caller_data,
ftdm_iterator_t iter 
)

Get an iterator to iterate over the channel variables.

Parameters:
caller_data The signal msg structure containing the variables
iter Optional iterator. You can reuse an old iterator (not previously freed) to avoid the extra allocation of a new iterator.
Note:
The iterator pointer returned is only valid while the signal message and it'll be destroyed when the signal message is processed. This iterator is completely non-thread safe, if you are adding variables or removing variables while iterating results are unpredictable

ftdm_status_t ftdm_call_remove_var ( ftdm_caller_data_t caller_data,
const char *  var_name 
)

Remove a variable attached to the call.

Note:
Removes a variable that was attached to the call.
Todo:
Document which call variables are available

ftdm_status_t ftdm_channel_add_to_group ( const char *  name,
ftdm_channel_t *  ftdmchan 
)

Add the channel to a hunt group.

ftdm_status_t ftdm_channel_add_token ( ftdm_channel_t *  ftdmchan,
char *  token,
int  end 
)

Add a new token to the channel.

Parameters:
ftdmchan The channel where the token will be added
token The token string to add
end if 0, the token will be added at the beginning of the token list, to the end otherwise
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_channel_add_var ( ftdm_channel_t *  ftdmchan,
const char *  var_name,
const char *  value 
)

Add a custom variable to the channel.

Note:
This variables may be used by signaling modules to override signaling parameters
Todo:
Document which signaling variables are available

ftdm_bool_t ftdm_channel_call_check_answered ( const ftdm_channel_t *  ftdmchan  ) 

Check if the call is answered already.

ftdm_bool_t ftdm_channel_call_check_busy ( const ftdm_channel_t *  ftdmchan  ) 

Check if the call is busy.

ftdm_bool_t ftdm_channel_call_check_done ( const ftdm_channel_t *  ftdmchan  ) 

Check if the call is done (final state for a call, just after hangup).

ftdm_bool_t ftdm_channel_call_check_hangup ( const ftdm_channel_t *  ftdmchan  ) 

Check if the call is hangup.

ftdm_bool_t ftdm_channel_call_check_hold ( const ftdm_channel_t *  ftdmchan  ) 

Check if the call is in hold.

ftdm_status_t ftdm_channel_clear_token ( ftdm_channel_t *  ftdmchan,
const char *  token 
)

Remove the given token from the channel.

Parameters:
ftdmchan The channel where the token is
token The token string. If NULL, all tokens in the channel are cleared
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_channel_close ( ftdm_channel_t **  ftdmchan  ) 

Close a previously open channel.

Warning:
FreeTDM is more and more a signaling API rather than just a plane IO API, unless you are using FreeTDM as a pure IO API without its signaling modules, you should not use this function
Note:
If you placed a call in this channel use ftdm_channel_call_hangup(), you MUST NOT call this function, the signaling stack will close the channel when the call is done.
Parameters:
ftdmchan pointer to the channel to close
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

ftdm_status_t ftdm_channel_command ( ftdm_channel_t *  ftdmchan,
ftdm_command_t  command,
void *  arg 
)

Execute a command in a channel (same semantics as the ioctl() unix system call).

Parameters:
ftdmchan The channel to execute the command
command The command to execute
arg The argument for the command
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

ftdm_size_t ftdm_channel_dequeue_dtmf ( ftdm_channel_t *  ftdmchan,
char *  dtmf,
ftdm_size_t  len 
)

Dequeue DTMF from the given channel.

Note:
To transmit DTMF use ftdm_channel_command with command FTDM_COMMAND_SEND_DTMF
Parameters:
ftdmchan The channel to dequeue DTMF from
dtmf DTMF buffer to store the dtmf (you are responsible for its allocation and deallocation)
len The size of the provided DTMF buffer
Return values:
The size of the dequeued DTMF (it might be zero if there is no DTMF in the queue)

void ftdm_channel_flush_dtmf ( ftdm_channel_t *  ftdmchan  ) 

Flush the DTMF queue.

Parameters:
ftdmchan The channel to flush the dtmf queue of

ftdm_status_t ftdm_channel_get_alarms ( ftdm_channel_t *  ftdmchan,
ftdm_alarm_flag_t alarmbits 
)

Get the current alarm bitmask for the channel.

Parameters:
ftdmchan The channel to get the alarm bitmask from
alarmbits The alarm bitmask pointer to store the current alarms (you are responsible for allocation/deallocation)
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

int ftdm_channel_get_availability ( ftdm_channel_t *  ftdmchan  ) 

Return the availability rate for a channel.

Parameters:
ftdmchan Channel to get the availability from
Return values:
> 0 if availability is supported
-1 if availability is not supported

ftdm_caller_data_t* ftdm_channel_get_caller_data ( ftdm_channel_t *  channel  ) 

Get the caller data for a channel, typically you need this when receiving FTDM_SIGEVENT_START.

ftdm_codec_t ftdm_channel_get_codec ( const ftdm_channel_t *  ftdmchan  ) 

Get the I/O read/write codec.

Parameters:
ftdmchan The channel to get the codec from
Return values:
The codec type

ftdm_status_t ftdm_channel_get_current_var ( ftdm_iterator_t iter,
const char **  var_name,
const char **  var_val 
)

Get variable name and value for the current iterator position.

char* ftdm_channel_get_history_str ( const ftdm_channel_t *  channel  ) 

For display debugging purposes you can display this string which describes the history of the channel.

Parameters:
channel The channel to get the history from
Returns:
History string for the channel. You must free the string with ftdm_free

uint32_t ftdm_channel_get_id ( const ftdm_channel_t *  ftdmchan  ) 

Get the id associated to the channel.

uint32_t ftdm_channel_get_io_interval ( const ftdm_channel_t *  ftdmchan  ) 

Get the I/O read/write interval.

Parameters:
ftdmchan The channel to get the interval from
Return values:
The interval in milliseconds

uint32_t ftdm_channel_get_io_packet_len ( const ftdm_channel_t *  ftdmchan  ) 

Get the I/O read/write packet length per interval.

Parameters:
ftdmchan The channel to get the packet length from
Return values:
The packet length interval in bytes

const char* ftdm_channel_get_last_error ( const ftdm_channel_t *  ftdmchan  ) 

Get the last error string for the channel.

Parameters:
ftdmchan The channel to get the error from
Return values:
The error string (not thread-safe, the string is per channel, not per thread)

int ftdm_channel_get_last_state ( const ftdm_channel_t *  ftdmchan  ) 

Get last state of a channel.

const char* ftdm_channel_get_last_state_str ( const ftdm_channel_t *  channel  ) 

For display debugging purposes you can display this string which describes the last channel internal state.

const char* ftdm_channel_get_name ( const ftdm_channel_t *  ftdmchan  ) 

Get the name associated to the channel.

const char* ftdm_channel_get_number ( const ftdm_channel_t *  ftdmchan  ) 

Get the number associated to the channel.

uint32_t ftdm_channel_get_ph_id ( const ftdm_channel_t *  ftdmchan  ) 

Get the number physical id associated to the channel.

uint32_t ftdm_channel_get_ph_span_id ( const ftdm_channel_t *  ftdmchan  ) 

Get the physical span id associated to the channel.

void* ftdm_channel_get_private ( const ftdm_channel_t *  ftdmchan  ) 

Get user private data in the channel.

Parameters:
ftdmchan The channel to retrieve the private data
Return values:
The private data (if any or NULL if no data has been stored)

ftdm_status_t ftdm_channel_get_sig_status ( ftdm_channel_t *  ftdmchan,
ftdm_signaling_status_t status 
)

Get channel signaling status (ie: whether protocol layer is up or down).

ftdm_span_t* ftdm_channel_get_span ( const ftdm_channel_t *  ftdmchan  ) 

Get the span pointer associated to the channel.

uint32_t ftdm_channel_get_span_id ( const ftdm_channel_t *  ftdmchan  ) 

Get the span pointer associated to the channel.

const char* ftdm_channel_get_span_name ( const ftdm_channel_t *  ftdmchan  ) 

Get the span name associated to the channel.

int ftdm_channel_get_state ( const ftdm_channel_t *  ftdmchan  ) 

Get current state of a channel.

const char* ftdm_channel_get_state_str ( const ftdm_channel_t *  channel  ) 

For display debugging purposes you can display this string which describes the current channel internal state.

const char* ftdm_channel_get_token ( const ftdm_channel_t *  ftdmchan,
uint32_t  tokenid 
)

Get the requested token.

Parameters:
ftdmchan The channel where the token is
tokenid The id of the token
Return values:
The token character string
NULL token not found

uint32_t ftdm_channel_get_token_count ( const ftdm_channel_t *  ftdmchan  ) 

Get the token count.

Parameters:
ftdmchan The channel to get the token count from
Return values:
The token count

ftdm_chan_type_t ftdm_channel_get_type ( const ftdm_channel_t *  ftdmchan  ) 

Get the channel type.

Parameters:
ftdmchan The channel to get the type from
Return values:
channel type (FXO, FXS, B-channel, D-channel, etc)

const char* ftdm_channel_get_var ( ftdm_channel_t *  ftdmchan,
const char *  var_name 
)

Get a custom variable from the channel.

Note:
The variable pointer returned is only valid while the channel is open and it'll be destroyed when the channel is closed.

ftdm_iterator_t* ftdm_channel_get_var_iterator ( const ftdm_channel_t *  ftdmchan,
ftdm_iterator_t iter 
)

Get an iterator to iterate over the channel variables.

Parameters:
ftdmchan The channel structure containing the variables
iter Optional iterator. You can reuse an old iterator (not previously freed) to avoid the extra allocation of a new iterator.
Note:
The iterator pointer returned is only valid while the channel is open and it'll be destroyed when the channel is closed. This iterator is completely non-thread safe, if you are adding variables or removing variables while iterating results are unpredictable

ftdm_status_t ftdm_channel_init ( ftdm_channel_t *  ftdmchan  ) 

Initialize channel state for an outgoing call.

Deprecated:
This API is only used for boost signaling

ftdm_status_t ftdm_channel_open ( uint32_t  span_id,
uint32_t  chan_id,
ftdm_channel_t **  ftdmchan 
)

Open a channel specifying the span id and chan id (required before placing a call on the channel).

Warning:
Try using ftdm_call_place instead if you plan to place a call after opening the channel
Note:
You must call ftdm_channel_close() or ftdm_channel_call_hangup() to release the channel afterwards Only use ftdm_channel_close if there is no call (incoming or outgoing) in the channel
Parameters:
span_id The span id the channel belongs to
chan_id Channel id of the channel you want to open
ftdmchan Pointer to store the channel once is open
Return values:
FTDM_SUCCESS success (the channel was found and is available)
FTDM_FAIL failure (channel was not found or not available)

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 
)

Hunts and opens a channel specifying group id.

Warning:
Try using ftdm_call_place instead if you plan to place a call after opening the channel
Note:
You must call ftdm_channel_close() or ftdm_channel_call_hangup() to release the channel afterwards Only use ftdm_channel_close if there is no call (incoming or outgoing) in the channel
Parameters:
group_id The group id to hunt for a channel
direction The hunting direction
caller_data The calling party information
ftdmchan The channel pointer to store the available channel
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

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 
)

Hunts and opens a channel specifying the span id only.

Warning:
Try using ftdm_call_place instead if you plan to place a call after opening the channel
Note:
You must call ftdm_channel_close() or ftdm_channel_call_hangup() to release the channel afterwards Only use ftdm_channel_close if there is no call (incoming or outgoing) in the channel
Parameters:
span_id The span id to hunt for a channel
direction The hunting direction
caller_data The calling party information
ftdmchan The channel pointer to store the available channel
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

ftdm_status_t ftdm_channel_read ( ftdm_channel_t *  ftdmchan,
void *  data,
ftdm_size_t *  datalen 
)

Read data from a channel.

Parameters:
ftdmchan The channel to read data from
data The pointer to the buffer to store the read data
datalen The size in bytes of the provided buffer
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

ftdm_status_t ftdm_channel_read_event ( ftdm_channel_t *  ftdmchan,
ftdm_event_t **  event 
)

Retrieves an event from the span.

Note:
This function is non-reentrant and not thread-safe. The event returned may be modified if the function is called again from a different thread or even the same. It is recommended to handle events from the same span in a single thread.
Parameters:
ftdmchan The channel to retrieve the event from
event Pointer to store the pointer to the event
Return values:
FTDM_SUCCESS success (at least one event available)
FTDM_FAIL failure

ftdm_status_t ftdm_channel_remove_from_group ( ftdm_group_t *  group,
ftdm_channel_t *  ftdmchan 
)

Remove the channel from a hunt group.

void ftdm_channel_replace_token ( ftdm_channel_t *  ftdmchan,
const char *  old_token,
const char *  new_token 
)

Replace the given token with the new token.

Parameters:
ftdmchan The channel where the token is
old_token The token to replace
new_token The token to put in place

ftdm_status_t ftdm_channel_set_caller_data ( ftdm_channel_t *  ftdmchan,
ftdm_caller_data_t caller_data 
)

Set the caller data for a channel. Be sure to call this before ftdm_channel_call_place().

void ftdm_channel_set_private ( ftdm_channel_t *  ftdmchan,
void *  pvt 
)

Set user private data in the channel.

Parameters:
ftdmchan The channel where the private data will be stored
pvt The private pointer to store

ftdm_status_t ftdm_channel_set_sig_status ( ftdm_channel_t *  ftdmchan,
ftdm_signaling_status_t  status 
)

Set channel signaling status (ie: put specific circuit down) only if supported by the signaling.

ftdm_status_t ftdm_channel_wait ( ftdm_channel_t *  ftdmchan,
ftdm_wait_flag_t flags,
int32_t  timeout 
)

Wait for I/O events in a channel.

Parameters:
ftdmchan The channel to wait I/O for
flags The wait I/O flags
timeout The timeout in milliseconds
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

ftdm_status_t ftdm_channel_write ( ftdm_channel_t *  ftdmchan,
void *  data,
ftdm_size_t  datasize,
ftdm_size_t *  datalen 
)

Write data to a channel.

Note:
The difference between data and datasize is subtle but important.
datalen is a pointer to the size of the actual data that you want to write. This pointer will be updated with the number of bytes actually written.

datasize on the other hand is the size of the entire buffer provided in data, whether all of that buffer is in use or not is a different matter. The difference becomes important only if you are using FreeTDM doing transcoding, for example, providing a ulaw frame of 160 bytes but where the I/O device accepts input in signed linear, the data to write will be 320 bytes, therefore datasize is expected to be at least 320 where datalen would be just 160.

Parameters:
ftdmchan The channel to write data to
data The pointer to the buffer to write
datasize The maximum number of bytes in data that can be used (in case transcoding is necessary)
datalen The size of the actual data
Return values:
FTDM_SUCCESS success (a suitable channel was found available)
FTDM_FAIL failure (no suitable channel was found available)

ftdm_status_t ftdm_conf_node_add_param ( ftdm_conf_node_t *  node,
const char *  param,
const char *  val 
)

Adds a new parameter to the specified configuration node.

Parameters:
node The configuration node to add the param-val pair to
param The parameter name
val The parameter value
Returns:
FTDM_SUCCESS success

FTDM_FAIL failure

ftdm_status_t ftdm_conf_node_create ( const char *  name,
ftdm_conf_node_t **  node,
ftdm_conf_node_t *  parent 
)

Create a configuration node.

Parameters:
name The name of the configuration node
node The node pointer to store the new node
parent The parent node if any, or NULL if no parent
Returns:
FTDM_SUCCESS success

FTDM_FAIL failure

ftdm_status_t ftdm_conf_node_destroy ( ftdm_conf_node_t *  node  ) 

Destroy the memory allocated for a configuration node (and all of its descendance).

Parameters:
node The node to destroy
Returns:
FTDM_SUCCESS success

FTDM_FAIL failure

ftdm_status_t ftdm_configure_span ( ftdm_span_t *  span,
const char *  type,
fio_signal_cb_t  sig_cb,
  ... 
)

Configure span with a signaling type.

Deprecated:
use ftdm_configure_span_signaling instead
Note:
This function does the same as ftdm_configure_span_signaling
Parameters:
span The span to configure
type The signaling type ("boost", "isdn" and others, this depends on the available signaling modules)
sig_cb The callback that the signaling stack will use to notify about events
... variable argument list with "var", value sequence, the variable and values are signaling type dependant the last argument must be FTDM_TAG_END
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_configure_span_channels ( ftdm_span_t *  span,
const char *  str,
ftdm_channel_config_t chan_config,
unsigned *  configured 
)

Create and configure channels in the given span.

Parameters:
span The span container
str The channel range null terminated string. "1-10", "24" etc
chan_config The basic channel configuration for each channel within the range
configured Pointer where the number of channels configured will be stored
Returns:
FTDM_SUCCESS success

FTDM_FAIL failure

ftdm_status_t ftdm_configure_span_signaling ( ftdm_span_t *  span,
const char *  type,
fio_signal_cb_t  sig_cb,
ftdm_conf_parameter_t parameters 
)

Configure span with a signaling type.

Parameters:
span The span to configure
type The signaling type ("boost", "isdn" and others, this depends on the available signaling modules)
sig_cb The callback that the signaling stack will use to notify about events
parameters The array if signaling-specific parameters (the last member of the array MUST have its var member set to NULL, ie: .var = NULL)
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_global_add_io_interface ( ftdm_io_interface_t *  io_interface  ) 

Register a custom I/O interface with the FreeTDM core.

Parameters:
io_interface the Interface to register
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_global_configuration ( void   ) 

Create spans and channels reading the freetdm.conf file.

ftdm_status_t ftdm_global_destroy ( void   ) 

Shutdown the library.

ftdm_status_t ftdm_global_init ( void   ) 

Initialize the library.

void ftdm_global_set_config_directory ( const char *  path  ) 

Set the directory to look for configs.

void ftdm_global_set_crash_policy ( ftdm_crash_policy_t  policy  ) 

Set the crash policy for the library.

void ftdm_global_set_default_logger ( int  level  ) 

Set the default logger level.

void ftdm_global_set_logger ( ftdm_logger_t  logger  ) 

Set the logger handler for the library.

ftdm_status_t ftdm_global_set_memory_handler ( ftdm_memory_handler_t *  handler  ) 

Set memory handler for the library.

void ftdm_global_set_mod_directory ( const char *  path  ) 

Set the directory to look for modules.

ftdm_status_t ftdm_global_set_queue_handler ( ftdm_queue_handler_t handler  ) 

Override the default queue handler.

ftdm_status_t ftdm_group_channel_use_count ( ftdm_group_t *  group,
uint32_t *  count 
)

Get the number of channels in use on a group.

ftdm_status_t ftdm_group_create ( ftdm_group_t **  group,
const char *  name 
)

Create a group with the given name.

ftdm_status_t ftdm_group_find ( uint32_t  id,
ftdm_group_t **  group 
)

Find a hunt group by id.

ftdm_status_t ftdm_group_find_by_name ( const char *  name,
ftdm_group_t **  group 
)

Find a hunt group by name.

uint32_t ftdm_group_get_id ( const ftdm_group_t *  group  ) 

Get the id of a group.

void* ftdm_iterator_current ( ftdm_iterator_t iter  ) 

Get iterator current value (depends on the iterator type).

Note:
Channel iterators return a pointer to ftdm_channel_t Variable iterators return a pointer to the variable name (not the variable value)

ftdm_status_t ftdm_iterator_free ( ftdm_iterator_t iter  ) 

Free iterator.

Note:
You must free an iterator after using it unless you plan to reuse it

ftdm_iterator_t* ftdm_iterator_next ( ftdm_iterator_t iter  ) 

Advance iterator.

ftdm_bool_t ftdm_running ( void   ) 

Check if the FTDM library is initialized and running.

ftdm_status_t ftdm_span_add_channel ( ftdm_span_t *  span,
ftdm_socket_t  sockfd,
ftdm_chan_type_t  type,
ftdm_channel_t **  chan 
)

Add a new channel to a span.

Parameters:
span Where to add the new channel
sockfd The socket device associated to the channel (ie: sangoma device, dahdi device etc)
type Channel type
chan Pointer to store the newly allocated channel
Return values:
FTDM_SUCCESS success (the channel was created)
FTDM_FAIL failure (span was not created)

ftdm_status_t ftdm_span_channel_use_count ( ftdm_span_t *  span,
uint32_t *  count 
)

Get the number of channels in use on a span.

ftdm_status_t ftdm_span_create ( const char *  iotype,
const char *  name,
ftdm_span_t **  span 
)

Create a new span (not needed if you are using freetdm.conf).

Parameters:
iotype The I/O interface type this span will use. This depends on the available I/O modules ftmod_wanpipe = "wanpipe" (Sangoma) ftmod_zt = "zt" (DAHDI or Zaptel) ftmod_pika "pika" (this one is most likely broken)
name Name for the span
span Pointer to store the create span
Return values:
FTDM_SUCCESS success (the span was created)
FTDM_FAIL failure (span was not created)

ftdm_status_t ftdm_span_find ( uint32_t  id,
ftdm_span_t **  span 
)

Find a span by its id.

Parameters:
id The span id
span Pointer to store the span if found
Return values:
FTDM_SUCCESS success (span is valid)
FTDM_FAIL failure (span is not valid)

ftdm_status_t ftdm_span_find_by_name ( const char *  name,
ftdm_span_t **  span 
)

Find a span by name.

uint32_t ftdm_span_get_chan_count ( const ftdm_span_t *  span  ) 

Return the channel count number for the given span.

ftdm_iterator_t* ftdm_span_get_chan_iterator ( const ftdm_span_t *  span,
ftdm_iterator_t iter 
)

Get iterator for the span channels.

Parameters:
span The span containing the channels
iter Optional iterator. You can reuse an old iterator (not previously freed) to avoid the extra allocation of a new iterator.

ftdm_channel_t* ftdm_span_get_channel ( const ftdm_span_t *  span,
uint32_t  chanid 
)

Return the channel identified by the provided id.

Parameters:
span The span where the channel belongs
chanid The channel id within the span
Returns:
The channel pointer if found, NULL otherwise

uint32_t ftdm_span_get_id ( const ftdm_span_t *  span  ) 

Get the span id.

const char* ftdm_span_get_last_error ( const ftdm_span_t *  span  ) 

Get the last error string for the given span.

Parameters:
span The span to get the last error from
Return values:
character string for the last error

const char* ftdm_span_get_name ( const ftdm_span_t *  span  ) 

Get the span name.

ftdm_status_t ftdm_span_get_sig_status ( ftdm_span_t *  span,
ftdm_signaling_status_t status 
)

Get span signaling status (ie: whether protocol layer is up or down).

ftdm_trunk_type_t ftdm_span_get_trunk_type ( const ftdm_span_t *  span  ) 

Get the trunk type for a span.

Parameters:
span The span
Returns:
The span trunk type

const char* ftdm_span_get_trunk_type_str ( const ftdm_span_t *  span  ) 

For display debugging purposes you can display this string which describes the trunk type of a span.

ftdm_status_t ftdm_span_poll_event ( ftdm_span_t *  span,
uint32_t  ms,
short *  poll_events 
)

Wait for an event in the span.

Parameters:
span The span to wait events for
ms Milliseconds timeout
poll_events Array of events to poll for, for each channel on the span
Return values:
FTDM_SUCCESS success (at least one event available)
FTDM_TIMEOUT Timed out waiting for events
FTDM_FAIL failure

ftdm_status_t ftdm_span_set_blocking_mode ( const ftdm_span_t *  span,
ftdm_bool_t  enabled 
)

Enable/disable blocking mode in the channels for this span.

ftdm_status_t ftdm_span_set_sig_status ( ftdm_span_t *  span,
ftdm_signaling_status_t  status 
)

Set span signaling status (ie: put the whole span protocol layer down) only if supported by the signaling.

void ftdm_span_set_trunk_type ( ftdm_span_t *  span,
ftdm_trunk_type_t  type 
)

Set the trunk type for a span This must be called before configuring any channels within the span.

Parameters:
span The span
type The trunk type

ftdm_status_t ftdm_span_start ( ftdm_span_t *  span  ) 

Start the span signaling (must call ftdm_configure_span_signaling first).

Note:
Even before this function returns you may receive signaling events! Never block in the signaling callback since it might be called in a thread that handles more than 1 call and therefore you would be blocking all the calls handled by that thread!
Parameters:
span The span to start
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

ftdm_status_t ftdm_span_stop ( ftdm_span_t *  span  ) 

Stop the span signaling (must call ftdm_span_start first).

Note:
certain signalings (boost signaling) does not support granular span start/stop so it is recommended to always configure all spans and then starting them all and finally stop them all (or call ftdm_global_destroy which takes care of stopping and destroying the spans at once).
Parameters:
span The span to stop
Return values:
FTDM_SUCCESS success
FTDM_FAIL failure

FTDM_STR2ENUM_P ( ftdm_str2channel_indication  ,
ftdm_channel_indication2str  ,
ftdm_channel_indication_t   
)

Move from string to ftdm_channel_indication_t and viceversa.

00517                {
00518         /* The indication that was completed */
00519         ftdm_channel_indication_t indication;
00520         /* Completion status of the indication */
00521         ftdm_status_t status;
00522 } ftdm_event_indication_completed_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_trace_type  ,
ftdm_trace_type2str  ,
ftdm_trace_type_t   
)

Move string to ftdm_trace_type_t and viceversa.

00487                {
00488         /* Direction - incoming or outgoing */
00489         ftdm_trace_dir_t dir;
00490         ftdm_trace_type_t type;
00491 } ftdm_event_trace_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_trace_dir  ,
ftdm_trace_dir2str  ,
ftdm_trace_dir_t   
)

Move string to ftdm_trace_dir_t and viceversa.

00477              {
00478         FTDM_TRACE_TYPE_Q931,
00479         FTDM_TRACE_TYPE_Q921,
00480         FTDM_TRACE_TYPE_INVALID,
00481 } ftdm_trace_type_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_signaling_status  ,
ftdm_signaling_status2str  ,
ftdm_signaling_status_t   
)

Move from string to ftdm_signaling_status_t and viceversa.

00460                {
00461         ftdm_signaling_status_t status;
00462 } ftdm_event_sigstatus_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_trunk_type  ,
ftdm_trunk_type2str  ,
ftdm_trunk_type_t   
)

Move from string to ftdm_trunk_type_t and viceversa Basic channel configuration provided to ftdm_configure_span_channels.

00430                                    {    
00431         char name[FTDM_MAX_NAME_STR_SZ];
00432         char number[FTDM_MAX_NUMBER_STR_SZ];
00433         char group_name[FTDM_MAX_NAME_STR_SZ];
00434         ftdm_chan_type_t type;
00435         float rxgain;
00436         float txgain;
00437         uint8_t debugdtmf;
00438 } ftdm_channel_config_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_signal_event  ,
ftdm_signal_event2str  ,
ftdm_signal_event_t   
)

Move from string to ftdm_signal_event_t and viceversa Span trunk types.

00413              {
00414         FTDM_TRUNK_E1,
00415         FTDM_TRUNK_T1,
00416         FTDM_TRUNK_J1,
00417         FTDM_TRUNK_BRI,
00418         FTDM_TRUNK_BRI_PTMP,
00419         FTDM_TRUNK_FXO,
00420         FTDM_TRUNK_FXS,
00421         FTDM_TRUNK_EM,
00422         FTDM_TRUNK_NONE
00423 } ftdm_trunk_type_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_calling_party_category  ,
ftdm_calling_party_category2str  ,
ftdm_calling_party_category_t   
)

Digit limit used in DNIS/ANI Number abstraction.

00288                {
00289         char digits[FTDM_DIGITS_LIMIT];
00290         uint8_t type;
00291         uint8_t plan;
00292 } ftdm_number_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_usr_layer1_prot  ,
ftdm_user_layer1_prot2str  ,
ftdm_user_layer1_prot_t   
)

Calling Party Category

00271              {
00272         FTDM_CPC_UNKNOWN,
00273         FTDM_CPC_OPERATOR,
00274         FTDM_CPC_ORDINARY,
00275         FTDM_CPC_PRIORITY,
00276         FTDM_CPC_DATA,
00277         FTDM_CPC_TEST,
00278         FTDM_CPC_PAYPHONE,
00279         FTDM_CPC_INVALID
00280 } ftdm_calling_party_category_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_bearer_cap  ,
ftdm_bearer_cap2str  ,
ftdm_bearer_cap_t   
)

user information layer 1 protocol

00261              {
00262         FTDM_USER_LAYER1_PROT_V110 = 0x01,
00263         FTDM_USER_LAYER1_PROT_ULAW = 0x02,
00264         FTDM_USER_LAYER1_PROT_ALAW = 0x03,
00265         FTDM_USER_LAYER1_PROT_INVALID
00266 } ftdm_user_layer1_prot_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_screening  ,
ftdm_screening2str  ,
ftdm_screening_t   
)

bearer capability

00251              {
00252         FTDM_BEARER_CAP_SPEECH = 0x00,
00253         FTDM_BEARER_CAP_64K_UNRESTRICTED = 0x02,
00254         FTDM_BEARER_CAP_3_1KHZ_AUDIO = 0x03,
00255         FTDM_BEARER_CAP_INVALID
00256 } ftdm_bearer_cap_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_presentation  ,
ftdm_presentation2str  ,
ftdm_presentation_t   
)

Screening Ind

00240              {
00241         FTDM_SCREENING_NOT_SCREENED,
00242         FTDM_SCREENING_VERIFIED_PASSED,
00243         FTDM_SCREENING_VERIFIED_FAILED,
00244         FTDM_SCREENING_NETWORK_PROVIDED,
00245         FTDM_SCREENING_INVALID
00246 } ftdm_screening_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_npi  ,
ftdm_npi2str  ,
ftdm_npi_t   
)

Presentation Ind

00229              {
00230         FTDM_PRES_ALLOWED,
00231         FTDM_PRES_RESTRICTED,
00232         FTDM_PRES_NOT_AVAILABLE,
00233         FTDM_PRES_RESERVED,
00234         FTDM_PRES_INVALID
00235 } ftdm_presentation_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_ton  ,
ftdm_ton2str  ,
ftdm_ton_t   
)

Numbering Plan Identification (NPI)

00215              {
00216         FTDM_NPI_UNKNOWN = 0,
00217         FTDM_NPI_ISDN = 1,
00218         FTDM_NPI_DATA = 3,
00219         FTDM_NPI_TELEX = 4,
00220         FTDM_NPI_NATIONAL = 8,
00221         FTDM_NPI_PRIVATE = 9,
00222         FTDM_NPI_RESERVED = 10,
00223         FTDM_NPI_INVALID
00224 } ftdm_npi_t;

FTDM_STR2ENUM_P ( ftdm_str2ftdm_chan_type  ,
ftdm_chan_type2str  ,
ftdm_chan_type_t   
) const

transform from channel type to string and from string to channel type ftdm_str2ftdm_chan_type transforms a channel string (ie: "FXO" to FTDM_CHAN_TYPE_FXO) ftdm_chan_type2str transforms a channel type to string (ie: FTDM_CHAN_TYPE_B to "B") Test if a channel is a voice channel Test if a channel is a D-channel Logging function prototype to be used for all FreeTDM logs you should use ftdm_global_set_logger to set your own logger


Variable Documentation

ftdm_size_t ftdm_size_t* datalen

ftdm_size_t ftdm_size_t* datalen

ftdm_size_t ftdm_size_t* datalen

ftdm_size_t ftdm_size_t* datalen

ftdm_size_t ftdm_size_t* datalen

ftdm_size_t ftdm_size_t* datalen

const char int int const char* fmt

ftdm_bearer_cap_t

ftdm_calling_party_category_t

ftdm_channel_config_t

ftdm_event_indication_completed_t

ftdm_event_sigstatus_t

ftdm_event_trace_t

FT_DECLARE_DATA ftdm_logger_t ftdm_log

ftdm_npi_t

ftdm_number_t

ftdm_presentation_t

const char int int const char typedef ftdm_status_t(*) ftdm_queue_create_func_t(ftdm_queue_t **queue, ftdm_size_t capacity)

Data queue operation functions you can use ftdm_global_set_queue_handler if you want to override the default implementation (not recommended).

ftdm_screening_t

ftdm_trace_type_t

ftdm_trunk_type_t

ftdm_user_layer1_prot_t

const char* func

const char int int level

const char int line

ftdm_size_t max

ftdm_size_t max

ftdm_size_t max

ftdm_size_t max

ftdm_size_t max

ftdm_size_t max


Generated on Fri Jan 14 10:44:04 2011 for FreeTDM by  doxygen 1.4.7