gnutella 1.0.0 → 1.1.0

package/src/handshake_policy/capabilities.ts

@@ -0,0 +1,167 @@
+import { DEFAULT_USER_AGENT } from "../const";
+import type { PeerCapabilities } from "../types";
+import {
+  hasToken,
+  lowerCaseHeaders,
+  parseBoolHeader,
+  parseListenIpHeader,
+  parsePositiveIntHeader,
+  parseRemoteIpHeader,
+} from "./headers";
+import type { CapabilityPolicy, LocalHandshakePolicy } from "./types";
+
+const GTK_MODERN_ULTRAPEER_MIN_DEGREE = 16;
+
+function ultrapeerNeededHeader(
+  policy: LocalHandshakePolicy,
+): string | undefined {
+  if (policy.nodeMode !== "ultrapeer") return undefined;
+  if (policy.connectedMeshPeerCount < policy.maxUltrapeerConnections)
+    return "True";
+  if (policy.connectedLeafCount < policy.maxLeafConnections)
+    return "False";
+  return undefined;
+}
+
+function baseRoleHeaders(
+  policy: LocalHandshakePolicy,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    "x-ultrapeer": policy.nodeMode === "ultrapeer" ? "True" : "False",
+  };
+  const ultrapeerNeeded = ultrapeerNeededHeader(policy);
+  if (ultrapeerNeeded) headers["x-ultrapeer-needed"] = ultrapeerNeeded;
+  if (policy.nodeMode === "ultrapeer") {
+    headers["x-ultrapeer-query-routing"] = "0.1";
+    headers["x-dynamic-querying"] = "0.1";
+    headers["x-ext-probes"] = "0.1";
+    headers["x-degree"] = String(
+      Math.max(
+        GTK_MODERN_ULTRAPEER_MIN_DEGREE,
+        policy.maxUltrapeerConnections,
+      ),
+    );
+  }
+  return headers;
+}
+
+function baseFeatureHeaders(
+  policy: LocalHandshakePolicy,
+): Record<string, string> {
+  const headers: Record<string, string> = {};
+  if (policy.enableQrp)
+    headers["x-query-routing"] = policy.queryRoutingVersion || "0.1";
+  if (policy.enableCompression) headers["accept-encoding"] = "deflate";
+  if (policy.enablePongCaching) headers["pong-caching"] = "0.1";
+  if (policy.enableGgep) headers.ggep = "0.5";
+  if (policy.enableBye) headers["bye-packet"] = "0.1";
+  return headers;
+}
+
+export function buildBaseHandshakeHeaders(
+  policy: LocalHandshakePolicy,
+  remoteIp?: string,
+): Record<string, string> {
+  const headers: Record<string, string> = {
+    "user-agent": policy.userAgent || DEFAULT_USER_AGENT,
+    "listen-ip": `${policy.advertisedHost}:${policy.advertisedPort}`,
+    "x-max-ttl": String(policy.maxTtl),
+    ...baseRoleHeaders(policy),
+    ...baseFeatureHeaders(policy),
+  };
+  const observedRemote = parseRemoteIpHeader(remoteIp);
+  if (observedRemote) headers["remote-ip"] = observedRemote;
+  return headers;
+}
+
+function peerRequestedTlsUpgrade(
+  headers: Record<string, string>,
+  upgradeToken: string,
+): boolean {
+  return hasToken(headers.upgrade, upgradeToken);
+}
+
+function peerAcceptedTlsUpgrade(
+  headers: Record<string, string>,
+  upgradeToken: string,
+): boolean {
+  return (
+    hasToken(headers.upgrade, upgradeToken) &&
+    hasToken(headers.connection, "upgrade")
+  );
+}
+
+export function buildServerHandshakeHeaders(
+  policy: LocalHandshakePolicy,
+  requestHeaders: Record<string, string>,
+  remoteIp?: string,
+): Record<string, string> {
+  const headers = buildBaseHandshakeHeaders(policy, remoteIp);
+  if (
+    policy.tlsEnabled &&
+    peerRequestedTlsUpgrade(requestHeaders, policy.tlsUpgradeToken)
+  ) {
+    headers.upgrade = policy.tlsUpgradeToken;
+    headers.connection = "Upgrade";
+  }
+  if (
+    policy.enableCompression &&
+    hasToken(requestHeaders["accept-encoding"], "deflate")
+  ) {
+    headers["content-encoding"] = "deflate";
+  }
+  return headers;
+}
+
+export function buildClientFinalHeaders(
+  policy: LocalHandshakePolicy,
+  serverHeaders: Record<string, string>,
+  remoteIp?: string,
+): Record<string, string> {
+  const headers: Record<string, string> = {};
+  const observedRemote = parseRemoteIpHeader(remoteIp);
+  if (observedRemote) headers["remote-ip"] = observedRemote;
+  if (
+    policy.tlsEnabled &&
+    peerAcceptedTlsUpgrade(serverHeaders, policy.tlsUpgradeToken)
+  )
+    headers.connection = "Upgrade";
+  if (
+    policy.enableCompression &&
+    hasToken(serverHeaders["accept-encoding"], "deflate")
+  ) {
+    headers["content-encoding"] = "deflate";
+  }
+  return headers;
+}
+
+export function buildPeerCapabilities(
+  policy: CapabilityPolicy,
+): PeerCapabilities {
+  const h = lowerCaseHeaders(policy.headers);
+  return {
+    version: policy.version,
+    headers: h,
+    userAgent: h["user-agent"],
+    supportsGgep: !!h.ggep,
+    supportsPongCaching: !!h["pong-caching"],
+    supportsBye: !!h["bye-packet"],
+    supportsTls:
+      policy.tlsEnabled &&
+      peerRequestedTlsUpgrade(h, policy.tlsUpgradeToken),
+    supportsCompression:
+      hasToken(h["accept-encoding"], "deflate") ||
+      hasToken(h["content-encoding"], "deflate"),
+    compressIn: policy.compressIn,
+    compressOut: policy.compressOut,
+    isUltrapeer: parseBoolHeader(h["x-ultrapeer"]),
+    ultrapeerNeeded: parseBoolHeader(h["x-ultrapeer-needed"]),
+    queryRoutingVersion: h["x-query-routing"],
+    ultrapeerQueryRoutingVersion: h["x-ultrapeer-query-routing"],
+    dynamicQueryingVersion: h["x-dynamic-querying"],
+    extProbesVersion: h["x-ext-probes"],
+    degree: parsePositiveIntHeader(h["x-degree"]),
+    isCrawler: !!h.crawler,
+    listenIp: parseListenIpHeader(h["listen-ip"]),
+  };
+}

