path: root/modules/extra/db_mysql.cpp

#include "module.h"
#include "sql.h"

struct NickAliasFlagInfo
{
	Anope::string Name;
	NickNameFlag Flag;
};

NickAliasFlagInfo NickAliasFlags[] = {
	{"FORBIDDEN", NS_FORBIDDEN},
	{"NOEXPIRE", NS_NO_EXPIRE},
	{"", static_cast<NickNameFlag>(-1)}
};

struct NickCoreFlagInfo
{
	Anope::string Name;
	NickCoreFlag Flag;
};

NickCoreFlagInfo NickCoreFlags[] = {
	{"KILLPROTECT", NI_KILLPROTECT},
	{"SECURE", NI_SECURE},
	{"MSG", NI_MSG},
	{"MEMO_HARDMAX", NI_MEMO_HARDMAX},
	{"MEMO_SIGNON", NI_MEMO_SIGNON},
	{"MEMO_RECEIVE", NI_MEMO_RECEIVE},
	{"PRIVATE", NI_PRIVATE},
	{"HIDE_EMAIL", NI_HIDE_EMAIL},
	{"HIDE_MASK", NI_HIDE_MASK},
	{"HIDE_QUIT", NI_HIDE_QUIT},
	{"KILL_QUICK", NI_KILL_QUICK},
	{"KILL_IMMED", NI_KILL_IMMED},
	{"MEMO_MAIL", NI_MEMO_MAIL},
	{"HIDE_STATUS", NI_HIDE_STATUS},
	{"SUSPENDED", NI_SUSPENDED},
	{"AUTOOP", NI_AUTOOP},
	{"FORBIDDEN", NI_FORBIDDEN},
	{"", static_cast<NickCoreFlag>(-1)}
};

struct BotServFlagInfo
{
	Anope::string Name;
	BotFlag Flag;
};

BotServFlagInfo BotServFlags[] = {
	{"PRIVATE", BI_PRIVATE},
	{"", static_cast<BotFlag>(-1)}
};

struct BotFlagInfo
{
	Anope::string Name;
	BotServFlag Flag;
};

BotFlagInfo BotFlags[] = {
	{"DONTKICKOPS", BS_DONTKICKOPS},
	{"DONTKICKVOICES", BS_DONTKICKVOICES},
	{"FANTASY", BS_FANTASY},
	{"SYMBIOSIS", BS_SYMBIOSIS},
	{"GREET", BS_GREET},
	{"NOBOT", BS_NOBOT},
	{"KICK_BOLDS", BS_KICK_BOLDS},
	{"KICK_COLORS", BS_KICK_COLORS},
	{"KICK_REVERSES", BS_KICK_REVERSES},
	{"KICK_UNDERLINES", BS_KICK_UNDERLINES},
	{"KICK_BADWORDS", BS_KICK_BADWORDS},
	{"KICK_CAPS", BS_KICK_CAPS},
	{"KICK_FLOOD", BS_KICK_FLOOD},
	{"KICK_REPEAT", BS_KICK_REPEAT},
	{"KICK_ITALICS", BS_KICK_ITALICS},
	{"", static_cast<BotServFlag>(-1)}
};

struct ChannelFlagInfo
{
	Anope::string Name;
	ChannelInfoFlag Flag;
};

ChannelFlagInfo ChannelFlags[] = {
	{"KEEPTOPIC", CI_KEEPTOPIC},
	{"SECUREOPS", CI_SECUREOPS},
	{"PRIVATE", CI_PRIVATE},
	{"TOPICLOCK", CI_TOPICLOCK},
	{"RESTRICTED", CI_RESTRICTED},
	{"PEACE", CI_PEACE},
	{"SECURE", CI_SECURE},
	{"FORBIDDEN", CI_FORBIDDEN},
	{"NO_EXPIRE", CI_NO_EXPIRE},
	{"MEMO_HARDMAX", CI_MEMO_HARDMAX},
	{"OPNOTICE", CI_OPNOTICE},
	{"SECUREFOUNDER", CI_SECUREFOUNDER},
	{"SIGNKICK", CI_SIGNKICK},
	{"SIGNKICK_LEVEL", CI_SIGNKICK_LEVEL},
	{"XOP", CI_XOP},
	{"SUSPENDED", CI_SUSPENDED},
	{"PERSIST", CI_PERSIST},
	{"", static_cast<ChannelInfoFlag>(-1)}
};

struct MemoFlagInfo
{
	Anope::string Name;
	MemoFlag Flag;
};

MemoFlagInfo MemoFlags[] = {
	{"UNREAD", MF_UNREAD},
	{"RECEIPT", MF_RECEIPT},
	{"NOTIFYS", MF_NOTIFYS},
	{"", static_cast<MemoFlag>(-1)}
};

static std::vector<Anope::string> MakeVector(const Anope::string &buf)
{
	Anope::string s;
	spacesepstream sep(buf);
	std::vector<Anope::string> params;

	while (sep.GetToken(s))
	{
		if (s[0] == ':')
		{
			s.erase(s.begin());
			if (!s.empty() && !sep.StreamEnd())
				params.push_back(s + " " + sep.GetRemaining());
			else if (!s.empty())
				params.push_back(s);
		}
		else
			params.push_back(s);
	}

	return params;
}

static Anope::string BuildFlagsList(ChannelInfo *ci)
{
	Anope::string ret;

	for (int i = 0; ChannelFlags[i].Flag != -1; ++i)
		if (ci->HasFlag(ChannelFlags[i].Flag))
			ret += " " + ChannelFlags[i].Name;

	if (!ret.empty())
		ret.erase(ret.begin());

	return ret;
}

