homeio

1import "server-only";
2
3import { readFile } from "node:fs/promises";
4import os from "node:os";
5
6// Everything the metrics snapshot needs about the network is already in /proc
7// and /sys. systeminformation's networkInterfaces() and networkStats() gather
8// it by spawning ~120 commands (cat, grep, nmcli, ip) on every snapshot.
9
10export type NetworkCounters = { rxBytes: number; txBytes: number };
11export type NetworkRate = { rxBytesPerSec: number; txBytesPerSec: number };
12export type InterfaceAddresses = { ipv4: string | null; ipv6: string | null };
13
14// Interface names are at most 15 characters and never contain a slash; this
15// keeps a name from walking out of /sys/class/net.
16const INTERFACE_NAME = /^[\w.:@-]{1,15}$/;
17
18/**
19 * The interface carrying the IPv4 default route, lowest metric first, from
20 * /proc/net/route. Columns: Iface Destination Gateway Flags RefCnt Use Metric Mask ...
21 */
22export function parseDefaultRouteInterface(text: string): string | null {
23  let best: { iface: string; metric: number } | null = null;
24  for (const line of text.split("\n").slice(1)) {
25    const fields = line.trim().split(/\s+/);
26    if (fields.length < 8) continue;
27    const [iface, destination, , , , , metricField, mask] = fields;
28    if (destination !== "00000000" || mask !== "00000000") continue;
29    const metric = Number(metricField);
30    if (!best || metric < best.metric) best = { iface, metric };
31  }
32  return best?.iface ?? null;
33}
34
35export async function readDefaultRouteInterface(): Promise<string | null> {
36  try {
37    return parseDefaultRouteInterface(await readFile("/proc/net/route", "utf8"));
38  } catch {
39    // Not Linux: there is no /proc/net/route.
40    return null;
41  }
42}
43
44/** Bytes received and sent by one interface, from /sys/class/net/<iface>/statistics. */
45export async function readInterfaceCounters(iface: string): Promise<NetworkCounters | null> {
46  if (!INTERFACE_NAME.test(iface)) return null;
47  try {
48    const statistics = `/sys/class/net/${iface}/statistics`;
49    const [rx, tx] = await Promise.all([
50      readFile(`${statistics}/rx_bytes`, "utf8"),
51      readFile(`${statistics}/tx_bytes`, "utf8"),
52    ]);
53    const rxBytes = Number(rx);
54    const txBytes = Number(tx);
55    if (!Number.isFinite(rxBytes) || !Number.isFinite(txBytes)) return null;
56    return { rxBytes, txBytes };
57  } catch {
58    // The interface went away, or this is not Linux.
59    return null;
60  }
61}
62
63/**
64 * Turns successive readings of an interface into rates. Switching interface
65 * (Wi-Fi to Ethernet, say) starts a new baseline instead of reporting a
66 * nonsense difference between two unrelated counters.
67 */
68export function createNetworkRateTracker(maxGapMs = 60_000) {
69  let previous: { iface: string; at: number; counters: NetworkCounters } | null = null;
70
71  return function update(iface: string, counters: NetworkCounters, at: number): NetworkRate | null {
72    const before = previous;
73    previous = { iface, at, counters };
74    if (!before || before.iface !== iface || at <= before.at || at - before.at > maxGapMs) {
75      return null;
76    }
77
78    const seconds = (at - before.at) / 1000;
79    const rx = counters.rxBytes - before.counters.rxBytes;
80    const tx = counters.txBytes - before.counters.txBytes;
81    // A counter that went backwards (interface re-created) gives no rate this round.
82    if (rx < 0 || tx < 0) return null;
83
84    return { rxBytesPerSec: rx / seconds, txBytesPerSec: tx / seconds };
85  };
86}
87
88/** The interface's IPv4 address, and its IPv6 address preferring a global one over link-local. */
89export function readInterfaceAddresses(
90  iface: string,
91  interfaces: NodeJS.Dict<os.NetworkInterfaceInfo[]> = os.networkInterfaces(),
92): InterfaceAddresses {
93  const addresses = (interfaces[iface] ?? []).filter((address) => !address.internal);
94  const ipv4 = addresses.find((address) => address.family === "IPv4")?.address ?? null;
95  const ipv6Addresses = addresses.filter((address) => address.family === "IPv6");
96  const ipv6 =
97    (ipv6Addresses.find((address) => !address.address.startsWith("fe80:")) ?? ipv6Addresses[0])
98      ?.address ?? null;
99  return { ipv4, ipv6 };
100}
101