construct/modules/m_presence.cc

// Matrix Construct
//
// Copyright (C) Matrix Construct Developers, Authors & Contributors
// Copyright (C) 2016-2018 Jason Volk <jason@zemos.net>
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice is present in all copies. The
// full license for this software is available in the LICENSE file.

using namespace ircd;

static void handle_ircd_presence(const m::event &, m::vm::eval &);
static void handle_edu_m_presence_object(const m::event &, const m::presence &edu);
static void handle_edu_m_presence(const m::event &, m::vm::eval &);

mapi::header
IRCD_MODULE
{
	"Matrix Presence"
};

/// Coarse enabler for incoming federation presence events. If this is
/// disabled then all presence coming over the federation is ignored. Note
/// that there are other ways to degrade or ignore presence in various
/// other subsystems like sync without losing the data; however presence
/// data over the federation is considerable and tiny deployments which
/// won't /sync presence to clients should probably quench it here too.
conf::item<bool>
federation_incoming
{
	{ "name",     "ircd.m.presence.federation.incoming" },
	{ "default",  true                                  },
};

/// Coarse enabler to send presence events over the federation.
conf::item<bool>
federation_send
{
	{ "name",     "ircd.m.presence.federation.send" },
	{ "default",  false                             },
};

log::log
presence_log
{
	"m.presence"
};

/// This hook processes incoming m.presence events from the federation and
/// turns them into ircd.presence events in the user's room.
const m::hookfn<m::vm::eval &>
_m_presence_eval
{
	handle_edu_m_presence,
	{
		{ "_site",   "vm.eval"     },
		{ "type",    "m.presence"  },
	}
};

extern const string_view
valid_states[];

void
handle_edu_m_presence(const m::event &event,
                      m::vm::eval &eval)
try
{
	if(!federation_incoming)
		return;

	if(my(event))
		return;

	const json::object &content
	{
		at<"content"_>(event)
	};

	const json::array &push
	{
		content.get("push")
	};

	for(const json::object &presence : push)
		handle_edu_m_presence_object(event, presence);
}
catch(const std::exception &e)
{
	log::derror
	{
		presence_log, "Presence from %s :%s",
		json::get<"origin"_>(event),
		e.what(),
	};
}

void
handle_edu_m_presence_object(const m::event &event,
                             const m::presence &object)
try
{
	const m::user::id &user_id
	{
		at<"user_id"_>(object)
	};

	if(user_id.host() != at<"origin"_>(event))
	{
		log::dwarning
		{
			presence_log, "Ignoring %s from %s for user %s",
			at<"type"_>(event),
			at<"origin"_>(event),
			string_view{user_id}
		};

		return;
	}

	bool useful{true};
	const auto closure{[&event, &object, &useful]
	(const m::event &existing_event)
	{
		const json::object &existing_object
		{
			json::get<"content"_>(existing_event)
		};

		// This check shouldn't have to exist. I think this was a result of corrupting
		// my DB during development and it fails on only one user. Nevertheless, it's
		// a valid assertion so might as well keep it.
		if(unlikely(json::get<"user_id"_>(object) != unquote(existing_object.get("user_id"))))
		{
			//log::critical("%s != %s", json::get<"user_id"_>(object), unquote(existing_object.get("user_id")));
			return;
		}

		assert(json::get<"user_id"_>(object) == unquote(existing_object.get("user_id")));

		const auto &prev_active_ago
		{
			existing_object.get<time_t>("last_active_ago")
		};

		const time_t &now_active_ago
		{
			json::get<"last_active_ago"_>(object)
		};

		const time_t &prev_active_absolute
		{
			json::get<"origin_server_ts"_>(existing_event) - prev_active_ago
		};

		const time_t &now_active_absolute
		{
			json::get<"origin_server_ts"_>(event) - now_active_ago
		};

		// First way to filter out the synapse presence spam bug is seeing
		// if the update is older than the last update.
		if(now_active_absolute < prev_active_absolute)
			useful = false;
		else if(json::get<"presence"_>(object) != unquote(existing_object.get("presence")))
			useful = true;
		else if(json::get<"currently_active"_>(object) != existing_object.get<bool>("currently_active"))
			useful = true;
		else if(json::get<"currently_active"_>(object))
			useful = true;
		else
			useful = false;
	}};

	static const m::event::fetch::opts fopts
	{
		m::event::keys::include {"content", "origin_server_ts"}
	};

	m::presence::get(std::nothrow, user_id, closure, &fopts);

	if(!useful)
	{
		log::dwarning
		{
			presence_log, "presence spam from %s %s is %s and %s %zd seconds ago",
			at<"origin"_>(event),
			string_view{user_id},
			json::get<"currently_active"_>(object)? "active"_sv : "inactive"_sv,
			json::get<"presence"_>(object),
			json::get<"last_active_ago"_>(object) / 1000L
		};

		return;
	}

	const auto evid
	{
		m::presence::set(object)
	};

	log::info
	{
		presence_log, "%s %s is %s and %s %zd seconds ago",
		at<"origin"_>(event),
		string_view{user_id},
		json::get<"currently_active"_>(object)? "active"_sv : "inactive"_sv,
		json::get<"presence"_>(object),
		json::get<"last_active_ago"_>(object) / 1000L
	};
}
catch(const m::error &e)
{
	log::error
	{
		presence_log, "Presence from %s :%s :%s",
		json::get<"origin"_>(event),
		e.what(),
		e.content
	};
}

