diff --git a/.github/workflows/run_all_tests.yml b/.github/workflows/run_all_tests.yml index cf6bc7a..cba7b25 100644 --- a/.github/workflows/run_all_tests.yml +++ b/.github/workflows/run_all_tests.yml @@ -32,5 +32,5 @@ jobs: working-directory: tests - name: run_tests run: | - sudo ./run_all_tests + sudo ./output/run_tests working-directory: tests diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index c5bcaff..9518968 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -49,7 +49,7 @@ endif() add_library(swiftnet STATIC ${SOURCE_FILES}) target_compile_options(swiftnet PRIVATE -O0) -target_link_options(swiftnet PRIVATE -O0) +target_link_options(swiftnet PRIVATE -lpcap -O0) set_target_properties(swiftnet PROPERTIES OUTPUT_NAME "swiftnet" diff --git a/src/cleanup_connection.c b/src/cleanup_connection.c index 7a8a572..1f81bbe 100644 --- a/src/cleanup_connection.c +++ b/src/cleanup_connection.c @@ -1,6 +1,7 @@ #include "internal/internal.h" #include "swift_net.h" #include +#include #include void swiftnet_client_cleanup(SwiftNetClientConnection* const client) { @@ -12,6 +13,34 @@ void swiftnet_client_cleanup(SwiftNetClientConnection* const client) { vector_destroy(&client->pending_messages); vector_destroy(&client->packets_completed); + const char* interface_name = client->loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface; + + vector_lock(&listeners); + + for (uint16_t i = 0; i < listeners.size; i++) { + Listener* const current_listener = vector_get(&listeners, i); + if (strcmp(interface_name, current_listener->interface_name) == 0) { + vector_lock(¤t_listener->client_connections); + + for (uint16_t inx = 0; inx < current_listener->client_connections.size; inx++) { + SwiftNetClientConnection* const current_client_conn = vector_get(¤t_listener->client_connections, i); + if (current_client_conn != client) { + continue; + } + + vector_remove(¤t_listener->client_connections, inx); + + break; + } + + vector_unlock(¤t_listener->client_connections); + + break; + } + } + + vector_unlock(&listeners); + atomic_store_explicit(&client->closing, true, memory_order_release); pthread_join(client->process_packets_thread, NULL); @@ -31,6 +60,34 @@ void swiftnet_server_cleanup(SwiftNetServer* const server) { vector_destroy(&server->pending_messages); vector_destroy(&server->packets_completed); + const char* interface_name = server->loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface; + + vector_lock(&listeners); + + for (uint16_t i = 0; i < listeners.size; i++) { + Listener* const current_listener = vector_get(&listeners, i); + if (strcmp(interface_name, current_listener->interface_name) == 0) { + vector_lock(¤t_listener->servers); + + for (uint16_t inx = 0; inx < current_listener->servers.size; inx++) { + SwiftNetServer* const current_server = vector_get(¤t_listener->servers, i); + if (current_server != server) { + continue; + } + + vector_remove(¤t_listener->servers, inx); + + break; + } + + vector_unlock(¤t_listener->servers); + + break; + } + } + + vector_unlock(&listeners); + atomic_store_explicit(&server->closing, true, memory_order_release); pthread_join(server->process_packets_thread, NULL); diff --git a/src/execute_packet_callback.c b/src/execute_packet_callback.c index bb2f342..2865d04 100644 --- a/src/execute_packet_callback.c +++ b/src/execute_packet_callback.c @@ -70,25 +70,6 @@ void execute_packet_callback(PacketCallbackQueue* const queue, void (* const _At (*packet_handler_loaded)(node->packet_data); - if(node->pending_message != NULL) { - free(node->pending_message->chunks_received); - allocator_free(pending_message_memory_allocator, node->pending_message); - - if (connection_type == 0) { - free(((const SwiftNetClientPacketData* const)(node->packet_data))->data); - } else { - free(((const SwiftNetServerPacketData* const)(node->packet_data))->data); - } - } else { - if (connection_type == 0) { - allocator_free(&packet_buffer_memory_allocator, ((SwiftNetClientPacketData*)(node->packet_data))->data - PACKET_HEADER_SIZE); - allocator_free(&client_packet_data_memory_allocator, node->packet_data); - } else { - allocator_free(&packet_buffer_memory_allocator, ((SwiftNetServerPacketData*)(node->packet_data))->data - PACKET_HEADER_SIZE); - allocator_free(&server_packet_data_memory_allocator, node->packet_data); - } - } - allocator_free(&packet_callback_queue_node_memory_allocator, (void*)node); } } diff --git a/src/generic_functions.c b/src/generic_functions.c index cd32109..f299a0d 100644 --- a/src/generic_functions.c +++ b/src/generic_functions.c @@ -57,10 +57,28 @@ void* swiftnet_server_read_packet(SwiftNetServerPacketData* const packet_data, c return ptr; } -void swiftnet_client_destroy_packet_data(SwiftNetClientPacketData* const packet_data) { - allocator_free(&client_packet_data_memory_allocator, packet_data); +void swiftnet_client_destroy_packet_data(SwiftNetClientPacketData* const packet_data, SwiftNetClientConnection* const client_conn) { + if(packet_data->internal_pending_message != NULL) { + free(packet_data->internal_pending_message->chunks_received); + + allocator_free(&client_conn->pending_messages_memory_allocator, packet_data->internal_pending_message); + + free(packet_data->data); + } else { + allocator_free(&packet_buffer_memory_allocator, packet_data->data - PACKET_HEADER_SIZE - client_conn->prepend_size); + allocator_free(&client_packet_data_memory_allocator, packet_data); + } } -void swiftnet_server_destroy_packet_data(SwiftNetServerPacketData* const packet_data) { - allocator_free(&server_packet_data_memory_allocator, packet_data); +void swiftnet_server_destroy_packet_data(SwiftNetServerPacketData* const packet_data, SwiftNetServer* const server) { + if(packet_data->internal_pending_message != NULL) { + free(packet_data->internal_pending_message->chunks_received); + + allocator_free(&server->pending_messages_memory_allocator, packet_data->internal_pending_message); + + free(packet_data->data); + } else { + allocator_free(&packet_buffer_memory_allocator, packet_data->data - PACKET_HEADER_SIZE - server->prepend_size); + allocator_free(&server_packet_data_memory_allocator, packet_data); + } } diff --git a/src/initialize_server_socket.c b/src/initialize_server_socket.c index da3f494..7294a0f 100644 --- a/src/initialize_server_socket.c +++ b/src/initialize_server_socket.c @@ -26,7 +26,7 @@ SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool loopback) new_server->server_port = port; new_server->loopback = loopback; - // Init bpf device + // Init pcap device new_server->pcap = swiftnet_pcap_open(loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface); if (new_server->pcap == NULL) { fprintf(stderr, "Failed to open bpf\n"); diff --git a/src/make_response.c b/src/make_response.c index 7c10acf..c82cb9c 100644 --- a/src/make_response.c +++ b/src/make_response.c @@ -17,7 +17,7 @@ void swiftnet_server_make_response(SwiftNetServer* const server, SwiftNetServerP .destination_port = packet_data->metadata.port_info.source_port }; - swiftnet_send_packet(server, packet_data->metadata.sender.maximum_transmission_unit, packet_data->metadata.port_info, buffer, packet_length, &packet_data->metadata.sender.sender_address, &server->packets_sending, &server->packets_sending_memory_allocator, server->pcap, server->eth_header, server->loopback, server->addr_type, server->prepend_size, NULL, true, packet_data->metadata.packet_id); + swiftnet_send_packet(server, packet_data->metadata.sender.maximum_transmission_unit, port_info, buffer, packet_length, &packet_data->metadata.sender.sender_address, &server->packets_sending, &server->packets_sending_memory_allocator, server->pcap, server->eth_header, server->loopback, server->addr_type, server->prepend_size, NULL, true, packet_data->metadata.packet_id); } #endif diff --git a/src/process_packets.c b/src/process_packets.c index ff4e089..9e20a92 100644 --- a/src/process_packets.c +++ b/src/process_packets.c @@ -192,15 +192,11 @@ static inline void handle_request_response(const uint16_t packet_id, const struc if (is_valid_response == true) { if (pending_message != NULL) { - free(pending_message->chunks_received); - - allocator_free(pending_message_memory_allocator, pending_message); - vector_lock(pending_messages); for (uint32_t i = 0; i < pending_messages->size; i++) { - const SwiftNetPendingMessage* const pending_message = vector_get(pending_messages, i); - if ((connection_type == CONNECTION_TYPE_CLIENT && pending_message->packet_id == packet_id) || (connection_type == CONNECTION_TYPE_SERVER && pending_message->sender_address.s_addr == sender.s_addr && pending_message->packet_id == packet_id)) { + const SwiftNetPendingMessage* const current_pending_message = vector_get(pending_messages, i); + if (current_pending_message == pending_message) { vector_remove(pending_messages, i); } } @@ -503,8 +499,9 @@ static inline void swiftnet_process_packets( const uint16_t lost_chunk_indexes = return_lost_chunk_indexes(pending_message->chunks_received, pending_message->packet_info.chunk_amount, mtu - PACKET_HEADER_SIZE, (uint32_t*)(buffer + header_size)); const uint16_t packet_length = sizeof(struct ip) + sizeof(SwiftNetPacketInfo) + (lost_chunk_indexes * sizeof(uint32_t)); + const uint16_t packet_length_net_order = htons(packet_length); - memcpy(buffer + prepend_size + offsetof(struct ip, ip_len), &packet_length, SIZEOF_FIELD(struct ip, ip_len)); + memcpy(buffer + prepend_size + offsetof(struct ip, ip_len), &packet_length_net_order, SIZEOF_FIELD(struct ip, ip_len)); HANDLE_CHECKSUM(buffer, packet_length + prepend_size, prepend_size); @@ -596,6 +593,7 @@ static inline void swiftnet_process_packets( SwiftNetServerPacketData* const new_packet_data = allocator_allocate(&server_packet_data_memory_allocator) ; new_packet_data->data = packet_data; new_packet_data->current_pointer = packet_data; + new_packet_data->internal_pending_message = NULL; new_packet_data->metadata = (SwiftNetPacketServerMetadata){ .port_info = packet_info.port_info, .sender = sender, @@ -619,6 +617,7 @@ static inline void swiftnet_process_packets( SwiftNetClientPacketData* const new_packet_data = allocator_allocate(&client_packet_data_memory_allocator) ; new_packet_data->data = packet_data; new_packet_data->current_pointer = packet_data; + new_packet_data->internal_pending_message = NULL; new_packet_data->metadata = (SwiftNetPacketClientMetadata){ .port_info = packet_info.port_info, .data_length = packet_info.packet_length, @@ -672,6 +671,7 @@ static inline void swiftnet_process_packets( SwiftNetServerPacketData* const packet_data = allocator_allocate(&server_packet_data_memory_allocator); packet_data->data = ptr; packet_data->current_pointer = ptr; + packet_data->internal_pending_message = pending_message; packet_data->metadata = (SwiftNetPacketServerMetadata){ .port_info = packet_info.port_info, .sender = sender, @@ -697,6 +697,7 @@ static inline void swiftnet_process_packets( SwiftNetClientPacketData* const packet_data = allocator_allocate(&client_packet_data_memory_allocator) ; packet_data->data = ptr; packet_data->current_pointer = ptr; + packet_data->internal_pending_message = pending_message; packet_data->metadata = (SwiftNetPacketClientMetadata){ .port_info = packet_info.port_info, .data_length = packet_info.packet_length, diff --git a/src/send_packet.c b/src/send_packet.c index b80f56e..2a31162 100644 --- a/src/send_packet.c +++ b/src/send_packet.c @@ -285,9 +285,10 @@ inline void swiftnet_send_packet( if(current_offset + (mtu - PACKET_HEADER_SIZE) >= packet_info.packet_length) { // Last chunk const uint16_t bytes_to_send = (uint16_t)packet_length - current_offset + PACKET_HEADER_SIZE + prepend_size; + const uint16_t bytes_to_send_net_order = htons(bytes_to_send - prepend_size); memcpy(&buffer[PACKET_HEADER_SIZE + prepend_size], packet->packet_data_start + current_offset, bytes_to_send - prepend_size - PACKET_HEADER_SIZE); - memcpy(&buffer[prepend_size + offsetof(struct ip, ip_len)], &bytes_to_send, SIZEOF_FIELD(struct ip, ip_len)); + memcpy(&buffer[prepend_size + offsetof(struct ip, ip_len)], &bytes_to_send_net_order, SIZEOF_FIELD(struct ip, ip_len)); HANDLE_CHECKSUM(buffer, bytes_to_send, prepend_size) diff --git a/src/swift_net.h b/src/swift_net.h index 0ce53c6..daf5035 100644 --- a/src/swift_net.h +++ b/src/swift_net.h @@ -78,6 +78,25 @@ typedef struct { #endif } SwiftNetPacketClientMetadata; +typedef struct { + uint32_t packet_length; + SwiftNetPortInfo port_info; + uint8_t packet_type; + uint32_t chunk_amount; + uint32_t chunk_index; + uint32_t maximum_transmission_unit; +} SwiftNetPacketInfo; + +typedef struct { + uint8_t* packet_data_start; + SwiftNetPacketInfo packet_info; + uint16_t packet_id; + struct in_addr sender_address; + uint8_t* chunks_received; + uint32_t chunks_received_length; + uint32_t chunks_received_number; +} SwiftNetPendingMessage; + typedef struct { uint32_t data_length; SwiftNetPortInfo port_info; @@ -88,15 +107,6 @@ typedef struct { #endif } SwiftNetPacketServerMetadata; -typedef struct { - uint32_t packet_length; - SwiftNetPortInfo port_info; - uint8_t packet_type; - uint32_t chunk_amount; - uint32_t chunk_index; - uint32_t maximum_transmission_unit; -} SwiftNetPacketInfo; - typedef struct { uint32_t maximum_transmission_unit; } SwiftNetServerInformation; @@ -126,16 +136,6 @@ typedef struct { uint8_t* packet_append_pointer; // Current position to append new data } SwiftNetPacketBuffer; -typedef struct { - uint8_t* packet_data_start; - SwiftNetPacketInfo packet_info; - uint16_t packet_id; - struct in_addr sender_address; - uint8_t* chunks_received; - uint32_t chunks_received_length; - uint32_t chunks_received_number; -} SwiftNetPendingMessage; - typedef struct PacketQueueNode PacketQueueNode; struct PacketQueueNode { @@ -165,12 +165,14 @@ typedef struct { uint8_t* data; uint8_t* current_pointer; SwiftNetPacketServerMetadata metadata; + SwiftNetPendingMessage* internal_pending_message; // Do not use!! } SwiftNetServerPacketData; typedef struct { uint8_t* data; uint8_t* current_pointer; SwiftNetPacketClientMetadata metadata; + SwiftNetPendingMessage* internal_pending_message; // Do not use!! } SwiftNetClientPacketData; typedef struct { @@ -278,8 +280,8 @@ extern SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool lo extern SwiftNetClientConnection* swiftnet_create_client(const char* const ip_address, const uint16_t port, const uint32_t timeout_ms); extern void* swiftnet_client_read_packet(SwiftNetClientPacketData* const packet_data, const uint32_t data_size); extern void* swiftnet_server_read_packet(SwiftNetServerPacketData* const packet_data, const uint32_t data_size); -extern void swiftnet_client_destroy_packet_data(SwiftNetClientPacketData* const packet_data); -extern void swiftnet_server_destroy_packet_data(SwiftNetServerPacketData* const packet_data); +extern void swiftnet_client_destroy_packet_data(SwiftNetClientPacketData* const packet_data, SwiftNetClientConnection* const client_conn); +extern void swiftnet_server_destroy_packet_data(SwiftNetServerPacketData* const packet_data, SwiftNetServer* const server); extern void swiftnet_cleanup(); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index 76cc235..b3d4ade 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -25,15 +25,9 @@ set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0") file(GLOB SRC_FILES "${CMAKE_SOURCE_DIR}/src/*.c") -foreach(src_file IN LISTS SRC_FILES) - get_filename_component(exec_name ${src_file} NAME_WE) - add_executable(${exec_name} ${src_file}) - target_compile_options(${exec_name} PRIVATE) - target_link_libraries(${exec_name} swiftnet pcap) -endforeach() +add_executable(run_tests ${SRC_FILES}) -set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) +target_link_libraries(run_tests swiftnet pcap) +target_link_options(run_tests PRIVATE -g -O0) -add_executable(run_all_tests run_all_tests.c) -target_link_libraries(run_all_tests swiftnet pcap) -target_link_options(run_all_tests PRIVATE -g -O0) +set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) diff --git a/tests/run_all_tests.c b/tests/run_all_tests.c deleted file mode 100644 index c4890a0..0000000 --- a/tests/run_all_tests.c +++ /dev/null @@ -1,76 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include -#include - -int run_and_check(const char *path) { - pid_t pid = fork(); - - if (pid == -1) { - return -1; - } else if (pid == 0) { - execl(path, path, NULL); - exit(127); - } else { - int status; - waitpid(pid, &status, 0); - - if (WIFEXITED(status)) { - return WEXITSTATUS(status); - } else { - return -1; - } - } -} - -int main() { - - const char *dir_path = "./output"; - DIR *dir = opendir(dir_path); - if (!dir) { - perror("opendir"); - return 1; - } - - struct dirent *entry; - char full_path[4096]; - int all_ok = 1; - - while ((entry = readdir(dir)) != NULL) { - if (strcmp(entry->d_name, ".") == 0 || strcmp(entry->d_name, "..") == 0) - continue; - - snprintf(full_path, sizeof(full_path), "%s/%s", dir_path, entry->d_name); - - struct stat st; - if (stat(full_path, &st) == -1) { - perror("stat"); - continue; - } - - if (S_ISREG(st.st_mode)) { - printf("Running: %s\n", full_path); - int exit_code = run_and_check(full_path); - if (exit_code == 0) { - fprintf(stdout, "successfully completed test: %s\n", full_path); - } else { - fprintf(stderr, "Error: %s exited with code %d\n", full_path, exit_code); - all_ok = 0; - } - } - } - - closedir(dir); - - if (all_ok) { - printf("All tests ran successfully.\n"); - return 0; - } else { - printf("Some tests failed.\n"); - return 1; - } -} diff --git a/tests/src/making_request.c b/tests/src/making_request.c new file mode 100644 index 0000000..6ceed6b --- /dev/null +++ b/tests/src/making_request.c @@ -0,0 +1,355 @@ +#include "../config.h" +#include +#include +#include +#include "../../src/swift_net.h" +#include +#include +#include +#include "run_tests.h" + +static _Atomic (SwiftNetClientConnection*) g_client_conn = NULL; +static _Atomic (SwiftNetServer*) g_server = NULL; + +static _Atomic int g_test_result = INT_MAX; + +static _Atomic (uint8_t*) g_request_data = NULL; +static _Atomic (uint8_t*) g_response_data = NULL; + +static _Atomic bool g_sent_response = false; + +static _Atomic uint32_t g_request_data_len = 0; +static _Atomic uint32_t g_response_data_len = 0; + +const uint8_t g_make_request_code = 0xFF; + +static void wait_until_response_sent() { + while (atomic_load_explicit(&g_sent_response, memory_order_acquire) == false) { + usleep(1000); + } +} + +static void reset_test_state() { + swiftnet_server_cleanup(atomic_load_explicit(&g_server, memory_order_acquire)); + swiftnet_client_cleanup(atomic_load_explicit(&g_client_conn, memory_order_acquire)); + + uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire); + uint8_t* request_data = atomic_load_explicit(&g_request_data, memory_order_acquire); + + if (response_data) free(response_data); + if (request_data) free(request_data); + + atomic_store_explicit(&g_response_data, NULL, memory_order_release); + atomic_store_explicit(&g_request_data, NULL, memory_order_release); + + atomic_store_explicit(&g_response_data_len, 0, memory_order_release); + atomic_store_explicit(&g_request_data_len, 0, memory_order_release); + + atomic_store_explicit(&g_client_conn, NULL, memory_order_release); + atomic_store_explicit(&g_server, NULL, memory_order_release); + + atomic_store_explicit(&g_sent_response, false, memory_order_release); + + atomic_store_explicit(&g_test_result, INT_MAX, memory_order_release); +} + +static void on_client_packet(SwiftNetClientPacketData* packet) { + SwiftNetClientConnection* const client_conn = atomic_load_explicit(&g_client_conn, memory_order_acquire); + + if (packet->metadata.data_length != atomic_load_explicit(&g_request_data_len, memory_order_acquire)) { + PRINT_ERROR("Server received invalid data size: %d | %d", + packet->metadata.data_length, + atomic_load_explicit(&g_request_data_len, memory_order_acquire) + ); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_client_destroy_packet_data(packet, client_conn); + + return; + } + + const uint8_t* data = atomic_load_explicit(&g_request_data, memory_order_acquire); + + for (uint32_t i = 0; i < packet->metadata.data_length; i++) { + uint8_t byte_received = *(uint8_t*)swiftnet_client_read_packet(packet, 1); + if (data[i] != byte_received) { + PRINT_ERROR("Client received invalid data"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_client_destroy_packet_data(packet, client_conn); + + return; + } + } + + const uint32_t response_data_len = atomic_load_explicit(&g_response_data_len, memory_order_acquire); + uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire); + + SwiftNetPacketBuffer send_buffer = swiftnet_client_create_packet_buffer(response_data_len); + + swiftnet_client_append_to_packet(response_data, response_data_len, &send_buffer); + + swiftnet_client_make_response(atomic_load_explicit(&g_client_conn, memory_order_acquire), packet, &send_buffer); + + swiftnet_client_destroy_packet_buffer(&send_buffer); + swiftnet_client_destroy_packet_data(packet, client_conn); + + atomic_store_explicit(&g_sent_response, true, memory_order_release); +} + +static void on_server_packet(SwiftNetServerPacketData* packet) { + SwiftNetServer* const server = atomic_load_explicit(&g_server, memory_order_acquire); + + if (packet->metadata.expecting_response) { + if (packet->metadata.data_length != atomic_load_explicit(&g_request_data_len, memory_order_acquire)) { + PRINT_ERROR("Server received invalid data size: %d | %d", + packet->metadata.data_length, + atomic_load_explicit(&g_request_data_len, memory_order_acquire) + ); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + const uint8_t* data = atomic_load_explicit(&g_request_data, memory_order_acquire); + + for (uint32_t i = 0; i < packet->metadata.data_length; i++) { + uint8_t byte_received = *(uint8_t*)swiftnet_server_read_packet(packet, 1); + if (data[i] != byte_received) { + PRINT_ERROR("Server received invalid data"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + } + + const uint32_t response_data_len = atomic_load_explicit(&g_response_data_len, memory_order_acquire); + uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire); + + SwiftNetPacketBuffer send_buffer = swiftnet_server_create_packet_buffer(response_data_len); + + swiftnet_server_append_to_packet(response_data, response_data_len, &send_buffer); + + swiftnet_server_make_response(atomic_load_explicit(&g_server, memory_order_acquire), packet, &send_buffer); + + swiftnet_server_destroy_packet_buffer(&send_buffer); + swiftnet_server_destroy_packet_data(packet, server); + + atomic_store_explicit(&g_sent_response, true, memory_order_release); + } else { + if (packet->metadata.data_length != sizeof(g_make_request_code)) { + PRINT_ERROR("Server received invalid data size: %d | %lu", + packet->metadata.data_length, + sizeof(g_make_request_code) + ); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + uint8_t byte_received = *(uint8_t*)swiftnet_server_read_packet(packet, 1); + + if (byte_received != g_make_request_code) { + PRINT_ERROR("Server received invalid data"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + const uint32_t request_data_len = atomic_load_explicit(&g_request_data_len, memory_order_acquire); + uint8_t* request_data = atomic_load_explicit(&g_request_data, memory_order_acquire); + const uint32_t response_data_len = atomic_load_explicit(&g_response_data_len, memory_order_acquire); + uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire); + + SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(request_data_len); + + swiftnet_server_append_to_packet(request_data, request_data_len, &buffer); + + SwiftNetServerPacketData* response = swiftnet_server_make_request(atomic_load_explicit(&g_server, memory_order_acquire), &buffer, packet->metadata.sender, 1000); + + swiftnet_server_destroy_packet_buffer(&buffer); + + if (response == NULL) { + int result = atomic_load_explicit(&g_test_result, memory_order_acquire); + if (result == INT_MAX) { + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + PRINT_ERROR("Did not receive response from server"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + if (response->metadata.data_length != response_data_len) { + PRINT_ERROR("Server received invalid data size: %d | %d", + response->metadata.data_length, + response_data_len + ); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + for (uint32_t i = 0; i < response->metadata.data_length; i++) { + uint8_t received_byte = *(uint8_t*)swiftnet_server_read_packet(response, 1); + if (response_data[i] != received_byte) { + PRINT_ERROR("Client received invalid data"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + } + + atomic_store_explicit(&g_test_result, 0, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + } +} + +int test_making_request(const union Args* args_ptr) { + const struct TestMakingRequestArgs args = args_ptr->test_making_request_args; + + SwiftNetServer* const server = swiftnet_create_server(8080, args.loopback); + if (server == NULL) { + PRINT_ERROR("Failed to create server"); + return -1; + } + + swiftnet_server_set_message_handler(server, on_server_packet); + + SwiftNetClientConnection* const client_conn = swiftnet_create_client(args.ip_address, 8080, 1000); + if (client_conn == NULL) { + PRINT_ERROR("Failed to create client connection"); + return -1; + } + + swiftnet_client_set_message_handler(client_conn, on_client_packet); + + atomic_store_explicit(&g_client_conn, client_conn, memory_order_release); + atomic_store_explicit(&g_server, server, memory_order_release); + + uint8_t* req_data = malloc(args.request_data_len); + if (!req_data) { + PRINT_ERROR("Failed to allocate memory"); + return -1; + } + + uint8_t* res_data = malloc(args.response_data_len); + if (!res_data) { + PRINT_ERROR("Failed to allocate memory"); + return -1; + } + + atomic_store_explicit(&g_request_data, req_data, memory_order_release); + atomic_store_explicit(&g_response_data, res_data, memory_order_release); + + atomic_store_explicit(&g_request_data_len, args.request_data_len, memory_order_release); + atomic_store_explicit(&g_response_data_len, args.response_data_len, memory_order_release); + + if (args.receiver == Server) { + SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(args.request_data_len); + + swiftnet_client_append_to_packet(req_data, args.request_data_len, &buffer); + + SwiftNetClientPacketData* const response = swiftnet_client_make_request(client_conn, &buffer, 1000); + + swiftnet_client_destroy_packet_buffer(&buffer); + + if (response == NULL) { + int result = atomic_load_explicit(&g_test_result, memory_order_acquire); + if (result != INT_MAX) { + return result; + } + + PRINT_ERROR("Did not receive response from server"); + + reset_test_state(); + + return -1; + } + + if (response->metadata.data_length != args.response_data_len) { + PRINT_ERROR("Client received invalid data size: %d | %d", + response->metadata.data_length, + args.response_data_len + ); + + swiftnet_client_destroy_packet_data(response, client_conn); + + reset_test_state(); + + return -1; + } + + for (uint32_t i = 0; i < response->metadata.data_length; i++) { + uint8_t received_byte = *(uint8_t*)swiftnet_client_read_packet(response, 1); + if (res_data[i] != received_byte) { + PRINT_ERROR("Client received invalid data"); + + swiftnet_client_destroy_packet_data(response, client_conn); + + reset_test_state(); + + return -1; + } + } + + swiftnet_client_destroy_packet_data(response, client_conn); + + wait_until_response_sent(); + + reset_test_state(); + + return 0; + } else { + SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(sizeof(g_make_request_code)); + + swiftnet_client_append_to_packet(&g_make_request_code, sizeof(g_make_request_code), &buffer); + + swiftnet_client_send_packet(client_conn, &buffer); + + swiftnet_client_destroy_packet_buffer(&buffer); + + for ( ;; ) { + int result = atomic_load_explicit(&g_test_result, memory_order_acquire); + if (result == INT_MAX) { + usleep(1000); + continue; + } + + if (result == 0) { + wait_until_response_sent(); + } + + reset_test_state(); + + return result; + } + } +} diff --git a/tests/src/run_tests.c b/tests/src/run_tests.c new file mode 100644 index 0000000..2d0d64b --- /dev/null +++ b/tests/src/run_tests.c @@ -0,0 +1,130 @@ +#include "run_tests.h" +#include "../../src/swift_net.h" +#include +#include + +int main() { + const struct Test tests[] = { + { + .function = test_sending_packet, + .args = {.test_sending_packet_args = { + .client_data_len = 50, + .server_data_len = 50, + .ip_address = "127.0.0.1", + .loopback = true + }}, + .test_name = "Test sending small packets" + }, + { + .function = test_sending_packet, + .args = {.test_sending_packet_args = { + .client_data_len = 0, + .server_data_len = 10000, + .ip_address = "127.0.0.1", + .loopback = true + }}, + .test_name = "Test client sending large packet" + }, + { + .function = test_sending_packet, + .args = {.test_sending_packet_args = { + .client_data_len = 10000, + .server_data_len = 10, + .ip_address = "127.0.0.1", + .loopback = true + }}, + .test_name = "Test server sending large packet" + }, + { + .function = test_making_request, + .args = {.test_making_request_args = { + .ip_address = "127.0.0.1", + .loopback = true, + .receiver = Server, + .request_data_len = 100, + .response_data_len = 100 + }}, + .test_name = "Test client making small request" + }, + { + .function = test_making_request, + .args = {.test_making_request_args = { + .ip_address = "127.0.0.1", + .loopback = true, + .receiver = Client, + .request_data_len = 100, + .response_data_len = 100 + }}, + .test_name = "Test server making small request" + }, + { + .function = test_making_request, + .args = {.test_making_request_args = { + .ip_address = "127.0.0.1", + .loopback = true, + .receiver = Client, + .request_data_len = 10000, + .response_data_len = 100 + }}, + .test_name = "Test server making large request" + }, + { + .function = test_making_request, + .args = {.test_making_request_args = { + .ip_address = "127.0.0.1", + .loopback = true, + .receiver = Server, + .request_data_len = 10000, + .response_data_len = 100 + }}, + .test_name = "Test client making large request" + }, + { + .function = test_making_request, + .args = {.test_making_request_args = { + .ip_address = "127.0.0.1", + .loopback = true, + .receiver = Client, + .request_data_len = 100, + .response_data_len = 10000 + }}, + .test_name = "Test client making large response" + }, + { + .function = test_making_request, + .args = {.test_making_request_args = { + .ip_address = "127.0.0.1", + .loopback = true, + .receiver = Server, + .request_data_len = 100, + .response_data_len = 10000 + }}, + .test_name = "Test server making large response" + }, + }; + + swiftnet_initialize(); + + swiftnet_add_debug_flags(DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS | DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING); + + for (uint16_t i = 0; i < sizeof(tests) / sizeof(struct Test); i++) { + const struct Test* current_test = &tests[i]; + + int result = current_test->function(¤t_test->args); + if (result != 0) { + PRINT_ERROR("Failed test: %s", current_test->test_name); + + swiftnet_cleanup(); + + return -1; + } + + printf("\033[32mSuccessfully completed test: %s\033[0m\n", current_test->test_name); + + continue; + } + + swiftnet_cleanup(); + + return 0; +} diff --git a/tests/src/run_tests.h b/tests/src/run_tests.h new file mode 100644 index 0000000..3ce1504 --- /dev/null +++ b/tests/src/run_tests.h @@ -0,0 +1,42 @@ +#pragma once + +#include +#include +#include + +#define PRINT_ERROR(error, ...) \ + printf("\033[31m" error "\033[0m\n", ##__VA_ARGS__) + +enum ConnectionType { + Server, + Client +}; + +struct TestSendingPacketArgs { + const char* ip_address; + const bool loopback; + const uint32_t client_data_len; + const uint32_t server_data_len; +}; + +struct TestMakingRequestArgs { + const char* ip_address; + const bool loopback; + const enum ConnectionType receiver; + const uint32_t request_data_len; + const uint32_t response_data_len; +}; + +union Args { + struct TestSendingPacketArgs test_sending_packet_args; + struct TestMakingRequestArgs test_making_request_args; +}; + +struct Test { + int (*function)(const union Args*); + const union Args args; + const char* test_name; +}; + +int test_sending_packet(const union Args* args_ptr); +int test_making_request(const union Args* args_ptr); diff --git a/tests/src/sending_packet.c b/tests/src/sending_packet.c new file mode 100644 index 0000000..3501682 --- /dev/null +++ b/tests/src/sending_packet.c @@ -0,0 +1,200 @@ +#include "../config.h" +#include +#include +#include +#include "../../src/swift_net.h" +#include +#include +#include +#include "run_tests.h" + +static _Atomic (SwiftNetClientConnection*) g_client_conn = NULL; +static _Atomic (SwiftNetServer*) g_server = NULL; + +static _Atomic bool g_client_send_done = false; +static _Atomic bool g_server_send_done = false; +static _Atomic int g_test_result = INT_MAX; + +static _Atomic (uint8_t*) g_client_data = NULL; +static _Atomic (uint8_t*) g_server_data = NULL; + +static _Atomic uint32_t g_client_data_len = 0; +static _Atomic uint32_t g_server_data_len = 0; + +static void reset_test_state() { + swiftnet_server_cleanup(atomic_load_explicit(&g_server, memory_order_acquire)); + swiftnet_client_cleanup(atomic_load_explicit(&g_client_conn, memory_order_acquire)); + + uint8_t* client_data = atomic_load_explicit(&g_client_data, memory_order_acquire); + uint8_t* server_data = atomic_load_explicit(&g_server_data, memory_order_acquire); + + if (client_data) free(client_data); + if (server_data) free(server_data); + + atomic_store_explicit(&g_client_send_done, false, memory_order_release); + atomic_store_explicit(&g_server_send_done, false, memory_order_release); + + atomic_store_explicit(&g_client_data, NULL, memory_order_release); + atomic_store_explicit(&g_server_data, NULL, memory_order_release); + + atomic_store_explicit(&g_client_data_len, 0, memory_order_release); + atomic_store_explicit(&g_server_data_len, 0, memory_order_release); + + atomic_store_explicit(&g_client_conn, NULL, memory_order_release); + atomic_store_explicit(&g_server, NULL, memory_order_release); + + atomic_store_explicit(&g_test_result, INT_MAX, memory_order_release); +} + +static void on_client_packet(SwiftNetClientPacketData* packet) { + SwiftNetClientConnection* const client_conn = atomic_load_explicit(&g_client_conn, memory_order_acquire); + + while (!atomic_load_explicit(&g_client_send_done, memory_order_acquire)) usleep(1000); + + if (packet->metadata.data_length != atomic_load_explicit(&g_client_data_len, memory_order_acquire)) { + PRINT_ERROR("Client received invalid data size: %d | %d", + packet->metadata.data_length, + atomic_load_explicit(&g_client_data_len, memory_order_acquire) + ); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_client_destroy_packet_data(packet, client_conn); + + return; + } + + const uint8_t* data = atomic_load_explicit(&g_client_data, memory_order_acquire); + + for (uint32_t i = 0; i < packet->metadata.data_length; i++) { + uint8_t received_byte = *(uint8_t*)swiftnet_client_read_packet(packet, 1); + if (data[i] != received_byte) { + PRINT_ERROR("Client received invalid data"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_client_destroy_packet_data(packet, client_conn); + + return; + } + } + + atomic_store_explicit(&g_test_result, 0, memory_order_release); + + swiftnet_client_destroy_packet_data(packet, client_conn); +} + +static void on_server_packet(SwiftNetServerPacketData* packet) { + SwiftNetServer* const server = atomic_load_explicit(&g_server, memory_order_acquire); + + while (!atomic_load_explicit(&g_server_send_done, memory_order_acquire)) usleep(1000); + + if (packet->metadata.data_length != atomic_load_explicit(&g_server_data_len, memory_order_acquire)) { + PRINT_ERROR("Server received invalid data size: %d | %d", + packet->metadata.data_length, + atomic_load_explicit(&g_server_data_len, memory_order_acquire) + ); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + + const uint8_t* data = atomic_load_explicit(&g_server_data, memory_order_acquire); + + for (uint32_t i = 0; i < packet->metadata.data_length; i++) { + uint8_t byte_received = *(uint8_t*)swiftnet_server_read_packet(packet, 1); + if (data[i] != byte_received) { + PRINT_ERROR("Server received invalid data"); + + atomic_store_explicit(&g_test_result, -1, memory_order_release); + + swiftnet_server_destroy_packet_data(packet, server); + + return; + } + } + + if (atomic_load_explicit(&g_client_data_len, memory_order_acquire) != 0) { + uint32_t size = atomic_load_explicit(&g_client_data_len, memory_order_acquire); + uint8_t* send_data = atomic_load_explicit(&g_client_data, memory_order_acquire); + + SwiftNetPacketBuffer buf = swiftnet_server_create_packet_buffer(size); + swiftnet_server_append_to_packet(send_data, size, &buf); + swiftnet_server_send_packet(atomic_load_explicit(&g_server, memory_order_acquire), &buf, packet->metadata.sender); + swiftnet_server_destroy_packet_buffer(&buf); + + atomic_store_explicit(&g_client_send_done, true, memory_order_release); + } else { + atomic_store_explicit(&g_test_result, 0, memory_order_release); + } + + swiftnet_server_destroy_packet_data(packet, server); +} + +int test_sending_packet(const union Args* args_ptr) { + const struct TestSendingPacketArgs args = args_ptr->test_sending_packet_args; + + SwiftNetServer* const server = swiftnet_create_server(8080, args.loopback); + if (server == NULL) { + PRINT_ERROR("Failed to create server"); + return -1; + } + + swiftnet_server_set_message_handler(server, on_server_packet); + + SwiftNetClientConnection* const client_conn = swiftnet_create_client(args.ip_address, 8080, 1000); + if (client_conn == NULL) { + PRINT_ERROR("Failed to create client connection"); + return -1; + } + + swiftnet_client_set_message_handler(client_conn, on_client_packet); + + atomic_store_explicit(&g_client_conn, client_conn, memory_order_release); + atomic_store_explicit(&g_server, server, memory_order_release); + + g_client_data_len = args.client_data_len; + g_server_data_len = args.server_data_len; + + uint8_t* c_data = malloc(args.client_data_len); + if (!c_data) { + PRINT_ERROR("Failed to allocate memory"); + return -1; + } + + for (uint32_t i = 0; i < args.client_data_len; i++) c_data[i] = rand(); + + atomic_store_explicit(&g_client_data, c_data, memory_order_release); + + if (args.server_data_len != 0) { + uint8_t* s_data = malloc(args.server_data_len); + if (!s_data) { + PRINT_ERROR("Failed to allocate memory"); + return -1; + } + + for (uint32_t i = 0; i < args.server_data_len; i++) s_data[i] = rand(); + + atomic_store_explicit(&g_server_data, s_data, memory_order_release); + } + + SwiftNetPacketBuffer buf = swiftnet_client_create_packet_buffer(args.server_data_len); + swiftnet_client_append_to_packet(atomic_load_explicit(&g_server_data, memory_order_acquire), args.server_data_len, &buf); + swiftnet_client_send_packet(client_conn, &buf); + swiftnet_client_destroy_packet_buffer(&buf); + + atomic_store_explicit(&g_server_send_done, true, memory_order_release); + + for ( ;; ) { + int result = atomic_load_explicit(&g_test_result, memory_order_acquire); + if (result == INT_MAX) { + usleep(1000); + continue; + } + reset_test_state(); + return result; + } +} diff --git a/tests/src/test_basic_client_server_communication.c b/tests/src/test_basic_client_server_communication.c deleted file mode 100644 index 26b609c..0000000 --- a/tests/src/test_basic_client_server_communication.c +++ /dev/null @@ -1,86 +0,0 @@ -#include "../../src/swift_net.h" -#include -#include -#include -#include -#include -#include "../config.h" - -SwiftNetServer* server; -SwiftNetClientConnection* client; - -const char* const message = "hello"; - -void client_message_handler(SwiftNetClientPacketData* const packet_data) { - uint8_t* data = swiftnet_client_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - } else { - fprintf(stderr, "Invalid data received\n"); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - }; -} - -void server_message_handler(SwiftNetServerPacketData* const packet_data) { - uint8_t* data = swiftnet_server_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(strlen(message)); - - swiftnet_server_append_to_packet(message, strlen(message), &buffer); - - swiftnet_server_send_packet(server, &buffer, packet_data->metadata.sender); - - swiftnet_server_destroy_packet_buffer(&buffer); - } else { - fprintf(stderr, "Invalid data received\n"); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - }; -} - -int main() { - swiftnet_add_debug_flags(DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING | DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS); - - swiftnet_initialize(); - - server = swiftnet_create_server(8080, LOOPBACK); - swiftnet_server_set_message_handler(server, server_message_handler); - - client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); - swiftnet_client_set_message_handler(client, client_message_handler); - - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(strlen(message)); - - swiftnet_client_append_to_packet(message, strlen(message), &buffer); - - swiftnet_client_send_packet(client, &buffer); - - swiftnet_client_destroy_packet_buffer(&buffer); - - usleep(10000000); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - return -1; -} diff --git a/tests/src/test_client_making_requests.c b/tests/src/test_client_making_requests.c deleted file mode 100644 index 537cd49..0000000 --- a/tests/src/test_client_making_requests.c +++ /dev/null @@ -1,99 +0,0 @@ -#include "../../src/swift_net.h" -#include "../config.h" -#include -#include -#include -#include -#include - -SwiftNetServer* server; -SwiftNetClientConnection* client; - -const char* const message = "hello"; - -void client_message_handler(SwiftNetClientPacketData* const packet_data) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); -} - -void server_message_handler(SwiftNetServerPacketData* const packet_data) { - uint8_t* data = swiftnet_server_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(strlen(message)); - - swiftnet_server_append_to_packet(message, strlen(message), &buffer); - - swiftnet_server_make_response(server, packet_data, &buffer); - - swiftnet_server_destroy_packet_buffer(&buffer); - } else { - printf("Invalid Data Received\n"); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - }; -} - -int main() { - swiftnet_add_debug_flags(DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING | DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS); - - swiftnet_initialize(); - - server = swiftnet_create_server(8080, LOOPBACK); - swiftnet_server_set_message_handler(server, server_message_handler); - - client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); - swiftnet_client_set_message_handler(client, client_message_handler); - - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(strlen(message)); - - swiftnet_client_append_to_packet(message, strlen(message), &buffer); - - SwiftNetClientPacketData* packet_data = swiftnet_client_make_request(client, &buffer, 5000); - if (packet_data == NULL) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } - - swiftnet_client_destroy_packet_buffer(&buffer); - - if (packet_data->metadata.data_length != strlen(message)) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } - - uint8_t* const data = swiftnet_client_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - } else { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } -} diff --git a/tests/src/test_client_sending_large_packet_to_server.c b/tests/src/test_client_sending_large_packet_to_server.c deleted file mode 100644 index e6beac0..0000000 --- a/tests/src/test_client_sending_large_packet_to_server.c +++ /dev/null @@ -1,89 +0,0 @@ -#include "../../src/swift_net.h" - -#include -#include -#include -#include -#include "../config.h" - -#define DATA_TO_SEND 100000 - -SwiftNetClientConnection* client; -SwiftNetServer* server; - -_Atomic bool finished_sending = false; - -uint8_t* random_generated_data = NULL; - -void client_message_handler(SwiftNetClientPacketData* const packet_data) { -} - -void server_message_handler(SwiftNetServerPacketData* const packet_data) { - while (atomic_load(&finished_sending) == false) { - usleep(1000); - } - - for(uint32_t i = 0; i < packet_data->metadata.data_length / 1; i++) { - const uint8_t data_received = *(uint8_t*)swiftnet_server_read_packet(packet_data, 1); - - if(random_generated_data[i] != data_received) { - fprintf(stderr, "invalid byte at index: %d\ndata received: %d\ndata sent: %d\n", i, data_received, random_generated_data[i]); - fflush(stdout); - fflush(stderr); - abort(); - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - free(random_generated_data); - swiftnet_cleanup(); - } - } - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - free(random_generated_data); - swiftnet_cleanup(); - exit(EXIT_SUCCESS); -} - -int main() { - swiftnet_add_debug_flags(DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING | DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS); - - random_generated_data = malloc(DATA_TO_SEND); - if (random_generated_data == NULL) { - fprintf(stderr, "failed to allocate memory\n"); - return EXIT_FAILURE; - } - - for(uint32_t i = 0; i < DATA_TO_SEND / 1; i++) { - random_generated_data[i] = rand(); - } - - swiftnet_initialize(); - - server = swiftnet_create_server(8080, LOOPBACK); - swiftnet_server_set_message_handler(server, server_message_handler); - - client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); - swiftnet_client_set_message_handler(client, client_message_handler); - - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(DATA_TO_SEND); - - swiftnet_client_append_to_packet(random_generated_data, DATA_TO_SEND, &buffer); - - swiftnet_client_send_packet(client, &buffer); - - swiftnet_client_destroy_packet_buffer(&buffer); - - atomic_store(&finished_sending, true); - - usleep(10000000); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - free(random_generated_data); - - swiftnet_cleanup(); - - return EXIT_FAILURE; -} diff --git a/tests/src/test_multiple_server_communication.c b/tests/src/test_multiple_server_communication.c deleted file mode 100644 index e689438..0000000 --- a/tests/src/test_multiple_server_communication.c +++ /dev/null @@ -1,122 +0,0 @@ -#include "../../src/swift_net.h" -#include -#include -#include -#include -#include -#include -#include -#include "../config.h" - -#define MAX_ITERATIONS 5000 - -SwiftNetServer* server; -SwiftNetClientConnection* client; - -SwiftNetServer* second_server; -SwiftNetClientConnection* second_client; - -#define FIRST_PORT 7070 -#define SECOND_PORT 8080 - -_Atomic bool first_port_response = false; -_Atomic bool second_port_response = false; - -const char* const message = "hello"; - -void client_message_handler(SwiftNetClientPacketData* const packet_data) { - uint8_t* data = swiftnet_client_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - if (packet_data->metadata.port_info.source_port == FIRST_PORT) { - atomic_store(&first_port_response, true); - } else if (packet_data->metadata.port_info.source_port == SECOND_PORT) { - atomic_store(&second_port_response, true); - } - } -} - -void server_message_handler(SwiftNetServerPacketData* const packet_data) { - uint8_t* data = swiftnet_server_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(strlen(message)); - - SwiftNetServer* srvr = NULL; - if (packet_data->metadata.port_info.destination_port == FIRST_PORT) { - srvr = server; - } else if (packet_data->metadata.port_info.destination_port == SECOND_PORT) { - srvr = second_server; - } - - swiftnet_server_append_to_packet(message, strlen(message), &buffer); - - swiftnet_server_send_packet(srvr, &buffer, packet_data->metadata.sender); - - swiftnet_server_destroy_packet_buffer(&buffer); - }; -} - -int main() { - swiftnet_add_debug_flags(DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING | DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS); - - swiftnet_initialize(); - - server = swiftnet_create_server(FIRST_PORT, LOOPBACK); - swiftnet_server_set_message_handler(server, server_message_handler); - - client = swiftnet_create_client(IP_ADDRESS, FIRST_PORT, 2000); - swiftnet_client_set_message_handler(client, client_message_handler); - - second_server = swiftnet_create_server(SECOND_PORT, LOOPBACK); - swiftnet_server_set_message_handler(second_server, server_message_handler); - - second_client = swiftnet_create_client(IP_ADDRESS, SECOND_PORT, 2000); - swiftnet_client_set_message_handler(second_client, client_message_handler); - - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(strlen(message)); - - swiftnet_client_append_to_packet(message, strlen(message), &buffer); - - swiftnet_client_send_packet(client, &buffer); - - swiftnet_client_destroy_packet_buffer(&buffer); - - SwiftNetPacketBuffer second_buffer = swiftnet_client_create_packet_buffer(strlen(message)); - - swiftnet_client_append_to_packet(message, strlen(message), &second_buffer); - - swiftnet_client_send_packet(second_client, &second_buffer); - - swiftnet_client_destroy_packet_buffer(&second_buffer); - - uint32_t iterations = 0; - - while (atomic_load(&first_port_response) == false || atomic_load(&second_port_response) == false) { - iterations++; - - if (iterations >= MAX_ITERATIONS) { - swiftnet_server_cleanup(server); - swiftnet_server_cleanup(second_server); - - swiftnet_client_cleanup(client); - swiftnet_client_cleanup(second_client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } - - usleep(1000); - } - - swiftnet_server_cleanup(server); - swiftnet_server_cleanup(second_server); - - swiftnet_client_cleanup(client); - swiftnet_client_cleanup(second_client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); -} diff --git a/tests/src/test_server_making_requests.c b/tests/src/test_server_making_requests.c deleted file mode 100644 index efceaf8..0000000 --- a/tests/src/test_server_making_requests.c +++ /dev/null @@ -1,107 +0,0 @@ -#include "../../src/swift_net.h" -#include "../config.h" -#include -#include -#include -#include -#include - -SwiftNetServer* server; -SwiftNetClientConnection* client; - -const char* const message = "hello"; - -void client_message_handler(SwiftNetClientPacketData* const packet_data) { - uint8_t* data = swiftnet_client_read_packet(packet_data, packet_data->metadata.data_length); - - if(memcmp(data, message, packet_data->metadata.data_length) == 0) { - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(strlen(message)); - - swiftnet_client_append_to_packet(message, strlen(message), &buffer); - - swiftnet_client_make_response(client, packet_data, &buffer); - - swiftnet_client_destroy_packet_buffer(&buffer); - } else { - printf("Invalid Data Received\n"); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - }; -} - -void server_message_handler(SwiftNetServerPacketData* const packet_data) { - SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(strlen(message)); - - swiftnet_server_append_to_packet(message, strlen(message), &buffer); - - SwiftNetServerPacketData* response = swiftnet_server_make_request(server, &buffer, packet_data->metadata.sender, 5000); - if (response == NULL) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } - - swiftnet_server_destroy_packet_buffer(&buffer); - - if (response->metadata.data_length != strlen(message)) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } - - uint8_t* data = swiftnet_server_read_packet(response, response->metadata.data_length); - - if(memcmp(data, message, response->metadata.data_length) == 0) { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_SUCCESS); - } else { - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); - } -} - -int main() { - swiftnet_add_debug_flags(DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING | DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS); - - swiftnet_initialize(); - - server = swiftnet_create_server(8080, LOOPBACK); - swiftnet_server_set_message_handler(server, server_message_handler); - - client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); - swiftnet_client_set_message_handler(client, client_message_handler); - - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(strlen(message)); - - swiftnet_client_append_to_packet(message, strlen(message), &buffer); - - swiftnet_client_send_packet(client, &buffer); - - usleep(10000000); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - exit(EXIT_FAILURE); -} diff --git a/tests/src/test_server_sending_large_packet_to_client.c b/tests/src/test_server_sending_large_packet_to_client.c deleted file mode 100644 index e8fd1c4..0000000 --- a/tests/src/test_server_sending_large_packet_to_client.c +++ /dev/null @@ -1,98 +0,0 @@ -#include "../../src/swift_net.h" - -#include -#include -#include -#include -#include "../config.h" - -#define DATA_TO_SEND 100000 - -SwiftNetClientConnection* client; -SwiftNetServer* server; - -uint8_t* random_generated_data = NULL; - -_Atomic bool finished = false; - -#define REQUEST_SEND_LARGE_PACKET 0xFF - -void client_message_handler(SwiftNetClientPacketData* const packet_data) { - while (atomic_load(&finished) == false) { - usleep(1000); - } - - for(uint32_t i = 0; i < packet_data->metadata.data_length; i++) { - if(random_generated_data[i] != packet_data->data[i]) { - fprintf(stderr, "invalid byte at index: %d\ndata received: %d\ndata sent: %d\n", i, packet_data->data[i], random_generated_data[i]); - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - free(random_generated_data); - swiftnet_cleanup(); - exit(EXIT_FAILURE); - } - } - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - free(random_generated_data); - swiftnet_cleanup(); - exit(EXIT_SUCCESS); -} - -void server_message_handler(SwiftNetServerPacketData* const packet_data) { - if (packet_data->data[0] == REQUEST_SEND_LARGE_PACKET) { - SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(DATA_TO_SEND); - - swiftnet_server_append_to_packet(random_generated_data, DATA_TO_SEND, &buffer); - - swiftnet_server_send_packet(server, &buffer, packet_data->metadata.sender); - - atomic_store(&finished, true); - - swiftnet_server_destroy_packet_buffer(&buffer); - } -} - -int main() { - swiftnet_add_debug_flags(DEBUG_PACKETS_RECEIVING | DEBUG_PACKETS_SENDING | DEBUG_INITIALIZATION | DEBUG_LOST_PACKETS); - - random_generated_data = malloc(DATA_TO_SEND); - if (random_generated_data == NULL) { - fprintf(stderr, "failed to allocate memory\n"); - return EXIT_FAILURE; - } - - for(uint32_t i = 0; i < DATA_TO_SEND; i++) { - random_generated_data[i] = rand(); - } - - swiftnet_initialize(); - - server = swiftnet_create_server(8080, LOOPBACK); - swiftnet_server_set_message_handler(server, server_message_handler); - - client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); - swiftnet_client_set_message_handler(client, client_message_handler); - - const uint8_t message = REQUEST_SEND_LARGE_PACKET; - - SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(sizeof(message)); - - swiftnet_client_append_to_packet(&message, sizeof(message), &buffer); - - swiftnet_client_send_packet(client, &buffer); - - swiftnet_client_destroy_packet_buffer(&buffer); - - usleep(10000000); - - swiftnet_server_cleanup(server); - swiftnet_client_cleanup(client); - - swiftnet_cleanup(); - - free(random_generated_data); - - return EXIT_FAILURE; -}