merge: resolve origin dev refactor conflicts

src/shared/chunk.c

@@ -148,7 +148,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
     data_pointer += sizeof(size_t);
     remaining_size -= sizeof(size_t);
 
-    if (remaining_size < path_len) {
+    if (path_len > SIZE_MAX - 1 || remaining_size < path_len) {
       log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path");
       array_list_delete(files);
       return NULL;
@@ -279,8 +279,11 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
   Chunk* chunk = chunk_create(file_array, files->size);
 
   free(file_array);
-  if (chunk != NULL)
-    files->item_destroyer = NULL;
+  if (chunk == NULL) {
+    array_list_delete(files);
+    return NULL;
+  }
+  files->item_destroyer = NULL;
   array_list_delete(files);
 
   return chunk;

src/shared/config.c

@@ -214,102 +214,130 @@ 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
- */
+/* Each helper is deliberately ordered to match the wire format. Keep the
+ * helper call order in config_send and config_receive unchanged when adding
+ * fields. */
+static bool send_core_fields(int fd, const Config* c) {
+  return send_str(fd, c->version) && send_str(fd, c->send_directory) &&
+         send_str(fd, c->receive_root_directory) && send_int(fd, c->save_to_disk) &&
+         send_int(fd, c->use_multithreading) && send_int(fd, c->use_chunk_serialization) &&
+         send_int(fd, c->use_compression) && send_int(fd, c->use_metadata) &&
+         send_int(fd, c->compression_level) &&
+         send_n_data(fd, &c->chunk_size, sizeof(c->chunk_size)) && send_int(fd, c->use_sendfile);
+}
+
+static bool send_delta_fields(int fd, const Config* c) {
+  return send_int(fd, c->use_delete) && send_int(fd, c->use_incremental) &&
+         send_int(fd, c->use_delta) &&
+         send_n_data(fd, &c->delta_block_size, sizeof(c->delta_block_size)) &&
+         send_n_data(fd, &c->delta_max_file_size, sizeof(unsigned long long));
+}
+
+static bool send_file_options(int fd, const Config* c) {
+  return send_int(fd, c->backup) && send_str(fd, c->backup_dir ? c->backup_dir : "") &&
+         send_int(fd, c->follow_symlinks) && send_int(fd, c->copy_links) &&
+         send_int(fd, c->safe_links) && send_int(fd, c->copy_unsafe_links) &&
+         send_int(fd, c->preserve_hard_links) && send_int(fd, c->preserve_acls) &&
+         send_int(fd, c->preserve_xattrs) && send_int(fd, c->preserve_devices) &&
+         send_int(fd, c->preserve_sparse);
+}
+
+static bool send_selection_options(int fd, const Config* c) {
+  return send_int(fd, c->update) && send_int(fd, c->inplace) && send_int(fd, c->append) &&
+         send_int(fd, c->append_verify) && send_int(fd, c->delete_excluded) &&
+         send_int(fd, c->delete_after) && send_n_data(fd, &c->max_delete, sizeof(c->max_delete)) &&
+         send_int(fd, c->relative) && send_int(fd, c->prune_empty_dirs);
+}
+
+static bool send_resume_options(int fd, const Config* c) {
+  return send_str(fd, c->temp_dir ? c->temp_dir : "") && send_int(fd, c->partial) &&
+         send_str(fd, c->partial_dir ? c->partial_dir : "") &&
+         send_str(fd, c->suffix ? c->suffix : "") && send_int(fd, c->delete_before) &&
+         send_int(fd, c->checksum) && send_str(fd, c->compress_choice ? c->compress_choice : "");
+}
+
+static bool receive_core_fields(int fd, Config* c) {
+  int value;
+  c->send_directory = receive_str(fd);
+  c->receive_root_directory = receive_str(fd);
+  if (!c->send_directory || !c->receive_root_directory)
+    return false;
+  if (!receive_wire_bool(fd, &c->save_to_disk) || !receive_wire_bool(fd, &c->use_multithreading) ||
+      !receive_wire_bool(fd, &c->use_chunk_serialization) ||
+      !receive_wire_bool(fd, &c->use_compression) || !receive_wire_bool(fd, &c->use_metadata))
+    return false;
+  if (!receive_int(fd, &value))
+    return false;
+  c->compression_level = value;
+  if (!receive_n_data(fd, &c->chunk_size, sizeof(c->chunk_size)))
+    return false;
+  if (!receive_wire_bool(fd, &c->use_sendfile))
+    return false;
+  return true;
+}
+
+static bool receive_delta_fields(int fd, Config* c) {
+  if (!receive_wire_bool(fd, &c->use_delete))
+    return false;
+  if (!receive_wire_bool(fd, &c->use_incremental))
+    return false;
+  if (!receive_wire_bool(fd, &c->use_delta))
+    return false;
+  return receive_n_data(fd, &c->delta_block_size, sizeof(c->delta_block_size)) &&
+         receive_n_data(fd, &c->delta_max_file_size, sizeof(unsigned long long));
+}
+
+static bool receive_file_options(int fd, Config* c) {
+  if (!receive_wire_bool(fd, &c->backup))
+    return false;
+  c->backup_dir = receive_str(fd);
+  if (!c->backup_dir)
+    return false;
+  bool* flags[] = {&c->follow_symlinks,   &c->copy_links,          &c->safe_links,
+                   &c->copy_unsafe_links, &c->preserve_hard_links, &c->preserve_acls,
+                   &c->preserve_xattrs,   &c->preserve_devices,    &c->preserve_sparse};
+  for (size_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
+    if (!receive_wire_bool(fd, flags[i]))
+      return false;
+  }
+  return true;
+}
+
+static bool receive_selection_options(int fd, Config* c) {
+  bool* flags[] = {&c->update,        &c->inplace,         &c->append,
+                   &c->append_verify, &c->delete_excluded, &c->delete_after};
+  for (size_t i = 0; i < sizeof(flags) / sizeof(flags[0]); i++) {
+    if (!receive_wire_bool(fd, flags[i]))
+      return false;
+  }
+  if (!receive_n_data(fd, &c->max_delete, sizeof(c->max_delete)))
+    return false;
+  if (!receive_wire_bool(fd, &c->relative))
+    return false;
+  if (!receive_wire_bool(fd, &c->prune_empty_dirs))
+    return false;
+  return true;
+}
+
+static bool receive_resume_options(int fd, Config* c) {
+  c->temp_dir = receive_str(fd);
+  if (!c->temp_dir || !receive_wire_bool(fd, &c->partial))
+    return false;
+  c->partial_dir = receive_str(fd);
+  c->suffix = c->partial_dir ? receive_str(fd) : NULL;
+  if (!c->partial_dir || !c->suffix || !receive_wire_bool(fd, &c->delete_before))
+    return false;
+  if (!receive_wire_bool(fd, &c->checksum))
+    return false;
+  c->compress_choice = receive_str(fd);
+  return c->compress_choice != NULL;
+}
+
 bool config_send(int file_descriptor, const Config* config) {
-  if (!send_str(file_descriptor, config->version))
-    return false;
-  if (!send_str(file_descriptor, config->send_directory))
-    return false;
-  if (!send_str(file_descriptor, config->receive_root_directory))
-    return false;
-  if (!send_int(file_descriptor, config->save_to_disk))
-    return false;
-  if (!send_int(file_descriptor, config->use_multithreading))
-    return false;
-  if (!send_int(file_descriptor, config->use_chunk_serialization))
-    return false;
-  if (!send_int(file_descriptor, config->use_compression))
-    return false;
-  if (!send_int(file_descriptor, config->use_metadata))
-    return false;
-  if (!send_int(file_descriptor, config->compression_level))
-    return false;
-  if (!send_n_data(file_descriptor, &config->chunk_size, sizeof(config->chunk_size)))
-    return false;
-  if (!send_int(file_descriptor, config->use_sendfile))
-    return false;
-  if (!send_int(file_descriptor, config->use_delete))
-    return false;
-  if (!send_int(file_descriptor, config->use_incremental))
-    return false;
-  if (!send_int(file_descriptor, config->use_delta))
-    return false;
-  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;
-  if (!send_int(file_descriptor, config->backup))
-    return false;
-  if (!send_str(file_descriptor, config->backup_dir ? config->backup_dir : ""))
-    return false;
-  if (!send_int(file_descriptor, config->follow_symlinks))
-    return false;
-  if (!send_int(file_descriptor, config->copy_links))
-    return false;
-  if (!send_int(file_descriptor, config->safe_links))
-    return false;
-  if (!send_int(file_descriptor, config->copy_unsafe_links))
-    return false;
-  if (!send_int(file_descriptor, config->preserve_hard_links))
-    return false;
-  if (!send_int(file_descriptor, config->preserve_acls))
-    return false;
-  if (!send_int(file_descriptor, config->preserve_xattrs))
-    return false;
-  if (!send_int(file_descriptor, config->preserve_devices))
-    return false;
-  if (!send_int(file_descriptor, config->preserve_sparse))
-    return false;
-  if (!send_int(file_descriptor, config->update))
-    return false;
-  if (!send_int(file_descriptor, config->inplace))
-    return false;
-  if (!send_int(file_descriptor, config->append))
-    return false;
-  if (!send_int(file_descriptor, config->append_verify))
-    return false;
-  if (!send_int(file_descriptor, config->delete_excluded))
-    return false;
-  if (!send_int(file_descriptor, config->delete_after))
-    return false;
-  if (!send_n_data(file_descriptor, &config->max_delete, sizeof(config->max_delete)))
-    return false;
-  if (!send_int(file_descriptor, config->relative))
-    return false;
-  if (!send_int(file_descriptor, config->prune_empty_dirs))
-    return false;
-  if (!send_str(file_descriptor, config->temp_dir ? config->temp_dir : ""))
-    return false;
-  if (!send_int(file_descriptor, config->partial))
-    return false;
-  if (!send_str(file_descriptor, config->partial_dir ? config->partial_dir : ""))
-    return false;
-  if (!send_str(file_descriptor, config->suffix ? config->suffix : ""))
-    return false;
-  if (!send_int(file_descriptor, config->delete_before))
-    return false;
-  if (!send_int(file_descriptor, config->checksum))
-    return false;
-  if (!send_str(file_descriptor, config->compress_choice ? config->compress_choice : ""))
+  if (!send_core_fields(file_descriptor, config) || !send_delta_fields(file_descriptor, config) ||
+      !send_file_options(file_descriptor, config) ||
+      !send_selection_options(file_descriptor, config) ||
+      !send_resume_options(file_descriptor, config))
     return false;
   Status status;
   if (!receive_status(file_descriptor, &status))
@@ -321,106 +349,25 @@ 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)
+  Config* config = config_create();
+  if (!config)
     return NULL;
-  config_set_defaults(config);
   free(config->version);
   config->version = receive_str(file_descriptor);
-  if (!config->version) {
-    free(config->server_host);
-    free(config);
-    return NULL;
-  }
+  if (!config->version)
+    goto error;
   if (strcmp(config->version, PROTOCOL_VERSION) != 0) {
     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;
+    goto error;
   }
-  config->send_directory = receive_str(file_descriptor);
-  if (!config->send_directory) {
-    free(config->version);
-    free(config->server_host);
-    free(config);
-    return NULL;
-  }
-  config->receive_root_directory = receive_str(file_descriptor);
-  if (!config->receive_root_directory) {
-    free(config->version);
-    free(config->send_directory);
-    free(config->server_host);
-    free(config);
-    return NULL;
-  }
-  int tmp;
-  if (!receive_wire_bool(file_descriptor, &config->save_to_disk) ||
-      !receive_wire_bool(file_descriptor, &config->use_multithreading) ||
-      !receive_wire_bool(file_descriptor, &config->use_chunk_serialization) ||
-      !receive_wire_bool(file_descriptor, &config->use_compression) ||
-      !receive_wire_bool(file_descriptor, &config->use_metadata))
-    goto error;
-  if (!receive_int(file_descriptor, &tmp))
-    goto error;
-  config->compression_level = tmp;
-  if (!receive_n_data(file_descriptor, &config->chunk_size, sizeof(config->chunk_size)))
-    goto error;
-  if (!receive_wire_bool(file_descriptor, &config->use_sendfile) ||
-      !receive_wire_bool(file_descriptor, &config->use_delete) ||
-      !receive_wire_bool(file_descriptor, &config->use_incremental) ||
-      !receive_wire_bool(file_descriptor, &config->use_delta))
-    goto error;
-  if (!receive_n_data(file_descriptor, &config->delta_block_size, sizeof(config->delta_block_size)))
-    goto error;
-  if (!receive_n_data(file_descriptor, &config->delta_max_file_size, sizeof(unsigned long long)))
-    goto error;
-  if (!receive_wire_bool(file_descriptor, &config->backup))
-    goto error;
-  config->backup_dir = receive_str(file_descriptor);
-  if (config->backup_dir == NULL)
-    goto error;
-  if (!receive_wire_bool(file_descriptor, &config->follow_symlinks) ||
-      !receive_wire_bool(file_descriptor, &config->copy_links) ||
-      !receive_wire_bool(file_descriptor, &config->safe_links) ||
-      !receive_wire_bool(file_descriptor, &config->copy_unsafe_links) ||
-      !receive_wire_bool(file_descriptor, &config->preserve_hard_links) ||
-      !receive_wire_bool(file_descriptor, &config->preserve_acls) ||
-      !receive_wire_bool(file_descriptor, &config->preserve_xattrs) ||
-      !receive_wire_bool(file_descriptor, &config->preserve_devices) ||
-      !receive_wire_bool(file_descriptor, &config->preserve_sparse) ||
-      !receive_wire_bool(file_descriptor, &config->update) ||
-      !receive_wire_bool(file_descriptor, &config->inplace) ||
-      !receive_wire_bool(file_descriptor, &config->append) ||
-      !receive_wire_bool(file_descriptor, &config->append_verify) ||
-      !receive_wire_bool(file_descriptor, &config->delete_excluded) ||
-      !receive_wire_bool(file_descriptor, &config->delete_after))
-    goto error;
-  if (!receive_n_data(file_descriptor, &config->max_delete, sizeof(config->max_delete)))
-    goto error;
-  if (!receive_wire_bool(file_descriptor, &config->relative) ||
-      !receive_wire_bool(file_descriptor, &config->prune_empty_dirs))
-    goto error;
-  config->temp_dir = receive_str(file_descriptor);
-  if (config->temp_dir == NULL)
-    goto error;
-  if (!receive_wire_bool(file_descriptor, &config->partial))
-    goto error;
-  config->partial_dir = receive_str(file_descriptor);
-  if (config->partial_dir == NULL)
-    goto error;
-  config->suffix = receive_str(file_descriptor);
-  if (config->suffix == NULL)
-    goto error;
-  if (!receive_wire_bool(file_descriptor, &config->delete_before) ||
-      !receive_wire_bool(file_descriptor, &config->checksum))
-    goto error;
-  config->compress_choice = receive_str(file_descriptor);
-  if (config->compress_choice == NULL)
+  if (!receive_core_fields(file_descriptor, config) ||
+      !receive_delta_fields(file_descriptor, config) ||
+      !receive_file_options(file_descriptor, config) ||
+      !receive_selection_options(file_descriptor, config) ||
+      !receive_resume_options(file_descriptor, config))
     goto error;
   if (config->compress_choice[0] != '\0' && strcmp(config->compress_choice, "zstd") != 0 &&
       strcmp(config->compress_choice, "none") != 0) {
@@ -438,15 +385,6 @@ Config* config_receive(int file_descriptor) {
   return config;
 
 error:
-  free(config->version);
-  free(config->send_directory);
-  free(config->receive_root_directory);
-  free(config->server_host);
-  free(config->backup_dir);
-  free(config->temp_dir);
-  free(config->partial_dir);
-  free(config->suffix);
-  free(config->compress_choice);
-  free(config);
+  config_delete(config);
   return NULL;
 }

src/shared/file.c

@@ -19,6 +19,7 @@
 #include "config.h"
 #include "data.h"
 #include "file.h"
+#include "file_store.h"
 #include "metadata.h"
 #include "protocol.h"
 #include "utils.h"
@@ -305,13 +306,14 @@ fail:
 }
 
 static File* receive_delta_file(int fd, const Config* config, const char* check_path,
-                                void* old_data, unsigned long long old_size) {
+                                void* old_data, unsigned long long old_size, bool* failed) {
   if (!old_data)
     return NULL;
 
   DeltaSignature* sig = delta_signature_create(old_data, old_size, config->delta_block_size);
   if (!sig) {
     free(old_data);
+    *failed = true;
     return NULL;
   }
 
@@ -319,6 +321,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
   if (!sig_data) {
     delta_signature_destroy(sig);
     free(old_data);
+    *failed = true;
     return NULL;
   }
 
@@ -328,6 +331,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
   if (!sig_sent) {
     delta_signature_destroy(sig);
     free(old_data);
+    *failed = true;
     return NULL;
   }
 
@@ -335,6 +339,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
   if (!receive_status(fd, &resp)) {
     delta_signature_destroy(sig);
     free(old_data);
+    *failed = true;
     return NULL;
   }
 
@@ -343,7 +348,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
     if (!delta_data) {
       delta_signature_destroy(sig);
       free(old_data);
-      send_status(fd, STATUS_ERROR);
+      *failed = true;
       return NULL;
     }
 
@@ -354,7 +359,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
       if (!raw_delta) {
         free(old_data);
         delta_signature_destroy(sig);
-        send_status(fd, STATUS_ERROR);
+        *failed = true;
         return NULL;
       }
     }
@@ -364,7 +369,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
     if (!delta) {
       free(old_data);
       delta_signature_destroy(sig);
-      send_status(fd, STATUS_ERROR);
+      *failed = true;
       return NULL;
     }
 
@@ -382,7 +387,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
     if (!new_data) {
       free(old_data);
       delta_signature_destroy(sig);
-      send_status(fd, STATUS_ERROR);
+      *failed = true;
       return NULL;
     }
 
@@ -391,7 +396,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
       free(new_data);
       free(old_data);
       delta_signature_destroy(sig);
-      send_status(fd, STATUS_ERROR);
+      *failed = true;
       return NULL;
     }
 
@@ -403,7 +408,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
         free(new_data);
         free(old_data);
         delta_signature_destroy(sig);
-        send_status(fd, STATUS_ERROR);
+        *failed = true;
         return NULL;
       }
     }
@@ -430,7 +435,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
 
     File* file = file_create(check_path);
     if (!file) {
-      send_status(fd, STATUS_ERROR);
+      *failed = true;
       return NULL;
     }
 
@@ -439,7 +444,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
       file->metadata = metadata_receive(fd, &meta_ok);
       if (!meta_ok) {
         file_destroy(file);
-        send_status(fd, STATUS_ERROR);
+        *failed = true;
         return NULL;
       }
     }
@@ -447,7 +452,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
     Data* file_data = receive_data_limited(fd, MAX_RECEIVE_FILE_SIZE);
     if (file_data == NULL) {
       file_destroy(file);
-      send_status(fd, STATUS_ERROR);
+      *failed = true;
       return NULL;
     }
 
@@ -456,7 +461,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
       data_destroy(file_data);
       if (uncompressed == NULL) {
         file_destroy(file);
-        send_status(fd, STATUS_ERROR);
+        *failed = true;
         return NULL;
       }
       if (uncompressed->size > MAX_FILE_DATA_SIZE) {
@@ -476,6 +481,7 @@ static File* receive_delta_file(int fd, const Config* config, const char* check_
   delta_signature_destroy(sig);
   free(old_data);
   send_status(fd, STATUS_ERROR);
+  *failed = true;
   return NULL;
 }
 
@@ -487,7 +493,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   *skipped = false;
   char* check_path = receive_str(fd);
   if (check_path == NULL) {
-    send_status(fd, STATUS_ERROR);
     return NULL;
   }
 
@@ -497,12 +502,10 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   if (!receive_n_data(fd, &check_size, sizeof(check_size)) ||
       !receive_n_data(fd, &check_mtime, sizeof(check_mtime))) {
     free(check_path);
-    send_status(fd, STATUS_ERROR);
     return NULL;
   }
   if (config->checksum && !receive_n_data(fd, &check_checksum, sizeof(check_checksum))) {
     free(check_path);
-    send_status(fd, STATUS_ERROR);
     return NULL;
   }
 
@@ -515,7 +518,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   if (has_path_traversal(check_path)) {
     log_message(LOG_LEVEL_ERROR, "Path traversal detected: %s", check_path);
     free(check_path);
-    send_status(fd, STATUS_ERROR);
     return NULL;
   }
 
@@ -586,13 +588,20 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
                    delta_should_attempt(old_size, check_size, config->delta_max_file_size);
 
   if (try_delta) {
-    File* delta_file = receive_delta_file(fd, config, check_path, old_data, old_size);
+    bool delta_failed = false;
+    File* delta_file =
+        receive_delta_file(fd, config, check_path, old_data, old_size, &delta_failed);
     old_data = NULL; /* receive_delta_file consumes the snapshot on every path */
     if (delta_file) {
       free(full_path);
       free(check_path);
       return delta_file;
     }
+    if (delta_failed) {
+      free(full_path);
+      free(check_path);
+      return NULL;
+    }
     free(old_data);
     old_data = NULL;
     try_delta = false;
@@ -610,7 +619,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   free(check_path);
   free(full_path);
   if (file == NULL) {
-    send_status(fd, STATUS_ERROR);
     return NULL;
   }
 
@@ -619,7 +627,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
     file->metadata = metadata_receive(fd, &meta_ok);
     if (!meta_ok) {
       file_destroy(file);
-      send_status(fd, STATUS_ERROR);
       return NULL;
     }
   }
@@ -627,7 +634,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   Data* file_data = receive_data_limited(fd, MAX_RECEIVE_FILE_SIZE);
   if (file_data == NULL) {
     file_destroy(file);
-    send_status(fd, STATUS_ERROR);
     return NULL;
   }
 
@@ -636,7 +642,6 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
     data_destroy(file_data);
     if (uncompressed == NULL) {
       file_destroy(file);
-      send_status(fd, STATUS_ERROR);
       return NULL;
     }
     if (uncompressed->size > MAX_FILE_DATA_SIZE) {

src/shared/file_store.c

@@ -0,0 +1,197 @@
+#include <errno.h>
+#include <fcntl.h>
+#include <libgen.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+#include "file_store.h"
+#include "metadata.h"
+#include "utils.h"
+
+static int authorized_root_fd = -1;
+static char* authorized_root_path;
+
+static bool path_is_within_root(const char* root, const char* path) {
+  size_t root_length = strlen(root);
+  return strncmp(root, path, root_length) == 0 &&
+         (path[root_length] == '\0' || path[root_length] == '/');
+}
+
+bool file_store_set_authorized_root(int fd, const char* canonical_path) {
+  char* new_path = canonical_path ? str_dup(canonical_path) : NULL;
+  if (canonical_path && !new_path) {
+    authorized_root_fd = -1;
+    free(authorized_root_path);
+    authorized_root_path = NULL;
+    return false;
+  }
+  free(authorized_root_path);
+  authorized_root_path = new_path;
+  authorized_root_fd = fd;
+  return true;
+}
+
+int file_store_open_secure_parent(const char* path, char** leaf_out) {
+  char* copy = str_dup(path);
+  if (!copy)
+    return -1;
+  char* parent = dirname(copy);
+  const char* slash = strrchr(path, '/');
+  char* leaf = str_dup(slash ? slash + 1 : path);
+  if (!leaf) {
+    free(copy);
+    return -1;
+  }
+  int fd;
+  if (authorized_root_fd >= 0) {
+    if (!authorized_root_path || path[0] != '/' ||
+        !path_is_within_root(authorized_root_path, path)) {
+      free(copy);
+      free(leaf);
+      return -1;
+    }
+    fd = dup(authorized_root_fd);
+    if (fd < 0) {
+      free(copy);
+      free(leaf);
+      return -1;
+    }
+    size_t root_length = strlen(authorized_root_path);
+    char* relative = str_dup(path + root_length);
+    if (!relative) {
+      free(copy);
+      free(leaf);
+      close(fd);
+      return -1;
+    }
+    free(copy);
+    copy = relative;
+    parent = dirname(copy);
+  } else {
+    fd = (parent[0] == '/') ? open("/", O_RDONLY | O_DIRECTORY | O_CLOEXEC)
+                            : open(".", O_RDONLY | O_DIRECTORY | O_CLOEXEC);
+  }
+  if (fd < 0) {
+    free(copy);
+    free(leaf);
+    return -1;
+  }
+  char* save = NULL;
+  char* component = strtok_r(parent, "/", &save);
+  while (component) {
+    if (strcmp(component, "..") == 0) {
+      close(fd);
+      free(copy);
+      free(leaf);
+      return -1;
+    }
+    if (strcmp(component, ".") != 0) {
+      int next = openat(fd, component, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC);
+      if (next < 0 && errno == ENOENT) {
+        if (mkdirat(fd, component, 0755) == 0 || errno == EEXIST)
+          next = openat(fd, component, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC);
+      }
+      if (next < 0) {
+        close(fd);
+        free(copy);
+        free(leaf);
+        return -1;
+      }
+      close(fd);
+      fd = next;
+    }
+    component = strtok_r(NULL, "/", &save);
+  }
+  free(copy);
+  *leaf_out = leaf;
+  return fd;
+}
+
+bool file_store_rename_secure(const char* old_path, const char* new_path) {
+  char *old_leaf = NULL, *new_leaf = NULL;
+  int old_parent = file_store_open_secure_parent(old_path, &old_leaf);
+  int new_parent = file_store_open_secure_parent(new_path, &new_leaf);
+  bool ok = old_parent >= 0 && new_parent >= 0 &&
+            renameat(old_parent, old_leaf, new_parent, new_leaf) == 0;
+  if (old_parent >= 0)
+    close(old_parent);
+  if (new_parent >= 0)
+    close(new_parent);
+  free(old_leaf);
+  free(new_leaf);
+  return ok;
+}
+
+static bool write_all(int fd, const void* data, unsigned long long size) {
+  const unsigned char* p = data;
+  unsigned long long done = 0;
+  while (done < size) {
+    ssize_t n = write(fd, p + done, (size_t)(size - done));
+    if (n < 0 && errno == EINTR)
+      continue;
+    if (n <= 0)
+      return false;
+    done += (unsigned long long)n;
+  }
+  return true;
+}
+
+bool file_store_write_secure(const char* path, const void* data, unsigned long long data_size,
+                             bool inplace, bool sparse, const FileMetadata* metadata) {
+  char* leaf = NULL;
+  int dirfd = file_store_open_secure_parent(path, &leaf);
+  if (dirfd < 0)
+    return false;
+  int fd = -1;
+  bool ok = false;
+  if (inplace) {
+    fd = openat(dirfd, leaf, O_WRONLY | O_CREAT | O_TRUNC | O_CLOEXEC | O_NOFOLLOW, 0644);
+    if (fd >= 0) {
+      if (!sparse || data_size == 0 || ftruncate(fd, (off_t)data_size) == 0)
+        ok = write_all(fd, data, data_size);
+      if (ok && metadata)
+        ok = file_restore_metadata_fd(fd, metadata);
+    }
+  } else {
+    int tmp_size = snprintf(NULL, 0, ".%s.tmp.%ld.%u", leaf, (long)getpid(), 99U);
+    if (tmp_size < 0) {
+      close(dirfd);
+      free(leaf);
+      return false;
+    }
+    char* tmp = malloc((size_t)tmp_size + 1);
+    if (!tmp) {
+      close(dirfd);
+      free(leaf);
+      return false;
+    }
+    for (unsigned int i = 0; i < 100 && !ok; ++i) {
+      snprintf(tmp, (size_t)tmp_size + 1, ".%s.tmp.%ld.%u", leaf, (long)getpid(), i);
+      fd = openat(dirfd, tmp, O_WRONLY | O_CREAT | O_EXCL | O_CLOEXEC | O_NOFOLLOW, 0600);
+      if (fd < 0)
+        continue;
+      if (sparse && data_size > 0)
+        ok = ftruncate(fd, (off_t)data_size) == 0;
+      if (ok || (!sparse || data_size == 0))
+        ok = write_all(fd, data, data_size);
+      if (ok && metadata)
+        ok = file_restore_metadata_fd(fd, metadata);
+      if (close(fd) != 0)
+        ok = false;
+      fd = -1;
+      if (ok && renameat(dirfd, tmp, dirfd, leaf) != 0)
+        ok = false;
+      if (!ok)
+        unlinkat(dirfd, tmp, 0);
+    }
+    free(tmp);
+  }
+  if (fd >= 0)
+    close(fd);
+  close(dirfd);
+  free(leaf);
+  return ok;
+}

src/shared/file_store.h

@@ -0,0 +1,13 @@
+#ifndef FILE_STORE_H
+#define FILE_STORE_H
+
+#include "file.h"
+#include <stdbool.h>
+
+bool file_store_set_authorized_root(int fd, const char* canonical_path);
+int file_store_open_secure_parent(const char* path, char** leaf_out);
+bool file_store_rename_secure(const char* old_path, const char* new_path);
+bool file_store_write_secure(const char* path, const void* data, unsigned long long data_size,
+                             bool inplace, bool sparse, const FileMetadata* metadata);
+
+#endif

src/shared/multiprocessing.c

@@ -1,4 +1,5 @@
 #include "multiprocessing.h"
+#include "receiver.h"
 
 #include "array_list.h"
 #include "chunk.h"
@@ -14,10 +15,6 @@
 #include <string.h>
 #include <threads.h>
 
-static bool valid_batch_path(const char* path) {
-  return path && path[0] != '\0' && path[0] != '/' && !has_path_traversal(path);
-}
-
 PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
                                                       Queue* queue_loader) {
   PipelineContextSender* context = malloc(sizeof(PipelineContextSender));
@@ -101,6 +98,8 @@ PipelineContextReceiver* pipeline_context_receiver_create(Config* config, Queue*
   context->queue = queue;
   context->file_descriptor = file_descriptor;
   context->ssl = ssl;
+  protocol_session_init(&context->session, file_descriptor, file_descriptor);
+  protocol_session_set_ssl(&context->session, ssl);
   context->receiver_done = false;
   atomic_init(&context->cancelled, false);
   int init = 0;
@@ -137,24 +136,14 @@ void pipeline_context_receiver_destroy(PipelineContextReceiver* context) {
   free(context);
 }
 
-static bool receive_chunk_enqueue(int file_descriptor, PipelineContextReceiver* context) {
-  Chunk* chunk = receive_chunk_data(file_descriptor, context->config);
-  if (chunk == NULL)
-    return false;
-
-  for (int i = 0; i < chunk->element_count; i++) {
-    File* file = chunk->items[i];
-    chunk->items[i] = NULL;
-    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;
+static bool receiver_enqueue_file(File* file, void* context_pointer) {
+  PipelineContextReceiver* context = context_pointer;
+  if (queue_enqueue_multithreaded_cancel(context->queue, file, &context->mutex,
+                                         &context->condition_not_empty,
+                                         &context->condition_not_full, &context->cancelled))
+    return true;
+  file_destroy(file);
+  return false;
 }
 
 static void receiver_thread_fail(PipelineContextReceiver* context) {
@@ -167,130 +156,42 @@ static void receiver_thread_fail(PipelineContextReceiver* context) {
 }
 
 int receive_thread(void* pipeline_context) {
-#define RECEIVE_THREAD_FAIL()                                                                      \
-  do {                                                                                             \
-    receiver_thread_fail(context);                                                                 \
-    return thrd_error;                                                                             \
-  } while (0)
   PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
-  if (context->ssl)
-    io_set_ssl(context->ssl);
+  protocol_session_bind(&context->session);
   mtx_lock(&context->mutex);
   int file_descriptor = context->file_descriptor;
   const Config* config = context->config;
   mtx_unlock(&context->mutex);
 
-  Status status;
-  if (!receive_status(file_descriptor, &status))
-    RECEIVE_THREAD_FAIL();
-  while (status == STATUS_NEXT || status == STATUS_CHUNK || status == STATUS_CHECK ||
-         status == STATUS_KEEPALIVE || status == STATUS_ABORT || status == STATUS_CHECK_BATCH) {
-    if (status == STATUS_KEEPALIVE) {
-      if (!send_status(file_descriptor, STATUS_KEEPALIVE))
-        RECEIVE_THREAD_FAIL();
-      goto next;
-    }
-    if (status == STATUS_ABORT) {
-      log_message(LOG_LEVEL_INFO, "Received abort from client, cleaning up");
-      RECEIVE_THREAD_FAIL();
-    }
-    if (status == STATUS_CHECK) {
-      bool skipped;
-      File* file = receive_incremental_check(file_descriptor, config, &skipped);
-      if (!skipped) {
-        if (file == NULL)
-          RECEIVE_THREAD_FAIL();
-        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))
-        RECEIVE_THREAD_FAIL();
-    } else if (status == STATUS_CHECK_BATCH) {
-      int count;
-      if (config->checksum || !receive_int(file_descriptor, &count) || count < 0 ||
-          count > MAX_MANIFEST_ENTRIES)
-        RECEIVE_THREAD_FAIL();
-      for (int i = 0; i < count; i++) {
-        char* check_path = receive_str(file_descriptor);
-        if (!check_path)
-          RECEIVE_THREAD_FAIL();
-        unsigned long long check_size;
-        long long check_mtime;
-        if (!receive_n_data(file_descriptor, &check_size, sizeof(check_size)) ||
-            !receive_n_data(file_descriptor, &check_mtime, sizeof(check_mtime))) {
-          free(check_path);
-          RECEIVE_THREAD_FAIL();
-        }
-        if (!valid_batch_path(check_path)) {
-          free(check_path);
-          if (!send_status(file_descriptor, STATUS_ERROR))
-            RECEIVE_THREAD_FAIL();
-          RECEIVE_THREAD_FAIL();
-        }
-        char* full_path = path_cat(config->receive_root_directory, check_path);
-        if (!full_path) {
-          free(check_path);
-          if (!send_status(file_descriptor, STATUS_ERROR))
-            RECEIVE_THREAD_FAIL();
-          RECEIVE_THREAD_FAIL();
-        }
-        struct stat st;
-        bool has_old = full_path && file_stat_secure(full_path, &st);
-        bool match = has_old && (unsigned long long)st.st_size == check_size &&
-                     (long long)st.st_mtime == check_mtime && S_ISREG(st.st_mode);
-        if (!send_status(file_descriptor, match ? STATUS_OK : STATUS_NEXT))
-          RECEIVE_THREAD_FAIL();
-        free(full_path);
-        free(check_path);
-      }
-      goto next;
-    } else {
-      File* file = file_receive(config, file_descriptor);
-      if (file) {
-        if (!queue_enqueue_multithreaded_cancel(
-                context->queue, file, &context->mutex, &context->condition_not_empty,
-                &context->condition_not_full, &context->cancelled)) {
-          file_destroy(file);
-          receiver_thread_fail(context);
-          return thrd_error;
-        }
-      } else {
-        log_message(LOG_LEVEL_ERROR, "Failed to receive file");
-        RECEIVE_THREAD_FAIL();
-      }
-    }
-  next:
-    if (!receive_status(file_descriptor, &status))
-      RECEIVE_THREAD_FAIL();
+  ReceiverSink sink = {receiver_enqueue_file, context, false, false};
+  if (receiver_process((Config*)config, file_descriptor, &sink) != 0) {
+    receiver_thread_fail(context);
+    protocol_session_unbind();
+    return thrd_error;
   }
-  if (status == STATUS_MANIFEST) {
-    if (receive_manifest(file_descriptor, config, &status) != 0) {
-      RECEIVE_THREAD_FAIL();
-    }
-  }
-  if (status != STATUS_FINISHED)
-    RECEIVE_THREAD_FAIL();
   mtx_lock(&context->mutex);
   context->receiver_done = true;
   cnd_signal(&context->condition_not_empty);
   mtx_unlock(&context->mutex);
-#undef RECEIVE_THREAD_FAIL
+  protocol_session_unbind();
   return thrd_success;
 }
 
 int write_thread(void* pipeline_context) {
   PipelineContextReceiver* context = (PipelineContextReceiver*)pipeline_context;
-  if (context->ssl)
-    io_set_ssl(context->ssl);
   mtx_lock(&context->mutex);
   bool save_to_disk = context->config->save_to_disk;
   char* root_directory = str_dup(context->config->receive_root_directory);
   mtx_unlock(&context->mutex);
+  if (save_to_disk && !root_directory) {
+    mtx_lock(&context->mutex);
+    atomic_store(&context->cancelled, true);
+    context->receiver_done = true;
+    cnd_broadcast(&context->condition_not_full);
+    cnd_broadcast(&context->condition_not_empty);
+    mtx_unlock(&context->mutex);
+    return thrd_error;
+  }
 
   while (true) {
     File* file =

src/shared/multiprocessing.h

@@ -35,6 +35,7 @@ typedef struct PipelineContextReceiver {
   Config* config;
   int file_descriptor;
   SSL* ssl;
+  ProtocolSession session;
   mtx_t mutex;
   cnd_t condition_not_full;
   cnd_t condition_not_empty;

src/shared/protocol.c

@@ -18,89 +18,125 @@
 static __thread int io_read_fd = -1;
 static __thread int io_write_fd = -1;
 static __thread SSL* io_ssl;
+static __thread ProtocolSession* bound_session;
+static __thread ProtocolSession legacy_io_session = {.read_fd = -1, .write_fd = -1};
 
 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;
+static unsigned long long global_bwlimit(void);
 
 void protocol_release_memory(size_t charge) {
-  if ((unsigned long long)charge >= total_allocated_bytes)
-    total_allocated_bytes = 0;
+  ProtocolSession* session = bound_session ? bound_session : &legacy_io_session;
+  if ((unsigned long long)charge >= session->total_allocated_bytes)
+    session->total_allocated_bytes = 0;
   else
-    total_allocated_bytes -= charge;
+    session->total_allocated_bytes -= charge;
 }
-
 void io_set_fds(int read_fd, int write_fd) {
+  bound_session = NULL;
   io_read_fd = read_fd;
   io_write_fd = write_fd;
   /* A descriptor switch starts a new transport; never reuse a TLS object
      belonging to a previous connection or test pipe. */
   io_ssl = NULL;
-  total_allocated_bytes = 0;
+  legacy_io_session.read_fd = read_fd;
+  legacy_io_session.write_fd = write_fd;
+  legacy_io_session.ssl = NULL;
+  legacy_io_session.total_allocated_bytes = 0;
+  protocol_session_set_bwlimit(&legacy_io_session, global_bwlimit());
+}
+
+void protocol_session_init(ProtocolSession* session, int read_fd, int write_fd) {
+  if (!session)
+    return;
+  memset(session, 0, sizeof(*session));
+  session->read_fd = read_fd;
+  session->write_fd = write_fd;
+  protocol_session_set_bwlimit(session, global_bwlimit());
+}
+
+void protocol_session_bind(ProtocolSession* session) {
+  bound_session = session;
+}
+
+void protocol_session_unbind(void) {
+  bound_session = NULL;
+}
+
+void protocol_session_set_ssl(ProtocolSession* session, SSL* ssl) {
+  if (session)
+    session->ssl = ssl;
 }
 
 static void bw_mutex_init(void) {
   mtx_init(&bw_mutex, mtx_plain);
 }
 
+static unsigned long long global_bwlimit(void) {
+  unsigned long long limit;
+  call_once(&bw_mutex_once, bw_mutex_init);
+  mtx_lock(&bw_mutex);
+  limit = io_bwlimit;
+  mtx_unlock(&bw_mutex);
+  return limit;
+}
+
 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 > (unsigned long long)LLONG_MAX ? (unsigned long long)LLONG_MAX : 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) {
-  call_once(&bw_mutex_once, bw_mutex_init);
-  mtx_lock(&bw_mutex);
-  if (io_bwlimit == 0) {
-    mtx_unlock(&bw_mutex);
+void protocol_session_set_bwlimit(ProtocolSession* session, unsigned long long bytes_per_sec) {
+  if (!session)
+    return;
+  session->bwlimit =
+      bytes_per_sec > (unsigned long long)LLONG_MAX ? (unsigned long long)LLONG_MAX : bytes_per_sec;
+  session->bw_tokens = (long long)session->bwlimit;
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  session->bw_last_refill_sec = now.tv_sec;
+  session->bw_last_refill_nsec = now.tv_nsec;
+}
+
+static void bw_throttle_session(ProtocolSession* session, size_t bytes_written) {
+  if (session->bwlimit == 0)
     return;
-  }
 
   struct timespec now;
   clock_gettime(CLOCK_MONOTONIC, &now);
 
-  long long elapsed_ns =
-      (now.tv_sec - bw_last_refill.tv_sec) * 1000000000LL + (now.tv_nsec - bw_last_refill.tv_nsec);
-  bw_last_refill = now;
+  long long elapsed_ns = (now.tv_sec - session->bw_last_refill_sec) * 1000000000LL +
+                         (now.tv_nsec - session->bw_last_refill_nsec);
+  session->bw_last_refill_sec = now.tv_sec;
+  session->bw_last_refill_nsec = now.tv_nsec;
 
-  long long tokens_to_add = (long long)((double)io_bwlimit * elapsed_ns / 1000000000.0);
-  bw_tokens += tokens_to_add;
-  if (bw_tokens > (long long)io_bwlimit)
-    bw_tokens = (long long)io_bwlimit;
+  long long tokens_to_add = (long long)((double)session->bwlimit * elapsed_ns / 1000000000.0);
+  session->bw_tokens += tokens_to_add;
+  if (session->bw_tokens > (long long)session->bwlimit)
+    session->bw_tokens = (long long)session->bwlimit;
 
-  bw_tokens -= (long long)bytes_written;
+  session->bw_tokens -= bytes_written;
 
-  if (bw_tokens < 0) {
-    long long deficit_us = (long long)((double)(-bw_tokens) / io_bwlimit * 1000000.0);
+  if (session->bw_tokens < 0) {
+    long long deficit_us =
+        (long long)((double)(-session->bw_tokens) / session->bwlimit * 1000000.0);
     if (deficit_us >= 1000)
       poll(NULL, 0, (int)(deficit_us / 1000));
     else
       usleep((useconds_t)deficit_us);
-    bw_tokens = 0;
-    clock_gettime(CLOCK_MONOTONIC, &bw_last_refill);
+    session->bw_tokens = 0;
+    session->bw_last_refill_sec = now.tv_sec;
+    session->bw_last_refill_nsec = now.tv_nsec;
   }
-  mtx_unlock(&bw_mutex);
-}
-
-static bool bw_enabled(void) {
-  bool enabled;
-  call_once(&bw_mutex_once, bw_mutex_init);
-  mtx_lock(&bw_mutex);
-  enabled = io_bwlimit != 0;
-  mtx_unlock(&bw_mutex);
-  return enabled;
 }
 
 void io_set_ssl(SSL* ssl) {
+  bound_session = NULL;
   io_ssl = ssl;
 }
 
@@ -108,8 +144,30 @@ SSL* io_get_ssl(void) {
   return io_ssl;
 }
 
-static int io_fd(int dir_fd, int file_descriptor) {
-  return (dir_fd != -1) ? dir_fd : file_descriptor;
+static ProtocolSession* legacy_session(int read_fd, int write_fd) {
+  if (bound_session)
+    return bound_session;
+  int target_read_fd = io_read_fd != -1 ? io_read_fd : read_fd;
+  int target_write_fd = io_write_fd != -1 ? io_write_fd : write_fd;
+  if (legacy_io_session.read_fd != target_read_fd ||
+      legacy_io_session.write_fd != target_write_fd) {
+    legacy_io_session.read_fd = target_read_fd;
+    legacy_io_session.write_fd = target_write_fd;
+    legacy_io_session.total_allocated_bytes = 0;
+    protocol_session_set_bwlimit(&legacy_io_session, global_bwlimit());
+  } else if (legacy_io_session.bwlimit != global_bwlimit()) {
+    protocol_session_set_bwlimit(&legacy_io_session, global_bwlimit());
+  }
+  legacy_io_session.ssl = io_ssl;
+  return &legacy_io_session;
+}
+
+bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
+  return protocol_send_n_data(legacy_session(-1, file_descriptor), data, data_size);
+}
+
+bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
+  return protocol_receive_n_data(legacy_session(file_descriptor, -1), data, data_size);
 }
 
 static int deadline_remaining_ms(const struct timespec* deadline) {
@@ -123,11 +181,13 @@ static int deadline_remaining_ms(const struct timespec* deadline) {
   return ms > INT_MAX ? INT_MAX : (int)ms;
 }
 
-bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
+bool protocol_send_n_data(ProtocolSession* session, const void* data, size_t data_size) {
   if (!data && data_size != 0)
     return false;
   log_message(LOG_LEVEL_DEBUG, "    Sending n Data: %zu", data_size);
-  int fd = io_fd(io_write_fd, file_descriptor);
+  if (!session)
+    return false;
+  int fd = session->write_fd;
   struct timespec deadline;
   clock_gettime(CLOCK_MONOTONIC, &deadline);
   deadline.tv_sec += SEND_TIMEOUT_SEC;
@@ -135,7 +195,7 @@ bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
   ssize_t total_bytes_send = 0;
   while ((size_t)total_bytes_send < data_size) {
     size_t chunk = data_size - total_bytes_send;
-    if (bw_enabled() && chunk > 65536)
+    if (session->bwlimit > 0 && chunk > 65536)
       chunk = 65536;
     struct pollfd pfd = {.fd = fd, .events = wait_events};
     int poll_result = poll(&pfd, 1, deadline_remaining_ms(&deadline));
@@ -148,13 +208,13 @@ bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
     if (pfd.revents & (POLLERR | POLLNVAL))
       return false;
     ssize_t bytes_send;
-    if (io_ssl)
-      bytes_send = SSL_write(io_ssl, (const char*)data + total_bytes_send, chunk);
+    if (session->ssl)
+      bytes_send = SSL_write(session->ssl, (const char*)data + total_bytes_send, chunk);
     else
       bytes_send = write(fd, (const char*)data + total_bytes_send, chunk);
     if (bytes_send <= 0) {
-      if (io_ssl) {
-        int ssl_err = SSL_get_error(io_ssl, (int)bytes_send);
+      if (session->ssl) {
+        int ssl_err = SSL_get_error(session->ssl, (int)bytes_send);
         if (ssl_err == SSL_ERROR_WANT_WRITE || ssl_err == SSL_ERROR_WANT_READ) {
           wait_events = ssl_err == SSL_ERROR_WANT_WRITE ? POLLOUT : POLLIN;
           continue;
@@ -163,18 +223,20 @@ bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
       log_message(LOG_LEVEL_ERROR, "Could not send data");
       return false;
     }
-    bw_throttle((size_t)bytes_send);
+    bw_throttle_session(session, (size_t)bytes_send);
     total_bytes_send += bytes_send;
-    if (io_ssl)
+    if (session->ssl)
       wait_events = POLLOUT;
   }
   log_message(LOG_LEVEL_DEBUG, "    Send n Data: %zu", total_bytes_send);
   return true;
 }
 
-bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
+bool protocol_receive_n_data(ProtocolSession* session, void* data, size_t data_size) {
   log_message(LOG_LEVEL_DEBUG, "    Receiving n Data: %zu", data_size);
-  int fd = io_fd(io_read_fd, file_descriptor);
+  if (!session)
+    return false;
+  int fd = session->read_fd;
 
   struct timespec deadline;
   clock_gettime(CLOCK_MONOTONIC, &deadline);
@@ -183,7 +245,7 @@ bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
   size_t total_bytes_received = 0;
   short wait_events = POLLIN;
   while (total_bytes_received < data_size) {
-    if (!io_ssl || SSL_pending(io_ssl) == 0) {
+    if (!session->ssl || SSL_pending(session->ssl) == 0) {
       struct pollfd pfd = {.fd = fd, .events = wait_events};
       int poll_result = poll(&pfd, 1, deadline_remaining_ms(&deadline));
       if (poll_result == 0) {
@@ -201,15 +263,15 @@ bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
     }
 
     ssize_t bytes_received;
-    if (io_ssl)
-      bytes_received =
-          SSL_read(io_ssl, (char*)data + total_bytes_received, data_size - total_bytes_received);
+    if (session->ssl)
+      bytes_received = SSL_read(session->ssl, (char*)data + total_bytes_received,
+                                data_size - total_bytes_received);
     else
       bytes_received =
           read(fd, (char*)data + total_bytes_received, data_size - total_bytes_received);
     if (bytes_received <= 0) {
-      if (io_ssl) {
-        int ssl_err = SSL_get_error(io_ssl, (int)bytes_received);
+      if (session->ssl) {
+        int ssl_err = SSL_get_error(session->ssl, (int)bytes_received);
         if (ssl_err == SSL_ERROR_WANT_WRITE || ssl_err == SSL_ERROR_WANT_READ) {
           wait_events = ssl_err == SSL_ERROR_WANT_WRITE ? POLLOUT : POLLIN;
           continue;
@@ -222,7 +284,7 @@ bool receive_n_data(int file_descriptor, void* data, size_t data_size) {
       return false;
     }
     total_bytes_received += (size_t)bytes_received;
-    if (io_ssl)
+    if (session->ssl)
       wait_events = POLLIN;
   }
   log_message(LOG_LEVEL_DEBUG, "    Received n Data: %zu", total_bytes_received);
@@ -258,23 +320,24 @@ static const char* status_to_string(Status status) {
   }
 }
 
-bool send_str(int file_descriptor, const char* data) {
+bool protocol_send_str(ProtocolSession* session, const char* data) {
   if (data == NULL)
     return false;
   size_t size = strlen(data);
-  if (!send_n_data(file_descriptor, &size, sizeof(size_t)))
+  if (!protocol_send_n_data(session, &size, sizeof(size_t)))
     return false;
-  if (!send_n_data(file_descriptor, data, size))
+  if (!protocol_send_n_data(session, data, size))
     return false;
   log_message(LOG_LEVEL_DEBUG, "Send String: %s", data);
   return true;
 }
 
-char* receive_str(int file_descriptor) {
+char* protocol_receive_str(ProtocolSession* session) {
   size_t size;
-  if (!receive_n_data(file_descriptor, &size, sizeof(size_t)))
+  if (!protocol_receive_n_data(session, &size, sizeof(size_t)))
     return NULL;
-  if (size > MAX_STRING_SIZE || size > SIZE_MAX - 1) {
+  if (size > MAX_STRING_SIZE || size > SIZE_MAX - 1 ||
+      size + 1 > MAX_CONNECTION_MEMORY - session->total_allocated_bytes) {
     log_message(LOG_LEVEL_ERROR, "String size %zu exceeds maximum %llu", size,
                 (unsigned long long)MAX_STRING_SIZE);
     return NULL;
@@ -282,7 +345,7 @@ char* receive_str(int file_descriptor) {
   char* data = (char*)malloc(size + 1);
   if (data == NULL)
     return NULL;
-  if (!receive_n_data(file_descriptor, data, size)) {
+  if (!protocol_receive_n_data(session, data, size)) {
     free(data);
     return NULL;
   }
@@ -292,25 +355,30 @@ char* receive_str(int file_descriptor) {
     return NULL;
   }
   data[size] = '\0';
+  session->total_allocated_bytes += size + 1;
   log_message(LOG_LEVEL_DEBUG, "Received String: %s", data);
   return data;
 }
 
-bool send_data(int file_descriptor, const Data* data) {
+bool protocol_send_data(ProtocolSession* session, const Data* data) {
   if (!data || (!data->data && data->size != 0))
     return false;
-  unsigned long long data_size = data->size;
-  if (!send_n_data(file_descriptor, &data_size, sizeof(unsigned long long)))
+  if (!session)
     return false;
-  if (!send_n_data(file_descriptor, data->data, data_size))
+  unsigned long long data_size = data->size;
+  if (!protocol_send_n_data(session, &data_size, sizeof(unsigned long long)))
+    return false;
+  if (!protocol_send_n_data(session, data->data, data_size))
     return false;
   log_message(LOG_LEVEL_DEBUG, "Send %lld data", data_size);
   return true;
 }
 
-Data* receive_data_limited(int file_descriptor, unsigned long long maximum_size) {
+Data* protocol_receive_data_limited(ProtocolSession* session, unsigned long long maximum_size) {
+  if (!session)
+    return NULL;
   unsigned long long size = 0;
-  if (!receive_n_data(file_descriptor, &size, sizeof(unsigned long long)))
+  if (!protocol_receive_n_data(session, &size, sizeof(unsigned long long)))
     return NULL;
   if (size > MAX_DATA_PAYLOAD_SIZE || size > maximum_size) {
     log_message(LOG_LEVEL_ERROR, "Data size %llu exceeds maximum %llu", size,
@@ -318,56 +386,86 @@ Data* receive_data_limited(int file_descriptor, unsigned long long maximum_size)
     return NULL;
   }
   size_t allocation_size = size == 0 ? 1 : (size_t)size;
-  if (allocation_size > MAX_CONNECTION_MEMORY - total_allocated_bytes) {
-    log_message(LOG_LEVEL_ERROR, "Per-connection memory limit exceeded");
+  if (allocation_size > MAX_CONNECTION_MEMORY - session->total_allocated_bytes) {
+    log_message(LOG_LEVEL_ERROR, "Per-connection memory limit exceeded (%llu + %llu > %llu)",
+                (unsigned long long)session->total_allocated_bytes, size,
+                (unsigned long long)MAX_CONNECTION_MEMORY);
     return NULL;
   }
   void* data = malloc(allocation_size);
   if (data == NULL)
     return NULL;
-  if (!receive_n_data(file_descriptor, data, (size_t)size)) {
+  if (!protocol_receive_n_data(session, data, (size_t)size)) {
     free(data);
     return NULL;
   }
+  session->total_allocated_bytes += allocation_size;
   log_message(LOG_LEVEL_DEBUG, "Received %lld data", size);
   Data* result = data_create(data, (size_t)size);
   if (!result) {
-    free(data);
+    session->total_allocated_bytes -= allocation_size;
     return NULL;
   }
-  total_allocated_bytes += allocation_size;
   result->protocol_charge = allocation_size;
   return result;
 }
 
-Data* receive_data(int file_descriptor) {
-  return receive_data_limited(file_descriptor, MAX_DATA_PAYLOAD_SIZE);
+Data* protocol_receive_data(ProtocolSession* session) {
+  return protocol_receive_data_limited(session, MAX_DATA_PAYLOAD_SIZE);
 }
 
-bool send_int(int file_descriptor, int data) {
-  if (!send_n_data(file_descriptor, &data, sizeof(int)))
+bool protocol_send_int(ProtocolSession* session, int data) {
+  if (!protocol_send_n_data(session, &data, sizeof(int)))
     return false;
   log_message(LOG_LEVEL_DEBUG, "Send Int: %d", data);
   return true;
 }
 
-bool receive_int(int file_descriptor, int* data) {
-  if (!receive_n_data(file_descriptor, data, sizeof(int)))
+bool protocol_receive_int(ProtocolSession* session, int* data) {
+  if (!protocol_receive_n_data(session, data, sizeof(int)))
     return false;
   log_message(LOG_LEVEL_DEBUG, "Received Int: %d", *data);
   return true;
 }
 
-bool send_status(int file_descriptor, Status status) {
-  if (!send_n_data(file_descriptor, &status, sizeof(Status)))
+bool protocol_send_status(ProtocolSession* session, Status status) {
+  if (!protocol_send_n_data(session, &status, sizeof(Status)))
     return false;
   log_message(LOG_LEVEL_DEBUG, "Send Status: %s", status_to_string(status));
   return true;
 }
 
-bool receive_status(int file_descriptor, Status* status) {
-  if (!receive_n_data(file_descriptor, status, sizeof(Status)))
+bool protocol_receive_status(ProtocolSession* session, Status* status) {
+  if (!protocol_receive_n_data(session, status, sizeof(Status)))
     return false;
   log_message(LOG_LEVEL_DEBUG, "Received Status: %s", status_to_string(*status));
   return true;
 }
+
+bool send_str(int fd, const char* data) {
+  return protocol_send_str(legacy_session(-1, fd), data);
+}
+char* receive_str(int fd) {
+  return protocol_receive_str(legacy_session(fd, -1));
+}
+bool send_data(int fd, const Data* data) {
+  return protocol_send_data(legacy_session(-1, fd), data);
+}
+Data* receive_data(int fd) {
+  return protocol_receive_data_limited(legacy_session(fd, -1), MAX_DATA_PAYLOAD_SIZE);
+}
+Data* receive_data_limited(int fd, unsigned long long maximum_size) {
+  return protocol_receive_data_limited(legacy_session(fd, -1), maximum_size);
+}
+bool send_int(int fd, int data) {
+  return protocol_send_int(legacy_session(-1, fd), data);
+}
+bool receive_int(int fd, int* data) {
+  return protocol_receive_int(legacy_session(fd, -1), data);
+}
+bool send_status(int fd, Status status) {
+  return protocol_send_status(legacy_session(-1, fd), status);
+}
+bool receive_status(int fd, Status* status) {
+  return protocol_receive_status(legacy_session(fd, -1), status);
+}

src/shared/protocol.h

@@ -21,6 +21,23 @@
 
 typedef struct ssl_st SSL;
 
+/*
+ * Explicit owner of protocol I/O.  A session does not own the descriptors or
+ * SSL object; it only describes the transport used by a transfer.  This makes
+ * it safe to pass the transport to a worker without relying on inherited
+ * thread-local state.
+ */
+typedef struct ProtocolSession {
+  int read_fd;
+  int write_fd;
+  SSL* ssl;
+  unsigned long long bwlimit;
+  long long bw_tokens;
+  long long bw_last_refill_sec;
+  long bw_last_refill_nsec;
+  unsigned long long total_allocated_bytes;
+} ProtocolSession;
+
 typedef int Status;
 enum NET_STATUS {
   STATUS_OK,
@@ -41,6 +58,24 @@ void io_set_fds(int read_fd, int write_fd);
 void io_set_bwlimit(unsigned long long bytes_per_sec);
 void io_set_ssl(SSL* ssl);
 SSL* io_get_ssl(void);
+
+void protocol_session_init(ProtocolSession* session, int read_fd, int write_fd);
+/* Transitional bridge for helpers whose signatures still carry only an fd. */
+void protocol_session_bind(ProtocolSession* session);
+void protocol_session_unbind(void);
+void protocol_session_set_ssl(ProtocolSession* session, SSL* ssl);
+void protocol_session_set_bwlimit(ProtocolSession* session, unsigned long long bytes_per_sec);
+bool protocol_send_n_data(ProtocolSession* session, const void* data, size_t data_size);
+bool protocol_receive_n_data(ProtocolSession* session, void* data, size_t data_size);
+bool protocol_send_str(ProtocolSession* session, const char* data);
+char* protocol_receive_str(ProtocolSession* session);
+bool protocol_send_data(ProtocolSession* session, const Data* data);
+Data* protocol_receive_data(ProtocolSession* session);
+Data* protocol_receive_data_limited(ProtocolSession* session, unsigned long long maximum_size);
+bool protocol_send_int(ProtocolSession* session, int data);
+bool protocol_receive_int(ProtocolSession* session, int* data);
+bool protocol_send_status(ProtocolSession* session, Status status);
+bool protocol_receive_status(ProtocolSession* session, Status* status);
 bool send_n_data(int file_descriptor, const void* data, size_t data_size);
 bool receive_n_data(int file_descriptor, void* data, size_t data_size);
 

src/shared/transport_tcp.c

@@ -151,6 +151,10 @@ int tcp_get_contimeout_sec(void) {
   return g_contimeout_sec;
 }
 
+int tcp_get_timeout_sec(void) {
+  return g_timeout_sec;
+}
+
 static void tcp_apply_socket_timeout(int fd) {
   struct timeval tv;
   tv.tv_sec = g_timeout_sec;
@@ -173,7 +177,7 @@ Client* client_create() {
   return client;
 }
 
-bool client_connect(Client* client, char* host, int port) {
+bool tcp_connect_socket(Client* client, char* host, int port) {
   struct addrinfo hints;
   struct addrinfo* result;
   memset(&hints, 0, sizeof(hints));
@@ -222,6 +226,12 @@ bool client_connect(Client* client, char* host, int port) {
     return false;
   }
 
+  return true;
+}
+
+bool client_connect(Client* client, char* host, int port) {
+  if (!tcp_connect_socket(client, host, port))
+    return false;
   tcp_apply_socket_timeout(client->file_descriptor);
   return true;
 }

src/shared/transport_tcp.h

@@ -30,9 +30,11 @@ void server_accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
 void server_delete(Server** server);
 Client* client_create();
 bool client_connect(Client* client, char* host, int port);
+bool tcp_connect_socket(Client* client, char* host, int port);
 void client_disconnect(Client* client);
 void client_delete(Client* client);
 void tcp_set_timeouts(int timeout_sec, int contimeout_sec);
 int tcp_get_contimeout_sec(void);
+int tcp_get_timeout_sec(void);
 
 #endif

src/shared/transport_tls.c

@@ -3,7 +3,6 @@
 #include "protocol.h"
 #include "transport_tcp.h"
 #include <arpa/inet.h>
-#include <netdb.h>
 #include <openssl/err.h>
 #include <openssl/ssl.h>
 #include <signal.h>
@@ -13,6 +12,7 @@
 #include <sys/socket.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
+#include <time.h>
 #include <unistd.h>
 
 bool tls_global_init(void) {
@@ -120,6 +120,7 @@ static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server, const char* h
   }
 
   // Retry SSL_accept/SSL_connect on WANT_READ/WANT_WRITE (non-blocking handshake)
+  time_t deadline = time(NULL) + (is_server ? tcp_get_timeout_sec() : tcp_get_contimeout_sec());
   int ret;
   do {
     if (is_server)
@@ -129,7 +130,8 @@ static SSL* wrap_fd_with_ssl(int fd, SSL_CTX* ctx, bool is_server, const char* h
 
     if (ret <= 0) {
       int ssl_err = SSL_get_error(ssl, ret);
-      if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE)
+      if ((ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE) &&
+          time(NULL) < deadline)
         continue;
       log_message(LOG_LEVEL_ERROR, "SSL %s failed", is_server ? "accept" : "connect");
       log_ssl_errors();
@@ -176,55 +178,7 @@ bool server_listen_tls(Server* server, void (*handler)(int file_descriptor)) {
 
 bool client_connect_tls(Client* client, char* host, int port, const char* cert_path,
                         const char* key_path, const char* ca_path) {
-  struct addrinfo hints;
-  struct addrinfo* result;
-  memset(&hints, 0, sizeof(hints));
-  hints.ai_family = AF_UNSPEC;
-  hints.ai_socktype = SOCK_STREAM;
-  hints.ai_protocol = IPPROTO_TCP;
-
-  char port_str[16];
-  snprintf(port_str, sizeof(port_str), "%d", port);
-
-  int err = getaddrinfo(host, port_str, &hints, &result);
-  if (err != 0 || result == NULL) {
-    fprintf(stderr, "Could not resolve host: %s (%s)\n", host, gai_strerror(err));
-    if (client->file_descriptor >= 0) {
-      close(client->file_descriptor);
-      client->file_descriptor = -1;
-    }
-    return false;
-  }
-
-  struct addrinfo* rp;
-  bool connected = false;
-  for (rp = result; rp != NULL; rp = rp->ai_next) {
-    if (client->file_descriptor >= 0)
-      close(client->file_descriptor);
-
-    client->file_descriptor = socket(rp->ai_family, rp->ai_socktype, rp->ai_protocol);
-    if (client->file_descriptor < 0)
-      continue;
-
-    struct timeval ct;
-    ct.tv_sec = tcp_get_contimeout_sec();
-    ct.tv_usec = 0;
-    setsockopt(client->file_descriptor, SOL_SOCKET, SO_RCVTIMEO, &ct, sizeof(ct));
-    setsockopt(client->file_descriptor, SOL_SOCKET, SO_SNDTIMEO, &ct, sizeof(ct));
-
-    memcpy(&client->address, rp->ai_addr, rp->ai_addrlen);
-    client->address_length = rp->ai_addrlen;
-
-    if (connect(client->file_descriptor, (struct sockaddr*)&client->address,
-                client->address_length) == 0) {
-      connected = true;
-      break;
-    }
-  }
-  freeaddrinfo(result);
-
-  if (!connected) {
-    perror("Could not connect to Server!");
+  if (!tcp_connect_socket(client, host, port)) {
     if (client->file_descriptor >= 0)
       close(client->file_descriptor);
     client->file_descriptor = -1;

src/shared/utils.c

@@ -329,6 +329,10 @@ bool has_path_traversal(const char* path) {
   return false;
 }
 
+bool utils_valid_batch_path(const char* path) {
+  return path && path[0] != '\0' && path[0] != '/' && !has_path_traversal(path);
+}
+
 char* path_cat(const char* path1, const char* path2) {
   if (path1 == NULL || *path1 == '\0')
     return str_dup(path2);

src/shared/utils.h

@@ -16,5 +16,6 @@ bool utils_set_authorized_root(int fd, const char* canonical_path);
  * callers should use utils_set_authorized_root with the canonical identity. */
 void utils_set_authorized_root_fd(int fd);
 bool has_path_traversal(const char* path);
+bool utils_valid_batch_path(const char* path);
 
 #endif