Merge pull request #230 from loss-and-quick/feat/routing-catch-all-warning

feat(frontend): warn about catch-all routing rules

Author: loss-and-quick

frontend/src/features/settings/__tests__/isCatchAllRule.test.ts

@@ -0,0 +1,77 @@
+import { describe, expect, it } from "vitest";
+import type { RoutingRule } from "../../../generated/bindings";
+import { isCatchAllRule, isRedundantCatchAll } from "../helpers";
+
+const rule = (patch: Partial<RoutingRule>): RoutingRule => ({
+  id: "r1",
+  remarks: "",
+  enabled: true,
+  outboundTag: "proxy",
+  ...patch,
+});
+
+describe("isCatchAllRule", () => {
+  it("flags a full port range with no other match field", () => {
+    expect(isCatchAllRule(rule({ port: "0-65535" }))).toBe(true);
+    expect(isCatchAllRule(rule({ port: "1-65535" }))).toBe(true);
+  });
+
+  it("flags a full range assembled from several parts", () => {
+    expect(isCatchAllRule(rule({ port: "1-1000,1001-65535" }))).toBe(true);
+  });
+
+  it("ignores a range with a gap or a short tail", () => {
+    expect(isCatchAllRule(rule({ port: "1-1000,1002-65535" }))).toBe(false);
+    expect(isCatchAllRule(rule({ port: "0-65534" }))).toBe(false);
+    expect(isCatchAllRule(rule({ port: "443" }))).toBe(false);
+  });
+
+  it("ignores rules that also match on domain, ip or protocol", () => {
+    expect(isCatchAllRule(rule({ port: "0-65535", domain: ["geosite:private"] }))).toBe(false);
+    expect(isCatchAllRule(rule({ port: "0-65535", ip: ["geoip:ru"] }))).toBe(false);
+    expect(isCatchAllRule(rule({ port: "0-65535", protocol: ["bittorrent"] }))).toBe(false);
+  });
+
+  it("treats a single-network rule as narrower than catch-all", () => {
+    expect(isCatchAllRule(rule({ port: "0-65535", network: "udp" }))).toBe(false);
+    expect(isCatchAllRule(rule({ port: "0-65535", network: "tcp,udp" }))).toBe(true);
+  });
+
+  it("ignores disabled rules and rules the backend drops for having no match field", () => {
+    expect(isCatchAllRule(rule({ port: "0-65535", enabled: false }))).toBe(false);
+    expect(isCatchAllRule(rule({}))).toBe(false);
+    expect(isCatchAllRule(rule({ port: "  " }))).toBe(false);
+  });
+
+  it("ignores a malformed port list", () => {
+    expect(isCatchAllRule(rule({ port: "0-abc" }))).toBe(false);
+  });
+});
+
+describe("isRedundantCatchAll", () => {
+  const catchAll = (patch: Partial<RoutingRule> = {}) => rule({ port: "0-65535", ...patch });
+
+  it("flags a trailing catch-all that only repeats the final proxy fallback", () => {
+    expect(isRedundantCatchAll([rule({ ip: ["geoip:ru"] }), catchAll()], 1)).toBe(true);
+  });
+
+  it("ignores one that still shadows an enabled rule below", () => {
+    expect(isRedundantCatchAll([catchAll(), rule({ ip: ["geoip:ru"] })], 0)).toBe(false);
+  });
+
+  it("looks past disabled rules below", () => {
+    expect(isRedundantCatchAll([catchAll(), rule({ ip: ["geoip:ru"], enabled: false })], 0)).toBe(
+      true,
+    );
+  });
+
+  it("ignores a catch-all routed anywhere but the proxy", () => {
+    expect(isRedundantCatchAll([catchAll({ outboundTag: "direct" })], 0)).toBe(false);
+    expect(isRedundantCatchAll([catchAll({ outboundTag: "block" })], 0)).toBe(false);
+  });
+
+  it("ignores an index that points at no rule", () => {
+    expect(isRedundantCatchAll([catchAll()], -1)).toBe(false);
+    expect(isRedundantCatchAll([], 0)).toBe(false);
+  });
+});

frontend/src/features/settings/helpers.ts

@@ -63,6 +63,46 @@ export function ruleSummary(
   return parts.join(" · ");
 }
 
