Add reason to transition to blocked state

5 files changed, 66 insertions, 16 deletions

diff --git a/gui/packages/desktop/src/renderer/app.js b/gui/packages/desktop/src/renderer/app.js
index 5c4847d76a..e3ed3f78ef 100644
--- a/gui/packages/desktop/src/renderer/app.js
+++ b/gui/packages/desktop/src/renderer/app.js
@@ -504,7 +504,11 @@ export default class AppRenderer {
       if (newState) {
         const connectionState = this._tunnelStateToConnectionState(newState);
 
-        log.debug(`Got new state from daemon '${newState}', translated to '${connectionState}'`);
+        log.debug(
+          `Got new state from daemon '${JSON.stringify(
+            newState,
+          )}', translated to '${connectionState}'`,
+        );
 
         this._updateConnectionState(connectionState);
         this._refreshStateOnChange();
@@ -546,7 +550,7 @@ export default class AppRenderer {
   }
 
   _tunnelStateToConnectionState(tunnelState: TunnelState): ConnectionState {
-    switch (tunnelState) {
+    switch (tunnelState.state) {
       case 'disconnected':
       // Fall through
       case 'disconnecting':
diff --git a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
index 5dcf041dcd..1578b04638 100644
--- a/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
+++ b/gui/packages/desktop/src/renderer/lib/daemon-rpc.js
@@ -41,7 +41,29 @@ const LocationSchema = object({
   mullvad_exit_ip: boolean,
 });
 
-export type TunnelState = 'disconnected' | 'connecting' | 'connected' | 'disconnecting' | 'blocked';
+export type BlockReason = string;
+export type DisconnectedState = {
+  state: 'disconnected',
+};
+export type ConnectingState = {
+  state: 'connecting',
+};
+export type ConnectedState = {
+  state: 'connected',
+};
+export type DisconnectingState = {
+  state: 'disconnecting',
+};
+export type BlockedState = {
+  state: 'blocked',
+  details: BlockReason,
+};
+export type TunnelState =
+  | DisconnectedState
+  | ConnectingState
+  | ConnectedState
+  | DisconnectingState
+  | BlockedState;
 
 export type RelayProtocol = 'tcp' | 'udp';
 export type RelayLocation = {| city: [string, string] |} | {| country: string |};
@@ -196,14 +218,22 @@ const AccountDataSchema = object({
   expiry: string,
 });
 
-const allTunnelStates: Array<TunnelState> = [
-  'disconnected',
-  'connecting',
-  'connected',
-  'disconnecting',
-  'blocked',
-];
-const TunnelStateSchema = enumeration(...allTunnelStates);
+const BlockedStateSchema = object({
+  state: enumeration('blocked'),
+  details: string,
+});
+const ConnectedStateSchema = object({ state: enumeration('connected') });
+const ConnectingStateSchema = object({ state: enumeration('connecting') });
+const DisconnectedStateSchema = object({ state: enumeration('disconnected') });
+const DisconnectingStateSchema = object({ state: enumeration('disconnecting') });
+
+const TunnelStateSchema = oneOf(
+  BlockedStateSchema,
+  ConnectedStateSchema,
+  ConnectingStateSchema,
+  DisconnectedStateSchema,
+  DisconnectingStateSchema,
+);
 
 export type AppVersionInfo = {
   currentIsSupported: boolean,
diff --git a/mullvad-cli/src/cmds/status.rs b/mullvad-cli/src/cmds/status.rs
index bdc308892e..1266299c17 100644
--- a/mullvad-cli/src/cmds/status.rs
+++ b/mullvad-cli/src/cmds/status.rs
@@ -43,7 +43,7 @@ impl Command for Status {
 fn print_state(state: TunnelStateTransition) {
     print!("Tunnel status: ");
     match state {
-        Blocked => println!("Blocked"),
+        Blocked(reason) => println!("Blocked ({})", reason),
         Connected => println!("Connected"),
         Connecting => println!("Connecting..."),
         Disconnected => println!("Disconnected"),
diff --git a/talpid-core/src/tunnel_state_machine/blocked_state.rs b/talpid-core/src/tunnel_state_machine/blocked_state.rs
index f4499c7b58..f63326b800 100644
--- a/talpid-core/src/tunnel_state_machine/blocked_state.rs
+++ b/talpid-core/src/tunnel_state_machine/blocked_state.rs
@@ -1,6 +1,8 @@
 use futures::sync::mpsc;
 use futures::Stream;
 
+use talpid_types::tunnel::BlockReason;
+
 use super::{
     ConnectingState, DisconnectedState, EventConsequence, SharedTunnelStateValues, TunnelCommand,
     TunnelState, TunnelStateTransition, TunnelStateWrapper,
@@ -10,15 +12,15 @@ use super::{
 pub struct BlockedState;
 
 impl TunnelState for BlockedState {
-    type Bootstrap = ();
+    type Bootstrap = BlockReason;
 
     fn enter(
         _: &mut SharedTunnelStateValues,
-        _: Self::Bootstrap,
+        block_reason: Self::Bootstrap,
     ) -> (TunnelStateWrapper, TunnelStateTransition) {
         (
             TunnelStateWrapper::from(BlockedState),
-            TunnelStateTransition::Blocked,
+            TunnelStateTransition::Blocked(block_reason),
         )
     }
 
diff --git a/talpid-types/src/tunnel.rs b/talpid-types/src/tunnel.rs
index ce94b43685..59ee2499cd 100644
--- a/talpid-types/src/tunnel.rs
+++ b/talpid-types/src/tunnel.rs
@@ -1,6 +1,9 @@
+use std::fmt;
+
 /// Event resulting from a transition to a new tunnel state.
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "snake_case")]
+#[serde(tag = "state", content = "details")]
 pub enum TunnelStateTransition {
     /// No connection is established and network is unsecured.
     Disconnected,
@@ -11,5 +14,16 @@ pub enum TunnelStateTransition {
     /// Disconnecting tunnel.
     Disconnecting,
     /// Tunnel is disconnected but secured by blocking all connections.
-    Blocked,
+    Blocked(BlockReason),
+}
+
+/// Reason for entering the blocked state.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+pub enum BlockReason {}
+
+impl fmt::Display for BlockReason {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        Ok(())
+    }
 }