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

Last change on this file since 9735 was 9683, checked in by sandervl, 23 years ago

PF: Changes for building ntdll with GCC
File size: 29.9 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
754/* resource functions */
755
756typedef struct _RTL_RWLOCK {
757 CRITICAL_SECTION rtlCS;
758 HANDLE hSharedReleaseSemaphore;
759 UINT uSharedWaiters;
760 HANDLE hExclusiveReleaseSemaphore;
761 UINT uExclusiveWaiters;
762 INT iNumberActive;
763 HANDLE hOwningThreadId;
764 DWORD dwTimeoutBoost;
765 PVOID pDebugInfo;
766} RTL_RWLOCK, *LPRTL_RWLOCK;
767
768VOID WINAPI RtlInitializeResource(
769 LPRTL_RWLOCK);
770
771VOID WINAPI RtlDeleteResource(
772 LPRTL_RWLOCK);
773
774BYTE WINAPI RtlAcquireResourceExclusive(
775 LPRTL_RWLOCK, BYTE fWait);
776
777BYTE WINAPI RtlAcquireResourceShared(
778 LPRTL_RWLOCK, BYTE fWait);
779
780VOID WINAPI RtlReleaseResource(
781 LPRTL_RWLOCK);
782
783VOID WINAPI RtlDumpResource(
784 LPRTL_RWLOCK);
785
786/* time functions */
787
788typedef struct _TIME_FIELDS
789{ CSHORT Year;
790 CSHORT Month;
791 CSHORT Day;
792 CSHORT Hour;
793 CSHORT Minute;
794 CSHORT Second;
795 CSHORT Milliseconds;
796 CSHORT Weekday;
797} TIME_FIELDS;
798
799typedef TIME_FIELDS *PTIME_FIELDS;
800
801void WINAPI RtlSystemTimeToLocalTime(PLARGE_INTEGER,PLARGE_INTEGER);
802void WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
803
804BOOLEAN WINAPI RtlTimeFieldsToTime(
805 PTIME_FIELDS tfTimeFields,
806 PLARGE_INTEGER Time);
807
808VOID WINAPI RtlTimeToElapsedTimeFields(
809 PLARGE_INTEGER liTime,
810 PTIME_FIELDS TimeFields);
811
812NTSTATUS WINAPI NtQuerySystemTime(PLARGE_INTEGER);
813
814void WINAPI RtlSecondsSince1970ToTime(DWORD,LARGE_INTEGER *);
815void WINAPI RtlSecondsSince1980ToTime(DWORD,LARGE_INTEGER *);
816BOOLEAN WINAPI RtlTimeToSecondsSince1970(const LARGE_INTEGER *,PULONG);
817BOOLEAN WINAPI RtlTimeToSecondsSince1980(const LARGE_INTEGER *,LPDWORD);
818
819typedef struct tagRTL_BITMAP {
820 ULONG SizeOfBitMap; /* Number of bits in the bitmap */
821 LPBYTE BitMapBuffer; /* Bitmap data, assumed sized to a DWORD boundary */
822} RTL_BITMAP, *PRTL_BITMAP;
823
824typedef const RTL_BITMAP *PCRTL_BITMAP;
825
826typedef struct tagRTL_BITMAP_RUN {
827 ULONG StartOfRun; /* Bit position at which run starts - FIXME: Name? */
828 ULONG SizeOfRun; /* Size of the run in bits - FIXME: Name? */
829} RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;
830
831typedef const RTL_BITMAP_RUN *PCRTL_BITMAP_RUN;
832
833/* heap functions */
834
835/* Data structure for heap definition. This includes various
836 sizing parameters and callback routines, which, if left NULL,
837 result in default behavior */
838
839typedef struct
840{ ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
841 ULONG Unknown[11];
842} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
843
844HANDLE WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
845HANDLE WINAPI RtlDestroyHeap(HANDLE);
846PVOID WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
847BOOLEAN WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
848PVOID WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
849ULONG WINAPI RtlCompactHeap(HANDLE,ULONG);
850BOOLEAN WINAPI RtlLockHeap(HANDLE);
851BOOLEAN WINAPI RtlUnlockHeap(HANDLE);
852ULONG WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
853BOOLEAN WINAPI RtlValidateHeap(HANDLE,ULONG,PCVOID);
854ULONG WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
855NTSTATUS WINAPI RtlWalkHeap(HANDLE,PVOID);
856
857/* exception */
858
859void WINAPI NtRaiseException(
860 PEXCEPTION_RECORD,PCONTEXT,BOOL);
861
862void WINAPI RtlRaiseException(
863 PEXCEPTION_RECORD);
864
865void WINAPI RtlRaiseStatus(
866 NTSTATUS);
867
868void WINAPI RtlUnwind(
869 PEXCEPTION_FRAME,
870 LPVOID,
871 PEXCEPTION_RECORD,DWORD);
872
873/* process environment block */
874VOID WINAPI RtlAcquirePebLock(void);
875VOID WINAPI RtlReleasePebLock(void);
876
877/* mathematics */
878#if defined(__WIN32OS2__) && defined(__IBMC__)
879LARGE_INTEGER WINAPI RtlpConvertLongToLargeInteger( LONG a );
880LARGE_INTEGER WINAPI RtlpEnlargedIntegerMultiply( INT a, INT b );
881LARGE_INTEGER WINAPI RtlpExtendedMagicDivide( LARGE_INTEGER *a, LARGE_INTEGER *b, INT shift );
882LARGE_INTEGER WINAPI RtlpExtendedIntegerMultiply( LARGE_INTEGER *a, INT b );
883LARGE_INTEGER WINAPI RtlpExtendedLargeIntegerDivide( LARGE_INTEGER *a, INT b, INT *rem );
884LARGE_INTEGER WINAPI RtlpLargeIntegerAdd( LARGE_INTEGER *a, LARGE_INTEGER *b );
885LARGE_INTEGER WINAPI RtlpLargeIntegerArithmeticShift( LARGE_INTEGER *a, INT count );
886LARGE_INTEGER WINAPI RtlpLargeIntegerNegate( LARGE_INTEGER *a );
887LARGE_INTEGER WINAPI RtlpLargeIntegerShiftLeft( LARGE_INTEGER *a, INT count );
888LARGE_INTEGER WINAPI RtlpLargeIntegerShiftRight( LARGE_INTEGER *a, INT count );
889LARGE_INTEGER WINAPI RtlpLargeIntegerSubtract( LARGE_INTEGER *a, LARGE_INTEGER b );
890ULARGE_INTEGER WINAPI RtlpEnlargedUnsignedMultiply( UINT a, UINT b );
891LARGE_INTEGER WINAPI RtlpEnlargedUnsignedDivide( ULARGE_INTEGER a, UINT b, UINT *remptr );
892ULARGE_INTEGER WINAPI RtlpConvertUlongToLargeInteger( ULONG a );
893ULARGE_INTEGER WINAPI RtlpLargeIntegerDivide( ULARGE_INTEGER *a, ULARGE_INTEGER *b, ULARGE_INTEGER *rem );
894
895#else
896
897LONGLONG WINAPI RtlConvertLongToLargeInteger( LONG a );
898LONGLONG WINAPI RtlEnlargedIntegerMultiply( INT a, INT b );
899LONGLONG WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift );
900LONGLONG WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b );
901LONGLONG WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem );
902LONGLONG WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b );
903LONGLONG WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count );
904LONGLONG WINAPI RtlLargeIntegerNegate( LONGLONG a );
905LONGLONG WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count );
906LONGLONG WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count );
907LONGLONG WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b );
908ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b );
909UINT WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr );
910ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a );
911ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem );
912
913#endif
914
915/* environment */
916DWORD WINAPI RtlCreateEnvironment(
917 DWORD x1,
918 DWORD x2);
919
920DWORD WINAPI RtlDestroyEnvironment(
921 DWORD x);
922
923DWORD WINAPI RtlQueryEnvironmentVariable_U(
924 DWORD x1,
925 PUNICODE_STRING key,
926 PUNICODE_STRING val) ;
927
928DWORD WINAPI RtlSetEnvironmentVariable(
929 DWORD x1,
930 PUNICODE_STRING key,
931 PUNICODE_STRING val);
932
933/* object security */
934
935DWORD WINAPI RtlNewSecurityObject(
936 DWORD x1,
937 DWORD x2,
938 DWORD x3,
939 DWORD x4,
940 DWORD x5,
941 DWORD x6);
942
943DWORD WINAPI RtlDeleteSecurityObject(
944 DWORD x1);
945
946NTSTATUS WINAPI
947NtQuerySecurityObject(
948 IN HANDLE Object,
949 IN SECURITY_INFORMATION RequestedInformation,
950 OUT PSECURITY_DESCRIPTOR pSecurityDesriptor,
951 IN ULONG Length,
952 OUT PULONG ResultLength);
953
954NTSTATUS WINAPI
955NtSetSecurityObject(
956 IN HANDLE Handle,
957 IN SECURITY_INFORMATION SecurityInformation,
958 IN PSECURITY_DESCRIPTOR SecurityDescriptor);
959
960/* registry functions */
961
962NTSTATUS WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,
963 const UNICODE_STRING*,ULONG,PULONG);
964NTSTATUS WINAPI NtDeleteKey(HANDLE);
965NTSTATUS WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING*);
966NTSTATUS WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
967NTSTATUS WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
968NTSTATUS WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING*,ULONG,ULONG,const void*,ULONG);
969NTSTATUS WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
970NTSTATUS WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING*,KEY_VALUE_INFORMATION_CLASS,
971 void*,DWORD,DWORD*);
972NTSTATUS WINAPI NtLoadKey(const OBJECT_ATTRIBUTES*,const OBJECT_ATTRIBUTES*);
973
974
975NTSTATUS WINAPI NtEnumerateValueKey(
976 HANDLE KeyHandle,
977 ULONG Index,
978 KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
979 PVOID KeyInformation,
980 ULONG Length,
981 PULONG ResultLength);
982
983NTSTATUS WINAPI NtFlushKey(HANDLE KeyHandle);
984
985NTSTATUS WINAPI NtNotifyChangeKey(
986 IN HANDLE KeyHandle,
987 IN HANDLE Event,
988 IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
989 IN PVOID ApcContext OPTIONAL,
990 OUT PIO_STATUS_BLOCK IoStatusBlock,
991 IN ULONG CompletionFilter,
992 IN BOOLEAN Asynchroneous,
993 OUT PVOID ChangeBuffer,
994 IN ULONG Length,
995 IN BOOLEAN WatchSubtree);
996
997NTSTATUS WINAPI NtQueryMultipleValueKey(
998 HANDLE KeyHandle,
999 PVALENTW ListOfValuesToQuery,
1000 ULONG NumberOfItems,
1001 PVOID MultipleValueInformation,
1002 ULONG Length,
1003 PULONG ReturnLength);
1004
1005NTSTATUS WINAPI NtReplaceKey(
1006 IN POBJECT_ATTRIBUTES ObjectAttributes,
1007 IN HANDLE Key,
1008 IN POBJECT_ATTRIBUTES ReplacedObjectAttributes);
1009
1010NTSTATUS WINAPI NtRestoreKey(
1011 HANDLE KeyHandle,
1012 HANDLE FileHandle,
1013 ULONG RestoreFlags);
1014
1015NTSTATUS WINAPI NtSaveKey(
1016 IN HANDLE KeyHandle,
1017 IN HANDLE FileHandle);
1018
1019NTSTATUS WINAPI NtSetInformationKey(
1020 IN HANDLE KeyHandle,
1021 IN const int KeyInformationClass,
1022 IN PVOID KeyInformation,
1023 IN ULONG KeyInformationLength);
1024
1025NTSTATUS WINAPI NtUnloadKey(
1026 IN HANDLE KeyHandle);
1027
1028NTSTATUS WINAPI NtClose(
1029 HANDLE Handle);
1030
1031NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
1032NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
1033
1034NTSTATUS WINAPI NtClearEvent(HANDLE);
1035NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1036NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
1037NTSTATUS WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *attr);
1038NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
1039NTSTATUS WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
1040NTSTATUS WINAPI NtResetEvent(HANDLE,PULONG);
1041NTSTATUS WINAPI NtSetEvent(HANDLE,PULONG);
1042
1043NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit );
1044NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount );
1045NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit );
1046NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit );
1047NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit );
1048NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1049BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1050NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit );
1051
1052/* string functions */
1053extern LPSTR _strlwr( LPSTR str );
1054extern LPSTR _strupr( LPSTR str );
1055
1056/* misc */
1057
1058#if defined(__i386__) && defined(__GNUC__)
1059static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
1060static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
1061#else /* __i386__ && __GNUC__ */
1062void WINAPI DbgBreakPoint(void);
1063void WINAPI DbgUserBreakPoint(void);
1064#endif /* __i386__ && __GNUC__ */
1065void WINAPIV DbgPrint(LPCSTR fmt, ...);
1066
1067DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
1068DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
1069LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
1070DWORD WINAPI RtlNtStatusToDosError(NTSTATUS status);
1071BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
1072PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule);
1073
1074DWORD WINAPI RtlOpenCurrentUser(
1075 IN ACCESS_MASK DesiredAccess,
1076 OUT PHANDLE KeyHandle);
1077
1078BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
1079BOOL WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
1080
1081NTSTATUS WINAPI
1082NtAccessCheck(
1083 IN PSECURITY_DESCRIPTOR SecurityDescriptor,
1084 IN HANDLE ClientToken,
1085 IN ACCESS_MASK DesiredAccess,
1086 IN PGENERIC_MAPPING GenericMapping,
1087 OUT PPRIVILEGE_SET PrivilegeSet,
1088 OUT PULONG ReturnLength,
1089 OUT PULONG GrantedAccess,
1090 OUT PBOOLEAN AccessStatus);
1091
1092NTSTATUS WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1093
1094#ifdef __cplusplus
1095}
1096#endif
1097
1098#endif
Note: See TracBrowser for help on using the repository browser.