ed2-precompiled_websocket-driver 0.8.0

data/lib/websocket/driver.rb

@@ -0,0 +1,248 @@
+# Protocol references:
+#
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+require 'base64'
+require 'digest/md5'
+require 'digest/sha1'
+require 'securerandom'
+require 'set'
+require 'stringio'
+require 'uri'
+require 'websocket/extensions'
+
+module WebSocket
+  autoload :HTTP, File.expand_path('../http', __FILE__)
+
+  class Driver
+
+    root = File.expand_path('../driver', __FILE__)
+
+    begin
+      # Load C native extension
+      require 'websocket_mask'
+    rescue LoadError
+      # Fall back to pure-Ruby implementation
+      require 'websocket/mask'
+    end
+
+
+    if RUBY_PLATFORM =~ /java/
+      require 'jruby'
+      com.jcoglan.websocket.WebsocketMaskService.new.basicLoad(JRuby.runtime)
+    end
+
+    unless Mask.respond_to?(:mask)
+      def Mask.mask(payload, mask)
+        @instance ||= new
+        @instance.mask(payload, mask)
+      end
+    end
+
+    MAX_LENGTH = 0x3ffffff
+    PORTS      = { 'ws' => 80, 'wss' => 443 }
+    STATES     = [:connecting, :open, :closing, :closed]
+
+    ConnectEvent = Struct.new(nil)
+    OpenEvent    = Struct.new(nil)
+    MessageEvent = Struct.new(:data)
+    PingEvent    = Struct.new(:data)
+    PongEvent    = Struct.new(:data)
+    CloseEvent   = Struct.new(:code, :reason)
+
+    ProtocolError      = Class.new(StandardError)
+    URIError           = Class.new(ArgumentError)
+    ConfigurationError = Class.new(ArgumentError)
+
+    autoload :Client,       root + '/client'
+    autoload :Draft75,      root + '/draft75'
+    autoload :Draft76,      root + '/draft76'
+    autoload :EventEmitter, root + '/event_emitter'
+    autoload :Headers,      root + '/headers'
+    autoload :Hybi,         root + '/hybi'
+    autoload :Proxy,        root + '/proxy'
+    autoload :Server,       root + '/server'
+    autoload :StreamReader, root + '/stream_reader'
+
+    include EventEmitter
+    attr_reader :protocol, :ready_state
+
+    def initialize(socket, options = {})
+      super()
+      Driver.validate_options(options, [:max_length, :masking, :require_masking, :protocols, :binary_data_format])
+
+      @socket      = socket
+      @reader      = StreamReader.new
+      @options     = options
+      @max_length  = options[:max_length] || MAX_LENGTH
+      @headers     = Headers.new
+      @queue       = []
+      @ready_state = 0
+
+      @binary_data_format = options[:binary_data_format] || :string
+    end
+
+    def state
+      return nil unless @ready_state >= 0
+      STATES[@ready_state]
+    end
+
+    def add_extension(extension)
+      false
+    end
+
+    def set_header(name, value)
+      return false unless @ready_state <= 0
+      @headers[name] = value
+      true
+    end
+
+    def start
+      return false unless @ready_state == 0
+
+      unless Driver.websocket?(@socket.env)
+        return fail_handshake(ProtocolError.new('Not a WebSocket request'))
+      end
+
+      begin
+        response = handshake_response
+      rescue => error
+        return fail_handshake(error)
+      end
+
+      @socket.write(response)
+      open unless @stage == -1
+      true
+    end
+
+    def text(message)
+      message = Driver.encode(message, Encoding::UTF_8)
+      frame(message, :text)
+    end
+
+    def binary(message)
+      false
+    end
+
+    def ping(*args)
+      false
+    end
+
+    def pong(*args)
+      false
+    end
+
+    def close(reason = nil, code = nil)
+      return false unless @ready_state == 1
+      @ready_state = 3
+      emit(:close, CloseEvent.new(nil, nil))
+      true
+    end
+
+  private
+
+    def fail_handshake(error)
+      headers = Headers.new
+      headers['Content-Type'] = 'text/plain'
+      headers['Content-Length'] = error.message.bytesize
+
+      headers = ['HTTP/1.1 400 Bad Request', headers.to_s, error.message]
+      @socket.write(headers.join("\r\n"))
+      fail(:protocol_error, error.message)
+
+      false
+    end
+
+    def fail(type, message)
+      @ready_state = 2
+      emit(:error, ProtocolError.new(message))
+      close
+    end
+
+    def open
+      @ready_state = 1
+      @queue.each { |message| frame(*message) }
+      @queue = []
+      emit(:open, OpenEvent.new)
+    end
+
+    def queue(message)
+      @queue << message
+      true
+    end
+
+    def self.client(socket, options = {})
+      Client.new(socket, options.merge(:masking => true))
+    end
+
+    def self.server(socket, options = {})
+      Server.new(socket, options.merge(:require_masking => true))
+    end
+
+    def self.rack(socket, options = {})
+      env     = socket.env
+      version = env['HTTP_SEC_WEBSOCKET_VERSION']
+      key     = env['HTTP_SEC_WEBSOCKET_KEY']
+      key1    = env['HTTP_SEC_WEBSOCKET_KEY1']
+      key2    = env['HTTP_SEC_WEBSOCKET_KEY2']
+
+      if version or key
+        Hybi.new(socket, options.merge(:require_masking => true))
+      elsif key1 or key2
+        Draft76.new(socket, options)
+      else
+        Draft75.new(socket, options)
+      end
+    end
+
+    def self.encode(data, encoding = nil)
+      if Array === data
+        data = data.pack('C*')
+        encoding ||= Encoding::BINARY
+      end
+
+      return data if encoding.nil? or data.encoding == encoding
+
+      if data.encoding == Encoding::BINARY
+        data = data.dup if data.frozen?
+        data.force_encoding(encoding)
+      else
+        data.encode(encoding)
+      end
+    end
+
+    def self.host_header(uri)
+      host = uri.host
+      if uri.port and uri.port != PORTS[uri.scheme]
+        host += ":#{uri.port}"
+      end
+      host
+    end
+
+    def self.validate_options(options, valid_keys)
+      options.keys.each do |key|
+        unless valid_keys.include?(key)
+          raise ConfigurationError, "Unrecognized option: #{ key.inspect }"
+        end
+      end
+
+      if options[:binary_data_format]
+        unless [:array, :string].include?(options[:binary_data_format])
+          raise ConfigurationError, "Invalid :binary_data_format: #{options[:binary_data_format].inspect}"
+        end
+      end
+    end
+
+    def self.websocket?(env)
+      connection = env['HTTP_CONNECTION'] || ''
+      upgrade    = env['HTTP_UPGRADE']    || ''
+
+      env['REQUEST_METHOD'] == 'GET' and
+      connection.downcase.split(/ *, */).include?('upgrade') and
+      upgrade.downcase == 'websocket'
+    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

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/mask.rb

