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

Debugging journalio process

Browse source
This commit is contained in:
jmjatlanta 2017-08-30 11:09:28 -05:00
parent ecb9f984ba
commit f0d82129ab
14 changed files with 169 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
include/libp2p/net/multistream.h
View file

@ -40,6 +40,15 @@ int libp2p_net_multistream_write(void* stream_context, const unsigned char* data
*/
struct Stream* libp2p_net_multistream_connect(const char* hostname, int port);
/**
* Connect to a multistream host, and this includes the multistream handshaking.
* @param hostname the host
* @param port the port
* @param timeout_secs number of secs before timeout
* @returns the socket file descriptor of the connection, or -1 on error
*/
struct Stream* libp2p_net_multistream_connect_with_timeout(const char* hostname, int port, int timeout_secs);
/**
* Negotiate the multistream protocol by sending and receiving the protocol id. This is a server side function.
* Servers should send the protocol ID, and then expect it back.
@ -56,7 +65,7 @@ int libp2p_net_multistream_negotiate(struct SessionContext* session);
* @param fd the socket file descriptor
* @returns true(1) on success, false(0) if not
*/
struct Libp2pMessage* libp2p_net_multistream_get_message(struct Stream* stream);
struct KademliaMessage* libp2p_net_multistream_get_message(struct Stream* stream);
struct Stream* libp2p_net_multistream_stream_new(int socket_fd, const char* ip, int port);

1
include/libp2p/net/p2pnet.h
View file

@ -10,6 +10,7 @@ int socket_read_select4(int socket_fd, int num_seconds);
int socket_accept4(int s, uint32_t *ip, uint16_t *port);
int socket_local4(int s, uint32_t *ip, uint16_t *port);
int socket_connect4(int s, uint32_t ip, uint16_t port);
int socket_connect4_with_timeout(int s, uint32_t ip, uint16_t port, int timeout_secs);
int socket_listen(int s, uint32_t *localip, uint16_t *localport);
/***

2
include/libp2p/net/stream.h
View file

@ -22,7 +22,7 @@ struct Stream {
/**
* Writes to a stream
* @param stream the stream context
* @param stream the stream context (usually a SessionContext pointer)
* @param buffer what to write
* @param how much to write
* @returns true(1) on success, false(0) otherwise

12
include/libp2p/peer/peer.h
View file

@ -83,10 +83,18 @@ int libp2p_peer_compare(const struct Libp2pPeer* a, const struct Libp2pPeer* b);
/***
* Determine if the passed in peer and id match
* @param in the peer to check
* @param peer_id peer id, zero terminated string
* @param peer_id peer id
* @param peer_size length of peer_id
* @returns true if peer matches
*/
int libp2p_peer_matches_id(struct Libp2pPeer* in, const unsigned char* peer_id);
int libp2p_peer_matches_id(struct Libp2pPeer* in, const unsigned char* peer_id, int peer_size);
/***
* Convert peer id to null terminated string
* @param in the peer object
* @returns the peer id as a null terminated string
*/
char* libp2p_peer_id_to_string(struct Libp2pPeer* in);
/***
* Determine if we are currently connected to this peer

14
include/libp2p/record/message.h
View file

@ -17,7 +17,7 @@ enum MessageType {
MESSAGE_TYPE_PING = 5
};
struct Libp2pMessage {
struct KademliaMessage {
enum MessageType message_type; // protobuf field 1 (a varint)
char* key; // protobuf field 2
size_t key_size;
@ -31,20 +31,20 @@ struct Libp2pMessage {
* create a new Libp2pMessage struct
* @returns a new Libp2pMessage with default settings
*/
struct Libp2pMessage* libp2p_message_new();
struct KademliaMessage* libp2p_message_new();
/**
* Deallocate memory from a Message struct
* @param in the struct
*/
void libp2p_message_free(struct Libp2pMessage* in);
void libp2p_message_free(struct KademliaMessage* in);
/**
* determine the size necessary for a message struct to be protobuf'd
* @param in the struct to be protobuf'd
* @returns the size required
*/
size_t libp2p_message_protobuf_encode_size(const struct Libp2pMessage* in);
size_t libp2p_message_protobuf_encode_size(const struct KademliaMessage* in);
/**
* Encode a Message into a protobuf
@ -54,7 +54,7 @@ size_t libp2p_message_protobuf_encode_size(const struct Libp2pMessage* in);
* @param bytes_written will hold the number of bytes written to buffer
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_message_protobuf_encode(const struct Libp2pMessage* in, unsigned char* buffer, size_t max_buffer_size, size_t* bytes_written);
int libp2p_message_protobuf_encode(const struct KademliaMessage* in, unsigned char* buffer, size_t max_buffer_size, size_t* bytes_written);
/**
* Convert a Libp2pMessage into protobuf format,
@ -64,7 +64,7 @@ int libp2p_message_protobuf_encode(const struct Libp2pMessage* in, unsigned char
* @param buffer_size the size written into buffer
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_message_protobuf_allocate_and_encode(const struct Libp2pMessage* in, unsigned char **buffer, size_t* buffer_size);
int libp2p_message_protobuf_allocate_and_encode(const struct KademliaMessage* in, unsigned char **buffer, size_t* buffer_size);
/**
* turn a protobuf back into a message
@ -73,5 +73,5 @@ int libp2p_message_protobuf_allocate_and_encode(const struct Libp2pMessage* in,
* @param out the message
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_message_protobuf_decode(unsigned char* buffer, size_t buffer_size, struct Libp2pMessage** out);
int libp2p_message_protobuf_decode(unsigned char* buffer, size_t buffer_size, struct KademliaMessage** out);

15
net/multistream.c
View file

@ -226,6 +226,17 @@ int libp2p_net_multistream_read(void* stream_context, unsigned char** results, s
* @returns the socket file descriptor of the connection, or -1 on error
*/
struct Stream* libp2p_net_multistream_connect(const char* hostname, int port) {
return libp2p_net_multistream_connect_with_timeout(hostname, port, multistream_default_timeout);
}
/**
* Connect to a multistream host, and this includes the multistream handshaking.
* @param hostname the host
* @param port the port
* @param timeout_secs number of secs before timeout
* @returns the socket file descriptor of the connection, or -1 on error
*/
struct Stream* libp2p_net_multistream_connect_with_timeout(const char* hostname, int port, int timeout_secs) {
int retVal = -1, return_result = -1, socket = -1;
unsigned char* results = NULL;
size_t results_size;
@ -236,7 +247,7 @@ struct Stream* libp2p_net_multistream_connect(const char* hostname, int port) {
socket = socket_open4();
// connect
if (socket_connect4(socket, ip, port) != 0)
if (socket_connect4_with_timeout(socket, ip, port, timeout_secs) != 0)
goto exit;
// send the multistream handshake
@ -252,7 +263,7 @@ struct Stream* libp2p_net_multistream_connect(const char* hostname, int port) {
session.default_stream = stream;
// try to receive the protocol id
return_result = libp2p_net_multistream_read(&session, &results, &results_size, multistream_default_timeout);
return_result = libp2p_net_multistream_read(&session, &results, &results_size, timeout_secs);
if (return_result == 0 || results_size < 1)
goto exit;

7
net/protocol.c
View file

@ -1,4 +1,5 @@
#include <stdlib.h>
#include <string.h>
#include "libp2p/utils/logger.h"
#include "libp2p/net/protocol.h"
@ -30,8 +31,12 @@ const struct Libp2pProtocolHandler* protocol_compare(const unsigned char* incomi
int libp2p_protocol_marshal(const unsigned char* incoming, size_t incoming_size, struct SessionContext* session, struct Libp2pVector* handlers) {
const struct Libp2pProtocolHandler* handler = protocol_compare(incoming, incoming_size, handlers);
if (handler == NULL) {
libp2p_logger_error("protocol", "Unable to find handler.\n");
char str[incoming_size + 1];
memcpy(str, incoming, incoming_size);
str[incoming_size] = 0;
libp2p_logger_error("protocol", "Unable to find handler for %s.\n", str);
return -1;
}
//TODO: strip off the protocol?
return handler->HandleMessage(incoming, incoming_size, session, handler->context);
}

70
net/socket.c
View file

@ -8,7 +8,9 @@
#include <netdb.h>
#include <arpa/inet.h>
#include <errno.h>
#include <fcntl.h>
#include "libp2p/utils/logger.h"
#include "libp2p/net/p2pnet.h"
/**
@ -103,16 +105,80 @@ int socket_local4(int s, uint32_t *ip, uint16_t *port)
* @param port the port number
* @return 0 on success, otherwise -1
*/
int socket_connect4(int s, uint32_t ip, uint16_t port)
int socket_connect4(int s, uint32_t ip, uint16_t port) {
return socket_connect4_with_timeout(s, ip, port, 10);
}
/***
* start a client connection.
* @param s the socket number
* @param ip the ip address
* @param port the port number
* @param timeout_secs the number of seconds before timeout
* @return 0 on success, otherwise -1
*/
int socket_connect4_with_timeout(int s, uint32_t ip, uint16_t port, int timeout_secs)
{
struct sockaddr_in sa;
//long args; // fctl args with O_NONBLOCK
//long orig_args; // fctl args;
memset(&sa, 0, sizeof sa);
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
sa.sin_addr.s_addr = ip;
return connect(s, (struct sockaddr *) &sa, sizeof sa);
/*
// set to non blocking
orig_args = fcntl(s, F_GETFL, NULL);
if (orig_args < 0) {
// unable to get flags
libp2p_logger_error("socket", "Unable to get socket flags on connect.\n");
return -1;
}
args = orig_args;
args |= O_NONBLOCK;
if (args != orig_args) {
libp2p_logger_debug("socket", "Setting socket to non-blocking on connect.\n");
if (fcntl(s, F_SETFL, args) < 0) {
// unable to set flags
return -1;
}
} else {
libp2p_logger_debug("socket", "Socket already non-blocking during connect.\n");
}
*/
// connect
int retVal = connect(s, (struct sockaddr *) &sa, sizeof sa);
if (retVal == -1 && errno == EINPROGRESS) {
libp2p_logger_debug("socket", "Socket connect unsuccessful. Waiting to try again.\n");
// wait for timeout
sleep(timeout_secs);
retVal = connect(s, (struct sockaddr *) &sa, sizeof sa);
if (retVal == -1 && errno == EALREADY) {
libp2p_logger_debug("socket", "Socket connect completed.\n");
retVal = 0;
} else {
libp2p_logger_debug("socket", "Socket connect worked on second try.\n");
}
} else {
if (retVal == -1) {
libp2p_logger_debug("socket", "Socket connect failed with error %d.\n", errno);
}
}
/*
if ( retVal == 0 && args != orig_args) {
// set back to blocking
libp2p_logger_debug("socket", "Setting socket back to blocking.\n");
args = fcntl(s, F_GETFL, NULL);
args &= (~O_NONBLOCK);
fcntl(s, F_SETFL, args);
}
*/
return retVal;
}
/**

35
peer/peer.c
View file

@ -35,9 +35,9 @@ struct Libp2pPeer* libp2p_peer_new_from_multiaddress(const struct MultiAddress*
struct Libp2pPeer* out = libp2p_peer_new();
char* id = multiaddress_get_peer_id(in);
if (id != NULL) {
out->id_size = strlen(id) + 1;
out->id_size = strlen(id);
out->id = malloc(out->id_size);
strcpy(out->id, id);
memcpy(out->id, id, out->id_size);
free(id);
}
out->addr_head = libp2p_utils_linked_list_new();
@ -52,9 +52,9 @@ struct Libp2pPeer* libp2p_peer_new_from_multiaddress(const struct MultiAddress*
void libp2p_peer_free(struct Libp2pPeer* in) {
if (in != NULL) {
if (in->addr_head != NULL && in->addr_head->item != NULL) {
libp2p_logger_debug("peer", "Freeing peer %s\n", ((struct MultiAddress*)in->addr_head->item)->string);
//libp2p_logger_debug("peer", "Freeing peer %s\n", ((struct MultiAddress*)in->addr_head->item)->string);
} else {
libp2p_logger_debug("peer", "Freeing peer with no multiaddress.\n");
//libp2p_logger_debug("peer", "Freeing peer with no multiaddress.\n");
}
if (in->id != NULL)
free(in->id);
@ -97,6 +97,7 @@ int libp2p_peer_handle_connection_error(struct Libp2pPeer* peer) {
* @returns true(1) on success, false(0) if we could not connect
*/
int libp2p_peer_connect(struct RsaPrivateKey* privateKey, struct Libp2pPeer* peer, struct Peerstore* peerstore, int timeout) {
libp2p_logger_debug("peer", "Attemping to connect to %s.\n", libp2p_peer_id_to_string(peer));
time_t now, prev = time(NULL);
// find an appropriate address
struct Libp2pLinkedList* current_address = peer->addr_head;
@ -108,8 +109,9 @@ int libp2p_peer_connect(struct RsaPrivateKey* privateKey, struct Libp2pPeer* pee
continue;
int port = multiaddress_get_ip_port(ma);
peer->sessionContext = libp2p_session_context_new();
peer->sessionContext->insecure_stream = libp2p_net_multistream_connect(ip, port);
peer->sessionContext->insecure_stream = libp2p_net_multistream_connect_with_timeout(ip, port, timeout);
if (peer->sessionContext->insecure_stream == NULL) {
libp2p_logger_debug("peer", "Unable to connect to IP %s and port %d for peer %s.\n", ip, port, libp2p_peer_id_to_string(peer));
free(ip);
return 0;
}
@ -118,6 +120,7 @@ int libp2p_peer_connect(struct RsaPrivateKey* privateKey, struct Libp2pPeer* pee
peer->connection_type = CONNECTION_TYPE_CONNECTED;
}
if (libp2p_secio_initiate_handshake(peer->sessionContext, privateKey, peerstore) <= 0) {
libp2p_logger_error("peer", "Attempted secio handshake, but failed for peer %s.\n", libp2p_peer_id_to_string(peer));
free(ip);
return 0;
}
@ -127,7 +130,11 @@ int libp2p_peer_connect(struct RsaPrivateKey* privateKey, struct Libp2pPeer* pee
if (now >= (prev + timeout))
break;
} // trying to connect
return peer->connection_type == CONNECTION_TYPE_CONNECTED;
int retVal = peer->connection_type == CONNECTION_TYPE_CONNECTED;
if (!retVal) {
libp2p_logger_debug("peer", "Attempted connect to %s but failed.\n", libp2p_peer_id_to_string(peer));
}
return retVal;
}
/**
@ -176,14 +183,26 @@ struct Libp2pPeer* libp2p_peer_copy(const struct Libp2pPeer* in) {
* @param peer_id peer id, zero terminated string
* @returns true if peer matches
*/
int libp2p_peer_matches_id(struct Libp2pPeer* in, const unsigned char* peer_id) {
if (strlen((char*)peer_id) == in->id_size) {
int libp2p_peer_matches_id(struct Libp2pPeer* in, const unsigned char* peer_id, int peer_size) {
if (peer_size == in->id_size) {
if (strncmp(in->id, (char*)peer_id, in->id_size) == 0)
return 1;
}
return 0;
}
static char string_retval[100];
/***
* Convert peer id to null terminated string
* @param in the peer object
* @returns the peer id as a null terminated string
*/
char* libp2p_peer_id_to_string(struct Libp2pPeer* in) {
memcpy(string_retval, in->id, in->id_size);
string_retval[in->id_size] = 0;
return string_retval;
}
/***
* Determine if we are currently connected to this peer
* @param in the peer to check

16
record/message.c
View file

@ -16,8 +16,8 @@
* Allocate memory for a message
* @returns a new, allocated Libp2pMessage struct
*/
struct Libp2pMessage* libp2p_message_new() {
struct Libp2pMessage* out = (struct Libp2pMessage*)malloc(sizeof(struct Libp2pMessage));
struct KademliaMessage* libp2p_message_new() {
struct KademliaMessage* out = (struct KademliaMessage*)malloc(sizeof(struct KademliaMessage));
if (out != NULL) {
out->closer_peer_head = NULL;
out->cluster_level_raw = 0;
@ -34,7 +34,7 @@ struct Libp2pMessage* libp2p_message_new() {
* Frees all resources related to a Libp2pMessage
* @param in the incoming message
*/
void libp2p_message_free(struct Libp2pMessage* in) {
void libp2p_message_free(struct KademliaMessage* in) {
if (in != NULL) {
// a linked list of peer structs
struct Libp2pLinkedList* current = in->closer_peer_head;
@ -63,7 +63,7 @@ void libp2p_message_free(struct Libp2pMessage* in) {
}
}
size_t libp2p_message_protobuf_encode_size(const struct Libp2pMessage* in) {
size_t libp2p_message_protobuf_encode_size(const struct KademliaMessage* in) {
// message type
size_t retVal = 11;
// clusterlevelraw
@ -95,7 +95,7 @@ size_t libp2p_message_protobuf_encode_size(const struct Libp2pMessage* in) {
* @param buffer_size the size of the buffer
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_message_protobuf_allocate_and_encode(const struct Libp2pMessage* in, unsigned char **buffer, size_t *buffer_size) {
int libp2p_message_protobuf_allocate_and_encode(const struct KademliaMessage* in, unsigned char **buffer, size_t *buffer_size) {
*buffer_size = libp2p_message_protobuf_encode_size(in);
*buffer = malloc(*buffer_size);
if (*buffer == NULL) {
@ -111,7 +111,7 @@ int libp2p_message_protobuf_allocate_and_encode(const struct Libp2pMessage* in,
return retVal;
}
int libp2p_message_protobuf_encode(const struct Libp2pMessage* in, unsigned char* buffer, size_t max_buffer_size, size_t* bytes_written) {
int libp2p_message_protobuf_encode(const struct KademliaMessage* in, unsigned char* buffer, size_t max_buffer_size, size_t* bytes_written) {
// data & data_size
size_t bytes_used = 0;
*bytes_written = 0;
@ -190,7 +190,7 @@ int libp2p_message_protobuf_encode(const struct Libp2pMessage* in, unsigned char
return 1;
}
int libp2p_message_protobuf_decode(unsigned char* in, size_t in_size, struct Libp2pMessage** out) {
int libp2p_message_protobuf_decode(unsigned char* in, size_t in_size, struct KademliaMessage** out) {
size_t pos = 0;
int retVal = 0;
size_t buffer_size = 0;
@ -201,7 +201,7 @@ int libp2p_message_protobuf_decode(unsigned char* in, size_t in_size, struct Lib
struct Libp2pLinkedList* current_item = NULL;
struct Libp2pLinkedList* last_closer = NULL;
struct Libp2pLinkedList* last_provider = NULL;
struct Libp2pMessage* ptr = NULL;
struct KademliaMessage* ptr = NULL;
if ( (*out = libp2p_message_new()) == NULL)
goto exit;

4
record/message_handler.c
View file

@ -6,11 +6,11 @@
*/
int libp2p_record_handler_ping(struct Libp2pPeer* peer, struct Libp2pMessage* message) {
int libp2p_record_handler_ping(struct Libp2pPeer* peer, struct KademliaMessage* message) {
return 0;
}
int libp2p_record_message_handle(struct Libp2pPeer* peer, struct Libp2pMessage* message) {
int libp2p_record_message_handle(struct Libp2pPeer* peer, struct KademliaMessage* message) {
switch (message->message_type) {
case (MESSAGE_TYPE_PING):
return libp2p_record_handler_ping(peer, message);

16
routing/dht_protocol.c
View file

@ -61,7 +61,7 @@ struct Libp2pProtocolHandler* libp2p_routing_dht_build_protocol_handler(struct P
* @param buffer_size the size of the results
* @returns true(1) on success, false(0) otherwise
*/
int libp2p_routing_dht_protobuf_message(struct Libp2pMessage* message, unsigned char** buffer, size_t *buffer_size) {
int libp2p_routing_dht_protobuf_message(struct KademliaMessage* message, unsigned char** buffer, size_t *buffer_size) {
*buffer_size = libp2p_message_protobuf_encode_size(message);
*buffer = malloc(*buffer_size);
if (!libp2p_message_protobuf_encode(message, *buffer, *buffer_size, buffer_size)) {
@ -124,7 +124,7 @@ int libp2p_routing_dht_handshake(struct SessionContext* context) {
* @param buffer_size the length of the results
* @returns true(1) on success, false(0) otherwise
*/
int libp2p_routing_dht_handle_ping(struct Libp2pMessage* message, unsigned char** buffer, size_t *buffer_size) {
int libp2p_routing_dht_handle_ping(struct KademliaMessage* message, unsigned char** buffer, size_t *buffer_size) {
// just turn message back into a protobuf and send it back...
return libp2p_routing_dht_protobuf_message(message, buffer, buffer_size);
}
@ -137,7 +137,7 @@ int libp2p_routing_dht_handle_ping(struct Libp2pMessage* message, unsigned char*
* @param providerstore the list of peers that can provide things
* @returns true(1) on success, false(0) otherwise
*/
int libp2p_routing_dht_handle_get_providers(struct SessionContext* session, struct Libp2pMessage* message, struct Peerstore* peerstore,
int libp2p_routing_dht_handle_get_providers(struct SessionContext* session, struct KademliaMessage* message, struct Peerstore* peerstore,
struct ProviderStore* providerstore, unsigned char** results, size_t* results_size) {
unsigned char* peer_id = NULL;
int peer_id_size = 0;
@ -228,7 +228,7 @@ struct MultiAddress* libp2p_routing_dht_find_peer_ip_multiaddress(struct Libp2pL
* @param result_buffer_size the size of the result buffer
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_routing_dht_handle_add_provider(struct SessionContext* session, struct Libp2pMessage* message,
int libp2p_routing_dht_handle_add_provider(struct SessionContext* session, struct KademliaMessage* message,
struct Peerstore* peerstore, struct ProviderStore* providerstore, unsigned char** result_buffer, size_t* result_buffer_size) {
int retVal = 0;
struct Libp2pPeer *peer = NULL;
@ -315,7 +315,7 @@ int libp2p_routing_dht_handle_add_provider(struct SessionContext* session, struc
* @param result_buffer_size the size of the results
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_routing_dht_handle_get_value(struct SessionContext* session, struct Libp2pMessage* message,
int libp2p_routing_dht_handle_get_value(struct SessionContext* session, struct KademliaMessage* message,
struct Peerstore* peerstore, struct ProviderStore* providerstore, unsigned char** result_buffer, size_t *result_buffer_size) {
struct Datastore* datastore = session->datastore;
@ -359,7 +359,7 @@ int libp2p_routing_dht_handle_get_value(struct SessionContext* session, struct L
* @param result_buffer_size the size of the results
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_routing_dht_handle_put_value(struct SessionContext* session, struct Libp2pMessage* message,
int libp2p_routing_dht_handle_put_value(struct SessionContext* session, struct KademliaMessage* message,
struct Peerstore* peerstore, struct ProviderStore* providerstore, unsigned char** result_buffer, size_t *result_buffer_size) {
//TODO: implement this
return 0;
@ -375,7 +375,7 @@ int libp2p_routing_dht_handle_put_value(struct SessionContext* session, struct L
* @param result_buffer_size the size of the results
* @returns true(1) on success, otherwise false(0)
*/
int libp2p_routing_dht_handle_find_node(struct SessionContext* session, struct Libp2pMessage* message,
int libp2p_routing_dht_handle_find_node(struct SessionContext* session, struct KademliaMessage* message,
struct Peerstore* peerstore, struct ProviderStore* providerstore, unsigned char** result_buffer, size_t *result_buffer_size) {
// look through peer store
struct Libp2pPeer* peer = libp2p_peerstore_get_peer(peerstore, (unsigned char*)message->key, message->key_size);
@ -402,7 +402,7 @@ int libp2p_routing_dht_handle_message(struct SessionContext* session, struct Pee
unsigned char* buffer = NULL, *result_buffer = NULL;
size_t buffer_size = 0, result_buffer_size = 0;
int retVal = 0;
struct Libp2pMessage* message = NULL;
struct KademliaMessage* message = NULL;
// read from stream
if (!session->default_stream->read(session, &buffer, &buffer_size, 5))

9
secio/secio.c
View file

@ -580,6 +580,7 @@ int libp2p_secio_unencrypted_read(struct SessionContext* session, unsigned char*
read_this_time = 0;
if ( (errno == EAGAIN) || (errno == EWOULDBLOCK)) {
// TODO: use epoll or select to wait for socket to be writable
libp2p_logger_debug("secio", "Attempted read, but got EAGAIN or EWOULDBLOCK. Code %d.\n", errno);
return 0;
} else {
libp2p_logger_error("secio", "Error in libp2p_secio_unencrypted_read: %s\n", strerror(errno));
@ -587,16 +588,17 @@ int libp2p_secio_unencrypted_read(struct SessionContext* session, unsigned char*
}
}
if (read == 0 && size[0] == 10) {
// a spurious \n
// write over this value by not adding it
libp2p_logger_error("secio", "Spurrious newline found.\n");
} else {
left = left - read_this_time;
read += read_this_time;
}
} while (left > 0);
buffer_size = ntohl(buffer_size);
if (buffer_size == 0)
if (buffer_size == 0) {
libp2p_logger_error("secio", "unencrypted read buffer size is 0.\n");
return 0;
}
// now read the number of bytes we've found, minus the 4 that we just read
left = buffer_size;
@ -611,6 +613,7 @@ int libp2p_secio_unencrypted_read(struct SessionContext* session, unsigned char*
if ( (errno == EAGAIN) || (errno == EWOULDBLOCK)) {
// TODO: use epoll or select to wait for socket to be writable
} else {
libp2p_logger_error("secio", "read from socket returned %d.\n", errno);
return 0;
}
}

4
test/test_record.h
View file

@ -208,8 +208,8 @@ int test_record_peer_protobuf() {
int test_record_message_protobuf() {
int retVal = 0;
struct Libp2pPeer* closer_peer = NULL;
struct Libp2pMessage* message = NULL;
struct Libp2pMessage* result = NULL;
struct KademliaMessage* message = NULL;
struct KademliaMessage* result = NULL;
struct MultiAddress *ma_result = NULL;
char* buffer = NULL;
size_t buffer_len = 0;