Merge branch 'master' into netborder

Conflicts: libs/freetdm/src/ftdm_io.c libs/freetdm/src/ftmod/ftmod_sangoma_isdn/ftmod_sangoma_isdn_trace.c libs/freetdm/src/include/freetdm.h
2025-08-13 01:26:58 +00:00 · 2011-01-05 13:11:37 -05:00
parent 9be9d799f3 f574db0958
commit eb84fc772f
224 changed files with 13786 additions and 6134 deletions
--- a/libs/freetdm/src/include/freetdm.h
+++ b/libs/freetdm/src/include/freetdm.h
@@ -144,7 +144,9 @@ typedef enum {
 /*! \brief Hunting direction (when hunting for free channels) */
 typedef enum {
 	FTDM_TOP_DOWN,
-	FTDM_BOTTOM_UP
+	FTDM_BOTTOM_UP,
+	FTDM_RR_DOWN,
+	FTDM_RR_UP,
 } ftdm_direction_t;

 /*! \brief I/O channel type */
@@ -265,15 +267,32 @@ typedef enum {
 #define USER_LAYER1_PROT_STRINGS "V.110", "u-law", "a-law", "Invalid"
 FTDM_STR2ENUM_P(ftdm_str2ftdm_usr_layer1_prot, ftdm_user_layer1_prot2str, ftdm_user_layer1_prot_t)

+/*! Calling Party Category */
+typedef enum {
+	FTDM_CPC_UNKNOWN,
+	FTDM_CPC_OPERATOR,
+	FTDM_CPC_ORDINARY,
+	FTDM_CPC_PRIORITY,
+	FTDM_CPC_DATA,
+	FTDM_CPC_TEST,
+	FTDM_CPC_PAYPHONE,
+	FTDM_CPC_INVALID
+} ftdm_calling_party_category_t;
+#define CALLING_PARTY_CATEGORY_STRINGS "unknown", "operator", "ordinary", "priority", "data-call", "test-call", "payphone", "invalid"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_calling_party_category, ftdm_calling_party_category2str, ftdm_calling_party_category_t)
+
+/*! \brief Digit limit used in DNIS/ANI */
+#define FTDM_DIGITS_LIMIT 25
+
 /*! \brief Number abstraction */
 typedef struct {
-	char digits[25];
+	char digits[FTDM_DIGITS_LIMIT];
 	uint8_t type;
 	uint8_t plan;
 } ftdm_number_t;

 typedef void * ftdm_variable_container_t; 
-									 
+
 /*! \brief Caller information */
 typedef struct ftdm_caller_data {
 	char cid_date[8]; /*!< Caller ID date */
@@ -282,10 +301,10 @@ typedef struct ftdm_caller_data {
 	ftdm_number_t ani; /*!< ANI (Automatic Number Identification) */
 	ftdm_number_t dnis; /*!< DNIS (Dialed Number Identification Service) */
 	ftdm_number_t rdnis; /*!< RDNIS (Redirected Dialed Number Identification Service) */
-	char aniII[25]; /*! ANI II */
+	char aniII[FTDM_DIGITS_LIMIT]; /*! ANI II */
 	uint8_t screen; /*!< Screening */
 	uint8_t pres; /*!< Presentation*/
-	char collected[25]; /*!< Collected digits so far */
+	char collected[FTDM_DIGITS_LIMIT]; /*!< Collected digits so far */
 	int hangup_cause; /*!< Hangup cause */
 	char raw_data[1024]; /*!< Protocol specific raw caller data */
 	uint32_t raw_data_len; /*!< Raw data length */
@@ -294,12 +313,14 @@ typedef struct ftdm_caller_data {
 	ftdm_bearer_cap_t bearer_capability;
 	/* user information layer 1 protocol */
 	ftdm_user_layer1_prot_t bearer_layer1;
-	ftdm_variable_container_t variables; /*!<variables attached to this call */
+	ftdm_calling_party_category_t cpc; /*!< Calling party category */
+	ftdm_variable_container_t variables; /*!< Variables attached to this call */
 	/* We need call_id inside caller_data for the user to be able to retrieve 
 	 * the call_id when ftdm_channel_call_place is called. This is the only time
 	 * that the user can use caller_data.call_id to obtain the call_id. The user
 	 * should use the call_id from sigmsg otherwise */
 	uint32_t call_id; /*!< Unique call ID for this call */
+	ftdm_channel_t *fchan; /*!< FreeTDM channel associated (can be NULL) */
 } ftdm_caller_data_t;

 /*! \brief Tone type */
@@ -328,12 +349,13 @@ typedef enum {
 	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_INVALID, /*!<Invalid */
 } ftdm_signal_event_t;
 #define SIGNAL_STRINGS "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", "INVALID"
-
+		"COLLECTED_DIGIT", "ADD_CALL", "RESTART", "SIGSTATUS_CHANGED", "COLLISION", "FACILITY", \
+		"TRACE", "TRACE_RAW", "INDICATION_COMPLETED", "INVALID"
 /*! \brief Move from string to ftdm_signal_event_t and viceversa */
 FTDM_STR2ENUM_P(ftdm_str2ftdm_signal_event, ftdm_signal_event2str, ftdm_signal_event_t)

@@ -418,19 +440,55 @@ typedef struct {
 	ftdm_trace_type_t type;
 } ftdm_event_trace_t;

+typedef struct {
+	/* Digits collected */
+	char digits[FTDM_DIGITS_LIMIT];
+} ftdm_event_collected_t;
+
+/*! \brief 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 */
+typedef enum {
+	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,
+	/* Using this indication is equivalent to call ftdm_channel_call_answer API */
+	FTDM_CHANNEL_INDICATE_ANSWER,
+	FTDM_CHANNEL_INDICATE_INVALID,
+} ftdm_channel_indication_t;
+#define INDICATION_STRINGS "NONE", "RINGING", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "BUSY", "ANSWER", "INVALID"
+
+/*! \brief Move from string to ftdm_channel_indication_t and viceversa */
+FTDM_STR2ENUM_P(ftdm_str2channel_indication, ftdm_channel_indication2str, ftdm_channel_indication_t)
+
+typedef struct {
+	/* The indication that was completed */
+	ftdm_channel_indication_t indication;
+	/* Completion status of the indication */
+	ftdm_status_t status;
+} ftdm_event_indication_completed_t;
+
 /*! \brief Generic signaling message */
 struct ftdm_sigmsg {
 	ftdm_signal_event_t event_id; /*!< The type of message */
 	ftdm_channel_t *channel; /*!< Related channel */
 	uint32_t chan_id; /*!< easy access to chan id */
 	uint32_t span_id; /*!< easy access to span_id */
-	void *raw_data; /*!< Message specific data if any */
-	uint32_t raw_data_len; /*!< Data len in case is needed */
 	uint32_t call_id; /*!< unique call id for this call */
 	union {
 		ftdm_event_sigstatus_t sigstatus; /*!< valid if event_id is FTDM_SIGEVENT_SIGSTATUS_CHANGED */
 		ftdm_event_trace_t trace;	/*!< valid if event_id is FTDM_SIGEVENT_TRACE or FTDM_SIGEVENT_TRACE_RAW */
-	}ev_data;
+		ftdm_event_collected_t collected; /*!< valid if event_id is FTDM_SIGEVENT_COLLECTED_DIGIT */
+		ftdm_event_indication_completed_t indication_completed; /*!< valid if the event_id is FTDM_SIGEVENT_INDICATION_COMPLETED */
+	} ev_data;
+	struct {
+		uint8_t autofree; /*!< Whether the freetdm core will free it after message delivery */
+		uint32_t len; /*!< Data len */
+		void *data; /*!< Signaling module specific data */
+	} raw;
 };

 /*! \brief Crash policy 
@@ -535,11 +593,17 @@ typedef enum {
 	FTDM_COMMAND_GET_LINK_STATUS,
 	FTDM_COMMAND_ENABLE_LOOP,
 	FTDM_COMMAND_DISABLE_LOOP,
-	FTDM_COMMAND_COUNT,
 	FTDM_COMMAND_SET_RX_QUEUE_SIZE,
 	FTDM_COMMAND_SET_TX_QUEUE_SIZE,
+	FTDM_COMMAND_SET_POLARITY,
+	FTDM_COMMAND_COUNT,
 } ftdm_command_t;

+typedef enum {
+	FTDM_POLARITY_FORWARD = 0,
+	FTDM_POLARITY_REVERSE = 1
+} ftdm_polarity_t;
+
 /*! \brief Custom memory handler hooks. Not recommended to use unless you need memory allocation customizations */
 typedef void *(*ftdm_malloc_func_t)(void *pool, ftdm_size_t len);
 typedef void *(*ftdm_calloc_func_t)(void *pool, ftdm_size_t elements, ftdm_size_t len);
@@ -598,7 +662,20 @@ typedef ftdm_status_t (*fio_span_get_sig_status_t) FIO_SPAN_GET_SIG_STATUS_ARGS;
 typedef ftdm_status_t (*fio_span_poll_event_t) FIO_SPAN_POLL_EVENT_ARGS ;
 typedef ftdm_status_t (*fio_span_next_event_t) FIO_SPAN_NEXT_EVENT_ARGS ;
 typedef ftdm_status_t (*fio_channel_next_event_t) FIO_CHANNEL_NEXT_EVENT_ARGS ;
+
+/*! \brief Callback for signal delivery (FTDM_SIGEVENT_START and friends) 
+ *  \note This callback is provided by the user during ftdm_configure_span_signaling
+ *
+ *  \note 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
+ *
+ *  \note 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_signal_cb_t) FIO_SIGNAL_CB_ARGS ;
+
 typedef ftdm_status_t (*fio_event_cb_t) FIO_EVENT_CB_ARGS ;
 typedef ftdm_status_t (*fio_configure_span_t) FIO_CONFIGURE_SPAN_ARGS ;
 typedef ftdm_status_t (*fio_configure_t) FIO_CONFIGURE_ARGS ;
@@ -682,17 +759,6 @@ typedef enum {
 	FTDM_CODEC_NONE = (1 << 30)
 } ftdm_codec_t;

-/*! \brief FreeTDM supported indications.
- * This is used during incoming calls when you want to request the signaling stack
- * to notify about indications occurring locally */
-typedef enum {
-	FTDM_CHANNEL_INDICATE_RINGING,
-	FTDM_CHANNEL_INDICATE_PROCEED,
-	FTDM_CHANNEL_INDICATE_PROGRESS,
-	FTDM_CHANNEL_INDICATE_PROGRESS_MEDIA,
-	FTDM_CHANNEL_INDICATE_BUSY,
-} ftdm_channel_indication_t;
-
 /*! \brief FreeTDM supported hardware alarms. */
 typedef enum {
 	FTDM_ALARM_NONE    = 0,
@@ -715,7 +781,12 @@ FT_DECLARE(ftdm_status_t) ftdm_global_set_queue_handler(ftdm_queue_handler_t *ha
 */
 FT_DECLARE(int) ftdm_channel_get_availability(ftdm_channel_t *ftdmchan);

-/*! \brief Answer call */
+/*! \brief 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) 
+ *  \note Although this API will 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_answer(ftdmchan) _ftdm_channel_call_answer(__FILE__, __FUNCTION__, __LINE__, (ftdmchan))

 /*! \brief Answer call recording the source code point where the it was called (see ftdm_channel_call_answer for an easy to use macro) */
@@ -727,7 +798,19 @@ FT_DECLARE(ftdm_status_t) _ftdm_channel_call_answer(const char *file, const char
 /*! \brief Place an outgoing call recording the source code point where it was called (see ftdm_channel_call_place for an easy to use macro) */
 FT_DECLARE(ftdm_status_t) _ftdm_channel_call_place(const char *file, const char *func, int line, ftdm_channel_t *ftdmchan);

-/*! \brief Indicate a new condition in an incoming call */
+/*! \brief 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
+ *
+ * \note  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_indicate(ftdmchan, indication) _ftdm_channel_call_indicate(__FILE__, __FUNCTION__, __LINE__, (ftdmchan), (indication))

 /*! \brief 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) */
@@ -1468,9 +1551,14 @@ FT_DECLARE(const char *) ftdm_channel_get_last_state_str(const ftdm_channel_t *c
 */
 FT_DECLARE(char *) ftdm_channel_get_history_str(const ftdm_channel_t *channel);

-/*! \brief Initialize channel state for an outgoing call */
+/*! \brief Initialize channel state for an outgoing call
+ *  \note This API will eventually be deprecated, is only needed if you use boost signaling 
+ */
 FT_DECLARE(ftdm_status_t) ftdm_channel_init(ftdm_channel_t *ftdmchan);

+/*! \brief Enable/disable blocking mode in the channels for this span */
+FT_DECLARE(ftdm_status_t) ftdm_span_set_blocking_mode(const ftdm_span_t *span, ftdm_bool_t enabled);
+
 /*! \brief Initialize the library */
 FT_DECLARE(ftdm_status_t) ftdm_global_init(void);

--- a/libs/freetdm/src/include/ftdm_call_utils.h
+++ b/libs/freetdm/src/include/ftdm_call_utils.h
@@ -30,6 +30,12 @@
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * Contributors: 
+ *
+ * Moises Silva <moy@sangoma.com>
+ * Ricardo Barroetaveña <rbarroetavena@anura.com.ar>
+ *
 */

 #ifndef __FTDM_CALL_UTILS_H__
@@ -114,5 +120,16 @@ FT_DECLARE(ftdm_status_t) ftdm_set_presentation_ind(const char *string, uint8_t
 */
 FT_DECLARE(ftdm_status_t) ftdm_is_number(const char *number);

+/*! 
+ * \brief Set the Calling Party Category from an enum
+ *
+ * \param cpc_string string value
+ * \param target the target to set value to
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
+FT_DECLARE(ftdm_status_t) ftdm_set_calling_party_category(const char *string, uint8_t *target);
+
 #endif /* __FTDM_CALL_UTILS_H__ */

--- a/libs/freetdm/src/include/ftdm_declare.h
+++ b/libs/freetdm/src/include/ftdm_declare.h
@@ -183,7 +183,16 @@ typedef enum {
 	FTDM_TIMEOUT, /*!< Operation timed out (ie: polling on a device)*/
 	FTDM_NOTIMPL, /*!< Operation not implemented */
 	FTDM_BREAK, /*!< Request the caller to perform a break (context-dependant, ie: stop getting DNIS/ANI) */
-	FTDM_EINVAL /*!< Invalid argument */
+
+	/*!< Any new return codes should try to mimc unix style error codes, no need to reinvent */
+	/* Remapping some of the codes that were before */
+	FTDM_ENOMEM = FTDM_MEMERR, /*!< Memory error */
+	FTDM_ETIMEDOUT = FTDM_TIMEOUT, /*!< Operation timedout */
+	FTDM_ENOSYS = FTDM_NOTIMPL, /*!< The function is not implemented */
+
+	FTDM_EINVAL, /*!< Invalid argument */
+	FTDM_ECANCELED, /*!< Operation cancelled */
+	FTDM_EBUSY, /*!< Device busy */
 } ftdm_status_t;

 /*! \brief FreeTDM bool type. */
--- a/libs/freetdm/src/include/ftdm_os.h
+++ b/libs/freetdm/src/include/ftdm_os.h
@@ -51,6 +51,9 @@ extern "C" {
 #include <unistd.h>
 #endif

+/*! \brief time data type */
+typedef uint64_t ftdm_time_t; 
+
 /*! \brief sleep x amount of milliseconds */
 #ifdef __WINDOWS__
 #define ftdm_sleep(x) Sleep(x)
@@ -114,6 +117,8 @@ FT_DECLARE(char *) ftdm_strdup(const char *str);
 /*! \brief Duplicate string with limit */
 FT_DECLARE(char *) ftdm_strndup(const char *str, ftdm_size_t inlen);

+/*! \brief Get the current time in milliseconds */
+FT_DECLARE(ftdm_time_t) ftdm_current_time_in_ms(void);

 #ifdef __cplusplus
 } /* extern C */
--- a/libs/freetdm/src/include/private/ftdm_core.h
+++ b/libs/freetdm/src/include/private/ftdm_core.h
@@ -143,7 +143,9 @@ extern "C" {
  \return true value if the object has the flags defined
 */
 #define ftdm_test_flag(obj, flag) ((obj)->flags & flag)
+/*!< Physical (IO) module specific flags */
 #define ftdm_test_pflag(obj, flag) ((obj)->pflags & flag)
+/*!< signaling module specific flags */
 #define ftdm_test_sflag(obj, flag) ((obj)->sflags & flag)

 #define ftdm_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag)
@@ -190,17 +192,6 @@ extern "C" {

 #define ftdm_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);

-#define ftdm_set_state(obj, s) ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);									\
-
-#define ftdm_set_state_locked(obj, s) \
-	do { \
-		ftdm_channel_lock(obj); \
-		ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);									\
-		ftdm_channel_unlock(obj); \
-	} while(0);
-
-#define ftdm_set_state_r(obj, s, r) r = ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);
-
 #ifdef _MSC_VER
 /* The while(0) below throws a conditional expression is constant warning */
 #pragma warning(disable:4127) 
@@ -361,15 +352,6 @@ typedef struct {
 	ftdm_mutex_t *mutex;
 } ftdm_dtmf_debug_t;

-typedef struct {
-	const char *file;
-	const char *func;
-	int line;
-	ftdm_channel_state_t state;
-	ftdm_channel_state_t last_state;
-	ftdm_time_t time;
-} ftdm_channel_history_entry_t;
-
 typedef enum {
 	FTDM_IOSTATS_ERROR_CRC		= (1 << 0),
 	FTDM_IOSTATS_ERROR_FRAME	= (1 << 1),
@@ -411,7 +393,7 @@ struct ftdm_channel {
 	uint32_t extra_id;
 	ftdm_chan_type_t type;
 	ftdm_socket_t sockfd;
-	uint32_t flags;
+	uint64_t flags;
 	uint32_t pflags;
 	uint32_t sflags;
 	ftdm_alarm_flag_t alarm_flags;
@@ -422,9 +404,11 @@ struct ftdm_channel {
 	uint32_t native_interval;
 	uint32_t packet_len;
 	ftdm_channel_state_t state;
+	ftdm_state_status_t state_status;
 	ftdm_channel_state_t last_state;
 	ftdm_channel_state_t init_state;
-	ftdm_channel_history_entry_t history[10];
+	ftdm_channel_indication_t indication;
+	ftdm_state_history_entry_t history[10];
 	uint8_t hindex;
 	ftdm_mutex_t *mutex;
 	teletone_dtmf_detect_state_t dtmf_detect;
@@ -456,6 +440,7 @@ struct ftdm_channel {
 	ftdm_fsk_data_state_t fsk;
 	uint8_t fsk_buf[80];
 	uint32_t ring_count;
+	ftdm_polarity_t polarity;
 	/* Private I/O data. Do not touch unless you are an I/O module */
 	void *io_data;
 	/* Private signaling data. Do not touch unless you are a signaling module */
@@ -477,6 +462,7 @@ struct ftdm_channel {
 	ftdm_dtmf_debug_t dtmfdbg;
 	ftdm_io_dump_t rxdump;
 	ftdm_io_dump_t txdump;
+	ftdm_interrupt_t *state_completed_interrupt; /*!< Notify when a state change is completed */
 	int32_t txdrops;
 	int32_t rxdrops;
 };
@@ -493,6 +479,7 @@ struct ftdm_span {
 	ftdm_trunk_type_t trunk_type;
 	ftdm_analog_start_type_t start_type;
 	ftdm_signal_type_t signal_type;
+	uint32_t last_used_index;
 	/* Private signaling data. Do not touch unless you are a signaling module */
 	void *signal_data;
 	fio_signal_cb_t signal_cb;
@@ -513,15 +500,15 @@ struct ftdm_span {
 	ftdm_span_stop_t stop;
 	ftdm_channel_sig_read_t sig_read;
 	ftdm_channel_sig_write_t sig_write;
-	/* Private I/O data per span. Do not touch unless you are an I/O module */
-	void *io_data;
+	ftdm_channel_state_processor_t state_processor; /*!< This guy is called whenever state processing is required */
+	void *io_data; /*!< Private I/O data per span. Do not touch unless you are an I/O module */
 	char *type;
 	char *dtmf_hangup;
 	size_t dtmf_hangup_len;
 	ftdm_state_map_t *state_map;
 	ftdm_caller_data_t default_caller_data;
-	ftdm_queue_t *pendingchans;
-	ftdm_queue_t *pendingsignals;
+	ftdm_queue_t *pendingchans; /*!< Channels pending of state processing */
+	ftdm_queue_t *pendingsignals; /*!< Signals pending from being delivered to the user */
 	struct ftdm_span *next;
 };

@@ -568,11 +555,7 @@ FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *stat
 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number);
 FT_DECLARE(ftdm_status_t) ftdm_channel_send_fsk_data(ftdm_channel_t *ftdmchan, ftdm_fsk_data_state_t *fsk_data, float db_level);

-FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(const char *file, const char *func, int line,
-		ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int wait);
-
 FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname);
-FT_DECLARE(ftdm_time_t) ftdm_current_time_in_ms(void);

 FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan);

@@ -585,8 +568,6 @@ FT_DECLARE(void) print_hex_bytes(uint8_t *data, ftdm_size_t dlen, char *buf, ftd
 FT_DECLARE_NONSTD(int) ftdm_hash_equalkeys(void *k1, void *k2);
 FT_DECLARE_NONSTD(uint32_t) ftdm_hash_hashfromstring(void *ky);

-FT_DECLARE(ftdm_status_t) ftdm_channel_complete_state(ftdm_channel_t *ftdmchan);
-
 FT_DECLARE(int) ftdm_load_modules(void);

 FT_DECLARE(ftdm_status_t) ftdm_unload_modules(void);
@@ -602,6 +583,7 @@ FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap);

 FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
 FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
+FT_DECLARE(void) ftdm_ack_indication(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_status_t status);

 /*! 
 * \brief Retrieves an event from the span
@@ -702,50 +684,6 @@ static __inline__ void ftdm_abort(void)
 #endif
 }

-static __inline__ void ftdm_set_state_all(ftdm_span_t *span, ftdm_channel_state_t state)
-{
-	uint32_t j;
-	ftdm_mutex_lock(span->mutex);
-	for(j = 1; j <= span->chan_count; j++) {
-		if (!FTDM_IS_DCHAN(span->channels[j])) {
-			ftdm_set_state_locked((span->channels[j]), state);
-		}
-	}
-	ftdm_mutex_unlock(span->mutex);
-}
-
-static __inline__ int ftdm_check_state_all(ftdm_span_t *span, ftdm_channel_state_t state)
-{
-	uint32_t j;
-	for(j = 1; j <= span->chan_count; j++) {
-		if (span->channels[j]->state != state || ftdm_test_flag(span->channels[j], FTDM_CHANNEL_STATE_CHANGE)) {
-			return 0;
-		}
-	}
-
-	return 1;
-}
-
-static __inline__ void ftdm_set_flag_all(ftdm_span_t *span, uint32_t flag)
-{
-	uint32_t j;
-	ftdm_mutex_lock(span->mutex);
-	for(j = 1; j <= span->chan_count; j++) {
-		ftdm_set_flag_locked((span->channels[j]), flag);
-	}
-	ftdm_mutex_unlock(span->mutex);
-}
-
-static __inline__ void ftdm_clear_flag_all(ftdm_span_t *span, uint32_t flag)
-{
-	uint32_t j;
-	ftdm_mutex_lock(span->mutex);
-	for(j = 1; j <= span->chan_count; j++) {
-		ftdm_clear_flag_locked((span->channels[j]), flag);
-	}
-	ftdm_mutex_unlock(span->mutex);
-}
-
 static __inline__ int16_t ftdm_saturated_add(int16_t sample1, int16_t sample2)
 {
 	int addres;
--- a/libs/freetdm/src/include/private/ftdm_m3ua.h
+++ b/libs/freetdm/src/include/private/ftdm_m3ua.h
@@ -1,134 +0,0 @@
-/*
- *  ftdm_m3ua.h
- *  freetdm
- *
- *  Created by Shane Burrell on 4/3/08.
- *  Copyright 2008 Shane Burrell. All rights reserved.
- *
- * Copyright (c) 2007, Anthony Minessale II, Nenad Corbic
- * 
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 
- * * Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 
- * * Redistributions in binary form must reproduce the above copyright
- * notice, this list of conditions and the following disclaimer in the
- * documentation and/or other materials provided with the distribution.
- * 
- * * Neither the name of the original author; nor the names of any contributors
- * may be used to endorse or promote products derived from this software
- * without specific prior written permission.
- * 
- * 
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
- * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
- * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
- * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
- * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- */
-
-
-//#include "m3ua_client.h"
-#include "freetdm.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-enum	e_sigboost_event_id_values
-{
-	SIGBOOST_EVENT_CALL_START			= 0x80, /*128*/
-	SIGBOOST_EVENT_CALL_START_ACK			= 0x81, /*129*/
-	SIGBOOST_EVENT_CALL_START_NACK			= 0x82, /*130*/
-	SIGBOOST_EVENT_CALL_START_NACK_ACK		= 0x83, /*131*/
-	SIGBOOST_EVENT_CALL_ANSWERED			= 0x84, /*132*/
-	SIGBOOST_EVENT_CALL_STOPPED			= 0x85, /*133*/
-	SIGBOOST_EVENT_CALL_STOPPED_ACK			= 0x86, /*134*/
-	SIGBOOST_EVENT_SYSTEM_RESTART			= 0x87, /*135*/
-	SIGBOOST_EVENT_SYSTEM_RESTART_ACK		= 0x88, /*136*/
-	/* Following IDs are ss7boost to sangoma_mgd only. */
-	SIGBOOST_EVENT_HEARTBEAT			= 0x89, /*137*/
-	SIGBOOST_EVENT_INSERT_CHECK_LOOP		= 0x8a, /*138*/
-	SIGBOOST_EVENT_REMOVE_CHECK_LOOP		= 0x8b, /*139*/
-	SIGBOOST_EVENT_AUTO_CALL_GAP_ABATE		= 0x8c, /*140*/
-};
-enum	e_sigboost_release_cause_values
-{
-	SIGBOOST_RELEASE_CAUSE_UNDEFINED		= 0,
-	SIGBOOST_RELEASE_CAUSE_NORMAL			= 16,
-	SIGBOOST_RELEASE_CAUSE_BUSY			= 17,
-	/* probable elimination */
-	//SIGBOOST_RELEASE_CAUSE_BUSY			= 0x91, /* 145 */
-	//SIGBOOST_RELEASE_CAUSE_CALLED_NOT_EXIST	= 0x92, /* 146 */
-	//SIGBOOST_RELEASE_CAUSE_CIRCUIT_RESET		= 0x93, /* 147 */
-	//SIGBOOST_RELEASE_CAUSE_NOANSWER		= 0x94, /* 148 */
-};
-
-enum	e_sigboost_call_setup_ack_nack_cause_values
-{
-	SIGBOOST_CALL_SETUP_NACK_ALL_CKTS_BUSY		= 117, /* unused Q.850 value */
-	SIGBOOST_CALL_SETUP_NACK_TEST_CKT_BUSY		= 118, /* unused Q.850 value */
-	SIGBOOST_CALL_SETUP_NACK_INVALID_NUMBER		= 28,
-	/* probable elimination */
-	//SIGBOOST_CALL_SETUP_RESERVED			= 0x00,
-	//SIGBOOST_CALL_SETUP_CIRCUIT_RESET		= 0x10,
-	//SIGBOOST_CALL_SETUP_NACK_CKT_START_TIMEOUT	= 0x11,
-	//SIGBOOST_CALL_SETUP_NACK_AUTO_CALL_GAP	= 0x17,
-};
-typedef enum {
-	M3UA_SPAN_SIGNALING_M3UA,
-	M3UA_SPAN_SIGNALING_SS7BOX,
-	
-} M3UA_TSpanSignaling;
-#define M3UA_SPAN_STRINGS "M3UA", "SS7BOX"
-FTDM_STR2ENUM_P(m3ua_str2span, m3ua_span2str, M3UA_TSpanSignaling)
-
-
-
-typedef enum {
-	FTDM_M3UA_RUNNING = (1 << 0)
-} ftdm_m3uat_flag_t;
-
-/*typedef struct m3ua_data {
-	m3uac_connection_t mcon;
-	m3uac_connection_t pcon;
-	fio_signal_cb_t signal_cb;
-	uint32_t flags;
-} m3ua_data_t;
-
-*/
-/*typedef struct mu3a_link {
-	ss7bc_connection_t mcon;
-	ss7bc_connection_t pcon;
-	fio_signal_cb_t signal_cb;
-	uint32_t flags;
-} ftdm_m3ua_data_t;
-*/
-
-ftdm_status_t m3ua_init(ftdm_io_interface_t **zint);
-ftdm_status_t m3ua_destroy(void);
-ftdm_status_t m3ua_start(ftdm_span_t *span);
-
-#ifdef __cplusplus
-}
-#endif
-
-/* For Emacs:
- * Local Variables:
- * mode:c
- * indent-tabs-mode:t
- * tab-width:4
- * c-basic-offset:4
- * End:
- * For VIM:
- * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
- */
-
--- a/libs/freetdm/src/include/private/ftdm_state.h
+++ b/libs/freetdm/src/include/private/ftdm_state.h
@@ -0,0 +1,237 @@
+/*
+ * Copyright (c) 2010, Sangoma Technologies
+ * Moises Silva <moy@sangoma.com>
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ * 
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ * 
+ * * Neither the name of the original author; nor the names of any contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ * 
+ * 
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
+ * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+ * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __FTDM_STATE_H__
+#define __FTDM_STATE_H__
+
+/*! \file
+ * \brief State handling definitions
+ * \note Most, if not all of the state handling functions assume you have a lock acquired. Touching the channel
+ *       state is a sensitive matter that requires checks and careful thought and is typically a process that
+ *       is not encapsulated within a single function, therefore the lock must be explicitly acquired by the 
+ *       caller (most of the time, signaling modules), process states, set a new state and process it, and 
+ *       finally unlock the channel. See docs/locking.txt fore more info
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	FTDM_CHANNEL_STATE_DOWN,
+	FTDM_CHANNEL_STATE_HOLD,
+	FTDM_CHANNEL_STATE_SUSPENDED,
+	FTDM_CHANNEL_STATE_DIALTONE,
+	FTDM_CHANNEL_STATE_COLLECT,
+	FTDM_CHANNEL_STATE_RING,
+	FTDM_CHANNEL_STATE_RINGING,
+	FTDM_CHANNEL_STATE_BUSY,
+	FTDM_CHANNEL_STATE_ATTN,
+	FTDM_CHANNEL_STATE_GENRING,
+	FTDM_CHANNEL_STATE_DIALING,
+	FTDM_CHANNEL_STATE_GET_CALLERID,
+	FTDM_CHANNEL_STATE_CALLWAITING,
+	FTDM_CHANNEL_STATE_RESTART,
+	FTDM_CHANNEL_STATE_PROCEED,
+	FTDM_CHANNEL_STATE_PROGRESS,
+	FTDM_CHANNEL_STATE_PROGRESS_MEDIA,
+	FTDM_CHANNEL_STATE_UP,
+	FTDM_CHANNEL_STATE_IDLE,
+	FTDM_CHANNEL_STATE_TERMINATING,
+	FTDM_CHANNEL_STATE_CANCEL,
+	FTDM_CHANNEL_STATE_HANGUP,
+	FTDM_CHANNEL_STATE_HANGUP_COMPLETE,
+	FTDM_CHANNEL_STATE_IN_LOOP,
+	FTDM_CHANNEL_STATE_RESET,
+	FTDM_CHANNEL_STATE_INVALID
+} ftdm_channel_state_t;
+#define CHANNEL_STATE_STRINGS "DOWN", "HOLD", "SUSPENDED", "DIALTONE", "COLLECT", \
+		"RING", "RINGING", "BUSY", "ATTN", "GENRING", "DIALING", "GET_CALLERID", "CALLWAITING", \
+		"RESTART", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "UP", "IDLE", "TERMINATING", "CANCEL", \
+		"HANGUP", "HANGUP_COMPLETE", "IN_LOOP", "RESET", "INVALID"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_channel_state, ftdm_channel_state2str, ftdm_channel_state_t)
+
+typedef struct {
+	const char *file;
+	const char *func;
+	int line;
+	ftdm_channel_state_t state; /*!< Current state (processed or not) */
+	ftdm_channel_state_t last_state; /*!< Previous state */
+	ftdm_time_t time; /*!< Time the state was set */
+	ftdm_time_t end_time; /*!< Time the state processing was completed */
+} ftdm_state_history_entry_t;
+
+typedef ftdm_status_t (*ftdm_channel_state_processor_t)(ftdm_channel_t *fchan);
+
+/*!
+ * \brief Process channel states by invoking the channel state processing routine
+ *        it will keep calling the processing routine while the state status
+ *        is FTDM_STATE_STATUS_NEW, it will not do anything otherwise
+ */
+FT_DECLARE(ftdm_status_t) ftdm_channel_advance_states(ftdm_channel_t *fchan);
+
+FT_DECLARE(ftdm_status_t) _ftdm_channel_complete_state(const char *file, const char *function, int line, ftdm_channel_t *fchan);
+#define ftdm_channel_complete_state(obj) _ftdm_channel_complete_state(__FILE__, __FUNCTION__, __LINE__, obj)
+FT_DECLARE(int) ftdm_check_state_all(ftdm_span_t *span, ftdm_channel_state_t state);
+
+/*!
+ * \brief Status of the current channel state 
+ * \note A given state goes thru several status (yes, states for the state!)
+ * The order is always FTDM_STATE_STATUS_NEW -> FTDM_STATE_STATUS_PROCESSED -> FTDM_STATUS_COMPLETED
+ * However, is possible to go from NEW -> COMPLETED directly when the signaling module explicitly changes 
+ * the state of the channel in the middle of processing the current state by calling the ftdm_set_state() API
+ *
+ * FTDM_STATE_STATUS_NEW - 
+ *   Someone just set the state of the channel, either the signaling module or the user (implicitly through a call API). 
+ *   This is accomplished by calling ftdm_channel_set_state() which changes the 'state' and 'last_state' memebers of 
+ *   the ftdm_channel_t structure.
+ *
+ * FTDM_STATE_STATUS_PROCESSED -
+ *   The signaling module did something based on the new state.
+ *
+ *   This is accomplished via ftdm_channel_advance_states()
+ *
+ *   When ftdm_channel_advance_states(), at the very least, if the channel has its state in FTDM_STATE_STATUS_NEW, it
+ *   will move to FTDM_STATE_STATUS_PROCESSED, depending on what the signaling module does during the processing
+ *   the state may move to FTDM_STATE_STATUS_COMPLETED right after or wait for a signaling specific event to complete it.
+ *   It is also possible that more state transitions occur during the execution of ftdm_channel_advance_states() if one
+ *   state processing/completion leads to another state change, the function will not return until the chain of events
+ *   lead to a state that is not in FTDM_STATE_STATUS_NEW
+ *
+ * FTDM_STATE_STATUS_COMPLETED - 
+ *   The signaling module completed the processing of the state and there is nothing further to be done for this state.
+ *
+ *   This is accomplished either explicitly by the signaling module by calling ftdm_channel_complete_state() or by
+ *   the signaling module implicitly by trying to set the state of the channel to a new state via ftdm_set_state()
+ *
+ *   When working with blocking channels (FTDM_CHANNEL_NONBLOCK flag not set), the user thread is signaled and unblocked 
+ *   so it can continue.
+ *
+ *   When a state moves to this status is also possible for a signal FTDM_SIGEVENT_INDICATION_COMPLETED to be delivered 
+ *   by the core if the state change was associated to an indication requested by the user, 
+ */
+typedef enum {
+	FTDM_STATE_STATUS_NEW,
+	FTDM_STATE_STATUS_PROCESSED,
+	FTDM_STATE_STATUS_COMPLETED,
+	FTDM_STATE_STATUS_INVALID
+} ftdm_state_status_t;
+#define CHANNEL_STATE_STATUS_STRINGS "NEW", "PROCESSED", "COMPLETED", "INVALID"
+FTDM_STR2ENUM_P(ftdm_str2ftdm_state_status, ftdm_state_status2str, ftdm_state_status_t)
+
+typedef enum {
+	ZSM_NONE,
+	ZSM_UNACCEPTABLE,
+	ZSM_ACCEPTABLE
+} ftdm_state_map_type_t;
+
+typedef enum {
+	ZSD_INBOUND,
+	ZSD_OUTBOUND,
+} ftdm_state_direction_t;
+
+#define FTDM_MAP_NODE_SIZE 512
+#define FTDM_MAP_MAX FTDM_CHANNEL_STATE_INVALID+2
+
+struct ftdm_state_map_node {
+	ftdm_state_direction_t direction;
+	ftdm_state_map_type_t type;
+	ftdm_channel_state_t check_states[FTDM_MAP_MAX];
+	ftdm_channel_state_t states[FTDM_MAP_MAX];
+};
+typedef struct ftdm_state_map_node ftdm_state_map_node_t;
+
+struct ftdm_state_map {
+	ftdm_state_map_node_t nodes[FTDM_MAP_NODE_SIZE];
+};
+typedef struct ftdm_state_map ftdm_state_map_t;
+
+/*!\brief Set the state for a channel (the channel must be locked when calling this function)
+ * \note Signaling modules should use ftdm_set_state macro instead
+ * \note If this function is called with the wait parameter set to a non-zero value, the recursivity
+ *       of the channel lock must be == 1 because the channel will be unlocked/locked when waiting */
+FT_DECLARE(ftdm_status_t) ftdm_channel_set_state(const char *file, const char *func, int line,
+		ftdm_channel_t *ftdmchan, ftdm_channel_state_t state, int wait);
+
+/*!\brief Set the state of a channel immediately and implicitly complete the previous state if needed 
+ * \note FTDM_SIGEVENT_INDICATION_COMPLETED will be sent if the state change 
+ *       is associated to some indication (ie FTDM_CHANNEL_INDICATE_PROCEED)
+ * \note The channel must be locked when calling this function
+ * */
+FT_DECLARE(ftdm_status_t) _ftdm_set_state(const char *file, const char *func, int line,
+			ftdm_channel_t *fchan, ftdm_channel_state_t state);
+#define ftdm_set_state(obj, s) _ftdm_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s);									\
+
+/*!\brief This macro is deprecated, signaling modules should always lock the channel themselves anyways since they must
+ * process first the user pending state changes then set a new state before releasing the lock 
+ * this macro is here for backwards compatibility, DO NOT USE IT in new code since it is *always* wrong to set
+ * a state in a signaling module without checking and processing the current state first (and for that you must lock the channel)
+ */
+#define ftdm_set_state_locked(obj, s) \
+	do { \
+		ftdm_channel_lock(obj); \
+		ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);									\
+		ftdm_channel_unlock(obj); \
+	} while(0);
+
+#define ftdm_set_state_r(obj, s, r) r = ftdm_channel_set_state(__FILE__, __FUNCTION__, __LINE__, obj, s, 0);
+
+#define ftdm_set_state_all(span, state) \
+	do { \
+		uint32_t _j; \
+		ftdm_mutex_lock((span)->mutex); \
+		for(_j = 1; _j <= (span)->chan_count; _j++) { \
+			if (!FTDM_IS_DCHAN(span->channels[_j])) { \
+				ftdm_set_state_locked((span->channels[_j]), state); \
+			} \
+		} \
+		ftdm_mutex_unlock((span)->mutex); \
+	} while (0);
+
+#ifdef __cplusplus
+} 
+#endif
+
+#endif
+
+/* For Emacs:
+ * Local Variables:
+ * mode:c
+ * indent-tabs-mode:t
+ * tab-width:4
+ * c-basic-offset:4
+ * End:
+ * For VIM:
+ * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
+ */
--- a/libs/freetdm/src/include/private/ftdm_types.h
+++ b/libs/freetdm/src/include/private/ftdm_types.h
@@ -69,8 +69,6 @@ extern "C" {
 #define FTDM_END -1
 #define FTDM_ANY_STATE -1

-typedef uint64_t ftdm_time_t; 
-
 typedef enum {
 	FTDM_ENDIAN_BIG = 1,
 	FTDM_ENDIAN_LITTLE = -1
@@ -123,6 +121,7 @@ typedef enum {
 FTDM_STR2ENUM_P(ftdm_str2ftdm_analog_start_type, ftdm_analog_start_type2str, ftdm_analog_start_type_t)

 typedef enum {
+	FTDM_OOB_NOOP,
 	FTDM_OOB_ONHOOK,
 	FTDM_OOB_OFFHOOK,
 	FTDM_OOB_WINK,
@@ -131,11 +130,11 @@ typedef enum {
 	FTDM_OOB_RING_STOP,
 	FTDM_OOB_ALARM_TRAP,
 	FTDM_OOB_ALARM_CLEAR,
-	FTDM_OOB_NOOP,
 	FTDM_OOB_CAS_BITS_CHANGE,
+	FTDM_OOB_POLARITY_REVERSE,
 	FTDM_OOB_INVALID
 } ftdm_oob_event_t;
-#define OOB_STRINGS "ONHOOK", "OFFHOOK", "WINK", "FLASH", "RING_START", "RING_STOP", "ALARM_TRAP", "ALARM_CLEAR", "NOOP", "CAS_BITS_CHANGE", "INVALID"
+#define OOB_STRINGS "NOOP", "ONHOOK", "OFFHOOK", "WINK", "FLASH", "RING_START", "RING_STOP", "ALARM_TRAP", "ALARM_CLEAR", "CAS_BITS_CHANGE", "POLARITY_REVERSE", "INVALID"
 FTDM_STR2ENUM_P(ftdm_str2ftdm_oob_event, ftdm_oob_event2str, ftdm_oob_event_t)

 /*! \brief Event types */
@@ -169,7 +168,7 @@ typedef enum {

 typedef enum {
 	FTDM_SPAN_CONFIGURED = (1 << 0),
-	FTDM_SPAN_READY = (1 << 1),
+	FTDM_SPAN_STARTED = (1 << 1),
 	FTDM_SPAN_STATE_CHANGE = (1 << 2),
 	FTDM_SPAN_SUSPENDED = (1 << 3),
 	FTDM_SPAN_IN_THREAD = (1 << 4),
@@ -203,113 +202,56 @@ typedef enum {
 	FTDM_CHANNEL_FEATURE_IO_STATS = (1<<9), /*!< Channel supports IO statistics (HDLC channels only) */
 } ftdm_channel_feature_t;

-typedef enum {
-	FTDM_CHANNEL_STATE_DOWN,
-	FTDM_CHANNEL_STATE_HOLD,
-	FTDM_CHANNEL_STATE_SUSPENDED,
-	FTDM_CHANNEL_STATE_DIALTONE,
-	FTDM_CHANNEL_STATE_COLLECT,
-	FTDM_CHANNEL_STATE_RING,
-	FTDM_CHANNEL_STATE_RINGING,
-	FTDM_CHANNEL_STATE_BUSY,
-	FTDM_CHANNEL_STATE_ATTN,
-	FTDM_CHANNEL_STATE_GENRING,
-	FTDM_CHANNEL_STATE_DIALING,
-	FTDM_CHANNEL_STATE_GET_CALLERID,
-	FTDM_CHANNEL_STATE_CALLWAITING,
-	FTDM_CHANNEL_STATE_RESTART,
-	FTDM_CHANNEL_STATE_PROCEED,
-	FTDM_CHANNEL_STATE_PROGRESS,
-	FTDM_CHANNEL_STATE_PROGRESS_MEDIA,
-	FTDM_CHANNEL_STATE_UP,
-	FTDM_CHANNEL_STATE_IDLE,
-	FTDM_CHANNEL_STATE_TERMINATING,
-	FTDM_CHANNEL_STATE_CANCEL,
-	FTDM_CHANNEL_STATE_HANGUP,
-	FTDM_CHANNEL_STATE_HANGUP_COMPLETE,
-	FTDM_CHANNEL_STATE_IN_LOOP,
-	FTDM_CHANNEL_STATE_RESET,
-	FTDM_CHANNEL_STATE_INVALID
-} ftdm_channel_state_t;
-#define CHANNEL_STATE_STRINGS "DOWN", "HOLD", "SUSPENDED", "DIALTONE", "COLLECT", \
-		"RING", "RINGING", "BUSY", "ATTN", "GENRING", "DIALING", "GET_CALLERID", "CALLWAITING", \
-		"RESTART", "PROCEED", "PROGRESS", "PROGRESS_MEDIA", "UP", "IDLE", "TERMINATING", "CANCEL", \
-		"HANGUP", "HANGUP_COMPLETE", "IN_LOOP", "RESET", "INVALID"
-FTDM_STR2ENUM_P(ftdm_str2ftdm_channel_state, ftdm_channel_state2str, ftdm_channel_state_t)
+/*!< Channel flags. This used to be an enum but we reached the 32bit limit for enums, is safer this way */
+#define FTDM_CHANNEL_CONFIGURED    (1ULL << 0)
+#define FTDM_CHANNEL_READY         (1ULL << 1)
+#define FTDM_CHANNEL_OPEN          (1ULL << 2)
+#define FTDM_CHANNEL_DTMF_DETECT   (1ULL << 3)
+#define FTDM_CHANNEL_SUPRESS_DTMF  (1ULL << 4)
+#define FTDM_CHANNEL_TRANSCODE     (1ULL << 5)
+#define FTDM_CHANNEL_BUFFER        (1ULL << 6)
+#define FTDM_CHANNEL_EVENT         (1ULL << 7)
+#define FTDM_CHANNEL_INTHREAD      (1ULL << 8)
+#define FTDM_CHANNEL_WINK          (1ULL << 9)
+#define FTDM_CHANNEL_FLASH         (1ULL << 10)
+#define FTDM_CHANNEL_STATE_CHANGE  (1ULL << 11)
+#define FTDM_CHANNEL_HOLD          (1ULL << 12)
+#define FTDM_CHANNEL_INUSE         (1ULL << 13)
+#define FTDM_CHANNEL_OFFHOOK       (1ULL << 14)
+#define FTDM_CHANNEL_RINGING       (1ULL << 15)
+#define FTDM_CHANNEL_PROGRESS_DETECT (1ULL << 16)
+#define FTDM_CHANNEL_CALLERID_DETECT (1ULL << 17)
+#define FTDM_CHANNEL_OUTBOUND        (1ULL << 18)
+#define FTDM_CHANNEL_SUSPENDED       (1ULL << 19)
+#define FTDM_CHANNEL_3WAY            (1ULL << 20)

-typedef enum {
-	FTDM_CHANNEL_CONFIGURED = (1 << 0),
-	FTDM_CHANNEL_READY = (1 << 1),
-	FTDM_CHANNEL_OPEN = (1 << 2),
-	FTDM_CHANNEL_DTMF_DETECT = (1 << 3),
-	FTDM_CHANNEL_SUPRESS_DTMF = (1 << 4),
-	FTDM_CHANNEL_TRANSCODE = (1 << 5),
-	FTDM_CHANNEL_BUFFER = (1 << 6),
-	FTDM_CHANNEL_EVENT = (1 << 7),
-	FTDM_CHANNEL_INTHREAD = (1 << 8),
-	FTDM_CHANNEL_WINK = (1 << 9),
-	FTDM_CHANNEL_FLASH = (1 << 10),
-	FTDM_CHANNEL_STATE_CHANGE = (1 << 11),
-	FTDM_CHANNEL_HOLD = (1 << 12),
-	FTDM_CHANNEL_INUSE = (1 << 13),
-	FTDM_CHANNEL_OFFHOOK = (1 << 14),
-	FTDM_CHANNEL_RINGING = (1 << 15),
-	FTDM_CHANNEL_PROGRESS_DETECT = (1 << 16),
-	FTDM_CHANNEL_CALLERID_DETECT = (1 << 17),
-	FTDM_CHANNEL_OUTBOUND = (1 << 18),
-	FTDM_CHANNEL_SUSPENDED = (1 << 19),
-	FTDM_CHANNEL_3WAY = (1 << 20),
-	FTDM_CHANNEL_PROGRESS = (1 << 21),
-	FTDM_CHANNEL_MEDIA = (1 << 22),
-	FTDM_CHANNEL_ANSWERED = (1 << 23),
-	FTDM_CHANNEL_MUTE = (1 << 24),
-	FTDM_CHANNEL_USE_RX_GAIN = (1 << 25),
-	FTDM_CHANNEL_USE_TX_GAIN = (1 << 26),
-	FTDM_CHANNEL_IN_ALARM = (1 << 27),
-	FTDM_CHANNEL_SIG_UP = (1 << 28),
-	FTDM_CHANNEL_USER_HANGUP = (1 << 29),
-	FTDM_CHANNEL_RX_DISABLED = (1 << 30),
-	FTDM_CHANNEL_TX_DISABLED = (1 << 31),
-	/* ok, when we reach 32, we need to move to uint64_t all the flag stuff */
-} ftdm_channel_flag_t;
-#if defined(__cplusplus) && defined(WIN32) 
-    // fix C2676 
-__inline__ ftdm_channel_flag_t operator|=(ftdm_channel_flag_t a, int32_t b) {
-    a = (ftdm_channel_flag_t)(a | b);
-    return a;
-}
-__inline__ ftdm_channel_flag_t operator&=(ftdm_channel_flag_t a, int32_t b) {
-    a = (ftdm_channel_flag_t)(a & b);
-    return a;
-}
-#endif
+/* this 3 flags are really nonsense used by boost module only, as soon
+ * as we deprecate/delete boost module we can get rid of them 
+ * ==================
+ * */
+#define FTDM_CHANNEL_PROGRESS        (1ULL << 21)
+#define FTDM_CHANNEL_MEDIA           (1ULL << 22)
+#define FTDM_CHANNEL_ANSWERED        (1ULL << 23)
+/* ================== */

-typedef enum {
-	ZSM_NONE,
-	ZSM_UNACCEPTABLE,
-	ZSM_ACCEPTABLE
-} ftdm_state_map_type_t;
+#define FTDM_CHANNEL_MUTE            (1ULL << 24)
+#define FTDM_CHANNEL_USE_RX_GAIN     (1ULL << 25)
+#define FTDM_CHANNEL_USE_TX_GAIN     (1ULL << 26)
+#define FTDM_CHANNEL_IN_ALARM        (1ULL << 27)
+#define FTDM_CHANNEL_SIG_UP          (1ULL << 28)
+#define FTDM_CHANNEL_USER_HANGUP     (1ULL << 29)
+#define FTDM_CHANNEL_RX_DISABLED     (1ULL << 30)
+#define FTDM_CHANNEL_TX_DISABLED     (1ULL << 31)
+/*!< The user knows about a call in this channel */
+#define FTDM_CHANNEL_CALL_STARTED    (1ULL << 32)
+/*!< The user wants non-blocking operations in the channel */
+#define FTDM_CHANNEL_NONBLOCK        (1ULL << 33)
+/*!< There is a pending acknowledge for an indication */
+#define FTDM_CHANNEL_IND_ACK_PENDING (1ULL << 34)
+/*!< There is someone blocking in the channel waiting for state completion */
+#define FTDM_CHANNEL_BLOCKING        (1ULL << 35)

-typedef enum {
-	ZSD_INBOUND,
-	ZSD_OUTBOUND,
-} ftdm_state_direction_t;
-
-#define FTDM_MAP_NODE_SIZE 512
-#define FTDM_MAP_MAX FTDM_CHANNEL_STATE_INVALID+2
-
-struct ftdm_state_map_node {
-	ftdm_state_direction_t direction;
-	ftdm_state_map_type_t type;
-	ftdm_channel_state_t check_states[FTDM_MAP_MAX];
-	ftdm_channel_state_t states[FTDM_MAP_MAX];
-};
-typedef struct ftdm_state_map_node ftdm_state_map_node_t;
-
-struct ftdm_state_map {
-	ftdm_state_map_node_t nodes[FTDM_MAP_NODE_SIZE];
-};
-typedef struct ftdm_state_map ftdm_state_map_t;
+#include "ftdm_state.h"

 typedef enum ftdm_channel_hw_link_status {
 	FTDM_HW_LINK_DISCONNECTED = 0,