ftw 0.0.6 → 0.0.7

data/lib/ftw/websocket/parser.rb

@@ -62,6 +62,8 @@ class FTW::WebSocket::Parser
   def transition(state, next_length)
     @logger.debug("Transitioning", :transition => state, :nextlen => next_length)
     @state = state
+    # TODO(sissel): Assert this self.respond_to?(state)
+    # TODO(sissel): Assert next_length is a number
     need(next_length)
   end # def transition
 
@@ -77,8 +79,7 @@ class FTW::WebSocket::Parser
     while have?(@need)
       value = send(@state)
       # Return if our state yields a value.
-      return value if !value.nil?
-      #yield value if !value.nil? and block_given?
+      yield value if !value.nil? and block_given?
     end
     return nil
   end # def <<
@@ -111,7 +112,7 @@ class FTW::WebSocket::Parser
     #    |I|S|S|S|  (4)  
     #    |N|V|V|V|       
     #    | |1|2|3|       
-    byte = get.bytes.first
+    byte = get(@need).bytes.first
     @opcode = byte & 0xF # last 4 bites
     @fin = (byte & 0x80 == 0x80)# first bit
 
@@ -127,8 +128,8 @@ class FTW::WebSocket::Parser
   # State: mask_and_payload_init
   # See: http://tools.ietf.org/html/rfc6455#section-5.2
   def mask_and_payload_init
-    byte = get.bytes.first
-    @mask = byte & 0x80 # first bit (msb)
+    byte = get(@need).bytes.first
+    @masked = (byte & 0x80) == 0x80 # first bit (msb)
     @payload_length = byte & 0x7F # remaining bits are the length
     case @payload_length
       when 126 # 2 byte, unsigned value is the payload length
@@ -136,9 +137,15 @@ class FTW::WebSocket::Parser
       when 127 # 8 byte, unsigned value is the payload length
         transition(:extended_payload_length, 8)
       else
-        # Keep the current payload length, a 7 bit value.
-        # Go to read the payload
-        transition(:payload, @payload_length)
+        # If there is a mask, read that next
+        if @masked
+          transition(:mask, 4)
+        else
+          # Otherwise, the payload is next.
+          # Keep the current payload length, a 7 bit value.
+          # Go to read the payload
+          transition(:payload, @payload_length)
+        end
     end # case @payload_length
 
     # This state yields no output.
@@ -149,7 +156,7 @@ class FTW::WebSocket::Parser
   # This is the 'extended payload length' with support for both 16 
   # and 64 bit lengths.
   # See: http://tools.ietf.org/html/rfc6455#section-5.2
-  def payload_length
+  def extended_payload_length
     #     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
     #    +-+-+-+-+-------+-+-------------+-------------------------------+
     #    |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
@@ -171,11 +178,27 @@ class FTW::WebSocket::Parser
         raise "Unknown payload_length byte length '#{@need}'"
     end
 
-    transition(:payload, @payload_length)
+    if @masked
+      # Read the mask next if there is one.
+      transition(:mask, 4)
+    else
+      # Otherwise, next is the payload
+      transition(:payload, @payload_length)
+    end
 
     # This state yields no output.
     return nil
-  end # def payload_length
+  end # def extended_payload_length
+
+  def mask
+    #    + - - - - - - - - - - - - - - - +-------------------------------+
+    #    |                               |Masking-key, if MASK set to 1  |
+    #    +-------------------------------+-------------------------------+
+    #    | Masking-key (continued)       |          Payload Data         |
+    #    +-------------------------------- - - - - - - - - - - - - - - - +
+    @mask = get(@need)
+    transition(:payload, @payload_length)
+  end # def mask
 
   # State: payload
   # Read the full payload and return it.
@@ -189,8 +212,24 @@ class FTW::WebSocket::Parser
     # thing. Have the consumer of this library make that decision.
     data = get(@need)
     transition(:flags_and_opcode, 1)
-    return data
+    if @masked
+      return unmask(data, @mask)
+    else
+      return data
+    end
   end # def payload
 
+  def unmask(message, key)
+    masked = []
+    mask_bytes = key.unpack("C4")
+    i = 0
+    message.each_byte do |byte|
+      masked << (byte ^ mask_bytes[i % 4])
+      i += 1
+    end
+    p :unmasked => masked.pack("C*"), :original => message
+    return  masked.pack("C*")
+  end # def mask
+
   public(:feed)
 end # class FTW::WebSocket::Parser

