23、Rust网络编程入门：从USB设备管理到网络通信

Rust网络编程入门：从USB设备管理到网络通信

1. USB设备管理回顾

在开始网络编程之前，先回顾一下USB设备管理相关内容。可以编写程序来检测连接的USB设备，并将每个USB设备的详细信息打印到终端和输出文件 usb_details.txt 中。具体操作步骤如下：
1. 确保将USB设备（如U盘）插入计算机。
2. 使用 cargo run 运行代码。

代码示例展示了如何使用外部 crate 检索USB设备详细信息，以及使用标准库进行文件I/O操作。同时，通过统一的错误处理结构体实现了错误处理的统一，并自动将错误类型转换为自定义错误类型。

// 代码省略，可参考原内容

Rust标准库为任何类型的设备提供了清晰的I/O操作抽象层，这鼓励Rust生态系统为任何类型的设备实现这些标准接口，使Rust系统程序员能够以统一的方式与不同设备进行交互。

2. 网络编程概述

网络编程是系统编程中的一个重要主题。大多数现代操作系统（如Unix/Linux和Windows变体）都原生支持使用TCP/IP进行网络通信。下面将介绍如何使用Rust进行网络编程，包括网络基础、Rust标准库中的网络原语、TCP和UDP编程，以及一个TCP反向代理项目。

2.1 技术要求

在开始之前，需要验证 rustup 、 rustc 和 cargo 是否已正确安装，可以使用以下命令进行验证：

rustup --version
rustc --version
cargo --version

代码的Git仓库地址为：https://github.com/PacktPublishing/Practical-System-Programming-for-Rust-Developers/tree/master/Chapter11

2.2 网络基础知识

互联网连接了全球多个不同的网络，使跨网络的机器能够以不同的方式进行通信，如请求 - 响应模型（同步）、异步消息传递和发布 - 订阅式通知。互联网还提供了网络协议和标准的抽象，方便不同网络上的主机进行通信。

2.2.1 网络标准

• 主机寻址格式 ：常见的主机寻址格式，结合主机地址和端口来定义网络端点。
• IP地址 ：IPv4地址是32位数字，IPv6地址是128位数字。

2.2.2 网络协议

协议名称	作用
HTTP	用于Web浏览器从Web服务器检索文档
DNS	将域名映射到主机地址
IP	将数据打包并在互联网上路由数据包
TCP	为IP数据包添加可靠性和错误处理

TCP/IP协议套件是互联网的基础，它分为以下几个层次：

graph LR
    A[应用层] --> B[传输层]
    B --> C[网络层（IP层）]
    C --> D[数据链路层]

• 数据链路层 ：由设备驱动程序和网络接口卡组成，将从较高网络（IP）层接收到的数据组装成数据帧，并通过物理链路传输。
• IP层 ：将数据组装成数据包并发送到数据链路层，负责在互联网上路由数据。IP是无连接协议，不保证数据的传输。
• 传输层 ：有两个流行的协议，即TCP和UDP。TCP是面向连接的，提供可靠的通信通道；UDP是无连接的，速度快但不保证可靠性。
• 应用层 ：处理消息的语义，例如HTTP使用请求和响应消息进行通信。

3. Rust标准库中的网络原语

Rust标准库提供了一些基础的数据结构来处理网络编程，常见的数据结构如下：
| 数据结构 | 描述 |
| ---- | ---- |
| Ipv4Addr | 存储32位整数表示的IPv4地址，并提供设置和查询地址值的方法 |
| Ipv6Addr | 存储128位整数表示的IPv6地址，并提供查询和设置地址值的方法 |
| SocketAddrV4 | 表示互联网域套接字，存储IPv4地址和16位端口号 |
| SocketAddrV6 | 表示互联网域套接字，存储IPv6地址和16位端口号 |
| IpAddr | 枚举类型，可表示IPv4或IPv6主机地址 |
| SocketAddr | 枚举类型，可表示IPv4或IPv6套接字地址 |

