Jak zajistit garantované doručení dat přes protokol…

Zaručená doručení přes UDP, jakožto protokol bez navazování spojení a bez záruky doručení, vyžaduje implementaci mechanismů spolehlivosti na úrovni aplikace nebo s využitím middleware. Hlavní přístupy zahrnují:

Mechanismy potvrzení (Acknowledgements - ACK): Odesílatel zahrnuje do každého datagramu identifikátor (například pořadové číslo). Příjemce posílá potvrzení o přijetí pro každý úspěšně přijatý datagram.
Mechanismy opakovaného přenosu (Retransmission): Odesílatel nastaví časovač po odeslání datagramu. Pokud potvrzení nepřijde před vypršením časovače, datagram je považován za ztracený a je odeslán znovu.
Mechanismy kontroly duplicit: Příjemce sleduje identifikátory přijatých datagramů a odmítá duplicity, pokud se objeví v důsledku opakovaného přenosu.
Mechanismy kontroly pořadí: Ačkoliv UDP nezaručuje pořadí, aplikace může používat pořadová čísla k přeuspořádání datagramů na straně příjemce.
Kontrola toku: Pokud je třeba, lze implementovat mechanismus, který zabrání přetečení bufferu příjemce.

Implementace těchto mechanismů vyžaduje značné úsilí na úrovni aplikace nebo použití specializovaných knihoven/protokolů, například:

Reliable User Datagram Protocol (RUDP): Rozšíření UDP, které přidává spolehlivost.
Quic: Transportní protokol vyvinutý Googlem, který běží nad UDP a poskytuje funkčnost podobnou TCP (spolehlivost, řízení toku, bezpečnost), ale s vylepšeným časem navázání spojení a menším dopadem ztrát paketů.
Protokoly pro reálný čas s částečnou spolehlivostí: Například Secure Real-time Transport Protocol (SRTP) může zahrnovat volitelné mechanismy spolehlivosti.

Příklad schematické logiky na straně odesílatele:

# pseudokód pro názornost

data_to_send = [...] # seznam datagramů
sent_packets = {}    # slovník: pořadové číslo -> (data, čas odeslání)
next_seq_num = 0
ack_timeout = 0.1    # sekundy
max_retransmissions = 5

pro data v data_to_send:
    paket = (next_seq_num, data)
    send_udp(paket)
    sent_packets[next_seq_num] = (paket, time.time(), 0) # paket, čas odeslání, počet opakování
    next_seq_num += 1

dokud sent_packets:
    # Čekáme na potvrzení
    acks = receive_acks() # simulace příjmu potvrzení
    pro seq_num v acks:
        pokud seq_num v sent_packets:
            del sent_packets[seq_num] # odstraníme z čekajícího seznamu

    # Kontrola časových limitů a opětovné odeslání
    current_time = time.time()
    packets_to_retransmit = []
    pro seq_num, (paket, send_time, retransmit_count) v sent_packets.items():
        pokud current_time - send_time > ack_timeout:
            pokud retransmit_count < max_retransmissions:
                packets_to_retransmit.append(seq_num)
            jinak:
                # Paket je definitivně ztracen po MaxRetransmissions
                handle_packet_loss(seq_num)
                del sent_packets[seq_num]

    pro seq_num v packets_to_retransmit:
        paket, _, retransmit_count = sent_packets[seq_num]
        send_udp(paket)
        sent_packets[seq_num] = (paket, time.time(), retransmit_count + 1) # aktualizace času a počtu

Tato implementace v podstatě vytváří nad UDP protokol, který simuluje chování TCP z hlediska spolehlivosti. Výběr konkrétního přístupu závisí na požadavcích aplikace (například zpoždění, propustnost). Pro většinu případů, kde je potřeba spolehlivost, je vhodnější použít hotové protokoly (TCP, QUIC) nebo osvědčené knihovny.

Jak zajistit garantované doručení dat přes protokol UDP?