@k13engineering/linux-fuse 0.0.1 → 0.0.2

package/dist/lib/server.d.ts

@@ -0,0 +1,18 @@
+import { type TFuseRequest, type TFuseResponse } from "./protocol.js";
+type TRequestHandler = {
+    handleRequest: (args: {
+        request: TFuseRequest;
+    }) => Promise<TFuseResponse | undefined>;
+};
+declare const createFuseServer: ({ requestHandler, sendMessageToKernel, }: {
+    requestHandler: TRequestHandler;
+    sendMessageToKernel: ({ rawMessageToKernel }: {
+        rawMessageToKernel: Uint8Array;
+    }) => void;
+}) => {
+    processRequest: ({ rawIncomingRequest }: {
+        rawIncomingRequest: Uint8Array;
+    }) => void;
+};
+export { createFuseServer };
+export type { TRequestHandler, };

package/dist/lib/server.js

@@ -0,0 +1,73 @@
+import {
+  createMessageFromKernelParser,
+  createMessageToKernelParser,
+  /*type TParsedMessageToKernel
+*/} from "./message.js";
+import {
+  createMessageFromKernelInterpreter,
+  createMessageToKernelInterpreter,
+  /*type TFuseRequest,
+  *//*type TFuseResponse
+*/} from "./protocol.js";
+
+/*type TRequestHandler = {
+  handleRequest: (args: { request: TFuseRequest }) => Promise<TFuseResponse | undefined>;
+};*/
+
+const createFuseServer = ({
+  requestHandler,
+  sendMessageToKernel,
+}/*: {
+  requestHandler: TRequestHandler;
+  sendMessageToKernel: ({ rawMessageToKernel }: { rawMessageToKernel: Uint8Array }) => void;
+}*/) => {
+  const messageFromKernelInterpreter = createMessageFromKernelInterpreter();
+  const messageToKernelInterpreter = createMessageToKernelInterpreter();
+
+  const messageFromKernelParser = createMessageFromKernelParser();
+  const messageToKernelParser = createMessageToKernelParser();
+
+  const processRequest = ({ rawIncomingRequest }/*: { rawIncomingRequest: Uint8Array }*/) => {
+
+    const { error: parseError, parsedMessageFromKernel } = messageFromKernelParser.parseMessageFromKernel({ data: rawIncomingRequest });
+    if (parseError !== undefined) {
+      throw Error("not implemented yet", { cause: parseError });
+    }
+
+    const { error: interpretError, interpreted } = messageFromKernelInterpreter.interpretMessageFromKernel({ parsedMessageFromKernel });
+    if (interpretError !== undefined) {
+      throw Error("not implemented yet", { cause: interpretError });
+    }
+
+    requestHandler.handleRequest({ request: interpreted }).then((response) => {
+      if (response !== undefined) {
+
+        let encoded/*: TParsedMessageToKernel*/;
+
+        try {
+          encoded = messageToKernelInterpreter.encodeMessageToKernel({ response });
+        } catch (ex) {
+          throw Error(`failed to encode response for opcode ${response.forOpcode}, unique ${response.unique}`, { cause: ex });
+        }
+
+        const rawMessageToKernel = messageToKernelParser.formatMessageToKernel({ parsedMessageToKernel: encoded });
+
+        sendMessageToKernel({
+          rawMessageToKernel
+        });
+      }
+    });
+  };
+
+  return {
+    processRequest
+  };
+};
+
+export {
+  createFuseServer
+};
+
+/*export type {
+  TRequestHandler,
+};*/

package/dist/lib/syscalls.d.ts