@@ -0,0 +1,14 @@
+module WebSocket
+  module Mask
+    def self.mask(payload, mask)
+      return payload if mask.nil? || payload.empty?
+
+      payload.tap do |result|
+        payload.bytesize.times do |i|
+          result.setbyte(i, payload.getbyte(i) ^ mask.getbyte(i % 4))
+        end
+      end
+    end
+
+  end
+end

data/lib/websocket/websocket_mask.rb

@@ -0,0 +1,9 @@
+# Load C native extension
+
+begin
+  ruby_version = /(\d+\.\d+)/.match(::RUBY_VERSION)
+
+  require "websocket-driver/#{ruby_version}/websocket_mask"
+rescue LoadError
+  require "websocket-driver/websocket_mask"
+end

metadata

@@ -0,0 +1,153 @@
+--- !ruby/object:Gem::Specification
+name: ed2-precompiled_websocket-driver
+version: !ruby/object:Gem::Version
+  version: 0.8.0
+platform: ruby
+authors:
+- James Coglan
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: base64
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: websocket-extensions
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: permessage_deflate
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+email: jcoglan@gmail.com
+executables: []
+extensions:
+- ext/websocket-driver/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.md
+- README.md
+- ext/websocket-driver/WebsocketMaskService.java
+- ext/websocket-driver/extconf.rb
+- ext/websocket-driver/websocket_mask.c
+- lib/websocket/driver.rb
+- lib/websocket/driver/client.rb
+- lib/websocket/driver/draft75.rb
+- lib/websocket/driver/draft76.rb
+- lib/websocket/driver/event_emitter.rb
+- lib/websocket/driver/headers.rb
+- lib/websocket/driver/hybi.rb
+- lib/websocket/driver/hybi/frame.rb
+- lib/websocket/driver/hybi/message.rb
+- lib/websocket/driver/proxy.rb
+- lib/websocket/driver/server.rb
+- lib/websocket/driver/stream_reader.rb
+- lib/websocket/http.rb
+- lib/websocket/http/headers.rb
+- lib/websocket/http/request.rb
+- lib/websocket/http/response.rb
+- lib/websocket/mask.rb
+- lib/websocket/websocket_mask.rb
+homepage: https://github.com/faye/websocket-driver-ruby
+licenses:
+- Apache-2.0
+metadata:
+  changelog_uri: https://github.com/faye/websocket-driver-ruby/blob/main/CHANGELOG.md
+rdoc_options:
+- "--main"
+- README.md
+- "--markup"
+- markdown
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: WebSocket protocol handler with pluggable I/O
+test_files: []