libwebsocket 0.0.4

data/lib/libwebsocket/frame.rb

@@ -0,0 +1,67 @@
+module LibWebSocket
+  # Construct or parse a WebSocket frame.
+  #
+  # SYNOPSIS
+  #
+  #   # Create frame
+  #   frame = LibWebSocket::Frame.new('123')
+  #   frame.to_s # \x00123\xff
+  #
+  #   # Parse frames
+  #   frame = LibWebSocket::Frame.new
+  #   frame.append("123\x00foo\xff56\x00bar\xff789")
+  #   frame.next # =>  foo
+  #   frame.next # =>  bar
+  class Frame
+
+    def initialize(buffer = nil)
+      @buffer = buffer || ''
+    end
+
+    # Create new frame without modification of current
+    def new(buffer = nil)
+      self.class.new(buffer)
+    end
+
+    # Append a frame chunk.
+    # @example
+    #   frame.append("\x00foo")
+    #   frame.append("bar\xff")
+    def append(string = nil)
+      return unless string.is_a?(String)
+
+      @buffer += string
+
+      return self
+    end
+
+    # Return the next frame.
+    # @example
+    #   frame.append("\x00foo")
+    #   frame.append("\xff\x00bar\xff")
+    #
+    #   frame.next; # =>  foo
+    #   frame.next; # =>  bar
+    def next
+      return unless @buffer.slice!(/^[^\x00]*\x00(.*?)\xff/m)
+
+      string = $1
+      string.force_encoding('UTF-8') if string.respond_to?(:force_encoding)
+
+      return string
+    end
+
+    # Construct a WebSocket frame.
+    # @example
+    #   frame = LibWebSocket::Frame.new('foo')
+    #   frame.to_s # => \x00foo\xff
+    def to_s
+      ary = ["\x00", @buffer.dup, "\xff"]
+
+      ary.collect{ |s| s.force_encoding('UTF-8') if s.respond_to?(:force_encoding) }
+
+      return ary.join
+    end
+
+  end
+end

data/lib/libwebsocket/handshake.rb

@@ -0,0 +1,28 @@
+module LibWebSocket
+  # This is a base class for LibWebSocket::Handshake::Client and LibWebSocket::Handshake::Server.
+  class Handshake
+
+    autoload :Client, "#{File.dirname(__FILE__)}/handshake/client"
+    autoload :Server, "#{File.dirname(__FILE__)}/handshake/server"
+
+    attr_accessor :secure, :error
+
+    # Convert all hash keys to instance variables.
+    def initialize(hash = {})
+      hash.each do |k,v|
+        instance_variable_set("@#{k}",v)
+      end
+    end
+
+    # WebSocket request object.
+    def req
+      @req ||= Request.new
+    end
+
+    # WebSocket response object.
+    def res
+      @res ||= Response.new
+    end
+
+  end
+end

data/lib/libwebsocket/handshake/client.rb

@@ -0,0 +1,129 @@
+module LibWebSocket
+  class Handshake
+    # Construct or parse a client WebSocket handshake. This module is written for
+    # convenience, since using request and response directly requires the same code
+    # again and again.
+    #
+    # SYNOPSIS
+    #
+    #   h = LibWebSocket::Handshake::Client.new(:url => 'ws://example.com')
+    #
+    #   # Create request
+    #   h.to_s # GET /demo HTTP/1.1
+    #          # Upgrade: WebSocket
+    #          # Connection: Upgrade
+    #          # Host: example.com
+    #          # Origin: http://example.com
+    #          # Sec-WebSocket-Key1: 18x 6]8vM;54 *(5:  {   U1]8  z [  8
+    #          # Sec-WebSocket-Key2: 1_ tx7X d  <  nw  334J702) 7]o}` 0
+    #          #
+    #          # Tm[K T2u
+    #
+    #   # Parse server response
+    #   h.parse \<<EOF
+    #   HTTP/1.1 101 WebSocket Protocol Handshake
+    #   Upgrade: WebSocket
+    #   Connection: Upgrade
+    #   Sec-WebSocket-Origin: http://example.com
+    #   Sec-WebSocket-Location: ws://example.com/demo
+    #
+    #   fQJ,fN/4F4!~K~MH
+    #   EOF
+    #
+    #   h.error # Check if there were any errors
+    #   h.done? # Returns true
+    class Client < Handshake
+
+      attr_accessor :url
+
+      def initialize(hash = {})
+        super
+
+        self.set_url(self.url) if self.url
+      end
+
+      # Set or get WebSocket url.
+      # @see LibWebSocket::URL#initialize
+      # @example
+      #   handshake.url = 'ws://example.com/demo'
+      def url=(val)
+        self.set_url(val)
+
+        return self
+      end
+
+      # Parse server response
+      # @example
+      #   h.parse \<<EOF
+      #   HTTP/1.1 101 WebSocket Protocol Handshake
+      #   Upgrade: WebSocket
+      #   Connection: Upgrade
+      #   Sec-WebSocket-Origin: http://example.com
+      #   Sec-WebSocket-Location: ws://example.com/demo
+      #
+      #   fQJ,fN/4F4!~K~MH
+      #   EOF
+      def parse(opts)
+        req = self.req
+        res = self.res
+
+        unless res.done?
+          unless res.parse(opts)
+            self.error = res.error
+            return
+          end
+
+          if res.done?
+            if req.version > 75 && req.checksum != res.checksum
+              self.error = 'Checksum is wrong.'
+              return
+            end
+          end
+        end
+
+        return true
+      end
+
+      # Check if response is correct
+      def done?
+        res.done?
+      end
+
+      # Create request
+      # @example
+      #   h.to_s # GET /demo HTTP/1.1
+      #          # Upgrade: WebSocket
+      #          # Connection: Upgrade
+      #          # Host: example.com
+      #          # Origin: http://example.com
+      #          # Sec-WebSocket-Key1: 18x 6]8vM;54 *(5:  {   U1]8  z [  8
+      #          # Sec-WebSocket-Key2: 1_ tx7X d  <  nw  334J702) 7]o}` 0
+      #          #
+      #          # Tm[K T2u
+      def to_s
+        req.to_s
+      end
+
+      protected
+
+      def build_url
+        LibWebSocket::URL.new
+      end
+
+      def set_url(url)
+        @url = self.build_url.parse(url) unless url.is_a?(LibWebSocket::URL)
+
+        req = self.req
+
+        host = @url.host
+        host += ':' + @url.port if @url.port
+        req.host = host
+
+        req.resource_name = @url.resource_name
+
+        return self
+      end
+
+    end
+  end
+end

