Issue 120

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

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")

src/cleanup.c

@@ -1,17 +1,39 @@
 #include "internal/internal.h"
 #include "swift_net.h"
+#include <stdint.h>
 
 void swiftnet_cleanup() {
     allocator_destroy(&packet_queue_node_memory_allocator);
     allocator_destroy(&packet_callback_queue_node_memory_allocator);
     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(&current_listener->client_connections);
+        vector_destroy(&current_listener->servers);
+    }
+
+    vector_destroy(&listeners);
+
+    allocator_destroy(&server_memory_allocator);
+    allocator_destroy(&client_connection_memory_allocator);
+
+    allocator_destroy(&listener_memory_allocator);
 }

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);
 }

src/create_packet_buffer.c

@@ -4,9 +4,9 @@
 #include <stdlib.h>
 
 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,

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);
                 }
             }

src/handle_packets.c

@@ -1,6 +1,7 @@
 #include "swift_net.h"
 #include <arpa/inet.h>
 #include <stdatomic.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <unistd.h>
 #include <string.h>
@@ -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;
 }