shadowsocks_ruby 0.1.0

data/lib/shadowsocks_ruby/cli/sslocal_runner.rb

@@ -0,0 +1,125 @@
+require 'optparse'
+
+module ShadowsocksRuby
+  module Cli
+    class SslocalRunner
+      def initialize(argv = ARGV, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = Kernel)
+        @argv   = argv
+        $kernel = kernel
+        $stdin  = stdin
+        $stdout = stdout
+        $stderr = stderr
+      end
+
+      def execute!
+        # here sets default options
+        options        = {
+                           :port => 8388,
+                           :local_addr => '0.0.0.0',
+                           :local_port => 1080,
+                           :packet_name => 'origin',
+                           :cipher_name => 'aes-256-cfb',
+                           :timeout => 300
+                         }
+        lazy_default   = {
+                           :config => 'config.json',
+                           :obfs_name => 'http_simple'
+                         }
+
+        version        = ShadowsocksRuby::VERSION
+        config_help    = "path to config file (lazy default: #{lazy_default[:config]})"
+        server_addr_help    = "server address"
+        server_port_help = "server port (default: #{options[:port]})"
+        local_addr_help = "local binding address (default: #{options[:local_addr]})"
+        local_port_help = "local port  (default: default: #{options[:local_port]})"
+        password_help = "password"
+        packet_protocol_help = "packet protocol (default: #{options[:packet_name]})"
+        packet_param_help = "packet protocol parameters"
+        cipher_help = "cipher protocol (default: #{options[:cipher_name]})"
+        obfs_protocol_help = "obfuscate protocol (lazy default: #{lazy_default[:obfs_name]})"
+        obfs_param_help = "obfuscate protocol parameters"
+        timeout_help = "timeout in seconds, default: #{options[:timeout]}"
+        fast_open_help = "use TCP_FASTOPEN, requires Linux 3.7+"
+        einhorn_help = "Use Einhorn socket manager"
+
+        help_help = "display help message"
+        version_help = "show version information"
+        verbose_help = "verbose mode"
+        quiet_help = "quiet mode, only show warnings/errors"
+        get_help = "run #{File.basename($0)} -h to get help"
+
+        option_parser = OptionParser.new do |op|
+
+          op.banner =  "A SOCKS like tunnel proxy that helps you bypass firewalls."
+          op.separator ""
+          op.separator "Usage: #{File.basename($0)} [options]"
+          op.separator ""
+
+          op.separator "Proxy options:"
+          op.on("-c", "--config [CONFIG]", config_help) { |value| options[:config] = value }
+          op.on("-s", "--server SERVER_ADDR", server_addr_help)   { |value| options[:server] = value }
+          op.on("-p", "--port SERVER_PORT", server_port_help)   { |value| options[:port] = value.to_i }
+          op.on("-b", "--bind_addr LOCAL_ADDR", local_addr_help)   { |value| options[:local_addr] = value }
+          op.on("-l", "--local_port LOCAL_PORT", local_port_help)   { |value| options[:local_port] = value.to_i }
+          op.on("-k", "--password PASSWORD", password_help)   { |value| options[:password] = value }
+          op.on("-O", "--packet-protocol NAME", packet_protocol_help)   { |value| options[:packet_name] = value }
+          op.on("-G", "--packet-param PARAM", packet_param_help)   { |value| options[:packet_param] = value }
+          op.on("-m", "--cipher-protocol NAME", cipher_help)   { |value| options[:cipher_name] = value }
+          op.on("-o", "--obfs-protocol [NAME]", obfs_protocol_help)   { |value| options[:obfs_name] = value }
+          op.on("-g", "--obfs-param PARAM", obfs_param_help)   { |value| options[:obfs_param] = value }
+          op.on("-t", "--timeout TIMEOUT", timeout_help)   { |value| options[:timeout] = value.to_i }
+          op.on(      "--fast-open", fast_open_help)   { |value| options[:tcp_fast_open] = value }
+          op.on('-E', '--einhorn', einhorn_help) { |value| @options[:einhorn] = true }
+          op.separator ""
+
+          op.separator "Common options:"
+          op.on("-h", "--help", help_help)    { puts op.to_s; $kernel.exit }
+          op.on("-v", "--vv", verbose_help) { options[:verbose]   = true }
+          op.on("-q", "--qq", quiet_help) { options[:quiet]   = true }
+          op.on(      "--version", version_help) { puts version; $kernel.exit }
+          op.separator ""
+
+        end
+
+        begin
+          option_parser.parse!(@argv)
+        rescue OptionParser::MissingArgument => e
+          $kernel.abort("#{e.message}\n#{get_help}")
+        end
+
+        if options.include?(:config)
+          options[:config] = 'config.json' if options[:config] == nil
+          config_options = {}
+          begin
+            open(options[:config], 'r') do |f|
+            config_options = JSON.load(f, nil, {:symbolize_names => true})
+            end
+          rescue Errno::ENOENT
+            $kernel.abort("#{options[:config]} doesn't exists")
+          rescue JSON::ParserError
+            $kernel.abort("#{options[:config]} parse error")
+          end
+          options = config_options.merge(options)
+        end
+
+        if options.include?(:obfs_name)
+          options[:obfs_name] = lazy_default[:obfs_name] if options[:obfs_name] == nil
+        end
+
+        if !options.include?(:password)
+          $kernel.abort("--password is required\n#{get_help}")
+        end
+
+        if !options.include?(:server)
+          $kernel.abort("--server is required\n#{get_help}")
+        end
+
+
+        options[:__client] = true
+
+        App.options = options
+        App.instance.run!
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/cli/ssserver_runner.rb

