@k13engineering/linux-fuse 0.0.6 → 0.1.0

package/dist/lib/server.js

@@ -1,3 +1,4 @@
+import { ENOSYS, opcode } from "./constants.js";
 import {
   createMessageFromKernelParser,
   createMessageToKernelParser,
@@ -10,6 +11,10 @@ import {
   *//*type TFuseResponse
 */} from "./protocol.js";
 
+const knownOpcodes = new Set(Object.values(opcode).map((value) => {
+  return BigInt(value);
+}));
+
 /*type TRequestHandler = {
   handleRequest: (args: { request: TFuseRequest }) => Promise<TFuseResponse | undefined>;
 };*/
@@ -27,6 +32,26 @@ const createFuseServer = ({
   const messageFromKernelParser = createMessageFromKernelParser();
   const messageToKernelParser = createMessageToKernelParser();
 
+  const replyNotImplemented = ({ unique }/*: { unique: bigint }*/) => {
+    sendMessageToKernel({
+      rawMessageToKernel: messageToKernelParser.formatMessageToKernel({
+        parsedMessageToKernel: {
+          header: {
+            unique,
+            error: BigInt(-ENOSYS),
+          },
+          payload: new Uint8Array(0),
+        },
+      }),
+    });
+  };
+
+  const observeResponse = ({ response }/*: { response: TFuseResponse }*/) => {
+    if (response.forOpcode === "INIT" && response.errorCode === undefined) {
+      messageFromKernelInterpreter.applyInitResult({ result: response.result });
+    }
+  };
+
   const processRequest = ({ rawIncomingRequest }/*: { rawIncomingRequest: Uint8Array }*/) => {
 
     const { error: parseError, parsedMessageFromKernel } = messageFromKernelParser.parseMessageFromKernel({ data: rawIncomingRequest });
@@ -34,6 +59,12 @@ const createFuseServer = ({
       throw Error("not implemented yet", { cause: parseError });
     }
 
+    if (!knownOpcodes.has(parsedMessageFromKernel.header.opcode)) {
+      // newer kernels may send opcodes this package does not know yet, ENOSYS makes them fall back
+      replyNotImplemented({ unique: parsedMessageFromKernel.header.unique });
+      return;
+    }
+
     const { error: interpretError, interpreted } = messageFromKernelInterpreter.interpretMessageFromKernel({ parsedMessageFromKernel });
     if (interpretError !== undefined) {
       throw Error("not implemented yet", { cause: interpretError });
@@ -42,6 +73,8 @@ const createFuseServer = ({
     requestHandler.handleRequest({ request: interpreted }).then((response) => {
       if (response !== undefined) {
 
+        observeResponse({ response });
+
         let encoded/*: TParsedMessageToKernel*/;
 
         try {

package/dist/lib/syscalls.d.ts

@@ -1,11 +1,16 @@
-declare const read: ({ fd, buffer }: {
-    fd: number;
-    buffer: Uint8Array;
-}) => any;
-declare const write: ({ fd, buffer }: {
+import type { TKernel } from "./kernel.js";
+type TOpenatResult = {
+    errno: number;
+    fd: undefined;
+} | {
+    errno: undefined;
     fd: number;
-    buffer: Uint8Array;
-}) => any;
+};
+type TCloseResult = {
+    errno: number;
+} | {
+    errno: undefined;
+};
 type TFsopenResult = {
     errno: number;
     fsfd: undefined;
@@ -13,22 +18,11 @@ type TFsopenResult = {
     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;
@@ -36,11 +30,6 @@ type TFsMountResult = {
     errno: undefined;
     mountFd: number;
 };
-declare const fsmount: ({ fd, flags, mountAttributesBitmask, }: {
-    fd: number;
-    flags: bigint;
-    mountAttributesBitmask: bigint;
-}) => TFsMountResult;
 type TMoveMountResult = {
     errno: number;
 } | {
@@ -51,23 +40,62 @@ type TFchdirResult = {
 } | {
     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 };
+declare const createSyscalls: ({ kernel }: {
+    kernel: TKernel;
+}) => {
+    read: ({ fd, buffer }: {
+        fd: number;
+        buffer: Uint8Array;
+    }) => any;
+    write: ({ fd, buffer }: {
+        fd: number;
+        buffer: Uint8Array;
+    }) => any;
+    openat: ({ dirFd, path, flags, mode, }: {
+        dirFd: number;
+        path: string;
+        flags: number;
+        mode: number;
+    }) => TOpenatResult;
+    close: ({ fd }: {
+        fd: number;
+    }) => TCloseResult;
+    fsopen: ({ fileSystemName, flags, }: {
+        fileSystemName: string;
+        flags: bigint;
+    }) => TFsopenResult;
+    fsconfig: ({ fd, command, key, value, auxiliaryValue, }: {
+        fd: number;
+        command: bigint;
+        key: string | undefined;
+        value: string | Uint8Array | undefined;
+        auxiliaryValue: number;
+    }) => TFsConfigResult;
+    fsmount: ({ fd, flags, mountAttributesBitmask, }: {
+        fd: number;
+        flags: bigint;
+        mountAttributesBitmask: bigint;
+    }) => TFsMountResult;
+    move_mount: ({ fromFd, fromPath, toFd, toPath, flags, }: {
+        fromFd: number;
+        fromPath?: string;
+        toFd: number;
+        toPath: string | undefined;
+        flags: bigint;
+    }) => TMoveMountResult;
+    umount: ({ target, flags, }: {
+        target: string;
+        flags: bigint;
+    }) => TUmountResult;
+    fchdir: ({ fd, }: {
+        fd: number;
+    }) => TFchdirResult;
+};
+type TSyscalls = ReturnType<typeof createSyscalls>;
+export { createSyscalls, };
+export type { TSyscalls, };