@fuman/net 0.0.1

package/ip/v6.cjs

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const utils = require("@fuman/utils");
+const IPV6_PARTS = 8;
+function parseV6(string) {
+  const parts = new Uint16Array(8);
+  let parsedParts = 0;
+  let afterDoubleColon;
+  let zoneId;
+  let currentPartStart = 0;
+  let ipv4Part = false;
+  let hadSquareBracket = false;
+  let pos = 0;
+  function addPart(str, part) {
+    if (str.length > 4 || Number.isNaN(part) || part < 0 || part > 65535) {
+      throw new Error(`Invalid IPv6 part: ${str} (in ${string})`);
+    }
+    if (afterDoubleColon) {
+      afterDoubleColon.push(part);
+    } else {
+      parts[parsedParts] = part;
+      parsedParts += 1;
+      if (parsedParts > IPV6_PARTS) {
+        throw new Error(`Invalid IPv6 address (too many parts): ${string}`);
+      }
+    }
+  }
+  function handleCurrentPart() {
+    if (currentPartStart === pos) return;
+    const str = string.slice(currentPartStart, pos);
+    if (ipv4Part) {
+      const ipv4 = str.split(".");
+      if (ipv4.length !== 4) {
+        throw new Error(`Invalid IPv4 part: ${str} (in ${string})`);
+      }
+      addPart("", Number.parseInt(ipv4[0], 10) << 8 | Number.parseInt(ipv4[1], 10));
+      addPart("", Number.parseInt(ipv4[2], 10) << 8 | Number.parseInt(ipv4[3], 10));
+      return;
+    }
+    const part = Number.parseInt(str, 16);
+    addPart(str, part);
+  }
+  while (pos < string.length) {
+    const c = string[pos];
+    if (c === "%") {
+      handleCurrentPart();
+      pos += 1;
+      zoneId = string.slice(pos);
+      if (zoneId[zoneId.length - 1] === "]") {
+        zoneId = zoneId.slice(0, -1);
+      }
+      break;
+    } else if (c === "[") {
+      hadSquareBracket = true;
+      currentPartStart = pos + 1;
+    } else if (c === "]") {
+      if (!hadSquareBracket || pos !== string.length - 1 && string[pos + 1] !== "%") {
+        throw new Error(`Invalid IPv6 address (unexpected closing bracket): ${string}`);
+      }
+      handleCurrentPart();
+      currentPartStart = pos + 1;
+    } else if (c === ":") {
+      if (ipv4Part) {
+        throw new Error(`Invalid IPv6 address (colon after IPv4 part): ${string}`);
+      }
+      if (pos !== 0) {
+        handleCurrentPart();
+      }
+      if (string[pos + 1] === ":") {
+        if (afterDoubleColon) {
+          throw new Error(`Invalid IPv6 address (multiple double-colons): ${string}`);
+        }
+        afterDoubleColon = [];
+        pos += 1;
+      } else if (pos === 0) {
+        throw new Error(`Invalid IPv6 address (colon at the beginning): ${string}`);
+      }
+      currentPartStart = pos + 1;
+    } else if (c === ".") {
+      ipv4Part = true;
+    }
+    pos += 1;
+  }
+  if (!hadSquareBracket && zoneId === void 0) {
+    handleCurrentPart();
+  }
+  if (afterDoubleColon) {
+    const missing = IPV6_PARTS - parsedParts - afterDoubleColon.length;
+    if (missing < 0) {
+      throw new Error(`Invalid IPv6 address (too many parts): ${string}`);
+    }
+    for (let i = 0; i < missing; i++) {
+      parts[parsedParts + i] = 0;
+    }
+    for (let i = 0; i < afterDoubleColon.length; i++) {
+      parts[parsedParts + missing + i] = afterDoubleColon[i];
+    }
+  } else if (parsedParts < IPV6_PARTS) {
+    throw new Error(`Invalid IPv6 address (too few parts): ${string}`);
+  }
+  return {
+    type: "ipv6",
+    parts,
+    zoneId
+  };
+}
+function stringifyV6(parsed, options) {
+  const {
+    zeroCompression = true,
+    fixedLength = false
+  } = options || {};
+  let result = "";
+  let compressStart = -1;
+  let compressEnd = 0;
+  if (zeroCompression) {
+    let maxLength = 0;
+    let maxStart = -1;
+    let start = -1;
+    let length = 0;
+    for (let i2 = 0; i2 < parsed.parts.length; i2++) {
+      if (parsed.parts[i2] === 0) {
+        if (start === -1) {
+          start = i2;
+        }
+        length++;
+      } else {
+        if (length > maxLength) {
+          maxLength = length;
+          maxStart = start;
+        }
+        start = -1;
+        length = 0;
+      }
+    }
+    if (length > maxLength) {
+      maxLength = length;
+      maxStart = start;
+    }
+    if (maxLength > 1) {
+      compressStart = maxStart;
+      compressEnd = maxStart + maxLength;
+    }
+  }
+  let i = 0;
+  let writeColon = false;
+  while (i < parsed.parts.length) {
+    const part = parsed.parts[i];
+    if (part < 0 || part > 65535) {
+      throw new Error(`Invalid IPv6 part: ${part.toString(16)}`);
+    }
+    if (i === compressStart) {
+      result += "::";
+      i = compressEnd;
+      writeColon = false;
+      continue;
+    }
+    if (writeColon) result += ":";
+    else writeColon = true;
+    if (fixedLength) {
+      if (part < 16) result += "000";
+      else if (part < 256) result += "00";
+      else if (part < 4096) result += "0";
+    }
+    result += part.toString(16);
+    i += 1;
+  }
+  if (parsed.zoneId != null) {
+    result += `%${parsed.zoneId}`;
+  }
+  return result;
+}
+function expandV6(string) {
+  return stringifyV6(parseV6(string), { zeroCompression: false });
+}
+function _fromBytesInternal(bytes) {
+  const parts = new Uint16Array(bytes.buffer, bytes.byteOffset, 8);
+  if (utils.typed.getPlatformByteOrder() === "little") {
+    utils.u8.swap16(bytes);
+  }
+  return {
+    type: "ipv6",
+    parts
+  };
+}
+function fromBytesV6(bytes) {
+  if (bytes.length !== 16) {
+    throw new Error(`Invalid IPv6 address buffer: ${bytes.length} ≠ 16`);
+  }
+  return _fromBytesInternal(utils.u8.clone(bytes));
+}
+function readV6(reader) {
+  return _fromBytesInternal(io.read.exactly(reader, 16));
+}
+function toBytesV6(parsed) {
+  const copy = new Uint16Array(parsed.parts);
+  const bytes = new Uint8Array(copy.buffer);
+  if (utils.typed.getPlatformByteOrder() === "little") {
+    utils.u8.swap16(bytes);
+  }
+  return bytes;
+}
+function writeV6(parsed, writer) {
+  const buf = writer.writeSync(16);
+  buf.set(new Uint8Array(parsed.parts.buffer, parsed.parts.byteOffset, 16));
+  if (utils.typed.getPlatformByteOrder() === "little") {
+    utils.u8.swap16(buf);
+  }
+  writer.disposeWriteSync();
+}
+exports.expandV6 = expandV6;
+exports.fromBytesV6 = fromBytesV6;
+exports.parseV6 = parseV6;
+exports.readV6 = readV6;
+exports.stringifyV6 = stringifyV6;
+exports.toBytesV6 = toBytesV6;
+exports.writeV6 = writeV6;

