gnutella 1.0.0

package/src/protocol/content_urn.ts

@@ -0,0 +1,170 @@
+import { BASE32_ALPHABET } from "../const";
+
+const BASE32_LOOKUP = new Map(
+  [...BASE32_ALPHABET].map((char, index) => [char, index]),
+);
+
+const SHA1_URN_PREFIX = "urn:sha1:";
+const BITPRINT_URN_PREFIX = "urn:bitprint:";
+const TREE_TIGER_URN_PREFIX = "urn:tree:tiger/:";
+
+function normalizeSha1Base32(value: string): string | undefined {
+  const normalized = value.trim().toUpperCase();
+  return /^[A-Z2-7]{32}$/.test(normalized) ? normalized : undefined;
+}
+
+function normalizeTigerTreeBase32(value: string): string | undefined {
+  const normalized = value.trim().toUpperCase();
+  return /^[A-Z2-7]{39}$/.test(normalized) ? normalized : undefined;
+}
+
+function base32Decode(text: string): Buffer | undefined {
+  let bits = 0;
+  let value = 0;
+  const out: number[] = [];
+  for (const char of text.toUpperCase()) {
+    const digit = BASE32_LOOKUP.get(char);
+    if (digit == null) return undefined;
+    value = (value << 5) | digit;
+    bits += 5;
+    while (bits >= 8) {
+      out.push((value >>> (bits - 8)) & 0xff);
+      bits -= 8;
+    }
+  }
+  return Buffer.from(out);
+}
+
+export function base32Encode(data: Buffer): string {
+  let result = "";
+  let bits = 0;
+  let value = 0;
+  for (const byte of data) {
+    value = (value << 8) | byte;
+    bits += 8;
+    while (bits >= 5) {
+      result += BASE32_ALPHABET[(value >>> (bits - 5)) & 31];
+      bits -= 5;
+    }
+  }
+  if (bits > 0) result += BASE32_ALPHABET[(value << (5 - bits)) & 31];
+  return result;
+}
+
+function normalizeSha1Urn(raw: string): string | undefined {
+  const match = /^urn:sha1:([A-Z2-7]+)$/i.exec(raw.trim());
+  if (!match) return undefined;
+  const digest = normalizeSha1Base32(match[1]);
+  return digest ? `${SHA1_URN_PREFIX}${digest}` : undefined;
+}
+
+function normalizeBitprintUrn(raw: string): string | undefined {
+  const match = /^urn:bitprint:([A-Z2-7]+)\.([A-Z2-7]+)$/i.exec(
+    raw.trim(),
+  );
+  if (!match) return undefined;
+  const sha1 = normalizeSha1Base32(match[1]);
+  const tiger = normalizeTigerTreeBase32(match[2]);
+  if (!sha1 || !tiger) return undefined;
+  return `${BITPRINT_URN_PREFIX}${sha1}.${tiger}`;
+}
+
+function normalizeTreeTigerUrn(raw: string): string | undefined {
+  const match = /^urn:tree:tiger\/?:([A-Z2-7]+)$/i.exec(raw.trim());
+  if (!match) return undefined;
+  const tiger = normalizeTigerTreeBase32(match[1]);
+  return tiger ? `${TREE_TIGER_URN_PREFIX}${tiger}` : undefined;
+}
+
+export function sha1UrnFromUrn(raw: string): string | undefined {
+  const sha1 = normalizeSha1Urn(raw);
+  if (sha1) return sha1;
+  const bitprint = normalizeBitprintUrn(raw);
+  if (!bitprint) return undefined;
+  const dot = bitprint.indexOf(".");
+  return dot === -1
+    ? undefined
+    : `${SHA1_URN_PREFIX}${bitprint.slice(BITPRINT_URN_PREFIX.length, dot)}`;
+}
+
+export function sha1BufferFromUrn(raw: string): Buffer | undefined {
+  const sha1Urn = sha1UrnFromUrn(raw);
+  if (!sha1Urn) return undefined;
+  const digest = sha1Urn.slice(SHA1_URN_PREFIX.length);
+  const decoded = base32Decode(digest);
+  return decoded?.length === 20 ? decoded : undefined;
+}
+
+export function bitprintUrnFromHashes(
+  sha1: Buffer,
+  tigerTreeRoot: Buffer,
+): string {
+  return `${BITPRINT_URN_PREFIX}${base32Encode(sha1)}.${base32Encode(tigerTreeRoot)}`;
+}
+
+export function normalizeUrnList(rawUrns: Iterable<string>): string[] {
+  const out: string[] = [];
+  const seen = new Set<string>();
+  const add = (urn: string) => {
+    const key = urn.toLowerCase();
+    if (seen.has(key)) return;
+    seen.add(key);
+    out.push(urn);
+  };
+  for (const raw of rawUrns) {
+    const sha1 = normalizeSha1Urn(raw);
+    if (sha1) {
+      add(sha1);
+      continue;
+    }
+    const bitprint = normalizeBitprintUrn(raw);
+    if (bitprint) {
+      add(bitprint);
+      add(
+        `${SHA1_URN_PREFIX}${bitprint.slice(
+          BITPRINT_URN_PREFIX.length,
+          bitprint.indexOf("."),
+        )}`,
+      );
+      continue;
+    }
+    const tiger = normalizeTreeTigerUrn(raw);
+    if (tiger) {
+      add(tiger);
+      continue;
+    }
+    const trimmed = raw.trim();
+    if (trimmed.toLowerCase().startsWith("urn:")) add(trimmed);
+  }
+  return out;
+}
+
+export function firstSha1Urn(
+  rawUrns: Iterable<string>,
+): string | undefined {
+  for (const urn of rawUrns) {
+    const sha1 = sha1UrnFromUrn(urn);
+    if (sha1) return sha1;
+  }
+}
+
+export function textUrnFromGgepUrn(raw: Buffer): string | undefined {
+  const text = raw.toString("utf8").trim();
+  if (!text) return undefined;
+  if (text.toLowerCase().startsWith("urn:")) {
+    return normalizeUrnList([text])[0];
+  }
+  if (/^(sha1|bitprint|tree:tiger\/?):/i.test(text)) {
+    return normalizeUrnList([`urn:${text}`])[0];
+  }
+}
+
+export function bitprintUrnFromGgepHash(
+  payload: Buffer,
+): string | undefined {
+  if (payload.length < 1 + 20 + 24) return undefined;
+  return bitprintUrnFromHashes(
+    payload.subarray(1, 21),
+    payload.subarray(21, 45),
+  );
+}

