Added LuaExpat XML parsing library

git-svn-id: http://svn.net-core.org/repos/t-engine4@1297 51575b47-30f0-44d4-a5cc-537603b46e54

@@ -58,7 +58,7 @@ for i, file in ipairs(fs.list("/settings/")) do
 end
 
 -- Load default keys
-engine.KeyBind:load("move,actions")
+engine.KeyBind:load("move,actions,debug")
 
 -- Load remaps
 if fs.exists("/keybinds.cfg") then

@@ -261,6 +261,15 @@ Now go and have some fun!]]
 	self.step:setKeyHandling()
 	self.step:setMouseHandling()
 
+	self.step.key:addBinds{
+		-- Lua console
+		LUA_CONSOLE = function()
+			if config.settings.tome.cheat then
+				self:registerDialog(require("engine.DebugConsole").new())
+			end
+		end,
+	}
+
 	if self.s_log then
 		local w, h = self.s_log:getSize()
 		self.mouse:registerZone(self.w - w, self.h - h, w, h, function(button)

+local configmanager = require "core.configmanager";
+local log = require "util.logger".init("certmanager");
+local ssl = ssl;
+local ssl_newcontext = ssl and ssl.newcontext;
+
+local setmetatable, tostring = setmetatable, tostring;
+
+local prosody = prosody;
+
+module "certmanager"
+
+-- These are the defaults if not overridden in the config
+local default_ssl_ctx = { mode = "client", protocol = "sslv23", capath = "/etc/ssl/certs", verify = "none", options = "no_sslv2"; };
+local default_ssl_ctx_in = { mode = "server", protocol = "sslv23", capath = "/etc/ssl/certs", verify = "none", options = "no_sslv2"; };
+
+local default_ssl_ctx_mt = { __index = default_ssl_ctx };
+local default_ssl_ctx_in_mt = { __index = default_ssl_ctx_in };
+
+-- Global SSL options if not overridden per-host
+local default_ssl_config = configmanager.get("*", "core", "ssl");
+
+function create_context(host, mode, config)
+	local ssl_config = config and config.core.ssl or default_ssl_config;
+	if ssl and ssl_config then
+		local ctx, err = ssl_newcontext(setmetatable(ssl_config, mode == "client" and default_ssl_ctx_mt or default_ssl_ctx_in_mt));
+		if not ctx then
+			err = err or "invalid ssl config"
+			local file = err:match("^error loading (.-) %(");
+			if file then
+				if file == "private key" then
+					file = ssl_config.key or "your private key";
+				elseif file == "certificate" then
+					file = ssl_config.certificate or "your certificate file";
+				end
+				local reason = err:match("%((.+)%)$") or "some reason";
+				if reason == "Permission denied" then
+					reason = "Check that the permissions allow Prosody to read this file.";
+				elseif reason == "No such file or directory" then
+					reason = "Check that the path is correct, and the file exists.";
+				elseif reason == "system lib" then
+					reason = "Previous error (see logs), or other system error.";
+				elseif reason == "(null)" or not reason then
+					reason = "Check that the file exists and the permissions are correct";
+				else
+					reason = "Reason: "..tostring(reason):lower();
+				end
+				log("error", "SSL/TLS: Failed to load %s: %s", file, reason);
+			else
+				log("error", "SSL/TLS: Error initialising for host %s: %s", host, err );
+			end
+			ssl = false
+        	end
+        	return ctx, err;
+	end
+	return nil;
+end
+
+function reload_ssl_config()
+	default_ssl_config = configmanager.get("*", "core", "ssl");
+end
+
+prosody.events.add_handler("config-reloaded", reload_ssl_config);
+
+return _M;

+-- Prosody IM
+-- Copyright (C) 2008-2010 Matthew Wild
+-- Copyright (C) 2008-2010 Waqas Hussain
+-- 
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+local prosody = _G.prosody;
+local log = require "util.logger".init("componentmanager");
+local certmanager = require "core.certmanager";
+local configmanager = require "core.configmanager";
+local modulemanager = require "core.modulemanager";
+local jid_split = require "util.jid".split;
+local fire_event = require "core.eventmanager".fire_event;
+local events_new = require "util.events".new;
+local st = require "util.stanza";
+local prosody, hosts = prosody, prosody.hosts;
+local ssl = ssl;
+local uuid_gen = require "util.uuid".generate;
+
+local pairs, setmetatable, type, tostring = pairs, setmetatable, type, tostring;
+
+local components = {};
+
+local disco_items = require "util.multitable".new();
+local NULL = {};
+
+module "componentmanager"
+
+local function default_component_handler(origin, stanza)
+	log("warn", "Stanza being handled by default component; bouncing error for: %s", stanza:top_tag());
+	if stanza.attr.type ~= "error" and stanza.attr.type ~= "result" then
+		origin.send(st.error_reply(stanza, "wait", "service-unavailable", "Component unavailable"));
+	end
+end
+
+function load_enabled_components(config)
+	local defined_hosts = config or configmanager.getconfig();
+		
+	for host, host_config in pairs(defined_hosts) do
+		if host ~= "*" and ((host_config.core.enabled == nil or host_config.core.enabled) and type(host_config.core.component_module) == "string") then
+			hosts[host] = create_component(host);
+			hosts[host].connected = false;
+			components[host] = default_component_handler;
+			local ok, err = modulemanager.load(host, host_config.core.component_module);
+			if not ok then
+				log("error", "Error loading %s component %s: %s", tostring(host_config.core.component_module), tostring(host), tostring(err));
+			else
+				fire_event("component-activated", host, host_config);
+				log("debug", "Activated %s component: %s", host_config.core.component_module, host);
+			end
+		end
+	end
+end
+
+if prosody and prosody.events then
+	prosody.events.add_handler("server-starting", load_enabled_components);
+end
+
+function handle_stanza(origin, stanza)
+	local node, host = jid_split(stanza.attr.to);
+	local component = nil;
+	if host then
+		if node then component = components[node.."@"..host]; end -- hack to allow hooking node@server
+		if not component then component = components[host]; end
+	end
+	if component then
+		log("debug", "%s stanza being handled by component: %s", stanza.name, host);
+		component(origin, stanza, hosts[host]);
+	else
+		log("error", "Component manager recieved a stanza for a non-existing component: "..tostring(stanza));
+		default_component_handler(origin, stanza);
+	end
+end
+
+function create_component(host, component, events)
+	-- TODO check for host well-formedness
+	local ssl_ctx, ssl_ctx_in;
+	if host and ssl then
+		-- We need to find SSL context to use...
+		-- Discussion in prosody@ concluded that
+		-- 1 level back is usually enough by default
+		local base_host = host:gsub("^[^%.]+%.", "");
+		if hosts[base_host] then
+			ssl_ctx = hosts[base_host].ssl_ctx;
+			ssl_ctx_in = hosts[base_host].ssl_ctx_in;
+		else
+			-- We have no cert, and no parent host to borrow a cert from
+			-- Use global/default cert if there is one
+			ssl_ctx = certmanager.create_context(host, "client");
+			ssl_ctx_in = certmanager.create_context(host, "server");
+		end
+	end
+	return { type = "component", host = host, connected = true, s2sout = {}, 
+			ssl_ctx = ssl_ctx, ssl_ctx_in = ssl_ctx_in, events = events or events_new(),
+			dialback_secret = configmanager.get(host, "core", "dialback_secret") or uuid_gen() };
+end
+
+function register_component(host, component, session)
+	if not hosts[host] or (hosts[host].type == 'component' and not hosts[host].connected) then
+		local old_events = hosts[host] and hosts[host].events;
+
+		components[host] = component;
+		hosts[host] = session or create_component(host, component, old_events);
+
+		-- Add events object if not already one
+		if not hosts[host].events then
+			hosts[host].events = old_events or events_new();
+		end
+
+		if not hosts[host].dialback_secret then
+			hosts[host].dialback_secret = configmanager.get(host, "core", "dialback_secret") or uuid_gen();
+		end
+
+		-- add to disco_items
+		if not(host:find("@", 1, true) or host:find("/", 1, true)) and host:find(".", 1, true) then
+			disco_items:set(host:sub(host:find(".", 1, true)+1), host, true);
+		end
+		modulemanager.load(host, "dialback");
+		modulemanager.load(host, "tls");
+		log("debug", "component added: "..host);
+		return session or hosts[host];
+	else
+		log("error", "Attempt to set component for existing host: "..host);
+	end
+end
+
+function deregister_component(host)
+	if components[host] then
+		modulemanager.unload(host, "tls");
+		modulemanager.unload(host, "dialback");
+		hosts[host].connected = nil;
+		local host_config = configmanager.getconfig()[host];
+		if host_config and ((host_config.core.enabled == nil or host_config.core.enabled) and type(host_config.core.component_module) == "string") then
+			-- Set default handler
+			components[host] = default_component_handler;
+		else
+			-- Component not in config, or disabled, remove
+			hosts[host] = nil; -- FIXME do proper unload of all modules and other cleanup before removing
+			components[host] = nil;
+		end
+		-- remove from disco_items
+		if not(host:find("@", 1, true) or host:find("/", 1, true)) and host:find(".", 1, true) then
+			disco_items:remove(host:sub(host:find(".", 1, true)+1), host);
+		end
+		log("debug", "component removed: "..host);
+		return true;
+	else
+		log("error", "Attempt to remove component for non-existing host: "..host);
+	end
+end
+
+function set_component_handler(host, handler)
+	components[host] = handler;
+end
+
+function get_children(host)
+	return disco_items:get(host) or NULL;
+end
+
+return _M;

+-- Prosody IM
+-- Copyright (C) 2008-2010 Matthew Wild
+-- Copyright (C) 2008-2010 Waqas Hussain
+-- 
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+
+
+local _G = _G;
+local 	setmetatable, loadfile, pcall, rawget, rawset, io, error, dofile, type, pairs, table, format =
+		setmetatable, loadfile, pcall, rawget, rawset, io, error, dofile, type, pairs, table, string.format;
+
+
+local eventmanager = require "core.eventmanager";
+
+module "configmanager"
+
+local parsers = {};
+
+local config = { ["*"] = { core = {} } };
+
+local global_config = config["*"];
+
+-- When host not found, use global
+setmetatable(config, { __index = function () return global_config; end});
+local host_mt = { __index = global_config };
+
+-- When key not found in section, check key in global's section
+function section_mt(section_name)
+	return { __index = 	function (t, k)
+									local section = rawget(global_config, section_name);
+									if not section then return nil; end
+									return section[k];
+							end };
+end
+
+function getconfig()
+	return config;
+end
+
+function get(host, section, key)
+	local sec = config[host][section];
+	if sec then
+		return sec[key];
+	end
+	return nil;
+end
+
+function set(host, section, key, value)
+	if host and section and key then
+		local hostconfig = rawget(config, host);
+		if not hostconfig then
+			hostconfig = rawset(config, host, setmetatable({}, host_mt))[host];
+		end
+		if not rawget(hostconfig, section) then
+			hostconfig[section] = setmetatable({}, section_mt(section));
+		end
+		hostconfig[section][key] = value;
+		return true;
+	end
+	return false;
+end
+
+function load(filename, format)
+	format = format or filename:match("%w+$");
+
+	if parsers[format] and parsers[format].load then
+		local f, err = io.open(filename);
+		if f then
+			local ok, err = parsers[format].load(f:read("*a"), filename);
+			f:close();
+			if ok then
+				eventmanager.fire_event("config-reloaded", { filename = filename, format = format });
+			end
+			return ok, "parser", err;
+		end
+		return f, "file", err;
+	end
+
+	if not format then
+		return nil, "file", "no parser specified";
+	else
+		return nil, "file", "no parser for "..(format);
+	end
+end
+
+function save(filename, format)
+end
+
+function addparser(format, parser)
+	if format and parser then
+		parsers[format] = parser;
+	end
+end
+
+-- _M needed to avoid name clash with local 'parsers'
+function _M.parsers()
+	local p = {};
+	for format in pairs(parsers) do
+		table.insert(p, format);
+	end
+	return p;
+end
+
+-- Built-in Lua parser
+do
+	local loadstring, pcall, setmetatable = _G.loadstring, _G.pcall, _G.setmetatable;
+	local setfenv, rawget, tostring = _G.setfenv, _G.rawget, _G.tostring;
+	parsers.lua = {};
+	function parsers.lua.load(data, filename)
+		local env;
+		-- The ' = true' are needed so as not to set off __newindex when we assign the functions below
+		env = setmetatable({ Host = true, host = true, VirtualHost = true, Component = true, component = true,
+							Include = true, include = true, RunScript = dofile }, { __index = function (t, k)
+												return rawget(_G, k) or
+														function (settings_table)
+															config[__currenthost or "*"][k] = settings_table;
+														end;
+										end,
+								__newindex = function (t, k, v)
+											set(env.__currenthost or "*", "core", k, v);
+										end});
+		
+		rawset(env, "__currenthost", "*") -- Default is global
+		function env.VirtualHost(name)
+			if rawget(config, name) and rawget(config[name].core, "component_module") then
+				error(format("Host %q clashes with previously defined %s Component %q, for services use a sub-domain like conference.%s",
+					name, config[name].core.component_module:gsub("^%a+$", { component = "external", muc = "MUC"}), name, name), 0);
+			end
+			rawset(env, "__currenthost", name);
+			-- Needs at least one setting to logically exist :)
+			set(name or "*", "core", "defined", true);
+		end
+		env.Host, env.host = env.VirtualHost, env.VirtualHost;
+		
+		function env.Component(name)
+			if rawget(config, name) and rawget(config[name].core, "defined") and not rawget(config[name].core, "component_module") then
+				error(format("Component %q clashes with previously defined Host %q, for services use a sub-domain like conference.%s",
+					name, name, name), 0);
+			end
+			set(name, "core", "component_module", "component");
+			-- Don't load the global modules by default
+			set(name, "core", "load_global_modules", false);
+			rawset(env, "__currenthost", name);
+	
+			return function (module)
+					if type(module) == "string" then
+						set(name, "core", "component_module", module);
+					end
+				end
+		end
+		env.component = env.Component;
+		
+		function env.Include(file)
+			local f, err = io.open(file);
+			if f then
+				local data = f:read("*a");
+				local ok, err = parsers.lua.load(data, file);
+				if not ok then error(err:gsub("%[string.-%]", file), 0); end
+			end
+			if not f then error("Error loading included "..file..": "..err, 0); end
+			return f, err;
+		end
+		env.include = env.Include;
+		
+		local chunk, err = loadstring(data, "@"..filename);
+		
+		if not chunk then
+			return nil, err;
+		end
+		
+		setfenv(chunk, env);
+		
+		local ok, err = pcall(chunk);
+		
+		if not ok then
+			return nil, err;
+		end
+		
+		return true;
+	end
+	
+end
+
+return _M;