package/ip/v6.d.ts

@@ -0,0 +1,18 @@
+import { ISyncReadable, ISyncWritable } from '@fuman/io';
+import { Ipv6Address } from './types.js';
+export declare function parseV6(string: string): Ipv6Address;
+export interface StringifyV6Options {
+    /**
+     * Whether to compress consecutive zeroes
+     * (according to [RFC 5952](https://datatracker.ietf.org/doc/html/rfc5952#section-4))
+     */
+    zeroCompression?: boolean;
+    /** Whether to pad each part to 4 characters */
+    fixedLength?: boolean;
+}
+export declare function stringifyV6(parsed: Ipv6Address, options?: StringifyV6Options): string;
+export declare function expandV6(string: string): string;
+export declare function fromBytesV6(bytes: Uint8Array): Ipv6Address;
+export declare function readV6(reader: ISyncReadable): Ipv6Address;
+export declare function toBytesV6(parsed: Ipv6Address): Uint8Array;
+export declare function writeV6(parsed: Ipv6Address, writer: ISyncWritable): void;

package/ip/v6.js

@@ -0,0 +1,217 @@
+import { read } from "@fuman/io";
+import { u8, typed } from "@fuman/utils";
+const IPV6_PARTS = 8;
+function parseV6(string) {
+  const parts = new Uint16Array(8);
+  let parsedParts = 0;
+  let afterDoubleColon;
+  let zoneId;
+  let currentPartStart = 0;
+  let ipv4Part = false;
+  let hadSquareBracket = false;
+  let pos = 0;
+  function addPart(str, part) {
+    if (str.length > 4 || Number.isNaN(part) || part < 0 || part > 65535) {
+      throw new Error(`Invalid IPv6 part: ${str} (in ${string})`);
+    }
+    if (afterDoubleColon) {
+      afterDoubleColon.push(part);
+    } else {
+      parts[parsedParts] = part;
+      parsedParts += 1;
+      if (parsedParts > IPV6_PARTS) {
+        throw new Error(`Invalid IPv6 address (too many parts): ${string}`);
+      }
+    }
+  }
+  function handleCurrentPart() {
+    if (currentPartStart === pos) return;
+    const str = string.slice(currentPartStart, pos);
+    if (ipv4Part) {
+      const ipv4 = str.split(".");
+      if (ipv4.length !== 4) {
+        throw new Error(`Invalid IPv4 part: ${str} (in ${string})`);
+      }
+      addPart("", Number.parseInt(ipv4[0], 10) << 8 | Number.parseInt(ipv4[1], 10));
+      addPart("", Number.parseInt(ipv4[2], 10) << 8 | Number.parseInt(ipv4[3], 10));
+      return;
+    }
+    const part = Number.parseInt(str, 16);
+    addPart(str, part);
+  }
+  while (pos < string.length) {
+    const c = string[pos];
+    if (c === "%") {
+      handleCurrentPart();
+      pos += 1;
+      zoneId = string.slice(pos);
+      if (zoneId[zoneId.length - 1] === "]") {
+        zoneId = zoneId.slice(0, -1);
+      }
+      break;
+    } else if (c === "[") {
+      hadSquareBracket = true;
+      currentPartStart = pos + 1;
+    } else if (c === "]") {
+      if (!hadSquareBracket || pos !== string.length - 1 && string[pos + 1] !== "%") {
+        throw new Error(`Invalid IPv6 address (unexpected closing bracket): ${string}`);
+      }
+      handleCurrentPart();
+      currentPartStart = pos + 1;
+    } else if (c === ":") {
+      if (ipv4Part) {
+        throw new Error(`Invalid IPv6 address (colon after IPv4 part): ${string}`);
+      }
+      if (pos !== 0) {
+        handleCurrentPart();
+      }
+      if (string[pos + 1] === ":") {
+        if (afterDoubleColon) {
+          throw new Error(`Invalid IPv6 address (multiple double-colons): ${string}`);
+        }
+        afterDoubleColon = [];
+        pos += 1;
+      } else if (pos === 0) {
+        throw new Error(`Invalid IPv6 address (colon at the beginning): ${string}`);
+      }
+      currentPartStart = pos + 1;
+    } else if (c === ".") {
+      ipv4Part = true;
+    }
+    pos += 1;
+  }
+  if (!hadSquareBracket && zoneId === void 0) {
+    handleCurrentPart();
+  }
+  if (afterDoubleColon) {
+    const missing = IPV6_PARTS - parsedParts - afterDoubleColon.length;
+    if (missing < 0) {
+      throw new Error(`Invalid IPv6 address (too many parts): ${string}`);
+    }
+    for (let i = 0; i < missing; i++) {
+      parts[parsedParts + i] = 0;
+    }
+    for (let i = 0; i < afterDoubleColon.length; i++) {
+      parts[parsedParts + missing + i] = afterDoubleColon[i];
+    }
+  } else if (parsedParts < IPV6_PARTS) {
+    throw new Error(`Invalid IPv6 address (too few parts): ${string}`);
+  }
+  return {
+    type: "ipv6",
+    parts,
+    zoneId
+  };
+}
+function stringifyV6(parsed, options) {
+  const {
+    zeroCompression = true,
+    fixedLength = false
+  } = options || {};
+  let result = "";
+  let compressStart = -1;
+  let compressEnd = 0;
+  if (zeroCompression) {
+    let maxLength = 0;
+    let maxStart = -1;
+    let start = -1;
+    let length = 0;
+    for (let i2 = 0; i2 < parsed.parts.length; i2++) {
+      if (parsed.parts[i2] === 0) {
+        if (start === -1) {
+          start = i2;
+        }
+        length++;
+      } else {
+        if (length > maxLength) {
+          maxLength = length;
+          maxStart = start;
+        }
+        start = -1;
+        length = 0;
+      }
+    }
+    if (length > maxLength) {
+      maxLength = length;
+      maxStart = start;
+    }
+    if (maxLength > 1) {
+      compressStart = maxStart;
+      compressEnd = maxStart + maxLength;
+    }
+  }
+  let i = 0;
+  let writeColon = false;
+  while (i < parsed.parts.length) {
+    const part = parsed.parts[i];
+    if (part < 0 || part > 65535) {
+      throw new Error(`Invalid IPv6 part: ${part.toString(16)}`);
+    }
+    if (i === compressStart) {
+      result += "::";
+      i = compressEnd;
+      writeColon = false;
+      continue;
+    }
+    if (writeColon) result += ":";
+    else writeColon = true;
+    if (fixedLength) {
+      if (part < 16) result += "000";
+      else if (part < 256) result += "00";
+      else if (part < 4096) result += "0";
+    }
+    result += part.toString(16);
+    i += 1;
+  }
+  if (parsed.zoneId != null) {
+    result += `%${parsed.zoneId}`;
+  }
+  return result;
+}
+function expandV6(string) {
+  return stringifyV6(parseV6(string), { zeroCompression: false });
+}
+function _fromBytesInternal(bytes) {
+  const parts = new Uint16Array(bytes.buffer, bytes.byteOffset, 8);
+  if (typed.getPlatformByteOrder() === "little") {
+    u8.swap16(bytes);
+  }
+  return {
+    type: "ipv6",
+    parts
+  };
+}
+function fromBytesV6(bytes) {
+  if (bytes.length !== 16) {
+    throw new Error(`Invalid IPv6 address buffer: ${bytes.length} ≠ 16`);
+  }
+  return _fromBytesInternal(u8.clone(bytes));
+}
+function readV6(reader) {
+  return _fromBytesInternal(read.exactly(reader, 16));
+}
+function toBytesV6(parsed) {
+  const copy = new Uint16Array(parsed.parts);
+  const bytes = new Uint8Array(copy.buffer);
+  if (typed.getPlatformByteOrder() === "little") {
+    u8.swap16(bytes);
+  }
+  return bytes;
+}
+function writeV6(parsed, writer) {
+  const buf = writer.writeSync(16);
+  buf.set(new Uint8Array(parsed.parts.buffer, parsed.parts.byteOffset, 16));
+  if (typed.getPlatformByteOrder() === "little") {
+    u8.swap16(buf);
+  }
+  writer.disposeWriteSync();
+}
+export {
+  expandV6,
+  fromBytesV6,
+  parseV6,
+  readV6,
+  stringifyV6,
+  toBytesV6,
+  writeV6
+};

