redhound 1.0.1 → 2.0.0.rc2

data/sig/generated/redhound/capture/file_source.rbs

@@ -0,0 +1,67 @@
+# Generated from lib/redhound/capture/file_source.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    class FileSource < Source
+      class ReadStopped < StandardError
+      end
+
+      # @api private
+      class FileInput
+        # @rbs (::File io) -> void
+        def initialize: (::File io) -> void
+
+        # @rbs (Integer length) -> String?
+        def read: (Integer length) -> String?
+      end
+
+      # Nonregular inputs need bounded polling so Source#stop can interrupt an idle pipe.
+      class StreamInput
+        # @rbs (IO io, Source source) -> void
+        def initialize: (IO io, Source source) -> void
+
+        # @rbs (Integer length) -> String?
+        def read: (Integer length) -> String?
+      end
+
+      attr_reader reader: untyped
+
+      # @rbs (untyped input, ?filter: String?) -> void
+      def initialize: (untyped input, ?filter: String?) -> void
+
+      # @rbs (untyped input, ?filter: String?) -> FileSource
+      # @rbs [T] (untyped input, ?filter: String?) { (FileSource) -> T } -> T
+      def self.open: (untyped input, ?filter: String?) -> FileSource
+                   | [T] (untyped input, ?filter: String?) { (FileSource) -> T } -> T
+
+      # @rbs (?timeout: Numeric?) -> Packet?
+      def next_packet: (?timeout: Numeric?) -> Packet?
+
+      # @rbs (Filter::Program? program) -> void
+      def attach_filter: (Filter::Program? program) -> void
+
+      # @rbs () -> Integer
+      def linktype: () -> Integer
+
+      # @rbs () -> Array[Interface]
+      def interfaces: () -> Array[Interface]
+
+      # @rbs () -> Stats
+      def stats: () -> Stats
+
+      # @rbs () -> void
+      def stop: () -> void
+
+      # @rbs () -> void
+      def close: () -> void
+
+      private
+
+      # A single bounded worker preserves partial records across caller timeouts.
+      # @rbs (Numeric? timeout) -> (Packet | nil | :wait_readable)
+      def read_packet: (Numeric? timeout) -> (Packet | nil | :wait_readable)
+    end
+  end
+end

data/sig/generated/redhound/capture/interface.rbs

@@ -0,0 +1,53 @@
+# Generated from lib/redhound/capture/interface.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    class Interface
+      attr_reader name: untyped
+
+      attr_reader index: untyped
+
+      attr_reader linktype: untyped
+
+      attr_reader snaplen: untyped
+
+      attr_reader flags: untyped
+
+      attr_reader mtu: untyped
+
+      attr_reader mac: untyped
+
+      attr_reader description: untyped
+
+      attr_reader filter: untyped
+
+      attr_reader meta: untyped
+
+      # @rbs (name: String, ?index: Integer, ?linktype: Integer, ?snaplen: Integer, ?flags: Integer, ?mtu: Integer?, ?mac: String?, ?description: String?, ?filter: String?, ?meta: Hash[Symbol, untyped]) -> void
+      def initialize: (name: String, ?index: Integer, ?linktype: Integer, ?snaplen: Integer, ?flags: Integer, ?mtu: Integer?, ?mac: String?, ?description: String?, ?filter: String?, ?meta: Hash[Symbol, untyped]) -> void
+
+      # @rbs () -> Integer
+      def ifindex: () -> Integer
+
+      # @rbs () -> bool
+      def up?: () -> bool
+
+      # @rbs () -> bool
+      def loopback?: () -> bool
+
+      # @rbs () -> bool
+      def running?: () -> bool
+
+      # @rbs () -> String
+      def to_s: () -> String
+
+      # @rbs () -> Array[Interface]
+      def self.all: () -> Array[Interface]
+
+      # @rbs (String | Integer value) -> Interface
+      def self.find: (String | Integer value) -> Interface
+    end
+  end
+end

