0
0
Fork 0
mirror of https://github.com/matrix-construct/construct synced 2024-10-31 19:08:59 +01:00
construct/matrix/room_visible.cc
2021-02-02 07:54:26 -08:00

163 lines
4 KiB
C++

// 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.
namespace ircd::m
{
static bool visible_to_node(const room &, const string_view &node_id, const event &);
static bool visible_to_user(const room &, const string_view &history_visibility, const m::user::id &, const event &);
}
bool
ircd::m::visible(const m::event &event,
const string_view &mxid)
{
const m::room room
{
at<"room_id"_>(event), event.event_id
};
const m::room::state state
{
room
};
const event::idx visibility_event_idx
{
state.get(std::nothrow, "m.room.history_visibility", "")
};
char buf[32];
string_view history_visibility{"shared"};
m::get(std::nothrow, visibility_event_idx, "content", [&buf, &history_visibility]
(const json::object &content)
{
const json::string &_history_visibility
{
content.get("history_visibility", "shared")
};
history_visibility = strncpy
{
buf, _history_visibility
};
});
if(history_visibility == "world_readable")
return true;
if(empty(mxid))
return false;
if(rfc3986::valid_remote(std::nothrow, mxid))
return visible_to_node(room, mxid, event);
if(m::valid(m::id::USER, mxid))
{
const m::user::id user_id
{
mxid
};
if(visible_to_user(room, history_visibility, user_id, event))
return true;
// Unrestricted visibility for opers
if(is_oper(user_id))
return true;
return false;
}
throw m::UNSUPPORTED
{
"Cannot determine visibility of %s for '%s'",
string_view{room.room_id},
mxid,
};
}
bool
ircd::m::visible_to_user(const m::room &room,
const string_view &history_visibility,
const m::user::id &user_id,
const m::event &event)
{
assert(history_visibility != "world_readable");
// Allow any member event where the state_key string is a user mxid.
if(json::get<"type"_>(event) == "m.room.member")
if(at<"state_key"_>(event) == user_id)
return true;
// Get the membership of the user in the room at the event.
char buf[m::room::MEMBERSHIP_MAX_SIZE];
const string_view membership
{
m::membership(buf, room, user_id)
};
if(membership == "join")
return true;
if(history_visibility == "joined")
return false;
if(membership == "invite")
return true;
if(history_visibility == "invited")
return false;
// The history_visibility is now likely "shared"; though we cannot assert
// that in case some other string is used for any non-spec customization
// or for graceful forward compatibility. We default to "shared" here.
//assert(history_visibility == "shared");
// If the room is not at the present event then we have to run another
// test for membership here. Otherwise the "join" test already failed.
if(!room.event_id)
return false;
// An m::room instance with no event_id is used to query the room at the
// present state.
const m::room present
{
room.room_id
};
return m::membership(present, user_id, m::membership_positive); // join || invite
}
bool
ircd::m::visible_to_node(const m::room &room,
const string_view &node_id,
const m::event &event)
{
// Allow auth chain events XXX: this is too broad
if(m::room::auth::is_power_event(event))
return true;
// Allow any event where the state_key string is a user mxid and the server
// is the host of that user. Note that applies to any type of event.
if(m::valid(m::id::USER, json::get<"state_key"_>(event)))
if(m::user::id(at<"state_key"_>(event)).host() == node_id)
return true;
const m::room::origins origins
{
room
};
// Allow joined servers
if(origins.has(node_id))
return true;
return false;
}