@@ -0,0 +1,73 @@
+declare const read: ({ fd, buffer }: {
+    fd: number;
+    buffer: Uint8Array;
+}) => any;
+declare const write: ({ fd, buffer }: {
+    fd: number;
+    buffer: Uint8Array;
+}) => any;
+type TFsopenResult = {
+    errno: number;
+    fsfd: undefined;
+} | {
+    errno: undefined;
+    fsfd: number;
+};
+declare const fsopen: ({ fileSystemName, flags, }: {
+    fileSystemName: string;
+    flags: bigint;
+}) => TFsopenResult;
+type TFsConfigResult = {
+    errno: number;
+} | {
+    errno: undefined;
+};
+declare const fsconfig: ({ fd, command, key, value, auxiliaryValue, }: {
+    fd: number;
+    command: bigint;
+    key: string | undefined;
+    value: string | Uint8Array | undefined;
+    auxiliaryValue: number;
+}) => TFsConfigResult;
+type TFsMountResult = {
+    errno: number;
+    mountFd: undefined;
+} | {
+    errno: undefined;
+    mountFd: number;
+};
+declare const fsmount: ({ fd, flags, mountAttributesBitmask, }: {
+    fd: number;
+    flags: bigint;
+    mountAttributesBitmask: bigint;
+}) => TFsMountResult;
+type TMoveMountResult = {
+    errno: number;
+} | {
+    errno: undefined;
+};
+type TFchdirResult = {
+    errno: number;
+} | {
+    errno: undefined;
+};
+declare const move_mount: ({ fromFd, fromPath, toFd, toPath, flags, }: {
+    fromFd: number;
+    fromPath?: string;
+    toFd: number;
+    toPath: string | undefined;
+    flags: bigint;
+}) => TMoveMountResult;
+type TUmountResult = {
+    errno: number;
+} | {
+    errno: undefined;
+};
+declare const umount: ({ target, flags, }: {
+    target: string;
+    flags: bigint;
+}) => TUmountResult;
+declare const fchdir: ({ fd, }: {
+    fd: number;
+}) => TFchdirResult;
+export { read, write, fsopen, fsconfig, fsmount, move_mount, fchdir, umount };

package/dist/lib/syscalls.js

