atmos/os_lib/web_engine/

url_resolve.rs

// web_engine/url_resolve.rs - 外部CSS/リソースの相対URL解決。
// 依存: alloc のみ（ホスト側ユニットテスト tests/ から直接 #[path] 取り込み可能にするため、
// crate::os_lib/crate::kernel 側の型には一切依存しない）。

use alloc::format;
use alloc::string::String;
use alloc::vec::Vec;

/// `base_url`（絶対URL、例: `https://cdnjs.cloudflare.com/.../css/all.min.css`）を
/// 基点として、CSS内の相対URL参照（`../webfonts/x.woff2` 等）を絶対URLへ解決する。
/// 外部CSSファイル自身の場所を基準にする必要がある（HTMLドキュメント自身の
/// ホストとは異なることが多い。例: cdnjs.cloudflare.com上のCSSが参照する
/// webfontはcdnjs.cloudflare.com上の相対パス）。
pub fn resolve_url(base_url: &str, rel: &str) -> String {
    let rel = rel.trim();
    if rel.is_empty() {
        return String::from(rel);
    }
    if rel.starts_with("http://") || rel.starts_with("https://") || rel.starts_with("data:") {
        return String::from(rel);
    }
    let (scheme, rest) = if let Some(r) = base_url.strip_prefix("https://") {
        ("https://", r)
    } else if let Some(r) = base_url.strip_prefix("http://") {
        ("http://", r)
    } else {
        return String::from(rel);
    };
    let host = match rest.find('/') {
        Some(idx) => rest.get(..idx).unwrap_or(rest),
        None => rest,
    };
    if let Some(no_scheme) = rel.strip_prefix("//") {
        return format!("{}{}", scheme, no_scheme);
    }
    if let Some(abs_path) = rel.strip_prefix('/') {
        return format!("{}{}/{}", scheme, host, abs_path);
    }
    // ベースURLのパス部分から、末尾のファイル名を除いたディレクトリを求める。
    let base_path = match rest.find('/') {
        Some(idx) => rest.get(idx..).unwrap_or("/"),
        None => "/",
    };
    let mut dir_segments: Vec<&str> = base_path.split('/').collect();
    dir_segments.pop(); // 末尾のファイル名部分を除去
    for seg in rel.split('/') {
        match seg {
            "." | "" => {}
            ".." => {
                if dir_segments.len() > 1 {
                    dir_segments.pop();
                }
            }
            s => dir_segments.push(s),
        }
    }
    let joined_path = dir_segments.join("/");
    format!("{}{}{}", scheme, host, joined_path)
}

/// 外部CSSテキスト中の `url(...)` 参照を、そのCSSファイル自身の絶対URL
/// （`css_base_url`）を基準に絶対URLへ書き換える。`@font-face { src: url(...) }`
/// や `background-image: url(...)` 等、CSS内の相対パスは常にCSSファイル自身の
/// 場所基準で解決されるべき（HTMLドキュメントのURLではない）という仕様に従う。
pub fn rewrite_css_urls(css: &str, css_base_url: &str) -> String {
    if !css.contains("url(") {
        return String::from(css);
    }
    let mut out = String::with_capacity(css.len());
    let mut rest = css;
    while let Some(idx) = rest.find("url(") {
        if let Some(prefix) = rest.get(..idx) {
            out.push_str(prefix);
        }
        out.push_str("url(");
        let after_url = match rest.get(idx + 4..) {
            Some(s) => s,
            None => break,
        };
        let bytes = after_url.as_bytes();
        let mut depth = 1i32;
        let mut i = 0usize;
        while i < bytes.len() && depth > 0 {
            match bytes[i] {
                b'(' => depth += 1,
                b')' => depth -= 1,
                _ => {}
            }
            if depth > 0 {
                i += 1;
            }
        }
        let inner = after_url.get(..i).unwrap_or("");
        let trimmed = inner.trim();
        let (quote, unquoted) = if (trimmed.starts_with('"') && trimmed.ends_with('"'))
            || (trimmed.starts_with('\'') && trimmed.ends_with('\''))
        {
            let q = trimmed.get(..1).unwrap_or("");
            (q, trimmed.get(1..trimmed.len() - 1).unwrap_or(""))
        } else {
            ("", trimmed)
        };
        let resolved = resolve_url(css_base_url, unquoted);
        out.push_str(quote);
        out.push_str(&resolved);
        out.push_str(quote);
        if i < bytes.len() {
            out.push(')');
            i += 1;
        }
        rest = after_url.get(i..).unwrap_or("");
    }
    out.push_str(rest);
    out
}

