rtunnel 0.2.3 → 0.3.0

data/lib/client.rb

@@ -3,10 +3,18 @@ require 'optparse'
 require 'timeout'
 require 'resolv'
 
+require 'facets'
+require 'synchash'
+
 require 'core'
+require 'cmds'
+
+$debug = true
 
 module RTunnel
   class Client
+    CONNECTIONS = SyncHash.new
+
     def initialize(options = {})
       @control_address = options[:control_address]
       @control_address << ":#{DEFAULT_CONTROL_PORT}"  if @control_address !~ /:\d+$/
@@ -18,9 +26,7 @@ module RTunnel
       @tunnel_to_address = options[:tunnel_to_address]
       @tunnel_to_address.insert 0, "localhost:"  if @tunnel_to_address =~ /^\d+$/
 
-      @tunnel_from_address = @control_host + ":#{options[:tunnel_port] || DEFAULT_TUNNEL_PORT}"
-
-      [@control_address, @remote_listen_address, @tunnel_to_address, @tunnel_from_address].each do |addr|
+      [@control_address, @remote_listen_address, @tunnel_to_address].each do |addr|
         addr.replace_with_ip!
       end
 
@@ -43,6 +49,39 @@ module RTunnel
         end
       end
 
+=begin
+      # Memory leak testing
+      Thread.safe do
+        sleep 10
+        begin
+          objects = Hash.new 0
+
+          while true
+            last_objects = objects.dup
+            ObjectSpace.each_object do |o|
+              next  if ! o.respond_to? :class
+              objects[o.class] += 1
+            end
+
+            objects.reject!{|k,v| ! last_objects.has_key? k }  unless last_objects.empty?
+
+            new_objects = objects.dup
+            objects.each do |(klass, count)|
+              new_objects.delete klass  if count < last_objects[klass]  # has been GC'ed, "cant be leaking"
+            end
+            objects = new_objects
+
+            PP.pp objects.sort_by{|(k,cnt)| cnt }.reverse[0..10], STDERR
+
+            sleep 10
+          end
+        rescue Object
+          STDERR.puts $!.inspect
+          STDERR.puts $!.backtrace.join("\n")
+        end
+      end
+=end
+
       @main_thread = Thread.safe do
         while true
           stop_ping_check
@@ -57,46 +96,50 @@ module RTunnel
 
           start_ping_check
 
-          @control_sock.sync
-          @control_sock.puts "remote_listen #{@remote_listen_address}"
-
-          while cmd = (@control_sock.readline.strip  rescue (D "#{$!.inspect}"; nil))
-            case cmd
-            when "ping"
-              @last_ping = Time.now
-
-            when "new_tunnel"
-              @threads << Thread.safe do
-                D "connecting to to tunnel"
-                to = TCPSocket.new(*@tunnel_to_address.split(/:/))
-                D "connecting to from tunnel"
-                from = TCPSocket.new(*@tunnel_from_address.split(/:/))
-
-                while ready = (IO.select([to, from], nil, nil, 0.5).first  rescue [])
-                  if ready.include? to
-                    begin
-                      from.write(to.readpartial(1024))
-                    rescue EOFError
-                      D "to tunnel closed, closing from tunnel"
-                      from.close
-                      to.close
-
-                      Thread.exit
-                    end
-                  end
-
-                  if ready.include? from
-                    begin
-                      to.write(from.readpartial(1024))
-                    rescue EOFError
-                      D "from tunnel close, closing to tunnel"
-                      from.close
-                      to.close
-
-                      Thread.exit
+          write_to_control_sock RemoteListenCommand.new(@remote_listen_address)
+
+          cmd_queue = ""
+          while data = (@control_sock.readpartial(16384)  rescue (D "#{$!.inspect}"; nil))
+            cmd_queue << data
+            while Command.match(cmd_queue)
+              case command = Command.parse(cmd_queue)
+              when PingCommand
+                @last_ping = Time.now
+              when CreateConnectionCommand
+                # 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
+                    D "reading local data"
+                    while localdata = conn.readpartial(16834)
+                      D "sending data back to server: #{localdata.size}"
+                      write_to_control_sock SendDataCommand.new(cmd.conn_id, localdata)
                     end
+                  rescue EOFError
+                    D "to tunnel closed, closing from tunnel"
+                    conn.close
+                    CONNECTIONS.delete cmd.conn_id
+                    write_to_control_sock CloseConnectionCommand.new(cmd.conn_id)
                   end
                 end
+              when CloseConnectionCommand
+                D "close " + 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
+                D "send to local " + command.conn_id + " " + command.inspect
+                if connection = CONNECTIONS[command.conn_id]
+                  connection.write(command.data)
+                else
+                  puts "WARNING: received data for non existant connection!"
+                end
               end
             end
           end
@@ -117,6 +160,12 @@ module RTunnel
 
     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

data/lib/core.rb