3.1 创建IP地址示例

use std::net::{Ipv4Addr, Ipv6Addr};

fn main() {
    // 创建一个新的IPv4地址
    let ip_v4_addr1 = Ipv4Addr::new(106, 201, 34, 209);
    // 使用内置常量创建回环（本地主机）地址
    let ip_v4_addr2 = Ipv4Addr::LOCALHOST;
    println!(
        "Is ip_v4_addr1 a loopback address? {}",
        ip_v4_addr1.is_loopback()
    );
    println!(
        "Is ip_v4_addr2 a loopback address? {}",
        ip_v4_addr2.is_loopback()
    );
    // 创建一个新的IPv6地址
    let ip_v6_addr = Ipv6Addr::new(2001, 0000, 3238, 0xDFE1, 0063, 0000, 0000, 0xFEFB);
    println!("IPV 6 segments {:?}", ip_v6_addr.segments());
}

3.2 使用IpAddr枚举示例

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

fn main() {
    // 创建一个IPv4地址
    let ip_v4_addr = IpAddr::V4(Ipv4Addr::new(106, 201, 34, 209));
    // 检查地址是IPv4还是IPv6
    println!("Is ip_v4_addr an ipv4 address? {}", ip_v4_addr.is_ipv4());
    println!("Is ip_v4_addr an ipv6 address? {}", ip_v4_addr.is_ipv6());
    // 创建一个IPv6地址
    let ip_v6_addr = IpAddr::V6(Ipv6Addr::new(0, 0, 0, 0, 0, 0, 0, 1));
    println!("Is ip_v6_addr an ipv6 address? {}", ip_v6_addr.is_ipv6());
}

3.3 创建套接字示例

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

fn main() {
    // 创建一个IPv4套接字
    let socket = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 8000);
    println!("Socket address is {}, port is {}", socket.ip(), socket.port());
    println!("Is this IPv6 socket? {}", socket.is_ipv6());
}

IP地址和套接字是使用Rust标准库进行网络编程的基础数据结构。接下来将介绍如何使用Rust编写TCP和UDP程序。

4. 使用Rust进行TCP和UDP编程

TCP和UDP是互联网中基本的传输层网络协议。下面将分别介绍如何编写UDP和TCP的服务器和客户端程序。

4.1 创建项目

首先，创建一个名为 tcpudp 的新项目：

cargo new tcpudp && cd tcpudp

4.2 UDP服务器和客户端

4.2.1 UDP服务器

// tcpudp/src/bin/udp-server.rs
use std::str;
use std::thread;
use std::net::UdpSocket;

fn main() {
    let socket = UdpSocket::bind("127.0.0.1:3000").expect("Unable to bind to port");
    let mut buffer = [0; 1024];
    loop {
        let socket_new = socket.try_clone().expect("Unable to clone socket");
        match socket_new.recv_from(&mut buffer) {
            Ok((num_bytes, src_addr)) => {
                thread::spawn(move || {
                    let send_buffer = &mut buffer[..num_bytes];
                    println!(
                        "Received from client: {}",
                        str::from_utf8(send_buffer).unwrap()
                    );
                    let response_string = format!("Received this: {}", String::from_utf8_lossy(send_buffer));
                    socket_new.send_to(response_string.as_bytes(), &src_addr).expect("error in sending datagram to remote socket");
                });
            }
            Err(err) => {
                println!("Error in receiving datagrams over UDP: {}", err);
            }
        }
    }
}

4.2.2 UDP客户端

// tcpudp/src/bin/udp-client.rs
use std::net::UdpSocket;

fn main() {
    let socket = UdpSocket::bind("0.0.0.0:0").expect("Unable to bind to socket");
    socket.connect("127.0.0.1:3000").expect("Could not connect to UDP server");
    println!("socket peer addr is {:?}", socket.peer_addr());
    socket.send("Hello: sent using send() call".as_bytes()).expect("Unable to send bytes");
}

