eqemu-server/ucs/database.cpp

/*	EQEMu: Everquest Server Emulator
	Copyright (C) 2001-2008 EQEMu Development Team (http://eqemulator.net)

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; version 2 of the License.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY except by those people which sell it, which
	are required to give you total support for your newly bought product;
	without even the implied warranty of MERCHANTABILITY or FITNESS FOR
	A PARTICULAR PURPOSE. See the GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the Free Software
	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

*/


#include "../common/global_define.h"
#include "../common/eqemu_logsys.h"
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errmsg.h>
#include <mysqld_error.h>
#include <limits.h>
#include <ctype.h>
#include <assert.h>
#include <map>

// Disgrace: for windows compile
#ifdef _WINDOWS
#include <windows.h>
#define snprintf	_snprintf
#define strncasecmp	_strnicmp
#define strcasecmp	_stricmp
#else

#include "../common/unix.h"
#include <netinet/in.h>

#endif

#include "database.h"
#include "../common/eq_packet_structs.h"
#include "../common/misc_functions.h"
#include "../common/strings.h"
#include "chatchannel.h"

extern Clientlist      *g_Clientlist;
extern std::string GetMailPrefix();
extern ChatChannelList *ChannelList;
extern uint32          MailMessagesSent;

void UCSDatabase::GetAccountStatus(Client *client)
{

	std::string query = StringFormat(
		"SELECT `status`, `hideme`, `karma`, `revoked` FROM `account` WHERE `id` = %i LIMIT 1",
		client->GetAccountID()
	);

	auto results = QueryDatabase(query);
	if (!results.Success()) {
		LogInfo(
			"Unable to get account status for character [{}], error [{}]",
			client->GetName().c_str(),
			results.ErrorMessage().c_str()
		);

		return;
	}

	if (results.RowCount() != 1) {
		LogInfo("Error in GetAccountStatus");
		return;
	}

	auto row = results.begin();

	client->SetAccountStatus(atoi(row[0]));
	client->SetHideMe(atoi(row[1]) != 0);
	client->SetKarma(atoi(row[2]));
	client->SetRevoked((atoi(row[3]) == 1 ? true : false));

	LogDebug(
		"Set account status to [{}], hideme to [{}] and karma to [{}] for [{}]",
		client->GetAccountStatus(),
		client->GetHideMe(),
		client->GetKarma(),
		client->GetName().c_str()
	);
}

int UCSDatabase::FindAccount(const char *characterName, Client *client)
{

	LogInfo("FindAccount for character [{}]", characterName);

	client->ClearCharacters();
	std::string query   = StringFormat(
		"SELECT `id`, `account_id`, `level` FROM `character_data` WHERE `name` = '%s' LIMIT 1",
		characterName
	);
	auto        results = QueryDatabase(query);

	if (!results.Success()) {
		return -1;
	}

	if (results.RowCount() != 1) {
		return -1;
	}

	auto row = results.begin();
	client->AddCharacter(atoi(row[0]), characterName, atoi(row[2]));

	int accountID = atoi(row[1]);

	LogInfo("Account ID for [{}] is [{}]", characterName, accountID);

	query = StringFormat(
		"SELECT `id`, `name`, `level` FROM `character_data` "
		"WHERE `account_id` = %i AND `name` != '%s' AND deleted_at is NULL",
		accountID, characterName
	);

	results = QueryDatabase(query);
	if (!results.Success()) {
		return accountID;
	}

	for (auto row = results.begin(); row != results.end(); ++row)
		client->AddCharacter(atoi(row[0]), row[1], atoi(row[2]));

	return accountID;
}

bool UCSDatabase::VerifyMailKey(std::string characterName, int IPAddress, std::string MailKey)
{

	std::string query = StringFormat(
		"SELECT `mailkey` FROM `character_data` WHERE `name`='%s' LIMIT 1",
		characterName.c_str()
	);

	auto results = QueryDatabase(query);
	if (!results.Success()) {
		LogInfo("Error retrieving mailkey from database: [{}]", results.ErrorMessage().c_str());
		return false;
	}

	auto row = results.begin();

	// The key is the client's IP address (expressed as 8 hex digits) and an 8 hex digit random string generated
	// by world.
	//
	char combinedKey[17];

	if (RuleB(Chat, EnableMailKeyIPVerification) == true) {
		sprintf(combinedKey, "%08X%s", IPAddress, MailKey.c_str());
	}
	else {
		sprintf(combinedKey, "%s", MailKey.c_str());
	}

	LogInfo("DB key is [[{}]], Client key is [[{}]]", (row[0] ? row[0] : ""), combinedKey);

	return !strcmp(row[0], combinedKey);
}

