coderrr-rtunnel 0.3.8

data/README.markdown

@@ -0,0 +1,59 @@
+INSTALL
+-
+
+on server and local machine:
+
+`gem install rtunnel`
+
+If you don't have root access on server, you can use either the rtunnel_server_linux binary (only works with linux), or extract the .tar.gz and use `rtunnel_server.rb` (all function the same)
+
+USAGE
+-
+
+on server (myserver.com):
+
+`rtunnel_server`
+
+on your local machine:
+
+`rtunnel_client -c myserver.com -f 4000 -t 3000`
+
+This would reverse tunnel myserver.com:4000 to localhost:3000 so that if you had a web server running at port 3000 on your local machine, anyone on the internet could access it by going to http://myserver.com:4000
+
+**News**
+
+  * 0.3.6 released, new protocol
+  * created gem for easier installation
+  * 0.2.1 released, minor bugfix, cmdline options change
+  * 0.2.0 released, much simpler
+  * 0.1.2 released
+  * Created rtunnel_server binary for linux so you don't need Ruby installed on the host you want to reverse tunnel from
+  * 0.1.1 released
+  * Added default control port of 19050, no longer have to specify this on client or server unless you care to change it
+
+RTunnel?
+-
+
+This client/server allow you to reverse tunnel traffic.  Reverse tunneling is useful if you want to run a server behind a NAT and you do not have the ability use port forwarding.  The specific reason I created this program was to reduce the pain of Facebook App development on a crappy internet connection that drops often.  ssh -R was not cutting it.
+
+**How does reverse tunneling work?**
+
+  * tunnel\_client makes connection to tunnel\_server (through NAT)
+  * tunnel_server listens on port X
+  * internet_user connects to port X on tunnel server
+  * tunnel\_server uses existing connection to tunnel internet user's request back to tunnel\_client
+  * tunnel_client connects to local server on port Y
+  * tunnel_client tunnels internet users connection through to local server
+
+or:
+
+  * establish connection: tunnel\_client --NAT--> tunnel\_server
+  * reverse tunnel: internet\_user -> tunnel_server --(NAT)--> tunnel\_client -> server\_running\_behind\_nat
+
+**How is this different than normal tunneling?**
+
+With tunneling, usually your connections are made in the same direction you create the tunnel connection.  With reverse tunneling, you tunnel your connections the opposite direction of which you made the tunnel connection.  So you initiate the tunnel with A -> B, but connections are tunneled from B -> A.
+
+**Why not just use ssh -R?**
+
+The same thing can be achieved with ssh -R, why not just use it?  A lot of ssh servers don't have the GatewayPorts sshd option set up to allow you to reverse tunnel.  If you are not in control of the server and it is not setup correctly then you are SOL.  RTunnel does not require you are in control of the server.  ssh -R has other annoyances.  When your connection drops and you try to re-initiate the reverse tunnel sometimes you get an address already in use error because the old tunnel process is still laying around.  This requires you to kill the existing sshd process.  RTunnel does not have this problem.

data/Rakefile

@@ -0,0 +1,18 @@
+require 'rake'
+require 'spec/rake/spectask'
+require 'lib/core'
+
+desc "Run all examples"
+Spec::Rake::SpecTask.new('spec') do |t|
+  t.spec_files = FileList['spec/**/*.rb']
+end
+
+desc "Create packages"
+task :pkg4google do
+  system %Q{cd .. && tar cvzf rtunnel/pkg/rtunnel-#{RTunnel::VERSION}.tar.gz rtunnel \
+            --exclude=.svn --exclude=pkg --exclude=rtunnel.ipr --exclude=rtunnel.iws \
+            --exclude=rtunnel.iml
+            }
+  system "rubyscript2exe rtunnel_server.rb --stop-immediately && 
+          mv rtunnel_server_linux pkg/rtunnel_server_linux-#{RTunnel::VERSION}"
+end

data/ab_test.rb

