tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
use bytes::Bytes;
use futures_util::{AsyncReadExt as _, AsyncWriteExt as _};
use http::HeaderValue;
use std::net::IpAddr;

use crate::{
    Body, Error, Result,
    runtime::{Deadline, Executor, Io, PrefixedIo, Timer},
};

const MAX_PROXY_RESPONSE_SIZE: usize = 16 * 1024;

pub(crate) mod http1 {
    use super::{Body, Error, Executor, Io, Result};
    use crate::connection::Http1;

    pub(crate) type Sender = hyper::client::conn::http1::SendRequest<Body>;

    pub(crate) async fn connect(
        stream: Io,
        executor: &Executor,
        settings: Http1,
    ) -> Result<Sender> {
        let mut builder = hyper::client::conn::http1::Builder::new();
        settings.apply(&mut builder);
        let (sender, connection) = builder
            .handshake(stream)
            .await
            .map_err(|_| Error::connect())?;
        executor.spawn(async move {
            let _ = connection.with_upgrades().await;
        });
        Ok(sender)
    }
}

pub(crate) mod http2 {
    use super::{Body, Error, Executor, Io, Result, Timer};
    use crate::connection::Http2;

    pub(crate) type Sender = hyper::client::conn::http2::SendRequest<Body>;

    pub(crate) async fn connect(
        stream: Io,
        executor: &Executor,
        timer: &Timer,
        settings: Http2,
    ) -> Result<Sender> {
        let mut builder = hyper::client::conn::http2::Builder::new(executor.clone());
        builder.timer(timer.clone());
        settings.apply(&mut builder);
        let (sender, connection) = builder
            .handshake(stream)
            .await
            .map_err(|_| Error::connect())?;
        executor.spawn(async move {
            let _ = connection.await;
        });
        Ok(sender)
    }
}

pub(crate) fn classify_error(error: &hyper::Error) -> Error {
    if error.is_timeout() {
        Error::timeout()
    } else if error.is_closed() || error.is_canceled() {
        Error::connect()
    } else {
        Error::body()
    }
}

pub(crate) async fn tunnel(
    mut io: Io,
    authority: &str,
    authorization: Option<&HeaderValue>,
    deadline: Deadline,
) -> Result<Io> {
    let mut request = format!(
        "CONNECT {authority} HTTP/1.1\r\nHost: {authority}\r\nProxy-Connection: keep-alive\r\n"
    )
    .into_bytes();
    if let Some(authorization) = authorization {
        request.extend_from_slice(b"Proxy-Authorization: ");
        request.extend_from_slice(authorization.as_bytes());
        request.extend_from_slice(b"\r\n");
    }
    request.extend_from_slice(b"\r\n");

    deadline
        .run(async {
            io.write_all(&request).await.map_err(|_| Error::connect())?;
            io.flush().await.map_err(|_| Error::connect())?;
            Ok(())
        })
        .await?;

    let mut response = Vec::with_capacity(1024);
    let mut chunk = [0; 1024];
    let consumed = deadline
        .run(async {
            loop {
                let read = io.read(&mut chunk).await.map_err(|_| Error::connect())?;
                if read == 0 {
                    return Err(Error::connect());
                }
                response.extend_from_slice(&chunk[..read]);
                if let Some(consumed) = parse_tunnel_response(&response)? {
                    return Ok(consumed);
                }
            }
        })
        .await?;
    let prefix = Bytes::copy_from_slice(&response[consumed..]);
    Ok(Io::from_futures(PrefixedIo::new(prefix, io)))
}

pub(crate) async fn socks5(
    mut io: Io,
    host: &str,
    port: u16,
    credentials: Option<(&str, &str)>,
    deadline: Deadline,
) -> Result<Io> {
    let target = socks5_target(host, port)?;
    let authenticated = credentials.is_some();
    let greeting = if authenticated {
        &[5, 1, 2][..]
    } else {
        &[5, 1, 0][..]
    };
    deadline
        .run(async {
            io.write_all(greeting).await.map_err(|_| Error::connect())?;
            io.flush().await.map_err(|_| Error::connect())?;
            let mut selection = [0; 2];
            io.read_exact(&mut selection)
                .await
                .map_err(|_| Error::connect())?;
            if selection != [5, if authenticated { 2 } else { 0 }] {
                return Err(Error::connect());
            }

            if let Some((username, password)) = credentials {
                let username = username.as_bytes();
                let password = password.as_bytes();
                if username.len() > u8::MAX as usize || password.len() > u8::MAX as usize {
                    return Err(Error::connect());
                }
                let mut auth = Vec::with_capacity(username.len() + password.len() + 3);
                auth.extend_from_slice(&[1, username.len() as u8]);
                auth.extend_from_slice(username);
                auth.push(password.len() as u8);
                auth.extend_from_slice(password);
                io.write_all(&auth).await.map_err(|_| Error::connect())?;
                io.flush().await.map_err(|_| Error::connect())?;
                let mut reply = [0; 2];
                io.read_exact(&mut reply)
                    .await
                    .map_err(|_| Error::connect())?;
                if reply != [1, 0] {
                    return Err(Error::connect());
                }
            }

            let mut request = Vec::with_capacity(target.len() + 3);
            request.extend_from_slice(&[5, 1, 0]);
            request.extend_from_slice(&target);
            io.write_all(&request).await.map_err(|_| Error::connect())?;
            io.flush().await.map_err(|_| Error::connect())?;

            let mut reply = [0; 4];
            io.read_exact(&mut reply)
                .await
                .map_err(|_| Error::connect())?;
            if reply[0] != 5 || reply[1] != 0 {
                return Err(Error::connect());
            }
            let address_length = match reply[3] {
                1 => 4,
                3 => {
                    let mut length = [0; 1];
                    io.read_exact(&mut length)
                        .await
                        .map_err(|_| Error::connect())?;
                    usize::from(length[0])
                }
                4 => 16,
                _ => return Err(Error::connect()),
            };
            let mut ignored = vec![0; address_length + 2];
            io.read_exact(&mut ignored)
                .await
                .map_err(|_| Error::connect())?;
            Ok(())
        })
        .await?;
    Ok(io)
}

fn socks5_target(host: &str, port: u16) -> Result<Vec<u8>> {
    let mut target = Vec::with_capacity(host.len() + 3);
    match host.parse() {
        Ok(IpAddr::V4(address)) => {
            target.push(1);
            target.extend_from_slice(&address.octets());
        }
        Ok(IpAddr::V6(address)) => {
            target.push(4);
            target.extend_from_slice(&address.octets());
        }
        Err(_) => {
            if host.is_empty() || host.len() > u8::MAX as usize {
                return Err(Error::connect());
            }
            target.extend_from_slice(&[3, host.len() as u8]);
            target.extend_from_slice(host.as_bytes());
        }
    }
    target.extend_from_slice(&port.to_be_bytes());
    Ok(target)
}

fn parse_tunnel_response(input: &[u8]) -> Result<Option<usize>> {
    let mut headers = [httparse::EMPTY_HEADER; 64];
    let mut response = httparse::Response::new(&mut headers);
    let consumed = match response.parse(input).map_err(|_| Error::connect())? {
        httparse::Status::Partial if input.len() < MAX_PROXY_RESPONSE_SIZE => return Ok(None),
        httparse::Status::Partial => return Err(Error::connect()),
        httparse::Status::Complete(consumed) => consumed,
    };
    if !(200..300).contains(&response.code.unwrap_or_default()) {
        return Err(Error::connect());
    }
    Ok(Some(consumed))
}

#[cfg(test)]
mod tests {
    use super::socks5_target;

    #[test]
    fn socks_targets_preserve_ip_address_types() {
        assert_eq!(
            socks5_target("127.0.0.1", 80).unwrap(),
            [1, 127, 0, 0, 1, 0, 80]
        );
        assert_eq!(
            socks5_target("::1", 443).unwrap(),
            [4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 187]
        );
        assert_eq!(
            socks5_target("example.com", 8080).unwrap(),
            [
                3, 11, b'e', b'x', b'a', b'm', b'p', b'l', b'e', b'.', b'c', b'o', b'm', 31, 144
            ]
        );
    }
}