int UCSDatabase::FindCharacter(const char *characterName)
{
	char        *safeCharName = RemoveApostrophes(characterName);
	std::string query         = StringFormat(
		"SELECT `id` FROM `character_data` WHERE `name`='%s' LIMIT 1",
		safeCharName
	);
	auto        results       = QueryDatabase(query);
	if (!results.Success()) {
		safe_delete_array(safeCharName);
		return -1;
	}

	safe_delete_array(safeCharName);

	if (results.RowCount() != 1) {
		LogInfo("Bad result from FindCharacter query for character [{}]", characterName);
		return -1;
	}

	auto row = results.begin();

	int characterID = atoi(row[0]);

	return characterID;
}

bool UCSDatabase::GetVariable(const char *varname, char *varvalue, uint16 varvalue_len)
{

	std::string query   = StringFormat("SELECT `value` FROM `variables` WHERE `varname` = '%s'", varname);
	auto        results = QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	if (results.RowCount() != 1) {
		return false;
	}

	auto row = results.begin();

	snprintf(varvalue, varvalue_len, "%s", row[0]);

	return true;
}

bool UCSDatabase::LoadChatChannels()
{

	LogInfo("Loading chat channels from the database");

	const std::string query   = "SELECT `name`, `owner`, `password`, `minstatus` FROM `chatchannels`";
	auto              results = QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	for (auto row = results.begin(); row != results.end(); ++row) {
		std::string channelName     = row[0];
		std::string channelOwner    = row[1];
		std::string channelPassword = row[2];

		ChannelList->CreateChannel(channelName, channelOwner, channelPassword, true, atoi(row[3]));
	}

	return true;
}

void UCSDatabase::SetChannelPassword(std::string channelName, std::string password)
{
	LogInfo("UCSDatabase::SetChannelPassword([{}], [{}])", channelName.c_str(), password.c_str());

	std::string query = StringFormat(
		"UPDATE `chatchannels` SET `password` = '%s' WHERE `name` = '%s'",
		password.c_str(), channelName.c_str());
	QueryDatabase(query);
}

void UCSDatabase::SetChannelOwner(std::string channelName, std::string owner)
{
	LogInfo("UCSDatabase::SetChannelOwner([{}], [{}])", channelName.c_str(), owner.c_str());

	std::string query = StringFormat(
		"UPDATE `chatchannels` SET `owner` = '%s' WHERE `name` = '%s'",
		owner.c_str(),
		channelName.c_str()
	);

	QueryDatabase(query);
}

void UCSDatabase::SendHeaders(Client *client)
{

	int unknownField2 = 25015275;
	int unknownField3 = 1;
	int characterID   = FindCharacter(client->MailBoxName().c_str());

	LogDebug("Sendheaders for [{}], CharID is [{}]", client->MailBoxName().c_str(), characterID);

	if (characterID <= 0) {
		return;
	}

	std::string query   = StringFormat(
		"SELECT `msgid`,`timestamp`, `from`, `subject`, `status` "
		"FROM `mail` WHERE `charid`=%i", characterID
	);
	auto        results = QueryDatabase(query);
	if (!results.Success()) {
		return;
	}

	char buffer[100];

	int headerCountPacketLength = 0;

	sprintf(buffer, "%i", client->GetMailBoxNumber());
	headerCountPacketLength += (strlen(buffer) + 1);

	sprintf(buffer, "%i", unknownField2);
	headerCountPacketLength += (strlen(buffer) + 1);

	sprintf(buffer, "%i", unknownField3);
	headerCountPacketLength += (strlen(buffer) + 1);

	sprintf(buffer, "%i", results.RowCount());
	headerCountPacketLength += (strlen(buffer) + 1);

	auto outapp = new EQApplicationPacket(OP_MailHeaderCount, headerCountPacketLength);

	char *packetBuffer = (char *) outapp->pBuffer;

	VARSTRUCT_ENCODE_INTSTRING(packetBuffer, client->GetMailBoxNumber());
	VARSTRUCT_ENCODE_INTSTRING(packetBuffer, unknownField2);
	VARSTRUCT_ENCODE_INTSTRING(packetBuffer, unknownField3);
	VARSTRUCT_ENCODE_INTSTRING(packetBuffer, results.RowCount());


	client->QueuePacket(outapp);

	safe_delete(outapp);

	int       rowIndex = 0;
	for (auto row      = results.begin(); row != results.end(); ++row, ++rowIndex) {
		int headerPacketLength = 0;

		sprintf(buffer, "%i", client->GetMailBoxNumber());
		headerPacketLength += strlen(buffer) + 1;
		sprintf(buffer, "%i", unknownField2);
		headerPacketLength += strlen(buffer) + 1;
		sprintf(buffer, "%i", rowIndex);
		headerPacketLength += strlen(buffer) + 1;

		headerPacketLength += strlen(row[0]) + 1;
		headerPacketLength += strlen(row[1]) + 1;
		headerPacketLength += strlen(row[4]) + 1;
		headerPacketLength += GetMailPrefix().length() + strlen(row[2]) + 1;
		headerPacketLength += strlen(row[3]) + 1;

		outapp = new EQApplicationPacket(OP_MailHeader, headerPacketLength);

		packetBuffer = (char *) outapp->pBuffer;

		VARSTRUCT_ENCODE_INTSTRING(packetBuffer, client->GetMailBoxNumber());
		VARSTRUCT_ENCODE_INTSTRING(packetBuffer, unknownField2);
		VARSTRUCT_ENCODE_INTSTRING(packetBuffer, rowIndex);
		VARSTRUCT_ENCODE_STRING(packetBuffer, row[0]);
		VARSTRUCT_ENCODE_STRING(packetBuffer, row[1]);
		VARSTRUCT_ENCODE_STRING(packetBuffer, row[4]);
		VARSTRUCT_ENCODE_STRING(packetBuffer, GetMailPrefix().c_str());
		packetBuffer--;
		VARSTRUCT_ENCODE_STRING(packetBuffer, row[2]);
		VARSTRUCT_ENCODE_STRING(packetBuffer, row[3]);


		client->QueuePacket(outapp);

		safe_delete(outapp);
	}

}

