gnutella 1.0.0

package/src/protocol/share_library.ts

@@ -0,0 +1,246 @@
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+import { ensureDir, ts, unique, walkFilesIter } from "../shared";
+import type { ShareFile } from "../types";
+import type { GnutellaServent } from "./node";
+import { sha1File, sha1ToUrn, tokenizeKeywords } from "./qrp";
+import {
+  loadShareIndex,
+  writeShareIndex,
+  type ShareIndexEntry,
+} from "./share_index";
+
+function shareKeywords(abs: string, rel: string): string[] {
+  return unique([
+    ...tokenizeKeywords(path.basename(abs)),
+    ...tokenizeKeywords(rel),
+    ...tokenizeKeywords(path.parse(abs).name),
+  ]);
+}
+
+function cachedShareHash(
+  entry: ShareIndexEntry | undefined,
+  size: number,
+  mtimeMs: number,
+):
+  | {
+      sha1: Buffer;
+      sha1Urn: string;
+      sha1Hex: string;
+    }
+  | undefined {
+  if (!entry || entry.size !== size || entry.mtimeMs !== mtimeMs)
+    return undefined;
+  if (!entry.sha1Hex || !entry.sha1Urn) return undefined;
+  return {
+    sha1: Buffer.from(entry.sha1Hex, "hex"),
+    sha1Urn: entry.sha1Urn,
+    sha1Hex: entry.sha1Hex,
+  };
+}
+
+function rebuildShareState(
+  node: GnutellaServent,
+  shares: ShareFile[],
+): void {
+  node.shares = shares;
+  node.sharesByIndex = new Map(
+    shares.map((share) => [share.index, share]),
+  );
+  node.sharesByUrn = new Map(
+    shares.flatMap((share) =>
+      share.sha1Urn ? [[share.sha1Urn.toLowerCase(), share]] : [],
+    ),
+  );
+  node.qrpTable.rebuildFromShares(shares);
+}
+
+export async function persistShareIndex(
+  node: GnutellaServent,
+): Promise<void> {
+  await writeShareIndex(node.config().dataDir, node.shareIndexEntries);
+}
+
+function persistShareIndexLater(node: GnutellaServent): void {
+  void persistShareIndex(node).catch((e) =>
+    node.emitMaintenanceError("SAVE", e),
+  );
+}
+
+async function loadShareIndexOnce(node: GnutellaServent): Promise<void> {
+  if (node.shareIndexLoaded) return;
+  node.shareIndexEntries = await loadShareIndex(node.config().dataDir);
+  node.shareIndexLoaded = true;
+}
+
+function staleShareHashPass(
+  node: GnutellaServent,
+  generation: number,
+): boolean {
+  return node.stopped || generation !== node.shareRefreshGeneration;
+}
+
+function shareMatchesIndexEntry(
+  share: Pick<ShareFile, "size" | "mtimeMs">,
+  entry: ShareIndexEntry | undefined,
+): entry is ShareIndexEntry {
+  return (
+    !!entry && entry.size === share.size && entry.mtimeMs === share.mtimeMs
+  );
+}
+
+async function fileStillMatchesShare(
+  share: Pick<ShareFile, "abs" | "size" | "mtimeMs">,
+): Promise<boolean> {
+  const st = await fsp.stat(share.abs);
+  return (
+    st.isFile() && st.size === share.size && st.mtimeMs === share.mtimeMs
+  );
+}
+
+function currentIndexedShare(
+  node: GnutellaServent,
+  pendingShare: ShareFile,
+):
+  | {
+      share: ShareFile;
+      entry: ShareIndexEntry;
+    }
+  | undefined {
+  const share = node.sharesByIndex.get(pendingShare.index);
+  const entry = node.shareIndexEntries.get(pendingShare.rel);
+  if (!share || share.rel !== pendingShare.rel) return undefined;
+  if (!shareMatchesIndexEntry(pendingShare, entry)) return undefined;
+  return { share, entry };
+}
+
+function applyShareHash(
+  node: GnutellaServent,
+  share: ShareFile,
+  entry: ShareIndexEntry,
+  sha1: Buffer,
+): void {
+  const sha1Urn = sha1ToUrn(sha1);
+  share.sha1 = sha1;
+  share.sha1Urn = sha1Urn;
+  entry.sha1Hex = sha1.toString("hex");
+  entry.sha1Urn = sha1Urn;
+  node.sharesByUrn.set(sha1Urn.toLowerCase(), share);
+}
+
+async function hashPendingShare(
+  node: GnutellaServent,
+  pendingShare: ShareFile,
+  generation: number,
+): Promise<"continue" | "stop"> {
+  if (staleShareHashPass(node, generation)) return "stop";
+  const entry = node.shareIndexEntries.get(pendingShare.rel);
+  if (!shareMatchesIndexEntry(pendingShare, entry)) return "continue";
+  try {
+    if (!(await fileStillMatchesShare(pendingShare))) return "continue";
+    const sha1 = await sha1File(pendingShare.abs);
+    if (staleShareHashPass(node, generation)) return "stop";
+    const current = currentIndexedShare(node, pendingShare);
+    if (!current) return "continue";
+    applyShareHash(node, current.share, current.entry, sha1);
+  } catch {
+    // Files can be deleted or rewritten while hashing. The next rescan fixes
+    // metadata and retries the hash when appropriate.
+  }
+  return "continue";
+}
+
+async function hashPendingShares(
+  node: GnutellaServent,
+  pendingShares: ShareFile[],
+  generation: number,
+): Promise<void> {
+  for (const pendingShare of pendingShares) {
+    if (
+      (await hashPendingShare(node, pendingShare, generation)) === "stop"
+    )
+      return;
+  }
+  if (pendingShares.length === 0 || staleShareHashPass(node, generation)) {
+    return;
+  }
+  try {
+    await persistShareIndex(node);
+  } catch (e) {
+    node.emitMaintenanceError("SAVE", e);
+  }
+}
+
+export async function refreshShares(node: GnutellaServent): Promise<void> {
+  await loadShareIndexOnce(node);
+  await ensureDir(node.config().downloadsDir);
+  const downloadsDir = node.config().downloadsDir;
+  const shares: ShareFile[] = [];
+  const nextShareIndexEntries = new Map<string, ShareIndexEntry>();
+  const pendingHashes: ShareFile[] = [];
+  const generation = node.shareRefreshGeneration + 1;
+  node.shareRefreshGeneration = generation;
+  let idx = 1;
+  for await (const abs of walkFilesIter(downloadsDir)) {
+    const st = await fsp.stat(abs);
+    const rel = path.relative(downloadsDir, abs).replace(/\\/g, "/");
+    const share: ShareFile = {
+      index: idx++,
+      name: path.basename(abs),
+      rel,
+      abs,
+      size: st.size,
+      mtimeMs: st.mtimeMs,
+      keywords: shareKeywords(abs, rel),
+    };
+    const entry: ShareIndexEntry = {
+      rel,
+      size: st.size,
+      mtimeMs: st.mtimeMs,
+    };
+    const cached = cachedShareHash(
+      node.shareIndexEntries.get(rel),
+      share.size,
+      share.mtimeMs,
+    );
+    if (cached) {
+      share.sha1 = cached.sha1;
+      share.sha1Urn = cached.sha1Urn;
+      entry.sha1Hex = cached.sha1Hex;
+      entry.sha1Urn = cached.sha1Urn;
+    } else {
+      pendingHashes.push(share);
+    }
+    shares.push(share);
+    nextShareIndexEntries.set(rel, entry);
+  }
+  node.shareIndexEntries = nextShareIndexEntries;
+  rebuildShareState(node, shares);
+  node.emitEvent({
+    type: "SHARES_REFRESHED",
+    at: ts(),
+    count: node.shares.length,
+    totalKBytes: node.totalSharedKBytes(),
+  });
+  if (node.config().enableQrp) {
+    for (const peer of node.peers.values()) {
+      void node.sendQrpTable(peer).catch(() => void 0);
+    }
+  }
+  persistShareIndexLater(node);
+  if (pendingHashes.length === 0) {
+    node.shareHashTask = null;
+    return;
+  }
+  const task = hashPendingShares(node, pendingHashes, generation)
+    .catch((e) => node.emitMaintenanceError("SHARE_RESCAN", e))
+    .finally(() => {
+      if (node.shareHashTask === task) node.shareHashTask = null;
+    });
+  node.shareHashTask = task;
+}
+
+export function totalSharedKBytes(node: GnutellaServent): number {
+  return Math.ceil(node.shares.reduce((a, x) => a + x.size, 0) / 1024);
+}

