diff --git a/libdap-app-cli b/libdap-app-cli
deleted file mode 160000
index 8c21d84db9762ba3a5c0699599d9f98823bc280b..0000000000000000000000000000000000000000
--- a/libdap-app-cli
+++ /dev/null
@@ -1 +0,0 @@
-Subproject commit 8c21d84db9762ba3a5c0699599d9f98823bc280b
diff --git a/libdap-app-cli/CMakeLists.txt b/libdap-app-cli/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..7ca7367a4742324d8576c9a8914d649989bde1a5
--- /dev/null
+++ b/libdap-app-cli/CMakeLists.txt
@@ -0,0 +1,24 @@
+cmake_minimum_required(VERSION 2.8)
+project (dap_app_cli)
+
+set(DAP_APP_CLI_SRCS
+ src/dap_app_cli.c
+ src/dap_app_cli_net.c
+ src/dap_app_cli_shell.c
+ )
+
+set(DAP_APP_CLI_HEADERS
+ include/dap_app_cli.h
+ include/dap_app_cli_net.h
+ include/dap_app_cli_shell.h
+ )
+
+
+if(WIN32)
+ #include_directories(../3rdparty/curl/include/)
+endif()
+
+add_library(${PROJECT_NAME} STATIC ${DAP_APP_CLI_SRCS} ${DAP_APP_CLI_HEADERS} )
+
+target_link_libraries(${PROJECT_NAME} dap_core dap_chain_net m)
+target_include_directories(${PROJECT_NAME} PUBLIC include/ )
diff --git a/libdap-app-cli/README.md b/libdap-app-cli/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..6de2a0b76165680b8fb3ece91b3012bc18a1312f
--- /dev/null
+++ b/libdap-app-cli/README.md
@@ -0,0 +1,2 @@
+# libdap-chain-cli
+
diff --git a/libdap-app-cli/include/dap_app_cli.h b/libdap-app-cli/include/dap_app_cli.h
new file mode 100644
index 0000000000000000000000000000000000000000..944bb9c96ca46a3d0e3276dd07813e12a5ac7c98
--- /dev/null
+++ b/libdap-app-cli/include/dap_app_cli.h
@@ -0,0 +1,53 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <kahovski@gmail.com>
+ * DeM Labs Inc. https://demlabs.net
+ * DeM Labs Open source community https://github.com/demlabsinc
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+
+// command description
+typedef struct dap_app_cli_cmd_state {
+ char *cmd_name;
+ char **cmd_param;
+ int cmd_param_count;
+ int ret_code;
+ // for reply
+ char *cmd_res;
+ size_t cmd_res_len;
+ size_t cmd_res_cur;
+} dap_app_cli_cmd_state_t;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+/**
+ * Clear and delete memory of structure cmd_state
+ */
+void dap_app_cli_free_cmd_state(dap_app_cli_cmd_state_t *cmd);
+
+int dap_app_cli_main(const char * a_app_name, const char * a_socket_path, int argc, char **argv);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/libdap-app-cli/include/dap_app_cli_net.h b/libdap-app-cli/include/dap_app_cli_net.h
new file mode 100755
index 0000000000000000000000000000000000000000..e22056f9bfb17ddd9d264f41967764c86efc848a
--- /dev/null
+++ b/libdap-app-cli/include/dap_app_cli_net.h
@@ -0,0 +1,53 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <kahovski@gmail.com>
+ * DeM Labs Inc. https://demlabs.net
+ * DeM Labs Open source community https://github.com/demlabsinc
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "dap_app_cli.h"
+#include "dap_events_socket.h"
+
+#define DAP_CLI_HTTP_RESPONSE_SIZE_MAX 8192
+#define DAP_CLI_HTTP_TIMEOUT 10 // seconds
+#define DAP_CLI_ERROR_FORMAT -1
+#define DAP_CLI_ERROR_TIMEOUT -2
+#define DAP_CLI_ERROR_SOCKET -3
+
+// connection description
+typedef uint64_t dap_app_cli_connect_param_t;
+
+/**
+ * Connect to node unix socket server
+ *
+ * return struct connect_param if connect established, else NULL
+ */
+dap_app_cli_connect_param_t* dap_app_cli_connect(const char * a_socket_path);
+
+/**
+ * Send request to kelvin-node
+ *
+ * return 0 if OK, else error code
+ */
+int dap_app_cli_post_command(dap_app_cli_connect_param_t *socket, dap_app_cli_cmd_state_t *cmd);
+
+int dap_app_cli_disconnect(dap_app_cli_connect_param_t *socket);
diff --git a/libdap-app-cli/include/dap_app_cli_shell.h b/libdap-app-cli/include/dap_app_cli_shell.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fdfeb4a5bb6bffad4649bf8d4467e8b3df0ae2f
--- /dev/null
+++ b/libdap-app-cli/include/dap_app_cli_shell.h
@@ -0,0 +1,53 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <kahovski@gmail.com>
+ * DeM Labs Inc. https://demlabs.net
+ * DeM Labs Open source community https://github.com/demlabsinc
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#ifndef whitespace
+#define whitespace(c) (((c) == ' ') || ((c) == '\t'))
+#endif
+
+/*
+ * Initialize readline (and terminal if not already).
+ */
+int rl_initialize(void);
+
+/**
+ * Strip whitespace from the start and end of STRING. Return a pointer into STRING.
+ */
+char * rl_stripwhite(char *string);
+
+/**
+ * Read a line of input. Prompt with PROMPT. An empty PROMPT means none.
+ * A return value of NULL means that EOF was encountered.
+ */
+char *rl_readline(const char *prompt);
+
+/**
+ * Place STRING at the end of the history list.
+ */
+void add_history(const char *string);
+
+int parse_shell_options(char **argv, int arg_start, int arg_end);
+
diff --git a/libdap-app-cli/src/dap_app_cli.c b/libdap-app-cli/src/dap_app_cli.c
new file mode 100644
index 0000000000000000000000000000000000000000..923467b1cc275836a86071bd78335f423136139e
--- /dev/null
+++ b/libdap-app-cli/src/dap_app_cli.c
@@ -0,0 +1,218 @@
+/*
+ * Authors:
+ * Dmitriy A. Gearasimov <kahovski@gmail.com>
+ * DeM Labs Inc. https://demlabs.net
+ * DeM Labs Open source community https://github.com/demlabsinc
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stddef.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+//#include "dap_client.h"
+#include "dap_common.h"
+#include "dap_file_utils.h"
+#include "dap_strfuncs.h"
+#include "dap_chain_node_cli.h"
+#include "dap_app_cli.h"
+#include "dap_app_cli_net.h"
+#include "dap_app_cli_shell.h"
+
+
+#ifdef _WIN32
+#include "registry.h"
+#endif
+
+
+/**
+ * split string to argc and argv
+ */
+static char** split_word(char *line, int *argc)
+{
+ if(!line)
+ {
+ if(argc)
+ *argc = 0;
+ return NULL ;
+ }
+ char **argv = calloc(sizeof(char*), strlen(line));
+ int n = 0;
+ char *s, *start = line;
+ size_t len = strlen(line);
+ for(s = line; s <= line + len; s++) {
+ if(whitespace(*s)) {
+ *s = '\0';
+ argv[n] = start;
+ s++;
+ // miss spaces
+ for(; whitespace(*s); s++)
+ ;
+ start = s;
+ n++;
+ }
+ }
+ // last param
+ if(len) {
+ argv[n] = start;
+ n++;
+ }
+ if(argc)
+ *argc = n;
+ return argv;
+}
+
+/*
+ * Execute a command line.
+ */
+int execute_line(dap_app_cli_connect_param_t *cparam, char *line)
+{
+ register int i;
+ dap_chain_node_cmd_item_t *command;
+ char *word;
+
+ /* Isolate the command word. */
+ i = 0;
+ while(line[i] && whitespace(line[i]))
+ i++;
+ word = line + i;
+
+ int argc = 0;
+ char **argv = split_word(word, &argc);
+
+ // Call the function
+ if(argc > 0) {
+ dap_app_cli_cmd_state_t cmd;
+ memset(&cmd, 0, sizeof(dap_app_cli_cmd_state_t));
+ cmd.cmd_name = (char *) argv[0];
+ cmd.cmd_param_count = argc - 1;
+ if(cmd.cmd_param_count > 0)
+ cmd.cmd_param = (char**) (argv + 1);
+ // Send command
+ int res = dap_app_cli_post_command(cparam, &cmd);
+ return res;
+ }
+ fprintf(stderr, "No command\n");
+ return -1;
+}
+
+/**
+ * Clear and delete memory of structure cmd_state
+ */
+void dap_app_cli_free_cmd_state(dap_app_cli_cmd_state_t *cmd) {
+ if(!cmd->cmd_param)
+ return;
+ for(int i = 0; i < cmd->cmd_param_count; i++)
+ {
+ DAP_DELETE(cmd->cmd_param[i]);
+ }
+ DAP_DELETE(cmd->cmd_res);
+ DAP_DELETE(cmd);
+}
+
+/**
+ * Read and execute commands until EOF is reached. This assumes that
+ * the input source has already been initialized.
+ */
+int shell_reader_loop(dap_app_cli_connect_param_t *cparam)
+{
+ char *line, *s;
+
+ rl_initialize(); /* Bind our completer. */
+ int done = 0;
+ // Loop reading and executing lines until the user quits.
+ for(; done == 0;) {
+ // Read a line of input
+ line = rl_readline("> ");
+
+ if(!line)
+ break;
+
+ /* Remove leading and trailing whitespace from the line.
+ Then, if there is anything left, add it to the history list
+ and execute it. */
+ s = rl_stripwhite(line);
+
+ if(*s)
+ {
+ add_history(s);
+ execute_line(cparam, s);
+ }
+
+ DAP_DELETE(line);
+ }
+
+ return 0;
+}
+
+
+/**
+ * @brief dap_app_cli_main
+ * @param argc
+ * @param argv
+ * @return
+ */
+int dap_app_cli_main(const char * a_app_name, const char * a_socket_path, int a_argc, char **a_argv)
+{
+ dap_set_appname(a_app_name);
+ if (dap_common_init(dap_get_appname(), NULL) != 0) {
+ printf("Fatal Error: Can't init common functions module");
+ return -2;
+ }
+
+ dap_log_level_set(L_CRITICAL);
+#ifdef _WIN32
+ WSADATA wsaData;
+ WSAStartup(MAKEWORD(2,2), &wsaData);
+#endif
+ // connect to node
+ dap_app_cli_connect_param_t *cparam = dap_app_cli_connect( a_socket_path );
+ if(!cparam)
+ {
+ printf("Can't connect to %s on socket %s\n",dap_get_appname(), a_socket_path);
+ exit(-1);
+ }
+
+ if(a_argc > 1){
+ // Call the function
+ dap_app_cli_cmd_state_t cmd;
+ memset(&cmd, 0, sizeof(dap_app_cli_cmd_state_t));
+ cmd.cmd_name = strdup(a_argv[1]);
+ cmd.cmd_param_count = a_argc - 2;
+ if(cmd.cmd_param_count > 0)
+ cmd.cmd_param = (char**) (a_argv + 2);
+ // Send command
+ int res = dap_app_cli_post_command(cparam, &cmd);
+ dap_app_cli_disconnect(cparam);
+#ifdef _WIN32
+ WSACleanup();
+#endif
+ return res;
+ }else{
+ // command not found, start interactive shell
+ shell_reader_loop(cparam);
+ dap_app_cli_disconnect(cparam);
+ }
+#ifdef _WIN32
+ WSACleanup();
+#endif
+ return 0;
+}
+
diff --git a/libdap-app-cli/src/dap_app_cli_net.c b/libdap-app-cli/src/dap_app_cli_net.c
new file mode 100755
index 0000000000000000000000000000000000000000..2187f7ad2c4f7df47430395f7934fa9f67191dce
--- /dev/null
+++ b/libdap-app-cli/src/dap_app_cli_net.c
@@ -0,0 +1,220 @@
+/*
+ * Authors:
+ * Dmitriy A. Gerasimov <kahovski@gmail.com>
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * DeM Labs Open source community https://github.com/demlabsinc
+ * Copyright (c) 2017-2019
+ * All rights reserved.
+
+ This file is part of DAP (Deus Applications Prototypes) the open source project
+
+ DAP (Deus Applicaions Prototypes) is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ DAP is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+//#include <dap_client.h>
+
+#include <stdlib.h>
+#include <sys/types.h>
+#include <assert.h>
+#include <errno.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#else
+#include <sys/socket.h>
+#include <sys/un.h>
+#endif
+
+#include "dap_common.h"
+#include "dap_string.h"
+#include "dap_strfuncs.h"
+#include "dap_chain_node_cli.h" // for UNIX_SOCKET_FILE
+#include "dap_app_cli.h"
+#include "dap_app_cli_net.h"
+
+static int s_status;
+
+//callback function to receive http data
+static void dap_app_cli_http_read(uint64_t *socket, dap_app_cli_cmd_state_t *l_cmd)
+{
+ size_t l_recv_len = recv(*socket, &l_cmd->cmd_res[l_cmd->cmd_res_cur], DAP_CLI_HTTP_RESPONSE_SIZE_MAX, 0);
+ if (l_recv_len == -1) {
+ s_status = DAP_CLI_ERROR_SOCKET;
+ return;
+ }
+ l_cmd->cmd_res_cur += l_recv_len;
+ switch (s_status) {
+ case 1: { // Find content length
+ const char *l_cont_len_str = "Content-Length: ";
+ char *l_str_ptr = strstr(l_cmd->cmd_res, l_cont_len_str);
+ if (l_str_ptr && strstr(l_str_ptr, "\r\n")) {
+ l_cmd->cmd_res_len = atoi(l_str_ptr + strlen(l_cont_len_str));
+ if (l_cmd->cmd_res_len == 0) {
+ s_status = DAP_CLI_ERROR_FORMAT;
+ } else {
+ s_status++;
+ }
+ } else {
+ break;
+ }
+ }
+ case 2: { // Find header end and throw out header
+ const char *l_head_end_str = "\r\n\r\n";
+ char *l_str_ptr = strstr(l_cmd->cmd_res, l_head_end_str);
+ if (l_str_ptr) {
+ l_str_ptr += strlen(l_head_end_str);
+ size_t l_head_size = l_str_ptr - l_cmd->cmd_res;
+ strncpy(l_cmd->cmd_res, l_str_ptr, l_cmd->cmd_res_cur - l_head_size);
+ l_cmd->cmd_res_cur -= l_head_size;
+ s_status++;
+ } else {
+ break;
+ }
+ }
+ default:
+ case 3: { // Complete command reply
+ if (l_cmd->cmd_res_cur == l_cmd->cmd_res_len) {
+ l_cmd->cmd_res[l_cmd->cmd_res_cur] = 0;
+ s_status = 0;
+ }
+ } break;
+ }
+}
+
+/**
+ * @brief dap_app_cli_connect
+ * @details Connect to node unix socket server
+ * @param a_socket_path
+ * @return if connect established, else NULL
+ */
+dap_app_cli_connect_param_t* dap_app_cli_connect(const char *a_socket_path)
+{
+ // set socket param
+ int buffsize = DAP_CLI_HTTP_RESPONSE_SIZE_MAX;
+#ifdef WIN32
+ // TODO connect to the named pipe "\\\\.\\pipe\\node_cli.pipe"
+ uint16_t l_cli_port = dap_config_get_item_uint16 ( g_config, "conserver", "listen_port_tcp");
+ if (!l_cli_port)
+ return NULL;
+ SOCKET l_socket = socket(AF_INET, SOCK_STREAM, 0);
+ setsockopt((SOCKET)l_socket, SOL_SOCKET, SO_SNDBUF, (char *)&buffsize, sizeof(int) );
+ setsockopt((SOCKET)l_socket, SOL_SOCKET, SO_RCVBUF, (char *)&buffsize, sizeof(int) );
+#else
+ if (!a_socket_path) {
+ return NULL;
+ }
+ // create socket
+ int l_socket = socket(AF_UNIX, SOCK_STREAM, 0);
+ if (l_socket < 0) {
+ return NULL;
+ }
+ setsockopt(l_socket, SOL_SOCKET, SO_SNDBUF, (void*) &buffsize, sizeof(buffsize));
+ setsockopt(l_socket, SOL_SOCKET, SO_RCVBUF, (void*) &buffsize, sizeof(buffsize));
+#endif
+ // connect
+ int l_addr_len;
+#ifdef WIN32
+ struct sockaddr_in l_remote_addr;
+ l_remote_addr.sin_family = AF_INET;
+ IN_ADDR _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
+ l_remote_addr.sin_addr = _in_addr;
+ l_remote_addr.sin_port = l_cli_port;
+ l_addr_len = sizeof(struct sockaddr_in);
+#else
+ struct sockaddr_un l_remote_addr;
+ l_remote_addr.sun_family = AF_UNIX;
+ strcpy(l_remote_addr.sun_path, a_socket_path);
+ l_addr_len = SUN_LEN(&l_remote_addr);
+#endif
+ if (connect(l_socket, (struct sockaddr *)&l_remote_addr, l_addr_len) == SOCKET_ERROR) {
+#ifdef __WIN32
+ _set_errno(WSAGetLastError());
+#endif
+ printf("Socket connection err: %d\n", errno);
+ closesocket(l_socket);
+ return NULL;
+ }
+ uint64_t *l_ret = DAP_NEW(uint64_t);
+ *l_ret = l_socket;
+ return l_ret;
+}
+
+/**
+ * Send request to kelvin-node
+ *
+ * return 0 if OK, else error code
+ */
+int dap_app_cli_post_command( dap_app_cli_connect_param_t *a_socket, dap_app_cli_cmd_state_t *a_cmd )
+{
+ if(!a_socket || !a_cmd || !a_cmd->cmd_name) {
+ assert(0);
+ return -1;
+ }
+ s_status = 1;
+ a_cmd->cmd_res = DAP_NEW_Z_SIZE(char, DAP_CLI_HTTP_RESPONSE_SIZE_MAX);
+ a_cmd->cmd_res_cur = 0;
+ dap_string_t *l_cmd_data = dap_string_new(a_cmd->cmd_name);
+ if (a_cmd->cmd_param) {
+ for (int i = 0; i < a_cmd->cmd_param_count; i++) {
+ if (a_cmd->cmd_param[i]) {
+ dap_string_append(l_cmd_data, "\r\n");
+ dap_string_append(l_cmd_data, a_cmd->cmd_param[i]);
+ }
+ }
+ }
+ dap_string_append(l_cmd_data, "\r\n\r\n");
+ dap_string_t *l_post_data = dap_string_new("");
+ dap_string_printf(l_post_data, "POST /connect HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Content-Type: text/text\r\n"
+ "Content-Length: %d\r\n"
+ "\r\n"
+ "%s", l_cmd_data->len, l_cmd_data->str);
+ send(*a_socket, l_post_data->str, l_post_data->len, 0);
+
+ //wait for command execution
+ time_t l_start_time = time(NULL);
+ while(s_status > 0) {
+ dap_app_cli_http_read(a_socket, a_cmd);
+ if (time(NULL) - l_start_time > DAP_CLI_HTTP_TIMEOUT)
+ return DAP_CLI_ERROR_TIMEOUT;
+ }
+ // process result
+ if (a_cmd->cmd_res && !s_status) {
+ char **l_str = dap_strsplit(a_cmd->cmd_res, "\r\n", 1);
+ int l_cnt = dap_str_countv(l_str);
+ char *l_str_reply = NULL;
+ if (l_cnt == 2) {
+ long l_err_code = strtol(l_str[0], NULL, 10);
+ l_str_reply = l_str[1];
+ }
+ printf("%s\n", (l_str_reply) ? l_str_reply : "no response");
+ dap_strfreev(l_str);
+ }
+ DAP_DELETE(a_cmd->cmd_res);
+ dap_string_free(l_cmd_data, true);
+ dap_string_free(l_post_data, true);
+ return s_status;
+}
+
+int dap_app_cli_disconnect(dap_app_cli_connect_param_t *a_socket)
+{
+ closesocket(*a_socket);
+ DAP_DELETE(a_socket);
+}
diff --git a/libdap-app-cli/src/dap_app_cli_shell.c b/libdap-app-cli/src/dap_app_cli_shell.c
new file mode 100644
index 0000000000000000000000000000000000000000..cefbdf196927b8ac323b8a8a475fda318e6a0368
--- /dev/null
+++ b/libdap-app-cli/src/dap_app_cli_shell.c
@@ -0,0 +1,355 @@
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <stdlib.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <getopt.h>
+#include <signal.h>
+#include <string.h>
+#include <assert.h>
+#include <setjmp.h>
+#include <locale.h>
+
+#ifdef _WIN32
+#include <winsock2.h>
+#include <windows.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#include <pthread.h>
+#else
+#include <sys/ttydefaults.h>
+#endif
+
+#include "dap_common.h"
+#include "dap_app_cli.h"
+#include "dap_app_cli_shell.h"
+
+//#include "posixjmp.h"
+
+#ifndef savestring
+#define savestring(x) strcpy ((char *)malloc (1 + strlen (x)), (x))
+#endif
+
+typedef void rl_voidfunc_t(void);
+typedef void rl_vintfunc_t(int);
+
+/* Current prompt. */
+char *rl_prompt = (char *) NULL;
+int rl_visible_prompt_length = 0;
+
+/* Non-zero means we have been called at least once before. */
+static int rl_initialized;
+
+/* The stuff that gets printed out before the actual text of the line.
+ This is usually pointing to rl_prompt. */
+char *rl_display_prompt = (char *) NULL;
+
+/* Non-zero makes this the next keystroke to read. */
+int rl_pending_input = 0;
+
+/* Make this non-zero to return the current input_line. */
+int rl_done;
+/* Non-zero if the previous command was a kill command. */
+int _rl_last_command_was_kill = 0;
+
+/* Top level environment for readline_internal (). */
+jmp_buf _rl_top_level;
+
+/* Length of the current input line. */
+int rl_end;
+
+/* The character that can generate an EOF. Really read from
+ the terminal driver... just defaulted here. */
+//int _rl_eof_char = CTRL('D');
+
+#define NEWLINE '\n'
+
+/* Input error; can be returned by (*rl_getc_function) if readline is reading
+ a top-level command (RL_ISSTATE (RL_STATE_READCMD)). */
+#define READERR (-2)
+
+/* Possible state values for rl_readline_state */
+#define RL_STATE_NONE 0x000000 /* no state; before first call */
+
+#define RL_STATE_INITIALIZING 0x0000001 /* initializing */
+#define RL_STATE_INITIALIZED 0x0000002 /* initialization done */
+#define RL_STATE_READCMD 0x0000008 /* reading a command key */
+#define RL_STATE_INPUTPENDING 0x0020000 /* rl_execute_next called */
+#define RL_STATE_TERMPREPPED 0x0000004 /* terminal is prepped */
+
+/* Flags word encapsulating the current readline state. */
+unsigned long rl_readline_state = RL_STATE_NONE;
+
+#define RL_SETSTATE(x) (rl_readline_state |= (x))
+#define RL_UNSETSTATE(x) (rl_readline_state &= ~(x))
+#define RL_ISSTATE(x) (rl_readline_state & (x))
+
+/* The names of the streams that we do input and output to. */
+FILE *rl_instream = (FILE *) NULL;
+FILE *rl_outstream = (FILE *) NULL;
+
+/**
+ * Read one symbol
+ */
+unsigned char rl_getc(FILE *stream)
+{
+ int result;
+ unsigned char c;
+
+ while(1)
+ {
+
+#if defined (__MINGW32__)
+ if (isatty (fileno (stream)))
+ return (_getch ()); /* "There is no error return." */
+#endif
+ result = 0;
+ if(result >= 0)
+ result = read(fileno(stream), &c, sizeof(unsigned char));
+ if(result == sizeof(unsigned char))
+ return (c);
+
+ /* If zero characters are returned, then the file that we are
+ reading from is empty! Return EOF in that case. */
+ if(result == 0)
+ return (EOF);
+ }
+}
+
+/**
+ * Set up the prompt and expand it. Called from readline()
+ */
+int rl_set_prompt(const char *prompt)
+{
+ free(rl_prompt);
+ rl_prompt = prompt ? savestring(prompt) : (char *) NULL;
+ rl_display_prompt = rl_prompt ? rl_prompt : "";
+ fprintf(stdout, "%s", prompt);
+ fflush(stdout);
+ //rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
+ return 0;
+}
+
+/**
+ * Read a line of input. Prompt with PROMPT. An empty PROMPT means none.
+ * A return value of NULL means that EOF was encountered.
+ */
+char *rl_readline(const char *prompt)
+{
+ int value_size = 3, value_len = 0;
+ char *value = DAP_NEW_Z_SIZE(char, value_size + 1);
+
+ // Set up the prompt
+ rl_set_prompt(prompt);
+
+ // Read a line of input from the global rl_instream, doing output on the global rl_outstream.
+ while(1)
+ {
+ unsigned char c = rl_getc(rl_instream);
+
+ if(c == EOF || c == NEWLINE)
+ break;
+ value[value_len] = c;
+ value_len++;
+ if(value_len == value_size) {
+ value_size += 32;
+ value = realloc(value, value_size + 1);
+ }
+ }
+ return (value);
+}
+
+static char* _rl_get_locale_var(const char *v)
+{
+ char *lspec;
+
+ lspec = getenv("LC_ALL");
+ if(lspec == 0 || *lspec == 0)
+ lspec = getenv(v);
+ if(lspec == 0 || *lspec == 0)
+ lspec = getenv("LANG");
+
+ return lspec;
+}
+
+/*
+ * Query the right environment variables and call setlocale() to initialize
+ * the C library locale settings.
+ */
+static char* _rl_init_locale(void)
+{
+ char *ret, *lspec;
+
+ /* Set the LC_CTYPE locale category from environment variables. */
+ lspec = _rl_get_locale_var("LC_CTYPE");
+ /* Since _rl_get_locale_var queries the right environment variables,
+ we query the current locale settings with setlocale(), and, if
+ that doesn't return anything, we set lspec to the empty string to
+ force the subsequent call to setlocale() to define the `native'
+ environment. */
+ if(lspec == 0 || *lspec == 0)
+ lspec = setlocale(LC_CTYPE, (char *) NULL);
+ if(lspec == 0)
+ lspec = "";
+ ret = setlocale(LC_CTYPE, lspec); /* ok, since it does not change locale */
+
+ //_rl_utf8locale = (ret && *ret) ? utf8locale (ret) : 0;
+
+ return ret;
+}
+
+/*
+ * Initialize readline (and terminal if not already).
+ */
+int rl_initialize(void)
+{
+ /* If we have never been called before, initialize the
+ terminal and data structures. */
+ if(rl_initialized == 0)
+ {
+ RL_SETSTATE(RL_STATE_INITIALIZING);
+ rl_instream = (FILE *) stdin;
+ rl_outstream = (FILE *) stdout;
+ RL_UNSETSTATE(RL_STATE_INITIALIZING);
+ rl_initialized++;
+ RL_SETSTATE(RL_STATE_INITIALIZED);
+ }
+ else
+ (void) _rl_init_locale(); /* check current locale */
+ RL_SETSTATE(RL_STATE_INITIALIZING);
+ rl_instream = (FILE *) stdin;
+ rl_outstream = (FILE *) stdout;
+ RL_UNSETSTATE(RL_STATE_INITIALIZING);
+ return 0;
+}
+
+int parse_shell_options(char **argv, int arg_start, int arg_end)
+{
+ int arg_index;
+ int arg_character, on_or_off, next_arg, i;
+ char *o_option, *arg_string;
+
+ arg_index = arg_start;
+ while(arg_index != arg_end && (arg_string = argv[arg_index]) &&
+ (*arg_string == '-' || *arg_string == '+'))
+ {
+ /* There are flag arguments, so parse them. */
+ next_arg = arg_index + 1;
+
+ /* A single `-' signals the end of options. From the 4.3 BSD sh.
+ An option `--' means the same thing; this is the standard
+ getopt(3) meaning. */
+ if(arg_string[0] == '-' &&
+ (arg_string[1] == '\0' ||
+ (arg_string[1] == '-' && arg_string[2] == '\0')))
+ return (next_arg);
+
+ i = 1;
+ on_or_off = arg_string[0];
+ while(arg_character = arg_string[i++])
+ {
+ switch (arg_character)
+ {
+ case 'c':
+ //want_pending_command = 1;
+ break;
+
+ case 'l':
+ //make_login_shell = 1;
+ break;
+
+ case 's':
+ //read_from_stdin = 1;
+ break;
+
+ case 'o':
+ o_option = argv[next_arg];
+ if(o_option == 0)
+ {
+ //list_minus_o_opts(-1, (on_or_off == '-') ? 0 : 1);
+ break;
+ }
+ //if(set_minus_o_option(on_or_off, o_option) != EXECUTION_SUCCESS)
+ // exit(EX_BADUSAGE);
+ next_arg++;
+ break;
+
+ case 'O':
+ /* Since some of these can be overridden by the normal
+ interactive/non-interactive shell initialization or
+ initializing posix mode, we save the options and process
+ them after initialization. */
+ o_option = argv[next_arg];
+ if(o_option == 0)
+ {
+ //shopt_listopt(o_option, (on_or_off == '-') ? 0 : 1);
+ break;
+ }
+ //add_shopt_to_alist(o_option, on_or_off);
+ next_arg++;
+ break;
+
+ case 'D':
+ //dump_translatable_strings = 1;
+ break;
+
+ default:
+ break;
+// if(change_flag(arg_character, on_or_off) == FLAG_ERROR)
+// {
+// report_error(_("%c%c: invalid option"), on_or_off, arg_character);
+// show_shell_usage(stderr, 0);
+// exit(EX_BADUSAGE);
+// }
+ }
+ }
+ /* Can't do just a simple increment anymore -- what about
+ "bash -abouo emacs ignoreeof -hP"? */
+ arg_index = next_arg;
+ }
+
+ return (arg_index);
+}
+
+/**
+ * Strip whitespace from the start and end of STRING. Return a pointer into STRING.
+ */
+char * rl_stripwhite(char *string)
+{
+ register char *s, *t;
+
+ for(s = string; whitespace(*s); s++)
+ ;
+
+ if(*s == 0)
+ return (s);
+
+ t = s + strlen(s) - 1;
+ while(t > s && whitespace(*t))
+ t--;
+ *++t = '\0';
+
+ return s;
+}
+
+/* The structure used to store a history entry. */
+typedef struct _hist_entry {
+ char *line;
+ char *timestamp; /* char * rather than time_t for read/write */
+ char *data;
+} HIST_ENTRY;
+
+/**
+ * Place STRING at the end of the history list.
+ */
+void add_history(const char *string)
+{
+ HIST_ENTRY *temp;
+ // The data field is set to NULL
+ // TODO
+}