554 lines
12 KiB
C++
554 lines
12 KiB
C++
// Matrix Construct
|
|
//
|
|
// Copyright (C) Matrix Construct Developers, Authors & Contributors
|
|
// Copyright (C) 2016-2019 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
|
|
{
|
|
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);
|
|
};
|
|
|
|
decltype(ircd::m::createroom::version_default)
|
|
ircd::m::createroom::version_default
|
|
{
|
|
{ "name", "ircd.m.createroom.version_default" },
|
|
{ "default", "6" },
|
|
};
|
|
|
|
decltype(ircd::m::createroom::spec_presets)
|
|
ircd::m::createroom::spec_presets
|
|
{
|
|
"private_chat",
|
|
"public_chat",
|
|
"trusted_private_chat",
|
|
};
|
|
|
|
ircd::m::room
|
|
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 m.room.canonical_alias (room_alias_name)
|
|
|
|
if(json::get<"room_alias_name"_>(c)) try
|
|
{
|
|
const id::room_alias::buf canonical_alias_buf
|
|
{
|
|
json::get<"room_alias_name"_>(c), origin(my())
|
|
};
|
|
|
|
const json::value canonical_alias
|
|
{
|
|
canonical_alias_buf
|
|
};
|
|
|
|
send(room, creator, "m.room.aliases", origin(my()),
|
|
{
|
|
{ "aliases", json::value { &canonical_alias, 1 } }
|
|
});
|
|
|
|
send(room, creator, "m.room.canonical_alias", "",
|
|
{
|
|
{ "alias", canonical_alias }
|
|
});
|
|
}
|
|
catch(const std::exception &e)
|
|
{
|
|
report_error
|
|
{
|
|
errors, room_id, creator, "Failed to set room_alias_name :%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"
|
|
};
|
|
|
|
// Riot won't allow changing the join_rules unless the event exists.
|
|
if(join_rule != "invite" || createroom::spec_preset(preset)) 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", "", json::members
|
|
{
|
|
{ "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", "", json::members
|
|
{
|
|
{ "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);
|
|
}
|
|
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
|
|
}
|
|
|
|
bool
|
|
ircd::m::createroom::spec_preset(const string_view &preset)
|
|
{
|
|
const auto &s(spec_presets);
|
|
return std::find(begin(s), end(s), preset) != end(s);
|
|
}
|
|
|
|
//
|
|
// internal
|
|
//
|
|
|
|
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, { "auth_events", "[]" }},
|
|
{ event, { "depth", 0L }},
|
|
{ event, { "prev_events", "[]" }},
|
|
{ event, { "room_id", room.room_id }},
|
|
{ event, { "sender", creator }},
|
|
{ event, { "state_key", "" }},
|
|
{ event, { "type", "m.room.create" }},
|
|
{ content, { "creator", creator }},
|
|
};
|
|
|
|
const bool add_creation_type
|
|
{
|
|
!type.empty() && type != "room" && !user_content.has("type")
|
|
};
|
|
|
|
const json::iov::add _type
|
|
{
|
|
content, add_creation_type,
|
|
{
|
|
"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.phase.reset(vm::phase::VERIFY);
|
|
m::vm::eval
|
|
{
|
|
event, content, opts
|
|
};
|
|
|
|
return room;
|
|
}
|
|
|
|
//
|
|
// report_error
|
|
//
|
|
|
|
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);
|
|
}
|