From e20e4df9fb40f0177c062755af62a517d59607d6 Mon Sep 17 00:00:00 2001
From: Dmtiriy Gerasimov <naeper@demlabs.net>
Date: Thu, 9 May 2019 14:13:23 +0700
Subject: [PATCH] [*] Command refactoring [+] Token issue commands [*] Removed
glib dependendcies
---
dap_chain_net.c | 40 ++-
dap_chain_net.h | 20 ++
dap_chain_node.c | 73 ++---
dap_chain_node.h | 19 +-
dap_chain_node_cli.c | 18 +-
dap_chain_node_cli_cmd.c | 592 ++++++++++++++++++++++++++++++---------
dap_chain_node_cli_cmd.h | 15 +-
iputils/iputils.c | 1 -
iputils/ping.c | 1 -
9 files changed, 583 insertions(+), 196 deletions(-)
diff --git a/dap_chain_net.c b/dap_chain_net.c
index f09b3f6dae..757671dee9 100755
--- a/dap_chain_net.c
+++ b/dap_chain_net.c
@@ -66,6 +66,7 @@ typedef struct dap_chain_net_pvt{
typedef struct dap_chain_net_item{
char name [DAP_CHAIN_NET_NAME_MAX];
+ dap_chain_net_id_t net_id;
dap_chain_net_t * chain_net;
UT_hash_handle hh;
} dap_chain_net_item_t;
@@ -74,6 +75,7 @@ typedef struct dap_chain_net_item{
#define PVT_S(a) ( (dap_chain_net_pvt_t *) (void*) a.pvt )
static dap_chain_net_item_t * s_net_items = NULL;
+static dap_chain_net_item_t * s_net_items_ids = NULL;
static size_t s_net_configs_count = 0;
static pthread_cond_t s_net_proc_loop_cond = PTHREAD_COND_INITIALIZER;
@@ -176,7 +178,7 @@ int dap_chain_net_init()
dap_config_get_item_str(l_cfg , "general" , "node-role" )
);
l_net->pub.gdb_groups_prefix = dap_strdup (
- dap_config_get_item_str_default(l_cfg , "dag" , "gdb_groups_prefix","" ) );
+ dap_config_get_item_str_default(l_cfg , "general" , "gdb_groups_prefix","" ) );
// UTXO model
@@ -270,7 +272,9 @@ int dap_chain_net_init()
snprintf(l_net_item->name,sizeof (l_net_item->name),"%s"
,dap_config_get_item_str(l_cfg , "general" , "name" ));
l_net_item->chain_net = l_net;
+ l_net_item->net_id.uint64 = l_net->pub.id.uint64;
HASH_ADD_STR(s_net_items,name,l_net_item);
+ HASH_ADD(hh,s_net_items_ids,net_id,sizeof ( l_net_item->net_id),l_net_item);
// Start the proc thread
s_net_proc_start(l_net);
@@ -311,6 +315,23 @@ dap_chain_net_t * dap_chain_net_by_name( const char * a_name)
return NULL;
}
+/**
+ * @brief dap_chain_net_by_id
+ * @param a_id
+ * @return
+ */
+dap_chain_net_t * dap_chain_net_by_id( dap_chain_net_id_t a_id)
+{
+ dap_chain_net_item_t * l_net_item = NULL;
+ HASH_FIND(hh,s_net_items,&a_id,sizeof (a_id), l_net_item );
+ if ( l_net_item )
+ return l_net_item->chain_net;
+ else
+ return NULL;
+
+}
+
+
/**
* @brief dap_chain_net_id_by_name
* @param a_name
@@ -325,6 +346,23 @@ dap_chain_net_id_t dap_chain_net_id_by_name( const char * a_name)
return l_ret;
}
+/**
+ * @brief dap_chain_net_get_chain_by_name
+ * @param l_net
+ * @param a_name
+ * @return
+ */
+dap_chain_t * dap_chain_net_get_chain_by_name( dap_chain_net_t * l_net, const char * a_name)
+{
+ dap_chain_t * l_chain;
+ DL_FOREACH(l_net->pub.chains, l_chain){
+ if(strcmp(l_chain->name,a_name) == 0)
+ return l_chain;
+ }
+ return NULL;
+}
+
+
void dap_chain_net_proc_datapool (dap_chain_net_t * a_net)
{
diff --git a/dap_chain_net.h b/dap_chain_net.h
index 948db479f9..7090f1cff1 100755
--- a/dap_chain_net.h
+++ b/dap_chain_net.h
@@ -24,6 +24,7 @@
#pragma once
#include <stdint.h>
+#include <string.h>
#include "dap_chain_common.h"
#include "dap_chain.h"
@@ -53,4 +54,23 @@ void dap_chain_net_delete( dap_chain_net_t * a_net);
void dap_chain_net_proc_datapool (dap_chain_net_t * a_net);
dap_chain_net_t * dap_chain_net_by_name( const char * a_name);
+dap_chain_net_t * dap_chain_net_by_id( dap_chain_net_id_t a_id);
dap_chain_net_id_t dap_chain_net_id_by_name( const char * a_name);
+
+dap_chain_t * dap_chain_net_get_chain_by_name( dap_chain_net_t * l_net, const char * a_name);
+
+/**
+ * @brief dap_chain_net_get_gdb_group_mempool
+ * @param l_chain
+ * @return
+ */
+static inline char * dap_chain_net_get_gdb_group_mempool(dap_chain_t * l_chain)
+{
+ dap_chain_net_t * l_net = dap_chain_net_by_id(l_chain->net_id);
+ const char c_mempool_group_str[]="mempool";
+ size_t l_ret_size = strlen( l_net->pub.gdb_groups_prefix ) + 1 +
+ strlen( l_chain->name)+1+strlen(c_mempool_group_str)+1;
+ char * l_ret = DAP_NEW_Z_SIZE(char, l_ret_size);
+ snprintf( l_ret,l_ret_size,"%s.%s.%s",l_net->pub.gdb_groups_prefix,l_chain->name,c_mempool_group_str);
+ return l_ret;
+}
diff --git a/dap_chain_node.c b/dap_chain_node.c
index b35dfd1885..f1cee2def4 100755
--- a/dap_chain_node.c
+++ b/dap_chain_node.c
@@ -26,6 +26,7 @@
#include "dap_hash.h"
#include "rand/dap_rand.h"
#include "dap_chain_net.h"
+#include "dap_chain_global_db.h"
#include "dap_chain_node.h"
#define LOG_TAG "chain_node"
@@ -56,66 +57,40 @@ bool dap_chain_node_check_addr(dap_chain_node_addr_t *addr, dap_chain_cell_id_t
{
bool ret = false;
if(!addr || !shard_id)
- return ret;
- // generate new address by shard_id
- dap_chain_node_addr_t *tmp_addr = dap_chain_node_gen_addr(shard_id);
- if(tmp_addr) {
-
- if((uint32_t) addr->uint64 == (uint32_t) tmp_addr->uint64)
- ret = true;
- DAP_DELETE(tmp_addr);
- }
+ ret= false;
+
return ret;
}
/**
- * Convert binary data to binhex encoded data.
- *
- * out output buffer, must be twice the number of bytes to encode.
- * len is the size of the data in the in[] buffer to encode.
- * return the number of bytes encoded, or -1 on error.
+ * Register alias in base
*/
-int bin2hex0(char *out, const unsigned char *in, int len)
+bool dap_chain_node_alias_register(const char *alias, dap_chain_node_addr_t *addr)
{
- int ct = len;
- static char hex[] = "0123456789ABCDEF";
- if(!in || !out || len < 0)
- return -1;
- // hexadecimal lookup table
- while(ct-- > 0)
- {
- *out++ = hex[*in >> 4];
- *out++ = hex[*in++ & 0x0F];
- }
- return len;
+ const char *a_key = alias;
+// char a_value[2 * sizeof(dap_chain_node_addr_t) + 1];
+// if(bin2hex(a_value, (const unsigned char *) addr, sizeof(dap_chain_node_addr_t)) == -1)
+// return false;
+// a_value[2 * sizeof(dap_chain_node_addr_t)] = '\0';
+ bool res = dap_chain_global_db_gr_set(a_key, (const uint8_t*) addr, sizeof(dap_chain_node_addr_t), GROUP_ALIAS);
+ return res;
}
/**
- * Convert binhex encoded data to binary data
- *
- * len is the size of the data in the in[] buffer to decode, and must be even.
- * out outputbuffer must be at least half of "len" in size.
- * The buffers in[] and out[] can be the same to allow in-place decoding.
- * return the number of bytes encoded, or -1 on error.
+ * Delete alias from base
*/
-int hex2bin0(char *out, const unsigned char *in, int len)
+bool dap_chain_node_alias_delete(const char *alias)
{
- // '0'-'9' = 0x30-0x39
- // 'a'-'f' = 0x61-0x66
- // 'A'-'F' = 0x41-0x46
- int ct = len;
- if(!in || !out || len < 0 || (len & 1))
- return -1;
- while(ct > 0)
- {
- char ch1 = ((*in >= 'a') ? (*in++ - 'a' + 10) : ((*in >= 'A') ? (*in++ - 'A' + 10) : (*in++ - '0'))) << 4;
- char ch2 = ((*in >= 'a') ? (*in++ - 'a' + 10) : ((*in >= 'A') ? (*in++ - 'A' + 10) : (*in++ - '0'))); // ((*in >= 'A') ? (*in++ - 'A' + 10) : (*in++ - '0'));
- *out++ = ch1 + ch2;
- ct -= 2;
- }
- return len;
+ const char *a_key = alias;
+ bool res = dap_chain_global_db_gr_del(a_key, GROUP_ALIAS);
+ return res;
}
+
+
+
+
+
/**
* Calculate size of struct dap_chain_node_info_t
*/
@@ -126,6 +101,10 @@ size_t dap_chain_node_info_get_size(dap_chain_node_info_t *node_info)
return (sizeof(dap_chain_node_info_t) + node_info->hdr.links_number * sizeof(dap_chain_node_addr_t));
}
+
+
+
+
/**
* Serialize dap_chain_node_info_t
* size[out] - length of output string
diff --git a/dap_chain_node.h b/dap_chain_node.h
index e9f41c01e2..6f73b44fb5 100755
--- a/dap_chain_node.h
+++ b/dap_chain_node.h
@@ -119,23 +119,8 @@ dap_chain_node_addr_t* dap_chain_node_gen_addr(dap_chain_cell_id_t *shard_id);
*/
bool dap_chain_node_check_addr(dap_chain_node_addr_t *addr, dap_chain_cell_id_t *shard_id);
-/**
- * Convert binary data to binhex encoded data.
- *
- * out output buffer, must be twice the number of bytes to encode.
- * len is the size of the data in the in[] buffer to encode.
- * return the number of bytes encoded, or -1 on error.
- */
-int bin2hex(char *out, const unsigned char *in, int len);
-/**
- * Convert binhex encoded data to binary data
- *
- * len is the size of the data in the in[] buffer to decode, and must be even.
- * out outputbuffer must be at least half of "len" in size.
- * The buffers in[] and out[] can be the same to allow in-place decoding.
- * return the number of bytes encoded, or -1 on error.
- */
-int hex2bin(char *out, const unsigned char *in, int len);
+bool dap_chain_node_alias_register(const char *alias, dap_chain_node_addr_t *addr);
+bool dap_chain_node_alias_delete(const char *alias);
diff --git a/dap_chain_node_cli.c b/dap_chain_node_cli.c
index 36c6f46e35..068eec716c 100755
--- a/dap_chain_node_cli.c
+++ b/dap_chain_node_cli.c
@@ -481,8 +481,24 @@ int dap_chain_node_cli_init(dap_config_t * g_config)
"\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 info", "wallet [list | info -addr <addr> -w <wallet_name>]\n");
+
+ // Token commands
+ dap_chain_node_cli_cmd_item_create ("token_decl", com_token_decl, "Token declaration",
+ "token_decl net <net name> chain <chain name> token <token ticker> total_supply <total supply> sign_total <sign total> sign_valid <sign valid> certs <certs list>\n"
+ "\t Declare new token for <netname>:<chain name> with ticker <token ticker>, maximum emission <total supply> and <sign valid> from <sign total> signatures on valid emission\n"
+ "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_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",
- "token_emit addr <addr> tokent <token> certs <cert> emission_value <val>\n");
+ "token_emit net <net name> chain_emission <chain for emission> chain_base_tx <chain for base tx> addr <addr> token <token ticker> certs <cert> emission_value <val>\n");
+
+ // Transaction commands
dap_chain_node_cli_cmd_item_create ("tx_create", com_tx_create, "Make transaction",
"tx_create from_wallet_name <name> to_addr <addr> token <token> value <val> [fee <addr> value_fee <val>]\n" );
dap_chain_node_cli_cmd_item_create ("tx_cond_create", com_tx_cond_create, "Make cond transaction",
diff --git a/dap_chain_node_cli_cmd.c b/dap_chain_node_cli_cmd.c
index 5363263058..c4cc08cf53 100755
--- a/dap_chain_node_cli_cmd.c
+++ b/dap_chain_node_cli_cmd.c
@@ -22,17 +22,19 @@
along with any DAP based project. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <sys/types.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <errno.h>
#include <assert.h>
-#include <glib.h>
#include <time.h>
-#include <ctype.h> // for isspace()
-#include <arpa/inet.h>
-#include <netinet/in.h>
+#include <ctype.h>
+#include <dirent.h>
#include "iputils/iputils.h"
#include "dap_string.h"
@@ -62,56 +64,12 @@
#define LOG_TAG "chain_node_cli_cmd"
-/**
- * Convert string to digit
- */
-static void digit_from_string(const char *num_str, uint8_t *raw, size_t raw_len)
-{
- if(!num_str)
- return;
- uint64_t val;
- if(!strncasecmp(num_str, "0x", 2)) {
- val = strtoull(num_str + 2, NULL, 16);
- }
- else {
- val = strtoull(num_str, NULL, 10);
- }
- // for LITTLE_ENDIAN (Intel), do nothing, otherwise swap bytes
- val = le64toh(val);
- memset(raw, 0, raw_len);
- memcpy(raw, &val, min(raw_len, sizeof(uint64_t)));
-}
-
-/**
- * Add alias in base
- */
-static bool add_alias(const char *alias, dap_chain_node_addr_t *addr)
-{
- const char *a_key = alias;
-// char a_value[2 * sizeof(dap_chain_node_addr_t) + 1];
-// if(bin2hex(a_value, (const unsigned char *) addr, sizeof(dap_chain_node_addr_t)) == -1)
-// return false;
-// a_value[2 * sizeof(dap_chain_node_addr_t)] = '\0';
- bool res = dap_chain_global_db_gr_set(a_key, (const uint8_t*) addr, sizeof(dap_chain_node_addr_t), GROUP_ALIAS);
- return res;
-}
-
-/**
- * Delete alias from base
- */
-static bool del_alias(const char *alias)
-{
- const char *a_key = alias;
- bool res = dap_chain_global_db_gr_del(a_key, GROUP_ALIAS);
- return res;
-}
-
/**
* Find in base addr by alias
*
* return addr, NULL if not found
*/
-dap_chain_node_addr_t* get_name_by_alias(const char *a_alias)
+dap_chain_node_addr_t* dap_chain_node_addr_get_by_alias(const char *a_alias)
{
dap_chain_node_addr_t *l_addr = NULL;
if(!a_alias)
@@ -174,7 +132,7 @@ static dap_chain_node_addr_t* com_global_db_get_addr(dap_chain_node_info_t *node
{
dap_chain_node_addr_t *address = NULL;
if(alias_str && !addr->uint64) {
- address = get_name_by_alias(alias_str);
+ address = dap_chain_node_addr_get_by_alias(alias_str);
}
if(addr->uint64) {
address = DAP_NEW(dap_chain_node_addr_t);
@@ -285,7 +243,7 @@ static int com_global_db_add(dap_chain_node_info_t *node_info, const char *alias
}*/
if(alias_str) {
// add alias
- if(!add_alias(alias_str, &node_info->hdr.address)) {
+ if(!dap_chain_node_alias_register(alias_str, &node_info->hdr.address)) {
log_it(L_WARNING, "can't save alias %s", alias_str);
dap_chain_node_cli_set_reply_text(str_reply, "alias '%s' can't be mapped to addr=0x%lld",
alias_str, node_info->hdr.address.uint64);
@@ -342,10 +300,10 @@ static int com_global_db_del(dap_chain_node_info_t *node_info, const char *alias
while(list)
{
const char *alias = (const char *) list->data;
- del_alias(alias);
+ dap_chain_node_alias_delete(alias);
list = dap_list_next(list);
}
- dap_list_free_full(list_aliases, (DapDestroyNotify) free);
+ dap_list_free_full(list_aliases, (dap_callback_destroyed_t) free);
}
// set text response
dap_chain_node_cli_set_reply_text(str_reply, "node deleted");
@@ -536,7 +494,7 @@ static int com_global_db_dump(dap_chain_node_info_t *a_node_info, const char *al
dap_string_append_printf(aliases_string, "\nalias %s", alias);
list = dap_list_next(list);
}
- dap_list_free_full(list_aliases, (DapDestroyNotify) free);
+ dap_list_free_full(list_aliases, (dap_callback_destroyed_t) free);
}
else
dap_string_append(aliases_string, "\nno aliases");
@@ -789,13 +747,13 @@ int com_global_db(int argc, const char ** argv, char **str_reply)
memset(&node_info, 0, sizeof(dap_chain_node_info_t));
memset(&link, 0, sizeof(dap_chain_node_addr_t));
if(addr_str) {
- digit_from_string(addr_str, node_info.hdr.address.raw, sizeof(node_info.hdr.address.raw));
+ dap_digit_from_string(addr_str, node_info.hdr.address.raw, sizeof(node_info.hdr.address.raw));
}
if(cell_str) {
- digit_from_string(cell_str, node_info.hdr.cell_id.raw, sizeof(node_info.hdr.cell_id.raw)); //DAP_CHAIN_CELL_ID_SIZE);
+ dap_digit_from_string(cell_str, node_info.hdr.cell_id.raw, sizeof(node_info.hdr.cell_id.raw)); //DAP_CHAIN_CELL_ID_SIZE);
}
if(link_str) {
- digit_from_string(link_str, link.raw, sizeof(link.raw));
+ dap_digit_from_string(link_str, link.raw, sizeof(link.raw));
}
switch (cmd_num)
@@ -884,7 +842,7 @@ int com_node(int argc, const char ** argv, char **str_reply)
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-addr", &addr_str);
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "-alias", &alias_str);
- digit_from_string(addr_str, address.raw, sizeof(address.raw));
+ dap_digit_from_string(addr_str, address.raw, sizeof(address.raw));
switch (cmd_num)
{
@@ -893,7 +851,7 @@ int com_node(int argc, const char ** argv, char **str_reply)
if(alias_str) {
if(addr_str) {
// add alias
- if(!add_alias(alias_str, &address))
+ if(!dap_chain_node_alias_register(alias_str, &address))
log_it(L_WARNING, "can't save alias %s", alias_str);
else {
dap_chain_node_cli_set_reply_text(str_reply, "alias mapped successfully");
@@ -914,7 +872,7 @@ int com_node(int argc, const char ** argv, char **str_reply)
case CMD_CONNECT: {
// get address from alias if addr not defined
if(alias_str && !address.uint64) {
- dap_chain_node_addr_t *address_tmp = get_name_by_alias(alias_str);
+ dap_chain_node_addr_t *address_tmp = dap_chain_node_addr_get_by_alias(alias_str);
if(address_tmp) {
memcpy(&address, address_tmp, sizeof(address_tmp));
DAP_DELETE(address_tmp);
@@ -1003,7 +961,7 @@ int com_node(int argc, const char ** argv, char **str_reply)
case CMD_HANDSHAKE: {
// get address from alias if addr not defined
if(alias_str && !address.uint64) {
- dap_chain_node_addr_t *address_tmp = get_name_by_alias(alias_str);
+ dap_chain_node_addr_t *address_tmp = dap_chain_node_addr_get_by_alias(alias_str);
if(address_tmp) {
memcpy(&address, address_tmp, sizeof(address_tmp));
DAP_DELETE(address_tmp);
@@ -1322,18 +1280,18 @@ int com_tx_wallet(int argc, const char ** argv, char **str_reply)
switch (cmd_num) {
// wallet list
case CMD_WALLET_LIST: {
- GDir *l_dir = g_dir_open(c_wallets_path, 0, NULL);
- if(l_dir) {
- const char *l_file = NULL;
- do {
- l_file = g_dir_read_name(l_dir);
- int l_file_len = (l_file) ? strlen(l_file) : 0;
- if(l_file_len > 8 && !g_strcmp0(l_file + l_file_len - 8, ".dwallet")) {
- char *l_file_path_tmp = dap_strdup_printf("%s/%s", c_wallets_path, l_file);
+ DIR * l_dir = opendir(c_wallets_path);
+ if( l_dir ) {
+ struct dirent * l_dir_entry;
+ while((l_dir_entry=readdir(l_dir))!=NULL){
+ const char *l_file_name = l_dir_entry->d_name;
+ size_t l_file_name_len = (l_file_name) ? strlen(l_file_name) : 0;
+ if( (l_file_name_len > 8 )&& ( strcmp(l_file_name + l_file_name_len - 8, ".dwallet") == 0 ) ) {
+ char *l_file_path_tmp = dap_strdup_printf("%s/%s", c_wallets_path, l_file_name);
dap_chain_wallet_t *l_wallet = dap_chain_wallet_open_file(l_file_path_tmp);
if(l_wallet) {
- dap_chain_addr_t *l_addr = (dap_chain_addr_t *) dap_chain_wallet_get_addr(l_wallet);
- char *l_addr_str = dap_chain_addr_to_str((dap_chain_addr_t*) l_addr);
+ dap_chain_addr_t *l_addr = dap_chain_wallet_get_addr(l_wallet);
+ char *l_addr_str = dap_chain_addr_to_str(l_addr);
dap_string_append_printf(l_string_ret, "\nwallet: %s\n", l_wallet->name);
dap_string_append_printf(l_string_ret, "addr: %s\n", (l_addr_str) ? l_addr_str : "-");
DAP_DELETE(l_addr_str);
@@ -1342,8 +1300,7 @@ int com_tx_wallet(int argc, const char ** argv, char **str_reply)
DAP_DELETE(l_file_path_tmp);
}
}
- while(l_file);
- g_dir_close(l_dir);
+ closedir(l_dir);
}
}
break;
@@ -1403,6 +1360,398 @@ int com_tx_wallet(int argc, const char ** argv, char **str_reply)
return 0;
}
+/**
+ * @brief s_values_parse_net_chain
+ * @param argc
+ * @param argv
+ * @param str_reply
+ * @param l_chain
+ * @param l_net
+ * @return
+ */
+int s_values_parse_net_chain(int *a_arg_index,int argc, const char ** argv, char ** a_str_reply,
+ dap_chain_t ** a_chain, dap_chain_net_t ** a_net)
+{
+ const char * l_chain_str = NULL;
+ const char * l_net_str = NULL;
+ // Net name
+ dap_chain_node_cli_find_option_val(argv, *a_arg_index, argc, "net", &l_net_str);
+
+ // Chain name
+ dap_chain_node_cli_find_option_val(argv, *a_arg_index, argc, "chain", &l_chain_str);
+
+ // Select chain network
+ if(!l_net_str) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter 'net'");
+ return -42;
+ }else {
+ 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, "token_create requires parameter 'net' to be valid chain network name");
+ return -43;
+ }
+ }
+
+ // Select chain
+ if(!l_chain_str) {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter 'chain'");
+ return -44;
+ }else {
+ if ( ( *a_chain = dap_chain_net_get_chain_by_name(*a_net, l_chain_str ) ) == NULL ){ // Can't find such chain
+ dap_chain_node_cli_set_reply_text(a_str_reply, "token_create requires parameter 'chain' to be valid chain name in chain net %s",l_net_str);
+ return -45;
+ }
+ }
+ return 0;
+
+}
+
+/**
+ * @brief com_token_decl_sign
+ * @param argc
+ * @param argv
+ * @param str_reply
+ * @return
+ */
+int com_token_decl_sign(int argc, const char ** argv, char ** a_str_reply)
+{
+ int arg_index = 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);
+
+ if ( l_datum_hash_str ){
+ const char * l_certs_str = NULL;
+ dap_chain_cert_t ** l_certs = NULL;
+ size_t l_certs_size = 0;
+ dap_chain_t * l_chain;
+
+ dap_chain_net_t * l_net = NULL;
+
+ if ( s_values_parse_net_chain(&arg_index,argc,argv,a_str_reply,&l_chain, &l_net) < 0 )
+ return -1;
+
+ // Load certs lists
+ size_t l_signs_size = dap_chain_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,
+ "token_create command requres at least one valid certificate to sign the basic transaction of emission");
+ return -7;
+ }
+ size_t l_certs_count = l_certs_size / sizeof(dap_chain_cert_t *);
+
+ char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
+
+ log_it (L_DEBUG, "Requested to sign token declaration %s in gdb://%s with certs %s",
+ l_gdb_group_mempool,l_datum_hash_str, l_certs_str);
+
+ dap_chain_datum_t * l_datum = NULL;
+ size_t l_datum_size = 0;
+ if( (l_datum = (dap_chain_datum_t*) dap_chain_global_db_gr_get(
+ l_datum_hash_str ,&l_datum_size,l_gdb_group_mempool )) != NULL ) {
+
+ // Check if its token declaration
+ if ( l_datum->header.type_id == DAP_CHAIN_DATUM_TOKEN_DECL ){
+ dap_chain_datum_token_t * l_datum_token = (dap_chain_datum_token_t *) l_datum->data;
+ size_t l_datum_token_size = l_datum->header.data_size;
+ size_t l_signs_size = l_datum_token_size - sizeof(l_datum_token->header);
+
+ // Check for signatures, are they all in set and are good enought?
+ size_t l_signs_count = 0;
+
+ for ( size_t l_offset = 0; l_offset < l_signs_size; l_signs_count++ ) {
+ dap_chain_sign_t * l_sign = (dap_chain_sign_t *) l_datum_token->signs + l_offset;
+ l_offset += dap_chain_sign_get_size(l_sign);
+ if ( dap_chain_sign_verify(l_sign,&l_datum_token->header,sizeof (l_datum_token->header) ) != 1 ){
+ log_it(L_WARNING,"Wrong signature for datum_token with key %s in mempool!",l_datum_hash_str );
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s with datum token has wrong signature %u, break process and exit",
+ l_datum_hash_str, l_signs_count+1);
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return -666;
+ }
+ }
+ log_it( L_DEBUG,"Datum % with token declaration: %u signatures are verified well", l_signs_count);
+
+ // Check if all signs are present
+ if ( l_signs_count == l_datum_token->header.signs_total ){
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Datum %s with datum token has all signs on board. Can't add anything in it");
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return -7;
+ } // Check if more signs that could be (corrupted datum)
+ else if ( l_signs_count > l_datum_token->header.signs_total ){
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Warning! Datum %s with datum token has more signs on board (%u) than its possible to have (%u)!",
+ l_signs_count, l_datum_token->header.signs_total );
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return -8;
+ } // Check if we have enough place to sign the datum token declaration
+ else if ( l_datum_token->header.signs_total - l_signs_count < l_certs_count ){
+ l_datum = DAP_REALLOC(l_datum, l_datum_size+ l_signs_size ); // add place for new signatures
+ size_t l_offset = 0;
+ for ( size_t i = 0 ; i < l_certs_count ; i++ ){
+ dap_chain_sign_t * l_sign = dap_chain_sign_create( l_certs[i]->enc_key,
+ &l_datum_token->header,
+ sizeof (l_datum_token->header), 0 );
+ size_t l_sign_size = dap_chain_sign_get_size(l_sign);
+ if ( l_offset + l_sign_size <= l_signs_size ){
+ memcpy( l_datum_token->signs + l_datum_token_size - sizeof (l_datum_token->header) + l_offset,
+ l_sign,l_sign_size );
+ log_it (L_DEBUG, "Added datum token declaration sign with cert %s", l_certs[i]->name);
+ }
+
+ DAP_DELETE( l_sign);
+ l_offset += l_sign_size;
+ if (l_offset > l_signs_size ){
+ break;
+ }
+ }
+ l_datum_size += l_signs_size;
+
+
+ // Recalc hash, string and place new datum
+
+ // Calc datum's hash
+ dap_chain_hash_fast_t l_key_hash;
+ dap_hash_fast(l_datum,l_datum_size, &l_key_hash);
+ char * l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
+
+ // Add datum to mempool with datum_token hash as a key
+ if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum, l_datum_size,l_gdb_group_mempool )) {
+ // Remove old datum from pool
+ if (dap_chain_global_db_gr_del(l_datum_hash_str,l_gdb_group_mempool) ){
+ dap_chain_node_cli_set_reply_text(a_str_reply, "datum %s produced from %s is replacing the %s in datum pool",
+ l_key_str, l_datum_hash_str,l_datum_hash_str);
+
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return 0;
+ } else {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Warning! Can't remove old datum %s ( new datum %s added normaly in datum pool)",
+ l_datum_hash_str,l_key_str);
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return 1;
+ }
+
+ }
+ else{
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Error! datum %s produced from %s can't be placed in mempool",
+ l_key_str, l_datum_hash_str);
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return -2;
+ }
+
+ } else {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "Error! Not enought place for new signature (%u is left when we need %u signatures)",
+ l_datum_token->header.signs_total - l_signs_count, l_certs_count );
+ return -6;
+ }
+ } else {
+ dap_chain_node_cli_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, "token_decl_sign can't find datum with %s hash in the mempool of %s:%s", l_net->pub.name,l_chain->name);
+ return -5;
+ }
+ }else {
+ dap_chain_node_cli_set_reply_text(a_str_reply, "token_decl_sign need datum <datum hash> argument");
+ return -2;
+ }
+}
+
+
+/**
+ * @brief com_token_decl_list
+ * @param argc
+ * @param argv
+ * @param str_reply
+ * @return
+ */
+int com_mempool_list(int argc, const char ** argv, char ** str_reply)
+{
+ int arg_index = 1;
+ dap_chain_t * l_chain;
+ dap_chain_net_t * l_net = NULL;
+
+ if (s_values_parse_net_chain(&arg_index,argc,argv,str_reply,&l_chain, &l_net) < 0)
+ return -1;
+
+ char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
+}
+
+/**
+ * @brief com_token_decl
+ * @param argc
+ * @param argv
+ * @param str_reply
+ * @return
+ */
+int com_token_decl(int argc, const char ** argv, char ** str_reply)
+{
+ int arg_index = 1;
+ const char *str_tmp = NULL;
+ char *str_reply_tmp = NULL;
+ const char * l_ticker = NULL;
+
+ const char * l_total_supply_str = NULL;
+ uint64_t l_total_supply = 0;
+
+ const char * l_signs_emission_str = NULL;
+ uint16_t l_signs_emission = 0;
+
+ const char * l_signs_total_str = NULL;
+ uint16_t l_signs_total = 0;
+
+
+ const char * l_certs_str = NULL;
+
+ dap_chain_cert_t ** l_certs = NULL;
+ size_t l_certs_size = 0;
+
+ dap_chain_t * l_chain;
+ dap_chain_net_t * l_net = NULL;
+
+ if (s_values_parse_net_chain(&arg_index,argc,argv,str_reply,&l_chain, &l_net) < 0)
+ return -1;
+
+
+
+ // Total supply value
+ dap_chain_node_cli_find_option_val(argv, arg_index, argc, "total_supply", &l_total_supply_str);
+
+ // Token ticker
+ dap_chain_node_cli_find_option_val(argv, arg_index, argc, "token", &l_ticker);
+
+
+ // 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);
+
+ // Signs number thats own emissioncan't find
+ dap_chain_node_cli_find_option_val(argv, arg_index, argc, "signs_total", &l_signs_total_str);
+
+ // Signs minimum number thats need to authorize the emission
+ dap_chain_node_cli_find_option_val(argv, arg_index, argc, "signs_emission", &l_signs_emission_str);
+
+ if(!l_total_supply_str) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'total_supply'");
+ return -11;
+ }else {
+ char * l_tmp = NULL;
+ if ( ( l_total_supply = strtoull(l_total_supply_str,&l_tmp,10) ) == 0 ){
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'total_supply' to be unsigned integer value that fits in 8 bytes");
+ return -2;
+ }
+ }
+
+ // Signs emission
+ if(!l_signs_emission_str) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'signs_emission'");
+ return -3;
+ }else {
+ char * l_tmp = NULL;
+ if ( ( l_signs_emission =(uint16_t) strtol(l_signs_emission_str,&l_tmp,10) ) == 0 ){
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'signs_emission' to be unsigned integer value that fits in 2 bytes");
+ return -4;
+ }
+ }
+
+ // Signs total
+ if(!l_signs_total_str) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'signs_total'");
+ return -31;
+ }else {
+ char * l_tmp = NULL;
+ if ( ( l_signs_total =(uint16_t) strtol(l_signs_total_str,&l_tmp,10) ) == 0 ){
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'signs_total' to be unsigned integer value that fits in 2 bytes");
+ return -41;
+ }
+ }
+
+
+ // Check for ticker
+ if(!l_ticker) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_emit requires parameter 'token'");
+ return -5;
+ }
+
+
+ // Check certs list
+ if(!l_certs_str) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_emit requires parameter 'certs'");
+ return -6;
+ }
+
+ // Load certs lists
+ size_t l_signs_size = dap_chain_cert_parse_str_list(l_certs_str,&l_certs, &l_certs_size);
+ if(!l_certs_size) {
+ dap_chain_node_cli_set_reply_text(str_reply,
+ "token_create command requres at least one valid certificate to sign the basic transaction of emission");
+ return -7;
+ }
+
+ // If we have more certs than we need signs - use only first part of the list
+ if (l_certs_size > l_signs_total )
+ l_certs_size = l_signs_total;
+
+ // Create new datum token
+ dap_chain_datum_token_t * l_datum_token = DAP_NEW_Z_SIZE(dap_chain_datum_token_t,sizeof(l_datum_token->header) +
+ l_signs_size);
+ l_datum_token->header.version = 1; // Current version
+ snprintf(l_datum_token->header.ticker,sizeof(l_datum_token->header.ticker),"%s",l_ticker);
+ l_datum_token->header.total_supply = l_total_supply;
+ l_datum_token->header.signs_total = l_signs_total;
+ l_datum_token->header.signs_valid = l_signs_emission;
+
+ size_t l_signs_offset = 0;
+ // Sign header with all certificates in the list and add signs to the end of ticker declaration
+ // Important:
+ for ( size_t i = 0 ; i < l_certs_size; i++ ){
+ dap_chain_sign_t * l_sign = dap_chain_cert_sign( l_certs[i],
+ l_datum_token,
+ sizeof(l_datum_token->header),
+ 0);
+ size_t l_sign_size = dap_chain_sign_get_size(l_sign);
+ memcpy(l_datum_token->signs+l_signs_offset,l_sign,l_sign_size);
+ DAP_DELETE(l_sign);
+ }
+ dap_chain_datum_t * l_datum = dap_chain_datum_create(DAP_CHAIN_DATUM_TOKEN_DECL,l_datum_token,
+ sizeof (l_datum_token->header)+ l_signs_size);
+ size_t l_datum_size = dap_chain_datum_size(l_datum);
+
+ // Calc datum's hash
+ dap_chain_hash_fast_t l_key_hash;
+ dap_hash_fast(l_datum,l_datum_size, &l_key_hash);
+ char * l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
+
+ // Add datum to mempool with datum_token hash as a key
+ char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
+ if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum, l_datum_size,l_gdb_group_mempool )) {
+ dap_chain_node_cli_set_reply_text(str_reply, "%s\ndatum %s with token %s is placed in datum pool ", str_reply_tmp, l_key_str,l_ticker);
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return 0;
+ }
+ else{
+ dap_chain_node_cli_set_reply_text(str_reply, "%s\ndatum tx %s is not placed in datum pool ", str_reply_tmp, l_key_str);
+ DAP_DELETE(l_datum);
+ DAP_DELETE(l_datum_token);
+ DAP_DELETE(l_gdb_group_mempool);
+ return -2;
+ }
+
+}
+
/**
* @brief com_token_emit
* @param argc
@@ -1426,6 +1775,13 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
dap_chain_cert_t ** l_certs = NULL;
size_t l_certs_size = 0;
+ const char * l_chain_str = NULL;
+ dap_chain_t * l_chain;
+
+ const char * l_net_str = NULL;
+ dap_chain_net_t * l_net = NULL;
+
+
// Wallet address that recieves the emission
dap_chain_node_cli_find_option_val(argv, arg_index, argc, "certs", &l_certs_str);
@@ -1451,7 +1807,7 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
}
if(!l_ticker) {
- dap_chain_node_cli_set_reply_text(str_reply, "token_emit requires parameter 'tokent'");
+ dap_chain_node_cli_set_reply_text(str_reply, "token_emit requires parameter 'token'");
return -3;
}
@@ -1460,52 +1816,8 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
return -4;
}
- int n = 0;
- char * l_certs_tmp_ptrs = NULL;
- char * l_certs_str_dup = strdup(l_certs_str);
- char *l_cert_str = strtok_r(l_certs_str_dup, ",", &l_certs_tmp_ptrs);
- //debug
- {
- const char * l_wallets_path = dap_config_get_item_str(g_config, "general", "wallets_path");
- dap_chain_net_id_t a_net_id;
- a_net_id.uint64 = 0x123;
- dap_chain_sign_type_t l_type;
- l_type.type = 0x0003;// SIG_TYPE_TESLA=0x0003
- dap_chain_wallet_t *wallet1 = dap_chain_wallet_create("tesla_first", l_wallets_path, a_net_id, l_type);
- dap_chain_wallet_t *wallet2 = dap_chain_wallet_create("tesla_second", l_wallets_path, a_net_id, l_type);
- wallet1 = NULL;
- }
-
- // First we just calc items
- while(l_cert_str) {
- l_cert_str = strtok_r(NULL, ",", &l_certs_tmp_ptrs);
- l_certs_size++;
- }
- // init certs array
- l_certs = DAP_NEW_Z_SIZE(dap_chain_cert_t*, l_certs_size);
-
- // Second pass we parse them all
- strcpy(l_certs_str_dup, l_certs_str);
- l_cert_str = strtok_r(l_certs_str_dup, ",", &l_certs_tmp_ptrs);
-
- size_t l_certs_pos = 0;
- while(l_cert_str) {
-
- // trim token whitespace
- if(isspace(l_cert_str[0]))
- l_cert_str = l_cert_str + 1;
- if(isspace(l_cert_str[strlen(l_cert_str) - 1]))
- l_cert_str[strlen(l_cert_str) - 1] = 0;
- l_certs[l_certs_pos] = dap_chain_cert_find_by_name(l_cert_str);
- if(l_certs[l_certs_pos]) {
- l_certs_pos++;
- } else {
- dap_chain_node_cli_set_reply_text(str_reply, "Error: can't find %s certificate", l_cert_str);
- return -6;
- }
- l_cert_str = strtok_r(NULL, ",", &l_certs_tmp_ptrs);
- }
- free(l_certs_str_dup);
+ // Load certs
+ dap_chain_cert_parse_str_list(l_certs_str,&l_certs,&l_certs_size);
if(!l_certs_size) {
dap_chain_node_cli_set_reply_text(str_reply,
@@ -1513,6 +1825,7 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
return -5;
}
+
dap_chain_addr_t * l_addr = dap_chain_str_to_addr(l_addr_str);
if(!l_addr) {
@@ -1520,6 +1833,33 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
return -4;
}
+
+ // Select chain network
+ if(!l_net_str) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'net'");
+ return -42;
+ }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(str_reply, "token_create requires parameter 'net' to be valid chain network name");
+ return -43;
+ }
+ }
+
+ // Select chain
+ if(!l_chain_str) {
+ dap_chain_node_cli_set_reply_text(str_reply, "token_create requires parameter 'chain'");
+ return -44;
+ }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(str_reply, "token_create requires parameter 'chain' to be valid chain name in chain net %s",l_net_str);
+ return -45;
+ }
+ }
+
+ // Get mempool group for this chain
+ char * l_gdb_group_mempool = dap_chain_net_get_gdb_group_mempool(l_chain);
+
+
// Create emission datum
dap_chain_datum_token_emission_t * l_token_emission;
dap_chain_hash_fast_t l_token_emission_hash;
@@ -1540,7 +1880,7 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
// Add to mempool emission token
if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum_emission, l_datum_emission_size
- , dap_config_get_item_str_default(g_config, "mempool", "gdb_group", "datum-pool"))) {
+ , l_gdb_group_mempool)) {
str_reply_tmp = dap_strdup_printf("datum emission %s is placed in datum pool ", l_key_str);
}
else{
@@ -1578,16 +1918,16 @@ int com_token_emit(int argc, const char ** argv, char ** str_reply)
dap_chain_datum_t * l_datum_tx = dap_chain_datum_create(DAP_CHAIN_DATUM_TX, l_tx, l_tx_size);
size_t l_datum_tx_size = dap_chain_datum_size(l_datum_tx);
- // use l_tx hash for compatible with utho hash
- dap_hash_fast(l_tx, l_tx_size, &l_key_hash);//dap_hash_fast(l_datum_tx, l_datum_tx_size, &l_key_hash);
+ // calc datum hash
+ dap_hash_fast(l_datum_tx, l_datum_tx_size, &l_key_hash);
l_key_str = dap_chain_hash_fast_to_str_new(&l_key_hash);
DAP_DELETE(l_tx);
- // Add to mempool emission token
+
+ // Add to mempool tx token
if(dap_chain_global_db_gr_set(l_key_str, (uint8_t *) l_datum_tx, l_datum_tx_size
- , dap_config_get_item_str_default(g_config, "mempool", "gdb_group", "datum-pool"))) {
+ , l_gdb_group_mempool)) {
dap_chain_node_cli_set_reply_text(str_reply, "%s\ndatum tx %s is placed in datum pool ", str_reply_tmp, l_key_str);
- dap_chain_utxo_tx_add((dap_chain_datum_tx_t*)l_datum_tx->data);
}
else{
dap_chain_node_cli_set_reply_text(str_reply, "%s\ndatum tx %s is not placed in datum pool ", str_reply_tmp, l_key_str);
diff --git a/dap_chain_node_cli_cmd.h b/dap_chain_node_cli_cmd.h
index 2c8692aab3..301125aa2e 100755
--- a/dap_chain_node_cli_cmd.h
+++ b/dap_chain_node_cli_cmd.h
@@ -32,7 +32,7 @@
*
* return addr, NULL if not found
*/
-dap_chain_node_addr_t* get_name_by_alias(const char *alias);
+dap_chain_node_addr_t* dap_chain_node_addr_get_by_alias(const char *alias);
@@ -73,8 +73,19 @@ int com_ping(int argc, const char** argv, char **str_reply);
int com_help(int argc, const char ** argv, char **str_reply);
-int com_token_declare ( int argc, const char ** argv, char ** str_reply);
+/**
+ * Token declaration
+ */
+int com_token_decl ( int argc, const char ** argv, char ** str_reply);
+/**
+ * Token declaration add sign
+ */
+int com_token_decl_sign ( int argc, const char ** argv, char ** str_reply);
+
+/**
+ * Token emission
+ */
int com_token_emit (int argc, const char ** argv, char ** str_reply);
diff --git a/iputils/iputils.c b/iputils/iputils.c
index 07184747f1..7d73d1a085 100755
--- a/iputils/iputils.c
+++ b/iputils/iputils.c
@@ -4,7 +4,6 @@
#include <stdio.h>
#include <stdbool.h>
-//#include <glib.h>
#include "dap_common.h"
#include "dap_strfuncs.h"
diff --git a/iputils/ping.c b/iputils/ping.c
index 98a62dc4df..f9f65beada 100755
--- a/iputils/ping.c
+++ b/iputils/ping.c
@@ -56,7 +56,6 @@
#include <netinet/ip_icmp.h>
#include <ifaddrs.h>
#include <math.h>
-//#include <glib.h>
#include "dap_common.h"
#include "dap_strfuncs.h"
--
GitLab