nl 0.3.0 → 0.4.2

data/sig/generated/nl/genl.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/nl/genl.rb with RBS::Inline
+
+module Nl
+  # Generic Netlink families.
+  module Genl
+    # Base class for Generic Netlink families.
+    class Family < Nl::Family
+      # Returns the family-specific protocol version.
+      #
+      # @return [Integer] the protocol version
+      # @rbs () -> Integer
+      def self.version: () -> Integer
+
+      # Opens a session for this Generic Netlink family.
+      #
+      # @overload open(resolver:, executor: nil, notification_capacity: DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the session.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Family] the opened family session
+      # @overload open(resolver:, executor: nil, notification_capacity: DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The session is automatically closed after the block returns.
+      #   @param [#call] resolver a callable that resolves a family name to {FamilyInfo}
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Family] session the opened family session
+      #   @return [Object] the value returned from the block
+      # @rbs (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> (Nl::Family::Session & instance)
+      #    | [R] (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) -> (Nl::Family::Session & instance)
+                   | [R] (resolver: ^(Client, ::String) -> FamilyInfo, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+    end
+
+    # Base class for Generic Netlink messages.
+    #
+    # A Generic Netlink message payload begins with a {GenlMsgHdr}, followed by
+    # the optional fixed header and attributes handled by {Raw::Message}.
+    class Message < Raw::Message
+      # Decodes a Generic Netlink message payload.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @param [Integer] type the family ID from the Netlink message header
+      # @return [Message] the decoded message
+      # @raise [RuntimeError] if the command does not match the message class's type
+      # @rbs (Decoder decoder, type: Integer) -> instance
+      def self.decode: (Decoder decoder, type: Integer) -> instance
+    end
+  end
+end

data/sig/generated/nl/notification.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/nl/notification.rb with RBS::Inline
+
+module Nl
+  # A multicast group. `name` is the kernel-facing name.
+  # `id` is the fixed ID when the specification provides one.
+  class McastGroup < Data
+    attr_reader name(): untyped
+
+    attr_reader id(): untyped
+
+    def self.new: (untyped name, untyped id) -> instance
+                | (name: untyped, id: untyped) -> instance
+
+    def self.members: () -> [ :name, :id ]
+
+    def members: () -> [ :name, :id ]
+  end
+
+  # Thread-safe queue shared by a family's blocking and asynchronous facades.
+  class NotificationChannel
+    def initialize: (capacity: untyped) -> untyped
+
+    # Adds a notification without ever blocking the socket receive loop.
+    # Returns false after the channel has been closed.
+    def push: (untyped notification) -> untyped
+
+    # Records a broken notification boundary while allowing later delivery to
+    # resume after the consumer observes the error and resynchronizes state.
+    def fail: (untyped error) -> untyped
+
+    def pop: (?timeout: untyped) -> untyped
+
+    def empty?: () -> untyped
+
+    def close: () -> untyped
+
+    private def lose!: (untyped error) -> untyped
+  end
+
+  # An unbounded-in-time, single-family view of unsolicited messages.
+  class NotificationStream
+    include Enumerable[untyped]
+
+    def initialize: () ?{ (?) -> untyped } -> untyped
+
+    def next: (?timeout: untyped) -> untyped
+
+    # @rbs () -> Enumerator[untyped, void]
+    #  | () { (untyped) -> void } -> void
+    def each: () -> Enumerator[untyped, void]
+            | () { (untyped) -> void } -> void
+  end
+end

data/sig/generated/nl/notification_router.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/nl/notification_router.rb with RBS::Inline
+
+module Nl
+  # Routes unsolicited frames to per-family notification channels.
+  class NotificationRouter
+    class Entry < Struct[untyped]
+      attr_accessor endpoint(): untyped
+
+      attr_accessor classes(): untyped
+
+      attr_accessor channel(): untyped
+
+      def self.new: (?untyped endpoint, ?untyped classes, ?untyped channel) -> instance
+                  | (?endpoint: untyped, ?classes: untyped, ?channel: untyped) -> instance
+    end
+
+    def initialize: (protocol: untyped, capacity: untyped) -> untyped
+
+    def register: (untyped endpoint, untyped classes) -> untyped
+
+    def channel: (untyped endpoint) -> untyped
+
+    # Returns true if the frame belongs to a registered notification family.
+    def route: (untyped header, untyped payload) -> untyped
+
+    def close: () -> untyped
+
+    def lose_all: (untyped error) -> untyped
+  end
+end

data/sig/generated/nl/raw/client.rbs

@@ -0,0 +1,49 @@
+# Generated from lib/nl/raw/client.rb with RBS::Inline
+
+module Nl
+  module Raw
+    # Owns one raw Netlink connection shared by compatible families.
+    class Client
+      # Opens a client for a raw Netlink protocol.
+      #
+      # @overload open(protonum:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the client.
+      #   @param [Integer] protonum the Netlink protocol number
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Client] the opened client
+      # @overload open(protonum:, executor: nil, notification_capacity: Nl::Connection::DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The client is automatically closed after the block returns.
+      #   @param [Integer] protonum the Netlink protocol number
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Client] client the opened client
+      #   @return [Object] the value returned from the block
+      # @rbs (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+      #    | [R] (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> instance
+                   | [R] (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+
+      # @param [Integer] protonum the Netlink protocol number
+      # @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      # @param [Integer] notification_capacity the maximum number of queued notifications
+      # @rbs (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> void
+      def initialize: (protonum: Integer, ?executor: executor?, ?notification_capacity: Integer?) -> void
+
+      # Builds a family backed by this client's connection.
+      #
+      # @param [Class<Family>] family_class a raw Netlink family class
+      # @return [Family] an instance of `family_class`
+      # @raise [TypeError] if +family_class+ does not inherit from {Family}
+      # @raise [ArgumentError] if the family's protocol number differs from the client's protocol number
+      # @rbs [F < Family] (_FamilyClass[F] family_class) -> F
+      def family: [F < Family] (_FamilyClass[F] family_class) -> F
+
+      # Closes the underlying Netlink connection.
+      #
+      # @return [void]
+      # @rbs () -> void
+      def close: () -> void
+    end
+  end
+end

data/sig/generated/nl/raw/protocol.rbs

@@ -0,0 +1,122 @@
+# Generated from lib/nl/raw/protocol.rb with RBS::Inline
+
+module Nl
+  module Raw
+    class AckFrame < Data
+      attr_reader header(): untyped
+
+      def self.new: (untyped header) -> instance
+                  | (header: untyped) -> instance
+
+      def self.members: () -> [ :header ]
+
+      def members: () -> [ :header ]
+    end
+
+    class ErrorFrame < Data
+      attr_reader header(): untyped
+
+      attr_reader errno(): untyped
+
+      def self.new: (untyped header, untyped errno) -> instance
+                  | (header: untyped, errno: untyped) -> instance
+
+      def self.members: () -> [ :header, :errno ]
+
+      def members: () -> [ :header, :errno ]
+    end
+
+    class DoneFrame < Data
+      attr_reader header(): untyped
+
+      attr_reader errno(): untyped
+
+      def self.new: (untyped header, untyped errno) -> instance
+                  | (header: untyped, errno: untyped) -> instance
+
+      def self.members: () -> [ :header, :errno ]
+
+      def members: () -> [ :header, :errno ]
+    end
+
+    class UnknownFrame < Data
+      attr_reader header(): untyped
+
+      def self.new: (untyped header) -> instance
+                  | (header: untyped) -> instance
+
+      def self.members: () -> [ :header ]
+
+      def members: () -> [ :header ]
+    end
+
+    class DataFrame < Data
+      attr_reader header(): untyped
+
+      attr_reader message(): untyped
+
+      def self.new: (untyped header, untyped message) -> instance
+                  | (header: untyped, message: untyped) -> instance
+
+      def self.members: () -> [ :header, :message ]
+
+      def members: () -> [ :header, :message ]
+    end
+
+    class Request < Data
+      attr_reader type(): untyped
+
+      attr_reader flags(): untyped
+
+      attr_reader message(): untyped
+
+      def self.new: (untyped type, untyped flags, untyped message) -> instance
+                  | (type: untyped, flags: untyped, message: untyped) -> instance
+
+      def self.members: () -> [ :type, :flags, :message ]
+
+      def members: () -> [ :type, :flags, :message ]
+    end
+
+    # A generated raw Netlink family bound to its fixed wire identity.
+    class Endpoint
+      attr_reader definition: untyped
+
+      def initialize: (untyped definition) -> untyped
+
+      def name: () -> untyped
+
+      def frame_type: (untyped message_class) -> untyped
+
+      def multicast_group_id: (untyped name, untyped value) -> untyped
+    end
+
+    # Socket-wide wire behavior for a classic (netlink-raw) protocol.
+    class Protocol
+      attr_reader protonum: untyped
+
+      def initialize: (untyped protonum) -> untyped
+
+      def encode_message: (untyped encoder, untyped _endpoint, untyped request, seq: untyped, pid: untyped) -> untyped
+
+      # Decodes one frame using the reply class associated with its sequence.
+      def decode_frame: (untyped _endpoint, untyped header, untyped payload, untyped message_class) -> untyped
+
+      def send_message: (untyped socket, untyped endpoint, untyped request, seq: untyped, pid: untyped) -> untyped
+
+      def build_request: (untyped endpoint, untyped kind, untyped request_class, untyped args) -> untyped
+
+      def notification_channel_key: (untyped endpoint) -> untyped
+
+      def notification_route_keys: (untyped _endpoint, untyped classes) -> untyped
+
+      def notification_frame_key: (untyped header) -> untyped
+
+      def notification_frame?: (untyped _endpoint, untyped header, untyped _payload) -> untyped
+
+      def notification_class: (untyped _endpoint, untyped header, untyped _payload, untyped classes) -> untyped
+
+      def decode_notification: (untyped endpoint, untyped header, untyped payload, untyped message_class) -> untyped
+    end
+  end
+end

data/sig/generated/nl/raw/wire.rbs

@@ -0,0 +1,151 @@
+# Generated from lib/nl/raw/wire.rb with RBS::Inline
+
+module Nl
+  module Raw
+    # Constants from <linux/netlink.h>
+    module Constants
+      NETLINK_ROUTE: ::Integer
+
+      NETLINK_NETFILTER: ::Integer
+
+      NETLINK_GENERIC: ::Integer
+
+      NLM_F_REQUEST: ::Integer
+
+      NLM_F_MULTI: ::Integer
+
+      NLM_F_ACK: ::Integer
+
+      NLM_F_ECHO: ::Integer
+
+      NLM_F_DUMP_INTR: ::Integer
+
+      NLM_F_DUMP_FILTERED: ::Integer
+
+      NLM_F_ROOT: ::Integer
+
+      NLM_F_MATCH: ::Integer
+
+      NLM_F_ATOMIC: ::Integer
+
+      NLM_F_DUMP: untyped
+
+      NLM_F_REPLACE: ::Integer
+
+      NLM_F_EXCL: ::Integer
+
+      NLM_F_CREATE: ::Integer
+
+      NLM_F_APPEND: ::Integer
+
+      NLMSG_ALIGNTO: ::Integer
+
+      NLMSG_HDRLEN: ::Integer
+
+      NLMSG_NOOP: ::Integer
+
+      NLMSG_ERROR: ::Integer
+
+      NLMSG_DONE: ::Integer
+
+      NLMSG_OVERRUN: ::Integer
+
+      NLMSG_MIN_TYPE: ::Integer
+
+      NLA_F_NESTED: untyped
+
+      NLA_F_NET_BYTEORDER: untyped
+
+      NLA_TYPE_MASK: untyped
+
+      NLA_ALIGNTO: ::Integer
+
+      NLA_HDRLEN: ::Integer
+    end
+
+    include Constants
+
+    # Fixed-format metadata header prepended to every Netlink message.
+    #
+    # This corresponds to Linux's +struct nlmsghdr+.
+    #
+    # @!attribute [rw] len
+    #   @return [Integer] message length in bytes, including this header
+    # @!attribute [rw] type
+    #   @return [Integer] message content type
+    # @!attribute [rw] flags
+    #   @return [Integer] bitwise combination of +NLM_F_+ flags
+    # @!attribute [rw] seq
+    #   @return [Integer] sequence number used to correlate requests and replies
+    # @!attribute [rw] pid
+    #   @return [Integer] sender's Netlink port ID
+    class NlMsgHdr < Struct[Integer]
+      attr_accessor len(): Integer
+
+      attr_accessor type(): Integer
+
+      attr_accessor flags(): Integer
+
+      attr_accessor seq(): Integer
+
+      attr_accessor pid(): Integer
+
+      def self.new: (?Integer len, ?Integer type, ?Integer flags, ?Integer seq, ?Integer pid) -> instance
+                  | (?len: Integer, ?type: Integer, ?flags: Integer, ?seq: Integer, ?pid: Integer) -> instance
+    end
+
+    class NlMsgHdr
+      FORMAT: untyped
+
+      # Decodes a header from the decoder's current position.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @return [NlMsgHdr] the decoded header
+      # @rbs (Decoder decoder) -> instance
+      def self.decode: (Decoder decoder) -> instance
+
+      # Encodes this header at the encoder's current position.
+      #
+      # @param [Encoder] encoder the destination encoder
+      # @return [void]
+      # @rbs (Encoder encoder) -> void
+      def encode: (Encoder encoder) -> void
+    end
+
+    # Fixed-format header prepended to every Netlink attribute.
+    #
+    # This corresponds to Linux's +struct nlattr+.
+    #
+    # @!attribute [rw] len
+    #   @return [Integer] attribute length in bytes, including this header but
+    #     excluding trailing alignment padding
+    # @!attribute [rw] type
+    #   @return [Integer] attribute type combined with optional +NLA_F_+ flags
+    class NlAttr < Struct[Integer]
+      attr_accessor len(): Integer
+
+      attr_accessor type(): Integer
+
+      def self.new: (?Integer len, ?Integer type) -> instance
+                  | (?len: Integer, ?type: Integer) -> instance
+    end
+
+    class NlAttr
+      FORMAT: untyped
+
+      # Decodes an attribute header from the decoder's current position.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @return [NlAttr] the decoded header
+      # @rbs (Decoder decoder) -> instance
+      def self.decode: (Decoder decoder) -> instance
+
+      # Encodes this attribute header at the encoder's current position.
+      #
+      # @param [Encoder] encoder the destination encoder
+      # @return [void]
+      # @rbs (Encoder encoder) -> void
+      def encode: (Encoder encoder) -> void
+    end
+  end
+end

data/sig/generated/nl/raw.rbs

@@ -0,0 +1,70 @@
+# Generated from lib/nl/raw.rb with RBS::Inline
+
+module Nl
+  # Classic (Raw) Netlink families.
+  module Raw
+    # Base class for Raw Netlink families.
+    class Family < Nl::Family
+      # Opens a session for this raw Netlink family.
+      #
+      # @overload open(executor: nil, notification_capacity: DEFAULT_NOTIFICATION_CAPACITY)
+      #   The caller is responsible for closing the session.
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @return [Family] the opened family session
+      # @overload open(executor: nil, notification_capacity: DEFAULT_NOTIFICATION_CAPACITY, &block)
+      #   The session is automatically closed after the block returns.
+      #   @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      #   @param [Integer] notification_capacity the maximum number of queued notifications
+      #   @yieldparam [Family] session the opened family session
+      #   @return [Object] the value returned from the block
+      # @rbs (?executor: executor?, ?notification_capacity: Integer?) -> (Nl::Family::Session & instance)
+      #    | [R] (?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+      def self.open: (?executor: executor?, ?notification_capacity: Integer?) -> (Nl::Family::Session & instance)
+                   | [R] (?executor: executor?, ?notification_capacity: Integer?) { (instance) -> R } -> R
+
+      # Builds a session that owns its underlying client.
+      #
+      # @param [:thread, :fiber, nil] executor the asynchronous executor, or `nil` for blocking operation
+      # @param [Integer] notification_capacity the maximum number of queued notifications
+      # @return [Family] the opened family session
+      # @rbs (executor: executor?, notification_capacity: Integer) -> (Nl::Family::Session & instance)
+      private def self.build_session: (executor: executor?, notification_capacity: Integer) -> (Nl::Family::Session & instance)
+    end
+
+    # Base class for raw Netlink messages.
+    #
+    # A message may contain a fixed header followed by a set of Netlink
+    # attributes.
+    class Message
+      include Nl::StructuredPayload
+
+      # @param [Object, nil] fixed_header the family-specific fixed header
+      # @param [AttributeSet, nil] attributes the message's attributes
+      # @rbs (?untyped fixed_header, ?AttributeSet? attributes) -> void
+      def initialize: (?untyped fixed_header, ?AttributeSet? attributes) -> void
+
+      # Appends an attribute to the message.
+      #
+      # @param [AttributeSet::Attribute] attribute the attribute to append
+      # @return [void]
+      # @rbs (AttributeSet::Attribute attribute) -> void
+      def append_attribute: (AttributeSet::Attribute attribute) -> void
+
+      # Decodes a raw Netlink message payload.
+      #
+      # @param [Decoder] decoder the source decoder
+      # @param [Integer] type the message type from its Netlink header
+      # @return [Message] the decoded message
+      # @raise [RuntimeError] if +type+ does not match the message class's type
+      # @rbs (Decoder decoder, type: Integer) -> instance
+      def self.decode: (Decoder decoder, type: Integer) -> instance
+
+      # Returns the attribute names accepted by this message.
+      #
+      # @return [Array<Symbol>] the attribute names
+      # @rbs () -> Array[Symbol]
+      private def self.attribute_names: () -> Array[Symbol]
+    end
+  end
+end

data/sig/generated/nl/sequence_allocator.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/nl/sequence_allocator.rb with RBS::Inline
+
+module Nl
+  # Allocates nonzero 32-bit Netlink sequence numbers.
+  class SequenceAllocator
+    MAX: ::Integer
+
+    def initialize: () -> untyped
+
+    # Returns the next sequence number not rejected by the optional block.
+    def next: () -> untyped
+
+    private def advance: () -> untyped
+  end
+end

data/sig/generated/nl/socket.rbs

@@ -0,0 +1,59 @@
+# Generated from lib/nl/socket.rb with RBS::Inline
+
+module Nl
+  # Netlink socket
+  class Socket < ::Socket
+    module Constants
+      # From linux/socket.h
+      # -
+      PF_NETLINK: untyped
+
+      # From linux/netlink.h
+      # -
+      SOL_NETLINK: ::Integer
+
+      NETLINK_ADD_MEMBERSHIP: ::Integer
+
+      NETLINK_DROP_MEMBERSHIP: ::Integer
+    end
+
+    include Constants
+
+    # Packs Netlink socket address
+    #
+    # @rbs (Integer pid, Integer groups) -> String
+    def self.pack_sockaddr_nl: (Integer pid, Integer groups) -> String
+
+    alias self.sockaddr_nl self.pack_sockaddr_nl
+
+    # Unpacks Netlink socket address
+    #
+    # @rbs (String) -> [Integer, Integer]
+    def self.unpack_sockaddr_nl: (String) -> [ Integer, Integer ]
+
+    # @param [Integer] protonum Netlink protocol number
+    # @rbs (Integer) -> void
+    def initialize: (Integer) -> void
+
+    # Opens a Netlink socket for the specified protocol number.
+    #
+    # @rbs (Integer protonum) -> instance
+    #    | [R] (Integer protonum) { (instance) -> R } -> R
+    def self.open: (Integer protonum) -> instance
+                 | [R] (Integer protonum) { (instance) -> R } -> R
+
+    # @return [Integer] Local Netlink port ID assigned to this socket
+    # @rbs () -> Integer
+    def local_port_id: () -> Integer
+
+    # Adds this socket to a Netlink multicast group.
+    #
+    # @rbs (Integer group_id) -> void
+    def add_membership: (Integer group_id) -> void
+
+    # Removes this socket from a Netlink multicast group.
+    #
+    # @rbs (Integer group_id) -> void
+    def drop_membership: (Integer group_id) -> void
+  end
+end

data/sig/generated/nl/structured_payload.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/nl/structured_payload.rb with RBS::Inline
+
+module Nl
+  # Shared handling for a payload containing an optional fixed header followed
+  # by an optional attribute set.
+  module StructuredPayload
+    def self.included: (untyped base) -> untyped
+
+    attr_accessor fixed_header: untyped
+
+    attr_accessor attributes: untyped
+
+    def initialize: (?untyped fixed_header, ?untyped attributes) -> untyped
+
+    module ClassMethods
+      def from_params: (?untyped params, ?external_selectors: untyped, **untyped keywords) -> untyped
+
+      def decode: (untyped decoder, ?external_selectors: untyped) -> untyped
+
+      private def attribute_names: () -> untyped
+    end
+
+    def encode: (untyped encoder, ?external_selectors: untyped) -> untyped
+  end
+end