{17, LPWRAP_PRI_EVENT_PROGRESS, "PROGRESS"},
{18, LPWRAP_PRI_EVENT_KEYPAD_DIGIT, "KEYPAD_DIGIT"},
{19, LPWRAP_PRI_EVENT_IO_FAIL, "IO_FAIL"},
- {20, LPWRAP_PRI_EVENT_TIME_CHECK, "TIME_CHECK"}
};
#define LINE "--------------------------------------------------------------------------------"
res+=2;
//print_bits(buf, res-2, bb, sizeof(bb), 1, 0);
- //zap_log(ZAP_LOG_DEBUG, "READ %d\n%s\n%s\n\n", res-2, LINE, bb);
+ //zap_log(ZAP_LOG_DEBUG, "READ %d\n", res-2);
return res;
}
}
//print_bits(buf, (int)buflen-2, bb, sizeof(bb), 1, 0);
- //zap_log(ZAP_LOG_DEBUG, "WRITE %d\n%s\n%s\n\n", (int)buflen-2, LINE, bb);
+ //zap_log(ZAP_LOG_DEBUG, "WRITE %d\n", (int)buflen-2);
return (int) buflen;
}
spri->dchan = dchan;
if ((spri->pri = pri_new_cb(spri->dchan->sockfd, node, swtype, __pri_lpwrap_read, __pri_lpwrap_write, spri))){
+ unsigned char buf[4] = { 0 };
+ size_t buflen = sizeof(buf), len = 0;
spri->span = span;
pri_set_debug(spri->pri, debug);
ret = 0;
zap_set_flag(spri, LPWRAP_PRI_READY);
+ zap_channel_write(spri->dchan, buf, buflen, &len);
} else {
fprintf(stderr, "Unable to create PRI\n");
}
int sel;
if (spri->on_loop) {
- spri->on_loop(spri);
+ if ((sel = spri->on_loop(spri)) < 0) {
+ return sel;
+ }
+ }
+
+ if (!zap_test_flag(spri, LPWRAP_PRI_READY)) {
+ return -1;
}
FD_ZERO(&rfds);
event = NULL;
if (!sel) {
- if ((handler = spri->eventmap[LPWRAP_PRI_EVENT_TIME_CHECK] ?
- spri->eventmap[LPWRAP_PRI_EVENT_TIME_CHECK] : spri->eventmap[0] ? spri->eventmap[0] : NULL)) {
- if (handler(spri, LPWRAP_PRI_EVENT_TIME_CHECK, NULL) < 0) {
- return -1;
- }
- }
-
if ((next = pri_schedule_next(spri->pri))) {
gettimeofday(&now, NULL);
if (now.tv_sec >= next->tv_sec && (now.tv_usec >= next->tv_usec || next->tv_usec <= 100000)) {
return flags;
}
+static zap_io_interface_t zap_libpri_interface;
+static zap_status_t zap_libpri_start(zap_span_t *span);
static ZIO_API_FUNCTION(zap_libpri_api)
{
argc = zap_separate_string(mycmd, ' ', argv, (sizeof(argv) / sizeof(argv[0])));
}
+ if (argc == 2) {
+ if (!strcasecmp(argv[0], "kill")) {
+ int span_id = atoi(argv[1]);
+ zap_span_t *span = NULL;
+
+ if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS || zap_span_find(span_id, &span) == ZAP_SUCCESS) {
+ zap_libpri_data_t *isdn_data = span->signal_data;
+
+ if (span->start != zap_libpri_start) {
+ stream->write_function(stream, "%s: -ERR invalid span.\n", __FILE__);
+ goto done;
+ }
+
+ zap_clear_flag((&isdn_data->spri), LPWRAP_PRI_READY);
+ stream->write_function(stream, "%s: +OK killed.\n", __FILE__);
+ goto done;
+ } else {
+ stream->write_function(stream, "%s: -ERR invalid span.\n", __FILE__);
+ goto done;
+ }
+ }
+ }
if (argc > 2) {
if (!strcasecmp(argv[0], "debug")) {
- int span_id = atoi(argv[1]);
zap_span_t *span = NULL;
- if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS || zap_span_find(span_id, &span) == ZAP_SUCCESS) {
+ if (zap_span_find_by_name(argv[1], &span) == ZAP_SUCCESS) {
zap_libpri_data_t *isdn_data = span->signal_data;
+ if (span->start != zap_libpri_start) {
+ stream->write_function(stream, "%s: -ERR invalid span.\n", __FILE__);
+ goto done;
+ }
+
pri_set_debug(isdn_data->spri.pri, parse_debug(argv[2]));
stream->write_function(stream, "%s: +OK debug set.\n", __FILE__);
goto done;
goto done;
}
}
+
}
stream->write_function(stream, "%s: -ERR invalid command.\n", __FILE__);
}
-static zap_io_interface_t zap_libpri_interface;
-
static ZIO_IO_LOAD_FUNCTION(zap_libpri_io_init)
{
assert(zio != NULL);
{
pri_set_error(s_pri_error);
pri_set_message(s_pri_message);
-
return ZAP_SUCCESS;
}
check_state(span);
+ if (!zap_running() || zap_test_flag(span, ZAP_SPAN_STOP_THREAD)) {
+ return -1;
+ }
+
return 0;
}
}
-static int on_time_check(lpwrap_pri_t *spri, lpwrap_pri_event_t event_type, pri_event *pevent)
-{
-
- if (!zap_running() || zap_test_flag(spri->span, ZAP_SPAN_STOP_THREAD)) {
- return -1;
- }
-
- return 0;
-}
-
-
static void *zap_libpri_run(zap_thread_t *me, void *obj)
{
zap_span_t *span = (zap_span_t *) obj;
zap_libpri_data_t *isdn_data = span->signal_data;
int x, i;
+ int down = 0;
zap_set_flag(span, ZAP_SPAN_IN_THREAD);
LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_INFO_RECEIVED, on_info);
LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_RESTART, on_restart);
LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_IO_FAIL, on_io_fail);
- LPWRAP_MAP_PRI_EVENT(isdn_data->spri, LPWRAP_PRI_EVENT_TIME_CHECK, on_time_check);
-
+
+ if (down) {
+ zap_log(ZAP_LOG_INFO, "PRI back up on span %d\n", isdn_data->spri.span->span_id);
+ zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART);
+ down = 0;
+ }
isdn_data->spri.on_loop = check_flags;
isdn_data->spri.private_info = span;
break;
}
- zap_log(ZAP_LOG_CRIT, "PRI down on span %d\n", isdn_data->spri.span);
+ zap_log(ZAP_LOG_CRIT, "PRI down on span %d\n", isdn_data->spri.span->span_id);
+ zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART);
+ check_state(span);
+ check_state(span);
+ down++;
zap_sleep(5000);
}
+ zap_log(ZAP_LOG_DEBUG, "PRI thread ended on span %d\n", isdn_data->spri.span->span_id);
+
zap_clear_flag(span, ZAP_SPAN_IN_THREAD);
-
+ zap_clear_flag(isdn_data, OZMOD_LIBPRI_RUNNING);
+
return NULL;
}
+
static zap_status_t zap_libpri_stop(zap_span_t *span)
{
+ zap_libpri_data_t *isdn_data = span->signal_data;
+
+ if (!zap_test_flag(isdn_data, OZMOD_LIBPRI_RUNNING)) {
+ return ZAP_FAIL;
+ }
+
+ zap_set_state_all(span, ZAP_CHANNEL_STATE_RESTART);
+ check_state(span);
zap_set_flag(span, ZAP_SPAN_STOP_THREAD);
while(zap_test_flag(span, ZAP_SPAN_IN_THREAD)) {
zap_sleep(100);
}
+ check_state(span);
+
return ZAP_SUCCESS;
}
static zap_status_t zap_libpri_start(zap_span_t *span)
{
zap_status_t ret;
-
zap_libpri_data_t *isdn_data = span->signal_data;
+ if (zap_test_flag(isdn_data, OZMOD_LIBPRI_RUNNING)) {
+ return ZAP_FAIL;
+ }
+
+ zap_clear_flag(span, ZAP_SPAN_STOP_THREAD);
+ zap_clear_flag(span, ZAP_SPAN_IN_THREAD);
+
zap_set_flag(isdn_data, OZMOD_LIBPRI_RUNNING);
ret = zap_thread_create_detached(zap_libpri_run, span);
}
-
static int str2node(char *node)
{
if (!strcasecmp(node, "cpe") || !strcasecmp(node, "user"))
zap_hash_t *module_hash;
zap_hash_t *span_hash;
zap_mutex_t *mutex;
- struct zap_span *spans[ZAP_MAX_SPANS_INTERFACE+1];
+ zap_mutex_t *span_mutex;
uint32_t span_index;
uint32_t running;
+ zap_span_t *spans;
} globals;
return status;
}
-OZ_DECLARE(zap_status_t) zap_span_create(zap_io_interface_t *zio, zap_span_t **span)
+static void zap_span_add(zap_span_t *span)
+{
+ zap_span_t *sp;
+ zap_mutex_lock(globals.span_mutex);
+ for (sp = globals.spans; sp && sp->next; sp = sp->next);
+ if (sp) {
+ sp->next = span;
+ } else {
+ globals.spans = span;
+ }
+ hashtable_insert(globals.span_hash, (void *)span->name, span, HASHTABLE_FLAG_NONE);
+ zap_mutex_unlock(globals.span_mutex);
+}
+
+#if 0
+static void zap_span_del(zap_span_t *span)
+{
+ zap_span_t *last = NULL, *sp;
+
+ zap_mutex_lock(globals.span_mutex);
+ for (sp = globals.spans; sp; sp = sp->next) {
+
+ if (sp == span) {
+ if (last) {
+ last->next = sp->next;
+ } else {
+ globals.spans = sp->next;
+ }
+ hashtable_remove(globals.span_hash, (void *)sp->name);
+ break;
+ }
+
+ last = sp;
+ }
+ zap_mutex_unlock(globals.span_mutex);
+}
+#endif
+
+OZ_DECLARE(zap_status_t) zap_span_stop(zap_span_t *span)
+{
+ if (span->stop) {
+ span->stop(span);
+ return ZAP_SUCCESS;
+ }
+
+ return ZAP_FAIL;
+}
+
+OZ_DECLARE(zap_status_t) zap_span_create(zap_io_interface_t *zio, zap_span_t **span, const char *name)
{
zap_span_t *new_span = NULL;
zap_status_t status = ZAP_FAIL;
assert(zio != NULL);
zap_mutex_lock(globals.mutex);
+
if (globals.span_index < ZAP_MAX_SPANS_INTERFACE) {
- new_span = globals.spans[++globals.span_index];
- if (!new_span) {
- if (!(new_span = malloc(sizeof(*new_span)))) {
- goto done;
- }
- globals.spans[globals.span_index] = new_span;
- }
+ new_span = malloc(sizeof(*new_span));
+ assert(new_span);
memset(new_span, 0, sizeof(*new_span));
status = zap_mutex_create(&new_span->mutex);
- if (status != ZAP_SUCCESS) {
- goto done;
- }
+ assert(status == ZAP_SUCCESS);
+
zap_set_flag(new_span, ZAP_SPAN_CONFIGURED);
- new_span->span_id = globals.span_index;
+ new_span->span_id = ++globals.span_index;
new_span->zio = zio;
zap_copy_string(new_span->tone_map[ZAP_TONEMAP_DIAL], "%(1000,0,350,440)", ZAP_TONEMAP_LEN);
zap_copy_string(new_span->tone_map[ZAP_TONEMAP_RING], "%(2000,4000,440,480)", ZAP_TONEMAP_LEN);
zap_copy_string(new_span->tone_map[ZAP_TONEMAP_ATTN], "%(100,100,1400,2060,2450,2600)", ZAP_TONEMAP_LEN);
new_span->trunk_type = ZAP_TRUNK_NONE;
new_span->data_type = ZAP_TYPE_SPAN;
+
+ zap_mutex_lock(globals.span_mutex);
+ if (!zap_strlen_zero(name) && hashtable_search(globals.span_hash, (void *)name)) {
+ zap_log(ZAP_LOG_WARNING, "name %s is already used, substituting 'span%d' as the name\n", name, new_span->span_id);
+ name = NULL;
+ }
+ zap_mutex_unlock(globals.span_mutex);
+
+ if (!name) {
+ char buf[128] = "";
+ snprintf(buf, sizeof(buf), "span%d", new_span->span_id);
+ name = buf;
+ }
+ new_span->name = strdup(name);
+ zap_span_add(new_span);
*span = new_span;
status = ZAP_SUCCESS;
}
-
-done:
zap_mutex_unlock(globals.mutex);
return status;
}
OZ_DECLARE(zap_status_t) zap_span_close_all(void)
{
zap_span_t *span;
- uint32_t i, j;
+ uint32_t i = 0, j;
- zap_mutex_lock(globals.mutex);
- for(i = 1; i <= globals.span_index; i++) {
- span = globals.spans[i];
+ zap_mutex_lock(globals.span_mutex);
+ for (span = globals.spans; span; span = span->next) {
if (zap_test_flag(span, ZAP_SPAN_CONFIGURED)) {
for(j = 1; j <= span->chan_count && span->channels[j]; j++) {
zap_channel_destroy(span->channels[j]);
+ i++;
}
}
}
- zap_mutex_unlock(globals.mutex);
+ zap_mutex_unlock(globals.span_mutex);
return i ? ZAP_SUCCESS : ZAP_FAIL;
}
{
zap_status_t status = ZAP_FAIL;
- zap_mutex_lock(globals.mutex);
- if (!zap_strlen_zero(name) && (*span = hashtable_search(globals.span_hash, (void *)name))) {
- status = ZAP_SUCCESS;
- }
- zap_mutex_unlock(globals.mutex);
+ zap_mutex_lock(globals.span_mutex);
+ if (!zap_strlen_zero(name)) {
+ if ((*span = hashtable_search(globals.span_hash, (void *)name))) {
+ status = ZAP_SUCCESS;
+ } else {
+ int span_id = atoi(name);
+ zap_span_find(span_id, span);
+ if (*span) {
+ status = ZAP_SUCCESS;
+ }
+ }
+ }
+ zap_mutex_unlock(globals.span_mutex);
+
return status;
}
OZ_DECLARE(zap_status_t) zap_span_find(uint32_t id, zap_span_t **span)
{
- zap_span_t *fspan;
+ zap_span_t *fspan = NULL, *sp;
if (id > ZAP_MAX_SPANS_INTERFACE) {
return ZAP_FAIL;
}
- zap_mutex_lock(globals.mutex);
- fspan = globals.spans[id];
- zap_mutex_unlock(globals.mutex);
+ zap_mutex_lock(globals.span_mutex);
+ for (sp = globals.spans; sp; sp = sp->next) {
+ if (sp->span_id == id) {
+ fspan = sp;
+ break;
+ }
+ }
+ zap_mutex_unlock(globals.span_mutex);
if (!fspan || !zap_test_flag(fspan, ZAP_SPAN_CONFIGURED)) {
return ZAP_FAIL;
zap_status_t status = ZAP_FAIL;
zap_channel_t *check;
uint32_t i,j;
- zap_span_t *span;
+ zap_span_t *span = NULL;
uint32_t span_max;
if (span_id) {
- if (span_id > globals.span_index || !globals.spans[span_id]) {
+ zap_span_find(span_id, &span);
+
+ if (!span || !zap_test_flag(span, ZAP_SPAN_CONFIGURED)) {
zap_log(ZAP_LOG_CRIT, "SPAN NOT DEFINED!\n");
*zchan = NULL;
return ZAP_FAIL;
}
- if (globals.spans[span_id]->active_count >= globals.spans[span_id]->chan_count) {
+ if (span->active_count >= span->chan_count) {
zap_log(ZAP_LOG_CRIT, "All circuits are busy.\n");
*zchan = NULL;
return ZAP_FAIL;
}
- if (globals.spans[span_id]->channel_request && !globals.spans[span_id]->suggest_chan_id) {
- return globals.spans[span_id]->channel_request(globals.spans[span_id], 0, direction, caller_data, zchan);
+ if (span->channel_request && !span->suggest_chan_id) {
+ return span->channel_request(span, 0, direction, caller_data, zchan);
}
span_max = span_id;
j = span_id;
} else {
- span_max = globals.span_index;
- if (direction == ZAP_TOP_DOWN) {
- j = 1;
- } else {
- j = span_max;
- }
+ zap_log(ZAP_LOG_CRIT, "No span supplied\n");
+ *zchan = NULL;
+ return ZAP_FAIL;
}
+ zap_mutex_lock(span->mutex);
+
+ if (direction == ZAP_TOP_DOWN) {
+ i = 1;
+ } else {
+ i = span->chan_count;
+ }
+
for(;;) {
+
if (direction == ZAP_TOP_DOWN) {
- if (j > span_max) {
- goto done;
+ if (i > span->chan_count) {
+ break;
}
} else {
- if (j == 0) {
- goto done;
+ if (i == 0) {
+ break;
}
}
-
- span = globals.spans[j];
- zap_mutex_lock(span->mutex);
-
- if (!zap_test_flag(span, ZAP_SPAN_CONFIGURED)) {
- goto next_loop;
+
+ if (!(check = span->channels[i])) {
+ status = ZAP_FAIL;
+ zap_mutex_unlock(span->mutex);
+ goto done;
}
-
- if (direction == ZAP_TOP_DOWN) {
- i = 1;
- } else {
- i = span->chan_count;
- }
-
- for(;;) {
-
- if (direction == ZAP_TOP_DOWN) {
- if (i > span->chan_count) {
- break;
- }
- } else {
- if (i == 0) {
- break;
- }
- }
- if (!(check = span->channels[i])) {
- status = ZAP_FAIL;
+ if (zap_test_flag(check, ZAP_CHANNEL_READY) &&
+ !zap_test_flag(check, ZAP_CHANNEL_INUSE) &&
+ !zap_test_flag(check, ZAP_CHANNEL_SUSPENDED) &&
+ check->state == ZAP_CHANNEL_STATE_DOWN
+ ) {
+
+ if (span && span->channel_request) {
+ status = span->channel_request(span, i, direction, caller_data, zchan);
zap_mutex_unlock(span->mutex);
goto done;
}
-
- if (zap_test_flag(check, ZAP_CHANNEL_READY) &&
- !zap_test_flag(check, ZAP_CHANNEL_INUSE) &&
- !zap_test_flag(check, ZAP_CHANNEL_SUSPENDED) &&
- check->state == ZAP_CHANNEL_STATE_DOWN
- ) {
-
- if (globals.spans[span_id] && globals.spans[span_id]->channel_request) {
- status = globals.spans[span_id]->channel_request(globals.spans[span_id], i, direction, caller_data, zchan);
- zap_mutex_unlock(span->mutex);
- goto done;
- }
- status = check->zio->open(check);
+ status = check->zio->open(check);
- if (status == ZAP_SUCCESS) {
- zap_set_flag(check, ZAP_CHANNEL_INUSE);
- zap_channel_open_chan(check);
- *zchan = check;
- zap_mutex_unlock(span->mutex);
- goto done;
- }
- }
-
- if (direction == ZAP_TOP_DOWN) {
- i++;
- } else {
- i--;
+ if (status == ZAP_SUCCESS) {
+ zap_set_flag(check, ZAP_CHANNEL_INUSE);
+ zap_channel_open_chan(check);
+ *zchan = check;
+ zap_mutex_unlock(span->mutex);
+ goto done;
}
}
- next_loop:
-
- zap_mutex_unlock(span->mutex);
-
if (direction == ZAP_TOP_DOWN) {
- j++;
+ i++;
} else {
- j--;
+ i--;
}
}
done:
-
+
return status;
}
{
zap_channel_t *check;
zap_status_t status = ZAP_FAIL;
+ zap_span_t *span = NULL;
- zap_mutex_lock(globals.mutex);
+ zap_mutex_unlock(globals.mutex);
+ zap_span_find(span_id, &span);
- if (span_id > globals.span_index || chan_id >= ZAP_MAX_CHANNELS_SPAN || !globals.spans[span_id]) {
- zap_log(ZAP_LOG_ERROR, "SPAN NOT DEFINED!\n");
+ if (!span || !zap_test_flag(span, ZAP_SPAN_CONFIGURED) || chan_id >= ZAP_MAX_CHANNELS_SPAN) {
+ zap_log(ZAP_LOG_CRIT, "SPAN NOT DEFINED!\n");
*zchan = NULL;
- goto done;
+ goto done;
}
- if (globals.spans[span_id]->channel_request) {
+ if (span->channel_request) {
zap_log(ZAP_LOG_ERROR, "Individual channel selection not implemented on this span.\n");
*zchan = NULL;
goto done;
}
- check = globals.spans[span_id]->channels[chan_id];
+ check = span->channels[chan_id];
if (zap_test_flag(check, ZAP_CHANNEL_SUSPENDED) ||
!zap_test_flag(check, ZAP_CHANNEL_READY) || (status = zap_mutex_trylock(check->mutex)) != ZAP_SUCCESS) {
continue;
}
- if (zap_span_create(zio, &span) == ZAP_SUCCESS) {
+ if (zap_span_create(zio, &span, name) == ZAP_SUCCESS) {
span->type = strdup(type);
d = 0;
- zap_mutex_lock(globals.mutex);
- if (!zap_strlen_zero(name) && hashtable_search(globals.span_hash, (void *)name)) {
- zap_log(ZAP_LOG_WARNING, "name %s is already used, substituting 'span%d' as the name\n", name, span->span_id);
- name = NULL;
- }
-
- if (!name) {
- char buf[128] = "";
- snprintf(buf, sizeof(buf), "span%d", span->span_id);
- name = buf;
- }
- span->name = strdup(name);
- hashtable_insert(globals.span_hash, (void *)span->name, span, HASHTABLE_FLAG_NONE);
- zap_mutex_unlock(globals.mutex);
-
zap_log(ZAP_LOG_DEBUG, "created span %d (%s) of type %s\n", span->span_id, span->name, type);
} else {
globals.span_hash = create_hashtable(16, zap_hash_hashfromstring, zap_hash_equalkeys);
modcount = 0;
zap_mutex_create(&globals.mutex);
+ zap_mutex_create(&globals.span_mutex);
modcount = zap_load_modules();
zap_log(ZAP_LOG_NOTICE, "Modules configured: %d \n", modcount);
OZ_DECLARE(zap_status_t) zap_global_destroy(void)
{
- unsigned int i,j;
+ unsigned int j;
+ zap_span_t *sp;
+
time_end();
globals.running = 0;
zap_span_close_all();
zap_sleep(1000);
- for(i = 1; i <= globals.span_index; i++) {
- zap_span_t *cur_span = globals.spans[i];
+ zap_mutex_lock(globals.span_mutex);
+ for (sp = globals.spans; sp;) {
+ zap_span_t *cur_span = sp;
+ sp = sp->next;
if (cur_span) {
if (zap_test_flag(cur_span, ZAP_SPAN_CONFIGURED)) {
zap_safe_free(cur_span->signal_data);
zap_span_destroy(cur_span);
}
- zap_mutex_lock(globals.mutex);
+
hashtable_remove(globals.span_hash, (void *)cur_span->name);
- zap_mutex_unlock(globals.mutex);
zap_safe_free(cur_span->type);
zap_safe_free(cur_span->name);
free(cur_span);
cur_span = NULL;
}
}
+ globals.spans = NULL;
+ zap_mutex_unlock(globals.span_mutex);
+
globals.span_index = 0;
zap_unload_modules();
hashtable_destroy(globals.span_hash);
zap_mutex_unlock(globals.mutex);
zap_mutex_destroy(&globals.mutex);
+ zap_mutex_destroy(&globals.span_mutex);
memset(&globals, 0, sizeof(globals));
return ZAP_SUCCESS;
projects / thirdparty / freeswitch.git / commitdiff
