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
extern crate rand;
use rand::distributions::{IndependentSample, Range};
use std::cmp::min;
use std::io::{self, Read, Write};
pub struct DribbleReader<R: Read> {
source: R,
buffer: Vec<u8>,
used: usize,
available: usize
}
impl<R: Read> DribbleReader<R> {
pub fn new(source: R) -> Self {
DribbleReader{source: source, buffer: vec![0; 64],
used: 0, available: 0}
}
}
impl<R: Read> Read for DribbleReader<R> {
fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
assert!(self.used <= self.available);
if self.used == self.available {
self.used = 0;
self.available = 0;
self.available = try!(self.source.read(&mut self.buffer));
}
if self.available == 0 {
Ok(0)
} else {
let mut rng = rand::thread_rng();
let bytes = min(buf.len(),
min(Range::new(1, 5).ind_sample(&mut rng),
self.available - self.used));
assert!(1 <= bytes && bytes <= 4);
for i in 0..bytes { buf[i] = self.buffer[self.used+i]; }
self.used += bytes;
Ok(bytes)
}
}
}
pub struct DribbleWriter<W: Write> {
dest: W
}
impl<W: Write> DribbleWriter<W> {
pub fn new(dest: W) -> Self {
DribbleWriter{dest: dest}
}
}
impl<W: Write> Write for DribbleWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
let mut rng = rand::thread_rng();
let mut written = 0;
while written < buf.len() {
let bytes = min(buf.len() - written,
Range::new(0, 5).ind_sample(&mut rng));
try!(self.dest.write(&buf[written..written+bytes]));
written += bytes;
}
Ok(written)
}
fn flush(&mut self) -> io::Result<()> {
self.dest.flush()
}
}