Java/Network Protocol/DatagramPacket

Create DatagramPacket from byte array

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
class Main {
  public static void main(String args[]) throws Exception {
    InetAddress ia = InetAddress.getByName(args[0]);
    int port = Integer.parseInt(args[1]);
    DatagramSocket ds = new DatagramSocket();
    while (true) {
      String s = "asdf";
      byte buffer[] = s.getBytes();
      DatagramPacket dp = new DatagramPacket(buffer, buffer.length, ia, port);
      ds.send(dp);
    }
  }
}

Get address and port from DatagramPacket

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
class Main {
  private final static int BUFSIZE = 20;
  public static void main(String args[]) throws Exception {
    int port = Integer.parseInt(args[0]);
    DatagramSocket ds = new DatagramSocket(port);
    byte buffer[] = new byte[BUFSIZE];
    while (true) {
      DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
      ds.receive(dp);
      InetAddress ia = dp.getAddress();
      System.out.println(ia);
      System.out.println(dp.getPort());
    }
  }
}

Get data from DatagramPacket

import java.net.DatagramPacket;
import java.net.DatagramSocket;
class DatagramReceiver {
  private final static int BUFSIZE = 20;
  public static void main(String args[]) throws Exception {
    int port = Integer.parseInt(args[0]);
    DatagramSocket ds = new DatagramSocket(port);
    byte buffer[] = new byte[BUFSIZE];
    while (true) {
      DatagramPacket dp = new DatagramPacket(buffer, buffer.length);
      ds.receive(dp);
      System.out.println(new String(dp.getData()));
    }
  }
}

Sends the specified text or file as a datagram to the specified port of the specified host

 
/*
 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd Edition.
 * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied.
 * You may study, use, and modify it for any non-commercial purpose,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.ru/javaexamples3.
 */
//package je3.net;
import java.io.File;
import java.io.FileInputStream;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
 * This class sends the specified text or file as a datagram to the specified
 * port of the specified host.
 */
public class UDPSend {
  public static final String usage = "Usage: java UDPSend <hostname> <port> <msg>...\n"
      + "   or: java UDPSend <hostname> <port> -f <file>";
  public static void main(String args[]) {
    try {
      // Check the number of arguments
      if (args.length < 3)
        throw new IllegalArgumentException("Wrong number of args");
      // Parse the arguments
      String host = args[0];
      int port = Integer.parseInt(args[1]);
      // Figure out the message to send.
      // If the third argument is -f, then send the contents of the file
      // specified as the fourth argument. Otherwise, concatenate the
      // third and all remaining arguments and send that.
      byte[] message;
      if (args[2].equals("-f")) {
        File f = new File(args[3]);
        int len = (int) f.length(); // figure out how big the file is
        message = new byte[len]; // create a buffer big enough
        FileInputStream in = new FileInputStream(f);
        int bytes_read = 0, n;
        do { // loop until we"ve read it all
          n = in.read(message, bytes_read, len - bytes_read);
          bytes_read += n;
        } while ((bytes_read < len) && (n != -1));
      } else { // Otherwise, just combine all the remaining arguments.
        String msg = args[2];
        for (int i = 3; i < args.length; i++)
          msg += " " + args[i];
        // Convert the message to bytes using UTF-8 encoding
        message = msg.getBytes("UTF-8");
      }
      // Get the internet address of the specified host
      InetAddress address = InetAddress.getByName(host);
      // Initialize a datagram packet with data and address
      DatagramPacket packet = new DatagramPacket(message, message.length, address, port);
      // Create a datagram socket, send the packet through it, close it.
      DatagramSocket dsocket = new DatagramSocket();
      dsocket.send(packet);
      dsocket.close();
    } catch (Exception e) {
      System.err.println(e);
      System.err.println(usage);
    }
  }
}

Waits to receive datagrams sent the specified port

import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * This program waits to receive datagrams sent the specified port. When it
 * receives one, it displays the sending host and prints the contents of the
 * datagram as a string. Then it loops and waits again.
 */
public class UDPReceive {
  public static final String usage = "Usage: java UDPReceive <port>";
  public static void main(String args[]) {
    try {
      if (args.length != 1)
        throw new IllegalArgumentException("Wrong number of args");
      // Get the port from the command line
      int port = Integer.parseInt(args[0]);
      // Create a socket to listen on the port.
      DatagramSocket dsocket = new DatagramSocket(port);
      // Create a buffer to read datagrams into. If anyone sends us a
      // packet containing more than will fit into this buffer, the
      // excess will simply be discarded!
      byte[] buffer = new byte[2048];
      // Create a packet to receive data into the buffer
      DatagramPacket packet = new DatagramPacket(buffer, buffer.length);
      // Now loop forever, waiting to receive packets and printing them.
      for (;;) {
        // Wait to receive a datagram
        dsocket.receive(packet);
        // Decode the bytes of the packet to characters, using the
        // UTF-8 encoding, and then display those characters.
        String msg = new String(buffer, 0, packet.getLength(), "UTF-8");
        System.out.println(packet.getAddress().getHostName() + ": " + msg);
        // Reset the length of the packet before reusing it.
        // Prior to Java 1.1, we"d just create a new packet each time.
        packet.setLength(buffer.length);
      }
    } catch (Exception e) {
      System.err.println(e);
      System.err.println(usage);
    }
  }
}