plum 0.0.3 → 0.1.0

data/lib/plum/frame_factory.rb

@@ -2,11 +2,19 @@ using Plum::BinaryString
 
 module Plum
   module FrameFactory
+    # Creates a RST_STREAM frame.
+    # @param stream_id [Integer] The stream ID.
+    # @param error_type [Symbol] The error type defined in RFC 7540 Section 7.
     def rst_stream(stream_id, error_type)
       payload = "".push_uint32(HTTPError::ERROR_CODES[error_type])
       Frame.new(type: :rst_stream, stream_id: stream_id, payload: payload)
     end
 
+    # Creates a GOAWAY frame.
+    # @param last_id [Integer] The biggest processed stream ID.
+    # @param error_type [Symbol] The error type defined in RFC 7540 Section 7.
+    # @param message [String] Additional debug data.
+    # @see RFC 7540 Section 6.8
     def goaway(last_id, error_type, message = "")
       payload = "".push_uint32((last_id || 0) | (0 << 31))
                   .push_uint32(HTTPError::ERROR_CODES[error_type])
@@ -14,15 +22,24 @@ module Plum
       Frame.new(type: :goaway, stream_id: 0, payload: payload)
     end
 
+    # Creates a SETTINGS frame.
+    # @param ack [Symbol] Pass :ack to create an ACK frame.
+    # @param args [Hash<Symbol, Integer>] The settings values to send.
     def settings(ack = nil, **args)
       payload = args.inject("") {|payload, (key, value)|
         id = Frame::SETTINGS_TYPE[key] or raise ArgumentError.new("invalid settings type")
         payload.push_uint16(id)
         payload.push_uint32(value)
       }
-      Frame.new(type: :settings, stream_id: 0, flags: [ack].compact, payload: payload)
+      Frame.new(type: :settings, stream_id: 0, flags: [ack], payload: payload)
     end
 
+    # Creates a PING frame.
+    # @overload ping(ack, payload)
+    #   @param ack [Symbol] Pass :ack to create an ACK frame.
+    #   @param payload [String] 8 bytes length data to send.
+    # @overload ping(payload = "plum\x00\x00\x00\x00")
+    #   @param payload [String] 8 bytes length data to send.
     def ping(arg1 = "plum\x00\x00\x00\x00", arg2 = nil)
       if !arg2
         raise ArgumentError.new("data must be 8 octets") if arg1.bytesize != 8
@@ -32,22 +49,39 @@ module Plum
       end
     end
 
+    # Creates a DATA frame.
+    # @param stream_id [Integer] The stream ID.
+    # @param payload [String] Payload.
+    # @param flags [Array<Symbol>] Flags.
     def data(stream_id, payload, *flags)
-      Frame.new(type: :data, stream_id: stream_id, flags: flags.compact, payload: payload.to_s)
+      Frame.new(type: :data, stream_id: stream_id, flags: flags, payload: payload)
     end
 
+    # Creates a DATA frame.
+    # @param stream_id [Integer] The stream ID.
+    # @param encoded [String] Headers.
+    # @param flags [Array<Symbol>] Flags.
     def headers(stream_id, encoded, *flags)
-      Frame.new(type: :headers, stream_id: stream_id, flags: flags.compact, payload: encoded)
+      Frame.new(type: :headers, stream_id: stream_id, flags: flags, payload: encoded)
     end
 
+    # Creates a PUSH_PROMISE frame.
+    # @param stream_id [Integer] The stream ID.
+    # @param new_id [Integer] The stream ID to create.
+    # @param encoded [String] Request headers.
+    # @param flags [Array<Symbol>] Flags.
     def push_promise(stream_id, new_id, encoded, *flags)
       payload = "".push_uint32(0 << 31 | new_id)
                   .push(encoded)
-      Frame.new(type: :push_promise, stream_id: stream_id, flags: flags.compact, payload: payload)
+      Frame.new(type: :push_promise, stream_id: stream_id, flags: flags, payload: payload)
     end
 
+    # Creates a CONTINUATION frame.
+    # @param stream_id [Integer] The stream ID.
+    # @param payload [String] Payload.
+    # @param flags [Array<Symbol>] Flags.
     def continuation(stream_id, payload, *flags)
-      Frame.new(type: :continuation, stream_id: stream_id, flags: flags.compact, payload: payload)
+      Frame.new(type: :continuation, stream_id: stream_id, flags: flags, payload: payload)
     end
   end
 end