@@ -0,0 +1,23 @@
+#require 'facets'
+require 'net/http'
+require 'logger'
+require 'stringio'
+require 'webrick'
+
+require 'lib/core'
+
+puts "make sure a fast responding webserver is started on port 4000"
+
+base_dir = File.dirname(__FILE__)
+
+fork{ exec "ruby #{base_dir}/rtunnel_server.rb > /dev/null 2>&1" }
+fork{ exec "ruby #{base_dir}/rtunnel_client.rb -c localhost -f 5000 -t 4000 > /dev/null" }
+
+sleep 2
+
+(puts "you need ab (apache bench) to run this stress test" ; exit) if %x{which ab}.empty?
+
+Process.wait fork { exec("ab -c 500 -n 10000 http://localhost:5000/") }
+
+puts "done, hit ^C"
+sleep 999999

data/bin/rtunnel_client

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+load 'rtunnel_client_cmd.rb'

data/bin/rtunnel_server

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+load 'rtunnel_server_cmd.rb'

data/lib/client.rb

@@ -0,0 +1,156 @@
+require 'rubygems'
+
+require 'gserver'
+require 'optparse'
+require 'timeout'
+require 'resolv'
+
+require 'core'
+require 'cmds'
+require 'leak'
+
+$debug = true
+
+module RTunnel
+  class Client
+    CONNECTIONS = {}
+
+    def initialize(options = {})
+      @control_address = options[:control_address]
+      @control_address << ":#{DEFAULT_CONTROL_PORT}"  if @control_address !~ /:\d+$/
+      @control_host = @control_address.split(/:/).first
+
+      @remote_listen_address = options[:remote_listen_address]
+      @remote_listen_address.insert 0, "0.0.0.0:"  if @remote_listen_address =~ /^\d+$/
+
+      @tunnel_to_address = options[:tunnel_to_address]
+      @tunnel_to_address.insert 0, "localhost:"  if @tunnel_to_address =~ /^\d+$/
+
+      [@control_address, @remote_listen_address, @tunnel_to_address].each do |addr|
+        addr.replace_with_ip!
+      end
+
+      @ping_timeout = options[:ping_timeout] || PING_TIMEOUT
+    end
+
+    def start
+      @threads = []
+
+      @last_ping = Time.now
+
+      @threads << Thread.safe do
+        loop do
+          if @check_ping and (Time.now - @last_ping) > @ping_timeout
+            D "control connection timeout"
+            @control_sock.close  rescue nil
+          end
+
+          sleep 1
+        end
+      end
+
+      # Memory leak testing
+      LeakTracker.start
+
+      @main_thread = Thread.safe do
+        loop do
+          stop_ping_check
+          D "connecting to control address (#{@control_address})"
+          @control_sock = begin
+            timeout(5) { TCPSocket.new(*@control_address.split(/:/)) }
+          rescue Exception
+            D "fail"
+            sleep 1
+            next
+          end
+
+          start_ping_check
+
+          write_to_control_sock RemoteListenCommand.new(@remote_listen_address)
+
+          cmd_queue = ""
+          while data = (@control_sock.readpartial(16384)  rescue (D "control sock read error: #{$!.inspect}"; nil))
+            cmd_queue << data
+            while Command.match(cmd_queue)
+              case command = Command.parse(cmd_queue)
+              when PingCommand
+                @last_ping = Time.now
+              when CreateConnectionCommand
+                begin
+                  # TODO: this currently blocks, but if we put it in thread, a SendDataCommand may try to get run for this connection before the connection exists
+                  CONNECTIONS[command.conn_id] = TCPSocket.new(*@tunnel_to_address.split(/:/))
+
+                  Thread.safe do
+                    cmd = command
+                    conn = CONNECTIONS[cmd.conn_id]
+
+                    begin
+                      while localdata = conn.readpartial(16834)
+                        write_to_control_sock SendDataCommand.new(cmd.conn_id, localdata)
+                      end
+                    rescue Exception
+                      begin
+                        D "to tunnel closed, closing from tunnel"
+                        conn.close
+                        CONNECTIONS.delete cmd.conn_id
+                        write_to_control_sock CloseConnectionCommand.new(cmd.conn_id)
+                      rescue
+                        p $!
+                        puts $!.backtrace.join("\n")
+                      end
+                    end
+                  end                  
+                rescue Exception
+                  D "error connecting to local port"
+                  write_to_control_sock CloseConnectionCommand.new(command.conn_id)
+                end
+              when CloseConnectionCommand
+                D "closing connection #{command.conn_id}"
+                if connection = CONNECTIONS[command.conn_id]
+                  # TODO: how the hell do u catch a .close error?
+                  connection.close_read
+                  #connection.close  unless connection.closed?
+                  CONNECTIONS.delete(command.conn_id)
+                end
+              when SendDataCommand
+                if connection = CONNECTIONS[command.conn_id]
+                  connection.write(command.data)
+                else
+                  puts "WARNING: received data for non existant connection!"
+                end
+              end
+            end
+          end
+        end
+      end
+
+      @threads << @main_thread
+    end
+
+    def join
+      @main_thread.join
+    end
+
+    def stop
+      @threads.each { |t| t.kill! rescue nil}
+      @control_sock.close  rescue nil
+    end
+
+    private
+
+    def write_to_control_sock(data)
+      (@control_sock_mutex ||= Mutex.new).synchronize do
+        @control_sock.write data
+      end
+    end
+
+    def start_ping_check
+      @last_ping = Time.now
+      @check_ping = true
+    end
+
+    def stop_ping_check
+      @check_ping = false
+    end
+  end
+end

