@birdcc/linter 0.0.1-alpha.0

package/src/rules/net.ts

@@ -0,0 +1,262 @@
+import { isIP } from "node:net";
+import type { BirdDiagnostic } from "@birdcc/core";
+import type { FilterBodyStatement, SourceRange } from "@birdcc/parser";
+import {
+  createRuleDiagnostic,
+  filterAndFunctionDeclarations,
+  protocolDeclarations,
+  pushUniqueDiagnostic,
+  type BirdRule,
+} from "./shared.js";
+
+interface PrefixParts {
+  address: string;
+  length: number | null;
+  raw: string;
+}
+
+const PREFIX_PATTERN_SOURCE = "([0-9A-Za-z:.]+\\/[^\\s,;{}[\\]]+)";
+
+const extractPrefixes = (text: string): PrefixParts[] => {
+  const prefixes: PrefixParts[] = [];
+  const prefixPattern = new RegExp(PREFIX_PATTERN_SOURCE, "g");
+  let matched = prefixPattern.exec(text);
+
+  while (matched) {
+    const raw = matched[1] ?? "";
+    const [address, lengthText] = raw.split("/");
+    if (!address || !lengthText) {
+      matched = prefixPattern.exec(text);
+      continue;
+    }
+
+    const normalizedLength = lengthText.trim();
+    const length = /^\d+$/.test(normalizedLength)
+      ? Number.parseInt(normalizedLength, 10)
+      : null;
+    prefixes.push({ address: address.trim(), length, raw });
+
+    matched = prefixPattern.exec(text);
+  }
+
+  return prefixes;
+};
+
+const statementText = (statement: FilterBodyStatement): string => {
+  if (statement.kind === "expression") {
+    return statement.expressionText;
+  }
+
+  if (statement.kind === "other") {
+    return statement.text;
+  }
+
+  if (statement.kind === "if") {
+    return statement.conditionText ?? "";
+  }
+
+  if (statement.kind === "return") {
+    return statement.valueText ?? "";
+  }
+
+  if (statement.kind === "case") {
+    return statement.subjectText ?? "";
+  }
+
+  return "";
+};
+
+const analyzePrefix = (
+  diagnostics: BirdDiagnostic[],
+  seen: Set<string>,
+  prefix: PrefixParts,
+  range: SourceRange,
+): void => {
+  const family = isIP(prefix.address);
+
+  if (prefix.length === null || prefix.length < 0 || prefix.length > 128) {
+    pushUniqueDiagnostic(
+      diagnostics,
+      seen,
+      createRuleDiagnostic(
+        "net/invalid-prefix-length",
+        `Invalid prefix length in '${prefix.raw}'`,
+        range,
+      ),
+    );
+    return;
+  }
+
+  if (prefix.address.includes(".")) {
+    if (family !== 4) {
+      pushUniqueDiagnostic(
+        diagnostics,
+        seen,
+        createRuleDiagnostic(
+          "net/invalid-ipv4-prefix",
+          `Invalid IPv4 prefix '${prefix.raw}'`,
+          range,
+        ),
+      );
+      return;
+    }
+
+    if (prefix.length > 32) {
+      pushUniqueDiagnostic(
+        diagnostics,
+        seen,
+        createRuleDiagnostic(
+          "net/max-prefix-length",
+          `Invalid max prefix length ${prefix.length} for IPv4 prefix '${prefix.raw}'`,
+          range,
+        ),
+      );
+    }
+    return;
+  }
+
+  if (prefix.address.includes(":")) {
+    if (family !== 6) {
+      pushUniqueDiagnostic(
+        diagnostics,
+        seen,
+        createRuleDiagnostic(
+          "net/invalid-ipv6-prefix",
+          `Invalid IPv6 prefix '${prefix.raw}'`,
+          range,
+        ),
+      );
+      return;
+    }
+
+    if (prefix.length > 128) {
+      pushUniqueDiagnostic(
+        diagnostics,
+        seen,
+        createRuleDiagnostic(
+          "net/max-prefix-length",
+          `Invalid max prefix length ${prefix.length} for IPv6 prefix '${prefix.raw}'`,
+          range,
+        ),
+      );
+    }
+    return;
+  }
+
+  pushUniqueDiagnostic(
+    diagnostics,
+    seen,
+    createRuleDiagnostic(
+      "net/invalid-ipv4-prefix",
+      `Invalid IP prefix '${prefix.raw}'`,
+      range,
+    ),
+  );
+};
+
+const netPrefixRules: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+
+  for (const declaration of filterAndFunctionDeclarations(parsed)) {
+    for (const statement of declaration.statements) {
+      const text = statementText(statement);
+      if (!text) {
+        continue;
+      }
+
+      for (const prefix of extractPrefixes(text)) {
+        analyzePrefix(diagnostics, seen, prefix, statement);
+      }
+    }
+
+    for (const match of declaration.matches) {
+      for (const prefix of extractPrefixes(match.right)) {
+        analyzePrefix(diagnostics, seen, prefix, match);
+      }
+    }
+
+    for (const literal of declaration.literals) {
+      if (literal.kind !== "prefix") {
+        continue;
+      }
+
+      for (const prefix of extractPrefixes(literal.value)) {
+        analyzePrefix(diagnostics, seen, prefix, literal);
+      }
+    }
+  }
+
+  return diagnostics;
+};
+
+const netMaxPrefixRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+  const seen = new Set<string>();
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    for (const statement of declaration.statements) {
+      if (statement.kind !== "channel") {
+        continue;
+      }
+
+      if (
+        statement.channelType !== "ipv4" &&
+        statement.channelType !== "ipv6"
+      ) {
+        continue;
+      }
+
+      const channelText = statement.entries
+        .filter((entry) => entry.kind === "other")
+        .map((entry) => entry.text)
+        .join(" ");
+      const matched = channelText.match(/\bmax\s+prefix\s+([^;\s]+)/i);
+      if (!matched) {
+        continue;
+      }
+
+      const token = (matched[1] ?? "").trim();
+      if (!/^\d+$/.test(token)) {
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "net/invalid-prefix-length",
+            `Invalid prefix length in 'max prefix ${token}'`,
+            statement,
+          ),
+        );
+        continue;
+      }
+
+      const length = Number.parseInt(token, 10);
+      if (Number.isNaN(length)) {
+        continue;
+      }
+
+      const maxAllowed = statement.channelType === "ipv4" ? 32 : 128;
+      if (length > maxAllowed) {
+        pushUniqueDiagnostic(
+          diagnostics,
+          seen,
+          createRuleDiagnostic(
+            "net/max-prefix-length",
+            `Invalid max prefix length ${length} for ${statement.channelType}`,
+            statement,
+          ),
+        );
+      }
+    }
+  }
+
+  return diagnostics;
+};
+
+export const netRules: BirdRule[] = [netPrefixRules, netMaxPrefixRule];
+
+export const collectNetRuleDiagnostics = (
+  context: Parameters<BirdRule>[0],
+): BirdDiagnostic[] => {
+  return netRules.flatMap((rule) => rule(context));
+};

