faye-websocket 0.1.2 → 0.2.0

data/lib/faye/websocket/hybi_parser/handshake.rb

@@ -0,0 +1,78 @@
+module Faye
+  class WebSocket
+    class HybiParser
+
+      class Handshake
+        GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+        attr_reader :protocol
+
+        def initialize(uri, protocols)
+          @uri       = uri
+          @protocols = protocols
+          @key       = Base64.encode64((1..16).map { rand(255).chr } * '').strip
+          @accept    = Base64.encode64(Digest::SHA1.digest(@key + GUID)).strip
+          @buffer    = []
+        end
+
+        def request_data
+          hostname = @uri.host + (@uri.port ? ":#{@uri.port}" : '')
+
+          headers = [
+            "GET #{@uri.path}#{@uri.query ? '?' : ''}#{@uri.query} HTTP/1.1",
+            "Host: #{hostname}",
+            "Upgrade: websocket",
+            "Connection: Upgrade",
+            "Sec-WebSocket-Key: #{@key}",
+            "Sec-WebSocket-Version: 13"
+          ]
+
+          if @protocols
+            headers << "Sec-WebSocket-Protocol: #{@protocols * ', '}"
+          end
+
+          (headers + ['','']).join("\r\n")
+        end
+
+        def parse(data)
+          message  = []
+          complete = false
+          data.each_byte do |byte|
+            if complete
+              message << byte
+            else
+              @buffer << byte
+              complete ||= complete?
+            end
+          end
+          message
+        end
+
+        def complete?
+          @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
+        end
+
+        def valid?
+          data = WebSocket.encode(@buffer)
+
+          response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
+          return false unless response.code.to_i == 101
+
+          upgrade    = response['Upgrade']
+          connection = response['Connection']
+          protocol   = response['Sec-WebSocket-Protocol']
+
+          @protocol = @protocols && @protocols.include?(protocol) ?
+                      protocol :
+                      nil
+
+          upgrade and upgrade =~ /^websocket$/i and
+          connection and connection.split(/\s*,\s*/).include?('Upgrade') and
+          ((!@protocols and !protocol) or @protocol) and
+          response['Sec-WebSocket-Accept'] == @accept
+        end
+      end
+
+    end
+  end
+end

data/lib/faye/websocket/hybi_parser/stream_reader.rb

@@ -0,0 +1,29 @@
+module Faye
+  class WebSocket
+    class HybiParser
+
+      class StreamReader
+        def initialize
+          @queue = []
+        end
+
+        def read(length)
+          read_bytes(length)
+        end
+
+        def put(bytes)
+          return unless bytes and bytes.size > 0
+          @queue.concat(bytes)
+        end
+
+      private
+
+        def read_bytes(length)
+          return nil if length > @queue.size
+          @queue.shift(length)
+        end
+      end
+
+    end
+  end
+end

data/spec/faye/websocket/client_spec.rb

@@ -15,7 +15,7 @@ WebSocketSteps = EM::RSpec.async_steps do
     EM.next_tick(&callback)
   end
   
-  def open_socket(url, &callback)
+  def open_socket(url, protocols, &callback)
     done = false
     
     resume = lambda do |open|
@@ -26,7 +26,7 @@ WebSocketSteps = EM::RSpec.async_steps do
       end
     end
     
-    @ws = Faye::WebSocket::Client.new(url)
+    @ws = Faye::WebSocket::Client.new(url, protocols)
     
     @ws.onopen  = lambda { |e| resume.call(true) }
     @ws.onclose = lambda { |e| resume.call(false) }
@@ -50,6 +50,11 @@ WebSocketSteps = EM::RSpec.async_steps do
     callback.call
   end
   
+  def check_protocol(protocol, &callback)
+    @ws.protocol.should == protocol
+    callback.call
+  end
+  
   def listen_for_message(&callback)
     @ws.add_event_listener('message', lambda { |e| @message = e.data })
     callback.call
@@ -74,6 +79,7 @@ end
 describe Faye::WebSocket::Client do
   include WebSocketSteps
   
+  let(:protocols)      { ["foo", "echo"]       }
   let(:plain_text_url) { "ws://0.0.0.0:8000/"  }
   let(:secure_url)     { "wss://0.0.0.0:8000/" }
   
@@ -84,23 +90,29 @@ describe Faye::WebSocket::Client do
   
   shared_examples_for "socket client" do
     it "can open a connection" do
-      open_socket(socket_url)
+      open_socket(socket_url, protocols)
       check_open
+      check_protocol("echo")
     end
     
     it "cannot open a connection to the wrong host" do
-      open_socket(blocked_url)
+      open_socket(blocked_url, protocols)
+      check_closed
+    end
+    
+    it "cannot open a connection with unacceptable protocols" do
+      open_socket(socket_url, ["foo"])
       check_closed
     end
     
     it "can close the connection" do
-      open_socket(socket_url)
+      open_socket(socket_url, protocols)
       close_socket
       check_closed
     end
     
     describe "in the OPEN state" do
