|
|
|
@@ -1,57 +1,18 @@
|
|
|
|
|
use std::{borrow::Borrow, collections::HashMap, iter::once, sync::Arc};
|
|
|
|
|
|
|
|
|
|
use axum::extract::State;
|
|
|
|
|
use axum_client_ip::ClientIp;
|
|
|
|
|
use conduwuit::{
|
|
|
|
|
Err, Result, debug, debug_info, debug_warn, err, error, info, is_true,
|
|
|
|
|
matrix::{
|
|
|
|
|
StateKey,
|
|
|
|
|
event::{gen_event_id, gen_event_id_canonical_json},
|
|
|
|
|
pdu::{PartialPdu, PduEvent},
|
|
|
|
|
state_res,
|
|
|
|
|
},
|
|
|
|
|
Err, Result, debug,
|
|
|
|
|
result::FlatOk,
|
|
|
|
|
trace,
|
|
|
|
|
utils::{
|
|
|
|
|
self, shuffle,
|
|
|
|
|
stream::{IterStream, ReadyExt},
|
|
|
|
|
to_canonical_object,
|
|
|
|
|
},
|
|
|
|
|
warn,
|
|
|
|
|
utils::{shuffle, stream::IterStream},
|
|
|
|
|
};
|
|
|
|
|
use futures::{FutureExt, StreamExt, TryFutureExt};
|
|
|
|
|
use futures::{FutureExt, StreamExt};
|
|
|
|
|
use ruma::{
|
|
|
|
|
CanonicalJsonObject, CanonicalJsonValue, OwnedRoomId, OwnedServerName, OwnedUserId, RoomId,
|
|
|
|
|
RoomVersionId, UserId,
|
|
|
|
|
api::{
|
|
|
|
|
client::membership::{join_room_by_id, join_room_by_id_or_alias},
|
|
|
|
|
error::{ErrorKind, IncompatibleRoomVersionErrorData},
|
|
|
|
|
federation::{self},
|
|
|
|
|
},
|
|
|
|
|
canonical_json::to_canonical_value,
|
|
|
|
|
events::{
|
|
|
|
|
StateEventType,
|
|
|
|
|
room::{
|
|
|
|
|
join_rules::JoinRule,
|
|
|
|
|
member::{MembershipState, RoomMemberEventContent},
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
OwnedRoomId, OwnedServerName, OwnedUserId, UserId,
|
|
|
|
|
api::client::membership::{join_room_by_id, join_room_by_id_or_alias},
|
|
|
|
|
};
|
|
|
|
|
use service::{
|
|
|
|
|
Services,
|
|
|
|
|
rooms::{
|
|
|
|
|
state::RoomMutexGuard,
|
|
|
|
|
state_compressor::{CompressedState, HashSetCompressStateEvent},
|
|
|
|
|
timeline::pdu_fits,
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
use tokio::join;
|
|
|
|
|
|
|
|
|
|
use super::{banned_room_check, validate_remote_member_event_stub};
|
|
|
|
|
use crate::{
|
|
|
|
|
Ruma,
|
|
|
|
|
server::{select_authorising_user, user_can_perform_restricted_join},
|
|
|
|
|
};
|
|
|
|
|
use super::banned_room_check;
|
|
|
|
|
use crate::Ruma;
|
|
|
|
|
|
|
|
|
|
/// # `POST /_matrix/client/r0/rooms/{roomId}/join`
|
|
|
|
|
///
|
|
|
|
@@ -111,9 +72,14 @@ pub(crate) async fn join_room_by_id_route(
|
|
|
|
|
shuffle(&mut servers);
|
|
|
|
|
let servers = deprioritize(servers, &services.config.deprioritize_joins_through_servers);
|
|
|
|
|
|
|
|
|
|
join_room_by_id_helper(&services, sender_user, &body.room_id, body.reason.clone(), &servers)
|
|
|
|
|
let room_id = services
|
|
|
|
|
.rooms
|
|
|
|
|
.membership
|
|
|
|
|
.join_room(sender_user, &body.room_id, body.reason.clone(), &servers)
|
|
|
|
|
.boxed()
|
|
|
|
|
.await
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
Ok(join_room_by_id::v3::Response::new(room_id))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// # `POST /_matrix/client/r0/join/{roomIdOrAlias}`
|
|
|
|
@@ -226,632 +192,14 @@ pub(crate) async fn join_room_by_id_or_alias_route(
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let servers = deprioritize(servers, &services.config.deprioritize_joins_through_servers);
|
|
|
|
|
let join_room_response =
|
|
|
|
|
join_room_by_id_helper(&services, sender_user, &room_id, body.reason.clone(), &servers)
|
|
|
|
|
.boxed()
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
Ok(join_room_by_id_or_alias::v3::Response::new(join_room_response.room_id))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
pub async fn join_room_by_id_helper(
|
|
|
|
|
services: &Services,
|
|
|
|
|
sender_user: &UserId,
|
|
|
|
|
room_id: &RoomId,
|
|
|
|
|
reason: Option<String>,
|
|
|
|
|
servers: &[OwnedServerName],
|
|
|
|
|
) -> Result<join_room_by_id::v3::Response> {
|
|
|
|
|
let state_lock = services.rooms.state.mutex.lock(room_id).await;
|
|
|
|
|
|
|
|
|
|
if services
|
|
|
|
|
let room_id = services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_cache
|
|
|
|
|
.is_joined(sender_user, room_id)
|
|
|
|
|
.await
|
|
|
|
|
{
|
|
|
|
|
debug_warn!("{sender_user} is already joined in {room_id}");
|
|
|
|
|
return Ok(join_room_by_id::v3::Response::new(room_id.to_owned()));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if let Err(e) = services
|
|
|
|
|
.antispam
|
|
|
|
|
.user_may_join_room(
|
|
|
|
|
sender_user.to_owned(),
|
|
|
|
|
room_id.to_owned(),
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_cache
|
|
|
|
|
.is_invited(sender_user, room_id)
|
|
|
|
|
.await,
|
|
|
|
|
)
|
|
|
|
|
.await
|
|
|
|
|
{
|
|
|
|
|
warn!("Antispam prevented user {} from joining room {}: {}", sender_user, room_id, e);
|
|
|
|
|
return Err!(Request(Forbidden("You are not allowed to join this room.")));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let server_in_room = services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_cache
|
|
|
|
|
.server_in_room(services.globals.server_name(), room_id)
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
// Only check our known membership if we're already in the room.
|
|
|
|
|
// See: https://forgejo.ellis.link/continuwuation/continuwuity/issues/855
|
|
|
|
|
let membership = if server_in_room {
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_accessor
|
|
|
|
|
.get_member(room_id, sender_user)
|
|
|
|
|
.await
|
|
|
|
|
} else {
|
|
|
|
|
debug!("Ignoring local state for join {room_id}, we aren't in the room yet.");
|
|
|
|
|
Ok(RoomMemberEventContent::new(MembershipState::Leave))
|
|
|
|
|
};
|
|
|
|
|
if let Ok(m) = membership {
|
|
|
|
|
if m.membership == MembershipState::Ban {
|
|
|
|
|
debug_warn!("{sender_user} is banned from {room_id} but attempted to join");
|
|
|
|
|
// TODO: return reason
|
|
|
|
|
return Err!(Request(Forbidden("You are banned from the room.")));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if !server_in_room && servers.is_empty() {
|
|
|
|
|
return Err!(Request(NotFound(
|
|
|
|
|
"No servers were provided to assist in joining the room remotely, and we are not \
|
|
|
|
|
already participating in the room."
|
|
|
|
|
)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if services.antispam.check_all_joins() {
|
|
|
|
|
if let Err(e) = services
|
|
|
|
|
.antispam
|
|
|
|
|
.meowlnir_accept_make_join(room_id.to_owned(), sender_user.to_owned())
|
|
|
|
|
.await
|
|
|
|
|
{
|
|
|
|
|
warn!("Antispam prevented user {} from joining room {}: {}", sender_user, room_id, e);
|
|
|
|
|
return Err!(Request(Forbidden("Antispam rejected join request.")));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if server_in_room {
|
|
|
|
|
join_room_by_id_helper_local(services, sender_user, room_id, reason, servers, state_lock)
|
|
|
|
|
.boxed()
|
|
|
|
|
.await?;
|
|
|
|
|
} else {
|
|
|
|
|
// Ask a remote server if we are not participating in this room
|
|
|
|
|
join_room_by_id_helper_remote(
|
|
|
|
|
services,
|
|
|
|
|
sender_user,
|
|
|
|
|
room_id,
|
|
|
|
|
reason,
|
|
|
|
|
servers,
|
|
|
|
|
state_lock,
|
|
|
|
|
)
|
|
|
|
|
.membership
|
|
|
|
|
.join_room(sender_user, &room_id, body.reason.clone(), &servers)
|
|
|
|
|
.boxed()
|
|
|
|
|
.await?;
|
|
|
|
|
}
|
|
|
|
|
Ok(join_room_by_id::v3::Response::new(room_id.to_owned()))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tracing::instrument(skip_all, fields(%sender_user, %room_id), name = "join_remote", level = "info")]
|
|
|
|
|
async fn join_room_by_id_helper_remote(
|
|
|
|
|
services: &Services,
|
|
|
|
|
sender_user: &UserId,
|
|
|
|
|
room_id: &RoomId,
|
|
|
|
|
reason: Option<String>,
|
|
|
|
|
servers: &[OwnedServerName],
|
|
|
|
|
state_lock: RoomMutexGuard,
|
|
|
|
|
) -> Result {
|
|
|
|
|
info!("Joining {room_id} over federation.");
|
|
|
|
|
|
|
|
|
|
let (make_join_response, remote_server) =
|
|
|
|
|
make_join_request(services, sender_user, room_id, servers).await?;
|
|
|
|
|
|
|
|
|
|
info!("make_join finished");
|
|
|
|
|
|
|
|
|
|
let room_version = make_join_response.room_version.unwrap_or(RoomVersionId::V1);
|
|
|
|
|
let room_version_rules = room_version
|
|
|
|
|
.rules()
|
|
|
|
|
.expect("room version should have defined rules");
|
|
|
|
|
|
|
|
|
|
if !services.server.supported_room_version(&room_version) {
|
|
|
|
|
// How did we get here?
|
|
|
|
|
return Err!(BadServerResponse("Remote room version {room_version} is not supported"));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let mut join_event_stub: CanonicalJsonObject =
|
|
|
|
|
serde_json::from_str(make_join_response.event.get()).map_err(|e| {
|
|
|
|
|
err!(BadServerResponse(warn!(
|
|
|
|
|
"Invalid make_join event json received from server: {e:?}"
|
|
|
|
|
)))
|
|
|
|
|
})?;
|
|
|
|
|
|
|
|
|
|
let join_authorized_via_users_server = {
|
|
|
|
|
use RoomVersionId::*;
|
|
|
|
|
if !matches!(room_version, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
|
|
|
|
|
join_event_stub
|
|
|
|
|
.get("content")
|
|
|
|
|
.map(|s| {
|
|
|
|
|
s.as_object()?
|
|
|
|
|
.get("join_authorised_via_users_server")?
|
|
|
|
|
.as_str()
|
|
|
|
|
})
|
|
|
|
|
.and_then(|s| OwnedUserId::try_from(s.unwrap_or_default()).ok())
|
|
|
|
|
} else {
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
join_event_stub.insert(
|
|
|
|
|
"origin_server_ts".to_owned(),
|
|
|
|
|
CanonicalJsonValue::Integer(
|
|
|
|
|
utils::millis_since_unix_epoch()
|
|
|
|
|
.try_into()
|
|
|
|
|
.expect("Timestamp is valid js_int value"),
|
|
|
|
|
),
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let mut join_content = RoomMemberEventContent::new(MembershipState::Join);
|
|
|
|
|
join_content.displayname = services.users.displayname(sender_user).await.ok();
|
|
|
|
|
join_content.avatar_url = services.users.avatar_url(sender_user).await.ok();
|
|
|
|
|
join_content.blurhash = services.users.blurhash(sender_user).await.ok();
|
|
|
|
|
join_content.reason = reason;
|
|
|
|
|
join_content
|
|
|
|
|
.join_authorized_via_users_server
|
|
|
|
|
.clone_from(&join_authorized_via_users_server);
|
|
|
|
|
|
|
|
|
|
join_event_stub.insert(
|
|
|
|
|
"content".to_owned(),
|
|
|
|
|
to_canonical_value(join_content).expect("event is valid, we just created it"),
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
// Remove event id if it exists
|
|
|
|
|
join_event_stub.remove("event_id");
|
|
|
|
|
|
|
|
|
|
// In order to create a compatible ref hash (EventID) the `hashes` field needs
|
|
|
|
|
// to be present
|
|
|
|
|
services
|
|
|
|
|
.server_keys
|
|
|
|
|
.hash_and_sign_event(&mut join_event_stub, &room_version_rules)?;
|
|
|
|
|
|
|
|
|
|
// Generate event id
|
|
|
|
|
let event_id = gen_event_id(&join_event_stub, &room_version_rules)?;
|
|
|
|
|
|
|
|
|
|
// Add event_id back
|
|
|
|
|
join_event_stub
|
|
|
|
|
.insert("event_id".to_owned(), CanonicalJsonValue::String(event_id.clone().into()));
|
|
|
|
|
|
|
|
|
|
// It has enough fields to be called a proper event now
|
|
|
|
|
let mut join_event = join_event_stub;
|
|
|
|
|
|
|
|
|
|
info!("Asking {remote_server} for send_join in room {room_id}");
|
|
|
|
|
let send_join_request = federation::membership::create_join_event::v2::Request::new(
|
|
|
|
|
room_id.to_owned(),
|
|
|
|
|
event_id.clone(),
|
|
|
|
|
services
|
|
|
|
|
.sending
|
|
|
|
|
.convert_to_outgoing_federation_event(join_event.clone())
|
|
|
|
|
.await,
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let send_join_response = match services
|
|
|
|
|
.sending
|
|
|
|
|
.send_synapse_request(&remote_server, send_join_request)
|
|
|
|
|
.await
|
|
|
|
|
{
|
|
|
|
|
| Ok(response) => response,
|
|
|
|
|
| Err(e) => {
|
|
|
|
|
error!("send_join failed: {e}");
|
|
|
|
|
return Err(e);
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
info!("send_join finished");
|
|
|
|
|
|
|
|
|
|
if join_authorized_via_users_server.is_some() {
|
|
|
|
|
if let Some(signed_raw) = &send_join_response.room_state.event {
|
|
|
|
|
debug_info!(
|
|
|
|
|
"There is a signed event with join_authorized_via_users_server. This room is \
|
|
|
|
|
probably using restricted joins. Adding signature to our event"
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let (signed_event_id, signed_value) =
|
|
|
|
|
gen_event_id_canonical_json(signed_raw, &room_version_rules).map_err(|e| {
|
|
|
|
|
err!(Request(BadJson(warn!(
|
|
|
|
|
"Could not convert event to canonical JSON: {e}"
|
|
|
|
|
))))
|
|
|
|
|
})?;
|
|
|
|
|
|
|
|
|
|
if signed_event_id != event_id {
|
|
|
|
|
return Err!(Request(BadJson(warn!(
|
|
|
|
|
%signed_event_id, %event_id,
|
|
|
|
|
"Server {remote_server} sent event with wrong event ID"
|
|
|
|
|
))));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
match signed_value["signatures"]
|
|
|
|
|
.as_object()
|
|
|
|
|
.ok_or_else(|| {
|
|
|
|
|
err!(BadServerResponse(warn!(
|
|
|
|
|
"Server {remote_server} sent invalid signatures type"
|
|
|
|
|
)))
|
|
|
|
|
})
|
|
|
|
|
.and_then(|e| {
|
|
|
|
|
e.get(remote_server.as_str()).ok_or_else(|| {
|
|
|
|
|
err!(BadServerResponse(warn!(
|
|
|
|
|
"Server {remote_server} did not send its signature for a restricted \
|
|
|
|
|
room"
|
|
|
|
|
)))
|
|
|
|
|
})
|
|
|
|
|
}) {
|
|
|
|
|
| Ok(signature) => {
|
|
|
|
|
join_event
|
|
|
|
|
.get_mut("signatures")
|
|
|
|
|
.expect("we created a valid pdu")
|
|
|
|
|
.as_object_mut()
|
|
|
|
|
.expect("we created a valid pdu")
|
|
|
|
|
.insert(remote_server.to_string(), signature.clone());
|
|
|
|
|
},
|
|
|
|
|
| Err(e) => {
|
|
|
|
|
warn!(
|
|
|
|
|
"Server {remote_server} sent invalid signature in send_join signatures \
|
|
|
|
|
for event {signed_value:?}: {e:?}",
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.short
|
|
|
|
|
.get_or_create_shortroomid(room_id)
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
info!("Parsing join event");
|
|
|
|
|
let parsed_join_pdu = PduEvent::from_id_val(&event_id, join_event.clone())
|
|
|
|
|
.map_err(|e| err!(BadServerResponse("Invalid join event PDU: {e:?}")))?;
|
|
|
|
|
|
|
|
|
|
info!("Acquiring server signing keys for response events");
|
|
|
|
|
let resp_events = &send_join_response.room_state;
|
|
|
|
|
let resp_state = &resp_events.state;
|
|
|
|
|
let resp_auth = &resp_events.auth_chain;
|
|
|
|
|
services
|
|
|
|
|
.server_keys
|
|
|
|
|
.acquire_events_pubkeys(resp_auth.iter().chain(resp_state.iter()))
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
info!("Going through send_join response room_state");
|
|
|
|
|
let cork = services.db.cork_and_flush();
|
|
|
|
|
let state = send_join_response
|
|
|
|
|
.room_state
|
|
|
|
|
.state
|
|
|
|
|
.iter()
|
|
|
|
|
.stream()
|
|
|
|
|
.then(|pdu| {
|
|
|
|
|
services
|
|
|
|
|
.server_keys
|
|
|
|
|
.validate_and_add_event_id_no_fetch(pdu, &room_version_rules)
|
|
|
|
|
.inspect_err(|e| {
|
|
|
|
|
debug_warn!("Could not validate send_join response room_state event: {e:?}");
|
|
|
|
|
})
|
|
|
|
|
.inspect(|_| debug!("Completed validating send_join response room_state event"))
|
|
|
|
|
})
|
|
|
|
|
.ready_filter_map(Result::ok)
|
|
|
|
|
.fold(HashMap::new(), |mut state, (event_id, value)| async move {
|
|
|
|
|
let pdu = match PduEvent::from_id_val(&event_id, value.clone()) {
|
|
|
|
|
| Ok(pdu) => pdu,
|
|
|
|
|
| Err(e) => {
|
|
|
|
|
debug_warn!("Invalid PDU in send_join response: {e:?}: {value:#?}");
|
|
|
|
|
return state;
|
|
|
|
|
},
|
|
|
|
|
};
|
|
|
|
|
if !pdu_fits(&mut value.clone()) {
|
|
|
|
|
warn!(
|
|
|
|
|
"dropping incoming PDU {event_id} in room {room_id} from room join because \
|
|
|
|
|
it exceeds 65535 bytes or is otherwise too large."
|
|
|
|
|
);
|
|
|
|
|
return state;
|
|
|
|
|
}
|
|
|
|
|
services.rooms.outlier.add_pdu_outlier(&event_id, &value);
|
|
|
|
|
if let Some(state_key) = &pdu.state_key {
|
|
|
|
|
let shortstatekey = services
|
|
|
|
|
.rooms
|
|
|
|
|
.short
|
|
|
|
|
.get_or_create_shortstatekey(&pdu.kind.to_string().into(), state_key)
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
state.insert(shortstatekey, pdu.event_id.clone());
|
|
|
|
|
}
|
|
|
|
|
state
|
|
|
|
|
})
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
drop(cork);
|
|
|
|
|
|
|
|
|
|
info!("Going through send_join response auth_chain");
|
|
|
|
|
let cork = services.db.cork_and_flush();
|
|
|
|
|
send_join_response
|
|
|
|
|
.room_state
|
|
|
|
|
.auth_chain
|
|
|
|
|
.iter()
|
|
|
|
|
.stream()
|
|
|
|
|
.then(|pdu| {
|
|
|
|
|
services
|
|
|
|
|
.server_keys
|
|
|
|
|
.validate_and_add_event_id_no_fetch(pdu, &room_version_rules)
|
|
|
|
|
})
|
|
|
|
|
.ready_filter_map(Result::ok)
|
|
|
|
|
.ready_for_each(|(event_id, value)| {
|
|
|
|
|
trace!(%event_id, "Adding PDU as an outlier from send_join auth_chain");
|
|
|
|
|
services.rooms.outlier.add_pdu_outlier(&event_id, &value);
|
|
|
|
|
})
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
drop(cork);
|
|
|
|
|
|
|
|
|
|
debug!("Running send_join auth check");
|
|
|
|
|
let fetch_state = &state;
|
|
|
|
|
let state_fetch = |k: StateEventType, s: StateKey| async move {
|
|
|
|
|
let shortstatekey = services.rooms.short.get_shortstatekey(&k, &s).await.ok()?;
|
|
|
|
|
|
|
|
|
|
let event_id = fetch_state.get(&shortstatekey)?;
|
|
|
|
|
services.rooms.timeline.get_pdu(event_id).await.ok()
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
let auth_check = state_res::event_auth::auth_check(
|
|
|
|
|
&room_version.rules().unwrap(),
|
|
|
|
|
&parsed_join_pdu,
|
|
|
|
|
None, // TODO: third party invite
|
|
|
|
|
|k, s| state_fetch(k.clone(), s.into()),
|
|
|
|
|
&state_fetch(StateEventType::RoomCreate, "".into())
|
|
|
|
|
.await
|
|
|
|
|
.expect("create event is missing from send_join auth"),
|
|
|
|
|
)
|
|
|
|
|
.await
|
|
|
|
|
.map_err(|e| err!(Request(Forbidden(warn!("Auth check failed: {e:?}")))))?;
|
|
|
|
|
|
|
|
|
|
if !auth_check {
|
|
|
|
|
return Err!(Request(Forbidden("Auth check failed")));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
info!("Compressing state from send_join");
|
|
|
|
|
let compressed: CompressedState = services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_compressor
|
|
|
|
|
.compress_state_events(state.iter().map(|(ssk, eid)| (ssk, eid.borrow())))
|
|
|
|
|
.collect()
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
debug!("Saving compressed state");
|
|
|
|
|
let HashSetCompressStateEvent {
|
|
|
|
|
shortstatehash: statehash_before_join,
|
|
|
|
|
added,
|
|
|
|
|
removed,
|
|
|
|
|
} = services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_compressor
|
|
|
|
|
.save_state(room_id, Arc::new(compressed))
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
debug!("Forcing state for new room");
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.state
|
|
|
|
|
.force_state(room_id, statehash_before_join, added, removed, &state_lock)
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
debug!("Updating joined counts for new room");
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.state_cache
|
|
|
|
|
.update_joined_count(room_id)
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
// We append to state before appending the pdu, so we don't have a moment in
|
|
|
|
|
// time with the pdu without it's state. This is okay because append_pdu can't
|
|
|
|
|
// fail.
|
|
|
|
|
let statehash_after_join = services
|
|
|
|
|
.rooms
|
|
|
|
|
.state
|
|
|
|
|
.append_to_state(&parsed_join_pdu, room_id)
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
info!("Appending new room join event");
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.timeline
|
|
|
|
|
.append_pdu(
|
|
|
|
|
&parsed_join_pdu,
|
|
|
|
|
join_event,
|
|
|
|
|
once(parsed_join_pdu.event_id.borrow()),
|
|
|
|
|
&state_lock,
|
|
|
|
|
room_id,
|
|
|
|
|
)
|
|
|
|
|
.await?;
|
|
|
|
|
|
|
|
|
|
info!("Setting final room state for new room");
|
|
|
|
|
// We set the room state after inserting the pdu, so that we never have a moment
|
|
|
|
|
// in time where events in the current room state do not exist
|
|
|
|
|
services
|
|
|
|
|
.rooms
|
|
|
|
|
.state
|
|
|
|
|
.set_room_state(room_id, statehash_after_join, &state_lock);
|
|
|
|
|
|
|
|
|
|
Ok(())
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[tracing::instrument(skip_all, fields(%sender_user, %room_id), name = "join_local", level = "info")]
|
|
|
|
|
async fn join_room_by_id_helper_local(
|
|
|
|
|
services: &Services,
|
|
|
|
|
sender_user: &UserId,
|
|
|
|
|
room_id: &RoomId,
|
|
|
|
|
reason: Option<String>,
|
|
|
|
|
servers: &[OwnedServerName],
|
|
|
|
|
state_lock: RoomMutexGuard,
|
|
|
|
|
) -> Result {
|
|
|
|
|
info!("Joining room locally");
|
|
|
|
|
|
|
|
|
|
let (room_version, join_rules, is_invited) = join!(
|
|
|
|
|
services.rooms.state.get_room_version(room_id),
|
|
|
|
|
services.rooms.state_accessor.get_join_rules(room_id),
|
|
|
|
|
services.rooms.state_cache.is_invited(sender_user, room_id)
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let room_version = room_version?;
|
|
|
|
|
let mut auth_user: Option<OwnedUserId> = None;
|
|
|
|
|
if !is_invited && matches!(join_rules, JoinRule::Restricted(_) | JoinRule::KnockRestricted(_))
|
|
|
|
|
{
|
|
|
|
|
use RoomVersionId::*;
|
|
|
|
|
if !matches!(room_version, V1 | V2 | V3 | V4 | V5 | V6 | V7) {
|
|
|
|
|
// This is a restricted room, check if we can complete the join requirements
|
|
|
|
|
// locally.
|
|
|
|
|
let needs_auth_user =
|
|
|
|
|
user_can_perform_restricted_join(services, sender_user, room_id).await;
|
|
|
|
|
if needs_auth_user.is_ok_and(is_true!()) {
|
|
|
|
|
// If there was an error or the value is false, we'll try joining over
|
|
|
|
|
// federation. Since it's Ok(true), we can authorise this locally.
|
|
|
|
|
// If we can't select a local user, this will remain None, the join will fail,
|
|
|
|
|
// and we'll fall back to federation.
|
|
|
|
|
auth_user = select_authorising_user(services, room_id, sender_user, &state_lock)
|
|
|
|
|
.await
|
|
|
|
|
.ok();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let mut content = RoomMemberEventContent::new(MembershipState::Join);
|
|
|
|
|
content.displayname = services.users.displayname(sender_user).await.ok();
|
|
|
|
|
content.avatar_url = services.users.avatar_url(sender_user).await.ok();
|
|
|
|
|
content.blurhash = services.users.blurhash(sender_user).await.ok();
|
|
|
|
|
content.reason.clone_from(&reason);
|
|
|
|
|
content.join_authorized_via_users_server = auth_user;
|
|
|
|
|
|
|
|
|
|
// Try normal join first
|
|
|
|
|
let Err(error) = services
|
|
|
|
|
.rooms
|
|
|
|
|
.timeline
|
|
|
|
|
.build_and_append_pdu(
|
|
|
|
|
PartialPdu::state(sender_user.to_string(), &content),
|
|
|
|
|
sender_user,
|
|
|
|
|
Some(room_id),
|
|
|
|
|
&state_lock,
|
|
|
|
|
)
|
|
|
|
|
.await
|
|
|
|
|
else {
|
|
|
|
|
info!("Joined room locally");
|
|
|
|
|
return Ok(());
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
if servers.is_empty() || servers.len() == 1 && services.globals.server_is_ours(&servers[0]) {
|
|
|
|
|
if !services.rooms.metadata.exists(room_id).await {
|
|
|
|
|
return Err!(Request(
|
|
|
|
|
Unknown(
|
|
|
|
|
"Room was not found locally and no servers were found to help us discover it"
|
|
|
|
|
),
|
|
|
|
|
NOT_FOUND
|
|
|
|
|
));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return Err(error);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
info!(
|
|
|
|
|
?error,
|
|
|
|
|
remote_servers = %servers.len(),
|
|
|
|
|
"Could not join room locally, attempting remote join",
|
|
|
|
|
);
|
|
|
|
|
join_room_by_id_helper_remote(services, sender_user, room_id, reason, servers, state_lock)
|
|
|
|
|
.await
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
async fn make_join_request(
|
|
|
|
|
services: &Services,
|
|
|
|
|
sender_user: &UserId,
|
|
|
|
|
room_id: &RoomId,
|
|
|
|
|
servers: &[OwnedServerName],
|
|
|
|
|
) -> Result<(federation::membership::prepare_join_event::v1::Response, OwnedServerName)> {
|
|
|
|
|
let mut make_join_counter: usize = 1;
|
|
|
|
|
|
|
|
|
|
for remote_server in servers {
|
|
|
|
|
if services.globals.server_is_ours(remote_server) {
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
info!(
|
|
|
|
|
"Asking {remote_server} for make_join (attempt {make_join_counter}/{})",
|
|
|
|
|
servers.len()
|
|
|
|
|
);
|
|
|
|
|
|
|
|
|
|
let mut request = federation::membership::prepare_join_event::v1::Request::new(
|
|
|
|
|
room_id.to_owned(),
|
|
|
|
|
sender_user.to_owned(),
|
|
|
|
|
);
|
|
|
|
|
request.ver = services.server.supported_room_versions().collect();
|
|
|
|
|
|
|
|
|
|
let make_join_response = services
|
|
|
|
|
.sending
|
|
|
|
|
.send_federation_request(remote_server, request)
|
|
|
|
|
.await;
|
|
|
|
|
|
|
|
|
|
trace!("make_join response: {:?}", make_join_response);
|
|
|
|
|
make_join_counter = make_join_counter.saturating_add(1);
|
|
|
|
|
|
|
|
|
|
match make_join_response {
|
|
|
|
|
| Ok(response) => {
|
|
|
|
|
info!("Received make_join response from {remote_server}");
|
|
|
|
|
if let Err(e) = validate_remote_member_event_stub(
|
|
|
|
|
&MembershipState::Join,
|
|
|
|
|
sender_user,
|
|
|
|
|
room_id,
|
|
|
|
|
&to_canonical_object(&response.event)?,
|
|
|
|
|
) {
|
|
|
|
|
warn!("make_join response from {remote_server} failed validation: {e}");
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
return Ok((response, remote_server.clone()));
|
|
|
|
|
},
|
|
|
|
|
| Err(e) => match e.kind() {
|
|
|
|
|
| ErrorKind::UnableToAuthorizeJoin => {
|
|
|
|
|
info!(
|
|
|
|
|
"{remote_server} was unable to verify the joining user satisfied \
|
|
|
|
|
restricted join requirements: {e}. Will continue trying."
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
| ErrorKind::UnableToGrantJoin => {
|
|
|
|
|
info!(
|
|
|
|
|
"{remote_server} believes the joining user satisfies restricted join \
|
|
|
|
|
rules, but is unable to authorise a join for us. Will continue trying."
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
| ErrorKind::IncompatibleRoomVersion(IncompatibleRoomVersionErrorData {
|
|
|
|
|
room_version,
|
|
|
|
|
..
|
|
|
|
|
}) => {
|
|
|
|
|
warn!(
|
|
|
|
|
"{remote_server} reports the room we are trying to join is \
|
|
|
|
|
v{room_version}, which we do not support."
|
|
|
|
|
);
|
|
|
|
|
return Err(e);
|
|
|
|
|
},
|
|
|
|
|
| ErrorKind::Forbidden => {
|
|
|
|
|
warn!("{remote_server} refuses to let us join: {e}.");
|
|
|
|
|
return Err(e);
|
|
|
|
|
},
|
|
|
|
|
| ErrorKind::NotFound => {
|
|
|
|
|
info!(
|
|
|
|
|
"{remote_server} does not know about {room_id}: {e}. Will continue \
|
|
|
|
|
trying."
|
|
|
|
|
);
|
|
|
|
|
},
|
|
|
|
|
| _ => {
|
|
|
|
|
info!("{remote_server} failed to make_join: {e}. Will continue trying.");
|
|
|
|
|
},
|
|
|
|
|
},
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
info!("All {} servers were unable to assist in joining {room_id} :(", servers.len());
|
|
|
|
|
Err!(BadServerResponse("No server available to assist in joining."))
|
|
|
|
|
Ok(join_room_by_id_or_alias::v3::Response::new(room_id))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Moves deprioritized servers (if any) to the back of the list.
|
|
|
|
|
Ginger