Changeset 1701


Ignore:
Timestamp:
1/27/2010 5:08:03 AM (3 years ago)
Author:
lowjoel
Message:

Forward port changes from trunk till r1700

Location:
branches/eraser6/CodeReview
Files:
1 added
15 edited

Legend:

Unmodified
Added
Removed

  • branches/eraser6/CodeReview

  • branches/eraser6/CodeReview/Eraser.DefaultPlugins/FileSystems/Windows.cs

    r1681 r1701  
    115115                    } 
    116116                } 
     117            } 
     118 
     119            //If the user wants plausible deniability, find a random file on the same 
     120            //volume and write it over. 
     121            if (Manager.ManagerLibrary.Settings.PlausibleDeniability) 
     122            { 
     123                using (FileStream fileStream = info.OpenWrite()) 
     124                    CopyPlausibleDeniabilityFile(fileStream); 
    117125            } 
    118126 

  • branches/eraser6/CodeReview/Eraser.Manager/DirectExecutor.cs

    r1681 r1701  
    402402                    delegate(int currentFile, int totalFiles, string currentFilePath) 
    403403                    { 
    404                         tipSearch.Completed = tipSearch.Total; 
     404                        tipSearch.MarkComplete(); 
    405405                        tipProgress.Total = totalFiles; 
    406406                        tipProgress.Completed = currentFile; 
    … …  
    482482 
    483483                //Mark the main bulk of the progress as complete 
    484                 mainProgress.Completed = mainProgress.Total; 
     484                mainProgress.MarkComplete(); 
    485485 
    486486                //Erase old resident file system table files 
    … …  
    502502                ); 
    503503 
    504                 residentProgress.Completed = residentProgress.Total = 1; 
     504                residentProgress.MarkComplete(); 
    505505            } 
    506506            finally 
    … …  
    513513                    new TaskProgressChangedEventArgs(string.Empty, 0, 0))); 
    514514                fsManager.DeleteFolder(info); 
    515                 tempFiles.Completed = tempFiles.Total = 1; 
     515                tempFiles.Completed = tempFiles.Total; 
    516516            } 
    517517 
    … …  
    537537            ); 
    538538 
    539             structureProgress.Completed = structureProgress.Total; 
     539            structureProgress.MarkComplete(); 
    540540            target.Progress = null; 
    541541        } 
    … …  
    583583                //Get the filesystem provider to handle the secure file erasures 
    584584                FileSystem fsManager = FileSystemManager.Get( 
    585                     VolumeInfo.FromMountpoint(info.DirectoryName)); 
     585                    VolumeInfo.FromMountPoint(info.DirectoryName)); 
    586586 
    587587                bool isReadOnly = false; 
    … …  
    611611                                throw new OperationCanceledException(S._("The task was cancelled.")); 
    612612 
     613                            step.Total = totalData; 
    613614                            step.Completed += lastWritten; 
    614                             step.Total = totalData; 
    615615                            task.OnProgressChanged(target, 
    616616                                new ProgressChangedEventArgs(step, 
    … …  
    622622                    if (fileInfo != null) 
    623623                        fsManager.DeleteFile(fileInfo); 
    624                     step.Completed = step.Total = 1; 
     624                    step.MarkComplete(); 
    625625                } 
    626626                catch (UnauthorizedAccessException) 
    … …  
    644644                                processes.Add(System.Diagnostics.Process.GetProcessById(handle.ProcessId)); 
    645645 
    646                     string lockedBy = null; 
    647                     if (processes.Count > 0) 
    648                     { 
    649                         StringBuilder processStr = new StringBuilder(); 
    650                         foreach (System.Diagnostics.Process process in processes) 
    651                             processStr.AppendFormat(System.Globalization.CultureInfo.InvariantCulture, 
    652                                 "{0}, ", process.MainModule.FileName); 
    653  
    654                         lockedBy = S._("(locked by {0})", processStr.ToString().Remove(processStr.Length - 2)); 
    655                     } 
    656  
    657                     task.Log.LastSessionEntries.Add(new LogEntry(S._( 
    658                             "Could not force closure of file \"{0}\" (locked by {1})", 
    659                             paths[i], processStr.ToString().Remove(processStr.Length - 2)), 
    660                         LogLevel.Error)); 
     646                        string lockedBy = null; 
     647                        if (processes.Count > 0) 
     648                        { 
     649                            StringBuilder processStr = new StringBuilder(); 
     650                            foreach (System.Diagnostics.Process process in processes) 
     651                            { 
     652                                try 
     653                                { 
     654                                    processStr.AppendFormat(System.Globalization.CultureInfo.InvariantCulture, 
     655                                        "{0}, ", process.MainModule.FileName); 
     656                                } 
     657                                catch (System.ComponentModel.Win32Exception) 
     658                                { 
     659                                } 
     660                            } 
     661 
     662                            lockedBy = S._("(locked by {0})", processStr.ToString().Remove(processStr.Length - 2)); 
     663                        } 
     664 
     665                        task.Log.LastSessionEntries.Add(new LogEntry(S._( 
     666                            "Could not force closure of file \"{0}\" {1}", paths[i], 
     667                            lockedBy == null ? string.Empty : lockedBy).Trim(), LogLevel.Error)); 
    661668                    } 
    662669                    else 
    … …  
    702709                        new ProgressChangedEventArgs(step, 
    703710                            new TaskProgressChangedEventArgs(info.FullName, 0, 0))); 
    704  
    705                     //See if this is the root of a volume. 
    706                     bool isVolumeRoot = info.Parent == null; 
    707                     foreach (VolumeInfo volume in VolumeInfo.Volumes) 
    708                         foreach (string mountPoint in volume.MountPoints) 
    709                             if (info.FullName == mountPoint) 
    710                                 isVolumeRoot = true; 
    711  
    712                     //If the folder is a mount point, then don't delete it. If it isn't, 
    713                     //search for files under the folder to see if it is empty. 
    714                     if (!isVolumeRoot && info.Exists && info.GetFiles("*", SearchOption.AllDirectories).Length == 0) 
    715                         fsManager.DeleteFolder(info); 
     711                    fsManager.DeleteFolder(info); 
    716712                } 
    717713            } 

  • branches/eraser6/CodeReview/Eraser.Manager/Strings.en.resx

    r1681 r1701  
    170170  </data> 
    171171  <data name="Could not force closure of file \&quot;{0}\&quot; {1}" xml:space="preserve"> 
    172     <value>Could not force closure of file \&quot;{0}\&quot; {1}</value> 
     172    <value>(Untranslated)</value> 
    173173  </data> 
    174174  <data name="Removing folders..." xml:space="preserve"> 
    … …  
    295295    <value>Unused disk space ({0})</value> 
    296296  </data> 
    297   <data name="Could not erase {0} because {1}" xml:space="preserve"> 
    298     <value>Could not erase {0} because {1}</value> 
     297  <data name="Could not erase files and subfolders in {0} because {1}" xml:space="preserve"> 
     298    <value>Could not erase files and subfolders in {0} because {1}</value> 
    299299  </data> 
    300300  <data name="Recycle Bin" xml:space="preserve"> 

  • branches/eraser6/CodeReview/Eraser.Manager/Strings.it.resx

    r1681 r1701  
    295295    <value>Spazio disco inutilizzato ({0})</value> 
    296296  </data> 
    297   <data name="Could not erase {0} because {1}" xml:space="preserve"> 
    298     <value>Impossibile pulire {0} a causa di {1}</value> 
     297  <data name="Could not erase files and subfolders in {0} because {1}" xml:space="preserve"> 
     298    <value>(Untranslated)</value> 
    299299  </data> 
    300300  <data name="Recycle Bin" xml:space="preserve"> 

  • branches/eraser6/CodeReview/Eraser.Manager/Strings.nl.resx

    r1681 r1701  
    295295    <value>(Untranslated)</value> 
    296296  </data> 
    297   <data name="Could not erase {0} because {1}" xml:space="preserve"> 
     297  <data name="Could not erase files and subfolders in {0} because {1}" xml:space="preserve"> 
    298298    <value>(Untranslated)</value> 
    299299  </data> 

  • branches/eraser6/CodeReview/Eraser.Manager/Strings.resx

    r1681 r1701  
    295295    <value>Unused disk space ({0})</value> 
    296296  </data> 
    297   <data name="Could not erase {0} because {1}" xml:space="preserve"> 
    298     <value>Could not erase {0} because {1}</value> 
     297  <data name="Could not erase files and subfolders in {0} because {1}" xml:space="preserve"> 
     298    <value>Could not erase files and subfolders in {0} because {1}</value> 
    299299  </data> 
    300300  <data name="Recycle Bin" xml:space="preserve"> 

  • branches/eraser6/CodeReview/Eraser.Manager/Task.cs

    r1681 r1701  
    508508        public override string UIText 
    509509        { 
    510             get { return System.IO.Path.GetFileName(Path); } 
     510            get 
     511            { 
     512                string fileName = System.IO.Path.GetFileName(Path); 
     513                string directoryName = System.IO.Path.GetDirectoryName(Path); 
     514                return string.IsNullOrEmpty(fileName) ?  
     515                        (string.IsNullOrEmpty(directoryName) ? Path : directoryName) 
     516                    : fileName; 
     517            } 
    511518        } 
    512519 

  • branches/eraser6/CodeReview/Eraser.Util/Eraser.Util.csproj

    r1618 r1701  
    104104    <Compile Include="ConsoleWindow.cs" /> 
    105105    <Compile Include="NativeMethods\DbgHelp.cs" /> 
     106    <Compile Include="NativeMethods\Mpr.cs" /> 
    106107    <Compile Include="PostDataBuilder.cs" /> 
    107108    <Compile Include="Power.cs" /> 

  • branches/eraser6/CodeReview/Eraser.Util/StreamInfo.cs

    r1681 r1701  
    138138                    { 
    139139                        case Win32ErrorCode.FileNotFound: 
    140                         case Win32ErrorCode.PathNotFound 
     140                        case Win32ErrorCode.PathNotFound: 
    141141                            return false; 
     142                        case Win32ErrorCode.AccessDenied: 
    142143                        case Win32ErrorCode.SharingViolation: 
    143144                            return true; 

  • branches/eraser6/CodeReview/Eraser.Util/VolumeInfo.cs

    r1681 r1701  
    3737        /// Constructor. 
    3838        /// </summary> 
    39         /// <param name="volumeId">The ID of the volume, in the form "\\?\Volume{GUID}\"</param> 
     39        /// <param name="volumeId">The ID of the volume, either in the form 
     40        /// "\\?\Volume{GUID}\" or as a valid UNC path.</param> 
    4041        public VolumeInfo(string volumeId) 
    4142        { 
    42             //Set the volume Id 
     43            //We only accept UNC paths as well as volume identifiers. 
     44            if (!(volumeId.StartsWith("\\\\?\\") || volumeId.StartsWith("\\\\"))) 
     45                throw new ArgumentException("The volumeId parameter only accepts volume GUID " + 
     46                    "and UNC paths", "volumeId"); 
     47 
     48            //Verify that the path ends with a trailing backslash 
     49            if (!volumeId.EndsWith("\\")) 
     50                throw new ArgumentException("The volumeId parameter must end with a trailing " + 
     51                    "backslash.", "volumeId"); 
     52 
     53            //Set the volume ID 
    4354            VolumeId = volumeId; 
     55 
     56            //Fill up the remaining members of the structure: file system, label, etc. 
     57            StringBuilder volumeName = new StringBuilder(NativeMethods.MaxPath * sizeof(char)), 
     58                fileSystemName = new StringBuilder(NativeMethods.MaxPath * sizeof(char)); 
     59            uint serialNumber, maxComponentLength, filesystemFlags; 
     60            if (!NativeMethods.GetVolumeInformation(volumeId, volumeName, NativeMethods.MaxPath, 
     61                out serialNumber, out maxComponentLength, out filesystemFlags, fileSystemName, 
     62                NativeMethods.MaxPath)) 
     63            { 
     64                int lastError = Marshal.GetLastWin32Error(); 
     65                switch (lastError) 
     66                { 
     67                    case Win32ErrorCode.Success: 
     68                    case Win32ErrorCode.NotReady: 
     69                    case Win32ErrorCode.InvalidParameter:   //when the volume given is not mounted. 
     70                    case Win32ErrorCode.UnrecognizedVolume: 
     71                        break; 
     72 
     73                    default: 
     74                        throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 
     75                } 
     76            } 
     77            else 
     78            { 
     79                IsReady = true; 
     80                VolumeLabel = volumeName.ToString(); 
     81                VolumeFormat = fileSystemName.ToString(); 
     82 
     83                //Determine whether it is FAT12 or FAT16 
     84                if (VolumeFormat == "FAT") 
     85                { 
     86                    uint clusterSize, sectorSize, freeClusters, totalClusters; 
     87                    if (NativeMethods.GetDiskFreeSpace(VolumeId, out clusterSize, 
     88                        out sectorSize, out freeClusters, out totalClusters)) 
     89                    { 
     90                        if (totalClusters <= 0xFF0) 
     91                            VolumeFormat += "12"; 
     92                        else 
     93                            VolumeFormat += "16"; 
     94                    } 
     95                } 
     96            } 
     97        } 
     98 
     99        /// <summary> 
     100        /// Gets the mountpoints associated with the current volume. 
     101        /// </summary> 
     102        /// <returns>A list of volume mount points for the current volume.</returns> 
     103        private List<string> GetLocalVolumeMountPoints() 
     104        { 
     105            List<string> result = new List<string>(); 
    44106 
    45107            //Get the paths of the said volume 
    … …  
    81143                        break; 
    82144 
    83                     mountPoints.Add(pathNames.Substring(lastIndex, i - lastIndex)); 
     145                    result.Add(pathNames.Substring(lastIndex, i - lastIndex)); 
    84146 
    85147                    lastIndex = i + 1; 
    … …  
    89151            } 
    90152 
    91             //Fill up the remaining members of the structure: file system, label, etc. 
    92             StringBuilder volumeName = new StringBuilder(NativeMethods.MaxPath * sizeof(char)), 
    93                 fileSystemName = new StringBuilder(NativeMethods.MaxPath * sizeof(char)); 
    94             uint serialNumber, maxComponentLength, filesystemFlags; 
    95             if (!NativeMethods.GetVolumeInformation(volumeId, volumeName, NativeMethods.MaxPath, 
    96                 out serialNumber, out maxComponentLength, out filesystemFlags, fileSystemName, 
    97                 NativeMethods.MaxPath)) 
    98             { 
    99                 int lastError = Marshal.GetLastWin32Error(); 
    100                 switch (lastError) 
    101                 { 
    102                     case Win32ErrorCode.Success: 
    103                     case Win32ErrorCode.NotReady: 
    104                     case Win32ErrorCode.InvalidParameter:   //when the volume given is not mounted. 
    105                     case Win32ErrorCode.UnrecognizedVolume: 
    106                         break; 
    107  
    108                     default: 
    109                         throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 
    110                 } 
    111             } 
    112             else 
    113             { 
    114                 IsReady = true; 
    115                 VolumeLabel = volumeName.ToString(); 
    116                 VolumeFormat = fileSystemName.ToString(); 
    117  
    118                 //Determine whether it is FAT12 or FAT16 
    119                 if (VolumeFormat == "FAT") 
    120                 { 
    121                     uint clusterSize, sectorSize, freeClusters, totalClusters; 
    122                     if (NativeMethods.GetDiskFreeSpace(VolumeId, out clusterSize, 
    123                         out sectorSize, out freeClusters, out totalClusters)) 
     153            return result; 
     154        } 
     155 
     156        /// <summary> 
     157        /// Gets the mountpoints associated with the network share. 
     158        /// </summary> 
     159        /// <returns>A list of network mount points for the given network share.</returns> 
     160        private List<string> GetNetworkMountPoints() 
     161        { 
     162            List<string> result = new List<string>(); 
     163 
     164            //Open an enumeration handle to list mount points. 
     165            IntPtr enumHandle; 
     166            uint errorCode = NativeMethods.WNetOpenEnum(NativeMethods.RESOURCE_CONNECTED, 
     167                NativeMethods.RESOURCETYPE_DISK, 0, IntPtr.Zero, out enumHandle); 
     168            if (errorCode != Win32ErrorCode.Success) 
     169                throw new Win32Exception((int)errorCode); 
     170 
     171            try 
     172            { 
     173                int resultBufferCount = 32; 
     174                int resultBufferSize = resultBufferCount * 
     175                    Marshal.SizeOf(typeof(NativeMethods.NETRESOURCE)); 
     176                IntPtr resultBuffer = Marshal.AllocHGlobal(resultBufferSize); 
     177 
     178                try 
     179                { 
     180                    for ( ; ; ) 
    124181                    { 
    125                         if (totalClusters <= 0xFF0) 
    126                             VolumeFormat += "12"; 
    127                         else 
    128                             VolumeFormat += "16"; 
     182                        uint resultBufferStored = (uint)resultBufferCount; 
     183                        uint resultBufferRequiredSize = (uint)resultBufferSize; 
     184                        errorCode = NativeMethods.WNetEnumResource(enumHandle, 
     185                            ref resultBufferStored, resultBuffer, 
     186                            ref resultBufferRequiredSize); 
     187 
     188                        if (errorCode == Win32ErrorCode.NoMoreItems) 
     189                            break; 
     190                        else if (errorCode != Win32ErrorCode.Success) 
     191                            throw new Win32Exception((int)errorCode); 
     192 
     193                        unsafe 
     194                        { 
     195                            //Marshal the memory block to managed structures. 
     196                            byte* pointer = (byte*)resultBuffer.ToPointer(); 
     197 
     198                            for (uint i = 0; i < resultBufferStored; 
     199                                ++i, pointer += Marshal.SizeOf(typeof(NativeMethods.NETRESOURCE))) 
     200                            { 
     201                                NativeMethods.NETRESOURCE resource = 
     202                                    (NativeMethods.NETRESOURCE)Marshal.PtrToStructure( 
     203                                        (IntPtr)pointer, typeof(NativeMethods.NETRESOURCE)); 
     204 
     205                                //Ensure that the path in the resource structure ends with a trailing 
     206                                //backslash as out volume ID ends with one. 
     207                                if (string.IsNullOrEmpty(resource.lpRemoteName)) 
     208                                    continue; 
     209                                if (resource.lpRemoteName[resource.lpRemoteName.Length - 1] != '\\') 
     210                                    resource.lpRemoteName += '\\'; 
     211 
     212                                if (resource.lpRemoteName == VolumeId) 
     213                                    result.Add(resource.lpLocalName); 
     214                            } 
     215                        } 
    129216                    } 
    130217                } 
    131             } 
     218                finally 
     219                { 
     220                    Marshal.FreeHGlobal(resultBuffer); 
     221                } 
     222            } 
     223            finally 
     224            { 
     225                NativeMethods.WNetCloseEnum(enumHandle); 
     226            } 
     227 
     228            return result; 
    132229        } 
    133230 
    … …  
    172269        public static VolumeInfo FromMountPoint(string mountPoint) 
    173270        { 
     271            //Verify that the mountpoint given exists; if it doesn't we'll raise 
     272            //a DirectoryNotFound exception. 
    174273            DirectoryInfo mountpointDir = new DirectoryInfo(mountPoint); 
    175             StringBuilder volumeID = new StringBuilder(50 * sizeof(char)); 
    176  
    177             //Verify that the mountpoint given exists; if it doesn't we'll raise 
    178             //a PathNotFound exception. 
    179274            if (!mountpointDir.Exists) 
    180275                throw new DirectoryNotFoundException(); 
    … …  
    182277            do 
    183278            { 
     279                //Ensure that the current path has a trailing backslash 
    184280                string currentDir = mountpointDir.FullName; 
    185281                if (currentDir.Length > 0 && currentDir[currentDir.Length - 1] != '\\') 
    186282                    currentDir += '\\'; 
    187                 if (!NativeMethods.GetVolumeNameForVolumeMountPoint(currentDir, volumeID, 50)) 
    188                 { 
    189                     int errorCode = Marshal.GetLastWin32Error(); 
     283 
     284                //The path cannot be empty. 
     285                if (string.IsNullOrEmpty(currentDir)) 
     286                    throw new DirectoryNotFoundException(); 
     287 
     288                //Get the type of the drive 
     289                DriveType driveType = (DriveType)NativeMethods.GetDriveType(currentDir); 
     290 
     291                //We do different things for different kinds of drives. Network drives 
     292                //will need us to resolve the drive to a UNC path. Local drives will 
     293                //be resolved to a volume GUID 
     294                StringBuilder volumeID = new StringBuilder(NativeMethods.MaxPath); 
     295                if (driveType == DriveType.Network) 
     296                { 
     297                    //Resolve the mountpoint to a UNC path 
     298                    uint bufferCapacity = (uint)volumeID.Capacity; 
     299                    uint errorCode = NativeMethods.WNetGetConnection( 
     300                        currentDir.Substring(0, currentDir.Length - 1), 
     301                        volumeID, ref bufferCapacity); 
    190302 
    191303                    switch (errorCode) 
    192304                    { 
    193                         case Win32ErrorCode.InvalidFunction: 
    194                         case Win32ErrorCode.FileNotFound: 
    195                         case Win32ErrorCode.PathNotFound: 
    196                         case Win32ErrorCode.NotAReparsePoint: 
     305                        case Win32ErrorCode.Success: 
     306                            return new VolumeInfo(volumeID.ToString() + '\\'); 
     307 
     308                        case Win32ErrorCode.BadDevice: //Path is not a network share 
    197309                            break; 
     310 
    198311                        default: 
    199                             throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 
     312                            throw new Win32Exception((int)errorCode); 
    200313                    } 
    201314                } 
    202315                else 
    203316                { 
    204                     return new VolumeInfo(volumeID.ToString()); 
     317                    if (!NativeMethods.GetVolumeNameForVolumeMountPoint(currentDir, volumeID, 50)) 
     318                    { 
     319                        int errorCode = Marshal.GetLastWin32Error(); 
     320                        switch (errorCode) 
     321                        { 
     322                            case Win32ErrorCode.InvalidFunction: 
     323                            case Win32ErrorCode.FileNotFound: 
     324                            case Win32ErrorCode.PathNotFound: 
     325                            case Win32ErrorCode.NotAReparsePoint: 
     326                                break; 
     327                            default: 
     328                                throw Marshal.GetExceptionForHR(Marshal.GetHRForLastWin32Error()); 
     329                        } 
     330                    } 
     331                    else 
     332                    { 
     333                        return new VolumeInfo(volumeID.ToString()); 
     334                    } 
    205335                } 
    206336 
    … …  
    397527            get 
    398528            { 
    399                 return mountPoints.AsReadOnly(); 
     529                return (VolumeType == DriveType.Network ? 
     530                    GetNetworkMountPoints() : GetLocalVolumeMountPoints()).AsReadOnly(); 
    400531            } 
    401532        } 
    … …  
    538669            return new VolumeLock(stream); 
    539670        } 
    540  
    541         private List<string> mountPoints = new List<string>(); 
    542671    } 
    543672 

  • branches/eraser6/CodeReview/Eraser.Util/Win32ErrorCodes.cs

    r1576 r1701  
    7171        public const int InvalidParameter = 87; 
    7272        public const int MoreData = 234; 
     73        public const int NoMoreItems = 259; 
    7374        public const int UnrecognizedVolume = 1005; 
     75        public const int BadDevice = 1200; 
    7476        public const int NotAReparsePoint = 4390; 
    7577    } 

  • branches/eraser6/CodeReview/Eraser/SchedulerPanel.Designer.cs

    r1681 r1701  
    7878            this.titleLabel.AccessibleName = null; 
    7979            resources.ApplyResources(this.titleLabel, "titleLabel"); 
    80             this.titleLabel.Font = null; 
    8180            //  
    8281            // titleIcon 

  • branches/eraser6/CodeReview/Eraser/SchedulerPanel.cs

    r1681 r1701  
    652652 
    653653            Rectangle rect = ((ListViewItem)schedulerProgress.Tag).SubItems[2].Bounds; 
     654            rect.Offset(2, 2); 
    654655            schedulerProgress.Location = rect.Location; 
    655656            schedulerProgress.Size = rect.Size; 

  • branches/eraser6/CodeReview/Eraser/UpdateForm.cs

    r1681 r1701  
    733733 
    734734                        //Let the event handler know the download is complete. 
    735                         step.Completed = step.Total; 
     735                        step.MarkComplete(); 
    736736                        OnProgress(new ProgressEventArgs(step.Progress, progress.Progress, 
    737737                            update, S._("Downloaded: {0}", update.Name))); 
Note: See TracChangeset for help on using the changeset viewer.