root/src/include/private/ftdm_core.h

/* [<][>][^][v][top][bottom][index][help] */

INCLUDED FROM


DEFINITIONS

This source file includes following definitions.
  1. ftdm_clean_string
  2. FT_DECLARE
  3. ftdm_abort
  4. ftdm_saturated_add

   1 /*
   2  * Copyright (c) 2010, Sangoma Technologies
   3  * Moises Silva <moy@sangoma.com>
   4  * All rights reserved.
   5  * 
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 
  10  * * Redistributions of source code must retain the above copyright
  11  * notice, this list of conditions and the following disclaimer.
  12  * 
  13  * * Redistributions in binary form must reproduce the above copyright
  14  * notice, this list of conditions and the following disclaimer in the
  15  * documentation and/or other materials provided with the distribution.
  16  * 
  17  * * Neither the name of the original author; nor the names of any contributors
  18  * may be used to endorse or promote products derived from this software
  19  * without specific prior written permission.
  20  * 
  21  * 
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  25  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
  26  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34 
  35 #include "freetdm.h"
  36 
  37 #ifndef __PRIVATE_FTDM_CORE__
  38 #define __PRIVATE_FTDM_CORE__
  39 
  40 #if !defined(_XOPEN_SOURCE) && !defined(__FreeBSD__)
  41 #define _XOPEN_SOURCE 600
  42 #endif
  43 
  44 #ifndef HAVE_STRINGS_H
  45 #define HAVE_STRINGS_H 1
  46 #endif
  47 #ifndef HAVE_SYS_SOCKET_H
  48 #define HAVE_SYS_SOCKET_H 1
  49 #endif
  50 
  51 #ifdef _MSC_VER
  52 #ifndef __inline__
  53 #define __inline__ __inline
  54 #endif
  55 #if (_MSC_VER >= 1400)                  /* VC8+ */
  56 #ifndef _CRT_SECURE_NO_DEPRECATE
  57 #define _CRT_SECURE_NO_DEPRECATE
  58 #endif
  59 #ifndef _CRT_NONSTDC_NO_DEPRECATE
  60 #define _CRT_NONSTDC_NO_DEPRECATE
  61 #endif
  62 #endif
  63 #ifndef strcasecmp
  64 #define strcasecmp(s1, s2) _stricmp(s1, s2)
  65 #endif
  66 #ifndef strncasecmp
  67 #define strncasecmp(s1, s2, n) _strnicmp(s1, s2, n)
  68 #endif
  69 #ifndef snprintf
  70 #define snprintf _snprintf
  71 #endif
  72 #ifndef S_IRUSR
  73 #define S_IRUSR _S_IREAD
  74 #endif
  75 #ifndef S_IWUSR
  76 #define S_IWUSR _S_IWRITE
  77 #endif
  78 #undef HAVE_STRINGS_H
  79 #undef HAVE_SYS_SOCKET_H
  80 /* disable warning for zero length array in a struct */
  81 /* this will cause errors on c99 and ansi compliant compilers and will need to be fixed in the wanpipe header files */
  82 #pragma warning(disable:4706)
  83 #pragma comment(lib, "Winmm")
  84 #endif
  85 
  86 #define FTDM_THREAD_STACKSIZE 240 * 1024
  87 #define FTDM_ENUM_NAMES(_NAME, _STRINGS) static const char * _NAME [] = { _STRINGS , NULL };
  88         
  89 #define ftdm_true(expr)                                                 \
  90         (expr && ( !strcasecmp(expr, "yes") ||          \
  91                            !strcasecmp(expr, "on") ||           \
  92                            !strcasecmp(expr, "true") ||         \
  93                            !strcasecmp(expr, "enabled") ||      \
  94                            !strcasecmp(expr, "active") ||       \
  95                            atoi(expr))) ? 1 : 0
  96 
  97 
  98 
  99 #include <time.h>
 100 #ifndef __WINDOWS__
 101 #include <sys/time.h>
 102 #endif
 103 
 104 #include <stdio.h>
 105 #include <stdlib.h>
 106 #include <string.h>
 107 #ifdef HAVE_STRINGS_H
 108 #include <strings.h>
 109 #endif
 110 #include <assert.h>
 111 
 112 #include "ftdm_types.h"
 113 #include "hashtable.h"
 114 #include "ftdm_config.h"
 115 #include "g711.h"
 116 #include "libteletone.h"
 117 #include "ftdm_buffer.h"
 118 #include "ftdm_threadmutex.h"
 119 #include "ftdm_sched.h"
 120 #include "ftdm_call_utils.h"
 121 
 122 #ifdef __cplusplus
 123 extern "C" {
 124 #endif
 125 
 126 #define GOTO_STATUS(label,st) status = st; goto label ;
 127 
 128 #define ftdm_copy_string(x,y,z) strncpy(x, y, z - 1) 
 129 #define ftdm_set_string(x,y) strncpy(x, y, sizeof(x)-1) 
 130 #define ftdm_strlen_zero(s) (!s || *s == '\0')
 131 #define ftdm_strlen_zero_buf(s) (*s == '\0')
 132 
 133 
 134 #define ftdm_channel_test_feature(obj, flag) ((obj)->features & flag)
 135 #define ftdm_channel_set_feature(obj, flag) (obj)->features |= (flag)
 136 #define ftdm_channel_clear_feature(obj, flag) (obj)->features &= ~(flag)
 137 #define ftdm_channel_set_member_locked(obj, _m, _v) ftdm_mutex_lock(obj->mutex); obj->_m = _v; ftdm_mutex_unlock(obj->mutex)
 138 
 139 /*!
 140   \brief Test for the existance of a flag on an arbitary object
 141   \command obj the object to test
 142   \command flag the or'd list of flags to test
 143   \return true value if the object has the flags defined
 144 */
 145 #define ftdm_test_flag(obj, flag) ((obj)->flags & flag)
 146 /*!< Physical (IO) module specific flags */
 147 #define ftdm_test_pflag(obj, flag) ((obj)->pflags & flag)
 148 /*!< signaling module specific flags */
 149 #define ftdm_test_sflag(obj, flag) ((obj)->sflags & flag)
 150 
 151 #define ftdm_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag)
 152 #define ftdm_clear_alarm_flag(obj, flag) (obj)->alarm_flags &= ~(flag)
 153 #define ftdm_test_alarm_flag(obj, flag) ((obj)->alarm_flags & flag)
 154 
 155 /*!
 156   \brief Set a flag on an arbitrary object
 157   \command obj the object to set the flags on
 158   \command flag the or'd list of flags to set
 159 */
 160 #define ftdm_set_flag(obj, flag) (obj)->flags |= (flag)
 161 #define ftdm_set_flag_locked(obj, flag) assert(obj->mutex != NULL);     \
 162         ftdm_mutex_lock(obj->mutex);                                                                            \
 163         (obj)->flags |= (flag);                                                 \
 164         ftdm_mutex_unlock(obj->mutex);
 165 
 166 #define ftdm_set_pflag(obj, flag) (obj)->pflags |= (flag)
 167 #define ftdm_set_pflag_locked(obj, flag) assert(obj->mutex != NULL);    \
 168         ftdm_mutex_lock(obj->mutex);                                                                            \
 169         (obj)->pflags |= (flag);                                                                                        \
 170         ftdm_mutex_unlock(obj->mutex);
 171 
 172 #define ftdm_set_sflag(obj, flag) (obj)->sflags |= (flag)
 173 #define ftdm_set_sflag_locked(obj, flag) assert(obj->mutex != NULL);    \
 174         ftdm_mutex_lock(obj->mutex);                                                                            \
 175         (obj)->sflags |= (flag);                                                                                        \
 176         ftdm_mutex_unlock(obj->mutex);
 177 
 178 /*!
 179   \brief Clear a flag on an arbitrary object while locked
 180   \command obj the object to test
 181   \command flag the or'd list of flags to clear
 182 */
 183 #define ftdm_clear_flag(obj, flag) (obj)->flags &= ~(flag)
 184 
 185 #define ftdm_clear_flag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->flags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
 186 
 187 #define ftdm_clear_pflag(obj, flag) (obj)->pflags &= ~(flag)
 188 
 189 #define ftdm_clear_pflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->pflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
 190 
 191 #define ftdm_clear_sflag(obj, flag) (obj)->sflags &= ~(flag)
 192 
 193 #define ftdm_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
 194 
 195 #ifdef _MSC_VER
 196 /* The while(0) below throws a conditional expression is constant warning */
 197 #pragma warning(disable:4127) 
 198 #endif
 199 
 200 /* this macro assumes obj is locked! */
 201 #define ftdm_wait_for_flag_cleared(obj, flag, time)                                     \
 202         do {                                                                            \
 203                 int __safety = time;                                                    \
 204                 while(__safety-- && ftdm_test_flag(obj, flag)) {                        \
 205                         ftdm_mutex_unlock(obj->mutex);                                  \
 206                         ftdm_sleep(10);                                                 \
 207                         ftdm_mutex_lock(obj->mutex);                                    \
 208                 }                                                                       \
 209                 if(!__safety) {                                                         \
 210                         ftdm_log(FTDM_LOG_CRIT, "flag %d was never cleared\n", flag);   \
 211                 }                                                                       \
 212         } while(0);
 213 
 214 #define ftdm_is_dtmf(key)  ((key > 47 && key < 58) || (key > 64 && key < 69) || (key > 96 && key < 101) || key == 35 || key == 42 || key == 87 || key == 119)
 215 
 216 #define FTDM_SPAN_IS_BRI(x)     ((x)->trunk_type == FTDM_TRUNK_BRI || (x)->trunk_type == FTDM_TRUNK_BRI_PTMP)
 217 /*!
 218   \brief Copy flags from one arbitrary object to another
 219   \command dest the object to copy the flags to
 220   \command src the object to copy the flags from
 221   \command flags the flags to copy
 222 */
 223 #define ftdm_copy_flags(dest, src, flags) (dest)->flags &= ~(flags);    (dest)->flags |= ((src)->flags & (flags))
 224 
 225 struct ftdm_stream_handle {
 226         ftdm_stream_handle_write_function_t write_function;
 227         ftdm_stream_handle_raw_write_function_t raw_write_function;
 228         void *data;
 229         void *end;
 230         ftdm_size_t data_size;
 231         ftdm_size_t data_len;
 232         ftdm_size_t alloc_len;
 233         ftdm_size_t alloc_chunk;
 234 };
 235 
 236 FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_raw_write(ftdm_stream_handle_t *handle, uint8_t *data, ftdm_size_t datalen);
 237 FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_write(ftdm_stream_handle_t *handle, const char *fmt, ...);
 238 
 239 #define FTDM_CMD_CHUNK_LEN 1024
 240 #define FTDM_STANDARD_STREAM(s) memset(&s, 0, sizeof(s)); s.data = ftdm_malloc(FTDM_CMD_CHUNK_LEN); \
 241         assert(s.data);                                                                                                         \
 242         memset(s.data, 0, FTDM_CMD_CHUNK_LEN);                                                          \
 243         s.end = s.data;                                                                                                         \
 244         s.data_size = FTDM_CMD_CHUNK_LEN;                                                                       \
 245         s.write_function = ftdm_console_stream_write;                                           \
 246         s.raw_write_function = ftdm_console_stream_raw_write;                           \
 247         s.alloc_len = FTDM_CMD_CHUNK_LEN;                                                                       \
 248         s.alloc_chunk = FTDM_CMD_CHUNK_LEN
 249 
 250 /*! brief create a new queue */
 251 #define ftdm_queue_create(queue, capacity) g_ftdm_queue_handler.create(queue, capacity)
 252 
 253 /*! Enqueue an object */
 254 #define ftdm_queue_enqueue(queue, obj) g_ftdm_queue_handler.enqueue(queue, obj)
 255 
 256 /*! dequeue an object from the queue */
 257 #define ftdm_queue_dequeue(queue) g_ftdm_queue_handler.dequeue(queue)
 258 
 259 /*! wait ms milliseconds for a queue to have available objects, -1 to wait forever */
 260 #define ftdm_queue_wait(queue, ms) g_ftdm_queue_handler.wait(queue, ms)
 261 
 262 /*! get the internal interrupt object (to wait for elements to be added from the outside bypassing ftdm_queue_wait) */
 263 #define ftdm_queue_get_interrupt(queue, ms) g_ftdm_queue_handler.get_interrupt(queue, ms)
 264 
 265 /*! destroy the queue */ 
 266 #define ftdm_queue_destroy(queue) g_ftdm_queue_handler.destroy(queue)
 267 
 268 FT_DECLARE_DATA extern ftdm_queue_handler_t g_ftdm_queue_handler;
 269 
 270 #define FTDM_TOKEN_STRLEN 128
 271 #define FTDM_MAX_TOKENS 10
 272 
 273 static __inline__ char *ftdm_clean_string(char *s)
 274 {
 275         char *p;
 276 
 277         for (p = s; p && *p; p++) {
 278                 uint8_t x = (uint8_t) *p;
 279                 if (x < 32 || x > 127) {
 280                         *p = ' ';
 281                 }
 282         }
 283 
 284         return s;
 285 }
 286 
 287 struct ftdm_bitstream {
 288         uint8_t *data;
 289         uint32_t datalen;
 290         uint32_t byte_index;
 291         uint8_t bit_index;
 292         int8_t endian;
 293         uint8_t top;
 294         uint8_t bot;
 295         uint8_t ss;
 296         uint8_t ssv;
 297 };
 298 
 299 struct ftdm_fsk_data_state {
 300         dsp_fsk_handle_t *fsk1200_handle;
 301         uint8_t init;
 302         uint8_t *buf;
 303         size_t bufsize;
 304         ftdm_size_t blen;
 305         ftdm_size_t bpos;
 306         ftdm_size_t dlen;
 307         ftdm_size_t ppos;
 308         int checksum;
 309 };
 310 
 311 struct ftdm_fsk_modulator {
 312         teletone_dds_state_t dds;
 313         ftdm_bitstream_t bs;
 314         uint32_t carrier_bits_start;
 315         uint32_t carrier_bits_stop;
 316         uint32_t chan_sieze_bits;
 317         uint32_t bit_factor;
 318         uint32_t bit_accum;
 319         uint32_t sample_counter;
 320         int32_t samples_per_bit;
 321         int32_t est_bytes;
 322         fsk_modem_types_t modem_type;
 323         ftdm_fsk_data_state_t *fsk_data;
 324         ftdm_fsk_write_sample_t write_sample_callback;
 325         void *user_data;
 326         int16_t sample_buffer[64];
 327 };
 328 
 329 
 330 typedef enum {
 331         FTDM_TYPE_NONE,
 332         FTDM_TYPE_SPAN = 0xFF,
 333         FTDM_TYPE_CHANNEL
 334 } ftdm_data_type_t;
 335 
 336 /* number of bytes for the IO dump circular buffer (5 seconds worth of audio by default) */
 337 #define FTDM_IO_DUMP_DEFAULT_BUFF_SIZE 8 * 5000
 338 typedef struct {
 339         char *buffer;
 340         ftdm_size_t size;
 341         int windex;
 342         int wrapped;
 343 } ftdm_io_dump_t;
 344 
 345 /* number of interval cycles before timeout and close the debug dtmf file (5 seconds if interval is 20) */
 346 #define DTMF_DEBUG_TIMEOUT 250
 347 typedef struct {
 348         uint8_t enabled;
 349         uint8_t requested;
 350         FILE *file;
 351         int32_t closetimeout;
 352         ftdm_mutex_t *mutex;
 353 } ftdm_dtmf_debug_t;
 354 
 355 typedef enum {
 356         FTDM_IOSTATS_ERROR_CRC          = (1 << 0),
 357         FTDM_IOSTATS_ERROR_FRAME        = (1 << 1),
 358         FTDM_IOSTATS_ERROR_ABORT        = (1 << 2),
 359         FTDM_IOSTATS_ERROR_FIFO         = (1 << 3),
 360         FTDM_IOSTATS_ERROR_DMA          = (1 << 4),
 361         FTDM_IOSTATS_ERROR_QUEUE_THRES  = (1 << 5), /* Queue reached high threshold */
 362         FTDM_IOSTATS_ERROR_QUEUE_FULL   = (1 << 6), /* Queue is full */
 363 } ftdm_iostats_error_type_t;
 364 
 365 typedef struct {
 366         struct {
 367                 uint32_t errors;
 368                 uint16_t flags;
 369                 uint8_t  queue_size;    /* max queue size configured */
 370                 uint8_t  queue_len;     /* Current number of elements in queue */
 371                 uint64_t packets;
 372         } rx;
 373 
 374         struct {
 375                 uint32_t errors;
 376                 uint16_t flags;
 377                 uint8_t  idle_packets;
 378                 uint8_t  queue_size;    /* max queue size configured */
 379                 uint8_t  queue_len;     /* Current number of elements in queue */
 380                 uint64_t packets;
 381         } tx;
 382 } ftdm_channel_iostats_t;
 383 
 384 /* 2^8 table size, one for each byte (sample) value */
 385 #define FTDM_GAINS_TABLE_SIZE 256
 386 struct ftdm_channel {
 387         ftdm_data_type_t data_type;
 388         uint32_t span_id;
 389         uint32_t chan_id;
 390         uint32_t physical_span_id;
 391         uint32_t physical_chan_id;
 392         uint32_t rate;
 393         uint32_t extra_id;
 394         ftdm_chan_type_t type;
 395         ftdm_socket_t sockfd;
 396         uint64_t flags;
 397         uint32_t pflags;
 398         uint32_t sflags;
 399         ftdm_alarm_flag_t alarm_flags;
 400         ftdm_channel_feature_t features;
 401         ftdm_codec_t effective_codec;
 402         ftdm_codec_t native_codec;
 403         uint32_t effective_interval;
 404         uint32_t native_interval;
 405         uint32_t packet_len;
 406         ftdm_channel_state_t state;
 407         ftdm_state_status_t state_status;
 408         ftdm_channel_state_t last_state;
 409         ftdm_channel_state_t init_state;
 410         ftdm_channel_indication_t indication;
 411         ftdm_state_history_entry_t history[10];
 412         uint8_t hindex;
 413         ftdm_mutex_t *mutex;
 414         teletone_dtmf_detect_state_t dtmf_detect;
 415         uint32_t buffer_delay;
 416         ftdm_event_t event_header;
 417         char last_error[256];
 418         fio_event_cb_t event_callback;
 419         uint32_t skip_read_frames;
 420         ftdm_buffer_t *dtmf_buffer;
 421         ftdm_buffer_t *gen_dtmf_buffer;
 422         ftdm_buffer_t *pre_buffer;
 423         ftdm_buffer_t *digit_buffer;
 424         ftdm_buffer_t *fsk_buffer;
 425         ftdm_mutex_t *pre_buffer_mutex;
 426         uint32_t dtmf_on;
 427         uint32_t dtmf_off;
 428         char *dtmf_hangup_buf;
 429         teletone_generation_session_t tone_session;
 430         ftdm_time_t last_event_time;
 431         ftdm_time_t ring_time;
 432         char tokens[FTDM_MAX_TOKENS+1][FTDM_TOKEN_STRLEN];
 433         uint8_t needed_tones[FTDM_TONEMAP_INVALID];
 434         uint8_t detected_tones[FTDM_TONEMAP_INVALID];
 435         ftdm_tonemap_t last_detected_tone;      
 436         uint32_t token_count;
 437         char chan_name[128];
 438         char chan_number[32];
 439         ftdm_filehandle_t fds[2];
 440         ftdm_fsk_data_state_t fsk;
 441         uint8_t fsk_buf[80];
 442         uint32_t ring_count;
 443         ftdm_polarity_t polarity;
 444         /* Private I/O data. Do not touch unless you are an I/O module */
 445         void *io_data;
 446         /* Private signaling data. Do not touch unless you are a signaling module */
 447         void *call_data;
 448         struct ftdm_caller_data caller_data;
 449         struct ftdm_span *span;
 450         struct ftdm_io_interface *fio;
 451         ftdm_hash_t *variable_hash;
 452         unsigned char rx_cas_bits;
 453         uint32_t pre_buffer_size;
 454         uint8_t rxgain_table[FTDM_GAINS_TABLE_SIZE];
 455         uint8_t txgain_table[FTDM_GAINS_TABLE_SIZE];
 456         float rxgain;
 457         float txgain;
 458         int availability_rate;
 459         void *user_private;
 460         ftdm_timer_id_t hangup_timer;
 461         ftdm_channel_iostats_t iostats;
 462         ftdm_dtmf_debug_t dtmfdbg;
 463         ftdm_io_dump_t rxdump;
 464         ftdm_io_dump_t txdump;
 465         ftdm_interrupt_t *state_completed_interrupt; /*!< Notify when a state change is completed */
 466         int32_t txdrops;
 467         int32_t rxdrops;
 468 };
 469 
 470 struct ftdm_span {
 471         ftdm_data_type_t data_type;
 472         char *name;
 473         uint32_t span_id;
 474         uint32_t chan_count;
 475         ftdm_span_flag_t flags;
 476         struct ftdm_io_interface *fio;
 477         fio_event_cb_t event_callback;
 478         ftdm_mutex_t *mutex;
 479         ftdm_trunk_type_t trunk_type;
 480         ftdm_analog_start_type_t start_type;
 481         ftdm_signal_type_t signal_type;
 482         uint32_t last_used_index;
 483         /* Private signaling data. Do not touch unless you are a signaling module */
 484         void *signal_data;
 485         fio_signal_cb_t signal_cb;
 486         ftdm_event_t event_header;
 487         char last_error[256];
 488         char tone_map[FTDM_TONEMAP_INVALID+1][FTDM_TONEMAP_LEN];
 489         teletone_tone_map_t tone_detect_map[FTDM_TONEMAP_INVALID+1];
 490         teletone_multi_tone_t tone_finder[FTDM_TONEMAP_INVALID+1];
 491         ftdm_channel_t *channels[FTDM_MAX_CHANNELS_SPAN+1];
 492         fio_channel_outgoing_call_t outgoing_call;
 493         fio_channel_send_msg_t send_msg;
 494         fio_channel_set_sig_status_t set_channel_sig_status;
 495         fio_channel_get_sig_status_t get_channel_sig_status;
 496         fio_span_set_sig_status_t set_span_sig_status;
 497         fio_span_get_sig_status_t get_span_sig_status;
 498         fio_channel_request_t channel_request;
 499         ftdm_span_start_t start;
 500         ftdm_span_stop_t stop;
 501         ftdm_channel_sig_read_t sig_read;
 502         ftdm_channel_sig_write_t sig_write;
 503         ftdm_channel_state_processor_t state_processor; /*!< This guy is called whenever state processing is required */
 504         void *io_data; /*!< Private I/O data per span. Do not touch unless you are an I/O module */
 505         char *type;
 506         char *dtmf_hangup;
 507         size_t dtmf_hangup_len;
 508         ftdm_state_map_t *state_map;
 509         ftdm_caller_data_t default_caller_data;
 510         ftdm_queue_t *pendingchans; /*!< Channels pending of state processing */
 511         ftdm_queue_t *pendingsignals; /*!< Signals pending from being delivered to the user */
 512         struct ftdm_span *next;
 513 };
 514 
 515 struct ftdm_group {
 516         char *name;
 517         uint32_t group_id;
 518         uint32_t chan_count;
 519         ftdm_channel_t *channels[FTDM_MAX_CHANNELS_GROUP];
 520         uint32_t last_used_index;
 521         ftdm_mutex_t *mutex;
 522         struct ftdm_group *next;
 523 };
 524 
 525 FT_DECLARE_DATA extern ftdm_crash_policy_t g_ftdm_crash_policy;
 526 
 527 FT_DECLARE(ftdm_size_t) ftdm_fsk_modulator_generate_bit(ftdm_fsk_modulator_t *fsk_trans, int8_t bit, int16_t *buf, ftdm_size_t buflen);
 528 FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits);
 529 FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans);
 530 FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans);
 531 #define ftdm_fsk_modulator_send_all(_it) ftdm_fsk_modulator_generate_chan_sieze(_it); \
 532         ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_start); \
 533         ftdm_fsk_modulator_send_data(_it); \
 534         ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_stop)
 535 
 536 FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans,
 537                                                                         fsk_modem_types_t modem_type,
 538                                                                         uint32_t sample_rate,
 539                                                                         ftdm_fsk_data_state_t *fsk_data,
 540                                                                         float db_level,
 541                                                                         uint32_t carrier_bits_start,
 542                                                                         uint32_t carrier_bits_stop,
 543                                                                         uint32_t chan_sieze_bits,
 544                                                                         ftdm_fsk_write_sample_t write_sample_callback,
 545                                                                         void *user_data);
 546 FT_DECLARE(int8_t) ftdm_bitstream_get_bit(ftdm_bitstream_t *bsp);
 547 FT_DECLARE(void) ftdm_bitstream_init(ftdm_bitstream_t *bsp, uint8_t *data, uint32_t datalen, ftdm_endian_t endian, uint8_t ss);
 548 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_parse(ftdm_fsk_data_state_t *state, ftdm_size_t *type, char **data, ftdm_size_t *len);
 549 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, size_t samples);
 550 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state);
 551 FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize);
 552 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen);
 553 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_mdmf(ftdm_fsk_data_state_t *state, ftdm_mdmf_type_t type, const uint8_t *data, uint32_t datalen);
 554 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state);
 555 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number);
 556 FT_DECLARE(ftdm_status_t) ftdm_channel_send_fsk_data(ftdm_channel_t *ftdmchan, ftdm_fsk_data_state_t *fsk_data, float db_level);
 557 
 558 FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname);
 559 
 560 FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan);
 561 
 562 FT_DECLARE(void) ftdm_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor);
 563 
 564 FT_DECLARE(uint32_t) ftdm_separate_string(char *buf, char delim, char **array, int arraylen);
 565 FT_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss);
 566 FT_DECLARE(void) print_hex_bytes(uint8_t *data, ftdm_size_t dlen, char *buf, ftdm_size_t blen);
 567 
 568 FT_DECLARE_NONSTD(int) ftdm_hash_equalkeys(void *k1, void *k2);
 569 FT_DECLARE_NONSTD(uint32_t) ftdm_hash_hashfromstring(void *ky);
 570 
 571 FT_DECLARE(int) ftdm_load_modules(void);
 572 
 573 FT_DECLARE(ftdm_status_t) ftdm_unload_modules(void);
 574 
 575 FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t *sigmsg);
 576 
 577 FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan);
 578 FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan);
 579 
 580 FT_DECLARE(int) ftdm_load_module(const char *name);
 581 FT_DECLARE(int) ftdm_load_module_assume(const char *name);
 582 FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap);
 583 
 584 FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
 585 FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
 586 FT_DECLARE(void) ftdm_ack_indication(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_status_t status);
 587 
 588 /*! 
 589  * \brief Retrieves an event from the span
 590  *
 591  * \note
 592  *      This function is non-reentrant and not thread-safe. 
 593  *      The event returned may be modified if the function is called again 
 594  *      from a different thread or even the same. It is recommended to
 595  *      handle events from the same span in a single thread.
 596  *      WARNING: this function used to be public ( in freetdm.h )
 597  *      but since is really of no use to users better keep it here
 598  *
 599  * \param span The span to retrieve the event from
 600  * \param event Pointer to store the pointer to the event
 601  *
 602  * \retval FTDM_SUCCESS success (at least one event available)
 603  * \retval FTDM_TIMEOUT Timed out waiting for events
 604  * \retval FTDM_FAIL failure
 605  */
 606 FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event);
 607 
 608 /*! 
 609  * \brief Enqueue a DTMF string into the channel
 610  *
 611  * \param ftdmchan The channel to enqueue the dtmf string to
 612  * \param dtmf null-terminated DTMF string
 613  *
 614  * \retval FTDM_SUCCESS success
 615  * \retval FTDM_FAIL failure
 616  */
 617 FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf);
 618 
 619 /* dequeue pending signals and notify the user via the span signal callback */
 620 FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span);
 621 
 622 /*! \brief clear the tone detector state */
 623 FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
 624 
 625 
 626 /*!
 627   \brief Assert condition
 628 */
 629 #define ftdm_assert(assertion, msg) \
 630         if (!(assertion)) { \
 631                 ftdm_log(FTDM_LOG_CRIT, msg); \
 632                 if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
 633                         ftdm_abort();  \
 634                 } \
 635         }
 636 
 637 /*!
 638   \brief Assert condition and return
 639 */
 640 #define ftdm_assert_return(assertion, retval, msg) \
 641         if (!(assertion)) { \
 642                 ftdm_log(FTDM_LOG_CRIT, msg); \
 643                 if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
 644                         ftdm_abort();  \
 645                 } else { \
 646                         return retval; \
 647                 } \
 648         }
 649 
 650 /*!
 651   \brief Socket the given socket
 652   \command it the socket
 653 */
 654 #define ftdm_socket_close(it) if (it > -1) { close(it); it = -1;}
 655 
 656 #define ftdm_channel_lock(chan) ftdm_mutex_lock(chan->mutex)
 657 #define ftdm_channel_unlock(chan) ftdm_mutex_unlock(chan->mutex)
 658 
 659 #define ftdm_log_throttle(level, ...) \
 660         time_current_throttle_log = ftdm_current_time_in_ms(); \
 661         if (time_current_throttle_log - time_last_throttle_log > FTDM_THROTTLE_LOG_INTERVAL) {\
 662                 ftdm_log(level, __VA_ARGS__); \
 663                 time_last_throttle_log = time_current_throttle_log; \
 664         } 
 665 
 666 #define ftdm_log_chan_ex(fchan, file, func, line, level, format, ...) ftdm_log(file, func, line, level, "[s%dc%d][%d:%d] " format, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id, __VA_ARGS__)
 667 #define ftdm_log_chan(fchan, level, format, ...) ftdm_log(level, "[s%dc%d][%d:%d] " format, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id, __VA_ARGS__)
 668 #define ftdm_log_chan_msg(fchan, level, msg) ftdm_log(level, "[s%dc%d][%d:%d] " msg, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id)
 669 
 670 #define ftdm_log_chan_throttle(fchan, level, format, ...) ftdm_log_throttle(level, "[s%dc%d][%d:%d] " format, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id, __VA_ARGS__)
 671 #define ftdm_log_chan_msg_throttle(fchan, level, format, ...) ftdm_log_throttle(level, "[s%dc%d][%d:%d] " format, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id, __VA_ARGS__)
 672 
 673 #define ftdm_span_lock(span) ftdm_mutex_lock(span->mutex)
 674 #define ftdm_span_unlock(span) ftdm_mutex_unlock(span->mutex)
 675 
 676 FT_DECLARE_DATA extern const char *FTDM_LEVEL_NAMES[9];
 677 
 678 static __inline__ void ftdm_abort(void)
 679 {
 680 #ifdef __cplusplus
 681         ::abort();
 682 #else
 683         abort();
 684 #endif
 685 }
 686 
 687 static __inline__ int16_t ftdm_saturated_add(int16_t sample1, int16_t sample2)
 688 {
 689         int addres;
 690 
 691         addres = sample1 + sample2;
 692         if (addres > 32767)
 693                 addres = 32767;
 694         else if (addres < -32767)
 695                 addres = -32767;
 696         return (int16_t)addres;
 697 }
 698 
 699 #ifdef __cplusplus
 700 }
 701 #endif
 702 
 703 #endif /* endif __PRIVATE_FTDM_CORE__ */

/* [<][>][^][v][top][bottom][index][help] */