Merge roster & presence from waqas

4 files changed, 213 insertions, 28 deletions

diff --git a/core/rostermanager.lua b/core/rostermanager.lua
index 5f06a308..26a14256 100644
--- a/core/rostermanager.lua
+++ b/core/rostermanager.lua
@@ -7,14 +7,18 @@ end
 local setmetatable = setmetatable;
 local format = string.format;
 local loadfile, setfenv, pcall = loadfile, setfenv, pcall;
+local pairs, ipairs = pairs, ipairs;
+
+local hosts = hosts;
 
 require "util.datamanager"
 
 local datamanager = datamanager;
+local st = require "util.stanza";
 
 module "rostermanager"
 
-function getroster(username, host)
+--[[function getroster(username, host)
 	return { 
 			["mattj@localhost"] = true,
 			["tobias@getjabber.ath.cx"] = true,
@@ -22,7 +26,81 @@ function getroster(username, host)
 			["thorns@getjabber.ath.cx"] = true, 
 			["idw@getjabber.ath.cx"] = true, 
 		}
---	return datamanager.load(username, host, "roster") or {};
+	--return datamanager.load(username, host, "roster") or {};
+end]]
+
+function add_to_roster(session, jid, item)
+	if session.roster then
+		local old_item = session.roster[jid];
+		session.roster[jid] = item;
+		if save_roster(session.username, session.host) then
+			return true;
+		else
+			session.roster[jid] = old_item;
+			return nil, "wait", "internal-server-error", "Unable to save roster";
+		end
+	else
+		return nil, "auth", "not-authorized", "Session's roster not loaded";
+	end
+end
+
+function remove_from_roster(session, jid)
+	if session.roster then
+		local old_item = session.roster[jid];
+		session.roster[jid] = nil;
+		if save_roster(session.username, session.host) then
+			return true;
+		else
+			session.roster[jid] = old_item;
+			return nil, "wait", "internal-server-error", "Unable to save roster";
+		end
+	else
+		return nil, "auth", "not-authorized", "Session's roster not loaded";
+	end
+end
+
+function roster_push(username, host, jid)
+	if hosts[host] and hosts[host].sessions[username] and hosts[host].sessions[username].roster then
+		local item = hosts[host].sessions[username].roster[jid];
+		local stanza = st.iq({type="set"});
+		stanza:tag("query", {xmlns = "jabber:iq:roster"});
+		if item then
+			stanza:tag("item", {jid = jid, subscription = item.subscription, name = item.name});
+			for group in pairs(item.groups) do
+				stanza:tag("group"):text(group):up();
+			end
+		else
+			stanza:tag("item", {jid = jid, subscription = "remove"});
+		end
+		stanza:up();
+		stanza:up();
+		-- stanza ready
+		for _, session in pairs(hosts[host].sessions[username].sessions) do
+			if session.interested then
+				-- FIXME do we need to set stanza.attr.to?
+				session.send(stanza);
+			end
+		end
+	end
+end
+
+function load_roster(username, host)
+	if hosts[host] and hosts[host].sessions[username] then
+		local roster = hosts[host].sessions[username].roster;
+		if not roster then
+			roster = datamanager.load(username, host, "roster") or {};
+			hosts[host].sessions[username].roster = roster;
+		end
+		return roster;
+	end
+	-- Attempt to load roster for non-loaded user
+end
+
+function save_roster(username, host)
+	if hosts[host] and hosts[host].sessions[username] and hosts[host].sessions[username].roster then
+		return datamanager.store(username, host, "roster", hosts[host].sessions[username].roster);
+	end
+	return nil;
 end
 
 return _M;
\ No newline at end of file
diff --git a/core/servermanager.lua b/core/servermanager.lua
index c1e075db..aba3f5d5 100644
--- a/core/servermanager.lua
+++ b/core/servermanager.lua
@@ -10,11 +10,13 @@ function handle_stanza(origin, stanza)
 	-- Use plugins
 	if not modulemanager.handle_stanza(origin, stanza) then
 		if stanza.name == "iq" then
-			local reply = st.reply(stanza);
-			reply.attr.type = "error";
-			reply:tag("error", { type = "cancel" })
-				:tag("service-unavailable", { xmlns = xmlns_stanzas });
-			send(origin, reply);
+			if stanza.attr.type ~= "result" and stanza.attr.type ~= "error" then
+				send(origin, st.error_reply(stanza, "cancel", "service-unavailable"));
+			end
+		elseif stanza.name == "message" then
+			send(origin, st.error_reply(stanza, "cancel", "service-unavailable"));
+		elseif stanza.name ~= "presence" then
+			error("Unknown stanza");
 		end
 	end
 end
