#include "blade.h"
-typedef enum {
- BDS_NONE = 0,
- BDS_MYPOOL = (1 << 0),
- BDS_MYTPOOL = (1 << 1),
-} bdspvt_flag_t;
-
struct blade_datastore_s {
- bdspvt_flag_t flags;
ks_pool_t *pool;
ks_thread_pool_t *tpool;
const char *config_database_path;
- //config_setting_t *config_service;
unqlite *db;
- //blade_service_t *service;
};
struct blade_datastore_fetch_userdata_s
KS_DECLARE(ks_status_t) blade_datastore_destroy(blade_datastore_t **bdsP)
{
blade_datastore_t *bds = NULL;
- bdspvt_flag_t flags;
- ks_pool_t *pool;
ks_assert(bdsP);
ks_assert(bds);
- flags = bds->flags;
- pool = bds->pool;
-
blade_datastore_shutdown(bds);
- if (bds->tpool && (flags & BDS_MYTPOOL)) ks_thread_pool_destroy(&bds->tpool);
-
ks_pool_free(bds->pool, &bds);
- if (pool && (flags & BDS_MYPOOL)) ks_pool_close(&pool);
-
return KS_STATUS_SUCCESS;
}
KS_DECLARE(ks_status_t) blade_datastore_create(blade_datastore_t **bdsP, ks_pool_t *pool, ks_thread_pool_t *tpool)
{
- bdspvt_flag_t newflags = BDS_NONE;
blade_datastore_t *bds = NULL;
- if (!pool) {
- newflags |= BDS_MYPOOL;
- ks_pool_open(&pool);
- ks_assert(pool);
- }
- // @todo: move thread pool creation to startup which allows thread pool to be configurable
- if (!tpool) {
- newflags |= BDS_MYTPOOL;
- ks_thread_pool_create(&tpool,
- BLADE_DATASTORE_TPOOL_MIN,
- BLADE_DATASTORE_TPOOL_MAX,
- BLADE_DATASTORE_TPOOL_STACK,
- KS_PRI_NORMAL,
- BLADE_DATASTORE_TPOOL_IDLE);
- ks_assert(tpool);
- }
+ ks_assert(bdsP);
+ ks_assert(pool);
+ ks_assert(tpool);
bds = ks_pool_alloc(pool, sizeof(*bds));
- bds->flags = newflags;
bds->pool = pool;
bds->tpool = tpool;
*bdsP = bds;
{
config_setting_t *tmp;
config_setting_t *database = NULL;
- //config_setting_t *service = NULL;
const char *config_database_path = NULL;
ks_assert(bds);
if (!tmp) return KS_STATUS_FAIL;
if (config_setting_type(tmp) != CONFIG_TYPE_STRING) return KS_STATUS_FAIL;
config_database_path = config_setting_get_string(tmp);
- //service = config_setting_get_member(config, "service");
if (bds->config_database_path) ks_pool_free(bds->pool, &bds->config_database_path);
bds->config_database_path = ks_pstrdup(bds->pool, config_database_path);
- //bds->config_service = service;
return KS_STATUS_SUCCESS;
}
if (blade_datastore_config(bds, config) != KS_STATUS_SUCCESS) return KS_STATUS_FAIL;
- //if (unqlite_open(&bds->db, NULL, UNQLITE_OPEN_IN_MEMORY) != UNQLITE_OK) {
if (unqlite_open(&bds->db, bds->config_database_path, UNQLITE_OPEN_CREATE) != UNQLITE_OK) {
const char *errbuf = NULL;
blade_datastore_error(bds, &errbuf, NULL);
// @todo VM init if document store is used (and output consumer callback)
- //blade_service_create(&bds->service, bds->pool, bds->tpool);
- //ks_assert(bds->service);
- //blade_service_startup(bds->service, bds->config_service);
-
return KS_STATUS_SUCCESS;
}
{
ks_assert(bds);
- //if (bds->service) blade_service_destroy(&bds->service);
-
if (bds->db) {
unqlite_close(bds->db);
bds->db = NULL;
}
if (bds->config_database_path) ks_pool_free(bds->pool, &bds->config_database_path);
- //bds->config_service = NULL;
return KS_STATUS_SUCCESS;
}
#include "blade.h"
-typedef enum {
- BP_NONE = 0,
- BP_MYPOOL = (1 << 0),
- BP_MYTPOOL = (1 << 1)
-} bppvt_flag_t;
-
struct blade_peer_s {
- bppvt_flag_t flags;
ks_pool_t *pool;
ks_thread_pool_t *tpool;
blade_service_t *service;
ks_socket_t sock;
ks_bool_t shutdown;
- ks_bool_t disconnecting;
+ blade_peerstate_t state;
+ blade_peerreason_t reason;
+
kws_t *kws;
ks_thread_t *kws_thread;
KS_DECLARE(ks_status_t) blade_peer_destroy(blade_peer_t **bpP)
{
blade_peer_t *bp = NULL;
- bppvt_flag_t flags;
- ks_pool_t *pool;
ks_assert(bpP);
ks_assert(bp);
- flags = bp->flags;
- pool = bp->pool;
-
blade_peer_shutdown(bp);
ks_q_destroy(&bp->messages_sending);
ks_q_destroy(&bp->messages_receiving);
- if (bp->tpool && (flags & BP_MYTPOOL)) ks_thread_pool_destroy(&bp->tpool);
-
ks_pool_free(bp->pool, &bp);
- if (pool && (flags & BP_MYPOOL)) ks_pool_close(&pool);
-
return KS_STATUS_SUCCESS;
}
KS_DECLARE(ks_status_t) blade_peer_create(blade_peer_t **bpP, ks_pool_t *pool, ks_thread_pool_t *tpool, blade_service_t *service)
{
- bppvt_flag_t newflags = BP_NONE;
blade_peer_t *bp = NULL;
ks_assert(bpP);
+ ks_assert(pool);
+ ks_assert(tpool);
ks_assert(service);
- if (!pool) {
- newflags |= BP_MYPOOL;
- ks_pool_open(&pool);
- ks_assert(pool);
- }
- if (!tpool) {
- newflags |= BP_MYTPOOL;
- ks_thread_pool_create(&tpool, BLADE_PEER_TPOOL_MIN, BLADE_PEER_TPOOL_MAX, BLADE_PEER_TPOOL_STACK, KS_PRI_NORMAL, BLADE_PEER_TPOOL_IDLE);
- ks_assert(tpool);
- }
-
bp = ks_pool_alloc(pool, sizeof(*bp));
- bp->flags = newflags;
bp->pool = pool;
bp->tpool = tpool;
bp->service = service;
+ bp->state = BLADE_PEERSTATE_CONNECTING;
+ bp->reason = BLADE_PEERREASON_NORMAL;
ks_q_create(&bp->messages_sending, pool, 0);
ks_q_create(&bp->messages_receiving, pool, 0);
*bpP = bp;
blade_peer_shutdown(bp);
bp->sock = sock;
+ bp->state = BLADE_PEERSTATE_CONNECTING;
+ bp->reason = BLADE_PEERREASON_NORMAL;
if (ks_thread_create_ex(&bp->kws_thread,
blade_peer_kws_thread,
KS_THREAD_FLAG_DEFAULT,
KS_THREAD_DEFAULT_STACK,
KS_PRI_NORMAL,
- bp->pool) != KS_STATUS_SUCCESS) return KS_STATUS_FAIL;
+ bp->pool) != KS_STATUS_SUCCESS) {
+ // @todo error logging
+ blade_peer_disconnect(bp, BLADE_PEERREASON_ERROR);
+ return KS_STATUS_FAIL;
+ }
return KS_STATUS_SUCCESS;
}
while (ks_q_trypop(bp->messages_sending, (void **)&message) == KS_STATUS_SUCCESS && message) blade_message_discard(&message);
while (ks_q_trypop(bp->messages_receiving, (void **)&message) == KS_STATUS_SUCCESS && message) blade_message_discard(&message);
-
+
if (bp->kws) kws_destroy(&bp->kws);
else if (bp->sock != KS_SOCK_INVALID) ks_socket_close(&bp->sock);
bp->sock = KS_SOCK_INVALID;
return KS_STATUS_SUCCESS;
}
-KS_DECLARE(void) blade_peer_disconnect(blade_peer_t *bp)
+KS_DECLARE(void) blade_peer_disconnect(blade_peer_t *bp, blade_peerreason_t reason)
{
ks_assert(bp);
- bp->disconnecting = KS_TRUE;
+ // @todo check if already disconnecting for another reason, avoid resetting to get initial reason for disconnect?
+ bp->reason = reason;
+ bp->state = BLADE_PEERSTATE_DISCONNECTING;
}
-KS_DECLARE(ks_bool_t) blade_peer_disconnecting(blade_peer_t *bp)
+KS_DECLARE(blade_peerstate_t) blade_peer_state(blade_peer_t *bp)
{
ks_assert(bp);
- return bp->disconnecting;
+ return bp->state;
}
KS_DECLARE(ks_status_t) blade_peer_message_pop(blade_peer_t *peer, blade_message_t **message)
ks_assert(data_length > 0);
if (blade_handle_message_claim(blade_service_handle(peer->service), &message, data, data_length) != KS_STATUS_SUCCESS || !message) {
- // @todo error handling
- // just drop the peer for now, the only failure scenarios are asserted OOM, or if the discard queue pop fails
- peer->disconnecting = KS_TRUE;
+ // @todo error logging
+ blade_peer_disconnect(peer, BLADE_PEERREASON_ERROR);
return KS_STATUS_FAIL;
}
ks_q_push(peer->messages_sending, message);
peer = (blade_peer_t *)data;
+ // @todo consider using an INITIALIZING state to track when there is problems during initialization (specifically SSL negotiations)?
+ // @todo should stack be notified with an internal event callback here before logic layer initialization starts (IE, before SSL negotiations)?
+ peer->state = BLADE_PEERSTATE_RUNNING;
+
// @todo: SSL init stuffs based on data from peer->service->config_websockets_ssl to pass into kws_init
if (kws_init(&peer->kws, peer->sock, NULL, NULL, KWS_BLOCK, peer->pool) != KS_STATUS_SUCCESS) {
- peer->disconnecting = KS_TRUE;
+ // @todo error logging
+ blade_peer_disconnect(peer, BLADE_PEERREASON_ERROR);
return NULL;
}
+
+ blade_service_peer_state_callback(peer->service, peer, BLADE_PEERSTATE_RUNNING);
while (!peer->shutdown) {
// @todo get exact timeout from service config?
poll_flags = ks_wait_sock(peer->sock, 100, KS_POLL_READ | KS_POLL_ERROR);
if (poll_flags & KS_POLL_ERROR) {
- // @todo switch this (and others below) to the enum for the state callback, called during the service connected peer cleanup
- peer->disconnecting = KS_TRUE;
+ // @todo error logging
+ blade_peer_disconnect(peer, BLADE_PEERREASON_ERROR);
break;
}
frame_data_len = kws_read_frame(peer->kws, &opcode, &frame_data);
if (frame_data_len <= 0) {
- // @todo error handling, strerror(ks_errno())
+ // @todo error logging, strerror(ks_errno())
// 0 means socket closed with WS_NONE, which closes websocket with no additional reason
// -1 means socket closed with a general failure
// -2 means nonblocking wait
// other values are based on WS_XXX reasons
// negative values are based on reasons, except for -1 is but -2 is nonblocking wait, and
- // @todo: this way of disconnecting would have the service periodically check the list of connected peers for those that are disconnecting,
- // remove them from the connected peer list, and then call peer destroy which will wait for this thread to rejoin which it already will have,
- // and then destroy the inner kws and finish any cleanup of the actual socket if neccessary, and can still call an ondisconnected callback
- // at the service level
- peer->disconnecting = KS_TRUE;
+ blade_peer_disconnect(peer, BLADE_PEERREASON_ERROR);
break;
}
if (blade_handle_message_claim(blade_service_handle(peer->service), &message, frame_data, frame_data_len) != KS_STATUS_SUCCESS || !message) {
- // @todo error handling
- // just drop the peer for now, the only failure scenarios are asserted OOM, or if the discard queue pop fails
- peer->disconnecting = KS_TRUE;
+ // @todo error logging
+ blade_peer_disconnect(peer, BLADE_PEERREASON_ERROR);
break;
}
ks_q_push(peer->messages_receiving, message);
- // @todo callback up the stack to indicate a message has been received and can be popped (more efficient than constantly polling by popping)?
- // might not perfectly fit the traditional state callback, but it could work if it only sends the state temporarily and does NOT actually change
- // the internal state to receiving
+ blade_service_peer_state_callback(peer->service, peer, BLADE_PEERSTATE_RECEIVING);
}
// @todo consider only sending one message at a time and use shorter polling timeout to prevent any considerable blocking if send buffers get full
while (ks_q_trypop(peer->messages_sending, (void **)&message) == KS_STATUS_SUCCESS && message) {
blade_message_get(message, (void **)&frame_data, &frame_data_len);
+ // @todo may need to get the WSOC_TEXT from the message if using WSOC_BINARY is desired later
kws_write_frame(peer->kws, WSOC_TEXT, frame_data, frame_data_len);
}
}
#include "blade.h"
-typedef enum {
- BS_NONE = 0,
- BS_MYPOOL = (1 << 0),
- BS_MYTPOOL = (1 << 1)
-} bspvt_flag_t;
-
#define BLADE_SERVICE_WEBSOCKETS_ENDPOINTS_MULTIHOME_MAX 16
struct blade_service_s {
- bspvt_flag_t flags;
ks_pool_t *pool;
ks_thread_pool_t *tpool;
blade_handle_t *handle;
+ blade_service_peer_state_callback_t peer_state_callback;
ks_sockaddr_t config_websockets_endpoints_ipv4[BLADE_SERVICE_WEBSOCKETS_ENDPOINTS_MULTIHOME_MAX];
ks_sockaddr_t config_websockets_endpoints_ipv6[BLADE_SERVICE_WEBSOCKETS_ENDPOINTS_MULTIHOME_MAX];
ks_bool_t shutdown;
struct pollfd *listeners_poll;
- int32_t *listeners_families;
int32_t listeners_size;
int32_t listeners_length;
ks_thread_t *listeners_thread;
KS_DECLARE(ks_status_t) blade_service_destroy(blade_service_t **bsP)
{
blade_service_t *bs = NULL;
- bspvt_flag_t flags;
- ks_pool_t *pool;
ks_assert(bsP);
ks_assert(bs);
- flags = bs->flags;
- pool = bs->pool;
-
blade_service_shutdown(bs);
list_destroy(&bs->connected);
- if (bs->tpool && (flags & BS_MYTPOOL)) ks_thread_pool_destroy(&bs->tpool);
-
ks_pool_free(bs->pool, &bs);
- if (pool && (flags & BS_MYPOOL)) ks_pool_close(&pool);
-
return KS_STATUS_SUCCESS;
}
-KS_DECLARE(ks_status_t) blade_service_create(blade_service_t **bsP, ks_pool_t *pool, ks_thread_pool_t *tpool, blade_handle_t *handle)
+KS_DECLARE(ks_status_t) blade_service_create(blade_service_t **bsP,
+ ks_pool_t *pool,
+ ks_thread_pool_t *tpool,
+ blade_handle_t *handle,
+ blade_service_peer_state_callback_t peer_state_callback)
{
- bspvt_flag_t newflags = BS_NONE;
blade_service_t *bs = NULL;
ks_assert(bsP);
+ ks_assert(pool);
+ ks_assert(tpool);
ks_assert(handle);
- if (!pool) {
- newflags |= BS_MYPOOL;
- ks_pool_open(&pool);
- ks_assert(pool);
- }
- if (!tpool) {
- newflags |= BS_MYTPOOL;
- ks_thread_pool_create(&tpool, BLADE_SERVICE_TPOOL_MIN, BLADE_SERVICE_TPOOL_MAX, BLADE_SERVICE_TPOOL_STACK, KS_PRI_NORMAL, BLADE_SERVICE_TPOOL_IDLE);
- ks_assert(tpool);
- }
-
bs = ks_pool_alloc(pool, sizeof(*bs));
- bs->flags = newflags;
bs->pool = pool;
bs->tpool = tpool;
bs->handle = handle;
+ bs->peer_state_callback = peer_state_callback;
list_init(&bs->connected);
*bsP = bs;
{
ks_assert(bs);
+ // @todo 1 more callback for blade_service_state_callback_t? providing event up the stack on service startup, shutdown, and service errors?
+
bs->shutdown = KS_TRUE;
if (bs->listeners_thread) {
list_iterator_start(&bs->connected);
while (list_iterator_hasnext(&bs->connected)) {
blade_peer_t *peer = (blade_peer_t *)list_iterator_next(&bs->connected);
- blade_peer_destroy(&peer);
+ blade_peer_destroy(&peer); // @todo determine if NOT receiving the DISCONNECTING event callback for these will matter, as service is being shutdown
}
list_iterator_stop(&bs->connected);
list_clear(&bs->connected);
return KS_STATUS_SUCCESS;
}
+KS_DECLARE(void) blade_service_peer_state_callback(blade_service_t *bs, blade_peer_t *bp, blade_peerstate_t state)
+{
+ ks_assert(bs);
+ ks_assert(bp);
+
+ if (bs->peer_state_callback) bs->peer_state_callback(bs, bp, state);
+}
+
ks_status_t blade_service_listen(blade_service_t *bs, ks_sockaddr_t *addr)
{
ks_socket_t listener = KS_SOCK_INVALID;
bs->listeners_size = bs->listeners_length;
bs->listeners_poll = (struct pollfd *)ks_pool_resize(bs->pool, bs->listeners_poll, sizeof(struct pollfd) * bs->listeners_size);
ks_assert(bs->listeners_poll);
- bs->listeners_families = (int32_t *)ks_pool_resize(bs->pool, bs->listeners_families, sizeof(int32_t) * bs->listeners_size);
- ks_assert(bs->listeners_families);
}
bs->listeners_poll[listener_index].fd = listener;
bs->listeners_poll[listener_index].events = POLLIN | POLLERR;
- bs->listeners_families[listener_index] = addr->family;
done:
if (ret != KS_STATUS_SUCCESS) {
service = (blade_service_t *)data;
+ // @todo 1 more callback for blade_service_state_callback_t? providing event up the stack on service startup, shutdown, and service errors?
+
while (!service->shutdown) {
// @todo take exact timeout from a setting in config_service_endpoints
if (ks_poll(service->listeners_poll, service->listeners_length, 100) > 0) {
ks_assert(peer);
// @todo call state callback with connecting enum state
+ blade_service_peer_state_callback(service, peer, BLADE_PEERSTATE_CONNECTING);
blade_peer_startup(peer, sock);
blade_peer_t *peer = (blade_peer_t *)list_iterator_next(&service->connected);
// @todo expose accessor for disconnecting, after changing it into the state callback enum
// ensure that every way kws_close might occur leads back to disconnecting = KS_TRUE for this to universally process disconnects
- if (blade_peer_disconnecting(peer)) {
+ if (blade_peer_state(peer) == BLADE_PEERSTATE_DISCONNECTING) {
// @todo check if there is an iterator based remove function, or indexed iteration to use list_delete_at()
list_delete(&service->connected, peer);
- // @todo call state callback with internal disconnecting enum state (stored in peer to hold specific reason for disconnecting)
+ blade_service_peer_state_callback(service, peer, BLADE_PEERSTATE_DISCONNECTING);
+
// @todo switch to blade_peer_shutdown(&peer) and blade_peer_discard(&peer) after introducing recycling of peers
blade_peer_destroy(&peer);
}
return KS_STATUS_SUCCESS;
}
-KS_DECLARE(ks_status_t) blade_handle_startup(blade_handle_t *bh, config_setting_t *config)
+KS_DECLARE(ks_status_t) blade_handle_startup(blade_handle_t *bh, config_setting_t *config, blade_service_peer_state_callback_t service_peer_state_callback)
{
ks_assert(bh);
if (blade_handle_config(bh, config) != KS_STATUS_SUCCESS) return KS_STATUS_FAIL;
if (bh->config_service && !blade_handle_service_available(bh)) {
- blade_service_create(&bh->service, bh->pool, bh->tpool, bh);
+ blade_service_create(&bh->service, bh->pool, bh->tpool, bh, service_peer_state_callback);
ks_assert(bh->service);
if (blade_service_startup(bh->service, bh->config_service) != KS_STATUS_SUCCESS) return KS_STATUS_FAIL;
}
#define _BLADE_DATASTORE_H_
#include <blade.h>
-#define BLADE_DATASTORE_TPOOL_MIN 2
-#define BLADE_DATASTORE_TPOOL_MAX 8
-#define BLADE_DATASTORE_TPOOL_STACK (1024 * 256)
-#define BLADE_DATASTORE_TPOOL_IDLE 10
-
KS_BEGIN_EXTERN_C
KS_DECLARE(ks_status_t) blade_datastore_create(blade_datastore_t **bdsP, ks_pool_t *pool, ks_thread_pool_t *tpool);
KS_DECLARE(ks_status_t) blade_datastore_destroy(blade_datastore_t **bdsP);
#define _BLADE_PEER_H_
#include <blade.h>
-#define BLADE_PEER_TPOOL_MIN 2
-#define BLADE_PEER_TPOOL_MAX 8
-#define BLADE_PEER_TPOOL_STACK (1024 * 256)
-#define BLADE_PEER_TPOOL_IDLE 10
-
KS_BEGIN_EXTERN_C
KS_DECLARE(ks_status_t) blade_peer_create(blade_peer_t **bpP, ks_pool_t *pool, ks_thread_pool_t *tpool, blade_service_t *service);
KS_DECLARE(ks_status_t) blade_peer_destroy(blade_peer_t **bpP);
KS_DECLARE(ks_status_t) blade_peer_startup(blade_peer_t *bp, ks_socket_t sock);
KS_DECLARE(ks_status_t) blade_peer_shutdown(blade_peer_t *bp);
-KS_DECLARE(void) blade_peer_disconnect(blade_peer_t *bp);
-KS_DECLARE(ks_bool_t) blade_peer_disconnecting(blade_peer_t *bp);
+KS_DECLARE(void) blade_peer_disconnect(blade_peer_t *bp, blade_peerreason_t reason);
+KS_DECLARE(blade_peerstate_t) blade_peer_state(blade_peer_t *bp);
+KS_DECLARE(blade_peerreason_t) blade_peer_reason(blade_peer_t *bp);
KS_DECLARE(ks_status_t) blade_peer_message_pop(blade_peer_t *peer, blade_message_t **message);
KS_DECLARE(ks_status_t) blade_peer_message_push(blade_peer_t *peer, void *data, ks_size_t data_length);
KS_END_EXTERN_C
#define _BLADE_SERVICE_H_
#include <blade.h>
-#define BLADE_SERVICE_TPOOL_MIN 2
-#define BLADE_SERVICE_TPOOL_MAX 8
-#define BLADE_SERVICE_TPOOL_STACK (1024 * 256)
-#define BLADE_SERVICE_TPOOL_IDLE 10
-
KS_BEGIN_EXTERN_C
-KS_DECLARE(ks_status_t) blade_service_create(blade_service_t **bsP, ks_pool_t *pool, ks_thread_pool_t *tpool, blade_handle_t *handle);
+KS_DECLARE(ks_status_t) blade_service_create(blade_service_t **bsP,
+ ks_pool_t *pool,
+ ks_thread_pool_t *tpool,
+ blade_handle_t *handle,
+ blade_service_peer_state_callback_t peer_state_callback);
KS_DECLARE(ks_status_t) blade_service_destroy(blade_service_t **bsP);
KS_DECLARE(blade_handle_t *) blade_service_handle(blade_service_t *bs);
KS_DECLARE(ks_status_t) blade_service_startup(blade_service_t *bs, config_setting_t *config);
KS_DECLARE(ks_status_t) blade_service_shutdown(blade_service_t *bs);
+KS_DECLARE(void) blade_service_peer_state_callback(blade_service_t *bs, blade_peer_t *bp, blade_peerstate_t state);
KS_END_EXTERN_C
#endif
KS_BEGIN_EXTERN_C
KS_DECLARE(ks_status_t) blade_handle_destroy(blade_handle_t **bhP);
KS_DECLARE(ks_status_t) blade_handle_create(blade_handle_t **bhP, ks_pool_t *pool, ks_thread_pool_t *tpool);
-KS_DECLARE(ks_status_t) blade_handle_startup(blade_handle_t *bh, config_setting_t *config);
+KS_DECLARE(ks_status_t) blade_handle_startup(blade_handle_t *bh, config_setting_t *config, blade_service_peer_state_callback_t service_peer_state_callback);
KS_DECLARE(ks_status_t) blade_handle_shutdown(blade_handle_t *bh);
KS_DECLARE(ks_status_t) blade_handle_message_claim(blade_handle_t *bh, blade_message_t **message, void *data, ks_size_t data_length);
KS_BEGIN_EXTERN_C
+typedef enum {
+ BLADE_PEERSTATE_CONNECTING,
+ BLADE_PEERSTATE_DISCONNECTING,
+ BLADE_PEERSTATE_RUNNING,
+ BLADE_PEERSTATE_RECEIVING,
+} blade_peerstate_t;
+
+typedef enum {
+ BLADE_PEERREASON_NORMAL,
+ BLADE_PEERREASON_ERROR,
+ // @todo populate more reasons for disconnecting as neccessary
+} blade_peerreason_t;
+
typedef struct blade_handle_s blade_handle_t;
typedef struct blade_peer_s blade_peer_t;
typedef struct blade_service_s blade_service_t;
typedef struct blade_message_s blade_message_t;
typedef struct blade_datastore_s blade_datastore_t;
+typedef void (*blade_service_peer_state_callback_t)(blade_service_t *bs, blade_peer_t *bp, blade_peerstate_t state);
typedef ks_bool_t (*blade_datastore_fetch_callback_t)(blade_datastore_t *bds, const void *data, uint32_t data_length, void *userdata);
KS_END_EXTERN_C
projects / thirdparty / freeswitch.git / commitdiff
