public static string GetTarget(string fileName) { SafeFileHandle handle = new SafeFileHandle(CreateFile(fileName, DESIRED_ACCESS, SHARE_MODE, IntPtr.Zero, CREATION_DISPOSITION, FLAGS_AND_ATTRIBUTES, IntPtr.Zero), true); if (Marshal.GetLastWin32Error() != 0) { string message = new Win32Exception(Marshal.GetLastWin32Error()).Message; throw new IOException(message + " (" + fileName + ")", Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); } int outBufferSize = Marshal.SizeOf(typeof(REPARSE_DATA_BUFFER)); IntPtr outBuffer = Marshal.AllocHGlobal(outBufferSize); try { int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, outBuffer, outBufferSize, out bytesReturned, IntPtr.Zero); if (!result) { if (Marshal.GetLastWin32Error() == ERROR_NOT_A_REPARSE_POINT) { return(null); } string message = new Win32Exception(Marshal.GetLastWin32Error()).Message; throw new IOException(message + " (" + fileName + ")", Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); } REPARSE_DATA_BUFFER reparseDataBuffer = (REPARSE_DATA_BUFFER) Marshal.PtrToStructure(outBuffer, typeof(REPARSE_DATA_BUFFER)); ushort offset = reparseDataBuffer.PrintNameOffset; if (reparseDataBuffer.ReparseTag == IO_REPARSE_TAG_SYMLINK) { // + sizeof(uint) for Flags // which I don't have in REPARSE_DATA_BUFFER offset += sizeof(uint); } else if (reparseDataBuffer.ReparseTag != IO_REPARSE_TAG_MOUNT_POINT) { // throw an error? } string targetDir = Encoding.Unicode.GetString(reparseDataBuffer.PathBuffer, offset, reparseDataBuffer.PrintNameLength); return(targetDir); } finally { handle.Close(); Marshal.FreeHGlobal(outBuffer); } }
/// <summary> /// Creates a junction point from the specified directory to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">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 junctionPoint, string targetDir, bool overwrite) { targetDir = Path.GetFullPath(targetDir); if (!Directory.Exists(targetDir)) { throw new IOException("Target path does not exist or is not a directory."); } if (Directory.Exists(junctionPoint)) { if (!overwrite) { throw new IOException("Directory already exists and overwrite parameter is false."); } } else { Directory.CreateDirectory(junctionPoint); } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { byte[] targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDir)); REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = (ushort)(targetDirBytes.Length + 12), SubstituteNameOffset = 0, SubstituteNameLength = (ushort)targetDirBytes.Length, PrintNameOffset = (ushort)(targetDirBytes.Length + 2), PrintNameLength = 0, PathBuffer = new byte[0x3ff0] }; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to create junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
// https://github.com/rad1oactive/BetterExplorer/blob/master/Windows%20API%20Code%20Pack%201.1/source/WindowsAPICodePack/Shell/ReparsePoint.cs public static string ParseSymLink(string path) { using var handle = OpenFileForRead(path, false, 0x00200000); if (!handle.IsInvalid) { REPARSE_DATA_BUFFER buffer = new REPARSE_DATA_BUFFER(); if (DeviceIoControl(handle.DangerousGetHandle(), FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, out buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, out _, IntPtr.Zero)) { var subsString = new string(buffer.PathBuffer, ((buffer.SubsNameOffset / 2) + 2), buffer.SubsNameLength / 2); var printString = new string(buffer.PathBuffer, ((buffer.PrintNameOffset / 2) + 2), buffer.PrintNameLength / 2); var normalisedTarget = printString ?? subsString; if (string.IsNullOrEmpty(normalisedTarget)) { normalisedTarget = subsString; if (normalisedTarget.StartsWith(@"\??\", StringComparison.Ordinal)) { normalisedTarget = normalisedTarget.Substring(4); } } if (buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK && (normalisedTarget.Length < 2 || normalisedTarget[1] != ':')) { // Target is relative, get the absolute path normalisedTarget = normalisedTarget.TrimStart(Path.DirectorySeparatorChar); path = path.TrimEnd(Path.DirectorySeparatorChar); normalisedTarget = Path.GetFullPath(Path.Combine(path.Substring(0, path.LastIndexOf(Path.DirectorySeparatorChar)), normalisedTarget)); } return(normalisedTarget); } } return(null); }
public static bool IsSymLink(string path) { using (SafeFileHandle output = CreateFile( path, FileAccess.FILE_READ_ATTRIBUTES, FileShare.Read, IntPtr.Zero, FileMode.Open, FileAttributes.FILE_FLAG_BACKUP_SEMANTICS | FileAttributes.FILE_FLAG_OPEN_REPARSE_POINT, IntPtr.Zero)) { if (output.IsInvalid) { ThrowLastWin32Exception($"Invalid handle for '{path}' as symlink"); } REPARSE_DATA_BUFFER reparseData = new REPARSE_DATA_BUFFER(); reparseData.ReparseDataLength = (4 * sizeof(ushort)) + ReparseDataPathBufferLength; uint bytesReturned; if (!DeviceIoControl(output, FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, out reparseData, (uint)Marshal.SizeOf(reparseData), out bytesReturned, IntPtr.Zero)) { ThrowLastWin32Exception($"Failed to place reparse point for '{path}'"); } return(reparseData.ReparseTag == IO_REPARSE_TAG_SYMLINK || reparseData.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT); } }
/// <summary> /// Creates a junction point from the specified directory to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="targetDir">The target directory to create</param> /// <param name="sourceDir">The source directory to alias</param> /// <param name="overwrite">If true overwrites an existing reparse point or empty directory</param> /// <exception cref="System.IO.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 sourceDir, string targetDir, bool overwrite = false, bool makeReadOnly = false) { sourceDir = Path.GetFullPath(sourceDir); if (!Directory.Exists(sourceDir)) { throw new System.IO.IOException($"Source path does not exist or is not a directory."); } if (Directory.Exists(targetDir) && !overwrite) { throw new System.IO.IOException($"Directory '{targetDir}' already exists."); } Directory.CreateDirectory(targetDir); using (SafeFileHandle handle = OpenReparsePoint(targetDir, EFileAccess.GenericWrite)) { byte[] sourceDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(sourceDir)); REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = (ushort)(sourceDirBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort)sourceDirBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort)(sourceDirBytes.Length + 2); reparseDataBuffer.PrintNameLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(sourceDirBytes, reparseDataBuffer.PathBuffer, sourceDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, sourceDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error($"Unable to create junction point '{sourceDir}' -> '{targetDir}'."); } } finally { Marshal.FreeHGlobal(inBuffer); } } if (makeReadOnly) { File.SetAttributes(targetDir, System.IO.FileAttributes.ReadOnly); } }
/// <summary> /// 为目标目录创建一个指向目标目录的目录联接。 /// </summary> /// <remarks> /// 注意,此方法仅在 NTFS 分区上才会生效。 /// </remarks> /// <param name="junctionPoint">目录联接的路径。</param> /// <param name="targetDirectory">要联接的目标目录。</param> /// <param name="overwrite">If true overwrites an existing reparse point or empty directory</param> /// <exception cref="IOException"> /// 如果无法创建目录联接则抛出异常。或者 <paramref name="overwrite" /> 为 false 时,当前目录联接路径已经存在。 /// </exception> public static void Create(string junctionPoint, string targetDirectory, bool overwrite) { targetDirectory = Path.GetFullPath(targetDirectory); if (!Directory.Exists(targetDirectory)) { throw new IOException($"{nameof(targetDirectory)} 指定的目标目录不存在,路径是“{targetDirectory}”。"); } if (Directory.Exists(junctionPoint)) { if (!overwrite) { throw new IOException($"目录联接“{junctionPoint}”已经存在,如果需要替换,请设置 {nameof(overwrite)} 为 true。"); } } else { Directory.CreateDirectory(junctionPoint); } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { var targetDirectoryBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDirectory)); var reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = (ushort)(targetDirectoryBytes.Length + 12), SubstituteNameOffset = 0, SubstituteNameLength = (ushort)targetDirectoryBytes.Length, PrintNameOffset = (ushort)(targetDirectoryBytes.Length + 2), PrintNameLength = 0, PathBuffer = new byte[0x3ff0] }; Array.Copy(targetDirectoryBytes, reparseDataBuffer.PathBuffer, targetDirectoryBytes.Length); var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirectoryBytes.Length + 20, IntPtr.Zero, 0, out var bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("无法创建目录联接。"); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
/// <summary> /// Deletes a junction point at the specified source directory along with the directory itself. /// Does nothing if the junction point does not exist. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The junction point path</param> public static void DeleteJunctionOrSymlink(string junctionPoint) { if (!Directory.Exists(junctionPoint)) { if (File.Exists(junctionPoint)) { throw new IOException("Path is not a junction point."); } return; } var linkManager = ReparsePointFactory.Create(); if (linkManager.GetLinkType(junctionPoint) == LinkType.Symbolic) { Directory.Delete(junctionPoint, false); return; } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_DELETE_REPARSE_POINT, inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to delete junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } try { Directory.Delete(junctionPoint); } catch (IOException ex) { throw new IOException("Unable to delete junction point.", ex); } } }
private static extern bool DeviceIoControl( SafeFileHandle hDevice, uint IoControlCode, [In] IntPtr InBuffer, uint nInBufferSize, [Out] out REPARSE_DATA_BUFFER OutBuffer, uint nOutBufferSize, out uint pBytesReturned, [In] IntPtr Overlapped);
/// <summary> /// Creates a junction point to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The directory to create</param> /// <param name="destination">The existing directory</param> /// <param name="overwrite">If true overwrites an existing reparse point or empty directory</param> /// <exception cref="System.IO.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 junctionPoint, string destination, bool overwrite) { if (destination.StartsWith(@"\\?\Volume{")) { throw new ArgumentException("Volume name is not supported!"); // TODO support "mounted folder" } junctionPoint = Path.GetFullPath(junctionPoint); destination = Path.GetFullPath(destination); if (!Directory.Exists(destination)) { throw Helper.IOException($"Destination path does not exist or is not a directory."); } if (Directory.Exists(junctionPoint) && overwrite == false) { throw Helper.IOException($"Directory '{junctionPoint}' already exists."); } // try { Directory.Delete(reparsePoint);} catch (Exception ex) {} Directory.CreateDirectory(junctionPoint); using (var handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { var sourceDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + destination); var reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = (ushort)(sourceDirBytes.Length + 12), SubstituteNameOffset = 0, SubstituteNameLength = (ushort)sourceDirBytes.Length, PrintNameOffset = (ushort)(sourceDirBytes.Length + 2), PrintNameLength = 0, PathBuffer = new byte[0x3ff0] }; Array.Copy(sourceDirBytes, reparseDataBuffer.PathBuffer, sourceDirBytes.Length); var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, sourceDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error($"Unable to create junction point '{destination}' -> '{junctionPoint}'."); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
private static extern bool DeviceIoControl( IntPtr hDevice, uint dwIoControlCode, IntPtr lpInBuffer, uint nInBufferSize, //IntPtr lpOutBuffer, out REPARSE_DATA_BUFFER outBuffer, uint nOutBufferSize, out uint lpBytesReturned, IntPtr lpOverlapped);
static extern bool DeviceIoControl( IntPtr hDevice, uint dwIoControlCode, IntPtr lpInBuffer, uint nInBufferSize, //IntPtr lpOutBuffer, out REPARSE_DATA_BUFFER outBuffer, uint nOutBufferSize, 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="junctionPoint">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 junctionPoint, string targetDir, bool overwrite) { targetDir = Path.GetFullPath(targetDir); if (!Directory.Exists(targetDir)) throw new IOException("Target path does not exist or is not a directory."); if (Directory.Exists(junctionPoint)) { if (!overwrite) throw new IOException("SourceDirectory already exists and overwrite parameter is false."); } else { Directory.CreateDirectory(junctionPoint); } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { var targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDir)); var reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = (ushort) (targetDirBytes.Length + 12), SubstituteNameOffset = 0, SubstituteNameLength = (ushort) targetDirBytes.Length, PrintNameOffset = (ushort) (targetDirBytes.Length + 2), PrintNameLength = 0, PathBuffer = new byte[0x3ff0] }; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) ThrowLastWin32Error("Unable to create junction point."); } finally { Marshal.FreeHGlobal(inBuffer); } } }
/// <summary> /// Deletes a junction point at the specified source directory along with the directory itself. /// Does nothing if the junction point does not exist. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The junction point path</param> public static void Delete(string junctionPoint) { if (!Directory.Exists(junctionPoint)) { if (File.Exists(junctionPoint)) { throw new IOException("Path is not a junction point."); } return; } using (var handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { var reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = 0, PathBuffer = new byte[0x3ff0] }; var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; var result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_DELETE_REPARSE_POINT, inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to delete junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } try { Directory.Delete(junctionPoint); } catch (IOException ex) { throw new IOException("Unable to delete junction point.", ex); } } }
public static void CreateJunction(string link, string target) { var di = new DirectoryInfo(link); if (di.Exists) { if (di.GetFiles().Length > 0 || di.GetDirectories().Length > 0) { throw new IOException("Directory already exists and is not empty"); } } else { di.Create(); } using (SafeFileHandle handle = OpenReparsePoint(link, EFileAccess.GenericWrite)) { byte[] linkbytes = Encoding.Unicode.GetBytes(VIRTUAL_NTFS_PATH_PREFIX + Path.GetFullPath(target)); REPARSE_DATA_BUFFER buffer = new REPARSE_DATA_BUFFER(); buffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; buffer.ReparseDataLength = (ushort)(linkbytes.Length + 12); buffer.SubstituteNameOffset = 0; buffer.SubstituteNameLength = (ushort)linkbytes.Length; buffer.PrintNameOffset = (ushort)(linkbytes.Length + 2); buffer.PrintNameLength = 0; buffer.PathBuffer = new byte[0x3ff0]; Array.Copy(linkbytes, buffer.PathBuffer, linkbytes.Length); int _size = Marshal.SizeOf(buffer); IntPtr _buffer = Marshal.AllocHGlobal(_size); try { Marshal.StructureToPtr(buffer, _buffer, false); int bytesReturned; bool result = NativeMethods.DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, _buffer, linkbytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { throw new IOException("Failed to create junction", Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error())); } } finally { Marshal.FreeHGlobal(_buffer); } } }
private string GetTargetPath() { IntPtr buff = IntPtr.Zero; int dataSize = 0; SafeFileHandle handle = OpenFile(); if (handle.IsInvalid) { return(null); } try { // // Try REPARSE data if (FindReparsePoint(handle, out buff, out dataSize)) { REPARSE_DATA_BUFFER reparseData = Marshal.PtrToStructure <REPARSE_DATA_BUFFER>(buff); if (reparseData.ReparseTag == ReparseTagType.IO_REPARSE_TAG_SYMLINK || reparseData.ReparseTag == ReparseTagType.IO_REPARSE_TAG_MOUNT_POINT) { // // Since the data size isn't fixed, Marshal.PtrToStructure can't return via reparseData.PathBuffer // Therefore we need to marshal it manually from the native data int offset = Marshal.SizeOf <REPARSE_DATA_BUFFER>(); byte[] data = new byte[dataSize]; Marshal.Copy(new IntPtr(buff.ToInt64() + offset), data, 0, data.Length); // // Symlink if (reparseData.ReparseTag == ReparseTagType.IO_REPARSE_TAG_SYMLINK) { return(Encoding.Unicode.GetString(data, reparseData.PrintNameOffset, reparseData.PrintNameLength)); } // // Junction return(Encoding.Unicode.GetString(data, reparseData.PrintNameOffset - Marshal.SizeOf <IntPtr>(), reparseData.PrintNameLength)); } } // // Fallback if REPARSE point can't be used return(GetFinalPathNameByHandle(handle)); } finally { handle.Dispose(); Marshal.FreeHGlobal(buff); } }
public static void Delete(string junctionPoint) { if (!Directory.Exists(junctionPoint)) { if (File.Exists(junctionPoint)) { throw new IOException("Path is not a junction point."); } return; } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IoReparseTagMountPoint; reparseDataBuffer.ReparseDataLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FsctlDeleteReparsePoint, inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error(Strings.UnableToDeleteJunctionPoint); } } finally { Marshal.FreeHGlobal(inBuffer); } try { Directory.Delete(junctionPoint); } catch (IOException ex) { throw new IOException(Strings.UnableToDeleteJunctionPoint, ex); } } }
private static ReparsePointInfo InternalGetTarget(SafeFileHandle handle) { int outBufferSize = Marshal.SizeOf(typeof(REPARSE_DATA_BUFFER)); IntPtr outBuffer = Marshal.AllocHGlobal(outBufferSize); try { int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, outBuffer, outBufferSize, out bytesReturned, IntPtr.Zero); if (!result) { int error = Marshal.GetLastWin32Error(); if (error == ERROR_NOT_A_REPARSE_POINT) { return(null); } ThrowLastWin32Error("Unable to get information about junction point."); } REPARSE_DATA_BUFFER reparseDataBuffer = (REPARSE_DATA_BUFFER) Marshal.PtrToStructure(outBuffer, typeof(REPARSE_DATA_BUFFER)); var res = new ReparsePointInfo { ReparseTag = (ReparsePointTag)reparseDataBuffer.ReparseTag, IsJunction = reparseDataBuffer.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT, }; if (!res.IsJunction) { return(res); } res.SubstituteName = Encoding.Unicode.GetString(reparseDataBuffer.PathBuffer, reparseDataBuffer.SubstituteNameOffset, reparseDataBuffer.SubstituteNameLength); res.PrintName = Encoding.Unicode.GetString(reparseDataBuffer.PathBuffer, reparseDataBuffer.PrintNameOffset, reparseDataBuffer.PrintNameLength); return(res); } finally { Marshal.FreeHGlobal(outBuffer); } }
private static string InternalGetTarget(SafeFileHandle handle) { int outBufferSize = Marshal.SizeOf(typeof(REPARSE_DATA_BUFFER)); IntPtr outBuffer = Marshal.AllocHGlobal(outBufferSize); try { int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, outBuffer, outBufferSize, out bytesReturned, IntPtr.Zero); if (!result) { int error = Marshal.GetLastWin32Error(); if (error == ERROR_NOT_A_REPARSE_POINT) { return(null); } ThrowLastWin32Error("Unable to get information about junction point."); } REPARSE_DATA_BUFFER reparseDataBuffer = (REPARSE_DATA_BUFFER) Marshal.PtrToStructure(outBuffer, typeof(REPARSE_DATA_BUFFER)); if (reparseDataBuffer.ReparseTag != IO_REPARSE_TAG_MOUNT_POINT) { return(null); } string targetDir = Encoding.Unicode.GetString(reparseDataBuffer.PathBuffer, reparseDataBuffer.SubstituteNameOffset, reparseDataBuffer.SubstituteNameLength); if (targetDir.StartsWith(NonInterpretedPathPrefix)) { targetDir = targetDir.Substring(NonInterpretedPathPrefix.Length); } return(targetDir); } finally { Marshal.FreeHGlobal(outBuffer); } }
/// <summary> /// Creates a junction point from the specified directory to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The junction point path</param> /// <param name="target">The target directory</param> /// <exception cref="IOException">Thrown when the junction point could not be created or when public void Create(string junctionPoint, string target) { target = Path.GetFullPath(target); Directory.CreateDirectory(junctionPoint); using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { byte[] targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(target)); var reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = (ushort)(targetDirBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort)targetDirBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort)(targetDirBytes.Length + 2); reparseDataBuffer.PrintNameLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to create junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
private static string InternalGetTarget(SafeFileHandle handle) { int outBufferSize = Marshal.SizeOf(typeof(REPARSE_DATA_BUFFER)); IntPtr outBuffer = Marshal.AllocHGlobal(outBufferSize); try { int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FsctlGetReparsePoint, IntPtr.Zero, 0, outBuffer, outBufferSize, out bytesReturned, IntPtr.Zero); if (!result) { int error = Marshal.GetLastWin32Error(); if (error == ErrorNotAReparsePoint) { return(null); } ThrowLastWin32Error(Strings.UnableToGetJunctionInformation); } REPARSE_DATA_BUFFER reparseDataBuffer = (REPARSE_DATA_BUFFER) Marshal.PtrToStructure(outBuffer, typeof(REPARSE_DATA_BUFFER)); if (reparseDataBuffer.ReparseTag != IoReparseTagMountPoint) { return(null); } string targetDir = Encoding.Unicode.GetString(reparseDataBuffer.PathBuffer, reparseDataBuffer.SubstituteNameOffset, reparseDataBuffer.SubstituteNameLength); if (targetDir.StartsWith(NonInterpretedPathPrefix, StringComparison.Ordinal)) { targetDir = targetDir.Substring(NonInterpretedPathPrefix.Length); } return(targetDir); } finally { Marshal.FreeHGlobal(outBuffer); } }
private static void CreateJuntionWindows(string sourceDir, string targetDir) { Directory.CreateDirectory(targetDir); using (SafeFileHandle handle = OpenReparsePoint(targetDir, EFileAccess.GenericWrite)) { byte[] sourceDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(sourceDir)); REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = (ushort)(sourceDirBytes.Length + 12), SubstituteNameOffset = 0, SubstituteNameLength = (ushort)sourceDirBytes.Length, PrintNameOffset = (ushort)(sourceDirBytes.Length + 2), PrintNameLength = 0, PathBuffer = new byte[0x3ff0], }; Array.Copy(sourceDirBytes, reparseDataBuffer.PathBuffer, sourceDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer: inBuffer, nInBufferSize: sourceDirBytes.Length + 20, outBuffer: IntPtr.Zero, nOutBufferSize: 0, pBytesReturned: out bytesReturned, lpOverlapped: IntPtr.Zero); if (!result) { ThrowLastWin32Error($"Unable to create junction point \'{sourceDir}\' -> \'{targetDir}\'."); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
public static void Create(string junctionPoint, string substituteName, string printName) { using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { byte[] substituteNameBytes = Encoding.Unicode.GetBytes(substituteName); byte[] printNameBytes = Encoding.Unicode.GetBytes(printName); REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = (ushort)(substituteNameBytes.Length + printNameBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort)substituteNameBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort)(substituteNameBytes.Length + 2); reparseDataBuffer.PrintNameLength = (ushort)printNameBytes.Length; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(substituteNameBytes, 0, reparseDataBuffer.PathBuffer, reparseDataBuffer.SubstituteNameOffset, reparseDataBuffer.SubstituteNameLength); Array.Copy(printNameBytes, 0, reparseDataBuffer.PathBuffer, reparseDataBuffer.PrintNameOffset, reparseDataBuffer.PrintNameLength); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, substituteNameBytes.Length + printNameBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error("Unable to create junction point."); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
public static string SymlinkTargetFromHandle(SafeFileHandle handle) { var rdb = new REPARSE_DATA_BUFFER(); var x = 10; var outSize = new IntPtr(x); if ( !DeviceIoControl(handle, FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, out rdb, (UInt32)Marshal.SizeOf(rdb), out outSize, IntPtr.Zero)) { throw new Win32Exception(); } if (rdb.ReparseTag != IO_REPARSE_TAG_SYMLINK) { throw new ApplicationException("not a symlink"); } var arrayOffset = rdb.PrintNameOffset / 2; return(rdb.PathBuffer.Substring(arrayOffset, arrayOffset + (rdb.PrintNameLength / 2))); }
/// <summary> /// Takes a full path to a reparse point and finds the target. /// </summary> /// <param name="path">Full path of the reparse point</param> public ReparsePoint(string path) { Debug.Assert(!string.IsNullOrEmpty(path) && path.Length > 2 && path[1] == ':' && path[2] == '\\'); normalisedTarget = ""; tag = TagType.None; bool success; int lastError; // Apparently we need to have backup privileges IntPtr token; TOKEN_PRIVILEGES tokenPrivileges = new TOKEN_PRIVILEGES(); tokenPrivileges.Privileges = new LUID_AND_ATTRIBUTES[1]; success = OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, out token); lastError = Marshal.GetLastWin32Error(); if (success) { success = LookupPrivilegeValue(null, SE_BACKUP_NAME, out tokenPrivileges.Privileges[0].Luid); // null for local system lastError = Marshal.GetLastWin32Error(); if (success) { tokenPrivileges.PrivilegeCount = 1; tokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; success = AdjustTokenPrivileges(token, false, ref tokenPrivileges, Marshal.SizeOf(tokenPrivileges), IntPtr.Zero, IntPtr.Zero); lastError = Marshal.GetLastWin32Error(); } CloseHandle(token); } if (success) { // Open the file and get its handle IntPtr handle = CreateFile(path, FileAccess.Read, FileShare.None, 0, FileMode.Open, FILE_FLAG_OPEN_REPARSE_POINT | FILE_FLAG_BACKUP_SEMANTICS, IntPtr.Zero); lastError = Marshal.GetLastWin32Error(); if (handle.ToInt32() >= 0) { REPARSE_DATA_BUFFER buffer = new REPARSE_DATA_BUFFER(); // Make up the control code - see CTL_CODE on ntddk.h uint controlCode = (FILE_DEVICE_FILE_SYSTEM << 16) | (FILE_ANY_ACCESS << 14) | (FSCTL_GET_REPARSE_POINT << 2) | METHOD_BUFFERED; uint bytesReturned; success = DeviceIoControl(handle, controlCode, IntPtr.Zero, 0, out buffer, MAXIMUM_REPARSE_DATA_BUFFER_SIZE, out bytesReturned, IntPtr.Zero); lastError = Marshal.GetLastWin32Error(); if (success) { string subsString = ""; string printString = ""; // Note that according to http://wesnerm.blogs.com/net_undocumented/2006/10/symbolic_links_.html // Symbolic links store relative paths, while junctions use absolute paths // however, they can in fact be either, and may or may not have a leading \. Debug.Assert(buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK || buffer.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT, "Unrecognised reparse tag"); // We only recognise these two if (buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK) { // for some reason symlinks seem to have an extra two characters on the front subsString = new string(buffer.ReparseTarget, (buffer.SubsNameOffset / 2 + 2), buffer.SubsNameLength / 2); printString = new string(buffer.ReparseTarget, (buffer.PrintNameOffset / 2 + 2), buffer.PrintNameLength / 2); tag = TagType.SymbolicLink; } else if (buffer.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) { // This could be a junction or a mounted drive - a mounted drive starts with "\\??\\Volume" subsString = new string(buffer.ReparseTarget, buffer.SubsNameOffset / 2, buffer.SubsNameLength / 2); printString = new string(buffer.ReparseTarget, buffer.PrintNameOffset / 2, buffer.PrintNameLength / 2); tag = subsString.StartsWith(@"\??\Volume") ? TagType.MountPoint : TagType.JunctionPoint; } Debug.Assert(!(string.IsNullOrEmpty(subsString) && string.IsNullOrEmpty(printString)), "Failed to retrieve parse point"); // the printstring should give us what we want if (!string.IsNullOrEmpty(printString)) { normalisedTarget = printString; } else { // if not we can use the substring with a bit of tweaking normalisedTarget = subsString; Debug.Assert(normalisedTarget.Length > 2, "Target string too short"); Debug.Assert( (normalisedTarget.StartsWith(@"\??\") && (normalisedTarget[5] == ':' || normalisedTarget.StartsWith(@"\??\Volume")) || (!normalisedTarget.StartsWith(@"\??\") && normalisedTarget[1] != ':')), "Malformed subsString"); // Junction points must be absolute Debug.Assert( buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK || normalisedTarget.StartsWith(@"\??\Volume") || normalisedTarget[1] == ':', "Relative junction point"); if (normalisedTarget.StartsWith(@"\??\")) { normalisedTarget = normalisedTarget.Substring(4); } } actualTarget = normalisedTarget; // Symlinks can be relative. if (buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK && (normalisedTarget.Length < 2 || normalisedTarget[1] != ':')) { // it's relative, we need to tack it onto the path if (normalisedTarget[0] == '\\') { normalisedTarget = normalisedTarget.Substring(1); } if (path.EndsWith(@"\")) { path = path.Substring(0, path.Length - 1); } // Need to take the symlink name off the path normalisedTarget = path.Substring(0, path.LastIndexOf('\\')) + @"\" + normalisedTarget; // Note that if the symlink target path contains any ..s these are not normalised but returned as is. } // Remove any final slash for consistency if (normalisedTarget.EndsWith("\\")) { normalisedTarget = normalisedTarget.Substring(0, normalisedTarget.Length - 1); } } CloseHandle(handle); } else { success = false; } } }
/// <summary> /// Deletes a junction point at the specified source directory along with the directory itself. /// Does nothing if the junction point does not exist. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The junction point path</param> public static void Delete(string junctionPoint) { if (!Directory.Exists(junctionPoint)) { if (File.Exists(junctionPoint)) throw new IOException("Path is not a junction point."); return; } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_DELETE_REPARSE_POINT, inBuffer, 8, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) ThrowLastWin32Error("Unable to delete junction point."); } finally { Marshal.FreeHGlobal(inBuffer); } try { Directory.Delete(junctionPoint); } catch (IOException ex) { throw new IOException("Unable to delete junction point.", ex); } } }
public static void CreateJunction(string name, string target) { // If the target doesn't include a full path, assume relative to the current directory. if (!Path.IsPathRooted(target)) { target = Path.Combine(Directory.GetCurrentDirectory(), target); } // likewise if the link name omits a path, make it relative to the current directory. if (!Path.IsPathRooted(name)) { name = Path.Combine(Directory.GetCurrentDirectory(), name); } // Check target exists before trying to create a link if (!Directory.Exists(target)) { throw new CreationFailedException("Target directory " + target + " does not exist"); } // Create a directory to populate with our reparse point // If it isn't empty, create file will return 'directory not empty..' Directory.CreateDirectory(name); SafeFileHandle h = CreateFile(name, GENERIC_WRITE, 0, IntPtr.Zero, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, IntPtr.Zero); try { if (h.IsInvalid) { throw new CreationFailedException(Marshal.GetLastWin32Error()); } // Transform the file into a reparse point var targetBytes = Encoding.Unicode.GetBytes(prefix + target); var reparseDataBuffer = new REPARSE_DATA_BUFFER { ReparseTag = IO_REPARSE_TAG_MOUNT_POINT, ReparseDataLength = (ushort)(targetBytes.Length + 12), SubstituteNameOffset = 0, SubstituteNameLength = (ushort)targetBytes.Length, PrintNameOffset = (ushort)(targetBytes.Length + 2), PrintNameLength = 0, PathBuffer = new byte[32768] // This should not be fixed }; Array.Copy(targetBytes, reparseDataBuffer.PathBuffer, targetBytes.Length); var inBufferSize = Marshal.SizeOf(reparseDataBuffer); var inBuffer = Marshal.AllocHGlobal(inBufferSize); Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); var r = DeviceIoControl(h.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetBytes.Length + 20, IntPtr.Zero, 0, out int bytesReturned, IntPtr.Zero); Marshal.FreeHGlobal(inBuffer); if (!r) { throw new CreationFailedException(Marshal.GetLastWin32Error()); } } finally { h.Close(); } return; }
/// <summary> /// Creates a junction point from the specified directory to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">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 CreateJunctionPointTo(this PathSpec junctionPoint, PathSpec targetDir, bool overwrite) { targetDir = targetDir.ToAbsolute(); if (targetDir.GetPathType() != PathType.Folder) throw new IOException("Target path does not exist or is not a directory."); if (junctionPoint.GetPathType() == PathType.Folder) { if (!overwrite) throw new IOException("Directory already exists and overwrite parameter is false."); } else { junctionPoint.Create(PathType.Folder); } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint.ToString(), EFileAccess.GenericWrite)) { byte[] targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDir.ToString())); REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = (ushort)(targetDirBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort)targetDirBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort)(targetDirBytes.Length + 2); reparseDataBuffer.PrintNameLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) ThrowLastWin32Error("Unable to create junction point."); } finally { Marshal.FreeHGlobal(inBuffer); } } }
public static string GetSymlinkTarget(string SymlinkPath) { if (Environment.OSVersion.Version.Major <= 5) { throw new InvalidOperationException("Only supported on Vista or later"); } IntPtr hFile = CreateFileNet( SymlinkPath, EFileAccess.GenericRead, EFileShare.Read | EFileShare.Write | EFileShare.Delete, IntPtr.Zero, ECreationDisposition.OpenExisting, EFileAttributes.BackupSemantics | EFileAttributes.OpenReparsePoint, IntPtr.Zero ); try { uint bufferSize = MAXIMUM_REPARSE_DATA_BUFFER_SIZE; IntPtr symData = Marshal.AllocHGlobal((int)bufferSize); try { uint bytesReturned = 0; try { DeviceIoControlNet(hFile, FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, symData, bufferSize, out bytesReturned, IntPtr.Zero); } catch (NotASymlinkException) { throw new NotASymlinkException(string.Format("{0} is not a symlink", SymlinkPath)); } REPARSE_DATA_BUFFER symDataHeader = (REPARSE_DATA_BUFFER)Marshal.PtrToStructure(symData, typeof(REPARSE_DATA_BUFFER)); if (symDataHeader.ReparseTag == IO_REPARSE_TAG_SYMLINK) { int subNameLength = ((int)symDataHeader.unnamedUnion.SymbolicLinkReparseBuffer.SubstituteNameLength) / ((int)Marshal.SizeOf(typeof(ushort))); uint subNameOffset = (uint)symDataHeader.unnamedUnion.SymbolicLinkReparseBuffer.SubstituteNameOffset; long pathOffset = symData.ToInt64(); pathOffset += Marshal.OffsetOf(typeof(REPARSE_DATA_BUFFER), "unnamedUnion").ToInt64(); pathOffset += Marshal.SizeOf(typeof(SymbolicLinkReparseBufferStructure)); pathOffset += subNameOffset; IntPtr pathBuffer = new IntPtr(pathOffset); string subPath = Marshal.PtrToStringUni(pathBuffer, subNameLength); if (subPath.StartsWith("\\??\\")) { subPath = subPath.Substring(4); } return(subPath); } else { throw new NotASymlinkException(string.Format("{0} is not a symlink", SymlinkPath)); } } finally { Marshal.FreeHGlobal(symData); } } finally { CloseHandleNet(hFile); } }
//----------------------------------------------------------------------- // Gets the target path for a reparse point private static void GetTarget(ref ReparsePoint rp) { string wPath = rp.Path; if (!wPath.StartsWith(@"\\?\")) wPath = @"\\?\" + wPath; if (((uint)rp.TagType & (uint)ReparseTagType.IO_REPARSE_TAG_MOUNT_POINT) != (uint)ReparseTagType.IO_REPARSE_TAG_MOUNT_POINT) { rp.Target = ""; return; } try { // We need a handle to the reparse point to pass to DeviceIocontrol down below. // CreateFile is how we get that handle. // We want to play nice with others, so we note that we're only reading it, and we want to // allow others to be able to access (but not delete) it as well while we have the handle (the // GENERIC_READ and FILE_SHARE_READ | FILE_SHARE_WRITE values) // // Biggest key is the flag FILE_FLAG_OPEN_REPARSE_POINT, which tells CreateFile that we want // a handle to the reparse point itself and not to the target of the reparse point // // CreateFile will return INVALID_HANDLE_VALUE with a last error of 5 - Access Denied // if the FILE_FLAG_BACKUP_SEMANTICS is not specified when opening a directory/reparse point // It's noted in the directory section of the CreateFile MSDN page IntPtr pathHndl = CreateFileW(wPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, IntPtr.Zero); if (pathHndl.ToInt32() == INVALID_HANDLE_VALUE) { rp.Err = Marshal.GetLastWin32Error(); rp.ErrMsg = "Invalid Handle returned by CreateFile"; rp.Target = ""; return; } uint lenDataReturned = 0; REPARSE_DATA_BUFFER rpDataBuf = new REPARSE_DATA_BUFFER(); //Allocate a buffer to get the "user defined data" out of the reaprse point. //MSDN page on FSCTL_GET_REPARSE_POINT discusses size calculation IntPtr pMem = Marshal.AllocHGlobal(Marshal.SizeOf(rpDataBuf) + ReparseHeaderSize); //DeviceIocontrol takes a handle to a file/directory/device etc, that's obtained via CreateFile // In our case, it's a handle to the directory that's marked a reparse point //We pass in the FSCTL_GET_REPARSE_POINT flag to getll DeviceIoControl that we want to get data about a reparse point //There is no In buffer. pMem is our out buffer that will hold the returned REPARSE_DATA_BUFFER //lenDataReturned is of course how much data was copied into our buffer pMem. //We're doing a simple call.. no asyncronous stuff going on, so Overlapped is a null pointer if (!DeviceIoControl(pathHndl, FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, pMem, (uint)Marshal.SizeOf(rpDataBuf) + ReparseHeaderSize, out lenDataReturned, IntPtr.Zero)) { rp.ErrMsg = "Call to DeviceIoControl failed"; rp.Err = Marshal.GetLastWin32Error(); rp.Target = ""; } else { rpDataBuf = (REPARSE_DATA_BUFFER)Marshal.PtrToStructure(pMem, rpDataBuf.GetType()); rp.Target = rpDataBuf.PathBuffer; } Marshal.FreeHGlobal(pMem); CloseHandle(pathHndl); } catch (Exception e) { rp.Err = -1; rp.ErrMsg = e.Message; rp.Target = ""; } return; }
/// <summary> /// Creates a junction point from the specified directory to the specified target directory. /// </summary> /// <remarks> /// Only works on NTFS. /// </remarks> /// <param name="junctionPoint">The junction point path</param> /// <param name="target">The target directory</param> /// <exception cref="IOException">Thrown when the junction point could not be created or when public void Create(string junctionPoint, string target) { target = Path.GetFullPath(target); Directory.CreateDirectory(junctionPoint); using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { byte[] targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(target)); var reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IO_REPARSE_TAG_MOUNT_POINT; reparseDataBuffer.ReparseDataLength = (ushort) (targetDirBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort) targetDirBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort) (targetDirBytes.Length + 2); reparseDataBuffer.PrintNameLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl(handle.DangerousGetHandle(), FSCTL_SET_REPARSE_POINT, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) ThrowLastWin32Error("Unable to create junction point."); } finally { Marshal.FreeHGlobal(inBuffer); } } }
private static extern bool DeviceIoControl(SafeFileHandle hDevice, UInt32 dwIoControlCode, IntPtr lpInBuffer, UInt32 nInBufferSize, out REPARSE_DATA_BUFFER rdb, UInt32 nOutBufferSize, out IntPtr lpBytesReturned, IntPtr lpOverlapped);
public static void Create(string junctionPoint, string targetDir, bool overwrite) { targetDir = Path.GetFullPath(targetDir); if (!Directory.Exists(targetDir)) { throw new IOException("Target path does not exist or is not a directory."); } if (Directory.Exists(junctionPoint)) { if (!overwrite) { throw new IOException("Directory already exists and overwrite parameter is false."); } } else { Directory.CreateDirectory(junctionPoint); } using (SafeFileHandle handle = OpenReparsePoint(junctionPoint, EFileAccess.GenericWrite)) { byte[] targetDirBytes = Encoding.Unicode.GetBytes(NonInterpretedPathPrefix + Path.GetFullPath(targetDir)); REPARSE_DATA_BUFFER reparseDataBuffer = new REPARSE_DATA_BUFFER(); reparseDataBuffer.ReparseTag = IoReparseTagMountPoint; reparseDataBuffer.ReparseDataLength = (ushort)(targetDirBytes.Length + 12); reparseDataBuffer.SubstituteNameOffset = 0; reparseDataBuffer.SubstituteNameLength = (ushort)targetDirBytes.Length; reparseDataBuffer.PrintNameOffset = (ushort)(targetDirBytes.Length + 2); reparseDataBuffer.PrintNameLength = 0; reparseDataBuffer.PathBuffer = new byte[0x3ff0]; Array.Copy(targetDirBytes, reparseDataBuffer.PathBuffer, targetDirBytes.Length); int inBufferSize = Marshal.SizeOf(reparseDataBuffer); IntPtr inBuffer = Marshal.AllocHGlobal(inBufferSize); try { Marshal.StructureToPtr(reparseDataBuffer, inBuffer, false); int bytesReturned; bool result = DeviceIoControl( handle.DangerousGetHandle(), FsctlSetReparsePoint, inBuffer, targetDirBytes.Length + 20, IntPtr.Zero, 0, out bytesReturned, IntPtr.Zero); if (!result) { ThrowLastWin32Error(Strings.UnableToCreateJunctionPoint); } } finally { Marshal.FreeHGlobal(inBuffer); } } }
//----------------------------------------------------------------------- // Gets the target path for a reparse point private static void GetTarget(ref ReparsePoint rp) { string wPath = rp.Path; if (!wPath.StartsWith(@"\\?\")) { wPath = @"\\?\" + wPath; } if (((uint)rp.TagType & (uint)ReparseTagType.IO_REPARSE_TAG_MOUNT_POINT) != (uint)ReparseTagType.IO_REPARSE_TAG_MOUNT_POINT) { rp.Target = ""; return; } try { // We need a handle to the reparse point to pass to DeviceIocontrol down below. // CreateFile is how we get that handle. // We want to play nice with others, so we note that we're only reading it, and we want to // allow others to be able to access (but not delete) it as well while we have the handle (the // GENERIC_READ and FILE_SHARE_READ | FILE_SHARE_WRITE values) // // Biggest key is the flag FILE_FLAG_OPEN_REPARSE_POINT, which tells CreateFile that we want // a handle to the reparse point itself and not to the target of the reparse point // // CreateFile will return INVALID_HANDLE_VALUE with a last error of 5 - Access Denied // if the FILE_FLAG_BACKUP_SEMANTICS is not specified when opening a directory/reparse point // It's noted in the directory section of the CreateFile MSDN page IntPtr pathHndl = CreateFileW(wPath, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, IntPtr.Zero, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, IntPtr.Zero); if (pathHndl.ToInt32() == INVALID_HANDLE_VALUE) { rp.Err = Marshal.GetLastWin32Error(); rp.ErrMsg = "Invalid Handle returned by CreateFile"; rp.Target = ""; return; } uint lenDataReturned = 0; REPARSE_DATA_BUFFER rpDataBuf = new REPARSE_DATA_BUFFER(); //Allocate a buffer to get the "user defined data" out of the reaprse point. //MSDN page on FSCTL_GET_REPARSE_POINT discusses size calculation IntPtr pMem = Marshal.AllocHGlobal(Marshal.SizeOf(rpDataBuf) + ReparseHeaderSize); //DeviceIocontrol takes a handle to a file/directory/device etc, that's obtained via CreateFile // In our case, it's a handle to the directory that's marked a reparse point //We pass in the FSCTL_GET_REPARSE_POINT flag to getll DeviceIoControl that we want to get data about a reparse point //There is no In buffer. pMem is our out buffer that will hold the returned REPARSE_DATA_BUFFER //lenDataReturned is of course how much data was copied into our buffer pMem. //We're doing a simple call.. no asyncronous stuff going on, so Overlapped is a null pointer if (!DeviceIoControl(pathHndl, FSCTL_GET_REPARSE_POINT, IntPtr.Zero, 0, pMem, (uint)Marshal.SizeOf(rpDataBuf) + ReparseHeaderSize, out lenDataReturned, IntPtr.Zero)) { rp.ErrMsg = "Call to DeviceIoControl failed"; rp.Err = Marshal.GetLastWin32Error(); rp.Target = ""; } else { rpDataBuf = (REPARSE_DATA_BUFFER)Marshal.PtrToStructure(pMem, rpDataBuf.GetType()); rp.Target = rpDataBuf.PathBuffer; } Marshal.FreeHGlobal(pMem); CloseHandle(pathHndl); } catch (Exception e) { rp.Err = -1; rp.ErrMsg = e.Message; rp.Target = ""; } return; }
/// <summary> /// Takes a full path to a reparse point and finds the target. /// </summary> /// <param name="path">Full path of the reparse point</param> public ReparsePoint(string path) { //Debug.Assert(!string.IsNullOrEmpty(path) && path.Length > 2 && path[1] == ':' && path[2] == '\\'); normalisedTarget = string.Empty; tag = TagType.None; bool success; int lastError; // Apparently we need to have backup privileges /*IntPtr token; * TOKEN_PRIVILEGES tokenPrivileges = new TOKEN_PRIVILEGES(); * tokenPrivileges.Privileges = new LUID_AND_ATTRIBUTES[1]; * success = OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, out token); * lastError = Marshal.GetLastWin32Error(); * if (success) * { * success = LookupPrivilegeValue(null, SE_BACKUP_NAME, out tokenPrivileges.Privileges[0].Luid); // null for local system * lastError = Marshal.GetLastWin32Error(); * if (success) * { * tokenPrivileges.PrivilegeCount = 1; * tokenPrivileges.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; * success = AdjustTokenPrivileges(token, false, ref tokenPrivileges, Marshal.SizeOf(tokenPrivileges), IntPtr.Zero, IntPtr.Zero); * lastError = Marshal.GetLastWin32Error(); * } * CloseHandle(token); * }*/ //if (success) { // Open the file and get its handle using (SafeFileHandle handle = CreateFile(path, EFileAccess.GenericRead, FileShare.ReadWrite | FileShare.Delete, IntPtr.Zero, FileMode.Open, FileAttributesEx.OpenReparsePoint | FileAttributesEx.BackupSemantics, IntPtr.Zero)) { lastError = Marshal.GetLastWin32Error(); if (!handle.IsInvalid) { int outBufferSize = Marshal.SizeOf(typeof(REPARSE_DATA_BUFFER)); IntPtr outBuffer = Marshal.AllocHGlobal(outBufferSize); //REPARSE_DATA_BUFFER buffer = new REPARSE_DATA_BUFFER(); // Make up the control code - see CTL_CODE on ntddk.h //uint controlCode = (FILE_DEVICE_FILE_SYSTEM << 16) | (FILE_ANY_ACCESS << 14) | (FSCTL_GET_REPARSE_POINT << 2) | METHOD_BUFFERED; success = DeviceIoControl(handle.DangerousGetHandle(), EIOControlCode.FsctlGetReparsePoint, IntPtr.Zero, 0, outBuffer, outBufferSize, out _, IntPtr.Zero); //lastError = Marshal.GetLastWin32Error(); if (success) { REPARSE_DATA_BUFFER buffer = (REPARSE_DATA_BUFFER) Marshal.PtrToStructure(outBuffer, typeof(REPARSE_DATA_BUFFER)); string subsString = string.Empty; string printString = string.Empty; // Note that according to http://wesnerm.blogs.com/net_undocumented/2006/10/symbolic_links_.html // Symbolic links store relative paths, while junctions use absolute paths // however, they can in fact be either, and may or may not have a leading \. /*Debug.Assert(buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK || buffer.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT, * "Unrecognised reparse tag"); // We only recognise these two */ if (buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK) { // for some reason symlinks seem to have an extra two characters on the front subsString = new string(buffer.ReparseTarget, (buffer.SubsNameOffset / 2 + 2), buffer.SubsNameLength / 2); printString = new string(buffer.ReparseTarget, (buffer.PrintNameOffset / 2 + 2), buffer.PrintNameLength / 2); tag = TagType.SymbolicLink; } else if (buffer.ReparseTag == IO_REPARSE_TAG_MOUNT_POINT) { // This could be a junction or a mounted drive - a mounted drive starts with "\\??\\Volume" subsString = new string(buffer.ReparseTarget, buffer.SubsNameOffset / 2, buffer.SubsNameLength / 2); printString = new string(buffer.ReparseTarget, buffer.PrintNameOffset / 2, buffer.PrintNameLength / 2); tag = subsString.StartsWith(@"\??\Volume", StringComparison.InvariantCultureIgnoreCase) ? TagType.MountPoint : TagType.JunctionPoint; } //Debug.Assert(!(string.IsNullOrEmpty(subsString) && string.IsNullOrEmpty(printString)), "Failed to retrieve parse point"); // the printstring should give us what we want if (printString.Length > 0) { normalisedTarget = printString; } else { // if not we can use the substring with a bit of tweaking normalisedTarget = subsString; /*Debug.Assert(normalisedTarget.Length > 2, "Target string too short"); * Debug.Assert( * (normalisedTarget.StartsWith(@"\??\") && (normalisedTarget[5] == ':' || normalisedTarget.StartsWith(@"\??\Volume")) || * (!normalisedTarget.StartsWith(@"\??\") && normalisedTarget[1] != ':')), * "Malformed subsString"); * // Junction points must be absolute * Debug.Assert( * buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK || * normalisedTarget.StartsWith(@"\??\Volume") || * normalisedTarget[1] == ':', * "Relative junction point");*/ if (normalisedTarget.StartsWith(@"\??\", StringComparison.Ordinal)) { normalisedTarget = normalisedTarget.Substring(4); } } actualTarget = normalisedTarget; // Symlinks can be relative. if (buffer.ReparseTag == IO_REPARSE_TAG_SYMLINK && (normalisedTarget.Length < 2 || normalisedTarget[1] != ':')) { // it's relative, we need to tack it onto the path if (normalisedTarget[0] == '\\') { normalisedTarget = normalisedTarget.Substring(1); } if (path.EndsWith(@"\", StringComparison.Ordinal)) { path = path.Substring(0, path.Length - 1); } // Need to take the symlink name off the path normalisedTarget = path.Substring(0, path.LastIndexOf('\\')) + @"\" + normalisedTarget; // Note that if the symlink target path contains any ..s these are not normalised but returned as is. } // Remove any final slash for consistency if (normalisedTarget.EndsWith("\\", StringComparison.Ordinal)) { normalisedTarget = normalisedTarget.Substring(0, normalisedTarget.Length - 1); } } Marshal.FreeHGlobal(outBuffer); handle.Close(); } /*else if (lastError == 5) * { * success = false; * }*/ else { throw new Win32Exception(lastError); } } } }