// Supporting functions
void free_msg_head_fields(syslog_msg_head *head) {
if (head->timestamp != NULL) {
cstr_free(head->timestamp);
head->timestamp = NULL;
}
if (head->hostname != NULL) {
cstr_free(head->hostname);
head->hostname = NULL;
}
if (head->appname != NULL) {
cstr_free(head->appname);
head->appname = NULL;
}
if (head->processid != NULL) {
cstr_free(head->processid);
head->processid = NULL;
}
if (head->messageid != NULL) {
cstr_free(head->messageid);
head->messageid = NULL;
}
}
cstring *ser_wallet(const struct wallet *wlt)
{
struct bp_key *key;
cstring *rs = cstr_new_sz(20 * 1024);
/*
* ser "root" record
*/
{
cstring *s_root = ser_wallet_root(wlt);
cstring *recdata = message_str(wlt->chain->netmagic,
"root", s_root->str, s_root->len);
cstr_append_buf(rs, recdata->str, recdata->len);
cstr_free(recdata, true);
cstr_free(s_root, true);
}
/* ser "privkey" records */
wallet_for_each_key(wlt, key) {
void *privkey = NULL;
size_t pk_len = 0;
bp_privkey_get(key, &privkey, &pk_len);
cstring *recdata = message_str(wlt->chain->netmagic,
"privkey",
privkey, pk_len);
free(privkey);
cstr_append_buf(rs, recdata->str, recdata->len);
cstr_free(recdata, true);
}
static void tl_expression_free (struct tl_expression *E) {
cstr_free (&E->text);
cstr_free (&E->right_name);
tl_list_token_free (E->left); E->left = NULL;
tl_list_token_free (E->right); E->right = NULL;
zfree (E, sizeof (*E));
}
static void runtest(bool is_valid, const char *basefn)
{
char *fn = test_filename(basefn);
json_t *tests = read_json(fn);
assert(json_is_array(tests));
unsigned int idx;
for (idx = 0; idx < json_array_size(tests); idx++) {
json_t *test = json_array_get(tests, idx);
assert(json_is_array(test));
const char *scriptSigEnc =
json_string_value(json_array_get(test, 0));
const char *scriptPubKeyEnc =
json_string_value(json_array_get(test, 1));
assert(scriptSigEnc != NULL);
assert(scriptPubKeyEnc != NULL);
cstring *scriptSig = parse_script_str(scriptSigEnc);
cstring *scriptPubKey = parse_script_str(scriptPubKeyEnc);
assert(scriptSig != NULL);
assert(scriptPubKey != NULL);
test_script(is_valid, scriptSig, scriptPubKey,
idx, scriptSigEnc, scriptPubKeyEnc);
cstr_free(scriptSig, true);
cstr_free(scriptPubKey, true);
}
json_decref(tests);
free(fn);
}
static void test_privkey_valid_enc(const char *base58_str,
cstring *payload,
bool compress, bool is_testnet)
{
assert(payload != NULL);
cstring *pl = cstr_new_sz(payload->len + 1);
cstr_append_buf(pl, payload->str, payload->len);
if (compress)
cstr_append_c(pl, 1);
cstring *b58 = base58_encode_check(
is_testnet ? PRIVKEY_ADDRESS_TEST : PRIVKEY_ADDRESS, true,
pl->str, pl->len);
assert(b58 != NULL);
if (strcmp(b58->str, base58_str)) {
fprintf(stderr, "base58: have %s, expected %s\n",
b58->str, base58_str);
assert(!strcmp(b58->str, base58_str));
}
cstr_free(b58, true);
cstr_free(pl, true);
cstr_free(payload, true);
}
void test_examples()
{
cstring *value;
cstring *key;
logdb_log_db *db;
enum logdb_error error = 0;
int create_database = 1;
/* create a new database object */
db = logdb_new();
/* create a database file (will overwrite existing) */
logdb_load(db, "/tmp/test.logdb", create_database, &error);
/* append a record */
value = cstr_new("testkey");
key = cstr_new("somevalue");
/* second parameter NULL means we don't use a transaction */
logdb_append(db, NULL, key, value);
/* flush database (write its state to disk) */
logdb_flush(db);
/* cleanup */
logdb_free(db);
cstr_free(key, true);
cstr_free(value, true);
}
void btc_node_send_version(btc_node *node)
{
if (!node)
return;
/* get new string buffer */
cstring *version_msg_cstr = cstr_new_sz(256);
/* copy socket_addr to p2p addr */
btc_p2p_address fromAddr;
btc_p2p_address_init(&fromAddr);
btc_p2p_address toAddr;
btc_p2p_address_init(&toAddr);
btc_addr_to_p2paddr(&node->addr, &toAddr);
/* create a version message struct */
btc_p2p_version_msg version_msg;
memset(&version_msg, 0, sizeof(version_msg));
/* create a serialized version message */
btc_p2p_msg_version_init(&version_msg, &fromAddr, &toAddr, node->nodegroup->clientstr);
btc_p2p_msg_version_ser(&version_msg, version_msg_cstr);
/* create p2p message */
cstring *p2p_msg = btc_p2p_message_new(node->nodegroup->chainparams->netmagic, BTC_MSG_VERSION, version_msg_cstr->str, version_msg_cstr->len);
/* send message */
btc_node_send(node, p2p_msg);
/* cleanup */
cstr_free(version_msg_cstr, true);
cstr_free(p2p_msg, true);
}
static void test_privkey_valid_dec(const char *base58_str,
cstring *payload,
bool compress, bool is_testnet)
{
assert(payload != NULL);
cstring *pl = cstr_new_sz(payload->len + 1);
cstr_append_buf(pl, payload->str, payload->len);
if (compress)
cstr_append_c(pl, 1);
unsigned char addrtype;
cstring *dec = base58_decode_check(&addrtype, base58_str);
assert(dec != NULL);
if (is_testnet)
assert(addrtype == PRIVKEY_ADDRESS_TEST);
else
assert(addrtype == PRIVKEY_ADDRESS);
if (compress) {
assert(dec->len == 33);
assert(dec->str[32] == 1);
} else
assert(dec->len == 32);
assert(dec->len == pl->len);
assert(memcmp(dec->str, pl->str, pl->len) == 0);
cstr_free(dec, true);
cstr_free(pl, true);
cstr_free(payload, true);
}
static void test_extended_key()
{
printf("TEST: test_extended_key\n");
// Check we get sensible results when parsing some test vector data
struct hd_extended_key pub;
assert(hd_extended_key_init(&pub));
{
cstring *tv1data = base58_decode(s_tv1_m_xpub);
assert(hd_extended_key_deser(&pub, tv1data->str, tv1data->len));
cstr_free(tv1data, true);
}
struct hd_extended_key priv;
assert(hd_extended_key_init(&priv));
{
cstring *tv1data = base58_decode(s_tv1_m_xprv);
assert(hd_extended_key_deser(&priv, tv1data->str, tv1data->len));
cstr_free(tv1data, true);
}
printf("PUB:\n");
print_ek_public(&pub);
printf("PRV:\n");
print_ek_public(&priv);
// Check we get the same codechains
assert(0 == memcmp(pub.chaincode.data, priv.chaincode.data, 32));
hd_extended_key_free(&priv);
hd_extended_key_free(&pub);
}
static void load_json_key(json_t *wallet, struct bp_key *key)
{
json_t *keys_a = json_object_get(wallet, "keys");
assert(json_is_array(keys_a));
json_t *key_o = json_array_get(keys_a, 0);
assert(json_is_object(key_o));
const char *address_str = json_string_value(json_object_get(key_o, "address"));
assert(address_str != NULL);
const char *privkey_address_str = json_string_value(json_object_get(key_o, "privkey_address"));
assert(privkey_address_str);
const char *pubkey_str = json_string_value(json_object_get(key_o, "pubkey"));
assert(pubkey_str != NULL);
const char *privkey_str = json_string_value(json_object_get(key_o, "privkey"));
assert(privkey_str != NULL);
char rawbuf[strlen(privkey_str)];
size_t buf_len = 0;
/* decode privkey */
assert(decode_hex(rawbuf, sizeof(rawbuf), privkey_str, &buf_len) == true);
assert(bp_privkey_set(key, rawbuf, buf_len) == true);
/* decode pubkey */
assert(decode_hex(rawbuf, sizeof(rawbuf), pubkey_str, &buf_len) == true);
void *pk = NULL;
size_t pk_len = 0;
/* verify pubkey matches expected */
assert(bp_pubkey_get(key, &pk, &pk_len) == true);
assert(pk_len == buf_len);
assert(memcmp(rawbuf, pk, pk_len) == 0);
free(pk);
/* verify pubkey hash (bitcoin address) matches expected */
cstring *btc_addr = bp_pubkey_get_address(key, PUBKEY_ADDRESS_TEST);
assert(strlen(address_str) == btc_addr->len);
assert(memcmp(address_str, btc_addr->str, btc_addr->len) == 0);
/* verify the private key address (WIF) */
cstring *privkey_addr = bp_privkey_get_address(key, PRIVKEY_ADDRESS_TEST);
assert(strlen(privkey_address_str) == privkey_addr->len);
assert(memcmp(privkey_address_str, privkey_addr->str, privkey_addr->len) == 0);
cstr_free(privkey_addr, true);
cstr_free(btc_addr, true);
}
void logdb_record_free(logdb_record* rec)
{
if (!rec)
return;
cstr_free(rec->key, true);
cstr_free(rec->value, true);
rec->next = NULL;
rec->prev = NULL;
free(rec);
}
static struct wallet *load_wallet(void)
{
char *passphrase = getenv("PICOCOIN_PASSPHRASE");
if (!passphrase) {
fprintf(stderr, "missing PICOCOIN_PASSPHRASE\n");
return NULL;
}
char *filename = wallet_filename();
if (!filename) {
fprintf(stderr, "wallet: no filename\n");
return NULL;
}
cstring *data = read_aes_file(filename, passphrase, strlen(passphrase),
100 * 1024 * 1024);
if (!data) {
fprintf(stderr, "wallet: missing or invalid\n");
return NULL;
}
struct wallet *wlt = calloc(1, sizeof(*wlt));
if (!wlt) {
fprintf(stderr, "wallet: failed to allocate wallet\n");
cstr_free(data, true);
return NULL;
}
if (!wallet_init(wlt, chain)) {
free(wlt);
cstr_free(data, true);
return NULL;
}
struct const_buffer buf = { data->str, data->len };
if (!deser_wallet(wlt, &buf))
goto err_out;
if (chain != wlt->chain) {
fprintf(stderr, "wallet root: foreign chain detected, aborting load. Try 'chain-set' first.\n");
goto err_out;
}
return wlt;
err_out:
fprintf(stderr, "wallet: invalid data found\n");
wallet_free(wlt);
cstr_free(data, true);
return NULL;
}
static bool read_ek_ser_from_base58(const char *base58,
struct hd_extended_key_serialized *out)
{
cstring *str = base58_decode(base58);
if (str->len == 82) {
memcpy(out->data, str->str, 78);
cstr_free(str, true);
return true;
}
cstr_free(str, true);
return false;
}
int main() {
cstr c = cstr_cat_printf(NULL, "sdsd");
int i;
printf("%d %d %s\n", cstr_used(c), cstr_cap(c), c);
cstr_free(c);
c = cstr_create(0);
for(i = 1; i < 100000; i++)
c = cstr_cat_char(c, i);
printf("cap %d, used %d ", cstr_cap(c), cstr_used(c));
cstr_free(c);
return 0;
}
static void cb_conn_read_cli(struct bufferevent *bev, void *user_data)
{
void* buffer = NULL;
uint32_t buf_len = 0;
struct evbuffer *buf_in = bufferevent_get_input(bev);
cli_cmd_t cmd;
cstr *json = cstr_new();
cli_cmd_init(&cmd);
/* bufferevent_lock(bev); */
/* read data frome buffer in */
buf_len = evbuffer_get_length(buf_in);
buffer = calloc(1, buf_len);
bufferevent_read(bev, buffer, buf_len);
/* bufferevent_unlock(bev); */
log_dbg("recv command: %s", (char*)buffer);
cli_parse(&cmd, (char*)buffer);
cli_cmd_to_json(&cmd, json);
log_dbg("cli response: %s", cstr_body(json));
bufferevent_send(bev, cstr_body(json), cstr_len(json) + 1);
/* put data to addr recv buffer, and translate to command format */
cli_cmd_release(&cmd);
cstr_free(json);
free(buffer);
/* bufferevent_free(bev); */
}
/* cleanup all static data used during compilation */
static void tcc_cleanup(void)
{
int i, n;
if (NULL == tcc_state) {
return;
}
tcc_state = NULL;
/* free -D defines */
free_defines (NULL);
/* free tokens */
n = tok_ident - TOK_IDENT;
for (i = 0; i < n; i++) {
free (table_ident[i]);
}
free (table_ident);
/* free sym_pools */
dynarray_reset (&sym_pools, &nb_sym_pools);
/* string buffer */
cstr_free (&tokcstr);
/* reset symbol stack */
sym_free_first = NULL;
/* cleanup from error/setjmp */
macro_ptr = NULL;
}
void node_periodical_timer(int fd, short event, void *ctx) {
UNUSED(fd);
UNUSED(event);
btc_node *node = (btc_node *)ctx;
uint64_t now = time(NULL);
/* pass data to the callback and give it a chance to cancle the call */
if (node->nodegroup->periodic_timer_cb)
if (!node->nodegroup->periodic_timer_cb(node, &now))
return;
if (node->time_started_con+BTC_CONNECT_TIMEOUT_S < now && ((node->state & NODE_CONNECTING) == NODE_CONNECTING))
{
node->state = 0;
node->time_started_con = 0;
node->state |= NODE_ERRORED;
node->state |= NODE_TIMEOUT;
btc_node_connection_state_changed(node);
}
if ( ((node->state & NODE_CONNECTED) == NODE_CONNECTED) && node->lastping + BTC_PING_INTERVAL_S < now)
{
//time for a ping
uint64_t nonce;
btc_cheap_random_bytes((uint8_t *)&nonce, sizeof(nonce));
cstring *pingmsg = btc_p2p_message_new(node->nodegroup->chainparams->netmagic, BTC_MSG_PING, &nonce, sizeof(nonce));
btc_node_send(node, pingmsg);
cstr_free(pingmsg, true);
node->lastping = now;
}
}
void cstr_split_l(cstring*c,char*data,int size,vector *v)
{
int n,len=0;
cstring *st,*tx;
tx = cstr_new();
cstr_set_c(tx,c);
while(1){
n = cstr_find_l(tx,0,data,size);
/*
if (n == 0){
len = n+size;
cstr_set_l(tx,tx->data+len,tx->size-len);
continue;
}else if (n > -1){
*/
if (n > -1){
st = cstr_new();
cstr_add_l(st,tx->data,n);
vector_add(v,st);
len = n+size;
cstr_set_l(tx,tx->data+len,tx->size-len);
}else{
st = cstr_new();
cstr_add_l(st,tx->data,tx->size);
vector_add(v,st);
break;
}
}
cstr_free(tx);
}
static void test_decode(const char *hexstr, const char *base58_str)
{
size_t hs_len = strlen(hexstr) / 2;
unsigned char *raw = calloc(1, hs_len);
size_t out_len;
bool rc = decode_hex(raw, hs_len, hexstr, &out_len);
if (!rc) {
fprintf(stderr, "raw %p, sizeof(raw) %lu, hexstr %p %s\n",
raw, hs_len, hexstr, hexstr);
assert(rc);
}
cstring *s = base58_decode(base58_str);
if (memcmp(s->str, raw, out_len < s->len ? out_len : s->len)) {
dumphex("decode have", s->str, s->len);
dumphex("decode want", raw, out_len);
assert(memcmp(s->str, raw, out_len) == 0);
}
if (s->len != out_len) {
fprintf(stderr, "decode len: have %u, want %u\n",
(unsigned int) s->len,
(unsigned int) out_len);
dumphex("decode have", s->str, s->len);
dumphex("decode want", raw, out_len);
assert(s->len == out_len);
}
free(raw);
cstr_free(s, true);
}
void bp_tx_sighash(bu256_t *hash, const cstring *scriptCode,
const struct bp_tx *txTo, unsigned int nIn,
int nHashType)
{
if (nIn >= txTo->vin->len) {
// nIn out of range
bu256_set_u64(hash, 1);
return;
}
// Check for invalid use of SIGHASH_SINGLE
if ((nHashType & 0x1f) == SIGHASH_SINGLE) {
if (nIn >= txTo->vout->len) {
// nOut out of range
bu256_set_u64(hash, 1);
return;
}
}
cstring *s = cstr_new_sz(512);
// Serialize only the necessary parts of the transaction being signed
bp_tx_sigserializer(s, scriptCode, txTo, nIn, nHashType);
ser_s32(s, nHashType);
bu_Hash((unsigned char *) hash, s->str, s->len);
cstr_free(s, true);
}
cstring *base58_decode_check(unsigned char *addrtype, const char *s_in)
{
/* decode base58 string */
cstring *s = base58_decode(s_in);
if (!s)
return NULL;
if (s->len < 4)
goto err_out;
/* validate with trailing hash, then remove hash */
unsigned char md32[4];
bu_Hash4(md32, s->str, s->len - 4);
if (memcmp(md32, &s->str[s->len - 4], 4))
goto err_out;
cstr_resize(s, s->len - 4);
/* if addrtype requested, remove from front of data string */
if (addrtype) {
*addrtype = (unsigned char) s->str[0];
cstr_erase(s, 0, 1);
}
return s;
err_out:
cstr_free(s, true);
return NULL;
}
cstring * logdb_record_find_desc(logdb_record* head, struct buffer *key)
{
cstring *found_value = NULL;
cstring *keycstr;
logdb_record *rec;
if (key == NULL)
return NULL;
keycstr = cstr_new_buf(key->p, key->len);
rec = head;
while (rec)
{
if (cstr_equal(rec->key, keycstr))
{
/* found */
found_value = rec->value;
/* found, but deleted */
if (rec->mode == RECORD_TYPE_ERASE)
found_value = NULL;
break;
}
rec = rec->prev;
}
cstr_free(keycstr, true);
return found_value;
}
static void print_from_base58(const char *str)
{
cstring *out_str = base58_decode(str);
/* *out= out_str->str; */
/* *out_len = out_str->len; */
print_n(out_str->str, out_str->len);
cstr_free(out_str, true);
}
void cstr_vector_set(vector *v, int index, void *e)
{
cstring *s;
if (index >= v->count) return;
s = vector_get(v, index);
cstr_free(s);
vector_set(v,index,e);
}
/********************* cleanup routines *********************/
void tl_list_token_free (struct tl_token *L) {
struct tl_token *E, *T;
for (E = L; E != NULL; E = T) {
T = E->next;
cstr_free (&E->text);
zfree (E, sizeof (*E));
}
}
/* connection begins */
static void nc_conn_evt_connected(int fd, short events, void *priv)
{
struct nc_conn *conn = priv;
if ((events & EV_WRITE) == 0) {
fprintf(plog, "net: %s connection timeout\n", conn->addr_str);
goto err_out;
}
int err = 0;
socklen_t len = sizeof(err);
/* check success of connect(2) */
if ((getsockopt(conn->fd, SOL_SOCKET, SO_ERROR, &err, &len) < 0) ||
(err != 0)) {
fprintf(plog, "net: connect %s failed: %s\n",
conn->addr_str, strerror(err));
goto err_out;
}
if (debugging)
fprintf(plog, "net: connected to %s\n", conn->addr_str);
conn->connected = true;
/* clear event used for watching connect(2) */
event_free(conn->ev);
conn->ev = NULL;
/* build and send "version" message */
cstring *msg_data = nc_version_build(conn);
bool rc = nc_conn_send(conn, "version", msg_data->str, msg_data->len);
cstr_free(msg_data, true);
if (!rc) {
fprintf(plog, "net: %s !conn_send\n", conn->addr_str);
goto err_out;
}
/* switch to read-header state */
conn->msg_p = conn->hdrbuf;
/* from message.c #define P2P_HDR_SZ (4 + 12 + 4 + 4)*/
conn->expected = P2P_HDR_SZ;
conn->reading_hdr = true;
if (!nc_conn_read_enable(conn)) {
fprintf(plog, "net: %s read not enabled\n", conn->addr_str);
goto err_out;
}
return;
err_out:
nc_conn_kill(conn);
}
void uconf_file_close(struct uconf_file *file)
{
if (uconf_file_opened(file)) {
UCONF_NO_EINTR(close(file->fd));
file->fd = -1;
cstr_free(file->name);
file->name = NULL;
file->flags = 0;
}
}
void cstr_vector_data_free(vector*v)
{
int i;
cstring *s;
for (i = 0; i < vector_count(v); i++){
s = vector_get(v, i);
cstr_free(s);
}
vector_data_free(v);
}
static cstring *blkdb_ser_rec(struct blkdb *db, const struct blkinfo *bi)
{
cstring *data = ser_blkinfo(bi);
cstring *rs = message_str(db->netmagic, "rec", data->str, data->len);
cstr_free(data, true);
return rs;
}
static void account_free(struct wallet_account *acct)
{
if (!acct)
return;
cstr_free(acct->name, true);
memset(acct, 0, sizeof(*acct));
free(acct);
}
