ed3-precompiled_websocket-driver 0.8.0-arm64-darwin

data/lib/websocket/driver/client.rb

@@ -0,0 +1,139 @@
+module WebSocket
+  class Driver
+
+    class Client < Hybi
+      VALID_SCHEMES = %w[ws wss]
+
+      def self.generate_key
+        Base64.strict_encode64(SecureRandom.random_bytes(16))
+      end
+
+      attr_reader :status, :headers
+
+      def initialize(socket, options = {})
+        super
+
+        @ready_state = -1
+        @key         = Client.generate_key
+        @accept      = Hybi.generate_accept(@key)
+        @http        = HTTP::Response.new
+
+        uri = URI.parse(@socket.url)
+        unless VALID_SCHEMES.include?(uri.scheme)
+          raise URIError, "#{ socket.url } is not a valid WebSocket URL"
+        end
+
+        path      = (uri.path == '') ? '/' : uri.path
+        @pathname = path + (uri.query ? '?' + uri.query : '')
+
+        @headers['Host']                  = Driver.host_header(uri)
+        @headers['Upgrade']               = 'websocket'
+        @headers['Connection']            = 'Upgrade'
+        @headers['Sec-WebSocket-Key']     = @key
+        @headers['Sec-WebSocket-Version'] = VERSION
+
+        if @protocols.size > 0
+          @headers['Sec-WebSocket-Protocol'] = @protocols * ', '
+        end
+
+        if uri.user
+          auth = Base64.strict_encode64([uri.user, uri.password] * ':')
+          @headers['Authorization'] = 'Basic ' + auth
+        end
+      end
+
+      def version
+        "hybi-#{ VERSION }"
+      end
+
+      def proxy(origin, options = {})
+        Proxy.new(self, origin, options)
+      end
+
+      def start
+        return false unless @ready_state == -1
+        @socket.write(handshake_request)
+        @ready_state = 0
+        true
+      end
+
+      def parse(chunk)
+        return if @ready_state == 3
+        return super if @ready_state > 0
+
+        @http.parse(chunk)
+        return fail_handshake('Invalid HTTP response') if @http.error?
+        return unless @http.complete?
+
+        validate_handshake
+        return if @ready_state == 3
+
+        open
+        parse(@http.body)
+      end
+
+    private
+
+      def handshake_request
+        extensions = @extensions.generate_offer
+        @headers['Sec-WebSocket-Extensions'] = extensions if extensions
+
+        start   = "GET #{ @pathname } HTTP/1.1"
+        headers = [start, @headers.to_s, '']
+        headers.join("\r\n")
+      end
+
+      def fail_handshake(message)
+        message = "Error during WebSocket handshake: #{ message }"
+        @ready_state = 3
+        emit(:error, ProtocolError.new(message))
+        emit(:close, CloseEvent.new(ERRORS[:protocol_error], message))
+      end
+
+      def validate_handshake
+        @status  = @http.code
+        @headers = Headers.new(@http.headers)
+
+        unless @http.code == 101
+          return fail_handshake("Unexpected response code: #{ @http.code }")
+        end
+
+        upgrade    = @http['Upgrade'] || ''
+        connection = @http['Connection'] || ''
+        accept     = @http['Sec-WebSocket-Accept'] || ''
+        protocol   = @http['Sec-WebSocket-Protocol'] || ''
+
+        if upgrade == ''
+          return fail_handshake("'Upgrade' header is missing")
+        elsif upgrade.downcase != 'websocket'
+          return fail_handshake("'Upgrade' header value is not 'WebSocket'")
+        end
+
+        if connection == ''
+          return fail_handshake("'Connection' header is missing")
+        elsif connection.downcase != 'upgrade'
+          return fail_handshake("'Connection' header value is not 'Upgrade'")
+        end
+
+        unless accept == @accept
+          return fail_handshake('Sec-WebSocket-Accept mismatch')
+        end
+
+        unless protocol == ''
+          if @protocols.include?(protocol)
+            @protocol = protocol
+          else
+            return fail_handshake('Sec-WebSocket-Protocol mismatch')
+          end
+        end
+
+        begin
+          @extensions.activate(@headers['Sec-WebSocket-Extensions'])
+        rescue ::WebSocket::Extensions::ExtensionError => error
+          return fail_handshake(error.message)
+        end
+      end
+    end
+
+  end
+end

