libwebsocket 0.1.5 → 0.1.6

data/examples/thin_server.rb

@@ -1,69 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'rubygems'
-require 'thin'
-require File.expand_path(File.dirname(__FILE__) + '/../lib/libwebsocket')
-
-# This is required due to thin incompatibility with streamming of data
-module ThinExtension
-  def self.included(thin_conn)
-     thin_conn.class_eval do
-       alias :pre_process_without_websocket :pre_process
-       alias :pre_process :pre_process_with_websocket
-
-       alias :receive_data_without_websocket :receive_data
-       alias :receive_data :receive_data_with_websocket
-     end
-   end
-
-   attr_accessor :websocket_client
-
-   def pre_process_with_websocket
-     @request.env['async.connection'] = self
-     pre_process_without_websocket
-   end
-   def receive_data_with_websocket(data)
-     if self.websocket_client
-       self.websocket_client.receive_data(data)
-     else
-       receive_data_without_websocket(data)
-     end
-   end
-end
-
-::Thin::Connection.send(:include, ThinExtension)
-
-class EchoServer
-  def call(env)
-    @hs ||= LibWebSocket::OpeningHandshake::Server.new
-    @connection = env['async.connection']
-
-    if !@hs.done?
-      @hs.parse(env)
-
-      if @hs.done?
-        @connection.websocket_client = self
-        resp = @hs.to_rack
-        return resp
-      end
-
-      return
-    end
-  end
-
-  def receive_data(data)
-    @frame ||= LibWebSocket::Frame.new
-
-    @frame.append(data)
-
-    while message = @frame.next
-      @connection.send_data @frame.new(message).to_s
-    end
-  end
-end
-
-Thin::Server.start('127.0.0.1', 8080) do
-  map '/' do
-    run proc{ |env| EchoServer.new.call(env) }
-  end
-end

data/lib/libwebsocket/cookie.rb

