Skip to content
Permalink

Comparing changes

Choose two branches to see what’s changed or to start a new pull request. If you need to, you can also or learn more about diff comparisons.

Open a pull request

Create a new pull request by comparing changes across two branches. If you need to, you can also . Learn more about diff comparisons here.
base repository: smoltcp-rs/smoltcp
Failed to load repositories. Confirm that selected base ref is valid, then try again.
Loading
base: 72abe80df84f
Choose a base ref
...
head repository: smoltcp-rs/smoltcp
Failed to load repositories. Confirm that selected head ref is valid, then try again.
Loading
compare: 44aa8db751f1
Choose a head ref
  • 3 commits
  • 3 files changed
  • 1 contributor

Commits on Dec 26, 2016

  1. Copy the full SHA
    0ad1ac0 View commit details
  2. Copy the full SHA
    5b4c4d9 View commit details
  3. Copy the full SHA
    44aa8db View commit details
Showing with 159 additions and 53 deletions.
  1. +2 −2 src/socket/mod.rs
  2. +155 −49 src/socket/tcp.rs
  3. +2 −2 src/socket/udp.rs
4 changes: 2 additions & 2 deletions src/socket/mod.rs
Original file line number Diff line number Diff line change
@@ -69,8 +69,8 @@ impl<'a, 'b> Socket<'a, 'b> {
/// is returned.
///
/// This function is used internally by the networking stack.
pub fn dispatch<F>(&mut self, emit: &mut F) -> Result<(), Error>
where F: FnMut(&IpRepr, &IpPayload) -> Result<(), Error> {
pub fn dispatch<F, R>(&mut self, emit: &mut F) -> Result<R, Error>
where F: FnMut(&IpRepr, &IpPayload) -> Result<R, Error> {
match self {
&mut Socket::Udp(ref mut socket) =>
socket.dispatch(emit),
204 changes: 155 additions & 49 deletions src/socket/tcp.rs
Original file line number Diff line number Diff line change
@@ -267,9 +267,13 @@ impl<'a> TcpSocket<'a> {

// Reject unacceptable acknowledgements.
match (self.state, repr) {
// Don't care about ACKs when performing the handshake.
(State::Listen, _) => (),
(State::SynSent, _) => (),
// The initial SYN cannot contain an acknowledgement.
(State::Listen, TcpRepr { ack_number: Some(_), .. }) => {
net_trace!("tcp:{}:{}: ACK in initial SYN",
self.local_endpoint, self.remote_endpoint);
return Err(Error::Malformed)
}
(State::Listen, TcpRepr { ack_number: None, .. }) => (),
// Every packet after the initial SYN must be an acknowledgement.
(_, TcpRepr { ack_number: None, .. }) => {
net_trace!("tcp:{}:{}: expecting an ACK",
@@ -368,8 +372,8 @@ impl<'a> TcpSocket<'a> {
}

/// See [Socket::dispatch](enum.Socket.html#method.dispatch).
pub fn dispatch<F>(&mut self, emit: &mut F) -> Result<(), Error>
where F: FnMut(&IpRepr, &IpPayload) -> Result<(), Error> {
pub fn dispatch<F, R>(&mut self, emit: &mut F) -> Result<R, Error>
where F: FnMut(&IpRepr, &IpPayload) -> Result<R, Error> {
let mut repr = TcpRepr {
src_port: self.local_endpoint.port,
dst_port: self.remote_endpoint.port,
@@ -480,42 +484,54 @@ mod test {
window_len: 128, payload: &[]
};

fn send(socket: &mut TcpSocket, repr: &TcpRepr) -> Result<(), Error> {
let mut buffer = vec![0; repr.buffer_len()];
let mut packet = TcpPacket::new(&mut buffer).unwrap();
repr.emit(&mut packet, &REMOTE_IP, &LOCAL_IP);
let ip_repr = IpRepr::Unspecified {
src_addr: REMOTE_IP,
dst_addr: LOCAL_IP,
protocol: IpProtocol::Tcp
};
socket.collect(&ip_repr, &packet.into_inner()[..])
}

fn recv<F>(socket: &mut TcpSocket, mut f: F)
where F: FnMut(Result<TcpRepr, Error>) {
let mut buffer = vec![];
let result = socket.dispatch(&mut |ip_repr, payload| {
assert_eq!(ip_repr.protocol(), IpProtocol::Tcp);
assert_eq!(ip_repr.src_addr(), LOCAL_IP);
assert_eq!(ip_repr.dst_addr(), REMOTE_IP);

buffer.resize(payload.buffer_len(), 0);
payload.emit(&ip_repr, &mut buffer[..]);
let packet = TcpPacket::new(&buffer[..]).unwrap();
let repr = try!(TcpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr()));
Ok(f(Ok(repr)))
});
// Appease borrow checker.
match result {
Ok(()) => (),
Err(e) => f(Err(e))
}
}

macro_rules! send {
($socket:ident, $repr:expr) => ({
let repr = $repr;
let mut buffer = vec![0; repr.buffer_len()];
let mut packet = TcpPacket::new(&mut buffer).unwrap();
repr.emit(&mut packet, &REMOTE_IP, &LOCAL_IP);
let ip_repr = IpRepr::Unspecified {
src_addr: REMOTE_IP,
dst_addr: LOCAL_IP,
protocol: IpProtocol::Tcp
};
let result = $socket.collect(&ip_repr, &packet.into_inner()[..]);
result.expect("send error")
})
($socket:ident, [$( $repr:expr )*]) => ({
$( send!($socket, $repr, Ok(())); )*
});
($socket:ident, $repr:expr, $result:expr) =>
(assert_eq!(send(&mut $socket, &$repr), $result))
}

macro_rules! recv {
($socket:ident, $expected:expr) => ({
let result = $socket.dispatch(&mut |ip_repr, payload| {
assert_eq!(ip_repr.protocol(), IpProtocol::Tcp);
assert_eq!(ip_repr.src_addr(), LOCAL_IP);
assert_eq!(ip_repr.dst_addr(), REMOTE_IP);

let mut buffer = vec![0; payload.buffer_len()];
payload.emit(&ip_repr, &mut buffer[..]);
let packet = TcpPacket::new(&buffer[..]).unwrap();
let repr = TcpRepr::parse(&packet, &ip_repr.src_addr(), &ip_repr.dst_addr());
assert_eq!(repr, Ok($expected));
Ok(())
});
assert_eq!(result, Ok(()));
let result = $socket.dispatch(&mut |_repr, _payload| {
Ok(())
});
assert_eq!(result, Err(Error::Exhausted));
})
($socket:ident, [$( $repr:expr )*]) => ({
$( recv!($socket, Ok($repr)); )*
recv!($socket, Err(Error::Exhausted))
});
($socket:ident, $result:expr) =>
(recv(&mut $socket, |repr| assert_eq!(repr, $result)))
}

fn init_logger() {
@@ -554,57 +570,147 @@ mod test {
}

#[test]
fn test_handshake() {
fn test_closed() {
let mut s = socket();
assert_eq!(s.state(), State::Closed);

send!(s, TcpRepr {
control: TcpControl::Syn,
..SEND_TEMPL
}, Err(Error::Rejected));
}

#[test]
fn test_listen() {
let mut s = socket();
s.listen(IpEndpoint::new(IpAddress::default(), LOCAL_PORT));
assert_eq!(s.state(), State::Listen);
}

send!(s, TcpRepr {
#[test]
fn test_handshake() {
let mut s = socket();
s.state = State::Listen;
s.local_endpoint = IpEndpoint::new(IpAddress::default(), LOCAL_PORT);

send!(s, [TcpRepr {
control: TcpControl::Syn,
seq_number: REMOTE_SEQ,
ack_number: None,
..SEND_TEMPL
});
}]);
assert_eq!(s.state(), State::SynReceived);
assert_eq!(s.local_endpoint(), LOCAL_END);
assert_eq!(s.remote_endpoint(), REMOTE_END);
recv!(s, TcpRepr {
recv!(s, [TcpRepr {
control: TcpControl::Syn,
seq_number: LOCAL_SEQ,
ack_number: Some(REMOTE_SEQ + 1),
..RECV_TEMPL
});
send!(s, TcpRepr {
}]);
send!(s, [TcpRepr {
seq_number: REMOTE_SEQ + 1,
ack_number: Some(LOCAL_SEQ + 1),
..SEND_TEMPL
});
}]);
assert_eq!(s.state(), State::Established);
assert_eq!(s.local_seq_no, LOCAL_SEQ + 1);
assert_eq!(s.remote_seq_no, REMOTE_SEQ + 1);
}

#[test]
fn test_recv_data() {
fn test_no_ack() {
let mut s = socket();
s.state = State::Established;
s.state = State::Established;
s.local_endpoint = LOCAL_END;
s.remote_endpoint = REMOTE_END;
s.local_seq_no = LOCAL_SEQ + 1;
s.remote_seq_no = REMOTE_SEQ + 1;

send!(s, TcpRepr {
seq_number: REMOTE_SEQ + 1,
ack_number: None,
..SEND_TEMPL
}, Err(Error::Malformed));
}

#[test]
fn test_bad_ack_listen() {
let mut s = socket();
s.state = State::Listen;
s.local_endpoint = IpEndpoint::new(IpAddress::default(), LOCAL_PORT);

send!(s, TcpRepr {
control: TcpControl::Syn,
seq_number: REMOTE_SEQ,
ack_number: Some(LOCAL_SEQ),
..SEND_TEMPL
}, Err(Error::Malformed));
}

#[test]
fn test_bad_ack_established() {
let mut s = socket();
s.state = State::Established;
s.local_endpoint = LOCAL_END;
s.remote_endpoint = REMOTE_END;
s.local_seq_no = LOCAL_SEQ + 1;
s.remote_seq_no = REMOTE_SEQ + 1;
s.tx_buffer.enqueue_slice(b"abcdef");

// Already acknowledged data.
send!(s, TcpRepr {
seq_number: REMOTE_SEQ + 1,
ack_number: Some(LOCAL_SEQ - 1),
..SEND_TEMPL
}, Err(Error::Malformed));

// Data not yet transmitted.
send!(s, TcpRepr {
seq_number: REMOTE_SEQ + 1,
ack_number: Some(LOCAL_SEQ + 10),
..SEND_TEMPL
}, Err(Error::Malformed));
}

#[test]
fn test_unacceptable_seq() {
let mut s = socket();
s.state = State::Established;
s.local_endpoint = LOCAL_END;
s.remote_endpoint = REMOTE_END;
s.local_seq_no = LOCAL_SEQ + 1;
s.remote_seq_no = REMOTE_SEQ + 1;

// Data outside of receive window.
send!(s, TcpRepr {
seq_number: REMOTE_SEQ + 1 + 256,
ack_number: Some(LOCAL_SEQ + 1),
..SEND_TEMPL
}, Err(Error::Malformed));
}

#[test]
fn test_recv_data() {
let mut s = socket();
s.state = State::Established;
s.local_endpoint = LOCAL_END;
s.remote_endpoint = REMOTE_END;
s.local_seq_no = LOCAL_SEQ + 1;
s.remote_seq_no = REMOTE_SEQ + 1;

send!(s, [TcpRepr {
seq_number: REMOTE_SEQ + 1,
ack_number: Some(LOCAL_SEQ + 1),
payload: &b"abcdef"[..],
..SEND_TEMPL
});
recv!(s, TcpRepr {
}]);
recv!(s, [TcpRepr {
seq_number: LOCAL_SEQ + 1,
ack_number: Some(REMOTE_SEQ + 1 + 6),
window_len: 122,
..RECV_TEMPL
});
}]);
assert_eq!(s.rx_buffer.dequeue(6), &b"abcdef"[..]);
}
}
4 changes: 2 additions & 2 deletions src/socket/udp.rs
Original file line number Diff line number Diff line change
@@ -189,8 +189,8 @@ impl<'a, 'b> UdpSocket<'a, 'b> {
}

/// See [Socket::dispatch](enum.Socket.html#method.dispatch).
pub fn dispatch<F>(&mut self, emit: &mut F) -> Result<(), Error>
where F: FnMut(&IpRepr, &IpPayload) -> Result<(), Error> {
pub fn dispatch<F, R>(&mut self, emit: &mut F) -> Result<R, Error>
where F: FnMut(&IpRepr, &IpPayload) -> Result<R, Error> {
let packet_buf = try!(self.tx_buffer.dequeue());
net_trace!("udp:{}:{}: dispatch {} octets",
self.endpoint, packet_buf.endpoint, packet_buf.size);