Merge pull request #177 from uProxy/trevj-merge-control

uproxy-networking merge: copy copypaste command port

Author: trevj

bin/connect-pair.py

@@ -0,0 +1,21 @@
+#!/usr/bin/python
+
+# Connects two copy-paste samples running on localhost.
+# TODO: add host/port args.
+
+import socket
+import time
+
+first = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+first.connect(("localhost", 9000))
+
+second = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+second.connect(("localhost", 9010))
+
+first.send("GET\n")
+time.sleep(0.5)
+first_sdp = first.recv(4096)
+second.send("GIVE " + first_sdp + "\n")
+time.sleep(0.5)
+second_sdp = second.recv(4096)
+first.send(second_sdp)

package.json

@@ -1,7 +1,7 @@
 {
   "name": "uproxy-lib",
   "description": "Shared libraries for uProxy projects.",
-  "version": "26.1.0",
+  "version": "26.2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/uProxy/uproxy-lib"

src/samples/copypaste-socks-chromeapp/freedom-module.ts

@@ -7,6 +7,7 @@ import arraybuffers = require('../../arraybuffers/arraybuffers');
 import rtc_to_net = require('../../rtc-to-net/rtc-to-net');
 import socks_to_rtc = require('../../socks-to-rtc/socks-to-rtc');
 import net = require('../../net/net.types');
+import tcp = require('../../net/tcp');
 import signals = require('../../webrtc/signals');
 
 import logging = require('../../logging/logging');
@@ -58,8 +59,86 @@ var pcConfig :freedom_RTCPeerConnection.RTCConfiguration = {
 var socksRtc:socks_to_rtc.SocksToRtc;
 var rtcNet:rtc_to_net.RtcToNet;
 
-parentModule.on('start', () => {
+
+// Listen for GET/GIVE requests, to control the app without user
+// interaction.
+var tcpServer:tcp.Server;
+
+var localhostControlEndpoints:[net.Endpoint] = [
+  { address: '127.0.0.1', port: 9000 },
+  { address: '127.0.0.1', port: 9010 },
+  { address: '127.0.0.1', port: 9020 }];
+
+function setupServer(endpoint:net.Endpoint) {
+  tcpServer = new tcp.Server(endpoint);
+  tcpServer.connectionsQueue.setSyncHandler((conn:tcp.Connection) => {
+    conn.dataFromSocketQueue.setSyncHandler((buf:ArrayBuffer) => {
+      var str = arraybuffers.arrayBufferToString(buf);
+      if (str.substr(0,3).toUpperCase() == "GET") {
+        doStart();
+        setTimeout(() => {
+          parentModule.emit('gatherMessage');
+        }, 500);
+      } else if (str.substr(0,4).toUpperCase() == "GIVE") {
+        log.info("GIVE found.");
+        // skip past space, and then read SDP.
+        var sdp = str.substr(5);
+        parentModule.emit('giveWithSDP', sdp);
+      } else {
+        log.info("I don't understand that command. (" + str + ")");
+      }
+    });
+  });
+
+  tcpServer.listen().then((endpoint) => {
+    log.info('Remote-commands available on %1', endpoint);
+  }).catch((e:Error) => {
+    log.error('Failed to listen on remote-command socket: %1', e.message);
+    if (localhostControlEndpoints.length > 1) {
+      setupServer(localhostControlEndpoints.shift());
+    }
+  });
+}
+
+setupServer(localhostControlEndpoints[0]);
+
+parentModule.on('giveSendBack', (data:ArrayBuffer) => {
+  log.info('giveSendBack: with arraybuf of ' + data.byteLength);
+  var conn:tcp.Connection = null;
+  var all_conns = tcpServer.connections();
+  if (all_conns.length < 1) {
+    log.info("'giveSendBack': Weird, didn't find a connection.");
+    return;
+  }
+  conn = all_conns[0];
+  conn.send(data);
+  conn.close();
+})
+
+// Invokd from main.core-env.ts, upon 'gatherMessage', which comes
+// back with our connection ID and the SDP, as a utf-8 string.
+parentModule.on('getSendBack', (data:ArrayBuffer) => {
+  log.info('getSendBack: with arraybuf of ' + data.byteLength);
+  var conn:tcp.Connection = null;
+  var all_conns = tcpServer.connections();
+  if (all_conns.length < 1) {
+    log.info("'getSendBack': Weird, didn't find a connection.");
+    return;
+  }
+  conn = all_conns[0];
+  conn.send(data);
+  conn.dataFromSocketQueue.setNextHandler((buf:ArrayBuffer) => {
+    var sdp = arraybuffers.arrayBufferToString(buf);
+    log.info('got sdp ' + sdp);
+    parentModule.emit('gotPeerSDP', sdp);
+    conn.close();
+    return Promise.resolve<void>();
+  });
+});
+
+var doStart = () => {
   var localhostEndpoint:net.Endpoint = { address: '127.0.0.1', port: 9999 };
+
   socksRtc = new socks_to_rtc.SocksToRtc();
 
   // Forward signalling channel messages to the UI.
@@ -92,10 +171,12 @@ parentModule.on('start', () => {
       parentModule.emit('proxyingStarted', endpoint);
     })
     .catch((e) => {
-      console.error('socksRtc Error: ' + e + '; ' + this.socksRtc.toString());
+      console.error('socksRtc Error: ' + e + '; ' + socksRtc.toString());
     });
   log.info('created socks-to-rtc');
-});
+}
+
+parentModule.on('start', doStart);
 
 // Receive signalling channel messages from the UI.
 // Messages are dispatched to either the socks-to-rtc or rtc-to-net

src/samples/copypaste-socks-chromeapp/main.core-env.ts

@@ -36,6 +36,30 @@ module copypaste_module {
       model.outboundMessageValue = base64Encode(newConcatenatedJson);
     });
 
+    copypaste.on('gotPeerSDP', (peerSDP:string) => {
+      console.log('gotPeerSDP of length ' + peerSDP.length);
+      parseInboundMessages(peerSDP);
+      consumeInboundMessage();
+    });
+
+    copypaste.on('gatherMessage', () => {
+      console.log('gatherMessage invoked.');
+      console.log('gatherMessage: sending back:' + model.outboundMessageValue);
+
+      copypaste.emit('getSendBack',
+                     arraybuffers.stringToArrayBuffer(model.outboundMessageValue));
+    });
+
+    copypaste.on('giveWithSDP', (sdp:string) => {
+      parseInboundMessages(sdp);
+      consumeInboundMessage();
+      setTimeout(() => {
+        console.log("Emitting giveSendback with SDP: " + model.outboundMessageValue);
+        copypaste.emit('giveSendBack',
+                       arraybuffers.stringToArrayBuffer(model.outboundMessageValue));
+      }, 500);
+    });
+
     copypaste.on('publicKeyExport', (publicKey:string) => {
       model.userPublicKey = publicKey;
     });