agorise/c-multiaddr
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Update

Browse source
This commit is contained in:
xethyrion 2016-11-08 13:02:45 +02:00 committed by GitHub
parent 7b1ed7a4a4
commit 483957077e
4 changed files with 296 additions and 222 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

29
multiaddr.h
View file

@ -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
View 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;
}

234
protoutils.h
View file

@ -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;
}
char protocol[2];
bzero(protocol,2);
protocol[0] = removedlines[i];
protocol[1] = removedlines[i+1];
if(proto_with_deccode(Hex_To_Int(protocol))!=NULL)
{
//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++)
{
//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)
{
if(addrsizesofar == (bprotox->size/4))
{
printf("%d -- %d\n", addrsizesofar, (bprotox->size/4));
the_wanted_address[zxp]='\0';
thelastpos=zx;
printf("THELASTPOS: %d ",thelastpos);
break;
}
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)
{
char a[5];
sprintf(a,"%lu",Hex_To_Int(the_wanted_address));
strcat(result,a);
}
else if(strcmp(bprotox->name,"udp")==0)
{
char a[5];
sprintf(a,"%lu",Hex_To_Int(the_wanted_address));
strcat(result,a);
}
else
{
return 0;
}
}
i++;
lastpos+1;
}
pid[0] = hex[lastpos];
pid[1] = hex[lastpos+1];
pid[2] = '\0';
if(lastpos == 0)
{
load_protocols();
}
if(proto_with_deccode(Hex_To_Int(pid)))
{
//////////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);
//////////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)
{
strcat(resultzx,int2ip(Hex_To_Int(address)));
}
else if(strcmp(name, "tcp")==0)
{
char a[5];
sprintf(a,"%lu",Hex_To_Int(address));
strcat(resultzx,a);
}
else if(strcmp(name, "udp")==0)
{
char a[5];
sprintf(a,"%lu",Hex_To_Int(address));
strcat(resultzx,a);
}
//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)
{
goto NAX;
}
}
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;
for(int i=0; i<100; i++)
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

205
varhexutils.h
View file

@ -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,95 +27,112 @@ 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)
{
// get current character then increment
uint8_t byte = *hex++;
// transform hex character to the 4bit equivalent number, using the ascii table indexes
if (byte >= '0' && byte <= '9') byte = byte - '0';
else if (byte >= 'a' && byte <='f') byte = byte - 'a' + 10;
else if (byte >= 'A' && byte <='F') byte = byte - 'A' + 10;
// shift 4 to make space for new digit, and add the 4 bits of the new digit
val = (val << 4) | (byte & 0xF);
}
return val;
// get current character then increment
uint8_t byte = *hex++;
// transform hex character to the 4bit equivalent number, using the ascii table indexes
if (byte >= '0' && byte <= '9') byte = byte - '0';
else if (byte >= 'a' && byte <='f') byte = byte - 'a' + 10;
else if (byte >= 'A' && byte <='F') byte = byte - 'A' + 10;
// shift 4 to make space for new digit, and add the 4 bits of the new digit
val = (val << 4) | (byte & 0xF);
}
return val;
}
//
char * Var_To_Hex(uint8_t * TOHEXINPUT) //VAR[binformat] TO HEX
void vthconvert(int size, char * crrz01, uint8_t * xbuf)
{
if(TOHEXINPUT != NULL)
uint8_t buf[100];
bzero(buf,100);
//fixing the buf
for(int cz=0; cz<size;cz++)
{
static char convert_resultz1[105]="\0";
memset(convert_resultz1,0,sizeof(convert_resultz1));
void convert(uint8_t * buf)
buf[cz] = xbuf[cz];
}
//
if(crrz01!=NULL)
{
char conv_proc[100]="\0";
for(int i=0; i < 100; i++)
char * crrz1 = NULL;
crrz1 = crrz01;
char conv_proc[200]="\0";
int i;
for(i=0; i < (size*2); i++)
{
if(buf[i]!=0)
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);
strcat(crrz1, conv_proc);
}
}
crrz1 = NULL;
}
convert(TOHEXINPUT);
return convert_resultz1;
}
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[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;
}
//
void convert(char * convert_result, uint8_t * buf) //Both of them read them properly.
{
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);
}
}
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
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
void convert(uint8_t buf[10]) //Both of them read them properly.
{
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_result, conv_proc);
}
}
uint8_t buf[10] = {0};
uvarint_encode64(TOHVINPUT, buf, 10);
convert(buf);
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);