docs: clarify rsync compatibility roadmap

README.md

@@ -1,363 +1,377 @@
 # FastSync
 
-A high-performance file synchronization system with SSH and TCP transport, TLS encryption, streaming zstd compression, multithreaded transfer, incremental sync, metadata preservation, and rsync-compatible CLI flags.
+FastSync is a high-performance file synchronization tool designed to become a
+drop-in replacement for common `rsync` workflows. It keeps the familiar
+source/destination model and rsync-style options while adding optional
+multithreading, streaming zstd compression, chunking, zero-copy TCP transfers,
+and native TCP/TLS transports.
 
-## Technical Overview
+The compatibility target is straightforward:
 
-1. **Dual transport**: custom TCP client-server or SSH subprocess (rsync-style `user@host:/path`)
-2. **TLS encryption**: OpenSSL-based TLS 1.2+ for encrypted TCP connections with optional CA verification
-3. **Chunked file transfer**: files grouped into configurable-size chunks (default ~10 MB)
-4. **Streaming zstd compression** (levels 1–22) using `ZSTD_compressStream2`
-5. **Multithreading**: producer-consumer pipeline with thread-safe queues (scanner → loader → sender)
-6. **Incremental sync**: skip files unchanged since last transfer (compares size + mtime)
-7. **Batch incremental**: send incremental checks in batched groups for reduced round-trips
-8. **Metadata preservation**: file mode and mtime are restored when enabled; ownership and atime are intentionally not restored
-9. **`sendfile()` zero-copy** on TCP (~2× faster on loopback)
-10. **SSH ControlMaster** for connection reuse across repeated invocations
-11. **Bandwidth limiting**: token-bucket throttling (`--bwlimit`)
-12. **`--delete`**: receiver removes files not present in sender manifest
-13. **`--exclude` / `--include`**: glob-pattern filename filtering
-14. **Path traversal protection**: `..` sequences in file paths are rejected automatically
-15. **Connection limits**: server enforces maximum concurrent connections (default 100)
-16. **Keep-alive**: periodic `STATUS_KEEPALIVE` messages detect stalled connections
-17. **Abort handling**: `SIGINT` sends `STATUS_ABORT` for clean server-side teardown
-18. **Atomic writes**: received files are written to a temporary name then atomically renamed
-19. **Backup mode**: `--backup` preserves overwritten files with optional `--backup-dir`
-20. **Log file**: `--log-file` redirects log output to a file instead of stderr
-21. **Transfer statistics**: `--stats` prints summary of transferred bytes, files, and timing
+- Existing rsync commands should keep the same meaning.
+- FastSync-only performance options should be additive and optional.
+- A normal compatibility-mode transfer should prioritize rsync filesystem
+  semantics over maximum throughput.
 