diff --git a/core/sessionmanager.lua b/core/sessionmanager.lua
index 3a5625cb..8bdb93d0 100644
--- a/core/sessionmanager.lua
+++ b/core/sessionmanager.lua
@@ -12,7 +12,7 @@ local modulemanager = require "core.modulemanager";
 local log = require "util.logger".init("sessionmanager");
 local error = error;
 local uuid_generate = require "util.uuid".uuid_generate;
-local rm_getroster = require "core.rostermanager".getroster
+local rm_load_roster = require "core.rostermanager".load_roster;
 
 local newproxy = newproxy;
 local getmetatable = getmetatable;
@@ -84,7 +84,7 @@ function bind_resource(session, resource)
 	else
 		if hosts[session.host].sessions[session.username].sessions[resource] then
 			-- Resource conflict
-			return false, "conflict";
+			return false, "conflict"; -- TODO kick old resource
 		end
 	end
 	
@@ -92,7 +92,7 @@ function bind_resource(session, resource)
 	session.full_jid = session.username .. '@' .. session.host .. '/' .. resource;
 	hosts[session.host].sessions[session.username].sessions[resource] = session;
 	
-	session.roster = rm_getroster(session.username, session.host);
+	session.roster = rm_load_roster(session.username, session.host);
 	
 	return true;
 end
diff --git a/core/stanza_router.lua b/core/stanza_router.lua
index e6085595..100239c6 100644
--- a/core/stanza_router.lua
+++ b/core/stanza_router.lua
@@ -9,15 +9,20 @@ local log = require "util.logger".init("stanzarouter")
 
 local st = require "util.stanza";
 local send = require "core.sessionmanager".send_to_session;
+local user_exists = require "core.usermanager".user_exists;
 
