vanken 0.1.0 → 0.3.0

data/lib/vanken/app/stats_job.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../gateway/statistics"
+
+module Vanken
+  module App
+    # Invoke refresh on the executor; cancel joins its current frame before store close.
+    class StatsJob
+      def initialize(document, specs: ["phs"], displayed_only: false)
+        @document, @specs, @displayed_only = document, specs, displayed_only
+        @mutex, @numbers, @cancelled = Mutex.new, [], false
+        reset
+      end
+
+      def refresh
+        @mutex.synchronize do
+          return [] if @cancelled || @document.closing?
+          numbers = @displayed_only ? @document.display_numbers.sort : (1..@document.count).to_a
+          reset unless numbers.take(@numbers.size) == @numbers
+          numbers.drop(@numbers.size).each do |number|
+            break if @cancelled || @document.closing?
+            @statistics.update(@dissector.dissect(@document.store.read(number)))
+            @numbers << number
+          end
+          @statistics.tables
+        end
+      end
+
+      def cancel
+        @cancelled = true
+        @mutex.synchronize { @statistics.close }
+        self
+      end
+
+      private
+
+      def reset
+        @statistics&.close
+        @numbers = []
+        @dissector = Gateway::Dissector.new(**@document.analysis_gateway_options)
+        @statistics = Gateway::Statistics.new(specs: @specs, registry: @dissector.registry, **@document.analysis_options)
+      end
+    end
+  end
+end

data/lib/vanken/capture/analyzer.rb

@@ -11,7 +11,7 @@ module Vanken
       def run
         number = 1
         loop do
-          break if @document.respond_to?(:closing?) && @document.closing?
+          break if @document.analysis_stopped?
           if number > @document.store.durable_count
             break if @document.received? && number > @document.store.durable_count
             @document.wait_for_frames
@@ -20,11 +20,13 @@ module Vanken
           frame = @document.store.read(number)
           begin
             packet = @dissector.dissect(frame)
+            break if @document.analysis_stopped?
             @analysis.update(packet)
           rescue StandardError => error
             @document.publish_failure(number, error)
             packet = nil
           end
+          break if @document.analysis_stopped?
           @document.publish(number, packet) if packet
           number += 1
           if number % 256 == 0

data/lib/vanken/capture/analyzer_process.rb

@@ -11,6 +11,7 @@ module Vanken
         @document, @verify_checksums = document, verify_checksums
       end
       def run
+        return if @document.analysis_stopped?
         unless Gem.win_platform?
           raise Vanken::Error, "packet analysis must run without root privileges" if Process.uid.zero? || Process.euid.zero?
         end
@@ -23,10 +24,11 @@ module Vanken
         @pid = Process.spawn(*arguments, in: child_in, out: child_out, close_others: true)
         child_in.close
         child_out.close
-        request(command: :start, spool: @document.store.directory, verify_checksums: @verify_checksums, analysis_options: @document.analysis_options)
+        request(command: :start, spool: @document.store.directory, verify_checksums: @verify_checksums, analysis_options: @document.analysis_options,
+          gateway_options: @document.analysis_gateway_options)
         number = 1
         loop do
-          break if @document.closing?
+          break if @document.analysis_stopped?
           limit = @document.store.durable_count
           if number > limit
             break if @document.received? && number > @document.store.durable_count
@@ -36,13 +38,14 @@ module Vanken
           last = [number + 255, limit].min
           configuration = @document.analysis_configuration(number, last)
           batch = request(configuration.merge(command: :analyze, first: number, last: last, interfaces: @document.store.interfaces))
+          break if @document.analysis_stopped?
           raise Vanken::Error, "analysis response range mismatch" unless batch[:first] == number && batch[:last] == last
           @document.publish_analysis_batch(batch, self, configuration[:generation], context_token: configuration[:context_token])
           number = last + 1
         end
       rescue StandardError
-        @document.cancel
-        raise unless @document.closing?
+        @document.cancel unless @document.analysis_stopped?
+        raise unless @document.analysis_stopped?
       ensure
         child_in&.close unless child_in&.closed?
         child_out&.close unless child_out&.closed?
