websocket 1.0.0

data/examples/tests/autobahn_client.rb

@@ -0,0 +1,52 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../client"
+require 'cgi'
+
+EM.epoll
+EM.run do
+
+  host   = 'ws://localhost:9001'
+  agent  = "WebSocket-Ruby (Ruby #{RUBY_VERSION})"
+  cases  = 0
+  skip   = []
+
+  ws = WebSocket::EventMachine::Client.connect(:uri => "#{host}/getCaseCount")
+
+  ws.onmessage do |msg, type|
+    puts "$ Total cases to run: #{msg}"
+    cases = msg.to_i
+  end
+
+  ws.onclose do
+
+    run_case = lambda do |n|
+
+      if n > cases
+        puts "$ Requesting report"
+        ws = WebSocket::EventMachine::Client.connect(:uri => "#{host}/updateReports?agent=#{CGI.escape agent}")
+        ws.onclose do
+          EM.stop
+        end
+
+      elsif skip.include?(n)
+        EM.next_tick { run_case.call(n+1) }
+
+      else
+        puts "$ Test number #{n}"
+        ws = WebSocket::EventMachine::Client.connect(:uri => "#{host}/runCase?case=#{n}&agent=#{CGI.escape agent}")
+
+        ws.onmessage do |msg, type|
+          puts "Received #{msg}(#{type})"
+          ws.send(msg, :type => type)
+        end
+
+        ws.onclose do |msg|
+          puts("Closing: #{msg}") if msg
+          run_case.call(n + 1)
+        end
+      end
+    end
+
+    run_case.call(1)
+  end
+
+end

data/examples/tests/echo_client.rb

@@ -0,0 +1,42 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../client"
+
+EM.epoll
+EM.run do
+
+  trap("TERM") { stop }
+  trap("INT")  { stop }
+
+  ws = WebSocket::EventMachine::Client.connect(:host => "localhost", :port => 9001);
+
+  ws.onopen do
+    puts "Connected"
+    ws.send "Hello"
+  end
+
+  ws.onmessage do |msg, type|
+    puts "Received message: #{msg}"
+    ws.send msg, :type => type
+  end
+
+  ws.onclose do
+    puts "Disconnected"
+  end
+
+  ws.onerror do |e|
+    puts "Error: #{e}"
+  end
+
+  ws.onping do |msg|
+    puts "Receied ping: #{msg}"
+  end
+
+  ws.onpong do |msg|
+    puts "Received pong: #{msg}"
+  end
+
+  def stop
+    puts "Terminating connection"
+    EventMachine.stop
+  end
+
+end

data/examples/tests/echo_server.rb

@@ -0,0 +1,45 @@
+require "#{File.expand_path(File.dirname(__FILE__))}/../server"
+
+EM.epoll
+EM.run do
+
+  trap("TERM") { stop }
+  trap("INT")  { stop }
+
+  WebSocket::EventMachine::Server.start(:host => "0.0.0.0", :port => 9001) do |ws|
+
+    ws.onopen do
+      puts "Client connected"
+    end
+
+    ws.onmessage do |msg, type|
+      puts "Received message: #{msg}"
+      ws.send msg, :type => type
+    end
+
+    ws.onclose do
+      puts "Client disconnected"
+    end
+
+    ws.onerror do |e|
+      puts "Error: #{e}"
+    end
+
+    ws.onping do |msg|
+      puts "Receied ping: #{msg}"
+    end
+
+    ws.onpong do |msg|
+      puts "Received pong: #{msg}"
+    end
+
+  end
+
+  puts "Server started at port 9001"
+
+  def stop
+    puts "Terminating WebSocket Server"
+    EventMachine.stop
+  end
+
+end

data/lib/websocket.rb

@@ -0,0 +1,16 @@
+# WebSocket protocol implementation in Ruby
+# This module does not provide a WebSocket server or client, but is made for using
+# in http servers or clients to provide WebSocket support.
+# @author Bernard "Imanel" Potocki
+# @see http://github.com/imanel/websocket-ruby main repository
+module WebSocket
+  class Error < RuntimeError; end
+
+  DEFAULT_VERSION = 13
+  ROOT = File.expand_path(File.dirname(__FILE__))
+
+  autoload :Frame,     "#{ROOT}/websocket/frame"
+  autoload :Handler,   "#{ROOT}/websocket/handler"
+  autoload :Handshake, "#{ROOT}/websocket/handshake"
+
+end

data/lib/websocket/frame.rb

@@ -0,0 +1,11 @@
+module WebSocket
+  module Frame
+
+    autoload :Base,     "#{::WebSocket::ROOT}/websocket/frame/base"
+    autoload :Data,     "#{::WebSocket::ROOT}/websocket/frame/data"
+    autoload :Handler,  "#{::WebSocket::ROOT}/websocket/frame/handler"
+    autoload :Incoming, "#{::WebSocket::ROOT}/websocket/frame/incoming"
+    autoload :Outgoing, "#{::WebSocket::ROOT}/websocket/frame/outgoing"
+
+  end
+end

