websocket-protocol 0.0.0

data/CHANGELOG.txt

@@ -0,0 +1,6 @@
+=== 0.0.0 / 2013-04-22
+
+* First release
+* Proof of concept for people to try out
+* Might be unstable
+

data/README.rdoc

@@ -0,0 +1,247 @@
+= websocket-protocol {<img src="https://secure.travis-ci.org/faye/websocket-protocol-ruby.png" />}[http://travis-ci.org/faye/websocket-protocol-ruby]
+
+This module provides a complete implementation of the WebSocket protocols that
+can be hooked up to any TCP library. It aims to simplify things by decoupling
+the protocol details from the I/O layer, such that users only need to implement
+code to stream data in and out of it without needing to know anything about how
+the protocol actually works. Think of it as a complete WebSocket system with
+pluggable I/O.
+
+Due to this design, you get a lot of things for free. In particular, if you
+hook this module up to some I/O object, it will do all of this for you:
+
+* Select the correct server-side protocol handler to talk to the client
+* Generate and send both server- and client-side handshakes
+* Recognize when the handshake phase completes and the WS protocol begins
+* Negotiate subprotocol selection based on <tt>Sec-WebSocket-Protocol</tt>
+* Buffer sent messages until the handshake process is finished
+* Deal with proxies that defer delivery of the draft-76 handshake body
+* Notify you when the socket is open and closed and when messages arrive
+* Recombine fragmented messages
+* Dispatch text, binary, ping and close frames
+* Manage the socket-closing handshake process
+* Automatically reply to ping frames with a matching pong
+* Apply masking to messages sent by the client
+
+This library was originally extracted from the {Faye}[http://faye.jcoglan.com]
+project but now aims to provide simple WebSocket support for any Ruby server or
+I/O system.
+
+
+== Usage
+
+To build either a server-side or client-side socket, the only requirement is
+that you supply a +socket+ object with these methods:
+
+* <tt>socket.url</tt> - returns the full URL of the socket as a string.
+* <tt>socket.write(string)</tt> - writes the given string to a TCP stream.
+
+Server-side sockets require one additional method:
+
+* <tt>socket.env</tt> - returns a Rack-style env hash that will contain some of
+  the following fields. Their values are strings containing the value of the
+  named header, unless stated otherwise.
+  * +HTTP_CONNECTION+
+  * +HTTP_HOST+
+  * +HTTP_ORIGIN+
+  * +HTTP_SEC_WEBSOCKET_KEY+
+  * +HTTP_SEC_WEBSOCKET_KEY1+
+  * +HTTP_SEC_WEBSOCKET_KEY2+
+  * +HTTP_SEC_WEBSOCKET_PROTOCOL+
+  * +HTTP_SEC_WEBSOCKET_VERSION+
+  * +HTTP_UPGRADE+
+  * <tt>rack.input</tt>, an +IO+ object representing the request body
+  * +REQUEST_METHOD+, the request's HTTP verb
+
+
+=== Server-side
+
+To handle a server-side WebSocket connection, you need to check whether the
+request is a WebSocket handshake, and if so create a protocol handler for it.
+You must give the handler an object with the +env+, +url+ and +write+ methods.
+A simple example might be:
+
+  require 'websocket/protocol'
+  require 'eventmachine'
+
+  class WS
+    attr_reader :env, :url
+
+    def initialize(env)
+      @env = env
+
+      secure = Rack::Request.new(env).ssl?
+      scheme = secure ? 'wss:' : 'ws:'
+      @url = scheme + '//' + env['HTTP_HOST'] + env['REQUEST_URI']
+
+      @handler = WebSocket::Protocol.rack(self)
+
+      env['rack.hijack'].call
+      @io = env['rack.hijack_io']
+
+      EM.attach(@io, Reader) { |conn| conn.handler = @handler }
+
+      @handler.start
+    end
+
+    def write(string)
+      @io.write(string)
+    end
+
+    module Reader
+      attr_writer :handler
+
+      def receive_data(string)
+        @handler.parse(string)
+      end
+    end
+  end
+
+To explain what's going on here: the +WS+ class implements the +env+, +url+ and
+<tt>write(string)</tt> methods as required. When instantiated with a Rack
+environment, it stores the environment and infers the complete URL from it.
+Having set up the +env+ and +url+, it asks <tt>WebSocket::Protocol</tt> for a
+server-side handler for the socket. Then it uses the Rack hijack API to gain
+access to the TCP stream, and uses EventMachine to stream in incoming data from
+the client, handing incoming data off to the handler for parsing. Finally, we
+tell the handler to +start+, which will begin sending the handshake response.
+This will invoke the <tt>WS#write</tt> method, which will send the response out
+over the TCP socket.
+
+Having defined this class we could use it like this when handling a request:
+
+  if WebSocket::Protocol.websocket?(env)
+    socket = WS.new(env)
+  end
+
+The handler API is described in full below.
+
+
+=== Client-side
+
+Similarly, to implement a WebSocket client you just need an object with +url+
+and +write+ methods. Once you have one such object, you ask for a handler for
+it:
+
+  handler = WebSocket::Protocol.client(socket)
+
+After this you use the handler API as described below to process incoming data
+and send outgoing data.
+
+
+=== Handler API
+
+Handlers are created using one of the following methods:
+
+  handler = WebSocket::Protocol.rack(socket, options)
+  handler = WebSocket::Protocol.client(socket, options)
+
+The +rack+ method returns a handler chosen using the socket's +env+. The
++client+ method always returns a handler for the RFC version of the protocol
+with masking enabled on outgoing frames.
+
+The +options+ argument is optional, and is a hash. It may contain the following
+keys:
+
+* <tt>:protocols</tt> - an array of strings representing acceptable
+  subprotocols for use over the socket. The handler will negotiate one of these
+  to use via the <tt>Sec-WebSocket-Protocol</tt> header if supported by the
+  other peer.
+
+All handlers respond to the following API methods, but some of them are no-ops
+depending on whether the client supports the behaviour.
+
+Note that most of these methods are commands: if they produce data that should
+be sent over the socket, they will give this to you by calling
+<tt>socket.write(string)</tt>.
+
+==== <tt>handler.onopen { |event| }</tt>
+
+Sets the handler block to execute when the socket becomes open.
+
+==== <tt>handler.onmessage { |event| }</tt>
+
+Sets the handler block to execute when a message is received. +event+ will have
+a +data+ attribute containing either a string in the case of a text message or
+an array of integers in the case of a binary message.
+
+==== <tt>handler.onclose { |event| }</tt>
+
+Sets the handler block to execute when the socket becomes closed. The +event+
+object has +code+ and +reason+ attributes.
+
+==== <tt>handler.start</tt>
+
+Initiates the protocol by sending the handshake - either the response for a
+server-side handler or the request for a client-side one. This should be the
+first method you invoke.  Returns +true+ iff a handshake was sent.
+
+==== <tt>handler.parse(string)</tt>
+
+Takes a string and parses it, potentially resulting in message events being
+emitted (see +onmessage+ above) or in data being sent to <tt>socket.write</tt>.
+You should send all data you receive via I/O to this method.
+
+==== <tt>handler.text(string)</tt>
+
+Sends a text message over the socket. If the socket handshake is not yet
+complete, the message will be queued until it is. Returns +true+ if the message
+was sent or queued, and +false+ if the socket can no longer send messages.
+
+==== <tt>handler.binary(array)</tt>
+
+Takes an array of byte-sized integers and sends them as a binary message. Will
+queue and return +true+ or +false+ the same way as the +text+ method. It will
+also return +false+ if the handler does not support binary messages.
+
+==== <tt>handler.ping(string = '', &callback)</tt>
+
+Sends a ping frame over the socket, queueing it if necessary. +string+ and the
++callback+ block are both optional. If a callback is given, it will be invoked
+when the socket receives a pong frame whose content matches +string+. Returns
++false+ if frames can no longer be sent, or if the handler does not support
+ping/pong.
+
+==== <tt>handler.close</tt>
+
+Initiates the closing handshake if the socket is still open. For handlers with
+no closing handshake, this will result in the immediate execution of the
++onclose+ handler. For handlers with a closing handshake, this sends a closing
+frame and +onclose+ will execute when a response is received or a protocol
+error occurs.
+
+==== <tt>handler.version</tt>
+
+Returns the WebSocket version in use as a string. Will either be
+<tt>hixie-75</tt>, <tt>hixie-76</tt> or <tt>hybi-$version</tt>.
+
+==== <tt>handler.protocol</tt>
+
+Returns a string containing the selected subprotocol, if any was agreed upon
+using the <tt>Sec-WebSocket-Protocol</tt> mechanism. This value becomes
+available after +onopen+ has fired.
+
+
+== License
+
+(The MIT License)
+
+Copyright (c) 2009-2013 James Coglan
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the 'Software'), to deal in
+the Software without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the
+Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+

data/ext/websocket_mask/WebsocketMaskService.java

@@ -0,0 +1,61 @@
+package com.jcoglan.websocket;
+
+import java.lang.Long;
+import java.io.IOException;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class WebsocketMaskService implements BasicLibraryService {
+  private Ruby runtime;
+
+  public boolean basicLoad(Ruby runtime) throws IOException {
+    this.runtime = runtime;
+    RubyModule websocket = runtime.defineModule("WebSocket");
+
+    RubyClass webSocketMask = websocket.defineClassUnder("Mask", runtime.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new WebsocketMask(runtime, rubyClass);
+      }
+    });
+
+    webSocketMask.defineAnnotatedMethods(WebsocketMask.class);
+    return true;
+  }
+
+  public class WebsocketMask extends RubyObject {
+    public WebsocketMask(final Ruby runtime, RubyClass rubyClass) {
+      super(runtime, rubyClass);
+    }
+
+    @JRubyMethod
+    public IRubyObject mask(ThreadContext context, IRubyObject payload, IRubyObject mask) {
+      int n = ((RubyArray)payload).getLength(), i;
+      long p, m;
+      RubyArray unmasked = RubyArray.newArray(runtime, n);
+
+      long[] maskArray = {
+        (Long)((RubyArray)mask).get(0),
+        (Long)((RubyArray)mask).get(1),
+        (Long)((RubyArray)mask).get(2),
+        (Long)((RubyArray)mask).get(3)
+      };
+
+      for (i = 0; i < n; i++) {
+        p = (Long)((RubyArray)payload).get(i);
+        m = maskArray[i % 4];
+        unmasked.set(i, p ^ m);
+      }
+      return unmasked;
+    }
+  }
+}