package/src/handshake_policy/headers.ts

@@ -0,0 +1,157 @@
+import {
+  CANONICAL_HEADER_NAMES,
+  INTERESTING_HANDSHAKE_HEADERS,
+} from "../const";
+import { normalizeIpv4, parsePeer } from "../peer_address";
+import type { PeerAddr } from "../types";
+
+export function hasToken(
+  value: string | undefined,
+  token: string,
+): boolean {
+  if (!value) return false;
+  return value
+    .split(",")
+    .map((x) => x.trim().toLowerCase())
+    .includes(token.toLowerCase());
+}
+
+export function parseBoolHeader(
+  v: string | undefined,
+): boolean | undefined {
+  if (v == null) return undefined;
+  const s = v.trim().toLowerCase();
+  if (s === "true") return true;
+  if (s === "false") return false;
+  return undefined;
+}
+
+export function parsePositiveIntHeader(
+  v: string | undefined,
+): number | undefined {
+  if (!v) return undefined;
+  const n = Number(v.trim());
+  return Number.isInteger(n) && n > 0 ? n : undefined;
+}
+
+export function parseRemoteIpHeader(
+  v: string | undefined,
+): string | undefined {
+  if (!v) return undefined;
+  return normalizeIpv4(v.split(",")[0]?.trim());
+}
+
+export function parsePeerHeaderList(v: string | undefined): PeerAddr[] {
+  if (!v) return [];
+  return v
+    .split(",")
+    .map((x) => parsePeer(x.trim()))
+    .filter((x): x is PeerAddr => !!x);
+}
+
+export function parseListenIpHeader(
+  v: string | undefined,
+): PeerAddr | undefined {
+  if (!v) return undefined;
+  return parsePeer(v.trim()) || undefined;
+}
+
+export function lowerCaseHeaders(
+  headers: Record<string, string>,
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const [k, v] of Object.entries(headers)) out[k.toLowerCase()] = v;
+  return out;
+}
+
+export function mergeHeaders(
+  ...parts: Array<Record<string, string> | undefined>
+): Record<string, string> {
+  const out: Record<string, string> = {};
+  for (const part of parts) {
+    if (!part) continue;
+    for (const [k, v] of Object.entries(part)) out[k.toLowerCase()] = v;
+  }
+  return out;
+}
+
+export function findHeaderEnd(raw: string): number {
+  const crlf = raw.indexOf("\r\n\r\n");
+  const lf = raw.indexOf("\n\n");
+  if (crlf !== -1 && (lf === -1 || crlf < lf)) return crlf + 4;
+  if (lf !== -1) return lf + 2;
+  return -1;
+}
+
+function appendContinuationLine(
+  headers: Record<string, string>,
+  current: string,
+  line: string,
+): boolean {
+  if (!/^[ \t]/.test(line) || !current) return false;
+  headers[current] = `${headers[current]} ${line.trim()}`.trim();
+  return true;
+}
+
+function recordHeaderLine(
+  headers: Record<string, string>,
+  line: string,
+): string {
+  const idx = line.indexOf(":");
+  if (idx === -1) return "";
+  const key = line.slice(0, idx).trim().toLowerCase();
+  const value = line.slice(idx + 1).trim();
+  headers[key] = headers[key] ? `${headers[key]},${value}` : value;
+  return key;
+}
+
+export function parseHandshakeBlock(raw: string): {
+  startLine: string;
+  headers: Record<string, string>;
+} {
+  const end = findHeaderEnd(raw);
+  const text = end === -1 ? raw : raw.slice(0, end);
+  const lines = text.replace(/\r\n/g, "\n").split("\n");
+  const startLine = lines.shift()?.trim() || "";
+  const headers: Record<string, string> = {};
+  let current = "";
+
+  for (const line of lines) {
+    if (!line) continue;
+    if (appendContinuationLine(headers, current, line)) continue;
+    current = recordHeaderLine(headers, line);
+  }
+  return { startLine, headers };
+}
+
+function canonicalHeaderName(key: string): string {
+  return CANONICAL_HEADER_NAMES[key.toLowerCase()] || key;
+}
+
+export function buildHandshakeBlock(
+  startLine: string,
+  headers: Record<string, string>,
+): Buffer {
+  const lines = [startLine];
+  for (const [k, v] of Object.entries(headers)) {
+    lines.push(`${canonicalHeaderName(k)}: ${v}`);
+  }
+  lines.push("", "");
+  return Buffer.from(lines.join("\r\n"), "latin1");
+}
+
+function summarizeHandshakeHeaders(
+  headers: Record<string, string>,
+): string {
+  const parts = INTERESTING_HANDSHAKE_HEADERS.filter(
+    (key) => !!headers[key],
+  ).map((key) => `${canonicalHeaderName(key)}=${headers[key]}`);
+  return parts.length ? ` [${parts.join("; ")}]` : "";
+}
+
+export function describeHandshakeResponse(
+  startLine: string,
+  headers: Record<string, string>,
+): string {
+  return `${startLine}${summarizeHandshakeHeaders(headers)}`;
+}

