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

More implementation of bitswap

Browse source
This commit is contained in:
John Jones 2017-07-27 12:05:41 -05:00
parent e1135fef3b
commit 73d7d5daed
27 changed files with 193 additions and 87 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
blocks/block.c
View file

@ -65,7 +65,7 @@ int ipfs_blocks_block_protobuf_decode(const unsigned char* buffer, const size_t
unsigned char* temp_buffer = NULL;
size_t temp_size;
*block = ipfs_blocks_block_new();
*block = ipfs_block_new();
if (*block == NULL)
goto exit;
@ -115,7 +115,7 @@ exit:
* @param block a pointer to the struct Block that will be created
* @returns true(1) on success
*/
struct Block* ipfs_blocks_block_new() {
struct Block* ipfs_block_new() {
// allocate memory for structure
struct Block* block = (struct Block*)malloc(sizeof(struct Block));
@ -172,7 +172,7 @@ int ipfs_block_free(struct Block* block) {
* @returns a new Block that is a copy
*/
struct Block* ipfs_block_copy(struct Block* original) {
struct Block* copy = ipfs_blocks_block_new();
struct Block* copy = ipfs_block_new();
copy->data_length = original->data_length;
copy->data = (unsigned char*) malloc(original->data_length);
memcpy(copy->data, original->data, original->data_length);

9
blocks/blockstore.c
View file

@ -113,6 +113,7 @@ char* ipfs_blockstore_path_get(const struct FSRepo* fs_repo, const char* filenam
* @returns true(1) on success
*/
int ipfs_blockstore_get(const struct BlockstoreContext* context, struct Cid* cid, struct Block** block) {
int retVal = 0;
// get datastore key, which is a base32 key of the multihash
unsigned char* key = ipfs_blockstore_hash_to_base32(cid->hash, cid->hash_length);
@ -122,13 +123,19 @@ int ipfs_blockstore_get(const struct BlockstoreContext* context, struct Cid* cid
unsigned char buffer[file_size];
FILE* file = fopen(filename, "rb");
if (file == NULL)
goto exit;
size_t bytes_read = fread(buffer, 1, file_size, file);
fclose(file);
int retVal = ipfs_blocks_block_protobuf_decode(buffer, bytes_read, block);
if (!ipfs_blocks_block_protobuf_decode(buffer, bytes_read, block))
goto exit;
(*block)->cid = ipfs_cid_copy(cid);
retVal = 1;
exit:
free(key);
free(filename);

3
core/daemon.c
View file

@ -19,9 +19,6 @@ int ipfs_daemon_start(char* repo_path) {
struct IpfsNodeListenParams listen_param;
struct MultiAddress* ma = NULL;
// Debugging JMJ
libp2p_logger_add_class("null");
libp2p_logger_info("daemon", "Initializing daemon...\n");
struct IpfsNode* local_node = NULL;

8
core/ipfs_node.c
View file

@ -1,6 +1,7 @@
#include <stdlib.h>
#include "ipfs/core/ipfs_node.h"
#include "ipfs/exchange/bitswap/bitswap.h"
/***
* build an online IpfsNode
@ -21,6 +22,7 @@ int ipfs_node_online_new(const char* repo_path, struct IpfsNode** node) {
local_node->providerstore = NULL;
local_node->repo = NULL;
local_node->routing = NULL;
local_node->exchange = NULL;
// build the struct
if (!ipfs_repo_fsrepo_new(repo_path, NULL, &fs_repo)) {
@ -42,7 +44,8 @@ int ipfs_node_online_new(const char* repo_path, struct IpfsNode** node) {
local_node->providerstore = libp2p_providerstore_new();
local_node->blockstore = ipfs_blockstore_new(fs_repo);
local_node->mode = MODE_OFFLINE;
local_node->routing = ipfs_routing_new_online(local_node, &fs_repo->config->identity->private_key, NULL);
local_node->routing = ipfs_routing_new_online(local_node, &fs_repo->config->identity->private_key);
local_node->exchange = ipfs_bitswap_new(local_node);
return 1;
}
@ -66,6 +69,9 @@ int ipfs_node_free(struct IpfsNode* node) {
if (node->blockstore != NULL) {
ipfs_blockstore_free(node->blockstore);
}
if (node->exchange != NULL) {
node->exchange->Close(node->exchange);
}
free(node);
}
return 1;

3
core/ping.c
View file

@ -22,7 +22,6 @@ int ipfs_ping (int argc, char **argv)
{
int retVal = 0;
struct IpfsNode local_node;
struct Stream* stream = NULL;
struct Libp2pPeer* peer_to_ping = NULL;
char* id = NULL;
struct FSRepo* fs_repo = NULL;
@ -51,7 +50,7 @@ int ipfs_ping (int argc, char **argv)
local_node.identity = fs_repo->config->identity;
local_node.repo = fs_repo;
local_node.mode = MODE_ONLINE;
local_node.routing = ipfs_routing_new_online(&local_node, &fs_repo->config->identity->private_key, stream);
local_node.routing = ipfs_routing_new_online(&local_node, &fs_repo->config->identity->private_key);
local_node.peerstore = libp2p_peerstore_new(local_node.identity->peer_id);
local_node.providerstore = libp2p_providerstore_new();

2
exchange/bitswap/Makefile
View file

@ -7,7 +7,7 @@ endif
LFLAGS =
DEPS =
OBJS = bitswap.o message.o network.o peer_request_queue.o want_manager.o wantlist_queue.o
OBJS = bitswap.o message.o network.o peer_request_queue.o want_manager.o wantlist_queue.o engine.o
%.o: %.c $(DEPS)
$(CC) -c -o $@ $< $(CFLAGS)

17
exchange/bitswap/bitswap.c
View file

@ -14,7 +14,7 @@
* @param sessionContext the context
* @returns an allocated Exchange structure
*/
struct Exchange* ipfs_bitswap_exchange_start(struct IpfsNode* ipfs_node) {
struct Exchange* ipfs_bitswap_new(struct IpfsNode* ipfs_node) {
struct Exchange* exchange = (struct Exchange*) malloc(sizeof(struct Exchange));
if (exchange != NULL) {
struct BitswapContext* bitswapContext = (struct BitswapContext*) malloc(sizeof(struct BitswapContext));
@ -22,15 +22,26 @@ struct Exchange* ipfs_bitswap_exchange_start(struct IpfsNode* ipfs_node) {
free(exchange);
return NULL;
}
exchange->exchangeContext = (void*) bitswapContext;
bitswapContext->bitswap_engine = ipfs_bitswap_engine_new();
if (bitswapContext->bitswap_engine == NULL) {
free(bitswapContext);
free(exchange);
return NULL;
}
bitswapContext->localWantlist = NULL;
bitswapContext->peerRequestQueue = NULL;
bitswapContext->ipfsNode = ipfs_node;
exchange->exchangeContext = (void*) bitswapContext;
exchange->IsOnline = ipfs_bitswap_is_online;
exchange->Close = ipfs_bitswap_close;
exchange->HasBlock = ipfs_bitswap_has_block;
exchange->GetBlock = ipfs_bitswap_get_block;
exchange->GetBlocks = ipfs_bitswap_get_blocks;
// Start the threads for the network
ipfs_bitswap_engine_start(bitswapContext);
}
//TODO: Start the threads for the network
return exchange;
}

65
exchange/bitswap/engine.c
View file

@ -1,35 +1,63 @@
#include <unistd.h>
#include "ipfs/exchange/bitswap/engine.h"
#include "ipfs/exchange/bitswap/wantlist_queue.h"
#include "ipfs/exchange/bitswap/peer_request_queue.h"
/***
* A separate thread that processes the queue
* @param context the context
* Implementation of the bitswap engine
*/
void ipfs_bitswap_engine_wantlist_processor_start(void* ctx) {
struct BitswapContext* context = (struct BitswapContext*)ctx;
// the loop
while (!context->bitswap_engine->shutting_down) {
struct WantListQueueEntry* item = ipfs_bitswap_wantlist_queue_pop(context->localWantlist);
if (item != NULL) {
// if there is something on the queue process it.
ipfs_bitswap__wantlist_process_entry(context, item);
} else {
// if there is nothing on the queue, wait...
sleep(2);
}
/***
* Allocate resources for a BitswapEngine
* @returns a new struct BitswapEngine
*/
struct BitswapEngine* ipfs_bitswap_engine_new() {
struct BitswapEngine* engine = (struct BitswapEngine*) malloc(sizeof(struct BitswapEngine));
if (engine != NULL) {
engine->shutting_down = 0;
}
return engine;
}
/***
* Deallocate resources from struct BitswapEngine
* @param engine the engine to free
* @returns true(1)
*/
int ipfs_bitswap_engine_free(struct BitswapEngine* engine) {
free(engine);
return 1;
}
/***
* A separate thread that processes the queue
* @param context the context
*/
void ipfs_bitswap_engine_peer_request_processor_start(void* ctx) {
void* ipfs_bitswap_engine_wantlist_processor_start(void* ctx) {
struct BitswapContext* context = (struct BitswapContext*)ctx;
// the loop
while (!context->bitswap_engine->shutting_down) {
struct BitswapPeerQueueEntry* item = ipfs_bitswap_peer_request_queue_pop(context->peerRequestQueue);
struct WantListQueueEntry* item = ipfs_bitswap_wantlist_queue_pop(context->localWantlist);
if (item != NULL) {
// if there is something on the queue process it.
ipfs_bitswap_wantlist_process_entry(context, item);
} else {
// if there is nothing on the queue, wait...
sleep(2);
}
}
return NULL;
}
/***
* A separate thread that processes the queue
* @param context the context
*/
void* ipfs_bitswap_engine_peer_request_processor_start(void* ctx) {
struct BitswapContext* context = (struct BitswapContext*)ctx;
// the loop
while (!context->bitswap_engine->shutting_down) {
struct PeerRequest* item = ipfs_bitswap_peer_request_queue_pop(context->peerRequestQueue);
if (item != NULL) {
// if there is something on the queue process it.
ipfs_bitswap_peer_request_process_entry(context, item);
@ -38,6 +66,7 @@ void ipfs_bitswap_engine_peer_request_processor_start(void* ctx) {
sleep(2);
}
}
return NULL;
}
/**
@ -69,8 +98,8 @@ int ipfs_bitswap_engine_start(const struct BitswapContext* context) {
int ipfs_bitswap_engine_stop(const struct BitswapContext* context) {
context->bitswap_engine->shutting_down = 1;
int error1 = pthread_join(context->bitswap_engine->wantlist_processor_thread);
int error2 = pthread_join(context->bitswap_engine->peer_request_processor_thread);
int error1 = pthread_join(context->bitswap_engine->wantlist_processor_thread, NULL);
int error2 = pthread_join(context->bitswap_engine->peer_request_processor_thread, NULL);
return !error1 && !error2;
}

2
exchange/bitswap/message.c
View file

@ -584,7 +584,7 @@ int ipfs_bitswap_message_protobuf_decode(unsigned char* buffer, size_t buffer_le
switch(field_no) {
case (1): {
// a Blocks entry that is just an array of bytes
struct Block* temp = ipfs_blocks_block_new();
struct Block* temp = ipfs_block_new();
if (!protobuf_decode_length_delimited(&buffer[pos], buffer_length - pos, (char**)&temp->data, &temp->data_length, &bytes_read)) {
return 0;
}

14
exchange/bitswap/peer_request_queue.c
View file

@ -132,7 +132,7 @@ struct PeerRequestEntry* ipfs_bitswap_peer_request_queue_find_entry(struct PeerR
* @param queue the queue
* @returns the PeerRequest that should be handled next, or NULL if the queue is empty
*/
struct PeerRequest* ipfs_bitswap_peer_request_pop(struct PeerRequestQueue* queue) {
struct PeerRequest* ipfs_bitswap_peer_request_queue_pop(struct PeerRequestQueue* queue) {
struct PeerRequest* retVal = NULL;
if (queue != NULL) {
pthread_mutex_lock(&queue->queue_mutex);
@ -185,3 +185,15 @@ int ipfs_bitswap_peer_request_queue_fill(struct PeerRequestQueue* queue, struct
// add to the block array
return 0;
}
/****
* Handle a PeerRequest
* @param context the BitswapContext
* @param request the request to process
* @returns true(1) on succes, otherwise false(0)
*/
int ipfs_bitswap_peer_request_process_entry(const struct BitswapContext* context, struct PeerRequest* request) {
//TODO: Implement this method
return 0;
}

20
exchange/bitswap/wantlist_queue.c
View file

@ -120,6 +120,26 @@ struct WantListQueueEntry* ipfs_bitswap_wantlist_queue_find(struct WantListQueue
return NULL;
}
/***
* Pops the top one off the queue
*
* @param wantlist the list
* @returns the WantListQueueEntry
*/
struct WantListQueueEntry* ipfs_bitswap_wantlist_queue_pop(struct WantListQueue* wantlist) {
struct WantListQueueEntry* entry = NULL;
if (wantlist->queue->total == 0)
return entry;
//TODO: This should be a linked list, not an array
pthread_mutex_lock(&wantlist->wantlist_mutex);
entry = (struct WantListQueueEntry*)libp2p_utils_vector_get(wantlist->queue, 0);
libp2p_utils_vector_delete(wantlist->queue, 0);
pthread_mutex_unlock(&wantlist->wantlist_mutex);
return entry;
}
/***
* Initialize a WantListQueueEntry
* @returns a new WantListQueueEntry

2
include/ipfs/blocks/block.h
View file

@ -18,7 +18,7 @@ struct Block {
* Create a new block
* @returns a new allocated Block struct
*/
struct Block* ipfs_blocks_block_new();
struct Block* ipfs_block_new();
int ipfs_blocks_block_add_data(const unsigned char* data, size_t data_size, struct Block* block);

2
include/ipfs/exchange/bitswap/bitswap.h
View file

@ -21,7 +21,7 @@ struct BitswapContext {
* @param ipfsNode the context
* @returns an Exchange struct that refers to the exchange
*/
struct Exchange* ipfs_bitswap_exchange_start(struct IpfsNode* ipfsNode);
struct Exchange* ipfs_bitswap_new(struct IpfsNode* ipfsNode);
/***
* These are the implementation methods for the exchange "Interface"

13
include/ipfs/exchange/bitswap/engine.h
View file

@ -11,6 +11,19 @@ struct BitswapEngine {
pthread_t peer_request_processor_thread;
};
/***
* Allocate resources for a BitswapEngine
* @returns a new struct BitswapEngine
*/
struct BitswapEngine* ipfs_bitswap_engine_new();
/***
* Deallocate resources from struct BitswapEngine
* @param engine the engine to free
* @returns true(1)
*/
int ipfs_bitswap_engine_free(struct BitswapEngine* engine);
/**
* Starts the bitswap engine that processes queue items. There
* should only be one of these per ipfs instance.

9
include/ipfs/exchange/bitswap/peer_request_queue.h
View file

@ -4,6 +4,7 @@
*/
#include <pthread.h>
#include "ipfs/exchange/bitswap/bitswap.h"
#include "ipfs/blocks/block.h"
struct PeerRequest {
@ -103,3 +104,11 @@ struct PeerRequestEntry* ipfs_bitswap_peer_request_entry_new();
* @returns true(1)
*/
int ipfs_bitswap_peer_request_entry_free(struct PeerRequestEntry* entry);
/****
* Handle a PeerRequest
* @param context the BitswapContext
* @param request the request to process
* @returns true(1) on succes, otherwise false(0)
*/
int ipfs_bitswap_peer_request_process_entry(const struct BitswapContext* context, struct PeerRequest* request);

9
include/ipfs/exchange/bitswap/wantlist_queue.h
View file

@ -97,3 +97,12 @@ int ipfs_bitswap_wantlist_session_compare(const struct WantListSession* a, const
* @returns true(1) on success, false(0) if not.
*/
int ipfs_bitswap_wantlist_process_entry(struct BitswapContext* context, struct WantListQueueEntry* entry);
/***
* Pops the top one off the queue
*
* @param wantlist the list
* @returns the WantListQueueEntry
*/
struct WantListQueueEntry* ipfs_bitswap_wantlist_queue_pop(struct WantListQueue* wantlist);

5
include/ipfs/routing/routing.h
View file

@ -12,7 +12,6 @@ struct IpfsRouting {
struct IpfsNode* local_node;
size_t ds_len;
struct RsaPrivateKey* sk;
struct Stream* stream;
/**
* Put a value in the datastore
@ -81,10 +80,10 @@ typedef struct IpfsRouting ipfs_routing;
// offline routing routines.
ipfs_routing* ipfs_routing_new_offline (struct IpfsNode* local_node, struct RsaPrivateKey *private_key);
// online using secio, should probably be deprecated
ipfs_routing* ipfs_routing_new_online (struct IpfsNode* local_node, struct RsaPrivateKey* private_key, struct Stream* stream);
ipfs_routing* ipfs_routing_new_online (struct IpfsNode* local_node, struct RsaPrivateKey* private_key);
int ipfs_routing_online_free(ipfs_routing*);
// online using DHT/kademlia, the recommended router
ipfs_routing* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struct RsaPrivateKey* private_key, struct Stream* stream);
ipfs_routing* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struct RsaPrivateKey* private_key);
// generic routines
int ipfs_routing_generic_put_value (ipfs_routing* offlineRouting, const unsigned char *key, size_t key_size, const void *val, size_t vlen);
int ipfs_routing_generic_get_value (ipfs_routing* offlineRouting, const unsigned char *key, size_t key_size, void **val, size_t *vlen);

3
routing/k_routing.c
View file

@ -148,7 +148,7 @@ int ipfs_routing_kademlia_bootstrap(struct IpfsRouting* routing) {
return 1;
}
struct IpfsRouting* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struct RsaPrivateKey* private_key, struct Stream* stream) {
struct IpfsRouting* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struct RsaPrivateKey* private_key) {
char kademlia_id[21];
// generate kademlia compatible id by getting first 20 chars of peer id
if (local_node->identity->peer_id == NULL || strlen(local_node->identity->peer_id) < 20) {
@ -160,7 +160,6 @@ struct IpfsRouting* ipfs_routing_new_kademlia(struct IpfsNode* local_node, struc
if (routing != NULL) {
routing->local_node = local_node;
routing->sk = private_key;
routing->stream = stream;
routing->PutValue = ipfs_routing_kademlia_put_value;
routing->GetValue = ipfs_routing_kademlia_get_value;
routing->FindProviders = ipfs_routing_kademlia_find_providers;

1
routing/offline.c
View file

@ -103,7 +103,6 @@ struct IpfsRouting* ipfs_routing_new_offline (struct IpfsNode* local_node, struc
if (offlineRouting) {
offlineRouting->local_node = local_node;
offlineRouting->sk = private_key;
offlineRouting->stream = NULL;
offlineRouting->PutValue = ipfs_routing_generic_put_value;
offlineRouting->GetValue = ipfs_routing_generic_get_value;

25
routing/online.c
View file

@ -20,27 +20,24 @@
* @param message what to send
* @returns what was received
*/
struct Libp2pMessage* ipfs_routing_online_send_receive_message(struct Stream* stream, struct Libp2pMessage* message) {
struct Libp2pMessage* ipfs_routing_online_send_receive_message(struct SessionContext* sessionContext, struct Libp2pMessage* message) {
size_t protobuf_size = 0, results_size = 0;
unsigned char* protobuf = NULL, *results = NULL;
struct Libp2pMessage* return_message = NULL;
struct SessionContext session_context;
protobuf_size = libp2p_message_protobuf_encode_size(message);
protobuf = (unsigned char*)malloc(protobuf_size);
libp2p_message_protobuf_encode(message, &protobuf[0], protobuf_size, &protobuf_size);
session_context.default_stream = stream;
session_context.insecure_stream = stream;
// upgrade to kademlia protocol
if (!libp2p_routing_dht_upgrade_stream(&session_context)) {
if (!libp2p_routing_dht_upgrade_stream(sessionContext)) {
goto exit;
}
// send the message, and expect the same back
session_context.default_stream->write(&session_context, protobuf, protobuf_size);
session_context.default_stream->read(&session_context, &results, &results_size, 5);
sessionContext->default_stream->write(sessionContext->default_stream, protobuf, protobuf_size);
sessionContext->default_stream->read(sessionContext->default_stream, &results, &results_size, 5);
// see if we can unprotobuf
if (!libp2p_message_protobuf_decode(results, results_size, &return_message))
@ -79,7 +76,7 @@ int ipfs_routing_online_find_remote_providers(struct IpfsRouting* routing, const
if (peer->connection_type == CONNECTION_TYPE_CONNECTED) {
// Ask for hash, if it has it, break out of the loop and stop looking
libp2p_logger_debug("online", "FindRemoteProviders: Asking for who can provide\n");
struct Libp2pMessage* return_message = ipfs_routing_online_send_receive_message(peer->connection, message);
struct Libp2pMessage* return_message = ipfs_routing_online_send_receive_message(peer->sessionContext, message);
if (return_message != NULL && return_message->provider_peer_head != NULL) {
libp2p_logger_debug("online", "FindRemoteProviders: Return value is not null\n");
found = 1;
@ -160,7 +157,7 @@ int ipfs_routing_online_ask_peer_for_peer(struct Libp2pPeer* whoToAsk, const uns
goto exit;
memcpy(message->key, peer_id, peer_id_size);
return_message = ipfs_routing_online_send_receive_message(whoToAsk->connection, message);
return_message = ipfs_routing_online_send_receive_message(whoToAsk->sessionContext, message);
if (return_message == NULL) {
// some kind of network error
whoToAsk->connection_type = CONNECTION_TYPE_NOT_CONNECTED;
@ -263,7 +260,7 @@ int ipfs_routing_online_provide(struct IpfsRouting* routing, const unsigned char
struct Libp2pPeer* current_peer = current_peer_entry->peer;
if (current_peer->connection_type == CONNECTION_TYPE_CONNECTED) {
// ignoring results is okay this time
struct Libp2pMessage* rslt = ipfs_routing_online_send_receive_message(current_peer->connection, msg);
struct Libp2pMessage* rslt = ipfs_routing_online_send_receive_message(current_peer->sessionContext, msg);
if (rslt != NULL)
libp2p_message_free(rslt);
} else if(current_peer->addr_head == NULL
@ -343,7 +340,7 @@ int ipfs_routing_online_get_peer_value(ipfs_routing* routing, const struct Libp2
msg->message_type = MESSAGE_TYPE_GET_VALUE;
// send message and receive results
struct Libp2pMessage* ret_msg = ipfs_routing_online_send_receive_message(peer->connection, msg);
struct Libp2pMessage* ret_msg = ipfs_routing_online_send_receive_message(peer->sessionContext, msg);
libp2p_message_free(msg);
if (ret_msg == NULL)
@ -486,7 +483,7 @@ int ipfs_routing_online_bootstrap(struct IpfsRouting* routing) {
if (peer == NULL) {
return -1; // this should never happen
}
if (peer->connection == NULL) { // should always be true unless we added it twice (TODO: we should prevent that earlier)
if (peer->sessionContext == NULL) { // should always be true unless we added it twice (TODO: we should prevent that earlier)
libp2p_peer_connect(peer, 5);
}
}
@ -499,16 +496,14 @@ int ipfs_routing_online_bootstrap(struct IpfsRouting* routing) {
* Create a new ipfs_routing struct for online clients
* @param fs_repo the repo
* @param private_key the local private key
* @param stream the stream to put in the struct
* @reurns the ipfs_routing struct that handles messages
*/
ipfs_routing* ipfs_routing_new_online (struct IpfsNode* local_node, struct RsaPrivateKey *private_key, struct Stream* stream) {
ipfs_routing* ipfs_routing_new_online (struct IpfsNode* local_node, struct RsaPrivateKey *private_key) {
ipfs_routing *onlineRouting = malloc (sizeof(ipfs_routing));
if (onlineRouting) {
onlineRouting->local_node = local_node;
onlineRouting->sk = private_key;
onlineRouting->stream = stream;
onlineRouting->PutValue = ipfs_routing_generic_put_value;
onlineRouting->GetValue = ipfs_routing_online_get_value;

44
test/exchange/test_bitswap.h
View file

@ -66,7 +66,7 @@ int test_bitswap_new_free() {
}
// payload
message->payload = libp2p_utils_vector_new(1);
block = ipfs_blocks_block_new();
block = ipfs_block_new();
block->data_length = 25;
libp2p_utils_vector_add(message->payload, block);
block = (struct Block*)libp2p_utils_vector_get(message->payload, 0);
@ -141,7 +141,7 @@ int test_bitswap_retrieve_file()
goto exit;
// fire up the exchange
exchange = ipfs_bitswap_exchange_start(localNode);
exchange = ipfs_bitswap_new(localNode);
// attempt to retrieve the file
if (!exchange->GetBlock(exchange, cid, &block)) {
@ -179,8 +179,8 @@ int test_bitswap_retrieve_file_third_party() {
libp2p_logger_add_class("peerstore");
libp2p_logger_add_class("exporter");
libp2p_logger_add_class("peer");
libp2p_logger_add_class("test_bitswap");
*/
libp2p_logger_add_class("test_bitswap");
// clean out repository
char* ipfs_path = "/tmp/test1";
@ -190,26 +190,27 @@ int test_bitswap_retrieve_file_third_party() {
int thread1_started = 0, thread2_started = 0;
struct MultiAddress* ma_peer1 = NULL;
struct Libp2pVector* ma_vector2 = NULL, *ma_vector3 = NULL;
struct HashtableNode* node = NULL, *result_node = NULL;
struct HashtableNode* node = NULL;
struct Block* result = NULL;
struct Cid* cid = NULL;
// create peer 1
libp2p_logger_debug("test_bitswap", "Firing up daemon 1.\n");
drop_and_build_repository(ipfs_path, 4001, NULL, &peer_id_1);
char multiaddress_string[255];
sprintf(multiaddress_string, "/ip4/127.0.0.1/tcp/4001/ipfs/%s", peer_id_1);
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
// start the daemon in a separate thread
libp2p_logger_debug("test_bitswap", "Firing up daemon 1.\n");
if (pthread_create(&thread1, NULL, test_routing_daemon_start, (void*)ipfs_path) < 0) {
fprintf(stderr, "Unable to start thread 1\n");
libp2p_logger_error("test_bitswap", "Unable to start thread 1\n");
goto exit;
}
thread1_started = 1;
// wait for everything to start up
// JMJ debugging =
sleep(3);
// create peer 2
libp2p_logger_debug("test_routing", "Firing up daemon 2.\n");
ipfs_path = "/tmp/test2";
// create a vector to hold peer1's multiaddress so we can connect as a peer
ma_vector2 = libp2p_utils_vector_new(1);
@ -226,19 +227,16 @@ int test_bitswap_retrieve_file_third_party() {
ipfs_import_file(NULL, "/home/parallels/ipfstest/hello_world.txt", &node, ipfs_node2, &bytes_written, 0);
ipfs_node_free(ipfs_node2);
// start the daemon in a separate thread
libp2p_logger_debug("test_routing", "Firing up daemon 2.\n");
if (pthread_create(&thread2, NULL, test_routing_daemon_start, (void*)ipfs_path) < 0) {
fprintf(stderr, "Unable to start thread 2\n");
libp2p_logger_error("test_bitswap", "Unable to start thread 2\n");
goto exit;
}
thread2_started = 1;
// wait for everything to start up
// JMJ debugging =
sleep(3);
libp2p_logger_debug("test_routing", "Firing up the 3rd client\n");
// create my peer, peer 3
libp2p_logger_debug("test_routing", "Firing up the 3rd client\n");
ipfs_path = "/tmp/test3";
ma_peer1 = multiaddress_new_from_string(multiaddress_string);
ma_vector3 = libp2p_utils_vector_new(1);
@ -249,18 +247,20 @@ int test_bitswap_retrieve_file_third_party() {
ipfs_node3->routing->Bootstrap(ipfs_node3->routing);
if (!ipfs_exporter_get_node(ipfs_node3, node->hash, node->hash_size, &result_node)) {
fprintf(stderr, "Get_Node returned false\n");
// this does the heavy lifting...
cid = ipfs_cid_new(0, node->hash, node->hash_size, CID_PROTOBUF);
if (!ipfs_node3->exchange->GetBlock(ipfs_node3->exchange, cid, &result)) {
libp2p_logger_error("test_bitswap", "GetBlock returned false\n");
goto exit;
}
if (node->hash_size != result_node->hash_size) {
fprintf(stderr, "Node hash sizes do not match. Should be %lu but is %lu\n", node->hash_size, result_node->hash_size);
if (node->hash_size != result->cid->hash_length) {
libp2p_logger_error("test_bitswap", "Node hash sizes do not match. Should be %lu but is %lu\n", node->hash_size, result->cid->hash_length);
goto exit;
}
if (node->data_size != result_node->data_size) {
fprintf(stderr, "Result sizes do not match. Should be %lu but is %lu\n", node->data_size, result_node->data_size);
if (node->data_size != result->data_length) {
libp2p_logger_error("test_bitswap", "Result sizes do not match. Should be %lu but is %lu\n", node->data_size, result->data_length);
goto exit;
}
@ -287,8 +287,10 @@ int test_bitswap_retrieve_file_third_party() {
}
if (node != NULL)
ipfs_hashtable_node_free(node);
if (result_node != NULL)
ipfs_hashtable_node_free(result_node);
if (result != NULL)
ipfs_block_free(result);
if (cid != NULL)
ipfs_cid_free(cid);
return retVal;
}

2
test/repo/test_repo_fsrepo.h
View file

@ -47,7 +47,7 @@ int test_repo_fsrepo_write_read_block() {
}
// create and write the block
block = ipfs_blocks_block_new();
block = ipfs_block_new();
if (block == NULL) {
ipfs_repo_fsrepo_free(fs_repo);
return 0;

4
test/routing/test_routing.h
View file

@ -93,7 +93,7 @@ int test_routing_find_peer() {
local_node.providerstore = NULL;
local_node.repo = fs_repo;
local_node.identity = fs_repo->config->identity;
local_node.routing = ipfs_routing_new_online(&local_node, &fs_repo->config->identity->private_key, NULL);
local_node.routing = ipfs_routing_new_online(&local_node, &fs_repo->config->identity->private_key);
local_node.routing->Bootstrap(local_node.routing);
@ -215,7 +215,7 @@ int test_routing_find_providers() {
local_node.providerstore = libp2p_providerstore_new();
local_node.repo = fs_repo;
local_node.identity = fs_repo->config->identity;
local_node.routing = ipfs_routing_new_online(&local_node, &fs_repo->config->identity->private_key, NULL);
local_node.routing = ipfs_routing_new_online(&local_node, &fs_repo->config->identity->private_key);
local_node.routing->Bootstrap(local_node.routing);

6
test/routing/test_supernode.h
View file

@ -59,7 +59,6 @@ int test_routing_supernode_get_remote_value() {
struct FSRepo* fs_repo = NULL;
struct IpfsNode* ipfs_node = NULL;
struct Libp2pPeer this_peer;
struct Stream* stream = NULL;
const unsigned char* orig_multihash = (unsigned char*)"QmYAXgX8ARiriupMQsbGXtKdDyGzWry1YV3sycKw1qqmgH";
size_t hash_size = 100;
unsigned char hash[hash_size];
@ -97,7 +96,7 @@ int test_routing_supernode_get_remote_value() {
// add bootstrap peer for kademlia
struct MultiAddress* remote = multiaddress_new_from_string("/ip4/127.0.0.1/udp/5001");
libp2p_utils_vector_add(ipfs_node->repo->config->bootstrap_peers, remote);
ipfs_node->routing = ipfs_routing_new_kademlia(ipfs_node, &fs_repo->config->identity->private_key, stream);
ipfs_node->routing = ipfs_routing_new_kademlia(ipfs_node, &fs_repo->config->identity->private_key);
if (ipfs_node->routing == NULL)
@ -159,7 +158,6 @@ 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* fullFileName = "/tmp/temp_file.bin";
@ -194,7 +192,7 @@ int test_routing_supernode_get_value() {
this_peer.addr_head = libp2p_utils_linked_list_new();
this_peer.addr_head->item = multiaddress_new_from_string("/ip4/127.0.0.1/tcp/4001");
libp2p_peerstore_add_peer(ipfs_node->peerstore, &this_peer);
ipfs_node->routing = ipfs_routing_new_kademlia(ipfs_node, &fs_repo->config->identity->private_key, stream);
ipfs_node->routing = ipfs_routing_new_kademlia(ipfs_node, &fs_repo->config->identity->private_key);
if (ipfs_node->routing == NULL)
goto exit;

2
test/storage/test_blocks.h
View file

@ -3,7 +3,7 @@
int test_blocks_new() {
const unsigned char* input = (const unsigned char*)"Hello, World!";
int retVal = 0;
struct Block* block = ipfs_blocks_block_new();
struct Block* block = ipfs_block_new();
if (block == NULL)
return 0;

2
test/storage/test_datastore.h
View file

@ -23,7 +23,7 @@ int test_ipfs_datastore_put() {
return 0;
// build the block
block = ipfs_blocks_block_new();
block = ipfs_block_new();
if (block == NULL)
return 0;

2
test/testit.c
View file

@ -37,6 +37,7 @@ const char* names[] = {
"test_bitswap_new_free",
"test_bitswap_peer_request_queue_new",
"test_bitswap_retrieve_file",
"test_bitswap_retrieve_file_third_party",
"test_cid_new_free",
"test_cid_cast_multihash",
"test_cid_cast_non_multihash",
@ -90,6 +91,7 @@ int (*funcs[])(void) = {
test_bitswap_new_free,
test_bitswap_peer_request_queue_new,
test_bitswap_retrieve_file,
test_bitswap_retrieve_file_third_party,
test_cid_new_free,
test_cid_cast_multihash,
test_cid_cast_non_multihash,