Python Socket文件传输中的Unicode解码错误及健壮性协议设计

file_name = client.recv(1024).decode()
file_size = client.recv(1024).decode()

client.send("received_image.png".encode() + b'\x00')
client.send(str(file_size).encode() + b'\x00')

def recv_until_null(sock):
    buffer = b''
    while True:
        chunk = sock.recv(1) # 每次接收一个字节
        if not chunk: # 连接已关闭
            raise ConnectionError("Connection lost while receiving data.")
        if chunk == b'\x00':
            break
        buffer += chunk
    return buffer.decode('utf-8') # 解码接收到的字符串

file_name = recv_until_null(client)
file_size_str = recv_until_null(client)
file_size = int(file_size_str)

import os
import socket
import struct # 用于处理固定长度的二进制数据

HOST = "localhost"
PORT = 9999

def send_file(client_socket, file_path, remote_file_name):
    """
    发送文件到服务器。
    协议：文件名长度(4字节) -> 文件名 -> 文件大小(8字节) -> 文件内容
    """
    try:
        file_size = os.path.getsize(file_path)

        # 1. 发送文件名
        file_name_bytes = remote_file_name.encode('utf-8')
        file_name_len = len(file_name_bytes)
        # 使用struct.pack将整数打包成固定字节长度的二进制数据
        client_socket.sendall(struct.pack("!I", file_name_len)) # !I 表示大端无符号整数 (4字节)
        client_socket.sendall(file_name_bytes)

        # 2. 发送文件大小
        client_socket.sendall(struct.pack("!Q", file_size)) # !Q 表示大端无符号长长整数 (8字节)

        # 3. 分块发送文件内容
        print(f"开始发送文件: {file_path} ({file_size} 字节)")
        with open(file_path, "rb") as f:
            bytes_sent = 0
            while True:
                chunk = f.read(4096) # 每次读取4KB
                if not chunk:
                    break
                client_socket.sendall(chunk)
                bytes_sent += len(chunk)
                # print(f"\r已发送: {bytes_sent}/{file_size} 字节", end="")
        print(f"\n文件 {remote_file_name} 发送完成。")

    except Exception as e:
        print(f"客户端发送文件时发生错误: {e}")

if __name__ == "__main__":
    client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    try:
        client.connect((HOST, PORT))
        print(f"已连接到服务器 {HOST}:{PORT}")

        # 假设要发送的图片文件名为 "image.png"
        # 远程保存的文件名为 "received_image.png"
        send_file(client, "image.png", "received_image.png")

    except ConnectionRefusedError:
        print("连接被拒绝，请确保服务器已运行。")
    except Exception as e:
        print(f"客户端发生错误: {e}")
    finally:
        client.close()
        print("客户端连接已关闭。")

import socket
import tqdm
import struct
import os

HOST = "localhost"
PORT = 9999
BUFFER_SIZE = 4096 # 每次接收的字节数

def recv_all(sock, n_bytes):
    """从socket接收指定数量的字节"""
    data = b''
    while len(data) < n_bytes:
        packet = sock.recv(n_bytes - len(data))
        if not packet:
            return None # 连接关闭
        data += packet
    return data

def start_server():
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.bind((HOST, PORT))
    server.listen()
    print(f"服务器正在监听 {HOST}:{PORT}...")

    while True:
        client_socket, addr = server.accept()
        print(f"接受来自 {addr} 的连接。")

        try:
            # 1. 接收文件名长度
            file_name_len_bytes = recv_all(client_socket, 4)
            if file_name_len_bytes is None:
                print("连接中断，无法接收文件名长度。")
                continue
            file_name_len = struct.unpack("!I", file_name_len_bytes)[0]

            # 2. 接收文件名
            file_name_bytes = recv_all(client_socket, file_name_len)
            if file_name_bytes is None:
                print("连接中断，无法接收文件名。")
                continue
            file_name = file_name_bytes.decode('utf-8')
            print(f"接收文件名: {file_name}")

            # 3. 接收文件大小
            file_size_bytes = recv_all(client_socket, 8)
            if file_size_bytes is None:
                print("连接中断，无法接收文件大小。")
                continue
            file_size = struct.unpack("!Q", file_size_bytes)[0]
            print(f"接收文件大小: {file_size} 字节")

            # 4. 接收文件内容并写入文件
            with open(file_name, "wb") as f:
                progress = tqdm.tqdm(unit="B", unit_scale=True, unit_divisor=1000, total=file_size, desc=f"接收 {file_name}")
                bytes_received = 0
                while bytes_received < file_size:
                    remaining_bytes = file_size - bytes_received
                    data_to_recv = min(BUFFER_SIZE, remaining_bytes)

                    data = client_socket.recv(data_to_recv)
                    if not data:
                        # 客户端可能已关闭连接，但未发送完所有数据
                        print(f"\n警告: 客户端在发送完文件前断开连接。已接收 {bytes_received}/{file_size} 字节。")
                        break
                    f.write(data)
                    bytes_received += len(data)
                    progress.update(len(data))
                progress.close()

            if bytes_received == file_size:
                print(f"文件 {file_name} 接收完成，大小: {os.path.getsize(file_name)} 字节。")
            else:
                print(f"文件 {file_name} 接收不完整。")

        except Exception as e:
            print(f"服务器处理客户端 {addr} 时发生错误: {e}")
        finally:
            client_socket.close()
            print(f"与 {addr} 的连接已关闭。")

if __name__ == "__main__":
    start_server()