package/src/handshake_policy/index.ts

@@ -0,0 +1,21 @@
+export { buildRejectHeaders } from "./admission";
+export {
+  buildBaseHandshakeHeaders,
+  buildClientFinalHeaders,
+  buildPeerCapabilities,
+  buildServerHandshakeHeaders,
+} from "./capabilities";
+export {
+  buildHandshakeBlock,
+  describeHandshakeResponse,
+  findHeaderEnd,
+  hasToken,
+  mergeHeaders,
+  parseBoolHeader,
+  parseHandshakeBlock,
+  parseListenIpHeader,
+  parsePeerHeaderList,
+  parsePositiveIntHeader,
+  parseRemoteIpHeader,
+} from "./headers";
+export type { LocalHandshakePolicy } from "./types";

package/src/handshake_policy/types.ts

@@ -0,0 +1,36 @@
+type HandshakeNodeMode = "leaf" | "ultrapeer";
+
+export type LocalHandshakePolicy = {
+  userAgent?: string;
+  advertisedHost: string;
+  advertisedPort: number;
+  maxTtl: number;
+  nodeMode: HandshakeNodeMode;
+  maxUltrapeerConnections: number;
+  maxLeafConnections: number;
+  connectedMeshPeerCount: number;
+  connectedLeafCount: number;
+  enableQrp: boolean;
+  queryRoutingVersion?: string;
+  enableCompression: boolean;
+  enablePongCaching: boolean;
+  enableGgep: boolean;
+  enableBye: boolean;
+  tlsEnabled: boolean;
+  tlsUpgradeToken: string;
+};
+
+export type CapabilityPolicy = {
+  version: string;
+  headers: Record<string, string>;
+  compressIn: boolean;
+  compressOut: boolean;
+  tlsEnabled: boolean;
+  tlsUpgradeToken: string;
+};
+
+export type RejectHandshakePolicy = {
+  extraHeaders?: Record<string, string>;
+  remoteIp?: string;
+  tryPeers?: string[];
+};