data/lib/plum/frame_utils.rb

@@ -3,7 +3,6 @@ using Plum::BinaryString
 module Plum
   module FrameUtils
     # Splits the DATA frame into multiple frames if the payload size exceeds max size.
-    #
     # @param max [Integer] The maximum size of a frame payload.
     # @return [Array<Frame>] The splitted frames.
     def split_data(max)
@@ -18,7 +17,6 @@ module Plum
     end
 
     # Splits the HEADERS or PUSH_PROMISE frame into multiple frames if the payload size exceeds max size.
-    #
     # @param max [Integer] The maximum size of a frame payload.
     # @return [Array<Frame>] The splitted frames.
     def split_headers(max)
@@ -34,7 +32,6 @@ module Plum
     end
 
     # Parses SETTINGS frame payload. Ignores unknown settings type (see RFC7540 6.5.2).
-    #
     # @return [Hash<Symbol, Integer>] The parsed strings.
     def parse_settings
       settings = {}

data/lib/plum/hpack/constants.rb

@@ -3,7 +3,7 @@ module Plum
     # RFC7541 Appendix A
     # index is starting from 0
     STATIC_TABLE = [
-      [":authority"],
+      [":authority", ""],
       [":method", "GET"],
       [":method", "POST"],
       [":path", "/"],
@@ -19,52 +19,52 @@ module Plum
       [":status", "500"],
       ["accept-charset"],
       ["accept-encoding", "gzip, deflate"],
-      ["accept-language"],
-      ["accept-ranges"],
-      ["accept"],
-      ["access-control-allow-origin"],
-      ["age"],
-      ["allow"],
-      ["authorization"],
-      ["cache-control"],
-      ["content-disposition"],
-      ["content-encoding"],
-      ["content-language"],
-      ["content-length"],
-      ["content-location"],
-      ["content-range"],
-      ["content-type"],
-      ["cookie"],
-      ["date"],
-      ["etag"],
-      ["expect"],
-      ["expires"],
-      ["from"],
-      ["host"],
-      ["if-match"],
-      ["if-modified-since"],
-      ["if-none-match"],
-      ["if-range"],
-      ["if-unmodified-since"],
-      ["last-modified"],
-      ["link"],
-      ["location"],
-      ["max-forwards"],
-      ["proxy-authenticate"],
-      ["proxy-authorization"],
-      ["range"],
-      ["referer"],
-      ["refresh"],
-      ["retry-after"],
-      ["server"],
-      ["set-cookie"],
-      ["strict-transport-security"],
-      ["transfer-encoding"],
-      ["user-agent"],
-      ["vary"],
-      ["via"],
-      ["www-authenticate"],
-    ]
+      ["accept-language", ""],
+      ["accept-ranges", ""],
+      ["accept", ""],
+      ["access-control-allow-origin", ""],
+      ["age", ""],
+      ["allow", ""],
+      ["authorization", ""],
+      ["cache-control", ""],
+      ["content-disposition", ""],
+      ["content-encoding", ""],
+      ["content-language", ""],
+      ["content-length", ""],
+      ["content-location", ""],
+      ["content-range", ""],
+      ["content-type", ""],
+      ["cookie", ""],
+      ["date", ""],
+      ["etag", ""],
+      ["expect", ""],
+      ["expires", ""],
+      ["from", ""],
+      ["host", ""],
+      ["if-match", ""],
+      ["if-modified-since", ""],
+      ["if-none-match", ""],
+      ["if-range", ""],
+      ["if-unmodified-since", ""],
+      ["last-modified", ""],
+      ["link", ""],
+      ["location", ""],
+      ["max-forwards", ""],
+      ["proxy-authenticate", ""],
+      ["proxy-authorization", ""],
+      ["range", ""],
+      ["referer", ""],
+      ["refresh", ""],
+      ["retry-after", ""],
+      ["server", ""],
+      ["set-cookie", ""],
+      ["strict-transport-security", ""],
+      ["transfer-encoding", ""],
+      ["user-agent", ""],
+      ["vary", ""],
+      ["via", ""],
+      ["www-authenticate", ""],
+    ].freeze
 
     HUFFMAN_TABLE = [
       "1111111111000",
@@ -324,8 +324,8 @@ module Plum
       "111111111111111111111110000",
       "11111111111111111111101110",
       "111111111111111111111111111111"
-    ]
+    ].freeze
     