@@ -54,7 +57,7 @@ module Vanken
       end
       def request(value)
         AnalyzerWire.write(@input, value)
-        response = AnalyzerWire.read(@output, cancelled: -> { @document.closing? })
+        response = AnalyzerWire.read(@output, cancelled: -> { @document.analysis_stopped? })
         raise Vanken::Error, response[:error] if response[:error]
         response
       end
@@ -82,7 +85,7 @@ module Vanken
           end
           sleep(0.005)
         end
-        raise Vanken::Error, "analysis worker failed while stopping" unless status.success? || @document.closing? || $!
+        raise Vanken::Error, "analysis worker failed while stopping" unless status.success? || @document.analysis_stopped? || $!
       rescue Errno::ECHILD, Errno::ESRCH
         nil
       end

data/lib/vanken/capture/analyzer_worker.rb

@@ -57,11 +57,11 @@ module Vanken
 
       def initialize(request)
         @reader = Reader.new(request.fetch(:spool))
-        @dissector = Gateway::Dissector.new(verify_checksums: request.fetch(:verify_checksums))
+        @dissector = Gateway::Dissector.new(**request.fetch(:gateway_options, {verify_checksums: request.fetch(:verify_checksums)}))
         @analysis = Gateway::Analysis.new(registry: @dissector.registry, **request.fetch(:analysis_options))
         @columns = Core::ColumnStore.new
         @annotations = Core::AnnotationStore.new(request.fetch(:spool), persist: false)
-        @catalog = Gateway::FieldCatalog.new
+        @catalog = Gateway::FieldCatalog.new(registry: @dissector.registry)
         @seen_fields = @catalog.names.to_set
         @context = Context.new(@reader)
         @next = 1

data/lib/vanken/capture/filter_worker.rb

@@ -8,6 +8,7 @@ require_relative "../core/frame_store"
 require_relative "../core/stores"
 require_relative "../core/display_filter/compiler"
 require_relative "../gateway/dissector"
+require_relative "../gateway/display_capture_filter"
 
 module Vanken
   module Capture
@@ -153,12 +154,17 @@ module Vanken
         raise ArgumentError, "filter chunk exceeds stored frames" unless last <= reader.count + 1
 
         dissector = Gateway::Dissector.new(decode_as: payload.fetch("decode_as", []), plugins: payload.fetch("plugins", []))
-        program = Core::DisplayFilter.compile(payload.fetch("expr"), catalog: Gateway::FieldCatalog.new)
+        program = Core::DisplayFilter.compile(payload.fetch("expr"), catalog: Gateway::FieldCatalog.new(registry: dissector.registry))
+        capture = Gateway::DisplayCaptureFilter.new(payload.fetch("expr")) if payload.fetch("plugins", []).empty? && payload.fetch("decode_as", []).empty?
+        capture = nil unless capture&.expression
         context = {marked: Set.new(payload.fetch("marked", [])), ignored: Set.new(payload.fetch("ignored", [])),
                    reference: payload.fetch("time_reference_ns") { reader.count.zero? ? 0 : reader.metadata(1)[:timestamp_ns] },
                    references: payload.fetch("time_references_ns", {}).map { |number, timestamp| [Integer(number), timestamp] }.sort_by(&:first),
                    predecessors: payload.fetch("displayed_predecessors", {})}
-        matches = (first...last).select { |number| program.match?(View.new(reader, number, dissector, context)) }
+        matches = (first...last).select do |number|
+          matched = capture&.match(reader.frame(number))
+          matched.nil? ? program.match?(View.new(reader, number, dissector, context)) : matched
+        end
         {"matches" => matches}
       ensure
         reader&.close

data/lib/vanken/capture/helper_main.rb

@@ -23,7 +23,7 @@ module Vanken
         when :list_interfaces then @stdout.puts(JSON.generate(Gateway::Interfaces.list)); return 0
         when :check then return check(options)
         when :version then @stdout.puts("Vanken #{VERSION}"); return 0
