atmos/kernel/

http_body.rs

//! HTTP 応答から**本文の範囲**を求める（純粋モジュール）。
//!
//! 【2026-08-05】まとめ取得（keep-alive）で
//! **ヘッダを含めて本文として返す**バグを出した。
//! キャッシュへ `HTTP/1.1 200 OK...` ごと書き込まれ、
//! Font Awesome が 1 つも登録されず、
//! ページ上のアイコンがすべて空の四角になっていた。
//!
//! 境界の計算はネットワークもハードウェアも要らないので、
//! ここへ切り出して単体試験で固定する。

/// ヘッダの終わり（＝**本文の開始位置**）を返す。
///
/// `\r\n\r\n` の**直後**を指す。見つからなければ `None`。
pub fn body_start(raw: &[u8]) -> Option<usize> {
    raw.windows(4).position(|w| w == b"\r\n\r\n").map(|i| i + 4)
}

/// `Content-Length` の値を返す（ヘッダ部だけを見る）。
pub fn content_length(raw: &[u8]) -> Option<usize> {
    let end = body_start(raw)?;
    // ヘッダは ASCII なのでバイト列のまま探す。
    // 文字列の添字操作は UTF-8 の途中で切ると panic しうる。
    const KEY: &[u8] = b"content-length:";
    let head = &raw[..end];
    let mut i = 0usize;
    while i + KEY.len() <= head.len() {
        let hit = head[i..i + KEY.len()]
            .iter()
            .zip(KEY.iter())
            .all(|(a, b)| a.to_ascii_lowercase() == *b);
        if hit {
            // 値は行末（CR）まで。先頭の空白は読み飛ばす。
            let mut j = i + KEY.len();
            let mut v: usize = 0;
            let mut seen = false;
            while j < head.len() && head[j] != 13 {
                match head[j] {
                    d @ 48..=57 => {
                        v = v.checked_mul(10)?.checked_add((d - 48) as usize)?;
                        seen = true;
                    }
                    32 | 9 if !seen => {}
                    _ => break,
                }
                j += 1;
            }
            return if seen { Some(v) } else { None };
        }
        i += 1;
    }
    None
}

/// 本文の範囲 `start..end` を返す。
///
/// **ここを間違えるとヘッダ込みで保存される**（実際に起きた）。
/// 足りていなければ `None`（まだ読み切っていない）。
pub fn body_range(raw: &[u8]) -> Option<(usize, usize)> {
    let start = body_start(raw)?;
    let len = content_length(raw)?;
    let end = start.checked_add(len)?;
    if raw.len() >= end {
        Some((start, end))
    } else {
        None
    }
}

/// 応答が**途中で切れている**か。
///
/// `Content-Length` が分かっていて、受信済み本文がそれより短ければ `true`。
/// `chunked`（長さ不明）は判定できないので `false`。
///
/// 【2026-08-05】この計算は `tls.rs` に 3 つの写しがあった
/// （`find_header_end` / `parse_content_length` / `response_looks_truncated`）。
/// 片方だけ直す事故を防ぐためここへ一本化した。
pub fn looks_truncated(raw: &[u8]) -> bool {
    let Some(start) = body_start(raw) else {
        return false;
    };
    let Some(len) = content_length(raw) else {
        return false;
    };
    raw.len().saturating_sub(start) < len
}

/// 応答（ヘッダ込みの生バイト列）が**最後まで届いたか**。
///
/// - ヘッダの終わりが無ければ不完全。
/// - 本文を持たない状態（1xx・204・304）は完全。
/// - `Transfer-Encoding: chunked` は終端（長さ 0 のチャンク）まで届いていれば完全。
/// - `Content-Length` があれば、その長さに達していれば完全。
/// - どちらも無ければ接続の切断が本文の終わり（HTTP/1.1 §6.3）なので完全とみなす。
///
/// 【2026-10-16】XHR（`tls::https_request`）は接続が途中で切れても手元の分を 200 として
/// 返していた。Cloudflare が chunked で返す papers.json（150,481 B）が 129,610 B で切れ、
/// jQuery の JSON 解析が黙って失敗して論文リストが約 3 回に 1 回出なかった。
/// 長さの分かる応答（Content-Length・chunked・本文の無いステータス）が揃ったか。
/// 接続の終わりで区切る応答（長さ情報なし）は常に false（読み続ける）。
/// 【2026-10-18】読み取りループがこれを見ずに接続が閉じる（またはタイムアウトする）まで
/// 待っており、keep-alive の動画サーバ（googlevideo）で応答ごとに 15 秒待っていた。
pub fn is_framed_complete(raw: &[u8]) -> bool {
    let Some(_) = body_start(raw) else {
        return false;
    };
    let status = raw
        .get(9..12)
        .and_then(|d| core::str::from_utf8(d).ok())
        .and_then(|d| d.parse::<u16>().ok())
        .unwrap_or(200);
    let no_body = (100..200).contains(&status) || status == 204 || status == 304;
    let chunked = header_value(raw, b"transfer-encoding:")
        .is_some_and(|v| v.to_ascii_lowercase().windows(7).any(|w| w == b"chunked"));
    if !no_body && !chunked && content_length(raw).is_none() {
        return false;
    }
    is_complete_response(raw)
}

