pmcf 2.15.0 → 2.16.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pmcf",
-  "version": "2.15.0",
+  "version": "2.16.0",
   "publishConfig": {
     "access": "public"
   },

package/src/cli.mjs

@@ -1,8 +1,9 @@
 import { parseArgs } from "node:util";
+import { resolve } from "node:path";
 import { argv, cwd, env } from "node:process";
 import { Root } from "./module.mjs";
 
-export async function prepare(options={}) {  
+export async function prepare(options = {}) {
   const { values, positionals } = parseArgs({
     args: argv.slice(2),
     options: {
@@ -17,7 +18,7 @@ export async function prepare(options={}) {
         default: false
       },
       publish: {
-        type: "string",
+        type: "string"
       },
       root: {
         type: "string",
@@ -32,9 +33,13 @@ export async function prepare(options={}) {
     allowPositionals: true
   });
 
+  if (values.output) {
+    values.output = resolve(cwd(), values.output);
+  }
+
   const root = new Root(values.root);
 
   await root.loadAll();
-  
+
   return { root, options: values, args: positionals };
 }

package/src/dns-utils.mjs

@@ -1,10 +1,5 @@
-import {
-  asIterator,
-  decodeIPv6,
-  encodeIPv6,
-  isIPv6Address,
-  normalizeIPAddress
-} from "./utils.mjs";
+import { asIterator } from "./utils.mjs";
+import { decodeIPv4, decodeIPv6 } from "./ip.mjs";
 
 export function dnsFullName(name) {
   return name.endsWith(".") ? name : name + ".";
@@ -19,10 +14,10 @@ export function DNSRecord(key, type, ...values) {
       break;
 
     case "A":
-      values[0] = normalizeIPAddress(values[0]);
+      values[0] = decodeIPv4(values[0]);
       break;
     case "AAAA":
-      values[0] = decodeIPv6(encodeIPv6(values[0]));
+      values[0] = decodeIPv6(values[0]);
       break;
   }
 
@@ -59,22 +54,3 @@ export function dnsMergeParameters(a, b) {
     ])
   );
 }
-
-export function reverseAddress(address) {
-  if (isIPv6Address(address)) {
-    return normalizeIPAddress(address)
-      .replaceAll(":", "")
-      .split("")
-      .reverse()
-      .join(".");
-  }
-
-  return address.split(".").reverse().join(".");
-}
-
-export function reverseArpaAddress(address) {
-  return (
-    reverseAddress(address) +
-    (isIPv6Address(address) ? ".ip6.arpa" : ".in-addr.arpa")
-  );
-}

package/src/host-utils.mjs

@@ -1,13 +1,5 @@
-import {
-  writeFile,
-  mkdir,
-  copyFile,
-  glob,
-  chmod,
-  stat
-} from "node:fs/promises";
+import { writeFile, mkdir } from "node:fs/promises";
 import { join } from "node:path";
-import { FileContentProvider } from "npm-pkgbuild";
 import { writeLines, sectionLines } from "../src/utils.mjs";
 import { addHook } from "./hooks.mjs";
 

package/src/host.mjs

@@ -6,16 +6,14 @@ import {
   networkProperties,
   networkAddressProperties
 } from "./network-support.mjs";
+import { asArray, domainFromDominName, domainName } from "./utils.mjs";
 import {
-  asArray,
-  isIPv4Address,
-  isIPv6Address,
-  normalizeIPAddress,
+  isIPv4,
+  isIPv6,
   formatCIDR,
   hasWellKnownSubnet,
-  domainFromDominName,
-  domainName
-} from "./utils.mjs";
+  normalizeIP
+} from "./ip.mjs";
 import { objectFilter } from "./filter.mjs";
 import { addType, types } from "./types.mjs";
 import { loadHooks } from "./hooks.mjs";
@@ -582,7 +580,7 @@ export class NetworkInterface extends Base {
   set ipAddresses(value) {
     for (const address of asArray(value)) {
       this._ipAddresses.set(
-        normalizeIPAddress(address),
+        normalizeIP(address),
         this.addSubnet(address)
       );
     }
@@ -593,11 +591,11 @@ export class NetworkInterface extends Base {
   }
 
   get rawIPv4Address() {
-    return this.rawAddresses.filter(a => isIPv4Address(a))[0];
+    return this.rawAddresses.filter(a => isIPv4(a))[0];
   }
 
   get rawIPv6Address() {
-    return this.rawAddresses.filter(a => isIPv6Address(a))[0];
+    return this.rawAddresses.filter(a => isIPv6(a))[0];
   }
 
   get rawAddresses() {
@@ -616,13 +614,13 @@ export class NetworkInterface extends Base {
 
   get rawIPv4Addresses() {
     return [...this.ipAddresses]
-      .filter(([address]) => isIPv4Address(address))
+      .filter(([address]) => isIPv4(address))
       .map(([address]) => address);
   }
 
   get rawIPv6Addresses() {
     return [...this.ipAddresses]
-      .filter(([address]) => isIPv6Address(address))
+      .filter(([address]) => isIPv6(address))
       .map(([address]) => address);
   }
 

package/src/ip.mjs

@@ -0,0 +1,298 @@
+const ipv4 = {
+  factory: Uint8Array,
+  normalize(address) {
+    return address;
+  },
+  separator: ".",
+  bitLength: 32,
+  byteLength: 4,
+  segments: 4,
+  segmentLength: 8,
+  segmentMask: 0xffn,
+  mask: 0xffffffffn,
+  base: 10
+};
+
+const ipv6 = {
+  factory: Uint16Array,
+  normalize(address) {
+    const parts = address.split(":");
+    const i = parts.indexOf("");
+    if (i >= 0) {
+      parts.splice(i, 1, ..."0".repeat(9 - parts.length));
+    }
+    return parts /*.map(s => s.padStart(4, "0"))*/
+      .join(":");
+  },
+  separator: ":",
+  compressor: "::",
+  bitLength: 128,
+  byteLength: 8,
+  segments: 8,
+  segmentLength: 16,
+  segmentMask: 0xffffn,
+  mask: 0xffffffffffffffffffffffffffffffffn,
+  base: 16
+};
+
+export function IPV4(...args) {
+  return _create(ipv4, ...args);
+}
+
+export function IPV6(...args) {
+  return _create(ipv6, ...args);
+}
+
+function _create(definition, ...args) {
+  if (args.length === 1) {
+    return _encode(definition, args[0]);
+  }
+  return new definition.factory(args);
+}
+
+export function encodeIP(address) {
+  return _encode(isIPv4(address) ? ipv4 : ipv6, address);
+}
+
+export function encodeIPv6(address) {
+  return _encode(ipv6, address);
+}
+
+export function encodeIPv4(address) {
+  return _encode(ipv4, address);
+}
+
+export function _encode(definition, address) {
+  switch (typeof address) {
+    case "string":
+      const res = new definition.factory(definition.segments);
+
+      let i = 0;
+      for (const segment of definition
+        .normalize(address)
+        .split(definition.separator)) {
+        res[i++] = parseInt(segment, definition.base);
+      }
+
+      return res;
+
+    case "object":
+      if (
+        address instanceof definition.factory &&
+        address.length === definition.byteLength
+      ) {
+        return address;
+      }
+  }
+}
+
+function _decode(definition, address, length) {
+  switch (typeof address) {
+    case "string":
+      if (length === undefined) {
+        return address;
+      }
+      address = _encode(definition, address);
+      break;
+    case "bigint":
+      address = _encodeBigInt(definition, address);
+  }
+
+  let result = "";
+  let compressed = 0;
+  let word;
+  let last = address?.length;
+
+  if (length !== undefined) {
+    length /= definition.segmentLength;
+
+    if (length < last) {
+      last = length;
+    }
+  }
+  for (let i = 0, j = 0; i < last; j = j + 1, i = j) {
+    for (; j < last; j++) {
+      word = address[j];
+
+      if (word !== 0 || !definition.compressor || compressed > 0) {
+        break;
+      }
+    }
+
+    if (j > i + 1) {
+      compressed++;
+      result += definition.compressor;
+    } else {
+      if (result.length > 0) {
+        result += definition.separator;
+      }
+    }
+
+    if (j < last) {
+      result += word.toString(definition.base);
+    }
+  }
+
+  return result;
+}
+
+export function decodeIPv6(address, length) {
+  return _decode(ipv6, address, length);
+}
+
+export function decodeIPv4(address, length) {
+  return _decode(ipv4, address, length);
+}
+
+export function decodeIP(address, length) {
+  return _decode(isIPv4(address) ? ipv4 : ipv6, address, length);
+}
+
+export function isIPv4(address) {
+  return _is(ipv4, address);
+}
+
+export function isIPv6(address) {
+  return _is(ipv6, address);
+}
+
+export function _is(definition, address) {
+  switch (typeof address) {
+    case "string":
+      return address.indexOf(definition.separator) >= 0;
+
+    case "object":
+      return (
+        address instanceof definition.factory &&
+        address.length === definition.byteLength
+      );
+  }
+
+  return false;
+}
+
+export function asBigInt(address) {
+  return _asBigInt(isIPv4(address) ? ipv4 : ipv6, address);
+}
+
+function _asBigInt(definition, address) {
+  if (typeof address === "bigint") {
+    return address;
+  }
+
+  const ea = _encode(definition, address);
+
+  let result = 0n;
+
+  for (let i = 0; i < ea.length; i++) {
+    result = result << BigInt(definition.segmentLength);
+    result += BigInt(ea[i]);
+  }
+
+  return result;
+}
+
+function _encodeBigInt(definition, address) {
+  const segments = [];
+
+  for (let i = 0; i < definition.segments; i++) {
+    segments.push(Number(address & definition.segmentMask));
+    address >>= BigInt(definition.segmentLength);
+  }
+
+  return new definition.factory(segments.reverse());
+}
+
+export function prefixIP(address, length) {
+  const definition = isIPv4(address) ? ipv4 : ipv6;
+  return _decode(definition, _prefix(definition, address, length));
+}
+
+export function _prefix(definition, address, length) {
+  return (
+    _asBigInt(definition, address) &
+    (definition.mask << BigInt(definition.bitLength - length))
+  );
+}
+
+export function normalizeCIDR(address) {
+  let [prefix, prefixLength] = address.split(/\//);
+  let longPrefix;
+
+  if (!prefixLength && isLinkLocal(address)) {
+    prefix = "fe80::";
+    longPrefix = prefix;
+    prefixLength = 64;
+  } else {
+    prefixLength = parseInt(prefixLength);
+
+    const definition = isIPv6(prefix) ? ipv6 : ipv4;
+    let n;
+
+    if (prefixLength) {
+      n = _prefix(definition, prefix, prefixLength);
+    } else {
+      n = _encode(definition, prefix);
+
+      if (isLocalhost(n)) {
+        prefixLength = definition === ipv6 ? 128 : 8;
+      } else {
+        return {};
+      }
+    }
+    prefix = _decode(definition, n, prefixLength);
+    longPrefix = _decode(definition, n);
+  }
+
+  return { longPrefix, prefix, prefixLength, cidr: `${prefix}/${prefixLength}` };
+}
+
+export function formatCIDR(address, subnet) {
+  return subnet ? `${address}/${subnet.prefixLength}` : address;
+}
+
+export function normalizeIP(address) {
+  return decodeIP(encodeIP(address));
+}
+
+export function reverseArpa(address) {
+  if (isIPv6(address)) {
+    const ea = encodeIPv6(address);
+    let result = [];
+    for (let i = 0; i < ea.length; i++) {
+      const v = ea[i];
+      for (let i = 0; i < 4; i++) {
+        result.push(((v >> (12 - 4 * i)) & 0x000f).toString(16));
+      }
+    }
+    return result.reverse().join(".") + ".ip6.arpa";
+  }
+
+  return address.split(".").reverse().join(".") + ".in-addr.arpa";
+}
+
+export function isLocalhost(address) {
+  const eaddr = encodeIP(address);
+
+  if (!eaddr) {
+    return false;
+  }
+
+  const str = eaddr.toString();
+
+  return str === IPV4_LOCALHOST.toString() || str === IPV6_LOCALHOST.toString();
+}
+
+export function isLinkLocal(address) {
+  const eaddr = encodeIP(address);
+  return eaddr[0] === 0xfe80;
+}
+
+export function hasWellKnownSubnet(address) {
+  return isLocalhost(address) || isLinkLocal(address);
+}
+
+export const IPV6_LINK_LOCAL_BROADCAST = _encode(ipv6, "ff02::1");
+export const IPV6_ROUTER_BROADCAST = _encode(ipv6, "ff02::2");
+export const IPV4_LOCALHOST = _encode(ipv4, "127.0.0.1");
+export const IPV6_LOCALHOST = _encode(ipv6, "::1");

package/src/owner.mjs

@@ -1,8 +1,8 @@
-import { asIterator, normalizeCIDR } from "./utils.mjs";
+import { asIterator } from "./utils.mjs";
 import { Base } from "./base.mjs";
 import { Subnet } from "./subnet.mjs";
 import { addType, types } from "./types.mjs";
-
+import { normalizeCIDR } from "./ip.mjs";
 const OwnerTypeDefinition = {
   name: "owner",
   owners: ["location", "owner", "root"],

package/src/service.mjs

@@ -1,7 +1,9 @@
 import { Base } from "./base.mjs";
 import { addType } from "./types.mjs";
-import { asArray, isLocalhost } from "./utils.mjs";
+import { objectFilter } from "./filter.mjs";
+import { asArray } from "./utils.mjs";
 import { networkAddressProperties } from "./network-support.mjs";
+import { isLocalhost } from "./ip.mjs";
 import {
   DNSRecord,
   dnsFullName,
@@ -59,6 +61,31 @@ const ServiceTypes = {
   }
 };
 
+export const endpointProperties = {
+  port: { type: "number", collection: false, writeable: true },
+  protocol: {
+    type: "string",
+    collection: false,
+    writeable: true,
+    values: ["tcp", "udp"]
+  },
+  type: { type: "string", collection: false, writeable: true },
+  tls: {
+    type: "boolean",
+    collection: false,
+    writeable: false,
+    default: false
+  }
+};
+
+export const EndpointTypeDefinition = {
+  name: "endpoint",
+  owners: ["service"],
+  priority: 0.4,
+  specializations: {},
+  properties: endpointProperties
+};
+
 export const ServiceTypeDefinition = {
   name: "service",
   owners: ["host", "cluster"],
@@ -78,23 +105,10 @@ export const ServiceTypeDefinition = {
   },
   properties: {
     ...networkAddressProperties,
+    ...endpointProperties,
     ipAddresses: { type: "string", collection: true, writeable: true },
-    port: { type: "number", collection: false, writeable: true },
-    protocol: {
-      type: "string",
-      collection: false,
-      writeable: true,
-      values: ["tcp", "udp"]
-    },
     alias: { type: "string", collection: false, writeable: true },
-    type: { type: "string", collection: false, writeable: true },
     weight: { type: "number", collection: false, writeable: true, default: 1 },
-    tls: {
-      type: "string",
-      collection: false,
-      writeable: false,
-      default: false
-    },
     systemd: { type: "string", collection: true, writeable: true }
   }
 };
@@ -191,6 +205,10 @@ export class Service extends Base {
       .flat();
   }
 
+  *findEndpoints(filter) {
+    yield* objectFilter(EndpointTypeDefinition, this.endpoints, filter);
+  }
+
   set alias(value) {
     this._alias = value;
   }

package/src/services/dhcp.mjs

@@ -7,7 +7,8 @@ import {
   serviceEndpoints
 } from "../service.mjs";
 import { addType } from "../types.mjs";
-import { writeLines, isIPv4Address, isIPv6Address } from "../utils.mjs";
+import { writeLines } from "../utils.mjs";
+import { isIPv4, isIPv6 } from "../ip.mjs";
 
 const DHCPServiceTypeDefinition = {
   name: "dhcp",
@@ -74,7 +75,7 @@ export class DHCPService extends Service {
     const dnsServerEndpoints = serviceEndpoints(network, {
       type: "dns",
       priority: "<10"
-    });
+    }).filter(endpoint => endpoint.networkInterface.kind !== "loopback");
 
     const packageData = {
       dir,
@@ -144,9 +145,11 @@ export class DHCPService extends Service {
       domains.map(domain => {
         return {
           name: domain,
-          "dns-servers": dnsServerEndpoints.map(endpoint => {
-            return { "ip-address": endpoint.rawAddress };
-          })
+          "dns-servers": dnsServerEndpoints
+            .filter(endpoint => isIPv4(endpoint.rawAddress))
+            .map(endpoint => {
+              return { "ip-address": endpoint.rawAddress };
+            })
         };
       });
 
@@ -227,7 +230,7 @@ export class DHCPService extends Service {
       Dhcp4: {
         ...commonConfig,
         "interfaces-config": {
-          interfaces: listenInterfaces(isIPv4Address)
+          interfaces: listenInterfaces(isIPv4)
         },
         "multi-threading": {
           "enable-multi-threading": false
@@ -240,6 +243,7 @@ export class DHCPService extends Service {
           {
             name: "domain-name-servers",
             data: dnsServerEndpoints
+              .filter(endpoint => isIPv4(endpoint.rawAddress))
               .map(endpoint => endpoint.rawAddress)
               .join(",")
           },
@@ -272,7 +276,7 @@ export class DHCPService extends Service {
       Dhcp6: {
         ...commonConfig,
         "interfaces-config": {
-          interfaces: listenInterfaces(isIPv6Address)
+          interfaces: listenInterfaces(isIPv6)
         },
         "control-socket": {
           "socket-type": "unix",
@@ -282,7 +286,10 @@ export class DHCPService extends Service {
         "option-data": [
           {
             name: "dns-servers",
-            data: "2001:db8:2::45, 2001:db8:2::100"
+            data: dnsServerEndpoints
+              .filter(endpoint => isIPv6(endpoint.rawAddress))
+              .map(endpoint => endpoint.rawAddress)
+              .join(",")
           }
         ],
         subnet6: [
@@ -301,12 +308,6 @@ export class DHCPService extends Service {
                 "delegated-len": 64
               }
             ],
-            "option-data": [
-              {
-                name: "dns-servers",
-                data: "2001:db8:2::dead:beef, 2001:db8:2::cafe:babe"
-              }
-            ],
             reservations: [
               {
                 duid: "01:02:03:04:05:0A:0B:0C:0D:0E",