websocket 1.2.2 → 1.2.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7ca690c7a42466b8cb035271b77010bdc7bf8a19
-  data.tar.gz: 206ca9afa7b5606cb08b85ef66a8f186342d37b3
+  metadata.gz: 48ee0f12aaa5fd6aba76f7c2070a09f600c53204
+  data.tar.gz: d011719667dc6227eecf743a764d0f24f7bf17b2
 SHA512:
-  metadata.gz: 6b846fa2663e5f85415adc35e2aa39e0e7b21f844b444546c432a6b630c79d4aa4aabf5dbaf996c6334b80e1296b81a35a0935a51a9d0cfa55d6a748fb1762b7
-  data.tar.gz: cbf090a638401a094b7432f7a634ba7bc2f8fcd77b06e0407a8d2490f3236858368d619a6acf17296a715824c239b1c51beb5577597af91133e6c6472338c659
+  metadata.gz: 568b9cd4986500c8c9ddf5ec2d8f90b81b654fd6b10451480209ca505be73e0d8a24b11b10040aa7bd3211c84bf6c25154482655985a117705657e75eb302e0f
+  data.tar.gz: 3c3c8d8c324b480654891f7326f1cf7153dbf3f7b4838c1b3ad2bbe670ba25c57dc2485092b049f5d5fd35b1f131a63882a46b989f684fc40a3925fc3d2024bb

data/.rubocop.yml

@@ -0,0 +1,37 @@
+# Target: 15
+Metrics/AbcSize:
+  Max: 24
+  Exclude:
+    - lib/websocket/frame/handler/handler75.rb
+    - spec/**/*
+
+Metrics/ClassLength:
+  Enabled: false
+
+# Target: 6
+Metrics/CyclomaticComplexity:
+  Max: 11
+  Exclude:
+    - spec/support/handshake_requests.rb
+
+Metrics/LineLength:
+  Enabled: false
+
+# Target: 10
+Metrics/MethodLength:
+  Max: 18
+  Exclude:
+    - lib/websocket/frame/handler/handler75.rb
+
+# Target: 7
+Metrics/PerceivedComplexity:
+  Max: 8
+  Exclude:
+    - lib/websocket/frame/handler/handler75.rb
+    - spec/support/handshake_requests.rb
+
+Style/Documentation:
+  Enabled: false
+
+Style/TrivialAccessors:
+  AllowPredicates: true

data/.travis.yml

@@ -8,3 +8,5 @@ rvm:
   - rbx-2
   - jruby-19mode
   - ruby-head
+before_install:
+  - gem install bundler

data/CHANGELOG.md

@@ -1,5 +1,10 @@
 # Changelog
 
+## 1.2.3
+
+- fix for draft 76 when challenge might sometimes fail
+- multiple small optimizations
+
 ## 1.2.2
 
 - fix handshake for draft 11+ sending Sec-WebSocket-Origin instead of Origin

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source 'http://rubygems.org'
 
 gemspec
 

data/Rakefile

@@ -4,19 +4,19 @@ Bundler::GemHelper.install_tasks
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new do |t|
-  t.rspec_opts = ["-c", "-f progress"]
+  t.rspec_opts = ['-c', '-f progress']
   t.pattern = 'spec/**/*_spec.rb'
 end
 
 task default: :spec
 
 namespace :autobahn do
-  desc "Run autobahn tests for client"
+  desc 'Run autobahn tests for client'
   task :client do
     system('wstest --mode=fuzzingserver --spec=autobahn-client.json')
   end
 
-  desc "Run autobahn tests for server"
+  desc 'Run autobahn tests for server'
   task :server do
     system('wstest --mode=fuzzingclient --spec=autobahn-server.json')
   end

data/lib/websocket.rb

@@ -4,7 +4,6 @@
 # @author Bernard "Imanel" Potocki
 # @see http://github.com/imanel/websocket-ruby main repository
 module WebSocket
-
   # Default WebSocket version to use
   DEFAULT_VERSION = 13
   ROOT = File.expand_path(File.dirname(__FILE__))
@@ -34,11 +33,11 @@ module WebSocket
   def self.should_raise=(val)
     @should_raise = val
   end
-
 end
 
 # Try loading websocket-native if available
 begin
   require 'websocket-native'
-rescue LoadError
+rescue LoadError => e
+  raise unless e.message =~ /websocket-native/
 end

data/lib/websocket/error.rb

@@ -1,89 +1,121 @@
 module WebSocket
   class Error < RuntimeError
