Adjust GUI code to new TunnelEndpoint type

8 files changed, 123 insertions, 115 deletions

diff --git a/gui/packages/desktop/src/main/daemon-rpc.js b/gui/packages/desktop/src/main/daemon-rpc.js
index 000dc544b9..6b3ec60135 100644
--- a/gui/packages/desktop/src/main/daemon-rpc.js
+++ b/gui/packages/desktop/src/main/daemon-rpc.js
@@ -53,12 +53,32 @@ const constraint = <T>(constraintValue: SchemaNode<T>) => {
   );
 };
 
-const TunnelEndpointDataSchema = partialObject({
-  openvpn: partialObject({
-    port: number,
-    protocol: enumeration('udp', 'tcp'),
+const CustomTunnelEndpoint = oneOf(
+  object({
+    openvpn: object({
+      endpoint: object({
+        address: string,
+        protocol: enumeration('udp', 'tcp'),
+      }),
+      username: string,
+      password: string,
+    }),
   }),
-});
+  object({
+    wireguard: object({
+      tunnel: object({
+        private_key: string,
+        addresses: arrayOf(string),
+      }),
+      peer: object({
+        public_key: string,
+        allowed_ips: arrayOf(string),
+        endpoint: string,
+      }),
+      gateway: string,
+    }),
+  }),
+);
 
 const RelaySettingsSchema = oneOf(
   object({
@@ -89,7 +109,7 @@ const RelaySettingsSchema = oneOf(
   object({
     custom_tunnel_endpoint: partialObject({
       host: string,
-      tunnel: TunnelEndpointDataSchema,
+      config: CustomTunnelEndpoint,
     }),
   }),
 );
@@ -142,11 +162,18 @@ const OpenVpnProxySchema = maybe(
 );
 
 const TunnelOptionsSchema = partialObject({
-  enable_ipv6: boolean,
   openvpn: partialObject({
     mssfix: maybe(number),
     proxy: OpenVpnProxySchema,
   }),
+  wireguard: partialObject({
+    mtu: maybe(number),
+    // only relevant on linux
+    fmwark: maybe(number),
+  }),
+  generic: partialObject({
+    enable_ipv6: boolean,
+  }),
 });
 
 const AccountDataSchema = partialObject({
@@ -162,7 +189,8 @@ const TunnelStateTransitionSchema = oneOf(
     state: enumeration('connecting', 'connected'),
     details: partialObject({
       address: string,
-      tunnel: TunnelEndpointDataSchema,
+      protocol: enumeration('tcp', 'udp'),
+      tunnel_type: enumeration('wireguard', 'openvpn'),
     }),
   }),
   object({
diff --git a/gui/packages/desktop/src/main/index.js b/gui/packages/desktop/src/main/index.js
index 4d20e98d0a..d13956cbc5 100644
--- a/gui/packages/desktop/src/main/index.js
+++ b/gui/packages/desktop/src/main/index.js
@@ -77,11 +77,17 @@ const ApplicationMain = {
       },
     },
     tunnelOptions: {
-      enableIpv6: false,
+      generic: {
+        enableIpv6: false,
+      },
       openvpn: {
         mssfix: null,
+        proxy: null,
+      },
+      wireguard: {
+        mtu: null,
+        fwmark: null,
       },
-      proxy: null,
     },
   }: Settings),
   _guiSettings: new GuiSettings(),
diff --git a/gui/packages/desktop/src/renderer/app.js b/gui/packages/desktop/src/renderer/app.js
index afea9e9651..280c815ba8 100644
--- a/gui/packages/desktop/src/renderer/app.js
+++ b/gui/packages/desktop/src/renderer/app.js
@@ -30,6 +30,7 @@ import { IpcRendererEventChannel } from '../shared/ipc-event-channel';
 import type {
   AccountToken,
   AccountData,
+  ConnectionConfig,
   Location,
   RelayList,
   RelaySettingsUpdate,
@@ -274,12 +275,19 @@ export default class AppRenderer {
       });
     } else if (relaySettings.customTunnelEndpoint) {
       const customTunnelEndpoint = relaySettings.customTunnelEndpoint;
-      const {
-        host,
-        tunnel: {
-          openvpn: { port, protocol },
-        },
-      } = customTunnelEndpoint;
+      const host = customTunnelEndpoint.host;
+      const config: ConnectionConfig = customTunnelEndpoint.config;
+
+      let port = 0;
+      let protocol = 'udp';
+      if (config.openvpn) {
+        port = config.openvpn.endpoint.port;
+        protocol = config.openvpn.endpoint.protocol;
+      }
+
+      if (config.wireguard) {
+        // TODO: handle wireguard
+      }
 
       actions.settings.updateRelay({
         customTunnelEndpoint: {
@@ -449,7 +457,7 @@ export default class AppRenderer {
     const reduxAccount = this._reduxActions.account;
 
     reduxSettings.updateAllowLan(newSettings.allowLan);
-    reduxSettings.updateEnableIpv6(newSettings.tunnelOptions.enableIpv6);
+    reduxSettings.updateEnableIpv6(newSettings.tunnelOptions.generic.enableIpv6);
     reduxSettings.updateBlockWhenDisconnected(newSettings.blockWhenDisconnected);
     reduxSettings.updateOpenVpnMssfix(newSettings.tunnelOptions.openvpn.mssfix);
 
diff --git a/gui/packages/desktop/src/renderer/components/Connect.js b/gui/packages/desktop/src/renderer/components/Connect.js
index c4d26d15db..08636ad567 100644
--- a/gui/packages/desktop/src/renderer/components/Connect.js
+++ b/gui/packages/desktop/src/renderer/components/Connect.js
@@ -10,6 +10,7 @@ import TunnelControl from './TunnelControl';
 import Map from './Map';
 import styles from './ConnectStyles';
 import { NoCreditError, NoInternetError } from '../../main/errors';
+import { parseSocketAddress } from '../../shared/daemon-rpc-types';
 
 import type { RelayOutAddress, RelayInAddress } from './TunnelControl';
 import type AccountExpiry from '../lib/account-expiry';
@@ -170,10 +171,11 @@ export default class Connect extends Component<Props> {
     let relayInAddress: ?RelayInAddress = null;
 
     if ((tunnelState === 'connecting' || tunnelState === 'connected') && details) {
+      const socketAddr = parseSocketAddress(details.address);
       relayInAddress = {
-        ip: details.address,
-        port: details.tunnel.openvpn.port,
-        protocol: details.tunnel.openvpn.protocol,
+        ip: socketAddr.host,
+        port: socketAddr.port,
+        protocol: details.protocol,
       };
     }
 
diff --git a/gui/packages/desktop/src/renderer/lib/relay-settings-builder.js b/gui/packages/desktop/src/renderer/lib/relay-settings-builder.js
index d81c4d6fac..3397f543df 100644
--- a/gui/packages/desktop/src/renderer/lib/relay-settings-builder.js
+++ b/gui/packages/desktop/src/renderer/lib/relay-settings-builder.js
@@ -5,7 +5,6 @@ import type {
   RelayProtocol,
   RelaySettingsUpdate,
   RelaySettingsNormalUpdate,
-  RelaySettingsCustom,
 } from '../../shared/daemon-rpc-types';
 
 type LocationBuilder<Self> = {
@@ -139,65 +138,6 @@ class NormalRelaySettingsBuilder {
   }
 }
 
-type CustomOpenVPNConfigurator<Self> = {
-  port: (port: number) => Self,
-  protocol: (protocol: RelayProtocol) => Self,
-};
-
-type CustomTunnelBuilder<Self> = {
-  openvpn: (configurator: (CustomOpenVPNConfigurator<*>) => void) => Self,
-};
-
-class CustomRelaySettingsBuilder {
-  _payload: RelaySettingsCustom = {
-    host: '',
-    tunnel: {
-      openvpn: {
-        port: 0,
-        protocol: 'udp',
-      },
-    },
-  };
-
-  build(): RelaySettingsUpdate {
-    return {
-      customTunnelEndpoint: this._payload,
-    };
-  }
-
-  host(value: string) {
-    this._payload.host = value;
-    return this;
-  }
-
-  get tunnel(): CustomTunnelBuilder<CustomRelaySettingsBuilder> {
-    const updateOpenvpn = (next) => {
-      const tunnel = this._payload.tunnel || {};
-      const prev = tunnel.openvpn || {};
-      this._payload.tunnel = {
-        openvpn: { ...prev, ...next },
-      };
-    };
-
-    return {
-      openvpn: (configurator) => {
-        configurator({
-          port: function(port: number) {
-            updateOpenvpn({ port });
-            return this;
-          },
-          protocol: function(protocol: RelayProtocol) {
-            updateOpenvpn({ protocol });
-            return this;
-          },
-        });
-        return this;
-      },
-    };
-  }
-}
-
 export default {
   normal: () => new NormalRelaySettingsBuilder(),
-  custom: () => new CustomRelaySettingsBuilder(),
 };
diff --git a/gui/packages/desktop/src/shared/daemon-rpc-types.js b/gui/packages/desktop/src/shared/daemon-rpc-types.js
index 82e52a7603..9b39ba90c2 100644
--- a/gui/packages/desktop/src/shared/daemon-rpc-types.js
+++ b/gui/packages/desktop/src/shared/daemon-rpc-types.js
@@ -1,5 +1,4 @@
 // @flow
-
 export type AccountData = { expiry: string };
 export type AccountToken = string;
 export type Ip = string;
@@ -30,16 +29,14 @@ export type AfterDisconnect = 'nothing' | 'block' | 'reconnect';
 
 export type TunnelState = 'connecting' | 'connected' | 'disconnecting' | 'disconnected' | 'blocked';
 
+export type TunnelType = 'wireguard' | 'openvpn';
+
+export type RelayProtocol = 'tcp' | 'udp';
+
 export type TunnelEndpoint = {
   address: string,
-  tunnel: TunnelEndpointData,
-};
-
-export type TunnelEndpointData = {
-  openvpn: {
-    port: number,
-    protocol: RelayProtocol,
-  },
+  protocol: RelayProtocol,
+  tunnel: TunnelType,
 };
 
 export type TunnelStateTransition =
@@ -49,7 +46,6 @@ export type TunnelStateTransition =
   | { state: 'disconnecting', details: AfterDisconnect }
   | { state: 'blocked', details: BlockReason };
 
-export type RelayProtocol = 'tcp' | 'udp';
 export type RelayLocation =
   | {| hostname: [string, string, string] |}
   | {| city: [string, string] |}
@@ -77,10 +73,36 @@ type RelaySettingsNormal<TTunnelConstraints> = {
       },
 };
 
+export type ConnectionConfig =
+  | {|
+      openvpn: {
+        endpoint: {
+          ip: string,
+          port: number,
+          protocol: RelayProtocol,
+        },
+        username: string,
+      },
+    |}
+  | {|
+      wireguard: {
+        tunnel: {
+          private_key: string,
+          addresses: Array<string>,
+        },
+        peer: {
+          public_key: string,
+          addresses: Array<string>,
+          endpoint: string,
+        },
+        gateway: string,
+      },
+    |};
+
 // types describing the structure of RelaySettings
 export type RelaySettingsCustom = {
   host: string,
-  tunnel: TunnelEndpointData,
+  config: ConnectionConfig,
 };
 export type RelaySettings =
   | {|
@@ -128,11 +150,18 @@ export type RelayListHostname = {
 };
 
 export type TunnelOptions = {
-  enableIpv6: boolean,
   openvpn: {
     mssfix: ?number,
+    proxy: ?ProxySettings,
+  },
+  wireguard: {
+    mtu: ?number,
+    // Only relevant on Linux
+    fwmark: ?number,
+  },
+  generic: {
+    enableIpv6: boolean,
   },
-  proxy: ?ProxySettings,
 };
 
 export type ProxySettings = LocalProxySettings | RemoteProxySettings;
@@ -168,3 +197,19 @@ export type Settings = {
   relaySettings: RelaySettings,
   tunnelOptions: TunnelOptions,
 };
+
+export type SocketAddress = { host: string, port: number };
+
+export function parseSocketAddress(socketAddrStr: string): SocketAddress {
+  const re = new RegExp(/(.+):(\d+)$/);
+  const matches = socketAddrStr.match(re);
+
+  if (!matches || matches.length < 3) {
+    throw new Error(`Failed to parse socket address from address string '${socketAddrStr}'`);
+  }
+  const socketAddress: SocketAddress = {
+    host: matches[1],
+    port: Number(matches[2]),
+  };
+  return socketAddress;
+}
diff --git a/gui/packages/desktop/test/relay-settings-builder.spec.js b/gui/packages/desktop/test/relay-settings-builder.spec.js
index 56126adca5..0782476fe8 100644
--- a/gui/packages/desktop/test/relay-settings-builder.spec.js
+++ b/gui/packages/desktop/test/relay-settings-builder.spec.js
@@ -122,25 +122,4 @@ describe('Relay settings builder', () => {
       },
     });
   });
-
-  it('should set custom endpoint settings', () => {
-    expect(
-      RelaySettingsBuilder.custom()
-        .host('se2.mullvad.net')
-        .tunnel.openvpn((openvpn) => {
-          openvpn.port(80).protocol('tcp');
-        })
-        .build(),
-    ).to.deep.equal({
-      customTunnelEndpoint: {
-        host: 'se2.mullvad.net',
-        tunnel: {
-          openvpn: {
-            port: 80,
-            protocol: 'tcp',
-          },
-        },
-      },
-    });
-  });
 });
diff --git a/mullvad-types/src/endpoint.rs b/mullvad-types/src/endpoint.rs
index 79cb6693b7..311ca267ba 100644
--- a/mullvad-types/src/endpoint.rs
+++ b/mullvad-types/src/endpoint.rs
@@ -9,7 +9,7 @@ use talpid_types::net::{wireguard, Endpoint, TransportProtocol};
 use crate::relay_list::{OpenVpnEndpointData, WireguardEndpointData};
 
 /// Contains server data needed to conenct to a single mullvad endpoint
-#[derive(Debug, Clone, PartialEq, Eq, Hash, Deserialize, Serialize)]
+#[derive(Debug, Clone)]
 pub enum MullvadEndpoint {
     OpenVpn(Endpoint),
     Wireguard {