package/src/protocol/core_utils.ts

@@ -0,0 +1,43 @@
+import crypto from "node:crypto";
+
+import { TYPE } from "../const";
+
+export function randomId16(): Buffer {
+  const id = crypto.randomBytes(16);
+  id[8] = 0xff;
+  id[15] = 0x00;
+  return id;
+}
+
+export function seenKey(
+  payloadType: number,
+  descriptorIdHex: string,
+  payload?: Buffer,
+): string {
+  const base = `${payloadType}:${descriptorIdHex}`;
+  if (
+    (payloadType === TYPE.PONG || payloadType === TYPE.QUERY_HIT) &&
+    payload
+  ) {
+    const digest = crypto.createHash("sha1").update(payload).digest("hex");
+    return `${base}:${digest}`;
+  }
+  return base;
+}
+
+export function fromHex16(hex: string): Buffer {
+  const clean = hex.trim().toLowerCase();
+  if (!/^[0-9a-f]{32}$/.test(clean))
+    throw new Error(`expected 32 hex chars, got ${hex}`);
+  const id = Buffer.from(clean, "hex");
+  id[8] = 0xff;
+  id[15] = 0x00;
+  return id;
+}
+
+export function rawHex16(hex: string): Buffer {
+  const clean = hex.trim().toLowerCase();
+  if (!/^[0-9a-f]{32}$/.test(clean))
+    throw new Error(`expected 32 hex chars, got ${hex}`);
+  return Buffer.from(clean, "hex");
+}

package/src/protocol/file_server.ts

