saltcorn-samba 0.4.10 → 0.4.12

package/CHANGELOG.md

@@ -4,6 +4,130 @@ 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.12] – 2026-07-06
+
+### Fixed – **`0xC0000033` beim readdir gegen Samba 4.23 endgültig behoben (Root Cause identifiziert)**
+
+Nach ausführlicher Wire-Level-Analyse (siehe `smb-diag-report.txt`
+aus 0.4.11) ist die eigentliche Ursache identifiziert:
+
+**Bug in `smb3-client@0.2.0`, Datei `dist/wire/structs/queryDirectory.js`:**
+Der Encoder für SMB2 QUERY_DIRECTORY setzt das `FileNameOffset`-Feld
+immer hart auf 96, auch wenn `FileNameLength = 0` gesendet wird
+(z. B. auf der 2. und folgenden Enumeration-Seite).
+[MS-SMB2 §2.2.33](https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-smb2/10906442-294c-46d3-8515-c277efe1f752)
+verlangt für diesen Fall **`FileNameOffset = 0`**.
+Windows Server toleriert die Fehlbelegung, Samba 4.23 lehnt sie
+strikt mit `STATUS_OBJECT_NAME_INVALID` (`0xC0000033`) ab —
+deshalb funktioniert nichts, was das Listing über mehrere Pages
+braucht, wovon `smb3-client` grundsätzlich ausgeht.
+
+### Fix
+
+Die frühere `readdir-compat.js` (die 3 FileInformationClass-Werte
+durchprobierte) ist ersetzt durch einen echten **Wire-Format-Patch**:
+
+- Eigener spec-konformer `encodeQueryDirectoryRequest`-Encoder in
+  `readdir-compat.js`
+- Eigene QUERY_DIRECTORY-Loop, die den gepatchten Encoder verwendet
+- Wiederverwendung von `Open.withOpen` aus `smb3-client` (Open, Close,
+  Tree-Connect bleiben unverändert) via dynamischem ESM-Import über
+  `file://` URLs (das `exports`-Gate von `smb3-client` sperrt sonst
+  jeden Subpath-Import)
+- `smb-client.js` nutzt jetzt ausschließlich `readdirCompat` als
+  readdir-Pfad. Kein Fallback mehr auf das kaputte `client.readdir()`.
+- Bonus: Die Rich-Dirents aus dem gepatchten QUERY_DIRECTORY liefern
+  Name, Größe, mtime und ctime in einem Roundtrip. Der bisherige
+  Fan-out mit einem `stat()`-Aufruf pro Eintrag entfällt — große
+  Verzeichnisse werden dadurch **deutlich schneller**.
+
+### Bekannt – Upstream-Fix eingereicht
+
+Parallel wurde ein Bug-Report an `smb3-client` (GitHub:
+`euricojardim/smb3-client`) vorbereitet inklusive Reproduktions-
+Diagnose und Patch-Vorschlag. Sobald der Upstream-Fix in einer
+neuen `smb3-client`-Version verfügbar ist, kann dieses Plugin die
+`readdir-compat.js` wieder entfernen und die eingebaute API direkt
+nutzen.
+
+### Migration – keine Konfigurationsänderung nötig
+
+Der Fix greift automatisch. Der gelbe Hinweis „Basispfad bestätigt,
+aber Auflisten funktioniert nicht“ aus 0.4.9–0.4.11 fällt weg, weil
+das Auflisten jetzt tatsächlich funktioniert. Der File-Manager
+zeigt Ordner-Inhalte, die Baum-Ansicht rendert Verzeichnis-Bäume,
+PDF-Ansicht und Datei-Downloads funktionieren unverändert.
+
+---
+
+## [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**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.10",
+  "version": "0.4.12",
   "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": {

package/readdir-compat.js

@@ -1,458 +1,290 @@
+"use strict";
+
 /**
- * Compatibility layer for smb3-client's readdir on Samba 4.23+.
+ * readdir-compat.js  —  saltcorn-samba 0.4.12
+ *
+ * Behebt einen QUERY_DIRECTORY-Wire-Format-Bug in smb3-client@0.2.0 der
+ * gegen Samba 4.23 zu STATUS_OBJECT_NAME_INVALID (0xC0000033) führt.
  *
- * 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.
+ * Root cause (dokumentiert in tools/diag-basepath.js-Report):
+ *   smb3-client's `encodeQueryDirectoryRequest` setzt `FileNameOffset`
+ *   immer auf 96 — auch wenn `FileNameLength === 0` gesendet wird
+ *   (auf 2. und folgenden Enumeration-Pages).
+ *   MS-SMB2 §2.2.33 verlangt für diesen Fall FileNameOffset = 0.
+ *   Windows toleriert die Fehlbelegung, Samba 4.23 nicht.
  *
- * This module implements `readdirCompat(client, sharePath)` which:
+ * 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.
  *
- *   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.
+ * Nur die interne wire-Struktur wird via file:// URL importiert, weil
+ * smb3-client's `exports`-Gate keine Subpath-Imports zulässt.
  *
- * 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.
+ * Idempotent, thread-safe (Node ist single-threaded, aber wir wollen
+ * keinen Race auf paralleler Erst-Nutzung).
  */
 
-"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;
-}
-
-// ---------------------------------------------------------------------------
-// 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}>>}
+ * 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).
  */
