Rustのstd::netを使ったネットワークプログラミングの基礎と実践

use std::net::TcpListener;

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080")?;
    println!("Server running on port 8080");

    for stream in listener.incoming() {
        let stream = stream?;
        println!("Connection established with {}", stream.peer_addr()?);
    }

    Ok(())
}

use std::net::TcpListener;
use std::io::{Read, Write};

fn main() -> std::io::Result<()> {
    // サーバーを指定したアドレスとポートでバインド
    let listener = TcpListener::bind("127.0.0.1:8080")?;
    println!("Server running on 127.0.0.1:8080");

    for stream in listener.incoming() {
        let mut stream = stream?;
        println!("Connection established: {}", stream.peer_addr()?);

        // クライアントからのメッセージを受信
        let mut buffer = [0; 512];
        stream.read(&mut buffer)?;
        println!("Received: {}", String::from_utf8_lossy(&buffer));

        // クライアントに応答を送信
        stream.write(b"Message received")?;
    }

    Ok(())
}

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

fn main() -> std::io::Result<()> {
    // サーバーに接続
    let mut stream = TcpStream::connect("127.0.0.1:8080")?;
    println!("Connected to the server!");

    // メッセージをサーバーに送信
    stream.write(b"Hello from client!")?;

    // サーバーからの応答を受信
    let mut buffer = [0; 512];
    stream.read(&mut buffer)?;
    println!("Response: {}", String::from_utf8_lossy(&buffer));

    Ok(())
}

if let Err(e) = TcpListener::bind("127.0.0.1:8080") {
    eprintln!("Failed to bind: {}", e);
}

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    // UDPソケットをバインド
    let socket = UdpSocket::bind("127.0.0.1:8080")?;
    println!("UDP server running on 127.0.0.1:8080");

    let mut buffer = [0; 512];

    loop {
        // クライアントからのメッセージを受信
        let (amt, src) = socket.recv_from(&mut buffer)?;
        println!("Received {} bytes from {}", amt, src);

        // 応答メッセージを送信
        socket.send_to(b"Message received", src)?;
    }
}

use std::net::UdpSocket;

fn main() -> std::io::Result<()> {
    // UDPソケットを作成
    let socket = UdpSocket::bind("127.0.0.1:0")?; // 任意のポートにバインド
    socket.connect("127.0.0.1:8080")?;
    println!("Connected to the UDP server!");

    // サーバーにメッセージを送信
    socket.send(b"Hello from client!")?;

    // サーバーからの応答を受信
    let mut buffer = [0; 512];
    let amt = socket.recv(&mut buffer)?;
    println!("Received: {}", String::from_utf8_lossy(&buffer[..amt]));

    Ok(())
}

use std::net::{SocketAddr, IpAddr, Ipv4Addr};

fn main() {
    // 手動でSocketAddrを構築
    let addr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8080);
    println!("SocketAddr: {}", addr);

    // 文字列からSocketAddrを作成
    let addr: SocketAddr = "127.0.0.1:8080".parse().unwrap();
    println!("Parsed SocketAddr: {}", addr);
}

use std::net::{ToSocketAddrs};

fn main() {
    // ホスト名を名前解決してSocketAddrを取得
    let addresses = "example.com:80".to_socket_addrs().unwrap();
    for addr in addresses {
        println!("Resolved address: {}", addr);
    }
}

use std::net::{TcpListener, ToSocketAddrs};

fn main() -> std::io::Result<()> {
    let address = "localhost:8080".to_socket_addrs()?.next().unwrap();
    let listener = TcpListener::bind(address)?;
    println!("Server listening on {}", address);

    for stream in listener.incoming() {
        println!("Connection established!");
    }

    Ok(())
}

async fn fetch_data() -> String {
    "Hello, async world!".to_string()
}

#[tokio::main]
async fn main() {
    let result = fetch_data().await;
    println!("{}", result);
}

use tokio::net::TcpListener;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("Server running on 127.0.0.1:8080");

    loop {
        let (mut socket, addr) = listener.accept().await?;
        println!("Connection established with {}", addr);

        tokio::spawn(async move {
            let mut buffer = [0; 1024];
            match socket.read(&mut buffer).await {
                Ok(0) => return, // 接続終了
                Ok(_) => {
                    socket.write_all(b"Message received").await.unwrap();
                }
                Err(e) => eprintln!("Failed to read from socket: {}", e),
            }
        });
    }
}