@@ -0,0 +1,275 @@
+import { syscall, syscallNumbers } from "syscall-napi";
+import { toCString } from "./abi.js";
+
+const read = ({
+  fd,
+  buffer
+}/*: {
+  fd: number;
+  buffer: Uint8Array;
+}*/) => {
+
+  return syscall({
+    syscallNumber: syscallNumbers.read,
+    args: [BigInt(fd), buffer, BigInt(buffer.length)]
+  });
+};
+
+const write = ({
+  fd,
+  buffer
+}/*: {
+  fd: number;
+  buffer: Uint8Array;
+}*/) => {
+
+  return syscall({
+    syscallNumber: syscallNumbers.write,
+    args: [BigInt(fd), buffer, BigInt(buffer.length)]
+  });
+};
+
+const toOptionalCStringArg = ({ value }/*: { value: string | undefined }*/) => {
+  if (value === undefined) {
+    return 0n;
+  }
+
+  return toCString(value);
+};
+
+const toOptionalPointerArg = ({ value } /*: { value: string | Uint8Array | undefined }*/) => {
+  if (value === undefined) {
+    return 0n;
+  }
+
+  if (typeof value === "string") {
+    return toCString(value);
+  }
+
+  return value;
+};
+
+/*type TFsopenResult = {
+  errno: number;
+  fsfd: undefined;
+} | {
+  errno: undefined;
+  fsfd: number;
+};*/
+
+const fsopen = ({
+  fileSystemName,
+  flags,
+}/*: {
+  fileSystemName: string;
+  flags: bigint;
+}*/)/*: TFsopenResult*/ => {
+  const { errno, ret } = syscall({
+    syscallNumber: syscallNumbers.fsopen,
+    args: [
+      toCString(fileSystemName),
+      flags,
+    ],
+  });
+
+  if (errno !== undefined) {
+    return {
+      errno,
+      fsfd: undefined,
+    };
+  }
+
+  return {
+    errno: undefined,
+    fsfd: Number(ret),
+  };
+};
+
+/*type TFsConfigResult = {
+  errno: number;
+} | {
+  errno: undefined;
+};*/
+
+const fsconfig = ({
+  fd,
+  command,
+  key,
+  value,
+  auxiliaryValue,
+}/*: {
+  fd: number;
+  command: bigint;
+  key: string | undefined;
+  value: string | Uint8Array | undefined;
+  auxiliaryValue: number;
+}*/)/*: TFsConfigResult*/ => {
+  const { errno } = syscall({
+    syscallNumber: syscallNumbers.fsconfig,
+    args: [
+      BigInt(fd),
+      command,
+      toOptionalCStringArg({ value: key }),
+      toOptionalPointerArg({ value }),
+      BigInt(auxiliaryValue),
+    ],
+  });
+
+  if (errno !== undefined) {
+    throw Error(`fsconfig syscall failed with errno ${errno}`);
+  }
+
+  return {
+    errno: undefined,
+  };
+};
+
+/*type TFsMountResult = {
+  errno: number;
+  mountFd: undefined;
+} | {
+  errno: undefined;
+  mountFd: number;
+};*/
+
+const fsmount = ({
+  fd,
+  flags,
+  mountAttributesBitmask,
+}/*: {
+  fd: number;
+  flags: bigint;
+  mountAttributesBitmask: bigint;
+}*/)/*: TFsMountResult*/ => {
+  const { errno, ret } = syscall({
+    syscallNumber: syscallNumbers.fsmount,
+    args: [
+      BigInt(fd),
+      flags,
+      mountAttributesBitmask,
+    ],
+  });
+
+  if (errno !== undefined) {
+    return {
+      errno,
+      mountFd: undefined,
+    };
+  }
+
+  return {
+    errno: undefined,
+    mountFd: Number(ret),
+  };
+};
+
+/*type TMoveMountResult = {
+  errno: number;
+} | {
+  errno: undefined;
+};*/
+
+/*type TFchdirResult = {
+  errno: number;
+} | {
+  errno: undefined;
+};*/
+
+const move_mount = ({
+  fromFd,
+  fromPath,
+  toFd,
+  toPath,
+  flags,
+}/*: {
+  fromFd: number;
+  fromPath?: string;
+  toFd: number;
+  toPath: string | undefined;
+  flags: bigint;
+}*/)/*: TMoveMountResult*/ => {
+  const { errno } = syscall({
+    syscallNumber: syscallNumbers.move_mount,
+    args: [
+      BigInt(fromFd),
+      toOptionalCStringArg({ value: fromPath }),
+      BigInt(toFd),
+      toOptionalCStringArg({ value: toPath }),
+      flags,
+    ],
+  });
+
+  if (errno !== undefined) {
+    return {
+      errno,
+    };
+  }
+
+  return {
+    errno: undefined,
+  };
+};
+
+/*type TUmountResult = {
+  errno: number;
+} | {
+  errno: undefined;
+};*/
+
+const umount = ({
+  target,
+  flags,
+}/*: {
+  target: string;
+  flags: bigint;
+}*/)/*: TUmountResult*/ => {
+  const { errno } = syscall({
+    syscallNumber: syscallNumbers.umount2,
+    args: [
+      toCString(target),
+      flags,
+    ],
+  });
+
+  if (errno !== undefined) {
+    return {
+      errno,
+    };
+  }
+
+  return {
+    errno: undefined,
+  };
+};
+
+const fchdir = ({
+  fd,
+}/*: {
+  fd: number;
+}*/)/*: TFchdirResult*/ => {
+  const { errno } = syscall({
+    syscallNumber: syscallNumbers.fchdir,
+    args: [BigInt(fd)],
+  });
+
+  if (errno !== undefined) {
+    return {
+      errno,
+    };
+  }
+
+  return {
+    errno: undefined,
+  };
+};
+
+export {
+  read,
+  write,
+  fsopen,
+  fsconfig,
+  fsmount,
+  move_mount,
+  fchdir,
+  umount
+};

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.0.1",
+  "version": "0.0.2",
   "name": "@k13engineering/linux-fuse",
   "type": "module",
   "description": "linux-fuse",