Issue 115

src/append_to_packet.c

@@ -18,15 +18,15 @@ static inline void append_data(uint8_t** const append_pointer, const void* const
     (*append_pointer) += data_size;
 }
 
-void swiftnet_client_append_to_packet(const void* const data, const uint32_t data_size, SwiftNetPacketBuffer* const packet) {
+void swiftnet_client_append_to_packet(const void* const data, const uint32_t data_size, struct SwiftNetPacketBuffer* const packet) {
     #ifdef SWIFT_NET_ERROR
         validate_args(data, data_size, __func__);
     #endif
 
     append_data(&packet->packet_append_pointer, data, data_size);
 }
 
-void swiftnet_server_append_to_packet(const void* const data, const uint32_t data_size, SwiftNetPacketBuffer* const packet) {
+void swiftnet_server_append_to_packet(const void* const data, const uint32_t data_size, struct SwiftNetPacketBuffer* const packet) {
     #ifdef SWIFT_NET_ERROR
         validate_args(data, data_size, __func__);
     #endif

src/cleanup.c

@@ -18,7 +18,7 @@ void swiftnet_cleanup() {
     vector_lock(&listeners);
 
     for (uint16_t i = 0; i < listeners.size; i++) {
-        Listener* const current_listener = vector_get(&listeners, i);
+        struct Listener* const current_listener = vector_get(&listeners, i);
 
         pcap_breakloop(current_listener->pcap);
 

src/cleanup_connection.c

@@ -4,7 +4,7 @@
 #include <stdint.h>
 #include <unistd.h>
 
-void swiftnet_client_cleanup(SwiftNetClientConnection* const client) {
+void swiftnet_client_cleanup(struct SwiftNetClientConnection* const client) {
     allocator_destroy(&client->packets_sending_memory_allocator);
     allocator_destroy(&client->pending_messages_memory_allocator);
     allocator_destroy(&client->packets_completed_memory_allocator);
@@ -18,12 +18,12 @@ void swiftnet_client_cleanup(SwiftNetClientConnection* const client) {
     vector_lock(&listeners);
 
     for (uint16_t i = 0; i < listeners.size; i++) {
-        Listener* const current_listener = vector_get(&listeners, i);
+        struct Listener* const current_listener = vector_get(&listeners, i);
         if (strcmp(interface_name, current_listener->interface_name) == 0) {
             vector_lock(&current_listener->client_connections);
 
             for (uint16_t inx = 0; inx < current_listener->client_connections.size; inx++) {
-                SwiftNetClientConnection* const current_client_conn = vector_get(&current_listener->client_connections, i);
+                struct SwiftNetClientConnection* const current_client_conn = vector_get(&current_listener->client_connections, i);
                 if (current_client_conn != client) {
                     continue;
                 }
@@ -51,7 +51,7 @@ void swiftnet_client_cleanup(SwiftNetClientConnection* const client) {
     allocator_free(&client_connection_memory_allocator, client);
 }
 
-void swiftnet_server_cleanup(SwiftNetServer* const server) {
+void swiftnet_server_cleanup(struct SwiftNetServer* const server) {
     allocator_destroy(&server->packets_sending_memory_allocator);
     allocator_destroy(&server->pending_messages_memory_allocator);
     allocator_destroy(&server->packets_completed_memory_allocator);
@@ -65,12 +65,12 @@ void swiftnet_server_cleanup(SwiftNetServer* const server) {
     vector_lock(&listeners);
 
     for (uint16_t i = 0; i < listeners.size; i++) {
-        Listener* const current_listener = vector_get(&listeners, i);
+        struct Listener* const current_listener = vector_get(&listeners, i);
         if (strcmp(interface_name, current_listener->interface_name) == 0) {
             vector_lock(&current_listener->servers);
 
             for (uint16_t inx = 0; inx < current_listener->servers.size; inx++) {
-                SwiftNetServer* const current_server = vector_get(&current_listener->servers, i);
+                struct SwiftNetServer* const current_server = vector_get(&current_listener->servers, i);
                 if (current_server != server) {
                     continue;
                 }

src/create_packet_buffer.c

@@ -3,22 +3,22 @@
 #include <stdint.h>
 #include <stdlib.h>
 
-static inline SwiftNetPacketBuffer create_packet_buffer(const uint32_t buffer_size) {
+static inline struct SwiftNetPacketBuffer create_packet_buffer(const uint32_t buffer_size) {
     uint8_t* const mem = malloc(buffer_size + PACKET_HEADER_SIZE + sizeof(struct ether_header));
 
     uint8_t* const data_pointer = mem + PACKET_HEADER_SIZE + sizeof(struct ether_header);
 
-    return (SwiftNetPacketBuffer){
+    return (struct SwiftNetPacketBuffer){
         .packet_buffer_start = mem,
         .packet_data_start = data_pointer,
         .packet_append_pointer = data_pointer 
     };
 }
 
-SwiftNetPacketBuffer swiftnet_server_create_packet_buffer(const uint32_t buffer_size) {
+struct SwiftNetPacketBuffer swiftnet_server_create_packet_buffer(const uint32_t buffer_size) {
     return create_packet_buffer(buffer_size);
 }
 
-SwiftNetPacketBuffer swiftnet_client_create_packet_buffer(const uint32_t buffer_size) {
+struct SwiftNetPacketBuffer swiftnet_client_create_packet_buffer(const uint32_t buffer_size) {
     return create_packet_buffer(buffer_size);
 }

src/destroy_packet_buffer.c

@@ -1,10 +1,10 @@
 #include "swift_net.h"
 #include <stdlib.h>
 
-void swiftnet_server_destroy_packet_buffer(const SwiftNetPacketBuffer* const packet) {
+void swiftnet_server_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet) {
     free(packet->packet_buffer_start);
 }
 
-void swiftnet_client_destroy_packet_buffer(const SwiftNetPacketBuffer* const packet) {
+void swiftnet_client_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet) {
     free(packet->packet_buffer_start);
 }

src/execute_packet_callback.c

@@ -6,7 +6,7 @@
 #include <unistd.h>
 #include <pthread.h>
 
-static PacketCallbackQueueNode* const wait_for_next_packet_callback(PacketCallbackQueue* const packet_queue) {
+static struct PacketCallbackQueueNode* const wait_for_next_packet_callback(struct PacketCallbackQueue* const packet_queue) {
     uint32_t owner_none = PACKET_CALLBACK_QUEUE_OWNER_NONE;
     while(!atomic_compare_exchange_strong_explicit(&packet_queue->owner, &owner_none, PACKET_CALLBACK_QUEUE_OWNER_EXECUTE_PACKET_CALLBACK, memory_order_acquire, memory_order_relaxed)) {
         owner_none = PACKET_CALLBACK_QUEUE_OWNER_NONE;
@@ -17,7 +17,7 @@ static PacketCallbackQueueNode* const wait_for_next_packet_callback(PacketCallba
         return NULL;
     }
 
-    PacketCallbackQueueNode* const node_to_process = packet_queue->first_node;
+    struct PacketCallbackQueueNode* const node_to_process = packet_queue->first_node;
 
     if(node_to_process->next == NULL) {
         packet_queue->first_node = NULL;
@@ -35,13 +35,13 @@ static PacketCallbackQueueNode* const wait_for_next_packet_callback(PacketCallba
     return node_to_process;
 }
 
-void execute_packet_callback(PacketCallbackQueue* const queue, void (* const _Atomic * const packet_handler) (void* const), const uint8_t connection_type, SwiftNetMemoryAllocator* const pending_message_memory_allocator, _Atomic bool* closing, const void* const connection, SwiftNetVector* const pending_messages) {
+void execute_packet_callback(struct PacketCallbackQueue* const queue, void (* const _Atomic * const packet_handler) (void* const), const uint8_t connection_type, struct SwiftNetMemoryAllocator* const pending_message_memory_allocator, _Atomic bool* closing, const void* const connection, struct SwiftNetVector* const pending_messages) {
     while (1) {
         if (atomic_load_explicit(closing, memory_order_acquire) == true) {
             break;
         }
 
-        const PacketCallbackQueueNode* const node = wait_for_next_packet_callback(queue);
+        const struct PacketCallbackQueueNode* const node = wait_for_next_packet_callback(queue);
         if(node == NULL) {
             continue;
         }
@@ -57,7 +57,7 @@ void execute_packet_callback(PacketCallbackQueue* const queue, void (* const _At
             vector_lock(pending_messages);
 
             for (uint32_t i = 0; i < pending_messages->size; i++) {
-                const SwiftNetPendingMessage* const pending_message = vector_get(pending_messages, i);
+                const struct SwiftNetPendingMessage* const pending_message = vector_get(pending_messages, i);
                 if (pending_message == node->pending_message) {
                     vector_remove(pending_messages, i);
                 }
@@ -75,15 +75,15 @@ void execute_packet_callback(PacketCallbackQueue* const queue, void (* const _At
 }
 
 void* execute_packet_callback_client(void* const void_client) {
-    SwiftNetClientConnection* const client = void_client;
+    struct SwiftNetClientConnection* const client = void_client;
 
     execute_packet_callback(&client->packet_callback_queue, (void*)&client->packet_handler, 0, &client->pending_messages_memory_allocator, &client->closing, void_client, &client->pending_messages);
 
     return NULL;
 }
 
 void* execute_packet_callback_server(void* const void_server) {
-    SwiftNetServer* const server = void_server;
+    struct SwiftNetServer* const server = void_server;
 
     execute_packet_callback(&server->packet_callback_queue, (void*)&server->packet_handler, 1, &server->pending_messages_memory_allocator, &server->closing, void_server, &server->pending_messages);
 

src/generic_functions.c

@@ -15,21 +15,21 @@ static inline void swiftnet_validate_new_handler(const void* const new_handler,
     #endif
 }
 
-void swiftnet_client_set_message_handler(SwiftNetClientConnection* const client, void (* const new_handler)(SwiftNetClientPacketData* const)) {
+void swiftnet_client_set_message_handler(struct SwiftNetClientConnection* const client, void (* const new_handler)(struct SwiftNetClientPacketData* const)) {
     swiftnet_validate_new_handler(new_handler, __func__);
 
     atomic_store(&client->packet_handler, new_handler);
 }
 
-void swiftnet_server_set_message_handler(SwiftNetServer* const server, void (* const new_handler)(SwiftNetServerPacketData* const)) {
+void swiftnet_server_set_message_handler(struct SwiftNetServer* const server, void (* const new_handler)(struct SwiftNetServerPacketData* const)) {
     swiftnet_validate_new_handler(new_handler, __func__);
 
     atomic_store(&server->packet_handler, new_handler);
 }
 
 // Read packet data into buffers
 
-void* swiftnet_client_read_packet(SwiftNetClientPacketData* const packet_data, const uint32_t data_size) {
+void* swiftnet_client_read_packet(struct SwiftNetClientPacketData* const packet_data, const uint32_t data_size) {
     const uint32_t data_already_read = (packet_data->current_pointer - packet_data->data) + data_size;
     if (data_already_read > packet_data->metadata.data_length) {
         fprintf(stderr, "Error: Tried to read more data than there actually is\n");
@@ -43,7 +43,7 @@ void* swiftnet_client_read_packet(SwiftNetClientPacketData* const packet_data, c
     return ptr;
 }
 
-void* swiftnet_server_read_packet(SwiftNetServerPacketData* const packet_data, const uint32_t data_size) {
+void* swiftnet_server_read_packet(struct SwiftNetServerPacketData* const packet_data, const uint32_t data_size) {
     const uint32_t data_already_read = (packet_data->current_pointer - packet_data->data) + data_size;
     if (data_already_read > packet_data->metadata.data_length) {
         fprintf(stderr, "Error: Tried to read more data than there actually is\n");
@@ -57,7 +57,7 @@ void* swiftnet_server_read_packet(SwiftNetServerPacketData* const packet_data, c
     return ptr;
 }
 
-void swiftnet_client_destroy_packet_data(SwiftNetClientPacketData* const packet_data, SwiftNetClientConnection* const client_conn) {
+void swiftnet_client_destroy_packet_data(struct SwiftNetClientPacketData* const packet_data, struct SwiftNetClientConnection* const client_conn) {
     if(packet_data->internal_pending_message != NULL) {
         free(packet_data->internal_pending_message->chunks_received);
 
@@ -70,7 +70,7 @@ void swiftnet_client_destroy_packet_data(SwiftNetClientPacketData* const packet_
     }
 }
 
-void swiftnet_server_destroy_packet_data(SwiftNetServerPacketData* const packet_data, SwiftNetServer* const server) {
+void swiftnet_server_destroy_packet_data(struct SwiftNetServerPacketData* const packet_data, struct SwiftNetServer* const server) {
     if(packet_data->internal_pending_message != NULL) {
         free(packet_data->internal_pending_message->chunks_received);
 

src/handle_packets.c

@@ -10,7 +10,7 @@
 #include "internal/internal.h"
 #include <stddef.h>
 
-static inline void insert_queue_node(PacketQueueNode* const new_node, volatile PacketQueue* const packet_queue, const 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;
     }
@@ -37,8 +37,8 @@ static inline void insert_queue_node(PacketQueueNode* const new_node, volatile P
     return;
 }
 
-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);
+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) {
+    struct PacketQueueNode *node = allocator_allocate(&packet_queue_node_memory_allocator);
     if (unlikely(node == NULL)) {
         return;
     }
@@ -83,28 +83,28 @@ static inline void swiftnet_handle_packets(const uint16_t source_port, pthread_t
     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;
+static void handle_client_init(struct SwiftNetClientConnection* user, const struct pcap_pkthdr* hdr, const uint8_t* buffer) {
+    struct SwiftNetClientConnection* const client_connection = (struct SwiftNetClientConnection*)user;
 
     if (atomic_load_explicit(&client_connection->closing, memory_order_acquire) == true) {
         return;
     }
 
     const uint32_t bytes_received = hdr->caplen;
 
-    if(bytes_received != PACKET_HEADER_SIZE + sizeof(SwiftNetServerInformation) + client_connection->prepend_size) {
+    if(bytes_received != PACKET_HEADER_SIZE + sizeof(struct 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));
+                send_debug_message("Invalid packet received from server. Expected server information: {\"bytes_received\": %u, \"expected_bytes\": %u}\n", bytes_received, PACKET_HEADER_SIZE + sizeof(struct SwiftNetServerInformation));
             }
         #endif
 
         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));
+    struct SwiftNetPacketInfo* packet_info = (struct SwiftNetPacketInfo*)(buffer + client_connection->prepend_size + sizeof(struct ip));
+    struct SwiftNetServerInformation* server_information = (struct SwiftNetServerInformation*)(buffer + client_connection->prepend_size + sizeof(struct ip) + sizeof(struct 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
@@ -131,14 +131,14 @@ static void handle_client_init(SwiftNetClientConnection* user, const struct pcap
 }
 
 static void pcap_packet_handle(uint8_t* user, const struct pcap_pkthdr* hdr, const uint8_t* packet) {
-    Listener* const listener = (Listener*)user;
+    struct Listener* const listener = (struct Listener*)user;
 
-    SwiftNetPortInfo* const port_info = (SwiftNetPortInfo*)(packet + PACKET_PREPEND_SIZE(listener->addr_type) + sizeof(struct ip) + offsetof(SwiftNetPacketInfo, port_info));
+    struct SwiftNetPortInfo* const port_info = (struct SwiftNetPortInfo*)(packet + PACKET_PREPEND_SIZE(listener->addr_type) + sizeof(struct ip) + offsetof(struct SwiftNetPacketInfo, port_info));
 
     vector_lock(&listener->servers);
 
     for (uint16_t i = 0; i < listener->servers.size; i++) {
-        SwiftNetServer* const server = vector_get(&listener->servers, i);
+        struct SwiftNetServer* const server = vector_get(&listener->servers, i);
         if (server->server_port == port_info->destination_port) {
             vector_unlock(&listener->servers);
 
@@ -153,7 +153,7 @@ static void pcap_packet_handle(uint8_t* user, const struct pcap_pkthdr* hdr, con
     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);
+        struct 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);
 
@@ -171,7 +171,7 @@ static void pcap_packet_handle(uint8_t* user, const struct pcap_pkthdr* hdr, con
 }
 
 void* interface_start_listening(void* listener_void) {
-    Listener* listener = listener_void;
+    struct Listener* listener = listener_void;
 
     pcap_loop(listener->pcap, 0, pcap_packet_handle, listener_void);