package net.sourceforge.rconed;

 import java.io.IOException;

 import java.net.DatagramPacket;

 import java.net.DatagramSocket;

 import java.net.InetAddress;

 import java.net.SocketTimeoutException;

 import net.sourceforge.rconed.exception.BadRcon;

 import net.sourceforge.rconed.exception.UnexpectedDataException;

 /**

  * Rcon is a simple Java library for issuing RCON commands to game servers.

  * <p/>

  * CODRcon is an extension to the library to allow for Call of Duty based

  * servers to be connected against. This has currently only been tested with

  * Call of Duty 2 servers, but the communication protocol should be valid for

  * all current Call of Duty versions.

  * <p/>

  * Example:

  * <p/>

  * response = CODRcon.send("127.0.0.1", 28960, rconPassword, "status");

  * <p/>

  * Copied bulk of original code from Rcon, making modifications where

  * necessary for Call of Duty servers

  * <p/>

  * @author DeadEd, David Hayes

  * @version 1.1

  */

 public class CODRcon {

     private static final int RESPONSE_TIMEOUT = 2000;

     private static final int MULTIPLE_PACKETS_TIMEOUT = 300;

     /**

      * Send the RCON request.  Sends the command to the game server. This version allows for

      * a local portless request to be made.

      * <p/>

      * As the communication travels via an unreliable method (at the choice of the Call of

      * Duty developers), the order in which the message will be returned is not guaranteed,

      * nor is the fact that you will receive a complete message. It is more advisable to call

      * commands that result in shorter returns from the console, than commands that return

      * longer results.

      *

      * @param ipStr     The IP (as a String) of the machine where the RCON command will go.

      * @param port      The port of the machine where the RCON command will go.

      * @param password  The RCON password.

      * @param command   The RCON command (without the rcon prefix).

      * @return The reponse text from the server after trying the RCON command.

      * @throws SocketTimeoutException when there is any problem communicating with the server.

      */

     public static String send(String ipStr, int port, String password, String command)

                     throws SocketTimeoutException, BadRcon, UnexpectedDataException {

             return send (-1, ipStr, port, password, command);

         }

     /**

      * Send the RCON request.  Sends the command to the game server.  A port

      * (localPort) must be opened to send the command through.

      * <p/>

      * As the communication travels via an unreliable method (at the choice of the Call of

      * Duty developers), the order in which the message will be returned is not guaranteed,

      * nor is the fact that you will receive a complete message. It is more advisable to call

      * commands that result in shorter returns from the console, than commands that return

      * longer results.

      *

      * @param localPort The port on the local machine where the RCON request can be made from.

      * @param ipStr     The IP (as a String) of the machine where the RCON command will go.

      * @param port      The port of the machine where the RCON command will go.

      * @param password  The RCON password.

      * @param command   The RCON command (without the rcon prefix).

      * @return The reponse text from the server after trying the RCON command.

      * @throws SocketTimeoutException when there is any problem communicating with the server.

      */

     public static String send(int localPort, String ipStr, int port, String password, String command)

             throws SocketTimeoutException, BadRcon, UnexpectedDataException {

         CODRconPacket[] requested = sendRequest(localPort, ipStr, port, password, command);

         String response = assemblePacket(requested);

         if (response.matches("Invalid password.\n")) {

                 throw new BadRcon();

         }

         return response;

     }

     private static DatagramPacket getDatagramPacket(String request, InetAddress inet, int port) {

         byte first = -1;

         byte last = 0;

         byte[] buffer = request.getBytes();

         byte[] commandBytes = new byte[buffer.length + 5];

         commandBytes[0] = first;

         commandBytes[1] = first;

         commandBytes[2] = first;

         commandBytes[3] = first;

         for (int i = 0; i < buffer.length; i++) {

             commandBytes[i + 4] = buffer[i];

         }

         commandBytes[buffer.length + 4] = last;

         return new DatagramPacket(commandBytes, commandBytes.length, inet, port);

     }

     private static CODRconPacket[] sendRequest(int localPort, String ipStr, int port, String password,

                                             String command) throws SocketTimeoutException {

         DatagramSocket socket = null;

         CODRconPacket[] resp = new CODRconPacket[128];

         try {

             if (localPort == -1) {

                 socket = new DatagramSocket();

             } else {

                 socket = new DatagramSocket(localPort);

             }

             int packetSize = 1400;

             InetAddress address = InetAddress.getByName(ipStr);

             byte[] ip = address.getAddress();

             InetAddress inet = InetAddress.getByAddress(ip);

             String commandStr = "rcon \"" + password + "\" " + command;

             DatagramPacket out = getDatagramPacket(commandStr, inet, port);

             socket.send(out);

             // get the response

             byte[] data = new byte[packetSize];

             DatagramPacket inPacket = new DatagramPacket(data, packetSize);

             socket.setSoTimeout(RESPONSE_TIMEOUT);

             socket.receive(inPacket);

             resp[0] = new CODRconPacket(inPacket);

             try {

             // Wait for a possible multiple packets response

                 socket.setSoTimeout(MULTIPLE_PACKETS_TIMEOUT);

                 int i = 1;

                 while (true) {

                     socket.receive(inPacket);

                     resp[i++] = new CODRconPacket(inPacket);

                 }

             } catch (SocketTimeoutException sex) {

                 // Server didn't send more packets

             }

         } catch (SocketTimeoutException sex) {

             throw sex;

         } catch (IOException ex) {

             ex.printStackTrace();

         } finally {

             if (socket != null) {

                 socket.close();

             }

         }

         return resp;

     }

     private static String assemblePacket(CODRconPacket[] respPacket) throws UnexpectedDataException {

         String resp = "";

         // TODO: inspect the headers to decide the correct order

         for (int i = 0; i < respPacket.length; i++) {

             if (respPacket[i] != null) {

                     // Verify that the packet was valid

                     if (respPacket[i].valid) {

                             resp = resp.concat(respPacket[i].data);

                     } else {

                             throw new UnexpectedDataException();

                     }

             }

         }

         return resp;

     }

 }

 class CODRconPacket {

     /**

      * ASCII representation of the full packet received (header included)

      */

     public String ascii = "";

     /**

      * The data included in the packet, header removed

      */

     public String data = "";

     /**

      * The full packet received (header included) in bytes

      */

     public byte[] bytes = new byte[1400];

     /**

      * Length of the packet

      */

     public int length = 0;

     /**

      * An indicator of the validity of the packet.

      */

     public boolean valid = true;

     /**

      * Represents a rcon response packet from the game server. A response may be split

      * into multiple packets, so an array of RconPackets should be used.

      *

      * @param packet One DatagramPacket returned by the server

      */

     public CODRconPacket(DatagramPacket packet) {

         this.ascii = new String(packet.getData(), 0, packet.getLength());

         this.bytes = ascii.getBytes();

         this.length = packet.getLength();

         try {

                 this.data = parseResponse(packet.getData());

         } catch (UnexpectedDataException e) {

                 this.data = "ERROR";

                 this.valid = false;

         }

     }

     private static String parseResponse(byte[] buf) throws UnexpectedDataException{

         String retVal = "";

         /*

          * The first four bytes of the return are always -1 (0xFF).

          * Then follows the characters "print" plus the ascii new line (0x0A)

          * thus the command below

          */

         if (buf[0] != -1 || buf[1] != -1 || buf[2] != -1 || buf[3] != -1 || buf[4] != 112 || buf[5] != 114 || buf[6] != 105 || buf[7] != 110 || buf[8] != 116 || !(buf[9] == 10 || buf[9] == 13)) {

             throw new UnexpectedDataException();

         }

                 int off = 10;

                 StringBuffer challenge = new StringBuffer(9995);

                 while (buf[off] != 0) {

                     challenge.append((char) (buf[off++] & 255));

                 }

                 retVal = challenge.toString();

         return retVal;

     }

 }