path: root/Tools/RCONClient/RCONClient.cpp

// RCONClient.cpp

// Implements the main app entrypoint

#include "Globals.h"
#include "OSSupport/Socket.h"
#include "ByteBuffer.h"





// If set to true, verbose messages are output to stderr. Use the "-v" or "--verbose" param to turn on
bool g_IsVerbose = false;





/** This class can read and write RCON packets to / from a connected socket */
class cRCONPacketizer
{
public:
	enum
	{
		ptCommand = 2,
		ptLogin = 3,
	} ;

	cRCONPacketizer(cSocket & a_Socket);

	/** Sends the packet to the socket and waits until the response is received.
	Returns true if response successfully received, false if the client disconnected or protocol error.
	Dumps the reply payload to stdout. */
	bool SendPacket(int a_PacketType, const AString & a_PacketPayload);

protected:
	/** The socket to use for reading incoming data and writing outgoing data: */
	cSocket & m_Socket;

	/** The RequestID of the packet that is being sent. Incremented when the reply is received */
	int m_RequestID;

	/** Receives the full response and dumps its payload to stdout.
	Returns true if successful, false if the client disconnected or protocol error. */
	bool ReceiveResponse(void);

	/** Parses the received response packet and dumps its payload to stdout.
	Returns true if successful, false on protocol error
	Assumes that the packet length has already been read from the packet
	If the packet is successfully parsed, increments m_RequestID */
	bool ParsePacket(cByteBuffer & a_Buffer, int a_PacketLength);
} ;





cRCONPacketizer::cRCONPacketizer(cSocket & a_Socket) :
	m_Socket(a_Socket),
	m_RequestID(0)
{
}





bool cRCONPacketizer::SendPacket(int a_PacketType, const AString & a_PacketPayload)
{
	// Send the packet:
	cByteBuffer bb(a_PacketPayload.size() + 30);
	bb.WriteLEInt(m_RequestID);
	bb.WriteLEInt(a_PacketType);
	bb.WriteBuf(a_PacketPayload.data(), a_PacketPayload.size());
	bb.WriteBEShort(0);  // Padding
	AString Packet;
	bb.ReadAll(Packet);
	size_t Length = Packet.size();
	if (!m_Socket.Send((const char *)&Length, 4))
	{
		fprintf(stderr, "Network error while sending packet: %d (%s). Aborting.\n",
			cSocket::GetLastError(), cSocket::GetLastErrorString().c_str()
		);
		return false;
	}
	if (!m_Socket.Send(Packet.data(), Packet.size()))
	{
		fprintf(stderr, "Network error while sending packet: %d (%s). Aborting.\n",
			cSocket::GetLastError(), cSocket::GetLastErrorString().c_str()
		);
		return false;
	}

	return ReceiveResponse();
}





bool cRCONPacketizer::ReceiveResponse(void)
{
	// Receive the response:
	cByteBuffer Buffer(64 KiB);
	while (true)
	{
		char buf[1024];
		int NumReceived = m_Socket.Receive(buf, sizeof(buf), 0);
		if (NumReceived == 0)
		{
			fprintf(stderr, "The remote end closed the connection. Aborting.\n");
			return false;
		}
		if (NumReceived < 0)
		{
			fprintf(stderr, "Network error while receiving response: %d, %d (%s). Aborting.\n",
				NumReceived, cSocket::GetLastError(), cSocket::GetLastErrorString().c_str()
			);
			return false;
		}
		Buffer.Write(buf, NumReceived);
		Buffer.ResetRead();

		// Check if the buffer contains the full packet:
		if (!Buffer.CanReadBytes(14))
		{
			// 14 is the minimum packet size for RCON
			continue;
		}
		int PacketSize;
		VERIFY(Buffer.ReadLEInt(PacketSize));
		if (!Buffer.CanReadBytes(PacketSize))
		{
			// The packet is not complete yet
			continue;
		}

		// Parse the packet
		return ParsePacket(Buffer, PacketSize);
	}
}





bool cRCONPacketizer::ParsePacket(cByteBuffer & a_Buffer, int a_PacketLength)
{
	// Check that the request ID is equal
	bool IsValid = true;
	int RequestID = 0;
	VERIFY(a_Buffer.ReadLEInt(RequestID));
	if (RequestID != m_RequestID)
	{
		if ((RequestID == -1) && (m_RequestID == 0))
		{
			fprintf(stderr, "Login failed. Aborting.\n");
			IsValid = false;
			// Continue, so that the payload is printed before the program aborts.
		}
		else
		{
			fprintf(stderr, "The server returned an invalid request ID, got %d, exp. %d. Aborting.\n", RequestID, m_RequestID);
			return false;
		}
	}

	// Check the packet type:
	int PacketType = 0;
	VERIFY(a_Buffer.ReadLEInt(PacketType));
	if (PacketType != ptCommand)
	{
		fprintf(stderr, "The server returned an unknown packet type: %d. Aborting.\n", PacketType);
		IsValid = false;
		// Continue, so that the payload is printed before the program aborts.
	}

	AString Payload;
	VERIFY(a_Buffer.ReadString(Payload, a_PacketLength - 10));

	// Dump the payload to stdout, in a binary mode
	fwrite(Payload.data(), Payload.size(), 1, stdout);

	if (IsValid)
	{
		m_RequestID++;
		return true;
	}
	return false;
}





