Código de ejemplo (Java)

El siguiente ejemplo muestra cómo usar el protocolo UDP para una comunicación cliente/servidor:

Servidor:

public static void main(String[] args) {

  try {
   System.out.println("server creado........");
   // 1. crear el servidor..
   DatagramSocket socket = new DatagramSocket(45000);

   // 2. recibir mensaje desde el cliente...

   // 2.1 crear el paquete donde se recibe el mensaje.
   byte[] buffer = new byte[1024];
   DatagramPacket paqueteCliente = new DatagramPacket(buffer, 1024);
   // 2.2 recibir el paquete. operacion bloqueante.
   System.out.println("socket esperando....");
   socket.receive(paqueteCliente);

   // 2.3 leer el paquete como string...
   String msj = new String(paqueteCliente.getData());

   System.out.println("desde "
     + paqueteCliente.getAddress().getHostAddress()
     + " desde el puerto " + paqueteCliente.getPort()
     + " se recibio:" + msj);

   // 3. enviar respuesta..
   String resp = new Date().toString();// la hora como respuesta.
   // 3.1 crear datagrama de envio.
   // direccion destino..
   InetAddress addr = paqueteCliente.getAddress();// la misma del
            // cliente.
   int port = paqueteCliente.getPort();
   // el datagrama contiene la información del destino.
   DatagramPacket paqueteEnvio = new DatagramPacket(resp.getBytes(),
     resp.length(), addr, port);
   System.out.println("enviando:"+new String(paqueteEnvio.getData()));
   // 3.2 enviar paquete...
   socket.send(paqueteEnvio);
   
   //4. cerrar el socket...
   socket.close();

  } catch (IOException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

 }

Cliente:

public static void main(String[] args) {
  try {

   // 1. crear el socket por donde se enviara la peticion y se recibira
   // la respuesta..
   DatagramSocket socket = new DatagramSocket(32000);

   // 2. crear datagrama para enviar la info. el datagrama contiene
   // toda la info necesaria para que llegue el msj
   String msj = "Hola Server....."; // msj a enviar.
   String ip = "127.0.0.1";
   int port = 45000;
   // 2.1 crear datagrama
   DatagramPacket paqueteEnvio = new DatagramPacket(msj.getBytes(),
     msj.length(), InetAddress.getByName(ip), port);
   // 2.2 enviar paquete.
   socket.send(paqueteEnvio);

   // 3. recibir respuesta...

   // 3.1 crear datagrama de recepcion.
   byte[] resp = new byte[1024];
   DatagramPacket paqueteRecibido = new DatagramPacket(resp,
     resp.length);

   // 3.2 recibir paquete.
   socket.receive(paqueteRecibido);

   // 4. mostrar info...
   System.out.println("Server respondio desde "
     + paqueteRecibido.getAddress().getHostAddress()
     + " por el puerto " + paqueteRecibido.getPort()
     + " se recibio:" + new String(paqueteRecibido.getData()));

   // 5. cerrar
   socket.close();

  } catch (IOException e) {
   e.printStackTrace();
  }

Código de ejemplo (Python 3.x)[editar]

El siguiente ejemplo muestra cómo usar el protocolo UDP para una comunicación cliente/servidor:

Servidor:

import socketserver
print("Servidor iniciado...")
class MyUDPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        data = self.request[0].strip()
        socket = self.request[1]
        print("{0} Ha escrito:".format(self.client_address[0]))
        print(data)
        socket.sendto(data.upper(), self.client_address)
if __name__ == "__main__":
    HOST, PORT = "localhost", 9999
    server = socketserver.UDPServer((HOST, PORT), MyUDPHandler)
    server.serve_forever()



Cliente (Cambia "localhost" por la dirección IP del servidor.):

import socket
import sys
print("Cliente iniciado...")
HOST, PORT = "localhost", 9999
data = " ".join(sys.argv[1:])

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

sock.sendto(bytes(data + "\n","utf8"), (HOST, PORT))
received = sock.recv(1024)

print("Enviado: {0}".format(data))
print("Recibido: {0}".format(received))



Código de ejemplo (C)

El siguiente ejemplo muestra cómo usar el protocolo UDP para una comunicación cliente/servidor:

Servidor:

#include <winsock.h>
#include <stdio.h>
#pragma comment(lib,"ws2_32.lib")

const int BufLen = 1024;

int main()
{
   WSADATA wsaData;
   SOCKET RecvSocket;
   sockaddr_in RecvAddr;
   int Puerto = 2345;
   char RecvBuf[BufLen];
   sockaddr_in SenderAddr;
   int SenderAddrSize = sizeof(SenderAddr);
   WSAStartup(MAKEWORD(2,2), &wsaData);
   RecvSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
   RecvAddr.sin_family = AF_INET;
   RecvAddr.sin_port = htons(Puerto);
   RecvAddr.sin_addr.s_addr = INADDR_ANY;
   bind(RecvSocket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr));
   recvfrom(RecvSocket,RecvBuf, BufLen,0,(SOCKADDR *)&SenderAddr,&SenderAddrSize);
 printf("%s\n",RecvBuf);
   closesocket(RecvSocket);
   WSACleanup();
}



Cliente (Cambia "127.0.0.1" por la dirección IP del servidor):

#include <winsock.h>
#pragma comment(lib,"ws2_32.lib")

int main()
{
 WSADATA wsaData;
   SOCKET SendSocket;
   sockaddr_in RecvAddr;
 int Puerto = 2345;
   char ip[] = "127.0.0.1";
   char SendBuf[] = "Hola!!!!";
   WSAStartup(MAKEWORD(2,2), &wsaData);
   SendSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
   RecvAddr.sin_family = AF_INET;
   RecvAddr.sin_port = htons(Puerto);
   RecvAddr.sin_addr.s_addr = inet_addr(ip);
   sendto(SendSocket,SendBuf,strlen(SendBuf)+1,0,(SOCKADDR *) &RecvAddr,sizeof(RecvAddr));
   WSACleanup();