# HG changeset patch # User Matthew Wild # Date 1300483587 0 # Node ID 445178d15b51134d61f2db15f1a80b708ad2d795 # Parent 2b0f2160fc618ba909b60df966e8b94e32436d0a mod_smacks: Merge mod_fastreconnect (resumption support), fix a number of bugs, refactor the code and add some more comments to explain process diff -r 2b0f2160fc61 -r 445178d15b51 mod_smacks/mod_smacks.lua --- a/mod_smacks/mod_smacks.lua Sat Mar 05 18:52:43 2011 +0000 +++ b/mod_smacks/mod_smacks.lua Fri Mar 18 21:26:27 2011 +0000 @@ -1,18 +1,23 @@ local st = require "util.stanza"; +local uuid_generate = require "util.uuid".generate; local t_insert, t_remove = table.insert, table.remove; local math_min = math.min; +local os_time = os.time; local tonumber, tostring = tonumber, tostring; local add_filter = require "util.filters".add_filter; local timer = require "util.timer"; local xmlns_sm = "urn:xmpp:sm:2"; +local xmlns_errors = "urn:ietf:params:xml:ns:xmpp-stanzas"; local sm_attr = { xmlns = xmlns_sm }; -local resume_timeout = 300; +local resume_timeout = module:get_option("smacks_hibernation_time", 300); local max_unacked_stanzas = 0; +local session_registry = {}; + module:hook("stream-features", function (event) event.features:tag("sm", sm_attr):tag("optional"):up():up(); @@ -23,49 +28,74 @@ event.features:tag("sm", sm_attr):tag("optional"):up():up(); end); -module:hook_stanza(xmlns_sm, "enable", +module:hook_stanza("http://etherx.jabber.org/streams", "features", function (session, stanza) - module:log("debug", "Enabling stream management"); - session.smacks = true; - - -- Overwrite process_stanza() and send() - local queue = {}; - session.outgoing_stanza_queue = queue; - session.last_acknowledged_stanza = 0; - local _send = session.sends2s or session.send; - local function new_send(stanza) - local attr = stanza.attr; - if attr and not attr.xmlns then -- Stanza in default stream namespace - queue[#queue+1] = st.clone(stanza); - end - local ok, err = _send(stanza); - if ok and #queue > max_unacked_stanzas and not session.awaiting_ack then - session.awaiting_ack = true; - return _send(st.stanza("r", { xmlns = xmlns_sm })); - end - return ok, err; + if not session.smacks and stanza:get_child("sm", xmlns_sm) then + session.send(st.stanza("enable", sm_attr)); end - - if session.sends2s then - session.sends2s = new_send; - else - session.send = new_send; +end); + +local function wrap_session(session, resume) + -- Overwrite process_stanza() and send() + local queue; + if not resume then + queue = {}; + session.outgoing_stanza_queue = queue; + session.last_acknowledged_stanza = 0; + else + queue = session.outgoing_stanza_queue; + end + + local _send = session.sends2s or session.send; + local function new_send(stanza) + local attr = stanza.attr; + if attr and not attr.xmlns then -- Stanza in default stream namespace + queue[#queue+1] = st.clone(stanza); + end + local ok, err = _send(stanza); + if ok and #queue > max_unacked_stanzas and not session.awaiting_ack then + session.awaiting_ack = true; + return _send(st.stanza("r", sm_attr)); + end + return ok, err; + end + + if session.sends2s then + session.sends2s = new_send; + else + session.send = new_send; + end + + if not resume then + session.handled_stanza_count = 0; + add_filter(session, "stanzas/in", function (stanza) + if not stanza.attr.xmlns then + session.handled_stanza_count = session.handled_stanza_count + 1; + session.log("debug", "Handled %d incoming stanzas", session.handled_stanza_count); end - - session.handled_stanza_count = 0; - add_filter(session, "stanzas/in", function (stanza) - if not stanza.attr.xmlns then - session.handled_stanza_count = session.handled_stanza_count + 1; - session.log("debug", "Handled %d incoming stanzas", session.handled_stanza_count); - end - return stanza; - end); + return stanza; + end); + end + + return session; +end - if not stanza.attr.resume then -- FIXME: Resumption should be a different spec :/ - _send(st.stanza("enabled", sm_attr)); - return true; - end - end, 100); +module:hook_stanza(xmlns_sm, "enable", function (session, stanza) + module:log("debug", "Enabling stream management"); + session.smacks = true; + + wrap_session(session); + + local resume_token; + local resume = stanza.attr.resume; + if resume == "true" or resume == "1" then + resume_token = uuid_generate(); + session_registry[resume_token] = session; + session.resumption_token = resume_token; + end + session.send(st.stanza("enabled", { xmlns = xmlns_sm, id = resume_token, resume = resume })); + return true; +end, 100); module:hook_stanza(xmlns_sm, "r", function (origin, stanza) if not origin.smacks then @@ -88,6 +118,7 @@ if handled_stanza_count > #queue then module:log("warn", "The client says it handled %d new stanzas, but we only sent %d :)", handled_stanza_count, #queue); + module:log("debug", "Client h: %d, our h: %d", tonumber(stanza.attr.h), origin.last_acknowledged_stanza); for i=1,#queue do module:log("debug", "Q item %d: %s", i, tostring(queue[i])); end @@ -134,11 +165,17 @@ handle_unacked_stanzas(session); end else - session.hibernating = true; + local hibernate_time = os_time(); -- Track the time we went into hibernation + session.hibernating = hibernate_time; timer.add_task(resume_timeout, function () - if session.hibernating then + -- Check the hibernate time still matches what we think it is, + -- otherwise the session resumed and re-hibernated. + if session.hibernating == hibernate_time then + session_registry[session.resumption_token] = nil; session.resumption_token = nil; - sessionmanager.destroy_session(session); -- Re-destroy + -- This recursion back into our destroy handler is to + -- make sure we still handle any queued stanzas + sessionmanager.destroy_session(session); end end); return; -- Postpone destruction for now @@ -147,3 +184,60 @@ end return _destroy_session(session, err); end + +module:hook_stanza(xmlns_sm, "resume", function (session, stanza) + local id = stanza.attr.previd; + local original_session = session_registry[id]; + if not original_session then + session.send(st.stanza("failed", sm_attr) + :tag("item-not-found", { xmlns = xmlns_errors }) + ); + elseif session.username == original_session.username + and session.host == original_session.host then + -- TODO: All this should move to sessionmanager (e.g. session:replace(new_session)) + original_session.ip = session.ip; + original_session.conn = session.conn; + original_session.send = session.send; + original_session.stream = session.stream; + original_session.secure = session.secure; + original_session.hibernating = nil; + local filter = original_session.filter; + local stream = session.stream; + local log = session.log; + function original_session.data(data) + data = filter("bytes/in", data); + if data then + local ok, err = stream:feed(data); + if ok then return; end + log("debug", "Received invalid XML (%s) %d bytes: %s", tostring(err), #data, data:sub(1, 300):gsub("[\r\n]+", " "):gsub("[%z\1-\31]", "_")); + original_session:close("xml-not-well-formed"); + end + end + wrap_session(original_session, true); + -- Inform xmppstream of the new session (passed to its callbacks) + stream:set_session(original_session); + -- Similar for connlisteners + require "net.connlisteners".get("xmppclient").associate_session(session.conn, original_session); + + session.send(st.stanza("resumed", { xmlns = xmlns_sm, + h = original_session.handled_stanza_count, previd = id })); + + -- Fake an with the h of the from the client + original_session:dispatch_stanza(st.stanza("a", { xmlns = xmlns_sm, + h = stanza.attr.h })); + + -- Ok, we need to re-send any stanzas that the client didn't see + -- ...they are what is now left in the outgoing stanza queue + local queue = original_session.outgoing_stanza_queue; + for i=1,#queue do + session.send(queue[i]); + end + else + log("warn", "Client %s@%s[%s] tried to resume stream for %s@%s[%s]", + session.username or "?", session.host or "?", session.type, + original_session.username or "?", original_session.host or "?", original_session.type); + session.send(st.stanza("failed", sm_attr) + :tag("not-authorized", { xmlns = xmlns_errors })); + end + return true; +end);