Added checks for sys/errno.h, sys/signal.h and sys/mman.h.
[wine] / include / ntddk.h
1 /*
2         this file defines interfaces mainly exposed to device drivers and
3         native nt dll's
4
5 */
6 #ifndef __WINE_NTDDK_H
7 #define __WINE_NTDDK_H
8
9 #include "ntdef.h"
10 #include "winnt.h"
11 #include "winbase.h"    /* fixme: should be taken out sometimes */
12
13 #ifdef __cplusplus
14 extern "C" {
15 #endif
16
17 /****************** 
18  * asynchronous I/O 
19  */
20 #undef Status   /* conflict with X11-includes*/
21
22 typedef struct _IO_STATUS_BLOCK 
23 {       union 
24         { NTSTATUS Status;
25           PVOID Pointer;
26         } u;
27         ULONG_PTR Information;
28 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;    
29
30 typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
31
32 typedef enum _KEY_INFORMATION_CLASS {
33         KeyBasicInformation,
34         KeyNodeInformation,
35         KeyFullInformation
36 } KEY_INFORMATION_CLASS;
37
38 typedef enum _KEY_VALUE_INFORMATION_CLASS {
39         KeyValueBasicInformation,
40         KeyValueFullInformation,
41         KeyValuePartialInformation,
42         KeyValueFullInformationAlign64,
43         KeyValuePartialInformationAlign64
44 } KEY_VALUE_INFORMATION_CLASS;
45
46 typedef enum _THREADINFOCLASS 
47 {       ThreadBasicInformation,
48         ThreadTimes,
49         ThreadPriority,
50         ThreadBasePriority,
51         ThreadAffinityMask,
52         ThreadImpersonationToken,
53         ThreadDescriptorTableEntry,
54         ThreadEnableAlignmentFaultFixup,
55         ThreadEventPair_Reusable,
56         ThreadQuerySetWin32StartAddress,
57         ThreadZeroTlsCell,
58         ThreadPerformanceCount,
59         ThreadAmILastThread,
60         ThreadIdealProcessor,
61         ThreadPriorityBoost,
62         ThreadSetTlsArrayAddress,
63         ThreadIsIoPending,
64         MaxThreadInfoClass
65 } THREADINFOCLASS;
66
67 typedef enum _FILE_INFORMATION_CLASS {
68         FileDirectoryInformation = 1,
69         FileFullDirectoryInformation,
70         FileBothDirectoryInformation,
71         FileBasicInformation,
72         FileStandardInformation,
73         FileInternalInformation,
74         FileEaInformation,
75         FileAccessInformation,
76         FileNameInformation,
77         FileRenameInformation,
78         FileLinkInformation,
79         FileNamesInformation,
80         FileDispositionInformation,
81         FilePositionInformation,
82         FileFullEaInformation,
83         FileModeInformation,
84         FileAlignmentInformation,
85         FileAllInformation,
86         FileAllocationInformation,
87         FileEndOfFileInformation,
88         FileAlternateNameInformation,
89         FileStreamInformation,
90         FilePipeInformation,
91         FilePipeLocalInformation,
92         FilePipeRemoteInformation,
93         FileMailslotQueryInformation,
94         FileMailslotSetInformation,
95         FileCompressionInformation,
96         FileObjectIdInformation,
97         FileCompletionInformation,
98         FileMoveClusterInformation,
99         FileQuotaInformation,
100         FileReparsePointInformation,
101         FileNetworkOpenInformation,
102         FileAttributeTagInformation,
103         FileTrackingInformation,
104         FileMaximumInformation
105 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
106
107 typedef enum _SECTION_INHERIT 
108 {
109         ViewShare = 1,
110         ViewUnmap = 2
111
112 } SECTION_INHERIT;
113  
114 /*
115         placeholder
116 */
117 typedef enum _OBJECT_INFORMATION_CLASS
118 {
119         DunnoTheConstants1
120
121 } OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
122
123
124 /*
125  *      NtQuerySystemInformation
126  */
127
128 typedef enum SYSTEM_INFORMATION_CLASS
129 {       Unknown1 = 1,
130         Unknown2,
131         Unknown3,
132         Unknown4,
133         SystemPerformanceInformation
134 } SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
135
136 /* reading coffee grounds... */
137 typedef struct _THREAD_INFO
138 {       DWORD   Unknown1[6];
139         DWORD   ThreadID;
140         DWORD   Unknown2[3];
141         DWORD   Status;
142         DWORD   WaitReason;
143         DWORD   Unknown3[4];
144 } THREAD_INFO, PTHREAD_INFO;
145
146 typedef struct _VM_COUNTERS_
147 {       ULONG PeakVirtualSize;
148         ULONG VirtualSize;
149         ULONG PageFaultCount;
150         ULONG PeakWorkingSetSize;
151         ULONG WorkingSetSize;
152         ULONG QuotaPeakPagedPoolUsage;
153         ULONG QuotaPagedPoolUsage;
154         ULONG QuotaPeakNonPagedPoolUsage;
155         ULONG QuotaNonPagedPoolUsage;
156         ULONG PagefileUsage;
157         ULONG PeakPagefileUsage;
158 } VM_COUNTERS, *PVM_COUNTERS;
159
160 typedef struct _PROCESS_INFO
161 {       DWORD           Offset;         /* 00 offset to next PROCESS_INFO ok*/
162         DWORD           ThreadCount;    /* 04 number of ThreadInfo member ok */
163         DWORD           Unknown1[6];
164         FILETIME        CreationTime;   /* 20 */
165         DWORD           Unknown2[5];
166         PWCHAR          ProcessName;    /* 3c ok */
167         DWORD           BasePriority;
168         DWORD           ProcessID;      /* 44 ok*/
169         DWORD           ParentProcessID;
170         DWORD           HandleCount;
171         DWORD           Unknown3[2];    /* 50 */
172         ULONG           PeakVirtualSize;
173         ULONG           VirtualSize;
174         ULONG           PageFaultCount;
175         ULONG           PeakWorkingSetSize;
176         ULONG           WorkingSetSize;
177         ULONG           QuotaPeakPagedPoolUsage;
178         ULONG           QuotaPagedPoolUsage;
179         ULONG           QuotaPeakNonPagedPoolUsage;
180         ULONG           QuotaNonPagedPoolUsage;
181         ULONG           PagefileUsage;
182         ULONG           PeakPagefileUsage;
183         DWORD           PrivateBytes;
184         DWORD           Unknown6[4];
185         THREAD_INFO     ati[ANYSIZE_ARRAY];     /* 94 size=0x40*/
186 } PROCESS_INFO, PPROCESS_INFO;
187
188 NTSTATUS WINAPI NtQuerySystemInformation(
189         IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
190         OUT PVOID SystemInformation,
191         IN ULONG Length,
192         OUT PULONG ResultLength);
193
194 /*
195  *      system configuration
196  */
197
198
199 typedef struct _SYSTEM_TIME_ADJUSTMENT
200 {
201         ULONG   TimeAdjustment;
202         BOOLEAN TimeAdjustmentDisabled;
203
204 } SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
205
206 typedef struct _SYSTEM_CONFIGURATION_INFO 
207 {
208         union 
209         { ULONG OemId;
210           struct 
211           { WORD        ProcessorArchitecture;
212             WORD        Reserved;
213           } tag1;
214         } tag2;
215         ULONG   PageSize;
216         PVOID   MinimumApplicationAddress;
217         PVOID   MaximumApplicationAddress;
218         ULONG   ActiveProcessorMask;
219         ULONG   NumberOfProcessors;
220         ULONG   ProcessorType;
221         ULONG   AllocationGranularity;
222         WORD    ProcessorLevel;
223         WORD    ProcessorRevision;
224
225 } SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
226
227
228 typedef struct _SYSTEM_CACHE_INFORMATION 
229 {
230         ULONG   CurrentSize;
231         ULONG   PeakSize;
232         ULONG   PageFaultCount;
233         ULONG   MinimumWorkingSet;
234         ULONG   MaximumWorkingSet;
235         ULONG   Unused[4];
236
237 } SYSTEM_CACHE_INFORMATION;
238
239 /*
240  *      NtQueryProcessInformation
241  */
242
243 /* parameter ProcessInformationClass */
244
245 typedef enum _PROCESSINFOCLASS 
246 {       ProcessBasicInformation,
247         ProcessQuotaLimits,
248         ProcessIoCounters,
249         ProcessVmCounters,
250         ProcessTimes,
251         ProcessBasePriority,
252         ProcessRaisePriority,
253         ProcessDebugPort,
254         ProcessExceptionPort,
255         ProcessAccessToken,
256         ProcessLdtInformation,
257         ProcessLdtSize,
258         ProcessDefaultHardErrorMode,
259         ProcessIoPortHandlers,
260         ProcessPooledUsageAndLimits,
261         ProcessWorkingSetWatch,
262         ProcessUserModeIOPL,
263         ProcessEnableAlignmentFaultFixup,
264         ProcessPriorityClass,
265         ProcessWx86Information,
266         ProcessHandleCount,
267         ProcessAffinityMask,
268         ProcessPriorityBoost,
269         ProcessDeviceMap,
270         ProcessSessionInformation,
271         ProcessForegroundInformation,
272         ProcessWow64Information,
273         MaxProcessInfoClass
274 } PROCESSINFOCLASS;
275
276 /* parameter ProcessInformation (depending on ProcessInformationClass) */
277
278 typedef struct _PROCESS_BASIC_INFORMATION 
279 {       DWORD   ExitStatus;
280         DWORD   PebBaseAddress;
281         DWORD   AffinityMask;
282         DWORD   BasePriority;
283         ULONG   UniqueProcessId;
284         ULONG   InheritedFromUniqueProcessId;
285 } PROCESS_BASIC_INFORMATION;
286
287 NTSTATUS WINAPI NtQueryInformationProcess(
288         IN HANDLE ProcessHandle,
289         IN PROCESSINFOCLASS ProcessInformationClass,
290         OUT PVOID ProcessInformation,
291         IN ULONG ProcessInformationLength,
292         OUT PULONG ReturnLength);
293
294 #define NtCurrentProcess() ( (HANDLE) -1 )
295
296 /*
297  *      timer
298  */
299
300 typedef enum _TIMER_TYPE 
301 {
302         NotificationTimer,
303         SynchronizationTimer
304
305 } TIMER_TYPE;
306
307 /*
308  *      token functions
309  */
310  
311 NTSTATUS WINAPI NtOpenProcessToken(
312         HANDLE ProcessHandle,
313         DWORD DesiredAccess, 
314         HANDLE *TokenHandle);
315         
316 NTSTATUS WINAPI NtOpenThreadToken(
317         HANDLE ThreadHandle,
318         DWORD DesiredAccess, 
319         BOOLEAN OpenAsSelf,
320         HANDLE *TokenHandle);
321
322 NTSTATUS WINAPI NtAdjustPrivilegesToken(
323         IN HANDLE TokenHandle,
324         IN BOOLEAN DisableAllPrivileges,
325         IN PTOKEN_PRIVILEGES NewState,
326         IN DWORD BufferLength,
327         OUT PTOKEN_PRIVILEGES PreviousState,
328         OUT PDWORD ReturnLength);
329
330 NTSTATUS WINAPI NtQueryInformationToken(
331         HANDLE token,
332         DWORD tokeninfoclass, 
333         LPVOID tokeninfo,
334         DWORD tokeninfolength,
335         LPDWORD retlen );
336
337 /*
338  *      sid functions
339  */
340
341 BOOLEAN WINAPI RtlAllocateAndInitializeSid (
342         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
343         DWORD nSubAuthorityCount,
344         DWORD x3,
345         DWORD x4,
346         DWORD x5,
347         DWORD x6,
348         DWORD x7,
349         DWORD x8,
350         DWORD x9,
351         DWORD x10,
352         PSID pSid);
353         
354 DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2);
355 DWORD WINAPI RtlFreeSid(DWORD x1);
356 DWORD WINAPI RtlLengthRequiredSid(DWORD nrofsubauths);
357 DWORD WINAPI RtlLengthSid(PSID sid);
358 DWORD WINAPI RtlInitializeSid(PSID PSID,PSID_IDENTIFIER_AUTHORITY PSIDauth, DWORD c);
359 LPDWORD WINAPI RtlSubAuthoritySid(PSID PSID,DWORD nr);
360 LPBYTE WINAPI RtlSubAuthorityCountSid(PSID PSID);
361 DWORD WINAPI RtlCopySid(DWORD len,PSID to,PSID from);
362
363 /*
364  *      security descriptor functions
365  */
366
367 NTSTATUS WINAPI RtlCreateSecurityDescriptor(
368         PSECURITY_DESCRIPTOR lpsd,
369         DWORD rev);
370
371 NTSTATUS WINAPI RtlValidSecurityDescriptor(
372         PSECURITY_DESCRIPTOR SecurityDescriptor);
373
374 ULONG WINAPI RtlLengthSecurityDescriptor(
375         PSECURITY_DESCRIPTOR SecurityDescriptor);
376
377 NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
378         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
379         OUT PBOOLEAN lpbDaclPresent,
380         OUT PACL *pDacl,
381         OUT PBOOLEAN lpbDaclDefaulted);
382
383 NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
384         PSECURITY_DESCRIPTOR lpsd,
385         BOOLEAN daclpresent,
386         PACL dacl,
387         BOOLEAN dacldefaulted );
388
389 NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
390         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
391         OUT PBOOLEAN lpbSaclPresent,
392         OUT PACL *pSacl,
393         OUT PBOOLEAN lpbSaclDefaulted);
394
395 NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
396         PSECURITY_DESCRIPTOR lpsd,
397         BOOLEAN saclpresent,
398         PACL sacl,
399         BOOLEAN sacldefaulted);
400
401 NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
402         PSECURITY_DESCRIPTOR SecurityDescriptor,
403         PSID *Owner,
404         PBOOLEAN OwnerDefaulted);
405
406 NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
407         PSECURITY_DESCRIPTOR lpsd,
408         PSID owner,
409         BOOLEAN ownerdefaulted);
410
411 NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
412         PSECURITY_DESCRIPTOR lpsd,
413         PSID group,
414         BOOLEAN groupdefaulted);
415
416 NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
417         PSECURITY_DESCRIPTOR SecurityDescriptor,
418         PSID *Group,
419         PBOOLEAN GroupDefaulted);
420
421 /*      ##############################
422         ######  ACL FUNCTIONS   ######
423         ##############################
424 */
425
426 DWORD WINAPI RtlCreateAcl(PACL acl,DWORD size,DWORD rev);
427
428 BOOLEAN WINAPI RtlFirstFreeAce(
429         PACL acl,
430         PACE_HEADER *x);
431
432 NTSTATUS WINAPI RtlAddAce(
433         PACL acl,
434         DWORD rev,
435         DWORD xnrofaces,
436         PACE_HEADER acestart,
437         DWORD acelen);
438         
439 DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
440 DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
441
442 /*
443  *      string functions
444  */
445
446 DWORD WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING uni,PANSI_STRING ansi,BOOLEAN doalloc);
447 DWORD WINAPI RtlOemStringToUnicodeString(PUNICODE_STRING uni,PSTRING ansi,BOOLEAN doalloc);
448 DWORD WINAPI RtlMultiByteToUnicodeN(LPWSTR unistr,DWORD unilen,LPDWORD reslen,LPSTR oemstr,DWORD oemlen);
449 DWORD WINAPI RtlOemToUnicodeN(LPWSTR unistr,DWORD unilen,LPDWORD reslen,LPSTR oemstr,DWORD oemlen);
450 VOID WINAPI RtlInitAnsiString(PANSI_STRING target,LPCSTR source);
451 VOID WINAPI RtlInitString(PSTRING target,LPCSTR source);
452 VOID WINAPI RtlInitUnicodeString(PUNICODE_STRING target,LPCWSTR source);
453 VOID WINAPI RtlFreeUnicodeString(PUNICODE_STRING str);
454 VOID WINAPI RtlFreeAnsiString(PANSI_STRING AnsiString);
455 DWORD WINAPI RtlUnicodeToOemN(LPSTR oemstr,DWORD oemlen,LPDWORD reslen,LPWSTR unistr,DWORD unilen);
456 DWORD WINAPI RtlUnicodeStringToOemString(PANSI_STRING oem,PUNICODE_STRING uni,BOOLEAN alloc);
457 DWORD WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING oem,PUNICODE_STRING uni,BOOLEAN alloc);
458 DWORD WINAPI RtlEqualUnicodeString(PUNICODE_STRING s1,PUNICODE_STRING s2,DWORD x);
459 DWORD WINAPI RtlUpcaseUnicodeString(PUNICODE_STRING dest,PUNICODE_STRING src,BOOLEAN doalloc);
460 UINT WINAPI RtlxOemStringToUnicodeSize(PSTRING str);
461 UINT WINAPI RtlxAnsiStringToUnicodeSize(PANSI_STRING str);
462 DWORD WINAPI RtlIsTextUnicode(LPVOID buf, DWORD len, DWORD *pf);
463 NTSTATUS WINAPI RtlCompareUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive);
464
465 /*
466  *      resource functions
467  */
468
469 typedef struct _RTL_RWLOCK {
470         CRITICAL_SECTION        rtlCS;
471         HANDLE          hSharedReleaseSemaphore;
472         UINT                    uSharedWaiters;
473         HANDLE          hExclusiveReleaseSemaphore;
474         UINT                    uExclusiveWaiters;
475         INT                     iNumberActive;
476         HANDLE          hOwningThreadId;
477         DWORD                   dwTimeoutBoost;
478         PVOID                   pDebugInfo;
479 } RTL_RWLOCK, *LPRTL_RWLOCK;
480
481 VOID   WINAPI RtlInitializeResource(
482         LPRTL_RWLOCK);
483         
484 VOID   WINAPI RtlDeleteResource(
485         LPRTL_RWLOCK);
486         
487 BYTE   WINAPI RtlAcquireResourceExclusive(
488         LPRTL_RWLOCK, BYTE fWait);
489         
490 BYTE   WINAPI RtlAcquireResourceShared(
491         LPRTL_RWLOCK, BYTE fWait);
492         
493 VOID   WINAPI RtlReleaseResource(
494         LPRTL_RWLOCK);
495         
496 VOID   WINAPI RtlDumpResource(
497         LPRTL_RWLOCK);
498
499 /*
500         time functions
501  */
502
503 typedef struct _TIME_FIELDS 
504 {   CSHORT Year;
505     CSHORT Month;
506     CSHORT Day;
507     CSHORT Hour;
508     CSHORT Minute;
509     CSHORT Second;
510     CSHORT Milliseconds;
511     CSHORT Weekday;
512 } TIME_FIELDS;
513
514 typedef TIME_FIELDS *PTIME_FIELDS;
515
516 VOID WINAPI RtlSystemTimeToLocalTime(
517         IN  PLARGE_INTEGER SystemTime,
518         OUT PLARGE_INTEGER LocalTime);
519
520 VOID WINAPI RtlTimeToTimeFields(
521         PLARGE_INTEGER liTime,
522         PTIME_FIELDS TimeFields);
523
524 BOOLEAN WINAPI RtlTimeFieldsToTime(
525         PTIME_FIELDS tfTimeFields,
526         PLARGE_INTEGER Time);
527         
528 VOID WINAPI RtlTimeToElapsedTimeFields(
529         PLARGE_INTEGER liTime,
530         PTIME_FIELDS TimeFields);
531         
532 BOOLEAN WINAPI RtlTimeToSecondsSince1980(
533         LPFILETIME ft,
534         LPDWORD timeret);
535
536 BOOLEAN WINAPI RtlTimeToSecondsSince1970(
537         LPFILETIME ft,
538         LPDWORD timeret);
539
540 /*
541         heap functions
542 */
543
544 /* Data structure for heap definition. This includes various
545    sizing parameters and callback routines, which, if left NULL,
546    result in default behavior */
547
548 typedef struct
549 {       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
550         ULONG   Unknown[11];
551 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
552
553 HANDLE WINAPI RtlCreateHeap(
554         ULONG Flags,
555         PVOID BaseAddress,
556         ULONG SizeToReserve,
557         ULONG SizeToCommit,
558         PVOID Unknown,
559         PRTL_HEAP_DEFINITION Definition);
560
561 PVOID WINAPI RtlAllocateHeap(
562         HANDLE Heap,
563         ULONG Flags,
564         ULONG Size);
565
566
567 BOOLEAN WINAPI RtlFreeHeap(
568         HANDLE Heap,
569         ULONG Flags,
570         PVOID Address);
571
572 /*
573  *      misc
574  */
575 void WINAPIV DbgPrint(LPCSTR fmt, ...);
576 DWORD WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
577 void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
578 void WINAPI RtlRaiseStatus(NTSTATUS);
579 void WINAPI RtlUnwind(PEXCEPTION_FRAME,LPVOID,PEXCEPTION_RECORD,DWORD);
580 VOID WINAPI RtlAcquirePebLock(void);
581 VOID WINAPI RtlReleasePebLock(void);
582 DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
583 DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
584 DWORD WINAPI RtlSetEnvironmentVariable(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val);
585 DWORD WINAPI RtlNewSecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6);
586 DWORD WINAPI RtlDeleteSecurityObject(DWORD x1);
587 LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
588 DWORD WINAPI RtlNtStatusToDosError(DWORD error);
589 BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
590 INT WINAPI RtlExtendedLargeIntegerDivide(LARGE_INTEGER dividend, DWORD divisor, LPDWORD rest);
591 long long WINAPI RtlExtendedIntegerMultiply(LARGE_INTEGER factor1,INT factor2);
592 DWORD WINAPI RtlFormatCurrentUserKeyPath(DWORD x);
593 DWORD WINAPI RtlOpenCurrentUser(DWORD x1, DWORD *x2);
594 BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
595 DWORD WINAPI RtlCreateEnvironment(DWORD x1,DWORD x2);
596 DWORD WINAPI RtlDestroyEnvironment(DWORD x);
597 DWORD WINAPI RtlQueryEnvironmentVariable_U(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val) ;
598
599 BOOL WINAPI IsValidSid(PSID);
600 BOOL WINAPI EqualSid(PSID,PSID);
601 BOOL WINAPI EqualPrefixSid(PSID,PSID);
602 DWORD  WINAPI GetSidLengthRequired(BYTE);
603 BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,
604                                        DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,
605                                        DWORD,PSID*);
606 VOID*  WINAPI FreeSid(PSID);
607 BOOL WINAPI InitializeSecurityDescriptor(SECURITY_DESCRIPTOR*,DWORD);
608 BOOL WINAPI InitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
609 DWORD* WINAPI GetSidSubAuthority(PSID,DWORD);
610 BYTE * WINAPI GetSidSubAuthorityCount(PSID);
611 DWORD  WINAPI GetLengthSid(PSID);
612 BOOL WINAPI CopySid(DWORD,PSID,PSID);
613 BOOL WINAPI LookupAccountSidA(LPCSTR,PSID,LPCSTR,LPDWORD,LPCSTR,LPDWORD,
614                                   PSID_NAME_USE);
615 BOOL WINAPI LookupAccountSidW(LPCWSTR,PSID,LPCWSTR,LPDWORD,LPCWSTR,LPDWORD,
616                                   PSID_NAME_USE);
617 PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
618
619 #ifdef __cplusplus
620 }
621 #endif
622
623 #endif