-        when :help then @stdout.puts("vanken-capture -i INTERFACE [--filter EXPR] [--snaplen N] [--no-promiscuous]\n  [--buffer-size BYTES] [--direction in|out|inout] [--backend auto|ring|socket|bpf]\n  [--drop-to UID:GID] [--stats-interval SEC] [--flush-interval SEC]\n  --list-interfaces | --check [--interface IF] | --version"); return 0
+        when :help then @stdout.puts("vanken-capture -i INTERFACE [--filter EXPR] [--snaplen N] [--no-promiscuous]\n  [--buffer-size BYTES] [--direction in|out|inout] [--backend auto|ring|socket|bpf]\n  [--drop-to UID:GID] [--stats-interval SEC] [--flush-interval SEC]\n  [--stop-count N] [--stop-duration SEC] [--stop-bytes BYTES]\n  --list-interfaces | --check [--interface IF] | --version"); return 0
         end
 
         capture(options)
@@ -64,11 +64,18 @@ module Vanken
         end
         @control.write(:started, interface: options.capture[:interface], linktype: source.linktype,
                        snaplen: options.capture[:snaplen], backend: source.backend, filter: options.capture[:filter], privileges_dropped: dropped)
-        flushed_at = stats_at = monotonic
+        started_at = flushed_at = stats_at = monotonic
+        captured = 0
         until @stop_reason || source.stopped?
           packet = source.next_packet(timeout: 0.05)
-          writer << packet if packet
+          if packet
+            writer << packet
+            captured += 1
+          end
           now = monotonic
+          @stop_reason ||= "count_limit" if options.stop_count && captured >= options.stop_count
+          @stop_reason ||= "duration_limit" if options.stop_duration && now - started_at >= options.stop_duration
+          @stop_reason ||= "bytes_limit" if options.stop_bytes && writer.bytes_written >= options.stop_bytes
           if now - flushed_at >= options.flush_interval
             writer.flush
             flushed_at = now

data/lib/vanken/capture/helper_options.rb

@@ -5,7 +5,8 @@ require "optparse"
 module Vanken
   module Capture
     class HelperOptions
-      attr_reader :command, :capture, :drop_to, :stats_interval, :flush_interval
+      attr_reader :command, :capture, :drop_to, :stats_interval, :flush_interval,
+                  :stop_count, :stop_duration, :stop_bytes
 
       def self.parse(argv)
         new.parse(argv)
@@ -36,13 +37,16 @@ module Vanken
           end
           opts.on("--stats-interval SEC", Float) { |v| @stats_interval = bounded(v, 0.01..60, "stats-interval") }
           opts.on("--flush-interval SEC", Float) { |v| @flush_interval = bounded(v, 0.001..1, "flush-interval") }
+          opts.on("--stop-count N", Integer) { |v| @stop_count = bounded(v, 1..9_223_372_036_854_775_807, "stop-count") }
+          opts.on("--stop-duration SEC", Float) { |v| @stop_duration = bounded(v, 0.001..31_536_000, "stop-duration") }
+          opts.on("--stop-bytes N", Integer) { |v| @stop_bytes = bounded(v, 1..9_223_372_036_854_775_807, "stop-bytes") }
           opts.on("--list-interfaces") { modes << :list_interfaces }
           opts.on("--check") { modes << :check }
           opts.on("--version") { modes << :version }
           opts.on("-h", "--help") { modes << :help }
         end
         # OptionParser accepts long-option abbreviations by default; privileged inputs must be exact.
-        known = %w[--interface --filter --snaplen --no-promiscuous --buffer-size --direction --backend --drop-to --stats-interval --flush-interval --list-interfaces --check --version --help]
+        known = %w[--interface --filter --snaplen --no-promiscuous --buffer-size --direction --backend --drop-to --stats-interval --flush-interval --stop-count --stop-duration --stop-bytes --list-interfaces --check --version --help]
         argv.each do |arg|
           raise ArgumentError, "unknown option: #{arg}" if arg.start_with?("--") && !known.include?(arg.split("=", 2).first)
         end

data/lib/vanken/capture/launcher.rb

