path: root/src/communication.cc

#include "communication.hh"
#include "config.hh"
#include "connections.hh"
#include "containers.hh"
#include "crypto.hh"
#include "query.hh"
#include "threads.hh"

#include "stubs.hh"

#include <poll.h>
#include <signal.h>

// NOTE(fusion): We seem to add this value of 48 every time `NetLoad` is called,
// and I assume it is to account for IPv4 (20 bytes) and TCP (20 bytes) headers
// although there are still 8 bytes on the table that I'm not sure where are
// comming from.
#define PACKET_AVERAGE_SIZE_OVERHEAD 48

#define MAX_COMMUNICATION_THREADS 1100
#define THREAD_OWN_STACK_SIZE ((int)KB(64))

static int TERMINALVERSION[3] = {770, 770, 770};
static int TCPSocket;
static ThreadHandle AcceptorThread;
static pid_t AcceptorThreadPID;
static int ActiveConnections;

static Semaphore RSAMutex(1);
static TRSAPrivateKey PrivateKey;

static TQueryManagerConnectionPool QueryManagerConnectionPool(10);
static int LoadHistory[360];
static int LoadHistoryPointer;
static int TotalLoad;
static int TotalSend;
static int TotalRecv;
static uint32 LagEnd;
static uint32 EarliestFreeAccountAdmissionRound;
static store<TWaitinglistEntry, 100> Waitinglist;
static TWaitinglistEntry *WaitinglistHead;

static Semaphore CommunicationThreadMutex(1);
static bool UseOwnStacks;
static uint8 CommunicationThreadStacks[MAX_COMMUNICATION_THREADS][THREAD_OWN_STACK_SIZE];
static pid_t LastUsingCommunicationThread[MAX_COMMUNICATION_THREADS];
static int FreeCommunicationThreadStacks[MAX_COMMUNICATION_THREADS];
static int NumberOfFreeCommunicationThreadStacks;

// Communication Thread Stacks
// =============================================================================
void GetCommunicationThreadStack(int *StackNumber, void **Stack){
	*StackNumber = -1;
	*Stack = NULL;

	if(!UseOwnStacks){
		error("GetCommunicationThreadStack: Bibliothek unterstützt keine eigenen Stacks.\n");
		return;
	}

	CommunicationThreadMutex.down();
	for(int i = 0; i < NumberOfFreeCommunicationThreadStacks; i += 1){
		int FreeStack = FreeCommunicationThreadStacks[i];
		if(LastUsingCommunicationThread[FreeStack] == 0
				|| kill(LastUsingCommunicationThread[FreeStack], 0) == -1){
			// NOTE(fusion): A little swap and pop action.
			NumberOfFreeCommunicationThreadStacks -= 1;
			FreeCommunicationThreadStacks[i] = FreeCommunicationThreadStacks[NumberOfFreeCommunicationThreadStacks];

			*StackNumber = FreeStack;
			*Stack = CommunicationThreadStacks[FreeStack];
			break;
		}
	}
	CommunicationThreadMutex.up();
}

void AttachCommunicationThreadStack(int StackNumber){
	LastUsingCommunicationThread[StackNumber] = getpid();
}

void ReleaseCommunicationThreadStack(int StackNumber){
	CommunicationThreadMutex.down();
	FreeCommunicationThreadStacks[NumberOfFreeCommunicationThreadStacks] = StackNumber;
	NumberOfFreeCommunicationThreadStacks += 1;
	CommunicationThreadMutex.up();
}

void InitCommunicationThreadStacks(void){
	if(UseOwnStacks){
		memset(CommunicationThreadStacks, 0xAA, sizeof(CommunicationThreadStacks));
		for(int i = 0; i < MAX_COMMUNICATION_THREADS; i += 1){
			LastUsingCommunicationThread[i] = 0;
			FreeCommunicationThreadStacks[i] = i;
		}
		NumberOfFreeCommunicationThreadStacks = MAX_COMMUNICATION_THREADS;
	}
}

void ExitCommunicationThreadStacks(void){
	if(UseOwnStacks){
		if(NumberOfFreeCommunicationThreadStacks != MAX_COMMUNICATION_THREADS){
			error("FreeCommunicationThreadStacks: Nicht alle Stacks freigegeben.\n");
		}

		int HighestStackAddress = -1;
		int LowestStackAddress = THREAD_OWN_STACK_SIZE;
		for(int i = 0; i < MAX_COMMUNICATION_THREADS; i += 1){
			for(int Addr = 0; Addr < THREAD_OWN_STACK_SIZE; Addr += 1){
				if(CommunicationThreadStacks[i][Addr] != 0xAA){
					if(Addr < LowestStackAddress){
						LowestStackAddress = Addr;
					}

					if(Addr > HighestStackAddress){
						HighestStackAddress = Addr;
					}
				}
			}
		}

		// NOTE(fusion): It seems we want to track whether the stack size is
		// too small but I'd argue the method is not very robust.
		if((HighestStackAddress - LowestStackAddress) > (THREAD_OWN_STACK_SIZE / 2)){
			error("Maximale Stack-Ausdehnung: %d..%d\n", LowestStackAddress, HighestStackAddress);
		}
	}
}

// Load History
// =============================================================================
void InitLoadHistory(void){
	for(int i = 0; i < NARRAY(LoadHistory); i += 1){
		LoadHistory[i] = 0;
	}
	LoadHistoryPointer = 0;
	TotalLoad = 0;
	TotalSend = 0;
	TotalRecv = 0;
	LagEnd = 0;
	EarliestFreeAccountAdmissionRound = 0;
	InitLog("netload");
}

