Table of Contents

Trabalho com UDP. - Trabalho 1

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:

  1. Linguagem de Programação: A escolha da linguagem é livre (ex: Python, Java, C/C++, etc.).
  2. 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.
  3. (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:

  1. Inicialização: O servidor deve ser executado antes do cliente.
  2. Porta: Deve operar em uma porta UDP especificada, com número maior que 1024 (portas abaixo de 1024 geralmente exigem privilégios de administrador).
  3. 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).
  4. 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.
  5. 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:

  1. Inicialização: O cliente deve ser executado após o servidor estar ativo.
  2. Conexão: Permitir que o usuário especifique o endereço IP e a porta do servidor UDP ao qual deseja se conectar.
  3. 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).
  4. 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.
  5. 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.).
  6. 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:

  1. 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?
  2. 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).
  3. 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)?
  4. 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).
  5. 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.
Roteiro para Vídeo de Apresentação
  1. No inicio do vídeo deve mostrar todos os itens obrigatórios funcionando no programa.
  2. Na segunda parte do vídeo deve ser explicado cada item como foi implementado no código (Comentando o código).

Itens Obrigatórios a Demonstrar e Explicar:

  1. 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.
  2. 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).
  3. 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).
  4. 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).
  5. 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.
  6. Cenários de Teste Específicos:
    1. Demonstrar o servidor lidando com dois clientes simultâneos 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).
O aluno deve:
  1. colocar no Classroom um arquivo .ZIP com todo o código,
  2. enviar como mensagem (Comentários particulares) o link do vídeo
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!
  • 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.