Added 1.7 to protocol recognizer.

The 1.7 protocol currently only reports server description and playercount.

VC2008/MCServer.vcproj

@@ -2527,6 +2527,14 @@
 					RelativePath="..\source\Protocol\Protocol16x.h"
 					>
 				</File>
+				<File
+					RelativePath="..\source\Protocol\Protocol17x.cpp"
+					>
+				</File>
+				<File
+					RelativePath="..\source\Protocol\Protocol17x.h"
+					>
+				</File>
 				<File
 					RelativePath="..\source\Protocol\ProtocolRecognizer.cpp"
 					>

source/Protocol/Protocol.h

@@ -186,6 +186,27 @@ protected:
 		WriteInt(a_Vector.y);
 		WriteInt(a_Vector.z);
 	}
+	
+	void WriteVarInt(UInt32 a_Value)
+	{
+		// A 32-bit integer can be encoded by at most 5 bytes:
+		unsigned char b[5];
+		int idx = 0;
+		do
+		{
+			b[idx] = (a_Value & 0x7f) | ((a_Value > 0x7f) ? 0x80 : 0x00);
+			a_Value = a_Value >> 7;
+			idx++;
+		} while (a_Value > 0);
+
+		SendData((const char *)b, idx);
+	}
+	
+	void WriteVarUTF8String(const AString & a_String)
+	{
+		WriteVarInt(a_String.size());
+		SendData(a_String.data(), a_String.size());
+	}
 } ;
 
 

source/Protocol/Protocol125.h

@@ -92,9 +92,9 @@ protected:
 		PARSE_INCOMPLETE = -3,
 	} ;
 	
-	cByteBuffer m_ReceivedData;  //< Buffer for the received data
+	cByteBuffer m_ReceivedData;  ///< Buffer for the received data
 	
-	AString m_Username;  //< Stored in ParseHandshake(), compared to Login username
+	AString m_Username;  ///< Stored in ParseHandshake(), compared to Login username
 	
 	virtual void SendData(const char * a_Data, int a_Size) override;
 	

source/Protocol/Protocol17x.cpp

