atmos/kernel/

tls.rs

#![allow(dead_code)]

extern crate alloc;
use alloc::string::String;
use alloc::vec::Vec;

use embedded_tls::blocking::{TlsConnection, TlsContext};
use embedded_tls::TlsConfig;
use rand_core::{CryptoRng, RngCore};

// --- OsRng Implementation ---

pub struct OsRng {
    state: u32,
}

impl Default for OsRng {
    fn default() -> Self {
        Self::new()
    }
}

/// 【2026-07-24診断用】`get_ticks()`だけをシードにすると、短時間に連続して
/// TLS接続を開く場合（例: 外部CSS/フォントの立て続けの取得）に同じ`tick`値を
/// 読んでしまい、複数の接続で全く同一の「乱数」シーケンス（ClientHello random、
/// 鍵交換の一時鍵等）が生成されうる。1回目のHTTPS接続は成功するが2回目以降が
/// 毎回TLSハンドシェイクに失敗する未解明の現象の調査の一環として、呼び出し毎に
/// 必ず異なる値になるよう単調増加カウンタを合成し、この可能性を切り分ける。
static OS_RNG_CALL_COUNTER: core::sync::atomic::AtomicU32 = core::sync::atomic::AtomicU32::new(0);

impl OsRng {
    pub fn new() -> Self {
        let t = crate::kernel::timer::get_ticks() as u32;
        let call_no = OS_RNG_CALL_COUNTER.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
        let seed = t ^ call_no.wrapping_mul(0x9E37_79B9);
        Self {
            state: if seed == 0 { 0xA11C0B0B } else { seed },
        }
    }
}

impl RngCore for OsRng {
    fn next_u32(&mut self) -> u32 {
        let mut x = self.state;
        x ^= x << 13;
        x ^= x >> 17;
        x ^= x << 5;
        self.state = x;
        x
    }
    fn next_u64(&mut self) -> u64 {
        ((self.next_u32() as u64) << 32) | (self.next_u32() as u64)
    }
    fn fill_bytes(&mut self, dest: &mut [u8]) {
        for chunk in dest.chunks_mut(4) {
            let val = self.next_u32().to_le_bytes();
            let len = chunk.len();
            chunk.copy_from_slice(&val[..len]);
        }
    }
    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), rand_core::Error> {
        self.fill_bytes(dest);
        Ok(())
    }
}

impl CryptoRng for OsRng {}

/// 【2026-08-05 計測】`retry_write` 経路で送信後に待った累計 tick と回数。
///
/// 変更の効果を「ページ読み込み全体」から推し量ると、
/// ホスト負荷のばらつきに埋もれて A/B のための往復が何度も要る。
/// **変えた当人を直接測れば 1 回の実行で判定できる。**
pub static WRITE_WAIT_TICKS: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
pub static WRITE_WAIT_CALLS: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);
/// そのうち再送に至った回数（＝本当に応答が来なかった回）。
pub static WRITE_RETX_COUNT: core::sync::atomic::AtomicU32 =
    core::sync::atomic::AtomicU32::new(0);

// --- TcpIoWrapper Implementation ---

pub struct TcpIoWrapper {
    pub local_port: u16,
    buffer: Vec<u8>,
    /// `buffer` の読み出し済み位置。
    ///
    /// 【2026-08-05】以前は読むたびに `buffer.drain(0..len)` していた。
    /// TLS はレコードヘッダ 5 バイトのように**小さく読む**ので、
    /// そのたびに残り全体を前へ詰め直すことになり O(n²) だった。
    ///
    /// 一斉計測で受信ループの内訳を割ったところ、
    ///
    /// ```text
    /// 受信待ち=40968/16661
    ///   受信sleep=8102/5191   recv呼出=233/6684
    /// ```
    ///
    /// sleep でも recv でもない**残り 32633 tick** がここだった。
    /// 位置を持てば詰め直しが要らない。
    pos: usize,
    // 【2026-07-24】書き込み後、応答が全く届かない場合に同一データを一度だけ
    // 再送するかどうか。この自作TCPスタックには再送機構が無く、ネットワーク上
    // でのパケットロス（特に外部CSS/フォント取得等、メインページ取得の直後に
    // 連続して発生する2回目以降のHTTPS接続で顕著）でハンドシェイクが失敗する
    // 問題への対策。既存の安定した経路（メインページ取得の`https_get`）へ
    // 影響を与えないよう、`https_get_binary`（外部リソース取得側）でのみ
    // `true`にする。
    retry_write: bool,
}

impl TcpIoWrapper {
    pub fn new(local_port: u16) -> Self {
        Self {
            local_port,
            buffer: Vec::new(),
            pos: 0,
            retry_write: false,
        }
    }

    pub fn new_with_retry_write(local_port: u16) -> Self {
        Self {
            local_port,
            buffer: Vec::new(),
            pos: 0,
            retry_write: true,
        }
    }
}

impl embedded_io::ErrorType for TcpIoWrapper {
    type Error = embedded_io::ErrorKind;
}

impl embedded_io::Read for TcpIoWrapper {
    fn read(&mut self, buf: &mut [u8]) -> Result<usize, Self::Error> {
        if buf.is_empty() {
            return Ok(0);
        }
        let _pr = crate::os_lib::web_engine::perf::start();
        let start_tick = crate::kernel::timer::get_ticks();
        // 15秒タイムアウト。大きな応答 (検索結果 ~30KB 等) はサーバ処理 + 小受信ウィンドウ
        // による多数の往復で到着が遅延バーストになりがちで、5秒では先頭バイト到着前に
        // 取りこぼすことがあった。
        let timeout_ticks = 1500usize; // 15秒 (1500 * 10ms)

        // 【2026-08-05】待ちの粒度は 10ms（`sleep(1)`）だった。
        //
        // 内訳を測ると受信待ち 12496 tick のうち 12231 tick が
        // この `sleep` そのもの（6234 回 × 約 2 tick）。
        // データは 10ms より短い間隔で届きうるので、
        // 眠るとそのぶん取りこぼす。
        //
        // 【2026-08-05 検証済み・入れていない】
        // 「まず 32 回は `yield_now()` で粘る」を試し、`受信待ち` を直接測った。
        //
        // ```text
        // 修正前: 受信待ち=12496  受信sleep=12231/6234
        // 修正後: 受信待ち=11535  受信sleep=10741/30291
        // ```
        //
        // **8% しか縮まらず、譲る回数は 5 倍**（6234 → 30291）。
        // データは実際に 10ms より早くは届いていない。
        // 縮まらないのに文脈切り替えを 3 万回増やすのは割に合わない。
        //
        // ここの待ちは**正当なネットワーク遅延**であり、無駄ではない。
        // 削るなら待ち方ではなく、往復回数そのものを減らす方向
        // （受信ウィンドウは検証済みで効かず。`spec/l1_l2_usb.md` 参照）。
        loop {
            if self.pos < self.buffer.len() {
                let avail = self.buffer.len() - self.pos;
                let len = avail.min(buf.len());
                buf[..len].copy_from_slice(&self.buffer[self.pos..self.pos + len]);
                self.pos += len;
                // 読み切ったら領域を返す（容量は保つので再確保は起きない）。
                if self.pos == self.buffer.len() {
                    self.buffer.clear();
                    self.pos = 0;
                }
                crate::os_lib::web_engine::perf::add(
                    crate::os_lib::web_engine::perf::Slot::TlsReadWait,
                    _pr,
                );
                return Ok(len);
            }

            // tcp_recv_real(.., 1) は即時タイムアウトで Err を返すが、これは
            // 「まだデータが来ていない」だけであり EOF ではない。
            // EOF 判定は下の tcp_is_socket_closed で行う（旧実装は Err を EOF と
            // 誤解釈し、応答到着前の読みで body が空になるバグがあった）。
            if let Ok(chunk) = crate::kernel::net::tcp_recv_real(self.local_port, 1) {
                if !chunk.is_empty() {
                    // 追記する前に、読み終わった前半を捨てて詰める。
                    // 毎回の読み出しでは詰めない（そこが O(n²) の原因だった）。
                    if self.pos > 0 {
                        self.buffer.drain(0..self.pos);
                        self.pos = 0;
                    }
                    self.buffer.extend_from_slice(&chunk);
                    continue; // Loop back to read from buffer
                }
            }

            if crate::kernel::net::tcp_is_socket_closed(self.local_port)
                && self.pos >= self.buffer.len()
            {
                // 【2026-07-29診断】応答が Content-Length に届かず途中で切れる件。
                // 受信ループがどの条件で抜けたかを一意に記録する。
                // 【2026-09-26】理由（状態・FIN・保持中の順序外セグメント数）を実際に出す。
                crate::warn!(
                    "[TLS][EOF] local_port={} {}",
                    self.local_port,
                    crate::kernel::net::tcp::tcp_close_diag(self.local_port)
                );
                return Ok(0); // EOF
            }

            // タイムアウト判定
            let elapsed = crate::kernel::timer::get_ticks().wrapping_sub(start_tick);
            if elapsed >= timeout_ticks {
                // 【2026-08-02】**失敗は必ずログに残す**。
                // 冗長な情報ログの整理をしたとき、このタイムアウトログまで
                // 一緒に消してしまい「失敗しているのに何も出ない」状態を作った。
                // 規約は `spec/logging_policy.md`。
                crate::warn!(
                    "[TLS][TIMEOUT] 受信タイムアウト local_port={} elapsed_ticks={} timeout_ticks={} seg_accepted={} seg_dropped={}",
                    self.local_port,
                    elapsed,
                    timeout_ticks,
                    crate::kernel::net::tcp::SEG_ACCEPTED.load(core::sync::atomic::Ordering::Relaxed),
                    crate::kernel::net::tcp::SEG_DROPPED.load(core::sync::atomic::Ordering::Relaxed)
                );
                return Err(embedded_io::ErrorKind::TimedOut);
            }

            // 【2026-08-05 検証済み・変更せず】ここを「まず数十回は
            // `yield_now()` で粘り、それでも来なければ眠る」に変えて測ったが、
            // 3.7MB の取得は 3746 → 3704 tick で**変わらなかった**。
            // 待ち方の粒度は律速ではない（律速は USB 転送の内側）。
            //
            crate::kernel::scheduler::sleep(1);
        }
    }
}

