mcs/class/referencesource/mscorlib/microsoft/win32/win32native.cs

   1 // ==++==
   2 //
   3 //   Copyright (c) Microsoft Corporation.  All rights reserved.
   4 //
   5 // ==--==
   6 /*============================================================
   7 **
   8 ** Class:  Microsoft.Win32.Win32Native
   9 **
  10 **
  11 ** Purpose: The CLR wrapper for all Win32 as well as
  12 **          ROTOR-style Unix PAL, etc. native operations
  13 **
  14 **
  15 ===========================================================*/
  16 /**
  17  * Notes to PInvoke users:  Getting the syntax exactly correct is crucial, and
  18  * more than a little confusing.  Here's some guidelines.
  19  *
  20  * For handles, you should use a SafeHandle subclass specific to your handle
  21  * type.  For files, we have the following set of interesting definitions:
  22  *
  23  *  [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
  24  *  private static extern SafeFileHandle CreateFile(...);
  25  *
  26  *  [DllImport(KERNEL32, SetLastError=true)]
  27  *  unsafe internal static extern int ReadFile(SafeFileHandle handle, ...);
  28  *
  29  *  [DllImport(KERNEL32, SetLastError=true)]
  30  *  internal static extern bool CloseHandle(IntPtr handle);
  31  *
  32  * P/Invoke will create the SafeFileHandle instance for you and assign the
  33  * return value from CreateFile into the handle atomically.  When we call
  34  * ReadFile, P/Invoke will increment a ref count, make the call, then decrement
  35  * it (preventing handle recycling vulnerabilities).  Then SafeFileHandle's
  36  * ReleaseHandle method will call CloseHandle, passing in the handle field
  37  * as an IntPtr.
  38  *
  39  * If for some reason you cannot use a SafeHandle subclass for your handles,
  40  * then use IntPtr as the handle type (or possibly HandleRef - understand when
  41  * to use GC.KeepAlive).  If your code will run in SQL Server (or any other
  42  * long-running process that can't be recycled easily), use a constrained
  43  * execution region to prevent thread aborts while allocating your
  44  * handle, and consider making your handle wrapper subclass
  45  * CriticalFinalizerObject to ensure you can free the handle.  As you can
  46  * probably guess, SafeHandle  will save you a lot of headaches if your code
  47  * needs to be robust to thread aborts and OOM.
  48  *
  49  *
  50  * If you have a method that takes a native struct, you have two options for
  51  * declaring that struct.  You can make it a value type ('struct' in CSharp),
  52  * or a reference type ('class').  This choice doesn't seem very interesting,
  53  * but your function prototype must use different syntax depending on your
  54  * choice.  For example, if your native method is prototyped as such:
  55  *
  56  *    bool GetVersionEx(OSVERSIONINFO & lposvi);
  57  *
  58  *
  59  * you must use EITHER THIS OR THE NEXT syntax:
  60  *
  61  *    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
  62  *    internal struct OSVERSIONINFO {  ...  }
  63  *
  64  *    [DllImport(KERNEL32, CharSet=CharSet.Auto)]
  65  *    internal static extern bool GetVersionEx(ref OSVERSIONINFO lposvi);
  66  *
  67  * OR:
  68  *
  69  *    [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
  70  *    internal class OSVERSIONINFO {  ...  }
  71  *
  72  *    [DllImport(KERNEL32, CharSet=CharSet.Auto)]
  73  *    internal static extern bool GetVersionEx([In, Out] OSVERSIONINFO lposvi);
  74  *
  75  * Note that classes require being marked as [In, Out] while value types must
  76  * be passed as ref parameters.
  77  *
  78  * Also note the CharSet.Auto on GetVersionEx - while it does not take a String
  79  * as a parameter, the OSVERSIONINFO contains an embedded array of TCHARs, so
  80  * the size of the struct varies on different platforms, and there's a
  81  * GetVersionExA & a GetVersionExW.  Also, the OSVERSIONINFO struct has a sizeof
  82  * field so the OS can ensure you've passed in the correctly-sized copy of an
  83  * OSVERSIONINFO.  You must explicitly set this using Marshal.SizeOf(Object);
  84  *
  85  * For security reasons, if you're making a P/Invoke method to a Win32 method
  86  * that takes an ANSI String and that String is the name of some resource you've
  87  * done a security check on (such as a file name), you want to disable best fit
  88  * mapping in WideCharToMultiByte.  Do this by setting BestFitMapping=false
  89  * in your DllImportAttribute.
  90  */
  91
  92 namespace Microsoft.Win32 {
  93     using System;
  94     using System.Security;
  95     using System.Security.Principal;
  96     using System.Text;
  97     using System.Configuration.Assemblies;
  98     using System.Runtime.Remoting;
  99     using System.Runtime.InteropServices;
 100     using System.Threading;
 101     using Microsoft.Win32.SafeHandles;
 102     using System.Runtime.CompilerServices;
 103     using System.Runtime.ConstrainedExecution;
 104     using System.Runtime.Versioning;
 105
 106     using BOOL = System.Int32;
 107     using DWORD = System.UInt32;
 108     using ULONG = System.UInt32;
 109
 110     /**
 111      * Win32 encapsulation for MSCORLIB.
 112      */
 113     // Remove the default demands for all P/Invoke methods with this
 114     // global declaration on the class.
 115     // <
 116
 117
 118
 119
 120
 121
 122
 123
 124
 125
 126
 127
 128     [System.Security.SecurityCritical]
 129     [SuppressUnmanagedCodeSecurityAttribute()]
 130     internal static class Win32Native {
 131
 132 #if !FEATURE_PAL
 133         internal const int KEY_QUERY_VALUE        = 0x0001;
 134         internal const int KEY_SET_VALUE          = 0x0002;
 135         internal const int KEY_CREATE_SUB_KEY     = 0x0004;
 136         internal const int KEY_ENUMERATE_SUB_KEYS = 0x0008;
 137         internal const int KEY_NOTIFY             = 0x0010;
 138         internal const int KEY_CREATE_LINK        = 0x0020;
 139         internal const int KEY_READ               =((STANDARD_RIGHTS_READ       |
 140                                                            KEY_QUERY_VALUE            |
 141                                                            KEY_ENUMERATE_SUB_KEYS     |
 142                                                            KEY_NOTIFY)
 143                                                           &
 144                                                           (~SYNCHRONIZE));
 145
 146         internal const int KEY_WRITE              =((STANDARD_RIGHTS_WRITE      |
 147                                                            KEY_SET_VALUE              |
 148                                                            KEY_CREATE_SUB_KEY)
 149                                                           &
 150                                                           (~SYNCHRONIZE));
 151         internal const int KEY_WOW64_64KEY        = 0x0100;     //
 152         internal const int KEY_WOW64_32KEY        = 0x0200;     //
 153         internal const int REG_OPTION_NON_VOLATILE= 0x0000;     // (default) keys are persisted beyond reboot/unload
 154         internal const int REG_OPTION_VOLATILE    = 0x0001;     // All keys created by the function are volatile
 155         internal const int REG_OPTION_CREATE_LINK = 0x0002;     // They key is a symbolic link
 156         internal const int REG_OPTION_BACKUP_RESTORE = 0x0004;  // Use SE_BACKUP_NAME process special privileges
 157         internal const int REG_NONE                    = 0;     // No value type
 158         internal const int REG_SZ                      = 1;     // Unicode nul terminated string
 159         internal const int REG_EXPAND_SZ               = 2;     // Unicode nul terminated string
 160         // (with environment variable references)
 161         internal const int REG_BINARY                  = 3;     // Free form binary
 162         internal const int REG_DWORD                   = 4;     // 32-bit number
 163         internal const int REG_DWORD_LITTLE_ENDIAN     = 4;     // 32-bit number (same as REG_DWORD)
 164         internal const int REG_DWORD_BIG_ENDIAN        = 5;     // 32-bit number
 165         internal const int REG_LINK                    = 6;     // Symbolic Link (unicode)
 166         internal const int REG_MULTI_SZ                = 7;     // Multiple Unicode strings
 167         internal const int REG_RESOURCE_LIST           = 8;     // Resource list in the resource map
 168         internal const int REG_FULL_RESOURCE_DESCRIPTOR  = 9;   // Resource list in the hardware description
 169         internal const int REG_RESOURCE_REQUIREMENTS_LIST = 10;
 170         internal const int REG_QWORD                   = 11;    // 64-bit number
 171
 172         internal const int HWND_BROADCAST              = 0xffff;
 173         internal const int WM_SETTINGCHANGE            = 0x001A;
 174
 175         // CryptProtectMemory and CryptUnprotectMemory.
 176         internal const uint CRYPTPROTECTMEMORY_BLOCK_SIZE    = 16;
 177         internal const uint CRYPTPROTECTMEMORY_SAME_PROCESS  = 0x00;
 178         internal const uint CRYPTPROTECTMEMORY_CROSS_PROCESS = 0x01;
 179         internal const uint CRYPTPROTECTMEMORY_SAME_LOGON    = 0x02;
 180
 181         // Security Quality of Service flags
 182         internal const int SECURITY_ANONYMOUS       = ((int)SECURITY_IMPERSONATION_LEVEL.Anonymous << 16);
 183         internal const int SECURITY_SQOS_PRESENT    = 0x00100000;
 184
 185         // Access Control library.
 186         internal const string MICROSOFT_KERBEROS_NAME = "Kerberos";
 187         internal const uint ANONYMOUS_LOGON_LUID = 0x3e6;
 188
 189         internal const int SECURITY_ANONYMOUS_LOGON_RID    = 0x00000007;
 190         internal const int SECURITY_AUTHENTICATED_USER_RID = 0x0000000B;
 191         internal const int SECURITY_LOCAL_SYSTEM_RID       = 0x00000012;
 192         internal const int SECURITY_BUILTIN_DOMAIN_RID     = 0x00000020;
 193
 194         internal const uint SE_PRIVILEGE_DISABLED           = 0x00000000;
 195         internal const uint SE_PRIVILEGE_ENABLED_BY_DEFAULT = 0x00000001;
 196         internal const uint SE_PRIVILEGE_ENABLED            = 0x00000002;
 197         internal const uint SE_PRIVILEGE_USED_FOR_ACCESS    = 0x80000000;
 198
 199         internal const uint SE_GROUP_MANDATORY          = 0x00000001;
 200         internal const uint SE_GROUP_ENABLED_BY_DEFAULT = 0x00000002;
 201         internal const uint SE_GROUP_ENABLED            = 0x00000004;
 202         internal const uint SE_GROUP_OWNER              = 0x00000008;
 203         internal const uint SE_GROUP_USE_FOR_DENY_ONLY  = 0x00000010;
 204         internal const uint SE_GROUP_LOGON_ID           = 0xC0000000;
 205         internal const uint SE_GROUP_RESOURCE           = 0x20000000;
 206
 207         internal const uint DUPLICATE_CLOSE_SOURCE      = 0x00000001;
 208         internal const uint DUPLICATE_SAME_ACCESS       = 0x00000002;
 209         internal const uint DUPLICATE_SAME_ATTRIBUTES   = 0x00000004;
 210 #endif
 211
 212         // TimeZone
 213         internal const int TIME_ZONE_ID_INVALID = -1;
 214         internal const int TIME_ZONE_ID_UNKNOWN = 0;
 215         internal const int TIME_ZONE_ID_STANDARD = 1;
 216         internal const int TIME_ZONE_ID_DAYLIGHT = 2;
 217         internal const int MAX_PATH = 260;
 218
 219         internal const int MUI_LANGUAGE_ID = 0x4;
 220         internal const int MUI_LANGUAGE_NAME = 0x8;
 221         internal const int MUI_PREFERRED_UI_LANGUAGES = 0x10;
 222         internal const int MUI_INSTALLED_LANGUAGES = 0x20;
 223         internal const int MUI_ALL_LANGUAGES = 0x40;
 224         internal const int MUI_LANG_NEUTRAL_PE_FILE = 0x100;
 225         internal const int MUI_NON_LANG_NEUTRAL_FILE = 0x200;
 226
 227         internal const int LOAD_LIBRARY_AS_DATAFILE = 0x00000002;
 228         internal const int LOAD_STRING_MAX_LENGTH = 500;
 229
 230         [StructLayout(LayoutKind.Sequential)]
 231         internal struct SystemTime {
 232             [MarshalAs(UnmanagedType.U2)]
 233             public short Year;
 234             [MarshalAs(UnmanagedType.U2)]
 235             public short Month;
 236             [MarshalAs(UnmanagedType.U2)]
 237             public short DayOfWeek;
 238             [MarshalAs(UnmanagedType.U2)]
 239             public short Day;
 240             [MarshalAs(UnmanagedType.U2)]
 241             public short Hour;
 242             [MarshalAs(UnmanagedType.U2)]
 243             public short Minute;
 244             [MarshalAs(UnmanagedType.U2)]
 245             public short Second;
 246             [MarshalAs(UnmanagedType.U2)]
 247             public short Milliseconds;
 248         }
 249
 250         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
 251         internal struct TimeZoneInformation {
 252             [MarshalAs(UnmanagedType.I4)]
 253             public Int32 Bias;
 254             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
 255             public string StandardName;
 256             public SystemTime StandardDate;
 257             [MarshalAs(UnmanagedType.I4)]
 258             public Int32 StandardBias;
 259             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
 260             public string DaylightName;
 261             public SystemTime DaylightDate;
 262             [MarshalAs(UnmanagedType.I4)]
 263             public Int32 DaylightBias;
 264
 265             public TimeZoneInformation(Win32Native.DynamicTimeZoneInformation dtzi) {
 266                 Bias = dtzi.Bias;
 267                 StandardName = dtzi.StandardName;
 268                 StandardDate = dtzi.StandardDate;
 269                 StandardBias = dtzi.StandardBias;
 270                 DaylightName = dtzi.DaylightName;
 271                 DaylightDate = dtzi.DaylightDate;
 272                 DaylightBias = dtzi.DaylightBias;
 273             }
 274         }
 275
 276
 277         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
 278         internal struct DynamicTimeZoneInformation {
 279             [MarshalAs(UnmanagedType.I4)]
 280             public Int32 Bias;
 281             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
 282             public string StandardName;
 283             public SystemTime StandardDate;
 284             [MarshalAs(UnmanagedType.I4)]
 285             public Int32 StandardBias;
 286             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 32)]
 287             public string DaylightName;
 288             public SystemTime DaylightDate;
 289             [MarshalAs(UnmanagedType.I4)]
 290             public Int32 DaylightBias;
 291             [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
 292             public string TimeZoneKeyName;
 293             [MarshalAs(UnmanagedType.Bool)]
 294             public bool DynamicDaylightTimeDisabled;
 295         }
 296
 297
 298         [StructLayout(LayoutKind.Sequential)]
 299         internal struct RegistryTimeZoneInformation {
 300             [MarshalAs(UnmanagedType.I4)]
 301             public Int32 Bias;
 302             [MarshalAs(UnmanagedType.I4)]
 303             public Int32 StandardBias;
 304             [MarshalAs(UnmanagedType.I4)]
 305             public Int32 DaylightBias;
 306             public SystemTime StandardDate;
 307             public SystemTime DaylightDate;
 308
 309             public RegistryTimeZoneInformation(Win32Native.TimeZoneInformation tzi) {
 310                 Bias = tzi.Bias;
 311                 StandardDate = tzi.StandardDate;
 312                 StandardBias = tzi.StandardBias;
 313                 DaylightDate = tzi.DaylightDate;
 314                 DaylightBias = tzi.DaylightBias;
 315             }
 316
 317             public RegistryTimeZoneInformation(Byte[] bytes) {
 318                 //
 319                 // typedef struct _REG_TZI_FORMAT {
 320                 // [00-03]    LONG Bias;
 321                 // [04-07]    LONG StandardBias;
 322                 // [08-11]    LONG DaylightBias;
 323                 // [12-27]    SYSTEMTIME StandardDate;
 324                 // [12-13]        WORD wYear;
 325                 // [14-15]        WORD wMonth;
 326                 // [16-17]        WORD wDayOfWeek;
 327                 // [18-19]        WORD wDay;
 328                 // [20-21]        WORD wHour;
 329                 // [22-23]        WORD wMinute;
 330                 // [24-25]        WORD wSecond;
 331                 // [26-27]        WORD wMilliseconds;
 332                 // [28-43]    SYSTEMTIME DaylightDate;
 333                 // [28-29]        WORD wYear;
 334                 // [30-31]        WORD wMonth;
 335                 // [32-33]        WORD wDayOfWeek;
 336                 // [34-35]        WORD wDay;
 337                 // [36-37]        WORD wHour;
 338                 // [38-39]        WORD wMinute;
 339                 // [40-41]        WORD wSecond;
 340                 // [42-43]        WORD wMilliseconds;
 341                 // } REG_TZI_FORMAT;
 342                 //
 343                 if (bytes == null || bytes.Length != 44) {
 344                     throw new ArgumentException(Environment.GetResourceString("Argument_InvalidREG_TZI_FORMAT"), "bytes");
 345                 }
 346                 Bias = BitConverter.ToInt32(bytes, 0);
 347                 StandardBias = BitConverter.ToInt32(bytes, 4);
 348                 DaylightBias = BitConverter.ToInt32(bytes, 8);
 349
 350                 StandardDate.Year = BitConverter.ToInt16(bytes, 12);
 351                 StandardDate.Month = BitConverter.ToInt16(bytes, 14);
 352                 StandardDate.DayOfWeek = BitConverter.ToInt16(bytes, 16);
 353                 StandardDate.Day = BitConverter.ToInt16(bytes, 18);
 354                 StandardDate.Hour = BitConverter.ToInt16(bytes, 20);
 355                 StandardDate.Minute = BitConverter.ToInt16(bytes, 22);
 356                 StandardDate.Second = BitConverter.ToInt16(bytes, 24);
 357                 StandardDate.Milliseconds = BitConverter.ToInt16(bytes, 26);
 358
 359                 DaylightDate.Year = BitConverter.ToInt16(bytes, 28);
 360                 DaylightDate.Month = BitConverter.ToInt16(bytes, 30);
 361                 DaylightDate.DayOfWeek = BitConverter.ToInt16(bytes, 32);
 362                 DaylightDate.Day = BitConverter.ToInt16(bytes, 34);
 363                 DaylightDate.Hour = BitConverter.ToInt16(bytes, 36);
 364                 DaylightDate.Minute = BitConverter.ToInt16(bytes, 38);
 365                 DaylightDate.Second = BitConverter.ToInt16(bytes, 40);
 366                 DaylightDate.Milliseconds = BitConverter.ToInt16(bytes, 42);
 367             }
 368         }
 369
 370         // end of TimeZone
 371
 372
 373         // Win32 ACL-related constants:
 374         internal const int READ_CONTROL                    = 0x00020000;
 375         internal const int SYNCHRONIZE                     = 0x00100000;
 376
 377         internal const int STANDARD_RIGHTS_READ            = READ_CONTROL;
 378         internal const int STANDARD_RIGHTS_WRITE           = READ_CONTROL;
 379
 380         // STANDARD_RIGHTS_REQUIRED  (0x000F0000L)
 381         // SEMAPHORE_ALL_ACCESS          (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3)
 382
 383         // SEMAPHORE and Event both use 0x0002
 384         // MUTEX uses 0x001 (MUTANT_QUERY_STATE)
 385
 386         // Note that you may need to specify the SYNCHRONIZE bit as well
 387         // to be able to open a synchronization primitive.
 388         internal const int SEMAPHORE_MODIFY_STATE = 0x00000002;
 389         internal const int EVENT_MODIFY_STATE     = 0x00000002;
 390         internal const int MUTEX_MODIFY_STATE     = 0x00000001;
 391         internal const int MUTEX_ALL_ACCESS       = 0x001F0001;
 392
 393
 394         internal const int LMEM_FIXED    = 0x0000;
 395         internal const int LMEM_ZEROINIT = 0x0040;
 396         internal const int LPTR          = (LMEM_FIXED | LMEM_ZEROINIT);
 397
 398         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
 399         internal class OSVERSIONINFO {
 400             internal OSVERSIONINFO() {
 401                 OSVersionInfoSize = (int)Marshal.SizeOf(this);
 402             }
 403
 404             // The OSVersionInfoSize field must be set to Marshal.SizeOf(this)
 405             internal int OSVersionInfoSize = 0;
 406             internal int MajorVersion = 0;
 407             internal int MinorVersion = 0;
 408             internal int BuildNumber = 0;
 409             internal int PlatformId = 0;
 410             [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)]
 411             internal String CSDVersion = null;
 412         }
 413
 414         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
 415         internal class OSVERSIONINFOEX {
 416
 417             public OSVERSIONINFOEX() {
 418                 OSVersionInfoSize = (int)Marshal.SizeOf(this);
 419             }
 420
 421             // The OSVersionInfoSize field must be set to Marshal.SizeOf(this)
 422             internal int OSVersionInfoSize = 0;
 423             internal int MajorVersion = 0;
 424             internal int MinorVersion = 0;
 425             internal int BuildNumber = 0;
 426             internal int PlatformId = 0;
 427             [MarshalAs(UnmanagedType.ByValTStr, SizeConst=128)]
 428             internal string CSDVersion = null;
 429             internal ushort ServicePackMajor = 0;
 430             internal ushort ServicePackMinor = 0;
 431             internal short SuiteMask = 0;
 432             internal byte ProductType = 0;
 433             internal byte Reserved = 0;
 434         }
 435
 436         [StructLayout(LayoutKind.Sequential)]
 437             internal struct SYSTEM_INFO {
 438             internal int dwOemId;    // This is a union of a DWORD and a struct containing 2 WORDs.
 439             internal int dwPageSize;
 440             internal IntPtr lpMinimumApplicationAddress;
 441             internal IntPtr lpMaximumApplicationAddress;
 442             internal IntPtr dwActiveProcessorMask;
 443             internal int dwNumberOfProcessors;
 444             internal int dwProcessorType;
 445             internal int dwAllocationGranularity;
 446             internal short wProcessorLevel;
 447             internal short wProcessorRevision;
 448         }
 449
 450         [StructLayout(LayoutKind.Sequential)]
 451         internal class SECURITY_ATTRIBUTES {
 452             internal int nLength = 0;
 453             // don't remove null, or this field will disappear in bcl.small
 454             internal unsafe byte * pSecurityDescriptor = null;
 455             internal int bInheritHandle = 0;
 456         }
 457
 458         [Serializable]
 459         [StructLayout(LayoutKind.Sequential)]
 460         internal struct WIN32_FILE_ATTRIBUTE_DATA {
 461             internal int fileAttributes;
 462             internal uint ftCreationTimeLow;
 463             internal uint ftCreationTimeHigh;
 464             internal uint ftLastAccessTimeLow;
 465             internal uint ftLastAccessTimeHigh;
 466             internal uint ftLastWriteTimeLow;
 467             internal uint ftLastWriteTimeHigh;
 468             internal int fileSizeHigh;
 469             internal int fileSizeLow;
 470
 471             [System.Security.SecurityCritical]
 472             internal void PopulateFrom(WIN32_FIND_DATA findData) {
 473                 // Copy the information to data
 474                 fileAttributes = findData.dwFileAttributes;
 475                 ftCreationTimeLow = findData.ftCreationTime_dwLowDateTime;
 476                 ftCreationTimeHigh = findData.ftCreationTime_dwHighDateTime;
 477                 ftLastAccessTimeLow = findData.ftLastAccessTime_dwLowDateTime;
 478                 ftLastAccessTimeHigh = findData.ftLastAccessTime_dwHighDateTime;
 479                 ftLastWriteTimeLow = findData.ftLastWriteTime_dwLowDateTime;
 480                 ftLastWriteTimeHigh = findData.ftLastWriteTime_dwHighDateTime;
 481                 fileSizeHigh = findData.nFileSizeHigh;
 482                 fileSizeLow = findData.nFileSizeLow;
 483             }
 484         }
 485
 486         [StructLayout(LayoutKind.Sequential)]
 487         internal struct FILE_TIME {
 488             public FILE_TIME(long fileTime) {
 489                 ftTimeLow = (uint) fileTime;
 490                 ftTimeHigh = (uint) (fileTime >> 32);
 491             }
 492
 493             public long ToTicks() {
 494                 return ((long) ftTimeHigh << 32) + ftTimeLow;
 495             }
 496
 497             internal uint ftTimeLow;
 498             internal uint ftTimeHigh;
 499         }
 500
 501 #if !FEATURE_PAL
 502
 503         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 504         internal struct KERB_S4U_LOGON {
 505             internal uint                   MessageType;
 506             internal uint                   Flags;
 507             internal UNICODE_INTPTR_STRING  ClientUpn;   // REQUIRED: UPN for client
 508             internal UNICODE_INTPTR_STRING  ClientRealm; // Optional: Client Realm, if known
 509         }
 510
 511         [StructLayoutAttribute(LayoutKind.Sequential)]
 512         internal struct LSA_OBJECT_ATTRIBUTES {
 513             internal int Length;
 514             internal IntPtr RootDirectory;
 515             internal IntPtr ObjectName;
 516             internal int Attributes;
 517             internal IntPtr SecurityDescriptor;
 518             internal IntPtr SecurityQualityOfService;
 519         }
 520
 521         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 522         internal struct UNICODE_STRING {
 523             internal ushort Length;
 524             internal ushort MaximumLength;
 525             [MarshalAs(UnmanagedType.LPWStr)] internal string Buffer;
 526         }
 527
 528         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 529         internal struct UNICODE_INTPTR_STRING {
 530             /// <remarks>
 531             ///     Note - this constructor extracts the raw pointer from the safe handle, so any
 532             ///     strings created with this version of the constructor will be unsafe to use after the buffer
 533             ///     has been freed.
 534             /// </remarks>
 535             [System.Security.SecurityCritical]  // auto-generated
 536             internal UNICODE_INTPTR_STRING (int stringBytes, SafeLocalAllocHandle buffer) {
 537                 BCLDebug.Assert(buffer == null || (stringBytes >= 0 && (ulong)stringBytes <= buffer.ByteLength),
 538                                 "buffer == null || (stringBytes >= 0 && stringBytes <= buffer.ByteLength)");
 539
 540                 this.Length = (ushort) stringBytes;
 541                 this.MaxLength = (ushort) buffer.ByteLength;
 542
 543                 // Marshaling with a SafePointer does not work correctly, so unfortunately we need to extract
 544                 // the raw handle here.
 545                 this.Buffer = buffer.DangerousGetHandle();
 546             }
 547
 548             /// <remarks>
 549             ///     This constructor should be used for constructing UNICODE_STRING structures with pointers
 550             ///     into a block of memory managed by a SafeHandle or the GC.  It shouldn't be used to own
 551             ///     any memory on its own.
 552             /// </remarks>
 553             internal UNICODE_INTPTR_STRING(int stringBytes, IntPtr buffer) {
 554                 BCLDebug.Assert((stringBytes == 0 && buffer == IntPtr.Zero) || (stringBytes > 0 && stringBytes <= UInt16.MaxValue && buffer != IntPtr.Zero),
 555                                 "(stringBytes == 0 && buffer == IntPtr.Zero) || (stringBytes > 0 && stringBytes <= UInt16.MaxValue && buffer != IntPtr.Zero)");
 556
 557                 this.Length = (ushort)stringBytes;
 558                 this.MaxLength = (ushort)stringBytes;
 559                 this.Buffer = buffer;
 560             }
 561
 562             internal ushort Length;
 563             internal ushort MaxLength;
 564             internal IntPtr Buffer;
 565         }
 566
 567         [StructLayout(LayoutKind.Sequential)]
 568         internal struct LSA_TRANSLATED_NAME {
 569             internal int Use;
 570             internal UNICODE_INTPTR_STRING Name;
 571             internal int DomainIndex;
 572         }
 573
 574         [StructLayoutAttribute(LayoutKind.Sequential)]
 575         internal struct LSA_TRANSLATED_SID {
 576             internal int Use;
 577             internal uint Rid;
 578             internal int DomainIndex;
 579         }
 580
 581         [StructLayoutAttribute(LayoutKind.Sequential)]
 582         internal struct LSA_TRANSLATED_SID2 {
 583             internal int Use;
 584             internal IntPtr Sid;
 585             internal int DomainIndex;
 586             uint Flags;
 587         }
 588
 589         [StructLayout(LayoutKind.Sequential)]
 590         internal struct LSA_TRUST_INFORMATION {
 591             internal UNICODE_INTPTR_STRING Name;
 592             internal IntPtr Sid;
 593         }
 594
 595         [StructLayout(LayoutKind.Sequential)]
 596         internal struct LSA_REFERENCED_DOMAIN_LIST {
 597             internal int Entries;
 598             internal IntPtr Domains;
 599         }
 600
 601         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 602         internal struct LUID {
 603             internal uint LowPart;
 604             internal uint HighPart;
 605         }
 606
 607         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 608         internal struct LUID_AND_ATTRIBUTES {
 609             internal LUID Luid;
 610             internal uint Attributes;
 611         }
 612
 613         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 614         internal struct QUOTA_LIMITS {
 615             internal IntPtr PagedPoolLimit;
 616             internal IntPtr NonPagedPoolLimit;
 617             internal IntPtr MinimumWorkingSetSize;
 618             internal IntPtr MaximumWorkingSetSize;
 619             internal IntPtr PagefileLimit;
 620             internal IntPtr TimeLimit;
 621         }
 622
 623         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 624         internal struct SECURITY_LOGON_SESSION_DATA {
 625             internal uint       Size;
 626             internal LUID       LogonId;
 627             internal UNICODE_INTPTR_STRING UserName;
 628             internal UNICODE_INTPTR_STRING LogonDomain;
 629             internal UNICODE_INTPTR_STRING AuthenticationPackage;
 630             internal uint       LogonType;
 631             internal uint       Session;
 632             internal IntPtr     Sid;
 633             internal long       LogonTime;
 634         }
 635
 636         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 637         internal struct SID_AND_ATTRIBUTES {
 638             internal IntPtr Sid;
 639             internal uint   Attributes;
 640             internal static readonly long SizeOf = (long)Marshal.SizeOf(typeof(SID_AND_ATTRIBUTES));
 641         }
 642
 643         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 644         internal struct TOKEN_GROUPS {
 645             internal uint GroupCount;
 646             internal SID_AND_ATTRIBUTES Groups; // SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY];
 647         }
 648
 649         [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
 650         internal struct TOKEN_PRIMARY_GROUP
 651         {
 652             internal IntPtr PrimaryGroup;
 653         }
 654
 655         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 656         internal struct TOKEN_PRIVILEGE {
 657             internal uint                PrivilegeCount;
 658             internal LUID_AND_ATTRIBUTES Privilege;
 659         }
 660
 661         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 662         internal struct TOKEN_SOURCE {
 663             private const int TOKEN_SOURCE_LENGTH = 8;
 664
 665             [MarshalAs(UnmanagedType.ByValArray, SizeConst=TOKEN_SOURCE_LENGTH)]
 666             internal char[] Name;
 667             internal LUID   SourceIdentifier;
 668         }
 669
 670         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 671         internal struct TOKEN_STATISTICS {
 672             internal LUID   TokenId;
 673             internal LUID   AuthenticationId;
 674             internal long   ExpirationTime;
 675             internal uint   TokenType;
 676             internal uint   ImpersonationLevel;
 677             internal uint   DynamicCharged;
 678             internal uint   DynamicAvailable;
 679             internal uint   GroupCount;
 680             internal uint   PrivilegeCount;
 681             internal LUID   ModifiedId;
 682         }
 683
 684         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Unicode)]
 685         internal struct TOKEN_USER {
 686             internal SID_AND_ATTRIBUTES User;
 687         }
 688
 689         [StructLayout(LayoutKind.Sequential)]
 690         internal struct MEMORYSTATUSEX {
 691             // The length field must be set to the size of this data structure.
 692             internal int length;
 693             internal int memoryLoad;
 694             internal ulong totalPhys;
 695             internal ulong availPhys;
 696             internal ulong totalPageFile;
 697             internal ulong availPageFile;
 698             internal ulong totalVirtual;
 699             internal ulong availVirtual;
 700             internal ulong availExtendedVirtual;
 701         }
 702
 703         [StructLayout(LayoutKind.Sequential)]
 704         internal unsafe struct MEMORY_BASIC_INFORMATION {
 705             internal void* BaseAddress;
 706             internal void* AllocationBase;
 707             internal uint AllocationProtect;
 708             internal UIntPtr RegionSize;
 709             internal uint State;
 710             internal uint Protect;
 711             internal uint Type;
 712         }
 713 #endif  // !FEATURE_PAL
 714
 715         internal const String KERNEL32 = "kernel32.dll";
 716         internal const String USER32   = "user32.dll";
 717         internal const String ADVAPI32 = "advapi32.dll";
 718         internal const String OLE32    = "ole32.dll";
 719         internal const String OLEAUT32 = "oleaut32.dll";
 720         internal const String SHELL32  = "shell32.dll";
 721         internal const String SHIM     = "mscoree.dll";
 722         internal const String CRYPT32  = "crypt32.dll";
 723         internal const String SECUR32  = "secur32.dll";
 724         internal const String NTDLL    = "ntdll.dll";
 725 #if FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
 726         internal const String MSCORWKS = "coreclr.dll";
 727 #else //FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
 728         internal const String MSCORWKS = "clr.dll";
 729 #endif //FEATURE_MAIN_CLR_MODULE_USES_CORE_NAME
 730
 731         // From WinBase.h
 732         internal const int SEM_FAILCRITICALERRORS = 1;
 733
 734         [DllImport(KERNEL32, SetLastError=true)]
 735         [ResourceExposure(ResourceScope.None)]
 736         internal static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo);
 737
 738         [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=true)]
 739         [ResourceExposure(ResourceScope.None)]
 740         internal static extern int FormatMessage(int dwFlags, IntPtr lpSource,
 741                     int dwMessageId, int dwLanguageId, [Out]StringBuilder lpBuffer,
 742                     int nSize, IntPtr va_list_arguments);
 743
 744         // Gets an error message for a Win32 error code.
 745         internal static String GetMessage(int errorCode) {
 746             StringBuilder sb = StringBuilderCache.Acquire(512);
 747             int result = Win32Native.FormatMessage(FORMAT_MESSAGE_IGNORE_INSERTS |
 748                 FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ARGUMENT_ARRAY,
 749                 IntPtr.Zero, errorCode, 0, sb, sb.Capacity, IntPtr.Zero);
 750             if (result != 0) {
 751                 // result is the # of characters copied to the StringBuilder.
 752                 return StringBuilderCache.GetStringAndRelease(sb);
 753             }
 754             else {
 755                 StringBuilderCache.Release(sb);
 756                 return Environment.GetResourceString("UnknownError_Num", errorCode);
 757             }
 758         }
 759
 760 #if FEATURE_PAL
 761         [FriendAccessAllowed]  // Used by Silverlight networking stack in one place.
 762 #endif // FEATURE_PAL
 763         [DllImport(KERNEL32, EntryPoint="LocalAlloc")]
 764         [ResourceExposure(ResourceScope.None)]
 765         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 766         internal static extern IntPtr LocalAlloc_NoSafeHandle(int uFlags, UIntPtr sizetdwBytes);
 767
 768 #if !FEATURE_PAL
 769         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
 770         [ResourceExposure(ResourceScope.None)]
 771         internal static extern
 772         SafeLocalAllocHandle LocalAlloc(
 773             [In] int uFlags,
 774             [In] UIntPtr sizetdwBytes);
 775 #endif // !FEATURE_PAL
 776
 777         [DllImport(KERNEL32, SetLastError=true)]
 778         [ResourceExposure(ResourceScope.None)]
 779         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 780         internal static extern IntPtr LocalFree(IntPtr handle);
 781
 782         // MSDN says the length is a SIZE_T.
 783         [DllImport(KERNEL32, EntryPoint = "RtlZeroMemory")]
 784         [ResourceExposure(ResourceScope.None)]
 785         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 786         internal static extern void ZeroMemory(IntPtr address, UIntPtr length);
 787
 788 #if !FEATURE_PAL
 789         internal static bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX buffer)
 790         {
 791             buffer.length = Marshal.SizeOf(typeof(MEMORYSTATUSEX));
 792             return GlobalMemoryStatusExNative(ref buffer);
 793         }
 794
 795         [DllImport(KERNEL32, SetLastError=true, EntryPoint="GlobalMemoryStatusEx")]
 796         [ResourceExposure(ResourceScope.None)]
 797         private static extern bool GlobalMemoryStatusExNative([In, Out] ref MEMORYSTATUSEX buffer);
 798
 799         [DllImport(KERNEL32, SetLastError=true)]
 800         [ResourceExposure(ResourceScope.None)]
 801         unsafe internal static extern UIntPtr VirtualQuery(void* address, ref MEMORY_BASIC_INFORMATION buffer, UIntPtr sizeOfBuffer);
 802
 803         // VirtualAlloc should generally be avoided, but is needed in
 804         // the MemoryFailPoint implementation (within a CER) to increase the
 805         // size of the page file, ignoring any host memory allocators.
 806         [DllImport(KERNEL32, SetLastError=true)]
 807         [ResourceExposure(ResourceScope.Process)]
 808         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 809         unsafe internal static extern void * VirtualAlloc(void* address, UIntPtr numBytes, int commitOrReserve, int pageProtectionMode);
 810
 811         [DllImport(KERNEL32, SetLastError=true)]
 812         [ResourceExposure(ResourceScope.Process)]
 813         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 814         unsafe internal static extern bool VirtualFree(void* address, UIntPtr numBytes, int pageFreeMode);
 815
 816
 817
 818         // Note - do NOT use this to call methods.  Use P/Invoke, which will
 819         // do much better things w.r.t. marshaling, pinning memory, security
 820         // stuff, better interactions with thread aborts, etc.  This is used
 821         // solely by DoesWin32MethodExist for avoiding try/catch EntryPointNotFoundException
 822         // in scenarios where an OS Version check is insufficient
 823         [DllImport(KERNEL32, CharSet=CharSet.Ansi, BestFitMapping=false, SetLastError=true, ExactSpelling=true)]
 824         [ResourceExposure(ResourceScope.None)]
 825         private static extern IntPtr GetProcAddress(IntPtr hModule, String methodName);
 826
 827         [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=false, SetLastError=true)]
 828         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 829         [ResourceExposure(ResourceScope.Process)]  // Is your module side-by-side?
 830         private static extern IntPtr GetModuleHandle(String moduleName);
 831
 832         [System.Security.SecurityCritical]  // auto-generated
 833         internal static bool DoesWin32MethodExist(String moduleName, String methodName)
 834         {
 835             // GetModuleHandle does not increment the module's ref count, so we don't need to call FreeLibrary.
 836             IntPtr hModule = Win32Native.GetModuleHandle(moduleName);
 837             if (hModule == IntPtr.Zero) {
 838                 BCLDebug.Assert(hModule != IntPtr.Zero, "GetModuleHandle failed.  Dll isn't loaded?");
 839                 return false;
 840             }
 841             IntPtr functionPointer = Win32Native.GetProcAddress(hModule, methodName);
 842             return (functionPointer != IntPtr.Zero);
 843         }
 844 #endif // !FEATURE_PAL
 845
 846         // There is no need to call CloseProcess or to use a SafeHandle if you get the handle
 847         // using GetCurrentProcess as it returns a pseudohandle
 848         [DllImport(KERNEL32, SetLastError = true, CallingConvention = CallingConvention.Winapi)]
 849         [return: MarshalAs(UnmanagedType.Bool)]
 850         [ResourceExposure(ResourceScope.Machine)]
 851         internal static extern bool IsWow64Process(
 852                    [In]
 853                    IntPtr hSourceProcessHandle,
 854                    [Out, MarshalAs(UnmanagedType.Bool)]
 855                    out bool isWow64);
 856
 857         [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=false)]
 858         [ResourceExposure(ResourceScope.Machine)]
 859         internal static extern uint GetTempPath(int bufferLen, [Out]StringBuilder buffer);
 860
 861         [DllImport(KERNEL32, CharSet=CharSet.Ansi, ExactSpelling=true, EntryPoint="lstrlenA")]
 862         [ResourceExposure(ResourceScope.None)]
 863         internal static extern int lstrlenA(IntPtr ptr);
 864
 865         [DllImport(KERNEL32, CharSet=CharSet.Unicode, ExactSpelling=true, EntryPoint="lstrlenW")]
 866         [ResourceExposure(ResourceScope.None)]
 867         internal static extern int lstrlenW(IntPtr ptr);
 868
 869         [DllImport(Win32Native.OLEAUT32, CharSet=CharSet.Unicode)]
 870         [ResourceExposure(ResourceScope.None)]
 871         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 872         internal static extern IntPtr SysAllocStringLen(String src, int len);  // BSTR
 873
 874         [DllImport(Win32Native.OLEAUT32)]
 875         [ResourceExposure(ResourceScope.None)]
 876         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 877         internal static extern IntPtr SysAllocStringByteLen(byte[] str, uint len);  // BSTR
 878
 879         [DllImport(Win32Native.OLEAUT32)]
 880         [ResourceExposure(ResourceScope.None)]
 881         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 882         internal static extern uint SysStringByteLen(IntPtr bstr);
 883
 884         [DllImport(Win32Native.OLEAUT32)]
 885         [ResourceExposure(ResourceScope.None)]
 886         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 887         internal static extern uint SysStringLen(IntPtr bstr);
 888
 889 #if !FEATURE_PAL
 890         [DllImport(Win32Native.OLEAUT32)]
 891         [ResourceExposure(ResourceScope.None)]
 892         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 893         internal static extern uint SysStringLen(SafeBSTRHandle bstr);
 894 #endif
 895
 896         [DllImport(Win32Native.OLEAUT32)]
 897         [ResourceExposure(ResourceScope.None)]
 898         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
 899         internal static extern void SysFreeString(IntPtr bstr);
 900
 901
 902         [DllImport(KERNEL32)]
 903         [ResourceExposure(ResourceScope.None)]
 904         internal static extern int GetACP();
 905
 906         [DllImport(KERNEL32, SetLastError=true)]
 907         [ResourceExposure(ResourceScope.None)]
 908         internal static extern bool SetEvent(SafeWaitHandle handle);
 909
 910         [DllImport(KERNEL32, SetLastError=true)]
 911         [ResourceExposure(ResourceScope.None)]
 912         internal static extern bool ResetEvent(SafeWaitHandle handle);
 913
 914         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
 915         [ResourceExposure(ResourceScope.Machine)] // Machine or none based on the value of "name"
 916         internal static extern SafeWaitHandle CreateEvent(SECURITY_ATTRIBUTES lpSecurityAttributes, bool isManualReset, bool initialState, String name);
 917
 918         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
 919         [ResourceExposure(ResourceScope.Machine)]
 920         internal static extern SafeWaitHandle OpenEvent(/* DWORD */ int desiredAccess, bool inheritHandle, String name);
 921
 922         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
 923         [ResourceExposure(ResourceScope.Machine)]
 924         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 925         internal static extern SafeWaitHandle CreateMutex(SECURITY_ATTRIBUTES lpSecurityAttributes, bool initialOwner, String name);
 926
 927         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
 928         [ResourceExposure(ResourceScope.Machine)]
 929         internal static extern SafeWaitHandle OpenMutex(/* DWORD */ int desiredAccess, bool inheritHandle, String name);
 930
 931         [DllImport(KERNEL32, SetLastError=true)]
 932         [ResourceExposure(ResourceScope.None)]
 933         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
 934         internal static extern bool ReleaseMutex(SafeWaitHandle handle);
 935
 936         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
 937         [ResourceExposure(ResourceScope.Machine)]
 938         internal unsafe static extern int GetFullPathName(char* path, int numBufferChars, char* buffer, IntPtr mustBeZero);
 939
 940         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false, ExactSpelling = true)]
 941         [ResourceExposure(ResourceScope.Machine)]
 942         internal unsafe static extern uint GetFullPathNameW(char* path, uint numBufferChars, SafeHandle buffer, IntPtr mustBeZero);
 943
 944         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
 945         [ResourceExposure(ResourceScope.Machine)]
 946         internal unsafe static extern int GetFullPathName(String path, int numBufferChars, [Out]StringBuilder buffer, IntPtr mustBeZero);
 947
 948         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
 949         [ResourceExposure(ResourceScope.Machine)]
 950         internal unsafe static extern int GetLongPathName(char* path, char* longPathBuffer, int bufferLength);
 951
 952         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
 953         [ResourceExposure(ResourceScope.Machine)]
 954         internal static extern int GetLongPathName(String path, [Out]StringBuilder longPathBuffer, int bufferLength);
 955
 956         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false, ExactSpelling = true)]
 957         [ResourceExposure(ResourceScope.Machine)]
 958         internal static extern uint GetLongPathNameW(SafeHandle lpszShortPath, SafeHandle lpszLongPath, uint cchBuffer);
 959
 960         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false, ExactSpelling = true)]
 961         [ResourceExposure(ResourceScope.Machine)]
 962         internal static extern uint GetLongPathNameW(string lpszShortPath, SafeHandle lpszLongPath, uint cchBuffer);
 963
 964         // Disallow access to all non-file devices from methods that take
 965         // a String.  This disallows DOS devices like "con:", "com1:",
 966         // "lpt1:", etc.  Use this to avoid security problems, like allowing
 967         // a web client asking a server for "http://server/com1.aspx" and
 968         // then causing a worker process to hang.
 969         [System.Security.SecurityCritical]  // auto-generated
 970         [ResourceExposure(ResourceScope.Machine)]
 971         [ResourceConsumption(ResourceScope.Machine)]
 972         internal static SafeFileHandle SafeCreateFile(String lpFileName,
 973                     int dwDesiredAccess, System.IO.FileShare dwShareMode,
 974                     SECURITY_ATTRIBUTES securityAttrs, System.IO.FileMode dwCreationDisposition,
 975                     int dwFlagsAndAttributes, IntPtr hTemplateFile)
 976         {
 977             SafeFileHandle handle = CreateFile( lpFileName, dwDesiredAccess, dwShareMode,
 978                                 securityAttrs, dwCreationDisposition,
 979                                 dwFlagsAndAttributes, hTemplateFile );
 980
 981             if (!handle.IsInvalid)
 982             {
 983                 int fileType = Win32Native.GetFileType(handle);
 984                 if (fileType != Win32Native.FILE_TYPE_DISK) {
 985                     handle.Dispose();
 986                     throw new NotSupportedException(Environment.GetResourceString("NotSupported_FileStreamOnNonFiles"));
 987                 }
 988             }
 989
 990             return handle;
 991         }
 992
 993         [System.Security.SecurityCritical]  // auto-generated
 994         [ResourceExposure(ResourceScope.Machine)]
 995         [ResourceConsumption(ResourceScope.Machine)]
 996         internal static SafeFileHandle UnsafeCreateFile(String lpFileName,
 997                     int dwDesiredAccess, System.IO.FileShare dwShareMode,
 998                     SECURITY_ATTRIBUTES securityAttrs, System.IO.FileMode dwCreationDisposition,
 999                     int dwFlagsAndAttributes, IntPtr hTemplateFile)