@@ -0,0 +1,115 @@
+require 'optparse'
+
+module ShadowsocksRuby
+  module Cli
+    class SsserverRunner
+      def initialize(argv = ARGV, stdin = $stdin, stdout = $stdout, stderr = $stderr, kernel = Kernel)
+        @argv   = argv
+        $kernel = kernel
+        $stdin  = stdin
+        $stdout = stdout
+        $stderr = stderr
+      end
+
+      def execute!
+        # here sets default options
+        options        = {
+                           :server => '0.0.0.0',
+                           :port => 8388,
+                           :packet_name => 'origin',
+                           :cipher_name => 'aes-256-cfb',
+                           :timeout => 300
+                         }
+        lazy_default   = {
+                           :config => 'config.json',
+                           :obfs_name => 'http_simple'
+                         }
+
+        version        = ShadowsocksRuby::VERSION
+        config_help    = "path to config file (lazy default: #{lazy_default[:config]})"
+        server_addr_help    = "server address (default: #{options[:server]})"
+        server_port_help = "server port (default: #{options[:port]})"
+        password_help = "password"
+        packet_protocol_help = "packet protocol (default: #{options[:packet_name]})"
+        packet_param_help = "packet protocol parameters"
+        cipher_help = "cipher protocol (default: #{options[:cipher_name]})"
+        obfs_protocol_help = "obfuscate protocol (lazy default: #{lazy_default[:obfs_name]})"
+        obfs_param_help = "obfuscate protocol parameters"
+        timeout_help = "timeout in seconds, default: #{options[:timeout]}"
+        fast_open_help = "use TCP_FASTOPEN, requires Linux 3.7+"
+        einhorn_help = "Use Einhorn socket manager"
+
+        help_help = "display help message"
+        version_help = "show version information"
+        verbose_help = "verbose mode"
+        quiet_help = "quiet mode, only show warnings/errors"
+        get_help = "run #{File.basename($0)} -h to get help"
+
+        option_parser = OptionParser.new do |op|
+
+          op.banner =  "A SOCKS like tunnel proxy that helps you bypass firewalls."
+          op.separator ""
+          op.separator "Usage: #{File.basename($0)} [options]"
+          op.separator ""
+
+          op.separator "Proxy options:"
+          op.on("-c", "--config [CONFIG]", config_help) { |value| options[:config] = value }
+          op.on("-s", "--server SERVER_ADDR", server_addr_help)   { |value| options[:server] = value }
+          op.on("-p", "--port SERVER_PORT", server_port_help)   { |value| options[:port] = value.to_i }
+          op.on("-k", "--password PASSWORD", password_help)   { |value| options[:password] = value }
+          op.on("-O", "--packet-protocol NAME", packet_protocol_help)   { |value| options[:packet_name] = value }
+          op.on("-G", "--packet-param PARAM", packet_param_help)   { |value| options[:packet_param] = value }
+          op.on("-m", "--cipher-protocol NAME", cipher_help)   { |value| options[:cipher_name] = value }
+          op.on("-o", "--obfs-protocol [NAME]", obfs_protocol_help)   { |value| options[:obfs_name] = value }
+          op.on("-g", "--obfs-param PARAM", obfs_param_help)   { |value| options[:obfs_param] = value }
+          op.on("-t", "--timeout TIMEOUT", timeout_help)   { |value| options[:timeout] = value.to_i }
+          op.on(      "--fast-open", fast_open_help)   { |value| options[:tcp_fast_open] = value }
+          op.on('-E', '--einhorn', einhorn_help) { |value| @options[:einhorn] = true }
+          op.separator ""
+
+          op.separator "Common options:"
+          op.on("-h", "--help", help_help)    { puts op.to_s; $kernel.exit }
+          op.on("-v", "--vv", verbose_help) { options[:verbose]   = true }
+          op.on("-q", "--qq", quiet_help) { options[:quiet]   = true }
+          op.on(      "--version", version_help) { puts version; $kernel.exit }
+          op.separator ""
+
+        end
+
+        begin
+          option_parser.parse!(@argv)
+        rescue OptionParser::MissingArgument => e
+          $kernel.abort("#{e.message}\n#{get_help}")
+        end
+
+        if options.include?(:config)
+          options[:config] = lazy_default[:config] if options[:config] == nil
+          config_options = {}
+          begin
+            open(options[:config], 'r') do |f|
+            config_options = JSON.load(f, nil, {:symbolize_names => true})
+            end
+          rescue Errno::ENOENT
+            $kernel.abort("#{options[:config]} doesn't exists")
+          rescue JSON::ParserError
+            $kernel.abort("#{options[:config]} parse error")
+          end
+          options = config_options.merge(options)
+        end
+
+        if options.include?(:obfs_name)
+          options[:obfs_name] = lazy_default[:obfs_name] if options[:obfs_name] == nil
+        end
+
+        if !options.include?(:password)
+          $kernel.abort("password is required\n#{get_help}")
+        end
+
+        options[:__server] = true
+
+        App.options = options
+        App.instance.run!        
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/backend_connection.rb

