websocket 1.0.0

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

@@ -0,0 +1,19 @@
+# encoding: binary
+
+module WebSocket
+  module Frame
+    module Handler
+      module Handler04
+
+        include Handler03
+
+        private
+
+        # The only difference between draft 03 framing and draft 04 framing is
+        # that the MORE bit has been changed to a FIN bit
+        def fin; true; end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# encoding: binary
+
+module WebSocket
+  module Frame
+    module Handler
+      module Handler05
+
+        include Handler04
+
+        private
+
+        def masking?; true; end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+# encoding: binary
+
+module WebSocket
+  module Frame
+    module Handler
+      module Handler07
+
+        include Handler05
+
+        private
+
+        FRAME_TYPES = {
+          :continuation => 0,
+          :text => 1,
+          :binary => 2,
+          :close => 8,
+          :ping => 9,
+          :pong => 10,
+        }
+
+        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

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

@@ -0,0 +1,79 @@
+# encoding: binary
+
+module WebSocket
+  module Frame
+    module Handler
+      module Handler75
+
+        include Base
+
+        def supported_frames
+          [:text, :close]
+        end
+
+        private
+
+        def encode_frame
+          case @type
+            when :close then "\xff\x00"
+            when :text then
+              ary = ["\x00", @data, "\xff"]
+              ary.collect{ |s| s.encode('UTF-8', 'UTF-8', :invalid => :replace) if s.respond_to?(:encode) }
+              ary.join
+          end
+        end
+
+        def decode_frame
+          return if @data.size == 0
+
+          pointer = 0
+          frame_type = @data.getbyte(pointer)
+          pointer += 1
+
+          if (frame_type & 0x80) == 0x80
+            # If the high-order bit of the /frame type/ byte is set
+            length = 0
+
+            loop do
+              return if !@data.getbyte(pointer)
+              b = @data.getbyte(pointer)
+              pointer += 1
+              b_v = b & 0x7F
+              length = length * 128 + b_v
+              break unless (b & 0x80) == 0x80
+            end
+
+            set_error(:frame_too_long) and return if length > MAX_FRAME_SIZE
+
+            unless @data.getbyte(pointer+length-1) == nil
+              # Straight from spec - I'm sure this isn't crazy...
+              # 6. Read /length/ bytes.
+              # 7. Discard the read bytes.
+              @data = @data[(pointer+length)..-1]
+
+              # If the /frame type/ is 0xFF and the /length/ was 0, then close
+              if length == 0
+                self.class.new(:version => version, :type => :close, :decoded => true)
+              end
+            end
+          else
+            # If the high-order bit of the /frame type/ byte is _not_ set
+
+            set_error(:invalid_frame) and return if @data.getbyte(0) != 0x00
+
+            # Addition to the spec to protect against malicious requests
+            set_error(:frame_too_long) and return if @data.size > MAX_FRAME_SIZE
+
+            msg = @data.slice!(/\A\x00[^\xff]*\xff/)
+            if msg
+              msg.gsub!(/\A\x00|\xff\z/, '')
+              msg.force_encoding('UTF-8') if msg.respond_to?(:force_encoding)
+              self.class.new(:version => version, :type => :text, :data => msg, :decoded => true)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/websocket/frame/incoming.rb

@@ -0,0 +1,43 @@
+module WebSocket
+  module Frame
+    class Incoming < Base
+
+      autoload :Client, "#{::WebSocket::ROOT}/websocket/frame/incoming/client"
+      autoload :Server, "#{::WebSocket::ROOT}/websocket/frame/incoming/server"
+
+      def initialize(args = {})
+        @decoded = args[:decoded] || false
+        super
+      end
+
+      # If data is still encoded after receiving then this is false. After calling "next" you will receive
+      # another instance of incoming frame, but with data decoded - this function will return true and
+      # to_s will return frame content instead of raw data.
+      # @return [Boolean] If frame already decoded?
+      def decoded?
+        @decoded
+      end
+
+      # Add provided string as raw incoming frame.
+      # @param data [String] Raw frame
+      def <<(data)
+        @data << data
+      end
+
+      # Return next complete frame.
+      # This function will merge together splitted frames and return as combined content.
+      # Check #error if nil received to check for eventual parsing errors
+      # @return [WebSocket::Frame::Incoming] Single incoming frame or nil if no complete frame is available.
+      def next
+        decode_frame unless decoded?
+      end
+
+      # If decoded then this will return frame content. Otherwise it will return raw frame.
+      # @return [String] Data of frame
+      def to_s
+        @data
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module WebSocket
+  module Frame
+    class Incoming
+      class Client < Incoming
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module WebSocket
+  module Frame
+    class Incoming
+      class Server < Incoming
+
+      end
+    end
+  end
+end

data/lib/websocket/frame/outgoing.rb

@@ -0,0 +1,28 @@
+module WebSocket
+  module Frame
+    class Outgoing < Base
+
+      autoload :Client, "#{::WebSocket::ROOT}/websocket/frame/outgoing/client"
+      autoload :Server, "#{::WebSocket::ROOT}/websocket/frame/outgoing/server"
+
+      # Is selected type supported by current draft version?
+      # @return [Boolean] true if frame type is supported
+      def supported?
+        support_type?
+      end
+
+      # Should current frame be sent? Exclude empty frames etc.
+      # @return [Boolean] true if frame should be sent
+      def require_sending?
+        !error?
+      end
+
+      # Return raw frame formatted for sending.
+      def to_s
+        set_error(:unknown_frame_type) and return unless supported?
+        encode_frame
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module WebSocket
+  module Frame
+    class Outgoing
+      class Client < Outgoing
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module WebSocket
+  module Frame
+    class Outgoing
+      class Server < Outgoing
+
+      end
+    end
+  end
+end