@@ -1,13 +1,11 @@
 module RTunnel
-  VERSION = '0.2.3'
+  VERSION = '0.3.0'
   
   DEFAULT_CONTROL_PORT = 19050
-  DEFAULT_TUNNEL_PORT = 19051
   PING_TIMEOUT = 10
 end
 
 
-
 def D(msg)
   puts msg  if $debug
 end
@@ -47,3 +45,9 @@ class IO
     nil
   end
 end
+
+class UUID
+  def self.t
+    timestamp_create.hexdigest
+  end
+end

data/lib/rtunnel_client_cmd.rb

@@ -11,7 +11,6 @@ control_address = tunnel_from_address = tunnel_to_address = remote_listen_addres
 (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("-p", "--tunnel-port ADDRESS") { |a| tunnel_port = a }
   o.on("-t", "--tunnel-to ADDRESS") { |a| tunnel_to_address = a }
 end).parse!  rescue (puts opts; exit)
 

data/lib/rtunnel_server_cmd.rb

@@ -10,12 +10,10 @@ control_address = tunnel_port = nil
 
 (opts = OptionParser.new do |o|
   o.on("-c", "--control ADDRESS") { |a| control_address = a }
-  o.on("-t", "--tunnel-port PORT") { |a| tunnel_port = a }
 end).parse!  rescue (puts opts; exit)
 
 server = RTunnel::Server.new(
-  :control_address => control_address,
-  :tunnel_port => tunnel_port
+  :control_address => control_address
 )
 
 server.start

data/lib/server.rb

@@ -1,7 +1,12 @@
 require 'gserver'
 require 'optparse'
+require 'uuidtools'
+
+require 'facets'
+require 'synchash'
 
 require 'core'
+require 'cmds'
 
 Socket.do_not_reverse_lookup = true
 
@@ -10,36 +15,29 @@ $debug = true
 module RTunnel
   # listens for incoming connections to tunnel
   class RemoteListenServer < GServer
-    @@m = Mutex.new
-    @@incoming_connections = []
-    @@cnt = 0
+    CONNECTIONS = SyncHash.new
 
     def initialize(port, host = DEFAULT_HOST)
       super(port, host, 10)
     end
 
-    def self.next_incoming_connection
-      @@m.synchronize { @@incoming_connections.pop }
-    end
-
     def serve(sock)
-      m = Mutex.new
-      cv = ConditionVariable.new
-
       D "new incoming connection"
-      incoming = [cv, sock]
-      @@m.synchronize { @@incoming_connections << incoming }
 
+      conn_id = UUID.t
+      CONNECTIONS[conn_id] = sock
       begin
-        ControlServer.new_tunnel
-      rescue
-        D "error talking on control connection, dropping incoming connection"
+        ControlServer.new_tunnel(conn_id)
 
-        @@m.synchronize { @@incoming_connections.delete(incoming) }
-        return
+        while data = (sock.readpartial(16384) rescue nil)
+          ControlServer.send_data(conn_id, data)
+        end
+      rescue
+        D "error talking on control connection, dropping incoming connection: #{$!.inspect}"
       end
-
-      m.synchronize { cv.wait(m) }
+      
+      CONNECTIONS.delete conn_id
+      ControlServer.close_tunnel(conn_id)
 
       D "sock closed"
     rescue
@@ -47,52 +45,52 @@ module RTunnel
       puts $!.backtrace.join("\n")
     end
   end
-
-  class TunnelListenServer < GServer
-    @@tunneled_connections = []
-
-    def initialize(port, host = DEFAULT_HOST)
-      super(port, host, 10)
-    end
-
-    def serve(sock)
-      D "new tunneled connection"
-      cv, incoming_connection = RemoteListenServer.next_incoming_connection
-      if ! incoming_connection
-        D "no incoming connections for this tunneled connection, closing"
-        return
-      end
-
-      while ready = (IO.select([incoming_connection, sock], nil, nil, 0.5).first  rescue [])
-        if ready.include? incoming_connection
-          begin
-            sock.write(incoming_connection.readpartial(1024))
-          rescue EOFError
-            D "incoming socket closed, closing tunneled socket"
-            sock.close
-            cv.signal
-
-            return
-          end
-        end
-
-        if ready.include? sock
-          begin
-            incoming_connection.write(sock.readpartial(1024))
-          rescue EOFError
-            D "tunneled socket closed, closing incoming connection socket"
-            incoming_connection.close
-            cv.signal
-
-            return
-          end
-        end
-      end
-    rescue Exception
-      p $!
-      puts $!.backtrace.join("\n")
-    end
-  end
+#
+#  class TunnelListenServer < GServer
+#    @@tunneled_connections = []
+#
+#    def initialize(port, host = DEFAULT_HOST)
+#      super(port, host, 10)
+#    end
+#
+#    def serve(sock)
+#      D "new tunneled connection"
+#      cv, incoming_connection = RemoteListenServer.next_incoming_connection
+#      if ! incoming_connection
+#        D "no incoming connections for this tunneled connection, closing"
+#        return
+#      end
+#
+#      while ready = (IO.select([incoming_connection, sock], nil, nil, 0.5).first  rescue [])
+#        if ready.include? incoming_connection
+#          begin
+#            sock.write(incoming_connection.readpartial(1024))
+#          rescue EOFError
+#            D "incoming socket closed, closing tunneled socket"
+#            sock.close
+#            cv.signal
+#
+#            return
+#          end
+#        end
+#
+#        if ready.include? sock
+#          begin
+#            incoming_connection.write(sock.readpartial(1024))
+#          rescue EOFError
+#            D "tunneled socket closed, closing incoming connection socket"
+#            incoming_connection.close
+#            cv.signal
+#
+#            return
+#          end
+#        end
+#      end
+#    rescue Exception
+#      p $!
+#      puts $!.backtrace.join("\n")
+#    end
+#  end
 
   class ControlServer < GServer
     @@control_connection = nil
