Hogyan biztosítható az adatok garantált kézbesítése az UDP protokollal?

Az UDP-n keresztül történő garantált kézbesítés, mint kapcsolat nélküli és garancia nélküli protokoll, megbízhatósági mechanizmusokat igényel az alkalmazási szinten vagy middleware használatával. A fő megközelítések a következők:

1. Elismerési mechanizmusok (Acknowledgements - ACK): A küldő minden egyes datagramhoz hozzárendel egy azonosítót (pl. sorrányszám). A fogadó megerősítést küld minden sikeresen fogadott datagramról.
2. Újraküldési mechanizmusok (Retransmission): A küldő időzítőt állít be a datagram küldése után. Ha az eltelő idő alatt nem érkezik megerősítés, a datagram elveszettnek tekinthető, és újraküldésre kerül.
3. Duplikátum-ellenőrző mechanizmusok: A fogadó nyomon követi a kapott datagramok azonosítóit, és elutasítja a duplikátumokat, amelyek az újraküldés eredményeként keletkeznek.
4. Sorrend-ellenőrző mechanizmusok: Bár az UDP nem garantálja a sorrendet, az alkalmazás használhat sorrányszámokat a datagramok újrarendezéséhez.
5. Áramlásvezérlés: Szükség esetén olyan mechanizmust lehet megvalósítani, amely megakadályozza a fogadó buffer túlcsordulását.

Ezeknek a mechanizmusoknak a megvalósítása jelentős erőfeszítést igényel az alkalmazási szinten vagy speciális könyvtárak/protokollok használatával, például:

• Reliable User Datagram Protocol (RUDP): A UDP kiterjesztése, amely megbízhatóságot ad hozzá.
• Quic: A Google által fejlesztett szállítási protokoll, amely UDP fölött működik, és olyan funkciókat nyújt, mint a TCP (megbízhatóság, áramlásvezérlés, biztonság), de gyorsabb kapcsolatfelépítést és kisebb csomagveszteséget kínál.
• Valós idejű protokollok részleges megbízhatósággal: Például a Secure Real-time Transport Protocol (SRTP) opcionális megbízhatósági mechanizmusokat tartalmazhat.

Az alábbiakban egy egyszerű példát mutatunk be a küldő oldal logikájára:

# példakód szemléltetéshez

data_to_send = [...] # adatcsomagok listája
sent_packets = {}    # szótár: sorrányszám -> (adat, küldési idő)
next_seq_num = 0
ack_timeout = 0.1    # másodperc
max_retransmissions = 5

minden data in data_to_send esetén:
    packet = (next_seq_num, data)
    send_udp(packet)
    sent_packets[next_seq_num] = (packet, time.time(), 0) # csomag, küldési idő, újraküldések száma
    next_seq_num += 1

amíg sent_packets:
    # Várjuk az elismeréseket
    acks = receive_acks() # elismerések fogadásának szimulációja
    minden seq_num az acks-ben:
        ha seq_num a sent_packets-ben:
            törlés sent_packets[seq_num] # törlés a várakozó listáról

    # Időkorlátok ellenőrzése és újraküldés
    current_time = time.time()
    packets_to_retransmit = []
    minden seq_num, (packet, send_time, retransmit_count) a sent_packets.items() között:
        ha current_time - send_time > ack_timeout:
            ha retransmit_count < max_retransmissions:
                packets_to_retransmit.append(seq_num)
            más:
                # A csomag véglegesen elveszett a MaxRetransmissions után
                handle_packet_loss(seq_num)
                törlés sent_packets[seq_num]

    minden seq_num a packets_to_retransmit listában:
        packet, _, retransmit_count = sent_packets[seq_num]
        send_udp(packet)
        sent_packets[seq_num] = (packet, time.time(), retransmit_count + 1) # idő és számláló frissítése

Ez a megvalósítás lényegében egy TCP-hez hasonló megbízhatóságot szimuláló protokollt hoz létre UDP felett. A konkrét megközelítés kiválasztása az alkalmazás követelményeitől (pl. késleltetés, sávszélesség) függ. A legtöbb esetben, ahol megbízhatóság szükséges, célszerű kész protokollokat (TCP, QUIC) vagy bevált könyvtárakat használni.