package/package.json

@@ -0,0 +1,30 @@
+{
+    "name": "@fuman/net",
+    "type": "module",
+    "version": "0.0.1",
+    "description": "experimental network abstractions",
+    "license": "MIT",
+    "scripts": {},
+    "dependencies": {
+        "@fuman/io": "^0.0.1",
+        "@fuman/utils": "^0.0.1"
+    },
+    "exports": {
+        ".": {
+            "import": {
+                "types": "./index.d.ts",
+                "default": "./index.js"
+            },
+            "require": {
+                "types": "./index.d.cts",
+                "default": "./index.cjs"
+            }
+        }
+    },
+    "sideEffects": false,
+    "author": "",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/teidesu/fuman.git"
+    }
+}

package/proxy/http/_protocol.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const utils = require("@fuman/utils");
+function buildConnectRequest(options, dest) {
+  let addr = dest.address;
+  if (addr.includes(":")) {
+    addr = `[${addr}]`;
+  }
+  const host = `${addr}:${dest.port}`;
+  const lines = [
+    `CONNECT ${host} HTTP/1.1`,
+    `Host: ${host}`,
+    "User-Agent: @fuman/net",
+    "Proxy-Connection: Keep-Alive"
+  ];
+  if (options.user != null) {
+    let auth = options.user;
+    if (options.password != null) {
+      auth += `:${options.password}`;
+    }
+    lines.push(`Proxy-Authorization: Basic ${utils.base64.encode(utils.utf8.encoder.encode(auth))}`);
+  }
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("", "");
+  return utils.utf8.encoder.encode(lines.join("\r\n"));
+}
+exports.buildConnectRequest = buildConnectRequest;