bool LagDetected(void){
	return RoundNr <= LagEnd;
}

void NetLoad(int Amount, bool Send){
	CommunicationThreadMutex.down();
	if(Send){
		TotalSend += Amount;
	}else{
		TotalRecv += Amount;
	}
	CommunicationThreadMutex.up();
}

void NetLoadSummary(void){
	CommunicationThreadMutex.down();
	Log("netload", "gesendet:  %d Bytes.\n", TotalSend);
	Log("netload", "empfangen: %d Bytes.\n", TotalRecv);
	TotalSend = 0;
	TotalRecv = 0;
	CommunicationThreadMutex.up();
}

void NetLoadCheck(void){
	static int LastRecv;

	int DeltaRecv = TotalRecv - LastRecv;
	LastRecv = TotalRecv;
	if(DeltaRecv < 0){
		return;
	}

	int DeltaRecvPerPlayer = 0;
	int PlayersOnline = GetPlayersOnline();
	if(PlayersOnline > 0){
		DeltaRecvPerPlayer = DeltaRecv / PlayersOnline;
	}

	TotalLoad -= LoadHistory[LoadHistoryPointer];
	TotalLoad += DeltaRecvPerPlayer;
	LoadHistory[LoadHistoryPointer] = DeltaRecvPerPlayer;
	LoadHistoryPointer += 1;
	if(LoadHistoryPointer >= NARRAY(LoadHistory)){
		LoadHistoryPointer = 0;
	}

	// NOTE(fusion): Running this lag check only makes sense if `LoadHistory`
	// is filled up which won't be the case until this function executes at
	// least as many times as there are entries in `LoadHistory`.
	//	Looking at `AdvanceGame`, we see that this function is called every
	// 10 rounds, giving us the value of `EarliestLagCheckRound`.
	constexpr uint32 EarliestLagCheckRound = 10 * NARRAY(LoadHistory);
	if(RoundNr >= EarliestLagCheckRound && PlayersOnline >= 50){
		int AvgDeltaRecvPerPlayer = (TotalLoad / NARRAY(LoadHistory));
		if(DeltaRecvPerPlayer < (AvgDeltaRecvPerPlayer / 2)){
			Log("game", "Lag erkannt!\n");
			LagEnd = RoundNr + 30;

			// NOTE(fusion): This formula looks weird but when we take `MaxPlayers` 
			// and `PremiumPlayerBuffer` to be 950 and 150 (taken from the config
			// file, although their values are now loaded from the database), we
			// get a line with negative values when the number of players online
			// is less than 650, and exactly 60 when it is 950. Since the delay
			// is 60 when `PremiumPlayerBuffer` is zero, I don't think this is a
			// coincidence.
			int FreeAccountAdmissionDelay = 60;
			if(PremiumPlayerBuffer != 0){
				FreeAccountAdmissionDelay = (PlayersOnline - (MaxPlayers - PremiumPlayerBuffer * 2));
				FreeAccountAdmissionDelay = (FreeAccountAdmissionDelay * 30) / PremiumPlayerBuffer;
				if(FreeAccountAdmissionDelay < 0){
					FreeAccountAdmissionDelay = 0;
				}
			}

			uint32 FreeAccountAdmissionRound = RoundNr + (uint32)FreeAccountAdmissionDelay;
			if(EarliestFreeAccountAdmissionRound < FreeAccountAdmissionRound){
				EarliestFreeAccountAdmissionRound = FreeAccountAdmissionRound;
			}

			TConnection *Connection = GetFirstConnection();
			while(Connection != NULL){
				if(Connection->Live()){
					Connection->EmergencyPing();
				}
				Connection = GetNextConnection();
			}
		}
	}
}

// Connection Output
// =============================================================================
bool WriteToSocket(TConnection *Connection, uint8 *Buffer, int Size){
	// IMPORTANT(fusion): The caller must ensure `Buffer` have two extra bytes
	// at the beginning and enough room at the end to properly add padding for
	// XTEA encryption when needed. `Size` refers to the payload size which
	// starts after the first two extra bytes. See note in `SendData`.

	while((Size % 8) != 0){
		Buffer[Size + 2] = rand_r(&Connection->RandomSeed);
		Size += 1;
	}

	for(int i = 0; i < Size; i += 8){
		Connection->SymmetricKey.encrypt(&Buffer[i + 2]);
	}

	TWriteBuffer WriteBuffer(Buffer, 2);
	WriteBuffer.writeWord((uint16)Size);

	int Attempts = 50;
	int BytesToWrite = Size + 2;
	uint8 *WritePtr = Buffer;
	while(BytesToWrite > 0){
		int ret = (int)write(Connection->GetSocket(), WritePtr, BytesToWrite);
		if(ret > 0){
			BytesToWrite -= ret;
			WritePtr += ret;
		}else if(ret == 0){
			// TODO(fusion): Can this even happen without an error?
			error("WriteToSocket: Fehler %d beim Senden an Socket %d.\n",
					errno, Connection->GetSocket());
			return false;
		}else if(errno != EINTR){
			if(errno != EAGAIN || Attempts <= 0){
				if(errno == ECONNRESET || errno == EPIPE || errno == EAGAIN){
					Log("game", "Verbindung an Socket %d zusammengebrochen.\n",
							Connection->GetSocket());
				}else{
					error("WriteToSocket: Fehler %d beim Senden an Socket %d.\n",
							errno, Connection->GetSocket());
				}
				return false;
			}

			DelayThread(0, 100000);
			Attempts -= 1;
		}
	}

	NetLoad(PACKET_AVERAGE_SIZE_OVERHEAD + Size + 2, true);
	return true;
}

