fix: complete triage security and transfer remediation

src/shared/file.c

@@ -2,6 +2,7 @@
 #include <errno.h>
 #include <fcntl.h>
 #include <libgen.h>
+#include <limits.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
@@ -175,6 +176,17 @@ bool file_save_to_disk(const char* root_directory, File* file, const Config* con
     return false;
   }
 
+  /* --update is receiver-side policy: never replace a newer destination. */
+  if (config && config->update) {
+    struct stat destination_stat;
+    if (stat(disk_path, &destination_stat) == 0 && file->metadata &&
+        destination_stat.st_mtime > file->metadata->mtime_sec) {
+      free(resolved_root);
+      free(disk_path);
+      return true;
+    }
+  }
+
   if (backup_enabled) {
     struct stat backup_stat;
     if (stat(disk_path, &backup_stat) == 0) {
@@ -546,8 +558,108 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
   return file;
 }
 
+static int 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 = (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 && strcmp(component, "..") != 0) {
+      int next = openat(fd, component, O_RDONLY | O_DIRECTORY | O_NOFOLLOW | O_CLOEXEC);
+      if (next < 0 && errno == ENOENT && mkdirat(fd, component, 0755) == 0)
+        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;
+}
+
+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;
+}
+
+static bool to_disk_secure(const char* path, const void* data, unsigned long long data_size,
+                           bool inplace, bool sparse) {
+  char* leaf = NULL;
+  int dirfd = 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);
+    }
+  } else {
+    char tmp[NAME_MAX];
+    for (unsigned int i = 0; i < 100 && !ok; ++i) {
+      snprintf(tmp, sizeof(tmp), ".%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 (close(fd) != 0)
+        ok = false;
+      fd = -1;
+      if (ok && renameat(dirfd, tmp, dirfd, leaf) != 0)
+        ok = false;
+      if (!ok)
+        unlinkat(dirfd, tmp, 0);
+    }
+  }
+  if (fd >= 0)
+    close(fd);
+  close(dirfd);
+  free(leaf);
+  return ok;
+}
+
 bool to_disk(const char* path, const void* data, unsigned long long data_size, bool inplace,
              bool sparse) {
+  if (!path || (!data && data_size != 0) || has_path_traversal(path))
+    return false;
+  return to_disk_secure(path, data, data_size, inplace, sparse);
+  /* Kept below only as historical context; all writes use descriptor-relative operations. */
   char* tmp_path = NULL;
   char* directory = NULL;
 

src/shared/queue.h

@@ -1,30 +1,30 @@
-#ifndef QUEUE_H
-#define QUEUE_H
-
-#include <stdbool.h>
-#include <threads.h>
-
-typedef struct Queue {
-  void** items;
-  int front;
-  int rear;
-  int size;
-  int capacity;
-  void (*item_destroyer)(void* item);
-} Queue;
-
-Queue* queue_create(int capacity, void (*destroyer)(void* item));
-void queue_destroy(Queue* queue);
-bool queue_is_empty(const Queue* queue);
-bool queue_is_full(const Queue* queue);
-bool queue_enqueue(Queue* queue, void* item);
-bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
-                                 cnd_t* condition_not_full);
+#ifndef QUEUE_H
+#define QUEUE_H
+
+#include <stdbool.h>
+#include <threads.h>
+
+typedef struct Queue {
+  void** items;
+  int front;
+  int rear;
+  int size;
+  int capacity;
+  void (*item_destroyer)(void* item);
+} Queue;
+
+Queue* queue_create(int capacity, void (*destroyer)(void* item));
+void queue_destroy(Queue* queue);
+bool queue_is_empty(const Queue* queue);
+bool queue_is_full(const Queue* queue);
+bool queue_enqueue(Queue* queue, void* item);
+bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t* condition_not_empty,
+                                 cnd_t* condition_not_full);
 bool queue_enqueue_multithreaded_cancel(Queue* queue, void* item, mtx_t* mutex,
                                         cnd_t* condition_not_empty, cnd_t* condition_not_full,
                                         const bool* cancelled);
-void* queue_dequeue(Queue* queue);
-void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
-                                  cnd_t* condition_not_full, const bool* other_thread_done);
-
-#endif
+void* queue_dequeue(Queue* queue);
+void* queue_dequeue_multithreaded(Queue* queue, mtx_t* mutex, cnd_t* condition_not_empty,
+                                  cnd_t* condition_not_full, const bool* other_thread_done);
+
+#endif

src/shared/transport_tcp.c

@@ -15,6 +15,8 @@
 
 static volatile sig_atomic_t g_active_connections = 0;
 
+static void tcp_apply_socket_timeout(int fd);
+
 static void sigchld_handler(int sig) {
   (void)sig;
   int saved_errno = errno;
@@ -93,6 +95,7 @@ static void accept_loop(Server* server, void (*child_fn)(int, void*), void* chil
       perror("Could not accept the connection");
       continue;
     }
+    tcp_apply_socket_timeout(fd);
     if ((unsigned int)g_active_connections >= server->max_connections) {
       log_message(LOG_LEVEL_WARNING, "Max connections (%u) reached, rejecting",
                   server->max_connections);

src/shared/transport_tls.c

@@ -71,7 +71,7 @@ static SSL_CTX* create_ssl_ctx(bool is_server, const char* cert, const char* key
       SSL_CTX_free(ctx);
       return NULL;
     }
-    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, NULL);
+    SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER | SSL_VERIFY_FAIL_IF_NO_PEER_CERT, NULL);
     SSL_CTX_set_verify_depth(ctx, 4);
   } else {
     SSL_CTX_set_verify(ctx, SSL_VERIFY_NONE, NULL);