http-parser 1.0.0

data/lib/http-parser/types.rb

@@ -0,0 +1,312 @@
+
+module HttpParser
+    HTTP_MAX_HEADER_SIZE = (80 * 1024)
+
+    #
+    # These share a byte of data as a bitmap
+    #
+    TYPES = enum :http_parser_type, [
+        :request, 0, 
+        :response,
+        :both
+    ]
+    FLAG = {
+        :CHUNKED => 1 << 2,
+        :CONNECTION_KEEP_ALIVE => 1 << 3,
+        :CONNECTION_CLOSE => 1 << 4,
+        :TRAILING => 1 << 5,
+        :UPGRADE => 1 << 6,
+        :SKIPBODY => 1 << 7
+    }
+
+    #
+    # Request Methods
+    #
+    METHODS = enum :http_method, [
+        :DELETE, 0,
+        :GET,
+        :HEAD,
+        :POST,
+        :PUT,
+        # pathological
+        :CONNECT,
+        :OPTIONS,
+        :TRACE,
+        # webdav
+        :COPY,
+        :LOCK,
+        :MKCOL,
+        :MOVE,
+        :PROPFIND,
+        :PROPPATCH,
+        :SEARCH,
+        :UNLOCK,
+        # subversion
+        :REPORT,
+        :MKACTIVITY,
+        :CHECKOUT,
+        :MERGE,
+        # upnp
+        :MSEARCH,
+        :NOTIFY,
+        :SUBSCRIBE,
+        :UNSUBSCRIBE,
+        # RFC-5789
+        :PATCH,
+        :PURGE
+    ]
+
+
+    UrlFields = enum :http_parser_url_fields, [
+        :SCHEMA, 0,
+        :HOST,
+        :PORT,
+        :PATH,
+        :QUERY,
+        :FRAGMENT,
+        :USERINFO,
+        :MAX
+    ]
+
+
+    #
+    # Effectively this represents a request instance
+    #
+    class Instance < FFI::Struct
+        layout  :type_flags,     :uchar,
+                :state,          :uchar,
+                :header_state,   :uchar,
+                :index,          :uchar,
+
+                :nread,          :uint32,
+                :content_length, :int64,
+
+                # READ-ONLY
+                :http_major,     :ushort,
+                :http_minor,     :ushort,
+                :status_code,    :ushort, # responses only
+                :method,         :uchar,  # requests only
+                :error_upgrade,  :uchar,  # errno = first 7bits, upgrade = last bit
+
+                # PUBLIC
+                :data,           :pointer
+
+
+        def initialize(ptr = nil)
+            if ptr then super(ptr)
+            else
+                super()
+                self.type = :both
+            end
+
+            yield self if block_given?
+
+            ::HttpParser.http_parser_init(self, self.type) unless ptr
+        end
+
+        #
+        # Resets the parser.
+        #
+        # @param [:request, :response, :both] new_type
+        #   The new type for the parser.
+        #
+        def reset!(new_type = type)
+            ::HttpParser.http_parser_init(self, new_type)
+        end
+        alias reset reset!
+
+        #
+        # The type of the parser.
+        #
+        # @return [:request, :response, :both]
+        #   The parser type.
+        #
+        def type
+            TYPES[self[:type_flags] & 0x3]
+        end
+
+        #
+        # Sets the type of the parser.
+        #
+        # @param [:request, :response, :both] new_type
+        #   The new parser type.
+        #
+        def type=(new_type)
+            self[:type_flags] = (flags | TYPES[new_type])
+        end
+
+        #
+        # Flags for the parser.
+        #
+        # @return [Integer]
+        #   Parser flags.
+        #
+        def flags
+            (self[:type_flags] & 0xfc)
+        end
+
+        #
+        # The parsed HTTP major version number.
+        #
+        # @return [Integer]
+        #   The HTTP major version number.
+        #
+        def http_major
+            self[:http_major]
+        end
+
+        #
+        # The parsed HTTP minor version number.
+        #
+        # @return [Integer]
+        #   The HTTP minor version number.
+        #
+        def http_minor
+            self[:http_minor]
+        end
+
+        #
+        # The parsed HTTP version.
+        #
+        # @return [String]
+        #   The HTTP version.
+        #
+        def http_version
+            "%d.%d" % [self[:http_major], self[:http_minor]]
+        end
+
+        #
+        # The parsed HTTP response Status Code.
+        #
+        # @return [Integer]
+        #   The HTTP Status Code.
+        #
+        # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec6.html#sec6.1.1
+        #
+        def http_status
+            self[:status_code]
+        end
+
+        #
+        # The parsed HTTP Method.
+        #
+        # @return [Symbol]
+        #   The HTTP Method name.
+        #
+        # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec5.html#sec5.1.1
+        #
+        def http_method
+            METHODS[self[:method]]
+        end
+
+        #
+        # Determines whether the `Upgrade` header has been parsed.
+        #
+        # @return [Boolean]
+        #   Specifies whether the `Upgrade` header has been seen.
+        #
+        # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.42
+        #
+        def upgrade?
+            (self[:error_upgrade] & 0b10000000) > 0
+        end
+
+        #
+        # Determines whether an error occurred during processing.
+        #
+        # @return [Boolean]
+        #   Did a parsing error occur with the request?
+        #
+        def error?
+            error = (self[:error_upgrade] & 0b1111111)
+            return error != 0
+        end
+
+        #
+        # Returns the error that occurred during processing.
+        #
+        # @return [StandarError]
+        #   Returns the error that occurred.
+        #
+        def error
+            error = (self[:error_upgrade] & 0b1111111)
+            return nil if error == 0
+
+            err = ::HttpParser.err_name(error)[4..-1] # HPE_ is at the start of all these errors
+            klass = ERRORS[err.to_sym]
+            err = "#{::HttpParser.err_desc(error)} (#{err})"
+            return klass.nil? ? Error::UNKNOWN.new(err) : klass.new(err)
+        end
+
+        #
+        # Additional data attached to the parser.
+        #
+        # @return [FFI::Pointer]
+        #   Pointer to the additional data.
+        #
+        def data
+            self[:data]
+        end
+
+        #
+        # Determines whether the `Connection: keep-alive` header has been
+        # parsed.
+        #
+        # @return [Boolean]
+        #   Specifies whether the Connection should be kept alive.
+        #
+        # @see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.10
+        #
+        def keep_alive?
+            ::HttpParser.http_should_keep_alive(self) > 0
+        end
+
+        #
+        # Halts the parser if called in a callback
+        #
+        def stop!
+            throw :return, 1
+        end
+
+        #
+        # Indicates an error has occurred when called in a callback
+        #
+        def error!
+            throw :return, -1
+        end
+    end
+
+    class FieldData < FFI::Struct
+        layout  :off,   :uint16,
+                :len,   :uint16
+    end
+
+    class HttpParserUrl < FFI::Struct
+        layout  :field_set,     :uint16,
+                :port,          :uint16,
+                :field_data,    [FieldData, UrlFields[:MAX]]
+    end
+
+
+    callback :http_data_cb, [Instance.ptr, :pointer, :size_t], :int
+    callback :http_cb,      [Instance.ptr], :int
+
+
+    class Settings < FFI::Struct
+        layout  :on_message_begin,    :http_cb,
+                :on_url,              :http_data_cb,
+                :on_status_complete,  :http_cb,
+                :on_header_field,     :http_data_cb,
+                :on_header_value,     :http_data_cb,
+                :on_headers_complete, :http_cb,
+                :on_body,             :http_data_cb,
+                :on_message_complete, :http_cb
+    end
+
+
+    attach_function :http_parser_init, [Instance.by_ref, :http_parser_type], :void, :blocking => true
+    attach_function :http_parser_execute, [Instance.by_ref, Settings.by_ref, :pointer, :size_t], :size_t, :blocking => true
+
+    attach_function :http_should_keep_alive, [Instance.by_ref], :int, :blocking => true
+    attach_function :http_method_str, [:http_method], :string, :blocking => true
+end

