saltcorn-samba 0.4.9 → 0.4.11

package/CHANGELOG.md

@@ -4,6 +4,125 @@ 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.11] – 2026-07-06
+
+### Changed – **Ehrliche Fehlerpropagation statt stiller Fallback**
+
+In 0.4.10 wurde der neue `readdir-compat.js`-Wrapper eingeführt, der
+vor dem eigentlichen `QUERY_DIRECTORY` die FileInformationClass
+automatisch von 37 → 3 → 1 durchprobiert. Zwei Probleme kamen dabei
+zum Vorschein:
+
+1. **Alle drei Info-Klassen lieferten weiterhin `0xC0000033`** auf
+   dem betroffenen Server. Das Umschalten der Info-Klasse ist also
+   *nicht* die eigentliche Ursache — die Annahme aus 0.4.10 war falsch.
+2. **Der Wrapper in `smb-client.js` fiel bei totalem Compat-Fehler
+   still auf das kaputte `client.readdir()` zurück**, das exakt
+   dieselbe (kaputte) FileInformationClass 37 verwendet. Dadurch
+   wurde die 0.4.10-Diagnostik komplett verschluckt und das Symptom
+   sah unverändert aus wie vor 0.4.10.
+
+**Fixes in 0.4.11:**
+
+- `smb-client.js` erkennt jetzt den 0xC0000033-Erschöpfungsfehler aus
+  dem Compat-Modul (Muster `"all classes exhausted"`) und propagiert
+  ihn direkt — kein stiller Retry mehr über das kaputte
+  `client.readdir()`.
+- `readdir-compat.js` wirft bei Ausschöpfung aller drei Klassen einen
+  synthetischen Fehler mit klarem Wortlaut:
+  `"QUERY_DIRECTORY failed: 0xC0000033 (all classes exhausted; no
+  working FileInformationClass on this server). Tried:
+  FileIdBothDirectoryInformation=37, FileBothDirectoryInformation=3,
+  FileDirectoryInformation=1."`
+  Der Fehler trägt zusätzlich ein `.attempts`-Array mit den
+  NT-Statuscodes pro Klasse für spätere Diagnose.
+
+### Was das für dich bedeutet
+
+Der gelbe Hinweis und `QUERY_DIRECTORY failed: 0xC0000033` sind
+**noch nicht behoben** — 0.4.11 macht den Fehler nur ehrlich sichtbar,
+sodass wir aus dem nächsten Diagnoselauf echte Signale bekommen.
+
+**Nächster Schritt — bitte auf dem Saltcorn-Server ausführen** (im
+entpackten Plugin-Verzeichnis, oder direkt aus dem ZIP):
+
+```bash
+cd /pfad/zu/saltcorn-samba
+node tools/diag-basepath.js \
+  --host 192.168.110.10 \
+  --share buero \
+  --path static \
+  --user 01_vassen \
+  --domain buero.ib-vassen.de \
+  --password 'DEIN_PASSWORT'
+```
+
+Das Skript führt 6 Sonden mit rohen NT-Statuscodes aus (TREE_CONNECT,
+CREATE, QUERY_DIRECTORY mit allen drei Info-Klassen, `stat`-Probe).
+Die Ausgabe zeigt, an welcher Stelle Samba den Fehler wirft und mit
+welchem Statuscode. Damit können wir 0.4.12 gezielt schreiben statt
+weiter zu raten.
+
+Ein heißer Kandidat für 0.4.12 (Wire-Format-Bug in `smb3-client`):
+`encodeQueryDirectoryRequest` setzt `FileNameOffset` immer auf 96,
+auch wenn kein Suchmuster gesendet wird — laut
+[MS-SMB2 §2.2.33](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/10906442-294c-46d3-8515-c277efe1f752)
+MUSS das Feld dann 0 sein. Bestätigung dafür aber bitte erst nach
+der Diagnose.
+
+---
+
+## [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)**

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.9",
+  "version": "0.4.11",
   "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,471 @@
+/**
+ * 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;
+    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;
+
+  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,35 @@ async function buildClient(config) {
      */
     async readdir(rel) {
       const full = resolvePath(rel);
+      // v0.4.11: prefer the compat readdir (which tries multiple
+      // FileInformationClass values). If it succeeds we are done — no
+      // extra per-entry stat fan-out needed because compat returns rich
+      // entries directly. If it fails, we ONLY fall back to smb3-client's
+      // built-in readdir when the compat failure was not itself the
+      // Samba-4.23 bug (0xC0000033 across all classes). If it *was*, the
+      // built-in readdir will produce the exact same 0xC0000033 — no
+      // point trying it, and it would hide the diagnostics compat has
+      // gathered. Instead we rethrow the compat error verbatim so the
+      // caller sees the true root cause.
+      let compatErr = null;
+      try {
+        return await readdirCompat(client, full);
+      } catch (err) {
+        compatErr = err;
+        const compatMsg = String((err && err.message) || err || "");
+        // If compat ran into the exact same info-class rejection with
+        // ALL classes exhausted, the built-in readdir cannot possibly
+        // help — it uses class 37, which compat already tried. Rethrow
+        // now so callers see the real reason.
+        if (/0xC0000033|OBJECT_NAME_INVALID/i.test(compatMsg) &&
+            /all classes exhausted|no working FileInformationClass/i.test(compatMsg)) {
+          throw err;
+        }
+        // Otherwise (compat failed for structural reasons like an unknown
+        // internal-module path, or a transient socket error) fall through
+        // to the classic path so the existing German error rewrites still
+        // apply.
+      }
       let dirents;
       try {
         dirents = await client.readdir(full, { withFileTypes: true });