Merge latest dev into triage remediation

src/shared/compression.c

@@ -1,12 +1,13 @@
 #include "compression.h"
 #include "data.h"
 #include "log.h"
-#include "stdlib.h"
-#include "string.h"
+#include <stdlib.h>
+#include <string.h>
 #include <strings.h>
-#include "zstd.h"
+#include <zstd.h>
 
 #define INITIAL_DECOMPRESS_BUF_SIZE (1024 * 1024)
+#define MAX_DECOMPRESSED_SIZE (100ULL * 1024 * 1024) /* 100 MB hard ceiling */
 
 static const char* SKIP_COMPRESSION_EXTENSIONS[] = {".jpg", ".jpeg", ".png", ".gif", ".mp4", ".mkv",
                                                     ".zip", ".gz",   ".xz",  ".zst", NULL};
@@ -84,6 +85,13 @@ Data* data_decompress(Data* compressed_data) {
     dst_size = compressed_data->size * 3;
     if (dst_size < INITIAL_DECOMPRESS_BUF_SIZE)
       dst_size = INITIAL_DECOMPRESS_BUF_SIZE;
+    if (dst_size > MAX_DECOMPRESSED_SIZE)
+      dst_size = MAX_DECOMPRESSED_SIZE;
+  }
+  if (dst_size > MAX_DECOMPRESSED_SIZE) {
+    log_message(LOG_LEVEL_ERROR, "Declared decompressed size exceeds %llu bytes",
+                (unsigned long long)MAX_DECOMPRESSED_SIZE);
+    return NULL;
   }
 
   ZSTD_DCtx* dctx = ZSTD_createDCtx();
