|
|
|
@ -1,6 +1,6 @@ |
|
|
|
use std::{ |
|
|
|
use std::{ |
|
|
|
collections::HashMap, |
|
|
|
collections::HashMap, |
|
|
|
convert::TryFrom, |
|
|
|
convert::{TryFrom, TryInto}, |
|
|
|
fmt::Debug, |
|
|
|
fmt::Debug, |
|
|
|
sync::Arc, |
|
|
|
sync::Arc, |
|
|
|
time::{Duration, Instant, SystemTime}, |
|
|
|
time::{Duration, Instant, SystemTime}, |
|
|
|
@ -14,9 +14,9 @@ use log::{error, info, warn}; |
|
|
|
use ring::digest; |
|
|
|
use ring::digest; |
|
|
|
use rocket::futures::stream::{FuturesUnordered, StreamExt}; |
|
|
|
use rocket::futures::stream::{FuturesUnordered, StreamExt}; |
|
|
|
use ruma::{ |
|
|
|
use ruma::{ |
|
|
|
api::{appservice, federation, OutgoingRequest}, |
|
|
|
api::{appservice, client::r0::push::Pusher, federation, OutgoingRequest}, |
|
|
|
events::{push_rules, EventType}, |
|
|
|
events::{push_rules, EventType}, |
|
|
|
uint, ServerName, UInt, |
|
|
|
uint, ServerName, UInt, UserId, |
|
|
|
}; |
|
|
|
}; |
|
|
|
use sled::IVec; |
|
|
|
use sled::IVec; |
|
|
|
use tokio::{select, sync::Semaphore}; |
|
|
|
use tokio::{select, sync::Semaphore}; |
|
|
|
@ -24,14 +24,14 @@ use tokio::{select, sync::Semaphore}; |
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)] |
|
|
|
#[derive(Clone, Debug, PartialEq, Eq, Hash)] |
|
|
|
pub enum OutgoingKind { |
|
|
|
pub enum OutgoingKind { |
|
|
|
Appservice(Box<ServerName>), |
|
|
|
Appservice(Box<ServerName>), |
|
|
|
Push(Vec<u8>), |
|
|
|
Push(Vec<u8>, Vec<u8>), // user and pushkey
|
|
|
|
Normal(Box<ServerName>), |
|
|
|
Normal(Box<ServerName>), |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#[derive(Clone)] |
|
|
|
#[derive(Clone)] |
|
|
|
pub struct Sending { |
|
|
|
pub struct Sending { |
|
|
|
/// The state for a given state hash.
|
|
|
|
/// The state for a given state hash.
|
|
|
|
pub(super) servernamepduids: sled::Tree, // ServernamePduId = (+ / $)ServerName / UserId + PduId
|
|
|
|
pub(super) servernamepduids: sled::Tree, // ServernamePduId = (+ / $)SenderKey / ServerName / UserId + PduId
|
|
|
|
pub(super) servercurrentpdus: sled::Tree, // ServerCurrentPdus = (+ / $)ServerName / UserId + PduId (pduid can be empty for reservation)
|
|
|
|
pub(super) servercurrentpdus: sled::Tree, // ServerCurrentPdus = (+ / $)ServerName / UserId + PduId (pduid can be empty for reservation)
|
|
|
|
pub(super) maximum_requests: Arc<Semaphore>, |
|
|
|
pub(super) maximum_requests: Arc<Semaphore>, |
|
|
|
} |
|
|
|
} |
|
|
|
@ -85,9 +85,11 @@ impl Sending { |
|
|
|
p.extend_from_slice(server.as_bytes()); |
|
|
|
p.extend_from_slice(server.as_bytes()); |
|
|
|
p |
|
|
|
p |
|
|
|
} |
|
|
|
} |
|
|
|
OutgoingKind::Push(id) => { |
|
|
|
OutgoingKind::Push(user, pushkey) => { |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
p.extend_from_slice(&id); |
|
|
|
p.extend_from_slice(&user); |
|
|
|
|
|
|
|
p.push(0xff); |
|
|
|
|
|
|
|
p.extend_from_slice(&pushkey); |
|
|
|
p |
|
|
|
p |
|
|
|
} |
|
|
|
} |
|
|
|
OutgoingKind::Normal(server) => { |
|
|
|
OutgoingKind::Normal(server) => { |
|
|
|
@ -106,6 +108,7 @@ impl Sending { |
|
|
|
|
|
|
|
|
|
|
|
let mut subscriber = servernamepduids.watch_prefix(b""); |
|
|
|
let mut subscriber = servernamepduids.watch_prefix(b""); |
|
|
|
loop { |
|
|
|
loop { |
|
|
|
|
|
|
|
println!("."); |
|
|
|
select! { |
|
|
|
select! { |
|
|
|
Some(response) = futures.next() => { |
|
|
|
Some(response) = futures.next() => { |
|
|
|
match response { |
|
|
|
match response { |
|
|
|
@ -116,9 +119,11 @@ impl Sending { |
|
|
|
p.extend_from_slice(server.as_bytes()); |
|
|
|
p.extend_from_slice(server.as_bytes()); |
|
|
|
p |
|
|
|
p |
|
|
|
} |
|
|
|
} |
|
|
|
OutgoingKind::Push(id) => { |
|
|
|
OutgoingKind::Push(user, pushkey) => { |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
p.extend_from_slice(&id); |
|
|
|
p.extend_from_slice(&user); |
|
|
|
|
|
|
|
p.push(0xff); |
|
|
|
|
|
|
|
p.extend_from_slice(&pushkey); |
|
|
|
p |
|
|
|
p |
|
|
|
}, |
|
|
|
}, |
|
|
|
OutgoingKind::Normal(server) => { |
|
|
|
OutgoingKind::Normal(server) => { |
|
|
|
@ -179,9 +184,11 @@ impl Sending { |
|
|
|
p.extend_from_slice(serv.as_bytes()); |
|
|
|
p.extend_from_slice(serv.as_bytes()); |
|
|
|
p |
|
|
|
p |
|
|
|
}, |
|
|
|
}, |
|
|
|
OutgoingKind::Push(id) => { |
|
|
|
OutgoingKind::Push(user, pushkey) => { |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
p.extend_from_slice(&id); |
|
|
|
p.extend_from_slice(&user); |
|
|
|
|
|
|
|
p.push(0xff); |
|
|
|
|
|
|
|
p.extend_from_slice(&pushkey); |
|
|
|
p |
|
|
|
p |
|
|
|
}, |
|
|
|
}, |
|
|
|
OutgoingKind::Normal(serv) => { |
|
|
|
OutgoingKind::Normal(serv) => { |
|
|
|
@ -208,7 +215,6 @@ impl Sending { |
|
|
|
Some(event) = &mut subscriber => { |
|
|
|
Some(event) = &mut subscriber => { |
|
|
|
if let sled::Event::Insert { key, .. } = event { |
|
|
|
if let sled::Event::Insert { key, .. } = event { |
|
|
|
let servernamepduid = key.clone(); |
|
|
|
let servernamepduid = key.clone(); |
|
|
|
let mut parts = servernamepduid.splitn(2, |&b| b == 0xff); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let exponential_backoff = |(tries, instant): &(u32, Instant)| { |
|
|
|
let exponential_backoff = |(tries, instant): &(u32, Instant)| { |
|
|
|
// Fail if a request has failed recently (exponential backoff)
|
|
|
|
// Fail if a request has failed recently (exponential backoff)
|
|
|
|
@ -219,33 +225,8 @@ impl Sending { |
|
|
|
|
|
|
|
|
|
|
|
instant.elapsed() < min_elapsed_duration |
|
|
|
instant.elapsed() < min_elapsed_duration |
|
|
|
}; |
|
|
|
}; |
|
|
|
if let Some((outgoing_kind, pdu_id)) = utils::string_from_bytes( |
|
|
|
|
|
|
|
parts |
|
|
|
if let Some((outgoing_kind, pdu_id)) = Self::parse_servercurrentpdus(&servernamepduid) |
|
|
|
.next() |
|
|
|
|
|
|
|
.expect("splitn will always return 1 or more elements"), |
|
|
|
|
|
|
|
) |
|
|
|
|
|
|
|
.map_err(|_| Error::bad_database("[Utf8] ServerName in servernamepduid bytes are invalid.")) |
|
|
|
|
|
|
|
.and_then(|ident_str| { |
|
|
|
|
|
|
|
// Appservices start with a plus
|
|
|
|
|
|
|
|
Ok(if ident_str.starts_with('+') { |
|
|
|
|
|
|
|
OutgoingKind::Appservice( |
|
|
|
|
|
|
|
Box::<ServerName>::try_from(&ident_str[1..]) |
|
|
|
|
|
|
|
.map_err(|_| Error::bad_database("ServerName in servernamepduid is invalid."))? |
|
|
|
|
|
|
|
) |
|
|
|
|
|
|
|
} else if ident_str.starts_with('$') { |
|
|
|
|
|
|
|
OutgoingKind::Push(ident_str[1..].as_bytes().to_vec()) |
|
|
|
|
|
|
|
} else { |
|
|
|
|
|
|
|
OutgoingKind::Normal( |
|
|
|
|
|
|
|
Box::<ServerName>::try_from(ident_str) |
|
|
|
|
|
|
|
.map_err(|_| Error::bad_database("ServerName in servernamepduid is invalid."))? |
|
|
|
|
|
|
|
) |
|
|
|
|
|
|
|
}) |
|
|
|
|
|
|
|
}) |
|
|
|
|
|
|
|
.and_then(|outgoing_kind| parts |
|
|
|
|
|
|
|
.next() |
|
|
|
|
|
|
|
.ok_or_else(|| Error::bad_database("Invalid servernamepduid in db.")) |
|
|
|
|
|
|
|
.map(|pdu_id| (outgoing_kind, pdu_id)) |
|
|
|
|
|
|
|
) |
|
|
|
|
|
|
|
.ok() |
|
|
|
.ok() |
|
|
|
.filter(|(outgoing_kind, _)| { |
|
|
|
.filter(|(outgoing_kind, _)| { |
|
|
|
if last_failed_try.get(outgoing_kind).map_or(false, exponential_backoff) { |
|
|
|
if last_failed_try.get(outgoing_kind).map_or(false, exponential_backoff) { |
|
|
|
@ -258,9 +239,11 @@ impl Sending { |
|
|
|
p.extend_from_slice(serv.as_bytes()); |
|
|
|
p.extend_from_slice(serv.as_bytes()); |
|
|
|
p |
|
|
|
p |
|
|
|
}, |
|
|
|
}, |
|
|
|
OutgoingKind::Push(id) => { |
|
|
|
OutgoingKind::Push(user, pushkey) => { |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
let mut p = b"$".to_vec(); |
|
|
|
p.extend_from_slice(&id); |
|
|
|
p.extend_from_slice(&user); |
|
|
|
|
|
|
|
p.push(0xff); |
|
|
|
|
|
|
|
p.extend_from_slice(&pushkey); |
|
|
|
p |
|
|
|
p |
|
|
|
}, |
|
|
|
}, |
|
|
|
OutgoingKind::Normal(serv) => { |
|
|
|
OutgoingKind::Normal(serv) => { |
|
|
|
@ -279,6 +262,8 @@ impl Sending { |
|
|
|
servercurrentpdus.insert(&key, &[]).unwrap(); |
|
|
|
servercurrentpdus.insert(&key, &[]).unwrap(); |
|
|
|
servernamepduids.remove(&key).unwrap(); |
|
|
|
servernamepduids.remove(&key).unwrap(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
dbg!("there is a future"); |
|
|
|
|
|
|
|
|
|
|
|
futures.push( |
|
|
|
futures.push( |
|
|
|
Self::handle_event( |
|
|
|
Self::handle_event( |
|
|
|
outgoing_kind, |
|
|
|
outgoing_kind, |
|
|
|
@ -295,15 +280,9 @@ impl Sending { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
#[tracing::instrument(skip(self))] |
|
|
|
#[tracing::instrument(skip(self))] |
|
|
|
pub fn send_push_pdu(&self, pdu_id: &[u8]) -> Result<()> { |
|
|
|
pub fn send_push_pdu(&self, pdu_id: &[u8], senderkey: IVec) -> Result<()> { |
|
|
|
// Make sure we don't cause utf8 errors when parsing to a String...
|
|
|
|
|
|
|
|
let pduid = String::from_utf8_lossy(pdu_id).as_bytes().to_vec(); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// these are valid ServerName chars
|
|
|
|
|
|
|
|
// (byte.is_ascii_alphanumeric() || byte == b'-' || byte == b'.')
|
|
|
|
|
|
|
|
let mut key = b"$".to_vec(); |
|
|
|
let mut key = b"$".to_vec(); |
|
|
|
// keep each pdu push unique
|
|
|
|
key.extend_from_slice(&senderkey); |
|
|
|
key.extend_from_slice(pduid.as_slice()); |
|
|
|
|
|
|
|
key.push(0xff); |
|
|
|
key.push(0xff); |
|
|
|
key.extend_from_slice(pdu_id); |
|
|
|
key.extend_from_slice(pdu_id); |
|
|
|
self.servernamepduids.insert(key, b"")?; |
|
|
|
self.servernamepduids.insert(key, b"")?; |
|
|
|
@ -313,6 +292,7 @@ impl Sending { |
|
|
|
|
|
|
|
|
|
|
|
#[tracing::instrument(skip(self))] |
|
|
|
#[tracing::instrument(skip(self))] |
|
|
|
pub fn send_pdu(&self, server: &ServerName, pdu_id: &[u8]) -> Result<()> { |
|
|
|
pub fn send_pdu(&self, server: &ServerName, pdu_id: &[u8]) -> Result<()> { |
|
|
|
|
|
|
|
dbg!(&server); |
|
|
|
let mut key = server.as_bytes().to_vec(); |
|
|
|
let mut key = server.as_bytes().to_vec(); |
|
|
|
key.push(0xff); |
|
|
|
key.push(0xff); |
|
|
|
key.extend_from_slice(pdu_id); |
|
|
|
key.extend_from_slice(pdu_id); |
|
|
|
@ -369,6 +349,8 @@ impl Sending { |
|
|
|
.filter_map(|r| r.ok()) |
|
|
|
.filter_map(|r| r.ok()) |
|
|
|
.collect::<Vec<_>>(); |
|
|
|
.collect::<Vec<_>>(); |
|
|
|
let permit = db.sending.maximum_requests.acquire().await; |
|
|
|
let permit = db.sending.maximum_requests.acquire().await; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
error!("sending pdus to {}: {:#?}", server, pdu_jsons); |
|
|
|
let response = appservice_server::send_request( |
|
|
|
let response = appservice_server::send_request( |
|
|
|
&db.globals, |
|
|
|
&db.globals, |
|
|
|
db.appservice |
|
|
|
db.appservice |
|
|
|
@ -391,17 +373,17 @@ impl Sending { |
|
|
|
|
|
|
|
|
|
|
|
response |
|
|
|
response |
|
|
|
} |
|
|
|
} |
|
|
|
OutgoingKind::Push(id) => { |
|
|
|
OutgoingKind::Push(user, pushkey) => { |
|
|
|
let pdus = pdu_ids |
|
|
|
let pdus = pdu_ids |
|
|
|
.iter() |
|
|
|
.iter() |
|
|
|
.map(|pdu_id| { |
|
|
|
.map(|pdu_id| { |
|
|
|
Ok::<_, (Vec<u8>, Error)>( |
|
|
|
Ok::<_, (Vec<u8>, Error)>( |
|
|
|
db.rooms |
|
|
|
db.rooms |
|
|
|
.get_pdu_from_id(pdu_id) |
|
|
|
.get_pdu_from_id(pdu_id) |
|
|
|
.map_err(|e| (id.clone(), e))? |
|
|
|
.map_err(|e| (pushkey.clone(), e))? |
|
|
|
.ok_or_else(|| { |
|
|
|
.ok_or_else(|| { |
|
|
|
( |
|
|
|
( |
|
|
|
id.clone(), |
|
|
|
pushkey.clone(), |
|
|
|
Error::bad_database( |
|
|
|
Error::bad_database( |
|
|
|
"[Push] Event in servernamepduids not found in db.", |
|
|
|
"[Push] Event in servernamepduids not found in db.", |
|
|
|
), |
|
|
|
), |
|
|
|
@ -418,35 +400,48 @@ impl Sending { |
|
|
|
continue; |
|
|
|
continue; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
for user in db.users.iter().filter_map(|r| r.ok()).filter(|user_id| { |
|
|
|
let userid = UserId::try_from(utils::string_from_bytes(user).map_err(|e| { |
|
|
|
db.rooms.is_joined(&user_id, &pdu.room_id).unwrap_or(false) |
|
|
|
( |
|
|
|
}) { |
|
|
|
OutgoingKind::Push(user.clone(), pushkey.clone()), |
|
|
|
// Don't notify the user of their own events
|
|
|
|
Error::bad_database("Invalid push user string in db."), |
|
|
|
if user == pdu.sender { |
|
|
|
) |
|
|
|
continue; |
|
|
|
})?) |
|
|
|
} |
|
|
|
.map_err(|e| { |
|
|
|
|
|
|
|
( |
|
|
|
|
|
|
|
OutgoingKind::Push(user.clone(), pushkey.clone()), |
|
|
|
|
|
|
|
Error::bad_database("Invalid push user id in db."), |
|
|
|
|
|
|
|
) |
|
|
|
|
|
|
|
})?; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let mut senderkey = user.clone(); |
|
|
|
|
|
|
|
senderkey.push(0xff); |
|
|
|
|
|
|
|
senderkey.extend_from_slice(pushkey); |
|
|
|
|
|
|
|
|
|
|
|
let pushers = db |
|
|
|
let pusher = match db |
|
|
|
.pusher |
|
|
|
.pusher |
|
|
|
.get_pusher(&user) |
|
|
|
.get_pusher(&senderkey) |
|
|
|
.map_err(|e| (OutgoingKind::Push(id.clone()), e))?; |
|
|
|
.map_err(|e| (OutgoingKind::Push(user.clone(), pushkey.clone()), e))? |
|
|
|
|
|
|
|
{ |
|
|
|
|
|
|
|
Some(pusher) => pusher, |
|
|
|
|
|
|
|
None => continue, |
|
|
|
|
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
let rules_for_user = db |
|
|
|
let rules_for_user = db |
|
|
|
.account_data |
|
|
|
.account_data |
|
|
|
.get::<push_rules::PushRulesEvent>(None, &user, EventType::PushRules) |
|
|
|
.get::<push_rules::PushRulesEvent>(None, &userid, EventType::PushRules) |
|
|
|
.map_err(|e| (OutgoingKind::Push(id.clone()), e))? |
|
|
|
.map_err(|e| (OutgoingKind::Push(user.clone(), pushkey.clone()), e))? |
|
|
|
.map(|ev| ev.content.global) |
|
|
|
.map(|ev| ev.content.global) |
|
|
|
.unwrap_or_else(|| crate::push_rules::default_pushrules(&user)); |
|
|
|
.unwrap_or_else(|| crate::push_rules::default_pushrules(&userid)); |
|
|
|
|
|
|
|
|
|
|
|
let unread: UInt = if let Some(last_read) = db |
|
|
|
let unread: UInt = if let Some(last_read) = db |
|
|
|
.rooms |
|
|
|
.rooms |
|
|
|
.edus |
|
|
|
.edus |
|
|
|
.private_read_get(&pdu.room_id, &user) |
|
|
|
.private_read_get(&pdu.room_id, &userid) |
|
|
|
.map_err(|e| (OutgoingKind::Push(id.clone()), e))? |
|
|
|
.map_err(|e| (OutgoingKind::Push(user.clone(), pushkey.clone()), e))? |
|
|
|
{ |
|
|
|
{ |
|
|
|
(db.rooms |
|
|
|
(db.rooms |
|
|
|
.pdus_since(&user, &pdu.room_id, last_read) |
|
|
|
.pdus_since(&userid, &pdu.room_id, last_read) |
|
|
|
.map_err(|e| (OutgoingKind::Push(id.clone()), e))? |
|
|
|
.map_err(|e| (OutgoingKind::Push(user.clone(), pushkey.clone()), e))? |
|
|
|
.filter_map(|pdu| pdu.ok()) // Filter out buggy events
|
|
|
|
.filter_map(|pdu| pdu.ok()) // Filter out buggy events
|
|
|
|
.filter(|(_, pdu)| { |
|
|
|
.filter(|(_, pdu)| { |
|
|
|
matches!( |
|
|
|
matches!( |
|
|
|
@ -462,10 +457,12 @@ impl Sending { |
|
|
|
}; |
|
|
|
}; |
|
|
|
|
|
|
|
|
|
|
|
let permit = db.sending.maximum_requests.acquire().await; |
|
|
|
let permit = db.sending.maximum_requests.acquire().await; |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
error!("sending pdu to {}: {:#?}", userid, pdu); |
|
|
|
let _response = pusher::send_push_notice( |
|
|
|
let _response = pusher::send_push_notice( |
|
|
|
&user, |
|
|
|
&userid, |
|
|
|
unread, |
|
|
|
unread, |
|
|
|
&pushers, |
|
|
|
&pusher, |
|
|
|
rules_for_user, |
|
|
|
rules_for_user, |
|
|
|
&pdu, |
|
|
|
&pdu, |
|
|
|
db, |
|
|
|
db, |
|
|
|
@ -476,8 +473,7 @@ impl Sending { |
|
|
|
|
|
|
|
|
|
|
|
drop(permit); |
|
|
|
drop(permit); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
Ok(OutgoingKind::Push(user.clone(), pushkey.clone())) |
|
|
|
Ok(OutgoingKind::Push(id.clone())) |
|
|
|
|
|
|
|
} |
|
|
|
} |
|
|
|
OutgoingKind::Normal(server) => { |
|
|
|
OutgoingKind::Normal(server) => { |
|
|
|
let pdu_jsons = pdu_ids |
|
|
|
let pdu_jsons = pdu_ids |
|
|
|
@ -540,30 +536,49 @@ impl Sending { |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
fn parse_servercurrentpdus(key: &IVec) -> Result<(OutgoingKind, IVec)> { |
|
|
|
fn parse_servercurrentpdus(key: &IVec) -> Result<(OutgoingKind, IVec)> { |
|
|
|
let mut parts = key.splitn(2, |&b| b == 0xff); |
|
|
|
// Appservices start with a plus
|
|
|
|
|
|
|
|
Ok::<_, Error>(if key.starts_with(b"+") { |
|
|
|
|
|
|
|
let mut parts = key[1..].splitn(2, |&b| b == 0xff); |
|
|
|
|
|
|
|
|
|
|
|
let server = parts.next().expect("splitn always returns one element"); |
|
|
|
let server = parts.next().expect("splitn always returns one element"); |
|
|
|
let pdu = parts |
|
|
|
let pdu = parts |
|
|
|
.next() |
|
|
|
.next() |
|
|
|
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; |
|
|
|
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; |
|
|
|
|
|
|
|
|
|
|
|
let server = utils::string_from_bytes(&server).map_err(|_| { |
|
|
|
let server = utils::string_from_bytes(&server).map_err(|_| { |
|
|
|
Error::bad_database("Invalid server bytes in server_currenttransaction") |
|
|
|
Error::bad_database("Invalid server bytes in server_currenttransaction") |
|
|
|
})?; |
|
|
|
})?; |
|
|
|
|
|
|
|
|
|
|
|
// Appservices start with a plus
|
|
|
|
|
|
|
|
Ok::<_, Error>(if server.starts_with('+') { |
|
|
|
|
|
|
|
( |
|
|
|
( |
|
|
|
OutgoingKind::Appservice(Box::<ServerName>::try_from(server).map_err(|_| { |
|
|
|
OutgoingKind::Appservice(Box::<ServerName>::try_from(server).map_err(|_| { |
|
|
|
Error::bad_database("Invalid server string in server_currenttransaction") |
|
|
|
Error::bad_database("Invalid server string in server_currenttransaction") |
|
|
|
})?), |
|
|
|
})?), |
|
|
|
IVec::from(pdu), |
|
|
|
IVec::from(pdu), |
|
|
|
) |
|
|
|
) |
|
|
|
} else if server.starts_with('$') { |
|
|
|
} else if key.starts_with(b"$") { |
|
|
|
|
|
|
|
let mut parts = key[1..].splitn(3, |&b| b == 0xff); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let user = parts.next().expect("splitn always returns one element"); |
|
|
|
|
|
|
|
let pushkey = parts |
|
|
|
|
|
|
|
.next() |
|
|
|
|
|
|
|
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; |
|
|
|
|
|
|
|
let pdu = parts |
|
|
|
|
|
|
|
.next() |
|
|
|
|
|
|
|
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; |
|
|
|
( |
|
|
|
( |
|
|
|
OutgoingKind::Push(server.as_bytes().to_vec()), |
|
|
|
OutgoingKind::Push(user.to_vec(), pushkey.to_vec()), |
|
|
|
IVec::from(pdu), |
|
|
|
IVec::from(pdu), |
|
|
|
) |
|
|
|
) |
|
|
|
} else { |
|
|
|
} else { |
|
|
|
|
|
|
|
let mut parts = key.splitn(2, |&b| b == 0xff); |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
let server = parts.next().expect("splitn always returns one element"); |
|
|
|
|
|
|
|
let pdu = parts |
|
|
|
|
|
|
|
.next() |
|
|
|
|
|
|
|
.ok_or_else(|| Error::bad_database("Invalid bytes in servercurrentpdus."))?; |
|
|
|
|
|
|
|
let server = utils::string_from_bytes(&server).map_err(|_| { |
|
|
|
|
|
|
|
Error::bad_database("Invalid server bytes in server_currenttransaction") |
|
|
|
|
|
|
|
})?; |
|
|
|
|
|
|
|
|
|
|
|
( |
|
|
|
( |
|
|
|
OutgoingKind::Normal(Box::<ServerName>::try_from(server).map_err(|_| { |
|
|
|
OutgoingKind::Normal(Box::<ServerName>::try_from(server).map_err(|_| { |
|
|
|
Error::bad_database("Invalid server string in server_currenttransaction") |
|
|
|
Error::bad_database("Invalid server string in server_currenttransaction") |
|
|
|
|
Timo Kösters
5 years ago