@@ -171,6 +171,7 @@ module Vanken
       def capture_argv(options)
         options.flat_map do |key, value|
           next [] if value.nil?
+          next [] if %i[stop_count stop_duration stop_bytes].include?(key.to_sym) && value == 0
           next value ? [] : ["--no-promiscuous"] if key.to_sym == :promiscuous
 
           ["--#{key.to_s.tr('_', '-')}", value.to_s]

data/lib/vanken/capture/permission_setup.rb

@@ -0,0 +1,201 @@
+# frozen_string_literal: true
+
+require "optparse"
+require "json"
+require "etc"
+require "shellwords"
+require "tempfile"
+require "open3"
+
+module Vanken
+  module Capture
+    class PermissionSetup
+      PREFIX = "/usr/local/libexec/vanken"
+      SOURCE = File.expand_path("../../..", __dir__)
+
+      def self.run(argv, stdout: $stdout, stderr: $stderr)
+        options = {}
+        dry_run = false
+        parser = OptionParser.new do |flags|
+          flags.banner = "Usage: vanken-setup-permissions [--dry-run] [--ruby PATH --gem-home PATH] [--policy polkit|sudoers] [--group GROUP]"
+          flags.on("--platform VALUE", %w[linux darwin]) { |value| options[:platform] = value.to_sym }
+          flags.on("--ruby PATH") { |value| options[:ruby] = value }
+          flags.on("--gem-home PATH") { |value| options[:gem_home] = value }
+          flags.on("--policy VALUE", %w[polkit sudoers]) { |value| options[:policy] = value.to_sym }
+          flags.on("--group GROUP") { |value| options[:group] = value }
+          flags.on("--root DIRECTORY", "Stage files without activating system permissions") { |value| options[:root] = value }
+          flags.on("--dry-run") { dry_run = true }
+          flags.on("-h", "--help") { stdout.puts(flags); return 0 }
+        end
+        known = %w[--platform --ruby --gem-home --policy --group --root --dry-run --help]
+        argv.each do |value|
+          raise ArgumentError, "unknown option: #{value}" if value.start_with?("--") && !known.include?(value.split("=", 2).first)
+        end
+        remaining = parser.parse(argv.dup)
+        raise ArgumentError, "unexpected arguments: #{remaining.join(' ')}" unless remaining.empty?
+        setup = new(**options)
+        setup.install unless dry_run
+        stdout.puts(JSON.pretty_generate(platform: setup.platform, dry_run: dry_run, staged: setup.staged?,
+          files: setup.plan.keys, next_steps: setup.next_steps))
+        0
+      rescue ArgumentError, OptionParser::ParseError => error
+        stderr.puts(error.message)
+        2
+      rescue SystemCallError, IOError => error
+        stderr.puts(error.message)
+        1
+      end
+
+      attr_reader :platform
+
+      def initialize(platform: nil,
+                     ruby: nil, gem_home: nil, policy: :polkit, group: "vanken", root: "/")
+        platform ||= RUBY_PLATFORM.include?("darwin") ? :darwin : (RUBY_PLATFORM.include?("linux") ? :linux : :unsupported)
+        @platform, @ruby, @gem_home, @policy, @group = platform.to_sym, ruby, gem_home, policy.to_sym, group
+        raise ArgumentError, "unsupported platform" unless %i[linux darwin].include?(@platform)
+        raise ArgumentError, "invalid policy" unless %i[polkit sudoers].include?(@policy)
+        raise ArgumentError, "invalid capture group" unless @group.match?(/\A[a-z_][a-z0-9_-]{0,31}\z/)
+        if @platform == :linux
+          [@ruby, @gem_home].each do |path|
+            raise ArgumentError, "Linux setup requires absolute --ruby and --gem-home paths" unless path&.start_with?("/") && !path.include?("\n")
+          end
+        end
+        raise ArgumentError, "staging root must be an existing absolute directory" unless root.start_with?("/") && File.directory?(root) && !File.symlink?(root)
+        @root = File.realpath(root)
+      end
+
+      def staged? = @root != "/"
+
+      def plan
+        if @platform == :darwin
+          return {"#{PREFIX}/chmod-bpf" => asset("macos/chmod-bpf", mode: 0o755),
+                  "/Library/LaunchDaemons/org.vanken.chmod-bpf.plist" => asset("macos/org.vanken.chmod-bpf.plist")}
+        end
+        files = {"#{PREFIX}/vanken-capture" => asset("linux/vanken-capture.wrapper", mode: 0o755),
+                 "#{PREFIX}/helper" => {contents: File.binread(File.join(SOURCE, "exe/vanken-capture")), mode: 0o755},
+                 "/usr/share/applications/vanken.desktop" => asset("linux/vanken.desktop")}
+        if @policy == :polkit
+          files["/usr/share/polkit-1/actions/org.vanken.capture.policy"] = asset("linux/org.vanken.capture.policy")
+        else
+          files["/etc/sudoers.d/vanken"] = asset("linux/vanken.sudoers", mode: 0o440)
+        end
+        Dir.glob(File.join(SOURCE, "lib", "**", "*"), File::FNM_DOTMATCH).each do |path|
+          raise ArgumentError, "source library contains a symlink" if File.symlink?(path)
+          next if File.directory?(path)
+          files["#{PREFIX}/#{path.delete_prefix("#{SOURCE}/")}"] = {contents: File.binread(path), mode: 0o644}
+        end
+        files
+      end
+
+      def install
+        raise ArgumentError, "system installation requires root; use --dry-run or --root for review" unless staged? || Process.euid.zero?
+        raise ArgumentError, "use --root or --dry-run to prepare files for another platform" unless staged? || RUBY_PLATFORM.include?(@platform.to_s)
+        validate_runtime! if @platform == :linux && !staged?
+        validate_group! if @platform == :darwin || @policy == :sudoers
+        plan.each do |absolute, item|
+          destination = File.join(@root, absolute.delete_prefix("/"))
+          secure_directory!(File.dirname(destination))
+          safe_entry!(destination) if File.exist?(destination) || File.symlink?(destination)
+          Tempfile.create([".vanken-", ".tmp"], File.dirname(destination)) do |file|
+            file.binmode
+            file.write(item[:contents])
+            file.chmod(item[:mode])
+            file.flush
+            validate_sudoers!(file.path) if absolute == "/etc/sudoers.d/vanken" && !staged?
+            File.rename(file.path, destination)
+          end
+        end
+        self
+      end
+
+      def validate_runtime!
+        trusted_tree!(@ruby)
+        raise ArgumentError, "Ruby interpreter must be executable" unless File.file?(@ruby) && File.executable?(@ruby)
+        runtime_prefix = File.dirname(File.dirname(File.realpath(@ruby)))
+        trusted_tree!(runtime_prefix) unless ["/", "/usr"].include?(runtime_prefix)
+        paths, status = Open3.capture2({"PATH" => "/usr/bin:/bin"}, @ruby, "--disable-gems", "-e", "$LOAD_PATH.each { |path| puts path }", unsetenv_others: true, chdir: "/")
+        raise ArgumentError, "could not inspect the Ruby runtime" unless status.success?
+        paths.each_line { |path| trusted_tree!(path.strip) }
+        trusted_tree!(@gem_home)
+        raise ArgumentError, "gem home must be a directory" unless File.directory?(@gem_home)
+        trusted_tree!(SOURCE)
+        self
+      end
+
+      def validate_group!
+        Etc.getgrnam(@group)
+      rescue ArgumentError
+        raise ArgumentError, "create the #{@group} capture group and add the intended users before installing"
+      end
+
+      def next_steps
+        if @platform == :darwin
+          ["sudo launchctl bootstrap system /Library/LaunchDaemons/org.vanken.chmod-bpf.plist",
+           "Log out and log in after changing group membership, then run vanken-capture --check --interface lo0."]
+        else
+          ["Run vanken-capture --check --interface IF as a normal user, then start Vanken."]
+        end
+      end
+
+      private
+
+      def asset(relative, mode: 0o644)
+        contents = File.binread(File.join(SOURCE, "packaging", relative)).gsub("VANKEN_GROUP", @group)
+        contents = contents.gsub("VANKEN_RUBY", Shellwords.escape(@ruby.to_s)).gsub("VANKEN_GEM_HOME", Shellwords.escape(@gem_home.to_s))
+        {contents: contents, mode: mode}
+      end
+
+      def trusted_tree!(path, visited = {})
+        resolved = trusted_path!(path)
+        return if visited[resolved]
+        visited[resolved] = true
+        return unless File.directory?(resolved)
+        Dir.children(resolved).each { |name| trusted_tree!(File.join(resolved, name), visited) }
+      rescue SystemCallError => error
+        raise ArgumentError, "cannot verify root-owned privileged path: #{error.message}"
+      end
+
+      def trusted_path!(path)
+        resolved = File.realpath(path)
+        current = path
+        loop do
+          stat = File.lstat(current)
+          unless stat.uid.zero? && (stat.symlink? || (stat.mode & 0o022).zero?) && (stat.file? || stat.directory? || stat.symlink?)
+            raise ArgumentError, "privileged paths must be root-owned without group or other write access"
+          end
+          if stat.symlink?
+            target = File.readlink(current)
+            trusted_path!(target.start_with?("/") ? target : File.join(File.dirname(current), target))
+          end
+          break if current == "/"
+          current = File.dirname(current)
+        end
+        trusted_path!(resolved) if path != resolved
+        resolved
+      end
+
+      def safe_entry!(path)
+        stat = File.lstat(path)
+        raise ArgumentError, "unsafe installation path or symlink: #{path}" unless stat.uid == Process.euid && (stat.mode & 0o022).zero? && (stat.file? || stat.directory?)
+      end
+
+      def secure_directory!(path)
+        safe_entry!(@root)
+        current = @root
+        path.delete_prefix(@root).split("/").reject(&:empty?).each do |part|
+          current = File.join(current, part)
+          Dir.mkdir(current, 0o755) unless File.exist?(current) || File.symlink?(current)
+          safe_entry!(current)
+          raise ArgumentError, "installation parent is not a directory" unless File.directory?(current)
+        end
+      end
+
+      def validate_sudoers!(path)
+        executable = %w[/usr/sbin/visudo /sbin/visudo].find { |candidate| File.executable?(candidate) }
+        raise ArgumentError, "visudo is required to install sudoers permissions" unless executable
+        _, errors, status = Open3.capture3(executable, "-cf", path)
+        raise ArgumentError, "invalid sudoers configuration: #{errors}" unless status.success?
+      end
+    end
+  end
+end

data/lib/vanken/config/analysis_settings.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative "yaml_file"
+
+module Vanken
+  module Config
+    class AnalysisSettings
+      def initialize(directory: Paths.config) = (@directory = directory)
+
+      def decode_as
+        value = YamlFile.read(File.join(@directory, "decode_as.yml"), default: {"rules" => []}).fetch("rules", [])
+        validate_rules(value)
+        value
+      end
+
+      def decode_as=(rules)
+        validate_rules(rules)
+        YamlFile.write(File.join(@directory, "decode_as.yml"), "rules" => rules)
+      end
+
+      def plugin_entries
+        entries = YamlFile.read(File.join(@directory, "plugins.yml"), default: {"files" => []}).fetch("files", [])
+        raise ConfigError, "invalid plugin list" unless entries.is_a?(Array) && entries.all? do |entry|
+          entry.is_a?(Hash) && entry["path"].is_a?(String) && !entry["path"].include?("\0") &&
+            [true, false].include?(entry["trusted"]) && [true, false].include?(entry["enabled"])
+        end
+        entries
+      end
+      def plugins = plugin_entries.select { |entry| entry["enabled"] && entry["trusted"] }.map { |entry| entry["path"] }
+      def untrusted_plugins = plugin_entries.select { |entry| entry["enabled"] && !entry["trusted"] }.map { |entry| entry["path"] }
+
+      def register_plugin(path)
+        raise ConfigError, "invalid plugin path" unless path.is_a?(String) && !path.include?("\0") && File.file?(path)
+        absolute = File.expand_path(path)
+        entries = plugin_entries.reject { |entry| entry["path"] == absolute }
+        entries << {"path" => absolute, "enabled" => true, "trusted" => false}
+        save_plugins(entries)
+      end
+
+      def remove_plugin(path) = save_plugins(plugin_entries.reject { |entry| entry["path"] == File.expand_path(path) })
+
+      def trust_plugins(paths)
+        entries = plugin_entries
+        raise ConfigError, "plugin is not registered" unless paths.all? { |path| entries.any? { |entry| entry["path"] == path } }
+        entries.each { |entry| entry["trusted"] = true if paths.include?(entry["path"]) }
+        save_plugins(entries)
+      end
+
+      private
+
+      def save_plugins(entries) = YamlFile.write(File.join(@directory, "plugins.yml"), "files" => entries)
+      def validate_rules(rules)
+        valid = rules.is_a?(Array) && rules.all? { |rule| rule.is_a?(String) && rule.match?(/\A[a-z][a-z0-9_.]*==[^,\s]+,[a-z][a-z0-9_]*\z/i) }
+        raise ConfigError, "invalid Decode As rules" unless valid
+      end
+    end
+  end
+end

data/lib/vanken/config/columns.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+require "ipaddr"
+require_relative "yaml_file"
+
+module Vanken
+  module Config
+    class Columns
+      BUILTINS = [[:no, "No.", 64], [:time, "Time", 128], [:source, "Source", 164],
+        [:destination, "Destination", 164], [:protocol, "Protocol", 90], [:length, "Length", 76], [:info, "Info", 560]].freeze
+
+      def self.load(directory:, legacy: [])
+        path = File.join(directory, "columns.yml")
+        raise ConfigError, "columns configuration must not be a symlink" if File.symlink?(path)
+        return new(YamlFile.read(path)) if File.file?(path)
+        settings = new
+        unless legacy.empty?
+          ordered = settings.to_h["columns"].sort_by { |column| legacy.index { |item| item["key"] == column["key"] } || legacy.size }
+          ordered.each do |column|
+            saved = legacy.find { |item| item["key"] == column["key"] }
+            column.merge!(saved.slice("width", "visible")) if saved
+          end
+          settings.replace("schema_version" => 1, "columns" => ordered)
+        end
+        settings
+      end
+
+      def initialize(payload = nil)
+        payload ||= {"schema_version" => 1, "columns" => BUILTINS.map do |key, label, width|
+          {"key" => key.to_s, "label" => label, "width" => width, "visible" => true, "field" => nil}
+        end}
+        replace(payload)
+      end
+
+      def replace(payload)
+        raise ConfigError, "unsupported columns schema" unless payload.is_a?(Hash) && payload["schema_version"] == 1
+        items = payload["columns"]
+        raise ConfigError, "columns must contain between 1 and 64 entries" unless items.is_a?(Array) && items.size.between?(1, 64)
+        rows = items.map do |item|
+          raise ConfigError, "invalid column" unless item.is_a?(Hash)
+          key, label, width, visible, field = item.values_at("key", "label", "width", "visible", "field")
+          custom = self.class.valid_field?(field) && key == "field:#{field}"
+          builtin = field.nil? && BUILTINS.any? { |entry| entry.first.to_s == key }
+          raise ConfigError, "invalid column key or field" unless key.is_a?(String) && (custom || builtin)
+          raise ConfigError, "invalid column label" unless label.is_a?(String) && !label.empty? && label.bytesize <= 256 && !label.include?("\0")
+          raise ConfigError, "invalid column width or visibility" unless width.is_a?(Numeric) && width.finite? && width.between?(40, 4096) && [true, false].include?(visible)
+          {"key" => key.dup.freeze, "label" => label.dup.freeze, "width" => width, "visible" => visible, "field" => field&.dup&.freeze}.freeze
+        end
+        raise ConfigError, "duplicate columns" unless rows.map { |item| item["key"] }.uniq.size == rows.size
+        @columns = rows.freeze
+        self
+      end
+
+      def self.valid_field?(field)
+        field.is_a?(String) && field.bytesize <= 256 && /\A[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z0-9_]+)+\z/.match?(field)
+      end
+
+      def to_h = {"schema_version" => 1, "columns" => @columns.map(&:dup)}
+      def custom = @columns.select { |column| column["field"] }
+      def table_columns
+        @columns.map do |column|
+          key = column.fetch("key").to_sym
+          {key: key, label: column.fetch("label"), width: column.fetch("width"), visible: column.fetch("visible"),
+           align: %i[no time length].include?(key) ? :end : :start}
+        end
+      end
+
+      def add(field, label: field, width: 120)
+        raise ConfigError, "invalid custom field name" unless self.class.valid_field?(field)
+        key = "field:#{field}"
+        rows = to_h["columns"]
+        existing = rows.find { |item| item["key"] == key }
+        if existing
+          existing["visible"] = true
+        else
+          rows << {"key" => key, "label" => label, "width" => width, "visible" => true, "field" => field}
+        end
+        replace("schema_version" => 1, "columns" => rows)
+        key
+      end
+
+      def remove(key)
+        raise ConfigError, "hide builtin columns instead of removing them" unless custom.any? { |item| item["key"] == key.to_s }
+        replace("schema_version" => 1, "columns" => to_h["columns"].reject { |item| item["key"] == key.to_s })
+      end
+
+      def move(key, index)
+        rows = to_h["columns"]
+        raise ConfigError, "column position is outside the list" unless index.is_a?(Integer) && index.between?(0, rows.size - 1)
+        item = rows.find { |column| column["key"] == key.to_s } || raise(ConfigError, "unknown column")
+        rows.delete(item)
+        rows.insert(index, item)
+        replace("schema_version" => 1, "columns" => rows)
+      end
+
+      def update_layout(items)
+        rows = items.map do |item|
+          key = item.fetch(:key).to_s
+          saved = @columns.find { |column| column["key"] == key } || raise(ConfigError, "unknown column")
+          saved.merge("width" => item.fetch(:width), "visible" => item.fetch(:visible))
+        end
+        raise ConfigError, "column layout is incomplete" unless rows.size == @columns.size
+        replace("schema_version" => 1, "columns" => rows)
+      rescue KeyError, NoMethodError
+        raise ConfigError, "invalid column layout"
+      end
+
+      def save(directory)
+        path = File.join(directory, "columns.yml")
+        raise ConfigError, "columns configuration must not be a symlink" if File.symlink?(directory) || File.symlink?(path)
+        YamlFile.write(path, to_h)
+      end
+
+      def self.display(values, type: nil)
+        # ponytail: cap a cell at 16 values and 4096 bytes; the details and byte panes retain full data.
+        text = values.first(16).map do |value|
+          text = type == :bytes && value.is_a?(String) ? value.byteslice(0, 1024).unpack1("H*") : value.to_s.byteslice(0, 1024)
+          escaped = text.b.gsub(/[^\x20-\x7e]/n) { |byte| format("\\x%02x", byte.getbyte(0)) }
+          escaped += "…" if value.to_s.bytesize > 1024
+          escaped
+        end.join(", ")
+        text = text.byteslice(0, 4096).force_encoding(Encoding::UTF_8).scrub + "…" if text.bytesize > 4096 || values.size > 16
+        text
+      end
+
+      def self.sort_value(value, type: nil)
+        return [2, 0] if value.nil?
+        return [0, value] if value.is_a?(Numeric)
+        return [0, value ? 1 : 0] if [true, false].include?(value)
+        return [0, IPAddr.new(value.to_s).ipv4? ? 4 : 6, IPAddr.new(value.to_s).to_i] if type == :address
+        return [0, value.to_s.delete(".:-").to_i(16)] if type == :mac
+        [1, value.to_s.b]
+      rescue ArgumentError
+        [1, value.to_s.b]
+      end
+    end
+  end
+end