source: trunk/include/win/ntddk.h

Last change on this file was 21916, checked in by dmik, 14 years ago

Merge branch gcc-kmk to trunk.
File size: 30.4 KB
RevLine 
[4]1/*
[1890]2 this file defines interfaces mainly exposed to device drivers and
3 native nt dll's
[4]4
5*/
6#ifndef __WINE_NTDDK_H
7#define __WINE_NTDDK_H
8
[1890]9#include "ntdef.h"
10#include "winnt.h"
[7985]11#include "winreg.h"
12#include "winbase.h" /* FIXME: should be taken out sometimes */
[4]13
14#ifdef __cplusplus
15extern "C" {
16#endif
17
[1890]18/******************
19 * asynchronous I/O
[4]20 */
[1890]21#undef Status /* conflict with X11-includes*/
[4]22
[1890]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;
[4]31
[7985]32#ifdef __WIN32OS2__
[4113]33typedef VOID (* NTAPI PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
[7985]34#else
35typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
36#endif
[4]37
[7985]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{
[1890]78 KeyBasicInformation,
79 KeyNodeInformation,
80 KeyFullInformation
[4]81} KEY_INFORMATION_CLASS;
82
[7985]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{
[1890]121 KeyValueBasicInformation,
122 KeyValueFullInformation,
123 KeyValuePartialInformation,
124 KeyValueFullInformationAlign64,
125 KeyValuePartialInformationAlign64
[4]126} KEY_VALUE_INFORMATION_CLASS;
127
[7985]128NTSTATUS WINAPI RtlFormatCurrentUserKeyPath(
129 PUNICODE_STRING KeyPath);
130
131/* thread information */
132
[1890]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
[4]152} THREADINFOCLASS;
153
[7985]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
[4]171typedef enum _FILE_INFORMATION_CLASS {
[1890]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
[4]209} FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
210
[1890]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
[4]224{
[1890]225 ViewShare = 1,
226 ViewUnmap = 2
[4]227
228} SECTION_INHERIT;
[1890]229
[7985]230/* object information */
231
[4]232typedef enum _OBJECT_INFORMATION_CLASS
233{
[1890]234 DunnoTheConstants1
[4]235
236} OBJECT_INFORMATION_CLASS, *POBJECT_INFORMATION_CLASS;
237
238
[7985]239/* system information */
[4]240
241typedef enum SYSTEM_INFORMATION_CLASS
[7985]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
[4]264} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
265
[7985]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
[4]363/* reading coffee grounds... */
364typedef struct _THREAD_INFO
[1890]365{ DWORD Unknown1[6];
366 DWORD ThreadID;
367 DWORD Unknown2[3];
368 DWORD Status;
369 DWORD WaitReason;
370 DWORD Unknown3[4];
[4]371} THREAD_INFO, PTHREAD_INFO;
372
373typedef struct _VM_COUNTERS_
[1890]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;
[4]385} VM_COUNTERS, *PVM_COUNTERS;
386
[7985]387/* process information */
388
[4]389typedef struct _PROCESS_INFO
[1890]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*/
[4]415} PROCESS_INFO, PPROCESS_INFO;
416
417NTSTATUS WINAPI NtQuerySystemInformation(
[1890]418 IN SYSTEM_INFORMATION_CLASS SystemInformationClass,
419 OUT PVOID SystemInformation,
420 IN ULONG Length,
421 OUT PULONG ResultLength);
[4]422
423/*
[1890]424 * system configuration
[4]425 */
426
427
428typedef struct _SYSTEM_TIME_ADJUSTMENT
429{
[1890]430 ULONG TimeAdjustment;
431 BOOLEAN TimeAdjustmentDisabled;
[4]432
433} SYSTEM_TIME_ADJUSTMENT, *PSYSTEM_TIME_ADJUSTMENT;
434
[1890]435typedef struct _SYSTEM_CONFIGURATION_INFO
[4]436{
[1890]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;
[4]453
454} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
455
456
457/*
[1890]458 * NtQueryProcessInformation
[4]459 */
460
461/* parameter ProcessInformationClass */
462
[1890]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
[4]492} PROCESSINFOCLASS;
493
494/* parameter ProcessInformation (depending on ProcessInformationClass) */
495
[1890]496typedef struct _PROCESS_BASIC_INFORMATION
497{ DWORD ExitStatus;
498 DWORD PebBaseAddress;
499 DWORD AffinityMask;
500 DWORD BasePriority;
501 ULONG UniqueProcessId;
502 ULONG InheritedFromUniqueProcessId;
[4]503} PROCESS_BASIC_INFORMATION;
504
505NTSTATUS WINAPI NtQueryInformationProcess(
[1890]506 IN HANDLE ProcessHandle,
507 IN PROCESSINFOCLASS ProcessInformationClass,
508 OUT PVOID ProcessInformation,
509 IN ULONG ProcessInformationLength,
510 OUT PULONG ReturnLength);
[4]511
512#define NtCurrentProcess() ( (HANDLE) -1 )
513
514/*
[1890]515 * timer
[4]516 */
517
[1890]518typedef enum _TIMER_TYPE
[4]519{
[1890]520 NotificationTimer,
521 SynchronizationTimer
[4]522
523} TIMER_TYPE;
524
[7985]525/* token functions */
[1890]526
[4]527NTSTATUS WINAPI NtOpenProcessToken(
[1890]528 HANDLE ProcessHandle,
529 DWORD DesiredAccess,
530 HANDLE *TokenHandle);
531
[4]532NTSTATUS WINAPI NtOpenThreadToken(
[1890]533 HANDLE ThreadHandle,
534 DWORD DesiredAccess,
535 BOOLEAN OpenAsSelf,
536 HANDLE *TokenHandle);
[4]537
538NTSTATUS WINAPI NtAdjustPrivilegesToken(
[1890]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);
[4]545
546NTSTATUS WINAPI NtQueryInformationToken(
[1890]547 HANDLE token,
548 DWORD tokeninfoclass,
549 LPVOID tokeninfo,
550 DWORD tokeninfolength,
551 LPDWORD retlen );
[4]552
[7985]553/* sid functions */
[4]554
555BOOLEAN WINAPI RtlAllocateAndInitializeSid (
[1890]556 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
[7985]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 );
[1890]563
[7985]564BOOL WINAPI RtlInitializeSid(
565 PSID pSid,
566 PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
567 BYTE nSubAuthorityCount);
568
569DWORD WINAPI RtlFreeSid(
570 PSID pSid);
[4]571
[7985]572BOOL WINAPI RtlEqualSid(
573 PSID pSid1,
574 PSID pSid2 );
575
576DWORD WINAPI RtlLengthRequiredSid(
577 DWORD nrofsubauths);
[4]578
[7985]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
[4]606NTSTATUS WINAPI RtlCreateSecurityDescriptor(
[1890]607 PSECURITY_DESCRIPTOR lpsd,
608 DWORD rev);
[4]609
610NTSTATUS WINAPI RtlValidSecurityDescriptor(
[1890]611 PSECURITY_DESCRIPTOR SecurityDescriptor);
[4]612
613ULONG WINAPI RtlLengthSecurityDescriptor(
[1890]614 PSECURITY_DESCRIPTOR SecurityDescriptor);
[4]615
616NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
[1890]617 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
618 OUT PBOOLEAN lpbDaclPresent,
619 OUT PACL *pDacl,
620 OUT PBOOLEAN lpbDaclDefaulted);
[4]621
622NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
[1890]623 PSECURITY_DESCRIPTOR lpsd,
624 BOOLEAN daclpresent,
625 PACL dacl,
626 BOOLEAN dacldefaulted );
[4]627
628NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
[1890]629 IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
630 OUT PBOOLEAN lpbSaclPresent,
631 OUT PACL *pSacl,
632 OUT PBOOLEAN lpbSaclDefaulted);
[4]633
634NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
[1890]635 PSECURITY_DESCRIPTOR lpsd,
636 BOOLEAN saclpresent,
637 PACL sacl,
638 BOOLEAN sacldefaulted);
[4]639
640NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
[1890]641 PSECURITY_DESCRIPTOR SecurityDescriptor,
642 PSID *Owner,
643 PBOOLEAN OwnerDefaulted);
[4]644
645NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
[1890]646 PSECURITY_DESCRIPTOR lpsd,
647 PSID owner,
648 BOOLEAN ownerdefaulted);
[4]649
650NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
[1890]651 PSECURITY_DESCRIPTOR lpsd,
652 PSID group,
653 BOOLEAN groupdefaulted);
[4]654
655NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
[1890]656 PSECURITY_DESCRIPTOR SecurityDescriptor,
657 PSID *Group,
658 PBOOLEAN GroupDefaulted);
[4]659
[7985]660NTSTATUS WINAPI RtlMakeSelfRelativeSD(
661 IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
662 IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
663 IN OUT LPDWORD lpdwBufferLength);
[4]664
[7985]665NTSTATUS WINAPI RtlGetControlSecurityDescriptor(
666 PSECURITY_DESCRIPTOR pSecurityDescriptor,
667 PSECURITY_DESCRIPTOR_CONTROL pControl,
668 LPDWORD lpdwRevision);
[4]669
[7985]670/* acl functions */
671
672NTSTATUS WINAPI RtlCreateAcl(
673 PACL acl,
674 DWORD size,
675 DWORD rev);
676
[4]677BOOLEAN WINAPI RtlFirstFreeAce(
[1890]678 PACL acl,
679 PACE_HEADER *x);
[4]680
681NTSTATUS WINAPI RtlAddAce(
[1890]682 PACL acl,
683 DWORD rev,
684 DWORD xnrofaces,
685 PACE_HEADER acestart,
686 DWORD acelen);
687
[7985]688BOOL WINAPI RtlAddAccessAllowedAce(
689 IN OUT PACL pAcl,
690 IN DWORD dwAceRevision,
691 IN DWORD AccessMask,
692 IN PSID pSid);
[4]693
[7985]694BOOL WINAPI AddAccessAllowedAceEx(
695 IN OUT PACL pAcl,
696 IN DWORD dwAceRevision,
697 IN DWORD AceFlags,
698 IN DWORD AccessMask,
699 IN PSID pSid);
[4]700
[7985]701DWORD WINAPI RtlGetAce(
702 PACL pAcl,
703 DWORD dwAceIndex,
704 LPVOID *pAce );
[5566]705
[7985]706/* string functions */
[4]707
[7985]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);
[5566]748
[7985]749DWORD WINAPI RtlIsTextUnicode(
750 LPVOID buf,
751 DWORD len,
752 DWORD *pf);
[5566]753
[7985]754/* resource functions */
755
[4]756typedef struct _RTL_RWLOCK {
[1890]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;
[4]766} RTL_RWLOCK, *LPRTL_RWLOCK;
767
768VOID WINAPI RtlInitializeResource(
[1890]769 LPRTL_RWLOCK);
770
[4]771VOID WINAPI RtlDeleteResource(
[1890]772 LPRTL_RWLOCK);
773
[4]774BYTE WINAPI RtlAcquireResourceExclusive(
[1890]775 LPRTL_RWLOCK, BYTE fWait);
776
[4]777BYTE WINAPI RtlAcquireResourceShared(
[1890]778 LPRTL_RWLOCK, BYTE fWait);
779
[4]780VOID WINAPI RtlReleaseResource(
[1890]781 LPRTL_RWLOCK);
782
[4]783VOID WINAPI RtlDumpResource(
[1890]784 LPRTL_RWLOCK);
[4]785
[7985]786/* time functions */
[4]787
[1890]788typedef struct _TIME_FIELDS
[4]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
[9673]801void WINAPI RtlSystemTimeToLocalTime(PLARGE_INTEGER,PLARGE_INTEGER);
802void WINAPI RtlTimeToTimeFields(const LARGE_INTEGER*,PTIME_FIELDS);
[4]803
804BOOLEAN WINAPI RtlTimeFieldsToTime(
[1890]805 PTIME_FIELDS tfTimeFields,
806 PLARGE_INTEGER Time);
807
[4]808VOID WINAPI RtlTimeToElapsedTimeFields(
[1890]809 PLARGE_INTEGER liTime,
810 PTIME_FIELDS TimeFields);
[4]811
[9673]812NTSTATUS WINAPI NtQuerySystemTime(PLARGE_INTEGER);
[4]813
[9673]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
[9631]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
[7985]833/* heap functions */
[4]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
[1890]840{ ULONG Length; /* = sizeof(RTL_HEAP_DEFINITION) */
841 ULONG Unknown[11];
[4]842} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
843
[7985]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);
[4]856
[7985]857/* exception */
[4]858
[7985]859void WINAPI NtRaiseException(
860 PEXCEPTION_RECORD,PCONTEXT,BOOL);
[4]861
[7985]862void WINAPI RtlRaiseException(
863 PEXCEPTION_RECORD);
[4]864
[7985]865void WINAPI RtlRaiseStatus(
866 NTSTATUS);
867
868void WINAPI RtlUnwind(
869 PEXCEPTION_FRAME,
870 LPVOID,
871 PEXCEPTION_RECORD,DWORD);
872
873/* process environment block */
[4]874VOID WINAPI RtlAcquirePebLock(void);
875VOID WINAPI RtlReleasePebLock(void);
[7985]876
877/* mathematics */
[21916]878#if defined(__WIN32OS2__) && defined(WINE_LARGE_INTEGER) && !defined(WINE_LONGLONG)
879
[8444]880LARGE_INTEGER WINAPI RtlpConvertLongToLargeInteger( LONG a );
881LARGE_INTEGER WINAPI RtlpEnlargedIntegerMultiply( INT a, INT b );
882LARGE_INTEGER WINAPI RtlpExtendedMagicDivide( LARGE_INTEGER *a, LARGE_INTEGER *b, INT shift );
883LARGE_INTEGER WINAPI RtlpExtendedIntegerMultiply( LARGE_INTEGER *a, INT b );
884LARGE_INTEGER WINAPI RtlpExtendedLargeIntegerDivide( LARGE_INTEGER *a, INT b, INT *rem );
885LARGE_INTEGER WINAPI RtlpLargeIntegerAdd( LARGE_INTEGER *a, LARGE_INTEGER *b );
886LARGE_INTEGER WINAPI RtlpLargeIntegerArithmeticShift( LARGE_INTEGER *a, INT count );
887LARGE_INTEGER WINAPI RtlpLargeIntegerNegate( LARGE_INTEGER *a );
888LARGE_INTEGER WINAPI RtlpLargeIntegerShiftLeft( LARGE_INTEGER *a, INT count );
889LARGE_INTEGER WINAPI RtlpLargeIntegerShiftRight( LARGE_INTEGER *a, INT count );
890LARGE_INTEGER WINAPI RtlpLargeIntegerSubtract( LARGE_INTEGER *a, LARGE_INTEGER b );
891ULARGE_INTEGER WINAPI RtlpEnlargedUnsignedMultiply( UINT a, UINT b );
892LARGE_INTEGER WINAPI RtlpEnlargedUnsignedDivide( ULARGE_INTEGER a, UINT b, UINT *remptr );
893ULARGE_INTEGER WINAPI RtlpConvertUlongToLargeInteger( ULONG a );
894ULARGE_INTEGER WINAPI RtlpLargeIntegerDivide( ULARGE_INTEGER *a, ULARGE_INTEGER *b, ULARGE_INTEGER *rem );
895
896#else
897
[7985]898LONGLONG WINAPI RtlConvertLongToLargeInteger( LONG a );
899LONGLONG WINAPI RtlEnlargedIntegerMultiply( INT a, INT b );
900LONGLONG WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift );
901LONGLONG WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b );
902LONGLONG WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem );
903LONGLONG WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b );
904LONGLONG WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count );
905LONGLONG WINAPI RtlLargeIntegerNegate( LONGLONG a );
906LONGLONG WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count );
907LONGLONG WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count );
908LONGLONG WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b );
909ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b );
910UINT WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr );
911ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a );
912ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem );
913
[8443]914#endif
915
[7985]916/* environment */
917DWORD WINAPI RtlCreateEnvironment(
918 DWORD x1,
919 DWORD x2);
920
921DWORD WINAPI RtlDestroyEnvironment(
922 DWORD x);
923
924DWORD WINAPI RtlQueryEnvironmentVariable_U(
925 DWORD x1,
926 PUNICODE_STRING key,
927 PUNICODE_STRING val) ;
928
929DWORD WINAPI RtlSetEnvironmentVariable(
930 DWORD x1,
931 PUNICODE_STRING key,
932 PUNICODE_STRING val);
933
934/* object security */
935
936DWORD WINAPI RtlNewSecurityObject(
937 DWORD x1,
938 DWORD x2,
939 DWORD x3,
940 DWORD x4,
941 DWORD x5,
942 DWORD x6);
943
944DWORD WINAPI RtlDeleteSecurityObject(
945 DWORD x1);
946
947NTSTATUS WINAPI
948NtQuerySecurityObject(
949 IN HANDLE Object,
950 IN SECURITY_INFORMATION RequestedInformation,
951 OUT PSECURITY_DESCRIPTOR pSecurityDesriptor,
952 IN ULONG Length,
953 OUT PULONG ResultLength);
954
955NTSTATUS WINAPI
956NtSetSecurityObject(
957 IN HANDLE Handle,
958 IN SECURITY_INFORMATION SecurityInformation,
959 IN PSECURITY_DESCRIPTOR SecurityDescriptor);
960
961/* registry functions */
962
963NTSTATUS WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,
964 const UNICODE_STRING*,ULONG,PULONG);
965NTSTATUS WINAPI NtDeleteKey(HANDLE);
966NTSTATUS WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING*);
967NTSTATUS WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
968NTSTATUS WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
969NTSTATUS WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING*,ULONG,ULONG,const void*,ULONG);
970NTSTATUS WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
971NTSTATUS WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING*,KEY_VALUE_INFORMATION_CLASS,
972 void*,DWORD,DWORD*);
973NTSTATUS WINAPI NtLoadKey(const OBJECT_ATTRIBUTES*,const OBJECT_ATTRIBUTES*);
[21327]974NTSTATUS WINAPI NtDuplicateObject(
975 IN HANDLE SourceProcessHandle,
976 IN PHANDLE SourceHandle,
977 IN HANDLE TargetProcessHandle,
978 OUT PHANDLE TargetHandle,
979 IN ACCESS_MASK DesiredAccess,
980 IN BOOLEAN InheritHandle,
981 ULONG Options);
[7985]982
983NTSTATUS WINAPI NtEnumerateValueKey(
984 HANDLE KeyHandle,
985 ULONG Index,
986 KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
987 PVOID KeyInformation,
988 ULONG Length,
989 PULONG ResultLength);
990
991NTSTATUS WINAPI NtFlushKey(HANDLE KeyHandle);
992
993NTSTATUS WINAPI NtNotifyChangeKey(
994 IN HANDLE KeyHandle,
995 IN HANDLE Event,
996 IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
997 IN PVOID ApcContext OPTIONAL,
998 OUT PIO_STATUS_BLOCK IoStatusBlock,
999 IN ULONG CompletionFilter,
1000 IN BOOLEAN Asynchroneous,
1001 OUT PVOID ChangeBuffer,
1002 IN ULONG Length,
1003 IN BOOLEAN WatchSubtree);
1004
1005NTSTATUS WINAPI NtQueryMultipleValueKey(
1006 HANDLE KeyHandle,
1007 PVALENTW ListOfValuesToQuery,
1008 ULONG NumberOfItems,
1009 PVOID MultipleValueInformation,
1010 ULONG Length,
1011 PULONG ReturnLength);
1012
1013NTSTATUS WINAPI NtReplaceKey(
1014 IN POBJECT_ATTRIBUTES ObjectAttributes,
1015 IN HANDLE Key,
1016 IN POBJECT_ATTRIBUTES ReplacedObjectAttributes);
1017
1018NTSTATUS WINAPI NtRestoreKey(
1019 HANDLE KeyHandle,
1020 HANDLE FileHandle,
1021 ULONG RestoreFlags);
1022
1023NTSTATUS WINAPI NtSaveKey(
1024 IN HANDLE KeyHandle,
1025 IN HANDLE FileHandle);
1026
1027NTSTATUS WINAPI NtSetInformationKey(
1028 IN HANDLE KeyHandle,
1029 IN const int KeyInformationClass,
1030 IN PVOID KeyInformation,
1031 IN ULONG KeyInformationLength);
1032
1033NTSTATUS WINAPI NtUnloadKey(
1034 IN HANDLE KeyHandle);
1035
1036NTSTATUS WINAPI NtClose(
1037 HANDLE Handle);
1038
1039NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
1040NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
1041
1042NTSTATUS WINAPI NtClearEvent(HANDLE);
1043NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1044NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
1045NTSTATUS WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *attr);
1046NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
1047NTSTATUS WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
1048NTSTATUS WINAPI NtResetEvent(HANDLE,PULONG);
1049NTSTATUS WINAPI NtSetEvent(HANDLE,PULONG);
1050
1051NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit );
1052NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount );
[9985]1053
1054void WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
1055void WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1056BOOLEAN WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
1057BOOLEAN WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
1058
[7985]1059NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit );
1060NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit );
1061NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit );
1062NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1063BOOL WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1064NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit );
1065
1066/* string functions */
1067extern LPSTR _strlwr( LPSTR str );
1068extern LPSTR _strupr( LPSTR str );
1069
1070/* misc */
1071
1072#if defined(__i386__) && defined(__GNUC__)
1073static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
1074static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
1075#else /* __i386__ && __GNUC__ */
1076void WINAPI DbgBreakPoint(void);
1077void WINAPI DbgUserBreakPoint(void);
1078#endif /* __i386__ && __GNUC__ */
1079void WINAPIV DbgPrint(LPCSTR fmt, ...);
1080
[4]1081DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
[9985]1082NTSTATUS WINAPI RtlIntegerToChar(ULONG,ULONG,ULONG,PCHAR);
[4]1083LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
[9683]1084DWORD WINAPI RtlNtStatusToDosError(NTSTATUS status);
[4]1085BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
[7985]1086PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule);
1087
1088DWORD WINAPI RtlOpenCurrentUser(
1089 IN ACCESS_MASK DesiredAccess,
1090 OUT PHANDLE KeyHandle);
1091
[4]1092BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
[7985]1093BOOL WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
[4]1094
[7985]1095NTSTATUS WINAPI
1096NtAccessCheck(
1097 IN PSECURITY_DESCRIPTOR SecurityDescriptor,
1098 IN HANDLE ClientToken,
1099 IN ACCESS_MASK DesiredAccess,
1100 IN PGENERIC_MAPPING GenericMapping,
1101 OUT PPRIVILEGE_SET PrivilegeSet,
1102 OUT PULONG ReturnLength,
1103 OUT PULONG GrantedAccess,
1104 OUT PBOOLEAN AccessStatus);
[4]1105
[9673]1106NTSTATUS WINAPI RtlQueryTimeZoneInformation(LPTIME_ZONE_INFORMATION);
1107
[4]1108#ifdef __cplusplus
1109}
1110#endif
1111
1112#endif
Note: See TracBrowser for help on using the repository browser.