@@ -0,0 +1,50 @@
+module ShadowsocksRuby
+  module Connections
+    # Mixed-in code to provide functionality to a BackendConnection
+    # ,whose peer is a upstream peer, like a Destinatiion or a RemoteServer.
+    module BackendConnection
+      
+      # Packet Protocol
+      #
+      # A Strategy Pattern for replacing protocol algorithm
+      #
+      # all read from {BackendConnection}'s {packet_protocol} is just data,
+      # 
+      # the first send to {packet_protocol} chould be address_bin (for a {RemoteServerConnection}) 
+      # or data (for a {DestinationConnection}),
+      # other send to {packet_protocol} should be just data
+      #
+      # @return [ShadowsocksRuby::Protocols::SomePacketProtocol]
+      # @see ShadowsocksRuby::Protocols
+      attr_accessor :packet_protocol
+
+      # (see ServerConnection#params)
+      attr_reader :params
+
+      # If clild class override initialize, make sure to call super
+      #
+      # @param [Protocols::ProtocolStack] protocol_stack
+      # @param [Hash] params
+      # @return [Connection_Object]
+      def initialize protocol_stack, params
+        super()
+
+        @packet_protocol = protocol_stack.build!(self)    
+
+        @params = params
+        @connected = EM::DefaultDeferrable.new
+      end
+
+
+      def connection_completed
+        @connected.succeed
+      end
+
+      # Buffer data until the connection to the backend server
+      # is established and is ready for use
+      def send_data data
+        @connected.callback { super data }
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/connection.rb

