Initial codebase structure

- Complete Gemini server implementation with logging
- Add comprehensive documentation (README.md, AGENTS.md)
- Implement certificate management guidelines
- Add .gitignore for security and build artifacts
- All unit tests passing (14/14)
- Ready for production deployment

src/config.rs

@@ -0,0 +1,57 @@
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Config {
+    pub root: Option<String>,
+    pub cert: Option<String>,
+    pub key: Option<String>,
+    pub host: Option<String>,
+    pub port: Option<u16>,
+    pub log_level: Option<String>,
+}
+
+pub fn load_config(path: &str) -> Result<Config, Box<dyn std::error::Error>> {
+    let content = std::fs::read_to_string(path)?;
+    let config: Config = toml::from_str(&content)?;
+    Ok(config)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::fs;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_load_config_valid() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+        let content = r#"
+            root = "/path/to/root"
+            cert = "cert.pem"
+            key = "key.pem"
+            host = "example.com"
+            port = 1965
+            log_level = "info"
+        "#;
+        fs::write(&config_path, content).unwrap();
+
+        let config = load_config(config_path.to_str().unwrap()).unwrap();
+        assert_eq!(config.root, Some("/path/to/root".to_string()));
+        assert_eq!(config.cert, Some("cert.pem".to_string()));
+        assert_eq!(config.key, Some("key.pem".to_string()));
+        assert_eq!(config.host, Some("example.com".to_string()));
+        assert_eq!(config.port, Some(1965));
+        assert_eq!(config.log_level, Some("info".to_string()));
+    }
+
+    #[test]
+    fn test_load_config_invalid() {
+        let temp_dir = TempDir::new().unwrap();
+        let config_path = temp_dir.path().join("config.toml");
+        let content = "invalid toml";
+        fs::write(&config_path, content).unwrap();
+
+        assert!(load_config(config_path.to_str().unwrap()).is_err());
+    }
+}

src/logging.rs

@@ -0,0 +1,52 @@
+use tokio::net::TcpStream;
+use tokio_rustls::server::TlsStream;
+
+pub struct RequestLogger {
+    client_ip: String,
+    request_url: String,
+}
+
+impl RequestLogger {
+    pub fn new(stream: &TlsStream<TcpStream>, request_url: String) -> Self {
+        let client_ip = extract_client_ip(stream);
+        
+        Self {
+            client_ip,
+            request_url,
+        }
+    }
+
+    pub fn log_success(self, status_code: u8) {
+        println!("{} \"{}\" {}", self.client_ip, self.request_url, status_code);
+    }
+
+    pub fn log_error(self, status_code: u8, error_message: &str) {
+        eprintln!("{} \"{}\" {} \"{}\"", self.client_ip, self.request_url, status_code, error_message);
+    }
+
+
+}
+
+fn extract_client_ip(stream: &TlsStream<TcpStream>) -> String {
+    match stream.get_ref() {
+        (tcp_stream, _) => {
+            match tcp_stream.peer_addr() {
+                Ok(addr) => addr.to_string(),
+                Err(_) => "unknown".to_string(),
+            }
+        }
+    }
+}
+
+pub fn init_logging(_level: &str) {
+    // Simple logging using stdout/stderr - systemd will capture this
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn test_basic_functionality() {
+        // Basic test to ensure logging module compiles
+        assert!(true);
+    }
+}

src/main.rs

