Implement remaining

Author: AliveDevil

core/src/main/csharp/NativeMethods.txt

@@ -15,6 +15,7 @@ ExtractIconEx
 FILE_ID_INFO
 FOLDERID_Downloads
 GetCurrentPackageFullName
+GetFileInformationByHandleEx
 GetFinalPathNameByHandle
 GetTokenInformation
 GetWindowLong
@@ -33,6 +34,9 @@ LoadLibrary
 LoadString
 MESSAGEBOX_RESULT
 OpenFileById
+PATHCCH_ALLOW_LONG_PATHS
+PATHCCH_MAX_CCH
+PathCchCanonicalizeEx
 PathCchStripPrefix
 PathParseIconLocation
 PBST_ERROR

core/src/main/csharp/Windows/Win32/CorePInvoke.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Runtime.InteropServices;
+using Microsoft.Win32.SafeHandles;
 using Windows.Win32.Foundation;
+using Windows.Win32.Security;
 using Windows.Win32.Security.Credentials;
 using Windows.Win32.Storage.FileSystem;
 using Windows.Win32.UI.Shell;
@@ -22,6 +24,48 @@ public static unsafe int LoadString(SafeHandle hInstance, uint uID, out PCWSTR l
         }
     }
 
+    /// <inheritdoc cref="CreateFile(PCWSTR, uint, FILE_SHARE_MODE, SECURITY_ATTRIBUTES*, FILE_CREATION_DISPOSITION, FILE_FLAGS_AND_ATTRIBUTES, HANDLE)"/>
+    public static unsafe SafeFileHandle CreateFile(
+        in ReadOnlySpan<char> lpFileName,
+        uint dwDesiredAccess,
+        FILE_SHARE_MODE dwShareMode,
+        SECURITY_ATTRIBUTES? lpSecurityAttributes,
+        FILE_CREATION_DISPOSITION dwCreationDisposition,
+        FILE_FLAGS_AND_ATTRIBUTES dwFlagsAndAttributes,
+        SafeHandle hTemplateFile)
+    {
+        bool hTemplateFileAddRef = false;
+        try
+        {
+            fixed (char* lpFileNameLocal = lpFileName)
+            {
+                SECURITY_ATTRIBUTES lpSecurityAttributesLocal = lpSecurityAttributes ?? default(SECURITY_ATTRIBUTES);
+                HANDLE hTemplateFileLocal;
+                if (hTemplateFile is object)
+                {
+                    hTemplateFile.DangerousAddRef(ref hTemplateFileAddRef);
+                    hTemplateFileLocal = (HANDLE)hTemplateFile.DangerousGetHandle();
+                }
+                else
+                    hTemplateFileLocal = (HANDLE)new IntPtr(0L);
+                HANDLE __result = CorePInvoke.CreateFile(
+                    lpFileName: lpFileNameLocal,
+                    dwDesiredAccess: dwDesiredAccess,
+                    dwShareMode: dwShareMode,
+                    lpSecurityAttributes: lpSecurityAttributes.HasValue ? &lpSecurityAttributesLocal : null,
+                    dwCreationDisposition: dwCreationDisposition,
+                    dwFlagsAndAttributes: dwFlagsAndAttributes,
+                    hTemplateFile: hTemplateFileLocal);
+                return new SafeFileHandle(__result, ownsHandle: true);
+            }
+        }
+        finally
+        {
+            if (hTemplateFileAddRef)
+                hTemplateFile.DangerousRelease();
+        }
+    }
+
     /// <inheritdoc cref="CredDelete(PCWSTR, CRED_TYPE, uint)" />
     public static unsafe bool CredDelete(string TargetName, CRED_TYPE type, CRED_FLAGS flags)
     {
@@ -43,6 +87,15 @@ public static unsafe SafeCredentialHandle CredRead(string TargetName, CRED_TYPE
         return new((nint)credential, true);
     }
 
+    /// <inheritdoc cref="GetFileInformationByHandleEx(HANDLE, FILE_INFO_BY_HANDLE_CLASS, void*, uint)"/>
+    public static unsafe BOOL GetFileInformationByHandleEx<T>(SafeHandle hFile, FILE_INFO_BY_HANDLE_CLASS FileInformationClass, out T value) where T : unmanaged
+    {
+        fixed (T* valueLocal = &value)
+        {
+            return GetFileInformationByHandleEx(hFile, FileInformationClass, valueLocal, (uint)Marshal.SizeOf<T>());
+        }
+    }
+
     /// <inheritdoc cref="GetFinalPathNameByHandle(HANDLE, PWSTR, uint, GETFINALPATHNAMEBYHANDLE_FLAGS)"/>
     public static unsafe partial uint GetFinalPathNameByHandle(SafeHandle hFile, Span<char> lpszFilePath, GETFINALPATHNAMEBYHANDLE_FLAGS dwFlags)
     {
@@ -52,6 +105,18 @@ public static unsafe partial uint GetFinalPathNameByHandle(SafeHandle hFile, Spa
         }
     }
 
+    /// <inheritdoc cref="PathCchCanonicalizeEx(PWSTR, nuint, PCWSTR, PATHCCH_OPTIONS)"/>
+    public static unsafe HRESULT PathCchCanonicalizeEx(ref Span<char> pszPathOut, string pszPathIn, PATHCCH_OPTIONS dwFlags)
+    {
+        fixed (char* ppszPathOut = pszPathOut)
+        {
+            PWSTR wstrpszPathOut = ppszPathOut;
+            HRESULT __result = CorePInvoke.PathCchCanonicalizeEx(wstrpszPathOut, (nuint)pszPathOut.Length, pszPathIn, dwFlags);
+            pszPathOut = pszPathOut.Slice(0, wstrpszPathOut.Length);
+            return __result;
+        }
+    }
+
     /// <inheritdoc cref="SHCreateAssociationRegistration(Guid*, object)"/>
     public static unsafe HRESULT SHCreateAssociationRegistration<T>(out T ppv) where T : class
     {

core/src/main/csharp/ch/cyberduck/core/local/NTFSFilesystemBookmarkResolver.cs

@@ -12,8 +12,8 @@
 // GNU General Public License for more details.
 
 using System;
-using System.Diagnostics;
 using System.Globalization;
+using System.Runtime.CompilerServices;
 using System.Runtime.InteropServices;
 using ch.cyberduck.core;
 using ch.cyberduck.core.exception;
@@ -22,36 +22,62 @@
 using org.apache.logging.log4j;
 using Windows.Win32;
 using Windows.Win32.Storage.FileSystem;
+using Windows.Win32.UI.Shell;
 using CoreLocal = ch.cyberduck.core.Local;
+using NetPath = System.IO.Path;
 
 namespace Ch.Cyberduck.Core.Local
 {
     public class NTFSFilesystemBookmarkResolver(CoreLocal local) : FilesystemBookmarkResolver
     {
         private static readonly Logger Log = LogManager.getLogger(typeof(NTFSFilesystemBookmarkResolver).FullName);
 
-        public NTFSFilesystemBookmarkResolver() : this(null)
-        {
-        }
-
         public string create(CoreLocal file) => FilesystemBookmarkResolver.__DefaultMethods.create(this, file);
 
         public string create(CoreLocal file, bool prompt)
         {
-            Debug.Assert(local is null, "Unnecessary usage of Local-constructor.");
+            Span<char> finalNameBuffer = new char[CorePInvoke.PATHCCH_MAX_CCH];
+            if (CorePInvoke.PathCchCanonicalizeEx(
+                ref finalNameBuffer,
+                NetPath.GetFullPath(file.getAbsolute()),
+                PATHCCH_OPTIONS.PATHCCH_ALLOW_LONG_PATHS | PATHCCH_OPTIONS.PATHCCH_FORCE_ENABLE_LONG_NAME_PROCESS) is
+                {
+                    Failed: true,
+                    Value: { } error
+                })
+            {
+                goto error;
+            }
 
-            // ToDo: Backport
+            FILE_ID_INFO info;
+            using (var handle = CorePInvoke.CreateFile(
+                lpFileName: finalNameBuffer,
+                dwDesiredAccess: 0,
+                dwShareMode: (FILE_SHARE_MODE)7,
+                lpSecurityAttributes: null,
+                dwCreationDisposition: FILE_CREATION_DISPOSITION.OPEN_EXISTING,
+                dwFlagsAndAttributes: FILE_FLAGS_AND_ATTRIBUTES.FILE_FLAG_BACKUP_SEMANTICS,
+                hTemplateFile: null))
+            {
+                if (handle.IsInvalid)
+                {
+                    goto error;
+                }
 
+                if (!CorePInvoke.GetFileInformationByHandleEx(handle, FILE_INFO_BY_HANDLE_CLASS.FileIdInfo, out info))
+                {
+                    goto error;
+                }
+            }
+
+            return Unsafe.As<FILE_ID_128, long>(ref info.FileId).ToString("X16");
+
+        error:
             return null;
         }
 
         public object resolve(string bookmark)
         {
-            if (local is null)
-            {
-                throw new LocalAccessDeniedException("Unsupported Interface usage");
-            }
-
             if (!ToFileId(bookmark, out var fileId))
             {
                 throw new LocalAccessDeniedException(bookmark);

core/src/test/csharp/ch/cyberduck/core/local/NTFSFilesystemBookmarkResolverTest.cs

@@ -0,0 +1,24 @@
+using ch.cyberduck.core.local;
+using NUnit.Framework;
+using NUnit.Framework.Constraints;
+using CoreLocal = ch.cyberduck.core.Local;
+using NetPath = System.IO.Path;
+
+namespace Ch.Cyberduck.Core.Local;
+
+[TestFixture]
+public class NTFSFilesystemBookmarkResolverTest
+{
+    [Test]
+    public void EnsureRoundtrip()
+    {
+        SystemLocal temp = new(NetPath.GetTempPath());
+        SystemLocal file = new(temp, NetPath.GetRandomFileName());
+        new DefaultLocalTouchFeature().touch(file);
+        NTFSFilesystemBookmarkResolver resolver = new(file);
+        var bookmark = resolver.create(file);
+        Assert.That(bookmark, new NotConstraint(new NullConstraint()));
+        CoreLocal resolved = (CoreLocal)resolver.resolve(bookmark);
+        Assert.That(resolved, new EqualConstraint(file));
+    }
+}