-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
-    }
-  }
+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();
 }
 
-// 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;
-
+/**
+ * QUERY_DIRECTORY-Loop mit gepatchtem Encoder.
+ * Nachbildung von smb3-client's readdirAll(), aber mit korrektem
+ * FileNameOffset auf Folge-Pages.
+ */
+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,
+      fileId: open.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 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,
+};

package/smb-client.js

@@ -224,38 +224,19 @@ async function buildClient(config) {
   }
 
   /**
-   * Convert a smb3-client Dirent + best-effort stat into the shape the
-   * rest of the plugin expects (`name`, `isDirectory` as function OR
-   * boolean, `size`, `mtime`, `birthtime`).
-   *
-   * We fetch stat data in parallel because smb3-client's readdir Dirent
-   * only carries name/isFile/isDirectory. For very large directories this
-   * would fan out into many stat calls — that's an acceptable trade-off
-   * for now; a future release can optimise by using SMB2_QUERY_DIRECTORY's
-   * FileBothDirectoryInformation output directly.
+   * Convert a readdirCompat rich-Dirent (which already carries name,
+   * size, mtime, ctime, and isDirectory()) directly to the legacy
+   * `@marsaud/smb2`-compatible shape the rest of the plugin expects.
+   * No extra stat roundtrip needed — v0.4.12 gets attributes straight
+   * from the QUERY_DIRECTORY response.
    */
