Issue 152

src/3

@@ -0,0 +1,83 @@
+#include <stdatomic.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <arpa/inet.h>
+#include <netinet/ip.h>
+#include <netinet/in.h>
+#include <sys/socket.h>
+#include <pthread.h>
+#include <stdbool.h>
+#include "internal/internal.h"
+#include "swift_net.h"
+
+static inline struct SwiftNetServer* const construct_server(const bool loopback, const uint16_t server_port, pcap_t* const pcap) {
+    struct SwiftNetServer* const new_server = allocator_allocate(&server_memory_allocator);
+
+    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->server_port = server_port;
+    new_server->loopback = loopback;
+    new_server->pcap = pcap;
+    new_server->addr_type = pcap_datalink(pcap);
+    new_server->prepend_size = PACKET_PREPEND_SIZE(new_server->addr_type);
+    new_server->packet_queue = (struct PacketQueue){
+        .first_node = NULL,
+        .last_node = NULL
+    };
+
+    memset(&new_server->packet_callback_queue, 0x00, sizeof(struct PacketCallbackQueue));
+
+    atomic_store_explicit(&new_server->packet_queue.owner, NONE, memory_order_release);
+    atomic_store_explicit(&new_server->packet_callback_queue.owner, NONE, memory_order_release);
+    atomic_store_explicit(&new_server->packet_handler, NULL, memory_order_release);
+    atomic_store_explicit(&new_server->packet_handler_user_arg, NULL, memory_order_release);
+    atomic_store_explicit(&new_server->closing, false, memory_order_release);
+
+    new_server->pending_messages_memory_allocator = allocator_create(sizeof(struct SwiftNetPendingMessage), 100);
+    new_server->pending_messages = vector_create(100);
+    new_server->packets_sending_memory_allocator = allocator_create(sizeof(struct SwiftNetPacketSending), 100);
+    new_server->packets_sending = vector_create(100);
+    new_server->packets_completed_memory_allocator = allocator_create(sizeof(struct SwiftNetPacketCompleted), 100);
+    new_server->packets_completed = vector_create(100);
+
+    return new_server;
+}
+
+struct SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool loopback) {
+    // Init pcap device
+    pcap_t* const pcap = swiftnet_pcap_open(loopback ? LOOPBACK_INTERFACE_NAME : default_network_interface);
+    if (unlikely(pcap == NULL)) {
+        PRINT_ERROR("Failed to open bpf");
+        return NULL;
+    }
+
+    struct SwiftNetServer* const new_server = construct_server(loopback, port, pcap);
+
+    // Create a new thread that will handle all packets received
+    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);
+
+    pthread_mutex_init(&new_server->process_packets_mtx, NULL);
+    pthread_mutex_init(&new_server->execute_callback_mtx, NULL);
+
+    pthread_cond_init(&new_server->process_packets_cond, NULL);
+
+    #ifdef SWIFT_NET_DEBUG
+        if (check_debug_flag(INITIALIZATION)) {
+            send_debug_message("Successfully initialized server\n");
+        }
+    #endif
+
+    return new_server;
+}

src/cleanup_connection.c

@@ -2,6 +2,7 @@
 #include "swift_net.h"
 #include <stdatomic.h>
 #include <stdint.h>
+#include <stdlib.h>
 #include <unistd.h>
 
 static inline void cleanup_connection_resources(const enum ConnectionType connection_type, void* const connection) {
@@ -83,15 +84,43 @@ static inline void close_threads(const enum ConnectionType connection_type, void
 
         atomic_store_explicit(&client->closing, true, memory_order_release);
 
+        pthread_mutex_lock(&client->process_packets_mtx);
+        pthread_cond_signal(&client->process_packets_cond);
+        pthread_mutex_unlock(&client->process_packets_mtx);
+
+        pthread_mutex_lock(&client->execute_callback_mtx);
+        pthread_cond_signal(&client->execute_callback_cond);
+        pthread_mutex_unlock(&client->execute_callback_mtx);
+
         pthread_join(client->process_packets_thread, NULL);
         pthread_join(client->execute_callback_thread, NULL);
+
+        pthread_mutex_destroy(&client->process_packets_mtx);
+        pthread_mutex_destroy(&client->execute_callback_mtx);
+
+        pthread_cond_destroy(&client->process_packets_cond);
+        pthread_cond_destroy(&client->execute_callback_cond);
     } else {
         struct SwiftNetServer* const server = connection;
 
         atomic_store_explicit(&server->closing, true, memory_order_release);
 
+        pthread_mutex_lock(&server->process_packets_mtx);
+        pthread_cond_signal(&server->process_packets_cond);
+        pthread_mutex_unlock(&server->process_packets_mtx);
+
+        pthread_mutex_lock(&server->execute_callback_mtx);
+        pthread_cond_signal(&server->execute_callback_cond);
+        pthread_mutex_unlock(&server->execute_callback_mtx);
+
         pthread_join(server->process_packets_thread, NULL);
         pthread_join(server->execute_callback_thread, NULL);
+
+        pthread_mutex_destroy(&server->process_packets_mtx);
+        pthread_mutex_destroy(&server->execute_callback_mtx);
+
+        pthread_cond_destroy(&server->process_packets_cond);
+        pthread_cond_destroy(&server->execute_callback_cond);
     }
 }
 