data/lib/websocket/driver/draft75.rb

@@ -0,0 +1,102 @@
+module WebSocket
+  class Driver
+
+    class Draft75 < Driver
+      def initialize(socket, options = {})
+        super
+
+        @stage   = 0
+        @closing = false
+
+        @headers['Upgrade']            = 'WebSocket'
+        @headers['Connection']         = 'Upgrade'
+        @headers['WebSocket-Origin']   = @socket.env['HTTP_ORIGIN']
+        @headers['WebSocket-Location'] = @socket.url
+      end
+
+      def version
+        'hixie-75'
+      end
+
+      def close(reason = nil, code = nil)
+        return false if @ready_state == 3
+        @ready_state = 3
+        emit(:close, CloseEvent.new(nil, nil))
+        true
+      end
+
+      def parse(chunk)
+        return if @ready_state > 1
+
+        @reader.put(chunk)
+
+        @reader.each_byte do |octet|
+          case @stage
+            when -1 then
+              @body << octet
+              send_handshake_body
+
+            when 0 then
+              parse_leading_byte(octet)
+
+            when 1 then
+              @length = (octet & 0x7F) + 128 * @length
+
+              if @closing and @length.zero?
+                return close
+              elsif (octet & 0x80) != 0x80
+                if @length.zero?
+                  @stage = 0
+                else
+                  @skipped = 0
+                  @stage   = 2
+                end
+              end
+
+            when 2 then
+              if octet == 0xFF
+                @stage = 0
+                emit(:message, MessageEvent.new(Driver.encode(@buffer, Encoding::UTF_8)))
+              else
+                if @length
+                  @skipped += 1
+                  @stage = 0 if @skipped == @length
+                else
+                  @buffer << octet
+                  return close if @buffer.size > @max_length
+                end
+              end
+          end
+        end
+      end
+
+      def frame(buffer, type = nil, error_type = nil)
+        return queue([buffer, type, error_type]) if @ready_state == 0
+        frame = [0x00, buffer, 0xFF].pack('CA*C')
+        @socket.write(frame)
+        true
+      end
+
+    private
+
+      def handshake_response
+        start   = 'HTTP/1.1 101 Web Socket Protocol Handshake'
+        headers = [start, @headers.to_s, '']
+        headers.join("\r\n")
+      end
+
+      def parse_leading_byte(octet)
+        if (octet & 0x80) == 0x80
+          @length = 0
+          @stage  = 1
+        else
+          @length  = nil
+          @skipped = nil
+          @buffer  = []
+          @stage   = 2
+        end
+      end
+    end
+
+  end
+end

data/lib/websocket/driver/draft76.rb