-require "util.jid"
-local jid_split = jid.split;
+local jid_split = require "util.jid".split;
+local print = print;
 
 function core_process_stanza(origin, stanza)
 	log("debug", "Received: "..tostring(stanza))
 	-- TODO verify validity of stanza (as well as JID validity)
 	if stanza.name == "iq" and not(#stanza.tags == 1 and stanza.tags[1].attr.xmlns) then
-		error("Invalid IQ");
+		if stanza.attr.type == "set" or stanza.attr.type == "get" then
+			error("Invalid IQ");
+		elseif #stanza.tags > 1 or not(stanza.attr.type == "error" or stanza.attr.type == "result") then
+			error("Invalid IQ");
+		end
 	end
 
 	if origin.type == "c2s" and not origin.full_jid
@@ -26,13 +31,50 @@ function core_process_stanza(origin, stanza)
 		error("Client MUST bind resource after auth");
 	end
 
-	
 	local to = stanza.attr.to;
-	stanza.attr.from = origin.full_jid -- quick fix to prevent impersonation
+	stanza.attr.from = origin.full_jid; -- quick fix to prevent impersonation (FIXME this would be incorrect when the origin is not c2s)
+	-- TODO also, stazas should be returned to their original state before the function ends
 	
-	if not to or (hosts[to] and hosts[to].type == "local") then
+	-- TODO presence subscriptions
+	if not to then
+		if stanza.name == "presence" and origin.roster then
+			if stanza.attr.type == nil or stanza.attr.type == "available" or stanza.attr.type == "unavailable" then
+				--stanza.attr.from = origin.full_jid;
+				for jid in pairs(origin.roster) do -- broadcast to all interested contacts
+					local subscription = origin.roster[jid].subscription;
+					if subscription == "both" or subscription == "from" then
+						stanza.attr.to = jid;
+						core_route_stanza(origin, stanza);
+					end
+				end
+				--[[local node, host = jid_split(stanza.attr.from);
+				for _, res in pairs(hosts[host].sessions[node].sessions) do -- broadcast to all resources
+					if res.full_jid then
+						res = user.sessions[k];
+						break;
+					end
+				end]]
+				if not origin.presence then -- presence probes on initial presence
+					local probe = st.presence({from = origin.full_jid, type = "probe"});
+					for jid in pairs(origin.roster) do
+						local subscription = origin.roster[jid].subscription;
+						if subscription == "both" or subscription == "to" then
+							probe.attr.to = jid;
+							core_route_stanza(origin, probe);
+						end
+					end
+				end
+				origin.presence = stanza;
+				stanza.attr.to = nil; -- reset it
+			else
+				-- TODO error, bad type
+			end
+		else
+			core_handle_stanza(origin, stanza);
+		end
+	elseif hosts[to] and hosts[to].type == "local" then
 		core_handle_stanza(origin, stanza);
-	elseif to and stanza.name == "iq" and not select(3, jid_split(to)) then
+	elseif stanza.name == "iq" and not select(3, jid_split(to)) then
 		core_handle_stanza(origin, stanza);
 	elseif origin.type == "c2s" then
 		core_route_stanza(origin, stanza);
@@ -43,7 +85,6 @@ function core_handle_stanza(origin, stanza)
 	-- Handlers
 	if origin.type == "c2s" or origin.type == "c2s_unauthed" then
 		local session = origin;
-		stanza.attr.from = session.full_jid;
 		
 		log("debug", "Routing stanza");
 		-- Stanza has no to attribute
@@ -56,32 +97,95 @@ function core_handle_stanza(origin, stanza)
 	end
 end
 
+function is_authorized_to_see_presence(origin, username, host)
+	local roster = datamanager.load(username, host, "roster") or {};
+	local item = roster[origin.username.."@"..origin.host];
+	return item and (item.subscription == "both" or item.subscription == "from");
+end
+
 function core_route_stanza(origin, stanza)
 	-- Hooks
 	--- ...later
 	
 	-- Deliver
-	local node, host, resource = jid_split(stanza.attr.to);
+	local to = stanza.attr.to;
+	local node, host, resource = jid_split(to);
+
+	if stanza.name == "presence" and stanza.attr.type == "probe" then resource = nil; end
+
 	local host_session = hosts[host]
 	if host_session and host_session.type == "local" then
 		-- Local host
 		local user = host_session.sessions[node];
 		if user then
 			local res = user.sessions[resource];
-			-- TODO do something about presence broadcast
 			if not res then
 				-- if we get here, resource was not specified or was unavailable
-				for k in pairs(user.sessions) do
-					res = user.sessions[k];
-					break;
+				if stanza.name == "presence" then
+					if stanza.attr.type == "probe" then
+						if is_authorized_to_see_presence(origin, node, host) then
+							for k in pairs(user.sessions) do -- return presence for all resources
+								if user.sessions[k].presence then
+									local pres = user.sessions[k].presence;
+									pres.attr.to = origin.full_jid;
+									pres.attr.from = user.sessions[k].full_jid;
+									send(origin, pres);
+									pres.attr.to = nil;
+									pres.attr.from = nil;
+								end
+							end
+						else
+							send(origin, st.presence({from = user.."@"..host, to = origin.username.."@"..origin.host, type = "unsubscribed"}));
+						end
+					else
+						for k in pairs(user.sessions) do -- presence broadcast to all user resources
+							if user.sessions[k].full_jid then
+								stanza.attr.to = user.sessions[k].full_jid;
+								send(user.sessions[k], stanza);
+							end
+						end
+					end
+				elseif stanza.name == "message" then -- select a resource to recieve message
+					for k in pairs(user.sessions) do
+						if user.sessions[k].full_jid then
+							res = user.sessions[k];
+							break;
+						end
+					end
+					-- TODO find resource with greatest priority
+					send(res, stanza);
+				else
+					-- TODO send IQ error
 				end
-				-- TODO find resource with greatest priority
+			else
+				stanza.attr.to = res.full_jid;
+				send(res, stanza); -- Yay \o/
 			end
-			stanza.attr.to = res.full_jid;
-			send(res, stanza); -- Yay \o/
 		else
-			-- user not found
-			send(origin, st.error_reply(stanza, "cancel", "service-unavailable"));
+			-- user not online
+			if user_exists(node, host) then
+				if stanza.name == "presence" then
+					if stanza.attr.type == "probe" and is_authorized_to_see_presence(origin, node, host) then -- FIXME what to do for not c2s?
+						-- TODO send last recieved unavailable presence
+					else
+						-- TODO send unavailable presence
+					end
+				elseif stanza.name == "message" then
+					-- TODO send message error, or store offline messages
+				elseif stanza.name == "iq" then
+					-- TODO send IQ error
+				end
+			else -- user does not exist
+				-- TODO we would get here for nodeless JIDs too. Do something fun maybe? Echo service? Let plugins use xmpp:server/resource addresses?
+				if stanza.name == "presence" then
+					if stanza.attr.type == "probe" then
+						send(origin, st.presence({from = user.."@"..host, to = origin.username.."@"..origin.host, type = "unsubscribed"}));
+					end
+					-- else ignore
+				else
+					send(origin, st.error_reply(stanza, "cancel", "service-unavailable"));
+				end
+			end
 		end
 	else
 		-- Remote host
@@ -91,6 +195,7 @@ function core_route_stanza(origin, stanza)
 			-- Need to establish the connection
 		end
 	end
+	stanza.attr.to = to; -- reset
 end
 
 function handle_stanza_nodest(stanza)