@@ -0,0 +1,245 @@
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import net from "node:net";
+
+import { errMsg } from "../shared";
+import type { ShareFile } from "../types";
+import { parseByteRange } from "./codec";
+import { hasToken, parseHttpHeaders, socketCanEnd } from "./handshake";
+import {
+  handleBrowseHostGet,
+  isBrowseHostGetRequest,
+} from "./browse_host";
+import type { GnutellaServent } from "./node";
+import type { ExistingGetRequest } from "./node_types";
+import { sha1UrnFromUrn } from "./content_urn";
+
+function toError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(errMsg(error));
+}
+
+async function handleGetByFileIndex(
+  node: GnutellaServent,
+  socket: net.Socket,
+  head: string,
+  first: string,
+): Promise<boolean | undefined> {
+  const match =
+    /^(GET|HEAD)\s+\/get\/(\d+)\/(.+?)(?:\/)?\s+HTTP\/(\d+\.\d+)$/i.exec(
+      first,
+    );
+  if (!match) return undefined;
+  const fileIndex = Number(match[2]);
+  const share = node.sharesByIndex.get(fileIndex);
+  if (!share) {
+    socket.end("HTTP/1.0 404 Not Found\r\n\r\n");
+    return false;
+  }
+  return await node.handleExistingGet(socket, head, share.abs, share);
+}
+
+async function handleUriResGet(
+  node: GnutellaServent,
+  socket: net.Socket,
+  head: string,
+  first: string,
+): Promise<boolean | undefined> {
+  const match =
+    /^(GET|HEAD)\s+\/uri-res\/N2R\?([^\s]+)\s+HTTP\/(\d+\.\d+)$/i.exec(
+      first,
+    );
+  if (!match || !node.config().serveUriRes) return undefined;
+  const rawUrn = decodeURIComponent(match[2]);
+  const urn = (sha1UrnFromUrn(rawUrn) || rawUrn).toLowerCase();
+  const share = node.sharesByUrn.get(urn);
+  if (!share) {
+    socket.end("HTTP/1.0 404 Not Found\r\n\r\n");
+    return false;
+  }
+  return await node.handleExistingGet(socket, head, share.abs, share);
+}
+
+export async function handleIncomingGet(
+  node: GnutellaServent,
+  socket: net.Socket,
+  head: string,
+  _body: Buffer = Buffer.alloc(0),
+): Promise<boolean> {
+  if (isBrowseHostGetRequest(head)) {
+    return await handleBrowseHostGet(node, socket, head);
+  }
+  const first = head.replace(/\r\n/g, "\n").split("\n", 1)[0];
+  const byIndex = await handleGetByFileIndex(node, socket, head, first);
+  if (byIndex != null) return byIndex;
+  const byUrn = await handleUriResGet(node, socket, head, first);
+  if (byUrn != null) return byUrn;
+
+  socket.end("HTTP/1.0 400 Bad Request\r\n\r\n");
+  return false;
+}
+
+export function parseExistingGetRequest(
+  _node: GnutellaServent,
+  head: string,
+): ExistingGetRequest {
+  const first = head.replace(/\r\n/g, "\n").split("\n", 1)[0];
+  const method =
+    /^(GET|HEAD)\s+/i.exec(first)?.[1]?.toUpperCase() || "GET";
+  const httpVersion =
+    /^([A-Z]+)\s+\S+\s+HTTP\/(\d+\.\d+)$/i.exec(first)?.[2] || "1.0";
+  const headers = parseHttpHeaders(head);
+  return {
+    method,
+    responseVersion: httpVersion === "1.1" ? "HTTP/1.1" : "HTTP/1.0",
+    headers,
+    keepAlive: !hasToken(headers["connection"], "close"),
+  };
+}
+
+export function writeInvalidRangeResponse(
+  _node: GnutellaServent,
+  socket: net.Socket,
+  request: ExistingGetRequest,
+  size: number,
+): boolean {
+  socket.write(
+    [
+      `${request.responseVersion} 416 Range Not Satisfiable`,
+      "Server: Gnutella",
+      "Content-Type: application/binary",
+      "Content-Length: 0",
+      `Content-Range: bytes */${size}`,
+      `Connection: ${request.keepAlive ? "Keep-Alive" : "close"}`,
+      "",
+      "",
+    ].join("\r\n"),
+  );
+  if (!request.keepAlive && socketCanEnd(socket)) socket.end();
+  return request.keepAlive;
+}
+
+export function existingGetBodyLength(
+  _node: GnutellaServent,
+  range: { start: number; end: number },
+): number {
+  return range.end >= range.start ? range.end - range.start + 1 : 0;
+}
+
+export function buildExistingGetResponseHeaders(
+  _node: GnutellaServent,
+  request: ExistingGetRequest,
+  range: { start: number; end: number; partial: boolean },
+  size: number,
+  remaining: number,
+  share?: ShareFile,
+): string {
+  return [
+    range.partial
+      ? `${request.responseVersion} 206 Partial Content`
+      : `${request.responseVersion} 200 OK`,
+    "Server: Gnutella",
+    "Content-Type: application/binary",
+    `Content-Length: ${remaining}`,
+    ...(range.partial
+      ? [`Content-Range: bytes ${range.start}-${range.end}/${size}`]
+      : []),
+    ...(share?.sha1Urn
+      ? [
+          `X-Gnutella-Content-URN: ${share.sha1Urn}`,
+          `X-Content-URN: ${share.sha1Urn}`,
+        ]
+      : []),
+    `Connection: ${request.keepAlive ? "Keep-Alive" : "close"}`,
+    "",
+    "",
+  ].join("\r\n");
+}
+
+export function finishExistingGetResponse(
+  _node: GnutellaServent,
+  socket: net.Socket,
+  keepAlive: boolean,
+): boolean {
+  if (!keepAlive && socketCanEnd(socket)) socket.end();
+  return keepAlive;
+}
+
+export async function streamExistingGetBody(
+  _node: GnutellaServent,
+  socket: net.Socket,
+  absPath: string,
+  range: { start: number; end: number },
+  keepAlive: boolean,
+): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    const rs = fs.createReadStream(absPath, {
+      start: range.start,
+      end: range.end,
+    });
+    let done = false;
+    const cleanup = () => {
+      rs.off("error", onError);
+      rs.off("end", onEnd);
+      socket.off("close", onClose);
+      socket.off("error", onSocketError);
+    };
+    const finish = () => {
+      if (done) return;
+      done = true;
+      cleanup();
+      resolve();
+    };
+    const fail = (error: unknown) => {
+      if (done) return;
+      done = true;
+      cleanup();
+      reject(toError(error));
+    };
+    const onError = (error: unknown) => fail(error);
+    const onSocketError = (error: unknown) => fail(error);
+    const onClose = () => finish();
+    const onEnd = () => {
+      if (!keepAlive && socketCanEnd(socket)) socket.end();
+      finish();
+    };
+    rs.on("error", onError);
+    rs.on("end", onEnd);
+    socket.once("close", onClose);
+    socket.once("error", onSocketError);
+    rs.pipe(socket, { end: false });
+  });
+}
+
+export async function handleExistingGet(
+  node: GnutellaServent,
+  socket: net.Socket,
+  head: string,
+  absPath: string,
+  share?: ShareFile,
+): Promise<boolean> {
+  const request = node.parseExistingGetRequest(head);
+  const stat = await fsp.stat(absPath);
+  const range = parseByteRange(request.headers["range"], stat.size);
+  if (!range)
+    return node.writeInvalidRangeResponse(socket, request, stat.size);
+  const remaining = node.existingGetBodyLength(range);
+  socket.write(
+    node.buildExistingGetResponseHeaders(
+      request,
+      range,
+      stat.size,
+      remaining,
+      share,
+    ),
+  );
+  if (request.method === "HEAD" || remaining === 0) {
+    return node.finishExistingGetResponse(socket, request.keepAlive);
+  }
+  await node.streamExistingGetBody(
+    socket,
+    absPath,
+    range,
+    request.keepAlive,
+  );
+  return request.keepAlive;
+}

