import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Date;

public class Server {

    public static final int MAXIMUM_DATAGRAM_SIZE = 255;        // Maximum size of datagram
    public static final String ECS = "End_of_Communication";        // End Communication String

    public static void main(String[] args) throws IOException {

        byte[] clientData1 = new byte[MAXIMUM_DATAGRAM_SIZE];       // Buffer for first client requesting to connect
        byte[] clientData2 = new byte[MAXIMUM_DATAGRAM_SIZE];       // Buffer for second client requesting to connect
        DatagramPacket clientPacket1 = new DatagramPacket(clientData1, clientData1.length);     // Packet for first client requesting to connect
        DatagramPacket clientPacket2 = new DatagramPacket(clientData2, clientData2.length);     // Packet for second client requesting to connect
        DatagramSocket serverSocket;        // Socket for server to listen on
        int serverPort;     // Port to start serverSocket on
        int clientPort1;
        int clientPort2;
        Runnable clientRun1;        // Runnable object for first client requesting to connect
        Runnable clientRun2;        // Runnable object for second client requesting to connect
        Thread clientThread1;       // Thread for first client requesting to connect
        Thread clientThread2;       // Thread for second client requesting to connect
        String clientAlias1;        // Alias of first client requesting to connect
        String clientAlias2;        // Alias of second client requesting to connect

        // Check for correct # of arguments
        if(args.length != 1)
            throw new IllegalArgumentException("Parameter(s): <Port>");

        // Initialize serverPort and serverSocket
        serverPort = Integer.parseInt(args[0]);
        serverSocket = new DatagramSocket(serverPort);

        // Loop forever and accept requests from clients
        while(true) {

            // Block until a client request is received, and get client alias and
            System.out.println("[" + getTime() + "] | Listening for client requests... |");
            serverSocket.receive(clientPacket1);
            clientAlias1 = new String(clientPacket1.getData());
            clientPort1 = clientPacket1.getPort();
            System.out.println("[" + getTime() + "] | Connected to first client <" + clientAlias1
                    + "> with socket address [" + clientPacket1.getSocketAddress() + "] |");

            // Block until a second client request is received, and get its alias
            serverSocket.receive(clientPacket2);
            clientAlias2 = new String(clientPacket2.getData());
            clientPort2 = clientPacket2.getPort();
            System.out.println("[" + getTime() + "] | Connected to second client <" + clientAlias2
                    + "> with socket address [" + clientPacket2.getSocketAddress() + "] |");

            // Send clientAlias2 to first client
            clientData2 = clientAlias2.getBytes();
            clientPacket1.setData(clientData2);
            serverSocket.send(clientPacket1);
            // Send clientAlias1 to second client
            clientData1 = clientAlias1.getBytes();
            clientPacket2.setData(clientData1);
            serverSocket.send(clientPacket2);

            // Send second client's port to first client
            clientData2 = String.valueOf(clientPort2).getBytes();
            clientPacket1.setData(clientData2);
            serverSocket.send(clientPacket1);

            clientData1 = String.valueOf(clientPort1).getBytes();
            clientPacket2.setData(clientData1);
            serverSocket.send(clientPacket2);

            // Create a new thread for each client request received
            clientRun1 = new ServerThread(serverSocket, clientPacket1, clientPacket2, clientAlias1);
            clientThread1 = new Thread(clientRun1);
            clientRun2 = new ServerThread(serverSocket, clientPacket2, clientPacket1, clientAlias2);
            clientThread2 = new Thread(clientRun2);

            // Start each thread
            clientThread1.start();
            clientThread2.start();

            // Wait for threads to finish before looping again
            try{
                clientThread1.join();
                clientThread2.join();
            } catch(InterruptedException interrupt) {
                System.out.println("InterruptedException: " + interrupt);
            }// End try/catch block

        }// End while loop
    }// End main

    private static String getTime() {
        DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Date date = new Date();
        return dateFormat.format(date);
    }

}// End Server

/*************************************End Server**************************************/
/*************************************************************************************/
/*********************************Start ServerThread**********************************/

class ServerThread implements Runnable {

    protected DatagramSocket socket;
    protected DatagramPacket readPacket;
    protected DatagramPacket writePacket;
    protected InetAddress readAddress;
    protected InetAddress writeAddress;
    protected int readPort;
    protected int writePort;
    protected String userName;

