zbox 0.9.2

ZboxFS is a zero-details, privacy-focused in-app file system.
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

// random error controller
#[cfg(any(feature = "storage-faulty", feature = "storage-zbox-faulty"))]
pub mod imp {
    use std::fmt::{self, Debug};

    use super::super::crypto;
    use zbox::FaultyController;

    pub struct Controller {
        ctl: FaultyController,
        prob: f32,
    }

    impl Controller {
        pub fn new() -> Self {
            Controller {
                ctl: FaultyController::new(),
                prob: 0.05, // set the error probability
            }
        }

        #[inline]
        pub fn reset(&self, seed: &crypto::RandomSeed) {
            self.ctl.reset(&seed.0, self.prob);
        }

        #[inline]
        pub fn turn_on(&self) {
            self.ctl.turn_on();
            //self.ctl.turn_off();
        }

        #[inline]
        pub fn turn_off(&self) {
            self.ctl.turn_off();
        }
    }

    impl Debug for Controller {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            f.debug_struct("Controller").finish()
        }
    }
}

#[cfg(not(any(feature = "storage-faulty", feature = "storage-zbox-faulty")))]
#[allow(dead_code)]
pub mod imp {
    use super::super::crypto;

    #[derive(Debug)]
    pub struct Controller {}

    impl Controller {
        pub fn new() -> Self {
            Controller {}
        }

        pub fn reset(&self, _seed: &crypto::RandomSeed) {}

        pub fn turn_on(&self) {}

        pub fn turn_off(&self) {}
    }
}