skinny 0.1.2 → 0.2.0

data/README.md

@@ -16,7 +16,7 @@ simple, not-yet-optimised example I'm using at the moment:
     class Sinatra::Request
       include Skinny::Helpers
     end
-    
+
     module MailCatcher
       class Web < Sinatra::Base
         get '/messages' do
@@ -34,7 +34,7 @@ simple, not-yet-optimised example I'm using at the moment:
         end
       end
     end
-  
+
 This syntax will probably get cleaned up. I would like to build a
 nice Sinatra handler with DSL with unbound handlers so Sinatra
 requests can be recycled.
@@ -46,6 +46,10 @@ requests can be recycled.
  * Tests
  * Make more generic for alternate server implementations?
 
+## Thanks
+
+The latest WebSocket draft support is adapted from https://github.com/gimite/web-socket-ruby -- thank you!
+
 ## Copyright
 
 Copyright (c) 2010 Samuel Cochran. See LICENSE for details.

data/lib/skinny.rb

@@ -10,7 +10,7 @@ module Skinny
         include InstanceMethods
       end
     end
-  
+
     module ClassMethods
       def define_callback *names
         names.each do |name|
@@ -20,7 +20,7 @@ module Skinny
         end
       end
     end
-  
+
     module InstanceMethods
       def add_callback name, &block
         @callbacks ||= {}
@@ -37,18 +37,27 @@ module Skinny
 
   class WebSocketError < RuntimeError; end
   class WebSocketProtocolError < WebSocketError; end
-  
+
   # We need to be really careful not to throw an exception too high
   # or we'll kill the server.
   class Websocket < EventMachine::Connection
     include Callbacks
     include Thin::Logging
-  
+
     define_callback :on_open, :on_start, :on_handshake, :on_message, :on_error, :on_finish, :on_close
 
     # 4mb is almost too generous, imho.
     MAX_BUFFER_LENGTH = 2 ** 32
-    
+
+    GUID = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"
+
+    OPCODE_CONTINUATION = 0x00
+    OPCODE_TEXT = 0x01
+    OPCODE_BINARY = 0x02
+    OPCODE_CLOSE = 0x08
+    OPCODE_PING = 0x09
+    OPCODE_PONG = 0x0a
+
     # Create a new WebSocket from a Thin::Request environment
     def self.from_env env, options={}
       # Pull the connection out of the env
@@ -58,31 +67,31 @@ module Skinny
       # We have all the events now, muahaha
       EM.attach(io, self, env, options)
     end
-    
+
     def initialize env, options={}
       @env = env.dup
       @buffer = ''
-      
-      self.protocol = options.delete :protocol if options.has_key? :protocol
+
+      @protocol = options.delete :protocol if options.has_key? :protocol
       [:on_open, :on_start, :on_handshake, :on_message, :on_error, :on_finish, :on_close].each do |name|
         send name, &options.delete(name) if options.has_key?(name)
       end
       raise ArgumentError, "Unknown options: #{options.inspect}" unless options.empty?
     end
 
-    # Connection is now open    
+    # Connection is now open
     def post_init
       EM.next_tick { callback :on_open, self rescue error! "Error in open callback" }
       @state = :open
     rescue
       error! "Error opening connection"
     end
-  
+
     # Return an async response -- stops Thin doing anything with connection.
     def response
       Thin::Connection::AsyncResponse
     end
-  
+
     # Arrayify self into a response tuple
     alias :to_a :response
 
@@ -90,189 +99,341 @@ module Skinny
     def start!
       # Steal any remaining data from rack.input
       @buffer = @env[Thin::Request::RACK_INPUT].read + @buffer
-    
+
       # Remove references to Thin connection objects, freeing memory
       @env.delete Thin::Request::RACK_INPUT
       @env.delete Thin::Request::ASYNC_CALLBACK
       @env.delete Thin::Request::ASYNC_CLOSE
 
