winsup/cygwin/ntdll.h

   1 /* ntdll.h.  Contains ntdll specific stuff not defined elsewhere.
   2
   3    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007 Red Hat, Inc.
   4
   5    This file is part of Cygwin.
   6
   7    This software is a copyrighted work licensed under the terms of the
   8    Cygwin license.  Please consult the file "CYGWIN_LICENSE" for
   9    details. */
  10
  11 #ifndef STATUS_INVALID_INFO_CLASS
  12 /* Some w32api header file defines this so we need to conditionalize this
  13    define to avoid warnings. */
  14 #define STATUS_INVALID_INFO_CLASS     ((NTSTATUS) 0xc0000003)
  15 #endif
  16 #define STATUS_INFO_LENGTH_MISMATCH   ((NTSTATUS) 0xc0000004)
  17 #define STATUS_INVALID_PARAMETER      ((NTSTATUS) 0xc000000d)
  18 #define STATUS_INVALID_DEVICE_REQUEST ((NTSTATUS) 0xc0000010)
  19 #define STATUS_BUFFER_TOO_SMALL       ((NTSTATUS) 0xc0000023)
  20 #define STATUS_SHARING_VIOLATION      ((NTSTATUS) 0xc0000043)
  21 #define STATUS_DELETE_PENDING         ((NTSTATUS) 0xc0000056)
  22 #define STATUS_WORKING_SET_QUOTA      ((NTSTATUS) 0xc00000a1)
  23 #define STATUS_NOT_ALL_ASSIGNED       ((NTSTATUS) 0x00000106)
  24 #define STATUS_INVALID_LEVEL          ((NTSTATUS) 0xc0000148)
  25 #define STATUS_NO_MORE_FILES          ((NTSTATUS) 0x80000006)
  26 #define PDI_MODULES 0x01
  27 #define PDI_HEAPS 0x04
  28 #define LDRP_IMAGE_DLL 0x00000004
  29 #define WSLE_PAGE_READONLY 0x001
  30 #define WSLE_PAGE_EXECUTE 0x002
  31 #define WSLE_PAGE_EXECUTE_READ 0x003
  32 #define WSLE_PAGE_READWRITE 0x004
  33 #define WSLE_PAGE_WRITECOPY 0x005
  34 #define WSLE_PAGE_EXECUTE_READWRITE 0x006
  35 #define WSLE_PAGE_EXECUTE_WRITECOPY 0x007
  36 #define WSLE_PAGE_SHARE_COUNT_MASK 0x0E0
  37 #define WSLE_PAGE_SHAREABLE 0x100
  38
  39 typedef enum _FILE_INFORMATION_CLASS
  40 {
  41   FileDirectoryInformation = 1,
  42   FileFullDirectoryInformation, // 2
  43   FileBothDirectoryInformation, // 3
  44   FileBasicInformation, // 4 wdm
  45   FileStandardInformation, // 5 wdm
  46   FileInternalInformation, // 6
  47   FileEaInformation, // 7
  48   FileAccessInformation, // 8
  49   FileNameInformation, // 9
  50   FileRenameInformation, // 10
  51   FileLinkInformation, // 11
  52   FileNamesInformation, // 12
  53   FileDispositionInformation, // 13
  54   FilePositionInformation, // 14 wdm
  55   FileFullEaInformation, // 15
  56   FileModeInformation, // 16
  57   FileAlignmentInformation, // 17
  58   FileAllInformation, // 18
  59   FileAllocationInformation, // 19
  60   FileEndOfFileInformation, // 20 wdm
  61   FileAlternateNameInformation, // 21
  62   FileStreamInformation, // 22
  63   FilePipeInformation, // 23
  64   FilePipeLocalInformation, // 24
  65   FilePipeRemoteInformation, // 25
  66   FileMailslotQueryInformation, // 26
  67   FileMailslotSetInformation, // 27
  68   FileCompressionInformation, // 28
  69   FileObjectIdInformation, // 29
  70   FileCompletionInformation, // 30
  71   FileMoveClusterInformation, // 31
  72   FileQuotaInformation, // 32
  73   FileReparsePointInformation, // 33
  74   FileNetworkOpenInformation, // 34
  75   FileAttributeTagInformation, // 35
  76   FileTrackingInformation, // 36
  77   FileIdBothDirectoryInformation, // 37
  78   FileIdFullDirectoryInformation, // 38
  79   FileValidDataLengthInformation, // 39
  80   FileShortNameInformation, // 40
  81   FileMaximumInformation
  82 } FILE_INFORMATION_CLASS, *PFILE_INFORMATION_CLASS;
  83
  84 typedef struct _FILE_NAMES_INFORMATION
  85 {
  86   ULONG  NextEntryOffset;
  87   ULONG  FileIndex;
  88   ULONG  FileNameLength;
  89   WCHAR  FileName[1];
  90 } FILE_NAMES_INFORMATION, *PFILE_NAMES_INFORMATION;
  91
  92 typedef struct _FILE_DIRECTORY_INFORMATION {
  93   ULONG  NextEntryOffset;
  94   ULONG  FileIndex;
  95   LARGE_INTEGER  CreationTime;
  96   LARGE_INTEGER  LastAccessTime;
  97   LARGE_INTEGER  LastWriteTime;
  98   LARGE_INTEGER  ChangeTime;
  99   LARGE_INTEGER  EndOfFile;
 100   LARGE_INTEGER  AllocationSize;
 101   ULONG  FileAttributes;
 102   ULONG  FileNameLength;
 103   WCHAR  FileName[1];
 104 } FILE_DIRECTORY_INFORMATION, *PFILE_DIRECTORY_INFORMATION;
 105
 106 typedef struct _FILE_BOTH_DIR_INFORMATION
 107 {
 108   ULONG  NextEntryOffset;
 109   ULONG  FileIndex;
 110   LARGE_INTEGER  CreationTime;
 111   LARGE_INTEGER  LastAccessTime;
 112   LARGE_INTEGER  LastWriteTime;
 113   LARGE_INTEGER  ChangeTime;
 114   LARGE_INTEGER  EndOfFile;
 115   LARGE_INTEGER  AllocationSize;
 116   ULONG  FileAttributes;
 117   ULONG  FileNameLength;
 118   ULONG  EaSize;
 119   CCHAR  ShortNameLength;
 120   WCHAR  ShortName[12];
 121   WCHAR  FileName[1];
 122 } FILE_BOTH_DIR_INFORMATION, *PFILE_BOTH_DIR_INFORMATION;
 123
 124 typedef struct _FILE_ID_BOTH_DIR_INFORMATION
 125 {
 126   ULONG  NextEntryOffset;
 127   ULONG  FileIndex;
 128   LARGE_INTEGER  CreationTime;
 129   LARGE_INTEGER  LastAccessTime;
 130   LARGE_INTEGER  LastWriteTime;
 131   LARGE_INTEGER  ChangeTime;
 132   LARGE_INTEGER  EndOfFile;
 133   LARGE_INTEGER  AllocationSize;
 134   ULONG  FileAttributes;
 135   ULONG  FileNameLength;
 136   ULONG  EaSize;
 137   CCHAR  ShortNameLength;
 138   WCHAR  ShortName[12];
 139   LARGE_INTEGER  FileId;
 140   WCHAR  FileName[1];
 141 } FILE_ID_BOTH_DIR_INFORMATION, *PFILE_ID_BOTH_DIR_INFORMATION;
 142
 143
 144 #define AT_EXTENDABLE_FILE 0x00002000
 145 #define AT_ROUND_TO_PAGE 0x40000000
 146
 147 #define LOCK_VM_IN_WSL 1
 148 #define LOCK_VM_IN_RAM 2
 149
 150 #define DIRECTORY_QUERY 1
 151
 152 typedef ULONG KAFFINITY;
 153
 154 typedef enum _SYSTEM_INFORMATION_CLASS
 155 {
 156   SystemBasicInformation = 0,
 157   SystemPerformanceInformation = 2,
 158   SystemTimeOfDayInformation = 3,
 159   SystemProcessesAndThreadsInformation = 5,
 160   SystemProcessorTimes = 8,
 161   SystemPagefileInformation = 18,
 162   /* There are a lot more of these... */
 163 } SYSTEM_INFORMATION_CLASS;
 164
 165 typedef struct _SYSTEM_BASIC_INFORMATION
 166 {
 167   ULONG Unknown;
 168   ULONG MaximumIncrement;
 169   ULONG PhysicalPageSize;
 170   ULONG NumberOfPhysicalPages;
 171   ULONG LowestPhysicalPage;
 172   ULONG HighestPhysicalPage;
 173   ULONG AllocationGranularity;
 174   ULONG LowestUserAddress;
 175   ULONG HighestUserAddress;
 176   ULONG ActiveProcessors;
 177   UCHAR NumberProcessors;
 178 } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
 179
 180 typedef struct _SYSTEM_PAGEFILE_INFORMATION
 181 {
 182   ULONG NextEntryOffset;
 183   ULONG CurrentSize;
 184   ULONG TotalUsed;
 185   ULONG PeakUsed;
 186   UNICODE_STRING FileName;
 187 } SYSTEM_PAGEFILE_INFORMATION, *PSYSTEM_PAGEFILE_INFORMATION;
 188
 189 typedef struct __attribute__ ((aligned (8))) _SYSTEM_PROCESSOR_TIMES
 190 {
 191   LARGE_INTEGER IdleTime;
 192   LARGE_INTEGER KernelTime;
 193   LARGE_INTEGER UserTime;
 194   LARGE_INTEGER DpcTime;
 195   LARGE_INTEGER InterruptTime;
 196   ULONG InterruptCount;
 197 } SYSTEM_PROCESSOR_TIMES, *PSYSTEM_PROCESSOR_TIMES;
 198
 199 typedef LONG KPRIORITY;
 200 typedef struct _VM_COUNTERS
 201 {
 202   ULONG PeakVirtualSize;
 203   ULONG VirtualSize;
 204   ULONG PageFaultCount;
 205   ULONG PeakWorkingSetSize;
 206   ULONG WorkingSetSize;
 207   ULONG QuotaPeakPagedPoolUsage;
 208   ULONG QuotaPagedPoolUsage;
 209   ULONG QuotaPeakNonPagedPoolUsage;
 210   ULONG QuotaNonPagedPoolUsage;
 211   ULONG PagefileUsage;
 212   ULONG PeakPagefileUsage;
 213 } VM_COUNTERS, *PVM_COUNTERS;
 214
 215 typedef struct _CLIENT_ID
 216 {
 217   HANDLE UniqueProcess;
 218   HANDLE UniqueThread;
 219 } CLIENT_ID, *PCLIENT_ID;
 220
 221 typedef enum
 222 {
 223   StateInitialized,
 224   StateReady,
 225   StateRunning,
 226   StateStandby,
 227   StateTerminated,
 228   StateWait,
 229   StateTransition,
 230   StateUnknown,
 231 } THREAD_STATE;
 232
 233 typedef enum
 234 {
 235   Executive,
 236   FreePage,
 237   PageIn,
 238   PoolAllocation,
 239   DelayExecution,
 240   Suspended,
 241   UserRequest,
 242   WrExecutive,
 243   WrFreePage,
 244   WrPageIn,
 245   WrPoolAllocation,
 246   WrDelayExecution,
 247   WrSuspended,
 248   WrUserRequest,
 249   WrEventPair,
 250   WrQueue,
 251   WrLpcReceive,
 252   WrLpcReply,
 253   WrVirtualMemory,
 254   WrPageOut,
 255   WrRendezvous,
 256   Spare2,
 257   Spare3,
 258   Spare4,
 259   Spare5,
 260   Spare6,
 261   WrKernel,
 262   MaximumWaitReason
 263 } KWAIT_REASON;
 264
 265 typedef struct _SYSTEM_THREADS
 266 {
 267   LARGE_INTEGER KernelTime;
 268   LARGE_INTEGER UserTime;
 269   LARGE_INTEGER CreateTime;
 270   ULONG WaitTime;
 271   PVOID StartAddress;
 272   CLIENT_ID ClientId;
 273   KPRIORITY Priority;
 274   KPRIORITY BasePriority;
 275   ULONG ContextSwitchCount;
 276   THREAD_STATE State;
 277   KWAIT_REASON WaitReason;
 278   DWORD Reserved;
 279 } SYSTEM_THREADS, *PSYSTEM_THREADS;
 280
 281 typedef struct _SYSTEM_PROCESSES
 282 {
 283   ULONG NextEntryDelta;
 284   ULONG ThreadCount;
 285   ULONG Reserved1[6];
 286   LARGE_INTEGER CreateTime;
 287   LARGE_INTEGER UserTime;
 288   LARGE_INTEGER KernelTime;
 289   UNICODE_STRING ProcessName;
 290   KPRIORITY BasePriority;
 291   ULONG ProcessId;
 292   ULONG InheritedFromProcessId;
 293   ULONG HandleCount;
 294   ULONG Reserved2[2];
 295   VM_COUNTERS VmCounters;
 296   IO_COUNTERS IoCounters;
 297   SYSTEM_THREADS Threads[1];
 298 } SYSTEM_PROCESSES, *PSYSTEM_PROCESSES;
 299
 300 typedef struct _IO_STATUS_BLOCK
 301 {
 302   NTSTATUS Status;
 303   ULONG Information;
 304 } IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;
 305
 306 typedef struct _SYSTEM_PERFORMANCE_INFORMATION
 307 {
 308   LARGE_INTEGER IdleTime;
 309   LARGE_INTEGER ReadTransferCount;
 310   LARGE_INTEGER WriteTransferCount;
 311   LARGE_INTEGER OtherTransferCount;
 312   ULONG ReadOperationCount;
 313   ULONG WriteOperationCount;
 314   ULONG OtherOperationCount;
 315   ULONG AvailablePages;
 316   ULONG TotalCommittedPages;
 317   ULONG TotalCommitLimit;
 318   ULONG PeakCommitment;
 319   ULONG PageFaults;
 320   ULONG WriteCopyFaults;
 321   ULONG TransitionFaults;
 322   ULONG Reserved1;
 323   ULONG DemandZeroFaults;
 324   ULONG PagesRead;
 325   ULONG PageReadIos;
 326   ULONG Reserved2[2];
 327   ULONG PagefilePagesWritten;
 328   ULONG PagefilePageWriteIos;
 329   ULONG MappedFilePagesWritten;
 330   ULONG MappedFilePageWriteIos;
 331   ULONG PagedPoolUsage;
 332   ULONG NonPagedPoolUsage;
 333   ULONG PagedPoolAllocs;
 334   ULONG PagedPoolFrees;
 335   ULONG NonPagedPoolAllocs;
 336   ULONG NonPagedPoolFrees;
 337   ULONG TotalFreeSystemPtes;
 338   ULONG SystemCodePage;
 339   ULONG TotalSystemDriverPages;
 340   ULONG TotalSystemCodePages;
 341   ULONG SmallNonPagedLookasideListAllocateHits;
 342   ULONG SmallPagedLookasideListAllocateHits;
 343   ULONG Reserved3;
 344   ULONG MmSystemCachePage;
 345   ULONG PagedPoolPage;
 346   ULONG SystemDriverPage;
 347   ULONG FastReadNoWait;
 348   ULONG FastReadWait;
 349   ULONG FastReadResourceMiss;
 350   ULONG FastReadNotPossible;
 351   ULONG FastMdlReadNoWait;
 352   ULONG FastMdlReadWait;
 353   ULONG FastMdlReadResourceMiss;
 354   ULONG FastMdlReadNotPossible;
 355   ULONG MapDataNoWait;
 356   ULONG MapDataWait;
 357   ULONG MapDataNoWaitMiss;
 358   ULONG MapDataWaitMiss;
 359   ULONG PinMappedDataCount;
 360   ULONG PinReadNoWait;
 361   ULONG PinReadWait;
 362   ULONG PinReadNoWaitMiss;
 363   ULONG PinReadWaitMiss;
 364   ULONG CopyReadNoWait;
 365   ULONG CopyReadWait;
 366   ULONG CopyReadNoWaitMiss;
 367   ULONG CopyReadWaitMiss;
 368   ULONG MdlReadNoWait;
 369   ULONG MdlReadWait;
 370   ULONG MdlReadNoWaitMiss;
 371   ULONG MdlReadWaitMiss;
 372   ULONG ReadAheadIos;
 373   ULONG LazyWriteIos;
 374   ULONG LazyWritePages;
 375   ULONG DataFlushes;
 376   ULONG DataPages;
 377   ULONG ContextSwitches;
 378   ULONG FirstLevelTbFills;
 379   ULONG SecondLevelTbFills;
 380   ULONG SystemCalls;
 381 } SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
 382
 383 typedef struct __attribute__ ((aligned(8))) _SYSTEM_TIME_OF_DAY_INFORMATION
 384 {
 385   LARGE_INTEGER BootTime;
 386   LARGE_INTEGER CurrentTime;
 387   LARGE_INTEGER TimeZoneBias;
 388   ULONG CurrentTimeZoneId;
 389 } SYSTEM_TIME_OF_DAY_INFORMATION, *PSYSTEM_TIME_OF_DAY_INFORMATION;
 390
 391 typedef enum _PROCESSINFOCLASS
 392 {
 393   ProcessBasicInformation = 0,
 394   ProcessQuotaLimits = 1,
 395   ProcessVmCounters = 3,
 396   ProcessTimes =4,
 397 } PROCESSINFOCLASS;
 398
 399 typedef struct _DEBUG_BUFFER
 400 {
 401   HANDLE SectionHandle;
 402   PVOID SectionBase;
 403   PVOID RemoteSectionBase;
 404   ULONG SectionBaseDelta;
 405   HANDLE EventPairHandle;
 406   ULONG Unknown[2];
 407   HANDLE RemoteThreadHandle;
 408   ULONG InfoClassMask;
 409   ULONG SizeOfInfo;
 410   ULONG AllocatedSize;
 411   ULONG SectionSize;
 412   PVOID ModuleInformation;
 413   PVOID BackTraceInformation;
 414   PVOID HeapInformation;
 415   PVOID LockInformation;
 416   PVOID Reserved[9];
 417 } DEBUG_BUFFER, *PDEBUG_BUFFER;
 418
 419 typedef struct _DEBUG_HEAP_INFORMATION
 420 {
 421   ULONG Base;
 422   ULONG Flags;
 423   USHORT Granularity;
 424   USHORT Unknown;
 425   ULONG Allocated;
 426   ULONG Committed;
 427   ULONG TagCount;
 428   ULONG BlockCount;
 429   ULONG Reserved[7];
 430   PVOID Tags;
 431   PVOID Blocks;
 432 } DEBUG_HEAP_INFORMATION, *PDEBUG_HEAP_INFORMATION;
 433
 434 typedef struct _DEBUG_MODULE_INFORMATION
 435 {
 436   ULONG Reserved[2];
 437   ULONG Base;
 438   ULONG Size;
 439   ULONG Flags;
 440   USHORT Index;
 441   USHORT Unknown;
 442   USHORT LoadCount;
 443   USHORT ModuleNameOffset;
 444   CHAR ImageName[256];
 445 } DEBUG_MODULE_INFORMATION, *PDEBUG_MODULE_INFORMATION;
 446
 447 typedef struct _KERNEL_USER_TIMES
 448 {
 449   LARGE_INTEGER CreateTime;
 450   LARGE_INTEGER ExitTime;
 451   LARGE_INTEGER KernelTime;
 452   LARGE_INTEGER UserTime;
 453 } KERNEL_USER_TIMES, *PKERNEL_USER_TIMES;
 454
 455 typedef struct _RTL_USER_PROCESS_PARAMETERS
 456 {
 457   ULONG AllocationSize;
 458   ULONG Size;
 459   ULONG Flags;
 460   ULONG DebugFlags;
 461   HANDLE hConsole;
 462   ULONG ProcessGroup;
 463   HANDLE hStdInput;
 464   HANDLE hStdOutput;
 465   HANDLE hStdError;
 466   UNICODE_STRING CurrentDirectoryName;
 467   HANDLE CurrentDirectoryHandle;
 468   UNICODE_STRING DllPath;
 469   UNICODE_STRING ImagePathName;
 470   UNICODE_STRING CommandLine;
 471   PWSTR Environment;
 472   ULONG dwX;
 473   ULONG dwY;
 474   ULONG dwXSize;
 475   ULONG dwYSize;
 476   ULONG dwXCountChars;
 477   ULONG dwYCountChars;
 478   ULONG dwFillAttribute;
 479   ULONG dwFlags;
 480   ULONG wShowWindow;
 481   UNICODE_STRING WindowTitle;
 482   UNICODE_STRING DesktopInfo;
 483   UNICODE_STRING ShellInfo;
 484   UNICODE_STRING RuntimeInfo;
 485 } RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
 486
 487 typedef struct _PEB
 488 {
 489   BYTE Reserved1[2];
 490   BYTE BeingDebugged;
 491   BYTE Reserved2[9];
 492   PVOID LoaderData;
 493   PRTL_USER_PROCESS_PARAMETERS ProcessParameters;
 494   BYTE Reserved3[448];
 495   ULONG SessionId;
 496 } PEB, *PPEB;
 497
 498 typedef struct _PROCESS_BASIC_INFORMATION
 499 {
 500   NTSTATUS ExitStatus;
 501   PPEB PebBaseAddress;
 502   KAFFINITY AffinityMask;
 503   KPRIORITY BasePriority;
 504   ULONG UniqueProcessId;
 505   ULONG InheritedFromUniqueProcessId;
 506 } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
 507
 508 typedef enum _MEMORY_INFORMATION_CLASS
 509 {
 510   MemoryBasicInformation,
 511   MemoryWorkingSetList,
 512   MemorySectionName,
 513   MemoryBasicVlmInformation
 514 } MEMORY_INFORMATION_CLASS;
 515
 516 typedef struct _MEMORY_WORKING_SET_LIST
 517 {
 518   ULONG NumberOfPages;
 519   ULONG WorkingSetList[1];
 520 } MEMORY_WORKING_SET_LIST, *PMEMORY_WORKING_SET_LIST;
 521
 522 typedef struct _FILE_BASIC_INFORMATION {
 523   LARGE_INTEGER CreationTime;
 524   LARGE_INTEGER LastAccessTime;
 525   LARGE_INTEGER LastWriteTime;
 526   LARGE_INTEGER ChangeTime;
 527   ULONG FileAttributes;
 528 } FILE_BASIC_INFORMATION, *PFILE_BASIC_INFORMATION;
 529
 530 typedef struct _FILE_STANDARD_INFORMATION {
 531   LARGE_INTEGER AllocationSize;
 532   LARGE_INTEGER EndOfFile;
 533   ULONG NumberOfLinks;
 534   BOOLEAN DeletePending;
 535   BOOLEAN Directory;
 536 } FILE_STANDARD_INFORMATION, *PFILE_STANDARD_INFORMATION;
 537
 538 typedef struct _FILE_NETWORK_OPEN_INFORMATION {
 539   LARGE_INTEGER CreationTime;
 540   LARGE_INTEGER LastAccessTime;
 541   LARGE_INTEGER LastWriteTime;
 542   LARGE_INTEGER ChangeTime;
 543   LARGE_INTEGER AllocationSize;
 544   LARGE_INTEGER EndOfFile;
 545   ULONG FileAttributes;
 546 } FILE_NETWORK_OPEN_INFORMATION, *PFILE_NETWORK_OPEN_INFORMATION;
 547
 548 typedef struct _FILE_INTERNAL_INFORMATION {
 549   LARGE_INTEGER FileId;
 550 } FILE_INTERNAL_INFORMATION, *PFILE_INTERNAL_INFORMATION;
 551
 552 typedef struct _FILE_EA_INFORMATION {
 553   ULONG EaSize;
 554 } FILE_EA_INFORMATION, *PFILE_EA_INFORMATION;
 555
 556 typedef struct _FILE_ACCESS_INFORMATION {
 557   ACCESS_MASK AccessFlags;
 558 } FILE_ACCESS_INFORMATION, *PFILE_ACCESS_INFORMATION;
 559
 560 typedef struct _FILE_DISPOSITION_INFORMATION {
 561   BOOLEAN DeleteFile;
 562 } FILE_DISPOSITION_INFORMATION, *PFILE_DISPOSITION_INFORMATION;
 563
 564 typedef struct _FILE_POSITION_INFORMATION {
 565   LARGE_INTEGER CurrentByteOffset;
 566 } FILE_POSITION_INFORMATION, *PFILE_POSITION_INFORMATION;
 567
 568 typedef struct _FILE_END_OF_FILE_INFORMATION {
 569   LARGE_INTEGER EndOfFile;
 570 } FILE_END_OF_FILE_INFORMATION, *PFILE_END_OF_FILE_INFORMATION;
 571
 572 typedef struct _FILE_MODE_INFORMATION {
 573   ULONG Mode;
 574 } FILE_MODE_INFORMATION, *PFILE_MODE_INFORMATION;
 575
 576 typedef struct _FILE_ALIGNMENT_INFORMATION {
 577   ULONG AlignmentRequirement;
 578 } FILE_ALIGNMENT_INFORMATION;
 579
 580 typedef struct _FILE_NAME_INFORMATION {
 581   ULONG FileNameLength;
 582   WCHAR FileName[1];
 583 } FILE_NAME_INFORMATION, *PFILE_NAME_INFORMATION;
 584
 585 typedef struct _FILE_LINK_INFORMATION {
 586   BOOLEAN ReplaceIfExists;
 587   HANDLE RootDirectory;
 588   ULONG FileNameLength;
 589   WCHAR FileName[1];
 590 } FILE_LINK_INFORMATION, *PFILE_LINK_INFORMATION;
 591
 592 typedef struct _FILE_RENAME_INFORMATION {
 593   BOOLEAN ReplaceIfExists;
 594   HANDLE RootDirectory;
 595   ULONG FileNameLength;
 596   WCHAR FileName[1];
 597 } FILE_RENAME_INFORMATION, *PFILE_RENAME_INFORMATION;
 598
 599 typedef struct _FILE_ALL_INFORMATION {
 600   FILE_BASIC_INFORMATION     BasicInformation;
 601   FILE_STANDARD_INFORMATION  StandardInformation;
 602   FILE_INTERNAL_INFORMATION  InternalInformation;
 603   FILE_EA_INFORMATION        EaInformation;
 604   FILE_ACCESS_INFORMATION    AccessInformation;
 605   FILE_POSITION_INFORMATION  PositionInformation;
 606   FILE_MODE_INFORMATION      ModeInformation;
 607   FILE_ALIGNMENT_INFORMATION AlignmentInformation;
 608   FILE_NAME_INFORMATION      NameInformation;
 609 } FILE_ALL_INFORMATION, *PFILE_ALL_INFORMATION;
 610
 611 typedef struct _FILE_PIPE_LOCAL_INFORMATION
 612 {
 613   ULONG NamedPipeType;
 614   ULONG NamedPipeConfiguration;
 615   ULONG MaximumInstances;
 616   ULONG CurrentInstances;
 617   ULONG InboundQuota;
 618   ULONG ReadDataAvailable;
 619   ULONG OutboundQuota;
 620   ULONG WriteQuotaAvailable;
 621   ULONG NamedPipeState;
 622   ULONG NamedPipeEnd;
 623 } FILE_PIPE_LOCAL_INFORMATION, *PFILE_PIPE_LOCAL_INFORMATION;
 624
 625 typedef struct _FILE_COMPRESSION_INFORMATION
 626 {
 627   LARGE_INTEGER CompressedSize;
 628   USHORT CompressionFormat;
 629   UCHAR CompressionUnitShift;
 630   UCHAR Unknown;
 631   UCHAR ClusterSizeShift;
 632 } FILE_COMPRESSION_INFORMATION, *PFILE_COMPRESSION_INFORMATION;
 633
 634 typedef struct _FILE_FS_ATTRIBUTE_INFORMATION
 635 {
 636   ULONG FileSystemAttributes;
 637   ULONG MaximumComponentNameLength;
 638   ULONG FileSystemNameLength;
 639   WCHAR FileSystemName[1];
 640 } FILE_FS_ATTRIBUTE_INFORMATION, *PFILE_FS_ATTRIBUTE_INFORMATION;
 641
 642 typedef struct _FILE_FS_VOLUME_INFORMATION
 643 {
 644   LARGE_INTEGER VolumeCreationTime;
 645   ULONG VolumeSerialNumber;
 646   ULONG VolumeLabelLength;
 647   BOOLEAN SupportsObjects;
 648   WCHAR VolumeLabel[1];
 649 } FILE_FS_VOLUME_INFORMATION, *PFILE_FS_VOLUME_INFORMATION;
 650
 651 typedef struct _FILE_FS_SIZE_INFORMATION
 652 {
 653   LARGE_INTEGER TotalAllocationUnits;
 654   LARGE_INTEGER AvailableAllocationUnits;
 655   ULONG SectorsPerAllocationUnit;
 656   ULONG BytesPerSector;
 657 } FILE_FS_SIZE_INFORMATION, *PFILE_FS_SIZE_INFORMATION;
 658
 659 typedef struct _FILE_FS_FULL_SIZE_INFORMATION
 660 {
 661   LARGE_INTEGER TotalAllocationUnits;
 662   LARGE_INTEGER CallerAvailableAllocationUnits;
 663   LARGE_INTEGER ActualAvailableAllocationUnits;
 664   ULONG SectorsPerAllocationUnit;
 665   ULONG BytesPerSector;
 666 } FILE_FS_FULL_SIZE_INFORMATION, *PFILE_FS_FULL_SIZE_INFORMATION;
 667
 668 typedef enum _FSINFOCLASS {
 669   FileFsVolumeInformation = 1,
 670   FileFsLabelInformation,
 671   FileFsSizeInformation,
 672   FileFsDeviceInformation,
 673   FileFsAttributeInformation,
 674   FileFsControlInformation,
 675   FileFsFullSizeInformation,
 676   FileFsObjectIdInformation,
 677   FileFsDriverPathInformation,
 678   FileFsMaximumInformation
 679 } FS_INFORMATION_CLASS, *PFS_INFORMATION_CLASS;
 680
 681 typedef enum _OBJECT_INFORMATION_CLASS
 682 {
 683   ObjectBasicInformation = 0,
 684   ObjectNameInformation = 1,
 685   ObjectHandleInformation = 4
 686    // and many more
 687 } OBJECT_INFORMATION_CLASS;
 688
 689 typedef struct _OBJECT_NAME_INFORMATION
 690 {
 691   UNICODE_STRING Name;
 692 } OBJECT_NAME_INFORMATION;
 693
 694 typedef struct _DIRECTORY_BASIC_INFORMATION
 695 {
 696   UNICODE_STRING ObjectName;
 697   UNICODE_STRING ObjectTypeName;
 698 } DIRECTORY_BASIC_INFORMATION, *PDIRECTORY_BASIC_INFORMATION;
 699
 700 typedef struct _FILE_GET_EA_INFORMATION
 701 {
 702   ULONG   NextEntryOffset;
 703   UCHAR   EaNameLength;
 704   CHAR    EaName[1];
 705 } FILE_GET_EA_INFORMATION, *PFILE_GET_EA_INFORMATION;
 706
 707
 708 typedef struct _FILE_FULL_EA_INFORMATION
 709 {
 710   ULONG NextEntryOffset;
 711   UCHAR Flags;
 712   UCHAR EaNameLength;
 713   USHORT EaValueLength;
 714   CHAR EaName[1];
 715 } FILE_FULL_EA_INFORMATION, *PFILE_FULL_EA_INFORMATION;
 716
 717 /* Function declarations for ntdll.dll.  These don't appear in any
 718    standard Win32 header.  */
 719 extern "C"
 720 {
 721   NTSTATUS NTAPI NtAdjustPrivilegesToken (HANDLE, BOOLEAN, PTOKEN_PRIVILEGES,
 722                                           ULONG, PTOKEN_PRIVILEGES, PULONG);
 723   NTSTATUS NTAPI NtClose (HANDLE);
 724   NTSTATUS NTAPI NtCreateFile (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES,
 725                              PIO_STATUS_BLOCK, PLARGE_INTEGER, ULONG, ULONG,
 726                              ULONG, ULONG, PVOID, ULONG);
 727   NTSTATUS NTAPI NtCreateSection (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES,
 728                                   PLARGE_INTEGER, ULONG, ULONG, HANDLE);
 729   NTSTATUS NTAPI NtCreateToken (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES,
 730                                 TOKEN_TYPE, PLUID, PLARGE_INTEGER, PTOKEN_USER,
 731                                 PTOKEN_GROUPS, PTOKEN_PRIVILEGES, PTOKEN_OWNER,
 732                                 PTOKEN_PRIMARY_GROUP, PTOKEN_DEFAULT_DACL,
 733                                 PTOKEN_SOURCE);
 734   NTSTATUS NTAPI NtFsControlFile (HANDLE, HANDLE, PVOID, PVOID,
 735                                   PIO_STATUS_BLOCK, ULONG, PVOID, ULONG,
 736                                   PVOID, ULONG);
 737   NTSTATUS NTAPI NtLockVirtualMemory (HANDLE, PVOID *, ULONG *, ULONG);
 738   NTSTATUS NTAPI NtMapViewOfSection (HANDLE, HANDLE, PVOID *, ULONG, ULONG,
 739                                      PLARGE_INTEGER, PULONG, SECTION_INHERIT,
 740                                      ULONG, ULONG);
 741   NTSTATUS NTAPI NtOpenDirectoryObject (PHANDLE, ACCESS_MASK,
 742                                         POBJECT_ATTRIBUTES);
 743   NTSTATUS NTAPI NtOpenFile (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES,
 744                              PIO_STATUS_BLOCK, ULONG, ULONG);
 745   NTSTATUS NTAPI NtOpenSection (PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
 746   NTSTATUS NTAPI NtQueryDirectoryFile(HANDLE, HANDLE, PVOID, PVOID,
 747                                       PIO_STATUS_BLOCK, PVOID, ULONG,
 748                                       FILE_INFORMATION_CLASS, BOOLEAN,
 749                                       PUNICODE_STRING, BOOLEAN);
 750   NTSTATUS NTAPI NtQueryDirectoryObject (HANDLE, PVOID, ULONG, BOOLEAN,
 751                                          BOOLEAN, PULONG, PULONG);
 752   NTSTATUS NTAPI NtQueryEaFile (HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG,
 753                                 BOOLEAN, PVOID, ULONG, PULONG, BOOLEAN);
 754   NTSTATUS NTAPI NtQueryFullAttributesFile (POBJECT_ATTRIBUTES,
 755                                             PFILE_NETWORK_OPEN_INFORMATION);
 756   NTSTATUS NTAPI NtQueryInformationFile (HANDLE, PIO_STATUS_BLOCK, PVOID,
 757                                          ULONG, FILE_INFORMATION_CLASS);
 758   NTSTATUS NTAPI NtQueryInformationProcess (HANDLE, PROCESSINFOCLASS,
 759                                             PVOID, ULONG, PULONG);
 760   NTSTATUS NTAPI NtQueryObject (HANDLE, OBJECT_INFORMATION_CLASS, VOID *,
 761                                 ULONG, ULONG *);
 762   NTSTATUS NTAPI NtQuerySystemInformation (SYSTEM_INFORMATION_CLASS,
 763                                            PVOID, ULONG, PULONG);
 764   NTSTATUS NTAPI NtQuerySecurityObject (HANDLE, SECURITY_INFORMATION,
 765                                         PSECURITY_DESCRIPTOR, ULONG, PULONG);
 766   NTSTATUS NTAPI NtQueryVirtualMemory (HANDLE, PVOID, MEMORY_INFORMATION_CLASS,
 767                                        PVOID, ULONG, PULONG);
 768   NTSTATUS NTAPI NtQueryVolumeInformationFile (HANDLE, IO_STATUS_BLOCK *,
 769                                                VOID *, ULONG,
 770                                                FS_INFORMATION_CLASS);
 771   NTSTATUS NTAPI NtSetEaFile (HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG);
 772   NTSTATUS NTAPI NtSetInformationFile (HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG,
 773                                        FILE_INFORMATION_CLASS);
 774   NTSTATUS NTAPI NtSetSecurityObject (HANDLE, SECURITY_INFORMATION,
 775                                       PSECURITY_DESCRIPTOR);
 776   NTSTATUS NTAPI NtUnlockVirtualMemory (HANDLE, PVOID *, ULONG *, ULONG);
 777   NTSTATUS NTAPI NtUnmapViewOfSection (HANDLE, PVOID);
 778   NTSTATUS NTAPI RtlAppendUnicodeToString (PUNICODE_STRING, PCWSTR);
 779   NTSTATUS NTAPI RtlAppendUnicodeStringToString (PUNICODE_STRING,
 780                                                  PUNICODE_STRING);
 781   NTSTATUS NTAPI RtlAnsiStringToUnicodeString (PUNICODE_STRING, PANSI_STRING,
 782                                                BOOLEAN);
 783   LONG NTAPI RtlCompareUnicodeString (PUNICODE_STRING, PUNICODE_STRING,
 784                                       BOOLEAN);
 785   VOID NTAPI RtlCopyUnicodeString (PUNICODE_STRING, PUNICODE_STRING);
 786   ULONG WINAPI RtlCreateUnicodeStringFromAsciiz (PUNICODE_STRING, PCSTR);
 787   BOOLEAN NTAPI RtlEqualUnicodeString (PUNICODE_STRING, PUNICODE_STRING,
 788                                        BOOLEAN);
 789   VOID NTAPI RtlFreeUnicodeString (PUNICODE_STRING);
 790   VOID NTAPI RtlInitEmptyUnicodeString (PUNICODE_STRING, PCWSTR, USHORT);
 791   VOID NTAPI RtlInitUnicodeString (PUNICODE_STRING, PCWSTR);
 792   ULONG NTAPI RtlIsDosDeviceName_U (PCWSTR);
 793   ULONG NTAPI RtlNtStatusToDosError (NTSTATUS);
 794   NTSTATUS NTAPI RtlOemStringToUnicodeString (PUNICODE_STRING, POEM_STRING,
 795                                                BOOLEAN);
 796   VOID NTAPI RtlSecondsSince1970ToTime (ULONG, PLARGE_INTEGER);
 797
 798   /* A few Rtl functions are either actually macros, or they just don't
 799      exist even though they would be a big help.  We implement them here
 800      as inline functions. */
 801   inline
 802   VOID NTAPI RtlInitEmptyUnicodeString(PUNICODE_STRING dest, PCWSTR buf,
 803                                        USHORT len)
 804   {
 805     dest->Length = 0;
 806     dest->MaximumLength = len;
 807     dest->Buffer = (PWSTR) buf;
 808   }
 809   inline
 810   VOID NTAPI RtlInitCountedUnicodeString (PUNICODE_STRING dest, PCWSTR buf,
 811                                           USHORT len)
 812   {
 813     dest->Length = dest->MaximumLength = len;
 814     dest->Buffer = (PWSTR) buf;
 815   }
 816   inline
 817   VOID NTAPI RtlSplitUnicodePath (PUNICODE_STRING path, PUNICODE_STRING dir,
 818                                   PUNICODE_STRING file)
 819   {
 820     USHORT len = path->Length / sizeof (WCHAR);
 821     while (len > 0 && path->Buffer[--len] != L'\\')
 822       ;
 823     ++len;
 824     if (dir)
 825       RtlInitCountedUnicodeString (dir, path->Buffer, len * sizeof (WCHAR));
 826     if (file)
 827       RtlInitCountedUnicodeString (file, &path->Buffer[len],
 828                                    path->Length - len * sizeof (WCHAR));
 829   }
 830   inline
 831   BOOLEAN NTAPI RtlEqualUnicodePathPrefix (PUNICODE_STRING path, PCWSTR prefix,
 832                                            BOOLEAN caseinsensitive)
 833   {
 834     UNICODE_STRING p, pref;
 835
 836     RtlInitUnicodeString (&pref, prefix);
 837     RtlInitCountedUnicodeString (&p, path->Buffer,
 838                                  pref.Length < path->Length
 839                                  ? pref.Length : path->Length);
 840     return RtlEqualUnicodeString (&p, &pref, caseinsensitive);
 841   }
 842   inline
 843   BOOL NTAPI RtlEqualUnicodePathSuffix (PUNICODE_STRING path, PCWSTR suffix,
 844                                         BOOLEAN caseinsensitive)
 845   {
 846     UNICODE_STRING p, suf;
 847
 848     RtlInitUnicodeString (&suf, suffix);
 849     if (suf.Length < path->Length)
 850       RtlInitCountedUnicodeString (&p, (PWCHAR) ((PBYTE) path->Buffer
 851                                        + path->Length - suf.Length),
 852                                    suf.Length);
 853     else
 854       RtlInitCountedUnicodeString (&p, path->Buffer, path->Length);
 855     return RtlEqualUnicodeString (&p, &suf, caseinsensitive);
 856   }
 857 }