gnutella 1.0.0

package/src/cli_shared.ts

@@ -0,0 +1,359 @@
+import { errMsg } from "./shared";
+import { RESULT_NAME_WIDTH_MAX } from "./const";
+import type { CliNode, ParsedCli } from "./types";
+import { buildMagnetUri } from "./protocol/magnet";
+
+const SIZE_FORMAT = new Intl.NumberFormat("en-US", {
+  maximumFractionDigits: 1,
+});
+const SIZE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB"];
+const RESULT_COUNT_DISPLAY_MAX = 999;
+const PEER_TABLE_WIDTH_MAX = 80;
+
+type ResultInfo = ReturnType<CliNode["getResults"]>[number];
+
+function formatSize(bytes: number): string {
+  const safeBytes =
+    Number.isFinite(bytes) && bytes > 0 ? Math.floor(bytes) : 0;
+  let value = safeBytes;
+  let unitIndex = 0;
+  while (value >= 1024 && unitIndex < SIZE_UNITS.length - 1) {
+    value /= 1024;
+    unitIndex++;
+  }
+  return `${SIZE_FORMAT.format(value)}${SIZE_UNITS[unitIndex]}`;
+}
+
+export function displayResultCount(count: number): number {
+  const safeCount =
+    Number.isFinite(count) && count > 0 ? Math.floor(count) : 0;
+  return Math.min(RESULT_COUNT_DISPLAY_MAX, safeCount);
+}
+
+function sanitizeTableCell(
+  value: string | undefined,
+  fallback = "",
+): string {
+  const safe = (value || "").replace(/[\r\n\t]/g, " ").trim();
+  return safe || fallback;
+}
+
+function fitTableCell(value: string, width: number): string {
+  if (value.length <= width) return value.padEnd(width, " ");
+  if (width <= 2) return value.slice(0, width);
+  const kept = width - 2;
+  const head = Math.floor(kept / 2);
+  const tail = kept - head;
+  return `${value.slice(0, head)}..${value.slice(-tail)}`;
+}
+
+function peerFlags(peer: ReturnType<CliNode["getPeers"]>[number]): string {
+  return `${peer.outbound ? "O" : "I"}${peer.compression ? "Z" : "-"}${peer.tls ? "L" : "-"}${peer.role === "ultrapeer" ? "U" : "-"}`;
+}
+
+function valueOrDash(value: string | number | undefined): string {
+  return value == null || value === "" ? "-" : String(value);
+}
+
+function boolOrDash(value: boolean | undefined): string {
+  return value == null ? "-" : String(value);
+}
+
+function speedOrDash(speedKBps: number | undefined): string {
+  return speedKBps == null ? "-" : `${speedKBps}KB/s`;
+}
+
+function appendValueList(
+  lines: string[],
+  label: string,
+  values: string[],
+): void {
+  if (!values.length) {
+    lines.push(`${label}: -`);
+    return;
+  }
+  lines.push(`${label}:`);
+  for (const value of values) lines.push(`  ${value}`);
+}
+
+function otherUrns(result: ResultInfo): string[] {
+  return (result.urns || []).filter((urn) => urn !== result.sha1Urn);
+}
+
+function formatResultInfoLines(result: ResultInfo): string[] {
+  const lines = [
+    `result: #${result.resultNo}`,
+    `file: ${JSON.stringify(result.fileName)}`,
+    `size: ${formatSize(result.fileSize)} (${result.fileSize}B)`,
+    `remote: ${result.remoteHost}:${result.remotePort}`,
+    `speed: ${speedOrDash(result.speedKBps)}`,
+    `file index: ${valueOrDash(result.fileIndex)}`,
+    `servent id: ${result.serventIdHex}`,
+    `query id: ${valueOrDash(result.queryIdHex)}`,
+    `query hops: ${valueOrDash(result.queryHops)}`,
+    `via peer: ${valueOrDash(result.viaPeerKey)}`,
+    `sha1 urn: ${valueOrDash(result.sha1Urn)}`,
+  ];
+  appendValueList(lines, "other urns", otherUrns(result));
+  appendValueList(lines, "metadata", result.metadata || []);
+  lines.push(`vendor: ${valueOrDash(result.vendorCode)}`);
+  lines.push(`needs push: ${boolOrDash(result.needsPush)}`);
+  lines.push(`busy: ${boolOrDash(result.busy)}`);
+  return lines;
+}
+
+function resultMagnetUri(result: ResultInfo): string {
+  return buildMagnetUri({
+    fileName: result.fileName,
+    fileSize: result.fileSize,
+    urns: result.urns,
+    sha1Urn: result.sha1Urn,
+  });
+}
+
+function findResult(node: CliNode, resultNo: number): ResultInfo {
+  const result = node
+    .getResults()
+    .find((candidate) => candidate.resultNo === resultNo);
+  if (!result) throw new Error(`no such result ${resultNo}`);
+  return result;
+}
+
+export function printStatus(
+  node: CliNode,
+  log: (msg: string) => void,
+): void {
+  const status = node.getStatus();
+  log(
+    `peers=${status.peers} shares=${status.shares} results=${displayResultCount(status.results)} knownPeers=${status.knownPeers}`,
+  );
+}
+
+export function printPeers(
+  node: CliNode,
+  log: (msg: string) => void,
+): void {
+  const peers = node.getPeers();
+  if (!peers.length) {
+    log("no peers");
+    return;
+  }
+  const rows = peers.map((peer) => ({
+    key: sanitizeTableCell(peer.key, "?"),
+    flags: peerFlags(peer),
+    remoteLabel: sanitizeTableCell(peer.remoteLabel, "?"),
+    userAgent: sanitizeTableCell(peer.userAgent, "-"),
+  }));
+
+  const key = Math.max("Id".length, ...rows.map((row) => row.key.length));
+  const flags = Math.max(
+    "Flags".length,
+    ...rows.map((row) => row.flags.length),
+  );
+  const desiredRemoteLabel = Math.max(
+    "Peer".length,
+    ...rows.map((row) => row.remoteLabel.length),
+  );
+  const desiredUserAgent = Math.max(
+    "Agent".length,
+    ...rows.map((row) => row.userAgent.length),
+  );
+  const available = Math.max(
+    "Peer".length + "Agent".length,
+    PEER_TABLE_WIDTH_MAX - key - flags - 6,
+  );
+
+  let remoteLabel = Math.min(
+    desiredRemoteLabel,
+    Math.floor(available / 2),
+  );
+  let userAgent = Math.min(desiredUserAgent, available - remoteLabel);
+  let remaining = available - remoteLabel - userAgent;
+  if (remaining > 0 && desiredUserAgent > userAgent) {
+    const extra = Math.min(remaining, desiredUserAgent - userAgent);
+    userAgent += extra;
+    remaining -= extra;
+  }
+  if (remaining > 0 && desiredRemoteLabel > remoteLabel) {
+    remoteLabel += Math.min(remaining, desiredRemoteLabel - remoteLabel);
+  }
+
+  const widths = {
+    key,
+    flags,
+    remoteLabel,
+    userAgent,
+  };
+
+  const line = (
+    key: string,
+    flags: string,
+    remoteLabel: string,
+    userAgent: string,
+  ) =>
+    `${key.padEnd(widths.key, " ")}  ${flags.padEnd(widths.flags, " ")}  ${fitTableCell(remoteLabel, widths.remoteLabel)}  ${fitTableCell(userAgent, widths.userAgent)}`.trimEnd();
+
+  log(
+    [
+      line("Id", "Flags", "Peer", "Agent"),
+      line(
+        "-".repeat(widths.key),
+        "-".repeat(widths.flags),
+        "-".repeat(widths.remoteLabel),
+        "-".repeat(widths.userAgent),
+      ),
+      ...rows.map((row) =>
+        line(row.key, row.flags, row.remoteLabel, row.userAgent),
+      ),
+    ].join("\n"),
+  );
+}
+
+export function printShares(
+  node: CliNode,
+  log: (msg: string) => void,
+): void {
+  const shares = node.getShares();
+  if (!shares.length) {
+    log("no shared files");
+    return;
+  }
+  for (const f of shares)
+    log(`#${f.index} ${f.size}B ${JSON.stringify(f.rel)}`);
+}
+
+export function printResults(
+  node: CliNode,
+  log: (msg: string) => void,
+): void {
+  const results = node.getResults();
+  if (!results.length) {
+    log("no results");
+    return;
+  }
+  const rows = [...results]
+    .sort(
+      (a, b) =>
+        a.resultNo - b.resultNo ||
+        a.fileName.localeCompare(b.fileName) ||
+        a.fileSize - b.fileSize ||
+        a.remoteHost.localeCompare(b.remoteHost) ||
+        a.remotePort - b.remotePort,
+    )
+    .map((result) => ({
+      resultNo: String(result.resultNo),
+      fileName: sanitizeTableCell(result.fileName),
+      fileSize: formatSize(result.fileSize),
+      remote: sanitizeTableCell(
+        `${result.remoteHost}:${result.remotePort}`,
+      ),
+    }));
+
+  const widths = {
+    resultNo: Math.max(
+      "No".length,
+      ...rows.map((row) => row.resultNo.length),
+    ),
+    fileName: RESULT_NAME_WIDTH_MAX,
+    fileSize: Math.max(
+      "Size".length,
+      ...rows.map((row) => row.fileSize.length),
+    ),
+    remote: Math.max("IP".length, ...rows.map((row) => row.remote.length)),
+  };
+
+  const line = (
+    resultNo: string,
+    fileName: string,
+    fileSize: string,
+    remote: string,
+  ) =>
+    `${resultNo.padStart(widths.resultNo, " ")}  ${fileName}  ${fileSize.padStart(widths.fileSize, " ")}  ${remote}`.trimEnd();
+
+  const fitName = (fileName: string): string => {
+    if (fileName.length <= widths.fileName - 2)
+      return fileName.padEnd(widths.fileName, " ");
+    if (widths.fileName <= 2) return fileName.slice(0, widths.fileName);
+    const kept = widths.fileName - 2;
+    const head = Math.floor(kept / 2);
+    const tail = kept - head;
+    return `${fileName.slice(0, head)}..${fileName.slice(-tail)}`;
+  };
+
+  log(
+    [
+      line("No", "File".padEnd(widths.fileName, " "), "Size", "IP"),
+      line(
+        "-".repeat(widths.resultNo),
+        "-".repeat(widths.fileName),
+        "-".repeat(widths.fileSize),
+        "-".repeat(widths.remote),
+      ),
+      ...rows.map((row) =>
+        line(
+          row.resultNo,
+          fitName(row.fileName),
+          row.fileSize,
+          row.remote,
+        ),
+      ),
+    ].join("\n"),
+  );
+}
+
+export function printResultInfo(
+  node: CliNode,
+  resultNo: number,
+  log: (msg: string) => void,
+): void {
+  const result = findResult(node, resultNo);
+  log(formatResultInfoLines(result).join("\n"));
+}
+
+export function printResultMagnet(
+  node: CliNode,
+  resultNo: number,
+  log: (msg: string) => void,
+): void {
+  log(resultMagnetUri(findResult(node, resultNo)));
+}
+
+export function parseCli(
+  argv: string[],
+  defaultConfig: string,
+): ParsedCli {
+  let config = defaultConfig;
+  const exec: string[] = [];
+  let command = "run";
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a === "--config") config = argv[++i] || config;
+    else if (a === "--exec") exec.push(argv[++i] || "");
+    else if (!a.startsWith("-") && command === "run") command = a;
+  }
+  return { config, exec, command };
+}
+
+export function runExecCommands(
+  execCmds: string[],
+  log: (msg: string) => void,
+  sleep: (ms: number) => Promise<void>,
+  runCommand: (line: string) => Promise<boolean>,
+  formatError: (e: unknown) => string,
+): void {
+  if (!execCmds.length) return;
+  void (async () => {
+    await sleep(500);
+    for (const cmd of execCmds) {
+      log(`exec> ${cmd}`);
+      try {
+        const keep = await runCommand(cmd);
+        if (!keep) return;
+      } catch (e) {
+        log(`command failed: ${formatError(e)}`);
+      }
+    }
+  })();
+}
+
+export { errMsg };

