@k13engineering/linux-fuse 0.0.1 → 0.0.3

package/dist/lib/message.js

@@ -0,0 +1,177 @@
+import { fuseInHeaderParser, fuseOutHeaderParser } from "./abi.js";
+
+
+/*type TParsedMessageFromKernel = {
+  header: {
+    opcode: bigint;
+    unique: bigint;
+    nodeid: bigint;
+    uid: bigint;
+    gid: bigint;
+    pid: bigint;
+  },
+  payload: Uint8Array
+};*/
+
+/*type TParsedMessageToKernel = {
+  header: {
+    error: bigint;
+    unique: bigint;
+  },
+  payload: Uint8Array
+};*/
+
+/*type TParseMessageFromKernelResult = {
+  error: Error;
+  parsedMessageFromKernel: undefined;
+} | {
+  error: undefined;
+  parsedMessageFromKernel: TParsedMessageFromKernel;
+};*/
+
+/*type TParseMessageToKernelResult = {
+  error: Error;
+  parsedMessageToKernel: undefined;
+} | {
+  error: undefined;
+  parsedMessageToKernel: TParsedMessageToKernel;
+};*/
+
+const createMessageFromKernelParser = () => {
+
+  const parseMessageFromKernel = ({ data }/*: { data: Uint8Array }*/)/*: TParseMessageFromKernelResult*/ => {
+
+    const inHeader = data.subarray(0, fuseInHeaderParser.size);
+    if (inHeader.length < fuseInHeaderParser.size) {
+      return {
+        error: Error(`invalid message: expected at least ${fuseInHeaderParser.size} bytes for header, got ${inHeader.length} bytes`),
+        parsedMessageFromKernel: undefined,
+      };
+    }
+
+    const parsedInHeader = fuseInHeaderParser.parse({
+      data: inHeader
+    });
+
+    const length = Number(parsedInHeader.len);
+
+
+    if (data.length !== length) {
+      return {
+        error: Error(`invalid message length: expected ${length} bytes, got ${data.length} bytes`),
+        parsedMessageFromKernel: undefined,
+      };
+    }
+
+    const payload = data.slice(fuseInHeaderParser.size, length);
+
+    return {
+      error: undefined,
+      parsedMessageFromKernel: {
+        header: {
+          opcode: parsedInHeader.opcode,
+          unique: parsedInHeader.unique,
+          nodeid: parsedInHeader.nodeid,
+          uid: parsedInHeader.uid,
+          gid: parsedInHeader.gid,
+          pid: parsedInHeader.pid,
+        },
+        payload
+      }
+    };
+  };
+
+  const formatMessageFromKernel = ({ parsedMessageFromKernel }/*: { parsedMessageFromKernel: TParsedMessageFromKernel }*/)/*: Uint8Array*/ => {
+    const messageBuffer = new Uint8Array(fuseInHeaderParser.size + parsedMessageFromKernel.payload.length);
+
+    const formattedHeader = fuseInHeaderParser.format({
+      value: {
+        opcode: parsedMessageFromKernel.header.opcode,
+        unique: parsedMessageFromKernel.header.unique,
+        nodeid: parsedMessageFromKernel.header.nodeid,
+        uid: parsedMessageFromKernel.header.uid,
+        gid: parsedMessageFromKernel.header.gid,
+        pid: parsedMessageFromKernel.header.pid,
+        len: BigInt(messageBuffer.length),
+        // TODO: what is this
+        total_extlen: 0n,
+        padding: 0n,
+      },
+    });
+
+    messageBuffer.set(formattedHeader, 0);
+    messageBuffer.set(parsedMessageFromKernel.payload, formattedHeader.length);
+
+    return messageBuffer;
+  };
+
+  return {
+    parseMessageFromKernel,
+    formatMessageFromKernel
+  };
+};
+
+const createMessageToKernelParser = () => {
+
+  const formatMessageToKernel = ({ parsedMessageToKernel }/*: { parsedMessageToKernel: TParsedMessageToKernel }*/)/*: Uint8Array*/ => {
+    const messageBuffer = new Uint8Array(fuseOutHeaderParser.size + parsedMessageToKernel.payload.length);
+
+    const formattedHeader = fuseOutHeaderParser.format({
+      value: {
+        error: parsedMessageToKernel.header.error,
+        unique: parsedMessageToKernel.header.unique,
+        len: BigInt(messageBuffer.length),
+      },
+    });
+
+    messageBuffer.set(formattedHeader, 0);
+    messageBuffer.set(parsedMessageToKernel.payload, formattedHeader.length);
+
+    return messageBuffer;
+  };
+
+  const parseMessageToKernel = ({ data }/*: { data: Uint8Array }*/)/*: TParseMessageToKernelResult*/ => {
+    const outHeader = data.subarray(0, fuseOutHeaderParser.size);
+
+    const parsedOutHeader = fuseOutHeaderParser.parse({
+      data: outHeader
+    });
+
+    const length = Number(parsedOutHeader.len);
+
+    if (data.length !== length) {
+      return {
+        error: Error(`invalid message length: expected ${length} bytes, got ${data.length} bytes`),
+        parsedMessageToKernel: undefined,
+      };
+    }
+
+    const payload = data.slice(fuseOutHeaderParser.size, length);
+
+    return {
+      error: undefined,
+      parsedMessageToKernel: {
+        header: {
+          error: parsedOutHeader.error,
+          unique: parsedOutHeader.unique,
+        },
+        payload
+      }
+    };
+  };
+
+  return {
+    formatMessageToKernel,
+    parseMessageToKernel
+  };
+};
+
+export {
+  createMessageFromKernelParser,
+  createMessageToKernelParser
+};
+
+/*export type {
+  TParsedMessageFromKernel,
+  TParsedMessageToKernel
+};*/

