Update

Almost finished

STATUS

@@ -0,0 +1,21 @@
+STATUS:
+Compatibility: Windows/Mac/Linux/Openbsd based systems (probably more)
+-Finished Base58.h Encryption/Decryption Algorhytm
+-Finished Endian.h Library for automating compiling for Linux/Mac/Windows
+-Finished Varhexutils - Different conversion algorhytms between bytes and strings etc.
+-Finsihed Varint.h - Conversion from Hex
+-Finished Protocols.h - Library for loading protocols & manipulating them easily.
+What needs to be done (known so far):
+
+-Not finished: protoutils.h (performs final byte encodings and checks for validity
+
+-Not started: Multiaddr.h 
+(The actual thing that makes everything simple, encapsulating different protocols easily for lower 
+internet consumption and higher overall efficiency.) (Basically simulating classes from other languages for easy development)
+
+Other things to do: 
+Add conversion for bigendian machines (doubt anyone will actually need them tbh but portability was requested.)
+Should work on all platforms so far.
+Add proper documentation in case anyone needs to add protocols etc.
+
+So far it's almost finished.

base58.h

@@ -0,0 +1,104 @@
+#ifndef __BASE58_H__
+#define __BASE58_H__
+#include <stdio.h>
+#include <string.h>
+
+
+#define BASE58_DECODE_BASE 0
+#define BASE58_ENCODE_BASE 0
+#define BASE58_DECODE_OUT_OF_RANGE 1
+
+void print_array(unsigned char* arr, int len){
+	int i = 0;
+	for (i=0; i<len; ++i){
+		printf("%02X ",arr[i]);
+	}
+	printf("\n");
+}
+
+static unsigned char alphabet[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+
+int base58Encode(const char* input,const unsigned int inLen,unsigned char *output,unsigned int outLen)
+{
+	int i,j,tmp;
+	memset(output,0,outLen);
+	for(i=0;i<inLen;i++)
+	{
+		unsigned int c = input[i] & (0xff) ;
+		for(j=outLen-1;j>=0;j--)
+		{
+			tmp = output[j] * 256 + c;
+			c = tmp/58;
+			output[j] = tmp%58;
+		}
+	}
+	for(j=0; j<outLen; ++j)
+	{
+		output[j] = alphabet[output[j]];
+	}
+	return BASE58_ENCODE_BASE;
+}
+
+
+
+
+int base58Decode(const char* addr,const unsigned int addrLen,unsigned char *buf,unsigned int bufLen)
+{
+	int i,j;
+	unsigned int tmp;
+	memset(buf,0,bufLen);
+	for(i=0;i<addrLen;i++)
+	{
+		unsigned int c = addr[i];
+
+		if (addr[i] < 58){ // Numbers
+			c -= 49;
+		}else if (addr[i] < 73){ // A-H
+			c -= 56;
+		}else if (addr[i] < 79){ // J-N
+			c -= 57;
+		}else if (addr[i] < 91){ // P-Z
+			c -= 58;
+		}else if (addr[i] < 108){ // a-k
+			c -= 64;
+		}else{ // m-z
+			c -= 65;
+		}
+
+		for(j=bufLen-1;j>=0;j--)
+		{
+			tmp = buf[j] * 58 + c;
+			c = (tmp & (~0xff)) >> 8;
+			buf[j] = tmp & (0xff);
+		}
+	}
+
+	return BASE58_DECODE_BASE;
+}
+#endif
+/*int main()
+{
+	//char addr[]="1NQEQ7fkCQQiVKDohBGuE3zSYs7xfDobbg";
+	char addr[]="Qmaa4Rw81a3a1VEx4LxB7HADUAXvZFhCoRdBzsMZyZmqHD";
+	             
+	//char addr[]="5R1";
+	//char addr[]="113YAvwi1V9WV9GEykK6XQ1UypmFPhVyh1";
+	const int addrLen = sizeof(addr)-1;
+	//char addr[]="115R";
+	//const int addrLen = 4;
+	const int bufLen = 40;
+	char buf[bufLen];
+	char addr2[addrLen];
+	memset(buf,0,bufLen);
+	printf("%s in Array[i] \BYTES AS HEX:", addr);
+	print_array(addr,addrLen);
+	printf("DECODED:");
+	base58Decode(addr, addrLen, buf, bufLen);
+	print_array(buf,bufLen);
+	
+	printf("ENCODED:");
+	base58Encode(buf, bufLen, addr2, addrLen);
+	print_array(addr2,addrLen);
+
+	return 0;
+}*/

endian.h

@@ -0,0 +1,111 @@
+#ifndef PORTABLE_ENDIAN_H__
+#define PORTABLE_ENDIAN_H__
+
+#if (defined(_WIN16) || defined(_WIN32) || defined(_WIN64)) && !defined(__WINDOWS__)
+
+#	define __WINDOWS__
+
+#endif
+
+#if defined(__linux__) || defined(__CYGWIN__)
+
+#	include <endian.h>
+
+#elif defined(__APPLE__)
+
+#	include <libkern/OSByteOrder.h>
+
+#	define htobe16(x) OSSwapHostToBigInt16(x)
+#	define htole16(x) OSSwapHostToLittleInt16(x)
+#	define be16toh(x) OSSwapBigToHostInt16(x)
+#	define le16toh(x) OSSwapLittleToHostInt16(x)
+
+#	define htobe32(x) OSSwapHostToBigInt32(x)
+#	define htole32(x) OSSwapHostToLittleInt32(x)
+#	define be32toh(x) OSSwapBigToHostInt32(x)
+#	define le32toh(x) OSSwapLittleToHostInt32(x)
+
+#	define htobe64(x) OSSwapHostToBigInt64(x)
+#	define htole64(x) OSSwapHostToLittleInt64(x)
+#	define be64toh(x) OSSwapBigToHostInt64(x)
+#	define le64toh(x) OSSwapLittleToHostInt64(x)
+
+#	define __BYTE_ORDER    BYTE_ORDER
+#	define __BIG_ENDIAN    BIG_ENDIAN
+#	define __LITTLE_ENDIAN LITTLE_ENDIAN
+#	define __PDP_ENDIAN    PDP_ENDIAN
+
+#elif defined(__OpenBSD__)
+
+#	include <sys/endian.h>
+
+#elif defined(__NetBSD__) || defined(__FreeBSD__) || defined(__DragonFly__)
+
+#	include <sys/endian.h>
+
+#	define be16toh(x) betoh16(x)
+#	define le16toh(x) letoh16(x)
+
+#	define be32toh(x) betoh32(x)
+#	define le32toh(x) letoh32(x)
+
+#	define be64toh(x) betoh64(x)
+#	define le64toh(x) letoh64(x)
+
+#elif defined(__WINDOWS__)
+
+#	include <winsock2.h>
+#	include <sys/param.h>
+
+#	if BYTE_ORDER == LITTLE_ENDIAN
+
+#		define htobe16(x) htons(x)
+#		define htole16(x) (x)
+#		define be16toh(x) ntohs(x)
+#		define le16toh(x) (x)
+
+#		define htobe32(x) htonl(x)
+#		define htole32(x) (x)
+#		define be32toh(x) ntohl(x)
+#		define le32toh(x) (x)
+
+#		define htobe64(x) htonll(x)
+#		define htole64(x) (x)
+#		define be64toh(x) ntohll(x)
+#		define le64toh(x) (x)
+
+#	elif BYTE_ORDER == BIG_ENDIAN
+
+#		define htobe16(x) (x)
+#		define htole16(x) __builtin_bswap16(x)
+#		define be16toh(x) (x)
+#		define le16toh(x) __builtin_bswap16(x)
+
+#		define htobe32(x) (x)
+#		define htole32(x) __builtin_bswap32(x)
+#		define be32toh(x) (x)
+#		define le32toh(x) __builtin_bswap32(x)
+
+#		define htobe64(x) (x)
+#		define htole64(x) __builtin_bswap64(x)
+#		define be64toh(x) (x)
+#		define le64toh(x) __builtin_bswap64(x)
+
+#	else
+
+#		error byte order not supported
+
+#	endif
+
+#	define __BYTE_ORDER    BYTE_ORDER
+#	define __BIG_ENDIAN    BIG_ENDIAN
+#	define __LITTLE_ENDIAN LITTLE_ENDIAN
+#	define __PDP_ENDIAN    PDP_ENDIAN
+
+#else
+
+#	error platform not supported
+
+#endif
+
+#endif

proto-dat

@@ -0,0 +1,15 @@
+hex-code				dec-code  	size  		name
+84000000000000000000		  4       32    	ip4
+A9000000000000000000		 41      128   		ip6
+86000000000000000000		  6       16    	tcp
+91000000000000000000    	 17       16    	udp
+A1000000000000000000    	 33       16    	dccp
+84810000000000000000    	132       16    	sctp
+AD820000000000000000  		301        0    	udt
+AE820000000000000000  		302        0    	utp
+AA000000000000000000    	 42       -1    	ipfs
+E0830000000000000000  		480        0    	http
+BB830000000000000000  		443        0    	https
+DD830000000000000000  		477        0    	ws
+BC830000000000000000 		444       10    	onion
+93820000000000000000  		275        0     	libp2p-webrtc-star

protocols.h

@@ -0,0 +1,208 @@
+#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&&CNT_PROTOCOLNUM!=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
+	{
+		if(CNT_PROTOCOLNUM == 0)
+		{
+			perror("ERROR: 0 PROTOCOLS... Did you load protocols?");
+		}
+		else
+		{
+			perror("ERROR: No such protocol!");
+		}
+		return 0;
+	}
+}
+void unload_protocols()
+{
+	free(protocol_P);
+}
+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 PROTOCOL
+					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 BIG PROBLEM!!!!\nPROTOCOLS.H-REACHED DEFAULT CASE IN READING FILE!\nREPORT TO SYSTEMS ADMIN!\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); 
+		}
+	}
+	return NULL;
+}
+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

