coderrr-rtunnel 0.3.9 → 0.4.0

metadata

@@ -1,50 +1,94 @@
 --- !ruby/object:Gem::Specification 
 name: coderrr-rtunnel
 version: !ruby/object:Gem::Version 
-  version: 0.3.9
+  version: 0.4.0
 platform: ruby
 authors: 
 - coderrr
+- costan
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2008-10-25 00:00:00 -07:00
+date: 2009-01-11 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: uuidtools
+  name: eventmachine
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.0.2
+        version: 0.12.2
     version: 
-description: reverse tunnel server and client
+- !ruby/object:Gem::Dependency 
+  name: net-ssh
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.4
+    version: 
+description: ""
 email: coderrr.contact@gmail.com
-executables: []
-
+executables: 
+- rtunnel_client
+- rtunnel_server
 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
+- CHANGELOG
+- LICENSE
+- Manifest
 - README.markdown
-- rtunnel.gemspec
-- stress_test.rb
 - Rakefile
-- rtunnel_client.rb
-- rtunnel_server.rb
+- bin/rtunnel_client
+- bin/rtunnel_server
+- lib/rtunnel.rb
+- lib/rtunnel/client.rb
+- lib/rtunnel/command_protocol.rb
+- lib/rtunnel/commands.rb
+- lib/rtunnel/core.rb
+- lib/rtunnel/crypto.rb
+- lib/rtunnel/frame_protocol.rb
+- lib/rtunnel/io_extensions.rb
+- lib/rtunnel/leak.rb
+- lib/rtunnel/rtunnel_client_cmd.rb
+- lib/rtunnel/rtunnel_server_cmd.rb
+- lib/rtunnel/server.rb
+- lib/rtunnel/socket_factory.rb
+- lib/rtunnel/connection_id.rb
+- lib/rtunnel/command_processor.rb
+- spec/client_spec.rb
+- spec/cmds_spec.rb
+- spec/integration_spec.rb
+- spec/server_spec.rb
+- spec/spec_helper.rb
+- test/command_stubs.rb
+- test/protocol_mocks.rb
+- test/scenario_connection.rb
+- test/test_client.rb
+- test/test_command_protocol.rb
+- test/test_commands.rb
+- test/test_crypto.rb
+- test/test_frame_protocol.rb
+- test/test_io_extensions.rb
+- test/test_server.rb
+- test/test_socket_factory.rb
+- test/test_tunnel.rb
+- test/test_connection_id.rb
+- test_data/known_hosts
+- test_data/ssh_host_rsa_key
+- test_data/random_rsa_key
+- test_data/ssh_host_dsa_key
+- test_data/authorized_keys2
+- tests/_ab_test.rb
+- tests/_stress_test.rb
+- tests/lo_http_server.rb
 has_rdoc: false
 homepage: http://github.com/coderrr/rtunnel
 post_install_message: 
@@ -70,10 +114,6 @@ 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
+summary: Reverse tunnel server and client.
+test_files: []
+

data/ab_test.rb

@@ -1,23 +0,0 @@
-#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/lib/client.rb

@@ -1,150 +0,0 @@
-require 'core'
-require 'cmds'
-require 'leak'
-
-require 'gserver'
-require 'timeout'
-
-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

@@ -1,166 +0,0 @@
-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