3 // Copyright (c) Microsoft Corporation. All rights reserved.
6 /*============================================================
8 ** Class: Microsoft.Win32.Win32Native
11 ** Purpose: The CLR wrapper for all Win32 as well as
12 ** ROTOR-style Unix PAL, etc. native operations
15 ===========================================================*/
17 * Notes to PInvoke users: Getting the syntax exactly correct is crucial, and
18 * more than a little confusing. Here's some guidelines.
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:
23 * [DllImport(KERNEL32, SetLastError=true, CharSet=CharSet.Auto, BestFitMapping=false)]
24 * private static extern SafeFileHandle CreateFile(...);
26 * [DllImport(KERNEL32, SetLastError=true)]
27 * unsafe internal static extern int ReadFile(SafeFileHandle handle, ...);
29 * [DllImport(KERNEL32, SetLastError=true)]
30 * internal static extern bool CloseHandle(IntPtr handle);
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
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.
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:
56 * bool GetVersionEx(OSVERSIONINFO & lposvi);
59 * you must use EITHER THIS OR THE NEXT syntax:
61 * [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
62 * internal struct OSVERSIONINFO { ... }
64 * [DllImport(KERNEL32, CharSet=CharSet.Auto)]
65 * internal static extern bool GetVersionEx(ref OSVERSIONINFO lposvi);
69 * [StructLayout(LayoutKind.Sequential, CharSet=CharSet.Auto)]
70 * internal class OSVERSIONINFO { ... }
72 * [DllImport(KERNEL32, CharSet=CharSet.Auto)]
73 * internal static extern bool GetVersionEx([In, Out] OSVERSIONINFO lposvi);
75 * Note that classes require being marked as [In, Out] while value types must
76 * be passed as ref parameters.
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);
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.
92 namespace Microsoft
.Win32
{
94 using System
.Security
;
95 using System
.Security
.Principal
;
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
;
106 using BOOL
= System
.Int32
;
107 using DWORD
= System
.UInt32
;
108 using ULONG
= System
.UInt32
;
111 * Win32 encapsulation for MSCORLIB.
113 // Remove the default demands for all P/Invoke methods with this
114 // global declaration on the class.
128 [System
.Security
.SecurityCritical
]
129 [SuppressUnmanagedCodeSecurityAttribute()]
130 internal static class Win32Native
{
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
|
141 KEY_ENUMERATE_SUB_KEYS
|
146 internal const int KEY_WRITE
=((STANDARD_RIGHTS_WRITE
|
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
172 internal const int HWND_BROADCAST
= 0xffff;
173 internal const int WM_SETTINGCHANGE
= 0x001A;
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;
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;
185 // Access Control library.
186 internal const string MICROSOFT_KERBEROS_NAME
= "Kerberos";
187 internal const uint ANONYMOUS_LOGON_LUID
= 0x3e6;
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;
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;
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;
207 internal const uint DUPLICATE_CLOSE_SOURCE
= 0x00000001;
208 internal const uint DUPLICATE_SAME_ACCESS
= 0x00000002;
209 internal const uint DUPLICATE_SAME_ATTRIBUTES
= 0x00000004;
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;
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;
227 internal const int LOAD_LIBRARY_AS_DATAFILE
= 0x00000002;
228 internal const int LOAD_STRING_MAX_LENGTH
= 500;
230 [StructLayout(LayoutKind
.Sequential
)]
231 internal struct SystemTime
{
232 [MarshalAs(UnmanagedType
.U2
)]
234 [MarshalAs(UnmanagedType
.U2
)]
236 [MarshalAs(UnmanagedType
.U2
)]
237 public short DayOfWeek
;
238 [MarshalAs(UnmanagedType
.U2
)]
240 [MarshalAs(UnmanagedType
.U2
)]
242 [MarshalAs(UnmanagedType
.U2
)]
244 [MarshalAs(UnmanagedType
.U2
)]
246 [MarshalAs(UnmanagedType
.U2
)]
247 public short Milliseconds
;
250 [StructLayout(LayoutKind
.Sequential
, CharSet
= CharSet
.Unicode
)]
251 internal struct TimeZoneInformation
{
252 [MarshalAs(UnmanagedType
.I4
)]
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
;
265 public TimeZoneInformation(Win32Native
.DynamicTimeZoneInformation dtzi
) {
267 StandardName
= dtzi
.StandardName
;
268 StandardDate
= dtzi
.StandardDate
;
269 StandardBias
= dtzi
.StandardBias
;
270 DaylightName
= dtzi
.DaylightName
;
271 DaylightDate
= dtzi
.DaylightDate
;
272 DaylightBias
= dtzi
.DaylightBias
;
277 [StructLayout(LayoutKind
.Sequential
, CharSet
= CharSet
.Unicode
)]
278 internal struct DynamicTimeZoneInformation
{
279 [MarshalAs(UnmanagedType
.I4
)]
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
;
298 [StructLayout(LayoutKind
.Sequential
)]
299 internal struct RegistryTimeZoneInformation
{
300 [MarshalAs(UnmanagedType
.I4
)]
302 [MarshalAs(UnmanagedType
.I4
)]
303 public Int32 StandardBias
;
304 [MarshalAs(UnmanagedType
.I4
)]
305 public Int32 DaylightBias
;
306 public SystemTime StandardDate
;
307 public SystemTime DaylightDate
;
309 public RegistryTimeZoneInformation(Win32Native
.TimeZoneInformation tzi
) {
311 StandardDate
= tzi
.StandardDate
;
312 StandardBias
= tzi
.StandardBias
;
313 DaylightDate
= tzi
.DaylightDate
;
314 DaylightBias
= tzi
.DaylightBias
;
317 public RegistryTimeZoneInformation(Byte
[] bytes
) {
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;
343 if (bytes
== null || bytes
.Length
!= 44) {
344 throw new ArgumentException(Environment
.GetResourceString("Argument_InvalidREG_TZI_FORMAT"), "bytes");
346 Bias
= BitConverter
.ToInt32(bytes
, 0);
347 StandardBias
= BitConverter
.ToInt32(bytes
, 4);
348 DaylightBias
= BitConverter
.ToInt32(bytes
, 8);
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);
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);
373 // Win32 ACL-related constants:
374 internal const int READ_CONTROL
= 0x00020000;
375 internal const int SYNCHRONIZE
= 0x00100000;
377 internal const int STANDARD_RIGHTS_READ
= READ_CONTROL
;
378 internal const int STANDARD_RIGHTS_WRITE
= READ_CONTROL
;
380 // STANDARD_RIGHTS_REQUIRED (0x000F0000L)
381 // SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3)
383 // SEMAPHORE and Event both use 0x0002
384 // MUTEX uses 0x001 (MUTANT_QUERY_STATE)
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;
394 internal const int LMEM_FIXED
= 0x0000;
395 internal const int LMEM_ZEROINIT
= 0x0040;
396 internal const int LPTR
= (LMEM_FIXED
| LMEM_ZEROINIT
);
398 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Auto
)]
399 internal class OSVERSIONINFO
{
400 internal OSVERSIONINFO() {
401 OSVersionInfoSize
= (int)Marshal
.SizeOf(this);
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;
414 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Auto
)]
415 internal class OSVERSIONINFOEX
{
417 public OSVERSIONINFOEX() {
418 OSVersionInfoSize
= (int)Marshal
.SizeOf(this);
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;
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
;
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;
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
;
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
;
486 [StructLayout(LayoutKind
.Sequential
)]
487 internal struct FILE_TIME
{
488 public FILE_TIME(long fileTime
) {
489 ftTimeLow
= (uint) fileTime
;
490 ftTimeHigh
= (uint) (fileTime
>> 32);
493 public long ToTicks() {
494 return ((long) ftTimeHigh
<< 32) + ftTimeLow
;
497 internal uint ftTimeLow
;
498 internal uint ftTimeHigh
;
503 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
504 internal struct KERB_S4U_LOGON
{
505 internal uint MessageType
;
507 internal UNICODE_INTPTR_STRING ClientUpn
; // REQUIRED: UPN for client
508 internal UNICODE_INTPTR_STRING ClientRealm
; // Optional: Client Realm, if known
511 [StructLayoutAttribute(LayoutKind
.Sequential
)]
512 internal struct LSA_OBJECT_ATTRIBUTES
{
514 internal IntPtr RootDirectory
;
515 internal IntPtr ObjectName
;
516 internal int Attributes
;
517 internal IntPtr SecurityDescriptor
;
518 internal IntPtr SecurityQualityOfService
;
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
;
528 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
529 internal struct UNICODE_INTPTR_STRING
{
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
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)");
540 this.Length
= (ushort) stringBytes
;
541 this.MaxLength
= (ushort) buffer
.ByteLength
;
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();
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.
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)");
557 this.Length
= (ushort)stringBytes
;
558 this.MaxLength
= (ushort)stringBytes
;
559 this.Buffer
= buffer
;
562 internal ushort Length
;
563 internal ushort MaxLength
;
564 internal IntPtr Buffer
;
567 [StructLayout(LayoutKind
.Sequential
)]
568 internal struct LSA_TRANSLATED_NAME
{
570 internal UNICODE_INTPTR_STRING Name
;
571 internal int DomainIndex
;
574 [StructLayoutAttribute(LayoutKind
.Sequential
)]
575 internal struct LSA_TRANSLATED_SID
{
578 internal int DomainIndex
;
581 [StructLayoutAttribute(LayoutKind
.Sequential
)]
582 internal struct LSA_TRANSLATED_SID2
{
585 internal int DomainIndex
;
589 [StructLayout(LayoutKind
.Sequential
)]
590 internal struct LSA_TRUST_INFORMATION
{
591 internal UNICODE_INTPTR_STRING Name
;
595 [StructLayout(LayoutKind
.Sequential
)]
596 internal struct LSA_REFERENCED_DOMAIN_LIST
{
597 internal int Entries
;
598 internal IntPtr Domains
;
601 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
602 internal struct LUID
{
603 internal uint LowPart
;
604 internal uint HighPart
;
607 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
608 internal struct LUID_AND_ATTRIBUTES
{
610 internal uint Attributes
;
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
;
623 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
624 internal struct SECURITY_LOGON_SESSION_DATA
{
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
;
633 internal long LogonTime
;
636 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
637 internal struct SID_AND_ATTRIBUTES
{
639 internal uint Attributes
;
640 internal static readonly long SizeOf
= (long)Marshal
.SizeOf(typeof(SID_AND_ATTRIBUTES
));
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];
649 [StructLayout(LayoutKind
.Sequential
, CharSet
= CharSet
.Unicode
)]
650 internal struct TOKEN_PRIMARY_GROUP
652 internal IntPtr PrimaryGroup
;
655 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
656 internal struct TOKEN_PRIVILEGE
{
657 internal uint PrivilegeCount
;
658 internal LUID_AND_ATTRIBUTES Privilege
;
661 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
662 internal struct TOKEN_SOURCE
{
663 private const int TOKEN_SOURCE_LENGTH
= 8;
665 [MarshalAs(UnmanagedType
.ByValArray
, SizeConst
=TOKEN_SOURCE_LENGTH
)]
666 internal char[] Name
;
667 internal LUID SourceIdentifier
;
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
;
684 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Unicode
)]
685 internal struct TOKEN_USER
{
686 internal SID_AND_ATTRIBUTES User
;
689 [StructLayout(LayoutKind
.Sequential
)]
690 internal struct MEMORYSTATUSEX
{
691 // The length field must be set to the size of this data structure.
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
;
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
;
710 internal uint Protect
;
713 #endif // !FEATURE_PAL
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
732 internal const int SEM_FAILCRITICALERRORS
= 1;
734 [DllImport(KERNEL32
, SetLastError
=true)]
735 [ResourceExposure(ResourceScope
.None
)]
736 internal static extern void GetSystemInfo(ref SYSTEM_INFO lpSystemInfo
);
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
);
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
);
751 // result is the # of characters copied to the StringBuilder.
752 return StringBuilderCache
.GetStringAndRelease(sb
);
755 StringBuilderCache
.Release(sb
);
756 return Environment
.GetResourceString("UnknownError_Num", errorCode
);
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
);
769 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true)]
770 [ResourceExposure(ResourceScope
.None
)]
771 internal static extern
772 SafeLocalAllocHandle
LocalAlloc(
774 [In
] UIntPtr sizetdwBytes
);
775 #endif // !FEATURE_PAL
777 [DllImport(KERNEL32
, SetLastError
=true)]
778 [ResourceExposure(ResourceScope
.None
)]
779 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
780 internal static extern IntPtr
LocalFree(IntPtr handle
);
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
);
789 internal static bool GlobalMemoryStatusEx(ref MEMORYSTATUSEX buffer
)
791 buffer
.length
= Marshal
.SizeOf(typeof(MEMORYSTATUSEX
));
792 return GlobalMemoryStatusExNative(ref buffer
);
795 [DllImport(KERNEL32
, SetLastError
=true, EntryPoint
="GlobalMemoryStatusEx")]
796 [ResourceExposure(ResourceScope
.None
)]
797 private static extern bool GlobalMemoryStatusExNative([In
, Out
] ref MEMORYSTATUSEX buffer
);
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
);
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
);
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
);
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
);
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
);
832 [System
.Security
.SecurityCritical
] // auto-generated
833 internal static bool DoesWin32MethodExist(String moduleName
, String methodName
)
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?");
841 IntPtr functionPointer
= Win32Native
.GetProcAddress(hModule
, methodName
);
842 return (functionPointer
!= IntPtr
.Zero
);
844 #endif // !FEATURE_PAL
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(
853 IntPtr hSourceProcessHandle
,
854 [Out
, MarshalAs(UnmanagedType
.Bool
)]
857 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
858 [ResourceExposure(ResourceScope
.Machine
)]
859 internal static extern uint GetTempPath(int bufferLen
, [Out
]StringBuilder buffer
);
861 [DllImport(KERNEL32
, CharSet
=CharSet
.Ansi
, ExactSpelling
=true, EntryPoint
="lstrlenA")]
862 [ResourceExposure(ResourceScope
.None
)]
863 internal static extern int lstrlenA(IntPtr ptr
);
865 [DllImport(KERNEL32
, CharSet
=CharSet
.Unicode
, ExactSpelling
=true, EntryPoint
="lstrlenW")]
866 [ResourceExposure(ResourceScope
.None
)]
867 internal static extern int lstrlenW(IntPtr ptr
);
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
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
879 [DllImport(Win32Native
.OLEAUT32
)]
880 [ResourceExposure(ResourceScope
.None
)]
881 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
882 internal static extern uint SysStringByteLen(IntPtr bstr
);
884 [DllImport(Win32Native
.OLEAUT32
)]
885 [ResourceExposure(ResourceScope
.None
)]
886 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
887 internal static extern uint SysStringLen(IntPtr bstr
);
890 [DllImport(Win32Native
.OLEAUT32
)]
891 [ResourceExposure(ResourceScope
.None
)]
892 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
893 internal static extern uint SysStringLen(SafeBSTRHandle bstr
);
896 [DllImport(Win32Native
.OLEAUT32
)]
897 [ResourceExposure(ResourceScope
.None
)]
898 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
899 internal static extern void SysFreeString(IntPtr bstr
);
902 [DllImport(KERNEL32
)]
903 [ResourceExposure(ResourceScope
.None
)]
904 internal static extern int GetACP();
906 [DllImport(KERNEL32
, SetLastError
=true)]
907 [ResourceExposure(ResourceScope
.None
)]
908 internal static extern bool SetEvent(SafeWaitHandle handle
);
910 [DllImport(KERNEL32
, SetLastError
=true)]
911 [ResourceExposure(ResourceScope
.None
)]
912 internal static extern bool ResetEvent(SafeWaitHandle handle
);
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
);
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
);
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
);
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
);
931 [DllImport(KERNEL32
, SetLastError
=true)]
932 [ResourceExposure(ResourceScope
.None
)]
933 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.MayFail
)]
934 internal static extern bool ReleaseMutex(SafeWaitHandle handle
);
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
);
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
);
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
);
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
);
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
);
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
);
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
);
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
)
977 SafeFileHandle handle
= CreateFile( lpFileName
, dwDesiredAccess
, dwShareMode
,
978 securityAttrs
, dwCreationDisposition
,
979 dwFlagsAndAttributes
, hTemplateFile
);
981 if (!handle
.IsInvalid
)
983 int fileType
= Win32Native
.GetFileType(handle
);
984 if (fileType
!= Win32Native
.FILE_TYPE_DISK
) {
986 throw new NotSupportedException(Environment
.GetResourceString("NotSupported_FileStreamOnNonFiles"));
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
)
1001 SafeFileHandle handle
= CreateFile( lpFileName
, dwDesiredAccess
, dwShareMode
,
1002 securityAttrs
, dwCreationDisposition
,
1003 dwFlagsAndAttributes
, hTemplateFile
);
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
);
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
);
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
);
1028 [DllImport(KERNEL32
, ExactSpelling
=true)]
1029 [ResourceExposure(ResourceScope
.Machine
)]
1030 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
1031 internal static extern bool UnmapViewOfFile(IntPtr lpBaseAddress
);
1033 [DllImport(KERNEL32
, SetLastError
=true)]
1034 [ResourceExposure(ResourceScope
.Machine
)]
1035 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
1036 internal static extern bool CloseHandle(IntPtr handle
);
1038 [DllImport(KERNEL32
)]
1039 [ResourceExposure(ResourceScope
.None
)]
1040 internal static extern int GetFileType(SafeFileHandle handle
);
1042 [DllImport(KERNEL32
, SetLastError
=true)]
1043 [ResourceExposure(ResourceScope
.None
)]
1044 internal static extern bool SetEndOfFile(SafeFileHandle hFile
);
1046 [DllImport(KERNEL32
, SetLastError
= true)]
1047 [ResourceExposure(ResourceScope
.None
)]
1048 [return: MarshalAs(UnmanagedType
.Bool
)]
1049 internal static extern bool FlushFileBuffers(SafeFileHandle hFile
);
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
);
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
) {
1059 int lo
= (int) offset
;
1060 int hi
= (int) (offset
>> 32);
1061 lo
= SetFilePointerWin32(handle
, lo
, &hi
, (int) origin
);
1063 if (lo
== -1 && ((hr
= Marshal
.GetLastWin32Error()) != 0))
1065 return (long) (((ulong) ((uint) hi
)) << 32) | ((uint) lo
);
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.
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
);
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
);
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.
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
);
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
);
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
);
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
);
1111 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true, BestFitMapping
=false)]
1112 [ResourceExposure(ResourceScope
.None
)]
1113 internal static extern int GetDriveType(String drive
);
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
);
1119 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true, BestFitMapping
=false)]
1120 [ResourceExposure(ResourceScope
.None
)]
1121 internal static extern bool SetVolumeLabel(String driveLetter
, String volumeName
);
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);
1129 [DllImport(KERNEL32
)]
1130 [ResourceExposure(ResourceScope
.None
)]
1131 [return: MarshalAs(UnmanagedType
.Bool
)]
1132 internal static extern bool QueryPerformanceFrequency(out long value);
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
);
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
);
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
1150 #if !FEATURE_CORECLR
1151 [StructLayout(LayoutKind
.Sequential
)]
1152 internal struct NlsVersionInfoEx
1154 internal int dwNLSVersionInfoSize
;
1155 internal int dwNLSVersion
;
1156 internal int dwDefinedVersion
;
1157 internal int dwEffectiveId
;
1158 internal Guid guidCustomVersion
;
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
);
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
);
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
);
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
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
);
1187 [DllImport(KERNEL32
, SetLastError
=true)]
1188 [ResourceExposure(ResourceScope
.None
)]
1189 internal static extern int GetFileSize(SafeFileHandle hFile
, out int highSize
);
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
);
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
);
1199 internal static readonly IntPtr INVALID_HANDLE_VALUE
= new IntPtr(-1); // WinBase.h
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;
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!
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;
1219 internal const int FILE_TYPE_DISK
= 0x0001;
1220 internal const int FILE_TYPE_CHAR
= 0x0002;
1221 internal const int FILE_TYPE_PIPE
= 0x0003;
1223 internal const int REPLACEFILE_WRITE_THROUGH
= 0x1;
1224 internal const int REPLACEFILE_IGNORE_MERGE_ERRORS
= 0x2;
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;
1230 internal const uint FILE_MAP_WRITE
= 0x0002;
1231 internal const uint FILE_MAP_READ
= 0x0004;
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;
1238 internal const int IO_REPARSE_TAG_MOUNT_POINT
= unchecked((int)0xA0000003);
1240 internal const int PAGE_READWRITE
= 0x04;
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;
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;
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;
1305 internal const int INVALID_FILE_SIZE
= -1;
1308 internal const int STATUS_ACCOUNT_RESTRICTION
= unchecked((int) 0xC000006E);
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
)
1314 BCLDebug
.Assert((0xFFFF0000 & errorCode
) == 0, "This is an HRESULT, not an error code!");
1315 return unchecked(((int)0x80070000) | errorCode
);
1318 // Win32 Structs in N/Direct style
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;
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
,
1352 IntPtr progressRoutine
,
1353 IntPtr progressData
,
1357 internal static bool CopyFile(String src
, String dst
, bool failIfExists
)
1360 return CopyFileEx(src
, dst
, IntPtr
.Zero
, IntPtr
.Zero
, ref cancel
, failIfExists
? 1U : 0U);
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
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
);
1374 [DllImport(KERNEL32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1375 [ResourceExposure(ResourceScope
.Machine
)]
1376 internal static extern bool DeleteFile(String path
);
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
);
1382 [DllImport(ADVAPI32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1383 [ResourceExposure(ResourceScope
.Machine
)]
1384 internal static extern bool DecryptFile(String path
, int reservedMustBeZero
);
1386 [DllImport(ADVAPI32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1387 [ResourceExposure(ResourceScope
.Machine
)]
1388 internal static extern bool EncryptFile(String path
);
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
);
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
);
1401 [DllImport(KERNEL32
)]
1402 [ResourceExposure(ResourceScope
.None
)]
1403 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
1404 internal static extern bool FindClose(IntPtr handle
);
1406 [DllImport(KERNEL32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1407 [ResourceExposure(ResourceScope
.Machine
)]
1408 internal static extern int GetCurrentDirectory(
1410 [Out
]StringBuilder lpBuffer
);
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
);
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
);
1420 [DllImport(KERNEL32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1421 [ResourceExposure(ResourceScope
.None
)]
1422 internal static extern bool SetFileAttributes(String name
, int attr
);
1424 [DllImport(KERNEL32
, SetLastError
=true)]
1425 [ResourceExposure(ResourceScope
.None
)]
1426 internal static extern int GetLogicalDrives();
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
);
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
);
1437 internal static bool MoveFile(String src
, String dst
)
1439 return MoveFileEx(src
, dst
, 2 /* MOVEFILE_COPY_ALLOWED */);
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
1447 [DllImport(KERNEL32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1448 [ResourceExposure(ResourceScope
.Machine
)]
1449 internal static extern bool DeleteVolumeMountPoint(String mountPoint
);
1451 [DllImport(KERNEL32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1452 [ResourceExposure(ResourceScope
.Machine
)]
1453 internal static extern bool RemoveDirectory(String path
);
1455 [DllImport(KERNEL32
, SetLastError
=true, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1456 [ResourceExposure(ResourceScope
.Machine
)]
1457 internal static extern bool SetCurrentDirectory(String path
);
1459 [DllImport(KERNEL32
, SetLastError
=false, EntryPoint
="SetErrorMode", ExactSpelling
=true)]
1460 [ResourceExposure(ResourceScope
.Process
)]
1461 private static extern int SetErrorMode_VistaAndOlder(int newMode
);
1463 [DllImport(KERNEL32
, SetLastError
=true, EntryPoint
="SetThreadErrorMode")]
1464 [ResourceExposure(ResourceScope
.None
)]
1465 private static extern bool SetErrorMode_Win7AndNewer(int newMode
, out int oldMode
);
1467 // RTM versions of Win7 and Windows Server 2008 R2
1468 private static readonly Version ThreadErrorModeMinOsVersion
= new Version(6, 1, 7600);
1470 // this method uses the thread-safe version of SetErrorMode on Windows 7 / Windows Server 2008 R2 operating systems.
1472 [ResourceExposure(ResourceScope
.Process
)]
1473 [ResourceConsumption(ResourceScope
.Process
)]
1474 internal static int SetErrorMode(int newMode
)
1476 #if !FEATURE_CORESYSTEM // ARMSTUB
1477 if (Environment
.OSVersion
.Version
>= ThreadErrorModeMinOsVersion
)
1480 SetErrorMode_Win7AndNewer(newMode
, out oldMode
);
1484 return SetErrorMode_VistaAndOlder(newMode
);
1487 internal const int LCID_SUPPORTED
= 0x00000002; // supported locale ids
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
);
1493 // A Win32 HandlerRoutine
1494 internal delegate bool ConsoleCtrlHandlerRoutine(int controlType
);
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
);
1501 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true, BestFitMapping
=false)]
1502 [ResourceExposure(ResourceScope
.Process
)]
1503 internal static extern bool SetEnvironmentVariable(string lpName
, string lpValue
);
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
);
1509 [DllImport(KERNEL32
, CharSet
=CharSet
.Unicode
)]
1510 [ResourceExposure(ResourceScope
.Machine
)]
1511 internal static unsafe extern char * GetEnvironmentStrings();
1513 [DllImport(KERNEL32
, CharSet
=CharSet
.Unicode
)]
1514 [ResourceExposure(ResourceScope
.Machine
)]
1515 internal static unsafe extern bool FreeEnvironmentStrings(char * pStrings
);
1517 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true)]
1518 [ResourceExposure(ResourceScope
.Process
)]
1519 internal static extern uint GetCurrentProcessId();
1521 [DllImport(ADVAPI32
, CharSet
=CharSet
.Auto
)]
1522 [ResourceExposure(ResourceScope
.None
)]
1523 internal static extern bool GetUserName([Out
]StringBuilder lpBuffer
, ref int nSize
);
1525 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1526 [ResourceExposure(ResourceScope
.None
)]
1527 internal extern static int GetComputerName([Out
]StringBuilder nameBuffer
, ref int bufferSize
);
1530 [ResourceExposure(ResourceScope
.None
)]
1531 internal extern static int CoCreateGuid(out Guid guid
);
1533 [DllImport(Win32Native
.OLE32
)]
1534 [ResourceExposure(ResourceScope
.None
)]
1535 internal static extern IntPtr
CoTaskMemAlloc(UIntPtr cb
);
1537 [DllImport(Win32Native
.OLE32
)]
1538 [ResourceExposure(ResourceScope
.None
)]
1539 internal static extern IntPtr
CoTaskMemRealloc(IntPtr pv
, UIntPtr cb
);
1541 [DllImport(Win32Native
.OLE32
)]
1542 [ResourceExposure(ResourceScope
.None
)]
1543 internal static extern void CoTaskMemFree(IntPtr ptr
);
1546 [StructLayoutAttribute(LayoutKind
.Sequential
)]
1547 internal struct COORD
1553 [StructLayoutAttribute(LayoutKind
.Sequential
)]
1554 internal struct SMALL_RECT
1556 internal short Left
;
1558 internal short Right
;
1559 internal short Bottom
;
1562 [StructLayoutAttribute(LayoutKind
.Sequential
)]
1563 internal struct CONSOLE_SCREEN_BUFFER_INFO
1565 internal COORD dwSize
;
1566 internal COORD dwCursorPosition
;
1567 internal short wAttributes
;
1568 internal SMALL_RECT srWindow
;
1569 internal COORD dwMaximumWindowSize
;
1572 [StructLayoutAttribute(LayoutKind
.Sequential
)]
1573 internal struct CONSOLE_CURSOR_INFO
1575 internal int dwSize
;
1576 internal bool bVisible
;
1579 // Win32's KEY_EVENT_RECORD
1580 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Auto
)]
1581 internal struct KeyEventRecord
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
;
1591 // Really, this is a union of KeyEventRecords and other types.
1592 [StructLayout(LayoutKind
.Sequential
, CharSet
=CharSet
.Auto
)]
1593 internal struct InputRecord
1595 internal short eventType
;
1596 internal KeyEventRecord keyEvent
;
1597 // This struct is a union! Word alighment should take care of padding!
1602 internal enum Color
: short
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,
1616 ForegroundMask
= 0xf,
1617 BackgroundMask
= 0xf0,
1621 [StructLayout(LayoutKind
.Sequential
)]
1622 internal struct CHAR_INFO
1624 ushort charData
; // Union between WCHAR and ASCII char
1628 internal const int ENABLE_PROCESSED_INPUT
= 0x0001;
1629 internal const int ENABLE_LINE_INPUT
= 0x0002;
1630 internal const int ENABLE_ECHO_INPUT
= 0x0004;
1632 [DllImport(KERNEL32
, SetLastError
=true)]
1633 [ResourceExposure(ResourceScope
.Process
)]
1634 internal static extern bool SetConsoleMode(IntPtr hConsoleHandle
, int mode
);
1636 [DllImport(KERNEL32
, SetLastError
=true)]
1637 [ResourceExposure(ResourceScope
.Process
)]
1638 internal static extern bool GetConsoleMode(IntPtr hConsoleHandle
, out int mode
);
1640 [DllImport(KERNEL32
, SetLastError
=true)]
1641 [ResourceExposure(ResourceScope
.None
)]
1642 internal static extern bool Beep(int frequency
, int duration
);
1644 [DllImport(KERNEL32
, SetLastError
=true)]
1645 [ResourceExposure(ResourceScope
.None
)]
1646 internal static extern bool GetConsoleScreenBufferInfo(IntPtr hConsoleOutput
,
1647 out CONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo
);
1649 [DllImport(KERNEL32
, SetLastError
=true)]
1650 [ResourceExposure(ResourceScope
.Process
)]
1651 internal static extern bool SetConsoleScreenBufferSize(IntPtr hConsoleOutput
, COORD size
);
1653 [DllImport(KERNEL32
, SetLastError
=true)]
1654 [ResourceExposure(ResourceScope
.None
)]
1655 internal static extern COORD
GetLargestConsoleWindowSize(IntPtr hConsoleOutput
);
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
);
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
);
1667 [DllImport(KERNEL32
, SetLastError
=true)]
1668 [ResourceExposure(ResourceScope
.Process
)]
1669 internal static unsafe extern bool SetConsoleWindowInfo(IntPtr hConsoleOutput
,
1670 bool absolute
, SMALL_RECT
* consoleWindow
);
1672 [DllImport(KERNEL32
, SetLastError
=true)]
1673 [ResourceExposure(ResourceScope
.Process
)]
1674 internal static extern bool SetConsoleTextAttribute(IntPtr hConsoleOutput
, short attributes
);
1676 [DllImport(KERNEL32
, SetLastError
=true)]
1677 [ResourceExposure(ResourceScope
.Process
)]
1678 internal static extern bool SetConsoleCursorPosition(IntPtr hConsoleOutput
,
1679 COORD cursorPosition
);
1681 [DllImport(KERNEL32
, SetLastError
=true)]
1682 [ResourceExposure(ResourceScope
.None
)]
1683 internal static extern bool GetConsoleCursorInfo(IntPtr hConsoleOutput
,
1684 out CONSOLE_CURSOR_INFO cci
);
1686 [DllImport(KERNEL32
, SetLastError
=true)]
1687 [ResourceExposure(ResourceScope
.Process
)]
1688 internal static extern bool SetConsoleCursorInfo(IntPtr hConsoleOutput
,
1689 ref CONSOLE_CURSOR_INFO cci
);
1691 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true, BestFitMapping
=true)]
1692 [ResourceExposure(ResourceScope
.Process
)]
1693 internal static extern bool SetConsoleTitle(String title
);
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
);
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
);
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
);
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
);
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
);
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
);
1721 [DllImport(USER32
)] // Appears to always succeed
1722 [ResourceExposure(ResourceScope
.Process
)]
1723 internal static extern short GetKeyState(int virtualKeyCode
);
1724 #endif // !FEATURE_PAL
1726 [DllImport(KERNEL32
, SetLastError
=false)]
1727 [ResourceExposure(ResourceScope
.None
)]
1728 internal static extern uint GetConsoleCP();
1730 [DllImport(KERNEL32
, SetLastError
=true)]
1731 [ResourceExposure(ResourceScope
.Process
)]
1732 internal static extern bool SetConsoleCP(uint codePage
);
1734 [DllImport(KERNEL32
, SetLastError
=false)]
1735 [ResourceExposure(ResourceScope
.None
)]
1736 internal static extern uint GetConsoleOutputCP();
1738 [DllImport(KERNEL32
, SetLastError
=true)]
1739 [ResourceExposure(ResourceScope
.Process
)]
1740 internal static extern bool SetConsoleOutputCP(uint codePage
);
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
);
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
);
1757 [DllImport(ADVAPI32
, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1758 [ResourceExposure(ResourceScope
.Machine
)]
1759 internal static extern int RegDeleteKey(SafeRegistryHandle hKey
, String lpSubKey
);
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
);
1766 [DllImport(ADVAPI32
, CharSet
=CharSet
.Auto
, BestFitMapping
=false)]
1767 [ResourceExposure(ResourceScope
.Machine
)]
1768 internal static extern int RegDeleteValue(SafeRegistryHandle hKey
, String lpValueName
);
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
);
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
,
1785 [DllImport(ADVAPI32
)]
1786 [ResourceExposure(ResourceScope
.None
)]
1787 internal static extern int RegFlushKey(SafeRegistryHandle hKey
);
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
);
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
);
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
);
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
,
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
,
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
,
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
,
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
,
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
);
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
);
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
);
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
);
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
);
1862 [DllImport(KERNEL32
)]
1863 [ResourceExposure(ResourceScope
.None
)]
1864 internal static extern IntPtr
LocalReAlloc(IntPtr handle
, IntPtr sizetcbBytes
, int uFlags
);
1865 #endif // !FEATURE_PAL
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;
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 //////!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!////////
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()
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;
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
);
1961 internal const int NameSamCompatible
= 2;
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
);
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
);
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();
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
);
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
);
1989 [StructLayout(LayoutKind
.Sequential
)]
1990 internal class USEROBJECTFLAGS
{
1991 internal int fInherit
= 0;
1992 internal int fReserved
= 0;
1993 internal int dwFlags
= 0;
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.
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
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
2025 [DllImport(NTDLL
, CharSet
=CharSet
.Unicode
, SetLastError
=true)]
2026 [ResourceExposure(ResourceScope
.None
)]
2027 internal static extern
2028 int RtlNtStatusToDosError (
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 (
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
);
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
);
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
);
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
);
2076 EntryPoint
="ConvertSecurityDescriptorToStringSecurityDescriptorW",
2077 CallingConvention
=CallingConvention
.Winapi
,
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
);
2091 EntryPoint
="ConvertStringSecurityDescriptorToSecurityDescriptorW",
2092 CallingConvention
=CallingConvention
.Winapi
,
2095 CharSet
=CharSet
.Unicode
)]
2096 [ResourceExposure(ResourceScope
.None
)]
2097 internal static extern BOOL
ConvertStringSdToSd(
2099 /* DWORD */ uint stringSdRevision
,
2100 out IntPtr resultSd
,
2101 ref ULONG resultSdLength
);
2105 EntryPoint
="ConvertStringSidToSidW",
2106 CallingConvention
=CallingConvention
.Winapi
,
2109 CharSet
=CharSet
.Unicode
)]
2110 [ResourceExposure(ResourceScope
.None
)]
2111 internal static extern BOOL
ConvertStringSidToSid(
2113 out IntPtr ByteArray
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(
2127 ref IntPtr StringSid
2133 EntryPoint
="CreateWellKnownSid",
2134 CallingConvention
=CallingConvention
.Winapi
,
2137 CharSet
=CharSet
.Unicode
)]
2138 [ResourceExposure(ResourceScope
.None
)]
2139 internal static extern BOOL
CreateWellKnownSid(
2142 [Out
] byte[] resultSid
,
2143 ref /*DWORD*/ uint resultSidLength
);
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
);
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
);
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
);
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
);
2196 EntryPoint
="EqualDomainSid",
2197 CallingConvention
=CallingConvention
.Winapi
,
2200 CharSet
=CharSet
.Unicode
)]
2201 [ResourceExposure(ResourceScope
.None
)]
2202 internal static extern BOOL
IsEqualDomainSid(
2207 [DllImport(KERNEL32
, CharSet
=CharSet
.Auto
, SetLastError
=true)]
2208 [ResourceExposure(ResourceScope
.Process
)]
2209 internal static extern IntPtr
GetCurrentProcess();
2211 [DllImport(KERNEL32
, CharSet
= CharSet
.Auto
, SetLastError
= true)]
2212 [ResourceExposure(ResourceScope
.Process
)]
2213 internal static extern IntPtr
GetCurrentThread();
2217 EntryPoint
="GetSecurityDescriptorLength",
2218 CallingConvention
=CallingConvention
.Winapi
,
2221 CharSet
=CharSet
.Unicode
)]
2222 [ResourceExposure(ResourceScope
.None
)]
2223 internal static extern /*DWORD*/ uint GetSecurityDescriptorLength(
2228 EntryPoint
="GetSecurityInfo",
2229 CallingConvention
=CallingConvention
.Winapi
,
2232 CharSet
=CharSet
.Unicode
)]
2233 [ResourceExposure(ResourceScope
.None
)]
2234 internal static extern /*DWORD*/ uint GetSecurityInfoByHandle(
2236 /*DWORD*/ uint objectType
,
2237 /*DWORD*/ uint securityInformation
,
2238 out IntPtr sidOwner
,
2239 out IntPtr sidGroup
,
2242 out IntPtr securityDescriptor
);
2246 EntryPoint
="GetNamedSecurityInfoW",
2247 CallingConvention
=CallingConvention
.Winapi
,
2250 CharSet
=CharSet
.Unicode
)]
2251 [ResourceExposure(ResourceScope
.None
)]
2252 internal static extern /*DWORD*/ uint GetSecurityInfoByName(
2254 /*DWORD*/ uint objectType
,
2255 /*DWORD*/ uint securityInformation
,
2256 out IntPtr sidOwner
,
2257 out IntPtr sidGroup
,
2260 out IntPtr securityDescriptor
);
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
);
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
);
2284 EntryPoint
="GetWindowsAccountDomainSid",
2285 CallingConvention
=CallingConvention
.Winapi
,
2288 CharSet
=CharSet
.Unicode
)]
2289 [ResourceExposure(ResourceScope
.None
)]
2290 internal static extern BOOL
GetWindowsAccountDomainSid(
2292 [Out
] byte[] resultSid
,
2293 ref /*DWORD*/ uint resultSidLength
);
2295 internal enum SECURITY_IMPERSONATION_LEVEL
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
2306 // CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID -> 0x00
2307 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_INVALID
= 0;
2309 // CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64 -> 0x01
2310 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_INT64
= 1;
2312 // CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64 -> 0x02
2313 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_UINT64
= 2;
2315 // CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING -> 0x03
2316 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_STRING
= 3;
2318 // CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN -> 0x04
2319 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_FQBN
= 4;
2321 // CLAIM_SECURITY_ATTRIBUTE_TYPE_SID -> 0x05
2322 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_SID
= 5;
2324 // CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN -> 0x06
2325 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_BOOLEAN
= 6;
2327 // CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING -> 0x10
2328 internal const int CLAIM_SECURITY_ATTRIBUTE_TYPE_OCTET_STRING
= 16;
2330 // CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE -> 0x0001
2331 internal const int CLAIM_SECURITY_ATTRIBUTE_NON_INHERITABLE
= 1;
2333 // CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE -> 0x0002
2334 internal const int CLAIM_SECURITY_ATTRIBUTE_VALUE_CASE_SENSITIVE
= 2;
2336 // CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY -> 0x0004
2337 internal const int CLAIM_SECURITY_ATTRIBUTE_USE_FOR_DENY_ONLY
= 4;
2339 // CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT -> 0x0008
2340 internal const int CLAIM_SECURITY_ATTRIBUTE_DISABLED_BY_DEFAULT
= 8;
2342 // CLAIM_SECURITY_ATTRIBUTE_DISABLED -> 0x0010
2343 internal const int CLAIM_SECURITY_ATTRIBUTE_DISABLED
= 16;
2345 // CLAIM_SECURITY_ATTRIBUTE_MANDATORY -> 0x0020
2346 internal const int CLAIM_SECURITY_ATTRIBUTE_MANDATORY
= 32;
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
;
2357 [StructLayoutAttribute( LayoutKind
.Explicit
)]
2358 internal struct CLAIM_SECURITY_ATTRIBUTE_INFORMATION_V1
2360 // defined as union in CLAIM_SECURITY_ATTRIBUTES_INFORMATION
2361 [FieldOffsetAttribute( 0 )]
2362 public IntPtr pAttributeV1
;
2365 [StructLayoutAttribute( LayoutKind
.Sequential
)]
2366 internal struct CLAIM_SECURITY_ATTRIBUTES_INFORMATION
2368 /// WORD->unsigned short
2369 public ushort Version
;
2371 /// WORD->unsigned short
2372 public ushort Reserved
;
2374 /// DWORD->unsigned int
2375 public uint AttributeCount
;
2377 /// CLAIM_SECURITY_ATTRIBUTE_V1
2378 public CLAIM_SECURITY_ATTRIBUTE_INFORMATION_V1 Attribute
;
2382 // Fully-qualified binary name.
2384 [StructLayoutAttribute( LayoutKind
.Sequential
, CharSet
= CharSet
.Unicode
)]
2385 internal struct CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE
2387 // DWORD64->unsigned __int64
2388 public ulong Version
;
2391 [MarshalAsAttribute( UnmanagedType
.LPWStr
)]
2395 [StructLayoutAttribute( LayoutKind
.Sequential
, CharSet
= CharSet
.Unicode
)]
2396 internal struct CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE
2399 public IntPtr pValue
;
2401 /// DWORD->unsigned int
2402 public uint ValueLength
;
2405 [StructLayoutAttribute( LayoutKind
.Explicit
, CharSet
= CharSet
.Unicode
)]
2406 internal struct CLAIM_VALUES_ATTRIBUTE_V1
2408 // PLONG64->__int64*
2409 [FieldOffsetAttribute( 0 )]
2410 public IntPtr pInt64
;
2412 // PDWORD64->unsigned __int64*
2413 [FieldOffsetAttribute( 0 )]
2414 public IntPtr pUint64
;
2417 [FieldOffsetAttribute( 0 )]
2418 public IntPtr ppString
;
2420 // PCLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE->_CLAIM_SECURITY_ATTRIBUTE_FQBN_VALUE*
2421 [FieldOffsetAttribute( 0 )]
2422 public IntPtr pFqbn
;
2424 // PCLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE->_CLAIM_SECURITY_ATTRIBUTE_OCTET_STRING_VALUE*
2425 [FieldOffsetAttribute( 0 )]
2426 public IntPtr pOctetString
;
2429 [StructLayoutAttribute( LayoutKind
.Sequential
, CharSet
= CharSet
.Unicode
)]
2430 internal struct CLAIM_SECURITY_ATTRIBUTE_V1
2433 [MarshalAsAttribute( UnmanagedType
.LPWStr
)]
2436 // WORD->unsigned short
2437 public ushort ValueType
;
2439 // WORD->unsigned short
2440 public ushort Reserved
;
2442 // DWORD->unsigned int
2445 // DWORD->unsigned int
2446 public uint ValueCount
;
2448 // struct CLAIM_VALUES - a union of 4 possible values
2449 public CLAIM_VALUES_ATTRIBUTE_V1 Values
;
2454 EntryPoint
="IsWellKnownSid",
2455 CallingConvention
=CallingConvention
.Winapi
,
2458 CharSet
=CharSet
.Unicode
)]
2459 [ResourceExposure(ResourceScope
.None
)]
2460 internal static extern BOOL
IsWellKnownSid(
2466 EntryPoint
="LsaOpenPolicy",
2467 CallingConvention
=CallingConvention
.Winapi
,
2470 CharSet
=CharSet
.Unicode
)]
2471 [ResourceExposure(ResourceScope
.None
)]
2472 internal static extern /*DWORD*/ uint LsaOpenPolicy(
2474 ref LSA_OBJECT_ATTRIBUTES attributes
,
2476 out SafeLsaPolicyHandle handle
2479 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.MayFail
)]
2482 EntryPoint
="LookupPrivilegeValueW",
2483 CharSet
=CharSet
.Auto
,
2486 BestFitMapping
=false)]
2487 [ResourceExposure(ResourceScope
.None
)]
2488 internal static extern
2489 bool LookupPrivilegeValue (
2490 [In
] string lpSystemName
,
2492 [In
,Out
] ref LUID Luid
);
2496 EntryPoint
="LsaLookupSids",
2497 CallingConvention
=CallingConvention
.Winapi
,
2500 CharSet
=CharSet
.Unicode
)]
2501 [ResourceExposure(ResourceScope
.None
)]
2502 internal static extern /*DWORD*/ uint LsaLookupSids(
2503 SafeLsaPolicyHandle handle
,
2506 ref SafeLsaMemoryHandle referencedDomains
,
2507 ref SafeLsaMemoryHandle names
2510 [DllImport(ADVAPI32
, SetLastError
=true)]
2511 [ResourceExposure(ResourceScope
.None
)]
2512 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
2513 internal static extern int LsaFreeMemory( IntPtr handle
);
2517 EntryPoint
="LsaLookupNames",
2518 CallingConvention
=CallingConvention
.Winapi
,
2521 CharSet
=CharSet
.Unicode
)]
2522 [ResourceExposure(ResourceScope
.None
)]
2523 internal static extern /*DWORD*/ uint LsaLookupNames(
2524 SafeLsaPolicyHandle handle
,
2526 UNICODE_STRING
[] names
,
2527 ref SafeLsaMemoryHandle referencedDomains
,
2528 ref SafeLsaMemoryHandle sids
2533 EntryPoint
="LsaLookupNames2",
2534 CallingConvention
=CallingConvention
.Winapi
,
2537 CharSet
=CharSet
.Unicode
)]
2538 [ResourceExposure(ResourceScope
.None
)]
2539 internal static extern /*DWORD*/ uint LsaLookupNames2(
2540 SafeLsaPolicyHandle handle
,
2543 UNICODE_STRING
[] names
,
2544 ref SafeLsaMemoryHandle referencedDomains
,
2545 ref SafeLsaMemoryHandle sids
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
);
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
);
2561 [DllImport(SECUR32
, CharSet
=CharSet
.Auto
, SetLastError
=true)]
2562 [ResourceExposure(ResourceScope
.None
)]
2563 internal static extern
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
);
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
);
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
);
2596 [DllImport(SECUR32
, SetLastError
=true)]
2597 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
2598 [ResourceExposure(ResourceScope
.None
)]
2599 internal static extern int LsaDeregisterLogonProcess(IntPtr handle
);
2601 [DllImport(ADVAPI32
, SetLastError
=true)]
2602 [ResourceExposure(ResourceScope
.None
)]
2603 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
2604 internal static extern int LsaClose( IntPtr handle
);
2606 [DllImport(SECUR32
, SetLastError
=true)]
2607 [ResourceExposure(ResourceScope
.None
)]
2608 [ReliabilityContract(Consistency
.WillNotCorruptState
, Cer
.Success
)]
2609 internal static extern int LsaFreeReturnBuffer(IntPtr handle
);
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
);
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
);
2635 EntryPoint
="SetNamedSecurityInfoW",
2636 CallingConvention
=CallingConvention
.Winapi
,
2639 CharSet
=CharSet
.Unicode
)]
2640 [ResourceExposure(ResourceScope
.Machine
)]
2641 internal static extern /*DWORD*/ uint SetSecurityInfoByName(
2643 /*DWORD*/ uint objectType
,
2644 /*DWORD*/ uint securityInformation
,
2652 EntryPoint
="SetSecurityInfo",
2653 CallingConvention
=CallingConvention
.Winapi
,
2656 CharSet
=CharSet
.Unicode
)]
2657 [ResourceExposure(ResourceScope
.None
)]
2658 internal static extern /*DWORD*/ uint SetSecurityInfoByHandle(
2660 /*DWORD*/ uint objectType
,
2661 /*DWORD*/ uint securityInformation
,
2667 #else // FEATURE_PAL
2669 // managed cryptography wrapper around the PALRT cryptography api
2670 internal const int PAL_HCRYPTPROV
= 123;
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);
2681 internal const int HP_ALGID
= 0x0001;
2682 internal const int HP_HASHVAL
= 0x0002;
2683 internal const int HP_HASHSIZE
= 0x0004;
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
,
2693 [DllImport(OLEAUT32
, SetLastError
=true)]
2694 [ResourceExposure(ResourceScope
.None
)]
2695 internal extern static bool CryptReleaseContext( IntPtr hProv
, int flags
);
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
);
2701 [DllImport(OLEAUT32
, SetLastError
=true)]
2702 [ResourceExposure(ResourceScope
.None
)]
2703 internal extern static bool CryptDestroyHash(IntPtr hHash
);
2705 [DllImport(OLEAUT32
, SetLastError
=true)]
2706 [ResourceExposure(ResourceScope
.None
)]
2707 internal extern static bool CryptHashData(IntPtr hHash
,
2708 [In
, MarshalAs(UnmanagedType
.LPArray
)] byte[] data
,
2712 [DllImport(OLEAUT32
, SetLastError
=true)]
2713 [ResourceExposure(ResourceScope
.None
)]
2714 internal extern static bool CryptGetHashParam(IntPtr hHash
,
2716 [Out
, MarshalAs(UnmanagedType
.LPArray
)] byte[] digest
,
2720 [DllImport(OLEAUT32
, SetLastError
=true)]
2721 [ResourceExposure(ResourceScope
.None
)]
2722 internal extern static bool CryptGetHashParam(IntPtr hHash
,
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
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
);
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
2745 [DllImport(KERNEL32
, CharSet
=CharSet
.Unicode
)]
2746 [SuppressUnmanagedCodeSecurityAttribute()]
2747 internal unsafe static extern int WideCharToMultiByte(
2750 char* lpWideCharStr
,
2752 byte* lpMultiByteStr
,
2754 char* lpDefaultChar
,
2755 bool* lpUsedDefaultChar
);
2757 [DllImport(KERNEL32
, CharSet
=CharSet
.Unicode
)]
2758 [SuppressUnmanagedCodeSecurityAttribute()]
2759 internal unsafe static extern int MultiByteToWideChar(
2762 byte* lpMultiByteStr
,
2764 char* lpWideCharStr
,
2766 #endif // FEATURE_CORECLR
2768 [DllImport(KERNEL32
, SetLastError
= true)]
2769 [return: MarshalAs(UnmanagedType
.Bool
)]
2770 internal extern static bool QueryUnbiasedInterruptTime(out ulong UnbiasedTime
);
2772 // This is needed by the RuntimeInformation feature
2774 internal static extern int RtlGetVersion(out RTL_OSVERSIONINFOEX lpVersionInformation
);
2776 [StructLayout(LayoutKind
.Sequential
)]
2777 internal struct RTL_OSVERSIONINFOEX
2779 internal uint dwOSVersionInfoSize
;
2780 internal uint dwMajorVersion
;
2781 internal uint dwMinorVersion
;
2782 internal uint dwBuildNumber
;
2783 internal uint dwPlatformId
;
2784 [MarshalAs(UnmanagedType
.ByValTStr
, SizeConst
= 128)]
2785 internal string szCSDVersion
;
2788 [DllImport(KERNEL32
)]
2789 internal extern static void GetNativeSystemInfo(out SYSTEM_INFO lpSystemInfo
);
2791 internal enum ProcessorArchitecture
: ushort
2793 Processor_Architecture_INTEL
= 0,
2794 Processor_Architecture_ARM
= 5,
2795 Processor_Architecture_IA64
= 6,
2796 Processor_Architecture_AMD64
= 9,
2797 Processor_Architecture_ARM64
= 12,
2798 Processor_Architecture_UNKNOWN
= 0xFFFF
2800 // end RuntimeInformation