websocket 1.2.3 → 1.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 48ee0f12aaa5fd6aba76f7c2070a09f600c53204
-  data.tar.gz: d011719667dc6227eecf743a764d0f24f7bf17b2
+  metadata.gz: 4bf1d6b28aadb7224c53978094d179673364550a
+  data.tar.gz: 0d376d27450259b680f585c8ff9dc56a7d3e5210
 SHA512:
-  metadata.gz: 568b9cd4986500c8c9ddf5ec2d8f90b81b654fd6b10451480209ca505be73e0d8a24b11b10040aa7bd3211c84bf6c25154482655985a117705657e75eb302e0f
-  data.tar.gz: 3c3c8d8c324b480654891f7326f1cf7153dbf3f7b4838c1b3ad2bbe670ba25c57dc2485092b049f5d5fd35b1f131a63882a46b989f684fc40a3925fc3d2024bb
+  metadata.gz: 0ab8110e8e84a36c606da58933b48b89e9df724dc145b4ac4d7cbe36f51c6c56f02ece9ad077103be2fba3d4c617c19692f0a2e1934037a39bf50bb47c81c6c1
+  data.tar.gz: 7239ff151df05fb67c67a713c6485377a1e0ab13446a945cef84497979aab255c18a09eaa794cc068da59e44d9f7f536af6d8bfe8dc75cd8fa3d70d1b9f43dcf

data/.rubocop.yml

@@ -1,3 +1,6 @@
+AllCops:
+  DisplayCopNames: true
+
 # Target: 15
 Metrics/AbcSize:
   Max: 24
@@ -5,6 +8,10 @@ Metrics/AbcSize:
     - lib/websocket/frame/handler/handler75.rb
     - spec/**/*
 
+Metrics/BlockLength:
+  Exclude:
+    - spec/**/*
+
 Metrics/ClassLength:
   Enabled: false
 

data/.travis.yml

@@ -1,12 +1,23 @@
 language: ruby
-script: "bundle exec rake spec"
+script: "bundle exec rake"
 rvm:
   - 1.9.3
   - 2.0
   - 2.1
   - 2.2
-  - rbx-2
-  - jruby-19mode
+  - 2.3
   - ruby-head
+  - jruby
+  - jruby-head
+  - rbx
+  - rbx-head
+
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+    - rvm: rbx
+    - rvm: rbx-head
+
 before_install:
   - gem install bundler

data/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 1.2.4
+
+- add subprotocol handling for both server and client
+
 ## 1.2.3
 
 - fix for draft 76 when challenge might sometimes fail

data/Gemfile

@@ -1,7 +1,3 @@
 source 'http://rubygems.org'
 
 gemspec
-
-gem 'rake'
-gem 'rspec', '~> 3.0.0'
-gem 'rspec-its'

data/README.md

