style: format config validation

fix: complete triage security and transfer remediation
style: format protocol deadline calculation
2026-08-08 20:35:46 +02:00 · 2026-08-08 20:35:29 +02:00 · 2026-08-08 20:27:44 +02:00 · 2026-08-08 20:27:26 +02:00 · 2026-08-08 20:25:58 +02:00 · 2026-08-02 09:20:37 +02:00
28 changed files with 809 additions and 79 deletions
@@ -2,7 +2,7 @@ name: CI

 on:
  push:
-    branches: [main]
+    branches: [main, dev]
  pull_request:

 jobs:
@@ -73,6 +73,13 @@ jobs:
      - name: Build fuzz targets
        run: cmake --build build-fuzz -j$(nproc)

+      - name: Smoke fuzz targets
+        run: |
+          for target in build-fuzz/fuzz_*; do
+            [ -x "$target" ] || continue
+            timeout 10s "$target" -runs=100 -max_total_time=5
+          done
+
  coverage:
    runs-on: ubuntu-latest
    container: gitea.tap-tap.win/taptap/fastsync-ci:v9
@@ -73,7 +73,7 @@ A high-performance file synchronization system with SSH and TCP transport, TLS e
 | `STATUS_NEXT` | Ready for next file (per-file mode) |
 | `STATUS_CHUNK` | Following data is a serialized chunk |
 | `STATUS_MANIFEST` | Following data is a file manifest (for `--delete`) |
-| `STATUS_CHECK` | Incremental check: client sends file path + size + mtime, server responds with OK (skip) or NEXT (send) |
+| `STATUS_CHECK` | Incremental check: client sends file path + size + mtime and, when negotiated, checksum; server responds with OK (skip) or NEXT (send) |
 | `STATUS_CHECK_BATCH` | Batch incremental check: multiple file checks sent in one message |
 | `STATUS_KEEPALIVE` | Keep-alive heartbeat to detect stalled connections |
 | `STATUS_ABORT` | Abort signal: client interrupts, server cleans up and exits |
@@ -95,7 +95,9 @@ Abort (`STATUS_ABORT`) may be sent at any point. On receipt the server cleans up

 ### Protocol Version

-`1.3.0` — server and client must match. Mismatch results in `STATUS_ERROR`.
+`2.2.0` — server and client must match. This version adds a 64-bit XXH64 checksum to checksum-enabled `STATUS_CHECK` messages and validates the negotiated compression choice (`zstd` or `none`). Older clients and servers must not be mixed with this version; mismatch results in `STATUS_ERROR`.
+
+Config negotiation is sender-driven: the client serializes transfer options and the server applies them while receiving and writing files. `--checksum` compares size and content checksum instead of timestamps. `--compress-choice zstd` enables zstd; `none` disables it. Unsupported choices are rejected during config exchange.

 ## Command-Line Arguments

@@ -186,7 +188,7 @@ Abort (`STATUS_ABORT`) may be sent at any point. On receipt the server cleans up
 2. **Chunking** — files accumulated until `chunk_size` threshold, then flushed
 3. **Compression** — streaming zstd via `ZSTD_compressStream2` / `ZSTD_decompressStream`
 4. **Network protocol** — status-code-driven exchange with metadata packing, keep-alive, and abort support
-5. **Incremental check** — client sends `STATUS_CHECK` + path + size + mtime; server compares against destination. Can be batched via `STATUS_CHECK_BATCH` for reduced round-trips.
+5. **Incremental check** — client sends `STATUS_CHECK` + path + size + mtime and, with `--checksum`, XXH64 content checksum; server compares against destination. Can be batched via `STATUS_CHECK_BATCH` for reduced round-trips.
 6. **Bandwidth limiting** — token-bucket algorithm with `nanosleep` throttling on 64 KB write chunks
 7. **Metadata restoration** — `chmod()`, `chown()`, `utimensat()` on the receiving side
 8. **`--delete`** — sender tracks all sent paths; receiver walks destination tree and removes unlisted files/directories
