Added resize packet buffer and write at offset functions

src/generic_functions.c

@@ -20,15 +20,7 @@ static inline void append_data(uint8_t** const append_pointer, const void* const
     (*append_pointer) += data_size;
 }
 
-void swiftnet_client_append_to_buffer(const void* const data, const uint32_t data_size, struct SwiftNetPacketBuffer* const buffer) {
-    #ifdef SWIFT_NET_ERROR
-        validate_append_to_packet_args(data, data_size);
-    #endif
-
-    append_data(&buffer->packet_append_pointer, data, data_size);
-}
-
-void swiftnet_server_append_to_buffer(const void* const data, const uint32_t data_size, struct SwiftNetPacketBuffer* const buffer) {
+void swiftnet_append_to_buffer(const void* const data, const uint32_t data_size, struct SwiftNetPacketBuffer* const buffer) {
     #ifdef SWIFT_NET_ERROR
         validate_append_to_packet_args(data, data_size);
     #endif

src/packet_buffer.c

@@ -1,5 +1,8 @@
 #include "internal/internal.h"
 #include "swift_net.h"
+#include <net/ethernet.h>
+#include <stdint.h>
+#include <stdlib.h>
 
 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));
@@ -13,18 +16,33 @@ static inline struct SwiftNetPacketBuffer create_packet_buffer(const uint32_t bu
     };
 }
 
