redhound 1.0.1 → 2.0.0.rc2

data/sig/generated/redhound/dissector.rbs

@@ -0,0 +1,117 @@
+# Generated from lib/redhound/dissector.rb with RBS::Inline
+
+module Redhound
+  # Base class and declarative fixed-header DSL for custom protocols.
+  class Dissector
+    # Unpack formats and byte lengths supported by the header DSL.
+    TYPES: untyped
+
+    # Build a single unpack template and its field descriptions.
+    class Header
+      # Compiled unpack template, header byte length and field definitions.
+      attr_reader template: untyped
+
+      # Compiled unpack template, header byte length and field definitions.
+      attr_reader length: untyped
+
+      # Compiled unpack template, header byte length and field definitions.
+      attr_reader definitions: untyped
+
+      # @rbs () -> void
+      # Start an empty fixed-header definition.
+      def initialize: () -> void
+
+      # @rbs (Symbol type, Symbol key, String name, **untyped opts) -> void
+      # Append a typed fixed-width field with optional format/enum metadata.
+      def field: (Symbol type, Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a signed 8-bit field.
+      def int8: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append an unsigned 8-bit field.
+      def uint8: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a network-order unsigned 16-bit field.
+      def uint16: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a network-order unsigned 32-bit field.
+      def uint32: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a network-order unsigned 64-bit field.
+      def uint64: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a six-byte MAC address.
+      def mac: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a four-byte IPv4 address.
+      def ipv4: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Symbol key, String name, **untyped opts) -> void
+      # Append a sixteen-byte IPv6 address.
+      def ipv6: (Symbol key, String name, **untyped opts) -> void
+
+      # @rbs (Integer width) { (Header) [self: Header] -> void } -> void
+      # Define bit fields filling an 8/16/32/64-bit network-order word.
+      def bits: (Integer width) { (Header) [self: Header] -> void } -> void
+
+      # @rbs (Symbol key, String name, Integer width, **untyped opts) -> void
+      # Append a bit field inside bits, optionally scaled/formatted.
+      def bit: (Symbol key, String name, Integer width, **untyped opts) -> void
+    end
+
+    # @rbs () -> Symbol
+    # Registered protocol symbol.
+    def self.protocol_id: () -> Symbol
+
+    # @rbs () -> String
+    # Human-readable protocol name.
+    def self.protocol_name: () -> String
+
+    # @rbs () -> String
+    # Short output label.
+    def self.short_name: () -> String
+
+    # @rbs () -> untyped
+    # Compiled header definition, if one was declared.
+    def self.compiled_header: () -> untyped
+
+    # @rbs (Symbol id, name: String, short: String) -> void
+    # Declare protocol identity and register the dissector.
+    def self.protocol: (Symbol id, name: String, short: String) -> void
+
+    # @rbs (String key, *Integer values) -> void
+    # Register this protocol under one or more dispatch values.
+    def self.dissects_on: (String key, *Integer values) -> void
+
+    # @rbs () { (Header) [self: Header] -> void } -> void
+    # Compile a fixed header from the DSL block.
+    def self.header: () { (Header) [self: Header] -> void } -> void
+
+    # @rbs () -> String
+    # Compiled unpack template, or an empty template.
+    def self.header_template: () -> String
+
+    # @rbs (Context ctx, Cursor cursor) -> Layer
+    # Decode fixed fields then invoke the variable-header hook.
+    def parse: (Context ctx, Cursor cursor) -> Layer
+
+    # @rbs (Context ctx, Layer layer) -> void
+    # Override to parse variable fields using the bounded Context cursor.
+    def dissect: (Context ctx, Layer layer) -> void
+
+    # @rbs (Context ctx, Layer layer) -> untyped
+    # Override to return the next protocol class or nil.
+    def next_dissector: (Context ctx, Layer layer) -> untyped
+
+    # @rbs (Layer layer) -> String
+    # Override to format the layer summary.
+    def summary: (Layer layer) -> String
+  end
+end

data/sig/generated/redhound/engine.rbs

@@ -0,0 +1,23 @@
+# Generated from lib/redhound/engine.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  class Engine
+    MAX_DEPTH: ::Integer
+
+    # @rbs () -> Engine
+    def self.default: () -> Engine
+
+    # @rbs (?registry: Registry, ?verify_checksums: bool) -> void
+    def initialize: (?registry: Registry, ?verify_checksums: bool) -> void
+
+    # @rbs (Packet packet) -> Array[Layer]
+    def dissect: (Packet packet) -> Array[Layer]
+
+    # @rbs (untyped klass, Context ctx, Layer layer) -> untyped
+    def next_dissector: (untyped klass, Context ctx, Layer layer) -> untyped
+
+    # @rbs (untyped klass, Context ctx, Cursor cursor) -> Layer
+    def safely: (untyped klass, Context ctx, Cursor cursor) -> Layer
+  end
+end

