521 lines
16 KiB
Rust
521 lines
16 KiB
Rust
use std::fmt::Write;
|
|
|
|
use api::client::{get_alias_helper, leave_room};
|
|
use ruma::{
|
|
events::room::message::RoomMessageEventContent, OwnedRoomId, OwnedUserId, RoomAliasId, RoomId, RoomOrAliasId,
|
|
};
|
|
use tracing::{debug, error, info, warn};
|
|
|
|
use super::{super::Service, RoomModerationCommand};
|
|
use crate::{escape_html, get_room_info, services, user_is_local, Result};
|
|
|
|
pub(crate) async fn process(command: RoomModerationCommand, body: Vec<&str>) -> Result<RoomMessageEventContent> {
|
|
match command {
|
|
RoomModerationCommand::BanRoom {
|
|
force,
|
|
room,
|
|
disable_federation,
|
|
} => ban_room(body, force, room, disable_federation).await,
|
|
RoomModerationCommand::BanListOfRooms {
|
|
force,
|
|
disable_federation,
|
|
} => ban_list_of_rooms(body, force, disable_federation).await,
|
|
RoomModerationCommand::UnbanRoom {
|
|
room,
|
|
enable_federation,
|
|
} => unban_room(body, room, enable_federation).await,
|
|
RoomModerationCommand::ListBannedRooms => list_banned_rooms(body).await,
|
|
}
|
|
}
|
|
|
|
async fn ban_room(
|
|
_body: Vec<&str>, force: bool, room: Box<RoomOrAliasId>, disable_federation: bool,
|
|
) -> Result<RoomMessageEventContent> {
|
|
debug!("Got room alias or ID: {}", room);
|
|
|
|
let admin_room_alias = &services().globals.admin_alias;
|
|
|
|
if let Some(admin_room_id) = Service::get_admin_room()? {
|
|
if room.to_string().eq(&admin_room_id) || room.to_string().eq(admin_room_alias) {
|
|
return Ok(RoomMessageEventContent::text_plain("Not allowed to ban the admin room."));
|
|
}
|
|
}
|
|
|
|
let room_id = if room.is_room_id() {
|
|
let room_id = match RoomId::parse(&room) {
|
|
Ok(room_id) => room_id,
|
|
Err(e) => {
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to parse room ID {room}. Please note that this requires a full room ID \
|
|
(`!awIh6gGInaS5wLQJwa:example.com`) or a room alias (`#roomalias:example.com`): {e}"
|
|
)))
|
|
},
|
|
};
|
|
|
|
debug!("Room specified is a room ID, banning room ID");
|
|
|
|
services().rooms.metadata.ban_room(&room_id, true)?;
|
|
|
|
room_id
|
|
} else if room.is_room_alias_id() {
|
|
let room_alias = match RoomAliasId::parse(&room) {
|
|
Ok(room_alias) => room_alias,
|
|
Err(e) => {
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to parse room ID {room}. Please note that this requires a full room ID \
|
|
(`!awIh6gGInaS5wLQJwa:example.com`) or a room alias (`#roomalias:example.com`): {e}"
|
|
)))
|
|
},
|
|
};
|
|
|
|
debug!(
|
|
"Room specified is not a room ID, attempting to resolve room alias to a room ID locally, if not using \
|
|
get_alias_helper to fetch room ID remotely"
|
|
);
|
|
|
|
let room_id = if let Some(room_id) = services().rooms.alias.resolve_local_alias(&room_alias)? {
|
|
room_id
|
|
} else {
|
|
debug!("We don't have this room alias to a room ID locally, attempting to fetch room ID over federation");
|
|
|
|
match get_alias_helper(room_alias, None).await {
|
|
Ok(response) => {
|
|
debug!("Got federation response fetching room ID for room {room}: {:?}", response);
|
|
response.room_id
|
|
},
|
|
Err(e) => {
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to resolve room alias {room} to a room ID: {e}"
|
|
)));
|
|
},
|
|
}
|
|
};
|
|
|
|
services().rooms.metadata.ban_room(&room_id, true)?;
|
|
|
|
room_id
|
|
} else {
|
|
return Ok(RoomMessageEventContent::text_plain(
|
|
"Room specified is not a room ID or room alias. Please note that this requires a full room ID \
|
|
(`!awIh6gGInaS5wLQJwa:example.com`) or a room alias (`#roomalias:example.com`)",
|
|
));
|
|
};
|
|
|
|
debug!("Making all users leave the room {}", &room);
|
|
if force {
|
|
for local_user in services()
|
|
.rooms
|
|
.state_cache
|
|
.room_members(&room_id)
|
|
.filter_map(|user| {
|
|
user.ok().filter(|local_user| {
|
|
user_is_local(local_user)
|
|
// additional wrapped check here is to avoid adding remote users
|
|
// who are in the admin room to the list of local users (would
|
|
// fail auth check)
|
|
&& (user_is_local(local_user)
|
|
// since this is a force operation, assume user is an admin
|
|
// if somehow this fails
|
|
&& services()
|
|
.users
|
|
.is_admin(local_user)
|
|
.unwrap_or(true))
|
|
})
|
|
})
|
|
.collect::<Vec<OwnedUserId>>()
|
|
{
|
|
debug!(
|
|
"Attempting leave for user {} in room {} (forced, ignoring all errors, evicting admins too)",
|
|
&local_user, &room_id
|
|
);
|
|
|
|
if let Err(e) = leave_room(&local_user, &room_id, None).await {
|
|
warn!(%e, "Failed to leave room");
|
|
}
|
|
}
|
|
} else {
|
|
for local_user in services()
|
|
.rooms
|
|
.state_cache
|
|
.room_members(&room_id)
|
|
.filter_map(|user| {
|
|
user.ok().filter(|local_user| {
|
|
local_user.server_name() == services().globals.server_name()
|
|
// additional wrapped check here is to avoid adding remote users
|
|
// who are in the admin room to the list of local users (would fail auth check)
|
|
&& (local_user.server_name()
|
|
== services().globals.server_name()
|
|
&& !services()
|
|
.users
|
|
.is_admin(local_user)
|
|
.unwrap_or(false))
|
|
})
|
|
})
|
|
.collect::<Vec<OwnedUserId>>()
|
|
{
|
|
debug!("Attempting leave for user {} in room {}", &local_user, &room_id);
|
|
if let Err(e) = leave_room(&local_user, &room_id, None).await {
|
|
error!(
|
|
"Error attempting to make local user {} leave room {} during room banning: {}",
|
|
&local_user, &room_id, e
|
|
);
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Error attempting to make local user {} leave room {} during room banning (room is still banned \
|
|
but not removing any more users): {}\nIf you would like to ignore errors, use --force",
|
|
&local_user, &room_id, e
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
|
|
if disable_federation {
|
|
services().rooms.metadata.disable_room(&room_id, true)?;
|
|
return Ok(RoomMessageEventContent::text_plain(
|
|
"Room banned, removed all our local users, and disabled incoming federation with room.",
|
|
));
|
|
}
|
|
|
|
Ok(RoomMessageEventContent::text_plain(
|
|
"Room banned and removed all our local users, use `!admin federation disable-room` to stop receiving new \
|
|
inbound federation events as well if needed.",
|
|
))
|
|
}
|
|
|
|
async fn ban_list_of_rooms(body: Vec<&str>, force: bool, disable_federation: bool) -> Result<RoomMessageEventContent> {
|
|
if body.len() < 2 || !body[0].trim().starts_with("```") || body.last().unwrap_or(&"").trim() != "```" {
|
|
return Ok(RoomMessageEventContent::text_plain(
|
|
"Expected code block in command body. Add --help for details.",
|
|
));
|
|
}
|
|
|
|
let rooms_s = body.clone().drain(1..body.len() - 1).collect::<Vec<_>>();
|
|
|
|
let admin_room_alias = &services().globals.admin_alias;
|
|
|
|
let mut room_ban_count: usize = 0;
|
|
let mut room_ids: Vec<OwnedRoomId> = Vec::new();
|
|
|
|
for &room in &rooms_s {
|
|
match <&RoomOrAliasId>::try_from(room) {
|
|
Ok(room_alias_or_id) => {
|
|
if let Some(admin_room_id) = Service::get_admin_room()? {
|
|
if room.to_owned().eq(&admin_room_id) || room.to_owned().eq(admin_room_alias) {
|
|
info!("User specified admin room in bulk ban list, ignoring");
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if room_alias_or_id.is_room_id() {
|
|
let room_id = match RoomId::parse(room_alias_or_id) {
|
|
Ok(room_id) => room_id,
|
|
Err(e) => {
|
|
if force {
|
|
// ignore rooms we failed to parse if we're force banning
|
|
warn!(
|
|
"Error parsing room \"{room}\" during bulk room banning, ignoring error and \
|
|
logging here: {e}"
|
|
);
|
|
continue;
|
|
}
|
|
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"{room} is not a valid room ID or room alias, please fix the list and try again: {e}"
|
|
)));
|
|
},
|
|
};
|
|
|
|
room_ids.push(room_id);
|
|
}
|
|
|
|
if room_alias_or_id.is_room_alias_id() {
|
|
match RoomAliasId::parse(room_alias_or_id) {
|
|
Ok(room_alias) => {
|
|
let room_id =
|
|
if let Some(room_id) = services().rooms.alias.resolve_local_alias(&room_alias)? {
|
|
room_id
|
|
} else {
|
|
debug!(
|
|
"We don't have this room alias to a room ID locally, attempting to fetch room \
|
|
ID over federation"
|
|
);
|
|
|
|
match get_alias_helper(room_alias, None).await {
|
|
Ok(response) => {
|
|
debug!(
|
|
"Got federation response fetching room ID for room {room}: {:?}",
|
|
response
|
|
);
|
|
response.room_id
|
|
},
|
|
Err(e) => {
|
|
// don't fail if force blocking
|
|
if force {
|
|
warn!("Failed to resolve room alias {room} to a room ID: {e}");
|
|
continue;
|
|
}
|
|
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to resolve room alias {room} to a room ID: {e}"
|
|
)));
|
|
},
|
|
}
|
|
};
|
|
|
|
room_ids.push(room_id);
|
|
},
|
|
Err(e) => {
|
|
if force {
|
|
// ignore rooms we failed to parse if we're force deleting
|
|
error!(
|
|
"Error parsing room \"{room}\" during bulk room banning, ignoring error and \
|
|
logging here: {e}"
|
|
);
|
|
continue;
|
|
}
|
|
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"{room} is not a valid room ID or room alias, please fix the list and try again: {e}"
|
|
)));
|
|
},
|
|
}
|
|
}
|
|
},
|
|
Err(e) => {
|
|
if force {
|
|
// ignore rooms we failed to parse if we're force deleting
|
|
error!(
|
|
"Error parsing room \"{room}\" during bulk room banning, ignoring error and logging here: {e}"
|
|
);
|
|
continue;
|
|
}
|
|
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"{room} is not a valid room ID or room alias, please fix the list and try again: {e}"
|
|
)));
|
|
},
|
|
}
|
|
}
|
|
|
|
for room_id in room_ids {
|
|
if services().rooms.metadata.ban_room(&room_id, true).is_ok() {
|
|
debug!("Banned {room_id} successfully");
|
|
room_ban_count = room_ban_count.saturating_add(1);
|
|
}
|
|
|
|
debug!("Making all users leave the room {}", &room_id);
|
|
if force {
|
|
for local_user in services()
|
|
.rooms
|
|
.state_cache
|
|
.room_members(&room_id)
|
|
.filter_map(|user| {
|
|
user.ok().filter(|local_user| {
|
|
local_user.server_name() == services().globals.server_name()
|
|
// additional wrapped check here is to avoid adding remote
|
|
// users who are in the admin room to the list of local
|
|
// users (would fail auth check)
|
|
&& (local_user.server_name()
|
|
== services().globals.server_name()
|
|
// since this is a force operation, assume user is an
|
|
// admin if somehow this fails
|
|
&& services()
|
|
.users
|
|
.is_admin(local_user)
|
|
.unwrap_or(true))
|
|
})
|
|
})
|
|
.collect::<Vec<OwnedUserId>>()
|
|
{
|
|
debug!(
|
|
"Attempting leave for user {} in room {} (forced, ignoring all errors, evicting admins too)",
|
|
&local_user, room_id
|
|
);
|
|
if let Err(e) = leave_room(&local_user, &room_id, None).await {
|
|
warn!(%e, "Failed to leave room");
|
|
}
|
|
}
|
|
} else {
|
|
for local_user in services()
|
|
.rooms
|
|
.state_cache
|
|
.room_members(&room_id)
|
|
.filter_map(|user| {
|
|
user.ok().filter(|local_user| {
|
|
local_user.server_name() == services().globals.server_name()
|
|
// additional wrapped check here is to avoid adding remote
|
|
// users who are in the admin room to the list of local
|
|
// users (would fail auth check)
|
|
&& (local_user.server_name()
|
|
== services().globals.server_name()
|
|
&& !services()
|
|
.users
|
|
.is_admin(local_user)
|
|
.unwrap_or(false))
|
|
})
|
|
})
|
|
.collect::<Vec<OwnedUserId>>()
|
|
{
|
|
debug!("Attempting leave for user {} in room {}", &local_user, &room_id);
|
|
if let Err(e) = leave_room(&local_user, &room_id, None).await {
|
|
error!(
|
|
"Error attempting to make local user {} leave room {} during bulk room banning: {}",
|
|
&local_user, &room_id, e
|
|
);
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Error attempting to make local user {} leave room {} during room banning (room is still \
|
|
banned but not removing any more users and not banning any more rooms): {}\nIf you would \
|
|
like to ignore errors, use --force",
|
|
&local_user, &room_id, e
|
|
)));
|
|
}
|
|
}
|
|
}
|
|
|
|
if disable_federation {
|
|
services().rooms.metadata.disable_room(&room_id, true)?;
|
|
}
|
|
}
|
|
|
|
if disable_federation {
|
|
Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Finished bulk room ban, banned {room_ban_count} total rooms, evicted all users, and disabled incoming \
|
|
federation with the room."
|
|
)))
|
|
} else {
|
|
Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Finished bulk room ban, banned {room_ban_count} total rooms and evicted all users."
|
|
)))
|
|
}
|
|
}
|
|
|
|
async fn unban_room(
|
|
_body: Vec<&str>, room: Box<RoomOrAliasId>, enable_federation: bool,
|
|
) -> Result<RoomMessageEventContent> {
|
|
let room_id = if room.is_room_id() {
|
|
let room_id = match RoomId::parse(&room) {
|
|
Ok(room_id) => room_id,
|
|
Err(e) => {
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to parse room ID {room}. Please note that this requires a full room ID \
|
|
(`!awIh6gGInaS5wLQJwa:example.com`) or a room alias (`#roomalias:example.com`): {e}"
|
|
)))
|
|
},
|
|
};
|
|
|
|
debug!("Room specified is a room ID, unbanning room ID");
|
|
|
|
services().rooms.metadata.ban_room(&room_id, false)?;
|
|
|
|
room_id
|
|
} else if room.is_room_alias_id() {
|
|
let room_alias = match RoomAliasId::parse(&room) {
|
|
Ok(room_alias) => room_alias,
|
|
Err(e) => {
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to parse room ID {room}. Please note that this requires a full room ID \
|
|
(`!awIh6gGInaS5wLQJwa:example.com`) or a room alias (`#roomalias:example.com`): {e}"
|
|
)))
|
|
},
|
|
};
|
|
|
|
debug!(
|
|
"Room specified is not a room ID, attempting to resolve room alias to a room ID locally, if not using \
|
|
get_alias_helper to fetch room ID remotely"
|
|
);
|
|
|
|
let room_id = if let Some(room_id) = services().rooms.alias.resolve_local_alias(&room_alias)? {
|
|
room_id
|
|
} else {
|
|
debug!("We don't have this room alias to a room ID locally, attempting to fetch room ID over federation");
|
|
|
|
match get_alias_helper(room_alias, None).await {
|
|
Ok(response) => {
|
|
debug!("Got federation response fetching room ID for room {room}: {:?}", response);
|
|
response.room_id
|
|
},
|
|
Err(e) => {
|
|
return Ok(RoomMessageEventContent::text_plain(format!(
|
|
"Failed to resolve room alias {room} to a room ID: {e}"
|
|
)));
|
|
},
|
|
}
|
|
};
|
|
|
|
services().rooms.metadata.ban_room(&room_id, false)?;
|
|
|
|
room_id
|
|
} else {
|
|
return Ok(RoomMessageEventContent::text_plain(
|
|
"Room specified is not a room ID or room alias. Please note that this requires a full room ID \
|
|
(`!awIh6gGInaS5wLQJwa:example.com`) or a room alias (`#roomalias:example.com`)",
|
|
));
|
|
};
|
|
|
|
if enable_federation {
|
|
services().rooms.metadata.disable_room(&room_id, false)?;
|
|
return Ok(RoomMessageEventContent::text_plain("Room unbanned."));
|
|
}
|
|
|
|
Ok(RoomMessageEventContent::text_plain(
|
|
"Room unbanned, you may need to re-enable federation with the room using enable-room if this is a remote room \
|
|
to make it fully functional.",
|
|
))
|
|
}
|
|
|
|
async fn list_banned_rooms(_body: Vec<&str>) -> Result<RoomMessageEventContent> {
|
|
let rooms = services()
|
|
.rooms
|
|
.metadata
|
|
.list_banned_rooms()
|
|
.collect::<Result<Vec<_>, _>>();
|
|
|
|
match rooms {
|
|
Ok(room_ids) => {
|
|
if room_ids.is_empty() {
|
|
return Ok(RoomMessageEventContent::text_plain("No rooms are banned."));
|
|
}
|
|
|
|
let mut rooms = room_ids
|
|
.into_iter()
|
|
.map(|room_id| get_room_info(&room_id))
|
|
.collect::<Vec<_>>();
|
|
rooms.sort_by_key(|r| r.1);
|
|
rooms.reverse();
|
|
|
|
let output_plain = format!(
|
|
"Rooms Banned ({}):\n```\n{}```",
|
|
rooms.len(),
|
|
rooms
|
|
.iter()
|
|
.map(|(id, members, name)| format!("{id}\tMembers: {members}\tName: {name}"))
|
|
.collect::<Vec<_>>()
|
|
.join("\n")
|
|
);
|
|
|
|
let output_html = format!(
|
|
"<table><caption>Rooms Banned ({}) \
|
|
</caption>\n<tr><th>id</th>\t<th>members</th>\t<th>name</th></tr>\n{}</table>",
|
|
rooms.len(),
|
|
rooms
|
|
.iter()
|
|
.fold(String::new(), |mut output, (id, members, name)| {
|
|
writeln!(
|
|
output,
|
|
"<tr><td>{}</td>\t<td>{}</td>\t<td>{}</td></tr>",
|
|
id,
|
|
members,
|
|
escape_html(name.as_ref())
|
|
)
|
|
.expect("should be able to write to string buffer");
|
|
output
|
|
})
|
|
);
|
|
|
|
Ok(RoomMessageEventContent::text_html(output_plain, output_html))
|
|
},
|
|
Err(e) => {
|
|
error!("Failed to list banned rooms: {}", e);
|
|
Ok(RoomMessageEventContent::text_plain(format!("Unable to list banned rooms: {e}")))
|
|
},
|
|
}
|
|
}
|