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

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

Port: NTDLL from Wine-990508 (almost) completely ported. 64-bit integer arithmtic missing.

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