Update
This commit is contained in:
xethyrion
GitHub
parent
7b1ed7a4a4
commit
483957077e
4 changed files with 296 additions and 222 deletions
29
multiaddr.h
29
multiaddr.h
|
|
@ -20,27 +20,36 @@ int strpos(char *haystack, char *needle)
|
|||
}
|
||||
struct maddr
|
||||
{
|
||||
char string[100];
|
||||
char string[200];
|
||||
uint8_t bytes[100];
|
||||
int bsize[1];
|
||||
};
|
||||
struct maddr new_maddr_fb(uint8_t * byteaddress,int size)//Construct new address from bytes
|
||||
{
|
||||
struct maddr anewaddr;
|
||||
struct maddr anewaddr2;
|
||||
if(byteaddress!=NULL)
|
||||
{
|
||||
memcpy(anewaddr.bytes, byteaddress,size);
|
||||
if(bytes_to_string(anewaddr.string,byteaddress,size)==1)
|
||||
memcpy(anewaddr2.bytes, byteaddress,size);
|
||||
if(bytes_to_string(anewaddr2.string,byteaddress,size)==1)
|
||||
{
|
||||
return anewaddr;
|
||||
return anewaddr2;
|
||||
}
|
||||
}
|
||||
}
|
||||
struct maddr new_maddr_fs(char * straddress)//Construct new address from string
|
||||
{
|
||||
struct maddr anewaddr;
|
||||
bzero(anewaddr.string, 100);
|
||||
strcpy(anewaddr.string, straddress);
|
||||
if(string_to_bytes(anewaddr.bytes,anewaddr.string,sizeof(anewaddr.string))==1)
|
||||
anewaddr.bsize[0] = 0;
|
||||
if(string_to_bytes(anewaddr.bytes,anewaddr.bsize,anewaddr.string,sizeof(anewaddr.string))==1)
|
||||
{
|
||||
int betta;
|
||||
//printf("BSIZE: %u\n", anewaddr.bsize[0]);
|
||||
for(betta=anewaddr.bsize[0];betta<100;betta++)
|
||||
{
|
||||
anewaddr.bytes[betta] = '\0';
|
||||
}
|
||||
return anewaddr;
|
||||
}
|
||||
}
|
||||
|
|
@ -49,13 +58,11 @@ int m_encapsulate(struct maddr * result, char * string)
|
|||
if(result!=NULL&&string!=NULL)
|
||||
{
|
||||
int success = 0;
|
||||
char pstr[50];
|
||||
bzero(pstr,50);
|
||||
char pstr[100];
|
||||
strcpy(pstr,result->string);
|
||||
strcat(pstr,string+1);
|
||||
if(string_to_bytes(result->bytes,pstr,sizeof(pstr)))
|
||||
if(string_to_bytes(result->bytes,result->bsize,pstr,sizeof(pstr)))
|
||||
{
|
||||
printf("RESULT WOULD BE: %s\n", pstr);
|
||||
strcpy(result->string,pstr);
|
||||
return 1;
|
||||
}
|
||||
|
|
@ -101,7 +108,6 @@ int m_decapsulate(struct maddr * result, char * srci)
|
|||
procstr[i] = '/';
|
||||
}
|
||||
}
|
||||
strcpy(result->string,procstr);
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
|
|
@ -115,4 +121,5 @@ int m_decapsulate(struct maddr * result, char * srci)
|
|||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
50
protocols.c
Normal file
50
protocols.c
Normal file
|
|
@ -0,0 +1,50 @@
|
|||
#include "protocols.h"
|
||||
#include "codecs.h"
|
||||
int main() //This won't exist, it's here for my own testing purposes.
|
||||
{
|
||||
load_protocols();
|
||||
pp();
|
||||
printf("The returned protocol is: %s\nSIZE: %d\n", proto_with_name("onion")->name, proto_with_name("onion")->size);
|
||||
printf("The returned protocol is: %s\nSIZE: %d\n", proto_with_deccode(444)->name, proto_with_deccode(444)->size);
|
||||
for(int i=0; i<14; i++)
|
||||
{
|
||||
uint64_t extract = (protocol_P+i)->deccode;
|
||||
char exhexco[20] = "\0";
|
||||
strcpy(exhexco, Num_To_HexVar_64(extract));
|
||||
uint64_t decimalval = HexVar_To_Num_64(exhexco);
|
||||
if(i<9){printf("PROTOCOL 0%d HAS HEXCODE: %s DECIMAL: %"PRIu64" \n", i+1, exhexco, decimalval);}
|
||||
else{printf("PROTOCOL %d HAS HEXCODE: %s DECIMAL: %"PRIu64" \n", i+1, exhexco, decimalval);};
|
||||
}
|
||||
free(protocol_P);
|
||||
printf("1337 in Hexvar_64: %s\n", Num_To_HexVar_64(1337));
|
||||
char HEXSTR[20] = "B90A0000000000000000"; //\0 since it's not defined in a source string
|
||||
uint64_t result = HexVar_To_Num_64(HEXSTR);
|
||||
result = HexVar_To_Num_64(HEXSTR);
|
||||
printf("Hexvar_To_Num_64: %"PRIu64"\n", result);
|
||||
uint8_t Numinvar[10] = {0};
|
||||
memcpy(Numinvar, Num_To_Varint_64(1337), 10);
|
||||
printf("Binary form unreadable obviously : %s\n", Numinvar);
|
||||
uint64_t Varinnum = 0;
|
||||
memcpy(&Varinnum, Varint_To_Num_64(Numinvar), sizeof(Varint_To_Num_64(Numinvar)));
|
||||
printf("Number form now readable again:%"PRIu64"\n", Varinnum);
|
||||
char converted2hex[20] = "\0";
|
||||
strcpy(converted2hex, Var_To_Hex(Numinvar));
|
||||
uint8_t converted2bin[10] = {0};
|
||||
memcpy(converted2bin, Hex_To_Var(converted2hex), 10);
|
||||
printf("Encoding previous binary to hex now: %s\n", converted2hex);
|
||||
printf("Encoding previous hex to binary now: %s\n", converted2bin);
|
||||
//Series of bytes test
|
||||
int8_t bcounter = 0;
|
||||
bcounter = Var_Bytes_Count(Numinvar);
|
||||
printf("Bytes_Count of Numinvar(1337): %d\n", bcounter);
|
||||
char int2hex[20] = "\0";
|
||||
strcat(int2hex, Int_To_Hex(1337));
|
||||
printf("INT2HEX: %s\n", int2hex);
|
||||
/*TESTING ENDIAN // Aparently won't be needed.
|
||||
printf("Testing Endian:\n");
|
||||
uint32_t val32 = 1337;
|
||||
printf("val32 = %d swapped val32 = %d\n",val32, htole32(val32));
|
||||
printf("val32 = 0x%08x swapped val32 = 0x%08x\n\n",val32, htole32(val32));
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
202
protoutils.h
202
protoutils.h
|
|
@ -247,6 +247,7 @@ char * int2ip(int inputintip)
|
|||
{
|
||||
uint32_t ipint = inputintip;
|
||||
static char xxx_int2ip_result[16] = "\0";
|
||||
bzero(xxx_int2ip_result,16);
|
||||
uint32_t ipint0 = (ipint >> 8*3) % 256;
|
||||
uint32_t ipint1 = (ipint >> 8*2) % 256;
|
||||
uint32_t ipint2 = (ipint >> 8*1) % 256;
|
||||
|
|
@ -255,112 +256,100 @@ char * int2ip(int inputintip)
|
|||
return xxx_int2ip_result;
|
||||
}
|
||||
//I didn't feel another address_bytes_to_string was necesarry sry guys
|
||||
int bytes_to_string(char * result, uint8_t * frombuf, size_t weesize)
|
||||
int bytes_to_string(char * resultzx, uint8_t * catx,int xbsize)
|
||||
{
|
||||
char removedlines[weesize*2];
|
||||
bzero(removedlines,sizeof(removedlines));
|
||||
strcpy(removedlines, Var_To_Hex(frombuf));
|
||||
//printf("Bytes to Hex: %s\n",removedlines);
|
||||
bzero(resultzx,200);
|
||||
uint8_t * bytes = NULL;
|
||||
int size = 0;
|
||||
size = xbsize;
|
||||
load_protocols();
|
||||
int thelastpos=0;
|
||||
for(int i=0;i<sizeof(removedlines);i++)
|
||||
char hex[xbsize*2];
|
||||
bzero(hex,xbsize*2);
|
||||
strcat(hex,Var_To_Hex(size, catx));
|
||||
//Positioning for memory jump:
|
||||
int lastpos = 0;
|
||||
char pid[3];
|
||||
//Process Hex String
|
||||
NAX:
|
||||
//Stage 1 ID:
|
||||
if(lastpos!=0)
|
||||
{
|
||||
if(thelastpos!=0)
|
||||
{
|
||||
i = thelastpos;
|
||||
thelastpos=0;
|
||||
lastpos+1;
|
||||
}
|
||||
char protocol[2];
|
||||
bzero(protocol,2);
|
||||
protocol[0] = removedlines[i];
|
||||
protocol[1] = removedlines[i+1];
|
||||
if(proto_with_deccode(Hex_To_Int(protocol))!=NULL)
|
||||
pid[0] = hex[lastpos];
|
||||
pid[1] = hex[lastpos+1];
|
||||
pid[2] = '\0';
|
||||
if(lastpos == 0)
|
||||
{
|
||||
//printf("Cproto: %s - %lu\n",protocol,Hex_To_Int(protocol));
|
||||
struct protocol * bprotox;
|
||||
bprotox = proto_with_deccode(Hex_To_Int(protocol));
|
||||
//Getting the address!
|
||||
char the_wanted_address[50];
|
||||
int ffpos=0;
|
||||
int zxp=0;
|
||||
int addrsizesofar=0;
|
||||
bzero(the_wanted_address,50);
|
||||
char isitp[2] = "\0";
|
||||
bzero(isitp,2);
|
||||
for(int zx=i+2;zx<sizeof(removedlines);zx++)
|
||||
load_protocols();
|
||||
}
|
||||
if(proto_with_deccode(Hex_To_Int(pid)))
|
||||
{
|
||||
//printf("ZX: %d\n",zx);
|
||||
if(zx%2==0)
|
||||
{
|
||||
isitp[0] = removedlines[zx];
|
||||
isitp[1] = removedlines[zx+1];
|
||||
struct protocol * izp;
|
||||
izp=proto_with_deccode(Hex_To_Int(isitp));
|
||||
if(izp)
|
||||
//////////Stage 2: Address
|
||||
struct protocol * PID;
|
||||
PID = NULL;
|
||||
PID = proto_with_deccode(Hex_To_Int(pid));
|
||||
lastpos = lastpos+2;
|
||||
char address[(PID->size/4)+1];
|
||||
bzero(address,(PID->size/4)+1);
|
||||
address[(PID->size/4)]='\0';
|
||||
int x=0;
|
||||
//printf("\nHEX TO DECODE: %s\n",hex);
|
||||
for(int i = lastpos;i<(PID->size/4)+lastpos;i++)
|
||||
{
|
||||
address[x] = hex[i];
|
||||
//printf("HEX[%d]=%c\n",i,hex[i]);
|
||||
x++;
|
||||
}
|
||||
//////////Stage 3 Process it back to string
|
||||
//printf("Protocol: %s\n", PID->name);
|
||||
//printf("Address : %s\n", address);
|
||||
lastpos= lastpos+(PID->size/4);
|
||||
//printf("lastpos: %d",lastpos);
|
||||
|
||||
if(addrsizesofar == (bprotox->size/4))
|
||||
//////////Address:
|
||||
//Keeping Valgrind happy
|
||||
char name[30];
|
||||
bzero(name,30);
|
||||
strcpy(name, PID->name);
|
||||
//
|
||||
strcat(resultzx, "/");
|
||||
strcat(resultzx, name);
|
||||
strcat(resultzx, "/");
|
||||
if(strcmp(name, "ip4")==0)
|
||||
{
|
||||
printf("%d -- %d\n", addrsizesofar, (bprotox->size/4));
|
||||
the_wanted_address[zxp]='\0';
|
||||
thelastpos=zx;
|
||||
printf("THELASTPOS: %d ",thelastpos);
|
||||
break;
|
||||
strcat(resultzx,int2ip(Hex_To_Int(address)));
|
||||
}
|
||||
else if(addrsizesofar>(bprotox->size/4))
|
||||
{
|
||||
printf("MALFORMED STRING!!!\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
}
|
||||
//printf("RL[%d]: %c\n",zx,removedlines[zx]);
|
||||
//printf("RL[%d]: %c\n",zx,removedlines[zx+1]);
|
||||
}
|
||||
addrsizesofar++;
|
||||
the_wanted_address[zxp] = removedlines[zx];
|
||||
zxp++;
|
||||
}
|
||||
|
||||
printf("And the address:%s\n", the_wanted_address);
|
||||
printf("With size: %d\n", addrsizesofar);
|
||||
//printf("%d < %lu\n", i,sizeof(removedlines));
|
||||
strcat(result, "/");
|
||||
strcat(result,bprotox->name);
|
||||
strcat(result, "/");
|
||||
if(strcmp(bprotox->name,"ip4")==0)
|
||||
{
|
||||
strcat(result,int2ip(Hex_To_Int(the_wanted_address)));
|
||||
}
|
||||
else if(strcmp(bprotox->name,"tcp")==0)
|
||||
else if(strcmp(name, "tcp")==0)
|
||||
{
|
||||
char a[5];
|
||||
sprintf(a,"%lu",Hex_To_Int(the_wanted_address));
|
||||
strcat(result,a);
|
||||
sprintf(a,"%lu",Hex_To_Int(address));
|
||||
strcat(resultzx,a);
|
||||
}
|
||||
else if(strcmp(bprotox->name,"udp")==0)
|
||||
else if(strcmp(name, "udp")==0)
|
||||
{
|
||||
char a[5];
|
||||
sprintf(a,"%lu",Hex_To_Int(the_wanted_address));
|
||||
strcat(result,a);
|
||||
sprintf(a,"%lu",Hex_To_Int(address));
|
||||
strcat(resultzx,a);
|
||||
}
|
||||
else
|
||||
//printf("Address(hex):%s\n",address);
|
||||
//printf("TESTING: %s\n",resultzx);
|
||||
/////////////Done processing this, move to next if there is more.
|
||||
if(lastpos<size*2)
|
||||
{
|
||||
return 0;
|
||||
goto NAX;
|
||||
}
|
||||
}
|
||||
i++;
|
||||
}
|
||||
strcat(resultzx, "/");
|
||||
unload_protocols();
|
||||
strcat(result,"/");
|
||||
return 1;
|
||||
|
||||
}
|
||||
|
||||
//
|
||||
|
||||
char * address_string_to_bytes(struct protocol * xx, char * abc,size_t getsznow)
|
||||
{
|
||||
static char astb__stringy[10] = "\0";
|
||||
static char astb__stringy[200] = "\0";
|
||||
bzero(astb__stringy,200);
|
||||
int code = 0;
|
||||
code = xx->deccode;
|
||||
switch(code)
|
||||
|
|
@ -368,6 +357,7 @@ char * address_string_to_bytes(struct protocol * xx, char * abc,size_t getsznow)
|
|||
case 4://IPv4
|
||||
{
|
||||
char testip[16] = "\0";
|
||||
bzero(testip,16);
|
||||
strcpy(testip,abc);
|
||||
if(is_valid_ipv4(testip)==1)
|
||||
{
|
||||
|
|
@ -483,7 +473,7 @@ char * address_string_to_bytes(struct protocol * xx, char * abc,size_t getsznow)
|
|||
}
|
||||
case 42://IPFS - !!!
|
||||
{
|
||||
//abc=address
|
||||
|
||||
break;
|
||||
}
|
||||
case 480://http
|
||||
|
|
@ -519,14 +509,15 @@ char * address_string_to_bytes(struct protocol * xx, char * abc,size_t getsznow)
|
|||
}
|
||||
}
|
||||
}
|
||||
int string_to_bytes(uint8_t * finalbytes,char * strx, size_t strsize)
|
||||
int string_to_bytes(uint8_t * finalbytes,int * realbbsize,char * strx, size_t strsize)
|
||||
{
|
||||
static char xxx[40] = "\0";
|
||||
bzero(xxx,40);
|
||||
static char xxx[200] = "\0";
|
||||
bzero(xxx,200);
|
||||
int sigmalf = 0;
|
||||
char * totpch;
|
||||
char totalwordstest[strsize];
|
||||
strcpy(totalwordstest, strx);
|
||||
bzero(totalwordstest,strsize);
|
||||
strcat(totalwordstest, strx);
|
||||
int totalwords = 0;
|
||||
totpch = strtok(totalwordstest, "/");
|
||||
while(totpch != NULL)
|
||||
|
|
@ -535,8 +526,10 @@ int string_to_bytes(uint8_t * finalbytes,char * strx, size_t strsize)
|
|||
totalwords++;
|
||||
}
|
||||
int processedwords = 0;
|
||||
char processedsofar[500] = "\0";
|
||||
char processedsofar[100];
|
||||
bzero(processedsofar,100);
|
||||
char str[strsize]; //This string will be bad later.
|
||||
bzero(str,strsize);
|
||||
nextproc:
|
||||
strcpy(str,strx);
|
||||
if(str[0] == '/')
|
||||
|
|
@ -557,10 +550,12 @@ int string_to_bytes(uint8_t * finalbytes,char * strx, size_t strsize)
|
|||
struct protocol * protx;
|
||||
//printf("PCH-P:%s\n",pch);
|
||||
protx = proto_with_name(pch);
|
||||
char cut[30]="\0";
|
||||
char cut[3]="\0";
|
||||
bzero(cut,3);
|
||||
strcat(cut,Int_To_Hex(protx->deccode));
|
||||
cut[2] = '\0';
|
||||
char finipbit[2] = "\0";
|
||||
char finipbit[3] = "\0";
|
||||
bzero(finipbit,3);
|
||||
finipbit[0] = cut[0];
|
||||
finipbit[1] = cut[1];
|
||||
finipbit[2] = '\0';
|
||||
|
|
@ -570,7 +565,8 @@ int string_to_bytes(uint8_t * finalbytes,char * strx, size_t strsize)
|
|||
strcat(processedsofar, pch);
|
||||
//printf("PCH-A:%s\n",pch);
|
||||
char addr[60] = "\0";
|
||||
strcpy(addr, pch);
|
||||
bzero(addr,60);
|
||||
strcat(addr, pch);
|
||||
//If both are ok:
|
||||
strcat(xxx,finipbit);
|
||||
if(address_string_to_bytes(protx, addr,sizeof(addr)))
|
||||
|
|
@ -610,30 +606,20 @@ int string_to_bytes(uint8_t * finalbytes,char * strx, size_t strsize)
|
|||
{
|
||||
//printf("S2B_RESULT: %s\n", xxx);
|
||||
//static uint8_t finalbytes[100] = {0};
|
||||
for(int i=0; i<100; i++)
|
||||
{
|
||||
finalbytes[i] = 0;
|
||||
}
|
||||
bzero(finalbytes,100);
|
||||
//printf("XXX: %s\n",xxx);
|
||||
memcpy(finalbytes, Hex_To_Var(xxx), 100);
|
||||
int xtotbytes = 0;
|
||||
realbbsize[0] = 0;
|
||||
for(int i=0;i<100;i++)
|
||||
{
|
||||
if(finalbytes[i] != 0)
|
||||
if(finalbytes[i])
|
||||
{
|
||||
xtotbytes++;
|
||||
realbbsize[0]++;
|
||||
}
|
||||
}
|
||||
//printf("TOT BYTES: %d\n", xtotbytes);
|
||||
uint8_t finalproc[sizeof(finalbytes)/sizeof(finalbytes)[0]];
|
||||
for(int i=0;i<sizeof(finalproc); i++)
|
||||
{
|
||||
if(finalbytes[i] != 0)
|
||||
{
|
||||
finalproc[i] = '\0';
|
||||
}
|
||||
}
|
||||
//printf("FinalBytes: %s\n",finalbytes);
|
||||
//printf("Finaltest: %s",Var_To_Hex(finalbytes));
|
||||
//printf("FB2XXX: %s\nWith size: %u\n",Var_To_Hex(finalbytes), realbbsize[0]);
|
||||
//realbsize = realsize;
|
||||
//printf("REALbBSZIE: %d", realbbsize[0]);
|
||||
return 1;//success
|
||||
}
|
||||
else
|
||||
|
|
|
|||
187
varhexutils.h
187
varhexutils.h
|
|
@ -13,7 +13,7 @@
|
|||
memcpy(encbe, htobe32(ebex32));
|
||||
return encbe;
|
||||
}*/
|
||||
int8_t Var_Bytes_Count(uint8_t countbytesofthis[10])
|
||||
int8_t Var_Bytes_Count(uint8_t * countbytesofthis)
|
||||
{
|
||||
static int8_t xrzk_bytescnt = 0;
|
||||
for(int8_t i=0; i<10; i++)
|
||||
|
|
@ -27,38 +27,40 @@ int8_t Var_Bytes_Count(uint8_t countbytesofthis[10])
|
|||
}
|
||||
uint8_t * Num_To_Varint_64(uint64_t TOV64INPUT) //UINT64_T TO VARINT
|
||||
{
|
||||
static uint8_t buffy_001[10] = {0};
|
||||
uvarint_encode64(TOV64INPUT, buffy_001, 10);
|
||||
static uint8_t buffy_001[60] = {0};
|
||||
uvarint_encode64(TOV64INPUT, buffy_001, 60);
|
||||
return buffy_001;
|
||||
}
|
||||
uint8_t * Num_To_Varint_32(uint32_t TOV32INPUT) // UINT32_T TO VARINT
|
||||
{
|
||||
static uint8_t buffy_032[10] = {0};
|
||||
uvarint_encode32(TOV32INPUT, buffy_032, 10);
|
||||
static uint8_t buffy_032[60] = {0};
|
||||
uvarint_encode32(TOV32INPUT, buffy_032, 60);
|
||||
return buffy_032;
|
||||
}
|
||||
uint64_t * Varint_To_Num_64(uint8_t TON64INPUT[10]) //VARINT TO UINT64_t
|
||||
uint64_t * Varint_To_Num_64(uint8_t TON64INPUT[60]) //VARINT TO UINT64_t
|
||||
{
|
||||
static uint64_t varintdecode_001 = 0;
|
||||
uvarint_decode64(TON64INPUT, 10, &varintdecode_001);
|
||||
uvarint_decode64(TON64INPUT, 60, &varintdecode_001);
|
||||
return &varintdecode_001;
|
||||
}
|
||||
uint32_t * Varint_To_Num_32(uint8_t TON32INPUT[10]) //VARINT TO UINT32_t
|
||||
uint32_t * Varint_To_Num_32(uint8_t TON32INPUT[60]) //VARINT TO UINT32_t
|
||||
{
|
||||
static uint32_t varintdecode_032 = 0;
|
||||
uvarint_decode32(TON32INPUT, 10, &varintdecode_032);
|
||||
uvarint_decode32(TON32INPUT, 60, &varintdecode_032);
|
||||
return &varintdecode_032;
|
||||
}
|
||||
//
|
||||
char * Int_To_Hex(uint64_t int2hex) //VAR[binformat] TO HEX
|
||||
{
|
||||
static char int2hex_result[20]="\0";
|
||||
static char int2hex_result[200]="\0";
|
||||
memset(int2hex_result,0,sizeof(int2hex_result));
|
||||
sprintf (int2hex_result, "%02lX", int2hex);
|
||||
return int2hex_result;
|
||||
}
|
||||
uint64_t Hex_To_Int(char *hex)
|
||||
uint64_t Hex_To_Int(char * hax)
|
||||
{
|
||||
char * hex = NULL;
|
||||
hex=hax;
|
||||
uint64_t val = 0;
|
||||
while (*hex)
|
||||
{
|
||||
|
|
@ -74,48 +76,63 @@ uint64_t Hex_To_Int(char *hex)
|
|||
return val;
|
||||
}
|
||||
//
|
||||
char * Var_To_Hex(uint8_t * TOHEXINPUT) //VAR[binformat] TO HEX
|
||||
void vthconvert(int size, char * crrz01, uint8_t * xbuf)
|
||||
{
|
||||
uint8_t buf[100];
|
||||
bzero(buf,100);
|
||||
|
||||
//fixing the buf
|
||||
for(int cz=0; cz<size;cz++)
|
||||
{
|
||||
buf[cz] = xbuf[cz];
|
||||
}
|
||||
//
|
||||
if(crrz01!=NULL)
|
||||
{
|
||||
char * crrz1 = NULL;
|
||||
crrz1 = crrz01;
|
||||
char conv_proc[200]="\0";
|
||||
int i;
|
||||
for(i=0; i < (size*2); i++)
|
||||
{
|
||||
if(buf[i]!='\0')
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
//printf("%d:%d\n",i, buf[i]);
|
||||
strcat(crrz1, conv_proc);
|
||||
}
|
||||
}
|
||||
crrz1 = NULL;
|
||||
}
|
||||
}
|
||||
char * Var_To_Hex(int realsize, uint8_t * TOHEXINPUT) //VAR[binformat] TO HEX
|
||||
{
|
||||
for(int ix=realsize;ix<100;ix++)
|
||||
{
|
||||
TOHEXINPUT[ix] = '\0';
|
||||
}
|
||||
if(TOHEXINPUT != NULL)
|
||||
{
|
||||
static char convert_resultz1[105]="\0";
|
||||
memset(convert_resultz1,0,sizeof(convert_resultz1));
|
||||
void convert(uint8_t * buf)
|
||||
{
|
||||
char conv_proc[100]="\0";
|
||||
for(int i=0; i < 100; i++)
|
||||
{
|
||||
if(buf[i]!=0)
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
//printf("%d:%d\n",i, buf[i]);
|
||||
strcat(convert_resultz1, conv_proc);
|
||||
}
|
||||
if(buf[i]==0 && buf[i+1]!=0)
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
//printf("%d:%d\n",i, buf[i]);
|
||||
strcat(convert_resultz1, conv_proc);
|
||||
}
|
||||
}
|
||||
}
|
||||
convert(TOHEXINPUT);
|
||||
static char convert_resultz1[200]="\0";
|
||||
bzero(convert_resultz1,200);
|
||||
vthconvert(realsize, convert_resultz1, TOHEXINPUT);
|
||||
return convert_resultz1;
|
||||
}
|
||||
}
|
||||
uint8_t * Hex_To_Var(char * Hexstr) //HEX TO VAR[BINFORMAT]
|
||||
{
|
||||
static uint8_t buffy_HEX[105] = {0};
|
||||
for(int i=0;i<105;i++)
|
||||
{
|
||||
buffy_HEX[i] = 0;
|
||||
}
|
||||
char codo[105] = "\0";
|
||||
static uint8_t buffy_HEX[100] = {0};
|
||||
bzero(buffy_HEX,100);
|
||||
int i;
|
||||
char codo[200] = "\0";
|
||||
bzero(codo,200);
|
||||
strcpy(codo, Hexstr);
|
||||
char code[3] = "\0";
|
||||
char code[3];
|
||||
bzero(code,3);
|
||||
code[3]='\0';
|
||||
int x = 0;
|
||||
int fori001=0;
|
||||
for(fori001=0;fori001<105;fori001++)
|
||||
for(fori001=0;fori001<200;fori001++)
|
||||
{
|
||||
strncpy(&code[0],&codo[fori001],1);
|
||||
strncpy(&code[1],&codo[fori001+1],1);
|
||||
|
|
@ -130,57 +147,67 @@ uint8_t * Hex_To_Var(char * Hexstr) //HEX TO VAR[BINFORMAT]
|
|||
return buffy_HEX;
|
||||
}
|
||||
//
|
||||
char * Num_To_HexVar_64(uint64_t TOHVINPUT) //UINT64 TO HEXIFIED VAR
|
||||
{ //Code to varint - py
|
||||
static char convert_result[10]="\0";//Note that the hex resulted from this will differ from py
|
||||
memset(convert_result,0,sizeof(convert_result));//But if you make sure the string is always 20 chars in size
|
||||
void convert(uint8_t buf[10]) //Both of them read them properly.
|
||||
void convert(char * convert_result, uint8_t * buf) //Both of them read them properly.
|
||||
{
|
||||
char conv_proc[10]="\0";
|
||||
int i=0;
|
||||
for(; i < 10; i++)
|
||||
char conv_proc[200]="\0";
|
||||
bzero(conv_proc,200);
|
||||
int i;
|
||||
for(i=0; i < 10; i++)
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
//printf("%d:%d\n",i, buf[i]);
|
||||
strcat(convert_result, conv_proc);
|
||||
}
|
||||
}
|
||||
uint8_t buf[10] = {0};
|
||||
uvarint_encode64(TOHVINPUT, buf, 10);
|
||||
convert(buf);
|
||||
|
||||
char * Num_To_HexVar_64(uint64_t TOHVINPUT) //UINT64 TO HEXIFIED VAR
|
||||
{ //Code to varint - py
|
||||
static char convert_result[200]="\0";//Note that the hex resulted from this will differ from py
|
||||
bzero(convert_result,200);
|
||||
memset(convert_result,0,sizeof(convert_result));//But if you make sure the string is always 20 chars in size
|
||||
uint8_t buf[100] = {0};
|
||||
bzero(buf,100);
|
||||
uvarint_encode64(TOHVINPUT, buf, 200);
|
||||
convert(convert_result,buf);
|
||||
return convert_result;
|
||||
}
|
||||
void convert2(char * convert_result2, uint8_t * bufhx)
|
||||
{
|
||||
uint8_t * buf = NULL;
|
||||
buf = bufhx;
|
||||
char conv_proc[3]="\0";
|
||||
conv_proc[3] = '\0';
|
||||
bzero(conv_proc, 3);
|
||||
int i;
|
||||
for(i=0; i == 0; i++)
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
//printf("aaaaaaaaaaah%d:%d\n",i, buf[i]);
|
||||
strcat(convert_result2, conv_proc);
|
||||
}
|
||||
buf = NULL;
|
||||
}
|
||||
char * Num_To_HexVar_32(uint32_t TOHVINPUT) //UINT32 TO HEXIFIED VAR
|
||||
{ //Code to varint - py
|
||||
static char convert_result2[20]="\0";
|
||||
static char convert_result2[3]="\0";
|
||||
bzero(convert_result2,3);
|
||||
convert_result2[2] = '\0';
|
||||
memset(convert_result2,0,sizeof(convert_result2));
|
||||
void convert(uint8_t buf[10])
|
||||
{
|
||||
char conv_proc[10]="\0";
|
||||
int i=0;
|
||||
for(; i < 10; i++)
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
printf("%d:%d\n",i, buf[i]);
|
||||
strcat(convert_result2, conv_proc);
|
||||
}
|
||||
}
|
||||
uint8_t buf[10] = {0};
|
||||
uvarint_encode32(TOHVINPUT, buf, 10);
|
||||
convert(buf);
|
||||
|
||||
uint8_t buf[1] = {0};
|
||||
bzero(buf,1);
|
||||
uvarint_encode32(TOHVINPUT, buf, 1);
|
||||
convert2(convert_result2,buf);
|
||||
return convert_result2;
|
||||
}
|
||||
|
||||
uint64_t HexVar_To_Num_64(char * theHEXstring) //HEXIFIED VAR TO UINT64_T
|
||||
{ //Varint to code - py
|
||||
uint8_t buffy[10] = {0};
|
||||
char codo[20] = "\0";
|
||||
uint8_t buffy[100] = {0};
|
||||
char codo[200] = "\0";
|
||||
bzero(codo,200);
|
||||
strcpy(codo, theHEXstring);
|
||||
char code[3] = "\0";
|
||||
int x = 0;
|
||||
for(int i= 0;i<20;i++)
|
||||
for(int i= 0;i<199;i++)
|
||||
{
|
||||
strncpy(&code[0],&codo[i],1);
|
||||
strncpy(&code[1],&codo[i+1],1);
|
||||
|
|
@ -192,17 +219,21 @@ uint64_t HexVar_To_Num_64(char * theHEXstring) //HEXIFIED VAR TO UINT64_T
|
|||
x++;
|
||||
}
|
||||
static uint64_t decoded;
|
||||
uvarint_decode64 (buffy, 10, &decoded);
|
||||
uvarint_decode64 (buffy, 100, &decoded);
|
||||
return decoded;
|
||||
}
|
||||
uint32_t HexVar_To_Num_32(char theHEXstring[]) //HEXIFIED VAR TO UINT32_T
|
||||
{ //Varint to code py
|
||||
uint8_t buffy[10] = {0};
|
||||
char codo[20] = "\0";
|
||||
uint8_t buffy[100] = {0};
|
||||
bzero(buffy,100);
|
||||
char codo[200] = "\0";
|
||||
bzero(codo,200);
|
||||
strcpy(codo, theHEXstring);
|
||||
char code[2] = "\0";
|
||||
char code[3] = "\0";
|
||||
bzero(code,3);
|
||||
code[3] = '\0';
|
||||
int x = 0;
|
||||
for(int i= 0;i<20;i++)
|
||||
for(int i= 0;i<199;i++)
|
||||
{
|
||||
strncpy(&code[0],&codo[i],1);
|
||||
strncpy(&code[1],&codo[i+1],1);
|
||||
|
|
|
|||
Loading…
Reference in a new issue