void UCSDatabase::SendBody(Client *client, int messageNumber)
{

	int characterID = FindCharacter(client->MailBoxName().c_str());

	LogInfo("SendBody: MsgID [{}], to [{}], CharID is [{}]", messageNumber, client->MailBoxName().c_str(), characterID);

	if (characterID <= 0) {
		return;
	}

	std::string query = StringFormat(
		"SELECT `msgid`, `body`, `to` FROM `mail` "
		"WHERE `charid`=%i AND `msgid`=%i",
		characterID,
		messageNumber
	);

	auto results = QueryDatabase(query);
	if (!results.Success()) {
		return;
	}


	if (results.RowCount() != 1) {
		return;
	}

	auto row = results.begin();

	LogInfo("Message: [{}]  body ([{}] bytes)", messageNumber, strlen(row[1]));

	int packetLength = 12 + strlen(row[0]) + strlen(row[1]) + strlen(row[2]);

	auto outapp = new EQApplicationPacket(OP_MailSendBody, packetLength);

	char *packetBuffer = (char *) outapp->pBuffer;

	VARSTRUCT_ENCODE_INTSTRING(packetBuffer, client->GetMailBoxNumber());
	VARSTRUCT_ENCODE_STRING(packetBuffer, row[0]);
	VARSTRUCT_ENCODE_STRING(packetBuffer, row[1]);
	VARSTRUCT_ENCODE_STRING(packetBuffer, "1");
	VARSTRUCT_ENCODE_TYPE(uint8, packetBuffer, 0);
	VARSTRUCT_ENCODE_TYPE(uint8, packetBuffer, 0x0a);
	VARSTRUCT_ENCODE_STRING(packetBuffer, "TO:");
	packetBuffer--;
	VARSTRUCT_ENCODE_STRING(packetBuffer, row[2]);
	packetBuffer--; // Overwrite the null terminator
	VARSTRUCT_ENCODE_TYPE(uint8, packetBuffer, 0x0a);

	client->QueuePacket(outapp);

	safe_delete(outapp);
}

bool UCSDatabase::SendMail(
	std::string recipient,
	std::string from,
	std::string subject,
	std::string body,
	std::string recipientsString
)
{

	int         characterID;
	std::string characterName;

	auto lastPeriod = recipient.find_last_of(".");

	if (lastPeriod == std::string::npos) {
		characterName = recipient;
	}
	else {
		characterName = recipient.substr(lastPeriod + 1);
	}

	characterName[0] = toupper(characterName[0]);

	for (unsigned int i = 1; i < characterName.length(); i++)
		characterName[i] = tolower(characterName[i]);

	characterID = FindCharacter(characterName.c_str());

	LogInfo("SendMail: CharacterID for recipient [{}] is [{}]", characterName.c_str(), characterID);

	if (characterID <= 0) {
		return false;
	}

	auto escSubject = new char[subject.length() * 2 + 1];
	auto escBody    = new char[body.length() * 2 + 1];

	DoEscapeString(escSubject, subject.c_str(), subject.length());
	DoEscapeString(escBody, body.c_str(), body.length());

	int now = time(nullptr); // time returns a 64 bit int on Windows at least, which vsnprintf doesn't like.

	std::string query = StringFormat(
		"INSERT INTO `mail` (`charid`, `timestamp`, `from`, `subject`, `body`, `to`, `status`) VALUES ('%i', %i, '%s', '%s', '%s', '%s', %i)",
		characterID,
		now,
		from.c_str(),
		escSubject,
		escBody,
		recipientsString.c_str(),
		1
	);
	safe_delete_array(escSubject);
	safe_delete_array(escBody);
	auto results = QueryDatabase(query);
	if (!results.Success()) {
		return false;
	}

	LogInfo("MessageID [{}] generated, from [{}], to [{}]", results.LastInsertedID(), from.c_str(), recipient.c_str());

	Client *client = g_Clientlist->IsCharacterOnline(characterName);

	if (client) {
		std::string FQN = GetMailPrefix() + from;
		client->SendNotification(client->GetMailBoxNumber(characterName), subject, FQN, results.LastInsertedID());
	}

	MailMessagesSent++;

	return true;
}