static Anope::string BuildFlagsList(NickAlias *na)
{
	Anope::string ret;

	for (int i = 0; NickAliasFlags[i].Flag != -1; ++i)
		if (na->HasFlag(NickAliasFlags[i].Flag))
			ret += " " + NickAliasFlags[i].Name;

	if (!ret.empty())
		ret.erase(ret.begin());

	return ret;
}

static Anope::string BuildFlagsList(NickCore *nc)
{
	Anope::string ret;

	for (int i = 0; NickCoreFlags[i].Flag != -1; ++i)
		if (nc->HasFlag(NickCoreFlags[i].Flag))
			ret += " " + NickCoreFlags[i].Name;

	if (!ret.empty())
		ret.erase(ret.begin());

	return ret;
}

static Anope::string BuildFlagsList(Memo *m)
{
	Anope::string ret;

	for (int i = 0; MemoFlags[i].Flag != -1; ++i)
		if (m->HasFlag(MemoFlags[i].Flag))
			ret += " " + MemoFlags[i].Name;

	if (!ret.empty())
		ret.erase(ret.begin());

	return ret;
}

static Anope::string MakeMLock(ChannelInfo *ci, bool status)
{
	Anope::string ret;

	if ((!Me || !Me->IsSynced()) && ci->GetExtRegular(status ? "db_mlock_modes_on" : "db_mlock_modes_off", ret))
		;
	else
	{
		for (std::map<char, ChannelMode *>::iterator it = ModeManager::ChannelModesByChar.begin(), it_end = ModeManager::ChannelModesByChar.end(); it != it_end; ++it)
		{
			ChannelMode *cm = it->second;
			if (ci->HasMLock(cm->Name, status))
				ret += " " + cm->NameAsString;
		}

		if (!ret.empty())
			ret.erase(ret.begin());
	}

	return ret;
}

static inline Anope::string GetMLockOn(ChannelInfo *ci)
{
	return MakeMLock(ci, true);
}

static inline Anope::string GetMLockOff(ChannelInfo *ci)
{
	return MakeMLock(ci, false);
}

static Anope::string GetMLockParams(ChannelInfo *ci)
{
	Anope::string ret;

	std::vector<std::pair<Anope::string, Anope::string> > oldparams;;
	if ((!Me || !Me->IsSynced()) && ci->GetExtRegular("db_mlp", oldparams))
	{
		for (std::vector<std::pair<Anope::string, Anope::string> >::iterator it = oldparams.begin(), it_end = oldparams.end(); it != it_end; ++it)
		{
			ret += " " + it->first + " " + it->second;
		}
	}
	else
	{
		for (std::map<char, ChannelMode *>::iterator it = ModeManager::ChannelModesByChar.begin(), it_end = ModeManager::ChannelModesByChar.end(); it != it_end; ++it)
		{
			ChannelMode *cm = it->second;

			Anope::string param;
			if (ci->GetParam(cm->Name, param))
				ret += " " + cm->NameAsString + " " + param;
		}
	}

	if (!ret.empty())
		ret.erase(ret.begin());

	return ret;
}

static Anope::string GetBotFlags(Flags<BotServFlag>& Flags)
{
	Anope::string buf;

	for (int i = 0; BotFlags[i].Flag != -1; ++i)
		if (Flags.HasFlag(BotFlags[i].Flag))
			buf += " " + BotFlags[i].Name;

	if (!buf.empty())
		buf.erase(buf.begin());

	return buf;
}

static Anope::string GetBotServFlags(BotInfo *bi)
{
	Anope::string buf;

	for (int i = 0; BotServFlags[i].Flag != -1; ++i)
		if (bi->HasFlag(BotServFlags[i].Flag))
			buf += " " + BotServFlags[i].Name;

	if (!buf.empty())
		buf.erase(buf.begin());;

	return buf;
}

static NickAlias *CurNick = NULL;
static NickCore *CurCore = NULL;
static ChannelInfo *CurChannel = NULL;
static BotInfo *CurBot = NULL;

static void Write(const Anope::string &data);
static void WriteNickMetadata(const Anope::string &key, const Anope::string &data);
static void WriteCoreMetadata(const Anope::string &key, const Anope::string &data);
static void WriteChannelMetadata(const Anope::string &key, const Anope::string &data);
static void WriteBotMetadata(const Anope::string &key, const Anope::string &data);

class CommandSQLSync : public Command
{
 public:
	CommandSQLSync() : Command("SQLSYNC", 0, 0, "operserv/sqlsync")
	{
	}

	CommandReturn Execute(User *u, const std::vector<Anope::string> &params);

	bool OnHelp(User *u, const Anope::string &subcommand)
	{
		u->SendMessage(OperServ, OPER_HELP_SYNC);
		return true;
	}

	void OnServHelp(User *u)
	{
		u->SendMessage(OperServ, OPER_HELP_CMD_SQLSYNC);
	}
};

class MySQLInterface : public SQLInterface
{
 public:
	MySQLInterface(Module *o) : SQLInterface(o) { }

	void OnResult(const SQLResult &r);

	void OnError(const SQLResult &r);
};

class DBMySQL;
static DBMySQL *me;
class DBMySQL : public Module
{
 private:
	CommandSQLSync commandsqlsync;
	MySQLInterface sqlinterface;
	service_reference<SQLProv