reverse-tunnel 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*~
+README.html
+log/*

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in reverse-tunnel.gemspec
+gemspec
+
+gem 'rb-inotify', '~> 0.8.8' if RUBY_PLATFORM =~ /linux/

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard 'rspec' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end
+

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Alban Peignier
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# Reverse::Tunnel
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'reverse-tunnel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install reverse-tunnel
+
+## Usage
+
+    reverse-tunnel server --public=88.190.240.120:4893 --api=172.20.11.9:3000 --range=172.20.11.9:10000-10100
+
+    reverse-tunnel client --server=88.190.240.120:4893 --local-port=22 6B833D3F561369156820B4240C7C2657
+
+    reverse-tunnel rt://console.tryphon.eu:4893/6B833D3F561369156820B4240C7C2657/22
+    reverse-tunnel cnQ6Ly9jb25zb2xlLnRyeXBob24uZXU6NDg5My82QjgzM0QzRjU2MTM2OTE1NjgyMEI0MjQwQzdDMjY1Ny8yMg==
+
+## API
+
+Create a new tunnel :
+
+    $ curl -X POST -d '{"token":"156820B4240C7C26576B833D3F561369","local_port":10001}' http://localhost:5000/tunnels.json
+    {
+        "token": "156820B4240C7C26576B833D3F561369",
+        "local_port": 10001
+    }
+
+Retrieve current tunnels :
+
+    $ curl http://localhost:5000/tunnels.json
+    [
+        {
+            "token": "6B833D3F561369156820B4240C7C2657",
+            "local_port": 10000,
+        },
+        {
+            "token": "156820B4240C7C26576B833D3F561369",
+            "local_port": 10001,
+            "connection": {
+                "peer": "127.0.0.1:42782",
+                "created_at": "2012-12-22 17:29:55 +0100"
+            }
+        }
+    ]
+
+
+## Protocol
+
+### Create tunnel
+
+* POST /tunnels on server API (with optional token and local port)
+* API returns token and local port
+
+### Open tunnel
+
+* client send tunnel token to server (on public ip:port)
+* server opens a tcp server on local port (associated to token)
+* client receives a confirmation message
+
+### Ping tunnel
+
+* every 30s (?) client sends a ping message
+* server responds a pong message
+
+### Use tunnel
+
+* server receives a connection on tcp server on local port
+* server creates a session (with id)
+* server sends received data to client
+* client creates local connection to local port (if not exist)
+* client send received data to local connection
+* client send back to server data received on local connection
+
+### Messages
+
+* OPEN_TUNNEL:tunnel_token
+* PING
+* PONG
+* OPEN_SESSION:session_id
+* DATA:session_id:data
+* CLOSE_SESSION:session_id
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,4 @@
+require "bundler/gem_tasks"
+
+FileList['tasks/**/*.rake'].each { |task| import task }
+

data/bin/reverse-tunnel

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "reverse-tunnel"
+
+ReverseTunnel::CLI.new(ARGV).run

data/lib/reverse-tunnel.rb

@@ -0,0 +1,35 @@
+require "reverse-tunnel/version"
+
+require "logger"
+
+module ReverseTunnel
+
+  def self.default_logger
+    Logger.new($stderr).tap do |logger|
+      logger.level = Logger::INFO
+    end
+  end
+
+  @@logger = default_logger
+  def self.logger
+    @@logger
+  end
+  def self.logger=(logger)
+    @@logger = logger
+  end
+
+  def self.reset_logger!
+    @@logger = default_logger
+  end
+
+end
+
+require "eventmachine"
+require "msgpack"
+require "trollop"
+require "syslog/logger"
+
+require "reverse-tunnel/message"
+require "reverse-tunnel/server"
+require "reverse-tunnel/client"
+require "reverse-tunnel/cli"

data/lib/reverse-tunnel/cli.rb