data/lib/websocket/frame/base.rb

@@ -0,0 +1,45 @@
+module WebSocket
+  module Frame
+    class Base
+
+      attr_reader :data, :type, :version, :error
+
+      # Initialize frame
+      # @param args [Hash] Arguments for frame
+      # @option args [Integer] :version Version of draft. Currently supported version are 75, 76 and 00-13.
+      # @option args [String] :type Type of frame - available types are "text", "binary", "ping", "pong" and "close"(support depends on draft version)
+      # @option args [String] :data default data for frame
+      def initialize(args = {})
+        @type = args[:type]
+        @data = Data.new(args[:data].to_s)
+        @version = args[:version] || DEFAULT_VERSION
+        set_handler
+      end
+
+      # Check if some errors occured
+      # @return [Boolean] True if error is set
+      def error?
+        !!@error
+      end
+
+      private
+
+      def set_handler
+        case @version
+          when 75..76 then extend Handler::Handler75
+          when 0..2 then extend Handler::Handler75
+          when 3 then extend Handler::Handler03
+          when 4 then extend Handler::Handler04
+          when 5..6 then extend Handler::Handler05
+          when 7..13 then extend Handler::Handler07
+          else set_error(:unknown_protocol_version) and return
+        end
+      end
+
+      def set_error(message)
+        @error = message
+      end
+
+    end
+  end
+end

data/lib/websocket/frame/data.rb

@@ -0,0 +1,52 @@
+module WebSocket
+  module Frame
+    class Data < String
+
+      def initialize(*args)
+        super *args.each { |arg| arg.force_encoding('ASCII-8BIT') if respond_to?(:force_encoding) }
+      end
+
+      def <<(*args)
+        super *args.each { |arg| arg.force_encoding('ASCII-8BIT') if respond_to?(:force_encoding) }
+      end
+
+      def set_mask
+        raise "Too short" if bytesize < 4 # TODO - change
+        @masking_key = Data.new(self[0..3])
+      end
+
+      def unset_mask
+        @masking_key = nil
+      end
+
+      def getbytes(start_index, count)
+        data = ''
+        data.force_encoding('ASCII-8BIT') if data.respond_to?(:force_encoding)
+        count.times do |i|
+          data << getbyte(start_index + i)
+        end
+        data
+      end
+
+      # Required for support of Ruby 1.8
+      unless new.respond_to?(:getbyte)
+        def getbyte(index)
+          self[index]
+        end
+      end
+
+      def getbyte_with_masking(index)
+        if @masking_key
+          masked_char = getbyte_without_masking(index)
+          masked_char ? masked_char ^ @masking_key.getbyte(index % 4) : nil
+        else
+          getbyte_without_masking(index)
+        end
+      end
+
+      alias_method :getbyte_without_masking, :getbyte
+      alias_method :getbyte, :getbyte_with_masking
+
+    end
+  end
+end

data/lib/websocket/frame/handler.rb

@@ -0,0 +1,15 @@
+module WebSocket
+  module Frame
+    module Handler
+
+      autoload :Base,     "#{::WebSocket::ROOT}/websocket/frame/handler/base"
+
+      autoload :Handler03, "#{::WebSocket::ROOT}/websocket/frame/handler/handler03"
+      autoload :Handler04, "#{::WebSocket::ROOT}/websocket/frame/handler/handler04"
+      autoload :Handler05, "#{::WebSocket::ROOT}/websocket/frame/handler/handler05"
+      autoload :Handler07, "#{::WebSocket::ROOT}/websocket/frame/handler/handler07"
+      autoload :Handler75, "#{::WebSocket::ROOT}/websocket/frame/handler/handler75"
+
+    end
+  end
+end

data/lib/websocket/frame/handler/base.rb

@@ -0,0 +1,41 @@
+module WebSocket
+  module Frame
+    module Handler
+      module Base
+
+        MAX_FRAME_SIZE = 20 * 1024 * 1024 # 20MB
+
+        # Is selected type supported for selected handler?
+        def support_type?
+          supported_frames.include?(@type)
+        end
+
+        # Implement in submodules
+        def supported_frames
+          raise NotImplementedError
+        end
+
+        private
+
+        # Convert data to raw frame ready to send to client
+        def encode_frame
+          raise NotImplementedError
+        end
+
+        # Convert raw data to decoded frame
+        def decode_frame
+          raise NotImplementedError
+        end
+
+        def control_frame?(frame_type)
+          ![:text, :binary, :continuation].include?(frame_type)
+        end
+
+        def data_frame?(frame_type)
+          [:text, :binary].include?(frame_type)
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/frame/handler/handler03.rb

