Optimize much of the database code and serialize code.

16 files changed, 334 insertions, 352 deletions

diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2c7566e78..8012e03e1 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -11,14 +11,6 @@ if(WIN32)
   append_to_list(SRC_SRCS win32/sigaction/sigaction.cpp)
 endif(WIN32)
 
-# If we have eventfd, use it
-if(HAVE_EVENTFD)
-  append_to_list(SRC_SRCS socketengines/pipeengine_pipe.cpp)
-# Else fall back to pipe
-else(HAVE_EVENTFD)
-  append_to_list(SRC_SRCS socketengines/pipeengine_pipe.cpp)
-endif(HAVE_EVENTFD)
-
 if(HAVE_EPOLL)
   append_to_list(SRC_SRCS socketengines/socketengine_epoll.cpp)
 else(HAVE_EPOLL)
diff --git a/src/access.cpp b/src/access.cpp
index 863e0d41d..c8cd3cf98 100644
--- a/src/access.cpp
+++ b/src/access.cpp
@@ -99,25 +99,26 @@ ChanAccess::~ChanAccess()
 {
 }
 
-Serialize::Data ChanAccess::Serialize() const
+void ChanAccess::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
 	data["provider"] << this->provider->name;
 	data["ci"] << this->ci->name;
 	data["mask"] << this->mask;
 	data["creator"] << this->creator;
-	data["last_seen"].SetType(Serialize::DT_INT) << this->last_seen;
-	data["created"].SetType(Serialize::DT_INT) << this->created;
+	data.SetType("last_seen", Serialize::Data::DT_INT); data["last_seen"] << this->last_seen;
+	data.SetType("created", Serialize::Data::DT_INT); data["created"] << this->created;
 	data["data"] << this->AccessSerialize();
-
-	return data;
 }
 
 Serializable* ChanAccess::Unserialize(Serializable *obj, Serialize::Data &data)
 {
-	ServiceReference<AccessProvider> aprovider("AccessProvider", data["provider"].astr());
-	ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr());
+	Anope::string provider, chan;
+
+	data["provider"] >> provider;
+	data["ci"] >>chan;
+
+	ServiceReference<AccessProvider> aprovider("AccessProvider", provider);
+	ChannelInfo *ci = ChannelInfo::Find(chan);
 	if (!aprovider || !ci)
 		return NULL;
 
@@ -131,7 +132,10 @@ Serializable* ChanAccess::Unserialize(Serializable *obj, Serialize::Data &data)
 	data["creator"] >> access->creator;
 	data["last_seen"] >> access->last_seen;
 	data["created"] >> access->created;
-	access->AccessUnserialize(data["data"].astr());
+
+	Anope::string adata;
+	data["data"] >> adata;
+	access->AccessUnserialize(adata);
 
 	if (!obj)
 		ci->AddAccess(access);
diff --git a/src/base.cpp b/src/base.cpp
index 5b8d828b6..b98b68893 100644
--- a/src/base.cpp
+++ b/src/base.cpp
@@ -14,25 +14,37 @@
 std::map<Anope::string, std::map<Anope::string, Service *> > Service::Services;
 std::map<Anope::string, std::map<Anope::string, Anope::string> > Service::Aliases;
 
-Base::Base()
+Base::Base() : references(NULL)
 {
 }
 
 Base::~Base()
 {
-	for (std::set<ReferenceBase *>::iterator it = this->references.begin(), it_end = this->references.end(); it != it_end; ++it)
+	if (this->references != NULL)
 	{
-		(*it)->Invalidate();
+		for (std::set<ReferenceBase *>::iterator it = this->references->begin(), it_end = this->references->end(); it != it_end; ++it)
+			(*it)->Invalidate();
+		delete this->references;
 	}
 }
 
 void Base::AddReference(ReferenceBase *r)
 {
-	this->references.insert(r);
+	if (this->references == NULL)
+		this->references = new std::set<ReferenceBase *>();
+	this->references->insert(r);
 }
 
 void Base::DelReference(ReferenceBase *r)
 {
-	this->references.erase(r);
+	if (this->references != NULL)
+	{
+		this->references->erase(r);
+		if (this->references->empty())
+		{
+			delete this->references;
+			this->references = NULL;
+		}
+	}
 }
 