+      # Figure out which version we're using
+      @version = @env['HTTP_SEC_WEBSOCKET_VERSION']
+      @version ||= "hixie-76" if @env.has_key?('HTTP_SEC_WEBSOCKET_KEY1') and @env.has_key?('HTTP_SEC_WEBSOCKET_KEY2')
+      @version ||= "hixie-75"
+
       # Pull out the details we care about
-      @origin ||= @env['HTTP_ORIGIN']
+      @origin ||= @env['HTTP_SEC_WEBSOCKET_ORIGIN'] || @env['HTTP_ORIGIN']
       @location ||= "ws#{secure? ? 's' : ''}://#{@env['HTTP_HOST']}#{@env['REQUEST_PATH']}"
-      @protocol ||= @env['HTTP_SEC_WEBSOCKET_PROTOCOL']
-    
+      @protocol ||= @env['HTTP_SEC_WEBSOCKET_PROTOCOL'] || @env['HTTP_WEBSOCKET_PROTOCOL']
+
       EM.next_tick { callback :on_start, self rescue error! "Error in start callback" }
-    
+
       # Queue up the actual handshake
       EM.next_tick method :handshake!
-      
+
       @state = :started
-    
+
       # Return self so we can be used as a response
       self
     rescue
       error! "Error starting connection"
     end
-    
-    attr_reader :env
-    attr_accessor :origin, :location, :protocol
-  
+
+    attr_reader :env, :version, :origin, :location, :protocol
+
+    def hixie_75?
+      @version == "hixie-75"
+    end
+
+    def hixie_76?
+      @version == "hixie-76"
+    end
+
     def secure?
       @env['HTTPS'] == 'on' or
+      # XXX: This could be faked... do we care?
       @env['HTTP_X_FORWARDED_PROTO'] == 'https' or
       @env['rack.url_scheme'] == 'https'
     end
 
+    def key
+      @env['HTTP_SEC_WEBSOCKET_KEY']
+    end
+
     [1, 2].each do |i|
       define_method :"key#{i}" do
         key = env["HTTP_SEC_WEBSOCKET_KEY#{i}"]
         key.scan(/[0-9]/).join.to_i / key.count(' ')
       end
     end
-  
+
     def key3
       @key3 ||= @buffer.slice!(0...8)
     end
-  
+
     def challenge?
       env.has_key? 'HTTP_SEC_WEBSOCKET_KEY1'
     end
-  
+
     def challenge
-      [key1, key2].pack("N*") + key3
+      if hixie_75?
+        nil
+      elsif hixie_76?
+        [key1, key2].pack("N*") + key3
+      else
+        key + GUID
+      end
     end
-  
+
     def challenge_response
-      Digest::MD5.digest(challenge)
+      if hixie_75?
+        nil
+      elsif hixie_76?
+        Digest::MD5.digest(challenge)
+      else
+        ActiveSupport::Base64.encode64(Digest::SHA1.digest(challenge)).strip
+      end
     end
-  
+
     # Generate the handshake
     def handshake
-      "HTTP/1.1 101 Web Socket Protocol Handshake\r\n" +
-      "Connection: Upgrade\r\n" +
-      "Upgrade: WebSocket\r\n" +
-      "Sec-WebSocket-Location: #{location}\r\n" +
-      "Sec-WebSocket-Origin: #{origin}\r\n" +
-      (protocol ? "Sec-WebSocket-Protocol: #{protocol}\r\n" : "") +
-      "\r\n" +
-      "#{challenge_response}"
+      "HTTP/1.1 101 Switching Protocols\r\n" <<
+      "Connection: Upgrade\r\n" <<
+      "Upgrade: WebSocket\r\n" <<
+      if hixie_75?
+        "WebSocket-Location: #{location}\r\n" <<
+        "WebSocket-Origin: #{origin}\r\n"
+      elsif hixie_76?
+        "Sec-WebSocket-Location: #{location}\r\n" <<
+        "Sec-WebSocket-Origin: #{origin}\r\n"
+      else
+        "Sec-WebSocket-Accept: #{challenge_response}\r\n"
+      end <<
+      (protocol ? "Sec-WebSocket-Protocol: #{protocol}\r\n" : "") <<
+      "\r\n" <<
+      (if hixie_76? then challenge_response else "" end)
     end
