nl 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b834199d097a768959ee9b81d4f8e08e504048b9bb537aefbbb3c737dcbc166b
-  data.tar.gz: 62fbdaaeb0ea9c4a5aefba149476f32dde99b16e210252566340b9627282bd4e
+  metadata.gz: 52aff4b073cd86a4ce19bb2feee6f92de27bf253869e4f6f4bea673c90d7dade
+  data.tar.gz: 50fef7586bbdd1b050a20303fb106a29510fab9c6ea7df80631e1a727a36ea10
 SHA512:
-  metadata.gz: 218aabff17cc161fbb064f22e50c78c11770bc70df76636434bd648af2e3592bbafdb491b61daf8164be306f5d5bfe1e8e0ad968963c9c17756fcb06e826ed47
-  data.tar.gz: 4ff4dc4caf73c20e1b93e090689684534f8f8b184f15538eac47451293c4705918fbea24583949e1454882a850379341784d1226f3c7f8421d362c6b184fcc3e
+  metadata.gz: bfb9af6ebc834dfd1e098220d74b0064c1bfc9fe38ecea9972cfe1dac6daae9058d046e8bfcb5a32ff2ca8da62a73e64e13b0efbe94627f9eb79f1f2f72f8045
+  data.tar.gz: 34584295bf54077889280d22be9937382914121e78607bbfe82649a8785e469f96d96136bbd41fa7a14878391bae780db71b0dc24f0c514759b92e3f69598ccc

data/CHANGELOG.md

@@ -2,4 +2,8 @@
 
 ## Unreleased
 
+## v0.2.0 (2026-03-02)
+
+## v0.1.0 (2025-04-20)
+
 - Initial release

data/Rakefile

@@ -1,4 +1,3 @@
-require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)

data/lib/nl/encoder.rb

@@ -16,12 +16,12 @@ module Nl
 
     def put_string(value)
       reserve(value.bytesize)
-      @position = @buffer.set_string(value, @position)
+      @position += @buffer.set_string(value, @position)
     end
 
     def put_zstring(value)
       reserve(value.bytesize + 1)
-      @position = @buffer.set_string(value, @position)
+      @position += @buffer.set_string(value, @position)
       @position = @buffer.set_value(:U8, @position, 0)
     end
 

data/lib/nl/endian.rb

@@ -20,16 +20,18 @@ module Nl
         when 4; [U32, S32]
         when 8; [U64, S64]
         else raise "Unsupported 'int' size"
-        end
+      end
       ULONG, SLONG = case SIZEOF_LONG
         when 4; [U32, S32]
         when 8; [U64, S64]
         else raise "Unsupported 'long' size"
-        end
+      end
       ULLONG, SLLONG = case SIZEOF_LLONG
         when 8; [U64, S64]
         else raise "Unsupported 'long long' size"
-        end
+      end
+
+      INT, LONG, LLONG = SINT, SLONG, SLLONG
     end
   end
 end

data/lib/nl/family.rb

@@ -1,14 +1,24 @@
+#--
+# rbs_inline: enabled
 require_relative 'socket'
 
 module Nl
   class Family
-    def initialize(socket)
+    #--
+    # @rbs socket: Socket
+    # @rbs protocol: Protocol
+    # @rbs return: instance
+    def initialize(socket, protocol: self.class::PROTOCOL)
       @socket = socket
+      @protocol = protocol
     end
 
+    #--
+    # @rbs () -> instance
+    #  | [R] () { (instance) -> R } -> R
     def self.open
       begin
-        socket = Socket.new(self::PROTONUM)
+        socket = Socket.new(self::PROTOCOL.protonum)
         socket.bind(Socket.sockaddr_nl(0, 0))
         if block_given?
           yield new(socket)
@@ -20,144 +30,8 @@ module Nl
       end
     end
 
-    def exchange_message(type, request_class, reply_class, args)
-      self.class::PROTOCOL.exchange_message(@socket, type, request_class, reply_class, args)
-    end
-
-    class Message
-      attr_accessor :header, :fixed_header, :attributes
-
-      def initialize(header, fixed_header = nil, attributes = [])
-        @header = header
-        @fixed_header = fixed_header
-        @attributes = attributes
-      end
-
-      def self.from_params(params)
-        header_params = params.slice(*self::HEADER_PARAMS)
-        attribute_params = params.slice(*self::ATTRIBUTE_PARAMS)
-        # TODO: Reject unknown params
-
-        header = Core::NlMsgHdr.new(0, self::TYPE, nil, nil, nil)
-        fixed_header = self::FIXED_HEADER&.new(**header_params)
-        attributes = self::ATTRIBUTE_SET.build_attributes(**attribute_params)
-        new(header, fixed_header, attributes)
-      end
-
-      def append_attribute(attribute)
-        @attributes << attribute
-      end
-
-      def encode(encoder)
-        validate!
-
-        encoder.measure(Endian::Host::U16) do
-          @header.encode(encoder)
-          @fixed_header.encode(encoder) if @fixed_header
-          @attributes.each do |attr|
-            attr.encode(encoder)
-          end
-        end
-      end
-
-      def self.decode(decoder, header)
-        unless self::TYPE == header.type
-          raise "Expected message type #{self::TYPE}, got #{header.type}"
-        end
-
-        if fixed_header_class = self::FIXED_HEADER
-          fixed_header = fixed_header_class.decode(decoder)
-        end
-
-        attributes = self::ATTRIBUTE_SET.decode(decoder)
-
-        new(header, fixed_header, attributes).tap(&:validate!)
-      end
-
-      def validate!
-        unless self.class::TYPE == header.type
-          raise "Expected message type #{self.class::FIXED_HEADER}, got #{header.type}"
-        end
-        # TODO: Validate fixed header and attributes
-        # @fixed_header&.validate!
-        # @attributes.each(&:validate!)
-      end
-
-      def to_h
-        to_h_rec(@attributes, @fixed_header&.to_h || {})
-      end
-
-      # FIXME:
-      private def to_h_rec(attributes, init = {})
-        attributes.each_with_object(init) do |attr, h|
-          if attr.class::DATATYPE.is_a?(Protocols::Raw::DataTypes::NestedAttributes)
-            h[attr.class::NAME] = to_h_rec(attr.value)
-          else
-            h[attr.class::NAME] = attr.value
-          end
-        end
-      end
-    end
-
-    class AttributeSet
-      Attribute = Struct.new(:value)
-      class Attribute
-        def self.decode(decoder)
-          value = self::DATATYPE.decode(decoder)
-          new(value)
-        end
-
-        def encode(encoder)
-          self.class::DATATYPE.encode(encoder, self.value)
-        end
-      end
-
-      class << self
-        private def decode1(decoder)
-          nlattr = Core::NlAttr.decode(decoder)
-          attr = decoder.limit(nlattr.len - Core::NLA_HDRLEN) do
-            if attr_class = self::BY_TYPE[nlattr.type & Core::NLA_TYPE_MASK]
-              attr_class.decode(decoder)
-            else
-              decoder.skip
-              nil
-            end
-          end
-          decoder.align_to(Core::NLA_ALIGNTO)
-          attr
-        end
-
-        def decode(decoder)
-          attrs = []
-          while decoder.available?
-            attr = decode1(decoder)
-            attrs << attr
-          end
-          attrs.compact
-        end
-
-        private def encode1(encoder, attr)
-          nlattr = Core::NlAttr.new(attr.class::TYPE, 0)
-          encoder.measure(Endian::Host::U16) do
-            nlattr.encode(encoder)
-            attr.encode(encoder)
-          end
-          encoder.align_to(Core::NLA_ALIGNTO)
-        end
-
-        def encode(encoder, attrs)
-          attrs.each do |attr|
-            encode1(encoder, attr)
-          end
-        end
-
-        def build_attributes(**params)
-          params.map do |name, value|
-            attr_class = self::BY_NAME[name] or raise "Unknown attribute #{name}"
-            attr_class.new(value)
-          end
-        end
-      end
+    private def exchange_message(type, request_class, reply_class, args, &block)
+      @protocol.exchange_message(@socket, type, request_class, reply_class, args, &block)
     end
   end
 end

data/lib/nl/genl.rb

@@ -48,18 +48,40 @@ module Nl
     end
     include Constants
 
-    GenlMsgHdr ||= Data.define(:cmd, :version, :reserved)
-    class GenlMsgHdr
-      GENLMSGHDR_FMT = Ractor.make_shareable([
-        Endian::Host::U8,
-        Endian::Host::U8,
-        Endian::Host::U16,
-      ])
-      private_constant :GENLMSGHDR_FMT
+    class Connection
+      def self.open(resolver:)
+        conn = new(resolver:)
+        if block_given?
+          begin
+            yield conn
+          ensure
+            conn.close
+          end
+        else
+          conn
+        end
+      end
+
+      def initialize(resolver:)
+        @socket = Socket.new(Core::NETLINK_GENERIC)
+        @socket.bind(Socket.sockaddr_nl(0, 0))
+        @resolver = resolver
+        @id_cache = {}
+      end
+
+      def open(family_class)
+        proto = family_class::PROTOCOL
+        id = @id_cache[proto.name] ||= begin
+          proto.family_id
+        rescue NotImplementedError
+          @resolver.call(@socket, proto.name)
+        end
+        family_class.new(@socket, protocol: Protocols::Genl.new(proto.name, family_id: id))
+      end
 
-      def self.parse(buffer, offset)
-        new(*buffer.get_values(GENLMSGHDR_FMT, offset))
+      def close
+        @socket.close
       end
     end
   end
-end
+end

data/lib/nl/protocols/genl.rb

@@ -1,14 +1,54 @@
 module Nl
   module Protocols
     # The Generic Netlink protocol
-      class Genl < Raw  # TODO: Implement
-      def initialize(name)
-        super(name, NETLINK_GENERIC)
+    class Genl < Raw
+      GenlMsgHdr = ::Struct.new(:cmd, :version, :reserved)
+      class GenlMsgHdr
+        FORMAT = Ractor.make_shareable([
+          Endian::Host::U8,
+          Endian::Host::U8,
+          Endian::Host::U16,
+        ])
+
+        def self.decode(decoder)
+          new(*decoder.get_values(FORMAT))
+        end
+
+        def encode(encoder)
+          encoder.put_values(FORMAT, to_a)
+        end
+      end
+
+      def initialize(name, family_id: nil)
+        super(name, Core::NETLINK_GENERIC)
+        @family_id = family_id || default_family_id(name)
+      end
+
+      def family_id
+        @family_id or raise NotImplementedError, "Genetlink family ID for '#{name}' must be resolved via nlctrl"
+      end
+
+      def encode_message(encoder, message)
+        cmd = message.nlmsg_header.type
+        encoder.measure(Endian::Host::U16) do
+          message.nlmsg_header.type = family_id
+          message.nlmsg_header.encode(encoder)
+          message.nlmsg_header.type = cmd
+          GenlMsgHdr.new(cmd, 1, 0).encode(encoder)
+          message.fixed_header&.encode(encoder)
+          message.attributes.encode(encoder)
+        end
+      end
+
+      class Message < Raw::Message
+        def self.decode(decoder, header)
+          genlhdr = GenlMsgHdr.decode(decoder)
+          super(decoder, header, type: genlhdr.cmd)
+        end
       end
 
-      def parse(buffer, offset)
-        nlmsg = super(buffer, offset)
-        genlmsg = GenlMsgHdr.parse(nlmsg.data, 0)
+      private def default_family_id(name)
+        Nl::Genl::GENL_ID_CTRL if name == 'nlctrl'
       end
     end
   end

data/lib/nl/protocols/raw.rb

@@ -1,3 +1,6 @@
+require_relative '../encoder'
+require_relative '../decoder'
+
 module Nl
   module Protocols
     # The raw Netlink protocol
@@ -26,7 +29,7 @@ module Nl
       end
 
       def send_message(socket, message)
-        seq_pid = socket.complete(message.header)
+        seq_pid = socket.complete(message.nlmsg_header)
         encoder = Encoder.new
         encode_message(encoder, message)
         socket.sendmsg(encoder.buffer.get_string, 0, Socket.sockaddr_nl(0, 0))
@@ -75,34 +78,187 @@ module Nl
       # @param reply_class [Class] Reply message class
       # @param args [Hash] Request arguments
       def exchange_message(socket, type, request_class, reply_class, args)
-        flags = Core::NLM_F_REQUEST | Core::NLM_F_ACK
-        flags |= Core::NLM_F_DUMP if type == :dump
+        flags = Core::NLM_F_REQUEST
+        flags |= type == :dump ? Core::NLM_F_DUMP : Core::NLM_F_ACK
 
         request = request_class.from_params(args)
-        request.header.flags = flags
+        request.nlmsg_header.flags = flags
         seq_pid = send_message(socket, request)
 
-        result = []
+        result = [] unless block_given?
 
         done = false
-        acked = false
         begin
           recv_message(socket, seq_pid, reply_class) do |message|
             case message
-            when Done
+            when Done, Ack
               done = true
             when Exception
-              raise
-            when Ack
-              acked = true
+              raise message
             else
-              result << message
-              done = true if type == :do
+              if block_given?
+                yield message
+              else
+                result << message
+              end
             end
           end
         end until done
 
-        result
+        unless block_given?
+          type == :dump ? result : result.first
+        end
+      end
+
+      class AttributeSet
+        Attribute = Struct.new(:value)
+        class Attribute
+          def self.decode(decoder)
+            value = self::DATATYPE.decode(decoder)
+            new(value)
+          end
+
+          def encode(encoder)
+            self.class::DATATYPE.encode(encoder, self.value)
+          end
+        end
+
+        def initialize(attributes)
+          attr_class = self.class::Attribute
+
+          attributes.each do |attr|
+            unless attr.kind_of?(attr_class)
+              raise TypeError, "attribute must be an instance of #{attr_class}"
+            end
+          end
+
+          @attributes = Array(attributes)
+        end
+
+        def [](type)
+          case type
+          when Symbol
+            attr_class = self.class.by_name(type)
+          when Integer
+            attr_class = self.class.by_type(type)
+          else
+            raise TypeError, "attribute type must be a Symbol or an Integer"
+          end
+
+          # TODO: multi-attr
+          @attributes.find { it.kind_of?(attr_class) } rescue binding.irb
+        end
+
+        def <<(attr)
+          attr_class = self.class::Attribute
+          unless attr.kind_of?(attr_class)
+            raise TypeError, "attribute must be an instance of #{attr_class}"
+          end
+
+          @attributes << attr
+        end
+
+        private def encode1(encoder, attr)
+          nlattr = Core::NlAttr.new(0, attr.class::TYPE)
+          encoder.measure(Endian::Host::U16) do
+            nlattr.encode(encoder)
+            attr.encode(encoder)
+          end
+          encoder.align_to(Core::NLA_ALIGNTO)
+        end
+
+        def encode(encoder)
+          @attributes.each do |attr|
+            encode1(encoder, attr)
+          end
+        end
+
+        class << self
+          private def decode1(decoder)
+            nlattr = Core::NlAttr.decode(decoder)
+            attr = decoder.limit(nlattr.len - Core::NLA_HDRLEN) do
+              if attr_class = self::BY_TYPE[nlattr.type & Core::NLA_TYPE_MASK]
+                attr_class.decode(decoder)
+              else
+                decoder.skip
+                nil
+              end
+            end
+            decoder.align_to(Core::NLA_ALIGNTO)
+            attr
+          end
+
+          def decode(decoder)
+            attrs = []
+            while decoder.available?
+              attr = decode1(decoder)
+              attrs << attr
+            end
+            new(attrs.compact)
+          end
+
+          def build_attributes(**params)
+            attrs = params.map do |name, value|
+              attr_class = self::BY_NAME[name] or raise "Unknown attribute #{name}"
+              attr_class.new(value)
+            end
+            new(attrs)
+          end
+        end
+      end
+
+      class Message
+        attr_accessor :nlmsg_header, :fixed_header, :attributes
+
+        def initialize(header, fixed_header = nil, attributes = self.class::ATTRIBUTE_SET.new)
+          @nlmsg_header = header
+          @fixed_header = fixed_header
+          @attributes = attributes
+        end
+
+        def self.from_params(params)
+          if self::FIXED_HEADER
+            header_params = params.slice(*self::FIXED_HEADER.members)
+            fixed_header = self::FIXED_HEADER.new(**header_params)
+          end
+          attribute_params = params.slice(*self::ATTRIBUTES)
+          attributes = self::ATTRIBUTE_SET.build_attributes(**attribute_params)
+
+          unknown = params.keys - attribute_params.keys
+          unknown -= header_params.keys if header_params
+          unless unknown.empty?
+            raise ArgumentError, "unknown parameters: #{unknown.join(', ')}"
+          end
+
+          header = Core::NlMsgHdr.new(0, self::TYPE, nil, nil, nil)
+          new(header, fixed_header, attributes)
+        end
+
+        def append_attribute(attribute)
+          @attributes << attribute
+        end
+
+        def encode(encoder)
+          encoder.measure(Endian::Host::U16) do
+            @nlmsg_header.encode(encoder)
+            @fixed_header&.encode(encoder)
+            @attributes.encode(encoder)
+          end
+        end
+
+        def self.decode(decoder, header, type: header.type)
+          unless self::TYPE == type
+            raise "Expected message type #{self::TYPE}, got #{type}"
+          end
+
+          if fixed_header_class = self::FIXED_HEADER
+            fixed_header = fixed_header_class.decode(decoder)
+          end
+
+          attributes = self::ATTRIBUTE_SET.decode(decoder)
+
+          new(header, fixed_header, attributes)
+        end
       end
 
       module DataTypes
@@ -150,6 +306,46 @@ module Nl
           end
         end
 
+        class Flag
+          def encode(encoder, value)
+            # flag attribute has no payload; presence encodes true
+          end
+
+          def decode(decoder)
+            true
+          end
+        end
+
+        # A 32-bit value paired with a selector mask (8 bytes total: value u32 + selector u32)
+        class Bitfield32
+          def encode(encoder, value)
+            v, selector = value.is_a?(Array) ? value : [value, 0xFFFFFFFF]
+            encoder.put_value(Endian::Host::U32, v)
+            encoder.put_value(Endian::Host::U32, selector)
+          end
+
+          def decode(decoder)
+            value = decoder.get_value(Endian::Host::U32)
+            selector = decoder.get_value(Endian::Host::U32)
+            [value, selector]
+          end
+        end
+
+        class Pad
+          def initialize(length = nil)
+            @length = length
+          end
+
+          def encode(encoder, _value)
+            encoder.put_string(?\0.b * @length) if @length
+          end
+
+          def decode(decoder)
+            @length ? decoder.skip(@length) : decoder.skip
+            nil
+          end
+        end
+
         class NestedAttributes
           def initialize(attribute_set)
             @attribute_set = attribute_set
@@ -163,6 +359,36 @@ module Nl
             @attribute_set.decode(decoder)
           end
         end
+
+        class IndexedArray
+          def initialize(sub_type)
+            @sub_type = sub_type
+          end
+
+          def encode(encoder, values)
+            values.each_with_index do |value, i|
+              nlattr = Core::NlAttr.new(0, i + 1)
+              encoder.measure(Endian::Host::U16) do
+                nlattr.encode(encoder)
+                @sub_type.encode(encoder, value)
+              end
+              encoder.align_to(Core::NLA_ALIGNTO)
+            end
+          end
+
+          def decode(decoder)
+            result = []
+            while decoder.available?
+              nlattr = Core::NlAttr.decode(decoder)
+              element = decoder.limit(nlattr.len - Core::NLA_HDRLEN) do
+                @sub_type.decode(decoder)
+              end
+              decoder.align_to(Core::NLA_ALIGNTO)
+              result << element
+            end
+            result
+          end
+        end
       end
     end
   end

data/lib/nl/version.rb

@@ -1,3 +1,3 @@
 module Nl
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nl
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Kasumi Hanazuki
@@ -37,7 +37,7 @@ licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/hanazuki/nl
-  source_code_uri: https://github.com/hanazuki/nl/tree/v0.1.0
+  source_code_uri: https://github.com/hanazuki/nl/tree/v0.2.0
   changelog_uri: https://github.com/hanazuki/nl/blob/master/CHANGELOG.md
 rdoc_options: []
 require_paths:
@@ -53,7 +53,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.8
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Linux Netlink client
 test_files: []