Esempio n. 1
0
        /// <summary>
        ///   Changes an existing link target to a new path.
        /// </summary>
        /// <param name="linkPath"> The link path. </param>
        /// <param name="newActualPath"> The new actual path. </param>
        /// <remarks>
        /// </remarks>
        public void ChangeLinkTarget(string linkPath, string newActualPath)
        {
            linkPath      = linkPath.GetFullPath();
            newActualPath = GetActualPath(newActualPath.GetFullPath());
            var oldActualPath = GetActualPath(linkPath);

            if (oldActualPath.Equals(newActualPath, StringComparison.CurrentCultureIgnoreCase))
            {
                return;
            }

            if (!IsSymlink(linkPath))
            {
                throw new PathIsNotSymlinkException(linkPath);
            }

            if (Directory.Exists(linkPath))
            {
                ReparsePoint.ChangeReparsePointTarget(linkPath, newActualPath);
            }
            else if (File.Exists(linkPath))
            {
                DeleteSymlink(linkPath);
                MakeFileLink(linkPath, newActualPath);
            }
            else
            {
                throw new DirectoryNotFoundException("Target directory not found");
            }
        }
Esempio n. 2
0
        public bool IsSymlink(string linkPath)
        {
            if (!ReparsePoint.IsReparsePoint(linkPath))
            {
                return(false);
            }

            var reparsePoint = ReparsePoint.Open(linkPath);

            return(reparsePoint.IsSymlinkOrJunction);
        }
Esempio n. 3
0
        public void ChangeLinkTarget(string linkPath, string newActualPath)
        {
            linkPath      = linkPath.GetFullPath();
            newActualPath = GetActualPath(newActualPath.GetFullPath());

            if (!IsSymlink(linkPath))
            {
                throw new PathIsNotSymlinkException(linkPath);
            }

            ReparsePoint.ChangeReparsePointTarget(linkPath, newActualPath);
        }
Esempio n. 4
0
 /// <summary>
 ///   Gets the actual path.
 /// </summary>
 /// <param name="linkPath"> The link path. </param>
 /// <returns> </returns>
 /// <remarks>
 /// </remarks>
 public string GetActualPath(string linkPath)
 {
     linkPath = linkPath.GetFullPath();
     if (File.Exists(linkPath))
     {
         string result;
         GetAlternateStreamData(linkPath, out result);
         return(result);
     }
     if (Directory.Exists(linkPath))
     {
         return(ReparsePoint.GetActualPath(linkPath));
     }
     return(linkPath);
 }
Esempio n. 5
0
        /// <summary>
        ///   Determines whether the specified link path is symlink.
        /// </summary>
        /// <param name="linkPath"> The link path. </param>
        /// <returns> <c>true</c> if the specified link path is symlink; otherwise, <c>false</c> . </returns>
        /// <remarks>
        /// </remarks>
        public bool IsSymlink(string linkPath)
        {
            linkPath = linkPath.GetFullPath();
            if (File.Exists(linkPath))
            {
                if (GetFileInfo(linkPath).NumberOfLinks > 1)
                {
                    string canonicalFilePath;
                    var    alternates = GetAlternateStreamData(linkPath, out canonicalFilePath);
                    var    result     = !linkPath.Equals(canonicalFilePath, StringComparison.CurrentCultureIgnoreCase);
                    try {
                        if (result && !alternates.Contains(linkPath))
                        {
                            AddSymlinkToAlternateStream(canonicalFilePath, linkPath);
                        }
                    } catch {
                        // just trying to clean-as-we-go
                    }

                    return(result);
                }
                try {
                    var s = new FileInfo(linkPath).GetAlternateDataStream(legacySymlinkInfo);
                    if (s.Exists)
                    {
                        s.Delete();
                    }
                } catch {
                    // just try to clean as we go...
                }
                return(false);
            }
            if (Directory.Exists(linkPath))
            {
                return(ReparsePoint.IsReparsePoint(linkPath));
            }
            throw new FileNotFoundException("Link does not exist");
        }
Esempio n. 6
0
        /// <summary>
        ///   Creates a symlink for a directory. If it already exists, it is updated.
        /// </summary>
        /// <param name="linkPath"> The link path. </param>
        /// <param name="actualFolderPath"> The actual folder path. </param>
        /// <remarks>
        /// </remarks>
        public void MakeDirectoryLink(string linkPath, string actualFolderPath)
        {
            linkPath         = linkPath.GetFullPath();
            actualFolderPath = GetActualPath(actualFolderPath.GetFullPath());

            if (!Directory.Exists(actualFolderPath))
            {
                throw new FileNotFoundException("Cannot link to non-existent directory", actualFolderPath);
            }

            if (Directory.Exists(linkPath) && IsSymlink(linkPath))
            {
                ReparsePoint.ChangeReparsePointTarget(linkPath, actualFolderPath);
                return;
            }

            if (File.Exists(linkPath) || Directory.Exists(linkPath))
            {
                throw new ConflictingFileOrFolderException(linkPath);
            }

            ReparsePoint.CreateJunction(linkPath, actualFolderPath);
        }
Esempio n. 7
0
 public string GetActualPath(string linkPath)
 {
     linkPath = linkPath.GetFullPath();
     return(ReparsePoint.GetActualPath(linkPath));
 }