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;
}