taptap 0.1.1

An implementation of the Tigo TAP protocol
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

use std::io::ErrorKind::UnexpectedEof;
use std::io::{BufReader, Read, Write};
use std::mem::size_of;
use std::ops::Add;
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use zerocopy::{big_endian, FromBytes, Immutable, IntoBytes, KnownLayout, Unaligned};

const GZIP_HEADER_COMMENT: &[u8] = b"taptap capture";

#[derive(Debug)]
pub struct Reader<R: Read>(BufReader<flate2::bufread::GzDecoder<BufReader<R>>>);

impl<R: Read> Reader<R> {
    pub fn new(reader: R) -> std::io::Result<Self> {
        let gz = flate2::bufread::GzDecoder::new(BufReader::new(reader));
        if let Some(h) = gz.header() {
            if h.comment() != Some(GZIP_HEADER_COMMENT) {
                // warn?
            }
        }

        Ok(Self(BufReader::new(gz)))
    }
}

impl<R: Read> Iterator for Reader<R> {
    type Item = std::io::Result<(Vec<u8>, SystemTime)>;

    fn next(&mut self) -> Option<Self::Item> {
        let mut record = [0u8; size_of::<Record>()];
        match self.0.read_exact(&mut record) {
            Err(e) if e.kind() == UnexpectedEof => {
                return None;
            }
            Err(e) => return Some(Err(e)),
            Ok(_) => {}
        };

        let record = Record::ref_from_bytes(&record).unwrap(); // infallible
        let mut data = vec![0; record.data_length.get() as usize];
        Some(match self.0.read_exact(&mut data) {
            Err(e) => Err(e),
            Ok(_) => Ok((data, record.timestamp())),
        })
    }
}

#[derive(Debug)]
pub struct Writer<W: Write>(flate2::write::GzEncoder<W>);

impl<W: Write> Writer<W> {
    pub fn new(writer: W) -> std::io::Result<Self> {
        let gz = flate2::GzBuilder::new()
            .comment(GZIP_HEADER_COMMENT)
            .write(writer, flate2::Compression::best());
        Ok(Self(gz))
    }

    pub fn write(&mut self, mut bytes: &[u8], timestamp: SystemTime) -> std::io::Result<()> {
        while bytes.len() > u16::MAX as usize {
            let (left, right) = bytes.split_at(u16::MAX as usize);
            self.write(left, timestamp)?;
            bytes = right;
        }

        assert!(bytes.len() <= u16::MAX as usize);

        let mut buffer = vec![0u8; bytes.len() + size_of::<Record>()];
        let (record, data) = buffer.as_mut_slice().split_at_mut(size_of::<Record>());
        let record = Record::mut_from_bytes(record).unwrap();
        record.set_timestamp(timestamp);
        record.data_length.set(bytes.len() as u16);
        data.copy_from_slice(bytes);

        self.0.write_all(&buffer)
    }

    pub fn flush(&mut self) -> std::io::Result<()> {
        self.0.flush()
    }

    pub fn finish(self) -> std::io::Result<W> {
        self.0.finish()
    }
}

#[derive(
    Debug, Copy, Clone, Eq, PartialEq, FromBytes, IntoBytes, Unaligned, KnownLayout, Immutable,
)]
#[repr(C)]
struct Record {
    /// Number of data bytes in this block
    pub data_length: big_endian::U16,
    // Milliseconds since epoch
    pub timestamp: big_endian::U64,
}

impl Record {
    pub fn timestamp(&self) -> SystemTime {
        UNIX_EPOCH.add(Duration::from_millis(self.timestamp.get()))
    }

    pub fn set_timestamp(&mut self, timestamp: SystemTime) {
        self.timestamp
            .set(timestamp.duration_since(UNIX_EPOCH).unwrap().as_millis() as u64)
    }
}