include/ntddk.h

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