void UCSDatabase::SetMessageStatus(int messageNumber, int status)
{

	LogInfo("SetMessageStatus [{}] [{}]", messageNumber, status);

	if (status == 0) {
		std::string query   = StringFormat("DELETE FROM `mail` WHERE `msgid` = %i", messageNumber);
		auto        results = QueryDatabase(query);
		return;
	}

	std::string query = StringFormat("UPDATE `mail` SET `status` = %i WHERE `msgid`=%i", status, messageNumber);
	QueryDatabase(query);
}

void UCSDatabase::ExpireMail()
{

	LogInfo("Expiring mail");

	std::string query   = "SELECT COUNT(*) FROM `mail`";
	auto        results = QueryDatabase(query);
	if (!results.Success()) {
		return;
	}

	auto row = results.begin();

	LogInfo("There are [{}] messages in the database", row[0]);

	/**
	 * Expire trash
	 */
	if (RuleI(Mail, ExpireTrash) >= 0) {
		query   = StringFormat(
			"DELETE FROM `mail` WHERE `status`=4 AND `timestamp` < %i",
			time(nullptr) - RuleI(Mail, ExpireTrash));
		results = QueryDatabase(query);
		if (results.Success()) {
			LogInfo("Expired [{}] trash messages", results.RowsAffected());
		}
	}

	/**
	 * Expire read
	 */
	if (RuleI(Mail, ExpireRead) >= 0) {
		query = StringFormat(
			"DELETE FROM `mail` WHERE `status` = 3 AND `timestamp` < %i",
			time(nullptr) - RuleI(Mail, ExpireRead)
		);

		results = QueryDatabase(query);
		if (results.Success())
			LogInfo("Expired [{}] read messages", results.RowsAffected());
	}

	/**
	 * Expire unread
	 */
	if (RuleI(Mail, ExpireUnread) >= 0) {
		query = StringFormat(
			"DELETE FROM `mail` WHERE `status`=1 AND `timestamp` < %i",
			time(nullptr) - RuleI(Mail, ExpireUnread)
		);

		results = QueryDatabase(query);
		if (results.Success()) {
			LogInfo("Expired [{}] unread messages", results.RowsAffected());
		}
	}
}

void UCSDatabase::AddFriendOrIgnore(int charID, int type, std::string name)
{
	std::string query = StringFormat(
		"INSERT INTO `friends` (`charid`, `type`, `name`) "
		"VALUES('%i', %i, '%s')",
		charID,
		type,
		CapitaliseName(name).c_str()
	);

	auto results = QueryDatabase(query);

	if (results.Success()) {
		LogInfo(
			"Wrote Friend/Ignore entry for charid [{}], type [{}], name [{}] to database",
			charID,
			type,
			name.c_str()
		);
	}
}

void UCSDatabase::RemoveFriendOrIgnore(int charID, int type, std::string name)
{
	std::string query = StringFormat(
		"DELETE FROM `friends` WHERE `charid` = %i AND `type` = %i AND `name` = '%s'",
		charID,
		type,
		CapitaliseName(name).c_str()
	);

	auto results = QueryDatabase(query);

	if (results.Success()) {
		LogInfo(
			"Removed Friend/Ignore entry for charid [{}], type [{}], name [{}] from database",
			charID,
			type,
			name.c_str()
		);
	}
}

void UCSDatabase::GetFriendsAndIgnore(int charID, std::vector<std::string> &friends, std::vector<std::string> &ignorees)
{

	std::string query   = StringFormat("select `type`, `name` FROM `friends` WHERE `charid`=%i", charID);
	auto        results = QueryDatabase(query);
	if (!results.Success()) {
		return;
	}


	for (auto row = results.begin(); row != results.end(); ++row) {
		std::string name = row[1];

		if (atoi(row[0]) == 0) {
			ignorees.push_back(name);
			LogInfo("Added Ignoree from DB [{}]", name.c_str());
			continue;
		}

		friends.push_back(name);
		LogInfo("Added Friend from DB [{}]", name.c_str());
	}

}