bool SendLoginMessage(TConnection *Connection, int Type, const char *Message, int WaitingTime){
	// TODO(fusion): Why do we return true on invalid parameters?

	// TODO(fusion):
	//	LOGIN_MESSAGE_ERROR = 20
	//	LOGIN_MESSAGE_? = 21
	//	LOGIN_MESSAGE_WAITING_LIST = 22

	if(Type != 20 && Type != 21 && Type != 22){
		error("SendLoginMessage: Ungültiger Meldungstyp %d.\n", Type);
		return true;
	}

	if(Message == NULL){
		error("SendLoginMessage: Message ist NULL.\n");
		return true;
	}

	if(Type == 22 && (WaitingTime < 0 || WaitingTime > UINT8_MAX)){
		error("SendLoginMessage: Ungültige Wartezeit %d.\n", WaitingTime);
		return true;
	}

	if(strlen(Message) > 290){
		error("SendLoginMessage: Botschaft zu lang (%s).\n", Message);
		return true;
	}

	// IMPORTANT(fusion): This is doing the same thing as `SendData` but in a
	// smaller scale and building the packet directly instead of using the
	// connection's write buffer.
	uint8 Data[302]; // 2 + 300
	TWriteBuffer WriteBuffer(Data + 2, sizeof(Data) - 2);
	WriteBuffer.writeWord(0);
	WriteBuffer.writeByte((uint8)Type);
	WriteBuffer.writeString(Message);
	if(Type == 22){
		WriteBuffer.writeByte(WaitingTime);
	}

	int Size = WriteBuffer.Position;
	WriteBuffer.Position = 0;
	WriteBuffer.writeWord((uint16)(Size - 2));
	return WriteToSocket(Connection, Data, Size);
}

bool SendData(TConnection *Connection){
	if(Connection == NULL){
		error("SendData: Verbindung ist NULL.\n");
		return false;
	}

	//
	// IMPORTANT(fusion): The final packet will have this layout:
	//	PLAIN:
	//		0 .. 2 => Encrypted Size
	//	ENCRYPTED:
	//		2 .. 4 => Data Size
	//		4 ..   => Data + Padding
	//
	//	The ENCRYPTED size needs to be a multiple of 8 for XTEA encryption and
	// `WriteToSocket` will add padding to ensure it is. This also requires us
	// to ensure the passed buffer has enough room for it, so we don't write out
	// of bounds.
	//

	int DataSize = Connection->NextToCommit - Connection->NextToSend;
	int EncryptedSize = (DataSize + 2);
	int EncryptedSizeAligned = (EncryptedSize + 7) & ~7;
	int PacketSize = EncryptedSizeAligned + 2;

	// TODO(fusion): The maximum size of a packet depends on the size of
	// `Connection->OutData` and I don't think we'd have a problem with
	// having a constant size buffer on the stack here although with such
	// a small stack size (64KB with our own stacks) it could become a
	// problem.
	uint8 *Buffer = (uint8*)alloca(PacketSize);
	TWriteBuffer WriteBuffer(Buffer, PacketSize);
	WriteBuffer.writeWord(0);
	WriteBuffer.writeWord((uint16)DataSize);

	// NOTE(fusion): `Connection->OutData` is a ring buffer so we need to check
	// if the data we're currently sending is wrapping around, in which case we'd
	// need to copy two separate regions instead of a single contiguous one.
	constexpr int OutDataSize = sizeof(Connection->OutData);
	int DataStart = Connection->NextToSend % OutDataSize;
	int DataEnd = DataStart + DataSize;
	if(DataEnd < OutDataSize){
		WriteBuffer.writeBytes(&Connection->OutData[DataStart], DataSize);
	}else{
		WriteBuffer.writeBytes(&Connection->OutData[DataStart], OutDataSize - DataStart);
		WriteBuffer.writeBytes(&Connection->OutData[0],         DataEnd - OutDataSize);
	}

	bool Result = WriteToSocket(Connection, Buffer, DataSize);
	if(Result){
		Connection->NextToSend += DataSize;
	}
	return Result;
}

bool SendData(TConnection *Connection, const uint8 *Data, int Size){
	if(Connection == NULL){
		error("SendData: Connection ist NULL.\n");
		return false;
	}

	// TODO(fusion): Why are we returning true for invalid parameters?
	if(Data == NULL){
		error("SendData: Data ist NULL.\n");
		return true;
	}

	// TODO(fusion): Why do we leave extra two bytes unassigned at the beginning?
	// `SendData` should already take care of building the packet properly so this
	// is something else or a bug, if this function is even used.
	memcpy(&Connection->OutData[2], Data, Size);
	Connection->NextToSend = 0;
	Connection->NextToCommit = Size + 2;
	return SendData(Connection);
}

// Waiting List
// =============================================================================
bool GetWaitinglistEntry(const char *Name, int *NextTry, bool *FreeAccount, bool *Newbie){
	bool Result = false;
	CommunicationThreadMutex.down();
	TWaitinglistEntry *Entry = WaitinglistHead;
	while(Entry != NULL){
		if(stricmp(Entry->Name, Name) == 0){
			break;
		}
		Entry = Entry->Next;
	}

	if(Entry != NULL){
		*NextTry = Entry->NextTry;
		*FreeAccount = Entry->FreeAccount;
		*Newbie = Entry->Newbie;
		Result = true;
	}
	CommunicationThreadMutex.up();
	return Result;
}