package/proxy/http/_protocol.d.ts

@@ -0,0 +1,3 @@
+import { TcpEndpoint } from '../../types.js';
+import { HttpProxySettings } from './types.js';
+export declare function buildConnectRequest(options: HttpProxySettings, dest: TcpEndpoint): Uint8Array;

package/proxy/http/_protocol.js

@@ -0,0 +1,31 @@
+import { base64, utf8 } from "@fuman/utils";
+function buildConnectRequest(options, dest) {
+  let addr = dest.address;
+  if (addr.includes(":")) {
+    addr = `[${addr}]`;
+  }
+  const host = `${addr}:${dest.port}`;
+  const lines = [
+    `CONNECT ${host} HTTP/1.1`,
+    `Host: ${host}`,
+    "User-Agent: @fuman/net",
+    "Proxy-Connection: Keep-Alive"
+  ];
+  if (options.user != null) {
+    let auth = options.user;
+    if (options.password != null) {
+      auth += `:${options.password}`;
+    }
+    lines.push(`Proxy-Authorization: Basic ${base64.encode(utf8.encoder.encode(auth))}`);
+  }
+  if (options.headers) {
+    for (const [key, value] of Object.entries(options.headers)) {
+      lines.push(`${key}: ${value}`);
+    }
+  }
+  lines.push("", "");
+  return utf8.encoder.encode(lines.join("\r\n"));
+}
+export {
+  buildConnectRequest
+};

