nl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b834199d097a768959ee9b81d4f8e08e504048b9bb537aefbbb3c737dcbc166b
+  data.tar.gz: 62fbdaaeb0ea9c4a5aefba149476f32dde99b16e210252566340b9627282bd4e
+SHA512:
+  metadata.gz: 218aabff17cc161fbb064f22e50c78c11770bc70df76636434bd648af2e3592bbafdb491b61daf8164be306f5d5bfe1e8e0ad968963c9c17756fcb06e826ed47
+  data.tar.gz: 4ff4dc4caf73c20e1b93e090689684534f8f8b184f15538eac47451293c4705918fbea24583949e1454882a850379341784d1226f3c7f8421d362c6b184fcc3e

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# ChangeLog
+
+## Unreleased
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Kasumi Hanazuki
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# nl
+
+Core library to handle Netlink sockets and data types.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/nl/core.rb

@@ -0,0 +1,94 @@
+# 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/decoder.rb

@@ -0,0 +1,86 @@
+module Nl
+  class Decoder
+    class Error < StandardError; end
+    class OutOfBounds < Error
+      def initialize(message = 'out of bounds') = super
+    end
+    class Unterminated < Error
+      def initialize(message = 'unterminated string') = super
+    end
+
+    def initialize(buffer, offset = 0, length = buffer.size - offset)
+      @buffer = buffer
+      @position = offset
+      @limit = length
+    end
+
+    def available?(size = 1)
+      @position + size <= @limit
+    end
+
+    def limit(size)
+      orig_limit = @limit
+      @limit = @position + size
+      result = yield self
+      if @limit != @position
+        raise "Not all bytes upto specified limit is consumed"
+      end
+      result
+    ensure
+      @limit = orig_limit
+    end
+
+    def skip(length = @limit - @position)
+      nposition = @position + length
+      raise OutOfBounds if nposition > @limit
+      @position = nposition
+    end
+
+    def get_string(length = @limit - @position)
+      nposition = @position + length
+      raise OutOfBounds if nposition > @limit
+      value = @buffer.get_string(@position, length)
+      @position = nposition
+      value
+    end
+
+    def get_zstring(unterminated_ok: false)
+      nposition = @position
+      nul_found = false
+      while nposition < @limit
+        c = @buffer.get_value(:U8, nposition)
+        nposition += 1
+        if c == 0
+          nul_found = true
+          break
+        end
+      end
+      raise Unterminated if !nul_found && !unterminated_ok
+      value = @buffer.get_string(@position, nposition - @position - (nul_found ? 1 : 0))
+      @position = nposition
+      value
+    end
+
+    def get_value(type)
+      nposition = @position + IO::Buffer.size_of(type)
+      raise OutOfBounds if nposition > @limit
+      value = @buffer.get_value(type, @position)
+      @position = nposition
+      value
+    end
+
+    def get_values(types)
+      nposition = @position + IO::Buffer.size_of(types)
+      raise OutOfBounds if nposition > @limit
+      values = @buffer.get_values(types, @position)
+      @position = nposition
+      values
+    end
+
+    def align_to(alignment)
+      nposition = (@position + alignment - 1) & ~(alignment - 1)
+      raise OutOfBounds if nposition > @limit
+      @position = nposition
+    end
+  end
+end

data/lib/nl/encoder.rb

@@ -0,0 +1,65 @@
+module Nl
+  class Encoder
+    attr_reader :position
+
+    def initialize(capacity = 4096)
+      @buffer = IO::Buffer.new(capacity)
+      @position = 0
+    end
+
+    def reserve(size)
+      nposition = @position + size
+      if @buffer.size < nposition
+        @buffer.resize([@buffer.size * 2, nposition].max)
+      end
+    end
+
+    def put_string(value)
+      reserve(value.bytesize)
+      @position = @buffer.set_string(value, @position)
+    end
+
+    def put_zstring(value)
+      reserve(value.bytesize + 1)
+      @position = @buffer.set_string(value, @position)
+      @position = @buffer.set_value(:U8, @position, 0)
+    end
+
+    def put_value(type, value)
+      reserve(IO::Buffer.size_of(type))
+      @position = @buffer.set_value(type, @position, value)
+    end
+
+    def put_values(types, values)
+      reserve(IO::Buffer.size_of(types))
+      @position = @buffer.set_values(types, @position, values)
+    end
+
+    def align_to(alignment)
+      if alignment > 1
+        nposition = (@position + alignment - 1) & ~(alignment - 1)
+        reserve(nposition - @position)
+        @position = nposition
+      end
+    end
+
+    def put_value_at(offset, type, value)
+      @buffer.set_value(type, offset, value)
+    end
+
+    def put_values_at(offset, types, values)
+      @buffer.set_values(types, offset, values)
+    end
+
+    def buffer
+      @buffer.slice(0, @position)
+    end
+
+    def measure(type, offset = 0)
+      before = @position
+      yield
+      after = @position
+      put_value_at(before + offset, type, after - before)
+    end
+  end
+end

