Add naming custom access methods

Just a bookkeeping feature for the end user

5 files changed, 100 insertions, 43 deletions

diff --git a/mullvad-cli/src/cmds/proxy.rs b/mullvad-cli/src/cmds/proxy.rs
index 74e0e22c22..507d5fa46d 100644
--- a/mullvad-cli/src/cmds/proxy.rs
+++ b/mullvad-cli/src/cmds/proxy.rs
@@ -130,9 +130,10 @@ impl Proxy {
                 let port = cmd.params.port.unwrap_or(shadowsocks.peer.port());
                 let password = cmd.params.password.unwrap_or(shadowsocks.password);
                 let cipher = cmd.params.cipher.unwrap_or(shadowsocks.cipher);
+                let name = cmd.params.name.unwrap_or(shadowsocks.name);
                 let enabled = shadowsocks.enabled;
                 mullvad_types::api_access_method::Shadowsocks::from_args(
-                    ip, port, cipher, password, enabled,
+                    ip, port, cipher, password, enabled, name,
                 )
                 .map(|x| x.into())
             }
@@ -141,18 +142,22 @@ impl Proxy {
                     let ip = cmd.params.ip.unwrap_or(local.peer.ip()).to_string();
                     let port = cmd.params.port.unwrap_or(local.peer.port());
                     let local_port = cmd.params.local_port.unwrap_or(local.port);
+                    let name = cmd.params.name.unwrap_or(local.name);
                     let enabled = local.enabled;
                     mullvad_types::api_access_method::Socks5Local::from_args(
-                        ip, port, local_port, enabled,
+                        ip, port, local_port, enabled, name,
                     )
                     .map(|x| x.into())
                 }
                 mullvad_types::api_access_method::Socks5::Remote(remote) => {
                     let ip = cmd.params.ip.unwrap_or(remote.peer.ip()).to_string();
                     let port = cmd.params.port.unwrap_or(remote.peer.port());
+                    let name = cmd.params.name.unwrap_or(remote.name);
                     let enabled = remote.enabled;
-                    mullvad_types::api_access_method::Socks5Remote::from_args(ip, port, enabled)
-                        .map(|x| x.into())
+                    mullvad_types::api_access_method::Socks5Remote::from_args(
+                        ip, port, enabled, name,
+                    )
+                    .map(|x| x.into())
                 }
             },
         }