package/src/const.ts

@@ -0,0 +1,138 @@
+export const HEADER_LEN = 23;
+export const LOCAL_ROUTE = "__local__";
+export const DEFAULT_QRP_TABLE_SIZE = 65536;
+export const DEFAULT_QRP_INFINITY = 7;
+export const DEFAULT_QRP_ENTRY_BITS = 1;
+export const DEFAULT_LISTEN_HOST = "0.0.0.0";
+export const DEFAULT_LISTEN_PORT_MIN = 20000;
+export const DEFAULT_LISTEN_PORT_MAX = 29999;
+export const DEFAULT_USER_AGENT = "GnutellaBun/1.0.0";
+export const DEFAULT_VENDOR_CODE = "GBUN";
+export const DATA_DOWNLOADS_DIRNAME = "downloads";
+export const MAX_ULTRAPEER_CONNECTIONS = 64;
+export const MAX_LEAF_CONNECTIONS = 64;
+export const CONNECT_TIMEOUT_MS = 5000;
+export const PING_INTERVAL_SEC = 60;
+export const RECONNECT_INTERVAL_SEC = 15;
+export const RESCAN_SHARES_SEC = 30;
+export const ROUTE_TTL_SEC = 600;
+export const SEEN_TTL_SEC = 600;
+export const MAX_PAYLOAD_BYTES = 1024 * 1024;
+export const MAX_TTL = 7;
+export const DEFAULT_PING_TTL = 1;
+export const DEFAULT_QUERY_TTL = 4;
+export const ADVERTISED_SPEED_KBPS = 512;
+export const DOWNLOAD_TIMEOUT_MS = 15000;
+export const PUSH_WAIT_MS = 15000;
+export const MAX_RESULTS_PER_QUERY = 50;
+export const MAX_TRACKED_PEERS = 40;
+export const PEER_SEEN_THRESHOLD_SEC = 60;
+export const MAX_PEER_AGE_SEC = 7 * 24 * 60 * 60;
+export const GWEBCACHE_REPORT_DELAY_SEC = 5 * 60;
+export const DEFAULT_QUERY_ROUTING_VERSION = "0.2";
+export const ENABLE_COMPRESSION = true;
+export const ENABLE_TLS = true;
+export const ENABLE_QRP = true;
+export const ENABLE_BYE = true;
+export const ENABLE_PONG_CACHING = true;
+export const ENABLE_GGEP = true;
+export const SERVE_URI_RES = true;
+export const QRP_COMPRESSOR_NONE = 0;
+export const QRP_COMPRESSOR_DEFLATE = 1;
+export const MAX_XTRY = 10;
+export const BYE_DEFAULT_CODE = 200;
+export const BOOTSTRAP_CONNECT_CONCURRENCY = 8;
+export const BOOTSTRAP_CONNECT_TIMEOUT_DIVISOR = 2;
+
+export const TYPE = {
+  PING: 0x00,
+  PONG: 0x01,
+  BYE: 0x02,
+  ROUTE_TABLE_UPDATE: 0x30,
+  PUSH: 0x40,
+  QUERY: 0x80,
+  QUERY_HIT: 0x81,
+} as const;
+
+export const TYPE_NAME: Record<number, string> = {
+  [TYPE.PING]: "PING",
+  [TYPE.PONG]: "PONG",
+  [TYPE.BYE]: "BYE",
+  [TYPE.ROUTE_TABLE_UPDATE]: "ROUTE_TABLE_UPDATE",
+  [TYPE.PUSH]: "PUSH",
+  [TYPE.QUERY]: "QUERY",
+  [TYPE.QUERY_HIT]: "QUERY_HIT",
+};
+
+export const CANONICAL_HEADER_NAMES: Record<string, string> = {
+  "user-agent": "User-Agent",
+  "x-ultrapeer": "X-Ultrapeer",
+  "x-ultrapeer-needed": "X-Ultrapeer-Needed",
+  "x-query-routing": "X-Query-Routing",
+  "x-ultrapeer-query-routing": "X-Ultrapeer-Query-Routing",
+  "x-dynamic-querying": "X-Dynamic-Querying",
+  "x-ext-probes": "X-Ext-Probes",
+  "x-degree": "X-Degree",
+  "accept-encoding": "Accept-Encoding",
+  connection: "Connection",
+  "content-encoding": "Content-Encoding",
+  upgrade: "Upgrade",
+  "listen-ip": "Listen-IP",
+  "remote-ip": "Remote-IP",
+  "pong-caching": "Pong-Caching",
+  ggep: "GGEP",
+  "bye-packet": "Bye-Packet",
+  "x-try": "X-Try",
+  "x-try-ultrapeers": "X-Try-Ultrapeers",
+  "x-max-ttl": "X-Max-TTL",
+  "private-data": "Private-Data",
+};
+
+export const INTERESTING_HANDSHAKE_HEADERS = [
+  "server",
+  "user-agent",
+  "x-try",
+  "x-try-ultrapeers",
+  "x-ultrapeer",
+  "x-ultrapeer-needed",
+  "x-dynamic-querying",
+  "x-ext-probes",
+  "x-degree",
+  "upgrade",
+  "connection",
+  "listen-ip",
+  "remote-ip",
+] as const;
+
+export const QRP_HASH_MULTIPLIER = 0x4f1bbcdc;
+export const BASE32_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+
+export const PROMPT_THROBBER_FRAMES = ["*", "o", ".", " "] as const;
+export const PROMPT_THROBBER_INTERVAL_MS = 120;
+export const CLI_SHUTDOWN_TIMEOUT_MS = 3000;
+
+export const CLI_HELP_LINES = [
+  "help",
+  "monitor",
+  "status",
+  "peers",
+  "blocked",
+  "block <ipv4>",
+  "unblock <ipv4>",
+  "connect <ip:port>",
+  "shares",
+  "results",
+  "clear",
+  "ping [ttl]",
+  "query <search terms...>",
+  "browse <peerKey|ip:port>",
+  "info <resultNo>",
+  "magnet <resultNo>",
+  "download <resultNo> [destPath]",
+  "rescan",
+  "save",
+  "quit",
+  "sleep",
+] as const;
+
+export const RESULT_NAME_WIDTH_MAX = 48;