impl embedded_io::Write for TcpIoWrapper {
    fn write(&mut self, buf: &[u8]) -> Result<usize, Self::Error> {
        // 【2026-08-31 バグ修正】MSS 相当のセグメント分割が未実装だった。
        //
        // `build_tcp_ipv4` が組む IP+TCP ヘッダは 40 バイト（オプション無し）、
        // `transmit_nic_ipv4_packet` はヘッダ込みで `NIC_TX_MAX_PAYLOAD`
        // （1536 バイト）を超えると `Err("packet too large")` を返す。
        // つまりこの `write()` に渡せる 1 回分の実ペイロードは最大 1496 バイト。
        // TLS レコードは最大 16KB あり、`embedded_tls` がそれを分割せず
        // まるごと渡してくると、そのまま `tcp_send_real` へ流れて失敗していた
        // （`spec/TODO.md` の「TCP セグメント分割（MSS）が未実装」参照）。
        //
        // `embedded_io::Write::write()` の契約は「渡された分すべてを
        // 送る」ではなく「送れた分だけ返す」（`Ok(n)`, `n <= buf.len()`）。
        // 呼び出し側は残りを次の `write()` 呼び出しで送るのが仕様どおりの
        // 振る舞いであり、この処理系専用の再送ロジック（下記）とは無関係の
        // 別の仕組み。ここで安全な上限へ切り詰めるだけで済み、
        // 以降の再送・シーケンス番号管理は一切変更しない。
        const MAX_TCP_PAYLOAD: usize = 1400;
        let buf = if buf.len() > MAX_TCP_PAYLOAD {
            &buf[..MAX_TCP_PAYLOAD]
        } else {
            buf
        };
        // 【2026-07-24重要修正】以前は再送のたびに`tcp_send_real`を再度呼んで
        // いたが、`tcp_send_real`は呼ぶ度に無条件で`snd_nxt`を進めてしまう
        // ため、"再送"のつもりが実際には誤った（進みすぎた）シーケンス番号
        // で送信してしまい、TCP/TLSストリームを破壊する重大なバグだった
        // （結果として`embedded_tls`側が復号時に`InternalError`を返す原因に
        // なっていたと判明）。正しい再送のため、最初の送信時点の`seq`を
        // 記録しておき、再送には`snd_nxt`を変更しない`tcp_retransmit_real`
        // を使う。
        let seq_at_send = crate::kernel::net::tcp_current_snd_seq(self.local_port);
        if crate::kernel::net::tcp_send_real(self.local_port, buf).is_err() {
            return Err(embedded_io::ErrorKind::BrokenPipe);
        }
        if self.retry_write {
            if let Some(seq) = seq_at_send {
                // 送信直後、短い間隔を空けて何らかの応答（1バイトでも）が来て
                // いるか確認する。何も来ておらず、かつソケットもまだ閉じられて
                // いなければ、送信パケット自体がロストした可能性が高いと判断し、
                // 同一データ・同一シーケンス番号で最大4回まで再送する。
                // 【2026-08-05】以前はここで**確認する前に 600ms 眠って**いた
                // （`sleep(60)` を先に実行してから応答を見る）。
                //
                // 応答が 1ms で返っても 600ms 待つので、
                // TLS ハンドシェイクのように**書き込みが複数回**ある経路では
                // それだけで数秒を捨てていた。
                // 実測: 49KB の CSS 取得に 21 秒（3.7MB の画像が 27 秒＝
                // 137KB/s なのに対し、バイトあたり 50 倍遅い）。
                //
                // 待ち総量（600ms で応答が無ければ再送）は変えず、
                // 短い間隔で確かめて**来ていたら即座に抜ける**。
                /// 1 回の確認間隔（tick, 10ms 単位）。
                const POLL_STEP: usize = 3;
                /// 再送を決めるまでに待つ総量（従来と同じ 600ms）。
                const WAIT_PER_TRY: usize = 60;
                let t_w0 = crate::kernel::timer::get_ticks();
                let _pw = crate::os_lib::web_engine::perf::start();
                WRITE_WAIT_CALLS.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                'retry: for _ in 0..4 {
                    // 【2026-08-05】待ち時間を**実経過**で数える。
                    //
                    // 以前は `waited += POLL_STEP`（指定値の足し算）だった。
                    // だが一斉計測で
                    //
                    // ```text
                    // 送信待ち=12191/39
                    // sleep実測=12163/1105   ← ほぼ全部がこれ
                    // 応答確認=9/1105  eth poll=16/1105
                    // ```
                    //
                    // となり、**1105 回 × 3 tick = 3315 のはずが実測 12163**。
                    // `sleep(3)` は実際には約 11 tick かかる（3.7 倍）。
                    // スケジューラの `sleep` は「最低でもこれだけ」であって
                    // 「ちょうどこれだけ」ではない。
                    //
                    // 指定値で数えていたので、600ms のつもりが実際は 2.2 秒。
                    // 実経過で数えれば意図どおり 600ms で切り上がる。
                    let t_wait0 = crate::kernel::timer::get_ticks();
                    while crate::kernel::timer::get_ticks().wrapping_sub(t_wait0)
                        < WAIT_PER_TRY
                    {
                        // 【2026-08-05】待ちの内訳を分解する。
                        // 上限を 300ms にしても 1 回あたり 2.5 秒かかったので、
                        // 時間は「待つと決めた量」ではなく別のところで消えている。
                        let _ps = crate::os_lib::web_engine::perf::start();
                        crate::kernel::scheduler::sleep(POLL_STEP);
                        crate::os_lib::web_engine::perf::add(
                            crate::os_lib::web_engine::perf::Slot::SleepActual,
                            _ps,
                        );
                        let _pe = crate::os_lib::web_engine::perf::start();
                        crate::kernel::usb::poll_ethernet_data_plane_only();
                        crate::os_lib::web_engine::perf::add(
                            crate::os_lib::web_engine::perf::Slot::EthPoll,
                            _pe,
                        );
                        let _pk = crate::os_lib::web_engine::perf::start();
                        // 【2026-10-05】送ったデータが ACK されたら待ちを終える。従来は
                        // **応答データ**が届くまで待っており、TLS の Finished のように
                        // サーバーが何も返さない書き込みのたびに 600ms 待って再送していた
                        // （実測: 送信待ち 3278 tick / 39 回。1 ページの読込で約 33 秒）。
                        let done = crate::kernel::net::tcp_acked_through(
                            self.local_port,
                            seq.wrapping_add(buf.len() as u32),
                        ) || crate::kernel::net::tcp_recv_peek_nonempty(self.local_port)
                            || crate::kernel::net::tcp_is_socket_closed(self.local_port);
                        crate::os_lib::web_engine::perf::add(
                            crate::os_lib::web_engine::perf::Slot::PeekCheck,
                            _pk,
                        );
                        if done {
                            break 'retry;
                        }
                    }
                    // 総量を待っても何も来ない。パケットロストの疑いとして再送する。
                    WRITE_RETX_COUNT.fetch_add(1, core::sync::atomic::Ordering::Relaxed);
                    let _ = crate::kernel::net::tcp_retransmit_real(self.local_port, buf, seq);
                }
                WRITE_WAIT_TICKS.fetch_add(
                    crate::kernel::timer::get_ticks().wrapping_sub(t_w0) as u32,
                    core::sync::atomic::Ordering::Relaxed,
                );
                crate::os_lib::web_engine::perf::add(
                    crate::os_lib::web_engine::perf::Slot::TlsWriteWait,
                    _pw,
                );
            }
        }
        Ok(buf.len())
    }

    fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}