package/dist/lib/mount.d.ts

@@ -0,0 +1,33 @@
+type TRequiredFuseMountOptions = {
+    rootmode: number;
+    user_id: number;
+    group_id: number;
+};
+type TMountAttributes = {
+    MOUNT_ATTR_RDONLY?: boolean;
+    MOUNT_ATTR_NOSUID?: boolean;
+    MOUNT_ATTR_NODEV?: boolean;
+    MOUNT_ATTR_NOEXEC?: boolean;
+    MOUNT_ATTR_NOSYMFOLLOW?: boolean;
+    MOUNT_ATTR_NODIRATIME?: boolean;
+    customFlags?: bigint;
+};
+declare const mountAttributesToBitmask: ({ mountAttributes }: {
+    mountAttributes: TMountAttributes;
+}) => bigint;
+type TUnmountResult = {
+    error: Error | undefined;
+};
+declare const moveMount: ({ mountFd, newMountPoint, }: {
+    mountFd: number;
+    newMountPoint: string;
+}) => {
+    error: any;
+};
+declare const unmount: ({ mountPoint, force, detach }: {
+    mountPoint: string;
+    force: boolean;
+    detach: boolean;
+}) => TUnmountResult;
+export { mountAttributesToBitmask, moveMount, unmount, };
+export type { TRequiredFuseMountOptions, TMountAttributes, };

package/dist/lib/mount.js

