saltcorn-samba 0.4.1 → 0.4.3

package/CHANGELOG.md

@@ -4,6 +4,77 @@ 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.3] – 2026-07-05
+
+### Fixed – **Unklare Meldung bei nicht-existierendem Basispfad**
+
+Wenn ein Basispfad angegeben wurde, der auf dem Server nicht existiert
+(oder für den angemeldeten Benutzer nicht sichtbar ist), meldete die
+Test-Route bisher nur die rohe Server-Antwort:
+
+```
+CREATE failed: STATUS_OBJECT_NAME_NOT_FOUND (ENOENT)
+CREATE failed: STATUS_OBJECT_PATH_NOT_FOUND (ENOENT)
+```
+
+Daraus konnte der Benutzer nicht erkennen, ob es sich um einen Tippfehler,
+um einen Klein-/Großschreibungs-Konflikt (Samba mit `case sensitive = yes`)
+oder um eine Berechtigung handelt.
+
+**Neu:**
+
+1. Die Test-Route prüft den Basispfad jetzt zuerst mit `stat()`, bevor sie
+   `readdir()` versucht. Fehlt der Ordner, wird eine deutsche Meldung
+   zurückgegeben, die den betroffenen Pfad, die Freigabe und typische
+   Ursachen (Schreibweise, Groß-/Kleinschreibung, Zugriffsrechte) nennt.
+2. Zusätzlich liefert die Route ein `diagnostics`-Objekt zurück, das
+   den fehlenden Segmentnamen, den übergeordneten Pfad und — sofern der
+   übergeordnete Ordner auflistbar ist — dessen tatsächliche Einträge
+   enthält. Das Test-UI hebt ähnlich geschriebene Nachbareinträge hervor,
+   damit Tippfehler oder Case-Mismatch sofort sichtbar werden.
+3. Der `smb-client.js`-`readdir()`-Wrapper mappt `OBJECT_NAME_NOT_FOUND`
+   und `OBJECT_PATH_NOT_FOUND` ebenfalls auf eine deutsche Meldung, damit
+   auch der File-Manager (außerhalb der Test-Route) verständlich über
+   fehlende Ordner informiert.
+
+**Kein Config-Migrationsschritt nötig.** Wer die neuen Diagnose-Boxen
+sehen will, muss lediglich `pv-host/saltcorn-samba@0.4.3` einspielen.
+
+## [0.4.2] – 2026-07-05
+
+### Fixed – **Dropdown-Felder zeigen `[object Object]` statt Optionen**
+
+Die neuen Felder `signing_mode` und `encryption_mode` wurden in der
+Saltcorn-UI mit `[object Object]` als einzige Auswahl gerendert.
+
+**Ursache:** In der genutzten Saltcorn-Version werden `attributes.options`
+als einfaches String-Array erwartet (`["a", "b", "c"]`), nicht als
+`{value, label}`-Objekt. Die Objekt-Form ist erst in neueren Builds
+vollständig unterstützt; sonst castet das UI die Objekte zu Strings.
+
+**Fix:** `options` auf String-Array umgestellt —
+`["if-offered", "required", "disabled"]`. Die Beschriftung bleibt in
+der `sublabel` erhalten (der Config-Wizard erklärt jeden Wert dort).
+
+### Fixed – **`STATUS_OBJECT_NAME_NOT_FOUND` durch fehlgeleiteten Root-Fallback**
+
+Der 0.4.1-Fallback `share/.` triggerte auf Samba einen anderen NT-Status:
+`STATUS_OBJECT_NAME_NOT_FOUND` (0xC0000034 / `ENOENT`), weil Samba `.` als
+literalen Dateinamen sucht statt als Current-Directory-Marker (das ist im
+POSIX-Layer, nicht im SMB2-Protokoll). Der zweite Fallback `share/*` ist
+protokoll-illegal (Wildcard im CREATE) und wird ebenfalls abgelehnt.
+
+**Neuer Ansatz:** Wir versuchen den Fallback erst gar nicht. Statt zu
+raten geben wir eine klare deutsche Fehlermeldung aus: **einen Basispfad
+setzen**. Das ist die einzige zuverlässige Lösung, solange `smb3-client`
+die `FileInformationClass` nicht konfigurierbar macht.
+
+Die Test-Route bleibt weiterhin nachsichtig: bei `OBJECT_NAME_INVALID`
+auf dem Root fällt sie auf `stat("")` zurück und meldet ein Erfolg mit
+Hinweis („Verbindung + Anmeldung erfolgreich, aber Share-Root nicht
+direkt auflistbar — bitte Basispfad setzen“). Der Hinweis wird als gelbe
+Box im Test-Ergebnis angezeigt.
+
 ## [0.4.1] – 2026-07-05
 
 ### Fixed – **`QUERY_DIRECTORY failed: 0xC0000033` auf Share-Root (Samba 4.20+/4.23+)**

