vanken 0.1.0 → 0.3.0

data/lib/vanken/config/messages.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Vanken
+  module Config
+    module Messages
+      EN = {
+        "TCP ストリームを追跡" => "Follow TCP Stream", "別プロトコルとして解析" => "Decode As",
+        "注記" => "note", "警告" => "warning", "エラー" => "error", "トラフィック" => "traffic",
+        "開く" => "Open", "名前を付けて保存" => "Save as", "ファイルを閉じる" => "Close file", "再読み込み" => "Reload",
+        "終了" => "Quit", "設定" => "Preferences", "キャプチャ開始／停止" => "Start or stop capture", "キャプチャ再開" => "Restart capture",
+        "フィルタを適用" => "Apply filter", "フィルタをクリア" => "Clear filter", "フィルタ履歴" => "Filter history", "フィルタを保存" => "Save filter",
+        "選択した項目でフィルタ" => "Filter by selected field", "選択した項目のフィルタを準備" => "Prepare filter from selected field",
+        "表示する列" => "Visible columns", "末尾追従" => "Follow tail", "末尾追従 ✓" => "Follow tail ✓",
+        "拡大" => "Zoom in", "縮小" => "Zoom out", "標準サイズ" => "Reset zoom",
+        "前のパケット" => "Previous packet", "次のパケット" => "Next packet", "最初のパケット" => "First packet", "最後のパケット" => "Last packet",
+        "パケットへ移動" => "Go to packet", "項目をフィルタとしてコピー" => "Copy field as filter",
+        "パケット検索" => "Find packet", "次を検索" => "Find next", "前を検索" => "Find previous",
+        "マーク／解除" => "Mark or unmark packet", "表示中をすべてマーク" => "Mark all displayed packets", "すべてのマークを解除" => "Unmark all packets",
+        "無視／解除" => "Ignore or unignore packet", "時刻基準／解除" => "Set or unset time reference", "同一会話の前" => "Previous in conversation", "同一会話の次" => "Next in conversation",
+        "色付けルール" => "Coloring rules", "色付け" => "Packet coloring", "エキスパート情報" => "Expert information",
+        "プラグイン再読み込み" => "Reload plugins", "ディセクタプラグイン" => "Dissector plugins", "キャプチャファイルのプロパティ" => "Capture file properties",
+        "プロトコル階層" => "Protocol hierarchy", "会話" => "Conversations", "端点" => "Endpoints", "I/O グラフ" => "I/O graph",
+        "指定パケットのエクスポート" => "Export specified packets", "解析結果のエクスポート" => "Export dissections", "コマンドパレット" => "Command palette", "プロファイル" => "Profiles",
+        "時刻: %{name}" => "Time: %{name}", "テーマ: %{name}" => "Theme: %{name}", "選択項目" => "Selected field", "選択項目を除外" => "Exclude selected field",
+        "適用: %{label}" => "Apply: %{label}", "準備: %{label}" => "Prepare: %{label}", "16 進数" => "Hexadecimal", "テキスト" => "Text", "ダンプ" => "Hex dump",
+        "エスケープした文字列" => "Escaped text", "バイトをコピー: %{label}" => "Copy bytes: %{label}",
+        "ファイル" => "File", "編集" => "Edit", "表示" => "View", "時刻形式" => "Time format", "テーマ" => "Theme", "移動" => "Go",
+        "キャプチャ" => "Capture", "フィルタ" => "Filter", "選択項目を適用" => "Apply selected field", "選択項目から準備" => "Prepare from selected field",
+        "分析" => "Analyze", "統計" => "Statistics", "ヘルプ" => "Help", "表示中のパケットのみ" => "Displayed packets only",
+        "%{value}秒" => "%{value} s", "間隔" => "Interval", "系列の表示フィルタ（1行に1系列、空行は全件）" => "Series display filters (one per line; blank means all packets)",
+        "系列を適用" => "Apply series", "表示するパケットがありません。" => "There are no packets to display.", "全件 %{index}" => "All packets %{index}",
+        "先頭の%{count}区間を省略しています。間隔を広げると全期間を表示できます。" => "The first %{count} intervals are omitted. Select a wider interval to show the entire capture.",
+        "TCPストリームを持つパケットを選択してください。" => "Select a packet with a TCP stream.", "ストリーム番号" => "Stream number",
+        "16進ダンプ" => "Hex dump", "生データ（保存用）" => "Raw data (for saving)", "表示形式" => "Display format", "両方向" => "Both directions",
+        "クライアント → サーバー" => "Client → server", "サーバー → クライアント" => "Server → client", "方向" => "Direction",
+        "ストリーム番号は0以上の整数で指定してください。" => "The stream number must be a nonnegative integer.", "文字列検索" => "Find text",
+        "保存" => "Save", "このストリームを除外" => "Exclude this stream", "表示は16 MiBまでです。保存は全量を含みます。" => "The display is limited to 16 MiB. Saving includes the entire stream.",
+        "範囲（1-10,20,30-）" => "Range (1-10,20,30-)", "無視したパケットを除外" => "Exclude ignored packets", "全件" => "All packets", "表示中" => "Displayed",
+        "選択" => "Selected", "マーク済み" => "Marked", "最初と最後のマークの間" => "Between first and last marks", "範囲指定" => "Packet range", "対象" => "Scope",
+        "形式" => "Format", "エクスポート" => "Export", "解析結果" => "Dissections", "パケット" => "Packets", "%{kind}のエクスポート" => "Export %{kind}",
+        "SHA-256を計算" => "Calculate SHA-256", "集計中…" => "Calculating…", "メモリ上限により%{count}行が省略されました。" => "%{count} rows were omitted because of the memory limit.",
+        "フィルタとして適用" => "Apply as filter", "エクスポート先" => "Export destination", "未記録" => "Not recorded", "未保存" => "Unsaved",
+        "期間（秒）" => "Duration (seconds)", "合計（bytes）" => "Total bytes", "保存済み（bytes）" => "Captured bytes", "平均pps" => "Average packets/s", "平均bps" => "Average bits/s",
+        "インタフェース %{name}" => "Interface %{name}", "取得統計 %{key}" => "Capture statistics %{key}",
+        "検索内容" => "Search query", "表示フィルタ" => "Display filter", "16 進" => "Hex", "文字列" => "String", "正規表現" => "Regular expression",
+        "パケット一覧" => "Packet list", "パケット詳細" => "Packet details", "パケットバイト" => "Packet bytes", "検索対象" => "Search in", "キャンセル" => "Cancel",
+        "一致するパケットはありません。" => "No matching packets were found.", "ルール" => "Rule", "名前" => "Name", "有効" => "Enabled",
+        "ライト" => "Light", "ダーク" => "Dark", "文字" => "Text color", "背景" => "Background", "削除" => "Delete", "追加" => "Add", "新しいルール" => "New rule",
+        "%{theme} %{part}" => "%{theme} %{part}", "インポート" => "Import", "適用" => "Apply", "色付けルールの読み込み先" => "Import coloring rules", "色付けルールの保存先" => "Export coloring rules",
+        "インタフェース" => "Interface", "キャプチャフィルタ (BPF)" => "Capture filter (BPF)", "バッファサイズ (bytes)" => "Buffer size (bytes)",
+        "停止件数 (0: 無制限)" => "Stop after packet count (0: unlimited)", "停止までの秒数 (0: 無制限)" => "Stop after seconds (0: unlimited)", "停止サイズ (bytes、0: 無制限)" => "Stop after bytes (0: unlimited)",
+        "リング保存先 (空欄: 保存しない)" => "Ring file path (blank: disabled)", "リングファイル上限 (bytes)" => "Ring file size limit (bytes)", "リング切替間隔 (秒)" => "Ring rotation interval (seconds)", "リングファイル数" => "Ring file count",
+        "プロミスキャスモード" => "Promiscuous mode", "送受信" => "Inbound and outbound", "受信" => "Inbound", "送信" => "Outbound",
+        "インタフェースを取得中です。" => "Loading interfaces…", "GUI は通常ユーザーで動作し、取得ヘルパーに必要な権限を渡します。" => "The application runs as your user and grants the capture helper the required permissions.",
+        "開始" => "Start", "停止" => "Stop", "再開" => "Restart", "キャプチャオプション" => "Capture options", "時刻表示" => "Time display", "文字を小さく" => "Smaller text", "文字を大きく" => "Larger text",
+        "ファイルを開く" => "Open file", "キャプチャを停止してから操作してください。" => "Stop the capture before continuing.", "キャプチャ中" => "Capturing",
+        "このキャプチャはまだ保存されていません。" => "This capture has not been saved.", "破棄" => "Discard", "キャプチャを保存しますか？" => "Save this capture?",
+        "指定したパケットは表示されていません" => "The specified packet is not displayed", "%{message} (位置 %{position})" => "%{message} (position %{position})",
+        "フィルタとしてコピー" => "Copy as filter", "フィルタを準備" => "Prepare filter", "フィルタの名前" => "Filter name",
+        "プロファイルの管理" => "Manage profiles", "複製" => "Duplicate", "新しいプロファイル名" => "New profile name", "新規作成" => "Create profile", "例: udp.port==8443,dns" => "Example: udp.port==8443,dns",
+        "Ruby ディセクタのパス" => "Ruby dissector path", "Ruby プラグインはユーザー権限で任意のコードを実行します。信頼するファイルだけを読み込んでください。\n%{paths}" => "Ruby plugins can execute arbitrary code as your user. Load only files you trust.\n%{paths}",
+        "信頼して読み込む" => "Trust and load", "プラグインの確認" => "Confirm plugins", "コマンドを検索" => "Search commands", "解析" => "Analysis", "名前解決" => "Name resolution",
+        "キャプチャファイルを開くか、インタフェースを選んで開始してください" => "Open a capture file or select an interface to start capturing.",
+        "読み込み中" => "Loading", "%{state} %{count} / %{total}   表示 %{displayed}   ドロップ %{dropped}" => "%{state} %{count} / %{total}   Displayed %{displayed}   Dropped %{dropped}",
+        "操作を完了できません" => "The operation could not be completed", "読み込みを中止" => "Cancel loading", "クリア" => "Clear", "履歴" => "History",
+        "パケットキャプチャを開くか、インタフェースを選択してキャプチャを開始します。" => "Open a packet capture or select an interface to start capturing.",
+        "キャプチャファイルを開く" => "Open capture file", "インタフェースを選択" => "Select interface",
+        "上へ移動" => "Move up", "下へ移動" => "Move down", "項目名" => "Column name", "表示フィールド" => "Display field", "列幅" => "Column width",
+        "列として適用" => "Apply as column", "カスタム列を追加" => "Add custom column", "カスタム列" => "Custom columns", "列の名前" => "Column label", "フィールド名" => "Field name",
+        "時刻" => "Time", "送信元" => "Source", "宛先" => "Destination", "プロトコル" => "Protocol", "長さ" => "Length", "情報" => "Info",
+        "重大度" => "Severity", "コード" => "Code", "件数" => "Count", "メッセージ" => "Message", "アドレス A" => "Address A", "ポート A" => "Port A", "アドレス B" => "Address B", "ポート B" => "Port B",
+        "パケット A → B" => "Packets A → B", "パケット B → A" => "Packets B → A", "バイト A → B" => "Bytes A → B", "バイト B → A" => "Bytes B → A",
+        "アドレス" => "Address", "ポート" => "Port", "送信パケット" => "Transmitted packets", "受信パケット" => "Received packets", "送信バイト" => "Transmitted bytes", "受信バイト" => "Received bytes", "期間（ns）" => "Duration (ns)",
+        "言語" => "Language", "文字サイズ" => "Font size", "時刻の精度" => "Time precision", "自動スクロール" => "Autoscroll", "行キャッシュ容量" => "Row cache size",
+        "チェックサム検証" => "Verify checksums", "解析メモリ上限（MiB）" => "Analysis memory limit (MiB)", "フロー数上限" => "Maximum flows", "ワーカー数" => "Workers",
+        "キャプチャ方式" => "Capture backend", "ヘルパー起動方式" => "Helper launcher", "解決タイムアウト（秒）" => "Resolution timeout (seconds)", "名前キャッシュ容量" => "Name cache size",
+        "保存せずに閉じる" => "Close without saving", "復旧可能なセッション" => "Recoverable sessions", "復旧" => "Recover", "一時セッションを復旧しますか？" => "Recover temporary sessions?",
+        "相対時刻" => "Relative time", "絶対時刻" => "Absolute time", "前パケットとの差" => "Delta from previous packet", "前表示パケットとの差" => "Delta from previous displayed packet", "エポック時刻" => "Epoch time",
+        "システム設定" => "System", "ハイコントラスト" => "High contrast", "ミリ秒" => "Milliseconds", "マイクロ秒" => "Microseconds", "ナノ秒" => "Nanoseconds",
+        "前回のキャプチャを復旧" => "Recover previous capture",
+        "%{label} %{count} / %{total}   表示 %{displayed}   ドロップ %{dropped}%{progress}" => "%{label} %{count} / %{total}   Displayed %{displayed}   Dropped %{dropped}%{progress}",
+        "幅" => "Width", "列名 (空欄: フィールド名)" => "Column label (blank: field name)", "幅は40から4096の範囲で指定してください" => "Width must be between 40 and 4096",
+        "%{protocol}   %{packets} パケット   %{bytes} bytes   %{percent}%" => "%{protocol}   %{packets} packets   %{bytes} bytes   %{percent}%",
+        "区間ごとのパケット数" => "Packets per interval", "%{count} パケット" => "%{count} packets", "キャプチャファイル" => "Capture files", "閉じる" => "Close",
+        "取得バッファ (bytes)" => "Capture buffer (bytes)", "取得方向" => "Capture direction",
+        "自動停止: パケット数 (0: 無効)" => "Stop after packet count (0: disabled)", "自動停止: 秒 (0: 無効)" => "Stop after seconds (0: disabled)", "自動停止: bytes (0: 無効)" => "Stop after bytes (0: disabled)",
+        "リング保存先 (空欄: 無効)" => "Ring file path (blank: disabled)", "リング: ファイルごとのbytes" => "Ring: bytes per file", "リング: 秒" => "Ring: seconds", "リング: 保持ファイル数" => "Ring: retained files",
+        "検索形式" => "Search mode", "キャプチャ操作" => "Capture controls", "日本語" => "Japanese", "英語" => "English", "自動" => "Automatic", "直接" => "Direct",
+        "マーク" => "Mark", "マークを解除" => "Unmark", "無視" => "Ignore", "無視を解除" => "Unignore", "時刻基準にする" => "Set time reference", "時刻基準を解除" => "Unset time reference", "双方向" => "Both directions", "フィルタ履歴はまだありません。" => "There is no filter history yet."
+      }.freeze #: Hash[String, String]
+      JA = EN.invert.freeze #: Hash[String, String]
+
+      # @rbs (String text, ?language: String, **untyped values) -> String
+      def self.translate(text, language: "ja", **values)
+        dictionary = case language
+        when "ja" then JA
+        when "en" then EN
+        else raise Vanken::ConfigError, "invalid language: #{language}"
+        end
+        dictionary.fetch(text, text).gsub(/%\{(\w+)\}/) { values.fetch(Regexp.last_match(1).to_sym).to_s }
+      end
+    end
+  end
+end

