Net

TCP echo server

首先，我们需要一个一个服务器端。

  1. fn server<A: ToSocketAddrs>(addr: A) -> io::Result<()> {
  2.     // 建立一个监听程序
  3.     let listener = try!(TcpListener::bind(&addr)) ;
  4.     // 这个程序一次只需处理一个链接就好
  5.     for stream in listener.incoming() {
  6.         // 通过match再次解包 stream到
  7.         match stream {
  8.             // 这里匹配的重点是如何将一个mut的匹配传给一个Result
  9.             Ok(mut st) => {
  10.                 // 我们总是要求client端先发送数据
  11.                 // 准备一个超大的缓冲区
  12.                 // 当然了，在实际的生活中我们一般会采用环形缓冲来重复利用内存。
  13.                 // 这里仅作演示，是一种很低效的做法
  14.                 let mut buf: Vec<u8> = vec![0u8; 1024];
  15.                 // 通过try!方法来解包
  16.                 // try!方法的重点是需要有特定的Error类型与之配合
  17.                 let rcount = try!(st.read(&mut buf));
  18.                 // 只输出缓冲区里读取到的内容
  19.                 println!("{:?}", &buf[0..rcount]);
  20.                 // 回写内容
  21.                 let wcount = try!(st.write(&buf[0..rcount]));
  22.                 // 以下代码实际上算是逻辑处理
  23.                 // 并非标准库的一部分了
  24.                 if rcount != wcount {
  25.                     panic!("Not Fully Echo!, r={}, w={}", rcount, wcount);
  26.                 }
  27.                 // 清除掉已经读到的内容
  28.                 buf.clear();
  29.             }
  30.             Err(e) => {
  31.                 panic!("{}", e);
  32.             }
  33.         }
  34.     }
  35.     // 关闭掉Serve端的链接
  36.     drop(listener);
  37.     Ok(())
  38. }

然后，我们准备一个模拟TCP短链接的客户端：

  1. fn client<A: ToSocketAddrs>(addr: A) -> io::Result<()> {
  3.     let mut buf = vec![0u8;1024];
  4.     loop {
  5.         // 对比Listener，TcpStream就简单很多了
  6.         // 本次模拟的是tcp短链接的过程，可以看作是一个典型的HTTP交互的基础IO模拟
  7.         // 当然，这个通讯里面并没有HTTP协议 XD！
  8.         let mut stream = TcpStream::connect(&addr).unwrap();
  9.         let msg = "WaySLOG comming!".as_bytes();
  10.         // 避免发送数据太快而刷屏
  11.         thread::sleep_ms(100);
  12.         let rcount = try!(stream.write(&msg));
  13.         let _ = try!(stream.read(&mut buf));
  14.         println!("{:?}", &buf[0..rcount]);
  15.         buf.clear();
  16.     }
  17.     Ok(())
  18. }

将我们的程序拼接起来如下：

  1. use std::net::*;
  2. use std::io;
  3. use std::io::{Read, Write};
  4. use std::env;
  5. use std::thread;
  7. fn server<A: ToSocketAddrs>(addr: A) -> io::Result<()> { .. }
  10. fn client<A: ToSocketAddrs>(addr: A) -> io::Result<()> { .. }
  13. fn main() {
  14.     let mut args = env::args();
  15.     args.next();
  16.     let action = args.next().unwrap();
  17.     if action == "s" {
  18.         server(&args.next().unwrap()).unwrap();
  19.     } else {
  20.         client(&args.next().unwrap()).unwrap();
  21.     }
  22. }