package/index.js

@@ -160,6 +160,9 @@ window.sambaTestConn = async function(btn) {
       var rows = (data.entries||[]).map(function(e){
         return '<li>'+ (e.isDirectory?'📁 ':'📄 ') + String(e.name).replace(/[<>&]/g,'?') +'</li>';
       }).join('');
+      var noteHtml = data.note
+        ? '<div style="margin-top:.5rem;padding:.4rem .6rem;background:#fff3cd;border:1px solid #ffeeba;border-radius:.25rem"><b>Hinweis:</b> ' + String(data.note).replace(/[<>&]/g,'?') + '</div>'
+        : '';
       out.innerHTML =
         '<div class="alert alert-success">' +
           '<b>✓ Verbindung erfolgreich</b> (' + data.duration_ms + ' ms)<br>' +
@@ -167,6 +170,7 @@ window.sambaTestConn = async function(btn) {
           'Basispfad: <code>' + data.base_path + '</code>, Benutzer: <code>' + data.username + '</code><br>' +
           'Einträge gefunden: <b>' + data.entry_count + '</b>' + (data.truncated ? ' (erste 20 unten)' : '') +
           (rows ? '<ul style="margin:.5rem 0 0 1rem">' + rows + '</ul>' : '') +
+          noteHtml +
         '</div>';
     } else {
       var a = data && data.attempted || {};
@@ -180,6 +184,40 @@ window.sambaTestConn = async function(btn) {
           'Fehler: <code>' + String(data && data.error || 'Unbekannt').replace(/[<>&]/g,'?') + '</code>' +
           (data && data.code ? ' <span class="text-muted">(' + data.code + ')</span>' : '') + '<br>' +
           (data && data.hint ? '<div style="margin-top:.4rem"><b>Hinweis:</b> ' + String(data.hint).replace(/[<>&]/g,'?') + '</div>' : '') +
+          ((function(){
+            var d = data && data.diagnostics;
+            if (!d) return '';
+            var esc = function(s){ return String(s==null?'':s).replace(/[<>&]/g,function(c){return {'<':'&lt;','>':'&gt;','&':'&amp;'}[c];}); };
+            var lc = String(d.missing_segment||'').toLowerCase();
+            var sibs = Array.isArray(d.siblings) ? d.siblings : [];
+            var similar = sibs.filter(function(s){
+              var n = String(s.name||'').toLowerCase();
+              if (!n || !lc) return false;
+              if (n === lc) return true;
+              if (n.indexOf(lc) !== -1 || lc.indexOf(n) !== -1) return true;
+              // simple Levenshtein-1 heuristic: same length ±1 and share prefix
+              return Math.abs(n.length - lc.length) <= 1 && n.substring(0, Math.min(3, n.length)) === lc.substring(0, Math.min(3, lc.length));
+            });
+            var box = '<div style="margin-top:.4rem;padding:.4rem .6rem;background:#f8d7da;border:1px solid #f5c2c7;border-radius:.25rem">';
+            box += '<b>Diagnose:</b> Der Server meldet, dass \u201e<code>' + esc(d.missing_segment) + '</code>\u201c im Ordner \u201e<code>' + esc(d.parent_path) + '</code>\u201c nicht existiert.';
+            if (!d.parent_listable) {
+              box += '<br><span class="text-muted">(Der übergeordnete Ordner konnte nicht aufgelistet werden — Share-Root-Auflistung ist mit smb3-client aktuell blockiert.)</span>';
+            } else if (sibs.length === 0) {
+              box += '<br>Der übergeordnete Ordner ist leer.';
+            } else {
+              if (similar.length) {
+                box += '<br><b>Ähnliche Einträge, die tatsächlich existieren:</b><ul style="margin:.3rem 0 .3rem 1rem">';
+                similar.slice(0, 10).forEach(function(s){ box += '<li>' + (s.isDirectory?'📁 ':'📄 ') + '<code>' + esc(s.name) + '</code></li>'; });
+                box += '</ul>';
+              }
+              box += '<details style="margin-top:.3rem"><summary>Alle Einträge im Ordner \u201e' + esc(d.parent_path) + '\u201c anzeigen (' + sibs.length + ')</summary><ul style="margin:.3rem 0 0 1rem">';
+              sibs.slice(0, 100).forEach(function(s){ box += '<li>' + (s.isDirectory?'📁 ':'📄 ') + '<code>' + esc(s.name) + '</code></li>'; });
+              if (sibs.length > 100) box += '<li><i>… (' + (sibs.length - 100) + ' weitere)</i></li>';
+              box += '</ul></details>';
+            }
+            box += '</div>';
+            return box;
+          })()) +
           (a.server ? (
             '<details style="margin-top:.4rem"><summary>Versuchte Verbindungsdaten</summary>' +
             '<table class="table table-sm" style="margin-top:.4rem">' +
@@ -301,11 +339,7 @@ const configuration_workflow = () =>
                 type: "String",
                 required: true,
                 attributes: {
-                  options: [
-                    { value: "if-offered", label: "if-offered (Standard)" },
-                    { value: "required",   label: "required (strikt)" },
-                    { value: "disabled",   label: "disabled (aus)" },
-                  ],
+                  options: ["if-offered", "required", "disabled"],
                 },
                 default: "if-offered",
               }),
@@ -321,11 +355,7 @@ const configuration_workflow = () =>
                 type: "String",
                 required: true,
                 attributes: {
-                  options: [
-                    { value: "if-offered", label: "if-offered (Standard)" },
-                    { value: "required",   label: "required (strikt)" },
-                    { value: "disabled",   label: "disabled (aus)" },
-                  ],
+                  options: ["if-offered", "required", "disabled"],
                 },
                 default: "if-offered",
               }),
@@ -801,21 +831,99 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
           // (TCP + Negotiate + Session + TREE_CONNECT + Auth) works, which
           // is all the connection test actually promises.
           const rel = testCfg.base_path ? sanitizeRelativePath(testCfg.base_path) : "";
+          // When a base_path is set, verify it exists and is a directory
+          // BEFORE trying to enumerate it. This turns the opaque
+          // "CREATE failed: STATUS_OBJECT_NAME_NOT_FOUND" into a clear
+          // "Basispfad existiert nicht" hint the user can act on.
+          if (rel) {
+            let st;
+            try {
+              st = await client.stat(rel);
+            } catch (statErr) {
+              const smsg = String((statErr && statErr.message) || statErr || "");
+              if (/OBJECT_NAME_NOT_FOUND|OBJECT_PATH_NOT_FOUND|ENOENT|STATUS_NO_SUCH_FILE/i.test(smsg)) {
+                // Try to list the parent directory so we can *show* the
+                // user what the server actually reports at that level.
+                // This helps distinguish typo vs. case-mismatch vs.
+                // permission-hidden entry. If the parent is the share
+                // root we can't list it (known smb3-client / Samba bug),
+                // so we just skip the sibling probe in that case.
+                const parts = rel.split("/").filter(Boolean);
+                const missing = parts[parts.length - 1];
+                const parent = parts.slice(0, -1).join("/");
+                let siblings = null;
+                if (parent) {
+                  try {
+                    const listing = await client.readdir(parent);
+                    siblings = Array.isArray(listing)
+                      ? listing.map((d) => ({
+                          name: d && (d.name || d),
+                          isDirectory: !!(d && (d.isDirectory === true || (typeof d.isDirectory === "function" && d.isDirectory()))),
+                        }))
+                      : null;
+                  } catch (_) {
+                    siblings = null;
+                  }
+                }
+                const hint =
+                  "Der Basispfad \u201e" + rel + "\u201c existiert auf der " +
+                  "Freigabe \u201e" + testCfg.share + "\u201c nicht " +
+                  "(oder ist f\u00fcr den angemeldeten Benutzer nicht " +
+                  "sichtbar). Bitte Schreibweise, Gro\u00df-/Kleinschreibung " +
+                  "und Zugriffsrechte pr\u00fcfen. Der Basispfad ist relativ " +
+                  "zur Freigabe \u2014 also z.\u202fB. \u201eprojekte/2026\u201c, " +
+                  "nicht \u201e/mnt/\u2026\u201c.";
+                const e = new Error(hint);
+                e.cause = statErr;
+                e.code = "BASE_PATH_NOT_FOUND";
+                e.diagnostics = {
+                  missing_segment: missing,
+                  parent_path: parent || "(Share-Root)",
+                  parent_listable: siblings !== null,
+                  siblings: siblings,
+                };
+                throw e;
+              }
+              throw statErr;
+            }
+            if (st && st.isDirectory === false && st.isFile === true) {
+              const e = new Error(
+                "Der Basispfad \u201e" + rel + "\u201c ist eine Datei, kein " +
+                "Verzeichnis. Bitte tragen Sie einen Ordnernamen ein."
+              );
+              e.code = "BASE_PATH_NOT_A_DIR";
+              throw e;
+            }
+          }
           try {
             return await client.readdir(rel);
           } catch (err) {
-            const msg = String((err && err.message) || err || "");
+            // Look at both the wrapper error and its underlying cause.
+            const causeMsg = String((err && err.cause && err.cause.message) || "");
+            const msg      = String((err && err.message) || err || "") + " " + causeMsg;
             const isRootProbe = !rel;
-            const isNameInvalid = /0xC0000033|OBJECT_NAME_INVALID/i.test(msg);
-            if (isRootProbe && isNameInvalid) {
-              // Fall back: proof-of-life via stat on share root.
-              await client.stat("");
-              return [];
+            const isRootEnumBug = /0xC0000033|OBJECT_NAME_INVALID|Share-Root/i.test(msg);
+            if (isRootProbe && isRootEnumBug) {
+              // Fall back: proof-of-life via stat on share root. This
+              // confirms TCP + Negotiate + Session + Auth + TREE_CONNECT
+              // without hitting the broken QUERY_DIRECTORY path.
+              try {
+                await client.stat("");
+                // Signal to the caller that the connection works, but
+                // the share root cannot be enumerated on this server.
+                const marker = [];
+                marker._rootNotEnumerable = true;
+                return marker;
+              } catch (statErr) {
+                // stat also failed — surface the original error.
+                throw err;
+              }
             }
             throw err;
           }
         });
         const took = Date.now() - started;