data/sig/generated/redhound/errors.rbs

@@ -0,0 +1,56 @@
+# Generated from lib/redhound/errors.rb with RBS::Inline
+
+module Redhound
+  # Base exception for Redhound operational and configuration errors.
+  class Error < StandardError
+  end
+
+  # Capture-device or live-operation failure.
+  class CaptureError < Error
+  end
+
+  # @api private
+  class RotationComplete < CaptureError
+  end
+
+  # Insufficient permission to access the capture device.
+  class PermissionDenied < CaptureError
+  end
+
+  # Requested capture interface does not exist.
+  class InterfaceNotFound < CaptureError
+  end
+
+  # Requested platform or capture capability is unavailable.
+  class UnsupportedPlatform < CaptureError
+  end
+
+  # Malformed or unsupported capture-file structure.
+  class FileFormatError < Error
+  end
+
+  # Invalid command-line or library configuration.
+  class ConfigurationError < Error
+  end
+
+  # Invalid cBPF program or unsupported filter operation.
+  class FilterError < Error
+  end
+
+  # Filter exceeds the target platform instruction limit.
+  class FilterTooLarge < FilterError
+  end
+
+  # Capture-filter syntax error with original expression and byte position.
+  class FilterSyntaxError < FilterError
+    # Original filter expression and zero-based error position.
+    attr_reader expression: untyped
+
+    # Original filter expression and zero-based error position.
+    attr_reader position: untyped
+
+    # @rbs (String message, ?expression: String?, ?position: Integer?) -> void
+    # Create a syntax diagnostic suitable for a caret display.
+    def initialize: (String message, ?expression: String?, ?position: Integer?) -> void
+  end
+end

data/sig/generated/redhound/field.rbs

@@ -0,0 +1,74 @@
+# Generated from lib/redhound/field.rb with RBS::Inline
+
+module Redhound
+  # Immutable description of a field location, type and display metadata.
+  class FieldDefinition < Data
+    attr_reader key(): untyped
+
+    attr_reader name(): untyped
+
+    attr_reader type(): untyped
+
+    attr_reader offset(): untyped
+
+    attr_reader length(): untyped
+
+    attr_reader index(): untyped
+
+    attr_reader shift(): untyped
+
+    attr_reader mask(): untyped
+
+    attr_reader scale(): untyped
+
+    attr_reader format(): untyped
+
+    attr_reader enum(): untyped
+
+    def self.new: (untyped key, untyped name, untyped type, untyped offset, untyped length, untyped index, untyped shift, untyped mask, untyped scale, untyped format, untyped enum) -> instance
+                | (key: untyped, name: untyped, type: untyped, offset: untyped, length: untyped, index: untyped, shift: untyped, mask: untyped, scale: untyped, format: untyped, enum: untyped) -> instance
+
+    def self.members: () -> [ :key, :name, :type, :offset, :length, :index, :shift, :mask, :scale, :format, :enum ]
+
+    def members: () -> [ :key, :name, :type, :offset, :length, :index, :shift, :mask, :scale, :format, :enum ]
+  end
+
+  # A decoded field with its definition, raw value and absolute location.
+  class Field
+    # Definition, raw decoded value and capture location.
+    attr_reader definition: untyped
+
+    # Definition, raw decoded value and capture location.
+    attr_reader raw_value: untyped
+
+    # Definition, raw decoded value and capture location.
+    attr_reader offset: untyped
+
+    # Definition, raw decoded value and capture location.
+    attr_reader length: untyped
+
+    # @rbs (untyped definition, untyped value, Integer base) -> void
+    # Bind a field definition to its value and layer base offset.
+    def initialize: (untyped definition, untyped value, Integer base) -> void
+
+    # @rbs () -> String
+    # Stable dotted field name.
+    def name: () -> String
+
+    # @rbs () -> Symbol
+    # Declared field representation.
+    def type: () -> Symbol
+
+    # @rbs () -> untyped
+    # Decoded value; addresses are returned in human-readable text.
+    def value: () -> untyped
+
+    # @rbs () -> untyped
+    # JSON-safe value; opaque bytes and invalid text are encoded in hexadecimal.
+    def json_value: () -> untyped
+
+    # @rbs () -> String
+    # Terminal-safe field text with escaped control and non-ASCII bytes.
+    def display: () -> String
+  end
+end

