rtunnel 0.3.8 → 0.4.0

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

data/lib/core.rb

@@ -1,53 +0,0 @@
-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 read_or_timeout(timeout = 5, read_size = 1024)
-    data = timeout(timeout) { self.read(read_size) }
-  rescue Timeout::Error
-    ''
-  rescue
-    nil
-  end
-end
-
-class UUID
-  def self.t
-    timestamp_create.hexdigest
-  end
-end

data/lib/rtunnel_client_cmd.rb

@@ -1,25 +0,0 @@
-#!/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

@@ -1,20 +0,0 @@
-#!/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

@@ -1,181 +0,0 @@
-require 'gserver'
-require 'optparse'
-require 'uuidtools'
-
-require 'facets'
-require 'facets/synchash'
-
-require 'core'
-require 'cmds'
-
-Socket.do_not_reverse_lookup = true
-
-$debug = true
-
-module RTunnel
-  # listens for incoming connections to tunnel
-  class RemoteListenServer < GServer
-    CONNECTIONS = SyncHash.new
-    CONTROL_CONNECTION_MAPPING = SyncHash.new
-
-    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.t
-      CONNECTIONS[conn_id] = sock
-      CONTROL_CONNECTION_MAPPING[conn_id] = @control_connection
-      begin
-        ControlServer.new_tunnel(conn_id)
-
-        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
-      
-      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 serve(sock)
-      D "new control connection"
-      @@control_connections << sock
-      sock.sync = true
-
-      cmd_queue = ""
-      while true
-        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
-              @@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
-        
-        # TODO: only do this every ping_interval instead of after each socket read
-        @@m.synchronize { @@control_connections.each {|cc| cc.write PingCommand.new } }
-      end
-    rescue
-      D $!.inspect
-      D $!.backtrace.join("\n")
-      raise
-    ensure
-      @@control_connections.delete sock
-    end
-
-    def stopping
-      @@remote_listen_server.stop
-    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_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'