Merge pull request #2808 from uProxy/trevj-air-save-servers

save contacts to HTML5 localStorage

Author: trevj

Gruntfile.js

@@ -252,7 +252,8 @@ module.exports = function(grunt) {
       // compatibility with the modified libxwalkcore.so that provides obfuscated WebRTC.
       ccaBuildAndroid: {
         cwd: '<%= androidDevPath %>',
-        command: '<%= ccaJsPath %> build android --debug --webview=crosswalk@org.xwalk:xwalk_core_library_beta:22.52.561.2'
+        // Pipe 'no' for the first time cca.js asks whether to send usage stats (grunt build_android_lite).
+        command: 'echo no | <%= ccaJsPath %> build android --debug --webview=crosswalk@org.xwalk:xwalk_core_library_beta:22.52.561.2'
       },
       ccaReleaseAndroid: {
         cwd: '<%= androidDistPath %>',

src/cca/model/server.ts

@@ -13,4 +13,6 @@ export type AccessCode = string;
 
 export interface ServerRepository {
   addServer(code: AccessCode): Promise<Server>
+  // Fetches the list of servers known to this repository.
+  getServers(): Promise<Server[]>;
 }

src/cca/scripts/background.ts

@@ -14,6 +14,20 @@ import { MakeCoreConnector } from './cordova_core_connector';
 import { GetGlobalTun2SocksVpnDevice } from './tun2socks_vpn_device';
 import * as vpn_device from '../model/vpn_device';
 import * as intents from './intents';
+import * as uproxy_core_api from '../../interfaces/uproxy_core_api';
+
+// https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API/Using_the_Web_Storage_API
+function getLocalStorage(): Storage {
+  try {
+    const storage = window['localStorage'];
+    const x = '__storage_test__';
+    storage.setItem(x, x);
+    storage.removeItem(x);
+    return localStorage;
+  } catch(e) {
+    throw new Error('localStorage unavailable');
+  }
+}
 
 // We save this reference to allow inspection of the context state from the browser debuggin tools.
 (window as any).context = this;
@@ -22,15 +36,20 @@ import * as intents from './intents';
 // TODO(fortuna): I believe we need to somehow wait for the core to be ready.
 let core = MakeCoreConnector();
 
-// Create UproxyServerRepository.
+// Log into the cloud social network and create UproxyServerRepository.
 let serversPromise = GetGlobalTun2SocksVpnDevice().then((vpnDevice) => {
   console.debug('Device supports VPN');
   return vpnDevice;
 }).catch((error) => {
   console.error(error);
   return new vpn_device.NoOpVpnDevice();
 }).then((vpnDevice) => {
-  return new UproxyServerRepository(core, vpnDevice);
+  return core.login({
+    network: 'Cloud',
+    loginType: uproxy_core_api.LoginType.INITIAL,
+  }).then(() => {
+    return new UproxyServerRepository(getLocalStorage(), core, vpnDevice);
+  });
 });
 
 // Create UI.

src/cca/scripts/uproxy_server.ts

@@ -1,4 +1,5 @@
 import uparams = require('uparams');
+import * as cloud_social_provider from '../../lib/cloud/social/provider';
 import * as jsurl from 'jsurl';
 import * as social from '../../interfaces/social';
 import * as uproxy_core_api from '../../interfaces/uproxy_core_api';
@@ -9,26 +10,6 @@ import { SocksProxy } from '../model/socks_proxy_server';
 import { VpnDevice } from '../model/vpn_device';
 import { CloudSocksProxy } from './cloud_socks_proxy_server';
 
-function parseInviteUrl(inviteUrl: string): social.InviteTokenData {
-  let params = uparams(inviteUrl);
-  if (!params || !params['networkName']) {
-    throw new Error(`networkName not found: ${inviteUrl}`);
-  }
-  var permission: any;
-  if (params['permission']) {
-    permission = jsurl.parse(params['permission']);
-  }
-  return {
-    v: parseInt(params['v'], 10),
-    networkData: JSON.parse(jsurl.parse(params['networkData'])),
-    networkName: params['networkName'],
-    userName: params['userName'],
-    permission: permission,
-    userId: params['userId'],  // undefined if no permission
-    instanceId: params['instanceId'],  // undefined if no permission
-  }
-}
-
 // A local Socks server that provides access to a remote uProxy Cloud server via RTC.
 export class UproxyServer implements Server {
   private instancePath: social.InstancePath;
@@ -56,25 +37,76 @@ export class UproxyServer implements Server {
   }
 }
 
+// Name by which servers are saved to storage.
+const SERVERS_STORAGE_KEY = 'servers';
+
+// Type of the object placed, in serialised form, in storage.
+type SavedServers = { [id: string]: SavedServer };
+
+// A server as saved to storage.
+interface SavedServer {
+  cloudTokens?: cloud_social_provider.Invite;
+}
+
+// Maintains a persisted set of servers and liases with the core.
 export class UproxyServerRepository implements ServerRepository {
-  constructor(private core: CoreConnector, private vpnDevice: VpnDevice) {
-    this.core.login({
-      network: 'Cloud',
-      loginType: uproxy_core_api.LoginType.INITIAL,
-    });
+  constructor(
+    private storage: Storage,
+    // Must already be logged into social networks.
+    private core: CoreConnector,
+    private vpnDevice: VpnDevice) { }
+
+  public getServers() {
+    const servers = this.loadServers();
+    return Promise.all(Object.keys(servers).map((host) => {
+      return this.notifyCoreOfServer(servers[host].cloudTokens);
+    }));
   }
 
-  public addServer(code: AccessCode): Promise<Server> {
-    let token = parseInviteUrl(code);
-    if (!token) {
-      return Promise.reject(`Failed to parse access code: ${code}`);
+  private loadServers(): SavedServers {
+    return JSON.parse(this.storage.getItem(SERVERS_STORAGE_KEY)) || {};
+  }
+
+  // Saves a server to storage, merging it with any already found there.
+  // Returns true if the server was not already in storage.
+  private saveServer(cloudTokens: cloud_social_provider.Invite) {
+    const savedServers = this.loadServers();
+    savedServers[cloudTokens.host] = {
+      cloudTokens: cloudTokens
+    };
+    this.storage.setItem(SERVERS_STORAGE_KEY, JSON.stringify(savedServers));
+  }
+
+  public addServer(accessCode: AccessCode) {
+    // This is inspired by ui.ts but note that uProxy Air only
+    // supports v2 access codes which have just three fields:
+    //  - v
+    //  - networkName
+    //  - networkData
+    // TODO: accept only cloud access codes
+    const params: social.InviteTokenData = uparams(accessCode);
+    if (!(params || params.v ||
+      params.networkName || params.networkData)) {
+      return Promise.reject(new Error('could not decode URL'));
     }
-    // TODO: Do I need to wait for core.login()?
+
+    const cloudTokens: cloud_social_provider.Invite = JSON.parse(
+        jsurl.parse(<string>params.networkData));
+    this.saveServer(cloudTokens);
+    // TODO: only notify the core when connecting, and delete it afterwards
+    return this.notifyCoreOfServer(cloudTokens);
+  }
+
+  private notifyCoreOfServer(cloudTokens: cloud_social_provider.Invite) {
     return this.core.acceptInvitation({
-      network: {name: 'Cloud'},
-      tokenObj: token
+      network: {
+        name: 'Cloud'
+      },
+      tokenObj: {
+        networkData: cloudTokens,
+      }
     }).then(() => {
-      let proxy = new CloudSocksProxy(this.core, (token.networkData as any).host);
+      let proxy = new CloudSocksProxy(this.core, cloudTokens.host);
       return new UproxyServer(proxy, this.vpnDevice, proxy.getRemoteIpAddress());
     });
   }

src/cca/ui_components/server_list.ts

@@ -55,6 +55,10 @@ export class ServerListPage {
   private addButton: HTMLButtonElement;
   private entryList: HTMLDivElement;
 
+  // Servers currently shown, indexed by hostname.
+  // Used to prevent listing servers more than once.
+  private activeServerIds = new Set<String>();
+
   // Parameters:
   // - root: Where to attach the ServerListPage to
   // - servers: the repository of the servers we can connect to.
@@ -68,6 +72,12 @@ export class ServerListPage {
       console.debug('Pressed Add Button');
       this.pressAddServer();
     });
+
+    servers.getServers().then((restoredServers) => {
+      restoredServers.forEach((server) => {
+        this.addServer(server);
+      });
+    });
   }
 
   public enterAccessCode(code: string) {
@@ -77,12 +87,18 @@ export class ServerListPage {
 
   public pressAddServer(): Promise<ServerEntryComponent> {
     return this.servers.addServer(this.addTokenText.value).then((server) => {
-      let entryElement = this.root.ownerDocument.createElement('div');
-      let serverEntry = new ServerEntryComponent(entryElement, server);
-      this.entryList.appendChild(entryElement);
-      return serverEntry;
-    }).catch((error) => {
-      console.error(error);
+      this.addServer(server);
     });
   }
+
+  private addServer(server: Server) {
+    if (this.activeServerIds.has(server.getIpAddress())) {
+      return;
+    }
+
+    this.activeServerIds.add(server.getIpAddress());
+    const entryElement = this.root.ownerDocument.createElement('div');
+    this.entryList.appendChild(entryElement);
+    return new ServerEntryComponent(entryElement, server);
+  }
 }

src/generic_core/social.ts

@@ -82,16 +82,10 @@ export function initializeNetworks() :void {
  */
 export function getNetwork(networkName :string, userId :string) :social.Network {
   if (!(networkName in networks)) {
-    log.warn('Network does not exist', networkName);
-    return null;
+    throw new Error('unknown network ${networkName}');
   }
-
   if (!(userId in networks[networkName])) {
-    log.info('Not logged in to network', {
-      userId: userId,
-      network: networkName
-    });
-    return null;
+    throw new Error('${userId} is not logged into network ${networkName}');
   }
   return networks[networkName][userId];
 }

src/generic_core/uproxy_core.ts

@@ -368,8 +368,12 @@ export class uProxyCore implements uproxy_core_api.CoreApi {
       // Assumes the user is only signed in once to any given network.
       networkUserId = Object.keys(social_network.networks[networkName])[0];
     }
-    var network = social_network.getNetwork(networkName, networkUserId);
-    return network.acceptInvitation(data.tokenObj, data.userId);
+    try {
+      return social_network.getNetwork(networkName, networkUserId).acceptInvitation(
+          data.tokenObj, data.userId);
+    } catch (e) {
+      return Promise.reject(e);
+    }
   }
 
   public getInviteUrl = (data :uproxy_core_api.CreateInviteArgs): Promise<string> => {

src/lib/cloud/social/provider.ts

@@ -37,7 +37,7 @@ const DEFAULT_MESSAGE_VERSION = 4;
 
 // Credentials for accessing a cloud instance.
 // The serialised, base64 form is distributed amongst users.
-interface Invite {
+export interface Invite {
   // Hostname or IP of the cloud instance.
   // This is the host on which sshd is running, so it should
   // be directly accessible from the client.

tsconfig.json

@@ -11,6 +11,7 @@
       "es5",
       "es2015.promise",
       "es2015.iterable",
+      "es2015.collection",
       "scripthost"
     ]
   },