prosody-hg: plugins/muc/mod_muc.lua comparison

comparison plugins/muc/mod_muc.lua @ 6609:d2faaaca695d

Merge 0.10->trunk

author	Matthew Wild <mwild1@gmail.com>
date	Fri, 27 Mar 2015 22:24:57 +0000
parents	d016437e01bf
children	6728ad041761

comparison

equal deleted inserted replaced

-:b6e558febb7a
+:d2faaaca695d
 --
 -- This project is MIT/X11 licensed. Please see the
 -- COPYING file in the source package for more information.
 --
-local array = require "util.array";
 if module:get_host_type() ~= "component" then
 	error("MUC should be loaded as a component, please see http://prosody.im/doc/components", 0);
 end
-local muc_host = module:get_host();
-local muc_name = module:get_option("name");
-if type(muc_name) ~= "string" then muc_name = "Prosody Chatrooms"; end
-local restrict_room_creation = module:get_option("restrict_room_creation");
-if restrict_room_creation then
-	if restrict_room_creation == true then
-		restrict_room_creation = "admin";
-	elseif restrict_room_creation ~= "admin" and restrict_room_creation ~= "local" then
-		restrict_room_creation = nil;
-	end
-end
-local lock_rooms = module:get_option_boolean("muc_room_locking", false);
-local lock_room_timeout = module:get_option_number("muc_room_lock_timeout", 300);
 local muclib = module:require "muc";
-local muc_new_room = muclib.new_room;
+room_mt = muclib.room_mt; -- Yes, global.
+local iterators = require "util.iterators";
 local jid_split = require "util.jid".split;
 local jid_bare = require "util.jid".bare;
 local st = require "util.stanza";
-local uuid_gen = require "util.uuid".generate;
 local um_is_admin = require "core.usermanager".is_admin;
-local hosts = prosody.hosts;
+local rooms = module:shared "rooms";
-rooms = {};
-local rooms = rooms;
-local persistent_rooms_storage = module:open_store("persistent");
-local persistent_rooms = persistent_rooms_storage:get() or {};
-local room_configs = module:open_store("config");
--- Configurable options
-muclib.set_max_history_length(module:get_option_number("max_history_messages"));
 module:depends("disco");
-module:add_identity("conference", "text", muc_name);
+module:add_identity("conference", "text", module:get_option_string("name", "Prosody Chatrooms"));
 module:add_feature("http://jabber.org/protocol/muc");
+module:depends "muc_unique"
+module:require "muc/lock";
 local function is_admin(jid)
 	return um_is_admin(jid, module.host);
 end
-room_mt = muclib.room_mt; -- Yes, global.
+do -- Monkey patch to make server admins room owners
-local _set_affiliation = room_mt.set_affiliation;
+	local _get_affiliation = room_mt.get_affiliation;
-local _get_affiliation = room_mt.get_affiliation;
+	function room_mt:get_affiliation(jid)
-function muclib.room_mt:get_affiliation(jid)
+		if is_admin(jid) then return "owner"; end
-	if is_admin(jid) then return "owner"; end
+		return _get_affiliation(self, jid);
-	return _get_affiliation(self, jid);
+	end
-end
-function muclib.room_mt:set_affiliation(actor, jid, affiliation, callback, reason)
+	local _set_affiliation = room_mt.set_affiliation;
-	if is_admin(jid) then return nil, "modify", "not-acceptable"; end
+	function room_mt:set_affiliation(actor, jid, ...)
-	return _set_affiliation(self, actor, jid, affiliation, callback, reason);
+		if is_admin(jid) then return nil, "modify", "not-acceptable"; end
-end
+		return _set_affiliation(self, actor, jid, ...);
+	end
-local function room_route_stanza(room, stanza) module:send(stanza); end
+end
+local persistent = module:require "muc/persistent";
+local persistent_rooms_storage = module:open_store("persistent");
+local persistent_rooms = module:open_store("persistent", "map");
+local room_configs = module:open_store("config");
 local function room_save(room, forced)
 	local node = jid_split(room.jid);
