3812114777

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/ensc/r-tftpd/commit/<a class=hub.com/ensc/r-tftpd/commit/<a class="double-link" href="https://git"><a class=hub.com/ensc/r-tftpd/commit/<a class="double-link" href="https://git"><a class=hub.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953ee1c3a69e">70efa4f51<a href="https://github.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953ee1c3a69e">&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ensc/r-tftpd/commit/&lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ensc/r-tftpd/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://git&quot;&gt;&amp;lt;a class=&lt;/a&gt;hub.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953ee1c3a69e&quot;&gt;70efa4f51&lt;/a&gt;&lt;a href=&quot;https://github.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953ee1c3a69e&quot;&gt;&amp;lt;a href=&amp;quot;https://github.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953e&lt;/a&gt;e1c3a69e">&quot;&gt;Merge &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ensc/r-tftpd/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ensc/r-tftpd/commit/<a class="double-link" href="https://github.com/ensc/r-tftpd/commit/b1a09b2564b4d421a8727aef3363504c00323808">b1a09b256</a><a href="https://github.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953ee1c3a69e">&amp;quot;&amp;gt;b1a09b256&amp;lt;/a&amp;gt;&amp;quot;&amp;gt;b1a09b256&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/ensc/r-tftpd/commit/70efa4f51b76c9447bd357597f0d953ee1c3a&lt;/a&gt;69e&quot;&gt; into &lt;/a&gt;&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/ensc/r-tftpd/commit/<a class="double-link" href="https://github.com/ensc/r-tftpd/commit/1e06521c6">1e06521c6">1e06521c6</a>

Pull Request Pull Request #3: Next

Run Details

45 of 45 new or added lines in 7 files covered. (100.0%)

2036 of 5030 relevant lines covered (40.48%)

879.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

82.91

/src/tftp/datagram.rs

use std::time::Duration;

use crate::{ Error, Result };
use crate::util::{ UdpSocket, SocketAddr };
use super::{ Request, RequestError as E, RequestResult, SequenceId };

#[derive(Debug)]
pub enum Datagram<'a> {
    Read(Request<'a>),
    Write(Request<'a>),
    Data(SequenceId, &'a[u8]),
    Ack(SequenceId),
    Error(u16, &'a[u8]),
    OAck
}

impl std::fmt::Display for Datagram<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::Read(r)        => write!(f, "RRQ({r:?})"),
            Self::Write(r)        => write!(f, "WRQ({r:?})"),
            Self::Data(id, d)        => write!(f, "DATA({}, ..{})", id, d.len()),
            Self::Ack(id)        => write!(f, "ACK({id}"),
            Self::Error(err, s)        => write!(f, "ERROR({}, \"{}\")", err, String::from_utf8_lossy(s)),
            Self::OAck                => write!(f, "OACK"),
        }
    }
}

trait TftpSlice {
    fn assert_len(&self, sz: usize) -> RequestResult<()>;
    fn get_u16(&self, idx: usize) -> u16;
    fn get_sequence_id(&self, idx: usize) -> SequenceId;
}

impl TftpSlice for &[u8]
{
    fn assert_len(&self, sz: usize) -> RequestResult<()>
    {
        if self.len() < sz {
            return Err(E::TooShort);
        }

        Ok(())
    }

    fn get_u16(&self, idx: usize) -> u16
    {
        (self[idx] as u16) << 8 | (self[idx + 1] as u16)
    }

    fn get_sequence_id(&self, idx: usize) -> SequenceId
    {
        SequenceId::new(self.get_u16(idx))
    }
}

impl <'a> TryFrom<&'a[u8]> for Datagram<'a> {
    type Error = Error;

    #[instrument(level = "trace", skip(v), ret)]
    fn try_from(v: &'a [u8]) -> Result<Self> {
        use super::request::Dir;

        v.assert_len(2)?;
        let op = v.get_u16(0);

        Ok(match op {
            // RRQ
            1        => {
                v.assert_len(2 + 1)?;
                Datagram::Read(Request::from_slice(&v[2..], Dir::Read)?)
            },

            // WRQ
            2        => {
                v.assert_len(2 + 1)?;
                Datagram::Write(Request::from_slice(&v[2..], Dir::Write)?)
            },

            // DATA
            3        => {
                v.assert_len(2 + 2)?;
                Datagram::Data(v.get_sequence_id(2), &v[4..])
            },

            // ACK
            4 if v.len() == 4        => Datagram::Ack(v.get_sequence_id(2)),
            4        => Err(E::MalformedAck)?,

            // ERROR
            5 if v.last() == Some(&b'\0')                => {
                v.assert_len(2 + 2 + 1)?;
                Datagram::Error(v.get_u16(2), &v[4..v.len() - 1])
            },
            5        => Err(E::MissingZero)?,

            // OACK (received on client side only)
            6        => Datagram::OAck,
            _        => Err(E::BadOpCode(op))?,
        })
    }
}

