websocket-driver 0.7.1

data/lib/websocket/driver/hybi/frame.rb

@@ -0,0 +1,20 @@
+module WebSocket
+  class Driver
+    class Hybi
+
+      class Frame
+        attr_accessor :final,
+                      :rsv1,
+                      :rsv2,
+                      :rsv3,
+                      :opcode,
+                      :masked,
+                      :masking_key,
+                      :length_bytes,
+                      :length,
+                      :payload
+      end
+
+    end
+  end
+end

data/lib/websocket/driver/hybi/message.rb

@@ -0,0 +1,31 @@
+module WebSocket
+  class Driver
+    class Hybi
+
+      class Message
+        attr_accessor :rsv1,
+                      :rsv2,
+                      :rsv3,
+                      :opcode,
+                      :data
+
+        def initialize
+          @rsv1   = false
+          @rsv2   = false
+          @rsv3   = false
+          @opcode = nil
+          @data   = String.new('').force_encoding(BINARY)
+        end
+
+        def <<(frame)
+          @rsv1   ||= frame.rsv1
+          @rsv2   ||= frame.rsv2
+          @rsv3   ||= frame.rsv3
+          @opcode ||= frame.opcode
+          @data   <<  frame.payload
+        end
+      end
+
+    end
+  end
+end

data/lib/websocket/driver/proxy.rb

@@ -0,0 +1,68 @@
+module WebSocket
+  class Driver
+
+    class Proxy
+      include EventEmitter
+
+      PORTS = {'ws' => 80, 'wss' => 443}
+
+      attr_reader :status, :headers
+
+      def initialize(client, origin, options)
+        super()
+
+        @client  = client
+        @http    = HTTP::Response.new
+        @socket  = client.instance_variable_get(:@socket)
+        @origin  = URI.parse(@socket.url)
+        @url     = URI.parse(origin)
+        @options = options
+        @state   = 0
+
+        @headers = Headers.new
+        @headers['Host'] = @origin.host + (@origin.port ? ":#{@origin.port}" : '')
+        @headers['Connection'] = 'keep-alive'
+        @headers['Proxy-Connection'] = 'keep-alive'
+
+        if @url.user
+          auth = Base64.strict_encode64([@url.user, @url.password] * ':')
+          @headers['Proxy-Authorization'] = 'Basic ' + auth
+        end
+      end
+
+      def set_header(name, value)
+        return false unless @state == 0
+        @headers[name] = value
+        true
+      end
+
+      def start
+        return false unless @state == 0
+        @state = 1
+
+        port    = @origin.port || PORTS[@origin.scheme]
+        start   = "CONNECT #{@origin.host}:#{port} HTTP/1.1"
+        headers = [start, @headers.to_s, '']
+
+        @socket.write(headers.join("\r\n"))
+        true
+      end
+
+      def parse(chunk)
+        @http.parse(chunk)
+        return unless @http.complete?
+
+        @status  = @http.code
+        @headers = Headers.new(@http.headers)
+
+        if @status == 200
+          emit(:connect, ConnectEvent.new)
+        else
+          message = "Can't establish a connection to the server at #{@socket.url}"
+          emit(:error, ProtocolError.new(message))
+        end
+      end
+    end
+
+  end
+end

data/lib/websocket/driver/server.rb