package/proxy/http/connect.cjs

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const io = require("@fuman/io");
+const utils = require("@fuman/utils");
+const _protocol = require("./_protocol.cjs");
+const types = require("./types.cjs");
+const HTTP1_1_OK = /* @__PURE__ */ utils.utf8.encoder.encode("HTTP/1.1 200");
+const CR = /* @__PURE__ */ "\r".charCodeAt(0);
+const LF = /* @__PURE__ */ "\n".charCodeAt(0);
+async function performHttpProxyHandshake(reader, writer, proxy, destination) {
+  await writer.write(_protocol.buildConnectRequest(proxy, destination));
+  const res1 = await io.read.async.exactly(reader, 12);
+  if (!utils.typed.equal(res1, HTTP1_1_OK)) {
+    throw new types.HttpProxyConnectionError(
+      proxy,
+      `Invalid HTTP response: ${utils.utf8.decoder.decode(res1)}`
+    );
+  }
+  const buf = utils.u8.alloc(4);
+  while (true) {
+    await io.read.async.exactly(reader, buf);
+    const idx = utils.typed.indexOf(buf, CR);
+    if (idx !== -1) {
+      if (idx > 0) {
+        buf.copyWithin(0, idx);
+        await io.read.async.exactly(reader, buf.subarray(4 - idx));
+      }
+      if (buf[0] === CR && buf[1] === LF && buf[2] === CR && buf[3] === LF) {
+        break;
+      }
+    }
+  }
+}
+exports.performHttpProxyHandshake = performHttpProxyHandshake;