@@ -0,0 +1,170 @@
+module ReverseTunnel
+  class CLI
+
+    attr_accessor :arguments
+
+    def initialize(arguments = [])
+      @arguments = arguments
+    end
+
+    def mode
+      @mode ||= arguments.shift
+    end
+
+    class Base
+
+      attr_reader :arguments
+
+      def initialize(arguments = [])
+        @arguments = arguments
+      end
+
+      def options
+        @options ||= Trollop::with_standard_exception_handling(parser) do
+          parser.parse arguments
+        end
+      end
+
+      def configure(object = self)
+        options.each do |k,v| 
+          unless [:help, :version].include? k or k.to_s =~ /_given$/
+            object.send "#{k.to_s.gsub('-','_')}=", v 
+          end
+        end
+
+        object
+      end
+
+    end
+
+    class Global < Base
+
+      def parser
+        @parser ||= Trollop::Parser.new do
+          banner <<-EOS
+Usage:
+       reverse-client [global options] server|client [options]
+
+where [global options] are:
+EOS
+
+          opt :debug, "Enable debug messages"
+          opt :syslog, "Send log messages to syslog"
+
+          version ReverseTunnel::VERSION
+
+          stop_on "server", "client"
+        end
+      end
+
+    end
+
+    class Configurator < Base
+
+      def instance
+        @instance ||= ReverseTunnel.const_get(self.class.name.split("::").last).new
+      end
+
+      def method_missing(name, *args)
+        instance.send name, *args
+      end
+      
+      def parse_host_port(string)
+        host, port = string.split(':')
+        [ host, port.to_i ]
+      end
+
+      def parse_host_port_range(string)
+        if string =~ /(.*):(\d+)-(\d+)$/
+          [ $1, ($2.to_i)..($3.to_i) ]
+        end
+      end
+
+      def server=(server)
+        self.server_host, self.server_port = parse_host_port(server)
+      end
+
+      def self.configure(arguments)
+        new(arguments).configure
+      end
+
+    end
+
+    class Client < Configurator
+
+      def parser
+        @parser ||= Trollop::Parser.new do
+          opt :server, "Host and port of ReverseTunnel server", :type => :string
+          opt :api, "Host and port of status HTTP api", :type => :string
+          opt :"local-port", "Port to forward incoming connection", :default => 22
+        end
+      end
+
+      def token
+        arguments.first
+      end
+
+      def api=(api)
+        self.api_host, self.api_port = parse_host_port(api) if api
+      end
+
+      def configure(object = self)
+        super
+        self.token = token
+        instance
+      end
+
+    end
+
+    class Server < Configurator
+
+      def parser
+        @parser ||= Trollop::Parser.new do
+          opt :server, "Host and port of ReverseTunnel server", :default => "0.0.0.0:4893"
+          opt :api, "Host and port of ReverseTunnel HTTP api", :default => "127.0.0.1:4894"
+          opt :local, "Host and port range to listen forwarded connections", :default => "127.0.0.1:10000-10010"
+        end
+      end
+
+      def api=(api)
+        self.api_host, self.api_port = parse_host_port(api)
+      end
+
+      def local=(local)
+        self.local_host, self.local_port_range = parse_host_port_range(local)
+      end
+
+    end
+
+    def debug=(debug)
+      level = debug ? Logger::DEBUG : Logger::INFO
+      ReverseTunnel.logger.level = level
+    end
+
+    def syslog=(syslog)
+      if syslog
+        syslog_logger = Syslog::Logger.new("rtunnel").tap do |logger|
+          logger.level = ReverseTunnel.logger.level
+        end
+        ReverseTunnel.logger = syslog_logger
+      end
+    end
+
+    def configurator_class
+      mode == "server" ? ReverseTunnel::CLI::Server : ReverseTunnel::CLI::Client
+    end
+
+    def instance
+      configurator_class.configure(arguments)
+    end
+
+    def configure
+      Global.new(arguments).configure(self)
+    end
+
+    def run
+      configure
+      instance.start
+    end
+  end
+end