@@ -102,10 +100,21 @@ module RTunnel
 
     attr_accessor :ping_interval
 
-    def self.new_tunnel
-      D "sending new tunnel command"
+    def self.new_tunnel(conn_id)
+      D "sending create connection command: #{conn_id}"
 
-      @@m.synchronize { @@control_connection.write "new_tunnel\n" }
+      @@m.synchronize { @@control_connection.write CreateConnectionCommand.new(conn_id) }
+    end
+
+    def self.send_data(conn_id, data)
+      D "send to client: #{conn_id}"
+      @@m.synchronize { @@control_connection.write SendDataCommand.new(conn_id, data) }
+    end
+
+    def self.close_tunnel(conn_id)
+      D "sending close connection command"
+
+      @@m.synchronize { @@control_connection.write CloseConnectionCommand.new(conn_id) }
     end
 
     def serve(sock)
@@ -113,20 +122,32 @@ module RTunnel
       @@control_connection = sock
       sock.sync = true
 
+      cmd_queue = ""
       while true
-        if IO.select([sock], nil, nil, @ping_interval)
-          cmd = sock.readline  rescue (D "#{$!.inspect}"; break)
-          case cmd
-          when /^remote_listen ([^: ]+:\d+)/
-            remote_listen_address = $1
-            @@remote_listen_server.stop  if @@remote_listen_server
-            (@@remote_listen_server = RemoteListenServer.new(*remote_listen_address.split(/:/).reverse)).start
-            D "listening for remote connections on #{remote_listen_address}"
-          else
-            D "bad command received: #{cmd.inspect}"
+        if r = IO.select([sock], nil, nil, @ping_interval)
+          cmd_queue << sock.readpartial(16384)  rescue (D "#{$!.inspect}"; break)
+          while Command.match(cmd_queue)
+            cmd = Command.parse(cmd_queue)
+            case cmd
+            when RemoteListenCommand
+              @@remote_listen_server.stop  if @@remote_listen_server
+              (@@remote_listen_server = RemoteListenServer.new(*cmd.address.split(/:/).reverse)).start
+              D "listening for remote connections on #{cmd.address}"
+            when SendDataCommand
+              D "send data to remote conn #{cmd.conn_id}"
+              RemoteListenServer::CONNECTIONS[cmd.conn_id].write cmd.data
+            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
-        sock.puts "ping"
+        D "ping"
+        @@m.synchronize { @@control_connection.write PingCommand.new }
       end
     rescue
       D $!.inspect
@@ -151,8 +172,6 @@ module RTunnel
       @control_host = @control_address.split(/:/).first
 
       @ping_interval = options[:ping_interval] || 2.0
-
-      @tunnel_address = @control_host + ":#{options[:tunnel_port] || DEFAULT_TUNNEL_PORT}"      
     end
 
     def start
@@ -160,9 +179,6 @@ module RTunnel
       @control_server.ping_interval = @ping_interval
       @control_server.audit = true
 
-      @tunnel_server = TunnelListenServer.new(*@tunnel_address.split(/:/).reverse)
-
-      @tunnel_server.start
       @control_server.start
     end
 
@@ -172,9 +188,7 @@ module RTunnel
 
     def stop
       @control_server.shutdown
-      @tunnel_server.shutdown
       ControlServer.stop(@control_server.port, @control_server.host)
-      TunnelListenServer.stop(@tunnel_server.port, @tunnel_server.host)
     end
   end
 end

data/rtunnel_client.rb

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

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: rtunnel
 version: !ruby/object:Gem::Version 
-  version: 0.2.3
-date: 2007-11-25 00:00:00 +07:00
+  version: 0.3.0
+date: 2007-11-27 00:00:00 +07:00
 summary: The author was too lazy to write a summary
 require_paths: 
 - lib