costan-rtunnel 0.4.0

data/lib/rtunnel/socket_factory.rb

@@ -0,0 +1,119 @@
+require 'socket'
+
+module RTunnel::SocketFactory
+  def self.split_address(address)
+    port_index = address.index /[^:]\:[^:]/
+    if port_index
+      [address[0, port_index + 1], address[port_index + 2, address.length]]
+    else
+      [address, nil]
+    end
+  end
+  
+  def self.host_from_address(address)
+    address and split_address(address)[0]
+  end
+  
+  def self.port_from_address(address)
+    address and (port_string = split_address(address)[1]) and port_string.to_i
+  end
+  
+  def self.inbound?(options)
+    options[:inbound] or [:in_port, :in_host, :in_addr].any? { |k| options[k] }
+  end
+  
+  def self.bind_host(options)
+    options[:in_host] or host_from_address(options[:in_addr]) or '0.0.0.0'
+  end
+  
+  def self.bind_port(options)
+    options[:in_port] or port_from_address(options[:in_addr]) or 0
+  end
+  
+  def self.bind_socket_address(options)
+    Socket::pack_sockaddr_in bind_port(options), bind_host(options)
+  end
+  
+  def self.connect_host(options)
+    options[:out_host] or host_from_address(options[:out_addr])
+  end
+  
+  def self.connect_port(options)
+    options[:out_port] or port_from_address(options[:out_addr])
+  end
+  
+  def self.connect_socket_address(options)
+    Socket::pack_sockaddr_in connect_port(options), connect_host(options)
+  end
+  
+  def self.tcp?(options)
+    options[:tcp] or !options[:udp]
+  end
+  
+  def self.new_tcp_socket
+    Socket.new Socket::AF_INET, Socket::SOCK_STREAM, Socket::PF_UNSPEC
+  end
+  
+  def self.new_udp_socket
+    Socket.new Socket::AF_INET, Socket::SOCK_DGRAM, Socket::PF_UNSPEC
+  end
+  
+  def self.new_socket(options)
+    tcp?(options) ? new_tcp_socket : new_udp_socket
+  end
+  
+  def self.bind(socket, options)
+    socket.bind bind_socket_address(options)
+  end
+  
+  def self.connect(socket, options)
+    socket.connect connect_socket_address(options)
+  end
+  
+  def self.set_options(socket, options)
+    if options[:no_delay]
+      socket.setsockopt Socket::IPPROTO_TCP, Socket::TCP_NODELAY, true
+      socket.sync = true
+    end
+    
+    if options[:reuse_addr]
+      socket.setsockopt Socket::SOL_SOCKET, Socket::SO_REUSEADDR, true
+    end
+    
+    unless options[:reverse_lookup]
+      if socket.respond_to? :do_not_reverse_lookup
+        socket.do_not_reverse_lookup = true
+      else
+        # work around until the patch below actually gets committed:
+        # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/2346
+        BasicSocket.do_not_reverse_lookup = true
+      end
+    end
+  end
+
+  # new sockets coming out of socket.accept will have the given options set
+  def self.set_options_on_accept_sockets(socket, options)
+    socket.instance_variable_set :@rtunnel_factory_options, options
+    def socket.accept(*args)
+      sock, addr = super
+      RTunnel::SocketFactory.set_options sock, @rtunnel_factory_options
+      return sock, addr
+    end
+  end
+  
+  def self.socket(options = {})    
+    s = new_socket options
+    set_options s, options
+    if inbound? options
+      bind s, options    
+      set_options_on_accept_sockets s, options
+    else
+      connect s, options
+    end
+    s
+  end
+  
+  def socket(options = {})
+    RTunnel::SocketFactory.socket(options)
+  end  
+end

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/test/command_stubs.rb

@@ -0,0 +1,77 @@
+# Contains generate_ and verify_ names for all RTunnel commands.
+module CommandStubs
+  @@test_id1 = "1029384756ALSKDJFH"
+  @@test_id2 = "ALSKDJFH1029384756"
+  @@test_address = "192.168.43.95"
+  @@data = (0..255).to_a.pack('C*')
+  @@ekey = (128...192).to_a.pack('C*') * 8
+  @@pubfp = (0...128).to_a.pack('C*') * 5
+  
+  def generate_keep_alive
+    RTunnel::KeepAliveCommand.new
+  end
+  def verify_keep_alive(cmd)
+    assert_equal RTunnel::KeepAliveCommand, cmd.class
+  end
+  
+  def generate_create
+    RTunnel::CreateConnectionCommand.new @@test_id1
+  end
+  def verify_create(cmd)
+    assert_equal RTunnel::CreateConnectionCommand, cmd.class
+    assert_equal @@test_id1, cmd.connection_id
+  end
+  
+  def generate_close
+    RTunnel::CloseConnectionCommand.new @@test_id2
+  end
+  def verify_close(cmd)
+    assert_equal RTunnel::CloseConnectionCommand, cmd.class
+    assert_equal @@test_id2, cmd.connection_id
+  end
+
+  def generate_listen
+    RTunnel::RemoteListenCommand.new @@test_address
+  end
+  def verify_listen(cmd)
+    assert_equal RTunnel::RemoteListenCommand, cmd.class
+    assert_equal @@test_address, cmd.address
+  end
+
+  def generate_send
+    RTunnel::SendDataCommand.new @@test_id1, @@data
+  end
+  def verify_send(cmd)
+    assert_equal RTunnel::SendDataCommand, cmd.class
+    assert_equal @@test_id1, cmd.connection_id
+    assert_equal @@data, cmd.data
+  end
+  
+  def generate_set_sk
+    RTunnel::SetSessionKeyCommand.new @@ekey
+  end
+  def verify_set_sk(cmd)
+    assert_equal RTunnel::SetSessionKeyCommand, cmd.class
+    assert_equal @@ekey, cmd.encrypted_keys
+  end
+
+  def generate_gen_sk
+    RTunnel::GenerateSessionKeyCommand.new @@pubfp
+  end
+  def verify_gen_sk(cmd)
+    assert_equal RTunnel::GenerateSessionKeyCommand, cmd.class
+    assert_equal @@pubfp, cmd.public_key_fp
+  end
+
+  # An array with the names of all commands.
+  # Use these names to obtain the names of the genrate_ and verify_ methods.
+  def self.command_names
+    [:keep_alive, :create, :close, :listen, :send, :gen_sk, :set_sk]
+  end
+
+  # A sequence of command names useful for testing "real" connections.
+  def self.command_test_sequence
+    [:create, :keep_alive, :gen_sk, :set_sk, :keep_alive, :listen, :keep_alive,
+     :send, :send, :keep_alive, :keep_alive, :send, :close]
+  end
+end