package/src/rules/normalize.ts

@@ -0,0 +1,90 @@
+import type { BirdDiagnostic } from "@birdcc/core";
+import type { ParsedBirdDocument } from "@birdcc/parser";
+import { isRuleCode, type RuleCode, RULE_SEVERITY } from "./catalog.js";
+
+const CORE_CODE_MAP: Record<string, RuleCode> = {
+  "semantic/duplicate-definition": "sym/duplicate",
+  "semantic/undefined-reference": "sym/undefined",
+  "semantic/circular-template": "cfg/circular-template",
+  "type/mismatch": "type/mismatch",
+  "type/undefined-variable": "sym/variable-scope",
+  "type/unknown-expression": "cfg/incompatible-type",
+  "semantic/invalid-router-id": "cfg/incompatible-type",
+  "semantic/invalid-neighbor-address": "cfg/incompatible-type",
+  "semantic/invalid-cidr": "net/invalid-prefix-length",
+  "semantic/missing-include": "sym/undefined",
+};
+
+const PARSER_TO_CFG_SYNTAX = new Set([
+  "syntax/missing-semicolon",
+  "syntax/unbalanced-brace",
+  "parser/syntax-error",
+  "parser/missing-symbol",
+  "parser/runtime-error",
+]);
+
+const normalizeCode = (code: string): RuleCode => {
+  if (isRuleCode(code)) {
+    return code;
+  }
+
+  if (code in CORE_CODE_MAP) {
+    return CORE_CODE_MAP[code] as RuleCode;
+  }
+
+  if (PARSER_TO_CFG_SYNTAX.has(code)) {
+    return "cfg/syntax-error";
+  }
+
+  return "cfg/incompatible-type";
+};
+
+const normalizeMessage = (
+  code: string,
+  mappedCode: RuleCode,
+  message: string,
+): string => {
+  if (code === mappedCode) {
+    return message;
+  }
+
+  return `[${code}] ${message}`;
+};
+
+const toNormalizedDiagnostic = (
+  diagnostic: BirdDiagnostic,
+  fallbackUri?: string,
+): BirdDiagnostic => {
+  const mappedCode = normalizeCode(diagnostic.code);
+  return {
+    ...diagnostic,
+    code: mappedCode,
+    severity: RULE_SEVERITY[mappedCode],
+    message: normalizeMessage(diagnostic.code, mappedCode, diagnostic.message),
+    uri: diagnostic.uri ?? fallbackUri,
+  };
+};
+
+export const normalizeBaseDiagnostics = (
+  parsed: ParsedBirdDocument,
+  coreDiagnostics: BirdDiagnostic[],
+  options: { uri?: string } = {},
+): BirdDiagnostic[] => {
+  const parserDiagnostics: BirdDiagnostic[] = parsed.issues.map((issue) => ({
+    code: issue.code,
+    message: issue.message,
+    severity: "error",
+    source: "parser",
+    uri: options.uri,
+    range: {
+      line: issue.line,
+      column: issue.column,
+      endLine: issue.endLine,
+      endColumn: issue.endColumn,
+    },
+  }));
+
+  return [...parserDiagnostics, ...coreDiagnostics].map((diagnostic) =>
+    toNormalizedDiagnostic(diagnostic, options.uri),
+  );
+};

