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[1];
 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 /*      resource functions */
 763
 764 typedef struct _RTL_RWLOCK {
 765         CRITICAL_SECTION        rtlCS;
 766         HANDLE          hSharedReleaseSemaphore;
 767         UINT                    uSharedWaiters;
 768         HANDLE          hExclusiveReleaseSemaphore;
 769         UINT                    uExclusiveWaiters;
 770         INT                     iNumberActive;
 771         HANDLE          hOwningThreadId;
 772         DWORD                   dwTimeoutBoost;
 773         PVOID                   pDebugInfo;
 774 } RTL_RWLOCK, *LPRTL_RWLOCK;
 775
 776 VOID   WINAPI RtlInitializeResource(
 777         LPRTL_RWLOCK);
 778
 779 VOID   WINAPI RtlDeleteResource(
 780         LPRTL_RWLOCK);
 781
 782 BYTE   WINAPI RtlAcquireResourceExclusive(
 783         LPRTL_RWLOCK, BYTE fWait);
 784
 785 BYTE   WINAPI RtlAcquireResourceShared(
 786         LPRTL_RWLOCK, BYTE fWait);
 787
 788 VOID   WINAPI RtlReleaseResource(
 789         LPRTL_RWLOCK);
 790
 791 VOID   WINAPI RtlDumpResource(
 792         LPRTL_RWLOCK);
 793
 794 /*      time functions */
 795
 796 typedef struct _TIME_FIELDS
 797 {   CSHORT Year;
 798     CSHORT Month;
 799     CSHORT Day;
 800     CSHORT Hour;
 801     CSHORT Minute;
 802     CSHORT Second;
 803     CSHORT Milliseconds;
 804     CSHORT Weekday;
 805 } TIME_FIELDS;
 806
 807 typedef TIME_FIELDS *PTIME_FIELDS;
 808
 809 VOID WINAPI RtlSystemTimeToLocalTime(
 810         IN  PLARGE_INTEGER SystemTime,
 811         OUT PLARGE_INTEGER LocalTime);
 812
 813 VOID WINAPI RtlTimeToTimeFields(
 814         PLARGE_INTEGER liTime,
 815         PTIME_FIELDS TimeFields);
 816
 817 BOOLEAN WINAPI RtlTimeFieldsToTime(
 818         PTIME_FIELDS tfTimeFields,
 819         PLARGE_INTEGER Time);
 820
 821 VOID WINAPI RtlTimeToElapsedTimeFields(
 822         PLARGE_INTEGER liTime,
 823         PTIME_FIELDS TimeFields);
 824
 825 void    WINAPI NtQuerySystemTime( LARGE_INTEGER *time );
 826
 827 BOOLEAN WINAPI RtlTimeToSecondsSince1980( const FILETIME *time, LPDWORD res );
 828 BOOLEAN WINAPI RtlTimeToSecondsSince1970( const FILETIME *time, LPDWORD res );
 829 void    WINAPI RtlSecondsSince1970ToTime( DWORD time, FILETIME *res );
 830 void    WINAPI RtlSecondsSince1980ToTime( DWORD time, FILETIME *res );
 831
 832 /*      heap functions */
 833
 834 /* Data structure for heap definition. This includes various
 835    sizing parameters and callback routines, which, if left NULL,
 836    result in default behavior */
 837
 838 typedef struct
 839 {       ULONG   Length;         /* = sizeof(RTL_HEAP_DEFINITION) */
 840         ULONG   Unknown[11];
 841 } RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
 842
 843 HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
 844 HANDLE    WINAPI RtlDestroyHeap(HANDLE);
 845 PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
 846 BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
 847 PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
 848 ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
 849 BOOLEAN   WINAPI RtlLockHeap(HANDLE);
 850 BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
 851 ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
 852 BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,PCVOID);
 853 ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
 854 NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
 855
 856 /*      exception */
 857
 858 void WINAPI NtRaiseException(
 859         PEXCEPTION_RECORD,PCONTEXT,BOOL);
 860
 861 void WINAPI RtlRaiseException(
 862         PEXCEPTION_RECORD);
 863
 864 void WINAPI RtlRaiseStatus(
 865         NTSTATUS);
 866
 867 void WINAPI RtlUnwind(
 868         PEXCEPTION_FRAME,
 869         LPVOID,
 870         PEXCEPTION_RECORD,DWORD);
 871
 872 /*      process environment block  */
 873 VOID WINAPI RtlAcquirePebLock(void);
 874 VOID WINAPI RtlReleasePebLock(void);
 875
 876 /*      mathematics */
 877 LONGLONG  WINAPI RtlConvertLongToLargeInteger( LONG a );
 878 LONGLONG  WINAPI RtlEnlargedIntegerMultiply( INT a, INT b );
 879 LONGLONG  WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift );
 880 LONGLONG  WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b );
 881 LONGLONG  WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem );
 882 LONGLONG  WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b );
 883 LONGLONG  WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count );
 884 LONGLONG  WINAPI RtlLargeIntegerNegate( LONGLONG a );
 885 LONGLONG  WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count );
 886 LONGLONG  WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count );
 887 LONGLONG  WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b );
 888 ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b );
 889 UINT      WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr );
 890 ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a );
 891 ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem );
 892
 893 /*      environment */
 894 DWORD WINAPI RtlCreateEnvironment(
 895         DWORD x1,
 896         DWORD x2);
 897
 898 DWORD WINAPI RtlDestroyEnvironment(
 899         DWORD x);
 900
 901 DWORD WINAPI RtlQueryEnvironmentVariable_U(
 902         DWORD x1,
 903         PUNICODE_STRING key,
 904         PUNICODE_STRING val) ;
 905
 906 DWORD WINAPI RtlSetEnvironmentVariable(
 907         DWORD x1,
 908         PUNICODE_STRING key,
 909         PUNICODE_STRING val);
 910
 911 /*      object security */
 912
 913 DWORD WINAPI RtlNewSecurityObject(
 914         DWORD x1,
 915         DWORD x2,
 916         DWORD x3,
 917         DWORD x4,
 918         DWORD x5,
 919         DWORD x6);
 920
 921 DWORD WINAPI RtlDeleteSecurityObject(
 922         DWORD x1);
 923
 924 NTSTATUS WINAPI
 925 NtQuerySecurityObject(
 926         IN HANDLE Object,
 927         IN SECURITY_INFORMATION RequestedInformation,
 928         OUT PSECURITY_DESCRIPTOR pSecurityDesriptor,
 929         IN ULONG Length,
 930         OUT PULONG ResultLength);
 931
 932 NTSTATUS WINAPI
 933 NtSetSecurityObject(
 934         IN HANDLE Handle,
 935         IN SECURITY_INFORMATION SecurityInformation,
 936         IN PSECURITY_DESCRIPTOR SecurityDescriptor);
 937
 938 /*      registry functions */
 939
 940 NTSTATUS    WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,
 941                                const UNICODE_STRING*,ULONG,PULONG);
 942 NTSTATUS    WINAPI NtDeleteKey(HANDLE);
 943 NTSTATUS    WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING*);
 944 NTSTATUS    WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
 945 NTSTATUS    WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
 946 NTSTATUS    WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING*,ULONG,ULONG,const void*,ULONG);
 947 NTSTATUS    WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
 948 NTSTATUS    WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING*,KEY_VALUE_INFORMATION_CLASS,
 949                                    void*,DWORD,DWORD*);
 950 NTSTATUS    WINAPI NtLoadKey(const OBJECT_ATTRIBUTES*,const OBJECT_ATTRIBUTES*);
 951
 952
 953 NTSTATUS WINAPI NtEnumerateValueKey(
 954         HANDLE KeyHandle,
 955         ULONG Index,
 956         KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
 957         PVOID KeyInformation,
 958         ULONG Length,
 959         PULONG ResultLength);
 960
 961 NTSTATUS WINAPI NtFlushKey(HANDLE KeyHandle);
 962
 963 NTSTATUS WINAPI NtNotifyChangeKey(
 964         IN HANDLE KeyHandle,
 965         IN HANDLE Event,
 966         IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
 967         IN PVOID ApcContext OPTIONAL,
 968         OUT PIO_STATUS_BLOCK IoStatusBlock,
 969         IN ULONG CompletionFilter,
 970         IN BOOLEAN Asynchroneous,
 971         OUT PVOID ChangeBuffer,
 972         IN ULONG Length,
 973         IN BOOLEAN WatchSubtree);
 974
 975 NTSTATUS WINAPI NtQueryMultipleValueKey(
 976         HANDLE KeyHandle,
 977         PVALENTW ListOfValuesToQuery,
 978         ULONG NumberOfItems,
 979         PVOID MultipleValueInformation,
 980         ULONG Length,
 981         PULONG  ReturnLength);
 982
 983 NTSTATUS WINAPI NtReplaceKey(
 984         IN POBJECT_ATTRIBUTES ObjectAttributes,
 985         IN HANDLE Key,
 986         IN POBJECT_ATTRIBUTES ReplacedObjectAttributes);
 987
 988 NTSTATUS WINAPI NtRestoreKey(
 989         HANDLE KeyHandle,
 990         HANDLE FileHandle,
 991         ULONG RestoreFlags);
 992
 993 NTSTATUS WINAPI NtSaveKey(
 994         IN HANDLE KeyHandle,
 995         IN HANDLE FileHandle);
 996
 997 NTSTATUS WINAPI NtSetInformationKey(
 998         IN HANDLE KeyHandle,
 999         IN const int KeyInformationClass,
1000         IN PVOID KeyInformation,
1001         IN ULONG KeyInformationLength);
1002
1003 NTSTATUS WINAPI NtUnloadKey(
1004         IN HANDLE KeyHandle);
1005
1006 NTSTATUS WINAPI NtClose(
1007         HANDLE Handle);
1008
1009 NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
1010 NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
1011
1012 NTSTATUS WINAPI NtClearEvent(HANDLE);
1013 NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1014 NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
1015 NTSTATUS WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *attr);
1016 NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
1017 NTSTATUS WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
1018 NTSTATUS WINAPI NtResetEvent(HANDLE,PULONG);
1019 NTSTATUS WINAPI NtSetEvent(HANDLE,PULONG);
1020
1021 NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit );
1022 NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount );
1023 NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit );
1024 NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit );
1025 NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit );
1026 NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1027 BOOL     WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
1028 NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit );
1029
1030 /* file functions */
1031
1032 /* flags for NtCreateFile and NtOpenFile */
1033 #define FILE_DIRECTORY_FLAG  0x00000001
1034 #define FILE_WRITE_THROUGH   0x00000002
1035 #define FILE_SEQUENTIAL_ONLY 0x00000004
1036 #define FILE_NO_INTERMEDIATE_BUFFERING 0x00000008
1037 #define FILE_SYNCHRONOUS_IO_ALERT    0x00000010
1038 #define FILE_SYNCHRONOUS_IO_NONALERT 0x00000020
1039 #define FILE_NON_DIRECTORY_FILE      0x00000040
1040 #define FILE_CREATE_TREE_CONNECTION  0x00000080
1041
1042 /* status for NtCreateFile or NtOpenFile */
1043 #define FILE_SUPERSEDED  0x00000000
1044 #define FILE_OPENED      0x00000001
1045 #define FILE_CREATED     0x00000002
1046 #define FILE_OVERWRITTEN 0x00000003
1047 #define FILE_EXISTS      0x00000004
1048 #define FILE_DOES_NOT_EXIST 0x00000005
1049
1050 NTSTATUS WINAPI NtCreateFile(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, PLARGE_INTEGER, ULONG, ULONG, ULONG, ULONG, PVOID, ULONG);
1051 NTSTATUS WINAPI NtOpenFile(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK, ULONG, ULONG);
1052 NTSTATUS WINAPI NtReadFile(HANDLE, HANDLE, PIO_APC_ROUTINE, PVOID, PIO_STATUS_BLOCK, PVOID, ULONG, PLARGE_INTEGER, PULONG);
1053
1054
1055 /* string functions */
1056 extern LPSTR _strlwr( LPSTR str );
1057 extern LPSTR _strupr( LPSTR str );
1058
1059 /*      misc */
1060
1061 #if defined(__i386__) && defined(__GNUC__)
1062 static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
1063 static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
1064 #else  /* __i386__ && __GNUC__ */
1065 void WINAPI DbgBreakPoint(void);
1066 void WINAPI DbgUserBreakPoint(void);
1067 #endif  /* __i386__ && __GNUC__ */
1068 void WINAPIV DbgPrint(LPCSTR fmt, ...);
1069
1070 DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
1071 DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
1072 LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
1073 DWORD WINAPI RtlNtStatusToDosError(DWORD error);
1074 BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
1075 PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule);
1076 PIMAGE_SECTION_HEADER WINAPI RtlImageRvaToSection( const IMAGE_NT_HEADERS *, HMODULE, DWORD );
1077 PVOID WINAPI RtlImageDirectoryEntryToData( HMODULE module, BOOL image, WORD dir, ULONG *size );
1078 PVOID WINAPI RtlImageRvaToVa( const IMAGE_NT_HEADERS *, HMODULE, DWORD, IMAGE_SECTION_HEADER **);
1079
1080 DWORD WINAPI RtlOpenCurrentUser(
1081         IN ACCESS_MASK DesiredAccess,
1082         OUT PHANDLE KeyHandle);
1083
1084 BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
1085 BOOL WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
1086
1087 NTSTATUS WINAPI
1088 NtAccessCheck(
1089         IN PSECURITY_DESCRIPTOR SecurityDescriptor,
1090         IN HANDLE ClientToken,
1091         IN ACCESS_MASK DesiredAccess,
1092         IN PGENERIC_MAPPING GenericMapping,
1093         OUT PPRIVILEGE_SET PrivilegeSet,
1094         OUT PULONG ReturnLength,
1095         OUT PULONG GrantedAccess,
1096         OUT PBOOLEAN AccessStatus);
1097
1098 /* bitmap functions */
1099
1100 /* Bitmap data type */
1101 typedef struct tagRTL_BITMAP
1102 {
1103   ULONG  SizeOfBitMap; /* Number of bits in the bitmap */
1104   LPBYTE BitMapBuffer; /* Bitmap data, assumed sized to a DWORD boundary */
1105 } RTL_BITMAP, *PRTL_BITMAP;
1106
1107 typedef const RTL_BITMAP* PCRTL_BITMAP;
1108
1109 /* Bit run data type */
1110 typedef struct tagRTL_BITMAP_RUN
1111 {
1112   ULONG StartOfRun; /* Bit position at which run starts - FIXME: Name? */
1113   ULONG SizeOfRun;  /* Size of the run in bits - FIXME: Name? */
1114 } RTL_BITMAP_RUN, *PRTL_BITMAP_RUN;
1115
1116 typedef const RTL_BITMAP_RUN* PCRTL_BITMAP_RUN;
1117
1118 /* Bitmap functions */
1119 VOID    WINAPI RtlInitializeBitMap(PRTL_BITMAP,LPBYTE,ULONG);
1120 VOID    WINAPI RtlSetAllBits(PRTL_BITMAP);
1121 VOID    WINAPI RtlClearAllBits(PRTL_BITMAP);
1122 VOID    WINAPI RtlSetBits(PRTL_BITMAP,ULONG,ULONG);
1123 VOID    WINAPI RtlClearBits(PRTL_BITMAP,ULONG,ULONG);
1124 ULONG   WINAPI RtlFindSetBits(PCRTL_BITMAP,ULONG,ULONG);
1125 ULONG   WINAPI RtlFindClearBits(PCRTL_BITMAP,ULONG,ULONG);
1126 ULONG   WINAPI RtlFindSetBitsAndClear(PRTL_BITMAP,ULONG,ULONG);
1127 ULONG   WINAPI RtlFindClearBitsAndSet(PRTL_BITMAP,ULONG,ULONG);
1128 ULONG   WINAPI RtlNumberOfSetBits(PCRTL_BITMAP);
1129 ULONG   WINAPI RtlNumberOfClearBits(PCRTL_BITMAP);
1130 ULONG   WINAPI RtlFindSetRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1131 ULONG   WINAPI RtlFindClearRuns(PCRTL_BITMAP,PRTL_BITMAP_RUN,ULONG,BOOLEAN);
1132 ULONG   WINAPI RtlFindLongestRunSet(PCRTL_BITMAP,PULONG);
1133 ULONG   WINAPI RtlFindLongestRunClear(PCRTL_BITMAP,PULONG);
1134 BOOLEAN WINAPI RtlAreBitsSet(PCRTL_BITMAP,ULONG,ULONG);
1135 BOOLEAN WINAPI RtlAreBitsClear(PCRTL_BITMAP,ULONG,ULONG);
1136 ULONG   WINAPI RtlFindLastBackwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1137 ULONG   WINAPI RtlFindLastBackwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1138 ULONG   WINAPI RtlFindNextForwardRunSet(PCRTL_BITMAP,ULONG,PULONG);
1139 ULONG   WINAPI RtlFindNextForwardRunClear(PCRTL_BITMAP,ULONG,PULONG);
1140 CCHAR   WINAPI RtlFindMostSignificantBit(ULONGLONG);
1141 CCHAR   WINAPI RtlFindLeastSignificantBit(ULONGLONG);
1142
1143 /* Inline the trivial calls */
1144 #define RtlInitializeBitMap(p,b,s) \
1145   do { \
1146     PRTL_BITMAP _p = (p); \
1147     _p->SizeOfBitMap = (s); \
1148     _p->BitMapBuffer = (b); \
1149   } while(0)
1150
1151 #define RtlSetAllBits(p) \
1152   do { \
1153     PRTL_BITMAP _p = (p); \
1154     memset(_p->BitMapBuffer,0xff,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1155   } while(0)
1156
1157 #define RtlClearAllBits(p) \
1158   do {\
1159     PRTL_BITMAP _p = (p);\
1160     memset(_p->BitMapBuffer,0,((_p->SizeOfBitMap + 31) & 0xffffffe0) >> 3); \
1161   } while(0)
1162
1163 inline static BOOLEAN RtlCheckBit(PCRTL_BITMAP lpBits, ULONG ulBit)
1164 {
1165   if (lpBits && ulBit < lpBits->SizeOfBitMap &&
1166       lpBits->BitMapBuffer[ulBit >> 3] & (1 << (ulBit & 7)))
1167     return TRUE;
1168   return FALSE;
1169 }
1170
1171 /* Endianness */
1172 #define RtlStoreUlong(p,v)  do { ULONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1173 #define RtlRetrieveUlong(p,s) memcpy((p), (s), sizeof(ULONG))
1174
1175 #define RtlStoreUlonglong(p,v) do { ULONGLONG _v = (v); memcpy((p), &_v, sizeof(_v)); } while (0)
1176 #define RtlRetrieveUlonglong(p,s) memcpy((p), (s), sizeof(ULONGLONG))
1177
1178 #ifdef __cplusplus
1179 }
1180 #endif
1181
1182 #endif