@@ -0,0 +1,274 @@
+# Rsync Feature Compatibility
+
+This document maps rsync's full feature set to FastSync's current implementation status.
+
+## Summary
+
+| Status | Count | Description |
+|--------|-------|-------------|
+| ✅ Implemented | 39 | Feature works end-to-end |
+| 🔀 Alt Arg | 5 | Functionality exists but under different flag/semantics |
+| ⚠️ Partial | 30 | Flag parsed/stored but behavior incomplete |
+| ❌ Not Implemented | 62 | Flag not recognized or no behavior |
+| **Total** | **136** | |
+
+---
+
+## 1. General Options
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-a`, `--archive` | Archive mode is -rlptgoD | 🔀 Alt Arg | Maps to -c -m -M (compression + multithread + metadata) |
+| `-v`, `--verbose` | Increase verbosity | ✅ Implemented | Sets `log_level=DEBUG` |
+| `-q`, `--quiet` | Suppress non-error messages | ✅ Implemented | `quiet` config field |
+| `-h`, `--help` | Show help | ✅ Implemented | Prints usage and exits |
+| `-V`, `--version` | Print version | ❌ Not Implemented | |
+| `--info=FLAGS` | Fine-grained info verbosity | ⚠️ Partial | `info_level` stored, not wired |
+| `--debug=FLAGS` | Fine-grained debug verbosity | ⚠️ Partial | `debug_level` stored, not wired |
+| `--stderr=MODE` | Change stderr output mode | ❌ Not Implemented | |
+| `--no-motd` | Suppress daemon MOTD | ❌ Not Implemented | |
+| `--exclude=PATTERN` | Exclude files matching pattern | ✅ Implemented | Glob matching in scanner |
+| `--include=PATTERN` | Include files matching pattern | ✅ Implemented | Glob matching in scanner |
+| `-C`, `--cvs-exclude` | Auto-ignore CVS files | ⚠️ Partial | `cvs_exclude` stored, not wired |
+
+## 2. Modifying Output
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `--stats` | Give transfer stats | ✅ Implemented | Prints file/byte counts |
+| `-h`, `--human-readable` | Human-readable numbers | ⚠️ Partial | `human_readable` stored, not wired |
+| `-i`, `--itemize-changes` | Per-file change summary | ⚠️ Partial | `itemize_changes` stored, not wired |
+| `--progress` | Show progress | ✅ Implemented | Progress callback in sender |
+| `-P` | Same as --partial --progress | ❌ Not Implemented | |
+| `--out-format=FORMAT` | Custom output format | ⚠️ Partial | `out_format` stored, not wired |
+| `--log-file=FILE` | Log to file | ✅ Implemented | `log_file` config field |
+| `--log-file-format=FMT` | Log format | ❌ Not Implemented | |
+| `--8-bit-output` | Leave high-bit chars unescaped | ❌ Not Implemented | |
+| `--list-only` | List files instead of copying | ⚠️ Partial | `list_only` stored, not wired |
+
+## 3. File Selection
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `--exclude-from=FILE` | Read exclude patterns from file | ✅ Implemented | Reads patterns from file |
+| `--include-from=FILE` | Read include patterns from file | ✅ Implemented | Reads patterns from file |
+| `--filter=RULE` | Add file-filtering rule | ⚠️ Partial | `filters` ArrayList stored, not wired |
+| `--files-from=FILE` | Read source file list from file | ⚠️ Partial | `files_from` stored, not wired |
+| `-0`, `--from0` | Delimit *-from files with NULs | ❌ Not Implemented | |
+| `--max-size=SIZE` | Skip files larger than SIZE | ✅ Implemented | `max_size` in scanner |
+| `--min-size=SIZE` | Skip files smaller than SIZE | ✅ Implemented | `min_size` in scanner |
+| `-I`, `--ignore-times` | Don't skip files matching size+time | ❌ Not Implemented | |
+| `--size-only` | Skip based on size only | ❌ Not Implemented | |
+| `-@`, `--modify-window=NUM` | Mod-time comparison accuracy | ❌ Not Implemented | |
+| `--existing` | Skip creating new files on receiver | ❌ Not Implemented | |
+| `--ignore-existing` | Skip updating existing files | ❌ Not Implemented | |
+| `--remove-source-files` | Sender removes synced files | ❌ Not Implemented | |
+
+## 4. Directory Options
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-r`, `--recursive` | Recurse into directories | ✅ Implemented | Default behavior |
+| `-R`, `--relative` | Use relative path names | ⚠️ Partial | `relative` stored, not wired |
+| `--no-implied-dirs` | Don't send implied dirs with -R | ❌ Not Implemented | |
+| `-d`, `--dirs` | Transfer dirs without recursing | ❌ Not Implemented | |
+| `--mkpath` | Create missing path components | ❌ Not Implemented | |
+
+## 5. Transfer Modifications
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-u`, `--update` | Skip files newer on receiver | ⚠️ Partial | `update` stored, not wired |
+| `--inplace` | Update files in-place | ✅ Implemented | Direct write mode |
+| `--append` | Append data to shorter files | ⚠️ Partial | `append` stored, not wired |
+| `--append-verify` | Append with old-data checksum | ⚠️ Partial | `append_verify` stored, not wired |
+| `-W`, `--whole-file` | Copy whole file (no delta) | ❌ Not Implemented | |
+| `--block-size=SIZE` | Force checksum block-size | ⚠️ Partial | Parsed as `--delta-block`; controls delta transfer block size |
+
+## 6. Destination Handling
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-n`, `--dry-run` | Trial run with no changes | ✅ Implemented | `dry_run` config field |
+| `-b`, `--backup` | Make backups of overwritten files | ✅ Implemented | Backup before overwrite |
+| `--backup-dir=DIR` | Backup directory hierarchy | ✅ Implemented | `backup_dir` config field |
+| `--suffix=SUFFIX` | Backup suffix (default ~) | ✅ Implemented | `suffix` config field |
+| `--delay-updates` | Put updated files in place at end | ❌ Not Implemented | |
+
+## 7. Deletion
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `--delete` | Delete extraneous files from dest | ✅ Implemented | `use_delete` config field |
+| `--delete-before` | Delete before transfer | ⚠️ Partial | `delete_before` stored, not wired |
+| `--delete-during` | Delete during transfer | ❌ Not Implemented | |
+| `--delete-delay` | Find deletions during, delete after | ❌ Not Implemented | |
+| `--delete-after` | Delete after transfer | ⚠️ Partial | `delete_after` stored, not wired |
+| `--delete-excluded` | Also delete excluded files | ⚠️ Partial | `delete_excluded` stored, not wired |
+| `--max-delete=NUM` | Max files to delete | ⚠️ Partial | `max_delete` stored, not wired |
+| `--ignore-errors` | Delete even with I/O errors | ❌ Not Implemented | |
+| `--force` | Force deletion of non-empty dirs | ❌ Not Implemented | |
+| `--prune-empty-dirs` | Prune empty dir chains | ⚠️ Partial | `prune_empty_dirs` stored, not wired |
+
+## 8. Metadata Preservation
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-M`, `--preserve` | Preserve file metadata | ✅ Implemented | Mode, uid, gid, mtime |
+| `-p`, `--perms` | Preserve permissions | 🔀 Alt Arg | `-p` means SSH port; permissions preserved via `-M`/`--preserve` |
+| `-o`, `--owner` | Preserve owner | ✅ Implemented | Part of -M |
+| `-g`, `--group` | Preserve group | ✅ Implemented | Part of -M |
+| `-t`, `--times` | Preserve modification times | ✅ Implemented | Part of -M |
+| `-E`, `--executability` | Preserve executability | ❌ Not Implemented | |
+| `--chmod=CHMOD` | Affect file permissions | ❌ Not Implemented | |
+| `-A`, `--acls` | Preserve ACLs | ⚠️ Partial | `preserve_acls` stored, not wired |
+| `-X`, `--xattrs` | Preserve extended attributes | ⚠️ Partial | `preserve_xattrs` stored, not wired |
+| `-H`, `--hard-links` | Preserve hard links | ⚠️ Partial | `preserve_hard_links` stored, not wired |
+| `-D` | Same as --devices --specials | 🔀 Alt Arg | Maps to --devices only (no --specials) |
+| `--devices` | Preserve device files | ⚠️ Partial | `preserve_devices` stored, not wired |
+| `--specials` | Preserve special files | ❌ Not Implemented | |
+| `--copy-devices` | Copy device contents as file | ❌ Not Implemented | |
+| `--write-devices` | Write to devices as files | ❌ Not Implemented | |
+| `-U`, `--atimes` | Preserve access times | ❌ Not Implemented | |
+| `-N`, `--crtimes` | Preserve create times | ❌ Not Implemented | |
+| `-O`, `--omit-dir-times` | Omit dirs from --times | ❌ Not Implemented | |
+| `-J`, `--omit-link-times` | Omit symlinks from --times | ❌ Not Implemented | |
+| `--super` | Receiver attempts super-user activities | ❌ Not Implemented | |
+| `--fake-super` | Store/recover privileged attrs via xattrs | ❌ Not Implemented | |
+
+## 9. Symlink Handling
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-l`, `--links` | Copy symlinks as symlinks | ⚠️ Partial | Scanner includes symlinks; target path not transmitted |
+| `-L`, `--copy-links` | Transform symlink to referent | ✅ Implemented | `copy_links` config field |
+| `--copy-unsafe-links` | Transform unsafe symlinks | ✅ Implemented | `copy_unsafe_links` config field |
+| `--safe-links` | Ignore symlinks outside tree | ✅ Implemented | `safe_links` config field |
+| `--munge-links` | Munge symlinks for safety | ❌ Not Implemented | |
+| `-k`, `--copy-dirlinks` | Transform symlink to dir | ❌ Not Implemented | |
+| `-K`, `--keep-dirlinks` | Treat symlinked dir as dir | ❌ Not Implemented | |
+
+## 10. Sparse & Device
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-S`, `--sparse` | Sparse block handling | ✅ Implemented | `preserve_sparse` config field |
+| `--preallocate` | Allocate dest files before writing | ❌ Not Implemented | |
+
+## 11. Checksum & Comparison
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-c`, `--checksum` | Skip based on checksum | 🔀 Alt Arg | `-c` means compression; `--checksum` stored and forwarded to scanner |
+| `--checksum-choice=STR` | Choose checksum algorithm | ❌ Not Implemented | xxHash used internally |
+| `--compare-dest=DIR` | Compare dest files relative to DIR | ⚠️ Partial | `compare_dest` stored, not wired |
+| `--copy-dest=DIR` | Include copies of unchanged files | ⚠️ Partial | `copy_dest` stored, not wired |
+| `--link-dest=DIR` | Hardlink to files when unchanged | ⚠️ Partial | `link_dest` stored, not wired |
+| `--fuzzy`, `--no-fuzzy` | Find similar file for basis | ❌ Not Implemented | |
+
+## 12. Compression
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-z`, `--compress` | Compress file data | 🔀 Alt Arg | Always uses zstd (rsync supports multiple algorithms) |
+| `--compress-choice=STR` | Choose compression algorithm | ⚠️ Partial | `compress_choice` stored, always zstd |
+| `--compress-level=NUM` | Set compression level | ✅ Implemented | 1-22, default 5 |
+| `--compress-threads=NUM` | Set compression threads | ❌ Not Implemented | |
+| `--skip-compress=LIST` | Skip compress for suffixes | ❌ Not Implemented | Internal skip for hardcoded types; not user-configurable |
+
+## 13. Connectivity
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `-e`, `--rsh=COMMAND` | Remote shell to use | ✅ Implemented | SSH transport support |
+| `--rsync-path=PROGRAM` | rsync binary on remote | ✅ Implemented | `rsync_path` config field |
+| `--port=PORT` | Alternate daemon port | ✅ Implemented | `server_port` config field |
+| `--sockopts=OPTIONS` | Custom TCP options | ❌ Not Implemented | |
+| `--blocking-io` | Use blocking I/O for remote shell | ❌ Not Implemented | |
+| `--outbuf=N\|L\|B` | Set output buffering | ❌ Not Implemented | |
+| `--address=ADDRESS` | Bind address for outgoing socket | ✅ Implemented | `address` config field |
+| `-4`, `--ipv4` | Prefer IPv4 | ✅ Implemented | `ipv4` config field |
+| `-6`, `--ipv6` | Prefer IPv6 | ✅ Implemented | `ipv6` config field |
+
+## 14. Daemon Mode
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `--daemon` | Run as rsync daemon | ⚠️ Partial | `daemon` stored, not wired |
+| `--config=FILE` | Alternate rsyncd.conf file | ⚠️ Partial | `daemon_config` stored, not wired |
+| `--dparam=OVERRIDE` | Override global daemon config | ❌ Not Implemented | |
+| `--no-detach` | Don't detach from parent | ❌ Not Implemented | |
+| `--password-file=FILE` | Read daemon password from file | ❌ Not Implemented | |
+| `--early-input=FILE` | Use FILE for daemon early exec | ❌ Not Implemented | |
+
+## 15. Safety & Security
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| Path escape detection | Ensure files stay within root | ✅ Implemented | `has_path_traversal()` + realpath |
+| Symlink-safe delete | Skip symlinks in delete walk | ✅ Implemented | `delete_extras_walk()` |
+| Protocol version check | Verify compatible versions | ✅ Implemented | `config_receive()` |
+| Max data/string/chunk sizes | Prevent OOM attacks | ✅ Implemented | Per-message limits |
+| Per-connection memory limit | 1GB per connection | ✅ Implemented | `MAX_CONNECTION_MEMORY` |
+| `--trust-sender` | Trust remote sender's file list | ❌ Not Implemented | |
+| `--old-args` | Disable modern arg protection | ❌ Not Implemented | |
+| `--ignore-missing-args` | Ignore missing source args | ❌ Not Implemented | |
+| `--delete-missing-args` | Delete missing source args | ❌ Not Implemented | |
+
+## 16. Batch Operations
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `--write-batch=FILE` | Write batched update to file | ❌ Not Implemented | |
+| `--only-write-batch=FILE` | Write batch without updating dest | ❌ Not Implemented | |
+| `--read-batch=FILE` | Read batched update from file | ❌ Not Implemented | |
+
+## 17. Advanced
+
+| Flag | Rsync Description | FastSync Status | Notes |
+|------|-------------------|-----------------|-------|
+| `--stop-after=MINS` | Stop after N minutes | ❌ Not Implemented | |
+| `--stop-at=TIME` | Stop at specified time | ❌ Not Implemented | |
+| `--fsync` | Fsync every written file | ❌ Not Implemented | |
+| `--protocol=NUM` | Force older protocol version | ❌ Not Implemented | |
+| `--iconv=CONVERT_SPEC` | Charset conversion | ❌ Not Implemented | |
+| `--checksum-seed=NUM` | Set checksum seed | ❌ Not Implemented | |
+| `-s`, `--secluded-args` | Use protocol to send args | ❌ Not Implemented | |
+| `--no-OPTION` | Turn off implied option | ❌ Not Implemented | |
+
+---
+
+## Recommendations: Top Features to Implement Next
+
+Ranked by user demand, implementation complexity, and interoperability impact:
+
+| Priority | Feature | Effort | Impact |
+|----------|---------|--------|--------|
+| 1 | `--whole-file` / `-W` | Low | High — users expect opt-out of delta |
+| 2 | `--ignore-times` / `-I` | Low | Medium — useful for forcing re-transfer |
+| 3 | `--size-only` | Low | Medium — common migration scenario |
+| 4 | `--existing` / `--ignore-existing` | Low | Medium — common sync patterns |
+| 5 | `--remove-source-files` | Low | High — common for moves/backup |
+| 6 | `--delete-during` | Medium | High — performance improvement |
+| 7 | `--delay-updates` | Medium | High — atomic updates |
+| 8 | `--chmod` | Low | Medium — permission flexibility |
+| 9 | `--executability` / `-E` | Low | Low — simple flag |
+| 10 | `--skip-compress` | Low | Medium — performance tuning |
+
+---
+
+## FastSync-Specific Features (Not in rsync)
+
+| Feature | Description |
+|---------|-------------|
+| `-m` | Multithreaded pipeline (scanner/loader/sender) |
+| `-s` | Chunk serialization mode |
+| `-f` / `--sendfile` | Zero-copy sendfile() syscall (TCP only) |
+| `-c [level]` | zstd compression level (1-22) |
+| `--chunk-size` | Configurable chunk size |
+| `--queue-size` | Pipeline queue capacity |
+| `--tls` | TLS encryption (mutual auth) |
+| `--fastsync-server-path` | Path to fastsync-server binary |
+| `--server-host` / `--server-port` | Direct TCP connection |
+| Incremental sync | Skip unchanged files (size+mtime) |
+| Delta transfer | Block-level delta for changed files |
@@ -461,6 +461,14 @@ static int parse_args(Config* config, int argc, char* argv[], int* positional_ar
        return -1;
      free(config->compress_choice);
      config->compress_choice = dup;
+      if (strcmp(config->compress_choice, "zstd") == 0)
+        config->use_compression = true;
+      else if (strcmp(config->compress_choice, "none") == 0)
+        config->use_compression = false;
+      else {
+        fprintf(stderr, "Error: --compress-choice must be 'zstd' or 'none'\n");
+        return -1;
+      }
    } else if (strcmp(argv[i], "--compress-level") == 0 && i + 1 < argc) {
      int val;
      if (!parse_positive_int(argv[++i], &val)) {
@@ -517,6 +525,12 @@ static bool validate_config(const Config* config) {
    fprintf(stderr, "Error: --delta cannot be combined with -f (sendfile)\n");
    return false;
  }
+  if (config->append || config->append_verify) {
+    fprintf(
+        stderr,
+        "Error: --append and --append-verify are not supported yet; refusing to ignore option\n");
+    return false;
+  }
  if (config->use_tls) {
    if (!config->tls_cert || !config->tls_key) {
      fprintf(stderr, "Error: --tls requires --cert and --key\n");
@@ -67,7 +67,8 @@ static int send_delete_manifest(int fd, ArrayList* manifest) {
  return 0;
 }

-static int incremental_check(Client* client, File* file, DeltaSignature** out_sig) {
+static int incremental_check(Client* client, File* file, const Config* config,
+                             DeltaSignature** out_sig) {
  *out_sig = NULL;
  if (!send_status(client->file_descriptor, STATUS_CHECK))
    return -1;
@@ -79,6 +80,12 @@ static int incremental_check(Client* client, File* file, DeltaSignature** out_si
    return -1;
  if (!send_n_data(client->file_descriptor, &mtime, sizeof(mtime)))
    return -1;
+  if (config->checksum) {
+    uint64_t checksum;
+    if (!file_checksum(file, &checksum) ||
+        !send_n_data(client->file_descriptor, &checksum, sizeof(checksum)))
+      return -1;
+  }
  Status s;
  if (!receive_status(client->file_descriptor, &s))
    return -1;
@@ -176,7 +183,7 @@ static int send_single_file(Client* client, File* file, Config* config, bool use
  // Incremental path: use sendfile for the actual data if enabled and no compression
  if (use_sendfile) {
    DeltaSignature* sig = NULL;
-    int rc = incremental_check(client, file, &sig);
+    int rc = incremental_check(client, file, config, &sig);
    if (rc == 1) {
      delta_signature_destroy(sig);
      return 1;
@@ -202,7 +209,7 @@ static int send_single_file(Client* client, File* file, Config* config, bool use
  // Incremental path with single_calls (supports compression and delta)
  file_send_fn send_fn = (file_send_fn)file_send_single_calls;
  DeltaSignature* sig = NULL;
-  int rc = incremental_check(client, file, &sig);
+  int rc = incremental_check(client, file, config, &sig);
  if (rc < 0) {
    delta_signature_destroy(sig);
    return -1;
@@ -15,6 +15,25 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+static char* authorized_root;
+static bool allow_delete;
+
+static bool path_is_within(const char* root, const char* path) {
+  size_t n = strlen(root);
+  return strncmp(root, path, n) == 0 && (path[n] == '\0' || path[n] == '/');
+}
+
+static bool __attribute__((unused)) configure_authorization(const char* root) {
+  char resolved[PATH_MAX];
+  if (!root || !realpath(root, resolved))
+    return false;
+  authorized_root = str_dup(resolved);
+  return authorized_root != NULL;
+}

 int receive_files(Config* config, int fd) {
  Status status;
@@ -39,7 +58,7 @@ int receive_files(Config* config, int fd) {
      if (file == NULL && !skipped)
        return -1;
      if (config->save_to_disk)
-        file_save_to_disk(config->receive_root_directory, file, NULL);
+        file_save_to_disk(config->receive_root_directory, file, config);
      file_destroy(file);
    } else if (status == STATUS_CHUNK) {
      Chunk* chunk = receive_chunk_data(fd, config);
@@ -49,7 +68,7 @@ int receive_files(Config* config, int fd) {
      }
      for (int i = 0; i < chunk->element_count; i++) {
        if (config->save_to_disk)
-          file_save_to_disk(config->receive_root_directory, chunk->items[i], NULL);
+          file_save_to_disk(config->receive_root_directory, chunk->items[i], config);
      }
      chunk_destroy(chunk);
    } else if (status == STATUS_CHECK_BATCH) {
@@ -88,7 +107,7 @@ int receive_files(Config* config, int fd) {
        return -1;
      }
      if (config->save_to_disk)
-        file_save_to_disk(config->receive_root_directory, file, NULL);
+        file_save_to_disk(config->receive_root_directory, file, config);
      file_destroy(file);
    }
  next:
@@ -119,6 +138,36 @@ void handler(int file_descriptor) {
    close(file_descriptor);
    return;
  }
+  if (!authorized_root) {
+    log_message(LOG_LEVEL_ERROR, "No server-side destination root configured");
+    config_delete(config);
+    close(file_descriptor);
+    return;
+  }
+  char resolved_destination[PATH_MAX];
+  char* canonical_destination = realpath(config->receive_root_directory, NULL);
+  const char* destination =
+      canonical_destination ? canonical_destination : config->receive_root_directory;
+  if (has_path_traversal(destination) || !path_is_within(authorized_root, destination)) {
+    log_message(LOG_LEVEL_ERROR, "Rejected destination outside authorized root");
+    free(canonical_destination);
+    config_delete(config);
+    close(file_descriptor);
+    return;
+  }
+  if (canonical_destination)
+    snprintf(resolved_destination, sizeof(resolved_destination), "%s", canonical_destination);
+  else
+    snprintf(resolved_destination, sizeof(resolved_destination), "%s", destination);
+  free(canonical_destination);
+  free(config->receive_root_directory);
+  config->receive_root_directory = str_dup(resolved_destination);
+  if (!config->receive_root_directory) {
+    config_delete(config);
+    close(file_descriptor);
+    return;
+  }
+  config->use_delete = config->use_delete && allow_delete;
  if (config->use_multithreading) {
    Queue* q = queue_create(100, file_destroy);
    if (q == NULL) {
@@ -142,8 +191,11 @@ void handler(int file_descriptor) {
      close(file_descriptor);
      return;
    }
-    thrd_join(receiver, NULL);
-    thrd_join(writer, NULL);
+    int receiver_result;
+    int writer_result;
+    thrd_join(receiver, &receiver_result);
+    thrd_join(writer, &writer_result);
+    if (receiver_result == thrd_success && writer_result == thrd_success)
      send_status(file_descriptor, STATUS_OK);
    pipeline_context_receiver_destroy(context);
  } else {
@@ -175,6 +227,8 @@ static void print_server_usage(void) {
  printf("  --cert <path>       TLS certificate file (PEM)\n");
  printf("  --key <path>        TLS private key file (PEM)\n");
  printf("  --ca <path>         TLS CA certificate file (PEM)\n");
+  printf("  --destination-root <path>  Authorized destination root (default: .)\n");
+  printf("  --allow-delete      Permit manifest deletion\n");
  printf("  -v, --verbose       Enable debug logging\n");
  printf("  --help              Show this help\n");
 }
@@ -185,6 +239,8 @@ int main(int argc, char* argv[]) {
  char* tls_key = NULL;
  char* tls_ca = NULL;
  int port = 8080;
+  const char* destination_root = ".";
+  bool stdio_mode = false;

  signal(SIGPIPE, SIG_IGN);
  for (int i = 1; i < argc; i++) {
@@ -192,9 +248,7 @@ int main(int argc, char* argv[]) {
      print_server_usage();
      return 0;
    } else if (strcmp(argv[i], "--stdio") == 0) {
-      io_set_fds(STDIN_FILENO, STDOUT_FILENO);
-      handler(STDIN_FILENO);
-      return 0;
+      stdio_mode = true;
    } else if (strcmp(argv[i], "-v") == 0 || strcmp(argv[i], "--verbose") == 0) {
      set_log_level(LOG_LEVEL_DEBUG);
    } else if (strcmp(argv[i], "--tls") == 0) {
@@ -205,6 +259,10 @@ int main(int argc, char* argv[]) {
      tls_key = argv[++i];
    } else if (strcmp(argv[i], "--ca") == 0 && i + 1 < argc) {
      tls_ca = argv[++i];
+    } else if (strcmp(argv[i], "--destination-root") == 0 && i + 1 < argc) {
+      destination_root = argv[++i];
+    } else if (strcmp(argv[i], "--allow-delete") == 0) {
+      allow_delete = true;
    } else if (strcmp(argv[i], "-p") == 0 && i + 1 < argc) {
      char* end;
      long p = strtol(argv[++i], &end, 10);
@@ -226,6 +284,16 @@ int main(int argc, char* argv[]) {

  signal(SIGINT, cleanup);
  signal(SIGTERM, cleanup);
+  if (!configure_authorization(destination_root)) {
+    fprintf(stderr, "Error: invalid destination root '%s'\n", destination_root);
+    return 1;
+  }
+  if (stdio_mode) {
+    io_set_fds(STDIN_FILENO, STDOUT_FILENO);
+    handler(STDIN_FILENO);
+    free(authorized_root);
+    return 0;
+  }
  g_server = server_create(port);
  if (g_server == NULL) {
    log_message(LOG_LEVEL_ERROR, "Failed to create server");
@@ -469,6 +469,12 @@ Config* config_receive(int file_descriptor) {
  config->compress_choice = receive_str(file_descriptor);
  if (config->compress_choice == NULL)
    goto error;
+  if (config->compress_choice[0] != '\0' && strcmp(config->compress_choice, "zstd") != 0 &&
+      strcmp(config->compress_choice, "none") != 0) {
+    fprintf(stderr, "Unsupported compression choice: %s\n", config->compress_choice);
+    send_status(file_descriptor, STATUS_ERROR);
+    goto error;
+  }
  config->address = NULL;
  config->bind_address = NULL;
  config->ipv6 = false;
@@ -128,7 +128,7 @@ typedef struct Config {
  char* compress_choice;
 } Config;

-#define PROTOCOL_VERSION "1.3.0"
+#define PROTOCOL_VERSION "2.2.0"
 #define DEFAULT_CHUNK_SIZE (10 * 1024 * 1024)

 Config* config_create(void);
@@ -27,6 +27,10 @@ uint32_t delta_xxhash32(const void* data, uint32_t len) {
  return XXH32(data, len, 0);
 }

+uint64_t delta_xxhash64(const void* data, size_t len) {
+  return XXH64(data, len, 0);
+}
+
 DeltaSignature* delta_signature_create(const void* old_file_data, uint64_t old_file_size,
                                       uint32_t block_size) {
  if (old_file_data == NULL || old_file_size == 0 || block_size == 0)
@@ -72,5 +72,6 @@ bool delta_is_worthwhile(const Delta* delta, uint64_t new_file_size);

 uint32_t delta_adler32(const void* data, uint32_t len);
 uint32_t delta_xxhash32(const void* data, uint32_t len);
+uint64_t delta_xxhash64(const void* data, size_t len);

 #endif
@@ -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>
@@ -21,6 +22,19 @@
 #include "protocol.h"
 #include "utils.h"

+bool file_checksum(File* file, uint64_t* checksum) {
+  if (!file || !checksum || !file->data)
+    return false;
+  if (file->data->size == 0) {
+    *checksum = delta_xxhash64("", 0);
+    return true;
+  }
+  if (!file->data->data && !file_load_data(file))
+    return false;
+  *checksum = delta_xxhash64(file->data->data, file->data->size);
+  return true;
+}
+
 File* file_create(const char* path) {
  File* file = (File*)malloc(sizeof(File));
  if (file == NULL) {
@@ -162,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) {
@@ -421,12 +446,18 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {

  unsigned long long check_size;
  long long check_mtime;
+  uint64_t check_checksum = 0;
  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;
+  }

  if (has_path_traversal(check_path)) {
    log_message(LOG_LEVEL_ERROR, "Path traversal detected: %s", check_path);
@@ -440,8 +471,17 @@ File* receive_incremental_check(int fd, const Config* config, bool* skipped) {
  bool has_old_file = (full_path && lstat(full_path, &st) == 0);
  unsigned long long old_size = has_old_file ? (unsigned long long)st.st_size : 0;

-  bool match = has_old_file && (unsigned long long)st.st_size == check_size &&
-               (long long)st.st_mtime == check_mtime;
+  bool match = has_old_file && (unsigned long long)st.st_size == check_size;
+  if (match && config->checksum) {
+    void* old_data = old_size > 0 ? old_data_from_path(full_path, old_size) : NULL;
+    uint64_t old_checksum = old_size == 0 ? delta_xxhash64("", 0) : 0;
+    if (old_data)
+      old_checksum = delta_xxhash64(old_data, (size_t)old_size);
+    match = (old_size == 0 || old_data) && old_checksum == check_checksum;
+    free(old_data);
+  } else if (match) {
+    match = (long long)st.st_mtime == check_mtime;
+  }

  if (match) {
    if (!send_status(fd, STATUS_OK)) {
@@ -518,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;

@@ -664,6 +804,11 @@ File* file_receive(const Config* config, int file_descriptor) {
  char* path = receive_str(file_descriptor);
  if (path == NULL)
    return NULL;
+  if (path[0] == '\0' || has_path_traversal(path)) {
+    log_message(LOG_LEVEL_ERROR, "Invalid received file path: %s", path);
+    free(path);
+    return NULL;
+  }
  File* file = file_create(path);
  free(path);
  if (file == NULL)
@@ -715,13 +860,20 @@ int receive_manifest(int fd, const Config* config, int* next_status) {
  int count;
  if (!receive_int(fd, &count))
    return -1;
+  if (count < 0 || count > MAX_MANIFEST_ENTRIES)
+    return -1;
  ArrayList* manifest = array_list_create(free);
-  if (manifest) {
+  if (!manifest)
+    return -1;
  for (int i = 0; i < count; i++) {
    char* s = receive_str(fd);
-      if (s)
-        array_list_add(manifest, s);
+    if (!s || s[0] == '\0' || has_path_traversal(s) || !array_list_add(manifest, s)) {
+      free(s);
+      array_list_delete(manifest);
+      return -1;
    }
+  }
+  if (manifest) {
    fprintf(stderr, "Deleting files not in manifest...\n");
    delete_extras(config->receive_root_directory, manifest);
    array_list_delete(manifest);
@@ -26,6 +26,7 @@ typedef struct {
 File* file_create(const char* path);
 void file_destroy(void* item);
 bool file_load_data(File* file);
+bool file_checksum(File* file, uint64_t* checksum);
 File* file_receive(const Config* config, int file_descriptor);
 bool file_send_single_calls(File* file, int file_descriptor, bool use_metadata,
                            int compression_level, bool send_path);
@@ -105,11 +105,16 @@ FileMetadata* metadata_receive(int file_descriptor, int* ok) {
      *ok = 0;
    return NULL;
  }
-  if (!present) {
+  if (present == 0) {
    if (ok)
      *ok = 1;
    return NULL;
  }
+  if (present != 1) {
+    if (ok)
+      *ok = 0;
+    return NULL;
+  }
  FileMetadata* m = malloc(sizeof(FileMetadata));
  if (m == NULL) {
    if (ok)
@@ -156,6 +161,12 @@ FileMetadata* metadata_receive(int file_descriptor, int* ok) {
    return NULL;
  }
  m->mtime_nsec = (long)mtime_nsec;
+  if (mtime_nsec < 0 || mtime_nsec >= 1000000000LL || mode < 0 || uid < 0 || gid < 0) {
+    free(m);
+    if (ok)
+      *ok = 0;
+    return NULL;
+  }
  if (ok)
    *ok = 1;
  return m;
@@ -101,7 +101,21 @@ static bool receive_chunk_enqueue(int file_descriptor, PipelineContextReceiver*
  return true;
 }

+static void receiver_thread_fail(PipelineContextReceiver* context) {
+  mtx_lock(&context->mutex);
+  context->cancelled = true;
+  context->receiver_done = true;
+  cnd_broadcast(&context->condition_not_empty);
+  cnd_broadcast(&context->condition_not_full);
+  mtx_unlock(&context->mutex);
+}
+
 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);
@@ -112,53 +126,52 @@ int receive_thread(void* pipeline_context) {

  Status status;
  if (!receive_status(file_descriptor, &status))
-    return thrd_error;
+    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) {
-      send_status(file_descriptor, 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");
-      return thrd_error;
+      RECEIVE_THREAD_FAIL();
    }
    if (status == STATUS_CHECK) {
      bool skipped;
      File* file = receive_incremental_check(file_descriptor, config, &skipped);
      if (!skipped) {
        if (file == NULL)
-          return thrd_error;
+          RECEIVE_THREAD_FAIL();
        queue_enqueue_multithreaded(context->queue, file, &context->mutex,
                                    &context->condition_not_empty, &context->condition_not_full);
      }
    } else if (status == STATUS_CHUNK) {
      if (!receive_chunk_enqueue(file_descriptor, context))
-        return thrd_error;
+        RECEIVE_THREAD_FAIL();
    } else if (status == STATUS_CHECK_BATCH) {
      int count;
      if (!receive_int(file_descriptor, &count))
-        return thrd_error;
+        RECEIVE_THREAD_FAIL();
      for (int i = 0; i < count; i++) {
        char* check_path = receive_str(file_descriptor);
        if (!check_path)
-          return thrd_error;
+          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);
-          return thrd_error;
+          RECEIVE_THREAD_FAIL();
        }
        char* full_path = path_cat(config->receive_root_directory, check_path);
        struct stat st;
        bool has_old = full_path && lstat(full_path, &st) == 0;
        bool match = has_old && (unsigned long long)st.st_size == check_size &&
                     (long long)st.st_mtime == check_mtime;
-        if (match)
-          send_status(file_descriptor, STATUS_OK);
-        else
-          send_status(file_descriptor, STATUS_NEXT);
+        if (!send_status(file_descriptor, match ? STATUS_OK : STATUS_NEXT))
+          RECEIVE_THREAD_FAIL();
        free(full_path);
        free(check_path);
      }
@@ -170,21 +183,24 @@ int receive_thread(void* pipeline_context) {
                                    &context->condition_not_empty, &context->condition_not_full);
      } else {
        log_message(LOG_LEVEL_ERROR, "Failed to receive file");
-        return thrd_error;
+        RECEIVE_THREAD_FAIL();
      }
    }
  next:
    if (!receive_status(file_descriptor, &status))
-      return thrd_error;
+      RECEIVE_THREAD_FAIL();
  }
  if (status == STATUS_MANIFEST) {
    if (receive_manifest(file_descriptor, config, &status) != 0)
-      return thrd_error;
+      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
  return thrd_success;
 }

@@ -26,6 +26,7 @@ typedef struct {
  mtx_t mutex_progress;
  unsigned long long progress_bytes;
  bool sender_done;
+  bool cancelled;
 } PipelineContextSender;

 typedef struct PipelineContextReceiver {
@@ -37,6 +38,7 @@ typedef struct PipelineContextReceiver {
  cnd_t condition_not_full;
  cnd_t condition_not_empty;
  bool receiver_done;
+  bool cancelled;
 } PipelineContextReceiver;

 PipelineContextSender* pipeline_context_sender_create(Config* config, Queue* queue_scanner,
@@ -1,6 +1,7 @@
 #include "protocol.h"
 #include "log.h"
 #include <errno.h>
+#include <limits.h>
 #include <openssl/ssl.h>
 #include <poll.h>
 #include <stdio.h>
@@ -75,6 +76,17 @@ static int io_fd(int dir_fd, int file_descriptor) {
  return (dir_fd != -1) ? dir_fd : file_descriptor;
 }

+static int deadline_remaining_ms(const struct timespec* deadline) {
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  long long ns =
+      (long long)(deadline->tv_sec - now.tv_sec) * 1000000000LL + deadline->tv_nsec - now.tv_nsec;
+  if (ns <= 0)
+    return 0;
+  long long ms = (ns + 999999) / 1000000;
+  return ms > INT_MAX ? INT_MAX : (int)ms;
+}
+
 bool send_n_data(int file_descriptor, const void* data, size_t data_size) {
  log_message(LOG_LEVEL_DEBUG, "    Sending n Data: %zu", data_size);
  int fd = io_fd(io_write_fd, file_descriptor);
@@ -114,13 +126,19 @@ bool receive_n_data(int file_descriptor, void* data, size_t data_size) {

  size_t total_bytes_received = 0;
  while (total_bytes_received < data_size) {
-    struct timespec now;
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    if (now.tv_sec > deadline.tv_sec ||
-        (now.tv_sec == deadline.tv_sec && now.tv_nsec > deadline.tv_nsec)) {
+    struct pollfd pfd = {.fd = fd, .events = POLLIN};
+    int poll_result = poll(&pfd, 1, deadline_remaining_ms(&deadline));
+    if (poll_result == 0) {
      log_message(LOG_LEVEL_ERROR, "Receive timeout after %ds", RECEIVE_TIMEOUT_SEC);
      return false;
    }
+    if (poll_result < 0) {
+      if (errno == EINTR)
+        continue;
+      return false;
+    }
+    if (pfd.revents & (POLLERR | POLLNVAL))
+      return false;

    ssize_t bytes_received;
    if (io_ssl)
@@ -13,6 +13,7 @@

 /* Maximum chunk size (64 MB) — prevents unbounded allocation from the wire */
 #define MAX_CHUNK_SIZE (64ULL * 1024 * 1024)
+#define MAX_MANIFEST_ENTRIES (1024 * 1024)

 typedef struct ssl_st SSL;

@@ -1,4 +1,5 @@
 #include <stdbool.h>
+#include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -7,6 +8,9 @@
 #include "queue.h"

 Queue* queue_create(int capacity, void (*destroyer)(void* item)) {
+  if (capacity <= 0)
+    return NULL;
+
  Queue* queue = (Queue*)malloc(sizeof(Queue));
  if (queue == NULL) {
    perror("ERROR: Could not allocate memory for queue structure");
@@ -61,7 +65,9 @@ bool queue_is_full(const Queue* queue) {
 static bool queue_double_capacity(Queue* queue) {
  if (queue == NULL)
    return false;
-  unsigned int new_capacity = queue->capacity * 2;
+  if (queue->capacity > INT_MAX / 2)
+    return false;
+  int new_capacity = queue->capacity * 2;
  if (new_capacity <= 1)
    new_capacity = 100;
  void** new_items = malloc(new_capacity * sizeof(void*));
@@ -103,6 +109,22 @@ bool queue_enqueue_multithreaded(Queue* queue, void* item, mtx_t* mutex, cnd_t*
  return ok;
 }

+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) {
+  mtx_lock(mutex);
+  while (queue_is_full(queue) && (cancelled == NULL || !*cancelled))
+    cnd_wait(condition_not_full, mutex);
+  if (cancelled != NULL && *cancelled) {
+    mtx_unlock(mutex);
+    return false;
+  }
+  bool ok = queue_enqueue(queue, item);
+  cnd_signal(condition_not_empty);
+  mtx_unlock(mutex);
+  return ok;
+}
+
 void* queue_dequeue(Queue* queue) {
  if (queue == NULL || queue_is_empty(queue)) {
    perror("ERROR: Could not dequeue from null or empty queue.");
@@ -20,6 +20,9 @@ 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);
@@ -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);
@@ -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);
@@ -193,6 +193,26 @@ class TestIncremental:
            content = f.read()
        assert b"modified content" in content, f"Modified content not transferred: {content[:50]}"

+    def test_checksum_detects_same_size_and_mtime_change(self, shared_server):
+        clean_dir(DEST_DIR)
+        result, _ = run_client(SOURCE_DIR, DEST_DIR, flags=["-M"], port=shared_server.port)
+        assert result.returncode == 0
+
+        received = get_dest_received_dir(DEST_DIR, SOURCE_DIR)
+        source_file = os.path.join(SOURCE_DIR, "small.txt")
+        received_file = os.path.join(received, "small.txt")
+        source_stat = os.stat(source_file)
+        with open(received_file, "wb") as f:
+            f.write(b"different!\n")
+        os.utime(received_file, (source_stat.st_atime, source_stat.st_mtime))
+
+        result, _ = run_client(SOURCE_DIR, DEST_DIR,
+                               flags=["-M", "--incremental", "--checksum"],
+                               port=shared_server.port)
+        assert result.returncode == 0, f"Checksum sync failed: {result.stderr[:200]}"
+        with open(received_file, "rb") as f:
+            assert f.read() == b"hello world\n"
+

 class TestDelete:
    def test_delete_removes_extra_files(self, shared_server):
@@ -35,6 +35,10 @@ static void test_xxhash32_different_data() {
  EXPECT_TRUE(ha != hb);
 }

+static void test_xxhash64_different_data() {
+  EXPECT_TRUE(delta_xxhash64("AAAA", 4) != delta_xxhash64("BBBB", 4));
+}
+
 static void test_signature_roundtrip() {
  char old_data[4096];
  for (int i = 0; i < 4096; i++)
@@ -328,6 +332,7 @@ void test_delta() {
  test_adler32_different_data();
  test_xxhash32_basic();
  test_xxhash32_different_data();
+  test_xxhash64_different_data();
  test_signature_roundtrip();
  test_delta_identical_files();
  test_delta_small_edit();
@@ -126,6 +126,28 @@ static void test_to_disk_creates_dirs() {
  rmdir("test_nested_tmp");
 }

+static void test_to_disk_does_not_follow_symlink() {
+  const char* outside = "test_to_disk_outside.txt";
+  const char* link = "test_to_disk_link.txt";
+  const char* content = "confined";
+  unlink(outside);
+  unlink(link);
+  EXPECT_TRUE(to_disk(outside, "outside", 7, false, false));
+  EXPECT_EQ_INT(symlink(outside, link), 0);
+  EXPECT_TRUE(to_disk(link, content, strlen(content), false, false));
+  FILE* fp = fopen(outside, "rb");
+  char buf[16] = {0};
+  EXPECT_NOT_NULL(fp);
+  if (fp) {
+    size_t read_count = fread(buf, 1, sizeof(buf) - 1, fp);
+    EXPECT_TRUE(read_count <= sizeof(buf) - 1);
+    fclose(fp);
+  }
+  EXPECT_EQ_STR(buf, "outside");
+  unlink(outside);
+  unlink(link);
+}
+
 static void test_file_content_to_buffer() {
  const char* content = "Buffer content test";
  EXPECT_TRUE(to_disk("test_buffer_file.txt", content, strlen(content), false, false));
@@ -434,6 +456,7 @@ void test_file() {
  test_file_save_to_disk();
  test_to_disk_basic();
  test_to_disk_creates_dirs();
+  test_to_disk_does_not_follow_symlink();
  test_file_content_to_buffer();
  test_file_save_to_disk_path_traversal();
  test_file_save_to_disk_deep_traversal();
@@ -109,6 +109,19 @@ static void test_metadata_send_null() {
  close(p[1]);
 }

+static void test_metadata_rejects_invalid_values() {
+  int p[2];
+  EXPECT_EQ_INT(pipe(p), 0);
+  io_set_fds(p[0], p[1]);
+  int32_t present = 2;
+  EXPECT_TRUE(send_n_data(p[1], &present, sizeof(present)));
+  int ok = 1;
+  EXPECT_NULL(metadata_receive(p[0], &ok));
+  EXPECT_EQ_INT(ok, 0);
+  close(p[0]);
+  close(p[1]);
+}
+
 static void test_file_restore_metadata() {
  const char* path = "temp_meta_restore_test.txt";
  const char* content = "test content";
@@ -137,5 +150,6 @@ void test_metadata() {
  test_metadata_from_buf_null();
  test_metadata_send_receive_roundtrip();
  test_metadata_send_null();
+  test_metadata_rejects_invalid_values();
  test_file_restore_metadata();
 }
@@ -82,7 +82,7 @@ static void test_sender_queue_capacities() {
  pipeline_context_sender_destroy(ctx);
 }

-/* Test that create handles zero-capacity queues */
+/* Invalid queue capacities must not create unusable pipeline queues. */
 static void test_sender_zero_capacity() {
  Config* cfg = config_create();
  EXPECT_NOT_NULL(cfg);
@@ -93,11 +93,9 @@ static void test_sender_zero_capacity() {

  Queue* q1 = queue_create(0, NULL);
  Queue* q2 = queue_create(0, NULL);
-  PipelineContextSender* ctx = pipeline_context_sender_create(cfg, q1, q2);
-  EXPECT_NOT_NULL(ctx);
-  EXPECT_EQ_INT(ctx->queue_scanner->capacity, 0);
-  EXPECT_EQ_INT(ctx->queue_loader->capacity, 0);
-  pipeline_context_sender_destroy(ctx);
+  EXPECT_NULL(q1);
+  EXPECT_NULL(q2);
+  config_delete(cfg);
 }

 /* Test receiver with zero file_descriptor */
@@ -168,6 +166,41 @@ static void test_receive_thread_finished() {
  }
 }

+/* A malformed terminal status must wake a writer waiting on an empty queue. */
+static void test_receive_thread_failure_wakes_writer() {
+  Config* cfg = config_create();
+  EXPECT_NOT_NULL(cfg);
+  free(cfg->version);
+  cfg->version = str_dup(PROTOCOL_VERSION);
+  cfg->send_directory = str_dup("/src");
+  cfg->receive_root_directory = str_dup("/tmp/dst");
+
+  int p[2];
+  EXPECT_EQ_INT(pipe(p), 0);
+  Queue* q = queue_create(1, file_destroy);
+  EXPECT_NOT_NULL(q);
+  PipelineContextReceiver* ctx = pipeline_context_receiver_create(cfg, q, p[0], NULL);
+  EXPECT_NOT_NULL(ctx);
+
+  thrd_t receiver;
+  thrd_t writer;
+  EXPECT_EQ_INT(thrd_create(&writer, write_thread, ctx), thrd_success);
+  EXPECT_EQ_INT(thrd_create(&receiver, receive_thread, ctx), thrd_success);
+  EXPECT_TRUE(send_status(p[1], STATUS_OK));
+  close(p[1]);
+
+  int receiver_result;
+  int writer_result;
+  EXPECT_EQ_INT(thrd_join(receiver, &receiver_result), thrd_success);
+  EXPECT_EQ_INT(thrd_join(writer, &writer_result), thrd_success);
+  EXPECT_EQ_INT(receiver_result, thrd_error);
+  EXPECT_EQ_INT(writer_result, thrd_success);
+  EXPECT_TRUE(ctx->receiver_done);
+
+  close(p[0]);
+  pipeline_context_receiver_destroy(ctx);
+}
+
 /* Test that write_thread completes cleanly when queue signals done */
 static void test_write_thread_done() {
  Config* cfg = config_create();
@@ -223,6 +256,7 @@ void test_multiprocessing() {
  test_receiver_fd_zero();
  if (!is_running_under_valgrind()) {
    test_receive_thread_finished();
+    test_receive_thread_failure_wakes_writer();
  }
  test_write_thread_done();
 }
@@ -56,6 +56,11 @@ static void test_queue_basic() {
  queue_destroy(q);
 }

+static void test_queue_rejects_invalid_capacity() {
+  EXPECT_NULL(queue_create(0, NULL));
+  EXPECT_NULL(queue_create(-1, NULL));
+}
+
 static void test_queue_resize() {
  Queue* q = queue_create(3, NULL);
  EXPECT_NOT_NULL(q);
@@ -199,6 +204,7 @@ static void test_queue_multithreaded() {

 void test_queue() {
  test_queue_basic();
+  test_queue_rejects_invalid_capacity();
  test_queue_resize();
  test_queue_destroyer();
  test_queue_multithreaded();
@@ -171,10 +171,26 @@ static void test_receive_files_abort() {
  }
 }

+static void test_receive_manifest_rejects_traversal() {
+  Config* cfg = config_create();
+  EXPECT_NOT_NULL(cfg);
+  cfg->receive_root_directory = str_dup("/tmp/dst");
+  int p[2];
+  EXPECT_EQ_INT(socketpair(AF_UNIX, SOCK_STREAM, 0, p), 0);
+  io_set_fds(p[0], p[1]);
+  EXPECT_TRUE(send_int(p[1], 1));
+  EXPECT_TRUE(send_str(p[1], "../outside"));
+  EXPECT_EQ_INT(receive_manifest(p[0], cfg, NULL), -1);
+  close(p[0]);
+  close(p[1]);
+  config_delete(cfg);
+}
+
 void test_server() {
  if (!is_running_under_valgrind()) {
    test_receive_files_finished();
    test_receive_files_single_file();
    test_receive_files_abort();
+    test_receive_manifest_rejects_traversal();
  }
 }
Author	SHA1	Message	Date
TapTap	9985a8f6a4	style: format config validation CI / lint (pull_request) Failing after 2m9s Details CI / build-and-test (pull_request) Has been skipped Details CI / sanitizers (address) (pull_request) Has been skipped Details CI / sanitizers (undefined) (pull_request) Has been skipped Details CI / fuzz-build (pull_request) Has been skipped Details CI / coverage (pull_request) Has been skipped Details CI / valgrind (pull_request) Has been skipped Details	2026-08-08 20:35:46 +02:00
TapTap	4534284fe9	fix: complete triage security and transfer remediation	2026-08-08 20:35:29 +02:00
TapTap	2ce4f9fbf6	style: format protocol deadline calculation	2026-08-08 20:27:44 +02:00
TapTap	2450b90dd0	feat: add checksum-aware incremental sync	2026-08-08 20:27:26 +02:00
TapTap	e8e9436879	fix: harden queue and receiver error handling	2026-08-08 20:25:58 +02:00
TapTap	98cb8e212e	Merge pull request 'docs: rsync feature compatibility matrix' (#199 ) from docs/rsync-compat into dev Reviewed-on: #199	2026-08-02 09:20:37 +02:00
TapTap	dd11f70043	docs: fix review issues in rsync compatibility matrix CI / lint (pull_request) Successful in 2m19s Details CI / sanitizers (address) (pull_request) Successful in 37s Details CI / sanitizers (undefined) (pull_request) Successful in 38s Details CI / fuzz-build (pull_request) Successful in 13s Details CI / coverage (pull_request) Successful in 31s Details CI / build-and-test (pull_request) Successful in 1m15s Details CI / valgrind (pull_request) Successful in 33s Details - Fix -l/--links: mark as Partial (symlink targets not transmitted) - Fix -p/--perms: mark as Alt Arg (-p means SSH port, not perms) - Fix -c/--checksum: mark as Alt Arg (-c means compression) - Fix --address note: correct config field name - Remove --whole-file duplicate (Section 5 and 11) - Remove --secluded-args duplicate (Section 15 and 17) - Fix --skip-compress note: clarify hardcoded, not user-configurable - Fix --block-size note: clarify delta transfer, not checksum blocks - Recount summary totals: 39/5/30/62 = 136 total	2026-08-02 09:14:35 +02:00
TapTap	0b68974b42	docs: add 🔀 Alt Arg status for features with different flag semantics CI / lint (pull_request) Successful in 2m19s Details CI / sanitizers (address) (pull_request) Successful in 36s Details CI / sanitizers (undefined) (pull_request) Successful in 35s Details CI / fuzz-build (pull_request) Successful in 14s Details CI / coverage (pull_request) Successful in 32s Details CI / build-and-test (pull_request) Successful in 1m15s Details CI / valgrind (pull_request) Successful in 33s Details	2026-08-02 09:01:11 +02:00
TapTap	df41e8bd06	docs: add rsync feature compatibility matrix	2026-08-02 09:01:11 +02:00
TapTap	9d67fcbf92	Merge pull request 'Batch fix: security, bugs, quality, and features (v2)' (#198 ) from integration/all-fixes-v2 into dev	2026-07-30 19:38:26 +02:00