gnutella 1.0.0 → 1.1.0

package/src/protocol/node_handshake.ts

@@ -1,6 +1,14 @@
 import net from "node:net";
 
-import { DEFAULT_USER_AGENT, MAX_XTRY } from "../const";
+import { MAX_XTRY } from "../const";
+import {
+  buildBaseHandshakeHeaders,
+  buildClientFinalHeaders as buildPolicyClientFinalHeaders,
+  buildPeerCapabilities,
+  buildRejectHeaders,
+  buildServerHandshakeHeaders as buildPolicyServerHandshakeHeaders,
+  type LocalHandshakePolicy,
+} from "../handshake_policy";
 import {
   errMsg,
   normalizeIpv4,
@@ -19,13 +27,9 @@ import {
   describeHandshakeResponse,
   findHeaderEnd,
   hasToken,
-  lowerCaseHeaders,
   mergeHeaders,
-  parseBoolHeader,
   parseHandshakeBlock,
-  parseListenIpHeader,
   parsePeerHeaderList,
-  parsePositiveIntHeader,
 } from "./handshake";
 import type { GnutellaServent } from "./node";
 import type { ProbeCtx } from "./node_types";
@@ -140,70 +144,40 @@ function emitHandshakeBlock(
   );
 }
 
-function ultrapeerNeededHeader(node: GnutellaServent): string | undefined {
-  if (node.nodeMode() !== "ultrapeer") return undefined;
-  if (
-    node.connectedMeshPeerCount() < node.config().maxUltrapeerConnections
-  )
-    return "True";
-  if (node.connectedLeafCount() < node.config().maxLeafConnections)
-    return "False";
-  return undefined;
-}
-
-const GTK_MODERN_ULTRAPEER_MIN_DEGREE = 16;
-
-function baseRoleHeaders(node: GnutellaServent): Record<string, string> {
-  const headers: Record<string, string> = {
-    "x-ultrapeer": node.nodeMode() === "ultrapeer" ? "True" : "False",
-  };
-  const ultrapeerNeeded = ultrapeerNeededHeader(node);
-  if (ultrapeerNeeded) headers["x-ultrapeer-needed"] = ultrapeerNeeded;
-  if (node.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,
-        node.config().maxUltrapeerConnections,
-      ),
-    );
-  }
-  return headers;
-}
-
-function baseFeatureHeaders(
+function localHandshakePolicy(
   node: GnutellaServent,
-): Record<string, string> {
+  tlsEnabled = node.tlsEnabled(),
+): LocalHandshakePolicy {
   const c = node.config();
-  const headers: Record<string, string> = {};
-  if (c.enableQrp)
-    headers["x-query-routing"] = c.queryRoutingVersion || "0.1";
-  if (c.enableCompression) headers["accept-encoding"] = "deflate";
-  if (c.enablePongCaching) headers["pong-caching"] = "0.1";
-  if (c.enableGgep) headers["ggep"] = "0.5";
-  if (c.enableBye) headers["bye-packet"] = "0.1";
-  return headers;
+  return {
+    userAgent: c.userAgent,
+    advertisedHost: node.currentAdvertisedHost(),
+    advertisedPort: node.currentAdvertisedPort(),
+    maxTtl: c.maxTtl,
+    nodeMode: node.nodeMode(),
+    maxUltrapeerConnections: c.maxUltrapeerConnections,
+    maxLeafConnections: c.maxLeafConnections,
+    connectedMeshPeerCount: node.connectedMeshPeerCount(),
+    connectedLeafCount: node.connectedLeafCount(),
+    enableQrp: c.enableQrp,
+    queryRoutingVersion: c.queryRoutingVersion,
+    enableCompression: c.enableCompression,
+    enablePongCaching: c.enablePongCaching,
+    enableGgep: c.enableGgep,
+    enableBye: c.enableBye,
+    tlsEnabled,
+    tlsUpgradeToken: node.tlsUpgradeToken(),
+  };
 }
 
 export function baseHandshakeHeaders(
   node: GnutellaServent,
   remoteIp?: string,
 ): Record<string, string> {
-  const c = node.config();
-  const advertisedHost = node.currentAdvertisedHost();
-  const advertisedPort = node.currentAdvertisedPort();
-  const headers: Record<string, string> = {
-    "user-agent": c.userAgent || DEFAULT_USER_AGENT,
-    "listen-ip": `${advertisedHost}:${advertisedPort}`,
-    "x-max-ttl": String(c.maxTtl),
-    ...baseRoleHeaders(node),
-    ...baseFeatureHeaders(node),
-  };
-  const observedRemote = normalizeIpv4(remoteIp);
-  if (observedRemote) headers["remote-ip"] = observedRemote;
-  return headers;
+  return buildBaseHandshakeHeaders(
+    localHandshakePolicy(node, false),
+    remoteIp,
+  );
 }
 
 export function buildServerHandshakeHeaders(
@@ -211,18 +185,11 @@ export function buildServerHandshakeHeaders(
   requestHeaders: Record<string, string>,
   remoteIp?: string,
 ): Record<string, string> {
-  const headers = node.baseHandshakeHeaders(remoteIp);
-  if (node.tlsEnabled() && node.peerRequestedTlsUpgrade(requestHeaders)) {
-    headers.upgrade = node.tlsUpgradeToken();
-    headers.connection = "Upgrade";
-  }
-  if (
-    node.config().enableCompression &&
-    hasToken(requestHeaders["accept-encoding"], "deflate")
-  ) {
-    headers["content-encoding"] = "deflate";
-  }
-  return headers;
+  return buildPolicyServerHandshakeHeaders(
+    localHandshakePolicy(node),
+    requestHeaders,
+    remoteIp,
+  );
 }
 
 export function buildClientFinalHeaders(
@@ -230,18 +197,11 @@ export function buildClientFinalHeaders(
   serverHeaders: Record<string, string>,
   remoteIp?: string,
 ): Record<string, string> {
-  const headers: Record<string, string> = {};
-  const observedRemote = normalizeIpv4(remoteIp);
-  if (observedRemote) headers["remote-ip"] = observedRemote;
-  if (node.tlsEnabled() && node.peerAcceptedTlsUpgrade(serverHeaders))
-    headers.connection = "Upgrade";
-  if (
-    node.config().enableCompression &&
-    hasToken(serverHeaders["accept-encoding"], "deflate")
-  ) {
-    headers["content-encoding"] = "deflate";
-  }
-  return headers;
+  return buildPolicyClientFinalHeaders(
+    localHandshakePolicy(node),
+    serverHeaders,
+    remoteIp,
+  );
 }
 
 export function buildCapabilities(
@@ -251,30 +211,14 @@ export function buildCapabilities(
   compressIn: boolean,
   compressOut: boolean,
 ): PeerCapabilities {
-  const h = lowerCaseHeaders(headers);
-  return {
+  return buildPeerCapabilities({
     version,
-    headers: h,
-    userAgent: h["user-agent"],
-    supportsGgep: !!h["ggep"],
-    supportsPongCaching: !!h["pong-caching"],
-    supportsBye: !!h["bye-packet"],
-    supportsTls: node.peerRequestedTlsUpgrade(h),
-    supportsCompression:
-      hasToken(h["accept-encoding"], "deflate") ||
-      hasToken(h["content-encoding"], "deflate"),
+    headers,
     compressIn,
     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"]),
-  };
+    tlsEnabled: node.tlsEnabled(),
+    tlsUpgradeToken: node.tlsUpgradeToken(),
+  });
 }
 
 export function selectTryPeers(
@@ -337,13 +281,11 @@ export function reject06(
   extraHeaders: Record<string, string> = {},
 ): void {
   const tryPeers = node.selectTryPeers();
-  const headers = lowerCaseHeaders(extraHeaders);
-  const observedRemote = normalizeIpv4(socket.remoteAddress);
-  if (observedRemote) headers["remote-ip"] = observedRemote;
-  if (tryPeers.length) {
-    headers["x-try"] = tryPeers.join(",");
-    headers["x-try-ultrapeers"] = tryPeers.join(",");
-  }
+  const headers = buildRejectHeaders({
+    extraHeaders,
+    remoteIp: socket.remoteAddress,
+    tryPeers,
+  });
   emitHandshakeBlock(
     node,
     "inbound",

package/src/protocol/node_protocol_runtime.ts

@@ -1,8 +1,25 @@
-import crypto from "node:crypto";
 import type net from "node:net";
 import zlib from "node:zlib";
 
-import { HEADER_LEN, LOCAL_ROUTE, TYPE, TYPE_NAME } from "../const";
+import { HEADER_LEN, TYPE, TYPE_NAME } from "../const";
+import {
+  forwardedDescriptorLifetime,
+  normalizeQueryLifetime as normalizeQueryLifetimePolicy,
+  overflowPongCacheKeys,
+  pongCacheKey,
+  pongReplyTtl,
+  queryHitReplyTtl,
+  responseRouteDecision,
+  selectCachedPongPayloads,
+  shouldMarkDescriptorSeen,
+  shouldRelayPing,
+  shouldSuppressDescriptor,
+} from "../descriptor_routing";
+import type { DescriptorLifetime } from "../descriptor_routing/types";
+import {
+  initialRemoteQrpState,
+  splitSearchTerms,
+} from "../query_routing/qrp";
 import { errMsg, toBuffer, ts } from "../shared";
 import type {
   PendingPush,
@@ -42,11 +59,7 @@ import type {
   Peer,
 } from "./node_types";
 import { firstSha1Urn } from "./content_urn";
-import {
-  initialRemoteQrpState,
-  matchQuery as shareMatchesQuery,
-  splitSearchTerms,
-} from "./qrp";
+import { matchQuery as shareMatchesQuery } from "./query_matching";
 
 function descriptorTypeName(payloadType: number): string {
   return TYPE_NAME[payloadType] || `0x${payloadType.toString(16)}`;
@@ -426,15 +439,16 @@ export function forwardToRoute(
   hops: number,
   payload: Buffer,
 ): void {
-  if (ttl <= 0) return;
+  const lifetime = forwardedDescriptorLifetime(ttl, hops);
+  if (!lifetime) return;
   const peer = node.peers.get(route.peerKey);
   if (!peer) return;
   node.sendToPeer(
     peer,
     payloadType,
     descriptorId,
-    Math.max(0, ttl - 1),
-    hops + 1,
+    lifetime.ttl,
+    lifetime.hops,
     payload,
   );
 }
@@ -479,11 +493,8 @@ export function normalizeQueryLifetime(
   node: GnutellaServent,
   ttl: number,
   hops: number,
-): { ttl: number; hops: number } | null {
-  if (ttl > 15) return null;
-  const maxLife = Math.max(1, node.config().maxTtl);
-  if (hops > maxLife) return null;
-  return { ttl: Math.max(0, Math.min(ttl, maxLife - hops)), hops };
+): DescriptorLifetime | null {
+  return normalizeQueryLifetimePolicy(ttl, hops, node.config().maxTtl);
 }
 
 export function isIndexQuery(
@@ -532,16 +543,14 @@ export function cachePongPayload(
   node: GnutellaServent,
   payload: Buffer,
 ): void {
-  const digest = crypto.createHash("sha1").update(payload).digest("hex");
+  const digest = pongCacheKey(payload);
   node.pongCache.set(digest, {
     payload: Buffer.from(payload),
     at: node.now(),
   });
-  if (node.pongCache.size <= 64) return;
-  const oldest = [...node.pongCache.entries()]
-    .sort((a, b) => a[1].at - b[1].at)
-    .slice(0, node.pongCache.size - 64);
-  for (const [key] of oldest) node.pongCache.delete(key);
+  for (const key of overflowPongCacheKeys(node.pongCache.entries(), 64)) {
+    node.pongCache.delete(key);
+  }
 }
 
 export function shouldIgnoreDescriptor(
@@ -550,15 +559,15 @@ export function shouldIgnoreDescriptor(
   hdr: RoutedDescriptor,
   payload: Buffer,
 ): boolean {
-  if (
-    peer.closingAfterBye &&
-    hdr.payloadType !== TYPE.QUERY_HIT &&
-    hdr.payloadType !== TYPE.PUSH
-  ) {
-    return true;
-  }
-  if (hdr.payloadType === TYPE.ROUTE_TABLE_UPDATE) return false;
-  return node.hasSeen(hdr.payloadType, hdr.descriptorIdHex, payload);
+  return shouldSuppressDescriptor({
+    closingAfterBye: !!peer.closingAfterBye,
+    payloadType: hdr.payloadType,
+    alreadySeen: node.hasSeen(
+      hdr.payloadType,
+      hdr.descriptorIdHex,
+      payload,
+    ),
+  });
 }
 
 export function rejectRelayedLeafDescriptor(
@@ -589,7 +598,7 @@ export function onPingDescriptor(
   });
   node.respondPong(peer, hdr);
   if (!node.shouldRelayPings()) return;
-  if (hdr.ttl <= 1 || node.now() - peer.lastPingAt < 1000) return;
+  if (!shouldRelayPing(hdr.ttl, node.now(), peer.lastPingAt, 1000)) return;
   peer.lastPingAt = node.now();
   broadcastPingToPeers(
     node,
@@ -681,7 +690,7 @@ export function handleDescriptor(
 ): void {
   if (node.rejectRelayedLeafDescriptor(peer, hdr)) return;
   if (node.shouldIgnoreDescriptor(peer, hdr, payload)) return;
-  if (hdr.payloadType !== TYPE.ROUTE_TABLE_UPDATE) {
+  if (shouldMarkDescriptorSeen(hdr.payloadType)) {
     node.markSeen(hdr.payloadType, hdr.descriptorIdHex, payload);
   }
   node.dispatchDescriptor(peer, hdr, payload);
@@ -709,7 +718,7 @@ export function respondPong(
   peer: Peer,
   hdr: Pick<DescriptorHeader, "descriptorId" | "hops">,
 ): void {
-  const ttl = Math.max(1, hdr.hops);
+  const ttl = pongReplyTtl(hdr.hops);
   const own = encodePong(
     node.currentAdvertisedPort(),
     node.currentAdvertisedHost(),
@@ -719,17 +728,12 @@ export function respondPong(
   node.sendToPeer(peer, TYPE.PONG, hdr.descriptorId, ttl, 0, own);
   if (!node.config().enablePongCaching) return;
   let sent = 1;
-  const cached = [...node.pongCache.values()].sort((a, b) => b.at - a.at);
-  for (const entry of cached) {
-    if (sent >= 10) break;
-    node.sendToPeer(
-      peer,
-      TYPE.PONG,
-      hdr.descriptorId,
-      ttl,
-      0,
-      entry.payload,
-    );
+  for (const payload of selectCachedPongPayloads(
+    node.pongCache.values(),
+    sent,
+    10,
+  )) {
+    node.sendToPeer(peer, TYPE.PONG, hdr.descriptorId, ttl, 0, payload);
     sent++;
   }
 }
@@ -750,10 +754,7 @@ export function respondQueryHit(
   const limit = Math.max(1, node.config().maxResultsPerQuery);
   const batchSize = 16;
   const chosen = matches.slice(0, limit);
-  const replyTtl = Math.min(
-    node.config().maxTtl,
-    Math.max(1, hdr.hops + 2),
-  );
+  const replyTtl = queryHitReplyTtl(hdr.hops, node.config().maxTtl);
   for (let off = 0; off < chosen.length; off += batchSize) {
     const batch = chosen.slice(off, off + batchSize);
     const out = encodeQueryHit(
@@ -792,9 +793,12 @@ export function onPong(
   const pong = parsePong(payload);
   node.cachePongPayload(payload);
   node.addKnownPeer(pong.ip, pong.port);
-  const route = node.pingRoutes.get(hdr.descriptorIdHex);
-  if (!route) return;
-  if (route === LOCAL_ROUTE) {
+  const decision = responseRouteDecision(
+    node.pingRoutes.get(hdr.descriptorIdHex),
+    { forwardInLeaf: true },
+  );
+  if (decision.kind === "drop") return;
+  if (decision.kind === "local") {
     node.emitEvent({
       type: "PONG",
       at: ts(),
@@ -806,7 +810,7 @@ export function onPong(
     return;
   }
   node.forwardToRoute(
-    route,
+    decision.route,
     TYPE.PONG,
     hdr.descriptorId,
     hdr.ttl,
@@ -826,9 +830,12 @@ export function onQueryHit(
     peerKey: peer.key,
     ts: node.now(),
   });
-  const route = node.queryRoutes.get(hdr.descriptorIdHex);
-  if (!route) return;
-  if (route === LOCAL_ROUTE) {
+  const decision = responseRouteDecision(
+    node.queryRoutes.get(hdr.descriptorIdHex),
+    { nodeMode: node.nodeMode() },
+  );
+  if (decision.kind === "drop") return;
+  if (decision.kind === "local") {
     for (const result of qh.results) {
       const hit: SearchHit = {
         resultNo: node.resultSeq++,
@@ -854,9 +861,8 @@ export function onQueryHit(
     }
     return;
   }
-  if (node.nodeMode() === "leaf") return;
   node.forwardToRoute(
-    route,
+    decision.route,
     TYPE.QUERY_HIT,
     hdr.descriptorId,
     hdr.ttl,
@@ -877,10 +883,13 @@ export async function onPush(
     return;
   }
   if (node.nodeMode() === "leaf") return;
-  const route = node.pushRoutes.get(push.serventIdHex);
-  if (!route) return;
+  const decision = responseRouteDecision(
+    node.pushRoutes.get(push.serventIdHex),
+    { nodeMode: node.nodeMode() },
+  );
+  if (decision.kind !== "forward") return;
   node.forwardToRoute(
-    route,
+    decision.route,
     TYPE.PUSH,
     hdr.descriptorId,
     hdr.ttl,

package/src/protocol/node_qrp_runtime.ts

@@ -1,4 +1,10 @@
-import { DEFAULT_QRP_ENTRY_BITS, TYPE } from "../const";
+import { TYPE } from "../const";
+import {
+  DEFAULT_QRP_ENTRY_BITS,
+  QrpTable,
+  validateRemoteQrpPatchSequence,
+  validateRemoteQrpReset,
+} from "../query_routing/qrp";
 import { errMsg } from "../shared";
 import { parseRouteTableUpdate } from "./codec";
 import type { GnutellaServent } from "./node";
@@ -7,11 +13,6 @@ import {
   sendPublishedQrpToMeshPeers,
 } from "./node_query_routing";
 import type { Peer } from "./node_types";
-import {
-  QrpTable,
-  validateRemoteQrpPatchSequence,
-  validateRemoteQrpReset,
-} from "./qrp";
 
 function rejectQrpUpdate(
   node: GnutellaServent,