Installation binary first part.

Cargo.toml

@@ -13,6 +13,7 @@ members = [
     "crates/utils",
     "crates/maybe-async",
     "crates/cli",
+    "crates/install",
     "tests",
 ]
 

crates/directory/src/config.rs

@@ -42,7 +42,8 @@ impl ConfigDirectory for Config {
             };
 
             // Add queries/filters as lookups
-            if ["sql", "ldap"].contains(&protocol) {
+            let is_directory = ["sql", "ldap"].contains(&protocol);
+            if is_directory {
                 let name = if protocol == "sql" { "query" } else { "filter" };
                 for lookup_id in self.sub_keys(("directory", id, name)) {
                     config.lookups.insert(
@@ -58,9 +59,8 @@ impl ConfigDirectory for Config {
             }
 
             // Parse lookups
-            let is_remote = protocol != "memory";
             for lookup_id in self.sub_keys(("directory", id, "lookup")) {
-                let lookup = if is_remote {
+                let lookup = if is_directory {
                     Lookup::Directory {
                         directory: directory.clone(),
                         query: self
@@ -120,6 +120,10 @@ impl DirectoryOptions {
         Ok(DirectoryOptions {
             catch_all: config.property_or_static((&key, "options.catch-all"), "false")?,
             subaddressing: config.property_or_static((&key, "options.subaddressing"), "true")?,
+            superuser_group: config
+                .value("options.superuser-group")
+                .unwrap_or("superusers")
+                .to_string(),
         })
     }
 }

crates/directory/src/imap/config.rs

@@ -21,7 +21,7 @@ impl ImapDirectory {
         let address = config.value_require((&prefix, "address"))?;
         let tls_implicit: bool = config.property_or_static((&prefix, "tls.implicit"), "false")?;
         let port: u16 = config
-            .property_or_static((&prefix, "port"), if tls_implicit { "443" } else { "143" })?;
+            .property_or_static((&prefix, "port"), if tls_implicit { "993" } else { "143" })?;
 
         let manager = ImapConnectionManager {
             addr: format!("{address}:{port}"),

crates/directory/src/ldap/lookup.rs

@@ -304,17 +304,25 @@ impl LdapDirectory {
                         for entry in rs {
                             'outer: for (attr, value) in SearchEntry::construct(entry).attrs {
                                 if self.mappings.attr_name.contains(&attr) {
-                                    if let Some(name) = value.first() {
-                                        if !name.is_empty() {
-                                            names.push(name.to_string());
+                                    if let Some(group) = value.first() {
+                                        if !group.is_empty() {
+                                            if !group
+                                                .eq_ignore_ascii_case(&self.opt.superuser_group)
+                                            {
+                                                names.push(group.to_string());
+                                            } else {
+                                                principal.typ = Type::Superuser;
+                                            }
                                             break 'outer;
                                         }
                                     }
                                 }
                             }
                         }
-                    } else {
+                    } else if !group.eq_ignore_ascii_case(&self.opt.superuser_group) {
                         names.push(group);
+                    } else {
+                        principal.typ = Type::Superuser;
                     }
                 }
                 principal.member_of = names;

crates/directory/src/lib.rs

@@ -33,6 +33,7 @@ pub enum Type {
     Location,
     #[default]
     Other,
+    Superuser,
 }
 
 #[derive(Debug)]
@@ -135,7 +136,7 @@ impl Debug for Lookup {
 impl Type {
     pub fn to_jmap(&self) -> &'static str {
         match self {
-            Self::Individual => "individual",
+            Self::Individual | Self::Superuser => "individual",
             Self::Group => "group",
             Self::Resource => "resource",
             Self::Location => "location",
@@ -148,6 +149,7 @@ impl Type {
 struct DirectoryOptions {
     catch_all: bool,
     subaddressing: bool,
+    superuser_group: String,
 }
 
 #[derive(Default, Clone, Debug)]

crates/directory/src/memory/config.rs

@@ -12,12 +12,26 @@ impl MemoryDirectory {
         prefix: impl AsKey,
     ) -> utils::config::Result<Arc<dyn Directory>> {
         let prefix = prefix.as_key();
-        let mut directory = MemoryDirectory::default();
+        let mut directory = MemoryDirectory {
+            opt: DirectoryOptions::from_config(config, prefix.clone())?,
+            ..Default::default()
+        };
 
         for lookup_id in config.sub_keys((prefix.as_str(), "users")) {
             let name = config
                 .value_require((prefix.as_str(), "users", lookup_id, "name"))?
                 .to_string();
+            let mut typ = Type::Individual;
+            let mut member_of = Vec::new();
+
+            for (_, group) in config.values((prefix.as_str(), "users", lookup_id, "member-of")) {
+                if !group.eq_ignore_ascii_case(&directory.opt.superuser_group) {
+                    member_of.push(group.to_string());
+                } else {
+                    typ = Type::Superuser;
+                }
+            }
+
             directory.principals.insert(
                 name.clone(),
                 Principal {
@@ -26,17 +40,14 @@ impl MemoryDirectory {
                         .values((prefix.as_str(), "users", lookup_id, "secret"))
                         .map(|(_, v)| v.to_string())
                         .collect(),
-                    typ: Type::Individual,
+                    typ,
                     description: config
                         .value((prefix.as_str(), "users", lookup_id, "description"))
                         .map(|v| v.to_string()),
                     quota: config
                         .property((prefix.as_str(), "users", lookup_id, "quota"))?
                         .unwrap_or(0),
-                    member_of: config
-                        .values((prefix.as_str(), "users", lookup_id, "member-of"))
-                        .map(|(_, v)| v.to_string())
-                        .collect(),
+                    member_of,
                 },
             );
             let mut emails = Vec::new();
@@ -105,7 +116,6 @@ impl MemoryDirectory {
         directory
             .domains
             .extend(config.parse_lookup_list((&prefix, "lookup.domains"))?);
-        directory.opt = DirectoryOptions::from_config(config, prefix)?;
 
         Ok(Arc::new(directory))
     }

crates/directory/src/sql/lookup.rs

@@ -39,6 +39,16 @@ impl Directory for SqlDirectory {
                 .fetch_all(&self.pool)
                 .await?;
 
+            // Check whether the user is a superuser
+            if let Some(idx) = principal
+                .member_of
+                .iter()
+                .position(|group| group.eq_ignore_ascii_case(&self.opt.superuser_group))
+            {
+                principal.member_of.swap_remove(idx);
+                principal.typ = Type::Superuser;
+            }
+
             Ok(Some(principal))
         } else {
             Ok(None)

crates/imap/src/core/mailbox.rs

@@ -5,7 +5,6 @@ use imap_proto::{protocol::list::Attribute, StatusResponse};
 use jmap::{
     auth::{acl::EffectiveAcl, AccessToken},
     mailbox::INBOX_ID,
-    SUPERUSER_ID,
 };
 use jmap_proto::{
     object::Object,
@@ -43,31 +42,29 @@ impl SessionData {
 
         // Fetch shared mailboxes
         for &account_id in access_token.shared_accounts(Collection::Mailbox) {
-            if account_id != SUPERUSER_ID {
-                match session
-                    .fetch_account_mailboxes(
-                        account_id,
-                        format!(
-                            "{}/{}",
-                            session.imap.name_shared,
-                            session
-                                .jmap
-                                .get_account_name(account_id)
-                                .await
-                                .unwrap_or_default()
-                                .unwrap_or_else(|| Id::from(account_id).to_string())
-                        )
-                        .into(),
-                        access_token,
+            match session
+                .fetch_account_mailboxes(
+                    account_id,
+                    format!(
+                        "{}/{}",
+                        session.imap.name_shared,
+                        session
+                            .jmap
+                            .get_account_name(account_id)
+                            .await
+                            .unwrap_or_default()
+                            .unwrap_or_else(|| Id::from(account_id).to_string())
                     )
-                    .await
-                {
-                    Ok(account_mailboxes) => {
-                        mailboxes.push(account_mailboxes);
-                    }
-                    Err(_) => {
-                        tracing::warn!(parent: &session.span, account_id = account_id, event = "error", "Failed to retrieve mailboxes.");
-                    }
+                    .into(),
+                    access_token,
+                )
+                .await
+            {
+                Ok(account_mailboxes) => {
+                    mailboxes.push(account_mailboxes);
+                }
+                Err(_) => {
+                    tracing::warn!(parent: &session.span, account_id = account_id, event = "error", "Failed to retrieve mailboxes.");
                 }
             }
         }
@@ -305,11 +302,10 @@ impl SessionData {
 
                 // Add new shared account ids
                 for account_id in has_access_to {
-                    if account_id != SUPERUSER_ID
-                        && !new_accounts
-                            .iter()
-                            .skip(1)
-                            .any(|m| m.account_id == account_id)
+                    if !new_accounts
+                        .iter()
+                        .skip(1)
+                        .any(|m| m.account_id == account_id)
                     {
                         tracing::debug!(parent: &self.span, "Adding shared account {}", account_id);
                         added_account_ids.push(account_id);

crates/imap/src/lib.rs

@@ -42,14 +42,16 @@ impl IMAP {
                 })
                 .into_bytes(),
             rate_limiter: DashMap::with_capacity_and_hasher_and_shard_amount(
-                config.property("imap.rate-limit.size")?.unwrap_or(2048),
+                config
+                    .property("imap.rate-limit.cache.size")?
+                    .unwrap_or(2048),
                 RandomState::default(),
                 config
                     .property::<u64>("global.shared-map.shard")?
                     .unwrap_or(32)
                     .next_power_of_two() as usize,
             ),
-            rate_requests: config.property_or_static("imap.rate-limit", "1000/1m")?,
+            rate_requests: config.property_or_static("imap.rate-limit.requests", "2000/1m")?,
             rate_concurrent: config.property("imap.rate-limit.concurrent")?.unwrap_or(4),
             allow_plain_auth: config.property_or_static("imap.auth.allow-plain-text", "false")?,
         }))

crates/install/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "stalwart-install"
+description = "Stalwart Mail Server installer"
+authors = ["Stalwart Labs Ltd. <hello@stalw.art>"]
+license = "AGPL-3.0-only"
+repository = "https://github.com/stalwartlabs/mail-server"
+homepage = "https://github.com/stalwartlabs/mail-server"
+version = "0.3.0"
+edition = "2021"
+readme = "README.md"
+resolver = "2"
+
+[dependencies]
+reqwest = { version = "0.11", default-features = false, features = ["rustls-tls-webpki-roots"]}
+rusqlite = { version = "0.29.0", features = ["bundled"] }
+rpassword = "7.0"
+indicatif = "0.17.0"
+dialoguer = "0.10.4"
+openssl = { version = "0.10.55", features = ["vendored"] }
+base64 = "0.21.2"
+pwhash = "1.0.0"
+rand = "0.8.5"
+
+[target.'cfg(not(target_env = "msvc"))'.dependencies]
+libc = "0.2.147"