data/lib/vanken/config/preferences.rb

@@ -5,6 +5,7 @@ require "yaml"
 require "fileutils"
 require "logger"
 require "tempfile"
+require_relative "yaml_file"
 
 module Vanken
   module Config
@@ -25,22 +26,32 @@ module Vanken
     class Preferences
       DEFAULTS = {
         "schema_version" => 1,
-        "appearance" => {"theme" => "system", "font_size" => 13, "language" => "ja"},
-        "packet_list" => {"time_format" => "relative", "time_precision" => "micro", "autoscroll" => true, "row_cache_rows" => 20_000},
-        "capture" => {"snaplen" => 262_144, "promiscuous" => true, "buffer_size" => 4 << 20, "backend" => "auto", "launcher" => "auto", "direction" => "inout"},
+        "appearance" => {"theme" => "system", "font_size" => 13, "language" => ENV.fetch("LANG", "en").start_with?("ja") ? "ja" : "en"},
+        "packet_list" => {"time_format" => "relative", "time_precision" => "micro", "autoscroll" => true, "row_cache_rows" => 20_000, "coloring" => true},
+        "capture" => {"snaplen" => 262_144, "promiscuous" => true, "buffer_size" => 4 << 20, "backend" => "auto", "launcher" => "auto", "direction" => "inout",
+          "stop_count" => 0, "stop_duration" => 0.0, "stop_bytes" => 0, "ring_path" => "", "ring_max_bytes" => 0, "ring_interval" => 0.0, "ring_file_count" => 10},
+        "name_resolution" => {"enabled" => false, "timeout" => 1.0, "cache_size" => 256},
         "analysis" => {"verify_checksums" => false, "max_state_mib" => 256, "max_flows" => 100_000, "workers" => 4},
         "history" => [], "recent_files" => [], "bookmarks" => {}, "layout" => {"ratios" => [0.55, 0.6], "width" => 1280, "height" => 800, "columns" => []}
       }.freeze
       attr_reader :warning, :directory
 