@@ -0,0 +1,80 @@
+module WebSocket
+  class Driver
+
+    class Server < Driver
+      EVENTS = %w[open message error close]
+
+      def initialize(socket, options = {})
+        super
+        @http = HTTP::Request.new
+        @delegate = nil
+      end
+
+      def env
+        @http.complete? ? @http.env : nil
+      end
+
+      def url
+        return nil unless e = env
+
+        url  = "ws://#{e['HTTP_HOST']}"
+        url << e['PATH_INFO']
+        url << "?#{e['QUERY_STRING']}" unless e['QUERY_STRING'] == ''
+        url
+      end
+
+      %w[add_extension set_header start frame text binary ping close].each do |method|
+        define_method(method) do |*args, &block|
+          if @delegate
+            @delegate.__send__(method, *args, &block)
+          else
+            @queue << [method, args, block]
+            true
+          end
+        end
+      end
+
+      %w[protocol version].each do |method|
+        define_method(method) do
+          @delegate && @delegate.__send__(method)
+        end
+      end
+
+      def parse(chunk)
+        return @delegate.parse(chunk) if @delegate
+
+        @http.parse(chunk)
+        return fail_request('Invalid HTTP request') if @http.error?
+        return unless @http.complete?
+
+        @delegate = Driver.rack(self, @options)
+        open
+
+        EVENTS.each do |event|
+          @delegate.on(event) { |e| emit(event, e) }
+        end
+
+        emit(:connect, ConnectEvent.new)
+      end
+
+      def write(buffer)
+        @socket.write(buffer)
+      end
+
+    private
+
+      def fail_request(message)
+        emit(:error, ProtocolError.new(message))
+        emit(:close, CloseEvent.new(Hybi::ERRORS[:protocol_error], message))
+      end
+
+      def open
+        @queue.each do |method, args, block|
+          @delegate.__send__(method, *args, &block)
+        end
+        @queue = []
+      end
+    end
+
+  end
+end

data/lib/websocket/driver/stream_reader.rb

@@ -0,0 +1,55 @@
+module WebSocket
+  class Driver
+
+    class StreamReader
+      # Try to minimise the number of reallocations done:
+      MINIMUM_AUTOMATIC_PRUNE_OFFSET = 128
+
+      def initialize
+        @buffer = String.new('').force_encoding(BINARY)
+        @offset = 0
+      end
+
+      def put(chunk)
+        return unless chunk and chunk.bytesize > 0
+        @buffer << chunk.force_encoding(BINARY)
+      end
+
+      # Read bytes from the data:
+      def read(length)
+        return nil if (@offset + length) > @buffer.bytesize
+
+        chunk = @buffer.byteslice(@offset, length)
+        @offset += chunk.bytesize
+
+        prune if @offset > MINIMUM_AUTOMATIC_PRUNE_OFFSET
+
+        return chunk
+      end
+
+      def each_byte
+        prune
+
+        @buffer.each_byte do |octet|
+          @offset += 1
+          yield octet
+        end
+      end
+
+    private
+
+      def prune
+        buffer_size = @buffer.bytesize
+
+        if @offset > buffer_size
+          @buffer = String.new('').force_encoding(BINARY)
+        else
+          @buffer = @buffer.byteslice(@offset, buffer_size - @offset)
+        end
+
+        @offset = 0
+      end
+    end
+
+  end
+end

data/lib/websocket/http.rb

@@ -0,0 +1,15 @@
+module WebSocket
+  module HTTP
+
+    root = File.expand_path('../http', __FILE__)
+
+    autoload :Headers,  root + '/headers'
+    autoload :Request,  root + '/request'
+    autoload :Response, root + '/response'
+
+    def self.normalize_header(name)
+      name.to_s.strip.downcase.gsub(/^http_/, '').gsub(/_/, '-')
+    end
+
+  end
+end

data/lib/websocket/http/headers.rb