use tokio::net::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("Connected to the server!");

    stream.write_all(b"Hello from async client!").await?;
    let mut buffer = [0; 1024];
    let n = stream.read(&mut buffer).await?;
    println!("Response: {}", String::from_utf8_lossy(&buffer[..n]));

    Ok(())
}

use tokio_rustls::TlsAcceptor;
use tokio::net::TcpListener;
use std::sync::Arc;
use rustls::ServerConfig;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let certs = rustls::internal::pemfile::certs(&mut std::io::BufReader::new(
        std::fs::File::open("server.crt")?,
    ))?;
    let key = rustls::internal::pemfile::rsa_private_keys(&mut std::io::BufReader::new(
        std::fs::File::open("server.key")?,
    ))?.remove(0);

    let config = ServerConfig::builder()
        .with_safe_defaults()
        .with_no_client_auth()
        .with_single_cert(certs, key)?;

    let acceptor = TlsAcceptor::from(Arc::new(config));
    let listener = TcpListener::bind("127.0.0.1:8080").await?;

    loop {
        let (socket, _) = listener.accept().await?;
        let acceptor = acceptor.clone();
        tokio::spawn(async move {
            let mut stream = acceptor.accept(socket).await.unwrap();
            let mut buffer = [0; 1024];
            stream.read(&mut buffer).await.unwrap();
            stream.write_all(b"Hello, secure world!").await.unwrap();
        });
    }
}

use tokio_rustls::TlsConnector;
use tokio::net::TcpStream;
use rustls::ClientConfig;
use std::sync::Arc;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let config = ClientConfig::builder()
        .with_safe_defaults()
        .with_root_certificates(rustls::RootCertStore::empty())
        .with_no_client_auth();

    let connector = TlsConnector::from(Arc::new(config));
    let stream = TcpStream::connect("127.0.0.1:8080").await?;
    let mut stream = connector.connect("localhost".try_into()?, stream).await?;

    stream.write_all(b"Hello from secure client!").await?;
    Ok(())
}

use tokio::net::TcpListener;
use tokio::sync::broadcast;
use tokio::io::{AsyncReadExt, AsyncWriteExt};

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:8080").await?;
    println!("Chat server running on 127.0.0.1:8080");

    // ブロードキャストチャネルを作成
    let (tx, _) = broadcast::channel(100);

    loop {
        let (mut socket, addr) = listener.accept().await?;
        println!("Client connected: {}", addr);

        let tx = tx.clone();
        let mut rx = tx.subscribe();

        // 非同期タスクでクライアントを処理
        tokio::spawn(async move {
            let mut buffer = [0; 1024];
            loop {
                tokio::select! {
                    result = socket.read(&mut buffer) => {
                        let n = match result {
                            Ok(n) if n == 0 => return,
                            Ok(n) => n,
                            Err(_) => return,
                        };
                        let message = String::from_utf8_lossy(&buffer[..n]).to_string();
                        println!("Received: {}", message);
                        tx.send(message).unwrap();
                    }
                    result = rx.recv() => {
                        if let Ok(message) = result {
                            socket.write_all(message.as_bytes()).await.unwrap();
                        }
                    }
                }
            }
        });
    }
}

use tokio::net::TcpStream;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::spawn;

#[tokio::main]
async fn main() -> std::io::Result<()> {
    let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
    println!("Connected to the chat server!");

    // 非同期タスクで受信メッセージを処理
    let mut stream_clone = stream.try_clone().unwrap();
    spawn(async move {
        let mut buffer = [0; 1024];
        loop {
            match stream_clone.read(&mut buffer).await {
                Ok(0) => break,
                Ok(n) => {
                    println!("Received: {}", String::from_utf8_lossy(&buffer[..n]));
                }
                Err(_) => break,
            }
        }
    });

    // ユーザー入力を送信
    let stdin = tokio::io::stdin();
    let mut input = String::new();
    loop {
        stdin.read_line(&mut input).await?;
        stream.write_all(input.trim().as_bytes()).await?;
        input.clear();
    }
}