src/execute_packet_callback.c

@@ -53,17 +53,37 @@ static inline void remove_pending_message_from_vector(struct SwiftNetVector* con
     vector_unlock(pending_messages);
 }
 
-void execute_packet_callback(struct PacketCallbackQueue* const queue, void (* const _Atomic * const packet_handler) (void* const, void* const), const enum ConnectionType connection_type, struct SwiftNetMemoryAllocator* const pending_message_memory_allocator, _Atomic bool* closing, void* const connection, struct SwiftNetVector* const pending_messages, _Atomic(void*)* user_data) {
+void execute_packet_callback(
+    struct PacketCallbackQueue* const queue,
+	void (* const _Atomic * const packet_handler) (void* const,
+	void* const),
+	const enum ConnectionType connection_type,
+	struct SwiftNetMemoryAllocator* const pending_message_memory_allocator,
+	_Atomic bool* closing,
+	void* const connection,
+	struct SwiftNetVector* const pending_messages,
+	_Atomic(void*)* user_data,
+    pthread_mutex_t* const execute_callback_mtx,
+    pthread_cond_t* const execute_callback_cond
+) {
     while (1) {
         if (atomic_load_explicit(closing, memory_order_acquire) == true) {
             break;
         }
 
+        pthread_mutex_lock(execute_callback_mtx);
+
         const struct PacketCallbackQueueNode* const node = wait_for_next_packet_callback(queue);
         if(node == NULL) {
+            pthread_cond_wait(execute_callback_cond, execute_callback_mtx);
+
+            pthread_mutex_unlock(execute_callback_mtx);
+
             continue;
         }
 
+        pthread_mutex_unlock(execute_callback_mtx);
+
         atomic_thread_fence(memory_order_acquire);
 
         if(node->packet_data == NULL) {
@@ -97,15 +117,15 @@ void execute_packet_callback(struct PacketCallbackQueue* const queue, void (* co
 void* execute_packet_callback_client(void* const void_client) {
     struct SwiftNetClientConnection* const client = void_client;
 
-    execute_packet_callback(&client->packet_callback_queue, (void*)&client->packet_handler, CONNECTION_TYPE_CLIENT, &client->pending_messages_memory_allocator, &client->closing, void_client, &client->pending_messages, &client->packet_handler_user_arg);
+    execute_packet_callback(&client->packet_callback_queue, (void*)&client->packet_handler, CONNECTION_TYPE_CLIENT, &client->pending_messages_memory_allocator, &client->closing, void_client, &client->pending_messages, &client->packet_handler_user_arg, &client->execute_callback_mtx, &client->execute_callback_cond);
 
     return NULL;
 }
 
 void* execute_packet_callback_server(void* const void_server) {
     struct SwiftNetServer* const server = void_server;
 
-    execute_packet_callback(&server->packet_callback_queue, (void*)&server->packet_handler, CONNECTION_TYPE_SERVER, &server->pending_messages_memory_allocator, &server->closing, void_server, &server->pending_messages, &server->packet_handler_user_arg);
+    execute_packet_callback(&server->packet_callback_queue, (void*)&server->packet_handler, CONNECTION_TYPE_SERVER, &server->pending_messages_memory_allocator, &server->closing, void_server, &server->pending_messages, &server->packet_handler_user_arg, &server->execute_callback_mtx, &server->execute_callback_cond);
 
     return NULL;
 }

src/handle_packets.c

@@ -21,7 +21,12 @@ static inline void unlock_packet_queue(struct PacketQueue* const packet_queue) {
     atomic_store_explicit(&packet_queue->owner, NONE, memory_order_release);
 }
 
-static inline void insert_queue_node(struct PacketQueueNode* const new_node, struct PacketQueue* const packet_queue, const enum ConnectionType contype) {
+static inline void insert_queue_node(
+    struct PacketQueueNode* const new_node,
+    struct PacketQueue* const packet_queue,
+    const enum ConnectionType contype
+
+) {
     if(new_node == NULL) {
         return;
     }
@@ -60,7 +65,21 @@ static inline struct PacketQueueNode* construct_node(const uint32_t data_read, v
     return node;
 }
 
-static inline void swiftnet_handle_packets(const uint16_t source_port, pthread_t* const process_packets_thread, void* connection, const enum ConnectionType connection_type, struct 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) {
+static inline void swiftnet_handle_packets(
+    const uint16_t source_port,
+	pthread_t* const process_packets_thread,
+	void* connection,
+	const enum ConnectionType connection_type,
+	struct 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,
+    pthread_mutex_t* const process_packets_mtx,
+    pthread_cond_t* const process_packets_cond
+
+) {
     uint8_t* const packet_buffer = allocator_allocate(&packet_buffer_memory_allocator);
     if (unlikely(packet_buffer == NULL)) {
         return;
@@ -94,7 +113,13 @@ static inline void swiftnet_handle_packets(const uint16_t source_port, pthread_t
 
     atomic_thread_fence(memory_order_release);
 
+    pthread_mutex_lock(process_packets_mtx);
+
     insert_queue_node(node, packet_queue, connection_type);
+
+    pthread_cond_signal(process_packets_cond);
+
+    pthread_mutex_unlock(process_packets_mtx);
 }
 
 static void handle_client_init(struct SwiftNetClientConnection* user, const struct pcap_pkthdr* hdr, const uint8_t* buffer) {
@@ -161,7 +186,7 @@ static inline void handle_correct_receiver(const enum ConnectionType connection_
                 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);
+                    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, &client_connection->process_packets_mtx, &client_connection->process_packets_cond);
                 }
 
                 return;
@@ -177,7 +202,7 @@ static inline void handle_correct_receiver(const enum ConnectionType connection_
             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);
+                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, &server->process_packets_mtx, &server->process_packets_cond);
 
                 return;
             }

src/initialize_client_socket.c

@@ -179,6 +179,12 @@ struct SwiftNetClientConnection* swiftnet_create_client(const char* const ip_add
     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);
 
+    pthread_mutex_init(&new_connection->process_packets_mtx, NULL);
+    pthread_mutex_init(&new_connection->execute_callback_mtx, NULL);
+
+    pthread_cond_init(&new_connection->process_packets_cond, NULL);
+    pthread_cond_init(&new_connection->execute_callback_cond, NULL);
+
     #ifdef SWIFT_NET_DEBUG
         if (check_debug_flag(INITIALIZATION)) {
             send_debug_message("Successfully initialized client\n");

src/initialize_server_socket.c

@@ -68,6 +68,12 @@ struct SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool lo
     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);
 
+    pthread_mutex_init(&new_server->process_packets_mtx, NULL);
+    pthread_mutex_init(&new_server->execute_callback_mtx, NULL);
+
+    pthread_cond_init(&new_server->process_packets_cond, NULL);
+    pthread_cond_init(&new_server->execute_callback_cond, NULL);
+
     #ifdef SWIFT_NET_DEBUG
         if (check_debug_flag(INITIALIZATION)) {
             send_debug_message("Successfully initialized server\n");

src/initialize_swift_net.c

@@ -18,6 +18,8 @@
     uint32_t items_leaked = 0;
 #endif
 
+uint32_t semaphore_counter = 0x00;
+
 uint32_t maximum_transmission_unit = 0x00;
 struct in_addr private_ip_address;
 uint8_t mac_address[6];

src/internal/internal.h

@@ -184,6 +184,8 @@ extern void* check_existing_listener(const char* interface_name, void* const con
 #define ALLOCATOR_STACK_OCCUPIED 1
 #define ALLOCATOR_STACK_FREE 0
 
+extern uint32_t semaphore_counter;
+
 extern struct SwiftNetMemoryAllocator allocator_create(const uint32_t item_size, const uint32_t chunk_item_amount);
 extern void* allocator_allocate(struct SwiftNetMemoryAllocator* const memory_allocator);
 extern void allocator_free(struct SwiftNetMemoryAllocator* const memory_allocator, void* const memory_location);