diff --git a/src/bots.cpp b/src/bots.cpp
index 1e48d034e..da5fe7574 100644
--- a/src/bots.cpp
+++ b/src/bots.cpp
@@ -82,29 +82,33 @@ BotInfo::~BotInfo()
 		BotListByUID->erase(this->uid);
 }
 
-Serialize::Data BotInfo::Serialize() const
+void BotInfo::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
-	data["nick"].SetMax(64)/*XXX*/ << this->nick;
+	data["nick"] << this->nick;
 	data["user"] << this->ident;
 	data["host"] << this->host;
 	data["realname"] << this->realname;
 	data["created"] << this->created;
 	data["flags"] << this->ToString();
-
-	return data;
 }
 
 Serializable* BotInfo::Unserialize(Serializable *obj, Serialize::Data &data)
 {
+	Anope::string nick, user, host, realname, flags;
+
+	data["nick"] >> nick;
+	data["user"] >> user;
+	data["host"] >> host;
+	data["realname"] >> realname;
+	data["flags"] >> flags;
+
 	BotInfo *bi;
 	if (obj)
 		bi = anope_dynamic_static_cast<BotInfo *>(obj);
-	else if (!(bi = BotInfo::Find(data["nick"].astr())))
-		bi = new BotInfo(data["nick"].astr(), data["user"].astr(), data["host"].astr(), data["realname"].astr());
+	else if (!(bi = BotInfo::Find(nick)))
+		bi = new BotInfo(nick, user, host, realname);
 	data["created"] >> bi->created;
-	bi->FromString(data["flags"].astr());
+	bi->FromString(flags);
 	return bi;
 }
 
diff --git a/src/init.cpp b/src/init.cpp
index e45d2a6f9..14e7d2025 100644
--- a/src/init.cpp
+++ b/src/init.cpp
@@ -16,7 +16,6 @@
 #include "protocol.h"
 #include "bots.h"
 #include "xline.h"
-#include "signals.h"
 #include "socketengine.h"
 #include "servers.h"
 #include "language.h"
@@ -91,91 +90,6 @@ static bool GetCommandLineArgument(const Anope::string &name, char shortname = 0
 	return GetCommandLineArgument(name, shortname, Unused);
 }
 
-/*************************************************************************/
-
-/* Remove our PID file.  Done at exit. */
-
-static void remove_pidfile()
-{
-	remove(Config->PIDFilename.c_str());
-}
-
-/*************************************************************************/
-
-/* Create our PID file and write the PID to it. */
-
-static void write_pidfile()
-{
-	FILE *pidfile = fopen(Config->PIDFilename.c_str(), "w");
-	if (pidfile)
-	{
-#ifdef _WIN32
-		fprintf(pidfile, "%d\n", static_cast<int>(GetCurrentProcessId()));
-#else
-		fprintf(pidfile, "%d\n", static_cast<int>(getpid()));
-#endif
-		fclose(pidfile);
-		atexit(remove_pidfile);
-	}
-	else
-		throw CoreException("Can not write to PID file " + Config->PIDFilename);
-}
-
-/*************************************************************************/
-
-class SignalReload : public Signal
-{
- public:
-	SignalReload(int sig) : Signal(sig) { }
-
-	void OnNotify()
-	{
-		Log() << "Received SIGHUP: Saving databases & rehashing configuration";
-
-		Anope::SaveDatabases();
-
-		ServerConfig *old_config = Config;
-		try
-		{
-			Config = new ServerConfig();
-			FOREACH_MOD(I_OnReload, OnReload());
-			delete old_config;
-		}
-		catch (const ConfigException &ex)
-		{
-			Config = old_config;
-			Log() << "Error reloading configuration file: " << ex.GetReason();
-		}
-	}
-};
-
-class SignalExit : public Signal
-{
- public:
-	SignalExit(int sig) : Signal(sig) { }
-
-	void OnNotify()
-	{
-#ifndef _WIN32
-		Log() << "Received " << strsignal(this->signal) << " signal (" << this->signal << "), exiting.";
-		Anope::QuitReason = Anope::string("Services terminating via signal ") + strsignal(this->signal) + " (" + stringify(this->signal) + ")";
-#else
-		Log() << "Received signal " << this->signal << ", exiting.";
-		Anope::QuitReason = Anope::string("Services terminating via signal ") + stringify(this->signal);
-#endif
-		Anope::SaveDatabases();
-		Anope::Quitting = true;
-	}
-};
-
-class SignalNothing : public Signal
-{
- public:
-	SignalNothing(int sig) : Signal(sig) { }
-
-	void OnNotify() { }
-};
-
 bool Anope::AtTerm()
 {
 	return isatty(fileno(stdout)) && isatty(fileno(stdin)) && isatty(fileno(stderr));
@@ -196,6 +110,45 @@ void Anope::Fork()
 #endif
 }
 