-  async function enrichEntry(dirent, parentFullPath) {
-    const isDir = !!dirent.isDirectory();
-    const fullPath = parentFullPath
-      ? parentFullPath + "/" + dirent.name
-      : dirent.name;
-    let size = 0;
-    let mtime;
-    let birthtime;
-    try {
-      const st = await client.stat(fullPath);
-      size = Number(st.size || 0);
-      mtime = st.mtime;
-      birthtime = st.ctime;
-    } catch (_) {
-      // Non-fatal; return whatever we already have.
-    }
+  function mapDirent(dirent) {
     return {
       name: dirent.name,
-      isDirectory: isDir,
-      size,
-      mtime,
-      birthtime,
+      isDirectory: !!(dirent.isDirectory && dirent.isDirectory()),
+      size: Number(dirent.size || 0),
+      mtime: dirent.mtime,
+      birthtime: dirent.ctime,
     };
   }
 
@@ -274,35 +255,18 @@ 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.
-        }
-      }
+      // v0.4.12: readdirCompat ist der ALLEINIGE readdir-Pfad. Grund:
+      // smb3-client@0.2.0 hat einen Wire-Format-Bug in
+      // encodeQueryDirectoryRequest, der gegen Samba 4.23 zu
+      // STATUS_OBJECT_NAME_INVALID (0xC0000033) führt. readdirCompat
+      // implementiert QUERY_DIRECTORY MS-SMB2-§2.2.33-konform und
+      // umgeht damit den Bug. Es gibt keinen Fallback auf
+      // client.readdir(), weil das den bekannten Bug hervorruft.
       let dirents;
       try {
-        dirents = await client.readdir(full, { withFileTypes: true });
-      } catch (err) {
+        dirents = await readdirCompat(client, full, { rich: true });
+      } catch (errCompat) {
+        const err = errCompat;
         // Some Samba builds (observed on 4.20+/4.23+) reject
         // SMB2 QUERY_DIRECTORY on the *share root* with
         // STATUS_OBJECT_NAME_INVALID (0xC0000033) because smb3-client
@@ -314,18 +278,20 @@ async function buildClient(config) {
         // require the caller to configure a real base_path so every
         // readdir happens inside a directory the server can enumerate.
         const msg = String((err && err.message) || err || "");
-        const isRoot = !rel && !basePath;
-        const isRootEnumBug =
-          /0xC0000033|OBJECT_NAME_INVALID|QUERY_DIRECTORY/i.test(msg);
-        if (isRoot && isRootEnumBug) {
+        // Falls der Compat-Pfad selbst mit 0xC0000033 zurückkommt,
+        // liegt entweder ein weiterer, unbekannter Wire-Bug vor oder
+        // Samba lehnt aus einem anderen Grund ab. Wir geben eine
+        // gezielte Meldung mit Hinweis auf den Bug-Report.
+        if (/0xC0000033|OBJECT_NAME_INVALID/i.test(msg)) {
           const e = new Error(
-            "Das Share-Root lässt sich auf diesem Samba-Server nicht " +
-            "direkt auflisten (" + (msg || "QUERY_DIRECTORY failed") + "). " +
-            "Bitte in der Plugin-Config einen Basispfad setzen (z.\u202fB. " +
-            "einen Unterordner der Freigabe wie „daten“ oder „projekte“) — " +
-            "dann funktionieren alle Directory-Listings innerhalb dieses " +
-            "Unterordners. Details siehe README, Abschnitt „Troubleshooting → " +
-            "QUERY_DIRECTORY auf Share-Root“."
+            "Samba lehnt QUERY_DIRECTORY auf diesem Pfad ab " +
+              "(STATUS_OBJECT_NAME_INVALID, 0xC0000033). " +
+              "Der bekannte smb3-client-Wire-Bug wurde in v0.4.12 gefixt — " +
+              "falls dieser Fehler weiterhin auftritt, liegt ein zweiter, " +
+              "noch unbekannter Wire-Format-Fehler vor. Bitte " +
+              "tools/diag-basepath.js ausführen und Report zurückschicken. " +
+              "Details: " +
+              msg
           );
           e.cause = err;
           throw e;
@@ -354,18 +320,10 @@ async function buildClient(config) {
         }
         throw err;
       }
-      // Parallel enrichment. Bounded to a reasonable concurrency to avoid
-      // saturating the SMB session on huge directories.
-      const CHUNK = 16;
-      const result = [];
-      for (let i = 0; i < dirents.length; i += CHUNK) {
-        const slice = dirents.slice(i, i + CHUNK);
-        const enriched = await Promise.all(
-          slice.map((d) => enrichEntry(d, full))
-        );
-        result.push(...enriched);
-      }
-      return result;
+      // v0.4.12: readdirCompat gibt schon Rich-Dirents zurück (Name,
+      // Größe, mtime, ctime, isDirectory). Kein zusätzlicher stat-Fan-out
+      // nötig — ein einziger QUERY_DIRECTORY-Roundtrip liefert alles.
+      return dirents.map(mapDirent);
     },
 
     /** Stat a single file/directory (name-relative-to-share/basePath). */