@@ -0,0 +1,112 @@
+module WebSocket
+  module HTTP
+
+    module Headers
+      MAX_LINE_LENGTH = 4096
+      CR = 0x0D
+      LF = 0x0A
+
+      # RFC 2616 grammar rules:
+      #
+      #       CHAR           = <any US-ASCII character (octets 0 - 127)>
+      #
+      #       CTL            = <any US-ASCII control character
+      #                        (octets 0 - 31) and DEL (127)>
+      #
+      #       SP             = <US-ASCII SP, space (32)>
+      #
+      #       HT             = <US-ASCII HT, horizontal-tab (9)>
+      #
+      #       token          = 1*<any CHAR except CTLs or separators>
+      #
+      #       separators     = "(" | ")" | "<" | ">" | "@"
+      #                      | "," | ";" | ":" | "\" | <">
+      #                      | "/" | "[" | "]" | "?" | "="
+      #                      | "{" | "}" | SP | HT
+      #
+      # Or, as redefined in RFC 7230:
+      #
+      #       token          = 1*tchar
+      #
+      #       tchar          = "!" / "#" / "$" / "%" / "&" / "'" / "*"
+      #                      / "+" / "-" / "." / "^" / "_" / "`" / "|" / "~"
+      #                      / DIGIT / ALPHA
+      #                      ; any VCHAR, except delimiters
+
+      HEADER_LINE = /^([!#\$%&'\*\+\-\.\^_`\|~0-9a-z]+):\s*([\x20-\x7e]*?)\s*$/i
+
+      attr_reader :headers
+
+      def initialize
+        @buffer  = []
+        @env     = {}
+        @headers = {}
+        @stage   = 0
+      end
+
+      def complete?
+        @stage == 2
+      end
+
+      def error?
+        @stage == -1
+      end
+
+      def parse(chunk)
+        chunk.each_byte do |octet|
+          if octet == LF and @stage < 2
+            @buffer.pop if @buffer.last == CR
+            if @buffer.empty?
+              complete if @stage == 1
+            else
+              result = case @stage
+                       when 0 then start_line(string_buffer)
+                       when 1 then header_line(string_buffer)
+                       end
+
+              if result
+                @stage = 1
+              else
+                error
+              end
+            end
+            @buffer = []
+          else
+            @buffer << octet if @stage >= 0
+            error if @stage < 2 and @buffer.size > MAX_LINE_LENGTH
+          end
+        end
+        @env['rack.input'] = StringIO.new(string_buffer)
+      end
+
+    private
+
+      def complete
+        @stage = 2
+      end
+
+      def error
+        @stage = -1
+      end
+
+      def header_line(line)
+        return false unless parsed = line.scan(HEADER_LINE).first
+
+        key   = HTTP.normalize_header(parsed[0])
+        value = parsed[1].strip
+
+        if @headers.has_key?(key)
+          @headers[key] << ', ' << value
+        else
+          @headers[key] = value
+        end
+        true
+      end
+
+      def string_buffer
+        @buffer.pack('C*')
+      end
+    end
+
+  end
+end

data/lib/websocket/http/request.rb

@@ -0,0 +1,45 @@
+module WebSocket
+  module HTTP
+
+    class Request
+      include Headers
+
+      REQUEST_LINE     = /^(OPTIONS|GET|HEAD|POST|PUT|DELETE|TRACE|CONNECT) ([\x21-\x7e]+) (HTTP\/[0-9]+\.[0-9]+)$/
+      REQUEST_TARGET   = /^(.*?)(\?(.*))?$/
+      RESERVED_HEADERS = %w[content-length content-type]
+
+      attr_reader :env
+
+    private
+
+      def start_line(line)
+        return false unless parsed = line.scan(REQUEST_LINE).first
+
+        target = parsed[1].scan(REQUEST_TARGET).first
+
+        @env = {
+          'REQUEST_METHOD' => parsed[0],
+          'SCRIPT_NAME'    => '',
+          'PATH_INFO'      => target[0],
+          'QUERY_STRING'   => target[2] || ''
+        }
+        true
+      end
+
+      def complete
+        super
+        @headers.each do |name, value|
+          rack_name = name.upcase.gsub(/-/, '_')
+          rack_name = "HTTP_#{rack_name}" unless RESERVED_HEADERS.include?(name)
+          @env[rack_name] = value
+        end
+        if host = @env['HTTP_HOST']
+          uri = URI.parse("http://#{host}")
+          @env['SERVER_NAME'] = uri.host
+          @env['SERVER_PORT'] = uri.port.to_s
+        end
+      end
+    end
+
+  end
+end

data/lib/websocket/http/response.rb

@@ -0,0 +1,29 @@
+module WebSocket
+  module HTTP
+
+    class Response
+      include Headers
+
+      STATUS_LINE = /^(HTTP\/[0-9]+\.[0-9]+) ([0-9]{3}) ([\x20-\x7e]+)$/
+
+      attr_reader :code
+
+      def [](name)
+        @headers[HTTP.normalize_header(name)]
+      end
+
+      def body
+        @buffer.pack('C*')
+      end
+
+    private
+
+      def start_line(line)
+        return false unless parsed = line.scan(STATUS_LINE).first
+        @code = parsed[1].to_i
+        true
+      end
+    end
+
+  end
+end