void InsertWaitinglistEntry(const char *Name, uint32 NextTry, bool FreeAccount, bool Newbie){
	bool NewEntry = false;
	CommunicationThreadMutex.down();
	TWaitinglistEntry *Prev = NULL;
	TWaitinglistEntry *Entry = WaitinglistHead;
	while(Entry != NULL){
		if(stricmp(Entry->Name, Name) == 0){
			break;
		}
		Prev = Entry;
		Entry = Entry->Next;
	}

	if(Entry == NULL){
		Entry = Waitinglist.getFreeItem();
		Entry->Next = NULL;
		strcpy(Entry->Name, Name);
		Entry->NextTry = NextTry;
		Entry->FreeAccount = FreeAccount;
		Entry->Newbie = Newbie;
		Entry->Sleeping = false;
		if(Prev != NULL){
			Prev->Next = Entry;
		}else{
			WaitinglistHead = Entry;
		}
		NewEntry = true;
	}else{
		Entry->NextTry = NextTry;
		Entry->FreeAccount = FreeAccount;
		Entry->Newbie = Newbie;
	}
	CommunicationThreadMutex.up();

	if(NewEntry){
		Log("queue", "Füge %s in die Warteschlange ein.\n", Name);
	}
}

void DeleteWaitinglistEntry(const char *Name){
	CommunicationThreadMutex.down();
	TWaitinglistEntry *Prev = NULL;
	TWaitinglistEntry *Entry = WaitinglistHead;
	while(Entry != NULL){
		if(stricmp(Entry->Name, Name) == 0){
			break;
		}
		Prev = Entry;
		Entry = Entry->Next;
	}

	if(Entry != NULL){
		if(Prev != NULL){
			Prev->Next = Entry->Next;
		}else{
			WaitinglistHead = Entry->Next;
		}
		Waitinglist.putFreeItem(Entry);
	}
	CommunicationThreadMutex.up();
}

int GetWaitinglistPosition(const char *Name, bool FreeAccount, bool Newbie){
	int FreeNewbies = 0;
	int FreeVeterans = 0;
	int PremiumNewbies = 0;
	int PremiumVeterans = 0;

	CommunicationThreadMutex.down();
	// NOTE(fusion): Remove inactive entries from the start of the list.
	while(WaitinglistHead != NULL && RoundNr > (WaitinglistHead->NextTry + 60)){
		TWaitinglistEntry *Next = WaitinglistHead->Next;
		Waitinglist.putFreeItem(WaitinglistHead);
		WaitinglistHead = Next;
	}

	// NOTE(fusion): Count players up until we find the player's entry or reach
	// the end of the queue.
	TWaitinglistEntry *Entry = WaitinglistHead;
	while(Entry != NULL){
		if(stricmp(Entry->Name, Name) == 0){
			break;
		}

		if(!Entry->Sleeping){
			if(RoundNr > (Entry->NextTry + 5)){
				Entry->Sleeping = true;
			}else if(Entry->FreeAccount){
				if(Entry->Newbie){
					FreeNewbies += 1;
				}else{
					FreeVeterans += 1;
				}
			}else{
				if(Entry->Newbie){
					PremiumNewbies += 1;
				}else{
					PremiumVeterans += 1;
				}
			}
		}

		Entry = Entry->Next;
	}
	CommunicationThreadMutex.up();

	int Result = 1;
	if(FreeAccount){
		Result += PremiumVeterans + FreeVeterans;
		if(Newbie){
			Result += PremiumNewbies + FreeNewbies;
		}else if(GetNewbiesOnline() < (MaxNewbies - PremiumNewbieBuffer)){
			Result += FreeNewbies;
		}
	}else{
		Result += PremiumVeterans;
		if(Newbie || GetNewbiesOnline() < MaxNewbies){
			Result += PremiumNewbies;
		}
	}
	return Result;
}

int CheckWaitingTime(const char *Name, TConnection *Connection, bool FreeAccount, bool Newbie){
	int WaitingTime = 0;
	const char *Reason = NULL;
	int Position = GetWaitinglistPosition(Name, FreeAccount, Newbie);
	int PlayersOnline = GetPlayersOnline();
	int NewbiesOnline = GetNewbiesOnline();
	if((PlayersOnline + Position) > GetOrderBufferSpace()){
		print(3, "Order-Puffer ist fast voll.\n");
		Reason = "The server is overloaded.";
		WaitingTime = (Position / 2) + 10;
	}else if(FreeAccount){
		if(EarliestFreeAccountAdmissionRound > RoundNr){
			print(3, "Keine FreeAccounts zugelassen nach MassKick.\n");
			Reason = "The server is overloaded.\n"
					"Only players with premium accounts\n"
					"are admitted at the moment.";
			WaitingTime = (int)(EarliestFreeAccountAdmissionRound - RoundNr);
			WaitingTime += Position / 2;
		}else if((PlayersOnline + Position) > (MaxPlayers - PremiumPlayerBuffer)){
			print(3, "Kein Platz mehr für FreeAccounts.\n");
			Reason = "Too many players online.\n"
					"Only players with premium accounts\n"
					"are admitted at the moment.";
			WaitingTime = Position / 2 + 5;
		}else if(Newbie && (NewbiesOnline + Position) > (MaxNewbies - PremiumNewbieBuffer)){
			print(3, "Kein Platz mehr für Newbies mit FreeAccount.\n");
			Reason = "There are too many players online\n"
					"on the beginners' island, Rookgaard.\n"
					"Only players with premium accounts\n"
					"are admitted at the moment.";
			WaitingTime = Position / 2 + 5;
		}
	}else{
		if((PlayersOnline + Position) > MaxPlayers){
			print(3, "Zu viele Spieler online.\n");
			Reason = "There are too many players online.";
			WaitingTime = Position / 2 + 3;
		}else if(Newbie && (NewbiesOnline + Position) > MaxNewbies){
			print(3, "Kein Platz mehr für Newbies.\n");
			Reason = "There are too many players online\n"
					"on the beginners' island, Rookgaard.";
			WaitingTime = Position / 2 + 3;
		}
	}

	if(WaitingTime > 240){
		WaitingTime = 240;
	}

	if(WaitingTime > 0){
		char Message[250];
		snprintf(Message, sizeof(Message),
				"%s\n\nYou are at place %d on the waiting list.",
				Reason, Position);
		SendLoginMessage(Connection, 22, Message, WaitingTime);
	}

	return WaitingTime;
}

