fix(dgw)!: clean up /jet/net/config route (#1387)

The JSON output of the `/jet/net/config` route is changed to be more
convenient in the consumer code.

Previous output example:
```
[
  {
    "name": "vboxnet0",
    "addresses": [
      {
        "V4": {
          "ip": "192.168.56.1",
          "broadcast": "192.168.56.255",
          "netmask": "255.255.255.0"
        }
      },
      {
        "V6": {
          "ip": "fe80::800:27ff:fe00:0",
          "netmask": "ffff:ffff:ffff:ffff::"
        }
      }
    ],
    "mac_addr": "0a:00:27:00:00:00",
    "index": 4
  }
]
```

New output example:

```
{
  "vboxnet0": [
    {
      "family": "IPv4",
      "address": "192.168.56.1",
      "broadcast": "192.168.56.255",
      "netmask": "255.255.255.0",
      "mac": "0a:00:27:00:00:00"
    },
    {
      "family": "IPv6",
      "address": "fe80::800:27ff:fe00:0",
      "netmask": "ffff:ffff:ffff:ffff::",
      "mac": "0a:00:27:00:00:00"
    }
  ]
}
```

Issue: DGW-287

Author: CBenoit

devolutions-gateway/src/api/net.rs

@@ -1,7 +1,7 @@
-use crate::extract::RepeatQuery;
-use crate::http::HttpError;
-use crate::token::Protocol;
-use crate::DgwState;
+use std::collections::HashMap;
+use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
+use std::time::Duration;
+
 use axum::extract::ws::{Message, Utf8Bytes};
 use axum::extract::WebSocketUpgrade;
 use axum::response::Response;
@@ -16,9 +16,11 @@ use network_scanner::ping::PingEvent;
 use network_scanner::port_discovery::TcpKnockEvent;
 use network_scanner::scanner::{self, DnsEvent, NetworkScannerParams, ScannerConfig, TcpKnockWithHost};
 use serde::{Deserialize, Serialize};
-use std::fmt;
-use std::net::{IpAddr, Ipv4Addr, Ipv6Addr};
-use std::time::Duration;
+
+use crate::extract::RepeatQuery;
+use crate::http::HttpError;
+use crate::token::Protocol;
+use crate::DgwState;
 
 pub fn make_router<S>(state: DgwState) -> Router<S> {
     let router = Router::new()
@@ -469,109 +471,77 @@ impl EventFilter {
     tag = "Net",
     path = "/jet/net/config",
     responses(
-        (status = 200, description = "Network interfaces", body = [Vec<NetworkInterface>]),
+        (status = 200, description = "Network interfaces", body = [HashMap<String, Vec<InterfaceInfo>>]),
         (status = 400, description = "Bad request"),
         (status = 401, description = "Invalid or missing authorization token"),
         (status = 403, description = "Insufficient permissions"),
         (status = 500, description = "Unexpected server error"),
     ),
     security(("netscan_token" = [])),
 ))]
-pub async fn get_net_config(_token: crate::extract::NetScanToken) -> Result<Json<Vec<NetworkInterface>>, HttpError> {
-    let interfaces = interfaces::get_network_interfaces()
-        .map_err(HttpError::internal().with_msg("failed to get network interfaces").err())?
-        .into_iter()
-        .map(NetworkInterface::from)
-        .collect();
-
-    Ok(Json(interfaces))
-}
+pub(crate) async fn get_net_config(
+    _token: crate::extract::NetScanToken,
+) -> Result<Json<HashMap<String, Vec<InterfaceInfo>>>, HttpError> {
+    let net_ifaces = interfaces::get_network_interfaces()
+        .map_err(HttpError::internal().with_msg("failed to get network interfaces").err())?;
 
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Debug, Clone, Serialize)]
-pub struct NetworkInterface {
-    pub name: String,
-    #[serde(rename = "addresses")]
-    pub addrs: Vec<Addr>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub mac_addr: Option<String>,
-    pub index: u32,
-}
+    let mut interface_map = HashMap::new();
 
-/// Network interface address
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub enum Addr {
-    V4(V4IfAddr),
-    V6(V6IfAddr),
-}
-
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub struct Netmask<T>(pub T);
+    for iface in net_ifaces {
+        let addresses: Vec<InterfaceInfo> = iface
+            .addr
+            .into_iter()
+            .map(|addr| match addr {
+                interfaces::Addr::V4(addr) => InterfaceInfo {
+                    address: IfAddress::V4 {
+                        address: addr.ip,
+                        broadcast: addr.broadcast,
+                        netmask: addr.netmask,
+                    },
+                    mac: iface.mac_addr.clone(),
+                },
+                interfaces::Addr::V6(addr) => InterfaceInfo {
+                    address: IfAddress::V6 {
+                        address: addr.ip,
+                        broadcast: addr.broadcast,
+                        netmask: addr.netmask,
+                    },
+                    mac: iface.mac_addr.clone(),
+                },
+            })
+            .collect();
 
-impl<T: fmt::Display> fmt::Display for Netmask<T> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
+        interface_map.insert(iface.name, addresses);
     }
