// Matrix Construct // // Copyright (C) Matrix Construct Developers, Authors & Contributors // Copyright (C) 2016-2019 Jason Volk // // 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. #include using namespace ircd; mapi::header IRCD_MODULE { "Server Command" }; static std::pair execute_command(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd); static void handle_command(const m::event &event, m::vm::eval &eval); m::hookfn command_hook { handle_command, { { "_site", "vm.effect" }, { "type", "ircd.cmd" }, { "origin", my_host() }, } }; void handle_command(const m::event &event, m::vm::eval &eval) try { const m::user user { at<"sender"_>(event) }; if(!m::my(user.user_id)) return; const json::object &content { json::get<"content"_>(event) }; const m::user::room user_room { user }; if(json::get<"room_id"_>(event) != user_room.room_id) return; const m::room::id &room_id { unquote(content.at("room_id")) }; const json::string &input { content.at("body") }; if(!startswith(input, "\\\\")) return; // View of the command string without prefix string_view cmd{input}; cmd = lstrip(cmd, "\\\\"); // Determine if there's a bang after the prefix; if so the response's // sender will be the user, and will be broadcast publicly to the room. // Otherwise the response comes from the server and is only visible in // the user's timeline. const bool public_response(startswith(cmd, '!')); cmd = lstrip(cmd, '!'); log::debug { m::log, "Server command from %s in %s public:%b :%s", string_view{room_id}, string_view{user.user_id}, public_response, cmd }; const unique_buffer buf { 32_KiB }; const auto &[html, alt] { execute_command(buf, user, room_id, cmd) }; if(!html && !alt) return; const auto &response_sender { public_response? user : m::me }; const auto &response_room { public_response? room_id : user_room }; const auto &response_type { public_response? "m.room.message" : "ircd.cmd.result" }; m::send(response_room, response_sender, response_type, { { "msgtype", "m.notice" }, { "format", "org.matrix.custom.html" }, { "body", { alt, json::STRING } }, { "formatted_body", { html, json::STRING } }, { "room_id", room_id }, { "input", input }, }); } catch(const std::exception &e) { throw; } static std::pair command__ping(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd); static std::pair command__dash(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd); static std::pair command__read(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd); static std::pair command__version(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd); std::pair execute_command(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd) try { switch(hash(token(cmd, ' ', 0))) { case "version"_: return command__version(buf, user, room, cmd); case "read"_: return command__read(buf, user, room, cmd); case "dash"_: return command__dash(buf, user, room, cmd); case "ping"_: return command__ping(buf, user, room, cmd); default: break; } const string_view out{fmt::sprintf { buf, "unknown command :%s", cmd }}; const string_view alt { out }; return { out, alt }; } catch(const m::error &e) { const json::object &error { e.content }; log::error { m::log, "Server command from %s in %s '%s' :%s :%s :%s", string_view{room.room_id}, string_view{user.user_id}, cmd, e.what(), unquote(error.get("errcode")), unquote(error.get("error")), }; std::ostringstream out; pubsetbuf(out, buf); const string_view fg[] {"#FCFCFC", "#FFFFFF"}; const string_view bg[] {"#A01810", "#C81810"}; const string_view sp {" "}; out << "
" << "" << "" << sp << sp << e.what() << sp << sp << "" << " " << "" << "" << sp << sp << unquote(error.get("errcode")) << sp << sp << "" << " " << "
" << "
"
	    << unquote(error.get("error"))
	    << "
" ; return { view(out, buf), e.what() }; } catch(const http::error &e) { log::error { m::log, "Server command from %s in %s '%s' :%s :%s", string_view{room.room_id}, string_view{user.user_id}, cmd, e.what(), e.content }; std::ostringstream out; pubsetbuf(out, buf); const string_view fg[] {"#FCFCFC"}; const string_view bg[] {"#A01810"}; const string_view sp {" "}; out << "
" << "" << "" << sp << sp << e.what() << sp << sp << "" << " " << "
" << "
"
	    << e.content
	    << "
