服务端

    1. use std::thread;
    2. use std::net::{TcpListener, TcpStream, Shutdown};
    3. use std::io::{Read, Write};
    5. fn handle_client(mut stream: TcpStream) {
    6.     let mut data = [0 as u8; 50]; // using 50 byte buffer
    7.     while match stream.read(&mut data) {
    8.         Ok(size) => {
    9.             // echo everything!
    10.             stream.write(&data[0..size]).unwrap();
    11.             true
    12.         },
    13.         Err(_) => {
    14.             println!("An error occurred, terminating connection with {}", stream.peer_addr().unwrap());
    15.             stream.shutdown(Shutdown::Both).unwrap();
    16.             false
    17.         }
    18.     } {}
    19. }
    21. fn main() {
    22.     let listener = TcpListener::bind("0.0.0.0:3333").unwrap();
    23.     // accept connections and process them, spawning a new thread for each one
    24.     println!("Server listening on port 3333");
    25.     for stream in listener.incoming() {
    26.         match stream {
    27.             Ok(stream) => {
    28.                 println!("New connection: {}", stream.peer_addr().unwrap());
    29.                 thread::spawn(move|| {
    30.                     // connection succeeded
    31.                     handle_client(stream)
    32.                 });
    33.             }
    34.             Err(e) => {
    35.                 println!("Error: {}", e);
    36.                 /* connection failed */
    37.             }
    38.         }
    39.     }
    40.     // close the socket server
    41.     drop(listener);
    42. }

    客户端

    1. use std::net::{TcpStream};
    2. use std::io::{Read, Write};
    3. use std::str::from_utf8;
    5. fn main() {
    6.     match TcpStream::connect("localhost:3333") {
    7.         Ok(mut stream) => {
    8.             println!("Successfully connected to server in port 3333");
    10.             let msg = b"Hello99999";
    12.             stream.write(msg).unwrap();
    13.             println!("Sent Hello, awaiting reply...");
    15.             let mut data = [0 as u8; 10]; // using 6 byte buffer
    16.             match stream.read_exact(&mut data) {
    17.                 Ok(_) => {
    18.                     if &data == msg {
    19.                         println!("Reply is ok!");
    20.                         let text = from_utf8(&data).unwrap();
    21.                         println!("Unexpected reply: {}", text);
    22.                     } else {
    23.                         let text = from_utf8(&data).unwrap();
    24.                         println!("Unexpected reply: {}", text);
    25.                     }
    26.                 },
    27.                 Err(e) => {
    28.                     println!("Failed to receive data: {}", e);
    29.                 }
    30.             }
    31.         },
    32.         Err(e) => {
    33.             println!("Failed to connect: {}", e);
    34.         }
    35.     }
    36.     println!("Terminated.");
    37. }