-      def initialize(directory: Paths.config)
+      def initialize(directory: Paths.config, state_directory: nil)
         @directory = directory
+        @state_directory = state_directory || (directory == Paths.config ? Paths.state : File.join(directory, "state"))
         @values = Marshal.load(Marshal.dump(DEFAULTS))
         path = File.join(directory, "preferences.yml")
-        return unless File.file?(path)
-        saved = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
-        raise Vanken::ConfigError, "unsupported preferences schema" unless saved.is_a?(Hash) && saved["schema_version"] == 1
-        merge(@values, saved)
+        if File.file?(path)
+          saved = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+          raise Vanken::ConfigError, "unsupported preferences schema" unless saved.is_a?(Hash) && saved["schema_version"] == 1
+          merge(@values, saved)
+        end
+        state = YamlFile.read(File.join(@state_directory, "recent.yml"))
+        merge(@values, state.slice("history", "recent_files"))
+        window = YamlFile.read(File.join(@state_directory, "window_state.yml"))
+        merge(@values["layout"], window.slice("width", "height", "ratios"))
+        filters = YamlFile.read(File.join(@directory, "filters.yml"))
+        merge(@values, filters.slice("bookmarks"))
         validate
       rescue Psych::Exception, Vanken::ConfigError, SystemCallError, TypeError => error
         @values = Marshal.load(Marshal.dump(DEFAULTS))