-struct SwiftNetPacketBuffer swiftnet_server_create_packet_buffer(const uint32_t buffer_size) {
+struct SwiftNetPacketBuffer swiftnet_create_packet_buffer(const uint32_t buffer_size) {
     return create_packet_buffer(buffer_size);
 }
 
-struct SwiftNetPacketBuffer swiftnet_client_create_packet_buffer(const uint32_t buffer_size) {
-    return create_packet_buffer(buffer_size);
+void swiftnet_resize_packet_buffer(uint32_t new_buffer_size, struct SwiftNetPacketBuffer* const packet_buffer) {
+    const uint32_t current_offset = packet_buffer->packet_append_pointer - packet_buffer->packet_data_start;
+
+    new_buffer_size += PACKET_HEADER_SIZE + sizeof(struct ether_header);
+
+    void* const new_ptr = realloc(packet_buffer->packet_buffer_start, new_buffer_size);
+
+    if (unlikely(new_ptr == NULL)) {
+        PRINT_ERROR("Failed to realloc");
+        exit(EXIT_FAILURE);
+    }
+
+    void* const data_start = new_ptr + PACKET_HEADER_SIZE + sizeof(struct ether_header);
+
+    packet_buffer->packet_buffer_start = new_ptr;
+    packet_buffer->packet_data_start = data_start;
+    packet_buffer->packet_append_pointer = data_start + current_offset;
 }
 
-void swiftnet_server_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet) {
-    free(packet->packet_buffer_start);
+void swiftnet_write_packet_buffer(const uint32_t byte_offset, struct SwiftNetPacketBuffer* const packet_buffer, void* const data, const uint32_t data_size) {
+    memcpy(packet_buffer->packet_data_start + byte_offset, data, data_size);
 }
 
-void swiftnet_client_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet) {
+void swiftnet_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet) {
     free(packet->packet_buffer_start);
 }

src/swift_net.h

@@ -310,17 +310,8 @@ extern void swiftnet_client_set_message_handler(
     void (* const new_handler)(struct SwiftNetClientPacketData* const, void* const),
     void* const user_arg
 );
-
 // Append data to a packet buffer.
-extern void swiftnet_client_append_to_buffer(
-    const void* const data,
-    const uint32_t data_size,
-    struct SwiftNetPacketBuffer* const buffer
-);
-
-
-// Append data to a packet buffer.
-extern void swiftnet_server_append_to_buffer(
+extern void swiftnet_append_to_buffer(
     const void* const data,
     const uint32_t data_size,
     struct SwiftNetPacketBuffer* const buffer 
@@ -348,17 +339,18 @@ extern void swiftnet_server_send_packet(
     const struct SwiftNetClientAddrData target
 );
 
-// Create a packet buffer for the server.
-extern struct SwiftNetPacketBuffer swiftnet_server_create_packet_buffer(const uint32_t buffer_size);
 
-// Create a packet buffer for the client.
-extern struct SwiftNetPacketBuffer swiftnet_client_create_packet_buffer(const uint32_t buffer_size);
+// Create a packet buffer.
+extern struct SwiftNetPacketBuffer swiftnet_create_packet_buffer(const uint32_t buffer_size);
+
+// Resizes packet buffer.
+extern void swiftnet_resize_packet_buffer(const uint32_t new_buffer_size, struct SwiftNetPacketBuffer* const);
 
-// Destroy a server packet buffer and free resources.
-extern void swiftnet_server_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet);
+// Writes to packet buffer at specific offset
+extern void swiftnet_write_packet_buffer(const uint32_t byte_offset, struct SwiftNetPacketBuffer* const, void* const data, const uint32_t data_size);
 
-// Destroy a client packet buffer and free resources.
-extern void swiftnet_client_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet);
+// Destroy a packet buffer and free resources.
+extern void swiftnet_destroy_packet_buffer(const struct SwiftNetPacketBuffer* const packet);
 
 // Create and initialize a server.
 extern struct SwiftNetServer* swiftnet_create_server(const uint16_t port, const bool loopback);

tests/integration_tests/src/making_request.c

@@ -86,13 +86,13 @@ static void on_client_packet(struct SwiftNetClientPacketData* packet, void* cons
     const uint32_t response_data_len = atomic_load_explicit(&g_response_data_len, memory_order_acquire);
     uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire);
 
-    struct SwiftNetPacketBuffer send_buffer = swiftnet_client_create_packet_buffer(response_data_len);
+    struct SwiftNetPacketBuffer send_buffer = swiftnet_create_packet_buffer(response_data_len);
 
-    swiftnet_client_append_to_buffer(response_data, response_data_len, &send_buffer);
+    swiftnet_append_to_buffer(response_data, response_data_len, &send_buffer);
 
     swiftnet_client_make_response(atomic_load_explicit(&g_client_conn, memory_order_acquire), packet, &send_buffer);
 
-    swiftnet_client_destroy_packet_buffer(&send_buffer);
+    swiftnet_destroy_packet_buffer(&send_buffer);
     swiftnet_client_destroy_packet_data(packet, client_conn);
 
     atomic_store_explicit(&g_sent_response, true, memory_order_release);
@@ -133,13 +133,13 @@ static void on_server_packet(struct SwiftNetServerPacketData* packet, void* cons
         const uint32_t response_data_len = atomic_load_explicit(&g_response_data_len, memory_order_acquire);
         uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire);
 
-        struct SwiftNetPacketBuffer send_buffer = swiftnet_server_create_packet_buffer(response_data_len);
+        struct SwiftNetPacketBuffer send_buffer = swiftnet_create_packet_buffer(response_data_len);
 
-        swiftnet_server_append_to_buffer(response_data, response_data_len, &send_buffer);
+        swiftnet_append_to_buffer(response_data, response_data_len, &send_buffer);
 
         swiftnet_server_make_response(atomic_load_explicit(&g_server, memory_order_acquire), packet, &send_buffer);
 
-        swiftnet_server_destroy_packet_buffer(&send_buffer);
+        swiftnet_destroy_packet_buffer(&send_buffer);
         swiftnet_server_destroy_packet_data(packet, server);
 
         atomic_store_explicit(&g_sent_response, true, memory_order_release);
@@ -174,13 +174,13 @@ static void on_server_packet(struct SwiftNetServerPacketData* packet, void* cons
         const uint32_t response_data_len = atomic_load_explicit(&g_response_data_len, memory_order_acquire);
         uint8_t* response_data = atomic_load_explicit(&g_response_data, memory_order_acquire);
 
-        struct SwiftNetPacketBuffer buffer = swiftnet_server_create_packet_buffer(request_data_len);
+        struct SwiftNetPacketBuffer buffer = swiftnet_create_packet_buffer(request_data_len);
 
-        swiftnet_server_append_to_buffer(request_data, request_data_len, &buffer);
+        swiftnet_append_to_buffer(request_data, request_data_len, &buffer);
 
         struct SwiftNetServerPacketData* response = swiftnet_server_make_request(atomic_load_explicit(&g_server, memory_order_acquire), &buffer, packet->metadata.sender, 1000);
 
-        swiftnet_server_destroy_packet_buffer(&buffer);
+        swiftnet_destroy_packet_buffer(&buffer);
 
         if (response == NULL) {
             int result = atomic_load_explicit(&g_test_result, memory_order_acquire);
@@ -275,13 +275,13 @@ int test_making_request(const union Args* args_ptr) {
     atomic_store_explicit(&g_response_data_len, args.response_data_len, memory_order_release);
 
     if (args.receiver == Server) {
-        struct SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(args.request_data_len);
+        struct SwiftNetPacketBuffer buffer = swiftnet_create_packet_buffer(args.request_data_len);
 
-        swiftnet_client_append_to_buffer(req_data, args.request_data_len, &buffer);
+        swiftnet_append_to_buffer(req_data, args.request_data_len, &buffer);
 
         struct SwiftNetClientPacketData* const response = swiftnet_client_make_request(client_conn, &buffer, 1000);
 
-        swiftnet_client_destroy_packet_buffer(&buffer);
+        swiftnet_destroy_packet_buffer(&buffer);
 
         if (response == NULL) {
             int result = atomic_load_explicit(&g_test_result, memory_order_acquire);
@@ -330,13 +330,13 @@ int test_making_request(const union Args* args_ptr) {
 
         return 0;
     } else {
-        struct SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(sizeof(g_make_request_code));
+        struct SwiftNetPacketBuffer buffer = swiftnet_create_packet_buffer(sizeof(g_make_request_code));
 
-        swiftnet_client_append_to_buffer(&g_make_request_code, sizeof(g_make_request_code), &buffer);
+        swiftnet_append_to_buffer(&g_make_request_code, sizeof(g_make_request_code), &buffer);
 
         swiftnet_client_send_packet(client_conn, &buffer);
 
-        swiftnet_client_destroy_packet_buffer(&buffer);
+        swiftnet_destroy_packet_buffer(&buffer);
 
         for ( ;; ) {
             int result = atomic_load_explicit(&g_test_result, memory_order_acquire);

tests/integration_tests/src/sending_packet.c

@@ -120,10 +120,10 @@ static void on_server_packet(struct SwiftNetServerPacketData* packet, void* cons
         uint32_t size = atomic_load_explicit(&g_client_data_len, memory_order_acquire);
         uint8_t* send_data = atomic_load_explicit(&g_client_data, memory_order_acquire);
 
-        struct SwiftNetPacketBuffer buf = swiftnet_server_create_packet_buffer(size);
-        swiftnet_server_append_to_buffer(send_data, size, &buf);
+        struct SwiftNetPacketBuffer buf = swiftnet_create_packet_buffer(size);
+        swiftnet_append_to_buffer(send_data, size, &buf);
         swiftnet_server_send_packet(atomic_load_explicit(&g_server, memory_order_acquire), &buf, packet->metadata.sender);
-        swiftnet_server_destroy_packet_buffer(&buf);
+        swiftnet_destroy_packet_buffer(&buf);
 
         atomic_store_explicit(&g_client_send_done, true, memory_order_release);
     } else {
@@ -180,10 +180,10 @@ int test_sending_packet(const union Args* args_ptr) {
         atomic_store_explicit(&g_server_data, s_data, memory_order_release);
     }
 
-    struct SwiftNetPacketBuffer buf = swiftnet_client_create_packet_buffer(args.server_data_len);
-    swiftnet_client_append_to_buffer(atomic_load_explicit(&g_server_data, memory_order_acquire), args.server_data_len, &buf);
+    struct SwiftNetPacketBuffer buf = swiftnet_create_packet_buffer(args.server_data_len);
+    swiftnet_append_to_buffer(atomic_load_explicit(&g_server_data, memory_order_acquire), args.server_data_len, &buf);
     swiftnet_client_send_packet(client_conn, &buf);
-    swiftnet_client_destroy_packet_buffer(&buf);
+    swiftnet_destroy_packet_buffer(&buf);
 
     atomic_store_explicit(&g_server_send_done, true, memory_order_release);
 

tests/performance_tests/src/main.c

@@ -50,14 +50,14 @@ void send_large_packets(const bool loopback) {
         exit(EXIT_FAILURE);
     }
 
-    struct SwiftNetPacketBuffer buffer = swiftnet_client_create_packet_buffer(PACKET_SIZE);
+    struct SwiftNetPacketBuffer buffer = swiftnet_create_packet_buffer(PACKET_SIZE);
 
     uint8_t* const random_data = malloc(PACKET_SIZE);
     for (uint32_t i = 0; i < PACKET_SIZE; i++) {
         random_data[i] = rand();
     }
 
-    swiftnet_client_append_to_buffer(random_data, PACKET_SIZE, &buffer);
+    swiftnet_append_to_buffer(random_data, PACKET_SIZE, &buffer);
 
     clock_gettime(CLOCK_MONOTONIC, &start);;
 
@@ -69,7 +69,7 @@ void send_large_packets(const bool loopback) {
         continue;
     }
 
-    swiftnet_client_destroy_packet_buffer(&buffer);
+    swiftnet_destroy_packet_buffer(&buffer);
 
     clock_gettime(CLOCK_MONOTONIC, &end);;