@@ -207,6 +212,8 @@ pub enum AddCustomCommands {
 
     /// Configure bundled Shadowsocks proxy
     Shadowsocks {
+        /// An easy to remember name for this custom proxy
+        name: String,
         /// The IP of the remote Shadowsocks server
         remote_ip: IpAddr,
         /// The port of the remote Shadowsocks server
@@ -246,6 +253,8 @@ pub struct RemoveCustomCommands {
 pub enum Socks5AddCommands {
     /// Configure a local SOCKS5 proxy
     Local {
+        /// An easy to remember name for this custom proxy
+        name: String,
         /// The port that the server on localhost is listening on
         local_port: u16,
         /// The IP of the remote peer
@@ -255,6 +264,8 @@ pub enum Socks5AddCommands {
     },
     /// Configure a remote SOCKS5 proxy
     Remote {
+        /// An easy to remember name for this custom proxy
+        name: String,
         /// The IP of the remote proxy server
         remote_ip: IpAddr,
         /// The port of the remote proxy server
@@ -270,6 +281,9 @@ pub enum Socks5AddCommands {
 
 #[derive(Args, Debug, Clone)]
 pub struct EditParams {
+    /// Name of the API proxy in the Mullvad client [All]
+    #[arg(long)]
+    name: Option<String>,
     /// Username for authentication [Shadowsocks]
     #[arg(long)]
     username: Option<String>,
@@ -312,6 +326,7 @@ mod conversions {
                         local_port,
                         remote_ip,
                         remote_port,
+                        name,
                     } => {
                         println!("Adding LOCAL SOCKS5-proxy: localhost:{local_port} => {remote_ip}:{remote_port}");
                         let socks_proxy = daemon_types::Socks5::Local(
@@ -320,6 +335,7 @@ mod conversions {
                                 remote_port,
                                 local_port,
                                 enabled,
+                                name,
                             )
                             .ok_or(anyhow!("Could not create a local Socks5 api proxy"))?,
                         );
@@ -330,6 +346,7 @@ mod conversions {
                         remote_port,
                         username,
                         password,
+                        name,
                     } => {
                         println!("Adding REMOTE SOCKS5-proxy: {username:?}+{password:?} @ {remote_ip}:{remote_port}");
                         let socks_proxy = daemon_types::Socks5::Remote(
@@ -337,6 +354,7 @@ mod conversions {
                                 remote_ip.to_string(),
                                 remote_port,
                                 enabled,
+                                name,
                             )
                             .ok_or(anyhow!("Could not create a remote Socks5 api proxy"))?,
                         );
@@ -348,6 +366,7 @@ mod conversions {
                     remote_port,
                     password,
                     cipher,
+                    name,
                 } => {
                     println!(
                 "Adding Shadowsocks-proxy: {password} @ {remote_ip}:{remote_port} using {cipher}"
@@ -358,6 +377,7 @@ mod conversions {
                         cipher,
                         password,
                         enabled,
+                        name,
                     )
                     .ok_or(anyhow!("Could not create a Shadowsocks api proxy"))?;
                     shadowsocks_proxy.into()
diff --git a/mullvad-daemon/src/api.rs b/mullvad-daemon/src/api.rs
index 26974ed4ee..e8568ac684 100644
--- a/mullvad-daemon/src/api.rs
+++ b/mullvad-daemon/src/api.rs
@@ -138,7 +138,8 @@ impl ApiConnectionModeProvider {
                                     ss_settings.peer,
                                     ss_settings.cipher,
                                     ss_settings.password,
-                                    *enabled,
+                                    enabled,
+                                    "Mullvad Bridges".to_string(), // TODO: Move this to some central location
                                 );
                             Some(ApiConnectionMode::Proxied(ProxyConfig::Shadowsocks(
                                 ss_settings,
diff --git a/mullvad-management-interface/proto/management_interface.proto b/mullvad-management-interface/proto/management_interface.proto
index e008ca5e50..ffc3f12120 100644
--- a/mullvad-management-interface/proto/management_interface.proto
+++ b/mullvad-management-interface/proto/management_interface.proto
@@ -354,16 +354,18 @@ message ApiAccessMethod {
   message Bridges { bool enabled = 1; }
   message Socks5Local {
     bool enabled = 1;
-    string id = 2;
-    string ip = 3;
-    uint32 port = 4;
-    uint32 local_port = 5;
+    string name = 2;
+    string id = 3;
+    string ip = 4;
+    uint32 port = 5;
+    uint32 local_port = 6;
   }
   message Socks5Remote {
     bool enabled = 1;
-    string id = 2;
-    string ip = 3;
-    uint32 port = 4;
+    string name = 2;
+    string id = 3;
+    string ip = 4;
+    uint32 port = 5;
   }
   message Socks5 {
     oneof Socks5type {
@@ -373,11 +375,12 @@ message ApiAccessMethod {
   }
   message Shadowsocks {
     bool enabled = 1;
-    string id = 2;
-    string ip = 3;
-    uint32 port = 4;
-    string password = 5;
-    string cipher = 6;
+    string name = 2;
+    string id = 3;
+    string ip = 4;
+    uint32 port = 5;
+    string password = 6;
+    string cipher = 7;
   }
   oneof access_method {
     Direct direct = 1;
diff --git a/mullvad-management-interface/src/types/conversions/api_access_method.rs b/mullvad-management-interface/src/types/conversions/api_access_method.rs
index 0b944dd44d..958cbf0564 100644
--- a/mullvad-management-interface/src/types/conversions/api_access_method.rs
+++ b/mullvad-management-interface/src/types/conversions/api_access_method.rs
@@ -127,21 +127,25 @@ mod data {
                             local.port as u16,
                             local.local_port as u16,
                             local.enabled,
+                            local.name,
                         )
                         .ok_or(FromProtobufTypeError::InvalidArgument(
                             "Could not parse Socks5 (local) message from protobuf",
                         ))?
                         .into(),
 
-                        Socks5type::Remote(remote) => {
-                            Socks5Remote::from_args(remote.ip, remote.port as u16, remote.enabled)
-                                .ok_or({
-                                    FromProtobufTypeError::InvalidArgument(
-                                        "Could not parse Socks5 (remote) message from protobuf",
-                                    )
-                                })?
-                                .into()
-                        }
+                        Socks5type::Remote(remote) => Socks5Remote::from_args(
+                            remote.ip,
+                            remote.port as u16,
+                            remote.enabled,
+                            remote.name,
+                        )
+                        .ok_or({
+                            FromProtobufTypeError::InvalidArgument(
+                                "Could not parse Socks5 (remote) message from protobuf",
+                            )
+                        })?
+                        .into(),
                     }
                 }
                 proto::api_access_method::AccessMethod::Shadowsocks(ss) => Shadowsocks::from_args(
@@ -150,6 +154,7 @@ mod data {
                     ss.cipher,
                     ss.password,
                     ss.enabled,
+                    ss.name,
                 )
                 .ok_or(FromProtobufTypeError::InvalidArgument(
                     "Could not parse Shadowsocks message from protobuf",
@@ -176,6 +181,7 @@ mod data {
                         password: ss.password,
                         cipher: ss.cipher,
                         enabled: ss.enabled,
+                        name: ss.name,
                     }
                     .into(),
 
@@ -183,23 +189,28 @@ mod data {
                         peer,
                         port,
                         enabled,
+                        name,
                     })) => proto::api_access_method::Socks5Local {
                         id: value.id,
                         ip: peer.ip().to_string(),
                         port: peer.port() as u32,
                         local_port: port as u32,
                         enabled,
+                        name,
                     }
                     .into(),
-                    ObfuscationProtocol::Socks5(Socks5::Remote(Socks5Remote { peer, enabled })) => {
-                        proto::api_access_method::Socks5Remote {
-                            id: value.id,
-                            ip: peer.ip().to_string(),
-                            port: peer.port() as u32,
-                            enabled,
-                        }
-                        .into()
+                    ObfuscationProtocol::Socks5(Socks5::Remote(Socks5Remote {
+                        peer,
+                        enabled,
+                        name,
+                    })) => proto::api_access_method::Socks5Remote {
+                        id: value.id,
+                        ip: peer.ip().to_string(),
+                        port: peer.port() as u32,
+                        enabled,
+                        name,
                     }
+                    .into(),
                 },
                 AccessMethod::BuiltIn(value) => match value {
                     mullvad_types::api_access_method::BuiltInAccessMethod::Direct(enabled) => {
diff --git a/mullvad-types/src/api_access_method.rs b/mullvad-types/src/api_access_method.rs
index e3a423db7f..6aaec7171d 100644
--- a/mullvad-types/src/api_access_method.rs
+++ b/mullvad-types/src/api_access_method.rs
@@ -61,6 +61,7 @@ pub struct Shadowsocks {
     pub password: String, // TODO: Mask the password (using special type)?
     pub cipher: String,   // Gets validated at a later stage. Is assumed to be valid.
     pub enabled: bool,
+    pub name: String,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
@@ -69,12 +70,14 @@ pub struct Socks5Local {
     /// Port on localhost where the SOCKS5-proxy listens to.
     pub port: u16,
     pub enabled: bool,
+    pub name: String,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
 pub struct Socks5Remote {
     pub peer: SocketAddr,
     pub enabled: bool,
+    pub name: String,
 }
 
 impl Hash for Shadowsocks {
@@ -158,12 +161,19 @@ impl AccessMethod {
 }
 
 impl Shadowsocks {
-    pub fn new(peer: SocketAddr, cipher: String, password: String, enabled: bool) -> Self {
+    pub fn new(
+        peer: SocketAddr,
+        cipher: String,
+        password: String,
+        enabled: bool,
+        name: String,
+    ) -> Self {
         Shadowsocks {
             peer,
             password,
             cipher,
             enabled,
+            name,
         }
     }
 
@@ -175,41 +185,53 @@ impl Shadowsocks {
         cipher: String,
         password: String,
         enabled: bool,
+        name: String,
     ) -> Option<Self> {
         let peer = SocketAddrV4::new(Ipv4Addr::from_str(&ip).ok()?, port).into();
-        Some(Self::new(peer, cipher, password, enabled))
+        Some(Self::new(peer, cipher, password, enabled, name))
     }
 }
 
 impl Socks5Local {
-    pub fn new(peer: SocketAddr, port: u16, enabled: bool) -> Self {
+    pub fn new(peer: SocketAddr, port: u16, enabled: bool, name: String) -> Self {
         Self {
             peer,
             port,
             enabled,
+            name,
         }
     }
 
     /// Like [new()], but tries to parse `ip` and `port` into a [`std::net::SocketAddr`] for you.
     /// If `ip` or `port` are valid [`Some(Socks5Local)`] is returned, otherwise [`None`].
-    pub fn from_args(ip: String, port: u16, localport: u16, enabled: bool) -> Option<Self> {
+    pub fn from_args(
+        ip: String,
+        port: u16,
+        localport: u16,
+        enabled: bool,
+        name: String,
+    ) -> Option<Self> {
         let peer_ip = IpAddr::V4(Ipv4Addr::from_str(&ip).ok()?);
         let peer = SocketAddr::new(peer_ip, port);
-        Some(Self::new(peer, localport, enabled))
+        Some(Self::new(peer, localport, enabled, name))
     }
 }
 
 impl Socks5Remote {
-    pub fn new(peer: SocketAddr, enabled: bool) -> Self {
-        Self { peer, enabled }
+    pub fn new(peer: SocketAddr, enabled: bool, name: String) -> Self {
+        Self {
+            peer,
+            enabled,
+            name,
+        }
     }
 
     /// Like [new()], but tries to parse `ip` and `port` into a [`std::net::SocketAddr`] for you.
     /// If `ip` or `port` are valid [`Some(Socks5Remote)`] is returned, otherwise [`None`].
-    pub fn from_args(ip: String, port: u16, enabled: bool) -> Option<Self> {
+    pub fn from_args(ip: String, port: u16, enabled: bool, name: String) -> Option<Self> {
         let peer_ip = IpAddr::V4(Ipv4Addr::from_str(&ip).ok()?);
         let peer = SocketAddr::new(peer_ip, port);
-        Some(Self::new(peer, enabled))
+        Some(Self::new(peer, enabled, name))
     }
 }