@@ -78,6 +89,9 @@ module Vanken
         temporary.fsync
         temporary.close
         File.rename(temporary.path, File.join(@directory, "preferences.yml"))
+        YamlFile.write(File.join(@state_directory, "recent.yml"), @values.slice("history", "recent_files"))
+        YamlFile.write(File.join(@state_directory, "window_state.yml"), @values["layout"].slice("width", "height", "ratios"))
+        YamlFile.write(File.join(@directory, "filters.yml"), @values.slice("bookmarks"))
       ensure
         temporary&.close unless temporary&.closed?
         File.unlink(temporary.path) if temporary && File.exist?(temporary.path)
@@ -99,6 +113,7 @@ module Vanken
         validate_shape(DEFAULTS, @values)
         raise Vanken::ConfigError, "invalid theme" unless %w[system dark light high_contrast].include?(get("appearance.theme"))
         raise Vanken::ConfigError, "invalid font size" unless get("appearance.font_size").is_a?(Integer) && get("appearance.font_size").between?(8, 32)
+        raise Vanken::ConfigError, "invalid language" unless %w[ja en].include?(get("appearance.language"))
         raise Vanken::ConfigError, "invalid time format" unless %w[relative absolute delta delta_displayed epoch].include?(get("packet_list.time_format"))
         raise Vanken::ConfigError, "invalid time precision" unless %w[milli micro nano].include?(get("packet_list.time_precision"))
         raise Vanken::ConfigError, "invalid history" unless history.all? { |item| item.is_a?(String) } && recent_files.all? { |item| item.is_a?(String) } && bookmarks.all? { |name, expression| name.is_a?(String) && expression.is_a?(String) }
