ffsync 1.2.0

Chunk-level file synchronization for big files and fast links
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use ffsync::protocol::framing::Frame;
use ffsync::protocol::message::*;
use std::path::PathBuf;

fn dump(name: &str, dir: &str, frame: Frame) {
    let p = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
        .join("fuzz/corpus")
        .join(dir);
    std::fs::create_dir_all(&p).unwrap();
    std::fs::write(p.join(name), frame.payload).unwrap();
}

#[test]
fn dump_fuzz_corpus() {
    // Hello (valid + variations)
    let h = Hello {
        version: ffsync::protocol::VERSION,
        flags: FLAG_TRUST_TIMES,
        role: Role::Sender,
        cdc_min: 16384,
        cdc_avg: 65536,
        cdc_max: 262144,
        file_size: 1024,
        file_mtime: 1_700_000_000,
        file_mtime_nanos: 5,
        path: "a.bin".into(),
    };
    dump("hello_valid", "hello", h.clone().into_frame().unwrap());
    dump(
        "hello_zero",
        "hello",
        Hello {
            version: 4,
            flags: 0,
            role: Role::Receiver,
            cdc_min: 0,
            cdc_avg: 0,
            cdc_max: 0,
            file_size: 0,
            file_mtime: 0,
            file_mtime_nanos: 0,
            path: String::new(),
        }
        .into_frame()
        .unwrap(),
    );
    // ManifestChunk
    let mc = ManifestChunk {
        hash: blake3::Hash::from_bytes([7u8; 32]),
        offset: 4096,
        length: 65536,
    };
    dump("mc_valid", "manifest", mc.into_frame().unwrap());
    // PlanEntry
    let pl = PlanEntry::Local {
        target_offset: 0,
        length: 65536,
        source_offset: 8192,
        hash: blake3::Hash::from_bytes([1u8; 32]),
    };
    dump("plan_local", "plan", pl.into_frame().unwrap());
    let pr = PlanEntry::Remote {
        target_offset: 65536,
        length: 262144,
        hash: blake3::Hash::from_bytes([2u8; 32]),
    };
    dump("plan_remote", "plan", pr.into_frame().unwrap());
    // TreeBegin with entries (metadata + excludes + parallel)
    let tb = TreeBegin {
        flags: TREE_FLAG_PARALLEL | TREE_FLAG_METADATA | TREE_FLAG_EXCLUDES | TREE_FLAG_NEGATION,
        parallel: 4,
        excludes: vec!["*.log".into(), "!keep.log".into()],
        entries: vec![
            TreeEntryWire {
                rel_path: "a/b/c.bin".into(),
                kind: 0,
                size: 12345,
                mtime_secs: 1_700_000_000,
                mtime_nanos: 9,
                mode: 0o644,
            },
            TreeEntryWire {
                rel_path: "d/".into(),
                kind: 1,
                size: 0,
                mtime_secs: 0,
                mtime_nanos: 0,
                mode: 0,
            },
        ],
    };
    dump("tree_begin_full", "tree_begin", tb.into_frame().unwrap());
    dump(
        "tree_begin_min",
        "tree_begin",
        TreeBegin {
            flags: 0,
            parallel: 0,
            excludes: vec![],
            entries: vec![],
        }
        .into_frame()
        .unwrap(),
    );
    // Tree small frames
    dump(
        "tw",
        "tree_small",
        TreeWorker { worker_index: 3 }.into_frame().unwrap(),
    );
    dump(
        "tf",
        "tree_small",
        TreeFile {
            rel_path: "x/y.txt".into(),
        }
        .into_frame()
        .unwrap(),
    );
    dump(
        "te",
        "tree_small",
        TreeEnd {
            deleted_count: 2,
            deleted_bytes: 999,
        }
        .into_frame()
        .unwrap(),
    );
    dump(
        "err",
        "tree_small",
        encode_error(ErrorCode::BadFrame, "boom").unwrap(),
    );
    // framing corpus: raw byte streams with valid + invalid length prefixes (fuzz_frame reads raw bytes)
    let p = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/frame");
    std::fs::create_dir_all(&p).unwrap();
    let mut stream = Vec::new();
    stream.extend_from_slice(&4u32.to_le_bytes());
    stream.extend_from_slice(&ffsync::protocol::framing::T_HELLO.to_le_bytes());
    stream.extend_from_slice(b"FFSY");
    std::fs::write(p.join("tiny_valid"), &stream).unwrap();
    let mut bad = Vec::new();
    bad.extend_from_slice(&u32::MAX.to_le_bytes()); // absurd length -> MAX_PAYLOAD guard
    std::fs::write(p.join("absurd_len"), &bad).unwrap();
    std::fs::write(p.join("empty"), b"").unwrap();
    // The full fuzz/corpus dir is gitignored; this test only seeds it.
}