Merge feat/p4-devices

# Conflicts:
#	src/client/client_send.c
#	src/server/receiver.c
#	src/shared/chunk.c
#	src/shared/file.c
#	src/shared/file_receive.c
#	src/shared/file_receive.h
#	src/shared/file_types.h
#	src/shared/protocol.h
#	tests/test_chunk.c

tests/integration/test_features.py

@@ -3,6 +3,7 @@ import filecmp
 import os
 import random
 import shutil
+import stat
 import subprocess
 import sys
 import time
@@ -18,6 +19,159 @@ from common import (
 
 SOURCE_DIR = os.path.join(TEST_DATA_DIR, "feature_source")
 DEST_DIR = os.path.join(TEST_DATA_DIR, "feature_dest")
+DEVICE_SOURCE = os.path.join(TEST_DATA_DIR, "device_source")
+DEVICE_DEST = os.path.join(TEST_DATA_DIR, "device_dest")
+
+
+class TestDeviceSpecial:
+    """Phase 4: --devices / --specials / -D / --copy-devices / --write-devices.
+
+    Device node CREATION (mknod) is privileged (CAP_MKNOD); CI runs non-root, so
+    only the FIFO path (mkfifo, unprivileged) is asserted unconditionally.  The
+    real-device-created assertions are guarded to run only as root.  Everything
+    else must simply succeed / skip without aborting.
+    """
+
+    def _setup(self):
+        clean_dir(DEVICE_SOURCE)
+        clean_dir(DEVICE_DEST)
+        with open(os.path.join(DEVICE_SOURCE, "plain.txt"), "wb") as f:
+            f.write(b"regular content\n")
+
+    def test_specials_recreates_fifo(self, shared_server):
+        self._setup()
+        os.mkfifo(os.path.join(DEVICE_SOURCE, "pipe.fifo"))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["--specials"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+        received = get_dest_received_dir(DEVICE_DEST, DEVICE_SOURCE)
+        fifo = os.path.join(received, "pipe.fifo")
+        assert os.path.exists(fifo) and stat.S_ISFIFO(os.stat(fifo).st_mode), (
+            "source FIFO was not recreated as a FIFO on the destination"
+        )
+        # The regular file alongside it still transferred normally.
+        with open(os.path.join(received, "plain.txt")) as f:
+            assert f.read() == "regular content\n"
+
+    def test_D_implies_devices_and_specials_fifo(self, shared_server):
+        """-D implies --devices --specials; a FIFO is preserved without a crash
+        even though no device mknod is attempted on the (non-root) receiver."""
+        self._setup()
+        os.mkfifo(os.path.join(DEVICE_SOURCE, "pipe.fifo"))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["-D"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+        received = get_dest_received_dir(DEVICE_DEST, DEVICE_SOURCE)
+        assert stat.S_ISFIFO(os.stat(os.path.join(received, "pipe.fifo")).st_mode)
+
+    def test_copy_devices_non_crash(self, shared_server):
+        """--copy-devices treats a special/device source as a regular-file copy;
+        a FIFO (st_size 0) must transfer without hanging or crashing."""
+        self._setup()
+        os.mkfifo(os.path.join(DEVICE_SOURCE, "device_copy.fifo"))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["--copy-devices"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+
+    def test_write_devices_non_crash(self, shared_server):
+        """--write-devices writes into an existing device only; when the
+        destination holds no device node the entry is skipped safely and the
+        run still succeeds (never aborts)."""
+        self._setup()
+        # Destination already holds a regular file at the source FIFO's path:
+        # the receiver must not clobber it and must not crash.
+        os.mkfifo(os.path.join(DEVICE_SOURCE, "target.fifo"))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["--write-devices"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+
+    @pytest.mark.skipif(os.geteuid() != 0, reason="requires root to create device nodes")
+    def test_devices_recreates_real_char_device(self, shared_server):
+        """Root-only: a source char device node is recreated on the destination
+        with the same type and rdev (privilege-gated mknod path)."""
+        self._setup()
+        src_dev = os.path.join(DEVICE_SOURCE, "realdev")
+        os.mknod(src_dev, stat.S_IFCHR | 0o666, os.makedev(1, 3))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["--devices"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+        received = get_dest_received_dir(DEVICE_DEST, DEVICE_SOURCE)
+        st = os.lstat(os.path.join(received, "realdev"))
+        assert stat.S_ISCHR(st.st_mode)
+        assert os.major(st.st_rdev) == 1 and os.minor(st.st_rdev) == 3
+
+    def test_m_remove_source_files_keeps_recreated_fifo(self, shared_server):
+        """-m --remove-source-files --specials: a recreated FIFO must NOT be
+        acknowledged as a removable source (its outcome must not shift the
+        per-file status stream, which would break the run and mis-remove the
+        adjacent regular file).  The regular file is removed; the FIFO stays."""
+        self._setup()
+        os.mkfifo(os.path.join(DEVICE_SOURCE, "pipe.fifo"))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["-m", "--remove-source-files", "--specials"],
+                               port=shared_server.port)
+        assert result.returncode == 0, (
+            f"Exit {result.returncode}: {result.stderr[:300]}"
+        )
+        assert not os.path.exists(os.path.join(DEVICE_SOURCE, "plain.txt")), (
+            "regular source file should have been removed"
+        )
+        assert os.path.exists(os.path.join(DEVICE_SOURCE, "pipe.fifo")), (
+            "recreated FIFO source must never be removed"
+        )
+
+    @pytest.mark.skipif(os.geteuid() != 0, reason="requires root to create device nodes")
+    def test_m_remove_source_files_keeps_recreated_device(self, shared_server):
+        """Root-only: -m --remove-source-files --devices must not remove a
+        source device node the receiver recreated (mirrors the single-threaded
+        behavior; the special is never acknowledged as a removable source)."""
+        self._setup()
+        src_dev = os.path.join(DEVICE_SOURCE, "realdev")
+        os.mknod(src_dev, stat.S_IFCHR | 0o666, os.makedev(1, 3))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["-m", "--remove-source-files", "--devices"],
+                               port=shared_server.port)
+        assert result.returncode == 0, (
+            f"Exit {result.returncode}: {result.stderr[:300]}"
+        )
+        assert not os.path.exists(os.path.join(DEVICE_SOURCE, "plain.txt")), (
+            "regular source file should have been removed"
+        )
+        assert os.path.exists(src_dev) and stat.S_ISCHR(os.lstat(src_dev).st_mode), (
+            "recreated device source must never be removed"
+        )
+
+    def test_write_devices_fifo_target_skips_not_hangs(self, shared_server):
+        """--write-devices must never block on a pre-existing FIFO at the
+        destination mirror: opening with O_NONBLOCK fails with ENXIO and the
+        entry is skipped (the FIFO is left untouched and the run succeeds)."""
+        self._setup()
+        # Pre-plant a FIFO at the destination mirror of the source file's path.
+        received = get_dest_received_dir(DEVICE_DEST, DEVICE_SOURCE)
+        os.makedirs(received, exist_ok=True)
+        target = os.path.join(received, "plain.txt")
+        os.mkfifo(target)
+        result, dur = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                                 flags=["--write-devices"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+        assert stat.S_ISFIFO(os.lstat(target).st_mode), "FIFO target was clobbered"
+        assert dur < 60, "write-devices hung on a FIFO target"
+
+    def test_special_confined_to_receive_root(self, shared_server):
+        """A special node is created only under the receive root; nothing is
+        ever materialized outside it (the receiver is confined to its
+        authorized root)."""
+        self._setup()
+        os.mkfifo(os.path.join(DEVICE_SOURCE, "confined.fifo"))
+        result, _ = run_client(DEVICE_SOURCE, DEVICE_DEST,
+                               flags=["--specials"], port=shared_server.port)
+        assert result.returncode == 0, f"Exit {result.returncode}: {result.stderr[:200]}"
+        # The only new FIFO is under the receive tree; its sibling watchers
+        # confirm the confined dest layout (no stray node at the source root).
+        source_fifo_escaped = os.path.join(DEVICE_DEST, "confined.fifo")
+        assert not os.path.lexists(source_fifo_escaped), "special escaped the receive root"
+        received = get_dest_received_dir(DEVICE_DEST, DEVICE_SOURCE)
+        assert stat.S_ISFIFO(os.stat(os.path.join(received, "confined.fifo")).st_mode)
 
 
 @pytest.fixture(scope="module", autouse=True)

tests/test_chunk.c

@@ -216,9 +216,75 @@ static void test_chunk_symlink_roundtrip() {
   rmdir(link_path);
 }
 
+/* A --devices/--specials special entry (is_special + rdev) must round-trip
+ * through the chunk wire with a legal rdev. */
+static void test_chunk_special_rdev_roundtrip() {
+  const char* path = "temp_chunk_special_node";
+  unlink(path);
+  File* special = file_create(path);
+  EXPECT_NOT_NULL(special);
+  special->is_special = true;
+  special->rdev_major = 1;
+  special->rdev_minor = 3;
+  struct stat st;
+  EXPECT_EQ_INT(stat("/dev/null", &st), 0);
+  special->metadata = file_metadata_create(path, &st, false, false);
+  EXPECT_NOT_NULL(special->metadata);
+
+  File* files[1] = {special};
+  Chunk* chunk = chunk_create(files, 1);
+  EXPECT_NOT_NULL(chunk);
+  Data* serialized = chunk_serialize(chunk, true);
+  EXPECT_NOT_NULL(serialized);
+  Chunk* deserialized = chunk_deserialize(serialized, true);
+  EXPECT_NOT_NULL(deserialized);
+  EXPECT_EQ_INT(deserialized->element_count, 1);
+  EXPECT_TRUE(deserialized->items[0]->is_special);
+  EXPECT_FALSE(deserialized->items[0]->is_dir);
+  EXPECT_EQ_INT((int)deserialized->items[0]->data->size, 0);
+  EXPECT_EQ_INT(deserialized->items[0]->rdev_major, 1);
+  EXPECT_EQ_INT(deserialized->items[0]->rdev_minor, 3);
+  EXPECT_NOT_NULL(deserialized->items[0]->metadata);
+
+  data_destroy(serialized);
+  chunk_destroy(deserialized);
+  chunk_destroy(chunk);
+}
+
+/* A special entry carrying an out-of-range rdev is a malformed chunk and must be
+ * rejected at deserialize (bounded by the same 0xffff / 0x00ffffff limits
+ * file_special_rdev_valid uses on the per-file wire), not deferred to the
+ * creation site. */
+static void test_chunk_special_rdev_out_of_range_rejected() {
+  const char* path = "temp_chunk_special_bad_rdev";
+  unlink(path);
+  File* special = file_create(path);
+  EXPECT_NOT_NULL(special);
+  special->is_special = true;
+  special->rdev_major = 0x10000; /* > 0xffff */
+  special->rdev_minor = 3;
+  struct stat st;
+  EXPECT_EQ_INT(stat("/dev/null", &st), 0);
+  special->metadata = file_metadata_create(path, &st, false, false);
+  EXPECT_NOT_NULL(special->metadata);
+
+  File* files[1] = {special};
+  Chunk* chunk = chunk_create(files, 1);
+  EXPECT_NOT_NULL(chunk);
+  Data* serialized = chunk_serialize(chunk, true);
+  EXPECT_NOT_NULL(serialized);
+  Chunk* deserialized = chunk_deserialize(serialized, true);
+  EXPECT_NULL(deserialized);
+
+  data_destroy(serialized);
+  chunk_destroy(chunk);
+}
+
 void test_chunk() {
   test_file_operations();
   test_chunk_operations();
   test_chunk_dir_entry_roundtrip();
   test_chunk_symlink_roundtrip();
+  test_chunk_special_rdev_roundtrip();
+  test_chunk_special_rdev_out_of_range_rejected();
 }

tests/test_client_cli.c

@@ -772,8 +772,6 @@ static void test_parse_args_rejects_unimplemented_options() {
                                         "--acls",
                                         "-X",
                                         "--xattrs",
-                                        "-D",
-                                        "--devices",
                                         "--delete-excluded",
                                         "--max-delete",
                                         "--prune-empty-dirs",
@@ -2380,6 +2378,52 @@ static void test_parse_args_omit_link_times_long() {
   config_delete(cfg);
 }
 
+/* --devices / --specials / -D / --copy-devices / --write-devices parse into the
+   config, and the preserved flags imply metadata transmission. */
+static void test_parse_args_devices_specials() {
+  Config* cfg = config_create();
+  char* argv[] = {"fastsync", "--devices", "/src", "/dst"};
+  int positional_args[2];
+  int positional_count = 0;
+  EXPECT_EQ_INT(parse_args(cfg, 4, argv, positional_args, &positional_count), 0);
+  EXPECT_TRUE(cfg->preserve_devices);
+  EXPECT_FALSE(cfg->preserve_specials);
+  EXPECT_TRUE(cfg->use_metadata);
+  config_delete(cfg);
+
+  cfg = config_create();
+  char* argv2[] = {"fastsync", "--specials", "/src", "/dst"};
+  positional_count = 0;
+  EXPECT_EQ_INT(parse_args(cfg, 4, argv2, positional_args, &positional_count), 0);
+  EXPECT_TRUE(cfg->preserve_specials);
+  EXPECT_FALSE(cfg->preserve_devices);
+  EXPECT_TRUE(cfg->use_metadata);
+  config_delete(cfg);
+
+  cfg = config_create();
+  char* argv3[] = {"fastsync", "-D", "/src", "/dst"};
+  positional_count = 0;
+  EXPECT_EQ_INT(parse_args(cfg, 4, argv3, positional_args, &positional_count), 0);
+  EXPECT_TRUE(cfg->preserve_devices);
+  EXPECT_TRUE(cfg->preserve_specials);
+  EXPECT_TRUE(cfg->use_metadata);
+  config_delete(cfg);
+
+  cfg = config_create();
+  char* argv4[] = {"fastsync", "--copy-devices", "/src", "/dst"};
+  positional_count = 0;
+  EXPECT_EQ_INT(parse_args(cfg, 4, argv4, positional_args, &positional_count), 0);
+  EXPECT_TRUE(cfg->copy_devices);
+  config_delete(cfg);
+
+  cfg = config_create();
+  char* argv5[] = {"fastsync", "--write-devices", "/src", "/dst"};
+  positional_count = 0;
+  EXPECT_EQ_INT(parse_args(cfg, 4, argv5, positional_args, &positional_count), 0);
+  EXPECT_TRUE(cfg->write_devices);
+  config_delete(cfg);
+}
+
 void test_client_cli() {
   test_validate_config_required_paths();
   test_parse_args_numeric_ids();
@@ -2390,6 +2434,7 @@ void test_client_cli() {
   test_parse_args_rejects_malformed_identity();
   test_parse_args_preallocate();
   test_parse_args_metadata_times();
+  test_parse_args_devices_specials();
   test_parse_args_atimes_long_and_short();
   test_parse_args_omit_link_times_long();
   test_parse_args_append();

tests/test_config.c

@@ -1141,6 +1141,48 @@ static void test_config_preallocate_wire_roundtrip() {
     }
   }
 }
+static void test_config_devices_wire_roundtrip() {
+  if (is_running_under_valgrind())
+    return;
+  Config* send_cfg = config_create();
+  EXPECT_NOT_NULL(send_cfg);
+  send_cfg->send_directory = str_dup("/send/src");
+  send_cfg->receive_root_directory = str_dup("/send/dst");
+  send_cfg->preserve_devices = true;
+  send_cfg->preserve_specials = true;
+  send_cfg->copy_devices = true;
+  send_cfg->write_devices = true;
+
+  int p[2];
+  EXPECT_EQ_INT(socketpair(AF_UNIX, SOCK_STREAM, 0, p), 0);
+  io_set_fds(p[0], p[1]);
+  io_set_bwlimit(0);
+  pid_t pid = fork();
+  if (pid == 0) {
+    close(p[1]);
+    io_set_fds(p[0], p[0]);
+    Config* recv = config_receive(p[0]);
+    bool ok = recv != NULL;
+    if (ok) {
+      ok = recv->preserve_devices && recv->preserve_specials && recv->copy_devices &&
+           recv->write_devices;
+    }
+    config_delete(recv);
+    close(p[0]);
+    _exit(ok ? 0 : 1);
+  } else {
+    close(p[0]);
+    io_set_fds(p[1], p[1]);
+    bool sent = config_send(p[1], send_cfg);
+    int status;
+    waitpid(pid, &status, 0);
+    close(p[1]);
+    config_delete(send_cfg);
+    EXPECT_TRUE(sent);
+    EXPECT_TRUE(WIFEXITED(status) && WEXITSTATUS(status) == 0);
+  }
+}
+
 void test_config() {
   test_config_lifecycle();
   test_config_ssh_dest();
@@ -1169,6 +1211,7 @@ void test_config() {
     test_config_identity_wire_roundtrip();
     test_config_receive_rejects_invalid_identity();
     test_config_metadata_times_wire_roundtrip();
+    test_config_devices_wire_roundtrip();
     test_config_preallocate_wire_roundtrip();
   }
   test_config_delete_timing_early_helper();

tests/test_file.c

@@ -25,6 +25,26 @@ static void test_file_create() {
   file_destroy(f);
 }
 
+/* rdev/type validation shared by the wire path and the secure recreation site:
+ * a legal char/block major/minor pair is accepted, out-of-range / negative
+ * values and non-device entries carrying an rdev are rejected. */
+static void test_file_special_rdev_valid() {
+  mode_t fake_char = S_IFCHR | 0600;
+  mode_t fake_blk = S_IFBLK | 0600;
+  mode_t fake_fifo = S_IFIFO | 0600;
+  /* char/block devices: accept a legal pair, reject negative / oversized. */
+  EXPECT_TRUE(file_special_rdev_valid(1, 3, fake_char));
+  EXPECT_TRUE(file_special_rdev_valid(0xffff, 0x00ffffff, fake_blk));
+  EXPECT_FALSE(file_special_rdev_valid(-1, 3, fake_char));
+  EXPECT_FALSE(file_special_rdev_valid(1, -1, fake_char));
+  EXPECT_FALSE(file_special_rdev_valid(0x10000, 3, fake_char));
+  EXPECT_FALSE(file_special_rdev_valid(1, 0x1000000, fake_char));
+  /* FIFOs/sockets must carry an empty rdev. */
+  EXPECT_TRUE(file_special_rdev_valid(0, 0, fake_fifo));
+  EXPECT_FALSE(file_special_rdev_valid(1, 0, fake_fifo));
+  EXPECT_FALSE(file_special_rdev_valid(0, 0, (mode_t)(S_IFREG | 0600)));
+}
+
 static void test_file_destroy_null() {
   file_destroy(NULL);
 }
@@ -1004,6 +1024,7 @@ static void test_dir_entry_save_to_disk() {
 
 void test_file() {
   test_file_create();
+  test_file_special_rdev_valid();
   test_file_destroy_null();
   test_file_destroy_normal();
   test_file_load_data();