" ; return { view(out, buf), e.what() }; } catch(const std::exception &e) { log::error { m::log, "Server command from %s in %s '%s' :%s", string_view{room.room_id}, string_view{user.user_id}, cmd, e.what() }; const size_t len { copy(buf, string_view(e.what())) }; return { { data(buf), len }, { data(buf), len } }; } std::pair command__version(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd) { std::ostringstream out; pubsetbuf(out, buf); const string_view sp {" "}; out << "

" << info::name << "

" << "
"
	    << info::version
	    << "
" ; const string_view alt { info::version }; return { view(out, buf), alt }; } std::pair command__read(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd) { const params param{tokens_after(cmd, ' ', 0), " ", { "arg", "[time]" }}; const string_view &arg { param["arg"] }; const time_t &ms { param.at("[time]", ircd::time()) }; std::ostringstream out; pubsetbuf(out, buf); if(m::valid(m::id::EVENT, arg)) { const m::event::id::buf event_id { arg? m::event::id::buf{arg}: m::head(room) }; m::receipt::read(room, user, event_id, json::strung{json::members { { "ts", ms }, }}); return {}; } else if(m::valid(m::id::ROOM, arg) || m::valid(m::id::ROOM_ALIAS, arg)) { const auto room_id { m::room_id(arg) }; const m::room room { room_id }; const m::event::id::buf event_id { m::head(room) }; m::receipt::read(room, user, event_id, json::strung{json::members { { "ts", ms }, }}); return {}; } // We don't accept no-argument as a wildcard to prevent a naive user // just probing the command interface from performing the following large // operation on all their rooms... if(!arg) return {}; // The string argument can be a globular expression of room tags, like // `m.*` or just `*`. const globular_match match { arg }; // Iterate all joined rooms for a user. For each room we'll test if the // room's tag matches the arg string globular expression. const m::user::rooms user_rooms { user }; const string_view fg[] {"#FFFFFF"}; const string_view bg[] {"#000000"}; out << "
"
	<< ""
	<< ""
	;

	size_t matched(0);
	user_rooms.for_each("join", [&user, &ms, &match, &out, &matched]
	(const m::room::id &room_id, const string_view &)
	{
		const m::user::room_tags room_tags
		{
			user, room_id
		};

		// return true if the expression is not matched for this room.
		const auto without_match{[&match]
		(const string_view &key, const json::object &object)
		{
			return !match(key);
		}};

		// for_each returns true if it didn't break from the loop, which means
		// no match and skip actions for this room.
		if(match.expr != "*")
			if(room_tags.for_each(without_match))
				return;

		// Get the room head (if there are multiple, the best is selected for
		// us) which will be the target of our receipt.
		const m::event::id::buf event_id
		{
			m::head(std::nothrow, room_id)
		};

		// Nothing to send a receipt for.
		if(!event_id)
			return;

		const auto put{[&out]
		(const string_view &room_id, const string_view &event_id)
		{
			out
			<< ""
			<< ""
			<< ""
			<< ""
			;
		}};

		// Check if event_id is more recent than the last receipt's event_id.
		if(!m::receipt::freshest(room_id, user, event_id))
		{
			put(room_id, "You already read this or a later event in the room.");
			return;
		}

		// Check if user wants to prevent sending receipts to this room.
		if(m::receipt::ignoring(user, room_id))
		{
			put(room_id, "You have configured to not send receipts to this room.");
			return;
		}

		// Check if user wants to prevent based on this event's specifics.
		if(m::receipt::ignoring(user, event_id))
		{
			put(room_id, "You have configured to not send receipts for this event.");
			return;
		}

		// Commit the receipt.
		m::receipt::read(room_id, user, event_id, json::strung{json::members
		{
			{ "ts",        ms   },
			{ "m.hidden",  true },
		}});

		put(room_id, event_id);
		++matched;
	});

	out
	<< "