package/src/protocol.ts

@@ -0,0 +1,36 @@
+export { GnutellaServent } from "./protocol/node";
+export {
+  buildGetRequest,
+  buildHeader,
+  buildUriResRequest,
+  encodeBye,
+  encodePong,
+  encodePush,
+  encodeQuery,
+  parseBye,
+  parseHeader,
+  parsePong,
+  parsePush,
+  parseQuery,
+  parseQueryHit,
+  parseRouteTableUpdate,
+} from "./protocol/codec";
+export { initialRemoteQrpState, QrpTable } from "./protocol/qrp";
+export { buildMagnetUri, parseMagnetUri } from "./protocol/magnet";
+export { defaultDoc, loadDoc, writeDoc } from "./protocol/peer_state";
+export type { Peer } from "./protocol/node_types";
+export type {
+  BlockIpResult,
+  ConfigDoc,
+  ConnectPeerResult,
+  DownloadRecord,
+  GnutellaEvent,
+  GnutellaEventListener,
+  GnutellaServentOptions,
+  NodeStatus,
+  PeerInfo,
+  RuntimeConfig,
+  SearchHit,
+  ShareFile,
+  UnblockIpResult,
+} from "./types";

package/src/shared.ts

@@ -0,0 +1,236 @@
+import net from "node:net";
+import fsp from "node:fs/promises";
+import path from "node:path";
+
+export function ts(): string {
+  return new Date().toISOString();
+}
+
+export function errMsg(e: unknown): string {
+  return e instanceof Error ? e.message : String(e);
+}
+
+export function toBuffer(chunk: string | Buffer): Buffer {
+  return typeof chunk === "string" ? Buffer.from(chunk, "latin1") : chunk;
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function unique<T>(xs: T[]): T[] {
+  return [...new Set(xs)];
+}
+
+export function normalizePeer(host: string, port: number): string {
+  return `${normalizeIpv4(host) || host.trim()}:${port}`;
+}
+
+export function parsePeer(
+  s: string,
+): { host: string; port: number } | null {
+  const t = String(s || "").trim();
+  const m = /^(\d+\.\d+\.\d+\.\d+):(\d+)$/.exec(t);
+  if (!m) return null;
+  const host = normalizeIpv4(m[1]);
+  if (!host) return null;
+  const port = Number(m[2]);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) return null;
+  return { host, port };
+}
+
+export function normalizeIpv4(
+  host: string | undefined,
+): string | undefined {
+  if (!host) return undefined;
+  const trimmed = host.trim();
+  if (net.isIPv4(trimmed)) return trimmed;
+  const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/i.exec(trimmed);
+  if (mapped && net.isIPv4(mapped[1])) return mapped[1];
+  return undefined;
+}
+
+function ipv4Octets(host: string): number[] | null {
+  const normalized = normalizeIpv4(host);
+  if (!normalized) return null;
+  return normalized.split(".").map((part) => Number(part));
+}
+
+type Ipv4Matcher = (parts: readonly number[]) => boolean;
+
+const NON_ROUTABLE_IPV4_MATCHERS: Ipv4Matcher[] = [
+  ([a]) => a === 0 || a >= 224,
+  ([a]) => a === 10 || a === 127,
+  ([a, b]) => a === 100 && b >= 64 && b <= 127,
+  ([a, b]) => a === 169 && b === 254,
+  ([a, b]) => a === 172 && b >= 16 && b <= 31,
+  ([a, b]) => a === 192 && b === 168,
+  ([a, b, c]) => a === 192 && b === 0 && c === 0,
+  ([a, b, c]) => a === 192 && b === 0 && c === 2,
+  ([a, b]) => a === 198 && (b === 18 || b === 19),
+  ([a, b, c]) => a === 198 && b === 51 && c === 100,
+  ([a, b, c]) => a === 203 && b === 0 && c === 113,
+];
+
+export function isUnspecifiedIpv4(host: string): boolean {
+  return normalizeIpv4(host) === "0.0.0.0";
+}
+
+export function isRoutableIpv4(host: string): boolean {
+  const parts = ipv4Octets(host);
+  return (
+    !!parts && !NON_ROUTABLE_IPV4_MATCHERS.some((match) => match(parts))
+  );
+}
+
+export function ipv4Subnet16(host: string): string | undefined {
+  const parts = ipv4Octets(host);
+  if (!parts) return undefined;
+  return `${parts[0]}.${parts[1]}`;
+}
+
+export async function fileExists(p: string): Promise<boolean> {
+  try {
+    await fsp.access(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function ensureDir(p: string): Promise<void> {
+  try {
+    await fsp.mkdir(p, { recursive: true });
+  } catch (e) {
+    // Bun's compiled Windows runtime can report EEXIST for an already-existing
+    // directory on first-run config creation.
+    if ((e as NodeJS.ErrnoException).code !== "EEXIST") throw e;
+    const st = await fsp.stat(p).catch(() => null);
+    if (!st?.isDirectory()) throw e;
+  }
+}
+
+async function* walkFilesRecursive(
+  dir: string,
+): AsyncGenerator<string, void, void> {
+  const ents = await fsp.readdir(dir, { withFileTypes: true });
+  ents.sort((a, b) => a.name.localeCompare(b.name));
+  for (const ent of ents) {
+    const abs = path.join(dir, ent.name);
+    if (ent.isDirectory()) yield* walkFilesRecursive(abs);
+    else if (ent.isFile()) yield abs;
+  }
+}
+
+export async function* walkFilesIter(
+  root: string,
+): AsyncGenerator<string, void, void> {
+  if (!(await fileExists(root))) return;
+  yield* walkFilesRecursive(root);
+}
+
+export function ipToBytesBE(ip: string): Buffer {
+  const parts = ip.split(".").map((x) => Number(x));
+  if (
+    parts.length !== 4 ||
+    parts.some((n) => !Number.isInteger(n) || n < 0 || n > 255)
+  ) {
+    throw new Error(`invalid IPv4 address: ${ip}`);
+  }
+  return Buffer.from(parts);
+}
+
+export function ipToBytesLE(ip: string): Buffer {
+  return Buffer.from([...ipToBytesBE(ip)].reverse());
+}
+
+export function bytesToIpBE(buf: Buffer): string {
+  if (buf.length !== 4)
+    throw new Error(`expected 4 bytes for IPv4, got ${buf.length}`);
+  return `${buf[0]}.${buf[1]}.${buf[2]}.${buf[3]}`;
+}
+
+export function bytesToIpLE(buf: Buffer): string {
+  if (buf.length !== 4)
+    throw new Error(`expected 4 bytes for IPv4, got ${buf.length}`);
+  return `${buf[3]}.${buf[2]}.${buf[1]}.${buf[0]}`;
+}
+
+export function safeFileName(name: string): string {
+  return name.replace(/[\\/\0]/g, "_").replace(/^\.+$/, "_");
+}
+
+type SplitArgsState = {
+  out: string[];
+  cur: string;
+  quote: string;
+  esc: boolean;
+  pending: boolean;
+};
+
+function flushSplitArg(state: SplitArgsState): void {
+  if (!state.pending) return;
+  state.out.push(state.cur);
+  state.cur = "";
+  state.pending = false;
+}
+
+function consumeEscapedArgChar(
+  state: SplitArgsState,
+  ch: string,
+): boolean {
+  if (!state.esc) return false;
+  state.cur += ch;
+  state.esc = false;
+  state.pending = true;
+  return true;
+}
+
+function consumeEscapeStart(state: SplitArgsState, ch: string): boolean {
+  if (ch !== "\\") return false;
+  state.esc = true;
+  state.pending = true;
+  return true;
+}
+
+function consumeQuotedArgChar(state: SplitArgsState, ch: string): boolean {
+  if (!state.quote) return false;
+  if (ch === state.quote) state.quote = "";
+  else state.cur += ch;
+  return true;
+}
+
+function consumeQuoteStart(state: SplitArgsState, ch: string): boolean {
+  if (ch !== '"' && ch !== "'") return false;
+  state.quote = ch;
+  state.pending = true;
+  return true;
+}
+
+function consumeArgWhitespace(state: SplitArgsState, ch: string): boolean {
+  if (!/\s/.test(ch)) return false;
+  flushSplitArg(state);
+  return true;
+}
+
+export function splitArgs(line: string): string[] {
+  const state: SplitArgsState = {
+    out: [],
+    cur: "",
+    quote: "",
+    esc: false,
+    pending: false,
+  };
+  for (const ch of line) {
+    if (consumeEscapedArgChar(state, ch)) continue;
+    if (consumeEscapeStart(state, ch)) continue;
+    if (consumeQuotedArgChar(state, ch)) continue;
+    if (consumeQuoteStart(state, ch)) continue;
+    if (consumeArgWhitespace(state, ch)) continue;
+    state.cur += ch;
+    state.pending = true;
+  }
+  if (state.esc) state.cur += "\\";
+  flushSplitArg(state);
+  return state.out;
+}