+void Anope::HandleSignal()
+{
+	switch (Signal)
+	{
+		case SIGHUP:
+		{
+			Anope::SaveDatabases();
+
+			ServerConfig *old_config = Config;
+			try
+			{
+				Config = new ServerConfig();
+				FOREACH_MOD(I_OnReload, OnReload());
+				delete old_config;
+			}
+			catch (const ConfigException &ex)
+			{
+				Config = old_config;
+				Log() << "Error reloading configuration file: " << ex.GetReason();
+			}
+			break;
+		}
+		case SIGTERM:
+		case SIGINT:
+#ifndef _WIN32
+			Log() << "Received " << strsignal(Signal) << " signal (" << Signal << "), exiting.";
+			Anope::QuitReason = Anope::string("Services terminating via signal ") + strsignal(Signal) + " (" + stringify(Signal) + ")";
+#else
+			Log() << "Received signal " << Signal << ", exiting.";
+			Anope::QuitReason = Anope::string("Services terminating via signal ") + stringify(Signal);
+#endif
+			Anope::SaveDatabases();
+			Anope::Quitting = true;
+			break;
+	}
+
+	Signal = 0;
+}
+
 #ifndef _WIN32
 static void parent_signal_handler(int signal)
 {
@@ -215,6 +168,57 @@ static void parent_signal_handler(int signal)
 }
 #endif
 
+static void SignalHandler(int sig)
+{
+	Anope::Signal = sig;
+}
+
+static void InitSignals()
+{
+	struct sigaction sa;
+
+	sa.sa_flags = 0;
+	sigemptyset(&sa.sa_mask);
+
+	sa.sa_handler = SignalHandler;
+
+	sigaction(SIGHUP, &sa, NULL);
+
+	sigaction(SIGTERM, &sa, NULL);
+	sigaction(SIGINT, &sa, NULL);
+
+	sa.sa_handler = SIG_IGN;
+
+	sigaction(SIGCHLD, &sa, NULL);
+	sigaction(SIGPIPE, &sa, NULL);
+}
+
+/* Remove our PID file.  Done at exit. */
+
+static void remove_pidfile()
+{
+	remove(Config->PIDFilename.c_str());
+}
+
+/* Create our PID file and write the PID to it. */
+
+static void write_pidfile()
+{
+	FILE *pidfile = fopen(Config->PIDFilename.c_str(), "w");
+	if (pidfile)
+	{
+#ifdef _WIN32
+		fprintf(pidfile, "%d\n", static_cast<int>(GetCurrentProcessId()));
+#else
+		fprintf(pidfile, "%d\n", static_cast<int>(getpid()));
+#endif
+		fclose(pidfile);
+		atexit(remove_pidfile);
+	}
+	else
+		throw CoreException("Can not write to PID file " + Config->PIDFilename);
+}
+
 void Anope::Init(int ac, char **av)
 {
 	/* Set file creation mask and group ID. */
@@ -432,10 +436,7 @@ void Anope::Init(int ac, char **av)
 	/* Announce ourselves to the logfile. */
 	Log() << "Anope " << Anope::Version() << " starting up" << (Anope::Debug || Anope::ReadOnly ? " (options:" : "") << (Anope::Debug ? " debug" : "") << (Anope::ReadOnly ? " readonly" : "") << (Anope::Debug || Anope::ReadOnly ? ")" : "");
 
-	new SignalReload(SIGHUP);
-	new SignalExit(SIGTERM);
-	new SignalExit(SIGINT);
-	new SignalNothing(SIGPIPE);
+	InitSignals();
 
 	/* Initialize multi-language support */
 	Language::InitLanguages();
diff --git a/src/main.cpp b/src/main.cpp
index 82cd1af90..c35ee40d9 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -14,7 +14,6 @@
 #include "timers.h"
 #include "config.h"
 #include "bots.h"
-#include "signals.h"
 #include "socketengine.h"
 #include "uplink.h"
 
@@ -31,6 +30,7 @@ Anope::string Anope::ServicesDir;
 Anope::string Anope::ServicesBin;
 
 int Anope::ReturnValue = 0;
+sig_atomic_t Anope::Signal = 0;
 bool Anope::Quitting = false;
 bool Anope::Restarting = false;
 Anope::string Anope::QuitReason;
@@ -63,40 +63,6 @@ void Anope::SaveDatabases()
 	Log(LOG_DEBUG) << "Saving databases";
 }
 