// Connection Input
// =============================================================================
int ReadFromSocket(TConnection *Connection, uint8 *Buffer, int Size){
	int Attempts = 50;
	int BytesToRead = Size;
	uint8 *ReadPtr = Buffer;
	while(BytesToRead > 0){
		int BytesRead = (int)read(Connection->GetSocket(), ReadPtr, BytesToRead);
		if(BytesRead > 0){
			BytesToRead -= BytesRead;
			ReadPtr += BytesRead;
		}else if(BytesRead == 0){
			// NOTE(fusion): TCP FIN with no more data to read.
			break;
		}else if(errno != EINTR){
			if(errno != EAGAIN || BytesToRead == Size || Attempts <= 0){
				return -1;
			}
			DelayThread(0, 100000);
			Attempts -= 1;
		}
	}
	return Size - BytesToRead;
}

bool DrainSocket(TConnection *Connection, int Size){
	uint8 DiscardBuffer[KB(2)];
	while(Size > 0){
		int BytesToRead = std::min<int>(Size, sizeof(DiscardBuffer));
		int BytesRead = ReadFromSocket(Connection, DiscardBuffer, BytesToRead);
		if(BytesRead <= 0){
			return false;
		}
		Size -= BytesRead;
		NetLoad(PACKET_AVERAGE_SIZE_OVERHEAD + BytesRead, false);
	}
	return true;
}

bool CallGameThread(TConnection *Connection){
	if(GameRunning()){
		Connection->WaitingForACK = true;
		if(kill(GetGameThreadPID(), SIGUSR1) != 0){
			error("CallGameThread: Can't send SIGUSR1 to pid %d\n", GetGameThreadPID());
			SendLoginMessage(Connection, 20,
					"The server is not online.\nPlease try again later.", -1);
			return false;
		}
	}
	return true;
}

bool CheckConnection(TConnection *Connection){
	// TODO(fusion): Check if there is no input data?
	struct pollfd pollfd = {};
	pollfd.fd = Connection->GetSocket();
	pollfd.events = POLLIN;
	return poll(&pollfd, 1, 0) >= 0
		&& (pollfd.revents & POLLIN) == 0;
}

