Changeset 7985 for trunk/include


Ignore:
Timestamp:
Feb 21, 2002, 11:59:09 PM (24 years ago)
Author:
sandervl
Message:

header updates

Location:
trunk/include/win
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/include/win/imagehlp.h

    r4 r7985  
    1 /* $Id: imagehlp.h,v 1.1 1999-05-24 20:19:12 ktk Exp $ */
     1/* $Id: imagehlp.h,v 1.2 2002-02-21 22:59:08 sandervl Exp $ */
    22
    33/*
    … …  
    145145 */
    146146
    147 typedef struct _IMAGE_DATA_DIRECTORY {
    148   DWORD VirtualAddress;
    149   DWORD Size;
    150 } IMAGE_DATA_DIRECTORY, *PIMAGE_DATA_DIRECTORY;
    151147
    152148#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES 16
    153149
    154 typedef struct _IMAGE_OPTIONAL_HEADER {
    155 
    156   /* Standard fields */
    157 
    158   WORD  Magic;
    159   BYTE  MajorLinkerVersion;
    160   BYTE  MinorLinkerVersion;
    161   DWORD SizeOfCode;
    162   DWORD SizeOfInitializedData;
    163   DWORD SizeOfUninitializedData;
    164   DWORD AddressOfEntryPoint;
    165   DWORD BaseOfCode;
    166   DWORD BaseOfData;
    167 
    168   /* NT additional fields */
    169 
    170   DWORD ImageBase;
    171   DWORD SectionAlignment;
    172   DWORD FileAlignment;
    173   WORD  MajorOperatingSystemVersion;
    174   WORD  MinorOperatingSystemVersion;
    175   WORD  MajorImageVersion;
    176   WORD  MinorImageVersion;
    177   WORD  MajorSubsystemVersion;
    178   WORD  MinorSubsystemVersion;
    179   DWORD Win32VersionValue;
    180   DWORD SizeOfImage;
    181   DWORD SizeOfHeaders;
    182   DWORD CheckSum;
    183   WORD  Subsystem;
    184   WORD  DllCharacteristics;
    185   DWORD SizeOfStackReserve;
    186   DWORD SizeOfStackCommit;
    187   DWORD SizeOfHeapReserve;
    188   DWORD SizeOfHeapCommit;
    189   DWORD LoaderFlags;
    190   DWORD NumberOfRvaAndSizes;
    191   IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
    192 } IMAGE_OPTIONAL_HEADER, *PIMAGE_OPTIONAL_HEADER;
    193 
    194 typedef struct _IMAGE_FILE_HEADER {
    195   WORD  Machine;
    196   WORD  NumberOfSections;
    197   DWORD TimeDateStamp;
    198   DWORD PointerToSymbolTable;
    199   DWORD NumberOfSymbols;
    200   WORD  SizeOfOptionalHeader;
    201   WORD  Characteristics;
    202 } IMAGE_FILE_HEADER, *PIMAGE_FILE_HEADER;
    203 
    204 typedef struct _IMAGE_NT_HEADERS {
    205   DWORD Signature;
    206   IMAGE_FILE_HEADER FileHeader;
    207   IMAGE_OPTIONAL_HEADER OptionalHeader;
    208 } IMAGE_NT_HEADERS, *PIMAGE_NT_HEADERS;
    209 
    210 #define IMAGE_SIZEOF_SHORT_NAME 8
    211 
    212 typedef struct _IMAGE_SECTION_HEADER {
    213   BYTE  Name[IMAGE_SIZEOF_SHORT_NAME];
    214   union {
    215     DWORD PhysicalAddress;
    216     DWORD VirtualSize;
    217   } Misc;
    218   DWORD VirtualAddress;
    219   DWORD SizeOfRawData;
    220   DWORD PointerToRawData;
    221   DWORD PointerToRelocations;
    222   DWORD PointerToLinenumbers;
    223   WORD  NumberOfRelocations;
    224   WORD  NumberOfLinenumbers;
    225   DWORD Characteristics;
    226 } IMAGE_SECTION_HEADER, *PIMAGE_SECTION_HEADER;
    227150
    228151typedef struct _LOADED_IMAGE {
    … …  
    241164} LOADED_IMAGE, *PLOADED_IMAGE;
    242165
    243 typedef struct _IMAGE_LOAD_CONFIG_DIRECTORY {
    244   DWORD Characteristics;
    245   DWORD TimeDateStamp;
    246   WORD  MajorVersion;
    247   WORD  MinorVersion;
    248   DWORD GlobalFlagsClear;
    249   DWORD GlobalFlagsSet;
    250   DWORD CriticalSectionDefaultTimeout;
    251   DWORD DeCommitFreeBlockThreshold;
    252   DWORD DeCommitTotalFreeThreshold;
    253   PVOID LockPrefixTable;
    254   DWORD MaximumAllocationSize;
    255   DWORD VirtualMemoryThreshold;
    256   DWORD ProcessHeapFlags;
    257   DWORD ProcessAffinityMask;
    258   WORD  CSDVersion;
    259   WORD  Reserved1;
    260   PVOID EditList;
    261   DWORD Reserved[1];
    262 } IMAGE_LOAD_CONFIG_DIRECTORY, *PIMAGE_LOAD_CONFIG_DIRECTORY;
    263166
    264167typedef struct _WIN_CERTIFICATE {
    … …  
    281184  DWORD EndOfPrologue;
    282185} IMAGE_FUNCTION_ENTRY, *PIMAGE_FUNCTION_ENTRY;
    283 
    284 typedef struct _IMAGE_DEBUG_DIRECTORY {
    285   DWORD Characteristics;
    286   DWORD TimeDateStamp;
    287   WORD  MajorVersion;
    288   WORD  MinorVersion;
    289   DWORD Type;
    290   DWORD SizeOfData;
    291   DWORD AddressOfRawData;
    292   DWORD PointerToRawData;
    293 } IMAGE_DEBUG_DIRECTORY, *PIMAGE_DEBUG_DIRECTORY;
    294186
    295187typedef struct _IMAGE_COFF_SYMBOLS_HEADER {
    … …  
    435327} IMAGEHLP_DUPLICATE_SYMBOL, *PIMAGEHLP_DUPLICATE_SYMBOL;
    436328
    437 typedef struct _IMAGE_DOS_HEADER {
    438   WORD e_magic;
    439   WORD e_cblp;
    440   WORD e_cp;
    441   WORD e_crlc;
    442   WORD e_cparhdr;
    443   WORD e_minalloc;
    444   WORD e_maxalloc;
    445   WORD e_ss;
    446   WORD e_sp;
    447   WORD e_csum;
    448   WORD e_ip;
    449   WORD e_cs;
    450   WORD e_lfarlc;
    451   WORD e_ovno;
    452   WORD e_res[4];
    453   WORD e_oemid;
    454   WORD e_oeminfo;
    455   WORD e_res2[10];
    456   LONG e_lfanew;
    457 } IMAGE_DOS_HEADER, *PIMAGE_DOS_HEADER;
    458 
    459 typedef struct _IMAGE_OS2_HEADER {
    460   WORD ne_magic;
    461   CHAR ne_ver;
    462   CHAR ne_rev;
    463   WORD ne_enttab;
    464   WORD ne_cbenttab;
    465   LONG ne_crc;
    466   WORD ne_flags;
    467   WORD ne_autodata;
    468   WORD ne_heap;
    469   WORD ne_stack;
    470   LONG ne_csip;
    471   LONG ne_sssp;
    472   WORD ne_cseg;
    473   WORD ne_cmod;
    474   WORD ne_cbnrestab;
    475   WORD ne_segtab;
    476   WORD ne_rsrctab;
    477   WORD ne_restab;
    478   WORD ne_modtab;
    479   WORD ne_imptab;
    480   LONG ne_nrestab;
    481   WORD ne_cmovent;
    482   WORD ne_align;
    483   WORD ne_cres;
    484   BYTE ne_exetyp;
    485   BYTE ne_flagsothers;
    486   WORD ne_pretthunks;
    487   WORD ne_psegrefbytes;
    488   WORD ne_swaparea;
    489   WORD ne_expver;
    490 } IMAGE_OS2_HEADER, *PIMAGE_OS2_HEADER;
     329
    491330
    492331typedef struct _IMAGE_VXD_HEADER {

  • trunk/include/win/ntddk.h

    r6371 r7985  
    99#include "ntdef.h"
    1010#include "winnt.h"
    11 #include "winbase.h"    /* fixme: should be taken out sometimes */
     11#include "winreg.h"
     12#include "winbase.h"    /* FIXME: should be taken out sometimes */
    1213
    1314#ifdef __cplusplus
    … …  
    2930} IO_STATUS_BLOCK, *PIO_STATUS_BLOCK;   
    3031
     32#ifdef __WIN32OS2__
    3133typedef VOID (* NTAPI PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
    32 
    33 typedef enum _KEY_INFORMATION_CLASS {
     34#else
     35typedef VOID (NTAPI *PIO_APC_ROUTINE) ( PVOID ApcContext, PIO_STATUS_BLOCK IoStatusBlock, ULONG Reserved );
     36#endif
     37
     38/*
     39        registry
     40 */
     41
     42 /* key information */
     43typedef struct _KEY_BASIC_INFORMATION {
     44        LARGE_INTEGER   LastWriteTime;
     45        ULONG           TitleIndex;
     46        ULONG           NameLength;
     47        WCHAR           Name[1];
     48} KEY_BASIC_INFORMATION, *PKEY_BASIC_INFORMATION;
     49
     50typedef struct _KEY_NODE_INFORMATION
     51{
     52        LARGE_INTEGER   LastWriteTime;
     53        ULONG           TitleIndex;
     54        ULONG           ClassOffset;
     55        ULONG           ClassLength;
     56        ULONG           NameLength;
     57        WCHAR           Name[1];
     58/*      Class[1]; */
     59} KEY_NODE_INFORMATION, *PKEY_NODE_INFORMATION;
     60
     61typedef struct _KEY_FULL_INFORMATION
     62{
     63        LARGE_INTEGER   LastWriteTime;
     64        ULONG           TitleIndex;
     65        ULONG           ClassOffset;
     66        ULONG           ClassLength;
     67        ULONG           SubKeys;
     68        ULONG           MaxNameLen;
     69        ULONG           MaxClassLen;
     70        ULONG           Values;
     71        ULONG           MaxValueNameLen;
     72        ULONG           MaxValueDataLen;
     73        WCHAR           Class[1];
     74} KEY_FULL_INFORMATION, *PKEY_FULL_INFORMATION;
     75
     76typedef enum _KEY_INFORMATION_CLASS
     77{
    3478        KeyBasicInformation,
    3579        KeyNodeInformation,
    … …  
    3781} KEY_INFORMATION_CLASS;
    3882
    39 typedef enum _KEY_VALUE_INFORMATION_CLASS {
     83typedef struct _KEY_VALUE_ENTRY
     84{
     85        PUNICODE_STRING ValueName;
     86        ULONG           DataLength;
     87        ULONG           DataOffset;
     88        ULONG           Type;
     89} KEY_VALUE_ENTRY, *PKEY_VALUE_ENTRY;
     90
     91/* value information */
     92typedef struct _KEY_VALUE_BASIC_INFORMATION
     93{
     94        ULONG   TitleIndex;
     95        ULONG   Type;
     96        ULONG   NameLength;
     97        WCHAR   Name[1];
     98} KEY_VALUE_BASIC_INFORMATION, *PKEY_VALUE_BASIC_INFORMATION;
     99
     100typedef struct _KEY_VALUE_FULL_INFORMATION
     101{
     102        ULONG   TitleIndex;
     103        ULONG   Type;
     104        ULONG   DataOffset;
     105        ULONG   DataLength;
     106        ULONG   NameLength;
     107        WCHAR   Name[1];
     108/*      UCHAR   Data[1];*/
     109} KEY_VALUE_FULL_INFORMATION, *PKEY_VALUE_FULL_INFORMATION;
     110
     111typedef struct _KEY_VALUE_PARTIAL_INFORMATION
     112{
     113        ULONG   TitleIndex;
     114        ULONG   Type;
     115        ULONG   DataLength;
     116        UCHAR   Data[1];
     117} KEY_VALUE_PARTIAL_INFORMATION, *PKEY_VALUE_PARTIAL_INFORMATION;
     118
     119typedef enum _KEY_VALUE_INFORMATION_CLASS
     120{
    40121        KeyValueBasicInformation,
    41122        KeyValueFullInformation,
    … …  
    44125        KeyValuePartialInformationAlign64
    45126} KEY_VALUE_INFORMATION_CLASS;
     127
     128NTSTATUS WINAPI RtlFormatCurrentUserKeyPath(
     129        PUNICODE_STRING KeyPath);
     130
     131/*      thread information */
    46132
    47133typedef enum _THREADINFOCLASS
    … …  
    65151        MaxThreadInfoClass
    66152} THREADINFOCLASS;
     153
     154typedef struct {
     155/* This is used by NtQuerySystemInformation */
     156        FILETIME ftCreationTime;
     157        DWORD dwUnknown1;
     158        DWORD dwStartAddress;
     159        DWORD dwOwningPID;
     160        DWORD dwThreadID;
     161        DWORD dwCurrentPriority;
     162        DWORD dwBasePriority;
     163        DWORD dwContextSwitches;
     164        DWORD dwThreadState;
     165        DWORD dwWaitReason;
     166        DWORD dwUnknown2[5];
     167} THREADINFO, *PTHREADINFO;
     168
     169/*      file information */
    67170
    68171typedef enum _FILE_INFORMATION_CLASS {
    … …  
    125228} SECTION_INHERIT;
    126229 
    127 /*
    128         placeholder
    129 */
     230/*      object information */
     231
    130232typedef enum _OBJECT_INFORMATION_CLASS
    131233{
    … …  
    135237
    136238
    137 /*
    138  *      NtQuerySystemInformation
    139  */
     239/*      system information */
    140240
    141241typedef enum SYSTEM_INFORMATION_CLASS
    142 {       Unknown1 = 1,
    143         Unknown2,
    144         Unknown3,
    145         Unknown4,
    146         SystemPerformanceInformation
     242{       SystemBasicInformation = 0,
     243        Unknown1,
     244        SystemPerformanceInformation,
     245        SystemTimeInformation,
     246        Unknown4,
     247        SystemProcessInformation,
     248        Unknown6,
     249        Unknown7,
     250        Unknown8,
     251        Unknown9,
     252        Unknown10,
     253        SystemDriverInformation,
     254        Unknown12,
     255        Unknown13,
     256        Unknown14,
     257        Unknown15,
     258        SystemHandleList,
     259        Unknown17,
     260        Unknown18,
     261        Unknown19,
     262        Unknown20,
     263        SystemCacheInformation
    147264} SYSTEM_INFORMATION_CLASS, *PSYSTEM_INFORMATION_CLASS;
     265
     266typedef struct {
     267/* System Information Class 0x00 */
     268        DWORD dwUnknown1;
     269        ULONG uKeMaximumIncrement;
     270        ULONG uPageSize;
     271        ULONG uMmNumberOfPhysicalPages;
     272        ULONG uMmLowestPhysicalPage;
     273        ULONG uMmHighestPhysicalPage;
     274        ULONG uAllocationGranularity;
     275        PVOID pLowestUserAddress;
     276        PVOID pMmHighestUserAddress;
     277        ULONG uKeActiveProcessors;
     278        BYTE bKeNumberProcessors;
     279        BYTE bUnknown2;
     280        WORD wUnknown3;
     281} SYSTEM_BASIC_INFORMATION;
     282
     283typedef struct {
     284/* System Information Class 0x02 */
     285        LARGE_INTEGER liIdleTime;
     286        DWORD dwSpare[76];
     287} SYSTEM_PERFORMANCE_INFORMATION;
     288
     289typedef struct {
     290/* System Information Class 0x03 */
     291        LARGE_INTEGER liKeBootTime;
     292        LARGE_INTEGER liKeSystemTime;
     293        LARGE_INTEGER liExpTimeZoneBias;
     294        ULONG uCurrentTimeZoneId;
     295        DWORD dwReserved;
     296} SYSTEM_TIME_INFORMATION;
     297
     298typedef struct {
     299/* System Information Class 0x05 */
     300        DWORD dwOffset;
     301        DWORD dwThreadCount;
     302        DWORD dwUnknown1[6];
     303        FILETIME ftCreationTime;
     304        DWORD dwUnknown2[5];
     305        WCHAR* pszProcessName;
     306        DWORD dwBasePriority;
     307        DWORD dwProcessID;
     308        DWORD dwParentProcessID;
     309        DWORD dwHandleCount;
     310        DWORD dwUnknown3;
     311        DWORD dwUnknown4;
     312        DWORD dwVirtualBytesPeak;
     313        DWORD dwVirtualBytes;
     314        DWORD dwPageFaults;
     315        DWORD dwWorkingSetPeak;
     316        DWORD dwWorkingSet;
     317        DWORD dwUnknown5;
     318        DWORD dwPagedPool;
     319        DWORD dwUnknown6;
     320        DWORD dwNonPagedPool;
     321        DWORD dwPageFileBytesPeak;
     322        DWORD dwPrivateBytes;
     323        DWORD dwPageFileBytes;
     324        DWORD dwUnknown7[4];
     325#ifdef __WIN32OS2__
     326        THREADINFO ti[1];
     327#else
     328        THREADINFO ti[0];
     329#endif
     330} SYSTEM_PROCESS_INFORMATION;
     331
     332typedef struct {
     333/* System Information Class 0x0b */
     334        PVOID pvAddress;
     335        DWORD dwUnknown1;
     336        DWORD dwUnknown2;
     337        DWORD dwEntryIndex;
     338        DWORD dwUnknown3;
     339        char szName[MAX_PATH + 1];
     340} SYSTEM_DRIVER_INFORMATION;
     341
     342typedef struct {
     343/* System Information Class 0x10 */
     344        USHORT dwPID;
     345        USHORT dwCreatorBackTraceIndex;
     346        BYTE bObjectType;
     347        BYTE bHandleAttributes;
     348        USHORT usHandleOffset;
     349        DWORD dwKeObject;
     350        ULONG ulGrantedAccess;
     351} HANDLEINFO, *PHANDLEINFO;
     352
     353typedef struct {
     354/* System Information Class 0x15 */
     355        ULONG CurrentSize;
     356        ULONG PeakSize;
     357        ULONG PageFaultCount;
     358        ULONG MinimumWorkingSet;
     359        ULONG MaximumWorkingSet;
     360        ULONG unused[4];
     361} SYSTEM_CACHE_INFORMATION;
    148362
    149363/* reading coffee grounds... */
    … …  
    170384        ULONG PeakPagefileUsage;
    171385} VM_COUNTERS, *PVM_COUNTERS;
     386
     387/* process information */
    172388
    173389typedef struct _PROCESS_INFO
    … …  
    238454} SYSTEM_CONFIGURATION_INFO, *PSYSTEM_CONFIGURATION_INFO;
    239455
    240 
    241 typedef struct _SYSTEM_CACHE_INFORMATION
    242 {
    243         ULONG   CurrentSize;
    244         ULONG   PeakSize;
    245         ULONG   PageFaultCount;
    246         ULONG   MinimumWorkingSet;
    247         ULONG   MaximumWorkingSet;
    248         ULONG   Unused[4];
    249 
    250 } SYSTEM_CACHE_INFORMATION;
    251456
    252457/*
    … …  
    318523} TIMER_TYPE;
    319524
    320 /*
    321  *      token functions
    322  */
     525/*      token functions */
    323526 
    324527NTSTATUS WINAPI NtOpenProcessToken(
    … …  
    348551        LPDWORD retlen );
    349552
    350 /*
    351  *      sid functions
    352  */
     553/*      sid functions */
    353554
    354555BOOLEAN WINAPI RtlAllocateAndInitializeSid (
    355556        PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
    356         DWORD nSubAuthorityCount,
    357         DWORD x3,
    358         DWORD x4,
    359         DWORD x5,
    360         DWORD x6,
    361         DWORD x7,
    362         DWORD x8,
    363         DWORD x9,
    364         DWORD x10,
    365         PSID *pSid);
    366        
    367 DWORD WINAPI RtlEqualSid(PSID pSid1, PSID pSid2);
    368 DWORD WINAPI RtlEqualPrefixSid (PSID pSid1, PSID pSid2);
    369 DWORD WINAPI RtlValidSid( PSID pSid );
    370 DWORD WINAPI RtlFreeSid(PSID x1);
    371 DWORD WINAPI RtlLengthRequiredSid(DWORD nrofsubauths);
    372 DWORD WINAPI RtlLengthSid(PSID sid);
    373 DWORD WINAPI RtlInitializeSid(PSID PSID,PSID_IDENTIFIER_AUTHORITY PSIDauth, DWORD c);
    374 LPDWORD WINAPI RtlSubAuthoritySid(PSID PSID,DWORD nr);
    375 LPBYTE WINAPI RtlSubAuthorityCountSid(PSID PSID);
    376 DWORD WINAPI RtlCopySid(DWORD len,PSID to,PSID from);
    377 PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid( PSID pSid );
    378 
    379 /*
    380  *      security descriptor functions
    381  */
     557        BYTE nSubAuthorityCount,
     558        DWORD nSubAuthority0, DWORD nSubAuthority1,
     559        DWORD nSubAuthority2, DWORD nSubAuthority3,
     560        DWORD nSubAuthority4, DWORD nSubAuthority5,
     561        DWORD nSubAuthority6, DWORD nSubAuthority7,
     562        PSID *pSid );
     563       
     564BOOL WINAPI RtlInitializeSid(
     565        PSID pSid,
     566        PSID_IDENTIFIER_AUTHORITY pIdentifierAuthority,
     567        BYTE nSubAuthorityCount);
     568       
     569DWORD WINAPI RtlFreeSid(
     570        PSID pSid);
     571
     572BOOL WINAPI RtlEqualSid(
     573        PSID pSid1,
     574        PSID pSid2 );
     575       
     576DWORD WINAPI RtlLengthRequiredSid(
     577        DWORD nrofsubauths);
     578
     579DWORD WINAPI RtlLengthSid(
     580        PSID sid);
     581
     582LPDWORD WINAPI RtlSubAuthoritySid(
     583        PSID PSID,
     584        DWORD nr);
     585
     586LPBYTE WINAPI RtlSubAuthorityCountSid(
     587        PSID pSid);
     588
     589DWORD WINAPI RtlCopySid(
     590        DWORD len,
     591        PSID to,
     592        PSID from);
     593       
     594BOOL WINAPI RtlValidSid(
     595        PSID pSid);
     596
     597BOOL WINAPI RtlEqualPrefixSid(
     598        PSID pSid1,
     599        PSID pSid2);
     600
     601PSID_IDENTIFIER_AUTHORITY WINAPI RtlIdentifierAuthoritySid(
     602        PSID pSid );
     603
     604/*      security descriptor functions */
    382605
    383606NTSTATUS WINAPI RtlCreateSecurityDescriptor(
    … …  
    435658        PBOOLEAN GroupDefaulted);
    436659
    437 /*      ##############################
    438         ######  ACL FUNCTIONS   ######
    439         ##############################
    440 */
    441 
    442 DWORD WINAPI RtlCreateAcl(PACL acl,DWORD size,DWORD rev);
     660NTSTATUS WINAPI RtlMakeSelfRelativeSD(
     661        IN PSECURITY_DESCRIPTOR pAbsoluteSecurityDescriptor,
     662        IN PSECURITY_DESCRIPTOR pSelfRelativeSecurityDescriptor,
     663        IN OUT LPDWORD lpdwBufferLength);
     664
     665NTSTATUS WINAPI RtlGetControlSecurityDescriptor(
     666        PSECURITY_DESCRIPTOR  pSecurityDescriptor,
     667        PSECURITY_DESCRIPTOR_CONTROL pControl,
     668        LPDWORD lpdwRevision);
     669
     670/*      acl functions */
     671
     672NTSTATUS WINAPI RtlCreateAcl(
     673        PACL acl,
     674        DWORD size,
     675        DWORD rev);
    443676
    444677BOOLEAN WINAPI RtlFirstFreeAce(
    … …  
    453686        DWORD acelen);
    454687       
    455 NTSTATUS WINAPI RtlAddAccessAllowedAce(IN OUT PACL pAcl, IN DWORD dwAceRevision,
    456                                        IN DWORD AccessMask, IN PSID pSid);
    457 NTSTATUS WINAPI RtlGetAce(PACL pAcl,DWORD dwAceIndex,LPVOID *pAce );
    458 
    459 /*
    460  *      string functions
    461  */
    462 
    463 NTSTATUS WINAPI RtlAnsiStringToUnicodeString( UNICODE_STRING *uni,
    464                                               const STRING *ansi,
    465                                               BOOLEAN doalloc );
    466 NTSTATUS WINAPI RtlOemStringToUnicodeString( UNICODE_STRING *uni,
    467                                              const STRING *oem,
    468                                              BOOLEAN doalloc );
    469 NTSTATUS WINAPI RtlMultiByteToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
    470                                         LPCSTR src, DWORD srclen );
    471 NTSTATUS WINAPI RtlOemToUnicodeN( LPWSTR dst, DWORD dstlen, LPDWORD reslen,
    472                                   LPCSTR src, DWORD srclen );
    473 VOID WINAPI RtlInitAnsiString(PANSI_STRING target,LPCSTR source);
    474 VOID WINAPI RtlInitString(PSTRING target,LPCSTR source);
    475 VOID WINAPI RtlInitUnicodeString(PUNICODE_STRING target,LPCWSTR source);
    476 VOID WINAPI RtlFreeUnicodeString(PUNICODE_STRING str);
    477 VOID WINAPI RtlFreeAnsiString(PANSI_STRING AnsiString);
    478 NTSTATUS WINAPI RtlUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
    479                                   LPCWSTR src, DWORD srclen );
    480 NTSTATUS WINAPI RtlUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
    481                                         LPCWSTR src, DWORD srclen );
    482 NTSTATUS WINAPI RtlUnicodeStringToOemString( STRING *oem,
    483                                              const UNICODE_STRING *uni,
    484                                              BOOLEAN doalloc );
    485 NTSTATUS WINAPI RtlUnicodeStringToAnsiString( STRING *ansi,
    486                                               const UNICODE_STRING *uni,
    487                                               BOOLEAN doalloc );
    488 BOOLEAN WINAPI RtlEqualUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
    489                                       BOOLEAN CaseInsensitive );
    490 NTSTATUS WINAPI RtlUpcaseUnicodeString( UNICODE_STRING *dest,
    491                                         const UNICODE_STRING *src,
    492                                         BOOLEAN doalloc );
    493 NTSTATUS WINAPI RtlUpcaseUnicodeStringToAnsiString( STRING *dst,
    494                                                     const UNICODE_STRING *src,
    495                                                     BOOLEAN doalloc );
    496 NTSTATUS WINAPI RtlUpcaseUnicodeStringToOemString( STRING *dst,
    497                                                    const UNICODE_STRING *src,
    498                                                    BOOLEAN doalloc );
    499 NTSTATUS WINAPI RtlUpcaseUnicodeToMultiByteN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
    500                                               LPCWSTR src, DWORD srclen );
    501 NTSTATUS WINAPI RtlUpcaseUnicodeToOemN( LPSTR dst, DWORD dstlen, LPDWORD reslen,
    502                                         LPCWSTR src, DWORD srclen );
    503 NTSTATUS WINAPI RtlMultiByteToUnicodeSize( DWORD *size, LPCSTR str, UINT len );
    504 NTSTATUS WINAPI RtlUnicodeToMultiByteSize( DWORD *size, LPCWSTR str, UINT len );
    505 
    506 UINT WINAPI RtlxOemStringToUnicodeSize(PSTRING str);
    507 DWORD WINAPI RtlUnicodeStringToOemSize( const UNICODE_STRING *str );
    508 DWORD WINAPI RtlUnicodeStringToAnsiSize( const UNICODE_STRING *str );
    509 UINT WINAPI RtlxAnsiStringToUnicodeSize(PANSI_STRING str);
    510 DWORD WINAPI RtlIsTextUnicode(LPVOID buf, DWORD len, DWORD *pf);
    511 LONG WINAPI RtlCompareUnicodeString( const UNICODE_STRING *s1, const UNICODE_STRING *s2,
    512                                      BOOLEAN CaseInsensitive );
    513 
    514 NTSTATUS WINAPI RtlAppendStringToString( STRING *dst, const STRING *src );
    515 NTSTATUS WINAPI RtlAppendAsciizToString( STRING *dst, LPCSTR src );
    516 NTSTATUS WINAPI RtlAppendUnicodeToString( UNICODE_STRING *dst, LPCWSTR src );
    517 NTSTATUS WINAPI RtlAppendUnicodeStringToString( UNICODE_STRING *dst, const UNICODE_STRING *src );
    518 
    519 
    520 /*
    521  *      resource functions
    522  */
     688BOOL WINAPI RtlAddAccessAllowedAce(
     689        IN OUT PACL pAcl,
     690        IN DWORD dwAceRevision,
     691        IN DWORD AccessMask,
     692        IN PSID pSid);
     693
     694BOOL WINAPI AddAccessAllowedAceEx(
     695        IN OUT PACL pAcl,
     696        IN DWORD dwAceRevision,
     697        IN DWORD AceFlags,
     698        IN DWORD AccessMask,
     699        IN PSID pSid);
     700
     701DWORD WINAPI RtlGetAce(
     702        PACL pAcl,
     703        DWORD dwAceIndex,
     704        LPVOID *pAce );
     705
     706/*      string functions */
     707
     708DWORD       WINAPI RtlAnsiStringToUnicodeSize(const STRING*);
     709NTSTATUS    WINAPI RtlAnsiStringToUnicodeString(UNICODE_STRING*,const STRING *,BOOLEAN);
     710NTSTATUS    WINAPI RtlAppendAsciizToString(STRING*,LPCSTR);
     711NTSTATUS    WINAPI RtlAppendStringToString(STRING*,const STRING*);
     712NTSTATUS    WINAPI RtlAppendUnicodeStringToString(UNICODE_STRING*,const UNICODE_STRING*);
     713NTSTATUS    WINAPI RtlAppendUnicodeToString(UNICODE_STRING*,LPCWSTR);
     714LONG        WINAPI RtlCompareString(const STRING*,const STRING*,BOOLEAN);
     715LONG        WINAPI RtlCompareUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
     716void        WINAPI RtlCopyString(STRING*,const STRING*);
     717void        WINAPI RtlCopyUnicodeString(UNICODE_STRING*,const UNICODE_STRING*);
     718BOOLEAN     WINAPI RtlCreateUnicodeString(PUNICODE_STRING,LPCWSTR);
     719BOOLEAN     WINAPI RtlCreateUnicodeStringFromAsciiz(PUNICODE_STRING,LPCSTR);
     720void        WINAPI RtlEraseUnicodeString(UNICODE_STRING*);
     721BOOLEAN     WINAPI RtlEqualString(const STRING*,const STRING*,BOOLEAN);
     722BOOLEAN     WINAPI RtlEqualUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
     723void        WINAPI RtlFreeAnsiString(PSTRING);
     724void        WINAPI RtlFreeOemString(PSTRING);
     725void        WINAPI RtlFreeUnicodeString(PUNICODE_STRING);
     726void        WINAPI RtlInitAnsiString(PSTRING,LPCSTR);
     727void        WINAPI RtlInitString(PSTRING,LPCSTR);
     728void        WINAPI RtlInitUnicodeString(PUNICODE_STRING,LPCWSTR);
     729NTSTATUS    WINAPI RtlMultiByteToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
     730NTSTATUS    WINAPI RtlMultiByteToUnicodeSize(DWORD*,LPCSTR,UINT);
     731UINT        WINAPI RtlOemStringToUnicodeSize(const STRING*);
     732NTSTATUS    WINAPI RtlOemStringToUnicodeString(UNICODE_STRING*,const STRING*,BOOLEAN);
     733NTSTATUS    WINAPI RtlOemToUnicodeN(LPWSTR,DWORD,LPDWORD,LPCSTR,DWORD);
     734BOOLEAN     WINAPI RtlPrefixString(const STRING*,const STRING*,BOOLEAN);
     735BOOLEAN     WINAPI RtlPrefixUnicodeString(const UNICODE_STRING*,const UNICODE_STRING*,BOOLEAN);
     736DWORD       WINAPI RtlUnicodeStringToAnsiSize(const UNICODE_STRING*);
     737NTSTATUS    WINAPI RtlUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
     738DWORD       WINAPI RtlUnicodeStringToOemSize(const UNICODE_STRING*);
     739NTSTATUS    WINAPI RtlUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
     740NTSTATUS    WINAPI RtlUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
     741NTSTATUS    WINAPI RtlUnicodeToMultiByteSize(DWORD*,LPCWSTR,UINT);
     742NTSTATUS    WINAPI RtlUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
     743NTSTATUS    WINAPI RtlUpcaseUnicodeString(UNICODE_STRING*,const UNICODE_STRING *,BOOLEAN);
     744NTSTATUS    WINAPI RtlUpcaseUnicodeStringToAnsiString(STRING*,const UNICODE_STRING*,BOOLEAN);
     745NTSTATUS    WINAPI RtlUpcaseUnicodeStringToOemString(STRING*,const UNICODE_STRING*,BOOLEAN);
     746NTSTATUS    WINAPI RtlUpcaseUnicodeToMultiByteN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
     747NTSTATUS    WINAPI RtlUpcaseUnicodeToOemN(LPSTR,DWORD,LPDWORD,LPCWSTR,DWORD);
     748
     749DWORD WINAPI RtlIsTextUnicode(
     750        LPVOID buf,
     751        DWORD len,
     752        DWORD *pf);
     753
     754INT __cdecl wcstol(LPCWSTR,LPWSTR*,INT);
     755
     756/*      resource functions */
    523757
    524758typedef struct _RTL_RWLOCK {
    … …  
    552786        LPRTL_RWLOCK);
    553787
    554 /*
    555         time functions
    556  */
     788/*      time functions */
    557789
    558790typedef struct _TIME_FIELDS
    … …  
    585817        PTIME_FIELDS TimeFields);
    586818       
    587 BOOLEAN WINAPI RtlTimeToSecondsSince1980(
    588         LPFILETIME ft,
    589         LPDWORD timeret);
    590 
    591 BOOLEAN WINAPI RtlTimeToSecondsSince1970(
    592         LPFILETIME ft,
    593         LPDWORD timeret);
    594 
    595 /*
    596         heap functions
    597 */
     819void    WINAPI NtQuerySystemTime( LARGE_INTEGER *time );
     820
     821BOOLEAN WINAPI RtlTimeToSecondsSince1980( const FILETIME *time, LPDWORD res );
     822BOOLEAN WINAPI RtlTimeToSecondsSince1970( const FILETIME *time, LPDWORD res );
     823void    WINAPI RtlSecondsSince1970ToTime( DWORD time, FILETIME *res );
     824void    WINAPI RtlSecondsSince1980ToTime( DWORD time, FILETIME *res );
     825
     826/*      heap functions */
    598827
    599828/* Data structure for heap definition. This includes various
    … …  
    606835} RTL_HEAP_DEFINITION, *PRTL_HEAP_DEFINITION;
    607836
    608 HANDLE WINAPI RtlCreateHeap(
    609         ULONG Flags,
    610         PVOID BaseAddress,
    611         ULONG SizeToReserve,
    612         ULONG SizeToCommit,
    613         PVOID Unknown,
    614         PRTL_HEAP_DEFINITION Definition);
    615 
    616 PVOID WINAPI RtlAllocateHeap(
    617         HANDLE Heap,
    618         ULONG Flags,
    619         ULONG Size);
    620 
    621 
    622 BOOLEAN WINAPI RtlFreeHeap(
    623         HANDLE Heap,
    624         ULONG Flags,
    625         PVOID Address);
    626 
    627 /*
    628  *      misc
    629  */
    630 void WINAPIV DbgPrint(LPCSTR fmt, ...);
    631 void WINAPI NtRaiseException(PEXCEPTION_RECORD,PCONTEXT,BOOL);
    632 void WINAPI RtlRaiseException(PEXCEPTION_RECORD);
    633 void WINAPI RtlRaiseStatus(NTSTATUS);
    634 void WINAPI RtlUnwind(PEXCEPTION_FRAME,LPVOID,PEXCEPTION_RECORD,DWORD);
     837HANDLE    WINAPI RtlCreateHeap(ULONG,PVOID,ULONG,ULONG,PVOID,PRTL_HEAP_DEFINITION);
     838HANDLE    WINAPI RtlDestroyHeap(HANDLE);
     839PVOID     WINAPI RtlAllocateHeap(HANDLE,ULONG,ULONG);
     840BOOLEAN   WINAPI RtlFreeHeap(HANDLE,ULONG,PVOID);
     841PVOID     WINAPI RtlReAllocateHeap(HANDLE,ULONG,PVOID,ULONG);
     842ULONG     WINAPI RtlCompactHeap(HANDLE,ULONG);
     843BOOLEAN   WINAPI RtlLockHeap(HANDLE);
     844BOOLEAN   WINAPI RtlUnlockHeap(HANDLE);
     845ULONG     WINAPI RtlSizeHeap(HANDLE,ULONG,PVOID);
     846BOOLEAN   WINAPI RtlValidateHeap(HANDLE,ULONG,PCVOID);
     847ULONG     WINAPI RtlGetProcessHeaps(ULONG,HANDLE*);
     848NTSTATUS  WINAPI RtlWalkHeap(HANDLE,PVOID);
     849
     850/*      exception */
     851
     852void WINAPI NtRaiseException(
     853        PEXCEPTION_RECORD,PCONTEXT,BOOL);
     854
     855void WINAPI RtlRaiseException(
     856        PEXCEPTION_RECORD);
     857
     858void WINAPI RtlRaiseStatus(
     859        NTSTATUS);
     860
     861void WINAPI RtlUnwind(
     862        PEXCEPTION_FRAME,
     863        LPVOID,
     864        PEXCEPTION_RECORD,DWORD);
     865
     866/*      process environment block  */
    635867VOID WINAPI RtlAcquirePebLock(void);
    636868VOID WINAPI RtlReleasePebLock(void);
     869
     870/*      mathematics */
     871LONGLONG  WINAPI RtlConvertLongToLargeInteger( LONG a );
     872LONGLONG  WINAPI RtlEnlargedIntegerMultiply( INT a, INT b );
     873LONGLONG  WINAPI RtlExtendedMagicDivide( LONGLONG a, LONGLONG b, INT shift );
     874LONGLONG  WINAPI RtlExtendedIntegerMultiply( LONGLONG a, INT b );
     875LONGLONG  WINAPI RtlExtendedLargeIntegerDivide( LONGLONG a, INT b, INT *rem );
     876LONGLONG  WINAPI RtlLargeIntegerAdd( LONGLONG a, LONGLONG b );
     877LONGLONG  WINAPI RtlLargeIntegerArithmeticShift( LONGLONG a, INT count );
     878LONGLONG  WINAPI RtlLargeIntegerNegate( LONGLONG a );
     879LONGLONG  WINAPI RtlLargeIntegerShiftLeft( LONGLONG a, INT count );
     880LONGLONG  WINAPI RtlLargeIntegerShiftRight( LONGLONG a, INT count );
     881LONGLONG  WINAPI RtlLargeIntegerSubtract( LONGLONG a, LONGLONG b );
     882ULONGLONG WINAPI RtlEnlargedUnsignedMultiply( UINT a, UINT b );
     883UINT      WINAPI RtlEnlargedUnsignedDivide( ULONGLONG a, UINT b, UINT *remptr );
     884ULONGLONG WINAPI RtlConvertUlongToLargeInteger( ULONG a );
     885ULONGLONG WINAPI RtlLargeIntegerDivide( ULONGLONG a, ULONGLONG b, ULONGLONG *rem );
     886
     887/*      environment */
     888DWORD WINAPI RtlCreateEnvironment(
     889        DWORD x1,
     890        DWORD x2);
     891
     892DWORD WINAPI RtlDestroyEnvironment(
     893        DWORD x);
     894
     895DWORD WINAPI RtlQueryEnvironmentVariable_U(
     896        DWORD x1,
     897        PUNICODE_STRING key,
     898        PUNICODE_STRING val) ;
     899
     900DWORD WINAPI RtlSetEnvironmentVariable(
     901        DWORD x1,
     902        PUNICODE_STRING key,
     903        PUNICODE_STRING val);
     904
     905/*      object security */
     906
     907DWORD WINAPI RtlNewSecurityObject(
     908        DWORD x1,
     909        DWORD x2,
     910        DWORD x3,
     911        DWORD x4,
     912        DWORD x5,
     913        DWORD x6);
     914
     915DWORD WINAPI RtlDeleteSecurityObject(
     916        DWORD x1);
     917       
     918NTSTATUS WINAPI
     919NtQuerySecurityObject(
     920        IN HANDLE Object,
     921        IN SECURITY_INFORMATION RequestedInformation,
     922        OUT PSECURITY_DESCRIPTOR pSecurityDesriptor,
     923        IN ULONG Length,
     924        OUT PULONG ResultLength);
     925
     926NTSTATUS WINAPI
     927NtSetSecurityObject(
     928        IN HANDLE Handle,
     929        IN SECURITY_INFORMATION SecurityInformation,
     930        IN PSECURITY_DESCRIPTOR SecurityDescriptor);
     931
     932/*      registry functions */
     933
     934NTSTATUS    WINAPI NtCreateKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,
     935                               const UNICODE_STRING*,ULONG,PULONG);
     936NTSTATUS    WINAPI NtDeleteKey(HANDLE);
     937NTSTATUS    WINAPI NtDeleteValueKey(HANDLE,const UNICODE_STRING*);
     938NTSTATUS    WINAPI NtOpenKey(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*);
     939NTSTATUS    WINAPI NtQueryKey(HANDLE,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
     940NTSTATUS    WINAPI NtSetValueKey(HANDLE,const UNICODE_STRING*,ULONG,ULONG,const void*,ULONG);
     941NTSTATUS    WINAPI NtEnumerateKey(HANDLE,ULONG,KEY_INFORMATION_CLASS,void*,DWORD,DWORD*);
     942NTSTATUS    WINAPI NtQueryValueKey(HANDLE,const UNICODE_STRING*,KEY_VALUE_INFORMATION_CLASS,
     943                                   void*,DWORD,DWORD*);
     944NTSTATUS    WINAPI NtLoadKey(const OBJECT_ATTRIBUTES*,const OBJECT_ATTRIBUTES*);
     945
     946
     947NTSTATUS WINAPI NtEnumerateValueKey(
     948        HANDLE KeyHandle,
     949        ULONG Index,
     950        KEY_VALUE_INFORMATION_CLASS KeyInformationClass,
     951        PVOID KeyInformation,
     952        ULONG Length,
     953        PULONG ResultLength);
     954
     955NTSTATUS WINAPI NtFlushKey(HANDLE KeyHandle);
     956
     957NTSTATUS WINAPI NtNotifyChangeKey(
     958        IN HANDLE KeyHandle,
     959        IN HANDLE Event,
     960        IN PIO_APC_ROUTINE ApcRoutine OPTIONAL,
     961        IN PVOID ApcContext OPTIONAL,
     962        OUT PIO_STATUS_BLOCK IoStatusBlock,
     963        IN ULONG CompletionFilter,
     964        IN BOOLEAN Asynchroneous,
     965        OUT PVOID ChangeBuffer,
     966        IN ULONG Length,
     967        IN BOOLEAN WatchSubtree);
     968
     969NTSTATUS WINAPI NtQueryMultipleValueKey(
     970        HANDLE KeyHandle,
     971        PVALENTW ListOfValuesToQuery,
     972        ULONG NumberOfItems,
     973        PVOID MultipleValueInformation,
     974        ULONG Length,
     975        PULONG  ReturnLength);
     976
     977NTSTATUS WINAPI NtReplaceKey(
     978        IN POBJECT_ATTRIBUTES ObjectAttributes,
     979        IN HANDLE Key,
     980        IN POBJECT_ATTRIBUTES ReplacedObjectAttributes);
     981
     982NTSTATUS WINAPI NtRestoreKey(
     983        HANDLE KeyHandle,
     984        HANDLE FileHandle,
     985        ULONG RestoreFlags);
     986
     987NTSTATUS WINAPI NtSaveKey(
     988        IN HANDLE KeyHandle,
     989        IN HANDLE FileHandle);
     990
     991NTSTATUS WINAPI NtSetInformationKey(
     992        IN HANDLE KeyHandle,
     993        IN const int KeyInformationClass,
     994        IN PVOID KeyInformation,
     995        IN ULONG KeyInformationLength);
     996
     997NTSTATUS WINAPI NtUnloadKey(
     998        IN HANDLE KeyHandle);
     999
     1000NTSTATUS WINAPI NtClose(
     1001        HANDLE Handle);
     1002
     1003NTSTATUS WINAPI NtTerminateProcess( HANDLE handle, LONG exit_code );
     1004NTSTATUS WINAPI NtTerminateThread( HANDLE handle, LONG exit_code );
     1005
     1006NTSTATUS WINAPI NtClearEvent(HANDLE);
     1007NTSTATUS WINAPI NtCreateEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *,BOOLEAN,BOOLEAN);
     1008NTSTATUS WINAPI NtCreateSemaphore(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES*,ULONG,ULONG);
     1009NTSTATUS WINAPI NtOpenEvent(PHANDLE,ACCESS_MASK,const OBJECT_ATTRIBUTES *attr);
     1010NTSTATUS WINAPI NtPulseEvent(HANDLE,PULONG);
     1011NTSTATUS WINAPI NtReleaseSemaphore(HANDLE,ULONG,PULONG);
     1012NTSTATUS WINAPI NtResetEvent(HANDLE,PULONG);
     1013NTSTATUS WINAPI NtSetEvent(HANDLE,PULONG);
     1014
     1015NTSTATUS WINAPI RtlInitializeCriticalSection( RTL_CRITICAL_SECTION *crit );
     1016NTSTATUS WINAPI RtlInitializeCriticalSectionAndSpinCount( RTL_CRITICAL_SECTION *crit, DWORD spincount );
     1017NTSTATUS WINAPI RtlDeleteCriticalSection( RTL_CRITICAL_SECTION *crit );
     1018NTSTATUS WINAPI RtlpWaitForCriticalSection( RTL_CRITICAL_SECTION *crit );
     1019NTSTATUS WINAPI RtlpUnWaitCriticalSection( RTL_CRITICAL_SECTION *crit );
     1020NTSTATUS WINAPI RtlEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
     1021BOOL     WINAPI RtlTryEnterCriticalSection( RTL_CRITICAL_SECTION *crit );
     1022NTSTATUS WINAPI RtlLeaveCriticalSection( RTL_CRITICAL_SECTION *crit );
     1023
     1024/* string functions */
     1025extern LPSTR _strlwr( LPSTR str );
     1026extern LPSTR _strupr( LPSTR str );
     1027
     1028/*      misc */
     1029
     1030#if defined(__i386__) && defined(__GNUC__)
     1031static inline void WINAPI DbgBreakPoint(void) { __asm__ __volatile__("int3"); }
     1032static inline void WINAPI DbgUserBreakPoint(void) { __asm__ __volatile__("int3"); }
     1033#else  /* __i386__ && __GNUC__ */
     1034void WINAPI DbgBreakPoint(void);
     1035void WINAPI DbgUserBreakPoint(void);
     1036#endif  /* __i386__ && __GNUC__ */
     1037void WINAPIV DbgPrint(LPCSTR fmt, ...);
     1038
    6371039DWORD WINAPI RtlAdjustPrivilege(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
    6381040DWORD WINAPI RtlIntegerToChar(DWORD x1,DWORD x2,DWORD x3,DWORD x4);
    639 DWORD WINAPI RtlSetEnvironmentVariable(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val);
    640 DWORD WINAPI RtlNewSecurityObject(DWORD x1,DWORD x2,DWORD x3,DWORD x4,DWORD x5,DWORD x6);
    641 DWORD WINAPI RtlDeleteSecurityObject(DWORD x1);
    6421041LPVOID WINAPI RtlNormalizeProcessParams(LPVOID x);
    6431042DWORD WINAPI RtlNtStatusToDosError(DWORD error);
    6441043BOOLEAN WINAPI RtlGetNtProductType(LPDWORD type);
    645 LONGLONG WINAPI RtlExtendedLargeIntegerDivide(LONGLONG dividend, INT divisor, INT *rest);
    646 LONGLONG WINAPI RtlExtendedIntegerMultiply(LONGLONG factor1,INT factor2);
    647 DWORD WINAPI RtlFormatCurrentUserKeyPath(PUNICODE_STRING String);
    648 DWORD WINAPI RtlOpenCurrentUser(DWORD x1, DWORD *x2);
     1044PIMAGE_NT_HEADERS WINAPI RtlImageNtHeader(HMODULE hModule);
     1045
     1046DWORD WINAPI RtlOpenCurrentUser(
     1047        IN ACCESS_MASK DesiredAccess,
     1048        OUT PHANDLE KeyHandle);
     1049
    6491050BOOLEAN WINAPI RtlDosPathNameToNtPathName_U( LPWSTR from,PUNICODE_STRING us,DWORD x2,DWORD x3);
    650 DWORD WINAPI RtlCreateEnvironment(DWORD x1,DWORD x2);
    651 DWORD WINAPI RtlDestroyEnvironment(DWORD x);
    652 DWORD WINAPI RtlQueryEnvironmentVariable_U(DWORD x1,PUNICODE_STRING key,PUNICODE_STRING val) ;
    653 
    654 BOOL WINAPI IsValidSid(PSID);
    655 BOOL WINAPI EqualSid(PSID,PSID);
    656 BOOL WINAPI EqualPrefixSid(PSID,PSID);
    657 DWORD  WINAPI GetSidLengthRequired(BYTE);
    658 BOOL WINAPI AllocateAndInitializeSid(PSID_IDENTIFIER_AUTHORITY,BYTE,DWORD,
    659                                        DWORD,DWORD,DWORD,DWORD,DWORD,DWORD,
    660                                        DWORD,PSID*);
    661 VOID*  WINAPI FreeSid(PSID);
    662 BOOL WINAPI InitializeSecurityDescriptor(SECURITY_DESCRIPTOR*,DWORD);
    663 BOOL WINAPI InitializeSid(PSID,PSID_IDENTIFIER_AUTHORITY,BYTE);
    664 DWORD* WINAPI GetSidSubAuthority(PSID,DWORD);
    665 BYTE * WINAPI GetSidSubAuthorityCount(PSID);
    666 DWORD  WINAPI GetLengthSid(PSID);
    667 BOOL WINAPI CopySid(DWORD,PSID,PSID);
    668 BOOL WINAPI LookupAccountSidA(LPCSTR,PSID,LPSTR,LPDWORD,LPSTR,LPDWORD,
    669                                   PSID_NAME_USE);
    670 BOOL WINAPI LookupAccountSidW(LPCWSTR,PSID,LPWSTR,LPDWORD,LPWSTR,LPDWORD,
    671                                   PSID_NAME_USE);
    672 PSID_IDENTIFIER_AUTHORITY WINAPI GetSidIdentifierAuthority(PSID);
     1051BOOL WINAPI RtlImpersonateSelf(SECURITY_IMPERSONATION_LEVEL ImpersonationLevel);
     1052
     1053NTSTATUS WINAPI
     1054NtAccessCheck(
     1055        IN PSECURITY_DESCRIPTOR SecurityDescriptor,
     1056        IN HANDLE ClientToken,
     1057        IN ACCESS_MASK DesiredAccess,
     1058        IN PGENERIC_MAPPING GenericMapping,
     1059        OUT PPRIVILEGE_SET PrivilegeSet,
     1060        OUT PULONG ReturnLength,
     1061        OUT PULONG GrantedAccess,
     1062        OUT PBOOLEAN AccessStatus);
    6731063
    6741064#ifdef __cplusplus
Note: See TracChangeset for help on using the changeset viewer.