-std::vector<Signal *> Signal::SignalHandlers;
-
-void Signal::SignalHandler(int signal)
-{
-	for (unsigned i = 0, j = SignalHandlers.size(); i < j; ++i)
-		if (SignalHandlers[i]->signal == signal)
-			SignalHandlers[i]->Notify();
-}
-
-Signal::Signal(int s) : Pipe(), signal(s)
-{
-	memset(&this->old, 0, sizeof(this->old));
-
-	this->action.sa_flags = 0;
-	sigemptyset(&this->action.sa_mask);
-	this->action.sa_handler = SignalHandler;
-	
-	if (sigaction(s, &this->action, &this->old) == -1)
-		throw CoreException("Unable to install signal " + stringify(s) + ": " + Anope::LastError());
-
-	SignalHandlers.push_back(this);
-}
-
-Signal::~Signal()
-{
-	std::vector<Signal *>::iterator it = std::find(SignalHandlers.begin(), SignalHandlers.end(), this);
-	if (it != SignalHandlers.end())
-		SignalHandlers.erase(it);
-	
-	sigaction(this->signal, &this->old, NULL);
-}
-
-/*************************************************************************/
-
 /** The following comes from InspIRCd to get the full path of the Anope executable
  */
 static Anope::string GetFullProgDir(const Anope::string &argv0)
@@ -196,6 +162,9 @@ int main(int ac, char **av, char **envp)
 
 		/* Process the socket engine */
 		SocketEngine::Process();
+
+		if (Anope::Signal)
+			Anope::HandleSignal();
 	}
 
 	if (Anope::Restarting)
diff --git a/src/memos.cpp b/src/memos.cpp
index 2b221b03a..2f2672c51 100644
--- a/src/memos.cpp
+++ b/src/memos.cpp
@@ -24,17 +24,13 @@ template<> const Anope::string* Flags<MemoFlag>::flags_strings = MemoFlagString;
 
 Memo::Memo() : Serializable("Memo") { }
 
-Serialize::Data Memo::Serialize() const
+void Memo::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;	
-
 	data["owner"] << this->owner;
-	data["time"].SetType(Serialize::DT_INT) << this->time;
+	data.SetType("time", Serialize::Data::DT_INT); data["time"] << this->time;
 	data["sender"] << this->sender;
 	data["text"] << this->text;
 	data["flags"] << this->ToString();
-
-	return data;
 }
 
 Serializable* Memo::Unserialize(Serializable *obj, Serialize::Data &data)
@@ -42,8 +38,13 @@ Serializable* Memo::Unserialize(Serializable *obj, Serialize::Data &data)
 	if (!MemoServService)
 		return NULL;
 	
+	Anope::string owner, flags;
+
+	data["owner"] >> owner;
+	data["flags"] >> flags;
+	
 	bool ischan;
-	MemoInfo *mi = MemoServService->GetMemoInfo(data["owner"].astr(), ischan);
+	MemoInfo *mi = MemoServService->GetMemoInfo(owner, ischan);
 	if (!mi)
 		return NULL;
 
@@ -56,7 +57,7 @@ Serializable* Memo::Unserialize(Serializable *obj, Serialize::Data &data)
 	data["time"] >> m->time;
 	data["sender"] >> m->sender;
 	data["text"] >> m->text;
-	m->FromString(data["flags"].astr());
+	m->FromString(flags);
 
 	if (obj == NULL)
 		mi->memos->push_back(m);
diff --git a/src/modulemanager.cpp b/src/modulemanager.cpp
index 5e2165e30..50eff0cbd 100644
--- a/src/modulemanager.cpp
+++ b/src/modulemanager.cpp
@@ -93,16 +93,15 @@ static ModuleReturn moduleCopyFile(const Anope::string &name, Anope::string &out
 	}
 
 	int want = s.st_size;