// NOTE(fusion): `PlayerName` is an input and output parameter. It will contain
// the correct player name with upper and lower case letters if the player is
// actually logged in.
TPlayerData *PerformRegistration(TConnection *Connection, char *PlayerName,
		uint32 AccountID, const char *PlayerPassword, bool GamemasterClient){
	TQueryManagerPoolConnection QueryManagerConnection(&QueryManagerConnectionPool);
	if(!QueryManagerConnection){
		error("PerformRegistration: Kann Verbindung zum Query-Manager nicht herstellen.\n");
		SendLoginMessage(Connection, 20, "Internal error, closing connection.", -1);
		return NULL;
	}

	if(!CheckConnection(Connection)){
		return NULL;
	}

	// TODO(fusion): What a disaster. The size of these arrays are are hardcoded
	// and should be declared constants somewhere.
	uint32 CharacterID;
	int Sex;
	char Guild[31];				// MAX_NAME_LENGTH ?
	char Rank[31];				// MAX_NAME_LENGTH ?
	char Title[31];				// MAX_NAME_LENGTH ?
	int NumberOfBuddies;
	uint32 BuddyIDs[100];		// MAX_BUDDIES ?
	char BuddyNames[100][30];	// MAX_BUDDIES, MAX_NAME_LENGTH ?
	uint8 Rights[12];			// MAX_RIGHT_BYTES ?
	bool PremiumAccountActivated;
	int Status = QueryManagerConnection->loginGame(AccountID, PlayerName,
			PlayerPassword, Connection->GetIPAddress(), PrivateWorld, false,
			GamemasterClient, &CharacterID, &Sex, Guild, Rank, Title,
			&NumberOfBuddies, BuddyIDs, BuddyNames, Rights,
			&PremiumAccountActivated);
	switch(Status){
		case 0:{
			// NOTE(fusion): Login successful.
			break;
		}

		case 1:{
			print(3, "Spieler existiert nicht.\n");
			SendLoginMessage(Connection, 20,
					"Character doesn't exist.\n"
					"Create a new character on the Tibia website\n"
					"at \"www.tibia.com\".", -1);
			return NULL;
		}

		case 2:{
			print(3, "Spieler wurde gelöscht.\n");
			SendLoginMessage(Connection, 20,
					"Character doesn't exist.\n"
					"Create a new character on the Tibia website.", -1);
			return NULL;
		}

		case 3:{
			print(3, "Spieler lebt nicht auf dieser Welt.\n");
			SendLoginMessage(Connection, 20,
					"Character doesn't live on this world.\n"
					"Please login on the right world.", -1);
			return NULL;
		}

		case 4:{
			print(3, "Spieler ist nicht eingeladen.\n");
			SendLoginMessage(Connection, 20,
					"This world is private and you have not been invited to play on it.", -1);
			return NULL;
		}

		case 6:{
			Log("game", "Falsches Paßwort für Spieler %s; Login von %s.\n",
					PlayerName, Connection->GetIPAddress());
			SendLoginMessage(Connection, 20,
					"Accountnumber or password is not correct.", -1);
			return NULL;
		}

		case 7:{
			Log("game", "Spieler %s blockiert; Login von %s.\n",
					PlayerName, Connection->GetIPAddress());
			SendLoginMessage(Connection, 20,
					"Account disabled for five minutes. Please wait.", -1);
			return NULL;
		}

		case 8:{
			Log("game", "Account von Spieler %s wurde gelöscht.\n", PlayerName);
			SendLoginMessage(Connection, 20,
					"Accountnumber or password is not correct.", -1);
			return NULL;
		}

		case 9:{
			Log("game", "IP-Adresse %s für Spieler %s blockiert.\n",
					Connection->GetIPAddress(), PlayerName);
			SendLoginMessage(Connection, 20,
					"IP address blocked for 30 minutes. Please wait.", -1);
			return NULL;
		}

		case 10:{
			print(3, "Account ist verbannt.\n");
			SendLoginMessage(Connection, 20,
					"Your account is banished.", -1);
			return NULL;
		}

		case 11:{
			print(3, "Character muss umbenannt werden.\n");
			SendLoginMessage(Connection, 20,
					"Your character is banished because of his/her name.", -1);
			return NULL;
		}

		case 12:{
			print(3, "IP-Adresse ist gesperrt.\n");
			SendLoginMessage(Connection, 20,
					"Your IP address is banished.", -1);
			return NULL;
		}

		case 13:{
			print(3, "Schon andere Charaktere desselben Accounts eingeloggt.\n");
			SendLoginMessage(Connection, 20,
					"You may only login with one character\n"
					"of your account at the same time.", -1);
			return NULL;
		}

		case 14:{
			print(3, "Login mit Gamemaster-Client auf Nicht-Gamemaster-Account.\n");
			SendLoginMessage(Connection, 20,
					"You may only login with a Gamemaster account.", -1);
			return NULL;
		}

		case 15:{
			print(3, "Falsche Accountnummer %u für %s.\n", AccountID, PlayerName);
			SendLoginMessage(Connection, 20,
					"Login failed due to corrupt data.", -1);
			return NULL;
		}

		case -1:{
			SendLoginMessage(Connection, 20, "Internal error, closing connection.", -1);
			return NULL;
		}

		default:{
			error("PerformRegistration: Unbekannter Rückgabewert vom QueryManager.\n");
			SendLoginMessage(Connection, 20, "Internal error, closing connection.", -1);
			return NULL;
		}
	}

	// TODO(fusion): Again?
	if(!CheckConnection(Connection)){
		QueryManagerConnection->decrementIsOnline(CharacterID);
		return NULL;
	}

	if(AccountID == 0){
		error("PerformRegistration: Spieler %s wurde noch keinem Account zugewiesen.\n", PlayerName);
		SendLoginMessage(Connection, 20,
				"Character is not assigned to an account.\n"
				"Perform this on the Tibia website\n"
				"at \"www.tibia.com\".", -1);
		return NULL;
	}

	// TODO(fusion): We were also adding a null terminator to `PlayerName` here
	// for whatever reason. I assume it is a compiler artifact because we already
	// use it in the condition block just above so...
	// PlayerName[29] = 0;

	if(PremiumAccountActivated){
		SendLoginMessage(Connection, 21,
				"Your Premium Account is now activated.\n"
				"Have a lot of fun in Tibia.", -1);
	}

	Log("game", "Spieler %s loggt ein an Socket %d von %s.\n",
			PlayerName, Connection->GetSocket(), Connection->GetIPAddress());

	TPlayerData *PlayerData = AssignPlayerPoolSlot(CharacterID, true);
	if(PlayerData == NULL){
		error("PerformRegistration: Kann keinen Slot für Spielerdaten zuweisen.\n");
		QueryManagerConnection->decrementIsOnline(CharacterID);
		SendLoginMessage(Connection, 20,
				"There are too many players online.\n"
				"Please try again later.", -1);
		return NULL;
	}

	bool Locked = PlayerData->Locked == getpid();

	// TODO(fusion): How come this isn't a race condition? Perhaps these are
	// constant and can only change when loaded from the database?
	if(Locked || PlayerData->AccountID == 0){
		PlayerData->AccountID = AccountID;
		PlayerData->Sex = Sex;
		strcpy(PlayerData->Name, PlayerName);
		memcpy(PlayerData->Rights, Rights, sizeof(Rights));
		strcpy(PlayerData->Guild, Guild);
		strcpy(PlayerData->Rank, Rank);
		strcpy(PlayerData->Title, Title);
	}

	if(Locked && PlayerData->Buddies == 0){
		PlayerData->Buddies = NumberOfBuddies;
		for(int i = 0; i < NumberOfBuddies; i += 1){
			PlayerData->Buddy[i] = BuddyIDs[i];
			strcpy(PlayerData->BuddyName[i], BuddyNames[i]);
		}
	}

	return PlayerData;
}

