websocket-driver 0.1.0 → 0.2.0

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+### 0.2.0 / 2013-05-12
+
+* Add API for setting and reading headers
+* Add Driver.server() method for getting a driver for TCP servers
+
+### 0.1.0 / 2013-05-04
+
+* First stable release
+
 ### 0.0.0 / 2013-04-22
 
 * First release

data/README.md

@@ -61,7 +61,7 @@ Server-side sockets require one additional method:
   * `REQUEST_METHOD`, the request's HTTP verb
 
 
-### Server-side
+### Server-side with Rack
 
 To handle a server-side WebSocket connection, you need to check whether the
 request is a WebSocket handshake, and if so create a protocol driver for it.
@@ -127,6 +127,53 @@ end
 The driver API is described in full below.
 
 
+### Server-side with TCP
+
+You can also handle WebSocket connections in a bare TCP server, if you're not
+using Rack and don't want to implement HTTP parsing yourself. For this, your
+socket object only needs a `write` method.
+
+The driver will emit a `:connect` event when a request is received, and at this
+point you can detect whether it's a WebSocket and handle it as such. Here's an
+example using an EventMachine TCP server.
+
+```ruby
+module Connection
+  def initialize
+    @driver = WebSocket::Driver.server(self)
+
+    @driver.on(:connect) do
+      if WebSocket::Driver.websocket?(@driver.env)
+        @driver.start
+      else
+        # handle other HTTP requests
+      end
+    end
+
+    @driver.on(:message) { |e| @driver.text(e.data) }
+    @driver.on(:close)   { |e| close_connection_after_writing }
+  end
+
+  def receive_data(data)
+    @driver.parse(data)
+  end
+
+  def write(data)
+    send_data(data)
+  end
+end
+
+EM.run {
+  EM.start_server('127.0.0.1', 4180, Connection)
+}
+```
+
+In the `:connect` event, `@driver.env` is a Rack env representing the request.
+If the request has a body, it will be in the `@driver.env['rack.input']`
+stream, but only as much of the body as you have so far routed to it using the
+`parse` method.
+
+
 ### Client-side
 
 Similarly, to implement a WebSocket client you need an object with `url` and
@@ -139,6 +186,12 @@ driver = WebSocket::Driver.client(socket)
 After this you use the driver API as described below to process incoming data
 and send outgoing data.
 
+Client drivers have two additional methods for reading the HTTP data that was
+sent back by the server:
+
+* `driver.status` - the integer value of the HTTP status code
+* `driver.headers` - a hash-like object containing the response headers
+
 
 ### Driver API
 
@@ -146,12 +199,15 @@ Drivers are created using one of the following methods:
 
 ```ruby
 driver = WebSocket::Driver.rack(socket, options)
+driver = WebSocket::Driver.server(socket, options)
 driver = WebSocket::Driver.client(socket, options)
 ```
 
 The `rack` method returns a driver chosen using the socket's `env`. The
-`client` method always returns a driver for the RFC version of the protocol
-with masking enabled on outgoing frames.
+`server` method returns a driver that will parse an HTTP request and then
+decide which driver to use for it using the `rack` method. The `client` method
+always returns a driver 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:
@@ -188,6 +244,12 @@ describing the error.
 Sets the callback block to execute when the socket becomes closed. The `event`
 object has `code` and `reason` attributes.
 
+#### `driver.set_header(name, value)`
+
+Sets a custom header to be sent as part of the handshake response, either from
+the server or from the client. Must be called before `start`, since this is
+when the headers are serialized and sent.
+
 #### `driver.start`
 
 Initiates the protocol by sending the handshake - either the response for a

data/examples/tcp_server.rb

@@ -0,0 +1,27 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'eventmachine'
+require 'websocket/driver'
+
+module Connection
+  def initialize
+    @driver = WebSocket::Driver.server(self)
+
+    @driver.on(:connect) { |e| @driver.start if WebSocket::Driver.websocket? @driver.env }
+    @driver.on(:message) { |e| @driver.frame(e.data) }
+    @driver.on(:close)   { |e| close_connection_after_writing }
+  end
+
+  def receive_data(data)
+    @driver.parse(data)
+  end
+
+  def write(data)
+    send_data(data)
+  end
+end
+
+EM.run {
+  EM.start_server('127.0.0.1', ARGV[0], Connection)
+}
+

data/lib/websocket/driver.rb

@@ -7,11 +7,13 @@
 require 'base64'
 require 'digest/md5'
 require 'digest/sha1'
-require 'net/http'
+require 'set'
 require 'stringio'
 require 'uri'
 
 module WebSocket
+  autoload :HTTP, File.expand_path('../http', __FILE__)
+
   class Driver
 
     root = File.expand_path('../driver', __FILE__)