data/lib/http-parser/version.rb

@@ -0,0 +1,3 @@
+module HttpParser
+    VERSION = "1.0.0"
+end

data/spec/error_spec.rb

@@ -0,0 +1,45 @@
+require 'http-parser'
+
+describe HttpParser::Parser, "#initialize" do
+    before :each do
+        @inst = HttpParser::Parser.new_instance
+    end
+
+    it "should return true when no error" do
+        subject.parse(@inst, "GET / HTTP/1.1\r\n").should be_true
+        @inst.error?.should be_false
+    end
+
+    it "should return false on error" do
+        subject.parse(@inst, "GETS / HTTP/1.1\r\n").should be_false
+        @inst.error?.should be_true
+    end
+
+    it "the error should be inspectable" do
+        subject.parse(@inst, "GETS / HTTP/1.1\r\n").should be_false
+        @inst.error.should be_kind_of(::HttpParser::Error::INVALID_METHOD)
+        @inst.error?.should be_true
+    end
+
+    it "raises different error types depending on the error" do
+        subject.parse(@inst, "GET / HTTP/23\r\n").should be_false
+        @inst.error.should be_kind_of(::HttpParser::Error::INVALID_VERSION)
+        @inst.error?.should be_true
+    end
+
+    context "callback errors" do
+        subject do
+            described_class.new do |parser|
+                parser.on_url { |inst, data| raise 'unhandled' }
+            end
+        end
+
+        it "should handle unhandled errors gracefully" do
+            subject.parse(@inst, "GET /foo?q=1 HTTP/1.1").should be_false
+
+            @inst.error?.should be_true
+            @inst.error.should be_kind_of(::HttpParser::Error::CALLBACK)
+        end
+    end
+end
+

