-- XEP-0198: Stream Management for Prosody IM

--

-- Copyright (C) 2010-2015 Matthew Wild

-- Copyright (C) 2010 Waqas Hussain

-- Copyright (C) 2012-2022 Kim Alvefur

-- Copyright (C) 2012 Thijs Alkemade

-- Copyright (C) 2014 Florian Zeitz

-- Copyright (C) 2016-2020 Thilo Molitor

--

-- This project is MIT/X11 licensed. Please see the

-- COPYING file in the source package for more information.

--

-- TODO unify sendq and smqueue

local tonumber = tonumber;

local tostring = tostring;

local os_time = os.time;

-- These metrics together allow to calculate an instantaneous

-- "unacked stanzas" metric in the graphing frontend, without us having to

-- iterate over all the queues.

local tx_queued_stanzas = module:measure("tx_queued_stanzas", "counter");

local tx_dropped_stanzas =  module:metric(

	"histogram",

	"tx_dropped_stanzas", "", "number of stanzas in a queue which got dropped",

	{},

	{buckets = {0, 1, 2, 4, 8, 16, 32}}

):with_labels();

local tx_acked_stanzas = module:metric(

	"histogram",

	"tx_acked_stanzas", "", "number of items acked per ack received",

	{},

	{buckets = {0, 1, 2, 4, 8, 16, 32}}

):with_labels();

-- number of session resumptions attempts where the session had expired

local resumption_expired = module:measure("session_resumption_expired", "counter");

local resumption_age = module:metric(

	"histogram",

	"resumption_age", "seconds", "time the session had been hibernating at the time of a resumption",

	{},

	{buckets = { 0, 1, 2, 5, 10, 30, 60, 120, 300, 600 }}

):with_labels();

local sessions_expired = module:measure("sessions_expired", "counter");

local sessions_started = module:measure("sessions_started", "counter");

local datetime = require "util.datetime";

local add_filter = require "util.filters".add_filter;

local jid = require "util.jid";

local smqueue = require "util.smqueue";

local st = require "util.stanza";

local timer = require "util.timer";

local new_id = require "util.id".short;

local watchdog = require "util.watchdog";

local it = require"util.iterators";

local sessionmanager = require "core.sessionmanager";

local xmlns_errors = "urn:ietf:params:xml:ns:xmpp-stanzas";

local xmlns_delay = "urn:xmpp:delay";

local xmlns_mam2 = "urn:xmpp:mam:2";

local xmlns_sm2 = "urn:xmpp:sm:2";

local xmlns_sm3 = "urn:xmpp:sm:3";

local sm2_attr = { xmlns = xmlns_sm2 };

local sm3_attr = { xmlns = xmlns_sm3 };

local queue_size = module:get_option_number("smacks_max_queue_size", 500);

local resume_timeout = module:get_option_number("smacks_hibernation_time", 600);

local s2s_smacks = module:get_option_boolean("smacks_enabled_s2s", true);

local s2s_resend = module:get_option_boolean("smacks_s2s_resend", false);

local max_unacked_stanzas = module:get_option_number("smacks_max_unacked_stanzas", 0);

local max_inactive_unacked_stanzas = module:get_option_number("smacks_max_inactive_unacked_stanzas", 256);

local delayed_ack_timeout = module:get_option_number("smacks_max_ack_delay", 30);

local max_old_sessions = module:get_option_number("smacks_max_old_sessions", 10);

local c2s_sessions = module:shared("/*/c2s/sessions");

local local_sessions = prosody.hosts[module.host].sessions;

local function format_h(h) if h then return string.format("%d", h) end end

local all_old_sessions = module:open_store("smacks_h");

local old_session_registry = module:open_store("smacks_h", "map");

local session_registry = module:shared "/*/smacks/resumption-tokens"; -- > user@host/resumption-token --> resource

local function track_session(session, id)

	session_registry[jid.join(session.username, session.host, id or session.resumption_token)] = session;

	session.resumption_token = id;

end

local function save_old_session(session)

	session_registry[jid.join(session.username, session.host, session.resumption_token)] = nil;

	return old_session_registry:set(session.username, session.resumption_token,

		{ h = session.handled_stanza_count; t = os.time() })

end

local function clear_old_session(session, id)

	session_registry[jid.join(session.username, session.host, id or session.resumption_token)] = nil;

	return old_session_registry:set(session.username, id or session.resumption_token, nil)

end