4.2.3 运行UDP程序

• 运行UDP服务器：

cargo run --bin udp-server

• 从另一个终端运行UDP客户端：

cargo run --bin udp-client

4.3 TCP服务器和客户端

4.3.1 TCP服务器

// tcpudp/src/bin/tcp-server.rs
use std::io::{Read, Write};
use std::net::TcpListener;

fn main() {
    let connection_listener = TcpListener::bind("127.0.0.1:3000").unwrap();
    println!("Running on port 3000");
    for stream in connection_listener.incoming() {
        let mut stream = stream.unwrap();
        println!("Connection established");
        let mut buffer = [0; 100];
        stream.read(&mut buffer).unwrap();
        println!("Received from client: {}", String::from_utf8_lossy(&buffer));
        stream.write(&mut buffer).unwrap();
    }
}

4.3.2 TCP客户端

// tcpudp/src/bin/tcp-client.rs
use std::io::{Read, Write};
use std::net::TcpStream;
use std::str;

fn main() {
    let mut stream = TcpStream::connect("localhost:3000").unwrap();
    let msg_to_send = "Hello from TCP client";
    stream.write(msg_to_send.as_bytes()).unwrap();
    let mut buffer = [0; 200];
    stream.read(&mut buffer).unwrap();
    println!(
        "Got echo back from server:{:?}",
        str::from_utf8(&buffer).unwrap().trim_end_matches(char::from(0))
    );
}

通过以上步骤，我们学习了如何使用Rust进行USB设备管理和网络编程，包括网络基础、Rust标准库中的网络原语、TCP和UDP编程。希望这些内容能帮助你更好地掌握Rust网络编程。

5. 编写TCP反向代理项目

5.1 项目概述

在前面的内容中，我们已经学习了网络编程的基础知识，包括网络协议、Rust标准库中的网络原语，以及如何编写TCP和UDP的服务器与客户端程序。接下来，我们将通过一个具体的项目——TCP反向代理，来进一步巩固和应用这些知识。

5.2 反向代理原理

反向代理是一种服务器，它位于客户端和目标服务器之间，接收客户端的请求，然后将请求转发给目标服务器，并将目标服务器的响应返回给客户端。反向代理可以实现负载均衡、安全防护、缓存等功能。

5.3 实现步骤

5.3.1 项目结构

首先，我们需要在之前创建的 tcpudp 项目基础上进行开发。项目结构如下：

tcpudp/
├── src/
│   ├── bin/
│   │   ├── udp-server.rs
│   │   ├── udp-client.rs
│   │   ├── tcp-server.rs
│   │   ├── tcp-client.rs
│   │   └── tcp-reverse-proxy.rs
│   └── lib.rs
└── Cargo.toml

5.3.2 编写TCP反向代理代码

以下是 tcpudp/src/bin/tcp-reverse-proxy.rs 的代码示例：

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

fn handle_client(mut client_stream: TcpStream, target_addr: &str) {
    let mut target_stream = TcpStream::connect(target_addr).expect("Failed to connect to target server");

    let (mut client_reader, mut client_writer) = client_stream.split();
    let (mut target_reader, mut target_writer) = target_stream.split();

    let client_to_target = thread::spawn(move || {
        let mut buffer = [0; 1024];
        loop {
            let n = match client_reader.read(&mut buffer) {
                Ok(n) if n == 0 => break,
                Ok(n) => n,
                Err(_) => break,
            };
            target_writer.write_all(&buffer[0..n]).expect("Failed to write to target server");
        }
    });

    let target_to_client = thread::spawn(move || {
        let mut buffer = [0; 1024];
        loop {
            let n = match target_reader.read(&mut buffer) {
                Ok(n) if n == 0 => break,
                Ok(n) => n,
                Err(_) => break,
            };
            client_writer.write_all(&buffer[0..n]).expect("Failed to write to client");
        }
    });

    client_to_target.join().expect("Client to target thread panicked");
    target_to_client.join().expect("Target to client thread panicked");
}