-	persistent_rooms[room.jid] = room._data.persistent;
+	local is_persistent = persistent.get(room);
-	if room._data.persistent then
+	persistent_rooms:set(nil, room.jid, is_persistent);
+	if is_persistent then
 		local history = room._data.history;
 		room._data.history = nil;
 		local data = {
 			jid = room.jid;
 			_data = room._data;
 		room_configs:set(node, nil);
 		if not next(room._occupants) then -- Room empty
 			rooms[room.jid] = nil;
 		end
 	end
-	if forced then persistent_rooms_storage:set(nil, persistent_rooms); end
+end
-end
+-- Automatically destroy empty non-persistent rooms
-function create_room(jid)
+module:hook("muc-occupant-left",function(event)
-	local room = muc_new_room(jid);
+	local room = event.room
-	room.route_stanza = room_route_stanza;
+	if not room:has_occupant() and not persistent.get(room) then -- empty, non-persistent room
+		module:fire_event("muc-room-destroyed", { room = room });
+	end
+end);
+function track_room(room)
+	rooms[room.jid] = room;
+	-- When room is created, over-ride 'save' method
 	room.save = room_save;
-	rooms[jid] = room;
+end
-	if lock_rooms then
-		room.locked = true;
+local function restore_room(jid)
-		if lock_room_timeout and lock_room_timeout > 0 then
-			module:add_timer(lock_room_timeout, function ()
-				if room.locked then
-					room:destroy(); -- Not unlocked in time
-				end
-			end);
-		end
-	end
-	module:fire_event("muc-room-created", { room = room });
-	return room;
-end
-local persistent_errors = false;
-for jid in pairs(persistent_rooms) do
 	local node = jid_split(jid);
 	local data = room_configs:get(node);
 	if data then
-		local room = create_room(jid);
+		local room = muclib.new_room(jid);
 		room._data = data._data;
 		room._affiliations = data._affiliations;
-	else -- missing room data
+		track_room(room);
-		persistent_rooms[jid] = nil;
+		return room;
-		module:log("error", "Missing data for room '%s', removing from persistent room list", jid);
+	end
-		persistent_errors = true;
+end
-	end
-end
+function forget_room(room)
-if persistent_errors then persistent_rooms_storage:set(nil, persistent_rooms); end
+	local room_jid = room.jid;
+	local node = jid_split(room.jid);
-local host_room = muc_new_room(muc_host);
+	rooms[room_jid] = nil;
-host_room.route_stanza = room_route_stanza;
+	room_configs:set(node, nil);
-host_room.save = room_save;
+	if persistent.get(room) then
+		persistent_rooms:set(nil, room_jid, nil);
+	end
+end
+function get_room_from_jid(room_jid)
+	local room = rooms[room_jid];
+	if room == nil then
+		-- Check if in persistent storage
+		if persistent_rooms:get(nil, room_jid) then
+			room = restore_room(room_jid);
+			if room == nil then
+				module:log("error", "Missing data for room '%s', removing from persistent room list", room_jid);
+				persistent_rooms:set(nil, room_jid, nil);
+			end
+		end
+	end
+	return room
+end
+function each_room(local_only)
+	if not local_only then
+		for room_jid in pairs(persistent_rooms_storage:get(nil) or {}) do
+			if rooms[room_jid] == nil then -- Don't restore rooms that already exist
+				local room = restore_room(room_jid);
+				if room == nil then
+					module:log("error", "Missing data for room '%s', omitting from iteration", room_jid);
+				end
+			end
+		end
+	end
+	return iterators.values(rooms);
+end
 module:hook("host-disco-items", function(event)
 	local reply = event.reply;
 	module:log("debug", "host-disco-items called");
-	for jid, room in pairs(rooms) do
+	for room in each_room() do
 		if not room:get_hidden() then
-			reply:tag("item", {jid=jid, name=room:get_name()}):up();
+			reply:tag("item", {jid=room.jid, name=room:get_name()}):up();
 		end
 	end
 end);
-local function handle_to_domain(event)
+module:hook("muc-room-pre-create", function(event)
-	local origin, stanza = event.origin, event.stanza;
+	track_room(event.room);
-	local type = stanza.attr.type;
+end, -1000);
-	if type == "error" or type == "result" then return; end
-	if stanza.name == "iq" and type == "get" then
+module:hook("muc-room-destroyed",function(event)
-		local xmlns = stanza.tags[1].attr.xmlns;
+	return forget_room(event.room);
-		local node = stanza.tags[1].attr.node;
+end)
-		if xmlns == "http://jabber.org/protocol/muc#unique" then
-			origin.send(st.reply(stanza):tag("unique", {xmlns = xmlns}):text(uuid_gen())); -- FIXME Random UUIDs can theoretically have collisions
+do
-		else
+	local restrict_room_creation = module:get_option("restrict_room_creation");
-			origin.send(st.error_reply(stanza, "cancel", "service-unavailable")); -- TODO disco/etc
+	if restrict_room_creation == true then
-		end
+		restrict_room_creation = "admin";
-	else
+	end
-		host_room:handle_stanza(origin, stanza);
+	if restrict_room_creation then
-		--origin.send(st.error_reply(stanza, "cancel", "service-unavailable", "The muc server doesn't deal with messages and presence directed at it"));
+		local host_suffix = module.host:gsub("^[^%.]+%.", "");
-	end
+		module:hook("muc-room-pre-create", function(event)
-	return true;
+			local origin, stanza = event.origin, event.stanza;
-end
+			local user_jid = stanza.attr.from;
+			if not is_admin(user_jid) and not (
-function stanza_handler(event)
+				restrict_room_creation == "local" and
-	local origin, stanza = event.origin, event.stanza;
+				select(2, jid_split(user_jid)) == host_suffix
-	local bare = jid_bare(stanza.attr.to);
+			) then
-	local room = rooms[bare];
+				origin.send(st.error_reply(stanza, "cancel", "not-allowed"));
-	if not room then
+				return true;
-		if stanza.name ~= "presence" then
+			end
-			origin.send(st.error_reply(stanza, "cancel", "item-not-found"));
+		end);
-			return true;
+	end
-		end
+end
-		if not(restrict_room_creation) or
-		  is_admin(stanza.attr.from) or
+for event_name, method in pairs {
-		  (restrict_room_creation == "local" and select(2, jid_split(stanza.attr.from)) == module.host:gsub("^[^%.]+%.", "")) then
+	-- Normal room interactions
-			room = create_room(bare);
+	["iq-get/bare/http://jabber.org/protocol/disco#info:query"] = "handle_disco_info_get_query" ;
-		end
+	["iq-get/bare/http://jabber.org/protocol/disco#items:query"] = "handle_disco_items_get_query" ;
-	end
+	["iq-set/bare/http://jabber.org/protocol/muc#admin:query"] = "handle_admin_query_set_command" ;
-	if room then
+	["iq-get/bare/http://jabber.org/protocol/muc#admin:query"] = "handle_admin_query_get_command" ;
-		room:handle_stanza(origin, stanza);
+	["iq-set/bare/http://jabber.org/protocol/muc#owner:query"] = "handle_owner_query_set_to_room" ;
-		if not next(room._occupants) and not persistent_rooms[room.jid] then -- empty, non-persistent room
+	["iq-get/bare/http://jabber.org/protocol/muc#owner:query"] = "handle_owner_query_get_to_room" ;
-			module:fire_event("muc-room-destroyed", { room = room });
+	["message/bare"] = "handle_message_to_room" ;
-			rooms[bare] = nil; -- discard room
+	["presence/bare"] = "handle_presence_to_room" ;
-		end
+	-- Host room
-	else
+	["iq-get/host/http://jabber.org/protocol/disco#info:query"] = "handle_disco_info_get_query" ;
-		origin.send(st.error_reply(stanza, "cancel", "not-allowed"));
+	["iq-get/host/http://jabber.org/protocol/disco#items:query"] = "handle_disco_items_get_query" ;
-	end
+	["iq-set/host/http://jabber.org/protocol/muc#admin:query"] = "handle_admin_query_set_command" ;
-	return true;
+	["iq-get/host/http://jabber.org/protocol/muc#admin:query"] = "handle_admin_query_get_command" ;
-end
+	["iq-set/host/http://jabber.org/protocol/muc#owner:query"] = "handle_owner_query_set_to_room" ;
-module:hook("iq/bare", stanza_handler, -1);
+	["iq-get/host/http://jabber.org/protocol/muc#owner:query"] = "handle_owner_query_get_to_room" ;
-module:hook("message/bare", stanza_handler, -1);
+	["message/host"] = "handle_message_to_room" ;
-module:hook("presence/bare", stanza_handler, -1);
+	["presence/host"] = "handle_presence_to_room" ;
-module:hook("iq/full", stanza_handler, -1);
+	-- Direct to occupant (normal rooms and host room)
-module:hook("message/full", stanza_handler, -1);
+	["presence/full"] = "handle_presence_to_occupant" ;
-module:hook("presence/full", stanza_handler, -1);
+	["iq/full"] = "handle_iq_to_occupant" ;
-module:hook("iq/host", handle_to_domain, -1);
+	["message/full"] = "handle_message_to_occupant" ;
-module:hook("message/host", handle_to_domain, -1);
+} do
-module:hook("presence/host", handle_to_domain, -1);
+	module:hook(event_name, function (event)
+		local origin, stanza = event.origin, event.stanza;
-hosts[module.host].send = function(stanza) -- FIXME do a generic fix
+		local room_jid = jid_bare(stanza.attr.to);
-	if stanza.attr.type == "result" or stanza.attr.type == "error" then
+		local room = get_room_from_jid(room_jid);
-		module:send(stanza);
+		if room == nil then
-	else error("component.send only supports result and error stanzas at the moment"); end
+			-- Watch presence to create rooms
-end
+			if stanza.attr.type == nil and stanza.name == "presence" then
+				room = muclib.new_room(room_jid);
-hosts[module:get_host()].muc = { rooms = rooms };
+			else
+				origin.send(st.error_reply(stanza, "cancel", "not-allowed"));
-local saved = false;
+				return true;
-module.save = function()
+			end
-	saved = true;
+		end
-	return {rooms = rooms};
+		return room[method](room, origin, stanza);
-end
+	end, -2)
-module.restore = function(data)
+end
-	for jid, oldroom in pairs(data.rooms or {}) do
-		local room = create_room(jid);
-		room._jid_nick = oldroom._jid_nick;
-		room._occupants = oldroom._occupants;
-		room._data = oldroom._data;
-		room._affiliations = oldroom._affiliations;
-	end
-	hosts[module:get_host()].muc = { rooms = rooms };
-end
-function shutdown_room(room, stanza)
-	for nick, occupant in pairs(room._occupants) do
-		stanza.attr.from = nick;
-		for jid in pairs(occupant.sessions) do
-			stanza.attr.to = jid;
-			room:_route_stanza(stanza);
-			room._jid_nick[jid] = nil;
-		end
-		room._occupants[nick] = nil;
-	end
-end
 function shutdown_component()
-	if not saved then
+	local x = st.stanza("x", {xmlns = "http://jabber.org/protocol/muc#user"})
-		local stanza = st.presence({type = "unavailable"})
+		:tag("status", { code = "332"}):up();
-			:tag("x", {xmlns = "http://jabber.org/protocol/muc#user"})
+	for room in each_room(true) do
-				:tag("item", { affiliation='none', role='none' }):up()
+		room:clear(x);
-				:tag("status", { code = "332"}):up();
+	end
-		for roomjid, room in pairs(rooms) do
+end
-			shutdown_room(room, stanza);
-		end
-		shutdown_room(host_room, stanza);
-	end
-end
-module.unload = shutdown_component;
 module:hook_global("server-stopping", shutdown_component);
--- Ad-hoc commands
+do -- Ad-hoc commands
-module:depends("adhoc")
+	module:depends "adhoc";
-local t_concat = table.concat;
+	local t_concat = table.concat;
-local keys = require "util.iterators".keys;
+	local adhoc_new = module:require "adhoc".new;
-local adhoc_new = module:require "adhoc".new;
+	local adhoc_initial = require "util.adhoc".new_initial_data_form;
-local adhoc_initial = require "util.adhoc".new_initial_data_form;
+	local array = require "util.array";
-local dataforms_new = require "util.dataforms".new;
+	local dataforms_new = require "util.dataforms".new;
-local destroy_rooms_layout = dataforms_new {
+	local destroy_rooms_layout = dataforms_new {
-	title = "Destroy rooms";
+		title = "Destroy rooms";
-	instructions = "Select the rooms to destroy";
+		instructions = "Select the rooms to destroy";
-	{ name = "FORM_TYPE", type = "hidden", value = "http://prosody.im/protocol/muc#destroy" };
+		{ name = "FORM_TYPE", type = "hidden", value = "http://prosody.im/protocol/muc#destroy" };
-	{ name = "rooms", type = "list-multi", required = true, label = "Rooms to destroy:"};
+		{ name = "rooms", type = "list-multi", required = true, label = "Rooms to destroy:"};
-};
+	};
-local destroy_rooms_handler = adhoc_initial(destroy_rooms_layout, function()
+	local destroy_rooms_handler = adhoc_initial(destroy_rooms_layout, function()
-	return { rooms = array.collect(keys(rooms)):sort() };
+		return { rooms = array.collect(each_room()):pluck("jid"):sort(); };
-end, function(fields, errors)
+	end, function(fields, errors)
-	if errors then
+		if errors then
-		local errmsg = {};
+			local errmsg = {};
-		for name, err in pairs(errors) do
+			for name, err in pairs(errors) do
-			errmsg[#errmsg + 1] = name .. ": " .. err;
+				errmsg[#errmsg + 1] = name .. ": " .. err;
-		end
+			end
-		return { status = "completed", error = { message = t_concat(errmsg, "\n") } };
+			return { status = "completed", error = { message = t_concat(errmsg, "\n") } };
-	end
+		end
-	for _, room in ipairs(fields.rooms) do
+		for _, room in ipairs(fields.rooms) do
-		rooms[room]:destroy();
+			get_room_from_jid(room):destroy();
-		rooms[room] = nil;
+		end
-	end
+		return { status = "completed", info = "The following rooms were destroyed:\n"..t_concat(fields.rooms, "\n") };
-	return { status = "completed", info = "The following rooms were destroyed:\n"..t_concat(fields.rooms, "\n") };
+	end);
-end);
+	local destroy_rooms_desc = adhoc_new("Destroy Rooms", "http://prosody.im/protocol/muc#destroy", destroy_rooms_handler, "admin");
-local destroy_rooms_desc = adhoc_new("Destroy Rooms", "http://prosody.im/protocol/muc#destroy", destroy_rooms_handler, "admin");
+	module:provides("adhoc", destroy_rooms_desc);
-module:provides("adhoc", destroy_rooms_desc);
+end

Mercurial > prosody-hg

comparison plugins/muc/mod_muc.lua @ 6609:d2faaaca695d