-}
 
-impl<T> Serialize for Netmask<T>
-where
-    T: Serialize,
-{
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        self.0.serialize(serializer)
-    }
+    Ok(Json(interface_map))
 }
 
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct V4IfAddr {
-    pub ip: Ipv4Addr,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub broadcast: Option<Ipv4Addr>,
+#[derive(Debug, Clone, Serialize)]
+pub(crate) struct InterfaceInfo {
+    #[serde(flatten)]
+    address: IfAddress,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub netmask: Option<Netmask<Ipv4Addr>>,
+    mac: Option<String>,
 }
 
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize)]
-pub struct V6IfAddr {
-    pub ip: Ipv6Addr,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub broadcast: Option<Ipv6Addr>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub netmask: Option<Netmask<Ipv6Addr>>,
-}
-
-impl From<interfaces::NetworkInterface> for NetworkInterface {
-    fn from(iface: interfaces::NetworkInterface) -> Self {
-        let addr = iface
-            .addr
-            .into_iter()
-            .map(|addr| match addr {
-                interfaces::Addr::V4(v4) => Addr::V4(V4IfAddr {
-                    ip: v4.ip,
-                    broadcast: v4.broadcast,
-                    netmask: v4.netmask.map(Netmask),
-                }),
-                interfaces::Addr::V6(v6) => Addr::V6(V6IfAddr {
-                    ip: v6.ip,
-                    broadcast: v6.broadcast,
-                    netmask: v6.netmask.map(Netmask),
-                }),
-            })
-            .collect();
-
-        NetworkInterface {
-            name: iface.name,
-            mac_addr: iface.mac_addr,
-            addrs: addr,
-            index: iface.index,
-        }
-    }
+#[serde(tag = "family")]
+enum IfAddress {
+    #[serde(rename = "IPv4")]
+    V4 {
+        address: Ipv4Addr,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        broadcast: Option<Ipv4Addr>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        netmask: Option<Ipv4Addr>,
+    },
+    #[serde(rename = "IPv6")]
+    V6 {
+        address: Ipv6Addr,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        broadcast: Option<Ipv6Addr>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        netmask: Option<Ipv6Addr>,
+    },
 }

devolutions-gateway/src/openapi.rs

@@ -26,7 +26,7 @@ use crate::api::preflight::PreflightAlertStatus;
         crate::api::webapp::sign_session_token,
         crate::api::update::trigger_update_check,
         crate::api::preflight::post_preflight,
-        // crate::api::net::get_net_config,
+        crate::api::net::get_net_config,
     ),
     components(schemas(
         crate::api::health::Identity,
@@ -54,9 +54,10 @@ use crate::api::preflight::PreflightAlertStatus;
         PreflightOutput,
         PreflightOutputKind,
         PreflightAlertStatus,
-        // crate::api::net::NetworkInterface,
         SessionTokenContentType,
         SessionTokenSignRequest,
+        InterfaceInfo,
+        AddressFamily,
     )),
     modifiers(&SecurityAddon),
 )]
@@ -347,8 +348,7 @@ enum PreflightOperationKind {
 }
 
 #[allow(unused)]
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Deserialize)]
+#[derive(Deserialize, utoipa::ToSchema)]
 struct AppCredential {
     /// The kind of credentials.
     kind: AppCredentialKind,
@@ -362,15 +362,13 @@ struct AppCredential {
     password: Option<String>,
 }
 
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Deserialize)]
+#[derive(Deserialize, utoipa::ToSchema)]
 enum AppCredentialKind {
     #[serde(rename = "username-password")]
     UsernamePassword,
 }
 
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Serialize)]
+#[derive(Serialize, utoipa::ToSchema)]
 pub(crate) struct PreflightOutput {
     /// The ID of the preflight operation associated to this result.
     operation_id: Uuid,
@@ -419,8 +417,7 @@ pub(crate) struct PreflightOutput {
 }
 
 #[allow(unused)]
-#[cfg_attr(feature = "openapi", derive(utoipa::ToSchema))]
-#[derive(Serialize)]
+#[derive(Serialize, utoipa::ToSchema)]
 pub(crate) enum PreflightOutputKind {
     #[serde(rename = "version")]
     Version,
@@ -435,3 +432,21 @@ pub(crate) enum PreflightOutputKind {
     #[serde(rename = "alert")]
     Alert,
 }
+
+#[derive(Serialize, utoipa::ToSchema)]
+struct InterfaceInfo {
+    family: AddressFamily,
+    address: String,
+    broadcast: Option<String>,
+    netmask: Option<String>,
+    mac: Option<String>,
+}
+
+#[allow(unused)]
+#[derive(Serialize, utoipa::ToSchema)]
+enum AddressFamily {
+    #[serde(rename = "IPv4")]
+    V4,
+    #[serde(rename = "IPv6")]
+    V6,
+}