From 0885753efe840db7eff6e9520e978b9519dcf48e Mon Sep 17 00:00:00 2001 From: John Coffey Date: Thu, 19 Nov 2026 18:39:32 -0700 Subject: [PATCH] Keep an account's disk quota within its tenant's (inbuxa-admin#257) A tenant administrator could give an account any disk quota, even ten times the tenant's own. Writes still stopped at the tenant's limit, but the account's mail was refused as over quota while the webmail showed most of its 50 GB free. - x:Account/set (JMAP and SCIM) refuses an account disk quota above its tenant's maxDiskQuota with invalidProperties on quotas, naming both sizes, whoever writes it. Checked when the quota is set or changed or the account changes tenant: an account already over a lowered tenant limit keeps it until someone edits it, like the count limits (MT-18). No quota stays allowed (the account shares the tenant's space). Accounts a directory creates at sign-in and restored accounts aren't checked, so neither is refused for a setting nobody can edit first. - JMAP Quota/get and IMAP GETQUOTA report the limit the account will really meet: its own quota or its tenant's remaining space, whichever comes first, as DAV already did. One helper, effective_disk_quota, serves all three. An account with no quota of its own in a limited tenant now gets a Quota object too. Tests: the tenant suite covers refusals for the tenant and server administrators, an update over the limit, an unrelated edit to an account over a lowered limit, and Quota/get for a member without a quota. --- crates/common/src/storage/quota.rs | 29 ++++++++ crates/dav/src/common/propfind.rs | 31 ++------- crates/features/src/tenancy/writes.rs | 99 ++++++++++++++++++++++++++- crates/imap/src/op/quota.rs | 36 +++++----- crates/jmap/src/quota/get.rs | 16 +++-- crates/jmap/src/registry/set.rs | 13 ++++ tests/src/system/tenant.rs | 84 +++++++++++++++++++++-- 7 files changed, 255 insertions(+), 53 deletions(-) diff --git a/crates/common/src/storage/quota.rs b/crates/common/src/storage/quota.rs index 577adf25..a8189b94 100644 --- a/crates/common/src/storage/quota.rs +++ b/crates/common/src/storage/quota.rs @@ -92,6 +92,35 @@ impl Server { Ok(()) } + // inbuxa: the disk space an account can really use, for reporting it to + // clients (JMAP Quota, IMAP QUOTA, DAV quota properties). Returns what + // the account uses and, when any limit applies, the limit it will + // actually meet: its own quota or its tenant's remaining space, + // whichever comes first (MT-19). Without this a 50 GB account in a 5 GB + // tenant shows 45 GB free while its mail is refused. + pub async fn effective_disk_quota( + &self, + account: &AccountCache, + ) -> trc::Result<(u64, Option)> { + let used = self.get_used_quota_account(account.id).await?.max(0) as u64; + let mut available = + (account.quota_disk > 0).then(|| account.quota_disk.saturating_sub(used)); + + if let Some(tenant_id) = account.id_tenant { + let tenant = self.tenant(tenant_id).await?; + if tenant.quota_disk > 0 { + let tenant_used = self.get_used_quota_tenant(tenant_id).await?.max(0) as u64; + let tenant_available = tenant.quota_disk.saturating_sub(tenant_used); + available = Some(available.map_or(tenant_available, |a| a.min(tenant_available))); + } + } + + Ok(( + used, + available.map(|available| used.saturating_add(available)), + )) + } + // inbuxa: checks an item against the account's quota and, when it fits, // counts it towards the rest of the request pub async fn reserve_quota(&self, budget: &mut QuotaBudget, item_size: u64) -> trc::Result<()> { diff --git a/crates/dav/src/common/propfind.rs b/crates/dav/src/common/propfind.rs index 74d942cc..a0222997 100644 --- a/crates/dav/src/common/propfind.rs +++ b/crates/dav/src/common/propfind.rs @@ -1194,32 +1194,15 @@ impl PropFindRequestHandler for Server { async fn dav_quota(&self, account_id: u32) -> trc::Result { let account = self.account(account_id).await.caused_by(trc::location!())?; - let used = self - .get_used_quota_account(account_id) + let (used, limit) = self + .effective_disk_quota(&account) .await - .caused_by(trc::location!())? - .max(0) as u64; - let mut available = - (account.quota_disk > 0).then(|| account.quota_disk.saturating_sub(used)); + .caused_by(trc::location!())?; - if let Some(tenant_id) = account.id_tenant { - let tenant = self.tenant(tenant_id).await.caused_by(trc::location!())?; - - if tenant.quota_disk > 0 { - let tenant_used = self - .get_used_quota_tenant(tenant_id) - .await - .caused_by(trc::location!())? - .max(0) as u64; - let tenant_available = tenant.quota_disk.saturating_sub(tenant_used); - - available = Some(available.map_or(tenant_available, |available| { - available.min(tenant_available) - })); - } - } - - Ok(PropFindAccountQuota { used, available }) + Ok(PropFindAccountQuota { + used, + available: limit.map(|limit| limit.saturating_sub(used)), + }) } } #[allow(clippy::too_many_arguments)] diff --git a/crates/features/src/tenancy/writes.rs b/crates/features/src/tenancy/writes.rs index 5fe87f79..4ecbafd9 100644 --- a/crates/features/src/tenancy/writes.rs +++ b/crates/features/src/tenancy/writes.rs @@ -13,6 +13,8 @@ //! - MT-17: creating an object, or moving a domain in, stays within the //! tenant's count limits, and the server emits `limit.tenant-quota` when //! it doesn't. +//! - An account's disk quota fits within its tenant's (inbuxa-admin#257), +//! checked by `check_disk_quota` on JMAP and SCIM writes. use crate::tenancy::{ domain_move::{self, Move, Refusal}, @@ -23,7 +25,7 @@ use ahash::AHashSet; use jmap_proto::error::set::{SetError, SetErrorType}; use registry::{ schema::{ - enums::TenantStorageQuota, + enums::{StorageQuota, TenantStorageQuota}, prelude::{Object, ObjectInner, Property}, structs::{Account, DkimManagement, Domain, Tenant}, }, @@ -63,6 +65,19 @@ pub async fn default_tenant(registry: &RegistryStore, object: &mut Object) -> tr Ok(()) } +/// An account's own disk quota, `None` when it has none (0 is none too). +fn account_disk_quota(object: &ObjectInner) -> Option { + let quotas = match object { + ObjectInner::Account(Account::User(obj)) => &obj.quotas, + ObjectInner::Account(Account::Group(obj)) => &obj.quotas, + _ => return None, + }; + quotas + .get(&StorageQuota::MaxDiskQuota) + .copied() + .filter(|quota| *quota > 0) +} + /// A tenant's count limit, `None` when it has none. async fn limits( registry: &RegistryStore, @@ -146,6 +161,35 @@ pub async fn check( Ok(Ok(after)) } +/// inbuxa-admin#257: an account's disk quota fits within its tenant's, so no +/// member gets more space than the whole tenant has. Run on a JMAP or SCIM +/// write, after `check`. Checked when the quota is set or changed, or the +/// account changes tenant; an account already over a lowered tenant limit +/// keeps its quota until someone changes it, like the count limits (MT-18). +/// No quota at all is fine: the account shares the tenant's space. Not run +/// for accounts a directory creates at sign-in or for a restored account, +/// which would otherwise be refused for a setting nobody can edit first. +pub async fn check_disk_quota( + registry: &RegistryStore, + old: Option<&Object>, + new: &Object, +) -> trc::Result>> { + let tenant = new.inner.member_tenant_id(); + if let Some(tenant_id) = tenant + && let Some(quota) = account_disk_quota(&new.inner) + && old.is_none_or(|old| { + account_disk_quota(&old.inner) != Some(quota) || old.inner.member_tenant_id() != tenant + }) + && let Some(tenant_quota) = + (limits(registry, tenant_id).await?)(TenantStorageQuota::MaxDiskQuota) + .filter(|limit| *limit > 0) + && quota > tenant_quota + { + return Ok(Err(over_tenant_disk_quota(quota, tenant_quota))); + } + Ok(Ok(())) +} + /// Finishes a checked write once it's saved. Returns each other object it /// changed, as it was and as it is now, for cache invalidation. pub async fn after_save( @@ -196,6 +240,59 @@ fn over_quota(reached: LimitReached, tenant_id: Id) -> SetError { )) } +/// Refuses an account disk quota bigger than its tenant's (inbuxa-admin#257). +fn over_tenant_disk_quota(quota: u64, tenant_quota: u64) -> SetError { + SetError::invalid_properties() + .with_property(Property::Quotas) + .with_description(format!( + "The account's disk quota of {quota} bytes ({}) is more than its tenant's \ + maxDiskQuota of {tenant_quota} bytes ({}). Set it to {tenant_quota} or less, \ + or leave it empty to share the tenant's space.", + readable_size(quota), + readable_size(tenant_quota), + )) +} + +/// A byte count in binary units, for people reading an error: "50 GiB". +fn readable_size(bytes: u64) -> String { + const UNITS: [&str; 5] = ["bytes", "KiB", "MiB", "GiB", "TiB"]; + let mut value = bytes as f64; + let mut unit = 0; + while value >= 1024.0 && unit < UNITS.len() - 1 { + value /= 1024.0; + unit += 1; + } + if unit == 0 || value.fract() == 0.0 { + format!("{value:.0} {}", UNITS[unit]) + } else { + format!("{value:.1} {}", UNITS[unit]) + } +} + +#[cfg(test)] +mod disk_quota_tests { + use super::*; + + #[test] + fn readable_sizes() { + assert_eq!(readable_size(512), "512 bytes"); + assert_eq!(readable_size(5 * 1024 * 1024 * 1024), "5 GiB"); + assert_eq!(readable_size(1536 * 1024 * 1024), "1.5 GiB"); + } + + #[test] + fn zero_quota_is_no_quota() { + let user = |quota: u64| { + ObjectInner::Account(Account::User(registry::schema::structs::UserAccount { + quotas: [(StorageQuota::MaxDiskQuota, quota)].into_iter().collect(), + ..Default::default() + })) + }; + assert_eq!(account_disk_quota(&user(0)), None); + assert_eq!(account_disk_quota(&user(10)), Some(10)); + } +} + fn refused_move(refusal: Refusal, tenant: Option) -> SetError { match refusal { Refusal::Across => SetError::invalid_properties() diff --git a/crates/imap/src/op/quota.rs b/crates/imap/src/op/quota.rs index eca5c854..c92536a8 100644 --- a/crates/imap/src/op/quota.rs +++ b/crates/imap/src/op/quota.rs @@ -109,20 +109,20 @@ impl SessionData { .account(account_id) .await .imap_ctx(&arguments.tag, trc::location!())?; - let used_quota = self + // inbuxa: the limit the account will really meet, its own quota or + // its tenant's remaining space (inbuxa-admin#257) + let (used_quota, disk_limit) = self .server - .get_used_quota_account(account_id) + .effective_disk_quota(&account) .await .imap_ctx(&arguments.tag, trc::location!())?; + let disk_limit = disk_limit.unwrap_or_default(); trc::event!( Imap(trc::ImapEvent::GetQuota), SpanId = self.session_id, Id = arguments.name.clone(), - Details = vec![ - trc::Value::from(used_quota), - trc::Value::from(account.disk_quota()) - ], + Details = vec![trc::Value::from(used_quota), trc::Value::from(disk_limit)], Elapsed = op_start.elapsed() ); @@ -131,11 +131,11 @@ impl SessionData { quota_root_items: vec![], quota_items: vec![QuotaItem { name: arguments.name, - resources: if account.disk_quota() > 0 { + resources: if disk_limit > 0 { vec![QuotaResource { resource: QuotaResourceName::Storage, - total: account.disk_quota(), - used: used_quota as u64, + total: disk_limit, + used: used_quota, }] } else { vec![] @@ -173,20 +173,20 @@ impl SessionData { .account(account_id) .await .imap_ctx(&arguments.tag, trc::location!())?; - let used_quota = self + // inbuxa: the limit the account will really meet, its own quota or + // its tenant's remaining space (inbuxa-admin#257) + let (used_quota, disk_limit) = self .server - .get_used_quota_account(account_id) + .effective_disk_quota(&account) .await .imap_ctx(&arguments.tag, trc::location!())?; + let disk_limit = disk_limit.unwrap_or_default(); trc::event!( Imap(trc::ImapEvent::GetQuota), SpanId = self.session_id, MailboxName = arguments.name.clone(), - Details = vec![ - trc::Value::from(used_quota), - trc::Value::from(account.disk_quota()) - ], + Details = vec![trc::Value::from(used_quota), trc::Value::from(disk_limit)], Elapsed = op_start.elapsed() ); @@ -195,11 +195,11 @@ impl SessionData { quota_root_items: vec![arguments.name, format!("#{account_id}")], quota_items: vec![QuotaItem { name: format!("#{account_id}"), - resources: if account.disk_quota() > 0 { + resources: if disk_limit > 0 { vec![QuotaResource { resource: QuotaResourceName::Storage, - total: account.disk_quota(), - used: used_quota as u64, + total: disk_limit, + used: used_quota, }] } else { vec![] diff --git a/crates/jmap/src/quota/get.rs b/crates/jmap/src/quota/get.rs index b06875cd..2e6d2ef9 100644 --- a/crates/jmap/src/quota/get.rs +++ b/crates/jmap/src/quota/get.rs @@ -2,6 +2,8 @@ * SPDX-FileCopyrightText: 2020 Stalwart Labs LLC * * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-SEL + * + * Modified by Coffey Labs in 2026 for INBUXA. */ use common::{Server, auth::AccessToken}; @@ -44,7 +46,13 @@ impl QuotaGet for Server { ]); let account_id = request.account_id.document_id(); let account = self.account(account_id).await.caused_by(trc::location!())?; - let quota_ids = if account.disk_quota() > 0 { + // inbuxa: report the limit the account will really meet, its own + // quota or its tenant's remaining space (inbuxa-admin#257) + let (used, hard_limit) = self + .effective_disk_quota(&account) + .await + .caused_by(trc::location!())?; + let quota_ids = if hard_limit.is_some() { vec![0u32] } else { vec![] @@ -80,10 +88,8 @@ impl QuotaGet for Server { let value = match property { QuotaProperty::Id => Value::Element(id.into()), QuotaProperty::ResourceType => "octets".to_string().into(), - QuotaProperty::Used => { - (self.get_used_quota_account(account_id).await?.max(0) as u64).into() - } - QuotaProperty::HardLimit => account.as_ref().disk_quota().into(), + QuotaProperty::Used => used.into(), + QuotaProperty::HardLimit => hard_limit.unwrap_or_default().into(), QuotaProperty::Scope => "account".to_string().into(), QuotaProperty::Name => account.as_ref().name().to_string().into(), QuotaProperty::Description => account diff --git a/crates/jmap/src/registry/set.rs b/crates/jmap/src/registry/set.rs index 4a68b253..6cf2be9c 100644 --- a/crates/jmap/src/registry/set.rs +++ b/crates/jmap/src/registry/set.rs @@ -670,6 +670,19 @@ impl RegistrySet for Server { } }; + // inbuxa: inbuxa-admin#257: an account's disk quota fits + // within its tenant's + if let Err(err) = inbuxa_features::tenancy::writes::check_disk_quota( + self.registry(), + stored, + &new_object, + ) + .await? + { + set.failed(modification, err); + continue 'outer; + } + // inbuxa: BT-3, BT-15, BT-22: logos and templates follow their rules let before = match &modification { Modification::Update { object, .. } diff --git a/tests/src/system/tenant.rs b/tests/src/system/tenant.rs index 48483179..2d8e6342 100644 --- a/tests/src/system/tenant.rs +++ b/tests/src/system/tenant.rs @@ -23,7 +23,8 @@ use jmap_proto::error::set::SetErrorType; use registry::{ schema::{ enums::{ - Permission, TaskStoreMaintenanceType, TaskTenantMaintenanceType, TenantStorageQuota, + Permission, StorageQuota, TaskStoreMaintenanceType, TaskTenantMaintenanceType, + TenantStorageQuota, }, prelude::{ObjectType, Property}, structs::{ @@ -849,17 +850,20 @@ pub async fn test(test: &mut TestServer) { // Acceptance test 13: the tenant's disk limit bounds all its members // together (MT-19, MT-20) let d_id = admin.create_tenant("Tenant D").await; - admin + let d_domain = admin .create_tenant_domain("d.example.org", Some(d_id)) .await; let d_admin = admin .create_user_account("dadmin@d.example.org", SECRET_D, "D admin", &[], vec![]) .await; admin.make_tenant_admin(d_admin.id()).await; + let mut d_users = Vec::new(); for name in ["d1@d.example.org", "d2@d.example.org", "d3@d.example.org"] { - admin - .create_user_account(name, SECRET_D, "D user", &[], vec![]) - .await; + d_users.push( + admin + .create_user_account(name, SECRET_D, "D user", &[], vec![]) + .await, + ); } let message = concat!( "From: someone@remote.example.org\r\n", @@ -958,6 +962,76 @@ pub async fn test(test: &mut TestServer) { .registry_destroy(ObjectType::QueuedMessage, queued) .await; + // inbuxa-admin#257: an account's disk quota can't exceed its tenant's, + // whoever sets it + let d_limit = (two + one / 2) as u64; + let with_quota = |name: &str, quota: u64| { + structs::Account::User(structs::UserAccount { + name: name.to_string(), + domain_id: d_domain, + quotas: VecMap::from_iter([(StorageQuota::MaxDiskQuota, quota)]), + ..Default::default() + }) + }; + for writer in [&d_admin, &admin] { + writer + .registry_create_object_expect_err(with_quota("d4", d_limit * 10)) + .await + .assert_type(SetErrorType::InvalidProperties) + .assert_description_contains("maxDiskQuota"); + } + let d4 = d_admin + .registry_create_object(with_quota("d4", d_limit)) + .await; + d_admin + .registry_update_object_expect_err( + ObjectType::Account, + d4, + json!({ Property::Quotas: VecMap::from_iter([(StorageQuota::MaxDiskQuota, d_limit + 1)]) }), + ) + .await + .assert_type(SetErrorType::InvalidProperties); + // Lowering the tenant's limit leaves the account's quota alone, and + // other changes to it still save (MT-18) + admin + .set_tenant_quota(d_id, TenantStorageQuota::MaxDiskQuota, d_limit - 1) + .await; + d_admin + .registry_update_object( + ObjectType::Account, + d4, + json!({ Property::Description: "still here" }), + ) + .await; + admin + .set_tenant_quota(d_id, TenantStorageQuota::MaxDiskQuota, d_limit) + .await; + admin + .registry_destroy(ObjectType::Account, [d4]) + .await + .assert_destroyed(&[d4]); + test.wait_for_tasks().await; + // A member with no quota of its own sees the tenant's remaining space + // as its limit, the limit it would really meet + let response = d_users[0] + .jmap_method_call( + "Quota/get", + json!({ "accountId": d_users[0].id_string(), "ids": null }), + ) + .await + .to_string(); + let d1_used = test + .server + .get_used_quota_account(d_users[0].id().document_id()) + .await + .unwrap() + .max(0) as u64; + let expected = d1_used + d_limit.saturating_sub(two as u64); + assert!( + response.contains(&format!("\"hardLimit\":{expected}")), + "inbuxa-admin#257: Quota/get {response}" + ); + // Acceptance test 14: recalculateQuota restores a corrupted figure (MT-21) test.corrupt_tenant_usage(d_id, 123_456).await; assert_ne!(admin.tenant_usage(d_id).await, two); -- 2.54.0