rrs 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0d9733af6339a12ce11ff22d41f27142c86f16b46755c9b12c671f9a851fa6e
-  data.tar.gz: a3df3377fa1a8f10e93281536fb4ccdcfc1cdd2bf19ab3bf5ce8e2840f575a60
+  metadata.gz: 5a851d73be2407a245945dd33ac1e669bd66ccad17f7f073212bf00e8105f358
+  data.tar.gz: c5c4d8f7c52bfad9aa0fe4cc85aff98b515f870c146242a5f263f82c10c75fe3
 SHA512:
-  metadata.gz: f8ab7a7e7b4d8046101570b92a1ac8e7e07fd55100a3d43f4287b6c48ad317e5f13c07ccd80c743a6cd46a624d21dd82f5f27c993ea90430f79ace1e0b790f21
-  data.tar.gz: 6e2479f8d855d39afb625f61699501ec4d2d00c7d177d2f950d63dc845c260e0a6a02b6daf37e8f1e5fdb9b73b51357d9e58f735ddc3b35599025674b4688317
+  metadata.gz: 789a9f105dbaf0f00c93cd0811e75fbc6956130ede2482bba8720ed207cc14e27d53889824f284dbde05c3131b8e61a69883deaf4dc52d4035684ed8d7a94936
+  data.tar.gz: ca30ac41e67c5f55bebdeba2d9c7b28acde254385d838eca61c579a998bb64e2852de7407582f1e74e078c8b694440fdeab77cb33e59a38a0cfd9fbcda241bc6

data/lib/rrs/{a.rb → in/a.rb}

@@ -1,5 +1,5 @@
 module RRs
-  class A
+  class IN::A < Resource
     TypeValue = 1
     ClassValue = 1
   

data/lib/rrs/in.rb

@@ -0,0 +1,4 @@
+module RRs
+  module IN
+  end
+end

data/lib/rrs/inflector.rb

@@ -1,3 +1,4 @@
+require_relative "maps/qtype_map"
 module RRs
   class Inflector < Zeitwerk::Inflector
     def camelize(basename, abspath)
@@ -5,6 +6,10 @@ module RRs
         "RRs" + super($1, abspath)
       elsif basename =~ /\Aipv(.*)/
         "IPv" + super($1, abspath)
+      elsif basename =~ /\Ain(.*)/ && basename != "inflector"
+        "IN" + super($1, abspath)
+      elsif ::RRs::Maps::QTYPE_MAP.values.any? { |v| basename.upcase == v.to_s }
+        basename.upcase
       else
         super
       end

data/lib/rrs/label.rb

@@ -0,0 +1,39 @@
+module RRs
+  module Label # :nodoc:
+    def self.split(arg)
+      labels = []
+      arg.scan(/[^\.]+/) {labels << Str.new($&)}
+      return labels
+    end
+
+    class Str # :nodoc:
+      def initialize(string)
+        @string = string
+        # case insensivity of DNS labels doesn't apply non-ASCII characters. [RFC 4343]
+        # This assumes @string is given in ASCII compatible encoding.
+        @downcase = string.b.downcase
+      end
+      attr_reader :string, :downcase
+
+      def to_s
+        return @string
+      end
+
+      def inspect
+        return "#<#{self.class} #{self}>"
+      end
+
+      def ==(other)
+        return self.class == other.class && @downcase == other.downcase
+      end
+
+      def eql?(other)
+        return self == other
+      end
+
+      def hash
+        return @downcase.hash
+      end
+    end
+  end
+end

data/lib/rrs/maps/qclass_map.rb

@@ -0,0 +1,11 @@
+module RRs
+  module Maps
+    QCLASS_MAP = Ractor.make_shareable({
+      1 => :IN,
+      2 => :CS,
+      3 => :CH,
+      4 => :HS,
+      255 => :*
+    }.freeze)
+  end
+end

data/lib/rrs/maps/qtype_map.rb