-    HUFFMAN_TABLE_INVERSED = HUFFMAN_TABLE.each_with_index.to_h
+    HUFFMAN_TABLE_INVERSED = HUFFMAN_TABLE.each_with_index.to_h.freeze
   end
 end

data/lib/plum/hpack/context.rb

@@ -16,8 +16,9 @@ module Plum
       end
 
       def store(name, value)
+        value = value.to_s
         @dynamic_table.unshift([name, value])
-        @size += name.bytesize + value.to_s.bytesize + 32
+        @size += name.bytesize + value.bytesize + 32
         evict
       end
 
@@ -34,7 +35,7 @@ module Plum
       end
 
       def search(name, value)
-        pr = proc {|n, v|
+        pr = proc { |n, v|
           n == name && (!value || v == value)
         }
 
@@ -47,7 +48,7 @@ module Plum
       def evict
         while @limit && @size > @limit
           name, value = @dynamic_table.pop
-          @size -= name.bytesize + value.to_s.bytesize + 32
+          @size -= name.bytesize + value.bytesize + 32
         end
       end
     end

data/lib/plum/hpack/decoder.rb

@@ -10,42 +10,47 @@ module Plum
       end
 
       def decode(str)
-        str = str.dup
         headers = []
-        headers << parse!(str) while str.size > 0
-        headers.compact
+        pos = 0
+        lpos = str.bytesize
+        while pos < lpos
+          l, succ = parse(str, pos)
+          pos += succ
+          headers << l if l
+        end
+        headers
       end
 
       private
-      def parse!(str)
-        first_byte = str.uint8
-        if first_byte >= 128 # 0b1XXXXXXX
-          parse_indexed!(str)
-        elsif first_byte >= 64 # 0b01XXXXXX
-          parse_indexing!(str)
-        elsif first_byte >= 32 # 0b001XXXXX
-          self.limit = read_integer!(str, 5)
-          nil
+      def parse(str, pos)
+        first_byte = str.getbyte(pos)
+        if first_byte >= 0x80 # 0b1XXXXXXX
+          parse_indexed(str, pos)
+        elsif first_byte >= 0x40 # 0b01XXXXXX
+          parse_indexing(str, pos)
+        elsif first_byte >= 0x20 # 0b001XXXXX
+          self.limit, succ = read_integer(str, pos, 5)
+          [nil, succ]
         else # 0b0000XXXX (without indexing) or 0b0001XXXX (never indexing)
-          parse_no_indexing!(str)
+          parse_no_indexing(str, pos)
         end
       end
 
-      def read_integer!(str, prefix_length)
-        first_byte = str.byteshift(1).uint8
-        raise HPACKError.new("integer: end of buffer") unless first_byte
+      def read_integer(str, pos, prefix_length)
+        raise HPACKError.new("integer: end of buffer") if str.empty?
+        first_byte = str.getbyte(pos)
 
-        mask = (1 << prefix_length) - 1
-        ret = first_byte & mask
-        return ret if ret < mask
+        mask = 1 << prefix_length
+        ret = first_byte % mask
+        return [ret, 1] if ret != mask - 1
 
         octets = 0
-        while next_value = str.byteshift(1).uint8
-          ret += (next_value & 0b01111111) << (7 * octets)
+        while next_value = str.uint8(pos + octets + 1)
+          ret += (next_value % 0x80) << (7 * octets)
           octets += 1
 
-          if next_value < 128
-            return ret
+          if next_value < 0x80
+            return [ret, 1 + octets]
           elsif octets == 4 # RFC 7541 5.1 tells us that we MUST have limitation. at least > 2 ** 28
             raise HPACKError.new("integer: too large integer")
           end
@@ -54,29 +59,32 @@ module Plum
         raise HPACKError.new("integer: end of buffer")
       end
 
-      def read_string!(str)
-        first_byte = str.uint8
-        raise HPACKError.new("string: end of buffer") unless first_byte
+      def read_string(str, pos)
+        raise HPACKError.new("string: end of buffer") if str.empty?
+        first_byte = str.uint8(pos)
 
-        huffman = (first_byte >> 7) == 1
-        length = read_integer!(str, 7)
-        bin = str.byteshift(length)
+        huffman = first_byte > 0x80
+        length, ilen = read_integer(str, pos, 7)
+        raise HTTPError.new("string: end of buffer") if str.bytesize < length
 
-        raise HTTPError.new("string: end of buffer") if bin.bytesize < length
-        bin = Huffman.decode(bin) if huffman
-        bin
+        bin = str.byteslice(pos + ilen, length)
+        if huffman
+          [Huffman.decode(bin), ilen + length]
+        else
+          [bin, ilen + length]
+        end
       end
 
-      def parse_indexed!(str)
+      def parse_indexed(str, pos)
         # indexed
         # +---+---+---+---+---+---+---+---+
         # | 1 |        Index (7+)         |
         # +---+---------------------------+
-        index = read_integer!(str, 7)
-        fetch(index)
+        index, succ = read_integer(str, pos, 7)
+        [fetch(index), succ]
       end
 
-      def parse_indexing!(str)
+      def parse_indexing(str, pos)
         # +---+---+---+---+---+---+---+---+
         # | 0 | 1 |      Index (6+)       |
         # +---+---+-----------------------+
@@ -96,20 +104,21 @@ module Plum
         # +---+---------------------------+
         # | Value String (Length octets)  |
         # +-------------------------------+
-        index = read_integer!(str, 6)
+        index, ilen = read_integer(str, pos, 6)
         if index == 0
-          name = read_string!(str)
+          name, nlen = read_string(str, pos + ilen)
         else
           name, = fetch(index)
+          nlen = 0
         end
 
-        val = read_string!(str)
+        val, vlen = read_string(str, pos + ilen + nlen)
         store(name, val)
 
-        [name, val]
+        [[name, val], ilen + nlen + vlen]
       end
 
-      def parse_no_indexing!(str)
+      def parse_no_indexing(str, pos)
         # +---+---+---+---+---+---+---+---+
         # | 0 | 0 | 0 |0,1|  Index (4+)   |
         # +---+---+-----------------------+
@@ -129,16 +138,17 @@ module Plum
         # +---+---------------------------+
         # | Value String (Length octets)  |
         # +-------------------------------+
-        index = read_integer!(str, 4)
+        index, ilen = read_integer(str, pos, 4)
         if index == 0
-          name = read_string!(str)
+          name, nlen = read_string(str, pos + ilen)
         else
           name, = fetch(index)
+          nlen = 0
         end
 
-        val = read_string!(str)
+        val, vlen = read_string(str, pos + ilen + nlen)
 
-        [name, val]
+        [[name, val], ilen + nlen + vlen]
       end
     end
   end

data/lib/plum/hpack/encoder.rb

@@ -14,8 +14,8 @@ module Plum
       def encode(headers)
         out = ""
         headers.each do |name, value|
-          name = name.to_s.b
-          value = value.to_s.b
+          name = name.to_s
+          value = value.to_s
           if index = search(name, value)
             out << encode_indexed(index)
           elsif index = search(name, nil)
@@ -59,10 +59,9 @@ module Plum
       def encode_half_indexed(index, value)
         if @indexing
           store(fetch(index)[0], value)
-          fb = encode_integer(index, 6)
-          fb.setbyte(0, fb.uint8 | 0b01000000)
+          fb = encode_integer(index, 6, 0b01000000)
         else
-          fb = encode_integer(index, 4)
+          fb = encode_integer(index, 4, 0b00000000)
         end
         fb << encode_string(value)
       end
@@ -71,27 +70,24 @@ module Plum
       # | 1 |        Index (7+)         |
       # +---+---------------------------+
       def encode_indexed(index)
-        s = encode_integer(index, 7)
-        s.setbyte(0, s.uint8 | 0b10000000)
-        s
+        encode_integer(index, 7, 0b10000000)
       end
 
-      def encode_integer(value, prefix_length)
+      def encode_integer(value, prefix_length, hmask)
         mask = (1 << prefix_length) - 1
-        out = ""
 
         if value < mask
-          out.push_uint8(value)
+          (value + hmask).chr.force_encoding(Encoding::BINARY)
         else
+          vals = [mask + hmask]
           value -= mask
-          out.push_uint8(mask)
           while value >= mask
-            out.push_uint8((value % 0b10000000) + 0b10000000)
-            value >>= 7
+            vals << (value % 0x80) + 0x80
+            value /= 0x80
           end
-          out.push_uint8(value)
+          vals << value
+          vals.pack("C*")
         end
-        out.force_encoding(Encoding::BINARY)
       end
 
       def encode_string(str)
@@ -105,14 +101,13 @@ module Plum
       end
 
       def encode_string_plain(str)
-        encode_integer(str.bytesize, 7) << str.force_encoding(Encoding::BINARY)
+        encode_integer(str.bytesize, 7, 0b00000000) << str
       end
 
       def encode_string_huffman(str)
         huffman_str = Huffman.encode(str)
-        lenstr = encode_integer(huffman_str.bytesize, 7)
-        lenstr.setbyte(0, lenstr.uint8(0) | 0b10000000)
-        lenstr.force_encoding(Encoding::BINARY) << huffman_str
+        lenstr = encode_integer(huffman_str.bytesize, 7, 0b10000000)
+        lenstr << huffman_str
       end
     end
   end

data/lib/plum/http_connection.rb

@@ -2,12 +2,28 @@ using Plum::BinaryString
 
 module Plum
   class HTTPConnection < Connection
-    def initialize(io, local_settings = {})
+    attr_reader :sock
+
+    def initialize(sock, local_settings = {})
       require "http/parser"
-      super
       @_headers = nil
       @_body = ""
       @_http_parser = setup_parser
+      @sock = sock
+      super(@sock.method(:write), local_settings)
+    end
+
+    # Starts communication with the peer. It blocks until the io is closed, or reaches EOF.
+    def run
+      while !@sock.closed? && !@sock.eof?
+        self << @sock.readpartial(1024)
+      end
+    end
+
+    # Closes the socket.
+    def close
+      super
+      @sock.close
     end
 
     private
@@ -56,7 +72,7 @@ module Plum
       resp << "Server: plum/#{Plum::VERSION}\r\n"
       resp << "\r\n"
 
-      io.write(resp)
+      @sock.write(resp)
     end
 
     def process_first_request

data/lib/plum/https_connection.rb

@@ -1,15 +1,31 @@
 module Plum
   class HTTPSConnection < Connection
-    def initialize(io, local_settings = {})
-      if io.respond_to?(:cipher) # OpenSSL::SSL::SSLSocket-like
-        if CIPHER_BLACKLIST.include?(io.cipher.first) # [cipher-suite, ssl-version, keylen, alglen]
-          self.on(:negotiated) {
+    attr_reader :sock
+
+    def initialize(sock, local_settings = {})
+      @sock = sock
+      super(@sock.method(:write), local_settings)
+    end
+
+    # Starts communication with the peer. It blocks until the io is closed, or reaches EOF.
+    def run
+      if @sock.respond_to?(:cipher) # OpenSSL::SSL::SSLSocket-like
+        if CIPHER_BLACKLIST.include?(@sock.cipher.first) # [cipher-suite, ssl-version, keylen, alglen]
+          on(:negotiated) {
             raise ConnectionError.new(:inadequate_security)
           }
         end
       end
 
+      while !@sock.closed? && !@sock.eof?
+        self << @sock.readpartial(1024)
+      end
+    end
+
+    # Closes the socket.
+    def close
       super
+      @sock.close
     end
 
     CIPHER_BLACKLIST = %w(
@@ -26,6 +42,6 @@ module Plum
       AECDH-NULL-SHA AECDH-RC4-SHA AECDH-DES-CBC3-SHA AECDH-AES128-SHA AECDH-AES256-SHA SRP-3DES-EDE-CBC-SHA SRP-RSA-3DES-EDE-CBC-SHA SRP-DSS-3DES-EDE-CBC-SHA SRP-AES-128-CBC-SHA SRP-RSA-AES-128-CBC-SHA
       SRP-DSS-AES-128-CBC-SHA SRP-AES-256-CBC-SHA SRP-RSA-AES-256-CBC-SHA SRP-DSS-AES-256-CBC-SHA ECDHE-ECDSA-AES128-SHA256 ECDHE-ECDSA-AES256-SHA384 ECDH-ECDSA-AES128-SHA256 ECDH-ECDSA-AES256-SHA384 ECDHE-RSA-AES128-SHA256 ECDHE-RSA-AES256-SHA384
       ECDH-RSA-AES128-SHA256 ECDH-RSA-AES256-SHA384 ECDH-ECDSA-AES128-GCM-SHA256 ECDH-ECDSA-AES256-GCM-SHA384 ECDH-RSA-AES128-GCM-SHA256 ECDH-RSA-AES256-GCM-SHA384
-    )
+    ).freeze
   end
 end