home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / cwin / c.exe / $INSTDIR / include / ddk / ntapi.h < prev    next >
Encoding:
C/C++ Source or Header  |  2003-12-15  |  67.5 KB  |  3,008 lines
  1. /*
  2.  * ntapi.h
  3.  *
  4.  * Windows NT Native API
  5.  *
  6.  * Most structures in this file is obtained from Windows NT/2000 Native API
  7.  * Reference by Gary Nebbett, ISBN 1578701996.
  8.  *
  9.  * This file is part of the w32api package.
  10.  *
  11.  * Contributors:
  12.  *   Created by Casper S. Hornstrup <chorns@users.sourceforge.net>
  13.  *
  14.  * THIS SOFTWARE IS NOT COPYRIGHTED
  15.  *
  16.  * This source code is offered for use in the public domain. You may
  17.  * use, modify or distribute it freely.
  18.  *
  19.  * This code is distributed in the hope that it will be useful but
  20.  * WITHOUT ANY WARRANTY. ALL WARRANTIES, EXPRESS OR IMPLIED ARE HEREBY
  21.  * DISCLAIMED. This includes but is not limited to warranties of
  22.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  23.  *
  24.  */
  25.  
  26. #ifndef __NTAPI_H
  27. #define __NTAPI_H
  28.  
  29. #if __GNUC__ >=3
  30. #pragma GCC system_header
  31. #endif
  32.  
  33. #ifdef __cplusplus
  34. extern "C" {
  35. #endif
  36.  
  37. #pragma pack(push,4)
  38.  
  39. #include <stdarg.h>
  40. #include <winbase.h>
  41. #include "ntddk.h"
  42. #include "ntpoapi.h"
  43.  
  44. typedef struct _PEB *PPEB;
  45.  
  46. /* FIXME: Unknown definitions */
  47. typedef PVOID POBJECT_TYPE_LIST;
  48. typedef PVOID PEXECUTION_STATE;
  49. typedef PVOID PLANGID;
  50.  
  51.  
  52. /* System information and control */
  53.  
  54. typedef enum _SYSTEM_INFORMATION_CLASS {
  55.     SystemInformationClassMin = 0,
  56.     SystemBasicInformation = 0,
  57.     SystemProcessorInformation = 1,
  58.     SystemPerformanceInformation = 2,
  59.     SystemTimeOfDayInformation = 3,
  60.     SystemPathInformation = 4,
  61.     SystemNotImplemented1 = 4,
  62.     SystemProcessInformation = 5,
  63.     SystemProcessesAndThreadsInformation = 5,
  64.     SystemCallCountInfoInformation = 6,
  65.     SystemCallCounts = 6,
  66.     SystemDeviceInformation = 7,
  67.     SystemConfigurationInformation = 7,
  68.     SystemProcessorPerformanceInformation = 8,
  69.     SystemProcessorTimes = 8,
  70.     SystemFlagsInformation = 9,
  71.     SystemGlobalFlag = 9,
  72.     SystemCallTimeInformation = 10,
  73.     SystemNotImplemented2 = 10,
  74.     SystemModuleInformation = 11,
  75.     SystemLocksInformation = 12,
  76.     SystemLockInformation = 12,
  77.     SystemStackTraceInformation = 13,
  78.     SystemNotImplemented3 = 13,
  79.     SystemPagedPoolInformation = 14,
  80.     SystemNotImplemented4 = 14,
  81.     SystemNonPagedPoolInformation = 15,
  82.     SystemNotImplemented5 = 15,
  83.     SystemHandleInformation = 16,
  84.     SystemObjectInformation = 17,
  85.     SystemPageFileInformation = 18,
  86.     SystemPagefileInformation = 18,
  87.     SystemVdmInstemulInformation = 19,
  88.     SystemInstructionEmulationCounts = 19,
  89.     SystemVdmBopInformation = 20,
  90.     SystemInvalidInfoClass1 = 20,    
  91.     SystemFileCacheInformation = 21,
  92.     SystemCacheInformation = 21,
  93.     SystemPoolTagInformation = 22,
  94.     SystemInterruptInformation = 23,
  95.     SystemProcessorStatistics = 23,
  96.     SystemDpcBehaviourInformation = 24,
  97.     SystemDpcInformation = 24,
  98.     SystemFullMemoryInformation = 25,
  99.     SystemNotImplemented6 = 25,
  100.     SystemLoadImage = 26,
  101.     SystemUnloadImage = 27,
  102.     SystemTimeAdjustmentInformation = 28,
  103.     SystemTimeAdjustment = 28,
  104.     SystemSummaryMemoryInformation = 29,
  105.     SystemNotImplemented7 = 29,
  106.     SystemNextEventIdInformation = 30,
  107.     SystemNotImplemented8 = 30,
  108.     SystemEventIdsInformation = 31,
  109.     SystemNotImplemented9 = 31,
  110.     SystemCrashDumpInformation = 32,
  111.     SystemExceptionInformation = 33,
  112.     SystemCrashDumpStateInformation = 34,
  113.     SystemKernelDebuggerInformation = 35,
  114.     SystemContextSwitchInformation = 36,
  115.     SystemRegistryQuotaInformation = 37,
  116.     SystemLoadAndCallImage = 38,
  117.     SystemPrioritySeparation = 39,
  118.     SystemPlugPlayBusInformation = 40,
  119.     SystemNotImplemented10 = 40,
  120.     SystemDockInformation = 41,
  121.     SystemNotImplemented11 = 41,
  122.     //SystemPowerInformation = 42, Conflicts with POWER_INFORMATION_LEVEL
  123.     SystemInvalidInfoClass2 = 42,
  124.     SystemProcessorSpeedInformation = 43,
  125.     SystemInvalidInfoClass3 = 43,
  126.     SystemCurrentTimeZoneInformation = 44,
  127.     SystemTimeZoneInformation = 44,
  128.     SystemLookasideInformation = 45,
  129.     SystemSetTimeSlipEvent = 46,
  130.     SystemCreateSession = 47,
  131.     SystemDeleteSession = 48,
  132.     SystemInvalidInfoClass4 = 49,
  133.     SystemRangeStartInformation = 50,
  134.     SystemVerifierInformation = 51,
  135.     SystemAddVerifier = 52,
  136.     SystemSessionProcessesInformation    = 53,
  137.     SystemInformationClassMax
  138. } SYSTEM_INFORMATION_CLASS;
  139.  
  140. typedef struct _SYSTEM_BASIC_INFORMATION {
  141.     ULONG  Unknown;
  142.     ULONG  MaximumIncrement;
  143.     ULONG  PhysicalPageSize;
  144.     ULONG  NumberOfPhysicalPages;
  145.     ULONG  LowestPhysicalPage;
  146.     ULONG  HighestPhysicalPage;
  147.     ULONG  AllocationGranularity;
  148.     ULONG  LowestUserAddress;
  149.     ULONG  HighestUserAddress;
  150.     ULONG  ActiveProcessors;
  151.     UCHAR  NumberProcessors;
  152. } SYSTEM_BASIC_INFORMATION, *PSYSTEM_BASIC_INFORMATION;
  153.  
  154. typedef struct _SYSTEM_PROCESSOR_INFORMATION {
  155.     USHORT  ProcessorArchitecture;
  156.     USHORT  ProcessorLevel;
  157.     USHORT  ProcessorRevision;
  158.     USHORT  Unknown;
  159.     ULONG  FeatureBits;
  160. } SYSTEM_PROCESSOR_INFORMATION, *PSYSTEM_PROCESSOR_INFORMATION;
  161.  
  162. typedef struct _SYSTEM_PERFORMANCE_INFORMATION {
  163.     LARGE_INTEGER  IdleTime;
  164.     LARGE_INTEGER  ReadTransferCount;
  165.     LARGE_INTEGER  WriteTransferCount;
  166.     LARGE_INTEGER  OtherTransferCount;
  167.     ULONG  ReadOperationCount;
  168.     ULONG  WriteOperationCount;
  169.     ULONG  OtherOperationCount;
  170.     ULONG  AvailablePages;
  171.     ULONG  TotalCommittedPages;
  172.     ULONG  TotalCommitLimit;
  173.     ULONG  PeakCommitment;
  174.     ULONG  PageFaults;
  175.     ULONG  WriteCopyFaults;
  176.     ULONG  TransitionFaults;
  177.     ULONG  CacheTransitionFaults;
  178.     ULONG  DemandZeroFaults;
  179.     ULONG  PagesRead;
  180.     ULONG  PageReadIos;
  181.     ULONG     CacheReads;
  182.     ULONG     CacheIos;
  183.     ULONG  PagefilePagesWritten;
  184.     ULONG  PagefilePageWriteIos;
  185.     ULONG  MappedFilePagesWritten;
  186.     ULONG  MappedFilePageWriteIos;
  187.     ULONG  PagedPoolUsage;
  188.     ULONG  NonPagedPoolUsage;
  189.     ULONG  PagedPoolAllocs;
  190.     ULONG  PagedPoolFrees;
  191.     ULONG  NonPagedPoolAllocs;
  192.     ULONG  NonPagedPoolFrees;
  193.     ULONG  TotalFreeSystemPtes;
  194.     ULONG  SystemCodePage;
  195.     ULONG  TotalSystemDriverPages;
  196.     ULONG  TotalSystemCodePages;
  197.     ULONG  SmallNonPagedLookasideListAllocateHits;
  198.     ULONG  SmallPagedLookasideListAllocateHits;
  199.     ULONG  Reserved3;
  200.     ULONG  MmSystemCachePage;
  201.     ULONG  PagedPoolPage;
  202.     ULONG  SystemDriverPage;
  203.     ULONG  FastReadNoWait;
  204.     ULONG  FastReadWait;
  205.     ULONG  FastReadResourceMiss;
  206.     ULONG  FastReadNotPossible;
  207.     ULONG  FastMdlReadNoWait;
  208.     ULONG  FastMdlReadWait;
  209.     ULONG  FastMdlReadResourceMiss;
  210.     ULONG  FastMdlReadNotPossible;
  211.     ULONG  MapDataNoWait;
  212.     ULONG  MapDataWait;
  213.     ULONG  MapDataNoWaitMiss;
  214.     ULONG  MapDataWaitMiss;
  215.     ULONG  PinMappedDataCount;
  216.     ULONG  PinReadNoWait;
  217.     ULONG  PinReadWait;
  218.     ULONG  PinReadNoWaitMiss;
  219.     ULONG  PinReadWaitMiss;
  220.     ULONG  CopyReadNoWait;
  221.     ULONG  CopyReadWait;
  222.     ULONG  CopyReadNoWaitMiss;
  223.     ULONG  CopyReadWaitMiss;
  224.     ULONG  MdlReadNoWait;
  225.     ULONG  MdlReadWait;
  226.     ULONG  MdlReadNoWaitMiss;
  227.     ULONG  MdlReadWaitMiss;
  228.     ULONG  ReadAheadIos;
  229.     ULONG  LazyWriteIos;
  230.     ULONG  LazyWritePages;
  231.     ULONG  DataFlushes;
  232.     ULONG  DataPages;
  233.     ULONG  ContextSwitches;
  234.     ULONG  FirstLevelTbFills;
  235.     ULONG  SecondLevelTbFills;
  236.     ULONG  SystemCalls;
  237. } SYSTEM_PERFORMANCE_INFORMATION, *PSYSTEM_PERFORMANCE_INFORMATION;
  238.  
  239. typedef struct _SYSTEM_TIME_OF_DAY_INFORMATION {
  240.     LARGE_INTEGER  BootTime;
  241.     LARGE_INTEGER  CurrentTime;
  242.     LARGE_INTEGER  TimeZoneBias;
  243.     ULONG  CurrentTimeZoneId;
  244. } SYSTEM_TIME_OF_DAY_INFORMATION, *PSYSTEM_TIME_OF_DAY_INFORMATION;
  245.  
  246. typedef struct _VM_COUNTERS {
  247.     ULONG  PeakVirtualSize;
  248.     ULONG  VirtualSize;
  249.     ULONG  PageFaultCount;
  250.     ULONG  PeakWorkingSetSize;
  251.     ULONG  WorkingSetSize;
  252.     ULONG  QuotaPeakPagedPoolUsage;
  253.     ULONG  QuotaPagedPoolUsage;
  254.     ULONG  QuotaPeakNonPagedPoolUsage;
  255.     ULONG  QuotaNonPagedPoolUsage;
  256.     ULONG  PagefileUsage;
  257.     ULONG  PeakPagefileUsage;
  258. } VM_COUNTERS;
  259.  
  260. typedef enum _THREAD_STATE {
  261.     StateInitialized,
  262.     StateReady,
  263.     StateRunning,
  264.     StateStandby,
  265.     StateTerminated,
  266.     StateWait,
  267.     StateTransition,
  268.     StateUnknown
  269. } THREAD_STATE;
  270.  
  271. typedef struct _SYSTEM_THREADS {
  272.     LARGE_INTEGER  KernelTime;
  273.     LARGE_INTEGER  UserTime;
  274.     LARGE_INTEGER  CreateTime;
  275.     ULONG  WaitTime;
  276.     PVOID  StartAddress;
  277.     CLIENT_ID  ClientId;
  278.     KPRIORITY  Priority;
  279.     KPRIORITY  BasePriority;
  280.     ULONG  ContextSwitchCount;
  281.     THREAD_STATE  State;
  282.     KWAIT_REASON  WaitReason;
  283. } SYSTEM_THREADS, *PSYSTEM_THREADS;
  284.  
  285. typedef struct _SYSTEM_PROCESSES {
  286.     ULONG  NextEntryDelta;
  287.     ULONG  ThreadCount;
  288.     ULONG  Reserved1[6];
  289.     LARGE_INTEGER  CreateTime;
  290.     LARGE_INTEGER  UserTime;
  291.     LARGE_INTEGER  KernelTime;
  292.     UNICODE_STRING  ProcessName;
  293.     KPRIORITY  BasePriority;
  294.     ULONG  ProcessId;
  295.     ULONG  InheritedFromProcessId;
  296.     ULONG  HandleCount;
  297.     ULONG  Reserved2[2];
  298.     VM_COUNTERS  VmCounters;
  299.     IO_COUNTERS  IoCounters;
  300.     SYSTEM_THREADS  Threads[1];
  301. } SYSTEM_PROCESSES, *PSYSTEM_PROCESSES;
  302.  
  303. typedef struct _SYSTEM_CALLS_INFORMATION {
  304.     ULONG  Size;
  305.     ULONG  NumberOfDescriptorTables;
  306.     ULONG  NumberOfRoutinesInTable[1];
  307.     ULONG  CallCounts[ANYSIZE_ARRAY];
  308. } SYSTEM_CALLS_INFORMATION, *PSYSTEM_CALLS_INFORMATION;
  309.  
  310. typedef struct _SYSTEM_CONFIGURATION_INFORMATION {
  311.     ULONG  DiskCount;
  312.     ULONG  FloppyCount;
  313.     ULONG  CdRomCount;
  314.     ULONG  TapeCount;
  315.     ULONG  SerialCount;
  316.     ULONG  ParallelCount;
  317. } SYSTEM_CONFIGURATION_INFORMATION, *PSYSTEM_CONFIGURATION_INFORMATION;
  318.  
  319. typedef struct _SYSTEM_PROCESSOR_TIMES {
  320.     LARGE_INTEGER  IdleTime;
  321.     LARGE_INTEGER  KernelTime;
  322.     LARGE_INTEGER  UserTime;
  323.     LARGE_INTEGER  DpcTime;
  324.     LARGE_INTEGER  InterruptTime;
  325.     ULONG  InterruptCount;
  326. } SYSTEM_PROCESSOR_TIMES, *PSYSTEM_PROCESSOR_TIMES;
  327.  
  328. /* SYSTEM_GLOBAL_FLAG.GlobalFlag constants */
  329. #define FLG_STOP_ON_EXCEPTION             0x00000001
  330. #define FLG_SHOW_LDR_SNAPS                0x00000002
  331. #define FLG_DEBUG_INITIAL_COMMAND         0x00000004
  332. #define FLG_STOP_ON_HUNG_GUI              0x00000008
  333. #define FLG_HEAP_ENABLE_TAIL_CHECK        0x00000010
  334. #define FLG_HEAP_ENABLE_FREE_CHECK        0x00000020
  335. #define FLG_HEAP_VALIDATE_PARAMETERS      0x00000040
  336. #define FLG_HEAP_VALIDATE_ALL             0x00000080
  337. #define FLG_POOL_ENABLE_TAIL_CHECK        0x00000100
  338. #define FLG_POOL_ENABLE_FREE_CHECK        0x00000200
  339. #define FLG_POOL_ENABLE_TAGGING           0x00000400
  340. #define FLG_HEAP_ENABLE_TAGGING           0x00000800
  341. #define FLG_USER_STACK_TRACE_DB           0x00001000
  342. #define FLG_KERNEL_STACK_TRACE_DB         0x00002000
  343. #define FLG_MAINTAIN_OBJECT_TYPELIST      0x00004000
  344. #define FLG_HEAP_ENABLE_TAG_BY_DLL        0x00008000
  345. #define FLG_IGNORE_DEBUG_PRIV             0x00010000
  346. #define FLG_ENABLE_CSRDEBUG               0x00020000
  347. #define FLG_ENABLE_KDEBUG_SYMBOL_LOAD     0x00040000
  348. #define FLG_DISABLE_PAGE_KERNEL_STACKS    0x00080000
  349. #define FLG_HEAP_ENABLE_CALL_TRACING      0x00100000
  350. #define FLG_HEAP_DISABLE_COALESCING       0x00200000
  351. #define FLG_ENABLE_CLOSE_EXCEPTIONS       0x00400000
  352. #define FLG_ENABLE_EXCEPTION_LOGGING      0x00800000
  353. #define FLG_ENABLE_DBGPRINT_BUFFERING     0x08000000
  354.  
  355. typedef struct _SYSTEM_GLOBAL_FLAG {
  356.   ULONG  GlobalFlag;
  357. } SYSTEM_GLOBAL_FLAG, *PSYSTEM_GLOBAL_FLAG;
  358.  
  359. typedef struct _SYSTEM_MODULE_INFORMATION_ENTRY {
  360.     ULONG     Unknown1;
  361.     ULONG     Unknown2;
  362.     PVOID  Base;
  363.     ULONG  Size;
  364.     ULONG  Flags;
  365.     USHORT  Index;
  366.   /* Length of module name not including the path, this
  367.      field contains valid value only for NTOSKRNL module */
  368.     USHORT    NameLength;
  369.     USHORT  LoadCount;
  370.     USHORT  PathLength;
  371.     CHAR  ImageName[256];
  372. } SYSTEM_MODULE_INFORMATION_ENTRY, *PSYSTEM_MODULE_INFORMATION_ENTRY;
  373.  
  374. typedef struct _SYSTEM_MODULE_INFORMATION {
  375.     ULONG  Count;
  376.   SYSTEM_MODULE_INFORMATION_ENTRY Module[1];
  377. } SYSTEM_MODULE_INFORMATION, *PSYSTEM_MODULE_INFORMATION;
  378.  
  379. typedef struct _SYSTEM_LOCK_INFORMATION {
  380.     PVOID  Address;
  381.     USHORT  Type;
  382.     USHORT  Reserved1;
  383.     ULONG  ExclusiveOwnerThreadId;
  384.     ULONG  ActiveCount;
  385.     ULONG  ContentionCount;
  386.     ULONG  Reserved2[2];
  387.     ULONG  NumberOfSharedWaiters;
  388.     ULONG  NumberOfExclusiveWaiters;
  389. } SYSTEM_LOCK_INFORMATION, *PSYSTEM_LOCK_INFORMATION;
  390.  
  391. /*SYSTEM_HANDLE_INFORMATION.Flags cosntants */
  392. #define PROTECT_FROM_CLOSE                0x01
  393. #define INHERIT                           0x02
  394.  
  395. typedef struct _SYSTEM_HANDLE_INFORMATION {
  396.     ULONG  ProcessId;
  397.     UCHAR  ObjectTypeNumber;
  398.     UCHAR  Flags;
  399.     USHORT  Handle;
  400.     PVOID  Object;
  401.     ACCESS_MASK  GrantedAccess;
  402. } SYSTEM_HANDLE_INFORMATION, *PSYSTEM_HANDLE_INFORMATION;
  403.  
  404. typedef struct _SYSTEM_OBJECT_TYPE_INFORMATION {
  405.     ULONG  NextEntryOffset;
  406.     ULONG  ObjectCount;
  407.     ULONG  HandleCount;
  408.     ULONG  TypeNumber;
  409.     ULONG  InvalidAttributes;
  410.     GENERIC_MAPPING  GenericMapping;
  411.     ACCESS_MASK  ValidAccessMask;
  412.     POOL_TYPE  PoolType;
  413.     UCHAR  Unknown;
  414.     UNICODE_STRING  Name;
  415. } SYSTEM_OBJECT_TYPE_INFORMATION, *PSYSTEM_OBJECT_TYPE_INFORMATION;
  416.  
  417. /* SYSTEM_OBJECT_INFORMATION.Flags constants */
  418. #define FLG_SYSOBJINFO_SINGLE_HANDLE_ENTRY    0x40
  419. #define FLG_SYSOBJINFO_DEFAULT_SECURITY_QUOTA 0x20
  420. #define FLG_SYSOBJINFO_PERMANENT              0x10
  421. #define FLG_SYSOBJINFO_EXCLUSIVE              0x08
  422. #define FLG_SYSOBJINFO_CREATOR_INFO           0x04
  423. #define FLG_SYSOBJINFO_KERNEL_MODE            0x02
  424.  
  425. typedef struct _SYSTEM_OBJECT_INFORMATION {
  426.     ULONG  NextEntryOffset;
  427.     PVOID  Object;
  428.     ULONG  CreatorProcessId;
  429.     USHORT  Unknown;
  430.     USHORT  Flags;
  431.     ULONG  PointerCount;
  432.     ULONG  HandleCount;
  433.     ULONG  PagedPoolUsage;
  434.     ULONG  NonPagedPoolUsage;
  435.     ULONG  ExclusiveProcessId;
  436.     PSECURITY_DESCRIPTOR  SecurityDescriptor;
  437.     UNICODE_STRING  Name;
  438. } SYSTEM_OBJECT_INFORMATION, *PSYSTEM_OBJECT_INFORMATION;
  439.  
  440. typedef struct _SYSTEM_PAGEFILE_INFORMATION {
  441.     ULONG  NextEntryOffset;
  442.     ULONG  CurrentSize;
  443.     ULONG  TotalUsed;
  444.     ULONG  PeakUsed;
  445.     UNICODE_STRING  FileName;
  446. } SYSTEM_PAGEFILE_INFORMATION, *PSYSTEM_PAGEFILE_INFORMATION;
  447.  
  448. typedef struct _SYSTEM_INSTRUCTION_EMULATION_INFORMATION {
  449.     ULONG  SegmentNotPresent;
  450.     ULONG  TwoByteOpcode;
  451.     ULONG  ESprefix;
  452.     ULONG  CSprefix;
  453.     ULONG  SSprefix;
  454.     ULONG  DSprefix;
  455.     ULONG  FSPrefix;
  456.     ULONG  GSprefix;
  457.     ULONG  OPER32prefix;
  458.     ULONG  ADDR32prefix;
  459.     ULONG  INSB;
  460.     ULONG  INSW;
  461.     ULONG  OUTSB;
  462.     ULONG  OUTSW;
  463.     ULONG  PUSHFD;
  464.     ULONG  POPFD;
  465.     ULONG  INTnn;
  466.     ULONG  INTO;
  467.     ULONG  IRETD;
  468.     ULONG  INBimm;
  469.     ULONG  INWimm;
  470.     ULONG  OUTBimm;
  471.     ULONG  OUTWimm;
  472.     ULONG  INB;
  473.     ULONG  INW;
  474.     ULONG  OUTB;
  475.     ULONG  OUTW;
  476.     ULONG  LOCKprefix;
  477.     ULONG  REPNEprefix;
  478.     ULONG  REPprefix;
  479.     ULONG  HLT;
  480.     ULONG  CLI;
  481.     ULONG  STI;
  482.     ULONG  GenericInvalidOpcode;
  483. } SYSTEM_INSTRUCTION_EMULATION_INFORMATION, *PSYSTEM_INSTRUCTION_EMULATION_INFORMATION;
  484.  
  485. typedef struct _SYSTEM_POOL_TAG_INFORMATION {
  486.     CHAR  Tag[4];
  487.     ULONG  PagedPoolAllocs;
  488.     ULONG  PagedPoolFrees;
  489.     ULONG  PagedPoolUsage;
  490.     ULONG  NonPagedPoolAllocs;
  491.     ULONG  NonPagedPoolFrees;
  492.     ULONG  NonPagedPoolUsage;
  493. } SYSTEM_POOL_TAG_INFORMATION, *PSYSTEM_POOL_TAG_INFORMATION;
  494.  
  495. typedef struct _SYSTEM_PROCESSOR_STATISTICS {
  496.     ULONG  ContextSwitches;
  497.     ULONG  DpcCount;
  498.     ULONG  DpcRequestRate;
  499.     ULONG  TimeIncrement;
  500.     ULONG  DpcBypassCount;
  501.     ULONG  ApcBypassCount;
  502. } SYSTEM_PROCESSOR_STATISTICS, *PSYSTEM_PROCESSOR_STATISTICS;
  503.  
  504. typedef struct _SYSTEM_DPC_INFORMATION {
  505.     ULONG  Reserved;
  506.     ULONG  MaximumDpcQueueDepth;
  507.     ULONG  MinimumDpcRate;
  508.     ULONG  AdjustDpcThreshold;
  509.     ULONG  IdealDpcRate;
  510. } SYSTEM_DPC_INFORMATION, *PSYSTEM_DPC_INFORMATION;
  511.  
  512. typedef struct _SYSTEM_LOAD_IMAGE {
  513.     UNICODE_STRING  ModuleName;
  514.     PVOID  ModuleBase;
  515.     PVOID  SectionPointer;
  516.     PVOID  EntryPoint;
  517.     PVOID  ExportDirectory;
  518. } SYSTEM_LOAD_IMAGE, *PSYSTEM_LOAD_IMAGE;
  519.  
  520. typedef struct _SYSTEM_UNLOAD_IMAGE {
  521.   PVOID  ModuleBase;
  522. } SYSTEM_UNLOAD_IMAGE, *PSYSTEM_UNLOAD_IMAGE;
  523.  
  524. typedef struct _SYSTEM_QUERY_TIME_ADJUSTMENT {
  525.     ULONG  TimeAdjustment;
  526.     ULONG  MaximumIncrement;
  527.     BOOLEAN  TimeSynchronization;
  528. } SYSTEM_QUERY_TIME_ADJUSTMENT, *PSYSTEM_QUERY_TIME_ADJUSTMENT;
  529.  
  530. typedef struct _SYSTEM_SET_TIME_ADJUSTMENT {
  531.     ULONG  TimeAdjustment;
  532.     BOOLEAN  TimeSynchronization;
  533. } SYSTEM_SET_TIME_ADJUSTMENT, *PSYSTEM_SET_TIME_ADJUSTMENT;
  534.  
  535. typedef struct _SYSTEM_CRASH_DUMP_INFORMATION {
  536.     HANDLE  CrashDumpSectionHandle;
  537.     HANDLE  Unknown;
  538. } SYSTEM_CRASH_DUMP_INFORMATION, *PSYSTEM_CRASH_DUMP_INFORMATION;
  539.  
  540. typedef struct _SYSTEM_EXCEPTION_INFORMATION {
  541.     ULONG  AlignmentFixupCount;
  542.     ULONG  ExceptionDispatchCount;
  543.     ULONG  FloatingEmulationCount;
  544.     ULONG  Reserved;
  545. } SYSTEM_EXCEPTION_INFORMATION, *PSYSTEM_EXCEPTION_INFORMATION;
  546.  
  547. typedef struct _SYSTEM_CRASH_DUMP_STATE_INFORMATION {
  548.     ULONG  CrashDumpSectionExists;
  549.     ULONG  Unknown;
  550. } SYSTEM_CRASH_DUMP_STATE_INFORMATION, *PSYSTEM_CRASH_DUMP_STATE_INFORMATION;
  551.  
  552. typedef struct _SYSTEM_KERNEL_DEBUGGER_INFORMATION {
  553.     BOOLEAN  DebuggerEnabled;
  554.     BOOLEAN  DebuggerNotPresent;
  555. } SYSTEM_KERNEL_DEBUGGER_INFORMATION, *PSYSTEM_KERNEL_DEBUGGER_INFORMATION;
  556.  
  557. typedef struct _SYSTEM_CONTEXT_SWITCH_INFORMATION {
  558.     ULONG  ContextSwitches;
  559.     ULONG  ContextSwitchCounters[11];
  560. } SYSTEM_CONTEXT_SWITCH_INFORMATION, *PSYSTEM_CONTEXT_SWITCH_INFORMATION;
  561.  
  562. typedef struct _SYSTEM_REGISTRY_QUOTA_INFORMATION {
  563.     ULONG  RegistryQuota;
  564.     ULONG  RegistryQuotaInUse;
  565.     ULONG  PagedPoolSize;
  566. } SYSTEM_REGISTRY_QUOTA_INFORMATION, *PSYSTEM_REGISTRY_QUOTA_INFORMATION;
  567.  
  568. typedef struct _SYSTEM_LOAD_AND_CALL_IMAGE {
  569.   UNICODE_STRING  ModuleName;
  570. } SYSTEM_LOAD_AND_CALL_IMAGE, *PSYSTEM_LOAD_AND_CALL_IMAGE;
  571.  
  572. typedef struct _SYSTEM_PRIORITY_SEPARATION {
  573.   ULONG  PrioritySeparation;
  574. } SYSTEM_PRIORITY_SEPARATION, *PSYSTEM_PRIORITY_SEPARATION;
  575.  
  576. typedef struct _SYSTEM_TIME_ZONE_INFORMATION {
  577.     LONG  Bias;
  578.     WCHAR  StandardName[32];
  579.     LARGE_INTEGER  StandardDate;
  580.     LONG  StandardBias;
  581.     WCHAR  DaylightName[32];
  582.     LARGE_INTEGER  DaylightDate;
  583.     LONG  DaylightBias;
  584. } SYSTEM_TIME_ZONE_INFORMATION, *PSYSTEM_TIME_ZONE_INFORMATION;
  585.  
  586. typedef struct _SYSTEM_LOOKASIDE_INFORMATION {
  587.     USHORT  Depth;
  588.     USHORT  MaximumDepth;
  589.     ULONG  TotalAllocates;
  590.     ULONG  AllocateMisses;
  591.     ULONG  TotalFrees;
  592.     ULONG  FreeMisses;
  593.     POOL_TYPE  Type;
  594.     ULONG  Tag;
  595.     ULONG  Size;
  596. } SYSTEM_LOOKASIDE_INFORMATION, *PSYSTEM_LOOKASIDE_INFORMATION;
  597.  
  598. typedef struct _SYSTEM_SET_TIME_SLIP_EVENT {
  599.   HANDLE  TimeSlipEvent;
  600. } SYSTEM_SET_TIME_SLIP_EVENT, *PSYSTEM_SET_TIME_SLIP_EVENT;
  601.  
  602. typedef struct _SYSTEM_CREATE_SESSION {
  603.   ULONG  SessionId;
  604. } SYSTEM_CREATE_SESSION, *PSYSTEM_CREATE_SESSION;
  605.  
  606. typedef struct _SYSTEM_DELETE_SESSION {
  607.   ULONG  SessionId;
  608. } SYSTEM_DELETE_SESSION, *PSYSTEM_DELETE_SESSION;
  609.  
  610. typedef struct _SYSTEM_RANGE_START_INFORMATION {
  611.   PVOID  SystemRangeStart;
  612. } SYSTEM_RANGE_START_INFORMATION, *PSYSTEM_RANGE_START_INFORMATION;
  613.  
  614. typedef struct _SYSTEM_SESSION_PROCESSES_INFORMATION {
  615.     ULONG  SessionId;
  616.     ULONG  BufferSize;
  617.     PVOID  Buffer;
  618. } SYSTEM_SESSION_PROCESSES_INFORMATION, *PSYSTEM_SESSION_PROCESSES_INFORMATION;
  619.  
  620. typedef struct _SYSTEM_POOL_BLOCK {
  621.     BOOLEAN  Allocated;
  622.     USHORT  Unknown;
  623.     ULONG  Size;
  624.     CHAR  Tag[4];
  625. } SYSTEM_POOL_BLOCK, *PSYSTEM_POOL_BLOCK;
  626.  
  627. typedef struct _SYSTEM_POOL_BLOCKS_INFORMATION {
  628.     ULONG  PoolSize;
  629.     PVOID  PoolBase;
  630.     USHORT  Unknown;
  631.     ULONG  NumberOfBlocks;
  632.     SYSTEM_POOL_BLOCK  PoolBlocks[1];
  633. } SYSTEM_POOL_BLOCKS_INFORMATION, *PSYSTEM_POOL_BLOCKS_INFORMATION;
  634.  
  635. typedef struct _SYSTEM_MEMORY_USAGE {
  636.     PVOID  Name;
  637.     USHORT  Valid;
  638.     USHORT  Standby;
  639.     USHORT  Modified;
  640.     USHORT  PageTables;
  641. } SYSTEM_MEMORY_USAGE, *PSYSTEM_MEMORY_USAGE;
  642.  
  643. typedef struct _SYSTEM_MEMORY_USAGE_INFORMATION {
  644.   ULONG  Reserved;
  645.     PVOID  EndOfData;
  646.     SYSTEM_MEMORY_USAGE  MemoryUsage[1];
  647. } SYSTEM_MEMORY_USAGE_INFORMATION, *PSYSTEM_MEMORY_USAGE_INFORMATION;
  648.  
  649. NTOSAPI
  650. NTSTATUS
  651. NTAPI
  652. NtQuerySystemInformation(
  653.   IN SYSTEM_INFORMATION_CLASS  SystemInformationClass,
  654.   IN OUT PVOID  SystemInformation,
  655.   IN ULONG  SystemInformationLength,
  656.   OUT PULONG  ReturnLength  OPTIONAL);
  657.  
  658. NTOSAPI
  659. NTSTATUS
  660. NTAPI
  661. ZwQuerySystemInformation(
  662.   IN SYSTEM_INFORMATION_CLASS  SystemInformationClass,
  663.   IN OUT PVOID  SystemInformation,
  664.   IN ULONG  SystemInformationLength,
  665.   OUT PULONG  ReturnLength  OPTIONAL);
  666.  
  667. NTOSAPI
  668. NTSTATUS
  669. NTAPI
  670. ZwSetSystemInformation(
  671.     IN SYSTEM_INFORMATION_CLASS  SystemInformationClass,
  672.     IN OUT PVOID  SystemInformation,
  673.     IN ULONG  SystemInformationLength);
  674.  
  675. NTOSAPI
  676. NTSTATUS
  677. NTAPI
  678. ZwQuerySystemEnvironmentValue(
  679.     IN PUNICODE_STRING  Name,
  680.     OUT PVOID  Value,
  681.     IN ULONG  ValueLength,
  682.     OUT PULONG  ReturnLength  OPTIONAL);
  683.  
  684. NTOSAPI
  685. NTSTATUS
  686. NTAPI
  687. ZwSetSystemEnvironmentValue(
  688.     IN PUNICODE_STRING  Name,
  689.     IN PUNICODE_STRING  Value);
  690.  
  691. typedef enum _SHUTDOWN_ACTION {
  692.     ShutdownNoReboot,
  693.     ShutdownReboot,
  694.     ShutdownPowerOff
  695. } SHUTDOWN_ACTION;
  696.  
  697. NTOSAPI
  698. NTSTATUS
  699. NTAPI
  700. NtShutdownSystem(
  701.   IN SHUTDOWN_ACTION  Action);
  702.  
  703. typedef enum _DEBUG_CONTROL_CODE {
  704.   DebugGetTraceInformation = 1,
  705.     DebugSetInternalBreakpoint,
  706.     DebugSetSpecialCall,
  707.     DebugClearSpecialCalls,
  708.     DebugQuerySpecialCalls,
  709.     DebugDbgBreakPoint,
  710.     DebugMaximum
  711. } DEBUG_CONTROL_CODE;
  712.  
  713.  
  714. NTOSAPI
  715. NTSTATUS
  716. NTAPI
  717. ZwSystemDebugControl(
  718.     IN DEBUG_CONTROL_CODE  ControlCode,
  719.     IN PVOID  InputBuffer  OPTIONAL,
  720.     IN ULONG  InputBufferLength,
  721.     OUT PVOID  OutputBuffer  OPTIONAL,
  722.     IN ULONG  OutputBufferLength,
  723.     OUT PULONG  ReturnLength  OPTIONAL);
  724.  
  725.  
  726.  
  727. /* Objects, Object directories, and symbolic links */
  728.  
  729. typedef enum _OBJECT_INFORMATION_CLASS {
  730.     ObjectBasicInformation,
  731.     ObjectNameInformation,
  732.     ObjectTypeInformation,
  733.     ObjectAllTypesInformation,
  734.     ObjectHandleInformation
  735. } OBJECT_INFORMATION_CLASS;
  736.  
  737. NTOSAPI
  738. NTSTATUS
  739. NTAPI
  740. ZwQueryObject(
  741.     IN HANDLE  ObjectHandle,
  742.     IN OBJECT_INFORMATION_CLASS  ObjectInformationClass,
  743.     OUT PVOID  ObjectInformation,
  744.     IN ULONG  ObjectInformationLength,
  745.     OUT PULONG  ReturnLength  OPTIONAL);
  746.  
  747. NTOSAPI
  748. NTSTATUS
  749. NTAPI
  750. ZwSetInformationObject(
  751.     IN HANDLE  ObjectHandle,
  752.     IN OBJECT_INFORMATION_CLASS  ObjectInformationClass,
  753.     IN PVOID  ObjectInformation,
  754.     IN ULONG  ObjectInformationLength);
  755.  
  756. /* OBJECT_BASIC_INFORMATION.Attributes constants */
  757. #define HANDLE_FLAG_INHERIT               0x01
  758. #define HANDLE_FLAG_PROTECT_FROM_CLOSE    0x02
  759. #define PERMANENT                         0x10
  760. #define EXCLUSIVE                         0x20
  761.  
  762. typedef struct _OBJECT_BASIC_INFORMATION {
  763.     ULONG  Attributes;
  764.     ACCESS_MASK  GrantedAccess;
  765.     ULONG  HandleCount;
  766.     ULONG  PointerCount;
  767.     ULONG  PagedPoolUsage;
  768.     ULONG  NonPagedPoolUsage;
  769.     ULONG  Reserved[3];
  770.     ULONG  NameInformationLength;
  771.     ULONG  TypeInformationLength;
  772.     ULONG  SecurityDescriptorLength;
  773.     LARGE_INTEGER  CreateTime;
  774. } OBJECT_BASIC_INFORMATION, *POBJECT_BASIC_INFORMATION;
  775. #if 0
  776. // FIXME: Enable later
  777. typedef struct _OBJECT_TYPE_INFORMATION {
  778.     UNICODE_STRING  Name;
  779.     ULONG  ObjectCount;
  780.     ULONG  HandleCount;
  781.     ULONG  Reserved1[4];
  782.     ULONG  PeakObjectCount;
  783.     ULONG  PeakHandleCount;
  784.     ULONG  Reserved2[4];
  785.     ULONG  InvalidAttributes;
  786.     GENERIC_MAPPING  GenericMapping;
  787.     ULONG  ValidAccess;
  788.     UCHAR  Unknown;
  789.     BOOLEAN  MaintainHandleDatabase;
  790.     POOL_TYPE  PoolType;
  791.     ULONG  PagedPoolUsage;
  792.     ULONG  NonPagedPoolUsage;
  793. } OBJECT_TYPE_INFORMATION, *POBJECT_TYPE_INFORMATION;
  794.  
  795. typedef struct _OBJECT_ALL_TYPES_INFORMATION {
  796.   ULONG  NumberOfTypes;
  797.   OBJECT_TYPE_INFORMATION  TypeInformation;
  798. } OBJECT_ALL_TYPES_INFORMATION, *POBJECT_ALL_TYPES_INFORMATION;
  799. #endif
  800. typedef struct _OBJECT_HANDLE_ATTRIBUTE_INFORMATION {
  801.   BOOLEAN  Inherit;
  802.   BOOLEAN  ProtectFromClose;
  803. } OBJECT_HANDLE_ATTRIBUTE_INFORMATION, *POBJECT_HANDLE_ATTRIBUTE_INFORMATION;
  804.  
  805. NTOSAPI
  806. NTSTATUS
  807. NTAPI
  808. NtDuplicateObject(
  809.   IN HANDLE  SourceProcessHandle,
  810.   IN HANDLE  SourceHandle,
  811.   IN HANDLE  TargetProcessHandle,
  812.   OUT PHANDLE  TargetHandle  OPTIONAL,
  813.   IN ACCESS_MASK  DesiredAccess,
  814.   IN ULONG  Attributes,
  815.   IN ULONG  Options);
  816.  
  817. NTOSAPI
  818. NTSTATUS
  819. NTAPI
  820. ZwDuplicateObject(
  821.   IN HANDLE  SourceProcessHandle,
  822.   IN HANDLE  SourceHandle,
  823.   IN HANDLE  TargetProcessHandle,
  824.   OUT PHANDLE  TargetHandle  OPTIONAL,
  825.   IN ACCESS_MASK  DesiredAccess,
  826.   IN ULONG  Attributes,
  827.   IN ULONG  Options);
  828.  
  829. NTOSAPI
  830. NTSTATUS
  831. NTAPI
  832. NtQuerySecurityObject(
  833.   IN HANDLE Handle,
  834.   IN SECURITY_INFORMATION  SecurityInformation,
  835.   OUT PSECURITY_DESCRIPTOR  SecurityDescriptor,
  836.   IN ULONG  SecurityDescriptorLength,
  837.   OUT PULONG  ReturnLength);
  838.  
  839. NTOSAPI
  840. NTSTATUS
  841. NTAPI
  842. ZwQuerySecurityObject(
  843.   IN HANDLE Handle,
  844.   IN SECURITY_INFORMATION  SecurityInformation,
  845.   OUT PSECURITY_DESCRIPTOR  SecurityDescriptor,
  846.   IN ULONG  SecurityDescriptorLength,
  847.   OUT PULONG  ReturnLength);
  848.  
  849. NTOSAPI
  850. NTSTATUS
  851. NTAPI
  852. NtSetSecurityObject(
  853.   IN HANDLE  Handle,
  854.   IN SECURITY_INFORMATION  SecurityInformation,
  855.   IN PSECURITY_DESCRIPTOR  SecurityDescriptor);
  856.  
  857. NTOSAPI
  858. NTSTATUS
  859. NTAPI
  860. ZwSetSecurityObject(
  861.   IN HANDLE  Handle,
  862.   IN SECURITY_INFORMATION  SecurityInformation,
  863.   IN PSECURITY_DESCRIPTOR  SecurityDescriptor);
  864.  
  865. NTOSAPI
  866. NTSTATUS
  867. NTAPI
  868. ZwOpenDirectoryObject(
  869.   OUT PHANDLE  DirectoryHandle,
  870.   IN ACCESS_MASK  DesiredAccess,
  871.   IN POBJECT_ATTRIBUTES  ObjectAttributes);
  872.  
  873. NTOSAPI
  874. NTSTATUS
  875. NTAPI
  876. ZwQueryDirectoryObject(
  877.   IN HANDLE  DirectoryHandle,
  878.   OUT PVOID  Buffer,
  879.   IN ULONG  BufferLength,
  880.   IN BOOLEAN  ReturnSingleEntry,
  881.   IN BOOLEAN  RestartScan,
  882.   IN OUT PULONG  Context,
  883.   OUT PULONG  ReturnLength  OPTIONAL);
  884.  
  885. typedef struct _DIRECTORY_BASIC_INFORMATION {
  886.   UNICODE_STRING  ObjectName;
  887.   UNICODE_STRING  ObjectTypeName;
  888. } DIRECTORY_BASIC_INFORMATION, *PDIRECTORY_BASIC_INFORMATION;
  889.  
  890. NTOSAPI
  891. NTSTATUS
  892. NTAPI
  893. ZwCreateSymbolicLinkObject(
  894.   OUT PHANDLE  SymbolicLinkHandle,
  895.   IN ACCESS_MASK  DesiredAccess,
  896.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  897.   IN PUNICODE_STRING  TargetName);
  898.  
  899.  
  900.  
  901.  
  902. /* Virtual memory */
  903.  
  904. typedef enum _MEMORY_INFORMATION_CLASS {
  905. MemoryBasicInformation,
  906. MemoryWorkingSetList,
  907. MemorySectionName,
  908. MemoryBasicVlmInformation
  909. } MEMORY_INFORMATION_CLASS;
  910.  
  911. NTOSAPI
  912. NTSTATUS
  913. NTAPI
  914. NtAllocateVirtualMemory(
  915.   IN HANDLE  ProcessHandle,
  916.   IN OUT PVOID  *BaseAddress,
  917.   IN ULONG  ZeroBits,
  918.   IN OUT PULONG  AllocationSize,
  919.   IN ULONG  AllocationType,
  920.   IN ULONG  Protect);
  921.  
  922. NTOSAPI
  923. NTSTATUS
  924. NTAPI
  925. ZwAllocateVirtualMemory(
  926.   IN HANDLE  ProcessHandle,
  927.   IN OUT PVOID  *BaseAddress,
  928.   IN ULONG  ZeroBits,
  929.   IN OUT PULONG  AllocationSize,
  930.   IN ULONG  AllocationType,
  931.   IN ULONG  Protect);
  932.  
  933. NTOSAPI
  934. NTSTATUS
  935. NTAPI
  936. NtFreeVirtualMemory(
  937.   IN HANDLE  ProcessHandle,
  938.   IN OUT PVOID  *BaseAddress,
  939.   IN OUT PULONG  FreeSize,
  940.   IN ULONG  FreeType);
  941.  
  942. NTOSAPI
  943. NTSTATUS
  944. NTAPI
  945. ZwFreeVirtualMemory(
  946.   IN HANDLE  ProcessHandle,
  947.   IN OUT PVOID  *BaseAddress,
  948.   IN OUT PULONG  FreeSize,
  949.   IN ULONG  FreeType);
  950.  
  951. NTOSAPI
  952. NTSTATUS
  953. NTAPI
  954. ZwQueryVirtualMemory(
  955.     IN HANDLE  ProcessHandle,
  956.     IN PVOID  BaseAddress,
  957.     IN MEMORY_INFORMATION_CLASS  MemoryInformationClass,
  958.     OUT PVOID  MemoryInformation,
  959.     IN ULONG  MemoryInformationLength,
  960.     OUT PULONG  ReturnLength  OPTIONAL);
  961.  
  962. /* MEMORY_WORKING_SET_LIST.WorkingSetList constants */
  963. #define WSLE_PAGE_READONLY                0x001
  964. #define WSLE_PAGE_EXECUTE                 0x002
  965. #define WSLE_PAGE_READWRITE               0x004
  966. #define WSLE_PAGE_EXECUTE_READ            0x003
  967. #define WSLE_PAGE_WRITECOPY               0x005
  968. #define WSLE_PAGE_EXECUTE_READWRITE       0x006
  969. #define WSLE_PAGE_EXECUTE_WRITECOPY       0x007
  970. #define WSLE_PAGE_SHARE_COUNT_MASK        0x0E0
  971. #define WSLE_PAGE_SHAREABLE               0x100
  972.  
  973. typedef struct _MEMORY_WORKING_SET_LIST {
  974.   ULONG  NumberOfPages;
  975.   ULONG  WorkingSetList[1];
  976. } MEMORY_WORKING_SET_LIST, *PMEMORY_WORKING_SET_LIST;
  977.  
  978. typedef struct _MEMORY_SECTION_NAME {
  979.   UNICODE_STRING  SectionFileName;
  980. } MEMORY_SECTION_NAME, *PMEMORY_SECTION_NAME;
  981.  
  982. /* Zw[Lock|Unlock]VirtualMemory.LockType constants */
  983. #define LOCK_VM_IN_WSL                    0x01
  984. #define LOCK_VM_IN_RAM                    0x02
  985.  
  986. NTOSAPI
  987. NTSTATUS
  988. NTAPI
  989. ZwLockVirtualMemory(
  990.     IN HANDLE  ProcessHandle,
  991.     IN OUT PVOID  *BaseAddress,
  992.     IN OUT PULONG  LockSize,
  993.     IN ULONG  LockType);
  994.  
  995. NTOSAPI
  996. NTSTATUS
  997. NTAPI
  998. ZwUnlockVirtualMemory(
  999.     IN HANDLE  ProcessHandle,
  1000.     IN OUT PVOID  *BaseAddress,
  1001.     IN OUT PULONG  LockSize,
  1002.     IN ULONG  LockType);
  1003.  
  1004. NTOSAPI
  1005. NTSTATUS
  1006. NTAPI
  1007. ZwReadVirtualMemory(
  1008.     IN HANDLE  ProcessHandle,
  1009.     IN PVOID  BaseAddress,
  1010.     OUT PVOID  Buffer,
  1011.     IN ULONG  BufferLength,
  1012.     OUT PULONG  ReturnLength  OPTIONAL);
  1013.  
  1014. NTOSAPI
  1015. NTSTATUS
  1016. NTAPI
  1017. ZwWriteVirtualMemory(
  1018.     IN HANDLE  ProcessHandle,
  1019.     IN PVOID  BaseAddress,
  1020.     IN PVOID  Buffer,
  1021.     IN ULONG  BufferLength,
  1022.     OUT PULONG  ReturnLength  OPTIONAL);
  1023.  
  1024. NTOSAPI
  1025. NTSTATUS
  1026. NTAPI
  1027. ZwProtectVirtualMemory(
  1028.     IN HANDLE  ProcessHandle,
  1029.     IN OUT PVOID  *BaseAddress,
  1030.     IN OUT PULONG  ProtectSize,
  1031.     IN ULONG  NewProtect,
  1032.     OUT PULONG  OldProtect);
  1033.  
  1034. NTOSAPI
  1035. NTSTATUS
  1036. NTAPI
  1037. ZwFlushVirtualMemory(
  1038.     IN HANDLE  ProcessHandle,
  1039.     IN OUT PVOID  *BaseAddress,
  1040.     IN OUT PULONG  FlushSize,
  1041.     OUT PIO_STATUS_BLOCK  IoStatusBlock);
  1042.  
  1043. NTOSAPI
  1044. NTSTATUS
  1045. NTAPI
  1046. ZwAllocateUserPhysicalPages(
  1047.     IN HANDLE  ProcessHandle,
  1048.     IN PULONG  NumberOfPages,
  1049.     OUT PULONG  PageFrameNumbers);
  1050.  
  1051. NTOSAPI
  1052. NTSTATUS
  1053. NTAPI
  1054. ZwFreeUserPhysicalPages(
  1055.     IN HANDLE  ProcessHandle,
  1056.     IN OUT PULONG  NumberOfPages,
  1057.     IN PULONG  PageFrameNumbers);
  1058.  
  1059. NTOSAPI
  1060. NTSTATUS
  1061. NTAPI
  1062. ZwMapUserPhysicalPages(
  1063.     IN PVOID  BaseAddress,
  1064.     IN PULONG  NumberOfPages,
  1065.     IN PULONG  PageFrameNumbers);
  1066.  
  1067. NTOSAPI
  1068. NTSTATUS
  1069. NTAPI
  1070. ZwMapUserPhysicalPagesScatter(
  1071.     IN PVOID  *BaseAddresses,
  1072.     IN PULONG  NumberOfPages,
  1073.     IN PULONG  PageFrameNumbers);
  1074.  
  1075. NTOSAPI
  1076. NTSTATUS
  1077. NTAPI
  1078. ZwGetWriteWatch(
  1079.     IN HANDLE  ProcessHandle,
  1080.     IN ULONG  Flags,
  1081.     IN PVOID  BaseAddress,
  1082.     IN ULONG  RegionSize,
  1083.     OUT PULONG  Buffer,
  1084.     IN OUT PULONG  BufferEntries,
  1085.     OUT PULONG  Granularity);
  1086.  
  1087. NTOSAPI
  1088. NTSTATUS
  1089. NTAPI
  1090. ZwResetWriteWatch(
  1091.     IN HANDLE  ProcessHandle,
  1092.     IN PVOID  BaseAddress,
  1093.     IN ULONG  RegionSize);
  1094.  
  1095.  
  1096.  
  1097.  
  1098. /* Sections */
  1099.  
  1100. typedef enum _SECTION_INFORMATION_CLASS {
  1101.   SectionBasicInformation,
  1102.   SectionImageInformation
  1103. } SECTION_INFORMATION_CLASS;
  1104.  
  1105. NTOSAPI
  1106. NTSTATUS
  1107. NTAPI
  1108. NtCreateSection(
  1109.   OUT PHANDLE  SectionHandle,
  1110.   IN ACCESS_MASK  DesiredAccess,
  1111.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1112.   IN PLARGE_INTEGER  SectionSize  OPTIONAL,
  1113.   IN ULONG  Protect,
  1114.   IN ULONG  Attributes,
  1115.   IN HANDLE  FileHandle);
  1116.  
  1117. NTOSAPI
  1118. NTSTATUS
  1119. NTAPI
  1120. ZwCreateSection(
  1121.   OUT PHANDLE  SectionHandle,
  1122.   IN ACCESS_MASK  DesiredAccess,
  1123.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1124.   IN PLARGE_INTEGER  SectionSize  OPTIONAL,
  1125.   IN ULONG  Protect,
  1126.   IN ULONG  Attributes,
  1127.   IN HANDLE  FileHandle);
  1128.  
  1129. NTOSAPI
  1130. NTSTATUS
  1131. NTAPI
  1132. ZwQuerySection(
  1133.     IN HANDLE  SectionHandle,
  1134.     IN SECTION_INFORMATION_CLASS  SectionInformationClass,
  1135.     OUT PVOID  SectionInformation,
  1136.     IN ULONG  SectionInformationLength,
  1137.   OUT PULONG  ResultLength  OPTIONAL);
  1138.  
  1139. NTOSAPI
  1140. NTSTATUS
  1141. NTAPI
  1142. ZwExtendSection(
  1143.     IN HANDLE  SectionHandle,
  1144.     IN PLARGE_INTEGER  SectionSize);
  1145.  
  1146. NTOSAPI
  1147. NTSTATUS
  1148. NTAPI
  1149. ZwAreMappedFilesTheSame(
  1150.     IN PVOID  Address1,
  1151.     IN PVOID  Address2);
  1152.  
  1153.  
  1154.  
  1155.  
  1156. /* Threads */
  1157.  
  1158. typedef struct _USER_STACK {
  1159.     PVOID  FixedStackBase;
  1160.     PVOID  FixedStackLimit;
  1161.     PVOID  ExpandableStackBase;
  1162.     PVOID  ExpandableStackLimit;
  1163.     PVOID  ExpandableStackBottom;
  1164. } USER_STACK, *PUSER_STACK;
  1165.  
  1166. NTOSAPI
  1167. NTSTATUS
  1168. NTAPI
  1169. ZwCreateThread(
  1170.     OUT PHANDLE  ThreadHandle,
  1171.     IN ACCESS_MASK  DesiredAccess,
  1172.     IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1173.     IN HANDLE  ProcessHandle,
  1174.     OUT PCLIENT_ID  ClientId,
  1175.     IN PCONTEXT  ThreadContext,
  1176.     IN PUSER_STACK  UserStack,
  1177.     IN BOOLEAN  CreateSuspended);
  1178.  
  1179. NTOSAPI
  1180. NTSTATUS
  1181. NTAPI
  1182. NtOpenThread(
  1183.   OUT PHANDLE  ThreadHandle,
  1184.   IN ACCESS_MASK  DesiredAccess,
  1185.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1186.   IN PCLIENT_ID  ClientId);
  1187.  
  1188. NTOSAPI
  1189. NTSTATUS
  1190. NTAPI
  1191. ZwOpenThread(
  1192.   OUT PHANDLE  ThreadHandle,
  1193.   IN ACCESS_MASK  DesiredAccess,
  1194.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1195.   IN PCLIENT_ID  ClientId);
  1196.  
  1197. NTOSAPI
  1198. NTSTATUS
  1199. NTAPI
  1200. ZwTerminateThread(
  1201.     IN HANDLE  ThreadHandle  OPTIONAL,
  1202.     IN NTSTATUS  ExitStatus);
  1203.  
  1204. NTOSAPI
  1205. NTSTATUS
  1206. NTAPI
  1207. NtQueryInformationThread(
  1208.   IN HANDLE  ThreadHandle,
  1209.   IN THREADINFOCLASS  ThreadInformationClass,
  1210.   OUT PVOID  ThreadInformation,
  1211.   IN ULONG  ThreadInformationLength,
  1212.   OUT PULONG  ReturnLength  OPTIONAL);
  1213.  
  1214. NTOSAPI
  1215. NTSTATUS
  1216. NTAPI
  1217. ZwQueryInformationThread(
  1218.   IN HANDLE  ThreadHandle,
  1219.   IN THREADINFOCLASS  ThreadInformationClass,
  1220.   OUT PVOID  ThreadInformation,
  1221.   IN ULONG  ThreadInformationLength,
  1222.   OUT PULONG  ReturnLength  OPTIONAL);
  1223.  
  1224. NTOSAPI
  1225. NTSTATUS
  1226. NTAPI
  1227. NtSetInformationThread(
  1228.   IN HANDLE  ThreadHandle,
  1229.   IN THREADINFOCLASS  ThreadInformationClass,
  1230.   IN PVOID  ThreadInformation,
  1231.   IN ULONG  ThreadInformationLength);
  1232.  
  1233. typedef struct _THREAD_BASIC_INFORMATION {
  1234.     NTSTATUS  ExitStatus;
  1235.     PNT_TIB  TebBaseAddress;
  1236.     CLIENT_ID  ClientId;
  1237.     KAFFINITY  AffinityMask;
  1238.     KPRIORITY  Priority;
  1239.     KPRIORITY  BasePriority;
  1240. } THREAD_BASIC_INFORMATION, *PTHREAD_BASIC_INFORMATION;
  1241.  
  1242. typedef struct _KERNEL_USER_TIMES {
  1243.     LARGE_INTEGER  CreateTime;
  1244.     LARGE_INTEGER  ExitTime;
  1245.     LARGE_INTEGER  KernelTime;
  1246.     LARGE_INTEGER  UserTime;
  1247. } KERNEL_USER_TIMES, *PKERNEL_USER_TIMES;
  1248.  
  1249. NTOSAPI
  1250. NTSTATUS
  1251. NTAPI
  1252. ZwSuspendThread(
  1253.   IN HANDLE  ThreadHandle,
  1254.   OUT PULONG  PreviousSuspendCount  OPTIONAL);
  1255.  
  1256. NTOSAPI
  1257. NTSTATUS
  1258. NTAPI
  1259. ZwResumeThread(
  1260.   IN HANDLE  ThreadHandle,
  1261.   OUT PULONG  PreviousSuspendCount  OPTIONAL);
  1262.  
  1263. NTOSAPI
  1264. NTSTATUS
  1265. NTAPI
  1266. ZwGetContextThread(
  1267.   IN HANDLE  ThreadHandle,
  1268.   OUT PCONTEXT  Context);
  1269.  
  1270. NTOSAPI
  1271. NTSTATUS
  1272. NTAPI
  1273. ZwSetContextThread(
  1274.     IN HANDLE  ThreadHandle,
  1275.     IN PCONTEXT  Context);
  1276.  
  1277. NTOSAPI
  1278. NTSTATUS
  1279. NTAPI
  1280. ZwQueueApcThread(
  1281.     IN HANDLE  ThreadHandle,
  1282.     IN PKNORMAL_ROUTINE  ApcRoutine,
  1283.     IN PVOID  ApcContext  OPTIONAL,
  1284.     IN PVOID  Argument1  OPTIONAL,
  1285.     IN PVOID  Argument2  OPTIONAL);
  1286.  
  1287. NTOSAPI
  1288. NTSTATUS
  1289. NTAPI
  1290. ZwTestAlert(
  1291.   VOID);
  1292.  
  1293. NTOSAPI
  1294. NTSTATUS
  1295. NTAPI
  1296. ZwAlertThread(
  1297.   IN HANDLE  ThreadHandle);
  1298.  
  1299. NTOSAPI
  1300. NTSTATUS
  1301. NTAPI
  1302. ZwAlertResumeThread(
  1303.   IN HANDLE  ThreadHandle,
  1304.   OUT PULONG  PreviousSuspendCount  OPTIONAL);
  1305.  
  1306. NTOSAPI
  1307. NTSTATUS
  1308. NTAPI
  1309. ZwRegisterThreadTerminatePort(
  1310.   IN HANDLE  PortHandle);
  1311.  
  1312. NTOSAPI
  1313. NTSTATUS
  1314. NTAPI
  1315. ZwImpersonateThread(
  1316.     IN HANDLE  ThreadHandle,
  1317.     IN HANDLE  TargetThreadHandle,
  1318.     IN PSECURITY_QUALITY_OF_SERVICE  SecurityQos);
  1319.  
  1320. NTOSAPI
  1321. NTSTATUS
  1322. NTAPI
  1323. ZwImpersonateAnonymousToken(
  1324.   IN HANDLE  ThreadHandle);
  1325.  
  1326.  
  1327.  
  1328.  
  1329. /* Processes */
  1330.  
  1331. NTOSAPI
  1332. NTSTATUS
  1333. NTAPI
  1334. ZwCreateProcess(
  1335.     OUT PHANDLE  ProcessHandle,
  1336.     IN ACCESS_MASK  DesiredAccess,
  1337.     IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1338.     IN HANDLE  InheritFromProcessHandle,
  1339.     IN BOOLEAN  InheritHandles,
  1340.     IN HANDLE  SectionHandle  OPTIONAL,
  1341.     IN HANDLE  DebugPort  OPTIONAL,
  1342.     IN HANDLE  ExceptionPort  OPTIONAL);
  1343.  
  1344. NTOSAPI
  1345. NTSTATUS
  1346. NTAPI
  1347. ZwCreateProcess(
  1348.     OUT PHANDLE  ProcessHandle,
  1349.     IN ACCESS_MASK  DesiredAccess,
  1350.     IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1351.     IN HANDLE  InheritFromProcessHandle,
  1352.     IN BOOLEAN  InheritHandles,
  1353.     IN HANDLE  SectionHandle  OPTIONAL,
  1354.     IN HANDLE  DebugPort  OPTIONAL,
  1355.     IN HANDLE  ExceptionPort  OPTIONAL);
  1356.  
  1357. NTOSAPI
  1358. NTSTATUS
  1359. NTAPI
  1360. ZwTerminateProcess(
  1361.     IN HANDLE  ProcessHandle  OPTIONAL,
  1362.     IN NTSTATUS  ExitStatus);
  1363.  
  1364. NTOSAPI
  1365. NTSTATUS
  1366. NTAPI
  1367. ZwQueryInformationProcess(
  1368.   IN HANDLE  ProcessHandle,
  1369.   IN PROCESSINFOCLASS  ProcessInformationClass,
  1370.   OUT PVOID  ProcessInformation,
  1371.   IN ULONG  ProcessInformationLength,
  1372.   OUT PULONG  ReturnLength  OPTIONAL);
  1373.  
  1374. NTOSAPI
  1375. NTSTATUS
  1376. NTAPI
  1377. NtSetInformationProcess(
  1378.   IN HANDLE  ProcessHandle,
  1379.   IN PROCESSINFOCLASS  ProcessInformationClass,
  1380.   IN PVOID  ProcessInformation,
  1381.   IN ULONG  ProcessInformationLength);
  1382.  
  1383. NTOSAPI
  1384. NTSTATUS
  1385. NTAPI
  1386. ZwSetInformationProcess(
  1387.   IN HANDLE  ProcessHandle,
  1388.   IN PROCESSINFOCLASS  ProcessInformationClass,
  1389.   IN PVOID  ProcessInformation,
  1390.   IN ULONG  ProcessInformationLength);
  1391.  
  1392. typedef struct _PROCESS_BASIC_INFORMATION {
  1393.     NTSTATUS  ExitStatus;
  1394.     PPEB  PebBaseAddress;
  1395.     KAFFINITY  AffinityMask;
  1396.     KPRIORITY  BasePriority;
  1397.     ULONG  UniqueProcessId;
  1398.     ULONG  InheritedFromUniqueProcessId;
  1399. } PROCESS_BASIC_INFORMATION, *PPROCESS_BASIC_INFORMATION;
  1400.  
  1401. typedef struct _PROCESS_ACCESS_TOKEN {
  1402.   HANDLE  Token;
  1403.   HANDLE  Thread;
  1404. } PROCESS_ACCESS_TOKEN, *PPROCESS_ACCESS_TOKEN;
  1405.  
  1406. /* DefaultHardErrorMode constants */
  1407. #define SEM_FAILCRITICALERRORS            0x0001
  1408. #define SEM_NOGPFAULTERRORBOX             0x0002
  1409. #define SEM_NOALIGNMENTFAULTEXCEPT        0x0004
  1410. #define SEM_NOOPENFILEERRORBOX            0x8000
  1411.  
  1412. typedef struct _POOLED_USAGE_AND_LIMITS {
  1413.     ULONG  PeakPagedPoolUsage;
  1414.     ULONG  PagedPoolUsage;
  1415.     ULONG  PagedPoolLimit;
  1416.     ULONG  PeakNonPagedPoolUsage;
  1417.     ULONG  NonPagedPoolUsage;
  1418.     ULONG  NonPagedPoolLimit;
  1419.     ULONG  PeakPagefileUsage;
  1420.     ULONG  PagefileUsage;
  1421.     ULONG  PagefileLimit;
  1422. } POOLED_USAGE_AND_LIMITS, *PPOOLED_USAGE_AND_LIMITS;
  1423.  
  1424. typedef struct _PROCESS_WS_WATCH_INFORMATION {
  1425.   PVOID  FaultingPc;
  1426.   PVOID  FaultingVa;
  1427. } PROCESS_WS_WATCH_INFORMATION, *PPROCESS_WS_WATCH_INFORMATION;
  1428.  
  1429. /* PROCESS_PRIORITY_CLASS.PriorityClass constants */
  1430. #define PC_IDLE                           1
  1431. #define PC_NORMAL                         2
  1432. #define PC_HIGH                           3
  1433. #define PC_REALTIME                       4
  1434. #define PC_BELOW_NORMAL                   5
  1435. #define PC_ABOVE_NORMAL                   6
  1436.  
  1437. typedef struct _PROCESS_PRIORITY_CLASS {
  1438.   BOOLEAN  Foreground;
  1439.   UCHAR  PriorityClass;
  1440. } PROCESS_PRIORITY_CLASS, *PPROCESS_PRIORITY_CLASS;
  1441.  
  1442. /* PROCESS_DEVICEMAP_INFORMATION.DriveType constants */
  1443. #define DRIVE_UNKNOWN                     0
  1444. #define DRIVE_NO_ROOT_DIR                 1
  1445. #define DRIVE_REMOVABLE                   2
  1446. #define DRIVE_FIXED                       3
  1447. #define DRIVE_REMOTE                      4
  1448. #define DRIVE_CDROM                       5
  1449. #define DRIVE_RAMDISK                     6
  1450.  
  1451. typedef struct _PROCESS_DEVICEMAP_INFORMATION {
  1452.     union {
  1453.         struct {
  1454.           HANDLE  DirectoryHandle;
  1455.         } Set;
  1456.         struct {
  1457.           ULONG  DriveMap;
  1458.           UCHAR  DriveType[32];
  1459.         } Query;
  1460.     };
  1461. } PROCESS_DEVICEMAP_INFORMATION, *PPROCESS_DEVICEMAP_INFORMATION;
  1462.  
  1463. typedef struct _PROCESS_SESSION_INFORMATION {
  1464.   ULONG  SessionId;
  1465. } PROCESS_SESSION_INFORMATION, *PPROCESS_SESSION_INFORMATION;
  1466.  
  1467. typedef struct _RTL_USER_PROCESS_PARAMETERS {
  1468.     ULONG  AllocationSize;
  1469.     ULONG  Size;
  1470.     ULONG  Flags;
  1471.     ULONG  DebugFlags;
  1472.     HANDLE  hConsole;
  1473.     ULONG  ProcessGroup;
  1474.     HANDLE  hStdInput;
  1475.     HANDLE  hStdOutput;
  1476.     HANDLE  hStdError;
  1477.     UNICODE_STRING  CurrentDirectoryName;
  1478.     HANDLE  CurrentDirectoryHandle;
  1479.     UNICODE_STRING  DllPath;
  1480.     UNICODE_STRING  ImagePathName;
  1481.     UNICODE_STRING  CommandLine;
  1482.     PWSTR  Environment;
  1483.     ULONG  dwX;
  1484.     ULONG  dwY;
  1485.     ULONG  dwXSize;
  1486.     ULONG  dwYSize;
  1487.     ULONG  dwXCountChars;
  1488.     ULONG  dwYCountChars;
  1489.     ULONG  dwFillAttribute;
  1490.     ULONG  dwFlags;
  1491.     ULONG  wShowWindow;
  1492.     UNICODE_STRING  WindowTitle;
  1493.     UNICODE_STRING  DesktopInfo;
  1494.     UNICODE_STRING  ShellInfo;
  1495.     UNICODE_STRING  RuntimeInfo;
  1496. } RTL_USER_PROCESS_PARAMETERS, *PRTL_USER_PROCESS_PARAMETERS;
  1497.  
  1498. NTSTATUS
  1499. NTAPI
  1500. RtlCreateProcessParameters(
  1501.     OUT PRTL_USER_PROCESS_PARAMETERS  *ProcessParameters,
  1502.     IN PUNICODE_STRING  ImageFile,
  1503.     IN PUNICODE_STRING  DllPath  OPTIONAL,
  1504.     IN PUNICODE_STRING  CurrentDirectory  OPTIONAL,
  1505.     IN PUNICODE_STRING  CommandLine  OPTIONAL,
  1506.     IN PWSTR  Environment OPTIONAL,
  1507.     IN PUNICODE_STRING  WindowTitle  OPTIONAL,
  1508.     IN PUNICODE_STRING  DesktopInfo  OPTIONAL,
  1509.     IN PUNICODE_STRING  ShellInfo  OPTIONAL,
  1510.     IN PUNICODE_STRING  RuntimeInfo  OPTIONAL);
  1511.  
  1512. NTSTATUS
  1513. NTAPI
  1514. RtlDestroyProcessParameters(
  1515.   IN PRTL_USER_PROCESS_PARAMETERS  ProcessParameters);
  1516.  
  1517. typedef struct _DEBUG_BUFFER {
  1518.     HANDLE  SectionHandle;
  1519.     PVOID  SectionBase;
  1520.     PVOID  RemoteSectionBase;
  1521.     ULONG  SectionBaseDelta;
  1522.     HANDLE  EventPairHandle;
  1523.     ULONG  Unknown[2];
  1524.     HANDLE  RemoteThreadHandle;
  1525.     ULONG  InfoClassMask;
  1526.     ULONG  SizeOfInfo;
  1527.     ULONG  AllocatedSize;
  1528.     ULONG  SectionSize;
  1529.     PVOID  ModuleInformation;
  1530.     PVOID  BackTraceInformation;
  1531.     PVOID  HeapInformation;
  1532.     PVOID  LockInformation;
  1533.     PVOID  Reserved[8];
  1534. } DEBUG_BUFFER, *PDEBUG_BUFFER;
  1535.  
  1536. PDEBUG_BUFFER
  1537. NTAPI
  1538. RtlCreateQueryDebugBuffer(
  1539.     IN ULONG  Size,
  1540.     IN BOOLEAN  EventPair);
  1541.  
  1542. /* RtlQueryProcessDebugInformation.DebugInfoClassMask constants */
  1543. #define PDI_MODULES                       0x01
  1544. #define PDI_BACKTRACE                     0x02
  1545. #define PDI_HEAPS                         0x04
  1546. #define PDI_HEAP_TAGS                     0x08
  1547. #define PDI_HEAP_BLOCKS                   0x10
  1548. #define PDI_LOCKS                         0x20
  1549.  
  1550. NTSTATUS
  1551. NTAPI
  1552. RtlQueryProcessDebugInformation(
  1553.     IN ULONG  ProcessId,
  1554.     IN ULONG  DebugInfoClassMask,
  1555.     IN OUT PDEBUG_BUFFER  DebugBuffer);
  1556.  
  1557. NTSTATUS
  1558. NTAPI
  1559. RtlDestroyQueryDebugBuffer(
  1560.   IN PDEBUG_BUFFER  DebugBuffer);
  1561.  
  1562. /* DEBUG_MODULE_INFORMATION.Flags constants */
  1563. #define LDRP_STATIC_LINK                  0x00000002
  1564. #define LDRP_IMAGE_DLL                    0x00000004
  1565. #define LDRP_LOAD_IN_PROGRESS             0x00001000
  1566. #define LDRP_UNLOAD_IN_PROGRESS           0x00002000
  1567. #define LDRP_ENTRY_PROCESSED              0x00004000
  1568. #define LDRP_ENTRY_INSERTED               0x00008000
  1569. #define LDRP_CURRENT_LOAD                 0x00010000
  1570. #define LDRP_FAILED_BUILTIN_LOAD          0x00020000
  1571. #define LDRP_DONT_CALL_FOR_THREADS        0x00040000
  1572. #define LDRP_PROCESS_ATTACH_CALLED        0x00080000
  1573. #define LDRP_DEBUG_SYMBOLS_LOADED         0x00100000
  1574. #define LDRP_IMAGE_NOT_AT_BASE            0x00200000
  1575. #define LDRP_WX86_IGNORE_MACHINETYPE      0x00400000
  1576.  
  1577. typedef struct _DEBUG_MODULE_INFORMATION {
  1578.     ULONG  Reserved[2];
  1579.     ULONG  Base;
  1580.     ULONG  Size;
  1581.     ULONG  Flags;
  1582.     USHORT  Index;
  1583.     USHORT  Unknown;
  1584.     USHORT  LoadCount;
  1585.     USHORT  ModuleNameOffset;
  1586.     CHAR  ImageName[256];
  1587. } DEBUG_MODULE_INFORMATION, *PDEBUG_MODULE_INFORMATION;
  1588.  
  1589. typedef struct _DEBUG_HEAP_INFORMATION {
  1590.     ULONG  Base;
  1591.     ULONG  Flags;
  1592.     USHORT  Granularity;
  1593.     USHORT  Unknown;
  1594.     ULONG  Allocated;
  1595.     ULONG  Committed;
  1596.     ULONG  TagCount;
  1597.     ULONG  BlockCount;
  1598.     ULONG  Reserved[7];
  1599.     PVOID  Tags;
  1600.     PVOID  Blocks;
  1601. } DEBUG_HEAP_INFORMATION, *PDEBUG_HEAP_INFORMATION;
  1602.  
  1603. typedef struct _DEBUG_LOCK_INFORMATION {
  1604.     PVOID  Address;
  1605.     USHORT  Type;
  1606.     USHORT  CreatorBackTraceIndex;
  1607.     ULONG  OwnerThreadId;
  1608.     ULONG  ActiveCount;
  1609.     ULONG  ContentionCount;
  1610.     ULONG  EntryCount;
  1611.     ULONG  RecursionCount;
  1612.     ULONG  NumberOfSharedWaiters;
  1613.     ULONG  NumberOfExclusiveWaiters;
  1614. } DEBUG_LOCK_INFORMATION, *PDEBUG_LOCK_INFORMATION;
  1615.  
  1616.  
  1617.  
  1618.  
  1619. /* Jobs */
  1620.  
  1621. NTOSAPI
  1622. NTSTATUS
  1623. NTAPI
  1624. ZwCreateJobObject(
  1625.     OUT PHANDLE  JobHandle,
  1626.     IN ACCESS_MASK  DesiredAccess,
  1627.     IN POBJECT_ATTRIBUTES  ObjectAttributes);
  1628.  
  1629. NTOSAPI
  1630. NTSTATUS
  1631. NTAPI
  1632. ZwOpenJobObject(
  1633.     OUT PHANDLE  JobHandle,
  1634.     IN ACCESS_MASK  DesiredAccess,
  1635.     IN POBJECT_ATTRIBUTES  ObjectAttributes);
  1636.  
  1637. NTOSAPI
  1638. NTSTATUS
  1639. NTAPI
  1640. ZwTerminateJobObject(
  1641.     IN HANDLE  JobHandle,
  1642.     IN NTSTATUS  ExitStatus);
  1643.  
  1644. NTOSAPI
  1645. NTSTATUS
  1646. NTAPI
  1647. ZwAssignProcessToJobObject(
  1648.     IN HANDLE  JobHandle,
  1649.     IN HANDLE  ProcessHandle);
  1650.  
  1651. typedef enum _JOBOBJECTINFOCLASS {
  1652.     JobObjectBasicAccountingInformation = 1,
  1653.     JobObjectBasicLimitInformation,
  1654.     JobObjectBasicProcessIdList,
  1655.     JobObjectBasicUIRestrictions,
  1656.     JobObjectSecurityLimitInformation,
  1657.     JobObjectEndOfJobTimeInformation,
  1658.     JobObjectAssociateCompletionPortInformation,
  1659.     JobObjectBasicAndIoAccountingInformation,
  1660.     JobObjectExtendedLimitInformation
  1661. } JOBOBJECTINFOCLASS;
  1662.  
  1663. NTOSAPI
  1664. NTSTATUS
  1665. NTAPI
  1666. ZwQueryInformationJobObject(
  1667.     IN HANDLE  JobHandle,
  1668.     IN JOBOBJECTINFOCLASS  JobInformationClass,
  1669.     OUT PVOID  JobInformation,
  1670.     IN ULONG  JobInformationLength,
  1671.     OUT PULONG  ReturnLength  OPTIONAL);
  1672.  
  1673. NTOSAPI
  1674. NTSTATUS
  1675. NTAPI
  1676. ZwSetInformationJobObject(
  1677.     IN HANDLE  JobHandle,
  1678.     IN JOBOBJECTINFOCLASS  JobInformationClass,
  1679.     IN PVOID  JobInformation,
  1680.     IN ULONG  JobInformationLength);
  1681.  
  1682. typedef struct _JOBOBJECT_BASIC_ACCOUNTING_INFORMATION {
  1683.     LARGE_INTEGER  TotalUserTime;
  1684.     LARGE_INTEGER  TotalKernelTime;
  1685.     LARGE_INTEGER  ThisPeriodTotalUserTime;
  1686.     LARGE_INTEGER  ThisPeriodTotalKernelTime;
  1687.     ULONG  TotalPageFaultCount;
  1688.     ULONG  TotalProcesses;
  1689.     ULONG  ActiveProcesses;
  1690.     ULONG  TotalTerminatedProcesses;
  1691. } JOBOBJECT_BASIC_ACCOUNTING_INFORMATION, *PJOBOBJECT_BASIC_ACCOUNTING_INFORMATION;
  1692.  
  1693. /* JOBOBJECT_BASIC_LIMIT_INFORMATION.LimitFlags constants */
  1694. #define JOB_OBJECT_LIMIT_WORKINGSET                 0x0001
  1695. #define JOB_OBJECT_LIMIT_PROCESS_TIME               0x0002
  1696. #define JOB_OBJECT_LIMIT_JOB_TIME                   0x0004
  1697. #define JOB_OBJECT_LIMIT_ACTIVE_PROCESS             0x0008
  1698. #define JOB_OBJECT_LIMIT_AFFINITY                   0x0010
  1699. #define JOB_OBJECT_LIMIT_PRIORITY_CLASS             0x0020
  1700. #define JOB_OBJECT_LIMIT_PRESERVE_JOB_TIME          0x0040
  1701. #define JOB_OBJECT_LIMIT_SCHEDULING_CLASS           0x0080
  1702. #define JOB_OBJECT_LIMIT_PROCESS_MEMORY             0x0100
  1703. #define JOB_OBJECT_LIMIT_JOB_MEMORY                 0x0200
  1704. #define JOB_OBJECT_LIMIT_DIE_ON_UNHANDLED_EXCEPTION 0x0400
  1705. #define JOB_OBJECT_BREAKAWAY_OK                     0x0800
  1706. #define JOB_OBJECT_SILENT_BREAKAWAY                 0x1000
  1707.  
  1708. typedef struct _JOBOBJECT_BASIC_LIMIT_INFORMATION {
  1709.     LARGE_INTEGER  PerProcessUserTimeLimit;
  1710.     LARGE_INTEGER  PerJobUserTimeLimit;
  1711.     ULONG  LimitFlags;
  1712.     ULONG  MinimumWorkingSetSize;
  1713.     ULONG  MaximumWorkingSetSize;
  1714.     ULONG  ActiveProcessLimit;
  1715.     ULONG  Affinity;
  1716.     ULONG  PriorityClass;
  1717.     ULONG  SchedulingClass;
  1718. } JOBOBJECT_BASIC_LIMIT_INFORMATION, *PJOBOBJECT_BASIC_LIMIT_INFORMATION;
  1719.  
  1720. typedef struct _JOBOBJECT_BASIC_PROCESS_ID_LIST {
  1721.     ULONG  NumberOfAssignedProcesses;
  1722.     ULONG  NumberOfProcessIdsInList;
  1723.     ULONG_PTR  ProcessIdList[1];
  1724. } JOBOBJECT_BASIC_PROCESS_ID_LIST, *PJOBOBJECT_BASIC_PROCESS_ID_LIST;
  1725.  
  1726. /* JOBOBJECT_BASIC_UI_RESTRICTIONS.UIRestrictionsClass constants */
  1727. #define JOB_OBJECT_UILIMIT_HANDLES          0x0001
  1728. #define JOB_OBJECT_UILIMIT_READCLIPBOARD    0x0002
  1729. #define JOB_OBJECT_UILIMIT_WRITECLIPBOARD   0x0004
  1730. #define JOB_OBJECT_UILIMIT_SYSTEMPARAMETERS 0x0008
  1731. #define JOB_OBJECT_UILIMIT_DISPLAYSETTINGS  0x0010
  1732. #define JOB_OBJECT_UILIMIT_GLOBALATOMS      0x0020
  1733. #define JOB_OBJECT_UILIMIT_DESKTOP          0x0040
  1734. #define JOB_OBJECT_UILIMIT_EXITWINDOWS      0x0080
  1735.  
  1736. typedef struct _JOBOBJECT_BASIC_UI_RESTRICTIONS {
  1737.   ULONG  UIRestrictionsClass;
  1738. } JOBOBJECT_BASIC_UI_RESTRICTIONS, *PJOBOBJECT_BASIC_UI_RESTRICTIONS;
  1739.  
  1740. /* JOBOBJECT_SECURITY_LIMIT_INFORMATION.SecurityLimitFlags constants */
  1741. #define JOB_OBJECT_SECURITY_NO_ADMIN          0x0001
  1742. #define JOB_OBJECT_SECURITY_RESTRICTED_TOKEN  0x0002
  1743. #define JOB_OBJECT_SECURITY_ONLY_TOKEN        0x0004
  1744. #define JOB_OBJECT_SECURITY_FILTER_TOKENS     0x0008
  1745.  
  1746. typedef struct _JOBOBJECT_SECURITY_LIMIT_INFORMATION {
  1747.     ULONG  SecurityLimitFlags;
  1748.     HANDLE  JobToken;
  1749.     PTOKEN_GROUPS  SidsToDisable;
  1750.     PTOKEN_PRIVILEGES  PrivilegesToDelete;
  1751.     PTOKEN_GROUPS  RestrictedSids;
  1752. } JOBOBJECT_SECURITY_LIMIT_INFORMATION, *PJOBOBJECT_SECURITY_LIMIT_INFORMATION;
  1753.  
  1754. /* JOBOBJECT_END_OF_JOB_TIME_INFORMATION.EndOfJobTimeAction constants */
  1755. #define JOB_OBJECT_TERMINATE_AT_END_OF_JOB  0
  1756. #define JOB_OBJECT_POST_AT_END_OF_JOB       1
  1757.  
  1758. typedef struct _JOBOBJECT_END_OF_JOB_TIME_INFORMATION {
  1759.   ULONG  EndOfJobTimeAction;
  1760. } JOBOBJECT_END_OF_JOB_TIME_INFORMATION, *PJOBOBJECT_END_OF_JOB_TIME_INFORMATION;
  1761.  
  1762. #define JOB_OBJECT_MSG_END_OF_JOB_TIME        1
  1763. #define JOB_OBJECT_MSG_END_OF_PROCESS_TIME    2
  1764. #define JOB_OBJECT_MSG_ACTIVE_PROCESS_LIMIT   3
  1765. #define JOB_OBJECT_MSG_ACTIVE_PROCESS_ZERO    4
  1766. #define JOB_OBJECT_MSG_NEW_PROCESS            6
  1767. #define JOB_OBJECT_MSG_EXIT_PROCESS           7
  1768. #define JOB_OBJECT_MSG_ABNORMAL_EXIT_PROCESS  8
  1769. #define JOB_OBJECT_MSG_PROCESS_MEMORY_LIMIT   9
  1770. #define JOB_OBJECT_MSG_JOB_MEMORY_LIMIT       10
  1771.  
  1772. typedef struct _JOBOBJECT_ASSOCIATE_COMPLETION_PORT {
  1773.     PVOID  CompletionKey;
  1774.     HANDLE  CompletionPort;
  1775. } JOBOBJECT_ASSOCIATE_COMPLETION_PORT, *PJOBOBJECT_ASSOCIATE_COMPLETION_PORT;
  1776.  
  1777. typedef struct JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION {
  1778.   JOBOBJECT_BASIC_ACCOUNTING_INFORMATION  BasicInfo;
  1779.   IO_COUNTERS  IoInfo;
  1780. } JOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION, *PJOBOBJECT_BASIC_AND_IO_ACCOUNTING_INFORMATION;
  1781.  
  1782. typedef struct _JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
  1783.     JOBOBJECT_BASIC_LIMIT_INFORMATION  BasicLimitInformation;
  1784.     IO_COUNTERS  IoInfo;
  1785.     ULONG  ProcessMemoryLimit;
  1786.     ULONG  JobMemoryLimit;
  1787.     ULONG  PeakProcessMemoryUsed;
  1788.     ULONG  PeakJobMemoryUsed;
  1789. } JOBOBJECT_EXTENDED_LIMIT_INFORMATION, *PJOBOBJECT_EXTENDED_LIMIT_INFORMATION;
  1790.  
  1791.  
  1792.  
  1793.  
  1794. /* Tokens */
  1795.  
  1796. NTOSAPI
  1797. NTSTATUS
  1798. NTAPI
  1799. ZwCreateToken(
  1800. OUT PHANDLE TokenHandle,
  1801. IN ACCESS_MASK DesiredAccess,
  1802. IN POBJECT_ATTRIBUTES ObjectAttributes,
  1803. IN TOKEN_TYPE Type,
  1804. IN PLUID AuthenticationId,
  1805. IN PLARGE_INTEGER ExpirationTime,
  1806. IN PTOKEN_USER User,
  1807. IN PTOKEN_GROUPS Groups,
  1808. IN PTOKEN_PRIVILEGES Privileges,
  1809. IN PTOKEN_OWNER Owner,
  1810. IN PTOKEN_PRIMARY_GROUP PrimaryGroup,
  1811. IN PTOKEN_DEFAULT_DACL DefaultDacl,
  1812. IN PTOKEN_SOURCE Source
  1813. );
  1814.  
  1815. NTOSAPI
  1816. NTSTATUS
  1817. NTAPI
  1818. NtOpenProcessToken(
  1819.   IN HANDLE  ProcessHandle,
  1820.   IN ACCESS_MASK  DesiredAccess,
  1821.   OUT PHANDLE  TokenHandle);
  1822.  
  1823. NTOSAPI
  1824. NTSTATUS
  1825. NTAPI
  1826. ZwOpenProcessToken(
  1827.   IN HANDLE  ProcessHandle,
  1828.   IN ACCESS_MASK  DesiredAccess,
  1829.   OUT PHANDLE  TokenHandle);
  1830.  
  1831. NTOSAPI
  1832. NTSTATUS
  1833. NTAPI
  1834. NtOpenThreadToken(
  1835.   IN HANDLE  ThreadHandle,
  1836.   IN ACCESS_MASK  DesiredAccess,
  1837.   IN BOOLEAN  OpenAsSelf,
  1838.   OUT PHANDLE  TokenHandle);
  1839.  
  1840. NTOSAPI
  1841. NTSTATUS
  1842. NTAPI
  1843. ZwOpenThreadToken(
  1844.   IN HANDLE  ThreadHandle,
  1845.   IN ACCESS_MASK  DesiredAccess,
  1846.   IN BOOLEAN  OpenAsSelf,
  1847.   OUT PHANDLE  TokenHandle);
  1848.  
  1849. NTOSAPI
  1850. NTSTATUS
  1851. NTAPI
  1852. NtDuplicateToken(
  1853.   IN HANDLE  ExistingTokenHandle,
  1854.   IN ACCESS_MASK  DesiredAccess,
  1855.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1856.   IN BOOLEAN  EffectiveOnly,
  1857.   IN TOKEN_TYPE  TokenType,
  1858.   OUT PHANDLE  NewTokenHandle);
  1859.  
  1860. NTOSAPI
  1861. NTSTATUS
  1862. NTAPI
  1863. ZwDuplicateToken(
  1864.   IN HANDLE  ExistingTokenHandle,
  1865.   IN ACCESS_MASK  DesiredAccess,
  1866.   IN POBJECT_ATTRIBUTES  ObjectAttributes,
  1867.   IN BOOLEAN  EffectiveOnly,
  1868.   IN TOKEN_TYPE  TokenType,
  1869.   OUT PHANDLE  NewTokenHandle);
  1870.  
  1871. NTOSAPI
  1872. NTSTATUS
  1873. NTAPI
  1874. ZwFilterToken(
  1875.     IN HANDLE  ExistingTokenHandle,
  1876.     IN ULONG  Flags,
  1877.     IN PTOKEN_GROUPS  SidsToDisable,
  1878.     IN PTOKEN_PRIVILEGES  PrivilegesToDelete,
  1879.     IN PTOKEN_GROUPS  SidsToRestricted,
  1880.     OUT PHANDLE  NewTokenHandle);
  1881.  
  1882. NTOSAPI
  1883. NTSTATUS
  1884. NTAPI
  1885. NtAdjustPrivilegesToken(
  1886.   IN HANDLE  TokenHandle,
  1887.   IN BOOLEAN  DisableAllPrivileges,
  1888.   IN PTOKEN_PRIVILEGES  NewState,
  1889.   IN ULONG  BufferLength,
  1890.   OUT PTOKEN_PRIVILEGES  PreviousState  OPTIONAL,
  1891.   OUT PULONG  ReturnLength);
  1892.  
  1893. NTOSAPI
  1894. NTSTATUS
  1895. NTAPI
  1896. ZwAdjustPrivilegesToken(
  1897.   IN HANDLE  TokenHandle,
  1898.   IN BOOLEAN  DisableAllPrivileges,
  1899.   IN PTOKEN_PRIVILEGES  NewState,
  1900.   IN ULONG  BufferLength,
  1901.   OUT PTOKEN_PRIVILEGES  PreviousState  OPTIONAL,
  1902.   OUT PULONG  ReturnLength);
  1903.  
  1904. NTOSAPI
  1905. NTSTATUS
  1906. NTAPI
  1907. ZwAdjustGroupsToken(
  1908.     IN HANDLE  TokenHandle,
  1909.     IN BOOLEAN  ResetToDefault,
  1910.     IN PTOKEN_GROUPS  NewState,
  1911.     IN ULONG  BufferLength,
  1912.     OUT PTOKEN_GROUPS  PreviousState  OPTIONAL,
  1913.     OUT PULONG  ReturnLength);
  1914.  
  1915. NTOSAPI
  1916. NTSTATUS
  1917. NTAPI
  1918. NtQueryInformationToken(
  1919.   IN HANDLE  TokenHandle,
  1920.   IN TOKEN_INFORMATION_CLASS  TokenInformationClass,
  1921.   OUT PVOID  TokenInformation,
  1922.   IN ULONG  TokenInformationLength,
  1923.   OUT PULONG  ReturnLength);
  1924.  
  1925. NTOSAPI
  1926. NTSTATUS
  1927. NTAPI
  1928. ZwQueryInformationToken(
  1929.   IN HANDLE  TokenHandle,
  1930.   IN TOKEN_INFORMATION_CLASS  TokenInformationClass,
  1931.   OUT PVOID  TokenInformation,
  1932.   IN ULONG  TokenInformationLength,
  1933.   OUT PULONG  ReturnLength);
  1934.  
  1935. NTOSAPI
  1936. NTSTATUS
  1937. NTAPI
  1938. ZwSetInformationToken(
  1939.     IN HANDLE  TokenHandle,
  1940.     IN TOKEN_INFORMATION_CLASS  TokenInformationClass,
  1941.     IN PVOID  TokenInformation,
  1942.   IN ULONG  TokenInformationLength);
  1943.  
  1944.  
  1945.  
  1946.  
  1947. /* Time */
  1948.  
  1949. NTOSAPI
  1950. NTSTATUS
  1951. NTAPI
  1952. ZwQuerySystemTime(
  1953.   OUT PLARGE_INTEGER  CurrentTime);
  1954.  
  1955. NTOSAPI
  1956. NTSTATUS
  1957. NTAPI
  1958. ZwSetSystemTime(
  1959.   IN PLARGE_INTEGER  NewTime,
  1960.   OUT PLARGE_INTEGER  OldTime  OPTIONAL);
  1961.  
  1962. NTOSAPI
  1963. NTSTATUS
  1964. NTAPI
  1965. ZwQueryPerformanceCounter(
  1966.   OUT PLARGE_INTEGER  PerformanceCount,
  1967.   OUT PLARGE_INTEGER  PerformanceFrequency  OPTIONAL);
  1968.  
  1969. NTOSAPI
  1970. NTSTATUS
  1971. NTAPI
  1972. ZwQueryPerformanceCounter(
  1973.   OUT PLARGE_INTEGER  PerformanceCount,
  1974.   OUT PLARGE_INTEGER  PerformanceFrequency  OPTIONAL);
  1975.  
  1976. NTOSAPI
  1977. NTSTATUS
  1978. NTAPI
  1979. ZwQueryTimerResolution(
  1980.     OUT PULONG  CoarsestResolution,
  1981.     OUT PULONG  FinestResolution,
  1982.     OUT PULONG  ActualResolution);
  1983.  
  1984. NTOSAPI
  1985. NTSTATUS
  1986. NTAPI
  1987. ZwDelayExecution(
  1988.   IN BOOLEAN  Alertable,
  1989.   IN PLARGE_INTEGER  Interval);
  1990.  
  1991. NTOSAPI
  1992. NTSTATUS
  1993. NTAPI
  1994. ZwYieldExecution(
  1995.   VOID);
  1996.  
  1997. NTOSAPI
  1998. ULONG
  1999. NTAPI
  2000. ZwGetTickCount(
  2001.   VOID);
  2002.  
  2003.  
  2004.  
  2005.  
  2006. /* Execution profiling */
  2007.  
  2008. NTOSAPI
  2009. NTSTATUS
  2010. NTAPI
  2011. ZwCreateProfile(
  2012.     OUT PHANDLE  ProfileHandle,
  2013.     IN HANDLE  ProcessHandle,
  2014.     IN PVOID  Base,
  2015.     IN ULONG  Size,
  2016.     IN ULONG  BucketShift,
  2017.     IN PULONG  Buffer,
  2018.     IN ULONG  BufferLength,
  2019.     IN KPROFILE_SOURCE  Source,
  2020.     IN ULONG  ProcessorMask);
  2021.  
  2022. NTOSAPI
  2023. NTSTATUS
  2024. NTAPI
  2025. ZwSetIntervalProfile(
  2026.   IN ULONG  Interval,
  2027.   IN KPROFILE_SOURCE  Source);
  2028.  
  2029. NTOSAPI
  2030. NTSTATUS
  2031. NTAPI
  2032. ZwQueryIntervalProfile(
  2033.     IN KPROFILE_SOURCE  Source,
  2034.     OUT PULONG  Interval);
  2035.  
  2036. NTOSAPI
  2037. NTSTATUS
  2038. NTAPI
  2039. ZwStartProfile(
  2040.   IN HANDLE  ProfileHandle);
  2041.  
  2042. NTOSAPI
  2043. NTSTATUS
  2044. NTAPI
  2045. ZwStopProfile(
  2046.   IN HANDLE  ProfileHandle);
  2047.  
  2048.  
  2049.  
  2050.  
  2051. /* Local Procedure Call (LPC) */
  2052.  
  2053. typedef struct _LPC_MESSAGE {
  2054.     USHORT  DataSize;
  2055.     USHORT  MessageSize;
  2056.     USHORT  MessageType;
  2057.     USHORT  VirtualRangesOffset;
  2058.     CLIENT_ID  ClientId;
  2059.     ULONG  MessageId;
  2060.     ULONG  SectionSize;
  2061.     UCHAR  Data[ANYSIZE_ARRAY];
  2062. } LPC_MESSAGE, *PLPC_MESSAGE;
  2063.  
  2064. typedef enum _LPC_TYPE {
  2065.     LPC_NEW_MESSAGE,
  2066.     LPC_REQUEST,
  2067.     LPC_REPLY,
  2068.     LPC_DATAGRAM,
  2069.     LPC_LOST_REPLY,
  2070.     LPC_PORT_CLOSED,
  2071.     LPC_CLIENT_DIED,
  2072.     LPC_EXCEPTION,
  2073.     LPC_DEBUG_EVENT,
  2074.     LPC_ERROR_EVENT,
  2075.     LPC_CONNECTION_REQUEST,
  2076.   LPC_MAXIMUM
  2077. } LPC_TYPE;
  2078.  
  2079. typedef struct _LPC_SECTION_WRITE {
  2080.     ULONG  Length;
  2081.     HANDLE  SectionHandle;
  2082.     ULONG  SectionOffset;
  2083.     ULONG  ViewSize;
  2084.     PVOID  ViewBase;
  2085.     PVOID  TargetViewBase;
  2086. } LPC_SECTION_WRITE, *PLPC_SECTION_WRITE;
  2087.  
  2088. typedef struct _LPC_SECTION_READ {
  2089.     ULONG  Length;
  2090.     ULONG  ViewSize;
  2091.     PVOID  ViewBase;
  2092. } LPC_SECTION_READ, *PLPC_SECTION_READ;
  2093.  
  2094. NTOSAPI
  2095. NTSTATUS
  2096. NTAPI
  2097. ZwCreatePort(
  2098.     OUT PHANDLE  PortHandle,
  2099.     IN POBJECT_ATTRIBUTES  ObjectAttributes,
  2100.     IN ULONG  MaxDataSize,
  2101.     IN ULONG  MaxMessageSize,
  2102.     IN ULONG  Reserved);
  2103.  
  2104. NTOSAPI
  2105. NTSTATUS
  2106. NTAPI
  2107. ZwCreateWaitablePort(
  2108.     OUT PHANDLE  PortHandle,
  2109.     IN POBJECT_ATTRIBUTES  ObjectAttributes,
  2110.     IN ULONG  MaxDataSize,
  2111.     IN ULONG  MaxMessageSize,
  2112.     IN ULONG  Reserved);
  2113.  
  2114. NTOSAPI
  2115. NTSTATUS
  2116. NTAPI
  2117. NtConnectPort(
  2118.   OUT PHANDLE  PortHandle,
  2119.   IN PUNICODE_STRING  PortName,
  2120.   IN PSECURITY_QUALITY_OF_SERVICE  SecurityQos,
  2121.   IN OUT PLPC_SECTION_WRITE  WriteSection  OPTIONAL,
  2122.   IN OUT PLPC_SECTION_READ  ReadSection  OPTIONAL,
  2123.   OUT PULONG  MaxMessageSize  OPTIONAL,
  2124.   IN OUT PVOID  ConnectData  OPTIONAL,
  2125.   IN OUT PULONG  ConnectDataLength  OPTIONAL);
  2126.  
  2127. NTOSAPI
  2128. NTSTATUS
  2129. NTAPI
  2130. ZwConnectPort(
  2131.   OUT PHANDLE  PortHandle,
  2132.   IN PUNICODE_STRING  PortName,
  2133.   IN PSECURITY_QUALITY_OF_SERVICE  SecurityQos,
  2134.   IN OUT PLPC_SECTION_WRITE  WriteSection  OPTIONAL,
  2135.   IN OUT PLPC_SECTION_READ  ReadSection  OPTIONAL,
  2136.   OUT PULONG  MaxMessageSize  OPTIONAL,
  2137.   IN OUT PVOID  ConnectData  OPTIONAL,
  2138.   IN OUT PULONG  ConnectDataLength  OPTIONAL);
  2139.  
  2140. NTOSAPI
  2141. NTSTATUS
  2142. NTAPI
  2143. ZwConnectPort(
  2144.     OUT PHANDLE  PortHandle,
  2145.     IN PUNICODE_STRING  PortName,
  2146.     IN PSECURITY_QUALITY_OF_SERVICE  SecurityQos,
  2147.     IN OUT PLPC_SECTION_WRITE  WriteSection  OPTIONAL,
  2148.     IN OUT PLPC_SECTION_READ  ReadSection  OPTIONAL,
  2149.     OUT PULONG  MaxMessageSize  OPTIONAL,
  2150.     IN OUT PVOID  ConnectData  OPTIONAL,
  2151.     IN OUT PULONG  ConnectDataLength  OPTIONAL);
  2152.  
  2153. NTOSAPI
  2154. NTSTATUS
  2155. NTAPI
  2156. ZwListenPort(
  2157.   IN HANDLE  PortHandle,
  2158.   OUT PLPC_MESSAGE  Message);
  2159.  
  2160. NTOSAPI
  2161. NTSTATUS
  2162. NTAPI
  2163. ZwAcceptConnectPort(
  2164.     OUT PHANDLE  PortHandle,
  2165.     IN ULONG  PortIdentifier,
  2166.     IN PLPC_MESSAGE  Message,
  2167.     IN BOOLEAN  Accept,
  2168.     IN OUT PLPC_SECTION_WRITE  WriteSection  OPTIONAL,
  2169.     IN OUT PLPC_SECTION_READ  ReadSection  OPTIONAL);
  2170.  
  2171. NTOSAPI
  2172. NTSTATUS
  2173. NTAPI
  2174. ZwCompleteConnectPort(
  2175.   IN HANDLE  PortHandle);
  2176.  
  2177. NTOSAPI
  2178. NTSTATUS
  2179. NTAPI
  2180. NtRequestPort(
  2181.   IN HANDLE  PortHandle,
  2182.   IN PLPC_MESSAGE  RequestMessage);
  2183.  
  2184. NTOSAPI
  2185. NTSTATUS
  2186. NTAPI
  2187. NtRequestWaitReplyPort(
  2188.   IN HANDLE  PortHandle,
  2189.   IN PLPC_MESSAGE  RequestMessage,
  2190.   OUT PLPC_MESSAGE  ReplyMessage);
  2191.  
  2192. NTOSAPI
  2193. NTSTATUS
  2194. NTAPI
  2195. ZwRequestWaitReplyPort(
  2196.   IN HANDLE  PortHandle,
  2197.   IN PLPC_MESSAGE  RequestMessage,
  2198.   OUT PLPC_MESSAGE  ReplyMessage);
  2199.  
  2200. NTOSAPI
  2201. NTSTATUS
  2202. NTAPI
  2203. ZwReplyPort(
  2204.     IN HANDLE  PortHandle,
  2205.     IN PLPC_MESSAGE  ReplyMessage);
  2206.  
  2207. NTOSAPI
  2208. NTSTATUS
  2209. NTAPI
  2210. ZwReplyWaitReplyPort(
  2211.     IN HANDLE  PortHandle,
  2212.     IN OUT PLPC_MESSAGE  ReplyMessage);
  2213.  
  2214. NTOSAPI
  2215. NTSTATUS
  2216. NTAPI
  2217. ZwReplyWaitReceivePort(
  2218.     IN HANDLE  PortHandle,
  2219.     OUT PULONG  PortIdentifier  OPTIONAL,
  2220.     IN PLPC_MESSAGE  ReplyMessage  OPTIONAL,
  2221.     OUT PLPC_MESSAGE  Message);
  2222.  
  2223. NTOSAPI
  2224. NTSTATUS
  2225. NTAPI
  2226. ZwReplyWaitReceivePortEx(
  2227.     IN HANDLE  PortHandle,
  2228.     OUT PULONG  PortIdentifier  OPTIONAL,
  2229.     IN PLPC_MESSAGE  ReplyMessage  OPTIONAL,
  2230.     OUT PLPC_MESSAGE  Message,
  2231.     IN PLARGE_INTEGER  Timeout);
  2232.  
  2233. NTOSAPI
  2234. NTSTATUS
  2235. NTAPI
  2236. ZwReadRequestData(
  2237.     IN HANDLE  PortHandle,
  2238.     IN PLPC_MESSAGE  Message,
  2239.     IN ULONG  Index,
  2240.     OUT PVOID  Buffer,
  2241.     IN ULONG  BufferLength,
  2242.     OUT PULONG  ReturnLength  OPTIONAL);
  2243.  
  2244. NTOSAPI
  2245. NTSTATUS
  2246. NTAPI
  2247. ZwWriteRequestData(
  2248.     IN HANDLE  PortHandle,
  2249.     IN PLPC_MESSAGE  Message,
  2250.     IN ULONG  Index,
  2251.     IN PVOID  Buffer,
  2252.     IN ULONG  BufferLength,
  2253.     OUT PULONG  ReturnLength  OPTIONAL);
  2254.  
  2255. typedef enum _PORT_INFORMATION_CLASS {
  2256.   PortBasicInformation
  2257. } PORT_INFORMATION_CLASS;
  2258.  
  2259. NTOSAPI
  2260. NTSTATUS
  2261. NTAPI
  2262. ZwQueryInformationPort(
  2263.     IN HANDLE  PortHandle,
  2264.     IN PORT_INFORMATION_CLASS  PortInformationClass,
  2265.     OUT PVOID  PortInformation,
  2266.     IN ULONG  PortInformationLength,
  2267.   OUT PULONG  ReturnLength  OPTIONAL);
  2268.  
  2269. NTOSAPI
  2270. NTSTATUS
  2271. NTAPI
  2272. ZwImpersonateClientOfPort(
  2273.   IN HANDLE  PortHandle,
  2274.   IN PLPC_MESSAGE  Message);
  2275.  
  2276.  
  2277.  
  2278.  
  2279. /* Files */
  2280.  
  2281. NTOSAPI
  2282. NTSTATUS
  2283. NTAPI
  2284. NtDeleteFile(
  2285.   IN POBJECT_ATTRIBUTES  ObjectAttributes);
  2286.  
  2287. NTOSAPI
  2288. NTSTATUS
  2289. NTAPI
  2290. ZwDeleteFile(
  2291.   IN POBJECT_ATTRIBUTES  ObjectAttributes);
  2292.  
  2293. NTOSAPI
  2294. NTSTATUS
  2295. NTAPI
  2296. ZwFlushBuffersFile(
  2297.     IN HANDLE  FileHandle,
  2298.     OUT PIO_STATUS_BLOCK  IoStatusBlock);
  2299.  
  2300. NTOSAPI
  2301. NTSTATUS
  2302. NTAPI
  2303. ZwCancelIoFile(
  2304.     IN HANDLE  FileHandle,
  2305.     OUT PIO_STATUS_BLOCK  IoStatusBlock);
  2306.  
  2307. NTOSAPI
  2308. NTSTATUS
  2309. NTAPI
  2310. ZwReadFileScatter(
  2311.     IN HANDLE  FileHandle,
  2312.     IN HANDLE  Event OPTIONAL,
  2313.     IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
  2314.     IN PVOID  ApcContext  OPTIONAL,
  2315.     OUT PIO_STATUS_BLOCK  IoStatusBlock,
  2316.     IN PFILE_SEGMENT_ELEMENT  Buffer,
  2317.     IN ULONG  Length,
  2318.     IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
  2319.     IN PULONG  Key  OPTIONAL);
  2320.  
  2321. NTOSAPI
  2322. NTSTATUS
  2323. NTAPI
  2324. ZwWriteFileGather(
  2325.     IN HANDLE  FileHandle,
  2326.     IN HANDLE  Event  OPTIONAL,
  2327.     IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
  2328.     IN PVOID  ApcContext  OPTIONAL,
  2329.     OUT PIO_STATUS_BLOCK  IoStatusBlock,
  2330.     IN PFILE_SEGMENT_ELEMENT  Buffer,
  2331.     IN ULONG  Length,
  2332.     IN PLARGE_INTEGER  ByteOffset  OPTIONAL,
  2333.     IN PULONG  Key  OPTIONAL);
  2334.  
  2335.  
  2336.  
  2337.  
  2338. /* Registry keys */
  2339.  
  2340. NTOSAPI
  2341. NTSTATUS
  2342. NTAPI
  2343. ZwSaveKey(
  2344.     IN HANDLE  KeyHandle,
  2345.     IN HANDLE  FileHandle);
  2346.  
  2347. NTOSAPI
  2348. NTSTATUS
  2349. NTAPI
  2350. ZwSaveMergedKeys(
  2351.     IN HANDLE  KeyHandle1,
  2352.     IN HANDLE  KeyHandle2,
  2353.     IN HANDLE  FileHandle);
  2354.  
  2355. NTOSAPI
  2356. NTSTATUS
  2357. NTAPI
  2358. ZwRestoreKey(
  2359.   IN HANDLE  KeyHandle,
  2360.   IN HANDLE  FileHandle,
  2361.   IN ULONG  Flags);
  2362.  
  2363. NTOSAPI
  2364. NTSTATUS
  2365. NTAPI
  2366. ZwLoadKey(
  2367.   IN POBJECT_ATTRIBUTES  KeyObjectAttributes,
  2368.   IN POBJECT_ATTRIBUTES  FileObjectAttributes);
  2369.  
  2370. NTOSAPI
  2371. NTSTATUS
  2372. NTAPI
  2373. ZwLoadKey2(
  2374.     IN POBJECT_ATTRIBUTES  KeyObjectAttributes,
  2375.     IN POBJECT_ATTRIBUTES  FileObjectAttributes,
  2376.     IN ULONG  Flags);
  2377.  
  2378. NTOSAPI
  2379. NTSTATUS
  2380. NTAPI
  2381. ZwUnloadKey(
  2382.   IN POBJECT_ATTRIBUTES  KeyObjectAttributes);
  2383.  
  2384. NTOSAPI
  2385. NTSTATUS
  2386. NTAPI
  2387. ZwQueryOpenSubKeys(
  2388.     IN POBJECT_ATTRIBUTES  KeyObjectAttributes,
  2389.     OUT PULONG  NumberOfKeys);
  2390.  
  2391. NTOSAPI
  2392. NTSTATUS
  2393. NTAPI
  2394. ZwReplaceKey(
  2395.     IN POBJECT_ATTRIBUTES  NewFileObjectAttributes,
  2396.     IN HANDLE  KeyHandle,
  2397.     IN POBJECT_ATTRIBUTES  OldFileObjectAttributes);
  2398.  
  2399. typedef enum _KEY_SET_INFORMATION_CLASS {
  2400.   KeyLastWriteTimeInformation
  2401. } KEY_SET_INFORMATION_CLASS;
  2402.  
  2403. NTOSAPI
  2404. NTSTATUS
  2405. NTAPI
  2406. ZwSetInformationKey(
  2407.     IN HANDLE  KeyHandle,
  2408.     IN KEY_SET_INFORMATION_CLASS  KeyInformationClass,
  2409.     IN PVOID  KeyInformation,
  2410.     IN ULONG  KeyInformationLength);
  2411.  
  2412. typedef struct _KEY_LAST_WRITE_TIME_INFORMATION {
  2413.   LARGE_INTEGER LastWriteTime;
  2414. } KEY_LAST_WRITE_TIME_INFORMATION, *PKEY_LAST_WRITE_TIME_INFORMATION;
  2415.  
  2416. typedef struct _KEY_NAME_INFORMATION {
  2417.     ULONG NameLength;
  2418.     WCHAR Name[1];
  2419. } KEY_NAME_INFORMATION, *PKEY_NAME_INFORMATION;
  2420.  
  2421. NTOSAPI
  2422. NTSTATUS
  2423. NTAPI
  2424. ZwNotifyChangeKey(
  2425.     IN HANDLE  KeyHandle,
  2426.     IN HANDLE  EventHandle  OPTIONAL,
  2427.     IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
  2428.     IN PVOID  ApcContext  OPTIONAL,
  2429.     OUT PIO_STATUS_BLOCK  IoStatusBlock,
  2430.     IN ULONG  NotifyFilter,
  2431.     IN BOOLEAN  WatchSubtree,
  2432.     IN PVOID  Buffer,
  2433.     IN ULONG  BufferLength,
  2434.     IN BOOLEAN  Asynchronous);
  2435.  
  2436. /* ZwNotifyChangeMultipleKeys.Flags constants */
  2437. #define REG_MONITOR_SINGLE_KEY            0x00
  2438. #define REG_MONITOR_SECOND_KEY            0x01
  2439.  
  2440. NTOSAPI
  2441. NTSTATUS
  2442. NTAPI
  2443. ZwNotifyChangeMultipleKeys(
  2444.     IN HANDLE  KeyHandle,
  2445.     IN ULONG  Flags,
  2446.     IN POBJECT_ATTRIBUTES  KeyObjectAttributes,
  2447.     IN HANDLE  EventHandle  OPTIONAL,
  2448.     IN PIO_APC_ROUTINE  ApcRoutine  OPTIONAL,
  2449.     IN PVOID  ApcContext  OPTIONAL,
  2450.     OUT PIO_STATUS_BLOCK  IoStatusBlock,
  2451.     IN ULONG  NotifyFilter,
  2452.     IN BOOLEAN  WatchSubtree,
  2453.     IN PVOID  Buffer,
  2454.     IN ULONG  BufferLength,
  2455.     IN BOOLEAN  Asynchronous);
  2456.  
  2457. NTOSAPI
  2458. NTSTATUS
  2459. NTAPI
  2460. ZwQueryMultipleValueKey(
  2461.     IN HANDLE  KeyHandle,
  2462.     IN OUT  PKEY_VALUE_ENTRY  ValueList,
  2463.     IN ULONG  NumberOfValues,
  2464.     OUT PVOID  Buffer,
  2465.     IN OUT PULONG  Length,
  2466.     OUT PULONG  ReturnLength);
  2467.  
  2468. NTOSAPI
  2469. NTSTATUS
  2470. NTAPI
  2471. ZwInitializeRegistry(
  2472.   IN BOOLEAN  Setup);
  2473.  
  2474.  
  2475.  
  2476.  
  2477. /* Security and auditing */
  2478.  
  2479. NTOSAPI
  2480. NTSTATUS
  2481. NTAPI
  2482. ZwPrivilegeCheck(
  2483.     IN HANDLE  TokenHandle,
  2484.     IN PPRIVILEGE_SET  RequiredPrivileges,
  2485.     OUT PBOOLEAN  Result);
  2486.  
  2487. NTOSAPI
  2488. NTSTATUS
  2489. NTAPI
  2490. ZwPrivilegeObjectAuditAlarm(
  2491.     IN PUNICODE_STRING  SubsystemName,
  2492.     IN PVOID  HandleId,
  2493.     IN HANDLE  TokenHandle,
  2494.     IN ACCESS_MASK  DesiredAccess,
  2495.     IN PPRIVILEGE_SET  Privileges,
  2496.     IN BOOLEAN  AccessGranted);
  2497.  
  2498. NTOSAPI
  2499. NTSTATUS
  2500. NTAPI
  2501. ZwPrivilegeObjectAuditAlarm(
  2502.     IN PUNICODE_STRING  SubsystemName,
  2503.     IN PVOID  HandleId,
  2504.     IN HANDLE  TokenHandle,
  2505.     IN ACCESS_MASK  DesiredAccess,
  2506.     IN PPRIVILEGE_SET  Privileges,
  2507.     IN BOOLEAN  AccessGranted);
  2508.  
  2509. NTOSAPI
  2510. NTSTATUS
  2511. NTAPI
  2512. ZwAccessCheck(
  2513.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2514.     IN HANDLE  TokenHandle,
  2515.     IN ACCESS_MASK  DesiredAccess,
  2516.     IN PGENERIC_MAPPING  GenericMapping,
  2517.     IN PPRIVILEGE_SET  PrivilegeSet,
  2518.     IN PULONG  PrivilegeSetLength,
  2519.     OUT PACCESS_MASK  GrantedAccess,
  2520.     OUT PBOOLEAN  AccessStatus);
  2521.  
  2522. NTOSAPI
  2523. NTSTATUS
  2524. NTAPI
  2525. ZwAccessCheckAndAuditAlarm(
  2526.     IN PUNICODE_STRING  SubsystemName,
  2527.     IN PVOID  HandleId,
  2528.     IN PUNICODE_STRING  ObjectTypeName,
  2529.     IN PUNICODE_STRING  ObjectName,
  2530.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2531.     IN ACCESS_MASK  DesiredAccess,
  2532.     IN PGENERIC_MAPPING  GenericMapping,
  2533.     IN BOOLEAN  ObjectCreation,
  2534.     OUT PACCESS_MASK  GrantedAccess,
  2535.     OUT PBOOLEAN  AccessStatus,
  2536.     OUT PBOOLEAN  GenerateOnClose);
  2537.  
  2538. NTOSAPI
  2539. NTSTATUS
  2540. NTAPI
  2541. ZwAccessCheckByType(
  2542.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2543.     IN PSID  PrincipalSelfSid,
  2544.     IN HANDLE  TokenHandle,
  2545.     IN ULONG  DesiredAccess,
  2546.     IN POBJECT_TYPE_LIST  ObjectTypeList,
  2547.     IN ULONG  ObjectTypeListLength,
  2548.     IN PGENERIC_MAPPING  GenericMapping,
  2549.     IN PPRIVILEGE_SET  PrivilegeSet,
  2550.     IN PULONG  PrivilegeSetLength,
  2551.     OUT PACCESS_MASK  GrantedAccess,
  2552.     OUT PULONG  AccessStatus);
  2553.  
  2554. typedef enum _AUDIT_EVENT_TYPE {
  2555.     AuditEventObjectAccess,
  2556.     AuditEventDirectoryServiceAccess
  2557. } AUDIT_EVENT_TYPE, *PAUDIT_EVENT_TYPE;
  2558.  
  2559. NTOSAPI
  2560. NTSTATUS
  2561. NTAPI
  2562. ZwAccessCheckByTypeAndAuditAlarm(
  2563.     IN PUNICODE_STRING  SubsystemName,
  2564.     IN PVOID  HandleId,
  2565.     IN PUNICODE_STRING  ObjectTypeName,
  2566.     IN PUNICODE_STRING  ObjectName,
  2567.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2568.     IN PSID  PrincipalSelfSid,
  2569.     IN ACCESS_MASK  DesiredAccess,
  2570.     IN AUDIT_EVENT_TYPE  AuditType,
  2571.     IN ULONG  Flags,
  2572.     IN POBJECT_TYPE_LIST  ObjectTypeList,
  2573.     IN ULONG  ObjectTypeListLength,
  2574.     IN PGENERIC_MAPPING  GenericMapping,
  2575.     IN BOOLEAN  ObjectCreation,
  2576.     OUT PACCESS_MASK  GrantedAccess,
  2577.     OUT PULONG  AccessStatus,
  2578.     OUT PBOOLEAN  GenerateOnClose);
  2579.  
  2580. NTOSAPI
  2581. NTSTATUS
  2582. NTAPI
  2583. ZwAccessCheckByTypeResultList(
  2584.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2585.     IN PSID  PrincipalSelfSid,
  2586.     IN HANDLE  TokenHandle,
  2587.     IN ACCESS_MASK  DesiredAccess,
  2588.     IN POBJECT_TYPE_LIST  ObjectTypeList,
  2589.     IN ULONG  ObjectTypeListLength,
  2590.     IN PGENERIC_MAPPING  GenericMapping,
  2591.     IN PPRIVILEGE_SET  PrivilegeSet,
  2592.     IN PULONG  PrivilegeSetLength,
  2593.     OUT PACCESS_MASK  GrantedAccessList,
  2594.     OUT PULONG  AccessStatusList);
  2595.  
  2596. NTOSAPI
  2597. NTSTATUS
  2598. NTAPI
  2599. ZwAccessCheckByTypeResultListAndAuditAlarm(
  2600.     IN PUNICODE_STRING  SubsystemName,
  2601.     IN PVOID  HandleId,
  2602.     IN PUNICODE_STRING  ObjectTypeName,
  2603.     IN PUNICODE_STRING  ObjectName,
  2604.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2605.     IN PSID  PrincipalSelfSid,
  2606.     IN ACCESS_MASK  DesiredAccess,
  2607.     IN AUDIT_EVENT_TYPE  AuditType,
  2608.     IN ULONG  Flags,
  2609.     IN POBJECT_TYPE_LIST  ObjectTypeList,
  2610.     IN ULONG  ObjectTypeListLength,
  2611.     IN PGENERIC_MAPPING  GenericMapping,
  2612.     IN BOOLEAN  ObjectCreation,
  2613.     OUT PACCESS_MASK  GrantedAccessList,
  2614.     OUT PULONG  AccessStatusList,
  2615.     OUT PULONG  GenerateOnClose);
  2616.  
  2617. NTOSAPI
  2618. NTSTATUS
  2619. NTAPI
  2620. ZwAccessCheckByTypeResultListAndAuditAlarmByHandle(
  2621.     IN PUNICODE_STRING  SubsystemName,
  2622.     IN PVOID  HandleId,
  2623.     IN HANDLE  TokenHandle,
  2624.     IN PUNICODE_STRING  ObjectTypeName,
  2625.     IN PUNICODE_STRING  ObjectName,
  2626.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2627.     IN PSID  PrincipalSelfSid,
  2628.     IN ACCESS_MASK  DesiredAccess,
  2629.     IN AUDIT_EVENT_TYPE  AuditType,
  2630.     IN ULONG  Flags,
  2631.     IN POBJECT_TYPE_LIST  ObjectTypeList,
  2632.     IN ULONG  ObjectTypeListLength,
  2633.     IN PGENERIC_MAPPING  GenericMapping,
  2634.     IN BOOLEAN  ObjectCreation,
  2635.     OUT PACCESS_MASK  GrantedAccessList,
  2636.     OUT PULONG  AccessStatusList,
  2637.     OUT PULONG  GenerateOnClose);
  2638.  
  2639. NTOSAPI
  2640. NTSTATUS
  2641. NTAPI
  2642. ZwOpenObjectAuditAlarm(
  2643.     IN PUNICODE_STRING  SubsystemName,
  2644.     IN PVOID  *HandleId,
  2645.     IN PUNICODE_STRING  ObjectTypeName,
  2646.     IN PUNICODE_STRING  ObjectName,
  2647.     IN PSECURITY_DESCRIPTOR  SecurityDescriptor,
  2648.     IN HANDLE  TokenHandle,
  2649.     IN ACCESS_MASK  DesiredAccess,
  2650.     IN ACCESS_MASK  GrantedAccess,
  2651.     IN PPRIVILEGE_SET  Privileges  OPTIONAL,
  2652.     IN BOOLEAN  ObjectCreation,
  2653.     IN BOOLEAN  AccessGranted,
  2654.     OUT PBOOLEAN  GenerateOnClose);
  2655.  
  2656. NTOSAPI
  2657. NTSTATUS
  2658. NTAPI
  2659. ZwCloseObjectAuditAlarm(
  2660.   IN PUNICODE_STRING  SubsystemName,
  2661.   IN PVOID  HandleId,
  2662.   IN BOOLEAN  GenerateOnClose);
  2663.  
  2664. NTOSAPI
  2665. NTSTATUS
  2666. NTAPI
  2667. ZwDeleteObjectAuditAlarm(
  2668.   IN PUNICODE_STRING  SubsystemName,
  2669.   IN PVOID  HandleId,
  2670.   IN BOOLEAN  GenerateOnClose);
  2671.  
  2672.  
  2673.  
  2674.  
  2675. /* Plug and play and power management */
  2676.  
  2677. NTOSAPI
  2678. NTSTATUS
  2679. NTAPI
  2680. ZwRequestWakeupLatency(
  2681.   IN LATENCY_TIME  Latency);
  2682.  
  2683. NTOSAPI
  2684. NTSTATUS
  2685. NTAPI
  2686. ZwRequestDeviceWakeup(
  2687.   IN HANDLE  DeviceHandle);
  2688.  
  2689. NTOSAPI
  2690. NTSTATUS
  2691. NTAPI
  2692. ZwCancelDeviceWakeupRequest(
  2693.   IN HANDLE  DeviceHandle);
  2694.  
  2695. NTOSAPI
  2696. BOOLEAN
  2697. NTAPI
  2698. ZwIsSystemResumeAutomatic(
  2699.   VOID);
  2700.  
  2701. NTOSAPI
  2702. NTSTATUS
  2703. NTAPI
  2704. ZwSetThreadExecutionState(
  2705.     IN EXECUTION_STATE  ExecutionState,
  2706.     OUT PEXECUTION_STATE  PreviousExecutionState);
  2707.  
  2708. NTOSAPI
  2709. NTSTATUS
  2710. NTAPI
  2711. ZwGetDevicePowerState(
  2712.   IN HANDLE  DeviceHandle,
  2713.   OUT PDEVICE_POWER_STATE  DevicePowerState);
  2714.  
  2715. NTOSAPI
  2716. NTSTATUS
  2717. NTAPI
  2718. ZwSetSystemPowerState(
  2719.     IN POWER_ACTION  SystemAction,
  2720.     IN SYSTEM_POWER_STATE  MinSystemState,
  2721.     IN ULONG  Flags);
  2722.  
  2723. NTOSAPI
  2724. NTSTATUS
  2725. NTAPI
  2726. ZwInitiatePowerAction(
  2727.     IN POWER_ACTION  SystemAction,
  2728.     IN SYSTEM_POWER_STATE  MinSystemState,
  2729.     IN ULONG  Flags,
  2730.     IN BOOLEAN  Asynchronous);
  2731.  
  2732. NTOSAPI
  2733. NTSTATUS
  2734. NTAPI
  2735. ZwPowerInformation(
  2736.     IN POWER_INFORMATION_LEVEL  PowerInformationLevel,
  2737.     IN PVOID  InputBuffer  OPTIONAL,
  2738.     IN ULONG  InputBufferLength,
  2739.     OUT PVOID  OutputBuffer  OPTIONAL,
  2740.     IN ULONG  OutputBufferLength);
  2741.  
  2742. NTOSAPI
  2743. NTSTATUS
  2744. NTAPI
  2745. ZwPlugPlayControl(
  2746.   IN ULONG  ControlCode,
  2747.   IN OUT PVOID  Buffer,
  2748.   IN ULONG  BufferLength);
  2749.  
  2750. NTOSAPI
  2751. NTSTATUS
  2752. NTAPI
  2753. ZwGetPlugPlayEvent(
  2754.     IN ULONG  Reserved1,
  2755.     IN ULONG  Reserved2,
  2756.     OUT PVOID  Buffer,
  2757.     IN ULONG  BufferLength);
  2758.  
  2759.  
  2760.  
  2761.  
  2762. /* Miscellany */
  2763.  
  2764. NTOSAPI
  2765. NTSTATUS
  2766. NTAPI
  2767. ZwRaiseException(
  2768.   IN PEXCEPTION_RECORD  ExceptionRecord,
  2769.   IN PCONTEXT  Context,
  2770.   IN BOOLEAN  SearchFrames);
  2771.  
  2772. NTOSAPI
  2773. NTSTATUS
  2774. NTAPI
  2775. ZwContinue(
  2776.   IN PCONTEXT  Context,
  2777.   IN BOOLEAN  TestAlert);
  2778.  
  2779. NTOSAPI
  2780. NTSTATUS
  2781. NTAPI
  2782. ZwW32Call(
  2783.     IN ULONG  RoutineIndex,
  2784.     IN PVOID  Argument,
  2785.     IN ULONG  ArgumentLength,
  2786.     OUT PVOID  *Result  OPTIONAL,
  2787.     OUT PULONG  ResultLength  OPTIONAL);
  2788.  
  2789. NTOSAPI
  2790. NTSTATUS
  2791. NTAPI
  2792. ZwSetLowWaitHighThread(
  2793.   VOID);
  2794.  
  2795. NTOSAPI
  2796. NTSTATUS
  2797. NTAPI
  2798. ZwSetHighWaitLowThread(
  2799.   VOID);
  2800.  
  2801. NTOSAPI
  2802. NTSTATUS
  2803. NTAPI
  2804. ZwLoadDriver(
  2805.   IN PUNICODE_STRING  DriverServiceName);
  2806.  
  2807. NTOSAPI
  2808. NTSTATUS
  2809. NTAPI
  2810. ZwUnloadDriver(
  2811.   IN PUNICODE_STRING  DriverServiceName);
  2812.  
  2813. NTOSAPI
  2814. NTSTATUS
  2815. NTAPI
  2816. ZwFlushInstructionCache(
  2817.     IN HANDLE  ProcessHandle,
  2818.     IN PVOID  BaseAddress  OPTIONAL,
  2819.     IN ULONG  FlushSize);
  2820.  
  2821. NTOSAPI
  2822. NTSTATUS
  2823. NTAPI
  2824. ZwFlushWriteBuffer(
  2825.   VOID);
  2826.  
  2827. NTOSAPI
  2828. NTSTATUS
  2829. NTAPI
  2830. ZwQueryDefaultLocale(
  2831.     IN BOOLEAN  ThreadOrSystem,
  2832.     OUT PLCID  Locale);
  2833.  
  2834. NTOSAPI
  2835. NTSTATUS
  2836. NTAPI
  2837. ZwSetDefaultLocale(
  2838.   IN BOOLEAN  ThreadOrSystem,
  2839.   IN LCID  Locale);
  2840.  
  2841. NTOSAPI
  2842. NTSTATUS
  2843. NTAPI
  2844. ZwQueryDefaultUILanguage(
  2845.   OUT PLANGID  LanguageId);
  2846.  
  2847. NTOSAPI
  2848. NTSTATUS
  2849. NTAPI
  2850. ZwSetDefaultUILanguage(
  2851.   IN LANGID  LanguageId);
  2852.  
  2853. NTOSAPI
  2854. NTSTATUS
  2855. NTAPI
  2856. ZwQueryInstallUILanguage(
  2857.   OUT PLANGID  LanguageId);
  2858.  
  2859. NTOSAPI
  2860. NTSTATUS
  2861. NTAPI
  2862. NtAllocateLocallyUniqueId(
  2863.   OUT PLUID  Luid);
  2864.  
  2865. NTOSAPI
  2866. NTSTATUS
  2867. NTAPI
  2868. NtAllocateUuids(
  2869.   OUT PLARGE_INTEGER  UuidLastTimeAllocated,
  2870.   OUT PULONG  UuidDeltaTime,
  2871.   OUT PULONG  UuidSequenceNumber,
  2872.   OUT PUCHAR  UuidSeed);
  2873.  
  2874. NTOSAPI
  2875. NTSTATUS
  2876. NTAPI
  2877. ZwSetUuidSeed(
  2878.   IN PUCHAR  UuidSeed);
  2879.  
  2880. typedef enum _HARDERROR_RESPONSE_OPTION {
  2881.     OptionAbortRetryIgnore,
  2882.     OptionOk,
  2883.     OptionOkCancel,
  2884.     OptionRetryCancel,
  2885.     OptionYesNo,
  2886.     OptionYesNoCancel,
  2887.     OptionShutdownSystem
  2888. } HARDERROR_RESPONSE_OPTION, *PHARDERROR_RESPONSE_OPTION;
  2889.  
  2890. typedef enum _HARDERROR_RESPONSE {
  2891.     ResponseReturnToCaller,
  2892.     ResponseNotHandled,
  2893.     ResponseAbort,
  2894.     ResponseCancel,
  2895.     ResponseIgnore,
  2896.     ResponseNo,
  2897.     ResponseOk,
  2898.     ResponseRetry,
  2899.     ResponseYes
  2900. } HARDERROR_RESPONSE, *PHARDERROR_RESPONSE;
  2901.  
  2902. NTOSAPI
  2903. NTSTATUS
  2904. NTAPI
  2905. ZwRaiseHardError(
  2906.     IN NTSTATUS  Status,
  2907.     IN ULONG  NumberOfArguments,
  2908.     IN ULONG  StringArgumentsMask,
  2909.     IN PULONG  Arguments,
  2910.     IN HARDERROR_RESPONSE_OPTION  ResponseOption,
  2911.     OUT PHARDERROR_RESPONSE  Response);
  2912.  
  2913. NTOSAPI
  2914. NTSTATUS
  2915. NTAPI
  2916. ZwSetDefaultHardErrorPort(
  2917.   IN HANDLE  PortHandle);
  2918.  
  2919. NTOSAPI
  2920. NTSTATUS
  2921. NTAPI
  2922. ZwDisplayString(
  2923.   IN PUNICODE_STRING  String);
  2924.  
  2925. NTOSAPI
  2926. NTSTATUS
  2927. NTAPI
  2928. ZwCreatePagingFile(
  2929.   IN PUNICODE_STRING  FileName,
  2930.   IN PULARGE_INTEGER  InitialSize,
  2931.   IN PULARGE_INTEGER  MaximumSize,
  2932.   IN ULONG  Reserved);
  2933.  
  2934. typedef USHORT RTL_ATOM, *PRTL_ATOM;
  2935.  
  2936. NTOSAPI
  2937. NTSTATUS
  2938. NTAPI
  2939. NtAddAtom(
  2940.   IN PWSTR  AtomName,
  2941.   IN ULONG  AtomNameLength,
  2942.   OUT PRTL_ATOM  Atom);
  2943.  
  2944. NTOSAPI
  2945. NTSTATUS
  2946. NTAPI
  2947. NtFindAtom(
  2948.   IN PWSTR  AtomName,
  2949.   IN ULONG  AtomNameLength,
  2950.   OUT PRTL_ATOM  Atom);
  2951.  
  2952. NTOSAPI
  2953. NTSTATUS
  2954. NTAPI
  2955. NtDeleteAtom(
  2956.   IN RTL_ATOM  Atom);
  2957.  
  2958. typedef enum _ATOM_INFORMATION_CLASS {
  2959.     AtomBasicInformation,
  2960.     AtomListInformation
  2961. } ATOM_INFORMATION_CLASS;
  2962.  
  2963. NTOSAPI
  2964. NTSTATUS
  2965. NTAPI
  2966. NtQueryInformationAtom(
  2967.   IN RTL_ATOM  Atom,
  2968.   IN ATOM_INFORMATION_CLASS  AtomInformationClass,
  2969.   OUT PVOID  AtomInformation,
  2970.   IN ULONG  AtomInformationLength,
  2971.   OUT PULONG  ReturnLength  OPTIONAL);
  2972.  
  2973. typedef struct _ATOM_BASIC_INFORMATION {
  2974.     USHORT  ReferenceCount;
  2975.     USHORT  Pinned;
  2976.     USHORT  NameLength;
  2977.     WCHAR  Name[1];
  2978. } ATOM_BASIC_INFORMATION, *PATOM_BASIC_INFORMATION;
  2979.  
  2980. typedef struct _ATOM_LIST_INFORMATION {
  2981.   ULONG  NumberOfAtoms;
  2982.   ATOM  Atoms[1];
  2983. } ATOM_LIST_INFORMATION, *PATOM_LIST_INFORMATION;
  2984.  
  2985. NTOSAPI
  2986. NTSTATUS
  2987. NTAPI
  2988. ZwSetLdtEntries(
  2989.     IN ULONG  Selector1,
  2990.     IN LDT_ENTRY  LdtEntry1,
  2991.     IN ULONG  Selector2,
  2992.     IN LDT_ENTRY  LdtEntry2);
  2993.  
  2994. NTOSAPI
  2995. NTSTATUS
  2996. NTAPI
  2997. NtVdmControl(
  2998.   IN ULONG  ControlCode,
  2999.   IN PVOID  ControlData);
  3000.  
  3001. #pragma pack(pop)
  3002.  
  3003. #ifdef __cplusplus
  3004. }
  3005. #endif
  3006.  
  3007. #endif /* __NTAPI_H */
  3008.