-    
+
     def handshake!
-      [key1, key2].each { |key| raise WebSocketProtocolError, "Invalid key: #{key}" if key >= 2**32 }
-      
-      # XXX: Should we wait for 8 bytes?
-      raise WebSocketProtocolError, "Invalid challenge: #{key3}" if key3.length < 8
-      
+      if hixie_76?
+        [key1, key2].each { |key| raise WebSocketProtocolError, "Invalid key: #{key}" if key >= 2**32 }
+        raise WebSocketProtocolError, "Invalid challenge: #{key3}" if key3.length < 8
+      end
+
       send_data handshake
+
       @state = :handshook
-    
+
       EM.next_tick { callback :on_handshake, self rescue error! "Error in handshake callback" }
     rescue
       error! "Error during WebSocket connection handshake"
     end
-    
+
     def receive_data data
-      @buffer += data
-    
+      @buffer << data
+
       EM.next_tick { process_frame } if @state == :handshook
     rescue
       error! "Error while receiving WebSocket data"
     end
-    
+
+    def mask payload, mask_key
+      payload.unpack("C*").map.with_index do |byte, index|
+        byte ^ mask_key[index % 4]
+      end.pack("C*")
+    end
+
     def process_frame
-      if @buffer.length >= 1
-        if @buffer[0].ord < 0x7f
-          if ending = @buffer.index("\xff")
-            frame = @buffer.slice! 0..ending
-            message = frame[1..-2]
-          
-            EM.next_tick { receive_message message }
-            
-            # There might be more frames to process
-            EM.next_tick { process_frame }
-          elsif @buffer.length > MAX_BUFFER_LENGTH
-            raise WebSocketProtocolError, "Maximum buffer length (#{MAX_BUFFER_LENGTH}) exceeded: #{@buffer.length}"
-          end
-        elsif @buffer[0] == "\xff"
-          if @buffer.length > 1
-            if @buffer[1] == "\x00"
-              @buffer.slice! 0..1
-        
-              EM.next_tick { finish! }
-            else
-              raise WebSocketProtocolError, "Incorrect finish frame length: #{@buffer[1].inspect}"
+      if hixie_75? or hixie_76?
+        if @buffer.length >= 1
+          if @buffer[0].ord < 0x7f
+            if ending = @buffer.index("\xff")
+              frame = @buffer.slice! 0..ending
+              message = frame[1..-2]
+
+              EM.next_tick { receive_message message }
+
+              # There might be more frames to process
+              EM.next_tick { process_frame }
+            elsif @buffer.length > MAX_BUFFER_LENGTH
+              raise WebSocketProtocolError, "Maximum buffer length (#{MAX_BUFFER_LENGTH}) exceeded: #{@buffer.length}"
+            end
+          elsif @buffer[0] == "\xff"
+            if @buffer.length > 1
+              if @buffer[1] == "\x00"
+                @buffer.slice! 0..1
+
+                EM.next_tick { finish! }
+              else
+                raise WebSocketProtocolError, "Incorrect finish frame length: #{@buffer[1].inspect}"
+              end
             end
+          else
+            raise WebSocketProtocolError, "Unknown frame type: #{@buffer[0].inspect}"
           end