+const MAX_PORT = 65535;
+
+function portCoversEveryPort(port: string | null | undefined): boolean {
+  if (!port?.trim()) return false;
+  const ranges: [number, number][] = [];
+  for (const item of port.split(",")) {
+    const part = item.trim();
+    if (!part) continue;
+    const [lo, hi] = part.includes("-") ? part.split("-") : [part, part];
+    const from = Number(lo);
+    const to = Number(hi);
+    if (!Number.isInteger(from) || !Number.isInteger(to)) return false;
+    ranges.push([Math.min(from, to), Math.max(from, to)]);
+  }
+  ranges.sort((a, b) => a[0] - b[0]);
+  let reached = 0;
+  for (const [from, to] of ranges) {
+    if (from > reached + 1) break;
+    reached = Math.max(reached, to);
+  }
+  return reached >= MAX_PORT;
+}
+
+/** Whether the rule matches every connection, making the rules below it dead. */
+export function isCatchAllRule(rule: RoutingRule): boolean {
+  if (!rule.enabled) return false;
+  if (rule.domain?.length || rule.ip?.length || rule.protocol?.length) return false;
+  if (rule.network && rule.network !== "tcp,udp") return false;
+  return portCoversEveryPort(rule.port);
+}
+
+/**
+ * Whether the catch-all at `index` shadows nothing but the automatic tail, which
+ * already ends in the proxy fallback — so the rule costs the IP check and buys nothing.
+ */
+export function isRedundantCatchAll(rules: RoutingRule[], index: number): boolean {
+  if (index < 0 || rules[index]?.outboundTag !== "proxy") return false;
+  return !rules.slice(index + 1).some((rule) => rule.enabled);
+}
+
 export function ruleIcon(rule: RoutingRule): string {
   if (rule.outboundTag === "direct") return "near_me";
   if (rule.outboundTag === "block") return "block";

frontend/src/features/settings/sections/RoutingSection.tsx

@@ -14,7 +14,7 @@ import type { RoutingRule } from "../../../generated/bindings";
 import { useFormatters, useT } from "../../../i18n";
 import type { AdvancedSettings } from "../../../lib/bridge";
 import { getRuntimeBridgeMode } from "../../../lib/ksu-webui";
-import { ruleIcon, ruleSummary } from "../helpers";
+import { isCatchAllRule, isRedundantCatchAll, ruleIcon, ruleSummary } from "../helpers";
 import { makePresetRule, RULE_PRESETS } from "../rule-presets";
 
 export function RoutingSection({
@@ -51,6 +51,8 @@ export function RoutingSection({
   const profileName = (tag: string) => profiles.find((p) => p.id === tag)?.remarks;
   const domainStrategy4Xray = settings.domainStrategy;
   const domainStrategy4Singbox = settings.domainStrategy4Singbox;
+  const catchAllIndex = routingRules.findIndex(isCatchAllRule);
+  const catchAllRedundant = isRedundantCatchAll(routingRules, catchAllIndex);
 
   return (
     <>
@@ -204,7 +206,25 @@ export function RoutingSection({
                   key={rule.id}
                   icon={ruleIcon(rule)}
                   title={rule.remarks || t("settings.routingRuleDefault", { n: index + 1 })}
-                  sub={ruleSummary(rule, t, formatters, profileName)}
+                  sub={
+                    <>
+                      {ruleSummary(rule, t, formatters, profileName)}
+                      {index === catchAllIndex && (
+                        <div style={{ color: "var(--warn)", marginTop: 2 }}>
+                          {t(
+                            catchAllRedundant
+                              ? "settings.routingCatchAllRedundant"
+                              : "settings.routingCatchAll",
+                          )}
+                        </div>
+                      )}
+                      {catchAllIndex >= 0 && index > catchAllIndex && rule.enabled && (
+                        <div style={{ color: "var(--on-surface-faint)", marginTop: 2 }}>
+                          {t("settings.routingUnreachable")}
+                        </div>
+                      )}
+                    </>
+                  }
                   onClick={() => onEditRule(rule)}
                   right={
                     <div style={{ display: "flex", alignItems: "center", gap: 6 }}>

frontend/src/i18n/ar.ts

@@ -736,6 +736,10 @@ const ar = {
   "settings.routingAddRule": "إضافة قاعدة",
   "settings.routingEmpty": "لا توجد قواعد توجيه بعد.",
   "settings.routingRuleDefault": "القاعدة {n}",
+  "settings.routingCatchAll": "يطابق كل اتصال — القواعد أدناه وفحص IP التلقائي لن تُنفَّذ.",
+  "settings.routingCatchAllRedundant":
+    "يطابق كل اتصال. يُضاف التوجيه النهائي إلى البروكسي تلقائيًا بالفعل، لذا فإن هذه القاعدة تُلغي فحص IP التلقائي دون أي فائدة.",
+  "settings.routingUnreachable": "لا يتم الوصول إليها أبدًا.",
   "settings.routingRuleDomains": plural("count", {
     zero: "لا نطاقات",
     one: "نطاق واحد",

frontend/src/i18n/en.ts

@@ -625,6 +625,11 @@ const en = {
   "settings.routingAddRule": "Add rule",
   "settings.routingEmpty": "No routing rules yet.",
   "settings.routingRuleDefault": "Rule {n}",
+  "settings.routingCatchAll":
+    "Matches every connection — the rules below and the automatic IP check never run.",
+  "settings.routingCatchAllRedundant":
+    "Matches every connection. The proxy fallback is already appended automatically, so this rule only costs you the automatic IP check.",
+  "settings.routingUnreachable": "Never reached.",
   "settings.routingRuleDomains": plural("count", {
     one: "# domain",
     other: "# domains",

frontend/src/i18n/es.ts

@@ -619,6 +619,11 @@ const es = {
   "settings.routingAddRule": "Añadir regla",
   "settings.routingEmpty": "Aún no hay reglas de enrutamiento.",
   "settings.routingRuleDefault": "Regla {n}",
+  "settings.routingCatchAll":
+    "Coincide con todas las conexiones: las reglas siguientes y la comprobación automática de IP nunca se ejecutan.",
+  "settings.routingCatchAllRedundant":
+    "Coincide con todas las conexiones. La salida final por el proxy ya se añade automáticamente, así que esta regla solo te cuesta la comprobación automática de IP.",
+  "settings.routingUnreachable": "Nunca se alcanza.",
   "settings.routingRuleDomains": plural("count", {
     one: "# dominio",
     other: "# dominios",

frontend/src/i18n/hi.ts

@@ -610,6 +610,10 @@ const hi = {
   "settings.routingAddRule": "नियम जोड़ें",
   "settings.routingEmpty": "अभी कोई रूटिंग नियम नहीं हैं।",
   "settings.routingRuleDefault": "नियम {n}",
+  "settings.routingCatchAll": "हर कनेक्शन से मेल खाता है — नीचे के नियम और स्वचालित IP जाँच कभी नहीं चलते।",
+  "settings.routingCatchAllRedundant":
+    "हर कनेक्शन से मेल खाता है। प्रॉक्सी पर अंतिम फ़ॉलबैक पहले से ही अपने आप जुड़ जाता है, इसलिए यह नियम सिर्फ़ स्वचालित IP जाँच छीन लेता है।",
+  "settings.routingUnreachable": "कभी लागू नहीं होता।",
   "settings.routingRuleDomains": plural("count", {
     one: "# डोमेन",
     other: "# डोमेन",

frontend/src/i18n/pt.ts

@@ -618,6 +618,11 @@ const pt = {
   "settings.routingAddRule": "Adicionar regra",
   "settings.routingEmpty": "Ainda não há regras de roteamento.",
   "settings.routingRuleDefault": "Regra {n}",
+  "settings.routingCatchAll":
+    "Corresponde a todas as conexões — as regras abaixo e a verificação automática de IP nunca são executadas.",
+  "settings.routingCatchAllRedundant":
+    "Corresponde a todas as conexões. O encaminhamento final para o proxy já é adicionado automaticamente, portanto esta regra só lhe custa a verificação automática de IP.",
+  "settings.routingUnreachable": "Nunca é alcançada.",
   "settings.routingRuleDomains": plural("count", {
     one: "# domínio",
     other: "# domínios",

frontend/src/i18n/ru.ts

@@ -654,6 +654,11 @@ const ru = {
   "settings.routingAddRule": "Добавить правило",
   "settings.routingEmpty": "Правил маршрутизации пока нет.",
   "settings.routingRuleDefault": "Правило {n}",
+  "settings.routingCatchAll":
+    "Перехватывает весь трафик — правила ниже и автопроверка по IP не сработают.",
+  "settings.routingCatchAllRedundant":
+    "Перехватывает весь трафик. Переход на прокси и так добавляется автоматически, поэтому правило лишь отключает автопроверку по IP.",
+  "settings.routingUnreachable": "Никогда не сработает.",
   "settings.routingRuleDomains": plural("count", {
     one: "# домен",
     few: "# домена",

frontend/src/i18n/vi.ts

@@ -614,6 +614,11 @@ const vi = {
   "settings.routingAddRule": "Thêm quy tắc",
   "settings.routingEmpty": "Chưa có quy tắc định tuyến nào.",
   "settings.routingRuleDefault": "Quy tắc {n}",
+  "settings.routingCatchAll":
+    "Khớp mọi kết nối — các quy tắc bên dưới và bước kiểm tra IP tự động sẽ không chạy.",
+  "settings.routingCatchAllRedundant":
+    "Khớp mọi kết nối. Bước chuyển cuối sang proxy vốn đã được thêm tự động, nên quy tắc này chỉ khiến bạn mất bước kiểm tra IP tự động.",
+  "settings.routingUnreachable": "Không bao giờ được dùng.",
   "settings.routingRuleDomains": plural("count", {
     one: "# domain",
     other: "# domain",