kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

add guts for zt 

git-svn-id: http://svn.openzap.org/svn/openzap/trunk@185 a93c3328-9c30-0410-af19-c9cd2b2d52af
This commit is contained in:
Anthony Minessale 2007-05-30 01:01:32 +00:00
parent 77634068da
commit a04655dce5
10 changed files with 405 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/freetdm/mod_openzap/Makefile
View File

@ -9,6 +9,6 @@ include $(BASE)/build/modmake.rules
local_depend: $(OZA)
$(OZA):
cd $(OZ_DIR) && $(MAKE) ZAP_MODS=wanpipe
cd $(OZ_DIR) && $(MAKE) ZAP_MODS="wanpipe zt" ZAP_CFLAGS="-g -ggdb"

20
libs/freetdm/src/hashtable.c
View File

@ -213,29 +213,19 @@ hashtable_remove(struct hashtable *h, void *k)
/*****************************************************************************/
/* destroy */
void
hashtable_destroy(struct hashtable *h, int free_values)
hashtable_destroy(struct hashtable *h, int free_keys, int free_values)
{
unsigned int i;
struct entry *e, *f;
struct entry **table = h->table;
if (free_values)
{
for (i = 0; i < h->tablelength; i++)
for (i = 0; i < h->tablelength; i++)
{
e = table[i];
while (NULL != e)
{ f = e; e = e->next; freekey(f->k); free(f->v); free(f); }
{ f = e; e = e->next; if (free_keys) freekey(f->k); if (free_values) free(f->v); free(f); }
}
}
else
{
for (i = 0; i < h->tablelength; i++)
{
e = table[i];
while (NULL != e)
{ f = e; e = e->next; freekey(f->k); free(f); }
}
}
free(h->table);
free(h);
}

2
libs/freetdm/src/include/hashtable.h
View File

@ -166,7 +166,7 @@ hashtable_count(struct hashtable *h);
*/
void
hashtable_destroy(struct hashtable *h, int free_values);
hashtable_destroy(struct hashtable *h, int free_keys, int free_values);
#endif /* __HASHTABLE_CWC22_H__ */

1
libs/freetdm/src/include/zap_types.h
View File

@ -46,6 +46,7 @@ typedef int zap_socket_t;
#endif
typedef size_t zap_size_t;
typedef ssize_t zap_ssize_t;
struct zap_io_interface;
#define ZAP_COMMAND_OBJ_INT *((int *)obj)

6
libs/freetdm/src/include/zap_zt.h
View File