@@ -1,60 +0,0 @@
-module LibWebSocket
-  #A base class for LibWebSocket::Cookie::Request and LibWebSocket::Cookie::Response.
-  class Cookie
-
-    autoload :Request,  "#{File.dirname(__FILE__)}/cookie/request"
-    autoload :Response, "#{File.dirname(__FILE__)}/cookie/response"
-
-    attr_accessor :pairs
-
-    TOKEN         = /[^;,\s"]+/ # Cookie token
-    NAME          = /[^;,\s"=]+/ # Cookie name
-    QUOTED_STRING = /"(?:\\"|[^"])+"/ # Cookie quoted value
-    VALUE         = /(?:#{TOKEN}|#{QUOTED_STRING})/ # Cookie unquoted value
-
-    def initialize(hash = {})
-      hash.each do |k,v|
-        instance_variable_set("@#{k}",v)
-      end
-    end
-
-    # Parse cookie string to array
-    def parse(string = nil)
-      self.pairs = []
-
-      return if string.nil? || string == ''
-
-      while string.slice!(/\s*(#{NAME})\s*(?:=\s*(#{VALUE}))?;?/)
-        attr, value = $1, $2
-        if !value.nil?
-          value.gsub!(/^"/, '')
-          value.gsub!(/"$/, '')
-          value.gsub!(/\\"/, '"')
-        end
-        self.pairs.push([attr, value])
-      end
-
-      return self
-    end
-
-    # Convert cookie array to string
-    def to_s
-      pairs = []
-
-      self.pairs.each do |pair|
-        string = ''
-        string += pair[0]
-
-        unless pair[1].nil?
-          string += '='
-          string += (!pair[1].match(/^#{VALUE}$/) ? "\"#{pair[1]}\"" : pair[1])
-        end
-
-        pairs.push(string)
-      end
-
-      return pairs.join("; ")
-    end
-
-  end
-end

data/lib/libwebsocket/cookie/request.rb

@@ -1,48 +0,0 @@
-module LibWebSocket
-  class Cookie
-    # Construct or parse a WebSocket request cookie.
-    class Request < Cookie
-
-      attr_accessor :name, :value, :version, :path, :domain
-
-      # Parse a WebSocket request cookie.
-      # @example
-      #   cookie = LibWebSocket::Cookie::Request.new
-      #   cookies = cookie.parse('$Version=1; foo="bar"; $Path=/; bar=baz; $Domain=.example.com')
-      def parse(string)
-        result = super
-        return unless result
-
-        cookies = []
-
-        pair = self.pairs.shift
-        version = pair[1]
-
-        cookie = nil
-        self.pairs.each do |pair|
-          next unless pair[0]
-
-          if pair[0].match(/^[^\$]/)
-            cookies.push(cookie) if cookie
-
-            cookie = self.build_cookie(:name => pair[0], :value => pair[1], :version => version)
-          elsif pair[0] == '$Path'
-            cookie.path = pair[1]
-          elsif pair[0] == '$Domain'
-            cookie.domain = pair[1]
-          end
-        end
-
-        cookies.push(cookie) if cookie
-
-        return cookies
-      end
-
-      protected
-
-      def build_cookie(hash)
-        self.class.new(hash)
-      end
-    end
-  end
-end

data/lib/libwebsocket/cookie/response.rb

@@ -1,44 +0,0 @@
-module LibWebSocket
-  class Cookie
-    # Construct or parse a WebSocket response cookie.
-    class Response < Cookie
-
-      attr_accessor :name, :value, :comment, :comment_url, :discard, :max_age, :path, :portlist, :secure
-
-      # Construct a WebSocket response cookie.
-      # @example
-      #   cookie = LibWebSocket::Cookie::Response.new(
-      #     :name    => 'foo',
-      #     :value   => 'bar',
-      #     :discard => 1,
-      #     :max_age => 0
-      #   )
-      #   cookie.to_s # foo=bar; Discard; Max-Age=0; Version=1
-      def to_s
-        pairs = []
-
-        pairs.push([self.name, self.value])
-
-        pairs.push ['Comment', self.comment] if self.comment
-        pairs.push ['CommentURL', self.comment_url] if self.comment_url
-        pairs.push ['Discard'] if self.discard
-        pairs.push ['Max-Age', self.max_age] if self.max_age
-        pairs.push ['Path', self.path] if self.path
-
-        if self.portlist
-          self.portlist = Array(self.portlist)
-          list          = self.portlist.join(' ')
-          pairs.push ['Port', "\"#{list}\""]
-        end
-
-        pairs.push ['Secure'] if self.secure
-        pairs.push ['Version', '1']
-
-        self.pairs = pairs
-
-        super
-      end
-
-    end
-  end
-end

data/lib/libwebsocket/message.rb

@@ -1,167 +0,0 @@
-require 'digest/md5'
-
-module LibWebSocket
-  # A base class for LibWebSocket::Request and LibWebSocket::Response.
-  class Message
-    include Stateful
-
-    attr_accessor :fields, :error, :subprotocol, :host, :origin, :version, :number1, :number2, :challenge, :checksum
-
-    # A new instance of Message.
-    # Instance variables will be set from hash.
-    # @example
-    #   msg = LibMessage.new( :host => 'example.org' )
-    #   msg.host # => 'example.org'
-    def initialize(hash = {})
-      hash.each do |k,v|
-        instance_variable_set("@#{k}",v)
-      end
-
-      @version ||= 76
-      @buffer = ''
-      @fields ||= {}
-      @max_message_size ||= 2048
-      @cookies ||= []
-      @state = 'first_line'
-    end
-
-    # Alias for fields.
-    # Use this instead of fields directly to preserve normalization(lowercase etc.)
-    def field(f, val = nil)
-      name = f.downcase
-
-      return self.fields[name] unless val
-
-      self.fields[name] = val
-
-      return self
-    end
-
-    # Set state to 'error' and write error message
-    def error=(val)
-      @error = val
-      self.state = 'error'
-    end
-
-    # Calculate Draft 76 checksum
-    def checksum
-      return @checksum if @checksum
-
-      raise 'number1 is required'   unless self.number1
-      raise 'number2 is required'   unless self.number2
-      raise 'challenge is required' unless self.challenge
-
-      checksum = ''
-      checksum += [self.number1].pack('N')
-      checksum += [self.number2].pack('N')
-      checksum += self.challenge
-      checksum = Digest::MD5.digest(checksum)
-
-      return @checksum ||= checksum
-    end
-
-    # Parse string
-    # @see LibWebSocket::Request#parse
-    # @see LibWebSocket::Response#parse
-    def parse(string)
-      return unless string.is_a?(String)
-
-      return if self.error
-
-      return unless self.append(string)
-
-      while(!self.state?('body') && line = self.get_line)
-        if self.state?('first_line')
-          return unless self.parse_first_line(line)
-
-          self.state = 'fields'
-        elsif line != ''
-          return unless self.parse_field(line)
-        else
-          self.state = 'body'
-          break
-        end
-      end
-
-      return true unless self.state?('body')
-
-      rv = self.parse_body
-      return unless rv
-
-      # Need more data
-      return rv unless rv != true
-
-      return self.done
-    end
-
-    protected
-
-    def number(name, key, value = nil)
-      if value
-        return self.instance_variable_set("@#{name}", value)
-      end
-
-      return self.instance_variable_get("@#{name}") if self.instance_variable_get("@#{name}")
-
-      return self.instance_variable_set("@#{name}", self.extract_number(self.send(key)))
-    end
-
-    def extract_number(key)
-      number = ''
-      while key.slice!(/(\d)/)
-        number += $1
-      end
-      number = number.to_i
-
-      spaces = 0
-      while key.slice!(/ /)
-        spaces += 1
-      end
-
-      return if spaces == 0
-
-      return (number / spaces).to_i
-    end
-
-    def append(data)
-      return if self.error
-
-      @buffer += data
-
-      if @buffer.length > @max_message_size
-        self.error = 'Message is too long'
-        return
-      end
-
-      return self
-    end
-
-    def get_line
-      if @buffer.slice!(/\A(.*?)\x0d?\x0a/)
-        return $1
-      end
-      return
-    end
-
-    def parse_first_line(line)
-      self
-    end
-
-    def parse_field(line)
-      name, value = line.split(': ', 2)
-      unless name && value
-        self.error = 'Invalid field'
-        return
-      end
-
-      self.field(name, value)
-
-      return self
-    end
-
-    def parse_body
-      self
-    end
-
-  end
-end

data/lib/libwebsocket/request.rb

@@ -1,288 +0,0 @@
-module LibWebSocket
-  # Construct or parse a WebSocket request.
-  class Request < Message
-
-    attr_accessor :cookies, :resource_name
-
-    # Parse a WebSocket request.
-    # @param [String] opts parse string
-    # @param [Hash] opts parse rack env hash
-    # @see Request#parse_rack_env
-    # @example Parser
-    #   req = LibWebSocket::Request.new
-    #   req.parse("GET /demo HTTP/1.1\x0d\x0a")
-    #   req.parse("Upgrade: WebSocket\x0d\x0a")
-    #   req.parse("Connection: Upgrade\x0d\x0a")
-    #   req.parse("Host: example.com\x0d\x0a")
-    #   req.parse("Origin: http://example.com\x0d\x0a")
-    #   req.parse("Sec-WebSocket-Key1: 18x 6]8vM;54 *(5:  {   U1]8  z [  8\x0d\x0a")
-    #   req.parse("Sec-WebSocket-Key2: 1_ tx7X d  <  nw  334J702) 7]o}` 0\x0d\x0a")
-    #   req.parse("\x0d\x0aTm[K T2u")
-    def parse(opts)
-      case opts
-      when String then super
-      when Hash then parse_rack_env(opts)
-      end
-    end
-
-    # Parse a WebSocket request.
-    # @param [Hash] env parse rack env hash
-    # @example Parser
-    #   req = LibWebSocket::Request.new
-    #   req.parse(env)
-    def parse_rack_env(env)
-      method = env['REQUEST_METHOD']
-      unless method == 'GET'
-        self.error = 'Wrong request method'
-        return false
-      end
-
-      self.resource_name = env['REQUEST_URI']
-
-      env.keys.select { |v| v =~ /\AHTTP\_/ }.each do |key|
-        self.field(key.gsub(/\AHTTP\_/, "").gsub('_','-'), env[key])
-      end
-
-      body = env['rack.input']
-      # Is compatible with rack.input spec?
-      unless body.respond_to?(:rewind) and body.respond_to?(:read)
-        self.error = "Invalid rack input"
-        return false
-      end
-
-      body.rewind
-      @buffer = body.read
-
-      rv = self.parse_body
-      return unless rv
-
-      # Need more data
-      return rv unless rv != true
-
-      return self.done
-    end
-
-    # A shortcut for self.field('Upgrade')
-    def upgrade
-      self.field('Upgrade')
-    end
-    # A shortcut for self.field('Connection')
-    def connection
-      self.field('Connection')
-    end
-
-    # Draft 76 number 1 reader
-    def number1
-      self.number('number1','key1')
-    end
-    # Draft 76 number 1 writter
-    def number1=(val)
-      self.number('number1','key1',val)
-    end
-    # Draft 76 number 2 reader
-    def number2
-      self.number('number2','key2')
-    end
-    # Draft 76 number 2 writter
-    def number2=(val)
-      self.number('number2','key2',val)
-    end
-    # Draft 76 Sec-WebSocket-Key1 reader
-    def key1
-      self.key('key1')
-    end
-    # Draft 76 Sec-WebSocket-Key1 writter
-    def key1=(val)
-      self.key('key1',val)
-    end
-    # Draft 76 Sec-WebSocket-Key2 reader
-    def key2
-      self.key('key2')
-    end
-    # Draft 76 Sec-WebSocket-Key2 writter
-    def key2=(val)
-      self.key('key2',val)
-    end
-
-    # Construct a WebSocket request.
-    #     # Constructor
-    #     my $req = Protocol::WebSocket::Request.new(
-    #         host          => 'example.com',
-    #         resource_name => '/demo'
-    #     );
-    #     $req.to_s # GET /demo HTTP/1.1
-    #               # Upgrade: WebSocket
-    #               # Connection: Upgrade
-    #               # Host: example.com
-    #               # Origin: http://example.com
-    #               # Sec-WebSocket-Key1: 32 0  3lD& 24+<    i u4  8! -6/4
-    #               # Sec-WebSocket-Key2: 2q 4  2  54 09064
-    #               #
-    #               # x#####
-    def to_s
-      string = ''
-
-      raise 'resource_name is required' unless self.resource_name
-      string += "GET " + self.resource_name + " HTTP/1.1\x0d\x0a"
-
-      string += "Upgrade: WebSocket\x0d\x0a"
-      string += "Connection: Upgrade\x0d\x0a"
-
-      raise 'Host is required' unless self.host
-      string += "Host: " + self.host + "\x0d\x0a"
-
-      origin = self.origin || 'http://' + self.host
-      string += "Origin: " + origin + "\x0d\x0a"
-
-      if self.version > 75
-        self.generate_keys
-
-        string += 'Sec-WebSocket-Protocol: ' + self.subprotocol + "\x0d\x0a" if self.subprotocol
-
-        string += 'Sec-WebSocket-Key1: ' + self.key1 + "\x0d\x0a"
-        string += 'Sec-WebSocket-Key2: ' + self.key2 + "\x0d\x0a"
-
-        string += 'Content-Length: ' + self.challenge.length.to_s + "\x0d\x0a"
-      else
-        string += 'WebSocket-Protocol: ' + self.subprotocol + "\x0d\x0a" if self.subprotocol
-      end
-
-      # TODO cookies
-
-      string += "\x0d\x0a"
-
-      string += self.challenge if self.version > 75
-
-      return string
-    end
-
-    protected
-
-    def parse_first_line(line)
-      req, resource_name, http = line.split(' ')
-
-      unless req && resource_name && http
-        self.error = 'Wrong request line'
-        return
-      end
-
-      unless req == 'GET' && http == 'HTTP/1.1'
-        self.error = 'Wrong method or http version'
-        return
-      end
-
-      self.resource_name = resource_name
-
-      return self
-    end
-
-    def parse_body
-      if self.key1 && self.key2
-        return true if @buffer.length < 8
-
-        challenge = @buffer.slice!(0..7)
-        self.challenge = challenge
-      else
-        self.version = 75
-      end
-
-      if @buffer.length > 0
-        self.error = 'Leftovers'
-        return
-      end
-
-      return self if self.finalize
-
-      self.error = 'Not a valid request'
-      return
-    end
-
-    def key(name, value = nil)
-      unless value
-        if value = self.instance_variable_get("@#{name}")
-          self.field("Sec-WebSocket-" + name.capitalize, value)
-        end
-
-        return self.field("Sec-WebSocket-" + name.capitalize)
-      end
-
-      return self.field("Sec-WebSocket-" + name.capitalize, value)
-
-      return self
-    end
-
-    def generate_keys
-      unless self.key1
-        number, key = self.generate_key
-        self.number1 = number
-        self.key1 = key
-      end
-
-      unless self.key2
-        number, key = self.generate_key
-        self.number2 = number
-        self.key2 = key
-      end
-
-      self.challenge ||= self.generate_challenge
-
-      return self
-    end
-
-    NOISE_CHARS = ("\x21".."\x2f").to_a + ("\x3a".."\x7e").to_a # From spec
-
-    def generate_key
-      spaces = 1 + rand(12)
-      max = 4_294_967_295 / spaces
-      number = rand(max + 1)
-      key = (number * spaces).to_s
-      (1 + rand(12)).times do
-        char = NOISE_CHARS[rand(NOISE_CHARS.size)]
-        pos = rand(key.size + 1)
-        key[pos...pos] = char
-      end
-      spaces.times do
-        pos = 1 + rand(key.size - 1)
-        key[pos...pos] = " "
-      end
-      return [number, key]
-    end
-
-    def generate_challenge
-      challenge = ''
-      8.times do
-        challenge += rand(256).chr
-      end
-
-      return challenge
-    end
-
-    def finalize
-      return unless self.upgrade    && self.upgrade    == 'WebSocket'
-      return unless self.connection && self.connection == 'Upgrade'
-
-      origin = self.field('Origin')
-      return unless origin
-      self.origin = origin
-
-      host = self.field('Host')
-      return unless host
-      self.host = host
-
-      subprotocol = self.field('Sec-WebSocket-Protocol') || self.field('WebSocket-Protocol')
-      self.subprotocol = subprotocol if subprotocol
-
-      cookie = self.build_cookie
-      if cookies = cookie.parse(self.fields['cookie'])
-         self.cookies = cookies
-      end
-
-      return self
-    end
-
-    def build_cookie
-      Cookie::Request.new
-    end
-
-  end
-end