@@ -35,17 +37,20 @@ module WebSocket
 
     STATES = [:connecting, :open, :closing, :closed]
 
-    class OpenEvent < Struct.new(nil) ; end
+    class ConnectEvent < Struct.new(nil) ; end
+    class OpenEvent    < Struct.new(nil) ; end
     class MessageEvent < Struct.new(:data) ; end
-    class CloseEvent < Struct.new(:code, :reason) ; end
+    class CloseEvent   < Struct.new(:code, :reason) ; end
 
     class ProtocolError < StandardError ; end
 
-    autoload :EventEmitter, root + '/event_emitter'
+    autoload :Client,       root + '/client'
     autoload :Draft75,      root + '/draft75'
     autoload :Draft76,      root + '/draft76'
+    autoload :EventEmitter, root + '/event_emitter'
+    autoload :Headers,      root + '/headers'
     autoload :Hybi,         root + '/hybi'
-    autoload :Client,       root + '/client'
+    autoload :Server,       root + '/server'
 
     include EventEmitter
     attr_reader :protocol, :ready_state
@@ -55,6 +60,7 @@ module WebSocket
 
       @socket      = socket
       @options     = options
+      @headers     = Headers.new
       @queue       = []
       @ready_state = 0
     end
@@ -64,6 +70,12 @@ module WebSocket
       STATES[@ready_state]
     end
 
+    def set_header(name, value)
+      return false unless @ready_state <= 0
+      @headers[name] = value
+      true
+    end
+
     def start
       return false unless @ready_state == 0
       @socket.write(handshake_response)
@@ -116,6 +128,10 @@ module WebSocket
       Client.new(socket, options.merge(:masking => true))
     end
 
+    def self.server(socket, options = {})
+      Server.new(socket, options.merge(:require_masking => true))
+    end
+
     def self.rack(socket, options = {})
       env = socket.env
       if env['HTTP_SEC_WEBSOCKET_VERSION']

data/lib/websocket/driver/client.rb

@@ -6,12 +6,15 @@ module WebSocket
         Base64.encode64((1..16).map { rand(255).chr } * '').strip
       end
 
+      attr_reader :status, :headers
+
       def initialize(socket, options = {})
         super
 
         @ready_state = -1
         @key         = Client.generate_key
         @accept      = Hybi.generate_accept(@key)
+        @http        = HTTP::Response.new
       end
 
       def version
@@ -27,17 +30,10 @@ module WebSocket
 
       def parse(buffer)
         return super if @ready_state > 0
-        message = []
-        buffer.each_byte do |data|
-          case @ready_state
-            when 0 then
-              @buffer << data
-              validate_handshake if @buffer[-4..-1] == [0x0D, 0x0A, 0x0D, 0x0A]
-            when 1 then
-              message << data
-          end
-        end
-        parse(message) if @ready_state == 1
+        @http.parse(buffer)
+        return fail_handshake('Invalid HTTP response') if @http.error?
+        validate_handshake if @http.complete?
+        parse(@http.body) if @ready_state == 1
       end
 
     private 
@@ -60,7 +56,7 @@ module WebSocket
           headers << "Sec-WebSocket-Protocol: #{@protocols * ', '}"
         end
 
-        (headers + ['', '']).join("\r\n")
+        (headers + [@headers.to_s, '']).join("\r\n")
       end
 
       def fail_handshake(message)
@@ -71,18 +67,17 @@ module WebSocket
       end
 
       def validate_handshake
-        data     = Driver.encode(@buffer)
-        @buffer  = []
-        response = Net::HTTPResponse.read_new(Net::BufferedIO.new(StringIO.new(data)))
+        @status  = @http.code
+        @headers = Headers.new(@http.headers)
 
-        unless response.code.to_i == 101
-          return fail_handshake("Unexpected response code: #{response.code}")
+        unless @http.code == 101
+          return fail_handshake("Unexpected response code: #{@http.code}")
         end
 
-        upgrade    = response['Upgrade'] || ''
-        connection = response['Connection'] || ''
-        accept     = response['Sec-WebSocket-Accept'] || ''
-        protocol   = response['Sec-WebSocket-Protocol'] || ''
+        upgrade    = @http['Upgrade'] || ''
+        connection = @http['Connection'] || ''
+        accept     = @http['Sec-WebSocket-Accept'] || ''
+        protocol   = @http['Sec-WebSocket-Protocol'] || ''
 
         if upgrade == ''
           return fail_handshake("'Upgrade' header is missing")

data/lib/websocket/driver/draft75.rb

@@ -71,6 +71,7 @@ module WebSocket
         upgrade << "Connection: Upgrade\r\n"
         upgrade << "WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
         upgrade << "WebSocket-Location: #{@socket.url}\r\n"