-
     class Frame < ::WebSocket::Error
-
       class ControlFramePayloadTooLong < ::WebSocket::Error::Frame
-        def message; :control_frame_payload_too_long; end
+        def message
+          :control_frame_payload_too_long
+        end
       end
 
       class DataFrameInsteadContinuation < ::WebSocket::Error::Frame
-        def message; :data_frame_instead_continuation; end
+        def message
+          :data_frame_instead_continuation
+        end
       end
 
       class FragmentedControlFrame < ::WebSocket::Error::Frame
-        def message; :fragmented_control_frame; end
+        def message
+          :fragmented_control_frame
+        end
       end
 
       class Invalid < ::WebSocket::Error::Frame
-        def message; :invalid_frame; end
+        def message
+          :invalid_frame
+        end
       end
 
       class InvalidPayloadEncoding < ::WebSocket::Error::Frame
-        def message; :invalid_payload_encoding; end
+        def message
+          :invalid_payload_encoding
+        end
       end
 
       class MaskTooShort < ::WebSocket::Error::Frame
-        def message; :mask_is_too_short; end
+        def message
+          :mask_is_too_short
+        end
       end
 
       class ReservedBitUsed < ::WebSocket::Error::Frame
-        def message; :reserved_bit_used; end
+        def message
+          :reserved_bit_used
+        end
       end
 
       class TooLong < ::WebSocket::Error::Frame
-        def message; :frame_too_long; end
+        def message
+          :frame_too_long
+        end
       end
 
       class UnexpectedContinuationFrame < ::WebSocket::Error::Frame
-        def message; :unexpected_continuation_frame; end
+        def message
+          :unexpected_continuation_frame
+        end
       end
 
       class UnknownFrameType < ::WebSocket::Error::Frame
-        def message; :unknown_frame_type; end
+        def message
+          :unknown_frame_type
+        end
       end
 
       class UnknownOpcode < ::WebSocket::Error::Frame
-        def message; :unknown_opcode; end
+        def message
+          :unknown_opcode
+        end
       end
 
       class UnknownCloseCode < ::WebSocket::Error::Frame
-        def message; :unknown_close_code; end
+        def message
+          :unknown_close_code
+        end
       end
 
       class UnknownVersion < ::WebSocket::Error::Frame
-        def message; :unknown_protocol_version; end
+        def message
+          :unknown_protocol_version
+        end
       end
-
     end
 
     class Handshake < ::WebSocket::Error
-
       class GetRequestRequired < ::WebSocket::Error::Handshake
-        def message; :get_request_required; end
+        def message
+          :get_request_required
+        end
       end
 
       class InvalidAuthentication < ::WebSocket::Error::Handshake
-        def message; :invalid_handshake_authentication; end
+        def message
+          :invalid_handshake_authentication
+        end
       end
 
       class InvalidHeader < ::WebSocket::Error::Handshake
-        def message; :invalid_header; end
+        def message
+          :invalid_header
+        end
       end
 
       class InvalidStatusCode < ::WebSocket::Error::Handshake
-        def message; :invalid_status_code; end
+        def message
+          :invalid_status_code
+        end
       end
 
       class NoHostProvided < ::WebSocket::Error::Handshake
-        def message; :no_host_provided; end
+        def message
+          :no_host_provided
+        end
       end
 
       class UnknownVersion < ::WebSocket::Error::Handshake
-        def message; :unknown_protocol_version; end
+        def message
+          :unknown_protocol_version
+        end
       end
-
     end
-
   end
 end

data/lib/websocket/exception_handler.rb

@@ -1,22 +1,12 @@
 module WebSocket
   module ExceptionHandler
-
-    attr_reader :error
+    attr_accessor :error
 
     def self.included(base)
       base.extend(ClassMethods)
     end
 
-    private
-
-    # Changes state to error and sets error message
-    # @param [String] message Error message to set
-    def set_error(message)
-      @error = message
-    end
-
     module ClassMethods
-
       # Rescue from WebSocket::Error errors.
       #
       # @param [String] method_name Name of method that should be wrapped and rescued
@@ -28,15 +18,13 @@ module WebSocket
           begin
             send("#{method_name}_without_rescue", *args)
           rescue WebSocket::Error => e
-            set_error(e.message.to_sym)
+            self.error = e.message.to_sym
             WebSocket.should_raise ? raise : options[:return]
           end
         end
         alias_method "#{method_name}_without_rescue", method_name
         alias_method method_name, "#{method_name}_with_rescue"
       end
-
     end
-
   end
 end

