atmos/kernel/net/

udp.rs

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



pub fn udp_queue_lines(port_filter: Option<u16>) -> Vec<String> {
    let mut lines = Vec::new();
    let _lock = super::NET_LOCK.lock();
    unsafe {
        for i in 0..super::UDP_RX_QUEUE_SIZE {
            let e = super::UDP_RX_QUEUE[i];
            if !e.valid {
                continue;
            }
            if let Some(port) = port_filter {
                if e.dst_port != port {
                    continue;
                }
            }

            let preview_len = e.payload_len.min(24);
            let preview = payload_preview(&e.payload[..preview_len]);
            lines.push(alloc::format!(
                "{}:{} -> :{} len={} data='{}'",
                super::format_ipv4(e.src_ip),
                e.src_port,
                e.dst_port,
                e.payload_len,
                preview
            ));
        }
    }

    lines
}

pub fn udp_recv_next_line(port: u16) -> Option<String> {
    let dgram = udp_recv_next_datagram(port)?;
    let text = payload_preview(&dgram.payload);
    Some(alloc::format!(
        "UDP RX {}:{} -> :{} len={} data='{}'",
        super::format_ipv4(dgram.src_ip),
        dgram.src_port,
        dgram.dst_port,
        dgram.payload.len(),
        text
    ))
}

pub fn udp_recv_next_datagram(port: u16) -> Option<super::UdpDatagram> {
    udp_recv_matching(port, |_sip, _sport, _pl| true)
}

/// dst_port が一致し、かつ述語 `pred(src_ip, src_port, payload)` を満たす最古の
/// データグラムだけを取り出してキューから削除する。述語を満たさないエントリは
/// キューに残すため、並行クエリ（DNS browser_loader / img_load、NTP）が互いの
/// 応答を「取り出して照合失敗で破棄」してしまう競合を構造的に解消する。
pub fn udp_recv_matching<F>(port: u16, pred: F) -> Option<super::UdpDatagram>
where
    F: Fn([u8; 4], u16, &[u8]) -> bool,
{
    let _lock = super::NET_LOCK.lock();
    unsafe {
        // 照合（宛先ポート一致 + 述語 + 最古優先）は純粋モジュールへ委譲する。
        let queue = &*core::ptr::addr_of!(super::UDP_RX_QUEUE);
        let i = super::udp_queue::find_matching(queue, port, |e| {
            pred(e.src_ip, e.src_port, e.payload())
        })?;
        let e = super::UDP_RX_QUEUE[i];
        // 【2026-07-29】消費した応答と、同じ宛先ポート宛の重複応答をまとめて破棄する。
        //
        // `net/dns.rs:74-88` を読んで確認した仕様:
        //   let src_port = next_dns_src_port();   // 1 クエリにつき 1 ポート
        //   for &dns_ip in &dns_servers { send_udp_ipv4(dns_ip, src_port, 53, ...) }
        // 同一ポートから**複数の DNS サーバへ同じクエリ**を送るため、
        // 応答も同じポート宛に複数届く。1 件だけ消費すると残りが永久に滞留し、
        // クエリを重ねるほど 6 件のキューが消費済みの古い応答で埋まって
        // 新しい DNS 応答が入らなくなる（実測: `udp_queue_len=6` で全て古い応答）。
        //
        // ただし**ここ（汎用の recv）で一括破棄してはいけない**。
        // `udp_recv_matching` は「述語で送信元を絞り、一致しないエントリは残す」
        // 契約であり（`test_udp_recv_matching_predicate_filters_by_source` が固定）、
        // ポート単位で消すとその契約を壊す。破棄は「そのクエリが完了した」と
        // 判断できる呼び出し側（DNS 層）で行う。→ `purge_port()` 参照。
        super::UDP_RX_QUEUE[i] = super::UdpRxEntry::empty();

        let mut payload = Vec::with_capacity(e.payload_len);
        for idx in 0..e.payload_len {
            payload.push(e.payload[idx]);
        }

        Some(super::UdpDatagram {
            src_ip: e.src_ip,
            src_port: e.src_port,
            dst_port: e.dst_port,
            payload,
        })
    }
}

pub fn send_udp_ipv4(
    dst_ip: [u8; 4],
    src_port: u16,
    dst_port: u16,
    payload: &[u8],
) -> Result<usize, &'static str> {
    send_udp_ipv4_from(super::status().ip, dst_ip, src_port, dst_port, payload)
}

pub(crate) fn send_udp_ipv4_from(
    src_ip: [u8; 4],
    dst_ip: [u8; 4],
    src_port: u16,
    dst_port: u16,
    payload: &[u8],
) -> Result<usize, &'static str> {
    if payload.len() > 1400 {
        return Err("payload too large");
    }

    let total_len = 20usize + 8usize + payload.len();
    let mut pkt = [0u8; 1536];

    // IPv4 header
    pkt[0] = 0x45;
    pkt[1] = 0;
    pkt[2] = ((total_len >> 8) & 0xFF) as u8;
    pkt[3] = (total_len & 0xFF) as u8;
    pkt[4] = 0x12;
    pkt[5] = 0x34;
    pkt[6] = 0;
    pkt[7] = 0;
    pkt[8] = 64;
    pkt[9] = 17; // UDP

    pkt[12..16].copy_from_slice(&src_ip);
    pkt[16..20].copy_from_slice(&dst_ip);

    let csum = super::ipv4_header_checksum(&pkt[0..20]);
    pkt[10] = (csum >> 8) as u8;
    pkt[11] = csum as u8;

    // UDP header
    pkt[20] = (src_port >> 8) as u8;
    pkt[21] = src_port as u8;
    pkt[22] = (dst_port >> 8) as u8;
    pkt[23] = dst_port as u8;

    let udp_len = 8usize + payload.len();
    pkt[24] = (udp_len >> 8) as u8;
    pkt[25] = udp_len as u8;
    pkt[26] = 0;
    pkt[27] = 0;

    let data_start = 28usize;
    let data_end = data_start + payload.len();
    pkt[data_start..data_end].copy_from_slice(payload);

    // UDP チェックサム（IPv4 疑似ヘッダ + UDP ヘッダ + データ）。
    // checksum=0 は IPv4 UDP では仕様上「未計算」を意味する正当な値だが、一部の
    // ホームルータのファイアウォールや厳格なネットワーク経路はこれを不審として
    // 静かに破棄することがある。DNS 応答が実ネットワークでは届かず QEMU の
    // 簡易 NAT (SLIRP) では届いていた症状の一因と考えられるため、実際に計算する。
    let mut pseudo = [0u8; 12 + 1408];
    pseudo[0..4].copy_from_slice(&src_ip);
    pseudo[4..8].copy_from_slice(&dst_ip);
    pseudo[8] = 0;
    pseudo[9] = 17; // UDP
    pseudo[10] = (udp_len >> 8) as u8;
    pseudo[11] = udp_len as u8;
    pseudo[12..12 + udp_len].copy_from_slice(&pkt[20..20 + udp_len]);
    let udp_csum = super::internet_checksum(&pseudo[..12 + udp_len]);
    // 計算結果が 0 になった場合は「未計算」と区別するため 0xFFFF で送信する（RFC768）。
    let udp_csum = if udp_csum == 0 { 0xFFFF } else { udp_csum };
    pkt[26] = (udp_csum >> 8) as u8;
    pkt[27] = udp_csum as u8;

    let sent = super::arp::transmit_nic_ipv4_packet(&pkt[..total_len])?;
    Ok(sent)
}

pub(crate) fn parse_udp_ipv4_packet(packet: &[u8]) -> Result<(), &'static str> {
    let ihl = ((packet[0] & 0x0F) as usize) * 4;
    if ihl < 20 || packet.len() < ihl + 8 {
        return Err("udp packet too short");
    }

    let total_len = (((packet[2] as u16) << 8) | packet[3] as u16) as usize;
    if total_len < ihl + 8 || total_len > packet.len() {
        return Err("invalid ipv4 total length");
    }

    let udp = &packet[ihl..total_len];
    let src_port = ((udp[0] as u16) << 8) | udp[1] as u16;
    let dst_port = ((udp[2] as u16) << 8) | udp[3] as u16;

    let dst_ip = [packet[16], packet[17], packet[18], packet[19]];
    let my_ip = super::status().ip;
    let is_dhcp_broadcast = dst_ip == [255, 255, 255, 255] && dst_port == 68;
    let is_dhcp_client_rx = dst_port == 68;
    if dst_ip != my_ip && !is_dhcp_broadcast && !(my_ip == [0, 0, 0, 0] && is_dhcp_client_rx) {
        if is_dhcp_client_rx {
            crate::info!(
                "UDP Parse: Dropped DHCP packet to {:?} (my_ip={:?})",
                dst_ip,
                my_ip
            );
        } else {
            // 診断用: DNS/NTP 等の応答がここで宛先IP不一致により捨てられていないかを
            // 可視化する。「送信元IPの厳密一致は要求していない」（dns.rs 側）のに対し、
            // ここでは「宛先IP=自分のIP」を要求している非対称性が疑わしいため。
            let src_ip = [packet[12], packet[13], packet[14], packet[15]];
            crate::debug!(
                "[SYS] UDP Parse: dropped {}:{} -> {}:{} (dst != my_ip={})",
                super::format_ipv4(src_ip),
                src_port,
                super::format_ipv4(dst_ip),
                dst_port,
                super::format_ipv4(my_ip)
            );
        }
        return Err("udp packet not for local ip");
    }

    let udp_len = (((udp[4] as u16) << 8) | udp[5] as u16) as usize;
    if udp_len < 8 || udp_len > udp.len() {
        if is_dhcp_client_rx {
            crate::info!(
                "UDP Parse: Invalid UDP length {} (buffer {})",
                udp_len,
                udp.len()
            );
        }
        return Err("invalid udp length");
    }

    let payload = &udp[8..udp_len];
    let src_ip = [packet[12], packet[13], packet[14], packet[15]];

    if is_dhcp_client_rx {
        crate::info!(
            "UDP Parse: Accepted DHCP packet from {:?}:{} len={}",
            src_ip,
            src_port,
            payload.len()
        );
    }

    udp_queue_push(src_ip, src_port, dst_port, payload);

    unsafe {
        super::NET_STATE.rx_packets = super::NET_STATE.rx_packets.saturating_add(1);
    }

    Ok(())
}

/// 表の操作判断そのものは純粋モジュール `udp_queue` へ委譲する
/// （満杯時の LRU 退避・ペイロード切り詰めはホスト側ユニットテストで検証済み。
/// `tests/src/test_udp_queue.rs`）。ここは age の採番・ロック・グローバル配列
/// へのアクセスという副作用のみを担当する。
fn udp_queue_push(src_ip: [u8; 4], src_port: u16, dst_port: u16, payload: &[u8]) {
    let _lock = super::NET_LOCK.lock();
    unsafe {
        let age = super::UDP_RX_TICK;
        super::UDP_RX_TICK = super::UDP_RX_TICK.saturating_add(1);

        let queue = &mut *core::ptr::addr_of_mut!(super::UDP_RX_QUEUE);
        let _ = super::udp_queue::push(queue, src_ip, src_port, dst_port, payload, age);
    }
}

fn payload_preview(payload: &[u8]) -> String {
    let mut out = String::new();
    for &b in payload {
        let c = b as char;
        if c.is_ascii_graphic() || c == ' ' {
            out.push(c);
        } else {
            out.push('.');
        }
    }
    out
}

/// 指定した宛先ポート宛の受信エントリを全て破棄し、件数を返す。
///
/// 【2026-07-29】DNS は 1 つの `src_port` から複数サーバへ同じクエリを送るため
/// （`net/dns.rs:74-88`）、応答も同じポート宛に複数届く。1 件だけ消費すると
/// 残りが永久に滞留し、クエリを重ねるほどキューが消費済みの応答で埋まって
/// 新しい DNS 応答が入らなくなる（実測: `udp_queue_len=6` で全て古い応答）。
///
/// **クエリが完了したと判断できる呼び出し側だけが呼ぶこと。**
/// 汎用の `udp_recv_matching` 側で一括破棄すると、述語で送信元を絞る用途
/// （NTP 等）の契約を壊す。
pub fn purge_port(port: u16) -> usize {
    let _lock = super::NET_LOCK.lock();
    unsafe {
        let queue = &mut *core::ptr::addr_of_mut!(super::UDP_RX_QUEUE);
        super::udp_queue::purge_port(queue, port)
    }
}