-      before { open_socket(socket_url) }
+      before { open_socket(socket_url, protocols) }
       
       it "can send and receive messages" do
         listen_for_message
@@ -111,7 +123,7 @@ describe Faye::WebSocket::Client do
     
     describe "in the CLOSED state" do
       before do
-        open_socket(socket_url)
+        open_socket(socket_url, protocols)
         close_socket
       end
       

data/spec/faye/websocket/draft75_parser_spec.rb

@@ -11,21 +11,51 @@ describe Faye::WebSocket::Draft75Parser do
   end
   
   describe :parse do
-    it "parses text frames" do
-      @web_socket.should_receive(:receive).with("Hello")
-      parse [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+    shared_examples_for "draft-75 parser" do
+      it "parses text frames" do
+        @web_socket.should_receive(:receive).with("Hello")
+        parse [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+      end
+      
+      it "parses multiple frames from the same packet" do
+        @web_socket.should_receive(:receive).with("Hello").exactly(2)
+        parse [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+      end
+      
+      it "parses text frames beginning 0x00-0x7F" do
+        @web_socket.should_receive(:receive).with("Hello")
+        parse [0x66, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+      end
+      
+      it "ignores frames with a length header" do
+        @web_socket.should_not_receive(:receive)
+        parse [0x80, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
+      end
+      
+      it "parses text following an ignored block" do
+        @web_socket.should_receive(:receive).with("Hello")
+        parse [0x80, 0x02, 0x48, 0x65, 0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+      end
+      
+      it "parses multibyte text frames" do
+        @web_socket.should_receive(:receive).with(encode "Apple = ")
+        parse [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
+      end
+      
+      it "parses frames received in several packets" do
+        @web_socket.should_receive(:receive).with(encode "Apple = ")
+        parse [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65]
+        parse [0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
+      end
+      
+      it "parses fragmented frames" do
+        @web_socket.should_receive(:receive).with("Hello")
+        parse [0x00, 0x48, 0x65, 0x6c]
+        parse [0x6c, 0x6f, 0xff]
+      end
     end
     
-    it "parses multibyte text frames" do
-      @web_socket.should_receive(:receive).with(encode "Apple = ")
-      parse [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
-    end
-    
-    it "parses fragmented frames" do
-      @web_socket.should_receive(:receive).with("Hello")
-      parse [0x00, 0x48, 0x65, 0x6c]
-      parse [0x6c, 0x6f, 0xff]
-    end
+    it_should_behave_like "draft-75 parser"
   end
   
   describe :frame do

data/spec/faye/websocket/draft76_parser_spec.rb

@@ -0,0 +1,34 @@
+# encoding=utf-8
+
+require "spec_helper"
+
+describe Faye::WebSocket::Draft76Parser do
+  include EncodingHelper
+  
+  before do
+    @web_socket = mock Faye::WebSocket
+    @parser = Faye::WebSocket::Draft76Parser.new(@web_socket)
+    @parser.instance_eval { @handshake_complete = true }
+  end
+  
+  describe :parse do
+    it_should_behave_like "draft-75 parser"
+    
+    it "closes the socket if a close frame is received" do
+      @web_socket.should_receive(:close)
+      parse [0xFF, 0x00]
+    end
+  end
+  
+  describe :frame do
+    it "returns the given string formatted as a WebSocket frame" do
+      bytes(@parser.frame "Hello").should == [0x00, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0xff]
+    end
+    
+    it "encodes multibyte characters correctly" do
+      message = encode "Apple = "
+      bytes(@parser.frame message).should == [0x00, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf, 0xff]
+    end
+  end
+end
+

data/spec/faye/websocket/{protocol8_parser_spec.rb → hybi_parser_spec.rb}

@@ -2,17 +2,17 @@
 
 require "spec_helper"
 
-describe Faye::WebSocket::Protocol8Parser do
+describe Faye::WebSocket::HybiParser do
   include EncodingHelper
-  
+
   before do
     @web_socket = mock Faye::WebSocket
-    @parser = Faye::WebSocket::Protocol8Parser.new(@web_socket)
+    @parser = Faye::WebSocket::HybiParser.new(@web_socket)
   end
-  
+
   describe :parse do
     let(:mask) { (1..4).map { rand 255 } }
-    
+
     def mask_message(*bytes)
       output = []
       bytes.each_with_index do |byte, i|
@@ -20,124 +20,135 @@ describe Faye::WebSocket::Protocol8Parser do
       end
       output
     end
-    
+
     it "parses unmasked text frames" do
       @web_socket.should_receive(:receive).with("Hello")
       parse [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
     end
-    
+
+    it "parses multiple frames from the same packet" do
+      @web_socket.should_receive(:receive).with("Hello").exactly(2)
+      parse [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
+    end
+
     it "parses empty text frames" do
       @web_socket.should_receive(:receive).with("")
       parse [0x81, 0x00]
     end
-    
+
     it "parses fragmented text frames" do
       @web_socket.should_receive(:receive).with("Hello")
       parse [0x01, 0x03, 0x48, 0x65, 0x6c]
       parse [0x80, 0x02, 0x6c, 0x6f]
     end
-    
+
     it "parses masked text frames" do
       @web_socket.should_receive(:receive).with("Hello")
       parse [0x81, 0x85] + mask + mask_message(0x48, 0x65, 0x6c, 0x6c, 0x6f)
     end
-    
+
     it "parses masked empty text frames" do
       @web_socket.should_receive(:receive).with("")
       parse [0x81, 0x80] + mask + mask_message()
     end
-    
+
     it "parses masked fragmented text frames" do
       @web_socket.should_receive(:receive).with("Hello")
       parse [0x01, 0x81] + mask + mask_message(0x48)
       parse [0x80, 0x84] + mask + mask_message(0x65, 0x6c, 0x6c, 0x6f)
     end
-    
+
     it "closes the socket if the frame has an unrecognized opcode" do
       @web_socket.should_receive(:close).with(1002, nil, false)
       parse [0x83, 0x00]
     end
-    
+
     it "closes the socket if a close frame is received" do
       @web_socket.should_receive(:close).with(1000, "Hello", false)
       parse [0x88, 0x07, 0x03, 0xe8, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
     end
-    
+
     it "parses unmasked multibyte text frames" do
       @web_socket.should_receive(:receive).with(encode "Apple = ")
       parse [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]
     end
-    
+
+    it "parses frames received in several packets" do
+      @web_socket.should_receive(:receive).with(encode "Apple = ")
+      parse [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c]
+      parse [0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]
+    end
+
     it "parses fragmented multibyte text frames" do
       @web_socket.should_receive(:receive).with(encode "Apple = ")
       parse [0x01, 0x0a, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3]
       parse [0x80, 0x01, 0xbf]
     end
-    
+
     it "parses masked multibyte text frames" do
       @web_socket.should_receive(:receive).with(encode "Apple = ")
       parse [0x81, 0x8b] + mask + mask_message(0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf)
     end
-    
+
     it "parses masked fragmented multibyte text frames" do
       @web_socket.should_receive(:receive).with(encode "Apple = ")
       parse [0x01, 0x8a] + mask + mask_message(0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3)
       parse [0x80, 0x81] + mask + mask_message(0xbf)
     end
-    
+
     it "parses unmasked medium-length text frames" do
       @web_socket.should_receive(:receive).with("Hello" * 40)
       parse [0x81, 0x7e, 0x00, 0xc8] + [0x48, 0x65, 0x6c, 0x6c, 0x6f] * 40
     end
-    
+
     it "parses masked medium-length text frames" do
       @web_socket.should_receive(:receive).with("Hello" * 40)
       parse [0x81, 0xfe, 0x00, 0xc8] + mask + mask_message(*([0x48, 0x65, 0x6c, 0x6c, 0x6f] * 40))
     end
-    
+
     it "replies to pings with a pong" do
       @web_socket.should_receive(:send).with([0x4f, 0x48, 0x41, 0x49], :pong)
       parse [0x89, 0x04, 0x4f, 0x48, 0x41, 0x49]
     end
   end
-  
+
   describe :frame do
     it "returns the given string formatted as a WebSocket frame" do
       bytes(@parser.frame "Hello").should == [0x81, 0x05, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
     end
-    
+
     it "encodes multibyte characters correctly" do
       message = encode "Apple = "
       bytes(@parser.frame message).should == [0x81, 0x0b, 0x41, 0x70, 0x70, 0x6c, 0x65, 0x20, 0x3d, 0x20, 0xef, 0xa3, 0xbf]
     end
-    
+
     it "encodes medium-length strings using extra length bytes" do
       message = "Hello" * 40
       bytes(@parser.frame message).should == [0x81, 0x7e, 0x00, 0xc8] + [0x48, 0x65, 0x6c, 0x6c, 0x6f] * 40
     end
-    
+
     it "encodes long strings using extra length bytes" do
       message = "Hello" * 13108
       bytes(@parser.frame message).should == [0x81, 0x7f] +
                                              [0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x04] +
                                              [0x48, 0x65, 0x6c, 0x6c, 0x6f] * 13108
     end
-    
+
     it "encodes close frames with an error code" do
       frame = @parser.frame "Hello", :close, 1002
       bytes(frame).should == [0x88, 0x07, 0x03, 0xea, 0x48, 0x65, 0x6c, 0x6c, 0x6f]
     end
-    
+
     it "encodes pong frames" do
       bytes(@parser.frame '', :pong).should == [0x8a, 0x00]
     end
   end
-  
+
   describe :utf8 do
     it "detects valid UTF-8" do
       Faye::WebSocket.valid_utf8?( [72, 101, 108, 108, 111, 45, 194, 181, 64, 195, 159, 195, 182, 195, 164, 195, 188, 195, 160, 195, 161, 45, 85, 84, 70, 45, 56, 33, 33] ).should be_true
     end
-    
+
     it "detects invalid UTF-8" do
       Faye::WebSocket.valid_utf8?( [206, 186, 225, 189, 185, 207, 131, 206, 188, 206, 181, 237, 160, 128, 101, 100, 105, 116, 101, 100] ).should be_false
     end