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

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

header updates
File size: 28.2 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 "ntdef.h"
10#include "winnt.h"
11#include "winreg.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
32#ifdef __WIN32OS2__
33typedef VOID (* NTAPI PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
34#else
35typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
36#endif
37
38/*
39 registry
40 */
41
42 /* key information */
43typedef struct _KEY_BASIC_INFORMATION {
44 LARGE_INTEGER LastWriteTime;
45 ULONG TitleIndex;
46 ULONG NameLength;
47 WCHAR Name[1];
48} KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
49
50typedef struct _KEY_NODE_INFORMATION
51{
52 LARGE_INTEGER LastWriteTime;
53 ULONG TitleIndex;
54 ULONG ClassOffset;
55 ULONG ClassLength;
56 ULONG NameLength;
57 WCHAR Name[1];
58/* Class[1]; */
59} KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
60
61typedef struct _KEY_FULL_INFORMATION
62{
63 LARGE_INTEGER LastWriteTime;
64 ULONG TitleIndex;
65 ULONG ClassOffset;
66 ULONG ClassLength;
67 ULONG SubKeys;
68 ULONG MaxNameLen;
69 ULONG MaxClassLen;
70 ULONG Values;
71 ULONG MaxValueNameLen;
72 ULONG MaxValueDataLen;
73 WCHAR Class[1];
74} KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
75
76typedef enum _KEY_INFORMATION_CLASS
77{
78 KeyBasicInformation,
79 KeyNodeInformation,
80 KeyFullInformation
81} KEY_INFORMATION_CLASS;
82
83typedef struct _KEY_VALUE_ENTRY
84{
85 PUNICODE_STRING ValueName;
86 ULONG DataLength;
87 ULONG DataOffset;
88 ULONG Type;
89} KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
90
91/* value information */
92typedef struct _KEY_VALUE_BASIC_INFORMATION
93{
94 ULONG TitleIndex;
95 ULONG Type;
96 ULONG NameLength;
97 WCHAR Name[1];
98} KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
99
100typedef struct _KEY_VALUE_FULL_INFORMATION
101{
102 ULONG TitleIndex;
103 ULONG Type;
104 ULONG DataOffset;
105 ULONG DataLength;
106 ULONG NameLength;
107 WCHAR Name[1];
108/* UCHAR Data[1];*/
109} KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
110
111typedef struct _KEY_VALUE_PARTIAL_INFORMATION
112{
113 ULONG TitleIndex;
114 ULONG Type;
115 ULONG DataLength;
116 UCHAR Data[1];
117} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
118
119typedef enum _KEY_VALUE_INFORMATION_CLASS
120{
121 KeyValueBasicInformation,
122 KeyValueFullInformation,
123 KeyValuePartialInformation,
124 KeyValueFullInformationAlign64,
125 KeyValuePartialInformationAlign64
126} KEY_VALUE_INFORMATION_CLASS;
127
128NTSTATUS WINAPI RtlFormatCurrentUserKeyPath(
129 PUNICODE_STRING KeyPath);
130
131/* thread information */
132
133typedef enum _THREADINFOCLASS
134{ ThreadBasicInformation,
135 ThreadTimes,
136 ThreadPriority,
137 ThreadBasePriority,
138 ThreadAffinityMask,
139 ThreadImpersonationToken,
140 ThreadDescriptorTableEntry,
141 ThreadEnableAlignmentFaultFixup,
142 ThreadEventPair_Reusable,
143 ThreadQuerySetWin32StartAddress,
144 ThreadZeroTlsCell,
145 ThreadPerformanceCount,
146 ThreadAmILastThread,
147 ThreadIdealProcessor,
148 ThreadPriorityBoost,
149 ThreadSetTlsArrayAddress,
150 ThreadIsIoPending,
151 MaxThreadInfoClass
152} THREADINFOCLASS;
153
154typedef struct {
155/* This is used by NtQuerySystemInformation */
156 FILETIME ftCreationTime;
157 DWORD dwUnknown1;
158 DWORD dwStartAddress;
159 DWORD dwOwningPID;
160 DWORD dwThreadID;
161 DWORD dwCurrentPriority;
162 DWORD dwBasePriority;
163 DWORD dwContextSwitches;
164 DWORD dwThreadState;
165 DWORD dwWaitReason;
166 DWORD dwUnknown2[5];
167} THREADINFO, *PTHREADINFO;
168
169/* file information */
170
171typedef enum _FILE_INFORMATION_CLASS {
172 FileDirectoryInformation = 1,
173 FileFullDirectoryInformation,
174 FileBothDirectoryInformation,
175 FileBasicInformation,
176 FileStandardInformation,
177 FileInternalInformation,
178 FileEaInformation,
179 FileAccessInformation,
180 FileNameInformation,
181 FileRenameInformation,
182 FileLinkInformation,
183 FileNamesInformation,
184 FileDispositionInformation,
185 FilePositionInformation,
186 FileFullEaInformation,
187 FileModeInformation,
188 FileAlignmentInformation,
189 FileAllInformation,
190 FileAllocationInformation,
191 FileEndOfFileInformation,
192 FileAlternateNameInformation,
193 FileStreamInformation,
194 FilePipeInformation,
195 FilePipeLocalInformation,
196 FilePipeRemoteInformation,
197 FileMailslotQueryInformation,
198 FileMailslotSetInformation,
199 FileCompressionInformation,
200 FileObjectIdInformation,
201 FileCompletionInformation,
202 FileMoveClusterInformation,
203 FileQuotaInformation,
204 FileReparsePointInformation,
205 FileNetworkOpenInformation,
206 FileAttributeTagInformation,
207 FileTrackingInformation,
208 FileMaximumInformation
209} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
210
211typedef enum _FSINFOCLASS {
212 FileFsVolumeInformation = 1,
213 FileFsLabelInformation,
214 FileFsSizeInformation,
215 FileFsDeviceInformation,
216 FileFsAttributeInformation,
217 FileFsControlInformation,
218 FileFsFullSizeInformation,
219 FileFsObjectIdInformation,
220 FileFsMaximumInformation
221} FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
222
223typedef enum _SECTION_INHERIT
224{
225 ViewShare = 1,
226 ViewUnmap = 2
227
228} SECTION_INHERIT;
229
230/* object information */
231
232typedef enum _OBJECT_INFORMATION_CLASS
233{
234 DunnoTheConstants1
235
236} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
237
238
239/* system information */
240
241typedef enum SYSTEM_INFORMATION_CLASS
242{ SystemBasicInformation = 0,
243 Unknown1,
244 SystemPerformanceInformation,
245 SystemTimeInformation,
246 Unknown4,
247 SystemProcessInformation,
248 Unknown6,
249 Unknown7,
250 Unknown8,
251 Unknown9,
252 Unknown10,
253 SystemDriverInformation,
254 Unknown12,
255 Unknown13,
256 Unknown14,
257 Unknown15,
258 SystemHandleList,
259 Unknown17,
260 Unknown18,
261 Unknown19,
262 Unknown20,
263 SystemCacheInformation
264} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
265
266typedef struct {
267/* System Information Class 0x00 */
268 DWORD dwUnknown1;
269 ULONG uKeMaximumIncrement;
270 ULONG uPageSize;
271 ULONG uMmNumberOfPhysicalPages;
272 ULONG uMmLowestPhysicalPage;
273 ULONG uMmHighestPhysicalPage;
274 ULONG uAllocationGranularity;
275 PVOID pLowestUserAddress;
276 PVOID pMmHighestUserAddress;
277 ULONG uKeActiveProcessors;
278 BYTE bKeNumberProcessors;
279 BYTE bUnknown2;
280 WORD wUnknown3;
281} SYSTEM_BASIC_INFORMATION;
282
283typedef struct {
284/* System Information Class 0x02 */
285 LARGE_INTEGER liIdleTime;
286 DWORD dwSpare[76];
287} SYSTEM_PERFORMANCE_INFORMATION;
288
289typedef struct {
290/* System Information Class 0x03 */
291 LARGE_INTEGER liKeBootTime;
292 LARGE_INTEGER liKeSystemTime;
293 LARGE_INTEGER liExpTimeZoneBias;
294 ULONG uCurrentTimeZoneId;
295 DWORD dwReserved;
296} SYSTEM_TIME_INFORMATION;
297
298typedef struct {
299/* System Information Class 0x05 */
300 DWORD dwOffset;
301 DWORD dwThreadCount;
302 DWORD dwUnknown1[6];
303 FILETIME ftCreationTime;
304 DWORD dwUnknown2[5];
305 WCHAR* pszProcessName;
306 DWORD dwBasePriority;
307 DWORD dwProcessID;
308 DWORD dwParentProcessID;
309 DWORD dwHandleCount;
310 DWORD dwUnknown3;
311 DWORD dwUnknown4;
312 DWORD dwVirtualBytesPeak;
313 DWORD dwVirtualBytes;
314 DWORD dwPageFaults;
315 DWORD dwWorkingSetPeak;
316 DWORD dwWorkingSet;
317 DWORD dwUnknown5;
318 DWORD dwPagedPool;
319 DWORD dwUnknown6;
320 DWORD dwNonPagedPool;
321 DWORD dwPageFileBytesPeak;
322 DWORD dwPrivateBytes;
323 DWORD dwPageFileBytes;
324 DWORD dwUnknown7[4];
325#ifdef __WIN32OS2__
326 THREADINFO ti[1];
327#else
328 THREADINFO ti[0];
329#endif
330} SYSTEM_PROCESS_INFORMATION;
331
332typedef struct {
333/* System Information Class 0x0b */
334 PVOID pvAddress;
335 DWORD dwUnknown1;
336 DWORD dwUnknown2;
337 DWORD dwEntryIndex;
338 DWORD dwUnknown3;
339 char szName[MAX_PATH + 1];
340} SYSTEM_DRIVER_INFORMATION;
341
342typedef struct {
343/* System Information Class 0x10 */
344 USHORT dwPID;
345 USHORT dwCreatorBackTraceIndex;
346 BYTE bObjectType;
347 BYTE bHandleAttributes;
348 USHORT usHandleOffset;
349 DWORD dwKeObject;
350 ULONG ulGrantedAccess;
351} HANDLEINFO, *PHANDLEINFO;
352
353typedef struct {
354/* System Information Class 0x15 */
355 ULONG CurrentSize;
356 ULONG PeakSize;
357 ULONG PageFaultCount;
358 ULONG MinimumWorkingSet;
359 ULONG MaximumWorkingSet;
360 ULONG unused[4];
361} SYSTEM_CACHE_INFORMATION;
362
363/* reading coffee grounds... */
364typedef struct _THREAD_INFO
365{ DWORD Unknown1[6];
366 DWORD ThreadID;
367 DWORD Unknown2[3];
368 DWORD Status;
369 DWORD WaitReason;
370 DWORD Unknown3[4];
371} THREAD_INFO, PTHREAD_INFO;
372
373typedef struct _VM_COUNTERS_
374{ ULONG PeakVirtualSize;
375 ULONG VirtualSize;
376 ULONG PageFaultCount;
377 ULONG PeakWorkingSetSize;
378 ULONG WorkingSetSize;
379 ULONG QuotaPeakPagedPoolUsage;
380 ULONG QuotaPagedPoolUsage;
381 ULONG QuotaPeakNonPagedPoolUsage;
382 ULONG QuotaNonPagedPoolUsage;
383 ULONG PagefileUsage;
384 ULONG PeakPagefileUsage;
385} VM_COUNTERS, *PVM_COUNTERS;
386
387/* process information */
388
389typedef struct _PROCESS_INFO
390{ DWORD Offset; /* 00 offset to next PROCESS_INFO ok*/
391 DWORD ThreadCount; /* 04 number of ThreadInfo member ok */
392 DWORD Unknown1[6];
393 FILETIME CreationTime; /* 20 */
394 DWORD Unknown2[5];
395 PWCHAR ProcessName; /* 3c ok */
396 DWORD BasePriority;
397 DWORD ProcessID; /* 44 ok*/
398 DWORD ParentProcessID;
399 DWORD HandleCount;
400 DWORD Unknown3[2]; /* 50 */
401 ULONG PeakVirtualSize;
402 ULONG VirtualSize;
403 ULONG PageFaultCount;
404 ULONG PeakWorkingSetSize;
405 ULONG WorkingSetSize;
406 ULONG QuotaPeakPagedPoolUsage;
407 ULONG QuotaPagedPoolUsage;
408 ULONG QuotaPeakNonPagedPoolUsage;
409 ULONG QuotaNonPagedPoolUsage;
410 ULONG PagefileUsage;
411 ULONG PeakPagefileUsage;
412 DWORD PrivateBytes;
413 DWORD Unknown6[4];
414 THREAD_INFO ati[ANYSIZE_ARRAY]; /* 94 size=0x40*/
415} PROCESS_INFO, PPROCESS_INFO;
416
417NTSTATUS WINAPI NtQuerySystemInformation(
418 IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
419 OUT PVOID SystemInformation,
420 IN ULONG Length,
421 OUT PULONG ResultLength);
422
423/*
424 * system configuration
425 */
426
427
428typedef struct _SYSTEM_TIME_ADJUSTMENT
429{
430 ULONG TimeAdjustment;
431 BOOLEAN TimeAdjustmentDisabled;
432
433} SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
434
435typedef struct _SYSTEM_CONFIGURATION_INFO
436{
437 union
438 { ULONG OemId;
439 struct
440 { WORD ProcessorArchitecture;
441 WORD Reserved;
442 } tag1;
443 } tag2;
444 ULONG PageSize;
445 PVOID MinimumApplicationAddress;
446 PVOID MaximumApplicationAddress;
447 ULONG ActiveProcessorMask;
448 ULONG NumberOfProcessors;
449 ULONG ProcessorType;
450 ULONG AllocationGranularity;
451 WORD ProcessorLevel;
452 WORD ProcessorRevision;
453
454} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
455
456
457/*
458 * NtQueryProcessInformation
459 */
460
461/* parameter ProcessInformationClass */
462
463typedef enum _PROCESSINFOCLASS
464{ ProcessBasicInformation,
465 ProcessQuotaLimits,
466 ProcessIoCounters,
467 ProcessVmCounters,
468 ProcessTimes,
469 ProcessBasePriority,
470 ProcessRaisePriority,
471 ProcessDebugPort,
472 ProcessExceptionPort,
473 ProcessAccessToken,
474 ProcessLdtInformation,
475 ProcessLdtSize,
476 ProcessDefaultHardErrorMode,
477 ProcessIoPortHandlers,
478 ProcessPooledUsageAndLimits,
479 ProcessWorkingSetWatch,
480 ProcessUserModeIOPL,
481 ProcessEnableAlignmentFaultFixup,
482 ProcessPriorityClass,
483 ProcessWx86Information,
484 ProcessHandleCount,
485 ProcessAffinityMask,
486 ProcessPriorityBoost,
487 ProcessDeviceMap,
488 ProcessSessionInformation,
489 ProcessForegroundInformation,
490 ProcessWow64Information,
491 MaxProcessInfoClass
492} PROCESSINFOCLASS;
493
494/* parameter ProcessInformation (depending on ProcessInformationClass) */
495
496typedef struct _PROCESS_BASIC_INFORMATION
497{ DWORD ExitStatus;
498 DWORD PebBaseAddress;
499 DWORD AffinityMask;
500 DWORD BasePriority;
501 ULONG UniqueProcessId;
502 ULONG InheritedFromUniqueProcessId;
503} PROCESS_BASIC_INFORMATION;
504
505NTSTATUS WINAPI NtQueryInformationProcess(
506 IN HANDLE ProcessHandle,
507 IN PROCESSINFOCLASS ProcessInformationClass,
508 OUT PVOID ProcessInformation,
509 IN ULONG ProcessInformationLength,
510 OUT PULONG ReturnLength);
511
512#define NtCurrentProcess() ( (HANDLE) -1 )
513
514/*
515 * timer
516 */
517
518typedef enum _TIMER_TYPE
519{
520 NotificationTimer,
521 SynchronizationTimer
522
523} TIMER_TYPE;
524
525/* token functions */
526
527NTSTATUS WINAPI NtOpenProcessToken(
528 HANDLE ProcessHandle,
529 DWORD DesiredAccess,
530 HANDLE *TokenHandle);
531
532NTSTATUS WINAPI NtOpenThreadToken(
533 HANDLE ThreadHandle,
534 DWORD DesiredAccess,
535 BOOLEAN OpenAsSelf,
536 HANDLE *TokenHandle);
537
538NTSTATUS WINAPI NtAdjustPrivilegesToken(
539 IN HANDLE TokenHandle,
540 IN BOOLEAN DisableAllPrivileges,
541 IN PTOKEN_PRIVILEGES NewState,
542 IN DWORD BufferLength,
543 OUT PTOKEN_PRIVILEGES PreviousState,
544 OUT PDWORD ReturnLength);
545
546NTSTATUS WINAPI NtQueryInformationToken(
547 HANDLE token,
548 DWORD tokeninfoclass,
549 LPVOID tokeninfo,
550 DWORD tokeninfolength,
551 LPDWORD retlen );
552
553/* sid functions */
554
555BOOLEAN WINAPI RtlAllocateAndInitializeSid (
556 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
557 BYTE nSubAuthorityCount,
558 DWORD nSubAuthority0, DWORD nSubAuthority1,
559 DWORD nSubAuthority2, DWORD nSubAuthority3,
560 DWORD nSubAuthority4, DWORD nSubAuthority5,
561 DWORD nSubAuthority6, DWORD nSubAuthority7,
562 PSID *pSid );
563
564BOOL WINAPI RtlInitializeSid(
565 PSID pSid,
566 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
567 BYTE nSubAuthorityCount);
568
569DWORD WINAPI RtlFreeSid(
570 PSID pSid);
571
572BOOL WINAPI RtlEqualSid(
573 PSID pSid1,
574 PSID pSid2 );
575
576DWORD WINAPI RtlLengthRequiredSid(
577 DWORD nrofsubauths);
578
579DWORD WINAPI RtlLengthSid(
580 PSID sid);
581
582LPDWORD WINAPI RtlSubAuthoritySid(
583 PSID PSID,
584 DWORD nr);
585
586LPBYTE WINAPI RtlSubAuthorityCountSid(
587 PSID pSid);
588
589DWORD WINAPI RtlCopySid(
590 DWORD len,
591 PSID to,
592 PSID from);
593
594BOOL WINAPI RtlValidSid(
595 PSID pSid);
596
597BOOL WINAPI RtlEqualPrefixSid(
598 PSID pSid1,
599 PSID pSid2);
600
601PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(
602 PSID pSid );
603
604/* security descriptor functions */
605
606NTSTATUS WINAPI RtlCreateSecurityDescriptor(
607 PSECURITY_DESCRIPTOR lpsd,
608 DWORD rev);
609
610NTSTATUS WINAPI RtlValidSecurityDescriptor(
611 PSECURITY_DESCRIPTOR SecurityDescriptor);
612
613ULONG WINAPI RtlLengthSecurityDescriptor(
614 PSECURITY_DESCRIPTOR SecurityDescriptor);
615
616NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
617 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
618 OUT PBOOLEAN lpbDaclPresent,
619 OUT PACL *pDacl,
620 OUT PBOOLEAN lpbDaclDefaulted);
621
622NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
623 PSECURITY_DESCRIPTOR lpsd,
624 BOOLEAN daclpresent,
625 PACL dacl,
626 BOOLEAN dacldefaulted );
627
628NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
629 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
630 OUT PBOOLEAN lpbSaclPresent,
631 OUT PACL *pSacl,
632 OUT PBOOLEAN lpbSaclDefaulted);
633
634NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
635 PSECURITY_DESCRIPTOR lpsd,
636 BOOLEAN saclpresent,
637 PACL sacl,
638 BOOLEAN sacldefaulted);
639
640NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
641 PSECURITY_DESCRIPTOR SecurityDescriptor,
642 PSID *Owner,
643 PBOOLEAN OwnerDefaulted);
644
645NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
646 PSECURITY_DESCRIPTOR lpsd,
647 PSID owner,
648 BOOLEAN ownerdefaulted);
649
650NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
651 PSECURITY_DESCRIPTOR lpsd,
652 PSID group,
653 BOOLEAN groupdefaulted);
654
655NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
656 PSECURITY_DESCRIPTOR SecurityDescriptor,
657 PSID *Group,
658 PBOOLEAN GroupDefaulted);
659
660NTSTATUS WINAPI RtlMakeSelfRelativeSD(
661 IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
662 IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
663 IN OUT LPDWORD lpdwBufferLength);
664
665NTSTATUS WINAPI RtlGetControlSecurityDescriptor(
666 PSECURITY_DESCRIPTOR pSecurityDescriptor,
667 PSECURITY_DESCRIPTOR_CONTROL pControl,
668 LPDWORD lpdwRevision);
669
670/* acl functions */
671
672NTSTATUS WINAPI RtlCreateAcl(
673 PACL acl,
674 DWORD size,
675 DWORD rev);
676
677BOOLEAN WINAPI RtlFirstFreeAce(
678 PACL acl,
679 PACE_HEADER *x);
680
681NTSTATUS WINAPI RtlAddAce(
682 PACL acl,
683 DWORD rev,
684 DWORD xnrofaces,
685 PACE_HEADER acestart,
686 DWORD acelen);
687
688BOOL WINAPI RtlAddAccessAllowedAce(
689 IN OUT PACL pAcl,
690 IN DWORD dwAceRevision,
691 IN DWORD AccessMask,
692 IN PSID pSid);
693
694BOOL WINAPI AddAccessAllowedAceEx(
695 IN OUT PACL pAcl,
696 IN DWORD dwAceRevision,
697 IN DWORD AceFlags,
698 IN DWORD AccessMask,
699 IN PSID pSid);
700
701DWORD WINAPI RtlGetAce(
702 PACL pAcl,
703 DWORD dwAceIndex,
704 LPVOID *pAce );
705
706/* string functions */
707
708DWORD WINAPI RtlAnsiStringToUnicodeSize(const STRING*);
709NTSTATUS WINAPI RtlAnsiStringToUnicodeString(UNICODE_STRING*,const STRING *,BOOLEAN);
710NTSTATUS WINAPI RtlAppendAsciizToString(STRING*,LPCSTR);
711NTSTATUS WINAPI RtlAppendStringToString(STRING*,const STRING*);
712NTSTATUS WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING*,const UNICODE_STRING*);
713NTSTATUS WINAPI RtlAppendUnicodeToString(UNICODE_STRING*,LPCWSTR);
714LONG WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
715LONG WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
716void WINAPI RtlCopyString(STRING*,const STRING*);
717void WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
718BOOLEAN WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
719BOOLEAN WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
720void WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
721BOOLEAN WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
722BOOLEAN WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
723void WINAPI RtlFreeAnsiString(PSTRING);
724void WINAPI RtlFreeOemString(PSTRING);
725void WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
726void WINAPI RtlInitAnsiString(PSTRING,LPCSTR);
727void WINAPI RtlInitString(PSTRING,LPCSTR);
728void WINAPI RtlInitUnicodeString(PUNICODE_STRING,LPCWSTR);
729NTSTATUS WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
730NTSTATUS WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
731UINT WINAPI RtlOemStringToUnicodeSize(const STRING*);
732NTSTATUS WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
733NTSTATUS WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
734BOOLEAN WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
735BOOLEAN WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
736DWORD WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
737NTSTATUS WINAPI RtlUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
738DWORD WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
739NTSTATUS WINAPI RtlUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
740NTSTATUS WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
741NTSTATUS WINAPI RtlUnicodeToMultiByteSize(DWORD*,LPCWSTR,UINT);
742NTSTATUS WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
743NTSTATUS WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
744NTSTATUS WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
745NTSTATUS WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
746NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
747NTSTATUS WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
748
749DWORD WINAPI RtlIsTextUnicode(
750 LPVOID buf,
751 DWORD len,
752 DWORD *pf);
753
754INT __cdecl wcstol(LPCWSTR,LPWSTR*,INT);
755
756/* resource functions */
757
758typedef struct _RTL_RWLOCK {
759 CRITICAL_SECTION rtlCS;
760 HANDLE hSharedReleaseSemaphore;
761 UINT uSharedWaiters;
762 HANDLE hExclusiveReleaseSemaphore;
763 UINT uExclusiveWaiters;
764 INT iNumberActive;
765 HANDLE hOwningThreadId;
766 DWORD dwTimeoutBoost;
767 PVOID pDebugInfo;
768} RTL_RWLOCK, *LPRTL_RWLOCK;
769
770VOID WINAPI RtlInitializeResource(
771 LPRTL_RWLOCK);
772
773VOID WINAPI RtlDeleteResource(
774 LPRTL_RWLOCK);
775
776BYTE WINAPI RtlAcquireResourceExclusive(
777 LPRTL_RWLOCK, BYTE fWait);
778
779BYTE WINAPI RtlAcquireResourceShared(
780 LPRTL_RWLOCK, BYTE fWait);
781
782VOID WINAPI RtlReleaseResource(
783 LPRTL_RWLOCK);
784
785VOID WINAPI RtlDumpResource(
786 LPRTL_RWLOCK);
787
788/* time functions */
789
790typedef struct _TIME_FIELDS
791{ CSHORT Year;
792 CSHORT Month;
793 CSHORT Day;
794 CSHORT Hour;
795 CSHORT Minute;
796 CSHORT Second;
797 CSHORT Milliseconds;
798 CSHORT Weekday;
799} TIME_FIELDS;
800
801typedef TIME_FIELDS *PTIME_FIELDS;
802
803VOID WINAPI RtlSystemTimeToLocalTime(
804 IN PLARGE_INTEGER SystemTime,
805 OUT PLARGE_INTEGER LocalTime);
806
807VOID WINAPI RtlTimeToTimeFields(
808 PLARGE_INTEGER liTime,
809 PTIME_FIELDS TimeFields);
810
811BOOLEAN WINAPI RtlTimeFieldsToTime(
812 PTIME_FIELDS tfTimeFields,
813 PLARGE_INTEGER Time);
814
815VOID WINAPI RtlTimeToElapsedTimeFields(
816 PLARGE_INTEGER liTime,
817 PTIME_FIELDS TimeFields);
818
819void WINAPI NtQuerySystemTime( LARGE_INTEGER *time );
820
821BOOLEAN WINAPI RtlTimeToSecondsSince1980( const FILETIME *time, LPDWORD res );
822BOOLEAN WINAPI RtlTimeToSecondsSince1970( const FILETIME *time, LPDWORD res );
823void WINAPI RtlSecondsSince1970ToTime( DWORD time, FILETIME *res );
824void WINAPI RtlSecondsSince1980ToTime( DWORD time, FILETIME *res );
825
826/* heap functions */
827
828/* Data structure for heap definition. This includes various
829 sizing parameters and callback routines, which, if left NULL,
830 result in default behavior */
831
832typedef struct
833{ ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
834 ULONG Unknown[11];
835} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
836
837HANDLE WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
838HANDLE WINAPI RtlDestroyHeap(HANDLE);
839PVOID WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
840BOOLEAN WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
841PVOID WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
842ULONG WINAPI RtlCompactHeap(HANDLE,ULONG);
843BOOLEAN WINAPI RtlLockHeap(HANDLE);
844BOOLEAN WINAPI RtlUnlockHeap(HANDLE);
845ULONG WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
846BOOLEAN WINAPI RtlValidateHeap(HANDLE,ULONG,PCVOID);
847ULONG WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
848NTSTATUS WINAPI RtlWalkHeap(HANDLE,PVOID);
849
850/* exception */
851
852void WINAPI NtRaiseException(
853 PEXCEPTION_RECORD,PCONTEXT,BOOL);
854
855void WINAPI RtlRaiseException(
856 PEXCEPTION_RECORD);
857
858void WINAPI RtlRaiseStatus(
859 NTSTATUS);
860
861void WINAPI RtlUnwind(
862 PEXCEPTION_FRAME,
863 LPVOID,
864 PEXCEPTION_RECORD,DWORD);
865
866/* process environment block */
867VOID WINAPI RtlAcquirePebLock(void);
868VOID WINAPI RtlReleasePebLock(void);
869
870/* mathematics */
871LONGLONG WINAPI RtlConvertLongToLargeInteger( LONG a );
872LONGLONG WINAPI RtlEnlargedIntegerMultiply( INT a, INT b );
873LONGLONG WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift );
874LONGLONG WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b );
875LONGLONG WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem );
876LONGLONG WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b );
877LONGLONG WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count );
878LONGLONG WINAPI RtlLargeIntegerNegate( LONGLONG a );
879LONGLONG WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count );
880LONGLONG WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count );
881LONGLONG WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b );
882ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b );
883UINT WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr );
884ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a );
885ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem );
886
887/* environment */
888DWORD WINAPI RtlCreateEnvironment(
889 DWORD x1,
890 DWORD x2);
891
892DWORD WINAPI RtlDestroyEnvironment(
893 DWORD x);
894
895DWORD WINAPI RtlQueryEnvironmentVariable_U(
896 DWORD x1,
897 PUNICODE_STRING key,
898 PUNICODE_STRING val) ;
899
900DWORD WINAPI RtlSetEnvironmentVariable(
901 DWORD x1,
902 PUNICODE_STRING key,
903 PUNICODE_STRING val);
904
905/* object security */
906
907DWORD WINAPI RtlNewSecurityObject(
908 DWORD x1,
909 DWORD x2,
910 DWORD x3,
911 DWORD x4,
912 DWORD x5,
913 DWORD x6);
914
915DWORD WINAPI RtlDeleteSecurityObject(
916 DWORD x1);
917
918NTSTATUS WINAPI
919NtQuerySecurityObject(
920 IN HANDLE Object,
921 IN SECURITY_INFORMATION RequestedInformation,
922 OUT PSECURITY_DESCRIPTOR pSecurityDesriptor,
923 IN ULONG Length,
924 OUT PULONG ResultLength);
925
926NTSTATUS WINAPI
927NtSetSecurityObject(
928 IN HANDLE Handle,
929 IN SECURITY_INFORMATION SecurityInformation,
930 IN PSECURITY_DESCRIPTOR SecurityDescriptor);
931
932/* registry functions */
933
934NTSTATUS WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,
935 const UNICODE_STRING*,ULONG,PULONG);
936NTSTATUS WINAPI NtDeleteKey(HANDLE);
937NTSTATUS WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING*);
938NTSTATUS WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
939NTSTATUS WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
940NTSTATUS WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING*,ULONG,ULONG,const void*,ULONG);
941NTSTATUS WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
942NTSTATUS WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING*,KEY_VALUE_INFORMATION_CLASS,
943 void*,DWORD,DWORD*);
944NTSTATUS WINAPI NtLoadKey(const OBJECT_ATTRIBUTES*,const OBJECT_ATTRIBUTES*);
945
946
947NTSTATUS WINAPI NtEnumerateValueKey(
948 HANDLE KeyHandle,
949 ULONG Index,
950 KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
951 PVOID KeyInformation,
952 ULONG Length,
953 PULONG ResultLength);
954
955NTSTATUS WINAPI NtFlushKey(HANDLE KeyHandle);
956
957NTSTATUS WINAPI NtNotifyChangeKey(
958 IN HANDLE KeyHandle,
959 IN HANDLE Event,
960 IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
961 IN PVOID ApcContext OPTIONAL,
962 OUT PIO_STATUS_BLOCK IoStatusBlock,
963 IN ULONG CompletionFilter,
964 IN BOOLEAN Asynchroneous,
965 OUT PVOID ChangeBuffer,
966 IN ULONG Length,
967 IN BOOLEAN WatchSubtree);
968
969NTSTATUS WINAPI NtQueryMultipleValueKey(
970 HANDLE KeyHandle,
971 PVALENTW ListOfValuesToQuery,
972 ULONG NumberOfItems,
973 PVOID MultipleValueInformation,
974 ULONG Length,
975 PULONG ReturnLength);
976
977NTSTATUS WINAPI NtReplaceKey(
978 IN POBJECT_ATTRIBUTES ObjectAttributes,
979 IN HANDLE Key,
980 IN POBJECT_ATTRIBUTES ReplacedObjectAttributes);
981
982NTSTATUS WINAPI NtRestoreKey(
983 HANDLE KeyHandle,
984 HANDLE FileHandle,
985 ULONG RestoreFlags);
986
987NTSTATUS WINAPI NtSaveKey(
988 IN HANDLE KeyHandle,
989 IN HANDLE FileHandle);
990
991NTSTATUS WINAPI NtSetInformationKey(
992 IN HANDLE KeyHandle,
993 IN const int KeyInformationClass,
994 IN PVOID KeyInformation,
995 IN ULONG KeyInformationLength);
996
997NTSTATUS WINAPI NtUnloadKey(
998 IN HANDLE KeyHandle);
999
1000NTSTATUS WINAPI NtClose(
1001 HANDLE Handle);
1002
1003NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
1004NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
1005
1006NTSTATUS WINAPI NtClearEvent(HANDLE);
1007NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1008NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
1009NTSTATUS WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *attr);
1010NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
1011NTSTATUS WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
1012NTSTATUS WINAPI NtResetEvent(HANDLE,PULONG);
1013NTSTATUS WINAPI NtSetEvent(HANDLE,PULONG);
1014
1015NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit );
1016NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount );
1017NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit );
1018NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit );
1019NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit );
1020NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1021BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1022NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit );
1023
1024/* string functions */
1025extern LPSTR _strlwr( LPSTR str );
1026extern LPSTR _strupr( LPSTR str );
1027
1028/* misc */
1029
1030#if defined(__i386__) && defined(__GNUC__)
1031static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
1032static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
1033#else /* __i386__ && __GNUC__ */
1034void WINAPI DbgBreakPoint(void);
1035void WINAPI DbgUserBreakPoint(void);
1036#endif /* __i386__ && __GNUC__ */
1037void WINAPIV DbgPrint(LPCSTR fmt, ...);
1038
1039DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
1040DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
1041LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
1042DWORD WINAPI RtlNtStatusToDosError(DWORD error);
1043BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
1044PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule);
1045
1046DWORD WINAPI RtlOpenCurrentUser(
1047 IN ACCESS_MASK DesiredAccess,
1048 OUT PHANDLE KeyHandle);
1049
1050BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
1051BOOL WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
1052
1053NTSTATUS WINAPI
1054NtAccessCheck(
1055 IN PSECURITY_DESCRIPTOR SecurityDescriptor,
1056 IN HANDLE ClientToken,
1057 IN ACCESS_MASK DesiredAccess,
1058 IN PGENERIC_MAPPING GenericMapping,
1059 OUT PPRIVILEGE_SET PrivilegeSet,
1060 OUT PULONG ReturnLength,
1061 OUT PULONG GrantedAccess,
1062 OUT PBOOLEAN AccessStatus);
1063
1064#ifdef __cplusplus
1065}
1066#endif
1067
1068#endif
Note: See TracBrowser for help on using the repository browser.