package/src/peer_address.ts

@@ -0,0 +1,68 @@
+import net from "node:net";
+
+import type { PeerAddr } from "./types";
+
+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;
+}
+
+export function normalizePeer(host: string, port: number): string {
+  return `${normalizeIpv4(host) || host.trim()}:${port}`;
+}
+
+export function parsePeer(s: string): PeerAddr | 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 };
+}
+
+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]}`;
+}

package/src/peer_discovery/candidate_policy.ts

@@ -0,0 +1,80 @@
+import { normalizePeer, parsePeer } from "../peer_address";
+import type {
+  BootstrapAttemptSummary,
+  FreshPeerCandidateFetchInput,
+  PeerCandidate,
+  TimestampedPeerCandidate,
+} from "./types";
+
+export function normalizePeerCandidates(
+  peers: readonly string[],
+  isSelfPeer?: (host: string, port: number) => boolean,
+): PeerCandidate[] {
+  const out: PeerCandidate[] = [];
+  const seen = new Set<string>();
+
+  for (const peer of peers) {
+    const parsed = parsePeer(peer);
+    if (!parsed) continue;
+    if (isSelfPeer?.(parsed.host, parsed.port)) continue;
+
+    const normalized = normalizePeer(parsed.host, parsed.port);
+    if (seen.has(normalized)) continue;
+    seen.add(normalized);
+    out.push({
+      host: parsed.host,
+      port: parsed.port,
+      peer: normalized,
+    });
+  }
+
+  return out;
+}
+
+export function peerCandidateSetKey(
+  candidates: readonly PeerCandidate[],
+): string {
+  return candidates
+    .map((peer) => peer.peer)
+    .sort((a, b) => a.localeCompare(b))
+    .join(",");
+}
+
+export function exhaustedPeerSet(
+  candidates: readonly PeerCandidate[],
+  attempt: BootstrapAttemptSummary,
+): boolean {
+  return (
+    candidates.length === 0 ||
+    attempt.attemptedPeers.length >= candidates.length
+  );
+}
+
+export function shouldFetchFreshPeerCandidates(
+  input: FreshPeerCandidateFetchInput,
+): boolean {
+  if (!exhaustedPeerSet(input.candidates, input.initialAttempt)) {
+    return false;
+  }
+  if (input.state?.active) return false;
+  return input.state?.lastExhaustedPeerSet !== input.candidateKey;
+}
+
+export function addPeerCandidatesToKnownSet(
+  candidates: readonly PeerCandidate[],
+  knownPeers: Set<string>,
+): string[] {
+  const addedPeers: string[] = [];
+  for (const candidate of candidates) {
+    if (knownPeers.has(candidate.peer)) continue;
+    knownPeers.add(candidate.peer);
+    addedPeers.push(candidate.peer);
+  }
+  return addedPeers;
+}
+
+export function rankPeerCandidatesByLastSeen<
+  T extends TimestampedPeerCandidate,
+>(candidates: readonly T[]): T[] {
+  return [...candidates].sort((a, b) => b.lastSeen - a.lastSeen);
+}

package/src/peer_discovery/index.ts

@@ -0,0 +1,8 @@
+export {
+  addPeerCandidatesToKnownSet,
+  exhaustedPeerSet,
+  normalizePeerCandidates,
+  peerCandidateSetKey,
+  rankPeerCandidatesByLastSeen,
+  shouldFetchFreshPeerCandidates,
+} from "./candidate_policy";

package/src/peer_discovery/types.ts

@@ -0,0 +1,26 @@
+export type PeerCandidate = {
+  host: string;
+  port: number;
+  peer: string;
+};
+
+export type BootstrapAttemptSummary = {
+  attemptedPeers: readonly string[];
+};
+
+type DiscoveryBootstrapState = {
+  active?: boolean;
+  lastExhaustedPeerSet?: string;
+};
+
+export type FreshPeerCandidateFetchInput = {
+  candidates: readonly PeerCandidate[];
+  initialAttempt: BootstrapAttemptSummary;
+  candidateKey: string;
+  state?: DiscoveryBootstrapState;
+};
+
+export type TimestampedPeerCandidate = {
+  peer: string;
+  lastSeen: number;
+};

package/src/persistence/config_doc.ts

@@ -0,0 +1,61 @@
+import type { ConfigDoc, RuntimeConfig } from "../types";
+import { trimPeerState } from "./peer_state";
+import type {
+  PersistedConfig,
+  PersistedDoc,
+  PersistedState,
+} from "./types";
+
+export function persistedConfigForRuntime(
+  runtime: RuntimeConfig,
+): PersistedConfig {
+  const cleanConfig: PersistedConfig = {
+    listen_ip: runtime.listenHost,
+    listen_port: runtime.listenPort,
+    gwebcache_urls: [...runtime.gwebCacheUrls],
+    ultrapeer: runtime.ultrapeer,
+    max_ultrapeer_connections: runtime.maxUltrapeerConnections,
+    max_leaf_connections: runtime.maxLeafConnections,
+    max_ttl: runtime.maxTtl,
+    enable_tls: runtime.enableTls,
+    data_dir: runtime.dataDir,
+  };
+  if (runtime.advertisedHost)
+    cleanConfig.advertised_ip = runtime.advertisedHost;
+  if (
+    runtime.advertisedPort != null &&
+    runtime.advertisedPort !== runtime.listenPort
+  ) {
+    cleanConfig.advertised_port = runtime.advertisedPort;
+  }
+  if (runtime.blockedIps.length)
+    cleanConfig.blocked_ips = runtime.blockedIps;
+  if (runtime.monitorIgnoreEvents.length)
+    cleanConfig.log_ignore = runtime.monitorIgnoreEvents;
+  return cleanConfig;
+}
+
+export function persistedStateForDoc(
+  doc: ConfigDoc,
+  fallbackServentIdHex: string,
+): PersistedState {
+  return {
+    servent_id_hex:
+      typeof doc.state.serventIdHex === "string" &&
+      /^[0-9a-f]{32}$/i.test(doc.state.serventIdHex)
+        ? doc.state.serventIdHex.toLowerCase()
+        : fallbackServentIdHex,
+    peers: trimPeerState(doc.state.peers),
+  };
+}
+
+export function persistedDocForRuntime(
+  runtime: RuntimeConfig,
+  doc: ConfigDoc,
+  fallbackServentIdHex: string,
+): PersistedDoc {
+  return {
+    config: persistedConfigForRuntime(runtime),
+    state: persistedStateForDoc(doc, fallbackServentIdHex),
+  };
+}

package/src/persistence/index.ts

@@ -0,0 +1,14 @@
+export {
+  persistedConfigForRuntime,
+  persistedDocForRuntime,
+  persistedStateForDoc,
+} from "./config_doc";
+export {
+  filterBlockedPeerState,
+  normalizePeerState,
+  peerStateEquals,
+  peerStateTargets,
+  rememberPeerInState,
+  sortPeerStateEntries,
+  trimPeerState,
+} from "./peer_state";