@@ -0,0 +1,149 @@
+import {
+  AT_FCWD,
+  MOUNT_ATTR_NODEV,
+  MOUNT_ATTR_NODIRATIME,
+  MOUNT_ATTR_NOEXEC,
+  MOUNT_ATTR_NOSUID,
+  MOUNT_ATTR_NOSYMFOLLOW,
+  MOUNT_ATTR_RDONLY,
+  MOVE_MOUNT_F_EMPTY_PATH
+} from "./constants.js";
+import { move_mount, umount } from "./syscalls.js";
+
+/*type TRequiredFuseMountOptions = {
+  rootmode: number;
+  user_id: number;
+  group_id: number;
+};*/
+
+/*type TMountAttributes = {
+  MOUNT_ATTR_RDONLY?: boolean;
+  MOUNT_ATTR_NOSUID?: boolean;
+  MOUNT_ATTR_NODEV?: boolean;
+  MOUNT_ATTR_NOEXEC?: boolean;
+  MOUNT_ATTR_NOSYMFOLLOW?: boolean;
+  MOUNT_ATTR_NODIRATIME?: boolean;
+
+  customFlags?: bigint;
+};*/
+
+const knownMountAttributesBitmask = MOUNT_ATTR_RDONLY
+  | MOUNT_ATTR_NOSUID
+  | MOUNT_ATTR_NODEV
+  | MOUNT_ATTR_NOEXEC
+  | MOUNT_ATTR_NOSYMFOLLOW
+  | MOUNT_ATTR_NODIRATIME;
+
+// eslint-disable-next-line max-statements, complexity
+const mountAttributesToBitmask = ({ mountAttributes }/*: { mountAttributes: TMountAttributes }*/) => {
+  let bitmask = 0n;
+
+  if (mountAttributes.MOUNT_ATTR_RDONLY) {
+    bitmask |= MOUNT_ATTR_RDONLY;
+  }
+
+  if (mountAttributes.MOUNT_ATTR_NOSUID) {
+    bitmask |= MOUNT_ATTR_NOSUID;
+  }
+
+  if (mountAttributes.MOUNT_ATTR_NODEV) {
+    bitmask |= MOUNT_ATTR_NODEV;
+  }
+
+  if (mountAttributes.MOUNT_ATTR_NOEXEC) {
+    bitmask |= MOUNT_ATTR_NOEXEC;
+  }
+
+  if (mountAttributes.MOUNT_ATTR_NOSYMFOLLOW) {
+    bitmask |= MOUNT_ATTR_NOSYMFOLLOW;
+  }
+
+  if (mountAttributes.MOUNT_ATTR_NODIRATIME) {
+    bitmask |= MOUNT_ATTR_NODIRATIME;
+  }
+
+  if (mountAttributes.customFlags !== undefined) {
+
+    if ((mountAttributes.customFlags & knownMountAttributesBitmask) !== 0n) {
+      throw Error(`customFlags contains known mount attribute flags`);
+    }
+
+    bitmask |= mountAttributes.customFlags;
+  }
+
+  return bitmask;
+};
+
+
+/*type TUnmountResult = {
+  error: Error | undefined;
+};*/
+
+const MNT_FORCE = 1n;
+const MNT_DETACH = 2n;
+
+// for now, only export this simple variant for use with fuse
+const moveMount = ({
+  mountFd,
+  newMountPoint,
+}/*: {
+  mountFd: number;
+  newMountPoint: string;
+}*/) => {
+  const { errno: moveMountErrno } = move_mount({
+    fromFd: mountFd,
+    fromPath: "",
+    toFd: Number(AT_FCWD),
+    toPath: newMountPoint,
+    flags: MOVE_MOUNT_F_EMPTY_PATH,
+  });
+
+  if (moveMountErrno !== undefined) {
+    return {
+      error: Error(`move_mount syscall failed with errno ${moveMountErrno}`)
+    };
+  }
+
+  return {
+    error: undefined
+  };
+};
+
+const unmount = ({ mountPoint, force, detach }/*: { mountPoint: string, force: boolean, detach: boolean }*/)/*: TUnmountResult*/ => {
+
+  let flags = 0n;
+
+  if (force) {
+    flags |= MNT_FORCE;
+  }
+
+  if (detach) {
+    flags |= MNT_DETACH;
+  }
+
+  const { errno } = umount({
+    target: mountPoint,
+    flags,
+  });
+
+  if (errno !== undefined) {
+    return {
+      error: Error(`umount syscall failed with errno ${errno}`)
+    };
+  }
+
+  return {
+    error: undefined
+  };
+};
+
+export {
+  mountAttributesToBitmask,
+  moveMount,
+  unmount,
+};
+
+/*export type {
+  TRequiredFuseMountOptions,
+  TMountAttributes,
+};*/