260 lines
6.2 KiB
C
260 lines
6.2 KiB
C
#include "blade.h"
|
|
#include "tap.h"
|
|
|
|
#ifdef _WIN32
|
|
#define STDIO_FD(_fs) _fileno(_fs)
|
|
#define READ(_fd, _buffer, _count) _read(_fd, _buffer, _count)
|
|
#else
|
|
#define STDIO_FD(_fs) fileno(_fs)
|
|
#define READ(_fd, _buffer, _count) read(_fd, _buffer, _count)
|
|
#endif
|
|
|
|
#define CONSOLE_INPUT_MAX 512
|
|
|
|
ks_bool_t g_shutdown = KS_FALSE;
|
|
char g_console_input[CONSOLE_INPUT_MAX];
|
|
size_t g_console_input_length = 0;
|
|
size_t g_console_input_eol = 0;
|
|
|
|
void loop(blade_handle_t *bh);
|
|
void process_console_input(blade_handle_t *bh, char *line);
|
|
|
|
typedef void (*command_callback)(blade_handle_t *bh, char *args);
|
|
|
|
struct command_def_s {
|
|
const char *cmd;
|
|
command_callback callback;
|
|
};
|
|
|
|
void command_test(blade_handle_t *bh, char *args);
|
|
void command_quit(blade_handle_t *bh, char *args);
|
|
void command_store(blade_handle_t *bh, char *args);
|
|
void command_fetch(blade_handle_t *bh, char *args);
|
|
void command_connect(blade_handle_t *bh, char *args);
|
|
|
|
static const struct command_def_s command_defs[] = {
|
|
{ "test", command_test },
|
|
{ "quit", command_quit },
|
|
{ "store", command_store },
|
|
{ "fetch", command_fetch },
|
|
{ "connect", command_connect },
|
|
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
blade_handle_t *bh = NULL;
|
|
config_t config;
|
|
config_setting_t *config_blade = NULL;
|
|
blade_module_t *mod_wss = NULL;
|
|
//blade_identity_t *id = NULL;
|
|
const char *cfgpath = "bladec.cfg";
|
|
|
|
|
|
ks_global_set_default_logger(KS_LOG_LEVEL_DEBUG);
|
|
|
|
blade_init();
|
|
|
|
blade_handle_create(&bh, NULL, NULL);
|
|
|
|
if (argc > 1) cfgpath = argv[1];
|
|
|
|
config_init(&config);
|
|
if (!config_read_file(&config, cfgpath)) {
|
|
ks_log(KS_LOG_ERROR, "%s:%d - %s\n", config_error_file(&config), config_error_line(&config), config_error_text(&config));
|
|
config_destroy(&config);
|
|
return EXIT_FAILURE;
|
|
}
|
|
config_blade = config_lookup(&config, "blade");
|
|
if (!config_blade) {
|
|
ks_log(KS_LOG_ERROR, "Missing 'blade' config group\n");
|
|
config_destroy(&config);
|
|
return EXIT_FAILURE;
|
|
}
|
|
if (config_setting_type(config_blade) != CONFIG_TYPE_GROUP) {
|
|
ks_log(KS_LOG_ERROR, "The 'blade' config setting is not a group\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (blade_handle_startup(bh, config_blade) != KS_STATUS_SUCCESS) {
|
|
ks_log(KS_LOG_ERROR, "Blade startup failed\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
if (blade_module_wss_on_load(&mod_wss, bh) != KS_STATUS_SUCCESS) {
|
|
ks_log(KS_LOG_ERROR, "Blade WSS module load failed\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
if (blade_module_wss_on_startup(mod_wss, config_blade) != KS_STATUS_SUCCESS) {
|
|
ks_log(KS_LOG_ERROR, "Blade WSS module startup failed\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
loop(bh);
|
|
|
|
blade_module_wss_on_shutdown(mod_wss);
|
|
|
|
blade_module_wss_on_unload(mod_wss);
|
|
|
|
blade_handle_destroy(&bh);
|
|
|
|
blade_shutdown();
|
|
|
|
return 0;
|
|
}
|
|
|
|
|
|
|
|
void buffer_console_input(void)
|
|
{
|
|
ssize_t bytes = 0;
|
|
struct pollfd poll[1];
|
|
poll[0].fd = STDIO_FD(stdin);
|
|
poll[0].events = POLLIN | POLLERR;
|
|
|
|
if (ks_poll(poll, 1, 1) > 0) {
|
|
if (poll[0].revents & POLLIN) {
|
|
if ((bytes = READ(poll[0].fd, g_console_input + g_console_input_length, CONSOLE_INPUT_MAX - g_console_input_length)) <= 0) {
|
|
// @todo error
|
|
return;
|
|
}
|
|
g_console_input_length += bytes;
|
|
}
|
|
}
|
|
}
|
|
|
|
void loop(blade_handle_t *bh)
|
|
{
|
|
while (!g_shutdown) {
|
|
ks_bool_t eol = KS_FALSE;
|
|
buffer_console_input();
|
|
|
|
for (; g_console_input_eol < g_console_input_length; ++g_console_input_eol) {
|
|
char c = g_console_input[g_console_input_eol];
|
|
if (c == '\r' || c == '\n') {
|
|
eol = KS_TRUE;
|
|
break;
|
|
}
|
|
}
|
|
if (eol) {
|
|
g_console_input[g_console_input_eol] = '\0';
|
|
process_console_input(bh, g_console_input);
|
|
g_console_input_eol++;
|
|
for (; g_console_input_eol < g_console_input_length; ++g_console_input_eol) {
|
|
char c = g_console_input[g_console_input_eol];
|
|
if (c != '\r' && c != '\n') break;
|
|
}
|
|
if (g_console_input_eol == g_console_input_length) g_console_input_eol = g_console_input_length = 0;
|
|
else {
|
|
memcpy(g_console_input, g_console_input + g_console_input_eol, g_console_input_length - g_console_input_eol);
|
|
g_console_input_length -= g_console_input_eol;
|
|
g_console_input_eol = 0;
|
|
}
|
|
}
|
|
if (g_console_input_length == CONSOLE_INPUT_MAX) {
|
|
// @todo lines must not exceed 512 bytes, treat as error and ignore buffer until next new line?
|
|
ks_assert(0);
|
|
}
|
|
}
|
|
}
|
|
|
|
void parse_argument(char **input, char **arg, char terminator)
|
|
{
|
|
char *tmp;
|
|
|
|
ks_assert(input);
|
|
ks_assert(*input);
|
|
ks_assert(arg);
|
|
|
|
tmp = *input;
|
|
*arg = tmp;
|
|
|
|
while (*tmp && *tmp != terminator) ++tmp;
|
|
if (*tmp == terminator) {
|
|
*tmp = '\0';
|
|
++tmp;
|
|
}
|
|
*input = tmp;
|
|
}
|
|
|
|
void process_console_input(blade_handle_t *bh, char *line)
|
|
{
|
|
char *args = line;
|
|
char *cmd = NULL;
|
|
ks_bool_t found = KS_FALSE;
|
|
|
|
ks_log(KS_LOG_DEBUG, "Output: %s\n", line);
|
|
|
|
parse_argument(&args, &cmd, ' ');
|
|
|
|
ks_log(KS_LOG_DEBUG, "Command: %s, Args: %s\n", cmd, args);
|
|
|
|
for (int32_t index = 0; command_defs[index].cmd; ++index) {
|
|
if (!strcmp(command_defs[index].cmd, cmd)) {
|
|
found = KS_TRUE;
|
|
command_defs[index].callback(bh, args);
|
|
}
|
|
}
|
|
if (!found) ks_log(KS_LOG_INFO, "Command '%s' unknown.\n", cmd);
|
|
}
|
|
|
|
void command_test(blade_handle_t *bh, char *args)
|
|
{
|
|
ks_log(KS_LOG_DEBUG, "Hello World!\n");
|
|
}
|
|
|
|
void command_quit(blade_handle_t *bh, char *args)
|
|
{
|
|
ks_assert(bh);
|
|
ks_assert(args);
|
|
|
|
ks_log(KS_LOG_DEBUG, "Shutting down\n");
|
|
g_shutdown = KS_TRUE;
|
|
}
|
|
|
|
void command_store(blade_handle_t *bh, char *args)
|
|
{
|
|
char *key;
|
|
char *data;
|
|
|
|
ks_assert(args);
|
|
|
|
parse_argument(&args, &key, ' ');
|
|
parse_argument(&args, &data, ' ');
|
|
|
|
blade_handle_datastore_store(bh, key, strlen(key), data, strlen(data) + 1);
|
|
}
|
|
|
|
ks_bool_t blade_datastore_fetch_callback(blade_datastore_t *bds, const void *data, uint32_t data_length, void *userdata)
|
|
{
|
|
ks_log(KS_LOG_INFO, "%s\n", data);
|
|
return KS_TRUE;
|
|
}
|
|
|
|
void command_fetch(blade_handle_t *bh, char *args)
|
|
{
|
|
char *key;
|
|
|
|
ks_assert(args);
|
|
|
|
parse_argument(&args, &key, ' ');
|
|
|
|
blade_handle_datastore_fetch(bh, blade_datastore_fetch_callback, key, strlen(key), bh);
|
|
}
|
|
|
|
void command_connect(blade_handle_t *bh, char *args)
|
|
{
|
|
blade_connection_t *bc = NULL;
|
|
blade_identity_t *target = NULL;
|
|
|
|
ks_assert(bh);
|
|
ks_assert(args);
|
|
|
|
blade_identity_create(&target, blade_handle_pool_get(bh));
|
|
|
|
if (blade_identity_parse(target, args) == KS_STATUS_SUCCESS) blade_handle_connect(bh, &bc, target);
|
|
|
|
blade_identity_destroy(&target);
|
|
}
|