@@ -0,0 +1,216 @@
+
+// Protocol17x.cpp
+
+/*
+Implements the 1.7.x protocol classes:
+	- cProtocol172
+		- release 1.7.2 protocol (#4)
+(others may be added later in the future for the 1.7 release series)
+*/
+
+#include "Globals.h"
+#include "Protocol17x.h"
+#include "../ClientHandle.h"
+#include "../Root.h"
+#include "../Server.h"
+
+
+
+
+
+cProtocol172::cProtocol172(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State) :
+	super(a_Client),
+	m_ServerAddress(a_ServerAddress),
+	m_ServerPort(a_ServerPort),
+	m_State(a_State),
+	m_ReceivedData(32 KiB),
+	m_IsEncrypted(false)
+{
+}
+
+
+
+
+
+void cProtocol172::DataReceived(const char * a_Data, int a_Size)
+{
+	if (m_IsEncrypted)
+	{
+		byte Decrypted[512];
+		while (a_Size > 0)
+		{
+			int NumBytes = (a_Size > sizeof(Decrypted)) ? sizeof(Decrypted) : a_Size;
+			m_Decryptor.ProcessData(Decrypted, (byte *)a_Data, NumBytes);
+			AddReceivedData((const char *)Decrypted, NumBytes);
+			a_Size -= NumBytes;
+			a_Data += NumBytes;
+		}
+	}
+	else
+	{
+		AddReceivedData(a_Data, a_Size);
+	}
+}
+
+
+
+
+void cProtocol172::AddReceivedData(const char * a_Data, int a_Size)
+{
+	if (!m_ReceivedData.Write(a_Data, a_Size))
+	{
+		// Too much data in the incoming queue, report to caller:
+		m_Client->PacketBufferFull();
+		return;
+	}
+	
+	// Handle all complete packets:
+	while (true)
+	{
+		UInt32 PacketLen;
+		if (!m_ReceivedData.ReadVarInt(PacketLen))
+		{
+			// Not enough data
+			return;
+		}
+		if (!m_ReceivedData.CanReadBytes(PacketLen))
+		{
+			// The full packet hasn't been received yet
+			return;
+		}
+		UInt32 PacketType;
+		UInt32 NumBytesRead = m_ReceivedData.GetReadableSpace();
+		if (!m_ReceivedData.ReadVarInt(PacketType))
+		{
+			// Not enough data
+			return;
+		}
+		NumBytesRead -= m_ReceivedData.GetReadableSpace();
+		HandlePacket(PacketType, PacketLen - NumBytesRead);
+	}  // while (true)
+}
+
+
+
+
+void cProtocol172::HandlePacket(UInt32 a_PacketType, UInt32 a_RemainingBytes)
+{
+	switch (m_State)
+	{
+		case 1:
+		{
+			// Status
+			switch (a_PacketType)
+			{
+				case 0x00: HandlePacketStatusRequest(a_RemainingBytes); return;
+			}
+			break;
+		}
+		
+		case 2:
+		{
+			// Login
+			break;
+		}
+		
+		case 3:
+		{
+			// Game
+			break;
+		}
+	}  // switch (m_State)
+	
+	// Unknown packet type, report to the client:
+	m_Client->PacketUnknown(a_PacketType);
+	m_ReceivedData.SkipRead(a_RemainingBytes);
+	m_ReceivedData.CommitRead();
+}
+
+
+
+
+
+void cProtocol172::HandlePacketStatusRequest(UInt32 a_RemainingBytes)
+{
+	// No more bytes in this packet
+	ASSERT(a_RemainingBytes == 0);
+	m_ReceivedData.CommitRead();
+	
+	// Send the response:
+	AString Response = "{\"version\":{\"name\":\"1.7.2\",\"protocol\":4},\"players\":{";
+	AppendPrintf(Response, "\"max\":%u,\"online\":%u,\"sample\":[]},",
+		cRoot::Get()->GetServer()->GetMaxPlayers(),
+		cRoot::Get()->GetServer()->GetNumPlayers()
+	);
+	AppendPrintf(Response, "\"description\":{\"text\":\"%s\"}",
+		cRoot::Get()->GetServer()->GetDescription().c_str()
+	);
+	Response.append("}");
+	
+	cByteBuffer Packet(Response.size() + 10);
+	Packet.WriteVarInt(0x00);  // Response packet
+	Packet.WriteVarUTF8String(Response);
+	WritePacket(Packet);
+}
+
+
+
+
+
+void cProtocol172::WritePacket(cByteBuffer & a_Packet)
+{
+	cCSLock Lock(m_CSPacket);
+	AString Pkt;
+	a_Packet.ReadAll(Pkt);
+	WriteVarInt(Pkt.size());
+	SendData(Pkt.data(), Pkt.size());
+	Flush();
+}
+
+
+
+
+
+void cProtocol172::SendData(const char * a_Data, int a_Size)
+{
+	m_DataToSend.append(a_Data, a_Size);
+}
+
+
+
+
+
+void cProtocol172::Flush(void)
+{
+	ASSERT(m_CSPacket.IsLockedByCurrentThread());  // Did all packets lock the CS properly?
+	
+	if (m_DataToSend.empty())
+	{
+		LOGD("Flushing empty");
+		return;
+	}
+	const char * a_Data = m_DataToSend.data();
+	int a_Size = m_DataToSend.size();
+	if (m_IsEncrypted)
+	{
+		byte Encrypted[8192];  // Larger buffer, we may be sending lots of data (chunks)
+		while (a_Size > 0)
+		{
+			int NumBytes = (a_Size > sizeof(Encrypted)) ? sizeof(Encrypted) : a_Size;
+			m_Encryptor.ProcessData(Encrypted, (byte *)a_Data, NumBytes);
+			m_Client->SendData((const char *)Encrypted, NumBytes);
+			a_Size -= NumBytes;
+			a_Data += NumBytes;
+		}
+	}
+	else
+	{
+		m_Client->SendData(a_Data, a_Size);
+	}
+	m_DataToSend.clear();
+}
+
+
+
+
+

source/Protocol/Protocol17x.h

