Rust Socket Programming - Chapter 1

오늘은 간단하게 Rust를 이용하여 다중클라이언트 에코 서비스를 구현해보도록 하겠습니다.

 

server.rs

use std::thread;
use std::net::{TcpListener, TcpStream, Shutdown};
use std::io::{Read, Write};
use std::str::from_utf8;

fn handle_client(mut stream: TcpStream) {
    let mut data = [0 as u8; 1000]; 
    while match stream.read(&mut data) {
        Ok(_size) => {
            let text = from_utf8(&data).unwrap();
            print!("[{}] : {}", stream.peer_addr().unwrap(), text);
            stream.write(text.as_bytes()).unwrap();
            true
        },
        Err(_) => {
            println!("Disconnect [{}]", stream.peer_addr().unwrap());
            stream.shutdown(Shutdown::Both).unwrap();
            false
        }
    } {}
}

fn main() {
    println!("[Server]");

    println!("Enter server ip");
    let mut ip = String::from("");
    std::io::stdin().read_line(&mut ip).unwrap();
    let server_ip = &ip[0..ip.chars().count()-2];
    
    println!("Enter server port");
    let mut port = String::from("");
    std::io::stdin().read_line(&mut port).unwrap();
    let server_port = &port[0..port.chars().count()-2];

    let mut server_address = String::from("");
    server_address.push_str(server_ip);
    server_address.push_str(":");
    server_address.push_str(server_port);

    let listener = TcpListener::bind(server_address).unwrap();
    println!("Server listening on port {server_port}");
    for stream in listener.incoming() {
        match stream {
            Ok(stream) => {
                println!("New Connect [{}]", stream.peer_addr().unwrap());
                thread::spawn(move|| {
                    handle_client(stream)
                });
            }
            Err(e) => {
                println!("Error: {}", e);
            }
        }
    }
    drop(listener);
}

 

client.rs

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

fn main() {
    println!("[Client]");
    println!("Enter server address (ip:port)");
    let mut address = String::from("");
    let _temp = std::io::stdin().read_line(&mut address).unwrap();
    let server_address = &address[0..address.chars().count()-2];

    match TcpStream::connect(server_address) {
        Ok(mut stream) => {
            println!("Successfully connected to server in address {}\n", server_address);
            loop {
                let mut msg = String::from("");
                std::io::stdin().read_line(&mut msg).unwrap();
            
                stream.write(msg.as_bytes()).unwrap();

                let mut data = [0 as u8; 1000]; 
                match stream.read(&mut data) {
                    Ok(_) => {
                        if &data == msg.as_bytes() {
                            let text2 = from_utf8(&data).unwrap();
                            print!("recv : {text2}end");
                        } else {
                            let text = from_utf8(&data).unwrap();
                            println!("[echo server] : {}", text);
                        }
                    },
                    Err(e) => {
                        println!("Failed to receive data: {}", e);
                    }
                }
            }
        },
        Err(e) => {
            println!("Failed to connect: {}", e);
        }
    }
    println!("Terminated.");
}

 

실행 화면

 

소스 코드 링크

https://github.com/levhyun/rust_TCP

GitHub - levhyun/rust_TCP: [RUST] 스레드를 통한 다중 클라이언트 에코 서비스