fn main() {
    let listener = TcpListener::bind("127.0.0.1:8080").expect("Failed to bind to port");
    let target_addr = "127.0.0.1:3000";

    println!("Reverse proxy listening on 127.0.0.1:8080");

    for stream in listener.incoming() {
        let stream = stream.expect("Failed to accept connection");
        thread::spawn(move || {
            handle_client(stream, target_addr);
        });
    }
}

5.3.3 代码解释

• handle_client 函数：该函数负责处理客户端的连接。它将客户端的请求转发给目标服务器，并将目标服务器的响应返回给客户端。为了实现双向数据传输，我们使用了两个线程，一个线程负责将客户端的请求转发给目标服务器，另一个线程负责将目标服务器的响应返回给客户端。
• main 函数：该函数创建一个TCP监听器，监听 127.0.0.1:8080 端口。当有新的客户端连接时，它会为每个连接创建一个新的线程，并调用 handle_client 函数来处理该连接。

5.3.4 运行项目

• 首先，确保之前编写的TCP服务器（ tcp-server.rs ）正在运行：

cargo run --bin tcp-server

• 然后，运行TCP反向代理：

cargo run --bin tcp-reverse-proxy

• 最后，运行TCP客户端，将请求发送到反向代理：

cargo run --bin tcp-client

此时，客户端的请求会先发送到反向代理，反向代理再将请求转发给目标服务器（ 127.0.0.1:3000 ），并将目标服务器的响应返回给客户端。

5.4 总结

通过这个TCP反向代理项目，我们进一步加深了对网络编程的理解，学会了如何使用Rust编写一个简单的反向代理服务器。在实际应用中，反向代理可以用于负载均衡、安全防护等场景，具有重要的实用价值。

6. 总结与展望

6.1 内容总结

• USB设备管理 ：我们学习了如何编写程序来检测连接的USB设备，并将设备信息打印到终端和文件中。通过使用外部crate和标准库，实现了文件I/O操作和统一的错误处理。
• 网络编程基础 ：了解了互联网的网络协议和标准，包括TCP/IP协议套件的各个层次，如数据链路层、IP层、传输层和应用层。掌握了Rust标准库中的网络原语，如 Ipv4Addr 、 Ipv6Addr 、 SocketAddr 等。
• TCP和UDP编程 ：学会了如何使用Rust编写TCP和UDP的服务器与客户端程序。通过示例代码，我们了解了如何绑定套接字、接收和发送数据，以及如何处理并发连接。
• TCP反向代理项目 ：通过一个具体的项目，我们实践了如何使用Rust编写一个TCP反向代理服务器，将客户端的请求转发给目标服务器，并将目标服务器的响应返回给客户端。

6.2 知识体系图

下面是一个mermaid格式的流程图，展示了我们所学的知识体系：

graph LR
    A[USB设备管理] --> B[网络编程基础]
    B --> C[TCP和UDP编程]
    C --> D[TCP反向代理项目]
    B --> E[网络协议和标准]
    B --> F[Rust网络原语]
    C --> G[TCP服务器和客户端]
    C --> H[UDP服务器和客户端]

6.3 未来展望

Rust作为一种系统级编程语言，在网络编程领域具有很大的潜力。未来，我们可以进一步探索以下方面：
- 高级网络编程 ：学习更多的网络编程技术，如异步I/O、多路复用等，以提高程序的性能和并发处理能力。
- 分布式系统 ：使用Rust构建分布式系统，实现节点之间的通信和协作，如分布式存储、分布式计算等。
- 网络安全 ：研究网络安全相关的技术，如加密、认证、防火墙等，保障网络通信的安全性。

通过不断学习和实践，我们可以更好地掌握Rust网络编程，开发出更加高效、安全的网络应用程序。希望本文能为你在Rust网络编程的学习道路上提供一些帮助。