char *block_on_SuperNET(int32_t blockflag,char *JSONstr)
{
char **ptrs,*retstr,retbuf[1024];
uint64_t txid = 0;
ptrs = calloc(3,sizeof(*ptrs));
ptrs[0] = clonestr(JSONstr);
if ( blockflag == 0 )
{
txid = calc_txid((uint8_t *)JSONstr,(int32_t)strlen(JSONstr));
ptrs[2] = (char *)txid;
}
if ( Debuglevel > 2 )
printf("block.%d QUEUE.(%s)\n",blockflag,JSONstr);
queue_enqueue(&JSON_Q,ptrs);
if ( blockflag != 0 )
{
while ( (retstr= ptrs[1]) == 0 )
usleep(1000);
if ( ptrs[0] != 0 )
free(ptrs[0]);
free(ptrs);
//printf("block.%d returned.(%s)\n",blockflag,retstr);
return(retstr);
}
else
{
sprintf(retbuf,"{\"result\":\"pending SuperNET API call\",\"txid\":\"%llu\"}",(long long)txid);
//printf("queue.%d returned.(%s)\n",blockflag,retbuf);
return(clonestr(retbuf));
}
}
char *SuperNET_gotpacket(char *msg,int32_t duration,char *ip_port)
{
static int flood,duplicates;
cJSON *json;
uint16_t p2pport;
struct pserver_info *pserver;
uint64_t txid;
struct sockaddr prevaddr;
int32_t len,createdflag,valid;
unsigned char packet[2*MAX_JSON_FIELD];
char ipaddr[64],txidstr[64],retjsonstr[2*MAX_JSON_FIELD],verifiedNXTaddr[64],*cmdstr,*retstr;
if ( SUPERNET_PORT != _SUPERNET_PORT )
return(clonestr("{\"error\":private SuperNET}"));
strcpy(retjsonstr,"{\"result\":null}");
if ( Debuglevel > 2 )
printf("gotpacket.(%s) duration.%d from (%s)\n",msg,duration,ip_port);
if ( Finished_loading == 0 )
{
if ( is_hexstr(msg) == 0 )
{
//printf("QUEUE.(%s)\n",msg);
return(block_on_SuperNET(0,msg));
}
return(clonestr(retjsonstr));
}
p2pport = parse_ipaddr(ipaddr,ip_port);
uv_ip4_addr(ipaddr,0,(struct sockaddr_in *)&prevaddr);
pserver = get_pserver(0,ipaddr,0,p2pport);
len = (int32_t)strlen(msg);
if ( is_hexstr(msg) != 0 )
{
len >>= 1;
len = decode_hex(packet,len,msg);
txid = calc_txid(packet,len);//hash,sizeof(hash));
sprintf(txidstr,"%llu",(long long)txid);
MTadd_hashtable(&createdflag,&Global_pNXT->msg_txids,txidstr);
if ( createdflag == 0 )
{
duplicates++;
return(clonestr("{\"error\":\"duplicate msg\"}"));
}
if ( (len<<1) == 30 ) // hack against flood
flood++;
if ( Debuglevel > 0 )
printf("gotpacket %d | Finished_loading.%d | flood.%d duplicates.%d\n",duration,Finished_loading,flood,duplicates);
if ( is_encrypted_packet(packet,len) != 0 )
process_packet(0,retjsonstr,packet,len,0,&prevaddr,ipaddr,0);
/*else if ( (obookid= is_orderbook_tx(packet,len)) != 0 )
{
if ( update_orderbook_tx(1,obookid,(struct orderbook_tx *)packet,txid) == 0 )
{
((struct orderbook_tx *)packet)->txid = txid;
sprintf(retjsonstr,"{\"result\":\"SuperNET_gotpacket got obbokid.%llu packet txid.%llu\"}",(long long)obookid,(long long)txid);
} else sprintf(retjsonstr,"{\"result\":\"SuperNET_gotpacket error updating obookid.%llu\"}",(long long)obookid);
}*/ else sprintf(retjsonstr,"{\"error\":\"SuperNET_gotpacket cant find obookid\"}");
}
extern "C" uint64_t pNXT_submit_tx(currency::core *m_core,currency::simple_wallet *wallet,unsigned char *txbytes,int16_t size)
{
int i,j;
crypto::hash h;
uint64_t txid = 0;
blobdata txb,b;
transaction tx = AUTO_VAL_INIT(tx);
txin_to_key input_to_key = AUTO_VAL_INIT(input_to_key);
NOTIFY_NEW_TRANSACTIONS::request req;
currency_connection_context fake_context = AUTO_VAL_INIT(fake_context);
tx_verification_context tvc = AUTO_VAL_INIT(tvc);
if ( m_core == 0 || wallet == 0 )
{
printf("pNXT_submit_tx missing m_core.%p or wallet.%p\n",m_core,wallet);
return(0);
}
tx.vin.clear();
tx.vout.clear();
tx.signatures.clear();
keypair txkey = keypair::generate();
add_tx_pub_key_to_extra(tx, txkey.pub);
if ( sizeof(input_to_key.k_image) != 32 )
{
printf("FATAL: expected sizeof(input_to_key.k_image) to be 32!\n");
return(0);
}
j = add_byte(&tx,&input_to_key,0,size&0xff);
j = add_byte(&tx,&input_to_key,j,(size>>8)&0xff);
for (i=0; i<size; i++)
j = add_byte(&tx,&input_to_key,j,txbytes[i]);
if ( j != 0 )
tx.vin.push_back(input_to_key);
tx.version = 0;
txb = tx_to_blob(tx);
printf("FROM submit jl777\n");
if ( !m_core->handle_incoming_tx(txb,tvc,false) )
{
LOG_PRINT_L0("[on_send_raw_tx]: Failed to process tx");
return(0);
}
if ( tvc.m_verifivation_failed )
{
LOG_PRINT_L0("[on_send_raw_tx]: tx verification failed");
return(0);
}
if( !tvc.m_should_be_relayed )
{
LOG_PRINT_L0("[on_send_raw_tx]: tx accepted, but not relayed");
return(0);
}
req.txs.push_back(txb);
m_core->get_protocol()->relay_transactions(req,fake_context);
get_transaction_hash(tx,h);
txid = calc_txid((unsigned char *)&h,sizeof(h));
return(txid);
}
uint64_t call_SuperNET_broadcast(struct pserver_info *pserver,char *msg,int32_t len,int32_t duration)
{
int32_t SuperNET_broadcast(char *msg,int32_t duration);
int32_t SuperNET_narrowcast(char *destip,unsigned char *msg,int32_t len);
char ip_port[64],*ptr;
uint64_t txid = 0;
int32_t port;
if ( 1 || SUPERNET_PORT != _SUPERNET_PORT )
return(0);
if ( Debuglevel > 1 )
printf("call_SuperNET_broadcast.%p %p len.%d\n",pserver,msg,len);
txid = calc_txid((uint8_t *)msg,(int32_t)strlen(msg));
if ( pserver != 0 )
{
port = (pserver->p2pport == 0) ? BTCD_PORT : pserver->p2pport;
//fprintf(stderr,"port.%d\n",port);
sprintf(ip_port,"%s:%d",pserver->ipaddr,port);
txid ^= calc_ipbits(pserver->ipaddr);
if ( Debuglevel > 1 )
{
char debugstr[4096];
init_hexbytes_noT(debugstr,(uint8_t *)msg,len);
debugstr[32] = 0;
fprintf(stderr,"%s NARROWCAST.(%s) txid.%llu (%s)\n",pserver->ipaddr,debugstr,(long long)txid,ip_port);
}
ptr = calloc(1,64 + sizeof(len) + len + 1);
memcpy(ptr,&len,sizeof(len));
memcpy(&ptr[sizeof(len)],ip_port,strlen(ip_port));
memcpy(&ptr[sizeof(len) + 64],msg,len);
queue_enqueue(&NarrowQ,ptr);
return(txid);
}
else
{
char *cmdstr,NXTaddr[64];
cJSON *array;
int32_t valid;
array = cJSON_Parse(msg);
if ( array != 0 )
{
cmdstr = verify_tokenized_json(0,NXTaddr,&valid,array);
if ( cmdstr != 0 )
free(cmdstr);
free_json(array);
if ( Debuglevel > 1 )
{
char debugstr[4096];
init_hexbytes_noT(debugstr,(uint8_t *)msg,len);
debugstr[32] = 0;
printf("BROADCAST parms.(%s) valid.%d duration.%d txid.%llu len.%d\n",debugstr,valid,duration,(long long)txid,len);
}
ptr = calloc(1,sizeof(len) + sizeof(duration) + len);
memcpy(ptr,&len,sizeof(len));
memcpy(&ptr[sizeof(len)],&duration,sizeof(duration));
memcpy(&ptr[sizeof(len) + sizeof(duration)],msg,len);
ptr[sizeof(len) + sizeof(duration) + len] = 0;
queue_enqueue(&BroadcastQ,ptr);
return(txid);
} else printf("cant broadcast non-JSON.(%s)\n",msg);
}
return(txid);
}
