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