data/sig/generated/redhound/file/format.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/redhound/file/format.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module File
+    # @api private
+    module Format
+      MAX_RECORD: untyped
+
+      MAX_INTERFACES: ::Integer
+
+      MAX_INTERFACE_METADATA: untyped
+
+      MAX_OPTIONS: ::Integer
+
+      PCAP_MAGICS: untyped
+
+      PCAPNG_MAGIC: untyped
+
+      # @rbs (untyped io, Integer length, ?eof: false) -> String
+      # @rbs (untyped io, Integer length, eof: true) -> String?
+      def self.read_exact: (untyped io, Integer length, ?eof: false) -> String
+                         | (untyped io, Integer length, eof: true) -> String?
+
+      # @rbs (Integer length) -> Integer
+      def self.padded: (Integer length) -> Integer
+
+      # @rbs (String data) -> String
+      def self.pad: (String data) -> String
+
+      # NULL carries a host-order address family; libpcap also normalizes it on read.
+      # @rbs (String data, Integer linktype, String integer_format) -> String
+      def self.normalize_null: (String data, Integer linktype, String integer_format) -> String
+
+      # @rbs (Integer caplen, Integer original_length, Integer snaplen) -> void
+      def self.check_lengths: (Integer caplen, Integer original_length, Integer snaplen) -> void
+    end
+  end
+end

data/sig/generated/redhound/file/pcap_reader.rbs

@@ -0,0 +1,19 @@
+# Generated from lib/redhound/file/pcap_reader.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module File
+    # @api private
+    class PcapReader
+      attr_reader interfaces: untyped
+
+      attr_reader linktype: untyped
+
+      # @rbs (untyped io, String magic) -> void
+      def initialize: (untyped io, String magic) -> void
+
+      # @rbs () -> Packet?
+      def next_packet: () -> Packet?
+    end
+  end
+end

data/sig/generated/redhound/file/pcap_writer.rbs

@@ -0,0 +1,38 @@
+# Generated from lib/redhound/file/pcap_writer.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module File
+    # @api private
+    class PcapWriter
+      attr_reader bytes_written: untyped
+
+      attr_reader path: untyped
+
+      # @rbs (untyped output, ?linktype: Integer | Symbol | String, ?snaplen: Integer, ?precision: Symbol, ?packet_buffered: bool, **untyped) -> void
+      def initialize: (untyped output, ?linktype: Integer | Symbol | String, ?snaplen: Integer, ?precision: Symbol, ?packet_buffered: bool, **untyped) -> void
+
+      # @rbs (Packet packet) -> self
+      def write: (Packet packet) -> self
+
+      alias << write
+
+      # @rbs (Packet packet) -> Integer
+      def record_size: (Packet packet) -> Integer
+
+      # @rbs (Capture::Stats stats, ?interface: Capture::Interface?) -> void
+      def write_stats: (Capture::Stats stats, ?interface: Capture::Interface?) -> void
+
+      # @rbs () -> void
+      def flush: () -> void
+
+      # @rbs () -> void
+      def close: () -> void
+
+      private
+
+      # @rbs (String bytes) -> void
+      def write_bytes: (String bytes) -> void
+    end
+  end
+end

data/sig/generated/redhound/file/pcapng_reader.rbs

@@ -0,0 +1,54 @@
+# Generated from lib/redhound/file/pcapng_reader.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module File
+    # @api private
+    class PcapngReader
+      attr_reader interfaces: untyped
+
+      attr_reader stats: untyped
+
+      # @rbs (untyped io, String magic) -> void
+      def initialize: (untyped io, String magic) -> void
+
+      # @rbs () -> Integer
+      def linktype: () -> Integer
+
+      # @rbs () -> bool
+      def statistics?: () -> bool
+
+      # @rbs () -> Packet?
+      def next_packet: () -> Packet?
+
+      private
+
+      # @rbs () -> [Integer, String]?
+      def read_block: () -> [ Integer, String ]?
+
+      # @rbs (String body) -> void
+      def read_interface: (String body) -> void
+
+      # @rbs (String body) -> Packet
+      def read_enhanced: (String body) -> Packet
+
+      # @rbs (String body) -> Packet
+      def read_simple: (String body) -> Packet
+
+      # @rbs (String body) -> void
+      def read_statistics: (String body) -> void
+
+      # @rbs (String data, Capture::Interface interface, Integer original_length, Integer timestamp_ns, Symbol? direction, Hash[Symbol, untyped] meta) -> Packet
+      def make_packet: (String data, Capture::Interface interface, Integer original_length, Integer timestamp_ns, Symbol? direction, Hash[Symbol, untyped] meta) -> Packet
+
+      # @rbs (Integer index) -> Capture::Interface
+      def interface_at: (Integer index) -> Capture::Interface
+
+      # @rbs (String body, Integer offset, Array[Integer] allowed) -> Hash[Integer, Array[String]]
+      def options: (String body, Integer offset, Array[Integer] allowed) -> Hash[Integer, Array[String]]
+
+      # @rbs (String body, Integer size) -> void
+      def require_size: (String body, Integer size) -> void
+    end
+  end
+end