@@ -3,6 +3,7 @@
 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.
 
 [![Gem Version](https://badge.fury.io/rb/websocket.svg)](http://badge.fury.io/rb/websocket)
+[![Gem Downloads](https://img.shields.io/gem/dt/websocket.svg?maxAge=2592000)](https://rubygems.org/gems/websocket)
 [![Travis CI](https://travis-ci.org/imanel/websocket-ruby.png)](http://travis-ci.org/imanel/websocket-ruby)
 [![Code Climate](https://codeclimate.com/github/imanel/websocket-ruby.png)](https://codeclimate.com/github/imanel/websocket-ruby)
 

data/Rakefile

@@ -1,14 +1,17 @@
 require 'bundler'
-Bundler::GemHelper.install_tasks
-
 require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+Bundler::GemHelper.install_tasks
 
 RSpec::Core::RakeTask.new do |t|
   t.rspec_opts = ['-c', '-f progress']
   t.pattern = 'spec/**/*_spec.rb'
 end
 
-task default: :spec
+RuboCop::RakeTask.new
+
+task default: [:spec, :rubocop]
 
 namespace :autobahn do
   desc 'Run autobahn tests for client'

data/lib/websocket/error.rb

@@ -99,6 +99,12 @@ module WebSocket
         end
       end
 
+      class UnsupportedProtocol < ::WebSocket::Error::Handshake
+        def message
+          :unsupported_protocol
+        end
+      end
+
       class InvalidStatusCode < ::WebSocket::Error::Handshake
         def message
           :invalid_status_code

data/lib/websocket/frame/base.rb

@@ -36,7 +36,7 @@ module WebSocket
 
       # Implement in submodules
       def supported_frames
-        fail NotImplementedError
+        raise NotImplementedError
       end
 
       # Recreate inspect as #to_s was overwritten
@@ -58,7 +58,7 @@ module WebSocket
                    when 4 then Handler::Handler04.new(self)
                    when 5..6 then Handler::Handler05.new(self)
                    when 7..13 then Handler::Handler07.new(self)
-                   else fail WebSocket::Error::Frame::UnknownVersion
+                   else raise WebSocket::Error::Frame::UnknownVersion
                    end
       end
     end

data/lib/websocket/frame/data.rb

@@ -16,7 +16,7 @@ module WebSocket
 
       # Extract mask from 4 first bytes according to spec
       def set_mask
-        fail WebSocket::Error::Frame::MaskTooShort if bytesize < 4
+        raise WebSocket::Error::Frame::MaskTooShort if bytesize < 4
         @masking_key = self[0..3].bytes.to_a
       end
 

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

@@ -9,13 +9,13 @@ module WebSocket
         # Convert data to raw frame ready to send to client
         # @return [String] Encoded frame
         def encode_frame
-          fail NotImplementedError
+          raise NotImplementedError
         end
 
         # Convert raw data to decoded frame
         # @return [WebSocket::Frame::Incoming] Frame if found, nil otherwise
         def decode_frame
-          fail NotImplementedError
+          raise NotImplementedError
         end
 
         private

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

@@ -13,10 +13,10 @@ module WebSocket
           pong: 3,
           text: 4,
           binary: 5
-        }
+        }.freeze
 
         # Hash of frame opcodes and it's names
-        FRAME_TYPES_INVERSE = FRAME_TYPES.invert
+        FRAME_TYPES_INVERSE = FRAME_TYPES.invert.freeze
 
         # @see WebSocket::Frame::Base#supported_frames
         def supported_frames
@@ -50,7 +50,7 @@ module WebSocket
             elsif frame_type == :continuation
               return decode_finish_continuation_frame(application_data)
             else
-              fail(WebSocket::Error::Frame::InvalidPayloadEncoding) if frame_type == :text && !application_data.valid_encoding?
+              raise(WebSocket::Error::Frame::InvalidPayloadEncoding) if frame_type == :text && !application_data.valid_encoding?
               return @frame.class.new(version: @frame.version, type: frame_type, data: application_data, decoded: true)
             end
           end
@@ -74,7 +74,7 @@ module WebSocket
         # @return [Integer] opcode or nil
         # @raise [WebSocket::Error] if frame opcode is not known
         def type_to_opcode(frame_type)
-          FRAME_TYPES[frame_type] || fail(WebSocket::Error::Frame::UnknownFrameType)
+          FRAME_TYPES[frame_type] || raise(WebSocket::Error::Frame::UnknownFrameType)
         end
 
         # Convert frame opcode to type name
@@ -82,7 +82,7 @@ module WebSocket
         # @return [Symbol] Frame type name or nil
         # @raise [WebSocket::Error] if frame type name is not known
         def opcode_to_type(opcode)
-          FRAME_TYPES_INVERSE[opcode] || fail(WebSocket::Error::Frame::UnknownOpcode)
+          FRAME_TYPES_INVERSE[opcode] || raise(WebSocket::Error::Frame::UnknownOpcode)
         end
 
         def encode_header
@@ -117,7 +117,7 @@ module WebSocket
           frame_length = header_length + payload_length
           frame_length += 4 if mask
 
-          fail(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size
+          raise(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size
 
           # Check buffer size
           return unless buffer_exists?(frame_length) # Buffer incomplete
@@ -135,13 +135,13 @@ module WebSocket
         def decode_first_byte
           first_byte = @frame.data.getbyte(0)
 
-          fail(WebSocket::Error::Frame::ReservedBitUsed) if first_byte & 0b01110000 != 0b00000000
+          raise(WebSocket::Error::Frame::ReservedBitUsed) if first_byte & 0b01110000 != 0b00000000
 
           more = ((first_byte & 0b10000000) == 0b10000000) ^ fin
           frame_type = opcode_to_type first_byte & 0b00001111
 
-          fail(WebSocket::Error::Frame::FragmentedControlFrame) if more && control_frame?(frame_type)
-          fail(WebSocket::Error::Frame::DataFrameInsteadContinuation) if data_frame?(frame_type) && !@application_data_buffer.nil?
+          raise(WebSocket::Error::Frame::FragmentedControlFrame) if more && control_frame?(frame_type)
+          raise(WebSocket::Error::Frame::DataFrameInsteadContinuation) if data_frame?(frame_type) && !@application_data_buffer.nil?
 
           [more, frame_type]
         end
@@ -152,7 +152,7 @@ module WebSocket
           mask = @frame.incoming_masking? && (second_byte & 0b10000000) == 0b10000000
           length = second_byte & 0b01111111
 
-          fail(WebSocket::Error::Frame::ControlFramePayloadTooLong) if length > 125 && control_frame?(frame_type)
+          raise(WebSocket::Error::Frame::ControlFramePayloadTooLong) if length > 125 && control_frame?(frame_type)
 
           header_length, payload_length = decode_payload_length(length)
 
@@ -202,10 +202,10 @@ module WebSocket
         end
 
         def decode_finish_continuation_frame(application_data)
-          fail(WebSocket::Error::Frame::UnexpectedContinuationFrame) unless @frame_type
+          raise(WebSocket::Error::Frame::UnexpectedContinuationFrame) unless @frame_type
           @application_data_buffer << application_data
           # Test valid UTF-8 encoding
-          fail(WebSocket::Error::Frame::InvalidPayloadEncoding) if @frame_type == :text && !@application_data_buffer.valid_encoding?
+          raise(WebSocket::Error::Frame::InvalidPayloadEncoding) if @frame_type == :text && !@application_data_buffer.valid_encoding?
           message = @frame.class.new(version: @frame.version, type: @frame_type, data: @application_data_buffer, decoded: true)
           @application_data_buffer = nil
           @frame_type = nil

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

@@ -12,15 +12,15 @@ module WebSocket
           close: 8,
           ping: 9,
           pong: 10
-        }
+        }.freeze
 
         # Hash of frame opcodes and it's names
-        FRAME_TYPES_INVERSE = FRAME_TYPES.invert
+        FRAME_TYPES_INVERSE = FRAME_TYPES.invert.freeze
 
         def encode_frame
           if @frame.type == :close
             code = @frame.code || 1000
-            fail WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(code)
+            raise WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(code)
             @frame.data = Data.new([code].pack('n') + @frame.data.to_s)
             @frame.code = nil
           end
@@ -32,8 +32,8 @@ module WebSocket
           if close_code?(result)
             code = result.data.slice!(0..1)
             result.code = code.unpack('n').first
-            fail WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(result.code)
-            fail WebSocket::Error::Frame::InvalidPayloadEncoding unless valid_encoding?(result.data)
+            raise WebSocket::Error::Frame::UnknownCloseCode unless valid_code?(result.code)
+            raise WebSocket::Error::Frame::InvalidPayloadEncoding unless valid_encoding?(result.data)
           end
           result
         end
@@ -41,7 +41,7 @@ module WebSocket
         private
 
         def valid_code?(code)
-          [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011].include?(code) || (3000..4999).include?(code)
+          [1000, 1001, 1002, 1003, 1007, 1008, 1009, 1010, 1011].include?(code) || (3000..4999).cover?(code)
         end
 
         def valid_encoding?(data)
@@ -61,7 +61,7 @@ module WebSocket
         # @return [Integer] opcode or nil
         # @raise [WebSocket::Error] if frame opcode is not known
         def type_to_opcode(frame_type)
-          FRAME_TYPES[frame_type] || fail(WebSocket::Error::Frame::UnknownFrameType)
+          FRAME_TYPES[frame_type] || raise(WebSocket::Error::Frame::UnknownFrameType)
         end
 
         # Convert frame opcode to type name
@@ -69,7 +69,7 @@ module WebSocket
         # @return [Symbol] Frame type name or nil
         # @raise [WebSocket::Error] if frame type name is not known
         def opcode_to_type(opcode)
-          FRAME_TYPES_INVERSE[opcode] || fail(WebSocket::Error::Frame::UnknownOpcode)
+          FRAME_TYPES_INVERSE[opcode] || raise(WebSocket::Error::Frame::UnknownOpcode)
         end
       end
     end

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

@@ -17,13 +17,13 @@ module WebSocket
             ary = ["\x00", @frame.data, "\xff"]
             ary.map { |s| s.encode('UTF-8', 'UTF-8', invalid: :replace) }
             ary.join
-          else fail WebSocket::Error::Frame::UnknownFrameType
+          else raise WebSocket::Error::Frame::UnknownFrameType
           end
         end
 
         # @see WebSocket::Frame::Handler::Base#decode_frame
         def decode_frame
-          return if @frame.data.size == 0
+          return if @frame.data.size.zero?
 
           pointer = 0
           frame_type = @frame.data.getbyte(pointer)
@@ -42,7 +42,7 @@ module WebSocket
               break unless (b & 0x80) == 0x80
             end
 
-            fail WebSocket::Error::Frame::TooLong if length > ::WebSocket.max_frame_size
+            raise WebSocket::Error::Frame::TooLong if length > ::WebSocket.max_frame_size
 
             unless @frame.data.getbyte(pointer + length - 1).nil?
               # Straight from spec - I'm sure this isn't crazy...
@@ -51,17 +51,17 @@ module WebSocket
               @frame.instance_variable_set '@data', @frame.data[(pointer + length)..-1]
 
               # If the /frame type/ is 0xFF and the /length/ was 0, then close
-              if length == 0
+              if length.zero?
                 @frame.class.new(version: @frame.version, type: :close, decoded: true)
               end
             end
           else
             # If the high-order bit of the /frame type/ byte is _not_ set
 
-            fail WebSocket::Error::Frame::Invalid if @frame.data.getbyte(0) != 0x00
+            raise WebSocket::Error::Frame::Invalid if @frame.data.getbyte(0) != 0x00
 
             # Addition to the spec to protect against malicious requests
-            fail WebSocket::Error::Frame::TooLong if @frame.data.size > ::WebSocket.max_frame_size
+            raise WebSocket::Error::Frame::TooLong if @frame.data.size > ::WebSocket.max_frame_size
 
             msg = @frame.data.slice!(/\A\x00[^\xff]*\xff/)
             if msg

data/lib/websocket/frame/outgoing.rb

@@ -24,7 +24,7 @@ module WebSocket
 
       # Return raw frame formatted for sending.
       def to_s
-        fail WebSocket::Error::Frame::UnknownFrameType unless supported?
+        raise WebSocket::Error::Frame::UnknownFrameType unless supported?
         @handler.encode_frame
       end
       rescue_method :to_s

data/lib/websocket/handshake/base.rb

@@ -5,7 +5,8 @@ module WebSocket
       include ExceptionHandler
 
       attr_reader :host, :port, :path, :query,
-                  :state, :version, :secure, :headers
+                  :state, :version, :secure,
+                  :headers, :protocols
 
       # Initialize new WebSocket Handshake and set it's state to :new
       def initialize(args = {})
@@ -16,6 +17,7 @@ module WebSocket
 
         @data = ''
         @headers ||= {}
+        @protocols ||= []
       end
 
       # @abstract Add data to handshake
@@ -52,7 +54,7 @@ module WebSocket
 
       # @abstract Should send data after parsing is finished?
       def should_respond?
-        fail NotImplementedError
+        raise NotImplementedError
       end
 
       # Data left from parsing. Sometimes data that doesn't belong to handshake are added - use this method to retrieve them.
@@ -104,7 +106,15 @@ module WebSocket
 
         lines.each do |line|
           h = HEADER.match(line)
-          @headers[h[1].strip.downcase] = h[2].strip if h
+          next unless h # Skip any invalid headers
+          key = h[1].strip.downcase
+          val = h[2].strip
+          # If the header is already set and refers to the websocket protocol, append the new value
+          if @headers.key?(key) && key =~ /^(sec-)?websocket-protocol$/
+            @headers[key] << ", #{val}"
+          else
+            @headers[key] = val
+          end
         end
 
         @state = :finished

data/lib/websocket/handshake/client.rb

@@ -38,16 +38,17 @@ module WebSocket
       #
       # @param [Hash] args Arguments for client
       #
-      # @option args [String]  :host Host of request. Required if no :url param was provided.
-      # @option args [String]  :origin Origin of request. Optional, should be used mostly by browsers. Default: nil
-      # @option args [String]  :path Path of request. Should start with '/'. Default: '/'
-      # @option args [Integer] :port Port of request. Default: nil
-      # @option args [String]  :query. Query for request. Should be in format "aaa=bbb&ccc=ddd"
-      # @option args [Boolean] :secure Defines protocol to use. If true then wss://, otherwise ws://. This option will not change default port - it should be handled by programmer.
-      # @option args [String]  :url URL of request. Must by in format like ws://example.com/path?query=true. Every part of this url will be overriden by more specific arguments.
-      # @option args [String]  :uri Alias to :url
-      # @option args [Integer] :version Version of WebSocket to use. Default: 13 (this is version from RFC)
-      # @option args [Hash]    :headers HTTP headers to use in the handshake
+      # @option args [String]         :host Host of request. Required if no :url param was provided.
+      # @option args [String]         :origin Origin of request. Optional, should be used mostly by browsers. Default: nil
+      # @option args [String]         :path Path of request. Should start with '/'. Default: '/'
+      # @option args [Integer]        :port Port of request. Default: nil
+      # @option args [String]         :query. Query for request. Should be in format "aaa=bbb&ccc=ddd"
+      # @option args [Boolean]        :secure Defines protocol to use. If true then wss://, otherwise ws://. This option will not change default port - it should be handled by programmer.
+      # @option args [String]         :url URL of request. Must by in format like ws://example.com/path?query=true. Every part of this url will be overriden by more specific arguments.
+      # @option args [String]         :uri Alias to :url
+      # @option args [Array<String>]  :protocols An array of supported sub-protocols
+      # @option args [Integer]        :version Version of WebSocket to use. Default: 13 (this is version from RFC)
+      # @option args [Hash]           :headers HTTP headers to use in the handshake
       #
       # @example
       #   Websocket::Handshake::Client.new(url: "ws://example.com/path?query=true")
@@ -66,7 +67,7 @@ module WebSocket
         @path = '/' if @path.nil? || @path.empty?
         @version ||= DEFAULT_VERSION
 
-        fail WebSocket::Error::Handshake::NoHostProvided unless @host
+        raise WebSocket::Error::Handshake::NoHostProvided unless @host
 
         include_version
       end
@@ -107,7 +108,7 @@ module WebSocket
                    when 1..3  then Handler::Client01.new(self)
                    when 4..10 then Handler::Client04.new(self)
                    when 11..17 then Handler::Client11.new(self)
-                   else fail WebSocket::Error::Handshake::UnknownVersion
+                   else raise WebSocket::Error::Handshake::UnknownVersion
                    end
       end
 
@@ -118,9 +119,9 @@ module WebSocket
       # @return [Boolean] True if parsed correctly. False otherwise
       def parse_first_line(line)
         line_parts = line.match(FIRST_LINE)
-        fail WebSocket::Error::Handshake::InvalidHeader unless line_parts
+        raise WebSocket::Error::Handshake::InvalidHeader unless line_parts
         status = line_parts[1]
-        fail WebSocket::Error::Handshake::InvalidStatusCode unless status == '101'
+        raise WebSocket::Error::Handshake::InvalidStatusCode unless status == '101'
       end
     end
   end

data/lib/websocket/handshake/handler/client04.rb

@@ -7,7 +7,7 @@ module WebSocket
       class Client04 < Client
         # @see WebSocket::Handshake::Base#valid?
         def valid?
-          super && verify_accept
+          super && verify_accept && verify_protocol
         end
 
         private
@@ -25,6 +25,7 @@ module WebSocket
           keys << ['Sec-WebSocket-Origin', @handshake.origin] if @handshake.origin
           keys << ['Sec-WebSocket-Version', @handshake.version]
           keys << ['Sec-WebSocket-Key', key]
+          keys << ['Sec-WebSocket-Protocol', @handshake.protocols.join(', ')] if @handshake.protocols.any?
           keys
         end
 
@@ -43,7 +44,16 @@ module WebSocket
         # Verify if received header Sec-WebSocket-Accept matches generated one.
         # @return [Boolean] True if accept is matching. False otherwise(appropriate error is set)
         def verify_accept
-          fail WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.headers['sec-websocket-accept'] == accept
+          raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.headers['sec-websocket-accept'] == accept
+          true
+        end
+
+        # Verify if received header Sec-WebSocket-Protocol matches with one of the sent ones
+        # @return [Boolean] True if matching. False otherwise(appropriate error is set)
+        def verify_protocol
+          return true if @handshake.protocols.empty?
+          protos = @handshake.headers['sec-websocket-protocol'].split(/ *, */) & @handshake.protocols
+          raise WebSocket::Error::Handshake::UnsupportedProtocol if protos.empty?
           true
         end
       end

data/lib/websocket/handshake/handler/client75.rb

@@ -2,6 +2,11 @@ module WebSocket
   module Handshake
     module Handler
       class Client75 < Client
+        # @see WebSocket::Handshake::Base#valid?
+        def valid?
+          super && verify_protocol
+        end
+
         private
 
         # @see WebSocket::Handshake::Handler::Base#handshake_keys
@@ -14,9 +19,19 @@ module WebSocket
           host += ":#{@handshake.port}" if @handshake.port
           keys << ['Host', host]
           keys << ['Origin', @handshake.origin] if @handshake.origin
+          keys << ['WebSocket-Protocol', @handshake.protocols.first] if @handshake.protocols.any?
           keys += super
           keys
         end
+
+        # Verify if received header WebSocket-Protocol matches with the sent one
+        # @return [Boolean] True if matching. False otherwise(appropriate error is set)
+        def verify_protocol
+          return true if @handshake.protocols.empty?
+          invalid = @handshake.headers['websocket-protocol'].strip != @handshake.protocols.first
+          raise WebSocket::Error::Handshake::UnsupportedProtocol if invalid
+          true
+        end
       end
     end
   end

data/lib/websocket/handshake/handler/client76.rb

@@ -6,7 +6,7 @@ module WebSocket
       class Client76 < Client75
         # @see WebSocket::Handshake::Base#valid?
         def valid?
-          super && verify_challenge
+          super && verify_challenge && verify_protocol
         end
 
         private
@@ -62,7 +62,7 @@ module WebSocket
         # Verify if challenge sent by server match generated one
         # @return [Boolena] True if challenge matches, false otherwise(sets appropriate error)
         def verify_challenge
-          fail WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.leftovers == challenge
+          raise WebSocket::Error::Handshake::InvalidAuthentication unless @handshake.leftovers == challenge
           true
         end
 
@@ -93,6 +93,15 @@ module WebSocket
         def generate_key3
           [rand(0x100000000)].pack('N') + [rand(0x100000000)].pack('N')
         end
+
+        # Verify if received header Sec-WebSocket-Protocol matches with the sent one
+        # @return [Boolean] True if matching. False otherwise(appropriate error is set)
+        def verify_protocol
+          return true if @handshake.protocols.empty?
+          invalid = @handshake.headers['sec-websocket-protocol'].strip != @handshake.protocols.first
+          raise WebSocket::Error::Handshake::UnsupportedProtocol if invalid
+          true
+        end
       end
     end
   end

data/lib/websocket/handshake/handler/server04.rb

@@ -23,7 +23,7 @@ module WebSocket
             %w(Upgrade websocket),
             %w(Connection Upgrade),
             ['Sec-WebSocket-Accept', signature]
-          ]
+          ] + protocol
         end
 
         # Signature of response, created from client request Sec-WebSocket-Key
@@ -35,13 +35,19 @@ module WebSocket
         end
 
         def verify_key
-          fail WebSocket::Error::Handshake::InvalidAuthentication unless key
+          raise WebSocket::Error::Handshake::InvalidAuthentication unless key
           true
         end
 
         def key
           @handshake.headers['sec-websocket-key']
         end
+
+        def protocol
+          return [] unless @handshake.headers.key?('sec-websocket-protocol')
+          protos = @handshake.headers['sec-websocket-protocol'].split(/ *, */) & @handshake.protocols
+          [['Sec-WebSocket-Protocol', protos.first]]
+        end
       end
     end
   end

data/lib/websocket/handshake/handler/server75.rb

@@ -16,7 +16,13 @@ module WebSocket
             %w(Connection Upgrade),
             ['WebSocket-Origin', @handshake.headers['origin']],
             ['WebSocket-Location', @handshake.uri]
-          ]
+          ] + protocol
+        end
+
+        def protocol
+          return [] unless @handshake.headers.key?('websocket-protocol')
+          proto = @handshake.headers['websocket-protocol']
+          [['WebSocket-Protocol', @handshake.protocols.include?(proto) ? proto : nil]]
         end
       end
     end

data/lib/websocket/handshake/handler/server76.rb

@@ -28,7 +28,7 @@ module WebSocket
             %w(Connection Upgrade),
             ['Sec-WebSocket-Origin', @handshake.headers['origin']],
             ['Sec-WebSocket-Location', @handshake.uri]
-          ]
+          ] + protocol
         end
 
         # @see WebSocket::Handshake::Handler::Base#finishing_line
