include/ddk/wdm.h

   1 /*
   2  * Copyright 2004-2005 Ivan Leo Puoti
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #ifndef _WDMDDK_
  20 #define _WDMDDK_
  21 #define _NTDDK_
  22
  23 #include <ntstatus.h>
  24
  25 #ifdef _WIN64
  26 #define POINTER_ALIGNMENT DECLSPEC_ALIGN(8)
  27 #else
  28 #define POINTER_ALIGNMENT
  29 #endif
  30
  31 typedef LONG KPRIORITY;
  32
  33 typedef ULONG_PTR KSPIN_LOCK, *PKSPIN_LOCK;
  34
  35 struct _KDPC;
  36 struct _KAPC;
  37 struct _IRP;
  38 struct _DEVICE_OBJECT;
  39 struct _DRIVER_OBJECT;
  40
  41 typedef VOID (WINAPI *PKDEFERRED_ROUTINE)(struct _KDPC *, PVOID, PVOID, PVOID);
  42 typedef VOID (WINAPI *PKSTART_ROUTINE)(PVOID);
  43
  44 typedef NTSTATUS (WINAPI *PDRIVER_INITIALIZE)(struct _DRIVER_OBJECT *, PUNICODE_STRING);
  45 typedef NTSTATUS (WINAPI *PDRIVER_DISPATCH)(struct _DEVICE_OBJECT *, struct _IRP *);
  46 typedef void (WINAPI *PDRIVER_STARTIO)(struct _DEVICE_OBJECT *, struct _IRP *);
  47 typedef void (WINAPI *PDRIVER_UNLOAD)(struct _DRIVER_OBJECT *);
  48
  49 typedef struct _DISPATCHER_HEADER {
  50   UCHAR  Type;
  51   UCHAR  Absolute;
  52   UCHAR  Size;
  53   UCHAR  Inserted;
  54   LONG  SignalState;
  55   LIST_ENTRY  WaitListHead;
  56 } DISPATCHER_HEADER, *PDISPATCHER_HEADER;
  57
  58 typedef struct _KEVENT {
  59   DISPATCHER_HEADER  Header;
  60 } KEVENT, *PKEVENT, *RESTRICTED_POINTER PRKEVENT;
  61
  62 typedef struct _KDPC {
  63   CSHORT  Type;
  64   UCHAR  Number;
  65   UCHAR  Importance;
  66   LIST_ENTRY  DpcListEntry;
  67   PKDEFERRED_ROUTINE  DeferredRoutine;
  68   PVOID  DeferredContext;
  69   PVOID  SystemArgument1;
  70   PVOID  SystemArgument2;
  71   PULONG_PTR  Lock;
  72 } KDPC, *PKDPC, *RESTRICTED_POINTER PRKDPC;
  73
  74 typedef struct _KDEVICE_QUEUE_ENTRY {
  75   LIST_ENTRY  DeviceListEntry;
  76   ULONG  SortKey;
  77   BOOLEAN  Inserted;
  78 } KDEVICE_QUEUE_ENTRY, *PKDEVICE_QUEUE_ENTRY,
  79 *RESTRICTED_POINTER PRKDEVICE_QUEUE_ENTRY;
  80
  81 typedef struct _KDEVICE_QUEUE {
  82   CSHORT  Type;
  83   CSHORT  Size;
  84   LIST_ENTRY  DeviceListHead;
  85   KSPIN_LOCK  Lock;
  86   BOOLEAN  Busy;
  87 } KDEVICE_QUEUE, *PKDEVICE_QUEUE, *RESTRICTED_POINTER PRKDEVICE_QUEUE;
  88
  89 typedef struct _KMUTANT {
  90     DISPATCHER_HEADER Header;
  91     LIST_ENTRY MutantListEntry;
  92     struct _KTHREAD *RESTRICTED_POINTER OwnerThread;
  93     BOOLEAN Abandoned;
  94     UCHAR ApcDisable;
  95 } KMUTANT, *PKMUTANT, *RESTRICTED_POINTER PRKMUTANT, KMUTEX, *PKMUTEX, *RESTRICTED_POINTER PRKMUTEX;
  96
  97 typedef enum _KWAIT_REASON
  98 {
  99     Executive,
 100     FreePage,
 101     PageIn,
 102     PoolAllocation,
 103     DelayExecution,
 104     Suspended,
 105     UserRequest,
 106     WrExecutive,
 107     WrFreePage,
 108     WrPageIn,
 109     WrDelayExecution,
 110     WrSuspended,
 111     WrUserRequest,
 112     WrQueue,
 113     WrLpcReceive,
 114     WrLpcReply,
 115     WrVirtualMemory,
 116     WrPageOut,
 117     WrRendezvous,
 118     Spare2,
 119     Spare3,
 120     Spare4,
 121     Spare5,
 122     Spare6,
 123     WrKernel,
 124     MaximumWaitReason,
 125 } KWAIT_REASON;
 126
 127 typedef struct _IO_TIMER *PIO_TIMER;
 128 typedef struct _ETHREAD *PETHREAD;
 129 typedef struct _KTHREAD *PKTHREAD;
 130 typedef struct _EPROCESS *PEPROCESS;
 131 typedef struct _IO_WORKITEM *PIO_WORKITEM;
 132 typedef struct _OBJECT_TYPE *POBJECT_TYPE;
 133 typedef struct _OBJECT_HANDLE_INFORMATION *POBJECT_HANDLE_INFORMATION;
 134
 135 typedef struct _FAST_MUTEX
 136 {
 137     LONG Count;
 138     PKTHREAD Owner;
 139     ULONG Contention;
 140     KEVENT Gate;
 141     ULONG OldIrql;
 142 } FAST_MUTEX, *PFAST_MUTEX;
 143
 144 #define MAXIMUM_VOLUME_LABEL_LENGTH       (32 * sizeof(WCHAR))
 145
 146 typedef struct _VPB {
 147   CSHORT  Type;
 148   CSHORT  Size;
 149   USHORT  Flags;
 150   USHORT  VolumeLabelLength;
 151   struct _DEVICE_OBJECT  *DeviceObject;
 152   struct _DEVICE_OBJECT  *RealDevice;
 153   ULONG  SerialNumber;
 154   ULONG  ReferenceCount;
 155   WCHAR  VolumeLabel[MAXIMUM_VOLUME_LABEL_LENGTH / sizeof(WCHAR)];
 156 } VPB, *PVPB;
 157
 158 typedef enum _POOL_TYPE {
 159   NonPagedPool,
 160   PagedPool,
 161   NonPagedPoolMustSucceed,
 162   UnkownType,
 163   NonPagedPoolCacheAligned,
 164   PagedPoolCacheAligned,
 165   NonPagedPoolCacheAlignedMustS,
 166   MaxPoolType
 167 } POOL_TYPE;
 168
 169 typedef struct _WAIT_CONTEXT_BLOCK {
 170   KDEVICE_QUEUE_ENTRY  WaitQueueEntry;
 171   struct _DRIVER_CONTROL  *DeviceRoutine;
 172   PVOID  DeviceContext;
 173   ULONG  NumberOfMapRegisters;
 174   PVOID  DeviceObject;
 175   PVOID  CurrentIrp;
 176   PKDPC  BufferChainingDpc;
 177 } WAIT_CONTEXT_BLOCK, *PWAIT_CONTEXT_BLOCK;
 178
 179 #define DO_BUFFERED_IO                  0x00000004
 180 #define DO_EXCLUSIVE                    0x00000008
 181 #define DO_DIRECT_IO                    0x00000010
 182 #define DO_MAP_IO_BUFFER                0x00000020
 183 #define DO_DEVICE_INITIALIZING          0x00000080
 184 #define DO_SHUTDOWN_REGISTERED          0x00000800
 185 #define DO_BUS_ENUMERATED_DEVICE        0x00001000
 186 #define DO_POWER_PAGABLE                0x00002000
 187 #define DO_POWER_INRUSH                 0x00004000
 188
 189 #define IO_NO_INCREMENT                     0
 190 #define IO_CD_ROM_INCREMENT                 1
 191 #define IO_DISK_INCREMENT                   1
 192 #define IO_KEYBOARD_INCREMENT               6
 193 #define IO_MAILSLOT_INCREMENT               2
 194 #define IO_MOUSE_INCREMENT                  6
 195 #define IO_NAMED_PIPE_INCREMENT             2
 196 #define IO_NETWORK_INCREMENT                2
 197 #define IO_PARALLEL_INCREMENT               1
 198 #define IO_SERIAL_INCREMENT                 2
 199 #define IO_SOUND_INCREMENT                  8
 200 #define IO_VIDEO_INCREMENT                  1
 201
 202 #ifndef DEVICE_TYPE
 203 #define DEVICE_TYPE ULONG
 204 #endif
 205 #define IRP_MJ_MAXIMUM_FUNCTION           0x1b
 206 #define IRP_MJ_CREATE                     0x00
 207 #define IRP_MJ_CREATE_NAMED_PIPE          0x01
 208 #define IRP_MJ_CLOSE                      0x02
 209 #define IRP_MJ_READ                       0x03
 210 #define IRP_MJ_WRITE                      0x04
 211 #define IRP_MJ_QUERY_INFORMATION          0x05
 212 #define IRP_MJ_SET_INFORMATION            0x06
 213 #define IRP_MJ_QUERY_EA                   0x07
 214 #define IRP_MJ_SET_EA                     0x08
 215 #define IRP_MJ_FLUSH_BUFFERS              0x09
 216 #define IRP_MJ_QUERY_VOLUME_INFORMATION   0x0a
 217 #define IRP_MJ_SET_VOLUME_INFORMATION     0x0b
 218 #define IRP_MJ_DIRECTORY_CONTROL          0x0c
 219 #define IRP_MJ_FILE_SYSTEM_CONTROL        0x0d
 220 #define IRP_MJ_DEVICE_CONTROL             0x0e
 221 #define IRP_MJ_INTERNAL_DEVICE_CONTROL    0x0f
 222 #define IRP_MJ_SHUTDOWN                   0x10
 223 #define IRP_MJ_LOCK_CONTROL               0x11
 224 #define IRP_MJ_CLEANUP                    0x12
 225 #define IRP_MJ_CREATE_MAILSLOT            0x13
 226 #define IRP_MJ_QUERY_SECURITY             0x14
 227 #define IRP_MJ_SET_SECURITY               0x15
 228 #define IRP_MJ_POWER                      0x16
 229 #define IRP_MJ_SYSTEM_CONTROL             0x17
 230 #define IRP_MJ_DEVICE_CHANGE              0x18
 231 #define IRP_MJ_QUERY_QUOTA                0x19
 232 #define IRP_MJ_SET_QUOTA                  0x1a
 233 #define IRP_MJ_PNP                        0x1b
 234
 235 #define IRP_MN_START_DEVICE                 0x00
 236 #define IRP_MN_QUERY_REMOVE_DEVICE          0x01
 237 #define IRP_MN_REMOVE_DEVICE                0x02
 238 #define IRP_MN_CANCEL_REMOVE_DEVICE         0x03
 239 #define IRP_MN_STOP_DEVICE                  0x04
 240 #define IRP_MN_QUERY_STOP_DEVICE            0x05
 241 #define IRP_MN_CANCEL_STOP_DEVICE           0x06
 242 #define IRP_MN_QUERY_DEVICE_RELATIONS       0x07
 243 #define IRP_MN_QUERY_INTERFACE              0x08
 244 #define IRP_MN_QUERY_CAPABILITIES           0x09
 245 #define IRP_MN_QUERY_RESOURCES              0x0A
 246 #define IRP_MN_QUERY_RESOURCE_REQUIREMENTS  0x0B
 247 #define IRP_MN_QUERY_DEVICE_TEXT            0x0C
 248 #define IRP_MN_FILTER_RESOURCE_REQUIREMENTS 0x0D
 249 #define IRP_MN_READ_CONFIG                  0x0F
 250 #define IRP_MN_WRITE_CONFIG                 0x10
 251 #define IRP_MN_EJECT                        0x11
 252 #define IRP_MN_SET_LOCK                     0x12
 253 #define IRP_MN_QUERY_ID                     0x13
 254 #define IRP_MN_QUERY_PNP_DEVICE_STATE       0x14
 255 #define IRP_MN_QUERY_BUS_INFORMATION        0x15
 256 #define IRP_MN_DEVICE_USAGE_NOTIFICATION    0x16
 257 #define IRP_MN_SURPRISE_REMOVAL             0x17
 258
 259 #define IRP_QUOTA_CHARGED               0x01
 260 #define IRP_ALLOCATED_MUST_SUCCEED      0x02
 261 #define IRP_ALLOCATED_FIXED_SIZE        0x04
 262 #define IRP_LOOKASIDE_ALLOCATION        0x08
 263
 264 #define IO_TYPE_ADAPTER                 0x01
 265 #define IO_TYPE_CONTROLLER              0x02
 266 #define IO_TYPE_DEVICE                  0x03
 267 #define IO_TYPE_DRIVER                  0x04
 268 #define IO_TYPE_FILE                    0x05
 269 #define IO_TYPE_IRP                     0x06
 270 #define IO_TYPE_MASTER_ADAPTER          0x07
 271 #define IO_TYPE_OPEN_PACKET             0x08
 272 #define IO_TYPE_TIMER                   0x09
 273 #define IO_TYPE_VPB                     0x0a
 274 #define IO_TYPE_ERROR_LOG               0x0b
 275 #define IO_TYPE_ERROR_MESSAGE           0x0c
 276 #define IO_TYPE_DEVICE_OBJECT_EXTENSION 0x0d
 277
 278 typedef struct _DEVICE_OBJECT {
 279   CSHORT  Type;
 280   USHORT  Size;
 281   LONG  ReferenceCount;
 282   struct _DRIVER_OBJECT  *DriverObject;
 283   struct _DEVICE_OBJECT  *NextDevice;
 284   struct _DEVICE_OBJECT  *AttachedDevice;
 285   struct _IRP  *CurrentIrp;
 286   PIO_TIMER  Timer;
 287   ULONG  Flags;
 288   ULONG  Characteristics;
 289   PVPB  Vpb;
 290   PVOID  DeviceExtension;
 291   DEVICE_TYPE  DeviceType;
 292   CCHAR  StackSize;
 293   union {
 294     LIST_ENTRY  ListEntry;
 295     WAIT_CONTEXT_BLOCK  Wcb;
 296   } Queue;
 297   ULONG  AlignmentRequirement;
 298   KDEVICE_QUEUE  DeviceQueue;
 299   KDPC  Dpc;
 300   ULONG  ActiveThreadCount;
 301   PSECURITY_DESCRIPTOR  SecurityDescriptor;
 302   KEVENT  DeviceLock;
 303   USHORT  SectorSize;
 304   USHORT  Spare1;
 305   struct _DEVOBJ_EXTENSION  *DeviceObjectExtension;
 306   PVOID  Reserved;
 307 } DEVICE_OBJECT;
 308 typedef struct _DEVICE_OBJECT *PDEVICE_OBJECT;
 309
 310 typedef struct _DRIVER_EXTENSION {
 311   struct _DRIVER_OBJECT  *DriverObject;
 312   PVOID  AddDevice;
 313   ULONG  Count;
 314   UNICODE_STRING  ServiceKeyName;
 315 } DRIVER_EXTENSION, *PDRIVER_EXTENSION;
 316
 317 typedef struct _DRIVER_OBJECT {
 318   CSHORT  Type;
 319   CSHORT  Size;
 320   PDEVICE_OBJECT  DeviceObject;
 321   ULONG  Flags;
 322   PVOID  DriverStart;
 323   ULONG  DriverSize;
 324   PVOID  DriverSection;
 325   PDRIVER_EXTENSION  DriverExtension;
 326   UNICODE_STRING  DriverName;
 327   PUNICODE_STRING  HardwareDatabase;
 328   PVOID  FastIoDispatch;
 329   PDRIVER_INITIALIZE DriverInit;
 330   PDRIVER_STARTIO    DriverStartIo;
 331   PDRIVER_UNLOAD     DriverUnload;
 332   PDRIVER_DISPATCH   MajorFunction[IRP_MJ_MAXIMUM_FUNCTION + 1];
 333 } DRIVER_OBJECT;
 334 typedef struct _DRIVER_OBJECT *PDRIVER_OBJECT;
 335
 336 /* Irp definitions */
 337 typedef UCHAR KIRQL, *PKIRQL;
 338 typedef CCHAR KPROCESSOR_MODE;
 339
 340 typedef VOID (WINAPI *PDRIVER_CANCEL)(
 341   IN struct _DEVICE_OBJECT  *DeviceObject,
 342   IN struct _IRP  *Irp);
 343
 344 typedef VOID (WINAPI *PKNORMAL_ROUTINE)(
 345   IN PVOID  NormalContext,
 346   IN PVOID  SystemArgument1,
 347   IN PVOID  SystemArgument2);
 348
 349 typedef VOID (WINAPI *PKKERNEL_ROUTINE)(
 350   IN struct _KAPC  *Apc,
 351   IN OUT PKNORMAL_ROUTINE  *NormalRoutine,
 352   IN OUT PVOID  *NormalContext,
 353   IN OUT PVOID  *SystemArgument1,
 354   IN OUT PVOID  *SystemArgument2);
 355
 356 typedef VOID (WINAPI *PKRUNDOWN_ROUTINE)(
 357   IN struct _KAPC  *Apc);
 358
 359 typedef struct _KAPC {
 360   CSHORT  Type;
 361   CSHORT  Size;
 362   ULONG  Spare0;
 363   struct _KTHREAD  *Thread;
 364   LIST_ENTRY  ApcListEntry;
 365   PKKERNEL_ROUTINE  KernelRoutine;
 366   PKRUNDOWN_ROUTINE  RundownRoutine;
 367   PKNORMAL_ROUTINE  NormalRoutine;
 368   PVOID  NormalContext;
 369   PVOID  SystemArgument1;
 370   PVOID  SystemArgument2;
 371   CCHAR  ApcStateIndex;
 372   KPROCESSOR_MODE  ApcMode;
 373   BOOLEAN  Inserted;
 374 } KAPC, *PKAPC, *RESTRICTED_POINTER PRKAPC;
 375
 376 #include <pshpack1.h>
 377 typedef struct _IRP {
 378   CSHORT  Type;
 379   USHORT  Size;
 380   struct _MDL  *MdlAddress;
 381   ULONG  Flags;
 382   union {
 383     struct _IRP  *MasterIrp;
 384     LONG  IrpCount;
 385     PVOID  SystemBuffer;
 386   } AssociatedIrp;
 387   LIST_ENTRY  ThreadListEntry;
 388   IO_STATUS_BLOCK  IoStatus;
 389   KPROCESSOR_MODE  RequestorMode;
 390   BOOLEAN  PendingReturned;
 391   CHAR  StackCount;
 392   CHAR  CurrentLocation;
 393   BOOLEAN  Cancel;
 394   KIRQL  CancelIrql;
 395   CCHAR  ApcEnvironment;
 396   UCHAR  AllocationFlags;
 397   PIO_STATUS_BLOCK  UserIosb;
 398   PKEVENT  UserEvent;
 399   union {
 400     struct {
 401       PIO_APC_ROUTINE  UserApcRoutine;
 402       PVOID  UserApcContext;
 403     } AsynchronousParameters;
 404     LARGE_INTEGER  AllocationSize;
 405   } Overlay;
 406   PDRIVER_CANCEL  CancelRoutine;
 407   PVOID  UserBuffer;
 408   union {
 409     struct {
 410        union {
 411         KDEVICE_QUEUE_ENTRY  DeviceQueueEntry;
 412         struct {
 413           PVOID  DriverContext[4];
 414         } DUMMYSTRUCTNAME;
 415       } DUMMYUNIONNAME;
 416       PETHREAD  Thread;
 417       PCHAR  AuxiliaryBuffer;
 418       struct {
 419         LIST_ENTRY  ListEntry;
 420         union {
 421           struct _IO_STACK_LOCATION  *CurrentStackLocation;
 422           ULONG  PacketType;
 423         } DUMMYUNIONNAME;
 424       } DUMMYSTRUCTNAME;
 425       struct _FILE_OBJECT  *OriginalFileObject;
 426     } Overlay;
 427     KAPC  Apc;
 428     PVOID  CompletionKey;
 429   } Tail;
 430 } IRP;
 431 typedef struct _IRP *PIRP;
 432 #include <poppack.h>
 433
 434 /* MDL definitions */
 435
 436 typedef VOID (WINAPI *PINTERFACE_REFERENCE)(
 437   PVOID  Context);
 438
 439 typedef VOID (WINAPI *PINTERFACE_DEREFERENCE)(
 440   PVOID Context);
 441
 442 typedef struct _INTERFACE {
 443   USHORT  Size;
 444   USHORT  Version;
 445   PVOID  Context;
 446   PINTERFACE_REFERENCE  InterfaceReference;
 447   PINTERFACE_DEREFERENCE  InterfaceDereference;
 448 } INTERFACE, *PINTERFACE;
 449
 450 typedef struct _SECTION_OBJECT_POINTERS {
 451   PVOID  DataSectionObject;
 452   PVOID  SharedCacheMap;
 453   PVOID  ImageSectionObject;
 454 } SECTION_OBJECT_POINTERS, *PSECTION_OBJECT_POINTERS;
 455
 456 typedef struct _IO_COMPLETION_CONTEXT {
 457   PVOID  Port;
 458   PVOID  Key;
 459 } IO_COMPLETION_CONTEXT, *PIO_COMPLETION_CONTEXT;
 460
 461 typedef enum _DEVICE_RELATION_TYPE {
 462   BusRelations,
 463   EjectionRelations,
 464   PowerRelations,
 465   RemovalRelations,
 466   TargetDeviceRelation,
 467   SingleBusRelations
 468 } DEVICE_RELATION_TYPE, *PDEVICE_RELATION_TYPE;
 469
 470 typedef struct _FILE_OBJECT {
 471   CSHORT  Type;
 472   CSHORT  Size;
 473   PDEVICE_OBJECT  DeviceObject;
 474   PVPB  Vpb;
 475   PVOID  FsContext;
 476   PVOID  FsContext2;
 477   PSECTION_OBJECT_POINTERS  SectionObjectPointer;
 478   PVOID  PrivateCacheMap;
 479   NTSTATUS  FinalStatus;
 480   struct _FILE_OBJECT  *RelatedFileObject;
 481   BOOLEAN  LockOperation;
 482   BOOLEAN  DeletePending;
 483   BOOLEAN  ReadAccess;
 484   BOOLEAN  WriteAccess;
 485   BOOLEAN  DeleteAccess;
 486   BOOLEAN  SharedRead;
 487   BOOLEAN  SharedWrite;
 488   BOOLEAN  SharedDelete;
 489   ULONG  Flags;
 490   UNICODE_STRING  FileName;
 491   LARGE_INTEGER  CurrentByteOffset;
 492   ULONG  Waiters;
 493   ULONG  Busy;
 494   PVOID  LastLock;
 495   KEVENT  Lock;
 496   KEVENT  Event;
 497   PIO_COMPLETION_CONTEXT  CompletionContext;
 498 } FILE_OBJECT;
 499 typedef struct _FILE_OBJECT *PFILE_OBJECT;
 500
 501 #define INITIAL_PRIVILEGE_COUNT           3
 502
 503 typedef struct _INITIAL_PRIVILEGE_SET {
 504   ULONG  PrivilegeCount;
 505   ULONG  Control;
 506   LUID_AND_ATTRIBUTES  Privilege[INITIAL_PRIVILEGE_COUNT];
 507 } INITIAL_PRIVILEGE_SET, * PINITIAL_PRIVILEGE_SET;
 508
 509 typedef struct _SECURITY_SUBJECT_CONTEXT {
 510   PACCESS_TOKEN  ClientToken;
 511   SECURITY_IMPERSONATION_LEVEL  ImpersonationLevel;
 512   PACCESS_TOKEN  PrimaryToken;
 513   PVOID  ProcessAuditId;
 514 } SECURITY_SUBJECT_CONTEXT, *PSECURITY_SUBJECT_CONTEXT;
 515
 516 typedef struct _ACCESS_STATE {
 517   LUID  OperationID;
 518   BOOLEAN  SecurityEvaluated;
 519   BOOLEAN  GenerateAudit;
 520   BOOLEAN  GenerateOnClose;
 521   BOOLEAN  PrivilegesAllocated;
 522   ULONG  Flags;
 523   ACCESS_MASK  RemainingDesiredAccess;
 524   ACCESS_MASK  PreviouslyGrantedAccess;
 525   ACCESS_MASK  OriginalDesiredAccess;
 526   SECURITY_SUBJECT_CONTEXT  SubjectSecurityContext;
 527   PSECURITY_DESCRIPTOR  SecurityDescriptor;
 528   PVOID  AuxData;
 529   union {
 530     INITIAL_PRIVILEGE_SET  InitialPrivilegeSet;
 531     PRIVILEGE_SET  PrivilegeSet;
 532   } Privileges;
 533
 534   BOOLEAN  AuditPrivileges;
 535   UNICODE_STRING  ObjectName;
 536   UNICODE_STRING  ObjectTypeName;
 537 } ACCESS_STATE, *PACCESS_STATE;
 538
 539 typedef struct _IO_SECURITY_CONTEXT {
 540   PSECURITY_QUALITY_OF_SERVICE  SecurityQos;
 541   PACCESS_STATE  AccessState;
 542   ACCESS_MASK  DesiredAccess;
 543   ULONG  FullCreateOptions;
 544 } IO_SECURITY_CONTEXT, *PIO_SECURITY_CONTEXT;
 545
 546 typedef struct _DEVICE_CAPABILITIES {
 547   USHORT  Size;
 548   USHORT  Version;
 549   ULONG  DeviceD1 : 1;
 550   ULONG  DeviceD2 : 1;
 551   ULONG  LockSupported : 1;
 552   ULONG  EjectSupported : 1;
 553   ULONG  Removable : 1;
 554   ULONG  DockDevice : 1;
 555   ULONG  UniqueID : 1;
 556   ULONG  SilentInstall : 1;
 557   ULONG  RawDeviceOK : 1;
 558   ULONG  SurpriseRemovalOK : 1;
 559   ULONG  WakeFromD0 : 1;
 560   ULONG  WakeFromD1 : 1;
 561   ULONG  WakeFromD2 : 1;
 562   ULONG  WakeFromD3 : 1;
 563   ULONG  HardwareDisabled : 1;
 564   ULONG  NonDynamic : 1;
 565   ULONG  WarmEjectSupported : 1;
 566   ULONG  NoDisplayInUI : 1;
 567   ULONG  Reserved : 14;
 568   ULONG  Address;
 569   ULONG  UINumber;
 570   DEVICE_POWER_STATE  DeviceState[PowerSystemMaximum];
 571   SYSTEM_POWER_STATE  SystemWake;
 572   DEVICE_POWER_STATE  DeviceWake;
 573   ULONG  D1Latency;
 574   ULONG  D2Latency;
 575   ULONG  D3Latency;
 576 } DEVICE_CAPABILITIES, *PDEVICE_CAPABILITIES;
 577
 578 typedef enum _INTERFACE_TYPE {
 579   InterfaceTypeUndefined = -1,
 580   Internal,
 581   Isa,
 582   Eisa,
 583   MicroChannel,
 584   TurboChannel,
 585   PCIBus,
 586   VMEBus,
 587   NuBus,
 588   PCMCIABus,
 589   CBus,
 590   MPIBus,
 591   MPSABus,
 592   ProcessorInternal,
 593   InternalPowerBus,
 594   PNPISABus,
 595   PNPBus,
 596   MaximumInterfaceType
 597 } INTERFACE_TYPE, *PINTERFACE_TYPE;
 598
 599 typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS;
 600
 601 #define IO_RESOURCE_PREFERRED             0x01
 602 #define IO_RESOURCE_DEFAULT               0x02
 603 #define IO_RESOURCE_ALTERNATIVE           0x08
 604
 605 typedef struct _IO_RESOURCE_DESCRIPTOR {
 606   UCHAR  Option;
 607   UCHAR  Type;
 608   UCHAR  ShareDisposition;
 609   UCHAR  Spare1;
 610   USHORT  Flags;
 611   USHORT  Spare2;
 612   union {
 613     struct {
 614       ULONG  Length;
 615       ULONG  Alignment;
 616       PHYSICAL_ADDRESS  MinimumAddress;
 617       PHYSICAL_ADDRESS  MaximumAddress;
 618     } Port;
 619     struct {
 620       ULONG  Length;
 621       ULONG  Alignment;
 622       PHYSICAL_ADDRESS  MinimumAddress;
 623       PHYSICAL_ADDRESS  MaximumAddress;
 624     } Memory;
 625     struct {
 626       ULONG  MinimumVector;
 627       ULONG  MaximumVector;
 628     } Interrupt;
 629     struct {
 630       ULONG  MinimumChannel;
 631       ULONG  MaximumChannel;
 632     } Dma;
 633     struct {
 634       ULONG  Length;
 635       ULONG  Alignment;
 636       PHYSICAL_ADDRESS  MinimumAddress;
 637       PHYSICAL_ADDRESS  MaximumAddress;
 638     } Generic;
 639     struct {
 640       ULONG  Data[3];
 641     } DevicePrivate;
 642     struct {
 643       ULONG  Length;
 644       ULONG  MinBusNumber;
 645       ULONG  MaxBusNumber;
 646       ULONG  Reserved;
 647     } BusNumber;
 648     struct {
 649       ULONG  Priority;
 650       ULONG  Reserved1;
 651       ULONG  Reserved2;
 652     } ConfigData;
 653   } u;
 654 } IO_RESOURCE_DESCRIPTOR, *PIO_RESOURCE_DESCRIPTOR;
 655
 656 typedef struct _IO_RESOURCE_LIST {
 657   USHORT  Version;
 658   USHORT  Revision;
 659   ULONG  Count;
 660   IO_RESOURCE_DESCRIPTOR  Descriptors[1];
 661 } IO_RESOURCE_LIST, *PIO_RESOURCE_LIST;
 662
 663 typedef struct _IO_RESOURCE_REQUIREMENTS_LIST {
 664   ULONG  ListSize;
 665   INTERFACE_TYPE  InterfaceType;
 666   ULONG  BusNumber;
 667   ULONG  SlotNumber;
 668   ULONG  Reserved[3];
 669   ULONG  AlternativeLists;
 670   IO_RESOURCE_LIST  List[1];
 671 } IO_RESOURCE_REQUIREMENTS_LIST, *PIO_RESOURCE_REQUIREMENTS_LIST;
 672
 673 typedef enum _BUS_QUERY_ID_TYPE {
 674   BusQueryDeviceID,
 675   BusQueryHardwareIDs,
 676   BusQueryCompatibleIDs,
 677   BusQueryInstanceID,
 678   BusQueryDeviceSerialNumber
 679 } BUS_QUERY_ID_TYPE, *PBUS_QUERY_ID_TYPE;
 680
 681 typedef enum _DEVICE_TEXT_TYPE {
 682   DeviceTextDescription,
 683   DeviceTextLocationInformation
 684 } DEVICE_TEXT_TYPE, *PDEVICE_TEXT_TYPE;
 685
 686 typedef enum _DEVICE_USAGE_NOTIFICATION_TYPE {
 687   DeviceUsageTypeUndefined,
 688   DeviceUsageTypePaging,
 689   DeviceUsageTypeHibernation,
 690   DeviceUsageTypeDumpFile
 691 } DEVICE_USAGE_NOTIFICATION_TYPE;
 692
 693 typedef struct _POWER_SEQUENCE {
 694   ULONG  SequenceD1;
 695   ULONG  SequenceD2;
 696   ULONG  SequenceD3;
 697 } POWER_SEQUENCE, *PPOWER_SEQUENCE;
 698
 699 typedef enum _POWER_STATE_TYPE {
 700   SystemPowerState,
 701   DevicePowerState
 702 } POWER_STATE_TYPE, *PPOWER_STATE_TYPE;
 703
 704 typedef union _POWER_STATE {
 705   SYSTEM_POWER_STATE  SystemState;
 706   DEVICE_POWER_STATE  DeviceState;
 707 } POWER_STATE, *PPOWER_STATE;
 708
 709 typedef struct _CM_PARTIAL_RESOURCE_DESCRIPTOR {
 710   UCHAR Type;
 711   UCHAR ShareDisposition;
 712   USHORT Flags;
 713   union {
 714     struct {
 715       PHYSICAL_ADDRESS Start;
 716       ULONG Length;
 717     } Generic;
 718     struct {
 719       PHYSICAL_ADDRESS Start;
 720       ULONG Length;
 721     } Port;
 722     struct {
 723       ULONG Level;
 724       ULONG Vector;
 725       ULONG Affinity;
 726     } Interrupt;
 727     struct {
 728       PHYSICAL_ADDRESS Start;
 729       ULONG Length;
 730     } Memory;
 731     struct {
 732       ULONG Channel;
 733       ULONG Port;
 734       ULONG Reserved1;
 735     } Dma;
 736     struct {
 737       ULONG Data[3];
 738     } DevicePrivate;
 739     struct {
 740       ULONG Start;
 741       ULONG Length;
 742       ULONG Reserved;
 743     } BusNumber;
 744     struct {
 745       ULONG DataSize;
 746       ULONG Reserved1;
 747       ULONG Reserved2;
 748     } DeviceSpecificData;
 749   } u;
 750 } CM_PARTIAL_RESOURCE_DESCRIPTOR, *PCM_PARTIAL_RESOURCE_DESCRIPTOR;
 751
 752 typedef struct _CM_PARTIAL_RESOURCE_LIST {
 753   USHORT  Version;
 754   USHORT  Revision;
 755   ULONG  Count;
 756   CM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptors[1];
 757 } CM_PARTIAL_RESOURCE_LIST, *PCM_PARTIAL_RESOURCE_LIST;
 758
 759 typedef struct _CM_FULL_RESOURCE_DESCRIPTOR {
 760   INTERFACE_TYPE  InterfaceType;
 761   ULONG  BusNumber;
 762   CM_PARTIAL_RESOURCE_LIST  PartialResourceList;
 763 } CM_FULL_RESOURCE_DESCRIPTOR, *PCM_FULL_RESOURCE_DESCRIPTOR;
 764
 765 typedef struct _CM_RESOURCE_LIST {
 766   ULONG  Count;
 767   CM_FULL_RESOURCE_DESCRIPTOR  List[1];
 768 } CM_RESOURCE_LIST, *PCM_RESOURCE_LIST;
 769
 770 typedef NTSTATUS (WINAPI *PIO_COMPLETION_ROUTINE)(
 771   IN struct _DEVICE_OBJECT  *DeviceObject,
 772   IN struct _IRP  *Irp,
 773   IN PVOID  Context);
 774
 775 #define SL_PENDING_RETURNED             0x01
 776 #define SL_INVOKE_ON_CANCEL             0x20
 777 #define SL_INVOKE_ON_SUCCESS            0x40
 778 #define SL_INVOKE_ON_ERROR              0x80
 779
 780 #include <pshpack1.h>
 781 typedef struct _IO_STACK_LOCATION {
 782   UCHAR  MajorFunction;
 783   UCHAR  MinorFunction;
 784   UCHAR  Flags;
 785   UCHAR  Control;
 786   union {
 787     struct {
 788       PIO_SECURITY_CONTEXT  SecurityContext;
 789       ULONG  Options;
 790       USHORT POINTER_ALIGNMENT  FileAttributes;
 791       USHORT  ShareAccess;
 792       ULONG POINTER_ALIGNMENT  EaLength;
 793     } Create;
 794     struct {
 795       ULONG  Length;
 796       ULONG POINTER_ALIGNMENT  Key;
 797       LARGE_INTEGER  ByteOffset;
 798     } Read;
 799     struct {
 800       ULONG  Length;
 801       ULONG POINTER_ALIGNMENT  Key;
 802       LARGE_INTEGER  ByteOffset;
 803     } Write;
 804     struct {
 805       ULONG  Length;
 806       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 807     } QueryFile;
 808     struct {
 809       ULONG  Length;
 810       FILE_INFORMATION_CLASS POINTER_ALIGNMENT  FileInformationClass;
 811       PFILE_OBJECT  FileObject;
 812       union {
 813         struct {
 814           BOOLEAN  ReplaceIfExists;
 815           BOOLEAN  AdvanceOnly;
 816         } DUMMYSTRUCTNAME;
 817         ULONG  ClusterCount;
 818         HANDLE  DeleteHandle;
 819       } DUMMYUNIONNAME;
 820     } SetFile;
 821     struct {
 822       ULONG  Length;
 823       FS_INFORMATION_CLASS POINTER_ALIGNMENT  FsInformationClass;
 824     } QueryVolume;
 825     struct {
 826       ULONG  OutputBufferLength;
 827       ULONG POINTER_ALIGNMENT  InputBufferLength;
 828       ULONG POINTER_ALIGNMENT  IoControlCode;
 829       PVOID  Type3InputBuffer;
 830     } DeviceIoControl;
 831     struct {
 832       SECURITY_INFORMATION  SecurityInformation;
 833       ULONG POINTER_ALIGNMENT  Length;
 834     } QuerySecurity;
 835     struct {
 836       SECURITY_INFORMATION  SecurityInformation;
 837       PSECURITY_DESCRIPTOR  SecurityDescriptor;
 838     } SetSecurity;
 839     struct {
 840       PVPB  Vpb;
 841       PDEVICE_OBJECT  DeviceObject;
 842     } MountVolume;
 843     struct {
 844       PVPB  Vpb;
 845       PDEVICE_OBJECT  DeviceObject;
 846     } VerifyVolume;
 847     struct {
 848       struct _SCSI_REQUEST_BLOCK  *Srb;
 849     } Scsi;
 850     struct {
 851       DEVICE_RELATION_TYPE  Type;
 852     } QueryDeviceRelations;
 853     struct {
 854       CONST GUID  *InterfaceType;
 855       USHORT  Size;
 856       USHORT  Version;
 857       PINTERFACE  Interface;
 858       PVOID  InterfaceSpecificData;
 859     } QueryInterface;
 860     struct {
 861       PDEVICE_CAPABILITIES  Capabilities;
 862     } DeviceCapabilities;
 863     struct {
 864       PIO_RESOURCE_REQUIREMENTS_LIST  IoResourceRequirementList;
 865     } FilterResourceRequirements;
 866     struct {
 867       ULONG  WhichSpace;
 868       PVOID  Buffer;
 869       ULONG  Offset;
 870       ULONG POINTER_ALIGNMENT  Length;
 871     } ReadWriteConfig;
 872     struct {
 873       BOOLEAN  Lock;
 874     } SetLock;
 875     struct {
 876       BUS_QUERY_ID_TYPE  IdType;
 877     } QueryId;
 878     struct {
 879       DEVICE_TEXT_TYPE  DeviceTextType;
 880       LCID POINTER_ALIGNMENT  LocaleId;
 881     } QueryDeviceText;
 882     struct {
 883       BOOLEAN  InPath;
 884       BOOLEAN  Reserved[3];
 885       DEVICE_USAGE_NOTIFICATION_TYPE POINTER_ALIGNMENT  Type;
 886     } UsageNotification;
 887     struct {
 888       SYSTEM_POWER_STATE  PowerState;
 889     } WaitWake;
 890     struct {
 891       PPOWER_SEQUENCE  PowerSequence;
 892     } PowerSequence;
 893     struct {
 894       ULONG  SystemContext;
 895       POWER_STATE_TYPE POINTER_ALIGNMENT  Type;
 896       POWER_STATE POINTER_ALIGNMENT  State;
 897       POWER_ACTION POINTER_ALIGNMENT  ShutdownType;
 898     } Power;
 899     struct {
 900       PCM_RESOURCE_LIST  AllocatedResources;
 901       PCM_RESOURCE_LIST  AllocatedResourcesTranslated;
 902     } StartDevice;
 903     struct {
 904       ULONG_PTR  ProviderId;
 905       PVOID  DataPath;
 906       ULONG  BufferSize;
 907       PVOID  Buffer;
 908     } WMI;
 909     struct {
 910       PVOID  Argument1;
 911       PVOID  Argument2;
 912       PVOID  Argument3;
 913       PVOID  Argument4;
 914     } Others;
 915   } Parameters;
 916   PDEVICE_OBJECT  DeviceObject;
 917   PFILE_OBJECT  FileObject;
 918   PIO_COMPLETION_ROUTINE  CompletionRoutine;
 919   PVOID  Context;
 920 } IO_STACK_LOCATION, *PIO_STACK_LOCATION;
 921 #include <poppack.h>
 922
 923 typedef struct _MDL {
 924   struct _MDL  *Next;
 925   CSHORT  Size;
 926   CSHORT  MdlFlags;
 927   struct _EPROCESS  *Process;
 928   PVOID  MappedSystemVa;
 929   PVOID  StartVa;
 930   ULONG  ByteCount;
 931   ULONG  ByteOffset;
 932 } MDL, *PMDL;
 933
 934 typedef struct _KTIMER {
 935     DISPATCHER_HEADER Header;
 936     ULARGE_INTEGER DueTime;
 937     LIST_ENTRY TimerListEntry;
 938     struct _KDPC *Dpc;
 939     LONG Period;
 940 } KTIMER, *PKTIMER;
 941
 942 typedef struct _KSYSTEM_TIME {
 943     ULONG LowPart;
 944     LONG High1Time;
 945     LONG High2Time;
 946 } KSYSTEM_TIME, *PKSYSTEM_TIME;
 947
 948 typedef enum _NT_PRODUCT_TYPE {
 949     NtProductWinNt = 1,
 950     NtProductLanManNt,
 951     NtProductServer
 952 } NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
 953
 954 #define PROCESSOR_FEATURE_MAX 64
 955
 956 typedef enum _ALTERNATIVE_ARCHITECTURE_TYPE
 957 {
 958    StandardDesign,
 959    NEC98x86,
 960    EndAlternatives
 961 } ALTERNATIVE_ARCHITECTURE_TYPE;
 962
 963 typedef struct _KUSER_SHARED_DATA {
 964     ULONG TickCountLowDeprecated;
 965     ULONG TickCountMultiplier;
 966     volatile KSYSTEM_TIME InterruptTime;
 967     volatile KSYSTEM_TIME SystemTime;
 968     volatile KSYSTEM_TIME TimeZoneBias;
 969     USHORT ImageNumberLow;
 970     USHORT ImageNumberHigh;
 971     WCHAR NtSystemRoot[260];
 972     ULONG MaxStckTraceDepth;
 973     ULONG CryptoExponent;
 974     ULONG TimeZoneId;
 975     ULONG LargePageMinimum;
 976     ULONG Reserverd2[7];
 977     NT_PRODUCT_TYPE NtProductType;
 978     BOOLEAN ProductTypeIsValid;
 979     ULONG MajorNtVersion;
 980     ULONG MinorNtVersion;
 981     BOOLEAN ProcessorFeatures[PROCESSOR_FEATURE_MAX];
 982     ULONG Reserved1;
 983     ULONG Reserved3;
 984     volatile ULONG TimeSlip;
 985     ALTERNATIVE_ARCHITECTURE_TYPE AlternativeArchitecture;
 986     LARGE_INTEGER SystemExpirationDate;
 987     ULONG SuiteMask;
 988     BOOLEAN KdDebuggerEnabled;
 989     volatile ULONG ActiveConsoleId;
 990     volatile ULONG DismountCount;
 991     ULONG ComPlusPackage;
 992     ULONG LastSystemRITEventTickCount;
 993     ULONG NumberOfPhysicalPages;
 994     BOOLEAN SafeBootMode;
 995     ULONG TraceLogging;
 996     ULONGLONG Fill0;
 997     ULONGLONG SystemCall[4];
 998     union {
 999         volatile KSYSTEM_TIME TickCount;
1000         volatile ULONG64 TickCountQuad;
1001     } DUMMYUNIONNAME;
1002 } KSHARED_USER_DATA, *PKSHARED_USER_DATA;
1003
1004 NTSTATUS WINAPI ObCloseHandle(IN HANDLE handle);
1005
1006 #define IoGetCurrentIrpStackLocation(_Irp) ((_Irp)->Tail.Overlay.CurrentStackLocation)
1007
1008 #define KernelMode 0
1009 #define UserMode   1
1010
1011 /* directory object access rights */
1012 #define DIRECTORY_QUERY                 0x0001
1013 #define DIRECTORY_TRAVERSE              0x0002
1014 #define DIRECTORY_CREATE_OBJECT         0x0004
1015 #define DIRECTORY_CREATE_SUBDIRECTORY   0x0008
1016 #define DIRECTORY_ALL_ACCESS            (STANDARD_RIGHTS_REQUIRED | 0xF)
1017
1018 /* symbolic link access rights */
1019 #define SYMBOLIC_LINK_QUERY             0x0001
1020 #define SYMBOLIC_LINK_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | 0x1)
1021
1022 PVOID     WINAPI ExAllocatePool(POOL_TYPE,SIZE_T);
1023 PVOID     WINAPI ExAllocatePoolWithQuota(POOL_TYPE,SIZE_T);
1024 PVOID     WINAPI ExAllocatePoolWithTag(POOL_TYPE,SIZE_T,ULONG);
1025 PVOID     WINAPI ExAllocatePoolWithQuotaTag(POOL_TYPE,SIZE_T,ULONG);
1026 void      WINAPI ExFreePool(PVOID);
1027 void      WINAPI ExFreePoolWithTag(PVOID,ULONG);
1028
1029 NTSTATUS  WINAPI IoAllocateDriverObjectExtension(PDRIVER_OBJECT,PVOID,ULONG,PVOID*);
1030 PIRP      WINAPI IoAllocateIrp(CCHAR,BOOLEAN);
1031 NTSTATUS  WINAPI IoCreateDevice(DRIVER_OBJECT*,ULONG,UNICODE_STRING*,DEVICE_TYPE,ULONG,BOOLEAN,DEVICE_OBJECT**);
1032 NTSTATUS  WINAPI IoCreateDriver(UNICODE_STRING*,PDRIVER_INITIALIZE);
1033 NTSTATUS  WINAPI IoCreateSymbolicLink(UNICODE_STRING*,UNICODE_STRING*);
1034 void      WINAPI IoDeleteDevice(DEVICE_OBJECT*);
1035 void      WINAPI IoDeleteDriver(DRIVER_OBJECT*);
1036 NTSTATUS  WINAPI IoDeleteSymbolicLink(UNICODE_STRING*);
1037 void      WINAPI IoFreeIrp(IRP*);
1038 PEPROCESS WINAPI IoGetCurrentProcess(void);
1039 NTSTATUS  WINAPI IoGetDeviceObjectPointer(UNICODE_STRING*,ACCESS_MASK,PFILE_OBJECT*,PDEVICE_OBJECT*);
1040 PVOID     WINAPI IoGetDriverObjectExtension(PDRIVER_OBJECT,PVOID);
1041 PDEVICE_OBJECT WINAPI IoGetRelatedDeviceObject(PFILE_OBJECT);
1042 void      WINAPI IoInitializeIrp(IRP*,USHORT,CCHAR);
1043
1044 PKTHREAD  WINAPI KeGetCurrentThread(void);
1045 void      WINAPI KeQuerySystemTime(LARGE_INTEGER*);
1046 void      WINAPI KeQueryTickCount(LARGE_INTEGER*);
1047 ULONG     WINAPI KeQueryTimeIncrement(void);
1048
1049 PVOID     WINAPI MmAllocateNonCachedMemory(SIZE_T);
1050 void      WINAPI MmFreeNonCachedMemory(PVOID,SIZE_T);
1051
1052 NTSTATUS  WINAPI ObReferenceObjectByHandle(HANDLE,ACCESS_MASK,POBJECT_TYPE,KPROCESSOR_MODE,PVOID*,POBJECT_HANDLE_INFORMATION);
1053
1054 NTSTATUS  WINAPI PsCreateSystemThread(PHANDLE,ULONG,POBJECT_ATTRIBUTES,HANDLE,PCLIENT_ID,PKSTART_ROUTINE,PVOID);
1055 #define          PsGetCurrentProcess() IoGetCurrentProcess()
1056 #define          PsGetCurrentThread() ((PETHREAD)KeGetCurrentThread())
1057 HANDLE    WINAPI PsGetCurrentProcessId(void);
1058 HANDLE    WINAPI PsGetCurrentThreadId(void);
1059 BOOLEAN   WINAPI PsGetVersion(ULONG*,ULONG*,ULONG*,UNICODE_STRING*);
1060 NTSTATUS  WINAPI PsTerminateSystemThread(NTSTATUS);
1061
1062 NTSTATUS  WINAPI ZwAddBootEntry(PUNICODE_STRING,PUNICODE_STRING);
1063 NTSTATUS  WINAPI ZwAccessCheckAndAuditAlarm(PUNICODE_STRING,HANDLE,PUNICODE_STRING,PUNICODE_STRING,PSECURITY_DESCRIPTOR,ACCESS_MASK,PGENERIC_MAPPING,BOOLEAN,PACCESS_MASK,PBOOLEAN,PBOOLEAN);
1064 NTSTATUS  WINAPI ZwAdjustPrivilegesToken(HANDLE,BOOLEAN,PTOKEN_PRIVILEGES,DWORD,PTOKEN_PRIVILEGES,PDWORD);
1065 NTSTATUS  WINAPI ZwAlertThread(HANDLE ThreadHandle);
1066 NTSTATUS  WINAPI ZwAllocateVirtualMemory(HANDLE,PVOID*,ULONG,SIZE_T*,ULONG,ULONG);
1067 NTSTATUS  WINAPI ZwCancelIoFile(HANDLE,PIO_STATUS_BLOCK);
1068 NTSTATUS  WINAPI ZwCancelTimer(HANDLE, BOOLEAN*);
1069 NTSTATUS  WINAPI ZwClearEvent(HANDLE);
1070 NTSTATUS  WINAPI ZwClose(HANDLE);
1071 NTSTATUS  WINAPI ZwCloseObjectAuditAlarm(PUNICODE_STRING,HANDLE,BOOLEAN);
1072 NTSTATUS  WINAPI ZwConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
1073 NTSTATUS  WINAPI ZwCreateDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1074 NTSTATUS  WINAPI ZwCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
1075 NTSTATUS  WINAPI ZwCreateFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
1076 NTSTATUS  WINAPI ZwCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,const UNICODE_STRING*,ULONG,PULONG);
1077 NTSTATUS  WINAPI ZwCreateSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const LARGE_INTEGER*,ULONG,ULONG,HANDLE);
1078 NTSTATUS  WINAPI ZwCreateSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PUNICODE_STRING);
1079 NTSTATUS  WINAPI ZwCreateTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*, TIMER_TYPE);
1080 NTSTATUS  WINAPI ZwDeleteAtom(RTL_ATOM);
1081 NTSTATUS  WINAPI ZwDeleteFile(POBJECT_ATTRIBUTES);
1082 NTSTATUS  WINAPI ZwDeleteKey(HANDLE);
1083 NTSTATUS  WINAPI ZwDeleteValueKey(HANDLE,const UNICODE_STRING *);
1084 NTSTATUS  WINAPI ZwDeviceIoControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1085 NTSTATUS  WINAPI ZwDisplayString(PUNICODE_STRING);
1086 NTSTATUS  WINAPI ZwDuplicateObject(HANDLE,HANDLE,HANDLE,PHANDLE,ACCESS_MASK,ULONG,ULONG);
1087 NTSTATUS  WINAPI ZwDuplicateToken(HANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,SECURITY_IMPERSONATION_LEVEL,TOKEN_TYPE,PHANDLE);
1088 NTSTATUS  WINAPI ZwEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1089 NTSTATUS  WINAPI ZwEnumerateValueKey(HANDLE,ULONG,KEY_VALUE_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1090 NTSTATUS  WINAPI ZwFlushInstructionCache(HANDLE,LPCVOID,SIZE_T);
1091 NTSTATUS  WINAPI ZwFlushKey(HANDLE);
1092 NTSTATUS  WINAPI ZwFlushVirtualMemory(HANDLE,LPCVOID*,SIZE_T*,ULONG);
1093 NTSTATUS  WINAPI ZwFreeVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
1094 NTSTATUS  WINAPI ZwFsControlFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,PVOID,ULONG,PVOID,ULONG);
1095 NTSTATUS  WINAPI ZwInitiatePowerAction(POWER_ACTION,SYSTEM_POWER_STATE,ULONG,BOOLEAN);
1096 NTSTATUS  WINAPI ZwLoadDriver(const UNICODE_STRING *);
1097 NTSTATUS  WINAPI ZwLoadKey(const OBJECT_ATTRIBUTES *,OBJECT_ATTRIBUTES *);
1098 NTSTATUS  WINAPI ZwLockVirtualMemory(HANDLE,PVOID*,SIZE_T*,ULONG);
1099 NTSTATUS  WINAPI ZwMakeTemporaryObject(HANDLE);
1100 NTSTATUS  WINAPI ZwMapViewOfSection(HANDLE,HANDLE,PVOID*,ULONG,SIZE_T,const LARGE_INTEGER*,SIZE_T*,SECTION_INHERIT,ULONG,ULONG);
1101 NTSTATUS  WINAPI ZwNotifyChangeKey(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,ULONG,BOOLEAN,PVOID,ULONG,BOOLEAN);
1102 NTSTATUS  WINAPI ZwOpenDirectoryObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1103 NTSTATUS  WINAPI ZwOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1104 NTSTATUS  WINAPI ZwOpenFile(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
1105 NTSTATUS  WINAPI ZwOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *);
1106 NTSTATUS  WINAPI ZwOpenProcess(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1107 NTSTATUS  WINAPI ZwOpenProcessToken(HANDLE,DWORD,HANDLE *);
1108 NTSTATUS  WINAPI ZwOpenSection(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
1109 NTSTATUS  WINAPI ZwOpenSymbolicLinkObject(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES);
1110 NTSTATUS  WINAPI ZwOpenThread(HANDLE*,ACCESS_MASK,const OBJECT_ATTRIBUTES*,const CLIENT_ID*);
1111 NTSTATUS  WINAPI ZwOpenThreadToken(HANDLE,DWORD,BOOLEAN,HANDLE *);
1112 NTSTATUS  WINAPI ZwOpenTimer(HANDLE*, ACCESS_MASK, const OBJECT_ATTRIBUTES*);
1113 NTSTATUS  WINAPI ZwPowerInformation(POWER_INFORMATION_LEVEL,PVOID,ULONG,PVOID,ULONG);
1114 NTSTATUS  WINAPI ZwPulseEvent(HANDLE,PULONG);
1115 NTSTATUS  WINAPI ZwQueryDefaultLocale(BOOLEAN,LCID*);
1116 NTSTATUS  WINAPI ZwQueryDefaultUILanguage(LANGID*);
1117 NTSTATUS  WINAPI ZwQueryDirectoryFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
1118 NTSTATUS  WINAPI ZwQueryDirectoryObject(HANDLE,PDIRECTORY_BASIC_INFORMATION,ULONG,BOOLEAN,BOOLEAN,PULONG,PULONG);
1119 NTSTATUS  WINAPI ZwQueryEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,BOOLEAN,PVOID,ULONG,PVOID,BOOLEAN);
1120 NTSTATUS  WINAPI ZwQueryFullAttributesFile(const OBJECT_ATTRIBUTES*,FILE_NETWORK_OPEN_INFORMATION*);
1121 NTSTATUS  WINAPI ZwQueryInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,LONG,FILE_INFORMATION_CLASS);
1122 NTSTATUS  WINAPI ZwQueryInformationThread(HANDLE,THREADINFOCLASS,PVOID,ULONG,PULONG);
1123 NTSTATUS  WINAPI ZwQueryInformationToken(HANDLE,DWORD,PVOID,DWORD,LPDWORD);
1124 NTSTATUS  WINAPI ZwQueryInstallUILanguage(LANGID*);
1125 NTSTATUS  WINAPI ZwQueryKey(HANDLE,KEY_INFORMATION_CLASS,void *,DWORD,DWORD *);
1126 NTSTATUS  WINAPI ZwQueryObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG, PULONG);
1127 NTSTATUS  WINAPI ZwQuerySecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR,ULONG,PULONG);
1128 NTSTATUS  WINAPI ZwQuerySection(HANDLE,SECTION_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1129 NTSTATUS  WINAPI ZwQuerySymbolicLinkObject(HANDLE,PUNICODE_STRING,PULONG);
1130 NTSTATUS  WINAPI ZwQuerySystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG,PULONG);
1131 NTSTATUS  WINAPI ZwQueryTimerResolution(PULONG,PULONG,PULONG);
1132 NTSTATUS  WINAPI ZwQueryValueKey(HANDLE,const UNICODE_STRING *,KEY_VALUE_INFORMATION_CLASS,void *,DWORD,DWORD *);
1133 NTSTATUS  WINAPI ZwQueryVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1134 NTSTATUS  WINAPI ZwReadFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,PVOID,ULONG,PLARGE_INTEGER,PULONG);
1135 NTSTATUS  WINAPI ZwReplaceKey(POBJECT_ATTRIBUTES,HANDLE,POBJECT_ATTRIBUTES);
1136 NTSTATUS  WINAPI ZwRequestWaitReplyPort(HANDLE,PLPC_MESSAGE,PLPC_MESSAGE);
1137 NTSTATUS  WINAPI ZwResetEvent(HANDLE,PULONG);
1138 NTSTATUS  WINAPI ZwRestoreKey(HANDLE,HANDLE,ULONG);
1139 NTSTATUS  WINAPI ZwSaveKey(HANDLE,HANDLE);
1140 NTSTATUS  WINAPI ZwSecureConnectPort(PHANDLE,PUNICODE_STRING,PSECURITY_QUALITY_OF_SERVICE,PLPC_SECTION_WRITE,PSID,PLPC_SECTION_READ,PULONG,PVOID,PULONG);
1141 NTSTATUS  WINAPI ZwSetDefaultLocale(BOOLEAN,LCID);
1142 NTSTATUS  WINAPI ZwSetDefaultUILanguage(LANGID);
1143 NTSTATUS  WINAPI ZwSetEaFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG);
1144 NTSTATUS  WINAPI ZwSetEvent(HANDLE,PULONG);
1145 NTSTATUS  WINAPI ZwSetInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FILE_INFORMATION_CLASS);
1146 NTSTATUS  WINAPI ZwSetInformationKey(HANDLE,const int,PVOID,ULONG);
1147 NTSTATUS  WINAPI ZwSetInformationObject(HANDLE, OBJECT_INFORMATION_CLASS, PVOID, ULONG);
1148 NTSTATUS  WINAPI ZwSetInformationProcess(HANDLE,PROCESS_INFORMATION_CLASS,PVOID,ULONG);
1149 NTSTATUS  WINAPI ZwSetInformationThread(HANDLE,THREADINFOCLASS,LPCVOID,ULONG);
1150 NTSTATUS  WINAPI ZwSetIoCompletion(HANDLE,ULONG,ULONG,NTSTATUS,ULONG);
1151 NTSTATUS  WINAPI ZwSetSecurityObject(HANDLE,SECURITY_INFORMATION,PSECURITY_DESCRIPTOR);
1152 NTSTATUS  WINAPI ZwSetSystemInformation(SYSTEM_INFORMATION_CLASS,PVOID,ULONG);
1153 NTSTATUS  WINAPI ZwSetSystemTime(const LARGE_INTEGER*,LARGE_INTEGER*);
1154 NTSTATUS  WINAPI ZwSetTimer(HANDLE, const LARGE_INTEGER*, PTIMER_APC_ROUTINE, PVOID, BOOLEAN, ULONG, BOOLEAN*);
1155 NTSTATUS  WINAPI ZwSetValueKey(HANDLE,const UNICODE_STRING *,ULONG,ULONG,const void *,ULONG);
1156 NTSTATUS  WINAPI ZwSetVolumeInformationFile(HANDLE,PIO_STATUS_BLOCK,PVOID,ULONG,FS_INFORMATION_CLASS);
1157 NTSTATUS  WINAPI ZwSuspendThread(HANDLE,PULONG);
1158 NTSTATUS  WINAPI ZwTerminateProcess(HANDLE,LONG);
1159 NTSTATUS  WINAPI ZwUnloadDriver(const UNICODE_STRING *);
1160 NTSTATUS  WINAPI ZwUnloadKey(HANDLE);
1161 NTSTATUS  WINAPI ZwUnmapViewOfSection(HANDLE,PVOID);
1162 NTSTATUS  WINAPI ZwWaitForSingleObject(HANDLE,BOOLEAN,const LARGE_INTEGER*);
1163 NTSTATUS  WINAPI ZwWaitForMultipleObjects(ULONG,const HANDLE*,BOOLEAN,BOOLEAN,const LARGE_INTEGER*);
1164 NTSTATUS  WINAPI ZwWriteFile(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,const void*,ULONG,PLARGE_INTEGER,PULONG);
1165 NTSTATUS  WINAPI ZwYieldExecution(void);
1166
1167 #endif