data/lib/ftw/websocket/rack.rb

@@ -0,0 +1,77 @@
+require "ftw/namespace"
+require "ftw/websocket/parser"
+require "base64" # stdlib 
+require "digest/sha1" # stdlib
+
+class FTW::WebSocket::Rack
+  include FTW::WebSocket::Constants
+
+  private
+
+  def initialize(rack_env)
+    @env = rack_env
+    @handshake_errors = []
+
+    # RFC6455 section 4.2.1 bullet 3
+    expect_equal("websocket", @env["HTTP_UPGRADE"],
+                 "The 'Upgrade' header must be set to 'websocket'")
+    # RFC6455 section 4.2.1 bullet 4
+    expect_equal("Upgrade", @env["HTTP_CONNECTION"],
+                 "The 'Connection' header must be set to 'Upgrade'")
+    # RFC6455 section 4.2.1 bullet 6
+    expect_equal("13", @env["HTTP_SEC_WEBSOCKET_VERSION"],
+                 "Sec-WebSocket-Version must be set to 13")
+
+    # RFC6455 section 4.2.1 bullet 5
+    @key = @env["HTTP_SEC_WEBSOCKET_KEY"] 
+
+    @parser = FTW::WebSocket::Parser.new
+  end # def initialize
+
+  def expect_equal(expected, actual, message)
+    if expected != actual
+      @handshake_errors << message
+    end
+  end # def expected
+
+  def valid?
+    return @handshake_errors.empty?
+  end # def valid?
+
+  def rack_response
+    if valid?
+      # Return the status, headers, body that is expected.
+      sec_accept = @key + WEBSOCKET_ACCEPT_UUID
+      sec_accept_hash = Digest::SHA1.base64digest(sec_accept)
+
+      headers = {
+        "Upgrade" => "websocket",
+        "Connection" => "Upgrade",
+        "Sec-WebSocket-Accept" => sec_accept_hash
+      }
+      # See RFC6455 section 4.2.2
+      return 101, headers, nil
+    else
+      # Invalid request, tell the client why.
+      return 400, { "Content-Type" => "text/plain" },
+        @handshake_errors.map { |m| "#{m}#{CRLF}" }
+    end
+  end # def rack_response
+
+  def each
+    connection = @env["ftw.connection"]
+    while true
+      data = connection.read(16384)
+      @parser.feed(data) do |payload|
+        yield payload if !payload.nil?
+      end
+    end
+  end # def each
+
+  def publish(message)
+    writer = FTW::WebSocket::Writer.singleton
+    writer.write_text(@env["ftw.connection"], message)
+  end # def publish
+
+  public(:initialize, :valid?, :rack_response, :each, :publish)
+end # class FTW::WebSocket::Rack

data/lib/ftw/websocket/writer.rb

