Not sure if we really need DEEP_EQUAL here.
xethyrion
GitHub
parent
8a1240e802
commit
7a95f93924
|
|
@ -0,0 +1,201 @@
|
|||
/*
|
||||
* Copyright 2012-2014 Luke Dashjr
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the standard MIT license. See COPYING for more details.
|
||||
*/
|
||||
|
||||
#include <string.h>
|
||||
#include <math.h>
|
||||
#include <stdint.h>
|
||||
#include <sys/types.h>
|
||||
|
||||
static const char b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
|
||||
|
||||
static const int8_t b58digits_map[] = {
|
||||
-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,
|
||||
-1, 0, 1, 2, 3, 4, 5, 6, 7, 8,-1,-1,-1,-1,-1,-1,
|
||||
-1, 9,10,11,12,13,14,15, 16,-1,17,18,19,20,21,-1,
|
||||
22,23,24,25,26,27,28,29, 30,31,32,-1,-1,-1,-1,-1,
|
||||
-1,33,34,35,36,37,38,39, 40,41,42,43,-1,44,45,46,
|
||||
47,48,49,50,51,52,53,54, 55,56,57,-1,-1,-1,-1,-1,
|
||||
};
|
||||
|
||||
/**
|
||||
* convert a base58 encoded string into a binary array
|
||||
* @param b58 the base58 encoded string
|
||||
* @param base58_size the size of the encoded string
|
||||
* @param bin the results buffer
|
||||
* @param binszp the size of the results buffer
|
||||
* @returns true(1) on success
|
||||
*/
|
||||
int libp2p_crypto_encoding_base58_decode(const char* b58, size_t base58_size, unsigned char** bin, size_t* binszp)
|
||||
{
|
||||
size_t binsz = *binszp;
|
||||
const unsigned char* b58u = (const void*)b58;
|
||||
unsigned char* binu = *bin;
|
||||
size_t outisz = (binsz + 3) / 4;
|
||||
uint32_t outi[outisz];
|
||||
uint64_t t;
|
||||
uint32_t c;
|
||||
size_t i, j;
|
||||
uint8_t bytesleft = binsz % 4;
|
||||
uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;
|
||||
unsigned zerocount = 0;
|
||||
size_t b58sz;
|
||||
|
||||
b58sz = strlen(b58);
|
||||
|
||||
memset(outi, 0, outisz * sizeof(*outi));
|
||||
|
||||
// Leading zeros, just count
|
||||
for (i = 0; i < b58sz && !b58digits_map[b58u[i]]; ++i) {
|
||||
++zerocount;
|
||||
}
|
||||
|
||||
for (; i < b58sz; ++i) {
|
||||
if (b58u[i] & 0x80) {
|
||||
// High-bit set on invalid digit
|
||||
return 0;
|
||||
}
|
||||
if (b58digits_map[b58u[i]] == -1) {
|
||||
// Invalid base58 digit
|
||||
return 0;
|
||||
}
|
||||
c = (unsigned)b58digits_map[b58u[i]];
|
||||
for (j = outisz; j--;) {
|
||||
t = ((uint64_t)outi[j]) * 58 + c;
|
||||
c = (t & 0x3f00000000) >> 32;
|
||||
outi[j] = t & 0xffffffff;
|
||||
}
|
||||
if (c) {
|
||||
// Output number too big (carry to the next int32)
|
||||
memset(outi, 0, outisz * sizeof(*outi));
|
||||
return 0;
|
||||
}
|
||||
if (outi[0] & zeromask) {
|
||||
// Output number too big (last int32 filled too far)
|
||||
memset(outi, 0, outisz * sizeof(*outi));
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
j = 0;
|
||||
switch (bytesleft) {
|
||||
case 3:
|
||||
*(binu++) = (outi[0] & 0xff0000) >> 16;
|
||||
case 2:
|
||||
*(binu++) = (outi[0] & 0xff00) >> 8;
|
||||
case 1:
|
||||
*(binu++) = (outi[0] & 0xff);
|
||||
++j;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
for (; j < outisz; ++j) {
|
||||
*(binu++) = (outi[j] >> 0x18) & 0xff;
|
||||
*(binu++) = (outi[j] >> 0x10) & 0xff;
|
||||
*(binu++) = (outi[j] >> 8) & 0xff;
|
||||
*(binu++) = (outi[j] >> 0) & 0xff;
|
||||
}
|
||||
|
||||
// Count canonical base58 byte count
|
||||
binu = *bin;
|
||||
for (i = 0; i < binsz; ++i) {
|
||||
if (binu[i]) {
|
||||
break;
|
||||
}
|
||||
--*binszp;
|
||||
}
|
||||
*binszp += zerocount;
|
||||
|
||||
memset(outi, 0, outisz * sizeof(*outi));
|
||||
return 1;
|
||||
}
|
||||
|
||||
/**
|
||||
* encode an array of bytes into a base58 string
|
||||
* @param binary_data the data to be encoded
|
||||
* @param binary_data_size the size of the data to be encoded
|
||||
* @param base58 the results buffer
|
||||
* @param base58_size the size of the results buffer
|
||||
* @returns true(1) on success
|
||||
*/
|
||||
//int libp2p_crypto_encoding_base58_encode(const unsigned char* binary_data, size_t binary_data_size, unsigned char* base58, size_t* base58_size)
|
||||
int libp2p_crypto_encoding_base58_encode(const unsigned char* data, size_t binsz, unsigned char** b58, size_t* b58sz)
|
||||
{
|
||||
const uint8_t* bin = data;
|
||||
int carry;
|
||||
ssize_t i, j, high, zcount = 0;
|
||||
size_t size;
|
||||
|
||||
while (zcount < (ssize_t)binsz && !bin[zcount]) {
|
||||
++zcount;
|
||||
}
|
||||
|
||||
size = (binsz - zcount) * 138 / 100 + 1;
|
||||
uint8_t buf[size];
|
||||
memset(buf, 0, size);
|
||||
|
||||
for (i = zcount, high = size - 1; i < (ssize_t)binsz; ++i, high = j) {
|
||||
for (carry = bin[i], j = size - 1; (j > high) || carry; --j) {
|
||||
carry += 256 * buf[j];
|
||||
buf[j] = carry % 58;
|
||||
carry /= 58;
|
||||
}
|
||||
}
|
||||
|
||||
for (j = 0; j < (ssize_t)size && !buf[j]; ++j)
|
||||
;
|
||||
|
||||
if (*b58sz <= zcount + size - j) {
|
||||
*b58sz = zcount + size - j + 1;
|
||||
memset(buf, 0, size);
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (zcount) {
|
||||
memset(b58, '1', zcount);
|
||||
}
|
||||
for (i = zcount; j < (ssize_t)size; ++i, ++j) {
|
||||
(*b58)[i] = b58digits_ordered[buf[j]];
|
||||
}
|
||||
(*b58)[i] = '\0';
|
||||
*b58sz = i + 1;
|
||||
|
||||
memset(buf, 0, size);
|
||||
return 1;
|
||||
}
|
||||
|
||||
/***
|
||||
* calculate the size of the binary results based on an incoming base58 string
|
||||
* @param base58_string the string
|
||||
* @returns the size in bytes had the string been decoded
|
||||
*/
|
||||
size_t libp2p_crypto_encoding_base58_decode_size(const unsigned char* base58_string) {
|
||||
size_t string_length = strlen((char*)base58_string);
|
||||
size_t decoded_length = 0;
|
||||
size_t radix = strlen(b58digits_ordered);
|
||||
double bits_per_digit = log2(radix);
|
||||
|
||||
decoded_length = floor(string_length * bits_per_digit / 8);
|
||||
return decoded_length;
|
||||
}
|
||||
|
||||
/**
|
||||
* calculate the max length in bytes of an encoding of n source bits
|
||||
* @param base58_string the string
|
||||
* @returns the maximum size in bytes had the string been decoded
|
||||
*/
|
||||
size_t libp2p_crypto_encoding_base58_decode_max_size(const unsigned char* base58_string) {
|
||||
size_t string_length = strlen((char*)base58_string);
|
||||
size_t decoded_length = 0;
|
||||
size_t radix = strlen(b58digits_ordered);
|
||||
double bits_per_digit = log2(radix);
|
||||
|
||||
decoded_length = ceil(string_length * bits_per_digit / 8);
|
||||
return decoded_length;
|
||||
}
|
||||
|
|
@ -0,0 +1,47 @@
|
|||
//
|
||||
// base58.h
|
||||
// libp2p_xcode
|
||||
//
|
||||
// Created by John Jones on 11/7/16.
|
||||
// Copyright © 2016 JMJAtlanta. All rights reserved.
|
||||
//
|
||||
|
||||
#ifndef base58_h
|
||||
#define base58_h
|
||||
#include "varint.h"
|
||||
/**
|
||||
* convert a base58 encoded string into a binary array
|
||||
* @param base58 the base58 encoded string
|
||||
* @param base58_size the size of the encoded string
|
||||
* @param binary_data the results buffer
|
||||
* @param binary_data_size the size of the results buffer
|
||||
* @returns true(1) on success
|
||||
*/
|
||||
int libp2p_crypto_encoding_base58_decode(const unsigned char* base58, size_t base58_size, unsigned char** binary_data, size_t *binary_data_size);
|
||||
|
||||
/**
|
||||
* encode an array of bytes into a base58 string
|
||||
* @param binary_data the data to be encoded
|
||||
* @param binary_data_size the size of the data to be encoded
|
||||
* @param base58 the results buffer
|
||||
* @param base58_size the size of the results buffer
|
||||
* @returns true(1) on success
|
||||
*/
|
||||
int libp2p_crypto_encoding_base58_encode(const unsigned char* binary_data, size_t binary_data_size, unsigned char** base58, size_t* base58_size);
|
||||
|
||||
/***
|
||||
* calculate the size of the binary results based on an incoming base58 string with no initial padding
|
||||
* @param base58_string the string
|
||||
* @returns the size in bytes had the string been decoded
|
||||
*/
|
||||
size_t libp2p_crypto_encoding_base58_decode_size(const unsigned char* base58_string);
|
||||
|
||||
/**
|
||||
* calculate the max length in bytes of an encoding of n source bits
|
||||
* @param base58_string the string
|
||||
* @returns the maximum size in bytes had the string been decoded
|
||||
*/
|
||||
size_t libp2p_crypto_encoding_base58_decode_max_size(const unsigned char* base58_string);
|
||||
|
||||
|
||||
#endif /* base58_h */
|
||||
49
ipld.h
49
ipld.h
|
|
@ -5,12 +5,13 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <jansson.h>
|
||||
|
||||
#include "base58.h"
|
||||
#include "varhexutils.h"
|
||||
//Predefined values:
|
||||
#define IDKey "@id"
|
||||
#define TypeKey "@type"
|
||||
#define ValueKey "@value"
|
||||
#define CtxKey "@context"
|
||||
#define CtxKey "@/home/xethyrion/Desktop/Bak/varint.hcontext"
|
||||
#define CodecKey "@codec"
|
||||
#define LinkKey "mlink"
|
||||
|
||||
|
|
@ -28,7 +29,7 @@ struct NODE
|
|||
/* LOAD_NODE(@param1)
|
||||
* Creates a new node from a string.
|
||||
* @Param1 a json string(char *)
|
||||
* returns a json_t object! (jansson.h)
|
||||
* returns a json_t /home/xethyrion/Desktop/Bak/varint.hobject! (jansson.h)
|
||||
*/
|
||||
struct NODE LOAD_NODE(char * str)
|
||||
{
|
||||
|
|
@ -275,9 +276,9 @@ void lType(char * str, struct LINK O)
|
|||
}
|
||||
}
|
||||
|
||||
/* lType(@param1,@param2)
|
||||
* Gets the type of the link, of course, it should be an mlink.
|
||||
* @param1: LINK.type //Storing in type from LINK struct.
|
||||
/* lHash(@param1,@param2)
|
||||
* Gets the hash of the link, not b58 decoded
|
||||
* @param1: LINK.hash //Storing in hash from LINK struct.
|
||||
* @param2: LINK // The link structure we are using.
|
||||
*/
|
||||
void lHash(char * str, struct LINK O)
|
||||
|
|
@ -323,7 +324,40 @@ void lName(char * str, struct LINK O)
|
|||
strcat(str, key);
|
||||
}
|
||||
}
|
||||
|
||||
/*B58Hash(@param1, @parunsigned char** binary_dataam2)
|
||||
*Decodes the hash, and stores it into a char from your link struct
|
||||
*/
|
||||
void lb58Hash(char * str, struct LINK X) //Need to find out if prefixed or not!
|
||||
{
|
||||
char * hash = X.hash;
|
||||
size_t hash_length = strlen(hash);
|
||||
size_t result_buffer_length = libp2p_crypto_encoding_base58_decode_max_size(hash);
|
||||
unsigned char result_buffer[result_buffer_length];
|
||||
unsigned char * ptr_2_result = result_buffer;
|
||||
memset(result_buffer, 0, result_buffer_length);
|
||||
int valid = libp2p_crypto_encoding_base58_decode(hash,hash_length,&ptr_2_result, &result_buffer_length);
|
||||
printf("IS_VALID: %d\n",valid);
|
||||
char HReadable[1000];
|
||||
bzero(HReadable,1000);
|
||||
int ilen = 0;
|
||||
for(int i = 0; i<result_buffer_length;i++)
|
||||
{
|
||||
unsigned char c = ptr_2_result[i];
|
||||
char miu[3];
|
||||
bzero(miu,3);
|
||||
sprintf(miu,"%02x",c);
|
||||
miu[3] = '\0';
|
||||
strcat(HReadable, miu);
|
||||
}
|
||||
//DEBUG
|
||||
if(NODE_H_DEBUG == 1)
|
||||
{
|
||||
printf("Normal hash: %s\n", hash);
|
||||
printf("Result: %s\n", HReadable);
|
||||
}
|
||||
strcat(str, HReadable);
|
||||
|
||||
}
|
||||
/* LOAD_LINK(@param1)
|
||||
* Creates a new LINK from a string.
|
||||
* @Param1 a json string(char *)
|
||||
|
|
@ -344,6 +378,7 @@ struct LINK LOAD_LINK(char * str)
|
|||
lName(X.name, X);
|
||||
lType(X.type, X);
|
||||
lHash(X.hash, X);
|
||||
lb58Hash(X.b58hash, X);
|
||||
return X;
|
||||
}
|
||||
/* Unload_LINK(@param1) - Same as unload_node, makes it easier to avoid leaks and better structuring of your programs
|
||||
|
|
|
|||
32
ipld_tut.c
32
ipld_tut.c
|
|
@ -5,7 +5,7 @@ int main()
|
|||
NODE_H_DEBUG = 0;
|
||||
|
||||
//Load a node from string:
|
||||
char * str = "{\"@context\": \"/ipfs/Qmf1ec6n9f8kW8JTLjqaZceJVpDpZD4L3aPoJFvssBE7Eb/merkleweb\", \"@type\": \"node\", \"FIELD1\": { \"@value\": \"Qmabcbcbdba\", \"@type\": \"mlink\" }, \"FIELD2\": { \"@value\": \"Qmabcbcbdba2\", \"@type\": \"mlink\" } }";
|
||||
char * str = "{\"@context\": \"/ipfs/Qmf1ec6n9f8kW8JTLjqaZceJVpDpZD4L3aPoJFvssBE7Eb/merkleweb\", \"@type\": \"node\", \"FIELD1\": { \"@value\": \"Qmf1ec6n9f8kW8JTLjqaZceJVpDpZD4L3aPoJFvssBE7Eb\", \"@type\": \"mlink\" }, \"FIELD2\": { \"@value\": \"Qmf1ec6n9f8kW8JTLjqaZceJVpDpZD4L3aPoJFvssBE7Eb\", \"@type\": \"mlink\" } }";
|
||||
struct NODE A;
|
||||
A = LOAD_NODE(str);
|
||||
|
||||
|
|
@ -49,15 +49,16 @@ int main()
|
|||
printf("LINK CONTENTS: \n------------\n%s\n------------\n", linkstr);
|
||||
free(linkstr);
|
||||
//Access Name
|
||||
printf("LINK NAME: %s\n", L.name);
|
||||
printf("LINK NAME:\t%s\n", L.name);
|
||||
|
||||
//Access Type
|
||||
printf("LINK TYPE: %s\n", L.type);
|
||||
printf("LINK TYPE:\t%s\n", L.type);
|
||||
|
||||
//Access Hash
|
||||
printf("LINK HASH: %s\n", L.hash);
|
||||
printf("LINK HASH:\t%s\n", L.hash);
|
||||
|
||||
//Access b58Hash
|
||||
printf("LINK B58HASH:\t%s\n", L.b58hash);
|
||||
|
||||
//Free all nodes, links, link pointer array
|
||||
for(int i=0; i<linknum;i++){free(links[i]);} //FREE(Link char pointer array)
|
||||
|
|
@ -65,25 +66,4 @@ int main()
|
|||
UNLOAD_NODE(A); // FREE NODE STRUCTURE // You could've done this earlier as soon as you didn't need any more.
|
||||
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
json_t * obj;
|
||||
const char * str = "{\"FIELD1\": { \"@value\": \"Qmabcbcbdba\", \"@type\": \"mlink\" }, \"FIELD2\": { \"@value\": \"Qmabcbcbdba2\", \"@type\": \"mlink\" } }";
|
||||
json_error_t error;
|
||||
obj = json_loads(str, 0, &error);
|
||||
char * lol;
|
||||
lol = json_dumps(obj, JSON_INDENT(1));
|
||||
printf("LOL: %s", lol);
|
||||
free(lol);
|
||||
json_decref(obj);
|
||||
//WORKING FOREACH
|
||||
const char *key;
|
||||
json_t * value;
|
||||
json_object_foreach(A.obj, key, value)
|
||||
{
|
||||
char * valinchr;
|
||||
valinchr = json_dumps(value, JSON_INDENT(0));
|
||||
printf("KEY: %s\nValue: %s\n", key, valinchr);
|
||||
free(valinchr);
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
|
@ -0,0 +1,251 @@
|
|||
#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)
|
||||
{
|
||||
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[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[60] = {0};
|
||||
uvarint_encode32(TOV32INPUT, buffy_032, 60);
|
||||
return buffy_032;
|
||||
}
|
||||
uint64_t * Varint_To_Num_64(uint8_t TON64INPUT[60]) //VARINT TO UINT64_t
|
||||
{
|
||||
static uint64_t varintdecode_001 = 0;
|
||||
uvarint_decode64(TON64INPUT, 60, &varintdecode_001);
|
||||
return &varintdecode_001;
|
||||
}
|
||||
uint32_t * Varint_To_Num_32(uint8_t TON32INPUT[60]) //VARINT TO UINT32_t
|
||||
{
|
||||
static uint32_t varintdecode_032 = 0;
|
||||
uvarint_decode32(TON32INPUT, 60, &varintdecode_032);
|
||||
return &varintdecode_032;
|
||||
}
|
||||
//
|
||||
char * Int_To_Hex(uint64_t int2hex) //VAR[binformat] TO HEX
|
||||
{
|
||||
static char int2hex_result[800]="\0";
|
||||
memset(int2hex_result,0,sizeof(int2hex_result));
|
||||
sprintf (int2hex_result, "%02lX", int2hex);
|
||||
return int2hex_result;
|
||||
}
|
||||
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;
|
||||
}
|
||||
//
|
||||
void vthconvert(int size, char * crrz01, uint8_t * xbuf)
|
||||
{
|
||||
uint8_t buf[400];
|
||||
bzero(buf,400);
|
||||
|
||||
//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[800]="\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<400;ix++)
|
||||
{
|
||||
TOHEXINPUT[ix] = '\0';
|
||||
}
|
||||
if(TOHEXINPUT != NULL)
|
||||
{
|
||||
static char convert_resultz1[800]="\0";
|
||||
bzero(convert_resultz1,800);
|
||||
vthconvert(realsize, convert_resultz1, TOHEXINPUT);
|
||||
return convert_resultz1;
|
||||
}
|
||||
}
|
||||
uint8_t * Hex_To_Var(char * Hexstr) //HEX TO VAR[BINFORMAT]
|
||||
{
|
||||
static uint8_t buffy_HEX[400] = {0};
|
||||
bzero(buffy_HEX,400);
|
||||
int i;
|
||||
char codo[800] = "\0";
|
||||
bzero(codo,800);
|
||||
strcpy(codo, Hexstr);
|
||||
char code[3];
|
||||
bzero(code,3);
|
||||
code[3]='\0';
|
||||
int x = 0;
|
||||
int fori001=0;
|
||||
for(fori001=0;fori001<800;fori001++)
|
||||
{
|
||||
strncpy(&code[0],&codo[fori001],1);
|
||||
strncpy(&code[1],&codo[fori001+1],1);
|
||||
char *ck = NULL;
|
||||
uint64_t lu = 0;
|
||||
lu=strtoul(code, &ck, 16);
|
||||
buffy_HEX[x] = lu;
|
||||
//printf("%s - %lu\n",code,lu);
|
||||
fori001++;
|
||||
x++;
|
||||
}
|
||||
return buffy_HEX;
|
||||
}
|
||||
//
|
||||
void convert(char * convert_result, uint8_t * buf) //Both of them read them properly.
|
||||
{
|
||||
char conv_proc[800]="\0";
|
||||
bzero(conv_proc,800);
|
||||
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[800]="\0";//Note that the hex resulted from this will differ from py
|
||||
bzero(convert_result,800);
|
||||
memset(convert_result,0,sizeof(convert_result));//But if you make sure the string is always 20 chars in size
|
||||
uint8_t buf[400] = {0};
|
||||
bzero(buf,400);
|
||||
uvarint_encode64(TOHVINPUT, buf, 800);
|
||||
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[3]="\0";
|
||||
bzero(convert_result2,3);
|
||||
convert_result2[2] = '\0';
|
||||
memset(convert_result2,0,sizeof(convert_result2));
|
||||
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[400] = {0};
|
||||
char codo[800] = "\0";
|
||||
bzero(codo,800);
|
||||
strcpy(codo, theHEXstring);
|
||||
char code[3] = "\0";
|
||||
int x = 0;
|
||||
for(int i= 0;i<399;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, 400, &decoded);
|
||||
return decoded;
|
||||
}
|
||||
uint32_t HexVar_To_Num_32(char theHEXstring[]) //HEXIFIED VAR TO UINT32_T
|
||||
{ //Varint to code py
|
||||
uint8_t buffy[400] = {0};
|
||||
bzero(buffy,400);
|
||||
char codo[800] = "\0";
|
||||
bzero(codo,800);
|
||||
strcpy(codo, theHEXstring);
|
||||
char code[3] = "\0";
|
||||
bzero(code,3);
|
||||
code[3] = '\0';
|
||||
int x = 0;
|
||||
for(int i= 0;i<399;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
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
#include "varint.h"
|
||||
|
||||
|
||||
DEFN_ENCODER(32)
|
||||
DEFN_DECODER(32)
|
||||
|
||||
DEFN_ENCODER(64)
|
||||
DEFN_DECODER(64)
|
||||
|
|
@ -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 New Issue