2020-09-13 20:24:36 +00:00
|
|
|
use crate::{client_server, ConduitResult, Database, Error, PduEvent, Result, Ruma};
|
2020-10-05 20:19:22 +00:00
|
|
|
use get_profile_information::v1::ProfileField;
|
2020-09-23 10:03:08 +00:00
|
|
|
use http::header::{HeaderValue, AUTHORIZATION, HOST};
|
2020-09-15 06:16:20 +00:00
|
|
|
use log::warn;
|
2020-08-14 09:29:32 +00:00
|
|
|
use rocket::{get, post, put, response::content::Json, State};
|
2020-09-12 20:41:33 +00:00
|
|
|
use ruma::{
|
|
|
|
api::{
|
|
|
|
federation::{
|
2020-09-25 10:26:29 +00:00
|
|
|
directory::{get_public_rooms, get_public_rooms_filtered},
|
2020-09-12 20:41:33 +00:00
|
|
|
discovery::{
|
|
|
|
get_server_keys, get_server_version::v1 as get_server_version, ServerKey, VerifyKey,
|
|
|
|
},
|
2020-09-25 10:26:29 +00:00
|
|
|
event::get_missing_events,
|
2020-10-05 20:19:22 +00:00
|
|
|
query::get_profile_information,
|
2020-09-12 20:41:33 +00:00
|
|
|
transactions::send_transaction_message,
|
2020-08-06 12:29:59 +00:00
|
|
|
},
|
2020-09-12 20:41:33 +00:00
|
|
|
OutgoingRequest,
|
2020-08-14 09:29:32 +00:00
|
|
|
},
|
2020-09-14 09:42:16 +00:00
|
|
|
directory::{IncomingFilter, IncomingRoomNetwork},
|
2020-09-14 09:00:31 +00:00
|
|
|
EventId, ServerName,
|
2020-05-26 08:27:51 +00:00
|
|
|
};
|
2020-04-22 18:55:11 +00:00
|
|
|
use std::{
|
2020-04-25 09:47:32 +00:00
|
|
|
collections::BTreeMap,
|
|
|
|
convert::TryFrom,
|
2020-08-14 09:31:31 +00:00
|
|
|
fmt::Debug,
|
2020-04-22 18:55:11 +00:00
|
|
|
time::{Duration, SystemTime},
|
|
|
|
};
|
2020-09-23 10:03:08 +00:00
|
|
|
use trust_dns_resolver::AsyncResolver;
|
2020-04-19 12:14:47 +00:00
|
|
|
|
2020-09-15 06:16:20 +00:00
|
|
|
pub async fn request_well_known(
|
|
|
|
globals: &crate::database::globals::Globals,
|
|
|
|
destination: &str,
|
|
|
|
) -> Option<String> {
|
2020-04-29 10:18:45 +00:00
|
|
|
let body: serde_json::Value = serde_json::from_str(
|
2020-09-14 18:23:19 +00:00
|
|
|
&globals
|
2020-04-29 10:18:45 +00:00
|
|
|
.reqwest_client()
|
|
|
|
.get(&format!(
|
|
|
|
"https://{}/.well-known/matrix/server",
|
|
|
|
destination
|
|
|
|
))
|
|
|
|
.send()
|
|
|
|
.await
|
|
|
|
.ok()?
|
|
|
|
.text()
|
|
|
|
.await
|
|
|
|
.ok()?,
|
|
|
|
)
|
|
|
|
.ok()?;
|
2020-04-26 20:39:15 +00:00
|
|
|
Some(body.get("m.server")?.as_str()?.to_owned())
|
|
|
|
}
|
|
|
|
|
2020-08-14 09:31:31 +00:00
|
|
|
pub async fn send_request<T: OutgoingRequest>(
|
2020-09-14 18:23:19 +00:00
|
|
|
globals: &crate::database::globals::Globals,
|
2020-09-15 06:16:20 +00:00
|
|
|
destination: Box<ServerName>,
|
2020-04-19 12:14:47 +00:00
|
|
|
request: T,
|
2020-08-14 09:31:31 +00:00
|
|
|
) -> Result<T::IncomingResponse>
|
|
|
|
where
|
|
|
|
T: Debug,
|
|
|
|
{
|
2020-10-06 19:04:51 +00:00
|
|
|
if !globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-11-15 11:17:21 +00:00
|
|
|
let resolver = AsyncResolver::tokio_from_system_conf().await.map_err(|_| {
|
|
|
|
Error::bad_config("Failed to set up trust dns resolver with system config.")
|
|
|
|
})?;
|
2020-09-23 10:03:08 +00:00
|
|
|
|
|
|
|
let mut host = None;
|
|
|
|
|
2020-04-29 10:18:45 +00:00
|
|
|
let actual_destination = "https://".to_owned()
|
2020-09-23 10:03:08 +00:00
|
|
|
+ &if let Some(mut delegated_hostname) =
|
|
|
|
request_well_known(globals, &destination.as_str()).await
|
|
|
|
{
|
|
|
|
if let Ok(Some(srv)) = resolver
|
|
|
|
.srv_lookup(format!("_matrix._tcp.{}", delegated_hostname))
|
|
|
|
.await
|
|
|
|
.map(|srv| srv.iter().next().map(|result| result.target().to_string()))
|
|
|
|
{
|
|
|
|
host = Some(delegated_hostname);
|
|
|
|
srv.trim_end_matches('.').to_owned()
|
|
|
|
} else {
|
|
|
|
if delegated_hostname.find(':').is_none() {
|
|
|
|
delegated_hostname += ":8448";
|
2020-09-15 19:46:10 +00:00
|
|
|
}
|
2020-09-23 10:03:08 +00:00
|
|
|
delegated_hostname
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
let mut destination = destination.as_str().to_owned();
|
|
|
|
if destination.find(':').is_none() {
|
|
|
|
destination += ":8448";
|
|
|
|
}
|
|
|
|
destination
|
|
|
|
};
|
2020-08-14 09:31:31 +00:00
|
|
|
|
|
|
|
let mut http_request = request
|
|
|
|
.try_into_http_request(&actual_destination, Some(""))
|
2020-09-15 06:55:02 +00:00
|
|
|
.map_err(|e| {
|
|
|
|
warn!("{}: {}", actual_destination, e);
|
|
|
|
Error::BadServerResponse("Invalid destination")
|
|
|
|
})?;
|
2020-04-22 09:53:06 +00:00
|
|
|
|
2020-04-22 19:14:40 +00:00
|
|
|
let mut request_map = serde_json::Map::new();
|
2020-04-19 12:14:47 +00:00
|
|
|
|
2020-04-22 19:14:40 +00:00
|
|
|
if !http_request.body().is_empty() {
|
2020-04-25 09:47:32 +00:00
|
|
|
request_map.insert(
|
|
|
|
"content".to_owned(),
|
2020-09-15 06:55:02 +00:00
|
|
|
serde_json::from_slice(http_request.body())
|
|
|
|
.expect("body is valid json, we just created it"),
|
2020-04-25 09:47:32 +00:00
|
|
|
);
|
2020-04-22 19:14:40 +00:00
|
|
|
};
|
2020-04-19 12:14:47 +00:00
|
|
|
|
2020-04-22 09:53:06 +00:00
|
|
|
request_map.insert("method".to_owned(), T::METADATA.method.to_string().into());
|
2020-08-14 09:31:31 +00:00
|
|
|
request_map.insert(
|
|
|
|
"uri".to_owned(),
|
|
|
|
http_request
|
|
|
|
.uri()
|
|
|
|
.path_and_query()
|
|
|
|
.expect("all requests have a path")
|
|
|
|
.to_string()
|
|
|
|
.into(),
|
|
|
|
);
|
2020-09-15 06:16:20 +00:00
|
|
|
request_map.insert("origin".to_owned(), globals.server_name().as_str().into());
|
2020-09-14 09:00:31 +00:00
|
|
|
request_map.insert("destination".to_owned(), destination.as_str().into());
|
2020-04-22 19:14:40 +00:00
|
|
|
|
|
|
|
let mut request_json = request_map.into();
|
2020-06-05 16:19:26 +00:00
|
|
|
ruma::signatures::sign_json(
|
2020-09-14 18:23:19 +00:00
|
|
|
globals.server_name().as_str(),
|
|
|
|
globals.keypair(),
|
2020-05-09 19:47:09 +00:00
|
|
|
&mut request_json,
|
|
|
|
)
|
2020-09-15 06:55:02 +00:00
|
|
|
.expect("our request json is what ruma expects");
|
2020-04-19 12:14:47 +00:00
|
|
|
|
2020-04-22 09:53:06 +00:00
|
|
|
let signatures = request_json["signatures"]
|
|
|
|
.as_object()
|
|
|
|
.unwrap()
|
|
|
|
.values()
|
2020-08-14 09:31:31 +00:00
|
|
|
.map(|v| {
|
|
|
|
v.as_object()
|
|
|
|
.unwrap()
|
|
|
|
.iter()
|
|
|
|
.map(|(k, v)| (k, v.as_str().unwrap()))
|
|
|
|
});
|
|
|
|
|
|
|
|
for signature_server in signatures {
|
|
|
|
for s in signature_server {
|
|
|
|
http_request.headers_mut().insert(
|
|
|
|
AUTHORIZATION,
|
|
|
|
HeaderValue::from_str(&format!(
|
|
|
|
"X-Matrix origin={},key=\"{}\",sig=\"{}\"",
|
2020-09-14 18:23:19 +00:00
|
|
|
globals.server_name(),
|
2020-08-14 09:31:31 +00:00
|
|
|
s.0,
|
|
|
|
s.1
|
|
|
|
))
|
|
|
|
.unwrap(),
|
|
|
|
);
|
|
|
|
}
|
2020-04-22 09:53:06 +00:00
|
|
|
}
|
|
|
|
|
2020-09-23 10:03:08 +00:00
|
|
|
if let Some(host) = host {
|
|
|
|
http_request
|
|
|
|
.headers_mut()
|
|
|
|
.insert(HOST, HeaderValue::from_str(&host).unwrap());
|
|
|
|
}
|
|
|
|
|
|
|
|
let mut reqwest_request = reqwest::Request::try_from(http_request)
|
2020-08-14 09:31:31 +00:00
|
|
|
.expect("all http requests are valid reqwest requests");
|
|
|
|
|
2020-09-23 10:03:08 +00:00
|
|
|
*reqwest_request.timeout_mut() = Some(Duration::from_secs(30));
|
|
|
|
|
2020-09-23 13:23:29 +00:00
|
|
|
let url = reqwest_request.url().clone();
|
2020-09-14 18:23:19 +00:00
|
|
|
let reqwest_response = globals.reqwest_client().execute(reqwest_request).await;
|
2020-04-22 09:53:06 +00:00
|
|
|
|
|
|
|
// Because reqwest::Response -> http::Response is complicated:
|
|
|
|
match reqwest_response {
|
|
|
|
Ok(mut reqwest_response) => {
|
|
|
|
let status = reqwest_response.status();
|
|
|
|
let mut http_response = http::Response::builder().status(status);
|
|
|
|
let headers = http_response.headers_mut().unwrap();
|
|
|
|
|
|
|
|
for (k, v) in reqwest_response.headers_mut().drain() {
|
|
|
|
if let Some(key) = k {
|
|
|
|
headers.insert(key, v);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
let body = reqwest_response
|
|
|
|
.bytes()
|
|
|
|
.await
|
2020-10-21 14:08:54 +00:00
|
|
|
.unwrap_or_else(|e| {
|
|
|
|
warn!("server error: {}", e);
|
|
|
|
Vec::new().into()
|
|
|
|
}) // TODO: handle timeout
|
2020-04-22 09:53:06 +00:00
|
|
|
.into_iter()
|
|
|
|
.collect();
|
2020-09-12 19:30:07 +00:00
|
|
|
|
2020-09-15 06:55:02 +00:00
|
|
|
let response = T::IncomingResponse::try_from(
|
|
|
|
http_response
|
|
|
|
.body(body)
|
|
|
|
.expect("reqwest body is valid http body"),
|
|
|
|
);
|
2020-09-15 06:16:20 +00:00
|
|
|
response.map_err(|e| {
|
2020-09-23 13:23:29 +00:00
|
|
|
warn!(
|
|
|
|
"Server returned bad response {} ({}): {:?}",
|
|
|
|
destination, url, e
|
|
|
|
);
|
2020-09-15 06:16:20 +00:00
|
|
|
Error::BadServerResponse("Server returned bad response.")
|
|
|
|
})
|
2020-04-22 09:53:06 +00:00
|
|
|
}
|
2020-08-14 09:31:31 +00:00
|
|
|
Err(e) => Err(e.into()),
|
2020-04-22 09:53:06 +00:00
|
|
|
}
|
2020-04-19 12:14:47 +00:00
|
|
|
}
|
2020-04-22 18:55:11 +00:00
|
|
|
|
2020-08-14 09:31:31 +00:00
|
|
|
#[cfg_attr(feature = "conduit_bin", get("/_matrix/federation/v1/version"))]
|
2020-10-06 19:04:51 +00:00
|
|
|
pub fn get_server_version(db: State<'_, Database>) -> ConduitResult<get_server_version::Response> {
|
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-08-14 09:31:31 +00:00
|
|
|
Ok(get_server_version::Response {
|
2020-04-28 18:03:14 +00:00
|
|
|
server: Some(get_server_version::Server {
|
2020-04-22 18:55:11 +00:00
|
|
|
name: Some("Conduit".to_owned()),
|
|
|
|
version: Some(env!("CARGO_PKG_VERSION").to_owned()),
|
2020-04-28 18:03:14 +00:00
|
|
|
}),
|
2020-08-14 09:31:31 +00:00
|
|
|
}
|
|
|
|
.into())
|
2020-04-22 18:55:11 +00:00
|
|
|
}
|
|
|
|
|
2020-08-14 09:31:31 +00:00
|
|
|
#[cfg_attr(feature = "conduit_bin", get("/_matrix/key/v2/server"))]
|
2020-05-03 15:25:31 +00:00
|
|
|
pub fn get_server_keys(db: State<'_, Database>) -> Json<String> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
|
|
|
// TODO: Use proper types
|
|
|
|
return Json("Federation is disabled.".to_owned());
|
|
|
|
}
|
|
|
|
|
2020-04-22 18:55:11 +00:00
|
|
|
let mut verify_keys = BTreeMap::new();
|
|
|
|
verify_keys.insert(
|
2020-05-03 15:25:31 +00:00
|
|
|
format!("ed25519:{}", db.globals.keypair().version()),
|
2020-08-14 09:31:31 +00:00
|
|
|
VerifyKey {
|
2020-05-03 15:25:31 +00:00
|
|
|
key: base64::encode_config(db.globals.keypair().public_key(), base64::STANDARD_NO_PAD),
|
2020-04-22 18:55:11 +00:00
|
|
|
},
|
|
|
|
);
|
|
|
|
let mut response = serde_json::from_slice(
|
2020-08-14 09:31:31 +00:00
|
|
|
http::Response::try_from(get_server_keys::v2::Response {
|
|
|
|
server_key: ServerKey {
|
|
|
|
server_name: db.globals.server_name().to_owned(),
|
|
|
|
verify_keys,
|
|
|
|
old_verify_keys: BTreeMap::new(),
|
|
|
|
signatures: BTreeMap::new(),
|
|
|
|
valid_until_ts: SystemTime::now() + Duration::from_secs(60 * 2),
|
|
|
|
},
|
2020-04-22 18:55:11 +00:00
|
|
|
})
|
|
|
|
.unwrap()
|
|
|
|
.body(),
|
|
|
|
)
|
|
|
|
.unwrap();
|
2020-06-05 16:19:26 +00:00
|
|
|
ruma::signatures::sign_json(
|
2020-08-14 09:31:31 +00:00
|
|
|
db.globals.server_name().as_str(),
|
2020-05-17 17:56:40 +00:00
|
|
|
db.globals.keypair(),
|
|
|
|
&mut response,
|
|
|
|
)
|
|
|
|
.unwrap();
|
2020-04-25 09:47:32 +00:00
|
|
|
Json(response.to_string())
|
2020-04-22 18:55:11 +00:00
|
|
|
}
|
|
|
|
|
2020-08-14 09:31:31 +00:00
|
|
|
#[cfg_attr(feature = "conduit_bin", get("/_matrix/key/v2/server/<_>"))]
|
|
|
|
pub fn get_server_keys_deprecated(db: State<'_, Database>) -> Json<String> {
|
2020-05-03 15:25:31 +00:00
|
|
|
get_server_keys(db)
|
2020-04-22 18:55:11 +00:00
|
|
|
}
|
2020-08-14 09:29:32 +00:00
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "conduit_bin",
|
|
|
|
post("/_matrix/federation/v1/publicRooms", data = "<body>")
|
|
|
|
)]
|
2020-09-14 09:42:16 +00:00
|
|
|
pub async fn get_public_rooms_filtered_route(
|
|
|
|
db: State<'_, Database>,
|
|
|
|
body: Ruma<get_public_rooms_filtered::v1::Request<'_>>,
|
|
|
|
) -> ConduitResult<get_public_rooms_filtered::v1::Response> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-09-14 09:42:16 +00:00
|
|
|
let response = client_server::get_public_rooms_filtered_helper(
|
|
|
|
&db,
|
|
|
|
None,
|
|
|
|
body.limit,
|
|
|
|
body.since.as_deref(),
|
|
|
|
&body.filter,
|
|
|
|
&body.room_network,
|
|
|
|
)
|
|
|
|
.await?
|
|
|
|
.0;
|
|
|
|
|
|
|
|
Ok(get_public_rooms_filtered::v1::Response {
|
|
|
|
chunk: response
|
|
|
|
.chunk
|
|
|
|
.into_iter()
|
|
|
|
.map(|c| {
|
|
|
|
// Convert ruma::api::federation::directory::get_public_rooms::v1::PublicRoomsChunk
|
|
|
|
// to ruma::api::client::r0::directory::PublicRoomsChunk
|
|
|
|
Ok::<_, Error>(
|
|
|
|
serde_json::from_str(
|
|
|
|
&serde_json::to_string(&c)
|
|
|
|
.expect("PublicRoomsChunk::to_string always works"),
|
|
|
|
)
|
|
|
|
.expect("federation and client-server PublicRoomsChunk are the same type"),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.filter_map(|r| r.ok())
|
|
|
|
.collect(),
|
|
|
|
prev_batch: response.prev_batch,
|
|
|
|
next_batch: response.next_batch,
|
|
|
|
total_room_count_estimate: response.total_room_count_estimate,
|
|
|
|
}
|
|
|
|
.into())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "conduit_bin",
|
|
|
|
get("/_matrix/federation/v1/publicRooms", data = "<body>")
|
|
|
|
)]
|
2020-08-14 09:29:32 +00:00
|
|
|
pub async fn get_public_rooms_route(
|
|
|
|
db: State<'_, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<get_public_rooms::v1::Request<'_>>,
|
2020-08-14 09:29:32 +00:00
|
|
|
) -> ConduitResult<get_public_rooms::v1::Response> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-09-14 09:42:16 +00:00
|
|
|
let response = client_server::get_public_rooms_filtered_helper(
|
2020-08-23 12:32:43 +00:00
|
|
|
&db,
|
|
|
|
None,
|
2020-09-14 09:42:16 +00:00
|
|
|
body.limit,
|
|
|
|
body.since.as_deref(),
|
|
|
|
&IncomingFilter::default(),
|
|
|
|
&IncomingRoomNetwork::Matrix,
|
2020-08-14 09:29:32 +00:00
|
|
|
)
|
|
|
|
.await?
|
|
|
|
.0;
|
|
|
|
|
|
|
|
Ok(get_public_rooms::v1::Response {
|
2020-09-14 09:42:16 +00:00
|
|
|
chunk: response
|
|
|
|
.chunk
|
2020-08-14 09:29:32 +00:00
|
|
|
.into_iter()
|
|
|
|
.map(|c| {
|
|
|
|
// Convert ruma::api::federation::directory::get_public_rooms::v1::PublicRoomsChunk
|
|
|
|
// to ruma::api::client::r0::directory::PublicRoomsChunk
|
|
|
|
Ok::<_, Error>(
|
|
|
|
serde_json::from_str(
|
|
|
|
&serde_json::to_string(&c)
|
|
|
|
.expect("PublicRoomsChunk::to_string always works"),
|
|
|
|
)
|
|
|
|
.expect("federation and client-server PublicRoomsChunk are the same type"),
|
|
|
|
)
|
|
|
|
})
|
|
|
|
.filter_map(|r| r.ok())
|
|
|
|
.collect(),
|
2020-09-14 09:42:16 +00:00
|
|
|
prev_batch: response.prev_batch,
|
|
|
|
next_batch: response.next_batch,
|
|
|
|
total_room_count_estimate: response.total_room_count_estimate,
|
2020-08-14 09:29:32 +00:00
|
|
|
}
|
|
|
|
.into())
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "conduit_bin",
|
|
|
|
put("/_matrix/federation/v1/send/<_>", data = "<body>")
|
|
|
|
)]
|
2020-08-06 12:29:59 +00:00
|
|
|
pub fn send_transaction_message_route<'a>(
|
2020-09-12 20:41:33 +00:00
|
|
|
db: State<'a, Database>,
|
2020-09-08 15:32:03 +00:00
|
|
|
body: Ruma<send_transaction_message::v1::Request<'_>>,
|
2020-08-14 09:29:32 +00:00
|
|
|
) -> ConduitResult<send_transaction_message::v1::Response> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-09-13 20:24:36 +00:00
|
|
|
//dbg!(&*body);
|
2020-09-12 20:41:33 +00:00
|
|
|
for pdu in &body.pdus {
|
2020-09-13 20:24:36 +00:00
|
|
|
let mut value = serde_json::from_str(pdu.json().get())
|
|
|
|
.expect("converting raw jsons to values always works");
|
|
|
|
|
2020-09-12 20:41:33 +00:00
|
|
|
let event_id = EventId::try_from(&*format!(
|
|
|
|
"${}",
|
|
|
|
ruma::signatures::reference_hash(&value).expect("ruma can calculate reference hashes")
|
|
|
|
))
|
|
|
|
.expect("ruma's reference hashes are valid event ids");
|
|
|
|
|
|
|
|
value
|
|
|
|
.as_object_mut()
|
|
|
|
.expect("ruma pdus are json objects")
|
|
|
|
.insert("event_id".to_owned(), event_id.to_string().into());
|
|
|
|
|
2020-09-15 06:16:20 +00:00
|
|
|
let pdu = serde_json::from_value::<PduEvent>(value.clone())
|
|
|
|
.expect("all ruma pdus are conduit pdus");
|
2020-09-13 20:24:36 +00:00
|
|
|
if db.rooms.exists(&pdu.room_id)? {
|
2020-10-18 06:56:21 +00:00
|
|
|
let count = db.globals.next_count()?;
|
|
|
|
let mut pdu_id = pdu.room_id.as_bytes().to_vec();
|
|
|
|
pdu_id.push(0xff);
|
|
|
|
pdu_id.extend_from_slice(&count.to_be_bytes());
|
2020-10-19 13:29:36 +00:00
|
|
|
db.rooms.append_to_state(&pdu_id, &pdu)?;
|
2020-10-18 06:56:21 +00:00
|
|
|
db.rooms.append_pdu(
|
|
|
|
&pdu,
|
|
|
|
&value,
|
|
|
|
count,
|
|
|
|
pdu_id.clone().into(),
|
|
|
|
&db.globals,
|
|
|
|
&db.account_data,
|
2020-11-09 11:21:04 +00:00
|
|
|
&db.admin,
|
2020-10-18 06:56:21 +00:00
|
|
|
)?;
|
2020-09-13 20:24:36 +00:00
|
|
|
}
|
2020-09-12 20:41:33 +00:00
|
|
|
}
|
2020-08-14 09:29:32 +00:00
|
|
|
Ok(send_transaction_message::v1::Response {
|
|
|
|
pdus: BTreeMap::new(),
|
|
|
|
}
|
|
|
|
.into())
|
|
|
|
}
|
2020-09-25 10:26:29 +00:00
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "conduit_bin",
|
|
|
|
post("/_matrix/federation/v1/get_missing_events/<_>", data = "<body>")
|
|
|
|
)]
|
|
|
|
pub fn get_missing_events_route<'a>(
|
|
|
|
db: State<'a, Database>,
|
|
|
|
body: Ruma<get_missing_events::v1::Request<'_>>,
|
|
|
|
) -> ConduitResult<get_missing_events::v1::Response> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-09-25 10:26:29 +00:00
|
|
|
let mut queued_events = body.latest_events.clone();
|
|
|
|
let mut events = Vec::new();
|
|
|
|
|
|
|
|
let mut i = 0;
|
|
|
|
while i < queued_events.len() && events.len() < u64::from(body.limit) as usize {
|
|
|
|
if let Some(pdu) = db.rooms.get_pdu_json(&queued_events[i])? {
|
|
|
|
if body.earliest_events.contains(
|
|
|
|
&serde_json::from_value(
|
|
|
|
pdu.get("event_id")
|
|
|
|
.cloned()
|
|
|
|
.ok_or_else(|| Error::bad_database("Event in db has no event_id field."))?,
|
|
|
|
)
|
|
|
|
.map_err(|_| Error::bad_database("Invalid event_id field in pdu in db."))?,
|
|
|
|
) {
|
|
|
|
i += 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
queued_events.extend_from_slice(
|
|
|
|
&serde_json::from_value::<Vec<EventId>>(
|
|
|
|
pdu.get("prev_events").cloned().ok_or_else(|| {
|
|
|
|
Error::bad_database("Invalid prev_events field of pdu in db.")
|
|
|
|
})?,
|
|
|
|
)
|
|
|
|
.map_err(|_| Error::bad_database("Invalid prev_events content in pdu in db."))?,
|
|
|
|
);
|
2020-10-07 10:29:19 +00:00
|
|
|
events.push(PduEvent::convert_to_outgoing_federation_event(pdu));
|
2020-09-25 10:26:29 +00:00
|
|
|
}
|
|
|
|
i += 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(get_missing_events::v1::Response { events }.into())
|
|
|
|
}
|
2020-10-05 20:19:22 +00:00
|
|
|
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "conduit_bin",
|
|
|
|
get("/_matrix/federation/v1/query/profile", data = "<body>")
|
|
|
|
)]
|
|
|
|
pub fn get_profile_information_route<'a>(
|
|
|
|
db: State<'a, Database>,
|
|
|
|
body: Ruma<get_profile_information::v1::Request<'_>>,
|
|
|
|
) -> ConduitResult<get_profile_information::v1::Response> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
let mut displayname = None;
|
|
|
|
let mut avatar_url = None;
|
|
|
|
|
|
|
|
match body.field {
|
|
|
|
Some(ProfileField::DisplayName) => displayname = db.users.displayname(&body.user_id)?,
|
|
|
|
Some(ProfileField::AvatarUrl) => avatar_url = db.users.avatar_url(&body.user_id)?,
|
|
|
|
None => {
|
|
|
|
displayname = db.users.displayname(&body.user_id)?;
|
|
|
|
avatar_url = db.users.avatar_url(&body.user_id)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(get_profile_information::v1::Response {
|
|
|
|
displayname,
|
|
|
|
avatar_url,
|
|
|
|
}
|
|
|
|
.into())
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
#[cfg_attr(
|
|
|
|
feature = "conduit_bin",
|
|
|
|
get("/_matrix/federation/v2/invite/<_>/<_>", data = "<body>")
|
|
|
|
)]
|
|
|
|
pub fn get_user_devices_route<'a>(
|
|
|
|
db: State<'a, Database>,
|
|
|
|
body: Ruma<membership::v1::Request<'_>>,
|
|
|
|
) -> ConduitResult<get_profile_information::v1::Response> {
|
2020-10-06 19:04:51 +00:00
|
|
|
if !db.globals.federation_enabled() {
|
2020-11-14 22:13:06 +00:00
|
|
|
return Err(Error::bad_config("Federation is disabled."));
|
2020-10-06 19:04:51 +00:00
|
|
|
}
|
|
|
|
|
2020-10-05 20:19:22 +00:00
|
|
|
let mut displayname = None;
|
|
|
|
let mut avatar_url = None;
|
|
|
|
|
|
|
|
match body.field {
|
|
|
|
Some(ProfileField::DisplayName) => displayname = db.users.displayname(&body.user_id)?,
|
|
|
|
Some(ProfileField::AvatarUrl) => avatar_url = db.users.avatar_url(&body.user_id)?,
|
|
|
|
None => {
|
|
|
|
displayname = db.users.displayname(&body.user_id)?;
|
|
|
|
avatar_url = db.users.avatar_url(&body.user_id)?;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(get_profile_information::v1::Response {
|
|
|
|
displayname,
|
|
|
|
avatar_url,
|
|
|
|
}
|
|
|
|
.into())
|
|
|
|
}
|
|
|
|
*/
|