@@ -0,0 +1,75 @@
+
+// Protocol17x.h
+
+/*
+Declares the 1.7.x protocol classes:
+	- cProtocol172
+		- release 1.7.2 protocol (#4)
+(others may be added later in the future for the 1.7 release series)
+*/
+
+
+
+
+
+#pragma once
+
+#include "Protocol16x.h"
+
+
+
+
+
+class cProtocol172 :
+	public cProtocol162  // TODO
+{
+	typedef cProtocol162 super;  // TODO
+	
+public:
+
+	cProtocol172(cClientHandle * a_Client, const AString & a_ServerAddress, UInt16 a_ServerPort, UInt32 a_State);
+	
+	/// Called when client sends some data:
+	virtual void DataReceived(const char * a_Data, int a_Size) override;
+
+protected:
+
+	AString m_ServerAddress;
+	
+	UInt16 m_ServerPort;
+	
+	/// State of the protocol. 1 = status, 2 = login
+	UInt32 m_State;
+
+	/// Buffer for the received data
+	cByteBuffer m_ReceivedData;
+	
+	bool m_IsEncrypted;
+	CryptoPP::CFB_Mode<CryptoPP::AES>::Decryption m_Decryptor;
+	CryptoPP::CFB_Mode<CryptoPP::AES>::Encryption m_Encryptor;
+	
+	/// (Unencrypted) data to be sent to the client. Written by SendData, cleared by Flush()
+	AString m_DataToSend;
+	
+	
+	/// Adds the received (unencrypted) data to m_ReceivedData, parses complete packets
+	void AddReceivedData(const char * a_Data, int a_Size);
+	
+	/// Reads and handles the packet. The packet length and type have already been read.
+	void HandlePacket(UInt32 a_PacketType, UInt32 a_RemainingBytes);
+	
+	void HandlePacketStatusRequest(UInt32 a_RemainingBytes);
+	
+	/// Writes an entire packet into the output stream. a_Packet is expected to start with the packet type; data length is prepended here.
+	void WritePacket(cByteBuffer & a_Packet);
+
+	/// Adds unencrypted data to the outgoing data buffer
+	virtual void SendData(const char * a_Data, int a_Size) override;
+
+	/// Flushes m_DataToSend through the optional encryption into the outgoing socket data
+	virtual void Flush(void) override;
+} ;
+
+
+
+

source/Protocol/ProtocolRecognizer.cpp

@@ -12,6 +12,7 @@
 #include "Protocol14x.h"
 #include "Protocol15x.h"
 #include "Protocol16x.h"
+#include "Protocol17x.h"
 #include "../ClientHandle.h"
 #include "../Root.h"
 #include "../Server.h"
@@ -667,11 +668,65 @@ bool cProtocolRecognizer::TryRecognizeProtocol(void)
 	}
 	switch (PacketType)
 	{
-		case 0x02: break;  // Handshake, continue recognizing
+		case 0x02: return TryRecognizeLengthlessProtocol();  // Handshake, continue recognizing
-		case 0xfe: HandleServerPing(); return false;
+		case 0xfe:
-		default: return false;
+		{
-	}
+			// This may be either a packet length or the length-less Ping packet
+			Byte NextByte;
+			if (!m_Buffer.ReadByte(NextByte))
+			{
+				// Not enough data for either protocol
+				// This could actually happen with the 1.2 / 1.3 client, but their support is fading out anyway
+				return false;
+			}
+			if (NextByte != 0x01)
+			{
+				// This is definitely NOT a length-less Ping packet, handle as lengthed protocol:
+				break;
+			}
+			if (!m_Buffer.ReadByte(NextByte))
+			{
+				// There is no more data. Although this *could* mean TCP fragmentation, it is highly unlikely
+				// and rather this is a 1.4 client sending a regular Ping packet (without the following Plugin message)
+				SendLengthlessServerPing();
+				return false;
+			}
+			if (NextByte == 0xfa)
+			{
+				// Definitely a length-less Ping followed by a Plugin message
+				SendLengthlessServerPing();
+				return false;
+			}
+			// Definitely a lengthed Initial handshake, handle below:
+			break;
+		}
+	}  // switch (PacketType)
 