@@ -0,0 +1,195 @@
+require 'fiber'
+require 'ipaddr'
+
+module ShadowsocksRuby
+
+  # This module contains various functionality code to be mixed-in 
+  # with EventMachine::Connection
+  # when Connection object is instantiated.
+  #
+  # There are 4 kinds of connection: client, local backend, remote server and destination. Which are demonstrated below:
+  #
+  #                  -------------------------------------------       -------------------------------------------------
+  #                  |                                         |       |                                               |
+  #     Client <---> |ClientConnection -- RemoteServerConnecton| <---> |LocalBackendConnection -- DestinationConnection| <---> Destination
+  #             net  |           Shadowsocks Client            |  net  |               Shadowsocks Server              |  net
+  #                  -------------------------------------------       -------------------------------------------------
+  #
+  #    
+  module Connections
+    # Mixed-in code to provide fiber enabled asynchronously receive 
+    # function and pressure controled +send_data+ to EventMachine::Connection
+    #
+    # User code should define +process_hook+ which hopefully implement a state machine .
+    #
+    # *Note:* User code should not override +post_init+ and +receive_data+, it is by design.
+    #
+    # @example
+    #     class DummyConnection < EventMachine::Connection
+    #       include ShadowsocksRuby::Connections::Connection
+    #       def process_hook
+    #         @i ||= 0
+    #         @i += 1
+    #         puts "I'm now in a fiber enabled context: #{@fiber}"
+    #         Fiber.yield if @i >= 3
+    #       end
+    #     end
+    #
+    module Connection
+      # 512K, used to pause plexer when plexer.get_outbound_data_size > this value
+      PressureLevel = 524288
+
+      # It is where to relay peer's traffic to
+      # For a server connection, plexer is backend connection.
+      # For a backend connection, plexer is server connection.
+      # @return [Connection]
+      attr_accessor :plexer
+
+      # you can set logger in test code
+      attr_writer :logger
+
+      # get the logger object, the defautl logger is App.instance.logger
+      def logger
+        @logger ||= App.instance.logger
+      end
+
+
+      # send_data with pressure control
+      # @param[String] data       Data to send asynchronously
+      def send_data data
+        pressure_control
+        super data
+      end
+
+      # Call process_hook, which should be defined in user code
+      # @private
+      def process
+        process_hook
+      end
+
+      # Initialize a fiber context and enter the process loop
+      # normally, a child class should not override post_init, it is by design
+      # @private
+      def post_init
+        @buffer = String.new('', encoding: Encoding::ASCII_8BIT)
+        @fiber = Fiber.new do
+          # poor man's state machine
+          while true
+            process
+          end
+        end
+        @fiber.resume
+      end
+
+      def peer
+        @peer ||=
+        begin
+          port, ip = Socket.unpack_sockaddr_in(get_peername)
+          "#{ip}:#{port}"
+        end
+      end
+
+      # Asynchronously receive n bytes from @buffer
+      # @param [Integer] n             Bytes to receive, if n = -1 returns all data in @buffer
+      # @return [String]               Returned n bytes data
+      def async_recv n
+        # wait n bytes
+        if n == -1 && @buffer.size == 0 || @buffer.size < n
+          @wait_length = n
+          Fiber.yield
+        end
+        # read n bytes from buffer
+        if n == -1
+          s, @buffer = @buffer, String.new('', encoding: Encoding::ASCII_8BIT)
+          return s
+        else
+          return @buffer.slice!(0, n)
+        end
+      end
+
+      # Asynchronously receive data until str (eg: "\\r\\n\r\\n") appears.
+      # @param [String] str            Desired endding str
+      # @raise BufferOversizeError          raise if cannot find str in first 65536 bytes (64K bytes)of @buffer,
+      #                                  enough for a HTTP request head.
+      # @return [String]               Returned data, with str at end
+      def async_recv_until str
+        # wait for str
+        pos = @buffer =~ Regexp.new(str)
+        while pos == nil
+          @wait_length = -1
+          Fiber.yield
+          pos = @buffer =~ Regexp.new(str)
+          raise BufferOversizeError, "oversized async_recv_until read" if @buffer.size > 65536
+        end
+        # read until str from buffer
+        return @buffer.slice!(0, pos + str.length)
+      end
+
+
+      # Provide fiber enabled data receiving, should be always be called 
+      # in a fiber context.
+      #
+      # Normally, client class should not call receive_data directlly,
+      # instead should call async_recv or async_recv_until
+      # 
+      # @param [String] data
+      # @raise OutOfFiberConextError
+      #
+      # @private
+      def receive_data data
+        if @fiber.alive?
+          @buffer << data
+          if @wait_length == -1 || @buffer.size >= @wait_length
+            @fiber.resume
+          end
+        else
+          raise OutOfFiberContextError, "should not go here"
+        end
+      rescue MyErrorModule => e
+        logger.info {e.message}
+        close_connection
+      rescue Exception => e
+        logger.info {e.class.to_s + " " + e.message + e.backtrace.join("\n")}
+        close_connection
+      end
+
+      # if peer receving data is too slow, pause plexer sending data to me
+      # ,prevent memery usage to be too high
+      # @private
+      def pressure_control
+        @plexer ||= nil
+        if @plexer != nil
+          if get_outbound_data_size >= PressureLevel
+            @plexer.pause unless @plexer.paused?
+            EventMachine.next_tick self.method(:pressure_control)
+          else
+            @plexer.resume if @plexer.paused?
+          end
+        end
+      end
+
+      # Close plexer first if it exists
+      def unbind
+        @plexer ||= nil
+        @plexer.close_connection_after_writing if @plexer != nil
+      end
+
+      alias tcp_receive_from_client async_recv
+      alias tcp_receive_from_remoteserver async_recv
+      alias tcp_receive_from_localbackend async_recv
+      alias tcp_receive_from_destination async_recv
+      alias tcp_send_to_client send_data
+      alias tcp_send_to_remoteserver send_data
+      alias tcp_send_to_localbackend send_data
+      alias tcp_send_to_destination send_data
+      alias udp_receive_from_client async_recv
+      alias udp_receive_from_remoteserver async_recv
+      alias udp_receive_from_localbackend async_recv
+      alias udp_receive_from_destination async_recv
+      alias udp_send_to_client send_data
+      alias udp_send_to_remoteserver send_data
+      alias udp_send_to_localbackend send_data
+      alias udp_send_to_destination send_data
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/server_connection.rb

