home *** CD-ROM | disk | FTP | other *** search
/ OpenStep (Enterprise) / OpenStepENTCD.toast / OEDEV / DEV.Z / WINNT.H < prev    next >
C/C++ Source or Header  |  1996-09-08  |  166KB  |  4,769 lines
  1. #if !defined(__TOPLEVEL_NEXT_COMMON_INCLUDE__)
  2. #define __TOPLEVEL_NEXT_COMMON_INCLUDE__
  3. #define __TOPLEVEL_WINNT_H_ 
  4. #include <next_common_defines.h>
  5. #endif /* __TOPLEVEL_NEXT_COMMON_INCLUDE__ */
  6.  
  7. /*++ BUILD Version: 0093     Increment this if a change has global effects
  8.  
  9. Copyright (c) 1990-1995  Microsoft Corporation
  10.  
  11. Module Name:
  12.  
  13.     winnt.h
  14.  
  15. Abstract:
  16.  
  17.     This module defines the 32-Bit Windows types and constants that are
  18.     defined by NT, but exposed through the Win32 API.
  19.  
  20. Revision History:
  21.  
  22. --*/
  23.  
  24. #ifndef _WINNT_
  25. #define _WINNT_
  26.  
  27. #ifdef __cplusplus
  28. extern "C" {
  29. #endif
  30.  
  31. #include <ctype.h>  
  32. #define ANYSIZE_ARRAY 1       
  33.  
  34. #if defined(_M_MRX000) && !(defined(MIDL_PASS) || defined(RC_INVOKED)) && defined(ENABLE_RESTRICTED)
  35. #define RESTRICTED_POINTER __restrict
  36. #else
  37. #define RESTRICTED_POINTER
  38. #endif
  39.  
  40. #if defined(_M_MRX000) || defined(_M_ALPHA) || defined(_M_PPC)
  41. #define UNALIGNED __unaligned
  42. #else
  43. #define UNALIGNED
  44. #endif
  45.  
  46.  
  47. #if (defined(_M_MRX000) || defined(_M_IX86) || defined(_M_ALPHA) || defined(_M_PPC)) && !defined(MIDL_PASS)
  48. #define DECLSPEC_IMPORT __declspec(dllimport)
  49. #else
  50. #define DECLSPEC_IMPORT
  51. #endif
  52.  
  53. typedef void *PVOID;    
  54.  
  55. #if (_MSC_VER >= 800) || defined(_STDCALL_SUPPORTED)
  56. #define NTAPI __stdcall
  57. #else
  58. #define _cdecl
  59. #define NTAPI
  60. #endif
  61.  
  62. //
  63. // Define API decoration for direct importing system DLL references.
  64. //
  65.  
  66. #if !defined(_NTSYSTEM_)
  67. #define NTSYSAPI DECLSPEC_IMPORT
  68. #else
  69. #define NTSYSAPI
  70. #endif
  71.  
  72.  
  73. //
  74. // Basics
  75. //
  76.  
  77. #ifndef VOID
  78. #define VOID void
  79. typedef char CHAR;
  80. typedef short SHORT;
  81. typedef long LONG;
  82. #endif
  83.  
  84. //
  85. // UNICODE (Wide Character) types
  86. //
  87.  
  88. typedef wchar_t WCHAR;    // wc,   16-bit UNICODE character
  89.  
  90. typedef WCHAR *PWCHAR;
  91. typedef WCHAR *LPWCH, *PWCH;
  92. typedef CONST WCHAR *LPCWCH, *PCWCH;
  93. typedef WCHAR *NWPSTR;
  94. typedef WCHAR *LPWSTR, *PWSTR;
  95.  
  96. typedef CONST WCHAR *LPCWSTR, *PCWSTR;
  97.  
  98. //
  99. // ANSI (Multi-byte Character) types
  100. //
  101. typedef CHAR *PCHAR;
  102. typedef CHAR *LPCH, *PCH;
  103.  
  104. typedef CONST CHAR *LPCCH, *PCCH;
  105. typedef CHAR *NPSTR;
  106. typedef CHAR *LPSTR, *PSTR;
  107. typedef CONST CHAR *LPCSTR, *PCSTR;
  108.  
  109. //
  110. // Neutral ANSI/UNICODE types and macros
  111. //
  112. #ifdef  UNICODE
  113.  
  114. #ifndef _TCHAR_DEFINED
  115. typedef WCHAR TCHAR, *PTCHAR;
  116. typedef WCHAR TBYTE , *PTBYTE ;
  117. #define _TCHAR_DEFINED
  118. #endif /* !_TCHAR_DEFINED */
  119.  
  120. typedef LPWSTR LPTCH, PTCH;
  121. typedef LPWSTR PTSTR, LPTSTR;
  122. typedef LPCWSTR LPCTSTR;
  123. typedef LPWSTR LP;
  124. #define __TEXT(quote) L##quote
  125.  
  126. #else   /* UNICODE */
  127.  
  128. #ifndef _TCHAR_DEFINED
  129. typedef char TCHAR, *PTCHAR;
  130. typedef unsigned char TBYTE , *PTBYTE ;
  131. #define _TCHAR_DEFINED
  132. #endif /* !_TCHAR_DEFINED */
  133.  
  134. typedef LPSTR LPTCH, PTCH;
  135. typedef LPSTR PTSTR, LPTSTR;
  136. typedef LPCSTR LPCTSTR;
  137. #define __TEXT(quote) quote
  138.  
  139. #endif /* UNICODE */
  140. #define TEXT(quote) __TEXT(quote)
  141.  
  142.  
  143. typedef SHORT *PSHORT;  
  144. typedef LONG *PLONG;    
  145.  
  146. #ifdef STRICT
  147. typedef void *HANDLE;
  148. #define DECLARE_HANDLE(name) struct name##__ { int unused; }; typedef struct name##__ *name
  149. #else
  150. typedef PVOID HANDLE;
  151. #define DECLARE_HANDLE(name) typedef HANDLE name
  152. #endif
  153. typedef HANDLE *PHANDLE;
  154.  
  155. typedef char CCHAR;          
  156. #ifndef _LCID_DEFINED
  157. #define _LCID_DEFINED
  158. typedef DWORD LCID;         
  159. #endif /* _LCID_DEFINED */
  160. typedef PDWORD PLCID;       
  161. typedef WORD   LANGID;      
  162. /*lint -e624 */  
  163. /*lint +e624 */  
  164. #define APPLICATION_ERROR_MASK       0x20000000
  165. #define ERROR_SEVERITY_SUCCESS       0x00000000
  166. #define ERROR_SEVERITY_INFORMATIONAL 0x40000000
  167. #define ERROR_SEVERITY_WARNING       0x80000000
  168. #define ERROR_SEVERITY_ERROR         0xC0000000
  169.  
  170. //
  171. // __int64 is only supported by 2.0 and later midl.
  172. // __midl is set by the 2.0 midl and not by 1.0 midl.
  173. //
  174.  
  175. #if (!defined(MIDL_PASS) || defined(__midl)) && (!defined(_M_IX86) || (defined(_INTEGRAL_MAX_BITS) && _INTEGRAL_MAX_BITS >= 64))
  176. typedef __int64 LONGLONG;
  177. typedef unsigned __int64 DWORDLONG;
  178. #else
  179. typedef double LONGLONG;
  180. typedef double DWORDLONG;
  181. #endif
  182.  
  183. typedef LONGLONG *PLONGLONG;
  184. typedef DWORDLONG *PDWORDLONG;
  185.  
  186. // Update Sequence Number
  187.  
  188. typedef LONGLONG USN;
  189.  
  190. #if defined(MIDL_PASS)
  191. typedef struct _LARGE_INTEGER {
  192. #else // MIDL_PASS
  193. typedef union _LARGE_INTEGER {
  194.     struct {
  195.         DWORD LowPart;
  196.         LONG HighPart;
  197. #ifdef __GNUC__
  198.     } x;
  199. #else
  200.     };
  201. #endif /* __GNUC__ */
  202.     struct {
  203.         DWORD LowPart;
  204.         LONG HighPart;
  205.     } u;
  206. #endif //MIDL_PASS
  207.     LONGLONG QuadPart;
  208. } LARGE_INTEGER;
  209.  
  210. typedef LARGE_INTEGER *PLARGE_INTEGER;
  211.  
  212.  
  213. #if defined(MIDL_PASS)
  214. typedef struct _ULARGE_INTEGER {
  215. #else // MIDL_PASS
  216. typedef union _ULARGE_INTEGER {
  217.     struct {
  218.         DWORD LowPart;
  219.         DWORD HighPart;
  220. #ifdef __GNUC__
  221.     } x;
  222. #else
  223.     };
  224. #endif /* __GNUC__ */
  225.     struct {
  226.         DWORD LowPart;
  227.         DWORD HighPart;
  228.     } u;
  229. #endif //MIDL_PASS
  230.     DWORDLONG QuadPart;
  231. } ULARGE_INTEGER;
  232.  
  233. typedef ULARGE_INTEGER *PULARGE_INTEGER;
  234.  
  235. // end_ntminiport end_ntndis
  236.  
  237. //
  238. // Locally Unique Identifier
  239. //
  240.  
  241. typedef LARGE_INTEGER LUID, *PLUID;
  242.  
  243.  
  244. //
  245. // Define operations to logically shift an int64 by 0..31 bits and to multiply
  246. // 32-bits by 32-bits to form a 64-bit product.
  247. //
  248.  
  249. #if defined(MIDL_PASS) || defined(RC_INVOKED)
  250.  
  251. //
  252. // Midl does not understand inline assembler. Therefore, the Rtl functions
  253. // are used for shifts by 0.31 and multiplies of 32-bits times 32-bits to
  254. // form a 64-bit product.
  255. //
  256.  
  257. #define Int32x32To64(a, b) ((LONGLONG)((LONG)(a)) * (LONGLONG)((LONG)(b)))
  258. #define UInt32x32To64(a, b) ((DWORDLONG)((DWORD)(a)) * (DWORDLONG)((DWORD)(b)))
  259.  
  260. #define Int64ShllMod32(a, b) ((DWORDLONG)(a) << (b))
  261. #define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
  262. #define Int64ShrlMod32(a, b) ((DWORDLONG)(a) >> (b))
  263.  
  264. #elif defined(_M_MRX000)
  265.  
  266. //
  267. // MIPS uses intrinsic functions to perform shifts by 0..31 and multiplies of
  268. // 32-bits times 32-bits to 64-bits.
  269. //
  270.  
  271. #define Int32x32To64 __emul
  272. #define UInt32x32To64 __emulu
  273.  
  274. #define Int64ShllMod32 __ll_lshift
  275. #define Int64ShraMod32 __ll_rshift
  276. #define Int64ShrlMod32 __ull_rshift
  277.  
  278. #if defined (__cplusplus)
  279. extern "C" {
  280. #endif
  281.  
  282. LONGLONG
  283. NTAPI
  284. Int32x32To64 (
  285.     LONG Multiplier,
  286.     LONG Multiplicand
  287.     );
  288.  
  289. DWORDLONG
  290. NTAPI
  291. UInt32x32To64 (
  292.     DWORD Multiplier,
  293.     DWORD Multiplicand
  294.     );
  295.  
  296. DWORDLONG
  297. NTAPI
  298. Int64ShllMod32 (
  299.     DWORDLONG Value,
  300.     DWORD ShiftCount
  301.     );
  302.  
  303. LONGLONG
  304. NTAPI
  305. Int64ShraMod32 (
  306.     LONGLONG Value,
  307.     DWORD ShiftCount
  308.     );
  309.  
  310. DWORDLONG
  311. NTAPI
  312. Int64ShrlMod32 (
  313.     DWORDLONG Value,
  314.     DWORD ShiftCount
  315.     );
  316.  
  317. #if defined (__cplusplus)
  318. };
  319. #endif
  320.  
  321. #pragma intrinsic(__emul)
  322. #pragma intrinsic(__emulu)
  323.  
  324. #pragma intrinsic(__ll_lshift)
  325. #pragma intrinsic(__ll_rshift)
  326. #pragma intrinsic(__ull_rshift)
  327.  
  328. #elif defined(_M_IX86)
  329.  
  330. //
  331. // The x86 C compiler understands inline assembler. Therefore, inline functions
  332. // that employ inline assembler are used for shifts of 0..31.  The multiplies
  333. // rely on the compiler recognizing the cast of the multiplicand to int64 to
  334. // generate the optimal code inline.
  335. //
  336.  
  337. #define Int32x32To64( a, b ) (LONGLONG)((LONGLONG)(LONG)(a) * (LONG)(b))
  338. #define UInt32x32To64( a, b ) (DWORDLONG)((DWORDLONG)(DWORD)(a) * (DWORD)(b))
  339.  
  340. DWORDLONG
  341. NTAPI
  342. Int64ShllMod32 (
  343.     DWORDLONG Value,
  344.     DWORD ShiftCount
  345.     );
  346.  
  347. LONGLONG
  348. NTAPI
  349. Int64ShraMod32 (
  350.     LONGLONG Value,
  351.     DWORD ShiftCount
  352.     );
  353.  
  354. DWORDLONG
  355. NTAPI
  356. Int64ShrlMod32 (
  357.     DWORDLONG Value,
  358.     DWORD ShiftCount
  359.     );
  360.  
  361. #if !defined (__cplusplus)
  362.  
  363. #pragma warning(disable:4035)               // re-enable below
  364.  
  365. #ifndef __GNUC__
  366. __inline DWORDLONG
  367. NTAPI
  368. Int64ShllMod32 (
  369.     DWORDLONG Value,
  370.     DWORD ShiftCount
  371.     )
  372. {
  373.     _asm    {
  374.         mov     ecx, ShiftCount
  375.         mov     eax, dword ptr [Value]
  376.         mov     edx, dword ptr [Value+4]
  377.         shld    edx, eax, cl
  378.         shl     eax, cl
  379.     }
  380. }
  381.  
  382. __inline LONGLONG
  383. NTAPI
  384. Int64ShraMod32 (
  385.     LONGLONG Value,
  386.     DWORD ShiftCount
  387.     )
  388. {
  389.     _asm {
  390.         mov     ecx, ShiftCount
  391.         mov     eax, dword ptr [Value]
  392.         mov     edx, dword ptr [Value+4]
  393.         shrd    eax, edx, cl
  394.         sar     edx, cl
  395.     }
  396. }
  397.  
  398. __inline DWORDLONG
  399. NTAPI
  400. Int64ShrlMod32 (
  401.     DWORDLONG Value,
  402.     DWORD ShiftCount
  403.     )
  404. {
  405.     _asm    {
  406.         mov     ecx, ShiftCount
  407.         mov     eax, dword ptr [Value]
  408.         mov     edx, dword ptr [Value+4]
  409.         shrd    eax, edx, cl
  410.         shr     edx, cl
  411.     }
  412. }
  413. #endif /* __GNUC__ */
  414.  
  415. #else
  416.  
  417. #define Int64ShllMod32(a, b) ((DWORDLONG)(a) << (b))
  418. #define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
  419. #define Int64ShrlMod32(a, b) ((DWORDLONG)(a) >> (b))
  420.  
  421. #endif // !defined (__cplusplus)
  422.  
  423. #pragma warning(default:4035)
  424.  
  425. #elif defined(_M_ALPHA)
  426.  
  427. //
  428. // Alpha has native 64-bit operations that are just as fast as their 32-bit
  429. // counter parts. Therefore, the int64 data type is used directly to form
  430. // shifts of 0..31 and multiplies of 32-bits times 32-bits to form a 64-bit
  431. // product.
  432. //
  433.  
  434. #define Int32x32To64(a, b) ((LONGLONG)((LONG)(a)) * (LONGLONG)((LONG)(b)))
  435. #define UInt32x32To64(a, b) ((DWORDLONG)((DWORD)(a)) * (DWORDLONG)((DWORD)(b)))
  436.  
  437. #define Int64ShllMod32(a, b) ((DWORDLONG)(a) << (b))
  438. #define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
  439. #define Int64ShrlMod32(a, b) ((DWORDLONG)(a) >> (b))
  440.  
  441.  
  442. #elif defined(_M_PPC)
  443.  
  444. #define Int32x32To64(a, b) ((LONGLONG)((LONG)(a)) * (LONGLONG)((LONG)(b)))
  445. #define UInt32x32To64(a, b) ((DWORDLONG)((DWORD)(a)) * (DWORDLONG)((DWORD)(b)))
  446.  
  447. #define Int64ShllMod32(a, b) ((DWORDLONG)(a) << (b))
  448. #define Int64ShraMod32(a, b) ((LONGLONG)(a) >> (b))
  449. #define Int64ShrlMod32(a, b) ((DWORDLONG)(a) >> (b))
  450.  
  451. #else
  452.  
  453. #error Must define a target architecture.
  454.  
  455. #endif
  456.  
  457. #define UNICODE_NULL ((WCHAR)0) 
  458. typedef BYTE  BOOLEAN;           
  459. typedef BOOLEAN *PBOOLEAN;       
  460. //
  461. //  Doubly linked list structure.  Can be used as either a list head, or
  462. //  as link words.
  463. //
  464.  
  465. typedef struct _LIST_ENTRY {
  466.    struct _LIST_ENTRY *Flink;
  467.    struct _LIST_ENTRY *Blink;
  468. } LIST_ENTRY, *PLIST_ENTRY, *RESTRICTED_POINTER PRLIST_ENTRY;
  469.  
  470. //
  471. //  Singly linked list structure. Can be used as either a list head, or
  472. //  as link words.
  473. //
  474.  
  475. typedef struct _SINGLE_LIST_ENTRY {
  476.     struct _SINGLE_LIST_ENTRY *Next;
  477. } SINGLE_LIST_ENTRY, *PSINGLE_LIST_ENTRY;
  478.  
  479. //
  480. // Base data structures for OLE support
  481. //
  482.  
  483. #ifndef GUID_DEFINED
  484. #define GUID_DEFINED
  485.  
  486. typedef struct _GUID {          // size is 16
  487.     DWORD Data1;
  488.     WORD   Data2;
  489.     WORD   Data3;
  490.     BYTE  Data4[8];
  491. } GUID;
  492.  
  493. #endif // !GUID_DEFINED
  494.  
  495. #ifndef __OBJECTID_DEFINED
  496. #define __OBJECTID_DEFINED
  497.  
  498. typedef struct  _OBJECTID {     // size is 20
  499.     GUID Lineage;
  500.     DWORD Uniquifier;
  501. } OBJECTID;
  502. #endif // !_OBJECTID_DEFINED
  503.  
  504. #define MINCHAR     0x80        
  505. #define MAXCHAR     0x7f        
  506. #define MINSHORT    0x8000      
  507. #define MAXSHORT    0x7fff      
  508. #define MINLONG     0x80000000  
  509. #define MAXLONG     0x7fffffff  
  510. #define MAXBYTE     0xff        
  511. #define MAXWORD     0xffff      
  512. #define MAXDWORD    0xffffffff  
  513. //
  514. // Calculate the byte offset of a field in a structure of type type.
  515. //
  516.  
  517. #define FIELD_OFFSET(type, field)    ((LONG)&(((type *)0)->field))
  518.  
  519.  
  520. //
  521. // Calculate the address of the base of the structure given its type, and an
  522. // address of a field within the structure.
  523. //
  524.  
  525. #define CONTAINING_RECORD(address, type, field) ((type *)( \
  526.                                                   (PCHAR)(address) - \
  527.                                                   (PCHAR)(&((type *)0)->field)))
  528.  
  529. /*
  530.  *  Language IDs.
  531.  *
  532.  *  The following two combinations of primary language ID and
  533.  *  sublanguage ID have special semantics:
  534.  *
  535.  *    Primary Language ID   Sublanguage ID      Result
  536.  *    -------------------   ---------------     ------------------------
  537.  *    LANG_NEUTRAL          SUBLANG_NEUTRAL     Language neutral
  538.  *    LANG_NEUTRAL          SUBLANG_DEFAULT     User default language
  539.  *    LANG_NEUTRAL          SUBLANG_SYS_DEFAULT System default language
  540.  */
  541.  
  542. /*
  543.  *  Primary language IDs.
  544.  */
  545. #define LANG_NEUTRAL                     0x00
  546.  
  547. #define LANG_ARABIC                      0x01
  548. #define LANG_AFRIKAANS                   0x36
  549. #define LANG_ALBANIAN                    0x1c
  550. #define LANG_BASQUE                      0x2d
  551. #define LANG_BULGARIAN                   0x02
  552. #define LANG_BYELORUSSIAN                0x23
  553. #define LANG_CATALAN                     0x03
  554. #define LANG_CHINESE                     0x04
  555. #define LANG_CROATIAN                    0x1a
  556. #define LANG_CZECH                       0x05
  557. #define LANG_DANISH                      0x06
  558. #define LANG_DUTCH                       0x13
  559. #define LANG_ENGLISH                     0x09
  560. #define LANG_ESTONIAN                    0x25
  561. #define LANG_FAEROESE                    0x38
  562. #define LANG_FARSI                       0x29
  563. #define LANG_FINNISH                     0x0b
  564. #define LANG_FRENCH                      0x0c
  565. #define LANG_GERMAN                      0x07
  566. #define LANG_GREEK                       0x08
  567. #define LANG_HEBREW                      0x0D
  568. #define LANG_HUNGARIAN                   0x0e
  569. #define LANG_ICELANDIC                   0x0f
  570. #define LANG_INDONESIAN                  0x21
  571. #define LANG_ITALIAN                     0x10
  572. #define LANG_JAPANESE                    0x11
  573. #define LANG_KOREAN                      0x12
  574. #define LANG_LATVIAN                     0x26
  575. #define LANG_LITHUANIAN                  0x27
  576. #define LANG_NORWEGIAN                   0x14
  577. #define LANG_POLISH                      0x15
  578. #define LANG_PORTUGUESE                  0x16
  579. #define LANG_ROMANIAN                    0x18
  580. #define LANG_RUSSIAN                     0x19
  581. #define LANG_SLOVAK                      0x1b
  582. #define LANG_SLOVENIAN                   0x24
  583. #define LANG_SORBIAN                     0x2e
  584. #define LANG_SPANISH                     0x0a
  585. #define LANG_SWEDISH                     0x1d
  586. #define LANG_THAI                        0x1e
  587. #define LANG_TURKISH                     0x1f
  588. #define LANG_UKRAINIAN                   0x22
  589.  
  590. /*
  591.  *  Sublanguage IDs.
  592.  *
  593.  *  The name immediately following SUBLANG_ dictates which primary
  594.  *  language ID that sublanguage ID can be combined with to form a
  595.  *  valid language ID.
  596.  */
  597. #define SUBLANG_NEUTRAL                  0x00    /* language neutral */
  598. #define SUBLANG_DEFAULT                  0x01    /* user default */
  599. #define SUBLANG_SYS_DEFAULT              0x02    /* system default */
  600.  
  601. #define SUBLANG_ARABIC                   0x01    /* Arabic (Saudi Arabia) */
  602. #define SUBLANG_ARABIC_IRAQ              0x02    /* Arabic (Iraq) */
  603. #define SUBLANG_ARABIC_EGYPT             0x03    /* Arabic (Egypt) */
  604. #define SUBLANG_ARABIC_LIBYA             0x04    /* Arabic (Libya) */
  605. #define SUBLANG_ARABIC_ALGERIA           0x05    /* Arabic (Algeria) */
  606. #define SUBLANG_ARABIC_MOROCCO           0x06    /* Arabic (Morocco) */
  607. #define SUBLANG_ARABIC_TUNISIA           0x07    /* Arabic (Tunisia) */
  608. #define SUBLANG_ARABIC_OMAN              0x08    /* Arabic (Oman) */
  609. #define SUBLANG_ARABIC_YEMEN             0x09    /* Arabic (Yemen) */
  610. #define SUBLANG_ARABIC_SYRIA             0x10    /* Arabic (Syria) */
  611. #define SUBLANG_ARABIC_JORDAN            0x11    /* Arabic (Jordan) */
  612. #define SUBLANG_ARABIC_LEBANON           0x12    /* Arabic (Lebanon) */
  613. #define SUBLANG_ARABIC_KUWAIT            0x13    /* Arabic (Kuwait) */
  614. #define SUBLANG_ARABIC_UAE               0x14    /* Arabic (United Arab Emirates) */
  615. #define SUBLANG_ARABIC_BAHRAIN           0x15    /* Arabic (Bahrain) */
  616. #define SUBLANG_ARABIC_QATAR             0x16    /* Arabic (Qatar) */
  617. #define SUBLANG_CHINESE_TRADITIONAL      0x01    /* Chinese (Taiwan) */
  618. #define SUBLANG_CHINESE_SIMPLIFIED       0x02    /* Chinese (PR China) */
  619. #define SUBLANG_CHINESE_HONGKONG         0x03    /* Chinese (Hong Kong) */
  620. #define SUBLANG_CHINESE_SINGAPORE        0x04    /* Chinese (Singapore) */
  621. #define SUBLANG_DUTCH                    0x01    /* Dutch */
  622. #define SUBLANG_DUTCH_BELGIAN            0x02    /* Dutch (Belgian) */
  623. #define SUBLANG_ENGLISH_US               0x01    /* English (USA) */
  624. #define SUBLANG_ENGLISH_UK               0x02    /* English (UK) */
  625. #define SUBLANG_ENGLISH_AUS              0x03    /* English (Australian) */
  626. #define SUBLANG_ENGLISH_CAN              0x04    /* English (Canadian) */
  627. #define SUBLANG_ENGLISH_NZ               0x05    /* English (New Zealand) */
  628. #define SUBLANG_ENGLISH_EIRE             0x06    /* English (Irish) */
  629. #define SUBLANG_ENGLISH_SAFRICA          0x07    /* English (South Africa) */
  630. #define SUBLANG_ENGLISH_JAMAICA          0x08    /* English (Jamaica) */
  631. #define SUBLANG_ENGLISH_CARRIBEAN        0x09    /* English (Carribean) */
  632. #define SUBLANG_FRENCH                   0x01    /* French */
  633. #define SUBLANG_FRENCH_BELGIAN           0x02    /* French (Belgian) */
  634. #define SUBLANG_FRENCH_CANADIAN          0x03    /* French (Canadian) */
  635. #define SUBLANG_FRENCH_SWISS             0x04    /* French (Swiss) */
  636. #define SUBLANG_FRENCH_LUXEMBOURG        0x05    /* French (Luxembourg) */
  637. #define SUBLANG_GERMAN                   0x01    /* German */
  638. #define SUBLANG_GERMAN_SWISS             0x02    /* German (Swiss) */
  639. #define SUBLANG_GERMAN_AUSTRIAN          0x03    /* German (Austrian) */
  640. #define SUBLANG_GERMAN_LUXEMBOURG        0x04    /* German (Luxembourg) */
  641. #define SUBLANG_GERMAN_LIECHTENSTEIN     0x05    /* German (Liechtenstein) */
  642. #define SUBLANG_ITALIAN                  0x01    /* Italian */
  643. #define SUBLANG_ITALIAN_SWISS            0x02    /* Italian (Swiss) */
  644. #define SUBLANG_KOREAN                   0x01    /* Korean */
  645. #define SUBLANG_KOREAN_JOHAB             0x02    /* Korean (Johab) */
  646. #define SUBLANG_NORWEGIAN_BOKMAL         0x01    /* Norwegian (Bokmal) */
  647. #define SUBLANG_NORWEGIAN_NYNORSK        0x02    /* Norwegian (Nynorsk) */
  648. #define SUBLANG_PORTUGUESE               0x02    /* Portuguese */
  649. #define SUBLANG_PORTUGUESE_BRAZILIAN     0x01    /* Portuguese (Brazilian) */
  650. #define SUBLANG_SPANISH                  0x01    /* Spanish (Castilian) */
  651. #define SUBLANG_SPANISH_MEXICAN          0x02    /* Spanish (Mexican) */
  652. #define SUBLANG_SPANISH_MODERN           0x03    /* Spanish (Modern) */
  653. #define SUBLANG_SPANISH_GUATEMALA        0x04    /* Spanish (Guatemala) */
  654. #define SUBLANG_SPANISH_COSTARICA        0x05    /* Spanish (Costa Rica) */
  655. #define SUBLANG_SPANISH_PANAMA           0x06    /* Spanish (Panama) */
  656. #define SUBLANG_SPANISH_DOMINICAN        0x07    /* Spanish (Dominican Republic) */
  657. #define SUBLANG_SPANISH_VENEZUELA        0x08    /* Spanish (Venezuela) */
  658. #define SUBLANG_SPANISH_COLOMBIA         0x09    /* Spanish (Colombia) */
  659. #define SUBLANG_SPANISH_PERU             0x10    /* Spanish (Peru) */
  660. #define SUBLANG_SPANISH_ARGENTINA        0x11    /* Spanish (Argentina) */
  661. #define SUBLANG_SPANISH_ECUADOR          0x12    /* Spanish (Ecuador) */
  662. #define SUBLANG_SPANISH_CHILE            0x13    /* Spanish (Chile) */
  663. #define SUBLANG_SPANISH_URUGUAY          0x14    /* Spanish (Uruguay) */
  664. #define SUBLANG_SPANISH_PARAGUAY         0x15    /* Spanish (Paraguay) */
  665. #define SUBLANG_SPANISH_BOLIVIA          0x16    /* Spanish (Bolivia) */
  666.  
  667. /*
  668.  *  Sorting IDs.
  669.  *
  670.  */
  671. #define SORT_DEFAULT                     0x0     /* sorting default */
  672.  
  673. #define SORT_JAPANESE_XJIS               0x0     /* Japanese XJIS order */
  674. #define SORT_JAPANESE_UNICODE            0x1     /* Japanese Unicode order */
  675.  
  676. #define SORT_CHINESE_BIG5                0x0     /* Chinese BIG5 order */
  677. #define SORT_CHINESE_UNICODE             0x1     /* Chinese Unicode order */
  678.  
  679. #define SORT_KOREAN_KSC                  0x0     /* Korean KSC order */
  680. #define SORT_KOREAN_UNICODE              0x1     /* Korean Unicode order */
  681.  
  682.  
  683. /*
  684.  *  A language ID is a 16 bit value which is the combination of a
  685.  *  primary language ID and a secondary language ID.  The bits are
  686.  *  allocated as follows:
  687.  *
  688.  *       +-----------------------+-------------------------+
  689.  *       |     Sublanguage ID    |   Primary Language ID   |
  690.  *       +-----------------------+-------------------------+
  691.  *        15                   10 9                       0   bit
  692.  *
  693.  *
  694.  *  Language ID creation/extraction macros:
  695.  *
  696.  *    MAKELANGID    - construct language id from a primary language id and
  697.  *                    a sublanguage id.
  698.  *    PRIMARYLANGID - extract primary language id from a language id.
  699.  *    SUBLANGID     - extract sublanguage id from a language id.
  700.  */
  701. #define MAKELANGID(p, s)       ((((WORD  )(s)) << 10) | (WORD  )(p))
  702. #define PRIMARYLANGID(lgid)    ((WORD  )(lgid) & 0x3ff)
  703. #define SUBLANGID(lgid)        ((WORD  )(lgid) >> 10)
  704.  
  705.  
  706. /*
  707.  *  A locale ID is a 32 bit value which is the combination of a
  708.  *  language ID, a sort ID, and a reserved area.  The bits are
  709.  *  allocated as follows:
  710.  *
  711.  *       +-------------+---------+-------------------------+
  712.  *       |   Reserved  | Sort ID |      Language ID        |
  713.  *       +-------------+---------+-------------------------+
  714.  *        31         20 19     16 15                      0   bit
  715.  *
  716.  *
  717.  *  Locale ID creation/extraction macros:
  718.  *
  719.  *    MAKELCID       - construct locale id from a language id and a sort id.
  720.  *    LANGIDFROMLCID - extract language id from a locale id.
  721.  *    SORTIDFROMLCID - extract sort id from a locale id.
  722.  */
  723. #define NLS_VALID_LOCALE_MASK  0x000fffff
  724.  
  725. #define MAKELCID(lgid, srtid)  ((DWORD)((((DWORD)((WORD  )(srtid))) << 16) |  \
  726.                                          ((DWORD)((WORD  )(lgid)))))
  727. #define LANGIDFROMLCID(lcid)   ((WORD  )(lcid))
  728. #define SORTIDFROMLCID(lcid)   ((WORD  )((((DWORD)(lcid)) & NLS_VALID_LOCALE_MASK) >> 16))
  729.  
  730.  
  731. /*
  732.  *  Default System and User IDs for language and locale.
  733.  */
  734. #define LANG_SYSTEM_DEFAULT    (MAKELANGID(LANG_NEUTRAL, SUBLANG_SYS_DEFAULT))
  735. #define LANG_USER_DEFAULT      (MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT))
  736.  
  737. #define LOCALE_SYSTEM_DEFAULT  (MAKELCID(LANG_SYSTEM_DEFAULT, SORT_DEFAULT))
  738. #define LOCALE_USER_DEFAULT    (MAKELCID(LANG_USER_DEFAULT, SORT_DEFAULT))
  739.  
  740.  
  741.  
  742. // begin_ntminiport begin_ntndis
  743.  
  744. //
  745. // Macros used to eliminate compiler warning generated when formal
  746. // parameters or local variables are not declared.
  747. //
  748. // Use DBG_UNREFERENCED_PARAMETER() when a parameter is not yet
  749. // referenced but will be once the module is completely developed.
  750. //
  751. // Use DBG_UNREFERENCED_LOCAL_VARIABLE() when a local variable is not yet
  752. // referenced but will be once the module is completely developed.
  753. //
  754. // Use UNREFERENCED_PARAMETER() if a parameter will never be referenced.
  755. //
  756. // DBG_UNREFERENCED_PARAMETER and DBG_UNREFERENCED_LOCAL_VARIABLE will
  757. // eventually be made into a null macro to help determine whether there
  758. // is unfinished work.
  759. //
  760.  
  761. #if ! (defined(lint) || defined(_lint))
  762. #define UNREFERENCED_PARAMETER(P)          (P)
  763. #define DBG_UNREFERENCED_PARAMETER(P)      (P)
  764. #define DBG_UNREFERENCED_LOCAL_VARIABLE(V) (V)
  765.  
  766. #else // lint or _lint
  767.  
  768. // Note: lint -e530 says don't complain about uninitialized variables for
  769. // this.  line +e530 turns that checking back on.  Error 527 has to do with
  770. // unreachable code.
  771.  
  772. #define UNREFERENCED_PARAMETER(P)          \
  773.     /*lint -e527 -e530 */ \
  774.     { \
  775.         (P) = (P); \
  776.     } \
  777.     /*lint +e527 +e530 */
  778. #define DBG_UNREFERENCED_PARAMETER(P)      \
  779.     /*lint -e527 -e530 */ \
  780.     { \
  781.         (P) = (P); \
  782.     } \
  783.     /*lint +e527 +e530 */
  784. #define DBG_UNREFERENCED_LOCAL_VARIABLE(V) \
  785.     /*lint -e527 -e530 */ \
  786.     { \
  787.         (V) = (V); \
  788.     } \
  789.     /*lint +e527 +e530 */
  790.  
  791. #endif // lint or _lint
  792.  
  793.  
  794. #ifndef WIN32_NO_STATUS 
  795. /*lint -save -e767 */  
  796. #define STATUS_WAIT_0                    ((DWORD   )0x00000000L)    
  797. #define STATUS_ABANDONED_WAIT_0          ((DWORD   )0x00000080L)    
  798. #define STATUS_USER_APC                  ((DWORD   )0x000000C0L)    
  799. #define STATUS_TIMEOUT                   ((DWORD   )0x00000102L)    
  800. #define STATUS_PENDING                   ((DWORD   )0x00000103L)    
  801. #define STATUS_SEGMENT_NOTIFICATION      ((DWORD   )0x40000005L)    
  802. #define STATUS_GUARD_PAGE_VIOLATION      ((DWORD   )0x80000001L)    
  803. #define STATUS_DATATYPE_MISALIGNMENT     ((DWORD   )0x80000002L)    
  804. #define STATUS_BREAKPOINT                ((DWORD   )0x80000003L)    
  805. #define STATUS_SINGLE_STEP               ((DWORD   )0x80000004L)    
  806. #define STATUS_ACCESS_VIOLATION          ((DWORD   )0xC0000005L)    
  807. #define STATUS_IN_PAGE_ERROR             ((DWORD   )0xC0000006L)    
  808. #define STATUS_NO_MEMORY                 ((DWORD   )0xC0000017L)    
  809. #define STATUS_ILLEGAL_INSTRUCTION       ((DWORD   )0xC000001DL)    
  810. #define STATUS_NONCONTINUABLE_EXCEPTION  ((DWORD   )0xC0000025L)    
  811. #define STATUS_INVALID_DISPOSITION       ((DWORD   )0xC0000026L)    
  812. #define STATUS_ARRAY_BOUNDS_EXCEEDED     ((DWORD   )0xC000008CL)    
  813. #define STATUS_FLOAT_DENORMAL_OPERAND    ((DWORD   )0xC000008DL)    
  814. #define STATUS_FLOAT_DIVIDE_BY_ZERO      ((DWORD   )0xC000008EL)    
  815. #define STATUS_FLOAT_INEXACT_RESULT      ((DWORD   )0xC000008FL)    
  816. #define STATUS_FLOAT_INVALID_OPERATION   ((DWORD   )0xC0000090L)    
  817. #define STATUS_FLOAT_OVERFLOW            ((DWORD   )0xC0000091L)    
  818. #define STATUS_FLOAT_STACK_CHECK         ((DWORD   )0xC0000092L)    
  819. #define STATUS_FLOAT_UNDERFLOW           ((DWORD   )0xC0000093L)    
  820. #define STATUS_INTEGER_DIVIDE_BY_ZERO    ((DWORD   )0xC0000094L)    
  821. #define STATUS_INTEGER_OVERFLOW          ((DWORD   )0xC0000095L)    
  822. #define STATUS_PRIVILEGED_INSTRUCTION    ((DWORD   )0xC0000096L)    
  823. #define STATUS_STACK_OVERFLOW            ((DWORD   )0xC00000FDL)    
  824. #define STATUS_CONTROL_C_EXIT            ((DWORD   )0xC000013AL)    
  825. /*lint -restore */  
  826. #endif 
  827. #define MAXIMUM_WAIT_OBJECTS 64     // Maximum number of wait objects
  828.  
  829. #define MAXIMUM_SUSPEND_COUNT MAXCHAR // Maximum times thread can be suspended
  830. typedef DWORD KSPIN_LOCK;  
  831.  
  832. #ifdef _ALPHA_
  833.  
  834. // begin_ntddk begin_nthal
  835. //
  836. // The following flags control the contents of the CONTEXT structure.
  837. //
  838.  
  839. #if !defined(RC_INVOKED)
  840.  
  841. #define CONTEXT_PORTABLE_32BIT     0x00100000
  842. #define CONTEXT_ALPHA              0x00020000
  843.  
  844. #define CONTEXT_CONTROL         (CONTEXT_ALPHA | 0x00000001L)
  845. #define CONTEXT_FLOATING_POINT  (CONTEXT_ALPHA | 0x00000002L)
  846. #define CONTEXT_INTEGER         (CONTEXT_ALPHA | 0x00000004L)
  847.  
  848. #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
  849.  
  850. #endif
  851.  
  852. #ifndef _PORTABLE_32BIT_CONTEXT
  853.  
  854. //
  855. // Context Frame
  856. //
  857. //  This frame has a several purposes: 1) it is used as an argument to
  858. //  NtContinue, 2) it is used to construct a call frame for APC delivery,
  859. //  3) it is used to construct a call frame for exception dispatching
  860. //  in user mode, 4) it is used in the user level thread creation
  861. //  routines, and 5) it is used to to pass thread state to debuggers.
  862. //
  863. //  N.B. Because this record is used as a call frame, it must be EXACTLY
  864. //  a multiple of 16 bytes in length.
  865. //
  866. //  There are two variations of the context structure. This is the real one.
  867. //
  868.  
  869. typedef struct _CONTEXT {
  870.  
  871.     //
  872.     // This section is specified/returned if the ContextFlags word contains
  873.     // the flag CONTEXT_FLOATING_POINT.
  874.     //
  875.  
  876.     DWORDLONG FltF0;
  877.     DWORDLONG FltF1;
  878.     DWORDLONG FltF2;
  879.     DWORDLONG FltF3;
  880.     DWORDLONG FltF4;
  881.     DWORDLONG FltF5;
  882.     DWORDLONG FltF6;
  883.     DWORDLONG FltF7;
  884.     DWORDLONG FltF8;
  885.     DWORDLONG FltF9;
  886.     DWORDLONG FltF10;
  887.     DWORDLONG FltF11;
  888.     DWORDLONG FltF12;
  889.     DWORDLONG FltF13;
  890.     DWORDLONG FltF14;
  891.     DWORDLONG FltF15;
  892.     DWORDLONG FltF16;
  893.     DWORDLONG FltF17;
  894.     DWORDLONG FltF18;
  895.     DWORDLONG FltF19;
  896.     DWORDLONG FltF20;
  897.     DWORDLONG FltF21;
  898.     DWORDLONG FltF22;
  899.     DWORDLONG FltF23;
  900.     DWORDLONG FltF24;
  901.     DWORDLONG FltF25;
  902.     DWORDLONG FltF26;
  903.     DWORDLONG FltF27;
  904.     DWORDLONG FltF28;
  905.     DWORDLONG FltF29;
  906.     DWORDLONG FltF30;
  907.     DWORDLONG FltF31;
  908.  
  909.     //
  910.     // This section is specified/returned if the ContextFlags word contains
  911.     // the flag CONTEXT_INTEGER.
  912.     //
  913.     // N.B. The registers gp, sp, and ra are defined in this section, but are
  914.     //  considered part of the control context rather than part of the integer
  915.     //  context.
  916.     //
  917.  
  918.     DWORDLONG IntV0;    //  $0: return value register, v0
  919.     DWORDLONG IntT0;    //  $1: temporary registers, t0 - t7
  920.     DWORDLONG IntT1;    //  $2:
  921.     DWORDLONG IntT2;    //  $3:
  922.     DWORDLONG IntT3;    //  $4:
  923.     DWORDLONG IntT4;    //  $5:
  924.     DWORDLONG IntT5;    //  $6:
  925.     DWORDLONG IntT6;    //  $7:
  926.     DWORDLONG IntT7;    //  $8:
  927.     DWORDLONG IntS0;    //  $9: nonvolatile registers, s0 - s5
  928.     DWORDLONG IntS1;    // $10:
  929.     DWORDLONG IntS2;    // $11:
  930.     DWORDLONG IntS3;    // $12:
  931.     DWORDLONG IntS4;    // $13:
  932.     DWORDLONG IntS5;    // $14:
  933.     DWORDLONG IntFp;    // $15: frame pointer register, fp/s6
  934.     DWORDLONG IntA0;    // $16: argument registers, a0 - a5
  935.     DWORDLONG IntA1;    // $17:
  936.     DWORDLONG IntA2;    // $18:
  937.     DWORDLONG IntA3;    // $19:
  938.     DWORDLONG IntA4;    // $20:
  939.     DWORDLONG IntA5;    // $21:
  940.     DWORDLONG IntT8;    // $22: temporary registers, t8 - t11
  941.     DWORDLONG IntT9;    // $23:
  942.     DWORDLONG IntT10;   // $24:
  943.     DWORDLONG IntT11;   // $25:
  944.     DWORDLONG IntRa;    // $26: return address register, ra
  945.     DWORDLONG IntT12;   // $27: temporary register, t12
  946.     DWORDLONG IntAt;    // $28: assembler temp register, at
  947.     DWORDLONG IntGp;    // $29: global pointer register, gp
  948.     DWORDLONG IntSp;    // $30: stack pointer register, sp
  949.     DWORDLONG IntZero;  // $31: zero register, zero
  950.  
  951.     //
  952.     // This section is specified/returned if the ContextFlags word contains
  953.     // the flag CONTEXT_FLOATING_POINT.
  954.     //
  955.  
  956.     DWORDLONG Fpcr;     // floating point control register
  957.     DWORDLONG SoftFpcr; // software extension to FPCR
  958.  
  959.     //
  960.     // This section is specified/returned if the ContextFlags word contains
  961.     // the flag CONTEXT_CONTROL.
  962.     //
  963.     // N.B. The registers gp, sp, and ra are defined in the integer section,
  964.     //   but are considered part of the control context rather than part of
  965.     //   the integer context.
  966.     //
  967.  
  968.     DWORDLONG Fir;      // (fault instruction) continuation address
  969.     DWORD Psr;          // processor status
  970.  
  971.     //
  972.     // The flags values within this flag control the contents of
  973.     // a CONTEXT record.
  974.     //
  975.     // If the context record is used as an input parameter, then
  976.     // for each portion of the context record controlled by a flag
  977.     // whose value is set, it is assumed that that portion of the
  978.     // context record contains valid context. If the context record
  979.     // is being used to modify a thread's context, then only that
  980.     // portion of the threads context will be modified.
  981.     //
  982.     // If the context record is used as an IN OUT parameter to capture
  983.     // the context of a thread, then only those portions of the thread's
  984.     // context corresponding to set flags will be returned.
  985.     //
  986.     // The context record is never used as an OUT only parameter.
  987.     //
  988.  
  989.     DWORD ContextFlags;
  990.     DWORD Fill[4];      // padding for 16-byte stack frame alignment
  991.  
  992. } CONTEXT, *PCONTEXT;
  993.  
  994. #else
  995.  
  996. //
  997. // 32-bit Context Frame
  998. //
  999. //  This alternate version of the Alpha context structure parallels that
  1000. //  of MIPS and IX86 in style for the first 64 entries: 32-bit machines
  1001. //  can operate on the fields, and a value declared as a pointer to an
  1002. //  array of int's can be used to index into the fields.  This makes life
  1003. //  with windbg and ntsd vastly easier.
  1004. //
  1005. //  There are two parts: the first contains the lower 32-bits of each
  1006. //  element in the 64-bit definition above.  The second part contains
  1007. //  the upper 32-bits of each 64-bit element above.
  1008. //
  1009. //  The names in the first part are identical to the 64-bit names.
  1010. //  The second part names are prefixed with "High".
  1011. //
  1012. //  1st half: at 32 bits each, (containing the low parts of 64-bit values)
  1013. //      32 floats, 32 ints, fpcrs, fir, psr, contextflags
  1014. //  2nd half: at 32 bits each
  1015. //      32 floats, 32 ints, fpcrs, fir, fill
  1016. //
  1017. //  There is no external support for the 32-bit version of the context
  1018. //  structure.  It is only used internally by windbg and ntsd.
  1019. //
  1020. //  This structure must be the same size as the 64-bit version above.
  1021. //
  1022.  
  1023. typedef struct _CONTEXT {
  1024.  
  1025.     DWORD FltF0;
  1026.     DWORD FltF1;
  1027.     DWORD FltF2;
  1028.     DWORD FltF3;
  1029.     DWORD FltF4;
  1030.     DWORD FltF5;
  1031.     DWORD FltF6;
  1032.     DWORD FltF7;
  1033.     DWORD FltF8;
  1034.     DWORD FltF9;
  1035.     DWORD FltF10;
  1036.     DWORD FltF11;
  1037.     DWORD FltF12;
  1038.     DWORD FltF13;
  1039.     DWORD FltF14;
  1040.     DWORD FltF15;
  1041.     DWORD FltF16;
  1042.     DWORD FltF17;
  1043.     DWORD FltF18;
  1044.     DWORD FltF19;
  1045.     DWORD FltF20;
  1046.     DWORD FltF21;
  1047.     DWORD FltF22;
  1048.     DWORD FltF23;
  1049.     DWORD FltF24;
  1050.     DWORD FltF25;
  1051.     DWORD FltF26;
  1052.     DWORD FltF27;
  1053.     DWORD FltF28;
  1054.     DWORD FltF29;
  1055.     DWORD FltF30;
  1056.     DWORD FltF31;
  1057.  
  1058.     DWORD IntV0;        //  $0: return value register, v0
  1059.     DWORD IntT0;        //  $1: temporary registers, t0 - t7
  1060.     DWORD IntT1;        //  $2:
  1061.     DWORD IntT2;        //  $3:
  1062.     DWORD IntT3;        //  $4:
  1063.     DWORD IntT4;        //  $5:
  1064.     DWORD IntT5;        //  $6:
  1065.     DWORD IntT6;        //  $7:
  1066.     DWORD IntT7;        //  $8:
  1067.     DWORD IntS0;        //  $9: nonvolatile registers, s0 - s5
  1068.     DWORD IntS1;        // $10:
  1069.     DWORD IntS2;        // $11:
  1070.     DWORD IntS3;        // $12:
  1071.     DWORD IntS4;        // $13:
  1072.     DWORD IntS5;        // $14:
  1073.     DWORD IntFp;        // $15: frame pointer register, fp/s6
  1074.     DWORD IntA0;        // $16: argument registers, a0 - a5
  1075.     DWORD IntA1;        // $17:
  1076.     DWORD IntA2;        // $18:
  1077.     DWORD IntA3;        // $19:
  1078.     DWORD IntA4;        // $20:
  1079.     DWORD IntA5;        // $21:
  1080.     DWORD IntT8;        // $22: temporary registers, t8 - t11
  1081.     DWORD IntT9;        // $23:
  1082.     DWORD IntT10;       // $24:
  1083.     DWORD IntT11;       // $25:
  1084.     DWORD IntRa;        // $26: return address register, ra
  1085.     DWORD IntT12;       // $27: temporary register, t12
  1086.     DWORD IntAt;        // $28: assembler temp register, at
  1087.     DWORD IntGp;        // $29: global pointer register, gp
  1088.     DWORD IntSp;        // $30: stack pointer register, sp
  1089.     DWORD IntZero;      // $31: zero register, zero
  1090.  
  1091.     DWORD Fpcr;         // floating point control register
  1092.     DWORD SoftFpcr;     // software extension to FPCR
  1093.  
  1094.     DWORD Fir;          // (fault instruction) continuation address
  1095.  
  1096.     DWORD Psr;          // processor status
  1097.     DWORD ContextFlags;
  1098.  
  1099.     //
  1100.     // Beginning of the "second half".
  1101.     // The name "High" parallels the HighPart of a LargeInteger.
  1102.     //
  1103.  
  1104.     DWORD HighFltF0;
  1105.     DWORD HighFltF1;
  1106.     DWORD HighFltF2;
  1107.     DWORD HighFltF3;
  1108.     DWORD HighFltF4;
  1109.     DWORD HighFltF5;
  1110.     DWORD HighFltF6;
  1111.     DWORD HighFltF7;
  1112.     DWORD HighFltF8;
  1113.     DWORD HighFltF9;
  1114.     DWORD HighFltF10;
  1115.     DWORD HighFltF11;
  1116.     DWORD HighFltF12;
  1117.     DWORD HighFltF13;
  1118.     DWORD HighFltF14;
  1119.     DWORD HighFltF15;
  1120.     DWORD HighFltF16;
  1121.     DWORD HighFltF17;
  1122.     DWORD HighFltF18;
  1123.     DWORD HighFltF19;
  1124.     DWORD HighFltF20;
  1125.     DWORD HighFltF21;
  1126.     DWORD HighFltF22;
  1127.     DWORD HighFltF23;
  1128.     DWORD HighFltF24;
  1129.     DWORD HighFltF25;
  1130.     DWORD HighFltF26;
  1131.     DWORD HighFltF27;
  1132.     DWORD HighFltF28;
  1133.     DWORD HighFltF29;
  1134.     DWORD HighFltF30;
  1135.     DWORD HighFltF31;
  1136.  
  1137.     DWORD HighIntV0;        //  $0: return value register, v0
  1138.     DWORD HighIntT0;        //  $1: temporary registers, t0 - t7
  1139.     DWORD HighIntT1;        //  $2:
  1140.     DWORD HighIntT2;        //  $3:
  1141.     DWORD HighIntT3;        //  $4:
  1142.     DWORD HighIntT4;        //  $5:
  1143.     DWORD HighIntT5;        //  $6:
  1144.     DWORD HighIntT6;        //  $7:
  1145.     DWORD HighIntT7;        //  $8:
  1146.     DWORD HighIntS0;        //  $9: nonvolatile registers, s0 - s5
  1147.     DWORD HighIntS1;        // $10:
  1148.     DWORD HighIntS2;        // $11:
  1149.     DWORD HighIntS3;        // $12:
  1150.     DWORD HighIntS4;        // $13:
  1151.     DWORD HighIntS5;        // $14:
  1152.     DWORD HighIntFp;        // $15: frame pointer register, fp/s6
  1153.     DWORD HighIntA0;        // $16: argument registers, a0 - a5
  1154.     DWORD HighIntA1;        // $17:
  1155.     DWORD HighIntA2;        // $18:
  1156.     DWORD HighIntA3;        // $19:
  1157.     DWORD HighIntA4;        // $20:
  1158.     DWORD HighIntA5;        // $21:
  1159.     DWORD HighIntT8;        // $22: temporary registers, t8 - t11
  1160.     DWORD HighIntT9;        // $23:
  1161.     DWORD HighIntT10;       // $24:
  1162.     DWORD HighIntT11;       // $25:
  1163.     DWORD HighIntRa;        // $26: return address register, ra
  1164.     DWORD HighIntT12;       // $27: temporary register, t12
  1165.     DWORD HighIntAt;        // $28: assembler temp register, at
  1166.     DWORD HighIntGp;        // $29: global pointer register, gp
  1167.     DWORD HighIntSp;        // $30: stack pointer register, sp
  1168.     DWORD HighIntZero;      // $31: zero register, zero
  1169.  
  1170.     DWORD HighFpcr;         // floating point control register
  1171.     DWORD HighSoftFpcr;     // software extension to FPCR
  1172.     DWORD HighFir;          // processor status
  1173.  
  1174.     double DoNotUseThisField; // to force quadword structure alignment
  1175.     DWORD HighFill[2];      // padding for 16-byte stack frame alignment
  1176.  
  1177. } CONTEXT, *PCONTEXT;
  1178.  
  1179. //
  1180. // These should name the fields in the _PORTABLE_32BIT structure
  1181. // that overlay the Psr and ContextFlags in the normal structure.
  1182. //
  1183.  
  1184. #define _QUAD_PSR_OFFSET   HighSoftFpcr
  1185. #define _QUAD_FLAGS_OFFSET HighFir
  1186.  
  1187. #endif // _PORTABLE_32BIT_CONTEXT
  1188.  
  1189. // end_ntddk end_nthal
  1190.  
  1191. #endif // _ALPHA_
  1192.  
  1193.  
  1194. #ifdef _ALPHA_
  1195.  
  1196. VOID
  1197. __jump_unwind (
  1198.     PVOID VirtualFramePointer,
  1199.     PVOID TargetPc
  1200.     );
  1201.  
  1202. #endif // _ALPHA_
  1203.  
  1204.  
  1205. #ifdef _X86_
  1206.  
  1207. //
  1208. // Disable these two pramas that evaluate to "sti" "cli" on x86 so that driver
  1209. // writers to not leave them inadvertantly in their code.
  1210. //
  1211.  
  1212. #if !defined(MIDL_PASS)
  1213. #if !defined(RC_INVOKED)
  1214.  
  1215. #pragma warning(disable:4164)   // disable C4164 warning so that apps that
  1216.                                 // build with /Od don't get weird errors !
  1217. #ifdef _M_IX86
  1218. #pragma function(_enable)
  1219. #pragma function(_disable)
  1220. #endif
  1221.  
  1222. #pragma warning(default:4164)   // reenable C4164 warning
  1223.  
  1224. #endif
  1225. #endif
  1226.  
  1227.  
  1228. //
  1229. //  Define the size of the 80387 save area, which is in the context frame.
  1230. //
  1231.  
  1232. #define SIZE_OF_80387_REGISTERS      80
  1233.  
  1234. //
  1235. // The following flags control the contents of the CONTEXT structure.
  1236. //
  1237.  
  1238. #if !defined(RC_INVOKED)
  1239.  
  1240. #define CONTEXT_i386    0x00010000    // this assumes that i386 and
  1241. #define CONTEXT_i486    0x00010000    // i486 have identical context records
  1242.  
  1243. #define CONTEXT_CONTROL         (CONTEXT_i386 | 0x00000001L) // SS:SP, CS:IP, FLAGS, BP
  1244. #define CONTEXT_INTEGER         (CONTEXT_i386 | 0x00000002L) // AX, BX, CX, DX, SI, DI
  1245. #define CONTEXT_SEGMENTS        (CONTEXT_i386 | 0x00000004L) // DS, ES, FS, GS
  1246. #define CONTEXT_FLOATING_POINT  (CONTEXT_i386 | 0x00000008L) // 387 state
  1247. #define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x00000010L) // DB 0-3,6,7
  1248.  
  1249. #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER |\
  1250.                       CONTEXT_SEGMENTS)
  1251.  
  1252. #endif
  1253.  
  1254. typedef struct _FLOATING_SAVE_AREA {
  1255.     DWORD   ControlWord;
  1256.     DWORD   StatusWord;
  1257.     DWORD   TagWord;
  1258.     DWORD   ErrorOffset;
  1259.     DWORD   ErrorSelector;
  1260.     DWORD   DataOffset;
  1261.     DWORD   DataSelector;
  1262.     BYTE    RegisterArea[SIZE_OF_80387_REGISTERS];
  1263.     DWORD   Cr0NpxState;
  1264. } FLOATING_SAVE_AREA;
  1265.  
  1266. typedef FLOATING_SAVE_AREA *PFLOATING_SAVE_AREA;
  1267.  
  1268. //
  1269. // Context Frame
  1270. //
  1271. //  This frame has a several purposes: 1) it is used as an argument to
  1272. //  NtContinue, 2) is is used to constuct a call frame for APC delivery,
  1273. //  and 3) it is used in the user level thread creation routines.
  1274. //
  1275. //  The layout of the record conforms to a standard call frame.
  1276. //
  1277.  
  1278. typedef struct _CONTEXT {
  1279.  
  1280.     //
  1281.     // The flags values within this flag control the contents of
  1282.     // a CONTEXT record.
  1283.     //
  1284.     // If the context record is used as an input parameter, then
  1285.     // for each portion of the context record controlled by a flag
  1286.     // whose value is set, it is assumed that that portion of the
  1287.     // context record contains valid context. If the context record
  1288.     // is being used to modify a threads context, then only that
  1289.     // portion of the threads context will be modified.
  1290.     //
  1291.     // If the context record is used as an IN OUT parameter to capture
  1292.     // the context of a thread, then only those portions of the thread's
  1293.     // context corresponding to set flags will be returned.
  1294.     //
  1295.     // The context record is never used as an OUT only parameter.
  1296.     //
  1297.  
  1298.     DWORD ContextFlags;
  1299.  
  1300.     //
  1301.     // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
  1302.     // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
  1303.     // included in CONTEXT_FULL.
  1304.     //
  1305.  
  1306.     DWORD   Dr0;
  1307.     DWORD   Dr1;
  1308.     DWORD   Dr2;
  1309.     DWORD   Dr3;
  1310.     DWORD   Dr6;
  1311.     DWORD   Dr7;
  1312.  
  1313.     //
  1314.     // This section is specified/returned if the
  1315.     // ContextFlags word contians the flag CONTEXT_FLOATING_POINT.
  1316.     //
  1317.  
  1318.     FLOATING_SAVE_AREA FloatSave;
  1319.  
  1320.     //
  1321.     // This section is specified/returned if the
  1322.     // ContextFlags word contians the flag CONTEXT_SEGMENTS.
  1323.     //
  1324.  
  1325.     DWORD   SegGs;
  1326.     DWORD   SegFs;
  1327.     DWORD   SegEs;
  1328.     DWORD   SegDs;
  1329.  
  1330.     //
  1331.     // This section is specified/returned if the
  1332.     // ContextFlags word contians the flag CONTEXT_INTEGER.
  1333.     //
  1334.  
  1335.     DWORD   Edi;
  1336.     DWORD   Esi;
  1337.     DWORD   Ebx;
  1338.     DWORD   Edx;
  1339.     DWORD   Ecx;
  1340.     DWORD   Eax;
  1341.  
  1342.     //
  1343.     // This section is specified/returned if the
  1344.     // ContextFlags word contians the flag CONTEXT_CONTROL.
  1345.     //
  1346.  
  1347.     DWORD   Ebp;
  1348.     DWORD   Eip;
  1349.     DWORD   SegCs;              // MUST BE SANITIZED
  1350.     DWORD   EFlags;             // MUST BE SANITIZED
  1351.     DWORD   Esp;
  1352.     DWORD   SegSs;
  1353.  
  1354. } CONTEXT;
  1355.  
  1356.  
  1357.  
  1358. typedef CONTEXT *PCONTEXT;
  1359.  
  1360. // begin_ntminiport
  1361.  
  1362. #endif //_X86_
  1363.  
  1364.  
  1365. typedef struct _LDT_ENTRY {
  1366.     WORD    LimitLow;
  1367.     WORD    BaseLow;
  1368.     union {
  1369.         struct {
  1370.             BYTE    BaseMid;
  1371.             BYTE    Flags1;     // Declare as bytes to avoid alignment
  1372.             BYTE    Flags2;     // Problems.
  1373.             BYTE    BaseHi;
  1374.         } Bytes;
  1375.         struct {
  1376.             DWORD   BaseMid : 8;
  1377.             DWORD   Type : 5;
  1378.             DWORD   Dpl : 2;
  1379.             DWORD   Pres : 1;
  1380.             DWORD   LimitHi : 4;
  1381.             DWORD   Sys : 1;
  1382.             DWORD   Reserved_0 : 1;
  1383.             DWORD   Default_Big : 1;
  1384.             DWORD   Granularity : 1;
  1385.             DWORD   BaseHi : 8;
  1386.         } Bits;
  1387.     } HighWord;
  1388. } LDT_ENTRY, *PLDT_ENTRY;
  1389.  
  1390.  
  1391. #if defined(_MIPS_)
  1392.  
  1393. // begin_ntddk begin_nthal
  1394. //
  1395. // The following flags control the contents of the CONTEXT structure.
  1396. //
  1397.  
  1398. #if !defined(RC_INVOKED)
  1399.  
  1400. #define CONTEXT_R4000   0x00010000    // r4000 context
  1401.  
  1402. #define CONTEXT_CONTROL         (CONTEXT_R4000 | 0x00000001L)
  1403. #define CONTEXT_FLOATING_POINT  (CONTEXT_R4000 | 0x00000002L)
  1404. #define CONTEXT_INTEGER         (CONTEXT_R4000 | 0x00000004L)
  1405.  
  1406. #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
  1407.  
  1408. #endif
  1409.  
  1410. //
  1411. // Context Frame
  1412. //
  1413. //  N.B. This frame must be exactly a multiple of 16 bytes in length.
  1414. //
  1415. //  This frame has a several purposes: 1) it is used as an argument to
  1416. //  NtContinue, 2) it is used to constuct a call frame for APC delivery,
  1417. //  3) it is used to construct a call frame for exception dispatching
  1418. //  in user mode, and 4) it is used in the user level thread creation
  1419. //  routines.
  1420. //
  1421. //  The layout of the record conforms to a standard call frame.
  1422. //
  1423.  
  1424. typedef struct _CONTEXT {
  1425.  
  1426.     //
  1427.     // This section is always present and is used as an argument build
  1428.     // area.
  1429.     //
  1430.  
  1431.     DWORD Argument[4];
  1432.  
  1433.     //
  1434.     // This section is specified/returned if the ContextFlags word contains
  1435.     // the flag CONTEXT_FLOATING_POINT.
  1436.     //
  1437.  
  1438.     DWORD FltF0;
  1439.     DWORD FltF1;
  1440.     DWORD FltF2;
  1441.     DWORD FltF3;
  1442.     DWORD FltF4;
  1443.     DWORD FltF5;
  1444.     DWORD FltF6;
  1445.     DWORD FltF7;
  1446.     DWORD FltF8;
  1447.     DWORD FltF9;
  1448.     DWORD FltF10;
  1449.     DWORD FltF11;
  1450.     DWORD FltF12;
  1451.     DWORD FltF13;
  1452.     DWORD FltF14;
  1453.     DWORD FltF15;
  1454.     DWORD FltF16;
  1455.     DWORD FltF17;
  1456.     DWORD FltF18;
  1457.     DWORD FltF19;
  1458.     DWORD FltF20;
  1459.     DWORD FltF21;
  1460.     DWORD FltF22;
  1461.     DWORD FltF23;
  1462.     DWORD FltF24;
  1463.     DWORD FltF25;
  1464.     DWORD FltF26;
  1465.     DWORD FltF27;
  1466.     DWORD FltF28;
  1467.     DWORD FltF29;
  1468.     DWORD FltF30;
  1469.     DWORD FltF31;
  1470.  
  1471.     //
  1472.     // This section is specified/returned if the ContextFlags word contains
  1473.     // the flag CONTEXT_INTEGER.
  1474.     //
  1475.     // N.B. The registers gp, sp, and ra are defined in this section, but are
  1476.     //  considered part of the control context rather than part of the integer
  1477.     //  context.
  1478.     //
  1479.     // N.B. Register zero is not stored in the frame.
  1480.     //
  1481.  
  1482.     DWORD IntZero;
  1483.     DWORD IntAt;
  1484.     DWORD IntV0;
  1485.     DWORD IntV1;
  1486.     DWORD IntA0;
  1487.     DWORD IntA1;
  1488.     DWORD IntA2;
  1489.     DWORD IntA3;
  1490.     DWORD IntT0;
  1491.     DWORD IntT1;
  1492.     DWORD IntT2;
  1493.     DWORD IntT3;
  1494.     DWORD IntT4;
  1495.     DWORD IntT5;
  1496.     DWORD IntT6;
  1497.     DWORD IntT7;
  1498.     DWORD IntS0;
  1499.     DWORD IntS1;
  1500.     DWORD IntS2;
  1501.     DWORD IntS3;
  1502.     DWORD IntS4;
  1503.     DWORD IntS5;
  1504.     DWORD IntS6;
  1505.     DWORD IntS7;
  1506.     DWORD IntT8;
  1507.     DWORD IntT9;
  1508.     DWORD IntK0;
  1509.     DWORD IntK1;
  1510.     DWORD IntGp;
  1511.     DWORD IntSp;
  1512.     DWORD IntS8;
  1513.     DWORD IntRa;
  1514.     DWORD IntLo;
  1515.     DWORD IntHi;
  1516.  
  1517.     //
  1518.     // This section is specified/returned if the ContextFlags word contains
  1519.     // the flag CONTEXT_FLOATING_POINT.
  1520.     //
  1521.  
  1522.     DWORD Fsr;
  1523.  
  1524.     //
  1525.     // This section is specified/returned if the ContextFlags word contains
  1526.     // the flag CONTEXT_CONTROL.
  1527.     //
  1528.     // N.B. The registers gp, sp, and ra are defined in the integer section,
  1529.     //   but are considered part of the control context rather than part of
  1530.     //   the integer context.
  1531.     //
  1532.  
  1533.     DWORD Fir;
  1534.     DWORD Psr;
  1535.  
  1536.     //
  1537.     // The flags values within this flag control the contents of
  1538.     // a CONTEXT record.
  1539.     //
  1540.     // If the context record is used as an input parameter, then
  1541.     // for each portion of the context record controlled by a flag
  1542.     // whose value is set, it is assumed that that portion of the
  1543.     // context record contains valid context. If the context record
  1544.     // is being used to modify a thread's context, then only that
  1545.     // portion of the threads context will be modified.
  1546.     //
  1547.     // If the context record is used as an IN OUT parameter to capture
  1548.     // the context of a thread, then only those portions of the thread's
  1549.     // context corresponding to set flags will be returned.
  1550.     //
  1551.     // The context record is never used as an OUT only parameter.
  1552.     //
  1553.  
  1554.     DWORD ContextFlags;
  1555.  
  1556.     DWORD Fill[2];
  1557. } CONTEXT, *PCONTEXT;
  1558.  
  1559. // end_ntddk end_nthal
  1560.  
  1561. #endif // MIPS
  1562.  
  1563.  
  1564. #if defined(_MIPS_)
  1565.  
  1566. VOID
  1567. __jump_unwind (
  1568.     PVOID Fp,
  1569.     PVOID TargetPc
  1570.     );
  1571.  
  1572. #endif // MIPS
  1573.  
  1574.  
  1575. #if defined(_PPC_)
  1576.  
  1577. // begin_ntddk begin_nthal
  1578. //
  1579. // The following flags control the contents of the CONTEXT structure.
  1580. //
  1581.  
  1582. #if !defined(RC_INVOKED)
  1583.  
  1584. #define CONTEXT_CONTROL         0x00000001L
  1585. #define CONTEXT_FLOATING_POINT  0x00000002L
  1586. #define CONTEXT_INTEGER         0x00000004L
  1587. #define CONTEXT_DEBUG_REGISTERS 0x00000008L
  1588.  
  1589. #define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_FLOATING_POINT | CONTEXT_INTEGER)
  1590.  
  1591. #endif
  1592.  
  1593. //
  1594. // Context Frame
  1595. //
  1596. //  N.B. This frame must be exactly a multiple of 16 bytes in length.
  1597. //
  1598. //  This frame has a several purposes: 1) it is used as an argument to
  1599. //  NtContinue, 2) it is used to constuct a call frame for APC delivery,
  1600. //  3) it is used to construct a call frame for exception dispatching
  1601. //  in user mode, and 4) it is used in the user level thread creation
  1602. //  routines.
  1603. //
  1604. //  Requires at least 8-byte alignment (double)
  1605. //
  1606.  
  1607. typedef struct _CONTEXT {
  1608.  
  1609.     //
  1610.     // This section is specified/returned if the ContextFlags word contains
  1611.     // the flag CONTEXT_FLOATING_POINT.
  1612.     //
  1613.  
  1614.     double Fpr0;                        // Floating registers 0..31
  1615.     double Fpr1;
  1616.     double Fpr2;
  1617.     double Fpr3;
  1618.     double Fpr4;
  1619.     double Fpr5;
  1620.     double Fpr6;
  1621.     double Fpr7;
  1622.     double Fpr8;
  1623.     double Fpr9;
  1624.     double Fpr10;
  1625.     double Fpr11;
  1626.     double Fpr12;
  1627.     double Fpr13;
  1628.     double Fpr14;
  1629.     double Fpr15;
  1630.     double Fpr16;
  1631.     double Fpr17;
  1632.     double Fpr18;
  1633.     double Fpr19;
  1634.     double Fpr20;
  1635.     double Fpr21;
  1636.     double Fpr22;
  1637.     double Fpr23;
  1638.     double Fpr24;
  1639.     double Fpr25;
  1640.     double Fpr26;
  1641.     double Fpr27;
  1642.     double Fpr28;
  1643.     double Fpr29;
  1644.     double Fpr30;
  1645.     double Fpr31;
  1646.     double Fpscr;                       // Floating point status/control reg
  1647.  
  1648.     //
  1649.     // This section is specified/returned if the ContextFlags word contains
  1650.     // the flag CONTEXT_INTEGER.
  1651.     //
  1652.  
  1653.     DWORD Gpr0;                         // General registers 0..31
  1654.     DWORD Gpr1;
  1655.     DWORD Gpr2;
  1656.     DWORD Gpr3;
  1657.     DWORD Gpr4;
  1658.     DWORD Gpr5;
  1659.     DWORD Gpr6;
  1660.     DWORD Gpr7;
  1661.     DWORD Gpr8;
  1662.     DWORD Gpr9;
  1663.     DWORD Gpr10;
  1664.     DWORD Gpr11;
  1665.     DWORD Gpr12;
  1666.     DWORD Gpr13;
  1667.     DWORD Gpr14;
  1668.     DWORD Gpr15;
  1669.     DWORD Gpr16;
  1670.     DWORD Gpr17;
  1671.     DWORD Gpr18;
  1672.     DWORD Gpr19;
  1673.     DWORD Gpr20;
  1674.     DWORD Gpr21;
  1675.     DWORD Gpr22;
  1676.     DWORD Gpr23;
  1677.     DWORD Gpr24;
  1678.     DWORD Gpr25;
  1679.     DWORD Gpr26;
  1680.     DWORD Gpr27;
  1681.     DWORD Gpr28;
  1682.     DWORD Gpr29;
  1683.     DWORD Gpr30;
  1684.     DWORD Gpr31;
  1685.  
  1686.     DWORD Cr;                           // Condition register
  1687.     DWORD Xer;                          // Fixed point exception register
  1688.  
  1689.     //
  1690.     // This section is specified/returned if the ContextFlags word contains
  1691.     // the flag CONTEXT_CONTROL.
  1692.     //
  1693.  
  1694.     DWORD Msr;                          // Machine status register
  1695.     DWORD Iar;                          // Instruction address register
  1696.     DWORD Lr;                           // Link register
  1697.     DWORD Ctr;                          // Count register
  1698.  
  1699.     //
  1700.     // The flags values within this flag control the contents of
  1701.     // a CONTEXT record.
  1702.     //
  1703.     // If the context record is used as an input parameter, then
  1704.     // for each portion of the context record controlled by a flag
  1705.     // whose value is set, it is assumed that that portion of the
  1706.     // context record contains valid context. If the context record
  1707.     // is being used to modify a thread's context, then only that
  1708.     // portion of the threads context will be modified.
  1709.     //
  1710.     // If the context record is used as an IN OUT parameter to capture
  1711.     // the context of a thread, then only those portions of the thread's
  1712.     // context corresponding to set flags will be returned.
  1713.     //
  1714.     // The context record is never used as an OUT only parameter.
  1715.     //
  1716.  
  1717.     DWORD ContextFlags;
  1718.  
  1719.     DWORD Fill[3];                      // Pad out to multiple of 16 bytes
  1720.  
  1721.     //
  1722.     // This section is specified/returned if CONTEXT_DEBUG_REGISTERS is
  1723.     // set in ContextFlags.  Note that CONTEXT_DEBUG_REGISTERS is NOT
  1724.     // included in CONTEXT_FULL.
  1725.     //
  1726.     DWORD Dr0;                          // Breakpoint Register 1
  1727.     DWORD Dr1;                          // Breakpoint Register 2
  1728.     DWORD Dr2;                          // Breakpoint Register 3
  1729.     DWORD Dr3;                          // Breakpoint Register 4
  1730.     DWORD Dr4;                          // Breakpoint Register 5
  1731.     DWORD Dr5;                          // Breakpoint Register 6
  1732.     DWORD Dr6;                          // Debug Status Register
  1733.     DWORD Dr7;                          // Debug Control Register
  1734.  
  1735. } CONTEXT, *PCONTEXT;
  1736.  
  1737. // end_ntddk end_nthal
  1738.  
  1739.  
  1740. //
  1741. // Stack frame header
  1742. //
  1743. //   Order of appearance in stack frame:
  1744. //      Header (six words)
  1745. //      Parameters (at least eight words)
  1746. //      Local variables
  1747. //      Saved GPRs
  1748. //      Saved FPRs
  1749. //
  1750. //   Minimum alignment is 8 bytes
  1751.  
  1752. typedef struct _STACK_FRAME_HEADER {    // GPR 1 points here
  1753.     DWORD BackChain;                    // Addr of previous frame
  1754.     DWORD GlueSaved1;                   // Used by glue code
  1755.     DWORD GlueSaved2;
  1756.     DWORD Reserved1;                    // Reserved
  1757.     DWORD Spare1;                       // Used by tracing, profiling, ...
  1758.     DWORD Spare2;
  1759.  
  1760.     DWORD Parameter0;                   // First 8 parameter words are
  1761.     DWORD Parameter1;                   //   always present
  1762.     DWORD Parameter2;
  1763.     DWORD Parameter3;
  1764.     DWORD Parameter4;
  1765.     DWORD Parameter5;
  1766.     DWORD Parameter6;
  1767.     DWORD Parameter7;
  1768.  
  1769. } STACK_FRAME_HEADER,*PSTACK_FRAME_HEADER;
  1770.  
  1771. #endif // _PPC_
  1772.  
  1773.  
  1774. #if defined(_PPC_)
  1775.  
  1776. // **FINISH** This may need alteration for PowerPC
  1777.  
  1778. VOID
  1779. __jump_unwind (
  1780.     PVOID Fp,
  1781.     PVOID TargetPc
  1782.     );
  1783.  
  1784. #endif // _PPC_
  1785.  
  1786. #define EXCEPTION_NONCONTINUABLE 0x1    // Noncontinuable exception
  1787. #define EXCEPTION_MAXIMUM_PARAMETERS 15 // maximum number of exception parameters
  1788.  
  1789. //
  1790. // Exception record definition.
  1791. //
  1792.  
  1793. typedef struct _EXCEPTION_RECORD {
  1794.     /*lint -e18 */  // Don't complain about different definitions
  1795.     DWORD    ExceptionCode;
  1796.     /*lint +e18 */  // Resume checking for different definitions
  1797.     DWORD ExceptionFlags;
  1798.     struct _EXCEPTION_RECORD *ExceptionRecord;
  1799.     PVOID ExceptionAddress;
  1800.     DWORD NumberParameters;
  1801.     DWORD ExceptionInformation[EXCEPTION_MAXIMUM_PARAMETERS];
  1802.     } EXCEPTION_RECORD;
  1803.  
  1804. typedef EXCEPTION_RECORD *PEXCEPTION_RECORD;
  1805.  
  1806. //
  1807. // Typedef for pointer returned by exception_info()
  1808. //
  1809.  
  1810. typedef struct _EXCEPTION_POINTERS {
  1811.     PEXCEPTION_RECORD ExceptionRecord;
  1812.     PCONTEXT ContextRecord;
  1813. } EXCEPTION_POINTERS, *PEXCEPTION_POINTERS;
  1814. #define PROCESS_TERMINATE         (0x0001)  
  1815. #define PROCESS_CREATE_THREAD     (0x0002)  
  1816. #define PROCESS_VM_OPERATION      (0x0008)  
  1817. #define PROCESS_VM_READ           (0x0010)  
  1818. #define PROCESS_VM_WRITE          (0x0020)  
  1819. #define PROCESS_DUP_HANDLE        (0x0040)  
  1820. #define PROCESS_CREATE_PROCESS    (0x0080)  
  1821. #define PROCESS_SET_QUOTA         (0x0100)  
  1822. #define PROCESS_SET_INFORMATION   (0x0200)  
  1823. #define PROCESS_QUERY_INFORMATION (0x0400)  
  1824. #define PROCESS_ALL_ACCESS        (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
  1825.                                    0xFFF)
  1826.  
  1827. #define THREAD_TERMINATE               (0x0001)  
  1828. #define THREAD_SUSPEND_RESUME          (0x0002)  
  1829. #define THREAD_GET_CONTEXT             (0x0008)  
  1830. #define THREAD_SET_CONTEXT             (0x0010)  
  1831. #define THREAD_SET_INFORMATION         (0x0020)  
  1832. #define THREAD_QUERY_INFORMATION       (0x0040)  
  1833. #define THREAD_SET_THREAD_TOKEN        (0x0080)
  1834. #define THREAD_IMPERSONATE             (0x0100)
  1835. #define THREAD_DIRECT_IMPERSONATION    (0x0200)
  1836. // begin_ntddk
  1837.  
  1838. #define THREAD_ALL_ACCESS         (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | \
  1839.                                    0x3FF)
  1840.  
  1841. // end_ntddk
  1842. #define TLS_MINIMUM_AVAILABLE 64    
  1843. #define THREAD_BASE_PRIORITY_LOWRT  15  // value that gets a thread to LowRealtime-1
  1844. #define THREAD_BASE_PRIORITY_MAX    2   // maximum thread base priority boost
  1845. #define THREAD_BASE_PRIORITY_MIN    -2  // minimum thread base priority boost
  1846. #define THREAD_BASE_PRIORITY_IDLE   -15 // value that gets a thread to idle
  1847.  
  1848. typedef struct _QUOTA_LIMITS {
  1849.     DWORD PagedPoolLimit;
  1850.     DWORD NonPagedPoolLimit;
  1851.     DWORD MinimumWorkingSetSize;
  1852.     DWORD MaximumWorkingSetSize;
  1853.     DWORD PagefileLimit;
  1854.     LARGE_INTEGER TimeLimit;
  1855. } QUOTA_LIMITS;
  1856. typedef QUOTA_LIMITS *PQUOTA_LIMITS;
  1857.  
  1858. #define EVENT_MODIFY_STATE      0x0002  
  1859. #define EVENT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) 
  1860. #define MUTANT_QUERY_STATE      0x0001
  1861.  
  1862. #define MUTANT_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|\
  1863.                           MUTANT_QUERY_STATE)
  1864. #define SEMAPHORE_MODIFY_STATE      0x0002  
  1865. #define SEMAPHORE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) 
  1866. #define TIME_ZONE_ID_UNKNOWN  0
  1867. #define TIME_ZONE_ID_STANDARD 1
  1868. #define TIME_ZONE_ID_DAYLIGHT 2
  1869.  
  1870. #define PROCESSOR_INTEL_386     386
  1871. #define PROCESSOR_INTEL_486     486
  1872. #define PROCESSOR_INTEL_PENTIUM 586
  1873. #define PROCESSOR_MIPS_R4000    4000
  1874. #define PROCESSOR_ALPHA_21064   21064
  1875.  
  1876. #define PROCESSOR_ARCHITECTURE_INTEL 0
  1877. #define PROCESSOR_ARCHITECTURE_MIPS  1
  1878. #define PROCESSOR_ARCHITECTURE_ALPHA 2
  1879. #define PROCESSOR_ARCHITECTURE_PPC   3
  1880. #define PROCESSOR_ARCHITECTURE_UNKNOWN 0xFFFF
  1881.  
  1882. typedef struct _MEMORY_BASIC_INFORMATION {
  1883.     PVOID BaseAddress;
  1884.     PVOID AllocationBase;
  1885.     DWORD AllocationProtect;
  1886.     DWORD RegionSize;
  1887.     DWORD State;
  1888.     DWORD Protect;
  1889.     DWORD Type;
  1890. } MEMORY_BASIC_INFORMATION, *PMEMORY_BASIC_INFORMATION;
  1891. #define SECTION_QUERY       0x0001
  1892. #define SECTION_MAP_WRITE   0x0002
  1893. #define SECTION_MAP_READ    0x0004
  1894. #define SECTION_MAP_EXECUTE 0x0008
  1895. #define SECTION_EXTEND_SIZE 0x0010
  1896.  
  1897. #define SECTION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SECTION_QUERY|\
  1898.                             SECTION_MAP_WRITE |      \
  1899.                             SECTION_MAP_READ |       \
  1900.                             SECTION_MAP_EXECUTE |    \
  1901.                             SECTION_EXTEND_SIZE)
  1902. #define PAGE_NOACCESS          0x01     
  1903. #define PAGE_READONLY          0x02     
  1904. #define PAGE_READWRITE         0x04     
  1905. #define PAGE_WRITECOPY         0x08     
  1906. #define PAGE_EXECUTE           0x10     
  1907. #define PAGE_EXECUTE_READ      0x20     
  1908. #define PAGE_EXECUTE_READWRITE 0x40     
  1909. #define PAGE_EXECUTE_WRITECOPY 0x80     
  1910. #define PAGE_GUARD            0x100     
  1911. #define PAGE_NOCACHE          0x200     
  1912. #define MEM_COMMIT           0x1000     
  1913. #define MEM_RESERVE          0x2000     
  1914. #define MEM_DECOMMIT         0x4000     
  1915. #define MEM_RELEASE          0x8000     
  1916. #define MEM_FREE            0x10000     
  1917. #define MEM_PRIVATE         0x20000     
  1918. #define MEM_MAPPED          0x40000     
  1919. #define MEM_TOP_DOWN       0x100000     
  1920. #define SEC_FILE           0x800000     
  1921. #define SEC_IMAGE         0x1000000     
  1922. #define SEC_RESERVE       0x4000000     
  1923. #define SEC_COMMIT        0x8000000     
  1924. #define SEC_NOCACHE      0x10000000     
  1925. #define MEM_IMAGE         SEC_IMAGE     
  1926.  
  1927. //
  1928. // Define access rights to files and directories
  1929. //
  1930.  
  1931. //
  1932. // The FILE_READ_DATA and FILE_WRITE_DATA constants are also defined in
  1933. // devioctl.h as FILE_READ_ACCESS and FILE_WRITE_ACCESS. The values for these
  1934. // constants *MUST* always be in sync.
  1935. // The values are redefined in devioctl.h because they must be available to
  1936. // both DOS and NT.
  1937. //
  1938.  
  1939. #define FILE_READ_DATA            ( 0x0001 )    // file & pipe
  1940. #define FILE_LIST_DIRECTORY       ( 0x0001 )    // directory
  1941.  
  1942. #define FILE_WRITE_DATA           ( 0x0002 )    // file & pipe
  1943. #define FILE_ADD_FILE             ( 0x0002 )    // directory
  1944.  
  1945. #define FILE_APPEND_DATA          ( 0x0004 )    // file
  1946. #define FILE_ADD_SUBDIRECTORY     ( 0x0004 )    // directory
  1947. #define FILE_CREATE_PIPE_INSTANCE ( 0x0004 )    // named pipe
  1948.  
  1949. #define FILE_READ_EA              ( 0x0008 )    // file & directory
  1950. #define FILE_READ_PROPERTIES      FILE_READ_EA
  1951.  
  1952. #define FILE_WRITE_EA             ( 0x0010 )    // file & directory
  1953. #define FILE_WRITE_PROPERTIES     FILE_WRITE_EA
  1954.  
  1955. #define FILE_EXECUTE              ( 0x0020 )    // file
  1956. #define FILE_TRAVERSE             ( 0x0020 )    // directory
  1957.  
  1958. #define FILE_DELETE_CHILD         ( 0x0040 )    // directory
  1959.  
  1960. #define FILE_READ_ATTRIBUTES      ( 0x0080 )    // all
  1961.  
  1962. #define FILE_WRITE_ATTRIBUTES     ( 0x0100 )    // all
  1963.  
  1964. #define FILE_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED | SYNCHRONIZE | 0x1FF)
  1965.  
  1966. #define FILE_GENERIC_READ         (STANDARD_RIGHTS_READ     |\
  1967.                                    FILE_READ_DATA           |\
  1968.                                    FILE_READ_ATTRIBUTES     |\
  1969.                                    FILE_READ_EA             |\
  1970.                                    SYNCHRONIZE)
  1971.  
  1972.  
  1973. #define FILE_GENERIC_WRITE        (STANDARD_RIGHTS_WRITE    |\
  1974.                                    FILE_WRITE_DATA          |\
  1975.                                    FILE_WRITE_ATTRIBUTES    |\
  1976.                                    FILE_WRITE_EA            |\
  1977.                                    FILE_APPEND_DATA         |\
  1978.                                    SYNCHRONIZE)
  1979.  
  1980.  
  1981. #define FILE_GENERIC_EXECUTE      (STANDARD_RIGHTS_EXECUTE  |\
  1982.                                    FILE_READ_ATTRIBUTES     |\
  1983.                                    FILE_EXECUTE             |\
  1984.                                    SYNCHRONIZE)
  1985.  
  1986. #define FILE_SHARE_READ                 0x00000001  
  1987. #define FILE_SHARE_WRITE                0x00000002  
  1988. #define FILE_ATTRIBUTE_READONLY         0x00000001  
  1989. #define FILE_ATTRIBUTE_HIDDEN           0x00000002  
  1990. #define FILE_ATTRIBUTE_SYSTEM           0x00000004  
  1991. #define FILE_ATTRIBUTE_DIRECTORY        0x00000010  
  1992. #define FILE_ATTRIBUTE_ARCHIVE          0x00000020  
  1993. #define FILE_ATTRIBUTE_NORMAL           0x00000080  
  1994. #define FILE_ATTRIBUTE_TEMPORARY        0x00000100  
  1995. #define FILE_ATTRIBUTE_COMPRESSED       0x00000800  
  1996. #define FILE_NOTIFY_CHANGE_FILE_NAME    0x00000001   
  1997. #define FILE_NOTIFY_CHANGE_DIR_NAME     0x00000002   
  1998. #define FILE_NOTIFY_CHANGE_ATTRIBUTES   0x00000004   
  1999. #define FILE_NOTIFY_CHANGE_SIZE         0x00000008   
  2000. #define FILE_NOTIFY_CHANGE_LAST_WRITE   0x00000010   
  2001. #define FILE_NOTIFY_CHANGE_SECURITY     0x00000100   
  2002. #define MAILSLOT_NO_MESSAGE             ((DWORD)-1) 
  2003. #define MAILSLOT_WAIT_FOREVER           ((DWORD)-1) 
  2004. #define FILE_CASE_SENSITIVE_SEARCH      0x00000001  
  2005. #define FILE_CASE_PRESERVED_NAMES       0x00000002  
  2006. #define FILE_UNICODE_ON_DISK            0x00000004  
  2007. #define FILE_PERSISTENT_ACLS            0x00000008  
  2008. #define FILE_FILE_COMPRESSION           0x00000010  
  2009. #define FILE_VOLUME_IS_COMPRESSED       0x00008000  
  2010. #define IO_COMPLETION_MODIFY_STATE  0x0002  
  2011. #define IO_COMPLETION_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED|SYNCHRONIZE|0x3) 
  2012. #define DUPLICATE_CLOSE_SOURCE      0x00000001  
  2013. #define DUPLICATE_SAME_ACCESS       0x00000002  
  2014. typedef PVOID PACCESS_TOKEN;            
  2015. typedef PVOID PSECURITY_DESCRIPTOR;     
  2016. typedef PVOID PSID;     
  2017. ////////////////////////////////////////////////////////////////////////
  2018. //                                                                    //
  2019. //                             ACCESS MASK                            //
  2020. //                                                                    //
  2021. ////////////////////////////////////////////////////////////////////////
  2022.  
  2023. //
  2024. //  Define the access mask as a longword sized structure divided up as
  2025. //  follows:
  2026. //
  2027. //       3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  2028. //       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
  2029. //      +---------------+---------------+-------------------------------+
  2030. //      |G|G|G|G|Res'd|A| StandardRights|         SpecificRights        |
  2031. //      |R|W|E|A|     |S|               |                               |
  2032. //      +-+-------------+---------------+-------------------------------+
  2033. //
  2034. //      typedef struct _ACCESS_MASK {
  2035. //          WORD   SpecificRights;
  2036. //          BYTE  StandardRights;
  2037. //          BYTE  AccessSystemAcl : 1;
  2038. //          BYTE  Reserved : 3;
  2039. //          BYTE  GenericAll : 1;
  2040. //          BYTE  GenericExecute : 1;
  2041. //          BYTE  GenericWrite : 1;
  2042. //          BYTE  GenericRead : 1;
  2043. //      } ACCESS_MASK;
  2044. //      typedef ACCESS_MASK *PACCESS_MASK;
  2045. //
  2046. //  but to make life simple for programmer's we'll allow them to specify
  2047. //  a desired access mask by simply OR'ing together mulitple single rights
  2048. //  and treat an access mask as a DWORD.  For example
  2049. //
  2050. //      DesiredAccess = DELETE | READ_CONTROL
  2051. //
  2052. //  So we'll declare ACCESS_MASK as DWORD
  2053. //
  2054.  
  2055. // begin_ntddk begin_nthal begin_ntifs
  2056. typedef DWORD ACCESS_MASK;
  2057. typedef ACCESS_MASK *PACCESS_MASK;
  2058.  
  2059. ////////////////////////////////////////////////////////////////////////
  2060. //                                                                    //
  2061. //                             ACCESS TYPES                           //
  2062. //                                                                    //
  2063. ////////////////////////////////////////////////////////////////////////
  2064.  
  2065.  
  2066. // begin_ntddk begin_nthal begin_ntifs
  2067. //
  2068. //  The following are masks for the predefined standard access types
  2069. //
  2070.  
  2071. #define DELETE                           (0x00010000L)
  2072. #define READ_CONTROL                     (0x00020000L)
  2073. #define WRITE_DAC                        (0x00040000L)
  2074. #define WRITE_OWNER                      (0x00080000L)
  2075. #define SYNCHRONIZE                      (0x00100000L)
  2076.  
  2077. #define STANDARD_RIGHTS_REQUIRED         (0x000F0000L)
  2078.  
  2079. #define STANDARD_RIGHTS_READ             (READ_CONTROL)
  2080. #define STANDARD_RIGHTS_WRITE            (READ_CONTROL)
  2081. #define STANDARD_RIGHTS_EXECUTE          (READ_CONTROL)
  2082.  
  2083. #define STANDARD_RIGHTS_ALL              (0x001F0000L)
  2084.  
  2085. #define SPECIFIC_RIGHTS_ALL              (0x0000FFFFL)
  2086.  
  2087. //
  2088. // AccessSystemAcl access type
  2089. //
  2090.  
  2091. #define ACCESS_SYSTEM_SECURITY           (0x01000000L)
  2092.  
  2093. //
  2094. // MaximumAllowed access type
  2095. //
  2096.  
  2097. #define MAXIMUM_ALLOWED                  (0x02000000L)
  2098.  
  2099. //
  2100. //  These are the generic rights.
  2101. //
  2102.  
  2103. #define GENERIC_READ                     (0x80000000L)
  2104. #define GENERIC_WRITE                    (0x40000000L)
  2105. #define GENERIC_EXECUTE                  (0x20000000L)
  2106. #define GENERIC_ALL                      (0x10000000L)
  2107.  
  2108.  
  2109. //
  2110. //  Define the generic mapping array.  This is used to denote the
  2111. //  mapping of each generic access right to a specific access mask.
  2112. //
  2113.  
  2114. typedef struct _GENERIC_MAPPING {
  2115.     ACCESS_MASK GenericRead;
  2116.     ACCESS_MASK GenericWrite;
  2117.     ACCESS_MASK GenericExecute;
  2118.     ACCESS_MASK GenericAll;
  2119. } GENERIC_MAPPING;
  2120. typedef GENERIC_MAPPING *PGENERIC_MAPPING;
  2121.  
  2122.  
  2123.  
  2124. ////////////////////////////////////////////////////////////////////////
  2125. //                                                                    //
  2126. //                        LUID_AND_ATTRIBUTES                         //
  2127. //                                                                    //
  2128. ////////////////////////////////////////////////////////////////////////
  2129. //
  2130. //
  2131.  
  2132.  
  2133. #include <pshpack4.h>
  2134.  
  2135. typedef struct _LUID_AND_ATTRIBUTES {
  2136.     LUID Luid;
  2137.     DWORD Attributes;
  2138.     } LUID_AND_ATTRIBUTES, * PLUID_AND_ATTRIBUTES;
  2139. typedef LUID_AND_ATTRIBUTES LUID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY];
  2140. typedef LUID_AND_ATTRIBUTES_ARRAY *PLUID_AND_ATTRIBUTES_ARRAY;
  2141.  
  2142. #include <poppack.h>
  2143.  
  2144.  
  2145. ////////////////////////////////////////////////////////////////////////
  2146. //                                                                    //
  2147. //              Security Id     (SID)                                 //
  2148. //                                                                    //
  2149. ////////////////////////////////////////////////////////////////////////
  2150. //
  2151. //
  2152. // Pictorially the structure of an SID is as follows:
  2153. //
  2154. //         1   1   1   1   1   1
  2155. //         5   4   3   2   1   0   9   8   7   6   5   4   3   2   1   0
  2156. //      +---------------------------------------------------------------+
  2157. //      |      SubAuthorityCount        |Reserved1 (SBZ)|   Revision    |
  2158. //      +---------------------------------------------------------------+
  2159. //      |                   IdentifierAuthority[0]                      |
  2160. //      +---------------------------------------------------------------+
  2161. //      |                   IdentifierAuthority[1]                      |
  2162. //      +---------------------------------------------------------------+
  2163. //      |                   IdentifierAuthority[2]                      |
  2164. //      +---------------------------------------------------------------+
  2165. //      |                                                               |
  2166. //      +- -  -  -  -  -  -  -  SubAuthority[]  -  -  -  -  -  -  -  - -+
  2167. //      |                                                               |
  2168. //      +---------------------------------------------------------------+
  2169. //
  2170. //
  2171.  
  2172.  
  2173. // begin_ntifs
  2174.  
  2175. typedef struct _SID_IDENTIFIER_AUTHORITY {
  2176.     BYTE  Value[6];
  2177. } SID_IDENTIFIER_AUTHORITY, *PSID_IDENTIFIER_AUTHORITY;
  2178.  
  2179.  
  2180. typedef struct _SID {
  2181.    BYTE  Revision;
  2182.    BYTE  SubAuthorityCount;
  2183.    SID_IDENTIFIER_AUTHORITY IdentifierAuthority;
  2184. #ifdef MIDL_PASS
  2185.    [size_is(SubAuthorityCount)] DWORD SubAuthority[*];
  2186. #else // MIDL_PASS
  2187.    DWORD SubAuthority[ANYSIZE_ARRAY];
  2188. #endif // MIDL_PASS
  2189. } SID, *PISID;
  2190.  
  2191.  
  2192. #define SID_REVISION                     (1)    // Current revision level
  2193. #define SID_MAX_SUB_AUTHORITIES          (15)
  2194. #define SID_RECOMMENDED_SUB_AUTHORITIES  (1)    // Will change to around 6
  2195.                                                 // in a future release.
  2196.  
  2197. typedef enum _SID_NAME_USE {
  2198.     SidTypeUser = 1,
  2199.     SidTypeGroup,
  2200.     SidTypeDomain,
  2201.     SidTypeAlias,
  2202.     SidTypeWellKnownGroup,
  2203.     SidTypeDeletedAccount,
  2204.     SidTypeInvalid,
  2205.     SidTypeUnknown
  2206. } SID_NAME_USE, *PSID_NAME_USE;
  2207.  
  2208. // end_ntifs
  2209.  
  2210. typedef struct _SID_AND_ATTRIBUTES {
  2211.     PSID Sid;
  2212.     DWORD Attributes;
  2213.     } SID_AND_ATTRIBUTES, * PSID_AND_ATTRIBUTES;
  2214.  
  2215. typedef SID_AND_ATTRIBUTES SID_AND_ATTRIBUTES_ARRAY[ANYSIZE_ARRAY];
  2216. typedef SID_AND_ATTRIBUTES_ARRAY *PSID_AND_ATTRIBUTES_ARRAY;
  2217.  
  2218.  
  2219.  
  2220. /////////////////////////////////////////////////////////////////////////////
  2221. //                                                                         //
  2222. // Universal well-known SIDs                                               //
  2223. //                                                                         //
  2224. //     Null SID              S-1-0-0                                       //
  2225. //     World                 S-1-1-0                                       //
  2226. //     Local                 S-1-2-0                                       //
  2227. //     Creator Owner ID      S-1-3-0                                       //
  2228. //     Creator Group ID      S-1-3-1                                       //
  2229. //                                                                         //
  2230. //     (Non-unique IDs)      S-1-4                                         //
  2231. //                                                                         //
  2232. /////////////////////////////////////////////////////////////////////////////
  2233.  
  2234. #define SECURITY_NULL_SID_AUTHORITY     {0,0,0,0,0,0}
  2235. #define SECURITY_WORLD_SID_AUTHORITY    {0,0,0,0,0,1}
  2236. #define SECURITY_LOCAL_SID_AUTHORITY    {0,0,0,0,0,2}
  2237. #define SECURITY_CREATOR_SID_AUTHORITY  {0,0,0,0,0,3}
  2238. #define SECURITY_NON_UNIQUE_AUTHORITY   {0,0,0,0,0,4}
  2239.  
  2240. #define SECURITY_NULL_RID               (0x00000000L)
  2241. #define SECURITY_WORLD_RID              (0x00000000L)
  2242. #define SECURITY_LOCAL_RID              (0X00000000L)
  2243.  
  2244. #define SECURITY_CREATOR_OWNER_RID      (0x00000000L)
  2245. #define SECURITY_CREATOR_GROUP_RID      (0x00000001L)
  2246.  
  2247.  
  2248.  
  2249.  
  2250. /////////////////////////////////////////////////////////////////////////////
  2251. //                                                                         //
  2252. // NT well-known SIDs                                                      //
  2253. //                                                                         //
  2254. //     NT Authority          S-1-5                                         //
  2255. //     Dialup                S-1-5-1                                       //
  2256. //                                                                         //
  2257. //     Network               S-1-5-2                                       //
  2258. //     Batch                 S-1-5-3                                       //
  2259. //     Interactive           S-1-5-4                                       //
  2260. //     Service               S-1-5-6                                       //
  2261. //     AnonymousLogon        S-1-5-7       (aka null logon session)        //
  2262. //                                                                         //
  2263. //     (Logon IDs)           S-1-5-5-X-Y                                   //
  2264. //                                                                         //
  2265. //     (NT non-unique IDs)   S-1-5-0x15-...                                //
  2266. //                                                                         //
  2267. //     (Built-in domain)     s-1-5-0x20                                    //
  2268. //                                                                         //
  2269. /////////////////////////////////////////////////////////////////////////////
  2270.  
  2271.  
  2272. #define SECURITY_NT_AUTHORITY           {0,0,0,0,0,5}   // ntifs
  2273.  
  2274. #define SECURITY_DIALUP_RID             (0x00000001L)
  2275. #define SECURITY_NETWORK_RID            (0x00000002L)
  2276. #define SECURITY_BATCH_RID              (0x00000003L)
  2277. #define SECURITY_INTERACTIVE_RID        (0x00000004L)
  2278. #define SECURITY_SERVICE_RID            (0x00000006L)
  2279. #define SECURITY_ANONYMOUS_LOGON_RID    (0x00000007L)
  2280.  
  2281. #define SECURITY_LOGON_IDS_RID          (0x00000005L)
  2282. #define SECURITY_LOGON_IDS_RID_COUNT    (3L)
  2283.  
  2284. #define SECURITY_LOCAL_SYSTEM_RID       (0x00000012L)
  2285.  
  2286. #define SECURITY_NT_NON_UNIQUE          (0x00000015L)
  2287.  
  2288. #define SECURITY_BUILTIN_DOMAIN_RID     (0x00000020L)
  2289.  
  2290.  
  2291.  
  2292.  
  2293.  
  2294. /////////////////////////////////////////////////////////////////////////////
  2295. //                                                                         //
  2296. // well-known domain relative sub-authority values (RIDs)...               //
  2297. //                                                                         //
  2298. /////////////////////////////////////////////////////////////////////////////
  2299.  
  2300. // Well-known users ...
  2301.  
  2302. #define DOMAIN_USER_RID_ADMIN          (0x000001F4L)
  2303. #define DOMAIN_USER_RID_GUEST          (0x000001F5L)
  2304.  
  2305.  
  2306.  
  2307. // well-known groups ...
  2308.  
  2309. #define DOMAIN_GROUP_RID_ADMINS        (0x00000200L)
  2310. #define DOMAIN_GROUP_RID_USERS         (0x00000201L)
  2311. #define DOMAIN_GROUP_RID_GUESTS        (0x00000202L)
  2312.  
  2313.  
  2314.  
  2315.  
  2316. // well-known aliases ...
  2317.  
  2318. #define DOMAIN_ALIAS_RID_ADMINS        (0x00000220L)
  2319. #define DOMAIN_ALIAS_RID_USERS         (0x00000221L)
  2320. #define DOMAIN_ALIAS_RID_GUESTS        (0x00000222L)
  2321. #define DOMAIN_ALIAS_RID_POWER_USERS   (0x00000223L)
  2322.  
  2323. #define DOMAIN_ALIAS_RID_ACCOUNT_OPS   (0x00000224L)
  2324. #define DOMAIN_ALIAS_RID_SYSTEM_OPS    (0x00000225L)
  2325. #define DOMAIN_ALIAS_RID_PRINT_OPS     (0x00000226L)
  2326. #define DOMAIN_ALIAS_RID_BACKUP_OPS    (0x00000227L)
  2327.  
  2328. #define DOMAIN_ALIAS_RID_REPLICATOR    (0x00000228L)
  2329.  
  2330.  
  2331.  
  2332.  
  2333.  
  2334.  
  2335. //
  2336. // Allocate the System Luid.  The first 1000 LUIDs are reserved.
  2337. // Use #999 here (0x3E7 = 999)
  2338. //
  2339.  
  2340. #define SYSTEM_LUID                     { 0x3E7, 0x0 }
  2341.  
  2342. // end_ntifs
  2343.  
  2344. ////////////////////////////////////////////////////////////////////////
  2345. //                                                                    //
  2346. //                          User and Group related SID attributes     //
  2347. //                                                                    //
  2348. ////////////////////////////////////////////////////////////////////////
  2349.  
  2350. //
  2351. // Group attributes
  2352. //
  2353.  
  2354. #define SE_GROUP_MANDATORY              (0x00000001L)
  2355. #define SE_GROUP_ENABLED_BY_DEFAULT     (0x00000002L)
  2356. #define SE_GROUP_ENABLED                (0x00000004L)
  2357. #define SE_GROUP_OWNER                  (0x00000008L)
  2358. #define SE_GROUP_LOGON_ID               (0xC0000000L)
  2359.  
  2360.  
  2361.  
  2362. //
  2363. // User attributes
  2364. //
  2365.  
  2366. // (None yet defined.)
  2367.  
  2368.  
  2369.  
  2370.  
  2371. ////////////////////////////////////////////////////////////////////////
  2372. //                                                                    //
  2373. //                         ACL  and  ACE                              //
  2374. //                                                                    //
  2375. ////////////////////////////////////////////////////////////////////////
  2376.  
  2377. //
  2378. //  Define an ACL and the ACE format.  The structure of an ACL header
  2379. //  followed by one or more ACEs.  Pictorally the structure of an ACL header
  2380. //  is as follows:
  2381. //
  2382. //       3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  2383. //       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
  2384. //      +-------------------------------+---------------+---------------+
  2385. //      |            AclSize            |      Sbz1     |  AclRevision  |
  2386. //      +-------------------------------+---------------+---------------+
  2387. //      |              Sbz2             |           AceCount            |
  2388. //      +-------------------------------+-------------------------------+
  2389. //
  2390. //  The current AclRevision is defined to be ACL_REVISION.
  2391. //
  2392. //  AclSize is the size, in bytes, allocated for the ACL.  This includes
  2393. //  the ACL header, ACES, and remaining free space in the buffer.
  2394. //
  2395. //  AceCount is the number of ACES in the ACL.
  2396. //
  2397.  
  2398. // begin_ntddk begin_ntifs
  2399. // This is the *current* ACL revision
  2400.  
  2401. #define ACL_REVISION     (2)
  2402.  
  2403. // This is the history of ACL revisions.  Add a new one whenever
  2404. // ACL_REVISION is updated
  2405.  
  2406. #define ACL_REVISION1   (1)
  2407. #define ACL_REVISION2   (2)
  2408.  
  2409. typedef struct _ACL {
  2410.     BYTE  AclRevision;
  2411.     BYTE  Sbz1;
  2412.     WORD   AclSize;
  2413.     WORD   AceCount;
  2414.     WORD   Sbz2;
  2415. } ACL;
  2416. typedef ACL *PACL;
  2417.  
  2418. // end_ntddk
  2419.  
  2420. //
  2421. //  The structure of an ACE is a common ace header followed by ace type
  2422. //  specific data.  Pictorally the structure of the common ace header is
  2423. //  as follows:
  2424. //
  2425. //       3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  2426. //       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
  2427. //      +---------------+-------+-------+---------------+---------------+
  2428. //      |            AceSize            |    AceFlags   |     AceType   |
  2429. //      +---------------+-------+-------+---------------+---------------+
  2430. //
  2431. //  AceType denotes the type of the ace, there are some predefined ace
  2432. //  types
  2433. //
  2434. //  AceSize is the size, in bytes, of ace.
  2435. //
  2436. //  AceFlags are the Ace flags for audit and inheritance, defined shortly.
  2437.  
  2438. typedef struct _ACE_HEADER {
  2439.     BYTE  AceType;
  2440.     BYTE  AceFlags;
  2441.     WORD   AceSize;
  2442. } ACE_HEADER;
  2443. typedef ACE_HEADER *PACE_HEADER;
  2444.  
  2445. //
  2446. //  The following are the predefined ace types that go into the AceType
  2447. //  field of an Ace header.
  2448. //
  2449.  
  2450. #define ACCESS_ALLOWED_ACE_TYPE          (0x0)
  2451. #define ACCESS_DENIED_ACE_TYPE           (0x1)
  2452. #define SYSTEM_AUDIT_ACE_TYPE            (0x2)
  2453. #define SYSTEM_ALARM_ACE_TYPE            (0x3)
  2454.  
  2455. //
  2456. //  The following are the inherit flags that go into the AceFlags field
  2457. //  of an Ace header.
  2458. //
  2459.  
  2460. #define OBJECT_INHERIT_ACE                (0x1)
  2461. #define CONTAINER_INHERIT_ACE             (0x2)
  2462. #define NO_PROPAGATE_INHERIT_ACE          (0x4)
  2463. #define INHERIT_ONLY_ACE                  (0x8)
  2464. #define VALID_INHERIT_FLAGS               (0xF)
  2465.  
  2466.  
  2467. //  The following are the currently defined ACE flags that go into the
  2468. //  AceFlags field of an ACE header.  Each ACE type has its own set of
  2469. //  AceFlags.
  2470. //
  2471. //  SUCCESSFUL_ACCESS_ACE_FLAG - used only with system audit and alarm ACE
  2472. //  types to indicate that a message is generated for successful accesses.
  2473. //
  2474. //  FAILED_ACCESS_ACE_FLAG - used only with system audit and alarm ACE types
  2475. //  to indicate that a message is generated for failed accesses.
  2476. //
  2477.  
  2478. //
  2479. //  SYSTEM_AUDIT and SYSTEM_ALARM AceFlags
  2480. //
  2481. //  These control the signaling of audit and alarms for success or failure.
  2482. //
  2483.  
  2484. #define SUCCESSFUL_ACCESS_ACE_FLAG       (0x40)
  2485. #define FAILED_ACCESS_ACE_FLAG           (0x80)
  2486.  
  2487.  
  2488. //
  2489. //  We'll define the structure of the predefined ACE types.  Pictorally
  2490. //  the structure of the predefined ACE's is as follows:
  2491. //
  2492. //       3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  2493. //       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
  2494. //      +---------------+-------+-------+---------------+---------------+
  2495. //      |    AceFlags   | Resd  |Inherit|    AceSize    |     AceType   |
  2496. //      +---------------+-------+-------+---------------+---------------+
  2497. //      |                              Mask                             |
  2498. //      +---------------------------------------------------------------+
  2499. //      |                                                               |
  2500. //      +                                                               +
  2501. //      |                                                               |
  2502. //      +                              Sid                              +
  2503. //      |                                                               |
  2504. //      +                                                               +
  2505. //      |                                                               |
  2506. //      +---------------------------------------------------------------+
  2507. //
  2508. //  Mask is the access mask associated with the ACE.  This is either the
  2509. //  access allowed, access denied, audit, or alarm mask.
  2510. //
  2511. //  Sid is the Sid associated with the ACE.
  2512. //
  2513.  
  2514. //  The following are the four predefined ACE types.
  2515.  
  2516. //  Examine the AceType field in the Header to determine
  2517. //  which structure is appropriate to use for casting.
  2518.  
  2519.  
  2520. typedef struct _ACCESS_ALLOWED_ACE {
  2521.     ACE_HEADER Header;
  2522.     ACCESS_MASK Mask;
  2523.     DWORD SidStart;
  2524. } ACCESS_ALLOWED_ACE;
  2525.  
  2526. typedef ACCESS_ALLOWED_ACE *PACCESS_ALLOWED_ACE;
  2527.  
  2528. typedef struct _ACCESS_DENIED_ACE {
  2529.     ACE_HEADER Header;
  2530.     ACCESS_MASK Mask;
  2531.     DWORD SidStart;
  2532. } ACCESS_DENIED_ACE;
  2533. typedef ACCESS_DENIED_ACE *PACCESS_DENIED_ACE;
  2534.  
  2535. typedef struct _SYSTEM_AUDIT_ACE {
  2536.     ACE_HEADER Header;
  2537.     ACCESS_MASK Mask;
  2538.     DWORD SidStart;
  2539. } SYSTEM_AUDIT_ACE;
  2540. typedef SYSTEM_AUDIT_ACE *PSYSTEM_AUDIT_ACE;
  2541.  
  2542. typedef struct _SYSTEM_ALARM_ACE {
  2543.     ACE_HEADER Header;
  2544.     ACCESS_MASK Mask;
  2545.     DWORD SidStart;
  2546. } SYSTEM_ALARM_ACE;
  2547. typedef SYSTEM_ALARM_ACE *PSYSTEM_ALARM_ACE;
  2548.  
  2549. // end_ntifs
  2550.  
  2551.  
  2552. //
  2553. //  The following declarations are used for setting and querying information
  2554. //  about and ACL.  First are the various information classes available to
  2555. //  the user.
  2556. //
  2557.  
  2558. typedef enum _ACL_INFORMATION_CLASS {
  2559.     AclRevisionInformation = 1,
  2560.     AclSizeInformation
  2561. } ACL_INFORMATION_CLASS;
  2562.  
  2563. //
  2564. //  This record is returned/sent if the user is requesting/setting the
  2565. //  AclRevisionInformation
  2566. //
  2567.  
  2568. typedef struct _ACL_REVISION_INFORMATION {
  2569.     DWORD AclRevision;
  2570. } ACL_REVISION_INFORMATION;
  2571. typedef ACL_REVISION_INFORMATION *PACL_REVISION_INFORMATION;
  2572.  
  2573. //
  2574. //  This record is returned if the user is requesting AclSizeInformation
  2575. //
  2576.  
  2577. typedef struct _ACL_SIZE_INFORMATION {
  2578.     DWORD AceCount;
  2579.     DWORD AclBytesInUse;
  2580.     DWORD AclBytesFree;
  2581. } ACL_SIZE_INFORMATION;
  2582. typedef ACL_SIZE_INFORMATION *PACL_SIZE_INFORMATION;
  2583.  
  2584.  
  2585. ////////////////////////////////////////////////////////////////////////
  2586. //                                                                    //
  2587. //                             SECURITY_DESCRIPTOR                    //
  2588. //                                                                    //
  2589. ////////////////////////////////////////////////////////////////////////
  2590. //
  2591. //  Define the Security Descriptor and related data types.
  2592. //  This is an opaque data structure.
  2593. //
  2594.  
  2595. // begin_ntddk begin_ntifs
  2596. //
  2597. // Current security descriptor revision value
  2598. //
  2599.  
  2600. #define SECURITY_DESCRIPTOR_REVISION     (1)
  2601. #define SECURITY_DESCRIPTOR_REVISION1    (1)
  2602.  
  2603. // end_ntddk
  2604.  
  2605. //
  2606. // Minimum length, in bytes, needed to build a security descriptor
  2607. // (NOTE: This must manually be kept consistent with the)
  2608. // (sizeof(SECURITY_DESCRIPTOR)                         )
  2609. //
  2610.  
  2611. #define SECURITY_DESCRIPTOR_MIN_LENGTH   (20)
  2612.  
  2613.  
  2614. typedef WORD   SECURITY_DESCRIPTOR_CONTROL, *PSECURITY_DESCRIPTOR_CONTROL;
  2615.  
  2616. #define SE_OWNER_DEFAULTED               (0x0001)
  2617. #define SE_GROUP_DEFAULTED               (0x0002)
  2618. #define SE_DACL_PRESENT                  (0x0004)
  2619. #define SE_DACL_DEFAULTED                (0x0008)
  2620. #define SE_SACL_PRESENT                  (0x0010)
  2621. #define SE_SACL_DEFAULTED                (0x0020)
  2622. #define SE_SELF_RELATIVE                 (0x8000)
  2623.  
  2624. //
  2625. //  Where:
  2626. //
  2627. //      SE_OWNER_DEFAULTED - This boolean flag, when set, indicates that the
  2628. //          SID pointed to by the Owner field was provided by a
  2629. //          defaulting mechanism rather than explicitly provided by the
  2630. //          original provider of the security descriptor.  This may
  2631. //          affect the treatment of the SID with respect to inheritence
  2632. //          of an owner.
  2633. //
  2634. //      SE_GROUP_DEFAULTED - This boolean flag, when set, indicates that the
  2635. //          SID in the Group field was provided by a defaulting mechanism
  2636. //          rather than explicitly provided by the original provider of
  2637. //          the security descriptor.  This may affect the treatment of
  2638. //          the SID with respect to inheritence of a primary group.
  2639. //
  2640. //      SE_DACL_PRESENT - This boolean flag, when set, indicates that the
  2641. //          security descriptor contains a discretionary ACL.  If this
  2642. //          flag is set and the Dacl field of the SECURITY_DESCRIPTOR is
  2643. //          null, then a null ACL is explicitly being specified.
  2644. //
  2645. //      SE_DACL_DEFAULTED - This boolean flag, when set, indicates that the
  2646. //          ACL pointed to by the Dacl field was provided by a defaulting
  2647. //          mechanism rather than explicitly provided by the original
  2648. //          provider of the security descriptor.  This may affect the
  2649. //          treatment of the ACL with respect to inheritence of an ACL.
  2650. //          This flag is ignored if the DaclPresent flag is not set.
  2651. //
  2652. //      SE_SACL_PRESENT - This boolean flag, when set,  indicates that the
  2653. //          security descriptor contains a system ACL pointed to by the
  2654. //          Sacl field.  If this flag is set and the Sacl field of the
  2655. //          SECURITY_DESCRIPTOR is null, then an empty (but present)
  2656. //          ACL is being specified.
  2657. //
  2658. //      SE_SACL_DEFAULTED - This boolean flag, when set, indicates that the
  2659. //          ACL pointed to by the Sacl field was provided by a defaulting
  2660. //          mechanism rather than explicitly provided by the original
  2661. //          provider of the security descriptor.  This may affect the
  2662. //          treatment of the ACL with respect to inheritence of an ACL.
  2663. //          This flag is ignored if the SaclPresent flag is not set.
  2664. //
  2665. //      SE_SELF_RELATIVE - This boolean flag, when set, indicates that the
  2666. //          security descriptor is in self-relative form.  In this form,
  2667. //          all fields of the security descriptor are contiguous in memory
  2668. //          and all pointer fields are expressed as offsets from the
  2669. //          beginning of the security descriptor.  This form is useful
  2670. //          for treating security descriptors as opaque data structures
  2671. //          for transmission in communication protocol or for storage on
  2672. //          secondary media.
  2673. //
  2674. //
  2675. //
  2676. // Pictorially the structure of a security descriptor is as follows:
  2677. //
  2678. //       3 3 2 2 2 2 2 2 2 2 2 2 1 1 1 1 1 1 1 1 1 1
  2679. //       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
  2680. //      +---------------------------------------------------------------+
  2681. //      |            Control            |Reserved1 (SBZ)|   Revision    |
  2682. //      +---------------------------------------------------------------+
  2683. //      |                            Owner                              |
  2684. //      +---------------------------------------------------------------+
  2685. //      |                            Group                              |
  2686. //      +---------------------------------------------------------------+
  2687. //      |                            Sacl                               |
  2688. //      +---------------------------------------------------------------+
  2689. //      |                            Dacl                               |
  2690. //      +---------------------------------------------------------------+
  2691. //
  2692. // In general, this data structure should be treated opaquely to ensure future
  2693. // compatibility.
  2694. //
  2695. //
  2696.  
  2697. typedef struct _SECURITY_DESCRIPTOR {
  2698.    BYTE  Revision;
  2699.    BYTE  Sbz1;
  2700.    SECURITY_DESCRIPTOR_CONTROL Control;
  2701.    PSID Owner;
  2702.    PSID Group;
  2703.    PACL Sacl;
  2704.    PACL Dacl;
  2705.    } SECURITY_DESCRIPTOR, *PISECURITY_DESCRIPTOR;
  2706.  
  2707. // end_ntifs
  2708.  
  2709. // Where:
  2710. //
  2711. //     Revision - Contains the revision level of the security
  2712. //         descriptor.  This allows this structure to be passed between
  2713. //         systems or stored on disk even though it is expected to
  2714. //         change in the future.
  2715. //
  2716. //     Control - A set of flags which qualify the meaning of the
  2717. //         security descriptor or individual fields of the security
  2718. //         descriptor.
  2719. //
  2720. //     Owner - is a pointer to an SID representing an object's owner.
  2721. //         If this field is null, then no owner SID is present in the
  2722. //         security descriptor.  If the security descriptor is in
  2723. //         self-relative form, then this field contains an offset to
  2724. //         the SID, rather than a pointer.
  2725. //
  2726. //     Group - is a pointer to an SID representing an object's primary
  2727. //         group.  If this field is null, then no primary group SID is
  2728. //         present in the security descriptor.  If the security descriptor
  2729. //         is in self-relative form, then this field contains an offset to
  2730. //         the SID, rather than a pointer.
  2731. //
  2732. //     Sacl - is a pointer to a system ACL.  This field value is only
  2733. //         valid if the DaclPresent control flag is set.  If the
  2734. //         SaclPresent flag is set and this field is null, then a null
  2735. //         ACL  is specified.  If the security descriptor is in
  2736. //         self-relative form, then this field contains an offset to
  2737. //         the ACL, rather than a pointer.
  2738. //
  2739. //     Dacl - is a pointer to a discretionary ACL.  This field value is
  2740. //         only valid if the DaclPresent control flag is set.  If the
  2741. //         DaclPresent flag is set and this field is null, then a null
  2742. //         ACL (unconditionally granting access) is specified.  If the
  2743. //         security descriptor is in self-relative form, then this field
  2744. //         contains an offset to the ACL, rather than a pointer.
  2745. //
  2746.  
  2747.  
  2748.  
  2749. ////////////////////////////////////////////////////////////////////////
  2750. //                                                                    //
  2751. //               Privilege Related Data Structures                    //
  2752. //                                                                    //
  2753. ////////////////////////////////////////////////////////////////////////
  2754.  
  2755.  
  2756. // begin_ntddk begin_nthal begin_ntifs
  2757. //
  2758. // Privilege attributes
  2759. //
  2760.  
  2761. #define SE_PRIVILEGE_ENABLED_BY_DEFAULT (0x00000001L)
  2762. #define SE_PRIVILEGE_ENABLED            (0x00000002L)
  2763. #define SE_PRIVILEGE_USED_FOR_ACCESS    (0x80000000L)
  2764.  
  2765. //
  2766. // Privilege Set Control flags
  2767. //
  2768.  
  2769. #define PRIVILEGE_SET_ALL_NECESSARY    (1)
  2770.  
  2771. //
  2772. //  Privilege Set - This is defined for a privilege set of one.
  2773. //                  If more than one privilege is needed, then this structure
  2774. //                  will need to be allocated with more space.
  2775. //
  2776. //  Note: don't change this structure without fixing the INITIAL_PRIVILEGE_SET
  2777. //  structure (defined in se.h)
  2778. //
  2779.  
  2780. typedef struct _PRIVILEGE_SET {
  2781.     DWORD PrivilegeCount;
  2782.     DWORD Control;
  2783.     LUID_AND_ATTRIBUTES Privilege[ANYSIZE_ARRAY];
  2784.     } PRIVILEGE_SET, * PPRIVILEGE_SET;
  2785.  
  2786.  
  2787. ////////////////////////////////////////////////////////////////////////
  2788. //                                                                    //
  2789. //               NT Defined Privileges                                //
  2790. //                                                                    //
  2791. ////////////////////////////////////////////////////////////////////////
  2792.  
  2793. #define SE_CREATE_TOKEN_NAME              TEXT("SeCreateTokenPrivilege")
  2794. #define SE_ASSIGNPRIMARYTOKEN_NAME        TEXT("SeAssignPrimaryTokenPrivilege")
  2795. #define SE_LOCK_MEMORY_NAME               TEXT("SeLockMemoryPrivilege")
  2796. #define SE_INCREASE_QUOTA_NAME            TEXT("SeIncreaseQuotaPrivilege")
  2797. #define SE_UNSOLICITED_INPUT_NAME         TEXT("SeUnsolicitedInputPrivilege")
  2798. #define SE_MACHINE_ACCOUNT_NAME           TEXT("SeMachineAccountPrivilege")
  2799. #define SE_TCB_NAME                       TEXT("SeTcbPrivilege")
  2800. #define SE_SECURITY_NAME                  TEXT("SeSecurityPrivilege")
  2801. #define SE_TAKE_OWNERSHIP_NAME            TEXT("SeTakeOwnershipPrivilege")
  2802. #define SE_LOAD_DRIVER_NAME               TEXT("SeLoadDriverPrivilege")
  2803. #define SE_SYSTEM_PROFILE_NAME            TEXT("SeSystemProfilePrivilege")
  2804. #define SE_SYSTEMTIME_NAME                TEXT("SeSystemtimePrivilege")
  2805. #define SE_PROF_SINGLE_PROCESS_NAME       TEXT("SeProfileSingleProcessPrivilege")
  2806. #define SE_INC_BASE_PRIORITY_NAME         TEXT("SeIncreaseBasePriorityPrivilege")
  2807. #define SE_CREATE_PAGEFILE_NAME           TEXT("SeCreatePagefilePrivilege")
  2808. #define SE_CREATE_PERMANENT_NAME          TEXT("SeCreatePermanentPrivilege")
  2809. #define SE_BACKUP_NAME                    TEXT("SeBackupPrivilege")
  2810. #define SE_RESTORE_NAME                   TEXT("SeRestorePrivilege")
  2811. #define SE_SHUTDOWN_NAME                  TEXT("SeShutdownPrivilege")
  2812. #define SE_DEBUG_NAME                     TEXT("SeDebugPrivilege")
  2813. #define SE_AUDIT_NAME                     TEXT("SeAuditPrivilege")
  2814. #define SE_SYSTEM_ENVIRONMENT_NAME        TEXT("SeSystemEnvironmentPrivilege")
  2815. #define SE_CHANGE_NOTIFY_NAME             TEXT("SeChangeNotifyPrivilege")
  2816. #define SE_REMOTE_SHUTDOWN_NAME           TEXT("SeRemoteShutdownPrivilege")
  2817.  
  2818.  
  2819. ////////////////////////////////////////////////////////////////////
  2820. //                                                                //
  2821. //           Security Quality Of Service                          //
  2822. //                                                                //
  2823. //                                                                //
  2824. ////////////////////////////////////////////////////////////////////
  2825.  
  2826. // begin_ntddk begin_nthal begin_ntifs
  2827. //
  2828. // Impersonation Level
  2829. //
  2830. // Impersonation level is represented by a pair of bits in Windows.
  2831. // If a new impersonation level is added or lowest value is changed from
  2832. // 0 to something else, fix the Windows CreateFile call.
  2833. //
  2834.  
  2835. typedef enum _SECURITY_IMPERSONATION_LEVEL {
  2836.     SecurityAnonymous,
  2837.     SecurityIdentification,
  2838.     SecurityImpersonation,
  2839.     SecurityDelegation
  2840.     } SECURITY_IMPERSONATION_LEVEL, * PSECURITY_IMPERSONATION_LEVEL;
  2841.  
  2842. #define SECURITY_MAX_IMPERSONATION_LEVEL SecurityDelegation
  2843.  
  2844. #define DEFAULT_IMPERSONATION_LEVEL SecurityImpersonation
  2845.  
  2846. // end_nthal
  2847. //
  2848. // Security Tracking Mode
  2849. //
  2850.  
  2851. #define SECURITY_DYNAMIC_TRACKING      (TRUE)
  2852. #define SECURITY_STATIC_TRACKING       (FALSE)
  2853.  
  2854. typedef BOOLEAN SECURITY_CONTEXT_TRACKING_MODE,
  2855.                     * PSECURITY_CONTEXT_TRACKING_MODE;
  2856.  
  2857.  
  2858.  
  2859. //
  2860. // Quality Of Service
  2861. //
  2862.  
  2863. typedef struct _SECURITY_QUALITY_OF_SERVICE {
  2864.     DWORD Length;
  2865.     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
  2866.     SECURITY_CONTEXT_TRACKING_MODE ContextTrackingMode;
  2867.     BOOLEAN EffectiveOnly;
  2868.     } SECURITY_QUALITY_OF_SERVICE, * PSECURITY_QUALITY_OF_SERVICE;
  2869.  
  2870.  
  2871. //
  2872. // Used to represent information related to a thread impersonation
  2873. //
  2874.  
  2875. typedef struct _SE_IMPERSONATION_STATE {
  2876.     PACCESS_TOKEN Token;
  2877.     BOOLEAN CopyOnOpen;
  2878.     BOOLEAN EffectiveOnly;
  2879.     SECURITY_IMPERSONATION_LEVEL Level;
  2880. } SE_IMPERSONATION_STATE, *PSE_IMPERSONATION_STATE;
  2881.  
  2882.  
  2883. ////////////////////////////////////////////////////////////////////
  2884. //                                                                //
  2885. //           Token Object Definitions                             //
  2886. //                                                                //
  2887. //                                                                //
  2888. ////////////////////////////////////////////////////////////////////
  2889.  
  2890.  
  2891. //
  2892. // Token Specific Access Rights.
  2893. //
  2894.  
  2895. #define TOKEN_ASSIGN_PRIMARY    (0x0001)
  2896. #define TOKEN_DUPLICATE         (0x0002)
  2897. #define TOKEN_IMPERSONATE       (0x0004)
  2898. #define TOKEN_QUERY             (0x0008)
  2899. #define TOKEN_QUERY_SOURCE      (0x0010)
  2900. #define TOKEN_ADJUST_PRIVILEGES (0x0020)
  2901. #define TOKEN_ADJUST_GROUPS     (0x0040)
  2902. #define TOKEN_ADJUST_DEFAULT    (0x0080)
  2903.  
  2904. #define TOKEN_ALL_ACCESS (STANDARD_RIGHTS_REQUIRED  |\
  2905.                           TOKEN_ASSIGN_PRIMARY      |\
  2906.                           TOKEN_DUPLICATE           |\
  2907.                           TOKEN_IMPERSONATE         |\
  2908.                           TOKEN_QUERY               |\
  2909.                           TOKEN_QUERY_SOURCE        |\
  2910.                           TOKEN_ADJUST_PRIVILEGES   |\
  2911.                           TOKEN_ADJUST_GROUPS       |\
  2912.                           TOKEN_ADJUST_DEFAULT)
  2913.  
  2914.  
  2915. #define TOKEN_READ       (STANDARD_RIGHTS_READ      |\
  2916.                           TOKEN_QUERY)
  2917.  
  2918.  
  2919. #define TOKEN_WRITE      (STANDARD_RIGHTS_WRITE     |\
  2920.                           TOKEN_ADJUST_PRIVILEGES   |\
  2921.                           TOKEN_ADJUST_GROUPS       |\
  2922.                           TOKEN_ADJUST_DEFAULT)
  2923.  
  2924. #define TOKEN_EXECUTE    (STANDARD_RIGHTS_EXECUTE)
  2925.  
  2926.  
  2927. // begin_ntifs
  2928. //
  2929. // Token Types
  2930. //
  2931.  
  2932. typedef enum _TOKEN_TYPE {
  2933.     TokenPrimary = 1,
  2934.     TokenImpersonation
  2935.     } TOKEN_TYPE;
  2936. typedef TOKEN_TYPE *PTOKEN_TYPE;
  2937.  
  2938. // end_ntifs
  2939.  
  2940. //
  2941. // Token Information Classes.
  2942. //
  2943.  
  2944.  
  2945. typedef enum _TOKEN_INFORMATION_CLASS {
  2946.     TokenUser = 1,
  2947.     TokenGroups,
  2948.     TokenPrivileges,
  2949.     TokenOwner,
  2950.     TokenPrimaryGroup,
  2951.     TokenDefaultDacl,
  2952.     TokenSource,
  2953.     TokenType,
  2954.     TokenImpersonationLevel,
  2955.     TokenStatistics
  2956. } TOKEN_INFORMATION_CLASS, *PTOKEN_INFORMATION_CLASS;
  2957.  
  2958. //
  2959. // Token information class structures
  2960. //
  2961.  
  2962.  
  2963. typedef struct _TOKEN_USER {
  2964.     SID_AND_ATTRIBUTES User;
  2965. } TOKEN_USER, *PTOKEN_USER;
  2966.  
  2967.  
  2968. typedef struct _TOKEN_GROUPS {
  2969.     DWORD GroupCount;
  2970.     SID_AND_ATTRIBUTES Groups[ANYSIZE_ARRAY];
  2971. } TOKEN_GROUPS, *PTOKEN_GROUPS;
  2972.  
  2973.  
  2974. typedef struct _TOKEN_PRIVILEGES {
  2975.     DWORD PrivilegeCount;
  2976.     LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY];
  2977. } TOKEN_PRIVILEGES, *PTOKEN_PRIVILEGES;
  2978.  
  2979.  
  2980. typedef struct _TOKEN_OWNER {
  2981.     PSID Owner;
  2982. } TOKEN_OWNER, *PTOKEN_OWNER;
  2983.  
  2984.  
  2985. typedef struct _TOKEN_PRIMARY_GROUP {
  2986.     PSID PrimaryGroup;
  2987. } TOKEN_PRIMARY_GROUP, *PTOKEN_PRIMARY_GROUP;
  2988.  
  2989.  
  2990. typedef struct _TOKEN_DEFAULT_DACL {
  2991.     PACL DefaultDacl;
  2992. } TOKEN_DEFAULT_DACL, *PTOKEN_DEFAULT_DACL;
  2993.  
  2994.  
  2995. // begin_ntifs
  2996.  
  2997. #define TOKEN_SOURCE_LENGTH 8
  2998.  
  2999. typedef struct _TOKEN_SOURCE {
  3000.     CHAR SourceName[TOKEN_SOURCE_LENGTH];
  3001.     LUID SourceIdentifier;
  3002. } TOKEN_SOURCE, *PTOKEN_SOURCE;
  3003.  
  3004. // end_ntifs
  3005.  
  3006. typedef struct _TOKEN_STATISTICS {
  3007.     LUID TokenId;
  3008.     LUID AuthenticationId;
  3009.     LARGE_INTEGER ExpirationTime;
  3010.     TOKEN_TYPE TokenType;
  3011.     SECURITY_IMPERSONATION_LEVEL ImpersonationLevel;
  3012.     DWORD DynamicCharged;
  3013.     DWORD DynamicAvailable;
  3014.     DWORD GroupCount;
  3015.     DWORD PrivilegeCount;
  3016.     LUID ModifiedId;
  3017. } TOKEN_STATISTICS, *PTOKEN_STATISTICS;
  3018.  
  3019.  
  3020. // begin_ntifs
  3021.  
  3022. typedef struct _TOKEN_CONTROL {
  3023.     LUID TokenId;
  3024.     LUID AuthenticationId;
  3025.     LUID ModifiedId;
  3026.     TOKEN_SOURCE TokenSource;
  3027.     } TOKEN_CONTROL, *PTOKEN_CONTROL;
  3028.  
  3029.  
  3030. typedef DWORD SECURITY_INFORMATION, *PSECURITY_INFORMATION;
  3031.  
  3032. #define OWNER_SECURITY_INFORMATION       (0X00000001L)
  3033. #define GROUP_SECURITY_INFORMATION       (0X00000002L)
  3034. #define DACL_SECURITY_INFORMATION        (0X00000004L)
  3035. #define SACL_SECURITY_INFORMATION        (0X00000008L)
  3036.  
  3037.  
  3038. //
  3039. // Image Format
  3040. //
  3041.  
  3042. #ifndef NOIMAGE
  3043.  
  3044. #include "pshpack1.h"
  3045.  
  3046. #define IMAGE_DOS_SIGNATURE                 0x5A4D      // MZ
  3047. #define IMAGE_OS2_SIGNATURE                 0x454E      // NE
  3048. #define IMAGE_OS2_SIGNATURE_LE              0x454C      // LE
  3049. #define IMAGE_VXD_SIGNATURE                 0x454C      // LE
  3050. #define IMAGE_NT_SIGNATURE                  0x00004550  // PE00
  3051.  
  3052. typedef struct _IMAGE_DOS_HEADER {      // DOS .EXE header
  3053.     WORD   e_magic;                     // Magic number
  3054.     WORD   e_cblp;                      // Bytes on last page of file
  3055.     WORD   e_cp;                        // Pages in file
  3056.     WORD   e_crlc;                      // Relocations
  3057.     WORD   e_cparhdr;                   // Size of header in paragraphs
  3058.     WORD   e_minalloc;                  // Minimum extra paragraphs needed
  3059.     WORD   e_maxalloc;                  // Maximum extra paragraphs needed
  3060.     WORD   e_ss;                        // Initial (relative) SS value
  3061.     WORD   e_sp;                        // Initial SP value
  3062.     WORD   e_csum;                      // Checksum
  3063.     WORD   e_ip;                        // Initial IP value
  3064.     WORD   e_cs;                        // Initial (relative) CS value
  3065.     WORD   e_lfarlc;                    // File address of relocation table
  3066.     WORD   e_ovno;                      // Overlay number
  3067.     WORD   e_res[4];                    // Reserved words
  3068.     WORD   e_oemid;                     // OEM identifier (for e_oeminfo)
  3069.     WORD   e_oeminfo;                   // OEM information; e_oemid specific
  3070.     WORD   e_res2[10];                  // Reserved words
  3071.     LONG   e_lfanew;                    // File address of new exe header
  3072.   } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
  3073.  
  3074. typedef struct _IMAGE_OS2_HEADER {      // OS/2 .EXE header
  3075.     WORD   ne_magic;                    // Magic number
  3076.     CHAR   ne_ver;                      // Version number
  3077.     CHAR   ne_rev;                      // Revision number
  3078.     WORD   ne_enttab;                   // Offset of Entry Table
  3079.     WORD   ne_cbenttab;                 // Number of bytes in Entry Table
  3080.     LONG   ne_crc;                      // Checksum of whole file
  3081.     WORD   ne_flags;                    // Flag word
  3082.     WORD   ne_autodata;                 // Automatic data segment number
  3083.     WORD   ne_heap;                     // Initial heap allocation
  3084.     WORD   ne_stack;                    // Initial stack allocation
  3085.     LONG   ne_csip;                     // Initial CS:IP setting
  3086.     LONG   ne_sssp;                     // Initial SS:SP setting
  3087.     WORD   ne_cseg;                     // Count of file segments
  3088.     WORD   ne_cmod;                     // Entries in Module Reference Table
  3089.     WORD   ne_cbnrestab;                // Size of non-resident name table
  3090.     WORD   ne_segtab;                   // Offset of Segment Table
  3091.     WORD   ne_rsrctab;                  // Offset of Resource Table
  3092.     WORD   ne_restab;                   // Offset of resident name table
  3093.     WORD   ne_modtab;                   // Offset of Module Reference Table
  3094.     WORD   ne_imptab;                   // Offset of Imported Names Table
  3095.     LONG   ne_nrestab;                  // Offset of Non-resident Names Table
  3096.     WORD   ne_cmovent;                  // Count of movable entries
  3097.     WORD   ne_align;                    // Segment alignment shift count
  3098.     WORD   ne_cres;                     // Count of resource segments
  3099.     BYTE   ne_exetyp;                   // Target Operating system
  3100.     BYTE   ne_flagsothers;              // Other .EXE flags
  3101.     WORD   ne_pretthunks;               // offset to return thunks
  3102.     WORD   ne_psegrefbytes;             // offset to segment ref. bytes
  3103.     WORD   ne_swaparea;                 // Minimum code swap area size
  3104.     WORD   ne_expver;                   // Expected Windows version number
  3105.   } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER;
  3106.  
  3107. typedef struct _IMAGE_VXD_HEADER {      // Windows VXD header
  3108.     WORD   e32_magic;                   // Magic number
  3109.     BYTE   e32_border;                  // The byte ordering for the VXD
  3110.     BYTE   e32_worder;                  // The word ordering for the VXD
  3111.     DWORD  e32_level;                   // The EXE format level for now = 0
  3112.     WORD   e32_cpu;                     // The CPU type
  3113.     WORD   e32_os;                      // The OS type
  3114.     DWORD  e32_ver;                     // Module version
  3115.     DWORD  e32_mflags;                  // Module flags
  3116.     DWORD  e32_mpages;                  // Module # pages
  3117.     DWORD  e32_startobj;                // Object # for instruction pointer
  3118.     DWORD  e32_eip;                     // Extended instruction pointer
  3119.     DWORD  e32_stackobj;                // Object # for stack pointer
  3120.     DWORD  e32_esp;                     // Extended stack pointer
  3121.     DWORD  e32_pagesize;                // VXD page size
  3122.     DWORD  e32_lastpagesize;            // Last page size in VXD
  3123.     DWORD  e32_fixupsize;               // Fixup section size
  3124.     DWORD  e32_fixupsum;                // Fixup section checksum
  3125.     DWORD  e32_ldrsize;                 // Loader section size
  3126.     DWORD  e32_ldrsum;                  // Loader section checksum
  3127.     DWORD  e32_objtab;                  // Object table offset
  3128.     DWORD  e32_objcnt;                  // Number of objects in module
  3129.     DWORD  e32_objmap;                  // Object page map offset
  3130.     DWORD  e32_itermap;                 // Object iterated data map offset
  3131.     DWORD  e32_rsrctab;                 // Offset of Resource Table
  3132.     DWORD  e32_rsrccnt;                 // Number of resource entries
  3133.     DWORD  e32_restab;                  // Offset of resident name table
  3134.     DWORD  e32_enttab;                  // Offset of Entry Table
  3135.     DWORD  e32_dirtab;                  // Offset of Module Directive Table
  3136.     DWORD  e32_dircnt;                  // Number of module directives
  3137.     DWORD  e32_fpagetab;                // Offset of Fixup Page Table
  3138.     DWORD  e32_frectab;                 // Offset of Fixup Record Table
  3139.     DWORD  e32_impmod;                  // Offset of Import Module Name Table
  3140.     DWORD  e32_impmodcnt;               // Number of entries in Import Module Name Table
  3141.     DWORD  e32_impproc;                 // Offset of Import Procedure Name Table
  3142.     DWORD  e32_pagesum;                 // Offset of Per-Page Checksum Table
  3143.     DWORD  e32_datapage;                // Offset of Enumerated Data Pages
  3144.     DWORD  e32_preload;                 // Number of preload pages
  3145.     DWORD  e32_nrestab;                 // Offset of Non-resident Names Table
  3146.     DWORD  e32_cbnrestab;               // Size of Non-resident Name Table
  3147.     DWORD  e32_nressum;                 // Non-resident Name Table Checksum
  3148.     DWORD  e32_autodata;                // Object # for automatic data object
  3149.     DWORD  e32_debuginfo;               // Offset of the debugging information
  3150.     DWORD  e32_debuglen;                // The length of the debugging info. in bytes
  3151.     DWORD  e32_instpreload;             // Number of instance pages in preload section of VXD file
  3152.     DWORD  e32_instdemand;              // Number of instance pages in demand load section of VXD file
  3153.     DWORD  e32_heapsize;                // Size of heap - for 16-bit apps
  3154.     BYTE   e32_res3[12];                // Reserved words
  3155.     DWORD  e32_winresoff;
  3156.     DWORD  e32_winreslen;
  3157.     WORD   e32_devid;                   // Device ID for VxD
  3158.     WORD   e32_ddkver;                  // DDK version for VxD
  3159.   } IMAGE_VXD_HEADER, *PIMAGE_VXD_HEADER;
  3160.  
  3161. //
  3162. // File header format.
  3163. //
  3164.  
  3165. typedef struct _IMAGE_FILE_HEADER {
  3166.     WORD    Machine;
  3167.     WORD    NumberOfSections;
  3168.     DWORD   TimeDateStamp;
  3169.     DWORD   PointerToSymbolTable;
  3170.     DWORD   NumberOfSymbols;
  3171.     WORD    SizeOfOptionalHeader;
  3172.     WORD    Characteristics;
  3173. } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
  3174.  
  3175. #define IMAGE_SIZEOF_FILE_HEADER             20
  3176.  
  3177. #define IMAGE_FILE_RELOCS_STRIPPED           0x0001  // Relocation info stripped from file.
  3178. #define IMAGE_FILE_EXECUTABLE_IMAGE          0x0002  // File is executable  (i.e. no unresolved externel references).
  3179. #define IMAGE_FILE_LINE_NUMS_STRIPPED        0x0004  // Line nunbers stripped from file.
  3180. #define IMAGE_FILE_LOCAL_SYMS_STRIPPED       0x0008  // Local symbols stripped from file.
  3181. #define IMAGE_FILE_BYTES_REVERSED_LO         0x0080  // Bytes of machine word are reversed.
  3182. #define IMAGE_FILE_32BIT_MACHINE             0x0100  // 32 bit word machine.
  3183. #define IMAGE_FILE_DEBUG_STRIPPED            0x0200  // Debugging info stripped from file in .DBG file
  3184. #define IMAGE_FILE_SYSTEM                    0x1000  // System File.
  3185. #define IMAGE_FILE_DLL                       0x2000  // File is a DLL.
  3186. #define IMAGE_FILE_BYTES_REVERSED_HI         0x8000  // Bytes of machine word are reversed.
  3187.  
  3188. #define IMAGE_FILE_MACHINE_UNKNOWN           0
  3189. #define IMAGE_FILE_MACHINE_I386              0x14c   // Intel 386.
  3190. #define IMAGE_FILE_MACHINE_R3000             0x162   // MIPS little-endian, 0x160 big-endian
  3191. #define IMAGE_FILE_MACHINE_R4000             0x166   // MIPS little-endian
  3192. #define IMAGE_FILE_MACHINE_R10000            0x168   // MIPS little-endian
  3193. #define IMAGE_FILE_MACHINE_ALPHA             0x184   // Alpha_AXP
  3194. #define IMAGE_FILE_MACHINE_POWERPC           0x1F0   // IBM PowerPC Little-Endian
  3195.  
  3196. //
  3197. // Directory format.
  3198. //
  3199.  
  3200. typedef struct _IMAGE_DATA_DIRECTORY {
  3201.     DWORD   VirtualAddress;
  3202.     DWORD   Size;
  3203. } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
  3204.  
  3205. #define IMAGE_NUMBEROF_DIRECTORY_ENTRIES    16
  3206.  
  3207. //
  3208. // Optional header format.
  3209. //
  3210.  
  3211. typedef struct _IMAGE_OPTIONAL_HEADER {
  3212.     //
  3213.     // Standard fields.
  3214.     //
  3215.  
  3216.     WORD    Magic;
  3217.     BYTE    MajorLinkerVersion;
  3218.     BYTE    MinorLinkerVersion;
  3219.     DWORD   SizeOfCode;
  3220.     DWORD   SizeOfInitializedData;
  3221.     DWORD   SizeOfUninitializedData;
  3222.     DWORD   AddressOfEntryPoint;
  3223.     DWORD   BaseOfCode;
  3224.     DWORD   BaseOfData;
  3225.  
  3226.     //
  3227.     // NT additional fields.
  3228.     //
  3229.  
  3230.     DWORD   ImageBase;
  3231.     DWORD   SectionAlignment;
  3232.     DWORD   FileAlignment;
  3233.     WORD    MajorOperatingSystemVersion;
  3234.     WORD    MinorOperatingSystemVersion;
  3235.     WORD    MajorImageVersion;
  3236.     WORD    MinorImageVersion;
  3237.     WORD    MajorSubsystemVersion;
  3238.     WORD    MinorSubsystemVersion;
  3239.     DWORD   Reserved1;
  3240.     DWORD   SizeOfImage;
  3241.     DWORD   SizeOfHeaders;
  3242.     DWORD   CheckSum;
  3243.     WORD    Subsystem;
  3244.     WORD    DllCharacteristics;
  3245.     DWORD   SizeOfStackReserve;
  3246.     DWORD   SizeOfStackCommit;
  3247.     DWORD   SizeOfHeapReserve;
  3248.     DWORD   SizeOfHeapCommit;
  3249.     DWORD   LoaderFlags;
  3250.     DWORD   NumberOfRvaAndSizes;
  3251.     IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
  3252. } IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
  3253.  
  3254. typedef struct _IMAGE_ROM_OPTIONAL_HEADER {
  3255.     WORD   Magic;
  3256.     BYTE   MajorLinkerVersion;
  3257.     BYTE   MinorLinkerVersion;
  3258.     DWORD  SizeOfCode;
  3259.     DWORD  SizeOfInitializedData;
  3260.     DWORD  SizeOfUninitializedData;
  3261.     DWORD  AddressOfEntryPoint;
  3262.     DWORD  BaseOfCode;
  3263.     DWORD  BaseOfData;
  3264.     DWORD  BaseOfBss;
  3265.     DWORD  GprMask;
  3266.     DWORD  CprMask[4];
  3267.     DWORD  GpValue;
  3268. } IMAGE_ROM_OPTIONAL_HEADER, *PIMAGE_ROM_OPTIONAL_HEADER;
  3269.  
  3270. #define IMAGE_SIZEOF_ROM_OPTIONAL_HEADER      56
  3271. #define IMAGE_SIZEOF_STD_OPTIONAL_HEADER      28
  3272. #define IMAGE_SIZEOF_NT_OPTIONAL_HEADER      224
  3273.  
  3274. #define IMAGE_NT_OPTIONAL_HDR_MAGIC        0x10b
  3275. #define IMAGE_ROM_OPTIONAL_HDR_MAGIC       0x107
  3276.  
  3277. typedef struct _IMAGE_NT_HEADERS {
  3278.     DWORD Signature;
  3279.     IMAGE_FILE_HEADER FileHeader;
  3280.     IMAGE_OPTIONAL_HEADER OptionalHeader;
  3281. } IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS;
  3282.  
  3283. typedef struct _IMAGE_ROM_HEADERS {
  3284.     IMAGE_FILE_HEADER FileHeader;
  3285.     IMAGE_ROM_OPTIONAL_HEADER OptionalHeader;
  3286. } IMAGE_ROM_HEADERS, *PIMAGE_ROM_HEADERS;
  3287.  
  3288. #define IMAGE_FIRST_SECTION( ntheader ) ((PIMAGE_SECTION_HEADER)        \
  3289.     ((DWORD)ntheader +                                                  \
  3290.      FIELD_OFFSET( IMAGE_NT_HEADERS, OptionalHeader ) +                 \
  3291.      ((PIMAGE_NT_HEADERS)(ntheader))->FileHeader.SizeOfOptionalHeader   \
  3292.     ))
  3293.  
  3294.  
  3295. // Subsystem Values
  3296.  
  3297. #define IMAGE_SUBSYSTEM_UNKNOWN              0   // Unknown subsystem.
  3298. #define IMAGE_SUBSYSTEM_NATIVE               1   // Image doesn't require a subsystem.
  3299. #define IMAGE_SUBSYSTEM_WINDOWS_GUI          2   // Image runs in the Windows GUI subsystem.
  3300. #define IMAGE_SUBSYSTEM_WINDOWS_CUI          3   // Image runs in the Windows character subsystem.
  3301. #define IMAGE_SUBSYSTEM_OS2_CUI              5   // image runs in the OS/2 character subsystem.
  3302. #define IMAGE_SUBSYSTEM_POSIX_CUI            7   // image run  in the Posix character subsystem.
  3303.  
  3304.  
  3305. // Directory Entries
  3306.  
  3307. #define IMAGE_DIRECTORY_ENTRY_EXPORT         0   // Export Directory
  3308. #define IMAGE_DIRECTORY_ENTRY_IMPORT         1   // Import Directory
  3309. #define IMAGE_DIRECTORY_ENTRY_RESOURCE       2   // Resource Directory
  3310. #define IMAGE_DIRECTORY_ENTRY_EXCEPTION      3   // Exception Directory
  3311. #define IMAGE_DIRECTORY_ENTRY_SECURITY       4   // Security Directory
  3312. #define IMAGE_DIRECTORY_ENTRY_BASERELOC      5   // Base Relocation Table
  3313. #define IMAGE_DIRECTORY_ENTRY_DEBUG          6   // Debug Directory
  3314. #define IMAGE_DIRECTORY_ENTRY_COPYRIGHT      7   // Description String
  3315. #define IMAGE_DIRECTORY_ENTRY_GLOBALPTR      8   // Machine Value (MIPS GP)
  3316. #define IMAGE_DIRECTORY_ENTRY_TLS            9   // TLS Directory
  3317. #define IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG   10   // Load Configuration Directory
  3318. #define IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT  11   // Bound Import Directory in headers
  3319. #define IMAGE_DIRECTORY_ENTRY_IAT           12   // Import Address Table
  3320.  
  3321. //
  3322. // Section header format.
  3323. //
  3324.  
  3325. #define IMAGE_SIZEOF_SHORT_NAME              8
  3326.  
  3327. typedef struct _IMAGE_SECTION_HEADER {
  3328.     BYTE    Name[IMAGE_SIZEOF_SHORT_NAME];
  3329.     union {
  3330.             DWORD   PhysicalAddress;
  3331.             DWORD   VirtualSize;
  3332.     } Misc;
  3333.     DWORD   VirtualAddress;
  3334.     DWORD   SizeOfRawData;
  3335.     DWORD   PointerToRawData;
  3336.     DWORD   PointerToRelocations;
  3337.     DWORD   PointerToLinenumbers;
  3338.     WORD    NumberOfRelocations;
  3339.     WORD    NumberOfLinenumbers;
  3340.     DWORD   Characteristics;
  3341. } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
  3342.  
  3343. #define IMAGE_SIZEOF_SECTION_HEADER          40
  3344.  
  3345. //
  3346. // Section characteristics.
  3347. //
  3348.  
  3349. //      IMAGE_SCN_TYPE_REG                   0x00000000  // Reserved.
  3350. //      IMAGE_SCN_TYPE_DSECT                 0x00000001  // Reserved.
  3351. //      IMAGE_SCN_TYPE_NOLOAD                0x00000002  // Reserved.
  3352. //      IMAGE_SCN_TYPE_GROUP                 0x00000004  // Reserved.
  3353. #define IMAGE_SCN_TYPE_NO_PAD                0x00000008  // Reserved.
  3354. //      IMAGE_SCN_TYPE_COPY                  0x00000010  // Reserved.
  3355.  
  3356. #define IMAGE_SCN_CNT_CODE                   0x00000020  // Section contains code.
  3357. #define IMAGE_SCN_CNT_INITIALIZED_DATA       0x00000040  // Section contains initialized data.
  3358. #define IMAGE_SCN_CNT_UNINITIALIZED_DATA     0x00000080  // Section contains uninitialized data.
  3359.  
  3360. #define IMAGE_SCN_LNK_OTHER                  0x00000100  // Reserved.
  3361. #define IMAGE_SCN_LNK_INFO                   0x00000200  // Section contains comments or some other type of information.
  3362. //      IMAGE_SCN_TYPE_OVER                  0x00000400  // Reserved.
  3363. #define IMAGE_SCN_LNK_REMOVE                 0x00000800  // Section contents will not become part of image.
  3364. #define IMAGE_SCN_LNK_COMDAT                 0x00001000  // Section contents comdat.
  3365. //                                           0x00002000  // Reserved.
  3366.  
  3367. //      IMAGE_SCN_MEM_PROTECTED - Obsolete   0x00004000
  3368. #define IMAGE_SCN_MEM_FARDATA                0x00008000
  3369. //      IMAGE_SCN_MEM_SYSHEAP  - Obsolete    0x00010000
  3370. #define IMAGE_SCN_MEM_PURGEABLE              0x00020000
  3371. #define IMAGE_SCN_MEM_16BIT                  0x00020000
  3372. #define IMAGE_SCN_MEM_LOCKED                 0x00040000
  3373. #define IMAGE_SCN_MEM_PRELOAD                0x00080000
  3374.  
  3375. #define IMAGE_SCN_ALIGN_1BYTES               0x00100000  //
  3376. #define IMAGE_SCN_ALIGN_2BYTES               0x00200000  //
  3377. #define IMAGE_SCN_ALIGN_4BYTES               0x00300000  //
  3378. #define IMAGE_SCN_ALIGN_8BYTES               0x00400000  //
  3379. #define IMAGE_SCN_ALIGN_16BYTES              0x00500000  // Default alignment if no others are specified.
  3380. #define IMAGE_SCN_ALIGN_32BYTES              0x00600000  //
  3381. #define IMAGE_SCN_ALIGN_64BYTES              0x00700000  //
  3382. // Unused                                    0x00800000
  3383.  
  3384. #define IMAGE_SCN_LNK_NRELOC_OVFL            0x01000000  // Section contains extended relocations.
  3385. #define IMAGE_SCN_MEM_DISCARDABLE            0x02000000  // Section can be discarded.
  3386. #define IMAGE_SCN_MEM_NOT_CACHED             0x04000000  // Section is not cachable.
  3387. #define IMAGE_SCN_MEM_NOT_PAGED              0x08000000  // Section is not pageable.
  3388. #define IMAGE_SCN_MEM_SHARED                 0x10000000  // Section is shareable.
  3389. #define IMAGE_SCN_MEM_EXECUTE                0x20000000  // Section is executable.
  3390. #define IMAGE_SCN_MEM_READ                   0x40000000  // Section is readable.
  3391. #define IMAGE_SCN_MEM_WRITE                  0x80000000  // Section is writeable.
  3392.  
  3393. //
  3394. // Symbol format.
  3395. //
  3396.  
  3397. typedef struct _IMAGE_SYMBOL {
  3398.     union {
  3399.         BYTE    ShortName[8];
  3400.         struct {
  3401.             DWORD   Short;     // if 0, use LongName
  3402.             DWORD   Long;      // offset into string table
  3403.         } Name;
  3404.         PBYTE   LongName[2];
  3405.     } N;
  3406.     DWORD   Value;
  3407.     SHORT   SectionNumber;
  3408.     WORD    Type;
  3409.     BYTE    StorageClass;
  3410.     BYTE    NumberOfAuxSymbols;
  3411. } IMAGE_SYMBOL;
  3412. typedef IMAGE_SYMBOL UNALIGNED *PIMAGE_SYMBOL;
  3413.  
  3414. #define IMAGE_SIZEOF_SYMBOL                  18
  3415.  
  3416. //
  3417. // Section values.
  3418. //
  3419. // Symbols have a section number of the section in which they are
  3420. // defined. Otherwise, section numbers have the following meanings:
  3421. //
  3422.  
  3423. #define IMAGE_SYM_UNDEFINED           (SHORT)0          // Symbol is undefined or is common.
  3424. #define IMAGE_SYM_ABSOLUTE            (SHORT)-1         // Symbol is an absolute value.
  3425. #define IMAGE_SYM_DEBUG               (SHORT)-2         // Symbol is a special debug item.
  3426.  
  3427. //
  3428. // Type (fundamental) values.
  3429. //
  3430.  
  3431. #define IMAGE_SYM_TYPE_NULL                 0x0000  // no type.
  3432. #define IMAGE_SYM_TYPE_VOID                 0x0001  //
  3433. #define IMAGE_SYM_TYPE_CHAR                 0x0002  // type character.
  3434. #define IMAGE_SYM_TYPE_SHORT                0x0003  // type short integer.
  3435. #define IMAGE_SYM_TYPE_INT                  0x0004  //
  3436. #define IMAGE_SYM_TYPE_LONG                 0x0005  //
  3437. #define IMAGE_SYM_TYPE_FLOAT                0x0006  //
  3438. #define IMAGE_SYM_TYPE_DOUBLE               0x0007  //
  3439. #define IMAGE_SYM_TYPE_STRUCT               0x0008  //
  3440. #define IMAGE_SYM_TYPE_UNION                0x0009  //
  3441. #define IMAGE_SYM_TYPE_ENUM                 0x000A  // enumeration.
  3442. #define IMAGE_SYM_TYPE_MOE                  0x000B  // member of enumeration.
  3443. #define IMAGE_SYM_TYPE_BYTE                 0x000C  //
  3444. #define IMAGE_SYM_TYPE_WORD                 0x000D  //
  3445. #define IMAGE_SYM_TYPE_UINT                 0x000E  //
  3446. #define IMAGE_SYM_TYPE_DWORD                0x000F  //
  3447. #define IMAGE_SYM_TYPE_PCODE                0x8000  //
  3448.  
  3449. //
  3450. // Type (derived) values.
  3451. //
  3452.  
  3453. #define IMAGE_SYM_DTYPE_NULL                0       // no derived type.
  3454. #define IMAGE_SYM_DTYPE_POINTER             1       // pointer.
  3455. #define IMAGE_SYM_DTYPE_FUNCTION            2       // function.
  3456. #define IMAGE_SYM_DTYPE_ARRAY               3       // array.
  3457.  
  3458. //
  3459. // Storage classes.
  3460. //
  3461.  
  3462. #define IMAGE_SYM_CLASS_END_OF_FUNCTION     (BYTE )-1
  3463. #define IMAGE_SYM_CLASS_NULL                0x0000
  3464. #define IMAGE_SYM_CLASS_AUTOMATIC           0x0001
  3465. #define IMAGE_SYM_CLASS_EXTERNAL            0x0002
  3466. #define IMAGE_SYM_CLASS_STATIC              0x0003
  3467. #define IMAGE_SYM_CLASS_REGISTER            0x0004
  3468. #define IMAGE_SYM_CLASS_EXTERNAL_DEF        0x0005
  3469. #define IMAGE_SYM_CLASS_LABEL               0x0006
  3470. #define IMAGE_SYM_CLASS_UNDEFINED_LABEL     0x0007
  3471. #define IMAGE_SYM_CLASS_MEMBER_OF_STRUCT    0x0008
  3472. #define IMAGE_SYM_CLASS_ARGUMENT            0x0009
  3473. #define IMAGE_SYM_CLASS_STRUCT_TAG          0x000A
  3474. #define IMAGE_SYM_CLASS_MEMBER_OF_UNION     0x000B
  3475. #define IMAGE_SYM_CLASS_UNION_TAG           0x000C
  3476. #define IMAGE_SYM_CLASS_TYPE_DEFINITION     0x000D
  3477. #define IMAGE_SYM_CLASS_UNDEFINED_STATIC    0x000E
  3478. #define IMAGE_SYM_CLASS_ENUM_TAG            0x000F
  3479. #define IMAGE_SYM_CLASS_MEMBER_OF_ENUM      0x0010
  3480. #define IMAGE_SYM_CLASS_REGISTER_PARAM      0x0011
  3481. #define IMAGE_SYM_CLASS_BIT_FIELD           0x0012
  3482.  
  3483. #define IMAGE_SYM_CLASS_FAR_EXTERNAL        0x0044  //
  3484.  
  3485. #define IMAGE_SYM_CLASS_BLOCK               0x0064
  3486. #define IMAGE_SYM_CLASS_FUNCTION            0x0065
  3487. #define IMAGE_SYM_CLASS_END_OF_STRUCT       0x0066
  3488. #define IMAGE_SYM_CLASS_FILE                0x0067
  3489. // new
  3490. #define IMAGE_SYM_CLASS_SECTION             0x0068
  3491. #define IMAGE_SYM_CLASS_WEAK_EXTERNAL       0x0069
  3492.  
  3493. // type packing constants
  3494.  
  3495. #define N_BTMASK                            0x000F
  3496. #define N_TMASK                             0x0030
  3497. #define N_TMASK1                            0x00C0
  3498. #define N_TMASK2                            0x00F0
  3499. #define N_BTSHFT                            4
  3500. #define N_TSHIFT                            2
  3501.  
  3502. // MACROS
  3503.  
  3504. // Basic Type of  x
  3505. #define BTYPE(x) ((x) & N_BTMASK)
  3506.  
  3507. // Is x a pointer?
  3508. #ifndef ISPTR
  3509. #define ISPTR(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_POINTER << N_BTSHFT))
  3510. #endif
  3511.  
  3512. // Is x a function?
  3513. #ifndef ISFCN
  3514. #define ISFCN(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_FUNCTION << N_BTSHFT))
  3515. #endif
  3516.  
  3517. // Is x an array?
  3518.  
  3519. #ifndef ISARY
  3520. #define ISARY(x) (((x) & N_TMASK) == (IMAGE_SYM_DTYPE_ARRAY << N_BTSHFT))
  3521. #endif
  3522.  
  3523. // Is x a structure, union, or enumeration TAG?
  3524. #ifndef ISTAG
  3525. #define ISTAG(x) ((x)==IMAGE_SYM_CLASS_STRUCT_TAG || (x)==IMAGE_SYM_CLASS_UNION_TAG || (x)==IMAGE_SYM_CLASS_ENUM_TAG)
  3526. #endif
  3527.  
  3528. #ifndef INCREF
  3529. #define INCREF(x) ((((x)&~N_BTMASK)<<N_TSHIFT)|(IMAGE_SYM_DTYPE_POINTER<<N_BTSHFT)|((x)&N_BTMASK))
  3530. #endif
  3531. #ifndef DECREF
  3532. #define DECREF(x) ((((x)>>N_TSHIFT)&~N_BTMASK)|((x)&N_BTMASK))
  3533. #endif
  3534.  
  3535. //
  3536. // Auxiliary entry format.
  3537. //
  3538.  
  3539. typedef union _IMAGE_AUX_SYMBOL {
  3540.     struct {
  3541.         DWORD    TagIndex;                      // struct, union, or enum tag index
  3542.         union {
  3543.             struct {
  3544.                 WORD    Linenumber;             // declaration line number
  3545.                 WORD    Size;                   // size of struct, union, or enum
  3546.             } LnSz;
  3547.            DWORD    TotalSize;
  3548.         } Misc;
  3549.         union {
  3550.             struct {                            // if ISFCN, tag, or .bb
  3551.                 DWORD    PointerToLinenumber;
  3552.                 DWORD    PointerToNextFunction;
  3553.             } Function;
  3554.             struct {                            // if ISARY, up to 4 dimen.
  3555.                 WORD     Dimension[4];
  3556.             } Array;
  3557.         } FcnAry;
  3558.         WORD    TvIndex;                        // tv index
  3559.     } Sym;
  3560.     struct {
  3561.         BYTE    Name[IMAGE_SIZEOF_SYMBOL];
  3562.     } File;
  3563.     struct {
  3564.         DWORD   Length;                         // section length
  3565.         WORD    NumberOfRelocations;            // number of relocation entries
  3566.         WORD    NumberOfLinenumbers;            // number of line numbers
  3567.         DWORD   CheckSum;                       // checksum for communal
  3568.         SHORT   Number;                         // section number to associate with
  3569.         BYTE    Selection;                      // communal selection type
  3570.     } Section;
  3571. } IMAGE_AUX_SYMBOL;
  3572. typedef IMAGE_AUX_SYMBOL UNALIGNED *PIMAGE_AUX_SYMBOL;
  3573.  
  3574. #define IMAGE_SIZEOF_AUX_SYMBOL             18
  3575.  
  3576. //
  3577. // Communal selection types.
  3578. //
  3579.  
  3580. #define IMAGE_COMDAT_SELECT_NODUPLICATES    1
  3581. #define IMAGE_COMDAT_SELECT_ANY             2
  3582. #define IMAGE_COMDAT_SELECT_SAME_SIZE       3
  3583. #define IMAGE_COMDAT_SELECT_EXACT_MATCH     4
  3584. #define IMAGE_COMDAT_SELECT_ASSOCIATIVE     5
  3585. #define IMAGE_COMDAT_SELECT_LARGEST         6
  3586. #define IMAGE_COMDAT_SELECT_NEWEST          7
  3587.  
  3588. #define IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY  1
  3589. #define IMAGE_WEAK_EXTERN_SEARCH_LIBRARY    2
  3590. #define IMAGE_WEAK_EXTERN_SEARCH_ALIAS      3
  3591.  
  3592. //
  3593. // Relocation format.
  3594. //
  3595.  
  3596. typedef struct _IMAGE_RELOCATION {
  3597.     union {
  3598.         DWORD   VirtualAddress;
  3599.         DWORD   RelocCount;             // Set to the real count when IMAGE_SCN_LNK_NRELOC_OVFL is set
  3600.     } u;
  3601.     DWORD   SymbolTableIndex;
  3602.     WORD    Type;
  3603. } IMAGE_RELOCATION;
  3604. typedef IMAGE_RELOCATION UNALIGNED *PIMAGE_RELOCATION;
  3605.  
  3606. #define IMAGE_SIZEOF_RELOCATION         10
  3607.  
  3608. //
  3609. // I386 relocation types.
  3610. //
  3611.  
  3612. #define IMAGE_REL_I386_ABSOLUTE         0x0000  // Reference is absolute, no relocation is necessary
  3613. #define IMAGE_REL_I386_DIR16            0x0001  // Direct 16-bit reference to the symbols virtual address
  3614. #define IMAGE_REL_I386_REL16            0x0002  // PC-relative 16-bit reference to the symbols virtual address
  3615. #define IMAGE_REL_I386_DIR32            0x0006  // Direct 32-bit reference to the symbols virtual address
  3616. #define IMAGE_REL_I386_DIR32NB          0x0007  // Direct 32-bit reference to the symbols virtual address, base not included
  3617. #define IMAGE_REL_I386_SEG12            0x0009  // Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address
  3618. #define IMAGE_REL_I386_SECTION          0x000A
  3619. #define IMAGE_REL_I386_SECREL           0x000B
  3620. #define IMAGE_REL_I386_REL32            0x0014  // PC-relative 32-bit reference to the symbols virtual address
  3621.  
  3622. //
  3623. // MIPS relocation types.
  3624. //
  3625.  
  3626. #define IMAGE_REL_MIPS_ABSOLUTE         0x0000  // Reference is absolute, no relocation is necessary
  3627. #define IMAGE_REL_MIPS_REFHALF          0x0001
  3628. #define IMAGE_REL_MIPS_REFWORD          0x0002
  3629. #define IMAGE_REL_MIPS_JMPADDR          0x0003
  3630. #define IMAGE_REL_MIPS_REFHI            0x0004
  3631. #define IMAGE_REL_MIPS_REFLO            0x0005
  3632. #define IMAGE_REL_MIPS_GPREL            0x0006
  3633. #define IMAGE_REL_MIPS_LITERAL          0x0007
  3634. #define IMAGE_REL_MIPS_SECTION          0x000A
  3635. #define IMAGE_REL_MIPS_SECREL           0x000B
  3636. #define IMAGE_REL_MIPS_SECRELLO         0x000C  // Low 16-bit section relative referemce (used for >32k TLS)
  3637. #define IMAGE_REL_MIPS_SECRELHI         0x000D  // High 16-bit section relative reference (used for >32k TLS)
  3638. #define IMAGE_REL_MIPS_REFWORDNB        0x0022
  3639. #define IMAGE_REL_MIPS_PAIR             0x0025
  3640.  
  3641. //
  3642. // Alpha Relocation types.
  3643. //
  3644.  
  3645. #define IMAGE_REL_ALPHA_ABSOLUTE        0x0000
  3646. #define IMAGE_REL_ALPHA_REFLONG         0x0001
  3647. #define IMAGE_REL_ALPHA_REFQUAD         0x0002
  3648. #define IMAGE_REL_ALPHA_GPREL32         0x0003
  3649. #define IMAGE_REL_ALPHA_LITERAL         0x0004
  3650. #define IMAGE_REL_ALPHA_LITUSE          0x0005
  3651. #define IMAGE_REL_ALPHA_GPDISP          0x0006
  3652. #define IMAGE_REL_ALPHA_BRADDR          0x0007
  3653. #define IMAGE_REL_ALPHA_HINT            0x0008
  3654. #define IMAGE_REL_ALPHA_INLINE_REFLONG  0x0009
  3655. #define IMAGE_REL_ALPHA_REFHI           0x000A
  3656. #define IMAGE_REL_ALPHA_REFLO           0x000B
  3657. #define IMAGE_REL_ALPHA_PAIR            0x000C
  3658. #define IMAGE_REL_ALPHA_MATCH           0x000D
  3659. #define IMAGE_REL_ALPHA_SECTION         0x000E
  3660. #define IMAGE_REL_ALPHA_SECREL          0x000F
  3661. #define IMAGE_REL_ALPHA_REFLONGNB       0x0010
  3662. #define IMAGE_REL_ALPHA_SECRELLO        0x0011  // Low 16-bit section relative reference
  3663. #define IMAGE_REL_ALPHA_SECRELHI        0x0012  // High 16-bit section relative reference
  3664.  
  3665. //
  3666. // IBM PowerPC relocation types.
  3667. //
  3668.  
  3669. #define IMAGE_REL_PPC_ABSOLUTE          0x0000  // NOP
  3670. #define IMAGE_REL_PPC_ADDR64            0x0001  // 64-bit address
  3671. #define IMAGE_REL_PPC_ADDR32            0x0002  // 32-bit address
  3672. #define IMAGE_REL_PPC_ADDR24            0x0003  // 26-bit address, shifted left 2 (branch absolute)
  3673. #define IMAGE_REL_PPC_ADDR16            0x0004  // 16-bit address
  3674. #define IMAGE_REL_PPC_ADDR14            0x0005  // 16-bit address, shifted left 2 (load doubleword)
  3675. #define IMAGE_REL_PPC_REL24             0x0006  // 26-bit PC-relative offset, shifted left 2 (branch relative)
  3676. #define IMAGE_REL_PPC_REL14             0x0007  // 16-bit PC-relative offset, shifted left 2 (br cond relative)
  3677. #define IMAGE_REL_PPC_TOCREL16          0x0008  // 16-bit offset from TOC base
  3678. #define IMAGE_REL_PPC_TOCREL14          0x0009  // 16-bit offset from TOC base, shifted left 2 (load doubleword)
  3679.  
  3680. #define IMAGE_REL_PPC_ADDR32NB          0x000A  // 32-bit addr w/o image base
  3681. #define IMAGE_REL_PPC_SECREL            0x000B  // va of containing section (as in an image sectionhdr)
  3682. #define IMAGE_REL_PPC_SECTION           0x000C  // sectionheader number
  3683. #define IMAGE_REL_PPC_IFGLUE            0x000D  // substitute TOC restore instruction iff symbol is glue code
  3684. #define IMAGE_REL_PPC_IMGLUE            0x000E  // symbol is glue code; virtual address is TOC restore instruction
  3685. #define IMAGE_REL_PPC_SECREL16          0x000F  // va of containing section (limited to 16 bits)
  3686. #define IMAGE_REL_PPC_REFHI             0x0010
  3687. #define IMAGE_REL_PPC_REFLO             0x0011
  3688. #define IMAGE_REL_PPC_PAIR              0x0012
  3689.  
  3690. #define IMAGE_REL_PPC_TYPEMASK          0x00FF  // mask to isolate above values in IMAGE_RELOCATION.Type
  3691.  
  3692. // Flag bits in IMAGE_RELOCATION.TYPE
  3693.  
  3694. #define IMAGE_REL_PPC_NEG               0x0100  // subtract reloc value rather than adding it
  3695. #define IMAGE_REL_PPC_BRTAKEN           0x0200  // fix branch prediction bit to predict branch taken
  3696. #define IMAGE_REL_PPC_BRNTAKEN          0x0400  // fix branch prediction bit to predict branch not taken
  3697. #define IMAGE_REL_PPC_TOCDEFN           0x0800  // toc slot defined in file (or, data in toc)
  3698.  
  3699. //
  3700. // Based relocation format.
  3701. //
  3702.  
  3703. typedef struct _IMAGE_BASE_RELOCATION {
  3704.     DWORD   VirtualAddress;
  3705.     DWORD   SizeOfBlock;
  3706. //  WORD    TypeOffset[1];
  3707. } IMAGE_BASE_RELOCATION, *PIMAGE_BASE_RELOCATION;
  3708.  
  3709. #define IMAGE_SIZEOF_BASE_RELOCATION         8
  3710.  
  3711. //
  3712. // Based relocation types.
  3713. //
  3714.  
  3715. #define IMAGE_REL_BASED_ABSOLUTE              0
  3716. #define IMAGE_REL_BASED_HIGH                  1
  3717. #define IMAGE_REL_BASED_LOW                   2
  3718. #define IMAGE_REL_BASED_HIGHLOW               3
  3719. #define IMAGE_REL_BASED_HIGHADJ               4
  3720. #define IMAGE_REL_BASED_MIPS_JMPADDR          5
  3721.  
  3722. //
  3723. // Line number format.
  3724. //
  3725.  
  3726. typedef struct _IMAGE_LINENUMBER {
  3727.     union {
  3728.         DWORD   SymbolTableIndex;               // Symbol table index of function name if Linenumber is 0.
  3729.         DWORD   VirtualAddress;                 // Virtual address of line number.
  3730.     } Type;
  3731.     WORD    Linenumber;                         // Line number.
  3732. } IMAGE_LINENUMBER;
  3733. typedef IMAGE_LINENUMBER UNALIGNED *PIMAGE_LINENUMBER;
  3734.  
  3735. #define IMAGE_SIZEOF_LINENUMBER              6
  3736.  
  3737. //
  3738. // Archive format.
  3739. //
  3740.  
  3741. #define IMAGE_ARCHIVE_START_SIZE             8
  3742. #define IMAGE_ARCHIVE_START                  "!<arch>\n"
  3743. #define IMAGE_ARCHIVE_END                    "`\n"
  3744. #define IMAGE_ARCHIVE_PAD                    "\n"
  3745. #define IMAGE_ARCHIVE_LINKER_MEMBER          "/               "
  3746. #define IMAGE_ARCHIVE_LONGNAMES_MEMBER       "//              "
  3747.  
  3748. typedef struct _IMAGE_ARCHIVE_MEMBER_HEADER {
  3749.     BYTE     Name[16];                          // File member name - `/' terminated.
  3750.     BYTE     Date[12];                          // File member date - decimal.
  3751.     BYTE     UserID[6];                         // File member user id - decimal.
  3752.     BYTE     GroupID[6];                        // File member group id - decimal.
  3753.     BYTE     Mode[8];                           // File member mode - octal.
  3754.     BYTE     Size[10];                          // File member size - decimal.
  3755.     BYTE     EndHeader[2];                      // String to end header.
  3756. } IMAGE_ARCHIVE_MEMBER_HEADER, *PIMAGE_ARCHIVE_MEMBER_HEADER;
  3757.  
  3758. #define IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR      60
  3759.  
  3760. //
  3761. // DLL support.
  3762. //
  3763.  
  3764. //
  3765. // Export Format
  3766. //
  3767.  
  3768. typedef struct _IMAGE_EXPORT_DIRECTORY {
  3769.     DWORD   Characteristics;
  3770.     DWORD   TimeDateStamp;
  3771.     WORD    MajorVersion;
  3772.     WORD    MinorVersion;
  3773.     DWORD   Name;
  3774.     DWORD   Base;
  3775.     DWORD   NumberOfFunctions;
  3776.     DWORD   NumberOfNames;
  3777.     PDWORD  *AddressOfFunctions;
  3778.     PDWORD  *AddressOfNames;
  3779.     PWORD   *AddressOfNameOrdinals;
  3780. } IMAGE_EXPORT_DIRECTORY, *PIMAGE_EXPORT_DIRECTORY;
  3781.  
  3782. //
  3783. // Import Format
  3784. //
  3785.  
  3786. typedef struct _IMAGE_IMPORT_BY_NAME {
  3787.     WORD    Hint;
  3788.     BYTE    Name[1];
  3789. } IMAGE_IMPORT_BY_NAME, *PIMAGE_IMPORT_BY_NAME;
  3790.  
  3791. typedef struct _IMAGE_THUNK_DATA {
  3792.     union {
  3793.         PBYTE  ForwarderString;
  3794.         PDWORD Function;
  3795.         DWORD Ordinal;
  3796.         PIMAGE_IMPORT_BY_NAME AddressOfData;
  3797.     } u1;
  3798. } IMAGE_THUNK_DATA, *PIMAGE_THUNK_DATA;
  3799.  
  3800. #define IMAGE_ORDINAL_FLAG 0x80000000
  3801. #define IMAGE_SNAP_BY_ORDINAL(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG) != 0)
  3802. #define IMAGE_ORDINAL(Ordinal) (Ordinal & 0xffff)
  3803.  
  3804. typedef struct _IMAGE_IMPORT_DESCRIPTOR {
  3805.     union {
  3806.         DWORD   Characteristics;                // 0 for terminating null import descriptor
  3807.         PIMAGE_THUNK_DATA OriginalFirstThunk;   // RVA to original unbound IAT
  3808.     } u;
  3809.     DWORD   TimeDateStamp;                  // 0 if not bound,
  3810.                                             // -1 if bound, and real date\time stamp
  3811.                                             //     in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)
  3812.                                             // O.W. date/time stamp of DLL bound to (Old BIND)
  3813.  
  3814.     DWORD   ForwarderChain;                 // -1 if no forwarders
  3815.     DWORD   Name;
  3816.     PIMAGE_THUNK_DATA FirstThunk;           // RVA to IAT (if bound this IAT has actual addresses)
  3817. } IMAGE_IMPORT_DESCRIPTOR, *PIMAGE_IMPORT_DESCRIPTOR;
  3818.  
  3819. //
  3820. // New format import descriptors pointed to by DataDirectory[ IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT ]
  3821. //
  3822.  
  3823. typedef struct _IMAGE_BOUND_IMPORT_DESCRIPTOR {
  3824.     DWORD   TimeDateStamp;
  3825.     WORD    OffsetModuleName;
  3826.     WORD    NumberOfModuleForwarderRefs;
  3827. // Array of zero or more IMAGE_BOUND_FORWARDER_REF follows
  3828. } IMAGE_BOUND_IMPORT_DESCRIPTOR, *PIMAGE_BOUND_IMPORT_DESCRIPTOR;
  3829.  
  3830. typedef struct _IMAGE_BOUND_FORWARDER_REF {
  3831.     DWORD   TimeDateStamp;
  3832.     WORD    OffsetModuleName;
  3833.     WORD    Reserved;
  3834. } IMAGE_BOUND_FORWARDER_REF, *PIMAGE_BOUND_FORWARDER_REF;
  3835.  
  3836.  
  3837. //
  3838. // Thread Local Storage
  3839. //
  3840.  
  3841. typedef VOID
  3842. #ifdef __GNUC__
  3843. NTAPI (*PIMAGE_TLS_CALLBACK) (
  3844. #else
  3845. (NTAPI *PIMAGE_TLS_CALLBACK) (
  3846. #endif /* __GNUC__ */
  3847.     PVOID DllHandle,
  3848.     DWORD Reason,
  3849.     PVOID Reserved
  3850.     );
  3851.  
  3852. typedef struct _IMAGE_TLS_DIRECTORY {
  3853.     DWORD   StartAddressOfRawData;
  3854.     DWORD   EndAddressOfRawData;
  3855.     PDWORD  AddressOfIndex;
  3856.     PIMAGE_TLS_CALLBACK *AddressOfCallBacks;
  3857.     DWORD   SizeOfZeroFill;
  3858.     DWORD   Characteristics;
  3859. } IMAGE_TLS_DIRECTORY, *PIMAGE_TLS_DIRECTORY;
  3860.  
  3861.  
  3862. //
  3863. // Resource Format.
  3864. //
  3865.  
  3866. //
  3867. // Resource directory consists of two counts, following by a variable length
  3868. // array of directory entries.  The first count is the number of entries at
  3869. // beginning of the array that have actual names associated with each entry.
  3870. // The entries are in ascending order, case insensitive strings.  The second
  3871. // count is the number of entries that immediately follow the named entries.
  3872. // This second count identifies the number of entries that have 16-bit integer
  3873. // Ids as their name.  These entries are also sorted in ascending order.
  3874. //
  3875. // This structure allows fast lookup by either name or number, but for any
  3876. // given resource entry only one form of lookup is supported, not both.
  3877. // This is consistant with the syntax of the .RC file and the .RES file.
  3878. //
  3879.  
  3880. typedef struct _IMAGE_RESOURCE_DIRECTORY {
  3881.     DWORD   Characteristics;
  3882.     DWORD   TimeDateStamp;
  3883.     WORD    MajorVersion;
  3884.     WORD    MinorVersion;
  3885.     WORD    NumberOfNamedEntries;
  3886.     WORD    NumberOfIdEntries;
  3887. //  IMAGE_RESOURCE_DIRECTORY_ENTRY DirectoryEntries[];
  3888. } IMAGE_RESOURCE_DIRECTORY, *PIMAGE_RESOURCE_DIRECTORY;
  3889.  
  3890. #define IMAGE_RESOURCE_NAME_IS_STRING        0x80000000
  3891. #define IMAGE_RESOURCE_DATA_IS_DIRECTORY     0x80000000
  3892.  
  3893. //
  3894. // Each directory contains the 32-bit Name of the entry and an offset,
  3895. // relative to the beginning of the resource directory of the data associated
  3896. // with this directory entry.  If the name of the entry is an actual text
  3897. // string instead of an integer Id, then the high order bit of the name field
  3898. // is set to one and the low order 31-bits are an offset, relative to the
  3899. // beginning of the resource directory of the string, which is of type
  3900. // IMAGE_RESOURCE_DIRECTORY_STRING.  Otherwise the high bit is clear and the
  3901. // low-order 16-bits are the integer Id that identify this resource directory
  3902. // entry. If the directory entry is yet another resource directory (i.e. a
  3903. // subdirectory), then the high order bit of the offset field will be
  3904. // set to indicate this.  Otherwise the high bit is clear and the offset
  3905. // field points to a resource data entry.
  3906. //
  3907.  
  3908. typedef struct _IMAGE_RESOURCE_DIRECTORY_ENTRY {
  3909.     union {
  3910.         struct {
  3911.             DWORD NameOffset:31;
  3912.             DWORD NameIsString:1;
  3913.         } u;
  3914.         DWORD   Name;
  3915.         WORD    Id;
  3916.     } u1;
  3917.     union {
  3918.         DWORD   OffsetToData;
  3919.         struct {
  3920.             DWORD   OffsetToDirectory:31;
  3921.             DWORD   DataIsDirectory:1;
  3922.         } u;
  3923.     } u2;
  3924. } IMAGE_RESOURCE_DIRECTORY_ENTRY, *PIMAGE_RESOURCE_DIRECTORY_ENTRY;
  3925.  
  3926. //
  3927. // For resource directory entries that have actual string names, the Name
  3928. // field of the directory entry points to an object of the following type.
  3929. // All of these string objects are stored together after the last resource
  3930. // directory entry and before the first resource data object.  This minimizes
  3931. // the impact of these variable length objects on the alignment of the fixed
  3932. // size directory entry objects.
  3933. //
  3934.  
  3935. typedef struct _IMAGE_RESOURCE_DIRECTORY_STRING {
  3936.     WORD    Length;
  3937.     CHAR    NameString[ 1 ];
  3938. } IMAGE_RESOURCE_DIRECTORY_STRING, *PIMAGE_RESOURCE_DIRECTORY_STRING;
  3939.  
  3940.  
  3941. typedef struct _IMAGE_RESOURCE_DIR_STRING_U {
  3942.     WORD    Length;
  3943.     WCHAR   NameString[ 1 ];
  3944. } IMAGE_RESOURCE_DIR_STRING_U, *PIMAGE_RESOURCE_DIR_STRING_U;
  3945.  
  3946.  
  3947. //
  3948. // Each resource data entry describes a leaf node in the resource directory
  3949. // tree.  It contains an offset, relative to the beginning of the resource
  3950. // directory of the data for the resource, a size field that gives the number
  3951. // of bytes of data at that offset, a CodePage that should be used when
  3952. // decoding code point values within the resource data.  Typically for new
  3953. // applications the code page would be the unicode code page.
  3954. //
  3955.  
  3956. typedef struct _IMAGE_RESOURCE_DATA_ENTRY {
  3957.     DWORD   OffsetToData;
  3958.     DWORD   Size;
  3959.     DWORD   CodePage;
  3960.     DWORD   Reserved;
  3961. } IMAGE_RESOURCE_DATA_ENTRY, *PIMAGE_RESOURCE_DATA_ENTRY;
  3962.  
  3963. //
  3964. // Load Configuration Directory Entry
  3965. //
  3966.  
  3967. typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY {
  3968.     DWORD   Characteristics;
  3969.     DWORD   TimeDateStamp;
  3970.     WORD    MajorVersion;
  3971.     WORD    MinorVersion;
  3972.     DWORD   GlobalFlagsClear;
  3973.     DWORD   GlobalFlagsSet;
  3974.     DWORD   CriticalSectionDefaultTimeout;
  3975.     DWORD   DeCommitFreeBlockThreshold;
  3976.     DWORD   DeCommitTotalFreeThreshold;
  3977.     PVOID   LockPrefixTable;
  3978.     DWORD   MaximumAllocationSize;
  3979.     DWORD   VirtualMemoryThreshold;
  3980.     DWORD   ProcessHeapFlags;
  3981.     DWORD   Reserved[ 4 ];
  3982. } IMAGE_LOAD_CONFIG_DIRECTORY, *PIMAGE_LOAD_CONFIG_DIRECTORY;
  3983.  
  3984.  
  3985. //
  3986. // Function table entry format for MIPS/ALPHA images.  Function table is
  3987. // pointed to by the IMAGE_DIRECTORY_ENTRY_EXCEPTION directory entry.
  3988. // This definition duplicates ones in ntmips.h and ntalpha.h for use
  3989. // by portable image file mungers.
  3990. //
  3991.  
  3992. typedef struct _IMAGE_RUNTIME_FUNCTION_ENTRY {
  3993.     DWORD BeginAddress;
  3994.     DWORD EndAddress;
  3995.     PVOID ExceptionHandler;
  3996.     PVOID HandlerData;
  3997.     DWORD PrologEndAddress;
  3998. } IMAGE_RUNTIME_FUNCTION_ENTRY, *PIMAGE_RUNTIME_FUNCTION_ENTRY;
  3999.  
  4000. //
  4001. // Debug Format
  4002. //
  4003.  
  4004. typedef struct _IMAGE_DEBUG_DIRECTORY {
  4005.     DWORD   Characteristics;
  4006.     DWORD   TimeDateStamp;
  4007.     WORD    MajorVersion;
  4008.     WORD    MinorVersion;
  4009.     DWORD   Type;
  4010.     DWORD   SizeOfData;
  4011.     DWORD   AddressOfRawData;
  4012.     DWORD   PointerToRawData;
  4013. } IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;
  4014.  
  4015. #define IMAGE_DEBUG_TYPE_UNKNOWN          0
  4016. #define IMAGE_DEBUG_TYPE_COFF             1
  4017. #define IMAGE_DEBUG_TYPE_CODEVIEW         2
  4018. #define IMAGE_DEBUG_TYPE_FPO              3
  4019. #define IMAGE_DEBUG_TYPE_MISC             4
  4020. #define IMAGE_DEBUG_TYPE_EXCEPTION        5
  4021. #define IMAGE_DEBUG_TYPE_FIXUP            6
  4022. #define IMAGE_DEBUG_TYPE_OMAP_TO_SRC      7
  4023. #define IMAGE_DEBUG_TYPE_OMAP_FROM_SRC    8
  4024.  
  4025. typedef struct _IMAGE_COFF_SYMBOLS_HEADER {
  4026.     DWORD   NumberOfSymbols;
  4027.     DWORD   LvaToFirstSymbol;
  4028.     DWORD   NumberOfLinenumbers;
  4029.     DWORD   LvaToFirstLinenumber;
  4030.     DWORD   RvaToFirstByteOfCode;
  4031.     DWORD   RvaToLastByteOfCode;
  4032.     DWORD   RvaToFirstByteOfData;
  4033.     DWORD   RvaToLastByteOfData;
  4034. } IMAGE_COFF_SYMBOLS_HEADER, *PIMAGE_COFF_SYMBOLS_HEADER;
  4035.  
  4036. #define FRAME_FPO       0
  4037. #define FRAME_TRAP      1
  4038. #define FRAME_TSS       2
  4039. #define FRAME_NONFPO    3
  4040.  
  4041. typedef struct _FPO_DATA {
  4042.     DWORD       ulOffStart;             // offset 1st byte of function code
  4043.     DWORD       cbProcSize;             // # bytes in function
  4044.     DWORD       cdwLocals;              // # bytes in locals/4
  4045.     WORD        cdwParams;              // # bytes in params/4
  4046.     WORD        cbProlog : 8;           // # bytes in prolog
  4047.     WORD        cbRegs   : 3;           // # regs saved
  4048.     WORD        fHasSEH  : 1;           // TRUE if SEH in func
  4049.     WORD        fUseBP   : 1;           // TRUE if EBP has been allocated
  4050.     WORD        reserved : 1;           // reserved for future use
  4051.     WORD        cbFrame  : 2;           // frame type
  4052. } FPO_DATA, *PFPO_DATA;
  4053. #define SIZEOF_RFPO_DATA 16
  4054.  
  4055.  
  4056. #define IMAGE_DEBUG_MISC_EXENAME    1
  4057.  
  4058. typedef struct _IMAGE_DEBUG_MISC {
  4059.     DWORD       DataType;               // type of misc data, see defines
  4060.     DWORD       Length;                 // total length of record, rounded to four
  4061.                                         // byte multiple.
  4062.     BOOLEAN     Unicode;                // TRUE if data is unicode string
  4063.     BYTE        Reserved[ 3 ];
  4064.     BYTE        Data[ 1 ];              // Actual data
  4065. } IMAGE_DEBUG_MISC, *PIMAGE_DEBUG_MISC;
  4066.  
  4067.  
  4068. //
  4069. // Function table extracted from MIPS/ALPHA images.  Does not contain
  4070. // information needed only for runtime support.  Just those fields for
  4071. // each entry needed by a debugger.
  4072. //
  4073.  
  4074. typedef struct _IMAGE_FUNCTION_ENTRY {
  4075.     DWORD   StartingAddress;
  4076.     DWORD   EndingAddress;
  4077.     DWORD   EndOfPrologue;
  4078. } IMAGE_FUNCTION_ENTRY, *PIMAGE_FUNCTION_ENTRY;
  4079.  
  4080. //
  4081. // Debugging information can be stripped from an image file and placed
  4082. // in a separate .DBG file, whose file name part is the same as the
  4083. // image file name part (e.g. symbols for CMD.EXE could be stripped
  4084. // and placed in CMD.DBG).  This is indicated by the IMAGE_FILE_DEBUG_STRIPPED
  4085. // flag in the Characteristics field of the file header.  The beginning of
  4086. // the .DBG file contains the following structure which captures certain
  4087. // information from the image file.  This allows a debug to proceed even if
  4088. // the original image file is not accessable.  This header is followed by
  4089. // zero of more IMAGE_SECTION_HEADER structures, followed by zero or more
  4090. // IMAGE_DEBUG_DIRECTORY structures.  The latter structures and those in
  4091. // the image file contain file offsets relative to the beginning of the
  4092. // .DBG file.
  4093. //
  4094. // If symbols have been stripped from an image, the IMAGE_DEBUG_MISC structure
  4095. // is left in the image file, but not mapped.  This allows a debugger to
  4096. // compute the name of the .DBG file, from the name of the image in the
  4097. // IMAGE_DEBUG_MISC structure.
  4098. //
  4099.  
  4100. typedef struct _IMAGE_SEPARATE_DEBUG_HEADER {
  4101.     WORD        Signature;
  4102.     WORD        Flags;
  4103.     WORD        Machine;
  4104.     WORD        Characteristics;
  4105.     DWORD       TimeDateStamp;
  4106.     DWORD       CheckSum;
  4107.     DWORD       ImageBase;
  4108.     DWORD       SizeOfImage;
  4109.     DWORD       NumberOfSections;
  4110.     DWORD       ExportedNamesSize;
  4111.     DWORD       DebugDirectorySize;
  4112.     DWORD       Reserved[ 3 ];          // Note: reserved[0] is actually the section alignment
  4113. } IMAGE_SEPARATE_DEBUG_HEADER, *PIMAGE_SEPARATE_DEBUG_HEADER;
  4114.  
  4115. #define IMAGE_SEPARATE_DEBUG_SIGNATURE 0x4944
  4116.  
  4117. #include "poppack.h"
  4118.  
  4119. #endif // NOIMAGE
  4120. //
  4121. // End Image Format
  4122. //
  4123.  
  4124. //
  4125. // for move macros
  4126. //
  4127. #ifndef _INC_STRING
  4128. #include <string.h>
  4129. #endif /* _INC_STRING */
  4130. #define HEAP_NO_SERIALIZE               0x00000001      
  4131. #define HEAP_GROWABLE                   0x00000002      
  4132. #define HEAP_GENERATE_EXCEPTIONS        0x00000004      
  4133. #define HEAP_ZERO_MEMORY                0x00000008      
  4134. #define HEAP_REALLOC_IN_PLACE_ONLY      0x00000010      
  4135. #define HEAP_TAIL_CHECKING_ENABLED      0x00000020      
  4136. #define HEAP_FREE_CHECKING_ENABLED      0x00000040      
  4137. #define HEAP_DISABLE_COALESCE_ON_FREE   0x00000080      
  4138. #define HEAP_CREATE_ALIGN_16            0x00010000      
  4139. #define HEAP_CREATE_ENABLE_TRACING      0x00020000      
  4140. #define HEAP_MAXIMUM_TAG                0x0FFF              
  4141. #define HEAP_PSEUDO_TAG_FLAG            0x8000              
  4142. #define HEAP_TAG_SHIFT                  16                  
  4143. #define HEAP_MAKE_TAG_FLAGS( b, o ) ((DWORD)((b) + ((o) << 16)))  
  4144.  
  4145. #define IS_TEXT_UNICODE_ASCII16               0x0001
  4146. #define IS_TEXT_UNICODE_REVERSE_ASCII16       0x0010
  4147.  
  4148. #define IS_TEXT_UNICODE_STATISTICS            0x0002
  4149. #define IS_TEXT_UNICODE_REVERSE_STATISTICS    0x0020
  4150.  
  4151. #define IS_TEXT_UNICODE_CONTROLS              0x0004
  4152. #define IS_TEXT_UNICODE_REVERSE_CONTROLS      0x0040
  4153.  
  4154. #define IS_TEXT_UNICODE_SIGNATURE             0x0008
  4155. #define IS_TEXT_UNICODE_REVERSE_SIGNATURE     0x0080
  4156.  
  4157. #define IS_TEXT_UNICODE_ILLEGAL_CHARS         0x0100
  4158. #define IS_TEXT_UNICODE_ODD_LENGTH            0x0200
  4159. #define IS_TEXT_UNICODE_DBCS_LEADBYTE         0x0400
  4160. #define IS_TEXT_UNICODE_NULL_BYTES            0x1000
  4161.  
  4162. #define IS_TEXT_UNICODE_UNICODE_MASK          0x000F
  4163. #define IS_TEXT_UNICODE_REVERSE_MASK          0x00F0
  4164. #define IS_TEXT_UNICODE_NOT_UNICODE_MASK      0x0F00
  4165. #define IS_TEXT_UNICODE_NOT_ASCII_MASK        0xF000
  4166.  
  4167. #define COMPRESSION_FORMAT_NONE          (0x0000)   
  4168. #define COMPRESSION_FORMAT_DEFAULT       (0x0001)   
  4169. #define COMPRESSION_FORMAT_LZNT1         (0x0002)   
  4170. #define COMPRESSION_ENGINE_STANDARD      (0x0000)   
  4171. #define COMPRESSION_ENGINE_MAXIMUM       (0x0100)   
  4172. #if defined(_M_IX86) || defined(_M_MRX000) || defined(_M_ALPHA)
  4173. #define RtlMoveMemory(Destination,Source,Length) memmove((Destination),(Source),(Length))
  4174. #define RtlCopyMemory(Destination,Source,Length) memcpy((Destination),(Source),(Length))
  4175. #define RtlFillMemory(Destination,Length,Fill) memset((Destination),(Fill),(Length))
  4176. #define RtlZeroMemory(Destination,Length) memset((Destination),0,(Length))
  4177. #else
  4178.  
  4179. NTSYSAPI
  4180. VOID
  4181. NTAPI
  4182. RtlCopyMemory (
  4183.    VOID UNALIGNED *Destination,
  4184.    CONST VOID UNALIGNED *Source,
  4185.    DWORD Length
  4186.    );
  4187.  
  4188. NTSYSAPI
  4189. VOID
  4190. NTAPI
  4191. RtlMoveMemory (
  4192.    VOID UNALIGNED *Destination,
  4193.    CONST VOID UNALIGNED *Source,
  4194.    DWORD Length
  4195.    );
  4196.  
  4197. NTSYSAPI
  4198. VOID
  4199. NTAPI
  4200. RtlFillMemory (
  4201.    VOID UNALIGNED *Destination,
  4202.    DWORD Length,
  4203.    BYTE  Fill
  4204.    );
  4205.  
  4206. NTSYSAPI
  4207. VOID
  4208. NTAPI
  4209. RtlZeroMemory (
  4210.    VOID UNALIGNED *Destination,
  4211.    DWORD Length
  4212.    );
  4213. #endif
  4214.  
  4215. typedef struct _MESSAGE_RESOURCE_ENTRY {
  4216.     WORD   Length;
  4217.     WORD   Flags;
  4218.     BYTE  Text[ 1 ];
  4219. } MESSAGE_RESOURCE_ENTRY, *PMESSAGE_RESOURCE_ENTRY;
  4220.  
  4221. #define MESSAGE_RESOURCE_UNICODE 0x0001
  4222.  
  4223. typedef struct _MESSAGE_RESOURCE_BLOCK {
  4224.     DWORD LowId;
  4225.     DWORD HighId;
  4226.     DWORD OffsetToEntries;
  4227. } MESSAGE_RESOURCE_BLOCK, *PMESSAGE_RESOURCE_BLOCK;
  4228.  
  4229. typedef struct _MESSAGE_RESOURCE_DATA {
  4230.     DWORD NumberOfBlocks;
  4231.     MESSAGE_RESOURCE_BLOCK Blocks[ 1 ];
  4232. } MESSAGE_RESOURCE_DATA, *PMESSAGE_RESOURCE_DATA;
  4233.  
  4234.  
  4235. typedef struct _RTL_CRITICAL_SECTION_DEBUG {
  4236.     WORD   Type;
  4237.     WORD   CreatorBackTraceIndex;
  4238.     struct _RTL_CRITICAL_SECTION *CriticalSection;
  4239.     LIST_ENTRY ProcessLocksList;
  4240.     DWORD EntryCount;
  4241.     DWORD ContentionCount;
  4242.     DWORD Spare[ 2 ];
  4243. } RTL_CRITICAL_SECTION_DEBUG, *PRTL_CRITICAL_SECTION_DEBUG;
  4244.  
  4245. #define RTL_CRITSECT_TYPE 0
  4246. #define RTL_RESOURCE_TYPE 1
  4247.  
  4248. typedef struct _RTL_CRITICAL_SECTION {
  4249.     PRTL_CRITICAL_SECTION_DEBUG DebugInfo;
  4250.  
  4251.     //
  4252.     //  The following three fields control entering and exiting the critical
  4253.     //  section for the resource
  4254.     //
  4255.  
  4256.     LONG LockCount;
  4257.     LONG RecursionCount;
  4258.     HANDLE OwningThread;        // from the thread's ClientId->UniqueThread
  4259.     HANDLE LockSemaphore;
  4260.     DWORD Reserved;
  4261. } RTL_CRITICAL_SECTION, *PRTL_CRITICAL_SECTION;
  4262. #define DLL_PROCESS_ATTACH 1    
  4263. #define DLL_THREAD_ATTACH  2    
  4264. #define DLL_THREAD_DETACH  3    
  4265. #define DLL_PROCESS_DETACH 0    
  4266.  
  4267. //
  4268. // Defines for the READ flags for Eventlogging
  4269. //
  4270. #define EVENTLOG_SEQUENTIAL_READ        0X0001
  4271. #define EVENTLOG_SEEK_READ              0X0002
  4272. #define EVENTLOG_FORWARDS_READ          0X0004
  4273. #define EVENTLOG_BACKWARDS_READ         0X0008
  4274.  
  4275. //
  4276. // The types of events that can be logged.
  4277. //
  4278. #define EVENTLOG_SUCCESS                0X0000
  4279. #define EVENTLOG_ERROR_TYPE             0x0001
  4280. #define EVENTLOG_WARNING_TYPE           0x0002
  4281. #define EVENTLOG_INFORMATION_TYPE       0x0004
  4282. #define EVENTLOG_AUDIT_SUCCESS          0x0008
  4283. #define EVENTLOG_AUDIT_FAILURE          0x0010
  4284.  
  4285. //
  4286. // Defines for the WRITE flags used by Auditing for paired events
  4287. // These are not implemented in Product 1
  4288. //
  4289.  
  4290. #define EVENTLOG_START_PAIRED_EVENT    0x0001
  4291. #define EVENTLOG_END_PAIRED_EVENT      0x0002
  4292. #define EVENTLOG_END_ALL_PAIRED_EVENTS 0x0004
  4293. #define EVENTLOG_PAIRED_EVENT_ACTIVE   0x0008
  4294. #define EVENTLOG_PAIRED_EVENT_INACTIVE 0x0010
  4295.  
  4296. //
  4297. // Structure that defines the header of the Eventlog record. This is the
  4298. // fixed-sized portion before all the variable-length strings, binary
  4299. // data and pad bytes.
  4300. //
  4301. // TimeGenerated is the time it was generated at the client.
  4302. // TimeWritten is the time it was put into the log at the server end.
  4303. //
  4304.  
  4305. typedef struct _EVENTLOGRECORD {
  4306.     DWORD  Length;        // Length of full record
  4307.     DWORD  Reserved;      // Used by the service
  4308.     DWORD  RecordNumber;  // Absolute record number
  4309.     DWORD  TimeGenerated; // Seconds since 1-1-1970
  4310.     DWORD  TimeWritten;   // Seconds since 1-1-1970
  4311.     DWORD  EventID;
  4312.     WORD   EventType;
  4313.     WORD   NumStrings;
  4314.     WORD   EventCategory;
  4315.     WORD   ReservedFlags; // For use with paired events (auditing)
  4316.     DWORD  ClosingRecordNumber; // For use with paired events (auditing)
  4317.     DWORD  StringOffset;  // Offset from beginning of record
  4318.     DWORD  UserSidLength;
  4319.     DWORD  UserSidOffset;
  4320.     DWORD  DataLength;
  4321.     DWORD  DataOffset;    // Offset from beginning of record
  4322.     //
  4323.     // Then follow:
  4324.     //
  4325.     // WCHAR SourceName[]
  4326.     // WCHAR Computername[]
  4327.     // SID   UserSid
  4328.     // WCHAR Strings[]
  4329.     // BYTE  Data[]
  4330.     // CHAR  Pad[]
  4331.     // DWORD Length;
  4332.     //
  4333. } EVENTLOGRECORD, *PEVENTLOGRECORD;
  4334.  
  4335. #define DBG_CONTINUE                    ((DWORD   )0x00010002L) 
  4336. #define DBG_TERMINATE_THREAD            ((DWORD   )0x40010003L) 
  4337. #define DBG_TERMINATE_PROCESS           ((DWORD   )0x40010004L) 
  4338. #define DBG_CONTROL_C                   ((DWORD   )0x40010005L) 
  4339. #define DBG_CONTROL_BREAK               ((DWORD   )0x40010008L) 
  4340. #define DBG_EXCEPTION_NOT_HANDLED       ((DWORD   )0x80010001L) 
  4341. //
  4342.  
  4343. // begin_ntddk begin_nthal
  4344. //
  4345. // Registry Specific Access Rights.
  4346. //
  4347.  
  4348. #define KEY_QUERY_VALUE         (0x0001)
  4349. #define KEY_SET_VALUE           (0x0002)
  4350. #define KEY_CREATE_SUB_KEY      (0x0004)
  4351. #define KEY_ENUMERATE_SUB_KEYS  (0x0008)
  4352. #define KEY_NOTIFY              (0x0010)
  4353. #define KEY_CREATE_LINK         (0x0020)
  4354.  
  4355. #define KEY_READ                ((STANDARD_RIGHTS_READ       |\
  4356.                                   KEY_QUERY_VALUE            |\
  4357.                                   KEY_ENUMERATE_SUB_KEYS     |\
  4358.                                   KEY_NOTIFY)                 \
  4359.                                   &                           \
  4360.                                  (~SYNCHRONIZE))
  4361.  
  4362.  
  4363. #define KEY_WRITE               ((STANDARD_RIGHTS_WRITE      |\
  4364.                                   KEY_SET_VALUE              |\
  4365.                                   KEY_CREATE_SUB_KEY)         \
  4366.                                   &                           \
  4367.                                  (~SYNCHRONIZE))
  4368.  
  4369. #define KEY_EXECUTE             ((KEY_READ)                   \
  4370.                                   &                           \
  4371.                                  (~SYNCHRONIZE))
  4372.  
  4373. #define KEY_ALL_ACCESS          ((STANDARD_RIGHTS_ALL        |\
  4374.                                   KEY_QUERY_VALUE            |\
  4375.                                   KEY_SET_VALUE              |\
  4376.                                   KEY_CREATE_SUB_KEY         |\
  4377.                                   KEY_ENUMERATE_SUB_KEYS     |\
  4378.                                   KEY_NOTIFY                 |\
  4379.                                   KEY_CREATE_LINK)            \
  4380.                                   &                           \
  4381.                                  (~SYNCHRONIZE))
  4382.  
  4383. //
  4384. // Open/Create Options
  4385. //
  4386.  
  4387. #define REG_OPTION_RESERVED         (0x00000000L)   // Parameter is reserved
  4388.  
  4389. #define REG_OPTION_NON_VOLATILE     (0x00000000L)   // Key is preserved
  4390.                                                     // when system is rebooted
  4391.  
  4392. #define REG_OPTION_VOLATILE         (0x00000001L)   // Key is not preserved
  4393.                                                     // when system is rebooted
  4394.  
  4395. #define REG_OPTION_CREATE_LINK      (0x00000002L)   // Created key is a
  4396.                                                     // symbolic link
  4397.  
  4398. #define REG_OPTION_BACKUP_RESTORE   (0x00000004L)   // open for backup or restore
  4399.                                                     // special access rules
  4400.                                                     // privilege required
  4401.  
  4402. #define REG_LEGAL_OPTION            \
  4403.                 (REG_OPTION_RESERVED            |\
  4404.                  REG_OPTION_NON_VOLATILE        |\
  4405.                  REG_OPTION_VOLATILE            |\
  4406.                  REG_OPTION_CREATE_LINK         |\
  4407.                  REG_OPTION_BACKUP_RESTORE)
  4408.  
  4409. //
  4410. // Key creation/open disposition
  4411. //
  4412.  
  4413. #define REG_CREATED_NEW_KEY         (0x00000001L)   // New Registry Key created
  4414. #define REG_OPENED_EXISTING_KEY     (0x00000002L)   // Existing Key opened
  4415.  
  4416. //
  4417. // Key restore flags
  4418. //
  4419.  
  4420. #define REG_WHOLE_HIVE_VOLATILE     (0x00000001L)   // Restore whole hive volatile
  4421. #define REG_REFRESH_HIVE            (0x00000002L)   // Unwind changes to last flush
  4422.  
  4423. // end_ntddk end_nthal
  4424.  
  4425. //
  4426. // Notify filter values
  4427. //
  4428. #define REG_NOTIFY_CHANGE_NAME          (0x00000001L) // Create or delete (child)
  4429. #define REG_NOTIFY_CHANGE_ATTRIBUTES    (0x00000002L)
  4430. #define REG_NOTIFY_CHANGE_LAST_SET      (0x00000004L) // time stamp
  4431. #define REG_NOTIFY_CHANGE_SECURITY      (0x00000008L)
  4432.  
  4433. #define REG_LEGAL_CHANGE_FILTER                 \
  4434.                 (REG_NOTIFY_CHANGE_NAME          |\
  4435.                  REG_NOTIFY_CHANGE_ATTRIBUTES    |\
  4436.                  REG_NOTIFY_CHANGE_LAST_SET      |\
  4437.                  REG_NOTIFY_CHANGE_SECURITY)
  4438.  
  4439. //
  4440. //
  4441. // Predefined Value Types.
  4442. //
  4443.  
  4444. #define REG_NONE                    ( 0 )   // No value type
  4445. #define REG_SZ                      ( 1 )   // Unicode nul terminated string
  4446. #define REG_EXPAND_SZ               ( 2 )   // Unicode nul terminated string
  4447.                                             // (with environment variable references)
  4448. #define REG_BINARY                  ( 3 )   // Free form binary
  4449. #define REG_DWORD                   ( 4 )   // 32-bit number
  4450. #define REG_DWORD_LITTLE_ENDIAN     ( 4 )   // 32-bit number (same as REG_DWORD)
  4451. #define REG_DWORD_BIG_ENDIAN        ( 5 )   // 32-bit number
  4452. #define REG_LINK                    ( 6 )   // Symbolic Link (unicode)
  4453. #define REG_MULTI_SZ                ( 7 )   // Multiple Unicode strings
  4454. #define REG_RESOURCE_LIST           ( 8 )   // Resource list in the resource map
  4455. #define REG_FULL_RESOURCE_DESCRIPTOR ( 9 )  // Resource list in the hardware description
  4456. #define REG_RESOURCE_REQUIREMENTS_LIST ( 10 )
  4457.  
  4458. // end_ntddk end_nthal
  4459.  
  4460. // begin_ntddk begin_nthal
  4461. //
  4462. // Service Types (Bit Mask)
  4463. //
  4464. #define SERVICE_KERNEL_DRIVER          0x00000001
  4465. #define SERVICE_FILE_SYSTEM_DRIVER     0x00000002
  4466. #define SERVICE_ADAPTER                0x00000004
  4467. #define SERVICE_RECOGNIZER_DRIVER      0x00000008
  4468.  
  4469. #define SERVICE_DRIVER                 (SERVICE_KERNEL_DRIVER | \
  4470.                                         SERVICE_FILE_SYSTEM_DRIVER | \
  4471.                                         SERVICE_RECOGNIZER_DRIVER)
  4472.  
  4473. #define SERVICE_WIN32_OWN_PROCESS      0x00000010
  4474. #define SERVICE_WIN32_SHARE_PROCESS    0x00000020
  4475. #define SERVICE_WIN32                  (SERVICE_WIN32_OWN_PROCESS | \
  4476.                                         SERVICE_WIN32_SHARE_PROCESS)
  4477.  
  4478. #define SERVICE_INTERACTIVE_PROCESS    0x00000100
  4479.  
  4480. #define SERVICE_TYPE_ALL               (SERVICE_WIN32  | \
  4481.                                         SERVICE_ADAPTER | \
  4482.                                         SERVICE_DRIVER  | \
  4483.                                         SERVICE_INTERACTIVE_PROCESS)
  4484.  
  4485. //
  4486. // Start Type
  4487. //
  4488.  
  4489. #define SERVICE_BOOT_START             0x00000000
  4490. #define SERVICE_SYSTEM_START           0x00000001
  4491. #define SERVICE_AUTO_START             0x00000002
  4492. #define SERVICE_DEMAND_START           0x00000003
  4493. #define SERVICE_DISABLED               0x00000004
  4494.  
  4495. //
  4496. // Error control type
  4497. //
  4498. #define SERVICE_ERROR_IGNORE           0x00000000
  4499. #define SERVICE_ERROR_NORMAL           0x00000001
  4500. #define SERVICE_ERROR_SEVERE           0x00000002
  4501. #define SERVICE_ERROR_CRITICAL         0x00000003
  4502.  
  4503. //
  4504. //
  4505. // Define the registry driver node enumerations
  4506. //
  4507.  
  4508. typedef enum _CM_SERVICE_NODE_TYPE {
  4509.     DriverType               = SERVICE_KERNEL_DRIVER,
  4510.     FileSystemType           = SERVICE_FILE_SYSTEM_DRIVER,
  4511.     Win32ServiceOwnProcess   = SERVICE_WIN32_OWN_PROCESS,
  4512.     Win32ServiceShareProcess = SERVICE_WIN32_SHARE_PROCESS,
  4513.     AdapterType              = SERVICE_ADAPTER,
  4514.     RecognizerType           = SERVICE_RECOGNIZER_DRIVER
  4515. } SERVICE_NODE_TYPE;
  4516.  
  4517. typedef enum _CM_SERVICE_LOAD_TYPE {
  4518.     BootLoad    = SERVICE_BOOT_START,
  4519.     SystemLoad  = SERVICE_SYSTEM_START,
  4520.     AutoLoad    = SERVICE_AUTO_START,
  4521.     DemandLoad  = SERVICE_DEMAND_START,
  4522.     DisableLoad = SERVICE_DISABLED
  4523. } SERVICE_LOAD_TYPE;
  4524.  
  4525. typedef enum _CM_ERROR_CONTROL_TYPE {
  4526.     IgnoreError   = SERVICE_ERROR_IGNORE,
  4527.     NormalError   = SERVICE_ERROR_NORMAL,
  4528.     SevereError   = SERVICE_ERROR_SEVERE,
  4529.     CriticalError = SERVICE_ERROR_CRITICAL
  4530. } SERVICE_ERROR_TYPE;
  4531.  
  4532. #ifndef NOTAPE
  4533.  
  4534. //
  4535. // IOCTL_TAPE_ERASE definitions
  4536. //
  4537.  
  4538. #define TAPE_ERASE_SHORT            0L
  4539. #define TAPE_ERASE_LONG             1L
  4540.  
  4541. typedef struct _TAPE_ERASE {
  4542.     DWORD Type;
  4543.     BOOLEAN Immediate;
  4544. } TAPE_ERASE, *PTAPE_ERASE;
  4545.  
  4546. //
  4547. // IOCTL_TAPE_PREPARE definitions
  4548. //
  4549.  
  4550. #define TAPE_LOAD                   0L
  4551. #define TAPE_UNLOAD                 1L
  4552. #define TAPE_TENSION                2L
  4553. #define TAPE_LOCK                   3L
  4554. #define TAPE_UNLOCK                 4L
  4555. #define TAPE_FORMAT                 5L
  4556.  
  4557. typedef struct _TAPE_PREPARE {
  4558.     DWORD Operation;
  4559.     BOOLEAN Immediate;
  4560. } TAPE_PREPARE, *PTAPE_PREPARE;
  4561.  
  4562. //
  4563. // IOCTL_TAPE_WRITE_MARKS definitions
  4564. //
  4565.  
  4566. #define TAPE_SETMARKS               0L
  4567. #define TAPE_FILEMARKS              1L
  4568. #define TAPE_SHORT_FILEMARKS        2L
  4569. #define TAPE_LONG_FILEMARKS         3L
  4570.  
  4571. typedef struct _TAPE_WRITE_MARKS {
  4572.     DWORD Type;
  4573.     DWORD Count;
  4574.     BOOLEAN Immediate;
  4575. } TAPE_WRITE_MARKS, *PTAPE_WRITE_MARKS;
  4576.  
  4577. //
  4578. // IOCTL_TAPE_GET_POSITION definitions
  4579. //
  4580.  
  4581. #define TAPE_ABSOLUTE_POSITION       0L
  4582. #define TAPE_LOGICAL_POSITION        1L
  4583. #define TAPE_PSEUDO_LOGICAL_POSITION 2L
  4584.  
  4585. typedef struct _TAPE_GET_POSITION {
  4586.     DWORD Type;
  4587.     DWORD Partition;
  4588.     LARGE_INTEGER Offset;
  4589. } TAPE_GET_POSITION, *PTAPE_GET_POSITION;
  4590.  
  4591. //
  4592. // IOCTL_TAPE_SET_POSITION definitions
  4593. //
  4594.  
  4595. #define TAPE_REWIND                 0L
  4596. #define TAPE_ABSOLUTE_BLOCK         1L
  4597. #define TAPE_LOGICAL_BLOCK          2L
  4598. #define TAPE_PSEUDO_LOGICAL_BLOCK   3L
  4599. #define TAPE_SPACE_END_OF_DATA      4L
  4600. #define TAPE_SPACE_RELATIVE_BLOCKS  5L
  4601. #define TAPE_SPACE_FILEMARKS        6L
  4602. #define TAPE_SPACE_SEQUENTIAL_FMKS  7L
  4603. #define TAPE_SPACE_SETMARKS         8L
  4604. #define TAPE_SPACE_SEQUENTIAL_SMKS  9L
  4605.  
  4606. typedef struct _TAPE_SET_POSITION {
  4607.     DWORD Method;
  4608.     DWORD Partition;
  4609.     LARGE_INTEGER Offset;
  4610.     BOOLEAN Immediate;
  4611. } TAPE_SET_POSITION, *PTAPE_SET_POSITION;
  4612.  
  4613. //
  4614. // IOCTL_TAPE_GET_DRIVE_PARAMS definitions
  4615. //
  4616.  
  4617. //
  4618. // Definitions for FeaturesLow parameter
  4619. //
  4620.  
  4621. #define TAPE_DRIVE_FIXED            0x00000001
  4622. #define TAPE_DRIVE_SELECT           0x00000002
  4623. #define TAPE_DRIVE_INITIATOR        0x00000004
  4624.  
  4625. #define TAPE_DRIVE_ERASE_SHORT      0x00000010
  4626. #define TAPE_DRIVE_ERASE_LONG       0x00000020
  4627. #define TAPE_DRIVE_ERASE_BOP_ONLY   0x00000040
  4628. #define TAPE_DRIVE_ERASE_IMMEDIATE  0x00000080
  4629.  
  4630. #define TAPE_DRIVE_TAPE_CAPACITY    0x00000100
  4631. #define TAPE_DRIVE_TAPE_REMAINING   0x00000200
  4632. #define TAPE_DRIVE_FIXED_BLOCK      0x00000400
  4633. #define TAPE_DRIVE_VARIABLE_BLOCK   0x00000800
  4634.  
  4635. #define TAPE_DRIVE_WRITE_PROTECT    0x00001000
  4636. #define TAPE_DRIVE_EOT_WZ_SIZE      0x00002000
  4637.  
  4638. #define TAPE_DRIVE_ECC              0x00010000
  4639. #define TAPE_DRIVE_COMPRESSION      0x00020000
  4640. #define TAPE_DRIVE_PADDING          0x00040000
  4641. #define TAPE_DRIVE_REPORT_SMKS      0x00080000
  4642.  
  4643. #define TAPE_DRIVE_GET_ABSOLUTE_BLK 0x00100000
  4644. #define TAPE_DRIVE_GET_LOGICAL_BLK  0x00200000
  4645. #define TAPE_DRIVE_SET_EOT_WZ_SIZE  0x00400000
  4646.  
  4647. #define TAPE_DRIVE_RESERVED_BIT     0x80000000  //don't use this bit!
  4648. //                                              //can't be a low features bit!
  4649. //                                              //reserved; high features only
  4650.  
  4651. //
  4652. // Definitions for FeaturesHigh parameter
  4653. //
  4654.  
  4655. #define TAPE_DRIVE_LOAD_UNLOAD      0x80000001
  4656. #define TAPE_DRIVE_TENSION          0x80000002
  4657. #define TAPE_DRIVE_LOCK_UNLOCK      0x80000004
  4658. #define TAPE_DRIVE_REWIND_IMMEDIATE 0x80000008
  4659.  
  4660. #define TAPE_DRIVE_SET_BLOCK_SIZE   0x80000010
  4661. #define TAPE_DRIVE_LOAD_UNLD_IMMED  0x80000020
  4662. #define TAPE_DRIVE_TENSION_IMMED    0x80000040
  4663. #define TAPE_DRIVE_LOCK_UNLK_IMMED  0x80000080
  4664.  
  4665. #define TAPE_DRIVE_SET_ECC          0x80000100
  4666. #define TAPE_DRIVE_SET_COMPRESSION  0x80000200
  4667. #define TAPE_DRIVE_SET_PADDING      0x80000400
  4668. #define TAPE_DRIVE_SET_REPORT_SMKS  0x80000800
  4669.  
  4670. #define TAPE_DRIVE_ABSOLUTE_BLK     0x80001000
  4671. #define TAPE_DRIVE_ABS_BLK_IMMED    0x80002000
  4672. #define TAPE_DRIVE_LOGICAL_BLK      0x80004000
  4673. #define TAPE_DRIVE_LOG_BLK_IMMED    0x80008000
  4674.  
  4675. #define TAPE_DRIVE_END_OF_DATA      0x80010000
  4676. #define TAPE_DRIVE_RELATIVE_BLKS    0x80020000
  4677. #define TAPE_DRIVE_FILEMARKS        0x80040000
  4678. #define TAPE_DRIVE_SEQUENTIAL_FMKS  0x80080000
  4679.  
  4680. #define TAPE_DRIVE_SETMARKS         0x80100000
  4681. #define TAPE_DRIVE_SEQUENTIAL_SMKS  0x80200000
  4682. #define TAPE_DRIVE_REVERSE_POSITION 0x80400000
  4683. #define TAPE_DRIVE_SPACE_IMMEDIATE  0x80800000
  4684.  
  4685. #define TAPE_DRIVE_WRITE_SETMARKS   0x81000000
  4686. #define TAPE_DRIVE_WRITE_FILEMARKS  0x82000000
  4687. #define TAPE_DRIVE_WRITE_SHORT_FMKS 0x84000000
  4688. #define TAPE_DRIVE_WRITE_LONG_FMKS  0x88000000
  4689.  
  4690. #define TAPE_DRIVE_WRITE_MARK_IMMED 0x90000000
  4691. #define TAPE_DRIVE_FORMAT           0xA0000000
  4692. #define TAPE_DRIVE_FORMAT_IMMEDIATE 0xC0000000
  4693. #define TAPE_DRIVE_HIGH_FEATURES    0x80000000  //mask for high features flag
  4694.  
  4695. typedef struct _TAPE_GET_DRIVE_PARAMETERS {
  4696.     BOOLEAN ECC;
  4697.     BOOLEAN Compression;
  4698.     BOOLEAN DataPadding;
  4699.     BOOLEAN ReportSetmarks;
  4700.     DWORD DefaultBlockSize;
  4701.     DWORD MaximumBlockSize;
  4702.     DWORD MinimumBlockSize;
  4703.     DWORD MaximumPartitionCount;
  4704.     DWORD FeaturesLow;
  4705.     DWORD FeaturesHigh;
  4706.     DWORD EOTWarningZoneSize;
  4707. } TAPE_GET_DRIVE_PARAMETERS, *PTAPE_GET_DRIVE_PARAMETERS;
  4708.  
  4709. //
  4710. // IOCTL_TAPE_SET_DRIVE_PARAMETERS definitions
  4711. //
  4712.  
  4713. typedef struct _TAPE_SET_DRIVE_PARAMETERS {
  4714.     BOOLEAN ECC;
  4715.     BOOLEAN Compression;
  4716.     BOOLEAN DataPadding;
  4717.     BOOLEAN ReportSetmarks;
  4718.     DWORD EOTWarningZoneSize;
  4719. } TAPE_SET_DRIVE_PARAMETERS, *PTAPE_SET_DRIVE_PARAMETERS;
  4720.  
  4721. //
  4722. // IOCTL_TAPE_GET_MEDIA_PARAMETERS definitions
  4723. //
  4724.  
  4725. typedef struct _TAPE_GET_MEDIA_PARAMETERS {
  4726.     LARGE_INTEGER Capacity;
  4727.     LARGE_INTEGER Remaining;
  4728.     DWORD BlockSize;
  4729.     DWORD PartitionCount;
  4730.     BOOLEAN WriteProtected;
  4731. } TAPE_GET_MEDIA_PARAMETERS, *PTAPE_GET_MEDIA_PARAMETERS;
  4732.  
  4733. //
  4734. // IOCTL_TAPE_SET_MEDIA_PARAMETERS definitions
  4735. //
  4736.  
  4737. typedef struct _TAPE_SET_MEDIA_PARAMETERS {
  4738.     DWORD BlockSize;
  4739. } TAPE_SET_MEDIA_PARAMETERS, *PTAPE_SET_MEDIA_PARAMETERS;
  4740.  
  4741. //
  4742. // IOCTL_TAPE_CREATE_PARTITION definitions
  4743. //
  4744.  
  4745. #define TAPE_FIXED_PARTITIONS       0L
  4746. #define TAPE_SELECT_PARTITIONS      1L
  4747. #define TAPE_INITIATOR_PARTITIONS   2L
  4748.  
  4749. typedef struct _TAPE_CREATE_PARTITION {
  4750.     DWORD Method;
  4751.     DWORD Count;
  4752.     DWORD Size;
  4753. } TAPE_CREATE_PARTITION, *PTAPE_CREATE_PARTITION;
  4754.  
  4755. #endif // NOTAPE
  4756.  
  4757. #ifdef __cplusplus
  4758. }
  4759. #endif
  4760.  
  4761. #endif /* _WINNT_ */
  4762.  
  4763.  
  4764. #if defined(__TOPLEVEL_WINNT_H_)
  4765. #undef __TOPLEVEL_NEXT_COMMON_INCLUDE__
  4766. #undef __TOPLEVEL_WINNT_H_
  4767. #include <next_common_undefines.h>
  4768. #endif /* __TOPLEVEL_NEXT_COMMON_INCLUDE__ */
  4769.