+        upgrade << @headers.to_s
         upgrade << "\r\n"
         upgrade
       end

data/lib/websocket/driver/draft76.rb

@@ -37,6 +37,7 @@ module WebSocket
         upgrade << "Connection: Upgrade\r\n"
         upgrade << "Sec-WebSocket-Origin: #{@socket.env['HTTP_ORIGIN']}\r\n"
         upgrade << "Sec-WebSocket-Location: #{@socket.url}\r\n"
+        upgrade << @headers.to_s
         upgrade << "\r\n"
         upgrade
       end

data/lib/websocket/driver/headers.rb

@@ -0,0 +1,42 @@
+module WebSocket
+  class Driver
+
+    class Headers
+      ALLOWED_DUPLICATES = %w[set-cookie set-cookie2 warning www-authenticate]
+
+      def initialize(received = {})
+        @raw   = received
+        @sent  = Set.new
+        @lines = []
+
+        @received = {}
+        @raw.each { |k,v| @received[HTTP.normalize_header(k)] = v }
+      end
+
+      def [](name)
+        @received[HTTP.normalize_header(name)]
+      end
+
+      def []=(name, value)
+        return if value.nil?
+        key = HTTP.normalize_header(name)
+        return unless @sent.add?(key) or ALLOWED_DUPLICATES.include?(key)
+        @lines << "#{name.strip}: #{value.to_s.strip}\r\n"
+      end
+
+      def inspect
+        @raw.inspect
+      end
+
+      def to_h
+        @raw.dup
+      end
+
+      def to_s
+        @lines.join('')
+      end
+    end
+
+  end
+end
+

data/lib/websocket/driver/hybi.rb

@@ -213,7 +213,7 @@ module WebSocket
           end
         end
 
-        (headers + ['','']).join("\r\n")
+        (headers + [@headers.to_s, '']).join("\r\n")
       end
 
       def shutdown(code, reason)

data/lib/websocket/driver/server.rb

@@ -0,0 +1,73 @@
+module WebSocket
+  class Driver
+
+    class Server < Driver
+      EVENTS = %w[open message error close]
+
+      def initialize(socket, options = {})
+        super
+        @http = HTTP::Request.new
+      end
+
+      def env
+        @http.complete? ? @http.env : nil
+      end
+
+      def url
+        return nil unless e = env
+
+        url  = "ws://#{e['HTTP_HOST']}"
+        url << e['PATH_INFO']
+        url << "?#{e['QUERY_STRING']}" unless e['QUERY_STRING'] == ''
+        url
+      end
+
+      %w[set_header start state frame text binary ping close].each do |method|
+        define_method(method) do |*args|
+          if @delegate
+            @delegate.__send__(method, *args)
+          else
+            @queue << [method, args]
+            true
+          end
+        end
+      end
+
+      def parse(buffer)
+        return @delegate.parse(buffer) if @delegate
+
+        @http.parse(buffer)
+        return fail_request('Invalid HTTP request') if @http.error?
+        return unless @http.complete?
+
+        @delegate = Driver.rack(self, @options)
+        @delegate.on(:open) { open }
+        EVENTS.each do |event|
+          @delegate.on(event) { |e| emit(event, e) }
+        end
+
+        emit(:connect, ConnectEvent.new)
+      end
+
+      def write(data)
+        @socket.write(data)
+      end
+
+    private
+
+      def fail_request
+        emit(:error, ProtocolError.new(message))
+        emit(:close, CloseEvent.new(Hybi::ERRORS[:protocol_error], message))
+      end
+
+      def open
+        @queue.each do |message|
+          @delegate.__send__(message[0], *message[1])
+        end
+        @queue = []
+      end
+    end
+
+  end
+end
+

data/lib/websocket/http.rb

@@ -0,0 +1,16 @@
+module WebSocket
+  module HTTP
+
+    root = File.expand_path('../http', __FILE__)
+
+    autoload :Headers,  root + '/headers'
+    autoload :Request,  root + '/request'
+    autoload :Response, root + '/response'
+
+    def self.normalize_header(name)
+      name.to_s.strip.downcase.gsub(/^http_/, '').gsub(/_/, '-')
+    end
+
+  end
+end
+

data/lib/websocket/http/headers.rb

