agorise
/
c-ipfs
1
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

refactoring + beginning of file transfer 

Now attempting to use kademlia to find a hash, and NodeIO to transfer
the file
yamux
John Jones 2017-03-19 07:47:19 -05:00
parent 93c4988f90
commit e8b8d06f24
20 changed files with 357 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
core/null.c
View File

@ -32,7 +32,7 @@ void *ipfs_null_connection (void *ptr)
// TODO: multistream + secio + message.
// TODO: when should we exit the for loop and disconnect?
struct SecureSession secure_session;
struct SessionContext secure_session;
secure_session.insecure_stream = libp2p_net_multistream_stream_new(connection_param->socket);
secure_session.default_stream = secure_session.insecure_stream;

2
core/ping.c
View File

@ -18,7 +18,7 @@ int ipfs_ping (int argc, char **argv)
size_t results_size = 0;
int port = 0;
char* ip = NULL;
struct SecureSession session;
struct SessionContext session;
// read the configuration
struct FSRepo* fs_repo;

4
importer/importer.c
View File

@ -178,6 +178,10 @@ int ipfs_import_print_node_results(const struct Node* node, const char* file_nam
/**
* Creates a node based on an incoming file or directory
* NOTE: this can be called recursively for directories
* NOTE: When this function completes, parent_node will be either:
* 1) the complete file, in the case of a small file (<256k-ish)
* 2) a node with links to the various pieces of a large file
* 3) a node with links to files and directories if 'fileName' is a directory
* @param root_dir the directory for where to look for the file
* @param file_name the file (or directory) to import
* @param parent_node the root node (has links to others in case this is a large file and is split)

48
include/ipfs/core/daemon.h
View File

@ -1,30 +1,32 @@
#ifndef DAEMON_H
#define DAEMON_H
#include <stdint.h>
#define DAEMON_H
#define MAX 5
#define CONNECTIONS 50
#include <stdint.h>
struct null_connection_params {
int socket;
int *count;
struct IpfsNode* local_node;
};
#define MAX 5
#define CONNECTIONS 50
struct null_listen_params {
uint32_t ipv4;
uint16_t port;
};
struct null_connection_params {
int socket;
int *count;
struct IpfsNode* local_node;
};
struct IpfsNodeListenParams {
uint32_t ipv4;
uint16_t port;
struct IpfsNode* local_node;
};
struct null_listen_params {
uint32_t ipv4;
uint16_t port;
};
struct IpfsNodeListenParams {
uint32_t ipv4;
uint16_t port;
struct IpfsNode* local_node;
};
void *ipfs_null_connection (void *ptr);
void *ipfs_null_listen (void *ptr);
int ipfs_daemon (int argc, char **argv);
int ipfs_daemon_start(char* repo_path);
int ipfs_ping (int argc, char **argv);
void *ipfs_null_connection (void *ptr);
void *ipfs_null_listen (void *ptr);
int ipfs_daemon (int argc, char **argv);
int ipfs_daemon_start(char* repo_path);
int ipfs_ping (int argc, char **argv);
#endif // DAEMON_H

21
include/ipfs/importer/importer.h
View File

@ -5,16 +5,21 @@
#include "ipfs/repo/fsrepo/fs_repo.h"
/**
* Creates a node based on an incoming file
* @param root the root directory
* @param file_name the file to import (could contain a directory)
* @param node the root node (could have links to others)
* @param fs_repo the repo to use
* @param bytes_written the number of bytes written to disk
* @param recursive true(1) if you want to include files and directories
* Creates a node based on an incoming file or directory
* NOTE: this can be called recursively for directories
* NOTE: When this function completes, parent_node will be either:
* 1) the complete file, in the case of a small file (<256k-ish)
* 2) a node with links to the various pieces of a large file
* 3) a node with links to files and directories if 'fileName' is a directory
* @param root_dir the directory for where to look for the file
* @param file_name the file (or directory) to import
* @param parent_node the root node (has links to others in case this is a large file and is split)
* @param fs_repo the ipfs repository
* @param bytes_written number of bytes written to disk
* @param recursive true if we should navigate directories
* @returns true(1) on success
*/
int ipfs_import_file(const char* root, const char* fileName, struct Node** node, struct FSRepo* fs_repo, size_t* bytes_written, int recursive);
int ipfs_import_file(const char* root, const char* fileName, struct Node** parent_node, struct FSRepo* fs_repo, size_t* bytes_written, int recursive);
/**
* called from the command line

1
include/ipfs/merkledag/node.h
View File

@ -30,6 +30,7 @@ struct Node
struct NodeLink* head_link;
// not saved in protobuf
unsigned char* encoded;
// a base32 representation of the multihash
unsigned char* hash;
size_t hash_size;
};

3
include/ipfs/repo/config/addresses.h
View File

@ -1,10 +1,11 @@
#ifndef addresses_h
#define addresses_h
#include "libp2p/utils/linked_list.h"
#include "swarm.h"
struct Addresses {
struct SwarmAddresses* swarm;
struct Libp2pLinkedList* swarm_head;
char* api;
char* gateway;
};

33
include/ipfs/routing/routing.h
View File

@ -34,17 +34,42 @@ struct s_ipfs_routing {
int (*GetValue) (struct s_ipfs_routing*, char*, size_t, void**, size_t*);
/**
* Find a provider
* @param 1 the context
* @param 2 the information that is being looked for
* @param 3 the size of param 2
* @param 4 the information found
* @param 5 the size of the information found
*/
int (*FindProviders) (struct s_ipfs_routing*, char*, size_t, void*, size_t*);
/**
* Find a peer
* @param 1 the context
* @param 2 the peer to look for
* @param 3 the size of the peer char array
* @param 4 the results
* @param 5 the size of the results
*/
int (*FindPeer) (struct s_ipfs_routing*, char*, size_t, void*, size_t*);
int (*Provide) (struct s_ipfs_routing*, char*);
/**
* Ping this instance
* Announce to the network that this host can provide this key
* @param 1 the context
* @param 2 the key
* @param 3 the key size
* @returns true(1) on success, otherwise false(0)
*/
int (*Provide) (struct s_ipfs_routing*, char*, size_t);
/**
* Ping
* @param routing the context
* @param message the message
* @returns true(1) on success, otherwise false(0)
*/
int (*Ping) (struct s_ipfs_routing*, struct Libp2pMessage*);
/**
* Get everything going
* @param routing the context
* @returns true(1) on success, otherwise false(0)
*/
int (*Ping) (struct s_ipfs_routing*, struct Libp2pMessage* message);
int (*Bootstrap) (struct s_ipfs_routing*);
};
typedef struct s_ipfs_routing ipfs_routing;
@ -59,3 +84,5 @@ ipfs_routing* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struct RsaP
int ipfs_routing_generic_put_value (ipfs_routing* offlineRouting, char *key, size_t key_size, void *val, size_t vlen);
int ipfs_routing_generic_get_value (ipfs_routing* offlineRouting, char *key, size_t key_size, void **val, size_t *vlen);
// supernode
int ipfs_routing_supernode_parse_provider(const unsigned char* in, struct Libp2pLinkedList** multiaddresses);

