#pragma once #include "libp2p/yamux/yamux.h" #include "libp2p/identify/identify.h" #include "mock_stream.h" #include "libp2p/utils/logger.h" #include "libp2p/net/stream.h" #include "libp2p/net/multistream.h" #include "libp2p/net/server.h" /*** * Helpers */ struct StreamMessage* build_message(const char* data) { struct StreamMessage* out = libp2p_stream_message_new(); if (out != NULL) { out->data_size = strlen(data); out->data = (uint8_t*) malloc(out->data_size); memcpy(out->data, data, out->data_size); } return out; } /*** * Sends back the yamux protocol to fake negotiation */ int mock_yamux_read_protocol(void* context, struct StreamMessage** msg, int network_timeout) { *msg = libp2p_stream_message_new(); struct StreamMessage* message = *msg; const char* id = "/yamux/1.0.0\n"; message->data_size = strlen(id); message->data = malloc(message->data_size); memcpy(message->data, id, message->data_size); return 1; } /*** * Sends back the identify protocol (in a yamux wrapper) to fake negotiation */ int mock_identify_read_protocol(void* context, struct StreamMessage** msg, int network_timeout) { struct StreamMessage message; const char* id = "/ipfs/id/1.0.0\n"; message.data_size = strlen(id); message.data = (uint8_t*)id; *msg = libp2p_yamux_prepare_to_send(&message); // adjust the frame struct yamux_frame* frame = (struct yamux_frame*)(*msg)->data; frame->streamid = 1; frame->flags = yamux_frame_syn; encode_frame(frame); return 1; } /*** * Sends back the identify protocol (in a yamux wrapper) to fake negotiation */ int mock_multistream_read_protocol(void* context, struct StreamMessage** msg, int network_timeout) { struct StreamMessage message; const char* id = "/multistream/1.0.0\n"; message.data_size = strlen(id); message.data = (uint8_t*)id; *msg = libp2p_yamux_prepare_to_send(&message); // adjust the frame struct yamux_frame* frame = (struct yamux_frame*)(*msg)->data; frame->streamid = 1; frame->flags = yamux_frame_syn; encode_frame(frame); return 1; } int mock_counter = 0; /*** * Sends back the yamux protocol to fake negotiation */ int mock_multistream_then_identify_read_protocol(void* context, struct StreamMessage** msg, int network_timeout) { // prepare the message *msg = libp2p_stream_message_new(); struct StreamMessage* message = *msg; message->data_size = mock_message->data_size - mock_message_position; message->data = malloc(message->data_size); memcpy(message->data, &mock_message->data[mock_message_position], message->data_size); if (mock_counter == 0) { // this is the first time through. Set mock_message to the identify protocol libp2p_stream_message_free(mock_message); mock_message = libp2p_net_multistream_prepare_to_send(build_message("/ipfs/id/1.0.0\n")); mock_message_position = 0; } else { libp2p_stream_message_free(mock_message); mock_message = NULL; mock_message_position = 0; } return (*msg != NULL); } /*** * Tests */ /*** * Verify that we can initiate a yamux session */ int test_yamux_stream_new() { int retVal = 0; const char* yamux_id = "/yamux/1.0.0\n"; // setup struct Stream* mock_stream = mock_stream_new(); mock_message = build_message(yamux_id); struct Stream* yamux_stream = libp2p_yamux_stream_new(mock_stream, 0, NULL); if (yamux_stream == NULL) goto exit; // tear down retVal = 1; exit: if (yamux_stream != NULL) yamux_stream->close(yamux_stream); if (mock_message != NULL) libp2p_stream_message_free(mock_message); return retVal; } /*** * Attempt to add a protocol to the Yamux protocol */ int test_yamux_identify() { int retVal = 0; // setup // mock struct Stream* mock_stream = mock_stream_new(); mock_stream->read = mock_yamux_read_protocol; // protocol handlers struct Libp2pVector* protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_identify_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // yamux struct Stream* yamux_stream = libp2p_yamux_stream_new(mock_stream, 0, protocol_handlers); if (yamux_stream == NULL) goto exit; // Now add in another protocol mock_stream->read = mock_identify_read_protocol; if (!libp2p_yamux_stream_add(yamux_stream->stream_context, libp2p_identify_stream_new(yamux_stream))) { goto exit; } // tear down retVal = 1; exit: if (yamux_stream != NULL) yamux_stream->close(yamux_stream); libp2p_protocol_handlers_shutdown(protocol_handlers); if (mock_message != NULL) { libp2p_stream_message_free(mock_message); mock_message = NULL; } return retVal; } /*** * Attempt to add a protocol to the Yamux protocol */ /* int test_yamux_multistream() { int retVal = 0; // setup // mock struct Stream* mock_stream = mock_stream_new(); mock_stream->read = mock_yamux_read_protocol; // protocol handlers struct Libp2pVector* protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_identify_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // yamux struct Stream* yamux_stream = libp2p_yamux_stream_new(mock_stream, 0, protocol_handlers); if (yamux_stream == NULL) goto exit; // Now add in another protocol mock_stream->read = mock_multistream_read_protocol; if (!libp2p_yamux_stream_add(yamux_stream->stream_context, libp2p_multistream_stream_new(yamux_stream))) { goto exit; } // tear down retVal = 1; exit: if (yamux_stream != NULL) yamux_stream->close(yamux_stream); libp2p_protocol_handlers_shutdown(protocol_handlers); if (mock_message != NULL) { libp2p_stream_message_free(mock_message); mock_message = NULL; } return retVal; } */ int test_yamux_incoming_protocol_request() { int retVal = 0; // setup // build the protocol handler that can handle yamux, multistream, and identify protocol struct Libp2pVector* protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_identify_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); handler = libp2p_yamux_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); handler = libp2p_net_multistream_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // set up basic streams struct Stream* mock_stream = mock_stream_new(); struct SessionContext* session_context = ((struct ConnectionContext*)mock_stream->stream_context)->session_context; mock_message = build_message("/yamux/1.0.0\n"); struct StreamMessage* result_message = NULL; if (!session_context->default_stream->read(session_context->default_stream->stream_context, &result_message, 10)) { libp2p_logger_error("test_yamux", "Unable to read Yamux protocol from mock stream.\n"); goto exit; } if (libp2p_protocol_marshal(result_message, session_context->default_stream, protocol_handlers) < 0) { libp2p_logger_error("test_yamux", "Upgrade to Yamux protocol unsuccessful.\n"); goto exit; } // now we should have upgraded to the yamux protocol libp2p_stream_message_free(result_message); result_message = NULL; if (session_context->default_stream->parent_stream == NULL) { libp2p_logger_error("test_yamux", "Upgrade to Yamux protocol appeared susccessful, but was not.\n"); goto exit; } // Someone is requesting the multistream protocol libp2p_stream_message_free(mock_message); mock_message = libp2p_yamux_prepare_to_send(libp2p_net_multistream_prepare_to_send(build_message("/multistream/1.0.0\n"))); // act like this is new struct yamux_frame* frame = (struct yamux_frame*)mock_message->data; frame->streamid = (uint32_t)1; frame->flags = yamux_frame_syn; encode_frame(frame); mock_stream->read = mock_stream_read; if (!session_context->default_stream->read(session_context->default_stream->stream_context, &result_message, 10)) { libp2p_logger_error("test_yamux", "Unable to read multistream protocol.\n"); goto exit; } // handle the marshaling of the multistream protocol libp2p_protocol_marshal(result_message, session_context->default_stream, protocol_handlers); libp2p_stream_message_free(result_message); result_message = NULL; // now verify the results if (session_context->default_stream->stream_type != STREAM_TYPE_YAMUX) { libp2p_logger_error("test_yamux", "Expected stream type of %d, but received %d.\n", STREAM_TYPE_YAMUX, session_context->default_stream->stream_type); goto exit; } struct YamuxContext* yamux_context = (struct YamuxContext*)session_context->default_stream->stream_context; if (yamux_context->channels->total != 2) { libp2p_logger_error("test_yamux", "Identify protocol was not found.\n"); goto exit; } // tear down retVal = 1; exit: if (session_context->default_stream != NULL) session_context->default_stream->close(session_context->default_stream); libp2p_protocol_handlers_shutdown(protocol_handlers); return retVal; } /** * Attempt to negotiate the identity protocol, then use it. * This makes sure the framing is working correctly betwee identity * and yamux */ int test_yamux_identity_frame() { int retVal = 0; // setup // build the protocol handler that can handle yamux and identify protocol struct Libp2pVector* protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_identify_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); handler = libp2p_yamux_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); struct Stream* mock_stream = mock_stream_new(); struct SessionContext* session_context = ((struct ConnectionContext*)mock_stream->stream_context)->session_context; mock_stream->read = mock_yamux_read_protocol; struct StreamMessage* result_message = NULL; if (!session_context->default_stream->read(session_context->default_stream->stream_context, &result_message, 10)) { libp2p_logger_error("test_yamux", "Unable to read Yamux protocol from mock stream.\n"); goto exit; } if (libp2p_protocol_marshal(result_message, session_context->default_stream, protocol_handlers) < 0) { libp2p_logger_error("test_yamux", "Upgrade to Yamux protocol unsuccessful.\n"); goto exit; } // now we should have upgraded to the yamux protocol libp2p_stream_message_free(result_message); result_message = NULL; if (session_context->default_stream->parent_stream == NULL) { libp2p_logger_error("test_yamux", "Upgrade to Yamux protocol appeared susccessful, but was not.\n"); goto exit; } // Someone is requesting the identity protocol mock_stream->read = mock_multistream_then_identify_read_protocol; if (!session_context->default_stream->read(session_context->default_stream->stream_context, &result_message, 10)) { libp2p_logger_error("test_yamux", "Unable to read identify protocol.\n"); goto exit; } // handle the marshaling of the protocol libp2p_protocol_marshal(result_message, session_context->default_stream, protocol_handlers); libp2p_stream_message_free(result_message); result_message = NULL; // now verify the results struct YamuxContext* yamux_context = (struct YamuxContext*)session_context->default_stream->stream_context; if (yamux_context->channels->total != 2) { libp2p_logger_error("test_yamux", "Identify protocol was not found.\n"); goto exit; } // prepare a yamux frame that is an identity message // send the message // tear down retVal = 1; exit: if (session_context->default_stream != NULL) session_context->default_stream->close(session_context->default_stream); libp2p_protocol_handlers_shutdown(protocol_handlers); return retVal; } int test_yamux_client_server_connect() { int retVal = 0; struct Libp2pVector* protocol_handlers = NULL; struct StreamMessage* resultMessage = NULL; //libp2p_logger_add_class("connectionstream"); // setup // build the protocol handler that can handle yamux protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_yamux_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // set up server libp2p_net_server_start("127.0.0.1", 1234, protocol_handlers); sleep(1); // set up client (easiest to use transport dialers) struct Dialer* dialer = libp2p_conn_dialer_new(NULL, NULL, NULL); struct MultiAddress* server_ma = multiaddress_new_from_string("/ip4/127.0.0.1/tcp/1234"); struct Stream* stream = libp2p_conn_dialer_get_connection(dialer, server_ma); if (stream == NULL) { fprintf(stderr, "Unable to get stream.\n"); goto exit; } // have client attempt to connect to server and negotiate yamux struct Stream* yamux_stream = libp2p_yamux_stream_new(stream, 0, protocol_handlers); if (yamux_stream == NULL) { fprintf(stderr, "Was supposed to get yamux protocol id, but instead received nothing.\n"); goto exit; } //TODO: make sure everything is negotiated and yamux is in a happy state // hangup yamux_stream->close(yamux_stream); // for debugging // sleep(30); retVal = 1; exit: libp2p_net_server_stop(); if (protocol_handlers != NULL) { } return retVal; } int test_yamux_client_server_multistream() { int retVal = 0; struct Libp2pVector* protocol_handlers = NULL; struct StreamMessage* resultMessage = NULL; libp2p_logger_add_class("connectionstream"); libp2p_logger_add_class("multistream"); libp2p_logger_add_class("yamux"); // setup // build the protocol handler that can handle yamux protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_yamux_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); handler = libp2p_net_multistream_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // set up server libp2p_net_server_start("127.0.0.1", 1234, protocol_handlers); sleep(1); // set up client (easiest to use transport dialers) struct Dialer* dialer = libp2p_conn_dialer_new(NULL, NULL, NULL); struct MultiAddress* server_ma = multiaddress_new_from_string("/ip4/127.0.0.1/tcp/1234"); struct Stream* stream = libp2p_conn_dialer_get_connection(dialer, server_ma); if (stream == NULL) { fprintf(stderr, "Unable to get stream.\n"); goto exit; } // have client attempt to connect to server and negotiate yamux struct Stream* yamux_stream = libp2p_yamux_stream_new(stream, 0, protocol_handlers); if (yamux_stream == NULL) { fprintf(stderr, "Was supposed to get yamux protocol id, but instead received nothing.\n"); goto exit; } // now attempt multistream struct Stream* multistream = libp2p_net_multistream_stream_new(yamux_stream, 0); if (multistream == NULL) { fprintf(stderr, "Was supposed to get a multistream, but instead got NULL.\n"); goto exit; } // shut down nicely multistream->close(multistream); retVal = 1; exit: libp2p_net_server_stop(); if (protocol_handlers != NULL) { } return retVal; } int test_yamux_multistream_server() { int retVal = 0; struct Libp2pVector* protocol_handlers = NULL; struct StreamMessage* resultMessage = NULL; libp2p_logger_add_class("connectionstream"); libp2p_logger_add_class("multistream"); libp2p_logger_add_class("yamux"); // setup // build the protocol handler that can handle yamux protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_yamux_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); handler = libp2p_net_multistream_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // set up server libp2p_net_server_start("127.0.0.1", 1234, protocol_handlers); // debugging sleep(120); retVal = 1; exit: libp2p_net_server_stop(); if (protocol_handlers != NULL) { } return retVal; } int test_yamux_multistream_client() { int retVal = 0; struct Libp2pVector* protocol_handlers = NULL; struct StreamMessage* resultMessage = NULL; libp2p_logger_add_class("connectionstream"); libp2p_logger_add_class("multistream"); libp2p_logger_add_class("yamux"); // setup // build the protocol handler that can handle yamux protocol_handlers = libp2p_utils_vector_new(1); struct Libp2pProtocolHandler* handler = libp2p_yamux_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); handler = libp2p_net_multistream_build_protocol_handler(protocol_handlers); libp2p_utils_vector_add(protocol_handlers, handler); // set up client (easiest to use transport dialers) struct Dialer* dialer = libp2p_conn_dialer_new(NULL, NULL, NULL); struct MultiAddress* server_ma = multiaddress_new_from_string("/ip4/127.0.0.1/tcp/1234"); struct Stream* stream = libp2p_conn_dialer_get_connection(dialer, server_ma); if (stream == NULL) { fprintf(stderr, "Unable to get stream.\n"); goto exit; } // have client attempt to connect to server and negotiate yamux struct Stream* yamux_stream = libp2p_yamux_stream_new(stream, 0, protocol_handlers); if (yamux_stream == NULL) { fprintf(stderr, "Was supposed to get yamux protocol id, but instead received nothing.\n"); goto exit; } // now attempt multistream struct Stream* multistream = libp2p_net_multistream_stream_new(yamux_stream, 0); if (multistream == NULL) { fprintf(stderr, "Was supposed to get a multistream, but instead got NULL.\n"); goto exit; } // shut down nicely multistream->close(multistream); // debugging sleep(30); retVal = 1; exit: if (protocol_handlers != NULL) { } return retVal; }