-	char *buffer = new char[s.st_size];
+	char buffer[1024];
 	while (want > 0 && !source.fail() && !target.fail())
 	{
-		source.read(buffer, want);
+		source.read(buffer, std::min(want, static_cast<int>(sizeof(buffer))));
 		int read_len = source.gcount();
 
 		target.write(buffer, read_len);
 		want -= read_len;
 	}
-	delete [] buffer;
 	
 	source.close();
 	target.close();
diff --git a/src/nickalias.cpp b/src/nickalias.cpp
index f163c145f..4ce861943 100644
--- a/src/nickalias.cpp
+++ b/src/nickalias.cpp
@@ -238,17 +238,15 @@ NickAlias *NickAlias::Find(const Anope::string &nick)
 	return NULL;
 }
 
-Serialize::Data NickAlias::Serialize() const
+void NickAlias::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;	
-
-	data["nick"].SetMax(Config->NickLen) << this->nick;
+	data["nick"] << this->nick;
 	data["last_quit"] << this->last_quit;
 	data["last_realname"] << this->last_realname;
 	data["last_usermask"] << this->last_usermask;
 	data["last_realhost"] << this->last_realhost;
-	data["time_registered"].SetType(Serialize::DT_INT) << this->time_registered;
-	data["last_seen"].SetType(Serialize::DT_INT) << this->last_seen;
+	data.SetType("time_registered", Serialize::Data::DT_INT); data["time_registered"] << this->time_registered;
+	data.SetType("time_registered", Serialize::Data::DT_INT); data["last_seen"] << this->last_seen;
 	data["nc"] << this->nc->display;
 	data["flags"] << this->ToString();
 
@@ -259,13 +257,16 @@ Serialize::Data NickAlias::Serialize() const
 		data["vhost_creator"] << this->GetVhostCreator();
 		data["vhost_time"] << this->GetVhostCreated();
 	}
-
-	return data;
 }
 
 Serializable* NickAlias::Unserialize(Serializable *obj, Serialize::Data &data)
 {
-	NickCore *core = NickCore::Find(data["nc"].astr());
+	Anope::string snc, snick;
+
+	data["nc"] >> snc;
+	data["nick"] >> snick;
+
+	NickCore *core = NickCore::Find(snc);
 	if (core == NULL)
 		return NULL;
 
@@ -273,7 +274,7 @@ Serializable* NickAlias::Unserialize(Serializable *obj, Serialize::Data &data)
 	if (obj)
 		na = anope_dynamic_static_cast<NickAlias *>(obj);
 	else
-		na = new NickAlias(data["nick"].astr(), core);
+		na = new NickAlias(snick, core);
 
 	if (na->nc != core)
 	{
@@ -296,11 +297,20 @@ Serializable* NickAlias::Unserialize(Serializable *obj, Serialize::Data &data)
 	data["last_realhost"] >> na->last_realhost;
 	data["time_registered"] >> na->time_registered;
 	data["last_seen"] >> na->last_seen;
-	na->FromString(data["flags"].astr());
 
+	Anope::string flags;
+	data["flags"] >> flags;
+	na->FromString(flags);
+
+	Anope::string vhost_ident, vhost_host, vhost_creator;
 	time_t vhost_time;
+
+	data["vhost_ident"] >> vhost_ident;
+	data["vhost_host"] >> vhost_host;
+	data["vhost_creator"] >> vhost_creator;
 	data["vhost_time"] >> vhost_time;
-	na->SetVhost(data["vhost_ident"].astr(), data["vhost_host"].astr(), data["vhost_creator"].astr(), vhost_time);
+
+	na->SetVhost(vhost_ident, vhost_host, vhost_creator, vhost_time);
 	return na;
 }
 
diff --git a/src/nickcore.cpp b/src/nickcore.cpp
index f9ac3ef6c..304a40569 100644
--- a/src/nickcore.cpp
+++ b/src/nickcore.cpp
@@ -78,11 +78,9 @@ NickCore::~NickCore()
 	}
 }
 