data/lib/cmds.rb

@@ -0,0 +1,166 @@
+module RTunnel
+  class Command
+
+    def to_s
+      CLASSES_TO_CODES[self.class].dup
+    end
+
+    class << self
+      def parse(data)
+        klass = class_from_code(data[0..0])
+
+        new_data = data[1..-1]
+        cmd = klass.parse(new_data)
+
+        data.replace(new_data)
+
+        cmd
+      end
+
+      def match(data)
+        return false  if ! (klass = class_from_code(data[0..0]))
+
+        klass.match(data[1..-1])
+      end
+
+      private
+
+      def class_from_code(code)
+        CODES_TO_CLASSES[code]
+      end
+    end
+  end
+
+  class ConnectionCommand < Command
+    attr_reader :conn_id
+
+    def initialize(conn_id)
+      @conn_id = conn_id
+    end
+
+    def to_s
+      super + "#{conn_id}|"
+    end
+
+    class << self
+      RE = %r{^([^|]+)\|}
+
+      def parse(data)
+        data =~ RE
+        conn_id = $1
+
+        cmd = self.new(conn_id)
+
+        data.sub! RE, ''
+
+        cmd
+      end
+
+      def match(data)
+        !! (data =~ RE)
+      end
+    end
+
+  end
+
+  class CreateConnectionCommand < ConnectionCommand
+  end
+
+  class CloseConnectionCommand < ConnectionCommand
+  end
+
+  class SendDataCommand < Command
+    attr_reader :conn_id
+    attr_reader :data
+
+    def initialize(conn_id, data)
+      @conn_id = conn_id
+      @data = data
+    end
+
+    def to_s
+      super + "#{conn_id}|#{data.size}|#{data}"
+    end
+
+    class << self
+      RE = %r{^([^|]+)\|([^|]+)\|}
+
+      def parse(data)
+        data =~ RE
+
+        conn_id = $1
+        data_size = $2.to_i
+
+        new_data = data.sub(RE, '')
+        cmd_data = new_data[0,data_size]
+
+        cmd = SendDataCommand.new(conn_id, cmd_data)
+
+        data.replace(new_data[data_size..-1])
+
+        cmd
+      end
+
+      def match(data)
+        return false  if ! (data =~ RE)
+
+        data_size = $2.to_i
+
+        data.sub(RE, '').size >= data_size
+      end
+    end
+  end
+
+  class RemoteListenCommand < Command
+    attr_reader :address
+
+    def initialize(address)
+      @address = address
+    end
+
+    def to_s
+      super + "#{address}|"
+    end
+
+    class << self
+      RE = %r{^([^|]+)\|}
+
+      def parse(data)
+        data =~ RE
+        address = $1
+
+        cmd = self.new(address)
+
+        data.sub! RE, ''
+
+        cmd
+      end
+
+      def match(data)
+        !! (data =~ RE)
+      end
+    end
+
+  end
+
+  class PingCommand < Command
+    def self.parse(data)
+      PingCommand.new
+    end
+
+    def self.match(data)
+      true
+    end
+  end
+
+  class Command
+    CODES_TO_CLASSES = {
+      "C" => CreateConnectionCommand,
+      "X" => CloseConnectionCommand,
+      "D" => SendDataCommand,
+      "P" => PingCommand,
+      "L" => RemoteListenCommand,
+    }
+    CLASSES_TO_CODES = CODES_TO_CLASSES.invert
+  end
+end

