サンプルコードで身につける: TCP で送って受け取る — 名前解決、接続、タイムアウト、閉じるまで読む

use std::io::{Read, Write};
use std::net::{TcpStream, ToSocketAddrs};
use std::time::Duration;

struct Url {
    host: String,
    port: u16,
    path: String,
}

/// http://host[:port]/path だけ読む最小版
fn parse(input: &str) -> Option<Url> {
    let (_, rest) = input.split_once("://")?;
    let (authority, path) = rest.split_once('/').unwrap_or((rest, ""));
    let (host, port) = match authority.rsplit_once(':') {
        Some((h, p)) => (h, p.parse().ok()?),
        None => (authority, 80),
    };
    Some(Url { host: host.to_string(), port, path: format!("/{path}") })
}

fn host_header(url: &Url) -> String {
    if url.port == 80 { url.host.clone() } else { format!("{}:{}", url.host, url.port) }
}

/// URL に GET を 1 回送り、生のレスポンス(バイト列)を返す
fn fetch(url: &Url) -> Result<Vec<u8>, String> {
    // 1. 名前解決: ("localhost", 8000) -> 127.0.0.1:8000 のような SocketAddr。OS のリゾルバに任せる
    let addr = (url.host.as_str(), url.port)
        .to_socket_addrs()
        .map_err(|e| format!("名前解決に失敗 {}: {e}", url.host))?
        .next()
        .ok_or_else(|| format!("名前解決の結果が空: {}", url.host))?;

    // 2. TCP 接続。相手が応答しないとき無限に待たないよう、上限を付ける
    let mut stream = TcpStream::connect_timeout(&addr, Duration::from_secs(5))
        .map_err(|e| format!("接続に失敗 {addr}: {e}"))?;
    stream.set_read_timeout(Some(Duration::from_secs(10))).map_err(|e| e.to_string())?;

    // 3. リクエストを送る。Connection: close で「この 1 往復で閉じる」と宣言
    let request = format!(
        "GET {} HTTP/1.1\r\nHost: {}\r\nConnection: close\r\n\r\n",
        url.path,
        host_header(url)
    );
    stream.write_all(request.as_bytes()).map_err(|e| format!("送信に失敗: {e}"))?;

    // 4. サーバーが接続を閉じる(EOF)まで読む。close を宣言したので、閉じたら終わり
    let mut raw = Vec::new();
    stream.read_to_end(&mut raw).map_err(|e| format!("受信に失敗: {e}"))?;
    Ok(raw)
}

fn main() {
    // 別のターミナルで python3 -m http.server 8000 を起動してから実行する
    let url = parse("http://localhost:8000/").expect("URL が読めない");
    match fetch(&url) {
        Ok(raw) => {
            let text = String::from_utf8_lossy(&raw);
            println!("{} バイト受信", raw.len());
            for line in text.lines().take_while(|l| !l.is_empty()) {
                println!("  {line}");
            }
        }
        Err(e) => println!("失敗: {e}"),
    }
}

use std::io::{self, Read, Write};
use std::net::{TcpListener, TcpStream, ToSocketAddrs};
use std::thread;
use std::time::Duration;

fn main() -> io::Result<()> {
    // 1. ポート 0 で待ち受けると、OS が空いているポートを割り当てる(テストで衝突しない)
    let listener = TcpListener::bind("127.0.0.1:0")?;
    let port = listener.local_addr()?.port();

    // 2. サーバー役は別スレッド。1 接続だけ受け、固定のレスポンスを返して閉じる
    let server = thread::spawn(move || -> io::Result<String> {
        let (mut conn, _) = listener.accept()?;
        let mut buf = [0u8; 1024];
        let n = conn.read(&mut buf)?; // 短いリクエストなので 1 回で足りる前提(本物は空行まで読む)
        let received = String::from_utf8_lossy(&buf[..n]).to_string();
        conn.write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 12\r\nConnection: close\r\n\r\n<p>hello</p>")?;
        Ok(received) // conn はここで drop され、接続が閉じる -> クライアントの read_to_end が終わる
    });

    // 3. クライアント役: 名前解決 -> connect_timeout -> 送信 -> read_to_end
    let addr = ("127.0.0.1", port).to_socket_addrs()?.next().unwrap();
    let mut stream = TcpStream::connect_timeout(&addr, Duration::from_secs(5))?;
    stream.set_read_timeout(Some(Duration::from_secs(10)))?;
    let request = format!("GET / HTTP/1.1\r\nHost: 127.0.0.1:{port}\r\nConnection: close\r\n\r\n");
    stream.write_all(request.as_bytes())?;
    let mut raw = Vec::new();
    stream.read_to_end(&mut raw)?;

    let received = server.join().expect("サーバースレッドが panic した")?;
    println!("--- サーバーが受け取ったリクエスト ---");
    println!("{}", received.escape_debug());
    println!("--- クライアントが受け取ったレスポンス({} バイト)---", raw.len());
    println!("{}", String::from_utf8_lossy(&raw).escape_debug());
    Ok(())
}