@@ -0,0 +1,77 @@
+module WebSocket
+  module HTTP
+
+    module Headers
+      MAX_LINE_LENGTH = 4096
+      CR = 0x0D
+      LF = 0x0A
+
+      HEADER_LINE = /^([!#\$%&'\*\+\-\.\^_`\|~0-9a-z]+):\s*((?:\t|[\x20-\x7e])*?)\s*$/i
+
+      attr_reader :headers
+
+      def initialize
+        @buffer  = []
+        @headers = {}
+        @stage   = 0
+      end
+
+      def complete?
+        @stage == 2
+      end
+
+      def error?
+        @stage == -1
+      end
+
+      def parse(data)
+        data.each_byte do |byte|
+          if byte == LF and @stage < 2
+            @buffer.pop if @buffer.last == CR
+            if @buffer.empty?
+              complete if @stage == 1
+            else
+              result = case @stage
+                       when 0 then start_line(string_buffer)
+                       when 1 then header_line(string_buffer)
+                       end
+
+              if result
+                @stage = 1
+              else
+                error
+              end
+            end
+            @buffer = []
+          else
+            @buffer << byte if @stage >= 0
+            error if @stage < 2 and @buffer.size > MAX_LINE_LENGTH
+          end
+        end
+        @env['rack.input'] = StringIO.new(string_buffer) if @env
+      end
+
+    private
+
+      def complete
+        @stage = 2
+      end
+
+      def error
+        @stage = -1
+      end
+
+      def header_line(line)
+        return false unless parsed = line.scan(HEADER_LINE).first
+        @headers[HTTP.normalize_header(parsed[0])] = parsed[1].strip
+        true
+      end
+
+      def string_buffer
+        @buffer.pack('C*')
+      end
+    end
+
+  end
+end
+

data/lib/websocket/http/request.rb

@@ -0,0 +1,46 @@
+module WebSocket
+  module HTTP
+
+    class Request
+      include Headers
+
+      REQUEST_LINE     = /^([A-Z]+) +([\x21-\x7e]+) +(HTTP\/[0-9]\.[0-9])$/
+      REQUEST_TARGET   = /^(.*?)(\?(.*))?$/
+      RESERVED_HEADERS = %w[content-length content-type]
+
+      attr_reader :env
+
+    private
+
+      def start_line(line)
+        return false unless parsed = line.scan(REQUEST_LINE).first
+
+        target = parsed[1].scan(REQUEST_TARGET).first
+
+        @env = {
+          'REQUEST_METHOD' => parsed[0],
+          'SCRIPT_NAME'    => '',
+          'PATH_INFO'      => target[0],
+          'QUERY_STRING'   => target[2] || ''
+        }
+        true
+      end
+
+      def complete
+        super
+        @headers.each do |name, value|
+          rack_name = name.upcase.gsub(/-/, '_')
+          rack_name = "HTTP_#{rack_name}" unless RESERVED_HEADERS.include?(name)
+          @env[rack_name] = value
+        end
+        if host = @env['HTTP_HOST']
+          uri = URI.parse("http://#{host}")
+          @env['SERVER_NAME'] = uri.host
+          @env['SERVER_PORT'] = uri.port.to_s
+        end
+      end
+    end
+
+  end
+end
+

data/lib/websocket/http/response.rb

@@ -0,0 +1,30 @@
+module WebSocket
+  module HTTP
+
+    class Response
+      include Headers
+
+      STATUS_LINE = /^(HTTP\/[0-9]\.[0-9]) +([0-9]{3}) +(.*)$/
+
+      attr_reader :code
+
+      def [](name)
+        @headers[HTTP.normalize_header(name)]
+      end
+
+      def body
+        @buffer.pack('C*')
+      end
+
+    private
+
+      def start_line(line)
+        return false unless parsed = line.scan(STATUS_LINE).first
+        @code = parsed[1].to_i
+        true
+      end
+    end
+
+  end
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: websocket-driver
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,8 +9,24 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-04 00:00:00.000000000 Z
+date: 2013-05-12 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  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: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -56,14 +72,21 @@ files:
 - ext/websocket_mask/websocket_mask.c
 - ext/websocket_mask/WebsocketMaskService.java
 - ext/websocket_mask/extconf.rb
+- examples/tcp_server.rb
+- lib/websocket/http/request.rb
+- lib/websocket/http/headers.rb
+- lib/websocket/http/response.rb
+- lib/websocket/driver.rb
+- lib/websocket/http.rb
+- lib/websocket/driver/hybi/stream_reader.rb
+- lib/websocket/driver/utf8_match.rb
+- lib/websocket/driver/headers.rb
+- lib/websocket/driver/hybi.rb
+- lib/websocket/driver/server.rb
 - lib/websocket/driver/client.rb
 - lib/websocket/driver/draft75.rb
-- lib/websocket/driver/draft76.rb
 - lib/websocket/driver/event_emitter.rb
-- lib/websocket/driver/hybi/stream_reader.rb
-- lib/websocket/driver/hybi.rb
-- lib/websocket/driver/utf8_match.rb
-- lib/websocket/driver.rb
+- lib/websocket/driver/draft76.rb
 homepage: http://github.com/faye/websocket-driver-ruby
 licenses: []
 post_install_message: