Reverse port forwarding backend actually works now. UI needs some work for the "new vision".

lib/units/device/plugins/forward.js

@@ -1,157 +1,174 @@
 var net = require('net')
-var util = require('util')
 
-var syrup = require('syrup')
 var Promise = require('bluebird')
-var split = require('split')
+var syrup = require('syrup')
 
-var logger = require('../../../util/logger')
-var devutil = require('../../../util/devutil')
-var streamutil = require('../../../util/streamutil')
-var lifecycle = require('../../../util/lifecycle')
 var wire = require('../../../wire')
+var logger = require('../../../util/logger')
+var lifecycle = require('../../../util/lifecycle')
+var streamutil = require('../../../util/streamutil')
+var forwardutil = require('../../../util/forwardutil')
 var wireutil = require('../../../wire/util')
 
 module.exports = syrup.serial()
   .dependency(require('../support/adb'))
   .dependency(require('../support/router'))
   .dependency(require('../support/push'))
-  .dependency(require('../resources/remote'))
-  .define(function(options, adb, router, push, remote) {
+  .dependency(require('../resources/minirev'))
+  .define(function(options, adb, router, push, minirev) {
     var log = logger.createLogger('device:plugins:forward')
+    var plugin = Object.create(null)
 
-    var service = {
-      port: 2810
-    , privatePorts: (function() {
-        var ports = []
-        for (var i = 2520; i <= 2540; ++i) {
-          ports.push(i)
-        }
-        return ports
-      })()
-    , forwards: Object.create(null)
-    }
+    function ForwardManager() {
+      var forwards = Object.create(null)
 
-    function openService() {
-      log.info('Launching reverse port forwarding service')
-      return devutil.ensureUnusedPort(adb, options.serial, service.port)
-        .timeout(10000)
-        .then(function() {
-          return adb.shell(options.serial, [
-              'exec'
-            , remote.bin
-            , '--lib', remote.lib
-            , '--listen-forward', service.port
-            ])
-            .timeout(10000)
-            .then(function(out) {
-              lifecycle.share('Forward shell', out)
-              streamutil.talk(log, 'Forward shell says: "%s"', out)
-            })
-            .then(function() {
-              return devutil.waitForPort(adb, options.serial, service.port)
-                .timeout(10000)
-            })
-            .then(function(conn) {
-              conn.end()
-            })
-        })
-    }
+      function Forward(conn, to) {
+        var proxies = Object.create(null)
 
-    function createForward(data) {
-      log.info(
-        'Reverse port forwarding port %d to %s:%d'
-      , data.devicePort
-      , data.targetHost
-      , data.targetPort
-      )
-
-      var forward = service.forwards[data.devicePort]
-
-      if (forward) {
-        if (forward.targetHost === data.targetHost &&
-            forward.targetPort === data.targetPort) {
-          return Promise.resolve()
-        }
-        else if (forward.system) {
-          return Promise.reject(new Error('Cannot rebind system port'))
-        }
-        else {
-          removeForward(forward)
-        }
-      }
-
-      return adb.openTcp(options.serial, service.port)
-        .timeout(10000)
-        .then(function(conn) {
-          var resolver = Promise.defer()
-
-          var forward = {
-            devicePort: data.devicePort
-          , targetHost: data.targetHost
-          , targetPort: data.targetPort
-          , system: !!data.system
-          , privatePort: service.privatePorts.pop()
-          , connection: conn
+        function Proxy(fd) {
+          function maybeSend() {
+            var chunk
+            while ((chunk = this.read())) {
+              if (!conn.write(chunk)) {
+                break
+              }
+            }
           }
 
-          var parser = conn.pipe(split())
+          function killListeners() {
+            src.removeListener('readable', maybeSend)
+            conn.removeListener('drain', maybeSend)
+            conn.removeListener('end', killListeners)
+          }
 
-          parser.on('data', function(chunk) {
-            var cmd = chunk.toString().trim()
-            switch (cmd) {
-              case 'OKAY':
-                resolver.resolve(forward)
-                break
-              case 'FAIL':
-                resolver.reject(new Error('Remote replied with FAIL'))
-                break
-              case 'CNCT':
-                adb.openTcp(options.serial, forward.privatePort)
-                  .done(function(dstream) {
-                    return tryConnect(forward)
-                      .then(function(ustream) {
-                        ustream.pipe(dstream)
-                        dstream.pipe(ustream)
-                      })
-                  })
-                break
+          var src = new forwardutil.ForwardWriter(fd)
+            .on('readable', maybeSend)
+            .on('error', function(err) {
+              log.error('Proxy writer %d had an error', fd, to, err.stack)
+            })
+
+          conn.on('drain', maybeSend)
+          conn.on('end', killListeners)
+
+          this.dest = net.connect(to)
+            .once('end', function() {
+              delete proxies[fd]
+              killListeners()
+            })
+            .on('error', function(err) {
+              log.error('Proxy reader %d had an error', fd, to, err.stack)
+            })
+
+          this.dest.pipe(src)
+
+          this.stop = function() {
+            //this.dest.unpipe(this.src)
+            this.dest.end()
+          }.bind(this)
+        }
+
+        conn.pipe(new forwardutil.ForwardParser())
+          .on('packet', function(fd, packet) {
+            var proxy = proxies[fd]
+
+            if (!proxy) {
+              // New connection
+              proxy = proxies[fd] = new Proxy(fd)
+            }
+
+            proxy.dest.write(packet)
+          })
+          .on('fin', function(fd) {
+            // The connection ended
+            if (proxies[fd]) {
+              proxies[fd].stop()
             }
           })
 
-          // Keep this around
-          function endListener() {
-            removeForward(forward)
-          }
+        this.end = function() {
+          conn.end()
+        }
+      }
 
-          conn.on('end', endListener)
+      this.add = function(port, conn, to) {
+        forwards[port] = new Forward(conn, to)
+      }
 
-          conn.write(util.format(
-            'FRWD %d %d\n'
-          , forward.devicePort
-          , forward.privatePort
-          ))
-
-          return resolver.promise
-        })
-    }
-
-    function removeForward(data) {
-      log.info('Removing reverse port forwarding on port %d', data.devicePort)
-      var forward = service.forwards[data.devicePort]
-      if (forward) {
-        forward.connection.end()
-        delete service.forwards[data.devicePort]
+      this.remove = function(port) {
+        if (forwards[port]) {
+          forwards[port].end()
+        }
       }
     }
 
-    function tryConnect(data) {
+    var manager = new ForwardManager()
+
+    function startService() {
+      log.info('Launching reverse port forwarding service')
+      return adb.shell(options.serial, [
+          'exec'
+        , minirev.bin
+        ])
+        .timeout(10000)
+        .then(function(out) {
+          lifecycle.share('Forward shell', out)
+          streamutil.talk(log, 'Forward shell says: "%s"', out)
+        })
+    }
+
+    function connectService(times) {
+      function tryConnect(times, delay) {
+        return adb.openLocal(options.serial, 'localabstract:minirev')
+          .timeout(10000)
+          .catch(function(err) {
+            if (/closed/.test(err.message) && times > 1) {
+              return Promise.delay(delay)
+                .then(function() {
+                  return tryConnect(--times, delay * 2)
+                })
+            }
+            return Promise.reject(err)
+          })
+      }
+      log.info('Connecting to reverse port forwarding service')
+      return tryConnect(times, 100)
+    }
+
+    function awaitServer() {
+      return connectService(5)
+        .then(function(conn) {
+          conn.end()
+          return true
+        })
+    }
+
+    plugin.createForward = function(port, to) {
+      log.info(
+        'Creating reverse port forward from ":%d" to "%s:%d"'
+      , port
+      , to.host
+      , to.port
+      )
+      return connectService(1)
+        .then(function(out) {
+          var header = new Buffer(4)
+          header.writeUInt16LE(0, 0)
+          header.writeUInt16LE(port, 2)
+          out.write(header)
+          return manager.add(port, out, to)
+        })
+    }
+
+    plugin.removeForward = function(port) {
+      log.info('Removing reverse port forward ":%d"', port)
+      manager.remove(port)
+      return Promise.resolve()
+    }
+
+    plugin.connect = function(options) {
       var resolver = Promise.defer()
 
-      var conn = net.connect({
-        host: data.targetHost
-      , port: data.targetPort
-      })
+      var conn = net.connect(options)
 
       function connectListener() {
         resolver.resolve(conn)
@@ -170,31 +187,16 @@ module.exports = syrup.serial()
       })
     }
 
-    function resetForwards() {
-      Object.keys(service.forwards).forEach(function(privatePort) {
-        service.forwards[privatePort].connection.end()
-        delete service.forwards[privatePort]
-      })
-    }
-
-    function listForwards() {
-      return Object.keys(service.forwards).map(function(privatePort) {
-        var forward = service.forwards[privatePort]
-        return {
-          devicePort: forward.devicePort
-        , targetHost: forward.targetHost
-        , targetPort: forward.targetPort
-        , system: !!forward.system
-        }
-      })
-    }
-
-    return openService()
+    return startService()
+      .then(awaitServer)
       .then(function() {
         router
           .on(wire.ForwardTestMessage, function(channel, message) {
             var reply = wireutil.reply(options.serial)
-            tryConnect(message)
+            plugin.connect({
+                host: message.targetHost
+              , port: message.targetPort
+              })
               .then(function(conn) {
                 conn.end()
                 push.send([
@@ -211,7 +213,10 @@ module.exports = syrup.serial()
           })
           .on(wire.ForwardCreateMessage, function(channel, message) {
             var reply = wireutil.reply(options.serial)
-            createForward(message)
+            plugin.createForward(message.devicePort, {
+                host: message.targetHost
+              , port: message.targetPort
+              })
               .then(function() {
                 push.send([
                   channel
@@ -228,11 +233,21 @@ module.exports = syrup.serial()
           })
           .on(wire.ForwardRemoveMessage, function(channel, message) {
             var reply = wireutil.reply(options.serial)
-            removeForward(message)
-            push.send([
-              channel
-            , reply.okay('success')
-            ])
+            plugin.removeForward(message.devicePort)
+              .then(function() {
+                push.send([
+                  channel
+                , reply.okay('success')
+                ])
+              })
+              .catch(function(err) {
+                log.error('Reverse port unforwarding failed', err.stack)
+                push.send([
+                  channel
+                , reply.fail('fail')
+                ])
+              })
           })
       })
+      .return(plugin)
   })