diff --git a/CMakeLists.txt b/CMakeLists.txt
index 3289a8bf8bfa5337a7de40060c8b1b383be512c5..10b6762805e8667f0402af6144c56763934ca3e0 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -35,7 +35,7 @@ endif()
if (CELLFRAME_MODULES MATCHES "network")
- set(DAPSDK_MODULES "${DAPSDK_MODULES} network-core network-client network-server")
+ set(DAPSDK_MODULES "${DAPSDK_MODULES} app-cli plugin network-core network-client network-server")
endif()
if (CELLFRAME_MODULES MATCHES "dap-sdk-net-client")
diff --git a/dap-sdk/CMakeLists.txt b/dap-sdk/CMakeLists.txt
index 0781b5dec7acebc17ae9a3b356220bb8efc7f688..1a7d3a23383c730c332d1bbc7266483099f05acb 100644
--- a/dap-sdk/CMakeLists.txt
+++ b/dap-sdk/CMakeLists.txt
@@ -14,6 +14,14 @@ if (DAPSDK_MODULES MATCHES "crypto")
add_subdirectory(crypto)
endif()
+if (DAPSDK_MODULES MATCHES "app-cli")
+ add_subdirectory(net/app-cli)
+endif()
+
+if (DAPSDK_MODULES MATCHES "plugin")
+ add_subdirectory(plugin)
+endif()
+
# I/O subsystem
if (DAPSDK_MODULES MATCHES "io")
add_subdirectory(io)
diff --git a/dap-sdk/core/include/dap_common.h b/dap-sdk/core/include/dap_common.h
index 972a8b9902a62554eb219d0960c8b9d0cc812a5b..1269d8eeb2f8647d1c76cab5698f558c411661ba 100755
--- a/dap-sdk/core/include/dap_common.h
+++ b/dap-sdk/core/include/dap_common.h
@@ -511,6 +511,52 @@ char **dap_parse_items(const char *a_str, char a_delimiter, int *a_count, const
unsigned int dap_crc32c(unsigned int crc, const void *buf, size_t buflen);
+static inline const char *dap_get_arch() { //Get current architecture, detectx nearly every architecture. Coded by Freak
+ #if defined(__x86_64__) || defined(_M_X64)
+ return "x86_64";
+ #elif defined(i386) || defined(__i386__) || defined(__i386) || defined(_M_IX86)
+ return "x86_32";
+ #elif defined(__ARM_ARCH_2__)
+ return "ARM2";
+ #elif defined(__ARM_ARCH_3__) || defined(__ARM_ARCH_3M__)
+ return "ARM3";
+ #elif defined(__ARM_ARCH_4T__) || defined(__TARGET_ARM_4T)
+ return "ARM4T";
+ #elif defined(__ARM_ARCH_5_) || defined(__ARM_ARCH_5E_)
+ return "ARM5"
+ #elif defined(__ARM_ARCH_6T2_) || defined(__ARM_ARCH_6T2_)
+ return "ARM6T2";
+ #elif defined(__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) || defined(__ARM_ARCH_6K__) || defined(__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__)
+ return "ARM6";
+ #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)
+ return "ARM7";
+ #elif defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)
+ return "ARM7A";
+ #elif defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) || defined(__ARM_ARCH_7S__)
+ return "ARM7R";
+ #elif defined(__ARM_ARCH_7M__)
+ return "ARM7M";
+ #elif defined(__ARM_ARCH_7S__)
+ return "ARM7S";
+ #elif defined(__aarch64__) || defined(_M_ARM64)
+ return "ARM64";
+ #elif defined(mips) || defined(__mips__) || defined(__mips)
+ return "MIPS";
+ #elif defined(__sh__)
+ return "SUPERH";
+ #elif defined(__powerpc) || defined(__powerpc__) || defined(__powerpc64__) || defined(__POWERPC__) || defined(__ppc__) || defined(__PPC__) || defined(_ARCH_PPC)
+ return "POWERPC";
+ #elif defined(__PPC64__) || defined(__ppc64__) || defined(_ARCH_PPC64)
+ return "POWERPC64";
+ #elif defined(__sparc__) || defined(__sparc)
+ return "SPARC";
+ #elif defined(__m68k__)
+ return "M68K";
+ #else
+ return "UNKNOWN";
+ #endif
+ }
+
#ifdef __MINGW32__
int exec_silent(const char *a_cmd);
#endif
diff --git a/dap-sdk/core/include/dap_config.h b/dap-sdk/core/include/dap_config.h
index 806bf6eac74972a437c21d19bb5c3c77a577d5b1..944c32002002835bbab45191988e7a5f2a109bd1 100755
--- a/dap-sdk/core/include/dap_config.h
+++ b/dap-sdk/core/include/dap_config.h
@@ -40,6 +40,7 @@ typedef struct dap_config{
int dap_config_init(const char * a_configs_path);
void dap_config_deinit();
dap_config_t * dap_config_open(const char * a_name);
+dap_config_t * dap_config_load(const char * a_file_path);
void dap_config_close(dap_config_t * a_config);
const char * dap_config_path();
diff --git a/dap-sdk/core/src/dap_config.c b/dap-sdk/core/src/dap_config.c
index 27f0a2e3fb21ef19d815b3abc9c54ed9d110ba98..e4961e6621e917a4c7fa215ab5cb3af4e7fc9b7f 100755
--- a/dap-sdk/core/src/dap_config.c
+++ b/dap-sdk/core/src/dap_config.c
@@ -105,194 +105,207 @@ static uint16_t get_array_length(const char* str) {
*/
dap_config_t * dap_config_open(const char * a_name)
{
- dap_config_t * ret = NULL;
+ dap_config_t * l_ret = NULL;
if ( a_name ){
log_it(L_DEBUG,"Looking for config name %s...",a_name);
size_t l_config_path_size_max = strlen(a_name)+6+strlen(s_configs_path);
char *l_config_path = DAP_NEW_SIZE(char,l_config_path_size_max);
snprintf(l_config_path,l_config_path_size_max, "%s/%s.cfg",s_configs_path,a_name);
- FILE * f = fopen(l_config_path,"r");
- if ( f ){
- fseek(f, 0, SEEK_END);
- long buf_len = ftell(f);
- char buf[buf_len];
- fseek(f, 0L, SEEK_SET);
- log_it(L_DEBUG,"Opened config %s",l_config_path);
- ret = DAP_NEW_Z(dap_config_t);
- dap_config_internal_t * l_config_internal = DAP_NEW_Z(dap_config_internal_t);
- ret->_internal = l_config_internal;
- size_t l_global_offset=0;
- size_t l_buf_size=0;
- size_t l_buf_pos_line_start=0;
- size_t l_buf_pos_line_end=0;
- dap_config_item_t * l_section_current = NULL ;
- bool l_is_space_now = false;
- while ( feof(f)==0){ // Break on lines
- size_t i;
- l_global_offset += (l_buf_size = fread(buf, 1, buf_len, f) );
- for (i=0; i< l_buf_size; i++){
- if( (buf[i] == '\r') || (buf[i] == '\n' ) ){
- if( ! l_is_space_now){
- l_buf_pos_line_end = i;
- l_is_space_now = true;
- //if(l_buf_pos_line_end)
- // l_buf_pos_line_end--;
- if(l_buf_pos_line_end != l_buf_pos_line_start ){ // Line detected
- char *l_line = NULL;
- size_t l_line_length = 0;
- size_t j;
-
- // Trimming spaces and skip the line if commented
- for ( j = l_buf_pos_line_start; j < l_buf_pos_line_end; j++ ){
- if ( buf[j] == '#' )
- break;
- if (buf[j] != ' ' ){
- l_line_length = (l_buf_pos_line_end - j);
- break;
- }
+ l_ret = dap_config_load(l_config_path);
+ DAP_DELETE(l_config_path);
+ }else{
+ log_it(L_ERROR,"Config name is NULL");
+ }
+ return l_ret;
+}
+
+/**
+ * @brief Load config from file
+ * @param a_file_path
+ * @return
+ */
+dap_config_t * dap_config_load(const char * a_file_path)
+{
+ dap_config_t * l_ret = NULL;
+
+ FILE * f = fopen(a_file_path,"r");
+ if ( f ){
+ fseek(f, 0, SEEK_END);
+ long buf_len = ftell(f);
+ char buf[buf_len];
+ fseek(f, 0L, SEEK_SET);
+ log_it(L_DEBUG,"Opened config %s",a_file_path);
+ l_ret = DAP_NEW_Z(dap_config_t);
+ dap_config_internal_t * l_config_internal = DAP_NEW_Z(dap_config_internal_t);
+ l_ret->_internal = l_config_internal;
+ size_t l_global_offset=0;
+ size_t l_buf_size=0;
+ size_t l_buf_pos_line_start=0;
+ size_t l_buf_pos_line_end=0;
+ dap_config_item_t * l_section_current = NULL ;
+ bool l_is_space_now = false;
+ while ( feof(f)==0){ // Break on lines
+ size_t i;
+ l_global_offset += (l_buf_size = fread(buf, 1, buf_len, f) );
+ for (i=0; i< l_buf_size; i++){
+ if( (buf[i] == '\r') || (buf[i] == '\n' ) ){
+ if( ! l_is_space_now){
+ l_buf_pos_line_end = i;
+ l_is_space_now = true;
+ //if(l_buf_pos_line_end)
+ // l_buf_pos_line_end--;
+ if(l_buf_pos_line_end != l_buf_pos_line_start ){ // Line detected
+ char *l_line = NULL;
+ size_t l_line_length = 0;
+ size_t j;
+
+ // Trimming spaces and skip the line if commented
+ for ( j = l_buf_pos_line_start; j < l_buf_pos_line_end; j++ ){
+ if ( buf[j] == '#' )
+ break;
+ if (buf[j] != ' ' ){
+ l_line_length = (l_buf_pos_line_end - j);
+ break;
}
- if( l_line_length ){
- l_line = DAP_NEW_SIZE(char,l_line_length+1);
- memcpy(l_line,buf+j,l_line_length);
- l_line[l_line_length] = 0;
-
- // Process trimmed line
- if( (l_line[0] == '[' ) && (l_line[l_line_length-1] == ']' ) ){ // Section detected
- //log_it(L_DEBUG, "Raw line '%s'",l_line);
- char * l_section_name = strdup(l_line+1);
- size_t l_section_name_length = (l_line_length - 2);
- l_section_name[l_section_name_length]='\0';
- // log_it(L_DEBUG,"Config section '%s'",l_section_name);
-
- dap_config_item_t * l_item_section = DAP_NEW_Z(dap_config_item_t);
- strncpy(l_item_section->name,l_section_name,sizeof(l_item_section->name)-1);
- l_item_section->item_next = l_config_internal->item_root;
- l_config_internal->item_root = l_item_section;
- free(l_section_name);
-
- l_section_current = l_item_section;
- }else{ // key-value line
- //log_it(L_DEBUG,"Read line '%s'",l_line);
- char l_param_name[sizeof(l_section_current->name)];
- size_t l_param_name_size=0;
- size_t l_param_value_size=0;
- char l_param_value[1024];
- l_param_name[0] = 0;
- l_param_value[0] = 0;
- for ( j = 0; j < l_line_length; j++ ){ // Parse param name
- if ( ( l_line[j] == ' ' )|| ( l_line[j] == '=' ) ||( l_line[j] == '\t' ) ){ // Param name
- l_param_name_size = j;
- if (l_param_name_size > (sizeof(l_param_name) -1) ){
- l_param_name_size = (sizeof(l_param_name) - 1 );
- log_it(L_WARNING,"Too long param name in config, %zu is more than %zu maximum",
- j,sizeof(l_param_name) -1);
- }
- strncpy(l_param_name,l_line,j);
- l_param_name[j] = 0;
- break;
+ }
+ if( l_line_length ){
+ l_line = DAP_NEW_SIZE(char,l_line_length+1);
+ memcpy(l_line,buf+j,l_line_length);
+ l_line[l_line_length] = 0;
+
+ // Process trimmed line
+ if( (l_line[0] == '[' ) && (l_line[l_line_length-1] == ']' ) ){ // Section detected
+ //log_it(L_DEBUG, "Raw line '%s'",l_line);
+ char * l_section_name = strdup(l_line+1);
+ size_t l_section_name_length = (l_line_length - 2);
+ l_section_name[l_section_name_length]='\0';
+ // log_it(L_DEBUG,"Config section '%s'",l_section_name);
+
+ dap_config_item_t * l_item_section = DAP_NEW_Z(dap_config_item_t);
+ strncpy(l_item_section->name,l_section_name,sizeof(l_item_section->name)-1);
+ l_item_section->item_next = l_config_internal->item_root;
+ l_config_internal->item_root = l_item_section;
+ free(l_section_name);
+
+ l_section_current = l_item_section;
+ }else{ // key-value line
+ //log_it(L_DEBUG,"Read line '%s'",l_line);
+ char l_param_name[sizeof(l_section_current->name)];
+ size_t l_param_name_size=0;
+ size_t l_param_value_size=0;
+ char l_param_value[1024];
+ l_param_name[0] = 0;
+ l_param_value[0] = 0;
+ for ( j = 0; j < l_line_length; j++ ){ // Parse param name
+ if ( ( l_line[j] == ' ' )|| ( l_line[j] == '=' ) ||( l_line[j] == '\t' ) ){ // Param name
+ l_param_name_size = j;
+ if (l_param_name_size > (sizeof(l_param_name) -1) ){
+ l_param_name_size = (sizeof(l_param_name) - 1 );
+ log_it(L_WARNING,"Too long param name in config, %zu is more than %zu maximum",
+ j,sizeof(l_param_name) -1);
}
-
+ strncpy(l_param_name,l_line,j);
+ l_param_name[j] = 0;
+ break;
}
- for (; j < l_line_length; j++ ){ // Find beginning of param value
- if ( ( l_line[j] != '\t' ) && ( l_line[j] != ' ' ) && ( l_line[j] != '=' ) ){
+ }
+
+ for (; j < l_line_length; j++ ){ // Find beginning of param value
+ if ( ( l_line[j] != '\t' ) && ( l_line[j] != ' ' ) && ( l_line[j] != '=' ) ){
+ break;
+ }
+ }
+ l_param_value_size = l_line_length - j;
+ if (l_param_value_size ){
+ if (l_param_value_size > (sizeof(l_param_value) -1) ){
+ l_param_value_size = (sizeof(l_param_value) - 1 );
+ log_it(L_WARNING,"Too long param value in config, %zu is more than %zu maximum",
+ l_line_length - j,sizeof(l_param_value) -1);
+ }
+ strncpy(l_param_value,l_line +j, l_param_value_size);
+ l_param_value[l_param_value_size] = '\0';
+ for(int j=(int)l_param_value_size-1; j>=0; j--){
+ if( (l_param_value[j] ==' ') || (l_param_value[j] =='\t') ){
+ l_param_value[j] = '\0';
+ }else{
break;
}
}
- l_param_value_size = l_line_length - j;
- if (l_param_value_size ){
- if (l_param_value_size > (sizeof(l_param_value) -1) ){
- l_param_value_size = (sizeof(l_param_value) - 1 );
- log_it(L_WARNING,"Too long param value in config, %zu is more than %zu maximum",
- l_line_length - j,sizeof(l_param_value) -1);
- }
- strncpy(l_param_value,l_line +j, l_param_value_size);
- l_param_value[l_param_value_size] = '\0';
- for(int j=(int)l_param_value_size-1; j>=0; j--){
- if( (l_param_value[j] ==' ') || (l_param_value[j] =='\t') ){
- l_param_value[j] = '\0';
- }else{
- break;
- }
+ }
+ // log_it(L_DEBUG," Param '%s' = '%s'", l_param_name, l_param_value);
+ if (l_section_current){
+
+ if (l_param_value[0] == '[') {
+ if(l_param_value[1] == ']') {
+ //log_it(L_WARNING, "Empty array!");
+ DAP_DELETE(l_line);
+ continue;
}
- }
- // log_it(L_DEBUG," Param '%s' = '%s'", l_param_name, l_param_value);
- if (l_section_current){
-
- if (l_param_value[0] == '[') {
- if(l_param_value[1] == ']') {
- //log_it(L_WARNING, "Empty array!");
- DAP_DELETE(l_line);
- continue;
- }
-
- // delete '[' and ']'
- char* values = l_param_value + 1;
- values[l_param_value_size-2] = 0;
-
- dap_config_item_t * l_item = DAP_NEW_Z(dap_config_item_t);
-
- strncpy(l_item->name,l_param_name,sizeof(l_item->name));
- l_item->item_next = l_section_current->childs;
- l_item->is_array = true;
- l_section_current->childs = l_item;
- l_item->array_length = get_array_length(l_param_value);
- l_item->data_str_array = (char**) malloc (sizeof(char*) * l_item->array_length);
- // parsing items in array
- int j = 0;
- char * l_tmp = NULL;
- char *token = strtok_r(values, ",",&l_tmp);
- while(token) {
-
- // trim token whitespace
- if (isspace(token[0]))
- token = token + 1;
- char *closer = strchr(token, ']');
- if (closer) /* last item in array */
- *closer = 0;
-
- l_item->data_str_array[j] = strdup(token);
-
- token = strtok_r(NULL, ",",&l_tmp);
- j++;
- }
- l_item->array_length = j;
- } else {
- dap_config_item_t * l_item = DAP_NEW_Z(dap_config_item_t);
-
- strncpy(l_item->name,l_param_name,sizeof(l_item->name));
- l_item->item_next = l_section_current->childs;
- l_item->data_str = strdup (l_param_value);
-
- l_section_current->childs = l_item;
+
+ // delete '[' and ']'
+ char* values = l_param_value + 1;
+ values[l_param_value_size-2] = 0;
+
+ dap_config_item_t * l_item = DAP_NEW_Z(dap_config_item_t);
+
+ strncpy(l_item->name,l_param_name,sizeof(l_item->name));
+ l_item->item_next = l_section_current->childs;
+ l_item->is_array = true;
+ l_section_current->childs = l_item;
+ l_item->array_length = get_array_length(l_param_value);
+ l_item->data_str_array = (char**) malloc (sizeof(char*) * l_item->array_length);
+ // parsing items in array
+ int j = 0;
+ char * l_tmp = NULL;
+ char *token = strtok_r(values, ",",&l_tmp);
+ while(token) {
+
+ // trim token whitespace
+ if (isspace(token[0]))
+ token = token + 1;
+ char *closer = strchr(token, ']');
+ if (closer) /* last item in array */
+ *closer = 0;
+
+ l_item->data_str_array[j] = strdup(token);
+
+ token = strtok_r(NULL, ",",&l_tmp);
+ j++;
}
- }else{
- log_it(L_ERROR,"Can't add param to a tree without current section");
- }
+ l_item->array_length = j;
+ } else {
+ dap_config_item_t * l_item = DAP_NEW_Z(dap_config_item_t);
+ strncpy(l_item->name,l_param_name,sizeof(l_item->name));
+ l_item->item_next = l_section_current->childs;
+ l_item->data_str = strdup (l_param_value);
+
+ l_section_current->childs = l_item;
+ }
+ }else{
+ log_it(L_ERROR,"Can't add param to a tree without current section");
}
- DAP_DELETE(l_line);
+
}
+ DAP_DELETE(l_line);
}
}
- continue;
- }else{
- if (l_is_space_now){
- l_is_space_now = false;
- l_buf_pos_line_start = i;
- }
+ }
+ continue;
+ }else{
+ if (l_is_space_now){
+ l_is_space_now = false;
+ l_buf_pos_line_start = i;
}
}
}
- fclose(f);
- }else{
- log_it(L_ERROR,"Can't open config file '%s' (%s)",l_config_path,strerror(errno));
}
- DAP_DELETE(l_config_path);
+ fclose(f);
}else{
- log_it(L_ERROR,"Config name is NULL");
+ log_it(L_ERROR,"Can't open config file '%s' (%s)",a_file_path,strerror(errno));
}
- return ret;
+ return l_ret;
}
/**
diff --git a/dap-sdk/io/dap_context.c b/dap-sdk/io/dap_context.c
index 4b0ec46c0e99039de0dc83589d0355ff08faa155..99c1329b3a4dbeac472cce51b9ae345dd3baed36 100644
--- a/dap-sdk/io/dap_context.c
+++ b/dap-sdk/io/dap_context.c
@@ -1159,8 +1159,7 @@ int dap_context_poll_update(dap_events_socket_t * a_esocket)
u_short l_flags =a_esocket->kqueue_base_flags;
u_int l_fflags =a_esocket->kqueue_base_fflags;
- int l_kqueue_fd = a_esocket->worker? a_esocket->worker->kqueue_fd :
- a_esocket->proc_thread ? a_esocket->proc_thread->kqueue_fd : -1;
+ int l_kqueue_fd = a_esocket->context->kqueue_fd;
if ( l_kqueue_fd == -1 ){
log_it(L_ERROR, "Esocket is not assigned with anything ,exit");
}
@@ -1190,8 +1189,8 @@ int dap_context_poll_update(dap_events_socket_t * a_esocket)
}
}
if (l_is_error && l_errno == EBADF){
- log_it(L_ATT,"Poll update: socket %d (%p ) disconnected, rise CLOSE flag to remove from queue, lost %"DAP_UINT64_FORMAT_U":%" DAP_UINT64_FORMAT_U
- " bytes",a_esocket->socket,a_esocket,a_esocket->buf_in_size,a_esocket->buf_out_size);
+ log_it(L_ATT,"Poll update: socket %d (%p ) disconnected, rise CLOSE flag to remove from queue, lost %zd:%zd bytes",
+ a_esocket->socket,a_esocket,a_esocket->buf_in_size,a_esocket->buf_out_size);
a_esocket->flags |= DAP_SOCK_SIGNAL_CLOSE;
a_esocket->buf_in_size = a_esocket->buf_out_size = 0; // Reset everything from buffer, we close it now all
}else if ( l_is_error && l_errno != EINPROGRESS && l_errno != ENOENT){
diff --git a/dap-sdk/io/dap_net.c b/dap-sdk/io/dap_net.c
index 072388a71a03a61bee31e885f62076a93f395728..86251669530e93ecbabde3c5e71d9cef00610e8b 100644
--- a/dap-sdk/io/dap_net.c
+++ b/dap-sdk/io/dap_net.c
@@ -1,3 +1,29 @@
+#ifndef _WIN32
+#include <poll.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+//#include <unistd.h> // for close
+#include <fcntl.h>
+//#include <sys/poll.h>
+//#include <sys/select.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+//#define closesocket close
+//typedef int SOCKET;
+//#define SOCKET_ERROR -1 // for win32 = (-1)
+//#define INVALID_SOCKET -1 // for win32 = (SOCKET)(~0)
+// for Windows
+#else
+#include <winsock2.h>
+#include <windows.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#endif
+
+#include <errno.h>
#include <string.h>
#include "dap_net.h"
@@ -47,3 +73,33 @@ int dap_net_resolve_host(const char *a_host, int ai_family, struct sockaddr *a_a
freeaddrinfo(l_res);
return -1;
}
+
+/**
+ * @brief s_recv
+ * timeout in milliseconds
+ * return the number of read bytes (-1 err or -2 timeout)
+ * @param sock
+ * @param buf
+ * @param bufsize
+ * @param timeout
+ * @return long
+ */
+long dap_net_recv(SOCKET sd, unsigned char *buf, size_t bufsize, int timeout)
+{
+struct pollfd fds = {.fd = sd, .events = POLLIN};
+int res;
+
+ if ( !(res = poll(&fds, 1, timeout)) )
+ return -2;
+
+ if ( (res == 1) && !(fds.revents & POLLIN))
+ return -1;
+
+ if(res < 1)
+ return -1;
+
+ if ( 0 >= (res = recv(sd, (char *)buf, bufsize, 0)) )
+ printf("[s_recv] recv()->%d, errno: %d\n", res, errno);
+
+ return res;
+}
diff --git a/dap-sdk/io/include/dap_net.h b/dap-sdk/io/include/dap_net.h
index 2c79b8971f9405cd2f3b42f843c8c297ba0fc10a..3a5c8350eb4cc0a172f62275f9518d710c84f490 100644
--- a/dap-sdk/io/include/dap_net.h
+++ b/dap-sdk/io/include/dap_net.h
@@ -43,5 +43,7 @@
#endif
#include "dap_common.h"
+#include "dap_events_socket.h"
int dap_net_resolve_host(const char *a_host, int ai_family, struct sockaddr *a_addr_out);
+long dap_net_recv(SOCKET sd, unsigned char *buf, size_t bufsize, int timeout);
diff --git a/modules/app-cli/CMakeLists.txt b/dap-sdk/net/app-cli/CMakeLists.txt
similarity index 79%
rename from modules/app-cli/CMakeLists.txt
rename to dap-sdk/net/app-cli/CMakeLists.txt
index 26a2deb1bd0440d63b7993d176f644a4d7478fe6..d3827063acc7a677a6397b27a979b66a98000d14 100644
--- a/modules/app-cli/CMakeLists.txt
+++ b/dap-sdk/net/app-cli/CMakeLists.txt
@@ -7,5 +7,5 @@ file(GLOB DAP_APP_CLI_HEADERS include/*.h)
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_link_libraries(${PROJECT_NAME} dap_core dap_io dap_cli_server m)
target_include_directories(${PROJECT_NAME} PUBLIC include/ )
diff --git a/modules/app-cli/dap_app_cli.c b/dap-sdk/net/app-cli/dap_app_cli.c
similarity index 98%
rename from modules/app-cli/dap_app_cli.c
rename to dap-sdk/net/app-cli/dap_app_cli.c
index 495150e71c3a080d84f00763e9e58e90bab7719f..9d29d16ce5ed919badfc85318aaf41a08a9c5d88 100644
--- a/modules/app-cli/dap_app_cli.c
+++ b/dap-sdk/net/app-cli/dap_app_cli.c
@@ -27,11 +27,11 @@
#include <stdlib.h>
#include <string.h>
-#include "dap_chain_node_cli.h"
//#include "dap_client.h"
#include "dap_common.h"
#include "dap_file_utils.h"
#include "dap_strfuncs.h"
+#include "dap_cli_server.h"
#include "dap_app_cli.h"
#include "dap_app_cli_net.h"
#include "dap_app_cli_shell.h"
@@ -85,7 +85,7 @@ static char** split_word(char *line, int *argc)
int execute_line(dap_app_cli_connect_param_t *cparam, char *line)
{
register int i;
- dap_chain_node_cmd_item_t *command;
+ dap_cli_cmd_t *command;
char *word;
/* Isolate the command word. */
diff --git a/modules/app-cli/dap_app_cli_net.c b/dap-sdk/net/app-cli/dap_app_cli_net.c
similarity index 99%
rename from modules/app-cli/dap_app_cli_net.c
rename to dap-sdk/net/app-cli/dap_app_cli_net.c
index b5ee8845b1fa4bb1e295da3ebe213aee888a7c26..a1f37d22c4bbc3849b97a9234825688b15dbf659 100644
--- a/modules/app-cli/dap_app_cli_net.c
+++ b/dap-sdk/net/app-cli/dap_app_cli_net.c
@@ -46,7 +46,7 @@
#include "dap_common.h"
#include "dap_string.h"
#include "dap_strfuncs.h"
-#include "dap_chain_node_cli.h" // for UNIX_SOCKET_FILE
+#include "dap_cli_server.h" // for UNIX_SOCKET_FILE
#include "dap_app_cli.h"
#include "dap_app_cli_net.h"
#include "dap_enc_base64.h"
diff --git a/modules/app-cli/dap_app_cli_shell.c b/dap-sdk/net/app-cli/dap_app_cli_shell.c
similarity index 100%
rename from modules/app-cli/dap_app_cli_shell.c
rename to dap-sdk/net/app-cli/dap_app_cli_shell.c
diff --git a/modules/app-cli/include/dap_app_cli.h b/dap-sdk/net/app-cli/include/dap_app_cli.h
similarity index 100%
rename from modules/app-cli/include/dap_app_cli.h
rename to dap-sdk/net/app-cli/include/dap_app_cli.h
diff --git a/modules/app-cli/include/dap_app_cli_net.h b/dap-sdk/net/app-cli/include/dap_app_cli_net.h
similarity index 100%
rename from modules/app-cli/include/dap_app_cli_net.h
rename to dap-sdk/net/app-cli/include/dap_app_cli_net.h
diff --git a/modules/app-cli/include/dap_app_cli_shell.h b/dap-sdk/net/app-cli/include/dap_app_cli_shell.h
similarity index 100%
rename from modules/app-cli/include/dap_app_cli_shell.h
rename to dap-sdk/net/app-cli/include/dap_app_cli_shell.h
diff --git a/dap-sdk/net/server/CMakeLists.txt b/dap-sdk/net/server/CMakeLists.txt
index 2ad3a1a3f50afb0ce56181094e0348a0aa290fef..37e70acb389a9fb0f7608b3d299a65485c512432 100644
--- a/dap-sdk/net/server/CMakeLists.txt
+++ b/dap-sdk/net/server/CMakeLists.txt
@@ -1,11 +1,13 @@
project(libdap-server C)
cmake_minimum_required(VERSION 3.10)
+add_subdirectory(cli_server)
add_subdirectory(notify_server)
add_subdirectory(http_server)
add_subdirectory(enc_server)
add_subdirectory(json_rpc)
+
if (BUILD_LIB_DAP_SERVER_TESTS)
enable_testing()
add_subdirectory(test)
diff --git a/dap-sdk/net/server/cli_server/CMakeLists.txt b/dap-sdk/net/server/cli_server/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..b67f12d27d75a006161b9aa45f69ffe63558675b
--- /dev/null
+++ b/dap-sdk/net/server/cli_server/CMakeLists.txt
@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.10)
+project (dap_cli_server C)
+
+file(GLOB DAP_CLI_SRV_SRCS *.c)
+
+file(GLOB DAP_CLI_SRV_HEADERS include/*.h)
+
+add_library(${PROJECT_NAME} STATIC ${DAP_CLI_SRV_SRCS} ${DAP_CLI_SRV_HEADERS} )
+
+target_link_libraries(${PROJECT_NAME} dap_core dap_io m)
+target_include_directories(${PROJECT_NAME} PUBLIC include/ )
diff --git a/dap-sdk/net/server/cli_server/dap_cli_server.c b/dap-sdk/net/server/cli_server/dap_cli_server.c
new file mode 100644
index 0000000000000000000000000000000000000000..4ba5f85607617890b5062be8e110ea2df9faf804
--- /dev/null
+++ b/dap-sdk/net/server/cli_server/dap_cli_server.c
@@ -0,0 +1,1012 @@
+/*
+ * Authors:
+ * Dmitriy A. Gerasimov <gerasimov.dmitriy@demlabs.net>
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Cellframe https://cellframe.net
+ * Copyright (c) 2019-2021
+ * All rights reserved.
+
+ This file is part of Cellframe SDK
+
+ Cellframe SDK 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.
+
+ Cellframe SDK 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 Cellframe SDK based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <errno.h>
+#include <assert.h>
+//#include <glib.h>
+#include <unistd.h>
+
+#ifndef _WIN32
+#include <poll.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <arpa/inet.h>
+//#include <unistd.h> // for close
+#include <fcntl.h>
+//#include <sys/poll.h>
+//#include <sys/select.h>
+#include <netinet/in.h>
+#include <sys/un.h>
+#include <sys/stat.h>
+//#define closesocket close
+//typedef int SOCKET;
+//#define SOCKET_ERROR -1 // for win32 = (-1)
+//#define INVALID_SOCKET -1 // for win32 = (SOCKET)(~0)
+// for Windows
+#else
+#include <winsock2.h>
+#include <windows.h>
+#include <mswsock.h>
+#include <ws2tcpip.h>
+#include <io.h>
+#endif
+
+#include <pthread.h>
+
+#include "dap_common.h"
+#include "dap_strfuncs.h"
+#include "dap_file_utils.h"
+#include "dap_list.h"
+#include "dap_net.h"
+#include "dap_cli_server.h"
+
+#define LOG_TAG "dap_cli_server"
+
+#define MAX_CONSOLE_CLIENTS 16
+
+static SOCKET server_sockfd = -1; // network or local unix
+static uint32_t l_listen_port = 0;
+static bool s_debug_cli = false;
+
+#ifdef _WIN32
+ #define poll WSAPoll
+#endif
+
+static dap_cli_cmd_t * s_commands = NULL;
+
+
+static void* s_thread_one_client_func(void *args);
+static void* s_thread_main_func(void *args);
+static inline void s_cmd_add_ex(const char * a_name, dap_cli_server_cmd_callback_ex_t a_func, void *a_arg_func, const char *a_doc, const char *a_doc_ex);
+
+
+
+/**
+ * @brief dap_cli_server_init
+ * @param a_debug_more
+ * @param a_socket_path_or_address
+ * @param a_port
+ * @param a_permissions
+ * @return
+ */
+int dap_cli_server_init(bool a_debug_more,const char * a_socket_path_or_address, uint16_t a_port, const char * a_permissions)
+{
+ s_debug_cli = a_debug_more;
+#ifndef _WIN32
+ struct sockaddr_un l_server_addr={0};
+ l_server_addr.sun_family = AF_UNIX;
+ snprintf(l_server_addr.sun_path,sizeof(l_server_addr.sun_path), "%s", a_socket_path_or_address);
+#else
+ pthread_t threadId;
+#endif
+
+ struct sockaddr_in server_addr;
+ SOCKET sockfd = -1;
+
+ // create thread for waiting of clients
+ pthread_t l_thread_id;
+
+ l_listen_port = dap_config_get_item_uint16_default( g_config, "conserver", "listen_port_tcp",0);
+
+ const char * l_listen_unix_socket_path = dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_path");
+
+
+
+ const char * l_listen_unix_socket_permissions_str = dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_permissions");
+ mode_t l_listen_unix_socket_permissions = 0770;
+
+ if ( l_listen_unix_socket_path && l_listen_unix_socket_permissions ) {
+ if ( l_listen_unix_socket_permissions_str ) {
+ uint16_t l_perms;
+ dap_sscanf(l_listen_unix_socket_permissions_str,"%ho", &l_perms);
+ l_listen_unix_socket_permissions = l_perms;
+ }
+ log_it( L_INFO, "Console interace on path %s (%04o) ", l_listen_unix_socket_path, l_listen_unix_socket_permissions );
+
+ #ifndef _WIN32
+
+ if ( server_sockfd >= 0 ) {
+ dap_cli_server_deinit();
+ server_sockfd = 0;
+ }
+
+ // create socket
+ sockfd = socket( AF_UNIX, SOCK_STREAM, 0 );
+ if( sockfd == INVALID_SOCKET )
+ return -1;
+
+ //int gdsg = sizeof(struct sockaddr_un);
+
+ // Creatuing directory if not created
+ char * l_listen_unix_socket_path_dir = dap_path_get_dirname(l_listen_unix_socket_path);
+ dap_mkdir_with_parents(l_listen_unix_socket_path_dir);
+ DAP_DELETE(l_listen_unix_socket_path_dir);
+
+ if ( access( l_listen_unix_socket_path , R_OK) != -1 )
+ unlink( l_listen_unix_socket_path );
+
+
+ // connecting the address with a socket
+ if( bind(sockfd, (const struct sockaddr*) &l_server_addr, sizeof(struct sockaddr_un)) == SOCKET_ERROR) {
+ // errno = EACCES 13 Permission denied
+ if ( errno == EACCES ) // EACCES=13
+ log_it( L_ERROR, "Server can't start(err=%d). Can't create file=%s [Permission denied]", errno,
+ l_listen_unix_socket_path );
+ else
+ log_it( L_ERROR, "Server can't start(err=%d). May be problem with file=%s?", errno, l_listen_unix_socket_path );
+ closesocket( sockfd );
+ return -2;
+ }
+ chmod(l_listen_unix_socket_path,l_listen_unix_socket_permissions);
+
+ #else
+
+// Sleep( 3000 );
+
+ if( pthread_create(&threadId, NULL, thread_pipe_func, (void*) (intptr_t) sockfd) != 0 ) {
+ closesocket( sockfd );
+ return -7;
+ }
+
+ return 0;
+ #endif
+
+ }
+ else if (l_listen_port ){
+
+ const char *l_listen_addr_str = dap_config_get_item_str(g_config, "conserver", "listen_address");
+
+ log_it( L_INFO, "Console interace on addr %s port %u ", l_listen_addr_str, l_listen_port );
+
+ server_addr.sin_family = AF_INET;
+#ifdef _WIN32
+ struct in_addr _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
+ server_addr.sin_addr = _in_addr;
+ server_addr.sin_port = l_listen_port;
+#else
+ inet_pton( AF_INET, l_listen_addr_str, &server_addr.sin_addr );
+ server_addr.sin_port = htons( (uint16_t)l_listen_port );
+#endif
+ // create socket
+ if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ) {
+#ifdef __WIN32
+ _set_errno(WSAGetLastError());
+#endif
+ log_it( L_ERROR, "Console Server: can't create socket, err %d", errno );
+ return -3;
+ }
+
+ // connecting the address with a socket
+ if ( bind(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)) == SOCKET_ERROR ) {
+#ifdef __WIN32
+ _set_errno(WSAGetLastError());
+#endif
+ log_it( L_ERROR, "Console Server: can't bind socket, err %d", errno );
+ closesocket( sockfd );
+ return -4;
+ }
+ }else {
+ log_it (L_INFO, "Not defined console interface");
+ return 0;
+ }
+
+ // turn on reception of connections
+ if( listen(sockfd, MAX_CONSOLE_CLIENTS) == SOCKET_ERROR )
+ return -5;
+
+ if( pthread_create(&l_thread_id, NULL, s_thread_main_func, (void*) (intptr_t) sockfd) != 0 ) {
+ closesocket( sockfd );
+ return -6;
+ }
+
+ // in order to thread not remain in state "dead" after completion
+ pthread_detach( l_thread_id );
+ server_sockfd = sockfd;
+
+ return 0;
+}
+
+/**
+ * @brief dap_cli_server_deinit
+ */
+void dap_cli_server_deinit()
+{
+ if(server_sockfd != INVALID_SOCKET)
+ closesocket(server_sockfd);
+#ifdef __WIN32
+ WSACleanup();
+#endif
+
+}
+
+/**
+ * @brief dap_cli_server_cmd_add
+ * @param a_name
+ * @param a_func
+ * @param a_doc
+ * @param a_doc_ex
+ */
+void dap_cli_server_cmd_add(const char * a_name, dap_cli_server_cmd_callback_t a_func, const char *a_doc, const char *a_doc_ex)
+{
+ s_cmd_add_ex(a_name, (dap_cli_server_cmd_callback_ex_t)(void *)a_func, NULL, a_doc, a_doc_ex);
+}
+
+/**
+ * @brief s_cmd_add_ex
+ * @param a_name
+ * @param a_func
+ * @param a_arg_func
+ * @param a_doc
+ * @param a_doc_ex
+ */
+static inline void s_cmd_add_ex(const char * a_name, dap_cli_server_cmd_callback_ex_t a_func, void *a_arg_func, const char *a_doc, const char *a_doc_ex)
+{
+ dap_cli_cmd_t *l_cmd_item = DAP_NEW_Z(dap_cli_cmd_t);
+ dap_snprintf(l_cmd_item->name,sizeof (l_cmd_item->name),"%s",a_name);
+ l_cmd_item->doc = strdup( a_doc);
+ l_cmd_item->doc_ex = strdup( a_doc_ex);
+ if (a_arg_func) {
+ l_cmd_item->func_ex = a_func;
+ l_cmd_item->arg_func = a_arg_func;
+ } else {
+ l_cmd_item->func = (dap_cli_server_cmd_callback_t )(void *)a_func;
+ }
+ HASH_ADD_STR(s_commands,name,l_cmd_item);
+ log_it(L_DEBUG,"Added command %s",l_cmd_item->name);
+}
+
+/**
+ * @brief int s_poll
+ * Wait for data
+ * timeout - timeout in ms
+ * [Specifying a negative value in timeout means an infinite timeout.]
+ * [Specifying a timeout of zero causes poll() to return immediately, even if no file descriptors are ready.]
+ * return zero if the time limit expired
+ * return: >0 if data is present to read
+ * return: -1 if error
+ * @param socket
+ * @param timeout
+ * @return int
+ */
+static int s_poll( int sd, int timeout )
+{
+struct pollfd fds = {.fd = sd, .events = POLLIN};
+int res;
+
+ res = poll(&fds, 1, timeout);
+
+ return (res == 1 && !(fds.revents & POLLIN)) ? -1 : res;
+}
+
+
+/**
+ * @brief is_valid_socket
+ * Check socket for validity
+ * @param sock
+ * @return true
+ * @return false
+ */
+static int is_valid_socket(SOCKET sd)
+{
+struct pollfd fds = {.fd = sd, .events = POLLIN};
+int res;
+
+ if ( 0 > (res = poll(&fds, 1, 0)) )
+ return false;
+
+ // event with an error code
+ if(res > 0)
+ {
+ // feature of disconnection under Windows
+ // under Windows, with socket closed fds.revents=POLLHUP, in Unix fds.events = POLLIN
+ if(fds.revents & (POLLERR | POLLHUP | POLLNVAL))
+ return false;
+
+ // feature of disconnection under Unix (QNX)
+ // under Windows, with socket closed res = 0, in Unix res = -1
+ char buf[2];
+ if ( 0 > (res = recv(sd, buf, 1, MSG_PEEK)) ) // MSG_PEEK The data is treated as unread and the next recv() function shall still return this data.
+ return false;
+
+ // data in the buffer must be(count_desc>0), but read 0 bytes(res=0)
+ if(!res && (fds.revents & POLLIN))
+ return false;
+ }
+
+ return true;
+}
+
+
+/**
+ * @brief s_get_next_str
+ * Reading from the socket till arrival the specified string
+ *
+ * stop_str - string to which reading will continue
+ * del_stop_str - удалÑÑ‚ÑŒ ли Ñтроку Ð´Ð»Ñ Ð¿Ð¾Ð¸Ñка в конце
+ * timeout - in ms
+ * return: string (if waited for final characters) or NULL, if the string requires deletion
+ * @param nSocket
+ * @param dwLen
+ * @param stop_str
+ * @param del_stop_str
+ * @param timeout
+ * @return char*
+ */
+char* s_get_next_str( SOCKET nSocket, int *dwLen, const char *stop_str, bool del_stop_str, int timeout )
+{
+ bool bSuccess = false;
+ long nRecv = 0; // count of bytes received
+ size_t stop_str_len = (stop_str) ? strlen(stop_str) : 0;
+ // if there is nothing to look for
+ if(!stop_str_len)
+ return NULL;
+ size_t lpszBuffer_len = 256;
+ char *lpszBuffer = DAP_NEW_Z_SIZE(char, lpszBuffer_len);
+ // received string will not be larger than MAX_REPLY_LEN
+
+ while(1) //nRecv < MAX_REPLY_LEN)
+ {
+ // read one byte
+ long ret = dap_net_recv(nSocket, (unsigned char *) (lpszBuffer + nRecv), 1, timeout);
+ //int ret = recv(nSocket,lpszBuffer+nRecv,1, 0);
+ if(ret <= 0)
+ {
+ break;
+ }
+ nRecv += ret;
+ //printf("**debug** socket=%d read %d bytes '%0s'",nSocket, ret, (lpszBuffer + nRecv));
+ while((nRecv + 1) >= (long) lpszBuffer_len)
+ {
+ lpszBuffer_len *= 2;
+ lpszBuffer = (char*) realloc(lpszBuffer, lpszBuffer_len);
+ }
+ // search for the required string
+ if(nRecv >= (long) stop_str_len) {
+ // found the required string
+ if(!strncasecmp(lpszBuffer + nRecv - stop_str_len, stop_str, stop_str_len)) {
+ bSuccess = true;
+ break;
+ }
+ }
+ };
+
+ // end reading
+
+ if(bSuccess) {
+ // delete the searched string
+ if(del_stop_str) {
+ lpszBuffer[nRecv - (long) stop_str_len] = '\0';
+ if(dwLen)
+ *dwLen =(int) nRecv - (int) stop_str_len;
+ }
+ else {
+ lpszBuffer[nRecv] = '\0';
+ if(dwLen)
+ *dwLen = (int) nRecv;
+ }
+ char * l_buf_realloc = DAP_REALLOC(lpszBuffer,(size_t) *dwLen + 1);
+ if( l_buf_realloc)
+ lpszBuffer = l_buf_realloc;
+ return lpszBuffer;
+ }
+
+ // in case of an error or missing string
+
+ if(dwLen)
+ *dwLen = 0;
+
+ free(lpszBuffer);
+
+ return NULL;
+}
+
+/**
+ * threading function for processing a request from a client
+ */
+static void* s_thread_one_client_func(void *args)
+{
+SOCKET newsockfd = (SOCKET) (intptr_t) args;
+int str_len, marker = 0, timeout = 5000, argc = 0, is_data;
+dap_list_t *cmd_param_list = NULL;
+char *str_header;
+
+ if(s_debug_cli)
+ log_it(L_DEBUG, "new connection sockfd=%"DAP_FORMAT_SOCKET, newsockfd);
+
+
+ while ( !(0 > (is_data = s_poll(newsockfd, timeout))) ) // wait data from client
+ {
+ if ( !(is_data) ) // timeout
+ continue;
+
+ if ( !is_valid_socket(newsockfd) )
+ break;
+
+ // receiving http header
+ if ( !(str_header = s_get_next_str(newsockfd, &str_len, "\r\n", true, timeout)) )
+ break; // bad format
+
+ if(str_header && !strlen(str_header) ) {
+ marker++;
+ if(marker == 1){
+ DAP_DELETE(str_header);
+ continue;
+ }
+ }
+
+ // filling parameters of command
+ if(marker == 1) {
+ cmd_param_list = dap_list_append(cmd_param_list, str_header);
+ //printf("g_list_append argc=%d command=%s ", argc, str_header);
+ argc++;
+ }
+ else
+ DAP_DEL_Z(str_header);
+
+ if(marker == 2 && cmd_param_list) {
+ dap_list_t *list = cmd_param_list;
+ // form command
+ argc = dap_list_length(list);
+ // command is found
+ if(argc >= 1) {
+ int l_verbose = 0;
+ char *cmd_name = list->data;
+ list = dap_list_next(list);
+ // execute command
+ char *str_cmd = dap_strdup_printf("%s", cmd_name);
+ dap_cli_cmd_t *l_cmd = dap_cli_server_cmd_find(cmd_name);
+ int res = -1;
+ char *str_reply = NULL;
+ if(l_cmd){
+ while(list) {
+ char *str_cmd_prev = str_cmd;
+ str_cmd = dap_strdup_printf("%s;%s", str_cmd, list->data);
+ list = dap_list_next(list);
+ DAP_DELETE(str_cmd_prev);
+ }
+ if(l_cmd->overrides.log_cmd_call)
+ l_cmd->overrides.log_cmd_call(str_cmd);
+ else
+ log_it(L_DEBUG, "execute command=%s", str_cmd);
+ // exec command
+
+ char **l_argv = dap_strsplit(str_cmd, ";", -1);
+ // Call the command function
+ if(l_cmd && l_argv && l_cmd->func) {
+ if (l_cmd->arg_func) {
+ res = l_cmd->func_ex(argc, l_argv, l_cmd->arg_func, &str_reply);
+ } else {
+ res = l_cmd->func(argc, l_argv, &str_reply);
+ }
+ } else if (l_cmd) {
+ log_it(L_WARNING,"NULL arguments for input for command \"%s\"", str_cmd);
+ }else {
+ log_it(L_WARNING,"No function for command \"%s\" but it registred?!", str_cmd);
+ }
+ // find '-verbose' command
+ l_verbose = dap_cli_server_cmd_find_option_val(l_argv, 1, argc, "-verbose", NULL);
+ dap_strfreev(l_argv);
+ } else {
+ str_reply = dap_strdup_printf("can't recognize command=%s", str_cmd);
+ log_it(L_ERROR,"Reply string: \"%s\"", str_reply);
+ }
+ char *reply_body;
+ if(l_verbose)
+ reply_body = dap_strdup_printf("%d\r\nret_code: %d\r\n%s\r\n", res, res, (str_reply) ? str_reply : "");
+ else
+ reply_body = dap_strdup_printf("%d\r\n%s\r\n", res, (str_reply) ? str_reply : "");
+ // return the result of the command function
+ char *reply_str = dap_strdup_printf("HTTP/1.1 200 OK\r\n"
+ "Content-Length: %d\r\n\r\n"
+ "%s", strlen(reply_body), reply_body);
+ size_t l_reply_step = 32768;
+ size_t l_reply_len = strlen(reply_str);
+ size_t l_reply_rest = l_reply_len;
+
+ while(l_reply_rest) {
+ size_t l_send_bytes = min(l_reply_step, l_reply_rest);
+ int ret = send(newsockfd, reply_str + l_reply_len - l_reply_rest, l_send_bytes, 0);
+ if(ret<=0)
+ break;
+ l_reply_rest-=l_send_bytes;
+ };
+
+ DAP_DELETE(str_reply);
+ DAP_DELETE(reply_str);
+ DAP_DELETE(reply_body);
+
+ DAP_DELETE(str_cmd);
+ }
+ dap_list_free_full(cmd_param_list, NULL);
+ break;
+ }
+ }
+ // close connection
+ int cs = closesocket(newsockfd);
+ if (s_debug_cli)
+ log_it(L_DEBUG, "close connection=%d sockfd=%"DAP_FORMAT_SOCKET, cs, newsockfd);
+
+ return NULL;
+}
+
+#ifdef _WIN32
+
+/**
+ * @brief p_get_next_str
+ *
+ * @param hPipe
+ * @param dwLen
+ * @param stop_str
+ * @param del_stop_str
+ * @param timeout
+ * @return char*
+ */
+char *p_get_next_str( HANDLE hPipe, int *dwLen, const char *stop_str, bool del_stop_str, int timeout )
+{
+ UNUSED(timeout);
+ bool bSuccess = false;
+ long nRecv = 0; // count of bytes received
+ size_t stop_str_len = (stop_str) ? strlen(stop_str) : 0;
+ // if there is nothing to look for
+
+ if(!stop_str_len)
+ return NULL;
+
+ size_t lpszBuffer_len = 256;
+ char *lpszBuffer = DAP_NEW_Z_SIZE(char, lpszBuffer_len);
+ // received string will not be larger than MAX_REPLY_LEN
+
+ while( 1 ) //nRecv < MAX_REPLY_LEN)
+ {
+ long ret = 0;
+ // read one byte
+// long ret = s_recv( nSocket, (unsigned char *) (lpszBuffer + nRecv), 1, timeout);
+
+ bSuccess = ReadFile( hPipe, lpszBuffer + nRecv,
+ lpszBuffer_len - nRecv, (LPDWORD)&ret, NULL );
+
+ //int ret = recv(nSocket,lpszBuffer+nRecv,1, 0);
+ if ( ret <= 0 || !bSuccess )
+ break;
+
+ nRecv += ret;
+ //printf("**debug** socket=%d read %d bytes '%0s'",nSocket, ret, (lpszBuffer + nRecv));
+
+ while((nRecv + 1) >= (long) lpszBuffer_len)
+ {
+ lpszBuffer_len *= 2;
+ lpszBuffer = (char*) realloc(lpszBuffer, lpszBuffer_len);
+ }
+
+ // search for the required string
+ if(nRecv >= (long) stop_str_len) {
+ // found the required string
+ if(!strncasecmp(lpszBuffer + nRecv - stop_str_len, stop_str, stop_str_len)) {
+ bSuccess = true;
+ break;
+ }
+ }
+ };
+
+ // end reading
+
+ if(bSuccess) {
+ // delete the searched string
+ if(del_stop_str) {
+ lpszBuffer[nRecv - (long) stop_str_len] = '\0';
+ if(dwLen)
+ *dwLen =(int) nRecv - (int) stop_str_len;
+ }
+ else {
+ lpszBuffer[nRecv] = '\0';
+ if(dwLen)
+ *dwLen = (int) nRecv;
+ }
+ lpszBuffer = DAP_REALLOC(lpszBuffer,(size_t) *dwLen + 1);
+ return lpszBuffer;
+ }
+
+ // in case of an error or missing string
+
+ if(dwLen)
+ *dwLen = 0;
+
+ free(lpszBuffer);
+
+ return NULL;
+}
+
+/**
+ * @brief thread_pipe_client_func
+ * threading function for processing a request from a client
+ * @param args
+ * @return void*
+ */
+static void *thread_pipe_client_func( void *args )
+{
+ HANDLE hPipe = (HANDLE)args;
+
+// SOCKET newsockfd = (SOCKET) (intptr_t) args;
+ if(s_debug_cli)
+ log_it(L_INFO, "new connection pipe = %p", hPipe);
+
+ int str_len, marker = 0;
+ int timeout = 5000; // 5 sec
+ int argc = 0;
+
+ dap_list_t *cmd_param_list = NULL;
+
+ while( 1 )
+ {
+ // wait data from client
+// int is_data = s_poll( newsockfd, timeout );
+ // timeout
+// if(!is_data)
+// continue;
+ // error (may be socket closed)
+// if(is_data < 0)
+// break;
+
+// int is_valid = is_valid_socket(newsockfd);
+// if(!is_valid)
+// {
+// break;
+// }
+
+ // receiving http header
+ char *str_header = p_get_next_str( hPipe, &str_len, "\r\n", true, timeout );
+
+ // bad format
+ if(!str_header)
+ break;
+
+ if ( str_header && strlen(str_header) == 0) {
+ marker++;
+ if(marker == 1)
+ continue;
+ }
+
+ // filling parameters of command
+ if ( marker == 1 ) {
+ cmd_param_list = dap_list_append( cmd_param_list, str_header );
+ //printf("g_list_append argc=%d command=%s ", argc, str_header);
+ argc ++;
+ }
+ else
+ free( str_header );
+
+ if ( marker == 2 ) {
+
+ dap_list_t *list = cmd_param_list;
+ // form command
+
+ unsigned int argc = dap_list_length( list );
+ // command is found
+
+ if ( argc >= 1) {
+
+ int l_verbose = 0;
+ char *cmd_name = list->data;
+ list = dap_list_next( list );
+
+ // execute command
+ char *str_cmd = dap_strdup_printf( "%s", cmd_name );
+ dap_cli_cmd_t *l_cmd = dap_cli_server_cmd_find( cmd_name );
+ int res = -1;
+ char *str_reply = NULL;
+
+ if ( l_cmd ) {
+
+ while( list ) {
+ str_cmd = dap_strdup_printf( "%s;%s", str_cmd, list->data );
+ list = dap_list_next(list);
+ }
+
+ log_it(L_INFO, "execute command = %s", str_cmd );
+ // exec command
+
+ char **l_argv = dap_strsplit( str_cmd, ";", -1 );
+ // Call the command function
+
+ if ( l_cmd && l_argv && l_cmd->func ) {
+ if (l_cmd->arg_func) {
+ res = l_cmd->func_ex(argc, l_argv, l_cmd->arg_func, &str_reply);
+ } else {
+ res = l_cmd->func(argc, l_argv, &str_reply);
+ }
+ }
+
+ else if ( l_cmd ) {
+ log_it(L_WARNING,"NULL arguments for input for command \"%s\"", str_cmd );
+ }else {
+ log_it(L_WARNING,"No function for command \"%s\" but it registred?!", str_cmd );
+ }
+
+ // find '-verbose' command
+ l_verbose = dap_cli_server_cmd_find_option_val( l_argv, 1, argc, "-verbose", NULL );
+ dap_strfreev( l_argv );
+
+ } else {
+ str_reply = dap_strdup_printf("can't recognize command = %s", str_cmd );
+ log_it( L_ERROR, str_reply );
+ }
+
+ char *reply_body;
+
+ if(l_verbose)
+ reply_body = dap_strdup_printf("%d\r\nret_code: %d\r\n%s\r\n", res, res, (str_reply) ? str_reply : "");
+ else
+ reply_body = dap_strdup_printf("%d\r\n%s\r\n", res, (str_reply) ? str_reply : "");
+
+ // return the result of the command function
+ char *reply_str = dap_strdup_printf( "HTTP/1.1 200 OK\r\n"
+ "Content-Length: %d\r\n\r\n"
+ "%s",
+ strlen(reply_body), reply_body );
+
+ int ret;// = send( newsockfd, reply_str, strlen(reply_str) ,0 );
+
+ WriteFile( hPipe, reply_str, strlen(reply_str), (LPDWORD)&ret, NULL );
+
+ DAP_DELETE(str_reply);
+ DAP_DELETE(reply_str);
+ DAP_DELETE(reply_body);
+
+ DAP_DELETE(str_cmd);
+ }
+ dap_list_free_full(cmd_param_list, free);
+ break;
+ }
+ }
+
+ // close connection
+// int cs = closesocket(newsockfd);
+
+ log_it( L_INFO, "close connection pipe = %p", hPipe );
+
+ FlushFileBuffers( hPipe );
+ DisconnectNamedPipe( hPipe );
+ CloseHandle( hPipe );
+
+ return NULL;
+}
+
+
+/**
+ * @brief thread_pipe_func
+ * main threading server function pipe win32
+ * @param args
+ * @return void*
+ */
+static void* thread_pipe_func( void *args )
+{
+ UNUSED(args);
+ BOOL fConnected = FALSE;
+ pthread_t threadId;
+ HANDLE hPipe = INVALID_HANDLE_VALUE;
+ static const char *cPipeName = "\\\\.\\pipe\\node_cli.pipe";
+
+ for (;;)
+ {
+/// printf( "\nPipe Server: Main thread awaiting client connection on %s\n", lpszPipename );
+
+ hPipe = CreateNamedPipe(
+ cPipeName, // pipe name
+ PIPE_ACCESS_DUPLEX, // read/write access
+ PIPE_TYPE_MESSAGE | // message type pipe
+ PIPE_READMODE_MESSAGE | // message-read mode
+ PIPE_WAIT, // blocking mode
+ PIPE_UNLIMITED_INSTANCES, // max. instances
+ 4096, // output buffer size
+ 4096, // input buffer size
+ 0, // client time-out
+ NULL ); // default security attribute
+
+ if ( hPipe == INVALID_HANDLE_VALUE ) {
+ log_it( L_ERROR, "CreateNamedPipe failed, GLE = %lu.\n", GetLastError() );
+ return NULL;
+ }
+
+ fConnected = ConnectNamedPipe( hPipe, NULL ) ? TRUE : ( GetLastError() == ERROR_PIPE_CONNECTED );
+
+ if ( fConnected )
+ {
+ log_it( L_INFO, "Client %p connected, creating a processing thread.\n", hPipe );
+
+ pthread_create( &threadId, NULL, thread_pipe_client_func, hPipe );
+ pthread_detach( threadId );
+ }
+ else
+ CloseHandle( hPipe );
+ }
+
+ return NULL;
+}
+#endif
+
+
+/**
+ * @brief thread_main_func
+ * main threading server function
+ * @param args
+ * @return void*
+ */
+static void* s_thread_main_func(void *args)
+{
+ SOCKET sockfd = (SOCKET) (intptr_t) args;
+ SOCKET newsockfd;
+
+ log_it( L_INFO, "Server start socket = %s", dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_path") );
+ // wait of clients
+ while(1)
+ {
+ pthread_t threadId;
+ struct sockaddr_in peer;
+ socklen_t size = sizeof(peer);
+ // received a new connection request
+ if((newsockfd = accept(sockfd, (struct sockaddr*) &peer, &size)) == (SOCKET) -1) {
+ log_it(L_ERROR, "new connection break newsockfd=%"DAP_FORMAT_SOCKET, newsockfd);
+ break;
+ }
+ // create child thread for a client connection
+ pthread_create(&threadId, NULL, s_thread_one_client_func, (void*) (intptr_t) newsockfd);
+ // in order to thread not remain in state "dead" after completion
+ pthread_detach(threadId);
+ };
+ // close connection
+ int cs = closesocket(sockfd);
+ log_it(L_INFO, "Exit server thread=%d socket=%"DAP_FORMAT_SOCKET, cs, sockfd);
+ return NULL;
+}
+
+
+/**
+ * @brief dap_chain_node_cli_set_reply_text
+ * Write text to reply string
+ * @param str_reply
+ * @param str
+ * @param ...
+ */
+void dap_cli_server_cmd_set_reply_text(char **str_reply, const char *str, ...)
+{
+ if(str_reply) {
+ if(*str_reply) {
+ assert( *str_reply );
+ DAP_DELETE(*str_reply);
+ *str_reply = NULL;
+ }
+ va_list args;
+ va_start(args, str);
+ *str_reply = dap_strdup_vprintf(str, args); //*str_reply = dap_strdup(str);
+ va_end(args);
+ }
+}
+
+/**
+ * @brief dap_cli_server_cmd_check_option
+ * @param argv
+ * @param arg_start
+ * @param arg_end
+ * @param opt_name
+ * @return
+ */
+int dap_cli_server_cmd_check_option( char** argv, int arg_start, int arg_end, const char *opt_name)
+{
+ int arg_index = arg_start;
+ const char *arg_string;
+
+ while(arg_index < arg_end)
+ {
+ char * l_argv_cur = argv[arg_index];
+ arg_string = l_argv_cur;
+ // find opt_name
+ if(arg_string && opt_name && arg_string[0] && opt_name[0] && !strcmp(arg_string, opt_name)) {
+ return arg_index;
+ }
+ arg_index++;
+ }
+ return -1;
+}
+
+
+/**
+ * @brief dap_cli_server_cmd_find_option_val
+ * return index of string in argv, or 0 if not found
+ * @param argv
+ * @param arg_start
+ * @param arg_end
+ * @param opt_name
+ * @param opt_value
+ * @return int
+ */
+int dap_cli_server_cmd_find_option_val( char** argv, int arg_start, int arg_end, const char *opt_name, const char **opt_value)
+{
+ assert(argv);
+ int arg_index = arg_start;
+ const char *arg_string;
+ int l_ret_pos = 0;
+
+ while(arg_index < arg_end)
+ {
+ char * l_argv_cur = argv[arg_index];
+ arg_string = l_argv_cur;
+ // find opt_name
+ if(arg_string && opt_name && arg_string[0] && opt_name[0] && !strcmp(arg_string, opt_name)) {
+ // find opt_value
+ if(opt_value) {
+ arg_string = argv[++arg_index];
+ if(arg_string) {
+ *opt_value = arg_string;
+ return arg_index;
+ }
+ // for case if opt_name exist without value
+ else
+ l_ret_pos = arg_index;
+ }
+ else
+ // need only opt_name
+ return arg_index;
+ }
+ arg_index++;
+ }
+ return l_ret_pos;
+}
+
+
+/**
+ * @brief dap_cli_server_cmd_apply_overrides
+ *
+ * @param a_name
+ * @param a_overrides
+ */
+void dap_cli_server_cmd_apply_overrides(const char * a_name, const dap_cli_server_cmd_override_t a_overrides)
+{
+ dap_cli_cmd_t *l_cmd_item = dap_cli_server_cmd_find(a_name);
+ if(l_cmd_item)
+ l_cmd_item->overrides = a_overrides;
+}
+
+/**
+ * @brief dap_cli_server_cmd_get_first
+ * @return
+ */
+dap_cli_cmd_t* dap_cli_server_cmd_get_first()
+{
+ return s_commands;
+}
+
+/**
+ * @brief dap_cli_server_cmd_find
+ * @param a_name
+ * @return
+ */
+dap_cli_cmd_t* dap_cli_server_cmd_find(const char *a_name)
+{
+ dap_cli_cmd_t *l_cmd_item = NULL;
+ HASH_FIND_STR(s_commands,a_name,l_cmd_item);
+ return l_cmd_item;
+}
diff --git a/dap-sdk/net/server/cli_server/include/dap_cli_server.h b/dap-sdk/net/server/cli_server/include/dap_cli_server.h
new file mode 100644
index 0000000000000000000000000000000000000000..85688822573de0c57ba82625eb44a8b049ac1b66
--- /dev/null
+++ b/dap-sdk/net/server/cli_server/include/dap_cli_server.h
@@ -0,0 +1,67 @@
+/*
+ * Authors:
+ * Dmitriy A. Gerasimov <gerasimov.dmitriy@demlabs.net>
+ * Alexander Lysikov <alexander.lysikov@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Cellframe https://cellframe.net
+ * Copyright (c) 2019-2022
+ * All rights reserved.
+
+ This file is part of Cellframe SDK
+
+ Cellframe SDK 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.
+
+ Cellframe SDK 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 Cellframe SDK based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#pragma once
+
+#include "dap_events_socket.h"
+#include "dap_common.h"
+#include "dap_config.h"
+#include "uthash.h"
+
+typedef int (*dap_cli_server_cmd_callback_ex_t)(int argc, char ** argv, void *arg_func, char **str_reply);
+typedef int (*dap_cli_server_cmd_callback_t)(int argc, char ** argv, char **str_reply);
+
+typedef void (*dap_cli_server_override_log_cmd_callback_t)(const char*);
+
+typedef struct dap_cli_server_cmd_override{
+ /* use it if you want to prevent logging of some sensetive data */
+ dap_cli_server_override_log_cmd_callback_t log_cmd_call;
+} dap_cli_server_cmd_override_t;
+
+typedef struct dap_cli_cmd{
+ char name[32]; /* User printable name of the function. */
+ union {
+ dap_cli_server_cmd_callback_t func; /* Function to call to do the job. */
+ dap_cli_server_cmd_callback_ex_t func_ex; /* Function with additional arg to call to do the job. */
+ };
+ void *arg_func; /* additional argument of function*/
+ char *doc; /* Documentation for this function. */
+ char *doc_ex; /* Full documentation for this function. */
+ dap_cli_server_cmd_override_t overrides; /* Used to change default behaviour */
+ UT_hash_handle hh;
+} dap_cli_cmd_t;
+
+
+int dap_cli_server_init(bool a_debug_more,const char * a_socket_path_or_address, uint16_t a_port, const char * a_permissions) ;
+void dap_cli_server_deinit();
+
+void dap_cli_server_cmd_add(const char * a_name, dap_cli_server_cmd_callback_t a_func, const char *a_doc, const char *a_doc_ex);
+void dap_cli_server_cmd_set_reply_text(char **str_reply, const char *str, ...);
+int dap_cli_server_cmd_find_option_val( char** argv, int arg_start, int arg_end, const char *opt_name, const char **opt_value);
+int dap_cli_server_cmd_check_option( char** argv, int arg_start, int arg_end, const char *opt_name);
+void dap_cli_server_cmd_apply_overrides(const char * a_name, const dap_cli_server_cmd_override_t a_overrides);
+
+dap_cli_cmd_t* dap_cli_server_cmd_get_first();
+dap_cli_cmd_t* dap_cli_server_cmd_find(const char *a_name);
diff --git a/dap-sdk/net/stream/stream/dap_stream.c b/dap-sdk/net/stream/stream/dap_stream.c
index b57af3ccd8c58c335a2b652a0c65fe0d98699319..a27f3928cb37b63c0ce1cfe9cb9433b1a6c7fe3a 100644
--- a/dap-sdk/net/stream/stream/dap_stream.c
+++ b/dap-sdk/net/stream/stream/dap_stream.c
@@ -809,7 +809,6 @@ static void s_stream_proc_pkt_in(dap_stream_t * a_stream, dap_stream_pkt_t *a_pk
a_stream->buf_fragments_size_total = 0;
a_stream->buf_fragments_size_filled = 0;
}
- return true;
}
/**
diff --git a/dap-sdk/plugin/CMakeLists.txt b/dap-sdk/plugin/CMakeLists.txt
new file mode 100644
index 0000000000000000000000000000000000000000..6ef731ee9d50ab9059bdd808154b48108eba8cf9
--- /dev/null
+++ b/dap-sdk/plugin/CMakeLists.txt
@@ -0,0 +1,18 @@
+cmake_minimum_required(VERSION 3.0)
+project(dap_plugin C)
+
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_COLOR_MAKEFILE ON)
+set(CMAKE_C_STANDARD 11)
+
+file(GLOB DAP_PLUGIN_SRCS src/*.c)
+file(GLOB DAP_PLUGIN_HEADERS include/*.h)
+
+add_library(${PROJECT_NAME} STATIC ${DAP_PLUGIN_SRCS} ${DAP_PLUGIN_HEADERS})
+
+target_link_libraries(${PROJECT_NAME})
+
+target_link_libraries(${PROJECT_NAME} dap_core dap_cli_server)
+
+target_include_directories(${PROJECT_NAME} PUBLIC include/ )
+
diff --git a/dap-sdk/plugin/include/dap_plugin.h b/dap-sdk/plugin/include/dap_plugin.h
new file mode 100644
index 0000000000000000000000000000000000000000..e0ac75aa19e22e557fe99c347bf1f6f6344e72e9
--- /dev/null
+++ b/dap-sdk/plugin/include/dap_plugin.h
@@ -0,0 +1,56 @@
+/*
+* Authors:
+* Alexey V. Stratulat <alexey.stratulat@demlabs.net>
+* Dmitriy Gerasimov <dmitriy.gerasimov@demlabs.net
+* DeM Labs Inc. https://demlabs.net
+* Copyright (c) 2017-2022
+* 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
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#include "dap_config.h"
+#include "dap_plugin_manifest.h"
+
+typedef int (*dap_plugin_type_callback_load_t)(dap_plugin_manifest_t * a_manifest, void ** a_pvt_data, char ** a_error_str );
+typedef int (*dap_plugin_type_callback_unload_t)(dap_plugin_manifest_t * a_manifest, void * a_pvt_data, char ** a_error_str );
+
+typedef struct dap_plugin_type_callbacks
+{
+ dap_plugin_type_callback_load_t load;
+ dap_plugin_type_callback_unload_t unload;
+} dap_plugin_type_callbacks_t;
+typedef enum dap_plugin_status{ STATUS_RUNNING, STATUS_STOPPED, STATUS_NONE } dap_plugin_status_t;
+
+int dap_plugin_init(const char * a_root_path);
+void dap_plugin_deinit();
+
+int dap_plugin_type_create(const char* a_name, dap_plugin_type_callbacks_t *a_callbacks);
+void dap_plugin_start_all();
+void dap_plugin_stop_all();
+dap_plugin_status_t dap_plugin_status(const char * a_name);
+int dap_plugin_stop(const char * a_name);
+int dap_plugin_start(const char * a_name);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/dap-sdk/plugin/include/dap_plugin_binary.h b/dap-sdk/plugin/include/dap_plugin_binary.h
new file mode 100644
index 0000000000000000000000000000000000000000..48b634a6e13aa8f1beb36e682e7fe60ba68c6c82
--- /dev/null
+++ b/dap-sdk/plugin/include/dap_plugin_binary.h
@@ -0,0 +1,27 @@
+/*
+ * Authors:
+ * Dmitriy A. Gerasimov <gerasimov.dmitriy@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Cellframe https://cellframe.net
+ * Copyright (c) 2022
+ * All rights reserved.
+
+ This file is part of Cellframe SDK
+
+ Cellframe SDK 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.
+
+ Cellframe SDK 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 Cellframe SDK based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+int dap_plugin_binary_init();
+void dap_plugin_binary_deinit();
diff --git a/dap-sdk/plugin/include/dap_plugin_command.h b/dap-sdk/plugin/include/dap_plugin_command.h
new file mode 100644
index 0000000000000000000000000000000000000000..861c65ca5075655d0bda1c77e11cf0d99bccd4db
--- /dev/null
+++ b/dap-sdk/plugin/include/dap_plugin_command.h
@@ -0,0 +1,37 @@
+/*
+* Authors:
+* Alexey V. Stratulat <alexey.stratulat@demlabs.net>
+* DeM Labs Inc. https://demlabs.net
+* DeM Labs Open source community https://gitlab.demlabs.net/cellframe/libdap-plugins-python
+* Copyright (c) 2017-2020
+* 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
+
+#define _DAP_CHAIN_PLUGINS_COMMAND_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void dap_plugin_command_init(void);
+void dap_plugin_command_deinit(void);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/dap-sdk/plugin/include/dap_plugin_manifest.h b/dap-sdk/plugin/include/dap_plugin_manifest.h
new file mode 100644
index 0000000000000000000000000000000000000000..825e86eb38b46f28a1cf50f6bc06b624a3e79852
--- /dev/null
+++ b/dap-sdk/plugin/include/dap_plugin_manifest.h
@@ -0,0 +1,86 @@
+/*
+* Authors:
+* Alexey V. Stratulat <alexey.stratulat@demlabs.net>
+* DeM Labs Inc. https://demlabs.net
+* DeM Labs Open source community https://gitlab.demlabs.net/cellframe/libdap-plugins-python
+* Copyright (c) 2017-2020
+* 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
+
+#ifdef __cplusplus
+extern "C"{
+#endif
+
+#include <stdbool.h>
+#include "uthash.h"
+#include "dap_config.h"
+
+typedef struct dap_plugin_manifest{
+ char name[64];
+ char *version;
+ char *author;
+ char *description;
+
+
+ char * type;// Plugin type
+ char * path;// Path to the directory
+ dap_config_t * config; // Config file
+
+ // Dependencies
+ struct dap_plugin_manifest_dependence *dependencies; // Solved dependencies with links on same manifests
+ char **dependencies_names; // String list of dependencies
+ size_t dependencies_count; // Number of dependencies;
+
+ // Additional params
+ size_t params_count;
+ char ** params;
+
+ // Builtin plugin
+ bool is_builtin; // Doesn't allow to unload if true
+
+ // uthash handle
+ UT_hash_handle hh;
+}dap_plugin_manifest_t;
+
+typedef struct dap_plugin_manifest_dependence{
+ char name[64];
+ dap_plugin_manifest_t * manifest;
+ UT_hash_handle hh;
+}dap_plugin_manifest_dependence_t;
+
+int dap_plugin_manifest_init();
+void dap_plugin_manifest_deinit();
+
+dap_plugin_manifest_t* dap_plugin_manifest_all(void);
+dap_plugin_manifest_t *dap_plugin_manifest_find(const char *a_name);
+
+char* dap_plugin_manifests_get_list_dependencies(dap_plugin_manifest_t *a_element);
+
+dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path);
+dap_plugin_manifest_t* dap_plugin_manifest_add_builtin(const char *a_name, const char * a_type,
+ const char * a_author, const char * a_version,
+ const char * a_description, char ** a_dependencies_names,
+ size_t a_dependencies_count, char ** a_params, size_t a_params_count);
+
+bool dap_plugins_manifest_remove(const char *a_name);
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/dap-sdk/plugin/src/dap_plugin.c b/dap-sdk/plugin/src/dap_plugin.c
new file mode 100644
index 0000000000000000000000000000000000000000..2199a7ea161242c3f1e6f24fdc358765f1f8cbcd
--- /dev/null
+++ b/dap-sdk/plugin/src/dap_plugin.c
@@ -0,0 +1,292 @@
+/*
+* Authors:
+* Alexey V. Stratulat <alexey.stratulat@demlabs.net>
+* Dmitriy Gerasimov <dmitriy.gerasimov@demlabs.net
+* DeM Labs Inc. https://demlabs.net
+* Copyright (c) 2017-2022
+* 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 "uthash.h"
+#include "dap_config.h"
+#include "dap_common.h"
+#include "dap_file_utils.h"
+#include "dap_plugin_manifest.h"
+#include "dap_plugin_command.h"
+#include "dap_plugin_binary.h"
+
+#include "dap_plugin.h"
+#include "dap_strfuncs.h"
+
+#define LOG_TAG "dap_plugin"
+
+static char *s_plugins_root_path = NULL;
+
+struct plugin_type{
+ char *name;
+ dap_plugin_type_callbacks_t callbacks;
+ UT_hash_handle hh;
+} * s_types;
+
+
+struct plugin_module{
+ char *name;
+ struct plugin_type *type;
+ dap_plugin_manifest_t *manifest;
+
+ void * pvt_data; // Here are placed type-related things
+ UT_hash_handle hh;
+};
+
+struct plugin_type *s_types = NULL; // List of all registred plugin types
+struct plugin_module *s_modules = NULL; // List of all loaded modules
+static int s_stop(dap_plugin_manifest_t * a_manifest);
+static int s_start(dap_plugin_manifest_t * a_manifest);
+
+static void s_solve_dependencies();
+
+
+/**
+ * @brief dap_plugin_init
+ * @param a_root_path
+ * @return
+ */
+int dap_plugin_init(const char * a_root_path)
+{
+ s_plugins_root_path = dap_strdup(a_root_path);
+
+ log_it(L_INFO, "Start plugins initialization on root path %s", s_plugins_root_path);
+ if (!dap_dir_test(s_plugins_root_path)){
+ log_it(L_ERROR, "Can't find \"%s\" directory", s_plugins_root_path);
+ return -1;
+ }
+
+ //Get list files
+ dap_list_name_directories_t *l_list_plugins_name = dap_get_subs(s_plugins_root_path);
+ dap_list_name_directories_t *l_element;
+ // Register manifests
+ log_it(L_DEBUG, "Start registration of manifests");
+ dap_plugin_manifest_init();
+ dap_plugin_command_init();
+
+ char *l_name_file = NULL;
+ LL_FOREACH(l_list_plugins_name, l_element){
+ log_it(L_NOTICE, "Registration of \"%s\" manifest", l_element->name_directory);
+ l_name_file = dap_strjoin("",s_plugins_root_path, "/", l_element->name_directory, "/manifest.json", NULL);
+ if (!dap_plugin_manifest_add_from_file(l_name_file)){
+ log_it(L_ERROR, "Registration of \"%s\" manifest is failed", l_element->name_directory);
+ }
+ DAP_FREE(l_name_file);
+ }
+ s_solve_dependencies();
+ return 0;
+}
+
+
+void dap_plugin_deinit(){
+ log_it(L_NOTICE, "Deinitialize plugins");
+ dap_plugin_stop_all();
+ dap_plugin_manifest_deinit();
+ dap_plugin_command_deinit();
+}
+
+
+
+/**
+ * @brief s_solve_dependencies
+ */
+static void s_solve_dependencies()
+{
+ // TODO solving dependencies
+}
+
+
+/**
+ * @brief Create new plugin type. Same name will be new plugin itself to make dependencies from plugin type as from plugin
+ * @param a_name Plugin type name
+ * @param a_callbacks Set of callbacks
+ * @return Returns 0 if success otherwise if not
+ */
+int dap_plugin_type_create(const char* a_name, dap_plugin_type_callbacks_t* a_callbacks)
+{
+ if(!a_name){
+ log_it(L_CRITICAL, "Can't create plugin type without name!");
+ return -1;
+ }
+ if(!a_callbacks){
+ log_it(L_CRITICAL, "Can't create plugin type without callbacks!");
+ return -2;
+ }
+ struct plugin_type * l_new = DAP_NEW_Z(struct plugin_type);
+ if(!l_new){
+ log_it(L_CRITICAL, "OOM on new type create");
+ return -3;
+ }
+ l_new->name = dap_strdup(a_name);
+ memcpy(&l_new->callbacks,a_callbacks,sizeof(l_new->callbacks));
+ return 0;
+}
+
+/**
+ * @brief dap_plugin_start_all
+ */
+void dap_plugin_start_all()
+{
+ dap_plugin_manifest_t * l_manifest, *l_tmp;
+ HASH_ITER(hh,dap_plugin_manifest_all(),l_manifest,l_tmp ){
+ s_start(l_manifest);
+ }
+}
+
+/**
+ * @brief dap_plugin_stop_all
+ */
+void dap_plugin_stop_all()
+{
+ dap_plugin_manifest_t * l_manifest, *l_tmp;
+ HASH_ITER(hh,dap_plugin_manifest_all(),l_manifest,l_tmp ){
+ s_stop(l_manifest);
+ }
+}
+
+/**
+ * @brief dap_plugin_stop
+ * @param a_name
+ * @return
+ */
+int dap_plugin_stop(const char * a_name)
+{
+ dap_plugin_manifest_t * l_manifest = dap_plugin_manifest_find(a_name);
+ if(l_manifest)
+ return s_stop(l_manifest);
+ else
+ return -4; // Not found
+
+}
+
+/**
+ * @brief Stop services by manifest
+ * @param a_manifest
+ * @return
+ */
+static int s_stop(dap_plugin_manifest_t * a_manifest)
+{
+ if(!a_manifest)
+ return -4;
+ struct plugin_module * l_module = NULL;
+ HASH_FIND_STR(s_modules, a_manifest->name , l_module);
+ if(! l_module){
+ log_it(L_ERROR, "Plugin \"%s\" is not loaded", a_manifest->type);
+ return -5;
+ }
+ // unload plugin
+ char * l_err_str = NULL;
+ int l_ret = l_module->type->callbacks.unload(a_manifest,l_module->pvt_data, &l_err_str);
+ if(l_ret){ // Error while unloading
+ log_it(L_ERROR, "Can't unload plugin \"%s\" because of error \"%s\" (code %d)",a_manifest->name,
+ l_err_str?l_err_str:"<UNKNOWN>", l_ret);
+ DAP_DELETE(l_err_str);
+ }else{
+ HASH_DELETE(hh, s_modules,l_module);
+ DAP_DELETE(l_module);
+ }
+ return l_ret;
+}
+
+/**
+ * @brief dap_plugin_start
+ * @param a_name
+ * @return
+ */
+int dap_plugin_start(const char * a_name)
+{
+ dap_plugin_manifest_t * l_manifest = dap_plugin_manifest_find(a_name);
+ if(l_manifest)
+ return s_start(l_manifest);
+ else
+ return -4; // Not found
+}
+
+/**
+ * @brief l_stop
+ * @param a_manifest
+ * @return
+ */
+static int s_start(dap_plugin_manifest_t * a_manifest)
+{
+ struct plugin_type * l_type = NULL;
+ HASH_FIND_STR(s_types, a_manifest->type, l_type);
+ if(! l_type){
+ log_it(L_ERROR, "Plugin type \"%s\" is not recognized", a_manifest->type);
+ return -1;
+ }
+ if (a_manifest->dependencies != NULL){
+ log_it(L_NOTICE, "Check for plugin %s dependencies", a_manifest->name);
+ // Check for dependencies, are they loaded
+ bool l_is_unsolved = false;
+ for(size_t i=0; i< a_manifest->dependencies_count; i++){
+ dap_plugin_manifest_dependence_t * l_dep = NULL;
+ HASH_FIND_STR(a_manifest->dependencies, a_manifest->dependencies_names[i], l_dep);
+ if (!l_dep){ // meet unsolved dependence
+ log_it(L_ERROR, "Unsolved dependence \"%s\"", a_manifest->dependencies_names[i]);
+ l_is_unsolved = true;
+ }
+ }
+ if(l_is_unsolved)
+ return -2;
+ }
+
+ // load plugin
+ char * l_err_str = NULL;
+ void * l_pvt_data = NULL;
+ int l_ret = l_type->callbacks.load(a_manifest,&l_pvt_data, &l_err_str);
+ if(l_ret){ // Error while loading
+ log_it(L_ERROR, "Can't load plugin \"%s\" because of error \"%s\" (code %d)",a_manifest->name,
+ l_err_str?l_err_str:"<UNKNOWN>", l_ret);
+ DAP_DELETE(l_err_str);
+ }else{ // Successfully
+ struct plugin_module * l_module = DAP_NEW_Z(struct plugin_module);
+ l_module->pvt_data = l_pvt_data;
+ strncpy(l_module->name, a_manifest->name, sizeof(l_module->name)-1);
+ l_module->type = l_type;
+ l_module->manifest = a_manifest;
+ HASH_ADD_STR(s_modules,name,l_module);
+ }
+ return l_ret;
+}
+
+/**
+ * @brief dap_plugin_status
+ * @param a_name
+ * @return
+ */
+dap_plugin_status_t dap_plugin_status(const char * a_name)
+{
+ struct plugin_module * l_module = NULL;
+ HASH_FIND_STR(s_modules,a_name,l_module);
+ if(l_module){
+ return STATUS_RUNNING;
+ }
+ dap_plugin_manifest_t * l_manifest = dap_plugin_manifest_find(a_name);
+ if(l_manifest)
+ return STATUS_STOPPED;
+ return STATUS_NONE;
+}
+
+
+
diff --git a/dap-sdk/plugin/src/dap_plugin_binary.c b/dap-sdk/plugin/src/dap_plugin_binary.c
new file mode 100644
index 0000000000000000000000000000000000000000..6bf031d7fc10cbecce34a131d9f3a824b373fd26
--- /dev/null
+++ b/dap-sdk/plugin/src/dap_plugin_binary.c
@@ -0,0 +1,128 @@
+/*
+ * Authors:
+ * Dmitriy A. Gerasimov <gerasimov.dmitriy@demlabs.net>
+ * DeM Labs Inc. https://demlabs.net
+ * Cellframe https://cellframe.net
+ * Copyright (c) 2022
+ * All rights reserved.
+
+ This file is part of Cellframe SDK
+
+ Cellframe SDK 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.
+
+ Cellframe SDK 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 Cellframe SDK based project. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "dap_strfuncs.h"
+#ifdef DAP_OS_LINUX
+#include <dlfcn.h>
+#endif
+
+#include <assert.h>
+#include "dap_plugin.h"
+#include "dap_plugin_binary.h"
+#include "dap_plugin_manifest.h"
+
+#define LOG_TAG "dap_plugin_binary"
+
+typedef int (*plugin_init_callback_t)(dap_config_t * a_plugin_config, char ** a_error_str);
+typedef void (*plugin_deinit_callback_t)(void);
+
+static dap_plugin_manifest_t * s_manifest = NULL; // Own manifest
+
+static int s_type_callback_load(dap_plugin_manifest_t * a_manifest, void ** a_pvt_data, char ** a_error_str );
+static int s_type_callback_unload(dap_plugin_manifest_t * a_manifest, void * a_pvt_data, char ** a_error_str );
+
+struct binary_pvt_data{
+ void *handle;
+ plugin_init_callback_t callback_init;
+ plugin_deinit_callback_t callback_deinit;
+};
+
+/**
+ * @brief dap_plugin_binary_init
+ * @return
+ */
+int dap_plugin_binary_init()
+{
+ dap_plugin_type_callbacks_t l_callbacks={};
+ l_callbacks.load = s_type_callback_load;
+ l_callbacks.unload = s_type_callback_unload;
+ dap_plugin_type_create("bin",&l_callbacks);
+ s_manifest = dap_plugin_manifest_add_builtin("binary", "binary", "Demlabs Inc", "1.0","Binary shared library loader",NULL,0,NULL,0);
+ return 0;
+}
+
+/**
+ * @brief dap_plugin_binary_deinit
+ */
+void dap_plugin_binary_deinit()
+{
+
+}
+
+/**
+ * @brief s_type_callback_load
+ * @param a_manifest
+ * @param a_pvt_data
+ * @param a_error_str
+ * @return
+ */
+static int s_type_callback_load(dap_plugin_manifest_t * a_manifest, void ** a_pvt_data, char ** a_error_str )
+{
+ assert(a_pvt_data);
+ if(a_manifest == s_manifest) // Its our own manifest, do nothing we're already loaded
+ return 0;
+ struct binary_pvt_data * l_pvt_data= DAP_NEW_Z(struct binary_pvt_data);
+ *a_pvt_data = l_pvt_data;
+ #if defined (DAP_OS_LINUX) && !defined (__ANDROID__)
+ char * l_path = dap_strdup_printf("%s/%s.linux.common.%s.so",a_manifest->path,a_manifest->name,dap_get_arch());
+ l_pvt_data->handle = dlopen(l_path, RTLD_NOW); // Try with specified architecture first
+ if(l_pvt_data->handle){
+ l_pvt_data->callback_init = dlsym(l_pvt_data->handle, "plugin_init");
+ l_pvt_data->callback_deinit = dlsym(l_pvt_data->handle, "plugin_deinit");
+ }else{
+ log_it(L_ERROR,"Can't load %s module: %s (expected path %s)", a_manifest->name, l_path, dlerror());
+ *a_error_str = dap_strdup_printf("Can't load %s module: %s (expected path %s)", a_manifest->name, l_path, dlerror());
+ return -5;
+ }
+ #endif
+ if( l_pvt_data->callback_init){
+ return l_pvt_data->callback_init(a_manifest->config,a_error_str);
+ }else{
+ log_it(L_ERROR,"No \"plugin_init\" entry point in binary plugin") ;
+ *a_error_str = dap_strdup("No \"plugin_init\" entry point in binary plugin");
+ DAP_DELETE(l_pvt_data);
+ return -5;
+ }
+}
+
+/**
+ * @brief s_type_callback_unload
+ * @param a_manifest
+ * @param a_pvt_data
+ * @param a_error_str
+ * @return
+ */
+static int s_type_callback_unload(dap_plugin_manifest_t * a_manifest, void * a_pvt_data, char ** a_error_str )
+{
+ if(a_manifest == s_manifest) // Its our own manifest, do nothing we're can't be unloaded
+ return 0;
+ struct binary_pvt_data * l_pvt_data = (struct binary_pvt_data *) a_pvt_data;
+ assert(l_pvt_data);
+ if(l_pvt_data->callback_deinit)
+ l_pvt_data->callback_deinit();
+#if defined (DAP_OS_LINUX) && !defined (__ANDROID__)
+ dlclose(l_pvt_data->handle);
+#endif
+ return 0;
+}
diff --git a/dap-sdk/plugin/src/dap_plugin_command.c b/dap-sdk/plugin/src/dap_plugin_command.c
new file mode 100644
index 0000000000000000000000000000000000000000..272aa3d1be0625a7d710264cb54b8c78fa3b7df6
--- /dev/null
+++ b/dap-sdk/plugin/src/dap_plugin_command.c
@@ -0,0 +1,156 @@
+
+#include "dap_common.h"
+#include "dap_strfuncs.h"
+#include "dap_cli_server.h"
+#include "dap_plugin_manifest.h"
+#include "dap_plugin.h"
+#include "uthash.h"
+#include "utlist.h"
+#include "dap_plugin_command.h"
+
+#define LOG_TAG "dap_plugin_command"
+
+static bool s_l_restart_plugins = false;
+
+static int s_command_handler(int a_argc, char **a_argv, char **a_str_reply);
+
+
+/**
+ * @brief dap_chain_plugins_command_create
+ */
+void dap_plugin_command_init(void)
+{
+ if (!s_l_restart_plugins){
+ dap_cli_server_cmd_add("plugin", s_command_handler,
+ "Commands for working with plugins:\n",
+ "plugin list\n"
+ "\tShow plugins list\n"
+ "plugin show <plugin name>\n"
+ "\tShow plugin details\n"
+ "plugin restart\n"
+ "\tRestart all plugins\n"
+ "plugin reload <plugin name>\n"
+ "\tRestart plugin <plugin name>\n\n");
+ s_l_restart_plugins = true;
+ }
+}
+
+/**
+ * @brief dap_plugin_command_deinit
+ */
+void dap_plugin_command_deinit(void)
+{
+
+}
+
+/**
+ * @brief s_command_handler
+ * @param a_argc
+ * @param a_argv
+ * @param a_str_reply
+ * @return
+ */
+static int s_command_handler(int a_argc, char **a_argv, char **a_str_reply)
+{
+ enum {
+ CMD_NONE, CMD_LIST, CMD_SHOW_NAME, CMD_RESTART, CMD_RELOAD_NAME
+ };
+ int l_arg_index = 1;
+ int l_cmd_name = CMD_NONE;
+ dap_plugin_manifest_t *l_manifest = NULL, *l_tmp = NULL;
+ const char * l_cmd_arg = NULL;
+ if (dap_cli_server_cmd_find_option_val(a_argv,l_arg_index, a_argc, "list", &l_cmd_arg))
+ l_cmd_name = CMD_LIST;
+ if (dap_cli_server_cmd_find_option_val(a_argv,l_arg_index, a_argc, "show", &l_cmd_arg))
+ l_cmd_name = CMD_SHOW_NAME;
+ if (dap_cli_server_cmd_find_option_val(a_argv,l_arg_index, a_argc, "restart", &l_cmd_arg))
+ l_cmd_name = CMD_RESTART;
+ if (dap_cli_server_cmd_find_option_val(a_argv,l_arg_index, a_argc, "reload", &l_cmd_arg))
+ l_cmd_name = CMD_RELOAD_NAME;
+ switch (l_cmd_name) {
+ case CMD_LIST:{
+ char *l_str = NULL;
+ l_str = dap_strdup("|\tName plugin\t|\tVersion\t|\tAuthor(s)\t|\n");
+ HASH_ITER(hh,dap_plugin_manifest_all(), l_manifest, l_tmp){
+ l_str = dap_strjoin(NULL,
+ l_str, "|\t",l_manifest->name, "\t|\t", l_manifest->version, "\t|\t", l_manifest->author, "\t|\n", NULL);
+
+ }
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str);
+ }break;
+ case CMD_SHOW_NAME:
+ if(!l_cmd_arg){
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Need argument for this command");
+ }
+ HASH_FIND_STR(dap_plugin_manifest_all(), l_cmd_arg, l_manifest);
+ if(l_manifest){
+ char *l_deps = dap_plugin_manifests_get_list_dependencies(l_manifest);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, " Name: %s\n Version: %s\n Author: %s\n"
+ " Description: %s\n Dependencies: %s \n\n",
+ l_manifest->name, l_manifest->version, l_manifest->author,
+ l_manifest->description, l_deps?l_deps:" ");
+ if(l_deps)
+ DAP_DELETE(l_deps);
+ } else {
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find a plugin named %s", l_cmd_arg);
+ }
+ break;
+ case CMD_RESTART:
+ log_it(L_NOTICE, "Restart python plugin module");
+ dap_plugin_stop_all();
+ dap_plugin_start_all();
+ log_it(L_NOTICE, "Restart completed");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Restart completed");
+ break;
+ case CMD_RELOAD_NAME:{
+ int l_result;
+ l_result = dap_plugin_stop(l_cmd_arg);
+ switch (l_result) {
+ case 0: //All is good
+ break;
+ case -4:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "A plugin named \"%s\" was not found.", l_cmd_arg);
+ break;
+ case -5:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "A plugin named \"%s\" is not loaded", l_cmd_arg);
+ break;
+ default:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "An unforeseen error has occurred.");
+ break;
+ }
+ if(l_result == 0){
+ l_result = dap_plugin_start(l_cmd_arg);
+ switch (l_result) {
+ case 0:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Restart \"%s\" plugin is completed successfully.", l_cmd_arg);
+ break;
+ case -1:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Plugin \"%s\" has unsupported type, pls check manifest file", l_cmd_arg);
+ break;
+ case -2:
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
+ "\"%s\" plugin has unresolved dependencies. Restart all plugins.",
+ l_cmd_arg);
+ break;
+ case -3:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Registration \"%s\" manifest for \"%s\" plugin is failed.", l_cmd_arg);
+ break;
+ case -4:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Plugin \"%s\" was not found.", l_cmd_arg);
+ break;
+ case -5:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Plugin \"%s\" can't load", l_cmd_arg);
+ break;
+ default:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "An unforeseen error has occurred.");
+ break;
+ }
+ }
+ }break;
+ default:
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Arguments are incorrect.");
+ break;
+
+ }
+ return 0;
+}
diff --git a/dap-sdk/plugin/src/dap_plugin_manifest.c b/dap-sdk/plugin/src/dap_plugin_manifest.c
new file mode 100644
index 0000000000000000000000000000000000000000..32a511185ebe10812ad5177f17381c47e72de138
--- /dev/null
+++ b/dap-sdk/plugin/src/dap_plugin_manifest.c
@@ -0,0 +1,289 @@
+#include "dap_common.h"
+#include "dap_config.h"
+#include "dap_strfuncs.h"
+#include "dap_file_utils.h"
+#include "json-c/json_object.h"
+#include "json-c/json_tokener.h"
+
+#include "dap_plugin_manifest.h"
+#include "uthash.h"
+#include <string.h>
+
+#define LOG_TAG "dap_plugin_manifest"
+
+dap_plugin_manifest_t* s_manifests = NULL;
+
+static void s_manifest_delete(dap_plugin_manifest_t *a_manifest);
+
+/**
+ * @brief dap_plugin_manifest_init
+ * @return
+ */
+int dap_plugin_manifest_init()
+{
+ return 0;
+}
+
+/**
+ * @brief dap_plugin_manifest_deinit
+ */
+void dap_plugin_manifest_deinit()
+{
+ dap_plugin_manifest_t *l_manifest, * l_tmp;
+ HASH_ITER(hh,s_manifests,l_manifest,l_tmp){
+ HASH_DELETE(hh, s_manifests, l_manifest);
+ s_manifest_delete(l_manifest);
+ }
+}
+
+
+/**
+ * @brief dap_plugin_manifest_add_from_scratch
+ * @param a_name
+ * @param a_type
+ * @param a_author
+ * @param a_version
+ * @param a_description
+ * @param a_dependencies_names
+ * @param a_dependencies_count
+ * @param a_params
+ * @param a_params_count
+ * @return
+ */
+dap_plugin_manifest_t* dap_plugin_manifest_add_builtin(const char *a_name, const char * a_type,
+ const char * a_author, const char * a_version,
+ const char * a_description, char ** a_dependencies_names,
+ size_t a_dependencies_count, char ** a_params, size_t a_params_count)
+{
+ dap_plugin_manifest_t *l_manifest = NULL;
+ HASH_FIND_STR(s_manifests, a_name, l_manifest);
+ if(l_manifest){
+ log_it(L_ERROR, "Plugin name \"%s\" is already present", a_name);
+ return NULL;
+ }
+
+ l_manifest = DAP_NEW_Z(dap_plugin_manifest_t);
+ strncpy(l_manifest->name,a_name, sizeof(l_manifest->name)-1);
+ l_manifest->type = dap_strdup(a_type);
+ l_manifest->is_builtin = true;
+ l_manifest->author = dap_strdup(a_author);
+ l_manifest->version = dap_strdup(a_version);
+ l_manifest->description = dap_strdup(a_description);
+ l_manifest->dependencies_names = DAP_NEW_Z_SIZE(char *, sizeof(char*)* a_dependencies_count);
+ for(size_t i = 0; i < a_dependencies_count; i++){
+ l_manifest->dependencies_names[i] = dap_strdup (a_dependencies_names[i]);
+ }
+ l_manifest->dependencies_count = a_dependencies_count;
+
+ l_manifest->params_count = a_params_count;
+ l_manifest->params = DAP_NEW_Z_SIZE(char *, sizeof(char*)* a_params_count);
+ for(size_t i = 0; i < a_params_count; i++){
+ l_manifest->params[i] = dap_strdup (a_params[i]);
+ }
+ HASH_ADD_STR(s_manifests,name,l_manifest);
+ return l_manifest;
+}
+
+/**
+ * @brief dap_plugin_manifest_add_from_file
+ * @param file_path
+ * @return
+ */
+dap_plugin_manifest_t* dap_plugin_manifest_add_from_file(const char *a_file_path)
+{
+ //READ File in char
+ log_it(L_INFO, "Parse JSON file");
+ FILE *l_json_file = fopen(a_file_path, "rt");
+ if (l_json_file == NULL){
+ log_it(L_ERROR, "Can't open manifest file on path: %s", a_file_path);
+ return NULL;
+ }
+ fseek(l_json_file, 0, SEEK_END);
+ size_t size_file = (size_t)ftell(l_json_file);
+ char *l_json_data = DAP_NEW_SIZE(char, size_file);
+ rewind(l_json_file);
+ fread(l_json_data, sizeof(char), size_file, l_json_file);
+ fclose(l_json_file);
+ //Parse JSON
+ json_object *l_json_obj = json_tokener_parse(l_json_data);
+ json_object *l_json_name = NULL;
+ json_object *l_json_version = NULL;
+ json_object *l_json_dependencies = NULL;
+ json_object *l_json_author = NULL;
+ json_object *l_json_description = NULL;
+ json_object *l_json_path = NULL;
+ json_object *l_json_params = NULL;
+ json_object *l_json_type = NULL;
+
+ if (!json_object_object_get_ex(l_json_obj, "name", &l_json_name))
+ return NULL;
+ if (!json_object_object_get_ex(l_json_obj, "type", &l_json_type))
+ return NULL;
+ if (!json_object_object_get_ex(l_json_obj, "version", &l_json_version))
+ return NULL;
+ if (!json_object_object_get_ex(l_json_obj, "dependencies", &l_json_dependencies))
+ return NULL;
+ if (!json_object_object_get_ex(l_json_obj, "author", &l_json_author))
+ return NULL;
+ if (!json_object_object_get_ex(l_json_obj, "description", &l_json_description))
+ return NULL;
+ json_object_object_get_ex(l_json_obj, "description", &l_json_params);
+ json_object_object_get_ex(l_json_obj, "path", &l_json_path);
+
+ const char *l_name, *l_type, *l_version, *l_author, *l_description;
+ size_t l_dependencies_count, l_params_count;
+ char ** l_dependencies_names = NULL, **l_params = NULL;
+ l_name = json_object_get_string(l_json_name);
+
+ dap_plugin_manifest_t *l_manifest = NULL;
+ HASH_FIND_STR(s_manifests, l_name, l_manifest);
+ if(l_manifest){
+ log_it(L_ERROR, "Plugin name \"%s\" is already present", l_name);
+ DAP_DELETE(l_json_data);
+ return NULL;
+ }
+
+
+ l_type = json_object_get_string(l_json_type);
+ l_version = json_object_get_string(l_json_version);
+ l_author = json_object_get_string(l_json_author);
+ l_description = json_object_get_string(l_json_description);
+ l_dependencies_count = (size_t)json_object_array_length(l_json_dependencies);
+ l_params_count = (size_t)json_object_array_length(l_json_params);
+
+ // Read dependencies;
+ if(l_dependencies_count){
+ l_dependencies_names = DAP_NEW_SIZE(char*, sizeof(char*)* l_dependencies_count );
+ for (size_t i = 0; i < l_dependencies_count; i++){
+ l_dependencies_names[i] = dap_strdup(json_object_get_string(json_object_array_get_idx(l_json_dependencies, i)));
+ }
+ }
+
+ // Read additional params
+ if(l_params_count){
+ l_params = DAP_NEW_SIZE(char*, sizeof(char*)* l_params_count );
+ for (size_t i = 0; i < l_params_count; i++){
+ l_params[i] = dap_strdup(json_object_get_string(json_object_array_get_idx(l_json_params, i)));
+ }
+ }
+
+ // Create manifest itself
+ l_manifest = DAP_NEW_Z(dap_plugin_manifest_t);
+ strncpy(l_manifest->name,l_name, sizeof(l_manifest->name)-1);
+ l_manifest->type = dap_strdup(l_type);
+ l_manifest->author = dap_strdup(l_author);
+ l_manifest->version = dap_strdup(l_version);
+ l_manifest->description = dap_strdup(l_description);
+ l_manifest->dependencies_names = l_dependencies_names;
+ l_manifest->dependencies_count = l_dependencies_count;
+ l_manifest->params_count = l_params_count;
+ l_manifest->params = l_params;
+ if(l_json_path){ // If targeted manualy plugin's path
+ l_manifest->path = dap_strdup(json_object_get_string(l_json_path));
+ }else{ // Compose it from plugin root path
+ l_manifest->path = dap_path_get_dirname(a_file_path);
+ }
+
+ char * l_config_path = dap_strdup_printf("%s/%s.cfg", l_manifest->path,l_manifest->name );
+ if(dap_file_test(l_config_path)) // If present custom config
+ l_manifest->config = dap_config_load(l_config_path);
+ DAP_DELETE(l_config_path);
+
+ HASH_ADD_STR(s_manifests,name,l_manifest);
+
+ json_object_put(l_json_dependencies);
+ json_object_put(l_json_description);
+ json_object_put(l_json_author);
+ json_object_put(l_json_version);
+ json_object_put(l_json_name);
+ DAP_FREE(l_json_obj);
+ DAP_FREE(l_json_data);
+ return l_manifest;
+}
+
+/**
+ * @brief Returns all the manifests declared in system
+ * @return
+ */
+dap_plugin_manifest_t* dap_plugin_manifest_all()
+{
+ return s_manifests;
+}
+
+/**
+ * @brief Find plugin manifest by its unique name
+ * @param a_name Plugin name
+ * @return Pointer to manifest object if found or NULL if not
+ */
+dap_plugin_manifest_t *dap_plugin_manifest_find(const char *a_name)
+{
+ dap_plugin_manifest_t *l_ret;
+ HASH_FIND_STR(s_manifests,a_name,l_ret);
+ return l_ret;
+}
+
+/**
+ * @brief Create string with list of dependencies, breaking by ","
+ * @param a_element
+ * @return
+ */
+char* dap_plugin_manifests_get_list_dependencies(dap_plugin_manifest_t *a_element)
+{
+ if (a_element->dependencies == NULL) {
+ return NULL;
+ } else {
+ char *l_result = "";
+ dap_plugin_manifest_dependence_t * l_dep, *l_tmp;
+ HASH_ITER(hh,a_element->dependencies,l_dep,l_tmp){
+ dap_plugin_manifest_t * l_dep_manifest = l_dep->manifest;
+ if (l_dep->hh.hh_next )
+ l_result = dap_strjoin(NULL, l_result, l_dep_manifest->name, ", ", NULL);
+ else
+ l_result = dap_strjoin(NULL, l_result, l_dep_manifest->name, NULL);
+ }
+ return l_result;
+ }
+}
+
+/**
+ * @brief s_manifest_delete
+ * @param a_manifest
+ */
+static void s_manifest_delete(dap_plugin_manifest_t *a_manifest)
+{
+ DAP_DELETE(a_manifest->name);
+ DAP_DELETE(a_manifest->version);
+ DAP_DELETE(a_manifest->author);
+ DAP_DELETE(a_manifest->description);
+ if(a_manifest->dependencies_names){
+ for(size_t i = 0; i< a_manifest->dependencies_count; i++)
+ DAP_DELETE(a_manifest->dependencies_names[i]);
+ DAP_DELETE(a_manifest->dependencies_names);
+ }
+ dap_plugin_manifest_dependence_t * l_dep, *l_tmp;
+ HASH_ITER(hh,a_manifest->dependencies,l_dep,l_tmp){
+ HASH_DELETE(hh, a_manifest->dependencies, l_dep);
+ DAP_DELETE(l_dep);
+ }
+ DAP_DELETE(a_manifest);
+
+}
+
+/**
+ * @brief dap_plugins_manifest_remove
+ * @param a_name
+ * @return
+ */
+bool dap_plugins_manifest_remove(const char *a_name)
+{
+ dap_plugin_manifest_t *l_manifest;
+ HASH_FIND_STR(s_manifests, a_name,l_manifest);
+ if(l_manifest)
+ HASH_DEL(s_manifests, l_manifest);
+ else
+ return false;
+
+ s_manifest_delete(l_manifest);
+ return true;
+}
+
diff --git a/modules/CMakeLists.txt b/modules/CMakeLists.txt
index 6cb243e903d6251831350b1db60f993ffd5ca33b..5741cde7a0b651e5c2afce039696e8bf02ba4d39 100644
--- a/modules/CMakeLists.txt
+++ b/modules/CMakeLists.txt
@@ -1,7 +1,6 @@
# Core
if (CELLFRAME_MODULES MATCHES "core")
add_subdirectory(common)
- add_subdirectory(app-cli)
endif()
# Chains
diff --git a/modules/consensus/block-poa/dap_chain_cs_block_poa.c b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
index a4ab12bfba169c8d01d262256aba1a99b160e8fd..7cf5f83d0d318207b1bd3f7b10364770a58bd07a 100644
--- a/modules/consensus/block-poa/dap_chain_cs_block_poa.c
+++ b/modules/consensus/block-poa/dap_chain_cs_block_poa.c
@@ -74,7 +74,7 @@ int dap_chain_cs_block_poa_init(void)
// Add consensus constructor
dap_chain_cs_add ("block_poa", s_callback_new );
s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
- dap_chain_node_cli_cmd_item_create ("block_poa", s_cli_block_poa, "Blockchain PoA commands",
+ dap_cli_server_cmd_add ("block_poa", s_cli_block_poa, "Blockchain PoA commands",
"block_poa -net <chain net name> -chain <chain name> block sign [-cert <cert name>] \n"
"\tSign new block with certificate <cert name> or withs own PoA certificate\n\n");
@@ -107,11 +107,11 @@ static int s_cli_block_poa(int argc, char ** argv, char **a_str_reply)
dap_chain_t * l_chain = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type, "hex") && dap_strcmp(l_hash_out_type, "base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -124,9 +124,9 @@ static int s_cli_block_poa(int argc, char ** argv, char **a_str_reply)
const char * l_block_hash_str = NULL;
const char * l_cert_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "block", &l_block_new_cmd_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-block", &l_block_hash_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-cert", &l_cert_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "block", &l_block_new_cmd_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-block", &l_block_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-cert", &l_cert_str);
dap_enc_key_t *l_sign_key;
// Load cert to sign if its present
@@ -137,7 +137,7 @@ static int s_cli_block_poa(int argc, char ** argv, char **a_str_reply)
l_sign_key = l_poa_pvt->sign_key;
}
if (!l_sign_key || !l_sign_key->priv_key_data) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No certificate to sign blocks\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No certificate to sign blocks\n");
return -2;
}
diff --git a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
index 5986f4d9a30a3de867c24cf5add76c465417826b..df3b1b55c8f668581b82861b2f2b410bbb8c89a9 100644
--- a/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
+++ b/modules/consensus/dag-poa/dap_chain_cs_dag_poa.c
@@ -113,7 +113,7 @@ int dap_chain_cs_dag_poa_init(void)
// Add consensus constructor
dap_chain_cs_add ("dag_poa", s_callback_new );
s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
- dap_chain_node_cli_cmd_item_create ("dag_poa", s_cli_dag_poa, "DAG PoA commands",
+ dap_cli_server_cmd_add ("dag_poa", s_cli_dag_poa, "DAG PoA commands",
"dag_poa event sign -net <chain net name> -chain <chain name> -event <event hash> [-H {hex | base58(default)}]\n"
"\tSign event <event hash> in the new round pool with its authorize certificate\n\n");
@@ -179,11 +179,11 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
dap_chain_t * l_chain = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type, "hex") && dap_strcmp(l_hash_out_type, "base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -197,14 +197,14 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
const char * l_event_cmd_str = NULL;
const char * l_event_hash_str = NULL;
if ( l_poa_pvt->events_sign_cert == NULL) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No certificate to sign events\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No certificate to sign events\n");
return -2;
}
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "event", &l_event_cmd_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "event", &l_event_cmd_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
if (!l_event_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command dag_poa requires parameter '-event' <event hash>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command dag_poa requires parameter '-event' <event hash>");
return -4;
}
@@ -217,7 +217,7 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
l_event_hash_base58_str = dap_enc_base58_from_hex_str_to_str(l_event_hash_str);
if (!l_event_hash_base58_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid hex hash format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid hex hash format");
DAP_DELETE(l_event_hash_hex_str);
return -5;
}
@@ -228,7 +228,7 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
if (!l_event_hash_hex_str) {
DAP_DELETE(l_event_hash_base58_str);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid base58 hash format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid base58 hash format");
return -6;
}
@@ -248,7 +248,7 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
(dap_chain_cs_dag_event_round_item_t *)dap_global_db_get_sync(l_gdb_group_events,
l_event_hash_hex_str, &l_round_item_size, NULL, NULL );
if ( l_round_item == NULL ) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find event in round.new - only place where could be signed the new event\n",
l_event_hash_str);
ret = -30;
@@ -269,12 +269,12 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
if (dap_chain_cs_dag_event_gdb_set(l_dag, l_event_new_hash_hex_str, l_event,
l_event_size_new, l_round_item)) {
if(!dap_strcmp(l_hash_out_type, "hex")) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Added new sign with cert \"%s\", event %s placed back in round.new\n",
l_poa_pvt->events_sign_cert->name, l_event_new_hash_hex_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Added new sign with cert \"%s\", event %s placed back in round.new\n",
l_poa_pvt->events_sign_cert->name, l_event_new_hash_base58_str);
}
@@ -283,12 +283,12 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
s_round_event_cs_done(l_dag, l_event->header.round_id);
} else {
if(!dap_strcmp(l_hash_out_type, "hex")) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"GDB Error: Can't place event %s with new sign back in round.new\n",
l_event_new_hash_hex_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"GDB Error: Can't place event %s with new sign back in round.new\n",
l_event_new_hash_base58_str);
}
@@ -299,7 +299,7 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
DAP_DELETE(l_event_new_hash_hex_str);
DAP_DELETE(l_event_new_hash_base58_str);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't sign event in round.new\n",
l_event_hash_str);
ret=-1;
@@ -307,10 +307,10 @@ static int s_cli_dag_poa(int argc, char ** argv, char **a_str_reply)
DAP_DELETE(l_round_item);
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command dag_poa requires subcommand 'sign'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command dag_poa requires subcommand 'sign'");
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command dag_poa requires subcommand 'event'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command dag_poa requires subcommand 'event'");
}
DAP_DELETE(l_event_hash_hex_str);
diff --git a/modules/net/CMakeLists.txt b/modules/net/CMakeLists.txt
index ea6f12058037b9e67982566cdfd3b2d75a312dca..d54d45da2705c42468cc2e9f73c32be903548cf0 100644
--- a/modules/net/CMakeLists.txt
+++ b/modules/net/CMakeLists.txt
@@ -37,16 +37,16 @@ endif()
add_library(${PROJECT_NAME} STATIC ${DAP_CHAIN_NET_SRCS} ${DAP_CHAIN_NET_HEADERS} ${IPUTILS_SRCS} ${IPUTILS_HEADERS})
if(WIN32)
- target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_client dap_io dap_notify_srv dap_stream_ch_chain dap_stream_ch_chain_net dap_stream_ch_chain_net_srv dap_chain dap_chain_wallet dap_chain_net_srv dap_stream_ch_chain_voting
+ target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_client dap_io dap_notify_srv dap_cli_server dap_stream_ch_chain dap_stream_ch_chain_net dap_stream_ch_chain_net_srv dap_chain dap_chain_wallet dap_chain_net_srv dap_stream_ch_chain_voting
dap_chain_mempool dap_chain_global_db dap_chain_cs_none)
endif()
if(LINUX)
- target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_io dap_notify_srv dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_stream_ch_chain_net_srv dap_stream_ch_chain_voting dap_chain
+ target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_io dap_notify_srv dap_cli_server dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_stream_ch_chain_net_srv dap_stream_ch_chain_voting dap_chain
dap_chain_wallet dap_chain_net_srv dap_chain_mempool dap_chain_global_db dap_chain_cs_none
resolv )
elseif(BSD)
- target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_io dap_notify_srv dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_stream_ch_chain_net_srv dap_stream_ch_chain_voting dap_chain
+ target_link_libraries(${PROJECT_NAME} dap_core dap_crypto dap_io dap_notify_srv dap_cli_server dap_client dap_stream_ch_chain dap_stream_ch_chain_net dap_stream_ch_chain_net_srv dap_stream_ch_chain_voting dap_chain
dap_chain_wallet dap_chain_net_srv dap_chain_mempool dap_chain_global_db dap_chain_cs_none )
endif()
diff --git a/modules/net/dap_chain_net.c b/modules/net/dap_chain_net.c
index 9efe26944d68b2b910f9694d23dff29dff51aad7..9da9ca66e27378937655cd0fb6029a6c3d0b92ef 100644
--- a/modules/net/dap_chain_net.c
+++ b/modules/net/dap_chain_net.c
@@ -298,7 +298,7 @@ int dap_chain_net_init()
dap_stream_ch_chain_init();
dap_stream_ch_chain_net_init();
dap_chain_node_client_init();
- dap_chain_node_cli_cmd_item_create ("net", s_cli_net, "Network commands",
+ dap_cli_server_cmd_add ("net", s_cli_net, "Network commands",
"net list [chains -n <chain net name>]"
"\tList all networks or list all chains in selected network"
"net -net <chain net name> [-mode {update | all}] go {online | offline | sync}\n"
@@ -1724,7 +1724,7 @@ void s_set_reply_text_node_status(char **a_str_reply, dap_chain_net_t * a_net){
l_sync_current_link_text_block = dap_strdup_printf(", active links %u from %u",
PVT(a_net)->links_connected_count,
dap_list_length(PVT(a_net)->net_links));
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Network \"%s\" has state %s (target state %s)%s%s",
a_net->pub.name, c_net_states[PVT(a_net)->state],
c_net_states[PVT(a_net)->state_target],
@@ -1868,23 +1868,23 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
// command 'list'
const char * l_list_cmd = NULL;
- if(dap_chain_node_cli_find_option_val(argv, arg_index, min(argc, arg_index + 1), "list", &l_list_cmd) != 0 ) {
+ if(dap_cli_server_cmd_find_option_val(argv, arg_index, min(argc, arg_index + 1), "list", &l_list_cmd) != 0 ) {
dap_string_t *l_string_ret = dap_string_new("");
if (dap_strcmp(l_list_cmd,"chains")==0){
const char * l_net_str = NULL;
dap_chain_net_t* l_net = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-net", &l_net_str);
l_net = dap_chain_net_by_name(l_net_str);
@@ -1935,7 +1935,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
dap_string_append(l_string_ret, "\n");
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_string_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_string_ret->str);
dap_string_free(l_string_ret, true);
return 0;
}
@@ -1950,16 +1950,16 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
const char *l_stats_str = NULL;
const char *l_ca_str = NULL;
const char *l_ledger_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "sync", &l_sync_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "link", &l_links_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "go", &l_go_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "get", &l_get_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "stats", &l_stats_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "ca", &l_ca_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "ledger", &l_ledger_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "sync", &l_sync_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "link", &l_links_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "go", &l_go_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "get", &l_get_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "stats", &l_stats_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "ca", &l_ca_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "ledger", &l_ledger_str);
const char * l_sync_mode_str = "updates";
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-mode", &l_sync_mode_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-mode", &l_sync_mode_str);
if ( !dap_strcmp(l_sync_mode_str,"all") )
dap_chain_net_get_flag_sync_from_zero(l_net);
if (l_stats_str) {
@@ -1971,9 +1971,9 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
const char *l_from_str = NULL;
const char *l_prev_sec_str = NULL;
// Read from/to time
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-from", &l_from_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-to", &l_to_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-prev_sec", &l_prev_sec_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-from", &l_from_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-to", &l_to_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-prev_sec", &l_prev_sec_str);
time_t l_ts_now = time(NULL);
if (l_from_str) {
strptime( (char *)l_from_str, c_time_fmt, &l_from_tm );
@@ -2005,7 +2005,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
(long double) l_tx_count / (long double) ( l_to_ts - l_from_ts );
dap_string_append_printf( l_ret_str, "\tSpeed: %.3Lf TPS\n", l_tps );
dap_string_append_printf( l_ret_str, "\tTotal: %"DAP_UINT64_FORMAT_U"\n", l_tx_count );
- dap_chain_node_cli_set_reply_text( a_str_reply, l_ret_str->str );
+ dap_cli_server_cmd_set_reply_text( a_str_reply, l_ret_str->str );
dap_string_free( l_ret_str, false );
} else if (strcmp(l_stats_str, "tps") == 0) {
struct timespec l_from_time_acc = {}, l_to_time_acc = {};
@@ -2023,33 +2023,33 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
dap_string_append_printf(l_ret_str, "\tSpeed: %.3Lf TPS\n", l_tps);
}
dap_string_append_printf(l_ret_str, "\tTotal: %zu\n", l_tx_num);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_ret_str->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_ret_str->str);
dap_string_free(l_ret_str, false);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Subcommand 'stats' requires one of parameter: tx, tps\n");
}
} else if ( l_go_str){
if ( strcmp(l_go_str,"online") == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network \"%s\" going from state %s to %s",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network \"%s\" going from state %s to %s",
l_net->pub.name,c_net_states[PVT(l_net)->state],
c_net_states[NET_STATE_ONLINE]);
dap_chain_net_state_go_to(l_net, NET_STATE_ONLINE);
} else if ( strcmp(l_go_str,"offline") == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network \"%s\" going from state %s to %s",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network \"%s\" going from state %s to %s",
l_net->pub.name,c_net_states[PVT(l_net)->state],
c_net_states[NET_STATE_OFFLINE]);
dap_chain_net_state_go_to(l_net, NET_STATE_OFFLINE);
} else if (strcmp(l_go_str, "sync") == 0) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network \"%s\" resynchronizing",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network \"%s\" resynchronizing",
l_net->pub.name);
if (PVT(l_net)->state_target == NET_STATE_ONLINE)
dap_chain_net_state_go_to(l_net, NET_STATE_ONLINE);
else
dap_chain_net_state_go_to(l_net, NET_STATE_SYNC_CHAINS);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Subcommand 'go' requires one of parameters: online, offline, sync\n");
}
} else if ( l_get_str){
@@ -2089,23 +2089,23 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
i++;
}
pthread_rwlock_unlock(&l_net_pvt->rwlock );
- dap_chain_node_cli_set_reply_text(a_str_reply,"%s",l_reply->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply,"%s",l_reply->str);
dap_string_free(l_reply,true);
} else if ( strcmp(l_links_str,"add") == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply,"Not implemented\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply,"Not implemented\n");
} else if ( strcmp(l_links_str,"del") == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply,"Not implemented\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply,"Not implemented\n");
} else if ( strcmp(l_links_str,"info") == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply,"Not implemented\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply,"Not implemented\n");
} else if ( strcmp (l_links_str,"disconnect_all") == 0 ){
l_ret = 0;
dap_chain_net_stop(l_net);
- dap_chain_node_cli_set_reply_text(a_str_reply,"Stopped network\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply,"Stopped network\n");
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Subcommand 'link' requires one of parameters: list, add, del, info, disconnect_all\n");
l_ret = -3;
}
@@ -2113,25 +2113,25 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
} else if( l_sync_str) {
if ( strcmp(l_sync_str,"all") == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"SYNC_ALL state requested to state machine. Current state: %s\n",
c_net_states[ PVT(l_net)->state] );
dap_chain_net_sync_all(l_net);
} else if ( strcmp(l_sync_str,"gdb") == 0) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"SYNC_GDB state requested to state machine. Current state: %s\n",
c_net_states[ PVT(l_net)->state] );
dap_chain_net_sync_gdb(l_net);
} else if ( strcmp(l_sync_str,"chains") == 0) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"SYNC_CHAINS state requested to state machine. Current state: %s\n",
c_net_states[ PVT(l_net)->state] );
// TODO set PVT flag to exclude GDB sync
dap_chain_net_sync_chains(l_net);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Subcommand 'sync' requires one of parameters: all, gdb, chains\n");
l_ret = -2;
}
@@ -2141,11 +2141,11 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-cert", &l_cert_string);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-hash", &l_hash_string);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-cert", &l_cert_string);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-hash", &l_hash_string);
if (!l_cert_string && !l_hash_string) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "One of -cert or -hash parameters is mandatory");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "One of -cert or -hash parameters is mandatory");
return -6;
}
char *l_hash_hex_str = NULL;
@@ -2163,18 +2163,18 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
if (l_cert_string) {
dap_cert_t * l_cert = dap_cert_find_by_name(l_cert_string);
if (l_cert == NULL) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find \"%s\" certificate", l_cert_string);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find \"%s\" certificate", l_cert_string);
return -7;
}
if (l_cert->enc_key == NULL) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No key found in \"%s\" certificate", l_cert_string );
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No key found in \"%s\" certificate", l_cert_string );
return -8;
}
// Get publivc key hash
size_t l_pub_key_size = 0;
uint8_t *l_pub_key = dap_enc_key_serealize_pub_key(l_cert->enc_key, &l_pub_key_size);;
if (l_pub_key == NULL) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't serialize public key of certificate \"%s\"", l_cert_string);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't serialize public key of certificate \"%s\"", l_cert_string);
return -9;
}
dap_chain_hash_fast_t l_pkey_hash;
@@ -2185,7 +2185,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
const char c = '1';
char *l_gdb_group_str = dap_chain_net_get_gdb_group_acl(l_net);
if (!l_gdb_group_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Database ACL group not defined for this network");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Database ACL group not defined for this network");
return -11;
}
if( l_hash_hex_str ){
@@ -2193,19 +2193,19 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
DAP_DELETE(l_gdb_group_str);
DAP_DELETE(l_hash_hex_str);
if (!l_ret) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't save public key hash %s in database", l_hash_hex_str);
return -10;
}
} else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't save NULL public key hash in database");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't save NULL public key hash in database");
return -10;
}
return 0;
} else if (strcmp(l_ca_str, "list") == 0 ) {
char *l_gdb_group_str = dap_chain_net_get_gdb_group_acl(l_net);
if (!l_gdb_group_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Database ACL group not defined for this network");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Database ACL group not defined for this network");
return -11;
}
size_t l_objs_count;
@@ -2222,25 +2222,25 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
return 0;
} else if (strcmp(l_ca_str, "del") == 0 ) {
const char *l_hash_string = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-hash", &l_hash_string);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-hash", &l_hash_string);
if (!l_hash_string) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format should be 'net ca del -hash <hash string>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format should be 'net ca del -hash <hash string>");
return -6;
}
char *l_gdb_group_str = dap_chain_net_get_gdb_group_acl(l_net);
if (!l_gdb_group_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Database ACL group not defined for this network");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Database ACL group not defined for this network");
return -11;
}
l_ret = dap_global_db_del_sync(l_gdb_group_str, l_hash_string);
DAP_DELETE(l_gdb_group_str);
if (!l_ret) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Cant't find certificate public key hash in database");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Cant't find certificate public key hash in database");
return -10;
}
return 0;
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Subcommand 'ca' requires one of parameter: add, list, del\n");
l_ret = -5;
}
@@ -2250,7 +2250,7 @@ static int s_cli_net(int argc, char **argv, char **a_str_reply)
}
else
{
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Command 'net' requires one of subcomands: sync, link, go, get, stats, ca, ledger");
l_ret = -1;
}
diff --git a/modules/net/dap_chain_node_cli.c b/modules/net/dap_chain_node_cli.c
index 8a9038d5185936e08f21e868d9a3816a01391278..e97b4f724170c8a1e79d22085efffc598c5ad885 100644
--- a/modules/net/dap_chain_node_cli.c
+++ b/modules/net/dap_chain_node_cli.c
@@ -30,30 +30,6 @@
//#include <glib.h>
#include <unistd.h>
-#ifndef _WIN32
-#include <poll.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <arpa/inet.h>
-//#include <unistd.h> // for close
-#include <fcntl.h>
-//#include <sys/poll.h>
-//#include <sys/select.h>
-#include <netinet/in.h>
-#include <sys/un.h>
-#include <sys/stat.h>
-//#define closesocket close
-//typedef int SOCKET;
-//#define SOCKET_ERROR -1 // for win32 = (-1)
-//#define INVALID_SOCKET -1 // for win32 = (SOCKET)(~0)
-// for Windows
-#else
-#include <winsock2.h>
-#include <windows.h>
-#include <mswsock.h>
-#include <ws2tcpip.h>
-#include <io.h>
-#endif
#include <pthread.h>
@@ -66,809 +42,13 @@
#include "dap_chain_node_cli_cmd.h"
#include "dap_chain_node_client.h"
#include "dap_chain_node_cli_cmd_tx.h"
+#include "dap_cli_server.h"
#include "dap_chain_node_cli.h"
//#include "dap_chain_node_cli.h"
#define LOG_TAG "chain_node_cli"
-
-#define MAX_CONSOLE_CLIENTS 16
-
-static SOCKET server_sockfd = -1; // network or local unix
-uint32_t l_listen_port = 0;
-bool s_debug_cli = false;
-
-#ifdef _WIN32
- #define poll WSAPoll
-#endif
-
-static dap_chain_node_cmd_item_t * s_commands = NULL;
-
-/**
- * @brief int s_poll
- * Wait for data
- * timeout - timeout in ms
- * [Specifying a negative value in timeout means an infinite timeout.]
- * [Specifying a timeout of zero causes poll() to return immediately, even if no file descriptors are ready.]
- * return zero if the time limit expired
- * return: >0 if data is present to read
- * return: -1 if error
- * @param socket
- * @param timeout
- * @return int
- */
-static int s_poll( int sd, int timeout )
-{
-struct pollfd fds = {.fd = sd, .events = POLLIN};
-int res;
-
- res = poll(&fds, 1, timeout);
-
- return (res == 1 && !(fds.revents & POLLIN)) ? -1 : res;
-}
-
-
-/**
- * @brief is_valid_socket
- * Check socket for validity
- * @param sock
- * @return true
- * @return false
- */
-static int is_valid_socket(SOCKET sd)
-{
-struct pollfd fds = {.fd = sd, .events = POLLIN};
-int res;
-
- if ( 0 > (res = poll(&fds, 1, 0)) )
- return false;
-
- // event with an error code
- if(res > 0)
- {
- // feature of disconnection under Windows
- // under Windows, with socket closed fds.revents=POLLHUP, in Unix fds.events = POLLIN
- if(fds.revents & (POLLERR | POLLHUP | POLLNVAL))
- return false;
-
- // feature of disconnection under Unix (QNX)
- // under Windows, with socket closed res = 0, in Unix res = -1
- char buf[2];
- if ( 0 > (res = recv(sd, buf, 1, MSG_PEEK)) ) // MSG_PEEK The data is treated as unread and the next recv() function shall still return this data.
- return false;
-
- // data in the buffer must be(count_desc>0), but read 0 bytes(res=0)
- if(!res && (fds.revents & POLLIN))
- return false;
- }
-
- return true;
-}
-
-/**
- * @brief s_recv
- * timeout in milliseconds
- * return the number of read bytes (-1 err or -2 timeout)
- * @param sock
- * @param buf
- * @param bufsize
- * @param timeout
- * @return long
- */
-long s_recv(SOCKET sd, unsigned char *buf, size_t bufsize, int timeout)
-{
-struct pollfd fds = {.fd = sd, .events = POLLIN};
-int res;
-
- if ( !(res = poll(&fds, 1, timeout)) )
- return -2;
-
- if ( (res == 1) && !(fds.revents & POLLIN))
- return -1;
-
- if(res < 1)
- return -1;
-
- if ( 0 >= (res = recv(sd, (char *)buf, bufsize, 0)) )
- printf("[s_recv] recv()->%d, errno: %d\n", res, errno);
-
- return res;
-}
-
-
-/**
- * @brief s_get_next_str
- * Reading from the socket till arrival the specified string
- *
- * stop_str - string to which reading will continue
- * del_stop_str - удалÑÑ‚ÑŒ ли Ñтроку Ð´Ð»Ñ Ð¿Ð¾Ð¸Ñка в конце
- * timeout - in ms
- * return: string (if waited for final characters) or NULL, if the string requires deletion
- * @param nSocket
- * @param dwLen
- * @param stop_str
- * @param del_stop_str
- * @param timeout
- * @return char*
- */
-char* s_get_next_str( SOCKET nSocket, int *dwLen, const char *stop_str, bool del_stop_str, int timeout )
-{
- bool bSuccess = false;
- long nRecv = 0; // count of bytes received
- size_t stop_str_len = (stop_str) ? strlen(stop_str) : 0;
- // if there is nothing to look for
- if(!stop_str_len)
- return NULL;
- size_t lpszBuffer_len = 256;
- char *lpszBuffer = DAP_NEW_Z_SIZE(char, lpszBuffer_len);
- // received string will not be larger than MAX_REPLY_LEN
-
- while(1) //nRecv < MAX_REPLY_LEN)
- {
- // read one byte
- long ret = s_recv(nSocket, (unsigned char *) (lpszBuffer + nRecv), 1, timeout);
- //int ret = recv(nSocket,lpszBuffer+nRecv,1, 0);
- if(ret <= 0)
- {
- break;
- }
- nRecv += ret;
- //printf("**debug** socket=%d read %d bytes '%0s'",nSocket, ret, (lpszBuffer + nRecv));
- while((nRecv + 1) >= (long) lpszBuffer_len)
- {
- lpszBuffer_len *= 2;
- lpszBuffer = (char*) realloc(lpszBuffer, lpszBuffer_len);
- }
- // search for the required string
- if(nRecv >= (long) stop_str_len) {
- // found the required string
- if(!strncasecmp(lpszBuffer + nRecv - stop_str_len, stop_str, stop_str_len)) {
- bSuccess = true;
- break;
- }
- }
- };
-
- // end reading
-
- if(bSuccess) {
- // delete the searched string
- if(del_stop_str) {
- lpszBuffer[nRecv - (long) stop_str_len] = '\0';
- if(dwLen)
- *dwLen =(int) nRecv - (int) stop_str_len;
- }
- else {
- lpszBuffer[nRecv] = '\0';
- if(dwLen)
- *dwLen = (int) nRecv;
- }
- char * l_buf_realloc = DAP_REALLOC(lpszBuffer,(size_t) *dwLen + 1);
- if( l_buf_realloc)
- lpszBuffer = l_buf_realloc;
- return lpszBuffer;
- }
-
- // in case of an error or missing string
-
- if(dwLen)
- *dwLen = 0;
-
- free(lpszBuffer);
-
- return NULL;
-}
-
-/**
- * threading function for processing a request from a client
- */
-static void* thread_one_client_func(void *args)
-{
-SOCKET newsockfd = (SOCKET) (intptr_t) args;
-int str_len, marker = 0, timeout = 5000, argc = 0, is_data;
-dap_list_t *cmd_param_list = NULL;
-char *str_header;
-
- if(s_debug_cli)
- log_it(L_DEBUG, "new connection sockfd=%"DAP_FORMAT_SOCKET, newsockfd);
-
-
- while ( !(0 > (is_data = s_poll(newsockfd, timeout))) ) // wait data from client
- {
- if ( !(is_data) ) // timeout
- continue;
-
- if ( !is_valid_socket(newsockfd) )
- break;
-
- // receiving http header
- if ( !(str_header = s_get_next_str(newsockfd, &str_len, "\r\n", true, timeout)) )
- break; // bad format
-
- if(str_header && !strlen(str_header) ) {
- marker++;
- if(marker == 1){
- DAP_DELETE(str_header);
- continue;
- }
- }
-
- // filling parameters of command
- if(marker == 1) {
- cmd_param_list = dap_list_append(cmd_param_list, str_header);
- //printf("g_list_append argc=%d command=%s ", argc, str_header);
- argc++;
- }
- else
- DAP_DEL_Z(str_header);
-
- if(marker == 2 && cmd_param_list) {
- dap_list_t *list = cmd_param_list;
- // form command
- argc = dap_list_length(list);
- // command is found
- if(argc >= 1) {
- int l_verbose = 0;
- char *cmd_name = list->data;
- list = dap_list_next(list);
- // execute command
- char *str_cmd = dap_strdup_printf("%s", cmd_name);
- dap_chain_node_cmd_item_t *l_cmd = dap_chain_node_cli_cmd_find(cmd_name);
- int res = -1;
- char *str_reply = NULL;
- if(l_cmd){
- while(list) {
- char *str_cmd_prev = str_cmd;
- str_cmd = dap_strdup_printf("%s;%s", str_cmd, list->data);
- list = dap_list_next(list);
- DAP_DELETE(str_cmd_prev);
- }
- if(l_cmd->overrides.log_cmd_call)
- l_cmd->overrides.log_cmd_call(str_cmd);
- else
- log_it(L_DEBUG, "execute command=%s", str_cmd);
- // exec command
-
- char **l_argv = dap_strsplit(str_cmd, ";", -1);
- // Call the command function
- if(l_cmd && l_argv && l_cmd->func) {
- if (l_cmd->arg_func) {
- res = l_cmd->func_ex(argc, l_argv, l_cmd->arg_func, &str_reply);
- } else {
- res = l_cmd->func(argc, l_argv, &str_reply);
- }
- } else if (l_cmd) {
- log_it(L_WARNING,"NULL arguments for input for command \"%s\"", str_cmd);
- }else {
- log_it(L_WARNING,"No function for command \"%s\" but it registred?!", str_cmd);
- }
- // find '-verbose' command
- l_verbose = dap_chain_node_cli_find_option_val(l_argv, 1, argc, "-verbose", NULL);
- dap_strfreev(l_argv);
- } else {
- str_reply = dap_strdup_printf("can't recognize command=%s", str_cmd);
- log_it(L_ERROR,"Reply string: \"%s\"", str_reply);
- }
- char *reply_body;
- if(l_verbose)
- reply_body = dap_strdup_printf("%d\r\nret_code: %d\r\n%s\r\n", res, res, (str_reply) ? str_reply : "");
- else
- reply_body = dap_strdup_printf("%d\r\n%s\r\n", res, (str_reply) ? str_reply : "");
- // return the result of the command function
- char *reply_str = dap_strdup_printf("HTTP/1.1 200 OK\r\n"
- "Content-Length: %d\r\n\r\n"
- "%s", strlen(reply_body), reply_body);
- size_t l_reply_step = 32768;
- size_t l_reply_len = strlen(reply_str);
- size_t l_reply_rest = l_reply_len;
-
- while(l_reply_rest) {
- size_t l_send_bytes = min(l_reply_step, l_reply_rest);
- int ret = send(newsockfd, reply_str + l_reply_len - l_reply_rest, l_send_bytes, 0);
- if(ret<=0)
- break;
- l_reply_rest-=l_send_bytes;
- };
-
- DAP_DELETE(str_reply);
- DAP_DELETE(reply_str);
- DAP_DELETE(reply_body);
-
- DAP_DELETE(str_cmd);
- }
- dap_list_free_full(cmd_param_list, NULL);
- break;
- }
- }
- // close connection
- int cs = closesocket(newsockfd);
- if (s_debug_cli)
- log_it(L_DEBUG, "close connection=%d sockfd=%"DAP_FORMAT_SOCKET, cs, newsockfd);
-
- return NULL;
-}
-
-#ifdef _WIN32
-
-/**
- * @brief p_get_next_str
- *
- * @param hPipe
- * @param dwLen
- * @param stop_str
- * @param del_stop_str
- * @param timeout
- * @return char*
- */
-char *p_get_next_str( HANDLE hPipe, int *dwLen, const char *stop_str, bool del_stop_str, int timeout )
-{
- UNUSED(timeout);
- bool bSuccess = false;
- long nRecv = 0; // count of bytes received
- size_t stop_str_len = (stop_str) ? strlen(stop_str) : 0;
- // if there is nothing to look for
-
- if(!stop_str_len)
- return NULL;
-
- size_t lpszBuffer_len = 256;
- char *lpszBuffer = DAP_NEW_Z_SIZE(char, lpszBuffer_len);
- // received string will not be larger than MAX_REPLY_LEN
-
- while( 1 ) //nRecv < MAX_REPLY_LEN)
- {
- long ret = 0;
- // read one byte
-// long ret = s_recv( nSocket, (unsigned char *) (lpszBuffer + nRecv), 1, timeout);
-
- bSuccess = ReadFile( hPipe, lpszBuffer + nRecv,
- lpszBuffer_len - nRecv, (LPDWORD)&ret, NULL );
-
- //int ret = recv(nSocket,lpszBuffer+nRecv,1, 0);
- if ( ret <= 0 || !bSuccess )
- break;
-
- nRecv += ret;
- //printf("**debug** socket=%d read %d bytes '%0s'",nSocket, ret, (lpszBuffer + nRecv));
-
- while((nRecv + 1) >= (long) lpszBuffer_len)
- {
- lpszBuffer_len *= 2;
- lpszBuffer = (char*) realloc(lpszBuffer, lpszBuffer_len);
- }
-
- // search for the required string
- if(nRecv >= (long) stop_str_len) {
- // found the required string
- if(!strncasecmp(lpszBuffer + nRecv - stop_str_len, stop_str, stop_str_len)) {
- bSuccess = true;
- break;
- }
- }
- };
-
- // end reading
-
- if(bSuccess) {
- // delete the searched string
- if(del_stop_str) {
- lpszBuffer[nRecv - (long) stop_str_len] = '\0';
- if(dwLen)
- *dwLen =(int) nRecv - (int) stop_str_len;
- }
- else {
- lpszBuffer[nRecv] = '\0';
- if(dwLen)
- *dwLen = (int) nRecv;
- }
- lpszBuffer = DAP_REALLOC(lpszBuffer,(size_t) *dwLen + 1);
- return lpszBuffer;
- }
-
- // in case of an error or missing string
-
- if(dwLen)
- *dwLen = 0;
-
- free(lpszBuffer);
-
- return NULL;
-}
-
-/**
- * @brief thread_pipe_client_func
- * threading function for processing a request from a client
- * @param args
- * @return void*
- */
-static void *thread_pipe_client_func( void *args )
-{
- HANDLE hPipe = (HANDLE)args;
-
-// SOCKET newsockfd = (SOCKET) (intptr_t) args;
- if(s_debug_cli)
- log_it(L_INFO, "new connection pipe = %p", hPipe);
-
- int str_len, marker = 0;
- int timeout = 5000; // 5 sec
- int argc = 0;
-
- dap_list_t *cmd_param_list = NULL;
-
- while( 1 )
- {
- // wait data from client
-// int is_data = s_poll( newsockfd, timeout );
- // timeout
-// if(!is_data)
-// continue;
- // error (may be socket closed)
-// if(is_data < 0)
-// break;
-
-// int is_valid = is_valid_socket(newsockfd);
-// if(!is_valid)
-// {
-// break;
-// }
-
- // receiving http header
- char *str_header = p_get_next_str( hPipe, &str_len, "\r\n", true, timeout );
-
- // bad format
- if(!str_header)
- break;
-
- if ( str_header && strlen(str_header) == 0) {
- marker++;
- if(marker == 1)
- continue;
- }
-
- // filling parameters of command
- if ( marker == 1 ) {
- cmd_param_list = dap_list_append( cmd_param_list, str_header );
- //printf("g_list_append argc=%d command=%s ", argc, str_header);
- argc ++;
- }
- else
- free( str_header );
-
- if ( marker == 2 ) {
-
- dap_list_t *list = cmd_param_list;
- // form command
-
- unsigned int argc = dap_list_length( list );
- // command is found
-
- if ( argc >= 1) {
-
- int l_verbose = 0;
- char *cmd_name = list->data;
- list = dap_list_next( list );
-
- // execute command
- char *str_cmd = dap_strdup_printf( "%s", cmd_name );
- dap_chain_node_cmd_item_t *l_cmd = dap_chain_node_cli_cmd_find( cmd_name );
- int res = -1;
- char *str_reply = NULL;
-
- if ( l_cmd ) {
-
- while( list ) {
- str_cmd = dap_strdup_printf( "%s;%s", str_cmd, list->data );
- list = dap_list_next(list);
- }
-
- log_it(L_INFO, "execute command = %s", str_cmd );
- // exec command
-
- char **l_argv = dap_strsplit( str_cmd, ";", -1 );
- // Call the command function
-
- if ( l_cmd && l_argv && l_cmd->func ) {
- if (l_cmd->arg_func) {
- res = l_cmd->func_ex(argc, l_argv, l_cmd->arg_func, &str_reply);
- } else {
- res = l_cmd->func(argc, l_argv, &str_reply);
- }
- }
-
- else if ( l_cmd ) {
- log_it(L_WARNING,"NULL arguments for input for command \"%s\"", str_cmd );
- }else {
- log_it(L_WARNING,"No function for command \"%s\" but it registred?!", str_cmd );
- }
-
- // find '-verbose' command
- l_verbose = dap_chain_node_cli_find_option_val( l_argv, 1, argc, "-verbose", NULL );
- dap_strfreev( l_argv );
-
- } else {
- str_reply = dap_strdup_printf("can't recognize command = %s", str_cmd );
- log_it( L_ERROR, str_reply );
- }
-
- char *reply_body;
-
- if(l_verbose)
- reply_body = dap_strdup_printf("%d\r\nret_code: %d\r\n%s\r\n", res, res, (str_reply) ? str_reply : "");
- else
- reply_body = dap_strdup_printf("%d\r\n%s\r\n", res, (str_reply) ? str_reply : "");
-
- // return the result of the command function
- char *reply_str = dap_strdup_printf( "HTTP/1.1 200 OK\r\n"
- "Content-Length: %d\r\n\r\n"
- "%s",
- strlen(reply_body), reply_body );
-
- int ret;// = send( newsockfd, reply_str, strlen(reply_str) ,0 );
-
- WriteFile( hPipe, reply_str, strlen(reply_str), (LPDWORD)&ret, NULL );
-
- DAP_DELETE(str_reply);
- DAP_DELETE(reply_str);
- DAP_DELETE(reply_body);
-
- DAP_DELETE(str_cmd);
- }
- dap_list_free_full(cmd_param_list, free);
- break;
- }
- }
-
- // close connection
-// int cs = closesocket(newsockfd);
-
- log_it( L_INFO, "close connection pipe = %p", hPipe );
-
- FlushFileBuffers( hPipe );
- DisconnectNamedPipe( hPipe );
- CloseHandle( hPipe );
-
- return NULL;
-}
-
-
-/**
- * @brief thread_pipe_func
- * main threading server function pipe win32
- * @param args
- * @return void*
- */
-static void* thread_pipe_func( void *args )
-{
- UNUSED(args);
- BOOL fConnected = FALSE;
- pthread_t threadId;
- HANDLE hPipe = INVALID_HANDLE_VALUE;
- static const char *cPipeName = "\\\\.\\pipe\\node_cli.pipe";
-
- for (;;)
- {
-/// printf( "\nPipe Server: Main thread awaiting client connection on %s\n", lpszPipename );
-
- hPipe = CreateNamedPipe(
- cPipeName, // pipe name
- PIPE_ACCESS_DUPLEX, // read/write access
- PIPE_TYPE_MESSAGE | // message type pipe
- PIPE_READMODE_MESSAGE | // message-read mode
- PIPE_WAIT, // blocking mode
- PIPE_UNLIMITED_INSTANCES, // max. instances
- 4096, // output buffer size
- 4096, // input buffer size
- 0, // client time-out
- NULL ); // default security attribute
-
- if ( hPipe == INVALID_HANDLE_VALUE ) {
- log_it( L_ERROR, "CreateNamedPipe failed, GLE = %lu.\n", GetLastError() );
- return NULL;
- }
-
- fConnected = ConnectNamedPipe( hPipe, NULL ) ? TRUE : ( GetLastError() == ERROR_PIPE_CONNECTED );
-
- if ( fConnected )
- {
- log_it( L_INFO, "Client %p connected, creating a processing thread.\n", hPipe );
-
- pthread_create( &threadId, NULL, thread_pipe_client_func, hPipe );
- pthread_detach( threadId );
- }
- else
- CloseHandle( hPipe );
- }
-
- return NULL;
-}
-#endif
-
-
-/**
- * @brief thread_main_func
- * main threading server function
- * @param args
- * @return void*
- */
-static void* thread_main_func(void *args)
-{
- SOCKET sockfd = (SOCKET) (intptr_t) args;
- SOCKET newsockfd;
-
- log_it( L_INFO, "Server start socket = %s", dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_path") );
- // wait of clients
- while(1)
- {
- pthread_t threadId;
- struct sockaddr_in peer;
- socklen_t size = sizeof(peer);
- // received a new connection request
- if((newsockfd = accept(sockfd, (struct sockaddr*) &peer, &size)) == (SOCKET) -1) {
- log_it(L_ERROR, "new connection break newsockfd=%"DAP_FORMAT_SOCKET, newsockfd);
- break;
- }
- // create child thread for a client connection
- pthread_create(&threadId, NULL, thread_one_client_func, (void*) (intptr_t) newsockfd);
- // in order to thread not remain in state "dead" after completion
- pthread_detach(threadId);
- };
- // close connection
- int cs = closesocket(sockfd);
- log_it(L_INFO, "Exit server thread=%d socket=%"DAP_FORMAT_SOCKET, cs, sockfd);
- return NULL;
-}
-
-
-/**
- * @brief dap_chain_node_cli_set_reply_text
- * Write text to reply string
- * @param str_reply
- * @param str
- * @param ...
- */
-void dap_chain_node_cli_set_reply_text(char **str_reply, const char *str, ...)
-{
- if(str_reply) {
- if(*str_reply) {
- assert( *str_reply );
- DAP_DELETE(*str_reply);
- *str_reply = NULL;
- }
- va_list args;
- va_start(args, str);
- *str_reply = dap_strdup_vprintf(str, args); //*str_reply = dap_strdup(str);
- va_end(args);
- }
-}
-
-/**
- * @brief dap_chain_node_cli_check_option
- * @param argv
- * @param arg_start
- * @param arg_end
- * @param opt_name
- * @return
- */
-int dap_chain_node_cli_check_option( char** argv, int arg_start, int arg_end, const char *opt_name)
-{
- int arg_index = arg_start;
- const char *arg_string;
-
- while(arg_index < arg_end)
- {
- char * l_argv_cur = argv[arg_index];
- arg_string = l_argv_cur;
- // find opt_name
- if(arg_string && opt_name && arg_string[0] && opt_name[0] && !strcmp(arg_string, opt_name)) {
- return arg_index;
- }
- arg_index++;
- }
- return -1;
-}
-
-
-/**
- * @brief dap_chain_node_cli_find_option_val
- * return index of string in argv, or 0 if not found
- * @param argv
- * @param arg_start
- * @param arg_end
- * @param opt_name
- * @param opt_value
- * @return int
- */
-int dap_chain_node_cli_find_option_val( char** argv, int arg_start, int arg_end, const char *opt_name, const char **opt_value)
-{
- assert(argv);
- int arg_index = arg_start;
- const char *arg_string;
- int l_ret_pos = 0;
-
- while(arg_index < arg_end)
- {
- char * l_argv_cur = argv[arg_index];
- arg_string = l_argv_cur;
- // find opt_name
- if(arg_string && opt_name && arg_string[0] && opt_name[0] && !strcmp(arg_string, opt_name)) {
- // find opt_value
- if(opt_value) {
- arg_string = argv[++arg_index];
- if(arg_string) {
- *opt_value = arg_string;
- return arg_index;
- }
- // for case if opt_name exist without value
- else
- l_ret_pos = arg_index;
- }
- else
- // need only opt_name
- return arg_index;
- }
- arg_index++;
- }
- return l_ret_pos;
-}
-
-/**
- * @brief s_cmd_item_create
- * @param a_name
- * @param func
- * @param a_arg_func
- * @param doc
- * @param doc_ex
- * @return
- */
-void dap_chain_node_cli_cmd_item_create_ex(const char * a_name, cmdfunc_ex_t *a_func, void *a_arg_func, const char *a_doc, const char *a_doc_ex)
-{
- dap_chain_node_cmd_item_t *l_cmd_item = DAP_NEW_Z(dap_chain_node_cmd_item_t);
- dap_snprintf(l_cmd_item->name,sizeof (l_cmd_item->name),"%s",a_name);
- l_cmd_item->doc = strdup( a_doc);
- l_cmd_item->doc_ex = strdup( a_doc_ex);
- if (a_arg_func) {
- l_cmd_item->func_ex = a_func;
- l_cmd_item->arg_func = a_arg_func;
- } else {
- l_cmd_item->func = (cmdfunc_t *)(void *)a_func;
- }
- HASH_ADD_STR(s_commands,name,l_cmd_item);
- log_it(L_DEBUG,"Added command %s",l_cmd_item->name);
-}
-
-/**
- * @brief dap_chain_node_cli_cmd_item_apply_overrides
- *
- * @param a_name
- * @param a_overrides
- */
-void dap_chain_node_cli_cmd_item_apply_overrides(const char * a_name, const dap_chain_node_cmd_item_func_overrides_t * a_overrides){
- dap_chain_node_cmd_item_t *l_cmd_item = dap_chain_node_cli_cmd_find(a_name);
- if(l_cmd_item)
- l_cmd_item->overrides = *a_overrides;
-}
-
-/**
- * @brief dap_chain_node_cli_command_get_first
- * @return
- */
-dap_chain_node_cmd_item_t* dap_chain_node_cli_cmd_get_first()
-{
- return s_commands;
-}
-
-/**
- * @brief dap_chain_node_cli_command_find
- * @param a_name
- * @return
- */
-dap_chain_node_cmd_item_t* dap_chain_node_cli_cmd_find(const char *a_name)
-{
- dap_chain_node_cmd_item_t *l_cmd_item = NULL;
- HASH_FIND_STR(s_commands,a_name,l_cmd_item);
- return l_cmd_item;
-}
-
+static bool s_debug_cli = false;
/**
* @brief dap_chain_node_cli_init
@@ -882,16 +62,6 @@ dap_chain_node_cmd_item_t* dap_chain_node_cli_cmd_find(const char *a_name)
int dap_chain_node_cli_init(dap_config_t * g_config)
{
s_debug_cli = dap_config_get_item_bool_default(g_config,"conserver","debug_cli",false);
-#ifndef _WIN32
- struct sockaddr_un l_server_addr={0};
- l_server_addr.sun_family = AF_UNIX;
- snprintf(l_server_addr.sun_path,sizeof(l_server_addr.sun_path), "%s", dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_path") );
-#else
- pthread_t threadId;
-#endif
-
- struct sockaddr_in server_addr;
- SOCKET sockfd = -1;
bool l_conserver_enabled = dap_config_get_item_bool_default( g_config, "conserver", "enabled", true );
@@ -909,17 +79,26 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
return 2;
}
#endif
+ uint16_t l_listen_port = dap_config_get_item_uint16_default( g_config, "conserver", "listen_port_tcp",0); // For backward compatibility
+ if(l_listen_port == 0)
+ l_listen_port = dap_config_get_item_uint16_default( g_config, "conserver", "listen_port",0);
+
+ dap_cli_server_init( s_debug_cli,
+ l_listen_port ? dap_config_get_item_str(g_config, "conserver", "listen_address")
+ : dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_path"),
+ l_listen_port, dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_permissions")
+ );
- dap_chain_node_cli_cmd_item_create("global_db", com_global_db, "Work with global database",
+ dap_cli_server_cmd_add("global_db", com_global_db, "Work with global database",
"global_db cells add -cell <cell id> \n"
"global_db flush \n\n"
// "global_db wallet_info set -addr <wallet address> -cell <cell id> \n\n"
);
- dap_chain_node_cli_cmd_item_create("mempool", com_signer, "Sign operations",
+ dap_cli_server_cmd_add("mempool", com_signer, "Sign operations",
"mempool sign -cert <cert name> -net <net name> -chain <chain name> -file <filename> [-mime {<SIGNER_FILENAME,SIGNER_FILENAME_SHORT,SIGNER_FILESIZE,SIGNER_DATE,SIGNER_MIME_MAGIC> | <SIGNER_ALL_FLAGS>}]\n"
"mempool check -cert <cert name> -net <net name> {-file <filename> | -hash <hash>} [-mime {<SIGNER_FILENAME,SIGNER_FILENAME_SHORT,SIGNER_FILESIZE,SIGNER_DATE,SIGNER_MIME_MAGIC> | <SIGNER_ALL_FLAGS>}]\n"
);
- dap_chain_node_cli_cmd_item_create("node", com_node, "Work with node",
+ dap_cli_server_cmd_add("node", com_node, "Work with node",
"node add -net <net name> {-addr <node address> | -alias <node alias>} -port <port> -cell <cell id> {-ipv4 <ipv4 external address> | -ipv6 <ipv6 external address>}\n\n"
"node del -net <net name> {-addr <node address> | -alias <node alias>}\n\n"
"node link {add | del} -net <net name> {-addr <node address> | -alias <node alias>} -link <node address>\n\n"
@@ -928,30 +107,30 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"node handshake -net <net name> {-addr <node address> | -alias <node alias>}\n"
"node dump -net <net name> [ -addr <node address> | -alias <node alias>] [-full]\n\n"
);
- dap_chain_node_cli_cmd_item_create ("ping", com_ping, "Send ICMP ECHO_REQUEST to network hosts",
+ dap_cli_server_cmd_add ("ping", com_ping, "Send ICMP ECHO_REQUEST to network hosts",
"ping [-c <count>] host\n");
- dap_chain_node_cli_cmd_item_create ("traceroute", com_traceroute, "Print the hops and time of packets trace to network host",
+ dap_cli_server_cmd_add ("traceroute", com_traceroute, "Print the hops and time of packets trace to network host",
"traceroute host\n");
- dap_chain_node_cli_cmd_item_create ("tracepath", com_tracepath,"Traces path to a network host along this path",
+ dap_cli_server_cmd_add ("tracepath", com_tracepath,"Traces path to a network host along this path",
"tracepath host\n");
- dap_chain_node_cli_cmd_item_create ("version", com_version, "Return software version",
+ dap_cli_server_cmd_add ("version", com_version, "Return software version",
"version\n"
"\tReturn version number\n"
);
- dap_chain_node_cli_cmd_item_create ("help", com_help, "Description of command parameters",
+ dap_cli_server_cmd_add ("help", com_help, "Description of command parameters",
"help [<command>]\n"
"\tObtain help for <command> or get the total list of the commands\n"
);
- dap_chain_node_cli_cmd_item_create ("?", com_help, "Synonym for \"help\"",
+ dap_cli_server_cmd_add ("?", com_help, "Synonym for \"help\"",
"? [<command>]\n"
"\tObtain help for <command> or get the total list of the commands\n"
);
- dap_chain_node_cli_cmd_item_create("wallet", com_tx_wallet, "Wallet operations",
+ dap_cli_server_cmd_add("wallet", com_tx_wallet, "Wallet operations",
"wallet {new -w <wallet_name> [-sign <sign_type>] [-restore <hex value>] [-net <net_name>] [-force]| list | info {-addr <addr> | -w <wallet_name>} -net <net_name>}\n");
// Token commands
- dap_chain_node_cli_cmd_item_create ("token_update", com_token_update, "Token update",
+ dap_cli_server_cmd_add ("token_update", com_token_update, "Token update",
"\nPrivate token update\n"
"token_update -net <net name> -chain <chain name> -token <token ticker> [-type private] [-<Param name 1> <Param Value 1>] [-Param name 2> <Param Value 2>] ...[-<Param Name N> <Param Value N>]\n"
"\t Update private token <token ticker> for <netname>:<chain name> with"
@@ -1001,7 +180,7 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"\n"
);
// Token commands
- dap_chain_node_cli_cmd_item_create ("token_decl", com_token_decl, "Token declaration",
+ dap_cli_server_cmd_add ("token_decl", com_token_decl, "Token declaration",
"Simple token declaration:\n"
"\t token_decl -net <net name> -chain <chain name> -token <token ticker> -total_supply <total supply> -signs_total <sign total> -signs_emission <signs for emission> -certs <certs list>\n"
"\t Declare new simple token for <netname>:<chain name> with ticker <token ticker>, maximum emission <total supply> and <signs for emission> from <signs total> signatures on valid emission\n"
@@ -1047,52 +226,52 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"\n"
);
- dap_chain_node_cli_cmd_item_create ("token_decl_sign", com_token_decl_sign, "Token declaration add sign",
+ dap_cli_server_cmd_add ("token_decl_sign", com_token_decl_sign, "Token declaration add sign",
"token_decl_sign -net <net name> -chain <chain name> -datum <datum_hash> -certs <certs list>\n"
"\t Sign existent <datum hash> in mempool with <certs list>\n"
);
- dap_chain_node_cli_cmd_item_create ("token_emit", com_token_emit, "Token emission",
+ dap_cli_server_cmd_add ("token_emit", com_token_emit, "Token emission",
"token_emit {sign | -token <token ticker> -emission_value <val>} -net <net name> [-chain_emission <chain for emission>] [-chain_base_tx <chain for base tx> -addr <addr>] -certs <cert list>\n");
- dap_chain_node_cli_cmd_item_create ("mempool_list", com_mempool_list, "List mempool entries for selected chain network",
+ dap_cli_server_cmd_add ("mempool_list", com_mempool_list, "List mempool entries for selected chain network",
"mempool_list -net <net name>\n");
- dap_chain_node_cli_cmd_item_create ("mempool_proc", com_mempool_proc, "Proc mempool entrie with specified hash for selected chain network",
+ dap_cli_server_cmd_add ("mempool_proc", com_mempool_proc, "Proc mempool entrie with specified hash for selected chain network",
"mempool_proc -net <net name> -datum <datum hash>\n");
- dap_chain_node_cli_cmd_item_create ("mempool_delete", com_mempool_delete, "Delete datum with hash <datum hash> for selected chain network",
+ dap_cli_server_cmd_add ("mempool_delete", com_mempool_delete, "Delete datum with hash <datum hash> for selected chain network",
"mempool_delete -net <net name> -datum <datum hash>\n");
- dap_chain_node_cli_cmd_item_create ("mempool_add_ca", com_mempool_add_ca,
+ dap_cli_server_cmd_add ("mempool_add_ca", com_mempool_add_ca,
"Add pubic certificate into the mempool to prepare its way to chains",
"mempool_add_ca -net <net name> [-chain <chain name>] -ca_name <Certificate name>\n");
- dap_chain_node_cli_cmd_item_create ("chain_ca_pub", com_chain_ca_pub,
+ dap_cli_server_cmd_add ("chain_ca_pub", com_chain_ca_pub,
"Add pubic certificate into the mempool to prepare its way to chains",
"chain_ca_pub -net <net name> [-chain <chain name>] -ca_name <Certificate name>\n");
- dap_chain_node_cli_cmd_item_create ("chain_ca_copy", com_chain_ca_copy,
+ dap_cli_server_cmd_add ("chain_ca_copy", com_chain_ca_copy,
"Copy pubic certificate into the mempool to prepare its way to chains",
"chain_ca_copy -net <net name> [-chain <chain name>] -ca_name <Public certificate name>\n");
// Transaction commands
- dap_chain_node_cli_cmd_item_create ("tx_create", com_tx_create, "Make transaction",
+ dap_cli_server_cmd_add ("tx_create", com_tx_create, "Make transaction",
"tx_create -net <net name> -chain <chain name> {-from_wallet <name> -token <token ticker> -value <value> -to_addr <addr> | -from_emission <emission_hash>} [-fee <addr> -value_fee <val>]\n" );
- dap_chain_node_cli_cmd_item_create ("tx_create_json", com_tx_create_json, "Make transaction",
+ dap_cli_server_cmd_add ("tx_create_json", com_tx_create_json, "Make transaction",
"tx_create_json -net <net name> -chain <chain name> -json <json file path>\n" );
- dap_chain_node_cli_cmd_item_create ("tx_cond_create", com_tx_cond_create, "Make cond transaction",
+ dap_cli_server_cmd_add ("tx_cond_create", com_tx_cond_create, "Make cond transaction",
"tx_cond_create -net <net name> -token <token ticker> -wallet <from wallet> -cert <public cert> -value <value datoshi> -unit {mb | kb | b | sec | day} -srv_uid <numeric uid>\n" );
- dap_chain_node_cli_cmd_item_create ("tx_verify", com_tx_verify, "Verifing transaction in mempool",
+ dap_cli_server_cmd_add ("tx_verify", com_tx_verify, "Verifing transaction in mempool",
"tx_verify -net <net name> -chain <chain name> -tx <tx_hash>\n" );
// Transaction history
- dap_chain_node_cli_cmd_item_create("tx_history", com_tx_history, "Transaction history (for address or by hash)",
+ dap_cli_server_cmd_add("tx_history", com_tx_history, "Transaction history (for address or by hash)",
"tx_history {-addr <addr> | -w <wallet name> | -tx <tx_hash>} -net <net name> -chain <chain name>\n");
// Ledger info
- dap_chain_node_cli_cmd_item_create("ledger", com_ledger, "Ledger information",
+ dap_cli_server_cmd_add("ledger", com_ledger, "Ledger information",
"ledger list coins -net <network name>\n"
"ledger list threshold [-hash <tx_treshold_hash>] -net <network name>\n"
"ledger list balance -net <network name>\n"
@@ -1101,152 +280,33 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"ledger tx {-addr <addr> | -w <wallet name> | -tx <tx_hash>} [-chain <chain name>] -net <network name>\n");
// Token info
- dap_chain_node_cli_cmd_item_create("token", com_token, "Token info",
+ dap_cli_server_cmd_add("token", com_token, "Token info",
"token list -net <network name>\n"
"token info -net <network name> -name <token name>\n"
"token tx [all | -addr <wallet_addr> | -wallet <wallet_name>] -name <token name> -net <network name> [-page_start <page>] [-page <page>]\n");
// Log
- dap_chain_node_cli_cmd_item_create ("print_log", com_print_log, "Print log info",
+ dap_cli_server_cmd_add ("print_log", com_print_log, "Print log info",
"print_log [ts_after <timestamp >] [limit <line numbers>]\n" );
// Statisticss
- dap_chain_node_cli_cmd_item_create("stats", com_stats, "Print statistics",
+ dap_cli_server_cmd_add("stats", com_stats, "Print statistics",
"stats cpu");
// Exit
- dap_chain_node_cli_cmd_item_create ("exit", com_exit, "Stop application and exit",
+ dap_cli_server_cmd_add ("exit", com_exit, "Stop application and exit",
"exit\n" );
// Export GDB to JSON
- dap_chain_node_cli_cmd_item_create("gdb_export", cmd_gdb_export, "Export gdb to JSON",
+ dap_cli_server_cmd_add("gdb_export", cmd_gdb_export, "Export gdb to JSON",
"gdb_export filename <filename without extension> [-groups <group names list>]");
//Import GDB from JSON
- dap_chain_node_cli_cmd_item_create("gdb_import", cmd_gdb_import, "Import gdb from JSON",
+ dap_cli_server_cmd_add("gdb_import", cmd_gdb_import, "Import gdb from JSON",
"gdb_import filename <filename without extension>");
- // create thread for waiting of clients
- pthread_t l_thread_id;
-
- l_listen_port = dap_config_get_item_uint16_default( g_config, "conserver", "listen_port_tcp",0);
-
- const char * l_listen_unix_socket_path = dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_path");
-
-
-
- const char * l_listen_unix_socket_permissions_str = dap_config_get_item_str( g_config, "conserver", "listen_unix_socket_permissions");
- mode_t l_listen_unix_socket_permissions = 0770;
-
- if ( l_listen_unix_socket_path && l_listen_unix_socket_permissions ) {
- if ( l_listen_unix_socket_permissions_str ) {
- uint16_t l_perms;
- dap_sscanf(l_listen_unix_socket_permissions_str,"%ho", &l_perms);
- l_listen_unix_socket_permissions = l_perms;
- }
- log_it( L_INFO, "Console interace on path %s (%04o) ", l_listen_unix_socket_path, l_listen_unix_socket_permissions );
-
- #ifndef _WIN32
-
- if ( server_sockfd >= 0 ) {
- dap_chain_node_cli_delete( );
- server_sockfd = 0;
- }
-
- // create socket
- sockfd = socket( AF_UNIX, SOCK_STREAM, 0 );
- if( sockfd == INVALID_SOCKET )
- return -1;
-
- //int gdsg = sizeof(struct sockaddr_un);
-
- // Creatuing directory if not created
- char * l_listen_unix_socket_path_dir = dap_path_get_dirname(l_listen_unix_socket_path);
- dap_mkdir_with_parents(l_listen_unix_socket_path_dir);
- DAP_DELETE(l_listen_unix_socket_path_dir);
-
- if ( access( l_listen_unix_socket_path , R_OK) != -1 )
- unlink( l_listen_unix_socket_path );
-
-
- // connecting the address with a socket
- if( bind(sockfd, (const struct sockaddr*) &l_server_addr, sizeof(struct sockaddr_un)) == SOCKET_ERROR) {
- // errno = EACCES 13 Permission denied
- if ( errno == EACCES ) // EACCES=13
- log_it( L_ERROR, "Server can't start(err=%d). Can't create file=%s [Permission denied]", errno,
- l_listen_unix_socket_path );
- else
- log_it( L_ERROR, "Server can't start(err=%d). May be problem with file=%s?", errno, l_listen_unix_socket_path );
- closesocket( sockfd );
- return -2;
- }
- chmod(l_listen_unix_socket_path,l_listen_unix_socket_permissions);
-
- #else
-
-// Sleep( 3000 );
-
- if( pthread_create(&threadId, NULL, thread_pipe_func, (void*) (intptr_t) sockfd) != 0 ) {
- closesocket( sockfd );
- return -7;
- }
-
- return 0;
- #endif
-
- }
- else if (l_listen_port ){
-
- const char *l_listen_addr_str = dap_config_get_item_str(g_config, "conserver", "listen_address");
-
- log_it( L_INFO, "Console interace on addr %s port %u ", l_listen_addr_str, l_listen_port );
-
- server_addr.sin_family = AF_INET;
-#ifdef _WIN32
- struct in_addr _in_addr = { { .S_addr = htonl(INADDR_LOOPBACK) } };
- server_addr.sin_addr = _in_addr;
- server_addr.sin_port = l_listen_port;
-#else
- inet_pton( AF_INET, l_listen_addr_str, &server_addr.sin_addr );
- server_addr.sin_port = htons( (uint16_t)l_listen_port );
-#endif
- // create socket
- if ( (sockfd = socket(AF_INET, SOCK_STREAM, 0)) == INVALID_SOCKET ) {
-#ifdef __WIN32
- _set_errno(WSAGetLastError());
-#endif
- log_it( L_ERROR, "Console Server: can't create socket, err %d", errno );
- return -3;
- }
-
- // connecting the address with a socket
- if ( bind(sockfd, (struct sockaddr *) &server_addr, sizeof(server_addr)) == SOCKET_ERROR ) {
-#ifdef __WIN32
- _set_errno(WSAGetLastError());
-#endif
- log_it( L_ERROR, "Console Server: can't bind socket, err %d", errno );
- closesocket( sockfd );
- return -4;
- }
- }else {
- log_it (L_INFO, "Not defined console interface");
- return 0;
- }
-
- // turn on reception of connections
- if( listen(sockfd, MAX_CONSOLE_CLIENTS) == SOCKET_ERROR )
- return -5;
-
- if( pthread_create(&l_thread_id, NULL, thread_main_func, (void*) (intptr_t) sockfd) != 0 ) {
- closesocket( sockfd );
- return -6;
- }
-
- // in order to thread not remain in state "dead" after completion
- pthread_detach( l_thread_id );
- server_sockfd = sockfd;
return 0;
}
@@ -1258,11 +318,7 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
*/
void dap_chain_node_cli_delete(void)
{
- if(server_sockfd != INVALID_SOCKET)
- closesocket(server_sockfd);
-#ifdef __WIN32
- WSACleanup();
-#endif
+ dap_cli_server_deinit();
// deinit client for handshake
dap_chain_node_client_deinit();
}
diff --git a/modules/net/dap_chain_node_cli_cmd.c b/modules/net/dap_chain_node_cli_cmd.c
index 74312a096ad4a21a00653d361d98ca6c384e3cf0..bd1f53e11786307e4478dc7f38850570feb0b37c 100644
--- a/modules/net/dap_chain_node_cli_cmd.c
+++ b/modules/net/dap_chain_node_cli_cmd.c
@@ -204,7 +204,7 @@ static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net,
char *l_key = dap_chain_node_addr_to_hash_str(a_address);
if(!l_key)
{
- dap_chain_node_cli_set_reply_text(a_str_reply, "can't calculate hash of addr");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "can't calculate hash of addr");
return NULL;
}
size_t node_info_size = 0;
@@ -213,7 +213,7 @@ static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net,
node_info = (dap_chain_node_info_t *) dap_global_db_get_sync(a_net->pub.gdb_nodes, l_key, &node_info_size, NULL, NULL);
if(!node_info) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "node not found in base");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "node not found in base");
DAP_DELETE(l_key);
return NULL;
}
@@ -221,7 +221,7 @@ static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net,
node_info->hdr.ext_port = 8079; */
size_t node_info_size_must_be = dap_chain_node_info_get_size(node_info);
if(node_info_size_must_be != node_info_size) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "node has bad size in base=%u (must be %u)", node_info_size,
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "node has bad size in base=%u (must be %u)", node_info_size,
node_info_size_must_be);
DAP_DELETE(node_info);
DAP_DELETE(l_key);
@@ -245,13 +245,13 @@ static dap_chain_node_info_t* node_info_read_and_reply(dap_chain_net_t * a_net,
static bool node_info_save_and_reply(dap_chain_net_t * a_net, dap_chain_node_info_t *a_node_info, char **str_reply)
{
if(!a_node_info || !a_node_info->hdr.address.uint64) {
- dap_chain_node_cli_set_reply_text(str_reply, "node addr not found");
+ dap_cli_server_cmd_set_reply_text(str_reply, "node addr not found");
return false;
}
char *a_key = dap_chain_node_addr_to_hash_str(&a_node_info->hdr.address);
if(!a_key)
{
- dap_chain_node_cli_set_reply_text(str_reply, "can't calculate hash for addr");
+ dap_cli_server_cmd_set_reply_text(str_reply, "can't calculate hash for addr");
return NULL;
}
//char *a_value = dap_chain_node_info_serialize(node_info, NULL);
@@ -294,11 +294,11 @@ static int node_info_add_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
{
if(!a_node_info->hdr.address.uint64) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "not found -addr parameter");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "not found -addr parameter");
return -1;
}
if(!a_cell_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "not found -cell parameter");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "not found -cell parameter");
return -1;
}
if(a_ipv4_str)
@@ -316,7 +316,7 @@ static int node_info_add_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
// add alias
if(!dap_chain_node_alias_register(a_net, a_alias_str, &a_node_info->hdr.address)) {
log_it(L_WARNING, "can't save alias %s", a_alias_str);
- dap_chain_node_cli_set_reply_text(a_str_reply, "alias '%s' can't be mapped to addr=0x%lld",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "alias '%s' can't be mapped to addr=0x%lld",
a_alias_str, a_node_info->hdr.address.uint64);
return -1;
}
@@ -325,7 +325,7 @@ static int node_info_add_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
// write to base
bool res = node_info_save_and_reply(a_net, a_node_info, a_str_reply);
if(res)
- dap_chain_node_cli_set_reply_text(a_str_reply, "node added");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "node added");
else
return -1;
if(res)
@@ -348,20 +348,20 @@ static int node_info_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
char **str_reply)
{
if(!a_node_info->hdr.address.uint64 && !alias_str) {
- dap_chain_node_cli_set_reply_text(str_reply, "addr not found");
+ dap_cli_server_cmd_set_reply_text(str_reply, "addr not found");
return -1;
}
// check, current node have this addr or no
uint64_t l_cur_addr = dap_chain_net_get_cur_node_addr_gdb_sync(a_net->pub.name);
if(l_cur_addr && l_cur_addr == a_node_info->hdr.address.uint64) {
- dap_chain_node_cli_set_reply_text(str_reply, "current node cannot be deleted");
+ dap_cli_server_cmd_set_reply_text(str_reply, "current node cannot be deleted");
return -1;
}
// find addr by alias or addr_str
dap_chain_node_addr_t *address = s_node_info_get_addr(a_net, &a_node_info->hdr.address, alias_str);
if(!address) {
- dap_chain_node_cli_set_reply_text(str_reply, "alias not found");
+ dap_cli_server_cmd_set_reply_text(str_reply, "alias not found");
return -1;
}
char *a_key = dap_chain_node_addr_to_hash_str(address);
@@ -382,15 +382,15 @@ static int node_info_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_info
dap_list_free_full(list_aliases, NULL);
}
// set text response
- dap_chain_node_cli_set_reply_text(str_reply, "node deleted");
+ dap_cli_server_cmd_set_reply_text(str_reply, "node deleted");
}
else
- dap_chain_node_cli_set_reply_text(str_reply, "node not deleted");
+ dap_cli_server_cmd_set_reply_text(str_reply, "node not deleted");
DAP_DELETE(a_key);
DAP_DELETE(address);
return l_res;
}
- dap_chain_node_cli_set_reply_text(str_reply, "addr to delete can't be defined");
+ dap_cli_server_cmd_set_reply_text(str_reply, "addr to delete can't be defined");
DAP_DELETE(address);
return -1;
}
@@ -415,11 +415,11 @@ static int link_add_or_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_in
dap_chain_node_addr_t *link, char **a_str_reply)
{
if(!a_node_info->hdr.address.uint64 && !a_alias_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "addr not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "addr not found");
return -1;
}
if(!link->uint64) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "link not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link not found");
return -1;
}
// TODO check the presence of link in the node base
@@ -431,7 +431,7 @@ static int link_add_or_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_in
// find addr by alias or addr_str
dap_chain_node_addr_t *l_address = s_node_info_get_addr(a_net, &a_node_info->hdr.address, a_alias_str);
if(!l_address) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "alias not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "alias not found");
return -1;
}
@@ -484,9 +484,9 @@ static int link_add_or_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_in
if(res) {
res_successful = true;
if(cmd_int == 1)
- dap_chain_node_cli_set_reply_text(a_str_reply, "link added");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link added");
if(cmd_int == 2)
- dap_chain_node_cli_set_reply_text(a_str_reply, "link deleted");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link deleted");
}
else {
res_successful = false;
@@ -495,15 +495,15 @@ static int link_add_or_del_with_reply(dap_chain_net_t * a_net, dap_chain_node_in
else {
if(cmd_int == 1) {
if(index_link >= 0)
- dap_chain_node_cli_set_reply_text(a_str_reply, "link not added because it is already present");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link not added because it is already present");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "link not added");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link not added");
}
if(cmd_int == 2) {
if(index_link == -1)
- dap_chain_node_cli_set_reply_text(a_str_reply, "link not deleted because not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link not deleted because not found");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "link not deleted");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "link not deleted");
}
}
@@ -539,7 +539,7 @@ static int node_info_dump_with_reply(dap_chain_net_t * a_net, dap_chain_node_add
l_addr = dap_chain_node_alias_find(a_net, a_alias);
}
if(!l_addr) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "addr not valid");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "addr not valid");
dap_string_free(l_string_reply, true);
return -1;
}
@@ -622,7 +622,7 @@ static int node_info_dump_with_reply(dap_chain_net_t * a_net, dap_chain_node_add
if(!l_nodes_count || !l_objs) {
dap_string_append_printf(l_string_reply, "No records\n");
- dap_chain_node_cli_set_reply_text(a_str_reply, l_string_reply->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_string_reply->str);
dap_string_free(l_string_reply, true);
dap_global_db_objs_delete(l_objs, l_nodes_count);
return -1;
@@ -710,7 +710,7 @@ static int node_info_dump_with_reply(dap_chain_net_t * a_net, dap_chain_node_add
}
dap_global_db_objs_delete(l_objs, l_nodes_count);
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_string_reply->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_string_reply->str);
dap_string_free(l_string_reply, true);
return l_ret;
}
@@ -733,17 +733,17 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
int arg_index = 1;
int cmd_name = CMD_NONE;
// find 'cells' as first parameter only
- if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "cells", NULL))
+ if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "cells", NULL))
cmd_name = CMD_NAME_CELL;
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "flush", NULL))
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "flush", NULL))
cmd_name = CMD_FLUSH;
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "record", NULL))
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "record", NULL))
cmd_name = CMD_RECORD;
switch (cmd_name) {
case CMD_NAME_CELL:
{
if(!arg_index || a_argc < 3) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "parameters are not valid");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "parameters are not valid");
return -1;
}
dap_chain_t * l_chain = NULL;
@@ -754,12 +754,12 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
const char *l_cell_str = NULL, *l_chain_str = NULL;
// find cell and chain
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-cell", &l_cell_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-chain", &l_chain_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-cell", &l_cell_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-chain", &l_chain_str);
// Check for chain
if(!l_chain_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s requires parameter 'chain' to be valid", a_argv[0]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s requires parameter 'chain' to be valid", a_argv[0]);
return -12;
}
@@ -768,7 +768,7 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
int cmd_num = CMD_NONE;
switch (cmd_name) {
case CMD_NAME_CELL:
- if((arg_index_n = dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "add", NULL))
+ if((arg_index_n = dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "add", NULL))
!= 0) {
cmd_num = CMD_ADD;
}
@@ -782,22 +782,22 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
// add new node to global_db
case CMD_ADD:
if(!arg_index || a_argc < 7) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameters");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameters");
return -1;
}
dap_chain_cell_t *l_cell = dap_chain_cell_create_fill(l_chain, l_cell_id);
int l_ret = dap_chain_cell_file_update(l_cell);
if(l_ret > 0)
- dap_chain_node_cli_set_reply_text(a_str_reply, "cell added successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "cell added successfully");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "can't create file for cell 0x%016X ( %s )",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "can't create file for cell 0x%016X ( %s )",
l_cell->id.uint64,l_cell->file_storage_path);
dap_chain_cell_close(l_cell);
return l_ret;
//case CMD_NONE:
default:
- dap_chain_node_cli_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
return -1;
}
}
@@ -807,22 +807,22 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
int res_flush = dap_global_db_flush_sync();
switch (res_flush) {
case 0:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Commit data base and filesystem caches to disk completed.\n\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Commit data base and filesystem caches to disk completed.\n\n");
break;
case -1:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Couldn't open db directory. Can't init cdb\n"
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Couldn't open db directory. Can't init cdb\n"
"Reboot the node.\n\n");
break;
case -2:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't init cdb\n"
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't init cdb\n"
"Reboot the node.\n\n");
break;
case -3:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't init sqlite\n"
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't init sqlite\n"
"Reboot the node.\n\n");
break;
default:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't commit data base caches to disk completed.\n"
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't commit data base caches to disk completed.\n"
"Reboot the node.\n\n");
break;
}
@@ -834,40 +834,40 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
SUMCMD_GET, SUMCMD_PIN, SUMCMD_UNPIN
};
if(!arg_index || a_argc < 3) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "parameters are not valid");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "parameters are not valid");
return -1;
}
int arg_index_n = ++arg_index;
int l_subcmd;
// Get value
- if((arg_index_n = dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "get", NULL))!= 0) {
+ if((arg_index_n = dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "get", NULL))!= 0) {
l_subcmd = SUMCMD_GET;
}
// Pin record
- else if((arg_index_n = dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "pin", NULL)) != 0) {
+ else if((arg_index_n = dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "pin", NULL)) != 0) {
l_subcmd = SUMCMD_PIN;
}
// Unpin record
- else if((arg_index_n = dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "unpin", NULL)) != 0) {
+ else if((arg_index_n = dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "unpin", NULL)) != 0) {
l_subcmd = SUMCMD_UNPIN;
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand '%s' not recognized, available subcommands are 'get', 'pin' or 'unpin'", a_argv[2]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Subcommand '%s' not recognized, available subcommands are 'get', 'pin' or 'unpin'", a_argv[2]);
return -1;
}
// read record from database
const char *l_key = NULL;
const char *l_group = NULL;
// find key and group
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-key", &l_key);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-group", &l_group);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-key", &l_key);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-group", &l_group);
size_t l_value_len = 0;
uint8_t l_flags = 0;
bool l_is_pinned = false;
dap_nanotime_t l_ts =0;
uint8_t *l_value =dap_global_db_get_sync(l_group, l_key, &l_value_len, &l_is_pinned, &l_ts);
if(!l_value || !l_value_len) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Record not found\n\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Record not found\n\n");
return -1;
}
@@ -883,7 +883,7 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
}
char *l_value_str = DAP_NEW_Z_SIZE(char, l_value_len * 2 + 2);
size_t ret = dap_bin2hex(l_value_str, l_value, l_value_len);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Record found\n"
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Record found\n"
"lenght:\t%u byte\n"
"hash:\t%s\n"
"pinned:\t%s\n"
@@ -895,14 +895,14 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
case SUMCMD_PIN: // Pin record
{
if(l_is_pinned){
- dap_chain_node_cli_set_reply_text(a_str_reply, "record already pinned");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "record already pinned");
break;
}
if(dap_global_db_set_sync( l_group, l_key, l_value, l_value_len,true ) ==0 ){
- dap_chain_node_cli_set_reply_text(a_str_reply, "record successfully pinned");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "record successfully pinned");
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "can't pin the record");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "can't pin the record");
l_ret = -2;
}
break;
@@ -910,14 +910,14 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
case SUMCMD_UNPIN: // Unpin record
{
if(!l_is_pinned) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "record already unpinned");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "record already unpinned");
break;
}
if(dap_global_db_set_sync(l_group,l_key, l_value, l_value_len, false) == 0 ) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "record successfully unpinned");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "record successfully unpinned");
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "can't unpin the record");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "can't unpin the record");
l_ret = -2;
}
break;
@@ -927,7 +927,7 @@ int com_global_db(int a_argc, char ** a_argv, char **a_str_reply)
return l_ret;
}
default:
- dap_chain_node_cli_set_reply_text(a_str_reply, "parameters are not valid");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "parameters are not valid");
return -1;
}
return -555;
@@ -943,32 +943,32 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
};
int arg_index = 1;
int cmd_num = CMD_NONE;
- if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "add", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "add", NULL)) {
cmd_num = CMD_ADD;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "del", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "del", NULL)) {
cmd_num = CMD_DEL;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "link", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "link", NULL)) {
cmd_num = CMD_LINK;
}
else
// find add parameter ('alias' or 'handshake')
- if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "handshake", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "handshake", NULL)) {
cmd_num = CMD_HANDSHAKE;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "connect", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "connect", NULL)) {
cmd_num = CMD_CONNECT;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "alias", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "alias", NULL)) {
cmd_num = CMD_ALIAS;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "dump", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "dump", NULL)) {
cmd_num = CMD_DUMP;
}
arg_index++;
if(cmd_num == CMD_NONE) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
return -1;
}
const char *l_addr_str = NULL, *l_port_str = NULL, *alias_str = NULL;
@@ -981,13 +981,13 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
return -11;
// find addr, alias
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-port", &l_port_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-alias", &alias_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-cell", &l_cell_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-ipv4", &a_ipv4_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-ipv6", &a_ipv6_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-link", &l_link_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-port", &l_port_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-alias", &alias_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-cell", &l_cell_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-ipv4", &a_ipv4_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-ipv6", &a_ipv6_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-link", &l_link_str);
// struct to write to the global db
dap_chain_node_addr_t l_node_addr = { 0 };
@@ -1023,7 +1023,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
{
case CMD_ADD:
if(!arg_index || a_argc < 8) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameters");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameters");
DAP_DELETE(l_node_info);
return -1;
}
@@ -1042,20 +1042,20 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
return l_ret;
}
case CMD_LINK:
- if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "add", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "add", NULL)) {
// handler of command 'node link add -addr <node address> -link <node address>'
int l_ret = link_add_or_del_with_reply(l_net, l_node_info, "add", alias_str, &l_link, a_str_reply);
DAP_DELETE(l_node_info);
return l_ret;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "del", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), "del", NULL)) {
// handler of command 'node link del -addr <node address> -link <node address>'
int l_ret = link_add_or_del_with_reply(l_net, l_node_info, "del", alias_str, &l_link, a_str_reply);
DAP_DELETE(l_node_info);
return l_ret;
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command not recognize, supported format:\n"
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command not recognize, supported format:\n"
"global_db node link <add|del] [-addr <node address> | -alias <node alias>] -link <node address>");
DAP_DELETE(l_node_info);
return -1;
@@ -1063,7 +1063,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
case CMD_DUMP: {
// handler of command 'node dump'
- bool l_is_full = dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-full", NULL);
+ bool l_is_full = dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-full", NULL);
return node_info_dump_with_reply(l_net, &l_node_addr, l_is_full, alias_str, a_str_reply);
}
// add alias
@@ -1074,16 +1074,16 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
if(!dap_chain_node_alias_register(l_net, alias_str, &l_node_addr))
log_it(L_WARNING, "can't save alias %s", alias_str);
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "alias mapped successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "alias mapped successfully");
}
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "alias can't be mapped because -addr is not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "alias can't be mapped because -addr is not found");
return -1;
}
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "alias can't be mapped because -alias is not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "alias can't be mapped because -alias is not found");
return -1;
}
@@ -1098,7 +1098,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
DAP_DELETE(address_tmp);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "no address found by alias");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "no address found by alias");
return -1;
}
}
@@ -1110,9 +1110,9 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_node_addr_t *l_remote_node_addr = NULL;
if(!l_node_addr.uint64) {
// check whether auto mode
- l_is_auto = dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "auto", NULL);
+ l_is_auto = dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "auto", NULL);
if(!l_is_auto) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "addr not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "addr not found");
return -1;
}
// if auto mode, then looking for the node address
@@ -1136,7 +1136,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
}
if(!l_node_addr.uint64) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "no node is available");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "no node is available");
return -1;
}
}
@@ -1151,7 +1151,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
// start connect
l_node_client = dap_chain_node_client_connect(l_net,l_remote_node_info);
if(!l_node_client) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "can't connect");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "can't connect");
DAP_DELETE(l_remote_node_info);
return -1;
}
@@ -1189,7 +1189,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
if(res) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "no response from remote node(s)");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "no response from remote node(s)");
log_it(L_WARNING, "No response from remote node(s): err code %d", res);
// clean client struct
dap_chain_node_client_close(l_node_client);
@@ -1285,7 +1285,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
if(0 == dap_stream_ch_chain_pkt_write_unsafe(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_GLOBAL_DB,
l_net->pub.id.uint64, 0, 0, &l_sync_request,
sizeof(l_sync_request))) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
// clean client struct
dap_chain_node_client_close(l_node_client);
DAP_DELETE(l_remote_node_info);
@@ -1297,7 +1297,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
// TODO add progress info to console
res = dap_chain_node_client_wait(l_node_client, NODE_CLIENT_STATE_SYNCED, timeout_ms);
if(res < 0) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error: can't sync with node "NODE_ADDR_FP_STR,
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error: can't sync with node "NODE_ADDR_FP_STR,
NODE_ADDR_FP_ARGS_S(l_node_client->remote_node_addr));
dap_chain_node_client_close(l_node_client);
DAP_DELETE(l_remote_node_info);
@@ -1325,7 +1325,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
if(0 == dap_stream_ch_chain_pkt_write_unsafe(l_ch_chain, DAP_STREAM_CH_CHAIN_PKT_TYPE_SYNC_CHAINS,
l_net->pub.id.uint64, l_chain->id.uint64, l_remote_node_info->hdr.cell_id.uint64, &l_sync_request,
sizeof(l_sync_request))) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error: Can't send sync chains request");
// clean client struct
dap_chain_node_client_close(l_node_client);
DAP_DELETE(l_remote_node_info);
@@ -1348,7 +1348,7 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
//dap_client_disconnect(l_node_client->client);
//l_node_client->client = NULL;
dap_chain_node_client_close(l_node_client);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Node sync completed: Chains and gdb are synced");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Node sync completed: Chains and gdb are synced");
return 0;
}
@@ -1362,12 +1362,12 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
DAP_DELETE(address_tmp);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No address found by alias");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No address found by alias");
return -4;
}
}
if(!l_node_addr.uint64) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Addr not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Addr not found");
return -5;
}
@@ -1378,14 +1378,14 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
// start handshake
dap_chain_node_client_t *client = dap_chain_node_client_connect(l_net,node_info);
if(!client) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't connect");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't connect");
DAP_DELETE(node_info);
return -7;
}
// wait handshake
int res = dap_chain_node_client_wait(client, NODE_CLIENT_STATE_ESTABLISHED, timeout_ms);
if (res) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No response from node");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No response from node");
// clean client struct
dap_chain_node_client_close(client);
DAP_DELETE(node_info);
@@ -1399,14 +1399,14 @@ int com_node(int a_argc, char ** a_argv, char **a_str_reply)
{
case -1:
dap_chain_node_client_close(client);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Connection established, but not saved");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Connection established, but not saved");
return -9;
case -2:
dap_chain_node_client_close(client);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Connection already present");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Connection already present");
return -10;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "Connection established");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Connection established");
}
break;
}
@@ -1496,7 +1496,7 @@ int com_traceroute(int argc, char** argv, char **str_reply)
#else
UNUSED(argc);
UNUSED(argv);
- dap_chain_node_cli_set_reply_text(str_reply, "Not realized for your platform");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Not realized for your platform");
return -1;
#endif
}
@@ -1580,7 +1580,7 @@ int com_tracepath(int argc, char** argv, char **str_reply)
#else
UNUSED(argc);
UNUSED(argv);
- dap_chain_node_cli_set_reply_text(str_reply, "Not realized for your platform");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Not realized for your platform");
return -1;
#endif
}
@@ -1607,13 +1607,13 @@ int com_ping(int argc, char** argv, char **str_reply)
const char *n_str = NULL;
int argc_host = 1;
int argc_start = 1;
- argc_start = dap_chain_node_cli_find_option_val(argv, argc_start, argc, "-n", &n_str);
+ argc_start = dap_cli_server_cmd_find_option_val(argv, argc_start, argc, "-n", &n_str);
if(argc_start) {
argc_host = argc_start + 1;
n = (n_str) ? atoi(n_str) : 4;
}
else {
- argc_start = dap_chain_node_cli_find_option_val(argv, argc_start, argc, "-c", &n_str);
+ argc_start = dap_cli_server_cmd_find_option_val(argv, argc_start, argc, "-c", &n_str);
if(argc_start) {
argc_host = argc_start + 1;
n = (n_str) ? atoi(n_str) : 4;
@@ -1653,7 +1653,7 @@ int com_ping(int argc, char** argv, char **str_reply)
#else
UNUSED(argc);
UNUSED(argv);
- dap_chain_node_cli_set_reply_text(str_reply, "Not realized for your platform");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Not realized for your platform");
return -1;
#endif
}
@@ -1674,7 +1674,7 @@ int com_version(int argc, char ** argv, char **str_reply)
#pragma message "[!WRN!] DAP_VERSION IS NOT DEFINED. Manual override engaged."
#define DAP_VERSION 0.9-15
#endif
- dap_chain_node_cli_set_reply_text(str_reply,
+ dap_cli_server_cmd_set_reply_text(str_reply,
"%s version %s\n", dap_get_appname(), DAP_VERSION );
return 0;
}
@@ -1693,25 +1693,25 @@ int com_help(int argc, char ** argv, char **str_reply)
{
if(argc > 1) {
log_it(L_DEBUG, "Help for command %s", argv[1]);
- dap_chain_node_cmd_item_t *l_cmd = dap_chain_node_cli_cmd_find(argv[1]);
+ dap_cli_cmd_t *l_cmd = dap_cli_server_cmd_find(argv[1]);
if(l_cmd) {
- dap_chain_node_cli_set_reply_text(str_reply, "%s:\n%s", l_cmd->doc, l_cmd->doc_ex);
+ dap_cli_server_cmd_set_reply_text(str_reply, "%s:\n%s", l_cmd->doc, l_cmd->doc_ex);
return 0;
} else {
- dap_chain_node_cli_set_reply_text(str_reply, "command \"%s\" not recognized", argv[1]);
+ dap_cli_server_cmd_set_reply_text(str_reply, "command \"%s\" not recognized", argv[1]);
}
return -1;
} else {
// TODO Read list of commands & return it
log_it(L_DEBUG, "General help requested");
dap_string_t * l_help_list_str = dap_string_new(NULL);
- dap_chain_node_cmd_item_t *l_cmd = dap_chain_node_cli_cmd_get_first();
+ dap_cli_cmd_t *l_cmd = dap_cli_server_cmd_get_first();
while(l_cmd) {
dap_string_append_printf(l_help_list_str, "%s:\t\t\t%s\n",
l_cmd->name, l_cmd->doc ? l_cmd->doc : "(undocumented command)");
- l_cmd = (dap_chain_node_cmd_item_t*) l_cmd->hh.next;
+ l_cmd = (dap_cli_cmd_t*) l_cmd->hh.next;
}
- dap_chain_node_cli_set_reply_text(str_reply,
+ dap_cli_server_cmd_set_reply_text(str_reply,
"Available commands:\n\n%s\n",
l_help_list_str->len ? l_help_list_str->str : "NO ANY COMMAND WERE DEFINED");
return 0;
@@ -1739,18 +1739,18 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
int arg_index = 1;
int cmd_num = CMD_NONE;
// find add parameter ('alias' or 'handshake')
- if(dap_chain_node_cli_find_option_val(argv, arg_index, min(argc, arg_index + 1), "new", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(argv, arg_index, min(argc, arg_index + 1), "new", NULL)) {
cmd_num = CMD_WALLET_NEW;
}
- else if(dap_chain_node_cli_find_option_val(argv, arg_index, min(argc, arg_index + 1), "list", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(argv, arg_index, min(argc, arg_index + 1), "list", NULL)) {
cmd_num = CMD_WALLET_LIST;
}
- else if(dap_chain_node_cli_find_option_val(argv, arg_index, min(argc, arg_index + 1), "info", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(argv, arg_index, min(argc, arg_index + 1), "info", NULL)) {
cmd_num = CMD_WALLET_INFO;
}
arg_index++;
if(cmd_num == CMD_NONE) {
- dap_chain_node_cli_set_reply_text(str_reply,
+ dap_cli_server_cmd_set_reply_text(str_reply,
"Format of command: wallet [new -w <wallet_name> | list | info [<-addr <addr>]|[-w <wallet_name> -net <net_name>]");
return -1;
}
@@ -1759,9 +1759,9 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
memset(&address, 0, sizeof(dap_chain_node_addr_t));
const char *l_addr_str = NULL, *l_wallet_name = NULL, *l_net_name = NULL, *l_sign_type_str = NULL, *l_restore_str = NULL;
// find wallet addr
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-addr", &l_addr_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-w", &l_wallet_name);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-net", &l_net_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-addr", &l_addr_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-w", &l_wallet_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-net", &l_net_name);
dap_chain_net_t * l_net = l_net_name ? dap_chain_net_by_name( l_net_name) : NULL;
@@ -1769,18 +1769,18 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
switch (cmd_num) {
// new wallet
case CMD_WALLET_NEW: {
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-sign", &l_sign_type_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-restore", &l_restore_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-sign", &l_sign_type_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-restore", &l_restore_str);
// rewrite existing wallet
- int l_is_force = dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-force", NULL);
+ int l_is_force = dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-force", NULL);
if(!l_wallet_name) {
- dap_chain_node_cli_set_reply_text(str_reply, "Wallet name option <-w> not defined");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Wallet name option <-w> not defined");
return -1;
}
// Check if wallet name has only digits and English letter
if (!dap_isstralnum(l_wallet_name)){
- dap_chain_node_cli_set_reply_text(str_reply, "Wallet name must contains digits and aplhabetical symbols");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Wallet name must contains digits and aplhabetical symbols");
return -1;
}
@@ -1790,7 +1790,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
FILE *l_exists = fopen(l_file_name, "rb");
DAP_DELETE(l_file_name);
if (l_exists) {
- dap_chain_node_cli_set_reply_text(str_reply, "Wallet %s already exists", l_wallet_name);
+ dap_cli_server_cmd_set_reply_text(str_reply, "Wallet %s already exists", l_wallet_name);
fclose(l_exists);
return -1;
}
@@ -1803,7 +1803,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
} else {
l_sign_type = dap_sign_type_from_str(l_sign_type_str);
if (l_sign_type.type == SIG_TYPE_NULL){
- dap_chain_node_cli_set_reply_text(str_reply, "Unknown signature type");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Unknown signature type");
return -1;
}
}
@@ -1814,7 +1814,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
if (l_sign_type.type == SIG_TYPE_TESLA)
{
- dap_chain_node_cli_set_reply_text(str_reply, "Tesla algorithm is no longer supported, please, use another variant");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Tesla algorithm is no longer supported, please, use another variant");
return -1;
}
@@ -1828,7 +1828,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
DAP_DELETE(l_seed);
l_seed = NULL;
l_seed_size = 0;
- dap_chain_node_cli_set_reply_text(str_reply, "Resrote hash is invalid, wallet is not created");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Resrote hash is invalid, wallet is not created");
return -1;
}
}
@@ -1837,7 +1837,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
l_seed, l_seed_size);
dap_chain_addr_t *l_addr = l_net? dap_chain_wallet_get_addr(l_wallet,l_net->pub.id ) : NULL;
if(!l_wallet) {
- dap_chain_node_cli_set_reply_text(str_reply, "Wallet is not created besause of internal error");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Wallet is not created besause of internal error");
return -1;
}
char *l_addr_str = l_addr? dap_chain_addr_to_str(l_addr) : NULL;
@@ -1893,12 +1893,12 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name((const char *) l_net_name);
if(!l_net_name && !l_addr ) {
- dap_chain_node_cli_set_reply_text(str_reply, "Subcommand info requires parameter '-net'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Subcommand info requires parameter '-net'");
return -1;
}
else if (! l_addr){
if((l_ledger = dap_chain_ledger_by_net_name(l_net_name)) == NULL) {
- dap_chain_node_cli_set_reply_text(str_reply, "Not found net by name '%s'", l_net_name);
+ dap_cli_server_cmd_set_reply_text(str_reply, "Not found net by name '%s'", l_net_name);
return -1;
}
}else{
@@ -1907,7 +1907,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
l_ledger = l_net->pub.ledger;
l_net_name = l_net->pub.name;
}else{
- dap_chain_node_cli_set_reply_text(str_reply, "Can't find network id 0x%08X from address %s", l_addr->net_id.uint64,
+ dap_cli_server_cmd_set_reply_text(str_reply, "Can't find network id 0x%08X from address %s", l_addr->net_id.uint64,
l_addr_str);
return -1;
@@ -1953,7 +1953,7 @@ int com_tx_wallet(int argc, char ** argv, char **str_reply)
if(l_wallet)
dap_chain_wallet_close(l_wallet);
dap_string_free(l_string_ret, true);
- dap_chain_node_cli_set_reply_text(str_reply, "Wallet not found");
+ dap_cli_server_cmd_set_reply_text(str_reply, "Wallet not found");
return -1;
}
}
@@ -1981,31 +1981,31 @@ int dap_chain_node_cli_cmd_values_parse_net_chain(int *a_arg_index, int argc, ch
// Net name
if(a_net)
- dap_chain_node_cli_find_option_val(argv, *a_arg_index, argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(argv, *a_arg_index, argc, "-net", &l_net_str);
else
return -100;
// Select network
if(!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s requires parameter '-net'", argv[0]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s requires parameter '-net'", argv[0]);
return -101;
}
if((*a_net = dap_chain_net_by_name(l_net_str)) == NULL) { // Can't find such network
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s can't find network \"%s\"", argv[0], l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s can't find network \"%s\"", argv[0], l_net_str);
char l_str_to_reply_chain[500] = {0};
char *l_str_to_reply = NULL;
dap_sprintf(l_str_to_reply_chain, "%s can't find network \"%s\"\n", argv[0], l_net_str);
l_str_to_reply = dap_strcat2(l_str_to_reply,l_str_to_reply_chain);
dap_string_t* l_net_str = dap_cli_list_net();
l_str_to_reply = dap_strcat2(l_str_to_reply,l_net_str->str);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_to_reply);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_to_reply);
return -102;
}
// Chain name
if(a_chain) {
- dap_chain_node_cli_find_option_val(argv, *a_arg_index, argc, "-chain", &l_chain_str);
+ dap_cli_server_cmd_find_option_val(argv, *a_arg_index, argc, "-chain", &l_chain_str);
// Select chain
if(l_chain_str) {
@@ -2023,7 +2023,7 @@ int dap_chain_node_cli_cmd_values_parse_net_chain(int *a_arg_index, int argc, ch
l_str_to_reply = dap_strcat2(l_str_to_reply,l_chain->name);
l_str_to_reply = dap_strcat2(l_str_to_reply,"\n");
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_to_reply);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_to_reply);
return -103;
}
}
@@ -2031,13 +2031,13 @@ int dap_chain_node_cli_cmd_values_parse_net_chain(int *a_arg_index, int argc, ch
|| !strcmp(argv[0], "token_decl_sign")) {
if ( (*a_chain = dap_chain_net_get_default_chain_by_chain_type(*a_net, CHAIN_TYPE_TOKEN)) == NULL )
{
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"%s requires parameter '-chain' or set default datum type in chain configuration file",
argv[0]);
return -104;
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s requires parameter '-chain'", argv[0]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s requires parameter '-chain'", argv[0]);
return -104;
}
}
@@ -2100,17 +2100,17 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
int arg_index = 1;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
const char * l_datum_hash_str = NULL;
// Chain name
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
if(l_datum_hash_str) {
char * l_datum_hash_hex_str = NULL;
char * l_datum_hash_base58_str = NULL;
@@ -2131,14 +2131,14 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
}
// Certificates thats will be used to sign currend datum token
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-certs", &l_certs_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-certs", &l_certs_str);
// Load certs lists
if (l_certs_str)
dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
if(!l_certs_count) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_sign command requres at least one valid certificate to sign the basic transaction of emission");
return -7;
}
@@ -2183,7 +2183,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
dap_sign_t *l_sign = (dap_sign_t *)(l_datum_token->data_n_tsd + l_tsd_size + l_signs_size);
if( dap_sign_verify(l_sign, l_datum_token, sizeof(*l_datum_token) - sizeof(uint16_t)) != 1) {
log_it(L_WARNING, "Wrong signature %zu for datum_token with key %s in mempool!", i, l_datum_hash_out_str);
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Datum %s with datum token has wrong signature %zu, break process and exit",
l_datum_hash_out_str, i);
DAP_DELETE(l_datum_token);
@@ -2226,7 +2226,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
char* l_hash_str = l_datum_hash_hex_str;
// Remove old datum from pool
if( dap_global_db_del_sync(l_gdb_group_mempool, l_hash_str ) == 0) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"datum %s is replacing the %s in datum pool",
l_key_out_str, l_datum_hash_out_str);
@@ -2235,7 +2235,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_gdb_group_mempool);
return 0;
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't remove old datum %s ( new datum %s added normaly in datum pool)",
l_datum_hash_out_str, l_key_out_str);
DAP_DELETE(l_datum);
@@ -2247,7 +2247,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_key_str);
DAP_DELETE(l_key_str_base58);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Error! datum %s produced from %s can't be placed in mempool",
l_key_out_str, l_datum_hash_out_str);
DAP_DELETE(l_datum);
@@ -2258,12 +2258,12 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
return -2;
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Error! Wrong datum type. token_decl_sign sign only token declarations datum");
return -61;
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_decl_sign can't find datum with %s hash in the mempool of %s:%s",l_datum_hash_out_str,l_net? l_net->pub.name: "<undefined>",
l_chain?l_chain->name:"<undefined>");
return -5;
@@ -2271,7 +2271,7 @@ int com_token_decl_sign(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_datum_hash_hex_str);
DAP_DELETE(l_datum_hash_base58_str);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl_sign need -datum <datum hash> argument");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl_sign need -datum <datum hash> argument");
return -2;
}
return 0;
@@ -2339,7 +2339,7 @@ int com_mempool_list(int argc, char ** argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = "hex";
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
dap_chain_node_cli_cmd_values_parse_net_chain(&arg_index, argc, argv, a_str_reply, &l_chain, &l_net);
if(!l_net)
return -1;
@@ -2359,12 +2359,12 @@ int com_mempool_list(int argc, char ** argv, char ** a_str_reply)
DL_FOREACH(l_net->pub.chains, l_chain)
s_com_mempool_list_print_for_chain(l_net, l_chain, l_str_tmp, l_hash_out_type);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp, false);
return 0;
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Error! Need both -net <network name> and -chain <chain name> params\n");
return -2;
}
@@ -2385,11 +2385,11 @@ int com_mempool_delete(int argc, char ** argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -2400,7 +2400,7 @@ int com_mempool_delete(int argc, char ** argv, char ** a_str_reply)
if(l_chain && l_net) { // UNUSED(l_net)
const char * l_datum_hash_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
if(l_datum_hash_str) {
char *l_datum_hash_hex_str;
char *l_datum_hash_base58_str;
@@ -2417,15 +2417,15 @@ int com_mempool_delete(int argc, char ** argv, char ** a_str_reply)
uint8_t *l_data_tmp = l_datum_hash_hex_str ? dap_global_db_get_sync(l_gdb_group_mempool, l_datum_hash_hex_str, NULL, NULL, NULL ) : NULL;
if(l_data_tmp && dap_global_db_del_sync(l_gdb_group_mempool, l_datum_hash_hex_str) == 0) {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s deleted", l_datum_hash_hex_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s deleted", l_datum_hash_hex_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s deleted", l_datum_hash_base58_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s deleted", l_datum_hash_base58_str);
return 0;
} else {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_hex_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_hex_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_base58_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_base58_str);
return -4;
}
DAP_DELETE(l_gdb_group_mempool);
@@ -2433,11 +2433,11 @@ int com_mempool_delete(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_datum_hash_hex_str);
DAP_DELETE(l_datum_hash_base58_str);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error! %s requires -datum <datum hash> option", argv[0]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! %s requires -datum <datum hash> option", argv[0]);
return -3;
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Error! Need both -net <network name> and -chain <chain name> params\n");
return -2;
}
@@ -2459,11 +2459,11 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -2482,13 +2482,13 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
// If full or light it doesnt work
if(dap_chain_net_get_role(l_net).enums>= NODE_ROLE_FULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Need master node role or higher for network %s to process this command", l_net->pub.name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Need master node role or higher for network %s to process this command", l_net->pub.name);
return -1;
}
const char * l_datum_hash_str = NULL;
int ret = 0;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
if(l_datum_hash_str) {
char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_new(l_chain);
dap_string_t * l_str_tmp = dap_string_new(NULL);
@@ -2515,7 +2515,7 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
size_t l_datum_size2= l_datum? dap_chain_datum_size( l_datum): 0;
if (l_datum_size != l_datum_size2 ){
ret = -8;
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error! Corrupted datum %s, size by datum headers is %zd when in mempool is only %zd bytes",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! Corrupted datum %s, size by datum headers is %zd when in mempool is only %zd bytes",
l_datum_hash_hex_str, l_datum_size2, l_datum_size);
}else{
if(l_datum) {
@@ -2549,10 +2549,10 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
}
}
dap_string_append_printf(l_str_tmp, "\n");
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp, true);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! Can't find datum %s", l_datum_hash_str);
ret = -4;
}
}
@@ -2560,7 +2560,7 @@ int com_mempool_proc(int argc, char ** argv, char ** a_str_reply)
DAP_DELETE(l_datum_hash_hex_str);
DAP_DELETE(l_datum_hash_base58_str);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Error! %s requires -datum <datum hash> option", argv[0]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Error! %s requires -datum <datum hash> option", argv[0]);
ret = -5;
}
return ret;
@@ -2633,29 +2633,29 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type, "hex") && dap_strcmp(l_hash_out_type, "base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
if (dap_chain_node_cli_cmd_values_parse_net_chain(&l_arg_index, a_argc, a_argv, a_str_reply, &l_chain, &l_net))
return -1;
// Token ticker
- l_arg_index=dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_ticker);
+ l_arg_index=dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_ticker);
// Check for ticker
if(!l_ticker) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_update requires parameter 'token'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_update requires parameter 'token'");
return -2;
}
// Token type
- l_arg_index=dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-type", &l_type_str);
+ l_arg_index=dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-type", &l_type_str);
if (l_type_str && strcmp(l_type_str, "private")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_update can't accept type \"%s\"", l_type_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_update can't accept type \"%s\"", l_type_str);
return -22;
}
@@ -2678,7 +2678,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
while (l_str_flags && *l_str_flags){
uint16_t l_flag = dap_chain_datum_token_flag_from_str(*l_str_flags);
if ( l_flag == DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED ){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
return -20;
}
l_flags |= (1<<l_flag);
@@ -2697,7 +2697,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
while (l_str_flags && *l_str_flags ){
uint16_t l_flag = dap_chain_datum_token_flag_from_str(*l_str_flags);
if ( l_flag == DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED ){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
return -20;
}
l_flags |= l_flag;
@@ -2712,7 +2712,7 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
}else if ( strcmp( a_argv[l_arg_index],"-signs" )==0){
dap_cert_parse_str_list(l_arg_param, &l_certs, &l_certs_count);
if(!l_certs_count) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_update command requres at least one valid certificate to sign the basic transaction of emission");
return -10;
}
@@ -2792,14 +2792,14 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
l_tsd_total_size+= dap_tsd_size( l_tsd);
} else if (strcmp( a_argv[l_arg_index], "-chain") && strcmp( a_argv[l_arg_index], "-net") &&
strcmp( a_argv[l_arg_index], "-token") && !strcmp( a_argv[l_arg_index], "-type")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Unknown param \"%s\"",a_argv[l_arg_index]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Unknown param \"%s\"",a_argv[l_arg_index]);
return -20;
}
l_arg_index+=2;
}
if (!l_tsd_total_size) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No valid params to update");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No valid params to update");
return -21;
}
@@ -2831,14 +2831,14 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
}break;
default:
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Unknown token type");
return -8;
}
if (l_sign_counter == 0)
{
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Token declaration failed. Successful count of certificate signing is 0");
return -9;
}
@@ -2864,9 +2864,9 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
}
if(dap_global_db_set_sync(l_gdb_group_mempool, l_key_str, l_datum, l_datum_size, true) == 0) {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s with token update %s is placed in datum pool ", l_key_str, l_ticker);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "datum %s with token update %s is placed in datum pool ", l_key_str, l_ticker);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s with token update %s is placed in datum pool ", l_key_str_base58, l_ticker);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "datum %s with token update %s is placed in datum pool ", l_key_str_base58, l_ticker);
DAP_DELETE(l_datum);
DAP_DELETE(l_datum_token_update);
DAP_DELETE(l_gdb_group_mempool);
@@ -2876,9 +2876,9 @@ int com_token_update(int a_argc, char ** a_argv, char ** a_str_reply)
}
else {
if(!dap_strcmp(l_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum tx %s is not placed in datum pool ", l_key_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "datum tx %s is not placed in datum pool ", l_key_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "datum tx %s is not placed in datum pool ", l_key_str_base58);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "datum tx %s is not placed in datum pool ", l_key_str_base58);
DAP_DELETE(l_datum);
DAP_DELETE(l_datum_token_update);
DAP_DELETE(l_gdb_group_mempool);
@@ -2961,11 +2961,11 @@ typedef struct _dap_sdk_cli_params {
int s_parse_common_token_decl_arg(int a_argc, char ** a_argv, char ** a_str_reply, dap_sdk_cli_params* l_params)
{
l_params->l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE;
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-H", &l_params->l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-H", &l_params->l_hash_out_type);
if(!l_params->l_hash_out_type)
l_params->l_hash_out_type = "hex";
if(dap_strcmp(l_params->l_hash_out_type,"hex") && dap_strcmp(l_params->l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -2981,14 +2981,14 @@ int s_parse_common_token_decl_arg(int a_argc, char ** a_argv, char ** a_str_repl
}
}
//net name
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-net", &l_params->l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-net", &l_params->l_net_str);
//chainname
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-chain", &l_params->l_chain_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-chain", &l_params->l_chain_str);
//token_ticker
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-token", &l_params->l_ticker);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-token", &l_params->l_ticker);
// Token type
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-type", &l_params->l_type_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-type", &l_params->l_type_str);
if (l_params->l_type_str) {
if (strcmp(l_params->l_type_str, "private") == 0){
@@ -3000,7 +3000,7 @@ int s_parse_common_token_decl_arg(int a_argc, char ** a_argv, char ** a_str_repl
}else if (strcmp(l_params->l_type_str, "CF20") == 0){
l_params->l_type = DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL; // 256
}else{
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Unknown token type %s was specified. Supported types:\n"
" private_simple\n"
" private\n"
@@ -3011,15 +3011,15 @@ int s_parse_common_token_decl_arg(int a_argc, char ** a_argv, char ** a_str_repl
}
// Certificates thats will be used to sign currend datum token
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-certs", &l_params->l_certs_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-certs", &l_params->l_certs_str);
// Signs number thats own emissioncan't find
const char* l_signs_total_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-signs_total", &l_signs_total_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-signs_total", &l_signs_total_str);
// Signs total
char* l_tmp = NULL;
if(l_signs_total_str){
if((l_params->l_signs_total = (uint16_t) strtol(l_signs_total_str, &l_tmp, 10)) == 0){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"'signs_total' parameter must be unsigned integer value that fits in 2 bytes");
return -8;
}
@@ -3027,43 +3027,43 @@ int s_parse_common_token_decl_arg(int a_argc, char ** a_argv, char ** a_str_repl
// Signs minimum number thats need to authorize the emission
const char* l_signs_emission_str = NULL;
l_tmp = NULL;
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-signs_emission", &l_signs_emission_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-signs_emission", &l_signs_emission_str);
if (l_signs_emission_str){
if((l_params->l_signs_emission = (uint16_t) strtol(l_signs_emission_str, &l_tmp, 10)) == 0){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_decl requires parameter 'signs_emission' to be unsigned integer value that fits in 2 bytes");
return -6;
}
}
// Total supply value
const char* l_total_supply_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-total_supply", &l_total_supply_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-total_supply", &l_total_supply_str);
if (l_total_supply_str){
l_params->l_total_supply = dap_chain_balance_scan(l_total_supply_str);
if (IS_ZERO_256(l_params->l_total_supply)){
- dap_chain_node_cli_set_reply_text(a_str_reply, "'-total_supply' must be unsigned integer value that fits in 8 bytes");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "'-total_supply' must be unsigned integer value that fits in 8 bytes");
return -4;
}
}
// Total supply value
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-decimals", &l_params->l_decimals_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-decimals", &l_params->l_decimals_str);
return 0;
}
int s_parse_additional_token_decl_arg(int a_argc, char ** a_argv, char ** a_str_reply, dap_sdk_cli_params* l_params)
{
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-flags", &l_params->ext.flags);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-total_signs_valid", &l_params->ext.total_signs_valid);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-delegated_token_from", &l_params->ext.delegated_token_from);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-datum_type_allowed", &l_params->ext.datum_type_allowed);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-datum_type_blocked", &l_params->ext.datum_type_blocked);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &l_params->ext.tx_receiver_allowed);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_receiver_blocked", &l_params->ext.tx_receiver_blocked);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_sender_allowed", &l_params->ext.tx_sender_allowed);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &l_params->ext.tx_receiver_allowed);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx_sender_blocked", &l_params->ext.tx_sender_blocked);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-flags", &l_params->ext.flags);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-total_signs_valid", &l_params->ext.total_signs_valid);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-delegated_token_from", &l_params->ext.delegated_token_from);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-datum_type_allowed", &l_params->ext.datum_type_allowed);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-datum_type_blocked", &l_params->ext.datum_type_blocked);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &l_params->ext.tx_receiver_allowed);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-tx_receiver_blocked", &l_params->ext.tx_receiver_blocked);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-tx_sender_allowed", &l_params->ext.tx_sender_allowed);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-tx_receiver_allowed", &l_params->ext.tx_receiver_allowed);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-tx_sender_blocked", &l_params->ext.tx_sender_blocked);
return 0;
}
@@ -3084,33 +3084,33 @@ int s_token_decl_check_params(int a_argc, char ** a_argv, char ** a_str_reply, d
//DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL uses decimals parameter
if (l_params->l_type == DAP_CHAIN_DATUM_TOKEN_TYPE_SIMPLE || l_params->l_type == DAP_CHAIN_DATUM_TOKEN_TYPE_PRIVATE_DECL){
if(IS_ZERO_256(l_params->l_total_supply)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter '-total_supply'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl requires parameter '-total_supply'");
return -3;
}
}
if (!l_params->l_signs_emission){
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter '-signs_emission'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl requires parameter '-signs_emission'");
return -5;
}
if (!l_params->l_signs_total){
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'signs_total'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl requires parameter 'signs_total'");
return -7;
}
if(!l_params->l_ticker){
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter '-token'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl requires parameter '-token'");
return -2;
}
// check l_decimals in CF20 token
if (l_params->l_type == DAP_CHAIN_DATUM_TOKEN_TYPE_NATIVE_DECL){
if(!l_params->l_decimals_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter '-decimals'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl requires parameter '-decimals'");
return -3;
} else if (dap_strcmp(l_params->l_decimals_str, "18")) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_decl support '-decimals' to be 18 only");
return -4;
}
@@ -3118,7 +3118,7 @@ int s_token_decl_check_params(int a_argc, char ** a_argv, char ** a_str_reply, d
// Check certs list
if(!l_params->l_certs_str){
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl requires parameter 'certs'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_decl requires parameter 'certs'");
return -9;
}
return 0;
@@ -3198,7 +3198,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// Load certs lists
dap_cert_parse_str_list(l_params->l_certs_str, &l_certs, &l_certs_count);
if(!l_certs_count){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_decl command requres at least one valid certificate to sign token");
return -10;
}
@@ -3226,7 +3226,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
while (l_str_flags && *l_str_flags){
uint16_t l_flag = dap_chain_datum_token_flag_from_str(*l_str_flags);
if (l_flag == DAP_CHAIN_DATUM_TOKEN_FLAG_UNDEFINED ){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Flag can't be \"%s\"",*l_str_flags);
return -20;
}
l_flags |= l_flag; // if we have multiple flags
@@ -3236,7 +3236,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
if (l_params->ext.delegated_token_from) {
dap_chain_datum_token_t* l_delegated_token_from;
if (NULL == (l_delegated_token_from = dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_params->ext.delegated_token_from))) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "To create a delegated token %s, can't find token by ticket %s", l_ticker, l_params->ext.delegated_token_from);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "To create a delegated token %s, can't find token by ticket %s", l_ticker, l_params->ext.delegated_token_from);
return -91;
}
dap_chain_datum_token_tsd_delegate_from_stake_lock_t l_tsd_section;
@@ -3344,7 +3344,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
l_datum_token->signs_valid = l_signs_emission;
}break;
default:
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Unknown token type");
return -8;
}
@@ -3359,7 +3359,7 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
// We skip datum creation opeartion, if count of signed certificates in s_sign_cert_in_cycle is 0.
// Usually it happen, when certificate in token_decl or token_update command doesn't contain private data or broken
if (!l_datum_token || l_datum_token->signs_total == 0){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Token declaration failed. Successful count of certificate signing is 0");
return -9;
}
@@ -3384,13 +3384,13 @@ int com_token_decl(int a_argc, char ** a_argv, char ** a_str_reply)
else
l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool_by_chain_type(l_net, CHAIN_TYPE_TOKEN);
if (!l_gdb_group_mempool) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No suitable chain for placing token datum found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No suitable chain for placing token datum found");
DAP_DELETE(l_datum);
return -10;
}
int l_ret = 0;
bool l_placed = dap_global_db_set_sync(l_gdb_group_mempool, l_key_str, l_datum, l_datum_size, true) == 0;
- dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s with token %s is%s placed in datum pool",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Datum %s with token %s is%s placed in datum pool",
l_key_str_out, l_ticker, l_placed ? "" : " not");
//additional checking for incorrect key format
if (l_key_str_out != l_key_str)
@@ -3446,11 +3446,11 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -3459,67 +3459,67 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
return -43;
}
- int no_base_tx = dap_chain_node_cli_check_option(a_argv, arg_index, a_argc, "-no_base_tx");
+ int no_base_tx = dap_cli_server_cmd_check_option(a_argv, arg_index, a_argc, "-no_base_tx");
// Token emission
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission", &l_emission_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-emission", &l_emission_hash_str);
// Emission certs
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-certs", &l_certs_str);
// Wallet address that recieves the emission
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_str);
// Token ticker
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-token", &l_ticker);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-token", &l_ticker);
if(!l_certs_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-certs'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_emit requires parameter '-certs'");
return -4;
}
dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_size);
if(!l_certs_size) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_emit command requres at least one valid certificate to sign the basic transaction of emission");
return -5;
}
const char *l_add_sign = NULL;
dap_chain_addr_t *l_addr = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, arg_index + 1, "sign", &l_add_sign);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, arg_index + 1, "sign", &l_add_sign);
if (!l_add_sign) { //Create the emission
// Emission value
- if(dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-emission_value", &str_tmp)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-emission_value", &str_tmp)) {
l_emission_value = dap_chain_balance_scan(str_tmp);
}
if (IS_ZERO_256(l_emission_value)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-emission_value'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_emit requires parameter '-emission_value'");
return -1;
}
if(!l_addr_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-addr'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_emit requires parameter '-addr'");
return -2;
}
if(!l_ticker) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-token'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_emit requires parameter '-token'");
return -3;
}
l_addr = dap_chain_addr_from_str(l_addr_str);
if(!l_addr) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "address \"%s\" is invalid", l_addr_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "address \"%s\" is invalid", l_addr_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-chain_emission", &l_chain_emission_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-chain_emission", &l_chain_emission_str);
if(l_chain_emission_str) {
if((l_chain_emission = dap_chain_net_get_chain_by_name(l_net, l_chain_emission_str)) == NULL) { // Can't find such chain
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_create requires parameter '-chain_emission' to be valid chain name in chain net %s or set default datum type in chain configuration file",
l_net->pub.name);
return -45;
@@ -3535,21 +3535,21 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
}
}
if (!l_emission){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can' find emission with hash \"%s\" for token %s on network %s",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can' find emission with hash \"%s\" for token %s on network %s",
l_emission_hash_str, l_ticker, l_net->pub.name);
return -32;
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand 'sign' recuires parameter '-emission'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Subcommand 'sign' recuires parameter '-emission'");
return -31;
}
}
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-chain_base_tx", &l_chain_base_tx_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-chain_base_tx", &l_chain_base_tx_str);
if(l_chain_base_tx_str && no_base_tx < 0) {
if((l_chain_base_tx = dap_chain_net_get_chain_by_name(l_net, l_chain_base_tx_str)) == NULL) { // Can't find such chain
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_create requires parameter '-chain_base_tx' to be valid chain name in chain net %s or set default datum type in chain configuration file", l_net->pub.name);
DAP_DEL_Z(l_addr);
return -47;
@@ -3557,14 +3557,14 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
goto CheckTicker; // --->>
} else if (no_base_tx < 0) {
if((l_chain_base_tx = dap_chain_net_get_default_chain_by_chain_type(l_net, CHAIN_TYPE_TX)) == NULL) { // Can't find such chain
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_create requires parameter '-chain_base_tx' to be valid chain name in chain net %s or set default datum type in chain configuration file", l_net->pub.name);
DAP_DEL_Z(l_addr);
return -47;
}
CheckTicker: // <<---
if(!l_ticker) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "token_emit requires parameter '-token'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "token_emit requires parameter '-token'");
DAP_DEL_Z(l_addr);
return -3;
}
@@ -3574,7 +3574,7 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
if (!l_chain_emission) {
if ( (l_chain_emission = dap_chain_net_get_default_chain_by_chain_type(l_net,CHAIN_TYPE_EMISSION)) == NULL ) {
DAP_DEL_Z(l_addr);
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"token_create requires parameter '-chain_emission' to be valid chain name in chain net %s or set default datum type in chain configuration file",
l_net->pub.name);
return -50;
@@ -3633,12 +3633,12 @@ int com_token_emit(int a_argc, char ** a_argv, char ** a_str_reply)
l_addr, l_certs, l_certs_size);
char *l_tx_hash_str = l_hex_format ? dap_chain_hash_fast_to_str_new(l_datum_tx_hash)
: dap_enc_base58_encode_hash_to_str(l_datum_tx_hash);
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\nDatum %s with 256bit TX is%s placed in datum pool",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s\nDatum %s with 256bit TX is%s placed in datum pool",
str_reply_tmp, l_tx_hash_str, l_placed ? "" : " not");
DAP_DEL_Z(l_tx_hash_str);
DAP_DEL_Z(str_reply_tmp);
} else{ // if transaction was not specified when emission was added we need output only emission result
- dap_chain_node_cli_set_reply_text(a_str_reply, str_reply_tmp);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, str_reply_tmp);
}
DAP_DEL_Z(str_reply_tmp);
DAP_DEL_Z(l_addr);
@@ -3670,95 +3670,95 @@ int com_tx_cond_create(int a_argc, char ** a_argv, char **a_str_reply)
const char * l_srv_uid_str = NULL;
uint256_t l_value_datoshi = {};
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
// Token ticker
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-token", &l_token_ticker);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-token", &l_token_ticker);
// Wallet name - from
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-wallet", &l_wallet_str);
// Public certifiacte of condition owner
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-cert", &l_cert_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-cert", &l_cert_str);
// value datoshi
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-value", &l_value_datoshi_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-value", &l_value_datoshi_str);
// net
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_name);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_name);
// unit
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-unit", &l_unit_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-unit", &l_unit_str);
// service
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-srv_uid", &l_srv_uid_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-srv_uid", &l_srv_uid_str);
if(!l_token_ticker) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-token'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-token'");
return -1;
}
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-wallet'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-wallet'");
return -2;
}
if (!l_cert_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-cert'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-cert'");
return -3;
}
if(!l_value_datoshi_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-value'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-value'");
return -4;
}
if(!l_net_name) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-net'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-net'");
return -5;
}
if(!l_unit_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-unit'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-unit'");
return -6;
}
if(!l_srv_uid_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-srv_uid'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_cond_create requires parameter '-srv_uid'");
return -7;
}
dap_chain_net_srv_uid_t l_srv_uid = {};
l_srv_uid.uint64 = strtoll(l_srv_uid_str, NULL, 10);
if (!l_srv_uid.uint64) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find service UID %s ", l_srv_uid_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find service UID %s ", l_srv_uid_str);
return -8;
}
dap_chain_net_srv_price_unit_uid_t l_price_unit = dap_chain_net_srv_price_unit_uid_from_str(l_unit_str);
if(l_price_unit.enm == SERV_UNIT_UNDEFINED) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't recognize unit '%s'. Unit must look like {mb | kb | b | sec | day}",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't recognize unit '%s'. Unit must look like {mb | kb | b | sec | day}",
l_unit_str);
return -9;
}
l_value_datoshi = dap_chain_balance_scan(l_value_datoshi_str);
if(IS_ZERO_256(l_value_datoshi)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't recognize value '%s' as a number", l_value_datoshi_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't recognize value '%s' as a number", l_value_datoshi_str);
return -10;
}
dap_chain_net_t * l_net = l_net_name ? dap_chain_net_by_name(l_net_name) : NULL;
if(!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find net '%s'", l_net_name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find net '%s'", l_net_name);
return -11;
}
dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, c_wallets_path);
if(!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't open wallet '%s'", l_wallet);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't open wallet '%s'", l_wallet);
return -12;
}
dap_cert_t *l_cert_cond = dap_cert_find_by_name(l_cert_str);
if(!l_cert_cond) {
dap_chain_wallet_close(l_wallet);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find cert '%s'", l_cert_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find cert '%s'", l_cert_str);
return -13;
}
@@ -3766,7 +3766,7 @@ int com_tx_cond_create(int a_argc, char ** a_argv, char **a_str_reply)
dap_pkey_t *l_key_cond = dap_pkey_from_enc_key(l_cert_cond->enc_key);
if (!l_key_cond) {
dap_chain_wallet_close(l_wallet);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Cert '%s' doesn't contain a valid public key", l_cert_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Cert '%s' doesn't contain a valid public key", l_cert_str);
return -14;
}
@@ -3792,11 +3792,11 @@ int com_tx_cond_create(int a_argc, char ** a_argv, char **a_str_reply)
int l_ret;
// example: cond create succefully hash=0x4AA303EB7C10430C0AAC42F399D265BC7DD09E3983E088E02B8CED38DA22EDA9
if(l_hash_str){
- dap_chain_node_cli_set_reply_text(a_str_reply, "cond create succefully hash=%s\n", l_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "cond create succefully hash=%s\n", l_hash_str);
l_ret = 0;
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "cond can't create\n");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "cond can't create\n");
l_ret = -1;
}
@@ -3821,7 +3821,7 @@ int com_mempool_add_ca(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
dap_chain_t * l_chain = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-ca_name", &l_ca_name);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-ca_name", &l_ca_name);
dap_chain_node_cli_cmd_values_parse_net_chain(&arg_index,a_argc, a_argv, a_str_reply, &l_chain, &l_net);
if ( l_net == NULL ){
return -1;
@@ -3836,14 +3836,14 @@ int com_mempool_add_ca(int a_argc, char ** a_argv, char ** a_str_reply)
l_chain = dap_chain_net_get_chain_by_chain_type( l_net, CHAIN_TYPE_CA );
if (l_chain == NULL) { // If can't auto detect
// clean previous error code
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"No chains for CA datum in network \"%s\"", l_net->pub.name );
return -2;
}
}
// Check if '-ca_name' wasn't specified
if (l_ca_name == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"mempool_add_ca_public requires parameter '-ca_name' to specify the certificate name");
return -3;
}
@@ -3851,18 +3851,18 @@ int com_mempool_add_ca(int a_argc, char ** a_argv, char ** a_str_reply)
// Find certificate with specified key
dap_cert_t * l_cert = dap_cert_find_by_name( l_ca_name );
if( l_cert == NULL ){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find \"%s\" certificate", l_ca_name );
return -4;
}
if( l_cert->enc_key == NULL ){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Corrupted certificate \"%s\" without keys certificate", l_ca_name );
return -5;
}
if ( l_cert->enc_key->priv_key_data_size || l_cert->enc_key->priv_key_data){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Certificate \"%s\" has private key data. Please export public only key certificate without private keys", l_ca_name );
return -6;
}
@@ -3871,7 +3871,7 @@ int com_mempool_add_ca(int a_argc, char ** a_argv, char ** a_str_reply)
uint32_t l_cert_serialized_size = 0;
byte_t * l_cert_serialized = dap_cert_mem_save( l_cert, &l_cert_serialized_size );
if( l_cert_serialized == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't serialize in memory certificate \"%s\"", l_ca_name );
return -7;
}
@@ -3879,7 +3879,7 @@ int com_mempool_add_ca(int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_datum_t * l_datum = dap_chain_datum_create( DAP_CHAIN_DATUM_CA, l_cert_serialized , l_cert_serialized_size);
DAP_DELETE( l_cert_serialized);
if( l_datum == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't produce datum from certificate \"%s\"", l_ca_name );
return -7;
}
@@ -3887,12 +3887,12 @@ int com_mempool_add_ca(int a_argc, char ** a_argv, char ** a_str_reply)
// Finaly add datum to mempool
char *l_hash_str = dap_chain_mempool_datum_add(l_datum,l_chain);
if (l_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Datum %s was successfully placed to mempool", l_hash_str);
DAP_DELETE(l_hash_str);
return 0;
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't place certificate \"%s\" to mempool", l_ca_name);
DAP_DELETE( l_datum );
return -8;
@@ -3931,19 +3931,19 @@ int com_chain_ca_pub( int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_net_t * l_net = NULL;
dap_chain_t * l_chain = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-ca_name", &l_ca_name);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-ca_name", &l_ca_name);
dap_chain_node_cli_cmd_values_parse_net_chain(&arg_index,a_argc, a_argv, a_str_reply, &l_chain, &l_net);
dap_cert_t * l_cert = dap_cert_find_by_name( l_ca_name );
if( l_cert == NULL ){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find \"%s\" certificate", l_ca_name );
return -4;
}
if( l_cert->enc_key == NULL ){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Corrupted certificate \"%s\" without keys certificate", l_ca_name );
return -5;
}
@@ -3962,12 +3962,12 @@ int com_chain_ca_pub( int a_argc, char ** a_argv, char ** a_str_reply)
uint32_t l_cert_serialized_size = 0;
byte_t * l_cert_serialized = dap_cert_mem_save( l_cert_new, &l_cert_serialized_size );
if( l_cert_serialized == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't serialize in memory certificate" );
return -7;
}
if( l_cert_serialized == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't serialize in memory certificate");
return -7;
}
@@ -3975,7 +3975,7 @@ int com_chain_ca_pub( int a_argc, char ** a_argv, char ** a_str_reply)
dap_chain_datum_t * l_datum = dap_chain_datum_create( DAP_CHAIN_DATUM_CA, l_cert_serialized , l_cert_serialized_size);
DAP_DELETE( l_cert_serialized);
if( l_datum == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't produce datum from certificate");
return -7;
}
@@ -3983,12 +3983,12 @@ int com_chain_ca_pub( int a_argc, char ** a_argv, char ** a_str_reply)
// Finaly add datum to mempool
char *l_hash_str = dap_chain_mempool_datum_add(l_datum,l_chain);
if (l_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Datum %s was successfully placed to mempool", l_hash_str);
DAP_DELETE(l_hash_str);
return 0;
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't place certificate \"%s\" to mempool", l_ca_name);
DAP_DELETE( l_datum );
return -8;
@@ -4133,22 +4133,22 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
const char *l_chain_name = NULL; // optional parameter
const char *l_json_file_path = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_name); // optional parameter
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-chain", &l_chain_name); // optional parameter
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-json", &l_json_file_path);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_name); // optional parameter
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-chain", &l_chain_name); // optional parameter
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-json", &l_json_file_path);
if(!l_json_file_path) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command requires one of parameters '-json <json file path>'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command requires one of parameters '-json <json file path>'");
return -1;
}
// Open json file
struct json_object *l_json = json_object_from_file(l_json_file_path);
if(!l_json) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't open json file: %s", json_util_get_last_err());
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't open json file: %s", json_util_get_last_err());
return -2;
}
if(!json_object_is_type(l_json, json_type_object)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Wrong json format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Wrong json format");
json_object_put(l_json);
return -3;
}
@@ -4160,14 +4160,14 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
l_net_name = json_object_get_string(l_json_net);
}
if(!l_net_name) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command requires parameter '-net' or set net in the json file");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command requires parameter '-net' or set net in the json file");
json_object_put(l_json);
return -11;
}
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_name);
if(!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Not found net by name '%s'", l_net_name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Not found net by name '%s'", l_net_name);
json_object_put(l_json);
return -12;
}
@@ -4184,7 +4184,7 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
l_chain = dap_chain_net_get_chain_by_chain_type(l_net, CHAIN_TYPE_TX);
}
if(!l_chain) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Chain name '%s' not found, try use parameter '-chain' or set chain in the json file", l_chain_name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Chain name '%s' not found, try use parameter '-chain' or set chain in the json file", l_chain_name);
json_object_put(l_json);
return -13;
}
@@ -4195,7 +4195,7 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
size_t l_items_count = json_object_array_length(l_json_items);
bool a = (l_items_count = json_object_array_length(l_json_items));
if(!l_json_items || !json_object_is_type(l_json_items, json_type_array) || !(l_items_count = json_object_array_length(l_json_items))) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Wrong json format: not found array 'items' or array is empty");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Wrong json format: not found array 'items' or array is empty");
json_object_put(l_json);
return -15;
}
@@ -4493,9 +4493,9 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
if(l_items_ready<l_items_count) {
if(!l_items_ready)
- dap_chain_node_cli_set_reply_text(a_str_reply, "No valid items found to create a transaction");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No valid items found to create a transaction");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't create transaction, because only %zu items out of %zu are valid",l_items_ready,l_items_count);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't create transaction, because only %zu items out of %zu are valid",l_items_ready,l_items_count);
DAP_DELETE(l_tx);
return -30;
}
@@ -4516,11 +4516,11 @@ int com_tx_create_json(int a_argc, char ** a_argv, char **a_str_reply)
DAP_DELETE(l_datum_tx);
DAP_DELETE(l_gdb_group_mempool_base_tx);
if(!l_placed) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't add transaction to mempool");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't add transaction to mempool");
return -90;
}
// Completed successfully
- dap_chain_node_cli_set_reply_text(a_str_reply, "Transaction with %d items created and added to mempool successfully", l_items_ready);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction with %d items created and added to mempool successfully", l_items_ready);
return l_err_code;
}
@@ -4555,82 +4555,82 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
uint256_t l_value = {};
uint256_t l_value_fee = {};
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-from_wallet", &l_from_wallet_name);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-from_emission", &l_emission_hash_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-emission_chain", &l_emission_chain_name);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-to_addr", &addr_base58_to);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-token", &l_token_ticker);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-net", &l_net_name);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-chain", &l_chain_name);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-tx_num", &l_tx_num_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-certs", &l_certs_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-from_wallet", &l_from_wallet_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-from_emission", &l_emission_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-emission_chain", &l_emission_chain_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-to_addr", &addr_base58_to);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-token", &l_token_ticker);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-net", &l_net_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-chain", &l_chain_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-tx_num", &l_tx_num_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-certs", &l_certs_str);
if(l_tx_num_str)
l_tx_num = strtoul(l_tx_num_str, NULL, 10);
- if(dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-fee", &str_tmp)) {
+ if(dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-fee", &str_tmp)) {
l_value_fee = dap_chain_balance_scan(str_tmp);
} else {
l_value_fee = dap_chain_coins_to_balance("0.1");
}
- if(dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-value", &str_tmp)) {
+ if(dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-value", &str_tmp)) {
l_value = dap_chain_balance_scan(str_tmp);
}
if(!l_from_wallet_name && !l_emission_hash_str) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires one of parameters '-from_wallet' or '-from_emission'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires one of parameters '-from_wallet' or '-from_emission'");
return -1;
}
if(!addr_base58_to) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-to_addr'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-to_addr'");
return -2;
}
if(!l_net_name) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-net'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-net'");
return -6;
}
if(!l_token_ticker) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-token'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-token'");
return -6;
}
dap_chain_net_t * l_net = dap_chain_net_by_name(l_net_name);
dap_ledger_t *l_ledger = l_net ? l_net->pub.ledger : NULL;
if(l_net == NULL || (l_ledger = dap_chain_ledger_by_net_name(l_net_name)) == NULL) {
- dap_chain_node_cli_set_reply_text(str_reply, "not found net by name '%s'", l_net_name);
+ dap_cli_server_cmd_set_reply_text(str_reply, "not found net by name '%s'", l_net_name);
return -7;
}
dap_chain_t *l_emission_chain = NULL;
if (l_emission_hash_str) {
if (dap_chain_hash_fast_from_str(l_emission_hash_str, &l_emission_hash)) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-from_emission' "
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-from_emission' "
"to be valid string containing hash in hex or base58 format");
return -3;
}
if (!l_emission_chain_name ||
(l_emission_chain = dap_chain_net_get_chain_by_name(l_net, l_emission_chain_name)) == NULL) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-emission_chain' "
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-emission_chain' "
"to be a valid chain name");
return -9;
}
if(!l_certs_str) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-certs'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-certs'");
return -4;
}
dap_cert_parse_str_list(l_certs_str, &l_certs, &l_certs_count);
if(!l_certs_count) {
- dap_chain_node_cli_set_reply_text(str_reply,
+ dap_cli_server_cmd_set_reply_text(str_reply,
"tx_create requires at least one valid certificate to sign the basic transaction of emission");
return -5;
}
}
if(IS_ZERO_256(l_value)) {
- dap_chain_node_cli_set_reply_text(str_reply, "tx_create requires parameter '-value' to be valid uint256 value");
+ dap_cli_server_cmd_set_reply_text(str_reply, "tx_create requires parameter '-value' to be valid uint256 value");
return -4;
}
if (IS_ZERO_256(l_value_fee)) {
- dap_chain_node_cli_set_reply_text(str_reply,
+ dap_cli_server_cmd_set_reply_text(str_reply,
"tx_create requires parameter '-value_fee' to be valid uint256");
return -5;
}
@@ -4643,14 +4643,14 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
}
if(!l_chain) {
- dap_chain_node_cli_set_reply_text(str_reply, "not found chain name '%s', try use parameter '-chain' or set default datum type in chain configuration file",
+ dap_cli_server_cmd_set_reply_text(str_reply, "not found chain name '%s', try use parameter '-chain' or set default datum type in chain configuration file",
l_chain_name);
return -8;
}
dap_chain_addr_t *l_addr_to = dap_chain_addr_from_str(addr_base58_to);
if(!l_addr_to) {
- dap_chain_node_cli_set_reply_text(str_reply, "destination address is invalid");
+ dap_cli_server_cmd_set_reply_text(str_reply, "destination address is invalid");
return -11;
}
@@ -4668,7 +4668,7 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
dap_string_append_printf(string_ret, "transfer=False\n");
res = -15;
}
- dap_chain_node_cli_set_reply_text(str_reply, string_ret->str);
+ dap_cli_server_cmd_set_reply_text(str_reply, string_ret->str);
dap_string_free(string_ret, false);
DAP_DELETE(l_addr_to);
return res;
@@ -4678,19 +4678,19 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
dap_chain_wallet_t * l_wallet = dap_chain_wallet_open(l_from_wallet_name, c_wallets_path);
if(!l_wallet) {
- dap_chain_node_cli_set_reply_text(str_reply, "wallet %s does not exist", l_from_wallet_name);
+ dap_cli_server_cmd_set_reply_text(str_reply, "wallet %s does not exist", l_from_wallet_name);
return -9;
}
const dap_chain_addr_t *addr_from = (const dap_chain_addr_t *) dap_chain_wallet_get_addr(l_wallet, l_net->pub.id);
if(!addr_from) {
- dap_chain_node_cli_set_reply_text(str_reply, "source address is invalid");
+ dap_cli_server_cmd_set_reply_text(str_reply, "source address is invalid");
return -10;
}
// Check, if network ID is same as ID in destination wallet address. If not - operation is cancelled.
if (l_addr_to->net_id.uint64 != l_net->pub.id.uint64) {
- dap_chain_node_cli_set_reply_text(str_reply, "destination wallet network ID=0x%llx and network ID=0x%llx is not equal. Please, change network name or wallet address",
+ dap_cli_server_cmd_set_reply_text(str_reply, "destination wallet network ID=0x%llx and network ID=0x%llx is not equal. Please, change network name or wallet address",
l_addr_to->net_id.uint64, l_net->pub.id.uint64);
return -13;
}
@@ -4716,7 +4716,7 @@ int com_tx_create(int argc, char ** argv, char **str_reply)
}
- dap_chain_node_cli_set_reply_text(str_reply, string_ret->str);
+ dap_cli_server_cmd_set_reply_text(str_reply, string_ret->str);
dap_string_free(string_ret, false);
DAP_DELETE(l_addr_to);
@@ -4742,9 +4742,9 @@ int com_tx_verify(int a_argc, char **a_argv, char **a_str_reply)
dap_chain_t * l_chain = NULL;
int l_arg_index = 1;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
if(!l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_verify requires parameter '-tx'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_verify requires parameter '-tx'");
return -1;
}
dap_chain_node_cli_cmd_values_parse_net_chain(&l_arg_index, a_argc, a_argv, a_str_reply, &l_chain, &l_net);
@@ -4759,7 +4759,7 @@ int com_tx_verify(int a_argc, char **a_argv, char **a_str_reply)
if (dap_chain_hash_fast_from_hex_str(l_tx_hash_str, &l_tx_hash)) {
l_hex_str_from58 = dap_enc_base58_to_hex_str_from_str(l_tx_hash_str);
if (dap_chain_hash_fast_from_hex_str(l_hex_str_from58, &l_tx_hash)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid tx hash format, need hex or base58");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid tx hash format, need hex or base58");
return -3;
}
}
@@ -4769,15 +4769,15 @@ int com_tx_verify(int a_argc, char **a_argv, char **a_str_reply)
dap_global_db_get_sync(l_gdb_group, l_hex_str_from58 ? l_hex_str_from58 : l_tx_hash_str, &l_tx_size, NULL, NULL );
DAP_DEL_Z(l_hex_str_from58);
if (!l_tx) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified tx not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified tx not found");
return -3;
}
int l_ret = dap_chain_ledger_tx_add_check(l_net->pub.ledger, l_tx);
if (l_ret) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified tx verify fail with return code=%d", l_ret);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified tx verify fail with return code=%d", l_ret);
return -4;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified tx verified successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified tx verified successfully");
return 0;
}
@@ -4804,32 +4804,32 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_base58);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-w", &l_wallet_name);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-chain", &l_chain_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-tx", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-addr", &l_addr_base58);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-w", &l_wallet_name);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-chain", &l_chain_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-tx", &l_tx_hash_str);
if(!l_addr_base58 && !l_wallet_name && !l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_history requires parameter '-addr' or '-w' or '-tx'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_history requires parameter '-addr' or '-w' or '-tx'");
return -1;
}
// Select chain network
if(!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_history requires parameter '-net'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_history requires parameter '-net'");
return -2;
} else {
if((l_net = dap_chain_net_by_name(l_net_str)) == NULL) { // Can't find such network
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"tx_history requires parameter '-net' to be valid chain network name");
return -3;
}
@@ -4843,7 +4843,7 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
}
if(!l_chain) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx_history requires parameter '-chain' to be valid chain name in chain net %s. You can set default datum type in chain configuration file",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx_history requires parameter '-chain' to be valid chain name in chain net %s. You can set default datum type in chain configuration file",
l_net_str);
return -8;
}
@@ -4865,7 +4865,7 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
if(l_tx_hash_str) {
if(dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash) < 0) {
l_tx_hash_str = NULL;
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx hash not recognized");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx hash not recognized");
return -1;
}
// char hash_str[99];
@@ -4889,7 +4889,7 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
l_addr = dap_chain_addr_from_str(l_addr_base58);
}
if(!l_addr && !l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "wallet address not recognized");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "wallet address not recognized");
return -1;
}
}
@@ -4909,7 +4909,7 @@ int com_tx_history(int a_argc, char ** a_argv, char **a_str_reply)
l_str_out ? l_str_out : " empty");
DAP_DELETE(l_addr_str);
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_ret);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_ret);
DAP_DELETE(l_str_out);
DAP_DELETE(l_str_ret);
return 0;
@@ -4933,13 +4933,13 @@ int com_stats(int argc, char ** argv, char **str_reply)
int arg_index = 1;
int cmd_num = CMD_NONE;
// find add parameter ('cpu')
- if (dap_chain_node_cli_find_option_val(argv, arg_index, min(argc, arg_index + 1), "cpu", NULL)) {
+ if (dap_cli_server_cmd_find_option_val(argv, arg_index, min(argc, arg_index + 1), "cpu", NULL)) {
cmd_num = CMD_STATS_CPU;
}
switch (cmd_num) {
case CMD_NONE:
default:
- dap_chain_node_cli_set_reply_text(str_reply, "format of command: stats cpu");
+ dap_cli_server_cmd_set_reply_text(str_reply, "format of command: stats cpu");
return -1;
case CMD_STATS_CPU:
#if (defined DAP_OS_UNIX) || (defined __WIN32)
@@ -5010,28 +5010,28 @@ int com_print_log(int argc, char ** argv, char **str_reply)
const char * l_str_limit = NULL;
int64_t l_ts_after = 0;
long l_limit = 0;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "ts_after", &l_str_ts_after);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "limit", &l_str_limit);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "ts_after", &l_str_ts_after);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "limit", &l_str_limit);
l_ts_after = (l_str_ts_after) ? strtoll(l_str_ts_after, 0, 10) : -1;
l_limit = (l_str_limit) ? strtol(l_str_limit, 0, 10) : -1;
if(l_ts_after < 0 || !l_str_ts_after) {
- dap_chain_node_cli_set_reply_text(str_reply, "requires valid parameter 'l_ts_after'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "requires valid parameter 'l_ts_after'");
return -1;
}
if(!l_limit) {
- dap_chain_node_cli_set_reply_text(str_reply, "requires valid parameter 'limit'");
+ dap_cli_server_cmd_set_reply_text(str_reply, "requires valid parameter 'limit'");
return -1;
}
// get logs from list
char *l_str_ret = dap_log_get_item(l_ts_after, (int) l_limit);
if(!l_str_ret) {
- dap_chain_node_cli_set_reply_text(str_reply, "no logs");
+ dap_cli_server_cmd_set_reply_text(str_reply, "no logs");
return -1;
}
- dap_chain_node_cli_set_reply_text(str_reply, l_str_ret);
+ dap_cli_server_cmd_set_reply_text(str_reply, l_str_ret);
DAP_DELETE(l_str_ret);
return 0;
}
@@ -5049,16 +5049,16 @@ int cmd_gdb_export(int argc, char ** argv, char ** a_str_reply)
{
int arg_index = 1;
const char *l_filename = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "filename", &l_filename);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "filename", &l_filename);
if (!l_filename) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "gdb_export requires parameter 'filename'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "gdb_export requires parameter 'filename'");
return -1;
}
const char *l_db_path = dap_config_get_item_str(g_config, "resources", "dap_global_db_path");
DIR *dir = opendir(l_db_path);
if (!dir) {
log_it(L_ERROR, "Can't open db directory");
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't open db directory");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't open db directory");
return -1;
}
char l_path[MIN(strlen(l_db_path) + strlen(l_filename) + 12, MAX_PATH)];
@@ -5066,7 +5066,7 @@ int cmd_gdb_export(int argc, char ** argv, char ** a_str_reply)
dap_snprintf(l_path, sizeof(l_path), "%s/%s.json", l_db_path, l_filename);
const char *l_groups_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-groups", &l_groups_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-groups", &l_groups_str);
char *l_group_str = NULL, *l_ctx = NULL;
dap_list_t *l_parsed_groups_list = NULL;
if (l_groups_str) {
@@ -5121,7 +5121,7 @@ int cmd_gdb_export(int argc, char ** argv, char ** a_str_reply)
dap_chain_node_cli_set_reply_text (a_str_reply, "Couldn't export JSON to file, error code %d", errno );
#else
log_it(L_CRITICAL, "Couldn't export JSON to file, err '%s'", json_util_get_last_err());
- dap_chain_node_cli_set_reply_text(a_str_reply, json_util_get_last_err());
+ dap_cli_server_cmd_set_reply_text(a_str_reply, json_util_get_last_err());
#endif
json_object_put(l_json);
return -1;
@@ -5142,9 +5142,9 @@ int cmd_gdb_import(int argc, char ** argv, char ** a_str_reply)
{
int arg_index = 1;
const char *l_filename = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "filename", &l_filename);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "filename", &l_filename);
if (!l_filename) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "gdb_import requires parameter 'filename'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "gdb_import requires parameter 'filename'");
return -1;
}
const char *l_db_path = dap_config_get_item_str(g_config, "resources", "dap_global_db_path");
@@ -5158,7 +5158,7 @@ int cmd_gdb_import(int argc, char ** argv, char ** a_str_reply)
dap_chain_node_cli_set_reply_text(a_str_reply, "Import error occured: code %d",errno);
#else
log_it(L_CRITICAL, "Import error occured: %s", json_util_get_last_err());
- dap_chain_node_cli_set_reply_text(a_str_reply, json_util_get_last_err());
+ dap_cli_server_cmd_set_reply_text(a_str_reply, json_util_get_last_err());
#endif
return -1;
}
@@ -5251,14 +5251,14 @@ int com_signer(int a_argc, char **a_argv, char **a_str_reply)
size_t l_len_opts = sizeof(l_opts) / sizeof(struct opts);
for (size_t i = 0; i < l_len_opts; i++) {
- if (dap_chain_node_cli_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), l_opts[i].name, NULL)) {
+ if (dap_cli_server_cmd_find_option_val(a_argv, arg_index, min(a_argc, arg_index + 1), l_opts[i].name, NULL)) {
cmd_num = l_opts[i].cmd;
break;
}
}
if(cmd_num == CMD_NONE) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command %s not recognized", a_argv[1]);
return -1;
}
switch (cmd_num) {
@@ -5293,28 +5293,28 @@ static int s_check_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str_
char *l_str_opts_check[OPT_COUNT] = {0};
for (int i = 0; i < OPT_COUNT; i++) {
- dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, l_opts_check[i].name, (const char **) &l_str_opts_check[i]);
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, l_opts_check[i].name, (const char **) &l_str_opts_check[i]);
}
if (!l_str_opts_check[OPT_CERT]) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s need to be selected", l_opts_check[OPT_CERT].name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s need to be selected", l_opts_check[OPT_CERT].name);
return -1;
}
if (l_str_opts_check[OPT_HASH] && l_str_opts_check[OPT_FILE]) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "you can select is only one from (file or hash)");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "you can select is only one from (file or hash)");
return -1;
}
dap_chain_net_t *l_network = dap_chain_net_by_name(l_str_opts_check[OPT_NET]);
if (!l_network) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s network not found", l_str_opts_check[OPT_NET]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s network not found", l_str_opts_check[OPT_NET]);
return -1;
}
dap_chain_t *l_chain = dap_chain_net_get_chain_by_chain_type(l_network, CHAIN_TYPE_SIGNER);
if (!l_chain) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Not found datum signer in network %s", l_str_opts_check[OPT_NET]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Not found datum signer in network %s", l_str_opts_check[OPT_NET]);
return -1;
}
int found = 0;
@@ -5326,7 +5326,7 @@ static int s_check_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str_
l_gdb_group = dap_chain_net_get_gdb_group_mempool_new(l_chain);
if (!l_gdb_group) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Not found network group for chain: %s", l_chain->name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Not found network group for chain: %s", l_chain->name);
l_ret = -1;
goto end;
}
@@ -5347,7 +5347,7 @@ static int s_check_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str_
l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_SIGNER, l_sign->pkey_n_sign, l_sign->header.sign_size);
if (!l_datum) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "not created datum");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "not created datum");
l_ret = -1;
goto end;
}
@@ -5370,7 +5370,7 @@ static int s_check_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str_
dap_hash_fast_t l_hash;
dap_hash_fast(l_datum->data, l_datum->header.data_size, &l_hash);
if (!memcmp(l_hash_tmp.raw, l_hash.raw, DAP_CHAIN_HASH_FAST_SIZE)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "found!");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "found!");
found = 1;
break;
}
@@ -5382,7 +5382,7 @@ end:
if (l_gdb_group) DAP_FREE(l_gdb_group);
if (!found) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "not found!");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "not found!");
}
return 0;
@@ -5457,24 +5457,24 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str
char *l_opts_sign[OPT_COUNT] = {0};
for (int i = 0; i < OPT_COUNT; i++) {
- dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, l_opts_signer[i].name, (const char **) &l_opts_sign[i]);
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, l_opts_signer[i].name, (const char **) &l_opts_sign[i]);
}
if (!l_opts_sign[OPT_CERT]) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s need to be selected", l_opts_signer[OPT_CERT].name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s need to be selected", l_opts_signer[OPT_CERT].name);
return -1;
}
dap_chain_net_t *l_network = dap_chain_net_by_name(l_opts_sign[OPT_NET]);
if (!l_network) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s network not found", l_opts_sign[OPT_NET]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s network not found", l_opts_sign[OPT_NET]);
return -1;
}
dap_chain_t *l_chain = dap_chain_net_get_chain_by_name(l_network, l_opts_sign[OPT_CHAIN]);
if (!l_chain) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s chain not found", l_opts_sign[OPT_CHAIN]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s chain not found", l_opts_sign[OPT_CHAIN]);
return -1;
}
@@ -5485,7 +5485,7 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str
l_ret = s_get_key_from_file(l_opts_sign[OPT_FILE], l_opts_sign[OPT_MIME], l_opts_sign[OPT_CERT], &l_sign);
if (!l_ret) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s cert not found", l_opts_sign[OPT_CERT]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s cert not found", l_opts_sign[OPT_CERT]);
l_ret = -1;
goto end;
}
@@ -5494,7 +5494,7 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str
l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_SIGNER, l_sign->pkey_n_sign, l_sign->header.sign_size);
if (!l_datum) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "not created datum");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "not created datum");
l_ret = -1;
goto end;
}
@@ -5507,7 +5507,7 @@ static int s_signer_cmd(int a_arg_index, int a_argc, char **a_argv, char **a_str
dap_hash_fast_t l_hash;
dap_hash_fast(l_datum->data, l_datum->header.data_size, &l_hash);
char *l_key_str = dap_chain_hash_fast_to_str_new(&l_hash);
- dap_chain_node_cli_set_reply_text(a_str_reply, "hash: %s", l_key_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "hash: %s", l_key_str);
DAP_FREE(l_key_str);
end:
diff --git a/modules/net/dap_chain_node_cli_cmd_tx.c b/modules/net/dap_chain_node_cli_cmd_tx.c
index 13b2a891739a2eeafdebfbe58e488098958e911a..64c836a4e759864adc0576af670708cbe06d25ae 100644
--- a/modules/net/dap_chain_node_cli_cmd_tx.c
+++ b/modules/net/dap_chain_node_cli_cmd_tx.c
@@ -778,45 +778,45 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
//switch ledger params list | tx | info
int l_cmd = CMD_NONE;
- if (dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "list", NULL)){
+ if (dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "list", NULL)){
l_cmd = CMD_LIST;
- } else if (dap_chain_node_cli_find_option_val(a_argv, 1, 2, "tx", NULL)){
+ } else if (dap_cli_server_cmd_find_option_val(a_argv, 1, 2, "tx", NULL)){
l_cmd = CMD_TX_HISTORY;
- } else if (dap_chain_node_cli_find_option_val(a_argv, 2, 3, "info", NULL))
+ } else if (dap_cli_server_cmd_find_option_val(a_argv, 2, 3, "info", NULL))
l_cmd = CMD_TX_INFO;
- bool l_is_all = dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-all", NULL);
+ bool l_is_all = dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-all", NULL);
// command tx_history
if(l_cmd == CMD_TX_HISTORY) {
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-addr", &l_addr_base58);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-w", &l_wallet_name);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-net", &l_net_str);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-chain", &l_chain_str);
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-tx", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-addr", &l_addr_base58);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-w", &l_wallet_name);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-chain", &l_chain_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-tx", &l_tx_hash_str);
dap_chain_tx_hash_processed_ht_t *l_list_tx_hash_processd = NULL;
if(!l_is_all && !l_addr_base58 && !l_wallet_name && !l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-all' or '-addr' or '-w'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command requires parameter '-all' or '-addr' or '-w'");
return -1;
}
// Select chain network
if(!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-net'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command requires parameter '-net'");
return -2;
} else {
if((l_net = dap_chain_net_by_name(l_net_str)) == NULL) { // Can't find such network
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"command requires parameter '-net' to be valid chain network name");
return -3;
}
@@ -827,7 +827,7 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
//return -4;
} else {
if((l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str)) == NULL) { // Can't find such chain
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"command requires parameter '-chain' to be valid chain name in chain net %s",
l_net_str);
return -5;
@@ -839,7 +839,7 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
if(l_tx_hash_str) {
if (dap_chain_hash_fast_from_str(l_tx_hash_str, &l_tx_hash)) {
l_tx_hash_str = NULL;
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx hash not recognized");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx hash not recognized");
return -1;
}
// char hash_str[99];
@@ -864,7 +864,7 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
l_addr = dap_chain_addr_from_str(l_addr_base58);
}
if(!l_addr && !l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "wallet address not recognized");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "wallet address not recognized");
return -1;
}
}
@@ -922,7 +922,7 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
// all chain
if(!l_chain)
dap_chain_enum_unlock();
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_ret->str);
dap_string_free(l_str_ret, true);
return 0;
}
@@ -930,41 +930,41 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
enum {SUBCMD_NONE, SUBCMD_LIST_COIN, SUB_CMD_LIST_LEDGER_THRESHOLD, SUB_CMD_LIST_LEDGER_BALANCE, SUB_CMD_LIST_LEDGER_THRESHOLD_WITH_HASH};
int l_sub_cmd = SUBCMD_NONE;
dap_chain_hash_fast_t l_tx_threshold_hash;
- if (dap_chain_node_cli_find_option_val(a_argv, 2, 3, "coins", NULL ))
+ if (dap_cli_server_cmd_find_option_val(a_argv, 2, 3, "coins", NULL ))
l_sub_cmd = SUBCMD_LIST_COIN;
- if (dap_chain_node_cli_find_option_val(a_argv, 2, 3, "balance", NULL ))
+ if (dap_cli_server_cmd_find_option_val(a_argv, 2, 3, "balance", NULL ))
l_sub_cmd = SUB_CMD_LIST_LEDGER_BALANCE;
- if (dap_chain_node_cli_find_option_val(a_argv, 2, a_argc, "threshold", NULL)){
+ if (dap_cli_server_cmd_find_option_val(a_argv, 2, a_argc, "threshold", NULL)){
l_sub_cmd = SUB_CMD_LIST_LEDGER_THRESHOLD;
const char* l_tx_threshold_hash_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, 3, a_argc, "-hash", &l_tx_threshold_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 3, a_argc, "-hash", &l_tx_threshold_hash_str);
if (l_tx_threshold_hash_str){
l_sub_cmd = SUB_CMD_LIST_LEDGER_THRESHOLD_WITH_HASH;
if (dap_chain_hash_fast_from_str(l_tx_threshold_hash_str, &l_tx_threshold_hash)){
l_tx_hash_str = NULL;
- dap_chain_node_cli_set_reply_text(a_str_reply, "tx threshold hash not recognized");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tx threshold hash not recognized");
return -1;
}
}
}
if (l_sub_cmd == SUBCMD_NONE) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'list' requires subcommands 'coins' or 'threshold'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'list' requires subcommands 'coins' or 'threshold'");
return -5;
}
- dap_chain_node_cli_find_option_val(a_argv, 0, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, 0, a_argc, "-net", &l_net_str);
if (l_net_str == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'list' requires key -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'list' requires key -net");
return -1;
}
dap_ledger_t *l_ledger = dap_chain_ledger_by_net_name(l_net_str);
if (l_ledger == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't get ledger for net %s", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't get ledger for net %s", l_net_str);
return -2;
}
if (l_sub_cmd == SUB_CMD_LIST_LEDGER_THRESHOLD){
dap_string_t *l_str_ret = dap_chain_ledger_threshold_info(l_ledger);
if (l_str_ret){
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_ret->str);
dap_string_free(l_str_ret, true);
}
@@ -973,14 +973,14 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
if (l_sub_cmd == SUB_CMD_LIST_LEDGER_THRESHOLD_WITH_HASH){
dap_string_t *l_str_ret = dap_chain_ledger_threshold_hash_info(l_ledger, &l_tx_threshold_hash);
if (l_str_ret){
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_ret->str);
dap_string_free(l_str_ret, true);
}
}
if (l_sub_cmd == SUB_CMD_LIST_LEDGER_BALANCE){
dap_string_t *l_str_ret = dap_chain_ledger_balance_info(l_ledger);
if (l_str_ret){
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_ret->str);
dap_string_free(l_str_ret, true);
}
@@ -993,49 +993,49 @@ int com_ledger(int a_argc, char ** a_argv, char **a_str_reply)
dap_string_append(l_str_ret, (char *)l_list->data);
}
dap_list_free_full(l_token_list, NULL);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_ret->str);
dap_string_free(l_str_ret, true);
return 0;
} else if (l_cmd == CMD_TX_INFO){
//GET hash
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-hash", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-hash", &l_tx_hash_str);
//get net
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
//get search type
const char *l_unspent_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-unspent", &l_unspent_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-unspent", &l_unspent_str);
//check input
if (l_tx_hash_str == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand 'info' requires key -hash");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Subcommand 'info' requires key -hash");
return -1;
}
if (l_net_str == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand 'info' requires key -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Subcommand 'info' requires key -net");
return -2;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find net %s", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find net %s", l_net_str);
return -2;
}
dap_chain_hash_fast_t *l_tx_hash = DAP_NEW(dap_chain_hash_fast_t);
if (dap_chain_hash_fast_from_str(l_tx_hash_str, l_tx_hash)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't get hash_fast from %s", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't get hash_fast from %s", l_tx_hash_str);
return -4;
}
dap_chain_datum_tx_t *l_datum_tx = dap_chain_net_get_tx_by_hash(l_net, l_tx_hash,
l_unspent_str ? TX_SEARCH_TYPE_NET_UNSPENT : TX_SEARCH_TYPE_NET);
if (l_datum_tx == NULL){
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't get datum from transaction hash %s", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't get datum from transaction hash %s", l_tx_hash_str);
return -5;
}
dap_string_t *l_str = dap_string_new("");
s_dap_chain_datum_tx_out_data(l_datum_tx, l_net->pub.ledger, l_str, l_hash_out_type, l_tx_hash);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str->str);
dap_string_free(l_str, true);
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'ledger' requires parameter 'list' or 'tx' or 'info'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'ledger' requires parameter 'list' or 'tx' or 'info'");
return -6;
}
return 0;
@@ -1060,33 +1060,33 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_tx_hash_processed_ht_t *l_list_tx_hash_processd = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "base58";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-net", &l_net_str);
// Select chain network
if(!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-net'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command requires parameter '-net'");
return -2;
} else {
if((l_net = dap_chain_net_by_name(l_net_str)) == NULL) { // Can't find such network
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"command requires parameter '-net' to be valid chain network name");
return -3;
}
}
int l_cmd = CMD_NONE;
- if (dap_chain_node_cli_find_option_val(a_argv, 1, 2, "list", NULL))
+ if (dap_cli_server_cmd_find_option_val(a_argv, 1, 2, "list", NULL))
l_cmd = CMD_LIST;
- else if (dap_chain_node_cli_find_option_val(a_argv, 1, 2, "info", NULL))
+ else if (dap_cli_server_cmd_find_option_val(a_argv, 1, 2, "info", NULL))
l_cmd = CMD_INFO;
- else if (dap_chain_node_cli_find_option_val(a_argv, 1, 2, "tx", NULL))
+ else if (dap_cli_server_cmd_find_option_val(a_argv, 1, 2, "tx", NULL))
l_cmd = CMD_TX;
// token list
if(l_cmd == CMD_LIST) {
@@ -1111,7 +1111,7 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_enum_unlock();
//total
dap_string_append_printf(l_str_out, "---------------\ntokens: %zu\n", l_token_num_total);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_out->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_out->str);
dap_string_free(l_str_out, true);
return 0;
@@ -1119,9 +1119,9 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
// token info
else if(l_cmd == CMD_INFO) {
const char *l_token_name_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-name", &l_token_name_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-name", &l_token_name_str);
if(!l_token_name_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-name' <token name>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command requires parameter '-name' <token name>");
return -4;
}
@@ -1147,7 +1147,7 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
dap_chain_enum_unlock();
if(!l_token_num_total)
dap_string_append_printf(l_str_out, "token '%s' not found\n", l_token_name_str);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_out->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_out->str);
dap_string_free(l_str_out, true);
return 0;
@@ -1160,23 +1160,23 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
int l_subcmd = CMD_NONE;
const char *l_addr_base58_str = NULL;
const char *l_wallet_name = NULL;
- if(dap_chain_node_cli_find_option_val(a_argv, 2, a_argc, "all", NULL))
+ if(dap_cli_server_cmd_find_option_val(a_argv, 2, a_argc, "all", NULL))
l_subcmd = SUBCMD_TX_ALL;
- else if(dap_chain_node_cli_find_option_val(a_argv, 2, a_argc, "-addr", &l_addr_base58_str))
+ else if(dap_cli_server_cmd_find_option_val(a_argv, 2, a_argc, "-addr", &l_addr_base58_str))
l_subcmd = SUBCMD_TX_ADDR;
- else if(dap_chain_node_cli_find_option_val(a_argv, 2, a_argc, "-wallet", &l_wallet_name))
+ else if(dap_cli_server_cmd_find_option_val(a_argv, 2, a_argc, "-wallet", &l_wallet_name))
l_subcmd = SUBCMD_TX_ADDR;
const char *l_token_name_str = NULL;
const char *l_page_start_str = NULL;
const char *l_page_size_str = NULL;
const char *l_page_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-name", &l_token_name_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-page_start", &l_page_start_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-page_size", &l_page_size_str);
- dap_chain_node_cli_find_option_val(a_argv, arg_index, a_argc, "-page", &l_page_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-name", &l_token_name_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-page_start", &l_page_start_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-page_size", &l_page_size_str);
+ dap_cli_server_cmd_find_option_val(a_argv, arg_index, a_argc, "-page", &l_page_str);
if(!l_token_name_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "command requires parameter '-name' <token name>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "command requires parameter '-name' <token name>");
return -4;
}
long l_page_start = -1;// not used if =-1
@@ -1223,7 +1223,7 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
}
dap_chain_enum_unlock();
_dap_chain_tx_hash_processed_ht_free(l_list_tx_hash_processd);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_out->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_out->str);
dap_string_free(l_str_out, true);
return 0;
}
@@ -1248,12 +1248,12 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
ffl_addr_base58 = 0;
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "wallet '%s' not found", l_wallet_name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "wallet '%s' not found", l_wallet_name);
return -2;
}
}
if(!l_addr_base58) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "address not recognized");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "address not recognized");
return -3;
}
@@ -1278,20 +1278,20 @@ int com_token(int a_argc, char ** a_argv, char **a_str_reply)
l_chain_cur = dap_chain_enum(&l_chain_tmp);
}
dap_chain_enum_unlock();
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_out->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_out->str);
dap_string_free(l_str_out, true);
DAP_DELETE(l_addr_base58);
return 0;
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply, "not found parameter '-all', '-wallet' or '-addr'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "not found parameter '-all', '-wallet' or '-addr'");
return -1;
}
return 0;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "unknown command code %d", l_cmd);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "unknown command code %d", l_cmd);
return -5;
}
diff --git a/modules/net/dap_chain_node_ping.c b/modules/net/dap_chain_node_ping.c
index c327bce946676db8cb2ce66fcc37102a72282c2b..f37d61452ea1e36eaf9a38e8ce300288bf81920c 100644
--- a/modules/net/dap_chain_node_ping.c
+++ b/modules/net/dap_chain_node_ping.c
@@ -138,7 +138,7 @@ static void* node_ping_proc(void *a_arg)
long l_recv_count = 0;
// recv data with error message
if(l_send_count > 30)
- l_recv_count = s_recv(l_socket, l_buf, l_buf_size, 1000);
+ l_recv_count = dap_net_recv(l_socket, l_buf, l_buf_size, 1000);
// connect/send/recv was successful
if(l_recv_count > 20) {
clock_gettime(CLOCK_MONOTONIC, &l_time_stop);
diff --git a/modules/net/include/dap_chain_node_cli.h b/modules/net/include/dap_chain_node_cli.h
index e247d5f3de130908083d65e7591f99561fe09ceb..14b52dc90be74173df11b54054ac930e0b2156b1 100644
--- a/modules/net/include/dap_chain_node_cli.h
+++ b/modules/net/include/dap_chain_node_cli.h
@@ -30,51 +30,7 @@
#include "dap_config.h"
#include "uthash.h"
-typedef int cmdfunc_ex_t(int argc, char ** argv, void *arg_func, char **str_reply);
-typedef int cmdfunc_t(int argc, char ** argv, char **str_reply);
-
-typedef void cmd_item_func_override_log_cmd_call(const char*);
-
-typedef struct dap_chain_node_cmd_item_func_overrides{
- /* use it if you want to prevent logging of some sensetive data */
- cmd_item_func_override_log_cmd_call * log_cmd_call;
-} dap_chain_node_cmd_item_func_overrides_t;
-
-typedef struct dap_chain_node_cmd_item{
- char name[32]; /* User printable name of the function. */
- union {
- cmdfunc_t *func; /* Function to call to do the job. */
- cmdfunc_ex_t *func_ex; /* Function with additional arg to call to do the job. */
- };
- void *arg_func; /* additional argument of function*/
- char *doc; /* Documentation for this function. */
- char *doc_ex; /* Full documentation for this function. */
- dap_chain_node_cmd_item_func_overrides_t overrides; /* Used to change default behaviour */
- UT_hash_handle hh;
-} dap_chain_node_cmd_item_t;
-
-
-// Read from socket
-long s_recv(SOCKET sd, unsigned char *buf, size_t bufsize, int timeout);
-
-/**
- * Look up NAME as the name of a command, and return a pointer to that
- * command. Return a NULL pointer if NAME isn't a command name.
- */
-dap_chain_node_cmd_item_t* dap_chain_node_cli_cmd_get_first();
-dap_chain_node_cmd_item_t* dap_chain_node_cli_cmd_find(const char *a_name);
-void dap_chain_node_cli_cmd_item_create_ex(const char * a_name, cmdfunc_ex_t *a_func, void *a_arg_func, const char *a_doc, const char *a_doc_ex);
-DAP_STATIC_INLINE void dap_chain_node_cli_cmd_item_create(const char * a_name, cmdfunc_t *a_func, const char *a_doc, const char *a_doc_ex)
-{
- dap_chain_node_cli_cmd_item_create_ex(a_name, (cmdfunc_ex_t *)(void *)a_func, NULL, a_doc, a_doc_ex);
-}
-void dap_chain_node_cli_cmd_item_apply_overrides(const char * a_name, const dap_chain_node_cmd_item_func_overrides_t * a_overrides);
-
-void dap_chain_node_cli_set_reply_text(char **str_reply, const char *str, ...);
-
-int dap_chain_node_cli_find_option_val( char** argv, int arg_start, int arg_end, const char *opt_name, const char **opt_value);
-int dap_chain_node_cli_check_option( char** argv, int arg_start, int arg_end, const char *opt_name);
-
+#include "dap_cli_server.h"
/**
* Initialization of the server side of the interaction
diff --git a/modules/net/srv/dap_chain_net_srv.c b/modules/net/srv/dap_chain_net_srv.c
index 4a4967a5843e9aaeae564cd41f3f2eee699f1d21..51c9092bcfffeeede04b39693fe04d45a837451c 100644
--- a/modules/net/srv/dap_chain_net_srv.c
+++ b/modules/net/srv/dap_chain_net_srv.c
@@ -100,7 +100,7 @@ int dap_chain_net_srv_init()
if( dap_chain_net_srv_order_init() != 0 )
return -1;
- dap_chain_node_cli_cmd_item_create ("net_srv", s_cli_net_srv, "Network services managment",
+ dap_cli_server_cmd_add ("net_srv", s_cli_net_srv, "Network services managment",
"net_srv -net <chain net name> order find [-direction {sell | buy}] [-srv_uid <Service UID>] [-price_unit <price unit>]\n"
" [-price_token <Token ticker>] [-price_min <Price minimum>] [-price_max <Price maximum>]\n"
"\tOrders list, all or by UID and/or class\n"
@@ -201,11 +201,11 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
dap_chain_net_t * l_net = NULL;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type, "hex") && dap_strcmp(l_hash_out_type, "base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -215,46 +215,46 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
dap_string_t *l_string_ret = dap_string_new("");
const char *l_order_str = NULL;
- int l_order_arg_pos = dap_chain_node_cli_find_option_val(argv, arg_index, argc, "order", &l_order_str);
+ int l_order_arg_pos = dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "order", &l_order_str);
// Order direction
const char *l_direction_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-direction", &l_direction_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-direction", &l_direction_str);
const char* l_srv_uid_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-srv_uid", &l_srv_uid_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-srv_uid", &l_srv_uid_str);
const char* l_srv_class_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-srv_class", &l_srv_class_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-srv_class", &l_srv_class_str);
const char* l_node_addr_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-node_addr", &l_node_addr_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-node_addr", &l_node_addr_str);
const char* l_tx_cond_hash_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-tx_cond", &l_tx_cond_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-tx_cond", &l_tx_cond_hash_str);
const char* l_price_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price", &l_price_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price", &l_price_str);
const char* l_expires_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-expires", &l_expires_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-expires", &l_expires_str);
const char* l_price_unit_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price_unit", &l_price_unit_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price_unit", &l_price_unit_str);
const char* l_price_token_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price_token", &l_price_token_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price_token", &l_price_token_str);
const char* l_ext = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-ext", &l_ext);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-ext", &l_ext);
const char *l_order_hash_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-hash", &l_order_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-hash", &l_order_hash_str);
const char* l_region_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-region", &l_region_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-region", &l_region_str);
const char* l_continent_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-continent", &l_continent_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-continent", &l_continent_str);
int8_t l_continent_num = dap_chain_net_srv_order_continent_to_num(l_continent_str);
@@ -335,28 +335,28 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
// Order direction
const char *l_direction_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-direction", &l_direction_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-direction", &l_direction_str);
// Select with specified service uid
const char *l_srv_uid_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-srv_uid", &l_srv_uid_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-srv_uid", &l_srv_uid_str);
// Select with specified price units
const char* l_price_unit_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price_unit", &l_price_unit_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price_unit", &l_price_unit_str);
// Token ticker
const char* l_price_token_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price_token", &l_price_token_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price_token", &l_price_token_str);
// Select with price not more than price_min
const char* l_price_min_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price_min", &l_price_min_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price_min", &l_price_min_str);
// Select with price not more than price_max
const char* l_price_max_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-price_max", &l_price_max_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-price_max", &l_price_max_str);
dap_chain_net_srv_order_direction_t l_direction = SERV_DIR_UNDEFINED;
dap_chain_net_srv_uid_t l_srv_uid={{0}};
@@ -443,7 +443,7 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
}else if( dap_strcmp( l_order_str, "delete" ) == 0 ){
// Select with specified service uid
//const char *l_order_hash_str = NULL;
- //dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-hash", &l_order_hash_str);
+ //dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-hash", &l_order_hash_str);
if ( l_order_hash_str ){
dap_chain_net_srv_order_t * l_order = dap_chain_net_srv_order_find_by_hash_str( l_net, l_order_hash_hex_str );
if (l_order && dap_chain_net_srv_order_delete_by_hash_str_sync(l_net,l_order_hash_hex_str) == 0){
@@ -466,7 +466,7 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
}
}else if( dap_strcmp( l_order_str, "create" ) == 0 ){
const char *l_order_cert_name = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-cert", &l_order_cert_name);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-cert", &l_order_cert_name);
if ( l_srv_uid_str && l_price_str && l_price_token_str && l_price_unit_str) {
dap_chain_net_srv_uid_t l_srv_uid={{0}};
dap_chain_node_addr_t l_node_addr={0};
@@ -546,9 +546,9 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
}else if( dap_strcmp( l_order_str, "static" ) == 0 ){
// find the subcommand directly after the 'order' command
- int l_subcmd_save = dap_chain_node_cli_find_option_val(argv, l_order_arg_pos + 1, l_order_arg_pos + 2, "save", NULL);
- int l_subcmd_del = dap_chain_node_cli_find_option_val(argv, l_order_arg_pos + 1, l_order_arg_pos + 2, "delete", NULL) |
- dap_chain_node_cli_find_option_val(argv, l_order_arg_pos + 1, l_order_arg_pos + 2, "del", NULL);
+ int l_subcmd_save = dap_cli_server_cmd_find_option_val(argv, l_order_arg_pos + 1, l_order_arg_pos + 2, "save", NULL);
+ int l_subcmd_del = dap_cli_server_cmd_find_option_val(argv, l_order_arg_pos + 1, l_order_arg_pos + 2, "delete", NULL) |
+ dap_cli_server_cmd_find_option_val(argv, l_order_arg_pos + 1, l_order_arg_pos + 2, "del", NULL);
int (*dap_chain_net_srv_vpn_cdb_server_list_static_create)(dap_chain_net_t *a_net) = NULL;
int (*dap_chain_net_srv_vpn_cdb_server_list_static_delete)(dap_chain_net_t *a_net) = NULL;
@@ -593,7 +593,7 @@ static int s_cli_net_srv( int argc, char **argv, char **a_str_reply)
dap_string_append_printf(l_string_ret, "Command 'net_srv' requires subcommand 'order'");
ret = -3;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_string_ret->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_string_ret->str);
dap_string_free(l_string_ret, true);
}
diff --git a/modules/service/datum/dap_chain_net_srv_datum.c b/modules/service/datum/dap_chain_net_srv_datum.c
index 48c20c2828de4a015e14ca4507f1c46c703ef958..75b81fec1b19f9dde0851ac76a2ac6f895daa975 100644
--- a/modules/service/datum/dap_chain_net_srv_datum.c
+++ b/modules/service/datum/dap_chain_net_srv_datum.c
@@ -40,7 +40,7 @@ void s_order_notficator(void *a_arg, const char a_op_code, const char *a_group,
int dap_chain_net_srv_datum_init()
{
- dap_chain_node_cli_cmd_item_create("srv_datum", s_srv_datum_cli, "Service Datum commands",
+ dap_cli_server_cmd_add("srv_datum", s_srv_datum_cli, "Service Datum commands",
"srv_datum -net <chain net name> -chain <chain name> datum save -datum <datum hash>\n"
"\tSaving datum from mempool to file.\n\n"
"srv_datum -net <chain net name> -chain <chain name> datum load -datum <datum hash>\n"
@@ -111,16 +111,16 @@ static int s_srv_datum_cli(int argc, char ** argv, char **a_str_reply) {
}
const char * l_datum_hash_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
if (!l_datum_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command srv_datum requires parameter '-datum' <datum hash>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command srv_datum requires parameter '-datum' <datum hash>");
return -4;
}
const char * l_system_datum_folder = dap_config_get_item_str(g_config, "resources", "datum_folder");
const char * l_datum_cmd_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "datum", &l_datum_cmd_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "datum", &l_datum_cmd_str);
if ( l_datum_cmd_str != NULL ) {
if ( strcmp(l_datum_cmd_str, "save") == 0) {
char * l_gdb_group = dap_chain_net_get_gdb_group_mempool_new(l_chain);
@@ -168,11 +168,11 @@ static int s_srv_datum_cli(int argc, char ** argv, char **a_str_reply) {
char *l_ret;
if ((l_ret = dap_chain_net_srv_datum_custom_add(l_chain, l_datum_data, l_datum_data_size)) == NULL) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't place datum custom \"%s\" to mempool", l_datum_hash_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Datum custom %s was successfully placed to mempool", l_datum_hash_str);
DAP_DELETE(l_ret);
return 0;
diff --git a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
index 2951e9f2818091628438369c91a42154e4f4fe9f..2f4ec0b8804c6b00d64ea5527bb4f2ee89c78c45 100644
--- a/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
+++ b/modules/service/stake_lock/dap_chain_net_srv_stake_lock.c
@@ -101,7 +101,7 @@ static void s_callback_decree(dap_chain_net_srv_t* a_srv, dap_chain_net_t* a_net
*/
int dap_chain_net_srv_stake_lock_init()
{
- dap_chain_node_cli_cmd_item_create("stake_lock", s_cli_stake_lock, "Stake lock service commands",
+ dap_cli_server_cmd_add("stake_lock", s_cli_stake_lock, "Stake lock service commands",
"stake_lock hold -net <net name> -wallet <wallet name> -time_staking <in rfc822>\n"
"-token <ticker> -coins <value> -cert <name> -chain <chain (not necessary)> -chain_emission <chain (not necessary)>\n"
"stake_lock take -net <net name> -tx <transaction hash> -wallet <wallet name>\n"
@@ -192,7 +192,7 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
dap_string_append_printf(output_line, "---> HOLD <---\n");
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
|| NULL == l_net_str)
return NET_ARG_ERROR;
@@ -201,7 +201,7 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
return NET_ERROR;
}
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-token", &l_token_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-token", &l_token_str)
|| NULL == l_token_str
|| dap_strlen(l_token_str) > 8) // for 'm' delegated
return TOKEN_ARG_ERROR;
@@ -213,14 +213,14 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
strcpy(delegate_token_str + 1, l_token_str);
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-coins", &l_coins_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-coins", &l_coins_str)
|| NULL == l_coins_str)
return COINS_ARG_ERROR;
if (IS_ZERO_256((l_value = dap_chain_balance_scan(l_coins_str))))
return COINS_FORMAT_ERROR;
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-cert", &l_cert_str)
|| NULL == l_cert_str)
return CERT_ARG_ERROR;
@@ -229,7 +229,7 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
return CERT_LOAD_ERROR;
}
- if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
&& l_chain_str)
l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
else
@@ -237,7 +237,7 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
if (!l_chain)
return CHAIN_ERROR;
- if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-chain_emission", &l_chain_emission_str)
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain_emission", &l_chain_emission_str)
&& l_chain_emission_str)
l_chain_emission = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
else
@@ -245,12 +245,12 @@ static enum error_code s_cli_hold(int a_argc, char** a_argv, int a_arg_index, da
if (!l_chain_emission)
return CHAIN_EMISSION_ERROR;
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
|| NULL == l_wallet_str)
return WALLET_ARG_ERROR;
// Read time staking
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-time_staking", &l_time_staking_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-time_staking", &l_time_staking_str)
|| NULL == l_time_staking_str)
return TIME_ERROR;
@@ -353,7 +353,7 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
dap_string_append_printf(output_line, "---> TAKE <---\n");
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-net", &l_net_str)
|| NULL == l_net_str)
return NET_ARG_ERROR;
@@ -362,7 +362,7 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
return NET_ERROR;
}
- if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-chain", &l_chain_str)
&& l_chain_str)
l_chain = dap_chain_net_get_chain_by_name(l_net, l_chain_str);
else
@@ -370,7 +370,7 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
if (!l_chain)
return CHAIN_ERROR;
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-tx", &l_tx_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-tx", &l_tx_str)
|| NULL == l_tx_str)
return TX_ARG_ERROR;
@@ -410,7 +410,7 @@ static enum error_code s_cli_take(int a_argc, char** a_argv, int a_arg_index, da
return NOT_ENOUGH_TIME;
}
- if (!dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
+ if (!dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, "-wallet", &l_wallet_str)
|| NULL == l_wallet_str)
return WALLET_ARG_ERROR;
@@ -698,9 +698,9 @@ static int s_cli_stake_lock(int a_argc, char** a_argv, char** a_str_reply)
int l_cmd_num = CMD_NONE;
dap_string_t* output_line = dap_string_new(NULL);
- if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "hold", NULL))
+ if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "hold", NULL))
l_cmd_num = CMD_HOLD;
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "take", NULL))
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "take", NULL))
l_cmd_num = CMD_TAKE;
switch (l_cmd_num) {
@@ -714,7 +714,7 @@ static int s_cli_stake_lock(int a_argc, char** a_argv, char** a_str_reply)
} break;
default: {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
dap_string_free(output_line, false);
} return 1;
}
@@ -724,7 +724,7 @@ static int s_cli_stake_lock(int a_argc, char** a_argv, char** a_str_reply)
else
dap_string_append_printf(output_line, "Contribution successfully made");
- dap_chain_node_cli_set_reply_text(a_str_reply, output_line->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, output_line->str);
dap_string_free(output_line, true);
return 0;
diff --git a/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c b/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
index ed81e6a4b094e1d15074746f7398a6be427fda3c..04631f3073f4b2d5cb6b05368447b205328b202f 100644
--- a/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
+++ b/modules/service/stake_pos_delegate/dap_chain_net_srv_stake_pos_delegate.c
@@ -52,7 +52,7 @@ static dap_chain_net_srv_stake_t *s_srv_stake = NULL;
*/
int dap_chain_net_srv_stake_pos_delegate_init()
{
- dap_chain_node_cli_cmd_item_create("srv_stake", s_cli_srv_stake, "Delegated stake service commands",
+ dap_cli_server_cmd_add("srv_stake", s_cli_srv_stake, "Delegated stake service commands",
"srv_stake order create -net <net name> -addr_hldr <addr> -token <ticker> -coins <value> -cert <name> -fee_percent <value>\n"
"\tCreate a new order with specified amount of datoshi to delegate specified cert from the specified address.\n"
"\tThe fee with specified percent with this delagation will be returned to the fee address pointed by delegator\n"
@@ -778,16 +778,16 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
CMD_NONE, CMD_CREATE, CMD_DECLARE, CMD_REMOVE, CMD_LIST, CMD_UPDATE
};
int l_cmd_num = CMD_NONE;
- if(dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "create", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "create", NULL)) {
l_cmd_num = CMD_CREATE;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "remove", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "remove", NULL)) {
l_cmd_num = CMD_REMOVE;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "list", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "list", NULL)) {
l_cmd_num = CMD_LIST;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "update", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "update", NULL)) {
l_cmd_num = CMD_UPDATE;
}
int l_arg_index = a_arg_index + 1;
@@ -796,63 +796,63 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
const char *l_net_str = NULL, *l_token_str = NULL, *l_coins_str = NULL;
const char *l_addr_hldr_str = NULL, *l_cert_str = NULL, *l_fee_str = NULL;
dap_chain_net_t *l_net = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -net");
return -3;
}
l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_token_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_token_str);
if (!l_token_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -token");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -token");
return -5;
}
if (!dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_str)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_str);
return -6;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
if (!l_coins_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -coins");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -coins");
return -7;
}
uint256_t l_value = dap_chain_balance_scan(l_coins_str);
if (IS_ZERO_256(l_value)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <256 bit integer>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -coins <256 bit integer>");
return -8;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr_hldr", &l_addr_hldr_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-addr_hldr", &l_addr_hldr_str);
if (!l_addr_hldr_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -addr_hldr");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -addr_hldr");
return -9;
}
dap_chain_addr_t *l_addr_hldr = dap_chain_addr_from_str(l_addr_hldr_str);
if (!l_addr_hldr) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Wrong address format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Wrong address format");
return -10;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
if (!l_cert_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -cert");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -cert");
return -9;
}
dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
if (!l_cert) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't load cert %s", l_cert_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't load cert %s", l_cert_str);
return -10;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-fee_percent", &l_fee_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-fee_percent", &l_fee_str);
if (!l_fee_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -fee_percent");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -fee_percent");
return -11;
}
uint256_t l_fee = dap_chain_coins_to_balance(l_fee_str);
if (IS_ZERO_256(l_fee)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -fee_percent <long double>(%)");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -fee_percent <long double>(%)");
return -12;
}
// Create the stake item
@@ -869,11 +869,11 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
// Create the order & put it in GDB
char *l_order_hash_str = s_stake_order_create(l_stake, l_cert->enc_key);
if (l_order_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
DAP_DELETE(l_order_hash_str);
DAP_DELETE(l_stake);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the order");
DAP_DELETE(l_stake);
return -15;
}
@@ -882,58 +882,58 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
const char *l_net_str = NULL, *l_token_str = NULL, *l_coins_str = NULL;
const char *l_wallet_str = NULL, *l_fee_str = NULL;
dap_chain_net_t *l_net = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order declare' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order declare' required parameter -net");
return -3;
}
l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_token_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_token_str);
if (!l_token_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order declare' required parameter -token");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order declare' required parameter -token");
return -5;
}
if (!dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_str)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_str);
return -6;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
if (!l_coins_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order declare' required parameter -coins");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order declare' required parameter -coins");
return -7;
}
uint256_t l_value = dap_chain_balance_scan(l_coins_str);
if (IS_ZERO_256(l_value)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <256 bit integer>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -coins <256 bit integer>");
return -8;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order declare' required parameter -wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order declare' required parameter -wallet");
return -9;
}
dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -18;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-fee_percent", &l_fee_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-fee_percent", &l_fee_str);
if (!l_fee_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order declare' required parameter -fee_percent");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order declare' required parameter -fee_percent");
return -11;
}
uint256_t l_fee = dap_chain_coins_to_balance(l_fee_str);
if (IS_ZERO_256(l_fee)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -fee_percent <long double>(%)");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -fee_percent <long double>(%)");
return -12;
}
uint256_t l_balance = dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_token_str);
if (compare256(l_balance, l_value) == -1) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Insufficient coins for token %s in wallet '%s'", l_token_str, l_wallet_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Insufficient coins for token %s in wallet '%s'", l_token_str, l_wallet_str);
return -13;
}
// Create the stake item
@@ -948,11 +948,11 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
// Create the order & put it to GDB
char *l_order_hash_str = s_stake_order_create(l_stake, dap_chain_wallet_get_key(l_wallet, 0));
if (l_order_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
DAP_DELETE(l_order_hash_str);
DAP_DELETE(l_stake);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the order");
DAP_DELETE(l_stake);
return -15;
}
@@ -960,17 +960,17 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
case CMD_REMOVE: {
const char *l_net_str = NULL, *l_order_hash_str = NULL;
dap_chain_net_t *l_net = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order remove' requires parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order remove' requires parameter -net");
return -3;
}
l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
char *l_order_hash_hex_str;
char *l_order_hash_base58_str;
@@ -985,17 +985,17 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
}
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order remove' requires parameter -order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order remove' requires parameter -order");
return -13;
}
if (dap_chain_net_srv_order_delete_by_hash_str_sync(l_net, l_order_hash_hex_str)) {
if(!dap_strcmp(a_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't remove order %s\n", l_order_hash_hex_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't remove order %s\n", l_order_hash_hex_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't remove order %s\n", l_order_hash_base58_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't remove order %s\n", l_order_hash_base58_str);
return -14;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "Stake order successfully removed");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Stake order successfully removed");
} break;
case CMD_UPDATE: {
const char *l_net_str = NULL, *l_token_str = NULL, *l_coins_str = NULL;
@@ -1003,18 +1003,18 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
const char *l_order_hash_str = NULL, *l_wallet_str = NULL;
dap_chain_net_t *l_net = NULL;
dap_enc_key_t *l_key = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order update' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order update' required parameter -net");
return -3;
}
l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order update' requires parameter -order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order update' requires parameter -order");
return -13;
}
dap_chain_net_srv_order_t *l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_str);
@@ -1033,36 +1033,36 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
if (!l_order) {
if(!dap_strcmp(a_hash_out_type,"hex"))
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find order %s\n", l_order_hash_hex_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find order %s\n", l_order_hash_hex_str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find order %s\n", l_order_hash_base58_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find order %s\n", l_order_hash_base58_str);
return -14;
}
dap_chain_net_srv_stake_item_t *l_stake = s_stake_item_from_order(l_net, l_order);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_token_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_token_str);
if (l_token_str) {
if (!dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_str)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_str);
DAP_DELETE(l_stake);
return -6;
}
strcpy(l_stake->token, l_token_str);
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_coins_str);
if (l_coins_str) {
uint256_t l_value = dap_chain_balance_scan(l_coins_str);
if (IS_ZERO_256(l_value)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
DAP_DELETE(l_stake);
return -8;
}
l_stake->value = l_value;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-fee_percent", &l_fee_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-fee_percent", &l_fee_str);
if (l_fee_str) {
long double l_fee = strtold(l_fee_str, NULL);
if (!l_fee) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -fee_percent <long double> %");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -fee_percent <long double> %");
DAP_DELETE(l_stake);
return -12;
}
@@ -1070,24 +1070,24 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
dap_chain_addr_t l_empty_addr = {};
if (memcmp(&l_stake->signing_addr, &l_empty_addr, sizeof(dap_chain_addr_t))) {
// It's a buying order
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
if (!l_cert_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order update' requires parameter -cert for buying orders");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order update' requires parameter -cert for buying orders");
DAP_DELETE(l_stake);
return -9;
}
dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
if (!l_cert) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't load cert %s", l_cert_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't load cert %s", l_cert_str);
DAP_DELETE(l_stake);
return -10;
}
l_key = l_cert->enc_key;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr_hldr", &l_addr_hldr_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-addr_hldr", &l_addr_hldr_str);
if (l_addr_hldr_str) {
dap_chain_addr_t *l_addr_hldr = dap_chain_addr_from_str(l_addr_hldr_str);
if (!l_addr_hldr) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Wrong address format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Wrong address format");
DAP_DELETE(l_stake);
return -14;
}
@@ -1095,28 +1095,28 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
DAP_DELETE(l_addr_hldr);
}
} else { // It's a selling order
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order update' requires parameter -wallet for selling orders");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order update' requires parameter -wallet for selling orders");
DAP_DELETE(l_stake);
return -7;
}
dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
DAP_DELETE(l_stake);
return -18;
}
uint256_t l_balance = dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_stake->token);
if (compare256(l_balance, l_stake->value) == -1) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Insufficient coins for token %s in wallet '%s'", l_token_str, l_wallet_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Insufficient coins for token %s in wallet '%s'", l_token_str, l_wallet_str);
DAP_DELETE(l_stake);
return -11;
}
l_key = dap_chain_wallet_get_key(l_wallet, 0);
}
if (!l_token_str && !l_coins_str && !l_addr_hldr_str && !l_fee_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "At least one of updating parameters is mandatory");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "At least one of updating parameters is mandatory");
DAP_DELETE(l_stake);
return -16;
}
@@ -1127,28 +1127,28 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
l_order_hash_hex_str = s_stake_order_create(l_stake, l_key);
DAP_DELETE(l_stake);
if(!l_order_hash_hex_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the order");
return -15;
}
if(!dap_strcmp(a_hash_out_type, "hex")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_hex_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_hex_str);
} else {
l_order_hash_base58_str = dap_enc_base58_from_hex_str_to_str(l_order_hash_hex_str);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_base58_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_base58_str);
DAP_DELETE(l_order_hash_base58_str);
}
DAP_DELETE(l_order_hash_hex_str);
} break;
case CMD_LIST: {
const char *l_net_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order list' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order list' required parameter -net");
return -3;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
char * l_gdb_group_str = dap_chain_net_srv_order_get_gdb_group(l_net);
@@ -1179,7 +1179,7 @@ static int s_cli_srv_stake_order(int a_argc, char **a_argv, int a_arg_index, cha
*a_str_reply = dap_string_free(l_reply_str, false);
} break;
default: {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand %s not recognized", a_argv[a_arg_index]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Subcommand %s not recognized", a_argv[a_arg_index]);
return -2;
}
}
@@ -1194,35 +1194,35 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
int l_arg_index = 1;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "base58";
if(dap_strcmp(l_hash_out_type," hex") && dap_strcmp(l_hash_out_type, "base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
int l_cmd_num = CMD_NONE;
- if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "order", NULL)) {
+ if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "order", NULL)) {
l_cmd_num = CMD_ORDER;
}
// Create tx to freeze staker's funds and delete order
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "delegate", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "delegate", NULL)) {
l_cmd_num = CMD_DELEGATE;
}
// Create tx to approve staker's funds freeze
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "approve", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "approve", NULL)) {
l_cmd_num = CMD_APPROVE;
}
// Show the tx list with frozen staker funds
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "transactions", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "transactions", NULL)) {
l_cmd_num = CMD_TX_LIST;
}
// Return staker's funds
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "invalidate", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "invalidate", NULL)) {
l_cmd_num = CMD_INVALIDATE;
}
// Send a staker fee to staker
- else if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "commit", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "commit", NULL)) {
l_cmd_num = CMD_COMMIT;
}
switch (l_cmd_num) {
@@ -1231,39 +1231,39 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
case CMD_DELEGATE: {
const char *l_net_str = NULL, *l_wallet_str = NULL, *l_order_hash_str = NULL, *l_addr_fee_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'delegate' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'delegate' required parameter -net");
return -3;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'delegate' required parameter -wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'delegate' required parameter -wallet");
return -17;
}
dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -18;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
if (!l_order_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'delegate' required parameter -order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'delegate' required parameter -order");
return -13;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-fee_addr", &l_addr_fee_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-fee_addr", &l_addr_fee_str);
if (!l_addr_fee_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'delegate' required parameter -fee_addr");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'delegate' required parameter -fee_addr");
return -9;
}
dap_chain_addr_t *l_addr_fee = dap_chain_addr_from_str(l_addr_fee_str);
if (!l_addr_fee) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Wrong address format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Wrong address format");
return -10;
}
dap_chain_net_srv_order_t *l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_str);
@@ -1272,7 +1272,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
if (!l_stake) {
DAP_DELETE(l_order);
DAP_DELETE(l_addr_fee);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified order is invalid");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified order is invalid");
return -22;
}
memcpy(&l_stake->addr_fee, l_addr_fee, sizeof(dap_chain_addr_t));
@@ -1289,7 +1289,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
dap_chain_net_srv_order_delete_by_hash_str_sync(l_net, l_order_hash_str);
}
DAP_DELETE(l_order);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_tx ? "Stake transaction has done" :
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_tx ? "Stake transaction has done" :
"Stake transaction error");
if (!l_tx) {
DAP_DELETE(l_stake);
@@ -1298,36 +1298,36 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
HASH_ADD(hh, s_srv_stake->itemlist, signing_addr, sizeof(dap_chain_addr_t), l_stake);
} else {
DAP_DELETE(l_addr_fee);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified order not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified order not found");
return -14;
}
} break;
case CMD_APPROVE: {
const char *l_net_str = NULL, *l_tx_hash_str = NULL, *l_cert_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'approve' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'approve' required parameter -net");
return -3;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-cert", &l_cert_str);
if (!l_cert_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'approve' required parameter -cert");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'approve' required parameter -cert");
return -17;
}
dap_cert_t *l_cert = dap_cert_find_by_name(l_cert_str);
if (!l_cert) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified certificate not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified certificate not found");
return -18;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
if (!l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'delegate' required parameter -tx");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'delegate' required parameter -tx");
return -13;
}
dap_chain_hash_fast_t l_tx_hash = {};
@@ -1335,7 +1335,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
if (l_result)
l_result = dap_enc_base58_decode(l_tx_hash_str, &l_tx_hash) - sizeof(dap_chain_hash_fast_t);
if (l_result) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Invalid transaction hash format");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Invalid transaction hash format");
return -14;
}
dap_chain_net_srv_stake_item_t *l_stake = NULL, *l_tmp;
@@ -1345,7 +1345,7 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
}
}
if (!l_stake) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Transaction %s not found", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s not found", l_tx_hash_str);
return -20;
}
dap_chain_datum_tx_t *l_tx = s_stake_tx_approve(l_stake, l_cert);
@@ -1357,14 +1357,14 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
case CMD_TX_LIST: {
const char *l_net_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'transactions' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'transactions' required parameter -net");
return -3;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
dap_chain_net_srv_stake_item_t *l_stake = NULL, *l_tmp;
@@ -1398,29 +1398,29 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
case CMD_INVALIDATE: {
const char *l_net_str = NULL, *l_wallet_str = NULL, *l_tx_hash_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'invalidate' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' required parameter -net");
return -3;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'invalidate' required parameter -wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' required parameter -wallet");
return -17;
}
dap_chain_wallet_t *l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -18;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
if (!l_tx_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'invalidate' required parameter -tx");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'invalidate' required parameter -tx");
return -13;
}
dap_chain_hash_fast_t l_tx_hash = {};
@@ -1432,38 +1432,38 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
}
}
if (!l_stake) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Transaction %s not found", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Transaction %s not found", l_tx_hash_str);
dap_chain_wallet_close(l_wallet);
return -20;
}
bool l_success = s_stake_tx_invalidate(l_stake, l_wallet);
dap_chain_wallet_close(l_wallet);
if (l_success) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Stake successfully returned to owner");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Stake successfully returned to owner");
// don't delete stake here because it delete in s_stake_update after invalidate tx approve
// HASH_DEL(s_srv_stake->itemlist, l_stake);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't invalidate transaction %s", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't invalidate transaction %s", l_tx_hash_str);
return -21;
}
} break;
case CMD_COMMIT: {
const char *l_net_str = NULL, *l_tx_hash_str = NULL, *l_block_hash_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if(!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'commit' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'commit' required parameter -net");
return -3;
}
dap_chain_net_t *l_net = dap_chain_net_by_name(l_net_str);
if(!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-block", &l_block_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-tx", &l_tx_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-block", &l_block_hash_str);
if(!l_tx_hash_str && !l_block_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'commit' required parameter -block or -tx");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'commit' required parameter -block or -tx");
return -22;
}
// list of tx hash
@@ -1481,16 +1481,16 @@ static int s_cli_srv_stake(int a_argc, char **a_argv, char **a_str_reply)
bool l_success = s_stake_block_commit(l_net, l_tx_list);
dap_list_free_full(l_tx_list, free);
if(l_success) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Stake successfully transfered to holder");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Stake successfully transfered to holder");
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't transfered to holder");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't transfered to holder");
return -23;
}
}
break;
default: {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
return -1;
}
}
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn.c b/modules/service/vpn/dap_chain_net_srv_vpn.c
index b72d9856589bcd3675ec7176b401cc5632029260..0bf67e60ae6df339f77fdae3ed00c97b1e860c7f 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn.c
@@ -862,7 +862,7 @@ int dap_chain_net_srv_vpn_init(dap_config_t * g_config) {
s_ch_packet_out);
// add console command to display vpn statistics
- dap_chain_node_cli_cmd_item_create ("vpn_stat", com_vpn_statistics, "VPN statistics",
+ dap_cli_server_cmd_add ("vpn_stat", com_vpn_statistics, "VPN statistics",
"vpn_stat -net <net name> [-full]\n"
);
return 0;
diff --git a/modules/service/vpn/dap_chain_net_srv_vpn_cmd.c b/modules/service/vpn/dap_chain_net_srv_vpn_cmd.c
index fe8ebe224b5590a6b3dce9bc1262d32dcc9b0bac..df0d6ab08c2e756f59e1d1f535c33558012c179f 100644
--- a/modules/service/vpn/dap_chain_net_srv_vpn_cmd.c
+++ b/modules/service/vpn/dap_chain_net_srv_vpn_cmd.c
@@ -83,9 +83,9 @@ int com_vpn_statistics(int a_argc, char ** a_argv, char **a_str_reply)
// unlock sessions list
dap_stream_session_get_list_sessions_unlock();
if(l_conn>0)
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str->str);
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "No VPN connections");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No VPN connections");
// free tmp memory
dap_string_free(l_str, true);
return 0;
@@ -105,11 +105,11 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
int l_arg_index = 1;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -119,29 +119,29 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
return -2;
int cmd_num = CMD_NONE;
- if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "init", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "init", NULL)) {
cmd_num = CMD_INIT;
}
- if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "start", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "start", NULL)) {
cmd_num = CMD_START;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "stop", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "stop", NULL)) {
cmd_num = CMD_STOP;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "status", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "status", NULL)) {
cmd_num = CMD_STATUS;
}
- else if(dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "check", NULL)) {
+ else if(dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "check", NULL)) {
cmd_num = CMD_CHECK;
- if(dap_chain_node_cli_find_option_val(a_argv, min(a_argc, l_arg_index + 1), min(a_argc, l_arg_index + 2), "result", NULL)) {
+ if(dap_cli_server_cmd_find_option_val(a_argv, min(a_argc, l_arg_index + 1), min(a_argc, l_arg_index + 2), "result", NULL)) {
cmd_num = CMD_CHECK_RESULT;
}
}
if(cmd_num == CMD_NONE) {
if(!a_argv[1])
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameters");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameters");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "parameter %s not recognized", a_argv[1]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "parameter %s not recognized", a_argv[1]);
return -1;
}
@@ -149,23 +149,23 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
{
case CMD_CHECK_RESULT: {
char *l_str = dap_chain_net_vpn_client_check_result(l_net, l_hash_out_type);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str);
DAP_DELETE(l_str);
}
break;
case CMD_CHECK: {
const char * l_str_addr = NULL; // for example, "192.168.100.93"
const char * l_str_port = NULL; // for example, "8079"
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_str_addr);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_str_addr);
if(!l_str_addr) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"VPN server address not defined, use -addr <vpn server ipv4 address> parameter");
break;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-port", &l_str_port);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-port", &l_str_port);
int l_srv_port = (l_str_port) ? (int) strtoll(l_str_port, 0, 10) : 0;
if(!l_srv_port) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"VPN server port not defined, use -port <vpn server port> parameter");
break;
}
@@ -183,14 +183,14 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
}
switch (l_res) {
case 0:
- dap_chain_node_cli_set_reply_text(a_str_reply, "tested VPN server successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "tested VPN server successfully");
break;
case -2:
case -3:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't connect to VPN server");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't connect to VPN server");
break;
default:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't recognize error code=%d", l_res);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't recognize error code=%d", l_res);
break;
}
return l_res;
@@ -200,40 +200,40 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
const char * l_str_token = NULL; // token name
const char * l_str_value_datoshi = NULL;
const char * l_str_wallet = NULL; // wallet name
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_str_wallet);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_str_wallet);
if(!l_str_wallet)
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-w", &l_str_wallet);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-w", &l_str_wallet);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_str_token);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-value", &l_str_value_datoshi);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token", &l_str_token);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-value", &l_str_value_datoshi);
if(!l_str_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Wallet not defined, use -w <wallet_name> or -wallet <wallet_name> parameter");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Wallet not defined, use -w <wallet_name> or -wallet <wallet_name> parameter");
break;
}
if(!l_str_token) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Token not defined, use -token <token_name> parameter");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Token not defined, use -token <token_name> parameter");
break;
}
if(!l_str_value_datoshi) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Value of datoshi not defined, use -value <value of datoshi> parameter");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Value of datoshi not defined, use -value <value of datoshi> parameter");
break;
}
uint64_t l_a_value_datoshi = strtoull(l_str_value_datoshi, NULL, 10);
if(!l_a_value_datoshi)
l_a_value_datoshi = strtoull(l_str_value_datoshi, NULL, 16);
if(!l_a_value_datoshi) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Value of datoshi have to be more then 0");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Value of datoshi have to be more then 0");
break;
}
int l_res = dap_chain_net_vpn_client_update(l_net, l_str_wallet, l_str_token, l_a_value_datoshi);
if(!l_res)
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client init successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client init successfully");
else{
if(l_res==-3)
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client init successfully, but probably not enough founds in the wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client init successfully, but probably not enough founds in the wallet");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client not init");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client not init");
}
return l_res;
}
@@ -241,33 +241,33 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
case CMD_START: {
const char * l_str_addr = NULL; // for example, "192.168.100.93"
const char * l_str_port = NULL; // for example, "8079"
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_str_addr);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_str_addr);
if(!l_str_addr) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"VPN server address not defined, use -addr <vpn server ipv4 address> parameter");
break;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-port", &l_str_port);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-port", &l_str_port);
int l_srv_port = (l_str_port) ? (int) strtoll(l_str_port, 0, 10) : 0;
if(!l_srv_port) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"VPN server port not defined, use -port <vpn server port> parameter");
break;
}
int l_res = dap_chain_net_vpn_client_start(l_net, l_str_addr, NULL, l_srv_port);
switch (l_res) {
case 0:
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client started successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client started successfully");
break;
case 1:
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client already started");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client already started");
break;
case -2:
case -3:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't connect to VPN server");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't connect to VPN server");
break;
default:
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't start VPN client");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't start VPN client");
break;
}
return l_res;
@@ -276,9 +276,9 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
case CMD_STOP: {
int res = dap_chain_net_vpn_client_stop();
if(!res)
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client stopped successfully");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client stopped successfully");
else
- dap_chain_node_cli_set_reply_text(a_str_reply, "VPN client not stopped");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "VPN client not stopped");
return res;
}
break;
@@ -306,7 +306,7 @@ int com_vpn_client(int a_argc, char ** a_argv, char **a_str_reply)
l_status_txt = "VPN client status unknown";
break;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "%s\nused:\nwallet:%s\nreceipt:%u*1e-9 %s", l_status_txt,
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "%s\nused:\nwallet:%s\nreceipt:%u*1e-9 %s", l_status_txt,
l_wallet_name, l_value_datoshi, l_str_token);
break;
}
diff --git a/modules/service/vpn/dap_chain_net_vpn_client.c b/modules/service/vpn/dap_chain_net_vpn_client.c
index d2322f3553fe92a6f0b547290e07a340085207ef..edbce30708106c24a6ec057057ed3e07873883b7 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client.c
@@ -762,7 +762,7 @@ int dap_chain_net_vpn_client_init(dap_config_t * g_config)
pthread_mutex_init(&sf_socks_mutex, NULL);
// vpn client command
- dap_chain_node_cli_cmd_item_create ("vpn_client", com_vpn_client, "VPN client control",
+ dap_cli_server_cmd_add ("vpn_client", com_vpn_client, "VPN client control",
"vpn_client [start -addr <server address> -port <server port>| stop | status] -net <net name>\n"
"vpn_client init -w <wallet name> -token <token name> -value <value> -net <net name>\n"
"vpn_client stop -net <net name>\n"
diff --git a/modules/service/vpn/dap_chain_net_vpn_client_tun.c b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
index 067d94fe8da24c6ed188f5b6e59637d4dd12b2e5..66f3a6e0f1b6a27adeac92daac5f81c5bb479ea4 100644
--- a/modules/service/vpn/dap_chain_net_vpn_client_tun.c
+++ b/modules/service/vpn/dap_chain_net_vpn_client_tun.c
@@ -62,6 +62,16 @@
#include <sys/socket.h>
#include <sys/sys_domain.h>
#include <netinet/in.h>
+#include <netinet/ip.h>
+#elif defined (DAP_OS_BSD)
+#include <net/if.h>
+#include <sys/kern_control.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/socket.h>
+#include <sys/sys_domain.h>
+#include <netinet/in.h>
+#include <netinet/ip.h>
#endif
#include "dap_chain_net_srv_vpn.h"
@@ -379,7 +389,7 @@ static void m_client_tun_read(dap_events_socket_t * a_es, void * arg)
in_daddr.s_addr = iph->daddr;
in_saddr.s_addr = iph->saddr;
#else
- struct ip* iph = (struct ip*)l_tmp_buf;
+ struct ip* iph = (struct ip*)a_es->buf_in;
in_daddr.s_addr = iph->ip_dst.s_addr;
in_saddr.s_addr = iph->ip_src.s_addr;
#endif
diff --git a/modules/service/xchange/dap_chain_net_srv_xchange.c b/modules/service/xchange/dap_chain_net_srv_xchange.c
index 701718d563229263fcee33d590779c0b049ce202..3ce2df5d29b9eca818b349b0e44c43d85c91dcdc 100644
--- a/modules/service/xchange/dap_chain_net_srv_xchange.c
+++ b/modules/service/xchange/dap_chain_net_srv_xchange.c
@@ -92,7 +92,7 @@ static dap_chain_net_srv_xchange_t* s_srv_xchange;
*/
int dap_chain_net_srv_xchange_init()
{
- dap_chain_node_cli_cmd_item_create("srv_xchange", s_cli_srv_xchange, "eXchange service commands",
+ dap_cli_server_cmd_add("srv_xchange", s_cli_srv_xchange, "eXchange service commands",
"srv_xchange order create -net <net_name> -token_sell <token ticker> -token_buy <token_ticker> -wallet <name> -coins <value> -rate <value>\n"
"\tCreate a new order and tx with specified amount of datoshi to exchange with specified rate (buy / sell)\n"
"srv_xchange order remove -net <net_name> -order <order_hash> -wallet <wallet_name>\n"
@@ -620,16 +620,16 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
CMD_NONE, CMD_CREATE, CMD_REMOVE, CMD_UPDATE, CMD_HISTORY
};
int l_cmd_num = CMD_NONE;
- if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "create", NULL)) {
+ if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "create", NULL)) {
l_cmd_num = CMD_CREATE;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "remove", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "remove", NULL)) {
l_cmd_num = CMD_REMOVE;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "update", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "update", NULL)) {
l_cmd_num = CMD_UPDATE;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "history", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, min(a_argc, a_arg_index + 1), "history", NULL)) {
l_cmd_num = CMD_HISTORY;
}
int l_arg_index = a_arg_index + 1;
@@ -639,68 +639,68 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
dap_chain_net_t* l_net = NULL;
switch (l_cmd_num) {
case CMD_CREATE: {
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -net");
return -2;
}
l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -3;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token_sell", &l_token_sell_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token_sell", &l_token_sell_str);
if (!l_token_sell_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price create' required parameter -token_sell");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price create' required parameter -token_sell");
return -5;
}
if (!dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_sell_str)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_sell_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_sell_str);
return -6;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token_buy", &l_token_buy_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token_buy", &l_token_buy_str);
if (!l_token_buy_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price create' required parameter -token_buy");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price create' required parameter -token_buy");
return -5;
}
if (!dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_buy_str)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_buy_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Token ticker %s not found", l_token_buy_str);
return -6;
}
const char* l_val_sell_str = NULL, * l_val_rate_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_sell_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_sell_str);
if (!l_val_sell_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price create' required parameter -coins");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price create' required parameter -coins");
return -8;
}
uint256_t l_datoshi_sell = dap_chain_balance_scan(l_val_sell_str);
if (IS_ZERO_256(l_datoshi_sell)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
return -9;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-rate", &l_val_rate_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-rate", &l_val_rate_str);
if (!l_val_rate_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price create' required parameter -rate");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price create' required parameter -rate");
return -8;
}
uint256_t l_rate = dap_chain_coins_to_balance(l_val_rate_str);
if (!compare256(l_rate, uint256_0)) { // if (l_rate == 0)
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -rate n.n = buy / sell (eg: 1.0, 1.135)");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -rate n.n = buy / sell (eg: 1.0, 1.135)");
return -9;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price create' required parameter -wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price create' required parameter -wallet");
return -10;
}
dap_chain_wallet_t* l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -11;
}
uint256_t l_value = dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_token_sell_str);
if (compare256(l_value, l_datoshi_sell) == -1) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Not enough cash in specified wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Not enough cash in specified wallet");
dap_chain_wallet_close(l_wallet);
return -12;
}
@@ -715,7 +715,7 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
// Create conditional transaction
dap_chain_datum_tx_t* l_tx = s_xchange_tx_create_request(l_price, l_wallet);
if (!l_tx) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the conditional transaction");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the conditional transaction");
DAP_DELETE(l_price->wallet_str);
DAP_DELETE(l_price);
dap_chain_wallet_close(l_wallet);
@@ -728,47 +728,47 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
if (l_order_hash_str) {
dap_chain_hash_fast_from_str(l_order_hash_str, &l_price->order_hash);
if (!s_xchange_tx_put(l_tx, l_net)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't put transaction to mempool");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't put transaction to mempool");
dap_chain_net_srv_order_delete_by_hash_str_sync(l_net, l_order_hash_str);
DAP_DELETE(l_order_hash_str);
DAP_DELETE(l_price->wallet_str);
DAP_DELETE(l_price);
return -15;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
DAP_DELETE(l_order_hash_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the order");
DAP_DELETE(l_price->wallet_str);
DAP_DELETE(l_price);
return -18;
}
} break;
case CMD_HISTORY: {
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'order create' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'order create' required parameter -net");
return -2;
}
l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -3;
}
} break;
const char* l_order_hash_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
if (!l_order_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price %s' required parameter -order",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price %s' required parameter -order",
l_cmd_num == CMD_REMOVE ? "remove" : "update");
return -12;
}
dap_chain_net_srv_order_t* l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_str);
if (!l_order) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified order not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified order not found");
return -13;
}
@@ -777,7 +777,7 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
int l_rc = s_tx_check_for_open_close(l_net, l_tx);
char* l_tx_hash = dap_chain_hash_fast_to_str_new(&l_order->tx_cond_hash);
if (l_rc == 0) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "WRONG TX %s", l_tx_hash);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "WRONG TX %s", l_tx_hash);
}
else if (l_rc == 1) {
dap_string_t* l_str_reply = dap_string_new("");
@@ -793,52 +793,52 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
*a_str_reply = dap_string_free(l_str_reply, false);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Internal error!");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Internal error!");
}
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No history");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No history");
}
case CMD_REMOVE:
case CMD_UPDATE: {
const char* l_order_hash_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price %s' required parameter -net",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price %s' required parameter -net",
l_cmd_num == CMD_REMOVE ? "remove" : "update");
return -2;
}
dap_chain_net_t* l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -3;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price %s' required parameter -wallet",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price %s' required parameter -wallet",
l_cmd_num == CMD_REMOVE ? "remove" : "update");
return -10;
}
dap_chain_wallet_t* l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -11;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
if (!l_order_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'price %s' required parameter -order",
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'price %s' required parameter -order",
l_cmd_num == CMD_REMOVE ? "remove" : "update");
return -12;
}
dap_chain_net_srv_order_t* l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_str);
if (!l_order) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified order not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified order not found");
return -13;
}
dap_chain_net_srv_xchange_price_t* l_price = s_xchange_price_from_order(l_net, l_order);
if (!l_order) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't create price object from order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't create price object from order");
return -13;
}
@@ -867,36 +867,36 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
uint256_t l_datoshi_sell = {};
uint256_t l_rate = uint256_0;
dap_chain_wallet_t* l_wallet = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_sell_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_sell_str);
if (l_val_sell_str) {
l_datoshi_sell = dap_chain_balance_scan(l_val_sell_str);
if (IS_ZERO_256(l_datoshi_sell)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
return -9;
}
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-rate", &l_val_rate_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-rate", &l_val_rate_str);
if (l_val_rate_str) {
l_rate = dap_chain_coins_to_balance(l_val_rate_str);
if (!compare256(l_rate, uint256_0)) { // if (l_rate == 0)
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -rate <long double> = sell / buy");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -rate <long double> = sell / buy");
return -9;
}
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_new_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_new_wallet_str);
l_wallet_str = l_new_wallet_str ? l_new_wallet_str : l_price->wallet_str;
l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -11;
}
if (!l_val_sell_str && !l_val_rate_str && !l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "At least one of updating parameters is mandatory");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "At least one of updating parameters is mandatory");
return -13;
}
uint256_t l_value = dap_chain_wallet_get_balance(l_wallet, l_net->pub.id, l_token_sell_str);
if (!IS_ZERO_256(l_datoshi_sell) && compare256(l_value, l_datoshi_sell) == -1) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Not enough cash in specified wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Not enough cash in specified wallet");
dap_chain_wallet_close(l_wallet);
return -12;
}
@@ -915,14 +915,14 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
l_price->wallet_str = dap_strdup(l_new_wallet_str);
}
if (!l_tx) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the conditional transaction");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the conditional transaction");
return -14;
}
bool l_ret = s_xchage_tx_invalidate(l_price, l_wallet); // may be changed to old price later
dap_chain_wallet_close(l_wallet);
if (!l_ret) {
char* l_tx_hash_str = dap_chain_hash_fast_to_str_new(&l_price->tx_hash);
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't invalidate transaction %s\n", l_tx_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't invalidate transaction %s\n", l_tx_hash_str);
DAP_DELETE(l_tx_hash_str);
return -17;
}
@@ -934,16 +934,16 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
if (l_order_hash_str) {
dap_chain_hash_fast_from_str(l_order_hash_str, &l_price->order_hash);
if (!s_xchange_tx_put(l_tx, l_net)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't put transaction to mempool");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't put transaction to mempool");
dap_chain_net_srv_order_delete_by_hash_str_sync(l_net, l_order_hash_str);
DAP_DELETE(l_order_hash_str);
return -15;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Successfully created order %s", l_order_hash_str);
DAP_DELETE(l_order_hash_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't compose the order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't compose the order");
DAP_DELETE(l_price->wallet_str);
DAP_DELETE(l_price);
return -18;
@@ -951,7 +951,7 @@ static int s_cli_srv_xchange_order(int a_argc, char** a_argv, int a_arg_index, c
}
} break;
default: {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Subcommand %s not recognized", a_argv[a_arg_index]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Subcommand %s not recognized", a_argv[a_arg_index]);
return -4;
}
}
@@ -1171,25 +1171,25 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
enum { CMD_NONE = 0, CMD_ORDER, CMD_ORDERS, CMD_PURCHASE, CMD_ENABLE, CMD_DISABLE, CMD_TX_LIST, CMD_TOKEN_PAIR };
int l_arg_index = 1, l_cmd_num = CMD_NONE, l_rc;
- if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "order", NULL)) {
+ if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "order", NULL)) {
l_cmd_num = CMD_ORDER;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "orders", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "orders", NULL)) {
l_cmd_num = CMD_ORDERS;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "purchase", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "purchase", NULL)) {
l_cmd_num = CMD_PURCHASE;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "enable", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "enable", NULL)) {
l_cmd_num = CMD_ENABLE;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "disable", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "disable", NULL)) {
l_cmd_num = CMD_DISABLE;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "tx_list", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "tx_list", NULL)) {
l_cmd_num = CMD_TX_LIST;
}
- else if (dap_chain_node_cli_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "token_pair", NULL)) {
+ else if (dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, min(a_argc, l_arg_index + 1), "token_pair", NULL)) {
l_cmd_num = CMD_TOKEN_PAIR;
}
@@ -1200,14 +1200,14 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
case CMD_ORDERS: {
const char* l_net_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'orders' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'orders' required parameter -net");
return -2;
}
dap_chain_net_t* l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -3;
}
@@ -1261,46 +1261,46 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
case CMD_PURCHASE: {
const char* l_net_str = NULL, * l_wallet_str = NULL, * l_order_hash_str = NULL, * l_val_buy_str = NULL;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'purchase' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'purchase' required parameter -net");
return -2;
}
dap_chain_net_t* l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -3;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-wallet", &l_wallet_str);
if (!l_wallet_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'purchase' required parameter -wallet");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'purchase' required parameter -wallet");
return -10;
}
dap_chain_wallet_t* l_wallet = dap_chain_wallet_open(l_wallet_str, dap_chain_wallet_get_path(g_config));
if (!l_wallet) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified wallet not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified wallet not found");
return -11;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-order", &l_order_hash_str);
if (!l_order_hash_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'purchase' required parameter -order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'purchase' required parameter -order");
return -12;
}
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_buy_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-coins", &l_val_buy_str);
if (!l_val_buy_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'purchase' required parameter -coins");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'purchase' required parameter -coins");
return -8;
}
uint256_t l_datoshi_buy = dap_chain_balance_scan(l_val_buy_str);
if (IS_ZERO_256(l_datoshi_buy)) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Format -coins <unsigned long long>");
return -9;
}
dap_chain_net_srv_order_t* l_order = dap_chain_net_srv_order_find_by_hash_str(l_net, l_order_hash_str);
if (l_order) {
dap_chain_net_srv_xchange_price_t* l_price = s_xchange_price_from_order(l_net, l_order);
if (!l_price) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't create price from order");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't create price from order");
return -13;
}
// Create conditional transaction
@@ -1311,11 +1311,11 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
}
DAP_DELETE(l_price);
DAP_DELETE(l_order);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_tx ? "Exchange transaction has done" :
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_tx ? "Exchange transaction has done" :
"Exchange transaction error");
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Specified order not found");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Specified order not found");
return -13;
}
} break;
@@ -1332,16 +1332,16 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
dap_chain_addr_t* l_addr;
l_arg_index++;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-time_from", &l_time_begin_str);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-time_to", &l_time_end_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-time_from", &l_time_begin_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-time_to", &l_time_end_str);
/*
* @RRL: #6294: [[-addr <addr> [-status closed | open]]
* we should check for valid combination of the status and addr options
*/
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_addr_str);
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-status", &l_status_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-addr", &l_addr_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-status", &l_status_str);
/* Validate input arguments ... */
@@ -1357,19 +1357,19 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
else if (dap_strcmp(l_status_str, "all") == 0)
l_opt_status = 0;
else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Unrecognized '-status %s'", l_status_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Unrecognized '-status %s'", l_status_str);
return -3;
}
}
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'tx_list' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'tx_list' required parameter -net");
return -3;
}
dap_chain_net_t* l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
@@ -1382,7 +1382,7 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
if (l_addr_str)
{
if (!(l_addr = dap_chain_addr_from_str(l_addr_str)))
- return dap_chain_node_cli_set_reply_text(a_str_reply, "Cannot convert -addr '%s' to internal representative", l_addr_str), -EINVAL;
+ return dap_cli_server_cmd_set_reply_text(a_str_reply, "Cannot convert -addr '%s' to internal representative", l_addr_str), -EINVAL;
return s_cli_srv_xchange_tx_list_addr(l_net, l_time[0], l_time[1], l_addr, l_opt_status, a_str_reply);
}
@@ -1476,14 +1476,14 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
// Find and check the network
const char* l_net_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-net", &l_net_str);
if (!l_net_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'token_pair' required parameter -net");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'token_pair' required parameter -net");
return -3;
}
dap_chain_net_t* l_net = dap_chain_net_by_name(l_net_str);
if (!l_net) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Network %s not found", l_net_str);
return -4;
}
@@ -1492,46 +1492,46 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
// check for price subcommand
const char* l_price_subcommand = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "price", &l_price_subcommand);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "price", &l_price_subcommand);
// check for get subcommand
if (l_price_subcommand) {
// Check for token1
const char* l_token_from_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token_from", &l_token_from_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token_from", &l_token_from_str);
if (!l_token_from_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No argument '-token_from'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No argument '-token_from'");
return -5;
}
dap_chain_datum_token_t* l_token_from_datum = dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_from_str);
if (!l_token_from_datum) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find \"%s\" token in network \"%s\" for argument '-token_from' ", l_token_from_str, l_net->pub.name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find \"%s\" token in network \"%s\" for argument '-token_from' ", l_token_from_str, l_net->pub.name);
return -6;
}
// Check for token2
const char* l_token_to_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-token_to", &l_token_to_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-token_to", &l_token_to_str);
if (!l_token_to_str) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "No argument '-token_to'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "No argument '-token_to'");
return -5;
}
dap_chain_datum_token_t* l_token_to_datum = dap_chain_ledger_token_ticker_check(l_net->pub.ledger, l_token_to_str);
if (!l_token_to_datum) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find \"%s\" token in network \"%s\" for argument '-token2' ", l_token_to_str, l_net->pub.name);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find \"%s\" token in network \"%s\" for argument '-token2' ", l_token_to_str, l_net->pub.name);
return -6;
}
// Read time_from
dap_time_t l_time_from = 0;
const char* l_time_from_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-time_from", &l_time_from_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-time_from", &l_time_from_str);
l_time_from = dap_time_from_str_rfc822(l_time_from_str);
// Read time_to
dap_time_t l_time_to = 0;
const char* l_time_to_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "-time_to", &l_time_to_str);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "-time_to", &l_time_to_str);
l_time_to = dap_time_from_str_rfc822(l_time_to_str);
// Check for price subcommand
@@ -1719,7 +1719,7 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
}
const char* l_list_subcommand = NULL;
- dap_chain_node_cli_find_option_val(a_argv, l_arg_index, a_argc, "list", &l_list_subcommand);
+ dap_cli_server_cmd_find_option_val(a_argv, l_arg_index, a_argc, "list", &l_list_subcommand);
if (l_list_subcommand) {
if (strcmp(l_list_subcommand, "all") == 0) {
dap_string_t* l_reply_str = dap_string_new("");
@@ -1752,13 +1752,13 @@ static int s_cli_srv_xchange(int a_argc, char** a_argv, char** a_str_reply)
}
// No subcommand selected
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command 'token pair' required proper subcommand, please read its manual with command 'help srv_xchange'");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command 'token pair' required proper subcommand, please read its manual with command 'help srv_xchange'");
} break;
default: {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Command %s not recognized", a_argv[l_arg_index]);
return -1;
}
}
diff --git a/modules/type/blocks/dap_chain_cs_blocks.c b/modules/type/blocks/dap_chain_cs_blocks.c
index 13887ddbc237c70325cdaa0992676d686d2d24cc..aa24611d3c4acd6195ef08d6aa6f6cd61f85d68d 100644
--- a/modules/type/blocks/dap_chain_cs_blocks.c
+++ b/modules/type/blocks/dap_chain_cs_blocks.c
@@ -150,7 +150,7 @@ int dap_chain_cs_blocks_init()
dap_chain_cs_type_add("blocks", dap_chain_cs_blocks_new );
s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
s_debug_more = dap_config_get_item_bool_default(g_config, "blocks", "debug_more", false);
- dap_chain_node_cli_cmd_item_create ("block", s_cli_blocks, "Create and explore blockchains",
+ dap_cli_server_cmd_add ("block", s_cli_blocks, "Create and explore blockchains",
"New block create, fill and complete commands:"
"block -net <net_name> -chain <chain name> new\n"
"\t\tCreate new block and flush memory if was smth formed before\n\n"
@@ -297,7 +297,7 @@ static int s_cli_parse_cmd_hash(char ** a_argv, int a_arg_index, int a_argc, cha
assert(a_datum_hash);
const char *l_datum_hash_str = NULL;
- dap_chain_node_cli_find_option_val(a_argv, a_arg_index, a_argc, a_param, &l_datum_hash_str);
+ dap_cli_server_cmd_find_option_val(a_argv, a_arg_index, a_argc, a_param, &l_datum_hash_str);
return dap_chain_hash_fast_from_str(l_datum_hash_str, a_datum_hash);
}
@@ -386,7 +386,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
const char *l_chain_type = dap_chain_net_get_type(l_chain);
if (!strstr(l_chain_type, "block_")){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Type of chain %s is not block. This chain with type %s is not supported by this command",
l_chain->name, l_chain_type);
return -42;
@@ -396,9 +396,9 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
// Parse commands
for (size_t i=0; i<l_subcmd_str_count; i++){
- int l_opt_idx = dap_chain_node_cli_check_option(a_argv, arg_index,a_argc, l_subcmd_strs[i]);
+ int l_opt_idx = dap_cli_server_cmd_check_option(a_argv, arg_index,a_argc, l_subcmd_strs[i]);
if( l_opt_idx >= 0 ){
- dap_chain_node_cli_find_option_val(a_argv, l_opt_idx, a_argc, l_subcmd_strs[i], &l_subcmd_str_args[i] );
+ dap_cli_server_cmd_find_option_val(a_argv, l_opt_idx, a_argc, l_subcmd_strs[i], &l_subcmd_str_args[i] );
l_subcmd = i;
l_subcmd_str = l_subcmd_strs[i];
l_subcmd_str_arg = l_subcmd_str_args[i];
@@ -430,7 +430,7 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
s_cli_parse_cmd_hash(a_argv,arg_index,a_argc,a_str_reply,"-datum", &l_datum_hash );
l_blocks->block_new_size=dap_chain_block_datum_del_by_hash( &l_blocks->block_new, l_blocks->block_new_size, &l_datum_hash );
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Error! Can't delete datum from hash because no forming new block! Check pls you role, it must be MASTER NODE or greater");
ret = -12;
}
@@ -453,20 +453,20 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
char * l_datums_datum_hash_str = dap_chain_hash_fast_to_str_new(&l_datum_hash);
if ( dap_global_db_del_sync( l_gdb_group_mempool, l_datums_datum_hash_str) == 0 ){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Converted datum %s from mempool to event in the new forming round ",
l_datums_datum_hash_str);
DAP_DELETE(l_datums_datum_hash_str);
ret = 0;
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't delete datum %s from mempool after conversion to event in the new forming round ",
l_datums_datum_hash_str);
ret = 1;
}
}
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't convert datum %s from mempool to the new forming block's section ", l_subcmd_str_arg);
ret = -13;
}
@@ -570,12 +570,12 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
l_sign_size, l_pkey_hash_str, l_addr_str );
DAP_DELETE( l_pkey_hash_str );
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp,false);
ret=0;
}
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Can't find block %s ", l_subcmd_str_arg);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Can't find block %s ", l_subcmd_str_arg);
ret=-10;
}
}break;
@@ -596,13 +596,13 @@ static int s_cli_blocks(int a_argc, char ** a_argv, char **a_str_reply)
}
pthread_rwlock_unlock(&PVT(l_blocks)->rwlock);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp,false);
}break;
case SUBCMD_UNDEFINED: {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Undefined block subcommand \"%s\" ",
l_subcmd_str);
ret=-11;
diff --git a/modules/type/dag/dap_chain_cs_dag.c b/modules/type/dag/dap_chain_cs_dag.c
index 53fffa3538ca807619e32664c85ec7d01daecee7..786f7557ea0165ca39b2865a25b6b0426109a819 100644
--- a/modules/type/dag/dap_chain_cs_dag.c
+++ b/modules/type/dag/dap_chain_cs_dag.c
@@ -141,7 +141,7 @@ int dap_chain_cs_dag_init(void)
s_seed_mode = dap_config_get_item_bool_default(g_config,"general","seed_mode",false);
s_debug_more = dap_config_get_item_bool_default(g_config,"dag","debug_more",false);
- dap_chain_node_cli_cmd_item_create ("dag", s_cli_dag, "DAG commands",
+ dap_cli_server_cmd_add ("dag", s_cli_dag, "DAG commands",
"dag event create -net <net_name> -chain <chain_name> -datum <datum hash> [-H {hex | base58(default)}]\n"
"\tCreate event from datum mempool element\n\n"
"dag event cancel -net <net_name> -chain <chain_name> -event <event hash>\n"
@@ -1286,16 +1286,16 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
dap_chain_cs_dag_t * l_dag = NULL;
dap_chain_net_t * l_net = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, arg_index + 1, "event", &l_event_cmd_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, arg_index + 1, "round", &l_round_cmd_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, arg_index + 1, "event", &l_event_cmd_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, arg_index + 1, "round", &l_round_cmd_str);
arg_index++;
const char * l_hash_out_type = NULL;
- dap_chain_node_cli_find_option_val(argv, 0, argc, "-H", &l_hash_out_type);
+ dap_cli_server_cmd_find_option_val(argv, 0, argc, "-H", &l_hash_out_type);
if(!l_hash_out_type)
l_hash_out_type = "hex";
if(dap_strcmp(l_hash_out_type,"hex") && dap_strcmp(l_hash_out_type,"base58")) {
- dap_chain_node_cli_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "invalid parameter -H, valid values: -H <hex | base58>");
return -1;
}
@@ -1311,7 +1311,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
const char *l_chain_type = dap_chain_net_get_type(l_chain);
if (!strstr(l_chain_type, "dag_")){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Type of chain %s is not dag. This chain with type %s is not supported by this command",
l_chain->name, l_chain_type);
return -42;
@@ -1321,7 +1321,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
if ( l_round_cmd_str ) {
if ( strcmp(l_round_cmd_str,"complete") == 0 ){
const char * l_cmd_mode_str = NULL;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-mode", &l_cmd_mode_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-mode", &l_cmd_mode_str);
bool l_verify_only = false;
if ( dap_strcmp(l_cmd_mode_str,"verify only") == 0 ){
l_verify_only = true;
@@ -1383,7 +1383,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
// Cleaning up
dap_global_db_objs_delete(l_objs, l_objs_size);
- dap_chain_node_cli_set_reply_text(a_str_reply,l_str_ret_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply,l_str_ret_tmp->str);
dap_string_free(l_str_ret_tmp,false);
// Spread new mempool changes and dag events in network - going to SYNC_ALL
@@ -1393,7 +1393,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
char *l_datum_hash_hex_str = NULL;
char *l_datum_hash_base58_str = NULL;
if ( strcmp( l_event_cmd_str, "create" ) == 0 ) {
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-datum", &l_datum_hash_str);
// datum hash may be in hex or base58 format
if(l_datum_hash_str) {
@@ -1408,18 +1408,18 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
}
l_event_subcmd = SUBCMD_EVENT_CREATE;
} else if ( strcmp( l_event_cmd_str, "cancel" ) == 0 ) {
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
l_event_subcmd = SUBCMD_EVENT_CANCEL;
} else if ( strcmp( l_event_cmd_str, "list" ) == 0 ) {
l_event_subcmd = SUBCMD_EVENT_LIST;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-from", &l_from_events_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-from", &l_from_events_str);
} else if ( strcmp( l_event_cmd_str,"dump") == 0 ) {
l_event_subcmd = SUBCMD_EVENT_DUMP;
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-from", &l_from_events_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-from", &l_from_events_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
} else if ( strcmp( l_event_cmd_str, "sign" ) == 0 ) {
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
- dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-cert", &l_cert_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-event", &l_event_hash_str);
+ dap_cli_server_cmd_find_option_val(argv, arg_index, argc, "-cert", &l_cert_str);
l_event_subcmd = SUBCMD_EVENT_SIGN;
} else {
l_event_subcmd = SUBCMD_UNDEFINED;
@@ -1458,13 +1458,13 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
dap_hash_fast(l_datums[i],dap_chain_datum_size(l_datums[i]),&l_datum_hash);
char * l_datums_datum_hash_str = dap_chain_hash_fast_to_str_new(&l_datum_hash);
if ( dap_global_db_del_sync(l_gdb_group_mempool, l_datums_datum_hash_str ) ==0 ){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Converted datum %s from mempool to event in the new forming round ",
l_datums_datum_hash_str);
DAP_DELETE(l_datums_datum_hash_str);
ret = 0;
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't delete datum %s from mempool after conversion to event in the new forming round ",
l_datums_datum_hash_str);
ret = 1;
@@ -1472,11 +1472,11 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
}
}else {
if(!dap_strcmp(l_hash_out_type,"hex")){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't convert datum %s from mempool to event in the new forming round ", l_datum_hash_hex_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Warning! Can't convert datum %s from mempool to event in the new forming round ", l_datum_hash_base58_str);
}
ret = -12;
@@ -1491,12 +1491,12 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
char * l_gdb_group_events = DAP_CHAIN_CS_DAG(l_chain)->gdb_group_events_round_new;
if ( dap_global_db_del_sync(l_gdb_group_events, l_event_hash_hex_str ) ==0){
if(!dap_strcmp(l_hash_out_type, "hex")){
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Successfuly removed event %s from the new forming round ",
l_event_hash_hex_str);
}
else{
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Successfuly removed event %s from the new forming round ",
l_event_hash_base58_str);
}
@@ -1513,26 +1513,26 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
if(!dap_strcmp(l_hash_out_type, "hex")) {
log_it(L_WARNING, "Dropped event %s from chains! Hope you know what are you doing!",
l_event_hash_hex_str);
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Dropped event 0x%s from chains! Hope you know what are you doing! ",
l_event_hash_hex_str);
}
else {
log_it(L_WARNING, "Dropped event %s from chains! Hope you know what are you doing!",
l_event_hash_base58_str);
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Dropped event 0x%s from chains! Hope you know what are you doing! ",
l_event_hash_base58_str);
}
dap_chain_save_all(l_chain);
}else {
if(!dap_strcmp(l_hash_out_type, "hex")) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't remove event 0x%s ",
l_event_hash_hex_str);
}
else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't remove event 0x%s ",
l_event_hash_base58_str);
}
@@ -1569,7 +1569,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
l_event = l_event_item->event;
else {
ret = -23;
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find event %s in events_last table\n", l_event_hash_str);
break;
}
@@ -1583,7 +1583,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
l_event_size = l_event_item->event_size;
} else {
ret = -24;
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find event %s in events table\n", l_event_hash_str);
break;
}
@@ -1596,20 +1596,20 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
l_event = l_event_item->event;
else {
ret = -23;
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find event %s in threshold table\n", l_event_hash_str);
break;
}
}else {
ret = -22;
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Wrong events_from option \"%s\", need one of variant: events, round.new, events_lasts, round.0x0123456789ABCDEF, threshold", l_from_events_str);
break;
}
} else {
ret = -21;
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"No events_from option");
break;
}
@@ -1688,11 +1688,11 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
}
dap_chain_datum_dump(l_str_tmp, l_datum, l_hash_out_type);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp,false);
ret=0;
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find event 0x%s in the new forming round ",
l_event_hash_str);
ret=-10;
@@ -1728,7 +1728,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
ret = -2;
}
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp,false);
}else if (l_from_events_str && (strcmp(l_from_events_str,"events") == 0) ){
dap_string_t * l_str_tmp = dap_string_new(NULL);
@@ -1746,7 +1746,7 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
dap_string_append_printf(l_str_tmp,"%s.%s have total %zu events :\n",
l_net->pub.name, l_chain->name, l_events_count);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp,false);
}else if (l_from_events_str && (strcmp(l_from_events_str,"threshold") == 0) ){
dap_string_t * l_str_tmp = dap_string_new(NULL);
@@ -1765,11 +1765,11 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
pthread_rwlock_unlock(&PVT(l_dag)->events_rwlock);
dap_string_append_printf(l_str_tmp,"%s.%s have total %zu events in threshold :\n",
l_net->pub.name, l_chain->name, l_events_count);
- dap_chain_node_cli_set_reply_text(a_str_reply, l_str_tmp->str);
+ dap_cli_server_cmd_set_reply_text(a_str_reply, l_str_tmp->str);
dap_string_free(l_str_tmp,false);
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply, "Undefined events source for listing ");
+ dap_cli_server_cmd_set_reply_text(a_str_reply, "Undefined events source for listing ");
ret=-14;
}
@@ -1796,12 +1796,12 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
if (dap_chain_cs_dag_event_gdb_set(l_dag, l_event_new_hash_hex_str, l_event,
l_event_size_new, l_round_item)) {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Added new sign with cert \"%s\", event %s placed back in round.new\n",
l_cert_str, l_event_new_hash_base58_str ?
l_event_new_hash_base58_str : l_event_new_hash_hex_str);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"GDB Error: Can't place event %s with new sign back in round.new\n",
l_event_new_hash_base58_str ? l_event_new_hash_base58_str : l_event_new_hash_hex_str);
ret = -31;
@@ -1810,34 +1810,34 @@ static int s_cli_dag(int argc, char ** argv, char **a_str_reply)
DAP_DELETE(l_event_new_hash_hex_str);
DAP_DEL_Z(l_event_new_hash_base58_str);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't sign event in round.new\n",
l_event_hash_str);
ret=-1;
}
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"No valid certificate provided for event signing\n",
l_event_hash_str);
ret = -50;
}
DAP_DELETE(l_round_item);
} else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Can't find event in round.new - only place where could be signed the new event\n",
l_event_hash_str);
ret = -30;
}
} break;
case SUBCMD_UNDEFINED: {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Undefined event subcommand \"%s\" ",
l_event_cmd_str);
ret=-11;
}
}
}else {
- dap_chain_node_cli_set_reply_text(a_str_reply,
+ dap_cli_server_cmd_set_reply_text(a_str_reply,
"Undefined subcommand");
ret = -13;
}