@@ -0,0 +1,114 @@
+require "ftw/namespace"
+require "ftw/websocket"
+require "ftw/singleton"
+require "ftw/websocket/constants"
+
+# This class implements a writer for WebSocket messages over a stream.
+#
+# Protocol diagram copied from RFC6455
+#     0                   1                   2                   3
+#     0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+#    +-+-+-+-+-------+-+-------------+-------------------------------+
+#    |F|R|R|R| opcode|M| Payload len |    Extended payload length    |
+#    |I|S|S|S|  (4)  |A|     (7)     |             (16/64)           |
+#    |N|V|V|V|       |S|             |   (if payload len==126/127)   |
+#    | |1|2|3|       |K|             |                               |
+#    +-+-+-+-+-------+-+-------------+ - - - - - - - - - - - - - - - +
+#    |     Extended payload length continued, if payload len == 127  |
+#    + - - - - - - - - - - - - - - - +-------------------------------+
+#    |                               |Masking-key, if MASK set to 1  |
+#    +-------------------------------+-------------------------------+
+#    | Masking-key (continued)       |          Payload Data         |
+#    +-------------------------------- - - - - - - - - - - - - - - - +
+#    :                     Payload Data continued ...                :
+#    + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - +
+#    |                     Payload Data continued ...                |
+#    +---------------------------------------------------------------+
+
+class FTW::WebSocket::Writer
+  include FTW::WebSocket::Constants
+  extend FTW::Singleton
+
+  # 
+  VALID_MODES = [:server, :client]
+
+  private
+
+  # Write the given text in a websocket frame to the connection.
+  #
+  # Valid 'mode' settings are :server or :client. If :client, the
+  # payload will be masked according to RFC6455 section 5.3:
+  # http://tools.ietf.org/html/rfc6455#section-5.3
+  def write_text(connection, text, mode=:server)
+    if !VALID_MODES.include?(mode)
+      raise InvalidArgument.new("Invalid message mode: #{mode}, expected one of" \
+                                "#{VALID_MODES.inspect}")
+    end
+
+    data = []
+    pack = []
+
+    # For now, assume single-fragment, text frames
+    pack_opcode(data, pack, OPCODE_TEXT)
+    pack_payload(data, pack, text, mode)
+    connection.write(data.pack(pack.join("")))
+  end # def write_text
+
+  def pack_opcode(data, pack, opcode)
+    # Pack the first byte (fin + opcode)
+    data << ((1 << 7) | opcode)
+    pack << "C"
+  end # def pack_opcode
+
+  def pack_payload(data, pack, text, mode)
+    pack_maskbit_and_length(data, pack, text.length, mode)
+    pack_extended_length(data, pack, text.length) if text.length > 126
+    if mode == :client
+      mask_key = [rand(1 << 32)].pack("Q")
+      pack_mask(data, pack, mask_key)
+      data << mask(text, mask_key)
+      pack << "A*"
+    else
+      data << text
+      pack << "A*"
+    end
+  end # def pack_payload
+
+  # Implement masking as described by http://tools.ietf.org/html/rfc6455#section-5.3
+  # Basically, we take a 4-byte random string and use it, round robin, to XOR
+  # every byte. Like so:
+  #   message[0] ^ key[0]
+  #   message[1] ^ key[1]
+  #   message[2] ^ key[2]
+  #   message[3] ^ key[3]
+  #   message[4] ^ key[0]
+  #   ...
+  def mask(message, key)
+    masked = []
+    mask_bytes = key.unpack("C4")
+    i = 0
+    message.each_byte do |byte|
+      masked << (byte ^ mask_bytes[i % 4])
+      i += 1
+    end
+    return masked.pack("C*")
+  end # def mask
+
+  def pack_maskbit_and_length(data, pack, length, mode)
+    # Pack mask + payload length
+    maskbit = (mode == :client) ? (1 << 7) : 0
+    if length >= 126
+      if length < (1 << 16) # if less than 2^16, use 2 bytes
+        lengthbits = 126
+      else
+        lengthbits = 127
+      end
+    else
+      lengthbits = length
+    end
+    data << (maskbit | lengthbits)
+    pack << "C"
+  end
+
+  public(:initialize, :write_text)
+end # module FTW::WebSocket::Writer

data/lib/rack/handler/ftw.rb

