Merge branch 'next/minor' of github.com:Start9Labs/start-os into next/major

core/startos/src/db/model/public.rs

@@ -1,28 +1,31 @@
 use std::collections::{BTreeMap, BTreeSet};
-use std::net::{Ipv4Addr, Ipv6Addr};
+use std::net::{IpAddr, Ipv4Addr};
 
 use chrono::{DateTime, Utc};
 use exver::{Version, VersionRange};
 use imbl_value::InternedString;
-use ipnet::{Ipv4Net, Ipv6Net};
+use ipnet::IpNet;
 use isocountry::CountryCode;
 use itertools::Itertools;
 use models::PackageId;
 use openssl::hash::MessageDigest;
 use patch_db::{HasModel, Value};
-use reqwest::Url;
 use serde::{Deserialize, Serialize};
-use torut::onion::OnionAddressV3;
 use ts_rs::TS;
 
 use crate::account::AccountInfo;
 use crate::db::model::package::AllPackageData;
-use crate::net::utils::{get_iface_ipv4_addr, get_iface_ipv6_addr};
+use crate::net::acme::AcmeProvider;
+use crate::net::host::binding::{AddSslOptions, BindInfo, BindOptions, NetInfo};
+use crate::net::host::Host;
+use crate::net::utils::ipv6_is_local;
+use crate::net::vhost::AlpnInfo;
 use crate::prelude::*;
 use crate::progress::FullProgress;
 use crate::system::SmtpValue;
 use crate::util::cpupower::Governor;
 use crate::util::lshw::LshwDevice;
+use crate::util::serde::MaybeUtf8String;
 use crate::version::{Current, VersionT};
 use crate::{ARCH, PLATFORM};
 