/// 【2026-07-29】HTTPS 取得の結果を段階別に集計する。
///
/// 失敗段階が実行ごとにばらつくため、単発の観測では
/// 「どの修正が効いたか」を評価できなかった（このセッションで
/// 1 回の結果から誤った断定を何度も行った直接の原因）。
/// 1 回のブート内で発生する全取得を分類して数え、
/// 毎回サマリを出すことで成功率を数値で追えるようにする。
/// 【2026-07-30】1 回の取得で許容する最大バイト数。0 なら無制限。
/// 画像のような巨大リソースを `Content-Length` の時点で打ち切るために使う。
/// 呼び出し側が設定し、取得後に必ず 0 へ戻すこと。
pub static FETCH_BYTE_CAP: core::sync::atomic::AtomicUsize =
    core::sync::atomic::AtomicUsize::new(0);

pub mod stats {
    use core::sync::atomic::{AtomicU32, Ordering::Relaxed};
    pub static OK: AtomicU32 = AtomicU32::new(0);
    pub static DNS_FAIL: AtomicU32 = AtomicU32::new(0);
    pub static CONNECT_FAIL: AtomicU32 = AtomicU32::new(0);
    pub static HANDSHAKE_FAIL: AtomicU32 = AtomicU32::new(0);
    pub static TRUNCATED: AtomicU32 = AtomicU32::new(0);

    pub fn bump(c: &AtomicU32) {
        c.fetch_add(1, Relaxed);
    }

    /// 現在の集計を 1 行で出す。分母は全試行。
    pub fn report(tag: &str) {
        let ok = OK.load(Relaxed);
        let dns = DNS_FAIL.load(Relaxed);
        let conn = CONNECT_FAIL.load(Relaxed);
        let hs = HANDSHAKE_FAIL.load(Relaxed);
        let tr = TRUNCATED.load(Relaxed);
        let total = ok + dns + conn + hs + tr;
        crate::warn!(
            "[NET][STATS] {} total={} ok={} dns_fail={} connect_fail={} handshake_fail={} truncated={}",
            tag, total, ok, dns, conn, hs, tr
        );
    }
}

pub fn https_get(
    host: &str,
    path: &str,
) -> Result<crate::kernel::net::HttpsGetResult, &'static str> {
    https_get_with_referer(host, path, None)
}

