HASH_AND_INT(ramchain,getblock,blockhash,remoteonly)
{
int32_t len; char hexstr[(sizeof(uint32_t)+sizeof(struct iguana_msgblock))*2+1],*blockstr;
uint8_t serialized[sizeof(uint32_t)+sizeof(struct iguana_msgblock)]; bits256 hash2,txid;
struct iguana_msgblock msg; struct iguana_block *block;
cJSON *retjson = cJSON_CreateObject();
memset(&msg,0,sizeof(msg));
if ( remoteonly == 0 && (block= iguana_blockfind(coin,blockhash)) != 0 )
{
msg.H.version = block->RO.version;
msg.H.merkle_root = block->RO.merkle_root;
msg.H.timestamp = block->RO.timestamp;
msg.H.bits = block->RO.bits;
msg.H.nonce = block->RO.nonce;
msg.txn_count = block->RO.txn_count;
len = iguana_rwblock(1,&hash2,serialized,&msg);
char str[65]; printf("timestamp.%u bits.%u nonce.%u v.%d (%s) len.%d (%ld %ld)\n",block->RO.timestamp,block->RO.bits,block->RO.nonce,block->RO.version,bits256_str(str,hash2),len,sizeof(serialized),sizeof(hexstr));
init_hexbytes_noT(hexstr,serialized,len);
jaddstr(retjson,"result",hexstr);
}
else if ( coin->APIblockstr != 0 )
jaddstr(retjson,"error","already have pending request");
else
{
memset(txid.bytes,0,sizeof(txid));
if ( (blockstr= iguana_APIrequest(coin,blockhash,txid,5)) != 0 )
{
jaddstr(retjson,"result",blockstr);
free(blockstr);
} else jaddstr(retjson,"error","cant find blockhash");
}
return(jprint(retjson,1));
}
char *gecko_headersarrived(struct supernet_info *myinfo,struct iguana_info *virt,char *remoteaddr,uint8_t *data,int32_t datalen,bits256 firsthash2)
{
bits256 hash2,prevhash2; struct iguana_block *block; int32_t height,firstheight,i,len=0,n,num; struct iguana_msgzblock zmsgB; char str[65],str2[65];
num = (int32_t)(datalen / 84);
printf("headers.%s arrived.%d from %s\n",virt->symbol,num,bits256_str(str,firsthash2));
if ( (block= iguana_blockfind("geckohdrs",virt,firsthash2)) != 0 && (firstheight= block->height) >= 0 )
{
gecko_blockhashupdate(virt,firsthash2,firstheight);
prevhash2 = firsthash2;
for (i=0; i<num; i++)
{
if ( (n= iguana_rwblock(myinfo,virt->symbol,virt->chain->zcash,virt->chain->auxpow,virt->chain->hashalgo,0,&hash2,&data[len],&zmsgB,datalen-len)) > 0 )
{
if ( bits256_cmp(zmsgB.zH.prev_block,prevhash2) == 0 )
{
height = (firstheight + i + 1);
gecko_blockhashupdate(virt,hash2,height);
printf("ht.%d %s\n",height,bits256_str(str,hash2));
} else printf("ht.%d non prevhash i.%d %s %s\n",height,i,bits256_str(str,prevhash2),bits256_str(str2,zmsgB.zH.prev_block));
len += n;
prevhash2 = hash2;
}
}
return(clonestr("{\"result\":\"gecko headers processed\"}"));
} else return(clonestr("{\"error\":\"gecko headers couldnt find firsthash2\"}"));
}
int32_t iguana_gentxarray(struct iguana_info *coin,struct OS_memspace *mem,struct iguana_txblock *txdata,int32_t *lenp,uint8_t *data,int32_t recvlen)
{
struct iguana_msgtx *tx; bits256 hash2; struct iguana_msgblock msg; int32_t i,n,len,numvouts,numvins;
memset(&msg,0,sizeof(msg));
len = iguana_rwblock(0,&hash2,data,&msg);
iguana_blockconv(&txdata->block,&msg,hash2,-1);
tx = iguana_memalloc(mem,msg.txn_count*sizeof(*tx),1);
for (i=numvins=numvouts=0; i<msg.txn_count; i++)
{
if ( (n= iguana_rwtx(0,mem,&data[len],&tx[i],recvlen - len,&tx[i].txid,coin->chain->hastimestamp,strcmp(coin->symbol,"VPN")==0)) < 0 )
break;
numvouts += tx[i].tx_out;
numvins += tx[i].tx_in;
len += n;
}
if ( coin->chain->hastimestamp != 0 && len != recvlen && data[len] == (recvlen - len - 1) )
{
//printf("\n>>>>>>>>>>> len.%d vs recvlen.%d [%d]\n",len,recvlen,data[len]);
memcpy(txdata->space,&data[len],recvlen-len);
len += (recvlen-len);
txdata->extralen = (recvlen - len);
} else txdata->extralen = 0;
txdata->recvlen = len;
txdata->numtxids = msg.txn_count;
txdata->numunspents = numvouts;
txdata->numspends = numvins;
return(len);
}
struct iguana_msgtx *iguana_gentxarray(struct iguana_info *coin,int32_t *lenp,struct iguana_block *block,uint8_t *data,int32_t datalen,uint8_t extra[256])
{
struct iguana_msgtx *tx; bits256 hash2; struct iguana_msgblock msg; int32_t i,n,len;
memset(&msg,0,sizeof(msg));
len = iguana_rwblock(0,&hash2,data,&msg);
iguana_convblock(block,&msg,hash2,block->height,block->L.numtxids,block->L.numunspents,block->L.numspends,block->L.PoW);
block->txn_count = msg.txn_count;
block->height = iguana_setdependencies(coin,block);
//printf("iguana_gentxarray block %s prev.(%s): height.%d firsttxidind.%d firstvout.%d firstvin.%d PoW %f numtx.%d\n",bits256_str2(hash2),bits256_str(msg.H.prev_block),block->height,block->L.firsttxidind,block->L.firstvout,block->L.firstvin,block->L.PoW,msg.txn_count);
iguana_convblock(block,&msg,hash2,block->height,block->L.numtxids,block->L.numunspents,block->L.numspends,block->L.PoW);
tx = mycalloc('t',msg.txn_count,sizeof(*tx));
for (i=0; i<msg.txn_count; i++)
{
if ( (n= iguana_rwtx(0,&data[len],&tx[i],datalen - len,&tx[i].txid,block->height,coin->chain->hastimestamp)) < 0 )
break;
len += n;
}
if ( coin->chain->hastimestamp != 0 && len != datalen && data[len] == (datalen - len - 1) )
{
//printf("\n>>>>>>>>>>> len.%d vs datalen.%d [%d]\n",len,datalen,data[len]);
memcpy(extra,&data[len],datalen-len);
len += (datalen-len);
}
*lenp = len;
return(tx);
}
char *iguana_txscan(struct iguana_info *coin,cJSON *json,uint8_t *data,int32_t recvlen,bits256 txid)
{
struct iguana_msgtx tx; bits256 hash2; struct iguana_block block; struct iguana_msgblock msg;
int32_t i,n,len; char *txbytes,vpnstr[64];
memset(&msg,0,sizeof(msg));
vpnstr[0] = 0;
len = iguana_rwblock(0,&hash2,data,&msg);
iguana_blockconv(&block,&msg,hash2,-1);
for (i=0; i<msg.txn_count; i++)
{
if ( (n= iguana_rwmsgtx(coin,0,0,&data[len],recvlen - len,&tx,&tx.txid,vpnstr)) < 0 )
break;
//char str[65]; printf("%d of %d: %s\n",i,msg.txn_count,bits256_str(str,tx.txid));
if ( bits256_cmp(txid,tx.txid) == 0 )
{
if ( (n= iguana_rwmsgtx(coin,0,json,&data[len],recvlen - len,&tx,&tx.txid,vpnstr)) > 0 )
{
txbytes = malloc(n*2+1);
init_hexbytes_noT(txbytes,&data[len],n);
return(txbytes);
}
}
len += n;
}
return(0);
}
int32_t iguana_serialize_block(bits256 *hash2p,uint8_t serialized[sizeof(struct iguana_msgblock)],struct iguana_block *block)
{
struct iguana_msgblock msg;
memset(&msg,0,sizeof(msg));
msg.H.version = block->version;
msg.H.prev_block = block->prev_block;
msg.H.merkle_root = block->merkle_root;
msg.H.timestamp = block->timestamp;
msg.H.bits = block->bits;
msg.H.nonce = block->nonce;
msg.txn_count = block->txn_count;
return(iguana_rwblock(1,hash2p,serialized,&msg));
}
int32_t iguana_headerget(struct iguana_info *coin,uint8_t *serialized,int32_t maxsize,struct iguana_block *block)
{
bits256 checkhash2; struct iguana_msgblock msgB; int32_t len = 0;
iguana_blockunconv(coin->chain->zcash,coin->chain->auxpow,&msgB,block,1);
if ( (len= iguana_rwblock(coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&checkhash2,&serialized[sizeof(struct iguana_msghdr)],&msgB,(int32_t)(maxsize-sizeof(struct iguana_msghdr)))) < 0 )
return(-1);
if ( bits256_cmp(checkhash2,block->RO.hash2) != 0 )
{
char str[65],str2[65];
printf("iguana_peerhdrrequest blockhash.%d error (%s) vs (%s)\n",block->height,bits256_str(str,checkhash2),bits256_str(str2,block->RO.hash2));
return(-1);
}
return(len);
}
int32_t iguana_parser(struct iguana_info *coin,struct iguana_peer *addr,struct iguana_msghdr *H,uint8_t *data,int32_t datalen)
{
int32_t height,i,retval,srvmsg,bloom,intvectors,len= -100; uint64_t nonce,x;
uint32_t type,firsttxidind,firstvout,firstvin; bits256 hash2; double PoW;
bloom = intvectors = srvmsg = -1;
if ( addr != 0 )
{
addr->lastcontact = (uint32_t)time(NULL);
strcpy(addr->lastcommand,H->command);
}
retval = 0;
//printf("%s parse.(%s)\n",addr->ipaddr,H->command);
if ( strcmp(H->command,"version") == 0 )
{
struct iguana_msgversion recvmv;
if ( addr != 0 )
{
len = iguana_rwversion(0,data,&recvmv,addr->ipaddr);
if ( len == datalen )
iguana_gotversion(coin,addr,&recvmv);
//printf("deser.(%s) len.%d datalen.%d\n",recvmv.H.command,len,datalen);
addr->msgcounts.version++;
}
}
else if ( strcmp(H->command,"verack") == 0 )
{
if ( addr != 0 )
{
iguana_gotverack(coin,addr);
addr->msgcounts.verack++;
}
len = 0;
}
else if ( strcmp(H->command,"ping") == 0 )
{
if ( datalen == sizeof(uint64_t) && addr != 0 )
{
len = iguana_rwnum(0,data,sizeof(uint64_t),&nonce);
if ( addr != 0 )
{
//printf("%u got nonce.%llx from %s\n",(uint32_t)time(NULL),(long long)nonce,addr->ipaddr);
iguana_gotping(coin,addr,nonce,data);
addr->msgcounts.ping++;
}
}
}
else if ( strcmp(H->command,"pong") == 0 )
{
len = 0;
if ( datalen == sizeof(uint64_t) )
{
len = iguana_rwnum(0,data,sizeof(uint64_t),&nonce);
iguana_gotpong(coin,addr,nonce);
} else printf("unexpected pong datalen.%d\n",datalen);
if ( len == datalen && addr != 0 )
addr->msgcounts.pong++;
}
else if ( strcmp(H->command,"addr") == 0 )
{
struct iguana_msgaddress A;
len = iguana_rwvarint(0,data,&x);
for (i=0; i<x; i++)
{
memset(&A,0,sizeof(A));
if ( addr != 0 )
len += iguana_rwaddr(0,&data[len],&A,(int32_t)addr->protover);
iguana_gotaddr(coin,addr,&A);
}
if ( len == datalen && addr != 0 )
{
addr->lastgotaddr = (uint32_t)time(NULL);
addr->msgcounts.addr++;
}
//printf("%s -> addr datalen.%d num.%d\n",addr->ipaddr,datalen,(int32_t)x);
}
else if ( strcmp(H->command,"headers") == 0 )
{
struct iguana_msgblock msg; struct iguana_block *blocks; uint32_t n;
len = iguana_rwvarint32(0,data,&n);
if ( n <= IGUANA_MAXINV )
{
blocks = mycalloc('i',1,sizeof(*blocks) * n);
height = -1;
for (i=0; i<n; i++)
{
len += iguana_rwblock(0,&hash2,&data[len],&msg);
if ( i == 0 )
height = iguana_setchainvars(coin,&firsttxidind,&firstvout,&firstvin,&PoW,hash2,msg.H.bits,msg.H.prev_block,msg.txn_count);
iguana_convblock(&blocks[i],&msg,hash2,height,firsttxidind,firstvout,firstvin,PoW);
if ( firsttxidind > 0 )
{
height++;
firsttxidind += blocks[i].txn_count;
PoW += PoW_from_compact(blocks[i].bits,coin->chain->unitval);
}
}
//printf("GOT HEADERS n.%d len.%d\n",n,len);
iguana_gotheadersM(coin,addr,blocks,n);
//myfree(blocks,sizeof(*blocks) * n);
if ( len == datalen && addr != 0 )
addr->msgcounts.headers++;
} else printf("got unexpected n.%d for headers\n",n);
}
else if ( strcmp(H->command,"tx") == 0 )
{
struct iguana_msgtx *tx;
tx = mycalloc('u',1,sizeof(*tx));
len = iguana_rwtx(0,data,tx,datalen,&tx->txid,-1,coin->chain->hastimestamp);
if ( len == datalen && addr != 0 )
{
iguana_gotunconfirmedM(coin,addr,tx,data,datalen);
printf("tx datalen.%d\n",datalen);
addr->msgcounts.tx++;
}
}
else if ( strcmp(H->command,"block") == 0 )
{
struct iguana_block *block; struct iguana_msgtx *tx; uint8_t extra[256];
block = mycalloc('b',1,sizeof(*block));
memset(extra,0,sizeof(extra));
tx = iguana_gentxarray(coin,&len,block,data,datalen,extra);
if ( len == datalen )
{
if ( addr != 0 )
{
if ( len == datalen )
addr->msgcounts.block++;
//addr->OV.reqrecv += datalen;
//printf("%s gotblock.%d datalen.%d last.[%02x]\n",addr->ipaddr,block->height,datalen,data[len-1]);
}
iguana_gotblockM(coin,addr,block,tx,block->txn_count,data,datalen,extra);
} else printf("parse error block txn_count.%d, len.%d vs datalen.%d\n",block->txn_count,len,datalen);
//if ( tx != 0 )
// iguana_freetx(tx,block->txn_count);
//myfree(block,sizeof(*block));
}
else if ( strcmp(H->command,"reject") == 0 )
{
for (i=0; i<datalen; i++)
printf("%02x ",data[i]);
printf("reject.(%s) datalen.%d\n",data+1,datalen);
len = datalen;
if ( len == datalen && addr != 0 )
addr->msgcounts.reject++;
}
else if ( strcmp(H->command,"alert") == 0 )
{
for (i=0; i<datalen; i++)
printf("%02x ",data[i]);
printf("alert.(%s)\n",data+1);
len = datalen;
if ( len == datalen && addr != 0 )
addr->msgcounts.alert++;
}
else if ( addr != 0 )
{
if ( strcmp(H->command,"inv") == 0 )
intvectors = 'I', addr->msgcounts.inv++;
else if ( strcmp(H->command,"notfound") == 0 ) // for servers
intvectors = 'N', addr->msgcounts.notfound++;
else if ( strcmp(H->command,"getdata") == 0 ) // for servers
intvectors = srvmsg = 'D', addr->msgcounts.getdata++;
else if ( strcmp(H->command,"getblocks") == 0 ) // for servers
srvmsg = 'B', addr->msgcounts.getblocks++;
else if ( strcmp(H->command,"getheaders") == 0 ) // for servers
srvmsg = 'H', addr->msgcounts.getheaders++;
else if ( strcmp(H->command,"getaddr") == 0 ) // for servers
srvmsg = 'A', addr->msgcounts.getaddr++;
else if ( strcmp(H->command,"mempool") == 0 ) // for servers
srvmsg = 'M', addr->msgcounts.mempool++;
else if ( strcmp(H->command,"filterload") == 0 ) // for bloom
bloom = 'L', addr->msgcounts.filterload++;
else if ( strcmp(H->command,"filteradd") == 0 ) // for bloom
bloom = 'A', addr->msgcounts.filteradd++;
else if ( strcmp(H->command,"filterclear") == 0 ) // for bloom
bloom = 'C', addr->msgcounts.filterclear++;
else if ( strcmp(H->command,"merkleblock") == 0 ) // for bloom
bloom = 'M', addr->msgcounts.merkleblock++;
}
if ( bloom >= 0 || srvmsg >= 0 )
len = datalen; // just mark as valid
if ( intvectors >= 0 )
{
bits256 *txids=0,*blockhashes=0,hash; int32_t n,m;
len = n = m = 0;
len += iguana_rwvarint(0,&data[len],&x);
for (i=0; i<x; i++)
{
len += iguana_rwnum(0,&data[len],sizeof(uint32_t),&type);
len += iguana_rwbignum(0,&data[len],sizeof(bits256),hash.bytes);
if ( type == MSG_TX )
{
if ( txids == 0 )
txids = mycalloc('t',(int32_t)x,sizeof(*txids));
txids[m++] = hash;
if ( (rand() % 1000) == 0 && i == x-1 )
printf("%s iv.%c %d of %d: tx.%llx len.%d\n",addr->ipaddr,intvectors,i,(int32_t)x,(long long)hash.txid,len);
}
else if ( type == MSG_BLOCK )
{
if ( blockhashes == 0 )
blockhashes = mycalloc('f',(int32_t)x,sizeof(*blockhashes));
blockhashes[n++] = hash;
//init_hexbytes_noT(hashstr,hash.bytes,sizeof(hash));
//queue_enqueue("blocksQ",&coin->blocksQ,queueitem(hashstr),1);
//if ( i == x-2 )
// queue_enqueue("hdrsQ",&coin->hdrsQ,queueitem(hashstr),1);
//printf("iv.%d %d of %d: block.%llx len.%d %s\n",intvectors,i,(int32_t)x,(long long)hash.txid,len,bits256_str(hash));
}
else if ( type == MSG_FILTERED_BLOCK )
printf("iv.%d %d of %d: merkle.%llx\n",intvectors,i,(int32_t)x,(long long)hash.txid);
else printf("what type is %d\n",type);
}
if ( intvectors == 'I' )
{
if ( n > 0 )
{
if ( n != x )
{
//printf("n.%d != x.%d -> realloc blockhashes\n",n,(int32_t)x);
blockhashes = myrealloc('f',blockhashes,(int32_t)(x*sizeof(*blockhashes)),n*sizeof(*blockhashes));
} // else printf("n.%d == x.%d\n",n,(int32_t)x);
iguana_gotblockhashesM(coin,addr,blockhashes,n), blockhashes = 0;
}
if ( m > 0 )
{
if ( m != x )
txids = myrealloc('t',txids,(int32_t)(x*sizeof(*txids)),m*sizeof(*txids));
iguana_gottxidsM(coin,addr,txids,m), txids = 0;
}
}
if ( txids != 0 )
myfree(txids,sizeof(*txids) * x);
if ( blockhashes != 0 )
myfree(blockhashes,sizeof(*blockhashes) * x);
//printf("intvectors.%c datalen.%d\n",intvectors,datalen);
}
if ( len != datalen && len != datalen-1 )
{
//printf("error.(%s) (%s): len.%d != datalen.%d\n",H->command,addr->ipaddr,len,datalen);
//for (i=0; i<len; i++)
// printf("%02x",data[i]);
if ( strcmp(H->command,"addr") != 0 )
printf("%s.%s len mismatch %d != %d\n",addr!=0?addr->ipaddr:"local",H->command,len,datalen);
}
else if ( len == datalen-1 )
{
printf("extra byte.[%02x] command.%s len.%d datalen.%d\n",data[datalen-1],H->command,len,datalen);
//retval = -1;
}
return(retval);
}
int32_t iguana_msgparser(struct iguana_info *coin,struct iguana_peer *addr,struct OS_memspace *rawmem,struct OS_memspace *txmem,struct OS_memspace *hashmem,struct iguana_msghdr *H,uint8_t *data,int32_t recvlen)
{
uint8_t serialized[512]; char *retstr;
int32_t i,retval,delay,srvmsg,bloom,intvectors,len= -100; uint64_t nonce,x; uint32_t type; bits256 hash2;
bloom = intvectors = srvmsg = -1;
if ( addr != 0 )
{
addr->lastcontact = (uint32_t)time(NULL);
strcpy(addr->lastcommand,H->command);
}
retval = 0;
//printf("iguana_msgparser %s parse.(%s)\n",addr->ipaddr,H->command);
if ( strncmp(H->command,"SuperNET",strlen("SuperNET")) == 0 )
{
addr->supernet = 1;
addr->msgcounts.verack++;
len = recvlen;
if ( (retstr= SuperNET_p2p(coin,addr,&delay,addr->ipaddr,data,recvlen,H->command[strlen("SuperNET")]=='b')) != 0 )
{
iguana_send_supernet(coin,addr,retstr,delay);
free(retstr);
}
//printf("GOT.(%s) [%s] len.%d from %s -> (%s)\n",H->command,data,recvlen,addr->ipaddr,retstr==0?"null":retstr);
}
else if ( strcmp(H->command,"version") == 0 )
{
struct iguana_msgversion recvmv;
if ( addr != 0 )
{
len = iguana_rwversion(0,data,&recvmv,addr->ipaddr,recvlen);
if ( len <= recvlen )
iguana_gotversion(coin,addr,&recvmv);
//printf("deser.(%s) len.%d recvlen.%d\n",recvmv.H.command,len,recvlen);
addr->msgcounts.version++;
}
}
else if ( strcmp(H->command,"verack") == 0 )
{
if ( addr != 0 )
{
iguana_gotverack(coin,addr);
addr->msgcounts.verack++;
}
len = 0;
}
else if ( strcmp(H->command,"ConnectTo") == 0 )
{
iguana_queue_send(coin,addr,0,serialized,"getaddr",0,0,0);
len = 6;
}
else if ( strcmp(H->command,"ping") == 0 )
{
if ( recvlen == sizeof(uint64_t) && addr != 0 )
{
len = iguana_rwnum(0,data,sizeof(uint64_t),&nonce);
if ( addr != 0 )
{
//printf("%u got nonce.%llx from %s\n",(uint32_t)time(NULL),(long long)nonce,addr->ipaddr);
iguana_gotping(coin,addr,nonce,data);
addr->msgcounts.ping++;
}
iguana_queue_send(coin,addr,0,serialized,"getaddr",0,0,0);
}
}
else if ( strcmp(H->command,"pong") == 0 )
{
len = 0;
if ( recvlen == sizeof(uint64_t) )
{
len = iguana_rwnum(0,data,sizeof(uint64_t),&nonce);
iguana_gotpong(coin,addr,nonce);
} else printf("unexpected pong recvlen.%d\n",recvlen);
if ( len == recvlen && addr != 0 )
addr->msgcounts.pong++;
iguana_queue_send(coin,addr,0,serialized,"getaddr",0,0,0);
}
else if ( strcmp(H->command,"addr") == 0 )
{
struct iguana_msgaddress A;
len = iguana_rwvarint(0,data,&x);
for (i=0; i<x; i++)
{
memset(&A,0,sizeof(A));
if ( addr != 0 )
len += iguana_rwaddr(0,&data[len],&A,(int32_t)addr->protover);
iguana_gotaddr(coin,addr,&A);
}
if ( len == recvlen && addr != 0 )
{
addr->lastgotaddr = (uint32_t)time(NULL);
addr->msgcounts.addr++;
}
//printf("%s -> addr recvlen.%d num.%d\n",addr->ipaddr,recvlen,(int32_t)x);
}
else if ( strcmp(H->command,"headers") == 0 )
{
struct iguana_msgblock msg; struct iguana_block *blocks; uint32_t n;
len = iguana_rwvarint32(0,data,&n);
if ( n <= IGUANA_MAXINV )
{
blocks = mycalloc('i',1,sizeof(*blocks) * n);
for (i=0; i<n; i++)
{
len += iguana_rwblock(0,&hash2,&data[len],&msg);
iguana_blockconv(&blocks[i],&msg,hash2,-1);
}
iguana_gotheadersM(coin,addr,blocks,n);
//myfree(blocks,sizeof(*blocks) * n);
if ( len == recvlen && addr != 0 )
addr->msgcounts.headers++;
} else printf("got unexpected n.%d for headers\n",n);
//printf("GOT HEADERS n.%d len.%d\n",n,len);
}
else if ( strcmp(H->command,"tx") == 0 )
{
struct iguana_msgtx *tx;
iguana_memreset(rawmem);
tx = iguana_memalloc(rawmem,sizeof(*tx),1);//mycalloc('u',1,sizeof(*tx));
len = iguana_rwtx(0,rawmem,data,tx,recvlen,&tx->txid,coin->chain->hastimestamp,strcmp(coin->symbol,"VPN")==0);
iguana_gotunconfirmedM(coin,addr,tx,data,recvlen);
printf("tx recvlen.%d vs len.%d\n",recvlen,len);
addr->msgcounts.tx++;
}
else if ( strcmp(H->command,"block") == 0 )
{
struct iguana_txblock txdata;
if ( addr != 0 )
addr->msgcounts.block++;
iguana_memreset(rawmem), iguana_memreset(txmem);//, iguana_memreset(hashmem);
memset(&txdata,0,sizeof(txdata));
if ( (len= iguana_gentxarray(coin,rawmem,&txdata,&len,data,recvlen)) == recvlen )
iguana_gotblockM(coin,addr,&txdata,rawmem->ptr,H,data,recvlen);
else printf("parse error block txn_count.%d, len.%d vs recvlen.%d\n",txdata.block.RO.txn_count,len,recvlen);
}
else if ( strcmp(H->command,"reject") == 0 )
{
for (i=0; i<recvlen; i++)
printf("%02x ",data[i]);
printf("reject.(%s) recvlen.%d\n",data+1,recvlen);
len = recvlen;
if ( len == recvlen && addr != 0 )
addr->msgcounts.reject++;
}
else if ( strcmp(H->command,"alert") == 0 )
{
for (i=0; i<recvlen; i++)
printf("%02x ",data[i]);
printf("alert.(%s)\n",data+1);
len = recvlen;
if ( len == recvlen && addr != 0 )
addr->msgcounts.alert++;
}
else if ( addr != 0 )
{
if ( strcmp(H->command,"inv") == 0 )
intvectors = 'I', addr->msgcounts.inv++;
else if ( strcmp(H->command,"notfound") == 0 ) // for servers
intvectors = 'N', addr->msgcounts.notfound++;
else if ( strcmp(H->command,"getdata") == 0 ) // for servers
{
intvectors = srvmsg = 'D', addr->msgcounts.getdata++;
}
else if ( strcmp(H->command,"getblocks") == 0 ) // for servers
{
srvmsg = 'B', addr->msgcounts.getblocks++;
}
else if ( strcmp(H->command,"getheaders") == 0 ) // for servers
{
srvmsg = 'H', addr->msgcounts.getheaders++;
}
else if ( strcmp(H->command,"getaddr") == 0 )
{
srvmsg = 'A', addr->msgcounts.getaddr++;
}
else if ( strcmp(H->command,"mempool") == 0 )
srvmsg = 'M', addr->msgcounts.mempool++;
else if ( strcmp(H->command,"filterload") == 0 ) // for bloom
bloom = 'L', addr->msgcounts.filterload++;
else if ( strcmp(H->command,"filteradd") == 0 ) // for bloom
bloom = 'A', addr->msgcounts.filteradd++;
else if ( strcmp(H->command,"filterclear") == 0 ) // for bloom
bloom = 'C', addr->msgcounts.filterclear++;
else if ( strcmp(H->command,"merkleblock") == 0 ) // for bloom
bloom = 'M', addr->msgcounts.merkleblock++;
}
if ( bloom >= 0 || srvmsg >= 0 )
len = recvlen; // just mark as valid
if ( intvectors >= 0 )
{
bits256 *txids=0,*blockhashes=0,hash; int32_t n,m;
len = n = m = 0;
len += iguana_rwvarint(0,&data[len],&x);
for (i=0; i<x; i++)
{
len += iguana_rwnum(0,&data[len],sizeof(uint32_t),&type);
len += iguana_rwbignum(0,&data[len],sizeof(bits256),hash.bytes);
if ( type == MSG_TX )
{
if ( txids == 0 )
txids = mycalloc('t',(int32_t)x+1,sizeof(*txids));
txids[m++] = hash;
if ( (rand() % 1000) == 0 && i == x-1 )
printf("%s iv.%c %d of %d: tx.%llx len.%d\n",addr->ipaddr,intvectors,i,(int32_t)x,(long long)hash.txid,len);
}
else if ( type == MSG_BLOCK )
{
if ( blockhashes == 0 )
{
blockhashes = mycalloc('f',(int32_t)x+1,sizeof(*blockhashes));
n = 1;
}
blockhashes[n++] = hash;
}
else if ( type == MSG_FILTERED_BLOCK )
printf("iv.%d %d of %d: merkle.%llx\n",intvectors,i,(int32_t)x,(long long)hash.txid);
else printf("what type is %d\n",type);
}
if ( intvectors == 'I' )
{
if ( n > 0 )
{
if ( n != x+1 )
{
printf("n.%d != x.%d -> realloc blockhashes\n",n,(int32_t)x+1);
blockhashes = myrealloc('f',blockhashes,(int32_t)((x+1)*sizeof(*blockhashes)),n*sizeof(*blockhashes));
} // else printf("n.%d == x.%d\n",n,(int32_t)x);
if ( 1 )
iguana_gotblockhashesM(coin,addr,blockhashes,n), blockhashes = 0;
else iguana_send_hashes(coin,"getblocks",addr,blockhashes[0],&blockhashes[1],n);
}
if ( m > 0 )
{
if ( m != x )
txids = myrealloc('t',txids,(int32_t)((x+1)*sizeof(*txids)),(m+1)*sizeof(*txids));
iguana_gottxidsM(coin,addr,txids,m), txids = 0;
}
}
if ( txids != 0 )
myfree(txids,sizeof(*txids) * (x+1));
if ( blockhashes != 0 )
myfree(blockhashes,sizeof(*blockhashes) * (x+1));
//printf("intvectors.%c recvlen.%d\n",intvectors,recvlen);
}
if ( len != recvlen && len != recvlen-1 && len != recvlen-2 )
{
//printf("error.(%s) (%s): len.%d != recvlen.%d\n",H->command,addr->ipaddr,len,recvlen);
//for (i=0; i<len; i++)
// printf("%02x",data[i]);
if ( strcmp(H->command,"addr") != 0 )
printf("%s.%s len mismatch %d != %d\n",addr!=0?addr->ipaddr:"local",H->command,len,recvlen);
}
else if ( len != recvlen )
{
printf("%s extra byte.[%02x] command.%s len.%d recvlen.%d\n",addr->ipaddr,data[recvlen-1],H->command,len,recvlen);
//retval = -1;
}
return(retval);
}
cJSON *iguana_blockjson(struct supernet_info *myinfo,struct iguana_info *coin,struct iguana_block *block,int32_t txidsflag)
{
char str[65],hexstr[1024]; int32_t i,len,size; struct iguana_txid *tx,T; struct iguana_msgzblock zmsg; struct iguana_msgblock *msg = (void *)&zmsg; struct iguana_zblock *zblock;
bits256 hash2,nexthash2; uint8_t serialized[1024]; cJSON *array,*json = cJSON_CreateObject();
jaddstr(json,"result","success");
jaddstr(json,"hash",bits256_str(str,block->RO.hash2));
jaddnum(json,"height",block->height);
//jaddnum(json,"ipbits",block->fpipbits);
jaddstr(json,"merkleroot",bits256_str(str,block->RO.merkle_root));
jaddstr(json,"previousblockhash",bits256_str(str,block->RO.prev_block));
if ( block->height > 0 )
{
nexthash2 = iguana_blockhash(coin,block->height+1);
if ( bits256_nonz(nexthash2) != 0 )
jaddstr(json,"nextblockhash",bits256_str(str,nexthash2));
}
jaddnum(json,"timestamp",block->RO.timestamp);
jaddstr(json,"utc",utc_str(str,block->RO.timestamp));
jaddnum(json,"nonce",block->RO.nonce);
jaddnum(json,"version",block->RO.version);
jaddnum(json,"numvouts",block->RO.numvouts);
jaddnum(json,"numvins",block->RO.numvins);
jaddnum(json,"recvlen",block->RO.recvlen);
jaddnum(json,"hdrsi",block->hdrsi);
jaddnum(json,"difficulty",PoW_from_compact(block->RO.bits,coin->chain->unitval));
jaddnum(json,"bundlei",block->bundlei);
jaddnum(json,"mainchain",block->mainchain);
jaddnum(json,"valid",block->valid);
jaddnum(json,"txn_count",block->RO.txn_count);
jaddnum(json,"nBits",block->RO.bits);
serialized[0] = ((uint8_t *)&block->RO.bits)[3];
serialized[1] = ((uint8_t *)&block->RO.bits)[2];
serialized[2] = ((uint8_t *)&block->RO.bits)[1];
serialized[3] = ((uint8_t *)&block->RO.bits)[0];
init_hexbytes_noT(hexstr,serialized,sizeof(uint32_t));
jaddstr(json,"nBitshex",hexstr);
if ( block->RO.allocsize == sizeof(struct iguana_zblock) )
{
zblock = (void *)block;
memset(&zmsg,0,sizeof(zmsg));
zmsg.zH.version = zblock->RO.version;
zmsg.zH.merkle_root = zblock->RO.merkle_root;
zmsg.zH.timestamp = zblock->RO.timestamp;
zmsg.zH.bits = zblock->RO.bits;
zmsg.zH.bignonce = zblock->zRO.bignonce;
if ( iguana_rwvarint32(1,zmsg.zH.var_numelements,&zblock->zRO.numelements) != sizeof(zmsg.zH.var_numelements) )
printf("unexpected varint size for zmsg.zH.numelements <- %d\n",zblock->zRO.numelements);
for (i=0; i<ZCASH_SOLUTION_ELEMENTS; i++)
zmsg.zH.solution[i] = zblock->zRO.solution[i];
zmsg.txn_count = 0;//block->RO.txn_count;
len = iguana_rwblock(myinfo,coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&hash2,serialized,&zmsg,IGUANA_MAXPACKETSIZE*2);
}
else
{
memset(msg,0,sizeof(&msg));
msg->H.version = block->RO.version;
msg->H.prev_block = block->RO.prev_block;
msg->H.merkle_root = block->RO.merkle_root;
msg->H.timestamp = block->RO.timestamp;
msg->H.bits = block->RO.bits;
msg->H.nonce = block->RO.nonce;
msg->txn_count = 0;//block->RO.txn_count;
len = iguana_rwblock(myinfo,coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&hash2,serialized,&zmsg,IGUANA_MAXPACKETSIZE*2);
}
init_hexbytes_noT(hexstr,serialized,len);
jaddstr(json,"blockheader",hexstr);
if ( txidsflag != 0 )
{
array = cJSON_CreateArray();
for (i=0; i<block->RO.txn_count; i++)
{
if ( (tx= iguana_blocktx(coin,&T,block,i)) != 0 )
jaddistr(array,bits256_str(str,tx->txid));
}
jadd(json,"tx",array);
//printf("add txids[%d]\n",block->txn_count);
}
if ( (size= iguana_peerblockrequest(myinfo,coin,coin->blockspace,coin->blockspacesize,0,block->RO.hash2,0)) < 0 )
jaddstr(json,"error","couldnt generate raw bytes for block");
else jaddnum(json,"size",size);
return(json);
}
int32_t iguana_peerblockrequest(struct supernet_info *myinfo,struct iguana_info *coin,uint8_t *blockspace,int32_t max,struct iguana_peer *addr,bits256 hash2,int32_t validatesigs)
{
#if defined(_M_X64)
/*
* because we have no choice but to access the memory address
* we need 64bit to correctly hold 64bit memory address, thus changing
* to uint64_t instead of long in win x64
* @author - [email protected]
*/
struct iguana_txid *tx, T; bits256 checktxid; int32_t i, len, total, bundlei = -2; struct iguana_block *block; struct iguana_msgzblock zmsgB; bits256 *tree, checkhash2, merkle_root; struct iguana_bundle *bp = 0; uint64_t tmp; char str[65]; struct iguana_ramchaindata *rdata;
#else
struct iguana_txid *tx,T; bits256 checktxid; int32_t i,len,total,bundlei=-2; struct iguana_block *block; struct iguana_msgzblock zmsgB; bits256 *tree,checkhash2,merkle_root; struct iguana_bundle *bp=0; long tmp; char str[65]; struct iguana_ramchaindata *rdata;
#endif
if ( (bp= iguana_bundlefind(coin,&bp,&bundlei,hash2)) != 0 && bundlei >= 0 && bundlei < bp->n )
{
if ( (rdata= bp->ramchain.H.data) == 0 )//&& bp == coin->current )
{
//printf("iguana_peerblockrequest no ramchain data [%d] use RTcache\n",bp->hdrsi);
//rdata = coin->RTramchain.H.data;
return(-1);
}
if ( (block= bp->blocks[bundlei]) != 0 && rdata != 0 )
{
iguana_blockunconv(coin->chain->zcash,coin->chain->auxpow,&zmsgB,(void *)block,0);
zmsgB.txn_count = block->RO.txn_count;
total = iguana_rwblock(myinfo,coin->symbol,coin->chain->zcash,coin->chain->auxpow,coin->chain->hashalgo,1,&checkhash2,&blockspace[sizeof(struct iguana_msghdr) + 0],&zmsgB,max);
if ( bits256_cmp(checkhash2,block->RO.hash2) != 0 )
{
//static int counter;
//if ( counter++ < 100 )
printf("iguana_peerblockrequest: blockhash mismatch ht.%d\n",bp->bundleheight+bundlei);
return(-1);
}
for (i=0; i<block->RO.txn_count; i++)
{
if ( (tx= iguana_blocktx(coin,&T,block,i)) != 0 )
{
//printf("ht.%d [%d:%d] txi.%d i.%d o.%d %s\n",block->height,block->hdrsi,block->bundlei,i,tx->numvins,tx->numvouts,bits256_str(str,tx->txid));
if ( (len= iguana_ramtxbytes(coin,&blockspace[sizeof(struct iguana_msghdr) + total],max - total,&checktxid,tx,block->height,0,0,validatesigs)) > 0 )//&& bits256_cmp(checktxid,T.txid) == 0 )
total += len;
else
{
static uint32_t counter;
char str[65],str2[65];
if ( counter++ < 100 )
{
for (i=0; i<len; i++)
printf("%02x",blockspace[sizeof(struct iguana_msghdr)+i]);
printf(" len.%d error getting txi.%d [%d:%d] cmp.%s %s\n",len,i,bp->hdrsi,bundlei,bits256_str(str,checktxid),bits256_str(str2,T.txid));
}
break;
}
}
else
{
printf("%s null tx error getting txi.%d [%d:%d]\n",coin->symbol,i,bp->hdrsi,bundlei);
break;
}
}
if ( i == block->RO.txn_count )
{
#if defined(_M_X64)
/*
* because we have no choice but to access the memory address
* we need 64bit to correctly hold 64bit memory address, thus changing
* to uint64_t instead of long in win x64
* @author - [email protected]
*/
tmp = (uint64_t)&blockspace[sizeof(struct iguana_msghdr) + total + sizeof(bits256)];
#else
tmp = (long)&blockspace[sizeof(struct iguana_msghdr) + total + sizeof(bits256)];
#endif
tmp &= ~(sizeof(bits256) - 1);
tree = (void *)tmp;
for (i=0; i<block->RO.txn_count; i++)
{
if ( (tx= iguana_blocktx(coin,&T,block,i)) != 0 )
tree[i] = T.txid;
else break;
}
if ( i == block->RO.txn_count )
{
merkle_root = iguana_merkle(tree,block->RO.txn_count);
if ( bits256_cmp(merkle_root,block->RO.merkle_root) == 0 )
{
if ( addr != 0 && addr->lastsent != block->height )
{
addr->lastsent = block->height;
printf("Sendlen.%d block.%d %s to %s\n",total,block->height,bits256_str(str,block->RO.hash2),addr->ipaddr);
if ( 0 )
{
struct iguana_txblock txdata; int32_t checklen; static struct OS_memspace RAWMEM;
if ( RAWMEM.ptr == 0 )
iguana_meminit(&RAWMEM,addr->ipaddr,0,IGUANA_MAXPACKETSIZE * 2,0);
else iguana_memreset(&RAWMEM);
memset(&txdata,0,sizeof(txdata));
int32_t i;
for (i=0; i<total; i++)
{
if ( i == 81 )
printf(" ");
printf("%02x",blockspace[i + sizeof(struct iguana_msghdr)]);
}
printf(" blocksize.%d\n",total);
for (i=0; i<16; i++)
printf("%02x",blockspace[i + sizeof(struct iguana_msghdr)+81]);
printf(" txhdr\n");
if ( (checklen= iguana_gentxarray(myinfo,coin,&RAWMEM,&txdata,&checklen,&blockspace[sizeof(struct iguana_msghdr)],total)) != total && checklen != total-1 )
printf("Error reconstructing txarray checklen.%d total.%d\n",checklen,total);
}
return(iguana_queue_send(addr,0,blockspace,"block",total));
}
else
{
//printf("validated.[%d:%d] len.%d\n",bp->hdrsi,bundlei,total);
return(total);
}
} else printf("iguana_peerblockrequest: %s error %s merkle cmp tx.[%d] for ht.%d\n",coin->symbol,bits256_str(str,block->RO.hash2),i,bp->bundleheight+bundlei);
} else printf("iguana_peerblockrequest: error merkle verify tx.[%d] for ht.%d\n",i,bp->bundleheight+bundlei);
}
else
{
static uint32_t counter;
if ( counter++ < 10 )
printf("%s iguana_peerblockrequest: error getting tx.[%d] for ht.%d block.%p main.%d ht.%d\n",coin->symbol,i,bp->bundleheight+bundlei,block,block!=0?block->mainchain:-1,block!=0?block->height:-1);
}
}
else
{
if ( coin->virtualchain != 0 )
;
/*if ( block != 0 )
printf("iguana_peerblockrequest: block.%p ht.%d mainchain.%d [%d:%d] from %s bp.%p rdata.%p\n",block,block->height,block->mainchain,bp->hdrsi,bundlei,addr!=0?addr->ipaddr:"local",bp,bp!=0?rdata:0);
else printf("iguana_peerblockrequest: block.%p [%d:%d]\n",block,bp->hdrsi,bundlei);*/
}
} //else printf("iguana_peerblockrequest: cant find %s\n",bits256_str(str,hash2));
return(-1);
}