data/ext/websocket_mask/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+extension_name = 'websocket_mask'
+dir_config(extension_name)
+create_makefile(extension_name)
+

data/ext/websocket_mask/websocket_mask.c

@@ -0,0 +1,33 @@
+#include <ruby.h>
+
+VALUE WebSocket = Qnil;
+VALUE WebSocketMask = Qnil;
+
+void Init_websocket_mask();
+VALUE method_websocket_mask(VALUE self, VALUE payload, VALUE mask);
+
+void Init_websocket_mask() {
+  WebSocket = rb_define_module("WebSocket");
+  WebSocketMask = rb_define_module_under(WebSocket, "Mask");
+  rb_define_singleton_method(WebSocketMask, "mask", method_websocket_mask, 2);
+}
+
+VALUE method_websocket_mask(VALUE self, VALUE payload, VALUE mask) {
+  int n = RARRAY_LEN(payload), i, p, m;
+  VALUE unmasked = rb_ary_new2(n);
+
+  int mask_array[] = {
+    NUM2INT(rb_ary_entry(mask, 0)),
+    NUM2INT(rb_ary_entry(mask, 1)),
+    NUM2INT(rb_ary_entry(mask, 2)),
+    NUM2INT(rb_ary_entry(mask, 3))
+  };
+
+  for (i = 0; i < n; i++) {
+    p = NUM2INT(rb_ary_entry(payload, i));
+    m = mask_array[i % 4];
+    rb_ary_store(unmasked, i, INT2NUM(p ^ m));
+  }
+  return unmasked;
+}
+

