Skip to content

Jitsi Meet - Secure, Simple and Scalable Video Conferences that you use as a standalone app or embed in your web application.

10.0 KB
Raw Blame
-- USAGE / DEPLOYMENT
--   These endpoints are meant to be used by trusted internal services (e.g.
--   monitoring, backend services checking room occupancy) over a controlled
--   network path. By default (enable_roomsize_token_verification = false)
--   they have no authentication, and GET /sessions never has any. In that
--   configuration it is NOT safe to make them publicly accessible: do not
--   proxy them from the public web server (nginx) and do not expose Prosody's
--   HTTP ports (5280/5281) to the internet. Restrict access at the web server
--   or with network filters.
--
--   When enable_roomsize_token_verification is true, /room-size and /room
--   require a token issued by this deployment (the virtual host token
--   configuration) that is valid for the requested room.
--
-- Prosody IM
-- Copyright (C) 2021-present 8x8, Inc.
--
-- mod_muc_size exposes HTTP endpoints that let external services query the
-- occupancy and participant details of MUC rooms managed by the associated
-- conference component. It provides three routes:
--
--   GET /room-size?room=<name>&domain=<base>[&subdomain=<sub>][&token=<jwt>]
--       Returns {"participants": N} where N is the non-focus occupant count.
--       Returns 404 when the room does not exist.
--
--   GET /room?room=<name>&domain=<base>[&subdomain=<sub>][&token=<jwt>]
--       Returns a JSON array of occupant objects {jid, email, display_name},
--       excluding the hidden Jitsi focus participant.
--       Returns 404 when the room does not exist.
--
--   GET /sessions
--       Returns the total number of active Prosody client sessions as a plain
--       integer string.
--
-- The room address is built as <room>@<muc_domain_prefix>.<domain>, optionally
-- prefixed with [<subdomain>] for multi-tenant deployments.
-- Token-based JWT verification is optional and controlled by the
-- enable_roomsize_token_verification module option (default: false).

local jid = require "util.jid";
local it = require "util.iterators";
local json = require 'cjson.safe';
local iterators = require "util.iterators";
local array = require"util.array";

local have_async = pcall(require, "util.async");
if not have_async then
    module:log("error", "requires a version of Prosody with util.async");
    return;
end

-- muc_domain_prefix is needed by the build_room_address fallback below.
local muc_domain_prefix
    = module:get_option_string("muc_mapper_domain_prefix", "conference");

-- Load shared utility library. If it fails (e.g. a transitive dependency is
-- missing in the current environment) log the error and fall back to inline
-- implementations so the HTTP routes are always registered.
local async_handler_wrapper, get_room_from_jid, build_room_address, is_focus, strip_jwt_signature;
local ok_util, util_or_err = pcall(function() return module:require "util" end);
if ok_util then
    local util = util_or_err;
    async_handler_wrapper = util.async_handler_wrapper;
    get_room_from_jid    = util.get_room_from_jid;
    build_room_address   = util.build_room_address;
    is_focus             = util.is_focus;
    strip_jwt_signature  = util.strip_jwt_signature;
else
    module:log("warn", "mod_muc_size: util.lib.lua unavailable (%s); using inline fallbacks",
        tostring(util_or_err));
    async_handler_wrapper = function(_, handler) return handler(_) end;
    get_room_from_jid = function(room_jid)
        local _, host = jid.split(room_jid);
        local component = hosts[host];
        if component then
            local muc = component.modules.muc;
            if muc then return muc.get_room_from_jid(room_jid) end
        end
    end;
    build_room_address = function(room_name, domain_name, subdomain)
        local addr = jid.join(room_name, muc_domain_prefix.."."..domain_name);
        if subdomain and subdomain ~= "" then
            addr = "["..subdomain.."]"..addr;
        end
        return addr;
    end;
    is_focus = function(nick)
        return string.sub(nick, -string.len("/focus")) == "/focus";
    end;
    strip_jwt_signature = function(token)
        if token == nil then return nil end
        return tostring(token):match('^([^.]*%.[^.]*)%.') or '[redacted]';
    end;
end

local tostring = tostring;

-- Simple query-string parser: "room=foo&domain=bar" → { room="foo", domain="bar" }.
-- Avoids a dependency on the optional third-party net.url LuaRocks module.
local function parse(q)
    local t = {};
    for k, v in (q or ""):gmatch("([^=&]+)=([^&]*)") do
        t[k] = v;
    end
    return t;
end

