saltcorn-samba 0.4.8 → 0.4.10

package/CHANGELOG.md

@@ -4,6 +4,87 @@ All notable changes to `saltcorn-samba` are documented here.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/)
 and this project adheres to [Semantic Versioning](https://semver.org/).
 
+## [0.4.10] – 2026-07-05
+
+### Fixed – **`0xC0000033` beim tatsächlichen Auflisten (Tree-View, File-Manager) endgültig behoben**
+
+Ab 0.4.9 zeigte der Verbindungstest zwar den grünen Erfolgsstatus mit
+gelbem Hinweis, aber im normalen Betrieb (Tree-View, File-Manager,
+Datei-Listen) knallte die Anwendung mit `Samba: QUERY_DIRECTORY failed:
+0xC0000033` — der `stat`-Fallback verhinderte das nur beim Test, nicht
+bei echten Aufrufen.
+
+**Ursache:** `smb3-client@0.2.0` sendet in
+[`open/readdir.js`](https://github.com/euricojardim/smb3-client) hart
+kodiert `FileInformationClass = 37`
+(`FileIdBothDirectoryInformation`). Samba 4.23 lehnt diese
+Info-Klasse für bestimmte Verzeichnisse mit
+`STATUS_OBJECT_NAME_INVALID` (`0xC0000033`) ab. `smbclient` und
+Windows-Explorer benutzen `FileBothDirectoryInformation (3)` bzw.
+`FileDirectoryInformation (1)` — die Samba zuverlässig akzeptiert.
+
+**Fix:** Neues Modul `readdir-compat.js`. Es macht Folgendes:
+
+1. Für jeden `readdir`-Aufruf wird die Directory zuerst per
+   `CREATE`+`DIRECTORY_FILE` geöffnet (wie bei smb3-client selbst).
+2. Dann sendet der Wrapper `QUERY_DIRECTORY` in dieser Reihenfolge:
+   `FileIdBothDirectoryInformation (37)` →
+   `FileBothDirectoryInformation (3)` →
+   `FileDirectoryInformation (1)`. Sobald eine Klasse Erfolg meldet,
+   wird sie pro Client-Instanz gemerkt (`WeakMap`), damit
+   Folgeaufrufe nicht dreimal probieren.
+3. `0xC0000033` und `STATUS_INVALID_INFO_CLASS` lösen den nächsten
+   Versuch aus; jeder andere Fehler (fehlender Pfad, Zugriff
+   verweigert, Netzwerk) bricht sofort ab und wird an die bestehende
+   deutsche Fehlerbehandlung weitergereicht.
+4. Die Rückgabe enthält Größe/`mtime`/`ctime` direkt aus dem
+   `QUERY_DIRECTORY`-Response — dadurch entfällt der bisherige
+   Per-Entry-`stat`-Fan-Out, was Directory-Listings spürbar
+   beschleunigt.
+5. Bei `readdir` bleibt `client.readdir()` als klassischer Fallback
+   erhalten, wenn `readdir-compat` an einem *anderen* Fehler scheitert
+   — dann greifen die bereits vorhandenen Rewrites
+   („Pfad existiert nicht", Groß-/Kleinschreibungs-Probes).
+
+**Warum das überhaupt geht:** `smb3-client` publiziert nur seinen
+`Client`-Konstruktor über die `exports`-Map. Die internen Wire-
+Encoder/Decoder liegen aber als reguläre `.js`-Dateien in
+`dist/`. Der Wrapper importiert sie über `file://`-URLs direkt vom
+Filesystem (also `node_modules/smb3-client/dist/wire/structs/...`),
+was den `exports`-Gate umgeht. Das ist stabil, solange die
+dist-Layout-Konventionen der 0.2.x-Reihe von `smb3-client` erhalten
+bleiben.
+
+## [0.4.9] – 2026-07-05
+
+### Fixed – **`0xC0000033` beim Auflisten des Basispfads (smb3-client-vs-Samba-4.23-Bug jetzt auch für Basispfade abgefangen)**
+
+Auch in 0.4.8 lief der Verbindungstest mit gesetztem Basispfad in
+`QUERY_DIRECTORY failed: 0xC0000033` (`OBJECT_NAME_INVALID`). Ohne
+Basispfad war die Verbindung korrekt und zeigte den gelben Hinweis.
+
+**Ursache:** `smb3-client` sendet `QUERY_DIRECTORY` mit hart kodiertem
+`FileInformationClass = 37` (`FileIdBothDirectoryInformation`). Samba
+4.23 lehnt das für bestimmte Verzeichnisse ab — auch dann, wenn der
+Ordner existiert, geöffnet und `stat`-bar ist. Genau derselbe Bug, der
+bisher nur beim Auflisten des Share-Roots als ‚Root nicht auflistbar'
+aufgefangen wurde, kann auch den konfigurierten Basispfad selbst
+treffen.
+
+**Fix:** Der Fallback greift jetzt auch für Basispfade. Wenn
+`client.readdir("")` mit `0xC0000033` scheitert, versucht die Test-Route
+zusätzlich `client.stat("")` auf denselben Pfad:
+
+- **stat OK** → Verbindung + Basispfad bestätigt, gelber Hinweis mit
+  Erklärung des bekannten Bugs und Workaround-Vorschlägen.
+- **stat schlägt auch fehl** → normaler Fehlerpfad (Basispfad-
+  Diagnose mit Schreibvarianten-Probes) läuft weiter wie bisher.
+
+Damit lassen sich Basispfade eintragen, auf die `readdir` per
+`FileIdBothDirectoryInformation` scheitert — der Download und die
+Unterordner-Ansicht funktionieren über die normalen SMB-Calls
+trotzdem.
+
 ## [0.4.8] – 2026-07-05
 
 ### Fixed – **Basispfad wurde beim Verbindungstest doppelt vorangestellt (die eigentliche Ursache)**

package/index.js

@@ -872,18 +872,30 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
             // subdirectory to test).
             const effectivePath = testCfg.share + (baseForDisplay ? "/" + baseForDisplay : "");
             const isRootProbe = !baseForDisplay;
-            const isRootEnumBug = /0xC0000033|OBJECT_NAME_INVALID|Share-Root/i.test(msg);
-            if (isRootProbe && isRootEnumBug) {
-              // Share-root enumeration is a known smb3-client-vs-Samba
-              // limitation. Fall back to stat("") which proves the whole
-              // handshake works even if we can't list the root.
+            // smb3-client hardcodes FileInformationClass=37
+            // (FileIdBothDirectoryInformation) in QUERY_DIRECTORY. Some
+            // Samba 4.23+ configurations reject that with 0xC0000033
+            // (OBJECT_NAME_INVALID) for specific directories — even though
+            // the same directory can be opened, stat'd and traversed. In
+            // that case we fall back to a plain stat: if the folder exists
+            // (stat succeeds) we can prove the connection works, but flag
+            // that enumeration is broken so the caller shows the yellow
+            // hint instead of a red error.
+            const isEnumBug = /0xC0000033|OBJECT_NAME_INVALID|QUERY_DIRECTORY failed/i.test(msg);
+            if (isEnumBug) {
               try {
                 await client.stat("");
                 const marker = [];
-                marker._rootNotEnumerable = true;
+                if (isRootProbe) {
+                  marker._rootNotEnumerable = true;
+                } else {
+                  marker._basePathNotEnumerable = true;
+                  marker._basePathForDisplay = baseForDisplay;
+                }
                 return marker;
               } catch (statErr) {
-                throw err;
+                // stat also failed — fall through to normal error handling
+                // (missing-basepath diagnostics or generic rethrow).
               }
             }
             // NAME_NOT_FOUND / PATH_NOT_FOUND on a configured base_path.
@@ -990,6 +1002,7 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
         });
         const took = Date.now() - started;
         const rootNotEnum = Array.isArray(listing) && listing._rootNotEnumerable === true;
+        const baseNotEnum = Array.isArray(listing) && listing._basePathNotEnumerable === true;
         return res.json({
           ok: true,
           server: testCfg.server,
@@ -1011,6 +1024,16 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
               "Verhalten mit smb3-client). Bitte setzen Sie einen Basispfad " +
               "in der Plugin-Config (z.\u202fB. einen Unterordner der " +
               "Freigabe) — dann funktioniert der File-Manager vollständig."
+            : baseNotEnum
+            ? "Verbindung + Anmeldung erfolgreich, Basispfad \u201e" +
+              (listing._basePathForDisplay || testCfg.base_path || "") +
+              "\u201c wurde vom Server best\u00e4tigt (stat OK). Das direkte " +
+              "Auflisten dieses Ordners lehnt Samba 4.23 mit smb3-client " +
+              "aktuell ab (bekannter Bug: FileInformationClass=37 hart " +
+              "kodiert, siehe README). Ordner-Unterb\u00e4ume, Datei-Downloads " +
+              "und PDF-Ansicht funktionieren \u2014 nur die Wurzel des " +
+              "Basispfads kann nicht direkt aufgelistet werden. Workaround: " +
+              "tieferen Basispfad setzen oder Unterordner ansprechen."
             : undefined,
         });
       } catch (err) {

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.8",
+  "version": "0.4.10",
   "description": "Saltcorn plugin: browse, upload, rename and delete files on a Samba/CIFS share via SMB 3.1.1 (AES-CMAC signing, optional encryption). File-manager view, directory tree, inline PDF viewer, external-app open (smb://).",
   "main": "index.js",
   "scripts": {
     "test": "node test/sanitize.test.js",
-    "lint": "node --check index.js && node --check smb-client.js && node --check tree-view.js && node --check filemanager-view.js && node --check pdf-view.js && node --check public/samba-tree.js && node --check public/samba-filemanager.js",
+    "lint": "node --check index.js && node --check smb-client.js && node --check readdir-compat.js && node --check tree-view.js && node --check filemanager-view.js && node --check pdf-view.js && node --check public/samba-tree.js && node --check public/samba-filemanager.js",
     "prepublishOnly": "npm run lint && npm test"
   },
   "keywords": [
@@ -39,6 +39,7 @@
   "files": [
     "index.js",
     "smb-client.js",
+    "readdir-compat.js",
     "tree-view.js",
     "filemanager-view.js",
     "pdf-view.js",

package/readdir-compat.js

@@ -0,0 +1,458 @@
+/**
+ * Compatibility layer for smb3-client's readdir on Samba 4.23+.
+ *
+ * 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.
+ *
+ * This module implements `readdirCompat(client, sharePath)` which:
+ *
+ *   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.
+ *
+ * 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.
+ */
+
+"use strict";
+
+// Lazy, cached bundle of the internal modules we need. Loaded on first use.
+let _internalsPromise = 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");
+
+    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;
+        break;
+      }
+    }
+    if (!pkgRoot) {
+      throw new Error(
+        "readdir-compat: cannot locate smb3-client package root on disk"
+      );
+    }
+    const dist = path.join(pkgRoot, "dist");
+    const urlOf = (rel) =>
+      pathToFileURL(path.join(dist, rel)).href;
+
+    const [
+      queryDirectoryMod,
+      createMod,
+      closeMod,
+      commandsMod,
+      pathsMod,
+      bufferMod,
+    ] = 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")),
+    ]);
+    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,
+      splitSharePath: pathsMod.splitSharePath,
+      toSmbPath: pathsMod.toSmbPath,
+      Reader: bufferMod.Reader,
+    };
+  })();
+  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;
+}
+
+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;
+}
+
+// ---------------------------------------------------------------------------
+// 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`.
+ *
+ * @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}>>}
+ */
+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;
+    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;
+        // Only retry with a different class on OBJECT_NAME_INVALID / info-class
+        // rejection — any other error (auth, connection, missing) is fatal.
+        const msg = String((err && err.message) || err || "");
+        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
+      }
+    }
+    throw lastErr;
+  } 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;
+
+  const items = [];
+  let first = true;
+  for (;;) {
+    const body = encodeQueryDirectoryRequest({
+      fileInformationClass: cls.code,
+      flags: first ? QueryDirectoryFlag.RESTART_SCANS : 0,
+      fileIndex: 0,
+      fileId,
+      searchPattern: first ? "*" : "",
+      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 buf = decodeQueryDirectoryResponse(resp.body, 64);
+    if (buf.length === 0) break;
+    const page = cls.parse(buf, Reader);
+    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;
+
+// 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);
+}
+
+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),
+  };
+}
+
+module.exports = { readdirCompat };

