dns_json 0.1.0

data/lib/dns_json/rdata.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module DNSJSON
+  module RData
+    FORMATS = YAML.safe_load_file(File.expand_path("../../data/rdata_formats.yml", __dir__)).transform_values { |v| v.fetch("name").freeze }.freeze
+    NAMES = [2, 5, 12, 39].freeze
+    BASE32 = "0123456789ABCDEFGHIJKLMNOPQRSTUV"
+    class Cursor
+      attr_reader :position
+
+      def initialize(bytes, offset, length, max_pointers)
+        @bytes = bytes
+        @position = offset
+        @ending = offset + length
+        @max_pointers = max_pointers
+      end
+
+      def remaining = @ending - @position
+
+      def take(size = remaining)
+        raise ConversionError, "truncated RDATA" if size.negative? || @position + size > @ending || @position + size > @bytes.bytesize
+
+        result = @bytes.byteslice(@position, size)
+        @position += size
+        result
+      end
+
+      def u8 = take(1).unpack1("C")
+      def u16 = take(2).unpack1("n")
+      def u32 = take(4).unpack1("N")
+
+      def name
+        labels, count = Wire::Name.read(@bytes, @position, max_pointers: @max_pointers)
+        take(count)
+        Wire::Name.display(labels)
+      end
+
+      def strings
+        result = []
+        result << take(u8) until remaining.zero?
+        result
+      end
+    end
+
+    def self.decode(type, bytes, offset, length, max_pointers: 128)
+      return unless FORMATS.key?(type)
+
+      c = Cursor.new(bytes, offset, length, max_pointers)
+      result = case type
+               when 1, 28
+                 expected = type == 1 ? 4 : 16
+                 raise ConversionError, "invalid address length" unless length == expected
+
+                 IPAddr.new_ntoh(c.take).to_s
+               when *NAMES then c.name
+               when 16 then octets_text(c.strings.join)
+               when 99 then c.strings.map { |s| quote(s) }.join(" ")
+               when 15 then [c.u16, c.name].join(" ")
+               when 33 then [c.u16, c.u16, c.u16, c.name].join(" ")
+               when 25, 48, 60 then [c.u16, c.u8, c.u8, base64_encode(c.take)].join(" ")
+               when 43, 59 then [c.u16, c.u8, c.u8, DNSJSON.hex(c.take)].join(" ")
+               when 44 then [c.u8, c.u8, DNSJSON.hex(c.take)].join(" ")
+               when 52, 53 then [c.u8, c.u8, c.u8, DNSJSON.hex(c.take)].join(" ")
+               when 61 then base64_encode(c.take)
+               when 62 then [c.u32, c.u16, *bitmap_decode(c.take)].join(" ")
+               when 47 then [c.name, *bitmap_decode(c.take)].join(" ")
+               when 50, 51
+                 parts = [c.u8, c.u8, c.u16]
+                 salt = DNSJSON.hex(c.take(c.u8))
+                 parts << (salt.empty? ? "-" : salt)
+                 parts.push(base32_encode(c.take(c.u8)), *bitmap_decode(c.take)) if type == 50
+                 parts.join(" ")
+               when 46
+                 [Registry.type(c.u16), c.u8, c.u8, c.u32, timestamp(c.u32), timestamp(c.u32), c.u16, c.name,
+                  base64_encode(c.take)].join(" ")
+               when 45
+                 precedence = c.u8
+                 gateway_type = c.u8
+                 algorithm = c.u8
+                 gateway = case gateway_type
+                           when 0 then "."
+                           when 1 then IPAddr.new_ntoh(c.take(4)).to_s
+                           when 2 then IPAddr.new_ntoh(c.take(16)).to_s
+                           when 3 then c.name
+                           else raise ConversionError, "unknown IPSECKEY gateway type"
+                           end
+                 key = c.take
+                 [precedence, gateway_type, algorithm, gateway, key.empty? ? "." : base64_encode(key)].join(" ")
+               when 55
+                 hit_length = c.u8
+                 algorithm = c.u8
+                 key_length = c.u16
+                 parts = [algorithm, DNSJSON.hex(c.take(hit_length)), base64_encode(c.take(key_length))]
+                 parts << c.name until c.remaining.zero?
+                 parts.join(" ")
+               end
+      raise ConversionError, "excess RDATA" unless c.remaining.zero?
+
+      result
+    rescue ArgumentError, EncodingError => e
+      raise ConversionError, e.message
+    end
+
+    def self.encode(type, text)
+      raise ConversionError, "unsupported structured RDATA type" unless FORMATS.key?(type)
+      raise ConversionError, "RDATA must be a string" unless text.is_a?(String)
+      return address(text, type == 1 ? 4 : 16) if [1, 28].include?(type)
+      return Wire::Name.encode(text) if NAMES.include?(type)
+      return strings_encode([text_octets(text)]) if type == 16
+      return strings_encode(parse_strings(text)) if type == 99
+
+      parts = text.split(/\s+/)
+      result = case type
+               when 15 then integer(parts.shift, 16) + Wire::Name.encode(required(parts.shift))
+               when 33 then numbers(parts, 16, 16, 16) + Wire::Name.encode(required(parts.shift))
+               when 25, 48, 60 then numbers(parts, 16, 8, 8) + b64(parts)
+               when 43, 59 then numbers(parts, 16, 8, 8) + hex_tail(parts)
+               when 44 then numbers(parts, 8, 8) + hex_tail(parts)
+               when 52, 53 then numbers(parts, 8, 8, 8) + hex_tail(parts)
+               when 61 then b64(parts)
+               when 62 then numbers(parts, 32, 16) + bitmap_encode(parts.shift(parts.length))
+               when 47 then Wire::Name.encode(required(parts.shift)) + bitmap_encode(parts.shift(parts.length))
+               when 50, 51
+                 head = numbers(parts, 8, 8, 16)
+                 salt_text = required(parts.shift)
+                 salt = salt_text == "-" ? "".b : DNSJSON.unhex(salt_text.upcase)
+                 head += counted(salt)
+                 head += counted(base32_decode(required(parts.shift))) + bitmap_encode(parts.shift(parts.length)) if type == 50
+                 head
+               when 46
+                 head = integer(Registry.number(required(parts.shift)), 16) + numbers(parts, 8, 8, 32)
+                 head += integer(parse_time(parts.shift), 32) + integer(parse_time(parts.shift), 32) + numbers(parts, 16)
+                 head + Wire::Name.encode(required(parts.shift)) + b64(parts)
+               when 45
+                 gateway_type = parts[1]&.to_i
+                 head = numbers(parts, 8, 8, 8)
+                 gateway = required(parts.shift)
+                 head += case gateway_type
+                         when 0
+                           raise ConversionError, "gateway type 0 requires dot" unless gateway == "."
+
+                           "".b
+                         when 1 then address(gateway, 4)
+                         when 2 then address(gateway, 16)
+                         when 3 then Wire::Name.encode(gateway)
+                         else raise ConversionError, "unknown IPSECKEY gateway type"
+                         end
+                 key = if parts == ["."]
+                         (parts.clear
+                          "".b)
+                       else
+                         b64(parts)
+                       end
+                 head + key
+               when 55
+                 algorithm = integer(parts.shift, 8)
+                 hit = DNSJSON.unhex(required(parts.shift).upcase)
+                 key = base64_decode(required(parts.shift))
+                 integer(hit.bytesize, 8) + algorithm + integer(key.bytesize, 16) + hit + key + parts.shift(parts.length).map { |n|
+                   Wire::Name.encode(n)
+                 }.join.b
+               end
+      raise ConversionError, "excess RDATA fields" unless parts.empty?
+      raise ConversionError, "RDATA exceeds 65535 bytes" if result.bytesize > 65_535
+
+      result
+    rescue ArgumentError, EncodingError => e
+      raise ConversionError, e.message
+    end
+
+    def self.base64_encode(bytes) = [bytes].pack("m0")
+    def self.base64_decode(text) = text.unpack1("m0")
+
+    def self.required(value)
+      raise ConversionError, "missing RDATA field" if value.nil?
+
+      value
+    end
+
+    def self.integer(value, bits)
+      raise ConversionError, "invalid unsigned integer" unless required(value).to_s.match?(/\A\d+\z/)
+
+      value = value.to_i
+      raise ConversionError, "integer out of range" unless value.between?(0, (1 << bits) - 1)
+
+      [value].pack({ 8 => "C", 16 => "n", 32 => "N" }.fetch(bits))
+    end
+
+    def self.numbers(parts, *widths) = widths.map { |bits| integer(parts.shift, bits) }.join.b
+    def self.b64(parts) = base64_decode(parts.shift(parts.length).join)
+    def self.hex_tail(parts) = DNSJSON.unhex(parts.shift(parts.length).join.upcase)
+    def self.counted(bytes) = integer(bytes.bytesize, 8) + bytes
+
+    def self.address(text, length)
+      ip = IPAddr.new(text)
+      raise ConversionError, "wrong IP family or prefix" if text.include?("/") || ip.hton.bytesize != length
+
+      ip.hton
+    end
+
+    def self.octets_text(bytes) = bytes.force_encoding(Encoding::ISO_8859_1).encode(Encoding::UTF_8)
+    def self.text_octets(text) = text.encode(Encoding::ISO_8859_1).b
+
+    def self.strings_encode(strings)
+      strings.flat_map { |s| s.empty? ? ["".b] : s.bytes.each_slice(255).map { |v| v.pack("C*") } }.map { |s| counted(s) }.join.b
+    end
+
+    def self.quote(bytes)
+      content = bytes.bytes.map do |b|
+        if b.between?(32, 126)
+          [34, 92].include?(b) ? "\\#{b.chr}" : b.chr
+        else
+          format("\\%03d", b)
+        end
+      end.join
+      "\"#{content}\""
+    end
+
+    def self.parse_strings(text)
+      strings = []
+      current = nil
+      index = 0
+      while index < text.bytesize
+        byte = text.getbyte(index)
+        if current.nil?
+          if byte == 34 then current = +"".b
+          elsif ![9, 10, 13, 32].include?(byte) then raise ConversionError, "SPF strings must be quoted"
+          end
+        elsif byte == 34
+          strings << current
+          current = nil
+        elsif byte == 92
+          index += 1
+          digits = text.byteslice(index, 3)
+          raise ConversionError, "unfinished string escape" unless digits && !digits.empty?
+
+          if digits.match?(/\A\d{3}\z/)
+            raise ConversionError, "octet escape out of range" if digits.to_i > 255
+
+            current << digits.to_i
+            index += 2
+          else
+            current << text.getbyte(index)
+          end
+        else
+          current << byte
+        end
+        index += 1
+      end
+      raise ConversionError, "unclosed or missing SPF string" if current || strings.empty?
+
+      strings
+    end
+
+    def self.timestamp(value) = Time.at(value).utc.strftime("%Y%m%d%H%M%S")
+
+    def self.parse_time(text)
+      text = required(text)
+      return text if text.match?(/\A\d{1,10}\z/)
+      raise ConversionError, "invalid DNSSEC timestamp" unless text.match?(/\A\d{14}\z/)
+
+      time = Time.strptime("#{text} +0000", "%Y%m%d%H%M%S %z").utc
+      raise ConversionError, "invalid DNSSEC timestamp" unless timestamp(time.to_i) == text
+
+      time.to_i
+    end
+
+    def self.bitmap_decode(bytes)
+      types = []
+      offset = 0
+      previous = -1
+      while offset < bytes.bytesize
+        window, length = bytes.byteslice(offset, 2).unpack("CC")
+        raise ConversionError, "invalid type bitmap" unless length&.between?(1, 32) && window > previous && offset + 2 + length <= bytes.bytesize
+
+        bitmap = bytes.byteslice(offset + 2, length)
+        raise ConversionError, "noncanonical type bitmap" if bitmap.getbyte(length - 1).zero?
+
+        bitmap.bytes.each_with_index do |value, index|
+          8.times { |bit| types << Registry.type((window * 256) + (index * 8) + bit) unless value.nobits?(128 >> bit) }
+        end
+        previous = window
+        offset += length + 2
+      end
+      types
+    end
+
+    def self.bitmap_encode(names)
+      names.map { |n| Registry.number(n) }.uniq.sort.group_by { |n| n / 256 }.map do |window, values|
+        bitmap = Array.new(((values.last % 256) / 8) + 1, 0)
+        values.each { |n| bitmap[(n % 256) / 8] |= 128 >> (n % 8) }
+        [window, bitmap.length, *bitmap].pack("C*")
+      end.join.b
+    end
+
+    def self.base32_encode(bytes)
+      bits = bytes.unpack1("B*")
+      bits += "0" * ((5 - (bits.length % 5)) % 5)
+      bits.scan(/.{5}/).map { |b| BASE32[b.to_i(2)] }.join
+    end
+
+    def self.base32_decode(text)
+      raise ConversionError, "invalid base32hex" unless text.match?(/\A[0-9A-V]+\z/i)
+
+      bits = text.upcase.chars.map { |c| BASE32.index(c).to_s(2).rjust(5, "0") }.join
+      bytes = [bits[0, bits.length / 8 * 8]].pack("B*")
+      raise ConversionError, "noncanonical base32hex" unless base32_encode(bytes) == text.upcase
+
+      bytes
+    end
+  end
+end

