Struct net_util::sys::linux::tap::Tap

pub struct Tap {
    tap_file: File,
    if_name: [c_char; 16],
    if_flags: c_short,
}

Handle for a network tap interface.

For now, this simply wraps the file descriptor for the tap device so methods can run ioctls on the interface. The tap interface descriptor will be closed when Tap goes out of scope, and the kernel will clean up the interface automatically.

Fields

tap_file: File

if_name: [c_char; 16]

if_flags: c_short

Implementations

impl Tap

pub unsafe fn from_raw_descriptor(descriptor: RawDescriptor) -> Result<Tap>

Safety

1. descriptor’s ownership must be released by the caller. It is now owned by the returned value (Tap), or is closed (if an error is returned).

pub fn create_tap_with_ifreq(ifreq: &mut ifreq) -> Result<Tap>

fn get_ifreq(&self) -> ifreq

pub fn try_clone(&self) -> Result<Tap>

Trait Implementations

impl AsRawDescriptor for Tap

fn as_raw_descriptor(&self) -> RawDescriptor

Returns the underlying raw descriptor.

impl AsRawFd for Tap

fn as_raw_fd(&self) -> RawFd

Extracts the raw file descriptor.

impl Debug for Tap

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FileReadWriteVolatile for Tap

fn read_volatile(&mut self, slice: VolatileSlice<'_>) -> Result<usize>

Read bytes from this file into the given slice, returning the number of bytes read on success.

fn read_vectored_volatile( &mut self, bufs: &[VolatileSlice<'_>] ) -> Result<usize>

Like read_volatile, except it reads to a slice of buffers. Data is copied to fill each buffer in order, with the final buffer written to possibly being only partially filled. This method must behave as a single call to read_volatile with the buffers concatenated would. The default implementation calls read_volatile with either the first nonempty buffer provided, or returns Ok(0) if none exists.

fn write_volatile(&mut self, slice: VolatileSlice<'_>) -> Result<usize>

Write bytes from the slice to the given file, returning the number of bytes written on success.

fn write_vectored_volatile( &mut self, bufs: &[VolatileSlice<'_>] ) -> Result<usize>

Like write_volatile, except that it writes from a slice of buffers. Data is copied from each buffer in order, with the final buffer read from possibly being only partially consumed. This method must behave as a call to write_volatile with the buffers concatenated would. The default implementation calls write_volatile with either the first nonempty buffer provided, or returns Ok(0) if none exists.

fn read_exact_volatile(&mut self, slice: VolatileSlice<'_>) -> Result<(), Error>

Reads bytes from this into the given slice until all bytes in the slice are written, or an error is returned.

fn write_all_volatile(&mut self, slice: VolatileSlice<'_>) -> Result<(), Error>

Write bytes from the slice to the given file until all the bytes from the slice have been written, or an error is returned.

impl Read for Tap

fn read(&mut self, buf: &mut [u8]) -> IoResult<usize>

Pull some bytes from this source into the specified buffer, returning how many bytes were read.

fn read_vectored(&mut self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize, Error>

Like read, except that it reads into a slice of buffers.

fn is_read_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Reader has an efficient read_vectored implementation.

fn read_to_end(&mut self, buf: &mut Vec<u8>) -> Result<usize, Error>

Read all bytes until EOF in this source, placing them into buf.

fn read_to_string(&mut self, buf: &mut String) -> Result<usize, Error>

Read all bytes until EOF in this source, appending them to buf.

fn read_exact(&mut self, buf: &mut [u8]) -> Result<(), Error>

Read the exact number of bytes required to fill buf.

fn read_buf(&mut self, buf: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Pull some bytes from this source into the specified buffer.

fn read_buf_exact(&mut self, cursor: BorrowedCursor<'_>) -> Result<(), Error>

🔬This is a nightly-only experimental API. (read_buf)

Read the exact number of bytes required to fill cursor.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adaptor for this instance of Read.

fn bytes(self) -> Bytes<Self>

where Self: Sized,

Transforms this Read instance to an Iterator over its bytes.

fn chain<R>(self, next: R) -> Chain<Self, R>

where R: Read, Self: Sized,

Creates an adapter which will chain this stream with another.

fn take(self, limit: u64) -> Take<Self>

where Self: Sized,

Creates an adapter which will read at most limit bytes from it.

impl ReadNotifier for Tap

fn get_read_notifier(&self) -> &dyn AsRawDescriptor

Gets a descriptor that can be used in EventContext to wait for events to be available (e.g. to avoid receive_events blocking).

impl TapTCommon for Tap

fn new(vnet_hdr: bool, multi_vq: bool) -> Result<Self>

Create a new tap interface.

Set the vnet_hdr flag to true to allow offloading on this tap, which will add an extra 12 byte virtio net header to incoming frames. Offloading cannot be used if vnet_hdr is false. Set ‘multi_vq’ to true, if tap have multi virt queue pairs

fn new_with_name(name: &[u8], vnet_hdr: bool, multi_vq: bool) -> Result<Tap>

Create a new tap interface named name, or open it if it already exists with the same parameters.

fn into_mq_taps(self, vq_pairs: u16) -> Result<Vec<Tap>>

Change the origin tap into multiqueue taps, this means create other taps based on the origin tap.

fn ip_addr(&self) -> Result<Ipv4Addr>

Get the host-side IP address for the tap interface.

fn set_ip_addr(&self, ip_addr: Ipv4Addr) -> Result<()>

Set the host-side IP address for the tap interface.

fn netmask(&self) -> Result<Ipv4Addr>

Get the netmask for the tap interface’s subnet.

fn set_netmask(&self, netmask: Ipv4Addr) -> Result<()>

Set the netmask for the subnet that the tap interface will exist on.

fn mtu(&self) -> Result<u16>

Get the MTU for the tap interface.

fn set_mtu(&self, mtu: u16) -> Result<()>

Set the MTU for the tap interface.

fn mac_address(&self) -> Result<MacAddress>

Get the mac address for the tap interface.

fn set_mac_address(&self, mac_addr: MacAddress) -> Result<()>

Set the mac address for the tap interface.

fn set_offload(&self, flags: c_uint) -> Result<()>

Set the offload flags for the tap interface.

fn enable(&self) -> Result<()>

Enable the tap interface.

fn try_clone(&self) -> Result<Self>

Try to clone

unsafe fn from_raw_descriptor(descriptor: RawDescriptor) -> Result<Self>

Convert raw descriptor to

impl TapTLinux for Tap

fn set_vnet_hdr_size(&self, size: usize) -> Result<()>

Set the size of the vnet hdr.

fn if_flags(&self) -> u32

Get the interface flags

impl Write for Tap

fn write(&mut self, buf: &[u8]) -> IoResult<usize>

Write a buffer into this writer, returning how many bytes were written.

fn flush(&mut self) -> IoResult<()>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> Result<usize, Error>

Like write, except that it writes from a slice of buffers.

fn is_write_vectored(&self) -> bool

🔬This is a nightly-only experimental API. (can_vector)

Determines if this Writer has an efficient write_vectored implementation.

fn write_all(&mut self, buf: &[u8]) -> Result<(), Error>

Attempts to write an entire buffer into this writer.

fn write_all_vectored(&mut self, bufs: &mut [IoSlice<'_>]) -> Result<(), Error>

🔬This is a nightly-only experimental API. (write_all_vectored)

Attempts to write multiple buffers into this writer.

fn write_fmt(&mut self, fmt: Arguments<'_>) -> Result<(), Error>

Writes a formatted string into this writer, returning any error encountered.

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

Creates a “by reference” adapter for this instance of Write.

impl IntoAsync for Tap

impl TapT for Tap