data/lib/core.rb

@@ -0,0 +1,53 @@
+module RTunnel
+  VERSION = '0.3.8'
+  
+  DEFAULT_CONTROL_PORT = 19050
+  PING_TIMEOUT = 10
+end
+
+
+def D(msg)
+  puts msg  if $debug
+end
+
+class << Thread
+  def safe(*a)
+    Thread.new(*a) do
+      begin
+        yield
+      rescue Exception
+        puts $!.inspect
+        puts $!.backtrace.join("\n")
+      end  
+    end
+  end
+end
+
+class String
+  def replace_with_ip!
+    host = self.split(/:/).first
+
+    ip = timeout(5) { Resolv.getaddress(host) }
+
+    self.replace(self.gsub(host, ip))
+  rescue Exception
+    puts "Error resolving #{host}"
+    exit
+  end
+end
+
+class IO
+  def while_reading(data = nil, &b)
+    while buf = readpartial_rescued(1024)
+      data << buf  if data
+      yield buf  if block_given?
+    end
+    data
+  end
+
+  def readpartial_rescued(size)
+    readpartial(size)
+  rescue EOFError
+    nil
+  end
+end

data/lib/rtunnel_client_cmd.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << 'lib'
+
+require 'client'
+
+$debug = true
+
+control_address = tunnel_from_address = tunnel_to_address = remote_listen_address = nil
+
+(opts = OptionParser.new do |o|
+  o.on("-c", "--control-address ADDRESS") { |a| control_address = a }
+  o.on("-f", "--remote-listen-port ADDRESS") { |a| remote_listen_address = a }
+  o.on("-t", "--tunnel-to ADDRESS") { |a| tunnel_to_address = a }
+end).parse!  rescue (puts opts; exit)
+
+(puts opts; exit)  if [control_address, remote_listen_address, tunnel_to_address].include? nil
+
+client = RTunnel::Client.new(
+  :control_address => control_address,
+  :remote_listen_address => remote_listen_address,
+  :tunnel_to_address => tunnel_to_address
+)
+client.start
+client.join

data/lib/rtunnel_server_cmd.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/ruby
+
+$LOAD_PATH << 'lib'
+
+require 'server'
+
+$debug = true
+
+control_address = tunnel_port = nil
+
+(opts = OptionParser.new do |o|
+  o.on("-c", "--control ADDRESS") { |a| control_address = a }
+end).parse!  rescue (puts opts; exit)
+
+server = RTunnel::Server.new(
+  :control_address => control_address
+)
+
+server.start
+server.join

data/lib/server.rb

