二分队-写端口代码3

服务器1

import socket
import time
from random import randint

def start_server(port=12346):
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    server_socket.bind(('0.0.0.0', port))
    print(f"Server listening on port {port}...")

    expected_packets = 1000  # 假设我们期待接收到1000个包
    received_packets = set()  # 用来记录接收到的唯一包序列号
    incorrect_packets = 0  # 记录接收到的错误数据包

    start_time = time.time()

    while len(received_packets) < expected_packets:
        data, addr = server_socket.recvfrom(1024)
        seq_num = int(data.decode())

        # 模拟数据校验，这里简化处理，假设数据正确性依赖于序列号是否连续
        if seq_num != len(received_packets) + 1:
            incorrect_packets += 1

        received_packets.add(seq_num)

    end_time = time.time()
    elapsed_time = end_time - start_time

    # 计算统计指标
    packet_loss_rate = (expected_packets - len(received_packets)) / expected_packets * 100
    accuracy_rate = 100 - (incorrect_packets / len(received_packets) * 100) if received_packets else 0

    print(f"Total Packets Expected: {expected_packets}")
    print(f"Packets Received: {len(received_packets)}")
    print(f"Packet Loss Rate: {packet_loss_rate:.2f}%")
    print(f"Data Accuracy Rate: {accuracy_rate:.2f}%")
    print(f"Time Elapsed: {elapsed_time:.2f} seconds")

    server_socket.close()

if __name__ == "__main__":
    start_server()
 

客户端1

import socket
import time
from random import random

def start_client(server_ip='127.0.0.1', port=12346):
    try:
        client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        expected_packets = 1000
        for i in range(expected_packets):
            data = str(i + 1).encode()  # Simple sequence number as data content
            client_socket.sendto(data, (server_ip, port))
            # Simulate random delay (in milliseconds)
            time.sleep(random() * 0.01)
    except Exception as e:
        print(f"An error occurred: {e}")
    finally:
        client_socket.close()

if __name__ == "__main__":
    start_client()
 

服务器3

import socket
import struct
import hashlib
import os
BUFFER_SIZE = 1024

def receive_file(sock):
    file_size = struct.unpack('!Q', sock.recv(struct.calcsize('!Q')))[0]
    received_size = 0
    md5_hash = hashlib.md5()
    with open('received_file.txt', 'wb') as f:
        while received_size < file_size:
            chunk = sock.recv(BUFFER_SIZE)
            if not chunk:
                break

            f.write(chunk)
            md5_hash.update(chunk)
            received_size += len(chunk)
    return received_size == file_size, md5_hash.hexdigest()

def main(server_port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.bind(('0.0.0.0', server_port))
        sock.listen()
        print(f"Server listening on port {server_port}...")
        conn, addr = sock.accept()
        print(f"Connection from {addr}")

        success, file_md5 = receive_file(conn)
        if success:
            print("File received successfully.")
            print(f"MD5 Hash: {file_md5}")
        else:
            print("File reception failed.")

        conn.close()

if __name__ == "__main__":
    SERVER_PORT = 12345
    main(SERVER_PORT)
 

客户端3

import socket
import os
import struct
import time
from threading import Thread

BUFFER_SIZE = 128  # 缓冲区大小
FIXED_BANDWIDTH = 1024 * 1024  # 模拟的固定带宽，单位：字节/秒

def send_file(sock, file_path):
    with open(file_path, 'rb') as f:
        file_size = os.path.getsize(file_path)
        sock.sendall(struct.pack('!Q', file_size))  # 先发送文件大小
        sent_size = 0
        start_time = time.time()

        while sent_size < file_size:
            chunk = f.read(BUFFER_SIZE)
            if not chunk:
                break

            sock.sendall(chunk)
            sent_size += len(chunk)

            # 控制发送速率
            sleep_time = max(0, (sent_size / FIXED_BANDWIDTH) - (time.time() - start_time))
            if sleep_time > 0:
                time.sleep(sleep_time)
                start_time += sleep_time

def main(server_ip, server_port, file_path):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
        sock.connect((server_ip, server_port))
        print("Sending file...")
        send_file(sock, file_path)
        print("File sent.")

if __name__ == "__main__":
    SERVER_IP = '127.0.0.1'  # 服务器IP
    SERVER_PORT = 12345  # 服务器端口
    FILE_PATH = 'icudtl.dat'  # 要发送的文件路径
    main(SERVER_IP, SERVER_PORT, FILE_PATH)