mirror of
https://github.com/matrix-construct/construct
synced 2024-11-05 05:18:54 +01:00
671 lines
14 KiB
C++
671 lines
14 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 void auth_room_create(const event &, room::auth::hookdata &);
|
|
extern hookfn<room::auth::hookdata &> auth_room_create_hookfn;
|
|
|
|
static void created_room(const event &, vm::eval &);
|
|
extern hookfn<vm::eval &> created_room_hookfn;
|
|
}
|
|
|
|
ircd::mapi::header
|
|
IRCD_MODULE
|
|
{
|
|
"Matrix m.room.create"
|
|
};
|
|
|
|
decltype(ircd::m::createroom::version_default)
|
|
IRCD_MODULE_EXPORT_DATA
|
|
ircd::m::createroom::version_default
|
|
{
|
|
{ "name", "ircd.m.createroom.version_default" },
|
|
{ "default", "5" },
|
|
};
|
|
|
|
decltype(ircd::m::createroom::spec_presets)
|
|
IRCD_MODULE_EXPORT_DATA
|
|
ircd::m::createroom::spec_presets
|
|
{
|
|
"private_chat",
|
|
"public_chat",
|
|
"trusted_private_chat",
|
|
};
|
|
|
|
bool
|
|
IRCD_MODULE_EXPORT
|
|
ircd::m::createroom::spec_preset(const string_view &preset)
|
|
{
|
|
const auto &s(spec_presets);
|
|
return std::find(begin(s), end(s), preset) != end(s);
|
|
}
|
|
|
|
//
|
|
// an effect of room created
|
|
//
|
|
|
|
decltype(ircd::m::created_room_hookfn)
|
|
ircd::m::created_room_hookfn
|
|
{
|
|
created_room,
|
|
{
|
|
{ "_site", "vm.effect" },
|
|
{ "type", "m.room.create" },
|
|
}
|
|
};
|
|
|
|
void
|
|
ircd::m::created_room(const m::event &event,
|
|
m::vm::eval &)
|
|
try
|
|
{
|
|
const m::user::id &sender
|
|
{
|
|
at<"sender"_>(event)
|
|
};
|
|
|
|
const auto &level
|
|
{
|
|
my(sender) && sender != m::me?
|
|
log::INFO:
|
|
log::DEBUG
|
|
};
|
|
|
|
log::logf
|
|
{
|
|
m::log, level, "Created room %s with %s by %s",
|
|
json::get<"room_id"_>(event),
|
|
json::get<"sender"_>(event),
|
|
string_view{event.event_id},
|
|
};
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
log::error
|
|
{
|
|
m::log, "Effect of creating room %s with %s by %s :%s",
|
|
json::get<"room_id"_>(event),
|
|
string_view{event.event_id},
|
|
json::get<"sender"_>(event),
|
|
e.what()
|
|
};
|
|
}
|
|
|
|
//
|
|
// auth handler
|
|
//
|
|
|
|
decltype(ircd::m::auth_room_create_hookfn)
|
|
ircd::m::auth_room_create_hookfn
|
|
{
|
|
auth_room_create,
|
|
{
|
|
{ "_site", "room.auth" },
|
|
{ "type", "m.room.create" },
|
|
}
|
|
};
|
|
|
|
void
|
|
ircd::m::auth_room_create(const event &event,
|
|
room::auth::hookdata &data)
|
|
{
|
|
using FAIL = m::room::auth::FAIL;
|
|
using conforms = m::event::conforms;
|
|
|
|
// 1. If type is m.room.create:
|
|
assert(json::get<"type"_>(event) == "m.room.create");
|
|
|
|
// a. If it has any previous events, reject.
|
|
if(count(data.prev))
|
|
throw FAIL
|
|
{
|
|
"m.room.create has previous events."
|
|
};
|
|
|
|
// b. If the domain of the room_id does not match the domain of the
|
|
// sender, reject.
|
|
if(conforms(event).has(conforms::MISMATCH_CREATE_SENDER))
|
|
throw FAIL
|
|
{
|
|
"m.room.create room_id domain does not match sender domain."
|
|
};
|
|
|
|
// c. If content.room_version is present and is not a recognised
|
|
// version, reject.
|
|
if(json::get<"content"_>(event).has("room_version"))
|
|
{
|
|
const json::string &claim_version
|
|
{
|
|
json::get<"content"_>(event).get("room_version", "1"_sv)
|
|
};
|
|
|
|
const string_view &id_version
|
|
{
|
|
event.event_id.version()
|
|
};
|
|
|
|
if(claim_version == "1" || claim_version == "2")
|
|
{
|
|
// When the claimed version is 1 or 2 we don't actually
|
|
// care if the event_id is version 1, 3 or 4 etc; the server
|
|
// has eliminated use of the event_id hostpart in all rooms.
|
|
|
|
//if(id_version != "1")
|
|
// throw FAIL
|
|
// {
|
|
// "m.room.create room_version not 1"
|
|
// };
|
|
}
|
|
else if(claim_version == "3")
|
|
{
|
|
if(id_version != "3")
|
|
throw FAIL
|
|
{
|
|
"m.room.create room_version not 3"
|
|
};
|
|
}
|
|
else if(claim_version == "4")
|
|
{
|
|
if(id_version != "4")
|
|
throw FAIL
|
|
{
|
|
"m.room.create room_version not 4"
|
|
};
|
|
}
|
|
else
|
|
{
|
|
// Note that id_version reports "4" even for version "5"
|
|
// and beyond room versions. When a room version requires
|
|
// a new ID version these branches must be updated.
|
|
if(id_version != "4")
|
|
throw FAIL
|
|
{
|
|
"m.room.create room_version not 4"
|
|
};
|
|
}
|
|
}
|
|
|
|
// d. If content has no creator field, reject.
|
|
if(empty(json::get<"content"_>(event).get("creator")))
|
|
throw FAIL
|
|
{
|
|
"m.room.create content.creator is missing."
|
|
};
|
|
|
|
// e. Otherwise, allow.
|
|
data.allow = true;
|
|
}
|
|
|
|
namespace ircd::m
|
|
{
|
|
struct report_error;
|
|
|
|
static room _create_event(const createroom &);
|
|
}
|
|
|
|
struct ircd::m::report_error
|
|
{
|
|
static thread_local char buf[512];
|
|
|
|
template<class... args>
|
|
report_error(json::stack::array *const &errors,
|
|
const string_view &room_id,
|
|
const string_view &user_id,
|
|
const string_view &fmt,
|
|
args&&... a);
|
|
};
|
|
|
|
ircd::m::room
|
|
IRCD_MODULE_EXPORT
|
|
ircd::m::create(const createroom &c,
|
|
json::stack::array *const &errors)
|
|
try
|
|
{
|
|
const m::user::id &creator
|
|
{
|
|
at<"creator"_>(c)
|
|
};
|
|
|
|
// Initial create event is committed here first; note that this means the
|
|
// room is officially created and known to the system when this object
|
|
// constructs. Since this overall process including the rest of this scope
|
|
// is not naturally atomic, we shouldn't throw and abort after this point
|
|
// otherwise the full multi-event creation will not be completed. After
|
|
// this point we should report all errors to the errors array.
|
|
const room room
|
|
{
|
|
_create_event(c)
|
|
};
|
|
|
|
const m::room::id &room_id
|
|
{
|
|
room.room_id
|
|
};
|
|
assert(room_id == json::get<"room_id"_>(c));
|
|
|
|
const json::string preset
|
|
{
|
|
json::get<"preset"_>(c)
|
|
};
|
|
|
|
// creator join event
|
|
|
|
// user rooms don't have their user joined to them at this time otherwise
|
|
// they'll appear to clients.
|
|
if(!preset || createroom::spec_preset(preset))
|
|
{
|
|
const event::id::buf join_event_id
|
|
{
|
|
join(room, creator)
|
|
};
|
|
}
|
|
|
|
// initial power_levels
|
|
|
|
// initial power levels aren't set on internal user rooms for now.
|
|
if(!preset || createroom::spec_preset(preset)) try
|
|
{
|
|
thread_local char content_buf[8_KiB];
|
|
const json::object content
|
|
{
|
|
// If there is an override, use it
|
|
json::get<"power_level_content_override"_>(c)?
|
|
json::get<"power_level_content_override"_>(c):
|
|
|
|
// Otherwise generate the default content which allows our closure
|
|
// to add some items to the collections while it's buffering.
|
|
m::room::power::compose_content(content_buf, [&c, &creator, &preset]
|
|
(const string_view &key, json::stack::object &object)
|
|
{
|
|
if(key != "users")
|
|
return;
|
|
|
|
// Give the creator their power in the users collection
|
|
json::stack::member
|
|
{
|
|
object, creator, json::value(room::power::default_creator_level)
|
|
};
|
|
|
|
// For trusted_private_chat we need to promote everyone invited
|
|
// to the same level in the users collection
|
|
if(preset != "trusted_private_chat")
|
|
return;
|
|
|
|
for(const json::string &user_id : json::get<"invite"_>(c))
|
|
if(valid(id::USER, user_id))
|
|
json::stack::member
|
|
{
|
|
object, user_id, json::value(room::power::default_creator_level)
|
|
};
|
|
})
|
|
};
|
|
|
|
send(room, creator, "m.room.power_levels", "", content);
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set power_levels: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// initial join_rules
|
|
|
|
const string_view &join_rule
|
|
{
|
|
preset == "private_chat"? "invite":
|
|
preset == "trusted_private_chat"? "invite":
|
|
preset == "public_chat"? "public":
|
|
"invite"
|
|
};
|
|
|
|
if(join_rule != "invite") try
|
|
{
|
|
send(room, creator, "m.room.join_rules", "",
|
|
{
|
|
{ "join_rule", join_rule }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set join_rules: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// initial history_visibility
|
|
|
|
const string_view &history_visibility
|
|
{
|
|
preset == "private_chat"? "shared":
|
|
preset == "trusted_private_chat"? "shared":
|
|
preset == "public_chat"? "shared":
|
|
"shared"
|
|
};
|
|
|
|
if(history_visibility != "shared") try
|
|
{
|
|
send(room, creator, "m.room.history_visibility", "",
|
|
{
|
|
{ "history_visibility", history_visibility }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set history_visibility: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// initial guest_access
|
|
|
|
const string_view &guest_access
|
|
{
|
|
preset == "private_chat"? "forbidden":
|
|
preset == "trusted_private_chat"? "forbidden":
|
|
preset == "public_chat"? "forbidden":
|
|
"forbidden"
|
|
};
|
|
|
|
if(guest_access == "can_join") try
|
|
{
|
|
send(room, creator, "m.room.guest_access", "",
|
|
{
|
|
{ "guest_access", "can_join" }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set guest_access: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// user's initial state vector
|
|
//
|
|
// Takes precedence over events set by preset, but gets overriden by name
|
|
// and topic keys.
|
|
|
|
size_t i(0);
|
|
for(const json::object &event : json::get<"initial_state"_>(c)) try
|
|
{
|
|
const json::string &type(event["type"]);
|
|
const json::string &state_key(event["state_key"]);
|
|
const json::object &content(event["content"]);
|
|
send(room, creator, type, state_key, content);
|
|
++i;
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set initial_state event @%zu: %s",
|
|
i++,
|
|
e.what()
|
|
};
|
|
}
|
|
|
|
// override room name
|
|
|
|
if(json::get<"name"_>(c)) try
|
|
{
|
|
static const size_t name_max_len
|
|
{
|
|
// 14.2.1.3: The name of the room. This MUST NOT exceed 255 bytes.
|
|
255
|
|
};
|
|
|
|
const auto name
|
|
{
|
|
trunc(json::get<"name"_>(c), name_max_len)
|
|
};
|
|
|
|
send(room, creator, "m.room.name", "",
|
|
{
|
|
{ "name", name }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set room name: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// override topic
|
|
|
|
if(json::get<"topic"_>(c)) try
|
|
{
|
|
send(room, creator, "m.room.topic", "",
|
|
{
|
|
{ "topic", json::get<"topic"_>(c) }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set room topic: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// invitation vector
|
|
|
|
for(const json::string &_user_id : json::get<"invite"_>(c)) try
|
|
{
|
|
json::iov content;
|
|
const json::iov::add is_direct // Conditionally add is_direct
|
|
{
|
|
content, json::get<"is_direct"_>(c),
|
|
{
|
|
"is_direct", []() -> json::value { return json::literal_true; }
|
|
}
|
|
};
|
|
|
|
const m::user::id &user_id{_user_id};
|
|
invite(room, user_id, creator, content);
|
|
}
|
|
catch(const m::error &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to invite user '%s' :%s :%s :%s",
|
|
_user_id,
|
|
e.what(),
|
|
e.errcode(),
|
|
e.errstr()
|
|
};
|
|
|
|
// For DM's if we can't invite the counter-party there's no point in
|
|
// creating the room, we can just abort instead.
|
|
if(json::get<"is_direct"_>(c))
|
|
throw;
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to invite user '%s' :%s",
|
|
_user_id,
|
|
e.what()
|
|
};
|
|
}
|
|
|
|
// override guest_access
|
|
|
|
if(json::get<"guest_can_join"_>(c) && guest_access != "can_join") try
|
|
{
|
|
send(room, creator, "m.room.guest_access", "",
|
|
{
|
|
{ "guest_access", "can_join" }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set guest_access: %s", e.what()
|
|
};
|
|
}
|
|
|
|
// room directory
|
|
|
|
if(json::get<"visibility"_>(c) == "public") try
|
|
{
|
|
// This call sends a message to the !public room to list this room in the
|
|
// public rooms list. We set an empty summary for this room because we
|
|
// already have its state on this server;
|
|
m::rooms::summary::set(room.room_id, json::object{});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set public visibility: %s", e.what()
|
|
};
|
|
}
|
|
|
|
return room;
|
|
}
|
|
catch(const db::not_found &e)
|
|
{
|
|
throw m::error
|
|
{
|
|
http::CONFLICT, "M_ROOM_IN_USE", "The desired room name is in use."
|
|
};
|
|
|
|
throw m::error
|
|
{
|
|
http::CONFLICT, "M_ROOM_ALIAS_IN_USE", "An alias of the desired room is in use."
|
|
};
|
|
|
|
//XXX: clearly a conflict
|
|
}
|
|
|
|
ircd::m::room
|
|
ircd::m::_create_event(const createroom &c)
|
|
{
|
|
const m::user::id &creator
|
|
{
|
|
at<"creator"_>(c)
|
|
};
|
|
|
|
const auto &type
|
|
{
|
|
json::get<"preset"_>(c)
|
|
};
|
|
|
|
const auto &parent
|
|
{
|
|
json::get<"parent_room_id"_>(c)
|
|
};
|
|
|
|
const json::object &user_content
|
|
{
|
|
json::get<"creation_content"_>(c)
|
|
};
|
|
|
|
const size_t user_content_count
|
|
{
|
|
std::min(size(user_content), 16UL) // cap the number of keys
|
|
};
|
|
|
|
const room room
|
|
{
|
|
at<"room_id"_>(c)
|
|
};
|
|
|
|
json::iov event;
|
|
json::iov content;
|
|
json::iov::push _user_content[user_content_count];
|
|
make_iov(content, _user_content, user_content_count, user_content);
|
|
const json::iov::push push[]
|
|
{
|
|
{ event, { "room_id", room.room_id }},
|
|
{ event, { "depth", 0L }},
|
|
{ event, { "sender", creator }},
|
|
{ event, { "state_key", "" }},
|
|
{ event, { "type", "m.room.create" }},
|
|
{ content, { "creator", creator }},
|
|
};
|
|
|
|
const json::iov::add _type
|
|
{
|
|
content, !type.empty() && type != "room",
|
|
{
|
|
"type", [&type]() -> json::value
|
|
{
|
|
return type;
|
|
}
|
|
}
|
|
};
|
|
|
|
const string_view &room_version
|
|
{
|
|
json::get<"room_version"_>(c)?
|
|
string_view{json::get<"room_version"_>(c)}:
|
|
string_view{m::createroom::version_default}
|
|
};
|
|
|
|
const json::iov::push _room_version
|
|
{
|
|
content,
|
|
{
|
|
"room_version", json::value
|
|
{
|
|
room_version, json::STRING
|
|
}
|
|
}
|
|
};
|
|
|
|
m::vm::copts opts;
|
|
opts.room_version = room_version;
|
|
opts.verify = false;
|
|
m::vm::eval
|
|
{
|
|
event, content, opts
|
|
};
|
|
|
|
return room;
|
|
}
|
|
|
|
decltype(ircd::m::report_error::buf)
|
|
thread_local
|
|
ircd::m::report_error::buf;
|
|
|
|
template<class... args>
|
|
ircd::m::report_error::report_error(json::stack::array *const &errors,
|
|
const string_view &room_id,
|
|
const string_view &user_id,
|
|
const string_view &fmt,
|
|
args&&... a)
|
|
{
|
|
const string_view msg{fmt::sprintf
|
|
{
|
|
buf, fmt, std::forward<args>(a)...
|
|
}};
|
|
|
|
log::derror
|
|
{
|
|
m::log, "Error when creating room %s for user %s :%s",
|
|
room_id,
|
|
user_id,
|
|
msg
|
|
};
|
|
|
|
if(errors)
|
|
errors->append(msg);
|
|
}
|