@@ -0,0 +1,199 @@
+require 'rubygems'
+
+require 'gserver'
+require 'optparse'
+require 'uuidtools'
+
+require 'core'
+require 'cmds'
+
+Socket.do_not_reverse_lookup = true
+
+$debug = true
+
+module RTunnel
+  # listens for incoming connections to tunnel
+  class RemoteListenServer < GServer
+    CONNECTIONS = {}
+    CONTROL_CONNECTION_MAPPING = {}
+
+    def initialize(port, host, control_connection)
+      super(port, host, 10)
+      @control_connection = control_connection
+      @maxConnections = 1024
+    end
+
+    def serve(sock)
+      D "new incoming connection"
+
+      conn_id = UUID.timestamp_create.hexdigest
+      CONNECTIONS[conn_id] = sock
+      CONTROL_CONNECTION_MAPPING[conn_id] = @control_connection
+      begin
+        ControlServer.new_tunnel(conn_id)
+
+        sock.while_reading do |buf|
+          begin
+            ControlServer.send_data(conn_id, buf)
+          rescue Exception
+            D "error talking on control connection, dropping incoming connection: #{$!.inspect}"
+            break
+          end
+        end
+      rescue IOError
+        raise  unless $!.message =~ /stream closed/i
+      end
+
+      ControlServer.close_tunnel(conn_id)
+
+      CONNECTIONS.delete conn_id
+      CONTROL_CONNECTION_MAPPING.delete conn_id
+
+      D "sock closed"
+    rescue
+      p $!
+      puts $!.backtrace.join("\n")
+    end
+  end
+
+  class ControlServer < GServer
+    @@control_connections = []
+    @@remote_listen_servers = []
+
+    @@m = Mutex.new
+
+    attr_accessor :ping_interval
+
+    def initialize(*args)
+      super
+      @maxConnections = 1024
+    end
+
+    class << self
+      def new_tunnel(conn_id)
+        D "sending create connection command: #{conn_id}"
+
+        @@m.synchronize { control_connection_for(conn_id).write CreateConnectionCommand.new(conn_id) }
+      end
+
+      def send_data(conn_id, data)
+        @@m.synchronize { control_connection_for(conn_id).write SendDataCommand.new(conn_id, data) }
+      end
+
+      def close_tunnel(conn_id)
+        D "sending close connection command"
+
+        @@m.synchronize { control_connection_for(conn_id).write CloseConnectionCommand.new(conn_id) }
+      end
+
+      private
+
+      def control_connection_for(conn_id)
+        RemoteListenServer::CONTROL_CONNECTION_MAPPING[conn_id]
+      end
+    end
+
+    def starting
+      start_pinging
+    end
+
+    def serve(sock)
+      D "new control connection"
+      @@control_connections << sock
+      sock.sync = true
+
+      cmd_queue = ""
+      sock.while_reading(cmd_queue = '') do
+        while Command.match(cmd_queue)
+          case cmd = Command.parse(cmd_queue)
+          when RemoteListenCommand
+            @@m.synchronize do
+              addr, port = cmd.address.split(/:/)
+              if rls = @@remote_listen_servers.detect {|s| s.port == port.to_i }
+                rls.stop
+                @@remote_listen_servers.delete rls
+              end
+              (new_rls = RemoteListenServer.new(port, addr, sock)).start
+              @@remote_listen_servers << new_rls
+            end
+            D "listening for remote connections on #{cmd.address}"
+          when SendDataCommand
+            conn = RemoteListenServer::CONNECTIONS[cmd.conn_id]
+            begin
+              conn.write(cmd.data)  if conn
+            rescue Errno::EPIPE
+              D "broken pipe on #{cmd.conn_id}"
+            end
+          when CloseConnectionCommand
+            if connection = RemoteListenServer::CONNECTIONS[cmd.conn_id]
+              D "closing remote connection: #{cmd.conn_id}"
+              connection.close
+            end
+          else
+            D "bad command received: #{cmd.inspect}"
+          end
+        end
+      end
+    rescue Errno::ECONNRESET
+      D "client disconnected (conn reset)"
+    rescue
+      D $!.inspect
+      D $@*"\n"
+      raise
+    ensure
+      @@control_connections.delete sock
+    end
+
+    def stopping
+      @ping_thread.kill
+      @@remote_listen_server.stop
+    end
+
+    private
+
+    def start_pinging
+      @ping_thread = Thread.safe do
+        loop do
+          sleep @ping_interval
+
+          @@m.synchronize do
+            @@control_connections.each {|cc| cc.write PingCommand.new }
+          end
+        end
+      end
+    end
+  end
+
+  class Server
+    def initialize(options = {})
+      @control_address = options[:control_address]
+      if ! @control_address
+        @control_address = "0.0.0.0:#{DEFAULT_CONTROL_PORT}"  if ! @control_address
+      elsif @control_address =~ /^\d+$/
+        @control_address.insert 0, "0.0.0.0:"
+      elsif @control_address !~ /:\d+$/
+        @control_address << ":#{DEFAULT_CONTROL_PORT}"
+      end
+      @control_host = @control_address.split(/:/).first
+
+      @ping_interval = options[:ping_interval] || 2.0
+    end
+
+    def start
+      @control_server = ControlServer.new(*@control_address.split(/:/).reverse)
+      @control_server.ping_interval = @ping_interval
+      @control_server.audit = true
+
+      @control_server.start
+    end
+
+    def join
+      @control_server.join
+    end
+
+    def stop
+      @control_server.shutdown
+      ControlServer.stop(@control_server.port, @control_server.host)
+    end
+  end
+end