data/sig/generated/redhound/file/pcapng_writer.rbs

@@ -0,0 +1,50 @@
+# Generated from lib/redhound/file/pcapng_writer.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module File
+    # @api private
+    class PcapngWriter
+      attr_reader bytes_written: untyped
+
+      attr_reader path: untyped
+
+      # @rbs (untyped output, ?linktype: Integer | Symbol | String, ?snaplen: Integer, ?precision: Symbol, ?packet_buffered: bool, ?filter: String?, ?comment: String?, **untyped) -> void
+      def initialize: (untyped output, ?linktype: Integer | Symbol | String, ?snaplen: Integer, ?precision: Symbol, ?packet_buffered: bool, ?filter: String?, ?comment: String?, **untyped) -> void
+
+      # @rbs (Packet packet) -> self
+      def write: (Packet packet) -> self
+
+      alias << write
+
+      # @rbs (Packet packet) -> Integer
+      def record_size: (Packet packet) -> Integer
+
+      # @rbs (Capture::Stats stats, ?interface: Capture::Interface?) -> void
+      def write_stats: (Capture::Stats stats, ?interface: Capture::Interface?) -> void
+
+      # @rbs () -> void
+      def flush: () -> void
+
+      # @rbs () -> void
+      def close: () -> void
+
+      private
+
+      # @rbs (Packet packet) -> Integer
+      def ensure_interface: (Packet packet) -> Integer
+
+      # @rbs (Packet packet) -> Integer
+      def packet_flags: (Packet packet) -> Integer
+
+      # @rbs (Integer timestamp) -> String
+      def timestamp_words: (Integer timestamp) -> String
+
+      # @rbs (Hash[Integer, String] values) -> String
+      def options: (Hash[Integer, String] values) -> String
+
+      # @rbs (Integer type, String body) -> void
+      def write_block: (Integer type, String body) -> void
+    end
+  end
+end

data/sig/generated/redhound/file/rotating_writer.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/redhound/file/rotating_writer.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module File
+    # @api private
+    class RotatingWriter
+      attr_reader path: untyped
+
+      # @rbs (String path, ?max_bytes: Integer?, ?interval: Numeric?, ?file_count: Integer?, ?post_rotate_command: String?, **untyped options) -> void
+      def initialize: (String path, ?max_bytes: Integer?, ?interval: Numeric?, ?file_count: Integer?, ?post_rotate_command: String?, **untyped options) -> void
+
+      # @rbs (Packet packet) -> self
+      def write: (Packet packet) -> self
+
+      alias << write
+
+      # @rbs (Capture::Stats stats, ?interface: Capture::Interface?) -> void
+      def write_stats: (Capture::Stats stats, ?interface: Capture::Interface?) -> void
+
+      # @rbs () -> Integer
+      def bytes_written: () -> Integer
+
+      # @rbs () -> void
+      def flush: () -> void
+
+      # @rbs () -> void
+      def close: () -> void
+
+      private
+
+      # @rbs () -> void
+      def rotate: () -> void
+
+      # @rbs () -> void
+      def open_next: () -> void
+
+      # @rbs () -> void
+      def run_command: () -> void
+    end
+  end
+end

data/sig/generated/redhound/filter/analyzer.rbs