/// This hook processes ircd.presence events generated internally from local
/// users and converts them to m.presence over the federation.
const m::hookfn<m::vm::eval &>
_ircd_presence_eval
{
	handle_ircd_presence,
	{
		{ "_site",   "vm.effect"      },
		{ "type",    "ircd.presence"  },
	}
};

void
handle_ircd_presence(const m::event &event,
                     m::vm::eval &eval)
try
{
	if(!federation_send)
		return;

	const m::user::id &user_id
	{
		json::get<"sender"_>(event)
	};

	if(!my(user_id))
		return;

	// The event has to be an ircd.presence in the user's room, not just a
	// random ircd.presence typed event in some other room...
	if(!m::user::room::is(json::get<"room_id"_>(event), user_id))
		return;

	// Get the spec EDU data from our PDU's content
	const m::edu::m_presence edu
	{
		json::get<"content"_>(event)
	};

	// Check if the user_id in the content is legitimate. This should have
	// been checked on any input side, but nevertheless we'll ignore any
	// discrepancies here for now.
	if(unlikely(json::get<"user_id"_>(edu) != user_id))
		return;

	// The matrix EDU format requires us to wrap this data in an array
	// called "push" so we copy content into this stack buffer :/
	char buf[512];
	json::stack out{buf};
	{
		json::stack::array push{out};
		push.append(edu);
	}

	// Note that "sender" is intercepted by the federation sender and not
	// actually sent over the wire.
	json::iov edu_event, content;
	const json::iov::push pushed[]
	{
		{ edu_event,  { "type",    "m.presence"     }},
		{ edu_event,  { "sender",  user_id          }},
		{ content,    { "push",    out.completed()  }},
	};

	// Setup for a core injection of an EDU.
	m::vm::copts opts;
	opts.edu = true;
	opts.prop_mask.reset();            // Clear all PDU properties
	opts.notify_clients = false;       // Client /sync already saw the ircd.presence

	// Execute
	m::vm::eval
	{
		edu_event, content, opts
	};

	log::info
	{
		presence_log, "%s is %s and %s %zd seconds ago",
		string_view{user_id},
		json::get<"currently_active"_>(edu)? "active"_sv : "inactive"_sv,
		json::get<"presence"_>(edu),
		json::get<"last_active_ago"_>(edu) / 1000L,
	};
}
catch(const std::exception &e)
{
	log::error
	{
		presence_log, "Presence from our %s to federation :%s",
		string_view{json::get<"sender"_>(event)},
		e.what(),
	};
}

bool
IRCD_MODULE_EXPORT
ircd::m::presence::get(const std::nothrow_t,
                       const m::user &user,
                       const m::presence::closure_event &closure,
                       const m::event::fetch::opts *const &fopts_p)
{
	const m::event::idx event_idx
	{
		m::presence::get(std::nothrow, user)
	};

	if(!event_idx)
		return false;

	const auto &fopts
	{
		fopts_p? *fopts_p : event::fetch::default_opts
	};

	const m::event::fetch event
	{
		event_idx, std::nothrow, fopts
	};

	if(event.valid)
		closure(event);

	return event.valid;
}

m::event::idx
IRCD_MODULE_EXPORT
ircd::m::presence::get(const std::nothrow_t,
                       const m::user &user)
{
	const m::user::room user_room
	{
		user
	};

	const m::room::state state
	{
		user_room
	};

	return state.get(std::nothrow, "ircd.presence", "");
}

m::event::id::buf
IRCD_MODULE_EXPORT
ircd::m::presence::set(const m::presence &content)
{
	const m::user user
	{
		json::at<"user_id"_>(content)
	};

	//TODO: ABA
	if(!exists(user))
		create(user.user_id);

	m::vm::copts copts;
	const m::user::room user_room
	{
		user, &copts
	};

	//TODO: ABA
	return send(user_room, user.user_id, "ircd.presence", "", json::strung{content});
}

const string_view
valid_states[]
{
	"online", "offline", "unavailable",
};

bool
IRCD_MODULE_EXPORT
ircd::m::presence::valid_state(const string_view &state)
{
	return std::any_of(begin(valid_states), end(valid_states), [&state]
	(const string_view &valid)
	{
		return state == valid;
	});
}