data/rtunnel.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.name     = "rtunnel"
+  s.version  = "0.3.8"
+  s.summary  = "reverse tunnel server and client"
+  s.email    = "coderrr.contact@gmail.com"
+  s.homepage = "http://github.com/coderrr/rtunnel"
+  s.description = "reverse tunnel server and client"
+  s.has_rdoc = false
+  s.authors  = ["coderrr"]
+  s.files    = [
+    "lib/rtunnel_server_cmd.rb", "lib/client.rb", "lib/core.rb", "lib/rtunnel_client_cmd.rb", "lib/server.rb", "lib/cmds.rb", "bin/rtunnel_server", "bin/rtunnel_client",
+   "ab_test.rb", "README.markdown", "rtunnel.gemspec", "stress_test.rb", "Rakefile", "rtunnel_client.rb", "rtunnel_server.rb" 
+    ]
+  s.test_files = [
+    "spec/integration_spec.rb", "spec/spec_helper.rb", "spec/client_spec.rb", "spec/cmds_spec.rb", "spec/server_spec.rb"
+  ]
+  s.add_dependency("uuidtools", [">= 1.0.2"])
+end

data/rtunnel_client.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+load 'lib/rtunnel_client_cmd.rb'

data/rtunnel_server.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/ruby
+
+load 'lib/rtunnel_server_cmd.rb'

data/spec/client_spec.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'client'
+
+include RTunnel
+describe RTunnel::Client, "addresses" do
+  def o(opts)
+    {:control_address => 'x.com', :remote_listen_address => '5555', :tunnel_to_address => '6666'}.merge opts
+  end
+
+  before :all do
+    String.class_eval do
+      alias_method :orig_replace_with_ip!, :replace_with_ip!
+      define_method :replace_with_ip! do
+        self
+      end
+    end
+  end
+
+  after :all do
+    String.class_eval do
+      alias_method :replace_with_ip!, :orig_replace_with_ip!
+    end
+  end
+
+  it "should use default control port if not specified" do
+    Client.new(o :control_address => 'asdf.net').
+      instance_eval { @control_address }.should == "asdf.net:#{DEFAULT_CONTROL_PORT}"
+
+    Client.new(o :control_address => 'asdf.net:1234').
+      instance_eval { @control_address }.should == "asdf.net:1234"
+  end
+
+  it "should use 0.0.0.0 for remote listen host if not specified" do
+    Client.new(o :control_address => 'asdf.net:1234', :remote_listen_address => '8888').
+      instance_eval { @remote_listen_address }.should == '0.0.0.0:8888'
+
+    Client.new(o :control_address => 'asdf.net:1234', :remote_listen_address => 'ip2.asdf.net:8888').
+      instance_eval { @remote_listen_address }.should == 'ip2.asdf.net:8888'
+  end
+
+  it "should use localhost for tunnel to address if not specified" do
+    Client.new(o :tunnel_to_address => '5555').
+      instance_eval { @tunnel_to_address }.should == 'localhost:5555'
+  end
+
+end

data/spec/cmds_spec.rb