@@ -0,0 +1,63 @@
+module ShadowsocksRuby
+  module Connections
+
+    # Mixed-in code to provide functionality to a ServerConnection
+    # ,whose peer is a downstream peer, like a Client or a LocalBackend.
+    module ServerConnection
+      
+      # Packet Protocol
+      #
+      # A Strategy Pattern for replacing protocol algorithm
+      #
+      # the first read from {ServerConnection}'s {packet_protocol} is an address_bin,
+      # other read from {packet_protocol} is just data
+      # 
+      # all send to {packet_protocol} should be just data
+      #
+      # @return [ShadowsocksRuby::Protocols::SomePacketProtocol]
+      # @see ShadowsocksRuby::Protocols
+      attr_accessor :packet_protocol
+
+      # Params
+      # @return [Hash]
+      attr_reader :params
+
+      # If clild class override initialize, make sure to call super
+      #
+      # @param [Protocols::ProtocolStack] protocol_stack
+      # @param [Hash] params
+      # @param [Protocols::ProtocolStack] backend_protocol_stack
+      # @param [Hash] backend_params
+      # @return [Connection_Object]
+      def initialize protocol_stack, params, backend_protocol_stack, backend_params
+        super()
+
+        @packet_protocol = protocol_stack.build!(self)      
+
+        @params = params
+
+        @backend_protocol_stack = backend_protocol_stack
+        @backend_params = backend_params
+      end
+
+      def post_init
+        logger.info {"Accepted #{peer}"}
+        super()
+      end
+
+      # Create a plexer -- a backend connection
+      # @param [String] host
+      # @param [Integer] port
+      # @param [Class] backend_klass
+      # @return [Connection_Object]
+      def create_plexer(host, port, backend_klass)
+        @plexer = EventMachine.connect host, port, backend_klass, @backend_protocol_stack, @backend_params
+        @plexer.plexer = self
+        @plexer
+      rescue EventMachine::ConnectionError => e
+        raise ConnectionError, e.message + " when connect to #{host}:#{port}"
+      end
+
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/tcp/client_connection.rb