@@ -0,0 +1,105 @@
+mod config;
+mod tls;
+mod request;
+mod server;
+mod logging;
+
+use clap::Parser;
+use rustls::ServerConfig;
+use std::path::Path;
+use std::sync::Arc;
+use tokio::net::TcpListener;
+use tokio_rustls::TlsAcceptor;
+use logging::init_logging;
+
+
+
+#[derive(Parser)]
+#[command(author, version, about, long_about = None)]
+struct Args {
+    /// Path to config file
+    #[arg(short, long)]
+    config: Option<String>,
+
+    /// Directory to serve files from
+    #[arg(short, long)]
+    root: Option<String>,
+
+    /// Path to certificate file
+    #[arg(short, long)]
+    cert: Option<String>,
+
+    /// Path to private key file
+    #[arg(short, long)]
+    key: Option<String>,
+
+    /// Port to listen on
+    #[arg(short, long)]
+    port: Option<u16>,
+
+    /// Hostname for the server
+    #[arg(short = 'H', long)]
+    host: Option<String>,
+}
+
+
+
+#[tokio::main]
+async fn main() {
+    let args = Args::parse();
+
+    // Load config
+    let config_path = args.config.as_deref().unwrap_or("/etc/pollux/config.toml");
+    let config = config::load_config(config_path).unwrap_or(config::Config {
+        root: None,
+        cert: None,
+        key: None,
+        host: None,
+        port: None,
+        log_level: None,
+    });
+
+    // Initialize logging
+    let log_level = config.log_level.as_deref().unwrap_or("info");
+    init_logging(log_level);
+
+    // Merge config with args (args take precedence)
+    let root = args.root.or(config.root).expect("root is required");
+    let cert = args.cert.or(config.cert).expect("cert is required");
+    let key = args.key.or(config.key).expect("key is required");
+    let host = args.host.or(config.host).unwrap_or_else(|| "0.0.0.0".to_string());
+    let port = args.port.or(config.port).unwrap_or(1965);
+
+    // Validate directory
+    let dir_path = Path::new(&root);
+    if !dir_path.exists() || !dir_path.is_dir() {
+        eprintln!("Error: Directory '{}' does not exist or is not a directory", root);
+        std::process::exit(1);
+    }
+
+    // Load TLS certificates
+    let certs = tls::load_certs(&cert).unwrap();
+    let key = tls::load_private_key(&key).unwrap();
+
+    let config = ServerConfig::builder()
+        .with_safe_defaults()
+        .with_no_client_auth()
+        .with_single_cert(certs, key).unwrap();
+
+    let acceptor = TlsAcceptor::from(Arc::new(config));
+
+    let listener = TcpListener::bind(format!("{}:{}", host, port)).await.unwrap();
+    println!("Server listening on {}:{}", host, port);
+
+    loop {
+        let (stream, _) = listener.accept().await.unwrap();
+        let acceptor = acceptor.clone();
+        let dir = root.clone();
+        let expected_host = host.clone();
+        if let Ok(stream) = acceptor.accept(stream).await {
+            if let Err(e) = server::handle_connection(stream, &dir, &expected_host).await {
+                tracing::error!("Error handling connection: {}", e);
+            }
+        }
+    }
+}

src/request.rs

