saltcorn-samba 0.4.11 → 0.4.13

package/readdir-compat.js

@@ -1,471 +1,299 @@
+"use strict";
+
 /**
- * Compatibility layer for smb3-client's readdir on Samba 4.23+.
+ * readdir-compat.js  —  saltcorn-samba 0.4.13
+ *
+ * Behebt zwei QUERY_DIRECTORY-Wire-Bugs in smb3-client@0.2.0 die
+ * gegen Samba 4.23 zu STATUS_OBJECT_NAME_INVALID (0xC0000033) führen.
  *
- * Background
- * ----------
- * `smb3-client@0.2.0` hard-codes `FileInformationClass = 37`
- * (`FileIdBothDirectoryInformation`) in its `QUERY_DIRECTORY` request.
- * Some Samba 4.23+ configurations reject that class with
- * `STATUS_OBJECT_NAME_INVALID` (0xC0000033) for specific directories —
- * even though the directory can be opened, stat'd and traversed. The
- * same directories can be listed by `smbclient` (which requests class 3
- * or 1) and by Windows Explorer.
+ * BUG 1 (FileNameOffset bei leerem Pattern):
+ *   smb3-client's `encodeQueryDirectoryRequest` setzt `FileNameOffset`
+ *   immer auf 96 — auch wenn `FileNameLength === 0` gesendet wird.
+ *   MS-SMB2 §2.2.33 verlangt für diesen Fall FileNameOffset = 0.
  *
- * This module implements `readdirCompat(client, sharePath)` which:
+ * BUG 2 (Leeres Pattern auf Folge-Pages):  ← Der Hauptbug!
+ *   smb3-client sendet ab der 2. Enumeration-Page `searchPattern=""`.
+ *   Windows toleriert das, Samba 4.23 lehnt es strikt ab. Belegt via
+ *   diag-wire.js: `smb2_query_directory.c` prüft `in_file_name[0] ==
+ *   '\0'` und antwortet dann mit STATUS_OBJECT_NAME_INVALID.
+ *   Fix: Auf jeder Page `*` senden. RESTART_SCANS nur beim ersten Mal.
+ *   Samba beendet die Enumeration dann korrekt mit
+ *   STATUS_NO_MORE_FILES auf einem Folge-Request ohne RESTART_SCANS.
  *
- *   1. Reaches into smb3-client's *internal* wire primitives (via direct
- *      filesystem imports — see NOTE below).
- *   2. Opens the directory the same way `client.readdir()` does.
- *   3. Sends `QUERY_DIRECTORY` with `FileBothDirectoryInformation (3)`,
- *      which is the identical layout minus the 8-byte trailing `FileId`
- *      field.
- *   4. Falls back to `FileDirectoryInformation (1)` on the same error.
- *   5. Remembers the working class on the given client so subsequent
- *      readdir calls do not need to retry.
+ * Strategie:
+ *   Statt smb3-client's `client.readdir()` / `readdirAll` verwenden wir
+ *   einen eigenen Loop, der `Open.withOpen` von smb3-client wieder-
+ *   verwendet (Open, Close, Tree-Connect bleiben unverändert) und nur
+ *   die kaputte QUERY_DIRECTORY-Loop durch eine spec-konforme ersetzt.
  *
- * NOTE — subpath imports
- * ----------------------
- * `smb3-client` publishes with `"exports": { ".": ... }`, so subpath
- * imports via package name (`smb3-client/dist/...`) are blocked by
- * Node. We work around that by resolving the absolute filesystem path
- * of the main entry (via a dynamic `import("smb3-client")` and reading
- * `import.meta.url` off the returned URL of a re-export) and then
- * constructing `file://` URLs to the sibling internal modules. This
- * pattern is stable across `smb3-client 0.2.x` — the internal file
- * tree is documented in its README.
+ * Nur die interne wire-Struktur wird via file:// URL importiert, weil
+ * smb3-client's `exports`-Gate keine Subpath-Imports zulässt.
  */
 
-"use strict";
+const fs = require("fs");
+const path = require("path");
+const url = require("url");
 
-// Lazy, cached bundle of the internal modules we need. Loaded on first use.
-let _internalsPromise = null;
+let LOAD_PROMISE = null;
+let INTERNALS = null;
 