1000         {
1001             SafeFileHandle handle = CreateFile( lpFileName, dwDesiredAccess, dwShareMode,
1002                                 securityAttrs, dwCreationDisposition,
1003                                 dwFlagsAndAttributes, hTemplateFile );
1004
1005             return handle;
1006         }
1007
1008         // Do not use these directly, use the safe or unsafe versions above.
1009         // The safe version does not support devices (aka if will only open
1010         // files on disk), while the unsafe version give you the full semantic
1011         // of the native version.
1012         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1013         [ResourceExposure(ResourceScope.Machine)]
1014         private static extern SafeFileHandle CreateFile(String lpFileName,
1015                     int dwDesiredAccess, System.IO.FileShare dwShareMode,
1016                     SECURITY_ATTRIBUTES securityAttrs, System.IO.FileMode dwCreationDisposition,
1017                     int dwFlagsAndAttributes, IntPtr hTemplateFile);
1018
1019         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1020         [ResourceExposure(ResourceScope.Machine)]
1021         internal static extern SafeFileMappingHandle CreateFileMapping(SafeFileHandle hFile, IntPtr lpAttributes, uint fProtect, uint dwMaximumSizeHigh, uint dwMaximumSizeLow, String lpName);
1022
1023         [DllImport(KERNEL32, SetLastError=true, ExactSpelling=true)]
1024         [ResourceExposure(ResourceScope.Machine)]
1025         internal static extern IntPtr MapViewOfFile(
1026             SafeFileMappingHandle handle, uint dwDesiredAccess, uint dwFileOffsetHigh, uint dwFileOffsetLow, UIntPtr dwNumerOfBytesToMap);
1027
1028         [DllImport(KERNEL32, ExactSpelling=true)]
1029         [ResourceExposure(ResourceScope.Machine)]
1030         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
1031         internal static extern bool UnmapViewOfFile(IntPtr lpBaseAddress );
1032
1033         [DllImport(KERNEL32, SetLastError=true)]
1034         [ResourceExposure(ResourceScope.Machine)]
1035         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
1036         internal static extern bool CloseHandle(IntPtr handle);
1037
1038         [DllImport(KERNEL32)]
1039         [ResourceExposure(ResourceScope.None)]
1040         internal static extern int GetFileType(SafeFileHandle handle);
1041
1042         [DllImport(KERNEL32, SetLastError=true)]
1043         [ResourceExposure(ResourceScope.None)]
1044         internal static extern bool SetEndOfFile(SafeFileHandle hFile);
1045
1046         [DllImport(KERNEL32, SetLastError = true)]
1047         [ResourceExposure(ResourceScope.None)]
1048         [return: MarshalAs(UnmanagedType.Bool)]
1049         internal static extern bool FlushFileBuffers(SafeFileHandle hFile);
1050
1051         [DllImport(KERNEL32, SetLastError=true, EntryPoint="SetFilePointer")]
1052         [ResourceExposure(ResourceScope.None)]
1053         private unsafe static extern int SetFilePointerWin32(SafeFileHandle handle, int lo, int * hi, int origin);
1054
1055         [System.Security.SecurityCritical]  // auto-generated
1056         [ResourceExposure(ResourceScope.None)]
1057         internal unsafe static long SetFilePointer(SafeFileHandle handle, long offset, System.IO.SeekOrigin origin, out int hr) {
1058             hr = 0;
1059             int lo = (int) offset;
1060             int hi = (int) (offset >> 32);
1061             lo = SetFilePointerWin32(handle, lo, &hi, (int) origin);
1062
1063             if (lo == -1 && ((hr = Marshal.GetLastWin32Error()) != 0))
1064                 return -1;
1065             return (long) (((ulong) ((uint) hi)) << 32) | ((uint) lo);
1066         }
1067
1068         // Note there are two different ReadFile prototypes - this is to use
1069         // the type system to force you to not trip across a "feature" in
1070         // Win32's async IO support.  You can't do the following three things
1071         // simultaneously: overlapped IO, free the memory for the overlapped
1072         // struct in a callback (or an EndRead method called by that callback),
1073         // and pass in an address for the numBytesRead parameter.
1074         // <
1075
1076         [DllImport(KERNEL32, SetLastError=true)]
1077         [ResourceExposure(ResourceScope.None)]
1078         unsafe internal static extern int ReadFile(SafeFileHandle handle, byte* bytes, int numBytesToRead, IntPtr numBytesRead_mustBeZero, NativeOverlapped* overlapped);
1079
1080         [DllImport(KERNEL32, SetLastError=true)]
1081         [ResourceExposure(ResourceScope.None)]
1082         unsafe internal static extern int ReadFile(SafeFileHandle handle, byte* bytes, int numBytesToRead, out int numBytesRead, IntPtr mustBeZero);
1083
1084         // Note there are two different WriteFile prototypes - this is to use
1085         // the type system to force you to not trip across a "feature" in
1086         // Win32's async IO support.  You can't do the following three things
1087         // simultaneously: overlapped IO, free the memory for the overlapped
1088         // struct in a callback (or an EndWrite method called by that callback),
1089         // and pass in an address for the numBytesRead parameter.
1090         // <
1091
1092         [DllImport(KERNEL32, SetLastError=true)]
1093         [ResourceExposure(ResourceScope.None)]
1094         internal static unsafe extern int WriteFile(SafeFileHandle handle, byte* bytes, int numBytesToWrite, IntPtr numBytesWritten_mustBeZero, NativeOverlapped* lpOverlapped);
1095
1096         [DllImport(KERNEL32, SetLastError=true)]
1097         [ResourceExposure(ResourceScope.None)]
1098         internal static unsafe extern int WriteFile(SafeFileHandle handle, byte* bytes, int numBytesToWrite, out int numBytesWritten, IntPtr mustBeZero);
1099
1100         // This is only available on Vista or higher
1101         [DllImport(KERNEL32, SetLastError=true)]
1102         [ResourceExposure(ResourceScope.Process)]
1103         internal static unsafe extern bool CancelIoEx(SafeFileHandle handle, NativeOverlapped* lpOverlapped);
1104
1105         // NOTE: The out parameters are PULARGE_INTEGERs and may require
1106         // some byte munging magic.
1107         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1108         [ResourceExposure(ResourceScope.None)]
1109         internal static extern bool GetDiskFreeSpaceEx(String drive, out long freeBytesForUser, out long totalBytes, out long freeBytes);
1110
1111         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1112         [ResourceExposure(ResourceScope.None)]
1113         internal static extern int GetDriveType(String drive);
1114
1115         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1116         [ResourceExposure(ResourceScope.None)]
1117         internal static extern bool GetVolumeInformation(String drive, [Out]StringBuilder volumeName, int volumeNameBufLen, out int volSerialNumber, out int maxFileNameLen, out int fileSystemFlags, [Out]StringBuilder fileSystemName, int fileSystemNameBufLen);
1118
1119         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1120         [ResourceExposure(ResourceScope.None)]
1121         internal static extern bool SetVolumeLabel(String driveLetter, String volumeName);
1122
1123         // The following 4 methods are used by Microsoft.WlcProfile
1124         [DllImport(KERNEL32)]
1125         [ResourceExposure(ResourceScope.None)]
1126         [return: MarshalAs(UnmanagedType.Bool)]
1127         internal static extern bool QueryPerformanceCounter(out long value);
1128
1129         [DllImport(KERNEL32)]
1130         [ResourceExposure(ResourceScope.None)]
1131         [return: MarshalAs(UnmanagedType.Bool)]
1132         internal static extern bool QueryPerformanceFrequency(out long value);
1133
1134         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Auto, BestFitMapping = false)]
1135         [ResourceExposure(ResourceScope.Machine)]
1136         internal static extern SafeWaitHandle CreateSemaphore(SECURITY_ATTRIBUTES lpSecurityAttributes, int initialCount, int maximumCount, String name);
1137
1138         [DllImport(KERNEL32, SetLastError = true)]
1139         [ResourceExposure(ResourceScope.Machine)]
1140         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
1141         [return: MarshalAs(UnmanagedType.Bool)]
1142         internal static extern bool ReleaseSemaphore(SafeWaitHandle handle, int releaseCount, out int previousCount);
1143
1144         // Will be in winnls.h
1145         internal const int FIND_STARTSWITH  = 0x00100000; // see if value is at the beginning of source
1146         internal const int FIND_ENDSWITH    = 0x00200000; // see if value is at the end of source
1147         internal const int FIND_FROMSTART   = 0x00400000; // look for value in source, starting at the beginning
1148         internal const int FIND_FROMEND     = 0x00800000; // look for value in source, starting at the end
1149
1150 #if !FEATURE_CORECLR
1151         [StructLayout(LayoutKind.Sequential)]
1152         internal struct NlsVersionInfoEx
1153         {
1154             internal int dwNLSVersionInfoSize;
1155             internal int dwNLSVersion;
1156             internal int dwDefinedVersion;
1157             internal int dwEffectiveId;
1158             internal Guid guidCustomVersion;
1159         }
1160 #endif
1161
1162 #if !FEATURE_PAL
1163         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1164         [ResourceExposure(ResourceScope.Machine)]
1165         internal static extern int GetWindowsDirectory([Out]StringBuilder sb, int length);
1166
1167         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1168         [ResourceExposure(ResourceScope.Machine)]
1169         internal static extern int GetSystemDirectory([Out]StringBuilder sb, int length);
1170 #else
1171 #if !FEATURE_CORECLR
1172         [DllImport(KERNEL32, CharSet=CharSet.Unicode, SetLastError=true, ExactSpelling=true, EntryPoint="PAL_GetPALDirectoryW")]
1173         [ResourceExposure(ResourceScope.Machine)]
1174         internal static extern int GetSystemDirectory([Out]StringBuilder sb, int length);
1175
1176         [DllImport(OLEAUT32, CharSet=CharSet.Unicode, SetLastError=true, ExactSpelling=true, EntryPoint="PAL_FetchConfigurationStringW")]
1177         [ResourceExposure(ResourceScope.Machine)]
1178         internal static extern bool FetchConfigurationString(bool perMachine, String parameterName, [Out]StringBuilder parameterValue, int parameterValueLength);
1179 #endif // !FEATURE_CORECLR
1180 #endif // !FEATURE_PAL
1181
1182         [DllImport(KERNEL32, SetLastError=true)]
1183         [ResourceExposure(ResourceScope.None)]
1184         internal unsafe static extern bool SetFileTime(SafeFileHandle hFile, FILE_TIME* creationTime,
1185                     FILE_TIME* lastAccessTime, FILE_TIME* lastWriteTime);
1186
1187         [DllImport(KERNEL32, SetLastError=true)]
1188         [ResourceExposure(ResourceScope.None)]
1189         internal static extern int GetFileSize(SafeFileHandle hFile, out int highSize);
1190
1191         [DllImport(KERNEL32, SetLastError=true)]
1192         [ResourceExposure(ResourceScope.None)]
1193         internal static extern bool LockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);
1194
1195         [DllImport(KERNEL32, SetLastError=true)]
1196         [ResourceExposure(ResourceScope.None)]
1197         internal static extern bool UnlockFile(SafeFileHandle handle, int offsetLow, int offsetHigh, int countLow, int countHigh);
1198
1199         internal static readonly IntPtr INVALID_HANDLE_VALUE = new IntPtr(-1);  // WinBase.h
1200
1201         // Note, these are #defines used to extract handles, and are NOT handles.
1202         internal const int STD_INPUT_HANDLE = -10;
1203         internal const int STD_OUTPUT_HANDLE = -11;
1204         internal const int STD_ERROR_HANDLE = -12;
1205
1206         [DllImport(KERNEL32, SetLastError=true)]
1207         [ResourceExposure(ResourceScope.Process)]
1208         internal static extern IntPtr GetStdHandle(int nStdHandle);  // param is NOT a handle, but it returns one!
1209
1210         // From wincon.h
1211         internal const int CTRL_C_EVENT = 0;
1212         internal const int CTRL_BREAK_EVENT = 1;
1213         internal const int CTRL_CLOSE_EVENT = 2;
1214         internal const int CTRL_LOGOFF_EVENT = 5;
1215         internal const int CTRL_SHUTDOWN_EVENT = 6;
1216         internal const short KEY_EVENT = 1;
1217
1218         // From WinBase.h
1219         internal const int FILE_TYPE_DISK = 0x0001;
1220         internal const int FILE_TYPE_CHAR = 0x0002;
1221         internal const int FILE_TYPE_PIPE = 0x0003;
1222
1223         internal const int REPLACEFILE_WRITE_THROUGH = 0x1;
1224         internal const int REPLACEFILE_IGNORE_MERGE_ERRORS = 0x2;
1225
1226         private const int FORMAT_MESSAGE_IGNORE_INSERTS = 0x00000200;
1227         private const int FORMAT_MESSAGE_FROM_SYSTEM    = 0x00001000;
1228         private const int FORMAT_MESSAGE_ARGUMENT_ARRAY = 0x00002000;
1229
1230         internal const uint FILE_MAP_WRITE = 0x0002;
1231         internal const uint FILE_MAP_READ = 0x0004;
1232
1233         // Constants from WinNT.h
1234         internal const int FILE_ATTRIBUTE_READONLY      = 0x00000001;
1235         internal const int FILE_ATTRIBUTE_DIRECTORY     = 0x00000010;
1236         internal const int FILE_ATTRIBUTE_REPARSE_POINT = 0x00000400;
1237
1238         internal const int IO_REPARSE_TAG_MOUNT_POINT = unchecked((int)0xA0000003);
1239
1240         internal const int PAGE_READWRITE = 0x04;
1241
1242         internal const int MEM_COMMIT  =  0x1000;
1243         internal const int MEM_RESERVE =  0x2000;
1244         internal const int MEM_RELEASE =  0x8000;
1245         internal const int MEM_FREE    = 0x10000;
1246
1247         // Error codes from WinError.h
1248         internal const int ERROR_SUCCESS = 0x0;
1249         internal const int ERROR_INVALID_FUNCTION = 0x1;
1250         internal const int ERROR_FILE_NOT_FOUND = 0x2;
1251         internal const int ERROR_PATH_NOT_FOUND = 0x3;
1252         internal const int ERROR_ACCESS_DENIED  = 0x5;
1253         internal const int ERROR_INVALID_HANDLE = 0x6;
1254         internal const int ERROR_NOT_ENOUGH_MEMORY = 0x8;
1255         internal const int ERROR_INVALID_DATA = 0xd;
1256         internal const int ERROR_INVALID_DRIVE = 0xf;
1257         internal const int ERROR_NO_MORE_FILES = 0x12;
1258         internal const int ERROR_NOT_READY = 0x15;
1259         internal const int ERROR_BAD_LENGTH = 0x18;
1260         internal const int ERROR_SHARING_VIOLATION = 0x20;
1261         internal const int ERROR_NOT_SUPPORTED = 0x32;
1262         internal const int ERROR_FILE_EXISTS = 0x50;
1263         internal const int ERROR_INVALID_PARAMETER = 0x57;
1264         internal const int ERROR_BROKEN_PIPE = 0x6D;
1265         internal const int ERROR_CALL_NOT_IMPLEMENTED = 0x78;
1266         internal const int ERROR_INSUFFICIENT_BUFFER = 0x7A;
1267         internal const int ERROR_INVALID_NAME = 0x7B;
1268         internal const int ERROR_BAD_PATHNAME = 0xA1;
1269         internal const int ERROR_ALREADY_EXISTS = 0xB7;
1270         internal const int ERROR_ENVVAR_NOT_FOUND = 0xCB;
1271         internal const int ERROR_FILENAME_EXCED_RANGE = 0xCE;  // filename too long.
1272         internal const int ERROR_NO_DATA = 0xE8;
1273         internal const int ERROR_PIPE_NOT_CONNECTED = 0xE9;
1274         internal const int ERROR_MORE_DATA = 0xEA;
1275         internal const int ERROR_DIRECTORY = 0x10B;
1276         internal const int ERROR_OPERATION_ABORTED = 0x3E3;  // 995; For IO Cancellation
1277         internal const int ERROR_NOT_FOUND = 0x490;          // 1168; For IO Cancellation
1278         internal const int ERROR_NO_TOKEN = 0x3f0;
1279         internal const int ERROR_DLL_INIT_FAILED = 0x45A;
1280         internal const int ERROR_NON_ACCOUNT_SID = 0x4E9;
1281         internal const int ERROR_NOT_ALL_ASSIGNED = 0x514;
1282         internal const int ERROR_UNKNOWN_REVISION = 0x519;
1283         internal const int ERROR_INVALID_OWNER = 0x51B;
1284         internal const int ERROR_INVALID_PRIMARY_GROUP = 0x51C;
1285         internal const int ERROR_NO_SUCH_PRIVILEGE = 0x521;
1286         internal const int ERROR_PRIVILEGE_NOT_HELD = 0x522;
1287         internal const int ERROR_NONE_MAPPED = 0x534;
1288         internal const int ERROR_INVALID_ACL = 0x538;
1289         internal const int ERROR_INVALID_SID = 0x539;
1290         internal const int ERROR_INVALID_SECURITY_DESCR = 0x53A;
1291         internal const int ERROR_BAD_IMPERSONATION_LEVEL = 0x542;
1292         internal const int ERROR_CANT_OPEN_ANONYMOUS = 0x543;
1293         internal const int ERROR_NO_SECURITY_ON_OBJECT = 0x546;
1294         internal const int ERROR_TRUSTED_RELATIONSHIP_FAILURE = 0x6FD;
1295
1296         // Error codes from ntstatus.h
1297         internal const uint STATUS_SUCCESS = 0x00000000;
1298         internal const uint STATUS_SOME_NOT_MAPPED = 0x00000107;
1299         internal const uint STATUS_NO_MEMORY = 0xC0000017;
1300         internal const uint STATUS_OBJECT_NAME_NOT_FOUND = 0xC0000034;
1301         internal const uint STATUS_NONE_MAPPED = 0xC0000073;
1302         internal const uint STATUS_INSUFFICIENT_RESOURCES = 0xC000009A;
1303         internal const uint STATUS_ACCESS_DENIED = 0xC0000022;
1304
1305         internal const int INVALID_FILE_SIZE     = -1;
1306
1307         // From WinStatus.h
1308         internal const int STATUS_ACCOUNT_RESTRICTION = unchecked((int) 0xC000006E);
1309
1310         // Use this to translate error codes like the above into HRESULTs like
1311         // 0x80070006 for ERROR_INVALID_HANDLE
1312         internal static int MakeHRFromErrorCode(int errorCode)
1313         {
1314             BCLDebug.Assert((0xFFFF0000 & errorCode) == 0, "This is an HRESULT, not an error code!");
1315             return unchecked(((int)0x80070000) | errorCode);
1316         }
1317
1318         // Win32 Structs in N/Direct style
1319         [Serializable]
1320         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
1321         [BestFitMapping(false)]
1322         internal class WIN32_FIND_DATA {
1323             internal int  dwFileAttributes = 0;
1324             // ftCreationTime was a by-value FILETIME structure
1325             internal uint ftCreationTime_dwLowDateTime = 0 ;
1326             internal uint ftCreationTime_dwHighDateTime = 0;
1327             // ftLastAccessTime was a by-value FILETIME structure
1328             internal uint ftLastAccessTime_dwLowDateTime = 0;
1329             internal uint ftLastAccessTime_dwHighDateTime = 0;
1330             // ftLastWriteTime was a by-value FILETIME structure
1331             internal uint ftLastWriteTime_dwLowDateTime = 0;
1332             internal uint ftLastWriteTime_dwHighDateTime = 0;
1333             internal int  nFileSizeHigh = 0;
1334             internal int  nFileSizeLow = 0;
1335             // If the file attributes' reparse point flag is set, then
1336             // dwReserved0 is the file tag (aka reparse tag) for the
1337             // reparse point.  Use this to figure out whether something is
1338             // a volume mount point or a symbolic link.
1339             internal int  dwReserved0 = 0;
1340             internal int  dwReserved1 = 0;
1341             [MarshalAs(UnmanagedType.ByValTStr, SizeConst=260)]
1342             internal String   cFileName = null;
1343             [MarshalAs(UnmanagedType.ByValTStr, SizeConst=14)]
1344             internal String   cAlternateFileName = null;
1345         }
1346
1347 #if FEATURE_CORESYSTEM
1348         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1349         [ResourceExposure(ResourceScope.Machine)]
1350         private static extern bool CopyFileEx(String src,
1351                                               String dst,
1352                                               IntPtr progressRoutine,
1353                                               IntPtr progressData,
1354                                               ref uint cancel,
1355                                               uint flags);
1356
1357         internal static bool CopyFile(String src, String dst, bool failIfExists)
1358         {
1359             uint cancel = 0;
1360             return CopyFileEx(src, dst, IntPtr.Zero, IntPtr.Zero, ref cancel, failIfExists ? 1U : 0U);
1361         }
1362 #else // FEATURE_CORESYSTEM
1363         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1364         [ResourceExposure(ResourceScope.Machine)]
1365         internal static extern bool CopyFile(
1366                     String src, String dst, bool failIfExists);
1367 #endif // FEATURE_CORESYSTEM
1368
1369         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1370         [ResourceExposure(ResourceScope.Machine)]
1371         internal static extern bool CreateDirectory(
1372                     String path, SECURITY_ATTRIBUTES lpSecurityAttributes);
1373
1374         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1375         [ResourceExposure(ResourceScope.Machine)]
1376         internal static extern bool DeleteFile(String path);
1377
1378         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1379         [ResourceExposure(ResourceScope.Machine)]
1380         internal static extern bool ReplaceFile(String replacedFileName, String replacementFileName, String backupFileName, int dwReplaceFlags, IntPtr lpExclude, IntPtr lpReserved);
1381
1382         [DllImport(ADVAPI32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1383         [ResourceExposure(ResourceScope.Machine)]
1384         internal static extern bool DecryptFile(String path, int reservedMustBeZero);
1385
1386         [DllImport(ADVAPI32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1387         [ResourceExposure(ResourceScope.Machine)]
1388         internal static extern bool EncryptFile(String path);
1389
1390         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1391         [ResourceExposure(ResourceScope.None)]
1392         internal static extern SafeFindHandle FindFirstFile(String fileName, [In, Out] Win32Native.WIN32_FIND_DATA data);
1393
1394         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1395         [ResourceExposure(ResourceScope.None)]
1396         internal static extern bool FindNextFile(
1397                     SafeFindHandle hndFindFile,
1398                     [In, Out, MarshalAs(UnmanagedType.LPStruct)]
1399                     WIN32_FIND_DATA lpFindFileData);
1400
1401         [DllImport(KERNEL32)]
1402         [ResourceExposure(ResourceScope.None)]
1403         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
1404         internal static extern bool FindClose(IntPtr handle);
1405
1406         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1407         [ResourceExposure(ResourceScope.Machine)]
1408         internal static extern int GetCurrentDirectory(
1409                   int nBufferLength,
1410                   [Out]StringBuilder lpBuffer);
1411
1412         [DllImport(KERNEL32, SetLastError = true, CharSet = CharSet.Unicode, BestFitMapping = false, ExactSpelling = true)]
1413         [ResourceExposure(ResourceScope.Machine)]
1414         internal static extern uint GetCurrentDirectoryW(uint nBufferLength, SafeHandle lpBuffer);
1415
1416         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1417         [ResourceExposure(ResourceScope.None)]
1418         internal static extern bool GetFileAttributesEx(String name, int fileInfoLevel, ref WIN32_FILE_ATTRIBUTE_DATA lpFileInformation);
1419
1420         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1421         [ResourceExposure(ResourceScope.None)]
1422         internal static extern bool SetFileAttributes(String name, int attr);
1423
1424         [DllImport(KERNEL32, SetLastError=true)]
1425         [ResourceExposure(ResourceScope.None)]
1426         internal static extern int GetLogicalDrives();
1427
1428         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1429         [ResourceExposure(ResourceScope.None)]
1430         internal static extern uint GetTempFileName(String tmpPath, String prefix, uint uniqueIdOrZero, [Out]StringBuilder tmpFileName);
1431
1432 #if FEATURE_CORESYSTEM
1433         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1434         [ResourceExposure(ResourceScope.Machine)]
1435         private static extern bool MoveFileEx(String src, String dst, uint flags);
1436
1437         internal static bool MoveFile(String src, String dst)
1438         {
1439             return MoveFileEx(src, dst, 2 /* MOVEFILE_COPY_ALLOWED */);
1440         }
1441 #else // FEATURE_CORESYSTEM
1442         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1443         [ResourceExposure(ResourceScope.Machine)]
1444         internal static extern bool MoveFile(String src, String dst);
1445 #endif // FEATURE_CORESYSTEM
1446
1447         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1448         [ResourceExposure(ResourceScope.Machine)]
1449         internal static extern bool DeleteVolumeMountPoint(String mountPoint);
1450
1451         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1452         [ResourceExposure(ResourceScope.Machine)]
1453         internal static extern bool RemoveDirectory(String path);
1454
1455         [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
1456         [ResourceExposure(ResourceScope.Machine)]
1457         internal static extern bool SetCurrentDirectory(String path);
1458
1459         [DllImport(KERNEL32, SetLastError=false, EntryPoint="SetErrorMode", ExactSpelling=true)]
1460         [ResourceExposure(ResourceScope.Process)]
1461         private static extern int SetErrorMode_VistaAndOlder(int newMode);
1462
1463         [DllImport(KERNEL32, SetLastError=true, EntryPoint="SetThreadErrorMode")]
1464         [ResourceExposure(ResourceScope.None)]
1465         private static extern bool SetErrorMode_Win7AndNewer(int newMode, out int oldMode);
1466
1467         // RTM versions of Win7 and Windows Server 2008 R2
1468         private static readonly Version ThreadErrorModeMinOsVersion = new Version(6, 1, 7600);
1469
1470         // this method uses the thread-safe version of SetErrorMode on Windows 7 / Windows Server 2008 R2 operating systems.
1471         //
1472         [ResourceExposure(ResourceScope.Process)]
1473         [ResourceConsumption(ResourceScope.Process)]
1474         internal static int SetErrorMode(int newMode)
1475         {
1476 #if !FEATURE_CORESYSTEM // ARMSTUB
1477             if (Environment.OSVersion.Version >= ThreadErrorModeMinOsVersion)
1478             {
1479                 int oldMode;
1480                 SetErrorMode_Win7AndNewer(newMode, out oldMode);
1481                 return oldMode;
1482             }
1483 #endif
1484             return SetErrorMode_VistaAndOlder(newMode);
1485         }
1486
1487         internal const int LCID_SUPPORTED = 0x00000002;  // supported locale ids
1488
1489         [DllImport(KERNEL32)]
1490         [ResourceExposure(ResourceScope.None)]
1491         internal static extern unsafe int WideCharToMultiByte(uint cp, uint flags, char* pwzSource, int cchSource, byte* pbDestBuffer, int cbDestBuffer, IntPtr null1, IntPtr null2);
1492
1493         // A Win32 HandlerRoutine
1494         internal delegate bool ConsoleCtrlHandlerRoutine(int controlType);
1495
1496         [DllImport(KERNEL32, SetLastError=true)]
1497         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
1498         [ResourceExposure(ResourceScope.Process)]
1499         internal static extern bool SetConsoleCtrlHandler(ConsoleCtrlHandlerRoutine handler, bool addOrRemove);
1500
1501         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1502         [ResourceExposure(ResourceScope.Process)]
1503         internal static extern bool SetEnvironmentVariable(string lpName, string lpValue);
1504
1505         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1506         [ResourceExposure(ResourceScope.Machine)]
1507         internal static extern int GetEnvironmentVariable(string lpName, [Out]StringBuilder lpValue, int size);
1508
1509         [DllImport(KERNEL32, CharSet=CharSet.Unicode)]
1510         [ResourceExposure(ResourceScope.Machine)]
1511         internal static unsafe extern char * GetEnvironmentStrings();
1512
1513         [DllImport(KERNEL32, CharSet=CharSet.Unicode)]
1514         [ResourceExposure(ResourceScope.Machine)]
1515         internal static unsafe extern bool FreeEnvironmentStrings(char * pStrings);
1516
1517         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
1518         [ResourceExposure(ResourceScope.Process)]
1519         internal static extern uint GetCurrentProcessId();
1520
1521         [DllImport(ADVAPI32, CharSet=CharSet.Auto)]
1522         [ResourceExposure(ResourceScope.None)]
1523         internal static extern bool GetUserName([Out]StringBuilder lpBuffer, ref int nSize);
1524
1525         [DllImport(KERNEL32, CharSet=CharSet.Auto, BestFitMapping=false)]
1526         [ResourceExposure(ResourceScope.None)]
1527         internal extern static int GetComputerName([Out]StringBuilder nameBuffer, ref int bufferSize);
1528
1529         [DllImport(OLE32)]
1530         [ResourceExposure(ResourceScope.None)]
1531         internal extern static int CoCreateGuid(out Guid guid);
1532
1533         [DllImport(Win32Native.OLE32)]
1534         [ResourceExposure(ResourceScope.None)]
1535         internal static extern IntPtr CoTaskMemAlloc(UIntPtr cb);
1536
1537         [DllImport(Win32Native.OLE32)]
1538         [ResourceExposure(ResourceScope.None)]
1539         internal static extern IntPtr CoTaskMemRealloc(IntPtr pv, UIntPtr cb);
1540
1541         [DllImport(Win32Native.OLE32)]
1542         [ResourceExposure(ResourceScope.None)]
1543         internal static extern void CoTaskMemFree(IntPtr ptr);
1544
1545 #if !FEATURE_PAL
1546         [StructLayoutAttribute(LayoutKind.Sequential)]
1547         internal struct COORD
1548         {
1549             internal short X;
1550             internal short Y;
1551         }
1552
1553         [StructLayoutAttribute(LayoutKind.Sequential)]
1554         internal struct SMALL_RECT
1555         {
1556             internal short Left;
1557             internal short Top;
1558             internal short Right;
1559             internal short Bottom;
1560         }
1561
1562         [StructLayoutAttribute(LayoutKind.Sequential)]
1563         internal struct CONSOLE_SCREEN_BUFFER_INFO
1564         {
1565             internal COORD      dwSize;
1566             internal COORD      dwCursorPosition;
1567             internal short      wAttributes;
1568             internal SMALL_RECT srWindow;
1569             internal COORD      dwMaximumWindowSize;
1570         }
1571
1572         [StructLayoutAttribute(LayoutKind.Sequential)]
1573         internal struct CONSOLE_CURSOR_INFO
1574         {
1575             internal int dwSize;
1576             internal bool bVisible;
1577         }
1578
1579         // Win32's KEY_EVENT_RECORD
1580         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
1581         internal struct KeyEventRecord
1582         {
1583             internal bool keyDown;
1584             internal short repeatCount;
1585             internal short virtualKeyCode;
1586             internal short virtualScanCode;
1587             internal char uChar; // Union between WCHAR and ASCII char
1588             internal int controlKeyState;
1589         }
1590
1591         // Really, this is a union of KeyEventRecords and other types.
1592         [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
1593         internal struct InputRecord
1594         {
1595             internal short eventType;
1596             internal KeyEventRecord keyEvent;
1597             // This struct is a union!  Word alighment should take care of padding!
1598         }
1599
1600 [Serializable]
1601         [Flags]
1602         internal enum Color : short
1603         {
1604             Black = 0,
1605             ForegroundBlue = 0x1,
1606             ForegroundGreen = 0x2,
1607             ForegroundRed = 0x4,
1608             ForegroundYellow = 0x6,
1609             ForegroundIntensity = 0x8,
1610             BackgroundBlue = 0x10,
1611             BackgroundGreen = 0x20,
1612             BackgroundRed = 0x40,
1613             BackgroundYellow = 0x60,
1614             BackgroundIntensity = 0x80,
1615
1616             ForegroundMask = 0xf,
1617             BackgroundMask = 0xf0,
1618             ColorMask = 0xff
1619         }
1620
1621         [StructLayout(LayoutKind.Sequential)]
1622         internal struct CHAR_INFO
1623         {
1624             ushort charData;  // Union between WCHAR and ASCII char
1625             short attributes;
1626         }
1627
1628         internal const int ENABLE_PROCESSED_INPUT  = 0x0001;
1629         internal const int ENABLE_LINE_INPUT  = 0x0002;
1630         internal const int ENABLE_ECHO_INPUT  = 0x0004;
1631
1632         [DllImport(KERNEL32, SetLastError=true)]
1633         [ResourceExposure(ResourceScope.Process)]
1634         internal static extern bool SetConsoleMode(IntPtr hConsoleHandle, int mode);
1635
1636         [DllImport(KERNEL32, SetLastError=true)]
1637         [ResourceExposure(ResourceScope.Process)]
1638         internal static extern bool GetConsoleMode(IntPtr hConsoleHandle, out int mode);
1639
1640         [DllImport(KERNEL32, SetLastError=true)]
1641         [ResourceExposure(ResourceScope.None)]
1642         internal static extern bool Beep(int frequency, int duration);
1643
1644         [DllImport(KERNEL32, SetLastError=true)]
1645         [ResourceExposure(ResourceScope.None)]
1646         internal static extern bool GetConsoleScreenBufferInfo(IntPtr hConsoleOutput,
1647             out CONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo);
1648
1649         [DllImport(KERNEL32, SetLastError=true)]
1650         [ResourceExposure(ResourceScope.Process)]
1651         internal static extern bool SetConsoleScreenBufferSize(IntPtr hConsoleOutput, COORD size);
1652
1653         [DllImport(KERNEL32, SetLastError=true)]
1654         [ResourceExposure(ResourceScope.None)]
1655         internal static extern COORD GetLargestConsoleWindowSize(IntPtr hConsoleOutput);
1656
1657         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
1658         [ResourceExposure(ResourceScope.Process)]
1659         internal static extern bool FillConsoleOutputCharacter(IntPtr hConsoleOutput,
1660             char character, int nLength, COORD dwWriteCoord, out int pNumCharsWritten);
1661
1662         [DllImport(KERNEL32, SetLastError=true)]
1663         [ResourceExposure(ResourceScope.Process)]
1664         internal static extern bool FillConsoleOutputAttribute(IntPtr hConsoleOutput,
1665             short wColorAttribute, int numCells, COORD startCoord, out int pNumBytesWritten);
1666
1667         [DllImport(KERNEL32, SetLastError=true)]
1668         [ResourceExposure(ResourceScope.Process)]
1669         internal static unsafe extern bool SetConsoleWindowInfo(IntPtr hConsoleOutput,
1670             bool absolute, SMALL_RECT* consoleWindow);
1671
1672         [DllImport(KERNEL32, SetLastError=true)]
1673         [ResourceExposure(ResourceScope.Process)]
1674         internal static extern bool SetConsoleTextAttribute(IntPtr hConsoleOutput, short attributes);
1675
1676         [DllImport(KERNEL32, SetLastError=true)]
1677         [ResourceExposure(ResourceScope.Process)]
1678         internal static extern bool SetConsoleCursorPosition(IntPtr hConsoleOutput,
1679             COORD cursorPosition);
1680
1681         [DllImport(KERNEL32, SetLastError=true)]
1682         [ResourceExposure(ResourceScope.None)]
1683         internal static extern bool GetConsoleCursorInfo(IntPtr hConsoleOutput,
1684             out CONSOLE_CURSOR_INFO cci);
1685
1686         [DllImport(KERNEL32, SetLastError=true)]
1687         [ResourceExposure(ResourceScope.Process)]
1688         internal static extern bool SetConsoleCursorInfo(IntPtr hConsoleOutput,
1689             ref CONSOLE_CURSOR_INFO cci);
1690
1691         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=true)]
1692         [ResourceExposure(ResourceScope.Process)]
1693         internal static extern bool SetConsoleTitle(String title);
1694
1695         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
1696         [ResourceExposure(ResourceScope.Process)]
1697         internal static extern bool ReadConsoleInput(IntPtr hConsoleInput, out InputRecord buffer, int numInputRecords_UseOne, out int numEventsRead);
1698
1699         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
1700         [ResourceExposure(ResourceScope.Process)]
1701         internal static extern bool PeekConsoleInput(IntPtr hConsoleInput, out InputRecord buffer, int numInputRecords_UseOne, out int numEventsRead);
1702
1703         [DllImport(KERNEL32, SetLastError=true)]
1704         [ResourceExposure(ResourceScope.Process)]
1705         internal static unsafe extern bool ReadConsoleOutput(IntPtr hConsoleOutput, CHAR_INFO* pBuffer, COORD bufferSize, COORD bufferCoord, ref SMALL_RECT readRegion);
1706
1707         [DllImport(KERNEL32, CharSet=CharSet.Unicode, SetLastError=true)]
1708         [ResourceExposure(ResourceScope.Process)]
1709         [return: MarshalAs(UnmanagedType.Bool)]
1710         internal static unsafe extern bool ReadConsoleW(SafeFileHandle hConsoleInput, Byte* lpBuffer, Int32 nNumberOfCharsToRead, out Int32 lpNumberOfCharsRead, IntPtr pInputControl);
1711
1712         [DllImport(KERNEL32, SetLastError=true)]
1713         [ResourceExposure(ResourceScope.Process)]
1714         internal static unsafe extern bool WriteConsoleOutput(IntPtr hConsoleOutput, CHAR_INFO* buffer, COORD bufferSize, COORD bufferCoord, ref SMALL_RECT writeRegion);
1715
1716         [DllImport(KERNEL32, CharSet=CharSet.Unicode, SetLastError=true)]
1717         [ResourceExposure(ResourceScope.Process)]
1718         [return: MarshalAs(UnmanagedType.Bool)]
1719         internal static unsafe extern bool WriteConsoleW(SafeFileHandle hConsoleOutput, Byte* lpBuffer, Int32 nNumberOfCharsToWrite, out Int32 lpNumberOfCharsWritten, IntPtr lpReservedMustBeNull);
1720
1721         [DllImport(USER32)]  // Appears to always succeed
1722         [ResourceExposure(ResourceScope.Process)]
1723         internal static extern short GetKeyState(int virtualKeyCode);
1724 #endif // !FEATURE_PAL
1725
1726         [DllImport(KERNEL32, SetLastError=false)]
1727         [ResourceExposure(ResourceScope.None)]
1728         internal static extern uint GetConsoleCP();
1729
1730         [DllImport(KERNEL32, SetLastError=true)]
1731         [ResourceExposure(ResourceScope.Process)]
1732         internal static extern bool SetConsoleCP(uint codePage);
1733
1734         [DllImport(KERNEL32, SetLastError=false)]
1735         [ResourceExposure(ResourceScope.None)]
1736         internal static extern uint GetConsoleOutputCP();
1737
1738         [DllImport(KERNEL32, SetLastError=true)]
1739         [ResourceExposure(ResourceScope.Process)]
1740         internal static extern bool SetConsoleOutputCP(uint codePage);
1741
1742 #if !FEATURE_PAL
1743         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1744         [ResourceExposure(ResourceScope.Machine)]
1745         internal static extern int RegConnectRegistry(String machineName,
1746                     SafeRegistryHandle key, out SafeRegistryHandle result);
1747
1748         // Note: RegCreateKeyEx won't set the last error on failure - it returns
1749         // an error code if it fails.
1750         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1751         [ResourceExposure(ResourceScope.Machine)]
1752         internal static extern int RegCreateKeyEx(SafeRegistryHandle hKey, String lpSubKey,
1753                     int Reserved, String lpClass, int dwOptions,
1754                     int samDesired, SECURITY_ATTRIBUTES lpSecurityAttributes,
1755                     out SafeRegistryHandle hkResult, out int lpdwDisposition);
1756
1757         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1758         [ResourceExposure(ResourceScope.Machine)]
1759         internal static extern int RegDeleteKey(SafeRegistryHandle hKey, String lpSubKey);
1760
1761         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1762         [ResourceExposure(ResourceScope.Machine)]
1763         internal static extern int RegDeleteKeyEx(SafeRegistryHandle hKey, String lpSubKey,
1764                     int samDesired, int Reserved);
1765
1766         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1767         [ResourceExposure(ResourceScope.Machine)]
1768         internal static extern int RegDeleteValue(SafeRegistryHandle hKey, String lpValueName);
1769
1770         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1771         [ResourceExposure(ResourceScope.None)]
1772         internal unsafe static extern int RegEnumKeyEx(SafeRegistryHandle hKey, int dwIndex,
1773                     char *lpName, ref int lpcbName, int[] lpReserved,
1774                     [Out]StringBuilder lpClass, int[] lpcbClass,
1775                     long[] lpftLastWriteTime);
1776
1777         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1778         [ResourceExposure(ResourceScope.None)]
1779         internal unsafe static extern int RegEnumValue(SafeRegistryHandle hKey, int dwIndex,
1780                     char *lpValueName, ref int lpcbValueName,
1781                     IntPtr lpReserved_MustBeZero, int[] lpType, byte[] lpData,
1782                     int[] lpcbData);
1783
1784
1785         [DllImport(ADVAPI32)]
1786         [ResourceExposure(ResourceScope.None)]
1787         internal static extern int RegFlushKey(SafeRegistryHandle hKey);
1788
1789         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1790         [ResourceExposure(ResourceScope.Machine)]
1791         internal static extern int RegOpenKeyEx(SafeRegistryHandle hKey, String lpSubKey,
1792                     int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
1793
1794         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1795         [ResourceExposure(ResourceScope.Machine)]
1796         internal static extern int RegOpenKeyEx(IntPtr hKey, String lpSubKey,
1797                     int ulOptions, int samDesired, out SafeRegistryHandle hkResult);
1798
1799         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1800         [ResourceExposure(ResourceScope.None)]
1801         internal static extern int RegQueryInfoKey(SafeRegistryHandle hKey, [Out]StringBuilder lpClass,
1802                     int[] lpcbClass, IntPtr lpReserved_MustBeZero, ref int lpcSubKeys,
1803                     int[] lpcbMaxSubKeyLen, int[] lpcbMaxClassLen,
1804                     ref int lpcValues, int[] lpcbMaxValueNameLen,
1805                     int[] lpcbMaxValueLen, int[] lpcbSecurityDescriptor,
1806                     int[] lpftLastWriteTime);
1807
1808         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1809         [ResourceExposure(ResourceScope.None)]
1810         internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
1811                     int[] lpReserved, ref int lpType, [Out] byte[] lpData,
1812                     ref int lpcbData);
1813
1814         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1815         [ResourceExposure(ResourceScope.None)]
1816         internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
1817                     int[] lpReserved, ref int lpType, ref int lpData,
1818                     ref int lpcbData);
1819
1820         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1821         [ResourceExposure(ResourceScope.None)]
1822         internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
1823                     int[] lpReserved, ref int lpType, ref long lpData,
1824                     ref int lpcbData);
1825
1826         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1827         [ResourceExposure(ResourceScope.None)]
1828         internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
1829                      int[] lpReserved, ref int lpType, [Out] char[] lpData,
1830                      ref int lpcbData);
1831
1832         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1833         [ResourceExposure(ResourceScope.None)]
1834         internal static extern int RegQueryValueEx(SafeRegistryHandle hKey, String lpValueName,
1835                     int[] lpReserved, ref int lpType, [Out]StringBuilder lpData,
1836                     ref int lpcbData);
1837
1838         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1839         [ResourceExposure(ResourceScope.None)]
1840         internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
1841                     int Reserved, RegistryValueKind dwType, byte[] lpData, int cbData);
1842
1843         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1844         [ResourceExposure(ResourceScope.None)]
1845         internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
1846                     int Reserved, RegistryValueKind dwType, ref int lpData, int cbData);
1847
1848         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1849         [ResourceExposure(ResourceScope.None)]
1850         internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
1851                     int Reserved, RegistryValueKind dwType, ref long lpData, int cbData);
1852
1853         [DllImport(ADVAPI32, CharSet=CharSet.Auto, BestFitMapping=false)]
1854         [ResourceExposure(ResourceScope.None)]
1855         internal static extern int RegSetValueEx(SafeRegistryHandle hKey, String lpValueName,
1856                     int Reserved, RegistryValueKind dwType, String lpData, int cbData);
1857
1858         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1859         [ResourceExposure(ResourceScope.None)]
1860         internal static extern int ExpandEnvironmentStrings(String lpSrc, [Out]StringBuilder lpDst, int nSize);
1861
1862         [DllImport(KERNEL32)]
1863         [ResourceExposure(ResourceScope.None)]
1864         internal static extern IntPtr LocalReAlloc(IntPtr handle, IntPtr sizetcbBytes, int uFlags);
1865 #endif // !FEATURE_PAL
1866
1867         internal const int SHGFP_TYPE_CURRENT               = 0;      // the current (user) folder path setting
1868         internal const int UOI_FLAGS                        = 1;
1869         internal const int WSF_VISIBLE                      = 1;
1870
1871 //////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
1872 //////!!!!!! Keep the following locations synchronized            !!!!!!////////
1873 //////!!!!!! 1) ndp\clr\src\BCL\Microsoft\Win32\Win32Native.cs    !!!!!!////////
1874 //////!!!!!! 2) ndp\clr\src\BCL\System\Environment.cs             !!!!!!////////
1875 //////!!!!!! 3) rotor\pal\inc\rotor_pal.h                         !!!!!!////////
1876 //////!!!!!! 4) rotor\pal\corunix\shfolder\shfolder.cpp           !!!!!!////////
1877 //////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
1878 /*<
1879
1880
1881
1882
1883
1884
1885
1886
1887
1888
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899
1900
1901
1902
1903 */
1904         // .NET Framework 4.0 and newer - all versions of windows ||| \public\sdk\inc\shlobj.h
1905         internal const int CSIDL_FLAG_CREATE                = 0x8000; // force folder creation in SHGetFolderPath
1906         internal const int CSIDL_FLAG_DONT_VERIFY           = 0x4000; // return an unverified folder path
1907         internal const int CSIDL_ADMINTOOLS                 = 0x0030; // <user name>\Start Menu\Programs\Administrative Tools
1908         internal const int CSIDL_CDBURN_AREA                = 0x003b; // USERPROFILE\Local Settings\Application Data\Microsoft\CD Burning
1909         internal const int CSIDL_COMMON_ADMINTOOLS          = 0x002f; // All Users\Start Menu\Programs\Administrative Tools
1910         internal const int CSIDL_COMMON_DOCUMENTS           = 0x002e; // All Users\Documents
1911         internal const int CSIDL_COMMON_MUSIC               = 0x0035; // All Users\My Music
1912         internal const int CSIDL_COMMON_OEM_LINKS           = 0x003a; // Links to All Users OEM specific apps
1913         internal const int CSIDL_COMMON_PICTURES            = 0x0036; // All Users\My Pictures
1914         internal const int CSIDL_COMMON_STARTMENU           = 0x0016; // All Users\Start Menu
1915         internal const int CSIDL_COMMON_PROGRAMS            = 0X0017; // All Users\Start Menu\Programs
1916         internal const int CSIDL_COMMON_STARTUP             = 0x0018; // All Users\Startup
1917         internal const int CSIDL_COMMON_DESKTOPDIRECTORY    = 0x0019; // All Users\Desktop
1918         internal const int CSIDL_COMMON_TEMPLATES           = 0x002d; // All Users\Templates
1919         internal const int CSIDL_COMMON_VIDEO               = 0x0037; // All Users\My Video
1920         internal const int CSIDL_FONTS                      = 0x0014; // windows\fonts
1921         internal const int CSIDL_MYVIDEO                    = 0x000e; // "My Videos" folder
1922         internal const int CSIDL_NETHOOD                    = 0x0013; // %APPDATA%\Microsoft\Windows\Network Shortcuts
1923         internal const int CSIDL_PRINTHOOD                  = 0x001b; // %APPDATA%\Microsoft\Windows\Printer Shortcuts
1924         internal const int CSIDL_PROFILE                    = 0x0028; // %USERPROFILE% (%SystemDrive%\Users\%USERNAME%)
1925         internal const int CSIDL_PROGRAM_FILES_COMMONX86    = 0x002c; // x86 Program Files\Common on RISC
1926         internal const int CSIDL_PROGRAM_FILESX86           = 0x002a; // x86 C:\Program Files on RISC
1927         internal const int CSIDL_RESOURCES                  = 0x0038; // %windir%\Resources
1928         internal const int CSIDL_RESOURCES_LOCALIZED        = 0x0039; // %windir%\resources\0409 (code page)
1929         internal const int CSIDL_SYSTEMX86                  = 0x0029; // %windir%\system32
1930         internal const int CSIDL_WINDOWS                    = 0x0024; // GetWindowsDirectory()
1931
1932         // .NET Framework 3.5 and earlier - all versions of windows
1933         internal const int CSIDL_APPDATA                    = 0x001a;
1934         internal const int CSIDL_COMMON_APPDATA             = 0x0023;
1935         internal const int CSIDL_LOCAL_APPDATA              = 0x001c;
1936         internal const int CSIDL_COOKIES                    = 0x0021;
1937         internal const int CSIDL_FAVORITES                  = 0x0006;
1938         internal const int CSIDL_HISTORY                    = 0x0022;
1939         internal const int CSIDL_INTERNET_CACHE             = 0x0020;
1940         internal const int CSIDL_PROGRAMS                   = 0x0002;
1941         internal const int CSIDL_RECENT                     = 0x0008;
1942         internal const int CSIDL_SENDTO                     = 0x0009;
1943         internal const int CSIDL_STARTMENU                  = 0x000b;
1944         internal const int CSIDL_STARTUP                    = 0x0007;
1945         internal const int CSIDL_SYSTEM                     = 0x0025;
1946         internal const int CSIDL_TEMPLATES                  = 0x0015;
1947         internal const int CSIDL_DESKTOPDIRECTORY           = 0x0010;
1948         internal const int CSIDL_PERSONAL                   = 0x0005;
1949         internal const int CSIDL_PROGRAM_FILES              = 0x0026;
1950         internal const int CSIDL_PROGRAM_FILES_COMMON       = 0x002b;
1951         internal const int CSIDL_DESKTOP                    = 0x0000;
1952         internal const int CSIDL_DRIVES                     = 0x0011;
1953         internal const int CSIDL_MYMUSIC                    = 0x000d;
1954         internal const int CSIDL_MYPICTURES                 = 0x0027;
1955
1956         [DllImport(SHELL32, CharSet=CharSet.Auto, BestFitMapping=false)]
1957         [ResourceExposure(ResourceScope.Machine)]
1958         internal static extern int SHGetFolderPath(IntPtr hwndOwner, int nFolder, IntPtr hToken, int dwFlags, [Out]StringBuilder lpszPath);
1959
1960 #if !FEATURE_PAL
1961         internal const int NameSamCompatible = 2;
1962
1963         [ResourceExposure(ResourceScope.None)]
1964         [DllImport(SECUR32, CharSet=CharSet.Unicode, SetLastError=true)]
1965         // Win32 return type is BOOLEAN (which is 1 byte and not BOOL which is 4bytes)
1966         internal static extern byte GetUserNameEx(int format, [Out]StringBuilder domainName, ref uint domainNameLen);
1967
1968         [DllImport(ADVAPI32, CharSet=CharSet.Auto, SetLastError=true, BestFitMapping=false)]
1969         [ResourceExposure(ResourceScope.None)]
1970         internal static extern bool LookupAccountName(string machineName, string accountName, byte[] sid,
1971                                  ref int sidLen, [Out]StringBuilder domainName, ref uint domainNameLen, out int peUse);
1972
1973         // Note: This returns a handle, but it shouldn't be closed.  The Avalon
1974         // team says CloseWindowStation would ignore this handle.  So there
1975         // isn't a lot of value to switching to SafeHandle here.
1976         [DllImport(USER32, ExactSpelling=true)]
1977         [ResourceExposure(ResourceScope.Machine)]
1978         internal static extern IntPtr GetProcessWindowStation();
1979
1980         [DllImport(USER32, SetLastError=true)]
1981         [ResourceExposure(ResourceScope.None)]
1982         internal static extern bool GetUserObjectInformation(IntPtr hObj, int nIndex,
1983             [MarshalAs(UnmanagedType.LPStruct)] USEROBJECTFLAGS pvBuffer, int nLength, ref int lpnLengthNeeded);
1984
1985         [DllImport(USER32, SetLastError=true, BestFitMapping=false)]
1986         [ResourceExposure(ResourceScope.Machine)]
1987         internal static extern IntPtr SendMessageTimeout(IntPtr hWnd, int Msg, IntPtr wParam, String lParam, uint fuFlags, uint uTimeout, IntPtr lpdwResult);
1988
1989         [StructLayout(LayoutKind.Sequential)]
1990         internal class USEROBJECTFLAGS {
1991             internal int fInherit = 0;
1992             internal int fReserved = 0;
1993             internal int dwFlags = 0;
1994         }
1995
1996         //
1997         // DPAPI
1998         //
1999
2000         //
2001         // RtlEncryptMemory and RtlDecryptMemory are declared in the internal header file crypt.h.
2002         // They were also recently declared in the public header file ntsecapi.h (in the Platform SDK as well as the current build of Server 2003).
2003         // We use them instead of CryptProtectMemory and CryptUnprotectMemory because
2004         // they are available in both WinXP and in Windows Server 2003.
2005         //
2006
2007         [DllImport(Win32Native.ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2008         [ResourceExposure(ResourceScope.None)]
2009         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
2010         internal static extern
2011         int SystemFunction040 (
2012             [In,Out] SafeBSTRHandle     pDataIn,
2013             [In]     uint       cbDataIn,   // multiple of RTL_ENCRYPT_MEMORY_SIZE
2014             [In]     uint       dwFlags);
2015
2016         [DllImport(Win32Native.ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2017         [ResourceExposure(ResourceScope.None)]
2018         internal static extern
2019         int SystemFunction041 (
2020             [In,Out] SafeBSTRHandle     pDataIn,
2021             [In]     uint       cbDataIn,   // multiple of RTL_ENCRYPT_MEMORY_SIZE
2022             [In]     uint       dwFlags);
2023
2024 #if FEATURE_CORECLR
2025         [DllImport(NTDLL, CharSet=CharSet.Unicode, SetLastError=true)]
2026         [ResourceExposure(ResourceScope.None)]
2027         internal static extern
2028         int RtlNtStatusToDosError (
2029             [In]    int         status);
2030 #else
2031         // identical to RtlNtStatusToDosError, but we are in ask mode for desktop CLR
2032         [DllImport(ADVAPI32, CharSet = CharSet.Unicode, SetLastError = true)]
2033         [ResourceExposure(ResourceScope.None)]
2034         internal static extern
2035         int LsaNtStatusToWinError (
2036             [In]    int         status);
2037 #endif
2038         // Get the current FIPS policy setting on Vista and above
2039         [DllImport("bcrypt.dll")]
2040         [ResourceExposure(ResourceScope.Machine)]
2041         internal static extern uint BCryptGetFipsAlgorithmMode(
2042                 [MarshalAs(UnmanagedType.U1), Out]out bool pfEnabled);
2043
2044         //
2045         // Managed ACLs
2046         //
2047
2048         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
2049         [DllImport(ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2050         [ResourceExposure(ResourceScope.None)]
2051         internal static extern
2052         bool AdjustTokenPrivileges (
2053             [In]     SafeAccessTokenHandle TokenHandle,
2054             [In]     bool                  DisableAllPrivileges,
2055             [In]     ref TOKEN_PRIVILEGE   NewState,
2056             [In]     uint                  BufferLength,
2057             [In,Out] ref TOKEN_PRIVILEGE   PreviousState,
2058             [In,Out] ref uint              ReturnLength);
2059
2060         [DllImport(ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2061         [ResourceExposure(ResourceScope.None)]
2062         internal static extern
2063         bool AllocateLocallyUniqueId(
2064             [In,Out] ref LUID              Luid);
2065
2066         [DllImport(ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2067         [ResourceExposure(ResourceScope.None)]
2068         internal static extern
2069         bool CheckTokenMembership(
2070             [In]     SafeAccessTokenHandle  TokenHandle,
2071             [In]     byte[]                 SidToCheck,
2072             [In,Out] ref bool               IsMember);
2073
2074         [DllImport(
2075              ADVAPI32,
2076              EntryPoint="ConvertSecurityDescriptorToStringSecurityDescriptorW",
2077              CallingConvention=CallingConvention.Winapi,
2078              SetLastError=true,
2079              ExactSpelling=true,
2080              CharSet=CharSet.Unicode)]
2081         [ResourceExposure(ResourceScope.None)]
2082         internal static extern BOOL ConvertSdToStringSd(
2083             byte[] securityDescriptor,
2084             /* DWORD */ uint requestedRevision,
2085             ULONG securityInformation,
2086             out IntPtr resultString,
2087             ref ULONG resultStringLength );
2088
2089         [DllImport(
2090              ADVAPI32,
2091              EntryPoint="ConvertStringSecurityDescriptorToSecurityDescriptorW",
2092              CallingConvention=CallingConvention.Winapi,
2093              SetLastError=true,
2094              ExactSpelling=true,
2095              CharSet=CharSet.Unicode)]
2096         [ResourceExposure(ResourceScope.None)]
2097         internal static extern BOOL ConvertStringSdToSd(
2098             string stringSd,
2099             /* DWORD */ uint stringSdRevision,
2100             out IntPtr resultSd,
2101             ref ULONG resultSdLength );
2102
2103         [DllImport(
2104              ADVAPI32,
2105              EntryPoint="ConvertStringSidToSidW",
2106              CallingConvention=CallingConvention.Winapi,
2107              SetLastError=true,
2108              ExactSpelling=true,
2109              CharSet=CharSet.Unicode)]
2110         [ResourceExposure(ResourceScope.None)]
2111         internal static extern BOOL ConvertStringSidToSid(
2112             string stringSid,
2113             out IntPtr ByteArray
2114             );
2115
2116         [DllImport(
2117            ADVAPI32,
2118            EntryPoint = "ConvertSidToStringSidW",
2119            CallingConvention = CallingConvention.Winapi,
2120            SetLastError = true,
2121            ExactSpelling = true,
2122            CharSet = CharSet.Unicode)]
2123         [ResourceExposure(ResourceScope.None)]
2124         [return: MarshalAs(UnmanagedType.Bool)]
2125         internal static extern bool ConvertSidToStringSid(
2126             IntPtr Sid,
2127             ref IntPtr StringSid
2128             );
2129
2130
2131         [DllImport(
2132              ADVAPI32,
2133              EntryPoint="CreateWellKnownSid",
2134              CallingConvention=CallingConvention.Winapi,
2135              SetLastError=true,
2136              ExactSpelling=true,
2137              CharSet=CharSet.Unicode)]
2138         [ResourceExposure(ResourceScope.None)]
2139         internal static extern BOOL CreateWellKnownSid(
2140             int sidType,
2141             byte[] domainSid,
2142             [Out] byte[] resultSid,
2143             ref /*DWORD*/ uint resultSidLength );
2144
2145         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
2146         [ResourceExposure(ResourceScope.Machine)]
2147         internal static extern
2148         bool DuplicateHandle (
2149             [In]     IntPtr                     hSourceProcessHandle,
2150             [In]     IntPtr                     hSourceHandle,
2151             [In]     IntPtr                     hTargetProcessHandle,
2152             [In,Out] ref SafeAccessTokenHandle  lpTargetHandle,
2153             [In]     uint                       dwDesiredAccess,
2154             [In]     bool                       bInheritHandle,
2155             [In]     uint                       dwOptions);
2156
2157         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
2158         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
2159         [ResourceExposure(ResourceScope.Machine)]
2160         internal static extern
2161         bool DuplicateHandle (
2162             [In]     IntPtr                     hSourceProcessHandle,
2163             [In]     SafeAccessTokenHandle      hSourceHandle,
2164             [In]     IntPtr                     hTargetProcessHandle,
2165             [In,Out] ref SafeAccessTokenHandle  lpTargetHandle,
2166             [In]     uint                       dwDesiredAccess,
2167             [In]     bool                       bInheritHandle,
2168             [In]     uint                       dwOptions);
2169
2170 #if FEATURE_IMPERSONATION
2171         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
2172         [DllImport(ADVAPI32, CharSet=CharSet.Auto, SetLastError=true)]
2173         [ResourceExposure(ResourceScope.None)]
2174         internal static extern
2175         bool DuplicateTokenEx (
2176             [In]     SafeAccessTokenHandle       ExistingTokenHandle,
2177             [In]     TokenAccessLevels           DesiredAccess,
2178             [In]     IntPtr                      TokenAttributes,
2179             [In]     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel,
2180             [In]     System.Security.Principal.TokenType TokenType,
2181             [In,Out] ref SafeAccessTokenHandle   DuplicateTokenHandle );
2182
2183         [DllImport(ADVAPI32, CharSet=CharSet.Auto, SetLastError=true)]
2184         [ResourceExposure(ResourceScope.None)]
2185         internal static extern
2186         bool DuplicateTokenEx (
2187             [In]     SafeAccessTokenHandle      hExistingToken,
2188             [In]     uint                       dwDesiredAccess,
2189             [In]     IntPtr                     lpTokenAttributes,   // LPSECURITY_ATTRIBUTES
2190             [In]     uint                       ImpersonationLevel,
2191             [In]     uint                       TokenType,
2192             [In,Out] ref SafeAccessTokenHandle  phNewToken);
2193 #endif
2194         [DllImport(
2195              ADVAPI32,
2196              EntryPoint="EqualDomainSid",
2197              CallingConvention=CallingConvention.Winapi,
2198              SetLastError=true,
2199              ExactSpelling=true,
2200              CharSet=CharSet.Unicode)]
2201         [ResourceExposure(ResourceScope.None)]
2202         internal static extern BOOL IsEqualDomainSid(
2203             byte[] sid1,
2204             byte[] sid2,
2205             out bool result);
2206
2207         [DllImport(KERNEL32, CharSet=CharSet.Auto, SetLastError=true)]
2208         [ResourceExposure(ResourceScope.Process)]
2209         internal static extern IntPtr GetCurrentProcess();
2210
2211         [DllImport(KERNEL32, CharSet = CharSet.Auto, SetLastError = true)]
2212         [ResourceExposure(ResourceScope.Process)]
2213         internal static extern IntPtr GetCurrentThread();
2214
2215         [DllImport(
2216              ADVAPI32,
2217              EntryPoint="GetSecurityDescriptorLength",
2218              CallingConvention=CallingConvention.Winapi,
2219              SetLastError=true,
2220              ExactSpelling=true,
2221              CharSet=CharSet.Unicode)]
2222         [ResourceExposure(ResourceScope.None)]
2223         internal static extern /*DWORD*/ uint GetSecurityDescriptorLength(
2224             IntPtr byteArray );
2225
2226         [DllImport(
2227              ADVAPI32,
2228              EntryPoint="GetSecurityInfo",
2229              CallingConvention=CallingConvention.Winapi,
2230              SetLastError=true,
2231              ExactSpelling=true,
2232              CharSet=CharSet.Unicode)]
2233         [ResourceExposure(ResourceScope.None)]
2234         internal static extern /*DWORD*/ uint GetSecurityInfoByHandle(
2235             SafeHandle handle,
2236             /*DWORD*/ uint objectType,
2237             /*DWORD*/ uint securityInformation,
2238             out IntPtr sidOwner,
2239             out IntPtr sidGroup,
2240             out IntPtr dacl,
2241             out IntPtr sacl,
2242             out IntPtr securityDescriptor );
2243
2244         [DllImport(
2245              ADVAPI32,
2246              EntryPoint="GetNamedSecurityInfoW",
2247              CallingConvention=CallingConvention.Winapi,
2248              SetLastError=true,
2249              ExactSpelling=true,
2250              CharSet=CharSet.Unicode)]
2251         [ResourceExposure(ResourceScope.None)]
2252         internal static extern /*DWORD*/ uint GetSecurityInfoByName(
2253             string name,
2254             /*DWORD*/ uint objectType,
2255             /*DWORD*/ uint securityInformation,
2256             out IntPtr sidOwner,
2257             out IntPtr sidGroup,
2258             out IntPtr dacl,
2259             out IntPtr sacl,
2260             out IntPtr securityDescriptor );
2261
2262         [DllImport(ADVAPI32, CharSet=CharSet.Auto, SetLastError=true)]
2263         [ResourceExposure(ResourceScope.None)]
2264         internal static extern
2265         bool GetTokenInformation (
2266             [In]  IntPtr                TokenHandle,
2267             [In]  uint                  TokenInformationClass,
2268             [In]  SafeLocalAllocHandle  TokenInformation,
2269             [In]  uint                  TokenInformationLength,
2270             [Out] out uint              ReturnLength);
2271
2272         [DllImport(ADVAPI32, CharSet=CharSet.Auto, SetLastError=true)]
2273         [ResourceExposure(ResourceScope.None)]
2274         internal static extern
2275         bool GetTokenInformation (
2276             [In]  SafeAccessTokenHandle TokenHandle,
2277             [In]  uint                  TokenInformationClass,
2278             [In]  SafeLocalAllocHandle  TokenInformation,
2279             [In]  uint                  TokenInformationLength,
2280             [Out] out uint              ReturnLength);
2281
2282         [DllImport(
2283              ADVAPI32,
2284              EntryPoint="GetWindowsAccountDomainSid",
2285              CallingConvention=CallingConvention.Winapi,
2286              SetLastError=true,
2287              ExactSpelling=true,
2288              CharSet=CharSet.Unicode)]
2289         [ResourceExposure(ResourceScope.None)]
2290         internal static extern BOOL GetWindowsAccountDomainSid(
2291             byte[] sid,
2292             [Out] byte[] resultSid,
2293             ref /*DWORD*/ uint  resultSidLength );
2294
2295         internal enum SECURITY_IMPERSONATION_LEVEL
2296         {
2297             Anonymous = 0,
2298             Identification = 1,
2299             Impersonation = 2,
2300             Delegation = 3,
2301         }
2302
2303         // Structures and definitions for Claims that are being introduced in Win8
2304         // inside the NTTOken - see winnt.h.  They will be surfaced through WindowsIdentity.Claims
2305
2306         // CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID -> 0x00
2307         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID = 0;
2308
2309         // CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64 -> 0x01
2310         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64 = 1;
2311
2312         // CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64 -> 0x02
2313         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64 = 2;
2314
2315         // CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING -> 0x03
2316         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING = 3;
2317
2318         // CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN -> 0x04
2319         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN = 4;
2320
2321         // CLAIM_SECURITY_ATTRIBUTE_TYPE_SID -> 0x05
2322         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_SID = 5;
2323
2324         // CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN -> 0x06
2325         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN = 6;
2326
2327         // CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING -> 0x10
2328         internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING = 16;
2329
2330         // CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE -> 0x0001
2331         internal const int CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE = 1;
2332
2333         // CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE -> 0x0002
2334         internal const int CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE = 2;
2335
2336         // CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY -> 0x0004
2337         internal const int CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY = 4;
2338
2339         // CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT -> 0x0008
2340         internal const int CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT = 8;
2341
2342         // CLAIM_SECURITY_ATTRIBUTE_DISABLED -> 0x0010
2343         internal const int CLAIM_SECURITY_ATTRIBUTE_DISABLED = 16;
2344
2345         // CLAIM_SECURITY_ATTRIBUTE_MANDATORY -> 0x0020
2346         internal const int CLAIM_SECURITY_ATTRIBUTE_MANDATORY = 32;
2347
2348         internal const int CLAIM_SECURITY_ATTRIBUTE_VALID_FLAGS =
2349                       CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE
2350                     | CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE
2351                     | CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY
2352                     | CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT
2353                     | CLAIM_SECURITY_ATTRIBUTE_DISABLED
2354                     | CLAIM_SECURITY_ATTRIBUTE_MANDATORY;
2355
2356
2357         [StructLayoutAttribute( LayoutKind.Explicit )]
2358         internal struct CLAIM_SECURITY_ATTRIBUTE_INFORMATION_V1
2359         {
2360             // defined as union in CLAIM_SECURITY_ATTRIBUTES_INFORMATION
2361             [FieldOffsetAttribute( 0 )]
2362             public IntPtr pAttributeV1;
2363         }
2364
2365         [StructLayoutAttribute( LayoutKind.Sequential )]
2366         internal struct CLAIM_SECURITY_ATTRIBUTES_INFORMATION
2367         {
2368             /// WORD->unsigned short
2369             public ushort Version;
2370
2371             /// WORD->unsigned short
2372             public ushort Reserved;
2373
2374             /// DWORD->unsigned int
2375             public uint AttributeCount;
2376
2377             /// CLAIM_SECURITY_ATTRIBUTE_V1
2378             public CLAIM_SECURITY_ATTRIBUTE_INFORMATION_V1 Attribute;
2379         }
2380
2381         //
2382         //  Fully-qualified binary name.
2383         //
2384         [StructLayoutAttribute( LayoutKind.Sequential, CharSet = CharSet.Unicode )]
2385         internal struct CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE
2386         {
2387             // DWORD64->unsigned __int64
2388             public ulong Version;
2389
2390             // PWSTR->WCHAR*
2391             [MarshalAsAttribute( UnmanagedType.LPWStr )]
2392             public string Name;
2393         }
2394
2395         [StructLayoutAttribute( LayoutKind.Sequential, CharSet = CharSet.Unicode )]
2396         internal struct CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE
2397         {
2398             /// PVOID->void*
2399             public IntPtr pValue;
2400
2401             /// DWORD->unsigned int
2402             public uint ValueLength;
2403         }
2404
2405         [StructLayoutAttribute( LayoutKind.Explicit, CharSet = CharSet.Unicode )]
2406         internal struct CLAIM_VALUES_ATTRIBUTE_V1
2407         {
2408             // PLONG64->__int64*
2409             [FieldOffsetAttribute( 0 )]
2410             public IntPtr pInt64;
2411
2412             // PDWORD64->unsigned __int64*
2413             [FieldOffsetAttribute( 0 )]
2414             public IntPtr pUint64;
2415
2416             // PWSTR*
2417             [FieldOffsetAttribute( 0 )]
2418             public IntPtr ppString;
2419
2420             // PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE->_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE*
2421             [FieldOffsetAttribute( 0 )]
2422             public IntPtr pFqbn;
2423
2424             // PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE->_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE*
2425             [FieldOffsetAttribute( 0 )]
2426             public IntPtr pOctetString;
2427         }
2428
2429         [StructLayoutAttribute( LayoutKind.Sequential, CharSet = CharSet.Unicode )]
2430         internal struct CLAIM_SECURITY_ATTRIBUTE_V1
2431         {
2432             // PWSTR->WCHAR*
2433             [MarshalAsAttribute( UnmanagedType.LPWStr )]
2434             public string Name;
2435
2436             // WORD->unsigned short
2437             public ushort ValueType;
2438
2439             // WORD->unsigned short
2440             public ushort Reserved;
2441
2442             // DWORD->unsigned int
2443             public uint Flags;
2444
2445             // DWORD->unsigned int
2446             public uint ValueCount;
2447
2448             // struct CLAIM_VALUES - a union of 4 possible values
2449             public CLAIM_VALUES_ATTRIBUTE_V1 Values;
2450         }
2451
2452         [DllImport(
2453              ADVAPI32,
2454              EntryPoint="IsWellKnownSid",
2455              CallingConvention=CallingConvention.Winapi,
2456              SetLastError=true,
2457              ExactSpelling=true,
2458              CharSet=CharSet.Unicode)]
2459         [ResourceExposure(ResourceScope.None)]
2460         internal static extern BOOL IsWellKnownSid(
2461             byte[] sid,
2462             int type );
2463
2464         [DllImport(
2465             ADVAPI32,
2466             EntryPoint="LsaOpenPolicy",
2467             CallingConvention=CallingConvention.Winapi,
2468             SetLastError=true,
2469             ExactSpelling=true,
2470             CharSet=CharSet.Unicode)]
2471         [ResourceExposure(ResourceScope.None)]
2472         internal static extern /*DWORD*/ uint LsaOpenPolicy(
2473             string systemName,
2474             ref LSA_OBJECT_ATTRIBUTES attributes,
2475             int accessMask,
2476             out SafeLsaPolicyHandle handle
2477             );
2478
2479         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.MayFail)]
2480         [DllImport(
2481             ADVAPI32,
2482             EntryPoint="LookupPrivilegeValueW",
2483             CharSet=CharSet.Auto,
2484             SetLastError=true,
2485             ExactSpelling=true,
2486             BestFitMapping=false)]
2487         [ResourceExposure(ResourceScope.None)]
2488         internal static extern
2489         bool LookupPrivilegeValue (
2490             [In]     string             lpSystemName,
2491             [In]     string             lpName,
2492             [In,Out] ref LUID           Luid);
2493
2494         [DllImport(
2495             ADVAPI32,
2496             EntryPoint="LsaLookupSids",
2497             CallingConvention=CallingConvention.Winapi,
2498             SetLastError=true,
2499             ExactSpelling=true,
2500             CharSet=CharSet.Unicode)]
2501         [ResourceExposure(ResourceScope.None)]
2502         internal static extern /*DWORD*/ uint LsaLookupSids(
2503             SafeLsaPolicyHandle handle,
2504             int count,
2505             IntPtr[] sids,
2506             ref SafeLsaMemoryHandle referencedDomains,
2507             ref SafeLsaMemoryHandle names
2508             );
2509
2510         [DllImport(ADVAPI32, SetLastError=true)]
2511         [ResourceExposure(ResourceScope.None)]
2512         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
2513         internal static extern int LsaFreeMemory( IntPtr handle );
2514
2515         [DllImport(
2516             ADVAPI32,
2517             EntryPoint="LsaLookupNames",
2518             CallingConvention=CallingConvention.Winapi,
2519             SetLastError=true,
2520             ExactSpelling=true,
2521             CharSet=CharSet.Unicode)]
2522         [ResourceExposure(ResourceScope.None)]
2523         internal static extern /*DWORD*/ uint LsaLookupNames(
2524             SafeLsaPolicyHandle handle,
2525             int count,
2526             UNICODE_STRING[] names,
2527             ref SafeLsaMemoryHandle referencedDomains,
2528             ref SafeLsaMemoryHandle sids
2529             );
2530
2531         [DllImport(
2532             ADVAPI32,
2533             EntryPoint="LsaLookupNames2",
2534             CallingConvention=CallingConvention.Winapi,
2535             SetLastError=true,
2536             ExactSpelling=true,
2537             CharSet=CharSet.Unicode)]
2538         [ResourceExposure(ResourceScope.None)]
2539         internal static extern /*DWORD*/ uint LsaLookupNames2(
2540             SafeLsaPolicyHandle handle,
2541             int flags,
2542             int count,
2543             UNICODE_STRING[] names,
2544             ref SafeLsaMemoryHandle referencedDomains,
2545             ref SafeLsaMemoryHandle sids
2546             );
2547
2548         [DllImport(SECUR32, CharSet=CharSet.Auto, SetLastError=true)]
2549         [ResourceExposure(ResourceScope.None)]
2550         internal static extern
2551         int LsaConnectUntrusted (
2552             [In,Out] ref SafeLsaLogonProcessHandle LsaHandle);
2553
2554         [DllImport(SECUR32, CharSet=CharSet.Auto, SetLastError=true)]
2555         [ResourceExposure(ResourceScope.None)]
2556         internal static extern
2557         int LsaGetLogonSessionData (
2558             [In]     ref LUID                      LogonId,
2559             [In,Out] ref SafeLsaReturnBufferHandle ppLogonSessionData);
2560
2561         [DllImport(SECUR32, CharSet=CharSet.Auto, SetLastError=true)]
2562         [ResourceExposure(ResourceScope.None)]
2563         internal static extern
2564         int LsaLogonUser (
2565             [In]     SafeLsaLogonProcessHandle      LsaHandle,
2566             [In]     ref UNICODE_INTPTR_STRING      OriginName,
2567             [In]     uint                           LogonType,
2568             [In]     uint                           AuthenticationPackage,
2569             [In]     IntPtr                         AuthenticationInformation,
2570             [In]     uint                           AuthenticationInformationLength,
2571             [In]     IntPtr                         LocalGroups,
2572             [In]     ref TOKEN_SOURCE               SourceContext,
2573             [In,Out] ref SafeLsaReturnBufferHandle  ProfileBuffer,
2574             [In,Out] ref uint                       ProfileBufferLength,
2575             [In,Out] ref LUID                       LogonId,
2576             [In,Out] ref SafeAccessTokenHandle      Token,
2577             [In,Out] ref QUOTA_LIMITS               Quotas,
2578             [In,Out] ref int                        SubStatus);
2579
2580         [DllImport(SECUR32, CharSet=CharSet.Auto, SetLastError=true)]
2581         [ResourceExposure(ResourceScope.None)]
2582         internal static extern
2583         int LsaLookupAuthenticationPackage (
2584             [In]     SafeLsaLogonProcessHandle LsaHandle,
2585             [In]     ref UNICODE_INTPTR_STRING PackageName,
2586             [In,Out] ref uint                  AuthenticationPackage);
2587
2588         [DllImport(SECUR32, CharSet=CharSet.Auto, SetLastError=true)]
2589         [ResourceExposure(ResourceScope.None)]
2590         internal static extern
2591         int LsaRegisterLogonProcess (
2592             [In]     ref UNICODE_INTPTR_STRING     LogonProcessName,
2593             [In,Out] ref SafeLsaLogonProcessHandle LsaHandle,
2594             [In,Out] ref IntPtr                    SecurityMode);
2595
2596         [DllImport(SECUR32, SetLastError=true)]
2597         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
2598         [ResourceExposure(ResourceScope.None)]
2599         internal static extern int LsaDeregisterLogonProcess(IntPtr handle);
2600
2601         [DllImport(ADVAPI32, SetLastError=true)]
2602         [ResourceExposure(ResourceScope.None)]
2603         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
2604         internal static extern int LsaClose( IntPtr handle );
2605
2606         [DllImport(SECUR32, SetLastError=true)]
2607         [ResourceExposure(ResourceScope.None)]
2608         [ReliabilityContract(Consistency.WillNotCorruptState, Cer.Success)]
2609         internal static extern int LsaFreeReturnBuffer(IntPtr handle);
2610
2611 #if FEATURE_IMPERSONATION || FEATURE_CORECLR
2612         [DllImport (ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2613         [ResourceExposure(ResourceScope.Process)]
2614         internal static extern
2615         bool OpenProcessToken (
2616             [In]     IntPtr                     ProcessToken,
2617             [In]     TokenAccessLevels          DesiredAccess,
2618             [Out]    out SafeAccessTokenHandle  TokenHandle);
2619 #endif
2620
2621 #if FEATURE_CORECLR
2622         [DllImport (ADVAPI32, CharSet=CharSet.Unicode, SetLastError=true)]
2623         [ResourceExposure(ResourceScope.Process)]
2624         [return: MarshalAs(UnmanagedType.Bool)]
2625         internal static extern
2626         bool OpenThreadToken (
2627             [In]     IntPtr                     ThreadHandle,
2628             [In]     TokenAccessLevels          DesiredAccess,
2629             [In, MarshalAs(UnmanagedType.Bool)]     bool OpenAsSelf,
2630             [Out]    out SafeAccessTokenHandle  TokenHandle);
2631 #endif
2632
2633         [DllImport(
2634              ADVAPI32,
2635              EntryPoint="SetNamedSecurityInfoW",
2636              CallingConvention=CallingConvention.Winapi,
2637              SetLastError=true,
2638              ExactSpelling=true,
2639              CharSet=CharSet.Unicode)]
2640         [ResourceExposure(ResourceScope.Machine)]
2641         internal static extern /*DWORD*/ uint SetSecurityInfoByName(
2642             string name,
2643             /*DWORD*/ uint objectType,
2644             /*DWORD*/ uint securityInformation,
2645             byte[] owner,
2646             byte[] group,
2647             byte[] dacl,
2648             byte[] sacl );
2649
2650         [DllImport(
2651              ADVAPI32,
2652              EntryPoint="SetSecurityInfo",
2653              CallingConvention=CallingConvention.Winapi,
2654              SetLastError=true,
2655              ExactSpelling=true,
2656              CharSet=CharSet.Unicode)]
2657         [ResourceExposure(ResourceScope.None)]
2658         internal static extern /*DWORD*/ uint SetSecurityInfoByHandle(
2659             SafeHandle handle,
2660             /*DWORD*/ uint objectType,
2661             /*DWORD*/ uint securityInformation,
2662             byte[] owner,
2663             byte[] group,
2664             byte[] dacl,
2665             byte[] sacl );
2666
2667 #else // FEATURE_PAL
2668
2669         // managed cryptography wrapper around the PALRT cryptography api
2670         internal const int PAL_HCRYPTPROV = 123;
2671
2672         internal const int CALG_MD2         = ((4 << 13) | 1);
2673         internal const int CALG_MD4         = ((4 << 13) | 2);
2674         internal const int CALG_MD5         = ((4 << 13) | 3);
2675         internal const int CALG_SHA         = ((4 << 13) | 4);
2676         internal const int CALG_SHA1        = ((4 << 13) | 4);
2677         internal const int CALG_MAC         = ((4 << 13) | 5);
2678         internal const int CALG_SSL3_SHAMD5 = ((4 << 13) | 8);
2679         internal const int CALG_HMAC        = ((4 << 13) | 9);
2680
2681         internal const int HP_ALGID         = 0x0001;
2682         internal const int HP_HASHVAL       = 0x0002;
2683         internal const int HP_HASHSIZE      = 0x0004;
2684
2685         [DllImport(OLEAUT32, CharSet=CharSet.Unicode)]
2686         [ResourceExposure(ResourceScope.Machine)]
2687         internal extern static bool CryptAcquireContext(out IntPtr hProv,
2688                            [MarshalAs(UnmanagedType.LPWStr)] string container,
2689                            [MarshalAs(UnmanagedType.LPWStr)] string provider,
2690                            int provType,
2691                            int flags);
2692
2693         [DllImport(OLEAUT32, SetLastError=true)]
2694         [ResourceExposure(ResourceScope.None)]
2695         internal extern static bool CryptReleaseContext( IntPtr hProv, int flags);
2696
2697         [DllImport(OLEAUT32, SetLastError=true)]
2698         [ResourceExposure(ResourceScope.None)]
2699         internal extern static bool CryptCreateHash(IntPtr hProv, int Algid, IntPtr hKey, int flags, out IntPtr hHash);
2700
2701         [DllImport(OLEAUT32, SetLastError=true)]
2702         [ResourceExposure(ResourceScope.None)]
2703         internal extern static bool CryptDestroyHash(IntPtr hHash);
2704
2705         [DllImport(OLEAUT32, SetLastError=true)]
2706         [ResourceExposure(ResourceScope.None)]
2707         internal extern static bool CryptHashData(IntPtr hHash,
2708                            [In, MarshalAs(UnmanagedType.LPArray)] byte[] data,
2709                            int length,
2710                            int flags);
2711
2712         [DllImport(OLEAUT32, SetLastError=true)]
2713         [ResourceExposure(ResourceScope.None)]
2714         internal extern static bool CryptGetHashParam(IntPtr hHash,
2715                            int param,
2716                            [Out, MarshalAs(UnmanagedType.LPArray)] byte[] digest,
2717                            ref int length,
2718                            int flags);
2719
2720         [DllImport(OLEAUT32, SetLastError=true)]
2721         [ResourceExposure(ResourceScope.None)]
2722         internal extern static bool CryptGetHashParam(IntPtr hHash,
2723                            int param,
2724                            out int data,
2725                            ref int length,
2726                            int flags);
2727
2728         [DllImport(KERNEL32, EntryPoint="PAL_Random")]
2729         [ResourceExposure(ResourceScope.None)]
2730         internal extern static bool Random(bool bStrong,
2731                            [Out, MarshalAs(UnmanagedType.LPArray)] byte[] buffer, int length);
2732 #endif // FEATURE_PAL
2733
2734         // Fusion APIs
2735 #if FEATURE_FUSION
2736         [DllImport(MSCORWKS, CharSet=CharSet.Unicode)]
2737         [ResourceExposure(ResourceScope.None)]
2738         internal static extern int CreateAssemblyNameObject(out IAssemblyName ppEnum, String szAssemblyName, uint dwFlags, IntPtr pvReserved);
2739
2740         [DllImport(MSCORWKS, CharSet=CharSet.Auto)]
2741         [ResourceExposure(ResourceScope.None)]
2742         internal static extern int CreateAssemblyEnum(out IAssemblyEnum ppEnum, IApplicationContext pAppCtx, IAssemblyName pName, uint dwFlags, IntPtr pvReserved);
2743 #endif // FEATURE_FUSION
2744
2745 #if FEATURE_CORECLR
2746         [DllImport(KERNEL32, CharSet=CharSet.Unicode)]
2747         [SuppressUnmanagedCodeSecurityAttribute()]
2748         internal  unsafe static extern int WideCharToMultiByte(
2749             int     CodePage,
2750             UInt32    dwFlags,
2751             char*  lpWideCharStr,
2752             int      cchWideChar,
2753             byte*    lpMultiByteStr,
2754             int      cchMultiByte,
2755             char*   lpDefaultChar,
2756             bool*   lpUsedDefaultChar);
2757
2758         [DllImport(KERNEL32, CharSet=CharSet.Unicode)]
2759         [SuppressUnmanagedCodeSecurityAttribute()]
2760         internal unsafe static extern int MultiByteToWideChar(
2761             int     CodePage,
2762             UInt32    dwFlags,
2763             byte*    lpMultiByteStr,
2764             int      cchMultiByte,
2765             char*  lpWideCharStr,
2766             int      cchWideChar);
2767 #endif  // FEATURE_CORECLR
2768
2769         [DllImport(KERNEL32, SetLastError = true)]
2770         [return: MarshalAs(UnmanagedType.Bool)]
2771         internal extern static bool QueryUnbiasedInterruptTime(out ulong UnbiasedTime);
2772     }
2773 }