diff --git a/build/cmake/deadlightreal-swiftnetConfigVersion.cmake b/build/cmake/deadlightreal-swiftnetConfigVersion.cmake index a445dd1..9d50123 100644 --- a/build/cmake/deadlightreal-swiftnetConfigVersion.cmake +++ b/build/cmake/deadlightreal-swiftnetConfigVersion.cmake @@ -7,7 +7,7 @@ # PACKAGE_VERSION_COMPATIBLE if the current version is >= requested version. # The variable CVF_VERSION must be set before calling configure_file(). -set(PACKAGE_VERSION "1.0.0") +set(PACKAGE_VERSION "0.1.0") if (PACKAGE_FIND_VERSION_RANGE) # Package version must be in the requested version range diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 9e43fe2..c5bcaff 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required(VERSION 3.10) -project(SwiftNet C CXX) +project(swiftnet C CXX) include(GNUInstallDirs) @@ -23,9 +23,12 @@ set(SOURCE_FILES make_response.c make_request.c internal/get_mtu.c - internal/get_default_interface.c + internal/get_default_interface_and_mac.c internal/datatype_allocator.c internal/datatype_vector.c + internal/pcap_open.c + internal/pcap_send.c + internal/check_existing_listener.c ) if(SANITIZER STREQUAL "address") diff --git a/src/cleanup.c b/src/cleanup.c index 75458ce..801d91b 100644 --- a/src/cleanup.c +++ b/src/cleanup.c @@ -1,5 +1,6 @@ #include "internal/internal.h" #include "swift_net.h" +#include void swiftnet_cleanup() { allocator_destroy(&packet_queue_node_memory_allocator); @@ -7,11 +8,32 @@ void swiftnet_cleanup() { allocator_destroy(&server_packet_data_memory_allocator); allocator_destroy(&client_packet_data_memory_allocator); allocator_destroy(&packet_buffer_memory_allocator); - allocator_destroy(&server_memory_allocator); #ifdef SWIFT_NET_REQUESTS allocator_destroy(&requests_sent_memory_allocator); vector_destroy(&requests_sent); #endif + + vector_lock(&listeners); + + for (uint16_t i = 0; i < listeners.size; i++) { + Listener* const current_listener = vector_get(&listeners, i); + + pcap_breakloop(current_listener->pcap); + + pthread_join(current_listener->listener_thread, NULL); + + pcap_close(current_listener->pcap); + + vector_destroy(¤t_listener->client_connections); + vector_destroy(¤t_listener->servers); + } + + vector_destroy(&listeners); + + allocator_destroy(&server_memory_allocator); + allocator_destroy(&client_connection_memory_allocator); + + allocator_destroy(&listener_memory_allocator); } diff --git a/src/cleanup_connection.c b/src/cleanup_connection.c index 7306a6a..7a8a572 100644 --- a/src/cleanup_connection.c +++ b/src/cleanup_connection.c @@ -14,13 +14,10 @@ void swiftnet_client_cleanup(SwiftNetClientConnection* const client) { atomic_store_explicit(&client->closing, true, memory_order_release); - shutdown(client->sockfd, SHUT_RD); + pthread_join(client->process_packets_thread, NULL); + pthread_join(client->execute_callback_thread, NULL); - close(client->sockfd); - - pthread_detach(client->handle_packets_thread); - pthread_detach(client->process_packets_thread); - pthread_detach(client->execute_callback_thread); + pcap_close(client->pcap); allocator_free(&client_connection_memory_allocator, client); } @@ -36,11 +33,10 @@ void swiftnet_server_cleanup(SwiftNetServer* const server) { atomic_store_explicit(&server->closing, true, memory_order_release); - close(server->sockfd); + pthread_join(server->process_packets_thread, NULL); + pthread_join(server->execute_callback_thread, NULL); - pthread_detach(server->handle_packets_thread); - pthread_detach(server->process_packets_thread); - pthread_detach(server->execute_callback_thread); + pcap_close(server->pcap); allocator_free(&server_memory_allocator, server); } diff --git a/src/create_packet_buffer.c b/src/create_packet_buffer.c index 8d6380c..4344904 100644 --- a/src/create_packet_buffer.c +++ b/src/create_packet_buffer.c @@ -4,9 +4,9 @@ #include static inline SwiftNetPacketBuffer create_packet_buffer(const uint32_t buffer_size) { - uint8_t* const mem = malloc(buffer_size + PACKET_HEADER_SIZE); + uint8_t* const mem = malloc(buffer_size + PACKET_HEADER_SIZE + sizeof(struct ether_header)); - uint8_t* const data_pointer = mem + PACKET_HEADER_SIZE; + uint8_t* const data_pointer = mem + PACKET_HEADER_SIZE + sizeof(struct ether_header); return (SwiftNetPacketBuffer){ .packet_buffer_start = mem, diff --git a/src/execute_packet_callback.c b/src/execute_packet_callback.c index 6026f94..bb2f342 100644 --- a/src/execute_packet_callback.c +++ b/src/execute_packet_callback.c @@ -58,7 +58,7 @@ void execute_packet_callback(PacketCallbackQueue* const queue, void (* const _At 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 == node->pending_message->packet_id) || (connection_type == CONNECTION_TYPE_SERVER && pending_message->sender_address == ((SwiftNetServerPacketData*)node->packet_data)->metadata.sender.sender_address.sin_addr.s_addr && pending_message->packet_id == node->pending_message->packet_id)) { + if (pending_message == node->pending_message) { vector_remove(pending_messages, i); } } diff --git a/src/handle_packets.c b/src/handle_packets.c index f7b4408..094f17c 100644 --- a/src/handle_packets.c +++ b/src/handle_packets.c @@ -1,6 +1,7 @@ #include "swift_net.h" #include #include +#include #include #include #include @@ -36,59 +37,143 @@ static inline void insert_queue_node(PacketQueueNode* const new_node, volatile P return; } -static inline void swiftnet_handle_packets(const int sockfd, const uint16_t source_port, pthread_t* const process_packets_thread, void* connection, const ConnectionType connection_type, PacketQueue* const packet_queue, const _Atomic bool* closing) { - while(1) { - if (atomic_load_explicit(closing, memory_order_acquire) == true) { - break; - } +static inline void swiftnet_handle_packets(const uint16_t source_port, pthread_t* const process_packets_thread, void* connection, const ConnectionType connection_type, PacketQueue* const packet_queue, const _Atomic bool* closing, const bool loopback, const uint16_t addr_type, const struct pcap_pkthdr* hdr, const uint8_t* packet) { + PacketQueueNode *node = allocator_allocate(&packet_queue_node_memory_allocator); + if (unlikely(node == NULL)) { + return; + } - PacketQueueNode* const node = allocator_allocate(&packet_queue_node_memory_allocator); - if(unlikely(node == NULL)) { - continue; - } + uint8_t *packet_buffer = allocator_allocate(&packet_buffer_memory_allocator); + if (unlikely(packet_buffer == NULL)) { + allocator_free(&packet_queue_node_memory_allocator, node); + return; + } - node->server_address_length = sizeof(node->sender_address); + uint32_t len = hdr->caplen; + memcpy(packet_buffer, packet, len); - uint8_t* const packet_buffer = allocator_allocate(&packet_buffer_memory_allocator); - if(unlikely(packet_buffer == NULL)) { - allocator_free(&packet_queue_node_memory_allocator, node); - continue; - } + if (len == 0) { + allocator_free(&packet_queue_node_memory_allocator, node); + allocator_free(&packet_buffer_memory_allocator, packet_buffer); + return; + } - const int received_sucessfully = recvfrom(sockfd, packet_buffer, maximum_transmission_unit, 0, (struct sockaddr *)&node->sender_address, &node->server_address_length); - - if(received_sucessfully < 0) { + if (addr_type == DLT_EN10MB) { + struct ether_header *eth = (struct ether_header *)packet_buffer; + + if (ntohs(eth->ether_type) == ETHERTYPE_IP) { + struct ip *ip_header = (struct ip *)(packet_buffer + sizeof(struct ether_header)); + + node->sender_address = ip_header->ip_src; + } else { allocator_free(&packet_queue_node_memory_allocator, node); allocator_free(&packet_buffer_memory_allocator, packet_buffer); - continue; + return; } + } + + node->data_read = len; + node->data = packet_buffer; + node->next = NULL; + + node->server_address_length = sizeof(node->sender_address); + + atomic_thread_fence(memory_order_release); + + insert_queue_node(node, packet_queue, connection_type); +} + +static void handle_client_init(SwiftNetClientConnection* user, const struct pcap_pkthdr* hdr, const uint8_t* buffer) { + SwiftNetClientConnection* const client_connection = (SwiftNetClientConnection*)user; - struct in_addr sender_addr; - memcpy(&sender_addr, &packet_buffer[offsetof(struct ip, ip_src)], sizeof(struct in_addr)); + if (atomic_load_explicit(&client_connection->closing, memory_order_acquire) == true) { + return; + } - node->data_read = received_sucessfully; - node->data = packet_buffer; - node->sender_address.sin_addr = sender_addr; - node->next = NULL; + const uint32_t bytes_received = hdr->caplen; - atomic_thread_fence(memory_order_release); + if(bytes_received != PACKET_HEADER_SIZE + sizeof(SwiftNetServerInformation) + client_connection->prepend_size) { + #ifdef SWIFT_NET_DEBUG + if (check_debug_flag(DEBUG_INITIALIZATION)) { + send_debug_message("Invalid packet received from server. Expected server information: {\"bytes_received\": %u, \"expected_bytes\": %u}\n", bytes_received, PACKET_HEADER_SIZE + sizeof(SwiftNetServerInformation)); + } + #endif - insert_queue_node(node, packet_queue, connection_type); + return; } + + struct ip* ip_header = (struct ip*)(buffer + client_connection->prepend_size); + SwiftNetPacketInfo* packet_info = (SwiftNetPacketInfo*)(buffer + client_connection->prepend_size + sizeof(struct ip)); + SwiftNetServerInformation* server_information = (SwiftNetServerInformation*)(buffer + client_connection->prepend_size + sizeof(struct ip) + sizeof(SwiftNetPacketInfo)); + + if(packet_info->port_info.destination_port != client_connection->port_info.source_port || packet_info->port_info.source_port != client_connection->port_info.destination_port) { + #ifdef SWIFT_NET_DEBUG + if (check_debug_flag(DEBUG_INITIALIZATION)) { + send_debug_message("Port info does not match: {\"destination_port\": %d, \"source_port\": %d, \"source_ip_address\": \"%s\"}\n", packet_info->port_info.destination_port, packet_info->port_info.source_port, inet_ntoa(ip_header->ip_src)); + } + #endif + + return; + } + + if(packet_info->packet_type != PACKET_TYPE_REQUEST_INFORMATION) { + #ifdef SWIFT_NET_DEBUG + if (check_debug_flag(DEBUG_INITIALIZATION)) { + send_debug_message("Invalid packet type: {\"packet_type\": %d}\n", packet_info->packet_type); + } + #endif + return; + } + + client_connection->maximum_transmission_unit = server_information->maximum_transmission_unit; + + atomic_store_explicit(&client_connection->initialized, true, memory_order_release); } -void* swiftnet_client_handle_packets(void* const client_void) { - SwiftNetClientConnection* const client = (SwiftNetClientConnection*)client_void; +static void pcap_packet_handle(uint8_t* user, const struct pcap_pkthdr* hdr, const uint8_t* packet) { + Listener* const listener = (Listener*)user; - swiftnet_handle_packets(client->sockfd, client->port_info.source_port, &client->process_packets_thread, client, CONNECTION_TYPE_CLIENT, &client->packet_queue, &client->closing); + SwiftNetPortInfo* const port_info = (SwiftNetPortInfo*)(packet + PACKET_PREPEND_SIZE(listener->addr_type) + sizeof(struct ip) + offsetof(SwiftNetPacketInfo, port_info)); - return NULL; + vector_lock(&listener->servers); + + for (uint16_t i = 0; i < listener->servers.size; i++) { + SwiftNetServer* const server = vector_get(&listener->servers, i); + if (server->server_port == port_info->destination_port) { + vector_unlock(&listener->servers); + + swiftnet_handle_packets(server->server_port, &server->process_packets_thread, server, CONNECTION_TYPE_SERVER, &server->packet_queue, &server->closing, server->loopback, server->addr_type, hdr, packet); + + return; + } + } + + vector_unlock(&listener->servers); + + vector_lock(&listener->client_connections); + + for (uint16_t i = 0; i < listener->client_connections.size; i++) { + SwiftNetClientConnection* const client_connection = vector_get(&listener->client_connections, i); + if (client_connection->port_info.source_port == port_info->destination_port) { + vector_unlock(&listener->client_connections); + + if (client_connection->initialized == false) { + handle_client_init(client_connection, hdr, packet); + } else { + swiftnet_handle_packets(client_connection->port_info.source_port, &client_connection->process_packets_thread, client_connection, CONNECTION_TYPE_CLIENT, &client_connection->packet_queue, &client_connection->closing, client_connection->loopback, client_connection->addr_type, hdr, packet); + } + + return; + } + } + + vector_unlock(&listener->client_connections); } -void* swiftnet_server_handle_packets(void* const server_void) { - SwiftNetServer* const server = (SwiftNetServer*)server_void; +void* interface_start_listening(void* listener_void) { + Listener* listener = listener_void; - swiftnet_handle_packets(server->sockfd, server->server_port, &server->process_packets_thread, server, CONNECTION_TYPE_SERVER, &server->packet_queue, &server->closing); + pcap_loop(listener->pcap, 0, pcap_packet_handle, listener_void); return NULL; } diff --git a/src/initialize_client_socket.c b/src/initialize_client_socket.c index 4d2aa1e..3ce4ab1 100644 --- a/src/initialize_client_socket.c +++ b/src/initialize_client_socket.c @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -16,17 +17,15 @@ #include #include #include - -static _Atomic bool exit_thread = false; -static _Atomic bool timeout_reached = false; +#include typedef struct { - const int sockfd; + pcap_t* pcap; const void* const data; const uint32_t size; - const struct sockaddr_in server_addr; - const socklen_t server_addr_len; + const struct in_addr server_addr; const uint32_t timeout_ms; + SwiftNetClientConnection* const connection; } RequestServerInformationArgs; void* request_server_information(void* const request_server_information_args_void) { @@ -44,48 +43,53 @@ void* request_server_information(void* const request_server_information_args_voi uint32_t end = (uint32_t)tv.tv_sec * 1000 + tv.tv_usec / 1000; if (end > start + request_server_information_args->timeout_ms) { - atomic_store_explicit(&timeout_reached, true, memory_order_release); - break; } - if(atomic_load(&exit_thread) == true) { - atomic_store(&exit_thread, false); - + if(atomic_load_explicit(&request_server_information_args->connection->initialized, memory_order_acquire) == true) { return NULL; } #ifdef SWIFT_NET_DEBUG if (check_debug_flag(DEBUG_INITIALIZATION)) { - send_debug_message("Requested server information: {\"server_ip_address\": \"%s\"}\n", inet_ntoa(request_server_information_args->server_addr.sin_addr)); + send_debug_message("Requested server information: {\"server_ip_address\": \"%s\"}\n", inet_ntoa(request_server_information_args->server_addr)); } #endif - sendto(request_server_information_args->sockfd, request_server_information_args->data, request_server_information_args->size, 0, (struct sockaddr *)&request_server_information_args->server_addr, request_server_information_args->server_addr_len); + swiftnet_pcap_send(request_server_information_args->pcap, request_server_information_args->data, request_server_information_args->size); - usleep(100000); + usleep(250000); } return NULL; } + + SwiftNetClientConnection* swiftnet_create_client(const char* const ip_address, const uint16_t port, const uint32_t timeout_ms) { SwiftNetClientConnection* const new_connection = allocator_allocate(&client_connection_memory_allocator); - new_connection->sockfd = socket(AF_INET, SOCK_RAW, PROTOCOL_NUMBER); - if(unlikely(new_connection->sockfd < 0)) { - fprintf(stderr, "Socket creation failed\n"); - exit(EXIT_FAILURE); - } + struct in_addr addr; + inet_aton(ip_address, &addr); + const uint32_t ip = ntohl(addr.s_addr); + const bool loopback = (ip >> 24) == 127; - const int on = 1; - if(setsockopt(new_connection->sockfd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) { - fprintf(stderr, "Failed to set sockopt IP_HDRINCL\n"); + new_connection->loopback = loopback; + + new_connection->pcap = swiftnet_pcap_open(loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface); + if (new_connection->pcap == NULL) { + fprintf(stderr, "Failed to open bpf\n"); exit(EXIT_FAILURE); } - + + new_connection->addr_type = pcap_datalink(new_connection->pcap); + const uint16_t clientPort = rand(); + const uint8_t prepend_size = PACKET_PREPEND_SIZE(new_connection->addr_type); + + new_connection->prepend_size = prepend_size; + new_connection->packet_queue = (PacketQueue){ .first_node = NULL, .last_node = NULL @@ -100,15 +104,7 @@ SwiftNetClientConnection* swiftnet_create_client(const char* const ip_address, c new_connection->packet_handler = NULL; - new_connection->server_addr = (struct sockaddr_in){ - .sin_family = AF_INET, - .sin_port = htons(port), - .sin_addr = {.s_addr = inet_addr(ip_address)}, - .sin_zero = 0 - #ifdef MACOS - , .sin_len = 0 - #endif - }; + new_connection->server_addr.s_addr = inet_addr(ip_address); // Request the server information, and proccess it const SwiftNetPacketInfo request_server_information_packet_info = construct_packet_info( @@ -119,90 +115,65 @@ SwiftNetClientConnection* swiftnet_create_client(const char* const ip_address, c new_connection->port_info ); - const struct ip request_server_info_ip_header = construct_ip_header(new_connection->server_addr.sin_addr, PACKET_HEADER_SIZE, rand()); + struct ether_header eth_header = { + .ether_dhost = {0xff,0xff,0xff,0xff,0xff,0xff}, + .ether_type = htons(0x0800) + }; + + memcpy(eth_header.ether_shost, mac_address, sizeof(eth_header.ether_shost)); - uint8_t request_server_info_buffer[PACKET_HEADER_SIZE]; + new_connection->eth_header = eth_header; - memcpy(request_server_info_buffer, &request_server_info_ip_header, sizeof(struct ip)); - memcpy(request_server_info_buffer + sizeof(struct ip), &request_server_information_packet_info, sizeof(SwiftNetPacketInfo)); + const struct ip request_server_info_ip_header = construct_ip_header(new_connection->server_addr, PACKET_HEADER_SIZE, rand()); - const uint16_t checksum = crc16(request_server_info_buffer, sizeof(request_server_info_buffer)); + HANDLE_PACKET_CONSTRUCTION(&request_server_info_ip_header, &request_server_information_packet_info, new_connection->addr_type, ð_header, PACKET_HEADER_SIZE + prepend_size, request_server_info_buffer) - memcpy(request_server_info_buffer + offsetof(struct ip, ip_sum), &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(request_server_info_buffer, sizeof(request_server_info_buffer), prepend_size) memset(&new_connection->packet_callback_queue, 0x00, sizeof(PacketCallbackQueue)); atomic_store(&new_connection->packet_callback_queue.owner, PACKET_CALLBACK_QUEUE_OWNER_NONE); - uint8_t server_information_buffer[PACKET_HEADER_SIZE + sizeof(SwiftNetServerInformation)]; - pthread_t send_request_thread; const RequestServerInformationArgs thread_args = { - .sockfd = new_connection->sockfd, + .pcap = new_connection->pcap, .data = request_server_info_buffer, .size = sizeof(request_server_info_buffer), .server_addr = new_connection->server_addr, - .server_addr_len = sizeof(new_connection->server_addr), - .timeout_ms = timeout_ms + .timeout_ms = timeout_ms, + .connection = new_connection }; - pthread_create(&send_request_thread, NULL, request_server_information, (void*)&thread_args); - - while(1) { - const int bytes_received = recvfrom(new_connection->sockfd, server_information_buffer, sizeof(server_information_buffer), 0x00, NULL, NULL); - if(bytes_received != PACKET_HEADER_SIZE) { - if (atomic_load_explicit(&timeout_reached, memory_order_acquire) == true) { - pthread_join(send_request_thread, NULL); - - return NULL; - } - - #ifdef SWIFT_NET_DEBUG - if (check_debug_flag(DEBUG_INITIALIZATION)) { - send_debug_message("Invalid packet received from server. Expected server information: {\"bytes_received\": %d, \"expected_bytes\": %d}\n", bytes_received, PACKET_HEADER_SIZE + sizeof(SwiftNetServerInformation)); - } - #endif + atomic_store_explicit(&new_connection->closing, false, memory_order_release); - continue; - } + atomic_store_explicit(&new_connection->initialized, false, memory_order_release); - const struct ip* const ip_header = (struct ip*)&server_information_buffer; + Listener* const listener = check_existing_listener(loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface, new_connection, CONNECTION_TYPE_CLIENT, loopback); - const SwiftNetPacketInfo* const packet_info = (SwiftNetPacketInfo *)&server_information_buffer[sizeof(struct ip)]; + pthread_create(&send_request_thread, NULL, request_server_information, (void*)&thread_args); - if(packet_info->port_info.destination_port != new_connection->port_info.source_port || packet_info->port_info.source_port != new_connection->port_info.destination_port) { - #ifdef SWIFT_NET_DEBUG - if (check_debug_flag(DEBUG_INITIALIZATION)) { - send_debug_message("Port info does not match: {\"destination_port\": %d, \"source_port\": %d, \"source_ip_address\": \"%s\"}\n", packet_info->port_info.destination_port, packet_info->port_info.source_port, inet_ntoa(ip_header->ip_src)); - } - #endif + pthread_join(send_request_thread, NULL); - continue; - } + if (atomic_load_explicit(&new_connection->initialized, memory_order_acquire) == false) { + atomic_store_explicit(&new_connection->closing, true, memory_order_release); - if(packet_info->packet_type != PACKET_TYPE_REQUEST_INFORMATION) { - #ifdef SWIFT_NET_DEBUG - if (check_debug_flag(DEBUG_INITIALIZATION)) { - send_debug_message("Invalid packet type: {\"packet_type\": %d}\n", packet_info->packet_type); - } - #endif - continue; - } - - if(bytes_received != 0) { - break; - } - } + vector_lock(&listener->client_connections); - atomic_store(&exit_thread, true); + pcap_close(new_connection->pcap); - pthread_join(send_request_thread, NULL); + allocator_free(&client_connection_memory_allocator, new_connection); - const SwiftNetPacketInfo* const packet_info = (SwiftNetPacketInfo*)&server_information_buffer[sizeof(struct ip)]; + for (uint16_t i = 0; i < listener->client_connections.size; i++) { + SwiftNetClientConnection* const client_connection = vector_get(&listener->client_connections, i); + if (client_connection == new_connection) { + vector_remove(&listener->client_connections, i); + } + } - const SwiftNetServerInformation* const server_information = (SwiftNetServerInformation*)&server_information_buffer[PACKET_HEADER_SIZE]; + vector_unlock(&listener->client_connections); - new_connection->maximum_transmission_unit = packet_info->maximum_transmission_unit; + return NULL; + } new_connection->pending_messages_memory_allocator = allocator_create(sizeof(SwiftNetPendingMessage), 100); new_connection->pending_messages = vector_create(100); @@ -211,9 +182,6 @@ SwiftNetClientConnection* swiftnet_create_client(const char* const ip_address, c new_connection->packets_completed_memory_allocator = allocator_create(sizeof(SwiftNetPacketCompleted), 100); new_connection->packets_completed = vector_create(100); - atomic_store_explicit(&new_connection->closing, false, memory_order_release); - - pthread_create(&new_connection->handle_packets_thread, NULL, swiftnet_client_handle_packets, new_connection); pthread_create(&new_connection->process_packets_thread, NULL, swiftnet_client_process_packets, new_connection); pthread_create(&new_connection->execute_callback_thread, NULL, execute_packet_callback_client, new_connection); diff --git a/src/initialize_server_socket.c b/src/initialize_server_socket.c index 8f5041d..da3f494 100644 --- a/src/initialize_server_socket.c +++ b/src/initialize_server_socket.c @@ -13,7 +13,7 @@ #include "internal/internal.h" #include "swift_net.h" -SwiftNetServer* swiftnet_create_server(const uint16_t port) { +SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool loopback) { SwiftNetServer* const new_server = allocator_allocate(&server_memory_allocator); #ifdef SWIFT_NET_ERROR @@ -24,19 +24,27 @@ SwiftNetServer* swiftnet_create_server(const uint16_t port) { #endif new_server->server_port = port; + new_server->loopback = loopback; - // Create the socket - new_server->sockfd = socket(AF_INET, SOCK_RAW, PROTOCOL_NUMBER); - if (unlikely(new_server->sockfd < 0)) { - fprintf(stderr, "Socket creation failed\n"); + // Init bpf 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"); exit(EXIT_FAILURE); } - int on = 1; - if(setsockopt(new_server->sockfd, IPPROTO_IP, IP_HDRINCL, &on, sizeof(on)) < 0) { - fprintf(stderr, "Failed to set sockopt IP_HDRINCL\n"); - exit(EXIT_FAILURE); - } + new_server->addr_type = pcap_datalink(new_server->pcap); + + new_server->prepend_size = PACKET_PREPEND_SIZE(new_server->addr_type); + + struct ether_header eth_header = { + .ether_dhost = {0xff,0xff,0xff,0xff,0xff,0xff}, + .ether_type = htons(0x0800) + }; + + memcpy(eth_header.ether_shost, mac_address, sizeof(eth_header.ether_shost)); + + new_server->eth_header = eth_header; new_server->packet_queue = (PacketQueue){ .first_node = NULL, @@ -60,7 +68,7 @@ SwiftNetServer* swiftnet_create_server(const uint16_t port) { atomic_store_explicit(&new_server->closing, false, memory_order_release); // Create a new thread that will handle all packets received - pthread_create(&new_server->handle_packets_thread, NULL, swiftnet_server_handle_packets, new_server); + check_existing_listener(loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface, new_server, CONNECTION_TYPE_SERVER, loopback); pthread_create(&new_server->process_packets_thread, NULL, swiftnet_server_process_packets, new_server); pthread_create(&new_server->execute_callback_thread, NULL, execute_packet_callback_server, new_server); diff --git a/src/initialize_swift_net.c b/src/initialize_swift_net.c index 5191cd1..92c2fd0 100644 --- a/src/initialize_swift_net.c +++ b/src/initialize_swift_net.c @@ -14,6 +14,8 @@ uint32_t maximum_transmission_unit = 0x00; struct in_addr private_ip_address; +uint8_t mac_address[6]; +char default_network_interface[SIZEOF_FIELD(struct ifreq, ifr_name)]; SwiftNetMemoryAllocator packet_queue_node_memory_allocator; SwiftNetMemoryAllocator packet_callback_queue_node_memory_allocator; @@ -22,10 +24,14 @@ SwiftNetMemoryAllocator client_packet_data_memory_allocator; SwiftNetMemoryAllocator packet_buffer_memory_allocator; SwiftNetMemoryAllocator server_memory_allocator; SwiftNetMemoryAllocator client_connection_memory_allocator; -SwiftNetMemoryAllocator pending_message_memory_allocator; -SwiftNetMemoryAllocator requests_sent_memory_allocator; +SwiftNetMemoryAllocator listener_memory_allocator; -SwiftNetVector requests_sent; +#ifdef SWIFT_NET_REQUESTS + SwiftNetMemoryAllocator requests_sent_memory_allocator; + SwiftNetVector requests_sent; +#endif + +SwiftNetVector listeners; void swiftnet_initialize() { const int temp_socket = socket(AF_INET, SOCK_DGRAM, 0); @@ -56,9 +62,7 @@ void swiftnet_initialize() { private_ip_address = ((struct sockaddr_in *)&private_sockaddr)->sin_addr; - char default_network_interface[128]; - - const int got_default_interface = get_default_interface(default_network_interface, sizeof(default_network_interface), temp_socket); + const int got_default_interface = get_default_interface_and_mac(default_network_interface, sizeof(default_network_interface), mac_address, temp_socket); if(unlikely(got_default_interface != 0)) { close(temp_socket); fprintf(stderr, "Failed to get the default interface\n"); @@ -78,10 +82,10 @@ void swiftnet_initialize() { packet_callback_queue_node_memory_allocator = allocator_create(sizeof(PacketCallbackQueueNode), 100); server_packet_data_memory_allocator = allocator_create(sizeof(SwiftNetServerPacketData), 100); client_packet_data_memory_allocator = allocator_create(sizeof(SwiftNetClientPacketData), 100); - packet_buffer_memory_allocator = allocator_create(maximum_transmission_unit, 100); + packet_buffer_memory_allocator = allocator_create(maximum_transmission_unit + sizeof(struct ether_header), 100); server_memory_allocator = allocator_create(sizeof(SwiftNetServer), 10); client_connection_memory_allocator = allocator_create(sizeof(SwiftNetClientConnection), 10); - pending_message_memory_allocator = allocator_create(sizeof(SwiftNetPendingMessage), 100); + listener_memory_allocator = allocator_create(sizeof(Listener), 100); #ifdef SWIFT_NET_REQUESTS requests_sent_memory_allocator = allocator_create(sizeof(RequestSent), 100); @@ -89,5 +93,7 @@ void swiftnet_initialize() { requests_sent = vector_create(100); #endif + listeners = vector_create(10); + return; } diff --git a/src/internal/check_existing_listener.c b/src/internal/check_existing_listener.c new file mode 100644 index 0000000..1046c51 --- /dev/null +++ b/src/internal/check_existing_listener.c @@ -0,0 +1,50 @@ +#include "internal.h" + +void* check_existing_listener(const char* interface_name, void* const connection, const ConnectionType connection_type, const bool loopback) { + 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) { + if (connection_type == CONNECTION_TYPE_CLIENT) { + vector_lock(¤t_listener->client_connections); + + vector_push(¤t_listener->client_connections, connection); + + vector_unlock(¤t_listener->client_connections); + } else { + vector_lock(¤t_listener->servers); + + vector_push(¤t_listener->servers, connection); + + vector_unlock(¤t_listener->servers); + } + + vector_unlock(&listeners); + + return current_listener; + } + } + + Listener* const new_listener = allocator_allocate(&listener_memory_allocator); + new_listener->servers = vector_create(10); + new_listener->client_connections = vector_create(10); + new_listener->pcap = swiftnet_pcap_open(interface_name); + new_listener->addr_type = pcap_datalink(new_listener->pcap); + memcpy(new_listener->interface_name, interface_name, strlen(interface_name) + 1); + new_listener->loopback = loopback; + + if (connection_type == CONNECTION_TYPE_CLIENT) { + vector_push(&new_listener->client_connections, connection); + } else { + vector_push(&new_listener->servers, connection); + } + + vector_push(&listeners, new_listener); + + vector_unlock(&listeners); + + pthread_create(&new_listener->listener_thread, NULL, interface_start_listening, new_listener); + + return new_listener; +} diff --git a/src/internal/get_default_interface.c b/src/internal/get_default_interface.c deleted file mode 100644 index 3d1e03d..0000000 --- a/src/internal/get_default_interface.c +++ /dev/null @@ -1,58 +0,0 @@ -#include "internal.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -const int get_default_interface(char* const restrict interface_name, const uint32_t interface_name_length, const int sockfd) { - struct sockaddr_in local_addr; - socklen_t addr_len = sizeof(local_addr); - - if (getsockname(sockfd, (struct sockaddr *)&local_addr, &addr_len) < 0) { - fprintf(stderr, "getsockname failed\n"); - return -1; - } - - char local_ip[INET_ADDRSTRLEN]; - if (!inet_ntop(AF_INET, &local_addr.sin_addr, local_ip, sizeof(local_ip))) { - fprintf(stderr, "inet_ntop failed\n"); - return -1; - } - - struct ifaddrs *ifaddr, *ifa; - if (getifaddrs(&ifaddr) == -1) { - fprintf(stderr, "getifaddrs failed\n"); - return -1; - } - - int found = 0; - for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { - if (ifa->ifa_addr == NULL) continue; - if (ifa->ifa_addr->sa_family == AF_INET) { - char iface_ip[INET_ADDRSTRLEN]; - struct sockaddr_in *sin = (struct sockaddr_in *)ifa->ifa_addr; - - inet_ntop(AF_INET, &sin->sin_addr, iface_ip, sizeof(iface_ip)); - - if (strcmp(local_ip, iface_ip) == 0) { - strncpy(interface_name, ifa->ifa_name, interface_name_length - 1); - interface_name[interface_name_length - 1] = '\0'; - freeifaddrs(ifaddr); - return 0; - } - } - } - - freeifaddrs(ifaddr); - - fprintf(stderr, "Fatal Error: No matching interface found for IP %s\n", local_ip); - return -1; -} diff --git a/src/internal/get_default_interface_and_mac.c b/src/internal/get_default_interface_and_mac.c new file mode 100644 index 0000000..baca50d --- /dev/null +++ b/src/internal/get_default_interface_and_mac.c @@ -0,0 +1,104 @@ +#include "internal.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef __linux__ +#include +#include +#elif defined(__APPLE__) +#include +#endif + +int get_default_interface_and_mac(char* restrict interface_name, uint32_t interface_name_length, uint8_t mac_out[6], int sockfd) { + struct sockaddr_in local_addr; + socklen_t addr_len = sizeof(local_addr); + + if (getsockname(sockfd, (struct sockaddr *)&local_addr, &addr_len) < 0) { + perror("getsockname"); + return -1; + } + + char local_ip[INET_ADDRSTRLEN]; + if (!inet_ntop(AF_INET, &local_addr.sin_addr, local_ip, sizeof(local_ip))) { + perror("inet_ntop"); + return -1; + } + + struct ifaddrs *ifaddr, *ifa; + if (getifaddrs(&ifaddr) == -1) { + perror("getifaddrs"); + return -1; + } + + struct ifaddrs *match = NULL; + + for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { + if (!ifa->ifa_addr) continue; + + if (ifa->ifa_addr->sa_family == AF_INET) { + char iface_ip[INET_ADDRSTRLEN]; + struct sockaddr_in *sin = (struct sockaddr_in *)ifa->ifa_addr; + + if (!inet_ntop(AF_INET, &sin->sin_addr, iface_ip, sizeof(iface_ip))) + continue; + + if (strcmp(local_ip, iface_ip) == 0) { + match = ifa; + break; + } + } + } + + if (!match) { + fprintf(stderr, "No matching interface found for IP %s\n", local_ip); + freeifaddrs(ifaddr); + return -1; + } + + strncpy(interface_name, match->ifa_name, interface_name_length - 1); + interface_name[interface_name_length - 1] = '\0'; + + int mac_found = 0; + + for (ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) { + if (!ifa->ifa_addr) continue; + if (strcmp(ifa->ifa_name, interface_name) != 0) continue; + + #ifdef __linux__ + if (ifa->ifa_addr->sa_family == AF_PACKET) { + struct sockaddr_ll *s = (struct sockaddr_ll *)ifa->ifa_addr; + if (s->sll_halen == 6) { + memcpy(mac_out, s->sll_addr, 6); + mac_found = 1; + break; + } + } + #elif defined(__APPLE__) + if (ifa->ifa_addr->sa_family == AF_LINK) { + struct sockaddr_dl *sdl = (struct sockaddr_dl *)ifa->ifa_addr; + if (sdl->sdl_alen == 6) { + memcpy(mac_out, LLADDR(sdl), 6); + mac_found = 1; + break; + } + } + #endif + } + + freeifaddrs(ifaddr); + + if (!mac_found) { + fprintf(stderr, "No MAC address found for interface %s\n", interface_name); + return -1; + } + + return 0; +} diff --git a/src/internal/internal.h b/src/internal/internal.h index 12e83ad..d9921d7 100644 --- a/src/internal/internal.h +++ b/src/internal/internal.h @@ -1,6 +1,8 @@ #pragma once #include +#include +#include #include #include #include @@ -9,11 +11,35 @@ #include #include #include +#include + +#ifdef __linux__ + #define LOOPBACK_INTERFACE_NAME "lo\0" +#elif defined(__APPLE__) + #define LOOPBACK_INTERFACE_NAME "lo0\0" +#endif #define REQUEST_LOST_PACKETS_RETURN_UPDATED_BIT_ARRAY 0x00 #define REQUEST_LOST_PACKETS_RETURN_COMPLETED_PACKET 0x01 -#define PACKET_HEADER_SIZE (sizeof(SwiftNetPacketInfo) + sizeof(struct ip)) +#define PACKET_PREPEND_SIZE(addr_type) ((addr_type == DLT_NULL) ? sizeof(uint32_t) : addr_type == DLT_EN10MB ? sizeof(struct ether_header) : 0) +#define PACKET_HEADER_SIZE (sizeof(struct ip) + sizeof(SwiftNetPacketInfo)) +#define HANDLE_PACKET_CONSTRUCTION(ip_header, packet_info, addr_type, eth_hdr, buffer_size, buffer_name) \ + uint8_t buffer_name[buffer_size]; \ + if(addr_type == DLT_NULL) { \ + uint32_t family = PF_INET; \ + memcpy(buffer_name, &family, sizeof(family)); \ + memcpy(buffer_name + sizeof(family), ip_header, sizeof(*ip_header)); \ + memcpy(buffer_name + sizeof(family) + sizeof(*ip_header), packet_info, sizeof(*packet_info)); \ + } else if(addr_type == DLT_EN10MB){ \ + memcpy(buffer_name, eth_hdr, sizeof(*eth_hdr)); \ + memcpy(buffer_name + sizeof(*eth_hdr), ip_header, sizeof(*ip_header)); \ + memcpy(buffer_name + sizeof(*eth_hdr) + sizeof(*ip_header), packet_info, sizeof(*packet_info)); \ + } \ + +#define HANDLE_CHECKSUM(buffer, size, prepend_size) \ + uint16_t checksum = htons(crc16(buffer, size)); \ + memcpy(buffer + prepend_size + offsetof(struct ip, ip_sum), &checksum, sizeof(checksum)); #define PACKET_QUEUE_OWNER_NONE 0x00 #define PACKET_QUEUE_OWNER_HANDLE_PACKETS 0x01 @@ -23,7 +49,7 @@ #define PACKET_CALLBACK_QUEUE_OWNER_PROCESS_PACKETS 0x01 #define PACKET_CALLBACK_QUEUE_OWNER_EXECUTE_PACKET_CALLBACK 0x02 -#define PROTOCOL_NUMBER IPPROTO_RAW +#define PROTOCOL_NUMBER 253 #define SIZEOF_FIELD(type, field) sizeof(((type *)0)->field) @@ -76,8 +102,28 @@ static inline uint16_t crc16(const uint8_t *data, size_t length) { return crc ^ 0xFFFF; } -extern const int get_default_interface(char* restrict const interface_name, const uint32_t interface_name_length, const int sockfd); +typedef struct { + pcap_t* pcap; + char interface_name[IFNAMSIZ]; + SwiftNetVector servers; + SwiftNetVector client_connections; + pthread_t listener_thread; + bool loopback; + uint16_t addr_type; +} Listener; + +typedef enum { + CONNECTION_TYPE_SERVER, + CONNECTION_TYPE_CLIENT +} ConnectionType; + +extern SwiftNetVector listeners; + +extern int get_default_interface_and_mac(char *restrict interface_name, uint32_t interface_name_length, uint8_t mac_out[6], int sockfd); extern const uint32_t get_mtu(const char* restrict const interface, const int sockfd); +extern int get_bpf_device(); +extern int bind_bpf_to_interface(const int bpf, const bool loopback); +extern int setup_bpf_settings(const int bpf); extern void* swiftnet_server_process_packets(void* const void_server); extern void* swiftnet_client_process_packets(void* const void_client); @@ -86,6 +132,12 @@ extern void* execute_packet_callback_client(void* const void_client); extern void* execute_packet_callback_server(void* const void_server); extern struct in_addr private_ip_address; +extern uint8_t mac_address[6]; +extern char default_network_interface[SIZEOF_FIELD(struct ifreq, ifr_name)]; +extern pcap_t* swiftnet_pcap_open(const char* interface); +extern int swiftnet_pcap_send(pcap_t *pcap, const uint8_t *data, int len); + +extern void* check_existing_listener(const char* interface_name, void* const connection, const ConnectionType connection_type, const bool loopback); #ifdef SWIFT_NET_DEBUG extern SwiftNetDebugger debugger; @@ -133,20 +185,25 @@ extern SwiftNetMemoryAllocator client_packet_data_memory_allocator; extern SwiftNetMemoryAllocator packet_buffer_memory_allocator; extern SwiftNetMemoryAllocator server_memory_allocator; extern SwiftNetMemoryAllocator client_connection_memory_allocator; -extern SwiftNetMemoryAllocator pending_message_memory_allocator; +extern SwiftNetMemoryAllocator listener_memory_allocator; + +extern void* interface_start_listening(void* listener_void); -void* vector_get(SwiftNetVector* const vector, const uint32_t index); -void vector_remove(SwiftNetVector* const vector, const uint32_t index); -void vector_push(SwiftNetVector* const vector, void* const data); -void vector_destroy(SwiftNetVector* const vector); -SwiftNetVector vector_create(const uint32_t starting_amount); -void vector_lock(SwiftNetVector* const vector); -void vector_unlock(SwiftNetVector* const vector); +extern void* vector_get(SwiftNetVector* const vector, const uint32_t index); +extern void vector_remove(SwiftNetVector* const vector, const uint32_t index); +extern void vector_push(SwiftNetVector* const vector, void* const data); +extern void vector_destroy(SwiftNetVector* const vector); +extern SwiftNetVector vector_create(const uint32_t starting_amount); +extern void vector_lock(SwiftNetVector* const vector); +extern void vector_unlock(SwiftNetVector* const vector); + +extern void* server_start_pcap(void* server_void); +extern void* client_start_pcap(void* client_void); #ifdef SWIFT_NET_REQUESTS typedef struct { uint16_t packet_id; - in_addr_t address; + struct in_addr address; _Atomic(void*) packet_data; } RequestSent; @@ -160,11 +217,14 @@ extern void swiftnet_send_packet( const SwiftNetPortInfo port_info, const SwiftNetPacketBuffer* const packet, const uint32_t packet_length, - const struct sockaddr_in* const target_addr, - const socklen_t* const target_addr_len, + const struct in_addr* const target_addr, SwiftNetVector* const packets_sending, SwiftNetMemoryAllocator* const packets_sending_memory_allocator, - const int sockfd + pcap_t* const pcap, + const struct ether_header eth_hdr, + const bool loopback, + const uint16_t addr_type, + const uint8_t prepend_size #ifdef SWIFT_NET_REQUESTS , RequestSent* const request_sent , const bool response @@ -189,19 +249,14 @@ static struct ip construct_ip_header(struct in_addr destination_addr, const uint .ip_hl = 5, // Header length .ip_tos = 0, // Type of service .ip_p = PROTOCOL_NUMBER, // Protocol - .ip_len = packet_size, // Chunk size - .ip_id = packet_id, // Packet id - .ip_off = 0, // Not used + .ip_len = htons(packet_size), // Chunk size + .ip_id = htons(packet_id), // Packet id + .ip_off = htons(0), // Not used .ip_ttl = 64,// Time to live - .ip_sum = 0, // Checksum + .ip_sum = htons(0), // Checksum .ip_src = private_ip_address, // Source ip .ip_dst = destination_addr // Destination ip }; return ip_header; } - -typedef enum { - CONNECTION_TYPE_SERVER, - CONNECTION_TYPE_CLIENT -} ConnectionType; diff --git a/src/internal/pcap_open.c b/src/internal/pcap_open.c new file mode 100644 index 0000000..d18d0b6 --- /dev/null +++ b/src/internal/pcap_open.c @@ -0,0 +1,33 @@ +#include "internal.h" + +pcap_t* swiftnet_pcap_open(const char* interface) { + char errbuf[PCAP_ERRBUF_SIZE]; + + pcap_t *p = pcap_open_live( + interface, + 65535, + 0, + 25, + errbuf + ); + + if (!p) { + fprintf(stderr, "pcap_open_live failed: %s\n", errbuf); + return NULL; + } + + struct bpf_program fp; + char filter_exp[] = "ip proto 253"; + bpf_u_int32 net = 0; + + if (pcap_compile(p, &fp, filter_exp, 0, net) == -1) { + fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(p)); + exit(EXIT_FAILURE); + } + + if (pcap_setfilter(p, &fp) != 0) { + fprintf(stderr, "Unable to set filter: %s\n", pcap_geterr(p)); + } + + return p; +} diff --git a/src/internal/pcap_send.c b/src/internal/pcap_send.c new file mode 100644 index 0000000..5f8028e --- /dev/null +++ b/src/internal/pcap_send.c @@ -0,0 +1,10 @@ +#include "internal.h" + +int swiftnet_pcap_send(pcap_t *pcap, const u_char *data, int len) { + if (pcap_inject(pcap, data, len) == -1) { + fprintf(stderr, "inject error: %s\n", pcap_geterr(pcap)); + return -1; + } + + return 0; +} diff --git a/src/make_request.c b/src/make_request.c index 58facec..3c1f3c7 100644 --- a/src/make_request.c +++ b/src/make_request.c @@ -10,11 +10,11 @@ SwiftNetClientPacketData* swiftnet_client_make_request(SwiftNetClientConnection* const client, SwiftNetPacketBuffer* const packet, const uint32_t timeout_ms) { RequestSent* const request_sent = allocator_allocate(&requests_sent_memory_allocator); request_sent->packet_data = NULL; - request_sent->address = client->server_addr.sin_addr.s_addr; + request_sent->address = client->server_addr; const uint32_t packet_length = packet->packet_append_pointer - packet->packet_data_start; - swiftnet_send_packet(client, client->maximum_transmission_unit, client->port_info, packet, packet_length, &client->server_addr, &client->server_addr_len, &client->packets_sending, &client->packets_sending_memory_allocator, client->sockfd, request_sent, false, 0); + swiftnet_send_packet(client, client->maximum_transmission_unit, client->port_info, packet, packet_length, &client->server_addr, &client->packets_sending, &client->packets_sending_memory_allocator, client->pcap, client->eth_header, client->loopback, client->addr_type, client->prepend_size, request_sent, false, 0); struct timeval tv; gettimeofday(&tv, NULL); @@ -56,16 +56,16 @@ SwiftNetClientPacketData* swiftnet_client_make_request(SwiftNetClientConnection* SwiftNetServerPacketData* swiftnet_server_make_request(SwiftNetServer* const server, SwiftNetPacketBuffer* const packet, const SwiftNetClientAddrData addr_data, const uint32_t timeout_ms) { RequestSent* const request_sent = allocator_allocate(&requests_sent_memory_allocator); request_sent->packet_data = NULL; - request_sent->address = addr_data.sender_address.sin_addr.s_addr; + request_sent->address = addr_data.sender_address; const uint32_t packet_length = packet->packet_append_pointer - packet->packet_data_start; const SwiftNetPortInfo port_info = { - .destination_port = addr_data.sender_address.sin_port, + .destination_port = addr_data.port, .source_port = server->server_port }; - swiftnet_send_packet(server, addr_data.maximum_transmission_unit, port_info, packet, packet_length, &addr_data.sender_address, &addr_data.sender_address_length, &server->packets_sending, &server->packets_sending_memory_allocator, server->sockfd, request_sent, false, 0); + swiftnet_send_packet(server, addr_data.maximum_transmission_unit, port_info, packet, packet_length, &addr_data.sender_address, &server->packets_sending, &server->packets_sending_memory_allocator, server->pcap, server->eth_header, server->loopback, server->addr_type, server->prepend_size, request_sent, false, 0); while (1) { if (request_sent->packet_data != NULL) { diff --git a/src/make_response.c b/src/make_response.c index 6baac9b..7c10acf 100644 --- a/src/make_response.c +++ b/src/make_response.c @@ -6,7 +6,7 @@ void swiftnet_client_make_response(SwiftNetClientConnection* const client, SwiftNetClientPacketData* const packet_data, SwiftNetPacketBuffer* const buffer) { const uint32_t packet_length = buffer->packet_append_pointer - buffer->packet_data_start; - swiftnet_send_packet(client, client->maximum_transmission_unit, client->port_info, buffer, packet_length, &client->server_addr, &client->server_addr_len, &client->packets_sending, &client->packets_sending_memory_allocator, client->sockfd, NULL, true, packet_data->metadata.packet_id); + swiftnet_send_packet(client, client->maximum_transmission_unit, client->port_info, buffer, packet_length, &client->server_addr, &client->packets_sending, &client->packets_sending_memory_allocator, client->pcap, client->eth_header, client->loopback, client->addr_type, client->prepend_size, NULL, true, packet_data->metadata.packet_id); } void swiftnet_server_make_response(SwiftNetServer* const server, SwiftNetServerPacketData* const packet_data, SwiftNetPacketBuffer* const buffer) { @@ -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, &packet_data->metadata.sender.sender_address_length, &server->packets_sending, &server->packets_sending_memory_allocator, server->sockfd, NULL, true, packet_data->metadata.packet_id); + 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); } #endif diff --git a/src/process_packets.c b/src/process_packets.c index 3c32a52..ff4e089 100644 --- a/src/process_packets.c +++ b/src/process_packets.c @@ -9,13 +9,14 @@ #include #include #include +#include #include #include #include #include -static inline bool is_private_ip(in_addr_t ip) { - in_addr_t addr = htonl(ip); +static inline bool is_private_ip(struct in_addr ip) { + in_addr_t addr = htonl(ip.s_addr); uint8_t octet1 = (addr >> 24) & 0xFF; uint8_t octet2 = (addr >> 16) & 0xFF; uint8_t octet3 = (addr >> 8) & 0xFF; @@ -111,13 +112,13 @@ static inline bool check_packet_already_completed(const uint16_t packet_id, Swif return false; } -static inline SwiftNetPendingMessage* const get_pending_message(const SwiftNetPacketInfo* const restrict packet_info, SwiftNetVector* const pending_messages_vector, const ConnectionType connection_type, const in_addr_t sender_address, const uint16_t packet_id) { +static inline SwiftNetPendingMessage* const get_pending_message(const SwiftNetPacketInfo* const restrict packet_info, SwiftNetVector* const pending_messages_vector, const ConnectionType connection_type, const struct in_addr sender_address, const uint16_t packet_id) { vector_lock(pending_messages_vector); for(uint32_t i = 0; i < pending_messages_vector->size; i++) { SwiftNetPendingMessage* const current_pending_message = vector_get((SwiftNetVector*)pending_messages_vector, i); - if((connection_type == CONNECTION_TYPE_CLIENT && current_pending_message->packet_id == packet_id) || (connection_type == CONNECTION_TYPE_SERVER && current_pending_message->sender_address == sender_address && current_pending_message->packet_id == packet_id)) { + if((connection_type == CONNECTION_TYPE_CLIENT && current_pending_message->packet_id == packet_id) || (connection_type == CONNECTION_TYPE_SERVER && current_pending_message->sender_address.s_addr == sender_address.s_addr && current_pending_message->packet_id == packet_id)) { vector_unlock((SwiftNetVector*)pending_messages_vector); return current_pending_message; @@ -158,7 +159,7 @@ static inline void insert_callback_queue_node(PacketCallbackQueueNode* const new #ifdef SWIFT_NET_REQUESTS -static inline void handle_request_response(const uint16_t packet_id, const in_addr_t sender, SwiftNetPendingMessage* const pending_message, void* const packet_data, SwiftNetVector* const pending_messages, const ConnectionType connection_type) { +static inline void handle_request_response(const uint16_t packet_id, const struct in_addr sender, SwiftNetPendingMessage* const pending_message, void* const packet_data, SwiftNetVector* const pending_messages, SwiftNetMemoryAllocator* const pending_message_memory_allocator, const ConnectionType connection_type, const bool loopback) { bool is_valid_response = false; vector_lock(&requests_sent); @@ -171,11 +172,8 @@ static inline void handle_request_response(const uint16_t packet_id, const in_ad } if (current_request_sent->packet_id == packet_id) { - const in_addr_t first_byte = (sender >> 0) & 0xFF; - const in_addr_t second_byte = (sender >> 8) & 0xFF; - - if ((first_byte != 127) && !(first_byte == 192 && second_byte == 168)) { - if (current_request_sent->address != sender) { + if (!loopback) { + if (current_request_sent->address.s_addr != sender.s_addr) { continue; } } @@ -196,13 +194,13 @@ static inline void handle_request_response(const uint16_t packet_id, const in_ad if (pending_message != NULL) { free(pending_message->chunks_received); - allocator_free(&pending_message_memory_allocator, pending_message); + 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 == sender && pending_message->packet_id == packet_id)) { + 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)) { vector_remove(pending_messages, i); } } @@ -237,7 +235,7 @@ static inline void chunk_received(uint8_t* const chunks_received, const uint32_t chunks_received[byte] |= 1 << bit; } -static inline SwiftNetPendingMessage* const create_new_pending_message(SwiftNetVector* const pending_messages, SwiftNetMemoryAllocator* const pending_messages_memory_allocator, const SwiftNetPacketInfo* const restrict packet_info, const ConnectionType connection_type, const in_addr_t sender_address, const uint16_t packet_id) { +static inline SwiftNetPendingMessage* const create_new_pending_message(SwiftNetVector* const pending_messages, SwiftNetMemoryAllocator* const pending_messages_memory_allocator, const SwiftNetPacketInfo* const restrict packet_info, const ConnectionType connection_type, const struct in_addr sender_address, const uint16_t packet_id) { SwiftNetPendingMessage* const new_pending_message = allocator_allocate(pending_messages_memory_allocator); uint8_t* const allocated_memory = malloc(packet_info->packet_length); @@ -255,7 +253,7 @@ static inline SwiftNetPendingMessage* const create_new_pending_message(SwiftNetV new_pending_message->packet_id = packet_id; if(connection_type == CONNECTION_TYPE_SERVER) { - new_pending_message->sender_address = sender_address; + new_pending_message->sender_address.s_addr = sender_address.s_addr; } vector_lock(pending_messages); @@ -318,10 +316,17 @@ static inline bool packet_corrupted(const uint16_t checksum, const uint32_t chun return crc16(buffer, chunk_size) != checksum; } +static inline void handle_ip_header_ordering(struct ip* ip_hdr) { + +} + static inline void swiftnet_process_packets( void* _Atomic * packet_handler, - const int sockfd, + pcap_t* const pcap, + const struct ether_header eth_hdr, const uint16_t source_port, + const bool loopback, + const uint16_t addr_type, SwiftNetVector* const packets_sending, SwiftNetMemoryAllocator* const packets_sending_messages_memory_allocator, SwiftNetVector* const pending_messages, @@ -332,7 +337,8 @@ static inline void swiftnet_process_packets( PacketQueue* const packet_queue, PacketCallbackQueue* const packet_callback_queue, void* const connection, - _Atomic bool* closing + _Atomic bool* closing, + const uint8_t prepend_size ) { while(1) { if (atomic_load(closing) == true) { @@ -356,7 +362,7 @@ static inline void swiftnet_process_packets( goto next_packet; } - uint8_t* const packet_data = &packet_buffer[PACKET_HEADER_SIZE]; + uint8_t* const packet_data = &packet_buffer[prepend_size + PACKET_HEADER_SIZE]; // Check if user set a function that will execute with the packet data received as arg #ifdef SWIFT_NET_ERROR @@ -370,10 +376,10 @@ static inline void swiftnet_process_packets( #endif struct ip ip_header; - memcpy(&ip_header, packet_buffer, sizeof(ip_header)); + memcpy(&ip_header, packet_buffer + prepend_size, sizeof(ip_header)); SwiftNetPacketInfo packet_info; - memcpy(&packet_info, &packet_buffer[sizeof(ip_header)], sizeof(packet_info)); + memcpy(&packet_info, packet_buffer + prepend_size + sizeof(ip_header), sizeof(packet_info)); // Check if the packet is meant to be for this server if(packet_info.port_info.destination_port != source_port) { @@ -384,11 +390,11 @@ static inline void swiftnet_process_packets( const uint16_t checksum_received = ip_header.ip_sum; - memset(&packet_buffer[offsetof(struct ip, ip_sum)], 0x00, SIZEOF_FIELD(struct ip, ip_sum)); + memset(packet_buffer + prepend_size + offsetof(struct ip, ip_sum), 0x00, SIZEOF_FIELD(struct ip, ip_sum)); - memcpy(packet_buffer + offsetof(struct ip, ip_len), (void*)&node->data_read, SIZEOF_FIELD(struct ip, ip_len)); + memcpy(packet_buffer + prepend_size + offsetof(struct ip, ip_len), (void*)&node->data_read, SIZEOF_FIELD(struct ip, ip_len)); - if(memcmp(&ip_header.ip_src, &ip_header.ip_dst, sizeof(struct in_addr)) != 0 && is_private_ip(ip_header.ip_src.s_addr) == false && is_private_ip(ip_header.ip_dst.s_addr)) { + if(memcmp(&ip_header.ip_src, &ip_header.ip_dst, sizeof(struct in_addr)) != 0 && is_private_ip(ip_header.ip_src) == false && is_private_ip(ip_header.ip_dst)) { if(ip_header.ip_sum != 0 && packet_corrupted(checksum_received, node->data_read, packet_buffer) == true) { #ifdef SWIFT_NET_DEBUG if (check_debug_flag(DEBUG_PACKETS_RECEIVING)) { @@ -411,7 +417,7 @@ static inline void swiftnet_process_packets( switch(packet_info.packet_type) { case PACKET_TYPE_REQUEST_INFORMATION: { - const struct ip send_server_info_ip_header = construct_ip_header(node->sender_address.sin_addr, PACKET_HEADER_SIZE, rand()); + const struct ip send_server_info_ip_header = construct_ip_header(node->sender_address, PACKET_HEADER_SIZE, rand()); const SwiftNetPacketInfo packet_info_new = construct_packet_info( sizeof(SwiftNetServerInformation), @@ -424,16 +430,17 @@ static inline void swiftnet_process_packets( } ); - uint8_t send_buffer[PACKET_HEADER_SIZE]; - - memcpy(send_buffer, &send_server_info_ip_header, sizeof(send_server_info_ip_header)); - memcpy(send_buffer + sizeof(struct ip), &packet_info_new, sizeof(packet_info_new)); + const SwiftNetServerInformation server_info = { + .maximum_transmission_unit = maximum_transmission_unit + }; - const uint16_t checksum = crc16(send_buffer, sizeof(send_buffer)); + HANDLE_PACKET_CONSTRUCTION(&send_server_info_ip_header, &packet_info_new, addr_type, ð_hdr, prepend_size + PACKET_HEADER_SIZE + sizeof(server_info), buffer) - memcpy(&send_buffer[offsetof(struct ip, ip_sum)], &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + memcpy(buffer + prepend_size + PACKET_HEADER_SIZE, &server_info, sizeof(server_info)); - sendto(sockfd, send_buffer, sizeof(send_buffer), 0, (struct sockaddr *)&node->sender_address, node->server_address_length); + HANDLE_CHECKSUM(buffer, sizeof(buffer), prepend_size) + + swiftnet_pcap_send(pcap, buffer, sizeof(buffer)); allocator_free(&packet_buffer_memory_allocator, packet_buffer); @@ -443,11 +450,11 @@ static inline void swiftnet_process_packets( { const uint32_t mtu = MIN(packet_info.maximum_transmission_unit, maximum_transmission_unit); - SwiftNetPendingMessage* const pending_message = get_pending_message(&packet_info, pending_messages, connection_type, ip_header.ip_src.s_addr, ip_header.ip_id); + SwiftNetPendingMessage* const pending_message = get_pending_message(&packet_info, pending_messages, connection_type, ip_header.ip_src, ip_header.ip_id); if(pending_message == NULL) { const bool packet_already_completed = check_packet_already_completed(ip_header.ip_id, packets_completed_history); if(likely(packet_already_completed == true)) { - const struct ip send_packet_ip_header = construct_ip_header(node->sender_address.sin_addr, PACKET_HEADER_SIZE, ip_header.ip_id); + const struct ip send_packet_ip_header = construct_ip_header(node->sender_address, PACKET_HEADER_SIZE, ip_header.ip_id); SwiftNetPacketInfo send_packet_info = construct_packet_info( 0x00, @@ -460,16 +467,11 @@ static inline void swiftnet_process_packets( } ); - uint8_t send_buffer[PACKET_HEADER_SIZE]; - - memcpy(send_buffer, &send_packet_ip_header, sizeof(send_packet_ip_header)); - memcpy(send_buffer + sizeof(send_packet_ip_header), &send_packet_info, sizeof(send_packet_info)); - - const uint16_t checksum = crc16(send_buffer, sizeof(send_buffer)); + HANDLE_PACKET_CONSTRUCTION(&send_packet_ip_header, &send_packet_info, addr_type, ð_hdr, prepend_size + PACKET_HEADER_SIZE, buffer) - memcpy(send_buffer + offsetof(struct ip, ip_sum), &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(buffer, sizeof(buffer), prepend_size) - sendto(sockfd, &send_buffer, sizeof(send_buffer), 0x00, (const struct sockaddr *)&node->sender_address, node->server_address_length); + swiftnet_pcap_send(pcap, buffer, sizeof(buffer)); allocator_free(&packet_buffer_memory_allocator, packet_buffer); @@ -481,7 +483,7 @@ static inline void swiftnet_process_packets( goto next_packet; } - struct ip send_lost_packets_ip_header = construct_ip_header(node->sender_address.sin_addr, 0, ip_header.ip_id); + struct ip send_lost_packets_ip_header = construct_ip_header(node->sender_address, 0, ip_header.ip_id); SwiftNetPacketInfo packet_info_new = construct_packet_info( 0, @@ -494,26 +496,19 @@ static inline void swiftnet_process_packets( } ); - uint8_t send_buffer[mtu]; - memset(send_buffer, 0, mtu); - const uint32_t lost_chunk_indexes = return_lost_chunk_indexes(pending_message->chunks_received, pending_message->packet_info.chunk_amount, mtu - PACKET_HEADER_SIZE, (uint32_t*)(send_buffer + PACKET_HEADER_SIZE)); - - packet_info_new.packet_length = lost_chunk_indexes * sizeof(uint32_t); - - send_lost_packets_ip_header.ip_len = lost_chunk_indexes + PACKET_HEADER_SIZE; + const uint16_t header_size = sizeof(struct ip) + sizeof(SwiftNetPacketInfo) + prepend_size; - const uint32_t packet_length = PACKET_HEADER_SIZE + (lost_chunk_indexes * sizeof(uint32_t)); + HANDLE_PACKET_CONSTRUCTION(&send_lost_packets_ip_header, &packet_info_new, addr_type, ð_hdr, mtu + prepend_size, buffer) - memcpy(send_buffer, &send_lost_packets_ip_header, sizeof(send_lost_packets_ip_header)); - memcpy(send_buffer + sizeof(struct ip), &packet_info_new, sizeof(packet_info_new)); + 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)); - memcpy(send_buffer + offsetof(struct ip, ip_len), &packet_length, SIZEOF_FIELD(struct ip, ip_len)); + const uint16_t packet_length = sizeof(struct ip) + sizeof(SwiftNetPacketInfo) + (lost_chunk_indexes * sizeof(uint32_t)); - const uint16_t checksum = crc16(send_buffer, packet_length); + memcpy(buffer + prepend_size + offsetof(struct ip, ip_len), &packet_length, SIZEOF_FIELD(struct ip, ip_len)); - memcpy(&send_buffer[offsetof(struct ip, ip_sum)], &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(buffer, packet_length + prepend_size, prepend_size); - sendto(sockfd, send_buffer, packet_length, 0x00, (const struct sockaddr *)&node->sender_address, node->server_address_length); + swiftnet_pcap_send(pcap, buffer, packet_length + prepend_size); allocator_free(&packet_buffer_memory_allocator, packet_buffer); @@ -569,29 +564,27 @@ static inline void swiftnet_process_packets( break; } - node->sender_address.sin_port = packet_info.port_info.source_port; - const SwiftNetClientAddrData sender = { - .sender_address = node->sender_address, - .sender_address_length = node->server_address_length, - .maximum_transmission_unit = packet_info.maximum_transmission_unit + .sender_address.s_addr = loopback == true ? inet_addr("127.0.0.1") : node->sender_address.s_addr, + .maximum_transmission_unit = packet_info.maximum_transmission_unit, + .port = packet_info.port_info.source_port }; const uint32_t mtu = MIN(packet_info.maximum_transmission_unit, maximum_transmission_unit); const uint32_t chunk_data_size = mtu - PACKET_HEADER_SIZE; - SwiftNetPendingMessage* const pending_message = get_pending_message(&packet_info, pending_messages, connection_type, node->sender_address.sin_addr.s_addr, ip_header.ip_id); + SwiftNetPendingMessage* const pending_message = get_pending_message(&packet_info, pending_messages, connection_type, node->sender_address, ip_header.ip_id); if(pending_message == NULL) { - if(packet_info.packet_length + PACKET_HEADER_SIZE > mtu) { + if(packet_info.packet_length > chunk_data_size) { // Split packet into chunks - SwiftNetPendingMessage* const new_pending_message = create_new_pending_message(pending_messages, pending_messages_memory_allocator, &packet_info, connection_type, node->sender_address.sin_addr.s_addr, ip_header.ip_id); + SwiftNetPendingMessage* const new_pending_message = create_new_pending_message(pending_messages, pending_messages_memory_allocator, &packet_info, connection_type, node->sender_address, ip_header.ip_id); new_pending_message->chunks_received_number++; chunk_received(new_pending_message->chunks_received, packet_info.chunk_index); - memcpy(new_pending_message->packet_data_start, &packet_buffer[PACKET_HEADER_SIZE], chunk_data_size); + memcpy(new_pending_message->packet_data_start, packet_data, chunk_data_size); allocator_free(&packet_buffer_memory_allocator, packet_buffer); @@ -600,12 +593,10 @@ static inline void swiftnet_process_packets( packet_completed(ip_header.ip_id, packet_info.packet_length, packets_completed_history, packets_completed_history_memory_allocator); if(connection_type == CONNECTION_TYPE_SERVER) { - uint8_t* const ptr = packet_buffer + PACKET_HEADER_SIZE; - - SwiftNetServerPacketData* const packet_data = allocator_allocate(&server_packet_data_memory_allocator) ; - packet_data->data = ptr; - packet_data->current_pointer = ptr; - packet_data->metadata = (SwiftNetPacketServerMetadata){ + 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->metadata = (SwiftNetPacketServerMetadata){ .port_info = packet_info.port_info, .sender = sender, .data_length = packet_info.packet_length, @@ -617,20 +608,18 @@ static inline void swiftnet_process_packets( #ifdef SWIFT_NET_REQUESTS if (packet_info.packet_type == PACKET_TYPE_RESPONSE) { - handle_request_response(ip_header.ip_id, sender.sender_address.sin_addr.s_addr, NULL, packet_data, pending_messages, connection_type); + handle_request_response(ip_header.ip_id, sender.sender_address, NULL, new_packet_data, pending_messages, pending_messages_memory_allocator, connection_type, loopback); } else { - pass_callback_execution(packet_data, packet_callback_queue, NULL, ip_header.ip_id); + pass_callback_execution(new_packet_data, packet_callback_queue, NULL, ip_header.ip_id); } #else - pass_callback_execution(packet_data, packet_callback_queue, NULL, ip_header.ip_id); + pass_callback_execution(new_packet_data, packet_callback_queue, NULL, ip_header.ip_id); #endif } else { - uint8_t* const ptr = packet_buffer + PACKET_HEADER_SIZE; - - SwiftNetClientPacketData* const packet_data = allocator_allocate(&client_packet_data_memory_allocator) ; - packet_data->data = ptr; - packet_data->current_pointer = ptr; - packet_data->metadata = (SwiftNetPacketClientMetadata){ + 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->metadata = (SwiftNetPacketClientMetadata){ .port_info = packet_info.port_info, .data_length = packet_info.packet_length, .packet_id = ip_header.ip_id @@ -641,12 +630,12 @@ static inline void swiftnet_process_packets( #ifdef SWIFT_NET_REQUESTS if (packet_info.packet_type == PACKET_TYPE_RESPONSE) { - handle_request_response(ip_header.ip_id, ((SwiftNetClientConnection*)connection)->server_addr.sin_addr.s_addr, NULL, packet_data, pending_messages, connection_type); + handle_request_response(ip_header.ip_id, ((SwiftNetClientConnection*)connection)->server_addr, NULL, new_packet_data, pending_messages, pending_messages_memory_allocator, connection_type, loopback); } else { - pass_callback_execution(packet_data, packet_callback_queue, NULL, ip_header.ip_id); + pass_callback_execution(new_packet_data, packet_callback_queue, NULL, ip_header.ip_id); } #else - pass_callback_execution(packet_data, packet_callback_queue, NULL, ip_header.ip_id); + pass_callback_execution(new_packet_data, packet_callback_queue, NULL, ip_header.ip_id); #endif } @@ -657,14 +646,14 @@ static inline void swiftnet_process_packets( if(pending_message->chunks_received_number + 1 >= packet_info.chunk_amount) { // Completed the packet - memcpy(pending_message->packet_data_start + (chunk_data_size * packet_info.chunk_index), &packet_buffer[PACKET_HEADER_SIZE], bytes_to_write); + memcpy(pending_message->packet_data_start + (chunk_data_size * packet_info.chunk_index), packet_data, bytes_to_write); chunk_received(pending_message->chunks_received, packet_info.chunk_index); #ifdef SWIFT_NET_DEBUG - uint32_t lost_chunks_buffer[mtu - PACKET_HEADER_SIZE]; + uint32_t lost_chunks_buffer[chunk_data_size]; - const uint32_t lost_chunks_num = return_lost_chunk_indexes(pending_message->chunks_received, packet_info.chunk_amount, mtu - PACKET_HEADER_SIZE, (uint32_t*)lost_chunks_buffer); + const uint32_t lost_chunks_num = return_lost_chunk_indexes(pending_message->chunks_received, packet_info.chunk_amount, chunk_data_size, (uint32_t*)lost_chunks_buffer); if (lost_chunks_num != 0) { fprintf(stderr, "Packet marked as completed, but %d chunks are missing\n", lost_chunks_num); @@ -695,7 +684,7 @@ static inline void swiftnet_process_packets( #ifdef SWIFT_NET_REQUESTS if (packet_info.packet_type == PACKET_TYPE_RESPONSE) { - handle_request_response(ip_header.ip_id, sender.sender_address.sin_addr.s_addr, pending_message, packet_data, pending_messages, connection_type); + handle_request_response(ip_header.ip_id, sender.sender_address, pending_message, packet_data, pending_messages, pending_messages_memory_allocator, connection_type, loopback); } else { pass_callback_execution(packet_data, packet_callback_queue, pending_message, ip_header.ip_id); } @@ -719,7 +708,7 @@ static inline void swiftnet_process_packets( #ifdef SWIFT_NET_REQUESTS if (packet_info.packet_type == PACKET_TYPE_RESPONSE) { - handle_request_response(ip_header.ip_id, ((SwiftNetClientConnection*)connection)->server_addr.sin_addr.s_addr, pending_message, packet_data, pending_messages, connection_type); + handle_request_response(ip_header.ip_id, ((SwiftNetClientConnection*)connection)->server_addr, pending_message, packet_data, pending_messages, pending_messages_memory_allocator, connection_type, loopback); } else { pass_callback_execution(packet_data, packet_callback_queue, pending_message, ip_header.ip_id); } @@ -732,7 +721,7 @@ static inline void swiftnet_process_packets( goto next_packet; } else { - memcpy(pending_message->packet_data_start + (chunk_data_size * packet_info.chunk_index), &packet_buffer[PACKET_HEADER_SIZE], bytes_to_write); + memcpy(pending_message->packet_data_start + (chunk_data_size * packet_info.chunk_index), packet_data, bytes_to_write); chunk_received(pending_message->chunks_received, packet_info.chunk_index); @@ -758,7 +747,7 @@ static inline void swiftnet_process_packets( void* swiftnet_server_process_packets(void* const void_server) { SwiftNetServer* const server = (SwiftNetServer*)void_server; - swiftnet_process_packets((void*)&server->packet_handler, server->sockfd, server->server_port, &server->packets_sending, &server->packets_sending_memory_allocator, &server->pending_messages, &server->pending_messages_memory_allocator, &server->packets_completed, &server->packets_completed_memory_allocator, CONNECTION_TYPE_SERVER, &server->packet_queue, &server->packet_callback_queue, server, &server->closing); + swiftnet_process_packets((void*)&server->packet_handler, server->pcap, server->eth_header, server->server_port, server->loopback, server->addr_type, &server->packets_sending, &server->packets_sending_memory_allocator, &server->pending_messages, &server->pending_messages_memory_allocator, &server->packets_completed, &server->packets_completed_memory_allocator, CONNECTION_TYPE_SERVER, &server->packet_queue, &server->packet_callback_queue, server, &server->closing, server->prepend_size); return NULL; } @@ -766,7 +755,7 @@ void* swiftnet_server_process_packets(void* const void_server) { void* swiftnet_client_process_packets(void* const void_client) { SwiftNetClientConnection* const client = (SwiftNetClientConnection*)void_client; - swiftnet_process_packets((void*)&client->packet_handler, client->sockfd, client->port_info.source_port, &client->packets_sending, &client->packets_sending_memory_allocator, &client->pending_messages, &client->pending_messages_memory_allocator, &client->packets_completed, &client->packets_completed_memory_allocator, CONNECTION_TYPE_CLIENT, &client->packet_queue, &client->packet_callback_queue, client, &client->closing); + swiftnet_process_packets((void*)&client->packet_handler, client->pcap, client->eth_header, client->port_info.source_port, client->loopback, client->addr_type, &client->packets_sending, &client->packets_sending_memory_allocator, &client->pending_messages, &client->pending_messages_memory_allocator, &client->packets_completed, &client->packets_completed_memory_allocator, CONNECTION_TYPE_CLIENT, &client->packet_queue, &client->packet_callback_queue, client, &client->closing, client->prepend_size); return NULL; } diff --git a/src/send_packet.c b/src/send_packet.c index 8527106..b80f56e 100644 --- a/src/send_packet.c +++ b/src/send_packet.c @@ -1,7 +1,9 @@ #include "swift_net.h" #include #include +#include #include +#include #include #include #include @@ -24,13 +26,13 @@ static inline void unlock_packet_sending(SwiftNetPacketSending* const packet_sen atomic_store_explicit(&packet_sending->locked, false, memory_order_release); } -static inline uint8_t request_lost_packets_bitarray(const uint8_t* const raw_data, const uint32_t data_size, const struct sockaddr* const destination, const int sockfd, SwiftNetPacketSending* const packet_sending) { +static inline uint8_t request_lost_packets_bitarray(const uint8_t* const raw_data, const uint32_t data_size, const struct sockaddr* const destination, pcap_t* const pcap, SwiftNetPacketSending* const packet_sending) { while(1) { if(check_debug_flag(DEBUG_LOST_PACKETS)) { send_debug_message("Requested list of lost packets: {\"packet_id\": %d}\n", packet_sending->packet_id); } - sendto(sockfd, raw_data, data_size, 0, destination, sizeof(*destination)); + swiftnet_pcap_send(pcap, raw_data, data_size); for(uint8_t times_checked = 0; times_checked < 0xFF; times_checked++) { const PacketSendingUpdated status = atomic_load_explicit(&packet_sending->updated, memory_order_acquire); @@ -55,13 +57,16 @@ static inline void handle_lost_packets( SwiftNetPacketSending* const packet_sending, const uint32_t mtu, const SwiftNetPacketBuffer* const packet, - const int sockfd, - const struct sockaddr_in* const destination_address, - const socklen_t* destination_address_len, + pcap_t* pcap, + const struct ether_header eth_hdr, + const struct in_addr* const destination_address, const uint16_t source_port, const uint16_t destination_port, SwiftNetMemoryAllocator* const packets_sending_memory_allocator, - SwiftNetVector* const packets_sending + SwiftNetVector* const packets_sending, + const bool loopback, + const uint16_t addr_type, + const uint8_t prepend_size #ifdef SWIFT_NET_REQUESTS , const bool response , const uint8_t packet_type @@ -72,7 +77,7 @@ static inline void handle_lost_packets( .destination_port = destination_port }; - const struct ip request_lost_packets_ip_header = construct_ip_header(destination_address->sin_addr, PACKET_HEADER_SIZE, packet_sending->packet_id); + const struct ip request_lost_packets_ip_header = construct_ip_header(*destination_address, PACKET_HEADER_SIZE, packet_sending->packet_id); SwiftNetPacketInfo request_lost_packets_bit_array = construct_packet_info( 0x00, @@ -82,14 +87,9 @@ static inline void handle_lost_packets( port_info ); - uint8_t request_lost_packets_buffer[PACKET_HEADER_SIZE]; - - memcpy(request_lost_packets_buffer, &request_lost_packets_ip_header, sizeof(struct ip)); - memcpy(request_lost_packets_buffer + sizeof(struct ip), &request_lost_packets_bit_array, sizeof(SwiftNetPacketInfo)); + HANDLE_PACKET_CONSTRUCTION(&request_lost_packets_ip_header, &request_lost_packets_bit_array, addr_type, ð_hdr, PACKET_HEADER_SIZE + prepend_size, request_lost_packets_buffer) - uint16_t checksum = crc16(request_lost_packets_buffer, sizeof(request_lost_packets_buffer)); - - memcpy(request_lost_packets_buffer + offsetof(struct ip, ip_sum), &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(request_lost_packets_buffer, sizeof(request_lost_packets_buffer), prepend_size) const uint32_t packet_length = packet->packet_append_pointer - packet->packet_data_start; const uint32_t chunk_amount = (packet_length + (mtu - PACKET_HEADER_SIZE) - 1) / (mtu - PACKET_HEADER_SIZE); @@ -106,16 +106,12 @@ static inline void handle_lost_packets( port_info ); - const struct ip resend_chunk_ip_header = construct_ip_header(destination_address->sin_addr, mtu, packet_sending->packet_id); - - uint8_t resend_chunk_buffer[mtu]; - - memcpy(resend_chunk_buffer, &resend_chunk_ip_header, sizeof(struct ip)); + const struct ip resend_chunk_ip_header = construct_ip_header(*destination_address, mtu, packet_sending->packet_id); - memcpy(resend_chunk_buffer + sizeof(struct ip), &resend_chunk_packet_info, sizeof(SwiftNetPacketInfo)); + HANDLE_PACKET_CONSTRUCTION(&resend_chunk_ip_header, &resend_chunk_packet_info, addr_type, ð_hdr, mtu + prepend_size, resend_chunk_buffer) while(1) { - const uint8_t request_lost_packets_bitarray_response = request_lost_packets_bitarray(request_lost_packets_buffer, PACKET_HEADER_SIZE, (const struct sockaddr*)destination_address, sockfd, packet_sending); + const uint8_t request_lost_packets_bitarray_response = request_lost_packets_bitarray(request_lost_packets_buffer, PACKET_HEADER_SIZE + prepend_size, (const struct sockaddr*)destination_address, pcap, packet_sending); lock_packet_sending(packet_sending); @@ -151,35 +147,30 @@ static inline void handle_lost_packets( send_debug_message("Packet lost: {\"packet_id\": %d, \"chunk index\": %d}\n", packet_sending->packet_id, lost_chunk_index); } - memcpy(&resend_chunk_buffer[sizeof(struct ip) + offsetof(SwiftNetPacketInfo, chunk_index)], &lost_chunk_index, SIZEOF_FIELD(SwiftNetPacketInfo, chunk_index)); + memcpy(&resend_chunk_buffer[sizeof(struct ip) + prepend_size + offsetof(SwiftNetPacketInfo, chunk_index)], &lost_chunk_index, SIZEOF_FIELD(SwiftNetPacketInfo, chunk_index)); const uint32_t current_offset = lost_chunk_index * (mtu - PACKET_HEADER_SIZE); + const uint16_t null_sum = htons(0); + memcpy(&resend_chunk_buffer[prepend_size + offsetof(struct ip, ip_sum)], &null_sum, SIZEOF_FIELD(struct ip, ip_sum)); + if(current_offset + mtu - PACKET_HEADER_SIZE >= packet_length) { const uint32_t bytes_to_complete = packet_length - current_offset; - const uint16_t new_ip_len = bytes_to_complete + PACKET_HEADER_SIZE; + const uint16_t new_ip_len = htons(bytes_to_complete + PACKET_HEADER_SIZE); memcpy(&resend_chunk_buffer[offsetof(struct ip, ip_len)], &new_ip_len, SIZEOF_FIELD(struct ip, ip_len)); - memcpy(&resend_chunk_buffer[PACKET_HEADER_SIZE], &packet->packet_data_start[current_offset], bytes_to_complete); - - memset(&resend_chunk_buffer[offsetof(struct ip, ip_sum)], 0x00, SIZEOF_FIELD(struct ip, ip_sum)); - - const uint16_t checksum = crc16(resend_chunk_buffer, bytes_to_complete + PACKET_HEADER_SIZE); - - memcpy(&resend_chunk_buffer[offsetof(struct ip, ip_sum)], &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + memcpy(&resend_chunk_buffer + PACKET_HEADER_SIZE + prepend_size, &packet->packet_data_start[current_offset], bytes_to_complete); + + HANDLE_CHECKSUM(resend_chunk_buffer, prepend_size + PACKET_HEADER_SIZE + bytes_to_complete, prepend_size) - sendto(sockfd, resend_chunk_buffer, bytes_to_complete + PACKET_HEADER_SIZE, 0, (const struct sockaddr*)destination_address, *destination_address_len); + swiftnet_pcap_send(pcap, resend_chunk_buffer, bytes_to_complete + PACKET_HEADER_SIZE + prepend_size); } else { - memcpy(&resend_chunk_buffer[PACKET_HEADER_SIZE], &packet->packet_data_start[current_offset], mtu - PACKET_HEADER_SIZE); + memcpy(&resend_chunk_buffer + PACKET_HEADER_SIZE + prepend_size, &packet->packet_data_start[current_offset], mtu - PACKET_HEADER_SIZE); - memset(&resend_chunk_buffer[offsetof(struct ip, ip_sum)], 0x00, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(resend_chunk_buffer, mtu + prepend_size, prepend_size) - const uint16_t checksum = crc16(resend_chunk_buffer, sizeof(resend_chunk_buffer)); - - memcpy(&resend_chunk_buffer[offsetof(struct ip, ip_sum)], &checksum, SIZEOF_FIELD(struct ip, ip_sum)); - - sendto(sockfd, resend_chunk_buffer, sizeof(resend_chunk_buffer), 0, (const struct sockaddr*)destination_address, *destination_address_len); + swiftnet_pcap_send(pcap, resend_chunk_buffer, mtu + prepend_size); } } @@ -193,11 +184,14 @@ inline void swiftnet_send_packet( const SwiftNetPortInfo port_info, const SwiftNetPacketBuffer* const packet, const uint32_t packet_length, - const struct sockaddr_in* const target_addr, - const socklen_t* const target_addr_len, + const struct in_addr* const target_addr, SwiftNetVector* const packets_sending, SwiftNetMemoryAllocator* const packets_sending_memory_allocator, - const int sockfd + pcap_t* const pcap, + const struct ether_header eth_hdr, + const bool loopback, + const uint16_t addr_type, + const uint8_t prepend_size #ifdef SWIFT_NET_REQUESTS , RequestSent* const request_sent , const bool response @@ -208,7 +202,7 @@ inline void swiftnet_send_packet( #ifdef SWIFT_NET_DEBUG if (check_debug_flag(DEBUG_PACKETS_SENDING)) { - send_debug_message("Sending packet: {\"destination_ip_address\": \"%s\", \"destination_port\": %d, \"packet_length\": %d}\n", inet_ntoa(target_addr->sin_addr), port_info.destination_port, packet_length); + send_debug_message("Sending packet: {\"destination_ip_address\": \"%s\", \"destination_port\": %d, \"packet_length\": %d}\n", inet_ntoa(*target_addr), port_info.destination_port, packet_length); } #endif @@ -252,7 +246,7 @@ inline void swiftnet_send_packet( port_info ); - const struct ip ip_header = construct_ip_header(target_addr->sin_addr, mtu, packet_id); + const struct ip ip_header = construct_ip_header(*target_addr, mtu, packet_id); SwiftNetPacketSending* const new_packet_sending = allocator_allocate(packets_sending_memory_allocator); if(unlikely(new_packet_sending == NULL)) { @@ -272,10 +266,7 @@ inline void swiftnet_send_packet( new_packet_sending->lost_chunks_size = 0; new_packet_sending->packet_id = packet_id; - uint8_t buffer[mtu]; - - memcpy(buffer, &ip_header, sizeof(ip_header)); - memcpy(buffer + sizeof(ip_header), &packet_info, sizeof(packet_info)); + HANDLE_PACKET_CONSTRUCTION(&ip_header, &packet_info, addr_type, ð_hdr, mtu + prepend_size, buffer) for(uint32_t i = 0; ; i++) { const uint32_t current_offset = i * (mtu - PACKET_HEADER_SIZE); @@ -286,24 +277,23 @@ inline void swiftnet_send_packet( } #endif - memcpy(&buffer[sizeof(struct ip) + offsetof(SwiftNetPacketInfo, chunk_index)], &i, SIZEOF_FIELD(SwiftNetPacketInfo, chunk_index)); + memcpy(&buffer[sizeof(struct ip) + prepend_size + offsetof(SwiftNetPacketInfo, chunk_index)], &i, SIZEOF_FIELD(SwiftNetPacketInfo, chunk_index)); - memset(&buffer[offsetof(struct ip, ip_sum)], 0x00, SIZEOF_FIELD(struct ip, ip_sum)); + const uint16_t null_sum = htons(0); + memcpy(&buffer[prepend_size + offsetof(struct ip, ip_sum)], &null_sum, SIZEOF_FIELD(struct ip, ip_sum)); 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; + const uint16_t bytes_to_send = (uint16_t)packet_length - current_offset + PACKET_HEADER_SIZE + prepend_size; - memcpy(&buffer[PACKET_HEADER_SIZE], packet->packet_data_start + current_offset, bytes_to_send - PACKET_HEADER_SIZE); - memcpy(&buffer[offsetof(struct ip, ip_len)], &bytes_to_send, SIZEOF_FIELD(struct ip, ip_len)); + 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)); - const uint16_t checksum = crc16(buffer, bytes_to_send); + HANDLE_CHECKSUM(buffer, bytes_to_send, prepend_size) - memcpy(&buffer[offsetof(struct ip, ip_sum)], &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + swiftnet_pcap_send(pcap, buffer, bytes_to_send); - sendto(sockfd, buffer, bytes_to_send, 0x00, (const struct sockaddr *)target_addr, *target_addr_len); - - handle_lost_packets(new_packet_sending, mtu, packet, sockfd, target_addr, target_addr_len, port_info.source_port, port_info.destination_port, packets_sending_memory_allocator, packets_sending + handle_lost_packets(new_packet_sending, mtu, packet, pcap, eth_hdr, target_addr, port_info.source_port, port_info.destination_port, packets_sending_memory_allocator, packets_sending, loopback, addr_type, prepend_size #ifdef SWIFT_NET_REQUESTS , response , packet_type @@ -312,17 +302,15 @@ inline void swiftnet_send_packet( break; } else { - memcpy(buffer + PACKET_HEADER_SIZE, packet->packet_data_start + current_offset, mtu - PACKET_HEADER_SIZE); - - const uint16_t checksum = crc16(buffer, sizeof(buffer)); + memcpy(buffer + PACKET_HEADER_SIZE + prepend_size, packet->packet_data_start + current_offset, mtu - PACKET_HEADER_SIZE); - memcpy(&buffer[offsetof(struct ip, ip_sum)], &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(buffer, sizeof(buffer), prepend_size) - sendto(sockfd, buffer, sizeof(buffer), 0, (const struct sockaddr *)target_addr, sizeof(*target_addr)); + swiftnet_pcap_send(pcap, buffer, sizeof(buffer)); } } } else { - const uint32_t final_packet_size = PACKET_HEADER_SIZE + packet_length; + const uint32_t final_packet_size = prepend_size + PACKET_HEADER_SIZE + packet_length; const SwiftNetPacketInfo packet_info = construct_packet_info( packet_length, @@ -336,23 +324,37 @@ inline void swiftnet_send_packet( port_info ); - const struct ip ip_header = construct_ip_header(target_addr->sin_addr, final_packet_size, packet_id); + const struct ip ip_header = construct_ip_header(*target_addr, final_packet_size - prepend_size, packet_id); - memcpy(packet->packet_buffer_start, &ip_header, sizeof(struct ip)); - memcpy(packet->packet_buffer_start + sizeof(struct ip), &packet_info, sizeof(SwiftNetPacketInfo)); + if(addr_type == DLT_NULL) { + uint32_t family = PF_INET; + memcpy(packet->packet_buffer_start + sizeof(struct ether_header) - sizeof(family), &family, sizeof(family)); + memcpy(packet->packet_buffer_start + sizeof(struct ether_header), &ip_header, sizeof(ip_header)); + memcpy(packet->packet_buffer_start + sizeof(struct ether_header) + sizeof(struct ip), &packet_info, sizeof(packet_info)); - const uint16_t checksum = crc16(packet->packet_buffer_start, final_packet_size); + memcpy(packet->packet_buffer_start + PACKET_HEADER_SIZE + sizeof(struct ether_header), packet->packet_data_start, packet_length); - memcpy(packet->packet_buffer_start + offsetof(struct ip, ip_sum), &checksum, SIZEOF_FIELD(struct ip, ip_sum)); + HANDLE_CHECKSUM(packet->packet_buffer_start + sizeof(struct ether_header) - sizeof(family), final_packet_size, prepend_size) - sendto(sockfd, packet->packet_buffer_start, final_packet_size, 0, (const struct sockaddr *)target_addr, sizeof(*target_addr)); + swiftnet_pcap_send(pcap, packet->packet_buffer_start + sizeof(struct ether_header) - sizeof(family), final_packet_size); + } else if(addr_type == DLT_EN10MB) { + memcpy(packet->packet_buffer_start, ð_hdr, sizeof(eth_hdr)); + memcpy(packet->packet_buffer_start + sizeof(eth_hdr), &ip_header, sizeof(ip_header)); + memcpy(packet->packet_buffer_start + sizeof(eth_hdr) + sizeof(ip_header), &packet_info, sizeof(packet_info)); + + memcpy(packet->packet_buffer_start + PACKET_HEADER_SIZE + sizeof(struct ether_header), packet->packet_data_start, packet_length); + + HANDLE_CHECKSUM(packet->packet_buffer_start, final_packet_size, prepend_size) + + swiftnet_pcap_send(pcap, packet->packet_buffer_start, final_packet_size); + } } } void swiftnet_client_send_packet(SwiftNetClientConnection* const client, SwiftNetPacketBuffer* const packet) { const uint32_t packet_length = packet->packet_append_pointer - packet->packet_data_start; - swiftnet_send_packet(client, client->maximum_transmission_unit, client->port_info, packet, packet_length, &client->server_addr, &client->server_addr_len, &client->packets_sending, &client->packets_sending_memory_allocator, client->sockfd + swiftnet_send_packet(client, client->maximum_transmission_unit, client->port_info, packet, packet_length, &client->server_addr, &client->packets_sending, &client->packets_sending_memory_allocator, client->pcap, client->eth_header, client->loopback, client->addr_type, client->prepend_size #ifdef SWIFT_NET_REQUESTS , NULL, false, 0 #endif @@ -363,11 +365,11 @@ void swiftnet_server_send_packet(SwiftNetServer* const server, SwiftNetPacketBuf const uint32_t packet_length = packet->packet_append_pointer - packet->packet_data_start; const SwiftNetPortInfo port_info = { - .destination_port = target.sender_address.sin_port, + .destination_port = target.port, .source_port = server->server_port }; - swiftnet_send_packet(server, target.maximum_transmission_unit, port_info, packet, packet_length, &target.sender_address, &target.sender_address_length, &server->packets_sending, &server->packets_sending_memory_allocator, server->sockfd + swiftnet_send_packet(server, target.maximum_transmission_unit, port_info, packet, packet_length, &target.sender_address, &server->packets_sending, &server->packets_sending_memory_allocator, server->pcap, server->eth_header, server->loopback, server->addr_type, server->prepend_size #ifdef SWIFT_NET_REQUESTS , NULL, false, 0 #endif diff --git a/src/swift_net.h b/src/swift_net.h index 75f9010..0ce53c6 100644 --- a/src/swift_net.h +++ b/src/swift_net.h @@ -1,5 +1,6 @@ #pragma once +#include #ifdef __cplusplus extern "C" { @@ -9,9 +10,11 @@ #include #include #include +#include #include #include #include +#include #ifndef SWIFT_NET_DISABLE_ERROR_CHECKING #define SWIFT_NET_ERROR @@ -61,9 +64,9 @@ typedef struct { } SwiftNetPortInfo; typedef struct { - struct sockaddr_in sender_address; - socklen_t sender_address_length; + struct in_addr sender_address; uint32_t maximum_transmission_unit; + uint16_t port; } SwiftNetClientAddrData; typedef struct { @@ -127,7 +130,7 @@ typedef struct { uint8_t* packet_data_start; SwiftNetPacketInfo packet_info; uint16_t packet_id; - in_addr_t sender_address; + struct in_addr sender_address; uint8_t* chunks_received; uint32_t chunks_received_length; uint32_t chunks_received_number; @@ -139,7 +142,7 @@ struct PacketQueueNode { PacketQueueNode* next; uint8_t* data; uint32_t data_read; - struct sockaddr_in sender_address; + struct in_addr sender_address; socklen_t server_address_length; }; @@ -211,13 +214,16 @@ typedef struct { // Connection data typedef struct { - int sockfd; + pcap_t* pcap; + struct ether_header eth_header; SwiftNetPortInfo port_info; - struct sockaddr_in server_addr; + struct in_addr server_addr; socklen_t server_addr_len; _Atomic(void (*)(SwiftNetClientPacketData* const)) packet_handler; _Atomic bool closing; - pthread_t handle_packets_thread; + _Atomic bool initialized; + uint16_t addr_type; + bool loopback; pthread_t process_packets_thread; pthread_t execute_callback_thread; uint32_t maximum_transmission_unit; @@ -229,14 +235,17 @@ typedef struct { SwiftNetMemoryAllocator packets_completed_memory_allocator; PacketQueue packet_queue; PacketCallbackQueue packet_callback_queue; + uint8_t prepend_size; } SwiftNetClientConnection; typedef struct { - int sockfd; + pcap_t* pcap; + struct ether_header eth_header; uint16_t server_port; _Atomic(void (*)(SwiftNetServerPacketData* const)) packet_handler; _Atomic bool closing; - pthread_t handle_packets_thread; + uint16_t addr_type; + bool loopback; pthread_t process_packets_thread; pthread_t execute_callback_thread; SwiftNetVector pending_messages; @@ -248,6 +257,7 @@ typedef struct { uint8_t* current_read_pointer; PacketQueue packet_queue; PacketCallbackQueue packet_callback_queue; + uint8_t prepend_size; } SwiftNetServer; extern void swiftnet_server_set_message_handler(volatile SwiftNetServer* const server, void (* const new_handler)(SwiftNetServerPacketData* const)); @@ -257,8 +267,6 @@ extern void swiftnet_server_append_to_packet(const void* const data, const uint3 extern void swiftnet_client_cleanup(SwiftNetClientConnection* const client); extern void swiftnet_server_cleanup(SwiftNetServer* const server); extern void swiftnet_initialize(); -extern void* swiftnet_server_handle_packets(void* const server_void); -extern void* swiftnet_client_handle_packets(void* const client_void); extern void swiftnet_client_send_packet (SwiftNetClientConnection* const client, SwiftNetPacketBuffer* const packet); extern void swiftnet_server_send_packet (SwiftNetServer* const server, SwiftNetPacketBuffer* const packet, const SwiftNetClientAddrData target); @@ -266,7 +274,7 @@ extern SwiftNetPacketBuffer swiftnet_server_create_packet_buffer(const uint32_t extern SwiftNetPacketBuffer swiftnet_client_create_packet_buffer(const uint32_t buffer_size); extern void swiftnet_server_destroy_packet_buffer(const SwiftNetPacketBuffer* const packet); extern void swiftnet_client_destroy_packet_buffer(const SwiftNetPacketBuffer* const packet); -extern SwiftNetServer* swiftnet_create_server(const uint16_t port); +extern SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool loopback); 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); diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index dc2214b..76cc235 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required(VERSION 3.15) -project(SocketProtocol C) +project(SwiftNetTests C) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}/output) @@ -28,11 +28,12 @@ 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_link_libraries(${exec_name} swiftnet) + target_compile_options(${exec_name} PRIVATE) + target_link_libraries(${exec_name} swiftnet pcap) endforeach() set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) add_executable(run_all_tests run_all_tests.c) -target_link_libraries(run_all_tests swiftnet) +target_link_libraries(run_all_tests swiftnet pcap) target_link_options(run_all_tests PRIVATE -g -O0) diff --git a/tests/config.h b/tests/config.h index b5102ca..af5c5c6 100644 --- a/tests/config.h +++ b/tests/config.h @@ -1,3 +1,4 @@ #pragma once #define IP_ADDRESS "127.0.0.1" +#define LOOPBACK true diff --git a/tests/src/test_basic_client_server_communication.c b/tests/src/test_basic_client_server_communication.c index 6c99851..26b609c 100644 --- a/tests/src/test_basic_client_server_communication.c +++ b/tests/src/test_basic_client_server_communication.c @@ -21,7 +21,16 @@ void client_message_handler(SwiftNetClientPacketData* const packet_data) { 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) { @@ -35,6 +44,15 @@ void server_message_handler(SwiftNetServerPacketData* const packet_data) { 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); }; } @@ -43,7 +61,7 @@ int main() { swiftnet_initialize(); - server = swiftnet_create_server(8080); + server = swiftnet_create_server(8080, LOOPBACK); swiftnet_server_set_message_handler(server, server_message_handler); client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); diff --git a/tests/src/test_client_making_requests.c b/tests/src/test_client_making_requests.c index 2fcbf69..537cd49 100644 --- a/tests/src/test_client_making_requests.c +++ b/tests/src/test_client_making_requests.c @@ -17,7 +17,7 @@ void client_message_handler(SwiftNetClientPacketData* const packet_data) { swiftnet_cleanup(); - exit(EXIT_SUCCESS); + exit(EXIT_FAILURE); } void server_message_handler(SwiftNetServerPacketData* const packet_data) { @@ -31,6 +31,15 @@ void server_message_handler(SwiftNetServerPacketData* const packet_data) { 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); }; } @@ -39,7 +48,7 @@ int main() { swiftnet_initialize(); - server = swiftnet_create_server(8080); + server = swiftnet_create_server(8080, LOOPBACK); swiftnet_server_set_message_handler(server, server_message_handler); client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); diff --git a/tests/src/test_client_sending_large_packet_to_server.c b/tests/src/test_client_sending_large_packet_to_server.c index 999d6f1..e6beac0 100644 --- a/tests/src/test_client_sending_large_packet_to_server.c +++ b/tests/src/test_client_sending_large_packet_to_server.c @@ -13,7 +13,7 @@ SwiftNetServer* server; _Atomic bool finished_sending = false; -uint32_t* random_generated_data = NULL; +uint8_t* random_generated_data = NULL; void client_message_handler(SwiftNetClientPacketData* const packet_data) { } @@ -23,11 +23,11 @@ void server_message_handler(SwiftNetServerPacketData* const packet_data) { usleep(1000); } - for(uint32_t i = 0; i < packet_data->metadata.data_length / 4; i++) { - const uint32_t data_received = *(uint32_t*)swiftnet_server_read_packet(packet_data, 4); + 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, packet_data->data[i], random_generated_data[i]); + 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(); @@ -54,13 +54,13 @@ int main() { return EXIT_FAILURE; } - for(uint32_t i = 0; i < DATA_TO_SEND / 4; i++) { - random_generated_data[i] = i; + for(uint32_t i = 0; i < DATA_TO_SEND / 1; i++) { + random_generated_data[i] = rand(); } swiftnet_initialize(); - server = swiftnet_create_server(8080); + server = swiftnet_create_server(8080, LOOPBACK); swiftnet_server_set_message_handler(server, server_message_handler); client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); diff --git a/tests/src/test_multiple_server_communication.c b/tests/src/test_multiple_server_communication.c index ab93f8b..e689438 100644 --- a/tests/src/test_multiple_server_communication.c +++ b/tests/src/test_multiple_server_communication.c @@ -62,13 +62,13 @@ int main() { swiftnet_initialize(); - server = swiftnet_create_server(FIRST_PORT); + 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); + 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); diff --git a/tests/src/test_server_making_requests.c b/tests/src/test_server_making_requests.c index 0e2f888..efceaf8 100644 --- a/tests/src/test_server_making_requests.c +++ b/tests/src/test_server_making_requests.c @@ -22,6 +22,15 @@ void client_message_handler(SwiftNetClientPacketData* const packet_data) { 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); }; } @@ -75,7 +84,7 @@ int main() { swiftnet_initialize(); - server = swiftnet_create_server(8080); + server = swiftnet_create_server(8080, LOOPBACK); swiftnet_server_set_message_handler(server, server_message_handler); client = swiftnet_create_client(IP_ADDRESS, 8080, 2000); diff --git a/tests/src/test_server_sending_large_packet_to_client.c b/tests/src/test_server_sending_large_packet_to_client.c index b1051eb..e8fd1c4 100644 --- a/tests/src/test_server_sending_large_packet_to_client.c +++ b/tests/src/test_server_sending_large_packet_to_client.c @@ -69,7 +69,7 @@ int main() { swiftnet_initialize(); - server = swiftnet_create_server(8080); + server = swiftnet_create_server(8080, LOOPBACK); swiftnet_server_set_message_handler(server, server_message_handler); client = swiftnet_create_client(IP_ADDRESS, 8080, 2000);