cybrid_api_organization_ruby 0.129.1137 → 0.129.1138

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/lib/http/2/header/decompressor.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module HTTP2
+  module Header
+    # Responsible for decoding received headers and maintaining compression
+    # context of the opposing peer. Decompressor must be initialized with
+    # appropriate starting context based on local role: client or server.
+    class Decompressor
+      include Error
+      include BufferUtils
+
+      FORBIDDEN_HEADERS = %w[connection te].freeze
+
+      def initialize(settings = Settings.new)
+        @cc = EncodingContext.new(settings)
+      end
+
+      # Set dynamic table +size+ in EncodingContext
+      def table_size=(size)
+        @cc.table_size = size
+      end
+
+      # Decodes integer value from provided +buffer+.
+      def integer(buf, n)
+        limit = (1 << n) - 1
+        if n.zero?
+          i = 0
+          consumed = 0
+        else
+          i = buf.getbyte(0) & limit
+          consumed = 1
+        end
+
+        if i == limit
+          m = 0
+          while (byte = buf.getbyte(consumed))
+            i += ((byte & 127) << m)
+            m += 7
+            consumed += 1
+            break if byte.nobits?(128)
+          end
+        end
+
+        read_str(buf, consumed)
+        i
+      end
+
+      # Decodes string value from provided +buf+.
+      #
+      # raises CompressionError when input is malformed
+      def string(buf)
+        raise CompressionError, "invalid header block fragment" if buf.empty?
+
+        huffman = buf.getbyte(0).allbits?(0x80)
+        len = integer(buf, 7)
+        str = read_str(buf, len)
+        raise CompressionError, "string too short" unless str.bytesize == len
+
+        str = Huffman.decode(str) if huffman
+        str.force_encoding(Encoding::UTF_8)
+      end
+
+      # Decodes header command from provided +buf+.
+      def header(buf)
+        peek = buf.getbyte(0)
+
+        header_type, type = HEADREP.find do |_, desc|
+          mask = (peek >> desc[:prefix]) << desc[:prefix]
+          mask == desc[:pattern]
+        end
+
+        raise CompressionError unless header_type && type
+
+        header_name = integer(buf, type[:prefix])
+
+        case header_type
+        when :indexed
+          raise CompressionError if header_name.zero?
+
+          header_name -= 1
+
+          { type: header_type, name: header_name }
+        when :changetablesize
+          { type: header_type, name: header_name, value: header_name }
+        else
+          if header_name.zero?
+            header_name = string(buf)
+          else
+            header_name -= 1
+          end
+          header_value = string(buf)
+
+          { type: header_type, name: header_name, value: header_value }
+        end
+      end
+
+      # Decodes and processes header commands within provided +buf+.
+      def decode(buf, frame = nil)
+        list = [] #: Array[header_pair]
+        decoding_pseudo_headers = true
+        @cc.listen_on_table do
+          until buf.empty?
+            field, value = @cc.process(header(buf))
+            next if field.nil?
+
+            is_pseudo_header = field.start_with?(":")
+            if !decoding_pseudo_headers && is_pseudo_header
+              raise ProtocolError, "one or more pseudo headers encountered after regular headers"
+            end
+
+            decoding_pseudo_headers = is_pseudo_header
+            raise ProtocolError, "invalid header received: #{field}" if FORBIDDEN_HEADERS.include?(field)
+
+            if frame
+              case field
+              when ":status"
+                frame[:status] = Integer(value)
+              when ":method"
+                frame[:method] = value
+              when "content-length"
+                frame[:content_length] = Integer(value)
+              when "trailer"
+                (frame[:trailer] ||= []) << value
+              end
+            end
+            list << [field, value]
+          end
+        end
+        list
+      end
+    end
+  end
+end

data/vendor/bundle/ruby/4.0.0/gems/http-2-1.2.3/lib/http/2/header/encoding_context.rb

@@ -0,0 +1,313 @@
+# frozen_string_literal: true
+
+module HTTP2
+  # To decompress header blocks, a decoder only needs to maintain a
+  # dynamic table as a decoding context.
+  # No other state information is needed.
+  module Header
+    class EncodingContext
+      include Error
+
+      UPPER = /[[:upper:]]/.freeze
+
+      # @private
+      # Static table
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#appendix-A
+      STATIC_TABLE = [
+        [":authority",                  ""],
+        [":method",                     "GET"],
+        [":method",                     "POST"],
+        [":path",                       "/"],
+        [":path",                       "/index.html"],
+        [":scheme",                     "http"],
+        [":scheme",                     "https"],
+        [":status",                     "200"],
+        [":status",                     "204"],
+        [":status",                     "206"],
+        [":status",                     "304"],
+        [":status",                     "400"],
+        [":status",                     "404"],
+        [":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",            ""]
+      ].each(&:freeze).freeze
+
+      STATIC_TABLE_BY_FIELD =
+        STATIC_TABLE
+        .each_with_object({})
+        .with_index { |((field, value), hs), idx| (hs[field] ||= []) << [idx, value].freeze }
+        .each_value(&:freeze)
+        .freeze
+
+      STATIC_TABLE_SIZE = STATIC_TABLE.size
+
+      STATIC_ALL = %i[all static].freeze
+
+      STATIC_NEVER = %i[never static].freeze
+
+      # Current table of header key-value pairs.
+      attr_reader :table
+
+      # Current encoding settings
+      attr_reader :settings
+
+      # Current table size in octets
+      attr_reader :current_table_size
+
+      # Initializes compression context with appropriate client/server
+      # +settings+ and maximum size of the dynamic table.
+      def initialize(settings = Settings.new)
+        @table = []
+        @table_by_field = Hash.new { |hs, k| hs[k] = [] }
+        @unshifts = 0
+        @settings = settings
+        @limit = settings.table_size
+        @_table_updated = false
+        @current_table_size = 0
+      end
+
+      # Duplicates current compression context
+      def dup
+        other = EncodingContext.new(@settings)
+        t = @table
+        tbf = @table_by_field.transform_values(&:dup)
+        unshifts = @unshifts
+        l = @limit
+        other.instance_eval do
+          @table = t.dup # shallow copy
+          @table_by_field = tbf
+          @unshifts = unshifts
+          @limit = l
+        end
+        other
+      end
+
+      # Finds an entry in current dynamic table by +index+.
+      # Note that +index+ is zero-based in this module.
+      #
+      # If the +index+ is greater than the last index in the static table,
+      # an entry in the dynamic table is dereferenced.
+      #
+      # If the +index+ is greater than the last header index, an error is raised.
+      def dereference(index)
+        # NOTE: index is zero-based in this module.
+        return STATIC_TABLE[index] if index < STATIC_TABLE_SIZE
+
+        idx = index - STATIC_TABLE_SIZE
+
+        raise CompressionError, "Index too large" if idx >= @table.size
+
+        @table[index - STATIC_TABLE_SIZE]
+      end
+
+      # Header Block Processing
+      # - http://tools.ietf.org/html/draft-ietf-httpbis-header-compression-10#section-4.1
+      def process(cmd)
+        type = cmd[:type]
+        name = cmd[:name]
+        value = cmd[:value]
+
+        case type
+        when :changetablesize
+          raise CompressionError, "tried to change table size after adding elements to table" if @_table_updated
+
+          # we can receive multiple table size change commands inside a header frame. However,
+          # we should blow up if we receive another frame where the new table size is bigger.
+          table_size_updated = @limit != @settings.table_size
+
+          raise CompressionError, "dynamic table size update exceed limit" if !table_size_updated && value > @limit
+
+          self.table_size = value
+
+          nil
+        when :indexed
+          # Indexed Representation
+          # An _indexed representation_ entails the following actions:
+          # o  The header field corresponding to the referenced entry in either
+          # the static table or dynamic table is added to the decoded header
+          # list.
+          dereference(name)
+        when :incremental, :noindex, :neverindexed
+          # A _literal representation_ that is _not added_ to the dynamic table
+          # entails the following action:
+          # o  The header field is added to the decoded header list.
+
+          # A _literal representation_ that is _added_ to the dynamic table
+          # entails the following actions:
+          # o  The header field is added to the decoded header list.
+          # o  The header field is inserted at the beginning of the dynamic table.
+
+          case name
+          when Integer
+            name, v = dereference(name)
+
+            value ||= v
+          when UPPER
+            raise ProtocolError, "Invalid uppercase key: #{name}"
+          end
+
+          emit = [name, value]
+
+          # add to table
+          cmdsize = name.bytesize + value.bytesize + 32
+          if type == :incremental && size_check?(cmdsize)
+            @table.unshift(emit)
+            @unshifts += 1
+            @table_by_field[name].unshift([value, @unshifts])
+            @current_table_size += cmdsize
+            @_table_updated = true
+          end
+
+          emit
+        else
+          raise CompressionError, "Invalid type: #{type}"
+        end
+      end
+
+      # Plan +headers+ compression.
+      def encode(headers)
+        # Literals commands are marked with :noindex when index is not used
+        noindex = STATIC_NEVER.include?(@settings.index)
+
+        headers.each do |field, value|
+          # Literal header names MUST be translated to lowercase before
+          # encoding and transmission.
+          field = field.downcase if UPPER.match?(field)
+          value = "/" if field == ":path" && value.empty?
+          cmd = addcmd(field, value)
+          cmd[:type] = :noindex if noindex && cmd[:type] == :incremental
+          process(cmd)
+          yield cmd
+        end
+      end
+
+      # Emits command for a +field+/+value+ header.
+      # Prefer static table over dynamic table.
+      # Prefer exact match over name-only match.
+      #
+      def addcmd(field, value)
+        # @type var exact: Integer?
+        exact = nil
+        # @type var name_only: Integer?
+        name_only = nil
+
+        index_type = @settings.index
+
+        if STATIC_ALL.include?(index_type) &&
+           STATIC_TABLE_BY_FIELD.key?(field)
+          STATIC_TABLE_BY_FIELD[field].each do |i, svalue|
+            name_only ||= i
+            if value == svalue
+              exact = i
+              break
+            end
+          end
+        end
+
+        if index_type == :all && !exact
+          field_entries = @table_by_field[field]
+
+          field_entries&.each do |hvalue, unshift_id|
+            abs_index = (@unshifts - unshift_id) + STATIC_TABLE_SIZE
+            name_only ||= abs_index
+            if value == hvalue
+              exact = abs_index
+              break
+            end
+          end
+        end
+
+        if exact
+          { name: exact, type: :indexed }
+        else
+          { name: name_only || field, value: value, type: :incremental }
+        end
+      end
+
+      # Alter dynamic table size.
+      #  When the size is reduced, some headers might be evicted.
+      def table_size=(size)
+        @limit = size
+        resize_table(0)
+      end
+
+      def listen_on_table
+        yield
+      ensure
+        @_table_updated = false
+      end
+
+      private
+
+      def resize_table(cmdsize)
+        return if @table.empty?
+
+        while @current_table_size + cmdsize > @limit
+          name, value = @table.pop
+          @current_table_size -= name.bytesize + value.bytesize + 32
+
+          field_arr = @table_by_field[name]
+          field_arr.pop
+          @table_by_field.delete(name) if field_arr.empty?
+
+          break if @table.empty?
+
+        end
+      end
+
+      # whether +cmd+ fits in the dynamic table.
+      #
+      # To keep the dynamic table size lower than or equal to @limit,
+      # remove one or more entries at the end of the dynamic table.
+      def size_check?(cmdsize)
+        resize_table(cmdsize)
+        cmdsize <= @limit
+      end
+    end
+  end
+end