data/lib/websocket/handshake.rb

@@ -0,0 +1,10 @@
+module WebSocket
+  module Handshake
+
+    autoload :Base,    "#{::WebSocket::ROOT}/websocket/handshake/base"
+    autoload :Client,  "#{::WebSocket::ROOT}/websocket/handshake/client"
+    autoload :Handler, "#{::WebSocket::ROOT}/websocket/handshake/handler"
+    autoload :Server,  "#{::WebSocket::ROOT}/websocket/handshake/server"
+
+  end
+end

data/lib/websocket/handshake/base.rb

@@ -0,0 +1,67 @@
+module WebSocket
+  module Handshake
+    class Base
+
+      attr_reader :host, :port, :path, :query,
+                  :error, :state, :version, :secure
+
+      def initialize(args = {})
+        @state = :new
+
+        @data = ""
+        @headers = {}
+      end
+
+      def <<(data)
+        raise NotImplementedError
+      end
+
+      def finished?
+        @state == :finished || @state == :error
+      end
+
+      def valid?
+        finished? && @error == nil
+      end
+
+      def should_respond?
+        raise NotImplementedError
+      end
+
+      def leftovers
+        @leftovers.split("\n", reserved_leftover_lines + 1)[reserved_leftover_lines]
+      end
+
+      private
+
+      def reserved_leftover_lines
+        0
+      end
+
+      def set_error(message)
+        @state = :error
+        @error = message
+      end
+
+      HEADER = /^([^:]+):\s*(.+)$/
+
+      def parse_data
+        header, @leftovers = @data.split("\r\n\r\n", 2)
+        return unless @leftovers # The whole header has not been received yet.
+
+        lines = header.split("\r\n")
+
+        first_line = lines.shift
+        return unless parse_first_line(first_line)
+
+        lines.each do |line|
+          h = HEADER.match(line)
+          @headers[h[1].strip.downcase] = h[2].strip if h
+        end
+
+        @state = :finished
+      end
+
+    end
+  end
+end

data/lib/websocket/handshake/client.rb

@@ -0,0 +1,80 @@
+require 'URI' unless defined?(URI)
+
+module WebSocket
+  module Handshake
+    class Client < Base
+
+      def initialize(args = {})
+        super
+
+        @version = args[:version] || DEFAULT_VERSION
+        @origin = args[:origin]
+
+        if args[:uri]
+          uri     = URI.parse(args[:uri])
+          @secure = (uri.scheme == 'wss')
+          @host   = uri.host
+          @port   = uri.port
+          @path   = uri.path
+          @query  = uri.query
+        end
+
+        @secure = args[:secure] if args[:secure]
+        @host   = args[:host]   if args[:host]
+        @port   = args[:port]   if args[:port]
+        @path   = args[:path]   if args[:path]
+        @query  = args[:query]  if args[:query]
+
+        @path   ||= '/'
+
+        set_error(:no_host_provided) unless @host
+
+        include_version
+      end
+
+      def <<(data)
+        @data << data
+        if parse_data
+
+        end
+      end
+
+      def should_respond?
+        false
+      end
+
+      def uri
+        uri = @secure ? "wss://" : "ws://"
+        uri << @host
+        uri << ":#{@port}" if @port
+        uri << @path
+        uri << "?#{@query}" if @query
+        uri
+      end
+
+      private
+
+      def include_version
+        case @version
+          when 75 then extend Handler::Client75
+          when 76, 0 then extend Handler::Client76
+          when 1..3  then extend Handler::Client01
+          when 4..13 then extend Handler::Client04
+          else set_error(:unknown_protocol_version) and return false
+        end
+        return true
+      end
+
+      FIRST_LINE = /^HTTP\/1\.1 (\d{3})[\w\s]*$/
+
+      def parse_first_line(line)
+        line_parts = line.match(FIRST_LINE)
+        status = line_parts[1]
+        set_error(:invalid_status_code) and return unless status == '101'
+
+        return true
+      end
+
+    end
+  end
+end

data/lib/websocket/handshake/handler.rb

@@ -0,0 +1,20 @@
+module WebSocket
+  module Handshake
+    module Handler
+
+      autoload :Base,     "#{::WebSocket::ROOT}/websocket/handshake/handler/base"
+
+      autoload :Client,   "#{::WebSocket::ROOT}/websocket/handshake/handler/client"
+      autoload :Client01, "#{::WebSocket::ROOT}/websocket/handshake/handler/client01"
+      autoload :Client04, "#{::WebSocket::ROOT}/websocket/handshake/handler/client04"
+      autoload :Client75, "#{::WebSocket::ROOT}/websocket/handshake/handler/client75"
+      autoload :Client76, "#{::WebSocket::ROOT}/websocket/handshake/handler/client76"
+
+      autoload :Server,   "#{::WebSocket::ROOT}/websocket/handshake/handler/server"
+      autoload :Server04, "#{::WebSocket::ROOT}/websocket/handshake/handler/server04"
+      autoload :Server75, "#{::WebSocket::ROOT}/websocket/handshake/handler/server75"
+      autoload :Server76, "#{::WebSocket::ROOT}/websocket/handshake/handler/server76"
+
+    end
+  end
+end