-## System Architecture
+FastSync currently speaks its own protocol to `fastsync-server`. SSH mode
+starts that server remotely; it does not yet interoperate with an unmodified
+rsync client or rsync daemon. See [Compatibility Status](#compatibility-status)
+for the current boundary.
 
-### Client
-- Recursively scans source directories (BFS), supports exclude and include patterns
-- Groups files into chunks (configurable size)
-- Streaming zstd compression with configurable level
-- Chunk serialization (compact binary format) or per-file transfer
-- Incremental transfer: sends file metadata to server, skips unchanged files
-- Batch incremental: groups incremental checks to minimize round-trips
-- Manifests all sent paths when `--delete` is active
-- Sends via TCP `sendfile()` or SSH pipe
-- Optional progress display with throughput
-- Bandwidth limiting via token-bucket algorithm
-- Configurable I/O and connection timeouts (`--timeout`, `--contimeout`)
-- Backup overwritten files (`--backup`) with optional directory (`--backup-dir`)
-- Transfer statistics summary (`--stats`)
-- Maximum directory depth control (`--max-depth`)
-- Log file output (`--log-file`)
-- Exclude patterns from file (`--exclude-from`)
+## Why FastSync
 
-### Server
-- TCP mode: listens on configurable port (default 8080); SSH mode: runs via `--stdio`
-- TLS mode: wraps TCP connections with OpenSSL with optional CA verification
-- Receives and reassembles files
-- Decompresses (streaming zstd), deserializes, restores metadata
-- Handles incremental checks: compares size + mtime against destination files
-- Handles batch incremental checks for reduced round-trips
-- Processes `STATUS_MANIFEST` for `--delete`: walks destination tree, removes extras
-- Per-connection concurrency via `fork()` with configurable connection limit (default 100)
-- Thread pool for parallel processing
-- Atomic writes: files written to `.tmp` path then atomically renamed on success
-- Abort handling: cleanly shuts down on `STATUS_ABORT` from client
-- Path traversal protection: rejects file paths containing `..`
+FastSync uses a producer-consumer transfer pipeline and can combine several
+optimizations for large or high-latency transfers:
 
-## Protocol Details
+- Multithreaded scanning, loading, and sending.
+- Streaming zstd compression with levels 1 through 22.
+- Configurable file chunking and compact chunk serialization.
+- `sendfile()` zero-copy transfers over TCP.
+- Batched incremental checks to reduce round trips.
+- Optional block-level delta transfer for FastSync peers.
+- Bandwidth limiting, progress reporting, statistics, and backups.
+- TCP, SSH, and TLS transports.
+- Atomic temporary-file writes by default.
 
-### Status Codes
-| Code | Meaning |
-|------|---------|
-| `STATUS_OK` | Operation successful |
-| `STATUS_ERROR` | Error occurred |
-| `STATUS_FINISHED` | Transfer complete |
-| `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 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 |
-| `STATUS_DELTA_SIGNATURE` | Delta sync: following data is a file signature (rsync-style rolling hash) |
-| `STATUS_DELTA_DATA` | Delta sync: following data is a delta patch for a file |
+These optimizations are disabled or selected independently. Users can start
+with rsync-style commands and add FastSync options when they are useful.
 
-### Wire Format — Metadata
+## Compatibility Status
 
-When `use_metadata` is enabled (`-M`), each file entry carries a 4-byte `present` flag followed by five fields (`mode`, `uid`, `gid`, `mtime_sec`, `mtime_nsec`). When disabled globally, no metadata bytes are sent — zero wire overhead.
+FastSync is currently an rsync-compatible CLI in progress, not a complete
+replacement for every rsync feature or protocol mode.
 
-### Transfer Flow
-```
-Config → (STATUS_NEXT | STATUS_CHUNK | STATUS_CHECK | STATUS_CHECK_BATCH)* → [STATUS_MANIFEST] → STATUS_FINISHED → STATUS_OK
-```
+### Working today
 
-Keep-alive (`STATUS_KEEPALIVE`) may be sent at any point during the transfer. The receiver resets its inactivity timer on receipt. If no data arrives within the receive timeout, the connection is aborted.
+- Recursive directory scanning.
+- Rsync-style source and destination arguments.
+- SSH transport using `user@host:/path` destinations.
+- TCP client/server transfers.
+- Dry runs, excludes, includes, size filters, backups, statistics, and
+  bandwidth limiting.
+- Incremental size/mtime checks and optional xxHash64 content checks.
+- FastSync-native delta transfer for changed files.
+- Optional mode and timestamp preservation.
+- Delete manifests with server-side delete authorization.
+- Temporary-file writes with atomic rename by default.
+- Path traversal checks and destination-root confinement.
 
-Abort (`STATUS_ABORT`) may be sent at any point. On receipt the server cleans up temporary files and exits the child process.
+### Not yet equivalent to rsync
 
-### Protocol Version
+- The FastSync wire protocol is not the rsync wire protocol.
+- SSH mode requires `fastsync-server` on the remote host.
+- Archive mode does not yet provide all of rsync's `-rlptgoD` behavior.
+- Symlink transfer is incomplete; link targets are not yet recreated in all
+  modes.
+- Owner/group, ACL, xattr, hard-link, device, and special-file handling is
+  incomplete or unavailable.
+- Sparse-file handling does not yet preserve all holes correctly.
+- `--partial`, `--partial-dir`, `--append`, and `--append-verify` are not yet
+  full rsync-style resumable transfers.
+- Several rsync short options currently have FastSync-specific meanings. Do
+  not assume every short option is interchangeable yet.
 
-`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`.
+The detailed flag matrix is maintained in
+[`RSYNC_COMPAT.md`](RSYNC_COMPAT.md). It distinguishes implemented,
+partial, alternate, and planned behavior.
 
-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.
+## Quick Start
 
-## Command-Line Arguments
+### Build
 
-### Client
-
-| Argument | Description |
-|----------|-------------|
-| Positional | `<source> <dest>` — automatic SSH detection if dest contains `:` |
-| `-c [level]` | Compression with optional level (1–22, default 5) |
-| `-z [level]` | Alias for `-c` |
-| `-a, --archive` | Archive mode: enables `-c -m -M` (no `-s`) |
-| `-m` | Multithreading mode |
-| `-s` | Chunk serialization (batch all files per chunk) |
-| `-f, --sendfile` | Sendfile zero-copy. Incompatible with `-c` / `-s`. TCP only. |
-| `-M, --preserve` | Preserve supported file metadata (mode and mtime; ownership and atime are unsupported) |
-| `-n, --dry-run` | Scan and print what would be transferred |
-| `-p <port>` | SSH port (default: 22) |
-| `-v, --verbose` | Enable debug logging |
-| `--progress` | Show real-time transfer speed |
-| `--delete` | Delete files on receiver not present in source |
-| `--exclude <pattern>` | Exclude files matching glob pattern (repeatable) |
-| `--exclude-from <file>` | Read exclude patterns from a file (one per line) |
-| `--include <pattern>` | Only transfer files matching glob pattern (repeatable, whitelist) |
-| `--max-size <n>` | Skip files larger than n bytes |
-| `--min-size <n>` | Skip files smaller than n bytes |
-| `--incremental` | Skip files unchanged since last transfer (size + mtime). Auto-enables `--preserve`. Incompatible with `-s`. |
-| `--bwlimit <KB/s>` | Bandwidth limit in kilobytes per second |
-| `--chunk-size <n>` | Chunk size in bytes (default: 10485760) |
-| `--timeout <sec>` | I/O timeout in seconds (default: 30) |
-| `--contimeout <sec>` | Connection timeout in seconds (default: 10) |
-| `--backup` | Backup existing destination files before overwriting |
-| `--backup-dir <dir>` | Target directory for backups (requires `--backup`) |
-| `--stats` | Print transfer statistics at end (bytes, files, timing) |
-| `--max-depth <n>` | Maximum directory depth to recurse (0 = unlimited, default: 0) |
-| `--log-file <path>` | Write log messages to file instead of stderr |
-| `--source-dir <path>` | Source directory (overrides `FASTSYNC_SOURCE_DIR`) |
-| `--dest-dir <path>` | Server destination directory (overrides `FASTSYNC_DEST_DIR`) |
-| `--save-to-disk` | Write received files to disk |
-| `--server-host <ip>` | Server IP address (default: `127.0.0.1`) |
-| `--server-port <n>` | Server port (default: `8080`) |
-| `--tls` | Enable TLS encryption |
-| `--cert <path>` | TLS certificate file (PEM) |
-| `--key <path>` | TLS private key file (PEM) |
-| `--ca <path>` | TLS CA certificate file for verification (PEM) |
-
-### Server
-
-| Argument | Description |
-|----------|-------------|
-| `--stdio` | Run in stdio mode (for SSH transport; single connection then exits) |
-| `-p <port>` | TCP listen port (default: 8080, range: 1–65535) |
-| `--tls` | Enable TLS encryption |
-| `--cert <path>` | TLS certificate file (PEM) |
-| `--key <path>` | TLS private key file (PEM) |
-| `--ca <path>` | TLS CA certificate file for verification (PEM) |
-| `-v, --verbose` | Enable debug logging |
-| `--help` | Show help |
-
-## Environment Variables
-
-| Variable | Default | Description |
-|----------|---------|-------------|
-| `FASTSYNC_SOURCE_DIR` | — | Source directory fallback |
-| `FASTSYNC_DEST_DIR` | — | Destination directory fallback |
-| `FASTSYNC_SAVE_TO_DISK` | `false` | Disk persistence fallback |
-| `FASTSYNC_SSH_PORT` | `22` | Default SSH port |
-| `FASTSYNC_SERVER_HOST` | `127.0.0.1` | Default server host |
-| `FASTSYNC_SERVER_PORT` | `8080` | Default server port |
-| `FASTSYNC_TLS_CERT` | — | Default TLS certificate path |
-| `FASTSYNC_TLS_KEY` | — | Default TLS private key path |
-| `FASTSYNC_TLS_CA` | — | Default TLS CA certificate path |
-
-## Implementation Details
-
-### Data Structures
-1. **Chunk** — collection of files (~10 MB total by default)
-2. **File** — path, content (`Data`), optional `FileMetadata` pointer
-3. **FileMetadata** — `mode`, `uid`, `gid`, `mtime_sec`, `mtime_nsec`; uid/gid are advisory wire fields and are never applied by the receiver; atime is unsupported
-4. **Config** — runtime parameters (transported over wire, TLS settings excluded). Includes `timeout`, `contimeout`, `quiet`, `backup`, `backup_dir`, `stats`, `max_depth`, `log_file`, `queue_size`.
-5. **Queue** — thread-safe bounded queue with condition variables
-6. **DirectoryScanner** — recursive BFS traversal with exclude and include pattern support, max-depth enforcement
-
-### Key Algorithms
-1. **File scanning** — BFS directory traversal; entries matched against exclude and include patterns, max-depth enforced
-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 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
-9. **SSH transport** — `socketpair()` + `fork()` + `execvp("ssh", ...)` with `ControlMaster` and port support
-10. **TLS transport** — OpenSSL `SSL_CTX` with TLS 1.2 minimum, optional CA verification, transparent `SSL_read`/`SSL_write` via `io_set_ssl()`
-11. **Path traversal protection** — `has_path_traversal()` rejects any file path containing `..` components, preventing directory escape attacks
-12. **Connection limiting** — server tracks active connections and rejects new ones beyond `max_connections` (default 100)
-13. **Keep-alive** — idle connections receive periodic `STATUS_KEEPALIVE` to detect half-open TCP connections
-14. **Abort handling** — `SIGINT` sets an abort flag; the next protocol operation sends `STATUS_ABORT` for clean server cleanup
-15. **Atomic writes** — files are written to a `.tmp` suffix then atomically renamed via `rename()`, preventing partial files
-16. **Backup** — before overwriting, existing files are moved to `--backup-dir` (or same directory with `~` suffix) preserving the original
-
-## Security Features
-
-### Path Traversal Protection
-All received file paths are validated by `has_path_traversal()` before any disk operation. Any path containing `..` components is rejected with `STATUS_ERROR`, preventing directory escape attacks.
-
-### TLS Certificate Verification
-When `--ca` is provided, the server performs mutual TLS verification (`SSL_VERIFY_PEER` with depth 4). Without `--ca`, TLS is still encrypted but peer certificates are not verified.
-
-### Connection Limits
-The server enforces a maximum of 100 concurrent connections (configurable via `max_connections` in `Server`). When the limit is reached, new connections are immediately rejected and closed.
-
-### Abort Handling
-If the client receives `SIGINT` (Ctrl+C) during a transfer, it sends `STATUS_ABORT` to the server. The server then cleans up temporary files and exits the child process, preventing incomplete files from remaining on disk.
-
-### Atomic Writes
-Received files are written to a temporary path (suffixed with `.tmp`) and then atomically renamed to the final filename via `rename()`. This prevents partial or corrupted files from appearing at the destination if the transfer is interrupted.
-
-## Build Requirements
-
-- C11 compiler
-- CMake >= 3.22
-- zstd library
-- OpenSSL (development headers and libraries)
-- pthreads
-- SSH client (for SSH transport mode only)
-
-### Installing Dependencies
-
-**Ubuntu/Debian:**
-```bash
-sudo apt install cmake build-essential libzstd-dev libssl-dev openssh-client
-```
-
-**Nix:**
-```bash
-nix-shell  # provides zstd, openssl, cmake, gcc
-```
-
-## Building
+Requirements: C11 compiler, CMake 3.22 or newer, zstd, OpenSSL, pthreads,
+and an SSH client for SSH transport.
 
 ```bash
-cmake -B build -S . && cmake --build build -j$(nproc)
+cmake -B build -S .
+cmake --build build -j$(nproc)
 ```
 
-## Running
+With Nix:
 
-### Server (TCP mode)
 ```bash
-./build/server
+nix-shell
+cmake -B build -S .
+cmake --build build -j$(nproc)
 ```
 
-### Server with TLS
+### SSH transfer
+
+The remote host must have `fastsync-server` available in `PATH`, or use
+`--fastsync-server-path`.
+
 ```bash
-./build/server --tls --cert server.pem --key server-key.pem
+./build/client /path/to/source user@host:/path/to/destination
 ```
 
-### Server via SSH
-Place the `fastsync-server` binary in the remote `$PATH`. The client runs `ssh user@host fastsync-server --stdio` automatically when an SSH-style destination is given.
+### TCP transfer
+
+Start the FastSync server:
 
-### Client — SSH (rsync-style)
 ```bash
-./build/client /path/to/send user@host:/path/to/receive
+./build/server -p 8080
 ```
 
-### Client — TCP
+Then run the client:
+
 ```bash
-./build/client --source-dir /path/to/send --dest-dir /path/to/receive --save-to-disk
+./build/client --server-host 127.0.0.1 --server-port 8080 \
+  --source-dir /path/to/source --dest-dir /path/to/destination \
+  --save-to-disk
 ```
 
-### Client — TCP with TLS
+### TLS transfer
+
 ```bash
+./build/server --tls --cert server.pem --key server-key.pem -p 8443
 ./build/client --tls --cert client.pem --key client-key.pem --ca ca.pem \
-  --source-dir /path/to/send --dest-dir /path/to/receive --save-to-disk
+  --server-host example.com --server-port 8443 \
+  --source-dir /path/to/source --dest-dir /path/to/destination \
+  --save-to-disk
 ```
 
-### Common Options
+## Common Workflows
+
+These examples show the intended rsync-style workflow. Options marked as
+FastSync-native are optional performance or transport extensions.
+
 ```bash
-# Archive mode (compression + multithreading + metadata)
-./build/client -a /path/to/send user@host:/path
+# Basic synchronization
+./build/client /source/ /destination/
 
-# Dry run
-./build/client -n /path/to/send /path/to/receive
+# Archive-style synchronization (current FastSync archive behavior)
+./build/client -a /source/ user@host:/destination/
 
-# With progress and custom chunk size
-./build/client --progress --chunk-size 2097152 /src user@host:/dst
+# Preview a transfer without changing the destination
+./build/client -n /source/ /destination/
 
-# Exclude temporary files + delete extras on receiver
-./build/client --exclude "*.tmp" --exclude "*.o" --delete /src user@host:/dst
+# Exclude temporary and object files
+./build/client --exclude '*.tmp' --exclude '*.o' \
+  /source/ user@host:/destination/
 
-# Incremental sync (skip unchanged files)
-./build/client --incremental /src user@host:/dst
+# Remove destination entries not present in the source
+./build/client --delete /source/ user@host:/destination/
 
-# Bandwidth limit to 1 MB/s
-./build/client --bwlimit 1024 /src user@host:/dst
+# Skip unchanged files using size and modification time
+./build/client --incremental /source/ user@host:/destination/
 
-# With timeouts and stats
-./build/client --timeout 60 --contimeout 15 --stats /src user@host:/dst
+# Verify content when size and time are not sufficient
+./build/client --incremental --checksum /source/ user@host:/destination/
 
-# Backup overwritten files to a directory
-./build/client --backup --backup-dir /backups /src user@host:/dst
+# Preserve supported mode and timestamp metadata
+./build/client -M /source/ user@host:/destination/
 
-# Exclude patterns from file, limit depth
-./build/client --exclude-from ignore.txt --max-depth 3 /src user@host:/dst
-
-# Log to file
-./build/client --log-file /tmp/fastsync.log /src user@host:/dst
-
-# All features
-./build/client -a --progress --chunk-size 5242880 --exclude "*.log" --delete /src /dst
+# Keep backups of overwritten destination files
+./build/client --backup --backup-dir /backups \
+  /source/ user@host:/destination/
 ```
 
+## FastSync Extensions
+
+FastSync-native options are intended to add performance or operational
+features without changing the meaning of ordinary compatibility options.
+
+| Option | Purpose |
+|---|---|
+| `-m` | Enable the multithreaded scanner/loader/sender pipeline. |
+| `-c [level]`, `-z [level]` | Enable streaming zstd compression, levels 1-22. |
+| `--compress-level <n>` | Set the zstd compression level. |
+| `--chunk-size <bytes>` | Set the transfer chunk size. |
+| `-s` | Enable FastSync chunk serialization. |
+| `-f`, `--sendfile` | Use TCP `sendfile()` zero-copy transfer. Incompatible with compression and chunk serialization. |
+| `--delta` | Use FastSync-native block delta transfer. Requires `--incremental`. |
+| `--delta-block <bytes>` | Set the FastSync delta block size. |
+| `--delta-max <bytes>` | Limit files eligible for FastSync delta transfer. |
+| `--server-host <host>` | Select the TCP server host. |
+| `--server-port <port>` | Select the TCP server port. |
+| `--tls` | Enable TLS for TCP transport. |
+| `--bwlimit <KB/s>` | Apply token-bucket bandwidth limiting. |
+| `--progress` | Show transfer progress and throughput. |
+| `--stats` | Print transfer statistics. |
+| `--timeout <seconds>` | Set I/O timeout. |
+| `--contimeout <seconds>` | Set connection timeout. |
+
+Current short-option conflicts are tracked as compatibility work. In
+particular, FastSync currently uses `-p` for SSH port, `-s` for chunk
+serialization, and `-S` for sparse handling. These meanings must be reconciled
+before FastSync can claim full rsync CLI compatibility.
+
+## Client Options
+
+### Selection and transfer
+
+| Option | Description |
+|---|---|
+| `-a`, `--archive` | Enable current archive preset. Full rsync archive semantics are planned. |
+| `-n`, `--dry-run` | Scan and report without writing files. |
+| `--delete` | Request removal of destination entries absent from the source. The server must allow deletion. |
+| `--exclude <pattern>` | Exclude matching paths. Repeatable. |
+| `--include <pattern>` | Include matching paths. Repeatable. |
+| `--exclude-from <file>` | Read exclude patterns from a file. |
+| `--include-from <file>` | Read include patterns from a file. |
+| `--max-size <bytes>` | Skip files larger than the limit. |
+| `--min-size <bytes>` | Skip files smaller than the limit. |
+| `--max-depth <n>` | Limit recursive scanning depth; zero means unlimited. |
+| `--incremental` | Skip files matching destination size and mtime. |
+| `--checksum` | Include xxHash64 content checks in incremental comparisons. |
+| `--backup` | Back up overwritten files. |
+| `--backup-dir <dir>` | Store backups under a separate directory. |
+| `--suffix <suffix>` | Set the backup filename suffix. |
+| `--partial` | Keep received data under the configured partial location. Full resume semantics are planned. |
+| `--partial-dir <dir>` | Set the partial transfer directory. |
+| `--inplace` | Write directly to the destination instead of using a temporary file. |
+
+### Metadata and links
+
+| Option | Description |
+|---|---|
+| `-M`, `--preserve` | Preserve supported file metadata, currently mode and modification time. |
+| `-l`, `--links` | Request symlink preservation; link-target transfer remains incomplete. |
+| `--copy-links` | Copy symlink referents. |
+| `--safe-links` | Skip symlinks that point outside the transfer tree. |
+| `--copy-unsafe-links` | Copy unsafe symlink referents. |
+| `-S`, `--sparse` | Request sparse-file handling; full hole preservation is planned. |
+
+### Output and logging
+
+| Option | Description |
+|---|---|
+| `-v`, `--verbose` | Enable debug logging. |
+| `--progress` | Show live transfer progress. |
+| `--stats` | Print transfer statistics. |
+| `--log-file <path>` | Write log output to a file. |
+| `-V`, `--version` | Print the FastSync protocol version. |
+| `--help` | Print command usage. |
+
+### Paths and transport
+
+| Option | Description |
+|---|---|
+| `-p <port>` | SSH port in the current CLI. This conflicts with rsync's `-p` permissions option and is planned for correction. |
+| `--fastsync-server-path <path>` | Remote FastSync server path for SSH mode. |
+| `--source-dir <path>` | Set the source directory explicitly. |
+| `--dest-dir <path>` | Set the destination directory explicitly. |
+| `--save-to-disk` | Enable server-side disk persistence. |
+| `--server-host <host>` | TCP server address. |
+| `--server-port <port>` | TCP server port. |
+| `--tls` | Enable TLS. Requires `--cert` and `--key`. |
+| `--cert <path>` | TLS certificate file. |
+| `--key <path>` | TLS private key file. |
+| `--ca <path>` | CA file for peer verification. |
+
+## Server Options
+
+| Option | Description |
+|---|---|
+| `--stdio` | Serve one SSH connection over standard input/output. |
+| `-p <port>` | TCP listen port. |
+| `--tls` | Enable TLS. |
+| `--cert <path>` | TLS certificate file. |
+| `--key <path>` | TLS private key file. |
+| `--ca <path>` | CA file for peer verification. |
+| `--allow-delete` | Permit client delete manifests. Deletion is refused by default. |
+| `-v`, `--verbose` | Enable debug logging. |
+| `--help` | Print server usage. |
+
+## Architecture
+
+### Client
+
+- Recursively scans the source tree with include, exclude, size, and depth
+  filters.
+- Sends individual files or serialized chunks.
+- Performs incremental checks and optional content checksums.
+- Uses a multithreaded producer-consumer pipeline when requested.
+- Sends over TCP, TLS-wrapped TCP, or an SSH subprocess.
+- Supports progress, statistics, backups, timeouts, and bandwidth limiting.
+
+### Server
+
+- Runs as a TCP listener or one-shot SSH `--stdio` server.
+- Receives and reassembles files and decompresses streaming zstd data.
+- Applies supported metadata and writes files through a confined destination
+  root.
+- Uses temporary files and atomic rename by default.
+- Handles delete manifests only when explicitly authorized.
+- Enforces connection, message-size, and path-safety limits.
+
+## Protocol and Security
+
+FastSync protocol version `2.2.0` is shared by the client and server. The
+current protocol is sender-driven and includes configuration negotiation,
+incremental checks, checksums, manifests, keep-alives, abort handling, and
+FastSync-native delta messages. Client and server versions must currently
+match exactly.
+
+TLS provides encrypted TCP transport. Supplying `--ca` enables certificate
+verification; without it, traffic is encrypted but peer identity is not
+verified. Use certificate verification for deployments where authentication
+matters. The default TCP transport is not encrypted.
+
+The receiver protects its destination root with path validation, `openat()`
+directory traversal, `O_NOFOLLOW`, temporary files, and atomic renames. Delete
+operations require the server's explicit `--allow-delete` policy.
+
+## Compatibility Roadmap
+
+The project will reach the drop-in replacement goal in stages:
+
+1. Correct rsync option meanings, including short options, combined options,
+   and `--option=value` syntax.
+2. Add differential tests that compare FastSync and rsync contents, metadata,
+   links, deletes, filters, dry runs, and exit codes.
+3. Make `-a` implement the expected recursive, links, permissions, times,
+   owner/group, and supported special-file behavior.
+4. Complete symlink, sparse-file, metadata, delete-policy, and resumable-write
+   semantics.
+5. Add rsync remote-shell and daemon protocol interoperability.
+6. Keep FastSync performance options as negotiated, optional extensions.
+
+The exhaustive implementation matrix and compatibility notes are in
+[`RSYNC_COMPAT.md`](RSYNC_COMPAT.md).
+
 ## Testing
 
-```bash
-# Unit tests (18 suites — array_list, chunk, compression, config, data, delta, file, glob,
-#                      metadata, property, protocol, queue, robustness, scanner,
-#                      shared_utils, stress, transport_tcp, transport_ssh, transport_tls)
-./build/tests
+Run the unit test binary:
 
-# Integration + benchmark suite
-python3 test.py
+```bash
+./build/tests
 ```
 
-The benchmark prints throughput metrics, best configuration, and speedup vs rsync.
+Run the Python integration suite:
 
-## Performance Considerations
+```bash
+python3 -m pytest tests/
+```
 
-1. Chunk size (~10 MB default) balances memory and transfer efficiency
-2. Compression level trades CPU for bandwidth
-3. `sendfile()` bypasses userspace — ~2× faster on localhost for large files
-4. Multithreading scales with core count and uses memory-based pipeline sizing
-5. Metadata transfer adds negligible overhead (~24 bytes per file when enabled)
-6. SSH socketpair buffer set to 1 MB for improved pipe throughput
-7. SSH ControlMaster reuses connections across repeated invocations
-8. Incremental sync eliminates redundant transfers entirely
-9. Batch incremental reduces round-trips by grouping multiple checks into one message
-10. Bandwidth limiting uses token-bucket with nanosleep for accurate throttling
-11. Atomic writes add a single `rename()` per file — negligible overhead
-12. Path traversal check is O(n) in path length with negligible cost
+For stricter local validation:
 
-## Benchmark Results
+```bash
+cmake -B build-strict -S . -DSTRICT_WARNINGS=ON
+cmake --build build-strict -j$(nproc)
+cmake -B build-asan -S . -DSANITIZER=address
+cmake --build build-asan -j$(nproc)
+```
 
-25 MB of mixed file sizes over `localhost` with disk I/O throttled (reads ≤ 15 MB/s, writes ≤ 10 MB/s) and network emulation via `tc netem`. Each test was run 3×; the median is reported below.
+The benchmark tool compares FastSync configurations with rsync under
+controlled local and network conditions:
 
-### LAN (1000 Mbit, 20 ms ±1 ms, 0.1% loss)
+```bash
+python3 benchmark/bench.py --help
+```
 
-| Configuration | Time | vs rsync (archive) | vs rsync (compress) |
-|---|---|---|---|
-| **Best: `-m -c`** | **0.20 s** | **11.2× faster** | **3.6× faster** |
-| Compression (`-c`) | 0.31 s | 7.3× faster | 2.3× faster |
-| Standard | 1.27 s | 1.8× faster | — |
-| rsync (archive) | 2.27 s | — | — |
-| rsync (archive + compress) | 0.72 s | — | — |
+Benchmark results measure transfer performance only. They do not establish
+rsync protocol or filesystem-semantic compatibility.
 
-### WAN (100 Mbit, 50 ms ±10 ms, 1% loss)
+## Performance Guidance
 
-| Configuration | Time | vs rsync (archive) | vs rsync (compress) |
-|---|---|---|---|
-| **Best: `-m -c`** | **0.39 s** | **44.8× faster** | **3.8× faster** |
-| Compression (`-c`) | 0.64 s | 27.3× faster | 2.3× faster |
-| Standard | 7.12 s | 2.4× faster | — |
-| rsync (archive) | 17.44 s | — | — |
-| rsync (archive + compress) | 1.47 s | — | — |
+- Use `-m` for workloads with many files or enough CPU parallelism.
+- Use `-c` or `-z` when network bandwidth is more constrained than CPU.
+- Tune `--chunk-size` for file sizes, memory limits, and network latency.
+- Use `-f` for large uncompressed TCP transfers where zero-copy I/O helps.
+- Use `--incremental` to avoid retransmitting unchanged files.
+- Use `--delta` for changed files when both endpoints are FastSync peers.
+- Use `--bwlimit` when sharing a link with other traffic.
 
-Compression reduces the data on the wire enough that the transfer becomes latency-bound rather than bandwidth-bound. On WAN, the best configuration runs 10.8× faster than the theoretical limit for uncompressed data, since zstd shrinks the 25 MB payload to a fraction of its original size over the wire.
+Always validate the compatibility behavior required by a deployment before
+replacing an existing rsync job.

src/client/client_send.c

@@ -60,7 +60,6 @@ static Client* connect_transfer_client(const Config* config) {
     connected = client_connect(client, config->server_host, config->server_port);
   }
   if (!connected) {
-    client_disconnect(client);
     client_delete(client);
     return NULL;
   }
@@ -209,11 +208,8 @@ static int incremental_check(Client* client, File* file, const Config* config,
 
 static int send_delta(Client* client, File* file, DeltaSignature* sig, Config* config) {
   Delta* delta = delta_compute(file->data->data, file->data->size, sig, config->delta_block_size);
-  if (!delta) {
-    if (!send_status(client->file_descriptor, STATUS_NEXT))
-      return -1;
+  if (!delta)
     return 1;
-  }
 
   if (!delta_is_worthwhile(delta, file->data->size)) {
     delta_destroy(delta);
@@ -379,7 +375,6 @@ static int send_chunks_multithreaded(void* pipeline_context) {
     if (context->config->transport == TRANSPORT_TCP)
       fprintf(stderr, "Error: could not connect to server%s\n",
               context->config->use_tls ? " via TLS" : "");
-    pipeline_cancel(context);
     mark_sender_done(context);
     return thrd_error;
   }
@@ -388,7 +383,6 @@ static int send_chunks_multithreaded(void* pipeline_context) {
   protocol_session_set_ssl(&session, (SSL*)client->ssl);
   protocol_session_bind(&session);
   if (!config_send(client->file_descriptor, context->config)) {
-    pipeline_cancel(context);
     disconnect_transfer_client(client);
     mark_sender_done(context);
     protocol_session_unbind();
@@ -400,13 +394,6 @@ static int send_chunks_multithreaded(void* pipeline_context) {
         context->queue_loader, &context->mutex_loader, &context->condition_not_empty_loader,
         &context->condition_not_full_loader, &context->loader_done);
     if (current_chunk == NULL) {
-      if (atomic_load(&context->cancelled)) {
-        pipeline_cancel(context);
-        disconnect_transfer_client(client);
-        mark_sender_done(context);
-        protocol_session_unbind();
-        return thrd_error;
-      }
       if (context->config->use_delete) {
         if (send_delete_manifest(client->file_descriptor, context->manifest) != 0)
           goto send_fail;
@@ -519,10 +506,9 @@ static int load_files_multithreaded(void* pipeline_context) {
         if (f->data->size > STREAM_THRESHOLD)
           continue;
         if (!file_load_data(f)) {
-          log_message(LOG_LEVEL_ERROR, "Failed to load file data");
-          chunk_destroy(chunk);
-          pipeline_cancel(context);
-          return thrd_error;
+          log_message(LOG_LEVEL_ERROR, "Failed to load file data, skipping");
+          file_destroy(f);
+          chunk->items[i] = NULL;
         }
       }
     }
@@ -531,7 +517,9 @@ static int load_files_multithreaded(void* pipeline_context) {
                                             &context->condition_not_full_loader,
                                             &context->cancelled)) {
       chunk_destroy(chunk);
-      pipeline_cancel(context);
+      atomic_store(&context->cancelled, true);
+      cnd_broadcast(&context->condition_not_full_loader);
+      cnd_broadcast(&context->condition_not_empty_loader);
       return thrd_error;
     }
   }
@@ -627,8 +615,7 @@ int send_files(Config* config) {
           continue;
         if (!file_load_data(f)) {
           log_message(LOG_LEVEL_ERROR, "Failed to load file data");
-          chunk_destroy(current_chunk);
-          goto send_fail;
+          continue;
         }
       }
     }
@@ -658,7 +645,6 @@ int send_files(Config* config) {
   if (config->use_delete) {
     if (send_delete_manifest(client->file_descriptor, manifest) != 0) {
       array_list_delete(manifest);
-      manifest = NULL;
       goto send_fail;
     }
     array_list_delete(manifest);
@@ -722,10 +708,6 @@ int send_files_multithreaded(Config* config) {
   }
   if (config->use_delete)
     context->manifest = create_transfer_manifest(config);
-  if (config->use_delete && !context->manifest) {
-    pipeline_context_sender_destroy(context);
-    return 1;
-  }
 
   thrd_t scanner, loader, sender;
   bool scanner_created = false;

src/client/scanner.c

@@ -363,8 +363,6 @@ static int parallel_worker_thread(void* arg) {
       cnd_broadcast(&wa->ps->result_not_empty);
       cnd_broadcast(&wa->ps->result_not_full);
       mtx_unlock(&wa->ps->result_mutex);
-      for (int j = i; j < wa->dir_count; j++)
-        free(wa->dirs[j]);
       break;
     }
     Chunk* chunk;
@@ -400,18 +398,6 @@ static int parallel_worker_thread(void* arg) {
   return thrd_success;
 }
 
-static void parallel_scanner_creation_failed(ParallelScanner* ps) {
-  mtx_lock(&ps->result_mutex);
-  ps->failed = true;
-  atomic_store(&ps->cancelled, true);
-  ps->expected_threads = ps->created_threads;
-  if (ps->completed >= ps->expected_threads)
-    ps->done = true;
-  cnd_broadcast(&ps->result_not_empty);
-  cnd_broadcast(&ps->result_not_full);
-  mtx_unlock(&ps->result_mutex);
-}
-
 ParallelScanner* parallel_scanner_create_with_options(const char* root_directory,
                                                       const ScannerOptions* options) {
   if (!root_directory || !options)
@@ -534,6 +520,7 @@ ParallelScanner* parallel_scanner_create_with_options(const char* root_directory
         void** items = array_list_to_array(batch);
         if (!items) {
           ps->failed = true;
+          batch->item_destroyer = file_destroy;
           array_list_delete(batch);
           batch = NULL;
           break;
@@ -542,13 +529,11 @@ ParallelScanner* parallel_scanner_create_with_options(const char* root_directory
         free(items);
         if (!c) {
           ps->failed = true;
+          batch->item_destroyer = file_destroy;
           array_list_delete(batch);
           batch = NULL;
           break;
         }
-        int batch_start = i - batch->size + 1;
-        for (int j = batch_start; j <= i; j++)
-          root_files->items[j] = NULL;
         batch->item_destroyer = NULL;
         array_list_delete(batch);
         batch = NULL;
@@ -575,6 +560,7 @@ ParallelScanner* parallel_scanner_create_with_options(const char* root_directory
       array_list_delete(batch);
     }
     ps->initial_chunk = first;
+    root_files->item_destroyer = NULL;
   }
   array_list_delete(root_files);
 
@@ -601,14 +587,14 @@ ParallelScanner* parallel_scanner_create_with_options(const char* root_directory
         break;
       ParallelWorkerArg* wa = calloc(1, sizeof(ParallelWorkerArg));
       if (!wa) {
-        parallel_scanner_creation_failed(ps);
+        ps->failed = true;
         break;
       }
       wa->ps = ps;
       wa->dirs = calloc(count, sizeof(char*));
       if (!wa->dirs) {
         free(wa);
-        parallel_scanner_creation_failed(ps);
+        ps->failed = true;
         break;
       }
       bool dup_ok = true;
@@ -622,7 +608,7 @@ ParallelScanner* parallel_scanner_create_with_options(const char* root_directory
           free(wa->dirs[j]);
         free(wa->dirs);
         free(wa);
-        parallel_scanner_creation_failed(ps);
+        ps->failed = true;
         break;
       }
       wa->dir_count = count;
@@ -634,7 +620,13 @@ ParallelScanner* parallel_scanner_create_with_options(const char* root_directory
           free(wa->dirs[j]);
         free(wa->dirs);
         free(wa);
-        parallel_scanner_creation_failed(ps);
+        ps->failed = true;
+        atomic_store(&ps->cancelled, true);
+        ps->expected_threads = ps->created_threads;
+        mtx_lock(&ps->result_mutex);
+        cnd_broadcast(&ps->result_not_empty);
+        cnd_broadcast(&ps->result_not_full);
+        mtx_unlock(&ps->result_mutex);
         break;
       }
       ps->num_threads++;
@@ -667,11 +659,6 @@ Chunk* parallel_scanner_next(ParallelScanner* ps) {
   }
   if (ps->num_threads == 0) {
     mtx_lock(&ps->result_mutex);
-    if (!queue_is_empty(ps->result_queue)) {
-      Chunk* chunk = queue_dequeue(ps->result_queue);
-      mtx_unlock(&ps->result_mutex);
-      return chunk;
-    }
     ps->done = true;
     mtx_unlock(&ps->result_mutex);
     return NULL;

src/server/server.c

@@ -106,7 +106,6 @@ void handler(int file_descriptor) {
       protocol_session_unbind();
       return;
     }
-    context->session.total_allocated_bytes = session.total_allocated_bytes;
     thrd_t receiver, writer;
     bool receiver_created = thrd_create(&receiver, receive_thread, context) == thrd_success;
     bool writer_created = false;

src/shared/chunk.c

@@ -1,5 +1,4 @@
 #include <stddef.h>
-#include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -15,7 +14,6 @@
 
 /* Maximum individual file data size within a chunk (64 MB) */
 #define MAX_FILE_DATA_SIZE (64ULL * 1024 * 1024)
-#define MAX_CHUNK_FILES (1024 * 1024)
 
 Chunk* chunk_create(File** items, int element_count) {
   Chunk* chunk = (Chunk*)malloc(sizeof(Chunk));
@@ -94,11 +92,6 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
   size_t remaining_size = data->size;
 
   while (remaining_size > 0) {
-    if (files->size >= MAX_CHUNK_FILES) {
-      log_message(LOG_LEVEL_ERROR, "Chunk contains too many files");
-      array_list_delete(files);
-      return NULL;
-    }
     if (remaining_size < sizeof(size_t)) {
       log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path length");
       array_list_delete(files);
@@ -110,7 +103,7 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
     data_pointer += sizeof(size_t);
     remaining_size -= sizeof(size_t);
 
-    if (path_len > SIZE_MAX - 1 || remaining_size < path_len) {
+    if (remaining_size < path_len) {
       log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for path");
       array_list_delete(files);
       return NULL;
@@ -129,15 +122,10 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
 
     File* file = file_create(path);
     free(path);
-    if (file == NULL) {
-      array_list_delete(files);
-      return NULL;
-    }
 
     if (use_metadata) {
       if (remaining_size < sizeof(int)) {
         log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for metadata");
-        file_destroy(file);
         array_list_delete(files);
         return NULL;
       }
@@ -146,7 +134,6 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
       memcpy(&present_flag, data_pointer, sizeof(int));
       if (present_flag && remaining_size < sizeof(int) + FILE_METADATA_WIRE_SIZE) {
         log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for metadata body");
-        file_destroy(file);
         array_list_delete(files);
         return NULL;
       }
@@ -154,16 +141,10 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
       remaining_size -= sizeof(int);
       if (file->metadata)
         remaining_size -= FILE_METADATA_WIRE_SIZE;
-      else if (present_flag) {
-        file_destroy(file);
-        array_list_delete(files);
-        return NULL;
-      }
     }
 
     if (remaining_size < sizeof(size_t)) {
       log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for data size");
-      file_destroy(file);
       array_list_delete(files);
       return NULL;
     }
@@ -175,7 +156,6 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
 
     if (remaining_size < file_data_size) {
       log_message(LOG_LEVEL_ERROR, "Invalid chunk format: not enough data for file content");
-      file_destroy(file);
       array_list_delete(files);
       return NULL;
     }
@@ -184,48 +164,29 @@ Chunk* chunk_deserialize(Data* data, bool use_metadata) {
     if (file_data_size > MAX_FILE_DATA_SIZE) {
       log_message(LOG_LEVEL_ERROR, "File data size %zu exceeds maximum %llu", file_data_size,
                   (unsigned long long)MAX_FILE_DATA_SIZE);
-      file_destroy(file);
       array_list_delete(files);
       return NULL;
     }
 
-    void* file_data = malloc(file_data_size > 0 ? file_data_size : 1);
+    void* file_data = malloc(file_data_size);
     if (file_data == NULL) {
       perror("Could not allocate memory for file data");
-      file_destroy(file);
       array_list_delete(files);
       return NULL;
     }
     memcpy(file_data, data_pointer, file_data_size);
     data_destroy(file->data);
     file->data = data_create(file_data, file_data_size);
-    if (file->data == NULL) {
-      file_destroy(file);
-      array_list_delete(files);
-      return NULL;
-    }
     data_pointer += file_data_size;
     remaining_size -= file_data_size;
 
-    if (!array_list_add(files, file)) {
-      file_destroy(file);
-      array_list_delete(files);
-      return NULL;
-    }
+    array_list_add(files, file);
   }
 
   File** file_array = (File**)array_list_to_array(files);
-  if (file_array == NULL) {
-    array_list_delete(files);
-    return NULL;
-  }
   Chunk* chunk = chunk_create(file_array, files->size);
 
   free(file_array);
-  if (chunk == NULL) {
-    array_list_delete(files);
-    return NULL;
-  }
   files->item_destroyer = NULL;
   array_list_delete(files);
 

src/shared/file_store.c

@@ -130,20 +130,9 @@ bool file_store_write_secure(const char* path, const void* data, unsigned long l
         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;
-    }
+    char tmp[NAME_MAX];
     for (unsigned int i = 0; i < 100 && !ok; ++i) {
-      snprintf(tmp, (size_t)tmp_size + 1, ".%s.tmp.%ld.%u", leaf, (long)getpid(), 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;
@@ -161,7 +150,6 @@ bool file_store_write_secure(const char* path, const void* data, unsigned long l
       if (!ok)
         unlinkat(dirfd, tmp, 0);
     }
-    free(tmp);
   }
   if (fd >= 0)
     close(fd);

src/shared/multiprocessing.c

@@ -183,15 +183,6 @@ int write_thread(void* pipeline_context) {
   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/protocol.c

@@ -19,7 +19,6 @@ 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;
@@ -27,6 +26,8 @@ static struct timespec bw_last_refill = {0, 0};
 static mtx_t bw_mutex;
 static once_flag bw_mutex_once = ONCE_FLAG_INIT;
 
+static __thread unsigned long long total_allocated_bytes = 0;
+
 void io_set_fds(int read_fd, int write_fd) {
   bound_session = NULL;
   io_read_fd = read_fd;
@@ -34,11 +35,7 @@ void io_set_fds(int read_fd, int 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;
-  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, io_bwlimit);
+  total_allocated_bytes = 0;
 }
 
 void protocol_session_init(ProtocolSession* session, int read_fd, int write_fd) {
@@ -129,30 +126,32 @@ SSL* io_get_ssl(void) {
   return io_ssl;
 }
 
-static ProtocolSession* legacy_session(int read_fd, int write_fd) {
+static ProtocolSession* legacy_session(void) {
+  static __thread ProtocolSession session;
   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, io_bwlimit);
-  } else if (legacy_io_session.bwlimit != io_bwlimit) {
-    protocol_session_set_bwlimit(&legacy_io_session, io_bwlimit);
-  }
-  legacy_io_session.ssl = io_ssl;
-  return &legacy_io_session;
+  session.read_fd = io_read_fd;
+  session.write_fd = io_write_fd;
+  session.ssl = io_ssl;
+  session.bwlimit = io_bwlimit;
+  session.bw_tokens = (unsigned long long)(bw_tokens < 0 ? 0 : bw_tokens);
+  session.bw_last_refill_sec = bw_last_refill.tv_sec;
+  session.bw_last_refill_nsec = bw_last_refill.tv_nsec;
+  return &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);
+  ProtocolSession* session = legacy_session();
+  if (session->write_fd == -1)
+    session->write_fd = file_descriptor;
+  return protocol_send_n_data(session, 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);
+  ProtocolSession* session = legacy_session();
+  if (session->read_fd == -1)
+    session->read_fd = file_descriptor;
+  return protocol_receive_n_data(session, data, data_size);
 }
 
 static int deadline_remaining_ms(const struct timespec* deadline) {
@@ -404,26 +403,34 @@ bool protocol_receive_status(ProtocolSession* session, Status* status) {
 }
 
 bool send_str(int fd, const char* data) {
-  return protocol_send_str(legacy_session(-1, fd), data);
+  (void)fd;
+  return protocol_send_str(legacy_session(), data);
 }
 char* receive_str(int fd) {
-  return protocol_receive_str(legacy_session(fd, -1));
+  (void)fd;
+  return protocol_receive_str(legacy_session());
 }
 bool send_data(int fd, const Data* data) {
-  return protocol_send_data(legacy_session(-1, fd), data);
+  (void)fd;
+  return protocol_send_data(legacy_session(), data);
 }
 Data* receive_data(int fd) {
-  return protocol_receive_data(legacy_session(fd, -1));
+  (void)fd;
+  return protocol_receive_data(legacy_session());
 }
 bool send_int(int fd, int data) {
-  return protocol_send_int(legacy_session(-1, fd), data);
+  (void)fd;
+  return protocol_send_int(legacy_session(), data);
 }
 bool receive_int(int fd, int* data) {
-  return protocol_receive_int(legacy_session(fd, -1), data);
+  (void)fd;
+  return protocol_receive_int(legacy_session(), data);
 }
 bool send_status(int fd, Status status) {
-  return protocol_send_status(legacy_session(-1, fd), status);
+  (void)fd;
+  return protocol_send_status(legacy_session(), status);
 }
 bool receive_status(int fd, Status* status) {
-  return protocol_receive_status(legacy_session(fd, -1), status);
+  (void)fd;
+  return protocol_receive_status(legacy_session(), status);
 }

src/shared/transport_tcp.c

@@ -151,10 +151,6 @@ 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;

src/shared/transport_tcp.h

@@ -35,6 +35,5 @@ 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

@@ -9,7 +9,6 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <time.h>
 #include <unistd.h>
 
 bool tls_global_init(void) {
@@ -93,7 +92,6 @@ 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)
@@ -103,8 +101,7 @@ 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) &&
-          time(NULL) < deadline)
+      if (ssl_err == SSL_ERROR_WANT_READ || ssl_err == SSL_ERROR_WANT_WRITE)
         continue;
       log_message(LOG_LEVEL_ERROR, "SSL %s failed", is_server ? "accept" : "connect");
       log_ssl_errors();

tests/test_scanner.c

@@ -385,34 +385,6 @@ static void test_scanner_no_patterns() {
   rmdir(dir);
 }
 
-static void test_parallel_scanner_root_chunks_without_workers() {
-  const char* dir = "test_parallel_scan_root";
-  const char* file1 = "test_parallel_scan_root/a.txt";
-  const char* file2 = "test_parallel_scan_root/b.txt";
-
-  EXPECT_EQ_INT(mkdir(dir, 0755), 0);
-  create_test_file(file1, "a");
-  create_test_file(file2, "b");
-
-  ParallelScanner* scanner = parallel_scanner_create(dir, false, 1, NULL, 0, NULL, 0, 0, 0, 0, 0,
-                                                     false, false, false, false, false);
-  EXPECT_NOT_NULL(scanner);
-
-  int total_files = 0;
-  Chunk* chunk;
-  while ((chunk = parallel_scanner_next(scanner)) != NULL) {
-    total_files += chunk->element_count;
-    chunk_destroy(chunk);
-  }
-  EXPECT_EQ_INT(total_files, 2);
-  EXPECT_FALSE(parallel_scanner_failed(scanner));
-
-  parallel_scanner_destroy(scanner);
-  unlink(file1);
-  unlink(file2);
-  rmdir(dir);
-}
-
 void test_scanner() {
   test_scanner_single_file();
   test_scanner_multiple_files();
@@ -427,5 +399,4 @@ void test_scanner() {
   test_scanner_size_range();
   test_scanner_mixed_patterns();
   test_scanner_no_patterns();
-  test_parallel_scanner_root_chunks_without_workers();
 }