use std::{
collections::{BTreeMap, HashSet},
fmt,
future::Future,
sync::Arc,
time::SystemTime,
};
use jmap_types::{Id, JmapError, PushSubscription, SetObject, State, StateChange, UTCDate};
use serde_json::{Map, Value, json};
use subtle::ConstantTimeEq;
use crate::backend::{
BackendSetError, JmapBackend, SetError, SetErrorType, backend_set_error_value,
};
use crate::handlers::{server_fail_from_backend, server_fail_value_from_backend};
use crate::helpers::{
apply_patch_object, enforce_max_objects_in_get, enforce_max_objects_in_set, not_found_json,
optional_arg, reject_server_set, serialize_value, signed_seconds_since_epoch,
utc_date_from_epoch_seconds,
};
use crate::{CallContext, ClosureHandler, Dispatcher, HandlerFuture, HandlerOutput, JmapHandler};
const PRIVATE_PROPERTIES: [&str; 2] = ["url", "keys"];
const RFC_PROPERTIES: [&str; 5] = [
"id",
"deviceClientId",
"verificationCode",
"expires",
"types",
];
const MAX_OBJECTS_IN_GET: u64 = 500;
const MAX_OBJECTS_IN_SET: u64 = 500;
pub const MAX_PUSH_EXPIRY_SECS: i64 = 7 * 86_400;
#[derive(Clone, PartialEq, Eq)]
pub struct StoredPushSubscription {
pub subscription: PushSubscription,
pub expected_code: String,
}
impl fmt::Debug for StoredPushSubscription {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("StoredPushSubscription")
.field("subscription", &self.subscription)
.field("expected_code", &"[REDACTED]")
.finish()
}
}
pub trait PushSubscriptionBackend: JmapBackend {
const PUSH_SUBSCRIPTION_EXTENSION_PROPERTIES: &'static [&'static str] = &[];
fn list_push_subscriptions(
&self,
caller: &Self::CallerCtx,
) -> impl Future<Output = Result<Vec<StoredPushSubscription>, Self::Error>> + Send;
fn create_push_subscription(
&self,
caller: &Self::CallerCtx,
new: PushSubscription,
) -> impl Future<Output = Result<StoredPushSubscription, BackendSetError<Self::Error>>> + Send;
fn update_push_subscription(
&self,
caller: &Self::CallerCtx,
sub: PushSubscription,
) -> impl Future<Output = Result<PushSubscription, BackendSetError<Self::Error>>> + Send;
fn destroy_push_subscription(
&self,
caller: &Self::CallerCtx,
id: &Id,
) -> impl Future<Output = Result<(), BackendSetError<Self::Error>>> + Send;
}
pub fn register_push_subscription_handlers<B>(
dispatcher: &mut Dispatcher<B::CallerCtx>,
backend: Arc<B>,
) where
B: PushSubscriptionBackend + 'static,
{
let handler: Arc<dyn JmapHandler<B::CallerCtx>> = Arc::new(ClosureHandler::new(
Arc::clone(&backend),
|b: Arc<B>, cx: CallContext<B::CallerCtx>| {
Box::pin(async move { handle_push_subscription_get(&*b, &cx.caller, cx.args).await })
as HandlerFuture
},
));
dispatcher.register("PushSubscription/get", handler);
let handler: Arc<dyn JmapHandler<B::CallerCtx>> = Arc::new(ClosureHandler::new(
backend,
|b: Arc<B>, cx: CallContext<B::CallerCtx>| {
Box::pin(async move { handle_push_subscription_set(&*b, &cx.caller, cx.args).await })
as HandlerFuture
},
));
dispatcher.register("PushSubscription/set", handler);
}
async fn handle_push_subscription_get<B: PushSubscriptionBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
let Value::Object(mut args) = args else {
return Err(JmapError::invalid_arguments("arguments must be an object"));
};
enforce_max_objects_in_get(&args, MAX_OBJECTS_IN_GET)?;
let ids: Option<Vec<Id>> = optional_arg(&mut args, "ids", || {
JmapError::invalid_arguments("ids must be an Id array")
})?;
let properties: Option<Vec<String>> = optional_arg(&mut args, "properties", || {
JmapError::invalid_arguments("properties must be a string array")
})?;
if properties
.iter()
.flatten()
.any(|p| PRIVATE_PROPERTIES.contains(&p.as_str()))
{
return Err(JmapError::forbidden());
}
if let Some(bad) = properties.iter().flatten().find(|p| {
!RFC_PROPERTIES.contains(&p.as_str())
&& !B::PUSH_SUBSCRIPTION_EXTENSION_PROPERTIES.contains(&p.as_str())
}) {
return Err(JmapError::invalid_arguments(format!(
"unknown PushSubscription property: {bad}"
)));
}
let stored = backend
.list_push_subscriptions(caller)
.await
.map_err(|e| server_fail_from_backend(&e))?;
let mut subs: Vec<PushSubscription> = stored.into_iter().map(|s| s.subscription).collect();
let mut not_found = Vec::new();
if let Some(ids) = ids {
let mut found = Vec::with_capacity(ids.len());
let mut seen = HashSet::with_capacity(ids.len());
for id in ids {
if !seen.insert(id.clone()) {
continue;
}
match subs.iter().find(|s| s.id.as_ref() == Some(&id)) {
Some(s) => found.push(s.clone()),
None => not_found.push(id),
}
}
subs = found;
}
let list = subs
.into_iter()
.map(|mut sub| {
sub.url = None;
sub.keys = None;
let mut value = serialize_value(&sub)?;
if let (Some(props), Value::Object(obj)) = (&properties, &mut value) {
obj.retain(|key, _| key == "id" || props.contains(key));
}
Ok(value)
})
.collect::<Result<Vec<Value>, JmapError>>()?;
Ok(HandlerOutput::new(json!({
"list": list,
"notFound": not_found_json(¬_found),
})))
}
async fn handle_push_subscription_set<B: PushSubscriptionBackend>(
backend: &B,
caller: &B::CallerCtx,
args: Value,
) -> Result<HandlerOutput, JmapError> {
let Value::Object(mut args) = args else {
return Err(JmapError::invalid_arguments("arguments must be an object"));
};
enforce_max_objects_in_set(&args, MAX_OBJECTS_IN_SET)?;
let create: Option<Map<String, Value>> = optional_arg(&mut args, "create", || {
JmapError::invalid_arguments("create must be an object")
})?;
let update: Option<Map<String, Value>> = optional_arg(&mut args, "update", || {
JmapError::invalid_arguments("update must be an object")
})?;
let destroy: Option<Vec<Id>> = optional_arg(&mut args, "destroy", || {
JmapError::invalid_arguments("destroy must be an Id array")
})?;
let update_with_stored = match update.filter(|u| !u.is_empty()) {
Some(update) => {
let stored = backend
.list_push_subscriptions(caller)
.await
.map_err(|e| server_fail_from_backend(&e))?;
Some((update, stored))
}
None => None,
};
let mut created = Map::new();
let mut not_created = Map::new();
for (creation_id, obj) in create.unwrap_or_default() {
let sent: HashSet<String> = obj
.as_object()
.map(|fields| fields.keys().cloned().collect())
.unwrap_or_default();
let new = match validate_create(obj) {
Ok(new) => new,
Err(err) => {
not_created.insert(creation_id, err);
continue;
}
};
match backend.create_push_subscription(caller, new).await {
Ok(stored) => {
created.insert(creation_id, created_value(&stored.subscription, &sent));
}
Err(e) => {
not_created.insert(creation_id, backend_set_error_value(e));
}
}
}
let mut updated = Map::new();
let mut not_updated = Map::new();
if let Some((update, stored)) = update_with_stored {
for (id, patch) in update {
let current = stored
.iter()
.find(|s| s.subscription.id.as_ref().map(AsRef::as_ref) == Some(id.as_str()));
match update_one(backend, caller, current, patch).await {
Ok(changed) => {
updated.insert(id, changed);
}
Err(err) => {
not_updated.insert(id, err);
}
}
}
}
let mut destroyed = Vec::new();
let mut not_destroyed = Map::new();
for id in destroy.unwrap_or_default() {
match backend.destroy_push_subscription(caller, &id).await {
Ok(()) => destroyed.push(Value::String(id.as_ref().to_owned())),
Err(e) => {
not_destroyed.insert(id.as_ref().to_owned(), backend_set_error_value(e));
}
}
}
let or_null = |m: Map<String, Value>| {
if m.is_empty() {
Value::Null
} else {
Value::Object(m)
}
};
Ok(HandlerOutput::new(json!({
"created": or_null(created),
"updated": or_null(updated),
"destroyed": if destroyed.is_empty() { Value::Null } else { Value::Array(destroyed) },
"notCreated": or_null(not_created),
"notUpdated": or_null(not_updated),
"notDestroyed": or_null(not_destroyed),
})))
}
fn created_value(sub: &PushSubscription, sent: &HashSet<String>) -> Value {
let mut props = Map::new();
props.insert("id".to_owned(), json!(sub.id));
props.insert("deviceClientId".to_owned(), json!(sub.device_client_id));
props.insert("url".to_owned(), json!(sub.url));
props.insert("keys".to_owned(), json!(sub.keys));
props.insert("verificationCode".to_owned(), json!(sub.verification_code));
props.insert("expires".to_owned(), json!(sub.expires));
props.insert("types".to_owned(), json!(sub.types));
props.extend(sub.extra.clone());
props.retain(|k, _| k == "id" || k == "expires" || !sent.contains(k));
Value::Object(props)
}
fn validate_create(obj: Value) -> Result<PushSubscription, Value> {
let Value::Object(fields) = &obj else {
return Err(Value::from(
&SetError::new(SetErrorType::InvalidProperties)
.with_description("a create entry must be an object"),
));
};
if let Some(err) = reject_server_set::<PushSubscription>(fields) {
return Err(Value::from(&err));
}
if !fields
.get("url")
.and_then(Value::as_str)
.is_some_and(|url| url.starts_with("https://"))
{
return Err(invalid_property("url"));
}
if fields.get("verificationCode").is_some_and(|v| !v.is_null()) {
return Err(invalid_property("verificationCode"));
}
let mut new: PushSubscription = serde_json::from_value(obj).map_err(|e| {
Value::from(&SetError::new(SetErrorType::InvalidProperties).with_description(e.to_string()))
})?;
new.expires = Some(limit_expires(new.expires.as_ref())?);
Ok(new)
}
async fn update_one<B: PushSubscriptionBackend>(
backend: &B,
caller: &B::CallerCtx,
current: Option<&StoredPushSubscription>,
patch: Value,
) -> Result<Value, Value> {
let Some(current) = current else {
return Err(Value::from(&SetError::new(SetErrorType::NotFound)));
};
let Value::Object(patch) = patch else {
return Err(Value::from(
&SetError::new(SetErrorType::InvalidPatch)
.with_description("a PatchObject must be an object"),
));
};
let Value::Object(mut target) =
serialize_value(¤t.subscription).map_err(|e| server_fail_value_from_backend(&e))?
else {
return Err(server_fail_value_from_backend(
"PushSubscription did not serialize to an object",
));
};
let before = target.clone();
apply_patch_object(&mut target, &patch).map_err(|e| {
Value::from(&SetError::new(SetErrorType::InvalidPatch).with_description(e.to_string()))
})?;
let changed_read_only = PushSubscription::SERVER_SET
.iter()
.chain(PushSubscription::IMMUTABLE)
.find(|p| before.get(**p) != target.get(**p));
let mut patched: PushSubscription =
serde_json::from_value(Value::Object(target)).map_err(|e| {
Value::from(
&SetError::new(SetErrorType::InvalidProperties).with_description(e.to_string()),
)
})?;
if let Some(property) = changed_read_only {
return Err(invalid_property(property));
}
let old = ¤t.subscription;
if patched.verification_code != old.verification_code
&& let Some(code) = &patched.verification_code
&& !codes_match(code, ¤t.expected_code)
{
return Err(invalid_property("verificationCode"));
}
let requested_expires = patched.expires.clone();
if requested_expires != old.expires {
patched.expires = Some(limit_expires(requested_expires.as_ref())?);
}
let stored = backend
.update_push_subscription(caller, patched)
.await
.map_err(backend_set_error_value)?;
Ok(if stored.expires == requested_expires {
Value::Null
} else {
json!({ "expires": stored.expires })
})
}
fn limit_expires(requested: Option<&UTCDate>) -> Result<UTCDate, Value> {
let clock_fail = || server_fail_value_from_backend("system clock out of range");
let (now, _) = signed_seconds_since_epoch(SystemTime::now()).ok_or_else(clock_fail)?;
let max = now
.checked_add(MAX_PUSH_EXPIRY_SECS)
.ok_or_else(clock_fail)?;
if let Some(requested) = requested {
let secs = requested
.to_epoch_seconds()
.map_err(|_| invalid_property("expires"))?;
if secs <= max {
return Ok(requested.clone());
}
}
utc_date_from_epoch_seconds(max).ok_or_else(clock_fail)
}
pub fn is_deliverable(stored: &StoredPushSubscription, now_secs: i64) -> bool {
let sub = &stored.subscription;
let verified = sub
.verification_code
.as_deref()
.is_some_and(|code| codes_match(code, &stored.expected_code));
let unexpired = match &sub.expires {
None => true,
Some(expires) => expires
.to_epoch_seconds()
.is_ok_and(|expires| now_secs <= expires),
};
verified && unexpired
}
pub fn state_change_for(
sub: &PushSubscription,
changed: &BTreeMap<Id, BTreeMap<String, State>>,
) -> Option<StateChange> {
let filtered: BTreeMap<Id, BTreeMap<String, State>> = changed
.iter()
.map(|(account, types)| {
let kept: BTreeMap<String, State> = types
.iter()
.filter(|(t, _)| sub.types.as_ref().is_none_or(|wanted| wanted.contains(t)))
.map(|(t, s)| (t.clone(), s.clone()))
.collect();
(account.clone(), kept)
})
.filter(|(_, kept)| !kept.is_empty())
.collect();
(!filtered.is_empty()).then(|| StateChange::new(filtered))
}
fn codes_match(sent: &str, expected: &str) -> bool {
sent.as_bytes().ct_eq(expected.as_bytes()).into()
}
fn invalid_property(property: &str) -> Value {
Value::from(&SetError::new(SetErrorType::InvalidProperties).with_properties([property]))
}