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

More dialer changes, starting to implement default dialer

Browse source
This commit is contained in:
John Jones 2017-02-15 12:04:10 -05:00
parent 5c08094548
commit ccc7ca3e8b
9 changed files with 113 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
conn/Makefile
View file

@ -2,7 +2,7 @@ CC = gcc
CFLAGS = -O0 -I../include -I../../c-protobuf -I../../c-multihash/include -I../../c-multiaddr/include -g3
LFLAGS =
DEPS =
OBJS = dialer.o transport_dialer.o connection.o
OBJS = dialer.o transport_dialer.o connection.o tcp_transport_dialer.o
%.o: %.c $(DEPS)
$(CC) -c -o $@ $< $(CFLAGS)

2
conn/connection.c
View file

@ -16,7 +16,7 @@ struct Connection* libp2p_conn_connection_new(struct TransportDialer* transport_
void libp2p_conn_connection_free(struct Connection* connection) {
if (connection != NULL) {
fclose(connection->socket_handle);
//close(connection->socket_handle);
free(connection);
}
}

11
conn/dialer.c
View file

@ -9,10 +9,13 @@
#include "libp2p/crypto/key.h"
#include "libp2p/utils/linked_list.h"
struct TransportDialer* libp2p_conn_tcp_transport_dialer_new();
/**
* Create a Dialer with the specified local information
*/
struct Dialer* libp2p_conn_dialer_new(char* peer_id, struct PrivateKey* private_key) {
int success = 0;
struct Dialer* dialer = (struct Dialer*)malloc(sizeof(struct Dialer));
if (dialer != NULL) {
dialer->peer_id = malloc(strlen(peer_id) + 1);
@ -21,8 +24,9 @@ struct Dialer* libp2p_conn_dialer_new(char* peer_id, struct PrivateKey* private_
dialer->private_key = (struct PrivateKey*)malloc(sizeof(struct PrivateKey));
if (dialer->private_key != NULL) {
libp2p_crypto_private_key_copy(private_key, dialer->private_key);
dialer->fallback_dialer = NULL;
//TODO: build transport dialers
dialer->transport_dialers = NULL;
dialer->fallback_dialer = libp2p_conn_tcp_transport_dialer_new(peer_id, private_key);
return dialer;
}
}
@ -32,7 +36,9 @@ struct Dialer* libp2p_conn_dialer_new(char* peer_id, struct PrivateKey* private_
}
/**
* free resources from the Dialer
* Free resources from the Dialer
* NOTE: this frees the fallback dialer too (should we be doing this?
* @param in the Dialer struct to free
*/
void libp2p_conn_dialer_free(struct Dialer* in) {
if (in != NULL) {
@ -47,6 +53,7 @@ void libp2p_conn_dialer_free(struct Dialer* in) {
}
if (in->fallback_dialer != NULL)
libp2p_conn_transport_dialer_free((struct TransportDialer*)in->fallback_dialer);
free(in);
}
return;
}

66
conn/tcp_transport_dialer.c Normal file
View file

@ -0,0 +1,66 @@
#include <stdlib.h>
#include <netdb.h>
#include <arpa/inet.h>
#include "multiaddr/multiaddr.h"
#include "libp2p/net/p2pnet.h"
#include "libp2p/conn/connection.h"
#include "libp2p/conn/transport_dialer.h"
/**
* An implementation of a tcp transport dialer
*/
struct TcpIp {
char* ip;
int port;
};
struct TcpIp* libp2p_conn_parse_ip_multiaddress(struct MultiAddress* addr) {
struct TcpIp* out = (struct TcpIp*)malloc(sizeof(struct TcpIp));
char* address = malloc(strlen(addr->string) + 1);
strcpy(address, addr->string);
char* tok = strtok(address, "/");
int pos = 0;
while (tok != NULL) {
switch (pos) {
case 2: {
out->ip = malloc(strlen(tok) + 1);
strcpy(out->ip, tok);
break;
}
case 4: {
out->port = strtol(tok, NULL, 10);
break;
}
}
tok = strtok(NULL, "/");
pos++;
}
//TODO: do a better job of parsing the results
return out;
}
int libp2p_conn_tcp_can_handle(struct MultiAddress* addr) {
return 1;
}
struct Connection* libp2p_conn_tcp_dial(struct TransportDialer* transport_dialer, struct MultiAddress* addr) {
struct Connection* conn = (struct Connection*) malloc(sizeof(struct Connection*));
conn->socket_handle = socket_open4();
struct TcpIp* results = libp2p_conn_parse_ip_multiaddress(addr);
struct hostent* host = gethostbyname(results->ip);
struct in_addr** addr_list = (struct in_addr**)host->h_addr_list;
socket_connect4(conn->socket_handle, (*addr_list[0]).s_addr, results->port);
return conn;
}
struct TransportDialer* libp2p_conn_tcp_transport_dialer_new(char* peer_id, struct PrivateKey* private_key) {
struct TransportDialer* out = libp2p_conn_transport_dialer_new(peer_id, private_key);
out->can_handle = libp2p_conn_tcp_can_handle;
out->dial = libp2p_conn_tcp_dial;
return out;
}

38
conn/transport_dialer.c
View file

@ -1,19 +1,15 @@
#include <stdlib.h>
#include "libp2p/crypto/key.h"
#include "libp2p/conn/transport_dialer.h"
struct TransportDialer* libp2p_conn_transport_dialer_new(struct MultiAddress* multiaddr) {
struct TransportDialer* libp2p_conn_transport_dialer_new(char* peer_id, struct PrivateKey* private_key) {
struct TransportDialer* out = (struct TransportDialer*)malloc(sizeof(struct TransportDialer));
if (out != NULL) {
out->multiaddr = (struct MultiAddress*)malloc(sizeof(struct MultiAddress));
if (out->multiaddr == NULL) {
libp2p_conn_transport_dialer_free(out);
return NULL;
}
if (multiaddress_copy(multiaddr, out->multiaddr) == 0) {
libp2p_conn_transport_dialer_free(out);
return NULL;
}
out->peer_id = malloc(strlen(peer_id) + 1);
strcpy(out->peer_id, peer_id);
out->private_key = (struct PrivateKey*)malloc(sizeof(struct PrivateKey));
libp2p_crypto_private_key_copy(private_key, out->private_key);
}
return out;
}
@ -23,7 +19,12 @@ struct TransportDialer* libp2p_conn_transport_dialer_new(struct MultiAddress* mu
* @param in the struct to be freed
*/
void libp2p_conn_transport_dialer_free(struct TransportDialer* in) {
free(in);
if (in != NULL) {
if (in->peer_id != NULL)
free(in->peer_id);
libp2p_crypto_private_key_free(in->private_key);
free(in);
}
}
/**
@ -33,6 +34,19 @@ void libp2p_conn_transport_dialer_free(struct TransportDialer* in) {
* @returns a connection, or NULL if no appropriate dialer was found
*/
struct Connection* libp2p_conn_transport_dialer_get(struct Libp2pLinkedList* transport_dialers, struct MultiAddress* multiaddr) {
//TODO: implement this method
struct Libp2pLinkedList* current = transport_dialers;
struct TransportDialer* t_dialer = NULL;
while (current != NULL) {
t_dialer = (struct TransportDialer*)current->item;
if (t_dialer->can_handle(multiaddr))
break;
current = current->next;
t_dialer = NULL;
}
if (t_dialer != NULL) {
return t_dialer->dial(t_dialer, multiaddr);
}
return NULL;
}

2
include/libp2p/conn/connection.h
View file

@ -8,7 +8,7 @@
#include "multiaddr/multiaddr.h"
struct Connection {
FILE* socket_handle;
int socket_handle;
/**
* Read from the stream
* @param socket_handle the socket to read from

7
include/libp2p/conn/transport_dialer.h
View file

@ -4,10 +4,13 @@
#include "libp2p/utils/linked_list.h"
struct TransportDialer {
struct MultiAddress* multiaddr;
char* peer_id;
struct PrivateKey* private_key;
int (*can_handle)(struct MultiAddress* multiaddr);
struct Connection* (*dial)(struct TransportDialer* transport_dialer, struct MultiAddress* multiaddr);
};
struct TransportDialer* libp2p_conn_transport_dialer_new(struct MultiAddress* multiaddr);
struct TransportDialer* libp2p_conn_transport_dialer_new(char* peer_id, struct PrivateKey* private_key);
void libp2p_conn_transport_dialer_free(struct TransportDialer* in);
struct Connection* libp2p_conn_transport_dialer_get(struct Libp2pLinkedList* transport_dialers, struct MultiAddress* multiaddr);

3
test/test_conn.h
View file

@ -16,7 +16,7 @@ int test_dialer_new() {
int test_dialer_dial() {
int retVal = 0;
char* config_dir = "/home/parallels/.ipfs/config";
char* destination_string = "/ip/192.210.179.217/tcp/4001";
char* destination_string = "/ip4/192.210.179.217/tcp/4001/";
char* peer_id = NULL;
struct PrivateKey* private_key = NULL;
struct Dialer* dialer = NULL;
@ -56,6 +56,7 @@ int test_dialer_dial() {
exit:
if (result != NULL)
free(result);
free(peer_id);
multiaddress_free(destination_address);
libp2p_conn_dialer_free(dialer);
libp2p_crypto_private_key_free(private_key);

2
test/test_helper.h
View file

@ -39,6 +39,8 @@ struct PrivateKey* base64ToPrivateKey(char* base64) {
libp2p_crypto_private_key_free(out);
out = NULL;
}
if (decode_base64 != NULL)
free(decode_base64);
return out;
}