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))) ? FTDM_TRUE : FTDM_FALSE
96
97 #ifdef WIN32_LEAN_AND_MEAN
98 #include <winsock2.h>
99 #include <mmsystem.h>
100 #endif
101
102 #include <time.h>
103 #ifndef __WINDOWS__
104 #include <sys/time.h>
105 #endif
106
107 #include <stdio.h>
108 #include <stdlib.h>
109 #include <string.h>
110 #ifdef HAVE_STRINGS_H
111 #include <strings.h>
112 #endif
113 #include <assert.h>
114
115 #include "ftdm_types.h"
116 #include "hashtable.h"
117 #include "ftdm_config.h"
118 #include "g711.h"
119 #include "libteletone.h"
120 #include "ftdm_buffer.h"
121 #include "ftdm_threadmutex.h"
122 #include "ftdm_sched.h"
123 #include "ftdm_call_utils.h"
124
125 #ifdef __cplusplus
126 extern "C" {
127 #endif
128
129 #define SPAN_PENDING_CHANS_QUEUE_SIZE 1000
130 #define SPAN_PENDING_SIGNALS_QUEUE_SIZE 1000
131
132 #define GOTO_STATUS(label,st) status = st; goto label ;
133
134 #define ftdm_copy_string(x,y,z) strncpy(x, y, z - 1)
135 #define ftdm_set_string(x,y) strncpy(x, y, sizeof(x)-1)
136 #define ftdm_strlen_zero(s) (!s || *s == '\0')
137 #define ftdm_strlen_zero_buf(s) (*s == '\0')
138
139
140 #define ftdm_channel_test_feature(obj, flag) ((obj)->features & flag)
141 #define ftdm_channel_set_feature(obj, flag) (obj)->features = (ftdm_channel_feature_t)((obj)->features | flag)
142 #define ftdm_channel_clear_feature(obj, flag) (obj)->features = (ftdm_channel_feature_t)((obj)->features & ( ~(flag) ))
143 #define ftdm_channel_set_member_locked(obj, _m, _v) ftdm_mutex_lock(obj->mutex); obj->_m = _v; ftdm_mutex_unlock(obj->mutex)
144
145 /*!
146 \brief Test for the existance of a flag on an arbitary object
147 \command obj the object to test
148 \command flag the or'd list of flags to test
149 \return true value if the object has the flags defined
150 */
151 #define ftdm_test_flag(obj, flag) ((obj)->flags & flag)
152 /*!< Physical (IO) module specific flags */
153 #define ftdm_test_pflag(obj, flag) ((obj)->pflags & flag)
154 /*!< signaling module specific flags */
155 #define ftdm_test_sflag(obj, flag) ((obj)->sflags & flag)
156
157 #define ftdm_set_alarm_flag(obj, flag) (obj)->alarm_flags |= (flag)
158 #define ftdm_clear_alarm_flag(obj, flag) (obj)->alarm_flags &= ~(flag)
159 #define ftdm_test_alarm_flag(obj, flag) ((obj)->alarm_flags & flag)
160
161 #define ftdm_set_io_flag(obj, flag) (obj)->io_flags |= (flag)
162 #define ftdm_clear_io_flag(obj, flag) (obj)->io_flags &= ~(flag)
163 #define ftdm_test_io_flag(obj, flag) ((obj)->io_flags & flag)
164
165 /*!
166 \brief Set a flag on an arbitrary object
167 \command obj the object to set the flags on
168 \command flag the or'd list of flags to set
169 */
170 #define ftdm_set_flag(obj, flag) (obj)->flags |= (flag)
171 #define ftdm_set_flag_locked(obj, flag) assert(obj->mutex != NULL); \
172 ftdm_mutex_lock(obj->mutex); \
173 (obj)->flags |= (flag); \
174 ftdm_mutex_unlock(obj->mutex);
175
176 #define ftdm_set_pflag(obj, flag) (obj)->pflags |= (flag)
177 #define ftdm_set_pflag_locked(obj, flag) assert(obj->mutex != NULL); \
178 ftdm_mutex_lock(obj->mutex); \
179 (obj)->pflags |= (flag); \
180 ftdm_mutex_unlock(obj->mutex);
181
182 #define ftdm_set_sflag(obj, flag) (obj)->sflags |= (flag)
183 #define ftdm_set_sflag_locked(obj, flag) assert(obj->mutex != NULL); \
184 ftdm_mutex_lock(obj->mutex); \
185 (obj)->sflags |= (flag); \
186 ftdm_mutex_unlock(obj->mutex);
187
188 /*!
189 \brief Clear a flag on an arbitrary object while locked
190 \command obj the object to test
191 \command flag the or'd list of flags to clear
192 */
193 #define ftdm_clear_flag(obj, flag) (obj)->flags &= ~(flag)
194
195 #define ftdm_clear_flag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->flags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
196
197 #define ftdm_clear_pflag(obj, flag) (obj)->pflags &= ~(flag)
198
199 #define ftdm_clear_pflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->pflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
200
201 #define ftdm_clear_sflag(obj, flag) (obj)->sflags &= ~(flag)
202
203 #define ftdm_clear_sflag_locked(obj, flag) assert(obj->mutex != NULL); ftdm_mutex_lock(obj->mutex); (obj)->sflags &= ~(flag); ftdm_mutex_unlock(obj->mutex);
204
205 #ifdef _MSC_VER
206 /* The while(0) below throws a conditional expression is constant warning */
207 #pragma warning(disable:4127)
208 #endif
209
210 /* this macro assumes obj is locked! */
211 #define ftdm_wait_for_flag_cleared(obj, flag, time) \
212 do { \
213 int __safety = time; \
214 while(__safety-- && ftdm_test_flag(obj, flag)) { \
215 ftdm_mutex_unlock(obj->mutex); \
216 ftdm_sleep(10); \
217 ftdm_mutex_lock(obj->mutex); \
218 } \
219 if(!__safety) { \
220 ftdm_log(FTDM_LOG_CRIT, "flag %"FTDM_UINT64_FMT" was never cleared\n", (uint64_t)flag); \
221 } \
222 } while(0);
223
224 #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)
225
226 #ifdef __linux__
227 #define ftdm_print_stack(level) \
228 do { \
229 void *__stacktrace[100] = { 0 }; \
230 char **__symbols = NULL; \
231 int __size = 0; \
232 int __i = 0; \
233 __size = backtrace(__stacktrace, ftdm_array_len(__stacktrace)); \
234 __symbols = backtrace_symbols(__stacktrace, __size); \
235 if (__symbols) { \
236 for (__i = 0; __i < __size; __i++) { \
237 ftdm_log(__level, "%s\n", __symbols[i]); \
238 } \
239 free(__symbols); \
240 } \
241 } while (0);
242 #else
243 #define ftdm_print_stack(level) ftdm_log(level, "FTDM_PRINT_STACK is not implemented in this operating system!\n");
244 #endif
245
246
247 #define FTDM_SPAN_IS_BRI(x) ((x)->trunk_type == FTDM_TRUNK_BRI || (x)->trunk_type == FTDM_TRUNK_BRI_PTMP)
248 /*!
249 \brief Copy flags from one arbitrary object to another
250 \command dest the object to copy the flags to
251 \command src the object to copy the flags from
252 \command flags the flags to copy
253 */
254 #define ftdm_copy_flags(dest, src, flags) (dest)->flags &= ~(flags); (dest)->flags |= ((src)->flags & (flags))
255
256 struct ftdm_stream_handle {
257 ftdm_stream_handle_write_function_t write_function;
258 ftdm_stream_handle_raw_write_function_t raw_write_function;
259 void *data;
260 void *end;
261 ftdm_size_t data_size;
262 ftdm_size_t data_len;
263 ftdm_size_t alloc_len;
264 ftdm_size_t alloc_chunk;
265 };
266
267 FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_raw_write(ftdm_stream_handle_t *handle, uint8_t *data, ftdm_size_t datalen);
268 FT_DECLARE_NONSTD(ftdm_status_t) ftdm_console_stream_write(ftdm_stream_handle_t *handle, const char *fmt, ...);
269
270 #define FTDM_CMD_CHUNK_LEN 1024
271 #define FTDM_STANDARD_STREAM(s) memset(&s, 0, sizeof(s)); s.data = ftdm_malloc(FTDM_CMD_CHUNK_LEN); \
272 assert(s.data); \
273 memset(s.data, 0, FTDM_CMD_CHUNK_LEN); \
274 s.end = s.data; \
275 s.data_size = FTDM_CMD_CHUNK_LEN; \
276 s.write_function = ftdm_console_stream_write; \
277 s.raw_write_function = ftdm_console_stream_raw_write; \
278 s.alloc_len = FTDM_CMD_CHUNK_LEN; \
279 s.alloc_chunk = FTDM_CMD_CHUNK_LEN
280
281 /*! brief create a new queue */
282 #define ftdm_queue_create(queue, capacity) g_ftdm_queue_handler.create(queue, capacity)
283
284 /*! Enqueue an object */
285 #define ftdm_queue_enqueue(queue, obj) g_ftdm_queue_handler.enqueue(queue, obj)
286
287 /*! dequeue an object from the queue */
288 #define ftdm_queue_dequeue(queue) g_ftdm_queue_handler.dequeue(queue)
289
290 /*! wait ms milliseconds for a queue to have available objects, -1 to wait forever */
291 #define ftdm_queue_wait(queue, ms) g_ftdm_queue_handler.wait(queue, ms)
292
293 /*! get the internal interrupt object (to wait for elements to be added from the outside bypassing ftdm_queue_wait) */
294 #define ftdm_queue_get_interrupt(queue, ms) g_ftdm_queue_handler.get_interrupt(queue, ms)
295
296 /*! destroy the queue */
297 #define ftdm_queue_destroy(queue) g_ftdm_queue_handler.destroy(queue)
298
299 FT_DECLARE_DATA extern ftdm_queue_handler_t g_ftdm_queue_handler;
300
301 #define FTDM_TOKEN_STRLEN 128
302 #define FTDM_MAX_TOKENS 10
303
ftdm_clean_string(char * s)304 static __inline__ char *ftdm_clean_string(char *s)
305 {
306 char *p;
307
308 for (p = s; p && *p; p++) {
309 uint8_t x = (uint8_t) *p;
310 if (x < 32 || x > 127) {
311 *p = ' ';
312 }
313 }
314
315 return s;
316 }
317
318 struct ftdm_bitstream {
319 uint8_t *data;
320 uint32_t datalen;
321 uint32_t byte_index;
322 uint8_t bit_index;
323 int8_t endian;
324 uint8_t top;
325 uint8_t bot;
326 uint8_t ss;
327 uint8_t ssv;
328 };
329
330 struct ftdm_fsk_data_state {
331 dsp_fsk_handle_t *fsk1200_handle;
332 uint8_t init;
333 uint8_t *buf;
334 size_t bufsize;
335 ftdm_size_t blen;
336 ftdm_size_t bpos;
337 ftdm_size_t dlen;
338 ftdm_size_t ppos;
339 int checksum;
340 };
341
342 struct ftdm_fsk_modulator {
343 teletone_dds_state_t dds;
344 ftdm_bitstream_t bs;
345 uint32_t carrier_bits_start;
346 uint32_t carrier_bits_stop;
347 uint32_t chan_sieze_bits;
348 uint32_t bit_factor;
349 uint32_t bit_accum;
350 uint32_t sample_counter;
351 int32_t samples_per_bit;
352 int32_t est_bytes;
353 fsk_modem_types_t modem_type;
354 ftdm_fsk_data_state_t *fsk_data;
355 ftdm_fsk_write_sample_t write_sample_callback;
356 void *user_data;
357 int16_t sample_buffer[64];
358 };
359
360
361 typedef enum {
362 FTDM_TYPE_NONE,
363 FTDM_TYPE_SPAN = 0xFF,
364 FTDM_TYPE_CHANNEL
365 } ftdm_data_type_t;
366
367 /* number of bytes for the IO dump circular buffer (5 seconds worth of audio by default) */
368 #define FTDM_IO_DUMP_DEFAULT_BUFF_SIZE 8 * 5000
369 typedef struct {
370 char *buffer;
371 ftdm_size_t size;
372 int windex;
373 int wrapped;
374 } ftdm_io_dump_t;
375
376 /* number of interval cycles before timeout and close the debug dtmf file (5 seconds if interval is 20) */
377 #define DTMF_DEBUG_TIMEOUT 250
378 typedef struct {
379 uint8_t enabled;
380 uint8_t requested;
381 FILE *file;
382 int32_t closetimeout;
383 ftdm_mutex_t *mutex;
384 } ftdm_dtmf_debug_t;
385
386 typedef struct {
387 uint32_t duration_ms;
388 ftdm_time_t start_time;
389 /* If set to 1, we will send DTMF event the the tone starts, instead of waiting for end */
390 uint8_t trigger_on_start;
391 } ftdm_dtmf_detect_t;
392
393 /* 2^8 table size, one for each byte (sample) value */
394 #define FTDM_GAINS_TABLE_SIZE 256
395 struct ftdm_channel {
396 ftdm_data_type_t data_type;
397 uint32_t span_id;
398 uint32_t chan_id;
399 uint32_t physical_span_id;
400 uint32_t physical_chan_id;
401 uint32_t rate;
402 uint32_t extra_id;
403 ftdm_chan_type_t type;
404 ftdm_socket_t sockfd;
405 uint64_t flags;
406 uint32_t pflags;
407 uint32_t sflags;
408 uint8_t io_flags;
409 ftdm_alarm_flag_t alarm_flags;
410 ftdm_channel_feature_t features;
411 ftdm_codec_t effective_codec;
412 ftdm_codec_t native_codec;
413 uint32_t effective_interval;
414 uint32_t native_interval;
415 uint32_t packet_len;
416 ftdm_channel_state_t state;
417 ftdm_state_status_t state_status;
418 ftdm_channel_state_t last_state;
419 ftdm_channel_state_t init_state;
420 ftdm_channel_indication_t indication;
421 ftdm_state_history_entry_t history[10];
422 uint8_t hindex;
423 ftdm_mutex_t *mutex;
424 teletone_dtmf_detect_state_t dtmf_detect;
425 uint32_t buffer_delay;
426 ftdm_event_t event_header;
427 char last_error[256];
428 fio_event_cb_t event_callback;
429 uint32_t skip_read_frames;
430 ftdm_buffer_t *dtmf_buffer;
431 ftdm_buffer_t *gen_dtmf_buffer;
432 ftdm_buffer_t *pre_buffer;
433 ftdm_buffer_t *digit_buffer;
434 ftdm_buffer_t *fsk_buffer;
435 ftdm_mutex_t *pre_buffer_mutex;
436 uint32_t dtmf_on;
437 uint32_t dtmf_off;
438 char *dtmf_hangup_buf;
439 teletone_generation_session_t tone_session;
440 ftdm_time_t last_event_time;
441 ftdm_time_t ring_time;
442 char tokens[FTDM_MAX_TOKENS+1][FTDM_TOKEN_STRLEN];
443 uint8_t needed_tones[FTDM_TONEMAP_INVALID];
444 uint8_t detected_tones[FTDM_TONEMAP_INVALID];
445 ftdm_tonemap_t last_detected_tone;
446 uint32_t token_count;
447 char chan_name[128];
448 char chan_number[32];
449 ftdm_filehandle_t fds[2];
450 ftdm_fsk_data_state_t fsk;
451 uint8_t fsk_buf[80];
452 uint32_t ring_count;
453 ftdm_polarity_t polarity;
454 /* Private I/O data. Do not touch unless you are an I/O module */
455 void *io_data;
456 /* Private signaling data. Do not touch unless you are a signaling module */
457 void *call_data;
458 struct ftdm_caller_data caller_data;
459 struct ftdm_span *span;
460 struct ftdm_io_interface *fio;
461 unsigned char rx_cas_bits;
462 uint32_t pre_buffer_size;
463 uint8_t rxgain_table[FTDM_GAINS_TABLE_SIZE];
464 uint8_t txgain_table[FTDM_GAINS_TABLE_SIZE];
465 float rxgain;
466 float txgain;
467 int availability_rate;
468 void *user_private;
469 ftdm_timer_id_t hangup_timer;
470 ftdm_channel_iostats_t iostats;
471 ftdm_dtmf_debug_t dtmfdbg;
472 ftdm_dtmf_detect_t dtmfdetect;
473 ftdm_io_dump_t rxdump;
474 ftdm_io_dump_t txdump;
475 ftdm_interrupt_t *state_completed_interrupt; /*!< Notify when a state change is completed */
476 int32_t txdrops;
477 int32_t rxdrops;
478 ftdm_usrmsg_t *usrmsg;
479 ftdm_time_t last_state_change_time;
480 ftdm_time_t last_release_time;
481 };
482
483 struct ftdm_span {
484 ftdm_data_type_t data_type;
485 char *name;
486 uint32_t span_id;
487 uint32_t chan_count;
488 ftdm_span_flag_t flags;
489 struct ftdm_io_interface *fio;
490 fio_event_cb_t event_callback;
491 ftdm_mutex_t *mutex;
492 ftdm_trunk_type_t trunk_type;
493 ftdm_trunk_mode_t trunk_mode;
494 ftdm_analog_start_type_t start_type;
495 ftdm_signal_type_t signal_type;
496 uint32_t last_used_index;
497 /* Private signaling data. Do not touch unless you are a signaling module */
498 void *signal_data;
499 fio_signal_cb_t signal_cb;
500 ftdm_event_t event_header;
501 char last_error[256];
502 char tone_map[FTDM_TONEMAP_INVALID+1][FTDM_TONEMAP_LEN];
503 teletone_tone_map_t tone_detect_map[FTDM_TONEMAP_INVALID+1];
504 teletone_multi_tone_t tone_finder[FTDM_TONEMAP_INVALID+1];
505 ftdm_channel_t *channels[FTDM_MAX_CHANNELS_SPAN+1];
506 fio_channel_outgoing_call_t outgoing_call;
507 fio_channel_indicate_t indicate;
508 fio_channel_set_sig_status_t set_channel_sig_status;
509 fio_channel_get_sig_status_t get_channel_sig_status;
510 fio_span_set_sig_status_t set_span_sig_status;
511 fio_span_get_sig_status_t get_span_sig_status;
512 fio_channel_request_t channel_request;
513 ftdm_span_start_t start;
514 ftdm_span_stop_t stop;
515 ftdm_span_destroy_t destroy;
516 ftdm_channel_sig_read_t sig_read;
517 ftdm_channel_sig_write_t sig_write;
518 ftdm_channel_sig_dtmf_t sig_queue_dtmf;
519 ftdm_channel_sig_dtmf_t sig_send_dtmf;
520 uint32_t sig_release_guard_time_ms;
521 ftdm_channel_state_processor_t state_processor; /*!< This guy is called whenever state processing is required */
522 void *io_data; /*!< Private I/O data per span. Do not touch unless you are an I/O module */
523 char *type;
524 char *dtmf_hangup;
525 size_t dtmf_hangup_len;
526 ftdm_state_map_t *state_map;
527 ftdm_caller_data_t default_caller_data;
528 ftdm_queue_t *pendingchans; /*!< Channels pending of state processing */
529 ftdm_queue_t *pendingsignals; /*!< Signals pending from being delivered to the user */
530 struct ftdm_span *next;
531 };
532
533 struct ftdm_group {
534 char *name;
535 uint32_t group_id;
536 uint32_t chan_count;
537 ftdm_channel_t *channels[FTDM_MAX_CHANNELS_GROUP];
538 uint32_t last_used_index;
539 ftdm_mutex_t *mutex;
540 struct ftdm_group *next;
541 };
542
543 FT_DECLARE_DATA extern ftdm_crash_policy_t g_ftdm_crash_policy;
544
545 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);
546 FT_DECLARE(int32_t) ftdm_fsk_modulator_generate_carrier_bits(ftdm_fsk_modulator_t *fsk_trans, uint32_t bits);
547 FT_DECLARE(void) ftdm_fsk_modulator_generate_chan_sieze(ftdm_fsk_modulator_t *fsk_trans);
548 FT_DECLARE(void) ftdm_fsk_modulator_send_data(ftdm_fsk_modulator_t *fsk_trans);
549 #define ftdm_fsk_modulator_send_all(_it) ftdm_fsk_modulator_generate_chan_sieze(_it); \
550 ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_start); \
551 ftdm_fsk_modulator_send_data(_it); \
552 ftdm_fsk_modulator_generate_carrier_bits(_it, _it->carrier_bits_stop)
553
554 FT_DECLARE(ftdm_status_t) ftdm_fsk_modulator_init(ftdm_fsk_modulator_t *fsk_trans,
555 fsk_modem_types_t modem_type,
556 uint32_t sample_rate,
557 ftdm_fsk_data_state_t *fsk_data,
558 float db_level,
559 uint32_t carrier_bits_start,
560 uint32_t carrier_bits_stop,
561 uint32_t chan_sieze_bits,
562 ftdm_fsk_write_sample_t write_sample_callback,
563 void *user_data);
564 FT_DECLARE(int8_t) ftdm_bitstream_get_bit(ftdm_bitstream_t *bsp);
565 FT_DECLARE(void) ftdm_bitstream_init(ftdm_bitstream_t *bsp, uint8_t *data, uint32_t datalen, ftdm_endian_t endian, uint8_t ss);
566 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);
567 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_feed(ftdm_fsk_data_state_t *state, int16_t *data, size_t samples);
568 FT_DECLARE(ftdm_status_t) ftdm_fsk_demod_destroy(ftdm_fsk_data_state_t *state);
569 FT_DECLARE(int) ftdm_fsk_demod_init(ftdm_fsk_data_state_t *state, int rate, uint8_t *buf, size_t bufsize);
570 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_init(ftdm_fsk_data_state_t *state, uint8_t *data, uint32_t datalen);
571 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);
572 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_checksum(ftdm_fsk_data_state_t *state);
573 FT_DECLARE(ftdm_status_t) ftdm_fsk_data_add_sdmf(ftdm_fsk_data_state_t *state, const char *date, char *number);
574 FT_DECLARE(ftdm_status_t) ftdm_channel_send_fsk_data(ftdm_channel_t *ftdmchan, ftdm_fsk_data_state_t *fsk_data, float db_level);
575
576 FT_DECLARE(ftdm_status_t) ftdm_span_load_tones(ftdm_span_t *span, const char *mapname);
577
578 FT_DECLARE(ftdm_status_t) ftdm_channel_use(ftdm_channel_t *ftdmchan);
579
580 FT_DECLARE(void) ftdm_generate_sln_silence(int16_t *data, uint32_t samples, uint32_t divisor);
581
582 FT_DECLARE(uint32_t) ftdm_separate_string(char *buf, char delim, char **array, int arraylen);
583 FT_DECLARE(void) print_bits(uint8_t *b, int bl, char *buf, int blen, int e, uint8_t ss);
584 FT_DECLARE(void) print_hex_bytes(uint8_t *data, ftdm_size_t dlen, char *buf, ftdm_size_t blen);
585
586 FT_DECLARE_NONSTD(int) ftdm_hash_equalkeys(void *k1, void *k2);
587 FT_DECLARE_NONSTD(uint32_t) ftdm_hash_hashfromstring(void *ky);
588
589 FT_DECLARE(int) ftdm_load_modules(void);
590
591 FT_DECLARE(ftdm_status_t) ftdm_unload_modules(void);
592
593 FT_DECLARE(ftdm_status_t) ftdm_span_send_signal(ftdm_span_t *span, ftdm_sigmsg_t *sigmsg);
594
595 FT_DECLARE(void) ftdm_channel_clear_needed_tones(ftdm_channel_t *ftdmchan);
596 FT_DECLARE(void) ftdm_channel_rotate_tokens(ftdm_channel_t *ftdmchan);
597
598 FT_DECLARE(int) ftdm_load_module(const char *name);
599 FT_DECLARE(int) ftdm_load_module_assume(const char *name);
600 FT_DECLARE(int) ftdm_vasprintf(char **ret, const char *fmt, va_list ap);
601
602 FT_DECLARE(ftdm_status_t) ftdm_span_close_all(void);
603 FT_DECLARE(ftdm_status_t) ftdm_channel_open_chan(ftdm_channel_t *ftdmchan);
604 FT_DECLARE(void) ftdm_ack_indication(ftdm_channel_t *ftdmchan, ftdm_channel_indication_t indication, ftdm_status_t status);
605
606
607 FT_DECLARE(ftdm_iterator_t *) ftdm_get_iterator(ftdm_iterator_type_t type, ftdm_iterator_t *iter);
608
609 FT_DECLARE(ftdm_status_t) ftdm_channel_process_media(ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen);
610
611 FT_DECLARE(ftdm_status_t) ftdm_raw_read (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen);
612 FT_DECLARE(ftdm_status_t) ftdm_raw_write (ftdm_channel_t *ftdmchan, void *data, ftdm_size_t *datalen);
613
614 /*!
615 * \brief Retrieves an event from the span
616 *
617 * \note
618 * This function is non-reentrant and not thread-safe.
619 * The event returned may be modified if the function is called again
620 * from a different thread or even the same. It is recommended to
621 * handle events from the same span in a single thread.
622 * WARNING: this function used to be public ( in freetdm.h )
623 * but since is really of no use to users better keep it here
624 *
625 * \param span The span to retrieve the event from
626 * \param event Pointer to store the pointer to the event
627 *
628 * \retval FTDM_SUCCESS success (at least one event available)
629 * \retval FTDM_TIMEOUT Timed out waiting for events
630 * \retval FTDM_FAIL failure
631 */
632 FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event);
633
634 /*!
635 * \brief Enqueue a DTMF string into the channel
636 *
637 * \param ftdmchan The channel to enqueue the dtmf string to
638 * \param dtmf null-terminated DTMF string
639 *
640 * \retval FTDM_SUCCESS success
641 * \retval FTDM_FAIL failure
642 */
643 FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf);
644
645 /* dequeue pending signals and notify the user via the span signal callback */
646 FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span);
647
648 /*! \brief clear the tone detector state */
649 FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
650
651 /*! \brief adjust echocanceller for beginning of call */
652 FT_DECLARE(void) ftdm_set_echocancel_call_begin(ftdm_channel_t *chan);
653
654 /*! \brief adjust echocanceller for end of call */
655 FT_DECLARE(void) ftdm_set_echocancel_call_end(ftdm_channel_t *chan);
656
657 /*! \brief save data from user */
658 FT_DECLARE(ftdm_status_t) ftdm_channel_save_usrmsg(ftdm_channel_t *ftdmchan, ftdm_usrmsg_t *usrmsg);
659
660 /*! \brief free usrmsg and variables/raw data attached to it */
661 FT_DECLARE(ftdm_status_t) ftdm_usrmsg_free(ftdm_usrmsg_t **usrmsg);
662
663 /*! \brief Get a custom variable from the user message
664 * \note The variable pointer returned is only valid while the before the event is processed and it'll be destroyed once the event is processed. */
665 FT_DECLARE(const char *) ftdm_usrmsg_get_var(ftdm_usrmsg_t *usrmsg, const char *var_name);
666
667 /*! \brief Get raw data from user message
668 * \param usrmsg The message structure containing the variables
669 * \param data data will point to available data pointer if available
670 * \param datalen datalen will be set to length of data available
671 * \retval FTDM_SUCCESS data is available
672 * \retval FTDM_FAIL no data available
673 * \note data is only valid within the duration of the callback, to receive a data pointer that does not get
674 * \note destroyed when callback returns, see ftdm_sigmsg_get_raw_data_detached
675 */
676 FT_DECLARE(ftdm_status_t) ftdm_usrmsg_get_raw_data(ftdm_usrmsg_t *usrmsg, void **data, ftdm_size_t *datalen);
677
678 /*! \brief free sigmsg and variables/raw data attached to it */
679 FT_DECLARE(ftdm_status_t) ftdm_sigmsg_free(ftdm_sigmsg_t **sigmsg);
680
681 /*! \brief Add a custom variable to the event
682 * \note This variables may be used by signaling modules to override signaling parameters
683 * \todo Document which signaling variables are available
684 * */
685 FT_DECLARE(ftdm_status_t) ftdm_sigmsg_add_var(ftdm_sigmsg_t *sigmsg, const char *var_name, const char *value);
686
687 /*! \brief Remove a custom variable from the event
688 * \note The variable pointer returned is only valid while the before the event is processed and it'll be destroyed once the event is processed. */
689 FT_DECLARE(ftdm_status_t) ftdm_sigmsg_remove_var(ftdm_sigmsg_t *sigmsg, const char *var_name);
690
691 /*! \brief Attach raw data to sigmsg
692 * \param sigmsg The message structure containing the variables
693 * \param data pointer to data
694 * \param datalen datalen length of data
695 * \retval FTDM_SUCCESS success, data was successfully saved
696 * \retval FTDM_FAIL failed, event already had data attached to it.
697 * \note data must have been allocated using ftdm_calloc, FreeTDM will free data once the usrmsg is processed.
698 */
699 FT_DECLARE(ftdm_status_t) ftdm_sigmsg_set_raw_data(ftdm_sigmsg_t *sigmsg, void *data, ftdm_size_t datalen);
700
701 /*! \brief Retrieve a span and channel data structure from a string in the format 'span_id:chan_id'*/
702 FT_DECLARE(ftdm_status_t) ftdm_get_channel_from_string(const char *string_id, ftdm_span_t **out_span, ftdm_channel_t **out_channel);
703
704 /*!
705 \brief Assert condition
706 */
707 #define ftdm_assert(assertion, msg) \
708 if (!(assertion)) { \
709 ftdm_log(FTDM_LOG_CRIT, "%s", msg); \
710 if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
711 ftdm_abort(); \
712 } \
713 }
714
715 /*!
716 \brief Assert condition and return
717 */
718 #define ftdm_assert_return(assertion, retval, msg) \
719 if (!(assertion)) { \
720 ftdm_log(FTDM_LOG_CRIT, "%s", msg); \
721 if (g_ftdm_crash_policy & FTDM_CRASH_ON_ASSERT) { \
722 ftdm_abort(); \
723 } else { \
724 return retval; \
725 } \
726 }
727
728 /*!
729 \brief Socket the given socket
730 \command it the socket
731 */
732 #define ftdm_socket_close(it) if (it > -1) { close(it); it = -1;}
733
734 #define ftdm_channel_lock(chan) ftdm_mutex_lock((chan)->mutex)
735 #define ftdm_channel_unlock(chan) ftdm_mutex_unlock((chan)->mutex)
736
737 #define ftdm_log_throttle(level, ...) \
738 time_current_throttle_log = ftdm_current_time_in_ms(); \
739 if (time_current_throttle_log - time_last_throttle_log > FTDM_THROTTLE_LOG_INTERVAL) {\
740 ftdm_log(level, __VA_ARGS__); \
741 time_last_throttle_log = time_current_throttle_log; \
742 }
743
744 #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__)
745
746 #define ftdm_log_chan_ex_msg(fchan, file, func, line, level, msg) ftdm_log(file, func, line, level, "[s%dc%d][%d:%d] " msg, fchan->span_id, fchan->chan_id, fchan->physical_span_id, fchan->physical_chan_id)
747
748 #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__)
749
750 #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)
751
752 #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__)
753 #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__)
754
755 #define ftdm_span_lock(span) ftdm_mutex_lock(span->mutex)
756 #define ftdm_span_unlock(span) ftdm_mutex_unlock(span->mutex)
757
758 #define ftdm_test_and_set_media(fchan) \
759 do { \
760 if (!ftdm_test_flag((fchan), FTDM_CHANNEL_MEDIA)) { \
761 ftdm_set_flag((fchan), FTDM_CHANNEL_MEDIA); \
762 ftdm_set_echocancel_call_begin((fchan)); \
763 if ((fchan)->dtmfdbg.requested) { \
764 ftdm_channel_command((fchan), FTDM_COMMAND_ENABLE_DEBUG_DTMF, NULL); \
765 } \
766 } \
767 } while (0);
768
769 FT_DECLARE_DATA extern const char *FTDM_LEVEL_NAMES[9];
770
ftdm_abort(void)771 static __inline__ void ftdm_abort(void)
772 {
773 #ifdef __cplusplus
774 ::abort();
775 #else
776 abort();
777 #endif
778 }
779
ftdm_saturated_add(int16_t sample1,int16_t sample2)780 static __inline__ int16_t ftdm_saturated_add(int16_t sample1, int16_t sample2)
781 {
782 int addres;
783
784 addres = sample1 + sample2;
785 if (addres > 32767)
786 addres = 32767;
787 else if (addres < -32767)
788 addres = -32767;
789 return (int16_t)addres;
790 }
791
792 /* Bitmap helper functions */
793 typedef long ftdm_bitmap_t;
794 #define FTDM_BITMAP_NBITS (sizeof(ftdm_bitmap_t) * 8)
795 #define ftdm_map_set_bit(map, bit) (map[(bit/FTDM_BITMAP_NBITS)] |= ((ftdm_bitmap_t)1 << (bit % FTDM_BITMAP_NBITS)))
796 #define ftdm_map_clear_bit(map, bit) (map[(bit/FTDM_BITMAP_NBITS)] &= ~((ftdm_bitmap_t)1 << (bit % FTDM_BITMAP_NBITS)))
797 #define ftdm_map_test_bit(map, bit) (map[(bit/FTDM_BITMAP_NBITS)] & ((ftdm_bitmap_t)1 << (bit % FTDM_BITMAP_NBITS)))
798
799 #ifdef __cplusplus
800 }
801 #endif
802
803 #endif /* endif __PRIVATE_FTDM_CORE__ */
804