@@ -38,7 +41,6 @@ pub struct Public {
 }
 impl Public {
     pub fn init(account: &AccountInfo) -> Result<Self, Error> {
-        let lan_address = account.hostname.lan_address().parse().unwrap();
         Ok(Self {
             server_info: ServerInfo {
                 arch: get_arch(),
@@ -46,16 +48,44 @@ impl Public {
                 id: account.server_id.clone(),
                 version: Current::default().semver(),
                 hostname: account.hostname.no_dot_host_name(),
+                host: Host {
+                    bindings: [(
+                        80,
+                        BindInfo {
+                            enabled: false,
+                            options: BindOptions {
+                                preferred_external_port: 80,
+                                add_ssl: Some(AddSslOptions {
+                                    preferred_external_port: 443,
+                                    alpn: Some(AlpnInfo::Specified(vec![
+                                        MaybeUtf8String("http/1.1".into()),
+                                        MaybeUtf8String("h2".into()),
+                                    ])),
+                                }),
+                                secure: None,
+                            },
+                            net: NetInfo {
+                                assigned_port: None,
+                                assigned_ssl_port: Some(443),
+                                public: false,
+                            },
+                        },
+                    )]
+                    .into_iter()
+                    .collect(),
+                    onions: account
+                        .tor_keys
+                        .iter()
+                        .map(|k| k.public().get_onion_address())
+                        .collect(),
+                    domains: BTreeMap::new(),
+                    hostname_info: BTreeMap::new(),
+                },
                 last_backup: None,
                 package_version_compat: Current::default().compat().clone(),
                 post_init_migration_todos: BTreeSet::new(),
-                lan_address,
-                onion_address: account.tor_key.public().get_onion_address(),
-                tor_address: format!("https://{}", account.tor_key.public().get_onion_address())
-                    .parse()
-                    .unwrap(),
-                ip_info: BTreeMap::new(),
-                acme: None,
+                network_interfaces: BTreeMap::new(),
+                acme: BTreeMap::new(),
                 status_info: ServerStatus {
                     backup_progress: None,
                     updated: false,
@@ -115,6 +145,7 @@ pub struct ServerInfo {
     pub id: String,
     #[ts(type = "string")]
     pub hostname: InternedString,
+    pub host: Host,
     #[ts(type = "string")]
     pub version: Version,
     #[ts(type = "string")]
@@ -123,15 +154,11 @@ pub struct ServerInfo {
     pub post_init_migration_todos: BTreeSet<Version>,
     #[ts(type = "string | null")]
     pub last_backup: Option<DateTime<Utc>>,
-    #[ts(type = "string")]
-    pub lan_address: Url,
-    #[ts(type = "string")]
-    pub onion_address: OnionAddressV3,
-    /// for backwards compatibility
-    #[ts(type = "string")]
-    pub tor_address: Url,
-    pub ip_info: BTreeMap<String, IpInfo>,
-    pub acme: Option<AcmeSettings>,
+    #[ts(as = "BTreeMap::<String, NetworkInterfaceInfo>")]
+    #[serde(default)]
+    pub network_interfaces: BTreeMap<InternedString, NetworkInterfaceInfo>,
+    #[serde(default)]
+    pub acme: BTreeMap<AcmeProvider, AcmeSettings>,
     #[serde(default)]
     pub status_info: ServerStatus,
     pub wifi: WifiInfo,
@@ -151,43 +178,76 @@ pub struct ServerInfo {
     pub devices: Vec<LshwDevice>,
 }
 
-#[derive(Debug, Deserialize, Serialize, HasModel, TS)]
+#[derive(Clone, Debug, Default, Deserialize, Serialize, HasModel, TS)]
 #[serde(rename_all = "camelCase")]
 #[model = "Model<Self>"]
 #[ts(export)]
-pub struct IpInfo {
-    #[ts(type = "string | null")]
-    pub ipv4_range: Option<Ipv4Net>,
-    pub ipv4: Option<Ipv4Addr>,
-    #[ts(type = "string | null")]
-    pub ipv6_range: Option<Ipv6Net>,
-    pub ipv6: Option<Ipv6Addr>,
+pub struct NetworkInterfaceInfo {
+    pub public: Option<bool>,
+    pub ip_info: Option<IpInfo>,
 }
-impl IpInfo {
-    pub async fn for_interface(iface: &str) -> Result<Self, Error> {
-        let (ipv4, ipv4_range) = get_iface_ipv4_addr(iface).await?.unzip();
-        let (ipv6, ipv6_range) = get_iface_ipv6_addr(iface).await?.unzip();
-        Ok(Self {
-            ipv4_range,
-            ipv4,
-            ipv6_range,
-            ipv6,
+impl NetworkInterfaceInfo {
+    pub fn public(&self) -> bool {
+        self.public.unwrap_or_else(|| {
+            !self.ip_info.as_ref().map_or(true, |ip_info| {
+                let ip4s = ip_info
+                    .subnets
+                    .iter()
+                    .filter_map(|ipnet| {
+                        if let IpAddr::V4(ip4) = ipnet.addr() {
+                            Some(ip4)
+                        } else {
+                            None
+                        }
+                    })
+                    .collect::<BTreeSet<_>>();
+                if !ip4s.is_empty() {
+                    return ip4s.iter().all(|ip4| {
+                        ip4.is_loopback()
+                    || (ip4.is_private() && !ip4.octets().starts_with(&[10, 59])) // reserving 10.59 for public wireguard configurations
+                    || ip4.is_link_local()
+                    });
+                }
+                ip_info.subnets.iter().all(|ipnet| {
+                    if let IpAddr::V6(ip6) = ipnet.addr() {
+                        ipv6_is_local(ip6)
+                    } else {
+                        true
+                    }
+                })
+            })
         })
     }
 }
 
+#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Serialize, TS)]
+#[ts(export)]
+#[serde(rename_all = "camelCase")]
+pub struct IpInfo {
+    pub scope_id: u32,
+    pub device_type: Option<NetworkInterfaceType>,
+    #[ts(type = "string[]")]
+    pub subnets: BTreeSet<IpNet>,
+    pub wan_ip: Option<Ipv4Addr>,
+    #[ts(type = "string[]")]
+    pub ntp_servers: BTreeSet<InternedString>,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize, Serialize, TS)]
+#[ts(export)]
+#[serde(rename_all = "kebab-case")]
+pub enum NetworkInterfaceType {
+    Ethernet,
+    Wireless,
+    Wireguard,
+}
+
 #[derive(Debug, Deserialize, Serialize, HasModel, TS)]
 #[serde(rename_all = "camelCase")]
 #[model = "Model<Self>"]
 #[ts(export)]
 pub struct AcmeSettings {
-    #[ts(type = "string")]
-    pub provider: Url,
-    /// email addresses for letsencrypt
     pub contact: Vec<String>,
-    #[ts(type = "string[]")]
-    /// domains to get letsencrypt certs for
-    pub domains: BTreeSet<InternedString>,
 }
 
 #[derive(Debug, Default, Deserialize, Serialize, HasModel, TS)]