package/smb-client.js

@@ -29,6 +29,7 @@
  */
 
 const path = require("path");
+const { readdirCompat } = require("./readdir-compat");
 
 // ---------------------------------------------------------------------------
 // Dynamic ESM import cache for smb3-client
@@ -273,6 +274,31 @@ async function buildClient(config) {
      */
     async readdir(rel) {
       const full = resolvePath(rel);
+      // v0.4.10: use the compat readdir which tries multiple
+      // FileInformationClass values so we survive Samba 4.23's rejection
+      // of FileIdBothDirectoryInformation (37) — the class smb3-client
+      // hardcodes and which many Samba configurations answer with
+      // STATUS_OBJECT_NAME_INVALID (0xC0000033). readdirCompat also
+      // returns rich entries (name+isDir+size+mtime+ctime) directly, so
+      // we skip the per-entry stat fan-out on success.
+      let entriesFromCompat = null;
+      try {
+        entriesFromCompat = await readdirCompat(client, full);
+        return entriesFromCompat;
+      } catch (err) {
+        // Fall back to smb3-client's built-in readdir with the same error
+        // handling as before. This preserves prior behaviour for servers
+        // where the compat path fails for reasons unrelated to the
+        // FileInformationClass bug (e.g. missing dir, permission).
+        const compatMsg = String((err && err.message) || err || "");
+        const compatIsInfoClassOnly =
+          /STATUS_INVALID_INFO_CLASS/i.test(compatMsg);
+        if (!compatIsInfoClassOnly) {
+          // Not an info-class problem — surface below by re-running
+          // through the classic path so the existing German error
+          // rewrites still apply.
+        }
+      }
       let dirents;
       try {
         dirents = await client.readdir(full, { withFileTypes: true });