data/lib/nl/endian.rb

@@ -0,0 +1,35 @@
+module Nl
+  module Endian
+    SIZEOF_INT = [1].pack('i!').bytesize
+    SIZEOF_LONG = [1].pack('l!').bytesize
+    SIZEOF_LLONG = [1].pack('q!').bytesize
+
+    module Little
+      U8, S8, U16, S16, U32, S32, U64, S64, F32, F64 = :U8, :S8, :u16, :s16, :u32, :s32, :u64, :s64, :f32, :f64
+    end
+
+    module Big
+      U8, S8, U16, S16, U32, S32, U64, S64, F32, F64 = :U8, :S8, :U16, :S16, :U32, :S32, :U64, :S64, :F32, :F64
+    end
+
+    module Host
+      include (IO::Buffer::HOST_ENDIAN == IO::Buffer::LITTLE_ENDIAN ? Little : Big)
+
+      UINT, SINT = case SIZEOF_INT
+        when 2; [U16, S16]
+        when 4; [U32, S32]
+        when 8; [U64, S64]
+        else raise "Unsupported 'int' size"
+        end
+      ULONG, SLONG = case SIZEOF_LONG
+        when 4; [U32, S32]
+        when 8; [U64, S64]
+        else raise "Unsupported 'long' size"
+        end
+      ULLONG, SLLONG = case SIZEOF_LLONG
+        when 8; [U64, S64]
+        else raise "Unsupported 'long long' size"
+        end
+    end
+  end
+end

data/lib/nl/family.rb

@@ -0,0 +1,163 @@
+require_relative 'socket'
+
+module Nl
+  class Family
+    def initialize(socket)
+      @socket = socket
+    end
+
+    def self.open
+      begin
+        socket = Socket.new(self::PROTONUM)
+        socket.bind(Socket.sockaddr_nl(0, 0))
+        if block_given?
+          yield new(socket)
+        else
+          return new(socket)
+        end
+      ensure
+        socket&.close if block_given?
+      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
+    end
+  end
+end

data/lib/nl/genl.rb

@@ -0,0 +1,65 @@
+# General Netlink message handling
+
+require_relative 'core'
+require_relative 'endian'
+
+module Nl
+  module Genl
+    module Constants
+      # From include/uapi/linux/genetlink.
+      GENL_NAMSIZ = 16
+      GENL_MIN_ID = Core::NLMSG_MIN_TYPE
+      GENL_MAX_ID = 1023
+
+      GENL_HDRLEN = 4
+
+      GENL_ID_GENERATE = 0
+      GENL_ID_CTRL = Core::NLMSG_MIN_TYPE
+      GENL_ID_VFS_DQUOT = Core::NLMSG_MIN_TYPE + 1
+      GENL_ID_PMCRAID = Core::NLMSG_MIN_TYPE + 2
+
+      CTRL_CMD_UNSPEC = 0
+      CTRL_CMD_NEWFAMILY = 1
+      CTRL_CMD_DELFAMILY = 2
+      CTRL_CMD_GETFAMILY = 3
+      CTRL_CMD_NEWOPS = 4
+      CTRL_CMD_DELOPS = 5
+      CTRL_CMD_GETOPS = 6
+      CTRL_CMD_NEWMCAST_GRP = 7
+      CTRL_CMD_DELMCAST_GRP = 8
+      CTRL_CMD_GETMCAST_GRP = 9
+
+      CTRL_ATTR_UNSPEC = 0
+      CTRL_ATTR_FAMILY_ID = 1
+      CTRL_ATTR_FAMILY_NAME = 2
+      CTRL_ATTR_VERSION = 3
+      CTRL_ATTR_HDRSIZE = 4
+      CTRL_ATTR_MAXATTR = 5
+      CTRL_ATTR_OPS = 6
+      CTRL_ATTR_MCAST_GROUPS = 7
+
+      CTRL_ATTR_OP_UNSPEC = 0
+      CTRL_ATTR_OP_ID = 1
+      CTRL_ATTR_OP_FLAGS = 2
+
+      CTRL_ATTR_MCAST_GRP_UNSPEC = 0
+      CTRL_ATTR_MCAST_GRP_NAME = 1
+      CTRL_ATTR_MCAST_GRP_ID = 2
+    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
+
+      def self.parse(buffer, offset)
+        new(*buffer.get_values(GENLMSGHDR_FMT, offset))
+      end
+    end
+  end
+end

