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},
	{"MSG_PRIVMSG", BS_MSG_PRIVMSG},
	{"MSG_NOTICE", BS_MSG_NOTICE},
	{"MSG_NOTICEOPS", BS_MSG_NOTICEOPS},
	{"", 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::multimap<ChannelModeName, ModeLock>::const_iterator it = ci->GetMLock().begin(), it_end = ci->GetMLock().end(); it != it_end; ++it)
		{
			const ModeLock &ml = it->second;
			if (ml.set == status)
			{
				ChannelMode *cm = ModeManager::FindChannelModeByName(ml.name);
				if (!cm || cm->Type != MODE_REGULAR)
					continue;
				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, bool onoff)
{
	Anope::string ret;

	std::vector<std::pair<Anope::string, Anope::string> > oldparams;;
	if ((!Me || !Me->IsSynced()) && ci->GetExtRegular(onoff ? "db_mlp" : "db_mlp_off", oldparams))
	{
		for (std::vector<std::pair<A