@@ -0,0 +1,42 @@
+# Generated from lib/redhound/filter/analyzer.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    class Analyzer
+      PROTOCOL_NUMBERS: untyped
+
+      ETHER_TYPES: untyped
+
+      # @rbs (String expression) -> void
+      def initialize: (String expression) -> void
+
+      # @rbs (untyped node) -> untyped
+      def analyze: (untyped node) -> untyped
+
+      private
+
+      # @rbs (untyped node) -> untyped
+      def primitive: (untyped node) -> untyped
+
+      # @rbs (untyped node) -> untyped
+      def arithmetic: (untyped node) -> untyped
+
+      # @rbs (String value, String? proto, Symbol type, Integer position) -> untyped
+      def ports: (String value, String? proto, Symbol type, Integer position) -> untyped
+
+      # @rbs (String value, Symbol type, Integer position) -> untyped
+      def addresses: (String value, Symbol type, Integer position) -> untyped
+
+      # @rbs (String value, Hash[String, Integer] names, Integer position) -> Integer
+      def integer_or_name: (String value, Hash[String, Integer] names, Integer position) -> Integer
+
+      # @rbs () -> Hash[String, Integer]
+      def protocol_numbers: () -> Hash[String, Integer]
+
+      # @rbs (String message, Integer position) -> bot
+      def error: (String message, Integer position) -> bot
+    end
+  end
+end

data/sig/generated/redhound/filter/bpf/assembler.rbs

@@ -0,0 +1,39 @@
+# Generated from lib/redhound/filter/bpf/assembler.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    module BPF
+      # @api private
+      class Assembler
+        # @rbs () -> void
+        def initialize: () -> void
+
+        # @rbs () -> Symbol
+        def label: () -> Symbol
+
+        # @rbs (Symbol label) -> void
+        def mark: (Symbol label) -> void
+
+        # @rbs (Integer code, ?Integer k) -> void
+        def emit: (Integer code, ?Integer k) -> void
+
+        # @rbs (Symbol target) -> void
+        def jump: (Symbol target) -> void
+
+        # @rbs (Integer code, Integer k, Symbol yes, Symbol no) -> void
+        def branch: (Integer code, Integer k, Symbol yes, Symbol no) -> void
+
+        # @rbs () -> Array[[Integer, Integer, Integer, Integer]]
+        def assemble: () -> Array[[ Integer, Integer, Integer, Integer ]]
+
+        private
+
+        # Remove unreachable blocks and thread jumps through unconditional jumps.
+        # @rbs () -> void
+        def compact!: () -> void
+      end
+    end
+  end
+end

data/sig/generated/redhound/filter/bpf/disassembler.rbs

@@ -0,0 +1,18 @@
+# Generated from lib/redhound/filter/bpf/disassembler.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    module BPF
+      # @api private
+      module Disassembler
+        # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions, ?format: Symbol) -> String
+        def self.disassemble: (Array[[ Integer, Integer, Integer, Integer ]] instructions, ?format: Symbol) -> String
+
+        # @rbs (Integer code, Integer k) -> String
+        def self.instruction: (Integer code, Integer k) -> String
+      end
+    end
+  end
+end

data/sig/generated/redhound/filter/bpf/validator.rbs

@@ -0,0 +1,30 @@
+# Generated from lib/redhound/filter/bpf/validator.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    module BPF
+      # Validates the portable cBPF ISA and Linux VLAN ancillary loads.
+      # @api private
+      module Validator
+        LOADS: untyped
+
+        ALU: untyped
+
+        JUMPS: untyped
+
+        OPCODES: untyped
+
+        # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions) -> bool
+        def self.validate!: (Array[[ Integer, Integer, Integer, Integer ]] instructions) -> bool
+
+        # @rbs (Integer code, Integer jt, Integer jf, Integer k, Integer index) -> Array[Integer]
+        def self.successors: (Integer code, Integer jt, Integer jf, Integer k, Integer index) -> Array[Integer]
+
+        # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions) -> void
+        def self.validate_memory!: (Array[[ Integer, Integer, Integer, Integer ]] instructions) -> void
+      end
+    end
+  end
+end

data/sig/generated/redhound/filter/bpf/vm.rbs

@@ -0,0 +1,28 @@
+# Generated from lib/redhound/filter/bpf/vm.rb with RBS::Inline
+
+module Redhound
+  # @api private
+  module Filter
+    # @api private
+    module BPF
+      # @api private
+      class VM
+        LOAD_FORMATS: untyped
+
+        # @rbs (Array[[Integer, Integer, Integer, Integer]] instructions) -> void
+        def initialize: (Array[[ Integer, Integer, Integer, Integer ]] instructions) -> void
+
+        # @rbs (untyped packet) -> Integer
+        def evaluate: (untyped packet) -> Integer
+
+        private
+
+        # @rbs (Integer operation, Integer a, Integer operand) -> Integer
+        def arithmetic: (Integer operation, Integer a, Integer operand) -> Integer
+
+        # @rbs (Integer offset, untyped meta) -> Integer
+        def ancillary: (Integer offset, untyped meta) -> Integer
+      end
+    end
+  end
+end