diff options
| author | Antoine Ouvrard <antoine.ouvrard@nereide.fr> | 2020-11-23 10:28:32 +0100 |
|---|---|---|
| committer | Antoine Ouvrard <antoine.ouvrard@nereide.fr> | 2020-11-23 10:28:32 +0100 |
| commit | d3277d65639ef43230b71305922b5ccf33d86083 (patch) | |
| tree | 87455d87a534c1bcb33a34290b840b68e573df96 /jitsi-meet/prosody-plugins/poltergeist.lib.lua | |
initial commit
Diffstat (limited to 'jitsi-meet/prosody-plugins/poltergeist.lib.lua')
| -rw-r--r-- | jitsi-meet/prosody-plugins/poltergeist.lib.lua | 397 |
1 files changed, 397 insertions, 0 deletions
diff --git a/jitsi-meet/prosody-plugins/poltergeist.lib.lua b/jitsi-meet/prosody-plugins/poltergeist.lib.lua new file mode 100644 index 0000000..7fa0ae2 --- /dev/null +++ b/jitsi-meet/prosody-plugins/poltergeist.lib.lua @@ -0,0 +1,397 @@ +local inspect = require("inspect") +local jid = require("util.jid") +local stanza = require("util.stanza") +local timer = require("util.timer") +local update_presence_identity = module:require("util").update_presence_identity +local uuid = require("util.uuid") + +local component = module:get_option_string( + "poltergeist_component", + module.host +) + +local expiration_timeout = module:get_option_string( + "poltergeist_leave_timeout", + 30 -- defaults to 30 seconds +) + +local MUC_NS = "http://jabber.org/protocol/muc" + +-------------------------------------------------------------------------------- +-- Utility functions for commonly used poltergeist codes. +-------------------------------------------------------------------------------- + +-- Creates a nick for a poltergeist. +-- @param username is the unique username of the poltergeist +-- @return a nick to use for xmpp +local function create_nick(username) + return string.sub(username, 0,8) +end + +-- Returns the last presence of the occupant. +-- @param room the room instance where to check for occupant +-- @param nick the nick of the occupant +-- @return presence stanza of the occupant +function get_presence(room, nick) + local occupant_jid = room:get_occupant_jid(component.."/"..nick) + if occupant_jid then + return room:get_occupant_by_nick(occupant_jid):get_presence(); + end + return nil; +end + +-- Checks for existance of a poltergeist occupant in a room. +-- @param room the room instance where to check for the occupant +-- @param nick the nick of the occupant +-- @return true if occupant is found, false otherwise +function occupies(room, nick) + -- Find out if we have a poltergeist occupant in the room for this JID + return not not room:get_occupant_jid(component.."/"..nick); +end + +-------------------------------------------------------------------------------- +-- Username storage for poltergeist. +-- +-- Every poltergeist will have a username stored in a table underneath +-- the room name that they are currently active in. The username can +-- be retrieved given a room and a user_id. The username is removed from +-- a room by providing the room and the nick. +-- +-- A table with a single entry looks like: +-- { +-- ["[hug]hostilewerewolvesthinkslightly"] = { +-- ["655363:52148a3e-b5fb-4cfc-8fbd-f55e793cf657"] = "ed7757d6-d88d-4e6a-8e24-aca2adc31348", +-- ed7757d6 = "655363:52148a3e-b5fb-4cfc-8fbd-f55e793cf657" +-- } +-- } +-------------------------------------------------------------------------------- +-- state is the table where poltergeist usernames and call resources are stored +-- for a given xmpp muc. +local state = module:shared("state") + +-- Adds a poltergeist to the store. +-- @param room is the room the poltergeist is being added to +-- @param user_id is the user_id of the user the poltergeist represents +-- @param username is the unique id of the poltergeist itself +local function store_username(room, user_id, username) + local room_name = jid.node(room.jid) + + if not state[room_name] then + state[room_name] = {} + end + + state[room_name][user_id] = username + state[room_name][create_nick(username)] = user_id +end + +-- Retrieves a poltergeist username from the store if one exists. +-- @param room is the room to check for the poltergeist in the store +-- @param user_id is the user id of the user the poltergeist represents +local function get_username(room, user_id) + local room_name = jid.node(room.jid) + + if not state[room_name] then + return nil + end + + return state[room_name][user_id] +end + +local function get_username_from_nick(room_name, nick) + if not state[room_name] then + return nil + end + + local user_id = state[room_name][nick] + return state[room_name][user_id] +end + +-- Removes the username from the store. +-- @param room is the room the poltergeist is being removed from +-- @param nick is the nick of the muc occupant +local function remove_username(room, nick) + local room_name = jid.node(room.jid) + if not state[room_name] then + return + end + + local user_id = state[room_name][nick] + state[room_name][user_id] = nil + state[room_name][nick] = nil +end + +-- Removes all poltergeists in the store for the provided room. +-- @param room is the room all poltergiest will be removed from +local function remove_room(room) + local room_name = jid.node(room.jid) + if state[room_name] then + state[room_name] = nil + end +end + +-- Adds a resource that is associated with a a call in a room. There +-- is only one resource for each type. +-- @param room is the room the call and poltergeist is in. +-- @param call_id is the unique id for the call. +-- @param resource_type is type of resource being added. +-- @param resource_id is the id of the resource being added. +local function add_call_resource(room, call_id, resource_type, resource_id) + local room_name = jid.node(room.jid) + if not state[room_name] then + state[room_name] = {} + end + + if not state[room_name][call_id] then + state[room_name][call_id] = {} + end + + state[room_name][call_id][resource_type] = resource_id +end + +-------------------------------------------------------------------------------- +-- State for toggling the tagging of presence stanzas with ignored tag. +-- +-- A poltergeist with it's full room/nick set to ignore will have a jitsi ignore +-- tag applied to all presence stanza's broadcasted. The following funcitons +-- assisst in managing this state. +-------------------------------------------------------------------------------- +local presence_ignored = {} + +-- Sets the nick to ignored state. +-- @param room_nick full room/nick jid +local function set_ignored(room_nick) + presence_ignored[room_nick] = true +end + +-- Resets the nick out of ignored state. +-- @param room_nick full room/nick jid +local function reset_ignored(room_nick) + presence_ignored[room_nick] = nil +end + +-- Determines whether or not the leave presence should be tagged with ignored. +-- @param room_nick full room/nick jid +local function should_ignore(room_nick) + if presence_ignored[room_nick] == nil then + return false + end + return presence_ignored[room_nick] +end + +-------------------------------------------------------------------------------- +-- Poltergeist control functions for adding, updating and removing poltergeist. +-------------------------------------------------------------------------------- + +-- Updates the status tags and call flow tags of an existing poltergeist +-- presence. +-- @param presence_stanza is the actual presence stanza for a poltergeist. +-- @param status is the new status to be updated in the stanza. +-- @param call_details is a table of call flow signal information. +function update_presence_tags(presence_stanza, status, call_details) + local call_cancel = false + local call_id = nil + + -- Extract optional call flow signal information. + if call_details then + call_id = call_details["id"] + + if call_details["cancel"] then + call_cancel = call_details["cancel"] + end + end + + presence_stanza:maptags(function (tag) + if tag.name == "status" then + if call_cancel then + -- If call cancel is set then the status should not be changed. + return tag + end + return stanza.stanza("status"):text(status) + elseif tag.name == "call_id" then + if call_id then + return stanza.stanza("call_id"):text(call_id) + else + -- If no call id is provided the re-use the existing id. + return tag + end + elseif tag.name == "call_cancel" then + if call_cancel then + return stanza.stanza("call_cancel"):text("true") + else + return stanza.stanza("call_cancel"):text("false") + end + end + return tag + end) + + return presence_stanza +end + +-- Updates the presence status of a poltergeist. +-- @param room is the room the poltergeist has occupied +-- @param nick is the xmpp nick of the poltergeist occupant +-- @param status is the status string to set in the presence +-- @param call_details is a table of call flow control details +local function update(room, nick, status, call_details) + local original_presence = get_presence(room, nick) + + if not original_presence then + module:log("info", "update issued for a non-existing poltergeist") + return + end + + -- update occupant presence with appropriate to and from + -- so we can send it again + update_presence = stanza.clone(original_presence) + update_presence.attr.to = room.jid.."/"..nick + update_presence.attr.from = component.."/"..nick + + update_presence = update_presence_tags(update_presence, status, call_details) + + module:log("info", "updating poltergeist: %s/%s - %s", room, nick, status) + room:handle_normal_presence( + prosody.hosts[component], + update_presence + ) +end + +-- Removes the poltergeist from the room. +-- @param room is the room the poltergeist has occupied +-- @param nick is the xmpp nick of the poltergeist occupant +-- @param ignore toggles if the leave subsequent leave presence should be tagged +local function remove(room, nick, ignore) + local original_presence = get_presence(room, nick); + if not original_presence then + module:log("info", "attempted to remove a poltergeist with no presence") + return + end + + local leave_presence = stanza.clone(original_presence) + leave_presence.attr.to = room.jid.."/"..nick + leave_presence.attr.from = component.."/"..nick + leave_presence.attr.type = "unavailable" + + if (ignore) then + set_ignored(room.jid.."/"..nick) + end + + remove_username(room, nick) + module:log("info", "removing poltergeist: %s/%s", room, nick) + room:handle_normal_presence( + prosody.hosts[component], + leave_presence + ) +end + +-- Adds a poltergeist to a muc/room. +-- @param room is the room the poltergeist will occupy +-- @param is the id of the user the poltergeist represents +-- @param display_name is the display name to use for the poltergeist +-- @param avatar is the avatar link used for the poltergeist display +-- @param context is the session context of the user making the request +-- @param status is the presence status string to use +-- @param resources is a table of resource types and resource ids to correlate. +local function add_to_muc(room, user_id, display_name, avatar, context, status, resources) + local username = uuid.generate() + local presence_stanza = original_presence( + room, + username, + display_name, + avatar, + context, + status + ) + + module:log("info", "adding poltergeist: %s/%s", room, create_nick(username)) + store_username(room, user_id, username) + for k, v in pairs(resources) do + add_call_resource(room, username, k, v) + end + room:handle_first_presence( + prosody.hosts[component], + presence_stanza + ) + + local remove_delay = 5 + local expiration = expiration_timeout - remove_delay; + local nick = create_nick(username) + timer.add_task( + expiration, + function () + update(room, nick, "expired") + timer.add_task( + remove_delay, + function () + if occupies(room, nick) then + remove(room, nick, false) + end + end + ) + end + ) +end + +-- Generates an original presence for a new poltergeist +-- @param room is the room the poltergeist will occupy +-- @param username is the unique name for the poltergeist +-- @param display_name is the display name to use for the poltergeist +-- @param avatar is the avatar link used for the poltergeist display +-- @param context is the session context of the user making the request +-- @param status is the presence status string to use +-- @return a presence stanza that can be used to add the poltergeist to the muc +function original_presence(room, username, display_name, avatar, context, status) + local nick = create_nick(username) + local p = stanza.presence({ + to = room.jid.."/"..nick, + from = component.."/"..nick, + }):tag("x", { xmlns = MUC_NS }):up(); + + p:tag("bot", { type = "poltergeist" }):up(); + p:tag("call_cancel"):text(nil):up(); + p:tag("call_id"):text(username):up(); + + if status then + p:tag("status"):text(status):up(); + else + p:tag("status"):text(nil):up(); + end + + if display_name then + p:tag( + "nick", + { xmlns = "http://jabber.org/protocol/nick" }):text(display_name):up(); + end + + if avatar then + p:tag("avatar-url"):text(avatar):up(); + end + + -- If the room has a password set, let the poltergeist enter using it + local room_password = room:get_password(); + if room_password then + local join = p:get_child("x", MUC_NS); + join:tag("password", { xmlns = MUC_NS }):text(room_password); + end + + update_presence_identity( + p, + context.user, + context.group, + context.creator_user, + context.creator_group + ) + return p +end + +return { + get_username = get_username, + get_username_from_nick = get_username_from_nick, + occupies = occupies, + remove_room = remove_room, + reset_ignored = reset_ignored, + should_ignore = should_ignore, + create_nick = create_nick, + add_to_muc = add_to_muc, + update = update, + remove = remove +} |
