@k13engineering/linux-fuse 0.0.1 → 0.0.3

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/dirent.d.ts

@@ -0,0 +1,13 @@
+type TDirentFileType = "DT_FIFO" | "DT_CHR" | "DT_DIR" | "DT_BLK" | "DT_REG" | "DT_LNK" | "DT_SOCK" | "DT_UNKNOWN";
+type TDirent = {
+    inode: bigint;
+    nextOffset: bigint;
+    fileType: TDirentFileType;
+    name: string;
+};
+declare const direntsToBuffer: ({ entries, maxLength }: {
+    entries: TDirent[];
+    maxLength: number;
+}) => Uint8Array;
+export { direntsToBuffer };
+export type { TDirent };

package/dist/lib/dirent.js

@@ -0,0 +1,128 @@
+/*type TDirentFileType = "DT_FIFO" | "DT_CHR" | "DT_DIR" | "DT_BLK" | "DT_REG" | "DT_LNK" | "DT_SOCK" | "DT_UNKNOWN";*/
+
+/*type TDirent = {
+  inode: bigint;
+  nextOffset: bigint;
+  fileType: TDirentFileType;
+  name: string;
+};*/
+
+/*type TNativeDirent = {
+  inode: bigint;
+  nextOffset: bigint;
+  fileTypeNative: number;
+  encodedName: Uint8Array;
+};*/
+
+const align = ({ value, alignment }/*: { value: number; alignment: number }*/)/*: number*/ => {
+  const remainder = value % alignment;
+  if (remainder === 0) {
+    return value;
+  }
+
+  return value + (alignment - remainder);
+};
+
+// eslint-disable-next-line complexity
+const direntFileTypeToNative = ({ fileType }/*: { fileType: TDirentFileType }*/)/*: number*/ => {
+  switch (fileType) {
+  case "DT_FIFO": return 1;
+  case "DT_CHR": return 2;
+  case "DT_DIR": return 4;
+  case "DT_BLK": return 6;
+  case "DT_REG": return 8;
+  case "DT_LNK": return 10;
+  case "DT_SOCK": return 12;
+  default: return 0;
+  }
+};
+
+const determineAlignedDirentRecordLength = ({ nameLength }/*: { nameLength: number }*/)/*: number*/ => {
+  const headerLength = 24;
+  const recordLength = headerLength + nameLength;
+  return align({ value: recordLength, alignment: 8 });
+};
+
+const textEncoder = new TextEncoder();
+let direntBuffer = new Uint8Array(0);
+
+const encodeName = ({ name }/*: { name: string }*/)/*: Uint8Array*/ => {
+  if (name.includes("\0")) {
+    throw Error("name may not contain null bytes");
+  }
+
+  if (name.includes("/")) {
+    throw Error("name may not contain slashes");
+  }
+
+  return textEncoder.encode(name);
+};
+
+const direntToNative = ({ entry }/*: { entry: TDirent }*/)/*: TNativeDirent*/ => {
+  return {
+    inode: entry.inode,
+    nextOffset: entry.nextOffset,
+    fileTypeNative: direntFileTypeToNative({ fileType: entry.fileType }),
+    encodedName: encodeName({ name: entry.name })
+  };
+};
+
+// eslint-disable-next-line max-statements
+const direntsToBuffer = ({ entries, maxLength }/*: { entries: TDirent[], maxLength: number }*/)/*: Uint8Array*/ => {
+
+  if (maxLength > direntBuffer.length) {
+    direntBuffer = new Uint8Array(maxLength);
+  }
+
+  let offset = 0;
+
+  for (const entry of entries) {
+
+    const nativeEntry = direntToNative({ entry });
+
+    const view = new DataView(direntBuffer.buffer, direntBuffer.byteOffset + offset);
+
+    const recordLength = determineAlignedDirentRecordLength({ nameLength: nativeEntry.encodedName.length });
+
+    const newOffset = offset + recordLength;
+
+    if (newOffset > maxLength) {
+      break;
+    }
+
+    // struct fuse_dirent {
+
+    // uint64_t ino
+    view.setBigUint64(0, nativeEntry.inode, true);
+
+    // uint64_t off
+    // this is filesystem-interal offset and not used for offset calculation etc.
+    // this parameter will be provided by seek / read offset of readdir
+    view.setBigUint64(8, nativeEntry.nextOffset, true);
+
+    // uint32_t namelen
+    view.setUint32(16, nativeEntry.encodedName.length, true);
+
+    // uint32_t type
+    view.setUint32(20, nativeEntry.fileTypeNative, true);
+
+    // char[] name
+    direntBuffer.set(nativeEntry.encodedName, offset + 24);
+
+    // }
+
+    direntBuffer.fill(0, offset + 24 + nativeEntry.encodedName.length, newOffset);
+
+    offset = newOffset;
+  };
+
+  return direntBuffer.slice(0, offset);
+};
+
+export {
+  direntsToBuffer
+};
+
+/*export type {
+  TDirent
+};*/

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 };