static void *run_main_schedule(ftdm_thread_t *thread, void *data)
{
int32_t timeto;
int32_t sleepms;
ftdm_status_t status;
ftdm_sched_t *current = NULL;
#ifdef __WINDOWS__
UNREFERENCED_PARAMETER(data);
UNREFERENCED_PARAMETER(thread);
#endif
while (ftdm_running()) {
sleepms = SCHED_MAX_SLEEP;
ftdm_mutex_lock(sched_globals.mutex);
if (!sched_globals.freeruns) {
/* there are no free runs, wait a bit and check again (FIXME: use ftdm_interrupt_t for this) */
ftdm_mutex_unlock(sched_globals.mutex);
if (ftdm_running()) {
ftdm_sleep(sleepms);
}
}
for (current = sched_globals.freeruns; current; current = current->next) {
if (!ftdm_running()) {
break;
}
/* first run the schedule */
ftdm_sched_run(current);
/* now find out how much time to sleep until running them again */
status = ftdm_sched_get_time_to_next_timer(current, &timeto);
if (status != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_WARNING, "Failed to get time to next timer for schedule %s, skipping\n", current->name);
continue;
}
/* if timeto == -1 we don't want to sleep forever, so keep the last sleepms */
if (timeto != -1 && sleepms > timeto) {
sleepms = timeto;
}
}
ftdm_mutex_unlock(sched_globals.mutex);
if (ftdm_running()) {
ftdm_sleep(sleepms);
}
}
ftdm_log(FTDM_LOG_NOTICE, "Main scheduling thread going out ...\n");
sched_globals.running = 0;
return NULL;
}
int main(int argc, char *argv[])
{
ftdm_span_t *span;
ftdm_mutex_create(&mutex);
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
if (argc < 2) {
printf("umm no\n");
exit(-1);
}
if (ftdm_global_init() != FTDM_SUCCESS) {
fprintf(stderr, "Error loading FreeTDM\n");
exit(-1);
}
printf("FreeTDM loaded\n");
if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) {
fprintf(stderr, "Error finding FreeTDM span\n");
goto done;
}
if (ftdm_configure_span("r2", span, on_r2_signal,
"variant", "mx",
"max_ani", 10,
"max_dnis", 4,
"logging", "all",
TAG_END) == FTDM_SUCCESS) {
ftdm_span_start(span);
} else {
fprintf(stderr, "Error starting R2 span\n");
goto done;
}
signal(SIGINT, handle_SIGINT);
ftdm_mutex_lock(mutex);
R = 1;
ftdm_mutex_unlock(mutex);
while(R) {
ftdm_sleep(1 * 1000);
}
done:
ftdm_global_destroy();
return 1;
}
int main(int argc, char *argv[])
{
ftdm_conf_parameter_t parameters[20];
ftdm_span_t *span;
int local_port, remote_port;
local_port = remote_port = 53000;
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
#if 0
if (argc < 2) {
printf("invalid arguments\n");
exit(-1);
}
#endif
if (ftdm_global_init() != FTDM_SUCCESS) {
fprintf(stderr, "Error loading FreeTDM\n");
exit(-1);
}
if (ftdm_global_configuration() != FTDM_SUCCESS) {
fprintf(stderr, "Error configuring FreeTDM\n");
exit(-1);
}
printf("FreeTDM loaded\n");
if (ftdm_span_find_by_name("wp1", &span) != FTDM_SUCCESS) {
fprintf(stderr, "Error finding FreeTDM span %s\n", argv[1]);
goto done;
}
parameters[0].var = "sigmod";
parameters[0].val = "sangoma_prid";
parameters[1].var = "switchtype";
parameters[1].val = "euroisdn";
parameters[1].var = "signalling";
parameters[1].val = "pri_cpe";
parameters[2].var = NULL;
if (ftdm_configure_span_signaling("sangoma_boost", span, on_signal, parameters) == FTDM_SUCCESS) {
ftdm_span_start(span);
} else {
fprintf(stderr, "Error starting SS7_BOOST\n");
goto done;
}
while(ftdm_running() && R) {
ftdm_sleep(1 * 1000);
}
done:
ftdm_global_destroy();
return 0;
}
int main(int argc, char *argv[])
{
ftdm_span_t *span;
int span_id;
int digit_timeout = 2000;
int max_dialstr = 11;
if (argc < 2) {
printf("usage %s <spanno>\n", argv[0]);
exit(-1);
}
span_id = atoi(argv[1]);
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
if (ftdm_global_init() != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "Error loading FreeTDM\n");
exit(-1);
}
ftdm_log(FTDM_LOG_DEBUG, "FreeTDM loaded\n");
if (ftdm_span_find(span_id, &span) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "Error finding FreeTDM span\n");
goto done;
}
if (ftdm_configure_span("analog", span, on_signal,
"tonemap", "us",
"digit_timeout", &digit_timeout,
"max_dialstr", &max_dialstr,
TAG_END
) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_ERROR, "Error configuring FreeTDM span\n");
goto done;
}
ftdm_span_start(span);
R = 1;
while(ftdm_running() && R) {
ftdm_sleep(1 * 1000);
}
done:
ftdm_global_destroy();
return 0;
}
ftdm_status_t sng_isdn_activate_q921(ftdm_span_t *span)
{
ftdm_status_t status;
status = sng_isdn_cntrl_q921(span, ABND_ENA, NOTUSED);
/* Try to find an alternative for this */
/* LAPD will call LdUiDatBndCfm before it received a LdLiMacBndCfm from L1,
so we need to give some time before activating q931, as q931 will send a
LdUiDatConReq when activated, and this requires the Mac SAP to be already
bound first */
if (status == FTDM_SUCCESS) {
ftdm_sleep(500);
}
return status;
}
int main(int argc, char *argv[])
{
ftdm_span_t *span;
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
if (argc < 2) {
printf("umm no\n");
exit(-1);
}
if (ftdm_global_init() != FTDM_SUCCESS) {
fprintf(stderr, "Error loading FreeTDM\n");
exit(-1);
}
printf("FreeTDM loaded\n");
if (ftdm_span_find(atoi(argv[1]), &span) != FTDM_SUCCESS) {
fprintf(stderr, "Error finding FreeTDM span\n");
goto done;
}
if (ftdm_configure_span("isdn", span, on_signal,
"mode", "te",
"dialect", "national",
TAG_END) == FTDM_SUCCESS) {
ftdm_span_start(span);
} else {
fprintf(stderr, "Error starting ISDN D-Channel\n");
goto done;
}
signal(SIGINT, handle_SIGINT);
R = 1;
while(R) {
ftdm_sleep(1 * 1000);
}
done:
ftdm_global_destroy();
return 1;
}
int main(int argc, char *argv[])
{
ftdm_status_t status;
custom_data_t data;
ftdm_sched_t *sched;
signal(SIGINT, trap);
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
ftdm_cpu_monitor_disable();
if (ftdm_global_init() != FTDM_SUCCESS) {
fprintf(stderr, "Error loading FreeTDM\n");
exit(-1);
}
status = ftdm_sched_create(&sched, "testsched");
if (status != FTDM_SUCCESS) {
fprintf(stderr, "Error creating sched\n");
exit(-1);
}
data.sched = sched;
data.counter = 10;
data.beat = 5000;
data.callback = handle_heartbeat;
status = ftdm_sched_timer(sched, "heartbeat", data.beat, data.callback, &data, &data.heartbeat_timer);
if (status != FTDM_SUCCESS) {
fprintf(stderr, "Error creating heartbeat timer\n");
exit(-1);
}
ftdm_sched_free_run(sched);
while (running) {
ftdm_sleep(10);
}
ftdm_global_destroy();
printf("Done, press any key to die!\n");
getchar();
return 0;
}
FT_DECLARE(ftdm_bool_t) ftdm_free_sched_stop(void)
{
/* currently we really dont stop the thread here, we rely on freetdm being shutdown and ftdm_running() to be false
* so the scheduling thread dies and we just wait for it here */
uint32_t sanity = 100;
while (ftdm_free_sched_running() && --sanity) {
ftdm_log(FTDM_LOG_DEBUG, "Waiting for main schedule thread to finish\n");
ftdm_sleep(100);
}
if (!sanity) {
ftdm_log(FTDM_LOG_CRIT, "schedule thread did not stop running, we may crash on shutdown\n");
return FTDM_FALSE;
}
return FTDM_TRUE;
}
static ftdm_status_t ftdm_pritap_stop(ftdm_span_t *span)
{
pritap_t *pritap = span->signal_data;
if (!ftdm_test_flag(pritap, PRITAP_RUNNING)) {
return FTDM_FAIL;
}
ftdm_set_flag(span, FTDM_SPAN_STOP_THREAD);
while (ftdm_test_flag(span, FTDM_SPAN_IN_THREAD)) {
ftdm_sleep(100);
}
ftdm_mutex_destroy(&pritap->pcalls_lock);
return FTDM_SUCCESS;
}
static void *test_call(ftdm_thread_t *me, void *obj)
{
ftdm_channel_t *chan = (ftdm_channel_t *) obj;
uint8_t frame[1024];
ftdm_size_t len;
char *number = strdup("5551212");
ftdm_sleep(10 * 1000);
ftdm_log(FTDM_LOG_DEBUG, "answer call and start echo test\n");
ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_UP);
ftdm_channel_command(chan, FTDM_COMMAND_SEND_DTMF, number);
while (chan->state == FTDM_CHANNEL_STATE_UP) {
ftdm_wait_flag_t flags = FTDM_READ;
if (ftdm_channel_wait(chan, &flags, -1) == FTDM_FAIL) {
break;
}
len = sizeof(frame);
if (flags & FTDM_READ) {
if (ftdm_channel_read(chan, frame, &len) == FTDM_SUCCESS) {
//ftdm_log(FTDM_LOG_DEBUG, "WRITE %d\n", len);
ftdm_channel_write(chan, frame, sizeof(frame), &len);
} else {
break;
}
}
}
if (chan->state == FTDM_CHANNEL_STATE_UP) {
ftdm_set_state_locked(chan, FTDM_CHANNEL_STATE_BUSY);
}
ftdm_log(FTDM_LOG_DEBUG, "call over\n");
free(number);
return NULL;
}
ftdm_status_t sngisdn_stack_start(ftdm_span_t *span)
{
sngisdn_span_data_t *signal_data = (sngisdn_span_data_t*)span->signal_data;
if (signal_data->dchan) {
if (sngisdn_cntrl_q921(span, ABND_ENA, NOTUSED) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_CRIT, "%s:Failed to activate stack q921\n", span->name);
return FTDM_FAIL;
}
ftdm_log(FTDM_LOG_DEBUG, "%s:Stack q921 activated\n", span->name);
}
/* Try to find an alternative for this */
/* LAPD will call LdUiDatBndCfm before it received a LdLiMacBndCfm from L1,
so we need to give some time before activating q931, as q931 will send a
LdUiDatConReq when activated, and this requires the Mac SAP to be already
bound first */
ftdm_sleep(500);
if (!g_sngisdn_data.ccs[signal_data->cc_id].activation_done) {
g_sngisdn_data.ccs[signal_data->cc_id].activation_done = 1;
if (sngisdn_activate_cc(span) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_CRIT, "%s:Failed to activate stack CC\n", span->name);
return FTDM_FAIL;
}
ftdm_log(FTDM_LOG_DEBUG, "%s:Stack CC activated\n", span->name);
}
if (sngisdn_cntrl_q931(span, ABND_ENA, SAELMNT) != FTDM_SUCCESS) {
ftdm_log(FTDM_LOG_CRIT, "%s:Failed to activate stack q931\n", span->name);
return FTDM_FAIL;
}
ftdm_log(FTDM_LOG_DEBUG, "%s:Stack q931 activated\n", span->name);
ftdm_log(FTDM_LOG_INFO, "%s:Stack activated\n",span->name);
return FTDM_SUCCESS;
}
int main(int argc, char *argv[])
{
ftdm_span_t *span;
ftdm_conf_parameter_t parameters[20];
ftdm_mutex_create(&the_mutex);
if (argc < 2) {
printf("umm no\n");
exit(1);
}
ftdm_global_set_default_logger(FTDM_LOG_LEVEL_DEBUG);
if (ftdm_global_init() != FTDM_SUCCESS) {
fprintf(stderr, "Error loading FreeTDM\n");
exit(1);
}
ftdm_global_configuration();
printf("FreeTDM loaded\n");
if (ftdm_span_find_by_name(argv[1], &span) != FTDM_SUCCESS) {
fprintf(stderr, "Error finding FreeTDM span %s\n", argv[1]);
goto done;
}
/* testing non-blocking operation */
//ftdm_span_set_blocking_mode(span, FTDM_FALSE);
parameters[0].var = "variant";
parameters[0].val = "br";
parameters[1].var = "max_ani";
parameters[1].val = "4";
parameters[2].var = "max_dnis";
parameters[2].val = "4";
parameters[3].var = "logging";
parameters[3].val = "all";
parameters[4].var = NULL;
parameters[4].val = NULL;
if (ftdm_configure_span_signaling(span, "r2", on_r2_signal, parameters) == FTDM_SUCCESS) {
ftdm_span_start(span);
} else {
fprintf(stderr, "Error starting R2 span\n");
goto done;
}
running = 1;
signal(SIGINT, stop_test);
while(running) {
ftdm_sleep(20);
if (fchan && indication != FTDM_CHANNEL_INDICATE_NONE) {
ftdm_channel_t *lchan = NULL;
ftdm_channel_indication_t ind = FTDM_CHANNEL_INDICATE_NONE;
ftdm_time_t start, stop, diff;
ftdm_mutex_lock(the_mutex);
ind = indication;
indication = FTDM_CHANNEL_INDICATE_NONE;
lchan = fchan;
ftdm_mutex_unlock(the_mutex);
start = ftdm_current_time_in_ms();
ftdm_channel_call_indicate(lchan, ind);
stop = ftdm_current_time_in_ms();
diff = stop - start;
ftdm_log(FTDM_LOG_DEBUG, "Setting indication %s took %"FTDM_TIME_FMT" ms\n",
ftdm_channel_indication2str(ind), diff);
}
}
done:
ftdm_global_destroy();
return 0;
}
