Commit: 22910001f8acfa3229cd78f20d010bb49c38bb27 - FolderCategorizer2 (git)

ファイル整理用ツールのPrism+WPFサンプル実装

Commit MetaInfo

• Révision: 22910001f8acfa3229cd78f20d010bb49c38bb27 (tree)
• l'heure: 2023-09-24 18:59:19
• Auteur: yoshy <yoshy.org.bitbucket@gz.j...>
• Commiter: yoshy

Message de Log

[UPD] ファイルシステム操作系のコピー処理時にジャンクションとシンボリックリンクを認識してそのものをコピーする機能を追加
[FIX] ファイルシステム操作系のディレクトリ削除処理を自前で行うように修正（処理中の対象ディレクトリがディレクトリがリパースポイントの場合は再帰で削除しない）

Change Summary

• add: FolderCategorizer2.04OuterEdge/Repository/OS/JunctionHelper.cs
• modified: FolderCategorizer2.04OuterEdge/Repository/OS/LocalFileSystemRepository.cs

Modification

--- /dev/null
+++ b/FolderCategorizer2.04OuterEdge/Repository/OS/JunctionHelper.cs
@@ -0,0 +1,258 @@
+using Microsoft.Win32.SafeHandles;
+using NLog;
+using System;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace FolderCategorizer2.OuterEdge.Repository.OS
+{
+    /// <see href="https://stackoverflow.com/questions/1400549/in-net-how-do-i-create-a-junction-in-ntfs-as-opposed-to-a-symlink"/>
+    internal static class JunctionHelper
+    {
+        private static readonly ILogger logger = LogManager.GetCurrentClassLogger();
+
+        /// <summary>
+        /// Command to set the reparse point data block.
+        /// </summary>
+        private const uint FSCTL_SET_REPARSE_POINT = 0x000900A4;
+
+        /// <summary>
+        /// Command to get the reparse point data block.
+        /// </summary>
+        private const uint FSCTL_GET_REPARSE_POINT = 0x000900A8;
+
+        /// <summary>
+        /// Command to delete the reparse point data base.
+        /// </summary>
+        private const uint FSCTL_DELETE_REPARSE_POINT = 0x000900AC;
+
+        /// <summary>
+        /// Reparse point tag used to identify mount points and junction points.
+        /// </summary>
+        private const uint IO_REPARSE_TAG_MOUNT_POINT = 0xA0000003;
+
+        /// <summary>
+        /// This prefix indicates to NTFS that the path is to be treated as a non-interpreted
+        /// path in the virtual file system.
+        /// </summary>
+        private const string NonInterpretedPathPrefix = @"\??\";
+        
+        [Flags]
+        private enum Win32FileAccess : uint
+        {
+            GenericRead = 0x80000000U,
+            GenericWrite = 0x40000000U,
+            GenericExecute = 0x20000000U,
+            GenericAll = 0x10000000U
+        }
+
+        [Flags]
+        private enum Win32FileAttribute : uint
+        {
+            AttributeReadOnly = 0x1U,
+            AttributeHidden = 0x2U,
+            AttributeSystem = 0x4U,
+            AttributeDirectory = 0x10U,
+            AttributeArchive = 0x20U,
+            AttributeDevice = 0x40U,
+            AttributeNormal = 0x80U,
+            AttributeTemporary = 0x100U,
+            AttributeSparseFile = 0x200U,
+            AttributeReparsePoint = 0x400U,
+            AttributeCompressed = 0x800U,
+            AttributeOffline = 0x1000U,
+            AttributeNotContentIndexed = 0x2000U,
+            AttributeEncrypted = 0x4000U,
+            AttributeIntegrityStream = 0x8000U,
+            AttributeVirtual = 0x10000U,
+            AttributeNoScrubData = 0x20000U,
+            AttributeEA = 0x40000U,
+            AttributeRecallOnOpen = 0x40000U,
+            AttributePinned = 0x80000U,
+            AttributeUnpinned = 0x100000U,
+            AttributeRecallOnDataAccess = 0x400000U,
+            FlagOpenNoRecall = 0x100000U,
+            /// <summary>
+            /// Normal reparse point processing will not occur; CreateFile will attempt to open the reparse point. When a file is opened, a file handle is returned,
+            /// whether or not the filter that controls the reparse point is operational.
+            /// <br />This flag cannot be used with the <see cref="FileMode.Create"/> flag.
+            /// <br />If the file is not a reparse point, then this flag is ignored.
+            /// </summary>
+            FlagOpenReparsePoint = 0x200000U,
+            FlagSessionAware = 0x800000U,
+            FlagPosixSemantics = 0x1000000U,
+            /// <summary>
+            /// You must set this flag to obtain a handle to a directory. A directory handle can be passed to some functions instead of a file handle.
+            /// </summary>
+            FlagBackupSemantics = 0x2000000U,
+            FlagDeleteOnClose = 0x4000000U,
+            FlagSequentialScan = 0x8000000U,
+            FlagRandomAccess = 0x10000000U,
+            FlagNoBuffering = 0x20000000U,
+            FlagOverlapped = 0x40000000U,
+            FlagWriteThrough = 0x80000000U
+        }
+
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto)]
+        private static extern SafeFileHandle CreateFile(string lpFileName, Win32FileAccess dwDesiredAccess,
+            FileShare dwShareMode, IntPtr lpSecurityAttributes, FileMode dwCreationDisposition,
+            Win32FileAttribute dwFlagsAndAttributes, IntPtr hTemplateFile);
+
+        // Because the tag we're using is IO_REPARSE_TAG_MOUNT_POINT, we use the MountPointReparseBuffer struct in the DUMMYUNIONNAME union.
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct ReparseDataBuffer
+        {
+            /// <summary>Reparse point tag. Must be a Microsoft reparse point tag.</summary>
+            public uint ReparseTag;
+            /// <summary>Size, in bytes, of the reparse data in the buffer that <see cref="PathBuffer"/> points to.</summary>
+            public ushort ReparseDataLength;
+            /// <summary>Reserved; do not use.</summary>
+            private ushort Reserved;
+            /// <summary>Offset, in bytes, of the substitute name string in the <see cref="PathBuffer"/> array.</summary>
+            public ushort SubstituteNameOffset;
+            /// <summary>Length, in bytes, of the substitute name string. If this string is null-terminated, <see cref="SubstituteNameLength"/> does not include space for the null character.</summary>
+            public ushort SubstituteNameLength;
+            /// <summary>Offset, in bytes, of the print name string in the <see cref="PathBuffer"/> array.</summary>
+            public ushort PrintNameOffset;
+            /// <summary>Length, in bytes, of the print name string. If this string is null-terminated, <see cref="PrintNameLength"/> does not include space for the null character.</summary>
+            public ushort PrintNameLength;
+            /// <summary>
+            /// A buffer containing the unicode-encoded path string. The path string contains the substitute name
+            /// string and print name string. The substitute name and print name strings can appear in any order.
+            /// </summary>
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 8184)]
+            internal string PathBuffer;
+            // with <MarshalAs(UnmanagedType.ByValArray, SizeConst:=16368)> Public PathBuffer As Byte()
+            // 16368 is the amount of bytes. since a unicode string uses 2 bytes per character, constrain to 16368/2 = 8184 characters.
+        }
+
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto, EntryPoint = "DeviceIoControl")]
+        private static extern bool DeviceIoControlSet(SafeFileHandle hDevice, uint dwIoControlCode,
+            [In] ReparseDataBuffer lpInBuffer, uint nInBufferSize,
+            IntPtr lpOutBuffer, uint nOutBufferSize,
+            uint lpBytesReturned, IntPtr lpOverlapped);
+
+        [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Auto, EntryPoint = "DeviceIoControl")]
+        private static extern bool DeviceIoControlGet(SafeFileHandle hDevice, uint dwIoControlCode,
+            IntPtr lpInBuffer, uint nInBufferSize,
+            [In, Out] ref ReparseDataBuffer lpOutBuffer, uint nOutBufferSize,
+            [Out] out uint lpBytesReturned, IntPtr lpOverlapped);
+
+        /// <summary>
+        /// Creates a junction point from the specified directory to the specified target directory.
+        /// </summary>
+        /// <remarks>
+        /// Only works on NTFS.
+        /// </remarks>
+        /// <param name="path">The junction point path</param>
+        /// <param name="targetDir">The target directory</param>
+        /// <param name="overwrite">If true overwrites an existing reparse point or empty directory</param>
+        /// <exception cref="IOException">Thrown when the junction point could not be created or when
+        /// an existing directory was found and <paramref name="overwrite" /> if false</exception>
+        public static void Create(string path, string targetDir, bool overwrite = false)
+        {
+            if (Directory.Exists(path))
+            {
+                if (!overwrite)
+                    throw new IOException("Directory already exists and overwrite parameter is false.");
+            }
+            else
+            {
+                Directory.CreateDirectory(path);
+            }
+
+            targetDir = NonInterpretedPathPrefix + Path.GetFullPath(targetDir);
+
+            using SafeFileHandle reparsePointHandle = OpenReparsePoint(path, Win32FileAccess.GenericWrite);
+
+            if (reparsePointHandle.IsInvalid || Marshal.GetLastWin32Error() != 0)
+            {
+                throw new IOException("Unable to open reparse point.", new Win32Exception(Marshal.GetLastWin32Error()));
+            }
+
+            //// unicode string is 2 bytes per character, so *2 to get byte length
+            //ushort byteLength = (ushort)(targetDir.Length * 2);
+            ushort byteLength = (ushort)Encoding.Unicode.GetByteCount(targetDir);
+            var reparseDataBuffer = new ReparseDataBuffer()
+            {
+                ReparseTag = IO_REPARSE_TAG_MOUNT_POINT,
+                ReparseDataLength = (ushort)(byteLength + 12u),
+                SubstituteNameOffset = 0,
+                SubstituteNameLength = byteLength,
+                PrintNameOffset = (ushort)(byteLength + 2u),
+                PrintNameLength = 0,
+                PathBuffer = targetDir
+            };
+
+            bool result = DeviceIoControlSet(reparsePointHandle, FSCTL_SET_REPARSE_POINT, reparseDataBuffer, (uint)(byteLength + 20), IntPtr.Zero, 0u, 0u, IntPtr.Zero);
+            if (!result)
+                throw new IOException("Unable to create junction point.", new Win32Exception(Marshal.GetLastWin32Error()));
+        }
+
+        /// <summary>
+        /// Determines whether the specified path exists and refers to a junction point.
+        /// </summary>
+        /// <param name="path">The junction point path</param>
+        /// <returns>True if the specified path represents a junction point</returns>
+        /// <exception cref="IOException">Thrown if the specified path is invalid
+        /// or some other error occurs</exception>
+        public static bool Exists(string path)
+        {
+            if (!Directory.Exists(path))
+                return false;
+
+            using (SafeFileHandle handle = OpenReparsePoint(path, Win32FileAccess.GenericRead))
+            {
+                return InternalGetTarget(handle) != null;
+            }
+        }
+
+        /// <summary>
+        /// Gets the target of the specified junction point.
+        /// </summary>
+        /// <remarks>
+        /// Only works on NTFS.
+        /// </remarks>
+        /// <param name="path">The junction point path</param>
+        /// <returns>The target of the junction point, or null when the specified path does not
+        /// exist, is invalid, is not a junction point, or some other error occurs</returns>
+        public static string GetTarget(string path)
+        {
+            using (SafeFileHandle handle = OpenReparsePoint(path, Win32FileAccess.GenericRead))
+            {
+                return InternalGetTarget(handle);
+            }
+        }
+
+        private static string InternalGetTarget(SafeFileHandle hReparsePoint)
+        {
+            var reparseDataBuffer = new ReparseDataBuffer();
+            uint outBufferSize = 8200;
+            uint bytesReturned;
+
+            bool result = DeviceIoControlGet(hReparsePoint, FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0u, ref reparseDataBuffer, outBufferSize, out bytesReturned, IntPtr.Zero);
+            if (!result)
+                throw new IOException("Unable to get information about junction point.", new Win32Exception(Marshal.GetLastWin32Error()));
+
+            if (reparseDataBuffer.ReparseTag != IO_REPARSE_TAG_MOUNT_POINT)
+                return null;
+
+            string targetDir = reparseDataBuffer.PathBuffer;
+
+            if (targetDir.StartsWith(NonInterpretedPathPrefix))
+                targetDir = targetDir.Substring(NonInterpretedPathPrefix.Length);
+
+            return targetDir;
+        }
+
+        private static SafeFileHandle OpenReparsePoint(string junctionPath, Win32FileAccess desiredFileAccess)
+        {
+            return CreateFile(junctionPath, desiredFileAccess,
+                FileShare.Read | FileShare.Write | FileShare.Delete, IntPtr.Zero, FileMode.Open,
+                Win32FileAttribute.FlagBackupSemantics | Win32FileAttribute.FlagOpenReparsePoint, IntPtr.Zero);
+        }
+
+    }
+}