/// ネットワーク切断（TLS読み取りエラー等）で外部CSSが波括弧の途中で
/// 打ち切られた場合、そのまま後続のCSS（他の`<link>`分）と連結すると、
/// 閉じられなかった`{`のせいでパーサーが「まだ前のルールの中にいる」と
/// 誤認し、以降の本物のルールを大量に読み飛ばしてしまう（2026-07-25発見）。
/// 文字列/コメントを簡易的に読み飛ばしつつ波括弧の深さを追跡し、深さが
/// 0に戻った最後の位置（＝最後まで完結した最後のトップレベルルールの
/// 直後）までに安全側で切り詰める。既に完全にバランスしている場合は
/// 元の文字列をそのまま返す。
pub fn truncate_to_balanced_css(css: &str) -> &str {
    let bytes = css.as_bytes();
    let mut depth: i32 = 0;
    let mut last_balanced_end = 0usize;
    let mut i = 0usize;
    while i < bytes.len() {
        match bytes[i] {
            b'/' if bytes.get(i + 1) == Some(&b'*') => {
                // ブロックコメント内の { } を誤ってカウントしないよう読み飛ばす。
                i += 2;
                while i < bytes.len() && !(bytes[i] == b'*' && bytes.get(i + 1) == Some(&b'/')) {
                    i += 1;
                }
                i = (i + 2).min(bytes.len());
                continue;
            }
            b'"' | b'\'' => {
                // 文字列リテラル内の { } を誤ってカウントしないよう読み飛ばす。
                let quote = bytes[i];
                i += 1;
                while i < bytes.len() && bytes[i] != quote {
                    if bytes[i] == b'\\' {
                        i += 1;
                    }
                    i += 1;
                }
                i = (i + 1).min(bytes.len());
                continue;
            }
            b'{' => {
                depth += 1;
                i += 1;
            }
            b'}' => {
                depth -= 1;
                i += 1;
                if depth <= 0 {
                    depth = 0;
                    last_balanced_end = i;
                }
            }
            _ => {
                i += 1;
            }
        }
    }
    if depth == 0 {
        css
    } else {
        css.get(..last_balanced_end).unwrap_or("")
    }
}

/// 取得先の `(https か, ホスト, パス)` を求める。
///
/// `https://h/p`・`http://h/p`・`//h/p`（プロトコル相対）・`/p`（ルート相対）を
/// 扱う。現在のページのスキームとホストを引き継ぐ場面があるので受け取る。
///
/// # なぜ共通化するか
///
/// この判定は**同じ誤りを 4 箇所で繰り返していた**。`//host/path` を
/// `starts_with('/')` の枝に巻き込み、現在のホスト配下のパスとして
/// 取りに行ってしまう誤りで、`js/builtins.rs`・`web_engine/render.rs` で
/// 個別に直された後、`fetch_script_text_inner` に 4 例目が残っていた
/// （実サイトの `//ajax.googleapis.com/.../jquery.min.js` が
/// 自ホストの HTML を返し、それを JS として実行して構文エラーになっていた）。
/// 判定を 1 箇所に集めて、5 例目が生まれないようにする。
pub fn split_target(
    url: &str,
    current_is_https: bool,
    current_host: &str,
) -> (bool, String, String) {
    fn split_host_path(rest: &str) -> (String, String) {
        match rest.find('/') {
            Some(idx) => (
                String::from(rest.get(..idx).unwrap_or(rest)),
                String::from(rest.get(idx..).unwrap_or("/")),
            ),
            None => (String::from(rest), String::from("/")),
        }
    }
    // 素片（`#...`）は取得先に含めない。
    let url = match url.split_once('#') {
        Some((before, _)) => before,
        None => url,
    };
    if let Some(rest) = url.strip_prefix("https://") {
        let (h, p) = split_host_path(rest);
        (true, h, p)
    } else if let Some(rest) = url.strip_prefix("http://") {
        let (h, p) = split_host_path(rest);
        (false, h, p)
    } else if let Some(rest) = url.strip_prefix("//") {
        // プロトコル相対。**現在のスキームを引き継ぎ、ホストは相手側**。
        // ここを `/` の枝に落とすのが繰り返された誤り。
        let (h, p) = split_host_path(rest);
        (current_is_https, h, p)
    } else if url.starts_with('/') {
        (current_is_https, String::from(current_host), String::from(url))
    } else {
        (current_is_https, String::from(current_host), String::from(url))
    }
}