#endif
typedef size_t zap_size_t;
-struct zap_software_interface;
+struct zap_io_interface;
#define ZAP_COMMAND_OBJ_INT *((int *)obj)
#define ZAP_COMMAND_OBJ_CHAR_P (char *)obj
+typedef enum {
+ ZAP_SIGTYPE_NONE,
+ ZAP_SIGTYPE_ISDN,
+ ZAP_SIGTYPE_RBS,
+ ZAP_SIGTYPE_ANALOG
+} zap_signal_type_t;
+
+typedef enum {
+ ZAP_SIGEVENT_CALL_START,
+ ZAP_SIGEVENT_CALL_STOP,
+ ZAP_SIGEVENT_CALL_TRANSFER,
+ ZAP_SIGEVENT_ANSWER,
+ ZAP_SIGEVENT_PROGRESS,
+ ZAP_SIGEVENT_PROGRESS_MEDIA,
+ ZAP_SIGEVENT_NOTIFY,
+ ZAP_SIGEVENT_MISC
+} zap_signal_event_t;
+
+typedef enum {
+ ZAP_EVENT_NONE,
+ ZAP_EVENT_DTMF,
+
+ ZAP_EVENT_COUNT
+} zap_event_type_t;
+
typedef enum {
ZAP_TOP_DOWN,
ZAP_BOTTOM_UP
typedef struct zap_channel zap_channel_t;
typedef struct zap_event zap_event_t;
-#define ZINT_EVENT_CB_ARGS (zap_channel_t *zchan, zap_event_t *event)
-#define ZINT_CODEC_ARGS (void *data, zap_size_t max, zap_size_t *datalen)
-#define ZINT_CONFIGURE_ARGS (struct zap_software_interface *zint)
-#define ZINT_OPEN_ARGS (zap_channel_t *zchan)
-#define ZINT_CLOSE_ARGS (zap_channel_t *zchan)
-#define ZINT_COMMAND_ARGS (zap_channel_t *zchan, zap_command_t command, void *obj)
-#define ZINT_WAIT_ARGS (zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to)
-#define ZINT_READ_ARGS (zap_channel_t *zchan, void *data, zap_size_t *datalen)
-#define ZINT_WRITE_ARGS (zap_channel_t *zchan, void *data, zap_size_t *datalen)
-
-typedef zap_status_t (*zint_event_cb_t) ZINT_EVENT_CB_ARGS ;
-typedef zap_status_t (*zint_codec_t) ZINT_CODEC_ARGS ;
-typedef zap_status_t (*zint_configure_t) ZINT_CONFIGURE_ARGS ;
-typedef zap_status_t (*zint_open_t) ZINT_OPEN_ARGS ;
-typedef zap_status_t (*zint_close_t) ZINT_CLOSE_ARGS ;
-typedef zap_status_t (*zint_command_t) ZINT_COMMAND_ARGS ;
-typedef zap_status_t (*zint_wait_t) ZINT_WAIT_ARGS ;
-typedef zap_status_t (*zint_read_t) ZINT_READ_ARGS ;
-typedef zap_status_t (*zint_write_t) ZINT_WRITE_ARGS ;
-
-#define ZINT_EVENT_CB_FUNCTION(name) zap_status_t name ZINT_EVENT_CB_ARGS
-#define ZINT_CODEC_FUNCTION(name) zap_status_t name ZINT_CODEC_ARGS
-#define ZINT_CONFIGURE_FUNCTION(name) zap_status_t name ZINT_CONFIGURE_ARGS
-#define ZINT_OPEN_FUNCTION(name) zap_status_t name ZINT_OPEN_ARGS
-#define ZINT_CLOSE_FUNCTION(name) zap_status_t name ZINT_CLOSE_ARGS
-#define ZINT_COMMAND_FUNCTION(name) zap_status_t name ZINT_COMMAND_ARGS
-#define ZINT_WAIT_FUNCTION(name) zap_status_t name ZINT_WAIT_ARGS
-#define ZINT_READ_FUNCTION(name) zap_status_t name ZINT_READ_ARGS
-#define ZINT_WRITE_FUNCTION(name) zap_status_t name ZINT_WRITE_ARGS
-
-#define ZINT_CONFIGURE_MUZZLE assert(zint != NULL)
-#define ZINT_OPEN_MUZZLE assert(zchan != NULL)
-#define ZINT_CLOSE_MUZZLE assert(zchan != NULL)
-#define ZINT_COMMAND_MUZZLE assert(zchan != NULL); assert(command != 0); assert(obj != NULL)
-#define ZINT_WAIT_MUZZLE assert(zchan != NULL); assert(flags != 0); assert(to != 0)
-#define ZINT_READ_MUZZLE assert(zchan != NULL); assert(data != NULL); assert(datalen != NULL)
-#define ZINT_WRITE_MUZZLE assert(zchan != NULL); assert(data != NULL); assert(datalen != NULL)
+#define ZIO_EVENT_CB_ARGS (zap_channel_t *zchan, zap_event_t *event)
+#define ZIO_CODEC_ARGS (void *data, zap_size_t max, zap_size_t *datalen)
+#define ZIO_CONFIGURE_ARGS (struct zap_io_interface *zio)
+#define ZIO_OPEN_ARGS (zap_channel_t *zchan)
+#define ZIO_CLOSE_ARGS (zap_channel_t *zchan)
+#define ZIO_COMMAND_ARGS (zap_channel_t *zchan, zap_command_t command, void *obj)
+#define ZIO_WAIT_ARGS (zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to)
+#define ZIO_READ_ARGS (zap_channel_t *zchan, void *data, zap_size_t *datalen)
+#define ZIO_WRITE_ARGS (zap_channel_t *zchan, void *data, zap_size_t *datalen)
+
+typedef zap_status_t (*zio_event_cb_t) ZIO_EVENT_CB_ARGS ;
+typedef zap_status_t (*zio_codec_t) ZIO_CODEC_ARGS ;
+typedef zap_status_t (*zio_configure_t) ZIO_CONFIGURE_ARGS ;
+typedef zap_status_t (*zio_open_t) ZIO_OPEN_ARGS ;
+typedef zap_status_t (*zio_close_t) ZIO_CLOSE_ARGS ;
+typedef zap_status_t (*zio_command_t) ZIO_COMMAND_ARGS ;
+typedef zap_status_t (*zio_wait_t) ZIO_WAIT_ARGS ;
+typedef zap_status_t (*zio_read_t) ZIO_READ_ARGS ;
+typedef zap_status_t (*zio_write_t) ZIO_WRITE_ARGS ;
+
+#define ZIO_EVENT_CB_FUNCTION(name) zap_status_t name ZIO_EVENT_CB_ARGS
+#define ZIO_CODEC_FUNCTION(name) zap_status_t name ZIO_CODEC_ARGS
+#define ZIO_CONFIGURE_FUNCTION(name) zap_status_t name ZIO_CONFIGURE_ARGS
+#define ZIO_OPEN_FUNCTION(name) zap_status_t name ZIO_OPEN_ARGS
+#define ZIO_CLOSE_FUNCTION(name) zap_status_t name ZIO_CLOSE_ARGS
+#define ZIO_COMMAND_FUNCTION(name) zap_status_t name ZIO_COMMAND_ARGS
+#define ZIO_WAIT_FUNCTION(name) zap_status_t name ZIO_WAIT_ARGS
+#define ZIO_READ_FUNCTION(name) zap_status_t name ZIO_READ_ARGS
+#define ZIO_WRITE_FUNCTION(name) zap_status_t name ZIO_WRITE_ARGS
+
+#define ZIO_CONFIGURE_MUZZLE assert(zio != NULL)
+#define ZIO_OPEN_MUZZLE assert(zchan != NULL)
+#define ZIO_CLOSE_MUZZLE assert(zchan != NULL)
+#define ZIO_COMMAND_MUZZLE assert(zchan != NULL); assert(command != 0); assert(obj != NULL)
+#define ZIO_WAIT_MUZZLE assert(zchan != NULL); assert(flags != 0); assert(to != 0)
+#define ZIO_READ_MUZZLE assert(zchan != NULL); assert(data != NULL); assert(datalen != NULL)
+#define ZIO_WRITE_MUZZLE assert(zchan != NULL); assert(data != NULL); assert(datalen != NULL)
#define ZAP_PRE __FILE__, __FUNCTION__, __LINE__
#define ZAP_LOG_ALERT ZAP_PRE, ZAP_LOG_LEVEL_ALERT
#define ZAP_LOG_EMERG ZAP_PRE, ZAP_LOG_LEVEL_EMERG
-typedef enum {
- ZAP_EVENT_NONE,
- ZAP_EVENT_DTMF,
-
- ZAP_EVENT_COUNT
-} zap_event_type_t;
-
typedef struct zap_span zap_span_t;
typedef void (*zap_logger_t)(char *file, const char *func, int line, int level, char *fmt, ...);
-typedef struct zap_software_interface zap_software_interface_t;
+typedef struct zap_io_interface zap_io_interface_t;
typedef struct hashtable zap_hash_t;
typedef struct hashtable_itr zap_hash_itr_t;
typedef struct key zap_hash_key_t;
return hash;
}
-zap_status_t zap_span_create(zap_software_interface_t *zint, zap_span_t **span)
+zap_status_t zap_span_create(zap_io_interface_t *zio, zap_span_t **span)
{
zap_span_t *new_span = NULL;
- assert(zint != NULL);
+ assert(zio != NULL);
- if (zint->span_index < ZAP_MAX_SPANS_INTERFACE) {
- new_span = &zint->spans[++zint->span_index];
+ if (zio->span_index < ZAP_MAX_SPANS_INTERFACE) {
+ new_span = &zio->spans[++zio->span_index];
memset(new_span, 0, sizeof(*new_span));
zap_set_flag(new_span, ZAP_SPAN_CONFIGURED);
- new_span->span_id = zint->span_index;
- new_span->zint = zint;
+ new_span->span_id = zio->span_index;
+ new_span->zio = zio;
zap_mutex_create(&new_span->mutex);
*span = new_span;
return ZAP_SUCCESS;
return ZAP_FAIL;
}
-zap_status_t zap_span_close_all(zap_software_interface_t *zint)
+zap_status_t zap_span_close_all(zap_io_interface_t *zio)
{
zap_span_t *span;
uint32_t i;
- for(i = 0; i < zint->span_index; i++) {
- span = &zint->spans[i];
+ for(i = 0; i < zio->span_index; i++) {
+ span = &zio->spans[i];
if (span->mutex) {
zap_mutex_destroy(&span->mutex);
}
new_chan = &span->channels[++span->chan_count];
new_chan->type = type;
new_chan->sockfd = sockfd;
- new_chan->zint = span->zint;
+ new_chan->zio = span->zio;
new_chan->span_id = span->span_id;
new_chan->chan_id = span->chan_count;
new_chan->span = span;
zap_status_t zap_span_find(const char *name, uint32_t id, zap_span_t **span)
{
- zap_software_interface_t *zint;
+ zap_io_interface_t *zio;
zap_span_t *fspan;
zap_mutex_lock(globals.mutex);
- zint = (zap_software_interface_t *) hashtable_search(globals.interface_hash, (char *)name);
+ zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, (char *)name);
zap_mutex_unlock(globals.mutex);
- if (!zint) {
+ if (!zio) {
return ZAP_FAIL;
}
return ZAP_FAIL;
}
- fspan = &zint->spans[id];
+ fspan = &zio->spans[id];
if (!zap_test_flag(fspan, ZAP_SPAN_CONFIGURED)) {
return ZAP_FAIL;
}
-zap_status_t zap_span_set_event_callback(zap_span_t *span, zint_event_cb_t event_callback)
+zap_status_t zap_span_set_event_callback(zap_span_t *span, zio_event_cb_t event_callback)
{
zap_mutex_lock(span->mutex);
span->event_callback = event_callback;
return ZAP_SUCCESS;
}
-zap_status_t zap_channel_set_event_callback(zap_channel_t *zchan, zint_event_cb_t event_callback)
+zap_status_t zap_channel_set_event_callback(zap_channel_t *zchan, zio_event_cb_t event_callback)
{
zap_mutex_lock(zchan->span->mutex);
zchan->event_callback = event_callback;
zap_status_t zap_channel_open_any(const char *name, uint32_t span_id, zap_direction_t direction, zap_channel_t **zchan)
{
- zap_software_interface_t *zint;
+ zap_io_interface_t *zio;
zap_status_t status = ZAP_FAIL;
zap_channel_t *check;
uint32_t i,j;
uint32_t span_max;
zap_mutex_lock(globals.mutex);
- zint = (zap_software_interface_t *) hashtable_search(globals.interface_hash, (char *)name);
+ zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, (char *)name);
zap_mutex_unlock(globals.mutex);
- if (!zint) {
+ if (!zio) {
zap_log(ZAP_LOG_ERROR, "Invalid interface name!\n");
return ZAP_FAIL;
}
if (span_id) {
span_max = span_id;
} else {
- span_max = zint->span_index;
+ span_max = zio->span_index;
}
if (direction == ZAP_TOP_DOWN) {
zap_mutex_lock(globals.mutex);
for(;;) {
- span = &zint->spans[j];
+ span = &zio->spans[j];
if (!zap_test_flag(span, ZAP_SPAN_CONFIGURED)) {
goto next_loop;
if (zap_test_flag(check, ZAP_CHANNEL_READY) && !zap_test_flag(check, ZAP_CHANNEL_OPEN)) {
- status = check->zint->open(check);
+ status = check->zio->open(check);
if (status == ZAP_SUCCESS) {
zap_set_flag(check, ZAP_CHANNEL_OPEN);
zap_status_t zap_channel_open(const char *name, uint32_t span_id, uint32_t chan_id, zap_channel_t **zchan)
{
- zap_software_interface_t *zint;
+ zap_io_interface_t *zio;
zap_status_t status = ZAP_FAIL;
zap_mutex_lock(globals.mutex);
- zint = (zap_software_interface_t *) hashtable_search(globals.interface_hash, (char *)name);
+ zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, (char *)name);
zap_mutex_unlock(globals.mutex);
- if (span_id < ZAP_MAX_SPANS_INTERFACE && chan_id < ZAP_MAX_CHANNELS_SPAN && zint) {
+ if (span_id < ZAP_MAX_SPANS_INTERFACE && chan_id < ZAP_MAX_CHANNELS_SPAN && zio) {
zap_channel_t *check;
- zap_mutex_lock(zint->spans[span_id].mutex);
- check = &zint->spans[span_id].channels[chan_id];
+ zap_mutex_lock(zio->spans[span_id].mutex);
+ check = &zio->spans[span_id].channels[chan_id];
if (zap_test_flag(check, ZAP_CHANNEL_READY) && ! zap_test_flag(check, ZAP_CHANNEL_OPEN)) {
- status = check->zint->open(check);
+ status = check->zio->open(check);
if (status == ZAP_SUCCESS) {
zap_set_flag(check, ZAP_CHANNEL_OPEN);
*zchan = check;
}
}
- zap_mutex_unlock(zint->spans[span_id].mutex);
+ zap_mutex_unlock(zio->spans[span_id].mutex);
}
return status;
zap_mutex_lock(check->span->mutex);
if (zap_test_flag(check, ZAP_CHANNEL_OPEN)) {
- status = check->zint->close(check);
+ status = check->zio->close(check);
if (status == ZAP_SUCCESS) {
zap_channel_reset(check);
*zchan = NULL;
zap_status_t status = ZAP_FAIL;
assert(zchan != NULL);
- assert(zchan->zint != NULL);
+ assert(zchan->zio != NULL);
if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open");
break;
}
- if (!zchan->zint->command) {
+ if (!zchan->zio->command) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented");
GOTO_STATUS(done, ZAP_FAIL);
}
- status = zchan->zint->command(zchan, command, obj);
+ status = zchan->zio->command(zchan, command, obj);
done:
zap_mutex_unlock(zchan->span->mutex);
zap_status_t zap_channel_wait(zap_channel_t *zchan, zap_wait_flag_t *flags, int32_t to)
{
assert(zchan != NULL);
- assert(zchan->zint != NULL);
+ assert(zchan->zio != NULL);
if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open");
return ZAP_FAIL;
}
- if (!zchan->zint->wait) {
+ if (!zchan->zio->wait) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented");
return ZAP_FAIL;
}
- return zchan->zint->wait(zchan, flags, to);
+ return zchan->zio->wait(zchan, flags, to);
}
/*******************************/
-ZINT_CODEC_FUNCTION(zint_slin2ulaw)
+ZIO_CODEC_FUNCTION(zio_slin2ulaw)
{
int16_t sln_buf[512] = {0}, *sln = sln_buf;
uint8_t *lp = data;
}
-ZINT_CODEC_FUNCTION(zint_ulaw2slin)
+ZIO_CODEC_FUNCTION(zio_ulaw2slin)
{
int16_t *sln = data;
uint8_t law[1024] = {0}, *lp = law;
return ZAP_SUCCESS;
}
-ZINT_CODEC_FUNCTION(zint_slin2alaw)
+ZIO_CODEC_FUNCTION(zio_slin2alaw)
{
int16_t sln_buf[512] = {0}, *sln = sln_buf;
uint8_t *lp = data;
}
-ZINT_CODEC_FUNCTION(zint_alaw2slin)
+ZIO_CODEC_FUNCTION(zio_alaw2slin)
{
int16_t *sln = data;
uint8_t law[1024] = {0}, *lp = law;
return ZAP_SUCCESS;
}
-ZINT_CODEC_FUNCTION(zint_ulaw2alaw)
+ZIO_CODEC_FUNCTION(zio_ulaw2alaw)
{
zap_size_t len = *datalen;
uint32_t i;
return ZAP_SUCCESS;
}
-ZINT_CODEC_FUNCTION(zint_alaw2ulaw)
+ZIO_CODEC_FUNCTION(zio_alaw2ulaw)
{
zap_size_t len = *datalen;
uint32_t i;
zap_status_t zap_channel_read(zap_channel_t *zchan, void *data, zap_size_t *datalen)
{
zap_status_t status = ZAP_FAIL;
- zint_codec_t codec_func = NULL;
+ zio_codec_t codec_func = NULL;
zap_size_t max = *datalen;
assert(zchan != NULL);
- assert(zchan->zint != NULL);
- assert(zchan->zint != NULL);
+ assert(zchan->zio != NULL);
+ assert(zchan->zio != NULL);
if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open");
return ZAP_FAIL;
}
- if (!zchan->zint->read) {
+ if (!zchan->zio->read) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented");
return ZAP_FAIL;
}
- status = zchan->zint->read(zchan, data, datalen);
+ status = zchan->zio->read(zchan, data, datalen);
if (status == ZAP_SUCCESS && zap_test_flag(zchan, ZAP_CHANNEL_TRANSCODE) && zchan->effective_codec != zchan->native_codec) {
if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_SLIN) {
- codec_func = zint_ulaw2slin;
+ codec_func = zio_ulaw2slin;
} else if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_ALAW) {
- codec_func = zint_ulaw2alaw;
+ codec_func = zio_ulaw2alaw;
} else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_SLIN) {
- codec_func = zint_alaw2slin;
+ codec_func = zio_alaw2slin;
} else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_ULAW) {
- codec_func = zint_alaw2ulaw;
+ codec_func = zio_alaw2ulaw;
}
if (codec_func) {
teletone_dtmf_detect(&zchan->dtmf_detect, sln, (int)slen);
teletone_dtmf_get(&zchan->dtmf_detect, digit_str, sizeof(digit_str));
if(digit_str[0]) {
- zint_event_cb_t event_callback = NULL;
+ zio_event_cb_t event_callback = NULL;
if (zchan->span->event_callback) {
event_callback = zchan->span->event_callback;
} else if (zchan->event_callback) {
zap_status_t zap_channel_write(zap_channel_t *zchan, void *data, zap_size_t *datalen)
{
zap_status_t status = ZAP_FAIL;
- zint_codec_t codec_func = NULL;
+ zio_codec_t codec_func = NULL;
zap_size_t dtmf_blen, max = *datalen;
assert(zchan != NULL);
- assert(zchan->zint != NULL);
+ assert(zchan->zio != NULL);
if (!zap_test_flag(zchan, ZAP_CHANNEL_OPEN)) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "channel not open");
return ZAP_FAIL;
}
- if (!zchan->zint->write) {
+ if (!zchan->zio->write) {
snprintf(zchan->last_error, sizeof(zchan->last_error), "method not implemented");
return ZAP_FAIL;
}
if (zap_test_flag(zchan, ZAP_CHANNEL_TRANSCODE) && zchan->effective_codec != zchan->native_codec) {
if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_SLIN) {
- codec_func = zint_slin2ulaw;
+ codec_func = zio_slin2ulaw;
} else if (zchan->native_codec == ZAP_CODEC_ULAW && zchan->effective_codec == ZAP_CODEC_ALAW) {
- codec_func = zint_alaw2ulaw;
+ codec_func = zio_alaw2ulaw;
} else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_SLIN) {
- codec_func = zint_slin2alaw;
+ codec_func = zio_slin2alaw;
} else if (zchan->native_codec == ZAP_CODEC_ALAW && zchan->effective_codec == ZAP_CODEC_ULAW) {
- codec_func = zint_ulaw2alaw;
+ codec_func = zio_ulaw2alaw;
}
if (codec_func) {
if (zchan->native_codec != ZAP_CODEC_SLIN) {
if (zchan->native_codec == ZAP_CODEC_ULAW) {
*datalen = dlen;
- zint_slin2ulaw(data, max, datalen);
+ zio_slin2ulaw(data, max, datalen);
} else if (zchan->native_codec == ZAP_CODEC_ALAW) {
*datalen = dlen;
- zint_slin2alaw(data, max, datalen);
+ zio_slin2alaw(data, max, datalen);
}
}
}
- status = zchan->zint->write(zchan, data, datalen);
+ status = zchan->zio->write(zchan, data, datalen);
return status;
}
static struct {
- zap_software_interface_t *wanpipe_interface;
- zap_software_interface_t *zt_interface;
+ zap_io_interface_t *wanpipe_interface;
+ zap_io_interface_t *zt_interface;
} interfaces;
zap_status_t zap_global_init(void)
while (zap_config_next_pair(&cfg, &var, &val)) {
if (!strcasecmp(cfg.category, "openzap")) {
if (!strcmp(var, "load")) {
- zap_software_interface_t *zint;
+ zap_io_interface_t *zio;
zap_mutex_lock(globals.mutex);
- zint = (zap_software_interface_t *) hashtable_search(globals.interface_hash, val);
+ zio = (zap_io_interface_t *) hashtable_search(globals.interface_hash, val);
zap_mutex_unlock(globals.mutex);
- if (zint) {
- if (zint->configure(zint) == ZAP_SUCCESS) {
+ if (zio) {
+ if (zio->configure(zio) == ZAP_SUCCESS) {
configured++;
}
} else {
projects / thirdparty / freeswitch.git / commitdiff
