<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" />
<title>[Freeswitch-trunk][17439] </title>
</head>
<body>
<style type="text/css"><!--
#msg dl.meta { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dl.meta dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer, #logmsg { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fa0 solid; padding: 6px; }
#logmsg { background: #ffc; border: 1px #fa0 solid; padding: 1em 1em 0 1em; }
#logmsg p, #logmsg pre, #logmsg blockquote { margin: 0 0 1em 0; }
#logmsg p, #logmsg li, #logmsg dt, #logmsg dd { line-height: 14pt; }
#logmsg h1, #logmsg h2, #logmsg h3, #logmsg h4, #logmsg h5, #logmsg h6 { margin: .5em 0; }
#logmsg h1:first-child, #logmsg h2:first-child, #logmsg h3:first-child, #logmsg h4:first-child, #logmsg h5:first-child, #logmsg h6:first-child { margin-top: 0; }
#logmsg ul, #logmsg ol { padding: 0; list-style-position: inside; margin: 0 0 0 1em; }
#logmsg ul { text-indent: -1em; padding-left: 1em; }#logmsg ol { text-indent: -1.5em; padding-left: 1.5em; }
#logmsg > ul, #logmsg > ol { margin: 0 0 1em 0; }
#logmsg pre { background: #eee; padding: 1em; }
#logmsg blockquote { border: 1px solid #fa0; border-left-width: 10px; padding: 1em 1em 0 1em; background: white;}
#logmsg dl { margin: 0; }
#logmsg dt { font-weight: bold; }
#logmsg dd { margin: 0; padding: 0 0 0.5em 0; }
#logmsg dd:before { content:'\00bb';}
#logmsg table { border-spacing: 0px; border-collapse: collapse; border-top: 4px solid #fa0; border-bottom: 1px solid #fa0; background: #fff; }
#logmsg table th { text-align: left; font-weight: normal; padding: 0.2em 0.5em; border-top: 1px dotted #fa0; }
#logmsg table td { text-align: right; border-top: 1px dotted #fa0; padding: 0.2em 0.5em; }
#logmsg table thead th { text-align: center; border-bottom: 1px solid #fa0; }
#logmsg table th.Corner { text-align: left; }
#logmsg hr { border: none 0; border-top: 2px dashed #fa0; height: 1px; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<div id="msg">
<div id="header">FreeSWITCH Subversion</div>
<dl class="meta">
<dt>Revision</dt> <dd><a href="http://fisheye.freeswitch.org/changelog/FreeSWITCH?cs=17439">17439</a></dd>
<dt>Author</dt> <dd>moy</dd>
<dt>Date</dt> <dd>2010-04-28 17:17:50 -0500 (Wed, 28 Apr 2010)</dd>
</dl>
<h3>Log Message</h3>
<pre>freetdm: added documentation and clean up script</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#freeswitchtrunklibsfreetdmmod_freetdmmod_freetdmc">freeswitch/trunk/libs/freetdm/mod_freetdm/mod_freetdm.c</a></li>
<li><a href="#freeswitchtrunklibsfreetdmsrcftdm_ioc">freeswitch/trunk/libs/freetdm/src/ftdm_io.c</a></li>
<li><a href="#freeswitchtrunklibsfreetdmsrcincludefreetdmh">freeswitch/trunk/libs/freetdm/src/include/freetdm.h</a></li>
<li><a href="#freeswitchtrunklibsfreetdmsrcincludeprivateftdm_coreh">freeswitch/trunk/libs/freetdm/src/include/private/ftdm_core.h</a></li>
</ul>
<h3>Added Paths</h3>
<ul>
<li><a href="#freeswitchtrunklibsfreetdmmod_freetdmcleansh">freeswitch/trunk/libs/freetdm/mod_freetdm/clean.sh</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="freeswitchtrunklibsfreetdmmod_freetdmcleansh"></a>
<div class="addfile"><h4>Added: freeswitch/trunk/libs/freetdm/mod_freetdm/clean.sh (0 => 17439)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/libs/freetdm/mod_freetdm/clean.sh (rev 0)
+++ freeswitch/trunk/libs/freetdm/mod_freetdm/clean.sh 2010-04-28 22:17:50 UTC (rev 17439)
</span><span class="lines">@@ -0,0 +1,6 @@
</span><ins>+#!/bin/bash
+rm -rf mod_freetdm.so
+rm -rf .libs/mod_freetdm.so
+rm -rf mod_freetdm.o
+rm -rf .libs/mod_freetdm.o
+rm -rf mod_freetdm.lo
</ins><span class="cx">Property changes on: freeswitch/trunk/libs/freetdm/mod_freetdm/clean.sh
</span><span class="cx">___________________________________________________________________
</span><span class="cx">Name: svn:executable
</span><span class="cx"> + on
</span></span></pre></div>
<a id="freeswitchtrunklibsfreetdmmod_freetdmmod_freetdmc"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/libs/freetdm/mod_freetdm/mod_freetdm.c (17438 => 17439)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/libs/freetdm/mod_freetdm/mod_freetdm.c 2010-04-28 22:17:50 UTC (rev 17438)
+++ freeswitch/trunk/libs/freetdm/mod_freetdm/mod_freetdm.c 2010-04-28 22:17:50 UTC (rev 17439)
</span><span class="lines">@@ -3474,7 +3474,7 @@
</span><span class="cx"> stream->write_function(stream, "+OK gains set to Rx %f and Tx %f\n", rxgain, txgain);
</span><span class="cx"> } else {
</span><span class="cx">
</span><del>- char *rply = ftdm_api_execute(cmd, NULL);
</del><ins>+ char *rply = ftdm_api_execute(cmd);
</ins><span class="cx">
</span><span class="cx"> if (rply) {
</span><span class="cx"> stream->write_function(stream, "%s", rply);
</span></span></pre></div>
<a id="freeswitchtrunklibsfreetdmsrcftdm_ioc"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/libs/freetdm/src/ftdm_io.c (17438 => 17439)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/libs/freetdm/src/ftdm_io.c 2010-04-28 22:17:50 UTC (rev 17438)
+++ freeswitch/trunk/libs/freetdm/src/ftdm_io.c 2010-04-28 22:17:50 UTC (rev 17439)
</span><span class="lines">@@ -3163,21 +3163,20 @@
</span><span class="cx"> } interfaces;
</span><span class="cx">
</span><span class="cx">
</span><del>-FT_DECLARE(char *) ftdm_api_execute(const char *type, const char *cmd)
</del><ins>+FT_DECLARE(char *) ftdm_api_execute(const char *cmd)
</ins><span class="cx"> {
</span><span class="cx"> ftdm_io_interface_t *fio = NULL;
</span><span class="cx"> char *dup = NULL, *p;
</span><span class="cx"> char *rval = NULL;
</span><ins>+ char *type = NULL;
</ins><span class="cx">
</span><del>- if (type && !cmd) {
- dup = ftdm_strdup(type);
- if ((p = strchr(dup, ' '))) {
- *p++ = '\0';
- cmd = p;
- }
-
- type = dup;
</del><ins>+ dup = ftdm_strdup(cmd);
+ if ((p = strchr(dup, ' '))) {
+ *p++ = '\0';
+ cmd = p;
</ins><span class="cx"> }
</span><ins>+
+ type = dup;
</ins><span class="cx">
</span><span class="cx"> ftdm_mutex_lock(globals.mutex);
</span><span class="cx"> if (!(fio = (ftdm_io_interface_t *) hashtable_search(globals.interface_hash, (void *)type))) {
</span></span></pre></div>
<a id="freeswitchtrunklibsfreetdmsrcincludefreetdmh"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/libs/freetdm/src/include/freetdm.h (17438 => 17439)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/libs/freetdm/src/include/freetdm.h 2010-04-28 22:17:50 UTC (rev 17438)
+++ freeswitch/trunk/libs/freetdm/src/include/freetdm.h 2010-04-28 22:17:50 UTC (rev 17439)
</span><span class="lines">@@ -42,36 +42,54 @@
</span><span class="cx">
</span><span class="cx"> #include "ftdm_declare.h"
</span><span class="cx">
</span><ins>+/*! \brief Max number of channels per physical span */
</ins><span class="cx"> #define FTDM_MAX_CHANNELS_PHYSICAL_SPAN 32
</span><ins>+
+/*! \brief Max number of physical spans per logical span */
</ins><span class="cx"> #define FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN 32
</span><ins>+
+/*! \brief Max number of channels a logical span can contain */
</ins><span class="cx"> #define FTDM_MAX_CHANNELS_SPAN FTDM_MAX_CHANNELS_PHYSICAL_SPAN * FTDM_MAX_PHYSICAL_SPANS_PER_LOGICAL_SPAN
</span><ins>+
+/*! \brief Max number of logical spans */
</ins><span class="cx"> #define FTDM_MAX_SPANS_INTERFACE 128
</span><span class="cx">
</span><ins>+/*! \brief Max number of channels per hunting group */
</ins><span class="cx"> #define FTDM_MAX_CHANNELS_GROUP 1024
</span><ins>+
+/*! \brief Max number of groups */
</ins><span class="cx"> #define FTDM_MAX_GROUPS_INTERFACE FTDM_MAX_SPANS_INTERFACE
</span><span class="cx">
</span><del>-
</del><ins>+/*! \brief FreeTDM APIs possible return codes */
</ins><span class="cx"> typedef enum {
</span><del>- FTDM_SUCCESS,
- FTDM_FAIL,
- FTDM_MEMERR,
- FTDM_TIMEOUT,
- FTDM_NOTIMPL,
- FTDM_CHECKSUM_ERROR,
- FTDM_STATUS_COUNT,
- FTDM_BREAK
</del><ins>+ FTDM_SUCCESS, /*!< Success */
+ FTDM_FAIL, /*!< Failure, generic error return code, use ftdm_channel_get_last_error or ftdm_span_get_last_error for details */
+ FTDM_MEMERR, /*!< Memory error, most likely allocation failure */
+ 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) */
</ins><span class="cx"> } ftdm_status_t;
</span><span class="cx">
</span><del>-/* Thread/Mutex OS abstraction */
</del><ins>+/*! \brief FreeTDM bool type. */
+typedef enum {
+ FTDM_FALSE,
+ FTDM_TRUE
+} ftdm_bool_t;
+
+/*! \brief Thread/Mutex OS abstraction API. */
</ins><span class="cx"> #include "ftdm_os.h"
</span><span class="cx">
</span><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> extern "C" {
</span><span class="cx"> #endif
</span><span class="cx">
</span><ins>+/*! \brief Limit to span names */
</ins><span class="cx"> #define FTDM_MAX_NAME_STR_SZ 80
</span><ins>+
+/*! \brief Limit to channel number strings */
</ins><span class="cx"> #define FTDM_MAX_NUMBER_STR_SZ 20
</span><span class="cx">
</span><ins>+/*! \brief Hangup cause codes */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_CAUSE_NONE = 0,
</span><span class="cx"> FTDM_CAUSE_UNALLOCATED = 1,
</span><span class="lines">@@ -136,11 +154,13 @@
</span><span class="cx"> FTDM_CAUSE_MEDIA_TIMEOUT = 604
</span><span class="cx"> } ftdm_call_cause_t;
</span><span class="cx">
</span><ins>+/*! \brief Hunting direction (when hunting for free channels) */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_TOP_DOWN,
</span><span class="cx"> FTDM_BOTTOM_UP
</span><span class="cx"> } ftdm_direction_t;
</span><span class="cx">
</span><ins>+/*! \brief Event types */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_EVENT_NONE,
</span><span class="cx"> FTDM_EVENT_DTMF,
</span><span class="lines">@@ -148,12 +168,7 @@
</span><span class="cx"> FTDM_EVENT_COUNT
</span><span class="cx"> } ftdm_event_type_t;
</span><span class="cx">
</span><del>-typedef enum {
- FTDM_STATE_CHANGE_FAIL,
- FTDM_STATE_CHANGE_SUCCESS,
- FTDM_STATE_CHANGE_SAME,
-} ftdm_state_change_result_t;
-
</del><ins>+/*! \brief Generic event data type */
</ins><span class="cx"> struct ftdm_event {
</span><span class="cx"> ftdm_event_type_t e_type;
</span><span class="cx"> uint32_t enum_id;
</span><span class="lines">@@ -161,24 +176,38 @@
</span><span class="cx"> void *data;
</span><span class="cx"> };
</span><span class="cx">
</span><ins>+/*! \brief I/O channel type */
</ins><span class="cx"> typedef enum {
</span><del>- 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
</del><ins>+ FTDM_CHAN_TYPE_B, /*!< Bearer channel */
+ FTDM_CHAN_TYPE_DQ921, /*< DQ921 channel (D-channel) */
+ 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 */
</ins><span class="cx"> } ftdm_chan_type_t;
</span><span class="cx"> #define CHAN_TYPE_STRINGS "B", "DQ921", "DQ931", "FXS", "FXO", "EM", "CAS", "INVALID"
</span><ins>+/*! \brief 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")
+ */
</ins><span class="cx"> FTDM_STR2ENUM_P(ftdm_str2ftdm_chan_type, ftdm_chan_type2str, ftdm_chan_type_t)
</span><span class="cx">
</span><ins>+/*! \brief Test if a channel is a voice channel */
</ins><span class="cx"> #define FTDM_IS_VOICE_CHANNEL(ftdm_chan) ((ftdm_chan)->type != FTDM_CHAN_TYPE_DQ921 && (ftdm_chan)->type != FTDM_CHAN_TYPE_DQ931)
</span><ins>+
+/*! \brief Test if a channel is a D-channel */
</ins><span class="cx"> #define FTDM_IS_DCHAN(ftdm_chan) ((ftdm_chan)->type == FTDM_CHAN_TYPE_DQ921 || (ftdm_chan)->type == FTDM_CHAN_TYPE_DQ931)
</span><span class="cx">
</span><ins>+/*! \brief Logging function prototype to be used for all FreeTDM logs
+ * you should use ftdm_global_set_logger to set your own logger
+ */
</ins><span class="cx"> typedef void (*ftdm_logger_t)(const char *file, const char *func, int line, int level, const char *fmt, ...);
</span><span class="cx">
</span><ins>+/*! \brief Data queue operation functions
+ * you can use ftdm_global_set_queue_handler if you want to override the default implementation (not recommended)
+ */
</ins><span class="cx"> typedef ftdm_status_t (*ftdm_queue_create_func_t)(ftdm_queue_t **queue, ftdm_size_t capacity);
</span><span class="cx"> typedef ftdm_status_t (*ftdm_queue_enqueue_func_t)(ftdm_queue_t *queue, void *obj);
</span><span class="cx"> typedef void *(*ftdm_queue_dequeue_func_t)(ftdm_queue_t *queue);
</span><span class="lines">@@ -194,9 +223,7 @@
</span><span class="cx"> ftdm_queue_destroy_func_t destroy;
</span><span class="cx"> } ftdm_queue_handler_t;
</span><span class="cx">
</span><del>-/**
- * Type Of Number (TON)
- */
</del><ins>+/*! \brief Type Of Number (TON) */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_TON_UNKNOWN = 0,
</span><span class="cx"> FTDM_TON_INTERNATIONAL,
</span><span class="lines">@@ -208,9 +235,7 @@
</span><span class="cx"> FTDM_TON_INVALID = 255
</span><span class="cx"> } ftdm_ton_t;
</span><span class="cx">
</span><del>-/**
- * Numbering Plan Identification (NPI)
- */
</del><ins>+/*! Numbering Plan Identification (NPI) */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_NPI_UNKNOWN = 0,
</span><span class="cx"> FTDM_NPI_ISDN = 1,
</span><span class="lines">@@ -222,68 +247,59 @@
</span><span class="cx"> FTDM_NPI_INVALID = 255
</span><span class="cx"> } ftdm_npi_t;
</span><span class="cx">
</span><ins>+/*! \brief Number abstraction */
</ins><span class="cx"> typedef struct {
</span><span class="cx"> char digits[25];
</span><span class="cx"> uint8_t type;
</span><span class="cx"> uint8_t plan;
</span><span class="cx"> } ftdm_number_t;
</span><span class="cx">
</span><del>-typedef enum {
- FTDM_CALLER_STATE_DIALING,
- FTDM_CALLER_STATE_SUCCESS,
- FTDM_CALLER_STATE_FAIL
-} ftdm_caller_state_t;
-
</del><ins>+/*! \brief Caller information */
</ins><span class="cx"> typedef struct ftdm_caller_data {
</span><del>- char cid_date[8];
- char cid_name[80];
- ftdm_number_t cid_num;
- ftdm_number_t ani;
- ftdm_number_t dnis;
- ftdm_number_t rdnis;
- char aniII[25];
- uint8_t screen;
- uint8_t pres;
- char collected[25];
- int CRV;
- int hangup_cause;
- uint8_t raw_data[1024];
- uint32_t raw_data_len;
- uint32_t flags;
- ftdm_caller_state_t call_state;
- uint32_t chan_id;
</del><ins>+ char cid_date[8]; /*!< Caller ID date */
+ char cid_name[80]; /*!< Caller ID name */
+ ftdm_number_t cid_num; /*!< Caller ID number */
+ 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 */
+ uint8_t screen; /*!< Screening */
+ uint8_t pres; /*!< Presentation*/
+ char collected[25]; /*!< Collected digits so far */
+ int hangup_cause; /*! Hangup cause */
</ins><span class="cx"> } ftdm_caller_data_t;
</span><span class="cx">
</span><ins>+/*! \brief Tone type */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_TONE_DTMF = (1 << 0)
</span><span class="cx"> } ftdm_tone_type_t;
</span><span class="cx">
</span><ins>+/*! \brief Signaling messages sent by the stacks */
</ins><span class="cx"> typedef enum {
</span><del>- FTDM_SIGEVENT_START,
- FTDM_SIGEVENT_STOP,
- FTDM_SIGEVENT_TRANSFER,
- FTDM_SIGEVENT_ANSWER,
- FTDM_SIGEVENT_UP,
- FTDM_SIGEVENT_FLASH,
- FTDM_SIGEVENT_PROGRESS,
- FTDM_SIGEVENT_PROGRESS_MEDIA,
- FTDM_SIGEVENT_NOTIFY,
- FTDM_SIGEVENT_TONE_DETECTED,
- FTDM_SIGEVENT_ALARM_TRAP,
- FTDM_SIGEVENT_ALARM_CLEAR,
- FTDM_SIGEVENT_MISC,
- FTDM_SIGEVENT_COLLECTED_DIGIT,
- FTDM_SIGEVENT_ADD_CALL,
- FTDM_SIGEVENT_RESTART,
- /* Signaling status changed (D-chan up, down, R2 blocked etc) */
- FTDM_SIGEVENT_SIGSTATUS_CHANGED,
</del><ins>+ FTDM_SIGEVENT_START, /*!< Incoming call (ie: incoming SETUP msg or Ring) */
+ FTDM_SIGEVENT_STOP, /*!< Hangup */
+ FTDM_SIGEVENT_ANSWER, /*!< Outgoing call has been answered */
+ FTDM_SIGEVENT_UP, /*!< Outgoing call has been answered */
+ FTDM_SIGEVENT_FLASH, /*< Flash event (typically on-hook/off-hook for analog devices) */
+ FTDM_SIGEVENT_PROGRESS, /*!< Outgoing call is making progress */
+ FTDM_SIGEVENT_PROGRESS_MEDIA, /*!< Outgoing call is making progress and there is media available */
+ FTDM_SIGEVENT_TONE_DETECTED, /*!< Inband tone detected */
+ 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 */
</ins><span class="cx"> FTDM_SIGEVENT_INVALID
</span><span class="cx"> } ftdm_signal_event_t;
</span><span class="cx"> #define SIGNAL_STRINGS "START", "STOP", "TRANSFER", "ANSWER", "UP", "FLASH", "PROGRESS", \
</span><span class="cx"> "PROGRESS_MEDIA", "NOTIFY", "TONE_DETECTED", "ALARM_TRAP", "ALARM_CLEAR", "MISC", \
</span><span class="cx"> "COLLECTED_DIGIT", "ADD_CALL", "RESTART", "SIGLINK_CHANGED", "INVALID"
</span><ins>+
+/*! \brief Move from string to ftdm_signal_event_t and viceversa */
</ins><span class="cx"> FTDM_STR2ENUM_P(ftdm_str2ftdm_signal_event, ftdm_signal_event2str, ftdm_signal_event_t)
</span><span class="cx">
</span><ins>+/*! \brief Basic channel configuration provided to ftdm_configure_span_channels */
</ins><span class="cx"> typedef struct ftdm_channel_config {
</span><span class="cx"> char name[FTDM_MAX_NAME_STR_SZ];
</span><span class="cx"> char number[FTDM_MAX_NUMBER_STR_SZ];
</span><span class="lines">@@ -293,15 +309,18 @@
</span><span class="cx"> float txgain;
</span><span class="cx"> } ftdm_channel_config_t;
</span><span class="cx">
</span><ins>+/*! \brief Generic signaling message */
</ins><span class="cx"> struct ftdm_sigmsg {
</span><del>- ftdm_signal_event_t event_id;
- uint32_t chan_id;
- uint32_t span_id;
- ftdm_channel_t *channel;
- void *raw_data;
- uint32_t raw_data_len;
</del><ins>+ 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 */
</ins><span class="cx"> };
</span><span class="cx">
</span><ins>+/*! \brief Crash policy
+ * Useful for debugging only, default policy is never, if you wish to crash on asserts then use ftdm_global_set_crash_policy */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_CRASH_NEVER = 0,
</span><span class="cx"> FTDM_CRASH_ON_ASSERT
</span><span class="lines">@@ -315,14 +334,17 @@
</span><span class="cx"> FTDM_SIG_STATE_DOWN,
</span><span class="cx"> /* The signaling link is suspended (MFC-R2 bit pattern blocked, ss7 blocked?) */
</span><span class="cx"> FTDM_SIG_STATE_SUSPENDED,
</span><del>- /* The signaling link is ready and calls can be placed */
</del><ins>+ /* The signaling link is ready and calls can be placed (ie: d-chan up) */
</ins><span class="cx"> FTDM_SIG_STATE_UP,
</span><span class="cx"> /* Invalid status */
</span><span class="cx"> FTDM_SIG_STATE_INVALID
</span><span class="cx"> } ftdm_signaling_status_t;
</span><span class="cx"> #define SIGSTATUS_STRINGS "DOWN", "SUSPENDED", "UP", "INVALID"
</span><ins>+
+/*! \brief Move from string to ftdm_signaling_status_t and viceversa */
</ins><span class="cx"> FTDM_STR2ENUM_P(ftdm_str2ftdm_signaling_status, ftdm_signaling_status2str, ftdm_signaling_status_t)
</span><span class="cx">
</span><ins>+/*! \brief I/O waiting flags */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_NO_FLAGS = 0,
</span><span class="cx"> FTDM_READ = (1 << 0),
</span><span class="lines">@@ -330,11 +352,13 @@
</span><span class="cx"> FTDM_EVENTS = (1 << 2)
</span><span class="cx"> } ftdm_wait_flag_t;
</span><span class="cx">
</span><ins>+/*! \brief Signaling configuration parameter for the stacks (variable=value pair) */
</ins><span class="cx"> typedef struct ftdm_conf_parameter {
</span><span class="cx"> const char *var;
</span><span class="cx"> const char *val;
</span><span class="cx"> } ftdm_conf_parameter_t;
</span><span class="cx">
</span><ins>+/*! \brief Channel commands that can be executed through ftdm_channel_command() */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_COMMAND_NOOP,
</span><span class="cx"> FTDM_COMMAND_SET_INTERVAL,
</span><span class="lines">@@ -383,8 +407,7 @@
</span><span class="cx"> FTDM_COMMAND_COUNT
</span><span class="cx"> } ftdm_command_t;
</span><span class="cx">
</span><del>-
-
</del><ins>+/*! \brief Custom memory handler hooks. Not recommended to use unless you need memory allocation customizations */
</ins><span class="cx"> typedef void *(*ftdm_malloc_func_t)(void *pool, ftdm_size_t len);
</span><span class="cx"> typedef void *(*ftdm_calloc_func_t)(void *pool, ftdm_size_t elements, ftdm_size_t len);
</span><span class="cx"> typedef void *(*ftdm_realloc_func_t)(void *pool, void *buff, ftdm_size_t len);
</span><span class="lines">@@ -397,6 +420,9 @@
</span><span class="cx"> ftdm_free_func_t free;
</span><span class="cx"> } ftdm_memory_handler_t;
</span><span class="cx">
</span><ins>+
+/*! \brief FreeTDM I/O layer interface argument macros
+ * You don't need these unless your implementing an I/O interface module (most users don't) */
</ins><span class="cx"> #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)
</span><span class="cx"> #define FIO_CHANNEL_OUTGOING_CALL_ARGS (ftdm_channel_t *ftdmchan)
</span><span class="cx"> #define FIO_CHANNEL_SET_SIG_STATUS_ARGS (ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status)
</span><span class="lines">@@ -426,6 +452,8 @@
</span><span class="cx"> #define FIO_SIG_UNLOAD_ARGS (void)
</span><span class="cx"> #define FIO_API_ARGS (ftdm_stream_handle_t *stream, const char *data)
</span><span class="cx">
</span><ins>+/*! \brief FreeTDM I/O layer interface function typedefs
+ * You don't need these unless your implementing an I/O interface module (most users don't) */
</ins><span class="cx"> typedef ftdm_status_t (*fio_channel_request_t) FIO_CHANNEL_REQUEST_ARGS ;
</span><span class="cx"> typedef ftdm_status_t (*fio_channel_outgoing_call_t) FIO_CHANNEL_OUTGOING_CALL_ARGS ;
</span><span class="cx"> typedef ftdm_status_t (*fio_channel_set_sig_status_t) FIO_CHANNEL_SET_SIG_STATUS_ARGS;
</span><span class="lines">@@ -456,6 +484,8 @@
</span><span class="cx"> typedef ftdm_status_t (*fio_api_t) FIO_API_ARGS ;
</span><span class="cx">
</span><span class="cx">
</span><ins>+/*! \brief 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) */
</ins><span class="cx"> #define FIO_CHANNEL_REQUEST_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_REQUEST_ARGS
</span><span class="cx"> #define FIO_CHANNEL_OUTGOING_CALL_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_OUTGOING_CALL_ARGS
</span><span class="cx"> #define FIO_CHANNEL_SET_SIG_STATUS_FUNCTION(name) ftdm_status_t name FIO_CHANNEL_SET_SIG_STATUS_ARGS
</span><span class="lines">@@ -485,24 +515,27 @@
</span><span class="cx"> #define FIO_SIG_UNLOAD_FUNCTION(name) ftdm_status_t name FIO_SIG_UNLOAD_ARGS
</span><span class="cx"> #define FIO_API_FUNCTION(name) ftdm_status_t name FIO_API_ARGS
</span><span class="cx">
</span><ins>+/*! \brief 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) */
</ins><span class="cx"> struct ftdm_io_interface {
</span><del>- const char *name;
- fio_configure_span_t configure_span;
- fio_configure_t configure;
- fio_open_t open;
- fio_close_t close;
- fio_channel_destroy_t channel_destroy;
- fio_span_destroy_t span_destroy;
- fio_get_alarms_t get_alarms;
- fio_command_t command;
- fio_wait_t wait;
- fio_read_t read;
- fio_write_t write;
- fio_span_poll_event_t poll_event;
- fio_span_next_event_t next_event;
- fio_api_t api;
</del><ins>+ const char *name; /*!< I/O module name */
+ fio_configure_span_t configure_span; /*!< Configure span I/O */
+ fio_configure_t configure; /*!< Configure the module */
+ fio_open_t open; /*!< Open I/O channel */
+ fio_close_t close; /*!< Close I/O channel */
+ fio_channel_destroy_t channel_destroy; /*!< Destroy I/O channel */
+ fio_span_destroy_t span_destroy; /*!< Destroy span I/O */
+ fio_get_alarms_t get_alarms; /*!< Get hardware alarms */
+ fio_command_t command; /*!< Execute an I/O command on the channel */
+ fio_wait_t wait; /*!< Wait for events on the channel */
+ fio_read_t read; /*!< Read data from the channel */
+ fio_write_t write; /*!< Write data to the channel */
+ fio_span_poll_event_t poll_event; /*!< Poll for events on the whole span */
+ fio_span_next_event_t next_event; /*!< Retrieve an event from the span */
+ fio_api_t api; /*!< Execute a text command */
</ins><span class="cx"> };
</span><span class="cx">
</span><ins>+/*! \brief FreeTDM supported I/O codecs */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_CODEC_ULAW = 0,
</span><span class="cx"> FTDM_CODEC_ALAW = 8,
</span><span class="lines">@@ -510,6 +543,9 @@
</span><span class="cx"> FTDM_CODEC_NONE = (1 << 30)
</span><span class="cx"> } ftdm_codec_t;
</span><span class="cx">
</span><ins>+/*! \brief FreeTDM supported indications.
+ * This is used during incoming calls when you want to request the signaling stack
+ * to notify about indications occurring locally */
</ins><span class="cx"> typedef enum {
</span><span class="cx"> FTDM_CHANNEL_INDICATE_RING,
</span><span class="cx"> FTDM_CHANNEL_INDICATE_PROCEED,
</span><span class="lines">@@ -518,12 +554,8 @@
</span><span class="cx"> FTDM_CHANNEL_INDICATE_BUSY,
</span><span class="cx"> } ftdm_channel_indication_t;
</span><span class="cx">
</span><ins>+/*! \brief FreeTDM supported hardware alarms. */
</ins><span class="cx"> typedef enum {
</span><del>- FTDM_FALSE,
- FTDM_TRUE
-} ftdm_bool_t;
-
-typedef enum {
</del><span class="cx"> FTDM_ALARM_NONE = 0,
</span><span class="cx"> FTDM_ALARM_RED = (1 << 1),
</span><span class="cx"> FTDM_ALARM_YELLOW = (1 << 2),
</span><span class="lines">@@ -536,119 +568,628 @@
</span><span class="cx"> /*! \brief Override the default queue handler */
</span><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_global_set_queue_handler(ftdm_queue_handler_t *handler);
</span><span class="cx">
</span><ins>+/*! \brief Call control APIs*/
+
+/*! \brief Answer call */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_answer(ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Place an outgoing call */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_place(ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Indicate a new condition in an incoming call */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_indicate(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication);
</span><ins>+
+/*! \brief Hangup the call without and with cause */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_hangup(ftdm_channel_t *ftdmchan);
</span><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_hangup_with_cause(ftdm_channel_t *ftdmchan, ftdm_call_cause_t);
</span><ins>+
+/*! \brief Put a call on hold (if supported by the signaling stack) */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_hold(ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Unhold a call */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_call_unhold(ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Check if the call is answered already */
</ins><span class="cx"> FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_answered(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Check if the call is busy */
</ins><span class="cx"> FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_busy(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Check if the call is hangup */
</ins><span class="cx"> FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_hangup(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Check if the call is done (final state for a call, just after hangup) */
</ins><span class="cx"> FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_done(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Check if the call is in hold */
</ins><span class="cx"> FT_DECLARE(ftdm_bool_t) ftdm_channel_call_check_hold(const ftdm_channel_t *ftdmchan);
</span><span class="cx">
</span><ins>+/*! \brief Set channel signaling status (ie: put specific circuit down) only if supported by the signaling */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_set_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t status);
</span><ins>+
+/*! \brief Get channel signaling status (ie: whether protocol layer is up or down) */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_get_sig_status(ftdm_channel_t *ftdmchan, ftdm_signaling_status_t *status);
</span><ins>+
+/*! \brief Set span signaling status (ie: put the whole span protocol layer down) only if supported by the signaling */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_set_sig_status(ftdm_span_t *span, ftdm_signaling_status_t status);
</span><ins>+
+/*! \brief Get span signaling status (ie: whether protocol layer is up or down) */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_get_sig_status(ftdm_span_t *span, ftdm_signaling_status_t *status);
</span><span class="cx">
</span><ins>+/*! \brief Get span signaling status (ie: whether protocol layer is up or down) */
</ins><span class="cx"> FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
</span><del>-FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan);
</del><span class="cx">
</span><del>-FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan);
</del><ins>+/*!
+ * \brief Remove the given token from the channel
+ *
+ * \param ftdmchan The channel where the token is
+ * \param token The token string. If NULL, all tokens in the channel are cleared
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_clear_token(ftdm_channel_t *ftdmchan, const char *token);
</span><ins>+
+/*!
+ * \brief Replace the given token with the new token
+ *
+ * \param ftdmchan The channel where the token is
+ * \param token The token string. If NULL, all tokens in the channel are cleared
+ */
</ins><span class="cx"> FT_DECLARE(void) ftdm_channel_replace_token(ftdm_channel_t *ftdmchan, const char *old_token, const char *new_token);
</span><ins>+
+/*!
+ * \brief Add a new token to the channel
+ *
+ * \param ftdmchan The channel where the token will be added
+ * \param token The token string to add
+ * \param end if 0, the token will be added at the beginning of the token list, to the end otherwise
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_add_token(ftdm_channel_t *ftdmchan, char *token, int end);
</span><ins>+
+/*!
+ * \brief Get the requested token
+ *
+ * \param ftdmchan The channel where the token is
+ * \param tokenid The id of the token
+ *
+ * \retval The token character string
+ * \retval NULL token not found
+ */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_token(const ftdm_channel_t *ftdmchan, uint32_t tokenid);
</span><ins>+
+/*!
+ * \brief Get the token count
+ *
+ * \param ftdmchan The channel to get the token count from
+ *
+ * \retval The token count
+ */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_token_count(const ftdm_channel_t *ftdmchan);
</span><span class="cx">
</span><ins>+/*!
+ * \brief Get the I/O read/write interval
+ *
+ * \param ftdmchan The channel to get the interval from
+ *
+ * \retval The interval in milliseconds
+ */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_io_interval(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*!
+ * \brief Get the I/O read/write packet length per interval
+ *
+ * \param ftdmchan The channel to get the packet length from
+ *
+ * \retval The packet length interval in bytes
+ */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_io_packet_len(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*!
+ * \brief Get the I/O read/write codec
+ *
+ * \param ftdmchan The channel to get the codec from
+ *
+ * \retval The codec type
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_codec_t) ftdm_channel_get_codec(const ftdm_channel_t *ftdmchan);
</span><span class="cx">
</span><ins>+/*!
+ * \brief Get the last error string for the channel
+ *
+ * \param ftdmchan The channel to get the error from
+ *
+ * \retval The error string (not thread-safe, the string is per channel, not per thread)
+ */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_last_error(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*!
+ * \brief Get the current alarm bitmask for the channel
+ *
+ * \param ftdmchan The channel to get the alarm bitmask from
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_get_alarms(ftdm_channel_t *ftdmchan, ftdm_alarm_flag_t *alarmbits);
</span><ins>+
+/*!
+ * \brief Get the channel type
+ *
+ * \param ftdmchan The channel to get the type from
+ *
+ * \retval channel type (FXO, FXS, B-channel, D-channel, etc)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_chan_type_t) ftdm_channel_get_type(const ftdm_channel_t *ftdmchan);
</span><span class="cx">
</span><ins>+/*!
+ * \brief Get the channel type
+ *
+ * \param ftdmchan The channel to get the type from
+ *
+ * \retval channel type (FXO, FXS, B-channel, D-channel, etc)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_size_t) ftdm_channel_dequeue_dtmf(ftdm_channel_t *ftdmchan, char *dtmf, ftdm_size_t len);
</span><ins>+
+/*!
+ * \brief Enqueue a DTMF string into the channel
+ *
+ * \param ftdmchan The channel to enqueue the dtmf string to
+ * \param dtmf null-terminated DTMF string
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf);
</span><ins>+
+/*!
+ * \brief Flush the DTMF queue
+ *
+ * \param ftdmchan The channel to flush the dtmf queue of
+ */
</ins><span class="cx"> FT_DECLARE(void) ftdm_channel_flush_dtmf(ftdm_channel_t *ftdmchan);
</span><ins>+
+/*!
+ * \brief Wait for an event in the span
+ *
+ * \param span The span to wait events for
+ * \param ms Milliseconds timeout
+ *
+ * \retval FTDM_SUCCESS success (at least one event available)
+ * \retval FTDM_TIMEOUT Timed out waiting for events
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_poll_event(ftdm_span_t *span, uint32_t ms);
</span><ins>+
+/*!
+ * \brief 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.
+ *
+ * \param span The span to retrieve the event from
+ * \param event Pointer to store the pointer to the event
+ *
+ * \retval FTDM_SUCCESS success (at least one event available)
+ * \retval FTDM_TIMEOUT Timed out waiting for events
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event);
</span><ins>+
+/*!
+ * \brief Find a span by its id
+ *
+ * \param id The span id
+ * \param span Pointer to store the span if found
+ *
+ * \retval FTDM_SUCCESS success (span is valid)
+ * \retval FTDM_FAIL failure (span is not valid)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_find(uint32_t id, ftdm_span_t **span);
</span><ins>+
+/*!
+ * \brief Find a span by its id
+ *
+ * \param id The span id
+ * \param span Pointer to store the span if found
+ *
+ * \retval FTDM_SUCCESS success (span is valid)
+ * \retval FTDM_FAIL failure (span is not valid)
+ */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_span_get_last_error(const ftdm_span_t *ftdmchan);
</span><ins>+
+/*!
+ * \brief Create a new span (not needed if you are using freetdm.conf)
+ *
+ * \param fio The I/O interface the span will use
+ * \param span Pointer to store the create span
+ * \param name Name for the span
+ *
+ * \retval FTDM_SUCCESS success (the span was created)
+ * \retval FTDM_FAIL failure (span was not created)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_create(ftdm_io_interface_t *fio, ftdm_span_t **span, const char *name);
</span><del>-FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
</del><ins>+
+/*!
+ * \brief Add a new channel to a span
+ *
+ * \param span Where to add the new channel
+ * \param sockfd The socket device associated to the channel (ie: sangoma device, dahdi device etc)
+ * \param type Channel type
+ * \param chan Pointer to store the newly allocated channel
+ *
+ * \retval FTDM_SUCCESS success (the channel was created)
+ * \retval FTDM_FAIL failure (span was not created)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_add_channel(ftdm_span_t *span, ftdm_socket_t sockfd, ftdm_chan_type_t type, ftdm_channel_t **chan);
</span><ins>+
+/*! \brief Set an event callback for the span */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_set_event_callback(ftdm_span_t *span, fio_event_cb_t event_callback);
</span><ins>+
+/*! \brief Add the channel to a hunt group */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_add_to_group(const char* name, ftdm_channel_t* ftdmchan);
</span><ins>+
+/*! \brief Remove the channel from a hunt group */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_remove_from_group(ftdm_group_t* group, ftdm_channel_t* ftdmchan);
</span><ins>+
+/*! \brief Find a hunt group by id */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_group_find(uint32_t id, ftdm_group_t **group);
</span><ins>+
+/*! \brief Find a hunt group by name */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_group_find_by_name(const char *name, ftdm_group_t **group);
</span><ins>+
+/*! \brief Create a group with the given name */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_group_create(ftdm_group_t **group, const char *name);
</span><ins>+
+/*! \brief Set the event callback for the channel */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_set_event_callback(ftdm_channel_t *ftdmchan, fio_event_cb_t event_callback);
</span><del>-FT_DECLARE(ftdm_status_t) ftdm_channel_open(uint32_t span_id, uint32_t chan_id, ftdm_channel_t **ftdmchan);
-FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
</del><ins>+
+/*! \brief Get the number of channels in use on a span */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_channel_use_count(ftdm_span_t *span, uint32_t *count);
</span><ins>+
+/*! \brief Get the number of channels in use on a group */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_group_channel_use_count(ftdm_group_t *group, uint32_t *count);
</span><ins>+
+/*! \brief Get the id of a group */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_group_get_id(const ftdm_group_t *group);
</span><ins>+
+/*!
+ * \brief Open a channel specifying the span id and chan id (required before placing a call on 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
+ *
+ * \param span_id The span id the channel belongs to
+ * \param chan_id Channel id of the channel you want to open
+ * \param ftdmchan Pointer to store the channel once is open
+ *
+ * \retval FTDM_SUCCESS success (the channel was found and is available)
+ * \retval FTDM_FAIL failure (channel was not found or not available)
+ */
+FT_DECLARE(ftdm_status_t) ftdm_channel_open(uint32_t span_id, uint32_t chan_id, ftdm_channel_t **ftdmchan);
+
+/*!
+ * \brief Hunts and opens a channel specifying the span id only
+ *
+ * \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
+ *
+ * \param span_id The span id to hunt for a channel
+ * \param direction The hunting direction
+ * \param caller_data The calling party information
+ * \param ftdmchan The channel pointer to store the available channel
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_span(uint32_t span_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan);
</span><ins>+
+/*!
+ * \brief Hunts and opens a channel specifying group id
+ *
+ * \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
+ *
+ * \param group_id The group id to hunt for a channel
+ * \param direction The hunting direction
+ * \param caller_data The calling party information
+ * \param ftdmchan The channel pointer to store the available channel
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_open_by_group(uint32_t group_id, ftdm_direction_t direction, ftdm_caller_data_t *caller_data, ftdm_channel_t **ftdmchan);
</span><ins>+
+/*!
+ * \brief Close a previously open channel
+ *
+ * \note If you call ftdm_channel_call_hangup() you MUST NOT call this function, the signaling
+ * stack will close the channel.
+ *
+ * \param ftdmchan pointer to the channel to close
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_close(ftdm_channel_t **ftdmchan);
</span><del>-FT_DECLARE(ftdm_status_t) ftdm_channel_command(ftdm_channel_t *ftdmchan, ftdm_command_t command, void *obj);
-FT_DECLARE(ftdm_status_t) ftdm_channel_wait(ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t to);
</del><ins>+
+/*!
+ * \brief Execute a command in a channel
+ *
+ * \param ftdmchan The channel to execute the command
+ * \param command The command to execute
+ * \param arg The argument for the command
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
+FT_DECLARE(ftdm_status_t) ftdm_channel_command(ftdm_channel_t *ftdmchan, ftdm_command_t command, void *arg);
+
+/*!
+ * \brief Wait for I/O events in a channel
+ *
+ * \param ftdmchan The channel to wait I/O for
+ * \param flags The wait I/O flags
+ * \param timeout The timeout in milliseconds
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
+FT_DECLARE(ftdm_status_t) ftdm_channel_wait(ftdm_channel_t *ftdmchan, ftdm_wait_flag_t *flags, int32_t timeout);
+
+/*!
+ * \brief Read data from a channel
+ *
+ * \param ftdmchan The channel to read data from
+ * \param data The pointer to the buffer to store the read data
+ * \param datalen The size in bytes of the provided buffer
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_read(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen);
</span><ins>+
+/*!
+ * \brief Write data to a channel
+ *
+ * \param ftdmchan The channel to write data to
+ * \param data The pointer to the buffer to write
+ * \param datalen The size in bytes of the provided buffer
+ *
+ * \retval FTDM_SUCCESS success (a suitable channel was found available)
+ * \retval FTDM_FAIL failure (no suitable channel was found available)
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_write(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t datasize, ftdm_size_t *datalen);
</span><ins>+
+/*! \brief Add a custom variable to the channel */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_add_var(ftdm_channel_t *ftdmchan, const char *var_name, const char *value);
</span><ins>+
+/*! \brief Get a custom variable from the channel */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_var(ftdm_channel_t *ftdmchan, const char *var_name);
</span><ins>+
+/*! \brief Clear custom channel variables from the channel */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_clear_vars(ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the span pointer associated to the channel */
</ins><span class="cx"> FT_DECLARE(ftdm_span_t *) ftdm_channel_get_span(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the span pointer associated to the channel */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_span_id(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the physical span id associated to the channel */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_ph_span_id(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the span name associated to the channel */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_span_name(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the id associated to the channel */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_id(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the name associated to the channel */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_name(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the number associated to the channel */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_number(const ftdm_channel_t *ftdmchan);
</span><ins>+
+/*! \brief Get the number physical id associated to the channel */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_channel_get_ph_id(const ftdm_channel_t *ftdmchan);
</span><del>-FT_DECLARE(ftdm_status_t) ftdm_global_init(void);
-FT_DECLARE(ftdm_status_t) ftdm_global_configuration(void);
-FT_DECLARE(ftdm_status_t) ftdm_global_destroy(void);
-FT_DECLARE(ftdm_status_t) ftdm_global_set_memory_handler(ftdm_memory_handler_t *handler);
-FT_DECLARE(void) ftdm_global_set_crash_policy(ftdm_crash_policy_t policy);
-FT_DECLARE(void) ftdm_global_set_logger(ftdm_logger_t logger);
-FT_DECLARE(void) ftdm_global_set_default_logger(int level);
-FT_DECLARE(ftdm_bool_t) ftdm_running(void);
</del><ins>+
+/*!
+ * \brief Configure span with a signaling type (deprecated use ftdm_configure_span_signaling instead)
+ *
+ * \note This function does the same as ftdm_configure_span_signaling
+ *
+ * \param type The signaling type ("boost", "isdn" and others, this depends on the available signaling modules)
+ * \param span The span to configure
+ * \param sig_cb The callback that the signaling stack will use to notify about events
+ * \param ... variable argument list with "var", value sequence, the variable and values are signaling type dependant
+ * the last argument must be FTDM_TAG_END
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_configure_span(const char *type, ftdm_span_t *span, fio_signal_cb_t sig_cb, ...);
</span><ins>+#define FTDM_TAG_END NULL
+
+
+/*!
+ * \brief Configure span with a signaling type
+ *
+ * \param type The signaling type ("boost", "isdn" and others, this depends on the available signaling modules)
+ * \param span The span to configure
+ * \param sig_cb The callback that the signaling stack will use to notify about events
+ * \param ... variable argument list with "var", value sequence, the variable and values are signaling type dependant
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_configure_span_signaling(const char *type, ftdm_span_t *span, fio_signal_cb_t sig_cb, ftdm_conf_parameter_t *parameters);
</span><ins>+
+/*!
+ * \brief 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!
+ *
+ * \param span The span to start
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_start(ftdm_span_t *span);
</span><ins>+
+
+/*!
+ * \brief Stop the span signaling (must call ftdm_span_start first)
+ *
+ * \param span The span to stop
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_stop(ftdm_span_t *span);
</span><ins>+
+/*!
+ * \brief Register a custom I/O interface with the FreeTDM core
+ *
+ * \param io_interface the Interface to register
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_global_add_io_interface(ftdm_io_interface_t *io_interface);
</span><ins>+
+/*! \brief Find a span by name */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_span_find_by_name(const char *name, ftdm_span_t **span);
</span><ins>+
+/*! \brief Get the span id */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_span_get_id(const ftdm_span_t *span);
</span><ins>+
+/*! \brief Get the span name */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_span_get_name(const ftdm_span_t *span);
</span><del>-FT_DECLARE(char *) ftdm_api_execute(const char *type, const char *cmd);
</del><ins>+
+/*!
+ * \brief Execute a text command. The text command output will be returned and must be free'd
+ *
+ * \param cmd The command to execute
+ *
+ * \retval FTDM_SUCCESS success
+ * \retval FTDM_FAIL failure
+ */
+FT_DECLARE(char *) ftdm_api_execute(const char *cmd);
+
+/*!
+ * \brief Disables CPU monitoring
+ *
+ * \note CPU monitoring is enabled by default. This means a thread will be launched at startup (ftdm_global_init)
+ * with the sole purpose of monitoring system-wide CPU usage. If the CPU usage raises above a defined
+ * threshold, no new calls will be accepted (neither incoming or outgoing)
+ *
+ */
</ins><span class="cx"> FT_DECLARE(void) ftdm_cpu_monitor_disable(void);
</span><ins>+
+/*!
+ * \brief Create a configuration node
+ *
+ * \param name The name of the configuration node
+ * \param node The node pointer to store the new node
+ * \param parent The parent node if any, or NULL if no parent
+ *
+ * \return FTDM_SUCCESS success
+ * \return FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_conf_node_create(const char *name, ftdm_conf_node_t **node, ftdm_conf_node_t *parent);
</span><ins>+
+/*!
+ * \brief Adds a new parameter to the specified configuration node
+ *
+ * \param param The parameter name
+ * \param val The parameter value
+ *
+ * \return FTDM_SUCCESS success
+ * \return FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_conf_node_add_param(ftdm_conf_node_t *node, const char *param, const char *val);
</span><ins>+
+/*!
+ * \brief Destroy the memory allocated for a configuration node (and all of its descendance)
+ *
+ * \param node The node to destroy
+ *
+ * \return FTDM_SUCCESS success
+ * \return FTDM_FAIL failure
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_conf_node_destroy(ftdm_conf_node_t *node);
</span><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_configure_span_channels(ftdm_span_t *span, const char *str, ftdm_channel_config_t *chan_config, unsigned *configured);
</span><span class="cx">
</span><ins>+/*!
+ * \brief Return the channel identified by the provided id
+ *
+ * \param span The span where the channel belongs
+ * \param chanid The channel id within the span
+ *
+ * \return The channel pointer if found, NULL otherwise
+ */
</ins><span class="cx"> FT_DECLARE(ftdm_channel_t *) ftdm_span_get_channel(const ftdm_span_t *span, uint32_t chanid);
</span><ins>+
+/*! \brief Return the channel count number for the given span */
</ins><span class="cx"> FT_DECLARE(uint32_t) ftdm_span_get_chan_count(const ftdm_span_t *span);
</span><span class="cx">
</span><ins>+/*! \brief Set the caller data for a channel. Be sure to call this before ftdm_channel_call_place() */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_set_caller_data(ftdm_channel_t *ftdmchan, ftdm_caller_data_t *caller_data);
</span><ins>+
+/*! \brief Get the caller data for a channel, typically you need this when receiving FTDM_SIGEVENT_START */
</ins><span class="cx"> FT_DECLARE(ftdm_caller_data_t *) ftdm_channel_get_caller_data(ftdm_channel_t *channel);
</span><ins>+
+/*! \brief For display debugging purposes you can display this string which describes the current channel internal state */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_state_str(const ftdm_channel_t *channel);
</span><ins>+
+/*! \brief For display debugging purposes you can display this string which describes the last channel internal state */
</ins><span class="cx"> FT_DECLARE(const char *) ftdm_channel_get_last_state_str(const ftdm_channel_t *channel);
</span><span class="cx">
</span><del>-/* TODO: try to get rid of this API */
</del><ins>+/*! \brief For display debugging purposes you can display this string which describes the last channel internal state */
</ins><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_init(ftdm_channel_t *ftdmchan);
</span><span class="cx">
</span><ins>+/*! \brief Initialize the library */
+FT_DECLARE(ftdm_status_t) ftdm_global_init(void);
+
+/*! \brief Create spans and channels reading the freetdm.conf file */
+FT_DECLARE(ftdm_status_t) ftdm_global_configuration(void);
+
+/*! \brief Shutdown the library */
+FT_DECLARE(ftdm_status_t) ftdm_global_destroy(void);
+
+/*! \brief Set memory handler for the library */
+FT_DECLARE(ftdm_status_t) ftdm_global_set_memory_handler(ftdm_memory_handler_t *handler);
+
+/*! \brief Set the crash policy for the library */
+FT_DECLARE(void) ftdm_global_set_crash_policy(ftdm_crash_policy_t policy);
+
+/*! \brief Set the logger handler for the library */
+FT_DECLARE(void) ftdm_global_set_logger(ftdm_logger_t logger);
+
+/*! \brief Set the default logger level */
+FT_DECLARE(void) ftdm_global_set_default_logger(int level);
+
+/*! \brief Check if the FTDM library is initialized and running */
+FT_DECLARE(ftdm_bool_t) ftdm_running(void);
+
+FT_DECLARE_DATA extern ftdm_logger_t ftdm_log;
+
+/*! \brief Basic transcoding function prototype */
</ins><span class="cx"> #define FIO_CODEC_ARGS (void *data, ftdm_size_t max, ftdm_size_t *datalen)
</span><span class="cx"> #define FIO_CODEC_FUNCTION(name) FT_DECLARE_NONSTD(ftdm_status_t) name FIO_CODEC_ARGS
</span><span class="cx"> typedef ftdm_status_t (*fio_codec_t) FIO_CODEC_ARGS ;
</span><ins>+
+/*! \brief Basic transcoding functions */
</ins><span class="cx"> FIO_CODEC_FUNCTION(fio_slin2ulaw);
</span><span class="cx"> FIO_CODEC_FUNCTION(fio_ulaw2slin);
</span><span class="cx"> FIO_CODEC_FUNCTION(fio_slin2alaw);
</span><span class="lines">@@ -656,9 +1197,6 @@
</span><span class="cx"> FIO_CODEC_FUNCTION(fio_ulaw2alaw);
</span><span class="cx"> FIO_CODEC_FUNCTION(fio_alaw2ulaw);
</span><span class="cx">
</span><del>-
-FT_DECLARE_DATA extern ftdm_logger_t ftdm_log;
-
</del><span class="cx"> #define FTDM_PRE __FILE__, __FUNCTION__, __LINE__
</span><span class="cx"> #define FTDM_LOG_LEVEL_DEBUG 7
</span><span class="cx"> #define FTDM_LOG_LEVEL_INFO 6
</span><span class="lines">@@ -669,6 +1207,7 @@
</span><span class="cx"> #define FTDM_LOG_LEVEL_ALERT 1
</span><span class="cx"> #define FTDM_LOG_LEVEL_EMERG 0
</span><span class="cx">
</span><ins>+/*! \brief Log levels */
</ins><span class="cx"> #define FTDM_LOG_DEBUG FTDM_PRE, FTDM_LOG_LEVEL_DEBUG
</span><span class="cx"> #define FTDM_LOG_INFO FTDM_PRE, FTDM_LOG_LEVEL_INFO
</span><span class="cx"> #define FTDM_LOG_NOTICE FTDM_PRE, FTDM_LOG_LEVEL_NOTICE
</span><span class="lines">@@ -678,8 +1217,6 @@
</span><span class="cx"> #define FTDM_LOG_ALERT FTDM_PRE, FTDM_LOG_LEVEL_ALERT
</span><span class="cx"> #define FTDM_LOG_EMERG FTDM_PRE, FTDM_LOG_LEVEL_EMERG
</span><span class="cx">
</span><del>-#define FTDM_TAG_END NULL
-
</del><span class="cx"> #ifdef __cplusplus
</span><span class="cx"> } /* extern C */
</span><span class="cx"> #endif
</span></span></pre></div>
<a id="freeswitchtrunklibsfreetdmsrcincludeprivateftdm_coreh"></a>
<div class="modfile"><h4>Modified: freeswitch/trunk/libs/freetdm/src/include/private/ftdm_core.h (17438 => 17439)</h4>
<pre class="diff"><span>
<span class="info">--- freeswitch/trunk/libs/freetdm/src/include/private/ftdm_core.h 2010-04-28 22:17:50 UTC (rev 17438)
+++ freeswitch/trunk/libs/freetdm/src/include/private/ftdm_core.h 2010-04-28 22:17:50 UTC (rev 17439)
</span><span class="lines">@@ -263,6 +263,13 @@
</span><span class="cx"> */
</span><span class="cx"> #define ftdm_copy_flags(dest, src, flags) (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags))
</span><span class="cx">
</span><ins>+/*! \brief channel state change result */
+typedef enum {
+ FTDM_STATE_CHANGE_FAIL,
+ FTDM_STATE_CHANGE_SUCCESS,
+ FTDM_STATE_CHANGE_SAME,
+} ftdm_state_change_result_t;
+
</ins><span class="cx"> struct ftdm_stream_handle {
</span><span class="cx"> ftdm_stream_handle_write_function_t write_function;
</span><span class="cx"> ftdm_stream_handle_raw_write_function_t raw_write_function;
</span><span class="lines">@@ -556,17 +563,16 @@
</span><span class="cx">
</span><span class="cx"> FT_DECLARE(char *) ftdm_build_dso_path(const char *name, char *path, ftdm_size_t len);
</span><span class="cx">
</span><ins>+FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan);
+FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan);
+
</ins><span class="cx"> FT_DECLARE(int) ftdm_load_module(const char *name);
</span><span class="cx"> FT_DECLARE(int) ftdm_load_module_assume(const char *name);
</span><span class="cx"> FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap);
</span><span class="cx"> FT_DECLARE(ftdm_status_t) ftdm_channel_done(ftdm_channel_t *ftdmchan);
</span><span class="cx">
</span><del>-FIO_CODEC_FUNCTION(fio_slin2ulaw);
-FIO_CODEC_FUNCTION(fio_ulaw2slin);
-FIO_CODEC_FUNCTION(fio_slin2alaw);
-FIO_CODEC_FUNCTION(fio_alaw2slin);
-FIO_CODEC_FUNCTION(fio_ulaw2alaw);
-FIO_CODEC_FUNCTION(fio_alaw2ulaw);
</del><ins>+FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
+FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
</ins><span class="cx">
</span><span class="cx"> /*!
</span><span class="cx"> \brief Assert condition
</span></span></pre>
</div>
</div>
<div id="footer">See you at ClueCon</div>
</body>
</html>