This source file includes following definitions.
- ftdm_clean_string
- FT_DECLARE
- ftdm_abort
- ftdm_saturated_add
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
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)
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
81
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
141
142
143
144
145 #define ftdm_test_flag(obj, flag) ((obj)->flags & flag)
146
147 #define ftdm_test_pflag(obj, flag) ((obj)->pflags & flag)
148
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
157
158
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
180
181
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
197 #pragma warning(disable:4127)
198 #endif
199
200
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
219
220
221
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
251 #define ftdm_queue_create(queue, capacity) g_ftdm_queue_handler.create(queue, capacity)
252
253
254 #define ftdm_queue_enqueue(queue, obj) g_ftdm_queue_handler.enqueue(queue, obj)
255
256
257 #define ftdm_queue_dequeue(queue) g_ftdm_queue_handler.dequeue(queue)
258
259
260 #define ftdm_queue_wait(queue, ms) g_ftdm_queue_handler.wait(queue, ms)
261
262
263 #define ftdm_queue_get_interrupt(queue, ms) g_ftdm_queue_handler.get_interrupt(queue, ms)
264
265
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
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
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),
362 FTDM_IOSTATS_ERROR_QUEUE_FULL = (1 << 6),
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;
370 uint8_t queue_len;
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;
379 uint8_t queue_len;
380 uint64_t packets;
381 } tx;
382 } ftdm_channel_iostats_t;
383
384
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
445 void *io_data;
446
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;
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
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;
504 void *io_data;
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;
511 ftdm_queue_t *pendingsignals;
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
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606 FT_DECLARE(ftdm_status_t) ftdm_span_next_event(ftdm_span_t *span, ftdm_event_t **event);
607
608
609
610
611
612
613
614
615
616
617 FT_DECLARE(ftdm_status_t) ftdm_channel_queue_dtmf(ftdm_channel_t *ftdmchan, const char *dtmf);
618
619
620 FT_DECLARE(ftdm_status_t) ftdm_span_trigger_signals(const ftdm_span_t *span);
621
622
623 FT_DECLARE(void) ftdm_channel_clear_detected_tones(ftdm_channel_t *ftdmchan);
624
625
626
627
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
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
652
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