Struct Tube 

pub struct Tube<T>
where
    T: AsyncBufRead + AsyncWrite + Unpin,
{
    pub inner: T,
    pub timeout: Duration,
    /* private fields */
}

A wrapper to provide extra methods. Note that the API from this crate is different from pwntools.

Fields

inner: T

The inner struct, usually a BufReader containing the original struct.

timeout: Duration

This field is only used by methods directly provided by this struct and not methods from traits like AsyncRead.

This is due to the fact that during the polling, there is no way to keep track of the futures involved. If 2 calls to the poll functions occurs, there is not enough information in the argument to deduce whether it come from the same future or the previous future is dropped and another future has started polling. As a result, the API will be producing inconsistent timeout if it is implemented.

Luckily, tokio::time::timeout provides an easy way to add timeout to a future (which is how timeout is implemented in this library) so you can still have timeout behaviour on functions that doesn’t support them.

Hence, timeout can only be reliably implemented for async fn (which returns a future under the hood) or fn that return a future.

Implementations

impl<T> Tube<BufReader<T>>

where T: AsyncRead + AsyncWrite + Unpin,

pub fn new(inner: T) -> Self

Construct a new Tube<T>.

pub fn with_timeout(inner: T, timeout: Duration) -> Self

Construct a new Tube<T> with the supplied timeout argument. Note that timeout is only implemented for methods directly provided by this struct and not methods from traits.

use io_tubes::tubes::{ProcessTube, Tube};
use std::{io, time::Duration};

#[tokio::main]
async fn create_with_timeout() -> io::Result<()> {
    let mut p = Tube::process("/usr/bin/cat")?;
    p.timeout = Duration::from_millis(50);
    // Equivalent to
    let mut p =
        Tube::with_timeout(ProcessTube::new("/usr/bin/cat")?, Duration::from_millis(50));
    Ok(())
}

create_with_timeout();

impl Tube<BufReader<ProcessTube>>

pub fn process<S: AsRef<OsStr>>(program: S) -> Result<Self>

Create a process with supplied path to program.

use io_tubes::tubes::Tube;
use std::io;

#[tokio::main]
async fn create_process() -> io::Result<()> {
    let mut p = Tube::process("/usr/bin/cat")?;
    p.send("abcdHi!").await?;
    let result = p.recv_until("Hi").await?;
    assert_eq!(result, b"abcdHi");
    Ok(())
}

create_process();

impl Tube<BufReader<TcpStream>>

pub async fn remote<A: ToSocketAddrs>(addr: A) -> Result<Self>

Create a tube by connecting to the remote address.

use io_tubes::tubes::{Listener, Tube};
use std::{
    io,
    net::{IpAddr, Ipv4Addr, SocketAddr},
};

#[tokio::main]
async fn create_remote() -> io::Result<()> {
    let l = Listener::listen().await?;
    let mut p =
        Tube::remote(SocketAddr::new(IpAddr::V4(Ipv4Addr::LOCALHOST), l.port()?)).await?;
    let mut server = l.accept().await?;
    p.send("Client Hello").await?;
    server.send("Server Hello").await?;
    assert_eq!(p.recv_until("Hello").await?, b"Server Hello");
    assert_eq!(server.recv_until("Hello").await?, b"Client Hello");
    Ok(())
}

create_remote();

impl<T> Tube<T>

where T: AsyncBufRead + AsyncWrite + Unpin,

pub fn from_buffered(inner: T) -> Self

Construct a tube from any custom buffered type.

pub async fn recv(&mut self, len: usize) -> Result<Vec<u8>>

Receive up to len bytes.

pub async fn recv_line(&mut self) -> Result<Vec<u8>>

Receive until new line (0xA byte) is reached or EOF is reached.

pub async fn recv_until<A: AsRef<[u8]>>(&mut self, delims: A) -> Result<Vec<u8>>

Receive until the delims are found or EOF is reached.

A lookup table will be built to enable efficient matching of long patterns.

pub async fn send<A: AsRef<[u8]>>(&mut self, data: A) -> Result<()>

Send data and flush.

pub async fn send_line<A: AsRef<[u8]>>(&mut self, data: A) -> Result<()>

Same as send, but add new line (0xA byte).

pub async fn send_line_after<A: AsRef<[u8]>, B: AsRef<[u8]>>( &mut self, pattern: A, data: B, ) -> Result<Vec<u8>>

Send line after receiving the pattern from read.

use io_tubes::tubes::Tube;
use std::io;

#[tokio::main]
async fn send_line_after() -> io::Result<()> {
    let mut p = Tube::process("/usr/bin/cat")?;

    p.send("Hello, what's your name? ").await?;
    assert_eq!(
        p.send_line_after("name", "test").await?,
        b"Hello, what's your name"
    );
    assert_eq!(p.recv_line().await?, b"? test\n");

    Ok(())
}

send_line_after();

pub async fn interactive(&mut self) -> Result<()>

Connect the tube to stdin and stdout so you can interact with it directly.

pub fn into_inner(self) -> T

Consume the tube to get back the underlying BufReader

Trait Implementations

impl<T> AsyncBufRead for Tube<T>

where T: AsyncBufRead + AsyncWrite + Unpin,

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

Attempts to return the contents of the internal buffer, filling it with more data from the inner reader if it is empty.

fn consume(self: Pin<&mut Self>, amt: usize)

Tells this buffer that amt bytes have been consumed from the buffer, so they should no longer be returned in calls to poll_read.

impl<T> AsyncRead for Tube<T>

where T: AsyncBufRead + AsyncWrite + Unpin,

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

Attempts to read from the AsyncRead into buf.

impl<T> AsyncWrite for Tube<T>

where T: AsyncBufRead + AsyncWrite + Unpin,

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

Attempt to write bytes from buf into the object.

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

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<()>>

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<T> Debug for Tube<T>

where T: AsyncBufRead + AsyncWrite + Unpin + Debug,

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

Formats the value using the given formatter.

impl<T> From<T> for Tube<T>

where T: AsyncBufRead + AsyncWrite + Unpin,

fn from(tube_like: T) -> Self

Converts to this type from the input type.

impl<T> From<Tube<BufReader<T>>> for BufReader<T>

where T: AsyncRead + AsyncWrite + Unpin,

fn from(tube: Tube<BufReader<T>>) -> Self

Converts to this type from the input type.