" << "" << room_id << "" << "" << event_id << "
" << "
" << "
*** Marked " << matched << " rooms as read.
" << "
" ; return { view(out, buf), "TODO: alt text." }; } static std::pair command__ping__room(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd); std::pair command__ping(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd) { const params param{tokens_after(cmd, ' ', 0), " ", { "target" }}; const string_view &target { param["target"] }; const bool room_ping { !target || m::valid(m::id::ROOM, target) || m::valid(m::id::ROOM_ALIAS, target) }; if(room_ping) return command__ping__room(buf, user, room, cmd); m::v1::version::opts opts; if(m::valid(m::id::USER, target)) opts.remote = m::user::id(target).host(); else opts.remote = target; const unique_buffer http_buf { 8_KiB }; util::timer timer; m::v1::version request { http_buf, std::move(opts) }; std::exception_ptr eptr; try { request.wait(seconds(10)); const auto code(request.get()); } catch(const std::exception &e) { eptr = std::current_exception(); } const auto time { timer.at() }; static const string_view sp{" "}, fg{"#e8e8e8"}, host_bg{"#181b21"}, online_bg{"#008000"}, offline_bg{"#A01810"}; const string_view bg{eptr? offline_bg : online_bg}, status{eptr? "FAILED " : "ONLINE"}; std::ostringstream out; pubsetbuf(out, buf); thread_local char tmbuf[32]; out << " " << " " << sp << sp << status << sp << sp << " " << " " << " " << sp << sp << " " << target << " " << sp << " " ; if(!eptr) out << " " << pretty(tmbuf, time) << " " << " application layer round-trip time."; if(eptr) out << "
"
		     << what(eptr)
		     << "
"; const string_view rich { view(out, buf) }; const string_view alt{fmt::sprintf { buf + size(rich), "response in %s", pretty(tmbuf, time) }}; return { view(out, buf), alt }; } std::pair command__ping__room(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd) { const params param{tokens_after(cmd, ' ', 0), " ", { "target" }}; const string_view &target { param["target"] }; m::feds::opts opts; opts.op = m::feds::op::version; opts.room_id = room.room_id; opts.closure_cached_errors = true; opts.timeout = seconds(10); //TODO: conf thread_local char tmbuf[32]; std::ostringstream out; pubsetbuf(out, buf); util::timer timer; size_t responses{0}; m::feds::execute(opts, [&timer, &responses, &buf, &out] (const auto &result) { ++responses; static const string_view sp{" "}, fg{"#e8e8e8"}, host_bg{"#181b21"}, online_bg{"#008000"}, offline_bg{"#A01810"}; const string_view bg{result.eptr? offline_bg : online_bg}, status{result.eptr? "FAILED " : "ONLINE"}; out << " " << " " << sp << sp << status << sp << sp << " " << " " << " " << sp << sp << " " << result.origin << " " << sp << " " ; if(!result.eptr) out << " " << pretty(tmbuf, timer.at()) << " " << " application layer round-trip time." << "
"; if(result.eptr) out << "" << what(result.eptr) << "" << "
"; return true; }); const string_view rich { view(out, buf) }; const string_view alt{fmt::sprintf { buf + size(rich), "%zu responses in %s", responses, pretty(tmbuf, timer.at()) }}; return { view(out, buf), alt }; } std::pair command__dash(const mutable_buffer &buf, const m::user &user, const m::room &room, const string_view &cmd) { std::ostringstream out; pubsetbuf(out, buf); const string_view fg[] {"#3EA6FF", "#FFFFFF"}; const string_view bg[] {"#000000", "#008000"}; const string_view sp {" "}; out << "
" << "" << "" << sp << sp << " CONSTRUCT STATUS " << sp << sp << "" << " " << "" << "" << sp << sp << " OK " << sp << sp << "" << " " << "
" << "
"
	    << " "
	    << "
" ; const string_view alt { "no alt text" }; return { view(out, buf), alt }; }