Revert misunderstanding and make the JSON a little friendlier

6 files changed, 79 insertions, 46 deletions

diff --git a/Cargo.lock b/Cargo.lock
index 1e8207732a..0e366f88c4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,11 +1,3 @@
-[root]
-name = "talpid-types"
-version = "0.1.0"
-dependencies = [
- "serde 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
- "serde_derive 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
 [[package]]
 name = "advapi32-sys"
 version = "0.2.0"
@@ -1275,6 +1267,14 @@ dependencies = [
 ]
 
 [[package]]
+name = "talpid-types"
+version = "0.1.0"
+dependencies = [
+ "serde 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+ "serde_derive 1.0.15 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
 name = "tempdir"
 version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
diff --git a/mullvad-cli/src/cmds/relay.rs b/mullvad-cli/src/cmds/relay.rs
index ddb5b8f1a6..68582562f9 100644
--- a/mullvad-cli/src/cmds/relay.rs
+++ b/mullvad-cli/src/cmds/relay.rs
@@ -1,10 +1,11 @@
 use {Command, Result};
 use clap;
 
-use rpc;
-
-use mullvad_types::relay_constraints::{RelayConstraints, HostConstraint, OpenVpnConstraintsUpdate, Port,
+use mullvad_types::relay_constraints::{HostConstraint, OpenVpnConstraintsUpdate, PortConstraint,
+                                       ProtocolConstraint, RelayConstraints,
                                        RelayConstraintsUpdate, TunnelConstraintsUpdate};
+
+use rpc;
 use talpid_types::net::TransportProtocol;
 
 pub struct Relay;
@@ -41,9 +42,7 @@ impl Command for Relay {
                             ),
                     ),
             )
-            .subcommand(
-                clap::SubCommand::with_name("get")
-            )
+            .subcommand(clap::SubCommand::with_name("get"))
     }
 
     fn run(&self, matches: &clap::ArgMatches) -> Result<()> {
@@ -85,8 +84,7 @@ impl Relay {
                 }),
             })
         } else if let Some(protocol_matches) = matches.subcommand_matches("protocol") {
-            let protocol =
-                value_t_or_exit!(protocol_matches.value_of("protocol"), TransportProtocol);
+            let protocol = parse_protocol(protocol_matches.value_of("protocol"))?;
 
             self.update_constraints(RelayConstraintsUpdate {
                 host: None,
@@ -108,14 +106,13 @@ impl Relay {
     }
 }
 
-
-fn parse_port(raw_port: Option<&str>) -> Result<Port> {
+fn parse_port(raw_port: Option<&str>) -> Result<PortConstraint> {
     if let Some(s) = raw_port {
         let res = u16::from_str_radix(s, 10);
         match res {
-            Ok(num) => Ok(Port::Port(num)),
+            Ok(num) => Ok(PortConstraint::Port(num)),
             Err(_) => if s.to_lowercase() == "any" {
-                Ok(Port::Any)
+                Ok(PortConstraint::Any)
             } else {
                 bail!("not 'any' or a short".to_owned())
             },
@@ -124,3 +121,15 @@ fn parse_port(raw_port: Option<&str>) -> Result<Port> {
         bail!("not 'any' or a short".to_owned())
     }
 }
+
+fn parse_protocol(raw_protocol: Option<&str>) -> Result<ProtocolConstraint> {
+    if let Some(s) = raw_protocol {
+        if s.to_lowercase() == "any" {
+            return Ok(ProtocolConstraint::Any);
+        } else if ["udp", "tcp"].contains(&s) {
+            return Ok(ProtocolConstraint::Protocol(TransportProtocol::Udp));
+        }
+    }
+
+    bail!("not 'udp' or 'tcp'".to_owned())
+}
diff --git a/mullvad-daemon/src/main.rs b/mullvad-daemon/src/main.rs
index 1f2b53babc..e4edb30527 100644
--- a/mullvad-daemon/src/main.rs
+++ b/mullvad-daemon/src/main.rs
@@ -49,7 +49,8 @@ use jsonrpc_core::futures::sync::oneshot::Sender as OneshotSender;
 use management_interface::{BoxFuture, ManagementInterfaceServer, TunnelCommand};
 use mullvad_rpc::{AccountsProxy, HttpHandle};
 use mullvad_types::account::{AccountData, AccountToken};
-use mullvad_types::relay_constraints::{RelayConstraints, HostConstraint, OpenVpnConstraints, Port,
+use mullvad_types::relay_constraints::{HostConstraint, OpenVpnConstraints, PortConstraint,
+                                       ProtocolConstraint, RelayConstraints,
                                        RelayConstraintsUpdate, TunnelConstraints};
 use mullvad_types::relay_endpoint::RelayEndpoint;
 use mullvad_types::states::{DaemonState, SecurityState, TargetState};
@@ -320,7 +321,7 @@ impl Daemon {
             GetAccount(tx) => Ok(self.on_get_account(tx)),
             UpdateRelayConstraints(tx, constraints_update) => {
                 self.on_update_relay_constraints(tx, constraints_update)
-            },
+            }
             GetRelayConstraints(tx) => Ok(self.on_get_relay_constraints(tx)),
             Shutdown => self.handle_trigger_shutdown_event(),
         }
@@ -403,7 +404,11 @@ impl Daemon {
     }
 
     fn on_get_relay_constraints(&self, tx: OneshotSender<RelayConstraints>) {
-        Self::oneshot_send(tx, self.settings.get_relay_constraints(), "relay constraints")
+        Self::oneshot_send(
+            tx,
+            self.settings.get_relay_constraints(),
+            "relay constraints",
+        )
     }
 
     fn oneshot_send<T>(tx: OneshotSender<T>, t: T, msg: &'static str) {
@@ -526,7 +531,7 @@ impl Daemon {
     fn get_relay(&mut self) -> Result<Endpoint> {
         let relay_constraints = self.settings.get_relay_constraints();
 
-        let host = match relay_constraints.host.unwrap_or(HostConstraint::Any) {
+        let host = match relay_constraints.host {
             HostConstraint::Any => format!("{}", self.relay_iter.next().unwrap().address),
             HostConstraint::Host(host) => host,
         };
@@ -541,11 +546,14 @@ impl Daemon {
         host: String,
         constraints: OpenVpnConstraints,
     ) -> Result<Endpoint> {
-        let protocol = constraints.protocol.unwrap_or(TransportProtocol::Udp);
+        let protocol = match constraints.protocol {
+            ProtocolConstraint::Any => TransportProtocol::Udp,
+            ProtocolConstraint::Protocol(protocol) => protocol,
+        };
 
-        let port = match constraints.port.unwrap_or(Port::Any) {
-            Port::Any => randomize_port(protocol),
-            Port::Port(port) => port,
+        let port = match constraints.port {
+            PortConstraint::Any => randomize_port(protocol),
+            PortConstraint::Port(port) => port,
         };
 
         RelayEndpoint {
diff --git a/mullvad-daemon/src/management_interface.rs b/mullvad-daemon/src/management_interface.rs
index 952ffbe65e..28b905390d 100644
--- a/mullvad-daemon/src/management_interface.rs
+++ b/mullvad-daemon/src/management_interface.rs
@@ -10,6 +10,8 @@ use jsonrpc_ws_server;
 use mullvad_rpc;
 use mullvad_types::account::{AccountData, AccountToken};
 use mullvad_types::location::{CountryCode, Location};
+
+use mullvad_types::relay_constraints::{RelayConstraints, RelayConstraintsUpdate};
 use mullvad_types::states::{DaemonState, TargetState};
 
 use serde;
@@ -19,8 +21,6 @@ use std::collections::hash_map::Entry;
 use std::net::{IpAddr, Ipv4Addr};
 use std::sync::{Arc, Mutex, RwLock};
 use std::sync::atomic::{AtomicBool, Ordering};
-
-use mullvad_types::relay_constraints::{RelayConstraints, RelayConstraintsUpdate};
 use talpid_core::mpsc::IntoSender;
 use talpid_ipc;
 use uuid;
@@ -307,7 +307,7 @@ impl<T: From<TunnelCommand> + 'static + Send> ManagementInterface<T> {
     }
 
     fn check_auth(&self, meta: &Meta) -> Result<(), Error> {
-        if true || meta.authenticated.load(Ordering::SeqCst) {
+        if meta.authenticated.load(Ordering::SeqCst) {
             trace!("auth success");
             Ok(())
         } else {
diff --git a/mullvad-daemon/src/settings.rs b/mullvad-daemon/src/settings.rs
index 280823ca94..d1a852c11d 100644
--- a/mullvad-daemon/src/settings.rs
+++ b/mullvad-daemon/src/settings.rs
@@ -3,7 +3,8 @@ extern crate serde_json;
 
 use self::app_dirs::{AppDataType, AppInfo};
 
-use mullvad_types::relay_constraints::{OpenVpnConstraints, RelayConstraints,
+use mullvad_types::relay_constraints::{HostConstraint, OpenVpnConstraints, PortConstraint,
+                                       ProtocolConstraint, RelayConstraints,
                                        RelayConstraintsUpdate, TunnelConstraints};
 use std::fs::File;
 use std::io;
@@ -51,10 +52,10 @@ impl Default for Settings {
 const DEFAULT_SETTINGS: Settings = Settings {
     account_token: None,
     relay_constraints: RelayConstraints {
-        host: None,
+        host: HostConstraint::Any,
         tunnel: TunnelConstraints::OpenVpn(OpenVpnConstraints {
-            port: None,
-            protocol: None,
+            port: PortConstraint::Any,
+            protocol: ProtocolConstraint::Any,
         }),
     },
 };
diff --git a/mullvad-types/src/relay_constraints.rs b/mullvad-types/src/relay_constraints.rs
index b09c11d98a..26a3a04f84 100644
--- a/mullvad-types/src/relay_constraints.rs
+++ b/mullvad-types/src/relay_constraints.rs
@@ -1,15 +1,16 @@
 use talpid_types::net::TransportProtocol;
 
 #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
 pub struct RelayConstraints {
-    pub host: Option<HostConstraint>,
+    pub host: HostConstraint,
     pub tunnel: TunnelConstraints,
 }
 
 impl RelayConstraints {
     pub fn merge(&mut self, update: RelayConstraintsUpdate) -> Self {
         RelayConstraints {
-            host: update.host.or_else(|| self.host.clone()),
+            host: update.host.unwrap_or_else(|| self.host.clone()),
             tunnel: self.tunnel.merge(update.tunnel),
         }
     }
@@ -17,8 +18,9 @@ impl RelayConstraints {
 
 
 #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
 pub enum TunnelConstraints {
-    OpenVpn(OpenVpnConstraints),
+    #[serde(rename = "openvpn")] OpenVpn(OpenVpnConstraints),
 }
 
 impl TunnelConstraints {
@@ -34,47 +36,60 @@ impl TunnelConstraints {
 }
 
 #[derive(Debug, Clone, Deserialize, Serialize, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
 pub struct OpenVpnConstraints {
-    pub port: Option<Port>,
-    pub protocol: Option<TransportProtocol>,
+    pub port: PortConstraint,
+    pub protocol: ProtocolConstraint,
 }
 
 impl OpenVpnConstraints {
     pub fn merge(&mut self, update: OpenVpnConstraintsUpdate) -> Self {
         OpenVpnConstraints {
-            port: update.port.or_else(|| self.port.clone()),
-            protocol: update.protocol.or(self.protocol),
+            port: update.port.unwrap_or_else(|| self.port.clone()),
+            protocol: update.protocol.unwrap_or_else(|| self.protocol.clone()),
         }
     }
 }
 
 
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
 pub struct RelayConstraintsUpdate {
     pub host: Option<HostConstraint>,
     pub tunnel: TunnelConstraintsUpdate,
 }
 
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
 pub enum TunnelConstraintsUpdate {
-    OpenVpn(OpenVpnConstraintsUpdate),
+    #[serde(rename = "openvpn")] OpenVpn(OpenVpnConstraintsUpdate),
 }
 
 #[derive(Debug, Deserialize, Serialize)]
+#[serde(rename_all = "snake_case")]
 pub struct OpenVpnConstraintsUpdate {
-    pub port: Option<Port>,
-    pub protocol: Option<TransportProtocol>,
+    pub port: Option<PortConstraint>,
+    pub protocol: Option<ProtocolConstraint>,
 }
 
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
 pub enum HostConstraint {
     Any,
     Host(String),
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
-pub enum Port {
+#[serde(rename_all = "snake_case")]
+pub enum PortConstraint {
     Any,
     Port(u16),
 }
+
+#[derive(Debug, Clone, Serialize, Deserialize, Eq, PartialEq)]
+#[serde(rename_all = "snake_case")]
+pub enum ProtocolConstraint {
+    Any,
+    Protocol(TransportProtocol),
+}