@@ -36,8 +36,6 @@ module WebSocket
           @finishing_line ||= challenge_response
         end
 
-        private
-
         # Response to client challenge from request Sec-WebSocket-Key1, Sec-WebSocket-Key2 and leftovers
         # @return [String] Challenge response or nil if error occured
         def challenge_response
@@ -60,17 +58,23 @@ module WebSocket
 
           spaces = string.scan(/ /).size
           # As per 5.2.5, abort the connection if spaces are zero.
-          fail WebSocket::Error::Handshake::InvalidAuthentication if spaces == 0
+          raise WebSocket::Error::Handshake::InvalidAuthentication if spaces.zero?
 
           # As per 5.2.6, abort if numbers is not an integral multiple of spaces
-          fail WebSocket::Error::Handshake::InvalidAuthentication if numbers % spaces != 0
+          raise WebSocket::Error::Handshake::InvalidAuthentication if numbers % spaces != 0
 
           quotient = numbers / spaces
 
-          fail WebSocket::Error::Handshake::InvalidAuthentication if quotient > 2**32 - 1
+          raise WebSocket::Error::Handshake::InvalidAuthentication if quotient > 2**32 - 1
 
           quotient
         end
+
+        def protocol
+          return [] unless @handshake.headers.key?('sec-websocket-protocol')
+          proto = @handshake.headers['sec-websocket-protocol']
+          [['Sec-WebSocket-Protocol', @handshake.protocols.include?(proto) ? proto : nil]]
+        end
       end
     end
   end

