Struct ore::netio::SniffingStream

pub struct SniffingStream<A> {
    inner: A,
    buf: SmallVec<[u8; 8]>,
    off: usize,
    len: usize,
}

This is supported on crate feature network only.

A stream that can peek at its initial bytes without consuming them.

SniffingStreams have rather high overhead while sniffing, as they must double-buffer every read to support rewinding to the beginning of the stream.

SniffingStreams are designed to enable multiplexing multiple protocols on the same TcpStream. Determining which protocol the client expects requires reading several bytes from the stream, but the eventual protocol handler will be very confused if it receives a stream whose read pointer has been advanced by several bytes. A SniffingStream can easily be rewound to the beginning, via into_sniffed, before it is presented to the protocol handler.

Examples

async fn handle_connection<S>(stream: S) -> std::io::Result<()>
where
    S: AsyncRead + Unpin
{
    let mut ss = SniffingStream::new(stream);
    let mut buf = [0; 4];
    ss.read_exact(&mut buf).await?;
    if &buf == b"GET " {
        handle_http(ss.into_sniffed())
    } else {
        handle_foo(ss.into_sniffed())
    }
}

Fields

inner: A

buf: SmallVec<[u8; 8]>

off: usize

len: usize

Implementations

impl<A> SniffingStream<A> where
    A: Unpin, 

pub fn new(inner: A) -> SniffingStream<A>

Creates a new SniffingStream that wraps an underlying stream.

pub fn into_sniffed(self) -> SniffedStream<A>

Produces a SniffedStream that will yield bytes from the beginning of the underlying stream, including the bytes that were previously yielded by the SniffingStream.

The SniffingStream is consumed by this method.

fn inner_pin(&mut self) -> Pin<&mut A>

Trait Implementations

impl<A> AsyncRead for SniffingStream<A> where
    A: AsyncRead + Unpin, 

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &mut ReadBuf<'_>
) -> Poll<Result<(), Error>>

Attempts to read from the AsyncRead into buf.

impl<A> AsyncReady for SniffingStream<A> where
    A: AsyncReady + Send + Sync, 

fn ready<'life0, 'async_trait>(
    &'life0 self,
    interest: Interest
) -> Pin<Box<dyn Future<Output = Result<Ready>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Checks for IO readiness.

impl<A> AsyncWrite for SniffingStream<A> where
    A: AsyncWrite + Unpin, 

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    buf: &[u8]
) -> Poll<Result<usize, Error>>

Attempt to write bytes from buf into the object.

fn poll_flush(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

Attempts to flush the object, ensuring that any buffered data reach their destination.

fn poll_shutdown(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

Initiates or attempts to shut down this writer, returning success when the I/O connection has completely shut down.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context<'_>,
    bufs: &[IoSlice<'_>]
) -> Poll<Result<usize, Error>>

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

fn is_write_vectored(&self) -> bool

Determines if this writer has an efficient poll_write_vectored implementation.

impl<A> Debug for SniffingStream<A>

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

Formats the value using the given formatter.