source: trunk/include/win/ntddk.h@ 5566

Last change on this file since 5566 was 5566, checked in by sandervl, 24 years ago

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