@ -34,6 +34,8 @@
#ifndef ZAP_ZT_H
#define ZAP_ZT_H
#include "openzap.h"
#include <sys/ioctl.h>
#include <poll.h>
/* Hardware interface structures and defines */
/* Based on documentation of the structures required for the hardware interface */
@ -69,6 +71,8 @@ struct zt_params {
int pulse_after_time;
};
typedef struct zt_params zt_params_t;
/* Used with ioctl: ZT_CONFLINK, ZT_GETCONF and ZT_SETCONF */
struct zt_confinfo {
int chan_no; /* Channel Number, 0 for current */
@ -170,7 +174,7 @@ typedef enum {
ZT_MAINT_REMOTELOOP = 2, /* Remote Loopback */
ZT_MAINT_LOOPUP = 3, /* Send Loopup Code */
ZT_MAINT_LOOPDOWN = 4, /* Send Loopdown Code */
ZT_MAINT_LOOPSTOP = 5, /* Stop Sending Loop Codes */
ZT_MAINT_LOOPSTOP = 5 /* Stop Sending Loop Codes */
} zt_maintenance_mode_t;

8
libs/freetdm/src/testanalog.c
View File

@ -71,11 +71,15 @@ int main(int argc, char *argv[])
zap_log(ZAP_LOG_DEBUG, "OpenZAP loaded\n");
if (zap_span_find("wanpipe", 1, &span) != ZAP_SUCCESS) {
if (zap_span_find("zt", 1, &span) != ZAP_SUCCESS) {
zap_log(ZAP_LOG_ERROR, "Error finding OpenZAP span\n");
exit(-1);
}
zap_analog_configure_span(span, "us", 2000, 11, on_signal);
if (zap_analog_configure_span(span, "us", 2000, 11, on_signal) != ZAP_SUCCESS) {
zap_log(ZAP_LOG_ERROR, "Error configuring OpenZAP span\n");
exit(-1);
}
zap_analog_start(span);
while(zap_test_flag(span->analog_data, ZAP_ANALOG_RUNNING)) {

2
libs/freetdm/src/testapp.c
View File

@ -17,7 +17,7 @@ int main(int argc, char *argv[])
top:
//if (zap_channel_open_any("wanpipe", 0, ZAP_TOP_DOWN, &chan) == ZAP_SUCCESS) {
if (zap_channel_open("wanpipe", 1, 1, &chan) == ZAP_SUCCESS) {
if (zap_channel_open("zt", 1, 1, &chan) == ZAP_SUCCESS) {
int x = 0;
printf("opened channel %d:%d\n", chan->span_id, chan->chan_id);

1
libs/freetdm/src/zap_analog.c
View File

@ -253,6 +253,7 @@ static void *zap_analog_channel_run(zap_thread_t *me, void *obj)
}
}
if (last_digit && ((elapsed - last_digit > data->digit_timeout) || strlen(dtmf) > data->max_dialstr)) {
zap_log(ZAP_LOG_DEBUG, "Number obtained [%s]\n", dtmf);
zap_set_state_locked(chan, ZAP_CHANNEL_STATE_IDLE);

19
libs/freetdm/src/zap_io.c
View File

@ -229,9 +229,11 @@ zap_status_t zap_span_close_all(zap_io_interface_t *zio)
span = &zio->spans[i];
for(j = 0; j < span->chan_count; j++) {
zap_mutex_destroy(&span->channels[j].mutex);
zap_buffer_destroy(&span->channels[j].digit_buffer);
zap_buffer_destroy(&span->channels[j].dtmf_buffer);
if (zap_test_flag((&span->channels[j]), ZAP_CHANNEL_CONFIGURED)) {
zap_mutex_destroy(&span->channels[j].mutex);
zap_buffer_destroy(&span->channels[j].digit_buffer);
zap_buffer_destroy(&span->channels[j].dtmf_buffer);
}
}
if (span->mutex) {
@ -1417,7 +1419,8 @@ zap_status_t zap_global_init(void)
modcount = 0;
zap_mutex_create(&globals.mutex);
#ifdef ZAP_WANPIPE_SUPPORT
#ifdef Z
AP_WANPIPE_SUPPORT
if (wanpipe_init(&interfaces.wanpipe_interface) == ZAP_SUCCESS) {
zap_mutex_lock(globals.mutex);
hashtable_insert(globals.interface_hash, (void *)interfaces.wanpipe_interface->name, interfaces.wanpipe_interface);
@ -1483,18 +1486,20 @@ zap_status_t zap_global_destroy(void)
#ifdef ZAP_ZT_SUPPORT
if (interfaces.zt_interface) {
zt_destroy();
zap_span_close_all(interfaces.zt_interface);
zt_destroy();
}
#endif
#ifdef ZAP_WANPIPE_SUPPORT
if (interfaces.wanpipe_interface) {
wanpipe_destroy();
zap_span_close_all(interfaces.wanpipe_interface);
wanpipe_destroy();
}
#endif
hashtable_destroy(globals.interface_hash, 0);
zap_mutex_lock(globals.mutex);
hashtable_destroy(globals.interface_hash, 0, 0);
zap_mutex_unlock(globals.mutex);
zap_mutex_destroy(&globals.mutex);
return ZAP_SUCCESS;
}

373
libs/freetdm/src/zap_zt.c
View File

@ -35,45 +35,393 @@
#include "openzap.h"
#include "zap_zt.h"
static struct {
uint32_t codec_ms;
uint32_t wink_ms;
uint32_t flash_ms;
} zt_globals;
#define ZT_INVALID_SOCKET -1
static unsigned zt_open_range(zap_span_t *span, unsigned start, unsigned end, zap_chan_type_t type, char *name, char *number)
{
unsigned configured = 0, x;
char path[128] = "";
zt_params_t ztp = {0};
for(x = start; x < end; x++) {
zap_channel_t *chan;
zap_socket_t sockfd = ZT_INVALID_SOCKET;
int command;
int len = zt_globals.codec_ms * 8;
snprintf(path, sizeof(path), "/dev/zap/%d", x);
sockfd = open(path, O_RDWR);
if (sockfd != ZT_INVALID_SOCKET && zap_span_add_channel(span, sockfd, type, &chan) == ZAP_SUCCESS) {
command = ZT_START;
#if 0
if (ioctl(sockfd, ZT_HOOK, &command)) {
zap_log(ZAP_LOG_INFO, "failure configuring device %s as OpenZAP device %d:%d fd:%d err:%s\n",
path, chan->span_id, chan->chan_id, sockfd, strerror(errno));
continue;
}
#endif
if (ioctl(chan->sockfd, ZT_SET_BLOCKSIZE, &len)) {
zap_log(ZAP_LOG_INFO, "failure configuring device %s as OpenZAP device %d:%d fd:%d err:%s\n",
path, chan->span_id, chan->chan_id, sockfd, strerror(errno));
close(sockfd);
continue;
} else {
chan->packet_len = len;
chan->effective_interval = chan->native_interval = chan->packet_len / 8;
if (chan->effective_codec == ZAP_CODEC_SLIN) {
chan->packet_len *= 2;
}
}
if (ioctl(sockfd, ZT_GET_PARAMS, &ztp) < 0) {
close(sockfd);
zap_log(ZAP_LOG_INFO, "failure configuring device %s as OpenZAP device %d:%d fd:%d\n", path, chan->span_id, chan->chan_id, sockfd);
continue;
}
zap_log(ZAP_LOG_INFO, "configuring device %s as OpenZAP device %d:%d fd:%d\n", path, chan->span_id, chan->chan_id, sockfd);
if (type == ZAP_CHAN_TYPE_FXS || type == ZAP_CHAN_TYPE_FXO) {
if (ztp.g711_type == ZT_G711_ALAW) {
chan->native_codec = chan->effective_codec = ZAP_CODEC_ALAW;
} else {
chan->native_codec = chan->effective_codec = ZAP_CODEC_ULAW;
}
}
if (!zap_strlen_zero(name)) {
zap_copy_string(chan->chan_name, name, sizeof(chan->chan_name));
}
if (!zap_strlen_zero(number)) {
zap_copy_string(chan->chan_number, number, sizeof(chan->chan_number));
}
configured++;
} else {
zap_log(ZAP_LOG_ERROR, "failure configuring device %s\n", path);
}
}
return configured;
}
static ZIO_CONFIGURE_SPAN_FUNCTION(zt_configure_span)
{
return ZAP_FAIL;
int items, i;
char *mydata, *item_list[10];
char *ch, *mx;
int channo;
int top = 0;
unsigned configured = 0;
assert(str != NULL);
mydata = strdup(str);
assert(mydata != NULL);
items = zap_separate_string(mydata, ',', item_list, (sizeof(item_list) / sizeof(item_list[0])));
for(i = 0; i < items; i++) {
ch = item_list[i];
if (!(ch)) {
zap_log(ZAP_LOG_ERROR, "Invalid input\n");
continue;
}
channo = atoi(ch);
if (channo < 0) {
zap_log(ZAP_LOG_ERROR, "Invalid channel number %d\n", channo);
continue;
}
if ((mx = strchr(ch, '-'))) {
mx++;
top = atoi(mx) + 1;
} else {
top = channo + 1;
}
if (top < 0) {
zap_log(ZAP_LOG_ERROR, "Invalid range number %d\n", top);
continue;
}
configured += zt_open_range(span, channo, top, type, name, number);
}
free(mydata);
return configured;
}
static ZIO_CONFIGURE_FUNCTION(zt_configure)
{
return ZAP_FAIL;
if (!strcasecmp(category, "defaults")) {
if (!strcasecmp(var, "codec_ms")) {
unsigned codec_ms = atoi(val);
if (codec_ms < 10 || codec_ms > 60) {
zap_log(ZAP_LOG_WARNING, "invalid codec ms at line %d\n", lineno);
} else {
zt_globals.codec_ms = codec_ms;
}
}
}
return ZAP_SUCCESS;
}
static ZIO_OPEN_FUNCTION(zt_open)
{
ZIO_OPEN_MUZZLE;
return ZAP_FAIL;
return ZAP_SUCCESS;
}
static ZIO_CLOSE_FUNCTION(zt_close)
{
ZIO_CLOSE_MUZZLE;
return ZAP_FAIL;
return ZAP_SUCCESS;
}
static ZIO_COMMAND_FUNCTION(zt_command)
{
return ZAP_FAIL;
zt_params_t ztp = {0};
int err = 0;
ZIO_COMMAND_MUZZLE;
switch(command) {
case ZAP_COMMAND_GET_INTERVAL:
{
if (!(err = ioctl(zchan->sockfd, ZT_GET_BLOCKSIZE, &zchan->packet_len))) {
zchan->native_interval = zchan->packet_len / 8;
if (zchan->effective_codec == ZAP_CODEC_SLIN) {
zchan->packet_len *= 2;
}
ZAP_COMMAND_OBJ_INT = zchan->native_interval;
}
}
break;
case ZAP_COMMAND_SET_INTERVAL:
{
int interval = ZAP_COMMAND_OBJ_INT;
int len = interval * 8;
if (!(err = ioctl(zchan->sockfd, ZT_SET_BLOCKSIZE, &len))) {
zchan->packet_len = len;
zchan->effective_interval = zchan->native_interval = zchan->packet_len / 8;
if (zchan->effective_codec == ZAP_CODEC_SLIN) {
zchan->packet_len *= 2;
}
}
}
break;
default:
break;
};
if (err) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "%s", strerror(errno));
return ZAP_FAIL;
}
return ZAP_SUCCESS;
}
static ZIO_WAIT_FUNCTION(zt_wait)
{
return ZAP_FAIL;
int32_t inflags = 0;
int result;
struct pollfd pfds[1];
if (*flags & ZAP_READ) {
inflags |= POLLIN;
}
if (*flags & ZAP_WRITE) {
inflags |= POLLOUT;
}
if (*flags & ZAP_EVENTS) {
inflags |= POLLPRI;
}
memset(&pfds[0], 0, sizeof(pfds[0]));
pfds[0].fd = zchan->sockfd;
pfds[0].events = inflags;
result = poll(pfds, 1, to);
*flags = 0;
if (pfds[0].revents & POLLERR) {
result = -1;
}
if (result > 0) {
*flags = pfds[0].revents;
}
*flags = ZAP_NO_FLAGS;
if (result < 0){
snprintf(zchan->last_error, sizeof(zchan->last_error), "Poll failed");
return ZAP_FAIL;
}
if (result == 0) {
return ZAP_TIMEOUT;
}
if (inflags & POLLIN) {
*flags |= ZAP_READ;
}
if (inflags & POLLOUT) {
*flags |= ZAP_WRITE;
}
if (inflags & POLLPRI) {
*flags |= ZAP_EVENTS;
}
return ZAP_SUCCESS;
}
ZIO_SPAN_POLL_EVENT_FUNCTION(zt_poll_event)
{
struct pollfd pfds[ZAP_MAX_CHANNELS_SPAN];
int i, j = 0, k = 0, r, e;
for(i = 1; i <= span->chan_count; i++) {
e = ZT_IOMUX_SIGEVENT;
memset(&pfds[j], 0, sizeof(pfds[j]));
pfds[j].fd = span->channels[i].sockfd;
pfds[j].events = POLLPRI;
ioctl(span->channels[i].sockfd ,ZT_IOMUX, &e);
j++;
}
r = poll(pfds, j, ms);
if (r == 0) {
return ZAP_TIMEOUT;
} else if (r < 0 || (pfds[i-1].revents & POLLERR)) {
snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno));
return ZAP_FAIL;
}
for(i = 1; i <= span->chan_count; i++) {
if (pfds[i-1].revents & POLLPRI) {
zap_set_flag((&span->channels[i]), ZAP_CHANNEL_EVENT);
span->channels[i].last_event_time = zap_current_time_in_ms();
k++;
}
}
return k ? ZAP_SUCCESS : ZAP_FAIL;
}
ZIO_SPAN_NEXT_EVENT_FUNCTION(zt_next_event)
{
uint32_t i, event_id;
zap_oob_event_t zt_event_id;
for(i = 1; i <= span->chan_count; i++) {
if (zap_test_flag((&span->channels[i]), ZAP_CHANNEL_EVENT)) {
zap_clear_flag((&span->channels[i]), ZAP_CHANNEL_EVENT);
if (ioctl(span->channels[i].sockfd, ZT_GETEVENT, &zt_event_id) == -1) {
snprintf(span->last_error, sizeof(span->last_error), "%s", strerror(errno));
return ZAP_FAIL;
}
switch(zt_event_id) {
case ZT_EVENT_ONHOOK:
{
event_id = ZAP_OOB_ONHOOK;
}
break;
case ZT_EVENT_RINGOFFHOOK:
{
if (span->channels[i].type == ZAP_CHAN_TYPE_FXS) {
event_id = ZAP_OOB_OFFHOOK;
} else if (span->channels[i].type == ZAP_CHAN_TYPE_FXO) {
event_id = ZAP_OOB_RING_START;
}
}
break;
default:
{
zap_log(ZAP_LOG_WARNING, "Unhandled event %d\n", zt_event_id);
event_id = ZAP_OOB_INVALID;
}
break;
}
event:
span->channels[i].last_event_time = 0;
span->event_header.e_type = ZAP_EVENT_OOB;
span->event_header.enum_id = event_id;
span->event_header.channel = &span->channels[i];
*event = &span->event_header;
return ZAP_SUCCESS;
}
}
return ZAP_FAIL;
}
static ZIO_READ_FUNCTION(zt_read)
{
zap_ssize_t r = 0;
*datalen = zchan->packet_len;
r = read(zchan->sockfd, data, *datalen);
if (r >= 0) {
*datalen = r;
return ZAP_SUCCESS;
}
return ZAP_FAIL;
}
static ZIO_WRITE_FUNCTION(zt_write)
{
zap_ssize_t w = 0;
w = write(zchan->sockfd, data, *datalen);
if (w >= 0) {
*datalen = w;
return ZAP_SUCCESS;
}
return ZAP_FAIL;
}
@ -83,17 +431,26 @@ zap_status_t zt_init(zap_io_interface_t **zio)
{
assert(zio != NULL);
memset(&zt_interface, 0, sizeof(zt_interface));
memset(&zt_globals, 0, sizeof(zt_globals));
zt_globals.codec_ms = 20;
zt_globals.wink_ms = 150;
zt_globals.flash_ms = 750;
zt_interface.name = "zt";
zt_interface.configure = zt_configure;
zt_interface.configure = zt_configure;
zt_interface.configure_span = zt_configure_span;
zt_interface.open = zt_open;
zt_interface.close = zt_close;
zt_interface.wait = zt_wait;
zt_interface.read = zt_read;
zt_interface.write = zt_write;
zt_interface.poll_event = zt_poll_event;
zt_interface.next_event = zt_next_event;
*zio = &zt_interface;
return ZAP_FAIL;
return ZAP_SUCCESS;
}
zap_status_t zt_destroy(void)