saltcorn-samba 0.4.12 → 0.4.14

package/CHANGELOG.md

@@ -4,6 +4,95 @@ 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.14] – 2026-07-06
+
+### Changed – Code-Review / Aufräumen (keine Verhaltensänderung)
+
+Interne QS-Runde nach dem v0.4.13-Fix. Der Bug war behoben, aber die
+Kommentare, Fehlertexte und die Fallback-Logik im Connection-Test
+verwiesen noch auf die alte, mittlerweile widerlegte Hypothese
+(`FileInformationClass=37 hart kodiert`). Alle diese Stellen wurden
+auf den tatsächlichen Root Cause aktualisiert bzw. gelöscht.
+
+**readdir-compat.js:**
+- Docstring priorisiert den tatsächlichen Hauptbug (leeres Pattern
+  auf Folge-Pages) und schiebt den FileNameOffset-Bug in die Sekundär-
+  rolle (defensiv abgefangen, wird bei aktueller Loop nie getriggert).
+- Encoder-Docstring erklärt, dass der `pat.length === 0`-Zweig nur
+  noch defensive Sicherheit ist.
+
+**smb-client.js:**
+- Der lange, spekulative Kommentar-Block über „Some Samba builds
+  reject QUERY_DIRECTORY on the share root because FileInformation-
+  Class=37 is hardcoded“ wurde entfernt. Der wahre Grund steht jetzt
+  kurz und präzise dort.
+- Die 0xC0000033-Fehlermeldung verweist nicht mehr auf v0.4.12 als Fix
+  und nicht mehr auf `tools/diag-basepath.js`, sondern auf
+  `tools/diag-wire.js` (das aussagekräftigere Tool).
+
+**index.js (Connection-Test-Route):**
+- Der „gelber Hinweis“-Fallback bleibt als Safety Net, wird aber nur
+  noch aktiv, wenn `readdir` fehlschlägt und `stat` erfolgreich ist —
+  ein Zustand, der seit v0.4.13 nicht mehr auftreten sollte.
+- Der Hinweistext sagt jetzt „unerwarteter Zustand, bitte diag-wire.js
+  ausführen“ statt der alten, jetzt falschen Erklärung mit
+  `FileInformationClass=37`.
+
+**tools/diag-basepath.js:**
+- FIX: `client.disconnect()` → `client.close()`. smb3-client's Client
+  hat `close()`, nicht `disconnect()` (das war die marsaud-API). Der
+  Aufruf schlug bisher am Ende jedes Diagnostic-Runs mit einer
+  TypeError-Meldung fehl, ohne aber das Resultat zu beeinträchtigen.
+
+**tools/diag-wire.js:**
+- FIX: Zusätzlich zu `open.close()` wird jetzt auch `client.close()`
+  aufgerufen, damit der TCP-Socket sauber geschlossen wird.
+
+## [0.4.13] – 2026-07-06
+
+### Fixed – **QUERY_DIRECTORY leere Patterns → 0xC0000033 (die eigentliche Ursache)**
+
+Mit v0.4.12 wurde ein Wire-Bug in smb3-client (FileNameOffset) gefixt,
+aber Samba lehnte weiterhin ab. Mit dem neuen `tools/diag-wire.js` konnte
+die tatsächliche Ursache byteweise verifiziert werden:
+
+**Bug:** smb3-client's `readdirAll` sendet ab der 2. Enumeration-Seite
+`searchPattern=""` (leerer String). Windows toleriert das, aber Samba's
+`source3/smbd/smb2_query_directory.c` enthält den strikten Check:
+
+```c
+if (state->in_file_name[0] == '\0') {
+    tevent_req_nterror(req, NT_STATUS_OBJECT_NAME_INVALID);
+    return tevent_req_post(req, ev);
+}
+```
+
+Das ergibt exakt den STATUS_OBJECT_NAME_INVALID (0xC0000033), den wir
+seit v0.4.0 sehen.
+
+**Fix in `readdir-compat.js`:** Der eigene Enumeration-Loop sendet auf
+**jeder** Seite `searchPattern="*"`, nicht nur beim ersten Request.
+`RESTART_SCANS` wird nur beim ersten Request gesetzt; ab dann sendet
+Samba nach dem letzten Batch korrekt STATUS_NO_MORE_FILES, was den Loop
+sauber terminiert. Verifiziert via `diag-wire.js`:
+
+- Probe 1 (pat=`*`, RESTART): STATUS_SUCCESS, 8 Einträge
+- Probe 2 (pat=`*`, ohne RESTART): STATUS_NO_MORE_FILES → Loop-Ende
+- Probe 6 (pat=`""`, offset=0): **0xC0000033** ← der Bug
+
+### Added
+
+- `tools/diag-wire.js` – Wire-Level-Diagnose mit Hex-Dump der SMB2-Bytes,
+  testet 6 verschiedene QUERY_DIRECTORY-Varianten (Info-Class, Buffer-
+  Größe, mit/ohne Pattern). Nützlich für zukünftige Kompatibilitäts-
+  probleme mit anderen SMB-Servern.
+
+### Upstream-Report aktualisiert
+
+`smb3-client-bug-report.md` beschreibt jetzt beide Bugs (FileNameOffset
+**und** leeres Pattern gegen Samba). Beide Fixes sind identisch simpel:
+auf jeder Page `*` senden.
+
 ## [0.4.12] – 2026-07-06
 
 ### Fixed – **`0xC0000033` beim readdir gegen Samba 4.23 endgültig behoben (Root Cause identifiziert)**