--- a/FolderCategorizer2.04OuterEdge/Repository/OS/LocalFileSystemRepository.cs
+++ b/FolderCategorizer2.04OuterEdge/Repository/OS/LocalFileSystemRepository.cs
@@ -7,8 +7,10 @@ using Microsoft.VisualBasic.FileIO;
 using NLog;
 using System;
 using System.Collections.Generic;
+using System.ComponentModel;
 using System.IO;
 using System.Linq;
+using System.Runtime.InteropServices;
 using VBFileSystem = Microsoft.VisualBasic.FileIO.FileSystem;
 
 namespace FolderCategorizer2.OuterEdge.Repository.OS
@@ -109,140 +111,179 @@ namespace FolderCategorizer2.OuterEdge.Repository.OS
 
         public void MoveFile(string targetPath, string sourceFullPath)
         {
-#if false
             if (Directory.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.MoveDirectory({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.MoveDirectory(sourceFullPath, targetPath, UIOption.AllDialogs);
-            }
-            else if (File.Exists(sourceFullPath))
-            {
-                logger.Debug("FileSystem.MoveFile({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.MoveFile(sourceFullPath, targetPath, UIOption.AllDialogs);
-            }
-            else
-            {
-                throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
-            }
-#else
-            if (Directory.Exists(sourceFullPath))
-            {
-                logger.Debug("Directory.Move({0}, {1})", sourceFullPath, targetPath);
+                logger.Trace("Directory.Move({0}, {1})", sourceFullPath, targetPath);
                 Directory.Move(sourceFullPath, targetPath);
             }
             else if (File.Exists(sourceFullPath))
             {
-                logger.Debug("File.Move({0}, {1})", sourceFullPath, targetPath);
+                logger.Trace("File.Move({0}, {1})", sourceFullPath, targetPath);
                 File.Move(sourceFullPath, targetPath);
             }
             else
             {
                 throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
             }
-#endif
         }
 
         public void CopyFile(string targetPath, string sourceFullPath)
         {
-#if false
             if (Directory.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.CopyDirectory({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.CopyDirectory(sourceFullPath, targetPath, UIOption.AllDialogs);
+                CopyDirectoryInternal(targetPath, sourceFullPath);
             }
             else if (File.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.CopyFile({0}, {1})", sourceFullPath, targetPath);
-                VBFileSystem.CopyFile(sourceFullPath, targetPath, UIOption.AllDialogs);
+                CopyFileInternal(targetPath, sourceFullPath);
             }
             else
             {
                 throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
             }
-#else
-           if (Directory.Exists(sourceFullPath))
+        }
+
+        private static void CopyFileInternal(string targetPath, string sourceFullPath)
+        {
+            FileInfo file = new(sourceFullPath);
+
+            string junctionTarget = JunctionHelper.GetTarget(sourceFullPath);
+
+            if (junctionTarget != null)
             {
-                //logger.Debug("Directory.Copy({0}, {1})", sourceFullPath, targetPath);
-                CopyDirectory(targetPath, sourceFullPath);
+                logger.Trace("JunctionHelper.Create({0}, {1})", targetPath, junctionTarget);
+                JunctionHelper.Create(targetPath, junctionTarget);
             }
-            else if (File.Exists(sourceFullPath))
+            else if ((file.Attributes & FileAttributes.ReparsePoint) != 0)
             {
-                logger.Debug("File.Copy({0}, {1})", sourceFullPath, targetPath);
-                File.Copy(sourceFullPath, targetPath);
+                CreateFileSymbolicLink(targetPath, file, true);
             }
             else
             {
-                throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
+                logger.Trace("FileInfo({0}).CopyTo({1})", sourceFullPath, targetPath);
+                file.CopyTo(targetPath);
             }
-#endif
         }
 
-        /// <see cref="https://learn.microsoft.com/ja-jp/dotnet/standard/io/how-to-copy-directories"/>
-        private void CopyDirectory(string targetPath, string sourceFullPath)
+        private static void CreateFileSymbolicLink(string targetPath, FileInfo file, bool bFinalTarget)
+        {
+            string linkTarget = bFinalTarget ? file.ResolveLinkTarget(true).FullName : file.LinkTarget;
+            logger.Trace("File.CreateSymbolicLink({0}, {1})", targetPath, linkTarget);
+            File.CreateSymbolicLink(targetPath, linkTarget);
+        }
+
+        /// <see href="https://learn.microsoft.com/ja-jp/dotnet/standard/io/how-to-copy-directories"/>
+        private void CopyDirectoryInternal(string targetPath, string sourceFullPath)
         {
             // Get information about the source directory
             DirectoryInfo dir = new(sourceFullPath);
 
             // Check if the source directory exists
             if (!dir.Exists)
+            {
                 throw new DirectoryNotFoundException($"Source directory not found: {dir.FullName}");
+            }
 
             // Cache directories before we start copying
             DirectoryInfo[] dirs = dir.GetDirectories();
 
             // Create the destination directory
-            logger.Debug("Directory.CreateDirectory({0})", targetPath);
+            logger.Trace("Directory.CreateDirectory({0})", targetPath);
             Directory.CreateDirectory(targetPath);
 
             // Get the files in the source directory and copy to the destination directory
             foreach (FileInfo file in dir.GetFiles())
             {
                 string targetFilePath = Path.Combine(targetPath, file.Name);
-                logger.Debug("FileInfo({0}).CopyTo({1})", file.FullName, targetFilePath);
-                file.CopyTo(targetFilePath);
+                CopyFileInternal(targetFilePath, file.FullName);
             }
 
             // Recursively call this method
             foreach (DirectoryInfo subDir in dirs)
             {
                 string newDestinationDir = Path.Combine(targetPath, subDir.Name);
-                CopyDirectory(newDestinationDir, subDir.FullName);
+
+                string junctionTarget = JunctionHelper.GetTarget(subDir.FullName);
+
+                if (junctionTarget != null)
+                {
+                    logger.Trace("JunctionHelper.Create({0}, {1})", newDestinationDir, junctionTarget);
+                    JunctionHelper.Create(newDestinationDir, junctionTarget);
+                }
+                else if ((subDir.Attributes & FileAttributes.ReparsePoint) != 0)
+                {
+                    CreateDirectorySymbolicLink(newDestinationDir, subDir, true);
+                }
+                else
+                {
+                    CopyDirectoryInternal(newDestinationDir, subDir.FullName);
+                }
             }
         }
 
+        private static void CreateDirectorySymbolicLink(string targetPath, DirectoryInfo dir, bool bFinalTarget)
+        {
+            string linkTarget = bFinalTarget ? dir.ResolveLinkTarget(true).FullName : dir.LinkTarget;
+            logger.Trace("Directory.CreateSymbolicLink({0}, {1})", targetPath, linkTarget);
+            Directory.CreateSymbolicLink(targetPath, linkTarget);
+        }
+
         public void DeleteFile(string sourceFullPath)
         {
-#if false
             if (Directory.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.DeleteDirectory({0})", sourceFullPath);
-                VBFileSystem.DeleteDirectory(sourceFullPath, UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
+                logger.Trace("DeleteDirectoryInternal({0})", sourceFullPath);
+                DeleteDirectoryInternal(sourceFullPath);
             }
             else if (File.Exists(sourceFullPath))
             {
-                logger.Debug("FileSystem.DeleteFile({0})", sourceFullPath);
-                VBFileSystem.DeleteFile(sourceFullPath, UIOption.AllDialogs, RecycleOption.SendToRecycleBin);
+                logger.Trace("File.Delete({0})", sourceFullPath);
+                File.Delete(sourceFullPath);
             }
             else
             {
                 throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
             }
-#else
-            if (Directory.Exists(sourceFullPath))
+        }
+
+        /// <see href="https://qiita.com/mima_ita/items/f84e187d60b63074927f"/>
+        private void DeleteDirectoryInternal(string sourceFullPath)
+        {
+            // Get information about the source directory
+            DirectoryInfo dir = new(sourceFullPath);
+
+            // Check if the source directory exists
+            if (!dir.Exists)
+            {
+                throw new DirectoryNotFoundException($"Source directory not found: {dir.FullName}");
+            }
+
+            if ((dir.Attributes & FileAttributes.ReparsePoint) != 0)
             {
-                logger.Debug("Directory.Delete({0})", sourceFullPath);
-                Directory.Delete(sourceFullPath, true);
+                logger.Trace("Directory.Delete(<JUNCTION/SYMLINKD> {0})", sourceFullPath);
+                dir.Delete();
+                return;
             }
-            else if (File.Exists(sourceFullPath))
+
+            // Cache directories before we start deleting
+            DirectoryInfo[] dirs = dir.GetDirectories();
+
+            // Get the files in the source directory and delete them
+            foreach (FileInfo file in dir.GetFiles())
             {
-                logger.Debug("File.Delete({0})", sourceFullPath);
-                File.Delete(sourceFullPath);
+                logger.Trace("File({0}).Delete()", file.FullName);
+                File.SetAttributes(file.FullName, FileAttributes.Normal);
+                file.Delete();
             }
-            else
+
+            // Recursively call this method
+            foreach (DirectoryInfo subDir in dirs)
             {
-                throw new FileNotFoundException($"{sourceFullPath}が存在しないか無効です");
+                DeleteDirectoryInternal(subDir.FullName);
             }
-#endif
+
+            logger.Trace("Directory.Delete({0})", sourceFullPath);
+            dir.Delete();
         }
 
         public void RenameFile(string sourceFullPath, string targetName)