added ipfs support with proper base58
This commit is contained in:
parent
7574846553
commit
d7a90c513d
3 changed files with 314 additions and 166 deletions
185
base58.c
185
base58.c
|
@ -5,20 +5,12 @@
|
||||||
* under the terms of the standard MIT license. See COPYING for more details.
|
* under the terms of the standard MIT license. See COPYING for more details.
|
||||||
*/
|
*/
|
||||||
|
|
||||||
#ifndef WIN32
|
|
||||||
#include <arpa/inet.h>
|
|
||||||
#else
|
|
||||||
#include <winsock2.h>
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#include <stdbool.h>
|
|
||||||
#include <stddef.h>
|
|
||||||
#include <stdint.h>
|
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
#include <math.h>
|
||||||
|
#include <stdint.h>
|
||||||
|
#include <sys/types.h>
|
||||||
|
|
||||||
#include "base58.h"
|
static const char b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
|
||||||
|
|
||||||
bool (*b58_sha256_impl)(void *, const void *, size_t) = NULL;
|
|
||||||
|
|
||||||
static const int8_t b58digits_map[] = {
|
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,
|
||||||
|
@ -31,11 +23,19 @@ static const int8_t b58digits_map[] = {
|
||||||
47,48,49,50,51,52,53,54, 55,56,57,-1,-1,-1,-1,-1,
|
47,48,49,50,51,52,53,54, 55,56,57,-1,-1,-1,-1,-1,
|
||||||
};
|
};
|
||||||
|
|
||||||
bool b58tobin(void *bin, size_t *binszp, const char *b58, size_t b58sz)
|
/**
|
||||||
|
* 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;
|
size_t binsz = *binszp;
|
||||||
const unsigned char *b58u = (void*)b58;
|
const unsigned char* b58u = (const void*)b58;
|
||||||
unsigned char *binu = bin;
|
unsigned char* binu = *bin;
|
||||||
size_t outisz = (binsz + 3) / 4;
|
size_t outisz = (binsz + 3) / 4;
|
||||||
uint32_t outi[outisz];
|
uint32_t outi[outisz];
|
||||||
uint64_t t;
|
uint64_t t;
|
||||||
|
@ -44,37 +44,42 @@ bool b58tobin(void *bin, size_t *binszp, const char *b58, size_t b58sz)
|
||||||
uint8_t bytesleft = binsz % 4;
|
uint8_t bytesleft = binsz % 4;
|
||||||
uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;
|
uint32_t zeromask = bytesleft ? (0xffffffff << (bytesleft * 8)) : 0;
|
||||||
unsigned zerocount = 0;
|
unsigned zerocount = 0;
|
||||||
|
size_t b58sz;
|
||||||
|
|
||||||
if (!b58sz)
|
|
||||||
b58sz = strlen(b58);
|
b58sz = strlen(b58);
|
||||||
|
|
||||||
memset(outi, 0, outisz * sizeof(*outi));
|
memset(outi, 0, outisz * sizeof(*outi));
|
||||||
|
|
||||||
// Leading zeros, just count
|
// Leading zeros, just count
|
||||||
for (i = 0; i < b58sz && b58u[i] == '1'; ++i)
|
for (i = 0; i < b58sz && !b58digits_map[b58u[i]]; ++i) {
|
||||||
++zerocount;
|
++zerocount;
|
||||||
|
}
|
||||||
|
|
||||||
for ( ; i < b58sz; ++i)
|
for (; i < b58sz; ++i) {
|
||||||
{
|
if (b58u[i] & 0x80) {
|
||||||
if (b58u[i] & 0x80)
|
|
||||||
// High-bit set on invalid digit
|
// High-bit set on invalid digit
|
||||||
return false;
|
return 0;
|
||||||
if (b58digits_map[b58u[i]] == -1)
|
}
|
||||||
|
if (b58digits_map[b58u[i]] == -1) {
|
||||||
// Invalid base58 digit
|
// Invalid base58 digit
|
||||||
return false;
|
return 0;
|
||||||
|
}
|
||||||
c = (unsigned)b58digits_map[b58u[i]];
|
c = (unsigned)b58digits_map[b58u[i]];
|
||||||
for (j = outisz; j--; )
|
for (j = outisz; j--;) {
|
||||||
{
|
|
||||||
t = ((uint64_t)outi[j]) * 58 + c;
|
t = ((uint64_t)outi[j]) * 58 + c;
|
||||||
c = (t & 0x3f00000000) >> 32;
|
c = (t & 0x3f00000000) >> 32;
|
||||||
outi[j] = t & 0xffffffff;
|
outi[j] = t & 0xffffffff;
|
||||||
}
|
}
|
||||||
if (c)
|
if (c) {
|
||||||
// Output number too big (carry to the next int32)
|
// Output number too big (carry to the next int32)
|
||||||
return false;
|
memset(outi, 0, outisz * sizeof(*outi));
|
||||||
if (outi[0] & zeromask)
|
return 0;
|
||||||
|
}
|
||||||
|
if (outi[0] & zeromask) {
|
||||||
// Output number too big (last int32 filled too far)
|
// Output number too big (last int32 filled too far)
|
||||||
return false;
|
memset(outi, 0, outisz * sizeof(*outi));
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
j = 0;
|
j = 0;
|
||||||
|
@ -90,8 +95,7 @@ bool b58tobin(void *bin, size_t *binszp, const char *b58, size_t b58sz)
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
|
|
||||||
for (; j < outisz; ++j)
|
for (; j < outisz; ++j) {
|
||||||
{
|
|
||||||
*(binu++) = (outi[j] >> 0x18) & 0xff;
|
*(binu++) = (outi[j] >> 0x18) & 0xff;
|
||||||
*(binu++) = (outi[j] >> 0x10) & 0xff;
|
*(binu++) = (outi[j] >> 0x10) & 0xff;
|
||||||
*(binu++) = (outi[j] >> 8) & 0xff;
|
*(binu++) = (outi[j] >> 8) & 0xff;
|
||||||
|
@ -99,102 +103,99 @@ bool b58tobin(void *bin, size_t *binszp, const char *b58, size_t b58sz)
|
||||||
}
|
}
|
||||||
|
|
||||||
// Count canonical base58 byte count
|
// Count canonical base58 byte count
|
||||||
binu = bin;
|
binu = *bin;
|
||||||
for (i = 0; i < binsz; ++i)
|
for (i = 0; i < binsz; ++i) {
|
||||||
{
|
if (binu[i]) {
|
||||||
if (binu[i])
|
|
||||||
break;
|
break;
|
||||||
|
}
|
||||||
--*binszp;
|
--*binszp;
|
||||||
}
|
}
|
||||||
*binszp += zerocount;
|
*binszp += zerocount;
|
||||||
|
|
||||||
return true;
|
memset(outi, 0, outisz * sizeof(*outi));
|
||||||
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
static
|
/**
|
||||||
bool my_dblsha256(void *hash, const void *data, size_t datasz)
|
* encode an array of bytes into a base58 string
|
||||||
{
|
* @param binary_data the data to be encoded
|
||||||
uint8_t buf[0x20];
|
* @param binary_data_size the size of the data to be encoded
|
||||||
return b58_sha256_impl(buf, data, datasz) && b58_sha256_impl(hash, buf, sizeof(buf));
|
* @param base58 the results buffer
|
||||||
}
|
* @param base58_size the size of the results buffer
|
||||||
|
* @returns true(1) on success
|
||||||
int b58check(const void *bin, size_t binsz, const char *base58str, size_t b58sz)
|
*/
|
||||||
{
|
//int libp2p_crypto_encoding_base58_encode(const unsigned char* binary_data, size_t binary_data_size, unsigned char* base58, size_t* base58_size)
|
||||||
unsigned char buf[32];
|
int libp2p_crypto_encoding_base58_encode(const unsigned char* data, size_t binsz, unsigned char** b58, size_t* b58sz)
|
||||||
const uint8_t *binc = bin;
|
|
||||||
unsigned i;
|
|
||||||
if (binsz < 4)
|
|
||||||
return -4;
|
|
||||||
if (!my_dblsha256(buf, bin, binsz - 4))
|
|
||||||
return -2;
|
|
||||||
if (memcmp(&binc[binsz - 4], buf, 4))
|
|
||||||
return -1;
|
|
||||||
|
|
||||||
// Check number of zeros is correct AFTER verifying checksum (to avoid possibility of accessing base58str beyond the end)
|
|
||||||
for (i = 0; binc[i] == '\0' && base58str[i] == '1'; ++i)
|
|
||||||
{} // Just finding the end of zeros, nothing to do in loop
|
|
||||||
if (binc[i] == '\0' || base58str[i] == '1')
|
|
||||||
return -3;
|
|
||||||
|
|
||||||
return binc[0];
|
|
||||||
}
|
|
||||||
|
|
||||||
static const char b58digits_ordered[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
|
|
||||||
|
|
||||||
bool b58enc(char *b58, size_t *b58sz, const void *data, size_t binsz)
|
|
||||||
{
|
{
|
||||||
const uint8_t* bin = data;
|
const uint8_t* bin = data;
|
||||||
int carry;
|
int carry;
|
||||||
ssize_t i, j, high, zcount = 0;
|
ssize_t i, j, high, zcount = 0;
|
||||||
size_t size;
|
size_t size;
|
||||||
|
|
||||||
while (zcount < binsz && !bin[zcount])
|
while (zcount < (ssize_t)binsz && !bin[zcount]) {
|
||||||
++zcount;
|
++zcount;
|
||||||
|
}
|
||||||
|
|
||||||
size = (binsz - zcount) * 138 / 100 + 1;
|
size = (binsz - zcount) * 138 / 100 + 1;
|
||||||
uint8_t buf[size];
|
uint8_t buf[size];
|
||||||
memset(buf, 0, size);
|
memset(buf, 0, size);
|
||||||
|
|
||||||
for (i = zcount, high = size - 1; i < binsz; ++i, high = j)
|
for (i = zcount, high = size - 1; i < (ssize_t)binsz; ++i, high = j) {
|
||||||
{
|
for (carry = bin[i], j = size - 1; (j > high) || carry; --j) {
|
||||||
for (carry = bin[i], j = size - 1; (j > high) || carry; --j)
|
|
||||||
{
|
|
||||||
carry += 256 * buf[j];
|
carry += 256 * buf[j];
|
||||||
buf[j] = carry % 58;
|
buf[j] = carry % 58;
|
||||||
carry /= 58;
|
carry /= 58;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
for (j = 0; j < size && !buf[j]; ++j);
|
for (j = 0; j < (ssize_t)size && !buf[j]; ++j)
|
||||||
|
;
|
||||||
|
|
||||||
if (*b58sz <= zcount + size - j)
|
if (*b58sz <= zcount + size - j) {
|
||||||
{
|
|
||||||
*b58sz = zcount + size - j + 1;
|
*b58sz = zcount + size - j + 1;
|
||||||
return false;
|
memset(buf, 0, size);
|
||||||
|
return 0;
|
||||||
}
|
}
|
||||||
|
|
||||||
if (zcount)
|
if (zcount) {
|
||||||
memset(b58, '1', zcount);
|
memset(b58, '1', zcount);
|
||||||
for (i = zcount; j < size; ++i, ++j)
|
}
|
||||||
b58[i] = b58digits_ordered[buf[j]];
|
for (i = zcount; j < (ssize_t)size; ++i, ++j) {
|
||||||
b58[i] = '\0';
|
(*b58)[i] = b58digits_ordered[buf[j]];
|
||||||
|
}
|
||||||
|
(*b58)[i] = '\0';
|
||||||
*b58sz = i + 1;
|
*b58sz = i + 1;
|
||||||
|
|
||||||
return true;
|
memset(buf, 0, size);
|
||||||
|
return 1;
|
||||||
}
|
}
|
||||||
|
|
||||||
bool b58check_enc(char *b58c, size_t *b58c_sz, uint8_t ver, const void *data, size_t datasz)
|
/***
|
||||||
{
|
* calculate the size of the binary results based on an incoming base58 string
|
||||||
uint8_t buf[1 + datasz + 0x20];
|
* @param base58_string the string
|
||||||
uint8_t *hash = &buf[1 + datasz];
|
* @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);
|
||||||
|
|
||||||
buf[0] = ver;
|
decoded_length = floor(string_length * bits_per_digit / 8);
|
||||||
memcpy(&buf[1], data, datasz);
|
return decoded_length;
|
||||||
if (!my_dblsha256(hash, buf, datasz + 1))
|
|
||||||
{
|
|
||||||
*b58c_sz = 0;
|
|
||||||
return false;
|
|
||||||
}
|
}
|
||||||
|
|
||||||
return b58enc(b58c, b58c_sz, buf, 1 + datasz + 4);
|
/**
|
||||||
|
* 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;
|
||||||
}
|
}
|
59
base58.h
59
base58.h
|
@ -1,24 +1,47 @@
|
||||||
#ifndef LIBBASE58_H
|
//
|
||||||
#define LIBBASE58_H
|
// base58.h
|
||||||
|
// libp2p_xcode
|
||||||
|
//
|
||||||
|
// Created by John Jones on 11/7/16.
|
||||||
|
// Copyright © 2016 JMJAtlanta. All rights reserved.
|
||||||
|
//
|
||||||
|
|
||||||
#include <stdbool.h>
|
#ifndef base58_h
|
||||||
#include <stddef.h>
|
#define base58_h
|
||||||
#include <stdint.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);
|
||||||
|
|
||||||
#ifdef __cplusplus
|
/**
|
||||||
extern "C" {
|
* encode an array of bytes into a base58 string
|
||||||
#endif
|
* @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);
|
||||||
|
|
||||||
extern bool (*b58_sha256_impl)(void *, const void *, size_t);
|
/***
|
||||||
|
* 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);
|
||||||
|
|
||||||
extern bool b58tobin(void *bin, size_t *binsz, const char *b58, size_t b58sz);
|
/**
|
||||||
extern int b58check(const void *bin, size_t binsz, const char *b58, size_t b58sz);
|
* 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);
|
||||||
|
|
||||||
extern bool b58enc(char *b58, size_t *b58sz, const void *bin, size_t binsz);
|
|
||||||
extern bool b58check_enc(char *b58c, size_t *b58c_sz, uint8_t ver, const void *data, size_t datasz);
|
|
||||||
|
|
||||||
#ifdef __cplusplus
|
#endif /* base58_h */
|
||||||
}
|
|
||||||
#endif
|
|
||||||
|
|
||||||
#endif
|
|
128
protoutils.h
128
protoutils.h
|
@ -9,8 +9,44 @@
|
||||||
#include "base58.h"
|
#include "base58.h"
|
||||||
#include "varhexutils.h"
|
#include "varhexutils.h"
|
||||||
#include "protocols.h"
|
#include "protocols.h"
|
||||||
//IP2INT
|
//////////////////////////////////////////////////////////
|
||||||
|
char ASCII2bits(char ch) {
|
||||||
|
if (ch >= '0' && ch <= '9') {
|
||||||
|
return (ch - '0');
|
||||||
|
} else if (ch >= 'a' && ch <= 'z') {
|
||||||
|
return (ch - 'a') + 10;
|
||||||
|
} else if (ch >= 'A' && ch <= 'Z') {
|
||||||
|
return (ch - 'A') + 10;
|
||||||
|
}
|
||||||
|
return 0; // fail
|
||||||
|
}
|
||||||
|
|
||||||
|
void hex2bin (char *dst, char *src, int len)
|
||||||
|
{
|
||||||
|
while (len--) {
|
||||||
|
*dst = ASCII2bits(*src++) << 4; // higher bits
|
||||||
|
*dst++ |= ASCII2bits(*src++); // lower bits
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
char bits2ASCII(char b) {
|
||||||
|
if (b >= 0 && b < 10) {
|
||||||
|
return (b + '0');
|
||||||
|
} else if (b >= 10 && b <= 15) {
|
||||||
|
return (b - 10 + 'a');
|
||||||
|
}
|
||||||
|
return 0; // fail
|
||||||
|
}
|
||||||
|
|
||||||
|
void bin2hex (char *dst, char *src, int len)
|
||||||
|
{
|
||||||
|
while (len--) {
|
||||||
|
*dst++ = bits2ASCII((*src >> 4) & 0xf); // higher bits
|
||||||
|
*dst++ = bits2ASCII(*src++ & 0xf); // lower bits
|
||||||
|
}
|
||||||
|
*dst = '\0';
|
||||||
|
}
|
||||||
|
//////////////////////////////////////////////////////////
|
||||||
//IPv4 VALIDATOR
|
//IPv4 VALIDATOR
|
||||||
#define DELIM "."
|
#define DELIM "."
|
||||||
|
|
||||||
|
@ -196,7 +232,6 @@ int is_valid_ipv6(char *str)
|
||||||
|
|
||||||
return(err==0);
|
return(err==0);
|
||||||
}
|
}
|
||||||
///Still in work
|
|
||||||
uint64_t ip2int(char * ipconvertint)
|
uint64_t ip2int(char * ipconvertint)
|
||||||
{
|
{
|
||||||
uint64_t final_result =0;
|
uint64_t final_result =0;
|
||||||
|
@ -289,6 +324,8 @@ int bytes_to_string(char * resultzx, uint8_t * catx,int xbsize)
|
||||||
struct protocol * PID;
|
struct protocol * PID;
|
||||||
PID = NULL;
|
PID = NULL;
|
||||||
PID = proto_with_deccode(Hex_To_Int(pid));
|
PID = proto_with_deccode(Hex_To_Int(pid));
|
||||||
|
if(strcmp(PID->name,"ipfs")!=0)
|
||||||
|
{
|
||||||
lastpos = lastpos+2;
|
lastpos = lastpos+2;
|
||||||
char address[(PID->size/4)+1];
|
char address[(PID->size/4)+1];
|
||||||
bzero(address,(PID->size/4)+1);
|
bzero(address,(PID->size/4)+1);
|
||||||
|
@ -340,6 +377,53 @@ int bytes_to_string(char * resultzx, uint8_t * catx,int xbsize)
|
||||||
goto NAX;
|
goto NAX;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
else//IPFS CASE
|
||||||
|
{
|
||||||
|
|
||||||
|
lastpos = lastpos + 4;
|
||||||
|
//FETCHING SIZE OF ADDRESS
|
||||||
|
char prefixedvarint[3];
|
||||||
|
bzero(prefixedvarint,3);
|
||||||
|
int pvi;
|
||||||
|
pvi=0;
|
||||||
|
for(int i=lastpos-2;i<lastpos;i++)
|
||||||
|
{
|
||||||
|
prefixedvarint[pvi] = hex[i];
|
||||||
|
pvi++;
|
||||||
|
}
|
||||||
|
int addrsize;
|
||||||
|
addrsize = HexVar_To_Num_32(prefixedvarint);
|
||||||
|
unsigned char IPFS_ADDR[addrsize+1];
|
||||||
|
bzero(IPFS_ADDR,addrsize+1);
|
||||||
|
int IPFS_PARSE;
|
||||||
|
IPFS_PARSE = 0;
|
||||||
|
for(int i = lastpos;i<lastpos+addrsize;i++)
|
||||||
|
{
|
||||||
|
IPFS_ADDR[IPFS_PARSE] = hex[i];
|
||||||
|
//printf("\nIPFS_ADDR[%d] = %c\n\n",IPFS_PARSE,hex[i]);
|
||||||
|
IPFS_PARSE++;
|
||||||
|
}
|
||||||
|
unsigned char addrbuf[strlen(IPFS_ADDR)/2];
|
||||||
|
bzero(addrbuf,strlen(IPFS_ADDR)/2);
|
||||||
|
memcpy(addrbuf,Hex_To_Var(IPFS_ADDR),sizeof(addrbuf));
|
||||||
|
size_t rezbuflen = strlen(IPFS_ADDR);
|
||||||
|
unsigned char rezultat[rezbuflen];
|
||||||
|
bzero(rezultat,rezbuflen);
|
||||||
|
unsigned char * pointyaddr = NULL;
|
||||||
|
pointyaddr = rezultat;
|
||||||
|
int returnstatus = 0;
|
||||||
|
returnstatus = libp2p_crypto_encoding_base58_encode(addrbuf, sizeof(addrbuf), &pointyaddr, &rezbuflen);
|
||||||
|
if(returnstatus == 0)
|
||||||
|
{
|
||||||
|
printf("\nERROR!!!!!\n");
|
||||||
|
return 0;
|
||||||
|
}
|
||||||
|
strcat(resultzx, "/");
|
||||||
|
strcat(resultzx, PID->name);
|
||||||
|
strcat(resultzx, "/");
|
||||||
|
strcat(resultzx, rezultat);
|
||||||
|
}
|
||||||
|
}
|
||||||
strcat(resultzx, "/");
|
strcat(resultzx, "/");
|
||||||
unload_protocols();
|
unload_protocols();
|
||||||
|
|
||||||
|
@ -476,7 +560,47 @@ char * address_string_to_bytes(struct protocol * xx, char * abc,size_t getsznow)
|
||||||
case 42://IPFS - !!!
|
case 42://IPFS - !!!
|
||||||
{
|
{
|
||||||
|
|
||||||
|
|
||||||
|
char * x_data = NULL;
|
||||||
|
x_data = abc;
|
||||||
|
size_t x_data_length = strlen(x_data);
|
||||||
|
size_t result_buffer_length = libp2p_crypto_encoding_base58_decode_max_size(x_data);
|
||||||
|
unsigned char result_buffer[result_buffer_length];
|
||||||
|
unsigned char* ptr_to_result = result_buffer;
|
||||||
|
memset(result_buffer, 0, result_buffer_length);
|
||||||
|
// now get the decoded address
|
||||||
|
int return_value = libp2p_crypto_encoding_base58_decode(x_data, x_data_length, &ptr_to_result, &result_buffer_length);
|
||||||
|
if (return_value == 0)
|
||||||
|
{
|
||||||
return "ERR";
|
return "ERR";
|
||||||
|
}
|
||||||
|
// throw everything in a hex string so we can debug the results
|
||||||
|
static char returning_result[300];
|
||||||
|
bzero(returning_result,300);
|
||||||
|
char ADDR_ENCODED[300];
|
||||||
|
bzero(ADDR_ENCODED,300);
|
||||||
|
int ilen = 0;
|
||||||
|
bzero(returning_result,300);
|
||||||
|
for(int i = 0; i < result_buffer_length; i++)
|
||||||
|
{
|
||||||
|
// get the char so we can see it in the debugger
|
||||||
|
unsigned char c = ptr_to_result[i];
|
||||||
|
char miu[3];
|
||||||
|
bzero(miu, 3);
|
||||||
|
miu[3] = '\0';
|
||||||
|
sprintf(miu,"%02x", c);
|
||||||
|
|
||||||
|
strcat(ADDR_ENCODED, miu);
|
||||||
|
}
|
||||||
|
ilen = strlen(ADDR_ENCODED);
|
||||||
|
char prefixed[3];
|
||||||
|
strcpy(prefixed,Num_To_HexVar_32(ilen));
|
||||||
|
prefixed[3] = '\0';
|
||||||
|
strcat(returning_result, prefixed);
|
||||||
|
strcat(returning_result, ADDR_ENCODED);
|
||||||
|
//printf("ADDRESS: %s\nSIZEADDR: %d\n",ADDR_ENCODED,ilen);
|
||||||
|
//printf("NOW DECODED VARINT: %d", HexVar_To_Num_32(prefixed));
|
||||||
|
return returning_result;
|
||||||
break;
|
break;
|
||||||
}
|
}
|
||||||
case 480://http
|
case 480://http
|
||||||
|
|
Loading…
Reference in a new issue