@@ -111,6 +126,17 @@ module Vanken
         columns = get("layout.columns")
         raise Vanken::ConfigError, "invalid columns" unless columns.all? { |column| column.is_a?(Hash) && %w[no time source destination protocol length info].include?(column["key"]) && column["width"].is_a?(Numeric) && column["width"].finite? && column["width"].between?(40, 4096) && [true, false].include?(column["visible"]) } && columns.map { |column| column["key"] }.uniq.size == columns.size
         raise Vanken::ConfigError, "invalid capture settings" unless %w[auto direct sudo pkexec].include?(get("capture.launcher")) && %w[auto ring socket bpf].include?(get("capture.backend")) && %w[in out inout].include?(get("capture.direction"))
+        %w[capture.stop_count capture.stop_bytes capture.ring_max_bytes].each do |path|
+          raise ConfigError, "invalid #{path}" unless get(path).is_a?(Integer) && get(path).between?(0, (1 << 63) - 1)
+        end
+        %w[capture.stop_duration capture.ring_interval].each do |path|
+          value = get(path)
+          raise ConfigError, "invalid #{path}" unless value.is_a?(Numeric) && value.finite? && value >= 0
+        end
+        raise ConfigError, "invalid ring file count" unless get("capture.ring_file_count").between?(1, 10_000)
+        raise ConfigError, "invalid ring path" if get("capture.ring_path").include?("\0")
+        raise ConfigError, "invalid resolver timeout" unless get("name_resolution.timeout").finite? && get("name_resolution.timeout").between?(0.01, 10)
+        raise ConfigError, "invalid resolver cache size" unless get("name_resolution.cache_size").between?(1, 10_000)
       rescue NoMethodError, KeyError
         raise Vanken::ConfigError, "invalid preferences shape"
       end