data/lib/websocket/protocol.rb

@@ -0,0 +1,184 @@
+# Protocol references:
+#
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-75
+# * http://tools.ietf.org/html/draft-hixie-thewebsocketprotocol-76
+# * http://tools.ietf.org/html/draft-ietf-hybi-thewebsocketprotocol-17
+
+require 'base64'
+require 'digest/md5'
+require 'digest/sha1'
+require 'net/http'
+require 'stringio'
+require 'uri'
+
+module WebSocket
+  class Protocol
+
+    root = File.expand_path('../protocol', __FILE__)
+    require root + '/../../websocket_mask'
+
+    def self.jruby?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'jruby'
+    end
+
+    def self.rbx?
+      defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+    end
+
+    if jruby?
+      require 'jruby'
+      com.jcoglan.websocket.WebsocketMaskService.new.basicLoad(JRuby.runtime)
+    end
+
+    unless Mask.respond_to?(:mask)
+      def Mask.mask(payload, mask)
+        @instance ||= new
+        @instance.mask(payload, mask)
+      end
+    end
+
+    unless String.instance_methods.include?(:force_encoding)
+      require root + '/utf8_match'
+    end
+
+    STATES = [:connecting, :open, :closing, :closed]
+
+    class OpenEvent < Struct.new(nil) ; end
+    class MessageEvent < Struct.new(:data) ; end
+    class CloseEvent < Struct.new(:code, :reason) ; end
+
+    autoload :Draft75, root + '/draft75'
+    autoload :Draft76, root + '/draft76'
+    autoload :Hybi,    root + '/hybi'
+    autoload :Client,  root + '/client'
+
+    attr_reader :protocol, :ready_state
+
+    def initialize(socket, options = {})
+      @socket      = socket
+      @options     = options
+      @queue       = []
+      @ready_state = 0
+    end
+
+    def state
+      return nil unless @ready_state >= 0
+      STATES[@ready_state]
+    end
+
+    def start
+      return false unless @ready_state == 0
+      @socket.write(handshake_response)
+      open unless @stage == -1
+      true
+    end
+
+    def text(message)
+      frame(message)
+    end
+
+    def binary(message)
+      false
+    end
+
+    def ping(*args)
+      false
+    end
+
+    def close(reason = nil, code = nil)
+      return false unless @ready_state == 1
+      @ready_state = 3
+      dispatch(:onclose, CloseEvent.new(nil, nil))
+      true
+    end
+
+    def onopen(&block)
+      @onopen = block if block_given?
+      @onopen
+    end
+
+    def onmessage(&block)
+      @onmessage = block if block_given?
+      @onmessage
+    end
+
+    def onerror(&block)
+      @onerror = block if block_given?
+      @onerror
+    end
+
+    def onclose(&block)
+      @onclose = block if block_given?
+      @onclose
+    end
+
+  private
+
+    def open
+      @ready_state = 1
+      @queue.each { |message| frame(*message) }
+      @queue = []
+      dispatch(:onopen, OpenEvent.new)
+    end
+
+    def dispatch(name, event)
+      handler = __send__(name)
+      handler.call(event) if handler
+    end
+
+    def queue(message)
+      @queue << message
+      true
+    end
+
+    def self.encode(string, validate_encoding = false)
+      if Array === string
+        string = utf8_string(string)
+        return nil if validate_encoding and !valid_utf8?(string)
+      end
+      utf8_string(string)
+    end
+
+    def self.client(socket, options = {})
+      Client.new(socket, options.merge(:masking => true))
+    end
+
+    def self.rack(socket, options = {})
+      env = socket.env
+      if env['HTTP_SEC_WEBSOCKET_VERSION']
+        Hybi.new(socket, options.merge(:require_masking => true))
+      elsif env['HTTP_SEC_WEBSOCKET_KEY1']
+        Draft76.new(socket, options)
+      else
+        Draft75.new(socket, options)
+      end
+    end
+
+    def self.utf8_string(string)
+      string = string.pack('C*') if Array === string
+      string.respond_to?(:force_encoding) ?
+          string.force_encoding('UTF-8') :
+          string
+    end
+
+    def self.valid_utf8?(byte_array)
+      string = utf8_string(byte_array)
+      if defined?(UTF8_MATCH)
+        UTF8_MATCH =~ string ? true : false
+      else
+        string.valid_encoding?
+      end
+    end
+
+    def self.websocket?(env)
+      connection = env['HTTP_CONNECTION'] || ''
+      upgrade    = env['HTTP_UPGRADE']    || ''
+
+      env['REQUEST_METHOD'] == 'GET' and
+      connection.downcase.split(/\s*,\s*/).include?('upgrade') and
+      upgrade.downcase == 'websocket'
+    end
+
+  end
+end
+

