root/src/ftmod/ftmod_analog/ftmod_analog.c

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

DEFINITIONS

This source file includes following definitions.
  1. FIO_CHANNEL_OUTGOING_CALL_FUNCTION
  2. FIO_CHANNEL_OUTGOING_CALL_FUNCTION
  3. FIO_CHANNEL_GET_SIG_STATUS_FUNCTION
  4. FIO_SPAN_GET_SIG_STATUS_FUNCTION
  5. ftdm_analog_start
  6. ftdm_analog_stop
  7. FIO_SIG_CONFIGURE_FUNCTION
  8. teletone_handler
  9. send_caller_id
  10. analog_dial
  11. ftdm_analog_channel_run
  12. process_event
  13. ftdm_analog_run
  14. FIO_SIG_LOAD_FUNCTION

   1 /*
   2  * Copyright (c) 2007, Anthony Minessale II
   3  * All rights reserved.
   4  * 
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 
   9  * * Redistributions of source code must retain the above copyright
  10  * notice, this list of conditions and the following disclaimer.
  11  * 
  12  * * Redistributions in binary form must reproduce the above copyright
  13  * notice, this list of conditions and the following disclaimer in the
  14  * documentation and/or other materials provided with the distribution.
  15  * 
  16  * * Neither the name of the original author; nor the names of any contributors
  17  * may be used to endorse or promote products derived from this software
  18  * without specific prior written permission.
  19  * 
  20  * 
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  24  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER
  25  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  26  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  27  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  28  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  29  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  30  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  31  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  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  * \brief Starts an FXO channel thread (outgoing call)
  45  * \param ftdmchan Channel to initiate call on
  46  * \return Success or failure
  47  *
  48  * Initialises state, starts tone progress detection and runs the channel in a new a thread.
  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  * \brief Starts an FXS channel thread (outgoing call)
  72  * \param ftdmchan Channel to initiate call on
  73  * \return Success or failure
  74  *
  75  * Indicates call waiting if channel is already in use, otherwise runs the channel in a new thread.
  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  * \brief Returns the signalling status on a channel
  92  * \param ftdmchan Channel to get status on
  93  * \param status        Pointer to set signalling status
  94  * \return Success or failure
  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  * \brief Returns the signalling status on a span
 109  * \param span Span to get status on
 110  * \param status        Pointer to set signalling status
 111  * \return Success or failure
 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         /* if ALL channels are in alarm, report DOWN, UP otherwise. */
 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  * \brief Starts an analog span thread (monitor)
 140  * \param span Span to monitor
 141  * \return Success or failure
 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  * \brief Stops the analog span thread (monitor)
 152  * \param span Span to stop 
 153  * \return Success or failure
 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  * \brief Initialises an analog span from configuration variables
 173  * \param span Span to configure
 174  * \param sig_cb Callback function for event signals
 175  * \param ap List of configuration variables
 176  * \return Success or failure
 177  */
 178 static FIO_SIG_CONFIGURE_FUNCTION(ftdm_analog_configure_span)
 179 //ftdm_status_t ftdm_analog_configure_span(ftdm_span_t *span, char *tonemap, uint32_t digit_timeout, uint32_t max_dialstr, fio_signal_cb_t sig_cb)
 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  * \brief Retrieves tone generation output to be sent
 322  * \param ts Teletone generator
 323  * \param map Tone map
 324  * \return -1 on error, 0 on success
 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  * \brief Sends caller id on an analog channel (FSK coded)
 341  * \param ftdmchan Channel to send caller id on
 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  * \brief Main thread function for analog channel (outgoing call)
 411  * \param me Current thread
 412  * \param obj Channel to run in this thread
 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                                                         /* do not go up if we're waiting for polarity reversal */
 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                                                 /* if this polarity reverse is close to the answer polarity reverse, ignore it */
 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                                                         /* the polarity may be already reversed if this is the second time we 
 679                                                          * answer (ie, due to 2 calls being on the same line) */
 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                                 /* this state is only used when the user hangup, if the device hang up (onhook) we currently
 710                                  * go straight to DOWN. If we ever change this (as other signaling modules do) by using this
 711                                  * state for both user and device hangup, we should check here for the type of hangup since
 712                                  * some actions (polarity reverse) do not make sense if the device hung up */
 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                         /* we were requested not to wait for dial tone, we can dial immediately */
 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                         //rlen = len;
 890                         //memset(frame, 0, len);
 891                         //ftdm_channel_write(ftdmchan, frame, sizeof(frame), &rlen);
 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  * \brief Processes freetdm event
 973  * \param span Span on which the event was fired
 974  * \param event Event to be treated
 975  * \return Success or failure
 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         /* MAINTENANCE WARNING: 
 995          * 1. Be aware you are working on the locked channel
 996          * 2. We should not be calling ftdm_span_send_signal or ftdm_set_state when there is already a channel thread running
 997          *    however, since this is old code I am not changing it now, but new code should adhere to that convention
 998          *    otherwise, we have possible races where we compete with the user for state changes, ie, the user requests
 999          *    a state change and then we process an event, the state change from the user is pending so our ftdm_set_state
1000          *    operation will fail. In cases where we win the race, our state change will be accepted but if a user requests
1001          *    a state change before the state change we requested here is processed by the channel thread, we'll end up
1002          *    rejecting the user request.
1003          *
1004          *    See docs/locking.txt for further information about what guarantees should signaling modules provide when
1005          *    locking/unlocking a channel
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                                         /* we do not need to process HANGUP since the device also hangup already */
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                                 /* we always return to forward when the device goes onhook */
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                         /* we have a good channel, set the polarity flag and let the channel thread deal with it */
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  * \brief Main thread function for analog span (monitor)
1158  * \param me Current thread
1159  * \param obj Span to run in this thread
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  * \brief FreeTDM analog signaling module initialisation
1217  * \return Success
1218  */
1219 static FIO_SIG_LOAD_FUNCTION(ftdm_analog_init)
1220 {
1221         return FTDM_SUCCESS;
1222 }
1223 
1224 /**
1225  * \brief FreeTDM analog signaling module definition
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 /* For Emacs:
1238  * Local Variables:
1239  * mode:c
1240  * indent-tabs-mode:t
1241  * tab-width:4
1242  * c-basic-offset:4
1243  * End:
1244  * For VIM:
1245  * vim:set softtabstop=4 shiftwidth=4 tabstop=4:
1246  */

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