+-- Prosody IM
+-- Copyright (C) 2008-2010 Matthew Wild
+-- Copyright (C) 2008-2010 Waqas Hussain
+-- 
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+
+local t_insert = table.insert;
+local ipairs = ipairs;
+
+module "eventmanager"
+
+local event_handlers = {};
+
+function add_event_hook(name, handler)
+	if not event_handlers[name] then
+		event_handlers[name] = {};
+	end
+	t_insert(event_handlers[name] , handler);
+end
+
+function fire_event(name, ...)
+	local event_handlers = event_handlers[name];
+	if event_handlers then
+		for name, handler in ipairs(event_handlers) do
+			handler(...);
+		end
+	end
+end
+
+return _M;
\ No newline at end of file

+-- Prosody IM
+-- Copyright (C) 2008-2010 Matthew Wild
+-- Copyright (C) 2008-2010 Waqas Hussain
+-- 
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+local ssl = ssl
+
+local hosts = hosts;
+local certmanager = require "core.certmanager";
+local configmanager = require "core.configmanager";
+local eventmanager = require "core.eventmanager";
+local modulemanager = require "core.modulemanager";
+local events_new = require "util.events".new;
+
+local uuid_gen = require "util.uuid".generate;
+
+if not _G.prosody.incoming_s2s then
+	require "core.s2smanager";
+end
+local incoming_s2s = _G.prosody.incoming_s2s;
+
+local log = require "util.logger".init("hostmanager");
+
+local pairs, setmetatable = pairs, setmetatable;
+
+module "hostmanager"
+
+local hosts_loaded_once;
+
+local function load_enabled_hosts(config)
+	local defined_hosts = config or configmanager.getconfig();
+	local activated_any_host;
+	
+	for host, host_config in pairs(defined_hosts) do
+		if host ~= "*" and host_config.core.enabled ~= false and not host_config.core.component_module then
+			activated_any_host = true;
+			activate(host, host_config);
+		end
+	end
+	
+	if not activated_any_host then
+		log("error", "No active VirtualHost entries in the config file. This may cause unexpected behaviour as no modules will be loaded.");
+	end
+	
+	eventmanager.fire_event("hosts-activated", defined_hosts);
+	hosts_loaded_once = true;
+end
+
+eventmanager.add_event_hook("server-starting", load_enabled_hosts);
+
+function activate(host, host_config)
+	hosts[host] = {type = "local", connected = true, sessions = {},
+			host = host, s2sout = {}, events = events_new(),
+			disallow_s2s = configmanager.get(host, "core", "disallow_s2s")
+				or (configmanager.get(host, "core", "anonymous_login")
+				and (configmanager.get(host, "core", "disallow_s2s") ~= false));
+			dialback_secret = configmanager.get(host, "core", "dialback_secret") or uuid_gen();
+	              };
+	for option_name in pairs(host_config.core) do
+		if option_name:match("_ports$") or option_name:match("_interface$") then
+			log("warn", "%s: Option '%s' has no effect for virtual hosts - put it in the server-wide section instead", host, option_name);
+		end
+	end
+	
+	hosts[host].ssl_ctx = certmanager.create_context(host, "client", host_config); -- for outgoing connections
+	hosts[host].ssl_ctx_in = certmanager.create_context(host, "server", host_config); -- for incoming connections
+	
+	log((hosts_loaded_once and "info") or "debug", "Activated host: %s", host);
+	eventmanager.fire_event("host-activated", host, host_config);
+end
+
+function deactivate(host, reason)
+	local host_session = hosts[host];
+	log("info", "Deactivating host: %s", host);
+	eventmanager.fire_event("host-deactivating", host, host_session);
+	
+	reason = reason or { condition = "host-gone", text = "This server has stopped serving "..host };
+	
+	-- Disconnect local users, s2s connections
+	if host_session.sessions then
+		for username, user in pairs(host_session.sessions) do
+			for resource, session in pairs(user.sessions) do
+				log("debug", "Closing connection for %s@%s/%s", username, host, resource);
+				session:close(reason);
+			end
+		end
+	end
+	if host_session.s2sout then
+		for remotehost, session in pairs(host_session.s2sout) do
+			if session.close then
+				log("debug", "Closing outgoing connection to %s", remotehost);
+				if session.srv_hosts then session.srv_hosts = nil; end
+				session:close(reason);
+			end
+		end
+	end
+	for remote_session in pairs(incoming_s2s) do
+		if remote_session.to_host == host then
+			log("debug", "Closing incoming connection from %s", remote_session.from_host or "<unknown>");
+			remote_session:close(reason);
+		end
+	end
+
+	if host_session.modules then
+		for module in pairs(host_session.modules) do
+			modulemanager.unload(host, module);
+		end
+	end
+
+	hosts[host] = nil;
+	eventmanager.fire_event("host-deactivated", host);
+	log("info", "Deactivated host: %s", host);
+end
+
+function getconfig(name)
+end
+
+return _M;

