在Udp的基础上实现可靠数据传输及代码实现

在UDP基础上实现可靠数据传输，需要进行数据包的确认、重传、流量控制等操作。以下是一种简单的可靠UDP实现方式：

1. 发送方将数据分为若干个数据包，并为每个数据包分配一个序号。同时，记录一个发送窗口的起始序号和结束序号，初始时起始序号和结束序号相同。

2. 发送方向接收方发送数据包，并启动一个定时器。定时器的时间间隔为超时时间，即在这个时间内若未收到对应的确认包，就认为数据包丢失，需要进行重传。

3. 接收方收到数据包后，向发送方发送一个确认包，确认包中包含已成功接收的数据包序号。

4. 发送方收到确认包后，将发送窗口的起始序号更新为确认包中最小的未确认序号。同时，停止对应的定时器。如果有数据包未被确认，则重新启动对应的定时器。

5. 发送方每次发送数据包时，需要根据发送窗口的大小来控制发送速率，以防止网络拥塞。

以下是一个简单的可靠UDP的代码实现：

发送方：

import socket
import time

# 定义超时时间
TIMEOUT = 1

# 定义发送窗口大小
WINDOW_SIZE = 4

# 定义数据包大小
PACKET_SIZE = 1024

# 发送数据包
def send_packet(sock, data, addr, seq):
    packet = str(seq).encode() + data
    sock.sendto(packet, addr)
    print('send packet:', seq)
    return time.time()

# 接收确认包
def recv_ack(sock):
    ack, addr = sock.recvfrom(PACKET_SIZE)
    ack_seq = int(ack.decode())
    print('recv ack:', ack_seq)
    return ack_seq

# 发送数据
def send_data(sock, data, addr):
    # 分割数据
    packets = [data[i:i+PACKET_SIZE] for i in range(0, len(data), PACKET_SIZE)]
    # 初始化发送窗口
    window_start = 0
    window_end = min(WINDOW_SIZE, len(packets))
    # 初始化未确认的数据包
    unacked_packets = {i: time.time() for i in range(window_start, window_end)}
    while unacked_packets:
        # 发送窗口内的数据包
        for seq in range(window_start, window_end):
            if seq in unacked_packets and time.time() - unacked_packets[seq] > TIMEOUT:
                # 超时重传
                unacked_packets[seq] = send_packet(sock, packets[seq], addr, seq)
        # 接收确认包
        try:
            ack_seq = recv_ack(sock)
            if ack_seq >= window_start:
                del unacked_packets[ack_seq]
                window_start = ack_seq + 1
                window_end = min(window_end + 1, len(packets))
        except socket.timeout:
            pass
        # 发送新的数据包
        while window_end < len(packets) and window_end - window_start < WINDOW_SIZE:
            unacked_packets[window_end] = send_packet(sock, packets[window_end], addr, window_end)
            window_end += 1

# 测试代码
if __name__ == '__main__':
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.settimeout(TIMEOUT)
    data = b'hello world'
    addr = ('localhost', 8888)
    send_data(sock, data, addr)
    sock.close()

接收方：

import socket

# 定义数据包大小
PACKET_SIZE = 1024

# 发送确认包
def send_ack(sock, seq, addr):
    ack = str(seq).encode()
    sock.sendto(ack, addr)
    print('send ack:', seq)

# 接收数据
def recv_data(sock):
    data = b''
    seq = 0
    while True:
        packet, addr = sock.recvfrom(PACKET_SIZE)
        packet_seq = int(packet[:8].decode())
        if packet_seq == seq:
            # 接收到的数据包是期望的数据包，发送确认包
            data += packet[8:]
            seq += 1
            send_ack(sock, packet_seq, addr)
        elif packet_seq < seq:
            # 接收到的数据包是已经接收过的数据包，发送确认包
            send_ack(sock, packet_seq, addr)
        else:
            # 接收到的数据包是期望的后续数据包，不发送确认包
            pass
        if len(packet) < PACKET_SIZE:
            # 收到最后一个数据包，结束接收
            break
    return data

# 测试代码
if __name__ == '__main__':
    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    sock.bind(('localhost', 8888))
    data = recv_data(sock)
    print('recv data:', data.decode())
    sock.close()