data/lib/websocket/frame.rb

@@ -1,11 +1,9 @@
 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

@@ -26,7 +26,7 @@ module WebSocket
       # Check if some errors occured
       # @return [Boolean] True if error is set
       def error?
-        !!@error
+        !@error.nil?
       end
 
       # Is selected type supported for selected handler?
@@ -36,13 +36,13 @@ module WebSocket
 
       # Implement in submodules
       def supported_frames
-        raise NotImplementedError
+        fail NotImplementedError
       end
 
       # Recreate inspect as #to_s was overwritten
       def inspect
-        vars = self.instance_variables.map { |v| "#{v}=#{instance_variable_get(v).inspect}" }.join(', ')
-        insp = "#{self.class}:0x%08x" % (self.__id__ * 2)
+        vars = instance_variables.map { |v| "#{v}=#{instance_variable_get(v).inspect}" }.join(', ')
+        insp = Kernel.format("#{self.class}:0x%08x", __id__)
         "<#{insp} #{vars}>"
       end
 
@@ -52,16 +52,15 @@ module WebSocket
       # @return [Boolean] false if protocol number is unknown, otherwise true
       def include_version
         @handler = case @version
-          when 75..76 then Handler::Handler75.new(self)
-          when 0..2 then Handler::Handler75.new(self)
-          when 3 then Handler::Handler03.new(self)
-          when 4 then Handler::Handler04.new(self)
-          when 5..6 then Handler::Handler05.new(self)
-          when 7..13 then Handler::Handler07.new(self)
-          else raise WebSocket::Error::Frame::UnknownVersion
-        end
+                   when 75..76 then Handler::Handler75.new(self)
+                   when 0..2 then Handler::Handler75.new(self)
+                   when 3 then Handler::Handler03.new(self)
+                   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
+                   end
       end
-
     end
   end
 end

data/lib/websocket/frame/data.rb

@@ -1,7 +1,6 @@
 module WebSocket
   module Frame
     class Data < String
-
       def initialize(*args)
         super(*convert_args(args))
       end
@@ -17,7 +16,7 @@ module WebSocket
 
       # Extract mask from 4 first bytes according to spec
       def set_mask
-        raise WebSocket::Error::Frame::MaskTooShort if bytesize < 4
+        fail WebSocket::Error::Frame::MaskTooShort if bytesize < 4
         @masking_key = self[0..3].bytes.to_a
       end
 
@@ -42,7 +41,6 @@ module WebSocket
         end
         result
       end
-
     end
   end
 end

data/lib/websocket/frame/handler.rb

@@ -1,7 +1,6 @@
 module WebSocket
   module Frame
     module Handler
-
       autoload :Base,      "#{::WebSocket::ROOT}/websocket/frame/handler/base"
 
       autoload :Handler03, "#{::WebSocket::ROOT}/websocket/frame/handler/handler03"
@@ -9,7 +8,6 @@ module WebSocket
       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

@@ -2,7 +2,6 @@ module WebSocket
   module Frame
     module Handler
       class Base
-
         def initialize(frame)
           @frame = frame
         end
@@ -10,13 +9,13 @@ module WebSocket
         # Convert data to raw frame ready to send to client
         # @return [String] Encoded frame
         def encode_frame
-          raise NotImplementedError
+          fail NotImplementedError
         end
 
         # Convert raw data to decoded frame
         # @return [WebSocket::Frame::Incoming] Frame if found, nil otherwise
         def decode_frame
-          raise NotImplementedError
+          fail NotImplementedError
         end
 
         private
@@ -34,7 +33,6 @@ module WebSocket
         def data_frame?(frame_type)
           [:text, :binary].include?(frame_type)
         end
-
       end
     end
   end

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

@@ -1,10 +1,10 @@
 # encoding: binary
+require 'securerandom'
 
 module WebSocket
   module Frame
     module Handler
       class Handler03 < Base
