Como garantir a entrega de dados pelo protocolo UDP?

A entrega garantida sobre UDP, sendo um protocolo sem conexão e sem garantia de entrega, requer a implementação de mecanismos de fiabilidade ao nível da aplicação ou através de middleware. As abordagens principais incluem:

1. Mecanismos de confirmação (Acknowledgements - ACK): O remetente inclui em cada datagrama um identificador (por exemplo, um número de sequência). O receptor envia uma confirmação de receção para cada datagrama recebido com sucesso.
2. Mecanismos de retransmissão: O remetente estabelece um temporizador após enviar um datagrama. Se não receber confirmação antes de expirar o temporizador, o datagrama é considerado perdido e reenviado.
3. Mecanismos de controlo de duplicados: O receptor acompanha os identificadores dos datagramas recebidos e descarta os duplicados se aparecerem como resultado de retransmissões.
4. Mecanismos de controlo de ordem: Embora UDP não garanta a ordem, a aplicação pode usar números de sequência para reordenar os datagramas no lado do receptor.
5. Controlo de fluxo: Se necessário, pode implementar-se um mecanismo que evite o sobrecarregamento do buffer do receptor.

A implementação destes mecanismos requer esforços significativos ao nível da aplicação ou o uso de bibliotecas/protocolos especializados construídos sobre UDP, por exemplo:

• Reliable User Datagram Protocol (RUDP): Extensão do UDP que adiciona fiabilidade.
• Quic: Protocolo de transporte desenvolvido pelo Google, que funciona sobre UDP e fornece funcionalidades semelhantes ao TCP (fiabilidade, controlo de fluxo, segurança), mas com tempos de estabelecimento de ligação melhorados e menor impacto por perdas de pacotes.
• Protocolos para tempo real com fiabilidade parcial: Por exemplo, o Secure Real-time Transport Protocol (SRTP) pode incluir mecanismos de fiabilidade opcionais.

Exemplo de lógica esquemática no lado do remetente:

# pseudocódigo para ilustração

data_to_send = [...] # lista de datagramas
sent_packets = {}    # dicionário: número de sequência -> (dados, tempo de envio)
next_seq_num = 0
ack_timeout = 0.1    # segundos
max_retransmissions = 5

for data in data_to_send:
    packet = (next_seq_num, data)
    send_udp(packet)
    sent_packets[next_seq_num] = (packet, time.time(), 0) # pacote, tempo de envio, número de retransmissões
    next_seq_num += 1

while sent_packets:
    # Espera por confirmações
    acks = receive_acks() # simulação de receção de confirmações
    for seq_num in acks:
        if seq_num in sent_packets:
            del sent_packets[seq_num] # remover da lista de espera

    # Verificar temporizadores e retransmitir
    current_time = time.time()
    packets_to_retransmit = []
    for seq_num, (packet, send_time, retransmit_count) in sent_packets.items():
        if current_time - send_time > ack_timeout:
            if retransmit_count < max_retransmissions:
                packets_to_retransmit.append(seq_num)
            else:
                # Pacote perdido definitivamente após MaxRetransmissions
                handle_packet_loss(seq_num)
                del sent_packets[seq_num]

    for seq_num in packets_to_retransmit:
        packet, _, retransmit_count = sent_packets[seq_num]
        send_udp(packet)
        sent_packets[seq_num] = (packet, time.time(), retransmit_count + 1) # atualizar tempo e contador

Esta implementação na prática cria um protocolo sobre UDP que imita o comportamento do TCP em termos de fiabilidade. A escolha de uma abordagem específica depende dos requisitos da aplicação (por exemplo, latência, largura de banda). Para a maioria dos casos que requerem fiabilidade, é preferível usar protocolos existentes (TCP, QUIC) ou bibliotecas testadas.