Changeset 2523 for trunk/eraser

Timestamp:

3/14/2012 9:58:21 AM (15 months ago)

Author:

lowjoel

Message:

Implement recycle bin erasures according to what Vista and 7 would detect as part of the Recycle Bin. This would erase recycle bins which are on UNC paths and mounted drives without a drive letter. Tested and works with Windows 7 and Windows XP SP3.

Location:

trunk/eraser

Files:

• Eraser.DefaultPlugins/ErasureTargets/RecycleBinErasureTarget.cs (modified) (4 diffs)
• Eraser.Util/NativeMethods/Shell.cs (modified) (1 diff)
• Eraser.Util/Shell.cs (modified) (1 diff)

trunk/eraser/Eraser.DefaultPlugins/ErasureTargets/RecycleBinErasureTarget.cs

@@ -32 +32 @@
 using Eraser.Plugins;
 using Eraser.Plugins.ExtensionPoints;
+using Microsoft.Win32;
 
 namespace Eraser.DefaultPlugins
@@ -75 +76 @@
         protected override List<StreamInfo> GetPaths()
         {
-            List<StreamInfo> result = new List<StreamInfo>();
+            List<DirectoryInfo> directories = new List<DirectoryInfo>();
             string[] rootDirectory = new string[] {
                     "$RECYCLE.BIN",
@@ -84 +85 @@
                 User.ToString();
 
-            foreach (DriveInfo drive in DriveInfo.GetDrives())
+            //First try to get the recycle bin on each of of the physical volumes we have
+            foreach (VolumeInfo volume in VolumeInfo.Volumes)
             {
+                if (!volume.IsMounted)
+                    continue;
+
                 foreach (string rootDir in rootDirectory)
                 {
                     //First get the global recycle bin for the current drive
-                    string recycleBinPath = System.IO.Path.Combine(drive.Name, rootDir);
+                    string recycleBinPath = System.IO.Path.Combine(
+                        volume.MountPoints[0].FullName, rootDir);
                     if (!Directory.Exists(recycleBinPath))
                         continue;
@@ -97 +103 @@
                         recycleBinPath = System.IO.Path.Combine(recycleBinPath, userSid);
 
-                    foreach (FileInfo file in GetFiles(new DirectoryInfo(recycleBinPath)))
+                    directories.Add(new DirectoryInfo(recycleBinPath));
+                }
+            }
+
+            //Then try the Shell's known folders for Vista and later
+            using (RegistryKey key = Registry.CurrentUser.OpenSubKey(
+                "Software\\Microsoft\\Windows\\CurrentVersion\\Explorer\\BitBucket\\KnownFolder"))
+            {
+                if (key != null)
+                {
+                    string[] knownFolders = key.GetSubKeyNames();
+                    foreach (string stringGuid in knownFolders)
                     {
-                        //Add the ADSes
-                        result.AddRange(GetPathADSes(file));
+                        Guid guid = new Guid(stringGuid);
+                        DirectoryInfo info = Shell.KnownFolderIDs.GetPath(guid);
 
-                        //Then the file itself
-                        result.Add(new StreamInfo(file.FullName));
+                        if (info == null)
+                            continue;
+
+                        directories.Add(info);
                     }
                 }
             }
+
+            //Then get all the files in each of the directories
+            List<StreamInfo> result = new List<StreamInfo>();
+            foreach (DirectoryInfo directory in directories)
+                foreach (FileInfo file in GetFiles(directory))
+                {
+                    //Add the ADSes
+                    result.AddRange(GetPathADSes(file));
+
+                    //Then the file itself
+                    result.Add(new StreamInfo(file.FullName));
+                }
 
             return result;

trunk/eraser/Eraser.Util/NativeMethods/Shell.cs

@@ -414 +414 @@
         public static extern bool SHGetPathFromIDList(IntPtr pidl,
             StringBuilder pszPath);
+
+        /// <summary>
+        /// Retrieves the full path of a known folder identified by the folder's KNOWNFOLDERID.
+        /// </summary>
+        /// <param name="rfid">A reference to the KNOWNFOLDERID that identifies the
+        /// folder.</param>
+        /// <param name="dwFlags">Flags that specify special retrieval options. This value
+        /// can be 0; otherwise, one or more of the KNOWN_FOLDER_FLAG values.</param>
+        /// <param name="hToken">An access token that represents a particular user. If
+        /// this parameter is NULL, which is the most common usage, the function requests
+        /// the known folder for the current user.
+        /// 
+        /// Request a specific user's folder by passing the hToken of that user. This is
+        /// typically done in the context of a service that has sufficient privileges to
+        /// retrieve the token of a given user. That token must be opened with TOKEN_QUERY
+        /// and TOKEN_IMPERSONATE rights. In addition to passing the user's hToken, the
+        /// registry hive of that specific user must be mounted. See Access Control for
+        /// further discussion of access control issues.
+        /// 
+        /// Assigning the hToken parameter a value of -1 indicates the Default User. This
+        /// allows clients of SHGetKnownFolderPath to find folder locations (such as the
+        /// Desktop folder) for the Default User. The Default User user profile is duplicated
+        /// when any new user account is created, and includes special folders such as
+        /// Documents and Desktop. Any items added to the Default User folder also appear in
+        /// any new user account. Note that access to the Default User folders requires
+        /// administrator privileges.</param>
+        /// <param name="ppszPath">When this method returns, contains the address of a
+        /// pointer to a null-terminated Unicode string that specifies the path of the
+        /// known folder. The calling process is responsible for freeing this resource
+        /// once it is no longer needed by calling CoTaskMemFree. The returned path does
+        /// not include a trailing backslash. For example, "C:\Users" is returned rather
+        /// than "C:\Users\".</param>
+        /// <returns>Returns S_OK if successful, or an error value otherwise</returns>
+        [DllImport("Shell32.dll", CharSet = CharSet.Unicode)]
+        [return: MarshalAs(UnmanagedType.Error)]
+        internal static extern uint SHGetKnownFolderPath(
+            ref Guid rfid, uint dwFlags, IntPtr hToken, out IntPtr ppszPath);
     }
 }

trunk/eraser/Eraser.Util/Shell.cs

@@ -121 +121 @@
                 }
             }
+
+            /// <summary>
+            /// Retrieves the full path of a known folder identified by the folder's
+            /// KNOWNFOLDERID.
+            /// </summary>
+            /// <param name="guid">The KNOWNFOLDERID that identifies the folder.</param>
+            /// <returns>The DirectoryInfo for the given known folder path, or null if
+            /// an error occurred.</returns>
+            public static DirectoryInfo GetPath(Guid guid)
+            {
+                try
+                {
+                    IntPtr path = IntPtr.Zero;
+                    uint result = NativeMethods.SHGetKnownFolderPath(ref guid, 0, IntPtr.Zero,
+                        out path);
+
+                    if (result == 0)
+                    {
+                        string pathStr = Marshal.PtrToStringUni(path);
+                        Marshal.FreeCoTaskMem(path);
+
+                        return new DirectoryInfo(pathStr);
+                    }
+                    else
+                    {
+                        throw Marshal.GetExceptionForHR((int)result);
+                    }
+                }
+                catch (EntryPointNotFoundException)
+                {
+                    return null;
+                }
+            }
         }
     }