@@ -113,7 +121,16 @@ Data* data_decompress(Data* compressed_data) {
       return NULL;
     }
     if (ret > 0 && output.pos == output.size) {
+      if (buf_size >= MAX_DECOMPRESSED_SIZE) {
+        log_message(LOG_LEVEL_ERROR, "Decompressed data exceeds %llu bytes",
+                    (unsigned long long)MAX_DECOMPRESSED_SIZE);
+        ZSTD_freeDCtx(dctx);
+        data_destroy(uncompressed_data);
+        return NULL;
+      }
       buf_size *= 2;
+      if (buf_size > MAX_DECOMPRESSED_SIZE)
+        buf_size = MAX_DECOMPRESSED_SIZE;
       void* new_data = realloc(uncompressed_data->data, buf_size);
       if (!new_data) {
         log_message(LOG_LEVEL_ERROR, "Failed to grow decompression buffer");

src/shared/config.c

@@ -8,10 +8,7 @@
 #include <stdlib.h>
 #include <string.h>
 
-Config* config_create(void) {
-  Config* config = malloc(sizeof(Config));
-  if (!config)
-    return NULL;
+static void config_set_defaults(Config* config) {
   config->version = str_dup(PROTOCOL_VERSION);
   config->send_directory = NULL;
   config->receive_root_directory = NULL;
@@ -101,6 +98,13 @@ Config* config_create(void) {
   config->server_mode = false;
   config->checksum = false;
   config->compress_choice = NULL;
+}
+
+Config* config_create(void) {
+  Config* config = malloc(sizeof(Config));
+  if (!config)
+    return NULL;
+  config_set_defaults(config);
   return config;
 }
 
@@ -131,6 +135,8 @@ void config_parse_ssh_dest(Config* config) {
 }
 
 void config_delete(Config* config) {
+  if (config == NULL)
+    return;
   free(config->version);
   free(config->send_directory);
   free(config->receive_root_directory);
@@ -167,6 +173,16 @@ void config_delete(Config* config) {
   free(config);
 }
 
+/* Wire format order (must match config_receive and be updated when PROTOCOL_VERSION bumps):
+ * version, send_directory, receive_root_directory, save_to_disk, use_multithreading,
+ * use_chunk_serialization, use_compression, use_metadata, compression_level, chunk_size,
+ * use_sendfile, use_delete, use_incremental, use_delta, delta_block_size, delta_max_file_size,
+ * backup, backup_dir, follow_symlinks, copy_links, safe_links, copy_unsafe_links,
+ * preserve_hard_links, preserve_acls, preserve_xattrs, preserve_devices, preserve_sparse,
+ * update, inplace, append, append_verify, delete_excluded, delete_after, max_delete, relative,
+ * prune_empty_dirs, temp_dir, partial, partial_dir, suffix, delete_before, checksum,
+ * compress_choice, status
+ */
 bool config_send(int file_descriptor, const Config* config) {
   if (!send_str(file_descriptor, config->version))
     return false;
@@ -196,7 +212,7 @@ bool config_send(int file_descriptor, const Config* config) {
     return false;
   if (!send_int(file_descriptor, config->use_delta))
     return false;
-  if (!send_int(file_descriptor, (int)config->delta_block_size))
+  if (!send_n_data(file_descriptor, &config->delta_block_size, sizeof(config->delta_block_size)))
     return false;
   if (!send_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
     return false;
@@ -264,13 +280,16 @@ bool config_send(int file_descriptor, const Config* config) {
   return true;
 }
 
+/* Wire format order: see the comment above config_send. */
 Config* config_receive(int file_descriptor) {
   Config* config = (Config*)malloc(sizeof(Config));
   if (config == NULL)
     return NULL;
-  memset(config, 0, sizeof(*config));
+  config_set_defaults(config);
+  free(config->version);
   config->version = receive_str(file_descriptor);
   if (!config->version) {
+    free(config->server_host);
     free(config);
     return NULL;
   }
@@ -278,6 +297,7 @@ Config* config_receive(int file_descriptor) {
     fprintf(stderr, "Protocol version mismatch: client=%s, server=%s\n", config->version,
             PROTOCOL_VERSION);
     free(config->version);
+    free(config->server_host);
     free(config);
     send_status(file_descriptor, STATUS_ERROR);
     return NULL;
@@ -285,6 +305,7 @@ Config* config_receive(int file_descriptor) {
   config->send_directory = receive_str(file_descriptor);
   if (!config->send_directory) {
     free(config->version);
+    free(config->server_host);
     free(config);
     return NULL;
   }
@@ -292,6 +313,7 @@ Config* config_receive(int file_descriptor) {
   if (!config->receive_root_directory) {
     free(config->version);
     free(config->send_directory);
+    free(config->server_host);
     free(config);
     return NULL;
   }
@@ -328,67 +350,10 @@ Config* config_receive(int file_descriptor) {
   if (!receive_int(file_descriptor, &tmp))
     goto error;
   config->use_delta = tmp;
-  if (!receive_int(file_descriptor, &tmp))
+  if (!receive_n_data(file_descriptor, &config->delta_block_size, sizeof(config->delta_block_size)))
     goto error;
-  config->delta_block_size = (uint32_t)tmp;
   if (!receive_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
     goto error;
-  config->show_progress = false;
-  config->dry_run = false;
-  config->ssh_port = 22;
-  config->transport = TRANSPORT_TCP;
-  config->ssh_destination = NULL;
-  config->fastsync_server_path = NULL;
-  config->exclude_patterns = NULL;
-  config->exclude_count = 0;
-  config->include_patterns = NULL;
-  config->include_count = 0;
-  config->max_size = 0;
-  config->min_size = 0;
-  config->use_tls = false;
-  config->tls_cert = NULL;
-  config->tls_key = NULL;
-  config->tls_ca = NULL;
-  config->timeout = 30;
-  config->contimeout = 10;
-  config->quiet = false;
-  config->stats = false;
-  config->max_depth = 0;
-  config->log_file = NULL;
-  config->queue_size = 100;
-  config->follow_symlinks = false;
-  config->copy_links = false;
-  config->safe_links = false;
-  config->copy_unsafe_links = false;
-  config->preserve_hard_links = false;
-  config->preserve_acls = false;
-  config->preserve_xattrs = false;
-  config->preserve_devices = false;
-  config->preserve_sparse = false;
-  config->itemize_changes = false;
-  config->out_format = NULL;
-  config->info_level = 0;
-  config->debug_level = 0;
-  config->list_only = false;
-  config->human_readable = false;
-  config->update = false;
-  config->inplace = false;
-  config->append = false;
-  config->append_verify = false;
-  config->delete_excluded = false;
-  config->delete_after = false;
-  config->max_delete = 0;
-  config->filters = NULL;
-  config->files_from = NULL;
-  config->cvs_exclude = false;
-  config->prune_empty_dirs = false;
-  config->relative = false;
-  config->rsh_command = NULL;
-  config->rsync_path = NULL;
-  config->temp_dir = NULL;
-  config->compare_dest = NULL;
-  config->copy_dest = NULL;
-  config->link_dest = NULL;
   if (!receive_int(file_descriptor, &tmp))
     goto error;
   config->backup = tmp;
@@ -475,15 +440,6 @@ Config* config_receive(int file_descriptor) {
     send_status(file_descriptor, STATUS_ERROR);
     goto error;
   }
-  config->address = NULL;
-  config->bind_address = NULL;
-  config->ipv6 = false;
-  config->ipv4 = false;
-  config->daemon = false;
-  config->daemon_config = NULL;
-  config->server_mode = false;
-  config->server_host = str_dup("127.0.0.1");
-  config->server_port = 8080;
   if (!send_status(file_descriptor, STATUS_OK))
     goto error;
   return config;

src/shared/delta.c

@@ -392,6 +392,10 @@ Delta* delta_deserialize(const Data* data) {
 
     if (type == DELTA_OP_BLOCK_MATCH) {
       if (pos + sizeof(uint32_t) * 3 > data->size) {
+        for (uint32_t k = 0; k < i; k++) {
+          if (delta->instructions[k].type == DELTA_INSTR_LITERAL)
+            free(delta->instructions[k].literal.data);
+        }
         free(delta->instructions);
         free(delta);
         return NULL;
@@ -430,6 +434,11 @@ Delta* delta_deserialize(const Data* data) {
       }
       delta->instructions[i].literal.data = malloc(lit_len);
       if (!delta->instructions[i].literal.data) {
+        log_message(LOG_LEVEL_ERROR, "Failed to allocate %u bytes for literal data", lit_len);
+        for (uint32_t k = 0; k < i; k++) {
+          if (delta->instructions[k].type == DELTA_INSTR_LITERAL)
+            free(delta->instructions[k].literal.data);
+        }
         free(delta->instructions);
         free(delta);
         return NULL;
@@ -453,7 +462,8 @@ Delta* delta_deserialize(const Data* data) {
 
 void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta,
                   uint32_t block_size) {
-  if (!old_data || !delta)
+  if (!old_data || !delta || (delta->new_file_size > 0 && delta->instructions == NULL) ||
+      (delta->instruction_count > 0 && block_size == 0))
     return NULL;
 
   void* output = malloc((size_t)delta->new_file_size);
@@ -467,10 +477,15 @@ void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta,
   for (uint32_t i = 0; i < delta->instruction_count; i++) {
     if (delta->instructions[i].type == DELTA_INSTR_BLOCK_MATCH) {
       uint64_t src_offset = (uint64_t)delta->instructions[i].match.block_index * block_size;
+      if (src_offset > UINT64_MAX - delta->instructions[i].match.block_offset) {
+        free(output);
+        return NULL;
+      }
       src_offset += delta->instructions[i].match.block_offset;
       uint32_t len = delta->instructions[i].match.length;
 
-      if (src_offset + len > old_size) {
+      if (src_offset > old_size || (uint64_t)len > old_size - src_offset ||
+          out_pos > delta->new_file_size || (uint64_t)len > delta->new_file_size - out_pos) {
         free(output);
         return NULL;
       }
@@ -478,6 +493,10 @@ void* delta_apply(const void* old_data, uint64_t old_size, const Delta* delta,
       out_pos += len;
     } else {
       uint32_t len = delta->instructions[i].literal.length;
+      if (out_pos > delta->new_file_size || (uint64_t)len > delta->new_file_size - out_pos) {
+        free(output);
+        return NULL;
+      }
       memcpy(out + out_pos, delta->instructions[i].literal.data, len);
       out_pos += len;
     }

src/shared/file.c

@@ -17,7 +17,6 @@
 #include "config.h"
 #include "data.h"
 #include "file.h"
-#include "log.h"
 #include "metadata.h"
 #include "protocol.h"
 #include "utils.h"
@@ -110,6 +109,9 @@ bool file_load_data(File* file) {
   size_t bytes_read = file_content_to_buffer(file);
   if (bytes_read != file->data->size) {
     log_message(LOG_LEVEL_ERROR, "Did not read expected amount of bytes from file");
+    free(file->data->data);
+    file->data->data = NULL;
+    file->data->size = 0;
     return false;
   }
   return true;

src/shared/log.c

@@ -18,11 +18,15 @@ void log_set_file(FILE* fp) {
 void log_message(LogLevel log_level, const char* format, ...) {
   if (log_level < current_log_level)
     return;
+  if (log_level < 0 || log_level >= (int)(sizeof(log_level_strings) / sizeof(log_level_strings[0])))
+    return;
   time_t now = time(NULL);
-  const struct tm* t = localtime(&now);
+  struct tm t;
+  if (!localtime_r(&now, &t))
+    return;
 
-  fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900, t->tm_mon + 1,
-          t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, log_level_strings[log_level]);
+  fprintf(stderr, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t.tm_year + 1900, t.tm_mon + 1, t.tm_mday,
+          t.tm_hour, t.tm_min, t.tm_sec, log_level_strings[log_level]);
 
   va_list args;
   va_start(args, format);
@@ -31,8 +35,8 @@ void log_message(LogLevel log_level, const char* format, ...) {
   fprintf(stderr, "\n");
 
   if (log_fp) {
-    fprintf(log_fp, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t->tm_year + 1900, t->tm_mon + 1,
-            t->tm_mday, t->tm_hour, t->tm_min, t->tm_sec, log_level_strings[log_level]);
+    fprintf(log_fp, "%04d-%02d-%02d %02d:%02d:%02d [%s]: ", t.tm_year + 1900, t.tm_mon + 1,
+            t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, log_level_strings[log_level]);
     va_start(args, format);
     vfprintf(log_fp, format, args);
     va_end(args);

src/shared/multiprocessing.c

@@ -26,18 +26,48 @@ PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* que
   context->manifest = NULL;
   context->progress_bytes = 0;
   context->sender_done = false;
-  if (mtx_init(&context->mutex_scanner, mtx_plain) != thrd_success ||
-      cnd_init(&context->condition_not_full_scanner) != thrd_success ||
-      cnd_init(&context->condition_not_empty_scanner) != thrd_success ||
-      mtx_init(&context->mutex_loader, mtx_plain) != thrd_success ||
-      cnd_init(&context->condition_not_full_loader) != thrd_success ||
-      mtx_init(&context->mutex_progress, mtx_plain) != thrd_success ||
-      cnd_init(&context->condition_not_empty_loader) != thrd_success) {
-    perror("Error initializing synchronization objects");
-    free(context);
-    return NULL;
-  }
+  context->cancelled = false;
+  int init = 0;
+  if (mtx_init(&context->mutex_scanner, mtx_plain) != thrd_success)
+    goto fail;
+  init++;
+  if (cnd_init(&context->condition_not_full_scanner) != thrd_success)
+    goto fail;
+  init++;
+  if (cnd_init(&context->condition_not_empty_scanner) != thrd_success)
+    goto fail;
+  init++;
+  if (mtx_init(&context->mutex_loader, mtx_plain) != thrd_success)
+    goto fail;
+  init++;
+  if (cnd_init(&context->condition_not_full_loader) != thrd_success)
+    goto fail;
+  init++;
+  if (cnd_init(&context->condition_not_empty_loader) != thrd_success)
+    goto fail;
+  init++;
+  if (mtx_init(&context->mutex_progress, mtx_plain) != thrd_success)
+    goto fail;
+  // cppcheck-suppress unreadVariable
+  init++;
   return context;
+
+fail:
+  perror("Error initializing synchronization objects");
+  if (init >= 6)
+    cnd_destroy(&context->condition_not_empty_loader);
+  if (init >= 5)
+    cnd_destroy(&context->condition_not_full_loader);
+  if (init >= 4)
+    mtx_destroy(&context->mutex_loader);
+  if (init >= 3)
+    cnd_destroy(&context->condition_not_empty_scanner);
+  if (init >= 2)
+    cnd_destroy(&context->condition_not_full_scanner);
+  if (init >= 1)
+    mtx_destroy(&context->mutex_scanner);
+  free(context);
+  return NULL;
 }
 
 void pipeline_context_sender_destroy(PipelineContextSender* context) {
@@ -67,14 +97,30 @@ PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue*
   context->file_descriptor = file_descriptor;
   context->ssl = ssl;
   context->receiver_done = false;
-  if (mtx_init(&context->mutex, mtx_plain) != thrd_success ||
-      cnd_init(&context->condition_not_full) != thrd_success ||
-      cnd_init(&context->condition_not_empty) != thrd_success) {
-    perror("Error initializing synchronization objects");
-    free(context);
-    return NULL;
-  }
+  context->cancelled = false;
+  int init = 0;
+  if (mtx_init(&context->mutex, mtx_plain) != thrd_success)
+    goto fail;
+  init++;
+  if (cnd_init(&context->condition_not_full) != thrd_success)
+    goto fail;
+  init++;
+  if (cnd_init(&context->condition_not_empty) != thrd_success)
+    goto fail;
+  // cppcheck-suppress unreadVariable
+  init++;
   return context;
+
+fail:
+  perror("Error initializing synchronization objects");
+  if (init >= 3)
+    cnd_destroy(&context->condition_not_empty);
+  if (init >= 2)
+    cnd_destroy(&context->condition_not_full);
+  if (init >= 1)
+    mtx_destroy(&context->mutex);
+  free(context);
+  return NULL;
 }
 
 void pipeline_context_receiver_destroy(PipelineContextReceiver* context) {
@@ -94,8 +140,13 @@ static bool receive_chunk_enqueue(int file_descriptor, PipelineContextReceiver*
   for (int i = 0; i < chunk->element_count; i++) {
     File* file = chunk->items[i];
     chunk->items[i] = NULL;
-    queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                &context->condition_not_empty, &context->condition_not_full);
+    if (!queue_enqueue_multithreaded_cancel(context->queue, file, &context->mutex,
+                                            &context->condition_not_empty,
+                                            &context->condition_not_full, &context->cancelled)) {
+      file_destroy(file);
+      chunk_destroy(chunk);
+      return false;
+    }
   }
   chunk_destroy(chunk);
   return true;
@@ -144,8 +195,12 @@ int receive_thread(void* pipeline_context) {
       if (!skipped) {
         if (file == NULL)
           RECEIVE_THREAD_FAIL();
-        queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                    &context->condition_not_empty, &context->condition_not_full);
+        if (!queue_enqueue_multithreaded_cancel(
+                context->queue, file, &context->mutex, &context->condition_not_empty,
+                &context->condition_not_full, &context->cancelled)) {
+          file_destroy(file);
+          RECEIVE_THREAD_FAIL();
+        }
       }
     } else if (status == STATUS_CHUNK) {
       if (!receive_chunk_enqueue(file_descriptor, context))
@@ -179,8 +234,12 @@ int receive_thread(void* pipeline_context) {
     } else {
       File* file = file_receive(config, file_descriptor);
       if (file) {
-        queue_enqueue_multithreaded(context->queue, file, &context->mutex,
-                                    &context->condition_not_empty, &context->condition_not_full);
+        if (!queue_enqueue_multithreaded_cancel(
+                context->queue, file, &context->mutex, &context->condition_not_empty,
+                &context->condition_not_full, &context->cancelled)) {
+          file_destroy(file);
+          return thrd_error;
+        }
       } else {
         log_message(LOG_LEVEL_ERROR, "Failed to receive file");
         RECEIVE_THREAD_FAIL();

src/shared/protocol.c

@@ -7,10 +7,10 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <threads.h>
 #include <time.h>
 #include <unistd.h>
 
-#define MAX_DATA_SIZE (100ULL * 1024 * 1024)          /* 100 MB max per data message */
 #define RECEIVE_TIMEOUT_SEC 60                        /* 60 second per-message timeout */
 #define MAX_CONNECTION_MEMORY (1024ULL * 1024 * 1024) /* 1 GB total per connection */
 
@@ -21,6 +21,8 @@ static __thread SSL* io_ssl;
 static unsigned long long io_bwlimit = 0;
 static long long bw_tokens = 0;
 static struct timespec bw_last_refill = {0, 0};
+static mtx_t bw_mutex;
+static once_flag bw_mutex_once = ONCE_FLAG_INIT;
 
 static __thread unsigned long long total_allocated_bytes = 0;
 
@@ -29,15 +31,24 @@ void io_set_fds(int read_fd, int write_fd) {
   io_write_fd = write_fd;
 }
 
+static void bw_mutex_init(void) {
+  mtx_init(&bw_mutex, mtx_plain);
+}
+
 void io_set_bwlimit(unsigned long long bytes_per_sec) {
+  call_once(&bw_mutex_once, bw_mutex_init);
+  mtx_lock(&bw_mutex);
   io_bwlimit = bytes_per_sec;
   bw_tokens = (long long)io_bwlimit;
   clock_gettime(CLOCK_MONOTONIC, &bw_last_refill);
+  mtx_unlock(&bw_mutex);
 }
 
 static void bw_throttle(size_t bytes_written) {
   if (io_bwlimit == 0)
     return;
+  call_once(&bw_mutex_once, bw_mutex_init);
+  mtx_lock(&bw_mutex);
 
   struct timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
@@ -62,6 +73,7 @@ static void bw_throttle(size_t bytes_written) {
     bw_tokens = 0;
     clock_gettime(CLOCK_MONOTONIC, &bw_last_refill);
   }
+  mtx_unlock(&bw_mutex);
 }
 
 void io_set_ssl(SSL* ssl) {
@@ -195,6 +207,8 @@ static const char* status_to_string(Status status) {
 }
 
 bool send_str(int file_descriptor, const char* data) {
+  if (data == NULL)
+    return false;
   size_t size = strlen(data);
   if (!send_n_data(file_descriptor, &size, sizeof(size_t)))
     return false;
@@ -239,9 +253,9 @@ Data* receive_data(int file_descriptor) {
   unsigned long long size = 0;
   if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
     return NULL;
-  if (size > MAX_DATA_SIZE) {
+  if (size > MAX_DATA_PAYLOAD_SIZE) {
     log_message(LOG_LEVEL_ERROR, "Data size %llu exceeds maximum %llu", size,
-                (unsigned long long)MAX_DATA_SIZE);
+                (unsigned long long)MAX_DATA_PAYLOAD_SIZE);
     return NULL;
   }
   if (total_allocated_bytes + size > MAX_CONNECTION_MEMORY) {

src/shared/utils.c

@@ -10,11 +10,13 @@
 #include <unistd.h>
 
 bool mkdir_r(const char* path) {
-  char* path_duplicate = malloc(strlen(path) + 1);
+  size_t path_len = strlen(path);
+  char* path_duplicate = malloc(path_len + 1);
   if (!path_duplicate)
     return false;
-  memcpy(path_duplicate, path, strlen(path) + 1);
-  char* path_current = (char*)malloc((strlen(path) + 2) * sizeof(char));
+  memcpy(path_duplicate, path, path_len + 1);
+  size_t capacity = path_len + 2;
+  char* path_current = (char*)malloc(capacity * sizeof(char));
   if (!path_current) {
     free(path_duplicate);
     return false;
@@ -33,6 +35,10 @@ bool mkdir_r(const char* path) {
   bool ok = true;
   while (part != NULL) {
     size_t part_len = strlen(part);
+    if ((size_t)(path_current_position - path_current) + part_len + 2 > capacity) {
+      ok = false;
+      break;
+    }
     memcpy(path_current_position, part, part_len);
     path_current_position += part_len;
     path_current_position[0] = '/';
@@ -64,10 +70,18 @@ char* str_dup(const char* string) {
   return new_string;
 }
 
+/* Match a glob pattern against a string. Supported wildcards:
+ *   ?      matches any single character except '/'.
+ *   *      matches any sequence of characters within one path component (no '/').
+ *   **     matches any sequence of characters, including '/' (cross-directory).
+ *   slash-star-star-slash is treated as a cross-directory wildcard when it appears between
+ * literals.
+ */
 bool glob_match(const char* pattern, const char* str) {
   while (*pattern) {
     if (*pattern == '*') {
       if (*(pattern + 1) == '*') {
+        /* globstar: match across directories */
         pattern += 2;
         if (*pattern == '\0')
           return true;
@@ -80,6 +94,7 @@ bool glob_match(const char* pattern, const char* str) {
         }
         return glob_match(pattern, str);
       }
+      /* single *: match within one path component */
       pattern++;
       while (*str && *str != '/') {
         if (glob_match(pattern, str))
@@ -94,6 +109,7 @@ bool glob_match(const char* pattern, const char* str) {
       str++;
     } else {
       if (*pattern != *str) {
+        /* allow literal / ** / rest to match any number of directories */
         if (*pattern == '/' && *(pattern + 1) == '*' && *(pattern + 2) == '*') {
           const char* rest = pattern + 3;
           if (*rest == '/')