gnutella 1.0.0 → 1.1.0

package/src/persistence/peer_state.ts

@@ -0,0 +1,113 @@
+import { MAX_TRACKED_PEERS } from "../const";
+import { normalizeIpv4, normalizePeer, parsePeer } from "../peer_address";
+import { rankPeerCandidatesByLastSeen } from "../peer_discovery";
+import type { PeerState } from "../types";
+
+function normalizePeerTimestamp(value: unknown): number {
+  const ts = Number(value);
+  if (!Number.isFinite(ts)) return 0;
+  return Math.max(0, Math.floor(ts));
+}
+
+export function normalizePeerState(value: unknown): PeerState {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return {};
+
+  const out = new Map<string, number>();
+  for (const [peerSpec, rawTimestamp] of Object.entries(
+    value as Record<string, unknown>,
+  )) {
+    const addr = parsePeer(peerSpec);
+    if (!addr) continue;
+    const peer = normalizePeer(addr.host, addr.port);
+    const timestamp = normalizePeerTimestamp(rawTimestamp);
+    const current = out.get(peer) ?? 0;
+    if (!out.has(peer) || timestamp > current) out.set(peer, timestamp);
+  }
+
+  return Object.fromEntries(out);
+}
+
+export function sortPeerStateEntries(
+  peers: PeerState,
+): Array<[peer: string, lastSeen: number]> {
+  return rankPeerCandidatesByLastSeen(
+    Object.entries(normalizePeerState(peers)).map(([peer, lastSeen]) => ({
+      peer,
+      lastSeen,
+    })),
+  ).map(({ peer, lastSeen }) => [peer, lastSeen]);
+}
+
+export function trimPeerState(
+  peers: PeerState,
+  limit = MAX_TRACKED_PEERS,
+): PeerState {
+  if (limit <= 0) return {};
+  return Object.fromEntries(sortPeerStateEntries(peers).slice(0, limit));
+}
+
+export function filterBlockedPeerState(
+  peers: PeerState,
+  blockedIps: readonly string[],
+): PeerState {
+  const blocked = new Set(
+    blockedIps
+      .map((entry) => normalizeIpv4(entry))
+      .filter((entry): entry is string => !!entry),
+  );
+  if (!blocked.size) return trimPeerState(peers);
+  return Object.fromEntries(
+    sortPeerStateEntries(peers).filter(([peer]) => {
+      const addr = parsePeer(peer);
+      const host = normalizeIpv4(addr?.host);
+      return !host || !blocked.has(host);
+    }),
+  );
+}
+
+export function rememberPeerInState(
+  peers: PeerState,
+  peerSpec: string,
+  timestamp = 0,
+): PeerState {
+  const addr = parsePeer(peerSpec);
+  if (!addr) return trimPeerState(peers);
+
+  const peer = normalizePeer(addr.host, addr.port);
+  const current = normalizePeerState(peers);
+  const existing = current[peer];
+  const nextTimestamp = Math.max(
+    existing ?? 0,
+    normalizePeerTimestamp(timestamp),
+  );
+  const shouldPromote =
+    existing == null ||
+    nextTimestamp > existing ||
+    (existing === 0 && nextTimestamp === 0);
+
+  if (!shouldPromote) return trimPeerState(current);
+
+  return trimPeerState(
+    Object.fromEntries([
+      [peer, nextTimestamp],
+      ...Object.entries(current).filter(
+        ([candidate]) => candidate !== peer,
+      ),
+    ]),
+  );
+}
+
+export function peerStateTargets(peers: PeerState): string[] {
+  return sortPeerStateEntries(peers).map(([peer]) => peer);
+}
+
+export function peerStateEquals(a: PeerState, b: PeerState): boolean {
+  const aEntries = sortPeerStateEntries(a);
+  const bEntries = sortPeerStateEntries(b);
+  if (aEntries.length !== bEntries.length) return false;
+  return aEntries.every(
+    ([peer, lastSeen], index) =>
+      bEntries[index]?.[0] === peer && bEntries[index]?.[1] === lastSeen,
+  );
+}

package/src/persistence/types.ts

@@ -0,0 +1,28 @@
+export type PersistedConfig = {
+  listen_ip?: unknown;
+  listen_host?: unknown;
+  listen_port?: unknown;
+  advertised_ip?: unknown;
+  advertised_host?: unknown;
+  advertised_port?: unknown;
+  blocked_ips?: unknown;
+  gwebcache_urls?: unknown;
+  ultrapeer?: unknown;
+  max_connections?: unknown;
+  max_ultrapeer_connections?: unknown;
+  max_leaf_connections?: unknown;
+  max_ttl?: unknown;
+  enable_tls?: unknown;
+  log_ignore?: unknown;
+  data_dir?: unknown;
+};
+
+export type PersistedState = {
+  servent_id_hex?: unknown;
+  peers?: unknown;
+};
+
+export type PersistedDoc = {
+  config?: PersistedConfig;
+  state?: PersistedState;
+};