data/sig/generated/redhound/capture/linktype.rbs

@@ -0,0 +1,20 @@
+# Generated from lib/redhound/capture/linktype.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linktype
+      VALUES: untyped
+
+      # @rbs (Integer | Symbol | String value) -> Integer
+      def self.resolve: (Integer | Symbol | String value) -> Integer
+
+      # @rbs (Integer value) -> String
+      def self.name: (Integer value) -> String
+
+      # @rbs (Integer hardware_type) -> Integer
+      def self.for_hardware: (Integer hardware_type) -> Integer
+    end
+  end
+end

data/sig/generated/redhound/capture/linux/constants.rbs

@@ -0,0 +1,58 @@
+# Generated from lib/redhound/capture/linux/constants.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      module Constants
+        AF_PACKET: ::Integer
+
+        SOL_PACKET: ::Integer
+
+        ETH_P_ALL: ::Integer
+
+        PACKET_ADD_MEMBERSHIP: ::Integer
+
+        PACKET_RX_RING: ::Integer
+
+        PACKET_STATISTICS: ::Integer
+
+        PACKET_VERSION: ::Integer
+
+        PACKET_IGNORE_OUTGOING: ::Integer
+
+        PACKET_MR_PROMISC: ::Integer
+
+        PACKET_OUTGOING: ::Integer
+
+        SO_ATTACH_FILTER: ::Integer
+
+        SO_RCVBUFFORCE: ::Integer
+
+        TPACKET_V3: ::Integer
+
+        SIOCGSTAMPNS: ::Integer
+
+        SIOCGIFHWADDR: ::Integer
+
+        SIOCGIFMTU: ::Integer
+
+        SIOCGIFFLAGS: ::Integer
+
+        TP_STATUS_USER: ::Integer
+
+        TP_STATUS_CSUMNOTREADY: ::Integer
+
+        TP_STATUS_VLAN_VALID: ::Integer
+
+        TP_STATUS_VLAN_TPID_VALID: ::Integer
+
+        TP_STATUS_CSUM_VALID: ::Integer
+
+        RECEIVE_SIZE: ::Integer
+      end
+    end
+  end
+end

data/sig/generated/redhound/capture/linux/cooked.rbs

@@ -0,0 +1,15 @@
+# Generated from lib/redhound/capture/linux/cooked.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      module Cooked
+        # @rbs (SockaddrLL address) -> String
+        def self.header: (SockaddrLL address) -> String
+      end
+    end
+  end
+end

data/sig/generated/redhound/capture/linux/ifreq.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/redhound/capture/linux/ifreq.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      module Ifreq
+        # @rbs (String name, Integer command) -> String
+        def self.query: (String name, Integer command) -> String
+
+        # @rbs (String name, ?index: Integer) -> Interface
+        def self.interface: (String name, ?index: Integer) -> Interface
+      end
+    end
+  end
+end

data/sig/generated/redhound/capture/linux/packet_socket.rbs