package/src/protocol/ggep.ts

@@ -0,0 +1,168 @@
+import zlib from "node:zlib";
+
+const GGEP_MAGIC = 0xc3;
+const GGEP_HDR_LAST = 0x80;
+const GGEP_HDR_COBS = 0x40;
+const GGEP_HDR_DEFLATE = 0x20;
+const GGEP_HDR_RESERVED = 0x10;
+const GGEP_HDR_IDLEN = 0x0f;
+const GGEP_LEN_MORE = 0x80;
+const GGEP_LEN_LAST = 0x40;
+const GGEP_LEN_MASK = 0x3f;
+
+export type GgepItem = {
+  id: string;
+  data: Buffer;
+};
+
+function hasZeroByte(data: Buffer): boolean {
+  return data.includes(0);
+}
+
+function cobsEncode(data: Buffer): Buffer {
+  const out = [0];
+  let codeIndex = 0;
+  let code = 1;
+  for (const byte of data) {
+    if (byte === 0) {
+      out[codeIndex] = code;
+      codeIndex = out.length;
+      out.push(0);
+      code = 1;
+      continue;
+    }
+    out.push(byte);
+    code++;
+    if (code === 0xff) {
+      out[codeIndex] = code;
+      codeIndex = out.length;
+      out.push(0);
+      code = 1;
+    }
+  }
+  out[codeIndex] = code;
+  return Buffer.from(out);
+}
+
+function cobsDecode(data: Buffer): Buffer {
+  const out: number[] = [];
+  let offset = 0;
+  while (offset < data.length) {
+    const code = data[offset++];
+    if (code === 0) throw new Error("invalid GGEP COBS block");
+    const next = offset + code - 1;
+    if (next > data.length + 1)
+      throw new Error("truncated GGEP COBS block");
+    for (; offset < next && offset < data.length; offset++) {
+      out.push(data[offset] as number);
+    }
+    if (code < 0xff && offset < data.length) out.push(0);
+  }
+  return Buffer.from(out);
+}
+
+function encodeLength(length: number): Buffer {
+  const bytes: number[] = [];
+  if (length & 0x3f000) {
+    bytes.push(((length >>> 12) & GGEP_LEN_MASK) | GGEP_LEN_MORE);
+  }
+  if (length & 0x0fc0) {
+    bytes.push(((length >>> 6) & GGEP_LEN_MASK) | GGEP_LEN_MORE);
+  }
+  bytes.push((length & GGEP_LEN_MASK) | GGEP_LEN_LAST);
+  return Buffer.from(bytes);
+}
+
+function decodeLength(
+  raw: Buffer,
+  start: number,
+): { length: number; nextOffset: number } {
+  let offset = start;
+  let length = 0;
+  for (let i = 0; i < 3; i++) {
+    const byte = raw[offset++];
+    if (byte == null || byte === 0) throw new Error("invalid GGEP length");
+    length = (length << 6) | (byte & GGEP_LEN_MASK);
+    const last = !!(byte & GGEP_LEN_LAST);
+    const more = !!(byte & GGEP_LEN_MORE);
+    if (last) {
+      if (more) throw new Error("invalid GGEP length flags");
+      return { length, nextOffset: offset };
+    }
+    if (!more) throw new Error("invalid GGEP length continuation");
+  }
+  throw new Error("GGEP length too long");
+}
+
+function maybeDeflateDecode(data: Buffer, flags: number): Buffer {
+  if (!(flags & GGEP_HDR_DEFLATE)) return data;
+  return zlib.inflateRawSync(data);
+}
+
+function parseGgepItem(
+  raw: Buffer,
+  start: number,
+): { item: GgepItem; nextOffset: number; last: boolean } {
+  let offset = start;
+  const flags = raw[offset++];
+  if (flags == null) throw new Error("truncated GGEP flags");
+  if ((flags & GGEP_HDR_RESERVED) !== 0)
+    throw new Error("invalid GGEP reserved bit");
+  const idLength = flags & GGEP_HDR_IDLEN;
+  if (!idLength) throw new Error("invalid GGEP id length");
+  if (offset + idLength > raw.length) throw new Error("truncated GGEP id");
+  const id = raw.subarray(offset, offset + idLength).toString("ascii");
+  offset += idLength;
+  const decodedLength = decodeLength(raw, offset);
+  offset = decodedLength.nextOffset;
+  if (offset + decodedLength.length > raw.length)
+    throw new Error("truncated GGEP payload");
+  let data = Buffer.from(
+    raw.subarray(offset, offset + decodedLength.length),
+  ) as Buffer;
+  offset += decodedLength.length;
+  if (flags & GGEP_HDR_COBS) data = cobsDecode(data) as Buffer;
+  data = maybeDeflateDecode(data, flags) as Buffer;
+  return {
+    item: { id, data },
+    nextOffset: offset,
+    last: !!(flags & GGEP_HDR_LAST),
+  };
+}
+
+export function encodeGgep(items: GgepItem[]): Buffer {
+  if (!items.length) return Buffer.alloc(0);
+  const parts: Buffer[] = [Buffer.from([GGEP_MAGIC])];
+  items.forEach((item, index) => {
+    const id = item.id.trim();
+    if (!id || id.length > 15)
+      throw new Error(`invalid GGEP id ${JSON.stringify(item.id)}`);
+    let flags = id.length;
+    let data = item.data;
+    if (hasZeroByte(data)) {
+      data = cobsEncode(data);
+      flags |= GGEP_HDR_COBS;
+    }
+    if (index === items.length - 1) flags |= GGEP_HDR_LAST;
+    parts.push(
+      Buffer.from([flags]),
+      Buffer.from(id, "ascii"),
+      encodeLength(data.length),
+      data,
+    );
+  });
+  return Buffer.concat(parts);
+}
+
+export function parseGgep(raw: Buffer): GgepItem[] {
+  if (!raw.length || raw[0] !== GGEP_MAGIC) return [];
+  const items: GgepItem[] = [];
+  let offset = 1;
+  while (offset < raw.length) {
+    const parsed = parseGgepItem(raw, offset);
+    items.push(parsed.item);
+    offset = parsed.nextOffset;
+    if (parsed.last) break;
+  }
+  return items;
+}