+	// This must be a lengthed protocol, try if it has the entire initial handshake packet:
+	m_Buffer.ResetRead();
+	UInt32 PacketLen;
+	UInt32 ReadSoFar = m_Buffer.GetReadableSpace();
+	if (!m_Buffer.ReadVarInt(PacketLen))
+	{
+		// Not enough bytes for the packet length, keep waiting
+		return false;
+	}
+	ReadSoFar -= m_Buffer.GetReadableSpace();
+	if (!m_Buffer.CanReadBytes(PacketLen))
+	{
+		// Not enough bytes for the packet, keep waiting
+		return false;
+	}
+	return TryRecognizeLengthedProtocol(PacketLen - ReadSoFar);
+}
+
+
+
+
+
+bool cProtocolRecognizer::TryRecognizeLengthlessProtocol(void)
+{
+	// The comm started with 0x02, which is a Handshake packet in the length-less protocol family
 	// 1.3.2 starts with 0x02 0x39 <name-length-short>
 	// 1.2.5 starts with 0x02 <name-length-short> and name is expected to less than 0x3900 long :)
 	char ch;
@@ -724,7 +779,56 @@ bool cProtocolRecognizer::TryRecognizeProtocol(void)
 
 
 
-void cProtocolRecognizer::HandleServerPing(void)
+bool cProtocolRecognizer::TryRecognizeLengthedProtocol(UInt32 a_PacketLengthRemaining)
+{
+	UInt32 PacketType;
+	UInt32 NumBytesRead = m_Buffer.GetReadableSpace();
+	if (!m_Buffer.ReadVarInt(PacketType))
+	{
+		return false;
+	}
+	if (PacketType != 0x00)
+	{
+		// Not an initial handshake packet, we don't know how to talk to them
+		LOGINFO("Client \"%s\" uses an unsupported protocol (lengthed, initial packet %u)",
+			m_Client->GetIPString().c_str(), PacketType
+		);
+		m_Client->Kick("Unsupported protocol version");
+		return false;
+	}
+	UInt32 ProtocolVersion;
+	if (!m_Buffer.ReadVarInt(ProtocolVersion))
+	{
+		return false;
+	}
+	NumBytesRead -= m_Buffer.GetReadableSpace();
+	switch (ProtocolVersion)
+	{
+		case PROTO_VERSION_1_7_2:
+		{
+			AString ServerAddress;
+			short ServerPort;
+			UInt32 NextState;
+			m_Buffer.ReadVarUTF8String(ServerAddress);
+			m_Buffer.ReadBEShort(ServerPort);
+			m_Buffer.ReadVarInt(NextState);
+			m_Buffer.CommitRead();
+			m_Protocol = new cProtocol172(m_Client, ServerAddress, ServerPort, NextState);
+			return true;
+		}
+	}
+	LOGINFO("Client \"%s\" uses an unsupported protocol (lengthed, version %u)",
+		m_Client->GetIPString().c_str(), ProtocolVersion
+	);
+	m_Client->Kick("Unsupported protocol version");
+	return false;
+}
+
+
+
+
+
+void cProtocolRecognizer::SendLengthlessServerPing(void)
 {
 	AString Reply;
 	switch (cRoot::Get()->GetPrimaryServerVersion())
@@ -757,10 +861,12 @@ void cProtocolRecognizer::HandleServerPing(void)
 			// http://wiki.vg/wiki/index.php?title=Protocol&oldid=3101#Server_List_Ping_.280xFE.29
 			// _X 2012_10_31: I know that this needn't eat the byte, since it still may be in transit.
 			//    Who cares? We're disconnecting anyway.
-			if (m_Buffer.CanReadBytes(1))
+			m_Buffer.ResetRead();
+			if (m_Buffer.CanReadBytes(2))
 			{
 				byte val;
-				m_Buffer.ReadByte(val);
+				m_Buffer.ReadByte(val);  // Packet type - Serverlist ping
+				m_Buffer.ReadByte(val);  // 0x01 magic value
 				ASSERT(val == 0x01);
 			}
 			

source/Protocol/ProtocolRecognizer.h

@@ -47,6 +47,9 @@ public:
 		
 		PROTO_VERSION_NEXT,
 		PROTO_VERSION_LATEST = PROTO_VERSION_NEXT - 1,  ///< Automatically assigned to the last protocol version, this serves as the default for PrimaryServerVersion
+
+		// These will be kept "under" the next / latest, because the next and latest are only needed for previous protocols
+		PROTO_VERSION_1_7_2 = 4,
 	} ;
 
 	cProtocolRecognizer(cClientHandle * a_Client);
@@ -124,8 +127,23 @@ protected:
 	/// Tries to recognize protocol based on m_Buffer contents; returns true if recognized
 	bool TryRecognizeProtocol(void);
 	
-	/// Called when the recognizer gets a server ping packet; responds with server stats and destroys the client
+	/** Tries to recognize a protocol in the length-less family, based on m_Buffer; returns true if recognized.
-	void HandleServerPing(void);
+	Handles protocols before release 1.7, that didn't include packet lengths, and started with a 0x02 handshake packet
+	Note that length-less server ping is handled directly in TryRecognizeProtocol(), this function is called only
+	when the 0x02 Handshake packet has been received
+	*/
+	bool TryRecognizeLengthlessProtocol(void);
+	
+	/** Tries to recognize a protocol in the leghted family (1.7+), based on m_Buffer; returns true if recognized.
+	The packet length and type have already been read, type is 0
+	The number of bytes remaining in the packet is passed as a_PacketLengthRemaining
+	**/
+	bool TryRecognizeLengthedProtocol(UInt32 a_PacketLengthRemaining);
+	
+	/** Called when the recognizer gets a length-less protocol's server ping packet
+	Responds with server stats and destroys the client.
+	*/
+	void SendLengthlessServerPing(void);
 } ;