-
         # Hash of frame names and it's opcodes
         FRAME_TYPES = {
           continuation: 0,
@@ -25,155 +25,192 @@ module WebSocket
 
         # @see WebSocket::Frame::Handler::Base#encode_frame
         def encode_frame
-          frame = ''
+          frame = if @frame.outgoing_masking?
+                    masking_key = SecureRandom.random_bytes(4)
+                    tmp_data = Data.new(masking_key + @frame.data)
+                    tmp_data.set_mask
+                    masking_key + tmp_data.getbytes(4, tmp_data.size)
+                  else
+                    @frame.data
+                  end
+
+          encode_header + frame
+        end
+
+        # @see WebSocket::Frame::Handler::Base#decode_frame
+        def decode_frame
+          while @frame.data.size > 1
+            valid_header, more, frame_type, mask, payload_length = decode_header
+            return unless valid_header
+
+            application_data = decode_payload(payload_length, mask)
+
+            if more
+              decode_continuation_frame(application_data, frame_type)
+            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?
+              return @frame.class.new(version: @frame.version, type: frame_type, data: application_data, decoded: true)
+            end
+          end
+          nil
+        end
+
+        # Allow turning on or off masking
+        def masking?
+          false
+        end
+
+        private
 
-          opcode = type_to_opcode(@frame.type)
-          byte1 = opcode | (fin ? 0b10000000 : 0b00000000) # since more, rsv1-3 are 0 and 0x80 for Draft 4
-          frame << byte1
+        # This allows flipping the more bit to fin for draft 04
+        def fin
+          false
+        end
+
+        # Convert frame type name to opcode
+        # @param [Symbol] frame_type Frame type name
+        # @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)
+        end
 
+        # Convert frame opcode to type name
+        # @param [Integer] opcode Opcode
+        # @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)
+        end
+
+        def encode_header
           mask = @frame.outgoing_masking? ? 0b10000000 : 0b00000000
 
-          length = @frame.data.size
+          output = ''
+          output << (type_to_opcode(@frame.type) | (fin ? 0b10000000 : 0b00000000)) # since more, rsv1-3 are 0 and 0x80 for Draft 4
+          output << encode_payload_length(@frame.data.size, mask)
+          output
+        end
+
+        def encode_payload_length(length, mask)
+          output = ''
           if length <= 125
-            byte2 = length # since rsv4 is 0
-            frame << (byte2 | mask)
+            output << (length | mask) # since rsv4 is 0
           elsif length < 65_536 # write 2 byte length
-            frame << (126 | mask)
-            frame << [length].pack('n')
+            output << (126 | mask)
+            output << [length].pack('n')
           else # write 8 byte length
-            frame << (127 | mask)
-            frame << [length >> 32, length & 0xFFFFFFFF].pack('NN')
+            output << (127 | mask)
+            output << [length >> 32, length & 0xFFFFFFFF].pack('NN')
           end
-
-          if @frame.outgoing_masking?
-            masking_key = [rand(256).chr, rand(256).chr, rand(256).chr, rand(256).chr].join
-            tmp_data = Data.new([masking_key, @frame.data.to_s].join)
-            tmp_data.set_mask
-            frame << masking_key + tmp_data.getbytes(4, tmp_data.size)
-          else
-            frame << @frame.data
-          end
-
-          frame
+          output
         end
 
-        # @see WebSocket::Frame::Handler::Base#decode_frame
-        def decode_frame
-          while @frame.data.size > 1
-            pointer = 0
+        def decode_header
+          more, frame_type = decode_first_byte
+          header_length, payload_length, mask = decode_second_byte(frame_type)
+          return unless header_length
 
-            more = ((@frame.data.getbyte(pointer) & 0b10000000) == 0b10000000) ^ fin
+          # Compute the expected frame length
+          frame_length = header_length + payload_length
+          frame_length += 4 if mask
 
-            raise(WebSocket::Error::Frame::ReservedBitUsed) if @frame.data.getbyte(pointer) & 0b01110000 != 0b00000000
+          fail(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size
 
-            opcode = @frame.data.getbyte(pointer) & 0b00001111
-            frame_type = opcode_to_type(opcode)
-            pointer += 1
+          # Check buffer size
+          return unless buffer_exists?(frame_length) # Buffer incomplete
 
-            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?
+          # Remove frame header
+          @frame.data.slice!(0...header_length)
 
-            mask = @frame.incoming_masking? && (@frame.data.getbyte(pointer) & 0b10000000) == 0b10000000
-            length = @frame.data.getbyte(pointer) & 0b01111111
+          [true, more, frame_type, mask, payload_length]
+        end
 
-            raise(WebSocket::Error::Frame::ControlFramePayloadTooLong) if length > 125 && control_frame?(frame_type)
+        def buffer_exists?(buffer_number)
+          !@frame.data.getbyte(buffer_number - 1).nil?
+        end
 
-            pointer += 1
+        def decode_first_byte
+          first_byte = @frame.data.getbyte(0)
 
-            payload_length = case length
-            when 127 # Length defined by 8 bytes
-              # Check buffer size
-              return if @frame.data.getbyte(pointer + 8 - 1) == nil # Buffer incomplete
+          fail(WebSocket::Error::Frame::ReservedBitUsed) if first_byte & 0b01110000 != 0b00000000
 
-              # 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 = @frame.data.getbytes(pointer + 4, 4).unpack('N').first
-              pointer += 8
-              l
-            when 126 # Length defined by 2 bytes
-              # Check buffer size
-              return if @frame.data.getbyte(pointer + 2 - 1) == nil # Buffer incomplete
+          more = ((first_byte & 0b10000000) == 0b10000000) ^ fin
+          frame_type = opcode_to_type first_byte & 0b00001111
 
-              l = @frame.data.getbytes(pointer, 2).unpack('n').first
-              pointer += 2
-              l
-            else
-              length
-            end
+          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?
 
-            # Compute the expected frame length
-            frame_length = pointer + payload_length
-            frame_length += 4 if mask
+          [more, frame_type]
+        end
 
-            raise(WebSocket::Error::Frame::TooLong) if frame_length > WebSocket.max_frame_size
+        def decode_second_byte(frame_type)
+          second_byte = @frame.data.getbyte(1)
 
-            # Check buffer size
-            return if @frame.data.getbyte(frame_length - 1) == nil # Buffer incomplete
+          mask = @frame.incoming_masking? && (second_byte & 0b10000000) == 0b10000000
+          length = second_byte & 0b01111111
 
-            # Remove frame header
-            @frame.data.slice!(0...pointer)
-            pointer = 0
+          fail(WebSocket::Error::Frame::ControlFramePayloadTooLong) if length > 125 && control_frame?(frame_type)
 
-            # Read application data (unmasked if required)
-            @frame.data.set_mask if mask
-            pointer += 4 if mask
-            application_data = @frame.data.getbytes(pointer, payload_length)
-            application_data.force_encoding('UTF-8')
-            pointer += payload_length
-            @frame.data.unset_mask if mask
+          header_length, payload_length = decode_payload_length(length)
 
-            # Throw away data up to pointer
-            @frame.data.slice!(0...pointer)
+          [header_length, payload_length, mask]
+        end
 
-            raise(WebSocket::Error::Frame::UnexpectedContinuationFrame) if frame_type == :continuation && !@frame_type
+        def decode_payload_length(length)
+          case length
+          when 127 # Length defined by 8 bytes
+            # Check buffer size
+            return unless buffer_exists?(10) # Buffer incomplete
 
-            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::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
-                return message
-              else
-                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
+            # 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 :)
+            [10, @frame.data.getbytes(6, 4).unpack('N').first]
+          when 126 # Length defined by 2 bytes
+            # Check buffer size
+            return unless buffer_exists?(4) # Buffer incomplete
+
+            [4, @frame.data.getbytes(2, 2).unpack('n').first]
+          else
+            [2, length]
           end
-          return nil
         end
 
-        # Allow turning on or off masking
-        def masking?; false; end
+        def decode_payload(payload_length, mask)
+          pointer = 0
 
-        private
+          # Read application data (unmasked if required)
+          @frame.data.set_mask if mask
+          pointer += 4 if mask
+          payload = @frame.data.getbytes(pointer, payload_length)
+          payload.force_encoding('UTF-8')
+          pointer += payload_length
+          @frame.data.unset_mask if mask
 
-        # This allows flipping the more bit to fin for draft 04
-        def fin; false; end
+          # Throw away data up to pointer
+          @frame.data.slice!(0...pointer)
 
-        # Convert frame type name to opcode
-        # @param [Symbol] frame_type Frame type name
-        # @return [Integer] opcode or nil
-        # @raise [WebSocket::Error] if frame opcode is not known
-        def type_to_opcode(frame_type)
-          FRAME_TYPES[frame_type] || raise(WebSocket::Error::Frame::UnknownFrameType)
+          payload
         end
 
-        # Convert frame opcode to type name
-        # @param [Integer] opcode Opcode
-        # @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] || raise(WebSocket::Error::Frame::UnknownOpcode)
+        def decode_continuation_frame(application_data, frame_type)
+          @application_data_buffer ||= ''
+          @application_data_buffer << application_data
+          @frame_type ||= frame_type
         end
 
+        def decode_finish_continuation_frame(application_data)
+          fail(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?
+          message = @frame.class.new(version: @frame.version, type: @frame_type, data: @application_data_buffer, decoded: true)
+          @application_data_buffer = nil
+          @frame_type = nil
+          message
+        end
       end
     end
   end