data/lib/websocket/handshake/server.rb

@@ -35,6 +35,7 @@ module WebSocket
       # @param [Hash] args Arguments for server
       #
       # @option args [Boolean] :secure If true then server will use wss:// protocol
+      # @option args [Array<String>] :protocols an array of supported sub-protocols
       #
       # @example
       #   Websocket::Handshake::Server.new(secure: true)
@@ -70,7 +71,7 @@ module WebSocket
       # @example
       #   @handshake.from_rack(env)
       def from_rack(env)
-        @headers = env.select { |key, _value| key =~ /\AHTTP_/ }.each_with_object({}) do |tuple, memo|
+        @headers = env.select { |key, _value| key.start_with? 'HTTP_' }.each_with_object({}) do |tuple, memo|
           key, value = tuple
           memo[key.gsub(/\AHTTP_/, '').tr('_', '-').downcase] = value
         end
@@ -153,7 +154,7 @@ module WebSocket
                    when 75 then Handler::Server75.new(self)
                    when 76, 0..3 then Handler::Server76.new(self)
                    when 4..17 then Handler::Server04.new(self)
-                   else fail WebSocket::Error::Handshake::UnknownVersion
+                   else raise WebSocket::Error::Handshake::UnknownVersion
                    end
       end
 
@@ -164,9 +165,9 @@ module WebSocket
       # @return [Boolean] True if parsed correctly. False otherwise
       def parse_first_line(line)
         line_parts = line.match(PATH)