data/lib/vanken/config/profiles.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require_relative "preferences"
+require_relative "yaml_file"
+
+module Vanken
+  module Config
+    class Profiles
+      FILES = %w[preferences.yml coloring_rules.yml columns.yml filters.yml decode_as.yml plugins.yml].freeze
+      attr_reader :directory, :active
+
+      def initialize(directory: Paths.config)
+        @directory = File.expand_path(directory)
+        @active = YamlFile.read(File.join(@directory, "profiles.yml"), default: {"active" => "default"}).fetch("active", "default")
+        profile_directory(@active)
+        @active = "default" unless names.include?(@active)
+      end
+
+      def names
+        ["default", *Dir.glob(File.join(@directory, "profiles", "*")).select { |path| File.directory?(path) && !File.symlink?(path) }.map { |path| File.basename(path) }.sort]
+      end
+
+      def preferences
+        shared = @directory == File.expand_path(Paths.config) ? Paths.state : File.join(@directory, "state")
+        Preferences.new(directory: profile_directory(@active), state_directory: shared)
+      end
+
+      def create(name, copy_from: nil)
+        target = profile_directory(name)
+        raise ConfigError, "profile already exists" if names.include?(name) || File.exist?(target) || File.symlink?(target)
+        raise ConfigError, "unknown profile" if copy_from && !names.include?(copy_from)
+        FileUtils.mkdir_p(File.dirname(target), mode: 0o700)
+        Dir.mkdir(target, 0o700)
+        if copy_from
+          source = profile_directory(copy_from)
+          FILES.each do |file|
+            path = File.join(source, file)
+            next unless File.file?(path)
+            raise ConfigError, "profile file must not be a symlink" if File.symlink?(path)
+            File.write(File.join(target, file), File.binread(path), mode: "wb", perm: 0o600)
+          end
+        else
+          Preferences.new(directory: target).save
+        end
+        name
+      end
+
+      def switch(name)
+        profile_directory(name)
+        raise ConfigError, "unknown profile" unless names.include?(name)
+        @active = name
+        YamlFile.write(File.join(@directory, "profiles.yml"), "active" => name)
+        preferences
+      end
+
+      def delete(name)
+        path = profile_directory(name)
+        raise ConfigError, "cannot delete the active or default profile" if name == @active || name == "default"
+        raise ConfigError, "unknown profile" unless names.include?(name)
+        FileUtils.remove_entry_secure(path)
+      end
+
+      private
+
+      def profile_directory(name)
+        raise ConfigError, "invalid profile name" unless name.is_a?(String) && name.match?(/\A[\p{L}\p{N}_ -][\p{L}\p{N}_. -]{0,63}\z/) && !%w[. ..].include?(name)
+        path = name == "default" ? @directory : File.join(@directory, "profiles", name)
+        raise ConfigError, "profiles directory must not be a symlink" if name != "default" && File.symlink?(File.join(@directory, "profiles"))
+        raise ConfigError, "profile must not be a symlink" if File.symlink?(path)
+        path
+      end
+    end
+  end
+end

data/lib/vanken/config/sessions.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "json"
+
+module Vanken
+  module Config
+    module Sessions
+      def self.candidates(parent: Dir.tmpdir)
+        Dir.glob(File.join(parent, "vanken-*" )).select { |directory| orphan?(directory) }.sort
+      end
+
+      def self.recover(directory, parent: Dir.tmpdir, **options)
+        with_session(directory, parent: parent) { App::Document.recover(directory, **options) }
+      end
+
+      def self.discard(directory, parent: Dir.tmpdir)
+        store = with_session(directory, parent: parent) { Core::FrameStore.recover(directory) }
+        store.close
+      end
+
+      def self.orphan?(directory)
+        return false unless File.directory?(directory) && !File.symlink?(directory)
+        stat = File.stat(directory)
+        return false unless stat.uid == Process.uid && (stat.mode & 0o077).zero?
+        Dir.children(directory).each do |name|
+          stat = File.lstat(File.join(directory, name))
+          return false unless stat.file? && stat.uid == Process.uid && stat.nlink == 1
+        end
+        path = File.join(directory, "session.json")
+        return false unless File.file?(path) && File.size(path) <= 65_536
+        return false unless %w[frames.bin frames.idx].all? { |name| File.file?(File.join(directory, name)) }
+        session = JSON.parse(File.read(path))
+        pid = session["pid"]
+        return false unless session["schema_version"] == 1 && pid.is_a?(Integer) && pid.positive?
+        begin
+          Process.kill(0, pid)
+          false
+        rescue Errno::ESRCH
+          true
+        rescue Errno::EPERM
+          false
+        end
+      rescue SystemCallError, JSON::ParserError, TypeError, NoMethodError
+        false
+      end
+
+      def self.with_session(directory, parent:)
+        path = File.expand_path(directory)
+        raise Vanken::FileError, "session is active or unsafe" unless candidates(parent: parent).include?(path)
+        File.open(File.join(path, "session.json"), "r+b") do |file|
+          raise Vanken::FileError, "session is being recovered" unless file.flock(File::LOCK_EX | File::LOCK_NB)
+          raise Vanken::FileError, "session is active or unsafe" unless orphan?(path)
+          original = file.read
+          begin
+            yield
+          rescue StandardError
+            file.rewind
+            file.truncate(0)
+            file.write(original)
+            file.flush
+            raise
+          end
+        end
+      end
+      private_class_method :orphan?, :with_session
+    end
+  end
+end