@@ -0,0 +1,127 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'cmds'
+
+include RTunnel
+
+describe RTunnel::CreateConnectionCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = CreateConnectionCommand.new("id").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == CreateConnectionCommand
+    cmd.conn_id.should == "id"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = CreateConnectionCommand.new("abcbdefg").to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+describe RTunnel::SendDataCommand do
+  it "should be able to serialzied and parse itself" do
+    serialized = SendDataCommand.new("id", "here is some data").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == SendDataCommand
+    cmd.conn_id.should == "id"
+    cmd.data.should == "here is some data"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = SendDataCommand.new("abcbdefg", "and here is some data").to_s
+
+    serialized << "WAY MORE CRAP DATA!!!"
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should == "WAY MORE CRAP DATA!!!"
+  end
+end
+
+describe RTunnel::CloseConnectionCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = CloseConnectionCommand.new("id").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == CloseConnectionCommand
+    cmd.conn_id.should == "id"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = CloseConnectionCommand.new("abcbdefg").to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+describe RTunnel::PingCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = PingCommand.new.to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == PingCommand
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = PingCommand.new.to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+
+describe RTunnel::RemoteListenCommand do
+  it "should be able to serialize and parse itself" do
+    serialized = RemoteListenCommand.new("0.0.0.0:1234").to_s
+
+    cmd = Command.parse(serialized)
+    cmd.class.should == RemoteListenCommand
+    cmd.address.should == "0.0.0.0:1234"
+  end
+
+  it "should be able to match itself and remove itself from the stream" do
+    serialized = RemoteListenCommand.new("0.0.0.0:1234").to_s
+
+    Command.match(serialized).should == true
+    Command.parse(serialized)
+    serialized.should be_empty
+  end
+end
+
+
+describe RTunnel::Command do
+  it "should be able to match a command in a stream" do
+    Command.match("C1234abc|").should == true
+    Command.match("C1234abc").should == false
+    Command.match("C1234abc|C|").should == true
+
+    Command.match("Did|15|DATA").should == false
+    Command.match("Did|1|DATA").should == true
+    Command.match("Did|4|\0\0\0\0").should == true
+
+    data = "C1234abc|D1234abc|15|here is my dataX1234abc|L0.0.0.0:1234|CASDF"
+    cmd1 = Command.parse(data)
+    cmd2 = Command.parse(data)
+    cmd3 = Command.parse(data)
+    cmd4 = Command.parse(data)
+    cmd1.class.should == CreateConnectionCommand
+    cmd1.conn_id.should == "1234abc"
+    cmd2.class.should == SendDataCommand
+    cmd2.conn_id.should == "1234abc"
+    cmd3.class.should == CloseConnectionCommand
+    cmd3.conn_id.should == "1234abc"
+    cmd4.class.should == RemoteListenCommand
+    cmd4.address.should == "0.0.0.0:1234"
+
+    Command.match(data).should == false
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,105 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'client'
+require 'server'
+
+describe "RTunnel" do
+  class TextServer < GServer
+    def initialize(port, text)
+      @text = text
+      super(port)
+    end
+
+    def serve(io)
+      io.write(@text)
+    end
+  end
+
+  def read_from_address(addr)
+    timeout(2) { TCPSocket.open(*addr.split(/:/)) {|s| s.read } }
+  end
+
+  it "should work!" do
+    begin
+      server = RTunnel::Server.new(:control_address => 'localhost:9999')
+      client = RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30002', :tunnel_to_address => '30003')
+
+      server.start
+      client.start
+
+      s = TextServer.new(30003, echo_text = "tunnel this txt plz!")
+      s.start
+
+      sleep 0.5
+
+      # direct connect (sanity check)
+      read_from_address('localhost:30003').should == echo_text
+      # tunneled connect
+      read_from_address('localhost:30002').should == echo_text
+    ensure
+      begin
+        client.stop
+        server.stop
+        s.stop
+      rescue
+      end
+    end
+  end
+
+  it "should ping all clients periodically" do
+    begin
+      server = RTunnel::Server.new(:control_address => 'localhost:9999', :ping_interval => 0.2)
+      clients = []
+      clients << RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30002', :tunnel_to_address => '30003')
+      clients << RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30012', :tunnel_to_address => '30013')
+      server.start
+      clients.each{|c|c.start}
+
+      pings = Hash.new {|h,k| h[k] = [] }
+      t = Thread.new do
+        loop do
+          clients.each do |client|
+            pings[client] << client.instance_eval { @last_ping }
+          end
+          sleep 0.05
+        end
+      end
+
+      sleep 2
+
+      clients.each do |client|
+        # 2 seconds, 0.2 pings a sec = ~10 pings
+        (9..11).should include(pings[client].uniq.size)
+      end
+    ensure
+      t.kill
+      begin
+        clients.each{|c|c.stop}
+        server.stop
+      rescue
+        p $!,$@
+      end
+    end
+  end
+
+  it "the client shouldnt fail even if there is no server running at the tunnel_to address" do
+    begin
+      server = RTunnel::Server.new(:control_address => 'localhost:9999')
+      client = RTunnel::Client.new(:control_address => 'localhost:9999', :remote_listen_address => '30002', :tunnel_to_address => '30003')
+
+      server.start
+      client.start
+
+      sleep 0.5
+
+      # tunneled connect
+      read_from_address('localhost:30002').should be_empty
+    ensure
+      begin
+        client.stop
+        server.stop
+      rescue
+      end
+    end
+  end
+end

