|
|
@ -20,10 +20,17 @@ |
|
|
|
#include <memory.h> |
|
|
|
#include <string.h> |
|
|
|
#include <unistd.h> |
|
|
|
#include <curl/curl.h> |
|
|
|
#include <curl/easy.h> |
|
|
|
|
|
|
|
char USERPASS[8192]; |
|
|
|
char Gametxidstr[67]; |
|
|
|
|
|
|
|
#define SMALLVAL 0.000000000000001 |
|
|
|
#define SATOSHIDEN ((uint64_t)100000000L) |
|
|
|
#define dstr(x) ((double)(x) / SATOSHIDEN) |
|
|
|
#define KOMODO_ASSETCHAIN_MAXLEN 65 |
|
|
|
#define ASSETCHAINS_SYMBOL "ROGUE" |
|
|
|
|
|
|
|
#ifndef _BITS256 |
|
|
|
#define _BITS256 |
|
|
@ -31,6 +38,15 @@ union _bits256 { uint8_t bytes[32]; uint16_t ushorts[16]; uint32_t uints[8]; uin |
|
|
|
typedef union _bits256 bits256; |
|
|
|
#endif |
|
|
|
|
|
|
|
double OS_milliseconds() |
|
|
|
{ |
|
|
|
struct timeval tv; double millis; |
|
|
|
gettimeofday(&tv,NULL); |
|
|
|
millis = ((double)tv.tv_sec * 1000. + (double)tv.tv_usec / 1000.); |
|
|
|
//printf("tv_sec.%ld usec.%d %f\n",tv.tv_sec,tv.tv_usec,millis);
|
|
|
|
return(millis); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t _unhex(char c) |
|
|
|
{ |
|
|
|
if ( c >= '0' && c <= '9' ) |
|
|
@ -167,6 +183,23 @@ char *clonestr(char *str) |
|
|
|
strcpy(clone,str); |
|
|
|
return(clone); |
|
|
|
} |
|
|
|
|
|
|
|
char *parse_conf_line(char *line,char *field) |
|
|
|
{ |
|
|
|
line += strlen(field); |
|
|
|
for (; *line!='='&&*line!=0; line++) |
|
|
|
break; |
|
|
|
if ( *line == 0 ) |
|
|
|
return(0); |
|
|
|
if ( *line == '=' ) |
|
|
|
line++; |
|
|
|
while ( line[strlen(line)-1] == '\r' || line[strlen(line)-1] == '\n' || line[strlen(line)-1] == ' ' ) |
|
|
|
line[strlen(line)-1] = 0; |
|
|
|
//printf("LINE.(%s)\n",line);
|
|
|
|
_stripwhite(line,0); |
|
|
|
return(clonestr(line)); |
|
|
|
} |
|
|
|
|
|
|
|
int32_t safecopy(char *dest,char *src,long len) |
|
|
|
{ |
|
|
|
int32_t i = -1; |
|
|
@ -246,6 +279,487 @@ uint8_t *OS_fileptr(long *allocsizep,char *fname) |
|
|
|
return((uint8_t *)retptr); |
|
|
|
} |
|
|
|
|
|
|
|
struct MemoryStruct { char *memory; size_t size; }; |
|
|
|
struct return_string { char *ptr; size_t len; }; |
|
|
|
|
|
|
|
// return data from the server
|
|
|
|
#define CURL_GLOBAL_ALL (CURL_GLOBAL_SSL|CURL_GLOBAL_WIN32) |
|
|
|
#define CURL_GLOBAL_SSL (1<<0) |
|
|
|
#define CURL_GLOBAL_WIN32 (1<<1) |
|
|
|
|
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* |
|
|
|
* Initialize the string handler so that it is thread safe |
|
|
|
* |
|
|
|
************************************************************************/ |
|
|
|
|
|
|
|
void init_string(struct return_string *s) |
|
|
|
{ |
|
|
|
s->len = 0; |
|
|
|
s->ptr = (char *)calloc(1,s->len+1); |
|
|
|
if ( s->ptr == NULL ) |
|
|
|
{ |
|
|
|
fprintf(stderr,"init_string malloc() failed\n"); |
|
|
|
exit(-1); |
|
|
|
} |
|
|
|
s->ptr[0] = '\0'; |
|
|
|
} |
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* |
|
|
|
* Use the "writer" to accumulate text until done |
|
|
|
* |
|
|
|
************************************************************************/ |
|
|
|
|
|
|
|
size_t accumulatebytes(void *ptr,size_t size,size_t nmemb,struct return_string *s) |
|
|
|
{ |
|
|
|
size_t new_len = s->len + size*nmemb; |
|
|
|
s->ptr = (char *)realloc(s->ptr,new_len+1); |
|
|
|
if ( s->ptr == NULL ) |
|
|
|
{ |
|
|
|
fprintf(stderr, "accumulate realloc() failed\n"); |
|
|
|
exit(-1); |
|
|
|
} |
|
|
|
memcpy(s->ptr+s->len,ptr,size*nmemb); |
|
|
|
s->ptr[new_len] = '\0'; |
|
|
|
s->len = new_len; |
|
|
|
return(size * nmemb); |
|
|
|
} |
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* |
|
|
|
* return the current system time in milliseconds |
|
|
|
* |
|
|
|
************************************************************************/ |
|
|
|
|
|
|
|
#define EXTRACT_BITCOIND_RESULT // if defined, ensures error is null and returns the "result" field
|
|
|
|
#ifdef EXTRACT_BITCOIND_RESULT |
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* |
|
|
|
* perform post processing of the results |
|
|
|
* |
|
|
|
************************************************************************/ |
|
|
|
|
|
|
|
char *post_process_bitcoind_RPC(char *debugstr,char *command,char *rpcstr,char *params) |
|
|
|
{ |
|
|
|
long i,j,len; char *retstr = 0; cJSON *json,*result,*error; |
|
|
|
//printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC.%s.[%s]\n",debugstr,command,rpcstr);
|
|
|
|
if ( command == 0 || rpcstr == 0 || rpcstr[0] == 0 ) |
|
|
|
{ |
|
|
|
if ( strcmp(command,"signrawtransaction") != 0 ) |
|
|
|
printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC.%s.[%s]\n",debugstr,command,rpcstr); |
|
|
|
return(rpcstr); |
|
|
|
} |
|
|
|
json = cJSON_Parse(rpcstr); |
|
|
|
if ( json == 0 ) |
|
|
|
{ |
|
|
|
printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC.%s can't parse.(%s) params.(%s)\n",debugstr,command,rpcstr,params); |
|
|
|
free(rpcstr); |
|
|
|
return(0); |
|
|
|
} |
|
|
|
result = cJSON_GetObjectItem(json,"result"); |
|
|
|
error = cJSON_GetObjectItem(json,"error"); |
|
|
|
if ( error != 0 && result != 0 ) |
|
|
|
{ |
|
|
|
if ( (error->type&0xff) == cJSON_NULL && (result->type&0xff) != cJSON_NULL ) |
|
|
|
{ |
|
|
|
retstr = cJSON_Print(result); |
|
|
|
len = strlen(retstr); |
|
|
|
if ( retstr[0] == '"' && retstr[len-1] == '"' ) |
|
|
|
{ |
|
|
|
for (i=1,j=0; i<len-1; i++,j++) |
|
|
|
retstr[j] = retstr[i]; |
|
|
|
retstr[j] = 0; |
|
|
|
} |
|
|
|
} |
|
|
|
else if ( (error->type&0xff) != cJSON_NULL || (result->type&0xff) != cJSON_NULL ) |
|
|
|
{ |
|
|
|
if ( strcmp(command,"signrawtransaction") != 0 ) |
|
|
|
printf("<<<<<<<<<<< bitcoind_RPC: %s post_process_bitcoind_RPC (%s) error.%s\n",debugstr,command,rpcstr); |
|
|
|
} |
|
|
|
free(rpcstr); |
|
|
|
} else retstr = rpcstr; |
|
|
|
free_json(json); |
|
|
|
//fprintf(stderr,"<<<<<<<<<<< bitcoind_RPC: postprocess returns.(%s)\n",retstr);
|
|
|
|
return(retstr); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
/************************************************************************
|
|
|
|
* |
|
|
|
* perform the query |
|
|
|
* |
|
|
|
************************************************************************/ |
|
|
|
|
|
|
|
char *bitcoind_RPC(char **retstrp,char *debugstr,char *url,char *userpass,char *command,char *params) |
|
|
|
{ |
|
|
|
static int didinit,count,count2; static double elapsedsum,elapsedsum2; |
|
|
|
struct curl_slist *headers = NULL; struct return_string s; CURLcode res; CURL *curl_handle; |
|
|
|
char *bracket0,*bracket1,*databuf = 0; long len; int32_t specialcase,numretries; double starttime; |
|
|
|
if ( didinit == 0 ) |
|
|
|
{ |
|
|
|
didinit = 1; |
|
|
|
curl_global_init(CURL_GLOBAL_ALL); //init the curl session
|
|
|
|
} |
|
|
|
numretries = 0; |
|
|
|
if ( debugstr != 0 && strcmp(debugstr,"BTCD") == 0 && command != 0 && strcmp(command,"SuperNET") == 0 ) |
|
|
|
specialcase = 1; |
|
|
|
else specialcase = 0; |
|
|
|
if ( url[0] == 0 ) |
|
|
|
strcpy(url,"http://127.0.0.1:7876/nxt"); |
|
|
|
if ( specialcase != 0 && 0 ) |
|
|
|
printf("<<<<<<<<<<< bitcoind_RPC: debug.(%s) url.(%s) command.(%s) params.(%s)\n",debugstr,url,command,params); |
|
|
|
try_again: |
|
|
|
if ( retstrp != 0 ) |
|
|
|
*retstrp = 0; |
|
|
|
starttime = OS_milliseconds(); |
|
|
|
curl_handle = curl_easy_init(); |
|
|
|
init_string(&s); |
|
|
|
headers = curl_slist_append(0,"Expect:"); |
|
|
|
|
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_USERAGENT,"mozilla/4.0");//"Mozilla/4.0 (compatible; )");
|
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_HTTPHEADER, headers); |
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_URL, url); |
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_WRITEFUNCTION, (void *)accumulatebytes); // send all data to this function
|
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_WRITEDATA, &s); // we pass our 's' struct to the callback
|
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_NOSIGNAL, 1L); // supposed to fix "Alarm clock" and long jump crash
|
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_NOPROGRESS, 1L); // no progress callback
|
|
|
|
if ( strncmp(url,"https",5) == 0 ) |
|
|
|
{ |
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_SSL_VERIFYPEER,0); |
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_SSL_VERIFYHOST,0); |
|
|
|
} |
|
|
|
if ( userpass != 0 ) |
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_USERPWD, userpass); |
|
|
|
databuf = 0; |
|
|
|
if ( params != 0 ) |
|
|
|
{ |
|
|
|
if ( command != 0 && specialcase == 0 ) |
|
|
|
{ |
|
|
|
len = strlen(params); |
|
|
|
if ( len > 0 && params[0] == '[' && params[len-1] == ']' ) { |
|
|
|
bracket0 = bracket1 = (char *)""; |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
bracket0 = (char *)"["; |
|
|
|
bracket1 = (char *)"]"; |
|
|
|
} |
|
|
|
|
|
|
|
databuf = (char *)malloc(256 + strlen(command) + strlen(params)); |
|
|
|
sprintf(databuf,"{\"id\":\"jl777\",\"method\":\"%s\",\"params\":%s%s%s}",command,bracket0,params,bracket1); |
|
|
|
//printf("url.(%s) userpass.(%s) databuf.(%s)\n",url,userpass,databuf);
|
|
|
|
//
|
|
|
|
} //else if ( specialcase != 0 ) fprintf(stderr,"databuf.(%s)\n",params);
|
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_POST,1L); |
|
|
|
if ( databuf != 0 ) |
|
|
|
curl_easy_setopt(curl_handle,CURLOPT_POSTFIELDS,databuf); |
|
|
|
else curl_easy_setopt(curl_handle,CURLOPT_POSTFIELDS,params); |
|
|
|
} |
|
|
|
//laststart = milliseconds();
|
|
|
|
res = curl_easy_perform(curl_handle); |
|
|
|
curl_slist_free_all(headers); |
|
|
|
curl_easy_cleanup(curl_handle); |
|
|
|
if ( databuf != 0 ) // clean up temporary buffer
|
|
|
|
{ |
|
|
|
free(databuf); |
|
|
|
databuf = 0; |
|
|
|
} |
|
|
|
if ( res != CURLE_OK ) |
|
|
|
{ |
|
|
|
numretries++; |
|
|
|
if ( specialcase != 0 ) |
|
|
|
{ |
|
|
|
printf("<<<<<<<<<<< bitcoind_RPC.(%s): BTCD.%s timeout params.(%s) s.ptr.(%s) err.%d\n",url,command,params,s.ptr,res); |
|
|
|
free(s.ptr); |
|
|
|
return(0); |
|
|
|
} |
|
|
|
else if ( numretries >= 1 ) |
|
|
|
{ |
|
|
|
//printf("Maximum number of retries exceeded!\n");
|
|
|
|
free(s.ptr); |
|
|
|
return(0); |
|
|
|
} |
|
|
|
if ( (rand() % 1000) == 0 ) |
|
|
|
printf( "curl_easy_perform() failed: %s %s.(%s %s), retries: %d\n",curl_easy_strerror(res),debugstr,url,command,numretries); |
|
|
|
free(s.ptr); |
|
|
|
sleep((1<<numretries)); |
|
|
|
goto try_again; |
|
|
|
|
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
if ( command != 0 && specialcase == 0 ) |
|
|
|
{ |
|
|
|
count++; |
|
|
|
elapsedsum += (OS_milliseconds() - starttime); |
|
|
|
if ( (count % 1000000) == 0) |
|
|
|
printf("%d: ave %9.6f | elapsed %.3f millis | bitcoind_RPC.(%s) url.(%s)\n",count,elapsedsum/count,(OS_milliseconds() - starttime),command,url); |
|
|
|
if ( retstrp != 0 ) |
|
|
|
{ |
|
|
|
*retstrp = s.ptr; |
|
|
|
return(s.ptr); |
|
|
|
} |
|
|
|
return(post_process_bitcoind_RPC(debugstr,command,s.ptr,params)); |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
if ( 0 && specialcase != 0 ) |
|
|
|
fprintf(stderr,"<<<<<<<<<<< bitcoind_RPC: BTCD.(%s) -> (%s)\n",params,s.ptr); |
|
|
|
count2++; |
|
|
|
elapsedsum2 += (OS_milliseconds() - starttime); |
|
|
|
if ( (count2 % 10000) == 0) |
|
|
|
printf("%d: ave %9.6f | elapsed %.3f millis | NXT calls.(%s) cmd.(%s)\n",count2,elapsedsum2/count2,(double)(OS_milliseconds() - starttime),url,command); |
|
|
|
return(s.ptr); |
|
|
|
} |
|
|
|
} |
|
|
|
printf("bitcoind_RPC: impossible case\n"); |
|
|
|
free(s.ptr); |
|
|
|
return(0); |
|
|
|
} |
|
|
|
|
|
|
|
static size_t WriteMemoryCallback(void *ptr,size_t size,size_t nmemb,void *data) |
|
|
|
{ |
|
|
|
size_t realsize = (size * nmemb); |
|
|
|
struct MemoryStruct *mem = (struct MemoryStruct *)data; |
|
|
|
mem->memory = (char *)((ptr != 0) ? realloc(mem->memory,mem->size + realsize + 1) : malloc(mem->size + realsize + 1)); |
|
|
|
if ( mem->memory != 0 ) |
|
|
|
{ |
|
|
|
if ( ptr != 0 ) |
|
|
|
memcpy(&(mem->memory[mem->size]),ptr,realsize); |
|
|
|
mem->size += realsize; |
|
|
|
mem->memory[mem->size] = 0; |
|
|
|
} |
|
|
|
//printf("got %d bytes\n",(int32_t)(size*nmemb));
|
|
|
|
return(realsize); |
|
|
|
} |
|
|
|
|
|
|
|
char *curl_post(CURL **cHandlep,char *url,char *userpass,char *postfields,char *hdr0,char *hdr1,char *hdr2,char *hdr3) |
|
|
|
{ |
|
|
|
struct MemoryStruct chunk; CURL *cHandle; long code; struct curl_slist *headers = 0; |
|
|
|
if ( (cHandle= *cHandlep) == NULL ) |
|
|
|
*cHandlep = cHandle = curl_easy_init(); |
|
|
|
else curl_easy_reset(cHandle); |
|
|
|
//#ifdef DEBUG
|
|
|
|
//curl_easy_setopt(cHandle,CURLOPT_VERBOSE, 1);
|
|
|
|
//#endif
|
|
|
|
curl_easy_setopt(cHandle,CURLOPT_USERAGENT,"mozilla/4.0");//"Mozilla/4.0 (compatible; )");
|
|
|
|
curl_easy_setopt(cHandle,CURLOPT_SSL_VERIFYPEER,0); |
|
|
|
//curl_easy_setopt(cHandle,CURLOPT_SSLVERSION,1);
|
|
|
|
curl_easy_setopt(cHandle,CURLOPT_URL,url); |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_CONNECTTIMEOUT,10); |
|
|
|
if ( userpass != 0 && userpass[0] != 0 ) |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_USERPWD,userpass); |
|
|
|
if ( postfields != 0 && postfields[0] != 0 ) |
|
|
|
{ |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_POST,1); |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_POSTFIELDS,postfields); |
|
|
|
} |
|
|
|
if ( hdr0 != NULL && hdr0[0] != 0 ) |
|
|
|
{ |
|
|
|
//printf("HDR0.(%s) HDR1.(%s) HDR2.(%s) HDR3.(%s)\n",hdr0!=0?hdr0:"",hdr1!=0?hdr1:"",hdr2!=0?hdr2:"",hdr3!=0?hdr3:"");
|
|
|
|
headers = curl_slist_append(headers,hdr0); |
|
|
|
if ( hdr1 != 0 && hdr1[0] != 0 ) |
|
|
|
headers = curl_slist_append(headers,hdr1); |
|
|
|
if ( hdr2 != 0 && hdr2[0] != 0 ) |
|
|
|
headers = curl_slist_append(headers,hdr2); |
|
|
|
if ( hdr3 != 0 && hdr3[0] != 0 ) |
|
|
|
headers = curl_slist_append(headers,hdr3); |
|
|
|
} //headers = curl_slist_append(0,"Expect:");
|
|
|
|
if ( headers != 0 ) |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_HTTPHEADER,headers); |
|
|
|
//res = curl_easy_perform(cHandle);
|
|
|
|
memset(&chunk,0,sizeof(chunk)); |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_WRITEFUNCTION,WriteMemoryCallback); |
|
|
|
curl_easy_setopt(cHandle,CURLOPT_WRITEDATA,(void *)&chunk); |
|
|
|
curl_easy_perform(cHandle); |
|
|
|
curl_easy_getinfo(cHandle,CURLINFO_RESPONSE_CODE,&code); |
|
|
|
if ( headers != 0 ) |
|
|
|
curl_slist_free_all(headers); |
|
|
|
if ( code != 200 ) |
|
|
|
printf("(%s) server responded with code %ld (%s)\n",url,code,chunk.memory); |
|
|
|
return(chunk.memory); |
|
|
|
} |
|
|
|
|
|
|
|
#ifdef autoextract |
|
|
|
uint16_t _komodo_userpass(char *username,char *password,FILE *fp) |
|
|
|
{ |
|
|
|
char *rpcuser,*rpcpassword,*str,line[8192]; uint16_t port = 0; |
|
|
|
rpcuser = rpcpassword = 0; |
|
|
|
username[0] = password[0] = 0; |
|
|
|
while ( fgets(line,sizeof(line),fp) != 0 ) |
|
|
|
{ |
|
|
|
if ( line[0] == '#' ) |
|
|
|
continue; |
|
|
|
//printf("line.(%s) %p %p\n",line,strstr(line,(char *)"rpcuser"),strstr(line,(char *)"rpcpassword"));
|
|
|
|
if ( (str= strstr(line,(char *)"rpcuser")) != 0 ) |
|
|
|
rpcuser = parse_conf_line(str,(char *)"rpcuser"); |
|
|
|
else if ( (str= strstr(line,(char *)"rpcpassword")) != 0 ) |
|
|
|
rpcpassword = parse_conf_line(str,(char *)"rpcpassword"); |
|
|
|
else if ( (str= strstr(line,(char *)"rpcport")) != 0 ) |
|
|
|
{ |
|
|
|
port = atoi(parse_conf_line(str,(char *)"rpcport")); |
|
|
|
//fprintf(stderr,"rpcport.%u in file\n",port);
|
|
|
|
} |
|
|
|
} |
|
|
|
if ( rpcuser != 0 && rpcpassword != 0 ) |
|
|
|
{ |
|
|
|
strcpy(username,rpcuser); |
|
|
|
strcpy(password,rpcpassword); |
|
|
|
} |
|
|
|
//printf("rpcuser.(%s) rpcpassword.(%s) KMDUSERPASS.(%s) %u\n",rpcuser,rpcpassword,KMDUSERPASS,port);
|
|
|
|
if ( rpcuser != 0 ) |
|
|
|
free(rpcuser); |
|
|
|
if ( rpcpassword != 0 ) |
|
|
|
free(rpcpassword); |
|
|
|
return(port); |
|
|
|
} |
|
|
|
|
|
|
|
void komodo_statefname(char *fname,char *symbol,char *str) |
|
|
|
{ |
|
|
|
int32_t n,len; |
|
|
|
sprintf(fname,"%s",getDataDir()); |
|
|
|
if ( (n= (int32_t)strlen(ASSETCHAINS_SYMBOL)) != 0 ) |
|
|
|
{ |
|
|
|
len = (int32_t)strlen(fname); |
|
|
|
if ( strcmp(ASSETCHAINS_SYMBOL,&fname[len - n]) == 0 ) |
|
|
|
fname[len - n] = 0; |
|
|
|
else |
|
|
|
{ |
|
|
|
printf("unexpected fname.(%s) vs %s [%s] n.%d len.%d (%s)\n",fname,symbol,ASSETCHAINS_SYMBOL,n,len,&fname[len - n]); |
|
|
|
return; |
|
|
|
} |
|
|
|
} |
|
|
|
else |
|
|
|
{ |
|
|
|
#ifdef _WIN32 |
|
|
|
strcat(fname,"\\"); |
|
|
|
#else |
|
|
|
strcat(fname,"/"); |
|
|
|
#endif |
|
|
|
} |
|
|
|
if ( symbol != 0 && symbol[0] != 0 && strcmp("KMD",symbol) != 0 ) |
|
|
|
{ |
|
|
|
strcat(fname,symbol); |
|
|
|
//printf("statefname.(%s) -> (%s)\n",symbol,fname);
|
|
|
|
#ifdef _WIN32 |
|
|
|
strcat(fname,"\\"); |
|
|
|
#else |
|
|
|
strcat(fname,"/"); |
|
|
|
#endif |
|
|
|
} |
|
|
|
strcat(fname,str); |
|
|
|
//printf("test.(%s) -> [%s] statename.(%s) %s\n",test,ASSETCHAINS_SYMBOL,symbol,fname);
|
|
|
|
} |
|
|
|
|
|
|
|
uint16_t komodo_userpass(char *userpass,char *symbol) |
|
|
|
{ |
|
|
|
FILE *fp; uint16_t port = 0; char fname[512],username[512],password[512],confname[KOMODO_ASSETCHAIN_MAXLEN]; |
|
|
|
userpass[0] = 0; |
|
|
|
if ( strcmp("KMD",symbol) == 0 ) |
|
|
|
{ |
|
|
|
#ifdef __APPLE__ |
|
|
|
sprintf(confname,"Komodo.conf"); |
|
|
|
#else |
|
|
|
sprintf(confname,"komodo.conf"); |
|
|
|
#endif |
|
|
|
} |
|
|
|
else sprintf(confname,"%s.conf",symbol); |
|
|
|
komodo_statefname(fname,symbol,confname); |
|
|
|
if ( (fp= fopen(fname,"rb")) != 0 ) |
|
|
|
{ |
|
|
|
port = _komodo_userpass(username,password,fp); |
|
|
|
sprintf(userpass,"%s:%s",username,password); |
|
|
|
if ( strcmp(symbol,ASSETCHAINS_SYMBOL) == 0 ) |
|
|
|
strcpy(USERPASS,userpass); |
|
|
|
fclose(fp); |
|
|
|
} |
|
|
|
return(port); |
|
|
|
} |
|
|
|
#endif |
|
|
|
|
|
|
|
#define is_cJSON_True(json) ((json) != 0 && ((json)->type & 0xff) == cJSON_True) |
|
|
|
|
|
|
|
char *komodo_issuemethod(char *userpass,char *method,char *params,uint16_t port) |
|
|
|
{ |
|
|
|
//static void *cHandle;
|
|
|
|
char url[512],*retstr=0,*retstr2=0,postdata[8192]; |
|
|
|
if ( params == 0 || params[0] == 0 ) |
|
|
|
params = (char *)"[]"; |
|
|
|
if ( strlen(params) < sizeof(postdata)-128 ) |
|
|
|
{ |
|
|
|
sprintf(url,(char *)"http://127.0.0.1:%u",port); |
|
|
|
sprintf(postdata,"{\"method\":\"%s\",\"params\":%s}",method,params); |
|
|
|
//printf("[%s] (%s) postdata.(%s) params.(%s) USERPASS.(%s)\n",ASSETCHAINS_SYMBOL,url,postdata,params,KMDUSERPASS);
|
|
|
|
retstr2 = bitcoind_RPC(&retstr,(char *)"debug",url,userpass,method,params); |
|
|
|
//retstr = curl_post(&cHandle,url,USERPASS,postdata,0,0,0,0);
|
|
|
|
} |
|
|
|
return(retstr2); |
|
|
|
} |
|
|
|
|
|
|
|
#include "rogue.h" |
|
|
|
|
|
|
|
void rogue_progress(struct rogue_state *rs,uint64_t seed,char *keystrokes,int32_t num) |
|
|
|
{ |
|
|
|
char cmd[16384],hexstr[16384]; int32_t i; |
|
|
|
if ( rs->guiflag != 0 && Gametxidstr[0] != 0 ) |
|
|
|
{ |
|
|
|
for (i=0; i<num; i++) |
|
|
|
sprintf(&hexstr[i<<1],"%02x",keystrokes[i]); |
|
|
|
hexstr[i<<1] = 0; |
|
|
|
sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib keystrokes 17 \\\"[%%22%s%%22,%%22%s%%22]\\\" >> keystrokes.log",Gametxidstr,hexstr); |
|
|
|
if ( system(cmd) != 0 ) |
|
|
|
fprintf(stderr,"error issuing (%s)\n",cmd); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
int32_t rogue_setplayerdata(struct rogue_state *rs,char *gametxidstr) |
|
|
|
{ |
|
|
|
char cmd[32768]; int32_t i,n,retval=-1; char *filestr,*pname,*statusstr,*datastr,fname[128]; long allocsize; cJSON *retjson,*array,*item; |
|
|
|
if ( rs->guiflag == 0 ) |
|
|
|
return(-1); |
|
|
|
if ( gametxidstr == 0 || *gametxidstr == 0 ) |
|
|
|
return(retval); |
|
|
|
sprintf(fname,"%s.gameinfo",gametxidstr); |
|
|
|
sprintf(cmd,"./komodo-cli -ac_name=ROGUE cclib gameinfo 17 \\\"[%%22%s%%22]\\\" > %s",gametxidstr,fname); |
|
|
|
if ( system(cmd) != 0 ) |
|
|
|
fprintf(stderr,"error issuing (%s)\n",cmd); |
|
|
|
else |
|
|
|
{ |
|
|
|
filestr = (char *)OS_fileptr(&allocsize,fname); |
|
|
|
if ( (retjson= cJSON_Parse(filestr)) != 0 ) |
|
|
|
{ |
|
|
|
if ( (array= jarray(&n,retjson,"players")) != 0 ) |
|
|
|
{ |
|
|
|
for (i=0; i<n; i++) |
|
|
|
{ |
|
|
|
item = jitem(array,i); |
|
|
|
if ( is_cJSON_True(jobj(item,"ismine")) != 0 && (statusstr= jstr(item,"status")) != 0 ) |
|
|
|
{ |
|
|
|
if ( strcmp(statusstr,"registered") == 0 ) |
|
|
|
{ |
|
|
|
retval = 0; |
|
|
|
if ( (item= jobj(item,"player")) != 0 && (datastr= jstr(item,"data")) != 0 ) |
|
|
|
{ |
|
|
|
if ( (pname= jstr(item,"pname")) != 0 && strlen(pname) < MAXSTR-1 ) |
|
|
|
strcpy(whoami,pname); |
|
|
|
decode_hex((uint8_t *)&rs->P,(int32_t)strlen(datastr)/2,datastr); |
|
|
|
fprintf(stderr,"set pname[%s] %s\n",pname==0?"":pname,jprint(item,0)); |
|
|
|
rs->restoring = 1; |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
free_json(retjson); |
|
|
|
} |
|
|
|
free(filestr); |
|
|
|
} |
|
|
|
return(retval); |
|
|
|
} |
|
|
|
|
|
|
|
int main(int argc, char **argv, char **envp) |
|
|
|
{ |
|
|
|
uint64_t seed; FILE *fp = 0; |
|
|
|