local ack_errors = require"util.error".init("mod_smacks", xmlns_sm3, {

	head = { condition = "undefined-condition"; text = "Client acknowledged more stanzas than sent by server" };

	tail = { condition = "undefined-condition"; text = "Client acknowledged less stanzas than already acknowledged" };

	pop = { condition = "internal-server-error"; text = "Something went wrong with Stream Management" };

	overflow = { condition = "resource-constraint", text = "Too many unacked stanzas remaining, session can't be resumed" }

});

local enable_errors = require "util.error".init("mod_smacks", xmlns_sm3, {

	already_enabled = { condition = "unexpected-request", text = "Stream management is already enabled" };

	bind_required = { condition = "unexpected-request", text = "Client must bind a resource before enabling stream management" };

	unavailable = { condition = "service-unavailable", text = "Stream management is not available for this stream" };

	-- Resumption

	expired = { condition = "item-not-found", text = "Session expired, and cannot be resumed" };

	already_bound = { condition = "unexpected-request", text = "Cannot resume another session after a resource is bound" };

	unknown_session = { condition = "item-not-found", text = "Unknown session" };

});

-- COMPAT note the use of compatibility wrapper in events (queue:table())

local function ack_delayed(session, stanza)

	-- fire event only if configured to do so and our session is not already hibernated or destroyed

	if delayed_ack_timeout > 0 and session.awaiting_ack

	and not session.hibernating and not session.destroyed then

		session.log("debug", "Firing event 'smacks-ack-delayed', queue = %d",

			session.outgoing_stanza_queue and session.outgoing_stanza_queue:count_unacked() or 0);

		module:fire_event("smacks-ack-delayed", {origin = session, queue = session.outgoing_stanza_queue:table(), stanza = stanza});

	end

	session.delayed_ack_timer = nil;

end

local function can_do_smacks(session, advertise_only)

	if session.smacks then return false, enable_errors.new("already_enabled"); end

	local session_type = session.type;

	if session.username then

		if not(advertise_only) and not(session.resource) then -- Fail unless we're only advertising sm

			return false, enable_errors.new("bind_required");

		end

		return true;

	elseif s2s_smacks and (session_type == "s2sin" or session_type == "s2sout") then

		return true;

	end

	return false, enable_errors.new("unavailable");

end

module:hook("stream-features",

		function (event)

			if can_do_smacks(event.origin, true) then

				event.features:tag("sm", sm2_attr):tag("optional"):up():up();

				event.features:tag("sm", sm3_attr):tag("optional"):up():up();

			end

		end);

module:hook("s2s-stream-features",

		function (event)

			if can_do_smacks(event.origin, true) then

				event.features:tag("sm", sm2_attr):tag("optional"):up():up();

				event.features:tag("sm", sm3_attr):tag("optional"):up():up();

			end

		end);

local function should_ack(session, force)

	if not session then return end -- shouldn't be possible

	if session.destroyed then return end -- gone

	if not session.smacks then return end -- not using

	if session.hibernating then return end -- can't ack when asleep

	if session.awaiting_ack then return end -- already waiting

	if force then return force end

	local queue = session.outgoing_stanza_queue;

	local expected_h = queue:count_acked() + queue:count_unacked();

	local max_unacked = max_unacked_stanzas;

	if session.state == "inactive" then

		max_unacked = max_inactive_unacked_stanzas;

	end

	-- this check of last_requested_h prevents ack-loops if misbehaving clients report wrong

	-- stanza counts. it is set when an <r> is really sent (e.g. inside timer), preventing any

	-- further requests until a higher h-value would be expected.

	return queue:count_unacked() > max_unacked and expected_h ~= session.last_requested_h;

end

local function request_ack(session, reason)

	local queue = session.outgoing_stanza_queue;

	session.log("debug", "Sending <r> from %s - #queue=%d", reason, queue:count_unacked());

	session.awaiting_ack = true;

	(session.sends2s or session.send)(st.stanza("r", { xmlns = session.smacks }))

	if session.destroyed then return end -- sending something can trigger destruction

	-- expected_h could be lower than this expression e.g. more stanzas added to the queue meanwhile)

	session.last_requested_h = queue:count_acked() + queue:count_unacked();

	if not session.delayed_ack_timer then

		session.delayed_ack_timer = timer.add_task(delayed_ack_timeout, function()

			ack_delayed(session, nil); -- we don't know if this is the only new stanza in the queue

		end);

	end

end

local function request_ack_now_if_needed(session, force, reason)

	if should_ack(session, force) then

		request_ack(session, reason);

	end

end

