nbd 0.3.1

Rust library for NBD (network block device) servers and clients.
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

#[macro_use]
extern crate proptest;
extern crate nbd;
extern crate pipe;
extern crate readwrite;

use proptest::prelude::{prop, Just, ProptestConfig, Strategy};
use proptest::string::bytes_regex;

use std::io::{Cursor, Read, Result, Seek, SeekFrom, Write};

use readwrite::ReadWrite;

#[derive(Debug, Eq, PartialEq)]
enum Action {
    Seek(u64),
    Write(usize),
    Read(usize),
}

const SS: u64 = 1024 * 1024;

prop_compose! {
    fn biased_size()(x in 0..32usize, y in 0..3u8) -> usize {
        if y == 0 {
            x
        } else {
            x % 6
        }
    }
}

fn gen_action() -> impl Strategy<Value = Action> {
    prop_oneof! {
        (0..SS).prop_map(Action::Seek),
        biased_size().prop_map(Action::Write),
        biased_size().prop_map(Action::Read),
    }
}

fn gen_chunk() -> impl Strategy<Value = Vec<u8>> {
    prop_oneof! {
        Just(b"\x25\x60\x95\x13".to_vec()),
        Just(b"\x67\x44\x66\x98".to_vec()),
        Just(b"\x00\x00\x00".to_vec()),
        Just(b"\x00\x00\x00\x00\x00\x00\x00[\x00-\x1F]".to_vec()),
        Just(b"\x00\x00".to_vec()),
        Just(b"\xFF\xFF".to_vec()),
        bytes_regex(".").unwrap(),
        bytes_regex("\x00[\x01-\x09]").unwrap(),
    }
}

fn get_random_socket(chunks: Vec<Vec<u8>>) -> impl Read + Write {
    let input: Vec<u8> = chunks.iter().flatten().map(|x| *x).collect();
    let socket = ReadWrite::new(Cursor::new(input), ::std::io::sink());
    socket
}

struct FakeStorage;

impl Read for FakeStorage {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
        Ok(buf.len())
    }
}
impl Write for FakeStorage {
    fn write(&mut self, buf: &[u8]) -> Result<usize> {
        Ok(buf.len())
    }
    fn flush(&mut self) -> Result<()> {
        Ok(())
    }
}
impl Seek for FakeStorage {
    fn seek(&mut self, _: SeekFrom) -> Result<u64> {
        Ok(1024_000)
    }
}

proptest! {
    #![proptest_config(ProptestConfig {
        cases: 20_000,
        .. ProptestConfig::default()
    })]

    #[test]
    fn fuzz_client_transmission(chunks in prop::collection::vec(gen_chunk(),3..30),
                                script in prop::collection::vec(gen_action(),3..12),
        ) {
        let s = get_random_socket(chunks);
        let mut exp = nbd::client::Export::default();
        exp.size = SS;
        let mut client = nbd::client::NbdClient::new(s, &exp);

        let mut buf = vec![0;4096];

        let mut succ = 0;

        for i in script {
            match i {
                Action::Seek(pos) => {
                    client.seek(SeekFrom::Start(pos)).unwrap();
                },
                Action::Write(sz) => {
                    if sz > 0 {
                        if client.write(&buf[0..sz]).is_ok() { succ += 1; }
                    }
                },
                Action::Read(sz) => {
                    if sz > 0 {
                        if client.read(&mut buf[0..sz]).is_ok() { succ += 1; }
                    }
                },
            }
        }

        if succ > 1 {
            eprintln!("succ={}", succ);
        }
    }


    #[test]
    fn fuzz_server_transmission(chunks in prop::collection::vec(gen_chunk(),3..12)) {
        let s = get_random_socket(chunks);
        let ret = nbd::server::transmission(s, FakeStorage);
        if ret.is_ok() {
            eprintln!("Happy");
        }
    }
}