em-websocket 0.1.4 → 0.2.0

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/README.md

@@ -0,0 +1,76 @@
+# EM-WebSocket
+
+EventMachine based, async, Ruby WebSocket server. Take a look at examples directory, or check out the blog post below:
+
+* [Ruby & Websockets: TCP for the Web](http://www.igvita.com/2009/12/22/ruby-websockets-tcp-for-the-browser/)
+
+## Simple server example
+
+    EventMachine.run {
+
+        EventMachine::WebSocket.start(:host => "0.0.0.0", :port => 8080) do |ws|
+            ws.onopen {
+              puts "WebSocket connection open"
+
+              # publish message to the client
+              ws.send "Hello Client"
+            }
+
+            ws.onclose { puts "Connection closed" }
+            ws.onmessage { |msg|
+              puts "Recieved message: #{msg}"
+              ws.send "Pong: #{msg}"
+            }
+        end
+    }
+
+## Secure server
+
+It is possible to accept secure wss:// connections by passing :secure => true when opening the connection. Safari 5 does not currently support prompting on untrusted SSL certificates therefore using signed certificates is highly recommended. Pass a :tls_options hash containing keys as described in http://eventmachine.rubyforge.org/EventMachine/Connection.html#M000296
+
+For example,
+
+    EventMachine::WebSocket.start({
+        :host => "0.0.0.0",
+        :port => 443
+        :secure => true,
+        :tls_options => {
+          :private_key_file => "/private/key",
+          :cert_chain_file => "/ssl/certificate"
+        }
+    }) do |ws|
+    ...
+    end
+
+## Examples & Projects using em-websocket
+
+* [Pusher](http://pusherapp.com) - Realtime client push
+* [Livereload](https://github.com/mockko/livereload) - LiveReload applies CSS/JS changes to Safari or Chrome w/o reloading
+* [Twitter AMQP WebSocket Example](http://github.com/rubenfonseca/twitter-amqp-websocket-example)
+* examples/multicast.rb - broadcast all ruby tweets to all subscribers
+* examples/echo.rb - server <> client exchange via a websocket
+
+# License
+
+(The MIT License)
+
+Copyright (c) 2009 Ilya Grigorik
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,31 +1,9 @@
-require 'rake'
-require 'spec/rake/spectask'
+require 'bundler'
+Bundler::GemHelper.install_tasks
 
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gemspec|
-    gemspec.name = "em-websocket"
-    gemspec.summary = "EventMachine based WebSocket server"
-    gemspec.description = gemspec.summary
-    gemspec.email = "ilya@igvita.com"
-    gemspec.homepage = "http://github.com/igrigorik/em-websocket"
-    gemspec.authors = ["Ilya Grigorik"]
-    gemspec.add_dependency("eventmachine", ">= 0.12.9")
-    gemspec.add_dependency("addressable", '>= 2.1.1')
-    gemspec.add_development_dependency('em-http-request', '>= 0.2.6')
-    gemspec.rubyforge_project = "em-websocket"
-  end
+require 'rspec/core/rake_task'
 
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install jeweler -s http://gemcutter.org"
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = ["-c", "-f progress", "-r ./spec/helper.rb"]
+  t.pattern = 'spec/**/*_spec.rb'
 end
-
-task :default => :spec
-
-Spec::Rake::SpecTask.new do |t|
-  t.ruby_opts = ['-rtest/unit']
-  t.spec_files = FileList['spec/**/*_spec.rb']
-end
-
-

data/lib/em-websocket.rb

@@ -1,8 +1,12 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
 
-#require "rubygems"
 require "eventmachine"
 
-%w[ debugger websocket connection handler_factory handler handler75 handler76 ].each do |file|
+%w[
+  debugger websocket connection
+  handshake75 handshake76
+  framing76 framing03
+  handler_factory handler handler75 handler76 handler03
+].each do |file|
   require "em-websocket/#{file}"
 end

data/lib/em-websocket/connection.rb

@@ -5,30 +5,45 @@ module EventMachine
     class Connection < EventMachine::Connection
       include Debugger
 
-      attr_reader :state, :request
-
-      # Set the max frame lenth to very high value (10MB) until there is a
-      # limit specified in the spec to protect against malicious attacks
-      MAXIMUM_FRAME_LENGTH = 10 * 1024 * 1024
-
       # define WebSocket callbacks
       def onopen(&blk);     @onopen = blk;    end
       def onclose(&blk);    @onclose = blk;   end
       def onerror(&blk);    @onerror = blk;   end
       def onmessage(&blk);  @onmessage = blk; end
 
+      def trigger_on_message(msg)
+        @onmessage.call(msg) if @onmessage
+      end
+      def trigger_on_open
+        @onopen.call if @onopen
+      end
+      def trigger_on_close
+        @onclose.call if @onclose
+      end
+
       def initialize(options)
         @options = options
         @debug = options[:debug] || false
         @secure = options[:secure] || false
         @tls_options = options[:tls_options] || {}
-        @state = :handshake
         @request = {}
         @data = ''
 
         debug [:initialize]
       end
 
+      # Use this method to close the websocket connection cleanly
+      # This sends a close frame and waits for acknowlegement before closing
+      # the connection
+      def close_websocket
+        if @handler
+          @handler.close_websocket
+        else
+          # The handshake hasn't completed - should be safe to terminate
+          close_connection
+        end
+      end
+
       def post_init
         start_tls(@tls_options) if @secure
       end
@@ -36,41 +51,34 @@ module EventMachine
       def receive_data(data)
         debug [:receive_data, data]
 
-        @data << data
-        dispatch
+        if @handler
+          @handler.receive_data(data)
+        else
+          dispatch(data)
+        end
       end
 
       def unbind
         debug [:unbind, :connection]
 
-        @state = :closed
-        @onclose.call if @onclose
-      end
-
-      def dispatch
-        case @state
-          when :handshake
-            handshake
-          when :connected
-            process_message
-          else raise WebSocketError, "invalid state: #{@state}"
-        end
+        @handler.unbind if @handler
       end
 
-      def handshake
-        if @data.match(/<policy-file-request\s*\/>/)
+      def dispatch(data)
+        if data.match(/\A<policy-file-request\s*\/>/)
           send_flash_cross_domain_file
           return false
         else
-          debug [:inbound_headers, @data]
+          debug [:inbound_headers, data]
           begin
-            @handler = HandlerFactory.build(@data, @secure, @debug)
-            @data = ''
-            send_data @handler.handshake
-
-            @request = @handler.request
-            @state = :connected
-            @onopen.call if @onopen
+            @data << data
+            @handler = HandlerFactory.build(self, @data, @secure, @debug)
+            unless @handler
+              # The whole header has not been received yet.
+              return false
+            end
+            @data = nil
+            @handler.run
             return true
           rescue => e
             debug [:error, e]
@@ -97,95 +105,28 @@ module EventMachine
         close_connection_after_writing
       end
 
-      def process_message
-        debug [:message, @data]
-
-        # This algorithm comes straight from the spec
-        # http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76#section-4.2
-
-        error = false
-
-        while !error
-          pointer = 0
-          frame_type = @data[pointer].to_i
-          pointer += 1
-
-          if (frame_type & 0x80) == 0x80
-            # If the high-order bit of the /frame type/ byte is set
-            length = 0
-
-            loop do
-              b = @data[pointer].to_i
-              return false unless b
-              pointer += 1
-              b_v = b & 0x7F
-              length = length * 128 + b_v
-              break unless (b & 0x80) == 0x80
-            end
-
-            # Addition to the spec to protect against malicious requests
-            if length > MAXIMUM_FRAME_LENGTH
-              close_with_error(DataError.new("Frame length too long (#{length} bytes)"))
-              return false
-            end
-
-            if @data[pointer+length-1] == nil
-              debug [:buffer_incomplete, @data.inspect]
-              # Incomplete data - leave @data to accumulate
-              error = true
-            else
-              # Straight from spec - I'm sure this isn't crazy...
-              # 6. Read /length/ bytes.
-              # 7. Discard the read bytes.
-              @data = @data[(pointer+length)..-1]
-
-              # If the /frame type/ is 0xFF and the /length/ was 0, then close
-              if length == 0
-                send_data("\xff\x00")
-                @state = :closing
-                close_connection_after_writing
-              else
-                error = true
-              end
-            end
-          else
-            # If the high-order bit of the /frame type/ byte is _not_ set
-            msg = @data.slice!(/^\x00([^\xff]*)\xff/)
-            if msg
-              msg.gsub!(/\A\x00|\xff\z/, '')
-              if @state == :closing
-                debug [:ignored_message, msg]
-              else
-                msg.force_encoding('UTF-8') if msg.respond_to?(:force_encoding)
-                @onmessage.call(msg) if @onmessage
-              end
-            else
-              error = true
-            end
-          end
-        end
-
-        false
-      end
-
-      # should only be invoked after handshake, otherwise it
-      # will inject data into the header exchange
-      #
-      # frames need to start with 0x00-0x7f byte and end with
-      # an 0xFF byte. Per spec, we can also set the first
-      # byte to a value betweent 0x80 and 0xFF, followed by
-      # a leading length indicator
       def send(data)
         debug [:send, data]
-        ary = ["\x00", data, "\xff"]
-        ary.collect{ |s| s.force_encoding('UTF-8') if s.respond_to?(:force_encoding) }
-        send_data(ary.join)
+
+        if @handler
+          @handler.send_text_frame(data)
+        else
+          raise WebSocketError, "Cannot send data before onopen callback"
+        end
       end
 
       def close_with_error(message)
         @onerror.call(message) if @onerror
         close_connection_after_writing
       end
+
+      def request
+        @handler ? @handler.request : {}
+      end
+
+      def state
+        @handler ? @handler.state : :handshake
+      end
     end
   end
 end

data/lib/em-websocket/framing03.rb

@@ -0,0 +1,176 @@
+module EventMachine
+  module WebSocket
+    module Framing03
+      
+      def initialize_framing
+        @data = ''
+        @application_data_buffer = '' # Used for MORE frames
+      end
+      
+      def process_data
+        error = false
+
+        while !error && @data.size > 1
+          pointer = 0
+
+          more = (@data[pointer] & 0b10000000) == 0b10000000
+          # Ignoring rsv1-3 for now
+          opcode = @data[0] & 0b00001111
+          pointer += 1
+
+          # Ignoring rsv4
+          length = @data[pointer] & 0b01111111
+          pointer += 1
+
+          payload_length = case length
+          when 127 # Length defined by 8 bytes
+            # Check buffer size
+            if @data[pointer+8-1] == nil
+              debug [:buffer_incomplete, @data.inspect]
+              error = true
+              next
+            end
+            
+            # Only using the last 4 bytes for now, till I work out how to
+            # unpack 8 bytes. I'm sure 4GB frames will do for now :)
+            l = @data[(pointer+4)..(pointer+7)].unpack('N').first
+            pointer += 8
+            l
+          when 126 # Length defined by 2 bytes
+            # Check buffer size
+            if @data[pointer+2-1] == nil
+              debug [:buffer_incomplete, @data.inspect]
+              error = true
+              next
+            end
+            
+            l = @data[pointer..(pointer+1)].unpack('n').first
+            pointer += 2
+            l
+          else
+            length
+          end
+
+          # Check buffer size
+          if @data[pointer+payload_length-1] == nil
+            debug [:buffer_incomplete, @data.inspect]
+            error = true
+            next
+          end
+
+          # Throw away data up to pointer
+          @data.slice!(0...pointer)
+
+          # Read application data
+          application_data = @data.slice!(0...payload_length)
+
+          frame_type = opcode_to_type(opcode)
+
+          if frame_type == :continuation && !@frame_type
+            raise WebSocketError, 'Continuation frame not expected'
+          end
+
+          if more
+            debug [:moreframe, frame_type, application_data]
+            @application_data_buffer << application_data
+            @frame_type = frame_type
+          else
+            # Message is complete
+            if frame_type == :continuation
+              @application_data_buffer << application_data
+              message(@frame_type, '', @application_data_buffer)
+              @application_data_buffer = ''
+              @frame_type = nil
+            else
+              message(frame_type, '', application_data)
+            end
+          end
+        end # end while
+      end
+      
+      def send_frame(frame_type, application_data)
+        if @state == :closing && data_frame?(frame_type)
+          raise WebSocketError, "Cannot send data frame since connection is closing"
+        end
+
+        frame = ''
+
+        opcode = type_to_opcode(frame_type)
+        byte1 = opcode # since more, rsv1-3 are 0
+        frame << byte1
+
+        length = application_data.size
+        if length <= 125
+          byte2 = length # since rsv4 is 0
+          frame << byte2
+        elsif length < 65536 # write 2 byte length
+          frame << 126
+          frame << [length].pack('n')
+        else # write 8 byte length
+          frame << 127
+          frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
+        end
+
+        frame << application_data
+
+        @connection.send_data(frame)
+      end
+
+      def send_text_frame(data)
+        send_frame(:text, data)
+      end
+
+      private
+
+      def message(message_type, extension_data, application_data)
+        case message_type
+        when :close
+          if @state == :closing
+            # TODO: Check that message body matches sent data
+            # We can close connection immediately since there is no more data
+            # is allowed to be sent or received on this connection
+            @connection.close_connection
+            @state = :closed
+          else
+            # Acknowlege close
+            # The connection is considered closed
+            send_frame(:close, application_data)
+            @state = :closed
+            @connection.close_connection_after_writing
+          end
+        when :ping
+          # Pong back the same data
+          send_frame(:pong, application_data)
+        when :pong
+          # TODO: Do something. Complete a deferrable established by a ping?
+        when :text, :binary
+          @connection.trigger_on_message(application_data)
+        end
+      end
+
+      FRAME_TYPES = {
+        :continuation => 0,
+        :close => 1,
+        :ping => 2,
+        :pong => 3,
+        :text => 4,
+        :binary => 5
+      }
+      FRAME_TYPES_INVERSE = FRAME_TYPES.invert
+      # Frames are either data frames or control frames
+      DATA_FRAMES = [:text, :binary, :continuation]
+
+      def type_to_opcode(frame_type)
+        FRAME_TYPES[frame_type] || raise("Unknown frame type")
+      end
+
+      def opcode_to_type(opcode)
+        FRAME_TYPES_INVERSE[opcode] || raise("Unknown opcode")
+      end
+
+      def data_frame?(type)
+        DATA_FRAMES.include?(type)
+      end
+    end
+  end
+end