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 #define NtCurrentProcess() ( (HANDLE) -1 )
 295
 296 /*
 297  *      timer
 298  */
 299
 300 typedef enum _TIMER_TYPE
 301 {
 302         NotificationTimer,
 303         SynchronizationTimer
 304
 305 } TIMER_TYPE;
 306
 307 /*
 308  *      token functions
 309  */
 310
 311 NTSTATUS WINAPI NtOpenProcessToken(
 312         HANDLE ProcessHandle,
 313         DWORD DesiredAccess,
 314         HANDLE *TokenHandle);
 315
 316 NTSTATUS WINAPI NtOpenThreadToken(
 317         HANDLE ThreadHandle,
 318         DWORD DesiredAccess,
 319         BOOLEAN OpenAsSelf,
 320         HANDLE *TokenHandle);
 321
 322 NTSTATUS WINAPI NtAdjustPrivilegesToken(
 323         IN HANDLE TokenHandle,
 324         IN BOOLEAN DisableAllPrivileges,
 325         IN PTOKEN_PRIVILEGES NewState,
 326         IN DWORD BufferLength,
 327         OUT PTOKEN_PRIVILEGES PreviousState,
 328         OUT PDWORD ReturnLength);
 329
 330 NTSTATUS WINAPI NtQueryInformationToken(
 331         HANDLE token,
 332         DWORD tokeninfoclass,
 333         LPVOID tokeninfo,
 334         DWORD tokeninfolength,
 335         LPDWORD retlen );
 336
 337 /*
 338  *      sid functions
 339  */
 340
 341 BOOLEAN WINAPI RtlAllocateAndInitializeSid (
 342         PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
 343         DWORD nSubAuthorityCount,
 344         DWORD x3,
 345         DWORD x4,
 346         DWORD x5,
 347         DWORD x6,
 348         DWORD x7,
 349         DWORD x8,
 350         DWORD x9,
 351         DWORD x10,
 352         PSID pSid);
 353
 354 DWORD WINAPI RtlEqualSid(DWORD x1,DWORD x2);
 355 DWORD WINAPI RtlFreeSid(DWORD x1);
 356 DWORD WINAPI RtlLengthRequiredSid(DWORD nrofsubauths);
 357 DWORD WINAPI RtlLengthSid(PSID sid);
 358 DWORD WINAPI RtlInitializeSid(PSID PSID,PSID_IDENTIFIER_AUTHORITY PSIDauth, DWORD c);
 359 LPDWORD WINAPI RtlSubAuthoritySid(PSID PSID,DWORD nr);
 360 LPBYTE WINAPI RtlSubAuthorityCountSid(PSID PSID);
 361 DWORD WINAPI RtlCopySid(DWORD len,PSID to,PSID from);
 362
 363 /*
 364  *      security descriptor functions
 365  */
 366
 367 NTSTATUS WINAPI RtlCreateSecurityDescriptor(
 368         PSECURITY_DESCRIPTOR lpsd,
 369         DWORD rev);
 370
 371 NTSTATUS WINAPI RtlValidSecurityDescriptor(
 372         PSECURITY_DESCRIPTOR SecurityDescriptor);
 373
 374 ULONG WINAPI RtlLengthSecurityDescriptor(
 375         PSECURITY_DESCRIPTOR SecurityDescriptor);
 376
 377 NTSTATUS WINAPI RtlGetDaclSecurityDescriptor(
 378         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 379         OUT PBOOLEAN lpbDaclPresent,
 380         OUT PACL *pDacl,
 381         OUT PBOOLEAN lpbDaclDefaulted);
 382
 383 NTSTATUS WINAPI RtlSetDaclSecurityDescriptor (
 384         PSECURITY_DESCRIPTOR lpsd,
 385         BOOLEAN daclpresent,
 386         PACL dacl,
 387         BOOLEAN dacldefaulted );
 388
 389 NTSTATUS WINAPI RtlGetSaclSecurityDescriptor(
 390         IN PSECURITY_DESCRIPTOR pSecurityDescriptor,
 391         OUT PBOOLEAN lpbSaclPresent,
 392         OUT PACL *pSacl,
 393         OUT PBOOLEAN lpbSaclDefaulted);
 394
 395 NTSTATUS WINAPI RtlSetSaclSecurityDescriptor (
 396         PSECURITY_DESCRIPTOR lpsd,
 397         BOOLEAN saclpresent,
 398         PACL sacl,
 399         BOOLEAN sacldefaulted);
 400
 401 NTSTATUS WINAPI RtlGetOwnerSecurityDescriptor(
 402         PSECURITY_DESCRIPTOR SecurityDescriptor,
 403         PSID *Owner,
 404         PBOOLEAN OwnerDefaulted);
 405
 406 NTSTATUS WINAPI RtlSetOwnerSecurityDescriptor(
 407         PSECURITY_DESCRIPTOR lpsd,
 408         PSID owner,
 409         BOOLEAN ownerdefaulted);
 410
 411 NTSTATUS WINAPI RtlSetGroupSecurityDescriptor (
 412         PSECURITY_DESCRIPTOR lpsd,
 413         PSID group,
 414         BOOLEAN groupdefaulted);
 415
 416 NTSTATUS WINAPI RtlGetGroupSecurityDescriptor(
 417         PSECURITY_DESCRIPTOR SecurityDescriptor,
 418         PSID *Group,
 419         PBOOLEAN GroupDefaulted);
 420
 421 /*      ##############################
 422         ######  ACL FUNCTIONS   ######
 423         ##############################
 424 */
 425
 426 DWORD WINAPI RtlCreateAcl(PACL acl,DWORD size,DWORD rev);
 427
 428 BOOLEAN WINAPI RtlFirstFreeAce(
 429         PACL acl,
 430         PACE_HEADER *x);
 431
 432 NTSTATUS WINAPI RtlAddAce(
 433         PACL acl,
 434         DWORD rev,
 435         DWORD xnrofaces,
 436         PACE_HEADER acestart,
 437         DWORD acelen);
 438
 439 DWORD WINAPI RtlAddAccessAllowedAce(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
 440 DWORD WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
 441
 442 /*
 443  *      string functions
 444  */
 445
 446 DWORD WINAPI RtlAnsiStringToUnicodeString(PUNICODE_STRING uni,PANSI_STRING ansi,BOOLEAN doalloc);
 447 DWORD WINAPI RtlOemStringToUnicodeString(PUNICODE_STRING uni,PSTRING ansi,BOOLEAN doalloc);
 448 DWORD WINAPI RtlMultiByteToUnicodeN(LPWSTR unistr,DWORD unilen,LPDWORD reslen,LPSTR oemstr,DWORD oemlen);
 449 DWORD WINAPI RtlOemToUnicodeN(LPWSTR unistr,DWORD unilen,LPDWORD reslen,LPSTR oemstr,DWORD oemlen);
 450 VOID WINAPI RtlInitAnsiString(PANSI_STRING target,LPCSTR source);
 451 VOID WINAPI RtlInitString(PSTRING target,LPCSTR source);
 452 VOID WINAPI RtlInitUnicodeString(PUNICODE_STRING target,LPCWSTR source);
 453 VOID WINAPI RtlFreeUnicodeString(PUNICODE_STRING str);
 454 VOID WINAPI RtlFreeAnsiString(PANSI_STRING AnsiString);
 455 DWORD WINAPI RtlUnicodeToOemN(LPSTR oemstr,DWORD oemlen,LPDWORD reslen,LPWSTR unistr,DWORD unilen);
 456 DWORD WINAPI RtlUnicodeStringToOemString(PANSI_STRING oem,PUNICODE_STRING uni,BOOLEAN alloc);
 457 DWORD WINAPI RtlUnicodeStringToAnsiString(PANSI_STRING oem,PUNICODE_STRING uni,BOOLEAN alloc);
 458 DWORD WINAPI RtlEqualUnicodeString(PUNICODE_STRING s1,PUNICODE_STRING s2,DWORD x);
 459 DWORD WINAPI RtlUpcaseUnicodeString(PUNICODE_STRING dest,PUNICODE_STRING src,BOOLEAN doalloc);
 460 UINT WINAPI RtlxOemStringToUnicodeSize(PSTRING str);
 461 UINT WINAPI RtlxAnsiStringToUnicodeSize(PANSI_STRING str);
 462 DWORD WINAPI RtlIsTextUnicode(LPVOID buf, DWORD len, DWORD *pf);
 463 NTSTATUS WINAPI RtlCompareUnicodeString(PUNICODE_STRING String1, PUNICODE_STRING String2, BOOLEAN CaseInSensitive);
 464
 465 /*
 466  *      resource functions
 467  */
 468
 469 typedef struct _RTL_RWLOCK {
 470         CRITICAL_SECTION        rtlCS;
 471         HANDLE          hSharedReleaseSemaphore;
 472         UINT                    uSharedWaiters;
 473         HANDLE          hExclusiveReleaseSemaphore;
 474         UINT                    uExclusiveWaiters;
 475         INT                     iNumberActive;
 476         HANDLE          hOwningThreadId;
 477         DWORD                   dwTimeoutBoost;
 478         PVOID                   pDebugInfo;
 479 } RTL_RWLOCK, *LPRTL_RWLOCK;
 480
 481 VOID   WINAPI RtlInitializeResource(
 482         LPRTL_RWLOCK);
 483
 484 VOID   WINAPI RtlDeleteResource(
 485         LPRTL_RWLOCK);
 486
 487 BYTE   WINAPI RtlAcquireResourceExclusive(
 488         LPRTL_RWLOCK, BYTE fWait);
 489
 490 BYTE   WINAPI RtlAcquireResourceShared(
 491         LPRTL_RWLOCK, BYTE fWait);
 492
 493 VOID   WINAPI RtlReleaseResource(
 494         LPRTL_RWLOCK);
 495
 496 VOID   WINAPI RtlDumpResource(
 497         LPRTL_RWLOCK);
 498
 499 /*
 500         time functions
 501  */
 502
 503 typedef struct _TIME_FIELDS
 504 {   CSHORT Year;
 505     CSHORT Month;
 506     CSHORT Day;
 507     CSHORT Hour;
 508     CSHORT Minute;
 509     CSHORT Second;
 510     CSHORT Milliseconds;
 511     CSHORT Weekday;
 512 } TIME_FIELDS;
 513
 514 typedef TIME_FIELDS *PTIME_FIELDS;
 515
 516 VOID WINAPI RtlSystemTimeToLocalTime(
 517         IN  PLARGE_INTEGER SystemTime,
 518         OUT PLARGE_INTEGER LocalTime);
 519
 520 VOID WINAPI RtlTimeToTimeFields(
 521         PLARGE_INTEGER liTime,
 522         PTIME_FIELDS TimeFields);
 523
 524 BOOLEAN WINAPI RtlTimeFieldsToTime(
 525         PTIME_FIELDS tfTimeFields,
 526         PLARGE_INTEGER Time);
 527
 528 VOID WINAPI RtlTimeToElapsedTimeFields(
 529         PLARGE_INTEGER liTime,
 530         PTIME_FIELDS TimeFields);
 531
 532 BOOLEAN WINAPI RtlTimeToSecondsSince1980(
 533         LPFILETIME ft,
 534         LPDWORD timeret);
 535
 536 BOOLEAN WINAPI RtlTimeToSecondsSince1970(
 537         LPFILETIME ft,
 538         LPDWORD timeret);
 539
 540 /*
 541         heap functions
 542 */
 543
 544 /* Data structure for heap definition. This includes various
 545    sizing parameters and callback routines, which, if left NULL,
 546    result in default behavior */
 547
 548 typedef struct
 549 {       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
 550         ULONG   Unknown[11];
 551 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
 552
 553 HANDLE WINAPI RtlCreateHeap(
 554         ULONG Flags,
 555         PVOID BaseAddress,
 556         ULONG SizeToReserve,
 557         ULONG SizeToCommit,
 558         PVOID Unknown,
 559         PRTL_HEAP_DEFINITION Definition);
 560
 561 PVOID WINAPI RtlAllocateHeap(
 562         HANDLE Heap,
 563         ULONG Flags,
 564         ULONG Size);
 565
 566
 567 BOOLEAN WINAPI RtlFreeHeap(
 568         HANDLE Heap,
 569         ULONG Flags,
 570         PVOID Address);
 571
 572 /*
 573  *      misc
 574  */
 575 void __cdecl DbgPrint(LPCSTR fmt,LPVOID args);
 576 DWORD NtRaiseException ( DWORD dwExceptionCode, DWORD dwExceptionFlags, DWORD nNumberOfArguments,CONST ULONG_PTR *lpArguments);
 577 DWORD RtlRaiseException ( DWORD x);
 578 VOID WINAPI RtlAcquirePebLock(void);
 579 VOID WINAPI RtlReleasePebLock(void);
 580 DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
 581 DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
 582 DWORD WINAPI RtlSetEnvironmentVariable(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val);
 583 DWORD WINAPI RtlNewSecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6);
 584 DWORD WINAPI RtlDeleteSecurityObject(DWORD x1);
 585 LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
 586 DWORD WINAPI RtlNtStatusToDosError(DWORD error);
 587 BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
 588 INT WINAPI RtlExtendedLargeIntegerDivide(LARGE_INTEGER dividend, DWORD divisor, LPDWORD rest);
 589 long long WINAPI RtlExtendedIntegerMultiply(LARGE_INTEGER factor1,INT factor2);
 590 DWORD WINAPI RtlFormatCurrentUserKeyPath(DWORD x);
 591 DWORD WINAPI RtlOpenCurrentUser(DWORD x1, DWORD *x2);
 592 BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
 593 DWORD WINAPI RtlCreateEnvironment(DWORD x1,DWORD x2);
 594 DWORD WINAPI RtlDestroyEnvironment(DWORD x);
 595 DWORD WINAPI RtlQueryEnvironmentVariable_U(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val) ;
 596
 597 BOOL WINAPI IsValidSid(PSID);
 598 BOOL WINAPI EqualSid(PSID,PSID);
 599 BOOL WINAPI EqualPrefixSid(PSID,PSID);
 600 DWORD  WINAPI GetSidLengthRequired(BYTE);
 601 BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,
 602                                        DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,
 603                                        DWORD,PSID*);
 604 VOID*  WINAPI FreeSid(PSID);
 605 BOOL WINAPI InitializeSecurityDescriptor(SECURITY_DESCRIPTOR*,DWORD);
 606 BOOL WINAPI InitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
 607 DWORD* WINAPI GetSidSubAuthority(PSID,DWORD);
 608 BYTE * WINAPI GetSidSubAuthorityCount(PSID);
 609 DWORD  WINAPI GetLengthSid(PSID);
 610 BOOL WINAPI CopySid(DWORD,PSID,PSID);
 611 BOOL WINAPI LookupAccountSidA(LPCSTR,PSID,LPCSTR,LPDWORD,LPCSTR,LPDWORD,
 612                                   PSID_NAME_USE);
 613 BOOL WINAPI LookupAccountSidW(LPCWSTR,PSID,LPCWSTR,LPDWORD,LPCWSTR,LPDWORD,
 614                                   PSID_NAME_USE);
 615 PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
 616
 617 #ifdef __cplusplus
 618 }
 619 #endif
 620
 621 #endif