data/lib/nl/protocols/genl.rb

@@ -0,0 +1,15 @@
+module Nl
+  module Protocols
+    # The Generic Netlink protocol
+      class Genl < Raw  # TODO: Implement
+      def initialize(name)
+        super(name, NETLINK_GENERIC)
+      end
+
+      def parse(buffer, offset)
+        nlmsg = super(buffer, offset)
+        genlmsg = GenlMsgHdr.parse(nlmsg.data, 0)
+      end
+    end
+  end
+end

data/lib/nl/protocols/raw.rb

@@ -0,0 +1,169 @@
+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.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 | Core::NLM_F_ACK
+        flags |= Core::NLM_F_DUMP if type == :dump
+
+        request = request_class.from_params(args)
+        request.header.flags = flags
+        seq_pid = send_message(socket, request)
+
+        result = []
+
+        done = false
+        acked = false
+        begin
+          recv_message(socket, seq_pid, reply_class) do |message|
+            case message
+            when Done
+              done = true
+            when Exception
+              raise
+            when Ack
+              acked = true
+            else
+              result << message
+              done = true if type == :do
+            end
+          end
+        end until done
+
+        result
+      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 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
+      end
+    end
+  end
+end

data/lib/nl/socket.rb

@@ -0,0 +1,53 @@
+# Netlink sockets
+
+require 'socket'
+
+module Nl
+  # Netlink socket
+  class Socket < ::Socket
+    module Constants
+      # From include/linux/socket.h
+      PF_NETLINK = AF_NETLINK = 16
+    end
+    include Constants
+
+    class << self
+      def pack_sockaddr_nl(pid, groups) = [Socket::AF_NETLINK, 0, pid, groups].pack('S!S!LL')
+      alias sockaddr_nl pack_sockaddr_nl
+
+      def unpack_sockaddr_nl(sockaddr) = sockaddr.unpack('S!S!LL')[2..3]
+    end
+
+    # @param protonum [Integer] Netlink protocol number
+    def initialize(protonum)
+      super(PF_NETLINK, SOCK_RAW, protonum)
+      @seq = 0  # last-used sequence number
+    end
+
+    def self.open(protonum)
+      return new(protonum) unless block_given?
+      begin
+        socket = new(protonum)
+        yield socket
+      ensure
+        socket&.close
+      end
+    end
+
+    # XXX: Should Protocol manage next_seq?
+
+    # @return [Integer] Get next sequence number
+    def next_seq
+      nseq = (@seq + 1) & 0xFFFFFFFF
+      nseq = 1 if nseq == 0  # seq=0 is for notification
+      @seq = nseq
+    end
+
+    def complete(hdr)
+      [
+        hdr.seq ||= next_seq,
+        hdr.pid ||= Socket.unpack_sockaddr_nl(local_address.to_sockaddr).first,
+      ]
+    end
+  end
+end

data/lib/nl/version.rb

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

data/lib/nl.rb

@@ -0,0 +1,14 @@
+require_relative 'nl/version'
+require_relative 'nl/core'
+require_relative 'nl/genl'
+require_relative 'nl/socket'
+require_relative 'nl/family'
+require_relative 'nl/protocols/raw'
+require_relative 'nl/protocols/genl'
+
+module Nl
+  class Error < StandardError; end
+
+  include Core
+  include Genl
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: nl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kasumi Hanazuki
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Linux Netlink client
+email:
+- kasumi@rollingapple.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/nl.rb
+- lib/nl/core.rb
+- lib/nl/decoder.rb
+- lib/nl/encoder.rb
+- lib/nl/endian.rb
+- lib/nl/family.rb
+- lib/nl/genl.rb
+- lib/nl/protocols/genl.rb
+- lib/nl/protocols/raw.rb
+- lib/nl/socket.rb
+- lib/nl/version.rb
+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.1.0
+  changelog_uri: https://github.com/hanazuki/nl/blob/master/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.8
+specification_version: 4
+summary: Linux Netlink client
+test_files: []