data/lib/libwebsocket/handshake/server.rb

@@ -0,0 +1,114 @@
+module LibWebSocket
+  class Handshake
+    # Construct or parse a server WebSocket handshake. This module is written for
+    # convenience, since using request and response directly requires the same code
+    # again and again.
+    #
+    # SYNOPSIS
+    #
+    #   h = LibWebSocket::Handshake::Server.new
+    #
+    #   # Parse client request
+    #   h.parse \<<EOF
+    #   GET /demo HTTP/1.1
+    #   Upgrade: WebSocket
+    #   Connection: Upgrade
+    #   Host: example.com
+    #   Origin: http://example.com
+    #   Sec-WebSocket-Key1: 18x 6]8vM;54 *(5:  {   U1]8  z [  8
+    #   Sec-WebSocket-Key2: 1_ tx7X d  <  nw  334J702) 7]o}` 0
+    #
+    #   Tm[K T2u
+    #   EOF
+    #
+    #   h.error  # Check if there were any errors
+    #   h.idone? # Returns true
+    #
+    #   # Create response
+    #   h.to_s # HTTP/1.1 101 WebSocket Protocol Handshake
+    #          # Upgrade: WebSocket
+    #          # Connection: Upgrade
+    #          # Sec-WebSocket-Origin: http://example.com
+    #          # Sec-WebSocket-Location: ws://example.com/demo
+    #          #
+    #          # fQJ,fN/4F4!~K~MH
+    class Server < Handshake
+
+      # Parse client request
+      # @example
+      #   h.parse \<<EOF
+      #   GET /demo HTTP/1.1
+      #   Upgrade: WebSocket
+      #   Connection: Upgrade
+      #   Host: example.com
+      #   Origin: http://example.com
+      #   Sec-WebSocket-Key1: 18x 6]8vM;54 *(5:  {   U1]8  z [  8
+      #   Sec-WebSocket-Key2: 1_ tx7X d  <  nw  334J702) 7]o}` 0
+      #
+      #   Tm[K T2u
+      #   EOF
+      def parse(opts)
+        req = self.req
+        res = self.res
+
+        unless req.done?
+          unless req.parse(opts)
+            self.error = req.error
+            return
+          end
+
+          if req.done?
+            res.version = req.version
+            res.host = req.host
+
+            # res.secure = req.secure
+            res.resource_name = req.resource_name
+            res.origin = req.origin
+
+            if req.version > 75
+              res.number1 = req.number1
+              res.number2 = req.number2
+              res.challenge = req.challenge
+            end
+          end
+        end
+
+        return true
+      end
+
+      # Check if request is correct and done
+      def done?
+        req.done?
+      end
+
+      # Create response in string format
+      # @example
+      #   h.to_s # HTTP/1.1 101 WebSocket Protocol Handshake
+      #          # Upgrade: WebSocket
+      #          # Connection: Upgrade
+      #          # Sec-WebSocket-Origin: http://example.com
+      #          # Sec-WebSocket-Location: ws://example.com/demo
+      #          #
+      #          # fQJ,fN/4F4!~K~MH
+      def to_s
+        res.to_s
+      end
+
+      # Create response in rack format
+      # @example
+      #   h.to_rack # [ 101,
+      #             # {
+      #             #   'Upgrade'                => 'WebSocket'
+      #             #   'Connection'             => 'Upgrade'
+      #             #   'Sec-WebSocket-Origin'   => 'http://example.com'
+      #             #   'Sec-WebSocket-Location' => 'ws://example.com/demo'
+      #             #   'Content-Length'         => 16
+      #             # },
+      #             # [ 'fQJ,fN/4F4!~K~MH' ] ]
+      def to_rack
+        res.to_rack
+      end
+
+    end
+  end
+end

data/lib/libwebsocket/message.rb

@@ -0,0 +1,167 @@
+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