renet
/
renet
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Shrink the buffers in examples for ease of testing.

v0.7.x
whitequark 2016-12-26 16:29:33 +00:00
parent d7e73a36f0
commit 3917ba5836
3 changed files with 25 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -109,6 +109,8 @@ It responds to:
* UDP packets on port 6969 (`socat stdio udp4-connect:192.168.69.1:6969 <<<"abcdefg"`),
* TCP packets on port 6969 (`socat stdio tcp4-connect:192.168.69.1:6969 <<<"abcdefg"`),
The buffers are only 64 bytes long, for convenience of testing resource exhaustion conditions.
License
-------

21
examples/smoltcpserver.rs
View File

@ -4,6 +4,7 @@ extern crate log;
extern crate env_logger;
extern crate smoltcp;
use std::str;
use std::env;
use std::time::Instant;
use log::{LogLevelFilter, LogRecord};
@ -49,12 +50,12 @@ fn main() {
let endpoint = IpEndpoint::new(IpAddress::default(), 6969);
let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 2048])]);
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 2048])]);
let udp_rx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 64])]);
let udp_tx_buffer = UdpSocketBuffer::new(vec![UdpPacketBuffer::new(vec![0; 64])]);
let udp_socket = UdpSocket::new(endpoint, udp_rx_buffer, udp_tx_buffer);
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; 8192]);
let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; 8192]);
let tcp_rx_buffer = TcpSocketBuffer::new(vec![0; 64]);
let tcp_tx_buffer = TcpSocketBuffer::new(vec![0; 64]);
let mut tcp_socket = TcpSocket::new(tcp_rx_buffer, tcp_tx_buffer);
(tcp_socket.as_socket() : &mut TcpSocket).listen(endpoint);
@ -74,7 +75,8 @@ fn main() {
let socket: &mut UdpSocket = iface.sockets()[0].as_socket();
let client = match socket.recv() {
Ok((endpoint, data)) => {
debug!("udp recv data: {:?} from {}", data, endpoint);
debug!("udp recv data: {} from {}",
str::from_utf8(data.as_ref()).unwrap(), endpoint);
Some(endpoint)
}
Err(Error::Exhausted) => {
@ -87,7 +89,8 @@ fn main() {
};
if let Some(endpoint) = client {
let data = b"yo dawg";
debug!("udp send data: {:?}", data);
debug!("udp send data: {}",
str::from_utf8(data.as_ref()).unwrap());
socket.send_slice(endpoint, data).unwrap()
}
}
@ -97,7 +100,8 @@ fn main() {
let data = {
let mut data = socket.recv(128).to_owned();
if data.len() > 0 {
debug!("tcp recv data: {:?}", &data[..]);
debug!("tcp recv data: {}",
str::from_utf8(data.as_ref()).unwrap());
data = data.split(|&b| b == b'\n').next().unwrap().to_owned();
data.reverse();
data.extend(b"\n");
@ -105,7 +109,8 @@ fn main() {
data
};
if data.len() > 0 {
debug!("tcp send data: {:?}", &data[..]);
debug!("tcp send data: {}",
str::from_utf8(data.as_ref()).unwrap());
socket.send_slice(&data[..]);
}
}

22
src/socket/tcp.rs
View File

@ -266,6 +266,7 @@ impl<'a> TcpSocket<'a> {
/// See also [send](#method.send).
pub fn send_slice(&mut self, data: &[u8]) -> usize {
let buffer = self.send(data.len());
let data = &data[..buffer.len()];
buffer.copy_from_slice(data);
buffer.len()
}
@ -279,7 +280,7 @@ impl<'a> TcpSocket<'a> {
let buffer = self.rx_buffer.dequeue(size);
self.remote_seq_no += buffer.len() as i32;
if buffer.len() > 0 {
net_trace!("tcp:{}:{}: receive {} buffered octets",
net_trace!("tcp:{}:{}: rx buffer: dequeueing {} octets",
self.local_endpoint, self.remote_endpoint, buffer.len());
}
buffer
@ -293,7 +294,8 @@ impl<'a> TcpSocket<'a> {
/// See also [recv](#method.recv).
pub fn recv_slice(&mut self, data: &mut [u8]) -> usize {
let buffer = self.recv(data.len());
data[..buffer.len()].copy_from_slice(buffer);
let data = &mut data[..buffer.len()];
data.copy_from_slice(buffer);
buffer.len()
}
@ -447,12 +449,8 @@ impl<'a> TcpSocket<'a> {
if let Some(ack_number) = repr.ack_number {
let control_len =
if old_state == State::SynReceived { 1 } else { 0 };
if control_len > 0 {
net_trace!("tcp:{}:{}: ACK for a control flag",
self.local_endpoint, self.remote_endpoint);
}
if ack_number - self.local_seq_no - control_len > 0 {
net_trace!("tcp:{}:{}: ACK for {} octets",
net_trace!("tcp:{}:{}: tx buffer: dequeueing {} octets",
self.local_endpoint, self.remote_endpoint,
ack_number - self.local_seq_no - control_len);
}
@ -462,7 +460,7 @@ impl<'a> TcpSocket<'a> {
// Enqueue payload octets, which is guaranteed to be in order, unless we already did.
if repr.payload.len() > 0 {
net_trace!("tcp:{}:{}: receiving {} octets",
net_trace!("tcp:{}:{}: rx buffer: enqueueing {} octets",
self.local_endpoint, self.remote_endpoint, repr.payload.len());
self.rx_buffer.enqueue_slice(repr.payload)
}
@ -604,7 +602,7 @@ mod test {
src_port: LOCAL_PORT, dst_port: REMOTE_PORT,
control: TcpControl::None,
seq_number: 0, ack_number: Some(0),
window_len: 128, payload: &[]
window_len: 64, payload: &[]
};
fn send(socket: &mut TcpSocket, repr: &TcpRepr) -> Result<(), Error> {
@ -684,8 +682,8 @@ mod test {
fn socket() -> TcpSocket<'static> {
init_logger();
let rx_buffer = SocketBuffer::new(vec![0; 128]);
let tx_buffer = SocketBuffer::new(vec![0; 128]);
let rx_buffer = SocketBuffer::new(vec![0; 64]);
let tx_buffer = SocketBuffer::new(vec![0; 64]);
match TcpSocket::new(rx_buffer, tx_buffer) {
Socket::Tcp(socket) => socket,
_ => unreachable!()
@ -840,7 +838,7 @@ mod test {
recv!(s, [TcpRepr {
seq_number: LOCAL_SEQ + 1,
ack_number: Some(REMOTE_SEQ + 1 + 6),
window_len: 122,
window_len: 58,
..RECV_TEMPL
}]);
assert_eq!(s.rx_buffer.dequeue(6), &b"abcdef"[..]);