@@ -0,0 +1,28 @@
+module RRs
+  module Maps
+    QTYPE_MAP = Ractor.make_shareable({
+        1 => :A,
+        2 => :NS,
+        3 => :MD,
+        4 => :MF,
+        5 => :CNAME,
+        6 => :SOA,
+        7 => :MB,
+        8 => :MG,
+        9 => :MR,
+        10 => :NULL,
+        11 => :WKS,
+        12 => :PTR,
+        13 => :HINFO,
+        14 => :MINFO,
+        15 => :MX,
+        16 => :TXT,
+        28 => :AAAA,
+        41 => :OPT,
+        252 => :AXFR,
+        253 => :MAILB,
+        254 => :MAILA,
+        255 => :*
+      }.freeze)
+  end
+end

data/lib/rrs/maps.rb

@@ -0,0 +1,6 @@
+require_relative "maps/qclass_map"
+require_relative "maps/qtype_map"
+module RRs
+  module Maps
+  end
+end

data/lib/rrs/message.rb

@@ -0,0 +1,352 @@
+module RRs
+  class Message
+    @@identifier = -1
+  
+    def initialize(id = (@@identifier += 1) & 0xffff)
+      @id = id
+      @qr = 0
+      @opcode = 0
+      @aa = 0
+      @tc = 0
+      @rd = 0 # recursion desired
+      @ra = 0 # recursion available
+      @rcode = 0
+      @question = []
+      @answer = []
+      @authority = []
+      @additional = []
+    end
+  
+    attr_accessor :id, :qr, :opcode, :aa, :tc, :rd, :ra, :rcode
+    attr_reader :question, :answer, :authority, :additional
+  
+    def ==(other)
+      return @id == other.id &&
+              @qr == other.qr &&
+              @opcode == other.opcode &&
+              @aa == other.aa &&
+              @tc == other.tc &&
+              @rd == other.rd &&
+              @ra == other.ra &&
+              @rcode == other.rcode &&
+              @question == other.question &&
+              @answer == other.answer &&
+              @authority == other.authority &&
+              @additional == other.additional
+    end
+  
+    def add_question(name, typeclass)
+      @question << [Name.create(name), typeclass]
+    end
+  
+    def each_question
+      @question.each {|name, typeclass|
+        yield name, typeclass
+      }
+    end
+  
+    def add_answer(name, ttl, data)
+      @answer << [Name.create(name), ttl, data]
+    end
+  
+    def each_answer
+      @answer.each {|name, ttl, data|
+        yield name, ttl, data
+      }
+    end
+  
+    def add_authority(name, ttl, data)
+      @authority << [Name.create(name), ttl, data]
+    end
+  
+    def each_authority
+      @authority.each {|name, ttl, data|
+        yield name, ttl, data
+      }
+    end
+  
+    def add_additional(name, ttl, data)
+      @additional << [Name.create(name), ttl, data]
+    end
+  
+    def each_additional
+      @additional.each {|name, ttl, data|
+        yield name, ttl, data
+      }
+    end
+  
+    def each_resource
+      each_answer {|name, ttl, data| yield name, ttl, data}
+      each_authority {|name, ttl, data| yield name, ttl, data}
+      each_additional {|name, ttl, data| yield name, ttl, data}
+    end
+  
+    def encode
+      return MessageEncoder.new {|msg|
+        msg.put_pack('nnnnnn',
+          @id,
+          (@qr & 1) << 15 |
+          (@opcode & 15) << 11 |
+          (@aa & 1) << 10 |
+          (@tc & 1) << 9 |
+          (@rd & 1) << 8 |
+          (@ra & 1) << 7 |
+          (@rcode & 15),
+          @question.length,
+          @answer.length,
+          @authority.length,
+          @additional.length)
+        @question.each {|q|
+          name, typeclass = q
+          msg.put_name(name)
+          msg.put_pack('nn', typeclass::TypeValue, typeclass::ClassValue)
+        }
+        [@answer, @authority, @additional].each {|rr|
+          rr.each {|r|
+            name, ttl, data = r
+            msg.put_name(name)
+            msg.put_pack('nnN', data.class::TypeValue, data.class::ClassValue, ttl)
+            msg.put_length16 {data.encode_rdata(msg)}
+          }
+        }
+      }.to_s
+    end
+  
+    class MessageEncoder # :nodoc:
+      def initialize
+        @data = ''.dup
+        @names = {}
+        yield self
+      end
+  
+      def to_s
+        return @data
+      end
+  
+      def put_bytes(d)
+        @data << d
+      end
+  
+      def put_pack(template, *d)
+        @data << d.pack(template)
+      end
+  
+      def put_length16
+        length_index = @data.length
+        @data << "\0\0"
+        data_start = @data.length
+        yield
+        data_end = @data.length
+        @data[length_index, 2] = [data_end - data_start].pack("n")
+      end
+  
+      def put_string(d)
+        self.put_pack("C", d.length)
+        @data << d
+      end
+  
+      def put_string_list(ds)
+        ds.each {|d|
+          self.put_string(d)
+        }
+      end
+  
+      def put_name(d, compress: true)
+        put_labels(d.to_a, compress: compress)
+      end
+  
+      def put_labels(d, compress: true)
+        d.each_index {|i|
+          domain = d[i..-1]
+          if compress && idx = @names[domain]
+            self.put_pack("n", 0xc000 | idx)
+            return
+          else
+            if @data.length < 0x4000
+              @names[domain] = @data.length
+            end
+            self.put_label(d[i])
+          end
+        }
+        @data << "\0"
+      end
+  
+      def put_label(d)
+        self.put_string(d.to_s)
+      end
+    end
+  
+    def Message.decode(m)
+      o = Message.new(0)
+      MessageDecoder.new(m) {|msg|
+        id, flag, qdcount, ancount, nscount, arcount =
+          msg.get_unpack('nnnnnn')
+        o.id = id
+        o.tc = (flag >> 9) & 1
+        o.rcode = flag & 15
+        return o unless o.tc.zero?
+  
+        o.qr = (flag >> 15) & 1
+        o.opcode = (flag >> 11) & 15
+        o.aa = (flag >> 10) & 1
+        o.rd = (flag >> 8) & 1
+        o.ra = (flag >> 7) & 1
+        (1..qdcount).each {
+          name, typeclass = msg.get_question
+          o.add_question(name, typeclass)
+        }
+        (1..ancount).each {
+          name, ttl, data = msg.get_rr
+          o.add_answer(name, ttl, data)
+        }
+        (1..nscount).each {
+          name, ttl, data = msg.get_rr
+          o.add_authority(name, ttl, data)
+        }
+        (1..arcount).each {
+          name, ttl, data = msg.get_rr
+          o.add_additional(name, ttl, data)
+        }
+      }
+      return o
+    end
+  
+    class MessageDecoder # :nodoc:
+      def initialize(data)
+        @data = data
+        @index = 0
+        @limit = data.bytesize
+        yield self
+      end
+  
+      def inspect
+        "\#<#{self.class}: #{@data.byteslice(0, @index).inspect} #{@data.byteslice(@index..-1).inspect}>"
+      end
+  
+      def get_length16
+        len, = self.get_unpack('n')
+        save_limit = @limit
+        @limit = @index + len
+        d = yield(len)
+        if @index < @limit
+          raise DecodeError.new("junk exists")
+        elsif @limit < @index
+          raise DecodeError.new("limit exceeded")
+        end
+        @limit = save_limit
+        return d
+      end
+  
+      def get_bytes(len = @limit - @index)
+        raise DecodeError.new("limit exceeded") if @limit < @index + len
+        d = @data.byteslice(@index, len)
+        @index += len
+        return d
+      end
+  
+      def get_unpack(template)
+        len = 0
+        template.each_byte {|byte|
+          byte = "%c" % byte
+          case byte
+          when ?c, ?C
+            len += 1
+          when ?n
+            len += 2
+          when ?N
+            len += 4
+          else
+            raise StandardError.new("unsupported template: '#{byte.chr}' in '#{template}'")
+          end
+        }
+        raise DecodeError.new("limit exceeded") if @limit < @index + len
+        arr = @data.unpack("@#{@index}#{template}")
+        @index += len
+        return arr
+      end
+  
+      def get_string
+        raise DecodeError.new("limit exceeded") if @limit <= @index
+        len = @data.getbyte(@index)
+        raise DecodeError.new("limit exceeded") if @limit < @index + 1 + len
+        d = @data.byteslice(@index + 1, len)
+        @index += 1 + len
+        return d
+      end
+  
+      def get_string_list
+        strings = []
+        while @index < @limit
+          strings << self.get_string
+        end
+        strings
+      end
+  
+      def get_list
+        [].tap do |values|
+          while @index < @limit
+            values << yield
+          end
+        end
+      end
+  
+      def get_name
+        return Name.new(self.get_labels)
+      end
+  
+      def get_labels
+        prev_index = @index
+        save_index = nil
+        d = []
+        while true
+          raise DecodeError.new("limit exceeded") if @limit <= @index
+          case @data.getbyte(@index)
+          when 0
+            @index += 1
+            if save_index
+              @index = save_index
+            end
+            return d
+          when 192..255
+            idx = self.get_unpack('n')[0] & 0x3fff
+            if prev_index <= idx
+              raise DecodeError.new("non-backward name pointer")
+            end
+            prev_index = idx
+            if !save_index
+              save_index = @index
+            end
+            @index = idx
+          else
+            d << self.get_label
+          end
+        end
+      end
+  
+      def get_label
+        return Label::Str.new(self.get_string)
+      end
+  
+      def get_question
+        name = self.get_name
+        type, klass = self.get_unpack("nn")
+        return name, Resource.get_class(type, klass)
+      end
+  
+      def get_rr
+        name = self.get_name
+        type, klass, ttl = self.get_unpack('nnN')
+        typeclass = Resource.get_class(type, klass)
+        res = self.get_length16 do
+          begin
+            typeclass.decode_rdata self
+          rescue => e
+            raise DecodeError, e.message, e.backtrace
+          end
+        end
+        res.instance_variable_set :@ttl, ttl
+        return name, ttl, res
+      end
+    end
+  end
+end

data/lib/rrs/name.rb

@@ -0,0 +1,109 @@
+module RRs
+  ##
+  # A representation of a DNS name.
+
+  class Name
+
+    ##
+    # Creates a new DNS name from +arg+.  +arg+ can be:
+    #
+    # Name:: returns +arg+.
+    # String:: Creates a new Name.
+
+    def self.create(arg)
+      case arg
+      when Name
+        return arg
+      when String
+        return Name.new(Label.split(arg), /\.\z/ =~ arg ? true : false)
+      else
+        raise ArgumentError.new("cannot interpret as DNS name: #{arg.inspect}")
+      end
+    end
+
+    def initialize(labels, absolute=true) # :nodoc:
+      labels = labels.map {|label|
+        case label
+        when String then Label::Str.new(label)
+        when Label::Str then label
+        else
+          raise ArgumentError, "unexpected label: #{label.inspect}"
+        end
+      }
+      @labels = labels
+      @absolute = absolute
+    end
+
+    def inspect # :nodoc:
+      "#<#{self.class}: #{self}#{@absolute ? '.' : ''}>"
+    end
+
+    ##
+    # True if this name is absolute.
+
+    def absolute?
+      return @absolute
+    end
+
+    def ==(other) # :nodoc:
+      return false unless Name === other
+      return false unless @absolute == other.absolute?
+      return @labels == other.to_a
+    end
+
+    alias eql? == # :nodoc:
+
+    ##
+    # Returns true if +other+ is a subdomain.
+    #
+    # Example:
+    #
+    #   domain = Resolv::DNS::Name.create("y.z")
+    #   p Resolv::DNS::Name.create("w.x.y.z").subdomain_of?(domain) #=> true
+    #   p Resolv::DNS::Name.create("x.y.z").subdomain_of?(domain) #=> true
+    #   p Resolv::DNS::Name.create("y.z").subdomain_of?(domain) #=> false
+    #   p Resolv::DNS::Name.create("z").subdomain_of?(domain) #=> false
+    #   p Resolv::DNS::Name.create("x.y.z.").subdomain_of?(domain) #=> false
+    #   p Resolv::DNS::Name.create("w.z").subdomain_of?(domain) #=> false
+    #
+
+    def subdomain_of?(other)
+      raise ArgumentError, "not a domain name: #{other.inspect}" unless Name === other
+      return false if @absolute != other.absolute?
+      other_len = other.length
+      return false if @labels.length <= other_len
+      return @labels[-other_len, other_len] == other.to_a
+    end
+
+    def hash # :nodoc:
+      return @labels.hash ^ @absolute.hash
+    end
+
+    def to_a # :nodoc:
+      return @labels
+    end
+
+    def length # :nodoc:
+      return @labels.length
+    end
+
+    def [](i) # :nodoc:
+      return @labels[i]
+    end
+
+    ##
+    # returns the domain name as a string.
+    #
+    # The domain name doesn't have a trailing dot even if the name object is
+    # absolute.
+    #
+    # Example:
+    #
+    #   p Resolv::DNS::Name.create("x.y.z.").to_s #=> "x.y.z"
+    #   p Resolv::DNS::Name.create("x.y.z").to_s #=> "x.y.z"
+
+    def to_s
+      return @labels.join('.')
+    end
+  end
+end

data/lib/rrs/opt.rb

@@ -0,0 +1,16 @@
+module RRs
+  class OPT < Resource  
+    attr_reader :data
+    def initialize(data)
+      @data = data
+    end
+    
+    def encode_rdata(msg)
+      msg.put_bytes(data)
+    end
+    
+    def self.decode_rdata(msg)
+      return self.new(msg.get_bytes)
+    end
+  end
+end

data/lib/rrs/resource.rb

@@ -0,0 +1,51 @@
+class RRs::Resource
+  ##
+  # Remaining Time To Live for this Resource.
+
+  attr_reader :ttl
+
+  def encode_rdata(msg) # :nodoc:
+    raise NotImplementedError.new
+  end
+
+  def self.decode_rdata(msg) # :nodoc:
+    raise NotImplementedError.new
+  end
+
+  def ==(other) # :nodoc:
+    return false unless self.class == other.class
+    s_ivars = self.instance_variables
+    s_ivars.sort!
+    s_ivars.delete :@ttl
+    o_ivars = other.instance_variables
+    o_ivars.sort!
+    o_ivars.delete :@ttl
+    return s_ivars == o_ivars &&
+      s_ivars.collect {|name| self.instance_variable_get name} ==
+        o_ivars.collect {|name| other.instance_variable_get name}
+  end
+
+  def eql?(other) # :nodoc:
+    return self == other
+  end
+
+  def hash # :nodoc:
+    h = 0
+    vars = self.instance_variables
+    vars.delete :@ttl
+    vars.each {|name|
+      h ^= self.instance_variable_get(name).hash
+    }
+    return h
+  end
+  
+  def self.get_class(type_value, class_value) # :nodoc:    
+    path = []
+    if class_value
+     path.push(::RRs::Maps::QCLASS_MAP[class_value.to_i].to_s) if ::RRs::Maps::QCLASS_MAP[class_value.to_i]
+    end
+    path.push(::RRs::Maps::QTYPE_MAP[type_value.to_i].to_s)
+    RRs.const_get(path.join("::"))
+  end
+  
+end

data/lib/rrs.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 require "zeitwerk"
 require_relative "rrs/inflector"
+require_relative "rrs/maps"
 
 loader = Zeitwerk::Loader.for_gem
 loader.inflector = RRs::Inflector.new
+loader.ignore("#{__dir__}/rrs/maps")
 loader.setup
 
 module RRs
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
   class Error < StandardError; end
+  class DecodeError < StandardError; end
+  class EncodeError < StandardError; end
 end
 
 loader.eager_load

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rrs
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - reesericci
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-08-17 00:00:00.000000000 Z
+date: 2024-08-18 00:00:00.000000000 Z
 dependencies: []
 description: "RRs is a set of self-contained DNS primitives that do not share state,
   which makes them suitable for use in Ractors. \n\nThis is a contrast to the Resolv::DNS
@@ -23,10 +23,19 @@ files:
 - README.md
 - Rakefile
 - lib/rrs.rb
-- lib/rrs/a.rb
+- lib/rrs/in.rb
+- lib/rrs/in/a.rb
 - lib/rrs/inflector.rb
 - lib/rrs/ipv4.rb
 - lib/rrs/ipv6.rb
+- lib/rrs/label.rb
+- lib/rrs/maps.rb
+- lib/rrs/maps/qclass_map.rb
+- lib/rrs/maps/qtype_map.rb
+- lib/rrs/message.rb
+- lib/rrs/name.rb
+- lib/rrs/opt.rb
+- lib/rrs/resource.rb
 - sig/rrs.rbs
 homepage: https://codeberg.org/reesericci/rrs
 licenses: []