bool HandleLogin(TConnection *Connection){
	// TODO(fusion): Exception handling keeps getting crazier.

	TReadBuffer InputBuffer(Connection->InData, Connection->InDataSize);
	try{
		uint8 Command = InputBuffer.readByte();
		if(Command != 10){
			print(3, "Ungültiges Init-Kommando %d.\n", Command);
			return false;
		}
	}catch(const char *str){
		error("HandleLogin: Fehler beim Auslesen des Kommandos (%s).\n", str);
		return false;
	}

	int TerminalType;
	int TerminalVersion;
	bool GamemasterClient;
	uint32 AccountID;
	char PlayerName[30];
	char PlayerPassword[30];
	try{
		uint8 AssymmetricData[128];
		InputBuffer.readBytes(AssymmetricData, 128);
		RSAMutex.down();
		try{
			PrivateKey.decrypt(AssymmetricData);
		}catch(const char *str){
			RSAMutex.up();
			error("HandleLogin: Fehler beim Entschlüsseln (%s).\n", str);
			SendLoginMessage(Connection, 20,
					"Login failed due to corrupt data.",-1);
			return false;
		}
		RSAMutex.up();

		TReadBuffer ReadBuffer(AssymmetricData, 128);
		ReadBuffer.readByte();
		Connection->SymmetricKey.init(&ReadBuffer);
		TerminalType = (int)ReadBuffer.readWord();
		TerminalVersion = (int)ReadBuffer.readWord();
		GamemasterClient = ReadBuffer.readByte() != 0;
		AccountID = ReadBuffer.readQuad();
		ReadBuffer.readString(PlayerName, sizeof(PlayerName));
		ReadBuffer.readString(PlayerPassword, sizeof(PlayerPassword));
	}catch(const char *str){
		print(3, "Fehler beim Auslesen der Login-Daten (%s).\n", str);
		SendLoginMessage(Connection, 20,
				"Login failed due to corrupt data.",-1);
		return false;
	}

	if(PlayerName[0] == 0){
		SendLoginMessage(Connection, 20,
				"You must enter a character name.", -1);
		return false;
	}

	if(TerminalType < 0 || TerminalType >= NARRAY(TERMINALVERSION)
			|| TERMINALVERSION[TerminalType] != TerminalVersion){
		SendLoginMessage(Connection, 20,
				"Your terminal version is too old.\n"
				"Please get a new version at\n"
				"http://www.tibia.com.", -1);
		return false;
	}

	if(!GameRunning()){
		SendLoginMessage(Connection, 20,
				"The server is not online.\n"
				"Please try again later.", -1);
		return false;
	}

	if(GameStarting()){
		SendLoginMessage(Connection, 20,
				"The game is just starting.\n"
				"Please try again later.", -1);
		return false;
	}

	if(GameEnding()){
		SendLoginMessage(Connection, 20,
				"The game is just going down.\n"
				"Please try again later.", -1);
		return false;
	}

	// NOTE(fusion): Check waitlist entry.
	bool WasInWaitingList = false;
	while(true){
		uint32 NextTry;
		bool FreeAccount;
		bool Newbie;
		if(!GetWaitinglistEntry(PlayerName, &NextTry, &FreeAccount, &Newbie)){
			print(3, "Spieler nicht auf Warteliste.\n");
			break;
		}

		print(3, "Spieler auf Warteliste.\n");
		if(NextTry > RoundNr){
			int WaitingTime = (int)(NextTry - RoundNr);
			Log("queue", "%s meldet sich %d Sekunden zu früh an.\n",
					PlayerName, WaitingTime);
			SendLoginMessage(Connection, 22,
					"It's not your turn yet.", WaitingTime);
			return false;
		}

		if(RoundNr > (NextTry + 60)){
			Log("queue", "%s meldet sich %d Sekunden zu spät an.\n",
					PlayerName, (RoundNr - NextTry));
			DeleteWaitinglistEntry(PlayerName);
			continue;
		}

		int WaitingTime = CheckWaitingTime(PlayerName, Connection, FreeAccount, Newbie);
		if(WaitingTime > 0){
			NextTry = RoundNr + (uint32)WaitingTime;
			InsertWaitinglistEntry(PlayerName, NextTry, FreeAccount, Newbie);
			return false;
		}

		DeleteWaitinglistEntry(PlayerName);
		WasInWaitingList = true;
		break;
	}

	TPlayerData *Slot = PerformRegistration(Connection,
			PlayerName, AccountID, PlayerPassword, GamemasterClient);
	if(Slot == NULL){
		return false;
	}

	bool SlotLocked = Slot->Locked == getpid();

	// NOTE(fusion): These checks would have been already made if the player was
	// in the waiting list so they'd be redundant.
	if(!WasInWaitingList){
		bool BlockLogin = false;
		bool FreeAccount = !CheckBit(Slot->Rights, PREMIUM_ACCOUNT);
		bool Newbie = Slot->Profession == PROFESSION_NONE
				&& !CheckBit(Slot->Rights, NO_LOGOUT_BLOCK);

		bool PremiumOnly = (MaxPlayers == PremiumPlayerBuffer)
				|| (Newbie && MaxNewbies == PremiumNewbieBuffer);
		if(!BlockLogin && FreeAccount && PremiumOnly){
			SendLoginMessage(Connection, 20,
					"Only players with premium accounts\n"
					"are allowed to enter this world.", -1);
			BlockLogin = true;
		}

		if(!BlockLogin && !IsPlayerOnline(PlayerName)){
			int WaitingTime = CheckWaitingTime(PlayerName, Connection, FreeAccount, Newbie);
			if(WaitingTime > 0){
				uint32 NextTry = RoundNr + (uint32)WaitingTime;
				InsertWaitinglistEntry(PlayerName, NextTry, FreeAccount, Newbie);
				BlockLogin = true;
			}
		}

		if(BlockLogin){
			// TODO(fusion): This is probably an inlined function.
			TQueryManagerPoolConnection QueryManagerConnection(&QueryManagerConnectionPool);
			if(QueryManagerConnection){
				QueryManagerConnection->decrementIsOnline(Slot->CharacterID);
			}else{
				error("HandleLogin: Kann Verbindung zum Query-Manager nicht herstellen.\n");
			}

			if(SlotLocked){
				ReleasePlayerPoolSlot(Slot);
			}else{
				DecreasePlayerPoolSlotSticky(Slot);
			}
			return false;
		}
	}

	if(SlotLocked){
		IncreasePlayerPoolSlotSticky(Slot);
		ReleasePlayerPoolSlot(Slot);
	}

	// NOTE(fusion): Rewrite packet in a different format, ready for the main
	// thread to interpret.
	TWriteBuffer WriteBuffer(Connection->InData + 2,
					sizeof(Connection->InData) - 2);
	try{
		WriteBuffer.writeByte(11);
		WriteBuffer.writeWord((int)TerminalType);
		WriteBuffer.writeWord((int)TerminalVersion);
		WriteBuffer.writeQuad(Slot->CharacterID);
	}catch(const char *str){
		error("HandleLogin: Fehler beim Zusammenbauen des Login-Pakets (%s).\n", str);
		SendLoginMessage(Connection, 20,
				"Internal error, closing connection.",-1);
		return false;
	}

	Connection->NextToSend = 0;
	Connection->NextToCommit = 0;
	Connection->InDataSize = WriteBuffer.Position;
	Connection->NextToWrite = 0;

	Connection->Login();
	return CallGameThread(Connection);
}