-        else
-          raise WebSocketProtocolError, "Unknown frame type: #{@buffer[0].inspect}"
+        end
+      else
+        @frame_state ||= :opcode
+
+        if @frame_state == :opcode
+          return unless @buffer.length >= 2
+
+          bytes = @buffer.slice!(0...2).unpack("C*")
+
+          @opcode = bytes[0] & 0x0f
+          @fin = (bytes[0] & 0x80) != 0
+          @payload_length = bytes[1] & 0x7f
+          @masked = (bytes[1] & 0x80) != 0
+
+          return error! "Received unmasked data" unless @masked
+
+          if @payload_length == 126
+            @frame_state = :payload_2
+          elsif @payload_length == 127
+            @frame_state = :payload_8
+          else
+            @frame_state = :payload
+          end
+
+        elsif @frame_state == :payload_2
+          return unless @buffer.length >= 2
+
+          @payload_length = @buffer.slice!(0...2).unpack("n")[0]
+
+          @frame_state = :mask
+
+        elsif @frame_state == :payload_8
+          return unless @buffer.length >= 8
+
+          (high, low) = @buffer.slice!(0...8).unpack("NN")
+          @payload_length = high * (2 ** 32) + low
+
+          @frame_state = :mask
+
+        elsif @frame_state == :mask
+          return unless @buffer.length >= 4
+
+          bytes = @buffer[(offset)...(offset += 4)]
+          @mask_key = bytes.unpack("C*")
+
+          @frame_state = :payload
+
+        elsif @frame_state == :payload
+          return unless @buffer.length >= @payload_length
+
+          payload = @buffer.slice!(0...@payload_length)
+          payload = mask(payload, @mask_key)
+
+          if @opcode == OPCODE_TEXT
+            message = payload.force_encoding("UTF-8") if payload.respond_to? :force_encoding
+            EM.next_tick { receive_message payload }
+          elsif @opcode == OPCODE_CLOSE
+            EM.next_tick { finish! }
+          else
+            error! "Unsupported opcode: %d" % @opcode
+          end
+
+          @frame_state = nil
+          @opcode = @fin = @payload_length = @masked = nil
         end
       end
     rescue
       error! "Error while processing WebSocket frames"
     end
-  
+
     def receive_message message
       EM.next_tick { callback :on_message, self, message rescue error! "Error in message callback" }
     end
-  
-    def frame_message message
-      "\x00#{message}\xff"
+
+    # This is for post-hixie-76 versions only
+    def send_frame opcode, payload="", masked=false
+      payload = payload.dup.force_encoding("ASCII-8BIT") if payload.respond_to? :force_encoding
+      payload_length = payload.bytesize
+
+      # We don't support continuations (yet), so always send fin
+      fin_byte = 0x80
+      send_data [fin_byte | opcode].pack("C")
+
+      # We shouldn't be sending mask, we're a server only
+      masked_byte = masked ? 0x80 : 0x00
+
+      if payload_length <= 125
+        send_data [masked_byte | payload_length].pack("C")
+
+      elsif payload_length < 2 ** 16
+        send_data [masked_byte | 126].pack("C")
+        send_data [payload_length].pack("n")
+
+      else
+        send_data [masked_byte | 127].pack("C")
+        send_data [payload_length / (2 ** 32), payload_length % (2 ** 32)].pack("NN")
+      end
+
+      if payload_length
+        if masked
+          mask_key = Array.new(4) { rand(256) }.pack("C*")
+          send_data mask_key
+          payload = mask payload, mask_key
+        end
+
+        send_data payload
+      end
     end
-  
+
     def send_message message
-      send_data frame_message(message)
+      if hixie_75? or hixie_76?
+        send_data "\x00#{message}\xff"
+      else
+        send_frame OPCODE_TEXT, message
+      end
     end
-  
+
     # Finish the connection read for closing
     def finish!
-      send_data "\xff\x00"
-    
-      EM.next_tick { callback :on_finish, self rescue error! "Error in finish callback" }
+      if hixie_75? or hixie_76?
+        send_data "\xff\x00"
+      else
+        send_frame OPCODE_CLOSE
+      end
+
+      EM.next_tick { callback(:on_finish, self) rescue error! "Error in finish callback" }
       EM.next_tick { close_connection_after_writing }
 
       @state = :finished
     rescue
       error! "Error finishing WebSocket connection"
     end