////////////////////////////////////////////////////////////////////////////////
// main:

int RealMain(int argc, char * argv[])
{
	cLogger::InitiateMultithreading();

	// Parse the cmdline params for server IP, port, password and the commands to send:
	AString ServerAddress, Password;
	int ServerPort = -1;
	AStringVector Commands;
	for (int i = 1; i < argc; i++)
	{
		if (((NoCaseCompare(argv[i], "-s") == 0) || (NoCaseCompare(argv[i], "--server") == 0)) && (i < argc - 1))
		{
			ServerAddress = argv[i + 1];
			i++;
			continue;
		}
		if (((NoCaseCompare(argv[i], "-p") == 0) || (NoCaseCompare(argv[i], "--port") == 0)) && (i < argc - 1))
		{
			ServerPort = atoi(argv[i + 1]);
			i++;
			continue;
		}
		if (((NoCaseCompare(argv[i], "-w") == 0) || (NoCaseCompare(argv[i], "--password") == 0)) && (i < argc - 1))
		{
			Password = argv[i + 1];
			i++;
			continue;
		}
		if (((NoCaseCompare(argv[i], "-c") == 0) || (NoCaseCompare(argv[i], "--cmd") == 0) || (NoCaseCompare(argv[i], "--command") == 0)) && (i < argc - 1))
		{
			Commands.push_back(argv[i + 1]);
			i++;
			continue;
		}
		if (((NoCaseCompare(argv[i], "-f") == 0) || (NoCaseCompare(argv[i], "--file") == 0)) && (i < argc - 1))
		{
			i++;
			cFile f(argv[i], cFile::fmRead);
			if (!f.IsOpen())
			{
				fprintf(stderr, "Cannot read commands from file \"%s\", aborting.", argv[i]);
				return 2;
			}
			AString cmd;
			f.ReadRestOfFile(cmd);
			Commands.push_back(cmd);
			continue;
		}
		if ((NoCaseCompare(argv[i], "-v") == 0) || (NoCaseCompare(argv[i], "--verbose") == 0))
		{
			fprintf(stderr, "Verbose output enabled\n");
			g_IsVerbose = true;
			continue;
		}
		fprintf(stderr, "Unknown parameter: \"%s\". Aborting.", argv[i]);
		return 1;
	}  // for i - argv[]

	if (ServerAddress.empty() || (ServerPort < 0))
	{
		fprintf(stderr, "Server address or port not set. Use the --server and --port parameters to set them. Aborting.");
		return 1;
	}

	// Connect:
	if (cSocket::WSAStartup() != 0)
	{
		fprintf(stderr, "Cannot initialize network stack. Aborting\n");
		return 6;
	}
	if (g_IsVerbose)
	{
		fprintf(stderr, "Connecting to \"%s:%d\"...\n", ServerAddress.c_str(), ServerPort);
	}
	cSocket s = cSocket::CreateSocket(cSocket::IPv4);
	if (!s.ConnectIPv4(ServerAddress, (unsigned short)ServerPort))
	{
		fprintf(stderr, "Cannot connect to \"%s:%d\": %s\n", ServerAddress.c_str(), ServerPort, cSocket::GetLastErrorString().c_str());
		return 3;
	}
	cRCONPacketizer Packetizer(s);

	// Authenticate using the provided password:
	if (!Password.empty())
	{
		if (g_IsVerbose)
		{
			fprintf(stderr, "Sending the login packet...\n");
		}
		if (!Packetizer.SendPacket(cRCONPacketizer::ptLogin, Password))
		{
			// Error message has already been printed, bail out
			return 4;
		}
	}
	else
	{
		if (g_IsVerbose)
		{
			fprintf(stderr, "No password provided, not sending a login packet.\n");
		}
	}

	// Send each command:
	for (AStringVector::const_iterator itr = Commands.begin(), end = Commands.end(); itr != end; ++itr)
	{
		if (g_IsVerbose)
		{
			fprintf(stderr, "Sending command \"%s\"...\n", itr->c_str());
		}
		if (!Packetizer.SendPacket(cRCONPacketizer::ptCommand, *itr))
		{
			return 5;
		}
	}

	return 0;
}





int main(int argc, char * argv[])
{
	// This redirection function is only so that debugging the program is easier in MSVC - when RealMain exits, it's still possible to place a breakpoint
	int res = RealMain(argc, argv);
	return res;
}