package/src/protocol/codec.ts

@@ -1,5 +1,6 @@
 import { HEADER_LEN } from "../const";
 import { bytesToIpBE, ipToBytesBE } from "../shared";
+export { parseByteRange } from "../transfers/ranges";
 import type {
   QueryDescriptor,
   QueryHitDescriptor,
@@ -18,11 +19,11 @@ import {
   bitprintUrnFromGgepHash,
   firstSha1Urn,
   normalizeUrnList,
+  sha1ToUrn,
   sha1BufferFromUrn,
   textUrnFromGgepUrn,
 } from "./content_urn";
 import { splitQuerySearch } from "./query_search";
-import { sha1ToUrn } from "./qrp";
 
 const MODERN_QUERY_FLAG_BITS = [
   ["requesterFirewalled", 14],
@@ -32,6 +33,26 @@ const MODERN_QUERY_FLAG_BITS = [
   ["outOfBand", 10],
 ] as const;
 
+type QueryExtensionBlocks = {
+  textBlocks: Buffer[];
+  ggepItems: GgepItem[];
+};
+
+type QueryHitDescriptorBlockOptions = {
+  vendorCode?: string;
+  push: boolean;
+  busy?: boolean;
+  haveUploaded?: boolean;
+  measuredSpeed?: boolean;
+  ggep?: boolean;
+  privateArea?: Buffer;
+};
+
+type HttpDownloadHeader = {
+  remaining: number;
+  finalStart: number;
+};
+
 function normalizedModernQueryMaxHits(
   maxHits: number | undefined,
 ): number {
@@ -61,10 +82,9 @@ function splitFsBlocks(buf: Buffer): Buffer[] {
   return blocks.filter((x) => x.length > 0);
 }
 
-function splitTextAndGgepExtensions(rawExtensions: Buffer): {
-  textBlocks: Buffer[];
-  ggepItems: GgepItem[];
-} {
+function splitTextAndGgepExtensions(
+  rawExtensions: Buffer,
+): QueryExtensionBlocks {
   const ggepStart = rawExtensions.indexOf(0xc3);
   if (ggepStart === -1) {
     return {
@@ -151,15 +171,7 @@ function qhdFlagMeaningful(
   return !!(enabler & (1 << bit));
 }
 
-function buildQhdBlock(options: {
-  vendorCode?: string;
-  push: boolean;
-  busy?: boolean;
-  haveUploaded?: boolean;
-  measuredSpeed?: boolean;
-  ggep?: boolean;
-  privateArea?: Buffer;
-}): Buffer {
+function buildQhdBlock(options: QueryHitDescriptorBlockOptions): Buffer {
   const vendor = Buffer.alloc(4, 0);
   Buffer.from(
     (options.vendorCode || DEFAULT_VENDOR_CODE).slice(0, 4).padEnd(4, " "),
@@ -339,58 +351,6 @@ function parseQueryHitResultAt(
   };
 }
 
-function parseByteRangeSuffix(
-  endRaw: string,
-  size: number,
-  last: number,
-): { start: number; end: number; partial: boolean } | null {
-  const suffixLen = Number(endRaw);
-  if (!Number.isInteger(suffixLen) || suffixLen <= 0) return null;
-  const length = Math.min(suffixLen, size);
-  return { start: size - length, end: last, partial: length < size };
-}
-
-function explicitByteRangeEnd(
-  endRaw: string,
-  start: number,
-  size: number,
-  last: number,
-): number | undefined {
-  const end = endRaw ? Number(endRaw) : last;
-  if (!Number.isInteger(end) || end < start) return undefined;
-  if (size === 0) return -1;
-  return Math.min(end, last);
-}
-
-function parseByteRangeExplicit(
-  startRaw: string,
-  endRaw: string,
-  size: number,
-  last: number,
-): { start: number; end: number; partial: boolean } | null {
-  const start = Number(startRaw);
-  if (!Number.isInteger(start) || start < 0) return null;
-  if (size > 0 && start > last) return null;
-  const end = explicitByteRangeEnd(endRaw, start, size, last);
-  if (end == null) return null;
-  return { start, end, partial: size > 0 && (start > 0 || end < last) };
-}
-
-export function parseByteRange(
-  rangeHeader: string | undefined,
-  size: number,
-): { start: number; end: number; partial: boolean } | null {
-  const last = size > 0 ? size - 1 : -1;
-  if (!rangeHeader) return { start: 0, end: last, partial: false };
-  const m = /^bytes=(\d*)-(\d*)$/i.exec(rangeHeader.trim());
-  if (!m) return null;
-  const startRaw = m[1];
-  const endRaw = m[2];
-  if (!startRaw && !endRaw) return null;
-  if (!startRaw) return parseByteRangeSuffix(endRaw, size, last);
-  return parseByteRangeExplicit(startRaw, endRaw, size, last);
-}
-
 export function buildHeader(
   descriptorId: Buffer,
   payloadType: number,
@@ -692,7 +652,7 @@ export function buildUriResRequest(
 export function parseHttpDownloadHeader(
   head: string,
   requestedStart: number,
-): { remaining: number; finalStart: number } {
+): HttpDownloadHeader {
   const first = head.replace(/\r\n/g, "\n").split("\n", 1)[0];
   const match = /^HTTP\/(\d+\.\d+)\s+(\d+)/i.exec(first);
   if (!match) throw new Error("invalid HTTP response");

package/src/protocol/content_urn.ts

@@ -35,7 +35,7 @@ function base32Decode(text: string): Buffer | undefined {
   return Buffer.from(out);
 }
 
-export function base32Encode(data: Buffer): string {
+function base32Encode(data: Buffer): string {
   let result = "";
   let bits = 0;
   let value = 0;
@@ -51,6 +51,10 @@ export function base32Encode(data: Buffer): string {
   return result;
 }
 
+export function sha1ToUrn(sha1: Buffer): string {
+  return `${SHA1_URN_PREFIX}${base32Encode(sha1)}`;
+}
+
 function normalizeSha1Urn(raw: string): string | undefined {
   const match = /^urn:sha1:([A-Z2-7]+)$/i.exec(raw.trim());
   if (!match) return undefined;

package/src/protocol/file_hash.ts

@@ -0,0 +1,12 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+
+export async function sha1File(abs: string): Promise<Buffer> {
+  return await new Promise<Buffer>((resolve, reject) => {
+    const hash = crypto.createHash("sha1");
+    const rs = fs.createReadStream(abs);
+    rs.on("data", (chunk) => hash.update(chunk));
+    rs.on("error", reject);
+    rs.on("end", () => resolve(hash.digest()));
+  });
+}

package/src/protocol/file_server.ts

@@ -3,8 +3,8 @@ import fsp from "node:fs/promises";
 import net from "node:net";
 
 import { errMsg } from "../shared";
+import { parseByteRange } from "../transfers";
 import type { ShareFile } from "../types";
-import { parseByteRange } from "./codec";
 import { hasToken, parseHttpHeaders, socketCanEnd } from "./handshake";
 import {
   handleBrowseHostGet,

package/src/protocol/ggep.ts

@@ -15,6 +15,17 @@ export type GgepItem = {
   data: Buffer;
 };
 
+type GgepLengthCursor = {
+  length: number;
+  nextOffset: number;
+};
+
+type ParsedGgepItem = {
+  item: GgepItem;
+  nextOffset: number;
+  last: boolean;
+};
+
 function hasZeroByte(data: Buffer): boolean {
   return data.includes(0);
 }
@@ -73,10 +84,7 @@ function encodeLength(length: number): Buffer {
   return Buffer.from(bytes);
 }
 
-function decodeLength(
-  raw: Buffer,
-  start: number,
-): { length: number; nextOffset: number } {
+function decodeLength(raw: Buffer, start: number): GgepLengthCursor {
   let offset = start;
   let length = 0;
   for (let i = 0; i < 3; i++) {
@@ -99,10 +107,7 @@ function maybeDeflateDecode(data: Buffer, flags: number): Buffer {
   return zlib.inflateRawSync(data);
 }
 
-function parseGgepItem(
-  raw: Buffer,
-  start: number,
-): { item: GgepItem; nextOffset: number; last: boolean } {
+function parseGgepItem(raw: Buffer, start: number): ParsedGgepItem {
   let offset = start;
   const flags = raw[offset++];
   if (flags == null) throw new Error("truncated GGEP flags");

package/src/protocol/handshake.ts

@@ -1,170 +1,27 @@
 import net from "node:net";
 
-import {
-  CANONICAL_HEADER_NAMES,
-  INTERESTING_HANDSHAKE_HEADERS,
-} from "../const";
-import {
-  ipv4Subnet16,
-  isRoutableIpv4,
-  normalizeIpv4,
-  parsePeer,
-} from "../shared";
-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 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;
-}
-
-function parseRemoteIpHeader(v: string | undefined): string | undefined {
-  if (!v) return undefined;
-  return normalizeIpv4(v.split(",")[0]?.trim());
-}
-
-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)}`;
-}
+import { ipv4Subnet16, isRoutableIpv4, normalizeIpv4 } from "../shared";
+import { parseRemoteIpHeader } from "../handshake_policy";
+
+type ObservedAdvertisedHost = {
+  observedHost: string;
+  subnet: string;
+};
+
+export {
+  buildHandshakeBlock,
+  describeHandshakeResponse,
+  findHeaderEnd,
+  hasToken,
+  mergeHeaders,
+  parseHandshakeBlock,
+  parsePeerHeaderList,
+} from "../handshake_policy";
 
 export function observedAdvertisedHostCandidate(
   headers: Record<string, string>,
   reporterHost?: string,
-): { observedHost: string; subnet: string } | undefined {
+): ObservedAdvertisedHost | undefined {
   const observedHost = parseRemoteIpHeader(
     headers["remote-ip"] || headers["x-remote-ip"],
   );

package/src/protocol/http_download_reader.ts

@@ -1,4 +1,8 @@
 import { errMsg } from "../shared";
+import {
+  buildHttpDownloadResult,
+  httpDownloadEndDecision,
+} from "../transfers";
 import type { HttpDownloadState } from "./node_types";
 
 type HttpDownloadSourceHandlers = {
@@ -65,8 +69,10 @@ export async function readHttpDownloadSource({
         if (state.headerDone && state.remaining === 0) finish();
       },
       onEnd: () => {
-        if (!done && state.headerDone && state.remaining === 0) finish();
-        else if (!done) fail(new Error(incompleteMessage));
+        if (done) return;
+        const decision = httpDownloadEndDecision(state, incompleteMessage);
+        if (decision.kind === "complete") finish();
+        else fail(new Error(decision.message));
       },
       onError: (error) => fail(error),
     });
@@ -97,11 +103,7 @@ export async function readHttpDownloadSource({
       if (done) return;
       done = true;
       cleanup();
-      const meta = {
-        destPath,
-        bytes: state.finalStart + state.bodyBytes,
-        label,
-      };
+      const meta = buildHttpDownloadResult(state, destPath, label);
       if (!state.ws) {
         resolve(meta);
         return;

package/src/protocol/magnet.ts

@@ -11,6 +11,19 @@ type ParsedMagnet = {
   alternateSources: string[];
 };
 
+type ParsedMagnetParams = {
+  uri: string;
+  params: URLSearchParams;
+};
+
+type MagnetBuildInput = {
+  fileName?: string;
+  fileSize?: number;
+  search?: string;
+  urns?: string[];
+  sha1Urn?: string;
+};
+
 type MagnetFields = {
   xt: string[];
   xs: string[];
@@ -58,12 +71,7 @@ function pickFirst(values: string[]): string | undefined {
   return values.find((value) => value.length > 0);
 }
 
-function parseMagnetParams(raw: string):
-  | {
-      uri: string;
-      params: URLSearchParams;
-    }
-  | undefined {
+function parseMagnetParams(raw: string): ParsedMagnetParams | undefined {
   const uri = raw.trim();
   if (!/^magnet:\?/i.test(uri)) return undefined;
   return {
@@ -155,13 +163,7 @@ export function parseMagnetUri(raw: string): ParsedMagnet | undefined {
   };
 }
 
-export function buildMagnetUri(input: {
-  fileName?: string;
-  fileSize?: number;
-  search?: string;
-  urns?: string[];
-  sha1Urn?: string;
-}): string {
+export function buildMagnetUri(input: MagnetBuildInput): string {
   const params = new URLSearchParams();
   const urns = normalizeUrnList([
     ...(input.urns || []),

package/src/protocol/node.ts

@@ -7,6 +7,7 @@ import {
   reportSelfToGWebCaches,
   type GWebCacheBootstrapState,
 } from "../gwebcache_client";
+import { QrpTable } from "../query_routing/qrp";
 import { sleep } from "../shared";
 import type {
   ConfigDoc,
@@ -39,7 +40,6 @@ import * as topology from "./node_topology";
 import * as transfer from "./node_transfer";
 import type { ShareIndexEntry } from "./share_index";
 import type { Peer } from "./node_types";
-import { QrpTable } from "./qrp";
 
 type BoundMethods<T extends Record<string, unknown>> = {
   [K in keyof T as T[K] extends (...args: infer AllArgs) => unknown