synclaire 0.1.2

Transport-layer TCP/TLS library with guards, routing, and proxy primitives
Documentation
use crate::{
    client::tcp,
    config::ClientConfig,
    handler::Connection,
    SynError,
};
#[cfg(any(feature = "rustls-backend", feature = "aws-lc-backend"))]
use crate::client::tls;

pub struct AsyncClient {
    config: ClientConfig,
}

impl AsyncClient {
    pub fn new(config: ClientConfig) -> Self {
        Self { config }
    }

    pub async fn connect(self) -> Result<Connection, SynError> {
        let timeout = self.config.connection_timeout;
        let addr = self.config.connect_addr;
        tokio::time::timeout(timeout, self.connect_inner())
            .await
            .map_err(|_| SynError::connection_error(format!(
                "connection to {} timed out after {:?}", addr, timeout
            )))?
    }

    async fn connect_inner(self) -> Result<Connection, SynError> {
        log::info!("client connecting to {}", self.config.connect_addr);

        let stream = tcp::connect_async(self.config.connect_addr).await?;
        if let Err(error) = stream.set_nodelay(self.config.tcp_nodelay) {
            log::debug!("failed to set TCP_NODELAY: {}", error);
        }

        let local_addr = stream.local_addr().ok();
        let peer_addr = stream.peer_addr()?;

        if self.config.tls.enabled {
            #[cfg(any(feature = "rustls-backend", feature = "aws-lc-backend"))]
            {
                let tls_stream = tls::connect_async(stream, &self.config.tls).await?;
                let mut metadata = crate::handler::ConnectionMetadata::new(peer_addr, local_addr, true);
                metadata.tls_server_name = self.config.tls.server_name.clone();
                return Ok(Connection::from_client_tls(metadata, tls_stream));
            }
            #[cfg(not(any(feature = "rustls-backend", feature = "aws-lc-backend")))]
            return Err(SynError::UnsupportedFeature(
                "TLS requires the rustls-backend or aws-lc-backend feature",
            ));
        } else {
            let metadata = crate::handler::ConnectionMetadata::new(peer_addr, local_addr, false);
            Ok(Connection::from_async_tcp(metadata, stream))
        }
    }
}