local function outgoing_stanza_filter(stanza, session)

	-- XXX: Normally you wouldn't have to check the xmlns for a stanza as it's

	-- supposed to be nil.

	-- However, when using mod_smacks with mod_websocket, then mod_websocket's

	-- stanzas/out filter can get called before this one and adds the xmlns.

	if not session.smacks then return stanza end

	local is_stanza = st.is_stanza(stanza) and

		(not stanza.attr.xmlns or stanza.attr.xmlns == 'jabber:client')

		and not stanza.name:find":";

	if is_stanza then

		local queue = session.outgoing_stanza_queue;

		local cached_stanza = st.clone(stanza);

		if cached_stanza.name ~= "iq" and cached_stanza:get_child("delay", xmlns_delay) == nil then

			cached_stanza = cached_stanza:tag("delay", {

				xmlns = xmlns_delay,

				from = jid.bare(session.full_jid or session.host),

				stamp = datetime.datetime()

			});

		end

		queue:push(cached_stanza);

		tx_queued_stanzas(1);

		if session.hibernating then

			session.log("debug", "hibernating since %s, stanza queued", datetime.datetime(session.hibernating));

			-- FIXME queue implementation changed, anything depending on it being an array will break

			module:fire_event("smacks-hibernation-stanza-queued", {origin = session, queue = queue:table(), stanza = cached_stanza});

			return nil;

		end

	end

	return stanza;

end

local function count_incoming_stanzas(stanza, session)

	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

local function wrap_session_out(session, resume)

	if not resume then

		session.outgoing_stanza_queue = smqueue.new(queue_size);

	end

	add_filter(session, "stanzas/out", outgoing_stanza_filter, -999);

	return session;

end

module:hook("pre-session-close", function(event)

	local session = event.session;

	if session.smacks == nil then return end

	if session.resumption_token then

		session.log("debug", "Revoking resumption token");

		clear_old_session(session);

		session.resumption_token = nil;

	else

		session.log("debug", "Session not resumable");

	end

	if session.hibernating_watchdog then

		session.log("debug", "Removing sleeping watchdog");

		-- If the session is being replaced instead of resume, we don't want the

		-- old session around to time out and cause trouble for the new session

		session.hibernating_watchdog:cancel();

		session.hibernating_watchdog = nil;

	else

		session.log("debug", "No watchdog set");

	end

	-- send out last ack as per revision 1.5.2 of XEP-0198

	if session.smacks and session.conn and session.handled_stanza_count then

		(session.sends2s or session.send)(st.stanza("a", {

			xmlns = session.smacks;

			h = format_h(session.handled_stanza_count);

		}));

	end

end);

local function wrap_session_in(session, resume)

	if not resume then

		sessions_started(1);

		session.handled_stanza_count = 0;

	end

	add_filter(session, "stanzas/in", count_incoming_stanzas, 999);

	return session;

end

local function wrap_session(session, resume)

	wrap_session_out(session, resume);

	wrap_session_in(session, resume);

	return session;

end

function do_enable(session, stanza)

	local ok, err = can_do_smacks(session);

	if not ok then

		session.log("warn", "Failed to enable smacks: %s", err.text); -- TODO: XEP doesn't say we can send error text, should it?

		return nil, err;

	end

	if session.username then

		local old_sessions, err = all_old_sessions:get(session.username);

		session.log("debug", "Old sessions: %q", old_sessions)

		if old_sessions then

			local keep, count = {}, 0;

			for token, info in it.sorted_pairs(old_sessions, function(a, b)

				return (old_sessions[a].t or 0) > (old_sessions[b].t or 0);

			end) do

				count = count + 1;

				if count > max_old_sessions then break end

				keep[token] = info;

			end

			all_old_sessions:set(session.username, keep);

		elseif err then

			session.log("error", "Unable to retrieve old resumption counters: %s", err);

		end

	end

	local resume_token;

	local resume = stanza.attr.resume;

	if resume == "true" or resume == "1" then

		resume_token = new_id();

	end

	return {

		type = "enabled";

		id = resume_token;

		resume_max = resume_token and tostring(resume_timeout) or nil;

		session = session;

		finish = function ()

			session.log("debug", "Enabling stream management");

			session.smacks = stanza.attr.xmlns;

			track_session(session, resume_token);

			wrap_session(session, false);

		end;

	};

end

function handle_enable(session, stanza, xmlns_sm)

	local enabled, err = do_enable(session, stanza);

	if not enabled then

		(session.sends2s or session.send)(st.stanza("failed", { xmlns = xmlns_sm }):add_error(err));

		return true;

	end

	(session.sends2s or session.send)(st.stanza("enabled", {

		xmlns = xmlns_sm;

		id = enabled.id;

		max = enabled.resume_max;

	}));

	session.smacks = xmlns_sm;

	enabled.finish();

	return true;

end