/// `Referer` ヘッダ付きの GET（`None` なら付けない）。値は呼び出し側が参照元ポリシー
/// （`strict-origin-when-cross-origin`）で決めたもの（`web_engine::referrer`）。
pub fn https_get_with_referer(
    host: &str,
    path: &str,
    referer: Option<&str>,
) -> Result<crate::kernel::net::HttpsGetResult, &'static str> {
    let ordinal = crate::kernel::net::next_https_attempt_ordinal();
    crate::warn!("[NET][DIAG] https_get ordinal={} host={} path={}", ordinal, host, path);
    let (host_only, port) = crate::kernel::net::parse_host_port_with_default(host, 443);
    let remote_ip = crate::kernel::net::dns_query_a_via_udp(host_only).inspect_err(|e| {
        crate::warn!("[NET][DIAG] https_get ordinal={} DNS FAILED err={}", ordinal, e);
        stats::bump(&stats::DNS_FAIL);
        stats::report("after-dns-fail");
    })?;
    crate::warn!("[NET][DIAG] https_get ordinal={} host={} resolved={}.{}.{}.{}", ordinal, host_only, remote_ip[0], remote_ip[1], remote_ip[2], remote_ip[3]);
    let local_port = crate::kernel::net::tcp_connect_real(remote_ip, port).inspect_err(|e| {
        crate::warn!("[NET][DIAG] https_get ordinal={} TCP CONNECT FAILED port={} err={}", ordinal, port, e);
        stats::bump(&stats::CONNECT_FAIL);
        stats::report("after-connect-fail");
    })?;

    let mut stream = TcpIoWrapper::new(local_port);
    let mut rng = OsRng::new();

    let mut read_buf = alloc::vec![0u8; 18432]; // TLS最大レコード(16640)を収容
    let mut write_buf = alloc::vec![0u8; 16384];

    // Disable cert validation for bare metal
    let config = TlsConfig::new().with_server_name(host_only);

    let mut connection: TlsConnection<'_, &mut TcpIoWrapper, embedded_tls::Aes128GcmSha256> =
        TlsConnection::new(&mut stream, &mut read_buf[..], &mut write_buf[..]);

    // Perform TLS handshake
    let mut provider =
        embedded_tls::UnsecureProvider::new::<embedded_tls::Aes128GcmSha256>(&mut rng);
    let _ph = crate::os_lib::web_engine::perf::start();
    let _open = connection.open(crate::kernel::tls::TlsContext::new(&config, &mut provider));
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::TlsHandshake,
        _ph,
    );
    if let Err(e) = _open {
        crate::warn!("[NET][DIAG] https_get ordinal={} TLS HANDSHAKE FAILED err={:?}", ordinal, e);
        stats::bump(&stats::HANDSHAKE_FAIL);
        stats::report("after-handshake-fail");
        crate::warn!("[NET][DIAG] https_get ordinal={} about to tcp_close_real", ordinal);
        let _ = crate::kernel::net::tcp_close_real(local_port);
        crate::warn!("[NET][DIAG] https_get ordinal={} tcp_close_real returned, returning Err", ordinal);
        return Err("TLS handshake failed");
    }

    // Now we can use `connection` which implements embedded_io::Read and Write
    let referer_hdr = referer.map(|r| alloc::format!("Referer: {}\r\n", r)).unwrap_or_default();
    let request = alloc::format!("GET {} HTTP/1.1\r\nHost: {}\r\nUser-Agent: Mozilla/5.0 (AtmOS Browser)\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Encoding: identity\r\n{}Connection: close\r\n\r\n", path, host, referer_hdr);
    if embedded_io::Write::write_all(&mut connection, request.as_bytes()).is_err() {
        crate::kernel::net::tcp_close_real(local_port)?;
        return Err("HTTPS request failed");
    }

    // パケットをフラッシュして確実に送信
    embedded_io::Write::flush(&mut connection).ok();

    // パケット送出とサーバ側処理のためのウェイト
    // 【2026-08-05】無条件 500ms から「届いたら即抜ける」へ（上限は同じ）。
    // 詳細は `net::tcp::wait_for_first_byte`。
    crate::kernel::net::tcp::wait_for_first_byte(local_port, 50);

    let mut raw_bytes = Vec::new();
    let mut chunk = [0u8; 1024];
    loop {
        match embedded_io::Read::read(&mut connection, &mut chunk) {
            Ok(0) => break,
            Ok(n) => raw_bytes.extend_from_slice(&chunk[..n]),
            Err(e) => {
                crate::info!("[NET] TLS read err: {:?}", e);
                break;
            }
        }
    }

    // 【2026-07-26 バグ修正】応答を 1 バイトも読めなかった場合、これまでは
    // そのまま `Ok` を返しており、呼び出し側のログにも
    // `BROWSER: Load page SUCCESS. body_len=0` と「成功」として出ていた。
    // 実際には何も取得できておらず、ブラウザは空ページを描画したうえで
    // 外部 CSS の取得すら試みない（`<link>` が 1 つも無いため）。上位の
    // リトライ機構も「成功」と受け取るので再試行されず、ページ読み込みの
    // 機会が 1 回まるごと無駄になっていた。空応答は明確に失敗として返す。
    if raw_bytes.is_empty() {
        crate::warn!(
            "[NET][DIAG] https_get ordinal={} EMPTY RESPONSE (0 bytes read) host={}",
            ordinal,
            host
        );
        let _ = crate::kernel::net::tcp_close_real(local_port);
        return Err("empty https response");
    }

    let resp_str = match alloc::string::String::from_utf8(raw_bytes.clone()) {
        Ok(s) => s,
        Err(e) => {
            let valid = e.into_bytes();
            alloc::string::String::from_utf8_lossy(&valid).into_owned()
        }
    };

    // プレビューは先頭 300 *文字*（バイト境界で切ると UTF-8 文字の途中に落ちてパニックする）。
    let preview: String = resp_str.chars().take(300).collect();
    crate::info!("[NET] HTTPS RAW RESP: [{} bytes] {:?}", resp_str.len(), preview);
    let (status_code, reason, headers, body) = crate::kernel::net::parse_http_response_text(&raw_bytes)
        .unwrap_or((
            200,
            String::from("OK"),
            alloc::collections::BTreeMap::new(),
            resp_str,
        ));
    let body_bytes = crate::kernel::net::parse_http_response_bytes(&raw_bytes)
        .map(|(_, _, _, b)| b)
        .unwrap_or_default();

    crate::kernel::net::tcp_close_real(local_port)?;

    crate::warn!(
        "[NET][DIAG] https_get ordinal={} SUCCESS body_bytes={}",
        ordinal,
        body_bytes.len()
    );

    Ok(crate::kernel::net::HttpsGetResult {
        remote_ip,
        local_port,
        tls_version: String::from("TLS1.3"),
        cipher_suite: String::from("TLS_AES_128_GCM_SHA256"),
        cert_subject: alloc::format!("CN={}", host),
        cert_issuer: String::from("Unknown Root CA"),
        cert_not_after: String::from("Unknown"),
        status_code,
        reason,
        headers,
        body,
        body_bytes,
    })
}

/// 任意メソッド + 任意ヘッダの HTTPS リクエスト（OAuth2 / REST API / XHR・fetch 用）。
/// `Authorization: Bearer ...` などの追加ヘッダを付けて送れる。body が Some なら
/// Content-Type / Content-Length を付与する（content_type が空なら付けない）。
///
/// 【2026-10-16】応答が途中で切れていたら（`http_body::is_complete_response`）、
/// 冪等なメソッド（GET/HEAD/OPTIONS）に限り最大 3 回まで取り直す。従来は接続が切れても
/// 手元の分を 200 として返し、Cloudflare が chunked で返す sugi-lab.net の papers.json
/// （150,481 B）が 129,610 B で切れて jQuery の JSON 解析が黙って失敗、論文リストが約 3 回に
/// 1 回出なかった。POST 等は二重送信になるので取り直さない。
pub fn https_request(
    method: &str,
    host: &str,
    path: &str,
    extra_headers: &[(&str, &str)],
    content_type: &str,
    body: Option<&[u8]>,
) -> Result<crate::kernel::net::HttpsGetResult, &'static str> {
    const MAX_ATTEMPTS: u32 = 3;
    let idempotent = matches!(method, "GET" | "HEAD" | "OPTIONS");
    let mut partial: Option<crate::kernel::net::HttpsGetResult> = None;
    for attempt in 1..=MAX_ATTEMPTS {
        let (res, complete) =
            match https_request_once(method, host, path, extra_headers, content_type, body) {
                Ok(r) => r,
                // 取り直しが失敗したら、途中まで届いた分を返す（従来と同じ振る舞い）。
                Err(e) => return partial.ok_or(e),
            };
        if complete || !idempotent || method == "HEAD" {
            return Ok(res);
        }
        crate::warn!(
            "[NET][DIAG] https_request 途中切れ {} {}{} attempt={}/{} body={}",
            method, host, path, attempt, MAX_ATTEMPTS, res.body_bytes.len()
        );
        partial = Some(res);
    }
    partial.ok_or("HTTPS request failed")
}

