2016-12-15 01:39:44 +08:00
|
|
|
use core::borrow::BorrowMut;
|
|
|
|
|
|
|
|
use Error;
|
2016-12-17 12:15:12 +08:00
|
|
|
use Managed;
|
2016-12-15 13:15:00 +08:00
|
|
|
use wire::{InternetAddress as Address, InternetProtocolType as ProtocolType};
|
|
|
|
use wire::{InternetEndpoint as Endpoint};
|
|
|
|
use wire::{UdpPacket, UdpRepr};
|
|
|
|
use socket::{Socket, PacketRepr};
|
2016-12-15 01:39:44 +08:00
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
/// A buffered UDP packet.
|
2016-12-17 12:15:12 +08:00
|
|
|
#[derive(Debug)]
|
|
|
|
pub struct BufferElem<'a> {
|
2016-12-16 01:07:56 +08:00
|
|
|
endpoint: Endpoint,
|
|
|
|
size: usize,
|
2016-12-17 12:15:12 +08:00
|
|
|
payload: Managed<'a, [u8]>
|
2016-12-16 01:07:56 +08:00
|
|
|
}
|
2016-12-15 01:39:44 +08:00
|
|
|
|
2016-12-17 12:15:12 +08:00
|
|
|
impl<'a> BufferElem<'a> {
|
2016-12-16 01:07:56 +08:00
|
|
|
/// Create a buffered packet.
|
2016-12-17 12:15:12 +08:00
|
|
|
pub fn new<T>(payload: T) -> BufferElem<'a>
|
|
|
|
where T: Into<Managed<'a, [u8]>> {
|
2016-12-16 01:07:56 +08:00
|
|
|
BufferElem {
|
|
|
|
endpoint: Endpoint::INVALID,
|
|
|
|
size: 0,
|
2016-12-17 12:15:12 +08:00
|
|
|
payload: payload.into()
|
2016-12-16 01:07:56 +08:00
|
|
|
}
|
|
|
|
}
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
/// An UDP packet buffer.
|
|
|
|
#[derive(Debug)]
|
2016-12-17 12:15:12 +08:00
|
|
|
pub struct Buffer<'a> {
|
|
|
|
storage: Managed<'a, [BufferElem<'a>]>,
|
2016-12-16 01:07:56 +08:00
|
|
|
read_at: usize,
|
2016-12-17 12:15:12 +08:00
|
|
|
length: usize
|
2016-12-16 01:07:56 +08:00
|
|
|
}
|
|
|
|
|
2016-12-17 12:15:12 +08:00
|
|
|
impl<'a> Buffer<'a> {
|
2016-12-16 01:07:56 +08:00
|
|
|
/// Create a packet buffer with the given storage.
|
2016-12-17 12:15:12 +08:00
|
|
|
pub fn new<T>(storage: T) -> Buffer<'a>
|
|
|
|
where T: Into<Managed<'a, [BufferElem<'a>]>> {
|
|
|
|
let mut storage = storage.into();
|
|
|
|
for elem in storage.iter_mut() {
|
2016-12-16 01:07:56 +08:00
|
|
|
elem.endpoint = Default::default();
|
|
|
|
elem.size = 0;
|
|
|
|
}
|
2016-12-15 01:39:44 +08:00
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
Buffer {
|
|
|
|
storage: storage,
|
|
|
|
read_at: 0,
|
2016-12-17 12:15:12 +08:00
|
|
|
length: 0
|
2016-12-16 01:07:56 +08:00
|
|
|
}
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
fn mask(&self, index: usize) -> usize {
|
2016-12-17 12:15:12 +08:00
|
|
|
index % self.storage.len()
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
fn incr(&self, index: usize) -> usize {
|
|
|
|
self.mask(index + 1)
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
fn empty(&self) -> bool {
|
|
|
|
self.length == 0
|
|
|
|
}
|
2016-12-15 01:39:44 +08:00
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
fn full(&self) -> bool {
|
2016-12-17 12:15:12 +08:00
|
|
|
self.length == self.storage.len()
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
/// Enqueue an element into the buffer, and return a pointer to it, or return
|
|
|
|
/// `Err(Error::Exhausted)` if the buffer is full.
|
2016-12-17 12:15:12 +08:00
|
|
|
pub fn enqueue(&mut self) -> Result<&mut BufferElem<'a>, Error> {
|
2016-12-16 01:07:56 +08:00
|
|
|
if self.full() {
|
|
|
|
Err(Error::Exhausted)
|
|
|
|
} else {
|
|
|
|
let index = self.mask(self.read_at + self.length);
|
|
|
|
let result = &mut self.storage.borrow_mut()[index];
|
|
|
|
self.length += 1;
|
|
|
|
Ok(result)
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
/// Dequeue an element from the buffer, and return a pointer to it, or return
|
|
|
|
/// `Err(Error::Exhausted)` if the buffer is empty.
|
2016-12-17 12:15:12 +08:00
|
|
|
pub fn dequeue(&mut self) -> Result<&BufferElem<'a>, Error> {
|
2016-12-16 01:07:56 +08:00
|
|
|
if self.empty() {
|
|
|
|
Err(Error::Exhausted)
|
|
|
|
} else {
|
|
|
|
self.length -= 1;
|
2016-12-17 12:15:12 +08:00
|
|
|
let result = &self.storage[self.read_at];
|
2016-12-16 01:07:56 +08:00
|
|
|
self.read_at = self.incr(self.read_at);
|
|
|
|
Ok(result)
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// An User Datagram Protocol socket.
|
2016-12-15 13:15:00 +08:00
|
|
|
///
|
|
|
|
/// An UDP socket is bound to a specific endpoint, and owns transmit and receive
|
|
|
|
/// packet buffers.
|
2016-12-17 12:15:12 +08:00
|
|
|
pub struct UdpSocket<'a> {
|
2016-12-15 01:39:44 +08:00
|
|
|
endpoint: Endpoint,
|
2016-12-17 12:15:12 +08:00
|
|
|
rx_buffer: Buffer<'a>,
|
|
|
|
tx_buffer: Buffer<'a>
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-17 12:15:12 +08:00
|
|
|
impl<'a> UdpSocket<'a> {
|
2016-12-15 01:39:44 +08:00
|
|
|
/// Create an UDP socket with the given buffers.
|
2016-12-17 12:15:12 +08:00
|
|
|
pub fn new(endpoint: Endpoint, rx_buffer: Buffer<'a>, tx_buffer: Buffer<'a>)
|
|
|
|
-> UdpSocket<'a> {
|
2016-12-15 13:15:00 +08:00
|
|
|
UdpSocket {
|
2016-12-15 01:39:44 +08:00
|
|
|
endpoint: endpoint,
|
|
|
|
rx_buffer: rx_buffer,
|
|
|
|
tx_buffer: tx_buffer
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
/// Enqueue a packet to be sent to a given remote endpoint, and return a pointer
|
|
|
|
/// to its payload.
|
2016-12-15 01:39:44 +08:00
|
|
|
///
|
2016-12-16 01:07:56 +08:00
|
|
|
/// This function returns `Err(Error::Exhausted)` if the size is greater than what
|
|
|
|
/// the transmit buffer can accomodate.
|
|
|
|
pub fn send(&mut self, endpoint: Endpoint, size: usize) -> Result<&mut [u8], Error> {
|
|
|
|
let packet_buf = try!(self.tx_buffer.enqueue());
|
|
|
|
packet_buf.endpoint = endpoint;
|
|
|
|
packet_buf.size = size;
|
|
|
|
Ok(&mut packet_buf.payload.borrow_mut()[..size])
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
/// Dequeue a packet received from a remote endpoint, and return the endpoint as well
|
|
|
|
/// as a pointer to the payload.
|
2016-12-15 01:39:44 +08:00
|
|
|
///
|
2016-12-16 01:07:56 +08:00
|
|
|
/// This function returns `Err(Error::Exhausted)` if the receive buffer is empty.
|
|
|
|
pub fn recv<R, F>(&mut self) -> Result<(Endpoint, &[u8]), Error> {
|
|
|
|
let packet_buf = try!(self.rx_buffer.dequeue());
|
2016-12-17 12:15:12 +08:00
|
|
|
Ok((packet_buf.endpoint, &packet_buf.payload[..packet_buf.size]))
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
2016-12-15 13:15:00 +08:00
|
|
|
}
|
|
|
|
|
2016-12-17 12:15:12 +08:00
|
|
|
impl<'a> Socket for UdpSocket<'a> {
|
2016-12-15 13:15:00 +08:00
|
|
|
fn collect(&mut self, src_addr: &Address, dst_addr: &Address,
|
|
|
|
protocol: ProtocolType, payload: &[u8])
|
|
|
|
-> Result<(), Error> {
|
|
|
|
if protocol != ProtocolType::Udp { return Err(Error::Rejected) }
|
|
|
|
|
|
|
|
let packet = try!(UdpPacket::new(payload));
|
|
|
|
let repr = try!(UdpRepr::parse(&packet, src_addr, dst_addr));
|
2016-12-15 01:39:44 +08:00
|
|
|
|
|
|
|
if repr.dst_port != self.endpoint.port { return Err(Error::Rejected) }
|
|
|
|
if !self.endpoint.addr.is_unspecified() {
|
2016-12-15 13:15:00 +08:00
|
|
|
if self.endpoint.addr != *dst_addr { return Err(Error::Rejected) }
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
2016-12-15 13:15:00 +08:00
|
|
|
|
2016-12-16 01:07:56 +08:00
|
|
|
let packet_buf = try!(self.rx_buffer.enqueue());
|
|
|
|
packet_buf.endpoint = Endpoint { addr: *src_addr, port: repr.src_port };
|
|
|
|
packet_buf.size = repr.payload.len();
|
|
|
|
packet_buf.payload.borrow_mut()[..repr.payload.len()].copy_from_slice(repr.payload);
|
|
|
|
Ok(())
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
|
2016-12-15 13:15:00 +08:00
|
|
|
fn dispatch(&mut self, f: &mut FnMut(&Address, &Address,
|
|
|
|
ProtocolType, &PacketRepr) -> Result<(), Error>)
|
|
|
|
-> Result<(), Error> {
|
2016-12-16 01:07:56 +08:00
|
|
|
let packet_buf = try!(self.tx_buffer.dequeue());
|
|
|
|
f(&self.endpoint.addr,
|
|
|
|
&packet_buf.endpoint.addr,
|
|
|
|
ProtocolType::Udp,
|
|
|
|
&UdpRepr {
|
|
|
|
src_port: self.endpoint.port,
|
|
|
|
dst_port: packet_buf.endpoint.port,
|
2016-12-17 12:15:12 +08:00
|
|
|
payload: &packet_buf.payload[..]
|
2016-12-16 01:07:56 +08:00
|
|
|
})
|
2016-12-15 01:39:44 +08:00
|
|
|
}
|
|
|
|
}
|
2016-12-15 13:15:00 +08:00
|
|
|
|
|
|
|
impl<'a> PacketRepr for UdpRepr<'a> {
|
|
|
|
fn len(&self) -> usize {
|
|
|
|
self.len()
|
|
|
|
}
|
|
|
|
|
|
|
|
fn emit(&self, src_addr: &Address, dst_addr: &Address, payload: &mut [u8]) {
|
|
|
|
let mut packet = UdpPacket::new(payload).expect("undersized payload slice");
|
|
|
|
self.emit(&mut packet, src_addr, dst_addr)
|
|
|
|
}
|
|
|
|
}
|
2016-12-16 01:07:56 +08:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
pub fn test_buffer() {
|
|
|
|
let mut storage = vec![];
|
|
|
|
for _ in 0..5 {
|
|
|
|
storage.push(BufferElem::new(vec![0]))
|
|
|
|
}
|
|
|
|
let mut buffer = Buffer::new(&mut storage[..]);
|
|
|
|
|
|
|
|
assert_eq!(buffer.empty(), true);
|
|
|
|
assert_eq!(buffer.full(), false);
|
|
|
|
buffer.enqueue().unwrap().size = 1;
|
|
|
|
assert_eq!(buffer.empty(), false);
|
|
|
|
assert_eq!(buffer.full(), false);
|
|
|
|
buffer.enqueue().unwrap().size = 2;
|
|
|
|
buffer.enqueue().unwrap().size = 3;
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 1);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 2);
|
|
|
|
buffer.enqueue().unwrap().size = 4;
|
|
|
|
buffer.enqueue().unwrap().size = 5;
|
|
|
|
buffer.enqueue().unwrap().size = 6;
|
|
|
|
buffer.enqueue().unwrap().size = 7;
|
|
|
|
assert_eq!(buffer.enqueue().unwrap_err(), Error::Exhausted);
|
|
|
|
assert_eq!(buffer.empty(), false);
|
|
|
|
assert_eq!(buffer.full(), true);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 3);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 4);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 5);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 6);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap().size, 7);
|
|
|
|
assert_eq!(buffer.dequeue().unwrap_err(), Error::Exhausted);
|
|
|
|
assert_eq!(buffer.empty(), true);
|
|
|
|
assert_eq!(buffer.full(), false);
|
|
|
|
}
|
|
|
|
}
|