-async function loadInternals() {
-  if (_internalsPromise) return _internalsPromise;
-  _internalsPromise = (async () => {
-    // Locate smb3-client's package root on disk. We do this by walking
-    // require.resolve.paths() and looking for a real dist/index.js.
-    // (require.resolve() itself is blocked by the "exports" gate.)
-    const path = require("path");
-    const fs = require("fs");
-    const { pathToFileURL } = require("url");
+/**
+ * Interne Wire-/Path-Module aus smb3-client laden. Lazy + gecached.
+ * Wirft, wenn smb3-client nicht auffindbar oder Interna verändert.
+ */
+function loadInternals() {
+  if (INTERNALS) return Promise.resolve(INTERNALS);
+  if (LOAD_PROMISE) return LOAD_PROMISE;
 
-    let pkgRoot = null;
-    const candidatePaths = require.resolve.paths("smb3-client") || [];
-    for (const p of candidatePaths) {
-      const guess = path.join(p, "smb3-client");
-      if (fs.existsSync(path.join(guess, "dist", "index.js"))) {
-        pkgRoot = guess;
+  LOAD_PROMISE = (async () => {
+    // smb3-client-Root finden (package.json ist via exports-Gate blockiert,
+    // wir gehen über den Ordner-Pfad)
+    const candidates = [
+      path.join(__dirname, "node_modules", "smb3-client"),
+      path.join(__dirname, "..", "node_modules", "smb3-client"),
+      path.join(__dirname, "..", "..", "node_modules", "smb3-client"),
+      path.join(__dirname, "..", "..", "..", "node_modules", "smb3-client"),
+    ];
+    let smb3Root = null;
+    for (const c of candidates) {
+      try {
+        fs.accessSync(path.join(c, "dist", "index.js"));
+        smb3Root = c;
         break;
-      }
+      } catch (_) {}
     }
-    if (!pkgRoot) {
+    if (!smb3Root) {
       throw new Error(
-        "readdir-compat: cannot locate smb3-client package root on disk"
+        "readdir-compat: smb3-client-Installation nicht gefunden. " +
+          "Erwartet in node_modules/smb3-client relativ zu " +
+          __dirname
       );
     }
-    const dist = path.join(pkgRoot, "dist");
-    const urlOf = (rel) =>
-      pathToFileURL(path.join(dist, rel)).href;
+
+    const distDir = path.join(smb3Root, "dist");
+    const load = (rel) =>
+      import(url.pathToFileURL(path.join(distDir, rel)).href);
 
     const [
-      queryDirectoryMod,
-      createMod,
-      closeMod,
-      commandsMod,
+      bufMod,
+      qdMod,
+      cmdMod,
+      qiMod,
+      createStructMod,
       pathsMod,
-      bufferMod,
+      errMod,
+      openMod,
     ] = await Promise.all([
-      import(urlOf("wire/structs/queryDirectory.js")),
-      import(urlOf("wire/structs/create.js")),
-      import(urlOf("wire/structs/close.js")),
-      import(urlOf("wire/commands.js")),
-      import(urlOf("paths.js")),
-      import(urlOf("wire/buffer.js")),
+      load("wire/buffer.js"),
+      load("wire/structs/queryDirectory.js"),
+      load("wire/commands.js"),
+      load("wire/structs/queryInfo.js"),
+      load("wire/structs/create.js"),
+      load("paths.js"),
+      load("errors.js"),
+      load("open/open.js"),
     ]);
-    return {
-      encodeQueryDirectoryRequest: queryDirectoryMod.encodeQueryDirectoryRequest,
-      decodeQueryDirectoryResponse: queryDirectoryMod.decodeQueryDirectoryResponse,
-      QueryDirectoryFlag: queryDirectoryMod.QueryDirectoryFlag,
-      encodeCreateRequest: createMod.encodeCreateRequest,
-      decodeCreateResponse: createMod.decodeCreateResponse,
-      encodeCloseRequest: closeMod.encodeCloseRequest,
-      CreateDisposition: createMod.CreateDisposition,
-      FileAccess: createMod.FileAccess,
-      FileAttribute: createMod.FileAttribute,
-      ShareAccess: createMod.ShareAccess,
-      SmbCommand: commandsMod.SmbCommand,
-      NTStatus: commandsMod.NTStatus,
-      isSuccess: commandsMod.isSuccess,
-      statusName: commandsMod.statusName,
+
+    if (typeof bufMod.Writer !== "function")
+      throw new Error("readdir-compat: Writer-Klasse fehlt");
+    if (typeof qdMod.decodeQueryDirectoryResponse !== "function")
+      throw new Error("readdir-compat: decodeQueryDirectoryResponse fehlt");
+    if (typeof qdMod.parseFileIdBothDirectoryInformation !== "function")
+      throw new Error("readdir-compat: parseFileIdBothDirectoryInformation fehlt");
+    if (typeof openMod.Open !== "function")
+      throw new Error("readdir-compat: Open-Klasse fehlt");
+
+    INTERNALS = {
+      smb3Root,
+      Writer: bufMod.Writer,
+      decodeQueryDirectoryResponse: qdMod.decodeQueryDirectoryResponse,
+      parseFileIdBothDirectoryInformation:
+        qdMod.parseFileIdBothDirectoryInformation,
+      QueryDirectoryFlag: qdMod.QueryDirectoryFlag,
+      SmbCommand: cmdMod.SmbCommand,
+      NTStatus: cmdMod.NTStatus,
+      isSuccess: cmdMod.isSuccess,
+      statusName: cmdMod.statusName,
+      FileInformationClass: qiMod.FileInformationClass,
+      FileAccess: createStructMod.FileAccess,
+      ShareAccess: createStructMod.ShareAccess,
+      CreateDisposition: createStructMod.CreateDisposition,
+      CreateOptions: createStructMod.CreateOptions,
+      FileAttribute: createStructMod.FileAttribute,
       splitSharePath: pathsMod.splitSharePath,
       toSmbPath: pathsMod.toSmbPath,
-      Reader: bufferMod.Reader,
+      smbTimeToDate: pathsMod.smbTimeToDate,
+      SmbError: errMod.SmbError,
+      Open: openMod.Open,
     };
+    return INTERNALS;
   })();
-  return _internalsPromise;
-}
-
-// ---------------------------------------------------------------------------
-// Parsers for the alternative information classes
-// ---------------------------------------------------------------------------
-//
-// [MS-FSCC] 2.4.10 FileDirectoryInformation:
-//   NextEntryOffset u32
-//   FileIndex       u32
-//   CreationTime    u64
-//   LastAccessTime  u64
-//   LastWriteTime   u64
-//   ChangeTime      u64
-//   EndOfFile       u64
-//   AllocationSize  u64
-//   FileAttributes  u32
-//   FileNameLength  u32
-//   FileName        wchar[]
-//
-// [MS-FSCC] 2.4.6 FileBothDirectoryInformation adds after FileNameLength:
-//   EaSize          u32
-//   ShortNameLength u8
-//   Reserved1       u8
-//   ShortName       wchar[12] (24 bytes)
-//   FileName        wchar[]
 
-function parseFileDirectoryInformation(buf, Reader) {
-  const out = [];
-  let off = 0;
-  while (off < buf.length) {
-    const r = new Reader(buf);
-    r.offset = off;
-    const next = r.u32();
-    r.u32(); // FileIndex
-    const creationTime = r.u64();
-    const lastAccessTime = r.u64();
-    const lastWriteTime = r.u64();
-    const changeTime = r.u64();
-    const endOfFile = r.u64();
-    r.u64(); // AllocationSize
-    const fileAttributes = r.u32();
-    const fileNameLength = r.u32();
-    const fileName = fileNameLength > 0 ? r.utf16(fileNameLength) : "";
-    out.push({
-      fileName,
-      endOfFile,
-      fileAttributes,
-      creationTime,
-      lastAccessTime,
-      lastWriteTime,
-      changeTime,
-    });
-    if (next === 0) break;
-    off += next;
-  }
-  return out;
+  return LOAD_PROMISE;
 }
 
-function parseFileBothDirectoryInformation(buf, Reader) {
-  const out = [];
-  let off = 0;
-  while (off < buf.length) {
-    const r = new Reader(buf);
-    r.offset = off;
-    const next = r.u32();
-    r.u32(); // FileIndex
-    const creationTime = r.u64();
-    const lastAccessTime = r.u64();
-    const lastWriteTime = r.u64();
-    const changeTime = r.u64();
-    const endOfFile = r.u64();
-    r.u64(); // AllocationSize
-    const fileAttributes = r.u32();
-    const fileNameLength = r.u32();
-    r.u32(); // EaSize
-    r.u8(); // ShortNameLength
-    r.u8(); // Reserved1
-    r.bytes(24); // ShortName
-    const fileName = fileNameLength > 0 ? r.utf16(fileNameLength) : "";
-    out.push({
-      fileName,
-      endOfFile,
-      fileAttributes,
-      creationTime,
-      lastAccessTime,
-      lastWriteTime,
-      changeTime,
-    });
-    if (next === 0) break;
-    off += next;
-  }
-  return out;
-}
-
-// FileIdBothDirectoryInformation (37) — same parser as smb3-client
-// (used only if smb3-client's own readdir failed for OTHER reasons).
-function parseFileIdBothDirectoryInformation(buf, Reader) {
-  const out = [];
-  let off = 0;
-  while (off < buf.length) {
-    const r = new Reader(buf);
-    r.offset = off;
-    const next = r.u32();
-    r.u32(); // FileIndex
-    const creationTime = r.u64();
-    const lastAccessTime = r.u64();
-    const lastWriteTime = r.u64();
-    const changeTime = r.u64();
-    const endOfFile = r.u64();
-    r.u64(); // AllocationSize
-    const fileAttributes = r.u32();
-    const fileNameLength = r.u32();
-    r.u32(); // EaSize
-    r.u8(); // ShortNameLength
-    r.u8(); // Reserved1
-    r.bytes(24); // ShortName
-    r.u16(); // Reserved2
-    r.bytes(8); // FileId
-    const fileName = fileNameLength > 0 ? r.utf16(fileNameLength) : "";
-    out.push({
-      fileName,
-      endOfFile,
-      fileAttributes,
-      creationTime,
-      lastAccessTime,
-      lastWriteTime,
-      changeTime,
-    });
-    if (next === 0) break;
-    off += next;
-  }
-  return out;
+/**
+ * Spec-konformer Encoder für SMB2 QUERY_DIRECTORY (MS-SMB2 §2.2.33).
+ * Anders als das Original:
+ *   - FileNameOffset = 0, wenn kein Suchpattern (statt 96)
+ * Ansonsten identisch (Struktur + Padding-Byte).
+ */
+function encodeQueryDirectoryRequestFixed(I, req) {
+  const pat = req.searchPattern
+    ? Buffer.from(req.searchPattern, "utf16le")
+    : Buffer.alloc(0);
+  const w = new I.Writer();
+  w.u16(33); // StructureSize
+  w.u8(req.fileInformationClass);
+  w.u8(req.flags);
+  w.u32(req.fileIndex);
+  w.bytes(req.fileId); // 16 bytes
+  w.u16(pat.length === 0 ? 0 : 64 + 32);
+  w.u16(pat.length);
+  w.u32(req.outputBufferLength);
+  if (pat.length === 0) w.u8(0);
+  else w.bytes(pat);
+  return w.buffer();
 }
 
-// ---------------------------------------------------------------------------
-// Per-client sticky preferred information class
-// ---------------------------------------------------------------------------
-
-const PREFERRED_CLASS = new WeakMap(); // raw smb3-client Client → number
-
-// Ordered list of classes we try. First one is smb3-client's default, so
-// clients on servers that accept it get zero extra round-trips.
-const TRY_ORDER = [
-  { code: 37, parse: parseFileIdBothDirectoryInformation, name: "FileIdBothDirectoryInformation" },
-  { code: 3,  parse: parseFileBothDirectoryInformation,   name: "FileBothDirectoryInformation" },
-  { code: 1,  parse: parseFileDirectoryInformation,       name: "FileDirectoryInformation" },
-];
-
-// ---------------------------------------------------------------------------
-// Public entrypoint
-// ---------------------------------------------------------------------------
-
 /**
- * List a directory using the same open-and-query dance as
- * `client.readdir(path)` but with a configurable — and self-fallback —
- * `FileInformationClass`.
+ * QUERY_DIRECTORY-Loop mit gepatchtem Encoder.
  *
- * @param {object} rawClient  — instance of smb3-client's `Client`
- * @param {string} sharePath  — "share/sub/dir" (share = first segment)
- * @returns {Promise<Array<{name, isDirectory, size, mtime, birthtime, ctime}>>}
+ * Unterschiede zu smb3-client's readdirAll():
+ *   1. Auf Folge-Pages wird `searchPattern="*"` gesendet (nicht "").
+ *      Samba lehnt leere Patterns strikt ab (STATUS_OBJECT_NAME_INVALID).
+ *   2. RESTART_SCANS nur beim ersten Request.
+ *   3. Encoder setzt FileNameOffset=0 bei leerem Pattern (Fallback für
+ *      andere kaputte Server, wird hier faktisch nie benutzt).
  */
-async function readdirCompat(rawClient, sharePath) {
-  const int = await loadInternals();
-  const {
-    encodeQueryDirectoryRequest,
-    decodeQueryDirectoryResponse,
-    QueryDirectoryFlag,
-    encodeCreateRequest,
-    decodeCreateResponse,
-    encodeCloseRequest,
-    CreateDisposition,
-    FileAccess,
-    ShareAccess,
-    SmbCommand,
-    NTStatus,
-    isSuccess,
-    statusName,
-    splitSharePath,
-    toSmbPath,
-    Reader,
-  } = int;
-
-  const { share, rest } = splitSharePath(sharePath);
-  // treeFor is a "private" (TS-private, JS-public) method on Client.
-  const tree = await rawClient.treeFor(share);
-
-  // Open the target directory with DIRECTORY_FILE createOption (=1),
-  // matching what smb3-client itself does for readdir.
-  const createBody = encodeCreateRequest({
-    filename: toSmbPath(rest),
-    desiredAccess:
-      FileAccess.FILE_READ_DATA | FileAccess.FILE_READ_ATTRIBUTES,
-    shareAccess:
-      ShareAccess.READ | ShareAccess.WRITE | ShareAccess.DELETE,
-    createDisposition: CreateDisposition.OPEN,
-    createOptions: 1, // DIRECTORY_FILE
-    fileAttributes: 0,
-  });
-  const createSigning = tree.session.makeSigning();
-  const createResp = await tree.conn.send(SmbCommand.CREATE, createBody, {
-    sessionId: tree.session.sessionId,
-    treeId: tree.treeId,
-    ...(createSigning !== undefined ? { signing: createSigning } : {}),
-    encrypt: tree.encryptRequired,
-    creditCharge: 1,
-  });
-  if (!isSuccess(createResp.header.status)) {
-    const e = new Error(
-      "CREATE failed: " + statusName(createResp.header.status)
-    );
-    e.status = createResp.header.status;
-    throw e;
-  }
-  const meta = decodeCreateResponse(createResp.body);
-  const fileId = meta.fileId;
-
-  try {
-    // Try preferred class first, then the rest in TRY_ORDER.
-    const preferred = PREFERRED_CLASS.get(rawClient);
-    const order = preferred !== undefined
-      ? [
-          TRY_ORDER.find((c) => c.code === preferred),
-          ...TRY_ORDER.filter((c) => c.code !== preferred),
-        ]
-      : TRY_ORDER.slice();
-
-    let lastErr = null;
-    const attempts = [];
-    for (const cls of order) {
-      try {
-        const entries = await queryAll({
-          tree, fileId, cls,
-          encodeQueryDirectoryRequest,
-          decodeQueryDirectoryResponse,
-          QueryDirectoryFlag,
-          SmbCommand,
-          NTStatus,
-          isSuccess,
-          statusName,
-          Reader,
-        });
-        // Cache the winning class for the next readdir on this client.
-        PREFERRED_CLASS.set(rawClient, cls.code);
-        return entries.map(dirEntryToPluginEntry);
-      } catch (err) {
-        lastErr = err;
-        const msg = String((err && err.message) || err || "");
-        attempts.push({ class: cls.name, code: cls.code, error: msg });
-        // Only retry with a different class on OBJECT_NAME_INVALID / info-class
-        // rejection — any other error (auth, connection, missing) is fatal.
-        const isInfoClassBug =
-          /0xC0000033|OBJECT_NAME_INVALID|STATUS_INVALID_INFO_CLASS/i.test(msg);
-        if (!isInfoClassBug) {
-          throw err;
-        }
-        // else: fall through to next class in order
-      }
-    }
-    // All classes tried and all failed with 0xC0000033. Report a
-    // synthesised error that is uniquely identifiable ("all classes
-    // exhausted") so the caller can decide not to fall back to
-    // smb3-client's own readdir (which uses class 37 again).
-    const finalMsg =
-      "QUERY_DIRECTORY failed: 0xC0000033 (all classes exhausted; " +
-      "no working FileInformationClass on this server). Tried: " +
-      attempts.map((a) => a.class + "=" + a.code).join(", ") + ".";
-    const summary = new Error(finalMsg);
-    summary.cause = lastErr;
-    summary.attempts = attempts;
-    throw summary;
-  } finally {
-    // Always close the handle. Ignore errors.
-    try {
-      const closeBody = encodeCloseRequest(fileId);
-      const closeSigning = tree.session.makeSigning();
-      await tree.conn.send(SmbCommand.CLOSE, closeBody, {
-        sessionId: tree.session.sessionId,
-        treeId: tree.treeId,
-        ...(closeSigning !== undefined ? { signing: closeSigning } : {}),
-        encrypt: tree.encryptRequired,
-        creditCharge: 1,
-      });
-    } catch (_) {
-      // best-effort
-    }
-  }
-}
-
-// Send QUERY_DIRECTORY in a loop until STATUS_NO_MORE_FILES.
-async function queryAll(opts) {
-  const {
-    tree, fileId, cls,
-    encodeQueryDirectoryRequest,
-    decodeQueryDirectoryResponse,
-    QueryDirectoryFlag,
-    SmbCommand,
-    NTStatus,
-    isSuccess,
-    statusName,
-    Reader,
-  } = opts;
-
+async function readdirAllFixed(I, open) {
   const items = [];
   let first = true;
   for (;;) {
-    const body = encodeQueryDirectoryRequest({
-      fileInformationClass: cls.code,
-      flags: first ? QueryDirectoryFlag.RESTART_SCANS : 0,
+    const body = encodeQueryDirectoryRequestFixed(I, {
+      fileInformationClass:
+        I.FileInformationClass.FileIdBothDirectoryInformation,
+      flags: first ? I.QueryDirectoryFlag.RESTART_SCANS : 0,
       fileIndex: 0,
-      fileId,
-      searchPattern: first ? "*" : "",
+      fileId: open.fileId,
+      searchPattern: "*", // IMMER "*", nie "" — Samba lehnt leer ab
       outputBufferLength: 65536,
     });
     first = false;
-    const signing = tree.session.makeSigning();
-    const resp = await tree.conn.send(SmbCommand.QUERY_DIRECTORY, body, {
-      sessionId: tree.session.sessionId,
-      treeId: tree.treeId,
-      ...(signing !== undefined ? { signing } : {}),
-      encrypt: tree.encryptRequired,
-      creditCharge: 1,
-    });
-    if (resp.header.status === NTStatus.STATUS_NO_MORE_FILES) break;
-    if (!isSuccess(resp.header.status)) {
-      const err = new Error(
-        "QUERY_DIRECTORY failed: " + statusName(resp.header.status)
-      );
-      err.status = resp.header.status;
-      throw err;
+
+    const signing = open.tree.session.makeSigning();
+    const resp = await open.tree.conn.send(
+      I.SmbCommand.QUERY_DIRECTORY,
+      body,
+      {
+        sessionId: open.tree.session.sessionId,
+        treeId: open.tree.treeId,
+        ...(signing !== undefined ? { signing } : {}),
+        encrypt: open.tree.encryptRequired,
+        creditCharge: 1,
+      }
+    );
+
+    if (resp.header.status === I.NTStatus.STATUS_NO_MORE_FILES) break;
+    if (!I.isSuccess(resp.header.status)) {
+      throw new I.SmbError({
+        status: resp.header.status,
+        message:
+          "QUERY_DIRECTORY (compat) failed: " +
+          I.statusName(resp.header.status),
+      });
     }
-    const buf = decodeQueryDirectoryResponse(resp.body, 64);
+
+    const buf = I.decodeQueryDirectoryResponse(resp.body, 64);
     if (buf.length === 0) break;
-    const page = cls.parse(buf, Reader);
+
+    const page = I.parseFileIdBothDirectoryInformation(buf);
     for (const e of page) items.push(e);
     if (page.length === 0) break;
   }
-  // Filter "." and ".."
   return items.filter((x) => x.fileName !== "." && x.fileName !== "..");
 }
 
-// SMB file attribute bit for directory (MS-FSCC 2.6).
-const FILE_ATTRIBUTE_DIRECTORY = 0x10;
+/**
+ * Öffentliche API: readdirCompat(client, fullPath, opts)
+ *
+ * Drop-in-Ersatz für `client.readdir(fullPath, opts)` von smb3-client.
+ *   fullPath: "share/rest/of/path"  (smb3-client-Konvention)
+ *   opts:     { withFileTypes?: boolean }
+ *
+ * Rückgabe:
+ *   opts.withFileTypes === true → Dirent[]  { name, isFile(), isDirectory() }
+ *   sonst                       → string[]  Dateinamen
+ *
+ * Zusätzlich (ergänzend zur smb3-client-API) Rich-Objects auf Wunsch:
+ *   opts.rich === true → RichDirent[]
+ *     { name, size, isFile(), isDirectory(), mtime, ctime, atime,
+ *       changeTime, attributes, hidden, system, readonly, archive }
+ */
+async function readdirCompat(client, fullPath, opts) {
+  const I = await loadInternals();
+
+  const { share, rest } = I.splitSharePath(fullPath);
+  const tree = await client.treeFor(share);
 
-// SMB time = 100-ns intervals since 1601-01-01. Convert to JS Date.
-function smbTimeToDate(u64) {
-  if (u64 === undefined || u64 === null) return undefined;
-  // u64 is a BigInt from Reader.u64()
-  const ms = Number(u64 / 10000n) - 11644473600000;
-  if (!isFinite(ms)) return undefined;
-  return new Date(ms);
+  return I.Open.withOpen(
+    tree,
+    {
+      filename: I.toSmbPath(rest),
+      desiredAccess:
+        I.FileAccess.FILE_READ_DATA | I.FileAccess.FILE_READ_ATTRIBUTES,
+      shareAccess:
+        I.ShareAccess.READ | I.ShareAccess.WRITE | I.ShareAccess.DELETE,
+      createDisposition: I.CreateDisposition.OPEN,
+      createOptions: I.CreateOptions.DIRECTORY_FILE, // 1
+      fileAttributes: 0,
+    },
+    async (open) => {
+      const entries = await readdirAllFixed(I, open);
+      if (opts && opts.rich) {
+        return entries.map((e) => {
+          const attr = e.fileAttributes;
+          const isDir = (attr & I.FileAttribute.DIRECTORY) !== 0;
+          return {
+            name: e.fileName,
+            size: Number(e.endOfFile),
+            attributes: attr,
+            isFile: () => !isDir,
+            isDirectory: () => isDir,
+            mtime: I.smbTimeToDate(e.lastWriteTime),
+            ctime: I.smbTimeToDate(e.creationTime),
+            atime: I.smbTimeToDate(e.lastAccessTime),
+            changeTime: I.smbTimeToDate(e.changeTime),
+            hidden: (attr & 0x02) !== 0,
+            system: (attr & 0x04) !== 0,
+            readonly: (attr & 0x01) !== 0,
+            archive: (attr & 0x20) !== 0,
+          };
+        });
+      }
+      if (opts && opts.withFileTypes) {
+        return entries.map((e) => {
+          const isDir =
+            (e.fileAttributes & I.FileAttribute.DIRECTORY) !== 0;
+          return {
+            name: e.fileName,
+            isFile: () => !isDir,
+            isDirectory: () => isDir,
+          };
+        });
+      }
+      return entries.map((e) => e.fileName);
+    }
+  );
 }
 
-function dirEntryToPluginEntry(e) {
-  const isDir = (e.fileAttributes & FILE_ATTRIBUTE_DIRECTORY) !== 0;
-  return {
-    name: e.fileName,
-    isDirectory: isDir,
-    size: isDir ? 0 : Number(e.endOfFile || 0n),
-    mtime: smbTimeToDate(e.lastWriteTime),
-    birthtime: smbTimeToDate(e.creationTime),
-    ctime: smbTimeToDate(e.changeTime),
-  };
+/** Für Diagnose: Vorabladen erzwingen und Interna prüfen. */
+async function ensureLoaded() {
+  await loadInternals();
+  return { loaded: true, smb3Root: INTERNALS.smb3Root };
 }
 
-module.exports = { readdirCompat };
+module.exports = {
+  readdirCompat,
+  ensureLoaded,
+};