/// `https_request` の 1 回ぶん。戻り値の `bool` は応答が最後まで届いたか。
fn https_request_once(
    method: &str,
    host: &str,
    path: &str,
    extra_headers: &[(&str, &str)],
    content_type: &str,
    body: Option<&[u8]>,
) -> Result<(crate::kernel::net::HttpsGetResult, bool), &'static str> {
    let (host_only, port) = crate::kernel::net::parse_host_port_with_default(host, 443);
    let remote_ip = crate::kernel::net::dns_query_a_via_udp(host_only)?;
    let local_port = crate::kernel::net::tcp_connect_real(remote_ip, port)?;

    let mut stream = TcpIoWrapper::new(local_port);
    let mut rng = OsRng::new();

    let mut read_buf = alloc::vec![0u8; 18432];
    let mut write_buf = alloc::vec![0u8; 16384];

    let config = TlsConfig::new().with_server_name(host_only);
    let mut connection: TlsConnection<'_, &mut TcpIoWrapper, embedded_tls::Aes128GcmSha256> =
        TlsConnection::new(&mut stream, &mut read_buf[..], &mut write_buf[..]);
    let mut provider =
        embedded_tls::UnsecureProvider::new::<embedded_tls::Aes128GcmSha256>(&mut rng);
    let _ph = crate::os_lib::web_engine::perf::start();
    let _open = connection.open(crate::kernel::tls::TlsContext::new(&config, &mut provider));
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::TlsHandshake,
        _ph,
    );
    if let Err(e) = _open {
        crate::warn!("[NET] TLS handshake error: {:?}", e);
        let _ = crate::kernel::net::tcp_close_real(local_port);
        return Err("TLS handshake failed");
    }

    let mut header = alloc::format!(
        "{} {} HTTP/1.1\r\nHost: {}\r\nUser-Agent: AtmOS/1.0\r\n",
        method,
        path,
        host
    );
    // 呼び出し側（JS の fetch/XHR）が Accept を指定しなければ既定値を付ける。
    if !extra_headers.iter().any(|(k, _)| k.eq_ignore_ascii_case("accept")) {
        header.push_str("Accept: application/json\r\n");
    }
    for (k, v) in extra_headers {
        header.push_str(k);
        header.push_str(": ");
        header.push_str(v);
        header.push_str("\r\n");
    }
    let body = body.unwrap_or(&[]);
    if !content_type.is_empty() {
        header.push_str(&alloc::format!("Content-Type: {}\r\n", content_type));
    }
    if !body.is_empty() || method == "POST" || method == "PUT" || method == "PATCH" {
        header.push_str(&alloc::format!("Content-Length: {}\r\n", body.len()));
    }
    header.push_str("Accept-Encoding: identity\r\n");
    header.push_str("Connection: close\r\n\r\n");

    let mut request = header.into_bytes();
    request.extend_from_slice(body);

    if embedded_io::Write::write_all(&mut connection, &request).is_err() {
        crate::kernel::net::tcp_close_real(local_port)?;
        return Err("HTTPS request failed");
    }
    embedded_io::Write::flush(&mut connection).ok();
    // 【2026-08-05】無条件 500ms から「届いたら即抜ける」へ（上限は同じ）。
    // 詳細は `net::tcp::wait_for_first_byte`。
    crate::kernel::net::tcp::wait_for_first_byte(local_port, 50);

    let mut raw_bytes = Vec::new();
    let mut chunk = [0u8; 1024];
    loop {
        match embedded_io::Read::read(&mut connection, &mut chunk) {
            Ok(0) => break,
            Ok(n) => {
                raw_bytes.extend_from_slice(&chunk[..n]);
                // 長さの分かる応答は揃った時点で終える（keep-alive で閉じないサーバ向け）。
                if crate::kernel::http_body::is_framed_complete(&raw_bytes) {
                    break;
                }
            }
            Err(_) => break,
        }
    }

    let resp_str = match alloc::string::String::from_utf8(raw_bytes.clone()) {
        Ok(s) => s,
        Err(e) => alloc::string::String::from_utf8_lossy(&e.into_bytes()).into_owned(),
    };
    let (status_code, reason, headers, rbody) = crate::kernel::net::parse_http_response_text(&raw_bytes)
        .unwrap_or((
            200,
            String::from("OK"),
            alloc::collections::BTreeMap::new(),
            resp_str,
        ));
    // ボディの生バイト列（バイナリダウンロード向け。JSON/テキストAPIは rbody を使えばよい）。
    let body_bytes = crate::kernel::net::parse_http_response_bytes(&raw_bytes)
        .map(|(_, _, _, b)| b)
        .unwrap_or_default();
    let complete = crate::kernel::http_body::is_complete_response(&raw_bytes);
    crate::kernel::net::tcp_close_real(local_port)?;

    Ok((crate::kernel::net::HttpsGetResult {
        remote_ip,
        local_port,
        tls_version: String::from("TLS1.3"),
        cipher_suite: String::from("TLS_AES_128_GCM_SHA256"),
        cert_subject: alloc::format!("CN={}", host),
        cert_issuer: String::from("Unknown Root CA"),
        cert_not_after: String::from("Unknown"),
        status_code,
        reason,
        headers,
        body: rbody,
        body_bytes,
    }, complete))
}

/// HTTPS POST。https_get と同じ TLS 経路で、リクエスト行を POST にし
/// Content-Type / Content-Length ヘッダ + ボディを送信する。
/// フォーム送信（DuckDuckGo lite の検索等）が HTTPS で正しく届くために必須。
pub fn https_post(
    host: &str,
    path: &str,
    content_type: &str,
    body: &[u8],
) -> Result<crate::kernel::net::HttpsGetResult, &'static str> {
    let (host_only, port) = crate::kernel::net::parse_host_port_with_default(host, 443);
    let remote_ip = crate::kernel::net::dns_query_a_via_udp(host_only)?;
    let local_port = crate::kernel::net::tcp_connect_real(remote_ip, port)?;

    let mut stream = TcpIoWrapper::new(local_port);
    let mut rng = OsRng::new();

    let mut read_buf = alloc::vec![0u8; 18432]; // TLS最大レコード(16640)を収容
    let mut write_buf = alloc::vec![0u8; 16384];

    let config = TlsConfig::new().with_server_name(host_only);

    let mut connection: TlsConnection<'_, &mut TcpIoWrapper, embedded_tls::Aes128GcmSha256> =
        TlsConnection::new(&mut stream, &mut read_buf[..], &mut write_buf[..]);

    let mut provider =
        embedded_tls::UnsecureProvider::new::<embedded_tls::Aes128GcmSha256>(&mut rng);
    let _ph = crate::os_lib::web_engine::perf::start();
    let _open = connection.open(crate::kernel::tls::TlsContext::new(&config, &mut provider));
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::TlsHandshake,
        _ph,
    );
    if let Err(e) = _open {
        crate::warn!("[NET] TLS handshake error: {:?}", e);
        let _ = crate::kernel::net::tcp_close_real(local_port);
        return Err("TLS handshake failed");
    }

    // ヘッダとボディを 1 つのバッファにまとめて送る
    let header = alloc::format!(
        "POST {} HTTP/1.1\r\nHost: {}\r\nUser-Agent: Mozilla/5.0 (AtmOS Browser)\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\nAccept-Encoding: identity\r\nContent-Type: {}\r\nContent-Length: {}\r\nConnection: close\r\n\r\n",
        path, host, content_type, body.len()
    );
    let mut request = header.into_bytes();
    request.extend_from_slice(body);

    if embedded_io::Write::write_all(&mut connection, &request).is_err() {
        crate::kernel::net::tcp_close_real(local_port)?;
        return Err("HTTPS POST request failed");
    }
    embedded_io::Write::flush(&mut connection).ok();
    // 【2026-08-05】無条件 500ms から「届いたら即抜ける」へ（上限は同じ）。
    // 詳細は `net::tcp::wait_for_first_byte`。
    crate::kernel::net::tcp::wait_for_first_byte(local_port, 50);

    let mut raw_bytes = Vec::new();
    let mut chunk = [0u8; 1024];
    loop {
        match embedded_io::Read::read(&mut connection, &mut chunk) {
            Ok(0) => break,
            Ok(n) => raw_bytes.extend_from_slice(&chunk[..n]),
            // ConnectionClosed は close 後の正常終了。蓄積済みデータを使う
            Err(_) => break,
        }
    }

    let resp_str = match alloc::string::String::from_utf8(raw_bytes.clone()) {
        Ok(s) => s,
        Err(e) => alloc::string::String::from_utf8_lossy(&e.into_bytes()).into_owned(),
    };

    crate::info!("[NET] HTTPS POST: {} bytes received", resp_str.len());
    let (status_code, reason, headers, body) = crate::kernel::net::parse_http_response_text(&raw_bytes)
        .unwrap_or((
            200,
            String::from("OK"),
            alloc::collections::BTreeMap::new(),
            resp_str,
        ));
    let body_bytes = crate::kernel::net::parse_http_response_bytes(&raw_bytes)
        .map(|(_, _, _, b)| b)
        .unwrap_or_default();

    crate::kernel::net::tcp_close_real(local_port)?;

    Ok(crate::kernel::net::HttpsGetResult {
        remote_ip,
        local_port,
        tls_version: String::from("TLS1.3"),
        cipher_suite: String::from("TLS_AES_128_GCM_SHA256"),
        cert_subject: alloc::format!("CN={}", host),
        cert_issuer: String::from("Unknown Root CA"),
        cert_not_after: String::from("Unknown"),
        status_code,
        reason,
        headers,
        body,
        body_bytes,
    })
}

