Changeset 1566


Ignore:
Timestamp:
1/18/2010 6:41:13 AM (5 years ago)
Author:
lowjoel
Message:

Moved KernelApi?.GetHRForWin32Error and GetExceptionForWin32Error to the Win32ErrorCode class

Location:
branches/eraser6/CodeReview
Files:
9 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/CodeReview/Eraser.DefaultPlugins/FileSystems/Windows.cs

    r1551 r1566  
    9393                catch (IOException e) 
    9494                { 
    95                     switch ((Win32ErrorCodes)System.Runtime.InteropServices.Marshal.GetLastWin32Error()) 
     95                    switch (System.Runtime.InteropServices.Marshal.GetLastWin32Error()) 
    9696                    { 
    97                         case Win32ErrorCodes.AccessDenied: 
     97                        case Win32ErrorCode.AccessDenied: 
    9898                            throw new UnauthorizedAccessException(S._("The file {0} could not " + 
    9999                                "be erased because the file's permissions prevent access to the file.", 
    100100                                info.FullName)); 
    101101 
    102                         case Win32ErrorCodes.SharingViolation: 
     102                        case Win32ErrorCode.SharingViolation: 
    103103                            //If after FilenameEraseTries the file is still locked, some program is 
    104104                            //definitely using the file; throw an exception. 
     
    126126                catch (IOException e) 
    127127                { 
    128                     switch ((Win32ErrorCodes)System.Runtime.InteropServices.Marshal.GetLastWin32Error()) 
     128                    switch (System.Runtime.InteropServices.Marshal.GetLastWin32Error()) 
    129129                    { 
    130                         case Win32ErrorCodes.AccessDenied: 
     130                        case Win32ErrorCode.AccessDenied: 
    131131                            throw new UnauthorizedAccessException(S._("The file {0} could not " + 
    132132                                "be erased because the file's permissions prevent access to the file.", 
    133133                                info.FullName), e); 
    134134 
    135                         case Win32ErrorCodes.SharingViolation: 
     135                        case Win32ErrorCode.SharingViolation: 
    136136                            //If after FilenameEraseTries the file is still locked, some program is 
    137137                            //definitely using the file; throw an exception. 
  • branches/eraser6/CodeReview/Eraser.Manager/EntropySource.cs

    r1553 r1566  
    344344                catch (System.ComponentModel.Win32Exception e) 
    345345                { 
    346                     if (e.NativeErrorCode != (int)Win32ErrorCodes.AccessDenied) 
     346                    if (e.NativeErrorCode != Win32ErrorCode.AccessDenied) 
    347347                        throw; 
    348348                } 
     
    437437                    (uint)infoBuffer.Length, out dataWritten); 
    438438 
    439                 if (sysInfo == (int)Win32ErrorCodes.Success && dataWritten > 0) 
     439                if (sysInfo == Win32ErrorCode.Success && dataWritten > 0) 
    440440                { 
    441441                    byte[] entropy = new byte[dataWritten]; 
  • branches/eraser6/CodeReview/Eraser.Util/File.cs

    r1564 r1566  
    330330                out modifiedTimeNative)) 
    331331            { 
    332                 throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     332                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    333333            } 
    334334 
     
    351351                out accessedTimeNative, out modifiedTimeNative)) 
    352352            { 
    353                 throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     353                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    354354            } 
    355355 
     
    364364                ref accessedTimeNative, ref modifiedTimeNative)) 
    365365            { 
    366                 throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     366                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    367367            } 
    368368        } 
  • branches/eraser6/CodeReview/Eraser.Util/KernelApi.cs

    r1562 r1566  
    8686        { 
    8787            return NativeMethods.FreeConsole(); 
    88         } 
    89  
    90         /// <summary> 
    91         /// Converts a Win32 Error code to a HRESULT. 
    92         /// </summary> 
    93         /// <param name="errorCode">The error code to convert.</param> 
    94         /// <returns>A HRESULT value representing the error code.</returns> 
    95         internal static int GetHRForWin32Error(int errorCode) 
    96         { 
    97             const uint FACILITY_WIN32 = 7; 
    98             return errorCode <= 0 ? errorCode : 
    99                 (int)((((uint)errorCode) & 0x0000FFFF) | (FACILITY_WIN32 << 16) | 0x80000000); 
    100         } 
    101  
    102         /// <summary> 
    103         /// Gets a Exception for the given Win32 error code. 
    104         /// </summary> 
    105         /// <param name="errorCode">The error code.</param> 
    106         /// <returns>An exception object representing the error code.</returns> 
    107         internal static Exception GetExceptionForWin32Error(int errorCode) 
    108         { 
    109             int HR = GetHRForWin32Error(errorCode); 
    110             return Marshal.GetExceptionForHR(HR); 
    11188        } 
    11289 
  • branches/eraser6/CodeReview/Eraser.Util/Security.cs

    r1554 r1566  
    6464                NativeMethods.TOKEN_QUERY, out hToken); 
    6565            if (!result || hToken.IsInvalid) 
    66                 throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     66                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    6767 
    6868            IntPtr pElevationType = Marshal.AllocHGlobal(Marshal.SizeOf( 
     
    7979                //Check the return code 
    8080                if (!result) 
    81                     throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     81                    throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    8282 
    8383                NativeMethods.TOKEN_ELEVATION_TYPE elevationType = 
  • branches/eraser6/CodeReview/Eraser.Util/StreamInfo.cs

    r1551 r1566  
    133133                    if (!handle.IsInvalid) 
    134134                        return true; 
    135                     else if (Marshal.GetLastWin32Error() == (int)Win32ErrorCodes.FileNotFound) 
     135                    else if (Marshal.GetLastWin32Error() == Win32ErrorCode.FileNotFound) 
    136136                        return false; 
    137137 
    138                     throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     138                    throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    139139                } 
    140140            } 
     
    239239            try 
    240240            { 
    241                 KernelApi.GetFileTime(handle, out creationTime, out lastAccess, out lastWrite); 
     241                Util.File.GetFileTime(handle, out creationTime, out lastAccess, out lastWrite); 
    242242            } 
    243243            finally 
     
    268268            try 
    269269            { 
    270                 KernelApi.SetFileTime(handle, creationTime, lastAccess, lastWrite); 
     270                Util.File.SetFileTime(handle, creationTime, lastAccess, lastWrite); 
    271271            } 
    272272            finally 
     
    286286            else 
    287287                if (!NativeMethods.DeleteFile(FullName)) 
    288                     throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     288                    throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    289289        } 
    290290 
     
    389389                (uint)share, IntPtr.Zero, (uint)mode, (uint)options, IntPtr.Zero); 
    390390            if (result.IsInvalid) 
    391                 throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     391                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    392392 
    393393            //Cache the handle if we have an exclusive handle - this is used for things like 
  • branches/eraser6/CodeReview/Eraser.Util/VolumeInfo.cs

    r1551 r1566  
    5252                    pathNamesBuffer, (uint)pathNamesBuffer.Capacity, out returnLength)) 
    5353                { 
    54                     if (Marshal.GetLastWin32Error() == (int)Win32ErrorCodes.MoreData) 
     54                    if (Marshal.GetLastWin32Error() == Win32ErrorCode.MoreData) 
    5555                        pathNamesBuffer.EnsureCapacity((int)returnLength); 
    5656                    else 
     
    9393            { 
    9494                int lastError = Marshal.GetLastWin32Error(); 
    95                 switch ((Win32ErrorCodes)lastError) 
    96                 { 
    97                     case Win32ErrorCodes.Success: 
    98                     case Win32ErrorCodes.NotReady: 
    99                     case Win32ErrorCodes.InvalidParameter:  //when the volume given is not mounted. 
    100                     case Win32ErrorCodes.UnrecognizedVolume: 
     95                switch (lastError) 
     96                { 
     97                    case Win32ErrorCode.Success: 
     98                    case Win32ErrorCode.NotReady: 
     99                    case Win32ErrorCode.InvalidParameter:   //when the volume given is not mounted. 
     100                    case Win32ErrorCode.UnrecognizedVolume: 
    101101                        break; 
    102102 
     
    148148 
    149149                //Close the handle 
    150                 if (Marshal.GetLastWin32Error() == (int)Win32ErrorCodes.NoMoreFiles) 
     150                if (Marshal.GetLastWin32Error() == Win32ErrorCode.NoMoreFiles) 
    151151                    NativeMethods.FindVolumeClose(handle); 
    152152 
     
    177177                else 
    178178                { 
    179                     switch ((Win32ErrorCodes)Marshal.GetLastWin32Error()) 
     179                    switch (Marshal.GetLastWin32Error()) 
    180180                    { 
    181                         case Win32ErrorCodes.InvalidFunction: 
    182                         case Win32ErrorCodes.FileNotFound: 
    183                         case Win32ErrorCodes.PathNotFound: 
    184                         case Win32ErrorCodes.NotAReparsePoint: 
     181                        case Win32ErrorCode.InvalidFunction: 
     182                        case Win32ErrorCode.FileNotFound: 
     183                        case Win32ErrorCode.PathNotFound: 
     184                        case Win32ErrorCode.NotAReparsePoint: 
    185185                            break; 
    186186                        default: 
     
    193193            while (mountpointDir != null); 
    194194 
    195             throw Marshal.GetExceptionForHR(KernelApi.GetHRForWin32Error( 
    196                 (int)Win32ErrorCodes.NotAReparsePoint)); 
     195            throw Win32ErrorCode.GetExceptionForWin32Error(Win32ErrorCode.NotAReparsePoint); 
    197196        } 
    198197 
     
    272271                    return totalNumberOfFreeBytes != freeBytesAvailable; 
    273272                } 
    274                 else if (Marshal.GetLastWin32Error() == (int)Win32ErrorCodes.NotReady) 
     273                else if (Marshal.GetLastWin32Error() == Win32ErrorCode.NotReady) 
    275274                { 
    276275                    //For the lack of more appropriate responses. 
     
    362361 
    363362                //Close the handle 
    364                 if (Marshal.GetLastWin32Error() == (int)Win32ErrorCodes.NoMoreFiles) 
     363                if (Marshal.GetLastWin32Error() == Win32ErrorCode.NoMoreFiles) 
    365364                    NativeMethods.FindVolumeMountPointClose(handle); 
    366365 
     
    475474                (uint)share, IntPtr.Zero, (uint)FileMode.Open, (uint)options, IntPtr.Zero); 
    476475            if (result.IsInvalid) 
    477                 throw KernelApi.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
     476                throw Win32ErrorCode.GetExceptionForWin32Error(Marshal.GetLastWin32Error()); 
    478477 
    479478            return result; 
  • branches/eraser6/CodeReview/Eraser.Util/Win32ErrorCodes.cs

    r1551 r1566  
    2222using System; 
    2323using System.Collections.Generic; 
    24 using System.Linq; 
    2524using System.Text; 
     25using System.Runtime.InteropServices; 
    2626 
    2727namespace Eraser.Util 
    2828{ 
    29     public enum Win32ErrorCodes 
     29    public static class Win32ErrorCode 
    3030    { 
    31         NoError = Success, 
    32         Success = 0, 
    33         InvalidFunction = 1, 
    34         FileNotFound = 2, 
    35         PathNotFound = 3, 
    36         AccessDenied = 5, 
    37         NoMoreFiles = 18, 
    38         NotReady = 21, 
    39         SharingViolation = 32, 
    40         InvalidParameter = 87, 
    41         MoreData = 234, 
    42         UnrecognizedVolume = 1005, 
    43         NotAReparsePoint = 4390 
     31        /// <summary> 
     32        /// Converts a Win32 Error code to a HRESULT. 
     33        /// </summary> 
     34        /// <param name="errorCode">The error code to convert.</param> 
     35        /// <returns>A HRESULT value representing the error code.</returns> 
     36        internal static int GetHRForWin32Error(int errorCode) 
     37        { 
     38            const uint FACILITY_WIN32 = 7; 
     39            return errorCode <= 0 ? errorCode : 
     40                (int)((((uint)errorCode) & 0x0000FFFF) | (FACILITY_WIN32 << 16) | 0x80000000); 
     41        } 
     42 
     43        /// <summary> 
     44        /// Gets a Exception for the given Win32 error code. 
     45        /// </summary> 
     46        /// <param name="errorCode">The error code.</param> 
     47        /// <returns>An exception object representing the error code.</returns> 
     48        internal static Exception GetExceptionForWin32Error(int errorCode) 
     49        { 
     50            int HR = GetHRForWin32Error(errorCode); 
     51            return Marshal.GetExceptionForHR(HR); 
     52        } 
     53 
     54        public const int NoError = Success; 
     55        public const int Success = 0; 
     56        public const int InvalidFunction = 1; 
     57        public const int FileNotFound = 2; 
     58        public const int PathNotFound = 3; 
     59        public const int AccessDenied = 5; 
     60        public const int NoMoreFiles = 18; 
     61        public const int NotReady = 21; 
     62        public const int SharingViolation = 32; 
     63        public const int InvalidParameter = 87; 
     64        public const int MoreData = 234; 
     65        public const int UnrecognizedVolume = 1005; 
     66        public const int NotAReparsePoint = 4390; 
    4467    } 
    4568} 
  • branches/eraser6/CodeReview/Eraser/Program.cs

    r1551 r1566  
    157157                catch (UnauthorizedAccessException) 
    158158                { 
    159                     return (int)Win32ErrorCodes.AccessDenied; 
     159                    return Win32ErrorCode.AccessDenied; 
    160160                } 
    161161                catch (Win32Exception e) 
Note: See TracChangeset for help on using the changeset viewer.