Changeset 408


Ignore:
Timestamp:
9/27/2008 6:24:37 AM (6 years ago)
Author:
lowjoel
Message:

Silly me. I could have just used StringBuilders? for those functions parameters where strings are passed out through a buffer.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/Util/Drive.cs

    r407 r408  
    8888 
    8989            //Fill up the remaining members of the structure: file system, label, etc. 
    90             IntPtr volumeName = Marshal.AllocHGlobal(MaxPath * sizeof(char)), 
    91                    fileSystemName = Marshal.AllocHGlobal(MaxPath * sizeof(char)); 
    92             try 
    93             { 
    94                 uint serialNumber, maxComponentLength, filesystemFlags; 
    95                 if (!GetVolumeInformation(volumeID, volumeName, MaxPath, out serialNumber, 
    96                     out maxComponentLength, out filesystemFlags, fileSystemName, MaxPath)) 
    97                 { 
    98                     if (Marshal.GetLastWin32Error() != 21 /*ERROR_NOT_READY*/) 
    99                         throw new Win32Exception(Marshal.GetLastWin32Error(), "Eraser.Util.Volume.Volume"); 
    100                 } 
    101                 else 
    102                 { 
    103                     //OK, the volume information's queried, store what we know. 
    104                     driveFormat = Marshal.PtrToStringUni(fileSystemName); 
    105                     volumeLabel = Marshal.PtrToStringUni(volumeName); 
    106                     isReady = true; 
    107                 } 
    108             } 
    109             finally 
    110             { 
    111                 Marshal.FreeHGlobal(volumeName); 
    112                 Marshal.FreeHGlobal(fileSystemName); 
    113             } 
     90            StringBuilder volumeName = new StringBuilder(MaxPath * sizeof(char)), 
     91                   fileSystemName = new StringBuilder(MaxPath * sizeof(char)); 
     92            uint serialNumber, maxComponentLength, filesystemFlags; 
     93            if (!GetVolumeInformation(volumeID, volumeName, MaxPath, out serialNumber, 
     94                out maxComponentLength, out filesystemFlags, fileSystemName, MaxPath)) 
     95            { 
     96                if (Marshal.GetLastWin32Error() != 21 /*ERROR_NOT_READY*/) 
     97                    throw new Win32Exception(Marshal.GetLastWin32Error(), "Eraser.Util.Volume.Volume"); 
     98            } 
     99            else 
     100                isReady = true; 
     101 
     102            volumeLabel = volumeName.ToString(); 
     103            volumeFormat = fileSystemName.ToString(); 
    114104        } 
    115105 
     
    122112        { 
    123113            List<Volume> result = new List<Volume>(); 
    124             IntPtr nextVolume = Marshal.AllocHGlobal(LongPath * sizeof(char)); 
    125             try 
    126             { 
    127                 SafeHandle handle = FindFirstVolume(nextVolume, LongPath); 
    128                 if (handle.IsInvalid) 
    129                     return result; 
    130  
    131                 //Iterate over the volume mountpoints 
    132                 do 
    133                     result.Add(new Volume(Marshal.PtrToStringUni(nextVolume))); 
    134                 while (FindNextVolume(handle, nextVolume, LongPath)); 
    135  
    136                 //Close the handle 
    137                 if (Marshal.GetLastWin32Error() == 18 /*ERROR_NO_MORE_FILES*/) 
    138                     FindVolumeClose(handle); 
    139                  
     114            StringBuilder nextVolume = new StringBuilder(LongPath * sizeof(char)); 
     115            SafeHandle handle = FindFirstVolume(nextVolume, LongPath); 
     116            if (handle.IsInvalid) 
    140117                return result; 
    141             } 
    142             finally 
    143             { 
    144                 Marshal.FreeHGlobal(nextVolume); 
    145             } 
     118 
     119            //Iterate over the volume mountpoints 
     120            do 
     121                result.Add(new Volume(nextVolume.ToString())); 
     122            while (FindNextVolume(handle, nextVolume, LongPath)); 
     123 
     124            //Close the handle 
     125            if (Marshal.GetLastWin32Error() == 18 /*ERROR_NO_MORE_FILES*/) 
     126                FindVolumeClose(handle); 
     127             
     128            return result; 
    146129        } 
    147130 
     
    155138        { 
    156139            DirectoryInfo mountpointDir = new DirectoryInfo(mountpoint); 
    157             IntPtr volumeID = Marshal.AllocHGlobal(50 * sizeof(char)); 
    158             try 
    159             { 
    160                 do 
    161                 { 
    162                     string currentDir = mountpointDir.FullName; 
    163                     if (currentDir.Length > 0 && currentDir[currentDir.Length - 1] != '\\') 
    164                         currentDir += '\\'; 
    165                     if (GetVolumeNameForVolumeMountPoint(currentDir, volumeID, 50)) 
    166                         return new Volume(Marshal.PtrToStringUni(volumeID)); 
    167                     else if (Marshal.GetLastWin32Error() != 4390 /*ERROR_NOT_A_REPARSE_POINT*/) 
    168                         throw new Win32Exception(Marshal.GetLastWin32Error()); 
    169                     mountpointDir = mountpointDir.Parent; 
    170                 } 
    171                 while (mountpointDir != null); 
    172  
    173                 throw new Win32Exception(4390 /*ERROR_NOT_A_REPARSE_POINT*/); 
    174             } 
    175             finally 
    176             { 
    177                 Marshal.FreeHGlobal(volumeID); 
    178             } 
     140            StringBuilder volumeID = new StringBuilder(50 * sizeof(char)); 
     141 
     142            do 
     143            { 
     144                string currentDir = mountpointDir.FullName; 
     145                if (currentDir.Length > 0 && currentDir[currentDir.Length - 1] != '\\') 
     146                    currentDir += '\\'; 
     147                if (GetVolumeNameForVolumeMountPoint(currentDir, volumeID, 50)) 
     148                    return new Volume(volumeID.ToString()); 
     149                else if (Marshal.GetLastWin32Error() != 4390 /*ERROR_NOT_A_REPARSE_POINT*/) 
     150                    throw new Win32Exception(Marshal.GetLastWin32Error()); 
     151                mountpointDir = mountpointDir.Parent; 
     152            } 
     153            while (mountpointDir != null); 
     154 
     155            throw new Win32Exception(4390 /*ERROR_NOT_A_REPARSE_POINT*/); 
    179156        } 
    180157 
     
    205182            get 
    206183            { 
    207                 return driveFormat; 
    208             } 
    209         } 
    210         private string driveFormat; 
     184                return volumeFormat; 
     185            } 
     186        } 
     187        private string volumeFormat; 
    211188 
    212189        /// <summary> 
     
    321298            { 
    322299                List<Volume> result = new List<Volume>(); 
    323                 IntPtr nextMountpoint = Marshal.AllocHGlobal(LongPath * sizeof(char)); 
    324                 try 
    325                 { 
    326                     SafeHandle handle = FindFirstVolumeMountPoint(VolumeID, 
    327                         nextMountpoint, LongPath); 
    328                     if (handle.IsInvalid) 
    329                         return result; 
    330  
    331                     //Iterate over the volume mountpoints 
    332                     while (FindNextVolumeMountPoint(handle, nextMountpoint, LongPath)) 
    333                         result.Add(new Volume(Marshal.PtrToStringUni(nextMountpoint))); 
    334  
    335                     //Close the handle 
    336                     if (Marshal.GetLastWin32Error() == 18 /*ERROR_NO_MORE_FILES*/) 
    337                         FindVolumeMountPointClose(handle); 
    338  
     300                StringBuilder nextMountpoint = new StringBuilder(LongPath * sizeof(char)); 
     301 
     302                SafeHandle handle = FindFirstVolumeMountPoint(VolumeID, 
     303                    nextMountpoint, LongPath); 
     304                if (handle.IsInvalid) 
    339305                    return result; 
    340                 } 
    341                 finally 
    342                 { 
    343                     Marshal.FreeHGlobal(nextMountpoint); 
    344                 } 
     306 
     307                //Iterate over the volume mountpoints 
     308                while (FindNextVolumeMountPoint(handle, nextMountpoint, LongPath)) 
     309                    result.Add(new Volume(nextMountpoint.ToString())); 
     310 
     311                //Close the handle 
     312                if (Marshal.GetLastWin32Error() == 18 /*ERROR_NO_MORE_FILES*/) 
     313                    FindVolumeMountPointClose(handle); 
     314 
     315                return result; 
    345316            } 
    346317        } 
     
    435406        internal static extern bool GetVolumeInformation( 
    436407            string lpRootPathName, 
    437             IntPtr lpVolumeNameBuffer, 
     408            StringBuilder lpVolumeNameBuffer, 
    438409            uint nVolumeNameSize, 
    439410            out uint lpVolumeSerialNumber, 
    440411            out uint lpMaximumComponentLength, 
    441412            out uint lpFileSystemFlags, 
    442             IntPtr lpFileSystemNameBuffer, 
     413            StringBuilder lpFileSystemNameBuffer, 
    443414            uint nFileSystemNameSize); 
    444415 
     
    553524        /// call GetLastError.</returns> 
    554525        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] 
    555         internal static extern SafeFileHandle FindFirstVolume( 
    556             IntPtr lpszVolumeName, 
     526        internal static extern SafeFileHandle FindFirstVolume(StringBuilder lpszVolumeName, 
    557527            uint cchBufferLength); 
    558528 
     
    576546        [return: MarshalAs(UnmanagedType.Bool)] 
    577547        internal static extern bool FindNextVolume(SafeHandle hFindVolume, 
    578             IntPtr lpszVolumeName, uint cchBufferLength); 
     548            StringBuilder lpszVolumeName, uint cchBufferLength); 
    579549 
    580550        /// <summary> 
     
    612582        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] 
    613583        internal static extern SafeFileHandle FindFirstVolumeMountPoint( 
    614             string lpszRootPathName, 
    615             IntPtr lpszVolumeMountPoint, 
     584            string lpszRootPathName, StringBuilder lpszVolumeMountPoint, 
    616585            uint cchBufferLength); 
    617586 
     
    635604        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] 
    636605        [return: MarshalAs(UnmanagedType.Bool)] 
    637         internal static extern bool FindNextVolumeMountPoint(SafeHandle hFindVolumeMountPoint, 
    638             IntPtr lpszVolumeMountPoint, 
     606        internal static extern bool FindNextVolumeMountPoint( 
     607            SafeHandle hFindVolumeMountPoint, StringBuilder lpszVolumeMountPoint, 
    639608            uint cchBufferLength); 
    640609 
     
    674643        [return: MarshalAs(UnmanagedType.Bool)] 
    675644        internal static extern bool GetVolumeNameForVolumeMountPoint( 
    676             string lpszVolumeMountPoint, 
    677             IntPtr lpszVolumeName, 
     645            string lpszVolumeMountPoint, StringBuilder lpszVolumeName, 
    678646            uint cchBufferLength); 
    679647 
     
    696664        [DllImport("Kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)] 
    697665        internal static extern bool GetVolumePathNamesForVolumeName( 
    698             string lpszVolumeName, 
    699             IntPtr lpszVolumePathNames, 
    700             uint cchBufferLength, 
     666            string lpszVolumeName, IntPtr lpszVolumePathNames, uint cchBufferLength, 
    701667            out uint lpcchReturnLength); 
    702668 
Note: See TracChangeset for help on using the changeset viewer.