/// レスポンスヘッダから`Content-Length`（10進）を読み取る。無ければ`None`。
/// 同一ホストの複数パスを **1 本の接続・1 回のハンドシェイク**で取得する。
///
/// # なぜ要るのか
///
/// 【2026-08-05 実測】1 ページの読み込みで
/// `DNS=67/15 TCP接続=204/14 TLS握手=4118/14`。
/// **ハンドシェイクだけで 4118 tick（約 41 秒）**、1 回あたり約 294 tick。
/// DNS も TCP 接続も軽いので、重いのは TLS 交渉そのもの。
/// 同じホストへ毎回張り直しているのが原因。
///
/// # 応答の切れ目
///
/// keep-alive では接続が閉じないので、**どこで 1 応答が終わるか**を
/// 自分で決める必要がある。`Content-Length` を見て、その分だけ読む。
/// 見つからない応答（chunked 等）が来たらそこで打ち切り、
/// 残りは呼び出し元が個別取得へ切り替えられるよう `None` を返す。
///
/// # 戻り値
///
/// `paths` と同じ長さ。取れなかったものは `None`。
/// 途中で接続が壊れたら、それ以降は全部 `None`（呼び出し元が再取得する）。
pub fn https_get_binary_keepalive(
    host: &str,
    paths: &[String],
) -> Result<Vec<Option<Vec<u8>>>, &'static str> {
    if paths.is_empty() {
        return Ok(Vec::new());
    }
    let mut out: Vec<Option<Vec<u8>>> = Vec::with_capacity(paths.len());

    let (host_only, port) = crate::kernel::net::parse_host_port_with_default(host, 443);
    let remote_ip = crate::kernel::net::dns::dns_query_a_via_udp(host_only)?;
    let local_port = crate::kernel::net::tcp::tcp_connect_real(remote_ip, port)?;

    let mut rng = OsRng::new();
    let mut stream = TcpIoWrapper::new_with_retry_write(local_port);
    let mut read_buf = alloc::vec![0u8; 16384];
    let mut write_buf = alloc::vec![0u8; 16384];
    let config = TlsConfig::new().with_server_name(host_only);
    let mut connection: TlsConnection<'_, &mut TcpIoWrapper, embedded_tls::Aes128GcmSha256> =
        TlsConnection::new(&mut stream, &mut read_buf[..], &mut write_buf[..]);
    let mut provider =
        embedded_tls::UnsecureProvider::new::<embedded_tls::Aes128GcmSha256>(&mut rng);

    let _ph = crate::os_lib::web_engine::perf::start();
    let open = connection.open(crate::kernel::tls::TlsContext::new(&config, &mut provider));
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::TlsHandshake,
        _ph,
    );
    if open.is_err() {
        let _ = crate::kernel::net::tcp_close_real(local_port);
        return Err("TLS handshake failed");
    }

    let mut broken = false;
    for path in paths.iter() {
        if broken {
            out.push(None);
            continue;
        }
        // 最後の 1 本だけ close を伝える（サーバ側の後始末を促す）。
        let req = alloc::format!(
            concat!(
                "GET {} HTTP/1.1
",
                "Host: {}
",
                "User-Agent: Mozilla/5.0 (AtmOS Browser)
",
                "Accept: */*
",
                "Accept-Encoding: identity
",
                // 接続を閉じないよう明示する。閉じられると次のパスで
                // 張り直しになり、この関数の目的（ハンドシェイク削減）が消える。
                "Connection: keep-alive

"
            ),
            path,
            host
        );
        if embedded_io::Write::write_all(&mut connection, req.as_bytes()).is_err() {
            broken = true;
            out.push(None);
            continue;
        }
        embedded_io::Write::flush(&mut connection).ok();
        crate::kernel::net::tcp::wait_for_first_byte(local_port, 50);

        // ヘッダを読み切り、`Content-Length` の分だけ本文を読む。
        let mut buf: Vec<u8> = Vec::new();
        let mut chunk = [0u8; 1024];
        let mut header_end: Option<usize> = None;
        let mut want: Option<usize> = None;
        loop {
            if header_end.is_none() {
                if let Some(i) = crate::kernel::http_body::body_start(&buf) {
                    header_end = Some(i);
                    want = crate::kernel::http_body::content_length(&buf);
                    if want.is_none() {
                        // 長さが分からない応答は切れ目を決められない。
                        broken = true;
                        break;
                    }
                }
            }
            if let (Some(h), Some(w)) = (header_end, want) {
                if buf.len() >= h + w {
                    break;
                }
            }
            match embedded_io::Read::read(&mut connection, &mut chunk) {
                Ok(0) => {
                    broken = true;
                    break;
                }
                Ok(n) => buf.extend_from_slice(&chunk[..n]),
                Err(_) => {
                    broken = true;
                    break;
                }
            }
        }
        match (header_end, want) {
            (Some(h), Some(w)) if buf.len() >= h + w => {
                // 【2026-08-05 バグ修正】`buf[..h + w]` は**ヘッダを含んでいた**。
                //
                // `h` は本文の開始位置なので、本文は `buf[h..h + w]`。
                // ヘッダ込みで返していたため、キャッシュへ
                // `HTTP/1.1 200 OK...` ごと書き込まれ、フォント登録が
                // `[FONT] 未知のフォント形式 head=[48,54,54,50]` で失敗していた
                // （`{:02x?}` 表示なので "HTTP" の 4 文字）。
                //
                // 実害: **Font Awesome が 1 つも登録されず**、
                // ページ上のアイコンがすべて空の四角になっていた。
                // まとめ取得（keep-alive）を入れたときに混入した回帰。
                out.push(Some(crate::kernel::http_body::body_range(&buf)
                        .map(|(a, b)| buf[a..b].to_vec())
                        .unwrap_or_default()));
                stats::bump(&stats::OK);
            }
            _ => {
                out.push(None);
                broken = true;
            }
        }
    }

    let _ = crate::kernel::net::tcp_close_real(local_port);
    stats::report("after-resp");
    Ok(out)
}

// 【2026-08-05】`find_header_end` は `kernel::http_body::body_start` と
// **同じ計算を二重に持っていた**。片方だけ直す事故のもとなので一本化した。
// （実際、本文の切り出しを誤って Font Awesome が全滅した直後に気づいた）

// 【2026-08-05】`parse_content_length` も `kernel::http_body::content_length`
// と重複していた。文字列添字で値を切り出しており、
// UTF-8 の途中で切ると panic しうる書き方だった（clippy 指摘と同種）。
// バイト列で処理する `http_body` 版へ一本化する。

/// `Content-Length`が判明していて、かつ受信済みボディがそれより短い
/// （＝TLS読み取り途中で打ち切られた）場合に`true`を返す。`chunked`応答は
/// 対象外（`Content-Length`ヘッダを通常持たないため判定不能）。
fn response_looks_truncated(raw: &[u8]) -> bool {
    // 判定は `kernel::http_body::is_complete_response`（単体試験あり）へ委譲。
    // 【2026-10-16】従来の `looks_truncated` は Content-Length しか見ず、chunked の応答
    // （cdnjs・Cloudflare 経由はほぼこれ）の途中切れを完全とみなしていた。Font Awesome の
    // all.min.css（約 90KB）が 85,732 B で切れて末尾の `Font Awesome 6 Free` の @font-face が
    // 失われ、アイコンがときどき四角になった。続きから取る（Range）のは Content-Length が
    // ある応答だけ（`resume_offset`）で、chunked は最初から取り直す。
    !crate::kernel::http_body::is_complete_response(raw)
}

pub fn https_get_binary(host: &str, path: &str) -> Result<Vec<u8>, &'static str> {
    https_get_binary_policy(host, path, true)
}

/// `https_get_binary` の厳格版: 全試行で `Content-Length` に満たなければ **Err**。
///
/// 【2026-09-26 バグ修正】`https_get_binary` は全試行が途中で切れると「最も長く
/// 取れた部分」を成功として返す（CSS なら部分でも役立つため）。しかしフォント・画像は
/// 壊れたデータの方が代替表示より悪い: www.sugi-lab.net で Noto Sans JP（通常ウェイト、
/// 5,324,144 バイト）が 1,188 バイト欠けたまま登録され、**通常ウェイトの文字が
/// ページ全体で消えた**（QEMU 実画面で発見。しかも欠けたままキャッシュへ書かれる）。
/// バイナリ資源はこちらを使い、失敗なら既定フォント／代替表示へ落とす。
pub fn https_get_binary_complete(host: &str, path: &str) -> Result<Vec<u8>, &'static str> {
    https_get_binary_policy(host, path, false)
}

fn https_get_binary_policy(
    host: &str,
    path: &str,
    accept_partial: bool,
) -> Result<Vec<u8>, &'static str> {
    let _pg = crate::os_lib::web_engine::perf::start();
    let r = https_get_binary_measured(host, path, accept_partial);
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::HttpsGet,
        _pg,
    );
    r
}

fn https_get_binary_measured(
    host: &str,
    path: &str,
    accept_partial: bool,
) -> Result<Vec<u8>, &'static str> {
    const MAX_ATTEMPTS: u32 = 3;
    let ordinal = crate::kernel::net::next_https_attempt_ordinal();
    crate::warn!("[NET][DIAG] https_get_binary ordinal={} host={} path={}", ordinal, host, path);
    // 【2026-07-25】以前は`https_get_binary_attempt`内でDNS解決を毎回
    // 行っていたため、同一ホストへの再試行のたびに無駄なDNS往復が発生し、
    // DNS応答タイムアウト自体が再試行を無駄に消費する原因にもなっていた。
    // 同一ホストの名前解決結果は数秒の再試行間隔では変わらないため、
    // ここで1回だけ解決してから各TCP/TLS試行へ使い回す。
    let (host_only, port) = crate::kernel::net::parse_host_port_with_default(host, 443);
    let t_dns0 = crate::kernel::timer::get_ticks();
    let remote_ip = crate::kernel::net::dns_query_a_via_udp(host_only).inspect_err(|e| {
        crate::warn!("[NET][DIAG] https_get_binary ordinal={} DNS FAILED err={}", ordinal, e);
        stats::bump(&stats::DNS_FAIL);
        stats::report("after-dns-fail");
    })?;
    crate::warn!("[NET][DIAG] https_get_binary ordinal={} host={} resolved={}.{}.{}.{} dns_ticks={}", ordinal, host, remote_ip[0], remote_ip[1], remote_ip[2], remote_ip[3], crate::kernel::timer::get_ticks().wrapping_sub(t_dns0));
    let mut best: Option<Vec<u8>> = None;
    for attempt in 1..=MAX_ATTEMPTS {
        // 【2026-09-26】前回が途中で切れていて、サーバが Range に対応していれば続きから取る
        // （`http_body::resume_offset`／`merge_range_response`。理由はそちらの doc）。
        let resume = best.as_deref().and_then(crate::kernel::http_body::resume_offset);
        match https_get_binary_attempt(remote_ip, host, host_only, port, path, resume) {
            Ok((raw, complete)) => {
                let (raw, complete) = match (resume, best.as_deref()) {
                    (Some(off), Some(prev)) => {
                        match crate::kernel::http_body::merge_range_response(prev, off, &raw) {
                            Some(merged) => {
                                let done = !crate::kernel::http_body::looks_truncated(&merged);
                                crate::warn!(
                                    "[NET][DIAG] https_get_binary ordinal={} Range 再開 from={} +{} bytes complete={}",
                                    ordinal, off, merged.len() - prev.len(), done
                                );
                                (merged, done)
                            }
                            // 206 でない・範囲が合わない → 今回の応答を新規の全体取得として扱う。
                            None => (raw, complete),
                        }
                    }
                    _ => (raw, complete),
                };
                if complete {
                    crate::warn!(
                        "[NET][DIAG] https_get_binary ordinal={} SUCCESS attempt={} body_bytes={}",
                        ordinal, attempt, raw.len()
                    );
                    return Ok(crate::kernel::net::extract_http_body_binary(&raw));
                }
                crate::warn!(
                    "[NET][DIAG] https_get_binary ordinal={}: truncated response on attempt {}/{} ({} bytes), retrying",
                    ordinal, attempt, MAX_ATTEMPTS, raw.len()
                );
                if best.as_ref().is_none_or(|b: &Vec<u8>| raw.len() > b.len()) {
                    best = Some(raw);
                }
            }
            Err(e) => {
                crate::warn!(
                    "[NET][DIAG] https_get_binary ordinal={} attempt {}/{} FAILED err={}",
                    ordinal, attempt, MAX_ATTEMPTS, e
                );
                if attempt == MAX_ATTEMPTS {
                    return Err(e);
                }
            }
        }
    }
    // 全リトライで打ち切りが続いた場合は、最も長く取得できたものを返す
    // （何も返さないより、部分的にでもCSS/フォントが使える方が良い）。
    match best {
        Some(raw) if accept_partial => Ok(crate::kernel::net::extract_http_body_binary(&raw)),
        Some(raw) => {
            crate::warn!(
                "[NET][DIAG] https_get_binary ordinal={} 全 {} 回とも途中で切れたため不採用 (best={} bytes)",
                ordinal, MAX_ATTEMPTS, raw.len()
            );
            Err("HTTPS response truncated")
        }
        None => Err("HTTPS request failed"),
    }
}

/// 1回分のHTTPS GET試行。戻り値は(生レスポンス, Content-Lengthと矛盾なく
/// 完全に受信できたか)。呼び出し元`https_get_binary`がこれを複数回試行し、
/// 打ち切り（TLSタイムアウト等による部分受信）を検出したら再試行する。
/// `remote_ip`は呼び出し元で1回だけ解決済みのものを使い回す
/// （DNS解決自体を毎試行で繰り返さないため）。
fn https_get_binary_attempt(
    remote_ip: [u8; 4],
    host: &str,
    host_only: &str,
    port: u16,
    path: &str,
    range_from: Option<usize>,
) -> Result<(Vec<u8>, bool), &'static str> {
    crate::debug!(
        "[NET][DIAG] https_get_binary host={} resolved_ip={}.{}.{}.{}",
        host,
        remote_ip[0],
        remote_ip[1],
        remote_ip[2],
        remote_ip[3]
    );
    if tls12_hosts_contains(host_only) {
        return https_get_binary_attempt_tls12(remote_ip, host, host_only, port, path, range_from);
    }
    let t_conn0 = crate::kernel::timer::get_ticks();
    let local_port = crate::kernel::net::tcp_connect_real(remote_ip, port)?;
    let handshake_start = crate::kernel::timer::get_ticks();
    crate::debug!("[NET][DIAG] tcp_connect_real returned local_port={}", local_port);

    // 【2026-07-29 検証したが結論保留】`retry_write` は `https_get_binary` でのみ
    // 有効で、打ち切り（truncated）が起きるのもこの経路、という相関がある。
    // 積極的な再送が TLS ストリームを乱している可能性を疑い一時的に無効化して
    // 測定したが、**2 回の実行とも試行数が 1〜2 件しか得られず判断できなかった**
    // （ページが早期に失敗し後続の取得まで到達しないため）。
    // 証拠不十分のまま既存の対策を外すのは危険なので元に戻した。
    // 再検証するなら、1 回のブートで同じ URL を N 回取得する仕組みを先に用意すること。
    let mut stream = TcpIoWrapper::new_with_retry_write(local_port);
    let mut rng = OsRng::new();

    // 【2026-07-24診断】静的バッファに変更して試したがCSS取得失敗は解消せず
    // （ヒープ確保・再利用は原因ではないと判明したため、ヒープ確保に戻す）。
    let mut read_buf = alloc::vec![0u8; 18432]; // TLS最大レコード(16640)を収容
    let mut write_buf = alloc::vec![0u8; 16384];

    let config = TlsConfig::new().with_server_name(host_only);

    let mut connection: TlsConnection<'_, &mut TcpIoWrapper, embedded_tls::Aes128GcmSha256> =
        TlsConnection::new(&mut stream, &mut read_buf[..], &mut write_buf[..]);

    let mut provider =
        embedded_tls::UnsecureProvider::new::<embedded_tls::Aes128GcmSha256>(&mut rng);
    let _ph = crate::os_lib::web_engine::perf::start();
    let _open = connection.open(crate::kernel::tls::TlsContext::new(&config, &mut provider));
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::TlsHandshake,
        _ph,
    );
    if let Err(e) = _open {
        let elapsed = crate::kernel::timer::get_ticks().wrapping_sub(handshake_start);
        crate::warn!("[NET] TLS handshake error: {:?} (elapsed_ticks={})", e, elapsed);
        let _ = crate::kernel::net::tcp_close_real(local_port);
        // 【2026-10-03】TLS 1.3 で一度でもつながったホストなら、失敗は通信の問題とみなす。
        // それ以外は TLS 1.2 のみのサーバーの可能性があるので、TLS 1.2 で接続し直す。
        if tls13_hosts_contains(host_only) {
            return Err("TLS handshake failed");
        }
        return https_get_binary_attempt_tls12(remote_ip, host, host_only, port, path, range_from);
    }
    tls13_hosts_insert(host_only);
    let t_http0 = crate::kernel::timer::get_ticks();
    let r = read_http_response(&mut connection, local_port, host, path, range_from);
    let t_end = crate::kernel::timer::get_ticks();
    // 【2026-10-05】取得 1 本ごとの段階別の所要時間（高速化の対象を決めるため）。
    crate::warn!(
        "[NET][TIME] host={} path={} tcp={} tls={} http={} bytes={}",
        host,
        path.get(..path.len().min(60)).unwrap_or(path),
        handshake_start.wrapping_sub(t_conn0),
        t_http0.wrapping_sub(handshake_start),
        t_end.wrapping_sub(t_http0),
        r.as_ref().map(|(b, _)| b.len()).unwrap_or(0)
    );
    r
}

