This source file includes following definitions.
- FIO_CHANNEL_OUTGOING_CALL_FUNCTION
- FIO_CHANNEL_OUTGOING_CALL_FUNCTION
- FIO_CHANNEL_GET_SIG_STATUS_FUNCTION
- FIO_SPAN_GET_SIG_STATUS_FUNCTION
- ftdm_analog_start
- ftdm_analog_stop
- FIO_SIG_CONFIGURE_FUNCTION
- teletone_handler
- send_caller_id
- analog_dial
- ftdm_analog_channel_run
- process_event
- ftdm_analog_run
- FIO_SIG_LOAD_FUNCTION
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 #include "private/ftdm_core.h"
35 #include "ftdm_analog.h"
36
37 #ifndef localtime_r
38 struct tm * localtime_r(const time_t *clock, struct tm *result);
39 #endif
40
41 static void *ftdm_analog_channel_run(ftdm_thread_t *me, void *obj);
42
43
44
45
46
47
48
49
50 static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxo_outgoing_call)
51 {
52 ftdm_analog_data_t *analog_data = ftdmchan->span->signal_data;
53 if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) {
54 ftdm_channel_clear_needed_tones(ftdmchan);
55 ftdm_channel_clear_detected_tones(ftdmchan);
56
57 ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL);
58 ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_PROGRESS_DETECT, NULL);
59 if (analog_data->wait_dialtone_timeout) {
60 ftdmchan->needed_tones[FTDM_TONEMAP_DIAL] = 1;
61 }
62 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DIALING);
63 ftdm_thread_create_detached(ftdm_analog_channel_run, ftdmchan);
64 return FTDM_SUCCESS;
65 }
66
67 return FTDM_FAIL;
68 }
69
70
71
72
73
74
75
76
77 static FIO_CHANNEL_OUTGOING_CALL_FUNCTION(analog_fxs_outgoing_call)
78 {
79
80 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) {
81 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_CALLWAITING);
82 } else {
83 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_GENRING);
84 ftdm_thread_create_detached(ftdm_analog_channel_run, ftdmchan);
85 }
86
87 return FTDM_SUCCESS;
88 }
89
90
91
92
93
94
95
96
97 static FIO_CHANNEL_GET_SIG_STATUS_FUNCTION(analog_get_channel_sig_status)
98 {
99 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_IN_ALARM)) {
100 *status = FTDM_SIG_STATE_DOWN;
101 return FTDM_SUCCESS;
102 }
103 *status = FTDM_SIG_STATE_UP;
104 return FTDM_SUCCESS;
105 }
106
107
108
109
110
111
112
113
114 static FIO_SPAN_GET_SIG_STATUS_FUNCTION(analog_get_span_sig_status)
115 {
116 ftdm_iterator_t *citer = NULL;
117 ftdm_iterator_t *chaniter = ftdm_span_get_chan_iterator(span, NULL);
118 if (!chaniter) {
119 ftdm_log(FTDM_LOG_CRIT, "Failed to allocate channel iterator for span %s!\n", span->name);
120 return FTDM_FAIL;
121 }
122
123 *status = FTDM_SIG_STATE_DOWN;
124 for (citer = chaniter; citer; citer = ftdm_iterator_next(citer)) {
125 ftdm_channel_t *fchan = ftdm_iterator_current(citer);
126 ftdm_channel_lock(fchan);
127 if (!ftdm_test_flag(fchan, FTDM_CHANNEL_IN_ALARM)) {
128 *status = FTDM_SIG_STATE_UP;
129 ftdm_channel_unlock(fchan);
130 break;
131 }
132 ftdm_channel_unlock(fchan);
133 }
134 ftdm_iterator_free(chaniter);
135 return FTDM_SUCCESS;
136 }
137
138
139
140
141
142
143 static ftdm_status_t ftdm_analog_start(ftdm_span_t *span)
144 {
145 ftdm_analog_data_t *analog_data = span->signal_data;
146 ftdm_set_flag(analog_data, FTDM_ANALOG_RUNNING);
147 return ftdm_thread_create_detached(ftdm_analog_run, span);
148 }
149
150
151
152
153
154
155 static ftdm_status_t ftdm_analog_stop(ftdm_span_t *span)
156 {
157 ftdm_analog_data_t *analog_data = span->signal_data;
158 int32_t sanity = 100;
159 while (ftdm_test_flag(analog_data, FTDM_ANALOG_RUNNING) && sanity--) {
160 ftdm_sleep(100);
161 ftdm_log(FTDM_LOG_DEBUG, "Waiting for analog thread for span %s to stop\n", span->name);
162 }
163
164 if (!sanity) {
165 ftdm_log(FTDM_LOG_ERROR, "The analog thread for span %s is probably still running, we may crash :(\n", span->name);
166 return FTDM_FAIL;
167 }
168 return FTDM_SUCCESS;
169 }
170
171
172
173
174
175
176
177
178 static FIO_SIG_CONFIGURE_FUNCTION(ftdm_analog_configure_span)
179
180 {
181 ftdm_analog_data_t *analog_data;
182 const char *tonemap = "us";
183 const char *hotline = "";
184 uint32_t digit_timeout = 10;
185 uint32_t wait_dialtone_timeout = 30000;
186 uint32_t max_dialstr = MAX_DTMF;
187 uint32_t polarity_delay = 600;
188 const char *var, *val;
189 int *intval;
190 uint32_t flags = FTDM_ANALOG_CALLERID;
191 int callwaiting = 1;
192 unsigned int i = 0;
193
194 assert(sig_cb != NULL);
195 ftdm_log(FTDM_LOG_DEBUG, "Configuring span %s for analog signaling ...\n", span->name);
196
197 if (span->signal_type) {
198 ftdm_log(FTDM_LOG_ERROR, "Span %s is already configured for signaling %d\n", span->name, span->signal_type);
199 snprintf(span->last_error, sizeof(span->last_error), "Span is already configured for signalling.");
200 return FTDM_FAIL;
201 }
202
203 analog_data = ftdm_malloc(sizeof(*analog_data));
204
205 ftdm_assert_return(analog_data != NULL, FTDM_FAIL, "malloc failure\n");
206
207 memset(analog_data, 0, sizeof(*analog_data));
208
209 while ((var = va_arg(ap, char *))) {
210 ftdm_log(FTDM_LOG_DEBUG, "Analog config var = %s\n", var);
211 if (!strcasecmp(var, "tonemap")) {
212 if (!(val = va_arg(ap, char *))) {
213 break;
214 }
215 tonemap = val;
216 } else if (!strcasecmp(var, "digit_timeout")) {
217 if (!(intval = va_arg(ap, int *))) {
218 break;
219 }
220 digit_timeout = *intval;
221 } else if (!strcasecmp(var, "wait_dialtone_timeout")) {
222 if (!(intval = va_arg(ap, int *))) {
223 break;
224 }
225 wait_dialtone_timeout = *intval;
226 if (wait_dialtone_timeout < 0) {
227 wait_dialtone_timeout = 0;
228 }
229 ftdm_log_chan(span->channels[i], FTDM_LOG_DEBUG, "Wait dial tone ms = %d\n", wait_dialtone_timeout);
230 } else if (!strcasecmp(var, "enable_callerid")) {
231 if (!(val = va_arg(ap, char *))) {
232 break;
233 }
234
235 if (ftdm_true(val)) {
236 flags |= FTDM_ANALOG_CALLERID;
237 } else {
238 flags &= ~FTDM_ANALOG_CALLERID;
239 }
240 } else if (!strcasecmp(var, "answer_polarity_reverse")) {
241 if (!(val = va_arg(ap, char *))) {
242 break;
243 }
244 if (ftdm_true(val)) {
245 flags |= FTDM_ANALOG_ANSWER_POLARITY_REVERSE;
246 } else {
247 flags &= ~FTDM_ANALOG_ANSWER_POLARITY_REVERSE;
248 }
249 } else if (!strcasecmp(var, "hangup_polarity_reverse")) {
250 if (!(val = va_arg(ap, char *))) {
251 break;
252 }
253 if (ftdm_true(val)) {
254 flags |= FTDM_ANALOG_HANGUP_POLARITY_REVERSE;
255 } else {
256 flags &= ~FTDM_ANALOG_HANGUP_POLARITY_REVERSE;
257 }
258 } else if (!strcasecmp(var, "polarity_delay")) {
259 if (!(intval = va_arg(ap, int *))) {
260 break;
261 }
262 polarity_delay = *intval;
263 } else if (!strcasecmp(var, "callwaiting")) {
264 if (!(intval = va_arg(ap, int *))) {
265 break;
266 }
267 callwaiting = *intval;
268 } else if (!strcasecmp(var, "max_dialstr")) {
269 if (!(intval = va_arg(ap, int *))) {
270 break;
271 }
272 max_dialstr = *intval;
273 } else if (!strcasecmp(var, "hotline")) {
274 if (!(val = va_arg(ap, char *))) {
275 break;
276 }
277 hotline = val;
278 } else {
279 ftdm_log(FTDM_LOG_ERROR, "Unknown parameter %s in span %s\n", var, span->name);
280 }
281 }
282
283 if (digit_timeout < 2000 || digit_timeout > 10000) {
284 digit_timeout = 2000;
285 }
286
287 if ((max_dialstr < 1 && !strlen(hotline)) || max_dialstr > MAX_DTMF) {
288 max_dialstr = MAX_DTMF;
289 }
290
291 if (callwaiting) {
292 for (i = 1; i <= span->chan_count; i++) {
293 ftdm_log_chan_msg(span->channels[i], FTDM_LOG_DEBUG, "Enabled call waiting\n");
294 ftdm_channel_set_feature(span->channels[i], FTDM_CHANNEL_FEATURE_CALLWAITING);
295 }
296 }
297
298 span->start = ftdm_analog_start;
299 span->stop = ftdm_analog_stop;
300 analog_data->flags = flags;
301 analog_data->digit_timeout = digit_timeout;
302 analog_data->wait_dialtone_timeout = wait_dialtone_timeout;
303 analog_data->polarity_delay = polarity_delay;
304 analog_data->max_dialstr = max_dialstr;
305 span->signal_cb = sig_cb;
306 strncpy(analog_data->hotline, hotline, sizeof(analog_data->hotline));
307 span->signal_type = FTDM_SIGTYPE_ANALOG;
308 span->signal_data = analog_data;
309 span->outgoing_call = span->trunk_type == FTDM_TRUNK_FXS ? analog_fxs_outgoing_call : analog_fxo_outgoing_call;
310 span->get_channel_sig_status = analog_get_channel_sig_status;
311 span->get_span_sig_status = analog_get_span_sig_status;
312
313 ftdm_span_load_tones(span, tonemap);
314
315 ftdm_log(FTDM_LOG_DEBUG, "Configuration of analog signaling for span %s is done\n", span->name);
316 return FTDM_SUCCESS;
317
318 }
319
320
321
322
323
324
325
326 static int teletone_handler(teletone_generation_session_t *ts, teletone_tone_map_t *map)
327 {
328 ftdm_buffer_t *dt_buffer = ts->user_data;
329 int wrote;
330
331 if (!dt_buffer) {
332 return -1;
333 }
334 wrote = teletone_mux_tones(ts, map);
335 ftdm_buffer_write(dt_buffer, ts->buffer, wrote * 2);
336 return 0;
337 }
338
339
340
341
342
343 static void send_caller_id(ftdm_channel_t *ftdmchan)
344 {
345 ftdm_fsk_data_state_t fsk_data;
346 uint8_t databuf[1024] = "";
347 char time_str[9];
348 struct tm tm;
349 time_t now;
350 ftdm_mdmf_type_t mt = MDMF_INVALID;
351
352 time(&now);
353 #ifdef WIN32
354 _tzset();
355 _localtime64_s(&tm, &now);
356 #else
357 localtime_r(&now, &tm);
358 #endif
359 strftime(time_str, sizeof(time_str), "%m%d%H%M", &tm);
360
361 ftdm_fsk_data_init(&fsk_data, databuf, sizeof(databuf));
362 ftdm_fsk_data_add_mdmf(&fsk_data, MDMF_DATETIME, (uint8_t *) time_str, 8);
363
364 if (ftdm_strlen_zero(ftdmchan->caller_data.cid_num.digits)) {
365 mt = MDMF_NO_NUM;
366 ftdm_set_string(ftdmchan->caller_data.cid_num.digits, "O");
367 } else if (!strcasecmp(ftdmchan->caller_data.cid_num.digits, "P") || !strcasecmp(ftdmchan->caller_data.cid_num.digits, "O")) {
368 mt = MDMF_NO_NUM;
369 } else {
370 mt = MDMF_PHONE_NUM;
371 }
372 ftdm_fsk_data_add_mdmf(&fsk_data, mt, (uint8_t *) ftdmchan->caller_data.cid_num.digits, (uint8_t)strlen(ftdmchan->caller_data.cid_num.digits));
373
374 if (ftdm_strlen_zero(ftdmchan->caller_data.cid_name)) {
375 mt = MDMF_NO_NAME;
376 ftdm_set_string(ftdmchan->caller_data.cid_name, "O");
377 } else if (!strcasecmp(ftdmchan->caller_data.cid_name, "P") || !strcasecmp(ftdmchan->caller_data.cid_name, "O")) {
378 mt = MDMF_NO_NAME;
379 } else {
380 mt = MDMF_PHONE_NAME;
381 }
382 ftdm_fsk_data_add_mdmf(&fsk_data, mt, (uint8_t *) ftdmchan->caller_data.cid_name, (uint8_t)strlen(ftdmchan->caller_data.cid_name));
383
384 ftdm_fsk_data_add_checksum(&fsk_data);
385 ftdm_channel_send_fsk_data(ftdmchan, &fsk_data, -14);
386 }
387
388 static void analog_dial(ftdm_channel_t *ftdmchan, uint32_t *state_counter, uint32_t *dial_timeout)
389 {
390 if (ftdm_strlen_zero(ftdmchan->caller_data.dnis.digits)) {
391 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "No digits to send, moving to UP!\n");
392 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
393 } else {
394 if (ftdm_channel_command(ftdmchan, FTDM_COMMAND_SEND_DTMF, ftdmchan->caller_data.dnis.digits) != FTDM_SUCCESS) {
395 ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "Send Digits Failed [%s]\n", ftdmchan->last_error);
396 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY);
397 } else {
398 *state_counter = 0;
399 ftdmchan->needed_tones[FTDM_TONEMAP_RING] = 1;
400 ftdmchan->needed_tones[FTDM_TONEMAP_BUSY] = 1;
401 ftdmchan->needed_tones[FTDM_TONEMAP_FAIL1] = 1;
402 ftdmchan->needed_tones[FTDM_TONEMAP_FAIL2] = 1;
403 ftdmchan->needed_tones[FTDM_TONEMAP_FAIL3] = 1;
404 *dial_timeout = ((ftdmchan->dtmf_on + ftdmchan->dtmf_off) * strlen(ftdmchan->caller_data.dnis.digits)) + 2000;
405 }
406 }
407 }
408
409
410
411
412
413
414 static void *ftdm_analog_channel_run(ftdm_thread_t *me, void *obj)
415 {
416 ftdm_channel_t *ftdmchan = (ftdm_channel_t *) obj;
417 ftdm_buffer_t *dt_buffer = NULL;
418 teletone_generation_session_t ts;
419 uint8_t frame[1024];
420 ftdm_size_t len, rlen;
421 ftdm_tone_type_t tt = FTDM_TONE_DTMF;
422 char dtmf[MAX_DTMF+1] = "";
423 ftdm_size_t dtmf_offset = 0;
424 ftdm_analog_data_t *analog_data = ftdmchan->span->signal_data;
425 ftdm_channel_t *closed_chan;
426 uint32_t state_counter = 0, elapsed = 0, collecting = 0, interval = 0, last_digit = 0, indicate = 0, dial_timeout = analog_data->wait_dialtone_timeout;
427 uint32_t answer_on_polarity_counter = 0;
428 ftdm_sigmsg_t sig;
429 ftdm_status_t status;
430
431 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "ANALOG CHANNEL thread starting.\n");
432
433 ts.buffer = NULL;
434
435 if (ftdm_channel_open_chan(ftdmchan) != FTDM_SUCCESS) {
436 ftdm_log_chan(ftdmchan, FTDM_LOG_ERROR, "OPEN ERROR [%s]\n", ftdmchan->last_error);
437 goto done;
438 }
439
440 if (ftdm_buffer_create(&dt_buffer, 1024, 3192, 0) != FTDM_SUCCESS) {
441 snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "memory error!");
442 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "MEM ERROR\n");
443 goto done;
444 }
445
446 if (ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_DTMF_DETECT, &tt) != FTDM_SUCCESS) {
447 snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "error initilizing tone detector!");
448 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "failed to initialize DTMF detector\n");
449 goto done;
450 }
451 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Initialized DTMF detection\n");
452
453 ftdm_set_flag_locked(ftdmchan, FTDM_CHANNEL_INTHREAD);
454 teletone_init_session(&ts, 0, teletone_handler, dt_buffer);
455 ts.rate = 8000;
456 #if 0
457 ts.debug = 1;
458 ts.debug_stream = stdout;
459 #endif
460 ftdm_channel_command(ftdmchan, FTDM_COMMAND_GET_INTERVAL, &interval);
461 ftdm_buffer_set_loops(dt_buffer, -1);
462
463 memset(&sig, 0, sizeof(sig));
464 sig.chan_id = ftdmchan->chan_id;
465 sig.span_id = ftdmchan->span_id;
466 sig.channel = ftdmchan;
467
468 ftdm_assert(interval != 0, NULL);
469
470 if (!dial_timeout) {
471 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Not waiting for dial tone to dial number %s\n", ftdmchan->caller_data.dnis.digits);
472 }
473
474 while (ftdm_running() && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_INTHREAD)) {
475 ftdm_wait_flag_t flags = FTDM_READ;
476 ftdm_size_t dlen = 0;
477
478 len = sizeof(frame);
479
480 elapsed += interval;
481 state_counter += interval;
482
483 if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_STATE_CHANGE)) {
484 switch(ftdmchan->state) {
485 case FTDM_CHANNEL_STATE_GET_CALLERID:
486 {
487 if (state_counter > 5000 || !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_CALLERID_DETECT)) {
488 ftdm_channel_command(ftdmchan, FTDM_COMMAND_DISABLE_CALLERID_DETECT, NULL);
489 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING);
490 }
491 }
492 break;
493 case FTDM_CHANNEL_STATE_DIALING:
494 {
495 if (state_counter > dial_timeout) {
496 if (ftdmchan->needed_tones[FTDM_TONEMAP_DIAL]) {
497 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY);
498 } else {
499
500 if (ftdm_test_flag(analog_data, FTDM_ANALOG_ANSWER_POLARITY_REVERSE)) {
501 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_PROGRESS_MEDIA);
502 } else {
503 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
504 }
505 }
506 }
507 }
508 break;
509 case FTDM_CHANNEL_STATE_GENRING:
510 {
511 if (state_counter > 60000) {
512 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
513 } else if (!ftdmchan->fsk_buffer || !ftdm_buffer_inuse(ftdmchan->fsk_buffer)) {
514 ftdm_sleep(interval);
515 continue;
516 }
517 }
518 break;
519 case FTDM_CHANNEL_STATE_DIALTONE:
520 {
521 if (!ftdm_test_flag(ftdmchan, FTDM_CHANNEL_HOLD) && state_counter > 10000) {
522 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY);
523 }
524 }
525 break;
526 case FTDM_CHANNEL_STATE_BUSY:
527 {
528 if (state_counter > 20000) {
529 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_ATTN);
530 }
531 }
532 break;
533 case FTDM_CHANNEL_STATE_ATTN:
534 {
535 if (state_counter > 20000) {
536 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
537 }
538 }
539 break;
540 case FTDM_CHANNEL_STATE_HANGUP:
541 {
542 if (state_counter > 500) {
543 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) {
544 ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_OFF, NULL);
545 }
546
547 if (ftdmchan->type == FTDM_CHAN_TYPE_FXS &&
548 ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) &&
549 (ftdmchan->last_state == FTDM_CHANNEL_STATE_RINGING
550 || ftdmchan->last_state == FTDM_CHANNEL_STATE_DIALTONE
551 || ftdmchan->last_state == FTDM_CHANNEL_STATE_RING
552 || ftdmchan->last_state == FTDM_CHANNEL_STATE_UP)) {
553 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY);
554 } else {
555 ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CLEARING;
556 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
557 }
558 }
559 }
560 break;
561 case FTDM_CHANNEL_STATE_CALLWAITING:
562 {
563 int done = 0;
564
565 if (ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] == 1) {
566 send_caller_id(ftdmchan);
567 ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]++;
568 } else if (state_counter > 600 && !ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]) {
569 send_caller_id(ftdmchan);
570 ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]++;
571 } else if (state_counter > 1000 && !ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK]) {
572 done = 1;
573 } else if (state_counter > 10000) {
574 if (ftdmchan->fsk_buffer) {
575 ftdm_buffer_zero(ftdmchan->fsk_buffer);
576 } else {
577 ftdm_buffer_create(&ftdmchan->fsk_buffer, 128, 128, 0);
578 }
579
580 ts.user_data = ftdmchan->fsk_buffer;
581 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_CALLWAITING_SAS]);
582 ts.user_data = dt_buffer;
583 done = 1;
584 }
585
586 if (done) {
587 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
588 ftdm_clear_flag_locked(ftdmchan->span, FTDM_SPAN_STATE_CHANGE);
589 ftdm_channel_complete_state(ftdmchan);
590 ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] = 0;
591 }
592 }
593 case FTDM_CHANNEL_STATE_UP:
594 case FTDM_CHANNEL_STATE_RING:
595 case FTDM_CHANNEL_STATE_PROGRESS_MEDIA:
596 {
597 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) &&
598 ftdmchan->state == FTDM_CHANNEL_STATE_PROGRESS_MEDIA &&
599 ftdm_test_sflag(ftdmchan, AF_POLARITY_REVERSE)) {
600 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_NOTICE, "Answering on polarity reverse\n");
601 ftdm_clear_sflag(ftdmchan, AF_POLARITY_REVERSE);
602 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
603 answer_on_polarity_counter = state_counter;
604 } else if (ftdmchan->state == FTDM_CHANNEL_STATE_UP
605 && ftdm_test_sflag(ftdmchan, AF_POLARITY_REVERSE)){
606
607 if (answer_on_polarity_counter
608 && (state_counter - answer_on_polarity_counter) > analog_data->polarity_delay) {
609 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_NOTICE, "Hanging up on polarity reverse\n");
610 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_HANGUP);
611 } else {
612 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_WARNING,
613 "Not hanging up on polarity reverse, too close to Answer reverse\n");
614 }
615 ftdm_clear_sflag(ftdmchan, AF_POLARITY_REVERSE);
616 } else {
617 ftdm_sleep(interval);
618 }
619 continue;
620 }
621 break;
622 case FTDM_CHANNEL_STATE_DOWN:
623 {
624 goto done;
625 }
626 break;
627 default:
628 break;
629 }
630 } else {
631 ftdm_clear_flag_locked(ftdmchan->span, FTDM_SPAN_STATE_CHANGE);
632 ftdm_channel_complete_state(ftdmchan);
633 indicate = 0;
634 state_counter = 0;
635
636 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Executing state handler on %d:%d for %s\n",
637 ftdmchan->span_id, ftdmchan->chan_id,
638 ftdm_channel_state2str(ftdmchan->state));
639 switch(ftdmchan->state) {
640 case FTDM_CHANNEL_STATE_UP:
641 {
642 ftdm_channel_use(ftdmchan);
643 ftdm_channel_clear_needed_tones(ftdmchan);
644 ftdm_channel_flush_dtmf(ftdmchan);
645
646 if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) {
647 ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL);
648 }
649
650 if (ftdmchan->fsk_buffer && ftdm_buffer_inuse(ftdmchan->fsk_buffer)) {
651 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Cancel FSK transmit due to early answer.\n");
652 ftdm_buffer_zero(ftdmchan->fsk_buffer);
653 }
654
655 if (ftdmchan->type == FTDM_CHAN_TYPE_FXS && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) {
656 ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_OFF, NULL);
657 }
658
659 if (ftdmchan->token_count == 1) {
660 ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_HOLD);
661 }
662
663 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_HOLD)) {
664 ftdm_clear_flag(ftdmchan, FTDM_CHANNEL_HOLD);
665 sig.event_id = FTDM_SIGEVENT_ADD_CALL;
666 } else {
667 sig.event_id = FTDM_SIGEVENT_UP;
668 }
669
670 if (ftdmchan->type == FTDM_CHAN_TYPE_FXS &&
671 !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND) &&
672 ftdm_test_flag(analog_data, FTDM_ANALOG_ANSWER_POLARITY_REVERSE)) {
673 ftdm_polarity_t polarity = FTDM_POLARITY_REVERSE;
674 if (ftdmchan->polarity == FTDM_POLARITY_FORWARD) {
675 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Reversing polarity on answer\n");
676 ftdm_channel_command(ftdmchan, FTDM_COMMAND_SET_POLARITY, &polarity);
677 } else {
678
679
680 }
681 }
682
683 ftdm_span_send_signal(ftdmchan->span, &sig);
684 continue;
685 }
686 break;
687 case FTDM_CHANNEL_STATE_DIALING:
688 {
689 ftdm_channel_use(ftdmchan);
690 }
691 break;
692 case FTDM_CHANNEL_STATE_RING:
693 {
694 ftdm_channel_use(ftdmchan);
695 sig.event_id = FTDM_SIGEVENT_START;
696
697 if (ftdmchan->type == FTDM_CHAN_TYPE_FXO) {
698 ftdm_set_string(ftdmchan->caller_data.dnis.digits, ftdmchan->chan_number);
699 } else {
700 ftdm_set_string(ftdmchan->caller_data.dnis.digits, dtmf);
701 }
702
703 ftdm_span_send_signal(ftdmchan->span, &sig);
704 continue;
705 }
706 break;
707
708 case FTDM_CHANNEL_STATE_HANGUP:
709
710
711
712
713 if (ftdmchan->type == FTDM_CHAN_TYPE_FXS &&
714 ftdmchan->last_state == FTDM_CHANNEL_STATE_UP &&
715 ftdm_test_flag(analog_data, FTDM_ANALOG_HANGUP_POLARITY_REVERSE)) {
716 ftdm_polarity_t polarity = ftdmchan->polarity == FTDM_POLARITY_REVERSE
717 ? FTDM_POLARITY_FORWARD : FTDM_POLARITY_REVERSE;
718 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_DEBUG, "Reversing polarity on hangup\n");
719 ftdm_channel_command(ftdmchan, FTDM_COMMAND_SET_POLARITY, &polarity);
720 }
721 break;
722
723 case FTDM_CHANNEL_STATE_DOWN:
724 {
725 sig.event_id = FTDM_SIGEVENT_STOP;
726 ftdm_span_send_signal(ftdmchan->span, &sig);
727 goto done;
728 }
729 break;
730 case FTDM_CHANNEL_STATE_DIALTONE:
731 {
732 memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data));
733 *dtmf = '\0';
734 dtmf_offset = 0;
735 ftdm_buffer_zero(dt_buffer);
736 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_DIAL]);
737 indicate = 1;
738 }
739 break;
740 case FTDM_CHANNEL_STATE_CALLWAITING:
741 {
742 ftdmchan->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] = 0;
743 if (ftdmchan->fsk_buffer) {
744 ftdm_buffer_zero(ftdmchan->fsk_buffer);
745 } else {
746 ftdm_buffer_create(&ftdmchan->fsk_buffer, 128, 128, 0);
747 }
748
749 ts.user_data = ftdmchan->fsk_buffer;
750 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_CALLWAITING_SAS]);
751 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_CALLWAITING_CAS]);
752 ts.user_data = dt_buffer;
753 }
754 break;
755 case FTDM_CHANNEL_STATE_GENRING:
756 {
757 ftdm_sigmsg_t sig;
758
759 send_caller_id(ftdmchan);
760 ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_ON, NULL);
761
762 memset(&sig, 0, sizeof(sig));
763 sig.chan_id = ftdmchan->chan_id;
764 sig.span_id = ftdmchan->span_id;
765 sig.channel = ftdmchan;
766 sig.event_id = FTDM_SIGEVENT_PROGRESS;
767 ftdm_span_send_signal(ftdmchan->span, &sig);
768
769 }
770 break;
771 case FTDM_CHANNEL_STATE_GET_CALLERID:
772 {
773 memset(&ftdmchan->caller_data, 0, sizeof(ftdmchan->caller_data));
774 ftdm_channel_command(ftdmchan, FTDM_COMMAND_ENABLE_CALLERID_DETECT, NULL);
775 continue;
776 }
777 break;
778 case FTDM_CHANNEL_STATE_RINGING:
779 {
780 ftdm_buffer_zero(dt_buffer);
781 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_RING]);
782 indicate = 1;
783
784 }
785 break;
786 case FTDM_CHANNEL_STATE_BUSY:
787 {
788 ftdmchan->caller_data.hangup_cause = FTDM_CAUSE_NORMAL_CIRCUIT_CONGESTION;
789 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
790 ftdm_buffer_zero(dt_buffer);
791 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_BUSY]);
792 indicate = 1;
793 } else {
794 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
795 }
796 }
797 break;
798 case FTDM_CHANNEL_STATE_ATTN:
799 {
800 if (ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK) && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OUTBOUND)) {
801 ftdm_buffer_zero(dt_buffer);
802 teletone_run(&ts, ftdmchan->span->tone_map[FTDM_TONEMAP_ATTN]);
803 indicate = 1;
804 } else {
805 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_DOWN);
806 }
807 }
808 break;
809 default:
810 break;
811 }
812 }
813
814
815 if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE || ftdmchan->state == FTDM_CHANNEL_STATE_COLLECT) {
816 if ((dlen = ftdm_channel_dequeue_dtmf(ftdmchan, dtmf + dtmf_offset, sizeof(dtmf) - strlen(dtmf)))) {
817
818 if (ftdmchan->state == FTDM_CHANNEL_STATE_DIALTONE) {
819 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_COLLECT);
820 collecting = 1;
821 }
822 dtmf_offset = strlen(dtmf);
823 last_digit = elapsed;
824 sig.event_id = FTDM_SIGEVENT_COLLECTED_DIGIT;
825 ftdm_set_string(sig.ev_data.collected.digits, dtmf);
826 if (ftdm_span_send_signal(ftdmchan->span, &sig) == FTDM_BREAK) {
827 collecting = 0;
828 }
829 }
830 else if(!analog_data->max_dialstr)
831 {
832 last_digit = elapsed;
833 collecting = 0;
834 strcpy(dtmf, analog_data->hotline);
835 }
836 }
837
838
839 if (last_digit && (!collecting || ((elapsed - last_digit > analog_data->digit_timeout) || strlen(dtmf) >= analog_data->max_dialstr))) {
840 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Number obtained [%s]\n", dtmf);
841 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_RING);
842 last_digit = 0;
843 collecting = 0;
844 }
845
846 if (ftdm_channel_wait(ftdmchan, &flags, interval * 2) != FTDM_SUCCESS) {
847 continue;
848 }
849
850 if (!(flags & FTDM_READ)) {
851 continue;
852 }
853
854 if (ftdm_channel_read(ftdmchan, frame, &len) != FTDM_SUCCESS) {
855 ftdm_log_chan(ftdmchan, FTDM_LOG_WARNING, "read error [%s]\n", ftdmchan->last_error);
856 continue;
857 }
858
859 if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && ftdmchan->detected_tones[0]) {
860 int i;
861
862 for (i = 1; i < FTDM_TONEMAP_INVALID; i++) {
863 if (ftdmchan->detected_tones[i]) {
864 ftdm_log_chan(ftdmchan, FTDM_LOG_DEBUG, "Detected tone %s on %d:%d\n", ftdm_tonemap2str(i), ftdmchan->span_id, ftdmchan->chan_id);
865 }
866 }
867
868 if (ftdmchan->detected_tones[FTDM_TONEMAP_BUSY] ||
869 ftdmchan->detected_tones[FTDM_TONEMAP_FAIL1] ||
870 ftdmchan->detected_tones[FTDM_TONEMAP_FAIL2] ||
871 ftdmchan->detected_tones[FTDM_TONEMAP_FAIL3] ||
872 ftdmchan->detected_tones[FTDM_TONEMAP_ATTN]
873 ) {
874 ftdm_log_chan_msg(ftdmchan, FTDM_LOG_ERROR, "Failure indication detected!\n");
875 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_BUSY);
876 } else if (ftdmchan->detected_tones[FTDM_TONEMAP_DIAL]) {
877 analog_dial(ftdmchan, &state_counter, &dial_timeout);
878 } else if (ftdmchan->detected_tones[FTDM_TONEMAP_RING]) {
879 ftdm_set_state_locked(ftdmchan, FTDM_CHANNEL_STATE_UP);
880 }
881
882 ftdm_channel_clear_detected_tones(ftdmchan);
883 } else if (!dial_timeout) {
884
885 analog_dial(ftdmchan, &state_counter, &dial_timeout);
886 }
887
888 if ((ftdmchan->dtmf_buffer && ftdm_buffer_inuse(ftdmchan->dtmf_buffer)) || (ftdmchan->fsk_buffer && ftdm_buffer_inuse(ftdmchan->fsk_buffer))) {
889
890
891
892 continue;
893 }
894
895 if (!indicate) {
896 continue;
897 }
898
899 if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && !ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) {
900 ftdm_channel_command(ftdmchan, FTDM_COMMAND_OFFHOOK, NULL);
901 }
902
903 if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) {
904 len *= 2;
905 }
906
907 rlen = ftdm_buffer_read_loop(dt_buffer, frame, len);
908
909 if (ftdmchan->effective_codec != FTDM_CODEC_SLIN) {
910 fio_codec_t codec_func = NULL;
911
912 if (ftdmchan->native_codec == FTDM_CODEC_ULAW) {
913 codec_func = fio_slin2ulaw;
914 } else if (ftdmchan->native_codec == FTDM_CODEC_ALAW) {
915 codec_func = fio_slin2alaw;
916 }
917
918 if (codec_func) {
919 status = codec_func(frame, sizeof(frame), &rlen);
920 } else {
921 snprintf(ftdmchan->last_error, sizeof(ftdmchan->last_error), "codec error!");
922 goto done;
923 }
924 }
925
926 ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen);
927 }
928
929 done:
930
931 closed_chan = ftdmchan;
932
933 ftdm_channel_lock(closed_chan);
934
935 if (ftdmchan->type == FTDM_CHAN_TYPE_FXO && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_OFFHOOK)) {
936 ftdm_channel_command(ftdmchan, FTDM_COMMAND_ONHOOK, NULL);
937 }
938
939 if (ftdmchan->type == FTDM_CHAN_TYPE_FXS && ftdm_test_flag(ftdmchan, FTDM_CHANNEL_RINGING)) {
940 ftdm_channel_command(ftdmchan, FTDM_COMMAND_GENERATE_RING_OFF, NULL);
941 }
942
943
944 ftdm_clear_sflag(ftdmchan, AF_POLARITY_REVERSE);
945
946 ftdm_channel_close(&ftdmchan);
947
948 ftdm_channel_command(closed_chan, FTDM_COMMAND_SET_NATIVE_CODEC, NULL);
949
950 if (ts.buffer) {
951 teletone_destroy_session(&ts);
952 }
953
954 if (dt_buffer) {
955 ftdm_buffer_destroy(&dt_buffer);
956 }
957
958 if (closed_chan->state != FTDM_CHANNEL_STATE_DOWN) {
959 ftdm_set_state_locked(closed_chan, FTDM_CHANNEL_STATE_DOWN);
960 }
961
962 ftdm_log_chan(closed_chan, FTDM_LOG_DEBUG, "ANALOG CHANNEL %d:%d thread ended.\n", closed_chan->span_id, closed_chan->chan_id);
963
964 ftdm_clear_flag(closed_chan, FTDM_CHANNEL_INTHREAD);
965
966 ftdm_channel_unlock(closed_chan);
967
968 return NULL;
969 }
970
971
972
973
974
975
976
977 static __inline__ ftdm_status_t process_event(ftdm_span_t *span, ftdm_event_t *event)
978 {
979 ftdm_sigmsg_t sig;
980 ftdm_analog_data_t *analog_data = event->channel->span->signal_data;
981 int locked = 0;
982
983 memset(&sig, 0, sizeof(sig));
984 sig.chan_id = event->channel->chan_id;
985 sig.span_id = event->channel->span_id;
986 sig.channel = event->channel;
987
988
989 ftdm_log_chan(event->channel, FTDM_LOG_DEBUG, "Received event [%s] in state [%s]\n", ftdm_oob_event2str(event->enum_id), ftdm_channel_state2str(event->channel->state));
990
991 ftdm_mutex_lock(event->channel->mutex);
992 locked++;
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007 switch(event->enum_id) {
1008 case FTDM_OOB_RING_START:
1009 {
1010 if (event->channel->type != FTDM_CHAN_TYPE_FXO) {
1011 ftdm_log_chan_msg(event->channel, FTDM_LOG_ERROR, "Cannot get a RING_START event on a non-fxo channel, please check your config.\n");
1012 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_DOWN);
1013 goto end;
1014 }
1015 if (!event->channel->ring_count && (event->channel->state == FTDM_CHANNEL_STATE_DOWN && !ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD))) {
1016 if (ftdm_test_flag(analog_data, FTDM_ANALOG_CALLERID)) {
1017 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_GET_CALLERID);
1018 } else {
1019 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_RING);
1020 }
1021 event->channel->ring_count = 1;
1022 ftdm_mutex_unlock(event->channel->mutex);
1023 locked = 0;
1024 ftdm_thread_create_detached(ftdm_analog_channel_run, event->channel);
1025 } else {
1026 event->channel->ring_count++;
1027 }
1028 }
1029 break;
1030 case FTDM_OOB_ONHOOK:
1031 {
1032 if (ftdm_test_flag(event->channel, FTDM_CHANNEL_RINGING)) {
1033 ftdm_channel_command(event->channel, FTDM_COMMAND_GENERATE_RING_OFF, NULL);
1034 }
1035
1036 if (event->channel->state != FTDM_CHANNEL_STATE_DOWN) {
1037 if (event->channel->state == FTDM_CHANNEL_STATE_HANGUP &&
1038 ftdm_test_flag(event->channel, FTDM_CHANNEL_STATE_CHANGE)) {
1039
1040 ftdm_channel_complete_state(event->channel);
1041 }
1042 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_DOWN);
1043 }
1044 if (event->channel->type == FTDM_CHAN_TYPE_FXS) {
1045
1046 ftdm_polarity_t forward_polarity = FTDM_POLARITY_FORWARD;
1047 ftdm_channel_command(event->channel, FTDM_COMMAND_SET_POLARITY, &forward_polarity);
1048 }
1049 }
1050 break;
1051 case FTDM_OOB_FLASH:
1052 {
1053 if (event->channel->state == FTDM_CHANNEL_STATE_CALLWAITING) {
1054 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_UP);
1055 ftdm_clear_flag(event->channel->span, FTDM_SPAN_STATE_CHANGE);
1056 ftdm_channel_complete_state(event->channel);
1057 event->channel->detected_tones[FTDM_TONEMAP_CALLWAITING_ACK] = 0;
1058 }
1059
1060 ftdm_channel_rotate_tokens(event->channel);
1061
1062 if (ftdm_test_flag(event->channel, FTDM_CHANNEL_HOLD) && event->channel->token_count != 1) {
1063 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_UP);
1064 } else {
1065 sig.event_id = FTDM_SIGEVENT_FLASH;
1066 ftdm_span_send_signal(span, &sig);
1067 }
1068 }
1069 break;
1070 case FTDM_OOB_OFFHOOK:
1071 {
1072 if (event->channel->type == FTDM_CHAN_TYPE_FXS) {
1073 if (ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD)) {
1074 if (ftdm_test_flag(event->channel, FTDM_CHANNEL_RINGING)) {
1075 ftdm_channel_command(event->channel, FTDM_COMMAND_GENERATE_RING_OFF, NULL);
1076 }
1077 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_UP);
1078 } else {
1079 if(!analog_data->max_dialstr) {
1080 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_COLLECT);
1081 } else {
1082 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_DIALTONE);
1083 }
1084 ftdm_mutex_unlock(event->channel->mutex);
1085 locked = 0;
1086 ftdm_thread_create_detached(ftdm_analog_channel_run, event->channel);
1087 }
1088 } else {
1089 if (!ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD)) {
1090 if (ftdm_test_flag(event->channel, FTDM_CHANNEL_OFFHOOK)) {
1091 ftdm_channel_command(event->channel, FTDM_COMMAND_ONHOOK, NULL);
1092 }
1093 }
1094 ftdm_set_state(event->channel, FTDM_CHANNEL_STATE_DOWN);
1095 }
1096 }
1097 break;
1098 case FTDM_OOB_ALARM_TRAP:
1099 {
1100 sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
1101 sig.ev_data.sigstatus.status = FTDM_SIG_STATE_DOWN;
1102 ftdm_span_send_signal(span, &sig);
1103 }
1104 break;
1105 case FTDM_OOB_ALARM_CLEAR:
1106 {
1107 sig.event_id = FTDM_SIGEVENT_SIGSTATUS_CHANGED;
1108 sig.ev_data.sigstatus.status = FTDM_SIG_STATE_UP;
1109 ftdm_span_send_signal(span, &sig);
1110 }
1111 break;
1112 case FTDM_OOB_POLARITY_REVERSE:
1113 {
1114 if (event->channel->type != FTDM_CHAN_TYPE_FXO) {
1115 ftdm_log_chan_msg(event->channel, FTDM_LOG_WARNING,
1116 "Ignoring polarity reversal, this should not happen in non-FXO channels!\n");
1117 break;
1118 }
1119 if (!ftdm_test_flag(event->channel, FTDM_CHANNEL_INTHREAD) &&
1120 ftdm_test_flag(event->channel, FTDM_CHANNEL_OFFHOOK)) {
1121 ftdm_log_chan_msg(event->channel, FTDM_LOG_WARNING,
1122 "Forcing onhook in channel not in thread after polarity reversal\n");
1123 ftdm_channel_command(event->channel, FTDM_COMMAND_ONHOOK, NULL);
1124 break;
1125 }
1126 if (!ftdm_test_flag(analog_data, FTDM_ANALOG_ANSWER_POLARITY_REVERSE)
1127 && !ftdm_test_flag(analog_data, FTDM_ANALOG_HANGUP_POLARITY_REVERSE)) {
1128 ftdm_log_chan_msg(event->channel, FTDM_LOG_DEBUG,
1129 "Ignoring polarity reversal because this channel is not configured for it\n");
1130 break;
1131 }
1132 if (event->channel->state == FTDM_CHANNEL_STATE_DOWN) {
1133 ftdm_log_chan_msg(event->channel, FTDM_LOG_DEBUG,
1134 "Ignoring polarity reversal because this channel is down\n");
1135 break;
1136 }
1137
1138 ftdm_set_sflag(event->channel, AF_POLARITY_REVERSE);
1139 }
1140 break;
1141 default:
1142 {
1143 ftdm_log_chan(event->channel, FTDM_LOG_DEBUG, "Ignoring event [%s] in state [%s]\n", ftdm_oob_event2str(event->enum_id), ftdm_channel_state2str(event->channel->state));
1144 }
1145 break;
1146 }
1147
1148 end:
1149
1150 if (locked) {
1151 ftdm_mutex_unlock(event->channel->mutex);
1152 }
1153 return FTDM_SUCCESS;
1154 }
1155
1156
1157
1158
1159
1160
1161 static void *ftdm_analog_run(ftdm_thread_t *me, void *obj)
1162 {
1163 ftdm_span_t *span = (ftdm_span_t *) obj;
1164 ftdm_analog_data_t *analog_data = span->signal_data;
1165 int errs = 0;
1166
1167 ftdm_log(FTDM_LOG_DEBUG, "ANALOG thread starting.\n");
1168
1169 while(ftdm_running() && ftdm_test_flag(analog_data, FTDM_ANALOG_RUNNING)) {
1170 int waitms = 1000;
1171 ftdm_status_t status;
1172
1173 if ((status = ftdm_span_poll_event(span, waitms, NULL)) != FTDM_FAIL) {
1174 errs = 0;
1175 }
1176
1177 switch(status) {
1178 case FTDM_SUCCESS:
1179 {
1180 ftdm_event_t *event;
1181 while (ftdm_span_next_event(span, &event) == FTDM_SUCCESS) {
1182 if (event->enum_id == FTDM_OOB_NOOP) {
1183 continue;
1184 }
1185 if (process_event(span, event) != FTDM_SUCCESS) {
1186 goto end;
1187 }
1188 }
1189 }
1190 break;
1191 case FTDM_FAIL:
1192 {
1193 ftdm_log(FTDM_LOG_ERROR, "Failure Polling event! [%s]\n", span->last_error);
1194 if (++errs > 300) {
1195 ftdm_log(FTDM_LOG_CRIT, "Too Many Errors!\n");
1196 goto end;
1197 }
1198 }
1199 break;
1200 default:
1201 break;
1202 }
1203
1204 }
1205
1206 end:
1207
1208 ftdm_clear_flag(analog_data, FTDM_ANALOG_RUNNING);
1209
1210 ftdm_log(FTDM_LOG_DEBUG, "ANALOG thread ending.\n");
1211
1212 return NULL;
1213 }
1214
1215
1216
1217
1218
1219 static FIO_SIG_LOAD_FUNCTION(ftdm_analog_init)
1220 {
1221 return FTDM_SUCCESS;
1222 }
1223
1224
1225
1226
1227 EX_DECLARE_DATA ftdm_module_t ftdm_module = {
1228 "analog",
1229 NULL,
1230 NULL,
1231 ftdm_analog_init,
1232 ftdm_analog_configure_span,
1233 NULL
1234 };
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246