    public ServerThread(DatagramSocket serverSocket, DatagramPacket readPacket, DatagramPacket writePacket, String userName) {
        this.socket = serverSocket;
        this.readPacket = readPacket;
        this.writePacket = writePacket;
        this.readAddress = readPacket.getAddress();
        this.writeAddress = writePacket.getAddress();
        this.readPort = readPacket.getPort();
        this.writePort = writePacket.getPort();
        this.userName = userName;
    }

    public void run() {
        try {
            String message;
            byte[] readBytes = new byte[Server.MAXIMUM_DATAGRAM_SIZE];
            byte[] writeBytes = new byte[Server.MAXIMUM_DATAGRAM_SIZE];

            while(true) {

                // Create byte array to read data from packet into
                readBytes = new byte[Server.MAXIMUM_DATAGRAM_SIZE];
                readPacket = new DatagramPacket(readBytes, readBytes.length, readAddress, readPort);

                // Block until packet is received, and extract its data
                socket.receive(readPacket);
                if(readPacket.getPort() == writePort)
                    continue;
                message = new String(readPacket.getData());
                if(message.equals(Server.ECS))
                    System.out.println("[" + getTime() + "] | <" + userName + "> has disconnected. |");
                readBytes = Arrays.copyOfRange(readPacket.getData(), readPacket.getOffset(), readPacket.getOffset()+readPacket.getLength());

                // Create byte array to write extracted data to
                writeBytes = new byte[Server.MAXIMUM_DATAGRAM_SIZE];
                writeBytes = readBytes;
                writePacket = new DatagramPacket(writeBytes, writeBytes.length, writeAddress, writePort);

                // Send the packet to its destination
                socket.send(writePacket);


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

    }

    private String getTime() {
        DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Date date = new Date();
        return dateFormat.format(date);
    }


}

import java.net.DatagramSocket;
import java.net.DatagramPacket;
import java.net.InetAddress;
import java.net.SocketException;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Client {

    public static final int MAXIMUM_DATAGRAM_SIZE = 255;        // Maximum size of datagram
    public static final String ECS = "End_of_Communication";        // End Communication String

    public static void main(String[] args) throws IOException {

        BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));        // BufferedReader to get user input
        byte[] myData = new byte[MAXIMUM_DATAGRAM_SIZE];
        byte[] clientData = new byte[MAXIMUM_DATAGRAM_SIZE];
        DatagramSocket clientSocket;        // Socket for this client to connect to server
        DatagramPacket myDataPacket;
        DatagramPacket clientDataPacket;
        InetAddress serverIP;       // IP address of server
        int serverPort;     // Port that server is listening on
        int clientPort;     // Port to send messages to
        WriteThread write;      // Thread to write data to the server
        ReadThread read;        // Thread to read data from the server
        String userName;        // Alias to use for this client
        String clientName;      // Alias to use for other client

        // Check for correct # of arguments
        if((args.length < 1) || (args.length > 2))
            throw new IllegalArgumentException("Parameter(s): <Server> [<Port>]");

        // Create DatagramSocket on specified port and IP address
        serverIP = InetAddress.getByName(args[0]);
        serverPort = Integer.parseInt(args[1]);
        clientSocket = new DatagramSocket();

        // Connect the socket the server
        clientSocket.connect(serverIP, serverPort);

        // Collect data to connect
        System.out.println("Please enter username(No Spaces): [Guest]");
        userName = userInput.readLine();
        if(userName.isEmpty())
            userName = "Guest";

        System.out.println("| Username set to <" + userName + ">. Sending to server... |");
        myData = userName.getBytes();

        // Send packet with userName to server
        myDataPacket = new DatagramPacket(myData, myData.length, serverIP, serverPort);
        clientSocket.send(myDataPacket);

        // Create packet to receive data about the other client from the server
        clientDataPacket = new DatagramPacket(clientData, clientData.length);
        clientDataPacket.setLength(MAXIMUM_DATAGRAM_SIZE);
        clientSocket.receive(clientDataPacket);
        clientName = new String(clientDataPacket.getData());
        clientData = new byte[MAXIMUM_DATAGRAM_SIZE];
        clientDataPacket = new DatagramPacket(clientData, clientData.length);
        clientDataPacket.setLength(MAXIMUM_DATAGRAM_SIZE);
        clientSocket.receive(clientDataPacket);
        clientPort = Integer.parseInt((new String(clientDataPacket.getData())).trim());

        // Create and start threads to write to and read data from the server
        write = new WriteThread(clientSocket, serverPort, userName);
        read = new ReadThread(clientSocket, clientName);
        write.start();
        read.start();

        // Wait for threads to finish
        try {
            write.join();
            read.join();
        } catch(InterruptedException interrupt) {
            System.out.println("InterruptedException: " + interrupt);
        }// End try/catch block

    }// End main
}// End Client