-Serialize::Data NickCore::Serialize() const
+void NickCore::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;	
-
-	data["display"].SetMax(Config->NickLen) << this->display;
+	data["display"] << this->display;
 	data["pass"] << this->pass;
 	data["email"] << this->email;
 	data["greet"] << this->greet;
@@ -95,24 +93,27 @@ Serialize::Data NickCore::Serialize() const
 	data["memomax"] << this->memos.memomax;
 	for (unsigned i = 0; i < this->memos.ignores.size(); ++i)
 		data["memoignores"] << this->memos.ignores[i] << " ";
-	
-	return data;
 }
 
 Serializable* NickCore::Unserialize(Serializable *obj, Serialize::Data &data)
 {
 	NickCore *nc;
 
+	Anope::string sdisplay, sflags;
+
+	data["display"] >> sdisplay;
+	data["flags"] >> sflags;
+
 	if (obj)
 		nc = anope_dynamic_static_cast<NickCore *>(obj);
 	else
-		nc = new NickCore(data["display"].astr());
+		nc = new NickCore(sdisplay);
 
 	data["pass"] >> nc->pass;
 	data["email"] >> nc->email;
 	data["greet"] >> nc->greet;
 	data["language"] >> nc->language;
-	nc->FromString(data["flags"].astr());
+	nc->FromString(sflags);
 	{
 		Anope::string buf;
 		data["access"] >> buf;
diff --git a/src/socketengines/pipeengine_pipe.cpp b/src/pipeengine.cpp
index d56ffef55..6a5b8c3af 100644
--- a/src/socketengines/pipeengine_pipe.cpp
+++ b/src/pipeengine.cpp
@@ -48,15 +48,34 @@ Pipe::~Pipe()
 
 bool Pipe::ProcessRead()
 {
+	this->OnNotify();
+
 	char dummy[512];
 	while (read(this->GetFD(), dummy, 512) == 512);
-	this->OnNotify();
 	return true;
 }
 
+void Pipe::Write(const char *data, size_t sz)
+{
+	write(this->write_pipe, data, sz);
+}
+
+int Pipe::Read(char *data, size_t sz)
+{
+	return read(this->GetFD(), data, sz);
+}
+
+bool Pipe::SetWriteBlocking(bool state)
+{
+	int flags = fcntl(this->write_pipe, F_GETFL, 0);
+	if (state)
+		return !fcntl(this->write_pipe, F_SETFL, flags & ~O_NONBLOCK);
+	else
+		return !fcntl(this->write_pipe, F_SETFL, flags | O_NONBLOCK);
+}
+
 void Pipe::Notify()
 {
-	const char dummy = '*';
-	write(this->write_pipe, &dummy, 1);
+	this->Write("\0", 1);
 }
 
diff --git a/src/regchannel.cpp b/src/regchannel.cpp
index 3075ea301..43c51d783 100644
--- a/src/regchannel.cpp
+++ b/src/regchannel.cpp
@@ -34,20 +34,21 @@ template<> const Anope::string* Flags<ChannelInfoFlag>::flags_strings = ChannelI
 static const Anope::string AutoKickFlagString[] = { "AK_ISNICK", "" };
 template<> const Anope::string* Flags<AutoKickFlag>::flags_strings = AutoKickFlagString;
 
-Serialize::Data BadWord::Serialize() const
+void BadWord::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
-	data["ci"].SetMax(64)/*XXX*/ << this->ci->name;
-	data["word"].SetMax(512) << this->word;
-	data["type"].SetType(Serialize::DT_INT) << this->type;
-
-	return data;
+	data["ci"] << this->ci->name;
+	data["word"] << this->word;
+	data.SetType("type", Serialize::Data::DT_INT); data["type"] << this->type;
 }
 
 Serializable* BadWord::Unserialize(Serializable *obj, Serialize::Data &data)
 {
-	ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr());
+	Anope::string sci, sword;
+
+	data["ci"] >> sci;
+	data["word"] >> sword;
+
+	ChannelInfo *ci = ChannelInfo::Find(sci);
 	if (!ci)
 		return NULL;
 
@@ -62,7 +63,7 @@ Serializable* BadWord::Unserialize(Serializable *obj, Serialize::Data &data)
 		bw->type = static_cast<BadWordType>(n);
 	}
 	else
-		bw = ci->AddBadWord(data["word"].astr(), static_cast<BadWordType>(n));
+		bw = ci->AddBadWord(sword, static_cast<BadWordType>(n));
 	
 	return bw;
 }