@@ -0,0 +1,43 @@
+module ShadowsocksRuby
+  module Connections
+    # Provides various functionality code of a TCP Connection.
+    #
+    # @example
+    #     class DummyConnection < EventMachine::Connection
+    #       include ShadowsocksRuby::Connections::TCP::ClientConnection
+    #     end
+    #     # some how get a DummyConnection object
+    #     # dummy_connection = ...
+    #     # dummy_connection.plexer_protocol.tcp_process_client will be called looply
+    module TCP
+      # Mixed-in with an EventMachine::Connection Object to use this.
+      module ClientConnection
+        include ShadowsocksRuby::Connections::Connection
+        include ShadowsocksRuby::Connections::ServerConnection
+        # (see ServerConnection#initialize)
+        # @option params [String]                :host  shadowsocks server address, required
+        # @option params [Integer]                :port  shadowsocks server port, required
+        def initialize protocol_stack, params, backend_protocol_stack, backend_params
+          super
+        end
+
+        def process_first_packet
+          address_bin = packet_protocol.tcp_receive_from_client(-1)
+          create_plexer(@params[:host], @params[:port], RemoteServerConnection)
+          plexer.packet_protocol.tcp_send_to_remoteserver address_bin
+          class << self
+            alias process_hook process_other_packet
+          end
+        end
+
+        # This is Called by process loop 
+        alias process_hook process_first_packet
+
+        def process_other_packet
+          data = packet_protocol.tcp_receive_from_client(-1)
+          plexer.packet_protocol.tcp_send_to_remoteserver(data)
+        end
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/tcp/destination_connection.rb

@@ -0,0 +1,19 @@
+module ShadowsocksRuby
+  module Connections
+    module TCP
+      # (see TCP::ClientConnection)
+      module DestinationConnection
+        include ShadowsocksRuby::Connections::Connection
+        include ShadowsocksRuby::Connections::BackendConnection
+
+        # (see TCP::ClientConnection#process_hook)
+        def process_hook
+          #plexer.packet_protocol.tcp_send_to_localbackend(packet_protocol.tcp_receive_from_destination(-1))
+          data = packet_protocol.tcp_receive_from_destination(-1)
+          plexer.packet_protocol.tcp_send_to_localbackend(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/tcp/localbackend_connection.rb

@@ -0,0 +1,29 @@
+module ShadowsocksRuby
+  module Connections
+    module TCP
+      # (see TCP::ClientConnection)
+      module LocalBackendConnection
+        include ShadowsocksRuby::Connections::Connection
+        include ShadowsocksRuby::Connections::ServerConnection
+
+        def process_first_packet
+          address_bin = packet_protocol.tcp_receive_from_localbackend(-1)
+          host, port = Util::parse_address_bin(address_bin)
+          create_plexer(host, port, DestinationConnection)
+          class << self
+            alias process_hook process_other_packet
+          end
+        end
+
+        # (see TCP::ClientConnection#process_hook)
+        alias process_hook process_first_packet
+
+        def process_other_packet
+          data = packet_protocol.tcp_receive_from_localbackend(-1)
+          plexer.packet_protocol.tcp_send_to_destination(data)
+        end
+
+      end
+    end
+  end
+end

data/lib/shadowsocks_ruby/connections/tcp/remoteserver_connection.rb

@@ -0,0 +1,18 @@
+module ShadowsocksRuby
+  module Connections
+    module TCP
+      # (see TCP::ClientConnection)
+      module RemoteServerConnection
+        include ShadowsocksRuby::Connections::Connection
+        include ShadowsocksRuby::Connections::BackendConnection
+
+        # (see TCP::ClientConnection#process_hook)
+        def process_hook
+          data = packet_protocol.tcp_receive_from_remoteserver(-1)
+          plexer.packet_protocol.tcp_send_to_client(data)
+        end
+
+      end
+    end
+  end
+end