Trabalho com UDP.

Implementação de Transferência de Arquivos Confiável sobre UDP com Sockets

O Protocolo UDP

Este projeto foca na implementação de uma aplicação que opera sobre o protocolo UDP, utilizando programação com sockets. O principal objetivo é o desenvolvimento de um Servidor UDP simplificado, para consolidar o conhecimento sobre o funcionamento básico e a programação com UDP, contrastando-o com os serviços que o TCP disponibiliza para a camada de aplicação.

Objetivo do Projeto:

Desenvolver uma aplicação cliente-servidor para transferência de arquivos utilizando o protocolo UDP. O foco principal é a implementação de mecanismos básicos de controle e confiabilidade diretamente sobre UDP, simulando funcionalidades que o TCP oferece nativamente.

Requisitos Gerais:

Linguagem de Programação: A escolha da linguagem é livre (ex: Python, Java, C/C++, etc.).
Restrição de Bibliotecas: Não é permitido o uso de bibliotecas de alto nível que abstraiam a manipulação direta do protocolo UDP. A implementação deve utilizar a API de sockets do sistema operacional (ou da linguagem escolhida) para criar, enviar e receber datagramas UDP.
(Opcional/Sugestão) Recomenda-se iniciar com um exemplo simples “Hello World” cliente/servidor UDP para familiarização com a API de sockets antes de abordar a transferência de arquivos.

Requisitos do Servidor UDP:

Inicialização: O servidor deve ser executado antes do cliente.
Porta: Deve operar em uma porta UDP especificada, com número maior que 1024 (portas abaixo de 1024 geralmente exigem privilégios de administrador).
Recepção e Protocolo:
1. Aguardar conexões/mensagens de clientes.
2. Interpretar as requisições recebidas. É necessário definir e implementar um protocolo de aplicação simples sobre UDP para que o cliente requisite arquivos (Exemplo de formato de requisição: GET /nome_do_arquivo.ext).
Processamento da Requisição:
1. Verificar se o arquivo solicitado existe.
2. Se o arquivo não existir: Enviar uma mensagem de erro claramente definida pelo seu protocolo para o cliente.
Transmissão do Arquivo (se existir):
1. O arquivo a ser transmitido deve ser relativamente grande (ex: > 1 MB) para justificar a segmentação.
2. Segmentação: Dividir o arquivo em múltiplos segmentos/pedaços para envio em datagramas UDP.
3. Cabeçalho Customizado: Cada segmento enviado deve conter informações de controle definidas pelo seu protocolo (ver “Considerações de Protocolo” abaixo).
4. Retransmissão: Implementar lógica para reenviar segmentos específicos caso o cliente solicite (devido a perdas ou erros).

Requisitos do Cliente UDP:

Inicialização: O cliente deve ser executado após o servidor estar ativo.
Conexão: Permitir que o usuário especifique o endereço IP e a porta do servidor UDP ao qual deseja se conectar.
Requisição:
1. Enviar uma requisição ao servidor, utilizando o protocolo de aplicação definido, para solicitar um arquivo específico (Exemplo de entrada do usuário: @IP_Servidor:Porta_Servidor/nome_do_arquivo.ext).
Simulação de Perda:
1. Implementar uma opção (ex: via entrada do usuário ou configuração) que permita ao cliente descartar intencionalmente alguns segmentos recebidos do servidor. Isso é crucial para testar o mecanismo de recuperação de dados. A interface deve informar quais segmentos (ex: por número de sequência) estão sendo descartados.
Recepção e Montagem:
1. Receber os segmentos do arquivo enviados pelo servidor.
2. Armazenar e ordenar os segmentos recebidos corretamente.
3. Verificar a integridade de cada segmento (ex: usando checksum ou resumos criptográficos como o MD5 e SHA.).
Verificação e Finalização:
1. Após receber todos os segmentos esperados (ou um sinal de fim de transmissão do servidor), verificar a integridade e completude do arquivo.
2. Se o arquivo estiver OK: Salvar o arquivo reconstruído localmente e informar o sucesso ao usuário. Opcionalmente, apresentar/abrir o arquivo.
3. Se o arquivo estiver com erro ou incompleto:
  1. Identificar quais segmentos estão faltando ou corrompidos.
  2. Solicitar a retransmissão desses segmentos específicos ao servidor, utilizando o protocolo definido.
  3. Repetir o processo de recepção e verificação até que o arquivo esteja completo e correto.
  4. Interpretação de Erros: Interpretar e exibir mensagens de erro recebidas do servidor (ex: “Arquivo não encontrado”).

Considerações Obrigatórias para o Design do Protocolo:

O aluno deve projetar e justificar as escolhas para os seguintes aspectos do protocolo de aplicação sobre UDP:

