astrofarm/lib/gempress/src/gemini.rs

use std::fmt;

use openssl::ssl::SslStream;
use openssl::x509::X509;

use url::Url;
use std::{io::Write, net::TcpStream, str::FromStr};
use crate::error::{GempressError, GempressResult};

/// Gemini status codes as defined in Appendix 1
/// TODO: fill out remaining codes
#[derive(Debug, PartialEq, Eq, Copy, Clone)]
pub enum StatusCode {
    Success = 20,
    NotFound = 51,
}

impl fmt::Display for StatusCode {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", *self as u8)
    }
}

/// A gemini request
pub struct Request {
    /// The requested resource path
    pub url: Url,
    pub certificate: Option<X509>,
}

impl Request {
    /// Parse a request object from text
    pub fn parse(request: &str) -> GempressResult<Self> {
        Self::from_str(request)
    }

    /// Get file path
    pub fn file_path(&self) -> &str {
        self.url
            .path()
            .chars()
            .next()
            .map_or("", |c| &self.url.path()[c.len_utf8()..])
    }
}

impl FromStr for Request {
    type Err = GempressError;

    fn from_str(s: &str) -> GempressResult<Self> {
        let mut s = s.to_string();

        // Add gemini: scheme if not explicitly set
        if s.starts_with("//") {
            s = format!("gemini:{}", s);
        }

        // Check protocol
        if let Some(proto_end) = s.find("://") {
            // If set, check if it's allowed
            let protocol = &s[..proto_end];

            if protocol != "gemini" {
                // TODO: return 53 error instead of dropping
                return Err(GempressError::InvalidRequest("invalid protocol".into()));
            }
        } else {
            // If no protocol is found, gemini: is implied
            s = format!("gemini://{}", s);
        }

        // Extract and parse the url from the request.
        let raw = s
            .trim_end_matches(0x0 as char)
            .strip_suffix("\r\n")
            .ok_or_else(|| GempressError::InvalidRequest("malformed request".into()))?;
        let url = Url::parse(&raw)
            .map_err(|e| GempressError::InvalidRequest(format!("invalid url: {}", e)))?;

        let certificate: Option<X509> = None;

        Ok(Self { url, certificate })
    }
}

/// A gemini response
pub struct Response {
    pub status_code: StatusCode,
    pub meta: Vec<u8>,
    pub body: Vec<u8>,
    stream: SslStream<TcpStream>,
}

impl Response {
    pub(crate) fn new(stream: SslStream<TcpStream>) -> Self {
        Self {
            status_code: StatusCode::Success,
            meta: "text/gemini".into(),
            body: Vec::new(),
            stream,
        }
    }

    /// Set the status code of a response
    pub fn status(&mut self, code: StatusCode) -> GempressResult<&mut Self> {
        self.status_code = code;
        return Ok(self);
    }

    /// "Finish" the response and write it to the steeam
    pub fn send(&mut self, text: &[u8]) -> GempressResult<usize> {
        let mut buf: Vec<u8> = Vec::new();

        // <Status>
        buf.extend(self.status_code.to_string().as_bytes());

        // <Space>
        buf.push(0x20);

        // <Meta>
        buf.extend(&self.meta);

        buf.extend(b"\r\n");

        buf.extend(self.body.clone());

        buf.extend(text);

        self.stream
            .write(&buf)
            .map_err(GempressError::StreamWriteFailed)
    }
}

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

    fn check_request(raw: &str, expected_url: &str) {
        let req = Request::parse(raw).unwrap();

        assert_eq!(
            req,
            Request {
                url: Url::parse(expected_url).unwrap()
            }
        );
    }

    #[test]
    fn parse_request() {
        check_request("gemini://example.space\r\n", "gemini://example.space");
    }

    #[test]
    fn parse_without_scheme() {
        check_request("example.space\r\n", "gemini://example.space");
    }

    #[test]
    fn parse_without_scheme_double_slash() {
        check_request("//example.space\r\n", "gemini://example.space");
    }

    #[test]
    fn parse_malformed_request() {
        let raw = "gemini://example.space";

        match Request::parse(raw) {
            Err(GempressError::InvalidRequest(_)) => {}
            x => panic!("expected GempressError::InvalidRequest, got: {:?}", x),
        }
    }
}