@@ -0,0 +1,99 @@
+module WebSocket
+  class Driver
+
+    class Draft76 < Draft75
+      BODY_SIZE = 8
+
+      def initialize(socket, options = {})
+        super
+        input  = (@socket.env['rack.input'] || StringIO.new('')).read
+        input  = input.dup if input.frozen?
+        @stage = -1
+        @body  = input.force_encoding(Encoding::BINARY)
+
+        @headers.clear
+        @headers['Upgrade'] = 'WebSocket'
+        @headers['Connection'] = 'Upgrade'
+        @headers['Sec-WebSocket-Origin'] = @socket.env['HTTP_ORIGIN']
+        @headers['Sec-WebSocket-Location'] = @socket.url
+      end
+
+      def version
+        'hixie-76'
+      end
+
+      def start
+        return false unless super
+        send_handshake_body
+        true
+      end
+
+      def close(reason = nil, code = nil)
+        return false if @ready_state == 3
+        @socket.write([0xFF, 0x00].pack('C*')) if @ready_state == 1
+        @ready_state = 3
+        emit(:close, CloseEvent.new(nil, nil))
+        true
+      end
+
+    private
+
+      def handshake_response
+        env     = @socket.env
+        key1    = env['HTTP_SEC_WEBSOCKET_KEY1']
+        key2    = env['HTTP_SEC_WEBSOCKET_KEY2']
+
+        raise ProtocolError.new('Missing required header: Sec-WebSocket-Key1') unless key1
+        raise ProtocolError.new('Missing required header: Sec-WebSocket-Key2') unless key2
+
+        number1 = number_from_key(key1)
+        spaces1 = spaces_in_key(key1)
+
+        number2 = number_from_key(key2)
+        spaces2 = spaces_in_key(key2)
+
+        if number1 % spaces1 != 0 or number2 % spaces2 != 0
+          raise ProtocolError.new('Client sent invalid Sec-WebSocket-Key headers')
+        end
+
+        @key_values = [number1 / spaces1, number2 / spaces2]
+
+        start   = 'HTTP/1.1 101 WebSocket Protocol Handshake'
+        headers = [start, @headers.to_s, '']
+        headers.join("\r\n")
+      end
+
+      def handshake_signature
+        return nil unless @body.bytesize >= BODY_SIZE
+
+        head = @body[0...BODY_SIZE]
+        Digest::MD5.digest((@key_values + [head]).pack('N2A*'))
+      end
+
+      def send_handshake_body
+        return unless signature = handshake_signature
+        @socket.write(signature)
+        @stage = 0
+        open
+        parse(@body[BODY_SIZE..-1]) if @body.bytesize > BODY_SIZE
+      end
+
+      def parse_leading_byte(octet)
+        return super unless octet == 0xFF
+        @closing = true
+        @length  = 0
+        @stage   = 1
+      end
+
+      def number_from_key(key)
+        number = key.scan(/[0-9]/).join('')
+        number == '' ? Float::NAN : number.to_i(10)
+      end
+
+      def spaces_in_key(key)
+        key.scan(/ /).size
+      end
+    end
+
+  end
+end

data/lib/websocket/driver/event_emitter.rb

@@ -0,0 +1,54 @@
+module WebSocket
+  class Driver
+
+    module EventEmitter
+      def initialize
+        @listeners = Hash.new { |h,k| h[k] = [] }
+      end
+
+      def add_listener(event, callable = nil, &block)
+        listener = callable || block
+        @listeners[event.to_s] << listener
+        listener
+      end
+
+      def on(event, callable = nil, &block)
+        if callable
+          add_listener(event, callable)
+        else
+          add_listener(event, &block)
+        end
+      end
+
+      def remove_listener(event, callable = nil, &block)
+        listener = callable || block
+        @listeners[event.to_s].delete(listener)
+        listener
+      end
+
+      def remove_all_listeners(event = nil)
+        if event
+          @listeners.delete(event.to_s)
+        else
+          @listeners.clear
+        end
+      end
+
+      def emit(event, *args)
+        @listeners[event.to_s].dup.each do |listener|
+          listener.call(*args)
+        end
+      end
+
+      def listener_count(event)
+        return 0 unless @listeners.has_key?(event.to_s)
+        @listeners[event.to_s].size
+      end
+
+      def listeners(event)
+        @listeners[event.to_s]
+      end
+    end
+
+  end
+end

data/lib/websocket/driver/headers.rb

@@ -0,0 +1,45 @@
+module WebSocket
+  class Driver
+
+    class Headers
+      ALLOWED_DUPLICATES = %w[set-cookie set-cookie2 warning www-authenticate]
+
+      def initialize(received = {})
+        @raw = received
+        clear
+
+        @received = {}
+        @raw.each { |k,v| @received[HTTP.normalize_header(k)] = v }
+      end
+
+      def clear
+        @sent  = Set.new
+        @lines = []
+      end
+
+      def [](name)
+        @received[HTTP.normalize_header(name)]
+      end
+
+      def []=(name, value)
+        return if value.nil?
+        key = HTTP.normalize_header(name)
+        return unless @sent.add?(key) or ALLOWED_DUPLICATES.include?(key)
+        @lines << "#{ name.strip }: #{ value.to_s.strip }\r\n"
+      end
+
+      def inspect
+        @raw.inspect
+      end
+
+      def to_h
+        @raw.dup
+      end
+
+      def to_s
+        @lines.join('')
+      end
+    end
+
+  end
+end

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(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