@@ -71,38 +72,39 @@ AutoKick::AutoKick() : Serializable("AutoKick")
 {
 }
 
-Serialize::Data AutoKick::Serialize() const
+void AutoKick::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
-	data["ci"].SetMax(64)/*XXX*/ << this->ci->name;
+	data["ci"] << this->ci->name;
 	if (this->HasFlag(AK_ISNICK) && this->nc)
-		data["nc"].SetMax(Config->NickLen) << this->nc->display;
+		data["nc"] << this->nc->display;
 	else
-		data["mask"].SetMax(Config->NickLen) << this->mask;
+		data["mask"] << this->mask;
 	data["reason"] << this->reason;
 	data["creator"] << this->creator;
-	data["addtime"].SetType(Serialize::DT_INT) << this->addtime;
-	data["last_used"].SetType(Serialize::DT_INT) << this->last_used;
+	data.SetType("addtime", Serialize::Data::DT_INT); data["addtime"] << this->addtime;
+	data.SetType("last_used", Serialize::Data::DT_INT); data["last_used"] << this->last_used;
 	data["flags"] << this->ToString();
-
-	return data;
 }
 
 Serializable* AutoKick::Unserialize(Serializable *obj, Serialize::Data &data)
 {
-	ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr());
+	Anope::string sci, snc;
+
+	data["ci"] >> sci;
+	data["nc"] >> snc;
+
+	ChannelInfo *ci = ChannelInfo::Find(sci);
 	if (!ci)
 		return NULL;
 	
 	AutoKick *ak;
-	NickCore *nc = NickCore::Find(data["nc"].astr());
+	NickCore *nc = NickCore::Find(snc);
 	if (obj)
 	{
 		ak = anope_dynamic_static_cast<AutoKick *>(obj);
 		data["creator"] >> ak->creator;
 		data["reason"] >> ak->reason;
-		ak->nc = NickCore::Find(data["nc"].astr());
+		ak->nc = NickCore::Find(snc);
 		data["mask"] >> ak->mask;
 		data["addtime"] >> ak->addtime;
 		data["last_used"] >> ak->last_used;
@@ -113,12 +115,22 @@ Serializable* AutoKick::Unserialize(Serializable *obj, Serialize::Data &data)
 		data["addtime"] >> addtime;
 		data["last_used"] >> lastused;
 
+		Anope::string screator, sreason, smask;
+
+		data["creator"] >> screator;
+		data["reason"] >> sreason;
+		data["mask"] >> smask;
+
 		if (nc)	
-			ak = ci->AddAkick(data["creator"].astr(), nc, data["reason"].astr(), addtime, lastused);
+			ak = ci->AddAkick(screator, nc, sreason, addtime, lastused);
 		else
-			ak = ci->AddAkick(data["creator"].astr(), data["mask"].astr(), data["reason"].astr(), addtime, lastused);
+			ak = ci->AddAkick(screator, smask, sreason, addtime, lastused);
 	}
 
+	Anope::string sflags;
+	data["flags"] >> sflags;
+	ak->FromString(sflags);
+
 	return ak;
 }
 
@@ -126,27 +138,28 @@ ModeLock::ModeLock(ChannelInfo *ch, bool s, ChannelModeName n, const Anope::stri
 {
 }
 
-Serialize::Data ModeLock::Serialize() const
+void ModeLock::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
 	if (!this->ci)
-		return data;
+		return;
 
 	const Anope::string* ChannelModeNameStrings = Flags<ChannelModeName>::GetFlagStrings();
-	data["ci"].SetMax(64)/*XXX*/ << this->ci->name;
-	data["set"].SetMax(5) << this->set;
-	data["name"].SetMax(64) << ChannelModeNameStrings[this->name];
-	data["param"].SetMax(512) << this->param;
+	data["ci"] << this->ci->name;
+	data["set"] << this->set;
+	data["name"] << ChannelModeNameStrings[this->name];
+	data["param"] << this->param;
 	data["setter"] << this->setter;
-	data["created"].SetType(Serialize::DT_INT) << this->created;
-
-	return data;
+	data.SetType("created", Serialize::Data::DT_INT); data["created"] << this->created;
 }
 
 Serializable* ModeLock::Unserialize(Serializable *obj, Serialize::Data &data)
 {
-	ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr());
+	Anope::string sci, sname;
+	
+	data["ci"] >> sci;
+	data["name"] >> sname;
+
+	ChannelInfo *ci = ChannelInfo::Find(sci);
 	if (!ci)
 		return NULL;
 