+        const rootNotEnum = Array.isArray(listing) && listing._rootNotEnumerable === true;
         return res.json({
           ok: true,
           server: testCfg.server,
@@ -831,6 +939,13 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
             isDirectory: !!(e && (e.isDirectory === true || (e.stats && e.stats.isDirectory && e.stats.isDirectory()))),
           })),
           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."
+            : undefined,
         });
       } catch (err) {
         // Turn opaque SMB / socket errors into actionable hints.
@@ -873,6 +988,7 @@ code{background:#f4f4f4;padding:2px 6px;border-radius:3px;word-break:break-all}<
           error: msg,
           code,
           hint,
+          diagnostics: (err && err.diagnostics) || undefined,
           attempted: {
             server: testCfg.server,
             share: testCfg.share,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "saltcorn-samba",
-  "version": "0.4.1",
+  "version": "0.4.3",
   "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/smb-client.js

@@ -279,36 +279,54 @@ async function buildClient(config) {
       } catch (err) {
         // Some Samba builds (observed on 4.20+/4.23+) reject
         // SMB2 QUERY_DIRECTORY on the *share root* with
-        // STATUS_OBJECT_NAME_INVALID (0xC0000033) because the CREATE
-        // used an empty filename. The fallback below re-issues the
-        // request with an explicit path (".") which most Samba VFS
-        // modules accept for the current directory.
-        const status = (err && (err.status || err.code)) || "";
-        const msg    = String((err && err.message) || err || "");
+        // 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 || "");
         const isRoot = !rel && !basePath;
-        const isNameInvalid =
-          /0xC0000033|STATUS_OBJECT_NAME_INVALID|OBJECT_NAME_INVALID/i.test(msg) ||
-          status === 0xc0000033;
-        if (isRoot && isNameInvalid) {
-          try {
-            dirents = await client.readdir(shareName + "/.", { withFileTypes: true });
-          } catch (_) {
-            // Second fallback: an explicit wildcard segment.
-            try {
-              dirents = await client.readdir(shareName + "/*", { withFileTypes: true });
-            } catch (_) {
-              const e = new Error(
-                "QUERY_DIRECTORY auf dem Share-Root schlug fehl (" +
-                (msg || "OBJECT_NAME_INVALID") + "). " +
-                "Setzen Sie einen Basispfad im Plugin-Konfig oder prüfen Sie die Share-Definition auf dem Server."
-              );
-              e.cause = err;
-              throw e;
-            }
-          }
-        } else {
-          throw err;
+        const isRootEnumBug =
+          /0xC0000033|OBJECT_NAME_INVALID|QUERY_DIRECTORY/i.test(msg);
+        if (isRoot && isRootEnumBug) {
+          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“."
+          );
+          e.cause = err;
+          throw e;
         }
+        // A missing directory (either the base_path itself or a
+        // sub-directory the caller asked to list) surfaces as CREATE
+        // failing with STATUS_OBJECT_NAME_NOT_FOUND / OBJECT_PATH_NOT_FOUND
+        // (both reported by smb3-client with an ENOENT tail). The raw
+        // "CREATE failed: STATUS_OBJECT_NAME_NOT_FOUND (ENOENT)" is not
+        // actionable for end users, so rewrap it into a German hint that
+        // names the actual missing path.
+        const isMissing =
+          /OBJECT_NAME_NOT_FOUND|OBJECT_PATH_NOT_FOUND|ENOENT|STATUS_NO_SUCH_FILE/i.test(msg);
+        if (isMissing) {
+          const shown = full.replace(/^[^/]+\/?/, "") || "(Share-Root)";
+          const e = new Error(
+            "Der Pfad „" + shown + "“ existiert auf der Freigabe „" +
+            shareName + "“ nicht (oder ist für den angemeldeten Benutzer " +
+            "nicht sichtbar). Bitte Schreibweise, Groß-/Kleinschreibung " +
+            "und Zugriffsrechte prüfen. Ursprüngliche Server-Antwort: " +
+            (msg || "CREATE failed")
+          );
+          e.cause = err;
+          e.code = "ENOENT";
+          throw e;
+        }
+        throw err;
       }
       // Parallel enrichment. Bounded to a reasonable concurrency to avoid
       // saturating the SMB session on huge directories.