Prefix remote `ip` and `port` with `remote_` in Socks5Local contexts

6 files changed, 57 insertions, 38 deletions

diff --git a/mullvad-api/src/https_client_with_sni.rs b/mullvad-api/src/https_client_with_sni.rs
index 17d9f7f0d8..7d559faa7a 100644
--- a/mullvad-api/src/https_client_with_sni.rs
+++ b/mullvad-api/src/https_client_with_sni.rs
@@ -255,7 +255,10 @@ impl TryFrom<ApiConnectionMode> for InnerConnectionMode {
                 ProxyConfig::Socks(config) => match config {
                     access_method::Socks5::Local(config) => {
                         InnerConnectionMode::Socks5(SocksConfig {
-                            peer: SocketAddr::new(IpAddr::from(Ipv4Addr::LOCALHOST), config.port),
+                            peer: SocketAddr::new(
+                                IpAddr::from(Ipv4Addr::LOCALHOST),
+                                config.local_port,
+                            ),
                             authentication: SocksAuth::None,
                         })
                     }
diff --git a/mullvad-api/src/proxy.rs b/mullvad-api/src/proxy.rs
index 44a2309587..3193fdc19b 100644
--- a/mullvad-api/src/proxy.rs
+++ b/mullvad-api/src/proxy.rs
@@ -46,7 +46,7 @@ impl ProxyConfig {
         match self {
             ProxyConfig::Shadowsocks(ss) => ss.peer,
             ProxyConfig::Socks(socks) => match socks {
-                access_method::Socks5::Local(s) => s.peer,
+                access_method::Socks5::Local(s) => s.remote_peer,
                 access_method::Socks5::Remote(s) => s.peer,
             },
         }
@@ -60,7 +60,11 @@ impl fmt::Display for ProxyConfig {
             ProxyConfig::Shadowsocks(ss) => write!(f, "Shadowsocks {}/TCP", ss.peer),
             ProxyConfig::Socks(socks) => match socks {
                 access_method::Socks5::Local(s) => {
-                    write!(f, "Socks5 {}/TCP via localhost:{}", s.peer, s.port)
+                    write!(
+                        f,
+                        "Socks5 {}/TCP via localhost:{}",
+                        s.remote_peer, s.local_port
+                    )
                 }
                 access_method::Socks5::Remote(s) => write!(f, "Socks5 {}/TCP", s.peer),
             },
diff --git a/mullvad-cli/src/cmds/api_access.rs b/mullvad-cli/src/cmds/api_access.rs
index dc736c71c6..c5707a7276 100644
--- a/mullvad-cli/src/cmds/api_access.rs
+++ b/mullvad-cli/src/cmds/api_access.rs
@@ -116,11 +116,15 @@ impl ApiAccess {
                 }
                 CustomAccessMethod::Socks5(socks) => match socks {
                     mullvad_types::access_method::Socks5::Local(local) => {
-                        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);
-                        mullvad_types::access_method::Socks5Local::from_args(ip, port, local_port)
-                            .map(AccessMethod::from)
+                        let remote_ip = cmd.params.ip.unwrap_or(local.remote_peer.ip()).to_string();
+                        let remote_port = cmd.params.port.unwrap_or(local.remote_peer.port());
+                        let local_port = cmd.params.local_port.unwrap_or(local.local_port);
+                        mullvad_types::access_method::Socks5Local::from_args(
+                            remote_ip,
+                            remote_port,
+                            local_port,
+                        )
+                        .map(AccessMethod::from)
                     }
                     mullvad_types::access_method::Socks5::Remote(remote) => {
                         let ip = cmd.params.ip.unwrap_or(remote.peer.ip()).to_string();
@@ -223,9 +227,8 @@ impl ApiAccess {
                 rpc.set_access_method(previous_access_method.get_id())
                     .await?;
                 return Err(anyhow!(
-                    "Could not reach the Mullvad API using access method \"{}\". Rolling back to \"{}\"",
+                    "Could not reach the Mullvad API using access method \"{}\"",
                     new_access_method.get_name(),
-                    previous_access_method.get_name()
                 ));
             }
         };
@@ -586,8 +589,8 @@ mod pp {
                             }
                             writeln!(f)?;
                             print_option!("Protocol", "Socks5 (local)");
-                            print_option!("Peer", local.peer);
-                            print_option!("Local port", local.port);
+                            print_option!("Peer", local.remote_peer);
+                            print_option!("Local port", local.local_port);
                             Ok(())
                         }
                     },
diff --git a/mullvad-management-interface/proto/management_interface.proto b/mullvad-management-interface/proto/management_interface.proto
index 35417584b3..057718bdb1 100644
--- a/mullvad-management-interface/proto/management_interface.proto
+++ b/mullvad-management-interface/proto/management_interface.proto
@@ -333,8 +333,8 @@ message AccessMethod {
   message Direct {}
   message Bridges {}
   message Socks5Local {
-    string ip = 1;
-    uint32 port = 2;
+    string remote_ip = 1;
+    uint32 remote_port = 2;
     uint32 local_port = 3;
   }
   message SocksAuth {
diff --git a/mullvad-management-interface/src/types/conversions/access_method.rs b/mullvad-management-interface/src/types/conversions/access_method.rs
index 8907c4da29..40a9629070 100644
--- a/mullvad-management-interface/src/types/conversions/access_method.rs
+++ b/mullvad-management-interface/src/types/conversions/access_method.rs
@@ -142,11 +142,15 @@ mod data {
         type Error = FromProtobufTypeError;
 
         fn try_from(value: proto::access_method::Socks5Local) -> Result<Self, Self::Error> {
-            Socks5Local::from_args(value.ip, value.port as u16, value.local_port as u16)
-                .ok_or(FromProtobufTypeError::InvalidArgument(
-                    "Could not parse Socks5 (local) message from protobuf",
-                ))
-                .map(AccessMethod::from)
+            Socks5Local::from_args(
+                value.remote_ip,
+                value.remote_port as u16,
+                value.local_port as u16,
+            )
+            .ok_or(FromProtobufTypeError::InvalidArgument(
+                "Could not parse Socks5 (local) message from protobuf",
+            ))
+            .map(AccessMethod::from)
         }
     }
 
@@ -216,15 +220,16 @@ mod data {
                         },
                     )
                 }
-                CustomAccessMethod::Socks5(Socks5::Local(Socks5Local { peer, port })) => {
-                    proto::access_method::AccessMethod::Socks5local(
-                        proto::access_method::Socks5Local {
-                            ip: peer.ip().to_string(),
-                            port: peer.port() as u32,
-                            local_port: port as u32,
-                        },
-                    )
-                }
+                CustomAccessMethod::Socks5(Socks5::Local(Socks5Local {
+                    remote_peer: peer,
+                    local_port: port,
+                })) => proto::access_method::AccessMethod::Socks5local(
+                    proto::access_method::Socks5Local {
+                        remote_ip: peer.ip().to_string(),
+                        remote_port: peer.port() as u32,
+                        local_port: port as u32,
+                    },
+                ),
                 CustomAccessMethod::Socks5(Socks5::Remote(Socks5Remote {
                     peer,
                     authentication,
diff --git a/mullvad-types/src/access_method.rs b/mullvad-types/src/access_method.rs
index 249c097ba1..5473837bb2 100644
--- a/mullvad-types/src/access_method.rs
+++ b/mullvad-types/src/access_method.rs
@@ -205,9 +205,9 @@ pub struct Shadowsocks {
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
 pub struct Socks5Local {
-    pub peer: SocketAddr,
+    pub remote_peer: SocketAddr,
     /// Port on localhost where the SOCKS5-proxy listens to.
-    pub port: u16,
+    pub local_port: u16,
 }
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq, Hash)]
@@ -258,16 +258,20 @@ impl Shadowsocks {
 }
 
 impl Socks5Local {
-    pub fn new(peer: SocketAddr, port: u16) -> Self {
-        Self { peer, port }
+    pub fn new(remote_peer: SocketAddr, local_port: u16) -> Self {
+        Self {
+            remote_peer,
+            local_port,
+        }
     }
 
-    /// 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) -> Option<Self> {
-        let peer_ip = IpAddr::V4(Ipv4Addr::from_str(&ip).ok()?);
-        let peer = SocketAddr::new(peer_ip, port);
-        Some(Self::new(peer, localport))
+    /// Like [new()], but tries to parse `remote_ip` and `remote_port` into a
+    /// [`std::net::SocketAddr`] for you. If `remote_ip` or `remote_port` are
+    /// valid [`Some(Socks5Local)`] is returned, otherwise [`None`].
+    pub fn from_args(remote_ip: String, remote_port: u16, local_port: u16) -> Option<Self> {
+        let peer_ip = IpAddr::V4(Ipv4Addr::from_str(&remote_ip).ok()?);
+        let remote_peer = SocketAddr::new(peer_ip, remote_port);
+        Some(Self::new(remote_peer, local_port))
     }
 }