-    
+
     # Make sure we call the on_close callbacks when the connection
     # disappears
     def unbind
-      EM.next_tick { callback :on_close, self rescue error! "Error in close callback" }
+      EM.next_tick { callback(:on_close, self) rescue error! "Error in close callback" }
       @state = :closed
     rescue
       error! "Error closing WebSocket connection"
     end
-    
-    def error! message=nil
+
+    def error! message=nil, callback=true
       log message unless message.nil?
-      log_error
-      
+      log_error # Logs the exception itself
+
       # Allow error messages to be handled, maybe
-      EM.next_tick { callback :on_error, self rescue error! "Error in error callback" }
-      
+      # but only if this error was not caused by the error callback
+      if callback
+        EM.next_tick { callback(:on_error, self) rescue error! "Error in error callback", true }
+      end
+
       # Try to finish and close nicely.
       EM.next_tick { finish! } unless [:finished, :closed, :error].include? @state
 
+      # We're closed!
       @state = :error
     end
   end
 
   module Helpers
     def websocket?
-      env['HTTP_CONNECTION'] == 'Upgrade' && env['HTTP_UPGRADE'] == 'WebSocket'
+      env['HTTP_CONNECTION'].downcase == 'upgrade' && env['HTTP_UPGRADE'].downcase == 'websocket'
     end
-  
-    def websocket(options={}, &block)
+
+    def websocket options={}, &block
       env['skinny.websocket'] ||= begin
         raise RuntimerError, "Not a WebSocket request" unless websocket?
         options[:on_message] = block if block_given?
         Websocket.from_env(env, options)
       end
     end
-  
-    def websocket!(options={}, &block)
+
+    def websocket! options={}, &block
       websocket(options, &block).start!
     end
   end

metadata

@@ -1,100 +1,93 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: skinny
-version: !ruby/object:Gem::Version 
-  hash: 31
-  prerelease: false
-  segments: 
-  - 0
-  - 1
-  - 2
-  version: 0.1.2
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Samuel Cochran
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-11-01 00:00:00 +08:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2010-11-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: eventmachine
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+  requirement: &70337454861360 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.12'
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: thin
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: *70337454861360
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: &70337454860420 !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
   type: :runtime
-  version_requirements: *id002
-description: "      Simple, upgradable WebSockets for Thin.\n"
+  prerelease: false
+  version_requirements: *70337454860420
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &70337454859940 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70337454859940
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &70337454859320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70337454859320
+description: Simple, upgradable WebSockets for Thin.
 email: sj26@sj26.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
-- LICENSE
+extra_rdoc_files:
 - README.md
-files: 
-- .gitignore
 - LICENSE
+files:
 - README.md
-- Rakefile
-- VERSION
+- LICENSE
 - lib/skinny.rb
-has_rdoc: true
 homepage: http://github.com/sj26/skinny
 licenses: []
-
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options: []
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.8.7
 signing_key: 
 specification_version: 3
 summary: Thin WebSockets
 test_files: []
-

data/.gitignore

@@ -1 +0,0 @@
-pkg

data/Rakefile

@@ -1,33 +0,0 @@
-require 'rubygems'
-require 'rake'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "skinny"
-    gem.summary = %Q{Thin WebSockets}
-    gem.description = <<-EOD
-      Simple, upgradable WebSockets for Thin.
-    EOD
-    gem.email = "sj26@sj26.com"
-    gem.homepage = "http://github.com/sj26/skinny"
-    gem.authors = ["Samuel Cochran"]
-    
-    gem.add_dependency 'eventmachine'
-    gem.add_dependency 'thin'
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
-
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "skinny #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/*.rb')
-  rdoc.rdoc_files.include('lib/**/*.rb')
-end

data/VERSION

@@ -1 +0,0 @@
-0.1.2