Fix leak of fixed huffman lut

Author: someone13574

include/arena/arena.h

@@ -4,10 +4,24 @@
 
 typedef struct Arena Arena;
 
+/// Creates a new dynamically-allocated arena
 Arena* arena_new(size_t block_size);
+
+/// Creates a new arena within an existing buffer. Note that the whole buffer
+/// size may not be usable.
+Arena* arena_new_in_buffer(void* buffer, size_t buffer_len);
+
+/// Frees the dynamically-allocated arena. If the arena was initialized in a
+/// fixed buffer, this will panic.
 void arena_free(Arena* arena);
 
+/// Allocates a region of `size` bytes on the arena, with an alignment of
+/// `max_align_t`.
 void* arena_alloc(Arena* arena, size_t size);
+
+/// Allocates a region of `size` bytes on the arena with a custom alignment.
 void* arena_alloc_align(Arena* arena, size_t size, size_t align);
 
+/// Resets the arena, invalidating everything previously allocated on it. Note
+/// that this does not free any memory.
 void arena_reset(Arena* arena);

src/arena/arena.c

@@ -1,6 +1,7 @@
 #include "arena/arena.h"
 
 #include <stdalign.h>
+#include <stdbool.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
@@ -51,6 +52,7 @@ struct Arena {
     ArenaBlock* blocks;
     size_t num_blocks;
 
+    bool dynamic_arena;
     size_t next_block_size;
 };
 
@@ -63,13 +65,40 @@ Arena* arena_new(size_t block_size) {
     RELEASE_ASSERT(arena, "Malloc failed");
     arena->blocks = blocks;
     arena->num_blocks = 1;
+    arena->dynamic_arena = true;
     arena->next_block_size = block_size;
 
     return arena;
 }
 
+Arena* arena_new_in_buffer(void* buffer, size_t buffer_len) {
+    RELEASE_ASSERT(buffer);
+    RELEASE_ASSERT(
+        buffer_len >= sizeof(ArenaBlock),
+        "Arena must be large enough to store itself"
+    );
+
+    size_t self_size = sizeof(Arena) + sizeof(ArenaBlock);
+
+    // Create a single arena-block
+    ArenaBlock* block = buffer;
+    block->start = (uintptr_t)buffer + self_size;
+    block->end = (uintptr_t)buffer + buffer_len;
+    block->ptr = block->end;
+
+    // Create the arena
+    Arena* arena = (void*)((uint8_t*)buffer + sizeof(ArenaBlock));
+    arena->blocks = block;
+    arena->num_blocks = 1;
+    arena->dynamic_arena = false;
+    arena->next_block_size = 0;
+
+    return arena;
+}
+
 void arena_free(Arena* arena) {
     RELEASE_ASSERT(arena);
+    RELEASE_ASSERT(arena->dynamic_arena);
 
     LOG_DIAG(INFO, ARENA, "Freeing arena");
 
@@ -131,6 +160,10 @@ void* arena_alloc_align(Arena* arena, size_t size, size_t align) {
         return (void*)aligned_ptr;
     }
 
+    if (!arena->dynamic_arena) {
+        LOG_PANIC("Allocation failed on non-dynamic arena: not enough space");
+    }
+
     // Create new block
     ArenaBlock* new_array =
         realloc(arena->blocks, sizeof(ArenaBlock) * (arena->num_blocks + 1));

src/codec/deflate.c

@@ -434,6 +434,7 @@ static PdfError* decode_dyn_huffman_table_luts(
 static DeflateHuffmanLut get_fixed_huffman_lut(void) {
     static bool initialized = false;
     static DeflateHuffmanLut lut;
+    static uint8_t arena_backing[4096];
 
     if (!initialized) {
         LOG_DIAG(DEBUG, CODEC, "Initializing fixed deflate huffman lut");
@@ -455,8 +456,11 @@ static DeflateHuffmanLut get_fixed_huffman_lut(void) {
             bit_lens[i] = 8;
         }
 
-        Arena* persistent_arena = arena_new(1);
-        lut = build_deflate_huffman_lut(persistent_arena, bit_lens, 288);
+        Arena* arena = arena_new_in_buffer(
+            arena_backing,
+            sizeof(arena_backing) / sizeof(uint8_t)
+        );
+        lut = build_deflate_huffman_lut(arena, bit_lens, 288);
     }
 
     return lut;