@@ -0,0 +1,153 @@
+require "rack"
+require "ftw"
+require "ftw/protocol"
+require "ftw/crlf"
+require "socket"
+
+# FTW cannot fully respect the Rack 1.1 specification due to technical
+# limitations in the Rack design, specifically:
+#
+# * rack.input must be buffered, to support IO#rewind, for the duration of each
+#   request. This is not safe if that request is an HTTP Upgrade or a long
+#   upload.
+#
+# FTW::Connection does not implement #rewind. Need it? File a ticket.
+#
+# To support HTTP Upgrade, CONNECT, and protocol-switching features, this
+# server handler will set "ftw.connection" to the FTW::Connection related
+# to this request.
+#
+# The above data is based on the response to this ticket:
+#   https://github.com/rack/rack/issues/347
+class Rack::Handler::FTW
+  include FTW::Protocol
+  include FTW::CRLF
+
+  RACK_VERSION = [1,1]
+  REQUEST_METHOD = "REQUEST_METHOD".freeze
+  SCRIPT_NAME = "SCRIPT_NAME".freeze
+  PATH_INFO = "PATH_INFO".freeze
+  QUERY_STRING = "QUERY_STRING".freeze
+  SERVER_NAME = "SERVER_NAME".freeze
+  SERVER_PORT = "SERVER_PORT".freeze
+
+  RACK_DOT_VERSION = "rack.version".freeze
+  RACK_DOT_URL_SCHEME = "rack.url_scheme".freeze
+  RACK_DOT_INPUT = "rack.input".freeze
+  RACK_DOT_ERRORS = "rack.errors".freeze
+  RACK_DOT_MULTITHREAD = "rack.multithread".freeze
+  RACK_DOT_MULTIPROCESS = "rack.multiprocess".freeze
+  RACK_DOT_RUN_ONCE = "rack.run_once".freeze
+  FTW_DOT_CONNECTION = "ftw.connection".freeze
+
+  def self.run(app, config)
+    server = self.new(app, config)
+    server.run
+  end
+
+  private
+
+  def initialize(app, config)
+    @app = app
+    @config = config
+  end
+
+  def run
+    # {:environment=>"development", :pid=>nil, :Port=>9292, :Host=>"0.0.0.0",
+    #  :AccessLog=>[], :config=>"/home/jls/projects/ruby-ftw/examples/test.ru",
+    #  :server=>"FTW"}
+    #
+    # listen, pass connections off
+    #
+    # 
+    # """A Rack application is an Ruby object (not a class) that responds to
+    # call.  It takes exactly one argument, the environment and returns an
+    # Array of exactly three values: The status, the headers, and the body."""
+    #
+    server = FTW::Server.new([@config[:Host], @config[:Port]].join(":"))
+    server.each_connection do |connection|
+      Thread.new do
+        handle_connection(connection)
+      end
+    end
+  end # def run
+
+  def handle_connection(connection)
+    while true
+      begin
+        request = read_http_message(connection)
+        handle_request(request, connection)
+      rescue => e
+        puts e.inspect
+        puts e.backtrace
+        raise e
+      end
+    end
+    connection.disconnect("Fun")
+  end # def handle_connection
+
+  def handle_request(request, connection)
+    path, query = request.path.split("?", 2)
+    env = {
+      # CGI-like environment as required by the Rack SPEC version 1.1
+      REQUEST_METHOD => request.method,
+      SCRIPT_NAME => "/", # TODO(sissel): not totally sure what this really should be
+      PATH_INFO => path,
+      QUERY_STRING => query.nil? ? "" : query,
+      SERVER_NAME => "hahaha, no", # TODO(sissel): Set this
+      SERVER_PORT => "", # TODO(sissel): Set this
+
+      # Rack-specific environment, also required by Rack SPEC version 1.1
+      RACK_DOT_VERSION => RACK_VERSION,
+      RACK_DOT_URL_SCHEME =>  "http", # TODO(sissel): support https
+      RACK_DOT_INPUT => connection,
+      RACK_DOT_ERRORS => STDERR,
+      RACK_DOT_MULTITHREAD => true,
+      RACK_DOT_MULTIPROCESS => false,
+      RACK_DOT_RUN_ONCE => false,
+
+      # Extensions, not in Rack v1.1. 
+
+      # ftw.connection lets you access the connection involved in this request.
+      # It should be used when you need to hijack the connection for use
+      # in proxying, HTTP CONNECT, websockets, SPDY(maybe?), etc.
+      FTW_DOT_CONNECTION => connection
+    }
+
+    request.headers.each do |name, value|
+      # The Rack spec says: 
+      # """ Variables corresponding to the client-supplied HTTP request headers
+      #     (i.e., variables whose names begin with HTTP_). The presence or
+      #     absence of these variables should correspond with the presence or
+      #     absence of the appropriate HTTP header in the request. """
+      #
+      # It doesn't specify how to translate the header names into this hash syntax.
+      # I looked at what Thin does, and it capitalizes and replaces dashes with 
+      # underscores, so I'll just copy that behavior. The specific code that implements
+      # this in thin is here:
+      # https://github.com/macournoyer/thin/blob/2e9db13e414ae7425/ext/thin_parser/thin.c#L89-L95
+      #
+      # The Rack spec also doesn't describe what should be done for headers
+      # with multiple values.
+      #
+      env["HTTP_#{name.upcase.gsub("-", "_")}"] = value
+    end # request.headers.each
+
+    status, headers, body = @app.call(env)
+
+    response = FTW::Response.new
+    response.status = status.to_i
+    response.version = request.version
+    headers.each do |name, value|
+      response.headers.add(name, value)
+    end
+    response.body = body
+
+    connection.write(response.to_s + CRLF)
+    body.each do |chunk|
+      connection.write(chunk)
+    end
+  end # def handle_request
+
+  public(:run, :initialize)
+end