tokio-gemini/src/client/mod.rs

//! Everything related to Gemini client except cert verification

pub mod builder;
pub mod response;

pub use response::Response;

use crate::{error::*, status::*};
use builder::ClientBuilder;

use std::sync::Arc;

use tokio::{
    io::{AsyncBufReadExt, AsyncReadExt, AsyncWriteExt},
    net::TcpStream,
};
use tokio_rustls::{
    rustls::{self, pki_types},
    TlsConnector,
};
use url::Url;

pub struct Client {
    connector: TlsConnector,
}

impl From<rustls::ClientConfig> for Client {
    /// Create a Client from a Rustls config.
    #[inline]
    fn from(config: rustls::ClientConfig) -> Self {
        Client {
            connector: TlsConnector::from(Arc::new(config)),
        }
    }
}

impl Client {
    /// Create a Client with a customized configuration,
    /// see [`ClientBuilder`] methods.
    pub fn builder() -> ClientBuilder {
        ClientBuilder::new()
    }
}

impl Client {
    /// Parse the given URL, do some checks,
    /// take host and port (default is 1965) from the URL
    /// and perform a Gemini request, returning [`Response`] on success.
    ///
    /// # Errors
    /// Everything is converted into [`LibError`].
    /// - [`InvalidUrl::ParseError`] means that the given URL cannot be parsed.
    /// - [`InvalidUrl::SchemeNotGemini`] is returned when the scheme is not `gemini://`
    ///   (for proxying use [`Client::request_with_host`]).
    /// - [`InvalidUrl::UserinfoPresent`] is returned when the URL contains userinfo -- `user:password@` --
    ///   which is forbidden by the Gemini specs.
    /// - For the rest, see [`Client::request_with_host`].
    pub async fn request(&self, url_str: &str) -> Result<Response, LibError> {
        let url = Url::parse(url_str).map_err(InvalidUrl::ParseError)?;
        // deny non-Gemini requests
        if url.scheme() != "gemini" {
            return Err(InvalidUrl::SchemeNotGemini.into());
        }
        // userinfo (user:pswd@) is not allowed in Gemini
        if !url.username().is_empty() {
            return Err(InvalidUrl::UserinfoPresent.into());
        }

        let host = url.host_str().ok_or(InvalidUrl::ConvertError)?;
        let port = url.port().unwrap_or(1965);

        self.request_with_host(url_str, host, port).await
    }

    /// Perform a Gemini request with the specified host, port and URL.
    /// Non-`gemini://` URLs is OK if the remote server supports proxying.
    ///
    /// # Errors
    /// Everything is converted into [`LibError`].
    /// - [`InvalidUrl::ConvertError`] is an error while converting
    ///   host and port into [`std::net::SocketAddr`] or [`pki_types::ServerName`].
    /// - [`std::io::Error`] is returned in nearly all cases:
    ///   could not open a TCP connection, perform a TLS handshake,
    ///   write to or read from the TCP stream.
    ///   Check the inner error if you need to determine what exactly happened
    /// - [`LibError::StatusOutOfRange`] means that a server returned an incorrect status code
    ///   (less than 10 or greater than 69).
    /// - [`LibError::DataNotUtf8`] is returned when metadata (the text after a status code)
    ///   is not in UTF-8 and cannot be converted to string without errors.
    pub async fn request_with_host(
        &self,
        url_str: &str,
        host: &str,
        port: u16,
    ) -> Result<Response, LibError> {
        let addr = tokio::net::lookup_host((host, port))
            .await?
            .next()
            .ok_or(InvalidUrl::ConvertError)?;

        let domain = pki_types::ServerName::try_from(host)
            .map_err(|_| InvalidUrl::ConvertError)?
            .to_owned();

        let stream = TcpStream::connect(&addr).await?;
        let mut stream = self.connector.connect(domain, stream).await?;

        // Write URL, then CRLF
        stream.write_all(url_str.as_bytes()).await?;
        stream.write_all(b"\r\n").await?;

        let status = {
            let mut buf: [u8; 3] = [0, 0, 0]; // 2 digits, space
            stream.read_exact(&mut buf).await?;
            Status::parse_status(&buf)?
        };

        let mut stream = tokio::io::BufReader::new(stream);

        let message = {
            let mut result: Vec<u8> = Vec::new();
            let mut buf = [0u8]; // buffer for LF (\n)

            // reading message after status code
            // until CRLF (\r\n)
            loop {
                // until CR
                stream.read_until(b'\r', &mut result).await?;
                // now read next char...
                stream.read_exact(&mut buf).await?;
                if buf[0] == b'\n' {
                    // ...and check if it's LF
                    break;
                } else {
                    // ...otherwise, CR is a part of message, not a CRLF terminator,
                    // so append that one byte that's supposed to be LF (but not LF)
                    // to the message buffer
                    result.push(buf[0]);
                }
            }

            // trim last CR
            if result.last().is_some_and(|c| c == &b'\r') {
                result.pop();
            }

            // Vec<u8> -> ASCII or UTF-8 String
            String::from_utf8(result)?
        };

        Ok(Response::new(status, message, stream))
    }
}