package/proxy/http/connect.d.ts

@@ -0,0 +1,4 @@
+import { TcpEndpoint } from '../../types.js';
+import { IReadable, IWritable } from '@fuman/io';
+import { HttpProxySettings } from './types.js';
+export declare function performHttpProxyHandshake(reader: IReadable, writer: IWritable, proxy: HttpProxySettings, destination: TcpEndpoint): Promise<void>;

package/proxy/http/connect.js

@@ -0,0 +1,34 @@
+import { read } from "@fuman/io";
+import { typed, utf8, u8 } from "@fuman/utils";
+import { buildConnectRequest } from "./_protocol.js";
+import { HttpProxyConnectionError } from "./types.js";
+const HTTP1_1_OK = /* @__PURE__ */ utf8.encoder.encode("HTTP/1.1 200");
+const CR = /* @__PURE__ */ "\r".charCodeAt(0);
+const LF = /* @__PURE__ */ "\n".charCodeAt(0);
+async function performHttpProxyHandshake(reader, writer, proxy, destination) {
+  await writer.write(buildConnectRequest(proxy, destination));
+  const res1 = await read.async.exactly(reader, 12);
+  if (!typed.equal(res1, HTTP1_1_OK)) {
+    throw new HttpProxyConnectionError(
+      proxy,
+      `Invalid HTTP response: ${utf8.decoder.decode(res1)}`
+    );
+  }
+  const buf = u8.alloc(4);
+  while (true) {
+    await read.async.exactly(reader, buf);
+    const idx = typed.indexOf(buf, CR);
+    if (idx !== -1) {
+      if (idx > 0) {
+        buf.copyWithin(0, idx);
+        await read.async.exactly(reader, buf.subarray(4 - idx));
+      }
+      if (buf[0] === CR && buf[1] === LF && buf[2] === CR && buf[3] === LF) {
+        break;
+      }
+    }
+  }
+}
+export {
+  performHttpProxyHandshake
+};

package/proxy/http/index.cjs

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const connect = require("./connect.cjs");
+function withHttpProxy(connect$1, proxy) {
+  return async (endpoint) => {
+    const conn = await connect$1({
+      address: proxy.host,
+      port: proxy.port
+    });
+    await connect.performHttpProxyHandshake(conn, conn, proxy, endpoint);
+    return conn;
+  };
+}
+exports.performHttpProxyHandshake = connect.performHttpProxyHandshake;
+exports.withHttpProxy = withHttpProxy;

package/proxy/http/index.d.ts

@@ -0,0 +1,5 @@
+import { ConnectFunction, ITcpConnection, TcpEndpoint } from '../../types.js';
+import { HttpProxySettings } from './types.js';
+export * from './connect.js';
+export * from './types.js';
+export declare function withHttpProxy<Connection extends ITcpConnection, Connect extends ConnectFunction<TcpEndpoint, Connection>>(connect: Connect, proxy: HttpProxySettings): Connect;

package/proxy/http/index.js

@@ -0,0 +1,15 @@
+import { performHttpProxyHandshake } from "./connect.js";
+function withHttpProxy(connect, proxy) {
+  return async (endpoint) => {
+    const conn = await connect({
+      address: proxy.host,
+      port: proxy.port
+    });
+    await performHttpProxyHandshake(conn, conn, proxy, endpoint);
+    return conn;
+  };
+}
+export {
+  performHttpProxyHandshake,
+  withHttpProxy
+};

package/proxy/http/types.cjs

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+class HttpProxyConnectionError extends Error {
+  proxy;
+  constructor(proxy, message) {
+    super(`Error while connecting to ${proxy.host}:${proxy.port}: ${message}`);
+    this.proxy = proxy;
+  }
+}
+exports.HttpProxyConnectionError = HttpProxyConnectionError;