Segmentação e Tamanho do Buffer:
1. Como o arquivo será dividido? Qual o tamanho máximo de dados por datagrama UDP (payload)?
2. Este tamanho deve ser fixo ou variável? Como ele se relaciona com o MTU (Maximum Transmission Unit) da rede? (Pesquisar sobre MTU e fragmentação IP).
3. Os buffers de envio (servidor) e recepção (cliente) precisam ter tamanhos relacionados?
Detecção de Erros:
1. Como a integridade dos dados em cada segmento será verificada?
2. É necessário implementar um checksum?
3. Qual algoritmo usar? (Ex: CRC32, soma simples).
Ordenação e Detecção de Perda:
1. Como o cliente saberá a ordem correta dos segmentos? É necessário um número de sequência?
2. Como o cliente detectará que um segmento foi perdido (e não apenas atrasado)?
Controle de Fluxo/Janela (Opcional Avançado):
1. Considerar como evitar que o servidor envie dados mais rápido do que o cliente consegue processar (embora um controle de fluxo completo seja complexo e possa estar fora do escopo inicial).
Mensagens de Controle:
1. Definir claramente os formatos das mensagens de: requisição de arquivo, envio de segmento de dados (incluindo cabeçalhos com número de sequência, checksum, etc.), confirmação de recebimento (se houver), solicitação de retransmissão e mensagens de erro.

Lembre-se: O vídeo deve ser uma demonstração prática, complementada por explicações claras sobre o funcionamento e as decisões de projeto.

O vídeo deve ser anexado como link nos comentários da entrega dentro da atividade do classroom. NÃO deve ser enviado o arquivo do video!

Roteiro para Vídeo de Apresentação: Transferência Confiável de Arquivos sobre UDP

O vídeo de apresentação deve demonstrar o funcionamento da aplicação cliente-servidor desenvolvida, destacando a implementação dos mecanismos de controle diretamente sobre UDP utilizando a API de Sockets.

Itens Obrigatórios a Demonstrar e Explicar:

Ambiente e Setup:
1. Mostrar a execução do Servidor UDP.
2. Mostrar a execução do(s) Cliente(s) UDP.
3. Demonstrar como o cliente especifica/obtém o endereço IP e a porta do servidor.
4. Mostrar que a implementação utiliza a API de Sockets diretamente, sem bibliotecas de abstração UDP.
Protocolo de Aplicação e Requisição:
1. Demonstrar o cliente requisitando arquivos ao servidor usando o protocolo de aplicação proposto (Ex: GET /nome_arquivo).
2. Mostrar o cliente requisitando com sucesso arquivos diferentes (pelo menos dois).
Transferência e Segmentação:
1. Demonstrar a transferência de um arquivo grande (ex: > 10 MB).
2. Explicar e demonstrar como o arquivo é dividido em segmentos (chunks) para transmissão via UDP.
  1. Informar qual o tamanho do buffer/segmento de dados utilizado.
  2. Explicar brevemente a influência do tamanho do segmento e sua relação com o MTU (Maximum Transmission Unit).
Mecanismos de Confiabilidade (Demonstrar e Explicar):
1. Ordenação: Mostrar como os números de sequência são usados para ordenar os segmentos no cliente e detectar perdas.
2. Integridade:
  1. Demonstrar o uso de checksum ou hash (MD5/SHA) para verificar a integridade dos segmentos recebidos. Indicar qual método foi usado.
  2. Mostrar o processo de montagem e conferência do arquivo completo no cliente após o recebimento.
3. Recuperação de Erros/Perdas:
  1. Simular a perda de pacotes: Demonstrar um mecanismo (idealmente no cliente ou simulado) que cause a perda de segmentos durante a transmissão. (Nota: O requisito original mencionava o servidor descartando, o que é incomum. É mais didático simular a perda na rede ou no cliente para testar a recuperação).
  2. Mostrar o cliente detectando a falta de segmentos (por timeout, NACKs, ou análise de sequência).
  3. Demonstrar o cliente solicitando a retransmissão dos segmentos faltantes/corrompidos ao servidor.
  4. Explicar o mecanismo usado para disparo da retransmissão (Ex: timer de timeout, ACKs/NACKs).
Tratamento de Erros do Servidor:
1. Demonstrar o cenário em que o cliente requisita um arquivo inexistente.
2. Mostrar o servidor enviando uma mensagem de erro definida no protocolo.
3. Mostrar o cliente recebendo e apresentando o erro de forma clara (Ex: “Erro: Arquivo não encontrado”).
4. Mencionar/Demonstrar outros erros tratados, se houver.
Cenários de Teste Específicos:
1. Demonstrar o servidor lidando com dois clientes simultâneos (ou em rápida sucessão) requisitando arquivos diferentes.
2. Mostrar o que acontece se o cliente tentar conectar antes do servidor ser iniciado (demonstrar o erro resultante).
3. Mostrar o que acontece se o servidor for interrompido durante uma transferência (demonstrar o comportamento do cliente - ex: timeout, erro).
Pontos Chave para Enfatizar na Explicação:
1. A natureza não confiável do UDP e como os mecanismos implementados (sequência, checksum, retransmissão) buscam mitigar isso.
2. As escolhas de design feitas no protocolo de aplicação.
3. As limitações da solução implementada.

O aluno deve usar Socket UDP e não pode usar bibliotecas que mascarem o trabalho.

Para agilizar a verificação de integridade são utilizadas somas de verificação (checksums) ou resumos criptográficos como o MD5 e SHA.

Prof. Mauro Fonseca - UTFPR - DAINF

Table of Contents