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/util.lib.lua | |
initial commit
Diffstat (limited to 'jitsi-meet/prosody-plugins/util.lib.lua')
| -rw-r--r-- | jitsi-meet/prosody-plugins/util.lib.lua | 295 |
1 files changed, 295 insertions, 0 deletions
diff --git a/jitsi-meet/prosody-plugins/util.lib.lua b/jitsi-meet/prosody-plugins/util.lib.lua new file mode 100644 index 0000000..9c90553 --- /dev/null +++ b/jitsi-meet/prosody-plugins/util.lib.lua @@ -0,0 +1,295 @@ +local jid = require "util.jid"; +local timer = require "util.timer"; +local http = require "net.http"; + +local http_timeout = 30; +local have_async, async = pcall(require, "util.async"); +local http_headers = { + ["User-Agent"] = "Prosody ("..prosody.version.."; "..prosody.platform..")" +}; + +local muc_domain_prefix + = module:get_option_string("muc_mapper_domain_prefix", "conference"); + +-- defaults to module.host, the module that uses the utility +local muc_domain_base + = module:get_option_string("muc_mapper_domain_base", module.host); + +-- The "real" MUC domain that we are proxying to +local muc_domain = module:get_option_string( + "muc_mapper_domain", muc_domain_prefix.."."..muc_domain_base); + +local escaped_muc_domain_base = muc_domain_base:gsub("%p", "%%%1"); +local escaped_muc_domain_prefix = muc_domain_prefix:gsub("%p", "%%%1"); +-- The pattern used to extract the target subdomain +-- (e.g. extract 'foo' from 'foo.muc.example.com') +local target_subdomain_pattern + = "^"..escaped_muc_domain_prefix..".([^%.]+)%."..escaped_muc_domain_base; + +-- Utility function to split room JID to include room name and subdomain +local function room_jid_split_subdomain(room_jid) + local node, host, resource = jid.split(room_jid); + local target_subdomain = host and host:match(target_subdomain_pattern); + return node, host, resource, target_subdomain +end + +--- Utility function to check and convert a room JID from +-- virtual room1@muc.foo.example.com to real [foo]room1@muc.example.com +-- @param room_jid the room jid to match and rewrite if needed +-- @return returns room jid [foo]room1@muc.example.com when it has subdomain +-- otherwise room1@muc.example.com(the room_jid value untouched) +local function room_jid_match_rewrite(room_jid) + local node, host, resource, target_subdomain = room_jid_split_subdomain(room_jid); + if not target_subdomain then + module:log("debug", "No need to rewrite out 'to' %s", room_jid); + return room_jid; + end + -- Ok, rewrite room_jid address to new format + local new_node, new_host, new_resource + = "["..target_subdomain.."]"..node, muc_domain, resource; + room_jid = jid.join(new_node, new_host, new_resource); + module:log("debug", "Rewrote to %s", room_jid); + return room_jid +end + +local function internal_room_jid_match_rewrite(room_jid) + local node, host, resource = jid.split(room_jid); + if host ~= muc_domain or not node then + module:log("debug", "No need to rewrite %s (not from the MUC host)", room_jid); + return room_jid; + end + local target_subdomain, target_node = node:match("^%[([^%]]+)%](.+)$"); + if not (target_node and target_subdomain) then + module:log("debug", "Not rewriting... unexpected node format: %s", node); + return room_jid; + end + -- Ok, rewrite room_jid address to pretty format + local new_node, new_host, new_resource = target_node, muc_domain_prefix..".".. target_subdomain.."."..muc_domain_base, resource; + room_jid = jid.join(new_node, new_host, new_resource); + module:log("debug", "Rewrote to %s", room_jid); + return room_jid +end + +--- Finds and returns room by its jid +-- @param room_jid the room jid to search in the muc component +-- @return returns room if found or nil +function get_room_from_jid(room_jid) + local _, host = jid.split(room_jid); + local component = hosts[host]; + if component then + local muc = component.modules.muc + if muc and rawget(muc,"rooms") then + -- We're running 0.9.x or 0.10 (old MUC API) + return muc.rooms[room_jid]; + elseif muc and rawget(muc,"get_room_from_jid") then + -- We're running >0.10 (new MUC API) + return muc.get_room_from_jid(room_jid); + else + return + end + end +end + +function async_handler_wrapper(event, handler) + if not have_async then + module:log("error", "requires a version of Prosody with util.async"); + return nil; + end + + local runner = async.runner; + + -- Grab a local response so that we can send the http response when + -- the handler is done. + local response = event.response; + local async_func = runner( + function (event) + local result = handler(event) + + -- If there is a status code in the result from the + -- wrapped handler then add it to the response. + if tonumber(result.status_code) ~= nil then + response.status_code = result.status_code + end + + -- If there are headers in the result from the + -- wrapped handler then add them to the response. + if result.headers ~= nil then + response.headers = result.headers + end + + -- Send the response to the waiting http client with + -- or without the body from the wrapped handler. + if result.body ~= nil then + response:send(result.body) + else + response:send(); + end + end + ) + async_func:run(event) + -- return true to keep the client http connection open. + return true; +end + +--- Updates presence stanza, by adding identity node +-- @param stanza the presence stanza +-- @param user the user to which presence we are updating identity +-- @param group the group of the user to which presence we are updating identity +-- @param creator_user the user who created the user which presence we +-- are updating (this is the poltergeist case, where a user creates +-- a poltergeist), optional. +-- @param creator_group the group of the user who created the user which +-- presence we are updating (this is the poltergeist case, where a user creates +-- a poltergeist), optional. +function update_presence_identity( + stanza, user, group, creator_user, creator_group) + + -- First remove any 'identity' element if it already + -- exists, so it cannot be spoofed by a client + stanza:maptags( + function(tag) + for k, v in pairs(tag) do + if k == "name" and v == "identity" then + return nil + end + end + return tag + end + ) + module:log("debug", + "Presence after previous identity stripped: %s", tostring(stanza)); + + stanza:tag("identity"):tag("user"); + for k, v in pairs(user) do + stanza:tag(k):text(v):up(); + end + stanza:up(); + + -- Add the group information if it is present + if group then + stanza:tag("group"):text(group):up(); + end + + -- Add the creator user information if it is present + if creator_user then + stanza:tag("creator_user"); + for k, v in pairs(creator_user) do + stanza:tag(k):text(v):up(); + end + stanza:up(); + + -- Add the creator group information if it is present + if creator_group then + stanza:tag("creator_group"):text(creator_group):up(); + end + stanza:up(); + end + + module:log("debug", + "Presence with identity inserted %s", tostring(stanza)) +end + +-- Utility function to check whether feature is present and enabled. Allow +-- a feature if there are features present in the session(coming from +-- the token) and the value of the feature is true. +-- If features is not present in the token we skip feature detection and allow +-- everything. +function is_feature_allowed(session, feature) + if (session.jitsi_meet_context_features == nil + or session.jitsi_meet_context_features[feature] == "true") then + return true; + else + return false; + end +end + +function starts_with(str, start) + return str:sub(1, #start) == start +end + +-- healthcheck rooms in jicofo starts with a string '__jicofo-health-check' +function is_healthcheck_room(room_jid) + if starts_with(room_jid, "__jicofo-health-check") then + return true; + end + + return false; +end + +-- Utility function to make an http get request and +-- retry @param retry number of times +-- @param url endpoint to be called +-- @param retry nr of retries, if retry is +-- nil there will be no retries +-- @returns result of the http call or nil if +-- the external call failed after the last retry +function http_get_with_retry(url, retry) + local content, code; + local timeout_occurred; + local wait, done = async.waiter(); + local function cb(content_, code_, response_, request_) + if timeout_occurred == nil then + code = code_; + if code == 200 or code == 204 then + module:log("debug", "External call was successful, content %s", content_); + content = content_ + else + module:log("warn", "Error on public key request: Code %s, Content %s", + code_, content_); + end + done(); + else + module:log("warn", "External call reply delivered after timeout from: %s", url); + end + end + + local function call_http() + return http.request(url, { + headers = http_headers or {}, + method = "GET" + }, cb); + end + + local request = call_http(); + + local function cancel() + -- TODO: This check is racey. Not likely to be a problem, but we should + -- still stick a mutex on content / code at some point. + if code == nil then + timeout_occurred = true; + module:log("warn", "Timeout %s seconds making the external call to: %s", http_timeout, url); + -- no longer present in prosody 0.11, so check before calling + if http.destroy_request ~= nil then + http.destroy_request(request); + end + if retry == nil then + module:log("debug", "External call failed and retry policy is not set"); + done(); + elseif retry ~= nil and retry < 1 then + module:log("debug", "External call failed after retry") + done(); + else + module:log("debug", "External call failed, retry nr %s", retry) + retry = retry - 1; + request = call_http() + return http_timeout; + end + end + end + timer.add_task(http_timeout, cancel); + wait(); + + return content; +end + +return { + is_feature_allowed = is_feature_allowed; + is_healthcheck_room = is_healthcheck_room; + get_room_from_jid = get_room_from_jid; + async_handler_wrapper = async_handler_wrapper; + room_jid_match_rewrite = room_jid_match_rewrite; + room_jid_split_subdomain = room_jid_split_subdomain; + internal_room_jid_match_rewrite = internal_room_jid_match_rewrite; + update_presence_identity = update_presence_identity; + http_get_with_retry = http_get_with_retry; +}; |