@@ -154,7 +167,7 @@ Serializable* ModeLock::Unserialize(Serializable *obj, Serialize::Data &data)
 
 	const Anope::string* ChannelModeNameStrings = Flags<ChannelModeName>::GetFlagStrings();
 	for (unsigned i = 0; !ChannelModeNameStrings[i].empty(); ++i)
-		if (ChannelModeNameStrings[i] == data["name"].astr())
+		if (ChannelModeNameStrings[i] == sname)
 		{
 			name = static_cast<ChannelModeName>(i);
 			break;
@@ -182,7 +195,10 @@ Serializable* ModeLock::Unserialize(Serializable *obj, Serialize::Data &data)
 		time_t created;
 		data["created"] >> created;
 
-		ml = new ModeLock(ci, set, name, "", data["setter"].astr(), created);
+		Anope::string setter;
+		data["setter"] >> setter;
+
+		ml = new ModeLock(ci, set, name, "", setter, created);
 		data["param"] >> ml->param;
 
 		ci->mode_locks->insert(std::make_pair(ml->name, ml));
@@ -190,12 +206,10 @@ Serializable* ModeLock::Unserialize(Serializable *obj, Serialize::Data &data)
 	}
 }
 
-Serialize::Data LogSetting::Serialize() const
+void LogSetting::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
 	if (!ci)
-		return data;
+		return;
 
 	data["ci"] << ci->name;
 	data["service_name"] << service_name;
@@ -204,14 +218,16 @@ Serialize::Data LogSetting::Serialize() const
 	data["method"] << method;
 	data["extra"] << extra;
 	data["creator"] << creator;
-	data["created"].SetType(Serialize::DT_INT) << created;
-
-	return data;
+	data.SetType("created", Serialize::Data::DT_INT); data["created"] << created;
 }
 
 Serializable* LogSetting::Unserialize(Serializable *obj, Serialize::Data &data)
 {
-	ChannelInfo *ci = ChannelInfo::Find(data["ci"].astr());
+	Anope::string sci;
+	
+	data["ci"] >> sci;
+
+	ChannelInfo *ci = ChannelInfo::Find(sci);
 	if (ci == NULL)
 		return NULL;
 	
@@ -376,22 +392,20 @@ ChannelInfo::~ChannelInfo()
 		--this->founder->channelcount;
 }
 
-Serialize::Data ChannelInfo::Serialize() const
+void ChannelInfo::Serialize(Serialize::Data &data) const
 {
-	Serialize::Data data;
-
-	data["name"].SetMax(255) << this->name;
+	data["name"] << this->name;
 	if (this->founder)
 		data["founder"] << this->founder->display;
 	if (this->successor)
 		data["successor"] << this->successor->display;
 	data["description"] << this->desc;
-	data["time_registered"].SetType(Serialize::DT_INT) << this->time_registered;
-	data["last_used"].SetType(Serialize::DT_INT) << this->last_used;
+	data.SetType("time_registered", Serialize::Data::DT_INT); data["time_registered"] << this->time_registered;
+	data.SetType("last_used", Serialize::Data::DT_INT); data["last_used"] << this->last_used;
 	data["last_topic"] << this->last_topic;
 	data["last_topic_setter"] << this->last_topic_setter;
-	data["last_topic_time"].SetType(Serialize::DT_INT) << this->last_topic_time;
-	data["bantype"].SetType(Serialize::DT_INT) << this->bantype;
+	data.SetType("last_topic_time", Serialize::Data::DT_INT); data["last_topic_time"] << this->last_topic_time;
+	data.SetType("bantype", Serialize::Data::DT_INT); data["bantype"] << this->bantype;
 	data["flags"] << this->ToString();
 	data["botflags"] << this->botflags.ToString();
 	{
@@ -404,40 +418,44 @@ Serialize::Data ChannelInfo::Serialize() const
 		data["bi"] << this->bi->nick;
 	for (int i = 0; i < TTB_SIZE; ++i)
 		data["ttb"] << this->ttb[i] << " ";
-	data["