data/lib/websocket/protocol/client.rb

@@ -0,0 +1,94 @@
+module WebSocket
+  class Protocol
+
+    class Client < Hybi
+      def self.generate_key
+        Base64.encode64((1..16).map { rand(255).chr } * '').strip
+      end
+
+      def initialize(socket, options = {})
+        super
+
+        @ready_state = -1
+        @key         = Client.generate_key
+        @accept      = Base64.encode64(Digest::SHA1.digest(@key + GUID)).strip
+      end
+
+      def start
+        return false unless @ready_state == -1
+        @socket.write(handshake_request)
+        @ready_state = 0
+        true
+      end
+
+      def parse(buffer)
+        return super if @ready_state > 0
+        message = []
+        buffer.each_byte do |data|
+          case @ready_state
+            when 0 then
+              @buffer << data
+              if @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
+                if valid?
+                  open
+                else
+                  @ready_state = 3
+                  dispatch(:onclose, CloseEvent.new(ERRORS[:protocol_error], ''))
+                end
+              end
+            when 1 then
+              message << data
+          end
+        end
+        parse(message) if @ready_state == 1
+      end
+
+    private 
+
+      def handshake_request
+        uri   = URI.parse(@socket.url)
+        host  = uri.host + (uri.port ? ":#{uri.port}" : '')
+        path  = (uri.path == '') ? '/' : uri.path
+        query = uri.query ? "?#{uri.query}" : ''
+
+        headers = [ "GET #{path}#{query} HTTP/1.1",
+                    "Host: #{host}",
+                    "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 valid?
+        data = Protocol.encode(@buffer)
+        @buffer = []
+
+        response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
+        return false unless response.code.to_i == 101
+
+        connection = response['Connection'] || ''
+        upgrade    = response['Upgrade'] || ''
+        accept     = response['Sec-WebSocket-Accept']
+        protocol   = response['Sec-WebSocket-Protocol']
+
+        @protocol = @protocols && @protocols.include?(protocol) ?
+                    protocol :
+                    nil
+
+        connection.downcase.split(/\s*,\s*/).include?('upgrade') and
+        upgrade.downcase == 'websocket' and
+        ((!@protocols and !protocol) or @protocol) and
+        accept == @accept
+      end
+    end
+
+  end
+end
+

data/lib/websocket/protocol/draft75.rb

@@ -0,0 +1,91 @@
+module WebSocket
+  class Protocol
+
+    class Draft75 < Protocol
+      def initialize(socket, options = {})
+        super
+        @stage = 0
+      end
+
+      def version
+        'hixie-75'
+      end
+
+      def parse(buffer)
+        buffer = buffer.bytes if buffer.respond_to?(:bytes)
+
+        buffer.each do |data|
+          case @stage
+            when -1 then
+              @head << data
+              send_handshake_body
+
+            when 0 then
+              parse_leading_byte(data)
+
+            when 1 then
+              value = (data & 0x7F)
+              @length = value + 128 * @length
+
+              if @closing and @length.zero?
+                @ready_state = 3
+                dispatch(:onclose, CloseEvent.new(nil, nil))
+              elsif (0x80 & data) != 0x80
+                if @length.zero?
+                  dispatch(:onmessage, MessageEvent.new(''))
+                  @stage = 0
+                else
+                  @buffer = []
+                  @stage = 2
+                end
+              end
+
+            when 2 then
+              if data == 0xFF
+                dispatch(:onmessage, MessageEvent.new(Protocol.encode(@buffer)))
+                @stage = 0
+              else
+                @buffer << data
+                if @length and @buffer.size == @length
+                  @stage = 0
+                end
+              end
+          end
+        end
+      end
+
+      def frame(data, type = nil, error_type = nil)
+        return queue([data, type, error_type]) if @ready_state == 0
+        data = Protocol.encode(data)
+        frame = ["\x00", data, "\xFF"].map(&Protocol.method(:encode)) * ''
+        @socket.write(frame)
+        true
+      end
+
+    private
+
+      def handshake_response
+        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+        upgrade << "Upgrade: WebSocket\r\n"
+        upgrade << "Connection: Upgrade\r\n"
+        upgrade << "WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
+        upgrade << "WebSocket-Location: #{@socket.url}\r\n"
+        upgrade << "\r\n"
+        upgrade
+      end
+
+      def parse_leading_byte(data)
+        if (0x80 & data) == 0x80
+          @length = 0
+          @stage = 1
+        else
+          @length = nil
+          @buffer = []
+          @stage = 2
+        end
+      end
+    end
+
+  end
+end
+

data/lib/websocket/protocol/draft76.rb

@@ -0,0 +1,96 @@
+module WebSocket
+  class Protocol
+
+    class Draft76 < Draft75
+      HEAD_SIZE = 8
+
+      def initialize(socket, options = {})
+        super
+        input  = @socket.env['rack.input']
+        @stage = -1
+        @head  = input ? input.read.bytes.to_a : []
+      end
+
+      def version
+        'hixie-76'
+      end
+
+      def start
+        return false unless super
+        send_handshake_body
+        true
+      end
+
+      def close(reason = nil, code = nil)
+        return false if @ready_state == 3
+        @socket.write("\xFF\x00")
+        @ready_state = 3
+        dispatch(:onclose, CloseEvent.new(nil, nil))
+      end
+
+    private
+
+      def handshake_response
+        upgrade =  "HTTP/1.1 101 Web Socket Protocol Handshake\r\n"
+        upgrade << "Upgrade: WebSocket\r\n"
+        upgrade << "Connection: Upgrade\r\n"
+        upgrade << "Sec-WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
+        upgrade << "Sec-WebSocket-Location: #{@socket.url}\r\n"
+        upgrade << "\r\n"
+        upgrade
+      end
+
+      def handshake_signature
+        return nil unless @head.size >= HEAD_SIZE
+
+        head = @head[0...HEAD_SIZE].pack('C*')
+        head.force_encoding('ASCII-8BIT') if head.respond_to?(:force_encoding)
+
+        env = @socket.env
+
+        key1   = env['HTTP_SEC_WEBSOCKET_KEY1']
+        value1 = number_from_key(key1) / spaces_in_key(key1)
+
+        key2   = env['HTTP_SEC_WEBSOCKET_KEY2']
+        value2 = number_from_key(key2) / spaces_in_key(key2)
+
+        Digest::MD5.digest(big_endian(value1) +
+                           big_endian(value2) +
+                           head)
+      end
+
+      def send_handshake_body
+        return unless signature = handshake_signature
+        @socket.write(signature)
+        @stage = 0
+        open
+        parse(@head[HEAD_SIZE..-1]) if @head.size > HEAD_SIZE
+      end
+
+      def parse_leading_byte(data)
+        return super unless data == 0xFF
+        @closing = true
+        @length = 0
+        @stage = 1
+      end
+
+      def number_from_key(key)
+        key.scan(/[0-9]/).join('').to_i(10)
+      end
+
+      def spaces_in_key(key)
+        key.scan(/ /).size
+      end
+
+      def big_endian(number)
+        string = ''
+        [24,16,8,0].each do |offset|
+          string << (number >> offset & 0xFF).chr
+        end
+        string
+      end
+    end
+
+  end
+end
+

data/lib/websocket/protocol/hybi.rb

@@ -0,0 +1,348 @@
+module WebSocket
+  class Protocol
+
+    class Hybi < Protocol
+      root = File.expand_path('../hybi', __FILE__)
+      autoload :StreamReader, root + '/stream_reader'
+
+      GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'
+
+      BYTE       = 0b11111111
+      FIN = MASK = 0b10000000
+      RSV1       = 0b01000000
+      RSV2       = 0b00100000
+      RSV3       = 0b00010000
+      OPCODE     = 0b00001111
+      LENGTH     = 0b01111111
+
+      OPCODES = {
+        :continuation => 0,
+        :text         => 1,
+        :binary       => 2,
+        :close        => 8,
+        :ping         => 9,
+        :pong         => 10
+      }
+
+      FRAGMENTED_OPCODES = OPCODES.values_at(:continuation, :text, :binary)
+      OPENING_OPCODES = OPCODES.values_at(:text, :binary)
+
+      ERRORS = {
+        :normal_closure       => 1000,
+        :going_away           => 1001,
+        :protocol_error       => 1002,
+        :unacceptable         => 1003,
+        :encoding_error       => 1007,
+        :policy_violation     => 1008,
+        :too_large            => 1009,
+        :extension_error      => 1010,
+        :unexpected_condition => 1011
+      }
+
+      ERROR_CODES = ERRORS.values
+
+      def initialize(socket, options = {})
+        super
+        reset
+
+        @reader    = StreamReader.new
+        @stage     = 0
+        @masking   = options[:masking]
+        @protocols = options[:protocols]
+        @protocols = @protocols.strip.split(/\s*,\s*/) if String === @protocols
+
+        @require_masking = options[:require_masking]
+        @ping_callbacks  = {}
+      end
+
+      def version
+        "hybi-#{@socket.env['HTTP_SEC_WEBSOCKET_VERSION']}"
+      end
+
+      def parse(data)
+        data = data.bytes.to_a if data.respond_to?(:bytes)
+        @reader.put(data)
+        buffer = true
+        while buffer
+          case @stage
+            when 0 then
+              buffer = @reader.read(1)
+              parse_opcode(buffer[0]) if buffer
+
+            when 1 then
+              buffer = @reader.read(1)
+              parse_length(buffer[0]) if buffer
+
+            when 2 then
+              buffer = @reader.read(@length_size)
+              parse_extended_length(buffer) if buffer
+
+            when 3 then
+              buffer = @reader.read(4)
+              if buffer
+                @mask  = buffer
+                @stage = 4
+              end
+
+            when 4 then
+              buffer = @reader.read(@length)
+              if buffer
+                @payload = buffer
+                emit_frame
+                @stage = 0
+              end
+          end
+        end
+      end
+
+      def frame(data, type = nil, code = nil)
+        return queue([data, type, code]) if @ready_state == 0
+        return false unless @ready_state == 1
+
+        data = data.to_s unless Array === data
+        data = Protocol.encode(data) if String === data
+
+        is_text = (String === data)
+        opcode  = OPCODES[type || (is_text ? :text : :binary)]
+        buffer  = data.respond_to?(:bytes) ? data.bytes.to_a : data
+        insert  = code ? 2 : 0
+        length  = buffer.size + insert
+        header  = (length <= 125) ? 2 : (length <= 65535 ? 4 : 10)
+        offset  = header + (@masking ? 4 : 0)
+        masked  = @masking ? MASK : 0
+        frame   = Array.new(offset)
+
+        frame[0] = FIN | opcode
+
+        if length <= 125
+          frame[1] = masked | length
+        elsif length <= 65535
+          frame[1] = masked | 126
+          frame[2] = (length >> 8) & BYTE
+          frame[3] = length & BYTE
+        else
+          frame[1] = masked | 127
+          frame[2] = (length >> 56) & BYTE
+          frame[3] = (length >> 48) & BYTE
+          frame[4] = (length >> 40) & BYTE
+          frame[5] = (length >> 32) & BYTE
+          frame[6] = (length >> 24) & BYTE
+          frame[7] = (length >> 16) & BYTE
+          frame[8] = (length >> 8)  & BYTE
+          frame[9] = length & BYTE
+        end
+
+        if code
+          buffer = [(code >> 8) & BYTE, code & BYTE] + buffer
+        end
+
+        if @masking
+          mask = [rand(256), rand(256), rand(256), rand(256)]
+          frame[header...offset] = mask
+          buffer = Mask.mask(buffer, mask)
+        end
+
+        frame.concat(buffer)
+
+        @socket.write(Protocol.encode(frame))
+        true
+      end
+
+      def text(message)
+        frame(message, :text)
+      end
+
+      def binary(message)
+        frame(message, :binary)
+      end
+
+      def ping(message = '', &callback)
+        @ping_callbacks[message] = callback if callback
+        frame(message, :ping)
+      end
+
+      def close(reason = nil, code = nil)
+        reason ||= ''
+        code   ||= ERRORS[:normal_closure]
+
+        case @ready_state
+          when 0 then
+            @ready_state = 3
+            dispatch(:onclose, CloseEvent.new(code, reason))
+            true
+          when 1 then
+            frame(reason, :close, code)
+            @ready_state = 2
+            true
+          else
+            false
+        end
+      end
+
+    private
+
+      def handshake_response
+        sec_key = @socket.env['HTTP_SEC_WEBSOCKET_KEY']
+        return '' unless String === sec_key
+
+        accept    = Base64.encode64(Digest::SHA1.digest(sec_key + GUID)).strip
+        protos    = @socket.env['HTTP_SEC_WEBSOCKET_PROTOCOL']
+        supported = @protocols
+        proto     = nil
+
+        headers = [
+          "HTTP/1.1 101 Switching Protocols",
+          "Upgrade: websocket",
+          "Connection: Upgrade",
+          "Sec-WebSocket-Accept: #{accept}"
+        ]
+
+        if protos and supported
+          protos = protos.split(/\s*,\s*/) if String === protos
+          proto = protos.find { |p| supported.include?(p) }
+          if proto
+            @protocol = proto
+            headers << "Sec-WebSocket-Protocol: #{proto}"
+          end
+        end
+
+        (headers + ['','']).join("\r\n")
+      end
+
+      def shutdown(code, reason)
+        code   ||= ERRORS[:normal_closure]
+        reason ||= ''
+
+        frame(reason, :close, code)
+        @ready_state = 3
+        dispatch(:onclose, CloseEvent.new(code, reason))
+      end
+
+      def parse_opcode(data)
+        if [RSV1, RSV2, RSV3].any? { |rsv| (data & rsv) == rsv }
+          return shutdown(ERRORS[:protocol_error], nil)
+        end
+
+        @final   = (data & FIN) == FIN
+        @opcode  = (data & OPCODE)
+        @mask    = []
+        @payload = []
+
+        unless OPCODES.values.include?(@opcode)
+          return shutdown(ERRORS[:protocol_error], nil)
+        end
+
+        unless FRAGMENTED_OPCODES.include?(@opcode) or @final
+          return shutdown(ERRORS[:protocol_error], nil)
+        end
+
+        if @mode and OPENING_OPCODES.include?(@opcode)
+          return shutdown(ERRORS[:protocol_error], nil)
+        end
+
+        @stage = 1
+      end
+
+      def parse_length(data)
+        @masked = (data & MASK) == MASK
+        return shutdown(ERRORS[:unacceptable], nil) if @require_masking and not @masked
+
+        @length = (data & LENGTH)
+
+        if @length <= 125
+          @stage = @masked ? 3 : 4
+        else
+          @length_size = (@length == 126) ? 2 : 8
+          @stage       = 2
+        end
+      end
+
+      def parse_extended_length(buffer)
+        @length = integer(buffer)
+        @stage  = @masked ? 3 : 4
+      end
+
+      def emit_frame
+        payload = @masked ? Mask.mask(@payload, @mask) : @payload
+
+        case @opcode
+          when OPCODES[:continuation] then
+            return shutdown(ERRORS[:protocol_error], nil) unless @mode
+            @buffer.concat(payload)
+            if @final
+              message = @buffer
+              message = Protocol.encode(message, true) if @mode == :text
+              reset
+              if message
+                dispatch(:onmessage, MessageEvent.new(message))
+              else
+                shutdown(ERRORS[:encoding_error], nil)
+              end
+            end
+
+          when OPCODES[:text] then
+            if @final
+              message = Protocol.encode(payload, true)
+              if message
+                dispatch(:onmessage, MessageEvent.new(message))
+              else
+                shutdown(ERRORS[:encoding_error], nil)
+              end
+            else
+              @mode = :text
+              @buffer.concat(payload)
+            end
+
+          when OPCODES[:binary] then
+            if @final
+              dispatch(:onmessage, MessageEvent.new(payload))
+            else
+              @mode = :binary
+              @buffer.concat(payload)
+            end
+
+          when OPCODES[:close] then
+            code = (payload.size >= 2) ? 256 * payload[0] + payload[1] : nil
+
+            unless (payload.size == 0) or
+                   (code && code >= 3000 && code < 5000) or
+                   ERROR_CODES.include?(code)
+              code = ERRORS[:protocol_error]
+            end
+
+            if payload.size > 125 or not Protocol.valid_utf8?(payload[2..-1] || [])
+              code = ERRORS[:protocol_error]
+            end
+
+            reason = (payload.size > 2) ? Protocol.encode(payload[2..-1], true) : ''
+            shutdown(code, reason)
+
+          when OPCODES[:ping] then
+            return shutdown(ERRORS[:protocol_error], nil) if payload.size > 125
+            frame(payload, :pong)
+
+          when OPCODES[:pong] then
+            message = Protocol.encode(payload, true)
+            callback = @ping_callbacks[message]
+            @ping_callbacks.delete(message)
+            callback.call if callback
+        end
+      end
+
+      def reset
+        @buffer = []
+        @mode   = nil
+      end
+
+      def integer(bytes)
+        number = 0
+        bytes.each_with_index do |data, i|
+          number += data << (8 * (bytes.size - 1 - i))
+        end
+        number
+      end
+    end
+
+  end
+end
+

data/lib/websocket/protocol/hybi/stream_reader.rb

@@ -0,0 +1,30 @@
+module WebSocket
+  class Protocol
+
+    class Hybi
+      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/lib/websocket/protocol/utf8_match.rb

@@ -0,0 +1,7 @@
+module WebSocket
+  class Protocol
+    # http://www.w3.org/International/questions/qa-forms-utf-8.en.php
+    UTF8_MATCH = /^([\x00-\x7F]|[\xC2-\xDF][\x80-\xBF]|\xE0[\xA0-\xBF][\x80-\xBF]|[\xE1-\xEC\xEE\xEF][\x80-\xBF]{2}|\xED[\x80-\x9F][\x80-\xBF]|\xF0[\x90-\xBF][\x80-\xBF]{2}|[\xF1-\xF3][\x80-\xBF]{3}|\xF4[\x80-\x8F][\x80-\xBF]{2})*$/
+  end
+end
+

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: websocket-protocol
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+  prerelease: 
+platform: ruby
+authors:
+- James Coglan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: jcoglan@gmail.com
+executables: []
+extensions:
+- ext/websocket_mask/extconf.rb
+extra_rdoc_files:
+- README.rdoc
+files:
+- README.rdoc
+- CHANGELOG.txt
+- ext/websocket_mask/websocket_mask.c
+- ext/websocket_mask/WebsocketMaskService.java
+- ext/websocket_mask/extconf.rb
+- lib/websocket/protocol/client.rb
+- lib/websocket/protocol/draft75.rb
+- lib/websocket/protocol/draft76.rb
+- lib/websocket/protocol/hybi/stream_reader.rb
+- lib/websocket/protocol/hybi.rb
+- lib/websocket/protocol/utf8_match.rb
+- lib/websocket/protocol.rb
+homepage: http://github.com/faye/websocket-protocol-ruby
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: WebSocket protocol handler with pluggable I/O
+test_files: []
+has_rdoc: