nl 0.2.4 → 0.4.1

data/sig/generated/nl/version.rbs

@@ -0,0 +1,5 @@
+# Generated from lib/nl/version.rb with RBS::Inline
+
+module Nl
+  VERSION: ::String
+end

data/sig/generated/nl.rbs

@@ -0,0 +1,2 @@
+# Generated from lib/nl.rb with RBS::Inline
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nl
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.4.1
 platform: ruby
 authors:
 - Kasumi Hanazuki
@@ -9,7 +9,8 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies: []
-description: Linux Netlink client
+description: nl is a general-purpose Netlink implementation for building Ruby applications
+  that communicate with Linux kernel APIs or other userspace processes.
 email:
 - kasumi@rollingapple.net
 executables: []
@@ -22,22 +23,77 @@ files:
 - README.md
 - Rakefile
 - lib/nl.rb
-- lib/nl/core.rb
+- lib/nl/async.rb
+- lib/nl/async/dispatcher.rb
+- lib/nl/async/driver.rb
+- lib/nl/async/mailbox.rb
+- lib/nl/async/operation.rb
+- lib/nl/attribute_set.rb
+- lib/nl/bitfield32.rb
+- lib/nl/blocking_transport.rb
+- lib/nl/connection.rb
+- lib/nl/datagram.rb
+- lib/nl/datatypes.rb
 - lib/nl/decoder.rb
 - lib/nl/encoder.rb
 - lib/nl/endian.rb
+- lib/nl/error.rb
+- lib/nl/exchange.rb
 - lib/nl/family.rb
 - lib/nl/genl.rb
-- lib/nl/protocols/genl.rb
-- lib/nl/protocols/raw.rb
+- lib/nl/genl/client.rb
+- lib/nl/genl/protocol.rb
+- lib/nl/genl/wire.rb
+- lib/nl/notification.rb
+- lib/nl/notification_router.rb
+- lib/nl/raw.rb
+- lib/nl/raw/client.rb
+- lib/nl/raw/protocol.rb
+- lib/nl/raw/wire.rb
+- lib/nl/sequence_allocator.rb
 - lib/nl/socket.rb
+- lib/nl/structured_payload.rb
+- lib/nl/sub_message.rb
 - lib/nl/version.rb
+- sig/generated/nl.rbs
+- sig/generated/nl/async.rbs
+- sig/generated/nl/async/dispatcher.rbs
+- sig/generated/nl/async/driver.rbs
+- sig/generated/nl/async/mailbox.rbs
+- sig/generated/nl/async/operation.rbs
+- sig/generated/nl/attribute_set.rbs
+- sig/generated/nl/bitfield32.rbs
+- sig/generated/nl/blocking_transport.rbs
+- sig/generated/nl/connection.rbs
+- sig/generated/nl/datagram.rbs
+- sig/generated/nl/datatypes.rbs
+- sig/generated/nl/decoder.rbs
+- sig/generated/nl/encoder.rbs
+- sig/generated/nl/endian.rbs
+- sig/generated/nl/error.rbs
+- sig/generated/nl/exchange.rbs
+- sig/generated/nl/family.rbs
+- sig/generated/nl/genl.rbs
+- sig/generated/nl/genl/client.rbs
+- sig/generated/nl/genl/protocol.rbs
+- sig/generated/nl/genl/wire.rbs
+- sig/generated/nl/notification.rbs
+- sig/generated/nl/notification_router.rbs
+- sig/generated/nl/raw.rbs
+- sig/generated/nl/raw/client.rbs
+- sig/generated/nl/raw/protocol.rbs
+- sig/generated/nl/raw/wire.rbs
+- sig/generated/nl/sequence_allocator.rbs
+- sig/generated/nl/socket.rbs
+- sig/generated/nl/structured_payload.rbs
+- sig/generated/nl/sub_message.rbs
+- sig/generated/nl/version.rbs
 homepage: https://github.com/hanazuki/nl
 licenses:
 - MIT
 metadata:
   homepage_uri: https://github.com/hanazuki/nl
-  source_code_uri: https://github.com/hanazuki/nl/tree/v0.2.4
+  source_code_uri: https://github.com/hanazuki/nl/tree/v0.4.1
   changelog_uri: https://github.com/hanazuki/nl/blob/master/CHANGELOG.md
 rdoc_options: []
 require_paths:
@@ -46,14 +102,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.4'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.6
+rubygems_version: 4.0.16
 specification_version: 4
-summary: Linux Netlink client
+summary: Netlink protocol support for Ruby
 test_files: []

data/lib/nl/core.rb

@@ -1,94 +0,0 @@
-# Data types and message handling
-
-require_relative 'endian'
-
-module Nl
-  module Core
-    module Constants
-      # From include/uapi/linux/netlink.h
-      NETLINK_ROUTE = 0
-      NETLINK_NETFILTER = 12
-      NETLINK_GENERIC = 16
-
-      NLM_F_REQUEST = 1
-      NLM_F_MULTI = 2
-      NLM_F_ACK = 4
-      NLM_F_ECHO = 8
-      NLM_F_DUMP_INTR = 16
-      NLM_F_DUMP_FILTERED = 32
-      NLM_F_ROOT = 0x100
-      NLM_F_MATCH = 0x200
-      NLM_F_ATOMIC = 0x400
-      NLM_F_DUMP = NLM_F_ROOT | NLM_F_MATCH
-      NLM_F_REPLACE = 0x100
-      NLM_F_EXCL = 0x200
-      NLM_F_CREATE = 0x400
-      NLM_F_APPEND = 0x800
-
-      NLMSG_ALIGNTO = 4
-      NLMSG_HDRLEN = 16
-
-      NLMSG_NOOP = 0x1
-      NLMSG_ERROR = 0x2
-      NLMSG_DONE = 0x3
-      NLMSG_OVERRUN = 0x4
-
-      NLMSG_MIN_TYPE = 0x10
-
-      NLA_F_NESTED = 1 << 15
-      NLA_F_NET_BYTEORDER = 1 << 14
-      NLA_TYPE_MASK = ~(NLA_F_NESTED | NLA_F_NET_BYTEORDER)
-
-      NLA_ALIGNTO = 4
-      NLA_HDRLEN = 4
-    end
-    include Constants
-
-    NlMsgHdr = Struct.new(:len, :type, :flags, :seq, :pid)
-    # Message header
-    class NlMsgHdr
-      FORMAT = Ractor.make_shareable([
-        Endian::Host::U32,
-        Endian::Host::U16,
-        Endian::Host::U16,
-        Endian::Host::U32,
-        Endian::Host::U32,
-      ])
-      private_constant :FORMAT
-
-      def self.decode(decoder)
-        obj = new(*decoder.get_values(FORMAT))
-        decoder.align_to(Constants::NLMSG_ALIGNTO)
-        obj
-      end
-
-      def encode(encoder)
-        encoder.reserve(Constants::NLMSG_HDRLEN)
-        encoder.put_values(FORMAT, to_a)
-        encoder.align_to(Constants::NLMSG_ALIGNTO)
-      end
-    end
-
-    NlAttr = Struct.new(:len, :type)
-    # Attribute header
-    class NlAttr
-      FORMAT = Ractor.make_shareable([
-        Endian::Host::U16,
-        Endian::Host::U16,
-      ])
-      private_constant :FORMAT
-
-      def self.decode(decoder)
-        obj = new(*decoder.get_values(FORMAT))
-        decoder.align_to(Constants::NLA_ALIGNTO)
-        obj
-      end
-
-      def encode(encoder)
-        encoder.reserve(Constants::NLA_HDRLEN)
-        encoder.put_values(FORMAT, to_a)
-        encoder.align_to(Constants::NLA_ALIGNTO)
-      end
-    end
-  end
-end

data/lib/nl/protocols/genl.rb

@@ -1,55 +0,0 @@
-module Nl
-  module Protocols
-    # The Generic Netlink protocol
-    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
-
-      private def default_family_id(name)
-        Nl::Genl::GENL_ID_CTRL if name == 'nlctrl'
-      end
-    end
-  end
-end

data/lib/nl/protocols/raw.rb

@@ -1,395 +0,0 @@
-require_relative '../encoder'
-require_relative '../decoder'
-
-module Nl
-  module Protocols
-    # The raw Netlink protocol
-    class Raw
-      class Done
-      end
-      class Ack
-      end
-
-      attr_reader :name, :protonum
-
-      def initialize(name, protonum)
-        @name = name
-        @protonum = protonum
-      end
-
-      def encode_message(encoder, message)
-        message.encode(encoder)
-      end
-
-      def decode_message(decoder, message_class)
-        header = NlMsgHdr.decode(decoder)
-        decoder.limit(header.len - Core::NLMSG_HDRLEN) do
-          message_class.decode(decoder, header)
-        end
-      end
-
-      def send_message(socket, message)
-        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))
-        seq_pid
-      end
-
-      def recv_message(socket, seq_pid, message_class)
-        data, = socket.recvmsg
-
-        decoder = Decoder.new(IO::Buffer.for(data))
-        while decoder.available?(Core::NLMSG_HDRLEN)
-          header = Core::NlMsgHdr.decode(decoder)
-          decoder.align_to(Core::NLMSG_ALIGNTO)
-          raise binding.irb unless [header.seq, header.pid] == seq_pid
-          if header.type < Core::NLMSG_MIN_TYPE
-            # Control messages
-            case header.type
-            when Core::NLMSG_ERROR
-              errno = decoder.get_value(Endian::Host::SINT)
-              if errno == 0
-                yield Ack.new
-              else
-                yield SystemCallError.new(-errno)
-              end
-              decoder.skip(header.len - Core::NLMSG_HDRLEN - 4)
-            when Core::NLMSG_DONE
-              yield Done.new
-              decoder.skip(header.len - Core::NLMSG_HDRLEN)
-            else
-              # just ignore NLMSG_NOOP and other unknown control messages
-              decoder.skip(header.len - Core::NLMSG_HDRLEN)
-            end
-          else
-            # Subsystem-specific messages
-            decoder.limit(header.len - Core::NLMSG_HDRLEN) do
-              decoder.align_to(Core::NLMSG_ALIGNTO)
-              yield message_class.decode(decoder, header)
-            end
-          end
-        end
-      end
-
-      # @param socket [Socket] Netlink socket
-      # @param type [:do, :dump] Request type
-      # @param request_class [Class] Request message class
-      # @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
-        flags |= type == :dump ? Core::NLM_F_DUMP : Core::NLM_F_ACK
-
-        request = request_class.from_params(args)
-        request.nlmsg_header.flags = flags
-        seq_pid = send_message(socket, request)
-
-        result = [] unless block_given?
-
-        done = false
-        begin
-          recv_message(socket, seq_pid, reply_class) do |message|
-            case message
-            when Done, Ack
-              done = true
-            when Exception
-              raise message
-            else
-              if block_given?
-                yield message
-              else
-                result << message
-              end
-            end
-          end
-        end until done
-
-        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
-        class Scalar
-          def initialize(type, check)
-            @type = type
-            @check = check
-          end
-
-          def encode(encoder, value)
-            value ||= 0
-            encoder.put_value(@type, value.tap(&@check))
-          end
-
-          def decode(decoder)
-            value = decoder.get_value(@type).tap(&@check)
-          end
-        end
-
-        class String
-          def initialize(check)
-            @check = check
-          end
-
-          def encode(encoder, value)
-            encoder.put_zstring(value)
-          end
-
-          def decode(decoder)
-            decoder.get_zstring
-          end
-        end
-
-        class Binary
-          def initialize(check)
-            @check = check
-          end
-
-          def encode(encoder, value)
-            encoder.put_string(value)
-          end
-
-          def decode(decoder)
-            decoder.get_string
-          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
-          end
-
-          def encode(encoder, value)
-            @attribute_set.encode(encoder, value)
-          end
-
-          def decode(decoder)
-            @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
-end