mirror of
https://github.com/matrix-construct/construct
synced 2024-09-06 08:45:20 +02:00
1935 lines
37 KiB
C++
1935 lines
37 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.
|
|
*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/session.h
|
|
//
|
|
|
|
ircd::m::session::session(const hostport &host_port)
|
|
:client{std::make_shared<ircd::client>(host_port)}
|
|
{
|
|
}
|
|
|
|
ircd::json::object
|
|
ircd::m::session::operator()(parse::buffer &pb,
|
|
request &r)
|
|
{
|
|
const json::member origin
|
|
{
|
|
"origin", my_host()
|
|
};
|
|
|
|
const json::member destination
|
|
{
|
|
//host(remote_hostport(*client->sock))
|
|
"destination", "zemos.net"
|
|
};
|
|
|
|
const json::member method
|
|
{
|
|
"method", r.method
|
|
};
|
|
|
|
const std::string uri
|
|
{
|
|
std::string {"/"} + std::string{r.path} +
|
|
(r.query? (std::string{"?"} + std::string{r.query}) : std::string{})
|
|
};
|
|
|
|
json::iov iov;
|
|
const json::iov::push pushed[]
|
|
{
|
|
{ iov, json::member { "uri", uri } },
|
|
{ iov, origin },
|
|
{ iov, method },
|
|
{ iov, destination },
|
|
};
|
|
|
|
const json::iov::add_if content
|
|
{
|
|
iov, r.content.size() > 2, json::member
|
|
{
|
|
"content", r.content
|
|
}
|
|
};
|
|
|
|
size_t headers{2};
|
|
http::line::header header[3]
|
|
{
|
|
{ "Content-Type", "application/json" },
|
|
{ "User-Agent", "IRCd" }
|
|
};
|
|
|
|
char x_matrix_buf[2048];
|
|
if(startswith(r.path, "_matrix/federation"))
|
|
{
|
|
// These buffers can be comfortably large if they're not on a stack and
|
|
// nothing in this procedure has a yield; the assertion is tripped if so
|
|
static char request_object_buffer[4096];
|
|
static char signature_buffer[128];
|
|
ctx::critical_assertion ca;
|
|
|
|
const auto request_object
|
|
{
|
|
json::stringify(request_object_buffer, iov)
|
|
};
|
|
|
|
std::cout << request_object << std::endl;
|
|
|
|
const ed25519::sig sig
|
|
{
|
|
my::secret_key.sign(request_object)
|
|
};
|
|
|
|
const auto signature
|
|
{
|
|
b64encode_unpadded(signature_buffer, sig)
|
|
};
|
|
|
|
const auto x_matrix_len
|
|
{
|
|
fmt::sprintf(x_matrix_buf, "X-Matrix origin=%s,key=\"ed25519:pk2\",sig=\"%s\"",
|
|
string_view{origin.second},
|
|
signature)
|
|
};
|
|
|
|
const string_view x_matrix
|
|
{
|
|
x_matrix_buf, size_t(x_matrix_len)
|
|
};
|
|
|
|
header[headers++] = { "Authorization", x_matrix };
|
|
}
|
|
|
|
http::request
|
|
{
|
|
string_view{destination.second}, //host(remote(*client)),
|
|
r.method,
|
|
r.path,
|
|
r.query,
|
|
r.content,
|
|
write_closure(*client),
|
|
{ header, headers }
|
|
};
|
|
|
|
http::code status;
|
|
json::object object;
|
|
parse::capstan pc
|
|
{
|
|
pb, read_closure(*client)
|
|
};
|
|
|
|
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::m
|
|
{
|
|
std::map<std::string, ircd::module> modules;
|
|
ircd::net::listener *listener;
|
|
|
|
static void leave_ircd_room();
|
|
static void join_ircd_room();
|
|
static void init_keys(const std::string &secret_key_file);
|
|
static void bootstrap();
|
|
}
|
|
|
|
const ircd::m::user::id::buf
|
|
ircd_user_id
|
|
{
|
|
"ircd", "cdc.z" //TODO: hostname
|
|
};
|
|
|
|
ircd::m::user
|
|
ircd::m::me
|
|
{
|
|
ircd_user_id
|
|
};
|
|
|
|
const ircd::m::room::id::buf
|
|
ircd_room_id
|
|
{
|
|
"ircd", ircd::my_host()
|
|
};
|
|
|
|
ircd::m::room
|
|
ircd::m::my_room
|
|
{
|
|
ircd_room_id
|
|
};
|
|
|
|
ircd::string_view
|
|
ircd::m::my_host()
|
|
{
|
|
return "cdc.z:8447"; //me.user_id.host();
|
|
}
|
|
|
|
ircd::m::init::init()
|
|
try
|
|
{
|
|
init_keys("charybdis.sk");
|
|
|
|
const string_view prefixes[]
|
|
{
|
|
"client_", "key_",
|
|
};
|
|
|
|
for(const auto &name : mods::available())
|
|
if(startswith_any(name, std::begin(prefixes), std::end(prefixes)))
|
|
modules.emplace(name, name);
|
|
|
|
if(db::sequence(*event::events) == 0)
|
|
bootstrap();
|
|
|
|
modules.emplace("root.so"s, "root.so"s);
|
|
|
|
const auto options{json::strung(json::members
|
|
{
|
|
{ "name", "Chat Matrix" },
|
|
{ "host", "0.0.0.0" },
|
|
{ "port", 8447 },
|
|
{ "ssl_certificate_file", "/home/jason/zemos.net.tls2.crt" },
|
|
{ "ssl_certificate_chain_file", "/home/jason/zemos.net.tls2.crt" },
|
|
{ "ssl_tmp_dh_file", "/home/jason/zemos.net.tls.dh" },
|
|
{ "ssl_private_key_file_pem", "/home/jason/zemos.net.tls2.key" },
|
|
})};
|
|
|
|
//TODO: conf obviously
|
|
listener = new ircd::net::listener{options};
|
|
|
|
join_ircd_room();
|
|
}
|
|
catch(const m::error &e)
|
|
{
|
|
log::critical("%s %s", e.what(), e.content);
|
|
}
|
|
|
|
ircd::m::init::~init()
|
|
noexcept try
|
|
{
|
|
leave_ircd_room();
|
|
|
|
delete listener;
|
|
modules.clear();
|
|
}
|
|
catch(const m::error &e)
|
|
{
|
|
log::critical("%s %s", e.what(), e.content);
|
|
std::terminate();
|
|
}
|
|
|
|
void
|
|
ircd::m::join_ircd_room()
|
|
try
|
|
{
|
|
// ircd.start event
|
|
json::iov content;
|
|
my_room.join(me.user_id, content);
|
|
}
|
|
catch(const m::ALREADY_MEMBER &e)
|
|
{
|
|
log::warning("IRCd did not shut down correctly...");
|
|
}
|
|
|
|
void
|
|
ircd::m::leave_ircd_room()
|
|
{
|
|
// ircd.start event
|
|
json::iov content;
|
|
my_room.leave(me.user_id, content);
|
|
}
|
|
|
|
namespace ircd::m
|
|
{
|
|
static void bootstrap_keys();
|
|
}
|
|
|
|
void
|
|
ircd::m::bootstrap()
|
|
{
|
|
assert(event::events);
|
|
assert(db::sequence(*event::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..."
|
|
);
|
|
|
|
json::iov content;
|
|
my_room.create(me.user_id, me.user_id, content);
|
|
user::accounts.create(me.user_id, me.user_id, content);
|
|
user::accounts.join(me.user_id, content);
|
|
user::sessions.create(me.user_id, me.user_id, content);
|
|
filter::filters.create(me.user_id, me.user_id, content);
|
|
bootstrap_keys();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/keys.h
|
|
//
|
|
|
|
const ircd::m::room::id::buf
|
|
keys_room_id
|
|
{
|
|
"keys", ircd::my_host()
|
|
};
|
|
|
|
ircd::m::room
|
|
ircd::m::key::keys
|
|
{
|
|
keys_room_id
|
|
};
|
|
|
|
ircd::ed25519::sk
|
|
ircd::my::secret_key
|
|
{};
|
|
|
|
ircd::ed25519::pk
|
|
ircd::my::public_key
|
|
{};
|
|
|
|
std::string
|
|
ircd::my::public_key_b64
|
|
{};
|
|
|
|
static void
|
|
ircd::m::init_keys(const std::string &sk_file)
|
|
{
|
|
my::secret_key = ed25519::sk
|
|
{
|
|
sk_file, &my::public_key
|
|
};
|
|
|
|
my::public_key_b64 = b64encode_unpadded(my::public_key);
|
|
|
|
log::info("My ed25519 public key is: %s",
|
|
my::public_key_b64);
|
|
}
|
|
|
|
namespace ircd
|
|
{
|
|
size_t certbytes(const mutable_raw_buffer &buf, const std::string &certfile);
|
|
}
|
|
|
|
static void
|
|
ircd::m::bootstrap_keys()
|
|
{
|
|
json::iov content;
|
|
key::keys.create(me.user_id, me.user_id, content);
|
|
|
|
key my_key;
|
|
json::val<name::server_name>(my_key) = my_host();
|
|
json::val<name::old_verify_keys>(my_key) = "{}";
|
|
|
|
const auto valid_until
|
|
{
|
|
ircd::time<milliseconds>() + duration_cast<milliseconds>(hours(2160)).count()
|
|
};
|
|
json::val<name::valid_until_ts>(my_key) = valid_until;
|
|
|
|
static char verify_keys_buf[256];
|
|
json::val<name::verify_keys>(my_key) = json::stringify(verify_keys_buf, json::members
|
|
{
|
|
{ "ed25519:pk2", json::members
|
|
{
|
|
{ "key", my::public_key_b64 }
|
|
}}
|
|
});
|
|
|
|
//static unsigned char pembuf[4096];
|
|
//const auto cbsz{ircd::certbytes(pembuf, "/home/jason/zemos.net.tls.crt")};
|
|
|
|
static std::array<uint8_t, 32> tls_hash;
|
|
a2u(tls_hash, "C259B83ABED34D81B31F773737574FBD966CE33BDED708BF502CA1D4CEC3D318");
|
|
|
|
static char tls_b64_buf[256];
|
|
const json::members tlsfps
|
|
{
|
|
{ "sha256", b64encode_unpadded(tls_b64_buf, tls_hash) }
|
|
};
|
|
|
|
const json::value tlsfp[1]
|
|
{
|
|
{ tlsfps }
|
|
};
|
|
|
|
static char tls_fingerprints_buf[256];
|
|
json::get<"tls_fingerprints"_>(my_key) = json::stringify(tls_fingerprints_buf, json::value
|
|
{
|
|
tlsfp, 1
|
|
});
|
|
|
|
const std::string presig
|
|
{
|
|
json::string(my_key)
|
|
};
|
|
|
|
const ed25519::sig sig
|
|
{
|
|
my::secret_key.sign(const_raw_buffer{presig})
|
|
};
|
|
|
|
static char signature[128], signatures[256];
|
|
json::get<"signatures"_>(my_key) = json::stringify(signatures, json::members
|
|
{
|
|
{ my_host(), json::members
|
|
{
|
|
{ "ed25519:pk2", b64encode_unpadded(signature, sig) }
|
|
}}
|
|
});
|
|
|
|
keys::set(my_key);
|
|
}
|
|
|
|
void
|
|
ircd::m::keys::set(const key &key)
|
|
{
|
|
const auto &state_key
|
|
{
|
|
at<"server_name"_>(key)
|
|
};
|
|
|
|
const m::user::id::buf sender
|
|
{
|
|
"ircd", at<"server_name"_>(key)
|
|
};
|
|
|
|
const auto content
|
|
{
|
|
json::string(key)
|
|
};
|
|
|
|
json::iov event;
|
|
json::iov::push members[]
|
|
{
|
|
{ event, json::member { "type", "ircd.key" }},
|
|
{ event, json::member { "state_key", state_key }},
|
|
{ event, json::member { "sender", sender }},
|
|
{ event, json::member { "content", content }}
|
|
};
|
|
|
|
key::keys.send(event);
|
|
}
|
|
|
|
bool
|
|
ircd::m::keys::get(const string_view &server_name,
|
|
const closure &closure)
|
|
{
|
|
const m::event::query<m::event::where::equal> query
|
|
{
|
|
{ "room_id", key::keys.room_id },
|
|
{ "type", "ircd.key" },
|
|
{ "state_key", server_name },
|
|
};
|
|
|
|
return m::events::test(query, [&closure]
|
|
(const auto &event)
|
|
{
|
|
closure(json::val<name::content>(event));
|
|
return true;
|
|
});
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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::event::events = databases.at("events").get();
|
|
}
|
|
|
|
ircd::m::dbs::init::~init()
|
|
noexcept
|
|
{
|
|
ircd::m::event::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/filter.h
|
|
//
|
|
|
|
const ircd::m::room::id::buf
|
|
filters_room_id
|
|
{
|
|
"filters", ircd::my_host()
|
|
};
|
|
|
|
ircd::m::room
|
|
ircd::m::filter::filters
|
|
{
|
|
filters_room_id
|
|
};
|
|
|
|
ircd::m::filter::filter(const string_view &filter_id,
|
|
const mutable_buffer &buf)
|
|
{
|
|
const m::event::query<m::event::where::equal> query
|
|
{
|
|
{ "room_id", filters.room_id },
|
|
{ "type", "ircd.filter" },
|
|
{ "state_key", filter_id },
|
|
};
|
|
|
|
size_t len{0};
|
|
m::events::test(query, [&buf, &len]
|
|
(const auto &event)
|
|
{
|
|
len = copy(buf, json::get<"content"_>(event));
|
|
return true;
|
|
});
|
|
|
|
new (this) filter{json::object{buf}};
|
|
}
|
|
|
|
size_t
|
|
ircd::m::filter::size(const string_view &filter_id)
|
|
{
|
|
const m::event::query<m::event::where::equal> query
|
|
{
|
|
{ "room_id", filters.room_id },
|
|
{ "type", "ircd.filter" },
|
|
{ "state_key", filter_id },
|
|
};
|
|
|
|
size_t ret{0};
|
|
m::events::test(query, [&ret]
|
|
(const auto &event)
|
|
{
|
|
ret = json::get<"content"_>(event).size();
|
|
return true;
|
|
});
|
|
|
|
return ret;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/room.h
|
|
//
|
|
|
|
//
|
|
// m::room
|
|
//
|
|
|
|
void
|
|
ircd::m::room::create(const m::id::user &sender,
|
|
const m::id::user &creator,
|
|
json::iov &content)
|
|
{
|
|
const json::iov::add _creator
|
|
{
|
|
content, { "creator", me.user_id }
|
|
};
|
|
|
|
const auto _content
|
|
{
|
|
json::string(content)
|
|
};
|
|
|
|
send(
|
|
{
|
|
{ "type", "m.room.create" },
|
|
{ "sender", sender },
|
|
{ "state_key", "" },
|
|
{ "content", _content }
|
|
});
|
|
}
|
|
|
|
void
|
|
ircd::m::room::join(const m::id::user &user_id,
|
|
json::iov &content)
|
|
{
|
|
const json::iov::set membership_join
|
|
{
|
|
content, { "membership", "join" }
|
|
};
|
|
|
|
membership(user_id, content);
|
|
}
|
|
|
|
void
|
|
ircd::m::room::leave(const m::id::user &user_id,
|
|
json::iov &content)
|
|
{
|
|
const json::iov::set membership_leave
|
|
{
|
|
content, { "membership", "leave" }
|
|
};
|
|
|
|
membership(user_id, content);
|
|
}
|
|
|
|
void
|
|
ircd::m::room::membership(const m::id::user &user_id,
|
|
json::iov &content)
|
|
{
|
|
const string_view &membership
|
|
{
|
|
content.at("membership")
|
|
};
|
|
|
|
if(this->membership(user_id, membership))
|
|
throw m::ALREADY_MEMBER
|
|
{
|
|
"Member '%s' is already '%s'.", string_view{user_id}, membership
|
|
};
|
|
|
|
//TODO: child iov
|
|
const std::string c
|
|
{
|
|
json::string(content)
|
|
};
|
|
|
|
json::iov event;
|
|
json::iov::push members[]
|
|
{
|
|
{ event, json::member { "type", "m.room.member" }},
|
|
{ event, json::member { "state_key", user_id }},
|
|
{ event, json::member { "sender", user_id }},
|
|
{ event, json::member { "content", string_view{c} }}
|
|
};
|
|
|
|
send(event);
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::membership(const m::id::user &user_id,
|
|
const string_view &membership)
|
|
const
|
|
{
|
|
const event::query<event::where::equal> member_event
|
|
{
|
|
{ "room_id", room_id },
|
|
{ "type", "m.room.member" },
|
|
{ "state_key", user_id },
|
|
};
|
|
|
|
if(!membership)
|
|
return m::events::test(member_event);
|
|
|
|
const event::query<event::where::test> membership_test{[&membership]
|
|
(const auto &event)
|
|
{
|
|
const json::object &content
|
|
{
|
|
json::at<"content"_>(event)
|
|
};
|
|
|
|
const auto &existing_membership
|
|
{
|
|
unquote(content.at("membership"))
|
|
};
|
|
|
|
return membership == existing_membership;
|
|
}};
|
|
|
|
return m::events::test(member_event && membership_test);
|
|
}
|
|
|
|
ircd::m::event::id
|
|
ircd::m::room::head(event::id::buf &buf)
|
|
const
|
|
{
|
|
const event::query<event::where::equal> query
|
|
{
|
|
{ "room_id", room_id },
|
|
};
|
|
|
|
events::test(query, [&buf]
|
|
(const auto &event)
|
|
{
|
|
buf = json::get<"event_id"_>(event);
|
|
return true;
|
|
});
|
|
|
|
return buf;
|
|
}
|
|
|
|
ircd::m::event::id::buf
|
|
ircd::m::room::send(const json::members &event)
|
|
{
|
|
size_t i(0);
|
|
json::iov iov;
|
|
json::iov::push members[event.size()];
|
|
for(const auto &member : event)
|
|
new (members + i++) json::iov::push(iov, member);
|
|
|
|
return send(iov);
|
|
}
|
|
|
|
ircd::m::event::id::buf
|
|
ircd::m::room::send(json::iov &event)
|
|
{
|
|
const json::iov::add room_id
|
|
{
|
|
event, { "room_id", this->room_id }
|
|
};
|
|
|
|
const id::event::buf generated_event_id
|
|
{
|
|
id::generate, this->room_id.host()
|
|
};
|
|
|
|
const json::iov::add event_id
|
|
{
|
|
event, { "event_id", generated_event_id }
|
|
};
|
|
|
|
m::event::insert(event);
|
|
return generated_event_id;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/user.h
|
|
//
|
|
|
|
const ircd::m::room::id::buf
|
|
accounts_room_id
|
|
{
|
|
"accounts", ircd::my_host()
|
|
};
|
|
|
|
ircd::m::room
|
|
ircd::m::user::accounts
|
|
{
|
|
accounts_room_id
|
|
};
|
|
|
|
const ircd::m::room::id::buf
|
|
sessions_room_id
|
|
{
|
|
"sessions", ircd::my_host()
|
|
};
|
|
|
|
ircd::m::room
|
|
ircd::m::user::sessions
|
|
{
|
|
sessions_room_id
|
|
};
|
|
|
|
/// Register the user by joining them to the accounts room.
|
|
///
|
|
/// The content of the join event may store keys including the registration
|
|
/// options. Once this call completes the join was successful and the user is
|
|
/// registered, otherwise throws.
|
|
void
|
|
ircd::m::user::activate(const json::members &contents)
|
|
try
|
|
{
|
|
json::iov content;
|
|
json::iov::push members[contents.size()];
|
|
|
|
size_t i(0);
|
|
for(const auto &member : contents)
|
|
new (members + i++) json::iov::push(content, member);
|
|
|
|
accounts.join(user_id, content);
|
|
}
|
|
catch(const m::ALREADY_MEMBER &e)
|
|
{
|
|
throw m::error
|
|
{
|
|
http::CONFLICT, "M_USER_IN_USE", "The desired user ID is already in use."
|
|
};
|
|
}
|
|
|
|
void
|
|
ircd::m::user::deactivate(const json::members &contents)
|
|
{
|
|
json::iov content;
|
|
json::iov::push members[contents.size()];
|
|
|
|
size_t i(0);
|
|
for(const auto &member : contents)
|
|
new (members + i++) json::iov::push(content, member);
|
|
|
|
accounts.leave(user_id, content);
|
|
}
|
|
|
|
void
|
|
ircd::m::user::password(const string_view &password)
|
|
try
|
|
{
|
|
json::iov event;
|
|
json::iov::push members[]
|
|
{
|
|
{ event, json::member { "type", "ircd.password" }},
|
|
{ event, json::member { "state_key", user_id }},
|
|
{ event, json::member { "sender", user_id }},
|
|
{ event, json::member { "content", json::members
|
|
{
|
|
{ "plaintext", password }
|
|
}}},
|
|
};
|
|
|
|
accounts.send(event);
|
|
}
|
|
catch(const m::ALREADY_MEMBER &e)
|
|
{
|
|
throw m::error
|
|
{
|
|
http::CONFLICT, "M_USER_IN_USE", "The desired user ID is already in use."
|
|
};
|
|
}
|
|
|
|
bool
|
|
ircd::m::user::is_password(const string_view &supplied_password)
|
|
const
|
|
{
|
|
const event::query<event::where::equal> member_event
|
|
{
|
|
{ "room_id", accounts.room_id },
|
|
{ "type", "ircd.password" },
|
|
{ "state_key", user_id },
|
|
};
|
|
|
|
const event::query<event::where::test> correct_password{[&supplied_password]
|
|
(const auto &event)
|
|
{
|
|
const json::object &content
|
|
{
|
|
json::at<"content"_>(event)
|
|
};
|
|
|
|
const auto &correct_password
|
|
{
|
|
unquote(content.at("plaintext"))
|
|
};
|
|
|
|
return supplied_password == correct_password;
|
|
}};
|
|
|
|
const auto query
|
|
{
|
|
member_event && correct_password
|
|
};
|
|
|
|
return m::events::test(member_event && correct_password);
|
|
}
|
|
|
|
bool
|
|
ircd::m::user::is_active()
|
|
const
|
|
{
|
|
return accounts.membership(user_id);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// query lib
|
|
//
|
|
/*
|
|
bool
|
|
ircd::m::room::members::_rquery_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for type,state_key in room_id",
|
|
&query
|
|
};
|
|
|
|
//TODO: ???
|
|
static const size_t max_type_size
|
|
{
|
|
256
|
|
};
|
|
|
|
const auto key_max
|
|
{
|
|
room::id::buf::SIZE + max_type_size
|
|
};
|
|
|
|
size_t key_len;
|
|
char key[key_max]; key[0] = '\0';
|
|
key_len = strlcat(key, room_id, sizeof(key));
|
|
key_len = strlcat(key, "..m.room.member", sizeof(key)); //TODO: prefix protocol
|
|
for(auto it(cursor.rbegin(key)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::members::_query_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for type,state_key in room_id",
|
|
&query
|
|
};
|
|
|
|
//TODO: ???
|
|
static const size_t max_type_size
|
|
{
|
|
256
|
|
};
|
|
|
|
const auto key_max
|
|
{
|
|
room::id::buf::SIZE + max_type_size
|
|
};
|
|
|
|
size_t key_len;
|
|
char key[key_max]; key[0] = '\0';
|
|
key_len = strlcat(key, room_id, sizeof(key));
|
|
key_len = strlcat(key, "..m.room.member", sizeof(key)); //TODO: prefix protocol
|
|
for(auto it(cursor.begin(key)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::state::_rquery_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for type,state_key in room_id",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.rbegin(room_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::state::_query_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for type,state_key in room_id",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.begin(room_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::events::_rquery_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id in room_id",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.rbegin(room_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::room::events::_query_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id in room_id",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.begin(room_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::user::rooms::_rquery_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for room_id in sender",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.rbegin(user_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::user::rooms::_query_(const event::query<> &query,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for room_id in sender",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.begin(user_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::_rquery_(const event::query<> &where,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id",
|
|
&where
|
|
};
|
|
|
|
for(auto it(cursor.rbegin()); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::_query_(const event::query<> &where,
|
|
const event_closure_bool &closure)
|
|
const
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id",
|
|
&where
|
|
};
|
|
|
|
for(auto it(cursor.begin()); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/events.h
|
|
//
|
|
|
|
bool
|
|
ircd::m::events::test(const event::query<> &where)
|
|
{
|
|
return test(where, [](const auto &event)
|
|
{
|
|
return true;
|
|
});
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::test(const event::query<> &where,
|
|
const closure_bool &closure)
|
|
{
|
|
bool ret{false};
|
|
query(where, [&ret, &closure]
|
|
(const auto &event)
|
|
{
|
|
ret = closure(event);
|
|
return true;
|
|
});
|
|
|
|
return ret;
|
|
}
|
|
|
|
size_t
|
|
ircd::m::events::count(const event::query<> &where)
|
|
{
|
|
return count(where, [](const auto &event)
|
|
{
|
|
return true;
|
|
});
|
|
}
|
|
|
|
size_t
|
|
ircd::m::events::count(const event::query<> &where,
|
|
const closure_bool &closure)
|
|
{
|
|
size_t i(0);
|
|
for_each(where, [&closure, &i](const auto &event)
|
|
{
|
|
i += closure(event);
|
|
});
|
|
|
|
return i;
|
|
}
|
|
|
|
/*
|
|
void
|
|
ircd::m::events::rfor_each(const closure &closure)
|
|
{
|
|
const event::query<event::where::noop> where{};
|
|
rfor_each(where, closure);
|
|
}
|
|
|
|
void
|
|
ircd::m::events::rfor_each(const event::query<> &where,
|
|
const closure &closure)
|
|
{
|
|
rquery(where, [&closure](const auto &event)
|
|
{
|
|
closure(event);
|
|
return false;
|
|
});
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::rquery(const closure_bool &closure)
|
|
{
|
|
const event::query<event::where::noop> where{};
|
|
return rquery(where, closure);
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::rquery(const event::query<> &where,
|
|
const closure_bool &closure)
|
|
{
|
|
//return _rquery_(where, closure);
|
|
return true;
|
|
}
|
|
*/
|
|
|
|
void
|
|
ircd::m::events::for_each(const event::query<> &where,
|
|
const closure &closure)
|
|
{
|
|
query(where, [&closure](const auto &event)
|
|
{
|
|
closure(event);
|
|
return false;
|
|
});
|
|
}
|
|
|
|
void
|
|
ircd::m::events::for_each(const closure &closure)
|
|
{
|
|
const event::query<event::where::noop> where{};
|
|
for_each(where, closure);
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::query(const closure_bool &closure)
|
|
{
|
|
const event::query<event::where::noop> where{};
|
|
return query(where, closure);
|
|
}
|
|
|
|
namespace ircd::m::events
|
|
{
|
|
bool _query_event_id(const event::query<> &, const closure_bool &);
|
|
bool _query_in_room_id(const event::query<> &, const closure_bool &, const room::id &);
|
|
bool _query_for_type_state_key_in_room_id(const event::query<> &, const closure_bool &, const room::id &, const string_view &type = {}, const string_view &state_key = {});
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::query(const event::query<> &where,
|
|
const closure_bool &closure)
|
|
{
|
|
switch(where.type)
|
|
{
|
|
case event::where::equal:
|
|
{
|
|
auto &clause
|
|
{
|
|
dynamic_cast<const event::query<event::where::equal> &>(where)
|
|
};
|
|
|
|
const auto &value{clause.value};
|
|
const auto &room_id{json::get<"room_id"_>(value)};
|
|
const auto &type{json::get<"type"_>(value)};
|
|
const auto &state_key{json::get<"state_key"_>(value)};
|
|
if(room_id && type && state_key.defined())
|
|
return _query_for_type_state_key_in_room_id(where, closure, room_id, type, state_key);
|
|
|
|
if(room_id && state_key.defined())
|
|
return _query_for_type_state_key_in_room_id(where, closure, room_id, type, state_key);
|
|
|
|
if(room_id)
|
|
return _query_in_room_id(where, closure, room_id);
|
|
|
|
break;
|
|
}
|
|
|
|
case event::where::logical_and:
|
|
{
|
|
auto &clause
|
|
{
|
|
dynamic_cast<const event::query<event::where::logical_and> &>(where)
|
|
};
|
|
|
|
const auto &lhs{*clause.a}, &rhs{*clause.b};
|
|
const auto reclosure{[&lhs, &rhs, &closure]
|
|
(const auto &event)
|
|
{
|
|
if(!rhs(event))
|
|
return false;
|
|
|
|
return closure(event);
|
|
}};
|
|
|
|
return events::query(lhs, reclosure);
|
|
}
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return _query_event_id(where, closure);
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::_query_event_id(const event::query<> &where,
|
|
const closure_bool &closure)
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id",
|
|
&where
|
|
};
|
|
|
|
for(auto it(cursor.begin()); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::_query_in_room_id(const event::query<> &query,
|
|
const closure_bool &closure,
|
|
const room::id &room_id)
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id in room_id",
|
|
&query
|
|
};
|
|
|
|
for(auto it(cursor.begin(room_id)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
ircd::m::events::_query_for_type_state_key_in_room_id(const event::query<> &query,
|
|
const closure_bool &closure,
|
|
const room::id &room_id,
|
|
const string_view &type,
|
|
const string_view &state_key)
|
|
{
|
|
event::cursor cursor
|
|
{
|
|
"event_id for type,state_key in room_id",
|
|
&query
|
|
};
|
|
|
|
static const size_t max_type_size
|
|
{
|
|
255
|
|
};
|
|
|
|
static const size_t max_state_key_size
|
|
{
|
|
255
|
|
};
|
|
|
|
const auto key_max
|
|
{
|
|
room::id::buf::SIZE + max_type_size + max_state_key_size + 2
|
|
};
|
|
|
|
size_t key_len;
|
|
char key[key_max]; key[0] = '\0';
|
|
key_len = strlcat(key, room_id, sizeof(key));
|
|
key_len = strlcat(key, "..", sizeof(key)); //TODO: prefix protocol
|
|
key_len = strlcat(key, type, sizeof(key)); //TODO: prefix protocol
|
|
key_len = strlcat(key, state_key, sizeof(key)); //TODO: prefix protocol
|
|
for(auto it(cursor.begin(key)); bool(it); ++it)
|
|
if(closure(*it))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// m/event.h
|
|
//
|
|
|
|
namespace ircd::m
|
|
{
|
|
void append_indexes(const event &, db::iov &);
|
|
}
|
|
|
|
// vtable for the db::query partially specialized to m::event as its tuple
|
|
template ircd::db::query<ircd::m::event, ircd::db::where::noop>::~query();
|
|
|
|
ircd::database *
|
|
ircd::m::event::events
|
|
{};
|
|
|
|
ircd::ctx::view<const ircd::m::event>
|
|
ircd::m::event::inserted
|
|
{};
|
|
|
|
ircd::m::event::id::buf
|
|
ircd::m::event::head
|
|
{};
|
|
|
|
void
|
|
ircd::m::event::insert(json::iov &iov)
|
|
{
|
|
const id::event::buf generated_event_id
|
|
{
|
|
iov.has("event_id")? id::event::buf{} : id::event::buf{id::generate, my_host()}
|
|
};
|
|
|
|
const json::iov::add_if event_id
|
|
{
|
|
iov, !iov.has("event_id"), { "event_id", generated_event_id }
|
|
};
|
|
|
|
const json::iov::set origin_server_ts
|
|
{
|
|
iov, { "origin_server_ts", ircd::time<milliseconds>() }
|
|
};
|
|
|
|
const m::event event
|
|
{
|
|
iov
|
|
};
|
|
|
|
if(!json::at<"type"_>(event))
|
|
throw BAD_JSON("Required event field: '%s'", name::type);
|
|
|
|
if(!json::at<"sender"_>(event))
|
|
throw BAD_JSON("Required event field: '%s'", name::sender);
|
|
|
|
db::iov txn
|
|
{
|
|
*event::events
|
|
};
|
|
|
|
db::iov::append
|
|
{
|
|
txn, json::at<"event_id"_>(event), iov
|
|
};
|
|
|
|
append_indexes(event, txn);
|
|
txn(*event::events);
|
|
event::head = json::at<"event_id"_>(event);
|
|
event::inserted.notify(event);
|
|
}
|
|
|
|
ircd::m::event::const_iterator
|
|
ircd::m::event::find(const event::id &id)
|
|
{
|
|
cursor c{name::event_id};
|
|
return c.begin(string_view{id});
|
|
}
|
|
|
|
namespace ircd::m
|
|
{
|
|
struct indexer;
|
|
|
|
extern std::set<std::shared_ptr<indexer>> indexers;
|
|
}
|
|
|
|
struct ircd::m::indexer
|
|
{
|
|
struct concat;
|
|
struct concat_v;
|
|
struct concat_2v;
|
|
|
|
std::string name;
|
|
|
|
virtual void operator()(const event &, db::iov &iov) const = 0;
|
|
|
|
indexer(std::string name)
|
|
:name{std::move(name)}
|
|
{}
|
|
|
|
virtual ~indexer() noexcept;
|
|
};
|
|
|
|
ircd::m::indexer::~indexer()
|
|
noexcept
|
|
{
|
|
}
|
|
|
|
void
|
|
ircd::m::append_indexes(const event &event,
|
|
db::iov &iov)
|
|
{
|
|
for(const auto &ptr : indexers)
|
|
{
|
|
const m::indexer &indexer{*ptr};
|
|
indexer(event, iov);
|
|
}
|
|
}
|
|
|
|
|
|
struct ircd::m::indexer::concat
|
|
:indexer
|
|
{
|
|
std::string col_a;
|
|
std::string col_b;
|
|
|
|
void operator()(const event &, db::iov &) const override;
|
|
|
|
concat(std::string col_a, std::string col_b)
|
|
:indexer
|
|
{
|
|
fmt::snstringf(512, "%s in %s", col_a, col_b)
|
|
}
|
|
,col_a{col_a}
|
|
,col_b{col_b}
|
|
{}
|
|
};
|
|
|
|
void
|
|
ircd::m::indexer::concat::operator()(const event &event,
|
|
db::iov &iov)
|
|
const
|
|
{
|
|
if(!iov.has(db::op::SET, col_a) || !iov.has(db::op::SET, col_b))
|
|
return;
|
|
|
|
static const size_t buf_max
|
|
{
|
|
1024
|
|
};
|
|
|
|
char index[buf_max];
|
|
index[0] = '\0';
|
|
const auto function
|
|
{
|
|
[&index](const auto &val)
|
|
{
|
|
strlcat(index, byte_view<string_view>{val}, buf_max);
|
|
}
|
|
};
|
|
|
|
at(event, col_b, function);
|
|
at(event, col_a, function);
|
|
db::iov::append
|
|
{
|
|
iov, db::delta
|
|
{
|
|
name, // col
|
|
index, // key
|
|
{}, // val
|
|
}
|
|
};
|
|
}
|
|
|
|
struct ircd::m::indexer::concat_v
|
|
:indexer
|
|
{
|
|
std::string col_a;
|
|
std::string col_b;
|
|
std::string col_c;
|
|
|
|
void operator()(const event &, db::iov &) const override;
|
|
|
|
concat_v(std::string col_a, std::string col_b, std::string col_c)
|
|
:indexer
|
|
{
|
|
fmt::snstringf(512, "%s for %s in %s", col_a, col_b, col_c)
|
|
}
|
|
,col_a{col_a}
|
|
,col_b{col_b}
|
|
,col_c{col_c}
|
|
{}
|
|
};
|
|
|
|
void
|
|
ircd::m::indexer::concat_v::operator()(const event &event,
|
|
db::iov &iov)
|
|
const
|
|
{
|
|
if(!iov.has(db::op::SET, col_c) || !iov.has(db::op::SET, col_b))
|
|
return;
|
|
|
|
static const size_t buf_max
|
|
{
|
|
1024
|
|
};
|
|
|
|
char index[buf_max];
|
|
index[0] = '\0';
|
|
const auto concat
|
|
{
|
|
[&index](const auto &val)
|
|
{
|
|
strlcat(index, byte_view<string_view>{val}, buf_max);
|
|
}
|
|
};
|
|
|
|
at(event, col_c, concat);
|
|
at(event, col_b, concat);
|
|
|
|
string_view val;
|
|
at(event, col_a, [&val](const auto &_val)
|
|
{
|
|
val = byte_view<string_view>{_val};
|
|
});
|
|
|
|
db::iov::append
|
|
{
|
|
iov, db::delta
|
|
{
|
|
name, // col
|
|
index, // key
|
|
val, // val
|
|
}
|
|
};
|
|
}
|
|
|
|
struct ircd::m::indexer::concat_2v
|
|
:indexer
|
|
{
|
|
std::string col_a;
|
|
std::string col_b0;
|
|
std::string col_b1;
|
|
std::string col_c;
|
|
|
|
void operator()(const event &, db::iov &) const override;
|
|
|
|
concat_2v(std::string col_a, std::string col_b0, std::string col_b1, std::string col_c)
|
|
:indexer
|
|
{
|
|
fmt::snstringf(512, "%s for %s,%s in %s", col_a, col_b0, col_b1, col_c)
|
|
}
|
|
,col_a{col_a}
|
|
,col_b0{col_b0}
|
|
,col_b1{col_b1}
|
|
,col_c{col_c}
|
|
{}
|
|
};
|
|
|
|
void
|
|
ircd::m::indexer::concat_2v::operator()(const event &event,
|
|
db::iov &iov)
|
|
const
|
|
{
|
|
if(!iov.has(db::op::SET, col_c) || !iov.has(db::op::SET, col_b0) || !iov.has(db::op::SET, col_b1))
|
|
return;
|
|
|
|
static const size_t buf_max
|
|
{
|
|
2048
|
|
};
|
|
|
|
char index[buf_max];
|
|
index[0] = '\0';
|
|
const auto concat
|
|
{
|
|
[&index](const auto &val)
|
|
{
|
|
strlcat(index, byte_view<string_view>{val}, buf_max);
|
|
}
|
|
};
|
|
|
|
at(event, col_c, concat);
|
|
strlcat(index, "..", buf_max); //TODO: special
|
|
at(event, col_b0, concat);
|
|
at(event, col_b1, concat);
|
|
|
|
string_view val;
|
|
at(event, col_a, [&val](const auto &_val)
|
|
{
|
|
val = byte_view<string_view>{_val};
|
|
});
|
|
|
|
db::iov::append
|
|
{
|
|
iov, db::delta
|
|
{
|
|
name, // col
|
|
index, // key
|
|
val, // val
|
|
}
|
|
};
|
|
}
|
|
|
|
std::set<std::shared_ptr<ircd::m::indexer>> ircd::m::indexers
|
|
{{
|
|
std::make_shared<ircd::m::indexer::concat>("event_id", "sender"),
|
|
std::make_shared<ircd::m::indexer::concat>("event_id", "room_id"),
|
|
std::make_shared<ircd::m::indexer::concat_v>("event_id", "room_id", "type"),
|
|
std::make_shared<ircd::m::indexer::concat_v>("event_id", "room_id", "sender"),
|
|
std::make_shared<ircd::m::indexer::concat_2v>("event_id", "type", "state_key", "room_id"),
|
|
}};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// 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)
|
|
:string_view{}
|
|
,sigil{sigil}
|
|
{
|
|
}
|
|
|
|
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, strlcpy(buf, id, max)
|
|
}
|
|
,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 &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 == 1 && !host.empty())
|
|
{
|
|
if(split(name, ':').second != host)
|
|
throw INVALID_MXID("MXID must be on host '%s'", host);
|
|
|
|
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 auto len
|
|
{
|
|
fmt::snprintf(buf, max, "%s:%s",
|
|
name,
|
|
host)
|
|
};
|
|
|
|
return string_view { buf, size_t(len) };
|
|
}()}
|
|
,sigil{sigil}
|
|
{
|
|
}
|
|
|
|
void
|
|
ircd::m::id::validate()
|
|
const
|
|
{
|
|
if(!valid())
|
|
throw INVALID_MXID("Not a valid '%s' mxid", reflect(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;
|
|
}
|