@k13engineering/linux-fuse 0.0.1 → 0.0.2

package/dist/lib/convenience.js

@@ -0,0 +1,463 @@
+/*import type { TFuseRequest, TFuseResponse } from "./protocol.ts";*/
+/*import type { TRequestHandler } from "./server.ts";*/
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+/*type DistributiveOmit<T, K extends PropertyKey> = T extends any ? Omit<T, K> : never;*/
+
+/*type TConvenienceRequest<T extends string> = Extract<TFuseRequest, { opcode: T }>;*/
+/*type TConvenienceResponse<T extends string> = DistributiveOmit<Extract<TFuseResponse, { forOpcode: T }>, "unique">;*/
+
+/*type TFuseServerInterface = {
+  init: (req: TConvenienceRequest<"INIT">) => Promise<TConvenienceResponse<"INIT">>;
+  forget: (req: TConvenienceRequest<"FORGET">) => Promise<void>;
+  batchForget: (req: TConvenienceRequest<"BATCH_FORGET">) => Promise<void>;
+  getattr: (req: Extract<TConvenienceRequest<"GETATTR">, { getattrMode: "node" }>) => Promise<TConvenienceResponse<"GETATTR">>;
+  fgetattr: (req: Extract<TConvenienceRequest<"GETATTR">, { getattrMode: "fileHandle" }>) => Promise<TConvenienceResponse<"GETATTR">>;
+  setattr: (req: TConvenienceRequest<"SETATTR">) => Promise<TConvenienceResponse<"SETATTR">>;
+  listxattr: (req: TConvenienceRequest<"LISTXATTR">) => Promise<TConvenienceResponse<"LISTXATTR">>;
+  getxattr: (req: TConvenienceRequest<"GETXATTR">) => Promise<TConvenienceResponse<"GETXATTR">>;
+  readlink: (req: TConvenienceRequest<"READLINK">) => Promise<TConvenienceResponse<"READLINK">>;
+  symlink: (req: TConvenienceRequest<"SYMLINK">) => Promise<TConvenienceResponse<"SYMLINK">>;
+  mknod: (req: TConvenienceRequest<"MKNOD">) => Promise<TConvenienceResponse<"MKNOD">>;
+  mkdir: (req: TConvenienceRequest<"MKDIR">) => Promise<TConvenienceResponse<"MKDIR">>;
+  unlink: (req: TConvenienceRequest<"UNLINK">) => Promise<TConvenienceResponse<"UNLINK">>;
+  rmdir: (req: TConvenienceRequest<"RMDIR">) => Promise<TConvenienceResponse<"RMDIR">>;
+  rename: (req: TConvenienceRequest<"RENAME">) => Promise<TConvenienceResponse<"RENAME">>;
+  link: (req: TConvenienceRequest<"LINK">) => Promise<TConvenienceResponse<"LINK">>;
+  opendir: (req: TConvenienceRequest<"OPENDIR">) => Promise<TConvenienceResponse<"OPENDIR">>;
+  readdir: (req: TConvenienceRequest<"READDIR">) => Promise<TConvenienceResponse<"READDIR">>;
+  release: (req: TConvenienceRequest<"RELEASE">) => Promise<TConvenienceResponse<"RELEASE">>;
+  releasedir: (req: TConvenienceRequest<"RELEASEDIR">) => Promise<TConvenienceResponse<"RELEASEDIR">>;
+  fsyncdir: (req: TConvenienceRequest<"FSYNCDIR">) => Promise<TConvenienceResponse<"FSYNCDIR">>;
+  statfs: (req: TConvenienceRequest<"STATFS">) => Promise<TConvenienceResponse<"STATFS">>;
+  lookup: (req: TConvenienceRequest<"LOOKUP">) => Promise<TConvenienceResponse<"LOOKUP">>;
+  open: (req: TConvenienceRequest<"OPEN">) => Promise<TConvenienceResponse<"OPEN">>;
+  read: (req: TConvenienceRequest<"READ">) => Promise<TConvenienceResponse<"READ">>;
+  write: (req: TConvenienceRequest<"WRITE">) => Promise<TConvenienceResponse<"WRITE">>;
+  flush: (req: TConvenienceRequest<"FLUSH">) => Promise<TConvenienceResponse<"FLUSH">>;
+  fsync: (req: TConvenienceRequest<"FSYNC">) => Promise<TConvenienceResponse<"FSYNC">>;
+  access: (req: TConvenienceRequest<"ACCESS">) => Promise<TConvenienceResponse<"ACCESS">>;
+  setxattr: (req: TConvenienceRequest<"SETXATTR">) => Promise<TConvenienceResponse<"SETXATTR">>;
+  removexattr: (req: TConvenienceRequest<"REMOVEXATTR">) => Promise<TConvenienceResponse<"REMOVEXATTR">>;
+  create: (req: TConvenienceRequest<"CREATE">) => Promise<TConvenienceResponse<"CREATE">>;
+  destroy: (req: TConvenienceRequest<"DESTROY">) => Promise<TConvenienceResponse<"DESTROY">>;
+  getlk: (req: TConvenienceRequest<"GETLK">) => Promise<TConvenienceResponse<"GETLK">>;
+  setlk: (req: TConvenienceRequest<"SETLK">) => Promise<TConvenienceResponse<"SETLK">>;
+  setlkw: (req: TConvenienceRequest<"SETLKW">) => Promise<TConvenienceResponse<"SETLKW">>;
+  interrupt: (req: TConvenienceRequest<"INTERRUPT">) => Promise<void>;
+  bmap: (req: TConvenienceRequest<"BMAP">) => Promise<TConvenienceResponse<"BMAP">>;
+  ioctl: (req: TConvenienceRequest<"IOCTL">) => Promise<TConvenienceResponse<"IOCTL">>;
+  poll: (req: TConvenienceRequest<"POLL">) => Promise<TConvenienceResponse<"POLL">>;
+  notifyReply: (req: TConvenienceRequest<"NOTIFY_REPLY">) => Promise<void>;
+  fallocate: (req: TConvenienceRequest<"FALLOCATE">) => Promise<TConvenienceResponse<"FALLOCATE">>;
+  readdirplus: (req: TConvenienceRequest<"READDIRPLUS">) => Promise<TConvenienceResponse<"READDIRPLUS">>;
+};*/
+
+const createConvenienceRequestHandler = ({
+  serverInterface
+}/*: {
+  serverInterface: TFuseServerInterface
+}*/)/*: TRequestHandler*/ => {
+  // eslint-disable-next-line max-statements, complexity
+  const handleRequest/*: TRequestHandler["handleRequest"]*/ = async ({ request }) => {
+    switch (request.opcode) {
+    case "INIT": {
+      const response = await serverInterface.init(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "FORGET": {
+      await serverInterface.forget(request);
+      return undefined;
+    }
+
+    case "BATCH_FORGET": {
+      await serverInterface.batchForget(request);
+      return undefined;
+    }
+
+    case "GETATTR": {
+
+      switch (request.getattrMode) {
+      case "node": {
+        const response = await serverInterface.getattr(request);
+
+        return {
+          ...response,
+          unique: request.unique,
+        };
+      }
+
+      case "fileHandle": {
+        const response = await serverInterface.fgetattr(request);
+
+        return {
+          ...response,
+          unique: request.unique,
+        };
+      }
+
+      default: {
+        // @ts-expect-error exhaustive check
+        throw Error(`unsupported getattr mode: ${request.getattrMode}`);
+      }
+      }
+    }
+
+    case "SETATTR": {
+      const response = await serverInterface.setattr(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "LISTXATTR": {
+      const response = await serverInterface.listxattr(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "GETXATTR": {
+      const response = await serverInterface.getxattr(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "READLINK": {
+      const response = await serverInterface.readlink(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "SYMLINK": {
+      const response = await serverInterface.symlink(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "MKNOD": {
+      const response = await serverInterface.mknod(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "MKDIR": {
+      const response = await serverInterface.mkdir(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "UNLINK": {
+      const response = await serverInterface.unlink(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "RMDIR": {
+      const response = await serverInterface.rmdir(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "RENAME": {
+      const response = await serverInterface.rename(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "LINK": {
+      const response = await serverInterface.link(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "OPENDIR": {
+      const response = await serverInterface.opendir(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "READDIR": {
+      const response = await serverInterface.readdir(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "RELEASE": {
+      const response = await serverInterface.release(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "RELEASEDIR": {
+      const response = await serverInterface.releasedir(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "FSYNCDIR": {
+      const response = await serverInterface.fsyncdir(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "STATFS": {
+      const response = await serverInterface.statfs(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "LOOKUP": {
+      const response = await serverInterface.lookup(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "OPEN": {
+      const response = await serverInterface.open(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "READ": {
+      const response = await serverInterface.read(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "WRITE": {
+      const response = await serverInterface.write(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "FLUSH": {
+      const response = await serverInterface.flush(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "FSYNC": {
+      const response = await serverInterface.fsync(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "ACCESS": {
+      const response = await serverInterface.access(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "SETXATTR": {
+      const response = await serverInterface.setxattr(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "REMOVEXATTR": {
+      const response = await serverInterface.removexattr(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "CREATE": {
+      const response = await serverInterface.create(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "DESTROY": {
+      const response = await serverInterface.destroy(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "GETLK": {
+      const response = await serverInterface.getlk(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "SETLK": {
+      const response = await serverInterface.setlk(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "SETLKW": {
+      const response = await serverInterface.setlkw(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "INTERRUPT": {
+      await serverInterface.interrupt(request);
+      return undefined;
+    }
+
+    case "BMAP": {
+      const response = await serverInterface.bmap(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "IOCTL": {
+      const response = await serverInterface.ioctl(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "POLL": {
+      const response = await serverInterface.poll(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "NOTIFY_REPLY": {
+      await serverInterface.notifyReply(request);
+      return undefined;
+    }
+
+    case "FALLOCATE": {
+      const response = await serverInterface.fallocate(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    case "READDIRPLUS": {
+      const response = await serverInterface.readdirplus(request);
+
+      return {
+        ...response,
+        unique: request.unique,
+      };
+    }
+
+    default: {
+      // @ts-expect-error exhaustive check
+      throw Error(`unsupported opcode: ${request.opcode}`);
+    }
+    }
+  };
+
+  return {
+    handleRequest
+  };
+};
+
+export {
+  createConvenienceRequestHandler
+};
+
+/*export type {
+  TFuseServerInterface,
+};*/

package/dist/lib/fuse-lowlevel.d.ts

@@ -0,0 +1,42 @@
+type TIncomingRequest = {
+    header: {
+        opcode: bigint;
+        unique: bigint;
+        nodeid: bigint;
+        uid: bigint;
+        gid: bigint;
+        pid: bigint;
+    };
+    payload: Uint8Array;
+};
+type TOutgoingResponse = {
+    header: {
+        error: bigint;
+        unique: bigint;
+    };
+    payload: Uint8Array;
+};
+type TTryReadIncomingMessageResult = {
+    error: Error;
+    incomingMessage: undefined;
+    end: undefined;
+} | {
+    error: undefined;
+    incomingMessage: Uint8Array;
+    end: false;
+} | {
+    error: undefined;
+    incomingMessage: undefined;
+    end: false | true;
+};
+declare const createFuseLowLevel: ({ fuseFd, maxMessageSize }: {
+    fuseFd: number;
+    maxMessageSize: number;
+}) => {
+    tryReadIncomingMessage: () => TTryReadIncomingMessageResult;
+    writeOutgoingMessage: ({ rawMessage }: {
+        rawMessage: Uint8Array;
+    }) => void;
+};
+export { createFuseLowLevel };
+export type { TIncomingRequest, TOutgoingResponse };

package/dist/lib/fuse-lowlevel.js

@@ -0,0 +1,133 @@
+import { read, write } from "./syscalls.js";
+
+/*type TIncomingRequest = {
+  header: {
+    opcode: bigint;
+    unique: bigint;
+    nodeid: bigint;
+    uid: bigint;
+    gid: bigint;
+    pid: bigint;
+  },
+  payload: Uint8Array
+};*/
+
+/*type TOutgoingResponse = {
+  header: {
+    error: bigint;
+    unique: bigint;
+  },
+  payload: Uint8Array
+};*/
+
+/*type TTryReadIncomingMessageResult = {
+  error: Error;
+  incomingMessage: undefined;
+  end: undefined;
+} | {
+  error: undefined;
+  incomingMessage: Uint8Array;
+  end: false;
+} | {
+  error: undefined;
+  incomingMessage: undefined;
+  end: false | true;
+};*/
+
+const EPERM = 1;
+const EAGAIN = 11;
+const ENODEV = 19;
+
+const createFuseLowLevel = ({
+  fuseFd,
+  maxMessageSize
+}/*: {
+  fuseFd: number;
+  maxMessageSize: number;
+}*/) => {
+
+  const incomingBuffer = new Uint8Array(maxMessageSize);
+
+  // eslint-disable-next-line complexity
+  const tryReadIncomingMessage = ()/*: TTryReadIncomingMessageResult*/ => {
+
+    const { errno, ret } = read({
+      fd: fuseFd,
+      buffer: incomingBuffer
+    });
+
+    if (errno !== undefined) {
+
+      if (errno === EPERM) {
+
+        // most likely the filesystem hasn't been mounted yet
+
+        return {
+          error: undefined,
+          incomingMessage: undefined,
+          end: false
+        };
+      }
+
+      if (errno === EAGAIN) {
+        // no message to read
+
+        return {
+          error: undefined,
+          incomingMessage: undefined,
+          end: false
+        };
+      }
+
+      if (errno === ENODEV) {
+        // the filesystem has been unmounted
+
+        return {
+          error: undefined,
+          incomingMessage: undefined,
+          end: true
+        };
+      }
+
+      throw Error(`errno ${errno} not implemented yet`);
+    }
+
+    const incomingMessage = incomingBuffer.slice(0, Number(ret));
+
+    return {
+      error: undefined,
+      incomingMessage,
+      end: false
+    };
+  };
+
+  const writeOutgoingMessage = ({ rawMessage }/*: { rawMessage: Uint8Array }*/) => {
+
+    const { errno, ret } = write({
+      fd: fuseFd,
+      buffer: rawMessage
+    });
+
+    if (errno !== undefined) {
+      throw Error(`write syscall failed with errno ${errno}`);
+    }
+
+    if (ret !== BigInt(rawMessage.length)) {
+      throw Error(`short write not supported yet`);
+    }
+  };
+
+  return {
+    tryReadIncomingMessage,
+    writeOutgoingMessage,
+  };
+};
+
+export {
+  createFuseLowLevel
+};
+
+/*export type {
+  TIncomingRequest,
+  TOutgoingResponse
+};*/

package/dist/lib/index.d.ts

@@ -0,0 +1,40 @@
+import { type TRequestHandler } from "./server.js";
+import { openFuseFd, defaultFusePath } from "./linux.js";
+import { createConvenienceRequestHandler } from "./convenience.js";
+import { moveMount, unmount, type TMountAttributes, type TRequiredFuseMountOptions } from "./mount.js";
+import type { TFuseResponse } from "./protocol.js";
+declare const createFuseFileSystem: ({ fuseFd, requestHandler, sniff, }: {
+    fuseFd: number;
+    requestHandler: TRequestHandler;
+    sniff?: {
+        rawMessageFromKernel: (args: {
+            data: Uint8Array;
+        }) => void;
+        rawMessageToKernel: (args: {
+            data: Uint8Array;
+        }) => void;
+    };
+}) => {
+    mountDetached: ({ otherOptions, requiredOptions, mountAttributes, }: {
+        otherOptions: {
+            default_permissions?: boolean;
+            allow_other?: boolean;
+            allow_root?: boolean;
+        } | Record<string, string | boolean>;
+        requiredOptions: TRequiredFuseMountOptions;
+        mountAttributes: TMountAttributes;
+    }) => {
+        error: Error;
+        mountFd: undefined;
+    } | {
+        error: undefined;
+        mountFd: number;
+    };
+    close: () => void;
+};
+declare const createDefaultInitResult: () => Extract<TFuseResponse, {
+    forOpcode: "INIT";
+    errorCode: undefined;
+}>["result"];
+export { createFuseFileSystem, openFuseFd, defaultFusePath, createConvenienceRequestHandler, moveMount, unmount, createDefaultInitResult };
+export type { TRequiredFuseMountOptions, TMountAttributes, };