include/ntddk.h

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