diff --git a/Makefile b/Makefile index 4d88a24..9eca2a8 100644 --- a/Makefile +++ b/Makefile @@ -3,20 +3,24 @@ DEBUG = true export DEBUG all: + cd cid; make all; cd cmd; make all; cd commands; make all; cd core; make all; + cd multibase; make all; cd os; make all; cd repo; make all; - cd test; make all; cd thirdparty; make all; + cd test; make all; clean: + cd cid; make clean; cd cmd; make clean; cd commands; make clean; cd core; make clean; + cd multibase; make clean; cd os; make clean; cd repo; make clean; - cd test; make clean; cd thirdparty; make clean; + cd test; make clean; diff --git a/cid/Makefile b/cid/Makefile new file mode 100644 index 0000000..ac42db6 --- /dev/null +++ b/cid/Makefile @@ -0,0 +1,18 @@ +CC = gcc +CFLAGS = -O0 -I../include -I../../c-libp2p/include -I../../c-multihash/include + +ifdef DEBUG +CFLAGS += -g3 +endif + +LFLAGS = +DEPS = +OBJS = cid.o + +%.o: %.c $(DEPS) + $(CC) -c -o $@ $< $(CFLAGS) + +all: $(OBJS) + +clean: + rm -f *.o diff --git a/cid/cid.c b/cid/cid.c new file mode 100644 index 0000000..640f274 --- /dev/null +++ b/cid/cid.c @@ -0,0 +1,137 @@ +/** + * Content ID + */ + +#include +#include +#include + +#include "ipfs/cid/cid.h" + +#include "libp2p/crypto/encoding/base58.h" +#include "ipfs/multibase/multibase.h" +#include "mh/multihash.h" + + +/** + * Create a new CID based on the given hash + * @param version the version + * @param hash the multihash + * @param hash_length the length of the multihash in bytes + * @param codec the codec to be used (NOTE: For version 0, this should be CID_PROTOBUF) + * @param cid where to put the results + * @returns true(1) on success + */ +int cid_new(int version, unsigned char* hash, size_t hash_length, const char codec, struct Cid* cid) { + // allocate memory + cid->hash = malloc(sizeof(unsigned char) * hash_length); + if (cid->hash == NULL) + return 0; + // assign values + cid->version = version; + cid->codec = codec; + memcpy(cid->hash, hash, hash_length); + cid->hash_length = hash_length; + + return 1; + +} + +/*** + * Free the resources from a Cid + * @param cid the struct + * @returns 1 + */ +int cid_free(struct Cid* cid) { + if (cid->hash != NULL) + free(cid->hash); + return 1; +} + +/*** + * Fill a Cid struct based on a base 58 encoded string + * @param incoming the string + * @param incoming_size the size of the string + * @cid the Cid struct to fill + * @return true(1) on success + */ +int cid_decode_from_string(const unsigned char* incoming, size_t incoming_length, struct Cid* cid) { + int retVal = 0; + + if (incoming_length < 2) + return 0; + + // is this a sha_256 multihash? + if (incoming_length == 46 && incoming[0] == 'Q' && incoming[1] == 'm') { + size_t hash_length = libp2p_crypto_encoding_base58_decode_size(incoming_length); + unsigned char hash[hash_length]; + unsigned char* ptr = hash; + retVal = libp2p_crypto_encoding_base58_decode(incoming, incoming_length, &ptr, &hash_length); + if (retVal == 0) + return 0; + // now we have the hash, build the object + return cid_new(0, hash, hash_length, CID_PROTOBUF, cid); + } + + // TODO: finish this + /* + // it wasn't a sha_256 multihash, try to decode it using multibase + size_t buffer_size = multibase_decode_size(incoming_length); + if (buffer_size == 0) + return 0; + unsigned char buffer[buffer_size]; + + memset(buffer, 0, buffer_size); + + retVal = multibase_decode(incoming, incoming_length, buffer, buffer_size, &buffer_size); + if (retVal == 0) + return 0; + + return cid_cast(buffer, buffer_size, cid); + */ + return 0; +} + +/*** + * Turn a multibase decoded string of bytes into a Cid struct + * @param incoming the multibase decoded array + * @param incoming_size the size of the array + * @param cid the Cid structure to fill + */ +int cid_cast(unsigned char* incoming, size_t incoming_size, struct Cid* cid) { + // this is a multihash + if (incoming_size == 34 && incoming[0] == 18 && incoming[1] == 32) { + cid->hash_length = mh_multihash_length(incoming, incoming_size); + cid->codec = CID_PROTOBUF; + cid->version = 0; + // allocate memory for hash + cid->hash = malloc(cid->hash_length); + if (cid->hash == NULL) + return 0; + + mh_multihash_digest(incoming, incoming_size, &cid->hash, &cid->hash_length); + return 1; + } + + /* + *TODO: Implement this + // This is not a multihash. Try to peel the information out of the bytes + // first the version + int pos = 0, retVal = 0; + int num_bytes = 0; + retVal = varint_to_int(&incoming[pos], &cid->version, &num_bytes); + if (retVal == 0) + return 0; + pos = num_bytes; + // now the codec + retVal = varint_to_int(&incoming[pos], &cid->codec, &num_bytes); + if (retVal == 0) + return 0; + pos += num_bytes; + // now what is left + cid->hash_length = incoming_size - pos; + // TODO: allocate memory + memcpy(cid->hash, &incoming[pos], cid->hash_length); + */ + return 0; +} diff --git a/include/ipfs/cid/cid.h b/include/ipfs/cid/cid.h new file mode 100644 index 0000000..eedd560 --- /dev/null +++ b/include/ipfs/cid/cid.h @@ -0,0 +1,62 @@ +/*** + * A content id + */ + +#ifndef __IPFS_CID_CID_H +#define __IPFS_CID_CID_H + +#define CID_PROTOBUF 0x70 +#define CID_CBOR 0x71 +#define CID_RAW 0x72 +#define CID_JSON 0x73 +#define CID_ETHEREUM_BLOCK 0x90 +#define CID_ETHEREUM_TX 0x91 +#define CID_BITCOIN_BLOCK 0xb0 +#define CID_BITCOIN_TX 0xb1 +#define CID_ZCASH_BLOCK 0xc0 +#define CID_ZCASH_TX 0xc1 + +struct Cid { + int version; + char codec; + unsigned char* hash; // a multihash + size_t hash_length; +}; + + +/** + * Create a new CID based on the given hash + * @param version the version + * @param hash the multihash + * @param hash_length the length of the multihash in bytes + * @param codec the codec to be used (NOTE: For version 0, this should be CID_PROTOBUF) + * @param cid where to put the results + * @returns true(1) on success + */ +int cid_new(int version, unsigned char* hash, size_t hash_length, const char codec, struct Cid* cid); + +/*** + * Free the resources from a Cid + * @param cid the struct + * @returns 1 + */ +int cid_free(struct Cid* cid); + +/*** + * Fill a Cid struct based on a base 58 encoded string + * @param incoming the string + * @param incoming_size the size of the string + * @cid the Cid struct to fill + * @return true(1) on success + */ +int cid_decode_from_string(const unsigned char* incoming, size_t incoming_length, struct Cid* cid); + +/*** + * Turn a multibase decoded string of bytes into a Cid struct + * @param incoming the multibase decoded array + * @param incoming_size the size of the array + * @param cid the Cid structure to fill + */ +int cid_cast(unsigned char* incoming, size_t incoming_size, struct Cid* cid); + +#endif diff --git a/include/ipfs/multibase/multibase.h b/include/ipfs/multibase/multibase.h new file mode 100644 index 0000000..4d555f1 --- /dev/null +++ b/include/ipfs/multibase/multibase.h @@ -0,0 +1,47 @@ +#include + +#ifndef __IPFS_MULTIBASE_MULTIBASE_H__ +#define __IPFS_MULTIBASE_MULTIBASE_H__ + +// the first digit of data, to determine the encoding used or using +#define MULTIBASE_BASE1 '1' +#define MULTIBASE_BASE2 '0' +#define MULTIBASE_BASE8 '7' +#define MULTIBASE_BASE10 '9' +#define MULTIBASE_BASE16 'f' +#define MULTIBASE_BASE58_FLICKR 'Z' +#define MULTIBASE_BASE58_BTC 'z' + +/** + * Encode data in multibase format + * @param base the format to use (i.e. MULTIBASE_BASE58_BTC) + * @param incoming the data to encode + * @param incoming_length the length of the data to encode + * @param results where to put the results + * @param results_max_length the size of the results buffer + * @param results_length the size of the results after being encoded + * @returns true(1) on success + */ +int multibase_encode(const char base, const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t results_max_length, size_t* results_length); + +/*** + * Calculates the size of the buffer neccessary to encode the incoming byte array + * @param base the encoding to use + * @param incoming the incoming array of bytes + * @param incoming_length the length of the array in bytes + * @returns the appropriate size of the buffer + */ +int multibase_encode_size(const char base, const unsigned char* incoming, size_t incoming_length); + +/** + * Decode data that was encoded in multibase format + * @param incoming the data to decode + * @param incoming_length the length of the data to decode + * @param results where to put the results + * @param results_max_length the size of the results buffer + * @param results_length the size of the results after being encoded + * @returns true(1) on success + */ +int multibase_decode(const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t results_max_length, size_t* results_length); + +#endif diff --git a/include/ipfs/node/node.h b/include/ipfs/node/node.h new file mode 100644 index 0000000..abedfdf --- /dev/null +++ b/include/ipfs/node/node.h @@ -0,0 +1,14 @@ +/** + * An implementation of an IPFS node + * Copying the go-ipfs-node project + */ + +#include + + + +struct Link { + char* name; + uint64_t size; + struct Cid cid; // content id +}; diff --git a/multibase/Makefile b/multibase/Makefile new file mode 100644 index 0000000..1552afe --- /dev/null +++ b/multibase/Makefile @@ -0,0 +1,18 @@ +CC = gcc +CFLAGS = -O0 -I../include -I../../c-libp2p/include -I../../c-multihash/include + +ifdef DEBUG +CFLAGS += -g3 +endif + +LFLAGS = +DEPS = +OBJS = multibase.o + +%.o: %.c $(DEPS) + $(CC) -c -o $@ $< $(CFLAGS) + +all: $(OBJS) + +clean: + rm -f *.o diff --git a/multibase/multibase.c b/multibase/multibase.c new file mode 100644 index 0000000..84b27e8 --- /dev/null +++ b/multibase/multibase.c @@ -0,0 +1,113 @@ +#include +#include + +#include "ipfs/multibase/multibase.h" +#include "libp2p/crypto/encoding/base58.h" +#include "libp2p/crypto/encoding/base16.h" + +/** + * Encode data in multibase format. NOTE: currently only supports MULTIBASE_BASE58_BTC and MULTIBASE_BASE16 + * @param base the format to use (i.e. MULTIBASE_BASE58_BTC) + * @param incoming the data to encode + * @param incoming_length the length of the data to encode + * @param results where to put the results + * @param results_max_length the size of the results buffer + * @param results_length the size of the results after being encoded + * @returns true(1) on success + */ +int multibase_encode(const char base, const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t results_max_length, size_t* results_length) { + *results_length = results_max_length; + int retVal = 0; + + switch (base) { + case (MULTIBASE_BASE58_BTC): + retVal = libp2p_crypto_encoding_base58_encode(incoming, incoming_length, &results, results_length); + break; + case(MULTIBASE_BASE16): + retVal = libp2p_crypto_encoding_base16_encode(incoming, incoming_length, results, results_length); + break; + default: // unsupported format + return 0; + } + // check to see if there was a problem + if (retVal == 0) + return 0; + + // we have the hash, now add the code to the first byte (if there is room) + + if (*results_length >= results_max_length) { // It could be equal, but should never be greater. But just in case. + return 0; // buffer isn't big enough + } + + memcpy(&results[1], results, *results_length); + results[0] = base; + *results_length += 1; + + return 1; +} + +/*** + * Calculates the size of the buffer neccessary to encode the incoming byte array + * @param base the encoding to use + * @param incoming the incoming array of bytes + * @param incoming_length the length of the array in bytes + * @returns the appropriate size of the buffer + */ +int multibase_encode_size(const char base, const unsigned char* incoming, size_t incoming_length) { + switch (base) { + case (MULTIBASE_BASE58_BTC): + return libp2p_crypto_encoding_base58_encode_size(incoming_length) + 1; + case (MULTIBASE_BASE16): + return libp2p_crypto_encoding_base16_encode_size(incoming_length); + } + return 0; +} + +/** + * Decode data that was encoded in multibase format + * @param incoming the data to decode + * @param incoming_length the length of the data to decode + * @param results where to put the results + * @param results_max_length the size of the results buffer + * @param results_length the size of the results after being encoded + * @returns true(1) on success + */ +int multibase_decode(const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t results_max_length, size_t* results_length) { + *results_length = results_max_length; + int retVal = 0; + + const char base = incoming[0]; + + switch (base) { + case (MULTIBASE_BASE58_BTC): + retVal = libp2p_crypto_encoding_base58_decode(&incoming[1], incoming_length - 1, &results, results_length); + break; + case(MULTIBASE_BASE16): + retVal = libp2p_crypto_encoding_base16_decode(&incoming[1], incoming_length - 1, results, results_length); + break; + default: // unsupported format + return 0; + } + // check to see if there was a problem + if (retVal == 0) + return 0; + + return 1; +} + +/*** + * Calculates the size of the buffer neccessary to decode the incoming byte array + * @param base the encoding to use + * @param incoming the incoming array of bytes + * @param incoming_length the length of the array in bytes + * @returns the appropriate size of the buffer + */ +int multibase_decode_size(const char base, const unsigned char* incoming, size_t incoming_length) { + switch (base) { + case (MULTIBASE_BASE58_BTC): + return libp2p_crypto_encoding_base58_decode_size(incoming_length) + 1; + case (MULTIBASE_BASE16): + return libp2p_crypto_encoding_base16_decode_size(incoming_length); + } + return 0; +} diff --git a/node/node.c b/node/node.c new file mode 100644 index 0000000..04a1669 --- /dev/null +++ b/node/node.c @@ -0,0 +1,7 @@ +/** + * An implementation of an IPFS node + * Copying the go-ipfs-node project + */ + +#include "ipfs/node/node.h" + diff --git a/repo/config/Makefile b/repo/config/Makefile index 041661b..c8f8e71 100644 --- a/repo/config/Makefile +++ b/repo/config/Makefile @@ -7,7 +7,7 @@ endif LFLAGS = DEPS = config.h datastore.h identity.h -OBJS = config.o +OBJS = config.o identity.o bootstrap_peers.o datastore.o gateway.o addresses.o swarm.o peer.o %.o: %.c $(DEPS) $(CC) -c -o $@ $< $(CFLAGS) diff --git a/repo/config/identity.c b/repo/config/identity.c index 71f5e49..d0ca8de 100644 --- a/repo/config/identity.c +++ b/repo/config/identity.c @@ -23,7 +23,7 @@ int repo_config_identity_new(struct Identity* identity, unsigned long num_bits_f if (num_bits_for_keypair < 1024) return 0; // generate the private key (& public) - if (!crypto_rsa_generate_keypair( &(identity->private_key), num_bits_for_keypair)) + if (!libp2p_crypto_rsa_generate_keypair( &(identity->private_key), num_bits_for_keypair)) return 0; // now the private key (in DER format) is in identity->private_key->der; diff --git a/repo/fsrepo/fs_repo.c b/repo/fsrepo/fs_repo.c index 96feebd..ac9ec75 100644 --- a/repo/fsrepo/fs_repo.c +++ b/repo/fsrepo/fs_repo.c @@ -30,9 +30,9 @@ int repo_config_write_config_file(char* full_filename, struct RepoConfig* config fprintf(out_file, " \"PeerID\": \"%s\",\n", config->identity.peer_id); // TODO: print correct format of private key // first base 64 it - size_t encoded_size = base64_encode_length(config->identity.private_key.der, config->identity.private_key.der_length); + size_t encoded_size = libp2p_crypto_encoding_base64_encode_size(config->identity.private_key.der_length); unsigned char encoded_buffer[encoded_size + 1]; - int retVal = base64_encode(config->identity.private_key.der, config->identity.private_key.der_length, encoded_buffer, encoded_size, &encoded_size); + int retVal = libp2p_crypto_encoding_base64_encode(config->identity.private_key.der, config->identity.private_key.der_length, encoded_buffer, encoded_size, &encoded_size); if (retVal == 0) return 0; encoded_buffer[encoded_size] = 0; diff --git a/test/Makefile b/test/Makefile index dcf52a8..5f7663a 100644 --- a/test/Makefile +++ b/test/Makefile @@ -1,13 +1,13 @@ CC = gcc -CFLAGS = -O0 -I../include -I../../c-libp2p/include -g3 -LFLAGS = -L../../c-libp2p -lp2p -DEPS = cmd/ipfs/test_init.h repo/test_repo_bootstrap_peers.h repo/test_repo_config.h repo/test_repo_identity.h +CFLAGS = -O0 -I../include -I../../c-libp2p/include -I../../c-multihash/include -g3 +LFLAGS = -L../../c-libp2p -L../../c-multihash -lp2p -lm -lmultihash +DEPS = cmd/ipfs/test_init.h repo/test_repo_bootstrap_peers.h repo/test_repo_config.h repo/test_repo_identity.h cid/test_cid.h OBJS = testit.o ../cmd/ipfs/init.o ../commands/argument.o ../commands/command_option.o \ ../commands/command.o ../commands/cli/parse.o ../core/builder.o ../repo/fsrepo/fs_repo.o \ ../repo/fsrepo/fs_repo.o ../repo//config/config.o ../os/utils.o ../repo/config/identity.o \ ../repo/config/bootstrap_peers.o ../repo/config/datastore.o ../repo/config/gateway.o \ ../repo/config/addresses.o ../repo/config/swarm.o ../repo/config/peer.o \ - ../thirdparty/ipfsaddr/ipfs_addr.o + ../thirdparty/ipfsaddr/ipfs_addr.o ../cid/cid.o ../multibase/multibase.o %.o: %.c $(DEPS) $(CC) -c -o $@ $< $(CFLAGS) diff --git a/test/cid/test_cid.h b/test/cid/test_cid.h new file mode 100644 index 0000000..9cc1341 --- /dev/null +++ b/test/cid/test_cid.h @@ -0,0 +1,79 @@ +#include + +#include "mh/hashes.h" +#include "mh/multihash.h" + +#include "ipfs/cid/cid.h" +#include "ipfs/multibase/multibase.h" + +#include "libp2p/crypto/hashing/sha256.h" + +int test_cid_new_free() { + + struct Cid cid; + const unsigned char* hash = "ABC123"; + int retVal = cid_new(0, (unsigned char*)hash, strlen((char*)hash), CID_PROTOBUF, &cid); + if (retVal == 0) + return 0; + + if (cid.version != 0) + return 0; + + if (cid.codec != CID_PROTOBUF) + return 0; + + if (cid.hash_length != strlen((char*)hash)) + return 0; + + if (strncmp((char*)cid.hash, (char*)hash, 6) != 0) + return 0; + + return cid_free(&cid); +} + +/*** + * Test sending a multibase encoded multihash into cid_cast method + * that should return a Cid struct + */ +int test_cid_cast_multihash() { + // first, build a multihash + char* string_to_hash = "Hello, World!"; + unsigned char hashed[32]; + memset(hashed, 0, 32); + // hash the string + libp2p_crypto_hashing_sha256(string_to_hash, strlen(string_to_hash), hashed); + size_t multihash_size = mh_new_length(MH_H_SHA2_256, 32); + unsigned char multihash[multihash_size]; + memset(multihash, 0, multihash_size); + unsigned char* ptr = multihash; + + int retVal = mh_new(ptr, MH_H_SHA2_256, hashed, 32); + if (retVal < 0) + return 0; + + // now call cast + struct Cid cid; + retVal = cid_cast(multihash, multihash_size, &cid); + if (retVal == 0) + return 0; + // check results + if (cid.version != 0) + return 0; + if (cid.hash_length != 32) + return 0; + if (cid.codec != CID_PROTOBUF) + return 0; + if (strncmp(hashed, cid.hash, 32) != 0) + return 0; + + return 1; +} + +int test_cid_cast_non_multihash() { + // this should turn a multibase encoded string into a cid struct + // first, build a multibase encoded string + // now call cast + // check results + return 0; +} + diff --git a/test/repo/test_repo_identity.h b/test/repo/test_repo_identity.h index bde0569..1fddb40 100644 --- a/test/repo/test_repo_identity.h +++ b/test/repo/test_repo_identity.h @@ -29,9 +29,9 @@ int test_repo_config_identity_new() { // test this key int test_repo_config_identity_private_key() { const char* priv_b64 = "CAASpwkwggSjAgEAAoIBAQDTDJBWjDzS/HxDNOHazvzH2bu9CPMVHUrrvKRdBUM5ansL6/CC3MVZ6HVm4O6QHRapN6EF2CbrTgI4KBOXIL125Xo8MlROnyfXYk3O5q2tgwL/MbW8kXjtkyCfBak7MUoLOdLU7Svg0gkl3l+uDAiDcCLnwJVcFfq9ch6z4wMOhYJqE5dtx0uXxn6IuKWl1B69FTvBXCc0thw8Rw54b941FDcsBH5ttV9mRNCJym3poZ5qalNgXlxoIIB+PUx5QD+aq7KMJdpAX8HkapBntCOahP/QUceRmma0grlZLeYkH6/oi/hIrM6se3KUZ+F6tBuDFys8UAZy/X2BCUbKjbxtAgMBAAECggEANWfQfpYuLhXGPBt9q6kFPm1SnJtPJ+CpvM2XqhJS2IyhZnrl+bd0GTRBwS7aL42s1lVFYf04nAK5fQxnKK8YQqX/MIxr2RldM5ukpN6qxGWKtJkXrAgD2dqJPrRoBpqKahzPxSHfIJ0Fw5dqDtjsrpYJvyt0oEDPmnDuZAbmFx4sJqnesPNhKxtRMBx1+yxGVuRVJjHcqAgqPqwNiuoMEaYMY+G9yzT6vza8ovCpbX7BBIgM5fAT9PD8TBG//Vu9THvj/ZomiVG2qv6RL0qQyVb+DUzPZz1amBsSvahtXCl72jA3JwAZ943RxSR66P934S0ashkVwLUi46z/EAbJ4QKBgQDojGIO07BEVL2+7VxlGL9XGZQp4Y3qlhh2zDDQGwkCq/KQ+BdNYWitPwqRl9GqFLgpmeQIhyHTOa/IThx+AXGKVQ24ROH+skUs4IbO6R3qY7BKtb5lkZE/Yln09x70BBngUYAzh/rtnsXO3cl1x2XDDqUbCwlGcDAs8Jh/6UnvQwKBgQDoVSQs7Uq9MJCGIUM2bixX89tHzSxq5mn9wMD3/XRVfT5Ua8YkYBuzcmlcT39N7L5BwuyFqX3Vi7lv/Ya/qaQP6XkrZ8W1OAaTlYewfE5ZgknJqSpXcNWhABKeNmqndvqyQ/8HNCv/j8AdraGB2DGO57Xso5J0CQ43W/U9+QIyjwKBgHLL2hw3o+wXaRO3WMUPUmVM2zdRgR0suybp5a7Vqb0H5NZrohUw4NulIzJ8H6Q2VjMzJL6Q9sGu2HepF6ecTtBa7ErqtiVlG4Dr1aCOs5XhYEWBMlwxX+JKSt4Cn+UVoTB7Cy5lEhn7JurX0Xuy0ylXMWoIKKv89cs5eg6quzTBAoGAaq9eEztLjKCWXOE9SetBdYnG8aunb9cqaJlwgu/h0bfXPVDYBbAUSEyLURY4MQI7Q1tM3Pu9iqfEmUZj7/LoIV5mg6X9RX/alT6etk3+dF+9nlqN1OU9U9cCtZ/rTcb2y5EptJcidRH/eCFY/pTV/PcttOJPx/S4kHcroC+N8MUCgYEA6DA5QHxHfNN6Nxv+pEzy2DIxFe9RrBxS+KPBsra1C8jgdeMf4EmfU0Nox92V0q0bRrD5ztqQwSONI0hSRb1iiMWR6MuFnAFajUJfASjjIlZ6nIQjQslI7vjlvYyyHS/p/Codxap+yJlTLWwVEOXp2D9pWwiMq1xEyf0TH1BosvM="; - size_t decoded_len = base64_decode_length(priv_b64, strlen(priv_b64)); + size_t decoded_len = libp2p_crypto_encoding_base64_decode_size(strlen(priv_b64)); char* out_buff = malloc(sizeof(char) * decoded_len); - base64_decode(priv_b64, strlen(priv_b64), out_buff, decoded_len, &decoded_len); + libp2p_crypto_encoding_base64_decode(priv_b64, strlen(priv_b64), out_buff, decoded_len, &decoded_len); char str[decoded_len]; int j = 0; for (int i = 0; i < decoded_len; i++) { diff --git a/test/test_ipfs b/test/test_ipfs new file mode 100755 index 0000000..675bfe5 Binary files /dev/null and b/test/test_ipfs differ diff --git a/test/testit.c b/test/testit.c index 2189f33..9f88639 100644 --- a/test/testit.c +++ b/test/testit.c @@ -2,6 +2,7 @@ #include "repo/test_repo_identity.h" #include "repo/test_repo_bootstrap_peers.h" #include "cmd/ipfs/test_init.h" +#include "cid/test_cid.h" int testit(const char* name, int (*func)(void)) { printf("Testing %s...\n", name); @@ -14,6 +15,9 @@ int testit(const char* name, int (*func)(void)) { } int main(int argc, char** argv) { + testit("test_cid_new_free", test_cid_new_free); + testit("test_cid_cast_multihash", test_cid_cast_multihash); + testit("test_cid_cast_non_multihash", test_cid_cast_non_multihash); testit("test_init_new_installation", test_init_new_installation); testit("test_repo_config_init", test_repo_config_init); testit("test_repo_config_write", test_repo_config_write);