bool ReceiveCommand(TConnection *Connection){
	// IMPORTANT(fusion): The return value of this function is used to determine
	// whether the connection should be closed. Returning true will maintain it
	// open. It is a weird convention but w/e.

	if(Connection == NULL){
		error("ReceiveCommand: Connection ist NULL.\n");
		return false;
	}

	while(!Connection->WaitingForACK){
		uint8 Help[2];
		int BytesRead = ReadFromSocket(Connection, Help, 2);
		if(BytesRead == 0){
			return false;
		}else if(BytesRead < 0){
			return true;
		}else if(BytesRead == 1){
			NetLoad(PACKET_AVERAGE_SIZE_OVERHEAD + 1, false);
			print(3, "Zu wenig Daten an Socket %d.\n", BytesRead);
			return true;
		}

		// TODO(fusion): Size is encoded as a little endian uint16. We should
		// have a few helper functions to assist with buffer reading.
		int Size = ((uint16)Help[0] | ((uint16)Help[1] << 8));

		if(Size == 0 || Size > (int)sizeof(Connection->InData)){
			// TODO(fusion): We should definitely close the connection here.
			// Nevertheless, the original handling of this edge case was just
			// terrible, reading from the socket recklessly until at least `Size`
			// bytes were discarded. I replaced it with a small helper function
			// function `DrainSocket`.
			print(3, "Paket an Socket %d zu groß oder leer, wird verworfen (%d Bytes)\n",
					Connection->GetSocket(), Size);
			return DrainSocket(Connection, Size);
		}

		BytesRead = ReadFromSocket(Connection, &Connection->InData[0], Size);
		if(BytesRead < 0){
			// NOTE(fusion): It doesn't make sense to call `SendLoginMessage` before
			// the key exchange has completed, which happens after login.
			if(Connection->State != CONNECTION_CONNECTED){
				SendLoginMessage(Connection, 20,
					"Internal error, closing connection.", -1);
			}
			return false;
		}

		NetLoad(PACKET_AVERAGE_SIZE_OVERHEAD + BytesRead, false);

		// NOTE(fusion): It doesn't make sense to continue if we didn't receive
		// the whole packet. We're already using TCP which doesn't drop data so
		// it would only compound into more errors.
		if(BytesRead != Size){
			return false;
		}

		if(Connection->State == CONNECTION_CONNECTED){
			alarm(0); // TODO(fusion): Not sure why.
			Connection->InDataSize = Size;
			if(!HandleLogin(Connection)){
				return false;
			}
		}else{
			// NOTE(fusion): It doesn't make sense to continue if the client didn't
			// correctly size its packet.
			if((Size % 8) != 0){
				print(3, "Ungültige Paketlänge %d für verschlüsseltes Paket von %s.\n",
						Size, Connection->GetName());
				return false;
			}

			for(int i = 0; i < Size; i += 8){
				Connection->SymmetricKey.decrypt(&Connection->InData[i]);
			}

			// NOTE(fusion): It doesn't make sense to continue if the client didn't
			// correctly size its payload.
			int PlainSize = ((uint16)Connection->InData[0])
					| ((uint16)Connection->InData[1] << 8);
			if(PlainSize == 0 || (PlainSize + 2) > Size){
				print(3, "Nutzdaten (%d Bytes) von Paket an Socket %d zu groß oder leer.\n",
						PlainSize, Connection->GetSocket());
				return false;
			}

			Connection->InDataSize = PlainSize;
			if(!CallGameThread(Connection)){
				return false;
			}
		}
	}

	Connection->SigIOPending = true;
	return true;
}