serve.rs

//! A small server for trying hongo from a browser
//!
//! Paste the source text and press the button, and it becomes a PDF that is shown on the screen
//! and can also be saved.
//!
//! Usage:
//!   cargo run --release --example serve
//!   cargo run --release --example serve -- --port 8080 --font-japanese font/ipaexm.ttf
//!
//! Open http://127.0.0.1:7830. It does not accept connections from other machines.

use hongo::style::Style;
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::path::{Path, PathBuf};
use std::sync::Arc;


/// The maximum size of the source text it accepts
const LIMIT: usize = 4 * 1024 * 1024;


/// The directory from which images and `\input` files are looked for
const BASE: &str = "test";


/// The sample that is filled in from the start
const SAMPLE: &str = include_str!("../test/report.tex");


const PAGE: &str = include_str!("serve.html");


fn main() {
    let mut argument: Vec<String> = std::env::args().skip(1).collect();
    let port = take(&mut argument, "--port").unwrap_or_else(|| "7830".to_string());
    let japanese = take(&mut argument, "--font-japanese").map(PathBuf::from);
    let math = PathBuf::from("font/latinmodern-math.otf");

    if !math.is_file() {
        eprintln!("font/latinmodern-math.otf がありません");
        std::process::exit(1);
    }

    let japanese = japanese.or_else(|| any_font(&math));

    if japanese.is_none() {
        eprintln!("和文の書体がありません。font/ に明朝体を置くと日本語が出ます");
    }

    let library = match hongo::font::open(
        &math,
        None,
        None,
        None,
        None,
        None,
        japanese.as_deref(),
    ) {
        Ok(library) => Arc::new(library),
        Err(reason) => {
            eprintln!("書体を読めません: {reason}");
            std::process::exit(1);
        }
    };
    let address = format!("127.0.0.1:{port}");
    let listener = match TcpListener::bind(&address) {
        Ok(listener) => listener,
        Err(reason) => {
            eprintln!("{address} を開けません: {reason}");
            std::process::exit(1);
        }
    };
    println!("http://{address} を開いてください");

    for coming in listener.incoming() {
        let stream = match coming {
            Ok(stream) => stream,
            Err(_) => continue,
        };
        let library = Arc::clone(&library);
        std::thread::spawn(move || answer(stream, &library));
    }
}


/// Takes out one option
fn take(argument: &mut Vec<String>, name: &str) -> Option<String> {
    let at = argument.iter().position(|one| one == name)?;

    if at + 1 >= argument.len() {
        eprintln!("{name} のあとに値を書いてください");
        std::process::exit(1);
    }

    let value = argument.remove(at + 1);
    argument.remove(at);

    Some(value)
}


/// Looks for one typeface in font/ that is not the math typeface
fn any_font(except: &Path) -> Option<PathBuf> {
    let mut found: Vec<PathBuf> = std::fs::read_dir("font")
        .ok()?
        .filter_map(|entry| entry.ok())
        .map(|entry| entry.path())
        .filter(|path| {
            let suffix = path
                .extension()
                .and_then(|one| one.to_str())
                .unwrap_or_default()
                .to_lowercase();

            matches!(suffix.as_str(), "otf" | "ttf" | "ttc") && path != except
        })
        .collect();
    found.sort();

    found.into_iter().next()
}


/// Responds to one incoming connection
fn answer(mut stream: TcpStream, library: &hongo::Library) {
    let mut reader = match stream.try_clone() {
        Ok(copy) => BufReader::new(copy),
        Err(_) => return,
    };
    let mut head = String::new();

    if reader.read_line(&mut head).is_err() {
        return;
    }

    let mut length = 0;

    loop {
        let mut line = String::new();

        match reader.read_line(&mut line) {
            Ok(0) => break,
            Ok(_) => {}
            Err(_) => return,
        }

        if line.trim().is_empty() {
            break;
        }

        if let Some(value) = line.to_lowercase().strip_prefix("content-length:") {
            length = value.trim().parse::<usize>().unwrap_or(0).min(LIMIT);
        }
    }

    let mut word = head.split_whitespace();
    let method = word.next().unwrap_or_default();
    let path = word.next().unwrap_or_default();

    match (method, path) {
        ("GET", "/") => send(&mut stream, "200 OK", "text/html; charset=utf-8", "", PAGE.as_bytes()),
        ("GET", "/sample") => send(
            &mut stream,
            "200 OK",
            "text/plain; charset=utf-8",
            "",
            SAMPLE.as_bytes(),
        ),
        ("POST", "/pdf") => {
            let mut body = vec![0; length];

            if reader.read_exact(&mut body).is_err() {
                send(&mut stream, "400 Bad Request", "text/plain; charset=utf-8", "", b"");

                return;
            }

            let source = String::from_utf8_lossy(&body).to_string();
            make(&mut stream, &source, library);
        }
        _ => send(
            &mut stream,
            "404 Not Found",
            "text/plain; charset=utf-8",
            "",
            "ありません".as_bytes(),
        ),
    }
}


/// Typesets the source text and sends the result back
fn make(stream: &mut TcpStream, source: &str, library: &hongo::Library) {
    let style = Style::default();

    match hongo::render(source, library, &style, Path::new(BASE)) {
        Ok(made) => {
            let missing: String = made.missing.iter().collect();
            let extra = format!(
                "X-Page: {}\r\nX-Missing: {}\r\nContent-Disposition: inline; filename=\"hongo.pdf\"\r\n",
                made.page,
                escape(&missing)
            );
            send(stream, "200 OK", "application/pdf", &extra, &made.data);
        }
        Err(reason) => send(
            stream,
            "400 Bad Request",
            "text/plain; charset=utf-8",
            "",
            reason.message.as_bytes(),
        ),
    }
}


/// Turns characters that are not ASCII into %XX so that they can go in a header
fn escape(text: &str) -> String {
    let mut out = String::new();

    for byte in text.as_bytes() {
        if byte.is_ascii_alphanumeric() {
            out.push(*byte as char);

        } else {
            out.push_str(&format!("%{byte:02X}"));
        }
    }

    out
}


/// Writes the response
fn send(stream: &mut TcpStream, status: &str, kind: &str, extra: &str, body: &[u8]) {
    let head = format!(
        "HTTP/1.1 {status}\r\nContent-Type: {kind}\r\nContent-Length: {}\r\n\
Cache-Control: no-store\r\n{extra}Connection: close\r\n\r\n",
        body.len()
    );
    let _ = stream.write_all(head.as_bytes());
    let _ = stream.write_all(body);
    let _ = stream.flush();
}