/// TLS 1.3 でつながったことのあるホスト（TLS 1.2 への切り替えをしない）。
static TLS13_HOSTS: spin::Mutex<alloc::collections::BTreeSet<String>> =
    spin::Mutex::new(alloc::collections::BTreeSet::new());
/// TLS 1.2 でしかつながらなかったホスト（次回から TLS 1.3 を試さない）。
static TLS12_HOSTS: spin::Mutex<alloc::collections::BTreeSet<String>> =
    spin::Mutex::new(alloc::collections::BTreeSet::new());

fn tls13_hosts_contains(host: &str) -> bool {
    TLS13_HOSTS.lock().contains(host)
}

fn tls13_hosts_insert(host: &str) {
    let mut s = TLS13_HOSTS.lock();
    if !s.contains(host) {
        s.insert(String::from(host));
    }
}

fn tls12_hosts_contains(host: &str) -> bool {
    TLS12_HOSTS.lock().contains(host)
}

/// TLS 1.2（`kernel::tls12`）で取得する。TLS 1.3 専用の `embedded-tls` で
/// つながらないサーバー（例: sway.com）向けの代替経路。
fn https_get_binary_attempt_tls12(
    remote_ip: [u8; 4],
    host: &str,
    host_only: &str,
    port: u16,
    path: &str,
    range_from: Option<usize>,
) -> Result<(Vec<u8>, bool), &'static str> {
    let local_port = crate::kernel::net::tcp_connect_real(remote_ip, port)?;
    let mut stream = TcpIoWrapper::new_with_retry_write(local_port);
    let mut rng = OsRng::new();
    match crate::kernel::tls12::Tls12::connect(&mut stream, host_only, &mut rng) {
        Ok(mut conn) => {
            crate::warn!("[NET] TLS 1.2 で接続 host={}", host);
            {
                let mut s = TLS12_HOSTS.lock();
                if !s.contains(host_only) {
                    s.insert(String::from(host_only));
                }
            }
            let r = read_http_response(&mut conn, local_port, host, path, range_from);
            conn.close();
            r
        }
        Err(e) => {
            crate::warn!("[NET] TLS 1.2 handshake error: {:?} host={}", e, host);
            let _ = crate::kernel::net::tcp_close_real(local_port);
            Err("TLS handshake failed")
        }
    }
}

/// HTTP 要求を送り、応答全体を読む（TLS 1.3 / 1.2 共通）。
fn read_http_response<C: embedded_io::Read + embedded_io::Write>(
    connection: &mut C,
    local_port: u16,
    host: &str,
    path: &str,
    range_from: Option<usize>,
) -> Result<(Vec<u8>, bool), &'static str> {

    let range_hdr = range_from
        .map(|n| alloc::format!("Range: bytes={}-\r\n", n))
        .unwrap_or_default();
    let request = alloc::format!("GET {} HTTP/1.1\r\nHost: {}\r\nUser-Agent: Mozilla/5.0 (AtmOS Browser)\r\nAccept: */*\r\nAccept-Encoding: identity\r\n{}Connection: close\r\n\r\n", path, host, range_hdr);
    if embedded_io::Write::write_all(connection, request.as_bytes()).is_err() {
        crate::kernel::net::tcp_close_real(local_port)?;
        return Err("HTTPS request failed");
    }

    embedded_io::Write::flush(connection).ok();
    // 【2026-08-05】無条件 500ms から「届いたら即抜ける」へ（上限は同じ）。
    // 詳細は `net::tcp::wait_for_first_byte`。
    crate::kernel::net::tcp::wait_for_first_byte(local_port, 50);

    let mut body_bytes = Vec::new();
    let mut chunk = [0u8; 1024];
    loop {
        match embedded_io::Read::read(connection, &mut chunk) {
            Ok(0) => break,
            Ok(n) => {
                body_bytes.extend_from_slice(&chunk[..n]);
                // 【2026-09-26】`Content-Length` 分を受け取り終えたら接続終了（FIN）を
                // 待たずに抜ける。FIN が順序外で保留されると、本文は揃っているのに
                // 受信タイムアウト（15 秒）まで待ち続けることがあった。
                if crate::kernel::http_body::body_range(&body_bytes).is_some() {
                    break;
                }
                // 【2026-07-30】取得サイズの上限。0 なら無制限。
                // 画像のように巨大なリソースは、`Content-Length` が分かった
                // 時点で本文を読み切らずに打ち切る。
                // 実測で 3.7MB の背景写真のダウンロードが 120 秒を使い切り、
                // 描画へ進めなくなっていた（`spec/webfont_loading.md`）。
                let cap = FETCH_BYTE_CAP.load(core::sync::atomic::Ordering::Relaxed);
                if cap > 0 {
                    let declared = crate::kernel::http_body::content_length(&body_bytes);
                    if declared.is_some_and(|c| c > cap) || body_bytes.len() > cap {
                        crate::warn!(
                            "[TLS] host={} path={} 取得を打ち切り: 上限 {} バイト超過 (declared={:?} got={})",
                            host, path, cap, declared, body_bytes.len()
                        );
                        let _ = crate::kernel::net::tcp_close_real(local_port);
                        return Err("fetch exceeds size cap");
                    }
                }
            }
            Err(e) => {
                crate::warn!("[NET][DIAG] TLS read err: {:?} body_bytes_so_far={}", e, body_bytes.len());
                break;
            }
        }
    }
    crate::warn!(
        "[NET][DIAG] read loop done, body_bytes.len()={} preview={:?}",
        body_bytes.len(),
        String::from_utf8_lossy(&body_bytes[..body_bytes.len().min(80)])
    );

    crate::kernel::net::tcp_close_real(local_port)?;

    let complete = !response_looks_truncated(&body_bytes);
    // 【2026-07-29診断】実サイトで応答が実行ごとに違う長さで途中打ち切りになる件の
    // 切り分け。Content-Length と実読バイト数、打ち切り判定の結果を突き合わせる。
    if complete {
        stats::bump(&stats::OK);
    } else {
        stats::bump(&stats::TRUNCATED);
    }
    stats::report("after-resp");
    Ok((body_bytes, complete))
}