2016-12-11 00:25:43 +08:00
|
|
|
//! Access to networking hardware.
|
|
|
|
//!
|
2016-12-12 10:39:46 +08:00
|
|
|
//! The `phy` module deals with the *network devices*. It provides an interface
|
|
|
|
//! for transmitting and receiving frames, [Device](trait.Device.html),
|
2016-12-11 07:15:26 +08:00
|
|
|
//! as well as an implementations of that trait that uses the host OS,
|
2016-12-12 10:39:46 +08:00
|
|
|
//! [RawSocket](struct.RawSocket.html) and [TapInterface](struct.TapInterface.html).
|
2016-12-11 07:15:26 +08:00
|
|
|
|
|
|
|
#[cfg(feature = "std")]
|
|
|
|
mod sys;
|
2016-12-11 00:25:43 +08:00
|
|
|
|
2016-12-11 07:15:26 +08:00
|
|
|
#[cfg(feature = "std")]
|
2016-12-11 00:25:43 +08:00
|
|
|
mod raw_socket;
|
2016-12-11 07:15:26 +08:00
|
|
|
#[cfg(all(feature = "std", target_os = "linux"))]
|
|
|
|
mod tap_interface;
|
|
|
|
|
|
|
|
#[cfg(feature = "std")]
|
|
|
|
pub use self::raw_socket::RawSocket;
|
|
|
|
#[cfg(all(feature = "std", target_os = "linux"))]
|
|
|
|
pub use self::tap_interface::TapInterface;
|
2016-12-11 00:25:43 +08:00
|
|
|
|
2016-12-11 03:27:07 +08:00
|
|
|
/// An interface for sending and receiving raw network frames.
|
|
|
|
///
|
|
|
|
/// It is expected that a `Device` implementation would allocate memory for both sending
|
|
|
|
/// and receiving packets from memory pools; hence, the stack borrows the buffer for a packet
|
|
|
|
/// that it is about to receive, as well for a packet that it is about to send, from the device.
|
|
|
|
pub trait Device {
|
|
|
|
/// Maximum transmission unit.
|
|
|
|
///
|
|
|
|
/// The network device is unable to send or receive frames larger than the MTU.
|
|
|
|
/// In practice, MTU will fall between 64 and 9216 octets.
|
|
|
|
const MTU: usize;
|
|
|
|
|
|
|
|
/// Receives a frame.
|
|
|
|
///
|
|
|
|
/// It is expected that a `recv` implementation, once a packet is written to memory
|
|
|
|
/// through DMA, would gain ownership of the underlying buffer, provide it for parsing,
|
|
|
|
/// and then return it to the network device.
|
|
|
|
fn recv<F: FnOnce(&[u8])>(&mut self, handler: F);
|
|
|
|
|
|
|
|
/// Transmits a frame.
|
|
|
|
///
|
|
|
|
/// It is expected that a `send` implementation would gain ownership of a buffer with
|
2016-12-11 07:15:26 +08:00
|
|
|
/// the requested length, provide it for emission, and then schedule it to be read from
|
2016-12-11 03:27:07 +08:00
|
|
|
/// memory by the network device.
|
|
|
|
///
|
|
|
|
/// # Panics
|
2016-12-11 07:15:26 +08:00
|
|
|
/// This function may panic if `len` is larger than `MTU`.
|
|
|
|
fn send<F: FnOnce(&mut [u8])>(&mut self, len: usize, handler: F);
|
2016-12-11 03:27:07 +08:00
|
|
|
}
|