@@ -0,0 +1,64 @@
+# Generated from lib/redhound/capture/linux/packet_socket.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      class PacketSocket < Source
+        attr_reader socket: untyped
+
+        attr_reader linktype: untyped
+
+        attr_reader interfaces: untyped
+
+        # @rbs (interface: String | Integer | Interface, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> void
+        def initialize: (interface: String | Integer | Interface, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> void
+
+        # @rbs (?timeout: Numeric?) -> Packet?
+        def next_packet: (?timeout: Numeric?) -> Packet?
+
+        # @rbs (untyped program) -> void
+        def attach_filter: (untyped program) -> void
+
+        # @rbs () -> Stats
+        def stats: () -> Stats
+
+        # @rbs () -> void
+        def close: () -> void
+
+        # Positive filter returns select packets; the source applies its configured snaplen.
+        # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions) -> Array[[Integer, Integer, Integer, Integer]]
+        def receive_filter: (Array[[ Integer, Integer, Integer, Integer ]] instructions) -> Array[[ Integer, Integer, Integer, Integer ]]
+
+        # @rbs () -> void
+        def warn_vlan_offload: () -> void
+
+        # @rbs () -> void
+        def close_resources: () -> void
+
+        # @rbs () -> void
+        def prime_timestamp: () -> void
+
+        # @rbs () -> Integer
+        def receive_snaplen: () -> Integer
+
+        # @rbs (Integer? buffer_size) -> void
+        def setup_receive_buffer: (Integer? buffer_size) -> void
+
+        # @rbs (SockaddrLL address) -> bool
+        def accept_direction?: (SockaddrLL address) -> bool
+
+        # @rbs (SockaddrLL address) -> Interface
+        def packet_interface: (SockaddrLL address) -> Interface
+
+        # @rbs () -> Integer
+        def interface_dropped: () -> Integer
+
+        # @rbs () -> Integer
+        def timestamp: () -> Integer
+      end
+    end
+  end
+end

data/sig/generated/redhound/capture/linux/sockaddr_ll.rbs

@@ -0,0 +1,31 @@
+# Generated from lib/redhound/capture/linux/sockaddr_ll.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      class SockaddrLL
+        attr_reader protocol: untyped
+
+        attr_reader index: untyped
+
+        attr_reader hatype: untyped
+
+        attr_reader pkttype: untyped
+
+        attr_reader address: untyped
+
+        # @rbs (?protocol: Integer, ?index: Integer, ?hatype: Integer, ?pkttype: Integer, ?address: String) -> void
+        def initialize: (?protocol: Integer, ?index: Integer, ?hatype: Integer, ?pkttype: Integer, ?address: String) -> void
+
+        # @rbs () -> String
+        def to_sockaddr: () -> String
+
+        # @rbs (String bytes) -> SockaddrLL
+        def self.parse: (String bytes) -> SockaddrLL
+      end
+    end
+  end
+end

data/sig/generated/redhound/capture/linux/tpacket_v3.rbs

@@ -0,0 +1,35 @@
+# Generated from lib/redhound/capture/linux/tpacket_v3.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    module Linux
+      # @api private
+      class TPacketV3 < PacketSocket
+        # @rbs (?timeout: Numeric?) -> Packet?
+        def next_packet: (?timeout: Numeric?) -> Packet?
+
+        # @rbs () -> void
+        def close_resources: () -> void
+
+        # @rbs () -> Integer
+        def receive_snaplen: () -> Integer
+
+        # @rbs (Integer? buffer_size) -> void
+        def setup_receive_buffer: (Integer? buffer_size) -> void
+
+        private
+
+        # @rbs (Integer offset) -> Integer
+        def u32: (Integer offset) -> Integer
+
+        # @rbs (Integer offset, Integer length) -> void
+        def check_ring_bounds: (Integer offset, Integer length) -> void
+
+        # @rbs () -> void
+        def release_block: () -> void
+      end
+    end
+  end
+end

data/sig/generated/redhound/capture/source.rbs

@@ -0,0 +1,44 @@
+# Generated from lib/redhound/capture/source.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    class Source
+      include Enumerable[Packet]
+
+      # @rbs () -> void
+      def initialize: () -> void
+
+      # @rbs () { (Packet) -> void } -> self
+      # @rbs () -> Enumerator[Packet, self]
+      def each_packet: () { (Packet) -> void } -> self
+                     | () -> Enumerator[Packet, self]
+
+      alias each each_packet
+
+      # @rbs (?timeout: Numeric?) -> Packet?
+      def next_packet: (?timeout: Numeric?) -> Packet?
+
+      # @rbs () -> Stats
+      def stats: () -> Stats
+
+      # @rbs () -> bool
+      def stopped?: () -> bool
+
+      # @rbs () -> void
+      def stop: () -> void
+
+      # @rbs () -> void
+      def close: () -> void
+
+      private
+
+      # @rbs (IO io, Numeric? deadline) -> bool
+      def wait_readable: (IO io, Numeric? deadline) -> bool
+
+      # @rbs (Numeric? timeout) -> Numeric?
+      def deadline_for: (Numeric? timeout) -> Numeric?
+    end
+  end
+end

data/sig/generated/redhound/capture/stats.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/redhound/capture/stats.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @api private
+    class Stats
+      attr_accessor received: untyped
+
+      attr_accessor dropped: untyped
+
+      attr_accessor if_dropped: untyped
+
+      attr_accessor freeze_count: untyped
+
+      attr_accessor captured: untyped
+
+      # @rbs (?received: Integer, ?dropped: Integer, ?if_dropped: Integer, ?freeze_count: Integer, ?captured: Integer) -> void
+      def initialize: (?received: Integer, ?dropped: Integer, ?if_dropped: Integer, ?freeze_count: Integer, ?captured: Integer) -> void
+
+      # @rbs () -> Hash[Symbol, Integer]
+      def to_h: () -> Hash[Symbol, Integer]
+    end
+  end
+end

data/sig/generated/redhound/capture.rbs

@@ -0,0 +1,14 @@
+# Generated from lib/redhound/capture.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Capture
+    # @rbs (interface: String | Integer | Interface, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> Source
+    # @rbs [T] (interface: String | Integer | Interface, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) { (Source) -> T } -> T
+    def self.open: (interface: String | Integer | Interface, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) -> Source
+                 | [T] (interface: String | Integer | Interface, ?backend: Symbol | String, ?snaplen: Integer, ?promiscuous: bool, ?buffer_size: Integer?, ?direction: Symbol, ?filter: String?) { (Source) -> T } -> T
+
+    # @rbs () -> Array[Interface]
+    def self.interfaces: () -> Array[Interface]
+  end
+end

data/sig/generated/redhound/cli/command.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/redhound/cli/command.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module CLI
+    # @api private
+    class Command
+      # @rbs (Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+      def run: (Array[String] argv, ?out: untyped, ?err: untyped) -> Integer
+    end
+  end
+end

data/sig/generated/redhound/cli/options.rbs

@@ -0,0 +1,25 @@
+# Generated from lib/redhound/cli/options.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module CLI
+    # @api private
+    class Options
+      attr_reader values: untyped
+
+      attr_reader parser: untyped
+
+      # @rbs (Array[String] argv) -> void
+      def initialize: (Array[String] argv) -> void
+
+      # @rbs (Array[String] args) -> Array[String]
+      def normalize: (Array[String] args) -> Array[String]
+
+      # @rbs () -> OptionParser
+      def build_parser: () -> OptionParser
+
+      # @rbs () -> void
+      def validate: () -> void
+    end
+  end
+end

data/sig/generated/redhound/cli/privileges.rbs

@@ -0,0 +1,12 @@
+# Generated from lib/redhound/cli/privileges.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module CLI
+    # @api private
+    module Privileges
+      # @rbs (String user) -> void
+      def self.drop: (String user) -> void
+    end
+  end
+end

data/sig/generated/redhound/cli/runner.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/redhound/cli/runner.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module CLI
+    # @api private
+    class Runner
+      # @rbs (Hash[Symbol, untyped] options, ?out: untyped, ?err: untyped) -> void
+      def initialize: (Hash[Symbol, untyped] options, ?out: untyped, ?err: untyped) -> void
+
+      # @rbs () -> void
+      def run: () -> void
+
+      # @rbs () -> untyped
+      def formatter: () -> untyped
+
+      # @rbs () -> void
+      def install_signals: () -> void
+
+      # @rbs [T] () { () -> T } -> T
+      def read_capture: [T] () { () -> T } -> T
+
+      # @rbs () -> void
+      def statistics: () -> void
+    end
+  end
+end

data/sig/generated/redhound/context.rbs

@@ -0,0 +1,27 @@
+# Generated from lib/redhound/context.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  class Context
+    attr_reader packet: untyped
+
+    attr_reader registry: untyped
+
+    attr_reader layers: untyped
+
+    attr_accessor cursor: untyped
+
+    attr_accessor embedded: untyped
+
+    attr_accessor extension_count: untyped
+
+    # @rbs (Packet packet, registry: Registry, ?verify_checksums: bool) -> void
+    def initialize: (Packet packet, registry: Registry, ?verify_checksums: bool) -> void
+
+    # @rbs () -> bool
+    def verify_checksums?: () -> bool
+
+    # @rbs () -> Layer?
+    def network: () -> Layer?
+  end
+end

data/sig/generated/redhound/cursor.rbs

@@ -0,0 +1,59 @@
+# Generated from lib/redhound/cursor.rb with RBS::Inline
+
+module Redhound
+  # Checked binary reads within an absolute packet slice.
+  class Cursor
+    # Internal exception for a checked read beyond the captured slice.
+    class Truncated < StandardError
+    end
+
+    # Underlying data and absolute start/end bounds.
+    attr_reader data: untyped
+
+    # Underlying data and absolute start/end bounds.
+    attr_reader start: untyped
+
+    # Underlying data and absolute start/end bounds.
+    attr_reader limit: untyped
+
+    # @rbs (String data, ?Integer start, ?Integer? limit) -> void
+    # Create a bounded view; reject invalid ranges.
+    def initialize: (String data, ?Integer start, ?Integer? limit) -> void
+
+    # @rbs () -> Integer
+    # Remaining slice length in bytes.
+    def remaining: () -> Integer
+
+    # @rbs (Integer off) -> Integer
+    # Read an unsigned byte.
+    def u8: (Integer off) -> Integer
+
+    # @rbs (Integer off) -> Integer
+    # Read an unsigned network-order 16-bit integer.
+    def u16: (Integer off) -> Integer
+
+    # @rbs (Integer off) -> Integer
+    # Read an unsigned network-order 32-bit integer.
+    def u32: (Integer off) -> Integer
+
+    # @rbs (Integer off) -> Integer
+    # Read an unsigned network-order 64-bit integer.
+    def u64: (Integer off) -> Integer
+
+    # @rbs (String template, Integer size, ?Integer off) -> Array[untyped]
+    # Unpack a checked fixed-width header.
+    def unpack: (String template, Integer size, ?Integer off) -> Array[untyped]
+
+    # @rbs (Integer off, Integer len) -> String
+    # Read a checked binary substring.
+    def bytes: (Integer off, Integer len) -> String
+
+    # @rbs (Integer from, Integer to) -> Cursor
+    # Create a child slice that cannot escape the parent bounds.
+    def sub: (Integer from, Integer to) -> Cursor
+
+    # @rbs (Integer off, Integer len) -> void
+    # Validate a relative offset and read length.
+    def check: (Integer off, Integer len) -> void
+  end
+end

data/sig/generated/redhound/diagnostic.rbs

@@ -0,0 +1,21 @@
+# Generated from lib/redhound/diagnostic.rb with RBS::Inline
+
+module Redhound
+  # Structured protocol diagnostic with severity, stable code, message and optional field.
+  class Diagnostic < Data
+    attr_reader severity(): untyped
+
+    attr_reader code(): untyped
+
+    attr_reader message(): untyped
+
+    attr_reader field(): untyped
+
+    def self.new: (untyped severity, untyped code, untyped message, untyped field) -> instance
+                | (severity: untyped, code: untyped, message: untyped, field: untyped) -> instance
+
+    def self.members: () -> [ :severity, :code, :message, :field ]
+
+    def members: () -> [ :severity, :code, :message, :field ]
+  end
+end