gnutella 1.0.0

package/src/protocol/handshake.ts

@@ -0,0 +1,199 @@
+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)}`;
+}
+
+export function observedAdvertisedHostCandidate(
+  headers: Record<string, string>,
+  reporterHost?: string,
+): { observedHost: string; subnet: string } | undefined {
+  const observedHost = parseRemoteIpHeader(
+    headers["remote-ip"] || headers["x-remote-ip"],
+  );
+  const reporter = normalizeIpv4(reporterHost);
+  if (!observedHost || !reporter) return undefined;
+  if (!isRoutableIpv4(observedHost) || !isRoutableIpv4(reporter))
+    return undefined;
+  const subnet = ipv4Subnet16(reporter);
+  if (!subnet) return undefined;
+  return { observedHost, subnet };
+}
+
+export function socketCanEnd(socket: net.Socket): boolean {
+  return (
+    !socket.destroyed &&
+    !(socket as net.Socket & { writableEnded?: boolean }).writableEnded &&
+    !(socket as net.Socket & { ended?: boolean }).ended
+  );
+}
+
+export function parseHttpHeaders(raw: string): Record<string, string> {
+  const out: Record<string, string> = {};
+  const lines = raw.replace(/\r\n/g, "\n").split("\n");
+  for (const line of lines.slice(1)) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    out[line.slice(0, idx).trim().toLowerCase()] = line
+      .slice(idx + 1)
+      .trim();
+  }
+  return out;
+}

package/src/protocol/http_download_reader.ts

@@ -0,0 +1,112 @@
+import { errMsg } from "../shared";
+import type { HttpDownloadState } from "./node_types";
+
+type HttpDownloadSourceHandlers = {
+  onChunk: (chunk: Buffer) => void;
+  onEnd: () => void;
+  onError: (error: unknown) => void;
+};
+
+type ReadHttpDownloadSourceArgs = {
+  attach: (handlers: HttpDownloadSourceHandlers) => () => void;
+  consumeChunk: (
+    state: HttpDownloadState,
+    destPath: string,
+    requestedStart: number,
+    onWriteError: (error: Error) => void,
+    chunk: Buffer,
+  ) => void;
+  destPath: string;
+  destroyOnFailure?: () => void;
+  incompleteMessage: string;
+  label: string;
+  requestedStart: number;
+};
+
+function toReadError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(errMsg(error));
+}
+
+export async function readHttpDownloadSource({
+  attach,
+  consumeChunk,
+  destPath,
+  destroyOnFailure,
+  incompleteMessage,
+  label,
+  requestedStart,
+}: ReadHttpDownloadSourceArgs): Promise<unknown> {
+  return await new Promise((resolve, reject) => {
+    const state: HttpDownloadState = {
+      buf: Buffer.alloc(0),
+      headerDone: false,
+      remaining: 0,
+      ws: null,
+      finalStart: requestedStart,
+      bodyBytes: 0,
+    };
+    let done = false;
+    const onWriteError = (error: Error) => fail(error);
+    const detach = attach({
+      onChunk: (chunk) => {
+        if (done) return;
+        try {
+          consumeChunk(
+            state,
+            destPath,
+            requestedStart,
+            onWriteError,
+            chunk,
+          );
+        } catch (error) {
+          fail(error);
+          return;
+        }
+        if (state.headerDone && state.remaining === 0) finish();
+      },
+      onEnd: () => {
+        if (!done && state.headerDone && state.remaining === 0) finish();
+        else if (!done) fail(new Error(incompleteMessage));
+      },
+      onError: (error) => fail(error),
+    });
+
+    const cleanup = () => {
+      detach();
+      state.ws?.off("error", onWriteError);
+    };
+
+    const fail = (error: unknown) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      try {
+        state.ws?.destroy();
+      } catch {
+        // ignore
+      }
+      try {
+        destroyOnFailure?.();
+      } catch {
+        // ignore
+      }
+      reject(toReadError(error));
+    };
+
+    const finish = () => {
+      if (done) return;
+      done = true;
+      cleanup();
+      const meta = {
+        destPath,
+        bytes: state.finalStart + state.bodyBytes,
+        label,
+      };
+      if (!state.ws) {
+        resolve(meta);
+        return;
+      }
+      state.ws.end(() => resolve(meta));
+    };
+  });
+}

package/src/protocol/magnet.ts

@@ -0,0 +1,176 @@
+import { firstSha1Urn, normalizeUrnList } from "./content_urn";
+
+type ParsedMagnet = {
+  uri: string;
+  displayName?: string;
+  search?: string;
+  size?: number;
+  urns: string[];
+  sha1Urn?: string;
+  exactSources: string[];
+  alternateSources: string[];
+};
+
+type MagnetFields = {
+  xt: string[];
+  xs: string[];
+  as: string[];
+  dn: string[];
+  kt: string[];
+  size: string[];
+};
+
+type MagnetFieldKey = keyof MagnetFields;
+
+const MAGNET_FIELD_BY_KEY: Record<string, MagnetFieldKey | undefined> = {
+  xt: "xt",
+  xs: "xs",
+  as: "as",
+  dn: "dn",
+  kt: "kt",
+  xl: "size",
+  sz: "size",
+  fs: "size",
+};
+
+function emptyMagnetFields(): MagnetFields {
+  return {
+    xt: [],
+    xs: [],
+    as: [],
+    dn: [],
+    kt: [],
+    size: [],
+  };
+}
+
+function normalizedMagnetKey(key: string): string {
+  return key.toLowerCase().split(".", 1)[0] || "";
+}
+
+function positiveInteger(value: string): number | undefined {
+  if (!/^\d+$/.test(value)) return undefined;
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) && parsed >= 0 ? parsed : undefined;
+}
+
+function pickFirst(values: string[]): string | undefined {
+  return values.find((value) => value.length > 0);
+}
+
+function parseMagnetParams(raw: string):
+  | {
+      uri: string;
+      params: URLSearchParams;
+    }
+  | undefined {
+  const uri = raw.trim();
+  if (!/^magnet:\?/i.test(uri)) return undefined;
+  return {
+    uri,
+    params: new URLSearchParams(uri.slice(uri.indexOf("?") + 1)),
+  };
+}
+
+function appendMagnetField(
+  fields: MagnetFields,
+  rawKey: string,
+  rawValue: string,
+): void {
+  const key = MAGNET_FIELD_BY_KEY[normalizedMagnetKey(rawKey)];
+  const value = rawValue.trim();
+  if (!value || !key) return;
+  fields[key].push(value);
+}
+
+function readMagnetFields(params: URLSearchParams): MagnetFields {
+  const fields = emptyMagnetFields();
+  for (const [rawKey, rawValue] of params.entries()) {
+    appendMagnetField(fields, rawKey, rawValue);
+  }
+  return fields;
+}
+
+function parsedMagnetSize(fields: MagnetFields): number | undefined {
+  return fields.size
+    .map((value) => positiveInteger(value))
+    .find((value) => value != null);
+}
+
+function hasMagnetPayload(
+  fields: MagnetFields,
+  urns: string[],
+  displayName: string | undefined,
+  search: string | undefined,
+  size: number | undefined,
+): boolean {
+  return !!(
+    urns.length ||
+    displayName ||
+    search ||
+    size != null ||
+    fields.xs.length ||
+    fields.as.length
+  );
+}
+
+function preferredMagnetUrn(urns: string[]): string | undefined {
+  return (
+    urns.find((urn) => urn.toLowerCase().startsWith("urn:bitprint:")) ||
+    urns.find((urn) => urn.toLowerCase().startsWith("urn:sha1:")) ||
+    urns[0]
+  );
+}
+
+function appendMagnetSize(
+  params: URLSearchParams,
+  fileSize: number | undefined,
+): void {
+  if (fileSize == null || !Number.isFinite(fileSize) || fileSize < 0) {
+    return;
+  }
+  params.set("xl", String(Math.floor(fileSize)));
+}
+
+export function parseMagnetUri(raw: string): ParsedMagnet | undefined {
+  const parsed = parseMagnetParams(raw);
+  if (!parsed) return undefined;
+  const fields = readMagnetFields(parsed.params);
+  const urns = normalizeUrnList(fields.xt);
+  const displayName = pickFirst(fields.dn);
+  const search = pickFirst(fields.kt) || displayName;
+  const size = parsedMagnetSize(fields);
+  if (!hasMagnetPayload(fields, urns, displayName, search, size))
+    return undefined;
+  const sha1Urn = firstSha1Urn(urns);
+  return {
+    uri: parsed.uri,
+    ...(displayName ? { displayName } : {}),
+    ...(search ? { search } : {}),
+    ...(size != null ? { size } : {}),
+    urns,
+    ...(sha1Urn ? { sha1Urn } : {}),
+    exactSources: fields.xs,
+    alternateSources: fields.as,
+  };
+}
+
+export function buildMagnetUri(input: {
+  fileName?: string;
+  fileSize?: number;
+  search?: string;
+  urns?: string[];
+  sha1Urn?: string;
+}): string {
+  const params = new URLSearchParams();
+  const urns = normalizeUrnList([
+    ...(input.urns || []),
+    ...(input.sha1Urn ? [input.sha1Urn] : []),
+  ]);
+  const primaryUrn = preferredMagnetUrn(urns);
+  if (primaryUrn) params.set("xt", primaryUrn);
+  appendMagnetSize(params, input.fileSize);
+  if (input.fileName) params.set("dn", input.fileName);
+  else if (input.search) params.set("kt", input.search);
+  return `magnet:?${params.toString()}`;
+}