16 files changed, 806 insertions, 3 deletions
diff --git a/src/Common/RequestManager.h b/src/Common/RequestManager.h
index 4704a0f..aef6b90 100644
--- a/src/Common/RequestManager.h
+++ b/src/Common/RequestManager.h
@@ -70,12 +70,12 @@ class MAD_COMMON_EXPORT RequestManager : private boost::noncopyable {
 
 
 
-    template<class T> class RequestHandlerFactory : public RequestHandlerGroup {
+    template<typename T> class RequestHandlerFactory0 : public RequestHandlerGroup {
       private:
         std::set<std::string> types;
 
       public:
-        RequestHandlerFactory(const std::string &type) {
+        RequestHandlerFactory0(const std::string &type) {
           types.insert(type);
         }
 
@@ -88,6 +88,25 @@ class MAD_COMMON_EXPORT RequestManager : private boost::noncopyable {
         }
     };
 
+    template<typename T, typename T1> class RequestHandlerFactory1 : public RequestHandlerGroup {
+      private:
+      std::set<std::string> types;
+      T1 arg1;
+
+      public:
+      RequestHandlerFactory1(const std::string &type, T1 argT1) : arg1(argT1) {
+        types.insert(type);
+      }
+
+      virtual const std::set<std::string>& getPacketTypes() {
+        return types;
+      }
+
+      virtual boost::shared_ptr<RequestHandler> createRequestHandler(Application *application, const std::string& /*type*/) {
+        return boost::shared_ptr<RequestHandler>(new T(application, arg1));
+      }
+    };
+
     Application *application;
 
     boost::shared_mutex mutex;
@@ -146,7 +165,11 @@ class MAD_COMMON_EXPORT RequestManager : private boost::noncopyable {
     }
 
     template <class T> void registerPacketType(const std::string &type) {
-      registerRequestHandlerGroup(boost::shared_ptr<RequestHandlerFactory<T> >(new RequestHandlerFactory<T>(type)));
+      registerRequestHandlerGroup(boost::shared_ptr<RequestHandlerFactory0<T> >(new RequestHandlerFactory0<T>(type)));
+    }
+
+    template <class T, class T1> void registerPacketType(const std::string &type, T1 arg1) {
+        registerRequestHandlerGroup(boost::shared_ptr<RequestHandlerFactory1<T, T1> >(new RequestHandlerFactory1<T, T1>(type, arg1)));
     }
 
     void unregisterPacketType(const std::string &type) {
diff --git a/src/mad-server.conf b/src/mad-server.conf
index 1fb02e2..d83f9b4 100644
--- a/src/mad-server.conf
+++ b/src/mad-server.conf
@@ -13,6 +13,8 @@ LoadModule "UserDBBackendMysql"
 LoadModule "UserConfigBackendHome"
 LoadModule "UserConfigBackendKrb5"
 
+LoadModule "UserListManager"
+
 Log Console {
   Level "verbose"
 }
diff --git a/src/modules/CMakeLists.txt b/src/modules/CMakeLists.txt
index 2f497de..6681ad7 100644
--- a/src/modules/CMakeLists.txt
+++ b/src/modules/CMakeLists.txt
@@ -53,6 +53,8 @@ if(MYSQL_FOUND)
 add_subdirectory(UserDBBackendMysql)
 endif(MYSQL_FOUND)
 
+add_subdirectory(UserListManager)
+
 SET(STATIC_MODULE_LOADERS "")
 SET(STATIC_MODULE_LIST "")
 
diff --git a/src/modules/UserListManager/CMakeLists.txt b/src/modules/UserListManager/CMakeLists.txt
new file mode 100644
index 0000000..0ab429f
--- /dev/null
+++ b/src/modules/UserListManager/CMakeLists.txt
@@ -0,0 +1,14 @@
+include_directories(${INCLUDES})
+
+mad_module(UserListManager
+  RequestHandlers/UserListRequestHandlerGroup.cpp RequestHandlers/UserListRequestHandlerGroup.h
+  RequestHandlers/UserListUploadRequestHandler.cpp RequestHandlers/UserListUploadRequestHandler.h
+  
+  Module.cpp Module.h
+  UserList.h
+  UserListEntry.h
+  UserListManager.cpp UserListManager.h
+  Util.cpp Util.h
+)
+
+mad_module_libraries(UserListManager)
diff --git a/src/modules/UserListManager/Module.cpp b/src/modules/UserListManager/Module.cpp
new file mode 100644
index 0000000..2145a32
--- /dev/null
+++ b/src/modules/UserListManager/Module.cpp
@@ -0,0 +1,39 @@
+/*
+ * Module.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "../export.h"
+
+#include "Module.h"
+
+#include <Server/Application.h>
+
+extern "C" {
+
+MAD_MODULE_EXPORT Mad::Common::Module* UserListManager_create(Mad::Common::Application *application) {
+  Mad::Server::Application *serverApp = dynamic_cast<Mad::Server::Application*>(application);
+
+  if(!serverApp) {
+    application->log(Mad::Core::Logger::LOG_ERROR, "UserListManager: This module can be used with mad-server only.");
+    return 0;
+  }
+
+  return new Mad::Modules::UserListManager::Module(serverApp);
+}
+
+}
diff --git a/src/modules/UserListManager/Module.h b/src/modules/UserListManager/Module.h
new file mode 100644
index 0000000..035cdaa
--- /dev/null
+++ b/src/modules/UserListManager/Module.h
@@ -0,0 +1,44 @@
+/*
+ * Module.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_MODULE_H_
+#define MAD_MODULES_USERLISTMANAGER_MODULE_H_
+
+#include "UserListManager.h"
+#include <Common/Module.h>
+
+#include <boost/scoped_ptr.hpp>
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+
+class Module : public Common::Module {
+  private:
+    boost::scoped_ptr<UserListManager> userListManager;
+
+  public:
+    Module(Server::Application *application) : userListManager(new UserListManager(application)) {}
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_MODULE_H_ */
diff --git a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp
new file mode 100644
index 0000000..98d2815
--- /dev/null
+++ b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.cpp
@@ -0,0 +1,77 @@
+/*
+ * UserListRequestHandlerGroup.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UserListRequestHandlerGroup.h"
+#include "../UserListManager.h"
+#include "../Util.h"
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+namespace RequestHandlers {
+
+void UserListRequestHandlerGroup::handleUserListListRequest(boost::shared_ptr<const Common::XmlData> /*packet*/, Common::XmlData *ret, Common::Connection *connection) {
+  if(!connection->isAuthenticated())
+    throw(Core::Exception(Core::Exception::PERMISSION));
+
+  const std::set<std::string> &userLists = userListManager->getUserLists();
+
+  ret->setType("OK");
+  Common::XmlData::List *list = ret->createList("userLists");
+
+  for(std::set<std::string>::const_iterator userList = userLists.begin(); userList != userLists.end(); ++userList) {
+    Common::XmlData::List::iterator entry = list->addEntry();
+
+    entry->set("name", *userList);
+  }
+
+}
+
+void UserListRequestHandlerGroup::handleUserListDownloadRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) {
+  if(!connection->isAuthenticated())
+    throw(Core::Exception(Core::Exception::PERMISSION));
+
+  boost::shared_ptr<UserList> userList = userListManager->loadUserList(packet->get<const std::string&>("name"));
+  if(!userList)
+    throw(Core::Exception(Core::Exception::NOT_FOUND));
+
+  ret->setType("OK");
+  Util::serializeUserList(userList.get(), ret);
+}
+
+void UserListRequestHandlerGroup::handleUserListRemoveRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection) {
+  if(!connection->isAuthenticated())
+    throw(Core::Exception(Core::Exception::PERMISSION));
+
+  userListManager->removeUserList(packet->get<const std::string&>("name"));
+
+  ret->setType("OK");
+}
+
+UserListRequestHandlerGroup::UserListRequestHandlerGroup(Server::Application *application0, UserListManager *userListManager0)
+: application(application0), userListManager(userListManager0) {
+  registerHandler("ListUserLists", boost::bind(&UserListRequestHandlerGroup::handleUserListListRequest, this, _1, _2, _3));
+  registerHandler("DownloadUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListDownloadRequest, this, _1, _2, _3));
+  registerHandler("RemoveUserList", boost::bind(&UserListRequestHandlerGroup::handleUserListRemoveRequest, this, _1, _2, _3));
+}
+
+}
+}
+}
+}
diff --git a/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h
new file mode 100644
index 0000000..2aeda6b
--- /dev/null
+++ b/src/modules/UserListManager/RequestHandlers/UserListRequestHandlerGroup.h
@@ -0,0 +1,58 @@
+/*
+ * UserListRequestHandlerGroup.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_
+#define MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_
+
+#include "../../export.h"
+
+#include <Common/RequestHandlers/SimpleRequestHandlerGroup.h>
+
+namespace Mad {
+
+namespace Server {
+class Application;
+}
+
+namespace Modules {
+namespace UserListManager {
+
+class UserListManager;
+
+namespace RequestHandlers {
+
+class MAD_MODULE_EXPORT UserListRequestHandlerGroup  : public Common::RequestHandlers::SimpleRequestHandlerGroup {
+  private:
+    Server::Application *application;
+    UserListManager *userListManager;
+
+    void handleUserListListRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection);
+    void handleUserListDownloadRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection);
+    void handleUserListRemoveRequest(boost::shared_ptr<const Common::XmlData> packet, Common::XmlData *ret, Common::Connection *connection);
+
+  public:
+    UserListRequestHandlerGroup(Server::Application *application0, UserListManager *userListManager0);
+};
+
+}
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTREQUESTHANDLERGROUP_H_ */
diff --git a/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp
new file mode 100644
index 0000000..9d01b5e
--- /dev/null
+++ b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.cpp
@@ -0,0 +1,83 @@
+/*
+ * UserListUploadRequestHandler.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UserListUploadRequestHandler.h"
+#include "../UserListManager.h"
+#include "../Util.h"
+
+#include <boost/date_time/posix_time/posix_time.hpp>
+
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+namespace RequestHandlers {
+
+void UserListUploadRequestHandler::handlePacket(boost::shared_ptr<const Common::XmlData> packet) {
+  if(packet->getType() == "Cancel") {
+    Common::XmlData ret;
+    ret.setType("OK");
+    sendPacket(ret);
+
+    signalFinished();
+    return;
+  }
+  else if(packet->getType() != "UploadUserList") {
+    getApplication()->log(Core::Logger::LOG_ERROR, "Received an unexpected packet.");
+
+    Common::XmlData ret;
+    ret.setType("Error");
+    ret.set("ErrorCode", Core::Exception::UNEXPECTED_PACKET);
+
+    sendPacket(ret);
+
+    signalFinished();
+    return;
+  }
+
+  if(!getConnection()->isAuthenticated())
+    throw(Core::Exception(Core::Exception::PERMISSION));
+
+  if(name.empty()) { // Request
+    name = packet->get<const std::string&>("name");
+
+    if(name.empty())
+      name = boost::posix_time::to_simple_string(boost::posix_time::second_clock::universal_time());
+
+    Common::XmlData ret;
+    ret.setType("Continue");
+    ret.set("exists", userListManager->existsUserList(name));
+    sendPacket(ret);
+  }
+  else { // Upload
+    boost::shared_ptr<UserList> userList = Util::deserializeUserList(packet.get());
+    userListManager->storeUserList(name, userList.get());
+
+    Common::XmlData ret;
+    ret.setType("OK");
+    sendPacket(ret);
+
+    signalFinished();
+  }
+}
+
+}
+}
+}
+}
diff --git a/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h
new file mode 100644
index 0000000..933d4a5
--- /dev/null
+++ b/src/modules/UserListManager/RequestHandlers/UserListUploadRequestHandler.h
@@ -0,0 +1,51 @@
+/*
+ * UserListUploadRequestHandler.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_
+#define MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_
+
+#include <Common/RequestHandler.h>
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+
+class UserListManager;
+
+namespace RequestHandlers {
+
+class UserListUploadRequestHandler : public Common::RequestHandler {
+  private:
+    std::string name;
+
+    UserListManager *userListManager;
+
+  protected:
+    virtual void handlePacket(boost::shared_ptr<const Common::XmlData> packet);
+
+  public:
+    UserListUploadRequestHandler(Common::Application *application, UserListManager *userListManager0) : Common::RequestHandler(application), userListManager(userListManager0) {}
+};
+
+}
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_REQUESTHANDLERS_USERLISTUPLOADREQUESTHANDLER_H_ */
diff --git a/src/modules/UserListManager/UserList.h b/src/modules/UserListManager/UserList.h
new file mode 100644
index 0000000..6ca3de4
--- /dev/null
+++ b/src/modules/UserListManager/UserList.h
@@ -0,0 +1,40 @@
+/*
+ * UserList.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_USERLIST_H_
+#define MAD_MODULES_USERLISTMANAGER_USERLIST_H_
+
+#include "UserListEntry.h"
+
+#include <list>
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+
+class UserList : public std::list<UserListEntry> {
+  public:
+    UserList() {}
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_USERLIST_H_ */
diff --git a/src/modules/UserListManager/UserListEntry.h b/src/modules/UserListManager/UserListEntry.h
new file mode 100644
index 0000000..719787f
--- /dev/null
+++ b/src/modules/UserListManager/UserListEntry.h
@@ -0,0 +1,89 @@
+/*
+ * UserListEntry.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_USERLISTENTRY_H_
+#define MAD_MODULES_USERLISTMANAGER_USERLISTENTRY_H_
+
+#include <map>
+#include <set>
+#include <string>
+
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+
+class UserListEntry {
+  private:
+    std::string name;
+    std::string group;
+
+    std::map<std::string, std::string> details;
+
+  public:
+    UserListEntry(const std::string &name0 = std::string(), const std::string &group0 = std::string()) : name(name0), group(group0) {}
+
+    const std::string& getName() const {
+      return name;
+    }
+
+    void setName(const std::string &newName) {
+      name = newName;
+    }
+
+    const std::string& getGroup() const {
+      return group;
+    }
+
+    void setGroup(const std::string &newGroup) {
+      group = newGroup;
+    }
+
+    std::set<std::string> getDetailList() const {
+      std::set<std::string> ret;
+
+      for(std::map<std::string, std::string>::const_iterator it = details.begin(); it != details.end(); ++it)
+        ret.insert(it->first);
+
+      return ret;
+    }
+
+    std::string getDetail(const std::string &name) const {
+      std::map<std::string, std::string>::const_iterator it = details.find(name);
+      if(it != details.end())
+        return it->second;
+      else
+        return std::string();
+    }
+
+    void setDetail(const std::string &name, const std::string &value) {
+      details.erase(name);
+      details.insert(std::make_pair(name, value));
+    }
+
+    void unsetDetail(const std::string &name) {
+      details.erase(name);
+    }
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_USERLISTENTRY_H_ */
diff --git a/src/modules/UserListManager/UserListManager.cpp b/src/modules/UserListManager/UserListManager.cpp
new file mode 100644
index 0000000..c6e2c64
--- /dev/null
+++ b/src/modules/UserListManager/UserListManager.cpp
@@ -0,0 +1,84 @@
+/*
+ * UserListManager.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "UserListManager.h"
+#include "Util.h"
+#include "RequestHandlers/UserListRequestHandlerGroup.h"
+#include "RequestHandlers/UserListUploadRequestHandler.h"
+
+#include <Server/Application.h>
+#include <Common/RequestManager.h>
+#include <Common/StorageManager.h>
+#include <Core/ConfigManager.h>
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+
+UserListManager::UserListManager(Server::Application *application0) : application(application0), requestHandlerGroup(new RequestHandlers::UserListRequestHandlerGroup(application, this)) {
+  application->getConfigManager()->registerConfigurable(this);
+}
+
+UserListManager::~UserListManager() {
+  application->getRequestManager()->unregisterPacketType("UploadUserList");
+  application->getRequestManager()->unregisterRequestHandlerGroup(requestHandlerGroup);
+  application->getConfigManager()->unregisterConfigurable(this);
+}
+
+
+void UserListManager::configFinished() {
+  userLists = application->getStorageManager()->list("UserList");
+
+  application->getRequestManager()->registerRequestHandlerGroup(requestHandlerGroup);
+  application->getRequestManager()->registerPacketType<RequestHandlers::UserListUploadRequestHandler>("UploadUserList", this);
+}
+
+
+const std::set<std::string>& UserListManager::getUserLists() const {
+  return userLists;
+}
+
+
+bool UserListManager::existsUserList(const std::string &name) {
+  return application->getStorageManager()->exists("UserList", name);
+}
+
+boost::shared_ptr<UserList> UserListManager::loadUserList(const std::string &name) {
+  boost::shared_ptr<Common::XmlData> data = application->getStorageManager()->load("UserList", name);
+
+  if(!data)
+    return boost::shared_ptr<UserList>();
+
+  return Util::deserializeUserList(data.get());
+}
+
+void UserListManager::storeUserList(const std::string &name, const UserList *list) {
+  Common::XmlData data;
+
+  Util::serializeUserList(list, &data);
+  application->getStorageManager()->store("UserList", name, &data);
+}
+
+void UserListManager::removeUserList(const std::string &name) {
+  application->getStorageManager()->remove("UserList", name);
+}
+
+}
+}
+}
diff --git a/src/modules/UserListManager/UserListManager.h b/src/modules/UserListManager/UserListManager.h
new file mode 100644
index 0000000..b31b27a
--- /dev/null
+++ b/src/modules/UserListManager/UserListManager.h
@@ -0,0 +1,76 @@
+/*
+ * UserListManager.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_USERLISTMANAGER_H_
+#define MAD_MODULES_USERLISTMANAGER_USERLISTMANAGER_H_
+
+#include "../export.h"
+
+#include <Core/Configurable.h>
+
+#include <boost/noncopyable.hpp>
+#include <boost/shared_ptr.hpp>
+
+#include <set>
+
+namespace Mad {
+
+namespace Server {
+class Application;
+}
+
+namespace Modules {
+namespace UserListManager {
+
+namespace RequestHandlers {
+class UserListRequestHandlerGroup;
+}
+
+class UserList;
+
+class MAD_MODULE_EXPORT UserListManager : private Core::Configurable, private boost::noncopyable {
+  private:
+    Server::Application *application;
+
+    boost::shared_ptr<RequestHandlers::UserListRequestHandlerGroup> requestHandlerGroup;
+
+    std::set<std::string> userLists;
+
+  protected:
+    virtual void configFinished();
+
+  public:
+    virtual int getPriority() const {return -1;}
+
+    UserListManager(Server::Application *application0);
+    virtual ~UserListManager();
+
+    const std::set<std::string>& getUserLists() const;
+
+    bool existsUserList(const std::string &name);
+    boost::shared_ptr<UserList> loadUserList(const std::string &name);
+    void storeUserList(const std::string &name, const UserList *list);
+    void removeUserList(const std::string &name);
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_USERLISTMANAGER_H_ */
diff --git a/src/modules/UserListManager/Util.cpp b/src/modules/UserListManager/Util.cpp
new file mode 100644
index 0000000..f9b6a55
--- /dev/null
+++ b/src/modules/UserListManager/Util.cpp
@@ -0,0 +1,70 @@
+/*
+ * Util.cpp
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "Util.h"
+#include "UserList.h"
+
+#include <Common/XmlData.h>
+
+namespace Mad {
+namespace Modules {
+namespace UserListManager {
+
+void Util::serializeUserList(const UserList *list, Common::XmlData *data) {
+  Common::XmlData::List *userList = data->createList("users");
+
+  for(UserList::const_iterator user = list->begin(); user != list->end(); ++user) {
+    Common::XmlData::List::iterator entry = userList->addEntry();
+
+    std::set<std::string> details = user->getDetailList();
+    for(std::set<std::string>::iterator detail = details.begin(); detail != details.end(); ++detail)
+      entry->set(*detail, user->getDetail(*detail));
+
+    entry->set("name", user->getName());
+    entry->set("group", user->getGroup());
+  }
+}
+
+boost::shared_ptr<UserList> Util::deserializeUserList(const Common::XmlData *data) {
+  boost::shared_ptr<UserList> users(new UserList);
+
+  const Common::XmlData::List *userList = data->getList("users");
+
+  if(userList) {
+    for(Common::XmlData::List::const_iterator user = userList->begin(); user != userList->end(); ++user) {
+      UserListEntry entry(user->get<const std::string&>("name"), user->get<const std::string&>("group"));
+
+      std::set<std::string> details = user->getChildren();
+      for(std::set<std::string>::iterator detail = details.begin(); detail != details.end(); ++detail) {
+        if(*detail == "user" || *detail == "group")
+          continue;
+
+        entry.setDetail(*detail, user->get<const std::string&>(*detail));
+      }
+
+      users->push_back(entry);
+    }
+  }
+
+  return users;
+}
+
+}
+}
+}
diff --git a/src/modules/UserListManager/Util.h b/src/modules/UserListManager/Util.h
new file mode 100644
index 0000000..6af35cc
--- /dev/null
+++ b/src/modules/UserListManager/Util.h
@@ -0,0 +1,51 @@
+/*
+ * Util.h
+ *
+ * Copyright (C) 2009 Matthias Schiffer <matthias@gamezock.de>
+ *
+ * This program is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU Lesser General Public License as published by the
+ * Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef MAD_MODULES_USERLISTMANAGER_UTIL_H_
+#define MAD_MODULES_USERLISTMANAGER_UTIL_H_
+
+#include "../export.h"
+
+#include <boost/shared_ptr.hpp>
+
+namespace Mad {
+
+namespace Common {
+class XmlData;
+}
+
+namespace Modules {
+namespace UserListManager {
+
+class UserList;
+
+class MAD_MODULE_EXPORT Util {
+  private:
+    Util();
+
+  public:
+    static void serializeUserList(const UserList *list, Common::XmlData *data);
+    static boost::shared_ptr<UserList> deserializeUserList(const Common::XmlData *data);
+};
+
+}
+}
+}
+
+#endif /* MAD_MODULES_USERLISTMANAGER_UTIL_H_ */