impl <'a> Datagram<'a> {
    async fn recv_inner(sock: &UdpSocket,
                        buf: &'a mut [u8], exp_addr: &SocketAddr) -> Result<Datagram<'a>>
    {
        loop {
            let (len, addr) = sock.recvfrom(buf).await?;

            if &addr != exp_addr {
                error!("unexpected address: {} vs {}", addr, exp_addr);
                // TODO: audit this event?
                continue;
            }

            return Self::try_from(&buf[0..len])
        }
    }

    pub async fn recv(sock: &UdpSocket,
                      buf: &'a mut [u8], exp_addr: &SocketAddr, to: Duration) -> Result<Datagram<'a>>
    {
        use tokio::time::timeout;

        timeout(to, Self::recv_inner(sock, buf, exp_addr)).await
            .map_err(|_| Error::Timeout)
            .and_then(|v| v)
    }

    pub fn is_ack(&self) -> bool {
        matches!(self, Self::Ack(_))
    }

    pub fn get_data_len(&self) -> usize {
        match self {
            &Self::Data(_, d)        => d.len(),
            _                        => 0,
        }
    }
}

#[cfg(test)]
mod test {
    use super::*;

    macro_rules! assert_datagram {
        ($v:expr, $pat:pat) => {
            assert_datagram!($v, $pat, true)
        };

        ($v:expr, $pat:pat, $test:expr) => {
            assert_datagram!($v, pat => Ok($pat), test => $test)
        };

        ($v:expr, err => $pat:pat) => {
            assert_datagram!($v, pat => Err(Error::RequestError($pat)), test => true)
        };

        ($v:expr, err => $pat:pat, $test:expr) => {
            assert_datagram!($v, pat => Err(Error::RequestError($pat)), test => $test)
        };

        ($v:expr, pat => $pat:pat, test => $test:expr) => {
            match Datagram::try_from($v as &[u8]) {
                $pat if $test                => {},
                Ok(v)                        => panic!("bad result {}", v),
                Err(e)                        => panic!("err {:?}", e),
            }
        };
    }

    #[test]
    #[allow(unused_variables)]
    fn test_datagram() {
        use super::super::RequestError as RE;

        // RRQ
        assert_datagram!(b"\x00\x01file\x00octet\x00",    Datagram::Read(_rrq));
        assert_datagram!(b"\x00\x01file\x00netascii\x00", Datagram::Read(_rrq));
        assert_datagram!(b"\x00\x01file\x00binary\x00",   Datagram::Read(_rrq));
        assert_datagram!(b"\x00\x01file\x00mail\x00",     Datagram::Read(_rrq));
        assert_datagram!(b"\x00\x01file\x00mail\x00",     Datagram::Read(_rrq));

        assert_datagram!(b"\x00\x01file\x00XXX\x00", err => RE::BadMode);
        assert_datagram!(b"\x00\x01file\x00octet",   err => RE::MissingZero);
        assert_datagram!(b"\x00\x01file\x00",        err => RE::MissingMode);
        assert_datagram!(b"\x00\x01file",            err => RE::MissingZero);
        assert_datagram!(b"\x00\x01",                err => RE::TooShort);

        assert_datagram!(b"\x00\x01file\x00octet\x00\
                           blksize\x002000\x00\
                           unsupported\x001234\x00\
                           timeout\x005\x00\
                           tsize\x000\x00\
                           windowsize\x0064\x00", Datagram::Read(rrq),
                         rrq.get_filename().to_str().unwrap() == "file" &&
                         rrq.mode == super::super::Mode::Octet &&
                         rrq.block_size == Some(2000) &&
                         rrq.timeout == Some(std::time::Duration::from_secs(5)) &&
                         rrq.tsize == Some(0) &&
                         rrq.window_size == Some(64));

        assert_datagram!(b"\x00\x01file\x00octet\x00\
                           tsize\x0042\x00", err => RE::NumberOutOfRange);

        assert_datagram!(b"\x00\x01file\x00octet\x00\
                           tsize\x0042\x00", err => RE::NumberOutOfRange);

        assert_datagram!(b"\x00\x01file\x00octet\x00\
                           windowsize\x000\x00", err => RE::NumberOutOfRange);

        assert_datagram!(b"\x00\x01file\x00octet\x00\
                           blksize\x007\x00", err => RE::NumberOutOfRange);

        // WRQ
        assert_datagram!(b"\x00\x02file\x00octet\x00",    Datagram::Write(_wrq));
        assert_datagram!(b"\x00\x02file\x00octet\x00\
                           tsize\x0042\x00", Datagram::Write(wrq),
                         wrq.get_filename().to_str().unwrap() == "file" &&
                         wrq.mode == super::super::Mode::Octet &&
                         wrq.tsize == Some(42));

        // DATA
        assert_datagram!(b"\x00\x03\x01\x02data" as &[u8], Datagram::Data(seq, data),
                         seq.as_u16() == 0x0102 && data == b"data");

        // ACK
        assert_datagram!(b"\x00\x04\x01\x02", Datagram::Ack(seq),
                         seq.as_u16() == 0x0102);

        assert_datagram!(b"\x00\x04\x01\x02X", err => RE::MalformedAck);

        // ERROR
        assert_datagram!(b"\x00\x05\x01\x02error\x00", Datagram::Error(code, msg),
                         code == 0x0102 && msg == b"error");
        assert_datagram!(b"\x00\x05\x01\x02\x00", Datagram::Error(code, msg),
                         code == 0x0102 && msg == b"");

        assert_datagram!(b"\x00\x05\x01\x02error", err => RE::MissingZero);

        // OACK
        assert_datagram!(b"\x00\x06...", Datagram::OAck);

        // misc errors
        assert_datagram!(b"\x00\x07", err => RE::BadOpCode(c), c == 7);
        assert_datagram!(b"\x00",     err => RE::TooShort);
        assert_datagram!(b"",         err => RE::TooShort);
    }
}

1	use std::time::Duration;	×
2
3	use crate::{ Error, Result };
4	use crate::util::{ UdpSocket, SocketAddr };
5	use super::{ Request, RequestError as E, RequestResult, SequenceId };
6
7	#[derive(Debug)]	20✔
8	pub enum Datagram<'a> {
9	Read(Request<'a>),	×
10	Write(Request<'a>),	×
11	Data(SequenceId, &'a[u8]),	20✔
12	Ack(SequenceId),	×
13	Error(u16, &'a[u8]),	×
14	OAck
15	}
16
17	impl std::fmt::Display for Datagram<'_> {
18	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
19	match self {	×
20	Self::Read(r) => write!(f, "RRQ({r:?})"),	×
21	Self::Write(r) => write!(f, "WRQ({r:?})"),	×
22	Self::Data(id, d) => write!(f, "DATA({}, ..{})", id, d.len()),	×
23	Self::Ack(id) => write!(f, "ACK({id}"),	×
24	Self::Error(err, s) => write!(f, "ERROR({}, \"{}\")", err, String::from_utf8_lossy(s)),	×
25	Self::OAck => write!(f, "OACK"),	×
26	}
27	}	×
28	}
29
30	trait TftpSlice {
31	fn assert_len(&self, sz: usize) -> RequestResult<()>;
32	fn get_u16(&self, idx: usize) -> u16;
33	fn get_sequence_id(&self, idx: usize) -> SequenceId;
34	}
35
36	impl TftpSlice for &[u8]
37	{
38	fn assert_len(&self, sz: usize) -> RequestResult<()>	1,245✔
39	{
40	if self.len() < sz {	1,245✔
41	return Err(E::TooShort);	3✔
42	}
43
44	Ok(())	1,242✔
45	}	1,245✔
46
47	fn get_u16(&self, idx: usize) -> u16	2,317✔
48	{
49	(self[idx] as u16) << 8 \| (self[idx + 1] as u16)	2,317✔
50	}	2,317✔
51
52	fn get_sequence_id(&self, idx: usize) -> SequenceId	1,128✔
53	{
54	SequenceId::new(self.get_u16(idx))	1,128✔
55	}	1,128✔
56	}
57
58	impl <'a> TryFrom<&'a[u8]> for Datagram<'a> {
59	type Error = Error;
60
61	#[instrument(level = "trace", skip(v), ret)]	3,567✔
62	fn try_from(v: &'a [u8]) -> Result<Self> {
63	use super::request::Dir;
64
65	v.assert_len(2)?;	1,189✔
66	let op = v.get_u16(0);	1,187✔
67
68	Ok(match op {	2,362✔
69	// RRQ
70	1 => {
71	v.assert_len(2 + 1)?;	51✔
72	Datagram::Read(Request::from_slice(&v[2..], Dir::Read)?)	50✔
73	},	42✔
74
75	// WRQ
76	2 => {
77	v.assert_len(2 + 1)?;	2✔
78	Datagram::Write(Request::from_slice(&v[2..], Dir::Write)?)	2✔
79	},	2✔
80
81	// DATA
82	3 => {
83	v.assert_len(2 + 2)?;	1✔
84	Datagram::Data(v.get_sequence_id(2), &v[4..])	1✔
85	},	1✔
86
87	// ACK
88	4 if v.len() == 4 => Datagram::Ack(v.get_sequence_id(2)),	1,128✔
89	4 => Err(E::MalformedAck)?,	1✔
90
91	// ERROR
92	5 if v.last() == Some(&b'\0') => {	3✔
93	v.assert_len(2 + 2 + 1)?;	2✔
94	Datagram::Error(v.get_u16(2), &v[4..v.len() - 1])	2✔
95	},	2✔
96	5 => Err(E::MissingZero)?,	1✔
97
98	// OACK (received on client side only)
99	6 => Datagram::OAck,	1✔
100	_ => Err(E::BadOpCode(op))?,	1✔
101	})
102	}
103	}
104
105	impl <'a> Datagram<'a> {
106	async fn recv_inner(sock: &UdpSocket,	2,252✔
107	buf: &'a mut [u8], exp_addr: &SocketAddr) -> Result<Datagram<'a>>	1,126✔
108	{	3,376✔
109	loop {	1,126✔
110	let (len, addr) = sock.recvfrom(buf).await?;	2,250✔
111
112	if &addr != exp_addr {	1,126✔
113	error!("unexpected address: {} vs {}", addr, exp_addr);	×
114	// TODO: audit this event?
115	continue;
116	}
117
118	return Self::try_from(&buf[0..len])	1,126✔
119	}
120	}	2,252✔
121
122	pub async fn recv(sock: &UdpSocket,	2,252✔
123	buf: &'a mut [u8], exp_addr: &SocketAddr, to: Duration) -> Result<Datagram<'a>>	1,126✔
124	{	3,376✔
125	use tokio::time::timeout;
126
127	timeout(to, Self::recv_inner(sock, buf, exp_addr)).await	2,250✔
128	.map_err(\|_\| Error::Timeout)	×
129	.and_then(\|v\| v)	1,126✔
130	}	2,252✔
131
132	pub fn is_ack(&self) -> bool {	×
133	matches!(self, Self::Ack(_))	×
134	}	×
135
136	pub fn get_data_len(&self) -> usize {	1,098✔
137	match self {	1,098✔
138	&Self::Data(_, d) => d.len(),	1,098✔
139	_ => 0,	×
140	}
141	}	1,098✔
142	}
143
144	#[cfg(test)]
145	mod test {
146	use super::*;
147
148	macro_rules! assert_datagram {
149	($v:expr, $pat:pat) => {
150	assert_datagram!($v, $pat, true)
151	};
152
153	($v:expr, $pat:pat, $test:expr) => {
154	assert_datagram!($v, pat => Ok($pat), test => $test)
155	};
156
157	($v:expr, err => $pat:pat) => {
158	assert_datagram!($v, pat => Err(Error::RequestError($pat)), test => true)
159	};
160
161	($v:expr, err => $pat:pat, $test:expr) => {
162	assert_datagram!($v, pat => Err(Error::RequestError($pat)), test => $test)
163	};
164
165	($v:expr, pat => $pat:pat, test => $test:expr) => {
166	match Datagram::try_from($v as &[u8]) {
167	$pat if $test => {},
168	Ok(v) => panic!("bad result {}", v),
169	Err(e) => panic!("err {:?}", e),
170	}
171	};
172	}
173
174	#[test]
175	#[allow(unused_variables)]
176	fn test_datagram() {	2✔
177	use super::super::RequestError as RE;
178
179	// RRQ
180	assert_datagram!(b"\x00\x01file\x00octet\x00", Datagram::Read(_rrq));	1✔
181	assert_datagram!(b"\x00\x01file\x00netascii\x00", Datagram::Read(_rrq));	1✔
182	assert_datagram!(b"\x00\x01file\x00binary\x00", Datagram::Read(_rrq));	1✔
183	assert_datagram!(b"\x00\x01file\x00mail\x00", Datagram::Read(_rrq));	1✔
184	assert_datagram!(b"\x00\x01file\x00mail\x00", Datagram::Read(_rrq));	1✔
185
186	assert_datagram!(b"\x00\x01file\x00XXX\x00", err => RE::BadMode);	1✔
187	assert_datagram!(b"\x00\x01file\x00octet", err => RE::MissingZero);	1✔
188	assert_datagram!(b"\x00\x01file\x00", err => RE::MissingMode);	1✔
189	assert_datagram!(b"\x00\x01file", err => RE::MissingZero);	1✔
190	assert_datagram!(b"\x00\x01", err => RE::TooShort);	1✔
191
192	assert_datagram!(b"\x00\x01file\x00octet\x00\	1✔
193	blksize\x002000\x00\
194	unsupported\x001234\x00\
195	timeout\x005\x00\
196	tsize\x000\x00\
197	windowsize\x0064\x00", Datagram::Read(rrq),	2✔
198	rrq.get_filename().to_str().unwrap() == "file" &&	1✔
199	rrq.mode == super::super::Mode::Octet &&	1✔
200	rrq.block_size == Some(2000) &&	1✔
201	rrq.timeout == Some(std::time::Duration::from_secs(5)) &&	1✔
202	rrq.tsize == Some(0) &&	1✔
203	rrq.window_size == Some(64));	1✔
204
205	assert_datagram!(b"\x00\x01file\x00octet\x00\	1✔
206	tsize\x0042\x00", err => RE::NumberOutOfRange);
207
208	assert_datagram!(b"\x00\x01file\x00octet\x00\	1✔
209	tsize\x0042\x00", err => RE::NumberOutOfRange);
210
211	assert_datagram!(b"\x00\x01file\x00octet\x00\	1✔
212	windowsize\x000\x00", err => RE::NumberOutOfRange);
213
214	assert_datagram!(b"\x00\x01file\x00octet\x00\	1✔
215	blksize\x007\x00", err => RE::NumberOutOfRange);
216
217	// WRQ
218	assert_datagram!(b"\x00\x02file\x00octet\x00", Datagram::Write(_wrq));	1✔
219	assert_datagram!(b"\x00\x02file\x00octet\x00\	1✔
220	tsize\x0042\x00", Datagram::Write(wrq),	2✔
221	wrq.get_filename().to_str().unwrap() == "file" &&	1✔
222	wrq.mode == super::super::Mode::Octet &&	1✔
223	wrq.tsize == Some(42));	1✔
224
225	// DATA
226	assert_datagram!(b"\x00\x03\x01\x02data" as &[u8], Datagram::Data(seq, data),	2✔
227	seq.as_u16() == 0x0102 && data == b"data");	1✔
228
229	// ACK
230	assert_datagram!(b"\x00\x04\x01\x02", Datagram::Ack(seq),	1✔
231	seq.as_u16() == 0x0102);	1✔
232
233	assert_datagram!(b"\x00\x04\x01\x02X", err => RE::MalformedAck);	1✔
234
235	// ERROR
236	assert_datagram!(b"\x00\x05\x01\x02error\x00", Datagram::Error(code, msg),	2✔
237	code == 0x0102 && msg == b"error");	1✔
238	assert_datagram!(b"\x00\x05\x01\x02\x00", Datagram::Error(code, msg),	2✔
239	code == 0x0102 && msg == b"");	1✔
240
241	assert_datagram!(b"\x00\x05\x01\x02error", err => RE::MissingZero);	1✔
242
243	// OACK
244	assert_datagram!(b"\x00\x06...", Datagram::OAck);	1✔
245
246	// misc errors
247	assert_datagram!(b"\x00\x07", err => RE::BadOpCode(c), c == 7);	1✔
248	assert_datagram!(b"\x00", err => RE::TooShort);	1✔
249	assert_datagram!(b"", err => RE::TooShort);	1✔
250	}	2✔
251	}

ensc / r-tftpd / 3812114777

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous