atmos/kernel/net/

dns.rs

fn parse_host_port(host: &str) -> (&str, u16) {
    if let Some((h, p_str)) = host.split_once(':') {
        if let Ok(p) = p_str.parse::<u16>() {
            return (h, p);
        }
    }
    (host, 80)
}

fn parse_ipv4_addr(s: &str) -> Option<[u8; 4]> {
    let mut ip = [0u8; 4];
    let mut count = 0;
    let mut current = 0u32;
    let mut has_digits = false;
    for c in s.chars() {
        if c.is_ascii_digit() {
            let d = (c as u32) - ('0' as u32);
            current = current * 10 + d;
            if current > 255 {
                return None;
            }
            has_digits = true;
        } else if c == '.' {
            if count >= 3 || !has_digits {
                return None;
            }
            ip[count] = current as u8;
            count += 1;
            current = 0;
            has_digits = false;
        } else {
            return None;
        }
    }
    if count == 3 && has_digits {
        ip[3] = current as u8;
        Some(ip)
    } else {
        None
    }
}

pub fn dns_query_a_via_udp(host: &str) -> Result<[u8; 4], &'static str> {
    let _p = crate::os_lib::web_engine::perf::start();
    let r = dns_query_a_via_udp_measured(host);
    crate::os_lib::web_engine::perf::add(
        crate::os_lib::web_engine::perf::Slot::DnsQuery,
        _p,
    );
    r
}

fn dns_query_a_via_udp_measured(host: &str) -> Result<[u8; 4], &'static str> {
    let (host_only, _) = parse_host_port(host);
    if let Some(ip) = parse_ipv4_addr(host_only) {
        return Ok(ip);
    }

    // 対策2: DNS キャッシュ。期限内ならネットワークを一切叩かずに即返す。
    if let Some(ip) = super::dns_cache_lookup(host_only) {
        return Ok(ip);
    }

    let dhcp_dns = super::status().dns;
    let dhcp_dns2 = super::status().dns2;

    // 問い合わせ先DNSサーバーのリストを作成（重複は排除）
    let mut dns_servers = alloc::vec::Vec::new();
    if dhcp_dns != [0, 0, 0, 0] {
        dns_servers.push(dhcp_dns);
    }
    if dhcp_dns2 != [0, 0, 0, 0] && dhcp_dns2 != dhcp_dns {
        dns_servers.push(dhcp_dns2);
    }
    const FALLBACK_DNS: [[u8; 4]; 2] = [[8, 8, 8, 8], [1, 1, 1, 1]];
    for &fallback_ip in &FALLBACK_DNS {
        if !dns_servers.contains(&fallback_ip) {
            dns_servers.push(fallback_ip);
        }
    }

    let mut last_err = "dns response timeout";

    // 【2026-07-29】txid と送信元ポートは **3 回の試行で共有**する。
    //
    // 以前は試行ごとに新しい txid/ポートを採番していたため、1 回目への応答が
    // 遅れて 2 回目の待機中に届いても **txid 不一致で捨てられ**、まったく
    // 活かせなかった（`parse_dns_a_response` は txid 不一致で `Ok(None)`）。
    // 再送は「新しいクエリ」ではなく「同じクエリの再送」なので、
    // 同じ txid・同じポートで送るのが標準的な挙動。こうすれば
    // どの試行への応答でも受け取れる。
    // 実測で DNS 失敗が全体の 33〜50% を占めており最大の失敗要因
    // （`spec/tcp_receive.md` の STATS 参照）。
    let txid = super::next_dns_txid();
    let src_port = super::next_dns_src_port();

    for attempt in 0..3 {

        let mut query = [0u8; 256];
        let q_len = build_dns_query(host_only, txid, &mut query)?;

        // リスト内のすべてのDNSサーバーへ並行送信。1件も送れなければ（ARP解決失敗等）
        // 応答を待っても無駄なので、原因を可視化した上でこの試行の待機をスキップする
        // （以前は debug! で握り潰され、送信全滅時も毎回フル timeout 分待っていた —
        // これが「DNSが常にタイムアウトする」の主因の一つ）。
        // 【2026-07-29】全サーバへの同報をやめ、**試行ごとに 1 サーバ**へ送る。
        //
        // QEMU は `-netdev user`（SLIRP ユーザーモードネットワーク）で動いており、
        // SLIRP は同時 UDP セッション数に上限があり各セッションはアイドルで回収される。
        // 1 クエリを 3〜4 サーバへ同報するとセッションを 3〜4 倍消費し、
        // 後続クエリの応答を受け取る経路が確保できなくなる疑いがある。
        //
        // 実測の裏付け: 送信は常に `sent_ok=3/3` で成功しているのに応答が返らず、
        // 早いクエリ（src_port 53000/53002）は成功し後のクエリ（53005/53006）が
        // 全滅するというパターンだった（`spec/tcp_receive.md`）。
        //
        // 冗長性は「試行ごとにサーバを切り替える」ことで担保する。
        // 3 回の試行で最大 3 サーバを順に試すので、1 台が不調でも救える。
        let target = dns_servers[(attempt as usize) % dns_servers.len()];
        let mut any_sent = false;
        let mut sent_ok = 0u32;
        for &dns_ip in core::slice::from_ref(&target) {
            match super::udp::send_udp_ipv4(dns_ip, src_port, 53, &query[..q_len]) {
                Ok(_) => { any_sent = true; sent_ok += 1; }
                Err(e) => {
                    crate::warn!("[NET] DNS: send to {} failed: {}", super::format_ipv4(dns_ip), e);
                    last_err = e;
                }
            }
        }

        if !any_sent {
            crate::warn!(
                "DNS: Attempt {} for host '{}' — send failed to all {} server(s), skipping wait ({}).",
                attempt + 1,
                host_only,
                dns_servers.len(),
                last_err
            );
            crate::kernel::scheduler::sleep(10); // ~100ms backoff before next attempt
            continue;
        }

        // 【2026-07-29診断】「送れていないのか、送れているが届かないのか」を
        // 切り分ける。DNS 失敗が最大の失敗要因（実測 33〜63%）。
        crate::warn!(
            "[NET][DNSSEND] host={} attempt={} src_port={} txid={:#06x} sent_ok={}/{}",
            host_only, attempt + 1, src_port, txid, sent_ok, dns_servers.len()
        );

        let start_time = crate::kernel::timer::get_system_time_ms();
        let timeout_ms = 1500u64 + (attempt as u64) * 1000;

        loop {
            crate::kernel::usb::poll_ethernet_data_plane_only();

            // 応答元 IP の一致は要求しない: sport==53 + txid一致だけで照合する。
            // 一部のホームルータ/ISPは DNS を透過的に横取りし、問い合わせ先とは
            // 異なる IP（ルータ自身など）から応答を返す「透過 DNS プロキシ」を行う。
            // 以前は `dns_servers.contains(&sip)` を必須にしていたため、そうした
            // 環境では正当な応答が届いていても照合に失敗し、実質「常にタイムアウトする」
            // 挙動になっていた。txid は送信元ポート(53000+ローテーション)と合わせて
            // 十分な相関を持つため、送信元 IP の厳密一致は外しても安全側に倒れる。
            let matched = super::udp::udp_recv_matching(src_port, |_sip, sport, pl| {
                sport == 53
                    && pl.len() >= 2
                    && (((pl[0] as u16) << 8) | pl[1] as u16) == txid
            });

            if let Some(rx) = matched {
                // 【2026-07-29】この src_port のクエリは応答を得たので完了。
                // 同じポートから**全 DNS サーバへ同報**しているため、残りのサーバの
                // 応答が後からキューに残り続ける。放置すると 6 件のキューが
                // 消費済みの応答で埋まり、以降の DNS が受信できなくなる
                // （実測: `udp_queue_len=6` で全て古い応答）。ここで破棄する。
                let purged = super::udp::purge_port(src_port);
                if purged > 0 {
                    crate::debug!(
                        "[NET] DNS: purged {} duplicate responses for src_port={}",
                        purged,
                        src_port
                    );
                }
                if !dns_servers.contains(&rx.src_ip) {
                    crate::debug!(
                        "DNS: response for '{}' from unexpected IP {} (transparent proxy?), accepting anyway",
                        host_only,
                        super::format_ipv4(rx.src_ip)
                    );
                }
                match parse_dns_a_response(&rx.payload, txid, host_only) {
                    Ok(Some(parsed)) => {
                        super::dns_cache_insert(host_only, parsed);
                        return Ok(parsed);
                    }
                    Ok(None) => {}
                    Err(e) => {
                        crate::warn!("[NET] DNS parse err from {}: {}", super::format_ipv4(rx.src_ip), e);
                        last_err = e;
                    }
                }
            }

            let elapsed = crate::kernel::timer::get_system_time_ms().wrapping_sub(start_time);
            if elapsed >= timeout_ms {
                break;
            }

            crate::kernel::scheduler::sleep(1);
        }

        // 【2026-07-25診断】同一ブート内でHTTPS/DNS接続を重ねるほど失敗し
        // やすくなる現象（`ordinal=`ログで定量確認済み、詳細はTODO.md）
        // の原因切り分けのため、DNSタイムアウト時点でのUDP受信キュー全体
        // の中身をダンプする。もし無関係な古いエントリでキューが埋まって
        // いれば、本来届いているはずのDNS応答が処理前に退避されている
        // 可能性が高い、という仮説を検証する。
        let queue_dump = super::udp::udp_queue_lines(None);
        crate::warn!(
            "[NET][DIAG] DNS timeout: src_port={} txid={:#06x} udp_queue_len={} entries={:?}",
            src_port, txid, queue_dump.len(), queue_dump
        );

        crate::info!(
            "DNS: Attempt {} for host '{}' timed out. Retrying...",
            attempt + 1,
            host_only
        );
    }

    Err(last_err)
}


pub fn ntp_query(host: &str) -> Result<u64, &'static str> {
    let server_ip = dns_query_a_via_udp(host)?;

    let mut req = [0u8; 48];
    // LI=0, VN=4, Mode=3(client)。
    req[0] = 0x23;

    let mut last_err = "ntp response timeout";

    for attempt in 0..3 {
        // 送信元ポートをクエリ毎に変える（DNS と同じ思想）。固定ポートだと
        // 他スレッド/古い応答と UDP キューを共有し、正規応答を読み捨ててしまう。
        let src_port: u16 = 51230u16.wrapping_add((attempt as u16) * 7);

        // RFC 4330: 偽造・リプレイ攻撃防止のため、Transmit Timestamp (パケットの末尾8バイト) に
        // リクエスト毎に異なる一意な値（Nonce）を設定し、応答の Originate Timestamp と照合する。
        let nonce = crate::kernel::timer::get_system_time_ms();
        req[40] = (nonce >> 24) as u8;
        req[41] = (nonce >> 16) as u8;
        req[42] = (nonce >> 8) as u8;
        req[43] = nonce as u8;
        req[44] = attempt as u8;
        req[45] = 0;
        req[46] = 0;
        req[47] = 0;

        // 送信失敗（初回ARP未解決・TXキュー満杯など）を即 ? で中断せず、リトライへ回す。
        if super::udp::send_udp_ipv4(server_ip, src_port, 123, &req).is_err() {
            last_err = "ntp send failed";
            crate::kernel::scheduler::sleep(5); // ~50ms バックオフ後に再送
            continue;
        }

        let start_time = crate::kernel::timer::get_system_time_ms();
        let timeout_ms = 4000u64;

        loop {
            crate::kernel::usb::poll_ethernet_data_plane_only();

            // 送信元(server_ip:123)かつ 48B 以上の応答のみを取り出す（取り違え防止）。
            let matched = super::udp::udp_recv_matching(src_port, |sip, sport, pl| {
                sip == server_ip && sport == 123 && pl.len() >= 48
            });
            if let Some(rx) = matched {
                // レスポンス検証: Mode=4(server) 必須、stratum=0(Kiss-o'-Death) / stratum>15 を拒否。
                // (li == 3 unsync 警告は実質問題ない場合が多いため許容する)
                let mode = rx.payload[0] & 0x7;
                let stratum = rx.payload[1];
                if mode != 4 || stratum == 0 || stratum > 15 {
                    last_err = "ntp invalid response";
                    // この応答は捨て、同じ試行のタイムアウトまで本物を待ち続ける。
                } else if rx.payload[24..32] != req[40..48] {
                    // RFC 4330 準拠: Originate Timestamp (24..32) が、送信した Transmit Timestamp と一致するか検証
                    last_err = "ntp originate timestamp mismatch (replay attack?)";
                } else {
                    let secs_1900 = ((rx.payload[40] as u64) << 24)
                        | ((rx.payload[41] as u64) << 16)
                        | ((rx.payload[42] as u64) << 8)
                        | (rx.payload[43] as u64);
                    if secs_1900 > crate::kernel::timer::NTP_UNIX_OFFSET {
                        return Ok(secs_1900 - crate::kernel::timer::NTP_UNIX_OFFSET);
                    }
                    last_err = "ntp invalid timestamp";
                }
            }

            let elapsed = crate::kernel::timer::get_system_time_ms().wrapping_sub(start_time);
            if elapsed >= timeout_ms {
                break;
            }
            // フリーズ対策: スリープで完全に待つのではなく yield_now() で
            // パケット回収を高頻度で継続しつつ、他タスクへ CPU を譲る。
            crate::kernel::scheduler::yield_now();
        }

        crate::info!(
            "NTP: Attempt {} for '{}' timed out. Retrying...",
            attempt + 1,
            host
        );
        // リトライ間バックオフ（連射によるレート制限/KoD 誘発を回避）。
        crate::kernel::scheduler::sleep(10); // ~100ms
    }

    Err(last_err)
}

pub fn ntp_sync() -> Result<u64, &'static str> {
    // 1台が詰まっていても他で回復できるようフォールバック列を用意。
    const HOSTS: [&str; 3] = ["ntp.nict.jp", "time.cloudflare.com", "pool.ntp.org"];
    let mut last = "ntp response timeout";
    for h in HOSTS.iter() {
        match ntp_query(h) {
            Ok(unix) => {
                crate::kernel::timer::set_wall_clock(unix);
                crate::info!("[NET] NTP: synced via {}. unix={}", h, unix);
                return Ok(unix);
            }
            Err(e) => {
                crate::warn!("[SYS] NTP: Failed to query {}: {}", h, e);
                last = e;
            }
        }
    }
    Err(last)
}

pub fn build_dns_query(domain: &str, txid: u16, out: &mut [u8]) -> Result<usize, &'static str> {
    if out.len() < 64 {
        return Err("buffer too small");
    }

    out[0] = (txid >> 8) as u8;
    out[1] = txid as u8;
    out[2] = 0x01;
    out[3] = 0x00;
    out[4] = 0x00;
    out[5] = 0x01;
    out[6] = 0x00;
    out[7] = 0x00;
    out[8] = 0x00;
    out[9] = 0x00;
    out[10] = 0x00;
    out[11] = 0x00;

    let mut idx = 12usize;
    for label in domain.split('.') {
        let l = label.len();
        if l == 0 || l > 63 || idx + 1 + l >= out.len() {
            return Err("invalid domain");
        }
        out[idx] = l as u8;
        idx += 1;
        out[idx..idx + l].copy_from_slice(label.as_bytes());
        idx += l;
    }

    if idx + 5 >= out.len() {
        return Err("buffer too small");
    }

    out[idx] = 0x00;
    idx += 1;

    out[idx] = 0x00;
    out[idx + 1] = 0x01;
    out[idx + 2] = 0x00;
    out[idx + 3] = 0x01;

    Ok(idx + 4)
}

pub fn parse_dns_a_response(
    packet: &[u8],
    expected_txid: u16,
    expected_domain: &str,
) -> Result<Option<[u8; 4]>, &'static str> {
    if packet.len() < 12 {
        return Err("dns packet too short");
    }

    let rx_txid = ((packet[0] as u16) << 8) | packet[1] as u16;
    if rx_txid != expected_txid {
        return Ok(None);
    }

    let is_response = (packet[2] & 0x80) != 0;
    if !is_response {
        return Ok(None);
    }

    let rcode = packet[3] & 0x0F;
    if rcode != 0 {
        return Ok(None);
    }

    let qdcount = ((packet[4] as u16) << 8) | packet[5] as u16;
    let ancount = ((packet[6] as u16) << 8) | packet[7] as u16;
    let nscount = ((packet[8] as u16) << 8) | packet[9] as u16;
    let arcount = ((packet[10] as u16) << 8) | packet[11] as u16;

    let total_rrs = ancount + nscount + arcount;

    let mut idx = 12usize;

    for _ in 0..qdcount {
        idx = skip_dns_name(packet, idx)?;
        if idx + 4 > packet.len() {
            return Err("dns question truncated");
        }
        idx += 4;
    }

    for _ in 0..total_rrs {
        let (_matches, next_idx) = compare_dns_name(packet, idx, expected_domain)?;
        idx = next_idx;
        if idx + 10 > packet.len() {
            return Err("dns answer truncated");
        }

        let rr_type = ((packet[idx] as u16) << 8) | packet[idx + 1] as u16;
        let _rr_class = ((packet[idx + 2] as u16) << 8) | packet[idx + 3] as u16;
        let _ttl = ((packet[idx + 4] as u32) << 24)
            | ((packet[idx + 5] as u32) << 16)
            | ((packet[idx + 6] as u32) << 8)
            | packet[idx + 7] as u32;
        let rdlen = ((packet[idx + 8] as u16) << 8) | packet[idx + 9] as u16;
        idx += 10;

        if idx + rdlen as usize > packet.len() {
            return Err("dns rdata truncated");
        }

        if rr_type == 1 && rdlen == 4 {
            let ip = [
                packet[idx],
                packet[idx + 1],
                packet[idx + 2],
                packet[idx + 3],
            ];
            unsafe {
                super::NET_STATE.rx_packets = super::NET_STATE.rx_packets.saturating_add(1);
            }
            return Ok(Some(ip));
        }

        idx += rdlen as usize;
    }

    Ok(None)
}



fn skip_dns_name(packet: &[u8], mut idx: usize) -> Result<usize, &'static str> {
    if idx >= packet.len() {
        return Err("dns name out of bounds");
    }

    loop {
        if idx >= packet.len() {
            return Err("dns name truncated");
        }

        let len = packet[idx];

        if len & 0xC0 == 0xC0 {
            if idx + 1 >= packet.len() {
                return Err("dns ptr truncated");
            }
            return Ok(idx + 2);
        }

        idx += 1;
        if len == 0 {
            return Ok(idx);
        }

        idx += len as usize;
    }
}

fn compare_dns_name(packet: &[u8], start_idx: usize, expected: &str) -> Result<(bool, usize), &'static str> {
    // まず正確に名前全体をスキップして、次のパース位置を取得する
    let next_idx = skip_dns_name(packet, start_idx)?;
    
    let expected_bytes = expected.as_bytes();
    let mut expected_idx = 0;
    
    let mut cur_idx = start_idx;
    let mut jumps = 0;
    
    loop {
        if jumps > 10 { return Err("dns pointer loop"); }
        if cur_idx >= packet.len() { return Err("dns name out of bounds"); }
        
        let len = packet[cur_idx];
        if len & 0xC0 == 0xC0 {
            if cur_idx + 1 >= packet.len() { return Err("dns ptr truncated"); }
            let offset = (((len & 0x3F) as usize) << 8) | (packet[cur_idx + 1] as usize);
            cur_idx = offset;
            jumps += 1;
            continue;
        }
        
        cur_idx += 1;
        if len == 0 {
            let matches = expected_idx == expected_bytes.len();
            return Ok((matches, next_idx));
        }
        
        let label_len = len as usize;
        if cur_idx + label_len > packet.len() { return Err("dns name truncated"); }
        
        if expected_idx > 0 {
            if expected_idx >= expected_bytes.len() || expected_bytes[expected_idx] != b'.' {
                return Ok((false, next_idx));
            }
            expected_idx += 1;
        }
        
        let label = &packet[cur_idx..cur_idx + label_len];
        if expected_idx + label_len > expected_bytes.len() {
            return Ok((false, next_idx));
        }
        
        if !label.eq_ignore_ascii_case(&expected_bytes[expected_idx..expected_idx + label_len]) {
            return Ok((false, next_idx));
        }
        
        expected_idx += label_len;
        cur_idx += label_len;
    }
}