pub fn is_complete_response(raw: &[u8]) -> bool {
    let Some(start) = body_start(raw) else {
        return false;
    };
    let status = raw
        .get(9..12)
        .and_then(|d| core::str::from_utf8(d).ok())
        .and_then(|d| d.parse::<u16>().ok())
        .unwrap_or(200);
    if (100..200).contains(&status) || status == 204 || status == 304 {
        return true;
    }
    let chunked = header_value(raw, b"transfer-encoding:")
        .is_some_and(|v| v.to_ascii_lowercase().windows(7).any(|w| w == b"chunked"));
    if chunked {
        return chunked_terminated(raw.get(start..).unwrap_or(&[]));
    }
    match content_length(raw) {
        Some(len) => raw.len().saturating_sub(start) >= len,
        None => true,
    }
}

/// chunked 本文が終端チャンク（`0\r\n`）まで揃っているか。
fn chunked_terminated(body: &[u8]) -> bool {
    let mut i = 0usize;
    loop {
        let Some(rest) = body.get(i..) else {
            return false;
        };
        let Some(eol) = rest.windows(2).position(|w| w == b"\r\n") else {
            return false;
        };
        let line = rest.get(..eol).unwrap_or(&[]);
        let size_part = line.split(|&b| b == b';').next().unwrap_or(&[]);
        let Some(size) = core::str::from_utf8(size_part)
            .ok()
            .and_then(|t| usize::from_str_radix(t.trim(), 16).ok())
        else {
            return false;
        };
        if size == 0 {
            return true;
        }
        // サイズ行 + 本文 + CRLF。
        let next = i + eol + 2 + size + 2;
        if next > body.len() {
            return false;
        }
        i = next;
    }
}

/// ヘッダ部から `name:`（小文字で渡す）の値を返す（前後の空白は除く）。
fn header_value<'a>(raw: &'a [u8], name: &[u8]) -> Option<&'a [u8]> {
    let end = body_start(raw)?;
    let head = raw.get(..end)?;
    for line in head.split(|&b| b == b'\n') {
        let line = line.strip_suffix(b"\r").unwrap_or(line);
        if line.len() > name.len()
            && line
                .iter()
                .zip(name.iter())
                .all(|(a, b)| a.to_ascii_lowercase() == *b)
        {
            let v = line.get(name.len()..)?;
            let start = v.iter().position(|b| !b.is_ascii_whitespace()).unwrap_or(v.len());
            return v.get(start..);
        }
    }
    None
}

/// 途中で切れた応答を `Range: bytes=N-` で**続きから**取り直せるなら、その N（受信済み本文長）。
///
/// 【2026-09-26】QEMU の実画面で、GitHub Pages からの数 MB の取得がホスト側接続の
/// リセット（RST）で途中切れになることがあった（パケットキャプチャで確認。
/// ゲスト側 TCP は受信窓どおりに ACK しており正常）。最初から取り直すと同じ長さを
/// また運ぶことになり、再び切れやすい。サーバが `Accept-Ranges: bytes` を返していて、
/// 本文を 1 バイト以上受け取っており、まだ足りないときだけ `Some`。
pub fn resume_offset(raw: &[u8]) -> Option<usize> {
    if !looks_truncated(raw) {
        return None;
    }
    let ar = header_value(raw, b"accept-ranges:")?;
    if !ar.eq_ignore_ascii_case(b"bytes") {
        return None;
    }
    let got = raw.len().checked_sub(body_start(raw)?)?;
    (got > 0).then_some(got)
}

/// 途中まで受け取った応答 `partial`（200・全体の `Content-Length` 付き）に、
/// `Range: bytes=off-` への応答 `resp` の本文を継ぎ足した応答を返す。
///
/// `resp` が 206 で、`Content-Range: bytes off-.../全体長` の開始位置と全体長が
/// `partial` と一致するときだけ継ぎ足す（ファイルが差し替わっていたら混ぜない）。
/// `resp` 自体が途中で切れていても、伸びた分は返す（次の再開に使う）。
pub fn merge_range_response(partial: &[u8], off: usize, resp: &[u8]) -> Option<alloc::vec::Vec<u8>> {
    let status_ok = resp.starts_with(b"HTTP/1.1 206") || resp.starts_with(b"HTTP/1.0 206");
    if !status_ok {
        return None;
    }
    let total = content_length(partial)?;
    let cr = header_value(resp, b"content-range:")?;
    let cr = cr.strip_prefix(b"bytes ")?;
    let dash = cr.iter().position(|&b| b == b'-')?;
    let slash = cr.iter().position(|&b| b == b'/')?;
    let parse = |s: &[u8]| -> Option<usize> { core::str::from_utf8(s).ok()?.trim().parse().ok() };
    let start = parse(cr.get(..dash)?)?;
    let whole = parse(cr.get(slash + 1..)?)?;
    if start != off || whole != total {
        return None;
    }
    let body = resp.get(body_start(resp)?..)?;
    let pstart = body_start(partial)?;
    if partial.len().checked_sub(pstart)? != off {
        return None;
    }
    let mut out = alloc::vec::Vec::with_capacity(partial.len() + body.len());
    out.extend_from_slice(partial);
    out.extend_from_slice(body);
    Some(out)
}