protoutils.h

@@ -0,0 +1,357 @@
+#ifndef PROTOUTILS
+#define PROTOUTILS
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+//IP2INT
+
+//IPv4 VALIDATOR
+#define DELIM "."
+ 
+/* return 1 if string contain only digits, else return 0 */
+int valid_digit(char *ip_str)
+{
+    while (*ip_str) {
+        if (*ip_str >= '0' && *ip_str <= '9')
+            ++ip_str;
+        else
+            return 0;
+    }
+    return 1;
+}
+ 
+/* return 1 if IP string is valid, else return 0 */
+int is_valid_ipv4(char *ip_str)
+{
+    int i, num, dots = 0;
+    char *ptr;
+ 
+    if (ip_str == NULL)
+        return 0;
+ 
+    // See following link for strtok()
+    // http://pubs.opengroup.org/onlinepubs/009695399/functions/strtok_r.html
+    ptr = strtok(ip_str, DELIM);
+ 
+    if (ptr == NULL)
+        return 0;
+ 
+    while (ptr) {
+ 
+        /* after parsing string, it must contain only digits */
+        if (!valid_digit(ptr))
+            return 0;
+ 
+        num = atoi(ptr);
+ 
+        /* check for valid IP */
+        if (num >= 0 && num <= 255) {
+            /* parse remaining string */
+            ptr = strtok(NULL, DELIM);
+            if (ptr != NULL)
+                ++dots;
+        } else
+            return 0;
+    }
+ 
+    /* valid IP string must contain 3 dots */
+    if (dots != 3)
+        return 0;
+    return 1;
+}
+
+
+//////////////IPv6 Validator
+#define MAX_HEX_NUMBER_COUNT 8 
+
+int ishexdigit(char ch) 
+{
+   if((ch>='0'&&ch<='9')||(ch>='a'&&ch<='f')||(ch>='A'&&ch<='F'))
+      return(1);
+   return(0);
+}
+
+int is_valid_ipv6(char *str)
+{ 
+   int hdcount=0;
+   int hncount=0;
+   int err=0;
+   int packed=0;
+
+   if(*str==':')
+   {
+      str++;    
+      if(*str!=':')
+         return(0);
+      else
+      {
+         packed=1;
+         hncount=1;
+         str++;
+
+         if(*str==0)
+            return(1);
+      }
+   }
+
+   if(ishexdigit(*str)==0)
+   {
+      return(0);        
+   }
+
+   hdcount=1;
+   hncount=1;
+   str++;
+
+   while(err==0&&*str!=0)   
+   {                      
+      if(*str==':')
+      {
+         str++;
+         if(*str==':')
+         {
+           if(packed==1)
+              err=1;
+           else
+           {
+              str++;
+
+          if(ishexdigit(*str)||*str==0&&hncount<MAX_HEX_NUMBER_COUNT)
+          {
+             packed=1;
+             hncount++;
+
+             if(ishexdigit(*str))
+             {
+                if(hncount==MAX_HEX_NUMBER_COUNT)
+                {
+                   err=1;
+                } else
+                {
+                   hdcount=1;
+                   hncount++;
+                   str++;   
+                }
+             }
+          } else
+          {
+             err=1;
+          }
+       }
+    }
+	else
+    {
+           if(!ishexdigit(*str))
+           {
+              err=1;
+           } else
+           {
+              if(hncount==MAX_HEX_NUMBER_COUNT)
+              {
+                 err=1;
+              } else
+              {
+                  hdcount=1;
+                  hncount++;
+                  str++;   
+              }
+           }
+        }
+     } 
+	 else
+     {  
+        if(ishexdigit(*str))
+        {
+           if(hdcount==4)
+              err=1;
+           else
+           {
+              hdcount++;          
+              str++;
+           }
+         } else
+            err=1;
+     } 
+   }
+
+   if(hncount<MAX_HEX_NUMBER_COUNT&&packed==0)
+      err=1;
+
+    return(err==0);
+}
+///Still in work
+uint64_t ip2int(char * ipconvertint)
+{
+	uint64_t final_result =0;
+	char * iproc;
+	int ipat1=0;
+	int ipat2=0;
+	int ipat3=0;
+	int ipat4=0;
+	char ip[16];
+	strcpy(ip, ipconvertint);
+	printf("ip: %s\n", ip);
+	iproc = strtok (ip,".");
+	for(int i=0; i<4;i++)
+	{
+		switch(i)
+		{
+			case 0:
+			{
+				ipat1 = atoi(iproc);
+				break;
+			}
+			case 1:
+			{
+				ipat2 = atoi(iproc);
+				break;
+			}
+			case 2:
+			{
+				ipat3 = atoi(iproc);
+				break;
+			}
+			case 3:
+			{
+				ipat4 = atoi(iproc);
+				break;
+			}
+			default:
+			{
+				printf("Somebody misplaced an int\n");
+				break;
+			}
+		}
+		iproc = strtok (NULL,".");
+	}
+	final_result =  ((ipat1*pow(2,24))+(ipat2*pow(2,16))+(ipat3*pow(2,8))+1);
+	return final_result;
+}
+char * address_string_to_bytes(struct protocol * xx, char * abc)
+{
+	static char astb__stringy[10] = "\0";
+	int code = 0;
+	code = xx->deccode;
+	switch(code)
+	{
+		case 4://IPv4
+		{
+			if(is_valid_ipv4(abc))
+			{
+				uint64_t iip = ip2int(abc);
+				strcpy(astb__stringy,Int_To_Hex(iip));
+				return astb__stringy;
+			}
+			else
+			{
+				return "ERR";
+			}
+			break;
+		}
+		case 41://IPv6
+		{
+			printf("IP6\n");
+			break;
+		}
+		case 6: //Tcp
+		{
+			printf("TCP!\n");
+			break;
+		}
+		case 17: //Udp
+		{
+			break;
+		}
+		case 33://dccp
+		{
+			break;
+		}
+		case 132://sctp
+		{
+			break;
+		}
+		case 301://udt
+		{
+			break;
+		}
+		case 302://utp
+		{
+			break;
+		}
+		case 42://IPFS - !!!
+		{
+			break;
+		}
+		case 480://http
+		{
+			break;
+		}
+		case 443://https
+		{
+			break;
+		}
+		case 477://ws
+		{
+			break;
+		}
+		case 444://onion
+		{
+			break;
+		}
+		case 275://libp2p-webrtc-star
+		{
+			break;
+		}
+		default:
+		{
+			printf("NO SUCH PROTOCOL!\n");
+			break;
+		}
+	}
+}
+uint8_t * string_to_bytes(char * strx, size_t strsize)
+{
+	char str[strsize]; //This string will be bad later.
+	strcpy(str,strx);
+	if(str[0] == '/')
+	{
+		char * pch;
+		static char xxx[40] = "\0";
+		printf ("Splitting string \"%s\" into tokens:\n",str);
+		pch = strtok (str,"/");
+		load_protocols();
+		while (pch != NULL)
+		{
+			if(proto_with_name(pch))
+			{
+				struct protocol * protx;
+				protx = proto_with_name(pch);
+				char cut[20]="\0";
+				strcat(cut,Int_To_Hex(protx->deccode));
+				cut[2] = '\0';
+				strcat(xxx,cut);
+				pch = strtok (NULL, "/");
+				printf("ADDRESS: %s\n", pch);
+				if(address_string_to_bytes(protx, pch) != "ERR")
+				{
+				}
+				else
+				{
+					return 0;
+				}
+			}
+			else
+			{
+				pch = strtok (NULL, "/");
+			}
+		}
+		unload_protocols();
+		printf("S2B_RESULT: %s\n", xxx);
+	}
+	else
+	{
+		printf("ERROR, Multiaddr needs to start with '/'\n");
+	}
+}
+#endif

varhexutils.h

@@ -0,0 +1,186 @@
+#ifndef VARHEXUTILS
+#define VARHEXUTILS
+
+#include <stdio.h>
+#include <inttypes.h>
+#include "varint.h"
+#include <stdlib.h>
+#include <string.h>
+#include "endian.h"
+/*uint8_t * encode_big_endian_32(uint32_t ebex32)
+{
+	uint8_t encbe[10] = {0};
+	memcpy(encbe, htobe32(ebex32));
+	return encbe;
+}*/
+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 * Int_To_Hex(uint64_t int2hex) //VAR[binformat] TO HEX
+{
+	static char int2hex_result[10]="\0";
+	memset(int2hex_result,0,sizeof(int2hex_result));
+	sprintf (int2hex_result, "%02lX", int2hex);
+	return int2hex_result;
+}
+//
+char * Var_To_Hex(uint8_t TOHEXINPUT[10]) //VAR[binformat] TO HEX
+{
+	static char convert_resultz1[20]="\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[20]="\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

varint.c

@@ -0,0 +1,8 @@
+#include "varint.h"
+
+
+DEFN_ENCODER(32)
+DEFN_DECODER(32)
+
+DEFN_ENCODER(64)
+DEFN_DECODER(64)

varint.h

@@ -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