From 0d8f599ac9deed12f0a876c8c2baa94f4a1a600e Mon Sep 17 00:00:00 2001 From: jmjatlanta Date: Wed, 2 Nov 2016 13:09:38 -0500 Subject: [PATCH] Config file is now closer to completion. Still need to figure out ASN.1 DER for private key, and add peer id to config file --- cmd/ipfs/init.c | 2 +- include/ipfs/repo/config/addresses.h | 36 ++++++ include/ipfs/repo/config/bootstrap_peers.h | 33 ++++++ include/ipfs/repo/config/config.h | 43 +++++-- include/ipfs/repo/config/datastore.h | 18 ++- include/ipfs/repo/config/gateway.h | 36 ++++++ include/ipfs/repo/config/swarm.h | 33 ++++++ include/ipfs/thirdparty/ipfsaddr/ipfs_addr.h | 31 +++++ repo/config/addresses.c | 36 ++++++ repo/config/bootstrap_peers.c | 54 +++++++++ repo/config/config.c | 116 ++++++++----------- repo/config/datastore.c | 41 +++++++ repo/config/gateway.c | 43 +++++++ repo/config/identity.c | 7 +- repo/config/swarm.c | 40 +++++++ test/cmd/ipfs/test_init.h | 2 +- test/repo/test_repo.h | 13 --- test/repo/test_repo_bootstrap_peers.h | 46 ++++++++ test/repo/test_repo_config.h | 23 ++++ test/repo/test_repo_identity.h | 21 +++- test/testit.c | 7 +- thirdparty/ipfsaddr/ipfs_addr.c | 27 +++++ 22 files changed, 606 insertions(+), 102 deletions(-) create mode 100644 include/ipfs/repo/config/addresses.h create mode 100644 include/ipfs/repo/config/bootstrap_peers.h create mode 100644 include/ipfs/repo/config/gateway.h create mode 100644 include/ipfs/repo/config/swarm.h create mode 100644 include/ipfs/thirdparty/ipfsaddr/ipfs_addr.h create mode 100644 repo/config/addresses.c create mode 100644 repo/config/bootstrap_peers.c create mode 100644 repo/config/datastore.c create mode 100644 repo/config/gateway.c create mode 100644 repo/config/swarm.c delete mode 100644 test/repo/test_repo.h create mode 100644 test/repo/test_repo_bootstrap_peers.h create mode 100644 thirdparty/ipfsaddr/ipfs_addr.c diff --git a/cmd/ipfs/init.c b/cmd/ipfs/init.c index af950be..4726b7b 100644 --- a/cmd/ipfs/init.c +++ b/cmd/ipfs/init.c @@ -56,7 +56,7 @@ int do_init(FILE* out_file, char* repo_root, int empty, int num_bits_for_keypair return 0; //TODO: If the conf is null, make one if (conf == NULL) - repo_config_init(conf, num_bits_for_keypair); + repo_config_init(conf, num_bits_for_keypair, repo_root); //TODO: initialize the fs repo //TODO: add default assets return initialize_ipns_keyspace(repo_root); diff --git a/include/ipfs/repo/config/addresses.h b/include/ipfs/repo/config/addresses.h new file mode 100644 index 0000000..ffc0bc1 --- /dev/null +++ b/include/ipfs/repo/config/addresses.h @@ -0,0 +1,36 @@ +// +// addresses.h +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#ifndef addresses_h +#define addresses_h + +#include "swarm.h" + +struct Addresses { + struct SwarmAddresses swarm; + char* api; + char* gateway; +}; + +/** + * initialize the Addresses struct with data. Must add the SwarmAddresses later + * @param addresses the struct + * @param api the API address (like "/ip4/127.0.0.1/tcp/5001") + * @param gateway the gateway address (like "ip4/127.0.0.1/tcp/8080") + * @returns true(1) on success, otherwise false(0) + */ +int repo_config_addresses_init(struct Addresses* addresses, char* api, char* gateway); + +/** + * clear any memory allocated by a address_init call + * @param addresses the struct + * @returns true(1) + */ +int repo_config_addresses_free(struct Addresses* addresses); + +#endif /* addresses_h */ diff --git a/include/ipfs/repo/config/bootstrap_peers.h b/include/ipfs/repo/config/bootstrap_peers.h new file mode 100644 index 0000000..19c43bb --- /dev/null +++ b/include/ipfs/repo/config/bootstrap_peers.h @@ -0,0 +1,33 @@ +// +// bootstrap_peer.h +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#ifndef bootstrap_peer_h +#define bootstrap_peer_h + +#include "ipfs/thirdparty/ipfsaddr/ipfs_addr.h" + +struct BootstrapPeers { + int num_peers; + struct IPFSAddr** peers; +}; + +/*** + * get a list of peers to use to bootstrap the instance + * @param bootstrap_peers an array of IPFSAddr structs, will be allocated by this function + * @returns true(1) on success, otherwise false(0) + */ +int repo_config_bootstrap_peers_retrieve(struct BootstrapPeers* bootstrap_peers); + +/*** + * frees up memory caused by call to repo_config_bootstrap_peers_retrieve + * @param list the list to free + * @returns true(1) + */ +int repo_config_bootstrap_peers_free(struct BootstrapPeers* list); + +#endif /* bootstrap_peer_h */ diff --git a/include/ipfs/repo/config/config.h b/include/ipfs/repo/config/config.h index 4ca569d..6911a2f 100644 --- a/include/ipfs/repo/config/config.h +++ b/include/ipfs/repo/config/config.h @@ -3,21 +3,46 @@ #include "datastore.h" #include "identity.h" +#include "swarm.h" +#include "bootstrap_peers.h" +#include "addresses.h" +#include "gateway.h" + +struct MDNS { + int enabled; + int interval; +}; + +struct Discovery { + struct MDNS mdns; +}; + +struct Mounts { + char* ipfs; + char* ipns; +}; + +struct Ipns { + int resolve_cache_size; +}; + +struct Reprovider { + char* interval; +}; struct RepoConfig { struct Identity identity; struct Datastore datastore; - //struct address* addresses; - //struct mount* mounts; - //struct discovery discovery; - //struct ipns ipns; - //struct bootstrap* peer_addresses; + struct Addresses addresses; + struct Mounts mounts; + struct Discovery discovery; + struct Ipns ipns; + struct BootstrapPeers peer_addresses; //struct tour tour; - //struct gateway gateway; + struct Gateway gateway; //struct supernode_routing supernode_client_config; //struct api api; - //struct swarm swarm; - //struct reprovider reprovider; + struct Reprovider reprovider; }; /** @@ -47,6 +72,6 @@ int config_path(char* config_root, char* extension, char* result, int max_len); * @param num_bits_for_keypair number of bits for the key pair * @returns true(1) on success, otherwise 0 */ -int repo_config_init(struct RepoConfig* config, unsigned int num_bits_for_keypair); +int repo_config_init(struct RepoConfig* config, unsigned int num_bits_for_keypair, char* repo_path); #endif diff --git a/include/ipfs/repo/config/datastore.h b/include/ipfs/repo/config/datastore.h index ca3c5ae..c075265 100644 --- a/include/ipfs/repo/config/datastore.h +++ b/include/ipfs/repo/config/datastore.h @@ -9,7 +9,7 @@ struct Datastore { char* type; char* path; char* storage_max; - int64_t storage_gc_watermark; + int storage_gc_watermark; char* gc_period; char* params; @@ -18,4 +18,20 @@ struct Datastore { int bloom_filter_size; }; +/*** + * initialize the structure of the datastore + * @param datastore the struct to initialize + * @param config_root the path to the root of IPFS + * @returns true(1) on success + */ +int repo_config_datastore_init(struct Datastore* datastore, char* config_root); + +/*** + * deallocate the memory and clear resources from a datastore_init + * @param datastore the struct to deallocate + * @returns true(1) + */ +int repo_config_datastore_free(struct Datastore* datastore); + + #endif diff --git a/include/ipfs/repo/config/gateway.h b/include/ipfs/repo/config/gateway.h new file mode 100644 index 0000000..cdf63ab --- /dev/null +++ b/include/ipfs/repo/config/gateway.h @@ -0,0 +1,36 @@ +// +// gateway.h +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#ifndef gateway_h +#define gateway_h + +struct HTTPHeader { + char* header; + char* value; +}; + +struct HTTPHeaders { + struct HTTPHeader** headers; + int num_elements; +}; + +struct PathPrefixes { + int num_elements; + char** prefixes; +}; + +struct Gateway { + char* root_redirect; + int writable; + struct PathPrefixes path_prefixes; + struct HTTPHeaders http_headers; +}; + +int repo_config_gateway_http_header_init(struct HTTPHeaders* http_headers, char** headers, char** values, int num_elements); + +#endif /* gateway_h */ diff --git a/include/ipfs/repo/config/swarm.h b/include/ipfs/repo/config/swarm.h new file mode 100644 index 0000000..521c4e8 --- /dev/null +++ b/include/ipfs/repo/config/swarm.h @@ -0,0 +1,33 @@ +// +// swarm.h +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#ifndef swarm_h +#define swarm_h + +struct SwarmAddresses { + int num_addresses; + char** addresses; +}; + +/** + * add addresses to the SwarmAddresses struct + * @param swarm_addresses the structure + * @param addresses the array of addresses to store + * @param array_length the number of elements in addresses array + * @returns true(1) on success + */ +int repo_config_swarm_address_init(struct SwarmAddresses* swarm_addresses, char** addresses, int array_length); + +/*** + * free up memory from repo_config_swarm_address_init + * @param swarm_addresses the structure + * @returns true(1) + */ +int repo_config_swarm_address_free(struct SwarmAddresses* swarm_addresses); + +#endif /* swarm_h */ diff --git a/include/ipfs/thirdparty/ipfsaddr/ipfs_addr.h b/include/ipfs/thirdparty/ipfsaddr/ipfs_addr.h new file mode 100644 index 0000000..54c8f21 --- /dev/null +++ b/include/ipfs/thirdparty/ipfsaddr/ipfs_addr.h @@ -0,0 +1,31 @@ +// +// ipfs_addr.h +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#ifndef ipfs_addr_h +#define ipfs_addr_h + +struct IPFSAddr { + char* entire_string; +}; + +/** + * initialize a new IPFSAddr struct. NOTE: be sure to use ipfsaddr_free() + * @param addr the struct to initialize + * @param string the string that contains the address + * @returns true(1) on success, false(0) otherwise + */ +int ipfsaddr_init_new(struct IPFSAddr** addr, char* string); + +/*** + * frees allocated memory in the struct + * @param addr the struct that is going away + * @returns true(1) on success, false(0) otherwise + */ +int ipfsaddr_free(struct IPFSAddr* addr); + +#endif /* ipfs_addr_h */ diff --git a/repo/config/addresses.c b/repo/config/addresses.c new file mode 100644 index 0000000..c9c3959 --- /dev/null +++ b/repo/config/addresses.c @@ -0,0 +1,36 @@ +// +// addresses.c +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#include +#include +#include + +#include "ipfs/repo/config/addresses.h" + +char* alloc_and_copy(char* source) { + unsigned long strLen = strlen(source); + char* result = malloc(sizeof(char) * (strLen + 1)); + strncpy(result, source, strLen); + result[strLen] = 0; + return result; +} + +int repo_config_addresses_init(struct Addresses* addresses, char* api, char* gateway) { + // allocate memory to store api and gateway + addresses->api = alloc_and_copy(api); + addresses->gateway = alloc_and_copy(gateway); + if (addresses->api == NULL || addresses->gateway == NULL) + return 0; + return 1; +} + +int repo_config_addresses_free(struct Addresses* addresses) { + free(addresses->api); + free(addresses->gateway); + return 1; +} diff --git a/repo/config/bootstrap_peers.c b/repo/config/bootstrap_peers.c new file mode 100644 index 0000000..c2f0ad9 --- /dev/null +++ b/repo/config/bootstrap_peers.c @@ -0,0 +1,54 @@ +// +// bootstrap_peers.c +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#include +#include + +#include "ipfs/thirdparty/ipfsaddr/ipfs_addr.h" +#include "ipfs/repo/config/bootstrap_peers.h" + +int repo_config_bootstrap_peers_retrieve(struct BootstrapPeers* list) { + + char* default_bootstrap_addresses[] = { + "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ", // mars.i.ipfs.io + "/ip4/104.236.176.52/tcp/4001/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z", // neptune.i.ipfs.io + "/ip4/104.236.179.241/tcp/4001/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM", // pluto.i.ipfs.io + "/ip4/162.243.248.213/tcp/4001/ipfs/QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm", // uranus.i.ipfs.io + "/ip4/128.199.219.111/tcp/4001/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu", // saturn.i.ipfs.io + "/ip4/104.236.76.40/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64", // venus.i.ipfs.io + "/ip4/178.62.158.247/tcp/4001/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd", // earth.i.ipfs.io + "/ip4/178.62.61.185/tcp/4001/ipfs/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3", // mercury.i.ipfs.io + "/ip4/104.236.151.122/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx", // jupiter.i.ipfs.io + }; + + list->num_peers = 9; + // allocate memory for list + list->peers = malloc(sizeof(struct IPFSAddr*) * list->num_peers); + + for(int i = 0; i < list->num_peers; i++) { + // allocate memory for struct + struct IPFSAddr* currAddr = malloc(sizeof(struct IPFSAddr)); + if (currAddr == NULL) + return 0; + // allocate memory for string + if (ipfsaddr_init_new(&currAddr, default_bootstrap_addresses[i]) == 0) + return 0; + list->peers[i] = currAddr; + } + return 1; +} + +int repo_config_bootstrap_peers_free(struct BootstrapPeers* list) { + int array_size = sizeof(list); + + for(int i = 0; i < array_size; i++) { + ipfsaddr_free(list->peers[i]); + free(list->peers[i]); + } + return 1; +} diff --git a/repo/config/config.c b/repo/config/config.c index fec1b84..d8c57b5 100644 --- a/repo/config/config.c +++ b/repo/config/config.c @@ -12,7 +12,8 @@ #include "config.h" #include "ipfs/os/utils.h" - +#include "ipfs/repo/config/bootstrap_peers.h" +#include "ipfs/repo/config/swarm.h" /*** * public @@ -81,76 +82,55 @@ int config_get_file_name(char* path, char* result) { * @param num_bits_for_keypair number of bits for the key pair * @returns true(1) on success, otherwise 0 */ -int repo_config_init(struct RepoConfig* config, unsigned int num_bits_for_keypair) { - //TODO: convert to c - struct Identity* identity; - repo_config_identity_new(identity, num_bits_for_keypair); - return 0; - //TODO - /* - identity, err := identityConfig(out, nBitsForKeypair) - if err != nil { - return nil, err - } +int repo_config_init(struct RepoConfig* config, unsigned int num_bits_for_keypair, char* repo_path) { - bootstrapPeers, err := DefaultBootstrapPeers() - if err != nil { - return nil, err - } + // identity + int retVal = repo_config_identity_new(&(config->identity), num_bits_for_keypair); + if (retVal == 0) + return 0; - datastore, err := datastoreConfig() - if err != nil { - return nil, err - } + // bootstrap peers + retVal = repo_config_bootstrap_peers_retrieve(&(config->peer_addresses)); + if (retVal == 0) + return 0; - conf := &Config{ - - // setup the node's default addresses. - // NOTE: two swarm listen addrs, one tcp, one utp. - Addresses: Addresses{ - Swarm: []string{ - "/ip4/0.0.0.0/tcp/4001", - // "/ip4/0.0.0.0/udp/4002/utp", // disabled for now. - "/ip6/::/tcp/4001", - }, - API: "/ip4/127.0.0.1/tcp/5001", - Gateway: "/ip4/127.0.0.1/tcp/8080", - }, - - Datastore: datastore, - Bootstrap: BootstrapPeerStrings(bootstrapPeers), - Identity: identity, - Discovery: Discovery{MDNS{ - Enabled: true, - Interval: 10, - }}, - - // setup the node mount points. - Mounts: Mounts{ - IPFS: "/ipfs", - IPNS: "/ipns", - }, - - Ipns: Ipns{ - ResolveCacheSize: 128, - }, - - Gateway: Gateway{ - RootRedirect: "", - Writable: false, - PathPrefixes: []string{}, - HTTPHeaders: map[string][]string{ - "Access-Control-Allow-Origin": []string{"*"}, - "Access-Control-Allow-Methods": []string{"GET"}, - "Access-Control-Allow-Headers": []string{"X-Requested-With"}, - }, - }, - Reprovider: Reprovider{ - Interval: "12h", - }, - } + // datastore + retVal = repo_config_datastore_init(&(config->datastore), repo_path); + if (retVal == 0) + return 0; + + retVal = repo_config_addresses_init(&(config->addresses), "/ip4/127.0.0.1/tcp/5001", "/ip4/127.0.0.1/tcp/8080"); + if (retVal == 0) + return 0; - return conf, nil - */ + // swarm addresses + char** address_array = (char * []){ "/ip4/0.0.0.0/tcp/4001", "/ip6/::/tcp/4001" }; + retVal = repo_config_swarm_address_init(&(config->addresses.swarm), address_array, 2); + if (retVal == 0) + return 0; + + config->discovery.mdns.enabled = 1; + config->discovery.mdns.interval = 10; + + config->mounts.ipfs = "/ipfs"; + config->mounts.ipns = "/ipns"; + + config->ipns.resolve_cache_size = 128; + + config->reprovider.interval = "12h"; + + config->gateway.root_redirect = ""; + config->gateway.writable = 0; + + config->gateway.path_prefixes.num_elements = 0; + + // gateway http headers + char** header_array = (char * []) { "Access-Control-Allow-Origin", "Access-Control-Allow-Methods", "Access-Control-Allow-Headers" }; + char** header_values = (char*[]) { "*", "GET", "X-Requested-With" }; + retVal = repo_config_gateway_http_header_init(&(config->gateway.http_headers), header_array, header_values, 3); + if (retVal == 0) + return 0; + + return 1; } diff --git a/repo/config/datastore.c b/repo/config/datastore.c new file mode 100644 index 0000000..a0abe6c --- /dev/null +++ b/repo/config/datastore.c @@ -0,0 +1,41 @@ +// +// datastore.c +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#include +#include + +#include "ipfs/repo/config/datastore.h" +#include "ipfs/os/utils.h" + +/*** + * initialize the structure of the datastore + * @param datastore the struct to initialize + * @returns true(1) on success + */ +int repo_config_datastore_init(struct Datastore* datastore, char* config_root) { + unsigned long stringLength = strlen(config_root) + 12; + datastore->path = malloc(sizeof(char) * stringLength); + os_utils_filepath_join(config_root, "/datastore", datastore->path, stringLength); + datastore->type = "leveldb"; + datastore->storage_max = "10GB"; + datastore->storage_gc_watermark = 90; + datastore->gc_period = "1h"; + datastore->hash_on_read = 0; + datastore->bloom_filter_size = 0; + return 1; +} + +/*** + * deallocate the memory and clear resources from a datastore_init + * @param datastore the struct to deallocate + * @returns true(1) + */ +int repo_config_datastore_free(struct Datastore* datastore) { + //free(datastore); + return 1; +} diff --git a/repo/config/gateway.c b/repo/config/gateway.c new file mode 100644 index 0000000..f316ddc --- /dev/null +++ b/repo/config/gateway.c @@ -0,0 +1,43 @@ +// +// gateway.c +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#include +#include +#include + +#include "ipfs/repo/config/gateway.h" + +char* alloc_and_fill(char* source) { + char* newString = malloc(sizeof(char) * (strlen(source) + 1)); + strncpy(newString, source, strlen(source)); + newString[strlen(source)] = 0; + return newString; +} + +int repo_config_gateway_http_header_init(struct HTTPHeaders* http_headers, char** headers, char** values, int num_elements) { + // allocate memory for array + http_headers->headers = malloc(sizeof(struct HTTPHeader*) * num_elements); + if (http_headers->headers == NULL) { + http_headers->num_elements = 0; + return 0; + } + + // now fill in the array + for(int i = 0; i < num_elements; i++) { + http_headers->headers[i] = malloc(sizeof(struct HTTPHeader)); + if (http_headers->headers[i] == NULL) { + http_headers->num_elements = i; + return 0; + } + http_headers->headers[i]->header = alloc_and_fill(headers[i]); + http_headers->headers[i]->value = alloc_and_fill(values[i]); + } + + http_headers->num_elements = num_elements; + return 1; +} diff --git a/repo/config/identity.c b/repo/config/identity.c index c230c06..fcfe9ff 100644 --- a/repo/config/identity.c +++ b/repo/config/identity.c @@ -84,20 +84,19 @@ exit: */ /*** - * initializes a new Identity (this should be moved to identity.h) + * initializes a new Identity * @param identity the identity to fill * @param num_bits_for_keypair the number of bits for the keypair * @returns true(1) on success, false(0) otherwise */ int repo_config_identity_new(struct Identity* identity, unsigned long num_bits_for_keypair) { - identity = malloc(sizeof(struct Identity)); if (num_bits_for_keypair < 1024) return 0; // generate the private key (& public) - if (!repo_config_identity_generate_keypair(&identity->private_key, num_bits_for_keypair)) + if (!repo_config_identity_generate_keypair( &(identity->private_key), num_bits_for_keypair)) return 0; // TODO: Get ID from public key // TODO: Store peer id in identity struct - return 0; + return 1; } diff --git a/repo/config/swarm.c b/repo/config/swarm.c new file mode 100644 index 0000000..a42ef09 --- /dev/null +++ b/repo/config/swarm.c @@ -0,0 +1,40 @@ +// +// swarm.c +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#include +#include +#include + +#include "ipfs/repo/config/swarm.h" + +int repo_config_swarm_address_init(struct SwarmAddresses* swarm_addresses, char** addresses, int array_length) { + // allocate memory for the addresses array + swarm_addresses->addresses = malloc(sizeof(char*) * array_length); + if (swarm_addresses->addresses == NULL) + return 0; + + // copy in all the strings + for(int i = 0; i < array_length; i++) { + char* newString = malloc(sizeof(char) * (strlen(addresses[i]) + 1)); + if (newString == NULL) + return 0; + strncpy(newString, addresses[i], strlen(addresses[i])); + newString[strlen(addresses[i])] = 0; + swarm_addresses->addresses[i] = newString; + } + + return 1; +} + +int repo_config_swarm_address_free(struct SwarmAddresses* swarm_addresses) { + for (int i = 0; i < swarm_addresses->num_addresses; i++) { + free(swarm_addresses->addresses[i]); + } + free(swarm_addresses->addresses); + return 1; +} diff --git a/test/cmd/ipfs/test_init.h b/test/cmd/ipfs/test_init.h index e96e227..865532c 100644 --- a/test/cmd/ipfs/test_init.h +++ b/test/cmd/ipfs/test_init.h @@ -8,7 +8,7 @@ #include "ipfs/commands/argument.h" #include -#include +//#include int test_get_init_command() { struct Command cmd = { 0 }; diff --git a/test/repo/test_repo.h b/test/repo/test_repo.h deleted file mode 100644 index 60c6db1..0000000 --- a/test/repo/test_repo.h +++ /dev/null @@ -1,13 +0,0 @@ -#ifndef __TEST_REPO_H__ -#define __TEST_REPO_H__ - -#include "ipfs/repo/repo.h" - -#include - -int test_config_repo() { - return 0; -} - -#endif - diff --git a/test/repo/test_repo_bootstrap_peers.h b/test/repo/test_repo_bootstrap_peers.h new file mode 100644 index 0000000..270dea0 --- /dev/null +++ b/test/repo/test_repo_bootstrap_peers.h @@ -0,0 +1,46 @@ +// +// test_repo_bootstrap_peers.h +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#ifndef test_repo_bootstrap_peers_h +#define test_repo_bootstrap_peers_h + +//#include + +#include "ipfs/repo/config/bootstrap_peers.h" + +int test_repo_bootstrap_peers_init() { + + char* default_bootstrap_addresses[] = { + "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ", // mars.i.ipfs.io + "/ip4/104.236.176.52/tcp/4001/ipfs/QmSoLnSGccFuZQJzRadHn95W2CrSFmZuTdDWP8HXaHca9z", // neptune.i.ipfs.io + "/ip4/104.236.179.241/tcp/4001/ipfs/QmSoLPppuBtQSGwKDZT2M73ULpjvfd3aZ6ha4oFGL1KrGM", // pluto.i.ipfs.io + "/ip4/162.243.248.213/tcp/4001/ipfs/QmSoLueR4xBeUbY9WZ9xGUUxunbKWcrNFTDAadQJmocnWm", // uranus.i.ipfs.io + "/ip4/128.199.219.111/tcp/4001/ipfs/QmSoLSafTMBsPKadTEgaXctDQVcqN88CNLHXMkTNwMKPnu", // saturn.i.ipfs.io + "/ip4/104.236.76.40/tcp/4001/ipfs/QmSoLV4Bbm51jM9C4gDYZQ9Cy3U6aXMJDAbzgu2fzaDs64", // venus.i.ipfs.io + "/ip4/178.62.158.247/tcp/4001/ipfs/QmSoLer265NRgSp2LA3dPaeykiS1J6DifTC88f5uVQKNAd", // earth.i.ipfs.io + "/ip4/178.62.61.185/tcp/4001/ipfs/QmSoLMeWqB7YGVLJN3pNLQpmmEk35v6wYtsMGLzSr5QBU3", // mercury.i.ipfs.io + "/ip4/104.236.151.122/tcp/4001/ipfs/QmSoLju6m7xTh3DuokvT3886QRYqxAzb1kShaanJgW36yx", // jupiter.i.ipfs.io + }; + + struct BootstrapPeers list; + int retVal = 1; + repo_config_bootstrap_peers_retrieve(&list); + if ( list.num_peers != 9) { + printf("Size does not equal 9 in test_repo_bootstrap_peers_init"); + retVal = 0; + } + for(int i = 0; i < list.num_peers; i++) { + unsigned long strLen = strlen(default_bootstrap_addresses[i]); + if (strncmp(list.peers[i]->entire_string, default_bootstrap_addresses[i], strLen) != 0) + printf("The value of element %d is: %s\n", i, list.peers[i]->entire_string); + } + repo_config_bootstrap_peers_free(&list); + return retVal; +} + +#endif /* test_repo_bootstrap_peers_h */ diff --git a/test/repo/test_repo_config.h b/test/repo/test_repo_config.h index 005b32c..d33cfff 100644 --- a/test/repo/test_repo_config.h +++ b/test/repo/test_repo_config.h @@ -9,6 +9,29 @@ #ifndef test_repo_config_h #define test_repo_config_h +#include "ipfs/repo/config/config.h" +int test_repo_config_init() { + struct RepoConfig repoConfig; + int retVal = repo_config_init(&repoConfig, 2048, "/Users/JohnJones/.ipfs"); + if (retVal == 0) + return 0; + // now tear it apart to check for anything broken + + // addresses + retVal = strncmp(repoConfig.addresses.api, "/ip4/127.0.0.1/tcp/5001", 23); + if (retVal != 0) + return 0; + retVal = strncmp(repoConfig.addresses.gateway, "/ip4/127.0.0.1/tcp/8080", 23); + if (retVal != 0) + return 0; + + // datastore + retVal = strncmp(repoConfig.datastore.path, "/Users/JohnJones/.ipfs/datastore", 32); + if (retVal != 0) + return 0; + + return 1; +} #endif /* test_repo_config_h */ diff --git a/test/repo/test_repo_identity.h b/test/repo/test_repo_identity.h index 4c81f50..fc528de 100644 --- a/test/repo/test_repo_identity.h +++ b/test/repo/test_repo_identity.h @@ -15,8 +15,15 @@ #include "ipfs/repo/config/base64.h" int test_repo_config_identity_new() { - struct Identity* identity; - return repo_config_identity_new(identity, 2046); + struct Identity identity; + int retVal = repo_config_identity_new(&identity, 2046); + // now examine it + int privateKeySize = sizeof(identity.private_key); + if (privateKeySize != 72) { + printf("Private key structure size should be 72"); + retVal = 0; + } + return retVal; } // test this key @@ -25,9 +32,17 @@ int test_repo_config_identity_private_key() { size_t decoded_len = base64_decode_length(priv_b64, strlen(priv_b64)); char* out_buff = malloc(sizeof(char) * decoded_len); 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++) { - printf("%hhX ", out_buff[i]); + if (out_buff[i] >= 32 && out_buff[i] <= 127) { + str[j] = out_buff[i]; + j++; + } + printf("%hhX-%c ", out_buff[i], out_buff[i]); } + out_buff[j] = 0; + printf("String: %s", str); // now test return 0; diff --git a/test/testit.c b/test/testit.c index 2d9b125..8ae566b 100644 --- a/test/testit.c +++ b/test/testit.c @@ -1,6 +1,7 @@ #include "testit.h" -#include "repo/test_repo.h" +#include "repo/test_repo_config.h" #include "repo/test_repo_identity.h" +#include "repo/test_repo_bootstrap_peers.h" #include "cmd/ipfs/test_init.h" int testit(const char* name, int (*func)(void)) { @@ -14,9 +15,11 @@ int testit(const char* name, int (*func)(void)) { } int main(int argc, char** argv) { - testit("config_repo", test_config_repo); + testit("test_repo_config_init", test_repo_config_init); testit("test_repo_config_identity_new", test_repo_config_identity_new); testit("test_repo_config_identity_private_key", test_repo_config_identity_private_key); + testit("test_reop_bootstrap_peers_init", test_repo_bootstrap_peers_init); testit("get_init_command", test_get_init_command); + return 1; } diff --git a/thirdparty/ipfsaddr/ipfs_addr.c b/thirdparty/ipfsaddr/ipfs_addr.c new file mode 100644 index 0000000..898a2ed --- /dev/null +++ b/thirdparty/ipfsaddr/ipfs_addr.c @@ -0,0 +1,27 @@ +// +// ipfs_addr.c +// c-ipfs +// +// Created by John Jones on 11/2/16. +// Copyright © 2016 JMJAtlanta. All rights reserved. +// + +#include +#include +#include + +#include "ipfs/thirdparty/ipfsaddr/ipfs_addr.h" + +int ipfsaddr_init_new(struct IPFSAddr** addr, char* string) { + (*addr)->entire_string = malloc(sizeof(char) * (strlen(string) + 1)); + if ((*addr)->entire_string == NULL) + return 0; + strncpy((*addr)->entire_string, string, strlen(string)); + return 1; +} + +int ipfsaddr_free(struct IPFSAddr* addr) { + if (addr->entire_string != NULL) + free(addr->entire_string); + return 1; +}