websocket 1.0.5 → 1.0.6

data/.travis.yml

@@ -10,3 +10,6 @@ rvm:
   - rbx-18mode
   - rbx-19mode
   - ree
+matrix:
+  allow_failures:
+    - rvm: 2.0.0

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.0.6
+
+- support text frame types instead of only symbol ones
+- support for sending masked frames
+
 ## 1.0.5
 
 - add support for close codes

data/README.md

@@ -1,7 +1,7 @@
 # WebSocket Ruby
 
 - Travis CI build: [![](https://travis-ci.org/imanel/websocket-ruby.png)](http://travis-ci.org/imanel/websocket-ruby)
-- Autobahn tests: [server](http://imanel.github.com/websocket-ruby/autobahn/server/), client
+- Autobahn tests: [server](http://imanel.github.com/websocket-ruby/autobahn/server/), [client](http://imanel.github.com/websocket-ruby/autobahn/client/)
 
 Universal Ruby library to handle WebSocket protocol. It focuses on providing abstraction layer over [WebSocket API](http://dev.w3.org/html5/websockets/) instead of providing server or client functionality.
 
@@ -100,9 +100,10 @@ frame.next # "Hello"
 frame.next # "world!""
 ```
 
-## Examples
+## Examples & Projects using WebSocket-Ruby
 
-For examples on how to use WebSocket Ruby see examples directory in the repository. Provided examples are fully working servers - they are passing full autobahn compatibility suit.
+- [WebSocket-EventMachine-Client](https://github.com/imanel/websocket-eventmachine-client) - client based on EventMachine
+- [WebSocket-EventMachine-Server](https://github.com/imanel/websocket-eventmachine-server) - server based on EventMachine (drop-in replacement for EM-WebSocket)
 
 ## Native extension
 

data/lib/websocket/frame/base.rb

@@ -12,7 +12,7 @@ module WebSocket
       # @option args [Integer] :code Code for close frame. Supported by drafts > 05.
       # @option args [Integer] :version Version of draft. Currently supported version are 75, 76 and 00-13.
       def initialize(args = {})
-        @type = args[:type]
+        @type = args[:type].to_sym if args[:type]
         @code = args[:code]
         @data = Data.new(args[:data].to_s)
         @version = args[:version] || DEFAULT_VERSION

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

@@ -22,19 +22,29 @@ module WebSocket
           byte1 = opcode | (fin ? 0b10000000 : 0b00000000) # since more, rsv1-3 are 0 and 0x80 for Draft 4
           frame << byte1
 
+          mask = outgoing_masking? ? 0b10000000 : 0b00000000
+
           length = @data.size
           if length <= 125
             byte2 = length # since rsv4 is 0
-            frame << byte2
+            frame << (byte2 | mask)
           elsif length < 65536 # write 2 byte length
-            frame << 126
+            frame << (126 | mask)
             frame << [length].pack('n')
           else # write 8 byte length
-            frame << 127
+            frame << (127 | mask)
             frame << [length >> 32, length & 0xFFFFFFFF].pack("NN")
           end
 
-          frame << @data
+          if outgoing_masking?
+            masking_key = [rand(256).chr, rand(256).chr, rand(256).chr, rand(256).chr].join
+            tmp_data = Data.new([masking_key, @data.to_s].join)
+            tmp_data.set_mask
+            frame << masking_key + tmp_data.getbytes(4, tmp_data.size)
+          else
+            frame << @data
+          end
+
           frame
         rescue WebSocket::Error => e
           set_error(e.message.to_sym) and return
@@ -56,7 +66,7 @@ module WebSocket
             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
+            mask = incoming_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)

data/lib/websocket/frame/incoming/client.rb

@@ -3,6 +3,16 @@ module WebSocket
     class Incoming
       class Client < Incoming
 
+        private
+
+        def incoming_masking?
+          false
+        end
+
+        def outgoing_masking?
+          masking?
+        end
+
       end
     end
   end

data/lib/websocket/frame/incoming/server.rb

@@ -3,6 +3,16 @@ module WebSocket
     class Incoming
       class Server < Incoming
 
+        private
+
+        def incoming_masking?
+          masking?
+        end
+
+        def outgoing_masking?
+          false
+        end
+
       end
     end
   end

data/lib/websocket/frame/outgoing/client.rb

@@ -3,6 +3,16 @@ module WebSocket
     class Outgoing
       class Client < Outgoing
 
+        private
+
+        def incoming_masking?
+          false
+        end
+
+        def outgoing_masking?
+          masking?
+        end
+
       end
     end
   end

data/lib/websocket/frame/outgoing/server.rb

@@ -3,6 +3,16 @@ module WebSocket
     class Outgoing
       class Server < Outgoing
 
+        private
+
+        def incoming_masking?
+          masking?
+        end
+
+        def outgoing_masking?
+          false
+        end
+
       end
     end
   end

data/lib/websocket/version.rb

@@ -1,3 +1,3 @@
 module WebSocket
-  VERSION = '1.0.5'
+  VERSION = '1.0.6'
 end

data/spec/frame/masking_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe 'Masking frame draft 07' do
+  it "should encode and decode masked frame correctly" do
+    outgoing_frame = WebSocket::Frame::Outgoing::Client.new(:data => "Hello World", :type => "text")
+    outgoing_frame.to_s
+    outgoing_frame.error.should be_nil
+    incoming_frame = WebSocket::Frame::Incoming::Server.new(:data => outgoing_frame.to_s).next
+    incoming_frame.should_not be_nil
+    incoming_frame.class.should eql(WebSocket::Frame::Incoming::Server)
+    incoming_frame.error.should be_nil
+    incoming_frame.decoded?.should be_true
+    incoming_frame.to_s.should eql('Hello World')
+  end
+end

data/spec/support/frames_base.rb

@@ -0,0 +1,17 @@
+module WebSocket
+  module Frame
+    class Base
+
+      private
+
+      def incoming_masking?
+        masking?
+      end
+
+      def outgoing_masking?
+        false
+      end
+
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: websocket
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.0.6
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-19 00:00:00.000000000 Z
+date: 2012-12-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -40,15 +40,6 @@ files:
 - Gemfile
 - README.md
 - Rakefile
-- autobahn-client.json
-- autobahn-server.json
-- examples/base.rb
-- examples/client.rb
-- examples/server.rb
-- examples/tests/autobahn_client.rb
-- examples/tests/autobahn_server.rb
-- examples/tests/echo_client.rb
-- examples/tests/echo_server.rb
 - lib/websocket.rb
 - lib/websocket/frame.rb
 - lib/websocket/frame/base.rb
@@ -88,6 +79,7 @@ files:
 - spec/frame/incoming_07_spec.rb
 - spec/frame/incoming_75_spec.rb
 - spec/frame/incoming_common_spec.rb
+- spec/frame/masking_spec.rb
 - spec/frame/outgoing_03_spec.rb
 - spec/frame/outgoing_04_spec.rb
 - spec/frame/outgoing_05_spec.rb
@@ -103,6 +95,7 @@ files:
 - spec/spec_helper.rb
 - spec/support/all_client_drafts.rb
 - spec/support/all_server_drafts.rb
+- spec/support/frames_base.rb
 - spec/support/handshake_requests.rb
 - spec/support/incoming_frames.rb
 - spec/support/outgoing_frames.rb
@@ -138,6 +131,7 @@ test_files:
 - spec/frame/incoming_07_spec.rb
 - spec/frame/incoming_75_spec.rb
 - spec/frame/incoming_common_spec.rb
+- spec/frame/masking_spec.rb
 - spec/frame/outgoing_03_spec.rb
 - spec/frame/outgoing_04_spec.rb
 - spec/frame/outgoing_05_spec.rb
@@ -153,6 +147,7 @@ test_files:
 - spec/spec_helper.rb
 - spec/support/all_client_drafts.rb
 - spec/support/all_server_drafts.rb
+- spec/support/frames_base.rb
 - spec/support/handshake_requests.rb
 - spec/support/incoming_frames.rb
 - spec/support/outgoing_frames.rb

data/autobahn-client.json

@@ -1,11 +0,0 @@
-{
-   "url": "ws://127.0.0.1:9001",
-
-   "options": {"failByDrop": false},
-   "outdir": "./autobahn/client",
-   "webport": 8080,
-
-   "cases": ["1.1.1"],
-   "exclude-cases": [],
-   "exclude-agent-cases": {}
-}

data/autobahn-server.json

@@ -1,15 +0,0 @@
-{
-  "options": {"failByDrop": false},
-  "outdir": "./autobahn/server",
-
-  "servers": [
-    {"agent": "WebSocket-Ruby<br>(1.0.4 Pure)", "url": "ws://localhost:9001", "options": {"version": 18}},
-    {"agent": "WebSocket-Ruby<br>(1.0.4 Native)", "url": "ws://localhost:9002", "options": {"version": 18}},
-    {"agent": "Faye-WebSocket<br>(0.4.6 Thin)", "url": "ws://localhost:7000", "options": {"version": 18}},
-    {"agent": "EM-WebSocket<br>(0.3.8)", "url": "ws://localhost:8080", "options": {"version": 18}}
-  ],
-
-  "cases": ["*"],
-  "exclude-cases": [],
-  "exclude-agent-cases": {}
-}

data/examples/base.rb

@@ -1,162 +0,0 @@
-require 'rubygems'
-require 'eventmachine'
-require "#{File.expand_path(File.dirname(__FILE__))}/../lib/websocket"
-
-module WebSocket
-  module EventMachine
-    class Base < ::EventMachine::Connection
-
-      ###########
-      ### API ###
-      ###########
-
-      def onopen(&blk);     @onopen = blk;    end # Called when connection is opened
-      def onclose(&blk);    @onclose = blk;   end # Called when connection is closed
-      def onerror(&blk);    @onerror = blk;   end # Called when error occurs
-      def onmessage(&blk);  @onmessage = blk; end # Called when message is received from server
-      def onping(&blk);     @onping = blk;    end # Called when ping message is received from server
-      def onpong(&blk);     @onpong = blk;    end # Called when pond message is received from server
-
-      # Send data to client
-      # @param data [String] Data to send
-      # @param args [Hash] Arguments for send
-      # @option args [String] :type Type of frame to send - available types are "text", "binary", "ping", "pong" and "close"
-      # @return [Boolean] true if data was send, otherwise call on_error if needed
-      def send(data, args = {})
-        type = args[:type] || :text
-        unless type == :plain
-          frame = outgoing_frame.new(:version => @handshake.version, :data => data, :type => type)
-          if !frame.supported?
-            trigger_onerror("Frame type '#{type}' is not supported in protocol version #{@handshake.version}")
-            return false
-          elsif !frame.require_sending?
-            return false
-          end
-          data = frame.to_s
-        end
-        # debug "Sending raw: ", data
-        send_data(data)
-        true
-      end
-
-      # Close connection
-      # @return [Boolean] true if connection is closed immediately, false if waiting for server to close connection
-      def close
-        if @state == :open
-          @state = :closing
-          return false if send('', :type => :close)
-        else
-          send('', :type => :close) if @state == :closing
-          @state = :closed
-        end
-        close_connection_after_writing
-        true
-      end
-
-      # Send ping message to client
-      # @return [Boolean] false if protocol version is not supporting ping requests
-      def ping(data = '')
-        send(data, :type => :ping)
-      end
-
-      # Send pong message to client
-      # @return [Boolean] false if protocol version is not supporting pong requests
-      def pong(data = '')
-        send(data, :type => :pong)
-      end
-
-      ############################
-      ### EventMachine methods ###
-      ############################
-
-      def receive_data(data)
-        # debug "Received raw: ", data
-        case @state
-        when :connecting then handle_connecting(data)
-        when :open then handle_open(data)
-        when :closing then handle_closing(data)
-        end
-      end
-
-      def unbind
-        unless @state == :closed
-          @state = :closed
-          close
-          trigger_onclose('')
-        end
-      end
-
-      #######################
-      ### Private methods ###
-      #######################
-
-      private
-
-      ['onopen'].each do |m|
-        define_method "trigger_#{m}" do
-          callback = instance_variable_get("@#{m}")
-          callback.call if callback
-        end
-      end
-
-      ['onerror', 'onping', 'onpong', 'onclose'].each do |m|
-        define_method "trigger_#{m}" do |data|
-          callback = instance_variable_get("@#{m}")
-          callback.call(data) if callback
-        end
-      end
-
-      def trigger_onmessage(data, type)
-        @onmessage.call(data, type) if @onmessage
-      end
-
-      def handle_connecting(data)
-        @handshake << data
-        return unless @handshake.finished?
-        if @handshake.valid?
-          send(@handshake.to_s, :type => :plain) if @handshake.should_respond?
-          @frame = incoming_frame.new(:version => @handshake.version)
-          @state = :open
-          trigger_onopen
-          handle_open(@handshake.leftovers) if @handshake.leftovers
-        else
-          trigger_onerror(@handshake.error)
-          close
-        end
-      end
-
-      def handle_open(data)
-        @frame << data
-        while frame = @frame.next
-          case frame.type
-          when :close
-            @state = :closing
-            close
-            trigger_onclose(frame.to_s)
-          when :ping
-            pong(frame.to_s)
-            trigger_onping(frame.to_s)
-          when :pong
-            trigger_onpong(frame.to_s)
-          when :text
-            trigger_onmessage(frame.to_s, :text)
-          when :binary
-            trigger_onmessage(frame.to_s, :binary)
-          end
-        end
-        unbind if @frame.error?
-      end
-
-      def handle_closing(data)
-        @state = :closed
-        close
-        trigger_onclose
-      end
-
-      def debug(description, data)
-        puts(description + data.bytes.to_a.collect{|b| '\x' + b.to_s(16).rjust(2, '0')}.join) unless @state == :connecting
-      end
-
-    end
-  end
-end

data/examples/client.rb

@@ -1,70 +0,0 @@
-require "#{File.expand_path(File.dirname(__FILE__))}/base"
-require 'uri'
-
-# Example WebSocket Client (using EventMachine)
-# @example
-#   ws = WebSocket::EventMachine::Client.connect(:host => "0.0.0.0", :port => 8080)
-#   ws.onmessage { |msg| ws.send "Pong: #{msg}" }
-#   ws.send "data"
-module WebSocket
-  module EventMachine
-    class Client < Base
-
-      # Connect to websocket server
-      # @param args [Hash] The request arguments
-      # @option args [String] :host The host IP/DNS name
-      # @option args [Integer] :port The port to connect too(default = 80)
-      # @option args [Integer] :version Version of protocol to use(default = 13)
-      def self.connect(args = {})
-        host = nil
-        port = nil
-        if args[:uri]
-          uri = URI.parse(args[:uri])
-          host = uri.host
-          port = uri.port
-        end
-        host = args[:host] if args[:host]
-        port = args[:port] if args[:port]
-        port ||= 80
-
-        ::EventMachine.connect host, port, self, args
-      end
-
-      # Initialize connection
-      # @param args [Hash] Arguments for connection
-      # @option args [String] :host The host IP/DNS name
-      # @option args [Integer] :port The port to connect too(default = 80)
-      # @option args [Integer] :version Version of protocol to use(default = 13)
-      def initialize(args)
-        @args = args
-      end
-
-      ############################
-      ### EventMachine methods ###
-      ############################
-
-      # Called after initialize of connection, but before connecting to server
-      def post_init
-        @state = :connecting
-        @handshake = WebSocket::Handshake::Client.new(@args)
-      end
-
-      # Called by EventMachine after connecting.
-      # Sends handshake to server
-      def connection_completed
-        send(@handshake.to_s, :type => :plain)
-      end
-
-      private
-
-      def incoming_frame
-        WebSocket::Frame::Incoming::Client
-      end
-
-      def outgoing_frame
-        WebSocket::Frame::Outgoing::Client
-      end
-
-    end
-  end
-end

data/examples/server.rb

@@ -1,56 +0,0 @@
-require "#{File.expand_path(File.dirname(__FILE__))}/base"
-
-# Example WebSocket Server (using EventMachine)
-# @example
-#   WebSocket::EventMachine::Server.start(:host => "0.0.0.0", :port => 8080) do |ws|
-#     ws.onopen    { ws.send "Hello Client!"}
-#     ws.onmessage { |msg| ws.send "Pong: #{msg}" }
-#     ws.onclose   { puts "WebSocket closed" }
-#     ws.onerror   { |e| puts "Error: #{e}" }
-#   end
-module WebSocket
-  module EventMachine
-    class Server < Base
-
-      # Start server
-      # @param options [Hash] The request arguments
-      # @option args [String] :host The host IP/DNS name
-      # @option args [Integer] :port The port to connect too(default = 80)
-      def self.start(options, &block)
-        ::EventMachine::start_server(options[:host], options[:port], self, options) do |c|
-          block.call(c)
-        end
-      end
-
-      # Initialize connection
-      # @param args [Hash] Arguments for server
-      # @option args [Boolean] :secure If true then server will run over SSL
-      # @option args [Hash] :tls_options Options for SSL if secure = true
-      def initialize(args)
-        @secure = args[:secure] || false
-        @tls_options = args[:tls_options] || {}
-      end
-
-      ############################
-      ### Eventmachine methods ###
-      ############################
-
-      def post_init
-        @state = :connecting
-        @handshake = WebSocket::Handshake::Server.new(:secure => @secure)
-        start_tls(@tls_options) if @secure
-      end
-
-      private
-
-      def incoming_frame
-        WebSocket::Frame::Incoming::Server
-      end
-
-      def outgoing_frame
-        WebSocket::Frame::Outgoing::Server
-      end
-
-    end
-  end
-end

data/examples/tests/autobahn_client.rb

@@ -1,52 +0,0 @@
-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/autobahn_server.rb

@@ -1,24 +0,0 @@
-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.onmessage do |msg, type|
-      ws.send msg, :type => type
-    end
-
-  end
-
-  puts "Server started at port 9001"
-
-  def stop
-    puts "Terminating WebSocket Server"
-    EventMachine.stop
-  end
-
-end

data/examples/tests/echo_client.rb

@@ -1,42 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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