package/src/rules/ospf.ts

@@ -0,0 +1,221 @@
+import type { BirdDiagnostic } from "@birdcc/core";
+import type { SourceRange } from "@birdcc/parser";
+import {
+  createProtocolDiagnostic,
+  createRuleDiagnostic,
+  isProtocolType,
+  protocolDeclarations,
+  protocolOtherTextEntries,
+  type BirdRule,
+} from "./shared.js";
+
+interface OspfAreaSegment {
+  areaId: string;
+  text: string;
+  range: SourceRange;
+}
+
+const BACKBONE_AREA_IDS = new Set(["0", "0.0.0.0"]);
+
+const normalizeAreaId = (value: string): string => value.trim().toLowerCase();
+
+const isBackboneArea = (value: string): boolean =>
+  BACKBONE_AREA_IDS.has(normalizeAreaId(value));
+
+const parseAreaSegments = (
+  text: string,
+  range: SourceRange,
+): OspfAreaSegment[] => {
+  const segments: OspfAreaSegment[] = [];
+  const consumedRanges: Array<{ start: number; end: number }> = [];
+  const blockPattern = /\barea\s+([^\s{;]+)([^{};]*)\{/gi;
+  let matched = blockPattern.exec(text);
+
+  while (matched) {
+    const matchedText = matched[0] ?? "";
+    const areaId = normalizeAreaId(matched[1] ?? "");
+    const header = (matched[2] ?? "").trim();
+    const openBraceIndex = (matched.index ?? 0) + matchedText.length - 1;
+
+    let cursor = openBraceIndex + 1;
+    let depth = 1;
+    while (cursor < text.length && depth > 0) {
+      if (text[cursor] === "{") {
+        depth += 1;
+      } else if (text[cursor] === "}") {
+        depth -= 1;
+      }
+      cursor += 1;
+    }
+
+    const closeBraceIndex = depth === 0 ? cursor - 1 : text.length - 1;
+    const body = text.slice(openBraceIndex + 1, closeBraceIndex);
+    const scopeText = `${header} ${body}`.trim();
+    if (areaId.length > 0) {
+      segments.push({ areaId, text: scopeText, range });
+      consumedRanges.push({
+        start: matched.index ?? 0,
+        end: closeBraceIndex + 1,
+      });
+    }
+
+    blockPattern.lastIndex = Math.max(
+      closeBraceIndex + 1,
+      blockPattern.lastIndex,
+    );
+    matched = blockPattern.exec(text);
+  }
+
+  const inlinePattern = /\barea\s+([^\s{;]+)\s+([^{};\n]+)\s*;?/gi;
+  let inline = inlinePattern.exec(text);
+  while (inline) {
+    const start = inline.index ?? 0;
+    const insideBlock = consumedRanges.some(
+      (item) => start >= item.start && start < item.end,
+    );
+    if (!insideBlock) {
+      const areaId = normalizeAreaId(inline[1] ?? "");
+      const inlineText = (inline[2] ?? "").trim();
+      if (areaId.length > 0) {
+        segments.push({ areaId, text: inlineText, range });
+      }
+    }
+
+    inline = inlinePattern.exec(text);
+  }
+
+  return segments;
+};
+
+const collectAreas = (
+  entries: Array<{ text: string; range: SourceRange }>,
+): OspfAreaSegment[] => {
+  const areas: OspfAreaSegment[] = [];
+  for (const entry of entries) {
+    areas.push(...parseAreaSegments(entry.text, entry.range));
+  }
+  return areas;
+};
+
+const ospfMissingAreaRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    if (!isProtocolType(declaration, "ospf")) {
+      continue;
+    }
+
+    const areas = collectAreas(protocolOtherTextEntries(declaration));
+    if (areas.length > 0) {
+      continue;
+    }
+
+    diagnostics.push(
+      createProtocolDiagnostic(
+        "ospf/missing-area",
+        `OSPF protocol '${declaration.name}' has no configured areas`,
+        declaration,
+      ),
+    );
+  }
+
+  return diagnostics;
+};
+
+const ospfBackboneStubRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    if (!isProtocolType(declaration, "ospf")) {
+      continue;
+    }
+
+    const areas = collectAreas(protocolOtherTextEntries(declaration));
+    for (const area of areas) {
+      if (!isBackboneArea(area.areaId) || !/\bstub\b/i.test(area.text)) {
+        continue;
+      }
+
+      diagnostics.push(
+        createRuleDiagnostic(
+          "ospf/backbone-stub",
+          `OSPF protocol '${declaration.name}' configures backbone area as stub`,
+          area.range,
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+};
+
+const ospfVlinkInBackboneRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    if (!isProtocolType(declaration, "ospf")) {
+      continue;
+    }
+
+    const areas = collectAreas(protocolOtherTextEntries(declaration));
+    for (const area of areas) {
+      if (!isBackboneArea(area.areaId) || !/\bvlink\b/i.test(area.text)) {
+        continue;
+      }
+
+      diagnostics.push(
+        createRuleDiagnostic(
+          "ospf/vlink-in-backbone",
+          `OSPF protocol '${declaration.name}' cannot configure vlink in backbone area`,
+          area.range,
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+};
+
+const ospfAsbrStubAreaRule: BirdRule = ({ parsed }) => {
+  const diagnostics: BirdDiagnostic[] = [];
+
+  for (const declaration of protocolDeclarations(parsed)) {
+    if (!isProtocolType(declaration, "ospf")) {
+      continue;
+    }
+
+    const areas = collectAreas(protocolOtherTextEntries(declaration));
+    for (const area of areas) {
+      if (isBackboneArea(area.areaId)) {
+        continue;
+      }
+
+      if (!/\bstub\b/i.test(area.text) || !/\basbr\b/i.test(area.text)) {
+        continue;
+      }
+
+      diagnostics.push(
+        createRuleDiagnostic(
+          "ospf/asbr-stub-area",
+          `OSPF protocol '${declaration.name}' declares ASBR inside stub area ${area.areaId}`,
+          area.range,
+        ),
+      );
+    }
+  }
+
+  return diagnostics;
+};
+
+export const ospfRules: BirdRule[] = [
+  ospfMissingAreaRule,
+  ospfBackboneStubRule,
+  ospfVlinkInBackboneRule,
+  ospfAsbrStubAreaRule,
+];
+
+export const collectOspfRuleDiagnostics = (
+  context: Parameters<BirdRule>[0],
+): BirdDiagnostic[] => {
+  return ospfRules.flatMap((rule) => rule(context));
+};