data/spec/server_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+require 'server'
+
+include RTunnel
+describe RTunnel::Server, "addresses" do
+  it "control address should listen on all interfaces and use default control port if not specified" do
+    Server.new(:control_address => nil).
+      instance_eval { @control_address }.should == "0.0.0.0:#{DEFAULT_CONTROL_PORT}"
+
+    Server.new(:control_address => '5555').
+      instance_eval { @control_address }.should == "0.0.0.0:5555"
+
+    Server.new(:control_address => 'interface2').
+      instance_eval { @control_address }.should == "interface2:#{DEFAULT_CONTROL_PORT}"
+
+    Server.new(:control_address => 'interface2:2222').
+      instance_eval { @control_address }.should == "interface2:2222"
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+$LOAD_PATH << File.dirname(__FILE__) + "/../lib"
+
+require 'spec'

data/stress_test.rb

@@ -0,0 +1,74 @@
+require 'rubygems'
+
+require 'mongrel'
+require 'facets'
+require 'facets/random'
+require 'logger'
+require 'stringio'
+
+require 'lib/core'
+
+pids = []
+at_exit do
+  pids.each {|pid| Process.kill 9, pid }
+  p $!
+  puts "done, hit ^C"
+  sleep 999999
+end
+
+module Enumerable
+  def parallel_map
+    self.map do |e|
+      Thread.new(e) do |element|
+        yield element
+      end
+    end.map {|thread| thread.value }
+  end
+end
+
+CONCURRENT_CONNECTIONS = 25
+
+TUNNEL_PORT = 5000
+HTTP_PORT = 4444
+TUNNEL_URI = "http://localhost:#{TUNNEL_PORT}"
+EXPECTED_DATA = String.random(10*1024)
+
+puts EXPECTED_DATA.inspect
+
+p :gend_random_data
+
+require 'thin'
+app = lambda { |env| [200, {}, EXPECTED_DATA] }
+server = ::Thin::Server.new('localhost', HTTP_PORT, app)
+Thread.new { server.start }
+
+p :started_stressed_server
+
+base_dir = File.dirname(__FILE__)
+
+pids << fork{ exec "ruby #{base_dir}/rtunnel_server.rb > /dev/null 2>&1" }
+pids << fork{ exec "ruby #{base_dir}/rtunnel_client.rb -c localhost -f #{TUNNEL_PORT} -t #{HTTP_PORT} > /dev/null 2>&1" }
+
+p :started_rtunnels
+
+sleep 2
+
+p :slept
+
+STDOUT.sync = true
+999999999.times do |i|
+  puts i  if i%10 == 0
+  threads = []
+  CONCURRENT_CONNECTIONS.times do
+    threads << Thread.new do
+      text = %x{curl --silent #{TUNNEL_URI}}
+      if text != EXPECTED_DATA
+        puts "BAD!!!!"*1000
+        puts "response: #{text.inspect}"
+        exit
+      end
+    end
+  end
+
+  threads.parallel_map {|t| t.join; print '.'; STDOUT.flush }
+end

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification 
+name: coderrr-rtunnel
+version: !ruby/object:Gem::Version 
+  version: 0.3.8
+platform: ruby
+authors: 
+- coderrr
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: uuidtools
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.0.2
+    version: 
+description: reverse tunnel server and client
+email: coderrr.contact@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/rtunnel_server_cmd.rb
+- lib/client.rb
+- lib/core.rb
+- lib/rtunnel_client_cmd.rb
+- lib/server.rb
+- lib/cmds.rb
+- bin/rtunnel_server
+- bin/rtunnel_client
+- ab_test.rb
+- README.markdown
+- rtunnel.gemspec
+- stress_test.rb
+- Rakefile
+- rtunnel_client.rb
+- rtunnel_server.rb
+has_rdoc: false
+homepage: http://github.com/coderrr/rtunnel
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: reverse tunnel server and client
+test_files: 
+- spec/integration_spec.rb
+- spec/spec_helper.rb
+- spec/client_spec.rb
+- spec/cmds_spec.rb
+- spec/server_spec.rb