From a3481537d9067f1da8a9538225706aefbea176e7 Mon Sep 17 00:00:00 2001 From: whitequark Date: Tue, 20 Dec 2016 13:56:59 +0000 Subject: [PATCH] Add some sanity into buffer names (avoid clases with wire::*). --- examples/smoltcpserver.rs | 6 +++--- src/socket/mod.rs | 6 +++--- src/socket/tcp.rs | 10 +++++----- src/socket/udp.rs | 35 ++++++++++++++++++----------------- 4 files changed, 29 insertions(+), 28 deletions(-) diff --git a/examples/smoltcpserver.rs b/examples/smoltcpserver.rs index 69992a8..44ef93e 100644 --- a/examples/smoltcpserver.rs +++ b/examples/smoltcpserver.rs @@ -6,7 +6,7 @@ use smoltcp::Error; use smoltcp::phy::{Tracer, TapInterface}; use smoltcp::wire::{EthernetFrame, EthernetAddress, IpAddress, IpEndpoint}; use smoltcp::iface::{SliceArpCache, EthernetInterface}; -use smoltcp::socket::{UdpSocket, AsSocket, UdpBuffer, UdpPacket}; +use smoltcp::socket::{UdpSocket, AsSocket, UdpSocketBuffer, UdpPacketBuffer}; fn main() { let ifname = env::args().nth(1).unwrap(); @@ -21,8 +21,8 @@ fn main() { let listen_address = IpAddress::v4(0, 0, 0, 0); let endpoint = IpEndpoint::new(listen_address, 6969); - let udp_rx_buffer = UdpBuffer::new(vec![UdpPacket::new(vec![0; 2048])]); - let udp_tx_buffer = UdpBuffer::new(vec![UdpPacket::new(vec![0; 2048])]); + 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_socket = UdpSocket::new(endpoint, udp_rx_buffer, udp_tx_buffer); let mut sockets = [udp_socket]; diff --git a/src/socket/mod.rs b/src/socket/mod.rs index 43c46b6..ebc55a6 100644 --- a/src/socket/mod.rs +++ b/src/socket/mod.rs @@ -16,11 +16,11 @@ use wire::{IpAddress, IpProtocol}; mod udp; mod tcp; -pub use self::udp::Packet as UdpPacket; -pub use self::udp::Buffer as UdpBuffer; +pub use self::udp::PacketBuffer as UdpPacketBuffer; +pub use self::udp::SocketBuffer as UdpSocketBuffer; pub use self::udp::UdpSocket as UdpSocket; -pub use self::tcp::Buffer as TcpBuffer; +pub use self::tcp::SocketBuffer as TcpSocketBuffer; /// A packet representation. /// diff --git a/src/socket/tcp.rs b/src/socket/tcp.rs index 09df781..8c69ae2 100644 --- a/src/socket/tcp.rs +++ b/src/socket/tcp.rs @@ -2,17 +2,17 @@ use Managed; /// A TCP stream ring buffer. #[derive(Debug)] -pub struct Buffer<'a> { +pub struct SocketBuffer<'a> { storage: Managed<'a, [u8]>, read_at: usize, length: usize } -impl<'a> Buffer<'a> { +impl<'a> SocketBuffer<'a> { /// Create a packet buffer with the given storage. - pub fn new(storage: T) -> Buffer<'a> + pub fn new(storage: T) -> SocketBuffer<'a> where T: Into> { - Buffer { + SocketBuffer { storage: storage.into(), read_at: 0, length: 0 @@ -62,7 +62,7 @@ mod test { #[test] fn test_buffer() { - let mut buffer = Buffer::new(vec![0; 8]); // ........ + let mut buffer = SocketBuffer::new(vec![0; 8]); // ........ buffer.enqueue(6).copy_from_slice(b"foobar"); // foobar.. assert_eq!(buffer.dequeue(3), b"foo"); // ...bar.. buffer.enqueue(6).copy_from_slice(b"ba"); // ...barba diff --git a/src/socket/udp.rs b/src/socket/udp.rs index c33f924..4b3c0f0 100644 --- a/src/socket/udp.rs +++ b/src/socket/udp.rs @@ -6,17 +6,17 @@ use socket::{Socket, PacketRepr}; /// A buffered UDP packet. #[derive(Debug)] -pub struct Packet<'a> { +pub struct PacketBuffer<'a> { endpoint: IpEndpoint, size: usize, payload: Managed<'a, [u8]> } -impl<'a> Packet<'a> { +impl<'a> PacketBuffer<'a> { /// Create a buffered packet. - pub fn new(payload: T) -> Packet<'a> + pub fn new(payload: T) -> PacketBuffer<'a> where T: Into> { - Packet { + PacketBuffer { endpoint: IpEndpoint::INVALID, size: 0, payload: payload.into() @@ -34,23 +34,23 @@ impl<'a> Packet<'a> { /// An UDP packet ring buffer. #[derive(Debug)] -pub struct Buffer<'a, 'b: 'a> { - storage: Managed<'a, [Packet<'b>]>, +pub struct SocketBuffer<'a, 'b: 'a> { + storage: Managed<'a, [PacketBuffer<'b>]>, read_at: usize, length: usize } -impl<'a, 'b> Buffer<'a, 'b> { +impl<'a, 'b> SocketBuffer<'a, 'b> { /// Create a packet buffer with the given storage. - pub fn new(storage: T) -> Buffer<'a, 'b> - where T: Into]>> { + pub fn new(storage: T) -> SocketBuffer<'a, 'b> + where T: Into]>> { let mut storage = storage.into(); for elem in storage.iter_mut() { elem.endpoint = Default::default(); elem.size = 0; } - Buffer { + SocketBuffer { storage: storage, read_at: 0, length: 0 @@ -75,7 +75,7 @@ impl<'a, 'b> Buffer<'a, 'b> { /// Enqueue an element into the buffer, and return a pointer to it, or return /// `Err(Error::Exhausted)` if the buffer is full. - pub fn enqueue(&mut self) -> Result<&mut Packet<'b>, Error> { + pub fn enqueue(&mut self) -> Result<&mut PacketBuffer<'b>, Error> { if self.full() { Err(Error::Exhausted) } else { @@ -88,7 +88,7 @@ impl<'a, 'b> Buffer<'a, 'b> { /// Dequeue an element from the buffer, and return a pointer to it, or return /// `Err(Error::Exhausted)` if the buffer is empty. - pub fn dequeue(&mut self) -> Result<&Packet<'b>, Error> { + pub fn dequeue(&mut self) -> Result<&PacketBuffer<'b>, Error> { if self.empty() { Err(Error::Exhausted) } else { @@ -106,13 +106,14 @@ impl<'a, 'b> Buffer<'a, 'b> { /// packet buffers. pub struct UdpSocket<'a, 'b: 'a> { endpoint: IpEndpoint, - rx_buffer: Buffer<'a, 'b>, - tx_buffer: Buffer<'a, 'b> + rx_buffer: SocketBuffer<'a, 'b>, + tx_buffer: SocketBuffer<'a, 'b> } impl<'a, 'b> UdpSocket<'a, 'b> { /// Create an UDP socket with the given buffers. - pub fn new(endpoint: IpEndpoint, rx_buffer: Buffer<'a, 'b>, tx_buffer: Buffer<'a, 'b>) + pub fn new(endpoint: IpEndpoint, + rx_buffer: SocketBuffer<'a, 'b>, tx_buffer: SocketBuffer<'a, 'b>) -> Socket<'a, 'b> { Socket::Udp(UdpSocket { endpoint: endpoint, @@ -218,9 +219,9 @@ mod test { pub fn test_buffer() { let mut storage = vec![]; for _ in 0..5 { - storage.push(Packet::new(vec![0])) + storage.push(PacketBuffer::new(vec![0])) } - let mut buffer = Buffer::new(&mut storage[..]); + let mut buffer = SocketBuffer::new(&mut storage[..]); assert_eq!(buffer.empty(), true); assert_eq!(buffer.full(), false);