如何确认TCP服务器已正确接收数据并实现重发机制？

原客户端代码 #

use std::error::Error;
use tokio::io::AsyncWriteExt;
use tokio::net::TcpStream;

#[tokio::main]
pub async fn match_tcp_client(address: String, self_ip: String) -> Result<(), Box<dyn Error>> {
    // Connect to a peer
    println!("client to connect at {}", address);
    let mut stream = TcpStream::connect(address.clone()).await?;
    println!("client done");
    // Write some data.
    stream.write_all(self_ip.as_bytes()).await?;
    stream.write_all(b"hello world!EOF").await?;
    // stream.shutdown().await?;
    Ok(())
}

问题 #

是否存在可行方案，让客户端知晓服务器是否已正确接收数据，若未正确接收则执行数据重发操作？

解决方案 #

当然有可行方案，核心是在客户端和服务器之间建立确认机制，结合重发逻辑实现可靠传输。具体可以从以下几点入手：

• 约定确认报文：修改通信协议，要求服务器在成功接收并验证数据后，向客户端返回明确的确认信号（比如b"ACK"）；如果数据校验失败，返回否定确认（比如b"NACK"）。
• 加入数据校验：为发送的数据添加完整性校验（比如CRC32哈希、数据长度校验），服务器接收后验证校验值，只有通过才返回确认，避免因数据损坏导致的无效接收。
• 实现带重试的发送逻辑：客户端发送数据后，等待服务器的确认响应，若超时、连接异常或收到否定确认，则触发重发，同时限制最大重发次数防止无限循环。

修改后的示例代码 #

use std::error::Error;
use std::time::Duration;
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpStream;
use tokio::time::timeout;

#[tokio::main]
pub async fn match_tcp_client(address: String, self_ip: String) -> Result<(), Box<dyn Error>> {
    const MAX_RETRIES: u8 = 3;
    const RETRY_DELAY: Duration = Duration::from_secs(1);
    const RESPONSE_TIMEOUT: Duration = Duration::from_secs(2);

    let mut retries = 0;
    while retries < MAX_RETRIES {
        // 尝试建立连接
        let mut stream = match TcpStream::connect(&address).await {
            Ok(conn) => conn,
            Err(e) => {
                eprintln!("连接失败: {}, 剩余重试次数: {}", e, MAX_RETRIES - retries - 1);
                retries += 1;
                tokio::time::sleep(RETRY_DELAY).await;
                continue;
            }
        };
        println!("成功连接到服务器");

        // 组装带长度校验的数据（简单校验示例）
        let payload = format!("{}{}", self_ip, "hello world!EOF");
        let payload_len = payload.len().to_be_bytes(); // 用大端序传递数据长度
        let mut send_data = Vec::new();
        send_data.extend_from_slice(&payload_len);
        send_data.extend_from_slice(payload.as_bytes());

        // 发送数据
        if let Err(e) = stream.write_all(&send_data).await {
            eprintln!("数据发送失败: {}, 剩余重试次数: {}", e, MAX_RETRIES - retries - 1);
            retries += 1;
            tokio::time::sleep(RETRY_DELAY).await;
            continue;
        }

        // 等待服务器确认响应
        let mut response_buf = [0u8; 3];
        match timeout(RESPONSE_TIMEOUT, stream.read_exact(&mut response_buf)).await {
            Ok(Ok(_)) => {
                if &response_buf == b"ACK" {
                    println!("服务器已确认接收数据");
                    return Ok(());
                } else {
                    eprintln!("服务器返回无效响应，剩余重试次数: {}", MAX_RETRIES - retries - 1);
                }
            }
            Ok(Err(e)) => {
                eprintln!("读取响应失败: {}, 剩余重试次数: {}", e, MAX_RETRIES - retries - 1);
            }
            Err(_) => {
                eprintln!("等待响应超时，剩余重试次数: {}", MAX_RETRIES - retries - 1);
            }
        }

        retries += 1;
        tokio::time::sleep(RETRY_DELAY).await;
    }

    Err(format!("达到最大重发次数({})，操作失败", MAX_RETRIES).into())
}

服务器端配合逻辑（简要说明） #

服务器需要对应修改：

1. 先读取4字节的长度值（示例中用usize::to_be_bytes()，对应4字节）
2. 根据长度读取完整的 payload 数据
3. 验证数据完整性（示例中可检查长度是否匹配）
4. 向客户端返回b"ACK"或b"NACK"

内容的提问来源于stack exchange，提问作者Zubayr