atmos/kernel/net/

tcp_state.rs

// L4 (Transport) — TCP 受信側状態機械の「純粋ロジック」。
//
// ハードウェア(NIC)・グローバル状態(`TCP_SOCKETS`/`NET_LOCK`)・ログ出力に
// 一切依存しない自己完結モジュールとして `tcp.rs` から切り出した
// （`addr_util.rs` と同じ狙い）。これによりホスト側ユニットテスト
// （`tests/`, `make test`）から `#[path]` で直接取り込み、
// パケットロス・順序逆転・重複といった**異常系を含めて**検証できる。
//
// 呼び出し側 (`tcp::parse_tcp_ipv4_packet`) の責務:
//   1. IPv4/TCP ヘッダから `Segment` を組み立てる
//   2. `on_segment()` を呼ぶ
//   3. 戻り値 `SegmentOutcome` に従って rx_buffer への追記と ACK 送信を行う
// 状態(`RecvState`)の更新は `on_segment()` が直接行う。

/// TCP フラグビット。
pub const FLAG_FIN: u8 = 0x01;
pub const FLAG_SYN: u8 = 0x02;
pub const FLAG_RST: u8 = 0x04;
pub const FLAG_PSH: u8 = 0x08;
pub const FLAG_ACK: u8 = 0x10;

#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub enum TcpState {
    Closed,
    SynSent,
    Established,
    FinWait1,
    FinWait2,
    TimeWait,
    CloseWait,
    LastAck,
}

pub fn tcp_state_name(state: TcpState) -> &'static str {
    match state {
        TcpState::Closed => "CLOSED",
        TcpState::SynSent => "SYN-SENT",
        TcpState::Established => "ESTABLISHED",
        TcpState::FinWait1 => "FIN-WAIT-1",
        TcpState::FinWait2 => "FIN-WAIT-2",
        TcpState::TimeWait => "TIME-WAIT",
        TcpState::CloseWait => "CLOSE-WAIT",
        TcpState::LastAck => "LAST-ACK",
    }
}

/// 受信した 1 セグメントのうち、状態遷移の判断に必要な情報だけを抜き出したもの。
#[derive(Copy, Clone, Debug)]
pub struct Segment {
    pub seq: u32,
    pub ack: u32,
    pub flags: u8,
    pub payload_len: u32,
}

/// ソケットのうち、受信側状態機械が読み書きする部分だけを抜き出したもの。
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct RecvState {
    pub state: TcpState,
    /// 次に自分が送信するときに使うシーケンス番号。
    pub snd_nxt: u32,
    /// 次に受信を期待するシーケンス番号（これ未満は受信済み）。
    pub rcv_nxt: u32,
    /// 相手からの FIN を「順序どおりに」受け取ったか。
    /// これが true になると上位層は EOF と解釈するため、**データの取りこぼしが
    /// ある状態で true にしてはならない**（レスポンス途中切れの直接原因になる）。
    pub fin_received: bool,
}

/// `on_segment` の結果として呼び出し側が行うべき副作用。
#[derive(Copy, Clone, PartialEq, Eq, Debug)]
pub struct SegmentOutcome {
    /// true なら、このセグメントのペイロードを rx_buffer へ追記してよい
    /// （順序どおりに到着したデータ）。false ならペイロードは破棄する。
    pub accept_payload: bool,
    /// true なら ACK を送り返す。
    pub send_ack: bool,
}

/// ソケットテーブルから空きスロットを 1 つ選ぶ（純粋ロジック）。
///
/// 実体の `TcpSocket` は `Vec` を含み `Copy` でないため配列ごと渡せない。
/// 代わりに「長さ」と「その添字が使用中か」を返すクロージャだけを受け取ることで、
/// グローバル状態から完全に切り離してテストできるようにしている。
///
/// 満杯時のエラー文字列は呼び出し側・テストの双方が依存するため定数化してある。
pub const ERR_TABLE_FULL: &str = "tcp socket table full";

pub fn find_free_slot(len: usize, is_occupied: impl Fn(usize) -> bool) -> Result<usize, &'static str> {
    for i in 0..len {
        if !is_occupied(i) {
            return Ok(i);
        }
    }
    Err(ERR_TABLE_FULL)
}

/// エフェメラルポートカウンタの次の値を、既存の生きたソケットと衝突しない
/// ところまで進めて返す（純粋ロジック）。
///
/// 【2026-08-31】カウンタは 40000 起点で単調増加し、65535 到達で
/// 40000 へラップアラウンドする。ラップアラウンド後、テーブルに残っている
/// 生きたソケットと同じローカルポートを再び払い出すと、`tcp_find_socket`
/// は `local_port + remote_ip + remote_port` の一致だけで判定するため、
/// 別の生きた接続と誤って混線するリスクがある
/// （`TCP_SOCKET_TABLE_SIZE` が小さくポート範囲が広いため実害の可能性は
/// 低いが、理論上は起こりうる。`spec/TODO.md` 参照）。
///
/// `is_in_use` が真を返す間は候補を進め続ける。全ポートが使用中
/// （テーブルが空いているのにこれが起きることは無いはずだが、
/// 呼び出し側の不整合に備えて）なら `None` を返し、
/// 呼び出し側は従来どおり衝突未確認のまま払い出すか、エラーにする。
///
/// 計算量: 最悪 O(ポート範囲) だが、通常は 0〜数回で衝突なしと判定できる。
pub fn next_ephemeral_port(start: u16, is_in_use: impl Fn(u16) -> bool) -> Option<u16> {
    const MIN: u16 = 40000;
    let mut p = if start < MIN { MIN } else { start };
    let first = p;
    loop {
        if !is_in_use(p) {
            return Some(p);
        }
        p = if p == u16::MAX { MIN } else { p + 1 };
        if p == first {
            return None;
        }
    }
}

/// RFC 1982 準拠のシリアル番号比較: `a` が `b` より新しければ true。
/// 単純な `a > b` では 2^32 の折り返し（wraparound）で誤判定するため必須。
fn seq_gt(a: u32, b: u32) -> bool {
    (a.wrapping_sub(b) as i32) > 0
}

/// 受信セグメント 1 個を状態機械へ適用する。
pub fn on_segment(st: &mut RecvState, seg: &Segment) -> SegmentOutcome {
    let mut out = SegmentOutcome {
        accept_payload: false,
        send_ack: false,
    };

    // --- RST: 状態を問わず即座に接続断 ---
    // これを見落とすと、正当な接続拒否を受けても SYN 再送タイムアウトが
    // 尽きるまで無駄に待ち続けることになる。
    if seg.flags & FLAG_RST != 0 {
        st.state = TcpState::Closed;
        return out;
    }

    match st.state {
        TcpState::SynSent => {
            // SYN+ACK のみを受理する。SYN 単独(同時オープン)は本スタックでは非対応。
            if seg.flags & (FLAG_SYN | FLAG_ACK) == (FLAG_SYN | FLAG_ACK) {
                st.state = TcpState::Established;
                st.rcv_nxt = seg.seq.wrapping_add(1);
                st.snd_nxt = seg.ack;
                out.send_ack = true;
            }
        }

        TcpState::Established
        | TcpState::FinWait1
        | TcpState::FinWait2
        | TcpState::CloseWait
        | TcpState::LastAck => {
            // --- ACK 処理 ---
            // 【重要】以前は `snd_nxt = ack` と無条件に代入していたため、
            // 遅延・重複した古い ACK が届くと snd_nxt が**巻き戻り**、
            // 次の送信が既に送った番号を再利用して TCP ストリームを破壊して
            // いた。snd_nxt は決して後退させない（前進のみ）。
            if seg.flags & FLAG_ACK != 0 && seq_gt(seg.ack, st.snd_nxt) {
                st.snd_nxt = seg.ack;
            }

            // --- ペイロード処理 ---
            // 順序どおり(seq == rcv_nxt)のときのみ受理する。本スタックは
            // 順序逆転セグメントの再組み立てバッファを持たないため、
            // ギャップがある場合は破棄するしかない。
            let in_order_data = seg.payload_len > 0 && seg.seq == st.rcv_nxt;
            if in_order_data {
                st.rcv_nxt = st.rcv_nxt.wrapping_add(seg.payload_len);
                out.accept_payload = true;
                out.send_ack = true;
            } else if seg.payload_len > 0 {
                // 【改善】順序逆転・重複データを黙って捨てるのではなく、
                // 現在の rcv_nxt を載せた ACK（重複 ACK）を返す。相手はこれを
                // 見て欠落セグメントを再送できる。以前は無反応だったため、
                // 相手側の RTO が切れるまで回復の手がかりが無かった。
                out.send_ack = true;
            }

            // --- FIN 処理 ---
            // 【重要な修正】FIN はシーケンス空間上、ペイロードの直後の 1 番地を
            // 占める。したがって FIN が「順序どおり」なのは
            //     seg.seq + payload_len == rcv_nxt（ペイロード処理後）
            // のときだけである。
            //
            // 以前の実装は `seq == rcv_nxt || payload_len > 0` という条件で
            // FIN を受理していたため、
            //   * ギャップがあってペイロードを破棄したセグメント（payload_len>0）
            //   * 順序逆転した純粋 FIN
            // でも `fin_received = true` にしてしまっていた。上位層はこれを
            // EOF と解釈するので、**まだ届いていないデータがあるのに受信完了と
            // 誤認**し、レスポンスが途中で切れる（TLS 復号エラー・CSS の途中
            // 切断などの直接原因）。順序どおりの FIN のみを受理する。
            if seg.flags & FLAG_FIN != 0 {
                let fin_seq = seg.seq.wrapping_add(seg.payload_len);
                if fin_seq == st.rcv_nxt {
                    st.rcv_nxt = st.rcv_nxt.wrapping_add(1);
                    st.fin_received = true;
                    out.send_ack = true;

                    match st.state {
                        TcpState::Established => st.state = TcpState::CloseWait,
                        TcpState::FinWait1 => {
                            // 自分の FIN も同時に ACK されていれば TimeWait へ。
                            if seg.flags & FLAG_ACK != 0 && seg.ack == st.snd_nxt {
                                st.state = TcpState::TimeWait;
                            }
                        }
                        TcpState::FinWait2 => st.state = TcpState::TimeWait,
                        _ => {}
                    }
                } else {
                    // 順序外の FIN。受理せず、重複 ACK だけ返して相手に
                    // 欠落分の再送を促す。fin_received は立てない。
                    out.send_ack = true;
                }
            }

            // --- 自分が送った FIN に対する ACK ---
            if st.state == TcpState::FinWait1
                && seg.flags & FLAG_ACK != 0
                && seg.ack == st.snd_nxt
                && seg.flags & FLAG_FIN == 0
            {
                st.state = TcpState::FinWait2;
            }
        }

        TcpState::Closed | TcpState::TimeWait => {
            // 何もしない（クローズ済みソケットへの遅延パケット等）。
        }
    }

    out
}