-- option to enable/disable room API token verifications
local enableTokenVerification
    = module:get_option_boolean("enable_roomsize_token_verification", false);

local ok, token_util_mod = pcall(function() return module:require "token/util" end);
local token_util = ok and token_util_mod and token_util_mod.new(module) or nil;

-- no token configuration but required
if token_util == nil and enableTokenVerification then
    log("error", "no token configuration but it is required");
    return;
end

--- Verifies room name, domain name with the values in the token
-- @param token the token we received
-- @param room_address the full room address jid
-- @return true if values are ok or false otherwise
function verify_token(token, room_address)
    if not enableTokenVerification then
        return true;
    end

    -- if enableTokenVerification is enabled and we do not have token
    -- stop here, cause the main virtual host can have guest access enabled
    -- (allowEmptyToken = true) and we will allow access to rooms info without
    -- a token
    if token == nil then
        log("warn", "no token provided");
        return false;
    end

    local session = {};
    session.auth_token = token;
    local verified, reason = token_util:process_and_verify_token(session);
    if not verified then
        log("warn", "not a valid token %s", tostring(reason));
        return false;
    end

    if not token_util:verify_room(session, room_address) then
        log("warn", "Token %s not allowed to join: %s token room: %s token sub: %s",
            tostring(strip_jwt_signature(token)), tostring(room_address), tostring(session.jitsi_meet_room),
            tostring(session.jitsi_meet_domain));
        return false;
    end

    return true;
end

--- Handles request for retrieving the room size
-- @param event the http event, holds the request query
-- @return GET response, containing a json with participants count,
--         the value is without counting the focus.
function handle_get_room_size(event)
    if (not event.request.url.query) then
        return { status_code = 400; };
    end

    local params = parse(event.request.url.query);
    local room_name = params["room"];
    local domain_name = params["domain"];
    local subdomain = params["subdomain"];

    local room_address = build_room_address(room_name, domain_name, subdomain);

    if not verify_token(params["token"], room_address) then
        return { status_code = 403; };
    end

    local room = get_room_from_jid(room_address);
    local participant_count = 0;

    log("debug", "Querying room %s", tostring(room_address));

    if room then
        local occupants = room._occupants;
        if occupants then
            participant_count = iterators.count(room:each_occupant());
        end
        log("debug",
            "there are %s occupants in room", tostring(participant_count));
    else
        log("debug", "no such room exists");
        return { status_code = 404; };
    end

    if participant_count > 1 then
        participant_count = participant_count - 1;
    end

    return { status_code = 200; body = [[{"participants":]]..participant_count..[[}]] };
end

--- Handles request for retrieving the room participants details
-- @param event the http event, holds the request query
-- @return GET response, containing a json with participants details
function handle_get_room (event)
    if (not event.request.url.query) then
        return { status_code = 400; };
    end

    local params = parse(event.request.url.query);
    local room_name = params["room"];
    local domain_name = params["domain"];
    local subdomain = params["subdomain"];

    local room_address = build_room_address(room_name, domain_name, subdomain);

    if not verify_token(params["token"], room_address) then
        return { status_code = 403; };
    end

    local room = get_room_from_jid(room_address);
    local participant_count = 0;
    local occupants_json = array();

    log("debug", "Querying room %s", tostring(room_address));

    if room then
        local occupants = room._occupants;
        if occupants then
            participant_count = iterators.count(room:each_occupant());
            for _, occupant in room:each_occupant() do
                -- filter focus as we keep it as hidden participant
                if not is_focus(occupant.nick) then
                    for _, pr in occupant:each_session() do
                        local nick = pr:get_child_text("nick", "http://jabber.org/protocol/nick") or "";
                        local email = pr:get_child_text("email") or "";
                        occupants_json:push({
                            jid = tostring(occupant.nick),
                            email = tostring(email),
                            display_name = tostring(nick)});
                    end
                end
            end
        end
        log("debug",
            "there are %s occupants in room", tostring(participant_count));
    else
        log("debug", "no such room exists");
        return { status_code = 404; };
    end

    if participant_count > 1 then
        participant_count = participant_count - 1;
    end

    return { status_code = 200; body = json.encode(occupants_json); };
end;

module:provides("http", {
    default_path = "/";
    route = {
        ["GET /room-size"] = function (event) return async_handler_wrapper(event,handle_get_room_size) end;
        ["GET /sessions"] = function () return tostring(it.count(it.keys(prosody.full_sessions))); end;
        ["GET /room"] = function (event) return async_handler_wrapper(event,handle_get_room) end;
    };
});