1 files changed, 1256 insertions, 0 deletions

diff --git a/public/sdk/inc/ntdef.h b/public/sdk/inc/ntdef.h
new file mode 100644
index 000000000..31fdf4d36
--- /dev/null
+++ b/public/sdk/inc/ntdef.h
@@ -0,0 +1,1256 @@
+/*++ BUILD Version: 0001    // Increment this if a change has global effects
+
+Copyright (c) 1989-1993  Microsoft Corporation
+
+Module Name:
+
+    ntdef.h
+
+Abstract:
+
+    Type definitions for the basic types.
+
+Author:
+
+    Mark Lucovsky (markl)   02-Feb-1989
+
+Revision History:
+
+--*/
+
+#ifndef _NTDEF_
+#define _NTDEF_
+
+#include <ctype.h>  // winnt ntndis
+
+// begin_ntminiport begin_ntndis begin_ntminitape
+
+#ifndef IN
+#define IN
+#endif
+
+#ifndef OUT
+#define OUT
+#endif
+
+#ifndef OPTIONAL
+#define OPTIONAL
+#endif
+
+#ifndef NOTHING
+#define NOTHING
+#endif
+
+#ifndef CRITICAL
+#define CRITICAL
+#endif
+
+#ifndef ANYSIZE_ARRAY
+#define ANYSIZE_ARRAY 1       // winnt
+#endif
+
+// begin_winnt
+
+#if defined(_M_MRX000) && !(defined(MIDL_PASS) || defined(RC_INVOKED)) && defined(ENABLE_RESTRICTED)
+#define RESTRICTED_POINTER __restrict
+#else
+#define RESTRICTED_POINTER
+#endif
+
+#if defined(_M_MRX000) || defined(_M_ALPHA) || defined(_M_PPC)
+#define UNALIGNED __unaligned
+#else
+#define UNALIGNED
+#endif
+
+// end_winnt
+
+#ifndef CONST
+#define CONST               const
+#endif
+
+// begin_winnt
+
+#if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
+#define DECLSPEC_IMPORT __declspec(dllimport)
+#else
+#define DECLSPEC_IMPORT
+#endif
+
+// end_winnt
+
+//
+// Void
+//
+
+typedef void *PVOID;    // winnt
+
+// end_ntminiport end_ntndis end_ntminitape
+
+// begin_winnt begin_ntndis
+
+#if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
+#define NTAPI __stdcall
+#else
+#define _cdecl
+#define NTAPI
+#endif
+
+//
+// Define API decoration for direct importing system DLL references.
+//
+
+#if !defined(_NTSYSTEM_)
+#define NTSYSAPI DECLSPEC_IMPORT
+#else
+#define NTSYSAPI
+#endif
+
+// end_winnt end_ntndis
+
+// begin_winnt begin_ntminiport begin_ntndis begin_ntminitape
+
+//
+// Basics
+//
+
+#ifndef VOID
+#define VOID void
+typedef char CHAR;
+typedef short SHORT;
+typedef long LONG;
+#endif
+
+//
+// UNICODE (Wide Character) types
+//
+
+typedef wchar_t WCHAR;    // wc,   16-bit UNICODE character
+
+typedef WCHAR *PWCHAR;
+typedef WCHAR *LPWCH, *PWCH;
+typedef CONST WCHAR *LPCWCH, *PCWCH;
+typedef WCHAR *NWPSTR;
+typedef WCHAR *LPWSTR, *PWSTR;
+
+typedef CONST WCHAR *LPCWSTR, *PCWSTR;
+
+//
+// ANSI (Multi-byte Character) types
+//
+typedef CHAR *PCHAR;
+typedef CHAR *LPCH, *PCH;
+
+typedef CONST CHAR *LPCCH, *PCCH;
+typedef CHAR *NPSTR;
+typedef CHAR *LPSTR, *PSTR;
+typedef CONST CHAR *LPCSTR, *PCSTR;
+
+//
+// Neutral ANSI/UNICODE types and macros
+//
+#ifdef  UNICODE                     // r_winnt
+
+#ifndef _TCHAR_DEFINED
+typedef WCHAR TCHAR, *PTCHAR;
+typedef WCHAR TUCHAR, *PTUCHAR;
+#define _TCHAR_DEFINED
+#endif /* !_TCHAR_DEFINED */
+
+typedef LPWSTR LPTCH, PTCH;
+typedef LPWSTR PTSTR, LPTSTR;
+typedef LPCWSTR LPCTSTR;
+typedef LPWSTR LP;
+#define __TEXT(quote) L##quote      // r_winnt
+
+#else   /* UNICODE */               // r_winnt
+
+#ifndef _TCHAR_DEFINED
+typedef char TCHAR, *PTCHAR;
+typedef unsigned char TUCHAR, *PTUCHAR;
+#define _TCHAR_DEFINED
+#endif /* !_TCHAR_DEFINED */
+
+typedef LPSTR LPTCH, PTCH;
+typedef LPSTR PTSTR, LPTSTR;
+typedef LPCSTR LPCTSTR;
+#define __TEXT(quote) quote         // r_winnt
+
+#endif /* UNICODE */                // r_winnt
+#define TEXT(quote) __TEXT(quote)   // r_winnt
+
+
+// end_winnt
+
+typedef double DOUBLE;
+
+typedef struct _QUAD {              // QUAD is for those times we want
+    double  DoNotUseThisField;      // an 8 byte aligned 8 byte long structure
+} QUAD;                             // which is NOT really a floating point
+                                    // number.  Use DOUBLE if you want an FP
+                                    // number.
+
+//
+// Pointer to Basics
+//
+
+typedef SHORT *PSHORT;  // winnt
+typedef LONG *PLONG;    // winnt
+typedef QUAD *PQUAD;
+
+//
+// Unsigned Basics
+//
+
+// Tell windef.h that some types are already defined.
+#define BASETYPES
+
+typedef unsigned char UCHAR;
+typedef unsigned short USHORT;
+typedef unsigned long ULONG;
+typedef QUAD UQUAD;
+
+//
+// Pointer to Unsigned Basics
+//
+
+typedef UCHAR *PUCHAR;
+typedef USHORT *PUSHORT;
+typedef ULONG *PULONG;
+typedef UQUAD *PUQUAD;
+
+//
+// Signed characters
+//
+
+typedef signed char SCHAR;
+typedef SCHAR *PSCHAR;
+
+#ifndef NO_STRICT
+#ifndef STRICT
+#define STRICT 1
+#endif
+#endif
+
+//
+// Handle to an Object
+//
+
+// begin_winnt
+
+#ifdef STRICT
+typedef void *HANDLE;
+#define DECLARE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
+#else
+typedef PVOID HANDLE;
+#define DECLARE_HANDLE(name) typedef HANDLE name
+#endif
+typedef HANDLE *PHANDLE;
+
+//
+// Flag (bit) fields
+//
+
+typedef UCHAR  FCHAR;
+typedef USHORT FSHORT;
+typedef ULONG  FLONG;
+
+// end_winnt
+
+//
+// Low order two bits of a handle are ignored by the system and available
+// for use by application code as tag bits.  The remaining bits are opaque
+// and used to store a serial number and table index.
+//
+
+#define OBJ_HANDLE_TAGBITS  0x00000003L
+
+//
+// Cardinal Data Types [0 - 2**N-2)
+//
+
+typedef char CCHAR;          // winnt
+typedef short CSHORT;
+typedef ULONG CLONG;
+
+typedef CCHAR *PCCHAR;
+typedef CSHORT *PCSHORT;
+typedef CLONG *PCLONG;
+
+// end_ntminiport end_ntndis end_ntminitape
+
+//
+// NLS basics (Locale and Language Ids)
+//
+
+typedef ULONG LCID;         // winnt
+typedef PULONG PLCID;       // winnt
+typedef USHORT LANGID;      // winnt
+
+//
+// Logical Data Type - These are 32-bit logical values.
+//
+
+typedef ULONG LOGICAL;
+typedef ULONG *PLOGICAL;
+
+// begin_ntndis
+//
+// NTSTATUS
+//
+
+typedef LONG NTSTATUS;
+/*lint -e624 */  // Don't complain about different typedefs.   // winnt
+typedef NTSTATUS *PNTSTATUS;
+/*lint +e624 */  // Resume checking for different typedefs.    // winnt
+
+//
+//  Status values are 32 bit values layed out as follows:
+//
+//   3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
+//   1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0 9 8 7 6 5 4 3 2 1 0
+//  +---+-+-------------------------+-------------------------------+
+//  |Sev|C|       Facility          |               Code            |
+//  +---+-+-------------------------+-------------------------------+
+//
+//  where
+//
+//      Sev - is the severity code
+//
+//          00 - Success
+//          01 - Informational
+//          10 - Warning
+//          11 - Error
+//
+//      C - is the Customer code flag
+//
+//      Facility - is the facility code
+//
+//      Code - is the facility's status code
+//
+
+//
+// Generic test for success on any status value (non-negative numbers
+// indicate success).
+//
+
+#define NT_SUCCESS(Status) ((NTSTATUS)(Status) >= 0)
+
+//
+// Generic test for information on any status value.
+//
+
+#define NT_INFORMATION(Status) ((ULONG)(Status) >> 30 == 1)
+
+//
+// Generic test for warning on any status value.
+//
+
+#define NT_WARNING(Status) ((ULONG)(Status) >> 30 == 2)
+
+//
+// Generic test for error on any status value.
+//
+
+#define NT_ERROR(Status) ((ULONG)(Status) >> 30 == 3)
+
+// begin_winnt
+#define APPLICATION_ERROR_MASK       0x20000000
+#define ERROR_SEVERITY_SUCCESS       0x00000000
+#define ERROR_SEVERITY_INFORMATIONAL 0x40000000
+#define ERROR_SEVERITY_WARNING       0x80000000
+#define ERROR_SEVERITY_ERROR         0xC0000000
+// end_winnt
+
+// end_ntndis
+//
+// Large (64-bit) integer types and operations
+//
+
+#define TIME LARGE_INTEGER
+#define _TIME _LARGE_INTEGER
+#define PTIME PLARGE_INTEGER
+#define LowTime LowPart
+#define HighTime HighPart
+
+
+// begin_winnt begin_ntminiport begin_ntndis begin_ntminitape
+
+//
+// __int64 is only supported by 2.0 and later midl.
+// __midl is set by the 2.0 midl and not by 1.0 midl.
+//
+
+#define _ULONGLONG_
+#if (!defined(MIDL_PASS) || defined(__midl)) && (!defined(_M_IX86) || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 64))
+typedef __int64 LONGLONG;
+typedef unsigned __int64 ULONGLONG;
+
+#define MAXLONGLONG                      (0x7fffffffffffffff)
+#else
+typedef double LONGLONG;
+typedef double ULONGLONG;
+#endif
+
+typedef LONGLONG *PLONGLONG;
+typedef ULONGLONG *PULONGLONG;
+
+// Update Sequence Number
+
+typedef LONGLONG USN;
+
+#if defined(MIDL_PASS)
+typedef struct _LARGE_INTEGER {
+#else // MIDL_PASS
+typedef union _LARGE_INTEGER {
+    struct {
+        ULONG LowPart;
+        LONG HighPart;
+    };
+    struct {
+        ULONG LowPart;
+        LONG HighPart;
+    } u;
+#endif //MIDL_PASS
+    LONGLONG QuadPart;
+} LARGE_INTEGER;
+
+typedef LARGE_INTEGER *PLARGE_INTEGER;
+
+
+#if defined(MIDL_PASS)
+typedef struct _ULARGE_INTEGER {
+#else // MIDL_PASS
+typedef union _ULARGE_INTEGER {
+    struct {
+        ULONG LowPart;
+        ULONG HighPart;
+    };
+    struct {
+        ULONG LowPart;
+        ULONG HighPart;
+    } u;
+#endif //MIDL_PASS
+    ULONGLONG QuadPart;
+} ULARGE_INTEGER;
+
+typedef ULARGE_INTEGER *PULARGE_INTEGER;
+
+// end_ntminiport end_ntndis end_ntminitape
+
+//
+// Locally Unique Identifier
+//
+
+typedef struct _LUID {
+    ULONG LowPart;
+    LONG HighPart;
+} LUID, *PLUID;
+
+// end_winnt
+// begin_ntminiport begin_ntndis
+
+//
+// Physical address.
+//
+
+typedef LARGE_INTEGER PHYSICAL_ADDRESS, *PPHYSICAL_ADDRESS; // windbgkd
+
+// end_ntminiport end_ntndis
+
+// begin_winnt
+
+//
+// Define operations to logically shift an int64 by 0..31 bits and to multiply
+// 32-bits by 32-bits to form a 64-bit product.
+//
+
+#if defined(MIDL_PASS) || defined(RC_INVOKED)
+
+//
+// Midl does not understand inline assembler. Therefore, the Rtl functions
+// are used for shifts by 0.31 and multiplies of 32-bits times 32-bits to
+// form a 64-bit product.
+//
+
+#define Int32x32To64(a, b) ((LONGLONG)((LONG)(a)) * (LONGLONG)((LONG)(b)))
+#define UInt32x32To64(a, b) ((ULONGLONG)((ULONG)(a)) * (ULONGLONG)((ULONG)(b)))
+
+#define Int64ShllMod32(a, b) ((ULONGLONG)(a) << (b))
+#define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
+#define Int64ShrlMod32(a, b) ((ULONGLONG)(a) >> (b))
+
+#elif defined(_M_MRX000)
+
+//
+// MIPS uses intrinsic functions to perform shifts by 0..31 and multiplies of
+// 32-bits times 32-bits to 64-bits.
+//
+
+#define Int32x32To64 __emul
+#define UInt32x32To64 __emulu
+
+#define Int64ShllMod32 __ll_lshift
+#define Int64ShraMod32 __ll_rshift
+#define Int64ShrlMod32 __ull_rshift
+
+#if defined (__cplusplus)
+extern "C" {
+#endif
+
+LONGLONG
+NTAPI
+Int32x32To64 (
+    LONG Multiplier,
+    LONG Multiplicand
+    );
+
+ULONGLONG
+NTAPI
+UInt32x32To64 (
+    ULONG Multiplier,
+    ULONG Multiplicand
+    );
+
+ULONGLONG
+NTAPI
+Int64ShllMod32 (
+    ULONGLONG Value,
+    ULONG ShiftCount
+    );
+
+LONGLONG
+NTAPI
+Int64ShraMod32 (
+    LONGLONG Value,
+    ULONG ShiftCount
+    );
+
+ULONGLONG
+NTAPI
+Int64ShrlMod32 (
+    ULONGLONG Value,
+    ULONG ShiftCount
+    );
+
+#if defined (__cplusplus)
+};
+#endif
+
+#pragma intrinsic(__emul)
+#pragma intrinsic(__emulu)
+
+#pragma intrinsic(__ll_lshift)
+#pragma intrinsic(__ll_rshift)
+#pragma intrinsic(__ull_rshift)
+
+#elif defined(_M_IX86)
+
+//
+// The x86 C compiler understands inline assembler. Therefore, inline functions
+// that employ inline assembler are used for shifts of 0..31.  The multiplies
+// rely on the compiler recognizing the cast of the multiplicand to int64 to
+// generate the optimal code inline.
+//
+
+#define Int32x32To64( a, b ) (LONGLONG)((LONGLONG)(LONG)(a) * (LONG)(b))
+#define UInt32x32To64( a, b ) (ULONGLONG)((ULONGLONG)(ULONG)(a) * (ULONG)(b))
+
+ULONGLONG
+NTAPI
+Int64ShllMod32 (
+    ULONGLONG Value,
+    ULONG ShiftCount
+    );
+
+LONGLONG
+NTAPI
+Int64ShraMod32 (
+    LONGLONG Value,
+    ULONG ShiftCount
+    );
+
+ULONGLONG
+NTAPI
+Int64ShrlMod32 (
+    ULONGLONG Value,
+    ULONG ShiftCount
+    );
+
+#pragma warning(disable:4035)               // re-enable below
+
+__inline ULONGLONG
+NTAPI
+Int64ShllMod32 (
+    ULONGLONG Value,
+    ULONG ShiftCount
+    )
+{
+    __asm    {
+        mov     ecx, ShiftCount
+        mov     eax, dword ptr [Value]
+        mov     edx, dword ptr [Value+4]
+        shld    edx, eax, cl
+        shl     eax, cl
+    }
+}
+
+__inline LONGLONG
+NTAPI
+Int64ShraMod32 (
+    LONGLONG Value,
+    ULONG ShiftCount
+    )
+{
+    __asm {
+        mov     ecx, ShiftCount
+        mov     eax, dword ptr [Value]
+        mov     edx, dword ptr [Value+4]
+        shrd    eax, edx, cl
+        sar     edx, cl
+    }
+}
+
+__inline ULONGLONG
+NTAPI
+Int64ShrlMod32 (
+    ULONGLONG Value,
+    ULONG ShiftCount
+    )
+{
+    __asm    {
+        mov     ecx, ShiftCount
+        mov     eax, dword ptr [Value]
+        mov     edx, dword ptr [Value+4]
+        shrd    eax, edx, cl
+        shr     edx, cl
+    }
+}
+
+#pragma warning(default:4035)
+
+#elif defined(_M_ALPHA)
+
+//
+// Alpha has native 64-bit operations that are just as fast as their 32-bit
+// counter parts. Therefore, the int64 data type is used directly to form
+// shifts of 0..31 and multiplies of 32-bits times 32-bits to form a 64-bit
+// product.
+//
+
+#define Int32x32To64(a, b) ((LONGLONG)((LONG)(a)) * (LONGLONG)((LONG)(b)))
+#define UInt32x32To64(a, b) ((ULONGLONG)((ULONG)(a)) * (ULONGLONG)((ULONG)(b)))
+
+#define Int64ShllMod32(a, b) ((ULONGLONG)(a) << (b))
+#define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
+#define Int64ShrlMod32(a, b) ((ULONGLONG)(a) >> (b))
+
+
+#elif defined(_M_PPC)
+
+#define Int32x32To64(a, b) ((LONGLONG)((LONG)(a)) * (LONGLONG)((LONG)(b)))
+#define UInt32x32To64(a, b) ((ULONGLONG)((ULONG)(a)) * (ULONGLONG)((ULONG)(b)))
+
+#define Int64ShllMod32(a, b) ((ULONGLONG)(a) << (b))
+#define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
+#define Int64ShrlMod32(a, b) ((ULONGLONG)(a) >> (b))
+
+#else
+
+#error Must define a target architecture.
+
+#endif
+
+// end_winnt
+
+//
+// Event type
+//
+
+typedef enum _EVENT_TYPE {
+    NotificationEvent,
+    SynchronizationEvent
+    } EVENT_TYPE;
+
+//
+// Timer type
+//
+
+typedef enum _TIMER_TYPE {
+    NotificationTimer,
+    SynchronizationTimer
+    } TIMER_TYPE;
+
+//
+// Wait type
+//
+
+typedef enum _WAIT_TYPE {
+    WaitAll,
+    WaitAny
+    } WAIT_TYPE;
+
+//
+// Pointer to an Asciiz string
+//
+
+typedef CHAR *PSZ;
+typedef CONST char *PCSZ;
+
+// begin_ntndis
+//
+// Counted String
+//
+
+typedef struct _STRING {
+    USHORT Length;
+    USHORT MaximumLength;
+#ifdef MIDL_PASS
+    [size_is(MaximumLength), length_is(Length) ]
+#endif // MIDL_PASS
+    PCHAR Buffer;
+} STRING;
+typedef STRING *PSTRING;
+
+typedef STRING ANSI_STRING;
+typedef PSTRING PANSI_STRING;
+
+typedef STRING OEM_STRING;
+typedef PSTRING POEM_STRING;
+
+//
+// CONSTCounted String
+//
+
+typedef struct _CSTRING {
+    USHORT Length;
+    USHORT MaximumLength;
+    CONST char *Buffer;
+} CSTRING;
+typedef CSTRING *PCSTRING;
+
+typedef STRING CANSI_STRING;
+typedef PSTRING PCANSI_STRING;
+
+//
+// Unicode strings are counted 16-bit character strings. If they are
+// NULL terminated, Length does not include trailing NULL.
+//
+
+typedef struct _UNICODE_STRING {
+    USHORT Length;
+    USHORT MaximumLength;
+#ifdef MIDL_PASS
+    [size_is(MaximumLength / 2), length_is((Length) / 2) ] USHORT * Buffer;
+#else // MIDL_PASS
+    PWSTR  Buffer;
+#endif // MIDL_PASS
+} UNICODE_STRING;
+typedef UNICODE_STRING *PUNICODE_STRING;
+#define UNICODE_NULL ((WCHAR)0) // winnt
+
+// begin_ntminiport begin_ntminitape
+
+//
+// Boolean
+//
+
+typedef UCHAR BOOLEAN;           // winnt
+typedef BOOLEAN *PBOOLEAN;       // winnt
+
+// end_ntminiport end_ntminitape
+
+// begin_winnt
+//
+//  Doubly linked list structure.  Can be used as either a list head, or
+//  as link words.
+//
+
+typedef struct _LIST_ENTRY {
+   struct _LIST_ENTRY * volatile Flink;
+   struct _LIST_ENTRY * volatile Blink;
+} LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;
+
+//
+//  Singly linked list structure. Can be used as either a list head, or
+//  as link words.
+//
+
+typedef struct _SINGLE_LIST_ENTRY {
+    struct _SINGLE_LIST_ENTRY *Next;
+} SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;
+// end_winnt end_ntndis
+
+
+//
+// Valid values for the Attributes field
+//
+
+#define OBJ_INHERIT             0x00000002L
+#define OBJ_PERMANENT           0x00000010L
+#define OBJ_EXCLUSIVE           0x00000020L
+#define OBJ_CASE_INSENSITIVE    0x00000040L
+#define OBJ_OPENIF              0x00000080L
+#define OBJ_OPENLINK            0x00000100L
+#define OBJ_VALID_ATTRIBUTES    0x000001F2L
+
+//
+// Object Attributes structure
+//
+
+typedef struct _OBJECT_ATTRIBUTES {
+    ULONG Length;
+    HANDLE RootDirectory;
+    PUNICODE_STRING ObjectName;
+    ULONG Attributes;
+    PVOID SecurityDescriptor;        // Points to type SECURITY_DESCRIPTOR
+    PVOID SecurityQualityOfService;  // Points to type SECURITY_QUALITY_OF_SERVICE
+} OBJECT_ATTRIBUTES;
+typedef OBJECT_ATTRIBUTES *POBJECT_ATTRIBUTES;
+
+//++
+//
+// VOID
+// InitializeObjectAttributes(
+//     OUT POBJECT_ATTRIBUTES p,
+//     IN PUNICODE_STRING n,
+//     IN ULONG a,
+//     IN HANDLE r,
+//     IN PSECURITY_DESCRIPTOR s
+//     )
+//
+//--
+
+#define InitializeObjectAttributes( p, n, a, r, s ) { \
+    (p)->Length = sizeof( OBJECT_ATTRIBUTES );          \
+    (p)->RootDirectory = r;                             \
+    (p)->Attributes = a;                                \
+    (p)->ObjectName = n;                                \
+    (p)->SecurityDescriptor = s;                        \
+    (p)->SecurityQualityOfService = NULL;               \
+    }
+
+// begin_ntminiport begin_ntndis begin_ntminitape
+
+//
+// Constants
+//
+
+#define FALSE   0
+#define TRUE    1
+
+#ifndef NULL
+#ifdef __cplusplus
+#define NULL    0
+#else
+#define NULL    ((void *)0)
+#endif
+#endif // NULL
+
+// end_ntminiport end_ntndis end_ntminitape
+
+// begin_winnt begin_ntndis
+
+//
+// Base data structures for OLE support
+//
+
+#ifndef GUID_DEFINED
+#define GUID_DEFINED
+
+typedef struct _GUID {          // size is 16
+    ULONG Data1;
+    USHORT Data2;
+    USHORT Data3;
+    UCHAR Data4[8];
+} GUID;
+
+#endif // !GUID_DEFINED
+
+#ifndef __OBJECTID_DEFINED
+#define __OBJECTID_DEFINED
+
+typedef struct  _OBJECTID {     // size is 20
+    GUID Lineage;
+    ULONG Uniquifier;
+} OBJECTID;
+#endif // !_OBJECTID_DEFINED
+
+// end_winnt end_ntndis
+
+
+#define MINCHAR     0x80        // winnt
+#define MAXCHAR     0x7f        // winnt
+#define MINSHORT    0x8000      // winnt
+#define MAXSHORT    0x7fff      // winnt
+#define MINLONG     0x80000000  // winnt
+#define MAXLONG     0x7fffffff  // winnt
+#define MAXUCHAR    0xff        // winnt
+#define MAXUSHORT   0xffff      // winnt
+#define MAXULONG    0xffffffff  // winnt
+
+//
+// Useful Helper Macros
+//
+
+// begin_ntndis
+//
+// Determine if an argument is present by testing the value of the pointer
+// to the argument value.
+//
+
+#define ARGUMENT_PRESENT(ArgumentPointer)    (\
+    (CHAR *)(ArgumentPointer) != (CHAR *)(NULL) )
+
+// begin_winnt begin_ntminiport
+//
+// Calculate the byte offset of a field in a structure of type type.
+//
+
+#define FIELD_OFFSET(type, field)    ((LONG)&(((type *)0)->field))
+
+
+//
+// Calculate the address of the base of the structure given its type, and an
+// address of a field within the structure.
+//
+
+#define CONTAINING_RECORD(address, type, field) ((type *)( \
+                                                  (PCHAR)(address) - \
+                                                  (PCHAR)(&((type *)0)->field)))
+// end_winnt end_ntminiport end_ntndis
+
+//
+// Exception handler routine definition.
+//
+
+struct _CONTEXT;
+struct _EXCEPTION_RECORD;
+
+typedef
+EXCEPTION_DISPOSITION
+(*PEXCEPTION_ROUTINE) (
+    IN struct _EXCEPTION_RECORD *ExceptionRecord,
+    IN PVOID EstablisherFrame,
+    IN OUT struct _CONTEXT *ContextRecord,
+    IN OUT PVOID DispatcherContext
+    );
+
+// begin_ntminiport begin_ntndis
+
+//
+// Interrupt Request Level (IRQL)
+//
+
+typedef UCHAR KIRQL;
+
+typedef KIRQL *PKIRQL;
+
+// end_ntminiport end_ntndis
+
+//
+// Product types
+//
+
+typedef enum _NT_PRODUCT_TYPE {
+    NtProductWinNt = 1,
+    NtProductLanManNt,
+    NtProductServer
+} NT_PRODUCT_TYPE, *PNT_PRODUCT_TYPE;
+
+
+
+
+// begin_winnt begin_r_winnt
+
+//
+//  Language IDs.
+//
+//  The following two combinations of primary language ID and
+//  sublanguage ID have special semantics:
+//
+//    Primary Language ID   Sublanguage ID      Result
+//    -------------------   ---------------     ------------------------
+//    LANG_NEUTRAL          SUBLANG_NEUTRAL     Language neutral
+//    LANG_NEUTRAL          SUBLANG_DEFAULT     User default language
+//    LANG_NEUTRAL          SUBLANG_SYS_DEFAULT System default language
+//
+
+//
+//  Primary language IDs.
+//
+
+#define LANG_NEUTRAL                     0x00
+
+#define LANG_AFRIKAANS                   0x36
+#define LANG_ALBANIAN                    0x1c
+#define LANG_ARABIC                      0x01
+#define LANG_BASQUE                      0x2d
+#define LANG_BELARUSIAN                  0x23
+#define LANG_BULGARIAN                   0x02
+#define LANG_CATALAN                     0x03
+#define LANG_CHINESE                     0x04
+#define LANG_CROATIAN                    0x1a
+#define LANG_CZECH                       0x05
+#define LANG_DANISH                      0x06
+#define LANG_DUTCH                       0x13
+#define LANG_ENGLISH                     0x09
+#define LANG_ESTONIAN                    0x25
+#define LANG_FAEROESE                    0x38
+#define LANG_FARSI                       0x29
+#define LANG_FINNISH                     0x0b
+#define LANG_FRENCH                      0x0c
+#define LANG_GERMAN                      0x07
+#define LANG_GREEK                       0x08
+#define LANG_HEBREW                      0x0d
+#define LANG_HUNGARIAN                   0x0e
+#define LANG_ICELANDIC                   0x0f
+#define LANG_INDONESIAN                  0x21
+#define LANG_ITALIAN                     0x10
+#define LANG_JAPANESE                    0x11
+#define LANG_KOREAN                      0x12
+#define LANG_LATVIAN                     0x26
+#define LANG_LITHUANIAN                  0x27
+#define LANG_NORWEGIAN                   0x14
+#define LANG_POLISH                      0x15
+#define LANG_PORTUGUESE                  0x16
+#define LANG_ROMANIAN                    0x18
+#define LANG_RUSSIAN                     0x19
+#define LANG_SERBIAN                     0x1a
+#define LANG_SLOVAK                      0x1b
+#define LANG_SLOVENIAN                   0x24
+#define LANG_SPANISH                     0x0a
+#define LANG_SWEDISH                     0x1d
+#define LANG_THAI                        0x1e
+#define LANG_TURKISH                     0x1f
+#define LANG_UKRAINIAN                   0x22
+#define LANG_VIETNAMESE                  0x2a
+
+//
+//  Sublanguage IDs.
+//
+//  The name immediately following SUBLANG_ dictates which primary
+//  language ID that sublanguage ID can be combined with to form a
+//  valid language ID.
+//
+
+#define SUBLANG_NEUTRAL                  0x00    // language neutral
+#define SUBLANG_DEFAULT                  0x01    // user default
+#define SUBLANG_SYS_DEFAULT              0x02    // system default
+
+#define SUBLANG_ARABIC_SAUDI_ARABIA      0x01    // Arabic (Saudi Arabia)
+#define SUBLANG_ARABIC_IRAQ              0x02    // Arabic (Iraq)
+#define SUBLANG_ARABIC_EGYPT             0x03    // Arabic (Egypt)
+#define SUBLANG_ARABIC_LIBYA             0x04    // Arabic (Libya)
+#define SUBLANG_ARABIC_ALGERIA           0x05    // Arabic (Algeria)
+#define SUBLANG_ARABIC_MOROCCO           0x06    // Arabic (Morocco)
+#define SUBLANG_ARABIC_TUNISIA           0x07    // Arabic (Tunisia)
+#define SUBLANG_ARABIC_OMAN              0x08    // Arabic (Oman)
+#define SUBLANG_ARABIC_YEMEN             0x09    // Arabic (Yemen)
+#define SUBLANG_ARABIC_SYRIA             0x0a    // Arabic (Syria)
+#define SUBLANG_ARABIC_JORDAN            0x0b    // Arabic (Jordan)
+#define SUBLANG_ARABIC_LEBANON           0x0c    // Arabic (Lebanon)
+#define SUBLANG_ARABIC_KUWAIT            0x0d    // Arabic (Kuwait)
+#define SUBLANG_ARABIC_UAE               0x0e    // Arabic (U.A.E)
+#define SUBLANG_ARABIC_BAHRAIN           0x0f    // Arabic (Bahrain)
+#define SUBLANG_ARABIC_QATAR             0x10    // Arabic (Qatar)
+#define SUBLANG_CHINESE_TRADITIONAL      0x01    // Chinese (Taiwan)
+#define SUBLANG_CHINESE_SIMPLIFIED       0x02    // Chinese (PR China)
+#define SUBLANG_CHINESE_HONGKONG         0x03    // Chinese (Hong Kong)
+#define SUBLANG_CHINESE_SINGAPORE        0x04    // Chinese (Singapore)
+#define SUBLANG_DUTCH                    0x01    // Dutch
+#define SUBLANG_DUTCH_BELGIAN            0x02    // Dutch (Belgian)
+#define SUBLANG_ENGLISH_US               0x01    // English (USA)
+#define SUBLANG_ENGLISH_UK               0x02    // English (UK)
+#define SUBLANG_ENGLISH_AUS              0x03    // English (Australian)
+#define SUBLANG_ENGLISH_CAN              0x04    // English (Canadian)
+#define SUBLANG_ENGLISH_NZ               0x05    // English (New Zealand)
+#define SUBLANG_ENGLISH_EIRE             0x06    // English (Irish)
+#define SUBLANG_ENGLISH_SOUTH_AFRICA     0x07    // English (South Africa)
+#define SUBLANG_ENGLISH_JAMAICA          0x08    // English (Jamaica)
+#define SUBLANG_ENGLISH_CARIBBEAN        0x09    // English (Caribbean)
+#define SUBLANG_ENGLISH_BELIZE           0x0a    // English (Belize)
+#define SUBLANG_ENGLISH_TRINIDAD         0x0b    // English (Trinidad)
+#define SUBLANG_FRENCH                   0x01    // French
+#define SUBLANG_FRENCH_BELGIAN           0x02    // French (Belgian)
+#define SUBLANG_FRENCH_CANADIAN          0x03    // French (Canadian)
+#define SUBLANG_FRENCH_SWISS             0x04    // French (Swiss)
+#define SUBLANG_FRENCH_LUXEMBOURG        0x05    // French (Luxembourg)
+#define SUBLANG_GERMAN                   0x01    // German
+#define SUBLANG_GERMAN_SWISS             0x02    // German (Swiss)
+#define SUBLANG_GERMAN_AUSTRIAN          0x03    // German (Austrian)
+#define SUBLANG_GERMAN_LUXEMBOURG        0x04    // German (Luxembourg)
+#define SUBLANG_GERMAN_LIECHTENSTEIN     0x05    // German (Liechtenstein)
+#define SUBLANG_ITALIAN                  0x01    // Italian
+#define SUBLANG_ITALIAN_SWISS            0x02    // Italian (Swiss)
+#define SUBLANG_KOREAN                   0x01    // Korean (Extended Wansung)
+#define SUBLANG_KOREAN_JOHAB             0x02    // Korean (Johab)
+#define SUBLANG_NORWEGIAN_BOKMAL         0x01    // Norwegian (Bokmal)
+#define SUBLANG_NORWEGIAN_NYNORSK        0x02    // Norwegian (Nynorsk)
+#define SUBLANG_PORTUGUESE               0x02    // Portuguese
+#define SUBLANG_PORTUGUESE_BRAZILIAN     0x01    // Portuguese (Brazilian)
+#define SUBLANG_SERBIAN_LATIN            0x02    // Serbian (Latin)
+#define SUBLANG_SERBIAN_CYRILLIC         0x03    // Serbian (Cyrillic)
+#define SUBLANG_SPANISH                  0x01    // Spanish (Castilian)
+#define SUBLANG_SPANISH_MEXICAN          0x02    // Spanish (Mexican)
+#define SUBLANG_SPANISH_MODERN           0x03    // Spanish (Modern)
+#define SUBLANG_SPANISH_GUATEMALA        0x04    // Spanish (Guatemala)
+#define SUBLANG_SPANISH_COSTA_RICA       0x05    // Spanish (Costa Rica)
+#define SUBLANG_SPANISH_PANAMA           0x06    // Spanish (Panama)
+#define SUBLANG_SPANISH_DOMINICAN_REPUBLIC 0x07  // Spanish (Dominican Republic)
+#define SUBLANG_SPANISH_VENEZUELA        0x08    // Spanish (Venezuela)
+#define SUBLANG_SPANISH_COLOMBIA         0x09    // Spanish (Colombia)
+#define SUBLANG_SPANISH_PERU             0x0a    // Spanish (Peru)
+#define SUBLANG_SPANISH_ARGENTINA        0x0b    // Spanish (Argentina)
+#define SUBLANG_SPANISH_ECUADOR          0x0c    // Spanish (Ecuador)
+#define SUBLANG_SPANISH_CHILE            0x0d    // Spanish (Chile)
+#define SUBLANG_SPANISH_URUGUAY          0x0e    // Spanish (Uruguay)
+#define SUBLANG_SPANISH_PARAGUAY         0x0f    // Spanish (Paraguay)
+#define SUBLANG_SPANISH_BOLIVIA          0x10    // Spanish (Bolivia)
+#define SUBLANG_SPANISH_EL_SALVADOR      0x11    // Spanish (El Salvador)
+#define SUBLANG_SPANISH_HONDURAS         0x12    // Spanish (Honduras)
+#define SUBLANG_SPANISH_NICARAGUA        0x13    // Spanish (Nicaragua)
+#define SUBLANG_SPANISH_PUERTO_RICO      0x14    // Spanish (Puerto Rico)
+#define SUBLANG_SWEDISH                  0x01    // Swedish
+#define SUBLANG_SWEDISH_FINLAND          0x02    // Swedish (Finland)
+
+//
+//  Sorting IDs.
+//
+
+#define SORT_DEFAULT                     0x0     // sorting default
+
+#define SORT_JAPANESE_XJIS               0x0     // Japanese XJIS order
+#define SORT_JAPANESE_UNICODE            0x1     // Japanese Unicode order
+
+#define SORT_CHINESE_BIG5                0x0     // Chinese BIG5 order
+#define SORT_CHINESE_PRCP                0x0     // PRC Chinese Phonetic order
+#define SORT_CHINESE_UNICODE             0x1     // Chinese Unicode order
+#define SORT_CHINESE_PRC                 0x2     // PRC Chinese Stroke Count order
+
+#define SORT_KOREAN_KSC                  0x0     // Korean KSC order
+#define SORT_KOREAN_UNICODE              0x1     // Korean Unicode order
+
+#define SORT_GERMAN_PHONE_BOOK           0x1     // German Phone Book order
+
+// end_r_winnt
+
+//
+//  A language ID is a 16 bit value which is the combination of a
+//  primary language ID and a secondary language ID.  The bits are
+//  allocated as follows:
+//
+//       +-----------------------+-------------------------+
+//       |     Sublanguage ID    |   Primary Language ID   |
+//       +-----------------------+-------------------------+
+//        15                   10 9                       0   bit
+//
+//
+//  Language ID creation/extraction macros:
+//
+//    MAKELANGID    - construct language id from a primary language id and
+//                    a sublanguage id.
+//    PRIMARYLANGID - extract primary language id from a language id.
+//    SUBLANGID     - extract sublanguage id from a language id.
+//
+
+#define MAKELANGID(p, s)       ((((USHORT)(s)) << 10) | (USHORT)(p))
+#define PRIMARYLANGID(lgid)    ((USHORT)(lgid) & 0x3ff)
+#define SUBLANGID(lgid)        ((USHORT)(lgid) >> 10)
+
+
+//
+//  A locale ID is a 32 bit value which is the combination of a
+//  language ID, a sort ID, and a reserved area.  The bits are
+//  allocated as follows:
+//
+//       +-------------+---------+-------------------------+
+//       |   Reserved  | Sort ID |      Language ID        |
+//       +-------------+---------+-------------------------+
+//        31         20 19     16 15                      0   bit
+//
+//
+//  Locale ID creation/extraction macros:
+//
+//    MAKELCID       - construct locale id from a language id and a sort id.
+//    LANGIDFROMLCID - extract language id from a locale id.
+//    SORTIDFROMLCID - extract sort id from a locale id.
+//
+
+#define NLS_VALID_LOCALE_MASK  0x000fffff
+
+#define MAKELCID(lgid, srtid)  ((ULONG)((((ULONG)((USHORT)(srtid))) << 16) |  \
+                                         ((ULONG)((USHORT)(lgid)))))
+#define LANGIDFROMLCID(lcid)   ((USHORT)(lcid))
+#define SORTIDFROMLCID(lcid)   ((USHORT)((((ULONG)(lcid)) & NLS_VALID_LOCALE_MASK) >> 16))
+
+
+//
+//  Default System and User IDs for language and locale.
+//
+
+#define LANG_SYSTEM_DEFAULT    (MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT))
+#define LANG_USER_DEFAULT      (MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT))
+
+#define LOCALE_SYSTEM_DEFAULT  (MAKELCID(LANG_SYSTEM_DEFAULT, SORT_DEFAULT))
+#define LOCALE_USER_DEFAULT    (MAKELCID(LANG_USER_DEFAULT, SORT_DEFAULT))
+
+#define LOCALE_NEUTRAL                                                        \
+          (MAKELCID(MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL), SORT_DEFAULT))
+
+
+// begin_ntminiport begin_ntndis begin_ntminitape
+
+//
+// Macros used to eliminate compiler warning generated when formal
+// parameters or local variables are not declared.
+//
+// Use DBG_UNREFERENCED_PARAMETER() when a parameter is not yet
+// referenced but will be once the module is completely developed.
+//
+// Use DBG_UNREFERENCED_LOCAL_VARIABLE() when a local variable is not yet
+// referenced but will be once the module is completely developed.
+//
+// Use UNREFERENCED_PARAMETER() if a parameter will never be referenced.
+//
+// DBG_UNREFERENCED_PARAMETER and DBG_UNREFERENCED_LOCAL_VARIABLE will
+// eventually be made into a null macro to help determine whether there
+// is unfinished work.
+//
+
+#if ! (defined(lint) || defined(_lint))
+#define UNREFERENCED_PARAMETER(P)          (P)
+#define DBG_UNREFERENCED_PARAMETER(P)      (P)
+#define DBG_UNREFERENCED_LOCAL_VARIABLE(V) (V)
+
+#else // lint or _lint
+
+// Note: lint -e530 says don't complain about uninitialized variables for
+// this.  line +e530 turns that checking back on.  Error 527 has to do with
+// unreachable code.
+
+#define UNREFERENCED_PARAMETER(P)          \
+    /*lint -e527 -e530 */ \
+    { \
+        (P) = (P); \
+    } \
+    /*lint +e527 +e530 */
+#define DBG_UNREFERENCED_PARAMETER(P)      \
+    /*lint -e527 -e530 */ \
+    { \
+        (P) = (P); \
+    } \
+    /*lint +e527 +e530 */
+#define DBG_UNREFERENCED_LOCAL_VARIABLE(V) \
+    /*lint -e527 -e530 */ \
+    { \
+        (V) = (V); \
+    } \
+    /*lint +e527 +e530 */
+
+#endif // lint or _lint
+
+
+// end_winnt end_ntminiport end_ntndis end_ntminitape
+
+#endif // _NTDEF_