package/index.js

@@ -1019,21 +1019,18 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
           })),
           truncated: Array.isArray(listing) && listing.length > 20,
           note: rootNotEnum
-            ? "Verbindung + Anmeldung erfolgreich. Der Server erlaubt jedoch " +
-              "kein direktes Auflisten des Share-Roots (bekanntes Samba-" +
-              "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."
+            ? "Verbindung + Anmeldung erfolgreich, aber der Share-Root konnte " +
+              "nicht aufgelistet werden (stat OK, readdir schlug fehl). Das ist " +
+              "ein unerwarteter Zustand \u2014 seit v0.4.13 sollte readdir gegen " +
+              "Samba fehlerfrei laufen. Bitte tools/diag-wire.js ausf\u00fchren " +
+              "und den Report melden."
             : 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."
+              "\u201c wurde vom Server best\u00e4tigt (stat OK), das direkte " +
+              "Auflisten schlug aber fehl. Das ist ein unerwarteter Zustand \u2014 " +
+              "seit v0.4.13 sollte readdir gegen Samba fehlerfrei laufen. Bitte " +
+              "tools/diag-wire.js ausf\u00fchren und den Report melden."
             : undefined,
         });
       } catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.12",
+  "version": "0.4.14",
   "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": {
@@ -44,6 +44,7 @@
     "filemanager-view.js",
     "pdf-view.js",
     "public/",
+    "tools/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"

package/readdir-compat.js

@@ -1,17 +1,30 @@
 "use strict";
 
 /**
- * readdir-compat.js  —  saltcorn-samba 0.4.12
+ * readdir-compat.js  —  saltcorn-samba 0.4.14
  *
- * 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.
+ * 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.
  *
- * Root cause (dokumentiert in tools/diag-basepath.js-Report):
+ * BUG 1 (leeres Pattern auf Folge-Pages)  ─ Hauptursache des 0xC0000033:
+ *   smb3-client's `readdirAll` sendet ab der 2. Enumeration-Page
+ *   `searchPattern=""`. Windows toleriert das, Samba 4.23 lehnt es
+ *   strikt ab: `source3/smbd/smb2_query_directory.c` prüft
+ *   `in_file_name[0] == '\0'` und antwortet mit
+ *   STATUS_OBJECT_NAME_INVALID.
+ *   Fix (in readdirAllFixed): Auf jeder Page `*` senden. RESTART_SCANS
+ *   nur beim ersten Request. Samba beendet nach der letzten Seite
+ *   sauber mit STATUS_NO_MORE_FILES.
+ *
+ * BUG 2 (FileNameOffset bei leerem Pattern) ─ defensiv abgefangen:
  *   smb3-client's `encodeQueryDirectoryRequest` setzt `FileNameOffset`
- *   immer auf 96 — auch wenn `FileNameLength === 0` gesendet wird
- *   (auf 2. und folgenden Enumeration-Pages).
+ *   immer auf 96 — auch wenn `FileNameLength === 0` gesendet wird.
  *   MS-SMB2 §2.2.33 verlangt für diesen Fall FileNameOffset = 0.
- *   Windows toleriert die Fehlbelegung, Samba 4.23 nicht.
+ *   Da wir seit Bug-1-Fix ohnehin nie mit leerem Pattern senden, kann
+ *   dieser Bug nicht mehr getriggert werden — encodeQueryDirectory-
+ *   RequestFixed behandelt den Fall trotzdem spec-konform, falls ein
+ *   Aufrufer den Encoder direkt benutzt oder ein zukünftiger Server
+ *   noch strenger prüft.
  *
  * Strategie:
  *   Statt smb3-client's `client.readdir()` / `readdirAll` verwenden wir
@@ -19,11 +32,9 @@
  *   verwendet (Open, Close, Tree-Connect bleiben unverändert) und nur
  *   die kaputte QUERY_DIRECTORY-Loop durch eine spec-konforme ersetzt.
  *
- * Nur die interne wire-Struktur wird via file:// URL importiert, weil
- * smb3-client's `exports`-Gate keine Subpath-Imports zulässt.
- *
- * Idempotent, thread-safe (Node ist single-threaded, aber wir wollen
- * keinen Race auf paralleler Erst-Nutzung).
+ * Die internen wire-Module werden via `file://` URL geladen, weil
+ * smb3-client's `exports`-Gate keine Subpath-Imports über den
+ * Package-Namen zulässt (nicht einmal `smb3-client/package.json`).
  */
 
 const fs = require("fs");
@@ -130,9 +141,15 @@ function loadInternals() {
 
 /**
  * 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).
+ *
+ * Unterschied zum Original in smb3-client@0.2.0:
+ *   `FileNameOffset` wird auf 0 gesetzt, wenn `pat.length === 0`
+ *   (statt hart auf 64+32=96). MS-SMB2 §2.2.33 verlangt bei
+ *   `FileNameLength=0` genau `FileNameOffset=0`.
+ *
+ * In der aktuellen Compat-Loop wird immer `pat="*"` gesendet, daher
+ * wird dieser Zweig nie erreicht. Er bleibt als defensive Absicherung
+ * gegen Aufrufer, die den Encoder direkt mit leerem Pattern nutzen.
  */
 function encodeQueryDirectoryRequestFixed(I, req) {
   const pat = req.searchPattern
@@ -154,8 +171,13 @@ function encodeQueryDirectoryRequestFixed(I, req) {
 
 /**
  * QUERY_DIRECTORY-Loop mit gepatchtem Encoder.
- * Nachbildung von smb3-client's readdirAll(), aber mit korrektem
- * FileNameOffset auf Folge-Pages.
+ *
+ * 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 readdirAllFixed(I, open) {
   const items = [];
@@ -167,7 +189,7 @@ async function readdirAllFixed(I, open) {
       flags: first ? I.QueryDirectoryFlag.RESTART_SCANS : 0,
       fileIndex: 0,
       fileId: open.fileId,
-      searchPattern: first ? "*" : "",
+      searchPattern: "*", // IMMER "*", nie "" — Samba lehnt leer ab
       outputBufferLength: 65536,
     });
     first = false;

package/smb-client.js

@@ -227,8 +227,8 @@ async function buildClient(config) {
    * 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.
+   * No extra stat roundtrip needed — attributes come straight from the
+   * single QUERY_DIRECTORY response.
    */
   function mapDirent(dirent) {
     return {
@@ -255,42 +255,33 @@ async function buildClient(config) {
      */
     async readdir(rel) {
       const full = resolvePath(rel);
-      // 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.
+      // readdirCompat ist der ALLEINIGE readdir-Pfad. Grund: smb3-
+      // client@0.2.0 hat zwei QUERY_DIRECTORY-Wire-Bugs, die gegen
+      // Samba 4.23 zu STATUS_OBJECT_NAME_INVALID (0xC0000033) führen
+      // (leeres Pattern auf Folge-Pages + falscher FileNameOffset).
+      // readdirCompat implementiert QUERY_DIRECTORY MS-SMB2-§2.2.33-
+      // konform und umgeht beide Bugs. Kein Fallback auf
+      // client.readdir() — das würde die Bugs reproduzieren.
       let dirents;
       try {
         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
-        // asks for FileIdBothDirectoryInformation (class 37) on a
-        // handle opened with an empty filename. We cannot swap the
-        // information class from userland, and Samba refuses both
-        // "." (→ STATUS_OBJECT_NAME_NOT_FOUND) and "*" (→ CREATE with
-        // wildcard is protocol-illegal). The clean way out is:
-        // 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 || "");
         // 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.
+        // Samba lehnt aus einem anderen Grund ab (z. B. fehlende
+        // Rechte auf die Zielressource). Wir geben eine gezielte
+        // Meldung mit Handlungsanweisung.
         if (/0xC0000033|OBJECT_NAME_INVALID/i.test(msg)) {
           const e = new Error(
-            "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: " +
+            "Samba lehnt QUERY_DIRECTORY auf diesem Pfad unerwartet ab " +
+              "(STATUS_OBJECT_NAME_INVALID, 0xC0000033). Die bekannten " +
+              "smb3-client-Wire-Bugs sind in dieser Plugin-Version " +
+              "bereits gepatcht — falls dieser Fehler dennoch auftritt, " +
+              "liegt ein bislang unbekannter Wire-Format-Fehler oder ein " +
+              "Rechteproblem vor. Bitte tools/diag-wire.js ausführen " +
+              "und den Report zurücksenden. Details: " +
               msg
           );
           e.cause = err;
@@ -320,9 +311,9 @@ async function buildClient(config) {
         }
         throw err;
       }
-      // 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.
+      // readdirCompat gibt 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);
     },
 

package/tools/diag-basepath.js

@@ -0,0 +1,118 @@
+#!/usr/bin/env node
+/**
+ * Standalone diagnostic script for saltcorn-samba.
+ * Runs a series of individual SMB3 operations against a share so we can see
+ * exactly which primitive fails and why. Prints raw NT status codes.
+ *
+ * Usage (from the plugin directory, so smb3-client resolves):
+ *
+ *   node tools/diag-basepath.js \
+ *     --host 192.168.110.10 --share buero --user 01_vassen \
+ *     --domain buero.ib-vassen.de --password '…' \
+ *     --path static
+ *
+ * The script never writes; it only opens handles.
+ */
+
+"use strict";
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const required = ["host", "share", "user", "path"];
+  for (const k of required) {
+    if (!args[k]) {
+      console.error("missing required --" + k);
+      process.exit(2);
+    }
+  }
+  const password = args.password || process.env.SMB_PASSWORD || "";
+  if (!password) {
+    console.error("missing --password (or SMB_PASSWORD env var)");
+    process.exit(2);
+  }
+
+  const { Client } = await import("smb3-client");
+
+  const client = new Client({
+    host: args.host,
+    port: Number(args.port) || 445,
+    domain: args.domain || "",
+    username: args.user,
+    password,
+    connectTimeout: 10_000,
+    requestTimeout: 30_000,
+    signing: args.signing || "if-offered",
+    encryption: args.encryption || "if-offered",
+  });
+
+  console.log("[1/7] Connecting …");
+  await client.connect();
+  console.log("      \u2713 TCP + Negotiate + Session-Setup + Auth OK");
+
+  const share = args.share;
+  const path = args.path;
+  const shareAndPath = share + "/" + path;
+  console.log("[2/7] TREE_CONNECT to \\\\" + args.host + "\\" + share + " \u2026");
+  try {
+    // Trigger TREE_CONNECT by touching the raw internal — but smb3-client
+    // does that implicitly on the first per-share call. So instead we call
+    // a cheap op below and let the connect surface the error there.
+    console.log("      (deferred until first op)");
+  } catch (e) {
+    console.error("      \u2717 TREE_CONNECT failed:", e && e.message);
+  }
+
+  // --- Probes ------------------------------------------------------------
+  const probes = [
+    { label: "readdir(share)      \u2014 SHARE ROOT",           op: () => client.readdir(share) },
+    { label: "readdir(share/'')   \u2014 empty subpath",         op: () => client.readdir(share + "/") },
+    { label: "stat(share/path)    \u2014 target as-is",           op: () => client.stat(shareAndPath) },
+    { label: "readdir(share/path) \u2014 target as-is",           op: () => client.readdir(shareAndPath) },
+    { label: "readdir(share/PATH) \u2014 target uppercased",      op: () => client.readdir(share + "/" + path.toUpperCase()) },
+    { label: "readdir(share/path.lc) \u2014 target lowercased",   op: () => client.readdir(share + "/" + path.toLowerCase()) },
+  ];
+
+  let step = 3;
+  for (const p of probes) {
+    console.log("[" + step + "/7] " + p.label);
+    try {
+      const r = await p.op();
+      const preview = Array.isArray(r)
+        ? " (" + r.length + " entries" +
+          (r.length ? ", first: " +
+            JSON.stringify(r.slice(0, 3).map((e) => (typeof e === "string" ? e : e.name))) : "") + ")"
+        : " (" + JSON.stringify(r).slice(0, 120) + ")";
+      console.log("      \u2713 OK" + preview);
+    } catch (e) {
+      console.log("      \u2717 " + (e && e.message ? e.message.split("\n")[0] : String(e)));
+      if (e && e.status) console.log("        NT status: 0x" + e.status.toString(16));
+      if (e && e.code)   console.log("        error code: " + e.code);
+    }
+    step++;
+  }
+
+  // smb3-client's Client has close(), not disconnect() — the old
+  // marsaud API used disconnect. Use close() and ignore errors so a
+  // failing probe still tears down cleanly.
+  try { await client.close(); } catch (_) {}
+  console.log("Done.");
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const nxt = argv[i + 1];
+      if (!nxt || nxt.startsWith("--")) { out[key] = true; }
+      else { out[key] = nxt; i++; }
+    }
+  }
+  return out;
+}
+
+main().catch((e) => {
+  console.error("FATAL:", e && e.stack || e);
+  process.exit(1);
+});

package/tools/diag-wire.js

@@ -0,0 +1,355 @@
+#!/usr/bin/env node
+/**
+ * diag-wire.js — Wire-level QUERY_DIRECTORY diagnostic.
+ *
+ * Opens a connection, tree-connects, opens the target directory, then sends
+ * a hand-built QUERY_DIRECTORY packet with FULL HEX DUMP of both request
+ * and response. This bypasses smb3-client's encoders so we can compare bytes.
+ *
+ * Usage (from the plugin directory):
+ *   node tools/diag-wire.js \
+ *     --host 192.168.110.10 --share buero --user 01_vassen \
+ *     --domain buero.ib-vassen.de --password '...' \
+ *     --path static
+ */
+
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const url = require("url");
+
+async function loadInternals() {
+  const candidates = [
+    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 (!smb3Root) {
+    throw new Error("smb3-client not found in node_modules");
+  }
+  const distDir = path.join(smb3Root, "dist");
+  const load = (rel) => import(url.pathToFileURL(path.join(distDir, rel)).href);
+
+  const [
+    idx,
+    bufMod,
+    qdMod,
+    cmdMod,
+    qiMod,
+    createStructMod,
+    pathsMod,
+    errMod,
+    openMod,
+  ] = await Promise.all([
+    load("index.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 {
+    Client: idx.Client,
+    Writer: bufMod.Writer,
+    encodeQueryDirectoryRequest: qdMod.encodeQueryDirectoryRequest,
+    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,
+    splitSharePath: pathsMod.splitSharePath,
+    toSmbPath: pathsMod.toSmbPath,
+    SmbError: errMod.SmbError,
+    Open: openMod.Open,
+  };
+}
+
+function hex(buf, label) {
+  console.log(`\n--- ${label} (${buf.length} bytes) ---`);
+  for (let off = 0; off < buf.length; off += 16) {
+    const slice = buf.slice(off, Math.min(off + 16, buf.length));
+    const hexPart = Array.from(slice)
+      .map((b) => b.toString(16).padStart(2, "0"))
+      .join(" ")
+      .padEnd(48);
+    const asciiPart = Array.from(slice)
+      .map((b) => (b >= 32 && b < 127 ? String.fromCharCode(b) : "."))
+      .join("");
+    console.log(
+      `${off.toString(16).padStart(4, "0")}  ${hexPart}  ${asciiPart}`
+    );
+  }
+}
+
+// Build QUERY_DIRECTORY body byte-by-byte with named fields
+function buildQdBody(I, opts) {
+  const {
+    fileInformationClass,
+    flags,
+    fileIndex,
+    fileId,
+    searchPattern,
+    outputBufferLength,
+    forceFileNameOffsetZero, // testing variant
+  } = opts;
+
+  const pat = Buffer.from(searchPattern, "utf16le");
+  const w = new I.Writer();
+  w.u16(33); // StructureSize
+  w.u8(fileInformationClass);
+  w.u8(flags);
+  w.u32(fileIndex);
+  w.bytes(fileId); // 16
+  const fileNameOffset = forceFileNameOffsetZero
+    ? 0
+    : pat.length === 0
+      ? 0
+      : 64 + 32;
+  w.u16(fileNameOffset);
+  w.u16(pat.length);
+  w.u32(outputBufferLength);
+  if (pat.length === 0) {
+    w.u8(0); // pad byte
+  } else {
+    w.bytes(pat);
+  }
+  return w.buffer();
+}
+
+async function sendRaw(open, I, opts, label) {
+  const body = buildQdBody(I, opts);
+  hex(body, `${label} REQUEST BODY`);
+  console.log(
+    `Fields: StructSize=33, FileInformationClass=${opts.fileInformationClass}, ` +
+      `Flags=${opts.flags}, FileNameLength=${
+        Buffer.from(opts.searchPattern, "utf16le").length
+      }, ` +
+      `OutputBufferLength=${opts.outputBufferLength}`
+  );
+  const fnOff = body.readUInt16LE(32 - 8);
+  console.log(`FileNameOffset (from body): ${fnOff}`);
+
+  const signing = open.tree.session.makeSigning();
+  try {
+    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,
+    });
+    console.log(
+      `RESPONSE status: 0x${resp.header.status.toString(16)} (${I.statusName(
+        resp.header.status
+      )})`
+    );
+    hex(resp.body.slice(0, Math.min(resp.body.length, 128)), `${label} RESPONSE BODY (first 128)`);
+    if (I.isSuccess(resp.header.status)) {
+      const buf = I.decodeQueryDirectoryResponse(resp.body, 64);
+      const items = I.parseFileIdBothDirectoryInformation(buf);
+      console.log(
+        `Decoded ${items.length} entries: ${items.slice(0, 5).map((e) => e.fileName).join(", ")}`
+      );
+    }
+    return resp;
+  } catch (e) {
+    console.log(`SEND ERROR: ${e.message}`);
+    if (e.status) console.log(`  NT status: 0x${e.status.toString(16)}`);
+    return null;
+  }
+}
+
+async function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const required = ["host", "share", "user", "path"];
+  for (const k of required) {
+    if (!args[k]) {
+      console.error(`missing required --${k}`);
+      process.exit(2);
+    }
+  }
+  const password = args.password || process.env.SMB_PASSWORD || "";
+  if (!password) {
+    console.error("missing --password");
+    process.exit(2);
+  }
+
+  const I = await loadInternals();
+
+  const client = new I.Client({
+    host: args.host,
+    port: Number(args.port) || 445,
+    domain: args.domain || "",
+    username: args.user,
+    password,
+    connectTimeout: 10000,
+    requestTimeout: 30000,
+    signing: args.signing || "if-offered",
+    encryption: args.encryption || "if-offered",
+  });
+
+  console.log("Connecting…");
+  await client.connect();
+  console.log("Connected");
+
+  const fullPath = `${args.share}/${args.path}`;
+  const { share, rest } = I.splitSharePath(fullPath);
+  const tree = await client.treeFor(share);
+  console.log(`Tree connected: treeId=${tree.treeId}`);
+
+  // Open the target directory
+  const open = await I.Open.create(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,
+    fileAttributes: 0,
+  });
+  console.log(`Opened dir, fileId hex: ${open.fileId.toString("hex")}`);
+
+  // ---------------- 6 probes ----------------
+  console.log("\n============ PROBE 1: pat='*', flags=RESTART, class=FileIdBothDir ============");
+  await sendRaw(
+    open,
+    I,
+    {
+      fileInformationClass: I.FileInformationClass.FileIdBothDirectoryInformation,
+      flags: I.QueryDirectoryFlag.RESTART_SCANS,
+      fileIndex: 0,
+      fileId: open.fileId,
+      searchPattern: "*",
+      outputBufferLength: 65536,
+    },
+    "P1"
+  );
+
+  console.log("\n============ PROBE 2: pat='*', flags=0, class=FileIdBothDir ============");
+  await sendRaw(
+    open,
+    I,
+    {
+      fileInformationClass: I.FileInformationClass.FileIdBothDirectoryInformation,
+      flags: 0,
+      fileIndex: 0,
+      fileId: open.fileId,
+      searchPattern: "*",
+      outputBufferLength: 65536,
+    },
+    "P2"
+  );
+
+  console.log("\n============ PROBE 3: pat='*', flags=RESTART, class=FileBothDir (0x03) ============");
+  await sendRaw(
+    open,
+    I,
+    {
+      fileInformationClass: I.FileInformationClass.FileBothDirectoryInformation ?? 3,
+      flags: I.QueryDirectoryFlag.RESTART_SCANS,
+      fileIndex: 0,
+      fileId: open.fileId,
+      searchPattern: "*",
+      outputBufferLength: 65536,
+    },
+    "P3"
+  );
+
+  console.log("\n============ PROBE 4: pat='*', flags=RESTART, class=FileDirInfo (0x01) ============");
+  await sendRaw(
+    open,
+    I,
+    {
+      fileInformationClass: I.FileInformationClass.FileDirectoryInformation ?? 1,
+      flags: I.QueryDirectoryFlag.RESTART_SCANS,
+      fileIndex: 0,
+      fileId: open.fileId,
+      searchPattern: "*",
+      outputBufferLength: 65536,
+    },
+    "P4"
+  );
+
+  console.log("\n============ PROBE 5: pat='*', outBuf=8192, flags=RESTART ============");
+  await sendRaw(
+    open,
+    I,
+    {
+      fileInformationClass: I.FileInformationClass.FileIdBothDirectoryInformation,
+      flags: I.QueryDirectoryFlag.RESTART_SCANS,
+      fileIndex: 0,
+      fileId: open.fileId,
+      searchPattern: "*",
+      outputBufferLength: 8192,
+    },
+    "P5"
+  );
+
+  console.log("\n============ PROBE 6: pat='', flags=RESTART (empty pattern, offset=0) ============");
+  await sendRaw(
+    open,
+    I,
+    {
+      fileInformationClass: I.FileInformationClass.FileIdBothDirectoryInformation,
+      flags: I.QueryDirectoryFlag.RESTART_SCANS,
+      fileIndex: 0,
+      fileId: open.fileId,
+      searchPattern: "",
+      outputBufferLength: 65536,
+    },
+    "P6"
+  );
+
+  console.log("\nAvailable FileInformationClass values:");
+  console.log(JSON.stringify(I.FileInformationClass, null, 2));
+
+  try {
+    await open.close();
+  } catch (_) {}
+  try {
+    await client.close();
+  } catch (_) {}
+  console.log("\nDone.");
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (a.startsWith("--")) {
+      const key = a.slice(2);
+      const nxt = argv[i + 1];
+      if (!nxt || nxt.startsWith("--")) {
+        out[key] = true;
+      } else {
+        out[key] = nxt;
+        i++;
+      }
+    }
+  }
+  return out;
+}
+
+main().catch((e) => {
+  console.error("FATAL:", (e && e.stack) || e);
+  process.exit(1);
+});