coderrr-rtunnel 0.3.9 → 0.4.0

data/lib/core.rb

@@ -1,58 +0,0 @@
-require 'resolv'
-
-module RTunnel
-  VERSION = '0.3.9'
-  
-  DEFAULT_CONTROL_PORT = 19050
-  PING_TIMEOUT = 10
-end
-
-if ENV['RTUNNEL_DEBUG']
-  def D(msg)
-    puts msg
-  end
-else
-  def D(*a);end
-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}"
-    raise
-  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

@@ -1,23 +0,0 @@
-#!/usr/bin/ruby
-
-$LOAD_PATH << 'lib'
-require 'optparse'
-require 'client'
-
-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

@@ -1,18 +0,0 @@
-#!/usr/bin/ruby
-
-$LOAD_PATH << 'lib'
-require 'optparse'
-require 'server'
-
-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

@@ -1,197 +0,0 @@
-require 'rubygems'
-gem 'uuidtools', '>=1.0.2'
-require 'uuidtools'
-
-require 'core'
-require 'cmds'
-
-require 'gserver'
-
-Socket.do_not_reverse_lookup = 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

@@ -1,18 +0,0 @@
-Gem::Specification.new do |s|
-  s.name     = "rtunnel"
-  s.version  = "0.3.9"
-  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

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

data/rtunnel_server.rb

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

data/stress_test.rb

@@ -1,68 +0,0 @@
-require 'rubygems'
-require 'thin'
-
-require 'lib/core'
-
-require 'logger'
-require 'stringio'
-
-
-CONCURRENT_CONNECTIONS = 25
-DISPLAY_RTUNNEL_OUTPUT = false
-TUNNEL_PORT = 5000
-HTTP_PORT = 4444
-
-#################
-
-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
-
-TUNNEL_URI = "http://localhost:#{TUNNEL_PORT}"
-EXPECTED_DATA = (0..10*1024).map{0until(c=rand(?z).chr)=~/(?!_)\w/;c}*'' # gen random string GOLF FTW!
-puts EXPECTED_DATA
-
-app = lambda { |env| [200, {}, EXPECTED_DATA] }
-server = ::Thin::Server.new('localhost', HTTP_PORT, app)
-Thread.new { server.start }
-
-base_dir = File.dirname(__FILE__)
-
-d = !DISPLAY_RTUNNEL_OUTPUT
-pids << fork{ exec "ruby #{base_dir}/rtunnel_server.rb #{d && '> /dev/null'} 2>&1" }
-pids << fork{ exec "ruby #{base_dir}/rtunnel_client.rb -c localhost -f #{TUNNEL_PORT} -t #{HTTP_PORT} #{d &&' > /dev/null'} 2>&1" }
-
-puts 'wait 2 secs'
-sleep 2
-
-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