saltcorn-samba 0.4.11 → 0.4.13

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,39 +255,18 @@ 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.
-      }
+      // 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
@@ -318,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;
@@ -358,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). */

package/tools/diag-basepath.js

@@ -0,0 +1,115 @@
+#!/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++;
+  }
+
+  await client.disconnect();
+  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,352 @@
+#!/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 (_) {}
+  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);
+});