-        fail WebSocket::Error::Handshake::InvalidHeader unless line_parts
+        raise WebSocket::Error::Handshake::InvalidHeader unless line_parts
         method = line_parts[1].strip
-        fail WebSocket::Error::Handshake::GetRequestRequired unless method == 'GET'
+        raise WebSocket::Error::Handshake::GetRequestRequired unless method == 'GET'
 
         resource_name = line_parts[2].strip
         @path, @query = resource_name.split('?', 2)

data/lib/websocket/version.rb

@@ -1,3 +1,3 @@
 module WebSocket
-  VERSION = '1.2.3'
+  VERSION = '1.2.4'.freeze
 end

data/spec/frame/outgoing_03_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 RSpec.describe 'Outgoing frame draft 03' do
-  let(:version) { 03 }
+  let(:version) { 3 }
   let(:frame) { WebSocket::Frame::Outgoing.new(version: version, data: decoded_text, type: frame_type) }
   let(:decoded_text) { '' }
   let(:encoded_text) { "\x04\x00" }

data/spec/frame/outgoing_04_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 RSpec.describe 'Outgoing frame draft 04' do
-  let(:version) { 04 }
+  let(:version) { 4 }
   let(:frame) { WebSocket::Frame::Outgoing.new(version: version, data: decoded_text, type: frame_type) }
   let(:decoded_text) { '' }
   let(:encoded_text) { "\x84\x00" }