data/lib/vanken/config/yaml_file.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "yaml"
+require "tempfile"
+require "fileutils"
+
+module Vanken
+  module Config
+    module YamlFile
+      def self.read(path, default: {})
+        return default unless File.file?(path)
+        raise ConfigError, "configuration exceeds 1 MiB" if File.size(path) > 1 << 20
+        value = YAML.safe_load(File.read(path), permitted_classes: [], aliases: false)
+        raise ConfigError, "unsupported configuration schema: #{path}" unless value.is_a?(Hash) && value["schema_version"] == 1
+        value
+      rescue Psych::Exception => error
+        raise ConfigError, error.message
+      end
+
+      def self.write(path, value)
+        directory = File.dirname(path)
+        FileUtils.mkdir_p(directory, mode: 0o700)
+        temporary = Tempfile.create(["vanken-", ".yml"], directory)
+        temporary.chmod(0o600)
+        temporary.write(YAML.dump(value.merge("schema_version" => 1)))
+        temporary.flush
+        temporary.fsync
+        temporary.close
+        File.rename(temporary.path, path)
+      ensure
+        temporary&.close unless temporary&.closed?
+        File.unlink(temporary.path) if temporary && File.exist?(temporary.path)
+      end
+    end
+  end
+end

data/lib/vanken/core/coloring.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+require "yaml"
+require "tempfile"
+require "fileutils"
+require_relative "display_filter/compiler"
+
+module Vanken
+  module Core
+    module Coloring
+      Rule = Data.define(
+        :name, #: String
+        :filter, #: String
+        :light, #: Hash[String, String]
+        :dark, #: Hash[String, String]
+        :enabled, #: bool
+        :program #: DisplayFilter::Program
+      )
+
+      class RuleSet
+        DEFAULT_PATH = File.expand_path("../../../data/coloring_rules.yml", __dir__)
+        attr_reader :rules #: Array[Rule]
+
+        # @rbs (Hash[String, untyped] payload, ?catalog: untyped) -> void
+        def initialize(payload, catalog: nil)
+          raise Vanken::ConfigError, "unsupported coloring rules schema" unless payload.is_a?(Hash) && payload["schema_version"] == 1 && payload["rules"].is_a?(Array) && payload["rules"].size <= 256
+          @rules = payload.fetch("rules").map do |value|
+            raise Vanken::ConfigError, "invalid coloring rule" unless value.is_a?(Hash) && value["name"].is_a?(String) && value["filter"].is_a?(String) && !value["filter"].empty? && [true, false].include?(value["enabled"])
+            palettes = %w[light dark].map do |theme|
+              colors = value[theme]
+              raise Vanken::ConfigError, "invalid rule colors" unless colors.is_a?(Hash) && %w[fg bg].all? { |key| colors[key].is_a?(String) && /\A#[\da-fA-F]{6}\z/.match?(colors[key]) }
+              colors.slice("fg", "bg").transform_values { |color| color.dup.freeze }.freeze
+            end
+            Rule.new(value["name"].dup.freeze, value["filter"].dup.freeze, palettes[0], palettes[1], value["enabled"], DisplayFilter.compile(value["filter"], catalog: catalog))
+          end.freeze
+        rescue DisplayFilter::SyntaxError => error
+          raise Vanken::ConfigError, "invalid coloring filter: #{error.message}"
+        end
+
+        # @rbs (_FilterView view, ?theme: Symbol) -> Hash[Symbol, String]?
+        def match(view, theme: :light)
+          rule = @rules.find { |item| item.enabled && item.program.match?(view) }
+          return nil unless rule
+          palette = theme == :light ? rule.light : rule.dark
+          colors = {foreground: palette.fetch("fg")}
+          colors[:background] = palette.fetch("bg") unless theme == :high_contrast
+          colors
+        end
+
+        # @rbs () -> Hash[String, untyped]
+        def to_h
+          {"schema_version" => 1, "rules" => @rules.map do |rule|
+            {"name" => rule.name, "filter" => rule.filter, "light" => rule.light.dup, "dark" => rule.dark.dup, "enabled" => rule.enabled}
+          end}
+        end
+
+        # @rbs (String path) -> void
+        def save(path)
+          directory = File.dirname(File.expand_path(path))
+          FileUtils.mkdir_p(directory, mode: 0o700)
+          temporary = Tempfile.create(["coloring-", ".tmp"], directory)
+          temporary.write(YAML.dump(to_h))
+          temporary.flush
+          temporary.fsync
+          temporary.close
+          File.rename(temporary.path, path)
+        ensure
+          temporary&.close unless temporary&.closed?
+          File.unlink(temporary.path) if temporary && File.exist?(temporary.path)
+        end
+
+        # @rbs (String path, ?catalog: untyped) -> RuleSet
+        def self.load(path, catalog: nil)
+          raise Vanken::ConfigError, "coloring rules file exceeds 1 MiB" if File.size(path) > 1 << 20
+          new(YAML.safe_load(File.read(path), permitted_classes: [], aliases: false), catalog: catalog)
+        rescue Psych::Exception, SystemCallError => error
+          raise Vanken::ConfigError, error.message
+        end
+
+        # @rbs (?catalog: untyped) -> RuleSet
+        def self.defaults(catalog: nil) = load(DEFAULT_PATH, catalog: catalog)
+      end
+    end
+  end
+end

data/lib/vanken/core/frame_store.rb

@@ -114,8 +114,8 @@ module Vanken
             [@data, @records, @reader, @index_reader].compact.each(&:close)
             @closed = true
           end
+          FileUtils.remove_entry_secure(@directory) if remove && File.directory?(@directory)
         end
-        FileUtils.remove_entry_secure(@directory) if remove && File.directory?(@directory)
       end
 
       private
@@ -130,7 +130,7 @@ module Vanken
 
       def validate_directory
         raise Vanken::FileError, "unsafe session directory" unless File.directory?(@directory) && !File.symlink?(@directory) && File.stat(@directory).uid == Process.uid
-        %w[frames.idx frames.bin interfaces.json session.json].each do |name|
+        Dir.children(@directory).each do |name|
           path = File.join(@directory, name)
           next unless File.exist?(path) || File.symlink?(path)
           stat = File.lstat(path)

data/lib/vanken/core/stores.rb

@@ -116,12 +116,14 @@ module Vanken
       SIZE = 32
       attr_reader :streams #: Hash[Integer, Array[Integer]]
       attr_reader :experts #: Hash[Integer, Array[Hash[Symbol, untyped]]]
+      attr_reader :expert_count, :expert_max #: Integer
       # @rbs! @extra: Hash[Integer, Hash[String, untyped]]
       # @rbs! @io: File?
       # @rbs (String directory, ?persist: bool) -> void
       def initialize(directory, persist: true)
         @data = +"".b
         @extra, @streams, @experts = {}, Hash.new { |hash, key| hash[key] = [] }, {}
+        @expert_count = @expert_max = 0
         @io = File.open(File.join(directory, "annotations.bin"), "wb", 0o600) if persist
       end
       # @rbs (Integer number, annotation_values annotation) -> void
@@ -132,6 +134,8 @@ module Vanken
         @io&.write(record)
         @streams[annotation[:tcp_stream]] << number if annotation[:tcp_stream] >= 0
         @experts[number] = annotation[:expert_items] unless annotation[:expert_items].empty?
+        @expert_count += annotation[:expert_items].size
+        @expert_max = [@expert_max, annotation[:expert_max]].max
         @extra[number] = annotation[:extra] unless annotation[:extra].empty?
       end
       # @rbs () -> Hash[Symbol, untyped]
@@ -139,6 +143,7 @@ module Vanken
         batch = {data: @data, extras: @extra, streams: @streams.transform_values { |numbers| numbers }, experts: @experts}
         @data = +"".b
         @extra, @streams, @experts = {}, Hash.new { |hash, key| hash[key] = [] }, {}
+        @expert_count = @expert_max = 0
         batch
       end
       # @rbs (Hash[Symbol, untyped] batch) -> void
@@ -148,6 +153,13 @@ module Vanken
         @data << batch[:data]
         @extra.merge!(batch[:extras])
         @experts.merge!(batch[:experts])
+        batch[:experts].each_value do |items|
+          @expert_count += items.size
+          items.each do |item|
+            rank = {"note" => 1, "warn" => 2, "warning" => 2, "error" => 3}.fetch(item[:severity].to_s, 0)
+            @expert_max = [@expert_max, rank].max
+          end
+        end
         batch[:streams].each { |stream, numbers| @streams[stream].concat(numbers) }
       end
       # @rbs (Integer number) -> annotation_values

data/lib/vanken/gateway/detail_builder.rb

@@ -12,7 +12,7 @@ module Vanken
         frame = node("frame", "Frame #{raw.number}: #{raw.original_length} bytes on wire, #{raw.caplen} captured", offset: 0, length: raw.caplen)
         nodes = packet.layers.each_with_index.map do |layer, index|
           prefix = packet.layers.count { |item| item.protocol == layer.protocol } > 1 ? "#{layer.protocol}[#{index}]" : layer.protocol.to_s
-          klass = Redhound::Registry.default.protocols[layer.protocol]
+          klass = packet.registry.protocols[layer.protocol]
           source = packet.layer_source(layer)
           children = layer.fields.map do |field|
             value = field.value