+-- Prosody IM
+-- Copyright (C) 2008-2010 Matthew Wild
+-- Copyright (C) 2008-2010 Waqas Hussain
+-- 
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+
+local format, rep = string.format, string.rep;
+local pcall = pcall;
+local debug = debug;
+local tostring, setmetatable, rawset, pairs, ipairs, type = 
+	tostring, setmetatable, rawset, pairs, ipairs, type;
+local io_open, io_write = io.open, io.write;
+local math_max, rep = math.max, string.rep;
+local os_date, os_getenv = os.date, os.getenv;
+local getstyle, getstring = require "util.termcolours".getstyle, require "util.termcolours".getstring;
+
+if os.getenv("__FLUSH_LOG") then
+	local io_flush = io.flush;
+	local _io_write = io_write;
+	io_write = function(...) _io_write(...); io_flush(); end
+end
+
+local config = require "core.configmanager";
+local eventmanager = require "core.eventmanager";
+local logger = require "util.logger";
+local debug_mode = config.get("*", "core", "debug");
+
+_G.log = logger.init("general");
+
+module "loggingmanager"
+
+-- The log config used if none specified in the config file
+local default_logging = { { to = "console" , levels = { min = (debug_mode and "debug") or "info" } } };
+local default_file_logging = { { to = "file", levels = { min = (debug_mode and "debug") or "info" }, timestamps = true } };
+local default_timestamp = "%b %d %H:%M:%S";
+-- The actual config loggingmanager is using
+local logging_config = config.get("*", "core", "log") or default_logging;
+
+local apply_sink_rules;
+local log_sink_types = setmetatable({}, { __newindex = function (t, k, v) rawset(t, k, v); apply_sink_rules(k); end; });
+local get_levels;
+local logging_levels = { "debug", "info", "warn", "error", "critical" }
+
+-- Put a rule into action. Requires that the sink type has already been registered.
+-- This function is called automatically when a new sink type is added [see apply_sink_rules()]
+local function add_rule(sink_config)
+	local sink_maker = log_sink_types[sink_config.to];
+	if sink_maker then
+		if sink_config.levels and not sink_config.source then
+			-- Create sink
+			local sink = sink_maker(sink_config);
+			
+			-- Set sink for all chosen levels
+			for level in pairs(get_levels(sink_config.levels)) do
+				logger.add_level_sink(level, sink);
+			end
+		elseif sink_config.source and not sink_config.levels then
+			logger.add_name_sink(sink_config.source, sink_maker(sink_config));
+		elseif sink_config.source and sink_config.levels then
+			local levels = get_levels(sink_config.levels);
+			local sink = sink_maker(sink_config);
+			logger.add_name_sink(sink_config.source,
+				function (name, level, ...)
+					if levels[level] then
+						return sink(name, level, ...);
+					end
+				end);
+		else
+			-- All sources
+			-- Create sink
+			local sink = sink_maker(sink_config);
+			
+			-- Set sink for all levels
+			for _, level in pairs(logging_levels) do
+				logger.add_level_sink(level, sink);
+			end
+		end
+	else
+		-- No such sink type
+	end
+end
+
+-- Search for all rules using a particular sink type, and apply
+-- them. Called automatically when a new sink type is added to
+-- the log_sink_types table.
+function apply_sink_rules(sink_type)
+	if type(logging_config) == "table" then
+		for _, sink_config in pairs(logging_config) do
+			if sink_config.to == sink_type then
+				add_rule(sink_config);
+			end
+		end
+	elseif type(logging_config) == "string" and (not logging_config:match("^%*")) and sink_type == "file" then
+		-- User specified simply a filename, and the "file" sink type
+		-- was just added
+		for _, sink_config in pairs(default_file_logging) do
+			sink_config.filename = logging_config;
+			add_rule(sink_config);
+			sink_config.filename = nil;
+		end
+	elseif type(logging_config) == "string" and logging_config:match("^%*(.+)") == sink_type then
+		-- Log all levels (debug+) to this sink
+		add_rule({ levels = { min = "debug" }, to = sink_type });
+	end
+end
+
+
+
+--- Helper function to get a set of levels given a "criteria" table
+function get_levels(criteria, set)
+	set = set or {};
+	if type(criteria) == "string" then
+		set[criteria] = true;
+		return set;
+	end
+	local min, max = criteria.min, criteria.max;
+	if min or max then
+		local in_range;
+		for _, level in ipairs(logging_levels) do
+			if min == level then
+				set[level] = true;
+				in_range = true;
+			elseif max == level then
+				set[level] = true;
+				return set;
+			elseif in_range then
+				set[level] = true;
+			end
+		end
+	end
+	
+	for _, level in ipairs(criteria) do
+		set[level] = true;
+	end
+	return set;
+end
+
+--- Definition of built-in logging sinks ---
+
+-- Null sink, must enter log_sink_types *first*
+function log_sink_types.nowhere()
+	return function () return false; end;
+end
+
+-- Column width for "source" (used by stdout and console)
+local sourcewidth = 20;
+
+function log_sink_types.stdout()
+	local timestamps = config.timestamps;
+	
+	if timestamps == true then
+		timestamps = default_timestamp; -- Default format
+	end
+	
+	return function (name, level, message, ...)
+		sourcewidth = math_max(#name+2, sourcewidth);
+		local namelen = #name;
+		if timestamps then
+			io_write(os_date(timestamps), " ");
+		end
+		if ... then
+			io_write(name, rep(" ", sourcewidth-namelen), level, "\t", format(message, ...), "\n");
+		else
+			io_write(name, rep(" ", sourcewidth-namelen), level, "\t", message, "\n");
+		end
+	end
+end
+
+do
+	local do_pretty_printing = not os_getenv("WINDIR");
+	
+	local logstyles = {};
+	if do_pretty_printing then
+		logstyles["info"] = getstyle("bold");
+		logstyles["warn"] = getstyle("bold", "yellow");
+		logstyles["error"] = getstyle("bold", "red");
+	end
+	function log_sink_types.console(config)
+		-- Really if we don't want pretty colours then just use plain stdout
+		if not do_pretty_printing then
+			return log_sink_types.stdout(config);
+		end
+		
+		local timestamps = config.timestamps;
+
+		if timestamps == true then
+			timestamps = default_timestamp; -- Default format
+		end
+
+		return function (name, level, message, ...)
+			sourcewidth = math_max(#name+2, sourcewidth);
+			local namelen = #name;
+			
+			if timestamps then
+				io_write(os_date(timestamps), " ");
+			end
+			if ... then
+				io_write(name, rep(" ", sourcewidth-namelen), getstring(logstyles[level], level), "\t", format(message, ...), "\n");
+			else
+				io_write(name, rep(" ", sourcewidth-namelen), getstring(logstyles[level], level), "\t", message, "\n");
+			end
+		end
+	end
+end
+
+local empty_function = function () end;
+function log_sink_types.file(config)
+	local log = config.filename;
+	local logfile = io_open(log, "a+");
+	if not logfile then
+		return empty_function;
+	end
+	local write, flush = logfile.write, logfile.flush;
+
+	eventmanager.add_event_hook("reopen-log-files", function ()
+			if logfile then
+				logfile:close();
+			end
+			logfile = io_open(log, "a+");
+			if not logfile then
+				write, flush = empty_function, empty_function;
+			else
+				write, flush = logfile.write, logfile.flush;
+			end
+		end);
+
+	local timestamps = config.timestamps;
+
+	if timestamps == nil or timestamps == true then
+		timestamps = default_timestamp; -- Default format
+	end
+
+	return function (name, level, message, ...)
+		if timestamps then
+			write(logfile, os_date(timestamps), " ");
+		end
+		if ... then
+			write(logfile, name, "\t", level, "\t", format(message, ...), "\n");
+		else
+			write(logfile, name, "\t" , level, "\t", message, "\n");
+		end
+		flush(logfile);
+	end;
+end
+
+function register_sink_type(name, sink_maker)
+	local old_sink_maker = log_sink_types[name];
+	log_sink_types[name] = sink_maker;
+	return old_sink_maker;
+end
+
+return _M;

+-- Prosody IM
+-- Copyright (C) 2008-2010 Matthew Wild
+-- Copyright (C) 2008-2010 Waqas Hussain
+-- 
+-- This project is MIT/X11 licensed. Please see the
+-- COPYING file in the source package for more information.
+--
+
+local plugin_dir = CFG_PLUGINDIR or "./plugins/";
+
+local logger = require "util.logger";
+local log = logger.init("modulemanager");
+local eventmanager = require "core.eventmanager";
+local config = require "core.configmanager";
+local multitable_new = require "util.multitable".new;
+local st = require "util.stanza";
+local pluginloader = require "util.pluginloader";
+
+local hosts = hosts;
+local prosody = prosody;
+
+local loadfile, pcall, xpcall = loadfile, pcall, xpcall;
+local setmetatable, setfenv, getfenv = setmetatable, setfenv, getfenv;
+local pairs, ipairs = pairs, ipairs;
+local t_insert, t_concat = table.insert, table.concat;
+local type = type;
+local next = next;
+local rawget = rawget;
+local error = error;
+local tostring, tonumber = tostring, tonumber;
+
+local debug_traceback = debug.traceback;
+local unpack, select = unpack, select;
+pcall = function(f, ...)
+	local n = select("#", ...);
+	local params = {...};
+	return xpcall(function() f(unpack(params, 1, n)) end, function(e) return tostring(e).."\n"..debug_traceback(); end);
+end
+
+local array, set = require "util.array", require "util.set";
+
+local autoload_modules = {"presence", "message", "iq"};
+
+-- We need this to let modules access the real global namespace
+local _G = _G;
+
+module "modulemanager"
+
+api = {};
+local api = api; -- Module API container
+
+local modulemap = { ["*"] = {} };
+
+local stanza_handlers = multitable_new();
+local handler_info = {};
+
+local modulehelpers = setmetatable({}, { __index = _G });
+
+local handler_table = multitable_new();
+local hooked = multitable_new();
+local hooks = multitable_new();
+local event_hooks = multitable_new();
+
+local NULL = {};
+
+-- Load modules when a host is activated
+function load_modules_for_host(host)
+	local disabled_set = {};
+	local modules_disabled = config.get(host, "core", "modules_disabled");
+	if modules_disabled then
+		for _, module in ipairs(modules_disabled) do
+			disabled_set[module] = true;
+		end
+	end
+
+	-- Load auto-loaded modules for this host
+	if hosts[host].type == "local" then
+		for _, module in ipairs(autoload_modules) do
+			if not disabled_set[module] then
+				load(host, module);
+			end
+		end
+	end
+
+	-- Load modules from global section
+	if config.get(host, "core", "load_global_modules") ~= false then
+		local modules_enabled = config.get("*", "core", "modules_enabled");
+		if modules_enabled then
+			for _, module in ipairs(modules_enabled) do
+				if not disabled_set[module] and not is_loaded(host, module) then
+					load(host, module);
+				end
+			end
+		end
+	end
+	
+	-- Load modules from just this host
+	local modules_enabled = config.get(host, "core", "modules_enabled");
+	if modules_enabled and modules_enabled ~= config.get("*", "core", "modules_enabled") then
+		for _, module in pairs(modules_enabled) do
+			if not is_loaded(host, module) then
+				load(host, module);
+			end
+		end
+	end
+end
+eventmanager.add_event_hook("host-activated", load_modules_for_host);
+eventmanager.add_event_hook("component-activated", load_modules_for_host);
+--
+
+function load(host, module_name, config)
+	if not (host and module_name) then
+		return nil, "insufficient-parameters";
+	end
+	
+	if not modulemap[host] then
+		modulemap[host] = {};
+	end
+	
+	if modulemap[host][module_name] then
+		log("warn", "%s is already loaded for %s, so not loading again", module_name, host);
+		return nil, "module-already-loaded";
+	elseif modulemap["*"][module_name] then
+		return nil, "global-module-already-loaded";
+	end
+	
+
+	local mod, err = pluginloader.load_code(module_name);
+	if not mod then
+		log("error", "Unable to load module '%s': %s", module_name or "nil", err or "nil");
+		return nil, err;
+	end
+
+	local _log = logger.init(host..":"..module_name);
+	local api_instance = setmetatable({ name = module_name, host = host, config = config,  _log = _log, log = function (self, ...) return _log(...); end }, { __index = api });
+
+	local pluginenv = setmetatable({ module = api_instance }, { __index = _G });
+	api_instance.environment = pluginenv;
+	
+	setfenv(mod, pluginenv);
+	if not hosts[host] then
+		local create_component = _G.require "core.componentmanager".create_component;
+		hosts[host] = create_component(host);
+		hosts[host].connected = false;
+		log("debug", "Created new component: %s", host);
+	end
+	hosts[host].modules = modulemap[host];
+	modulemap[host][module_name] = pluginenv;
+	
+	local success, err = pcall(mod);
+	if success then
+		if module_has_method(pluginenv, "load") then
+			success, err = call_module_method(pluginenv, "load");
+			if not success then
+				log("warn", "Error loading module '%s' on '%s': %s", module_name, host, err or "nil");
+			end
+		end
+
+		-- Use modified host, if the module set one
+		if api_instance.host == "*" and host ~= "*" then
+			modulemap[host][module_name] = nil;
+			modulemap["*"][module_name] = pluginenv;
+			api_instance:set_global();
+		end
+	else
+		log("error", "Error initializing module '%s' on '%s': %s", module_name, host, err or "nil");
+	end
+	if success then
+		(hosts[api_instance.host] or prosody).events.fire_event("module-loaded", { module = module_name, host = host });
+		return true;
+	else -- load failed, unloading
+		unload(api_instance.host, module_name);
+		return nil, err;
+	end
+end
+
+function get_module(host, name)
+	return modulemap[host] and modulemap[host][name];
+end
+
+function is_loaded(host, name)
+	return modulemap[host] and modulemap[host][name] and true;
+end
+
+function unload(host, name, ...)
+	local mod = get_module(host, name);
+	if not mod then return nil, "module-not-loaded"; end
+	
+	if module_has_method(mod, "unload") then
+		local ok, err = call_module_method(mod, "unload");
+		if (not ok) and err then
+			log("warn", "Non-fatal error unloading module '%s' on '%s': %s", name, host, err);
+		end
+	end
+	local params = handler_table:get(host, name); -- , {module.host, origin_type, tag, xmlns}
+	for _, param in pairs(params or NULL) do
+		local handlers = stanza_handlers:get(param[1], param[2], param[3], param[4]);
+		if handlers then
+			handler_info[handlers[1]] = nil;
+			stanza_handlers:remove(param[1], param[2], param[3], param[4]);
+		end
+	end
+	event_hooks:remove(host, name);
+	-- unhook event handlers hooked by module:hook
+	for event, handlers in pairs(hooks:get(host, name) or NULL) do
+		for handler in pairs(handlers or NULL) do
+			(hosts[host] or prosody).events.remove_handler(event, handler);
+		end
+	end
+	hooks:remove(host, name);
+	if mod.module.items then -- remove items
+		for key,t in pairs(mod.module.items) do
+			for i = #t,1,-1 do
+				local value = t[i];
+				t[i] = nil;
+				hosts[host].events.fire_event("item-removed/"..key, {source = self, item = value});
+			end
+		end
+	end
+	modulemap[host][name] = nil;
+	(hosts[host] or prosody).events.fire_event("module-unloaded", { module = name, host = host });
+	return true;
+end
+
+function reload(host, name, ...)
+	local mod = get_module(host, name);
+	if not mod then return nil, "module-not-loaded"; end
+
+	local _mod, err = pluginloader.load_code(name); -- checking for syntax errors
+	if not _mod then
+		log("error", "Unable to load module '%s': %s", name or "nil", err or "nil");
+		return nil, err;
+	end
+
+	local saved;
+
+	if module_has_method(mod, "save") then
+		local ok, ret, err = call_module_method(mod, "save");
+		if ok then
+			saved = ret;
+		else
+			log("warn", "Error saving module '%s:%s' state: %s", host, module, ret);
+			if not config.get(host, "core", "force_module_reload") then
+				log("warn", "Aborting reload due to error, set force_module_reload to ignore this");
+				return nil, "save-state-failed";
+			else
+				log("warn", "Continuing with reload (using the force)");
+			end
+		end
+	end
+
+	unload(host, name, ...);
+	local ok, err = load(host, name, ...);
+	if ok then
+		mod = get_module(host, name);
+		if module_has_method(mod, "restore") then
+			local ok, err = call_module_method(mod, "restore", saved or {})
+			if (not ok) and err then
+				log("warn", "Error restoring module '%s' from '%s': %s", name, host, err);
+			end
+		end
+		return true;
+	end
+	return ok, err;
+end
+
+function handle_stanza(host, origin, stanza)
+	local name, xmlns, origin_type = stanza.name, stanza.attr.xmlns or "jabber:client", origin.type;
+	if name == "iq" and xmlns == "jabber:client" then
+		if stanza.attr.type == "get" or stanza.attr.type == "set" then
+			xmlns = stanza.tags[1].attr.xmlns or "jabber:client";
+			log("debug", "Stanza of type %s from %s has xmlns: %s", name, origin_type, xmlns);
+		else
+			log("debug", "Discarding %s from %s of type: %s", name, origin_type, stanza.attr.type);
+			return true;
+		end
+	end
+	local handlers = stanza_handlers:get(host, origin_type, name, xmlns);
+	if not handlers then handlers = stanza_handlers:get("*", origin_type, name, xmlns); end
+	if handlers then
+		log("debug", "Passing stanza to mod_%s", handler_info[handlers[1]].name);
+		(handlers[1])(origin, stanza);
+		return true;
+	else
+		if stanza.attr.xmlns == nil then
+			log("debug", "Unhandled %s stanza: %s; xmlns=%s", origin.type, stanza.name, xmlns); -- we didn't handle it
+			if stanza.attr.type ~= "error" and stanza.attr.type ~= "result" then
+				origin.send(st.error_reply(stanza, "cancel", "service-unavailable"));
+			end
+		elseif not((name == "features" or name == "error") and xmlns == "http://etherx.jabber.org/streams") then -- FIXME remove check once we handle S2S features
+			log("warn", "Unhandled %s stream element: %s; xmlns=%s: %s", origin.type, stanza.name, xmlns, tostring(stanza)); -- we didn't handle it
+			origin:close("unsupported-stanza-type");
+		end
+	end
+end
+
+function module_has_method(module, method)
+	return type(module.module[method]) == "function";
+end
+
+function call_module_method(module, method, ...)
+	if module_has_method(module, method) then
+		local f = module.module[method];
+		return pcall(f, ...);
+	else
+		return false, "no-such-method";
+	end
+end
+
+----- API functions exposed to modules -----------
+-- Must all be in api.*
+
+-- Returns the name of the current module
+function api:get_name()
+	return self.name;
+end
+
+-- Returns the host that the current module is serving
+function api:get_host()
+	return self.host;
+end
+
+function api:get_host_type()
+	return hosts[self.host].type;
+end
+
+function api:set_global()
+	self.host = "*";
+	-- Update the logger
+	local _log = logger.init("mod_"..self.name);
+	self.log = function (self, ...) return _log(...); end;
+	self._log = _log;
+end
+
+local function _add_handler(module, origin_type, tag, xmlns, handler)
+	local handlers = stanza_handlers:get(module.host, origin_type, tag, xmlns);
+	local msg = (tag == "iq") and "namespace" or "payload namespace";
+	if not handlers then
+		stanza_handlers:add(module.host, origin_type, tag, xmlns, handler);
+		handler_info[handler] = module;
+		handler_table:add(module.host, module.name, {module.host, origin_type, tag, xmlns});
+		--module:log("debug", "I now handle tag '%s' [%s] with %s '%s'", tag, origin_type, msg, xmlns);
+	else
+		module:log("warn", "I wanted to handle tag '%s' [%s] with %s '%s' but mod_%s already handles that", tag, origin_type, msg, xmlns, handler_info[handlers[1]].module.name);
+	end
+end
+
+function api:add_handler(origin_type, tag, xmlns, handler)
+	if not (origin_type and tag and xmlns and handler) then return false; end
+	if type(origin_type) == "table" then
+		for _, origin_type in ipairs(origin_type) do
+			_add_handler(self, origin_type, tag, xmlns, handler);
+		end
+	else
+		_add_handler(self, origin_type, tag, xmlns, handler);
+	end
+end
+function api:add_iq_handler(origin_type, xmlns, handler)
+	self:add_handler(origin_type, "iq", xmlns, handler);
+end
+
+function api:add_feature(xmlns)
+	self:add_item("feature", xmlns);
+end
+function api:add_identity(category, type, name)
+	self:add_item("identity", {category = category, type = type, name = name});
+end
+
+local event_hook = function(host, mod_name, event_name, ...)
+	if type((...)) == "table" and (...).host and (...).host ~= host then return; end
+	for handler in pairs(event_hooks:get(host, mod_name, event_name) or NULL) do
+		handler(...);
+	end
+end;
+function api:add_event_hook(name, handler)
+	if not hooked:get(self.host, self.name, name) then
+		eventmanager.add_event_hook(name, function(...) event_hook(self.host, self.name, name, ...); end);
+		hooked:set(self.host, self.name, name, true);
+	end
+	event_hooks:set(self.host, self.name, name, handler, true);
+end
+
+function api:fire_event(...)
+	return (hosts[self.host] or prosody).events.fire_event(...);
+end
+
+function api:hook(event, handler, priority)
+	hooks:set(self.host, self.name, event, handler, true);
+	(hosts[self.host] or prosody).events.add_handler(event, handler, priority);
+end
+
+function api:hook_stanza(xmlns, name, handler, priority)
+	if not handler and type(name) == "function" then
+		-- If only 2 options then they specified no xmlns
+		xmlns, name, handler, priority = nil, xmlns, name, handler;
+	elseif not (handler and name) then
+		self:log("warn", "Error: Insufficient parameters to module:hook_stanza()");
+		return;
+	end
+	return api.hook(self, "stanza/"..(xmlns and (xmlns..":") or "")..name, function (data) return handler(data.origin, data.stanza, data); end, priority);
+end
+
+function api:require(lib)
+	local f, n = pluginloader.load_code(self.name, lib..".lib.lua");
+	if not f then
+		f, n = pluginloader.load_code(lib, lib..".lib.lua");
+	end
+	if not f then error("Failed to load plugin library '"..lib.."', error: "..n); end -- FIXME better error message
+	setfenv(f, self.environment);
+	return f();
+end
+
+function api:get_option(name, default_value)
+	local value = config.get(self.host, self.name, name);
+	if value == nil then
+		value = config.get(self.host, "core", name);
+		if value == nil then
+			value = default_value;
+		end
+	end
+	return value;
+end
+
+function api:get_option_string(name, default_value)
+	local value = self:get_option(name, default_value);
+	if type(value) == "table" then
+		if #value > 1 then
+			self:log("error", "Config option '%s' does not take a list, using just the first item", name);
+		end
+		value = value[