data/spec/handshake/client_04_spec.rb

@@ -17,4 +17,45 @@ RSpec.describe 'Client draft 4 handshake' do
     expect(handshake).not_to be_valid
     expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
+
+  context 'protocol header specified' do
+    let(:handshake) { WebSocket::Handshake::Client.new(uri: 'ws://example.com/demo', origin: 'http://example.com', version: version, protocols: protocols) }
+
+    context 'single protocol requested' do
+      let(:protocols) { %w(binary) }
+
+      it 'returns a valid handshake' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).to be_valid
+      end
+    end
+
+    context 'multiple protocols requested' do
+      let(:protocols) { %w(binary xmpp) }
+
+      it 'returns with a valid handshake' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).to be_valid
+      end
+    end
+
+    context 'unsupported protocol requested' do
+      let(:protocols) { %w(binary xmpp) }
+
+      it 'fails with an unsupported protocol error' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'generic' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).not_to be_valid
+        expect(handshake.error).to eql(:unsupported_protocol)
+      end
+    end
+  end
 end

data/spec/handshake/client_75_spec.rb

@@ -8,4 +8,29 @@ RSpec.describe 'Client draft 75 handshake' do
   let(:server_response) { server_handshake_75(@request_params || {}) }
 
   it_should_behave_like 'all client drafts'
