User Datagram Protocol
UDP: Protocolo utiliza para distinguir para qual usuário
ou aplicativo deve ser encaminhado um datagrama
destinado a uma máquina que esteja executando mais de
um processo.
Problemas:
◦
Os processos são criados e destruídos dinâmicamente e os
transmissores raramente sabem o bastante para identificar um
processo de uma outra máquina.
◦
Deseja-se substituir os processos (no caso de uma reinicialização
da máquina) sem informar a todos os transmissores.
◦
Como permitir que um transmissor entre em contato com um
servidor (de arquivos, por exemplo) sem saber qual processo na
máquina de destino.
User Datagram Protocol
• Solução:
• Portas de protocolo: São pontos de destino abstratos,
identificadas por um número inteiro positivo.
• Elas utilizam “buffer”, que modo que os dados que
chegarem antes que um processo esteja pronto para
aceitá-los não sejam perdidos. Os buffers são
implementados como filas.
• Para comunicar-se com uma porta exterior, um
transmissor precisa conhecer tanto o endereço IP como
o número da porta na máquina de destino.
• Além da porta de destino, uma mensagem UDP deve ter
também a informação sobre a porta de origem para
onde as respostas deverão ser endereçadas.
User Datagram Protocol
• Assim como o IP, o UDP oferece um serviço não-confiável
de transmissão sem conexão.
• Desta forma, fica a cargo do aplicativo resolver o problema
da confiabilidade, como perda de mensagens, duplicação,
retardo, transmissão defeituosa e perda de conectividade.
• Formato de mensagens UDP:
•
O campo Comprimento contém o número de octetos na mensagem UDP
User Datagram Protocol
• Pseudocabeçalho UDP
• Tem como finalidade verificar se a mensagem UDP
atingiu o seu destino correto.
• O destino correto consiste em uma máquina específica e
uma porta específica dentro desta máquina.
• O pseudocabeçalho não é transmitido junto como a
mensagem UDP, mas a soma de verificação o abrange.
• No destino final, o pseudocabeçalho é remontado a
User Datagram Protocol
• Encapsulamento UDP
User Datagram Protocol
• Contradição entre organização em camadas e o cálculo da
soma de verificação UDP.
• Multiplexação: O software UDP aceita mensagens de
muitos programas aplicativos e os passa ao IP.
• Demultiplexação: E aceita mensagens UDP recebida de IP
e as passa ao programa aplicativo apropriado.
• Quando o UDP recebe uma mensagem, verifica se o
número da porta de destino confere com uma das portas
atualmente em uso. Se não houver correspondência, a
mensagem é descartada e uma mensagem de erro é
enviada. Caso contrário, o UDP enfileira a mensagem na
porta apropriada. Se não houver espaço na fila, a
mensagem é descartada e uma mensagem de erro é gerada.
User Datagram Protocol
• Como deverão ser atribuídos números de porta de
protocolo?
1. Uso de autoridade central que atribua números de
portas de acordo com a necessidade e publique a lista.
2. Atribuição dinâmica: Sempre que um programa
necessita de uma porta, o software de rede atribui uma.
Para saber que número de porta a máquina de destino
está usando, o emissor enviar uma mensagem
perguntando: “que porta o serviço X está usando?”
• O TCP/IP usa uma abordagem híbrida. Algumas portas são
atribuídas a priori e outras são deixadas a cargo dos
aplicativos.
UDP: Programação Socket
Interação Cliente/Servidor usando UDP:
Servidor
Cliente
Cria Socket:
socketServidor =
DatagramSocket()
Lê mensagem de
socketServidor
Escreve resposta
em socketServidor
Cria Socket:
socketCliente =
DatagramSocket()
Cria endereço: host, porta de
origem. Envia mensagem
em socketCliente
Lê resposta de socketCliente
Programação Socket com UDP:
Exemplo usando JAVA
import java.io.*; import java.net.*;
public class ClienteUDP {
public static void main(String argv[]) throws Exception {
int porta;
byte[] dadosEnviados;
byte[] dadosRecebidos = new byte[1024]; String frase = null;
String fraseModificada = null;
//argv[1] contem o numero da porta do servidor no host porta = (new Integer(argv[1])).intValue();
//Cria Stream de entrada. Redireciona entrada do teclado BufferedReader entradaDoUsuario =
new BufferedReader(new InputStreamReader(System.in));
//Cria socket cliente
DatagramSocket socketCliente = new DatagramSocket();
//Localiza o host especificado na linha de comando.
//A classe InetAddress contem as informacoes de end. IP do host InetAddress enderecoIP = InetAddress.getByName(argv[0]);
Programação Socket com UDP:
Exemplo usando JAVA
//Le frase do teclado
frase = entradaDoUsuario.readLine(); dadosEnviados = frase.getBytes();
//Cria datagrama de envio. Em JAVA, a classe DatagramPacket e' usada para //conter as informacoes do datagrama. Estas informacoes sao: array de //bytes (dadosEnviados), comprimento do array, endereco IP do destino, //porta UDP do destino.
DatagramPacket datagramaEnviado =
new DatagramPacket(dadosEnviados, dadosEnviados.length, enderecoIP, porta); //Envia datagrama para servidor
socketCliente.send(datagramaEnviado); //Espera resposta do servidor
//Cria datagrama para receber mensagem do servidor DatagramPacket datagramaRecebido =
new DatagramPacket(dadosRecebidos, dadosRecebidos.length); //Recebe datagrama do servidor
socketCliente.receive(datagramaRecebido); //Imprime resultado
fraseModificada = new String(datagramaRecebido.getData());
System.out.println(enderecoIP.getHostName() + " : " + fraseModificada); //Fecha socket
Programação Socket com UDP:
Exemplo usando JAVA
import java.io.*;
import java.net.*;
import java.util.*;
public class ServidorUDP {
public static void main(String argv[]) throws Exception
{
byte[] dadosEnviados;
byte[] dadosRecebidos = new byte[1024];
String frase, fraseModificada;
InetAddress enderecoIPDoCliente;
int portaDoCliente;
//Cria socket UDP na porta 6789
DatagramSocket socketServidor = new DatagramSocket(6789);
while(true)
{
//Cria datagrama para receber mensagem do cliente
DatagramPacket datagramaRecebido =
new DatagramPacket(dadosRecebidos, dadosRecebidos.length);
//Recebe datagrama
Programação Socket com UDP:
Exemplo usando JAVA
//O servidor deve obter o endereco IP do cliente e a porta UDP de origem. //Isto se deve ao fato do protocolo UDP ser sem conexao, ou seja, cada pacote //enviado deve conter o endereco do destino.
enderecoIPDoCliente = datagramaRecebido.getAddress(); portaDoCliente = datagramaRecebido.getPort();
//Executa o processamento. Neste caso, converte a frase para letras maiusculas frase = new String(datagramaRecebido.getData());
System.out.println(enderecoIPDoCliente.getHostName() + " : " + frase); fraseModificada = frase.toUpperCase();
//Prepara resposta para ser enviada ao cliente //Converte String para byte[]
dadosEnviados = fraseModificada.getBytes();
//Cria datagrama para enviar a resposta ao cliente
DatagramPacket datagrama = new DatagramPacket(dadosEnviados, dadosEnviados.length,
enderecoIPDoCliente, portaDoCliente);
//Envia resposta para o cliente socketServidor.send(datagrama);
//Para assegurar que nenhuma parte da mensagem anterior continue presente, // preencha o buffer de dados recebidos com 0.
Arrays.fill(dadosRecebidos, (byte)0); }
} }