data/lib/reverse-tunnel/client.rb

@@ -0,0 +1,304 @@
+module ReverseTunnel
+  class Client
+
+    class ApiServer < EM::Connection
+      include EM::HttpServer
+
+      attr_accessor :tunnel
+
+      def initialize(tunnel)
+        @tunnel = tunnel
+      end
+      
+      def post_init
+        super
+        no_environment_strings
+      end
+
+      def process_http_request
+        ReverseTunnel.logger.debug "Process http request #{@http_request_uri}"
+
+        response = EM::DelegatedHttpResponse.new(self)
+        response.status = 200
+        response.content_type 'application/json'
+
+        begin
+          if @http_request_uri =~ %r{^/status(.json)?$} and @http_request_method == "GET"
+            response.content = tunnel.to_json
+          end
+        rescue => e
+          ReverseTunnel.logger.error "Error in http request processing: #{e}"
+          response.status = 500
+        end
+
+        if response.content.nil?
+          response.status = 404
+        end
+
+        response.send_response
+      end
+      
+    end
+
+    class Tunnel
+
+      attr_accessor :host, :port
+      attr_accessor :token, :local_port
+
+      def initialize(attributes = {})
+        attributes.each { |k,v| send "#{k}=", v }
+      end
+
+      attr_accessor :connection
+
+      def connection=(connection)
+        if connection.nil?
+          EventMachine.add_timer(30) do  
+            start
+          end
+
+          local_connections.close_all
+          @hearbeat.cancel
+        else
+          @hearbeat = EventMachine.add_periodic_timer(5) do
+            ping
+          end
+        end
+
+        @connection = connection
+      end
+
+      def start
+        ReverseTunnel.logger.debug "Connect to #{host}:#{port}"
+        EventMachine.connect host, port, TunnelConnection, self
+      end
+
+      def open
+        connection.send_data Message::OpenTunnel.new(token).pack
+      end
+
+      attr_accessor :sequence_number
+      def sequence_number
+        @sequence_number ||= 0
+      end
+
+      def ping
+        next_number = self.sequence_number += 1
+        ReverseTunnel.logger.debug "Send ping #{next_number}"
+        connection.send_data Message::Ping.new(next_number).pack if connection
+      end
+
+      def ping_received(ping)
+        ReverseTunnel.logger.info "Receive ping #{ping.sequence_number}"
+      end
+
+      def open_session(session_id)
+        local_host = "localhost"
+        EventMachine.connect local_host, local_port, LocalConnection, self, session_id
+      end
+
+      def send_data(session_id, data)
+        if connection
+          ReverseTunnel.logger.debug "Send data to local connection #{session_id}"
+          connection.send_data Message::Data.new(session_id,data).pack
+        end
+      end
+
+      def local_connections
+        @local_connections ||= LocalConnections.new
+      end
+
+      def receive_data(session_id, data)
+        local_connection = local_connections.find(session_id)
+        if local_connection
+          ReverseTunnel.logger.debug "Send data to local connection #{session_id}"
+          local_connection.send_data data
+        else
+          local_connections.bufferize session_id, data
+        end
+      end
+
+      def to_json
+        { :token => token, 
+          :local_port => local_port, 
+          :server_host => host, 
+          :server_port => port,
+          :local_connections => local_connections.as_json
+        }.tap do |attributes|
+          attributes[:connection] = connection.as_json if connection
+        end.to_json
+      end
+
+    end
+
+    class LocalConnections
+
+      attr_reader :connections
+
+      def initialize
+        @connections = []
+      end
+
+      def find(session_id)
+        connections.find { |c| c.session_id == session_id }
+      end
+
+      def push(connection)
+        connections << connection
+
+        session_id = connection.session_id
+        ReverseTunnel.logger.debug "Clear buffer for #{session_id}"
+
+        (buffers.delete(session_id) or []).each do |data|
+          connection.send_data data
+        end
+      end
+      alias_method :<<, :push
+
+      def buffers
+        @buffers ||= Hash.new { |h,k| h[k] = [] }
+      end
+
+      def bufferize(session_id, data)
+        ReverseTunnel.logger.debug "Push buffer for #{session_id}"
+        buffers[session_id] << data
+      end
+
+      def delete(connection)
+        connections.delete connection
+      end
+
+      def close_all
+        connections.each(&:close_connection)
+      end
+
+      def as_json
+        connections.map(&:as_json)
+      end
+
+    end
+
+    class TunnelConnection < EventMachine::Connection
+      attr_accessor :tunnel, :created_at
+
+      attr_reader :hearbeat
+
+      def initialize(tunnel)
+        @tunnel = tunnel
+      end
+
+      def post_init
+        ReverseTunnel.logger.debug "New tunnel connection"
+        self.created_at = Time.now
+
+        tunnel.connection = self
+        tunnel.open
+      end
+
+      def message_unpacker
+        @message_unpacker ||= Message::Unpacker.new
+      end
+
+      def as_json
+        { :created_at => created_at }
+      end
+
+      def receive_data(data)
+        ReverseTunnel.logger.debug "Received data '#{data.unpack('H*').join}'"
+        message_unpacker.feed data
+
+        message_unpacker.each do |message|
+          ReverseTunnel.logger.debug "Received message in tunnel #{message.inspect}"
+
+          if message.data?
+            tunnel.receive_data message.session_id, message.data
+          elsif message.open_session?
+            tunnel.open_session message.session_id
+          elsif message.ping?
+            tunnel.ping_received message
+          end
+        end
+      end
+
+      def unbind
+        ReverseTunnel.logger.debug "Close tunnel connection"
+        tunnel.connection = nil
+      end
+
+    end
+
+    class LocalConnection < EventMachine::Connection
+      attr_accessor :tunnel, :session_id
+
+      attr_reader :created_at, :received_size, :send_size
+
+      def initialize(tunnel, session_id)
+        @tunnel, @session_id = tunnel, session_id
+        @received_size = @send_size = 0
+      end
+
+      def post_init
+        ReverseTunnel.logger.debug "New local connection"
+        @created_at = Time.now
+        tunnel.local_connections << self
+      end
+
+      def receive_data(data)
+        ReverseTunnel.logger.debug "Received data in local connection #{session_id}"
+        @received_size += data.size
+        tunnel.send_data session_id, data
+      end
+
+      def unbind
+        ReverseTunnel.logger.debug "Close local connection #{session_id}"
+        tunnel.local_connections.delete self
+      end
+
+      def send_data(data)
+        ReverseTunnel.logger.debug "Send data '#{data.unpack('H*').join}'"
+        @send_size += data.size
+        super
+      end
+
+      def as_json
+        { :session_id => session_id, :created_at => created_at, :received_size => received_size, :send_size => send_size }
+      end
+
+    end
+
+    def start
+      EventMachine.run do
+        tunnel.start
+        start_api
+      end
+    end
+
+    def start_api
+      if api_host
+        ReverseTunnel.logger.info "Wait api requests #{api_host}:#{api_port}"
+        EventMachine.start_server api_host, api_port, ApiServer, tunnel
+      end
+    end
+
+    def tunnel
+      @tunnel ||= Tunnel.new(:token => token, :local_port => local_port, :host => server_host, :port => server_port)
+    end
+
+    attr_accessor :token, :local_port
+    attr_accessor :server_host, :server_port
+    attr_accessor :api_host, :api_port
+
+    def server_port
+      @server_port ||= 4893
+    end
+
+    def api_port
+      @api_port ||= 4895
+    end
+
+    def local_port
+      @local_port ||= 22
+    end
+
+  end
+end