+
+  context 'protocol header specified' do
+    let(:handshake) { WebSocket::Handshake::Client.new(uri: 'ws://example.com/demo', origin: 'http://example.com', version: version, protocols: %w(binary)) }
+
+    context 'supported' do
+      it 'returns a valid handshake' do
+        @request_params = { headers: { 'WebSocket-Protocol' => 'binary' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).to be_valid
+      end
+    end
+
+    context 'unsupported' do
+      it 'fails with an unsupported protocol error' do
+        @request_params = { headers: { 'WebSocket-Protocol' => 'xmpp' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).not_to be_valid
+        expect(handshake.error).to eql(:unsupported_protocol)
+      end
+    end
+  end
 end

data/spec/handshake/client_76_spec.rb

@@ -17,4 +17,29 @@ RSpec.describe 'Client draft 76 handshake' do
     expect(handshake).not_to be_valid
     expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
+
+  context 'protocol header specified' do
+    let(:handshake) { WebSocket::Handshake::Client.new(uri: 'ws://example.com/demo', origin: 'http://example.com', version: version, protocols: %w(binary)) }
+
+    context 'supported' do
+      it 'returns a valid handshake' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).to be_valid
+      end
+    end
+
+    context 'unsupported' do
+      it 'fails with an unsupported protocol error' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp' } }
+        handshake << server_response
+
+        expect(handshake).to be_finished
+        expect(handshake).not_to be_valid
+        expect(handshake.error).to eql(:unsupported_protocol)
+      end
+    end
+  end
 end

data/spec/handshake/server_04_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 RSpec.describe 'Server draft 04 handshake' do
   let(:handshake) { WebSocket::Handshake::Server.new }
-  let(:version) { 04 }
+  let(:version) { 4 }
   let(:client_request) { client_handshake_04(@request_params || {}) }
   let(:server_response) { server_handshake_04(@request_params || {}) }
 
@@ -15,4 +15,35 @@ RSpec.describe 'Server draft 04 handshake' do
     expect(handshake).not_to be_valid
     expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
+
+  context 'protocol header specified' do
+    let(:handshake) { WebSocket::Handshake::Server.new(protocols: %w(binary xmpp)) }
+
+    context 'single protocol requested' do
+      it 'returns with the same protocol' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match('Sec-WebSocket-Protocol: binary')
+      end
+    end
+
+    context 'multiple protocols requested' do
+      it 'returns with the first supported protocol' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp, binary' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match('Sec-WebSocket-Protocol: xmpp')
+      end
+    end
+
+    context 'unsupported protocol requested' do
+      it 'reutrns with an empty protocol header' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'generic' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match("Sec-WebSocket-Protocol: \r\n")
+      end
+    end
+  end
 end

data/spec/handshake/server_75_spec.rb

@@ -8,4 +8,26 @@ RSpec.describe 'Server draft 75 handshake' do
   let(:server_response) { server_handshake_75(@request_params || {}) }
 
   it_should_behave_like 'all server drafts'
+
+  context 'protocol header specified' do
+    let(:handshake) { WebSocket::Handshake::Server.new(protocols: %w(binary)) }
+
+    context 'supported' do
+      it 'returns with the same protocol' do
+        @request_params = { headers: { 'WebSocket-Protocol' => 'binary' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match('WebSocket-Protocol: binary')
+      end
+    end
+
+    context 'unsupported' do
+      it 'returns with an empty protocol header' do
+        @request_params = { headers: { 'WebSocket-Protocol' => 'xmpp' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match("WebSocket-Protocol: \r\n")
+      end
+    end
+  end
 end

data/spec/handshake/server_76_spec.rb

@@ -43,4 +43,26 @@ RSpec.describe 'Server draft 76 handshake' do
     expect(handshake).not_to be_valid
     expect(handshake.error).to eql(:invalid_handshake_authentication)
   end
+
+  context 'protocol header specified' do
+    let(:handshake) { WebSocket::Handshake::Server.new(protocols: %w(binary)) }
+
+    context 'supported' do
+      it 'returns with the same protocol' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'binary' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match('Sec-WebSocket-Protocol: binary')
+      end
+    end
+
+    context 'unsupported' do
+      it 'returns with an empty protocol header' do
+        @request_params = { headers: { 'Sec-WebSocket-Protocol' => 'xmpp' } }
+        handshake << client_request
+
+        expect(handshake.to_s).to match("Sec-WebSocket-Protocol: \r\n")
+      end
+    end
+  end
 end

data/spec/support/handshake_requests.rb

@@ -14,7 +14,7 @@ def server_handshake_75(args = {})
 HTTP/1.1 101 Web Socket Protocol Handshake\r
 Upgrade: WebSocket\r
 Connection: Upgrade\r
-WebSocket-Origin: http://example.com\r
+#{(args[:headers] || {}).map { |key, value| "#{key}: #{value}\r\n" }.join('')}WebSocket-Origin: http://example.com\r
 WebSocket-Location: ws#{args[:secure] ? 's' : ''}://#{args[:host] || 'example.com'}#{":#{args[:port]}" if args[:port]}#{args[:path] || '/demo'}\r
 \r
   EOF
@@ -40,7 +40,7 @@ def server_handshake_76(args = {})
 HTTP/1.1 101 WebSocket Protocol Handshake\r
 Upgrade: WebSocket\r
 Connection: Upgrade\r
-Sec-WebSocket-Origin: http://example.com\r
+#{(args[:headers] || {}).map { |key, value| "#{key}: #{value}\r\n" }.join('')}Sec-WebSocket-Origin: http://example.com\r
 Sec-WebSocket-Location: ws#{args[:secure] ? 's' : ''}://#{args[:host] || 'example.com'}#{":#{args[:port]}" if args[:port]}#{args[:path] || '/demo'}\r
 \r
 #{args[:challenge] || "8jKS'y:G*Co,Wxa-"}
@@ -66,7 +66,7 @@ def server_handshake_04(args = {})
 HTTP/1.1 101 Switching Protocols\r
 Upgrade: websocket\r
 Connection: Upgrade\r
-Sec-WebSocket-Accept: #{args[:accept] || 's3pPLMBiTxaQ9kYGzzhZRbK+xOo='}\r
+#{(args[:headers] || {}).map { |key, value| "#{key}: #{value}\r\n" }.join('')}Sec-WebSocket-Accept: #{args[:accept] || 's3pPLMBiTxaQ9kYGzzhZRbK+xOo='}\r
 \r
   EOF
 end

data/spec/support/incoming_frames.rb

@@ -38,19 +38,21 @@ RSpec.shared_examples_for 'valid_incoming_frame' do
     after(:each) { WebSocket.should_raise = false }
 
     it 'should have specified number of returned frames' do
-      expect do
-        decoded_text_array.each_with_index do |da, index|
-          n = subject.next
-          expect(n).not_to be_nil, "Should return frame for #{da}, #{frame_type_array[index]}"
-          expect(n.class).to eql(WebSocket::Frame::Incoming), "Should be WebSocket::Frame::Incoming, #{n} received instead"
-        end
-        expect(subject.next).to be_nil
-        if error.is_a?(Class)
-          expect(subject.error).to eql(error.new.message)
-        else
-          expect(subject.error).to eql(error)
-        end
-      end.to raise_error(error) if error
+      if error
+        expect do
+          decoded_text_array.each_with_index do |da, index|
+            n = subject.next
+            expect(n).not_to be_nil, "Should return frame for #{da}, #{frame_type_array[index]}"
+            expect(n.class).to eql(WebSocket::Frame::Incoming), "Should be WebSocket::Frame::Incoming, #{n} received instead"
+          end
+          expect(subject.next).to be_nil
+          if error.is_a?(Class)
+            expect(subject.error).to eql(error.new.message)
+          else
+            expect(subject.error).to eql(error)
+          end
+        end.to raise_error(error)
+      end
     end
   end
 end

data/websocket.gemspec

@@ -17,4 +17,9 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
   s.require_paths = ['lib']
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec-its'
+  s.add_development_dependency 'rubocop'
 end

metadata

@@ -1,15 +1,71 @@
 --- !ruby/object:Gem::Specification
 name: websocket
 version: !ruby/object:Gem::Version
-  version: 1.2.3
+  version: 1.2.4
 platform: ruby
 authors:
 - Bernard Potocki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-05 00:00:00.000000000 Z
-dependencies: []
+date: 2017-01-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  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: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  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: rubocop
+  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'
 description: Universal Ruby library to handle WebSocket protocol
 email:
 - bernard.potocki@imanel.org
@@ -109,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Universal Ruby library to handle WebSocket protocol