From c137aa04fe1d17919cdd089fecc4b06e46fd6480 Mon Sep 17 00:00:00 2001 From: Jose Marcial Vieira Bisneto Date: Thu, 9 Nov 2017 22:54:19 -0300 Subject: [PATCH 1/3] Added missing prototype. --- include/libp2p/identify/identify.h | 1 + 1 file changed, 1 insertion(+) diff --git a/include/libp2p/identify/identify.h b/include/libp2p/identify/identify.h index b2bec1a..2502c45 100644 --- a/include/libp2p/identify/identify.h +++ b/include/libp2p/identify/identify.h @@ -31,6 +31,7 @@ struct IdentifyContext { int libp2p_identify_can_handle(const struct StreamMessage* msg); int libp2p_identify_send_protocol(struct Stream* stream); int libp2p_identify_receive_protocol(struct Stream* stream); +int libp2p_identify_handle_message(const struct StreamMessage* msg, struct Stream* stream, void* protocol_context); int libp2p_identify_shutdown(void* protocol_context); struct Libp2pProtocolHandler* libp2p_identify_build_protocol_handler(struct Libp2pVector* handlers); From 5291cb7a9ac0ee77dc507ca467e70037badfc570 Mon Sep 17 00:00:00 2001 From: Jose Marcial Vieira Bisneto Date: Thu, 9 Nov 2017 22:57:11 -0300 Subject: [PATCH 2/3] Implemented allocation and release of identify structure. --- identify/identify.c | 48 ++++++++++++++++++++++++++++++ include/libp2p/identify/identify.h | 5 ++++ 2 files changed, 53 insertions(+) diff --git a/identify/identify.c b/identify/identify.c index 3eafbd8..92f255c 100644 --- a/identify/identify.c +++ b/identify/identify.c @@ -73,6 +73,54 @@ int libp2p_identify_receive_protocol(struct Stream* stream) { return 1; } +/** + * Create a Identify struct + * @returns the newly allocated record struct + */ +Identify* libp2p_identify_new() { + Identify* out = (Identify*)malloc(sizeof(Identify)); + if (out != NULL) { + out->PublicKey = NULL; + out->ListenAddrs = NULL; + out->Protocols = NULL; + out->ObservedAddr = NULL; + out->ProtocolVersion = IDENTIFY_PROTOCOL_VERSION; + out->AgentVersion = IDENTIFY_AGENT_VERSION; + out->XXX_unrecognized = NULL; + } + return out; +} + +/** + * Free the resources from a identify struct + * @param in the struct to free + */ +void libp2p_identify_free(Identify* in) { + int i; + + if (in != NULL) { + if (in->PublicKey != NULL) + free(in->PublicKey); + if (in->ListenAddrs != NULL) { + // free every item + for (i = 0 ; in->ListenAddrs[i] ; i++) + free(in->ListenAddrs[i]); + // free array + free(in->ListenAddrs); + } + if (in->Protocols != NULL) { + for (i = 0 ; in->Protocols[i] ; i++) + free(in->Protocols[i]); + free(in->Protocols); + } + if (in->ObservedAddr != NULL) + free(in->ObservedAddr); + if (in->XXX_unrecognized != NULL) + free(in->XXX_unrecognized); + free(in); + } +} + /** * A remote node is attempting to send us an Identify message * @param msg the message sent diff --git a/include/libp2p/identify/identify.h b/include/libp2p/identify/identify.h index 2502c45..29c2486 100644 --- a/include/libp2p/identify/identify.h +++ b/include/libp2p/identify/identify.h @@ -2,6 +2,9 @@ #include "libp2p/utils/vector.h" +#define IDENTIFY_PROTOCOL_VERSION "ipfs/0.1.0" +#define IDENTIFY_AGENT_VERSION "c-ipfs/1.0" + typedef struct { // publicKey is this node's public key (which also gives its node.ID) // - may not need to be sent, as secure channel implies it has been sent. @@ -31,6 +34,8 @@ struct IdentifyContext { int libp2p_identify_can_handle(const struct StreamMessage* msg); int libp2p_identify_send_protocol(struct Stream* stream); int libp2p_identify_receive_protocol(struct Stream* stream); +Identify* libp2p_identify_new(); +void libp2p_identify_free(Identify* in); int libp2p_identify_handle_message(const struct StreamMessage* msg, struct Stream* stream, void* protocol_context); int libp2p_identify_shutdown(void* protocol_context); struct Libp2pProtocolHandler* libp2p_identify_build_protocol_handler(struct Libp2pVector* handlers); From 3972574148a8cea62ee48b12d819cd4083ff0fc2 Mon Sep 17 00:00:00 2001 From: Jose Marcial Vieira Bisneto Date: Thu, 9 Nov 2017 23:06:43 -0300 Subject: [PATCH 3/3] Implemented of protobuf encoding for identify protocol. --- identify/identify.c | 176 +++++++++++++++++++++++++++++ include/libp2p/identify/identify.h | 4 + 2 files changed, 180 insertions(+) diff --git a/identify/identify.c b/identify/identify.c index 92f255c..570aefc 100644 --- a/identify/identify.c +++ b/identify/identify.c @@ -1,6 +1,7 @@ #include #include "varint.h" +#include "protobuf.h" #include "libp2p/net/protocol.h" #include "libp2p/net/protocol.h" #include "libp2p/utils/vector.h" @@ -121,6 +122,181 @@ void libp2p_identify_free(Identify* in) { } } +/* helper to alloc and copy an item. + * @param item the item. + * @returns a pointer on success, otherwise NULL. + */ +char *libp2p_identify_new_item(char *item, size_t size) { + char *dst = NULL; + if (item) { + dst = malloc(size); + if (dst) { + memcpy(dst, item, size); + } + } + return dst; +} + +/* helper to add an item to an array. + * @param array the array. + * @param item the item. + * @returns count itens on success, otherwise zero. + */ +int libp2p_identify_array_add_item(char ***array, char *item) { + int count = 0; + if (array && item) { + if (*array) { + // count itens already in. + while (*array[count++]); + } + // alloc the necessary array count or realloc more if alread allocated. + *array = realloc(*array, sizeof(char*) * (count + 2)); // 2, the new and the NULL + *array[count++] = item; + *array[count] = NULL; + } + return count; +} + +/** + * Convert a identify struct into protobuf format + * @param in the Identify struct to convert + * @param buffer where to store the protobuf + * @param max_buffer_size the size of the allocated buffer + * @param bytes_written the size written into buffer + * @returns true(1) on success, otherwise false(0) + */ +int libp2p_identify_protobuf_encode(const Identify* in, unsigned char* buffer, size_t max_buffer_size, size_t* bytes_written) { + // data & data_size + size_t bytes_used = 0; + *bytes_written = 0; + int i, retVal = 0; + + // field 1 + retVal = protobuf_encode_string(1, WIRETYPE_LENGTH_DELIMITED, in->PublicKey, &buffer[*bytes_written], max_buffer_size - *bytes_written, &bytes_used); + if (retVal == 0) + return 0; + *bytes_written += bytes_used; + // field 2 + for (i = 0 ; in->ListenAddrs[i] ; i++) { + retVal = protobuf_encode_string(2, WIRETYPE_LENGTH_DELIMITED, in->ListenAddrs[i], &buffer[*bytes_written], max_buffer_size - *bytes_written, &bytes_used); + if (retVal == 0) + return 0; + *bytes_written += bytes_used; + } + // field 3 + for (i = 0 ; in->Protocols[i] ; i++) { + retVal = protobuf_encode_string(3, WIRETYPE_LENGTH_DELIMITED, in->Protocols[i], &buffer[*bytes_written], max_buffer_size - *bytes_written, &bytes_used); + if (retVal == 0) + return 0; + *bytes_written += bytes_used; + } + // field 4 + retVal = protobuf_encode_string(4, WIRETYPE_LENGTH_DELIMITED, in->ObservedAddr, &buffer[*bytes_written], max_buffer_size - *bytes_written, &bytes_used); + if (retVal == 0) + return 0; + *bytes_written += bytes_used; + // field 5 + retVal = protobuf_encode_string(5, WIRETYPE_LENGTH_DELIMITED, in->ProtocolVersion, &buffer[*bytes_written], max_buffer_size - *bytes_written, &bytes_used); + if (retVal == 0) + return 0; + *bytes_written += bytes_used; + // field 6 + retVal = protobuf_encode_string(6, WIRETYPE_LENGTH_DELIMITED, in->AgentVersion, &buffer[*bytes_written], max_buffer_size - *bytes_written, &bytes_used); + if (retVal == 0) + return 0; + *bytes_written += bytes_used; + + return 1; +} + +/** + * Convert a protobuf byte array into a Identify struct + * @param in the byte array + * @param in_size the size of the byte array + * @param out a pointer to the new Identify struct + * @returns true(1) on success, otherwise false(0) + */ +int libp2p_identify_protobuf_decode(const unsigned char* in, size_t in_size, Identify** out) { + size_t pos = 0; + int count, retVal = 0; + char *item; + + if ( (*out = libp2p_identify_new()) == NULL) + goto exit; + + while(pos < in_size) { + size_t bytes_read = 0; + int field_no; + enum WireType field_type; + if (!protobuf_decode_field_and_type(&in[pos], in_size, &field_no, &field_type, &bytes_read)) { + goto exit; + } + pos += bytes_read; + switch(field_no) { + case (1): // PublicKey + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&((*out)->PublicKey), &bytes_read)) + goto exit; + pos += bytes_read; + break; + case (2): // ListenAddrs + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&(item), &bytes_read)) + goto exit; + if (!libp2p_identify_array_add_item(&((*out)->ListenAddrs), item)) + goto exit; + pos += bytes_read; + break; + case (3): // Protocols + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&(item), &bytes_read)) + goto exit; + if (!libp2p_identify_array_add_item(&((*out)->Protocols), item)) + goto exit; + pos += bytes_read; + break; + case (4): // ObservedAddr + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&((*out)->ObservedAddr), &bytes_read)) + goto exit; + pos += bytes_read; + break; + case (5): // ProtocolVersion + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&((*out)->ProtocolVersion), &bytes_read)) + goto exit; + pos += bytes_read; + break; + case (6): // AgentVersion + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&((*out)->AgentVersion), &bytes_read)) + goto exit; + pos += bytes_read; + break; + default: // XXX_unrecognized + // create a comma-separated string of each unrecognized item. + if (!protobuf_decode_string(&in[pos], in_size - pos, (char**)&(item), &bytes_read)) + goto exit; + count = 0; + if ((*out)->XXX_unrecognized) { + count = strlen((*out)->XXX_unrecognized); + (*out)->XXX_unrecognized[count++] = ','; // null terminator is now a comma. + } + (*out)->XXX_unrecognized = realloc((*out)->XXX_unrecognized, count + bytes_read); + if (!(*out)->XXX_unrecognized) + goto exit; + // append after the comma. + memcpy((*out)->XXX_unrecognized+count, item, bytes_read); + free(item); + pos += bytes_read; + break; + } + } + + retVal = 1; + +exit: + if (retVal == 0) { + libp2p_identify_free(*out); + *out = NULL; + } + return retVal; +} + /** * A remote node is attempting to send us an Identify message * @param msg the message sent diff --git a/include/libp2p/identify/identify.h b/include/libp2p/identify/identify.h index 29c2486..c31dd7f 100644 --- a/include/libp2p/identify/identify.h +++ b/include/libp2p/identify/identify.h @@ -36,6 +36,10 @@ int libp2p_identify_send_protocol(struct Stream* stream); int libp2p_identify_receive_protocol(struct Stream* stream); Identify* libp2p_identify_new(); void libp2p_identify_free(Identify* in); +char *libp2p_identify_new_item(char *item, size_t size); +int libp2p_identify_array_add_item(char ***array, char *item); +int libp2p_identify_protobuf_encode(const Identify* in, unsigned char* buffer, size_t max_buffer_size, size_t* bytes_written); +int libp2p_identify_protobuf_decode(const unsigned char* in, size_t in_size, Identify** out); int libp2p_identify_handle_message(const struct StreamMessage* msg, struct Stream* stream, void* protocol_context); int libp2p_identify_shutdown(void* protocol_context); struct Libp2pProtocolHandler* libp2p_identify_build_protocol_handler(struct Libp2pVector* handlers);