@@ -0,0 +1,162 @@
+# encoding: binary
+
+module WebSocket
+  module Frame
+    module Handler
+      module Handler03
+
+        include Base
+
+        def supported_frames
+          [:text, :binary, :close, :ping, :pong]
+        end
+
+        private
+
+        def encode_frame
+          frame = ''
+
+          opcode = type_to_opcode(@type)
+          byte1 = opcode | (fin ? 0b10000000 : 0b00000000) # since more, rsv1-3 are 0 and 0x80 for Draft 4
+          frame << byte1
+
+          length = @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 << @data
+          frame
+        rescue WebSocket::Error => e
+          set_error(e.message.to_sym) and return
+        end
+
+        def decode_frame
+          while @data.size > 1
+            pointer = 0
+
+            more = ((@data.getbyte(pointer) & 0b10000000) == 0b10000000) ^ fin
+
+            raise(WebSocket::Error, :reserved_bit_used) if @data.getbyte(pointer) & 0b01110000 != 0b00000000
+
+            opcode = @data.getbyte(pointer) & 0b00001111
+            frame_type = opcode_to_type(opcode)
+            pointer += 1
+
+            raise(WebSocket::Error, :fragmented_control_frame) if more && control_frame?(frame_type)
+            raise(WebSocket::Error, :data_frame_instead_continuation) if data_frame?(frame_type) && !@application_data_buffer.nil?
+
+            mask = masking? && (@data.getbyte(pointer) & 0b10000000) == 0b10000000
+            length = @data.getbyte(pointer) & 0b01111111
+
+            raise(WebSocket::Error, :control_frame_payload_too_long) if length > 125 && control_frame?(frame_type)
+
+            pointer += 1
+
+            payload_length = case length
+            when 127 # Length defined by 8 bytes
+              # Check buffer size
+              return if @data.getbyte(pointer+8-1) == nil # Buffer incomplete
+
+              # 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.getbytes(pointer+4, 4).unpack('N').first
+              pointer += 8
+              l
+            when 126 # Length defined by 2 bytes
+              # Check buffer size
+              return if @data.getbyte(pointer+2-1) == nil # Buffer incomplete
+
+              l = @data.getbytes(pointer, 2).unpack('n').first
+              pointer += 2
+              l
+            else
+              length
+            end
+
+            # Compute the expected frame length
+            frame_length = pointer + payload_length
+            frame_length += 4 if mask
+
+            raise(WebSocket::Error, :frame_too_long) if frame_length > MAX_FRAME_SIZE
+
+            # Check buffer size
+            return if @data.getbyte(frame_length-1) == nil # Buffer incomplete
+
+            # Remove frame header
+            @data.slice!(0...pointer)
+            pointer = 0
+
+            # Read application data (unmasked if required)
+            @data.set_mask if mask
+            pointer += 4 if mask
+            application_data = @data.getbytes(pointer, payload_length)
+            application_data.force_encoding('UTF-8') if application_data.respond_to?(:force_encoding)
+            pointer += payload_length
+            @data.unset_mask if mask
+
+            # Throw away data up to pointer
+            @data.slice!(0...pointer)
+
+            raise(WebSocket::Error, :unexpected_continuation_frame) if frame_type == :continuation && !@frame_type
+
+            if more
+              @application_data_buffer ||= ''
+              @application_data_buffer << application_data
+              @frame_type ||= frame_type
+            else
+              # Message is complete
+              if frame_type == :continuation
+                @application_data_buffer << application_data
+                # Test valid UTF-8 encoding
+                raise(WebSocket::Error, :invalid_payload_encoding) if @frame_type == :text && @application_data_buffer.respond_to?(:valid_encoding?) && !@application_data_buffer.valid_encoding?
+                message = self.class.new(:version => version, :type => @frame_type, :data => @application_data_buffer, :decoded => true)
+                @application_data_buffer = nil
+                @frame_type = nil
+                return message
+              else
+                raise(WebSocket::Error, :invalid_payload_encoding) if frame_type == :text && application_data.respond_to?(:valid_encoding?) && !application_data.valid_encoding?
+                return self.class.new(:version => version, :type => frame_type, :data => application_data, :decoded => true)
+              end
+            end
+          end
+          return nil
+        rescue WebSocket::Error => e
+          set_error(e.message.to_sym) and return
+        end
+
+        # This allows flipping the more bit to fin for draft 04
+        def fin; false; end
+
+        def masking?; false; end
+
+        FRAME_TYPES = {
+          :continuation => 0,
+          :close => 1,
+          :ping => 2,
+          :pong => 3,
+          :text => 4,
+          :binary => 5
+        }
+
+        FRAME_TYPES_INVERSE = FRAME_TYPES.invert
+
+        def type_to_opcode(frame_type)
+          FRAME_TYPES[frame_type] || raise(WebSocket::Error, :unknown_frame_type)
+        end
+
+        def opcode_to_type(opcode)
+          FRAME_TYPES_INVERSE[opcode] || raise(WebSocket::Error, :unknown_opcode)
+        end
+
+      end
+    end
+  end
+end