/*************************************End Client**************************************/
/*************************************************************************************/
/**********************************Start WriteThread**********************************/

class WriteThread extends Thread implements Runnable {

    protected InetAddress serverIP;     // IP address of the server
    protected int serverPort;       // Port server is listening on
    protected DatagramSocket writeSocket;       // DatagramSocket to SEND data to server
    protected String userName;

    public WriteThread(DatagramSocket clientSocket, int serverPort, String userName) {
        this.writeSocket = clientSocket;
        this.serverPort = serverPort;
        this.serverIP = clientSocket.getInetAddress();
        this.userName = userName;
    }

    public void run() {

        try {
            BufferedReader userInput = new BufferedReader(new InputStreamReader(System.in));
            String writeString;
            byte[] writeBytes;
            DatagramPacket writePacket;

            while(true) {
                writeBytes = new byte[Client.MAXIMUM_DATAGRAM_SIZE];
                writeString = userInput.readLine();
                writeBytes = writeString.getBytes();
                writePacket = new DatagramPacket(writeBytes, writeBytes.length, serverIP, serverPort);
                writeSocket.send(writePacket);
                if((writeString).equals(Client.ECS))
                    break;
                System.out.println("[" + getTime() + "]<" + userName + "> " + new String(writePacket.getData()));
            }// End while

            // End_of_Communiation received, print disconnect message
            System.out.println("[" + getTime() + "] | <" + userName + "> has disconnected. |");
            writeBytes = new byte[Client.MAXIMUM_DATAGRAM_SIZE];
            writeBytes = writeString.getBytes();
            writePacket = new DatagramPacket(writeBytes, writeBytes.length, serverIP, serverPort);
            writeSocket.send(writePacket);

        } catch (IOException ex) {
            System.out.println("IOException: " + ex);
        }// End try/catch block
    }// End run()

    private String getTime() {
        DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Date date = new Date();
        return dateFormat.format(date);
    }

}// End writeThread

/***********************************End WriteThread***********************************/
/*************************************************************************************/
/**********************************Start ReadThread***********************************/

class ReadThread extends Thread implements Runnable {

    protected InetAddress serverIP;     // IP address of the server
    protected int serverPort;       // Port server is listening on
    protected DatagramSocket clientSocket;      // DatagramSocket to READ data to server
    protected String clientName;

    public ReadThread(DatagramSocket clientSocket, String clientName) throws SocketException {
        this.serverIP = clientSocket.getInetAddress();
        this.serverPort = clientSocket.getPort();
        this.clientSocket = clientSocket;
        this.clientName = clientName;
    }


    public void run() {
        try {
            byte[] readData = new byte[Server.MAXIMUM_DATAGRAM_SIZE];       // Buffer for data READ from server
            DatagramPacket readPacket;      // Packet to READ data to server
            String readMessage;     // String of the message READ from server

            // Loop until user requests disconnect
            while(true) {


                // Set up datagram packet to READ from server
                readPacket = new DatagramPacket(readData, readData.length);

                // Wait for a packet to READ from server
                clientSocket.receive(readPacket);

                // Extract and print message READ from server
                readMessage = new String(readPacket.getData(), 0, readPacket.getLength());
                if(readMessage.equals(Client.ECS))
                    break;
                System.out.println("[" + getTime() + "]<" + clientName + "> " + readMessage);
            }// End while

            // End_of_Communication received, exit
            System.out.println("[" + getTime() + "] | <" + clientName + "> has disconnected. |");

        } catch(IOException ex) {
            System.err.println("IOException caught: " + ex);
        }// End try/catch block
        return;
    }// End run

    private String getTime() {
        DateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        Date date = new Date();
        return dateFormat.format(date);
    }

}// End readThread

try {
    // Loop until user requests disconnect
    while(true) {
            //...bla bla...
    }// End while

    // End_of_Communication received, exit
    System.out.println("[" + getTime() + "] | <" + clientName + "> has disconnected. |");

} catch(IOException ex) {
    System.err.println("IOException caught: " + ex);
} finally {
    // here we want to close the socket.
    //Even if an exception is thrown we always want to make sure that the client connection is terminated.
    clientSocket.close();
}