mirror of
https://github.com/matrix-construct/construct
synced 2024-07-05 01:58:35 +02:00
781 lines
16 KiB
C++
781 lines
16 KiB
C++
/*
|
|
* Copyright (C) 2016 Charybdis Development Team
|
|
* Copyright (C) 2016 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.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
|
|
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
|
|
* INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include <ircd/m.h>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/session.h
|
|
//
|
|
|
|
ircd::m::session::session(const host_port &host_port)
|
|
:client{host_port}
|
|
{
|
|
}
|
|
|
|
ircd::json::object
|
|
ircd::m::session::operator()(parse::buffer &pb,
|
|
request &r)
|
|
{
|
|
parse::capstan pc
|
|
{
|
|
pb, read_closure(*this)
|
|
};
|
|
|
|
http::request
|
|
{
|
|
host(remote_addr(*this)),
|
|
r.method,
|
|
r.path,
|
|
r.query,
|
|
std::string(r),
|
|
write_closure(*this),
|
|
{
|
|
{ "Content-Type"s, "application/json"s }
|
|
}
|
|
};
|
|
|
|
http::code status;
|
|
json::object object;
|
|
http::response
|
|
{
|
|
pc,
|
|
nullptr,
|
|
[&pc, &status, &object](const http::response::head &head)
|
|
{
|
|
status = http::status(head.status);
|
|
object = http::response::content{pc, head};
|
|
}
|
|
};
|
|
|
|
if(status < 200 || status >= 300)
|
|
throw m::error(status, object);
|
|
|
|
return object;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m.h
|
|
//
|
|
|
|
namespace ircd {
|
|
namespace m {
|
|
|
|
std::map<std::string, ircd::module> modules;
|
|
ircd::listener *listener;
|
|
|
|
void bootstrap();
|
|
|
|
} // namespace m
|
|
} // namespace ircd
|
|
|
|
ircd::m::init::init()
|
|
{
|
|
if(db::sequence(*events::events) == 0)
|
|
bootstrap();
|
|
|
|
for(const auto &name : mods::available())
|
|
if(startswith(name, "client_"))
|
|
modules.emplace(name, name);
|
|
|
|
modules.emplace("root.so"s, "root.so"s);
|
|
|
|
//TODO: conf obviously
|
|
listener = new ircd::listener
|
|
{
|
|
json::string(json::members
|
|
{
|
|
{ "name", "Chat Matrix" },
|
|
{ "host", "0.0.0.0" },
|
|
{ "port", 8447 },
|
|
{ "ssl_certificate_file", "/home/jason/zemos.net.tls.crt" },
|
|
{ "ssl_certificate_chain_file", "/home/jason/zemos.net.tls.crt" },
|
|
{ "ssl_tmp_dh_file", "/home/jason/zemos.net.tls.dh" },
|
|
{ "ssl_private_key_file_pem", "/home/jason/zemos.net.tls.key" },
|
|
})
|
|
};
|
|
}
|
|
|
|
ircd::m::init::~init()
|
|
noexcept
|
|
{
|
|
delete listener;
|
|
modules.clear();
|
|
}
|
|
|
|
void
|
|
ircd::m::bootstrap()
|
|
{
|
|
assert(events::events);
|
|
assert(db::sequence(*events::events) == 0);
|
|
|
|
ircd::log::notice
|
|
(
|
|
"This appears to be your first time running IRCd because the events "
|
|
"database is empty. I will be bootstrapping it with initial events now..."
|
|
);
|
|
|
|
// ircd.create event
|
|
const m::id::id::room::buf room_id{"ircd", "localhost"};
|
|
const m::id::id::user::buf user_id{"ircd", "localhost"};
|
|
{
|
|
const auto type{"m.room.create"};
|
|
|
|
char content[512];
|
|
print(content, sizeof(content), json::members
|
|
{
|
|
{ "creator", user_id },
|
|
});
|
|
|
|
m::event event
|
|
{
|
|
{ "room_id", room_id },
|
|
{ "type", type },
|
|
{ "state_key", "" },
|
|
{ "sender", user_id },
|
|
{ "content", content },
|
|
};
|
|
|
|
m::events::insert(event);
|
|
}
|
|
|
|
{
|
|
const auto type{"m.room.member"};
|
|
|
|
char content[512];
|
|
print(content, sizeof(content), json::members
|
|
{
|
|
{ "membership", "join" },
|
|
});
|
|
|
|
m::event event
|
|
{
|
|
{ "room_id", room_id },
|
|
{ "type", type },
|
|
{ "state_key", user_id },
|
|
{ "sender", user_id },
|
|
{ "content", content },
|
|
};
|
|
|
|
m::events::insert(event);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/db.h
|
|
//
|
|
|
|
namespace ircd::m::dbs
|
|
{
|
|
std::map<std::string, ircd::module> modules;
|
|
std::map<std::string, import_shared<database>> databases;
|
|
|
|
void init_modules();
|
|
void init_databases();
|
|
}
|
|
|
|
ircd::m::dbs::init::init()
|
|
{
|
|
init_modules();
|
|
init_databases();
|
|
|
|
ircd::m::events::events = databases.at("events").get();
|
|
}
|
|
|
|
ircd::m::dbs::init::~init()
|
|
noexcept
|
|
{
|
|
ircd::m::events::events = nullptr;
|
|
|
|
databases.clear();
|
|
modules.clear();
|
|
}
|
|
|
|
void
|
|
ircd::m::dbs::init_databases()
|
|
{
|
|
for(const auto &pair : modules)
|
|
{
|
|
const auto &name(pair.first);
|
|
const auto dbname(mods::unpostfixed(name));
|
|
const std::string shortname(lstrip(dbname, "db_"));
|
|
const std::string symname(shortname + "_database"s);
|
|
databases.emplace(shortname, import_shared<database>
|
|
{
|
|
dbname, symname
|
|
});
|
|
}
|
|
}
|
|
|
|
void
|
|
ircd::m::dbs::init_modules()
|
|
{
|
|
for(const auto &name : mods::available())
|
|
if(startswith(name, "db_"))
|
|
modules.emplace(name, name);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/events.h
|
|
//
|
|
|
|
namespace ircd::m::events
|
|
{
|
|
void write(const event &);
|
|
}
|
|
|
|
ircd::database *ircd::m::events::events;
|
|
|
|
void
|
|
ircd::m::events::insert(json::iov &iov)
|
|
{
|
|
const id::event::buf generated_event_id
|
|
{
|
|
iov.has("event_id")? id::event::buf{} : id::event::buf{id::generate, "cdc.z"}
|
|
};
|
|
|
|
const json::iov::add event_id
|
|
{
|
|
iov, { "event_id", generated_event_id }
|
|
};
|
|
|
|
const json::iov::add origin_server_ts
|
|
{
|
|
iov, { "origin_server_ts", time<milliseconds>() }
|
|
};
|
|
|
|
insert(event{iov});
|
|
}
|
|
|
|
void
|
|
ircd::m::events::insert(const event &event)
|
|
{
|
|
if(!json::val<name::type>(event))
|
|
throw BAD_JSON("Required event field: '%s'", name::type);
|
|
|
|
if(!json::val<name::sender>(event))
|
|
throw BAD_JSON("Required event field: '%s'", name::sender);
|
|
|
|
if(!json::val<name::event_id>(event))
|
|
throw BAD_JSON("Required event field: '%s'", name::event_id);
|
|
|
|
if(!json::val<name::origin_server_ts>(event))
|
|
throw BAD_JSON("Required event field: '%s'", name::origin_server_ts);
|
|
|
|
for(const auto &transition : events::transitions)
|
|
if(!transition->valid(event))
|
|
throw INVALID_TRANSITION("Event insertion refused: '%s'",
|
|
transition->name);
|
|
|
|
write(event);
|
|
}
|
|
|
|
ircd::m::events::const_iterator
|
|
ircd::m::events::find(const id &id)
|
|
{
|
|
cursor cur{"!room_id$event_id"};
|
|
return cur.find(id);
|
|
}
|
|
|
|
ircd::m::events::const_iterator
|
|
ircd::m::events::begin()
|
|
{
|
|
cursor cur{"!room_id$event_id"};
|
|
return cur.begin();
|
|
}
|
|
|
|
ircd::m::events::const_iterator
|
|
ircd::m::events::end()
|
|
{
|
|
cursor cur{"!room_id$event_id"};
|
|
return cur.end();
|
|
}
|
|
|
|
ircd::m::events::transition_list
|
|
ircd::m::events::transitions
|
|
{};
|
|
|
|
ircd::m::events::transition::transition(const char *const &name)
|
|
:name{name}
|
|
,it
|
|
{
|
|
events::transitions, events::transitions.emplace(events::transitions.end(), this)
|
|
}
|
|
{
|
|
}
|
|
|
|
ircd::m::events::transition::transition(const char *const &name,
|
|
struct method method)
|
|
:name{name}
|
|
,method{std::move(method)}
|
|
,it
|
|
{
|
|
events::transitions, events::transitions.emplace(events::transitions.end(), this)
|
|
}
|
|
{
|
|
}
|
|
|
|
ircd::m::events::transition::~transition()
|
|
noexcept
|
|
{
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::transition::valid(const event &event)
|
|
const
|
|
{
|
|
return method.valid(event);
|
|
}
|
|
|
|
void
|
|
ircd::m::events::transition::effects(const event &event)
|
|
{
|
|
method.effects(event);
|
|
}
|
|
|
|
void
|
|
ircd::m::events::write(const event &event)
|
|
{
|
|
const auto &master_index
|
|
{
|
|
at<name::event_id>(event)
|
|
};
|
|
|
|
constexpr const size_t num_indexes(1);
|
|
constexpr const size_t num_deltas
|
|
{
|
|
event.size() + num_indexes
|
|
};
|
|
|
|
size_t i(0);
|
|
db::delta deltas[num_deltas];
|
|
for_each(event, [&i, &deltas, &master_index]
|
|
(const auto &key, const auto &val)
|
|
{
|
|
deltas[i++] =
|
|
{
|
|
key, // col
|
|
master_index, // key
|
|
byte_view<>{val}, // val
|
|
};
|
|
});
|
|
|
|
char buf[id::event::buf::SIZE + id::room::buf::SIZE];
|
|
if(!json::val<name::room_id>(event).empty())
|
|
{
|
|
strlcpy(buf, json::val<name::room_id>(event).data(), sizeof(buf));
|
|
strlcat(buf, json::val<name::event_id>(event).data(), sizeof(buf));
|
|
deltas[i++] = db::delta
|
|
{
|
|
"!room_id$event_id", // col
|
|
buf, // key
|
|
};
|
|
}
|
|
|
|
(*events)(begin(deltas), begin(deltas) + i);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/room.h
|
|
//
|
|
|
|
void
|
|
ircd::m::room::join(const m::id::user &user_id,
|
|
json::iov &content)
|
|
{
|
|
json::iov::set membership_join
|
|
{
|
|
content, { "membership", "join" }
|
|
};
|
|
|
|
membership(user_id, content);
|
|
}
|
|
|
|
void
|
|
ircd::m::room::membership(const m::id::user &user_id,
|
|
json::iov &content)
|
|
{
|
|
if(is_member(user_id, content.at("membership")))
|
|
throw m::ALREADY_MEMBER
|
|
{
|
|
"Already a member with this membership."
|
|
};
|
|
|
|
char buffer[512];
|
|
const auto printed_content
|
|
{
|
|
stringify(buffer, content)
|
|
};
|
|
|
|
json::iov event
|
|
{
|
|
{ "type", "m.room.member" },
|
|
{ "state_key", user_id },
|
|
{ "sender", user_id },
|
|
{ "content", printed_content }
|
|
};
|
|
|
|
send(event);
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::is_member(const m::id::user &user_id,
|
|
const string_view &membership)
|
|
{
|
|
const m::events::where::equal query
|
|
{
|
|
{ "type", "m.room.member" },
|
|
{ "state_key", user_id }
|
|
};
|
|
|
|
return count(query, [](const auto &event)
|
|
{
|
|
const json::object &content
|
|
{
|
|
json::val<m::name::content>(event)
|
|
};
|
|
|
|
const auto &membership
|
|
{
|
|
unquote(content["membership"])
|
|
};
|
|
|
|
return membership == membership;
|
|
});
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::any(const events::where &where)
|
|
const
|
|
{
|
|
events::cursor cursor{"!room_id$event_id"};
|
|
cursor.where = &where;
|
|
return bool(cursor.find(room_id));
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::any(const events::where &where,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
events::cursor cursor{"!room_id$event_id"};
|
|
cursor.where = &where;
|
|
|
|
for(auto it(cursor.find(room_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
size_t
|
|
ircd::m::room::count(const events::where &where)
|
|
const
|
|
{
|
|
events::cursor cursor{"!room_id$event_id"};
|
|
cursor.where = &where;
|
|
|
|
size_t i(0);
|
|
for(auto it(cursor.find(room_id)); bool(it); ++it, i++)
|
|
return i;
|
|
}
|
|
|
|
size_t
|
|
ircd::m::room::count(const events::where &where,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
events::cursor cursor{"!room_id$event_id"};
|
|
cursor.where = &where;
|
|
|
|
size_t i(0);
|
|
for(auto it(cursor.find(room_id)); bool(it); ++it)
|
|
{
|
|
const m::event &e(*it);
|
|
i += closure(e);
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
void
|
|
ircd::m::room::for_each(const events::where &where,
|
|
const event_closure &closure)
|
|
const
|
|
{
|
|
events::cursor cursor{"!room_id$event_id"};
|
|
cursor.where = &where;
|
|
auto it(cursor.find(room_id));
|
|
if(!it)
|
|
return;
|
|
|
|
for(; bool(it); ++it)
|
|
closure(*it);
|
|
}
|
|
|
|
void
|
|
ircd::m::room::for_each(const event_closure &closure)
|
|
const
|
|
{
|
|
const m::events::where::noop where{};
|
|
for_each(where, closure);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/id.h
|
|
//
|
|
|
|
ircd::m::id::id(const string_view &id)
|
|
:string_view{id}
|
|
,sigil{m::sigil(id)}
|
|
{
|
|
}
|
|
|
|
ircd::m::id::id(const enum sigil &sigil,
|
|
const string_view &id)
|
|
:string_view{id}
|
|
,sigil{sigil}
|
|
{
|
|
if(!valid())
|
|
throw INVALID_MXID("Not a valid '%s' mxid", reflect(sigil));
|
|
}
|
|
|
|
ircd::m::id::id(const enum sigil &sigil,
|
|
char *const &buf,
|
|
const size_t &max,
|
|
const string_view &id)
|
|
:string_view{buf}
|
|
,sigil{sigil}
|
|
{
|
|
strlcpy(buf, id, max);
|
|
}
|
|
|
|
ircd::m::id::id(const enum sigil &sigil,
|
|
char *const &buf,
|
|
const size_t &max,
|
|
const string_view &name,
|
|
const string_view &host)
|
|
:string_view{[&]() -> string_view
|
|
{
|
|
if(!max)
|
|
return {};
|
|
|
|
size_t len(0);
|
|
if(!startswith(name, sigil))
|
|
buf[len++] = char(sigil);
|
|
|
|
const auto has_sep
|
|
{
|
|
std::count(std::begin(name), std::end(name), ':')
|
|
};
|
|
|
|
if(!has_sep && host.empty())
|
|
{
|
|
len += strlcpy(buf + len, name, max - len);
|
|
}
|
|
else if(!has_sep && !host.empty())
|
|
{
|
|
len += fmt::snprintf(buf + len, max - len, "%s:%s",
|
|
name,
|
|
host);
|
|
}
|
|
else if(has_sep == 1 && !host.empty() && !split(name, ':').second.empty())
|
|
{
|
|
len += strlcpy(buf + len, name, max - len);
|
|
}
|
|
else if(has_sep && !host.empty())
|
|
{
|
|
throw INVALID_MXID("Not a valid '%s' mxid", reflect(sigil));
|
|
}
|
|
|
|
return { buf, len };
|
|
}()}
|
|
,sigil{sigil}
|
|
{
|
|
}
|
|
|
|
ircd::m::id::id(const enum sigil &sigil,
|
|
char *const &buf,
|
|
const size_t &max,
|
|
const generate_t &,
|
|
const string_view &host)
|
|
:string_view{[&]
|
|
{
|
|
char name[64]; switch(sigil)
|
|
{
|
|
case sigil::USER:
|
|
generate_random_prefixed(sigil::USER, "guest", name, sizeof(name));
|
|
break;
|
|
|
|
case sigil::ALIAS:
|
|
generate_random_prefixed(sigil::ALIAS, "", name, sizeof(name));
|
|
break;
|
|
|
|
default:
|
|
generate_random_timebased(sigil, name, sizeof(name));
|
|
break;
|
|
};
|
|
|
|
const size_t len
|
|
{
|
|
fmt::snprintf(buf, max, "%s:%s",
|
|
name,
|
|
host)
|
|
};
|
|
|
|
return string_view { buf, len };
|
|
}()}
|
|
,sigil{sigil}
|
|
{
|
|
}
|
|
|
|
bool
|
|
ircd::m::id::valid()
|
|
const
|
|
{
|
|
const auto parts(split(*this, ':'));
|
|
const auto &local(parts.first);
|
|
const auto &host(parts.second);
|
|
|
|
// this valid() requires a full canonical mxid with a host
|
|
if(host.empty())
|
|
return false;
|
|
|
|
// local requires a sigil plus at least one character
|
|
if(local.size() < 2)
|
|
return false;
|
|
|
|
// local requires the correct sigil type
|
|
if(!startswith(local, sigil))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
ircd::m::id::valid_local()
|
|
const
|
|
{
|
|
const auto parts(split(*this, ':'));
|
|
const auto &local(parts.first);
|
|
|
|
// local requires a sigil plus at least one character
|
|
if(local.size() < 2)
|
|
return false;
|
|
|
|
// local requires the correct sigil type
|
|
if(!startswith(local, sigil))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::m::id::generate_random_prefixed(const enum sigil &sigil,
|
|
const string_view &prefix,
|
|
char *const &buf,
|
|
const size_t &max)
|
|
{
|
|
const uint32_t num(rand::integer());
|
|
const size_t len(fmt::snprintf(buf, max, "%c%s%u", char(sigil), prefix, num));
|
|
return { buf, len };
|
|
}
|
|
|
|
ircd::string_view
|
|
ircd::m::id::generate_random_timebased(const enum sigil &sigil,
|
|
char *const &buf,
|
|
const size_t &max)
|
|
{
|
|
const auto utime(microtime());
|
|
const size_t len(snprintf(buf, max, "%c%zd%06d", char(sigil), utime.first, utime.second));
|
|
return { buf, len };
|
|
}
|
|
|
|
enum ircd::m::id::sigil
|
|
ircd::m::sigil(const string_view &s)
|
|
try
|
|
{
|
|
return sigil(s.at(0));
|
|
}
|
|
catch(const std::out_of_range &e)
|
|
{
|
|
throw BAD_SIGIL("sigil undefined");
|
|
}
|
|
|
|
enum ircd::m::id::sigil
|
|
ircd::m::sigil(const char &c)
|
|
{
|
|
switch(c)
|
|
{
|
|
case '$': return id::EVENT;
|
|
case '@': return id::USER;
|
|
case '#': return id::ALIAS;
|
|
case '!': return id::ROOM;
|
|
}
|
|
|
|
throw BAD_SIGIL("'%c' is not a valid sigil", c);
|
|
}
|
|
|
|
const char *
|
|
ircd::m::reflect(const enum id::sigil &c)
|
|
{
|
|
switch(c)
|
|
{
|
|
case id::EVENT: return "EVENT";
|
|
case id::USER: return "USER";
|
|
case id::ALIAS: return "ALIAS";
|
|
case id::ROOM: return "ROOM";
|
|
}
|
|
|
|
return "?????";
|
|
}
|
|
|
|
bool
|
|
ircd::m::valid_sigil(const string_view &s)
|
|
try
|
|
{
|
|
return valid_sigil(s.at(0));
|
|
}
|
|
catch(const std::out_of_range &e)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::valid_sigil(const char &c)
|
|
{
|
|
switch(c)
|
|
{
|
|
case id::EVENT:
|
|
case id::USER:
|
|
case id::ALIAS:
|
|
case id::ROOM:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|