We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ Microsoft.Win32 \ SECURITY_ATTRIBUTES

SSCLI
  1. // ==++==
  2. //
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. //
  14. // ==--==
  15. /*============================================================
  16. **
  17. ** Class:  Microsoft.Win32.Win32Native
  18. **
  19. **
  20. ** Purpose: The CLR wrapper for all Win32 (Win2000, NT4, Win9x,
  21. **          as well as ROTOR-style Unix PAL, etc.) native operations
  22. **
  23. **
  24. ===========================================================*/
  25. /**
  26. * Notes to PInvoke users:  Getting the syntax exactly correct is crucial, and
  27. * more than a little confusing.  Here's some guidelines.
  28. *
  29. * For handles, you should use a SafeHandle subclass specific to your handle
  30. * type.  For files, we have the following set of interesting definitions:
  31. *
  32. *  [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
  33. *  private static extern SafeFileHandle CreateFile(...);
  34. *
  35. *  [DllImport(KERNEL32, SetLastError=true)]
  36. *  unsafe internal static extern int ReadFile(SafeFileHandle handle, ...);
  37. *
  38. *  [DllImport(KERNEL32, SetLastError=true)]
  39. *  internal static extern bool CloseHandle(IntPtr handle);
  40. *
  41. * P/Invoke will create the SafeFileHandle instance for you and assign the
  42. * return value from CreateFile into the handle atomically.  When we call
  43. * ReadFile, P/Invoke will increment a ref count, make the call, then decrement
  44. * it (preventing handle recycling vulnerabilities).  Then SafeFileHandle's
  45. * ReleaseHandle method will call CloseHandle, passing in the handle field
  46. * as an IntPtr.
  47. *
  48. * If for some reason you cannot use a SafeHandle subclass for your handles,
  49. * then use IntPtr as the handle type (or possibly HandleRef - understand when
  50. * to use GC.KeepAlive).  If your code will run in SQL Server (or any other
  51. * long-running process that can't be recycled easily), use a constrained
  52. * execution region to prevent thread aborts while allocating your
  53. * handle, and consider making your handle wrapper subclass
  54. * CriticalFinalizerObject to ensure you can free the handle.  As you can
  55. * probably guess, SafeHandle  will save you a lot of headaches if your code
  56. * needs to be robust to thread aborts and OOM.
  57. *
  58. *
  59. * If you have a method that takes a native struct, you have two options for
  60. * declaring that struct.  You can make it a value type ('struct' in CSharp),
  61. * or a reference type ('class').  This choice doesn't seem very interesting,
  62. * but your function prototype must use different syntax depending on your
  63. * choice.  For example, if your native method is prototyped as such:
  64. *
  65. *    bool GetVersionEx(OSVERSIONINFO & lposvi);
  66. *
  67. *
  68. * you must use EITHER THIS OR THE NEXT syntax:
  69. *
  70. *    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
  71. *    internal struct OSVERSIONINFO {  ...  }
  72. *
  73. *    [DllImport(KERNEL32, CharSet=CharSet.Auto)]
  74. *    internal static extern bool GetVersionEx(ref OSVERSIONINFO lposvi);
  75. *
  76. * OR:
  77. *
  78. *    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
  79. *    internal class OSVERSIONINFO {  ...  }
  80. *
  81. *    [DllImport(KERNEL32, CharSet=CharSet.Auto)]
  82. *    internal static extern bool GetVersionEx([In, Out] OSVERSIONINFO lposvi);
  83. *
  84. * Note that classes require being marked as [In, Out] while value types must
  85. * be passed as ref parameters.
  86. *
  87. * Also note the CharSet.Auto on GetVersionEx - while it does not take a String
  88. * as a parameter, the OSVERSIONINFO contains an embedded array of TCHARs, so
  89. * the size of the struct varies on different platforms, and there's a
  90. * GetVersionExA & a GetVersionExW.  Also, the OSVERSIONINFO struct has a sizeof
  91. * field so the OS can ensure you've passed in the correctly-sized copy of an
  92. * OSVERSIONINFO.  You must explicitly set this using Marshal.SizeOf(Object);
  93. *
  94. * For security reasons, if you're making a P/Invoke method to a Win32 method
  95. * that takes an ANSI String (or will be ANSI on Win9x) and that String is the
  96. * name of some resource you've done a security check on (such as a file name),
  97. * you want to disable best fit mapping in WideCharToMultiByte.  Do this by
  98. * setting BestFitMapping=false in your DllImportAttribute.
  99. */
  101. namespace Microsoft.Win32
  102. {
  103.     using System;
  104.     using System.Security;
  105.     using System.Security.Principal;
  106.     using System.Text;
  107.     using System.Configuration.Assemblies;
  108.     using System.Runtime.Remoting;
  109.     using System.Runtime.InteropServices;
  110.     using System.Threading;
  111.     using Microsoft.Win32.SafeHandles;
  112.     using System.Runtime.ConstrainedExecution;
  113.     using System.Runtime.Versioning;
  114.    
  115.     using BOOL = System.Int32;
  116.     using DWORD = System.UInt32;
  117.     using ULONG = System.UInt32;
  118.    
  119. /**
  120.     * Win32 encapsulation for MSCORLIB.
  121.     */   
  122.     // Remove the default demands for all N/Direct methods with this
  123.     // global declaration on the class.
  124.     //
  125.     [SuppressUnmanagedCodeSecurityAttribute()]
  126.     static internal class Win32Native
  127.     {
  128.        
  129.        
  130.         // Win32 ACL-related constants:
  131.         internal const int READ_CONTROL = 131072;
  132.         internal const int SYNCHRONIZE = 1048576;
  133.        
  134.         internal const int STANDARD_RIGHTS_READ = READ_CONTROL;
  135.         internal const int STANDARD_RIGHTS_WRITE = READ_CONTROL;
  136.        
  137.         // STANDARD_RIGHTS_REQUIRED (0x000F0000L)
  138.         // SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3)
  139.        
  140.         // SEMAPHORE and Event both use 0x0002
  141.         // MUTEX uses 0x001 (MUTANT_QUERY_STATE)
  142.        
  143.         // Note that you may need to specify the SYNCHRONIZE bit as well
  144.         // to be able to open a synchronization primitive.
  145.         internal const int SEMAPHORE_MODIFY_STATE = 2;
  146.         internal const int EVENT_MODIFY_STATE = 2;
  147.         internal const int MUTEX_MODIFY_STATE = 1;
  148.         internal const int MUTEX_ALL_ACCESS = 2031617;
  149.        
  150.        
  151.         internal const int LMEM_FIXED = 0;
  152.         internal const int LMEM_ZEROINIT = 64;
  153.         internal const int LPTR = (LMEM_FIXED | LMEM_ZEROINIT);
  154.        
  155.         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
  156.         internal class OSVERSIONINFO
  157.         {
  158.             internal OSVERSIONINFO()
  159.             {
  160.                 OSVersionInfoSize = (int)Marshal.SizeOf(this);
  161.             }
  162.            
  163.             // The OSVersionInfoSize field must be set to Marshal.SizeOf(this)
  164.             internal int OSVersionInfoSize = 0;
  165.             internal int MajorVersion = 0;
  166.             internal int MinorVersion = 0;
  167.             internal int BuildNumber = 0;
  168.             internal int PlatformId = 0;
  169.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
  170.             internal string CSDVersion = null;
  171.         }
  172.        
  173.         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto)]
  174.         internal class OSVERSIONINFOEX
  175.         {
  176.            
  177.             public OSVERSIONINFOEX()
  178.             {
  179.                 OSVersionInfoSize = (int)Marshal.SizeOf(this);
  180.             }
  181.            
  182.             // The OSVersionInfoSize field must be set to Marshal.SizeOf(this)
  183.             internal int OSVersionInfoSize = 0;
  184.             internal int MajorVersion = 0;
  185.             internal int MinorVersion = 0;
  186.             internal int BuildNumber = 0;
  187.             internal int PlatformId = 0;
  188.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
  189.             internal string CSDVersion = null;
  190.             internal ushort ServicePackMajor = 0;
  191.             internal ushort ServicePackMinor = 0;
  192.             internal short SuiteMask = 0;
  193.             internal byte ProductType = 0;
  194.             internal byte Reserved = 0;
  195.         }
  196.        
  197.         [StructLayout(LayoutKind.Sequential)]
  198.         internal struct SYSTEM_INFO
  199.         {
  200.             internal int dwOemId;
  201.             // This is a union of a DWORD and a struct containing 2 WORDs.
  202.             internal int dwPageSize;
  203.             internal IntPtr lpMinimumApplicationAddress;
  204.             internal IntPtr lpMaximumApplicationAddress;
  205.             internal IntPtr dwActiveProcessorMask;
  206.             internal int dwNumberOfProcessors;
  207.             internal int dwProcessorType;
  208.             internal int dwAllocationGranularity;
  209.             internal short wProcessorLevel;
  210.             internal short wProcessorRevision;
  211.         }
  212.        
  213.         [StructLayout(LayoutKind.Sequential)]
  214.         internal class SECURITY_ATTRIBUTES
  215.         {
  216.             internal int nLength = 0;
  217.             unsafe internal byte* pSecurityDescriptor = null;
  218.             internal int bInheritHandle = 0;
  219.         }
  220.        
  221.         [StructLayout(LayoutKind.Sequential), Serializable()]
  222.         internal struct WIN32_FILE_ATTRIBUTE_DATA
  223.         {
  224.             internal int fileAttributes;
  225.             internal uint ftCreationTimeLow;
  226.             internal uint ftCreationTimeHigh;
  227.             internal uint ftLastAccessTimeLow;
  228.             internal uint ftLastAccessTimeHigh;
  229.             internal uint ftLastWriteTimeLow;
  230.             internal uint ftLastWriteTimeHigh;
  231.             internal int fileSizeHigh;
  232.             internal int fileSizeLow;
  233.         }
  234.        
  235.         [StructLayout(LayoutKind.Sequential)]
  236.         internal struct FILE_TIME
  237.         {
  238.             public FILE_TIME(long fileTime)
  239.             {
  240.                 ftTimeLow = (uint)fileTime;
  241.                 ftTimeHigh = (uint)(fileTime >> 32);
  242.             }
  243.            
  244.             public long ToTicks()
  245.             {
  246.                 return ((long)ftTimeHigh << 32) + ftTimeLow;
  247.             }
  248.            
  249.             internal uint ftTimeLow;
  250.             internal uint ftTimeHigh;
  251.         }
  252.        
  253.        
  254.        
  255.         #if !PLATFORM_UNIX
  256.         internal const string DLLPREFIX = "";
  257.         internal const string DLLSUFFIX = ".dll";
  258.         #else // !PLATFORM_UNIX
  259.         #if __APPLE__
  260.         internal const string DLLPREFIX = "lib";
  261.         internal const string DLLSUFFIX = ".dylib";
  262.         #else
  263.         internal const string DLLPREFIX = "lib";
  264.         internal const string DLLSUFFIX = ".so";
  265.         #endif
  266.         #endif // !PLATFORM_UNIX
  267.        
  268.         internal const string KERNEL32 = DLLPREFIX + "rotor_pal" + DLLSUFFIX;
  269.         internal const string USER32 = DLLPREFIX + "rotor_pal" + DLLSUFFIX;
  270.         internal const string ADVAPI32 = DLLPREFIX + "rotor_pal" + DLLSUFFIX;
  271.         internal const string OLE32 = DLLPREFIX + "rotor_pal" + DLLSUFFIX;
  272.         internal const string OLEAUT32 = DLLPREFIX + "rotor_palrt" + DLLSUFFIX;
  273.         internal const string SHIM = DLLPREFIX + "sscoree" + DLLSUFFIX;
  274.         internal const string MSCORWKS = DLLPREFIX + "mscorwks" + DLLSUFFIX;
  275.        
  276.        
  277.         internal const string LSTRCPY = "lstrcpy";
  278.         internal const string LSTRCPYN = "lstrcpyn";
  279.         internal const string LSTRLEN = "lstrlen";
  280.         internal const string LSTRLENA = "lstrlenA";
  281.         internal const string LSTRLENW = "lstrlenW";
  282.         internal const string MOVEMEMORY = "RtlMoveMemory";
  283.        
  284.        
  285.         // From WinBase.h
  286.         internal const int SEM_FAILCRITICALERRORS = 1;
  287.        
  288.         [DllImport(KERNEL32, SetLastError = true)]
  289.         [ResourceExposure(ResourceScope.None)]
  290.         static internal extern void SetLastError(int errorCode);
  291.        
  292.         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
  293.         [ResourceExposure(ResourceScope.None)]
  294.         static internal extern bool GetVersionEx(        [In(), Out()]
  295. OSVERSIONINFO ver);
  296.        
  297.         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
  298.         [ResourceExposure(ResourceScope.None)]
  299.         static internal extern bool GetVersionEx(        [In(), Out()]
  300. OSVERSIONINFOEX ver);
  301.        
  302.         [DllImport(KERNEL32, SetLastError = true)]
  303.         [ResourceExposure(ResourceScope.None)]
  304.         static internal extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo);
  305.        
  306.         [DllImport(KERNEL32, CharSet = CharSet.Auto, BestFitMapping = true)]
  307.         [ResourceExposure(ResourceScope.None)]
  308.         static internal extern int FormatMessage(int dwFlags, IntPtr lpSource, int dwMessageId, int dwLanguageId, StringBuilder lpBuffer, int nSize, IntPtr va_list_arguments);
  309.        
  310.         // Gets an error message for a Win32 error code.
  311.         static internal string GetMessage(int errorCode)
  312.         {
  313.             StringBuilder sb = new StringBuilder(512);
  314.             int result = Win32Native.FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY, Win32Native.NULL, errorCode, 0, sb, sb.Capacity, Win32Native.NULL);
  315.             if (result != 0) {
  316.                 // result is the # of characters copied to the StringBuilder on NT,
  317.                 // but on Win9x, it appears to be the number of MBCS bytes.
  318.                 // Just give up and return the String as-is...
  319.                 string s = sb.ToString();
  320.                 return s;
  321.             }
  322.             else {
  323.                 return Environment.GetResourceString("UnknownError_Num", errorCode);
  324.             }
  325.         }
  326.        
  327.         [DllImport(KERNEL32, EntryPoint = "LocalAlloc")]
  328.         [ResourceExposure(ResourceScope.None)]
  329.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  330.         static internal extern IntPtr LocalAlloc_NoSafeHandle(int uFlags, IntPtr sizetdwBytes);
  331.        
  332.        
  333.         [DllImport(KERNEL32, SetLastError = true)]
  334.         [ResourceExposure(ResourceScope.None)]
  335.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  336.         static internal extern IntPtr LocalFree(IntPtr handle);
  337.        
  338.         [DllImport(KERNEL32, SetLastError = true)]
  339.         [ResourceExposure(ResourceScope.None)]
  340.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  341.         static internal extern void ZeroMemory(IntPtr handle, uint length);
  342.        
  343.        
  344.         [DllImport(KERNEL32, CharSet = CharSet.Auto, BestFitMapping = false)]
  345.         [ResourceExposure(ResourceScope.Machine)]
  346.         static internal extern uint GetTempPath(int bufferLen, StringBuilder buffer);
  347.        
  348.         [DllImport(KERNEL32, CharSet = CharSet.Auto, EntryPoint = LSTRCPY, BestFitMapping = false)]
  349.         [ResourceExposure(ResourceScope.None)]
  350.         static internal extern IntPtr lstrcpy(IntPtr dst, string src);
  351.        
  352.         [DllImport(KERNEL32, CharSet = CharSet.Auto, EntryPoint = LSTRCPY, BestFitMapping = false)]
  353.         [ResourceExposure(ResourceScope.None)]
  354.         static internal extern IntPtr lstrcpy(StringBuilder dst, IntPtr src);
  355.        
  356.         [DllImport(KERNEL32, CharSet = CharSet.Auto, EntryPoint = LSTRLEN)]
  357.         [ResourceExposure(ResourceScope.None)]
  358.         static internal extern int lstrlen(sbyte[] ptr);
  359.        
  360.         [DllImport(KERNEL32, CharSet = CharSet.Auto, EntryPoint = LSTRLEN)]
  361.         [ResourceExposure(ResourceScope.None)]
  362.         static internal extern int lstrlen(IntPtr ptr);
  363.        
  364.         [DllImport(KERNEL32, CharSet = CharSet.Ansi, EntryPoint = LSTRLENA)]
  365.         [ResourceExposure(ResourceScope.None)]
  366.         static internal extern int lstrlenA(IntPtr ptr);
  367.        
  368.         [DllImport(KERNEL32, CharSet = CharSet.Unicode, EntryPoint = LSTRLENW)]
  369.         [ResourceExposure(ResourceScope.None)]
  370.         static internal extern int lstrlenW(IntPtr ptr);
  371.        
  372.         [DllImport(Win32Native.OLEAUT32, CharSet = CharSet.Unicode)]
  373.         [ResourceExposure(ResourceScope.None)]
  374.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  375.         static internal extern IntPtr SysAllocStringLen(string src, int len);
  376.         // BSTR
  377.         [DllImport(Win32Native.OLEAUT32)]
  378.         [ResourceExposure(ResourceScope.None)]
  379.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  380.         static internal extern int SysStringLen(IntPtr bstr);
  381.        
  382.         [DllImport(Win32Native.OLEAUT32)]
  383.         [ResourceExposure(ResourceScope.None)]
  384.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  385.         static internal extern void SysFreeString(IntPtr bstr);
  386.        
  387.         [DllImport(KERNEL32, CharSet = CharSet.Unicode, EntryPoint = MOVEMEMORY)]
  388.         [ResourceExposure(ResourceScope.None)]
  389.         static internal extern void CopyMemoryUni(IntPtr pdst, string psrc, IntPtr sizetcb);
  390.        
  391.         [DllImport(KERNEL32, CharSet = CharSet.Unicode, EntryPoint = MOVEMEMORY)]
  392.         [ResourceExposure(ResourceScope.None)]
  393.         static internal extern void CopyMemoryUni(StringBuilder pdst, IntPtr psrc, IntPtr sizetcb);
  394.        
  395.         [DllImport(KERNEL32, CharSet = CharSet.Ansi, EntryPoint = MOVEMEMORY, BestFitMapping = false)]
  396.         [ResourceExposure(ResourceScope.None)]
  397.         static internal extern void CopyMemoryAnsi(IntPtr pdst, string psrc, IntPtr sizetcb);
  398.        
  399.         [DllImport(KERNEL32, CharSet = CharSet.Ansi, EntryPoint = MOVEMEMORY, BestFitMapping = false)]
  400.         [ResourceExposure(ResourceScope.None)]
  401.         static internal extern void CopyMemoryAnsi(StringBuilder pdst, IntPtr psrc, IntPtr sizetcb);
  402.        
  403.        
  404.         [DllImport(KERNEL32)]
  405.         [ResourceExposure(ResourceScope.None)]
  406.         static internal extern int GetACP();
  407.        
  408.         [DllImport(KERNEL32, SetLastError = true)]
  409.         [ResourceExposure(ResourceScope.None)]
  410.         static internal extern bool SetEvent(SafeWaitHandle handle);
  411.        
  412.         [DllImport(KERNEL32, SetLastError = true)]
  413.         [ResourceExposure(ResourceScope.None)]
  414.         static internal extern bool ResetEvent(SafeWaitHandle handle);
  415.        
  416.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  417.         [ResourceExposure(ResourceScope.Machine)]
  418.         // Machine or none based on the value of "name"
  419.         static internal extern SafeWaitHandle CreateEvent(SECURITY_ATTRIBUTES lpSecurityAttributes, bool isManualReset, bool initialState, string name);
  420.        
  421.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  422.         [ResourceExposure(ResourceScope.Machine)]
  423.             /* DWORD */        static internal extern SafeWaitHandle OpenEvent(int desiredAccess, bool inheritHandle, string name);
  424.        
  425.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  426.         [ResourceExposure(ResourceScope.Machine)]
  427.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  428.         static internal extern SafeWaitHandle CreateMutex(SECURITY_ATTRIBUTES lpSecurityAttributes, bool initialOwner, string name);
  429.        
  430.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  431.         [ResourceExposure(ResourceScope.Machine)]
  432.             /* DWORD */        static internal extern SafeWaitHandle OpenMutex(int desiredAccess, bool inheritHandle, string name);
  433.        
  434.         [DllImport(KERNEL32, SetLastError = true)]
  435.         [ResourceExposure(ResourceScope.None)]
  436.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
  437.         static internal extern bool ReleaseMutex(SafeWaitHandle handle);
  438.        
  439.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  440.         [ResourceExposure(ResourceScope.Machine)]
  441.         static internal extern int GetFullPathName(        [In()]
  442. char[] path, int numBufferChars,         [Out()]
  443. char[] buffer, IntPtr mustBeZero);
  444.        
  445.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  446.         [ResourceExposure(ResourceScope.Machine)]
  447.         unsafe static internal extern int GetFullPathName(char* path, int numBufferChars, char* buffer, IntPtr mustBeZero);
  448.        
  449.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  450.         [ResourceExposure(ResourceScope.Machine)]
  451.         static internal extern int GetLongPathName(string path, StringBuilder longPathBuffer, int bufferLength);
  452.        
  453.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  454.         [ResourceExposure(ResourceScope.Machine)]
  455.         static internal extern int GetLongPathName(        [In()]
  456. char[] path,         [Out()]
  457. char[] longPathBuffer, int bufferLength);
  458.        
  459.        
  460.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  461.         [ResourceExposure(ResourceScope.Machine)]
  462.         unsafe static internal extern int GetLongPathName(char* path, char* longPathBuffer, int bufferLength);
  463.        
  464.         // Disallow access to all non-file devices from methods that take
  465.         // a String. This disallows DOS devices like "con:", "com1:",
  466.         // "lpt1:", etc. Use this to avoid security problems, like allowing
  467.         // a web client asking a server for "http://server/com1.aspx" and
  468.         // then causing a worker process to hang.
  469.         [ResourceExposure(ResourceScope.Machine)]
  470.         [ResourceConsumption(ResourceScope.Machine)]
  471.         static internal SafeFileHandle SafeCreateFile(string lpFileName, int dwDesiredAccess, System.IO.FileShare dwShareMode, SECURITY_ATTRIBUTES securityAttrs, System.IO.FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile)
  472.         {
  473.             SafeFileHandle handle = CreateFile(lpFileName, dwDesiredAccess, dwShareMode, securityAttrs, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
  474.            
  475.             if (!handle.IsInvalid) {
  476.                 int fileType = Win32Native.GetFileType(handle);
  477.                 if (fileType != Win32Native.FILE_TYPE_DISK) {
  478.                     handle.Dispose();
  479.                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_FileStreamOnNonFiles"));
  480.                 }
  481.             }
  482.            
  483.             return handle;
  484.         }
  485.        
  486.         [ResourceExposure(ResourceScope.Machine)]
  487.         [ResourceConsumption(ResourceScope.Machine)]
  488.         static internal SafeFileHandle UnsafeCreateFile(string lpFileName, int dwDesiredAccess, System.IO.FileShare dwShareMode, SECURITY_ATTRIBUTES securityAttrs, System.IO.FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile)
  489.         {
  490.             SafeFileHandle handle = CreateFile(lpFileName, dwDesiredAccess, dwShareMode, securityAttrs, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile);
  491.            
  492.             return handle;
  493.         }
  494.        
  495.         // Do not use these directly, use the safe or unsafe versions above.
  496.         // The safe version does not support devices (aka if will only open
  497.         // files on disk), while the unsafe version give you the full semantic
  498.         // of the native version.
  499.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  500.         [ResourceExposure(ResourceScope.Machine)]
  501.         private static extern SafeFileHandle CreateFile(string lpFileName, int dwDesiredAccess, System.IO.FileShare dwShareMode, SECURITY_ATTRIBUTES securityAttrs, System.IO.FileMode dwCreationDisposition, int dwFlagsAndAttributes, IntPtr hTemplateFile);
  502.        
  503.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  504.         [ResourceExposure(ResourceScope.Machine)]
  505.         static internal extern SafeFileMappingHandle CreateFileMapping(SafeFileHandle hFile, IntPtr lpAttributes, uint fProtect, uint dwMaximumSizeHigh, uint dwMaximumSizeLow, string lpName);
  506.        
  507.         [DllImport(KERNEL32, SetLastError = true, ExactSpelling = true)]
  508.         [ResourceExposure(ResourceScope.Machine)]
  509.         static internal extern SafeViewOfFileHandle MapViewOfFile(SafeFileMappingHandle handle, uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, UIntPtr dwNumerOfBytesToMap);
  510.        
  511.         [DllImport(KERNEL32, ExactSpelling = true)]
  512.         [ResourceExposure(ResourceScope.Machine)]
  513.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  514.         static internal extern bool UnmapViewOfFile(IntPtr lpBaseAddress);
  515.        
  516.         [DllImport(KERNEL32, SetLastError = true)]
  517.         [ResourceExposure(ResourceScope.Machine)]
  518.         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
  519.         static internal extern bool CloseHandle(IntPtr handle);
  520.        
  521.         [DllImport(KERNEL32)]
  522.         [ResourceExposure(ResourceScope.None)]
  523.         static internal extern int GetFileType(SafeFileHandle handle);
  524.        
  525.         [DllImport(KERNEL32, SetLastError = true)]
  526.         [ResourceExposure(ResourceScope.None)]
  527.         static internal extern bool SetEndOfFile(SafeFileHandle hFile);
  528.        
  529.         [DllImport(KERNEL32, SetLastError = true, EntryPoint = "SetFilePointer")]
  530.         [ResourceExposure(ResourceScope.None)]
  531.         unsafe private static extern int SetFilePointerWin32(SafeFileHandle handle, int lo, int* hi, int origin);
  532.        
  533.         [ResourceExposure(ResourceScope.None)]
  534.         unsafe static internal long SetFilePointer(SafeFileHandle handle, long offset, System.IO.SeekOrigin origin, out int hr)
  535.         {
  536.             hr = 0;
  537.             int lo = (int)offset;
  538.             int hi = (int)(offset >> 32);
  539.             lo = SetFilePointerWin32(handle, lo, &hi, (int)origin);
  540.            
  541.             if (lo == -1 && ((hr = Marshal.GetLastWin32Error()) != 0))
  542.                 return -1;
  543.             return (long)(((ulong)((uint)hi)) << 32) | ((uint)lo);
  544.         }
  545.        
  546.         // Note there are two different ReadFile prototypes - this is to use
  547.         // the type system to force you to not trip across a "feature" in
  548.         // Win32's async IO support. You can't do the following three things
  549.         // simultaneously: overlapped IO, free the memory for the overlapped
  550.         // struct in a callback (or an EndRead method called by that callback),
  551.         // and pass in an address for the numBytesRead parameter.
  552.        
  553.         [DllImport(KERNEL32, SetLastError = true)]
  554.         [ResourceExposure(ResourceScope.None)]
  555.         unsafe static internal extern int ReadFile(SafeFileHandle handle, byte* bytes, int numBytesToRead, IntPtr numBytesRead_mustBeZero, NativeOverlapped* overlapped);
  556.        
  557.         [DllImport(KERNEL32, SetLastError = true)]
  558.         [ResourceExposure(ResourceScope.None)]
  559.         unsafe static internal extern int ReadFile(SafeFileHandle handle, byte* bytes, int numBytesToRead, out int numBytesRead, IntPtr mustBeZero);
  560.        
  561.         // Note there are two different WriteFile prototypes - this is to use
  562.         // the type system to force you to not trip across a "feature" in
  563.         // Win32's async IO support. You can't do the following three things
  564.         // simultaneously: overlapped IO, free the memory for the overlapped
  565.         // struct in a callback (or an EndWrite method called by that callback),
  566.         // and pass in an address for the numBytesRead parameter.
  567.        
  568.         [DllImport(KERNEL32, SetLastError = true)]
  569.         [ResourceExposure(ResourceScope.None)]
  570.         unsafe static internal extern int WriteFile(SafeFileHandle handle, byte* bytes, int numBytesToWrite, IntPtr numBytesWritten_mustBeZero, NativeOverlapped* lpOverlapped);
  571.        
  572.         [DllImport(KERNEL32, SetLastError = true)]
  573.         [ResourceExposure(ResourceScope.None)]
  574.         unsafe static internal extern int WriteFile(SafeFileHandle handle, byte* bytes, int numBytesToWrite, out int numBytesWritten, IntPtr mustBeZero);
  575.        
  576.        
  577.         // NOTE: The out parameters are PULARGE_INTEGERs and may require
  578.         // some byte munging magic.
  579.         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
  580.         [ResourceExposure(ResourceScope.None)]
  581.         static internal extern bool GetDiskFreeSpaceEx(string drive, out long freeBytesForUser, out long totalBytes, out long freeBytes);
  582.        
  583.         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
  584.         [ResourceExposure(ResourceScope.None)]
  585.         static internal extern int GetDriveType(string drive);
  586.        
  587.         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
  588.         [ResourceExposure(ResourceScope.None)]
  589.         static internal extern bool GetVolumeInformation(string drive, StringBuilder volumeName, int volumeNameBufLen, out int volSerialNumber, out int maxFileNameLen, out int fileSystemFlags, StringBuilder fileSystemName, int fileSystemNameBufLen);
  590.        
  591.         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true, BestFitMapping = false)]
  592.         [ResourceExposure(ResourceScope.None)]
  593.         static internal extern bool SetVolumeLabel(string driveLetter, string volumeName);
  594.        
  595.        
  596.         [DllImport(KERNEL32, CharSet = CharSet.Unicode, SetLastError = true, EntryPoint = "PAL_GetPALDirectoryW", BestFitMapping = false)]
  597.         [ResourceExposure(ResourceScope.Machine)]
  598.         static internal extern int GetSystemDirectory(StringBuilder sb, int length);
  599.        
  600.         [DllImport(OLEAUT32, CharSet = CharSet.Unicode, SetLastError = true, EntryPoint = "PAL_FetchConfigurationStringW")]
  601.         [ResourceExposure(ResourceScope.Machine)]
  602.         static internal extern bool FetchConfigurationString(bool perMachine, string parameterName, StringBuilder parameterValue, int parameterValueLength);
  603.        
  604.         [DllImport(KERNEL32, SetLastError = true)]
  605.         [ResourceExposure(ResourceScope.None)]
  606.         unsafe static internal extern bool SetFileTime(SafeFileHandle hFile, FILE_TIME* creationTime, FILE_TIME* lastAccessTime, FILE_TIME* lastWriteTime);
  607.        
  608.         [DllImport(KERNEL32, SetLastError = true)]
  609.         [ResourceExposure(ResourceScope.None)]
  610.         static internal extern int GetFileSize(SafeFileHandle hFile, out int highSize);
  611.        
  612.         [DllImport(KERNEL32, SetLastError = true)]
  613.         [ResourceExposure(ResourceScope.None)]
  614.         static internal extern bool LockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);
  615.        
  616.         [DllImport(KERNEL32, SetLastError = true)]
  617.         [ResourceExposure(ResourceScope.None)]
  618.         static internal extern bool UnlockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);
  619.        
  620.         static internal readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);
  621.         // WinBase.h
  622.         static internal readonly IntPtr NULL = IntPtr.Zero;
  623.        
  624.         // Note, these are #defines used to extract handles, and are NOT handles.
  625.         internal const int STD_INPUT_HANDLE = -10;
  626.         internal const int STD_OUTPUT_HANDLE = -11;
  627.         internal const int STD_ERROR_HANDLE = -12;
  628.        
  629.         [DllImport(KERNEL32, SetLastError = true)]
  630.         [ResourceExposure(ResourceScope.Process)]
  631.         static internal extern IntPtr GetStdHandle(int nStdHandle);
  632.         // param is NOT a handle, but it returns one!
  633.         // From wincon.h
  634.         internal const int CTRL_C_EVENT = 0;
  635.         internal const int CTRL_BREAK_EVENT = 1;
  636.         internal const int CTRL_CLOSE_EVENT = 2;
  637.         internal const int CTRL_LOGOFF_EVENT = 5;
  638.         internal const int CTRL_SHUTDOWN_EVENT = 6;
  639.         internal const short KEY_EVENT = 1;
  640.        
  641.         // From WinBase.h
  642.         internal const int FILE_TYPE_DISK = 1;
  643.         internal const int FILE_TYPE_CHAR = 2;
  644.         internal const int FILE_TYPE_PIPE = 3;
  645.        
  646.         internal const int REPLACEFILE_WRITE_THROUGH = 1;
  647.         internal const int REPLACEFILE_IGNORE_MERGE_ERRORS = 2;
  648.        
  649.         private const int FORMAT_MESSAGE_IGNORE_INSERTS = 512;
  650.         private const int FORMAT_MESSAGE_FROM_SYSTEM = 4096;
  651.         private const int FORMAT_MESSAGE_ARGUMENT_ARRAY = 8192;
  652.        
  653.         // Constants from WinNT.h
  654.         internal const int FILE_ATTRIBUTE_READONLY = 1;
  655.         internal const int FILE_ATTRIBUTE_DIRECTORY = 16;
  656.         internal const int FILE_ATTRIBUTE_REPARSE_POINT = 1024;
  657.        
  658.         internal const int IO_REPARSE_TAG_MOUNT_POINT = unchecked((int)2684354563u);
  659.        
  660.         internal const int PAGE_READWRITE = 4;
  661.        
  662.         internal const int MEM_COMMIT = 4096;
  663.         internal const int MEM_RESERVE = 8192;
  664.         internal const int MEM_RELEASE = 32768;
  665.         internal const int MEM_FREE = 65536;
  666.        
  667.         // Error codes from WinError.h
  668.         internal const int ERROR_SUCCESS = 0;
  669.         internal const int ERROR_INVALID_FUNCTION = 1;
  670.         internal const int ERROR_FILE_NOT_FOUND = 2;
  671.         internal const int ERROR_PATH_NOT_FOUND = 3;
  672.         internal const int ERROR_ACCESS_DENIED = 5;
  673.         internal const int ERROR_INVALID_HANDLE = 6;
  674.         internal const int ERROR_NOT_ENOUGH_MEMORY = 8;
  675.         internal const int ERROR_INVALID_DATA = 13;
  676.         internal const int ERROR_INVALID_DRIVE = 15;
  677.         internal const int ERROR_NO_MORE_FILES = 18;
  678.         internal const int ERROR_NOT_READY = 21;
  679.         internal const int ERROR_BAD_LENGTH = 24;
  680.         internal const int ERROR_SHARING_VIOLATION = 32;
  681.         internal const int ERROR_NOT_SUPPORTED = 50;
  682.         internal const int ERROR_FILE_EXISTS = 80;
  683.         internal const int ERROR_INVALID_PARAMETER = 87;
  684.         internal const int ERROR_CALL_NOT_IMPLEMENTED = 120;
  685.         internal const int ERROR_INSUFFICIENT_BUFFER = 122;
  686.         internal const int ERROR_INVALID_NAME = 123;
  687.         internal const int ERROR_BAD_PATHNAME = 161;
  688.         internal const int ERROR_ALREADY_EXISTS = 183;
  689.         internal const int ERROR_ENVVAR_NOT_FOUND = 203;
  690.         internal const int ERROR_FILENAME_EXCED_RANGE = 206;
  691.         // filename too long.
  692.         internal const int ERROR_NO_DATA = 232;
  693.         internal const int ERROR_PIPE_NOT_CONNECTED = 233;
  694.         internal const int ERROR_MORE_DATA = 234;
  695.         internal const int ERROR_OPERATION_ABORTED = 995;
  696.         // 995; For IO Cancellation
  697.         internal const int ERROR_NO_TOKEN = 1008;
  698.         internal const int ERROR_DLL_INIT_FAILED = 1114;
  699.         internal const int ERROR_NON_ACCOUNT_SID = 1257;
  700.         internal const int ERROR_NOT_ALL_ASSIGNED = 1300;
  701.         internal const int ERROR_UNKNOWN_REVISION = 1305;
  702.         internal const int ERROR_INVALID_OWNER = 1307;
  703.         internal const int ERROR_INVALID_PRIMARY_GROUP = 1308;
  704.         internal const int ERROR_NO_SUCH_PRIVILEGE = 1313;
  705.         internal const int ERROR_PRIVILEGE_NOT_HELD = 1314;
  706.         internal const int ERROR_NONE_MAPPED = 1332;
  707.         internal const int ERROR_INVALID_ACL = 1336;
  708.         internal const int ERROR_INVALID_SID = 1337;
  709.         internal const int ERROR_INVALID_SECURITY_DESCR = 1338;
  710.         internal const int ERROR_BAD_IMPERSONATION_LEVEL = 1346;
  711.         internal const int ERROR_CANT_OPEN_ANONYMOUS = 1347;
  712.         internal const int ERROR_NO_SECURITY_ON_OBJECT = 1350;
  713.         internal const int ERROR_TRUSTED_RELATIONSHIP_FAILURE = 1789;
  714.        
  715.         // Error codes from ntstatus.h
  716.         internal const uint STATUS_SOME_NOT_MAPPED = 263;
  717.         internal const uint STATUS_NO_MEMORY = 3221225495u;
  718.         internal const uint STATUS_NONE_MAPPED = 3221225587u;
  719.         internal const uint STATUS_INSUFFICIENT_RESOURCES = 3221225626u;
  720.         internal const uint STATUS_ACCESS_DENIED = 3221225506u;
  721.        
  722.         internal const int INVALID_FILE_SIZE = -1;
  723.        
  724.         // From WinStatus.h
  725.         internal const int STATUS_ACCOUNT_RESTRICTION = unchecked((int)3221225582u);
  726.        
  727.         // Use this to translate error codes like the above into HRESULTs like
  728.         // 0x80070006 for ERROR_INVALID_HANDLE
  729.         static internal int MakeHRFromErrorCode(int errorCode)
  730.         {
  731.             BCLDebug.Assert((4294901760u & errorCode) == 0, "This is an HRESULT, not an error code!");
  732.             return unchecked(((int)2147942400u) | errorCode);
  733.         }
  734.        
  735.         // Win32 Structs in N/Direct style
  736.         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Auto), Serializable()]
  737.         [BestFitMapping(false)]
  738.         internal class WIN32_FIND_DATA
  739.         {
  740.             internal int dwFileAttributes = 0;
  741.             // ftCreationTime was a by-value FILETIME structure
  742.             internal int ftCreationTime_dwLowDateTime = 0;
  743.             internal int ftCreationTime_dwHighDateTime = 0;
  744.             // ftLastAccessTime was a by-value FILETIME structure
  745.             internal int ftLastAccessTime_dwLowDateTime = 0;
  746.             internal int ftLastAccessTime_dwHighDateTime = 0;
  747.             // ftLastWriteTime was a by-value FILETIME structure
  748.             internal int ftLastWriteTime_dwLowDateTime = 0;
  749.             internal int ftLastWriteTime_dwHighDateTime = 0;
  750.             internal int nFileSizeHigh = 0;
  751.             internal int nFileSizeLow = 0;
  752.             // If the file attributes' reparse point flag is set, then
  753.             // dwReserved0 is the file tag (aka reparse tag) for the
  754.             // reparse point. Use this to figure out whether something is
  755.             // a volume mount point or a symbolic link.
  756.             internal int dwReserved0 = 0;
  757.             internal int dwReserved1 = 0;
  758.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)]
  759.             internal string cFileName = null;
  760.             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 14)]
  761.             internal string cAlternateFileName = null;
  762.         }
  763.        
  764.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  765.         [ResourceExposure(ResourceScope.Machine)]
  766.         static internal extern bool CopyFile(string src, string dst, bool failIfExists);
  767.        
  768.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  769.         [ResourceExposure(ResourceScope.Machine)]
  770.         static internal extern bool CreateDirectory(string path, SECURITY_ATTRIBUTES lpSecurityAttributes);
  771.        
  772.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  773.         [ResourceExposure(ResourceScope.Machine)]
  774.         static internal extern bool DeleteFile(string path);
  775.        
  776.         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
  777.         [ResourceExposure(ResourceScope.Machine)]
  778.         static internal extern bool ReplaceFile(string replacedFileName, string replacementFileName, string backupFileName, int dwReplaceFlags, IntPtr lpExclude, IntPtr lpReserved);
  779. &