data/spec/instance_spec.rb

@@ -0,0 +1,98 @@
+require 'http-parser'
+
+describe ::HttpParser::Instance, "#initialize" do
+    context "when initialized from a pointer" do
+        it "should not call http_parser_init" do
+            ptr = described_class.new.to_ptr
+
+            ::HttpParser.should_not_receive(:http_parser_init)
+
+            described_class.new(ptr)
+        end
+    end
+
+    context "when given a block" do
+        it "should yield the new Instance" do
+            expected = nil
+
+            described_class.new { |inst| expected = inst }
+
+            expected.should be_kind_of(described_class)
+        end
+
+        it "should allow changing the parser type" do
+            inst = described_class.new do |inst|
+                inst.type = :request
+            end
+
+            inst.type.should == :request
+        end
+    end
+
+    describe "#type" do
+        it "should default to :both" do
+            subject.type.should == :both
+        end
+
+        it "should convert the type to a Symbol" do
+            subject[:type_flags] = ::HttpParser::TYPES[:request]
+
+            subject.type.should == :request
+        end
+
+        it "should extract the type from the type_flags field" do
+            subject[:type_flags] = ((0xff & ~0x3) | ::HttpParser::TYPES[:response])
+
+            subject.type.should == :response
+        end
+    end
+
+    describe "#type=" do
+        it "should set the type" do
+            subject.type = :response
+
+            subject.type.should == :response
+        end
+
+        it "should not change flags" do
+            flags = (0xff & ~0x3)
+            subject[:type_flags] = flags
+
+            subject.type = :request
+
+            subject[:type_flags].should == (flags | ::HttpParser::TYPES[:request])
+        end
+    end
+
+    describe "#stop!" do
+        it "should throw :return, 1" do
+            lambda { subject.stop! }.should throw_symbol(:return,1)
+        end
+    end
+
+    describe "#error!" do
+        it "should throw :return, -1" do
+            lambda { subject.error! }.should throw_symbol(:return,-1)
+        end
+    end
+
+    describe "#reset!" do
+        it "should call http_parser_init" do
+            inst = described_class.new
+
+            ::HttpParser.should_receive(:http_parser_init)
+
+            inst.reset!
+        end
+    end
+
+    it "should not change the type" do
+        inst = described_class.new do |inst|
+            inst.type = :request
+        end
+
+        inst.reset!
+        inst.type.should == :request
+    end
+end
+