Compare commits
4 commits
master
...
Version-0.
Author | SHA1 | Date | |
---|---|---|---|
|
e995693b53 | ||
|
1abe88b616 | ||
|
cc545f880b | ||
|
2cc0a0b4c6 |
6 changed files with 487 additions and 0 deletions
20
STATUS
Normal file
20
STATUS
Normal file
|
@ -0,0 +1,20 @@
|
|||
Work status:
|
||||
|
||||
1) varhexutils: Done
|
||||
-Collection of utilities for easy conversions in C
|
||||
2) varint.h/varint/c: Done
|
||||
-Varint Encoded bytes convertor
|
||||
3) protocols.h: Mostly done, not sure if anything else is needed yet.
|
||||
-Protocol Structure Library needed for multiaddr.
|
||||
4) protocols.c: Example of how they work so far.
|
||||
|
||||
5) proto-dat: Simple file to store our protocols.
|
||||
|
||||
Todo:
|
||||
--Work on overall compatibility
|
||||
--More testing
|
||||
--Make functions simpler
|
||||
! Find working base58/base64 converters
|
||||
1) utils.h
|
||||
2) codecs.h
|
||||
3) multiaddr.h
|
42
protocols.c
Normal file
42
protocols.c
Normal file
|
@ -0,0 +1,42 @@
|
|||
#include "protocols.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);
|
||||
|
||||
|
||||
return 0;
|
||||
}
|
196
protocols.h
Normal file
196
protocols.h
Normal file
|
@ -0,0 +1,196 @@
|
|||
#ifndef PROTOCOLS
|
||||
#define PROTOCOLS
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <errno.h>
|
||||
#include "varhexutils.h"
|
||||
int CNT_PROTOCOLNUM=0;
|
||||
struct protocol
|
||||
{
|
||||
char hexcode[21];
|
||||
int deccode;
|
||||
int size;
|
||||
char name[30];
|
||||
};
|
||||
struct protocol *protocol_P; //Pointer for holding multiple structures
|
||||
int protocol_REMOVE_id(int remid)//Function to remove & shift back all data, sort of like c++ vectors.
|
||||
{
|
||||
|
||||
if(remid < CNT_PROTOCOLNUM && remid >= 0) //Checking to see if remid actually exists.
|
||||
{
|
||||
for(int i=remid; i<CNT_PROTOCOLNUM; i++) //While i < num of registered protocols
|
||||
{
|
||||
strcpy((protocol_P+i)->hexcode, (protocol_P+i+1)->hexcode); //shift memory to the user we want to remove.
|
||||
(protocol_P+i)->deccode = (protocol_P+i+1)->deccode; //Same as above
|
||||
(protocol_P+i)->size = (protocol_P+i+1)->size; //Same as above
|
||||
strcpy((protocol_P+i)->name, (protocol_P+i+1)->name); //Same as above
|
||||
}//Overwriting user done. Time to get rid of that extra memory.
|
||||
protocol_P = (struct protocol*) realloc(protocol_P, (CNT_PROTOCOLNUM-1) * sizeof(struct protocol));
|
||||
//Memory erased,
|
||||
CNT_PROTOCOLNUM--; //Since the record no longer exists, we should decrease the ammount of users.
|
||||
return 1; //Purely for error checking, in case someone ever wants it/
|
||||
} //1 = Success
|
||||
else
|
||||
{
|
||||
printf("ERROR");
|
||||
return 0;//0 = Failure.
|
||||
}
|
||||
}
|
||||
void load_protocols()
|
||||
{
|
||||
FILE *FPROC_POINT; //File pointer.
|
||||
FPROC_POINT = fopen("proto-dat", "r");//Opening proto-dat Or protocols.csv, I just formatted it to my liking.
|
||||
if(FPROC_POINT != NULL) //While pointer is not null.
|
||||
{
|
||||
char W_BUFF[20] = "\0";//Char array to parse file.
|
||||
for(int i=0; fscanf(FPROC_POINT, "%s", W_BUFF) != EOF; i++) // Scanning file and incrementing for processing.
|
||||
{
|
||||
switch(i)
|
||||
{
|
||||
case 0: //First word - HEXCODE
|
||||
{
|
||||
//ADD MEMORY FOR NEW ROWS
|
||||
if(CNT_PROTOCOLNUM==0) //If there are no registered protocols yet, allocate memory to pointer.
|
||||
{
|
||||
protocol_P = (struct protocol*) malloc (sizeof(struct protocol));
|
||||
}
|
||||
else //Reallocate memory to fit one more protocol
|
||||
{
|
||||
protocol_P = (struct protocol*) realloc(protocol_P, (CNT_PROTOCOLNUM+1) * sizeof(struct protocol));
|
||||
}
|
||||
strcpy((protocol_P+CNT_PROTOCOLNUM)->hexcode, W_BUFF); //Copy word to structure at hexcode A hexcode is a string so we keep it as such
|
||||
break;
|
||||
}
|
||||
case 1://Second word - DECCODE
|
||||
{
|
||||
(protocol_P+CNT_PROTOCOLNUM)->deccode= atoi(W_BUFF); //Copy word to structure at deccode after converting it to int.
|
||||
break;
|
||||
}
|
||||
case 2://Third word - SIZE
|
||||
{
|
||||
(protocol_P+CNT_PROTOCOLNUM)->size= atoi(W_BUFF); //Copy word to structure at size after converting it to int.
|
||||
break;
|
||||
}
|
||||
case 3://Fourth word - NAME
|
||||
{
|
||||
strcpy((protocol_P+CNT_PROTOCOLNUM)->name, W_BUFF); //Copy word to structure at name // String
|
||||
i=-1;
|
||||
CNT_PROTOCOLNUM++;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
{
|
||||
printf("HOUSTON WE HAVE A PROBLEM!!!!\n");
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
fclose(FPROC_POINT);
|
||||
protocol_REMOVE_id(0);
|
||||
}
|
||||
else
|
||||
{
|
||||
perror("Fatal Error:");
|
||||
}
|
||||
}
|
||||
struct protocol * proto_with_name(char proto_w_name[]) //Search for protocol with inputted name
|
||||
{
|
||||
|
||||
for(int i=0; i<CNT_PROTOCOLNUM; i++)
|
||||
{
|
||||
if(strcmp(proto_w_name, (protocol_P+i)->name) == 0)
|
||||
{
|
||||
return (protocol_P+i);
|
||||
}
|
||||
}
|
||||
}
|
||||
struct protocol * proto_with_deccode(int proto_w_deccode) //Search for protocol with inputted deccode
|
||||
{
|
||||
for(int i=0; i<CNT_PROTOCOLNUM; i++)
|
||||
{
|
||||
if((protocol_P+i)->deccode == proto_w_deccode)
|
||||
{
|
||||
return (protocol_P+i);
|
||||
}
|
||||
}
|
||||
}
|
||||
void pp() //Purely for debugging purposes, prints the entire loaded protocols.
|
||||
{
|
||||
for(int i=0;i<CNT_PROTOCOLNUM;i++)
|
||||
{
|
||||
if(i>=9)
|
||||
{printf("=========== ~%d~ ===========\n", i+1);}
|
||||
else
|
||||
{printf("=========== ~0%d~ ===========\n", i+1);}
|
||||
printf(">> HEX-CODE: %s\n", (protocol_P+i)->hexcode);
|
||||
printf(">> DEC-CODE: %d\n", (protocol_P+i)->deccode);
|
||||
printf(">> SIZE: %d\n", (protocol_P+i)->size);
|
||||
printf(">> NAME: %s\n", (protocol_P+i)->name);
|
||||
}
|
||||
printf("----------------------------\n");
|
||||
printf("TOTAL PROTOCOLS: %d\n",CNT_PROTOCOLNUM);
|
||||
}
|
||||
void protocols_with_string(char * meee,int sizi) // NOT FINISHED, DO NOT USE!
|
||||
{
|
||||
int finalsize = 0;
|
||||
|
||||
if(!isalnum(meee[sizi-1]) && !isalnum(meee[sizi-1]))
|
||||
{
|
||||
//Everything is alright, it's nul terminated!;
|
||||
finalsize = sizi;
|
||||
}
|
||||
else
|
||||
{
|
||||
//Well houston we have a problem.
|
||||
finalsize = sizi+2;
|
||||
}
|
||||
char mestring[finalsize];
|
||||
strcpy(mestring, meee);
|
||||
if(sizi!=finalsize)
|
||||
{
|
||||
strcpy(mestring,"\0");
|
||||
}
|
||||
|
||||
char * words[50] = { NULL };
|
||||
int atword = 0;
|
||||
int mem = 0;
|
||||
for(int i=0; i<sizeof(mestring)-2; i++)
|
||||
{
|
||||
if(mestring[i] == '/')
|
||||
{
|
||||
printf("NEW WORD!\n");
|
||||
atword++;
|
||||
int currentsize = 0;
|
||||
for(int j = i+1; mestring[j] != '/' && j < sizeof(mestring)-2; j++)
|
||||
{
|
||||
currentsize++;
|
||||
}
|
||||
char haay[20];
|
||||
int lesbo = 0;
|
||||
for(int x = i+1; x<sizeof(mestring)-2; x++)
|
||||
{
|
||||
if(mestring[x] == '/')
|
||||
{
|
||||
break;
|
||||
}
|
||||
haay[lesbo] = mestring[x];
|
||||
lesbo++;
|
||||
}
|
||||
words[atword-1] = (char *) malloc(currentsize+2);
|
||||
strcpy(words[atword-1], haay);
|
||||
bzero(haay,20);
|
||||
}
|
||||
}
|
||||
printf("Result:%s\n", words[0]);
|
||||
for(int mm=0; mm < 50; mm++)
|
||||
{
|
||||
if(words[mm])
|
||||
{
|
||||
free(words[mm]);
|
||||
}
|
||||
}
|
||||
}
|
||||
#endif
|
170
varhexutils.h
Normal file
170
varhexutils.h
Normal file
|
@ -0,0 +1,170 @@
|
|||
#ifndef VARHEXUTILS
|
||||
#define VARHEXUTILS
|
||||
#include <stdio.h>
|
||||
#include <inttypes.h>
|
||||
#include "varint.h"
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
int8_t Var_Bytes_Count(uint8_t countbytesofthis[10])
|
||||
{
|
||||
static int8_t xrzk_bytescnt = 0;
|
||||
for(int8_t i=0; i<10; i++)
|
||||
{
|
||||
if(countbytesofthis[i] != 0)
|
||||
{
|
||||
xrzk_bytescnt++;
|
||||
}
|
||||
}
|
||||
return xrzk_bytescnt;
|
||||
}
|
||||
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);
|
||||
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);
|
||||
return buffy_032;
|
||||
}
|
||||
uint64_t * Varint_To_Num_64(uint8_t TON64INPUT[10]) //VARINT TO UINT64_t
|
||||
{
|
||||
static uint64_t varintdecode_001 = 0;
|
||||
uvarint_decode64(TON64INPUT, 10, &varintdecode_001);
|
||||
return &varintdecode_001;
|
||||
}
|
||||
uint32_t * Varint_To_Num_32(uint8_t TON32INPUT[10]) //VARINT TO UINT32_t
|
||||
{
|
||||
static uint32_t varintdecode_032 = 0;
|
||||
uvarint_decode32(TON32INPUT, 10, &varintdecode_032);
|
||||
return &varintdecode_032;
|
||||
}
|
||||
//
|
||||
char * Var_To_Hex(uint8_t TOHEXINPUT[10]) //VAR[binformat] TO HEX
|
||||
{
|
||||
static char convert_resultz1[10]="\0";
|
||||
memset(convert_resultz1,0,sizeof(convert_resultz1));
|
||||
void convert(uint8_t buf[10])
|
||||
{
|
||||
char conv_proc[10]="\0";
|
||||
for(int i=0; i < 10; i++)
|
||||
{
|
||||
sprintf (conv_proc, "%02X", buf[i]);
|
||||
//printf("%d:%d\n",i, buf[i]);
|
||||
strcat(convert_resultz1, conv_proc);
|
||||
}
|
||||
}
|
||||
convert(TOHEXINPUT);
|
||||
return convert_resultz1;
|
||||
}
|
||||
uint8_t * Hex_To_Var(char * Hexstr) //HEX TO VAR[BINFORMAT]
|
||||
{
|
||||
static uint8_t buffy_HEX[10] = {0};
|
||||
char codo[20] = "\0";
|
||||
strcpy(codo, Hexstr);
|
||||
char code[3] = "\0";
|
||||
int x = 0;
|
||||
for(int i= 0;i<20;i++)
|
||||
{
|
||||
strncpy(&code[0],&codo[i],1);
|
||||
strncpy(&code[1],&codo[i+1],1);
|
||||
char *ck = NULL;
|
||||
uint64_t lu = 0;
|
||||
lu=strtoul(code, &ck, 16);
|
||||
buffy_HEX[x] = lu;
|
||||
i++;
|
||||
x++;
|
||||
}
|
||||
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.
|
||||
{
|
||||
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);
|
||||
|
||||
return convert_result;
|
||||
}
|
||||
char * Num_To_HexVar_32(uint32_t TOHVINPUT) //UINT32 TO HEXIFIED VAR
|
||||
{ //Code to varint - py
|
||||
static char convert_result2[10]="\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);
|
||||
|
||||
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";
|
||||
strcpy(codo, theHEXstring);
|
||||
char code[3] = "\0";
|
||||
int x = 0;
|
||||
for(int i= 0;i<20;i++)
|
||||
{
|
||||
strncpy(&code[0],&codo[i],1);
|
||||
strncpy(&code[1],&codo[i+1],1);
|
||||
char *ck = NULL;
|
||||
uint64_t lu = 0;
|
||||
lu=strtoul(code, &ck, 16);
|
||||
buffy[x] = lu;
|
||||
i++;
|
||||
x++;
|
||||
}
|
||||
static uint64_t decoded;
|
||||
uvarint_decode64 (buffy, 10, &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";
|
||||
strcpy(codo, theHEXstring);
|
||||
char code[2] = "\0";
|
||||
int x = 0;
|
||||
for(int i= 0;i<20;i++)
|
||||
{
|
||||
strncpy(&code[0],&codo[i],1);
|
||||
strncpy(&code[1],&codo[i+1],1);
|
||||
char *ck = NULL;
|
||||
uint32_t lu = {0};
|
||||
lu=strtoul(code, &ck, 16);
|
||||
buffy[x] = lu;
|
||||
i++;
|
||||
x++;
|
||||
}
|
||||
static uint32_t decoded;
|
||||
uvarint_decode32 (buffy, 10, &decoded);
|
||||
return decoded;
|
||||
}
|
||||
#endif
|
8
varint.c
Normal file
8
varint.c
Normal file
|
@ -0,0 +1,8 @@
|
|||
#include "varint.h"
|
||||
|
||||
|
||||
DEFN_ENCODER(32)
|
||||
DEFN_DECODER(32)
|
||||
|
||||
DEFN_ENCODER(64)
|
||||
DEFN_DECODER(64)
|
51
varint.h
Normal file
51
varint.h
Normal file
|
@ -0,0 +1,51 @@
|
|||
#ifndef VARINT
|
||||
#define VARINT
|
||||
#include <stddef.h> /* size_t */
|
||||
#include <stdint.h> /* uint8_t, uint64_t */
|
||||
|
||||
|
||||
#define DEFN_ENCODER(SIZE) \
|
||||
size_t \
|
||||
uvarint_encode##SIZE (uint##SIZE##_t val, uint8_t buf[], size_t bufsize) \
|
||||
{ \
|
||||
size_t i = 0; \
|
||||
for (; i < (SIZE/8) && i < bufsize; i++) { \
|
||||
buf[i] = (uint8_t) ((val & 0xFF) | 0x80); \
|
||||
val >>= 7; \
|
||||
if (!val) \
|
||||
return i + 1; \
|
||||
} \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
|
||||
#define DEFN_DECODER(SIZE) \
|
||||
size_t \
|
||||
uvarint_decode##SIZE (uint8_t buf[], size_t bufsize, uint##SIZE##_t *val) \
|
||||
{ \
|
||||
*val = 0; \
|
||||
size_t i = 0; \
|
||||
for (; i < (SIZE/8) && i < bufsize; i++) { \
|
||||
*val |= ((buf[i] & 0x7f) << (7 * i)); \
|
||||
if (!(buf[i] & 0x80)) \
|
||||
return i + 1; \
|
||||
} \
|
||||
return -1; \
|
||||
}
|
||||
|
||||
|
||||
#define DECL_ENCODER(SIZE) \
|
||||
size_t \
|
||||
uvarint_encode##SIZE (uint##SIZE##_t val, uint8_t buf[], size_t bufsize);
|
||||
|
||||
#define DECL_DECODER(SIZE) \
|
||||
size_t \
|
||||
uvarint_decode##SIZE (uint8_t buf[], size_t bufsize, uint##SIZE##_t *val);
|
||||
|
||||
|
||||
DECL_ENCODER(32)
|
||||
DECL_DECODER(32)
|
||||
|
||||
DECL_ENCODER(64)
|
||||
DECL_DECODER(64)
|
||||
#endif
|
Loading…
Reference in a new issue