@@ -0,0 +1,119 @@
+use path_security::validate_path;
+use std::path::{Path, PathBuf};
+
+pub fn parse_gemini_url(request: &str, expected_host: &str) -> Result<String, ()> {
+    if let Some(url) = request.strip_prefix("gemini://") {
+        let host_end = url.find('/').unwrap_or(url.len());
+        let host = &url[..host_end];
+        if host != expected_host {
+            return Err(());  // Hostname mismatch
+        }
+        let path = if host_end < url.len() { &url[host_end..] } else { "/" };
+        Ok(path.trim().to_string())
+    } else {
+        Err(())
+    }
+}
+
+pub fn resolve_file_path(path: &str, dir: &str) -> Result<PathBuf, ()> {
+    let file_path_str = if path == "/" {
+        "index.gmi".to_string()
+    } else if path.ends_with('/') {
+        format!("{}index.gmi", &path[1..])
+    } else {
+        path[1..].to_string()
+    };
+
+    match validate_path(Path::new(&file_path_str), Path::new(dir)) {
+        Ok(safe_path) => Ok(safe_path),
+        Err(_) => Err(()),
+    }
+}
+
+pub fn get_mime_type(file_path: &Path) -> &str {
+    if let Some(ext) = file_path.extension() {
+        match ext.to_str() {
+            Some("gmi") => "text/gemini",
+            Some("txt") => "text/plain",
+            Some("html") => "text/html",
+            Some("png") => "image/png",
+            Some("jpg") | Some("jpeg") => "image/jpeg",
+            Some("webp") => "image/webp",
+            Some("gif") => "image/gif",
+            _ => "application/octet-stream",
+        }
+    } else {
+        "application/octet-stream"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::TempDir;
+
+    #[test]
+    fn test_parse_gemini_url_valid() {
+        assert_eq!(parse_gemini_url("gemini://gemini.jeena.net/", "gemini.jeena.net"), Ok("/".to_string()));
+        assert_eq!(parse_gemini_url("gemini://gemini.jeena.net/posts/test", "gemini.jeena.net"), Ok("/posts/test".to_string()));
+    }
+
+    #[test]
+    fn test_parse_gemini_url_invalid_host() {
+        assert!(parse_gemini_url("gemini://foo.com/", "gemini.jeena.net").is_err());
+    }
+
+    #[test]
+    fn test_parse_gemini_url_no_prefix() {
+        assert!(parse_gemini_url("http://gemini.jeena.net/", "gemini.jeena.net").is_err());
+    }
+
+    #[test]
+    fn test_resolve_file_path_root() {
+        let temp_dir = TempDir::new().unwrap();
+        assert!(resolve_file_path("/", temp_dir.path().to_str().unwrap()).is_ok());
+    }
+
+    #[test]
+    fn test_resolve_file_path_directory() {
+        let temp_dir = TempDir::new().unwrap();
+        std::fs::create_dir(temp_dir.path().join("test")).unwrap();
+        assert!(resolve_file_path("/test/", temp_dir.path().to_str().unwrap()).is_ok());
+    }
+
+    #[test]
+    fn test_resolve_file_path_file() {
+        let temp_dir = TempDir::new().unwrap();
+        assert!(resolve_file_path("/test.gmi", temp_dir.path().to_str().unwrap()).is_ok());
+    }
+
+    #[test]
+    fn test_resolve_file_path_traversal() {
+        let temp_dir = TempDir::new().unwrap();
+        assert!(resolve_file_path("/../etc/passwd", temp_dir.path().to_str().unwrap()).is_err());
+    }
+
+    #[test]
+    fn test_get_mime_type_gmi() {
+        let path = Path::new("test.gmi");
+        assert_eq!(get_mime_type(path), "text/gemini");
+    }
+
+    #[test]
+    fn test_get_mime_type_png() {
+        let path = Path::new("test.png");
+        assert_eq!(get_mime_type(path), "image/png");
+    }
+
+    #[test]
+    fn test_get_mime_type_unknown() {
+        let path = Path::new("test.xyz");
+        assert_eq!(get_mime_type(path), "application/octet-stream");
+    }
+
+    #[test]
+    fn test_get_mime_type_no_extension() {
+        let path = Path::new("test");
+        assert_eq!(get_mime_type(path), "application/octet-stream");
+    }
+}

src/server.rs

@@ -0,0 +1,101 @@
+use crate::request::{parse_gemini_url, resolve_file_path, get_mime_type};
+use crate::logging::RequestLogger;
+use std::fs;
+use std::io;
+use std::path::Path;
+use tokio::io::{AsyncReadExt, AsyncWriteExt};
+use tokio::net::TcpStream;
+use tokio::time::{timeout, Duration};
+use tokio_rustls::server::TlsStream;
+
+pub async fn serve_file(
+    stream: &mut TlsStream<TcpStream>,
+    file_path: &Path,
+) -> io::Result<()> {
+    if file_path.exists() && file_path.is_file() {
+        let mime_type = get_mime_type(&file_path);
+        let content = fs::read(&file_path)?;
+        let mut response = format!("20 {}\r\n", mime_type).into_bytes();
+        response.extend(content);
+        stream.write_all(&response).await?;
+        stream.flush().await?;
+        Ok(())
+    } else {
+        Err(io::Error::new(io::ErrorKind::NotFound, "File not found"))
+    }
+}
+
+pub async fn handle_connection(
+    mut stream: TlsStream<TcpStream>,
+    dir: &str,
+    expected_host: &str,
+) -> io::Result<()> {
+    const MAX_REQUEST_SIZE: usize = 4096;
+    const REQUEST_TIMEOUT: Duration = Duration::from_secs(10);
+
+    let mut request_buf = Vec::new();
+    let read_future = async {
+        loop {
+            if request_buf.len() >= MAX_REQUEST_SIZE {
+                return Err(io::Error::new(io::ErrorKind::InvalidData, "Request too large"));
+            }
+            let mut byte = [0; 1];
+            stream.read_exact(&mut byte).await?;
+            request_buf.push(byte[0]);
+            if request_buf.ends_with(b"\r\n") {
+                break;
+            }
+        }
+        Ok(())
+    };
+
+    if timeout(REQUEST_TIMEOUT, read_future).await.is_err() {
+        let request_str = String::from_utf8_lossy(&request_buf).trim().to_string();
+        let logger = RequestLogger::new(&stream, request_str);
+        logger.log_error(59, "Request timeout");
+        send_response(&mut stream, "59 Bad Request\r\n").await?;
+        return Ok(());
+    }
+
+    let request = String::from_utf8_lossy(&request_buf).trim().to_string();
+
+    // Parse Gemini URL
+    let path = match parse_gemini_url(&request, expected_host) {
+        Ok(p) => p,
+        Err(_) => {
+            let logger = RequestLogger::new(&stream, request.clone());
+            logger.log_error(59, "Invalid URL format");
+            send_response(&mut stream, "59 Bad Request\r\n").await?;
+            return Ok(());
+        }
+    };
+
+    // Initialize logger now that we have the full request URL
+    let logger = RequestLogger::new(&stream, request.clone());
+
+    // Resolve file path with security
+    let file_path = match resolve_file_path(&path, dir) {
+        Ok(fp) => fp,
+        Err(_) => {
+            logger.log_error(59, "Path traversal attempt");
+            return send_response(&mut stream, "59 Bad Request\r\n").await;
+        }
+    };
+
+    // Serve the file
+    match serve_file(&mut stream, &file_path).await {
+        Ok(_) => logger.log_success(20),
+        Err(_) => logger.log_error(51, "File not found"),
+    }
+    
+    Ok(())
+}
+
+async fn send_response(
+    stream: &mut TlsStream<TcpStream>,
+    response: &str,
+) -> io::Result<()> {
+    stream.write_all(response.as_bytes()).await?;
+    stream.flush().await?;
+    Ok(())
+}

src/tls.rs

@@ -0,0 +1,28 @@
+use std::fs;
+use std::io::{self, BufReader};
+
+pub fn load_certs(filename: &str) -> io::Result<Vec<rustls::Certificate>> {
+    let certfile = fs::File::open(filename)?;
+    let mut reader = BufReader::new(certfile);
+    rustls_pemfile::certs(&mut reader)?
+        .into_iter()
+        .map(|v| Ok(rustls::Certificate(v)))
+        .collect()
+}
+
+pub fn load_private_key(filename: &str) -> io::Result<rustls::PrivateKey> {
+    let keyfile = fs::File::open(filename)?;
+    let mut reader = BufReader::new(keyfile);
+
+    loop {
+        match rustls_pemfile::read_one(&mut reader)? {
+            Some(rustls_pemfile::Item::RSAKey(key)) => return Ok(rustls::PrivateKey(key)),
+            Some(rustls_pemfile::Item::PKCS8Key(key)) => return Ok(rustls::PrivateKey(key)),
+            Some(rustls_pemfile::Item::ECKey(key)) => return Ok(rustls::PrivateKey(key)),
+            None => break,
+            _ => {}
+        }
+    }
+
+    Err(io::Error::new(io::ErrorKind::InvalidData, "No supported private key found"))
+}