data/lib/dns_json/registry.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DNSJSON
+  module Registry
+    TYPES = YAML.safe_load_file(File.expand_path("../../data/rr_types.yml", __dir__)).transform_values(&:freeze).freeze
+    CLASSES = { 1 => "IN", 3 => "CH", 4 => "HS" }.freeze
+    def self.type(number) = TYPES.fetch(number) { "TYPE#{number}" }
+    def self.klass(number) = CLASSES.fetch(number) { "CLASS#{number}" }
+
+    def self.number(text, kind = :type)
+      table, prefix = kind == :type ? [TYPES, "TYPE"] : [CLASSES, "CLASS"]
+      number = table.key(text) || (text.to_s.match?(/\A#{prefix}\d+\z/) && text.delete_prefix(prefix).to_i)
+      raise ConversionError, "invalid #{kind} name" unless number.is_a?(Integer) && number.between?(0, 65_535)
+
+      number
+    end
+  end
+end

data/lib/dns_json/stream.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module DNSJSON
+  module Stream
+    class Writer
+      def initialize(io, profile: Profile::FULL)
+        @io = io
+        @profile = profile
+      end
+
+      def <<(message)
+        @io.write("\x1e#{message.to_json(profile: @profile)}\n")
+        self
+      end
+    end
+
+    class Reader
+      include Enumerable
+
+      attr_reader :problems, :dropped_problems
+
+      def initialize(io, strict: false, max_json_bytes: LIMITS[:max_json_bytes], max_problems: 1000, **options)
+        @io = io
+        @strict = strict
+        @max_bytes = max_json_bytes
+        @options = options
+        @problems = []
+        raise ArgumentError, "limits must be positive integers" unless [max_json_bytes, max_problems].all? { |n| n.is_a?(Integer) && n.positive? }
+
+        @max_problems = max_problems
+        @dropped_problems = 0
+      end
+
+      def each(&block)
+        return enum_for(:each) unless block_given?
+
+        buffer = +"".b
+        started = false
+        oversized = false
+        index = 0
+        while (chunk = @io.read(4096)) && !chunk.empty?
+          chunk.each_byte do |byte|
+            if byte == 30
+              consume(buffer, index, &block) if started && !buffer.strip.empty? && !oversized
+              index += 1 if started
+              buffer = +"".b
+              started = true
+              oversized = false
+            elsif started && !oversized
+              buffer << byte
+              if buffer.bytesize > @max_bytes
+                report(LimitError.new("sequence element exceeds max_json_bytes"), index)
+                buffer = +"".b
+                oversized = true
+              end
+            elsif !started && ![9, 10, 13, 32].include?(byte)
+              report(ParseError.new("content before first record separator"), index)
+              started = true
+              oversized = true
+            end
+          end
+        end
+        consume(buffer, index, &block) if started && !buffer.strip.empty? && !oversized
+        self
+      end
+
+      private
+
+      def consume(buffer, index)
+        message = begin
+          DNSJSON.parse(buffer, max_json_bytes: @max_bytes, **@options)
+        rescue Error => e
+          report(e, index)
+          nil
+        end
+        yield message if message
+      end
+
+      def report(error, index)
+        raise error if @strict
+
+        if @problems.length < @max_problems
+          @problems << Problem.new(offset: index, reason: error.message)
+        else
+          @dropped_problems += 1
+        end
+      end
+    end
+  end
+end

data/lib/dns_json/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DnsJson
+  VERSION = "0.1.0"
+end

data/lib/dns_json/wire/name.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module DNSJSON
+  module Wire
+    module Name
+      def self.read(bytes, offset, max_pointers: 128)
+        labels = []
+        visited = {}
+        cursor = offset
+        consumed = 0
+        jumped = false
+        loop do
+          raise ConversionError, "truncated name at #{cursor}" if cursor >= bytes.bytesize
+          raise ConversionError, "compression loop at #{cursor}" if visited[cursor]
+
+          visited[cursor] = true
+          size = bytes.getbyte(cursor)
+          if size >= 192
+            raise ConversionError, "truncated compression pointer" if cursor + 1 >= bytes.bytesize
+
+            target = ((size & 63) << 8) | bytes.getbyte(cursor + 1)
+            raise ConversionError, "compression pointer must point backwards" if target >= cursor
+
+            max_pointers -= 1
+            raise ConversionError, "name exceeds max_pointers" if max_pointers.negative?
+
+            consumed += 2 unless jumped
+            jumped = true
+            cursor = target
+          elsif size >= 64
+            raise ConversionError, "unsupported label encoding"
+          else
+            consumed += size + 1 unless jumped
+            break if size.zero?
+            raise ConversionError, "truncated label" if cursor + size >= bytes.bytesize
+
+            labels << bytes.byteslice(cursor + 1, size)
+            raise ConversionError, "expanded name exceeds 255 bytes" if labels.sum(&:bytesize) + labels.length + 1 > 255
+
+            cursor += size + 1
+          end
+        end
+        [labels, consumed, jumped]
+      end
+
+      def self.display(labels)
+        return "." if labels.empty?
+
+        result = labels.map do |label|
+          label.bytes.map do |byte|
+            case byte
+            when 46, 92 then "\\#{byte.chr}"
+            when 33..126 then byte.chr
+            else format("\\%03d", byte)
+            end
+          end.join
+        end.join(".")
+        "#{result}."
+      end
+
+      def self.encode(text)
+        raise ConversionError, "name must be an ASCII string" unless text.is_a?(String) && text.ascii_only?
+        return "\0".b if text == "." || text.empty?
+
+        labels = []
+        label = +"".b
+        index = 0
+        while index < text.bytesize
+          byte = text.getbyte(index)
+          if byte == 92
+            index += 1
+            raise ConversionError, "unfinished name escape" if index == text.bytesize
+
+            digits = text.byteslice(index, 3)
+            if digits.match?(/\A\d{3}\z/)
+              raise ConversionError, "name escape exceeds one octet" if digits.to_i > 255
+
+              label << digits.to_i
+              index += 2
+            else
+              label << text.getbyte(index)
+            end
+          elsif byte == 46
+            raise ConversionError, "empty interior name label" if label.empty?
+
+            labels << label
+            label = +"".b
+          else
+            label << byte
+          end
+          index += 1
+        end
+        labels << label unless label.empty?
+        pack(labels)
+      end
+
+      def self.pack(labels)
+        raise ConversionError, "label exceeds 63 bytes" if labels.any? { |s| s.bytesize > 63 }
+
+        result = labels.map { |s| s.bytesize.chr.b + s.b }.join.b + "\0".b
+        raise ConversionError, "name exceeds 255 bytes" if result.bytesize > 255
+
+        result
+      end
+    end
+  end
+end

data/lib/dns_json/wire/reader.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module DNSJSON
+  module Wire
+    class Reader
+      def initialize(bytes, **limits)
+        raise ParseError, "wire input must be a String" unless bytes.is_a?(String)
+
+        @limits = DNSJSON.validate_limits(limits)
+        raise LimitError, "wire input exceeds max_bytes" if bytes.bytesize > @limits[:max_bytes]
+
+        @bytes = bytes.b
+        @offset = 0
+        @problems = []
+        @data = { "messageOctetsHEX" => DNSJSON.hex(@bytes), "headerOctetsHEX" => DNSJSON.hex(@bytes.byteslice(0, 12)) }
+      end
+
+      def read(date: nil)
+        header
+        if @bytes.bytesize >= 12
+          total = 0
+          SECTIONS.each_with_index do |section, index|
+            start = @offset
+            records = []
+            count = @data.fetch(COUNTS[index])
+            count.times do
+              if total >= @limits[:max_records]
+                problem("record count exceeds max_records")
+                break
+              end
+              total += 1
+              record = read_record(question: index.zero?)
+              break unless record
+
+              records << record
+            end
+            @data["#{section}RRs"] = records
+            @data["#{section}OctetsHEX"] = DNSJSON.hex(@bytes.byteslice(start, @offset - start))
+            next unless index.zero? && !records.empty?
+
+            %w[NAME NAMEHEX TYPE TYPEname CLASS CLASSname].each { |key| @data["Q#{key}"] = records.first[key] }
+            @data["compressedQNAME"] = records.first["compressedNAME"]
+          end
+          if @offset < @bytes.bytesize
+            problem("unclaimed trailing bytes")
+            @data["additionalOctetsHEX"] += DNSJSON.hex(@bytes.byteslice(@offset..))
+          end
+        end
+        if date
+          raise ArgumentError, "date must be a nonnegative Time" unless date.is_a?(Time) && date.to_f >= 0
+
+          @data["dateString"] = date.utc.iso8601(6)
+          @data["dateSeconds"] = date.to_f
+        end
+        Message.new(@data, problems: @problems, **@limits)
+      end
+
+      private
+
+      def problem(reason, offset = @offset) = @problems << Problem.new(offset: offset, reason: reason)
+
+      def header
+        @data["ID"] = @bytes.unpack1("n") if @bytes.bytesize >= 2
+        if @bytes.bytesize >= 4
+          flags = @bytes.byteslice(2, 2).unpack1("n")
+          BITS.each { |key, shift| @data[key] = (flags >> shift) & 1 }
+          @data["Opcode"] = (flags >> 11) & 15
+          @data["RCODE"] = flags & 15
+        end
+        COUNTS.each_with_index { |key, i| @data[key] = @bytes.byteslice(4 + (i * 2), 2).unpack1("n") if @bytes.bytesize >= 6 + (i * 2) }
+        problem("truncated DNS header", @bytes.bytesize) if @bytes.bytesize < 12
+        problem("zero questions in DNS message", 4) if @data["QDCOUNT"]&.zero?
+        @offset = [12, @bytes.bytesize].min
+      end
+
+      def read_record(question:)
+        start = @offset
+        labels, consumed, compressed = Name.read(@bytes, @offset, max_pointers: @limits[:max_pointers])
+        @offset += consumed
+        record = { "NAME" => Name.display(labels), "NAMEHEX" => DNSJSON.hex(Name.pack(labels)),
+                   "compressedNAME" => { "isCompressed" => compressed ? 1 : 0, "length" => consumed } }
+        required = question ? 4 : 10
+        raise ConversionError, "truncated resource record header" if @offset + required > @bytes.bytesize
+
+        type, klass = @bytes.byteslice(@offset, 4).unpack("nn")
+        record.merge!("TYPE" => type, "TYPEname" => Registry.type(type), "CLASS" => klass, "CLASSname" => Registry.klass(klass))
+        @offset += 4
+        unless question
+          ttl, length = @bytes.byteslice(@offset, 6).unpack("l>n")
+          @offset += 6
+          record.merge!("TTL" => ttl, "RDLENGTH" => length)
+          actual = [length, @bytes.bytesize - @offset].min
+          record["RDATAHEX"] = DNSJSON.hex(@bytes.byteslice(@offset, actual))
+          if actual < length
+            problem("RDLENGTH exceeds available RDATA")
+          else
+            begin
+              value = RData.decode(type, @bytes, @offset, length, max_pointers: @limits[:max_pointers])
+              record["rdata#{RData::FORMATS[type]}"] = value unless value.nil?
+            rescue ConversionError => e
+              problem(e.message)
+            end
+          end
+          @offset += actual
+        end
+        record["rrOctetsHEX"] = DNSJSON.hex(@bytes.byteslice(start, @offset - start))
+        record
+      rescue ConversionError => e
+        problem(e.message, start)
+        @offset = @bytes.bytesize
+        nil
+      end
+    end
+  end
+end