source: trunk/src/NTDLL/ntdll.h@ 155

Last change on this file since 155 was 97, checked in by phaller, 26 years ago

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