15
repo/config/addresses.c
View File

@ -17,15 +17,18 @@ int repo_config_addresses_new(struct Addresses** addresses, char* api, char* gat
if (*addresses == NULL)
return 0;
struct Addresses* addr = *addresses;
// 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)
addr->api = alloc_and_copy(api);
addr->gateway = alloc_and_copy(gateway);
if ( addr->api == NULL || addr->gateway == NULL)
return 0;
// allocate memory for swarm_addresses
if (repo_config_swarm_address_new(&((*addresses)->swarm)) == 0)
return 0;
//if (repo_config_swarm_address_new(&((*addresses)->swarm)) == 0)
// return 0;
// this is now allocated when it is filled
addr->swarm_head = NULL;
return 1;
}
@ -33,7 +36,7 @@ int repo_config_addresses_new(struct Addresses** addresses, char* api, char* gat
int repo_config_addresses_free(struct Addresses* addresses) {
free(addresses->api);
free(addresses->gateway);
repo_config_swarm_address_free(addresses->swarm);
libp2p_utils_linked_list_free(addresses->swarm_head);
free(addresses);
return 1;
}

13
repo/config/config.c
View File

@ -2,6 +2,7 @@
#include <stdlib.h>
#include <string.h>
#include "libp2p/utils/linked_list.h"
#include "ipfs/repo/config/config.h"
#include "ipfs/os/utils.h"
#include "ipfs/repo/config/bootstrap_peers.h"
@ -96,10 +97,14 @@ int ipfs_repo_config_init(struct RepoConfig* config, unsigned int num_bits_for_k
return 0;
// 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;
const char* addr1 = "/ip4/0.0.0.0/tcp/4001";
const char* addr2 = "/ip6/::/tcp/4001";
config->addresses->swarm_head = libp2p_utils_linked_list_new();
config->addresses->swarm_head->item = malloc(strlen(addr1) + 1);
strcpy(config->addresses->swarm_head->item, addr1);
config->addresses->swarm_head->next = libp2p_utils_linked_list_new();
config->addresses->swarm_head->next->item = malloc(strlen(addr2) + 1);
strcpy(config->addresses->swarm_head->next->item, addr2);
config->discovery.mdns.enabled = 1;
config->discovery.mdns.interval = 10;

69
repo/fsrepo/fs_repo.c
View File

@ -67,12 +67,14 @@ int repo_config_write_config_file(char* full_filename, struct RepoConfig* config
fprintf(out_file, " \"BloomFilterSize\": %d\n", config->datastore->bloom_filter_size);
fprintf(out_file, " },\n \"Addresses\": {\n");
fprintf(out_file, " \"Swarm\": [\n");
for(int i = 0; i < config->addresses->swarm->num_addresses; i++) {
fprintf(out_file, " \"%s\"", config->addresses->swarm->addresses[i]);
if (i != (config->addresses->swarm->num_addresses - 1))
fprintf(out_file, ",\n");
else
struct Libp2pLinkedList* current = config->addresses->swarm_head;
while (current != NULL) {
fprintf(out_file, " \"%s\"", (char*)current->item);
if (current->next == NULL)
fprintf(out_file, "\n");
else
fprintf(out_file, ",\n");
current = current->next;
}
fprintf(out_file, " ],\n");
fprintf(out_file, " \"API\": \"%s\",\n", config->addresses->api);
@ -285,28 +287,41 @@ int _find_token(const char* data, const jsmntok_t* tokens, int tok_length, int s
* @param tokens the array of tokens
* @param tok_length the number of tokens
* @param search_from start search from this token onward
* @param tag what to search for
* @param tag what to search for (NOTE: If null, read from search_from)
* @param result where to put the result. NOTE: allocates memory that must be freed
* @returns true(1) on success
*/
int _get_json_string_value(char* data, const jsmntok_t* tokens, int tok_length, int search_from, const char* tag, char** result) {
int pos = _find_token(data, tokens, tok_length, search_from, tag);
if (pos < 0)
int pos = 0;
jsmntok_t* curr_token = NULL;
if (tag == NULL) {
pos = search_from;
if (pos >= 0)
curr_token = (jsmntok_t*)&tokens[pos];
}
else {
pos = _find_token(data, tokens, tok_length, search_from, tag);
if (pos >= 0)
curr_token = (jsmntok_t*)&tokens[pos + 1];
}
if (curr_token == NULL)
return 0;
jsmntok_t curr_token = tokens[pos+1];
if (curr_token.type == JSMN_PRIMITIVE) {
if (curr_token->type == JSMN_PRIMITIVE) {
// a null
*result = NULL;
}
if (curr_token.type != JSMN_STRING)
if (curr_token->type != JSMN_STRING)
return 0;
// allocate memory
int str_len = curr_token.end - curr_token.start;
int str_len = curr_token->end - curr_token->start;
*result = malloc(sizeof(char) * str_len + 1);
if (*result == NULL)
return 0;
// copy in the string
strncpy(*result, &data[curr_token.start], str_len);
strncpy(*result, &data[curr_token->start], str_len);
(*result)[str_len] = 0;
return 1;
}
@ -400,6 +415,34 @@ int fs_repo_open_config(struct FSRepo* repo) {
_get_json_int_value(data, tokens, num_tokens, curr_pos, "HashOnRead", &repo->config->datastore->hash_on_read);
_get_json_int_value(data, tokens, num_tokens, curr_pos, "BloomFilterSize", &repo->config->datastore->bloom_filter_size);
// get addresses. First is Swarm array, then Api, then Gateway
curr_pos = _find_token(data, tokens, num_tokens, curr_pos, "Addresses");
if (curr_pos < 0) {
free(data);
return 0;
}
// get swarm addresses
int swarm_pos = _find_token(data, tokens, num_tokens, curr_pos, "Swarm") + 1;
if (tokens[swarm_pos].type != JSMN_ARRAY)
return 0;
int swarm_size = tokens[swarm_pos].size;
swarm_pos++;
repo->config->addresses->swarm_head = NULL;
struct Libp2pLinkedList* last = NULL;
for(int i = 0; i < swarm_size; i++) {
struct Libp2pLinkedList* current = libp2p_utils_linked_list_new();
if (!_get_json_string_value(data, tokens, num_tokens, swarm_pos + i, NULL, (char**)&current->item))
break;
if (repo->config->addresses->swarm_head == NULL) {
repo->config->addresses->swarm_head = current;
} else {
last->next = current;
}
last = current;
}
_get_json_string_value(data, tokens, num_tokens, curr_pos, "API", &repo->config->addresses->api);
_get_json_string_value(data, tokens, num_tokens, curr_pos, "Gateway", &repo->config->addresses->gateway);
// free the memory used reading the json file
free(data);
free(priv_key_base64);

25
routing/k_routing.c
View File

@ -3,6 +3,8 @@
/**
* Routing using Kademlia and DHT
*
* The go version has "supernode" which is similar to this:
*/
/**
@ -32,8 +34,17 @@ int ipfs_routing_kademlia_get_value(struct s_ipfs_routing* routing, char* key, s
/**
* Find a provider
* @param routing the context
* @param key the key to what we're looking for
* @param key_size the size of the key
* @param results the results
* @param results_size the size of the results buffer
* @returns true(1) on success, otherwise false(0)
*/
int ipfs_routing_kademlia_find_providers(struct s_ipfs_routing* routing, char* param1, size_t param2, void* param3, size_t* param4) {
int ipfs_routing_kademlia_find_providers(struct s_ipfs_routing* routing, char* key, size_t key_size, void* results, size_t* results_size) {
// see if I can provide it
// add my multiaddress if I can
// get a list of providers that are closer
return 0;
}
@ -43,7 +54,7 @@ int ipfs_routing_kademlia_find_providers(struct s_ipfs_routing* routing, char* p
int ipfs_routing_kademlia_find_peer(struct s_ipfs_routing* routing, char* param1, size_t param2, void* param3, size_t* param4) {
return 0;
}
int ipfs_routing_kademlia_provide(struct s_ipfs_routing* routing, char* param1) {
int ipfs_routing_kademlia_provide(struct s_ipfs_routing* routing, char* param1, size_t param2) {
return 0;
}
@ -61,6 +72,12 @@ int ipfs_routing_kademlia_bootstrap(struct s_ipfs_routing* routing) {
}
struct s_ipfs_routing* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struct RsaPrivateKey* private_key, struct Stream* stream) {
char* kademlia_id = NULL;
// generate kademlia compatible id by getting last 20 chars of peer id
if (local_node->identity->peer_id == NULL || strlen(local_node->identity->peer_id) < 20) {
return NULL;
}
kademlia_id = &local_node->identity->peer_id[strlen(local_node->identity->peer_id)-20];
struct s_ipfs_routing* routing = (struct s_ipfs_routing*)malloc(sizeof(struct s_ipfs_routing));
if (routing != NULL) {
routing->local_node = local_node;
@ -79,8 +96,8 @@ struct s_ipfs_routing* ipfs_routing_new_kademlia(struct IpfsNode* local_node, st
if (multiaddress_is_ip(address)) {
int port = multiaddress_get_ip_port(address);
int family = multiaddress_get_ip_family(address);
start_kademlia(port, family, local_node->identity->peer_id, 10);
start_kademlia(port, family, kademlia_id, 10);
}
local_node->routing = routing;
return routing;
}

2
routing/offline.c
View File

@ -64,7 +64,7 @@ int ipfs_routing_offline_find_peer (ipfs_routing* offlineRouting, char *peer_id,
return ErrOffline;
}
int ipfs_routing_offline_provide (ipfs_routing* offlineRouting, char *cid)
int ipfs_routing_offline_provide (ipfs_routing* offlineRouting, char *cid, size_t cid_size)
{
return ErrOffline;
}

9
routing/online.c
View File

@ -14,7 +14,14 @@ int ipfs_routing_online_find_providers(struct s_ipfs_routing* routing, char* val
int ipfs_routing_online_find_peer(struct s_ipfs_routing* routing, char* val1, size_t val2, void* val3, size_t* val4) {
return 0;
}
int ipfs_routing_online_provide(struct s_ipfs_routing* routing, char* val1) {
/**
* Notify the network that this host can provide this key
* @param routing information about this host
* @param val1 the key (hash) of the data
* @returns true(1) on success, otherwise false
*/
int ipfs_routing_online_provide(struct s_ipfs_routing* routing, char* val1, size_t val2) {
return 0;
}
int ipfs_routing_online_ping(struct s_ipfs_routing* routing, struct Libp2pMessage* message) {

22
test/node/test_importer.h
View File

@ -1,5 +1,6 @@
#include <stdio.h>
#include "../test_helper.h"
#include "ipfs/importer/importer.h"
#include "ipfs/importer/exporter.h"
#include "ipfs/merkledag/merkledag.h"
@ -7,27 +8,6 @@
#include "mh/multihash.h"
#include "libp2p/crypto/encoding/base58.h"
/***
* Helper to create a test file in the OS
*/
int create_file(const char* fileName, unsigned char* bytes, size_t num_bytes) {
FILE* file = fopen(fileName, "wb");
fwrite(bytes, num_bytes, 1, file);
fclose(file);
return 1;
}
int create_bytes(unsigned char* buffer, size_t num_bytes) {
int counter = 0;
for(int i = 0; i < num_bytes; i++) {
buffer[i] = counter++;
if (counter > 15)
counter = 0;
}
return 1;
}
int test_import_large_file() {
size_t bytes_size = 1000000; //1mb
unsigned char file_bytes[bytes_size];

6
test/repo/test_repo_config.h
View File

@ -38,14 +38,14 @@ int test_repo_config_init() {
if (retVal != 0)
return 0;
if (repoConfig->addresses->swarm->num_addresses != 2)
if (repoConfig->addresses->swarm_head == NULL || repoConfig->addresses->swarm_head->next == NULL || repoConfig->addresses->swarm_head->next->next != NULL)
return 0;
retVal = strncmp(repoConfig->addresses->swarm->addresses[0], "/ip4/0.0.0.0/tcp/4001", 21);
retVal = strcmp((char*)repoConfig->addresses->swarm_head->item, "/ip4/0.0.0.0/tcp/4001");
if (retVal != 0)
return 0;
retVal = strncmp(repoConfig->addresses->swarm->addresses[1], "/ip6/::/tcp/4001", 16);
retVal = strcmp((char*)repoConfig->addresses->swarm_head->next->item, "/ip6/::/tcp/4001");
if (retVal != 0)
return 0;

129
test/routing/test_supernode.h Normal file
View File

@ -0,0 +1,129 @@
#include <stdlib.h>
#include "../test_helper.h"
#include "ipfs/routing/routing.h"
#include "ipfs/repo/fsrepo/fs_repo.h"
void stop_kademlia(void);
int test_routing_supernode_start() {
int retVal = 0;
struct FSRepo* fs_repo = NULL;
struct IpfsNode* ipfs_node = NULL;
struct Stream* stream = NULL;
if (!drop_build_and_open_repo("/tmp/.ipfs", &fs_repo))
goto exit;
ipfs_node = (struct IpfsNode*)malloc(sizeof(struct IpfsNode));
ipfs_node->mode = MODE_ONLINE;
ipfs_node->identity = fs_repo->config->identity;
ipfs_node->repo = fs_repo;
ipfs_node->routing = ipfs_routing_new_kademlia(ipfs_node, &fs_repo->config->identity->private_key, stream);
if (ipfs_node->routing == NULL)
goto exit;
//TODO ping kademlia
retVal = 1;
exit:
if (ipfs_node->routing != NULL)
stop_kademlia();
return retVal;
}
int test_routing_supernode_get_value() {
int retVal = 0;
struct FSRepo* fs_repo = NULL;
struct IpfsNode* ipfs_node = NULL;
struct Stream* stream = NULL;
int file_size = 1000;
unsigned char bytes[file_size];
char* fileName = "temp_file.bin";
char* fullFileName = "/tmp/temp_file.bin";
struct Node* write_node = NULL;
size_t bytes_written = 0;
unsigned char base58Hash[100];
size_t results_size = 2048;
char results_buffer[results_size];
if (!drop_build_and_open_repo("/tmp/.ipfs", &fs_repo))
goto exit;
ipfs_node = (struct IpfsNode*)malloc(sizeof(struct IpfsNode));
ipfs_node->mode = MODE_ONLINE;
ipfs_node->identity = fs_repo->config->identity;
ipfs_node->repo = fs_repo;
ipfs_node->routing = ipfs_routing_new_kademlia(ipfs_node, &fs_repo->config->identity->private_key, stream);
if (ipfs_node->routing == NULL)
goto exit;
// create a file
create_bytes(&bytes[0], file_size);
create_file(fullFileName, bytes, file_size);
// write to ipfs
if (ipfs_import_file("/tmp", fileName, &write_node, fs_repo, &bytes_written, 1) == 0) {
goto exit;
}
if (!ipfs_node->routing->Provide(ipfs_node->routing, (char*)write_node->data, write_node->data_size))
goto exit;
// write_node->hash has the base32 key of the file. Convert this to a base58.
if (!ipfs_cid_hash_to_base58(write_node->hash, write_node->hash_size, base58Hash, 100))
goto exit;
// ask the network who can provide this
if (!ipfs_node->routing->FindProviders(ipfs_node->routing, (char*)base58Hash, 100, &results_buffer[0], &results_size))
goto exit;
// Q: What should FindProviders have in the results buffer? A: A struct of:
// 20 byte id
// 4 byte (or 16 byte for ip6) ip address
// 2 byte port number
// that means we have to attempt a connection and ask for peer ID
// TODO: Q: How do we determine ip4 vs ip6?
struct Libp2pLinkedList* multiaddress_head;
// get an IP4 ip and port
if (!ipfs_routing_supernode_parse_provider(&results_buffer, &multiaddress_head))
goto exit;
struct Libp2pLinkedList* current_address = multiaddress_head;
struct MultiAddress* addr = NULL;
while (current_address != NULL) {
addr = (struct Multiaddress*)current_address->item;
if (multiaddress_is_ip4(addr))
break;
addr = NULL;
current_address = current_address->next;
}
if (addr == NULL)
goto exit;
// Connect to server
char* ip;
multiaddress_get_ip_address(addr, &ip);
struct Stream* file_stream = libp2p_net_multistream_connect(ip, multiaddress_get_ip_port(addr));
// Switch from multistream to NodeIO
if (!libp2p_net_multistream_upgrade(file_stream, "/NodeIO/1.0.0"))
goto exit;
// Ask for file
struct Node* node = libp2p_nodeio_get(file_stream, base58Hash, 100);
if (node == NULL)
goto exit;
retVal = 1;
exit:
if (ipfs_node->routing != NULL)
stop_kademlia();
if (fs_repo != NULL)
ipfs_repo_fsrepo_free(fs_repo);
return retVal;
}

25
test/test_helper.c
View File

@ -6,6 +6,31 @@
#include "ipfs/repo/fsrepo/fs_repo.h"
#include "ipfs/os/utils.h"
/***
* Helper to create a test file in the OS
*/
int create_file(const char* fileName, unsigned char* bytes, size_t num_bytes) {
FILE* file = fopen(fileName, "wb");
fwrite(bytes, num_bytes, 1, file);
fclose(file);
return 1;
}
/***
* Create a buffer with some data
*/
int create_bytes(unsigned char* buffer, size_t num_bytes) {
int counter = 0;
for(int i = 0; i < num_bytes; i++) {
buffer[i] = counter++;
if (counter > 15)
counter = 0;
}
return 1;
}
int remove_directory(const char *path)
{
DIR *d = opendir(path);

15
test/test_helper.h
View File

@ -9,3 +9,18 @@
int drop_and_build_repository(const char* dir);
int drop_build_and_open_repo(const char* path, struct FSRepo** fs_repo);
/***
* Helper to create a test file in the OS
* @pram fileName the resultant file name
* @param bytes the data that goes in the file
* @param num_bytes the size of the buffer
*/
int create_file(const char* fileName, unsigned char* bytes, size_t num_bytes);
/***
* Create a buffer with some bytes
* @param buffer where to put the bytes
* @param num_bytes how much to fill of the buffer
*/
int create_bytes(unsigned char* buffer, size_t num_bytes);

3
test/testit.c
View File

@ -9,6 +9,7 @@
#include "repo/test_repo_config.h"
#include "repo/test_repo_fsrepo.h"
#include "repo/test_repo_identity.h"
#include "routing/test_supernode.h"
#include "storage/test_ds_helper.h"
#include "storage/test_datastore.h"
#include "storage/test_blocks.h"
@ -36,6 +37,7 @@ const char* names[] = {
"test_repo_config_identity_new",
"test_repo_config_identity_private_key",
"test_repo_fsrepo_write_read_block",
"test_routing_supernode_start",
"test_get_init_command",
"test_import_small_file",
"test_import_large_file",
@ -72,6 +74,7 @@ int (*funcs[])(void) = {
test_repo_config_identity_new,
test_repo_config_identity_private_key,
test_repo_fsrepo_write_read_block,
test_routing_supernode_start,
test_get_init_command,
test_import_small_file,
test_import_large_file,